Minor improvements

4 files changed, 95 insertions, 94 deletions

diff --git a/Doc/Manual/Javascript.html b/Doc/Manual/Javascript.html
index 3b861be0f..aaef6ab17 100644
--- a/Doc/Manual/Javascript.html
+++ b/Doc/Manual/Javascript.html
@@ -457,7 +457,7 @@ var x = 42;
 var y = 105;
 var g = example.gcd(x,y);
 
-// Accessing the globak variable
+// Accessing the global variable
 var f = example.Foo;
 example.Foo = 3.1415926;</pre>
 </div>
diff --git a/Lib/javascript/v8/javascriptcode.swg b/Lib/javascript/v8/javascriptcode.swg
index 840d45bfb..d99546aff 100644
--- a/Lib/javascript/v8/javascriptcode.swg
+++ b/Lib/javascript/v8/javascriptcode.swg
@@ -8,7 +8,7 @@
  * ----------------------------------------------------------------------------- */
 
 %fragment("js_ctor", "templates") %{
-SwigV8ReturnValue $jswrapper(const SwigV8Arguments& args) {
+SwigV8ReturnValue $jswrapper(const SwigV8Arguments &args) {
   SWIGV8_HANDLESCOPE();
   
   v8::Handle<v8::Object> self = args.Holder();
@@ -32,7 +32,7 @@ fail:
  * ----------------------------------------------------------------------------- */
 %fragment ("js_veto_ctor", "templates")
 %{
-SwigV8ReturnValue $jswrapper(const SwigV8Arguments& args) {
+SwigV8ReturnValue $jswrapper(const SwigV8Arguments &args) {
   SWIGV8_HANDLESCOPE();
   
   SWIG_exception(SWIG_ERROR, "Class $jsname can not be instantiated");
@@ -48,7 +48,7 @@ SwigV8ReturnValue $jswrapper(const SwigV8Arguments& args) {
  * ----------------------------------------------------------------------------- */
 %fragment ("js_ctor_dispatcher", "templates")
 %{
-SwigV8ReturnValue $jswrapper(const SwigV8Arguments& args) {
+SwigV8ReturnValue $jswrapper(const SwigV8Arguments &args) {
   SWIGV8_HANDLESCOPE();
   
   OverloadErrorHandler errorHandler;
@@ -74,7 +74,7 @@ fail:
  *   - $jsmangledtype:    mangled type of class
  * ----------------------------------------------------------------------------- */
 %fragment("js_overloaded_ctor", "templates") %{
-SwigV8ReturnValue $jswrapper(const SwigV8Arguments& args, V8ErrorHandler& SWIGV8_ErrorHandler) {
+SwigV8ReturnValue $jswrapper(const SwigV8Arguments &args, V8ErrorHandler &SWIGV8_ErrorHandler) {
   SWIGV8_HANDLESCOPE();
   
   v8::Handle<v8::Object> self = args.Holder();
@@ -128,10 +128,10 @@ fail:
 void $jswrapper(v8::Persistent< v8::Value > object, void *parameter) {
   SWIGV8_Proxy *proxy = static_cast<SWIGV8_Proxy *>(parameter);
 #elif (SWIG_V8_VERSION < 0x031900)
-void $jswrapper(v8::Isolate *isolate, v8::Persistent< v8::Value > object, void *parameter) {
+void $jswrapper(v8::Isolate *isolate, v8::Persistent<v8::Value> object, void *parameter) {
   SWIGV8_Proxy *proxy = static_cast<SWIGV8_Proxy *>(parameter);
-#elif (SWIG_V8_VERSION < SWIG_SETWEAK_VERSION)
-void $jswrapper(v8::Isolate *isolate, v8::Persistent< v8::Object > * object, SWIGV8_Proxy *proxy) {
+#elif (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
+void $jswrapper(v8::Isolate *isolate, v8::Persistent<v8::Object> *object, SWIGV8_Proxy *proxy) {
 #else
 void $jswrapper(const v8::WeakCallbackData<v8::Object, SWIGV8_Proxy> &data) {
   v8::Local<v8::Object> object = data.GetValue();
@@ -169,13 +169,13 @@ void $jswrapper(const v8::WeakCallbackData<v8::Object, SWIGV8_Proxy> &data) {
 %fragment ("js_dtoroverride", "templates")
 %{
 #if (SWIG_V8_VERSION < 0x031710)
-void $jswrapper(v8::Persistent< v8::Value > object, void *parameter) {
+void $jswrapper(v8::Persistent<v8::Value> object, void *parameter) {
   SWIGV8_Proxy *proxy = static_cast<SWIGV8_Proxy *>(parameter);
 #elif (SWIG_V8_VERSION < 0x031900)
-void $jswrapper(v8::Isolate *isolate, v8::Persistent< v8::Value > object, void *parameter) {
+void $jswrapper(v8::Isolate *isolate, v8::Persistent<v8::Value> object, void *parameter) {
   SWIGV8_Proxy *proxy = static_cast<SWIGV8_Proxy *>(parameter);
-#elif (SWIG_V8_VERSION < SWIG_SETWEAK_VERSION)
-void $jswrapper(v8::Isolate *isolate, v8::Persistent< v8::Object > * object, SWIGV8_Proxy *proxy) {
+#elif (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
+void $jswrapper(v8::Isolate *isolate, v8::Persistent< v8::Object> *object, SWIGV8_Proxy *proxy) {
 #else
 void $jswrapper(const v8::WeakCallbackData<v8::Object, SWIGV8_Proxy> &data) {
   v8::Local<v8::Object> object = data.GetValue();
@@ -194,7 +194,7 @@ void $jswrapper(const v8::WeakCallbackData<v8::Object, SWIGV8_Proxy> &data) {
   object.Dispose(isolate);
 #elif (SWIG_V8_VERSION < 0x032100)
   object->Dispose(isolate);
-#elif (SWIG_V8_VERSION < SWIG_SETWEAK_VERSION)
+#elif (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
   object->Dispose();
 #else
   object.Clear();
@@ -210,7 +210,7 @@ void $jswrapper(const v8::WeakCallbackData<v8::Object, SWIGV8_Proxy> &data) {
  * ----------------------------------------------------------------------------- */
 %fragment("js_getter", "templates")
 %{
-SwigV8ReturnValue $jswrapper(v8::Local<v8::String> property, const SwigV8PropertyCallbackInfo& info) {
+SwigV8ReturnValue $jswrapper(v8::Local<v8::String> property, const SwigV8PropertyCallbackInfo &info) {
   SWIGV8_HANDLESCOPE();
   
   v8::Handle<v8::Value> jsresult;
@@ -233,7 +233,7 @@ fail:
 %fragment("js_setter", "templates")
 %{
 void $jswrapper(v8::Local<v8::String> property, v8::Local<v8::Value> value,
-  const SwigV8PropertyCallbackInfoVoid& info) {
+  const SwigV8PropertyCallbackInfoVoid &info) {
   SWIGV8_HANDLESCOPE();
   
   $jslocals
@@ -252,7 +252,7 @@ fail:
  * ----------------------------------------------------------------------------- */
 %fragment("js_function", "templates")
 %{
-SwigV8ReturnValue $jswrapper(const SwigV8Arguments& args) {
+SwigV8ReturnValue $jswrapper(const SwigV8Arguments &args) {
   SWIGV8_HANDLESCOPE();
   
   v8::Handle<v8::Value> jsresult;
@@ -277,7 +277,7 @@ fail:
  * ----------------------------------------------------------------------------- */
 %fragment("js_function_dispatcher", "templates")
 %{
-SwigV8ReturnValue $jswrapper(const SwigV8Arguments& args) {
+SwigV8ReturnValue $jswrapper(const SwigV8Arguments &args) {
   SWIGV8_HANDLESCOPE();
   
   v8::Handle<v8::Value> jsresult;
@@ -300,7 +300,7 @@ fail:
  * ----------------------------------------------------------------------------- */
 %fragment ("js_overloaded_function", "templates")
 %{
-SwigV8ReturnValue $jswrapper(const SwigV8Arguments& args, V8ErrorHandler& SWIGV8_ErrorHandler)
+SwigV8ReturnValue $jswrapper(const SwigV8Arguments &args, V8ErrorHandler &SWIGV8_ErrorHandler)
 {
   SWIGV8_HANDLESCOPE();
   
diff --git a/Lib/javascript/v8/javascriptrun.swg b/Lib/javascript/v8/javascriptrun.swg
index 15e5d2ecd..d4d636c8c 100644
--- a/Lib/javascript/v8/javascriptrun.swg
+++ b/Lib/javascript/v8/javascriptrun.swg
@@ -3,7 +3,15 @@
  *
  * ---------------------------------------------------------------------------*/
 
-#define SWIG_SETWEAK_VERSION 0x032224
+// First v8 version that uses "SetWeak" and not "MakeWeak"
+
+#define SWIGV8_SETWEAK_VERSION 0x032224
+
+#if (SWIG_V8_VERSION < 0x031803)
+#define SWIGV8_STRING_NEW2(cstr, len) v8::String::New(cstr, len)
+#else
+#define SWIGV8_STRING_NEW2(cstr, len) v8::String::NewFromUtf8(v8::Isolate::GetCurrent(), cstr, v8::String::kNormalString, len)
+#endif
 
 #if (SWIG_V8_VERSION < 0x031903)
 typedef v8::Handle<v8::Value> SwigV8ReturnValue;
@@ -34,54 +42,47 @@ typedef v8::PropertyCallbackInfo<v8::Value> SwigV8PropertyCallbackInfo;
 #endif
 
 #if (SWIG_V8_VERSION < 0x032224)
-#define SWIGV8_STRING_NEW(str) v8::String::New(str)
-#define SWIGV8_CURRENT_CONTEXT() v8::Context::GetCurrent()
-#define SWIGV8_SYMBOL_NEW(sym) v8::String::NewSymbol(sym)
 #define SWIGV8_ADJUST_MEMORY(size) v8::V8::AdjustAmountOfExternalAllocatedMemory(size)
+#define SWIGV8_CURRENT_CONTEXT() v8::Context::GetCurrent()
 #define SWIGV8_THROW_EXCEPTION(err) v8::ThrowException(err)
+#define SWIGV8_STRING_NEW(str) v8::String::New(str)
+#define SWIGV8_SYMBOL_NEW(sym) v8::String::NewSymbol(sym)
 #else
-#define SWIGV8_THROW_EXCEPTION(err) v8::Isolate::GetCurrent()->ThrowException(err)
 #define SWIGV8_ADJUST_MEMORY(size) v8::Isolate::GetCurrent()->AdjustAmountOfExternalAllocatedMemory(size)
-#define SWIGV8_STRING_NEW(str) v8::String::NewFromUtf8(v8::Isolate::GetCurrent(), str)
 #define SWIGV8_CURRENT_CONTEXT() v8::Isolate::GetCurrent()->GetCurrentContext()
+#define SWIGV8_THROW_EXCEPTION(err) v8::Isolate::GetCurrent()->ThrowException(err)
+#define SWIGV8_STRING_NEW(str) v8::String::NewFromUtf8(v8::Isolate::GetCurrent(), str)
 #define SWIGV8_SYMBOL_NEW(sym) v8::String::NewFromUtf8(v8::Isolate::GetCurrent(), sym)
 #endif
 
-#if (SWIG_V8_VERSION < 0x031803)
-#define SWIGV8_STRING_NEW2(cstr, len) v8::String::New(cstr, len)
-#else
-#define SWIGV8_STRING_NEW2(cstr, len) v8::String::NewFromUtf8(v8::Isolate::GetCurrent(), cstr, v8::String::kNormalString, len)
-#endif
-
 #if (SWIG_V8_VERSION < 0x032318)
+#define SWIGV8_ARRAY_NEW() v8::Array::New()
+#define SWIGV8_BOOLEAN_NEW(bool) v8::Boolean::New(bool)
+#define SWIGV8_EXTERNAL_NEW(val) v8::External::New(val)
 #define SWIGV8_FUNCTEMPLATE_NEW(func) v8::FunctionTemplate::New(func)
 #define SWIGV8_FUNCTEMPLATE_NEW_VOID() v8::FunctionTemplate::New()
+#define SWIGV8_INT32_NEW(num) v8::Int32::New(num)
+#define SWIGV8_INTEGER_NEW(num) v8::Integer::New(num)
+#define SWIGV8_INTEGER_NEW_UNS(num) v8::Integer::NewFromUnsigned(num)
+#define SWIGV8_NUMBER_NEW(num) v8::Number::New(num)
 #define SWIGV8_OBJECT_NEW() v8::Object::New()
-#define SWIGV8_EXTERNAL_NEW(val) v8::External::New(val)
 #define SWIGV8_UNDEFINED() v8::Undefined()
 #define SWIGV8_NULL() v8::Null()
-#define SWIGV8_BOOLEAN_NEW(bool) v8::Boolean::New(bool)
-#define SWIGV8_ARRAY_NEW() v8::Array::New()
-#define SWIGV8_NUMBER_NEW(num) v8::Number::New(num)
-#define SWIGV8_INTEGER_NEW(num) v8::Integer::New(num)
-#define SWIGV8_INTEGER_NEW_UNS(num) v8::Integer::NewFromUnsigned(num)
-#define SWIGV8_INT32_NEW(num) v8::Int32::New(num)
 #else
+#define SWIGV8_ARRAY_NEW() v8::Array::New(v8::Isolate::GetCurrent())
+#define SWIGV8_BOOLEAN_NEW(bool) v8::Boolean::New(v8::Isolate::GetCurrent(), bool)
+#define SWIGV8_EXTERNAL_NEW(val) v8::External::New(v8::Isolate::GetCurrent(), val)
 #define SWIGV8_FUNCTEMPLATE_NEW(func) v8::FunctionTemplate::New(v8::Isolate::GetCurrent(), func)
 #define SWIGV8_FUNCTEMPLATE_NEW_VOID() v8::FunctionTemplate::New(v8::Isolate::GetCurrent())
+#define SWIGV8_INT32_NEW(num) v8::Int32::New(v8::Isolate::GetCurrent(), num)
+#define SWIGV8_INTEGER_NEW(num) v8::Integer::New(v8::Isolate::GetCurrent(), num)
+#define SWIGV8_INTEGER_NEW_UNS(num) v8::Integer::NewFromUnsigned(v8::Isolate::GetCurrent(), num)
+#define SWIGV8_NUMBER_NEW(num) v8::Number::New(v8::Isolate::GetCurrent(), num)
 #define SWIGV8_OBJECT_NEW() v8::Object::New(v8::Isolate::GetCurrent())
-#define SWIGV8_EXTERNAL_NEW(val) v8::External::New(v8::Isolate::GetCurrent(), val)
 #define SWIGV8_UNDEFINED() v8::Undefined(v8::Isolate::GetCurrent())
 #define SWIGV8_NULL() v8::Null(v8::Isolate::GetCurrent())
-#define SWIGV8_BOOLEAN_NEW(bool) v8::Boolean::New(v8::Isolate::GetCurrent(), bool)
-#define SWIGV8_ARRAY_NEW() v8::Array::New(v8::Isolate::GetCurrent())
-#define SWIGV8_NUMBER_NEW(num) v8::Number::New(v8::Isolate::GetCurrent(), num)
-#define SWIGV8_INTEGER_NEW(num) v8::Integer::New(v8::Isolate::GetCurrent(), num)
-#define SWIGV8_INTEGER_NEW_UNS(num) v8::Integer::NewFromUnsigned(v8::Isolate::GetCurrent(), num)
-#define SWIGV8_INT32_NEW(num) v8::Int32::New(v8::Isolate::GetCurrent(), num)
 #endif
 
-
 /* ---------------------------------------------------------------------------
  * Error handling
  *
@@ -92,7 +93,7 @@ typedef v8::PropertyCallbackInfo<v8::Value> SwigV8PropertyCallbackInfo;
 #define SWIG_fail                 goto fail
 #define SWIGV8_OVERLOAD false
 
-void SWIG_V8_Raise(const char* msg) {
+void SWIG_V8_Raise(const char *msg) {
   SWIGV8_THROW_EXCEPTION(v8::Exception::Error(SWIGV8_STRING_NEW(msg)));
 }
 
@@ -112,7 +113,7 @@ void SWIG_V8_Raise(const char* msg) {
 class V8ErrorHandler {
 public:
   virtual ~V8ErrorHandler() {}
-  virtual void error(int code, const char* msg) {
+  virtual void error(int code, const char *msg) {
     SWIG_V8_Raise(msg);
   }
 };
@@ -122,7 +123,7 @@ V8ErrorHandler SWIGV8_ErrorHandler;
 // instances of this are used in overloaded functions
 class OverloadErrorHandler: public V8ErrorHandler {
 public:
-  virtual void error(int code, const char* msg) {
+  virtual void error(int code, const char *msg) {
     err = v8::Exception::Error(SWIGV8_STRING_NEW(msg));
     if(code != SWIG_TypeError) {
         SWIGV8_THROW_EXCEPTION(err);
@@ -153,7 +154,7 @@ public:
 #elif (SWIG_V8_VERSION < 0x032100)
     handle.ClearWeak(v8::Isolate::GetCurrent());
     handle.Dispose(v8::Isolate::GetCurrent());
-#elif (SWIG_V8_VERSION < SWIG_SETWEAK_VERSION)
+#elif (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
     handle.ClearWeak();
     handle.Dispose();
 #else    
@@ -161,7 +162,7 @@ public:
     handle.Reset();
 #endif
 
-#if (SWIG_V8_VERSION < SWIG_SETWEAK_VERSION)
+#if (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
     handle.Clear();
 #endif
 
@@ -182,7 +183,7 @@ public:
   void (*dtor) (v8::Persistent< v8::Value> object, void *parameter);
 #elif (SWIG_V8_VERSION < 0x031900)
   void (*dtor) (v8::Isolate *isolate, v8::Persistent< v8::Value> object, void *parameter);
-#elif (SWIG_V8_VERSION < SWIG_SETWEAK_VERSION)
+#elif (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
   void (*dtor) (v8::Isolate *isolate, v8::Persistent< v8::Object > *object, SWIGV8_Proxy *proxy);
 #else
   void (*dtor) (const v8::WeakCallbackData<v8::Object, SWIGV8_Proxy> &data);
@@ -191,7 +192,7 @@ public:
 
 v8::Persistent<v8::FunctionTemplate> SWIGV8_SWIGTYPE_Proxy_class_templ;
 
-int SWIG_V8_ConvertInstancePtr(v8::Handle<v8::Object> objRef, void** ptr, swig_type_info *info, int flags) {
+int SWIG_V8_ConvertInstancePtr(v8::Handle<v8::Object> objRef, void **ptr, swig_type_info *info, int flags) {
   SWIGV8_HANDLESCOPE();
 
   if(objRef->InternalFieldCount() < 1) return SWIG_ERROR;
@@ -230,7 +231,7 @@ void SWIGV8_Proxy_DefaultDtor(v8::Persistent< v8::Value > object, void *paramete
 #elif (SWIG_V8_VERSION < 0x031900)
 void SWIGV8_Proxy_DefaultDtor(v8::Isolate *, v8::Persistent< v8::Value > object, void *parameter) {
   SWIGV8_Proxy *proxy = static_cast<SWIGV8_Proxy *>(parameter);
-#elif (SWIG_V8_VERSION < SWIG_SETWEAK_VERSION)
+#elif (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
 void SWIGV8_Proxy_DefaultDtor(v8::Isolate *, v8::Persistent< v8::Object > *object, SWIGV8_Proxy *proxy) {
 #else
 void SWIGV8_Proxy_DefaultDtor(const v8::WeakCallbackData<v8::Object, SWIGV8_Proxy> &data) {
@@ -240,7 +241,7 @@ void SWIGV8_Proxy_DefaultDtor(const v8::WeakCallbackData<v8::Object, SWIGV8_Prox
   delete proxy;
 }
 
-int SWIG_V8_GetInstancePtr(v8::Handle<v8::Value> valRef, void** ptr) {
+int SWIG_V8_GetInstancePtr(v8::Handle<v8::Value> valRef, void **ptr) {
   if(!valRef->IsObject()) {
     return SWIG_TypeError;
   }
@@ -264,8 +265,8 @@ int SWIG_V8_GetInstancePtr(v8::Handle<v8::Value> valRef, void** ptr) {
   return SWIG_OK;
 }
 
-void SWIGV8_SetPrivateData(v8::Handle<v8::Object> obj, void* ptr, swig_type_info *info, int flags) {
-  SWIGV8_Proxy* cdata = new SWIGV8_Proxy();
+void SWIGV8_SetPrivateData(v8::Handle<v8::Object> obj, void *ptr, swig_type_info *info, int flags) {
+  SWIGV8_Proxy *cdata = new SWIGV8_Proxy();
   cdata->swigCObject = ptr;
   cdata->swigCMemOwn = (flags & SWIG_POINTER_OWN) ? 1 : 0;
   cdata->info = info;
@@ -297,7 +298,7 @@ void SWIGV8_SetPrivateData(v8::Handle<v8::Object> obj, void* ptr, swig_type_info
   } else {
     cdata->handle.MakeWeak(v8::Isolate::GetCurrent(), cdata, SWIGV8_Proxy_DefaultDtor);
   }
-#elif (SWIG_V8_VERSION < SWIG_SETWEAK_VERSION)
+#elif (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
   if(cdata->swigCMemOwn && (SWIGV8_ClientData*)info->clientdata) {
     cdata->handle.MakeWeak(cdata, ((SWIGV8_ClientData*)info->clientdata)->dtor);
   } else {
@@ -321,7 +322,7 @@ void SWIGV8_SetPrivateData(v8::Handle<v8::Object> obj, void* ptr, swig_type_info
 
 }
 
-int SWIG_V8_ConvertPtr(v8::Handle<v8::Value> valRef, void** ptr, swig_type_info *info, int flags) {
+int SWIG_V8_ConvertPtr(v8::Handle<v8::Value> valRef, void **ptr, swig_type_info *info, int flags) {
   SWIGV8_HANDLESCOPE();
   
   /* special case: JavaScript null => C NULL pointer */
@@ -448,7 +449,7 @@ public:
   ~SwigV8PackedData() {
   };
 
-  void* data;
+  void *data;
   size_t size;
   swig_type_info *type;
 
@@ -466,7 +467,7 @@ int SwigV8Packed_Check(v8::Handle<v8::Value> valRef) {
 }
 
 SWIGRUNTIME
-swig_type_info* SwigV8Packed_UnpackData(v8::Handle<v8::Value> valRef, void *ptr, size_t size) {
+swig_type_info *SwigV8Packed_UnpackData(v8::Handle<v8::Value> valRef, void *ptr, size_t size) {
   if (SwigV8Packed_Check(valRef)) {
     SWIGV8_HANDLESCOPE();
     
@@ -506,10 +507,10 @@ int SWIGV8_ConvertPacked(v8::Handle<v8::Value> valRef, void *ptr, size_t sz, swi
 void _wrap_SwigV8PackedData_delete(v8::Persistent< v8::Value > object, void *parameter) {
   SwigV8PackedData *cdata = static_cast<SwigV8PackedData *>(parameter);
 #elif (SWIG_V8_VERSION < 0x031900)
-void _wrap_SwigV8PackedData_delete(v8::Isolate *isolate, v8::Persistent< v8::Value > object, void *parameter) {
+void _wrap_SwigV8PackedData_delete(v8::Isolate *isolate, v8::Persistent<v8::Value> object, void *parameter) {
   SwigV8PackedData *cdata = static_cast<SwigV8PackedData *>(parameter);
-#elif (SWIG_V8_VERSION < SWIG_SETWEAK_VERSION)
-void _wrap_SwigV8PackedData_delete(v8::Isolate *isolate, v8::Persistent< v8::Object > * object, SwigV8PackedData *cdata) {
+#elif (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
+void _wrap_SwigV8PackedData_delete(v8::Isolate *isolate, v8::Persistent<v8::Object> *object, SwigV8PackedData *cdata) {
 #else
 void _wrap_SwigV8PackedData_delete(const v8::WeakCallbackData<v8::Object, SwigV8PackedData> &data) {
   v8::Local<v8::Object> object = data.GetValue();
@@ -526,7 +527,7 @@ void _wrap_SwigV8PackedData_delete(const v8::WeakCallbackData<v8::Object, SwigV8
   object.Dispose(isolate);
 #elif (SWIG_V8_VERSION < 0x032100)
   object->Dispose(isolate);
-#elif (SWIG_V8_VERSION < SWIG_SETWEAK_VERSION)
+#elif (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
   object->Dispose();
 #else
   object.Clear();
@@ -537,7 +538,7 @@ SWIGRUNTIME
 v8::Handle<v8::Value> SWIGV8_NewPackedObj(void *data, size_t size, swig_type_info *type) {
   SWIGV8_HANDLESCOPE_ESC();
 
-  SwigV8PackedData* cdata = new SwigV8PackedData(data, size, type);
+  SwigV8PackedData *cdata = new SwigV8PackedData(data, size, type);
 //  v8::Handle<v8::Object> obj = SWIGV8_OBJECT_NEW();
   v8::Local<v8::Object> obj = SWIGV8_OBJECT_NEW();
 
@@ -562,7 +563,7 @@ v8::Handle<v8::Value> SWIGV8_NewPackedObj(void *data, size_t size, swig_type_inf
   cdata->handle.MakeWeak(cdata, _wrap_SwigV8PackedData_delete);
 #elif (SWIG_V8_VERSION < 0x031918)
   cdata->handle.MakeWeak(v8::Isolate::GetCurrent(), cdata, _wrap_SwigV8PackedData_delete);
-#elif (SWIG_V8_VERSION < SWIG_SETWEAK_VERSION)
+#elif (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
   cdata->handle.MakeWeak(cdata, _wrap_SwigV8PackedData_delete);
 #else
   cdata->handle.SetWeak(cdata, _wrap_SwigV8PackedData_delete);
diff --git a/Tools/javascript/v8_shell.cxx b/Tools/javascript/v8_shell.cxx
index 0255d7e7f..bc90c1f10 100644
--- a/Tools/javascript/v8_shell.cxx
+++ b/Tools/javascript/v8_shell.cxx
@@ -72,7 +72,7 @@ public:
 

   virtual ~V8Shell();

 

-  virtual bool RunScript(const std::string& scriptPath);

+  virtual bool RunScript(const std::string &scriptPath);
 

   virtual bool RunShell();

 

@@ -81,27 +81,27 @@ protected:
 

   virtual bool InitializeEngine();

 

-  virtual bool ExecuteScript(const std::string& source, const std::string& scriptPath);

+  virtual bool ExecuteScript(const std::string &source, const std::string &scriptPath);
 

   virtual bool DisposeEngine();

 

 private:

 

-  v8::Handle<v8::Value> Import(const std::string& moduleName);

+  v8::Handle<v8::Value> Import(const std::string &moduleName);
 

   SwigV8Context CreateShellContext();
 

-  void ReportException(v8::TryCatch* handler);

+  void ReportException(v8::TryCatch *handler);
 

-  static SwigV8ReturnValue Print(const SwigV8Arguments& args);
+  static SwigV8ReturnValue Print(const SwigV8Arguments &args);
 

-  static SwigV8ReturnValue Require(const SwigV8Arguments& args);
+  static SwigV8ReturnValue Require(const SwigV8Arguments &args);
 

-  static SwigV8ReturnValue Quit(const SwigV8Arguments& args);
+  static SwigV8ReturnValue Quit(const SwigV8Arguments &args);
 

-  static SwigV8ReturnValue Version(const SwigV8Arguments& args);
+  static SwigV8ReturnValue Version(const SwigV8Arguments &args);
 

-  static const char* ToCString(const v8::String::Utf8Value& value);

+  static const char* ToCString(const v8::String::Utf8Value &value);
 

 };

 

@@ -116,10 +116,10 @@ V8Shell::V8Shell() {}
 

 V8Shell::~V8Shell() {}

 

-bool V8Shell::RunScript(const std::string& scriptPath) {

+bool V8Shell::RunScript(const std::string &scriptPath) {
   std::string source = ReadFile(scriptPath);
 

-  v8::Isolate* isolate = v8::Isolate::New();
+  v8::Isolate *isolate = v8::Isolate::New();
   v8::Isolate::Scope isolate_scope(isolate);
 
   SWIGV8_HANDLESCOPE();
@@ -182,7 +182,7 @@ bool V8Shell::RunShell() {
   while (true) {

     char buffer[kBufferSize];

     printf("> ");

-    char* str = fgets(buffer, kBufferSize, stdin);

+    char *str = fgets(buffer, kBufferSize, stdin);
     if (str == NULL) break;

     std::string source(str);

     ExecuteScript(source, "(shell)");

@@ -211,7 +211,7 @@ bool V8Shell::InitializeEngine() {
   return true;

 }

 

-bool V8Shell::ExecuteScript(const std::string& source, const std::string& name) {

+bool V8Shell::ExecuteScript(const std::string &source, const std::string &name) {
   SWIGV8_HANDLESCOPE();
 
   v8::TryCatch try_catch;

@@ -258,7 +258,7 @@ SwigV8Context V8Shell::CreateShellContext() {
 #endif
 }

 

-v8::Handle<v8::Value> V8Shell::Import(const std::string& module_path)

+v8::Handle<v8::Value> V8Shell::Import(const std::string &module_path)
 {

   SWIGV8_HANDLESCOPE_ESC();
 

@@ -281,7 +281,7 @@ v8::Handle<v8::Value> V8Shell::Import(const std::string& module_path)
   SWIGV8_ESCAPE(module);
 }

 

-SwigV8ReturnValue V8Shell::Print(const SwigV8Arguments& args) {
+SwigV8ReturnValue V8Shell::Print(const SwigV8Arguments &args) {
   SWIGV8_HANDLESCOPE();
 
   bool first = true;

@@ -293,7 +293,7 @@ SwigV8ReturnValue V8Shell::Print(const SwigV8Arguments& args) {
       printf(" ");

     }

     v8::String::Utf8Value str(args[i]);

-    const char* cstr = V8Shell::ToCString(str);

+    const char *cstr = V8Shell::ToCString(str);
     printf("%s", cstr);

   }

   printf("\n");

@@ -302,7 +302,7 @@ SwigV8ReturnValue V8Shell::Print(const SwigV8Arguments& args) {
   SWIGV8_RETURN(SWIGV8_UNDEFINED());
 }

 

-SwigV8ReturnValue V8Shell::Require(const SwigV8Arguments& args) {
+SwigV8ReturnValue V8Shell::Require(const SwigV8Arguments &args) {
   SWIGV8_HANDLESCOPE();
 

   if (args.Length() != 1) {

@@ -310,21 +310,21 @@ SwigV8ReturnValue V8Shell::Require(const SwigV8Arguments& args) {
   };

 

   v8::String::Utf8Value str(args[0]);

-  const char* cstr = V8Shell::ToCString(str);

+  const char *cstr = V8Shell::ToCString(str);
   std::string moduleName(cstr);

 

   v8::Local<v8::Object> global = SWIGV8_CURRENT_CONTEXT()->Global();
 
   v8::Local<v8::Value> hidden = global->GetHiddenValue(SWIGV8_STRING_NEW("__shell__"));
   v8::Local<v8::External> __shell__ = v8::Local<v8::External>::Cast(hidden);

-  V8Shell* _this = (V8Shell*) (long) __shell__->Value();

+  V8Shell *_this = (V8Shell *) (long) __shell__->Value();
 

   v8::Handle<v8::Value> module = _this->Import(moduleName);

 

   SWIGV8_RETURN(module);
 }

 

-SwigV8ReturnValue V8Shell::Quit(const SwigV8Arguments& args) {
+SwigV8ReturnValue V8Shell::Quit(const SwigV8Arguments &args) {
   SWIGV8_HANDLESCOPE();
 
   int exit_code = args[0]->Int32Value();

@@ -335,16 +335,16 @@ SwigV8ReturnValue V8Shell::Quit(const SwigV8Arguments& args) {
   SWIGV8_RETURN(SWIGV8_UNDEFINED());
 }

 

-SwigV8ReturnValue V8Shell::Version(const SwigV8Arguments& args) {
+SwigV8ReturnValue V8Shell::Version(const SwigV8Arguments &args) {
     SWIGV8_HANDLESCOPE();
     SWIGV8_RETURN(SWIGV8_STRING_NEW(v8::V8::GetVersion()));
 }

 

-void V8Shell::ReportException(v8::TryCatch* try_catch) {

+void V8Shell::ReportException(v8::TryCatch *try_catch) {
   SWIGV8_HANDLESCOPE();
 
   v8::String::Utf8Value exception(try_catch->Exception());

-  const char* exception_string = V8Shell::ToCString(exception);

+  const char *exception_string = V8Shell::ToCString(exception);
   v8::Handle<v8::Message> message = try_catch->Message();

   if (message.IsEmpty()) {

     // V8 didn't provide any extra information about this error; just

@@ -353,12 +353,12 @@ void V8Shell::ReportException(v8::TryCatch* try_catch) {
   } else {

     // Print (filename):(line number): (message).

     v8::String::Utf8Value filename(message->GetScriptResourceName());

-    const char* filename_string = V8Shell::ToCString(filename);

+    const char *filename_string = V8Shell::ToCString(filename);
     int linenum = message->GetLineNumber();

     printf("%s:%i: %s\n", filename_string, linenum, exception_string);

     // Print line of source code.

     v8::String::Utf8Value sourceline(message->GetSourceLine());

-    const char* sourceline_string = V8Shell::ToCString(sourceline);

+    const char *sourceline_string = V8Shell::ToCString(sourceline);
     printf("%s\n", sourceline_string);

     // Print wavy underline (GetUnderline is deprecated).

     int start = message->GetStartColumn();

@@ -372,17 +372,17 @@ void V8Shell::ReportException(v8::TryCatch* try_catch) {
     printf("\n");

     v8::String::Utf8Value stack_trace(try_catch->StackTrace());

     if (stack_trace.length() > 0) {

-      const char* stack_trace_string = V8Shell::ToCString(stack_trace);

+      const char *stack_trace_string = V8Shell::ToCString(stack_trace);
       printf("%s\n", stack_trace_string);

     }

   }

 }

 

 // Extracts a C string from a V8 Utf8Value.

-const char* V8Shell::ToCString(const v8::String::Utf8Value& value) {

+const char *V8Shell::ToCString(const v8::String::Utf8Value &value) {
   return *value ? *value : "<string conversion failed>";

 }

 

-JSShell* V8Shell_Create() {

+JSShell *V8Shell_Create() {
   return new V8Shell();

 }