Merge remote-tracking branch 'origin/master' into gsoc2012-scilab

Conflicts: .gitignore .travis.yml configure.ac
2015-01-26 10:50:20 +01:00 · 2015-01-26 10:50:20 +01:00 · adc4b788df
commit adc4b788df
parent 6f48e57090 8fe85e764f
352 changed files with 8897 additions and 2812 deletions
--- a/Lib/carrays.i
+++ b/Lib/carrays.i
@ -22,7 +22,7 @@
 %{
 static TYPE *new_##NAME(int nelements) { %}
 #ifdef __cplusplus
-%{  return new TYPE[nelements]; %}
+%{  return new TYPE[nelements](); %}
 #else
 %{  return (TYPE *) calloc(nelements,sizeof(TYPE)); %}
 #endif
--- a/Lib/csharp/arrays_csharp.i
+++ b/Lib/csharp/arrays_csharp.i
@ -103,6 +103,7 @@ CSHARP_ARRAYS(long long, long)
 CSHARP_ARRAYS(unsigned long long, ulong)
 CSHARP_ARRAYS(float, float)
 CSHARP_ARRAYS(double, double)
+CSHARP_ARRAYS(bool, bool)


 %define CSHARP_ARRAYS_FIXED( CTYPE, CSTYPE )
@ -134,4 +135,5 @@ CSHARP_ARRAYS_FIXED(long long, long)
 CSHARP_ARRAYS_FIXED(unsigned long long, ulong)
 CSHARP_ARRAYS_FIXED(float, float)
 CSHARP_ARRAYS_FIXED(double, double)
+CSHARP_ARRAYS_FIXED(bool, bool)

--- a/Lib/csharp/enums.swg
+++ b/Lib/csharp/enums.swg
@ -18,7 +18,7 @@
 %typemap(directorout,warning=SWIGWARN_TYPEMAP_THREAD_UNSAFE_MSG) const enum SWIGTYPE &
 %{ static $*1_ltype temp = ($*1_ltype)$input; 
   $result = &temp; %}
-%typemap(directorin) const enum SWIGTYPE & "$input = $1;"
+%typemap(directorin) const enum SWIGTYPE & "$input = (int)$1;"
 %typemap(csdirectorin) const enum SWIGTYPE & "($*csclassname)$iminput"
 %typemap(csdirectorout) const enum SWIGTYPE & "(int)$cscall"

@ -51,7 +51,7 @@
 %typemap(out) enum SWIGTYPE %{ $result = (int)$1; %}

 %typemap(directorout) enum SWIGTYPE  %{ $result = ($1_ltype)$input; %}
-%typemap(directorin) enum SWIGTYPE "$input = $1;"
+%typemap(directorin) enum SWIGTYPE "$input = (int)$1;"
 %typemap(csdirectorin) enum SWIGTYPE "($csclassname)$iminput"
 %typemap(csdirectorout) enum SWIGTYPE "(int)$cscall"

--- a/Lib/csharp/enumsimple.swg
+++ b/Lib/csharp/enumsimple.swg
@ -20,7 +20,7 @@
 %typemap(directorout,warning=SWIGWARN_TYPEMAP_THREAD_UNSAFE_MSG) const enum SWIGTYPE &
 %{ static $*1_ltype temp = ($*1_ltype)$input; 
   $result = &temp; %}
-%typemap(directorin) const enum SWIGTYPE & "$input = $1;"
+%typemap(directorin) const enum SWIGTYPE & "$input = (int)$1;"
 %typemap(csdirectorin) const enum SWIGTYPE & "$iminput"
 %typemap(csdirectorout) const enum SWIGTYPE & "$cscall"

@ -53,7 +53,7 @@
 %typemap(out) enum SWIGTYPE %{ $result = (int)$1; %}

 %typemap(directorout) enum SWIGTYPE  %{ $result = ($1_ltype)$input; %}
-%typemap(directorin) enum SWIGTYPE "$input = $1;"
+%typemap(directorin) enum SWIGTYPE "$input = (int)$1;"
 %typemap(csdirectorin) enum SWIGTYPE "$iminput"
 %typemap(csdirectorout) enum SWIGTYPE "$cscall"

--- a/Lib/csharp/enumtypesafe.swg
+++ b/Lib/csharp/enumtypesafe.swg
@ -19,7 +19,7 @@
 %typemap(directorout,warning=SWIGWARN_TYPEMAP_THREAD_UNSAFE_MSG) const enum SWIGTYPE &
 %{ static $*1_ltype temp = ($*1_ltype)$input; 
   $result = &temp; %}
-%typemap(directorin) const enum SWIGTYPE & "$input = $1;"
+%typemap(directorin) const enum SWIGTYPE & "$input = (int)$1;"
 %typemap(csdirectorin) const enum SWIGTYPE & "$*csclassname.swigToEnum($iminput)"
 %typemap(csdirectorout) const enum SWIGTYPE & "$cscall.swigValue"

@ -52,7 +52,7 @@
 %typemap(out) enum SWIGTYPE %{ $result = (int)$1; %}

 %typemap(directorout) enum SWIGTYPE  %{ $result = ($1_ltype)$input; %}
-%typemap(directorin) enum SWIGTYPE "$input = $1;"
+%typemap(directorin) enum SWIGTYPE "$input = (int)$1;"
 %typemap(csdirectorin) enum SWIGTYPE "$csclassname.swigToEnum($iminput)"
 %typemap(csdirectorout) enum SWIGTYPE "$cscall.swigValue"

--- a/Lib/d/boost_shared_ptr.i
+++ b/Lib/d/boost_shared_ptr.i
@ -152,7 +152,7 @@ public this(void* cObject, bool ownCObject) {
  swigCMemOwn = ownCObject;
 }

-public static void* swigGetCPtr($dclassname obj) {
+public static void* swigGetCPtr(typeof(this) obj) {
  return (obj is null) ? null : obj.swigCPtr;
 }
 %}
@ -167,7 +167,7 @@ public this(void* cObject, bool ownCObject) {
  swigCMemOwn = ownCObject;
 }

-public static void* swigGetCPtr($dclassname obj) {
+public static void* swigGetCPtr(typeof(this) obj) {
  return (obj is null) ? null : obj.swigCPtr;
 }
 %}
--- a/Lib/d/dclassgen.swg
+++ b/Lib/d/dclassgen.swg
@ -72,7 +72,7 @@ public this(void* cObject, bool ownCObject) {
  swigCMemOwn = ownCObject;
 }

-public static void* swigGetCPtr($dclassname obj) {
+public static void* swigGetCPtr(typeof(this) obj) {
  return (obj is null) ? null : obj.swigCPtr;
 }

@ -88,7 +88,7 @@ public this(void* cObject, bool ownCObject) {
  swigCPtr = cObject;
 }

-public static void* swigGetCPtr($dclassname obj) {
+public static void* swigGetCPtr(typeof(this) obj) {
  return (obj is null) ? null : obj.swigCPtr;
 }

@ -111,7 +111,7 @@ protected this() {
  swigCPtr = null;
 }

-public static void* swigGetCPtr($dclassname obj) {
+public static void* swigGetCPtr(typeof(this) obj) {
  return (obj is null) ? null : obj.swigCPtr;
 }

@ -134,7 +134,7 @@ protected this() {
  swigCPtr = null;
 }

-package static char* swigGetCMemberPtr($dclassname obj) {
+package static char* swigGetCMemberPtr(typeof(this) obj) {
  return (obj is null) ? null : obj.swigCPtr;
 }

--- a/Lib/d/denums.swg
+++ b/Lib/d/denums.swg
@ -16,10 +16,10 @@
 %typecheck(SWIG_TYPECHECK_POINTER) enum SWIGTYPE ""

 %typemap(in) enum SWIGTYPE %{ $1 = ($1_ltype)$input; %}
-%typemap(out) enum SWIGTYPE %{ $result = $1; %}
+%typemap(out) enum SWIGTYPE %{ $result = (int)$1; %}

 %typemap(directorout) enum SWIGTYPE %{ $result = ($1_ltype)$input; %}
-%typemap(directorin) enum SWIGTYPE "$input = $1;"
+%typemap(directorin) enum SWIGTYPE "$input = (int)$1;"
 %typemap(ddirectorin) enum SWIGTYPE "cast($dclassname)$winput"
 %typemap(ddirectorout) enum SWIGTYPE "cast(int)$dcall"

@ -43,9 +43,9 @@
 %typemap(in) const enum SWIGTYPE & ($*1_ltype temp)
 %{ temp = ($*1_ltype)$input;
   $1 = &temp; %}
-%typemap(out) const enum SWIGTYPE & %{ $result = *$1; %}
+%typemap(out) const enum SWIGTYPE & %{ $result = (int)*$1; %}

-%typemap(directorin) const enum SWIGTYPE & "$input = $1;"
+%typemap(directorin) const enum SWIGTYPE & "$input = (int)$1;"
 %typemap(directorout,warning=SWIGWARN_TYPEMAP_THREAD_UNSAFE_MSG) const enum SWIGTYPE &
 %{ static $*1_ltype temp = ($*1_ltype)$input;
   $result = &temp; %}
--- a/Lib/d/dhead.swg
+++ b/Lib/d/dhead.swg
@ -93,31 +93,26 @@ private class SwigExceptionHelper {

  static void setException(char* message) {
    auto exception = new object.Exception(tango.stdc.stringz.fromStringz(message).dup);
-    exception.next = SwigPendingException.retrieve();
    SwigPendingException.set(exception);
  }

  static void setIllegalArgumentException(char* message) {
    auto exception = new tango.core.Exception.IllegalArgumentException(tango.stdc.stringz.fromStringz(message).dup);
-    exception.next = SwigPendingException.retrieve();
    SwigPendingException.set(exception);
  }

  static void setIllegalElementException(char* message) {
    auto exception = new tango.core.Exception.IllegalElementException(tango.stdc.stringz.fromStringz(message).dup);
-    exception.next = SwigPendingException.retrieve();
    SwigPendingException.set(exception);
  }

  static void setIOException(char* message) {
    auto exception = new tango.core.Exception.IOException(tango.stdc.stringz.fromStringz(message).dup);
-    exception.next = SwigPendingException.retrieve();
    SwigPendingException.set(exception);
  }

  static void setNoSuchElementException(char* message) {
    auto exception = new tango.core.Exception.NoSuchElementException(tango.stdc.stringz.fromStringz(message).dup);
-    exception.next = SwigPendingException.retrieve();
    SwigPendingException.set(exception);
  }
 }
@ -125,51 +120,31 @@ private class SwigExceptionHelper {
 package class SwigPendingException {
 public:
  static this() {
-    m_sPendingCount = 0;
    m_sPendingException = new ThreadLocalData(null);
  }

  static bool isPending() {
-    bool pending = false;
-    if (m_sPendingCount > 0) {
-      if (m_sPendingException.val !is null) {
-        pending = true;
-      }
-    }
-    return pending;
+    return m_sPendingException.val !is null;
  }

  static void set(object.Exception e) {
-    if (m_sPendingException.val !is null) {
-      throw new object.Exception("FATAL: An earlier pending exception from C/C++ code " ~
-        "was missed and thus not thrown (" ~ m_sPendingException.val.classinfo.name ~
-        ": " ~ m_sPendingException.val.msg ~ ")!", e);
+    auto pending = m_sPendingException.val;
+    if (pending !is null) {
+      e.next = pending;
+      throw new object.Exception("FATAL: An earlier pending exception from C/C++ " ~
+        "code was missed and thus not thrown (" ~ pending.classinfo.name ~ ": " ~
+        pending.msg ~ ")!", e);
    }
-
    m_sPendingException.val = e;
-    synchronized {
-      ++m_sPendingCount;
-    }
  }

  static object.Exception retrieve() {
-    object.Exception e = null;
-    if (m_sPendingCount > 0) {
-      if (m_sPendingException.val !is null) {
-        e = m_sPendingException.val;
-        m_sPendingException.val = null;
-        synchronized {
-          --m_sPendingCount;
-        }
-      }
-    }
+    auto e = m_sPendingException.val;
+    m_sPendingException.val = null;
    return e;
  }

 private:
-  // The pending exception counter is stored thread-global.
-  static int m_sPendingCount;
-
  // The reference to the pending exception (if any) is stored thread-local.
  alias tango.core.Thread.ThreadLocal!(object.Exception) ThreadLocalData;
  static ThreadLocalData m_sPendingException;
@ -195,8 +170,7 @@ private class SwigExceptionHelper {
  }

  static void setException(const char* message) {
-    auto exception = new object.Exception(std.conv.to!string(message).idup);
-    exception.next = SwigPendingException.retrieve();
+    auto exception = new object.Exception(std.conv.to!string(message));
    SwigPendingException.set(exception);
  }
 }
@ -204,51 +178,31 @@ private class SwigExceptionHelper {
 package struct SwigPendingException {
 public:
  static this() {
-    m_sPendingCount = 0;
    m_sPendingException = null;
  }

  static bool isPending() {
-    bool pending = false;
-    if (m_sPendingCount > 0) {
-      if (m_sPendingException !is null) {
-        pending = true;
-      }
-    }
-    return pending;
+    return m_sPendingException !is null;
  }

  static void set(object.Exception e) {
    if (m_sPendingException !is null) {
+      e.next = m_sPendingException;
      throw new object.Exception("FATAL: An earlier pending exception from C/C++ code " ~
        "was missed and thus not thrown (" ~ m_sPendingException.classinfo.name ~
        ": " ~ m_sPendingException.msg ~ ")!", e);
    }

    m_sPendingException = e;
-    synchronized {
-      ++m_sPendingCount;
-    }
  }

  static object.Exception retrieve() {
-    object.Exception e = null;
-    if (m_sPendingCount > 0) {
-      if (m_sPendingException !is null) {
-        e = m_sPendingException;
-        m_sPendingException = null;
-        synchronized {
-          --m_sPendingCount;
-        }
-      }
-    }
+    auto e = m_sPendingException;
+    m_sPendingException = null;
    return e;
  }

 private:
-  // The pending exception counter is stored thread-global.
-  static shared int m_sPendingCount;
-
  // The reference to the pending exception (if any) is stored thread-local.
  static object.Exception m_sPendingException;
 }
--- a/Lib/go/go.swg
+++ b/Lib/go/go.swg
@ -225,13 +225,13 @@
 %{ $1 = *($&1_ltype)&$input; %}

 %typemap(out) SWIGTYPE *
-%{ *($&1_ltype)&$result = $1; %}
+%{ *($&1_ltype)&$result = ($1_ltype)$1; %}

 %typemap(directorin) SWIGTYPE *
-%{ $input = ($1_ltype)$1; %}
+%{ *($&1_ltype)&$input = ($1_ltype)$1; %}

 %typemap(directorout) SWIGTYPE *
-%{ $result = ($1_ltype)$input; %}
+%{ $result = *($&1_ltype)&$input; %}

 %apply SWIGTYPE * { SWIGTYPE *const }

@ -379,7 +379,7 @@
 %{ $result = (intgo)$1; %}

 %typemap(directorin) enum SWIGTYPE
-%{ $input = ($1_ltype)$1; %}
+%{ $input = (intgo)$1; %}

 %typemap(directorout) enum SWIGTYPE
 %{ $result = ($1_ltype)$input; %}
--- a/Lib/go/goruntime.swg
+++ b/Lib/go/goruntime.swg
@ -57,12 +57,21 @@ swiggo_size_assert(double, 8)
 extern "C" {
 #endif
 extern void crosscall2(void (*fn)(void *, int), void *, int);
+extern char* _cgo_topofstack(void) __attribute__ ((weak));
 extern void _cgo_allocate(void *, int);
 extern void _cgo_panic(void *, int);
 #ifdef __cplusplus
 }
 #endif

+static char *_swig_topofstack() {
+  if (_cgo_topofstack) {
+    return _cgo_topofstack();
+  } else {
+    return 0;
+  }
+}
+
 static void *_swig_goallocate(size_t len) {
  struct {
    size_t len;
@ -89,11 +98,11 @@ static void _swig_gopanic(const char *p) {
 #include "runtime.h"
 #include "cgocall.h"

-#ifdef _64BIT
-#define SWIG_PARM_SIZE 8
-#else
-#define SWIG_PARM_SIZE 4
-#endif
+#pragma dataflag 16
+static void *cgocall = runtime·cgocall;
+#pragma dataflag 16
+void *·_cgo_runtime_cgocall = &cgocall;
+
 %}

 #else
@ -194,6 +203,10 @@ static _gostring_ _swig_makegostring(const char *p, size_t l) {

 %go_import("unsafe", _ "runtime/cgo")

+%insert(go_header) %{
+var _cgo_runtime_cgocall func(unsafe.Pointer, uintptr)
+%}
+
 #else

 %go_import("syscall", "unsafe")
@ -212,6 +225,16 @@ type _ unsafe.Pointer

 %}

+/* Swig_always_false is used to conditionally assign parameters to
+   Swig_escape_val so that the compiler thinks that they escape.  We
+   only assign them if Swig_always_false is true, which it never is.
+   We export the variable so that the compiler doesn't realize that it
+   is never set. */
+%insert(go_header) %{
+var Swig_escape_always_false bool
+var Swig_escape_val interface{}
+%}
+
 /* Function pointers are translated by the code in go.cxx into
   _swig_fnptr.  Member pointers are translated to _swig_memberptr.  */

--- a/Lib/guile/typemaps.i
+++ b/Lib/guile/typemaps.i
@ -172,11 +172,11 @@
  }
  * (int *) &($1) = scm_to_int($input);
 }
-%typemap(out)    enum SWIGTYPE  { $result = scm_from_long($1); }
-%typemap(varout) enum SWIGTYPE  { $result = scm_from_long($1); }
+%typemap(out)    enum SWIGTYPE  { $result = scm_from_long((int)$1); }
+%typemap(varout) enum SWIGTYPE  { $result = scm_from_long((int)$1); }
 %typemap(throws) enum SWIGTYPE {
  scm_throw(scm_from_locale_symbol((char *) "swig-exception"),
-     scm_listify(scm_from_long($1), SCM_UNDEFINED));
+     scm_listify(scm_from_long((int)$1), SCM_UNDEFINED));
 }

 /* The SIMPLE_MAP_WITH_EXPR macro below defines the whole set of
--- a/Lib/java/director.swg
+++ b/Lib/java/director.swg
@ -100,6 +100,22 @@ namespace Swig {
    bool weak_global_;
  };

+  /* Local JNI reference deleter */
+  class LocalRefGuard {
+    JNIEnv *jenv_;
+    jobject jobj_;
+
+    // non-copyable
+    LocalRefGuard(const LocalRefGuard &);
+    LocalRefGuard &operator=(const LocalRefGuard &);
+  public:
+    LocalRefGuard(JNIEnv *jenv, jobject jobj): jenv_(jenv), jobj_(jobj) {}
+    ~LocalRefGuard() {
+      if (jobj_)
+        jenv_->DeleteLocalRef(jobj_);
+    }
+  };
+
  /* director base class */
  class Director {
    /* pointer to Java virtual machine */
@ -152,6 +168,7 @@ namespace Swig {
      JNIEnvWrapper jnienv(this) ;
      JNIEnv *jenv = jnienv.getJNIEnv() ;
      jobject jobj = swig_self_.get(jenv);
+      LocalRefGuard ref_deleter(jenv, jobj);
 #if defined(DEBUG_DIRECTOR_OWNED)
      std::cout << "Swig::Director::disconnect_director_self(" << jobj << ")" << std::endl;
 #endif
@ -164,7 +181,6 @@ namespace Swig {
          jenv->CallVoidMethod(jobj, disconn_meth);
        }
      }
-      jenv->DeleteLocalRef(jobj);
    }

  public:
@ -379,6 +395,5 @@ namespace Swig {
    }
    return matches;
  }
-
 }

--- a/Lib/java/java.swg
+++ b/Lib/java/java.swg
@ -400,11 +400,13 @@ SWIGINTERN const char * SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
 }

 %typemap(directorin, descriptor="Ljava/lang/String;", noblock=1) char * {
- $input = 0;
+  $input = 0;
  if ($1) {
    $input = JCALL1(NewStringUTF, jenv, (const char *)$1);
    if (!$input) return $null;
  }
+  Swig::LocalRefGuard $1_refguard(jenv, $input);
+// boohoo
 }

 %typemap(freearg, noblock=1) char * { if ($1) JCALL2(ReleaseStringUTFChars, jenv, $input, (const char *)$1); }
@ -731,6 +733,7 @@ SWIGINTERN const char * SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
    $input = JCALL1(NewStringUTF, jenv, (const char *)$1);
    if (!$input) return $null;
  }
+  Swig::LocalRefGuard $1_refguard(jenv, $input);
 }

 %typemap(argout) char[ANY], char[] ""
--- a/Lib/java/std_string.i
+++ b/Lib/java/std_string.i
@ -49,7 +49,8 @@ class string;
   jenv->ReleaseStringUTFChars($input, $1_pstr); %}

 %typemap(directorin,descriptor="Ljava/lang/String;") string 
-%{ $input = jenv->NewStringUTF($1.c_str()); %}
+%{ $input = jenv->NewStringUTF($1.c_str());
+   Swig::LocalRefGuard $1_refguard(jenv, $input); %}

 %typemap(out) string 
 %{ $result = jenv->NewStringUTF($1.c_str()); %}
@ -98,7 +99,8 @@ class string;
   jenv->ReleaseStringUTFChars($input, $1_pstr); %}

 %typemap(directorin,descriptor="Ljava/lang/String;") const string &
-%{ $input = jenv->NewStringUTF($1.c_str()); %}
+%{ $input = jenv->NewStringUTF($1.c_str());
+   Swig::LocalRefGuard $1_refguard(jenv, $input); %}

 %typemap(out) const string & 
 %{ $result = jenv->NewStringUTF($1->c_str()); %}
--- a/Lib/java/various.i
+++ b/Lib/java/various.i
@ -92,6 +92,7 @@
 * The returned string appears in the 1st element of the passed in Java String array.
 *
 * Example usage wrapping:
+ *   %apply char **STRING_OUT { char **string_out };
 *   void foo(char **string_out);
 *  
 * Java usage:
@ -154,3 +155,40 @@
 /* Prevent default freearg typemap from being used */
 %typemap(freearg) char *BYTE ""

+/* 
+ * unsigned char *NIOBUFFER typemaps. 
+ * This is for mapping Java nio buffers to C char arrays.
+ * It is useful for performance critical code as it reduces the memory copy an marshaling overhead.
+ * Note: The Java buffer has to be allocated with allocateDirect.
+ *
+ * Example usage wrapping:
+ *   %apply unsigned char *NIOBUFFER { unsigned char *buf };
+ *   void foo(unsigned char *buf);
+ *  
+ * Java usage:
+ *   java.nio.ByteBuffer b = ByteBuffer.allocateDirect(20); 
+ *   modulename.foo(b);
+ */
+%typemap(jni) unsigned char *NIOBUFFER "jobject"  
+%typemap(jtype) unsigned char *NIOBUFFER "java.nio.ByteBuffer"  
+%typemap(jstype) unsigned char *NIOBUFFER "java.nio.ByteBuffer"  
+%typemap(javain,
+  pre="  assert $javainput.isDirect() : \"Buffer must be allocated direct.\";") unsigned char *NIOBUFFER "$javainput"
+%typemap(javaout) unsigned char *NIOBUFFER {  
+  return $jnicall;  
+}  
+%typemap(in) unsigned char *NIOBUFFER {  
+  $1 = (unsigned char *) JCALL1(GetDirectBufferAddress, jenv, $input); 
+  if ($1 == NULL) {  
+    SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unable to get address of a java.nio.ByteBuffer direct byte buffer. Buffer must be a direct buffer and not a non-direct buffer.");  
+  }  
+}  
+%typemap(memberin) unsigned char *NIOBUFFER {  
+  if ($input) {  
+    $1 = $input;  
+  } else {  
+    $1 = 0;  
+  }  
+}  
+%typemap(freearg) unsigned char *NIOBUFFER ""  
+
--- a/Lib/javascript/jsc/javascriptcode.swg
+++ b/Lib/javascript/jsc/javascriptcode.swg
@ -354,7 +354,7 @@ static JSStaticFunction $jsmangledname_functions[] = {
  $jsmangledname_objectDefinition.staticValues = $jsmangledname_values;
  $jsmangledname_objectDefinition.staticFunctions = $jsmangledname_functions;
  $jsclass_inheritance
-  JSClassRef $jsmangledname_classRef = JSClassCreate(&$jsmangledname_objectDefinition);
+  $jsmangledname_classRef = JSClassCreate(&$jsmangledname_objectDefinition);
  SWIGTYPE_$jsmangledtype->clientdata = $jsmangledname_classRef;
 %}

--- a/Lib/javascript/v8/javascriptcode.swg
+++ b/Lib/javascript/v8/javascriptcode.swg
@ -8,8 +8,9 @@
 * ----------------------------------------------------------------------------- */

 %fragment("js_ctor", "templates") %{
-SwigV8ReturnValue $jswrapper(const SwigV8Arguments& args) {
-  v8::HandleScope scope;
+static SwigV8ReturnValue $jswrapper(const SwigV8Arguments &args) {
+  SWIGV8_HANDLESCOPE();
+  
  v8::Handle<v8::Object> self = args.Holder();
  $jslocals
  if(args.Length() != $jsargcount) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for $jswrapper.");
@ -20,7 +21,7 @@ SwigV8ReturnValue $jswrapper(const SwigV8Arguments& args) {

  goto fail;
 fail:
-  SWIGV8_RETURN(v8::Undefined());
+  SWIGV8_RETURN(SWIGV8_UNDEFINED());
 }
 %}

@ -31,10 +32,11 @@ fail:
 * ----------------------------------------------------------------------------- */
 %fragment ("js_veto_ctor", "templates")
 %{
-SwigV8ReturnValue $jswrapper(const SwigV8Arguments& args) {
-  v8::HandleScope scope;
+static SwigV8ReturnValue $jswrapper(const SwigV8Arguments &args) {
+  SWIGV8_HANDLESCOPE();
+  
  SWIG_exception(SWIG_ERROR, "Class $jsname can not be instantiated");
-  SWIGV8_RETURN(v8::Undefined());
+  SWIGV8_RETURN(SWIGV8_UNDEFINED());
 }
 %}

@ -46,8 +48,9 @@ SwigV8ReturnValue $jswrapper(const SwigV8Arguments& args) {
 * ----------------------------------------------------------------------------- */
 %fragment ("js_ctor_dispatcher", "templates")
 %{
-SwigV8ReturnValue $jswrapper(const SwigV8Arguments& args) {
-  v8::HandleScope scope;
+static SwigV8ReturnValue $jswrapper(const SwigV8Arguments &args) {
+  SWIGV8_HANDLESCOPE();
+  
  OverloadErrorHandler errorHandler;
  v8::Handle<v8::Value> self;

@ -58,7 +61,7 @@ SwigV8ReturnValue $jswrapper(const SwigV8Arguments& args) {
  SWIG_exception_fail(SWIG_ERROR, "Illegal arguments for construction of $jsmangledname");

 fail:
-  SWIGV8_RETURN(v8::Undefined());
+  SWIGV8_RETURN(SWIGV8_UNDEFINED());
 }
 %}

@ -71,8 +74,9 @@ fail:
 *   - $jsmangledtype:    mangled type of class
 * ----------------------------------------------------------------------------- */
 %fragment("js_overloaded_ctor", "templates") %{
-SwigV8ReturnValue $jswrapper(const SwigV8Arguments& args, V8ErrorHandler& SWIGV8_ErrorHandler) {
-  v8::HandleScope scope;
+static SwigV8ReturnValue $jswrapper(const SwigV8Arguments &args, V8ErrorHandler &SWIGV8_ErrorHandler) {
+  SWIGV8_HANDLESCOPE();
+  
  v8::Handle<v8::Object> self = args.Holder();
  $jslocals
  if(args.Length() != $jsargcount) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for $jswrapper.");
@ -83,7 +87,7 @@ SwigV8ReturnValue $jswrapper(const SwigV8Arguments& args, V8ErrorHandler& SWIGV8

  goto fail;
 fail:
-  SWIGV8_RETURN(v8::Undefined());
+  SWIGV8_RETURN(SWIGV8_UNDEFINED());
 }
 %}

@ -98,10 +102,10 @@ fail:
 %{
  if(args.Length() == $jsargcount) {
    errorHandler.err.Clear();
-#if SWIG_V8_VERSION < 0x031900
+#if (SWIG_V8_VERSION < 0x031903)
    self = $jswrapper(args, errorHandler);
    if(errorHandler.err.IsEmpty()) {
-      return scope.Close(self);
+      SWIGV8_ESCAPE(self);
    }
 #else
    $jswrapper(args, errorHandler);
@ -120,13 +124,18 @@ fail:
 %fragment ("js_dtor", "templates")
 %{

-#if (SWIG_V8_VERSION < 0x031900)
-void $jswrapper(v8::Persistent< v8::Value > object, void *parameter)
-{
+#if (SWIG_V8_VERSION < 0x031710)
+static void $jswrapper(v8::Persistent< v8::Value > object, void *parameter) {
  SWIGV8_Proxy *proxy = static_cast<SWIGV8_Proxy *>(parameter);
+#elif (SWIG_V8_VERSION < 0x031900)
+static void $jswrapper(v8::Isolate *isolate, v8::Persistent<v8::Value> object, void *parameter) {
+  SWIGV8_Proxy *proxy = static_cast<SWIGV8_Proxy *>(parameter);
+#elif (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
+static void $jswrapper(v8::Isolate *isolate, v8::Persistent<v8::Object> *object, SWIGV8_Proxy *proxy) {
 #else
-void $jswrapper(v8::Isolate *isolate, v8::Persistent< v8::Object > * object, SWIGV8_Proxy *proxy)
-{
+static void $jswrapper(const v8::WeakCallbackData<v8::Object, SWIGV8_Proxy> &data) {
+  v8::Local<v8::Object> object = data.GetValue();
+  SWIGV8_Proxy *proxy = data.GetParameter();
 #endif

  if(proxy->swigCMemOwn && proxy->swigCObject) {
@ -138,8 +147,11 @@ void $jswrapper(v8::Isolate *isolate, v8::Persistent< v8::Object > * object, SWI
  delete proxy;

  object.Clear();
-#if (SWIG_V8_VERSION < 0x031900)
+  
+#if (SWIG_V8_VERSION < 0x031710)
  object.Dispose();
+#elif (SWIG_V8_VERSION < 0x031900)
+  object.Dispose(isolate);
 #elif (SWIG_V8_VERSION < 0x032100)
  object->Dispose(isolate);
 #else
@ -156,26 +168,36 @@ void $jswrapper(v8::Isolate *isolate, v8::Persistent< v8::Object > * object, SWI
 * ----------------------------------------------------------------------------- */
 %fragment ("js_dtoroverride", "templates")
 %{
-#if (SWIG_V8_VERSION < 0x031900)
-void $jswrapper(v8::Persistent< v8::Value > object, void *parameter)
-{
+#if (SWIG_V8_VERSION < 0x031710)
+static void $jswrapper(v8::Persistent<v8::Value> object, void *parameter) {
  SWIGV8_Proxy *proxy = static_cast<SWIGV8_Proxy *>(parameter);
+#elif (SWIG_V8_VERSION < 0x031900)
+static void $jswrapper(v8::Isolate *isolate, v8::Persistent<v8::Value> object, void *parameter) {
+  SWIGV8_Proxy *proxy = static_cast<SWIGV8_Proxy *>(parameter);
+#elif (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
+static void $jswrapper(v8::Isolate *isolate, v8::Persistent< v8::Object> *object, SWIGV8_Proxy *proxy) {
 #else
-void $jswrapper(v8::Isolate *isolate, v8::Persistent< v8::Object > * object, SWIGV8_Proxy *proxy)
-{
+static void $jswrapper(const v8::WeakCallbackData<v8::Object, SWIGV8_Proxy> &data) {
+  v8::Local<v8::Object> object = data.GetValue();
+  SWIGV8_Proxy *proxy = data.GetParameter();
 #endif
+
  if(proxy->swigCMemOwn && proxy->swigCObject) {
    $jstype arg1 = ($jstype)proxy->swigCObject;
    ${destructor_action}
  }
  delete proxy;

-#if (SWIG_V8_VERSION < 0x031900)
+#if (SWIG_V8_VERSION < 0x031710)
  object.Dispose();
+#elif (SWIG_V8_VERSION < 0x031900)
+  object.Dispose(isolate);
 #elif (SWIG_V8_VERSION < 0x032100)
  object->Dispose(isolate);
-#else
+#elif (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
  object->Dispose();
+#else
+  object.Clear();
 #endif
 }
 %}
@ -188,8 +210,9 @@ void $jswrapper(v8::Isolate *isolate, v8::Persistent< v8::Object > * object, SWI
 * ----------------------------------------------------------------------------- */
 %fragment("js_getter", "templates")
 %{
-SwigV8ReturnValue $jswrapper(v8::Local<v8::String> property, const SwigV8PropertyCallbackInfo& info) {
-  v8::HandleScope scope;
+static SwigV8ReturnValue $jswrapper(v8::Local<v8::String> property, const SwigV8PropertyCallbackInfo &info) {
+  SWIGV8_HANDLESCOPE();
+  
  v8::Handle<v8::Value> jsresult;
  $jslocals
  $jscode
@ -197,7 +220,7 @@ SwigV8ReturnValue $jswrapper(v8::Local<v8::String> property, const SwigV8Propert

  goto fail;
 fail:
-  SWIGV8_RETURN_INFO(v8::Undefined(), info);
+  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
 }
 %}

@ -209,9 +232,10 @@ fail:
 * ----------------------------------------------------------------------------- */
 %fragment("js_setter", "templates")
 %{
-void $jswrapper(v8::Local<v8::String> property, v8::Local<v8::Value> value,
-  const SwigV8PropertyCallbackInfoVoid& info) {
-  v8::HandleScope scope;
+static void $jswrapper(v8::Local<v8::String> property, v8::Local<v8::Value> value,
+  const SwigV8PropertyCallbackInfoVoid &info) {
+  SWIGV8_HANDLESCOPE();
+  
  $jslocals
  $jscode
  goto fail;
@ -228,8 +252,9 @@ fail:
 * ----------------------------------------------------------------------------- */
 %fragment("js_function", "templates")
 %{
-SwigV8ReturnValue $jswrapper(const SwigV8Arguments& args) {
-  v8::HandleScope scope;
+static SwigV8ReturnValue $jswrapper(const SwigV8Arguments &args) {
+  SWIGV8_HANDLESCOPE();
+  
  v8::Handle<v8::Value> jsresult;
  $jslocals
  if(args.Length() != $jsargcount) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for $jswrapper.");
@ -239,7 +264,7 @@ SwigV8ReturnValue $jswrapper(const SwigV8Arguments& args) {

  goto fail;
 fail:
-  SWIGV8_RETURN(v8::Undefined());
+  SWIGV8_RETURN(SWIGV8_UNDEFINED());
 }
 %}

@ -252,8 +277,9 @@ fail:
 * ----------------------------------------------------------------------------- */
 %fragment("js_function_dispatcher", "templates")
 %{
-SwigV8ReturnValue $jswrapper(const SwigV8Arguments& args) {
-  v8::HandleScope scope;
+static SwigV8ReturnValue $jswrapper(const SwigV8Arguments &args) {
+  SWIGV8_HANDLESCOPE();
+  
  v8::Handle<v8::Value> jsresult;
  OverloadErrorHandler errorHandler;
  $jscode
@ -262,7 +288,7 @@ SwigV8ReturnValue $jswrapper(const SwigV8Arguments& args) {

  goto fail;
 fail:
-  SWIGV8_RETURN(v8::Undefined());
+  SWIGV8_RETURN(SWIGV8_UNDEFINED());
 }
 %}

@ -274,9 +300,10 @@ fail:
 * ----------------------------------------------------------------------------- */
 %fragment ("js_overloaded_function", "templates")
 %{
-SwigV8ReturnValue $jswrapper(const SwigV8Arguments& args, V8ErrorHandler& SWIGV8_ErrorHandler)
+static SwigV8ReturnValue $jswrapper(const SwigV8Arguments &args, V8ErrorHandler &SWIGV8_ErrorHandler)
 {
-  v8::HandleScope scope;
+  SWIGV8_HANDLESCOPE();
+  
  v8::Handle<v8::Value> jsresult;
  $jslocals
  $jscode
@ -284,7 +311,7 @@ SwigV8ReturnValue $jswrapper(const SwigV8Arguments& args, V8ErrorHandler& SWIGV8

  goto fail;
 fail:
-  SWIGV8_RETURN(v8::Undefined());
+  SWIGV8_RETURN(SWIGV8_UNDEFINED());
 }
 %}

@ -299,10 +326,10 @@ fail:

  if(args.Length() == $jsargcount) {
    errorHandler.err.Clear();
-#if (SWIG_V8_VERSION < 0x031900)
+#if (SWIG_V8_VERSION < 0x031903)
    jsresult = $jswrapper(args, errorHandler);
    if(errorHandler.err.IsEmpty()) {
-      return scope.Close(jsresult);
+      SWIGV8_ESCAPE(jsresult);
    }
 #else
    $jswrapper(args, errorHandler);
@ -330,12 +357,9 @@ fail:
 * ----------------------------------------------------------------------------- */
 %fragment("jsv8_define_class_template", "templates")
 %{
+  /* Name: $jsmangledname, Type: $jsmangledtype, Dtor: $jsdtor */
  v8::Handle<v8::FunctionTemplate> $jsmangledname_class = SWIGV8_CreateClassTemplate("$jsmangledname");
-#if (SWIG_V8_VERSION < 0x031900)
-  $jsmangledname_clientData.class_templ = v8::Persistent<v8::FunctionTemplate>::New($jsmangledname_class);
-#else
-  $jsmangledname_clientData.class_templ.Reset(v8::Isolate::GetCurrent(), $jsmangledname_class);
-#endif
+  SWIGV8_SET_CLASS_TEMPL($jsmangledname_clientData.class_templ, $jsmangledname_class);
  $jsmangledname_clientData.dtor = $jsdtor;
  if (SWIGTYPE_$jsmangledtype->clientdata == 0) {
    SWIGTYPE_$jsmangledtype->clientdata = &$jsmangledname_clientData;
@ -352,11 +376,11 @@ fail:
 %{
  if (SWIGTYPE_p$jsbaseclass->clientdata && !(static_cast<SWIGV8_ClientData *>(SWIGTYPE_p$jsbaseclass->clientdata)->class_templ.IsEmpty()))
  {
-#if (SWIG_V8_VERSION < 0x031900)
+#if (SWIG_V8_VERSION < 0x031903)
    $jsmangledname_class->Inherit(static_cast<SWIGV8_ClientData *>(SWIGTYPE_p$jsbaseclass->clientdata)->class_templ);
 #else
    $jsmangledname_class->Inherit(
-      v8::Handle<v8::FunctionTemplate>::New(
+      v8::Local<v8::FunctionTemplate>::New(
        v8::Isolate::GetCurrent(),
        static_cast<SWIGV8_ClientData *>(SWIGTYPE_p$jsbaseclass->clientdata)->class_templ)
     );
@ -379,6 +403,7 @@ fail:
 * ----------------------------------------------------------------------------- */
 %fragment("jsv8_create_class_instance", "templates")
 %{
+  /* Class: $jsname ($jsmangledname) */
  v8::Handle<v8::FunctionTemplate> $jsmangledname_class_0 = SWIGV8_CreateClassTemplate("$jsname");
  $jsmangledname_class_0->SetCallHandler($jsctor);
  $jsmangledname_class_0->Inherit($jsmangledname_class);
@ -394,7 +419,7 @@ fail:
 * ----------------------------------------------------------------------------- */
 %fragment("jsv8_register_class", "templates")
 %{
-  $jsparent_obj->Set(v8::String::NewSymbol("$jsname"), $jsmangledname_obj);
+  $jsparent_obj->Set(SWIGV8_SYMBOL_NEW("$jsname"), $jsmangledname_obj);
 %}

 /* -----------------------------------------------------------------------------
@ -403,7 +428,7 @@ fail:
 * ----------------------------------------------------------------------------- */
 %fragment("jsv8_create_namespace", "templates")
 %{
-  v8::Handle<v8::Object> $jsmangledname_obj = v8::Object::New();
+  v8::Handle<v8::Object> $jsmangledname_obj = SWIGV8_OBJECT_NEW();
 %}

 /* -----------------------------------------------------------------------------
@ -414,7 +439,7 @@ fail:
 * ----------------------------------------------------------------------------- */
 %fragment("jsv8_register_namespace", "templates")
 %{
-  $jsparent_obj->Set(v8::String::NewSymbol("$jsname"), $jsmangledname_obj);
+  $jsparent_obj->Set(SWIGV8_SYMBOL_NEW("$jsname"), $jsmangledname_obj);
 %}

 /* -----------------------------------------------------------------------------
--- a/Lib/javascript/v8/javascriptcomplex.swg
+++ b/Lib/javascript/v8/javascriptcomplex.swg
@ -15,12 +15,13 @@
 SWIGINTERNINLINE v8::Handle<v8::Value>
 SWIG_From_dec(Type)(%ifcplusplus(const Type&, Type) c)
 {
-  v8::HandleScope scope;
-  v8::Local<v8::Array> vals = v8::Array::New(2);
+  SWIGV8_HANDLESCOPE_ESC();
+
+  v8::Local<v8::Array> vals = SWIGV8_ARRAY_NEW(2);

  vals->Set(0, SWIG_From(double)(Real(c)));
  vals->Set(1, SWIG_From(double)(Imag(c)));
-  return scope.Close(vals);
+  SWIGV8_ESCAPE(vals);
 }
 }
 %enddef
@ -33,7 +34,7 @@ SWIG_From_dec(Type)(%ifcplusplus(const Type&, Type) c)
 SWIGINTERN int
 SWIG_AsVal_dec(Type) (v8::Handle<v8::Value> o, Type* val)
 {
-  v8::HandleScope scope;
+  SWIGV8_HANDLESCOPE();
  
  if (o->IsArray()) {
    v8::Handle<v8::Array> array = v8::Handle<v8::Array>::Cast(o);
@ -75,7 +76,7 @@ SWIG_AsVal_dec(Type) (v8::Handle<v8::Value> o, Type* val)
 SWIGINTERN int
 SWIG_AsVal_dec(Type) (v8::Handle<v8::Value> o, Type* val)
 {
-  v8::HandleScope scope;
+  SWIGV8_HANDLESCOPE();

  if (o->IsArray()) {
    v8::Handle<v8::Array> array = v8::Handle<v8::Array>::Cast(o);
--- a/Lib/javascript/v8/javascripthelpers.swg
+++ b/Lib/javascript/v8/javascripthelpers.swg
@ -1,7 +1,7 @@
 %insert(runtime) %{

 // Note: since 3.19 there are new CallBack types, since 03.21.9 the old ones have been removed
-#if SWIG_V8_VERSION < 0x031900
+#if (SWIG_V8_VERSION < 0x031903)
 typedef v8::InvocationCallback  SwigV8FunctionCallback;
 typedef v8::AccessorGetter      SwigV8AccessorGetterCallback;
 typedef v8::AccessorSetter      SwigV8AccessorSetterCallback;
@ -17,20 +17,21 @@ typedef v8::PropertyCallbackInfo<void>  SwigV8PropertyCallbackInfoVoid;
 * Creates a class template for a class with specified initialization function.
 */
 SWIGRUNTIME v8::Handle<v8::FunctionTemplate> SWIGV8_CreateClassTemplate(const char* symbol) {
-    v8::HandleScope scope;
-    v8::Local<v8::FunctionTemplate> class_templ = v8::FunctionTemplate::New();
-    class_templ->SetClassName(v8::String::NewSymbol(symbol));
+    SWIGV8_HANDLESCOPE_ESC();
+    
+    v8::Local<v8::FunctionTemplate> class_templ = SWIGV8_FUNCTEMPLATE_NEW_VOID();
+    class_templ->SetClassName(SWIGV8_SYMBOL_NEW(symbol));

    v8::Handle<v8::ObjectTemplate> inst_templ = class_templ->InstanceTemplate();
    inst_templ->SetInternalFieldCount(1);

    v8::Handle<v8::ObjectTemplate> equals_templ = class_templ->PrototypeTemplate();
-    equals_templ->Set(v8::String::NewSymbol("equals"), v8::FunctionTemplate::New(_SWIGV8_wrap_equals));
+    equals_templ->Set(SWIGV8_SYMBOL_NEW("equals"), SWIGV8_FUNCTEMPLATE_NEW(_SWIGV8_wrap_equals));

    v8::Handle<v8::ObjectTemplate> cptr_templ = class_templ->PrototypeTemplate();
-    cptr_templ->Set(v8::String::NewSymbol("getCPtr"), v8::FunctionTemplate::New(_wrap_getCPtr));
+    cptr_templ->Set(SWIGV8_SYMBOL_NEW("getCPtr"), SWIGV8_FUNCTEMPLATE_NEW(_wrap_getCPtr));

-    return scope.Close(class_templ);
+    SWIGV8_ESCAPE(class_templ);
 }

 /**
@ -39,7 +40,7 @@ SWIGRUNTIME v8::Handle<v8::FunctionTemplate> SWIGV8_CreateClassTemplate(const ch
 SWIGRUNTIME void SWIGV8_AddMemberFunction(v8::Handle<v8::FunctionTemplate> class_templ, const char* symbol,
  SwigV8FunctionCallback _func) {
    v8::Handle<v8::ObjectTemplate> proto_templ = class_templ->PrototypeTemplate();
-    proto_templ->Set(v8::String::NewSymbol(symbol), v8::FunctionTemplate::New(_func));
+    proto_templ->Set(SWIGV8_SYMBOL_NEW(symbol), SWIGV8_FUNCTEMPLATE_NEW(_func));
 }

 /**
@ -48,7 +49,7 @@ SWIGRUNTIME void SWIGV8_AddMemberFunction(v8::Handle<v8::FunctionTemplate> class
 SWIGRUNTIME void SWIGV8_AddMemberVariable(v8::Handle<v8::FunctionTemplate> class_templ, const char* symbol,
  SwigV8AccessorGetterCallback getter, SwigV8AccessorSetterCallback setter) {
  v8::Handle<v8::ObjectTemplate> proto_templ = class_templ->InstanceTemplate();
-  proto_templ->SetAccessor(v8::String::NewSymbol(symbol), getter, setter);
+  proto_templ->SetAccessor(SWIGV8_SYMBOL_NEW(symbol), getter, setter);
 }

 /**
@ -56,7 +57,7 @@ SWIGRUNTIME void SWIGV8_AddMemberVariable(v8::Handle<v8::FunctionTemplate> class
 */
 SWIGRUNTIME void SWIGV8_AddStaticFunction(v8::Handle<v8::Object> obj, const char* symbol,
  const SwigV8FunctionCallback& _func) {
-  obj->Set(v8::String::NewSymbol(symbol), v8::FunctionTemplate::New(_func)->GetFunction());
+  obj->Set(SWIGV8_SYMBOL_NEW(symbol), SWIGV8_FUNCTEMPLATE_NEW(_func)->GetFunction());
 }

 /**
@ -64,7 +65,7 @@ SWIGRUNTIME void SWIGV8_AddStaticFunction(v8::Handle<v8::Object> obj, const char
 */
 SWIGRUNTIME void SWIGV8_AddStaticVariable(v8::Handle<v8::Object> obj, const char* symbol,
  SwigV8AccessorGetterCallback getter, SwigV8AccessorSetterCallback setter) {
-  obj->SetAccessor(v8::String::NewSymbol(symbol), getter, setter);
+  obj->SetAccessor(SWIGV8_SYMBOL_NEW(symbol), getter, setter);
 }

 SWIGRUNTIME void JS_veto_set_variable(v8::Local<v8::String> property, v8::Local<v8::Value> value,
--- a/Lib/javascript/v8/javascriptinit.swg
+++ b/Lib/javascript/v8/javascriptinit.swg
@ -4,16 +4,16 @@

 SWIGRUNTIME void
 SWIG_V8_SetModule(void *, swig_module_info *swig_module) {
-  v8::Local<v8::Object> global_obj = v8::Context::GetCurrent()->Global();
-  v8::Local<v8::External> mod = v8::External::New(swig_module);
+  v8::Local<v8::Object> global_obj = SWIGV8_CURRENT_CONTEXT()->Global();
+  v8::Local<v8::External> mod = SWIGV8_EXTERNAL_NEW(swig_module);
  assert(!mod.IsEmpty());
-  global_obj->SetHiddenValue(v8::String::New("swig_module_info_data"), mod);
+  global_obj->SetHiddenValue(SWIGV8_STRING_NEW("swig_module_info_data"), mod);
 }

 SWIGRUNTIME swig_module_info *
 SWIG_V8_GetModule(void *) {
-  v8::Local<v8::Object> global_obj = v8::Context::GetCurrent()->Global();
-  v8::Local<v8::Value> moduleinfo = global_obj->GetHiddenValue(v8::String::New("swig_module_info_data"));
+  v8::Local<v8::Object> global_obj = SWIGV8_CURRENT_CONTEXT()->Global();
+  v8::Local<v8::Value> moduleinfo = global_obj->GetHiddenValue(SWIGV8_STRING_NEW("swig_module_info_data"));

  if (moduleinfo.IsEmpty())
  {
@ -61,7 +61,8 @@ void SWIGV8_INIT (v8::Handle<v8::Object> exports, v8::Handle<v8::Object> /*modul
 {
  SWIG_InitializeModule(static_cast<void *>(&exports));

-  v8::HandleScope scope;
+  SWIGV8_HANDLESCOPE();
+  
  v8::Handle<v8::Object> exports_obj = exports;
 %}

@ -81,11 +82,7 @@ void SWIGV8_INIT (v8::Handle<v8::Object> exports, v8::Handle<v8::Object> /*modul
 %fragment("js_initializer", "templates")
 %{
  // a class template for creating proxies of undefined types
-#if (SWIG_V8_VERSION < 0x031900)
-  SWIGV8_SWIGTYPE_Proxy_class_templ = v8::Persistent<v8::FunctionTemplate>::New(SWIGV8_CreateClassTemplate("SwigProxy"));
-#else
-  SWIGV8_SWIGTYPE_Proxy_class_templ.Reset(v8::Isolate::GetCurrent(), SWIGV8_CreateClassTemplate("SwigProxy"));
-#endif
+  SWIGV8_SET_CLASS_TEMPL(SWIGV8_SWIGTYPE_Proxy_class_templ, SWIGV8_CreateClassTemplate("SwigProxy"));

  /* create objects for namespaces */
  $jsv8nspaces
--- a/Lib/javascript/v8/javascriptprimtypes.swg
+++ b/Lib/javascript/v8/javascriptprimtypes.swg
@ -9,7 +9,7 @@ SWIGINTERNINLINE
 v8::Handle<v8::Value>
 SWIG_From_dec(bool)(bool value)
 {
-  return v8::Boolean::New(value);
+  return SWIGV8_BOOLEAN_NEW(value);
 }
 }

@ -33,7 +33,7 @@ int SWIG_AsVal_dec(bool)(v8::Handle<v8::Value> obj, bool *val)
 SWIGINTERNINLINE
 v8::Handle<v8::Value> SWIG_From_dec(int)(int value)
 {
-  return v8::Int32::New(value);
+  return SWIGV8_INT32_NEW(value);
 }
 }

@ -56,7 +56,7 @@ int SWIG_AsVal_dec(int)(v8::Handle<v8::Value> valRef, int* val)
 SWIGINTERNINLINE
 v8::Handle<v8::Value> SWIG_From_dec(long)(long value)
 {
-  return v8::Number::New(value);
+  return SWIGV8_NUMBER_NEW(value);
 }
 }

@ -82,7 +82,7 @@ SWIGINTERNINLINE
 v8::Handle<v8::Value> SWIG_From_dec(unsigned long)(unsigned long value)
 {
  return (value > LONG_MAX) ?
-    v8::Integer::NewFromUnsigned(value) : v8::Integer::New(%numeric_cast(value,long));
+    SWIGV8_INTEGER_NEW_UNS(value) : SWIGV8_INTEGER_NEW(%numeric_cast(value,long));
 }
 }

@ -116,7 +116,7 @@ int SWIG_AsVal_dec(unsigned long)(v8::Handle<v8::Value> obj, unsigned long *val)
 SWIGINTERNINLINE
 v8::Handle<v8::Value> SWIG_From_dec(long long)(long long value)
 {
-  return v8::Number::New(value);
+  return SWIGV8_NUMBER_NEW(value);
 }
 }

@ -146,7 +146,7 @@ SWIGINTERNINLINE
 v8::Handle<v8::Value> SWIG_From_dec(unsigned long long)(unsigned long long value)
 {
  return (value > LONG_MAX) ?
-    v8::Integer::NewFromUnsigned(value) : v8::Integer::New(%numeric_cast(value,long));
+    SWIGV8_INTEGER_NEW_UNS(value) : SWIGV8_INTEGER_NEW(%numeric_cast(value,long));
 }
 }

@ -179,7 +179,7 @@ int SWIG_AsVal_dec(unsigned long long)(v8::Handle<v8::Value> obj, unsigned long
 SWIGINTERN
 v8::Handle<v8::Value> SWIG_From_dec(double) (double val)
 {
-  return v8::Number::New(val);
+  return SWIGV8_NUMBER_NEW(val);
 }
 }

--- a/Lib/javascript/v8/javascriptrun.swg
+++ b/Lib/javascript/v8/javascriptrun.swg
@ -1,3 +1,96 @@
+/* ---------------------------------------------------------------------------
+ * These typedefs and defines are used to deal with v8 API changes
+ *
+ * ---------------------------------------------------------------------------*/
+
+// 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;
+typedef v8::Arguments SwigV8Arguments;
+typedef v8::AccessorInfo SwigV8PropertyCallbackInfo;
+#define SWIGV8_RETURN(val) return scope.Close(val)
+#define SWIGV8_RETURN_INFO(val, info) return scope.Close(val)
+#else
+typedef void SwigV8ReturnValue;
+typedef v8::FunctionCallbackInfo<v8::Value> SwigV8Arguments;
+typedef v8::PropertyCallbackInfo<v8::Value> SwigV8PropertyCallbackInfo;
+#define SWIGV8_RETURN(val) args.GetReturnValue().Set(val); return
+#define SWIGV8_RETURN_INFO(val, info) info.GetReturnValue().Set(val); return
+#endif
+
+#if (SWIG_V8_VERSION < 0x032117)
+#define SWIGV8_HANDLESCOPE() v8::HandleScope scope
+#define SWIGV8_HANDLESCOPE_ESC() v8::HandleScope scope
+#define SWIGV8_ESCAPE(val) return scope.Close(val)
+#elif (SWIG_V8_VERSION < 0x032224)
+#define SWIGV8_HANDLESCOPE() v8::HandleScope scope(v8::Isolate::GetCurrent());
+#define SWIGV8_HANDLESCOPE_ESC() v8::HandleScope scope(v8::Isolate::GetCurrent());
+#define SWIGV8_ESCAPE(val) return scope.Close(val)
+#else
+#define SWIGV8_HANDLESCOPE() v8::HandleScope scope(v8::Isolate::GetCurrent());
+#define SWIGV8_HANDLESCOPE_ESC() v8::EscapableHandleScope scope(v8::Isolate::GetCurrent());
+#define SWIGV8_ESCAPE(val) return scope.Escape(val)
+#endif
+
+#if (SWIG_V8_VERSION < 0x032224)
+#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_ADJUST_MEMORY(size) v8::Isolate::GetCurrent()->AdjustAmountOfExternalAllocatedMemory(size)
+#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 < 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_UNDEFINED() v8::Undefined()
+#define SWIGV8_NULL() v8::Null()
+#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_UNDEFINED() v8::Undefined(v8::Isolate::GetCurrent())
+#define SWIGV8_NULL() v8::Null(v8::Isolate::GetCurrent())
+#endif
+
+#if (SWIG_V8_VERSION < 0x031710)
+#define SWIGV8_SET_CLASS_TEMPL(class_templ, class) class_templ = v8::Persistent<v8::FunctionTemplate>::New(class);
+#elif (SWIG_V8_VERSION < 0x031900)
+#define SWIGV8_SET_CLASS_TEMPL(class_templ, class) class_templ = v8::Persistent<v8::FunctionTemplate>::New(v8::Isolate::GetCurrent(), class);
+#else
+#define SWIGV8_SET_CLASS_TEMPL(class_templ, class) class_templ.Reset(v8::Isolate::GetCurrent(), class);
+#endif
+
 /* ---------------------------------------------------------------------------
 * Error handling
 *
@ -8,8 +101,8 @@
 #define SWIG_fail                 goto fail
 #define SWIGV8_OVERLOAD false

-void SWIG_V8_Raise(const char* msg) {
-  v8::ThrowException(v8::Exception::Error(v8::String::New(msg)));
+static void SWIG_V8_Raise(const char *msg) {
+  SWIGV8_THROW_EXCEPTION(v8::Exception::Error(SWIGV8_STRING_NEW(msg)));
 }

 /*
@ -28,42 +121,25 @@ 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);
  }
 };
 // this is used in usually
-V8ErrorHandler SWIGV8_ErrorHandler;
+static V8ErrorHandler SWIGV8_ErrorHandler;

 // instances of this are used in overloaded functions
 class OverloadErrorHandler: public V8ErrorHandler {
 public:
-  virtual void error(int code, const char* msg) {
-    err = v8::Exception::Error(v8::String::New(msg));
+  virtual void error(int code, const char *msg) {
+    err = v8::Exception::Error(SWIGV8_STRING_NEW(msg));
    if(code != SWIG_TypeError) {
-      v8::ThrowException(err);
+        SWIGV8_THROW_EXCEPTION(err);
    }
  }
  v8::Handle<v8::Value> err;
 };

-// Note: these typedefs and defines are used to deal with  v8 API changes since version 3.19.00
-
-#if (SWIG_V8_VERSION < 0x031900)
-typedef v8::Handle<v8::Value> SwigV8ReturnValue;
-typedef v8::Arguments SwigV8Arguments;
-typedef v8::AccessorInfo SwigV8PropertyCallbackInfo;
-#define SWIGV8_RETURN(val) return scope.Close(val)
-#define SWIGV8_RETURN_INFO(val, info) return scope.Close(val)
-#else
-typedef void SwigV8ReturnValue;
-typedef v8::FunctionCallbackInfo<v8::Value> SwigV8Arguments;
-typedef v8::PropertyCallbackInfo<v8::Value> SwigV8PropertyCallbackInfo;
-#define SWIGV8_RETURN(val) args.GetReturnValue().Set(val); return
-#define SWIGV8_RETURN_INFO(val, info) info.GetReturnValue().Set(val); return
-#endif
-
-
 /* ---------------------------------------------------------------------------
 * Basic Proxy object
 *
@ -76,20 +152,29 @@ typedef v8::PropertyCallbackInfo<v8::Value> SwigV8PropertyCallbackInfo;
 class SWIGV8_Proxy {
 public:
  SWIGV8_Proxy(): swigCMemOwn(false), swigCObject(0), info(0) {
-    v8::V8::AdjustAmountOfExternalAllocatedMemory(SWIGV8_AVG_OBJ_SIZE);
+    SWIGV8_ADJUST_MEMORY(SWIGV8_AVG_OBJ_SIZE);
  };

  ~SWIGV8_Proxy() {
-#if (SWIG_V8_VERSION < 0x031900 || SWIG_V8_VERSION >= 0x032100)
+#if (SWIG_V8_VERSION < 0x031710)
    handle.ClearWeak();
    handle.Dispose();
-#else
+#elif (SWIG_V8_VERSION < 0x032100)
    handle.ClearWeak(v8::Isolate::GetCurrent());
    handle.Dispose(v8::Isolate::GetCurrent());
+#elif (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
+    handle.ClearWeak();
+    handle.Dispose();
+#else    
+    handle.ClearWeak();
+    handle.Reset();
 #endif

+#if (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
    handle.Clear();
-    v8::V8::AdjustAmountOfExternalAllocatedMemory(-SWIGV8_AVG_OBJ_SIZE);
+#endif
+
+    SWIGV8_ADJUST_MEMORY(-SWIGV8_AVG_OBJ_SIZE);
  }

  bool swigCMemOwn;
@ -102,21 +187,25 @@ class SWIGV8_ClientData {
 public:
  v8::Persistent<v8::FunctionTemplate> class_templ;

-#if (SWIG_V8_VERSION < 0x031900)
+#if (SWIG_V8_VERSION < 0x031710)
  void (*dtor) (v8::Persistent< v8::Value> object, void *parameter);
-#else
+#elif (SWIG_V8_VERSION < 0x031900)
+  void (*dtor) (v8::Isolate *isolate, v8::Persistent< v8::Value> object, void *parameter);
+#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);
 #endif
 };

-v8::Persistent<v8::FunctionTemplate> SWIGV8_SWIGTYPE_Proxy_class_templ;
+static 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) {
-  v8::HandleScope scope;
+static 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;

-#if (SWIG_V8_VERSION < 0x031900)
+#if (SWIG_V8_VERSION < 0x031511)
  v8::Handle<v8::Value> cdataRef = objRef->GetInternalField(0);
  SWIGV8_Proxy *cdata = static_cast<SWIGV8_Proxy *>(v8::External::Unwrap(cdataRef));
 #else
@ -143,20 +232,24 @@ int SWIG_V8_ConvertInstancePtr(v8::Handle<v8::Object> objRef, void** ptr, swig_t
  return SWIG_OK;
 }

-#if (SWIG_V8_VERSION < 0x031900)
-void SWIGV8_Proxy_DefaultDtor(v8::Persistent< v8::Value > object, void *parameter)
-#else
-void SWIGV8_Proxy_DefaultDtor(v8::Isolate *, v8::Persistent< v8::Object > *object, SWIGV8_Proxy *proxy)
-#endif
-{
-#if (SWIG_V8_VERSION < 0x031900)
+
+#if (SWIG_V8_VERSION < 0x031710)
+static void SWIGV8_Proxy_DefaultDtor(v8::Persistent< v8::Value > object, void *parameter) {
  SWIGV8_Proxy *proxy = static_cast<SWIGV8_Proxy *>(parameter);
+#elif (SWIG_V8_VERSION < 0x031900)
+static 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 < SWIGV8_SETWEAK_VERSION)
+static void SWIGV8_Proxy_DefaultDtor(v8::Isolate *, v8::Persistent< v8::Object > *object, SWIGV8_Proxy *proxy) {
+#else
+static void SWIGV8_Proxy_DefaultDtor(const v8::WeakCallbackData<v8::Object, SWIGV8_Proxy> &data) {
+  SWIGV8_Proxy *proxy = data.GetParameter();
 #endif

  delete proxy;
 }

-int SWIG_V8_GetInstancePtr(v8::Handle<v8::Value> valRef, void** ptr) {
+static int SWIG_V8_GetInstancePtr(v8::Handle<v8::Value> valRef, void **ptr) {
  if(!valRef->IsObject()) {
    return SWIG_TypeError;
  }
@ -164,7 +257,7 @@ int SWIG_V8_GetInstancePtr(v8::Handle<v8::Value> valRef, void** ptr) {

  if(objRef->InternalFieldCount() < 1) return SWIG_ERROR;

-#if (SWIG_V8_VERSION < 0x031900)
+#if (SWIG_V8_VERSION < 0x031511)
  v8::Handle<v8::Value> cdataRef = objRef->GetInternalField(0);
  SWIGV8_Proxy *cdata = static_cast<SWIGV8_Proxy *>(v8::External::Unwrap(cdataRef));
 #else
@ -180,46 +273,66 @@ 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();
+static 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;

-#if (SWIG_V8_VERSION < 0x031900)
+#if (SWIG_V8_VERSION < 0x031511)
  obj->SetPointerInInternalField(0, cdata);
-  cdata->handle = v8::Persistent<v8::Object>::New(obj);
 #else
  obj->SetAlignedPointerInInternalField(0, cdata);
+#endif
+
+#if (SWIG_V8_VERSION < 0x031710)
+  cdata->handle = v8::Persistent<v8::Object>::New(obj);
+#elif (SWIG_V8_VERSION < 0x031900)
+  cdata->handle = v8::Persistent<v8::Object>::New(v8::Isolate::GetCurrent(), obj);
+#else
  cdata->handle.Reset(v8::Isolate::GetCurrent(), obj);
 #endif

-#if (SWIG_V8_VERSION < 0x031900)
+#if (SWIG_V8_VERSION < 0x031710)
  // clientdata must be set for owned data as we need to register the dtor
  if(cdata->swigCMemOwn && (SWIGV8_ClientData*)info->clientdata) {
    cdata->handle.MakeWeak(cdata, ((SWIGV8_ClientData*)info->clientdata)->dtor);
  } else {
    cdata->handle.MakeWeak(cdata, SWIGV8_Proxy_DefaultDtor);
  }
-  cdata->handle.MarkIndependent();
-#else
+#elif (SWIG_V8_VERSION < 0x031918)
  if(cdata->swigCMemOwn && (SWIGV8_ClientData*)info->clientdata) {
    cdata->handle.MakeWeak(v8::Isolate::GetCurrent(), cdata, ((SWIGV8_ClientData*)info->clientdata)->dtor);
  } else {
    cdata->handle.MakeWeak(v8::Isolate::GetCurrent(), cdata, SWIGV8_Proxy_DefaultDtor);
  }
+#elif (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
+  if(cdata->swigCMemOwn && (SWIGV8_ClientData*)info->clientdata) {
+    cdata->handle.MakeWeak(cdata, ((SWIGV8_ClientData*)info->clientdata)->dtor);
+  } else {
+    cdata->handle.MakeWeak(cdata, SWIGV8_Proxy_DefaultDtor);
+  }
+#else
+  if(cdata->swigCMemOwn && (SWIGV8_ClientData*)info->clientdata) {
+    cdata->handle.SetWeak(cdata, ((SWIGV8_ClientData*)info->clientdata)->dtor);
+  } else {
+    cdata->handle.SetWeak(cdata, SWIGV8_Proxy_DefaultDtor);
+  }
+#endif

-#if (SWIG_V8_VERSION < 0x032100)
+#if (SWIG_V8_VERSION < 0x031710)
+  cdata->handle.MarkIndependent();
+#elif (SWIG_V8_VERSION < 0x032100)
  cdata->handle.MarkIndependent(v8::Isolate::GetCurrent());
 #else
  cdata->handle.MarkIndependent();
 #endif

-#endif
 }

-int SWIG_V8_ConvertPtr(v8::Handle<v8::Value> valRef, void** ptr, swig_type_info *info, int flags) {
-  v8::HandleScope scope;
+static 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 */
  if(valRef->IsNull()) {
    *ptr=0;
@ -232,34 +345,41 @@ int SWIG_V8_ConvertPtr(v8::Handle<v8::Value> valRef, void** ptr, swig_type_info
  return SWIG_V8_ConvertInstancePtr(objRef, ptr, info, flags);
 }

-v8::Handle<v8::Value> SWIG_V8_NewPointerObj(void *ptr, swig_type_info *info, int flags) {
-  v8::HandleScope scope;
+static v8::Handle<v8::Value> SWIG_V8_NewPointerObj(void *ptr, swig_type_info *info, int flags) {
+  SWIGV8_HANDLESCOPE_ESC();
+  
  v8::Handle<v8::FunctionTemplate> class_templ;

  if (ptr == NULL) {
-    return scope.Close(v8::Null());
+#if (SWIG_V8_VERSION < 0x031903)
+    SWIGV8_ESCAPE(SWIGV8_NULL());
+#else    
+    v8::Local<v8::Primitive> result = SWIGV8_NULL();
+    SWIGV8_ESCAPE(result);
+#endif    
  }

-#if (SWIG_V8_VERSION < 0x031900)
+#if (SWIG_V8_VERSION < 0x031903)
  if(info->clientdata != 0) {
    class_templ = ((SWIGV8_ClientData*) info->clientdata)->class_templ;
  } else {
    class_templ = SWIGV8_SWIGTYPE_Proxy_class_templ;
  }
 #else
-  v8::Isolate *iso = v8::Isolate::GetCurrent();
+  v8::Isolate *isolate = v8::Isolate::GetCurrent();

  if(info->clientdata != 0) {
-    class_templ = v8::Handle<v8::FunctionTemplate>::New(iso, ((SWIGV8_ClientData*) info->clientdata)->class_templ);
+    class_templ = v8::Local<v8::FunctionTemplate>::New(isolate, ((SWIGV8_ClientData*) info->clientdata)->class_templ);
  } else {
-    class_templ = v8::Handle<v8::FunctionTemplate>::New(iso, SWIGV8_SWIGTYPE_Proxy_class_templ);
+    class_templ = v8::Local<v8::FunctionTemplate>::New(isolate, SWIGV8_SWIGTYPE_Proxy_class_templ);
  }
 #endif

-  v8::Handle<v8::Object> result = class_templ->InstanceTemplate()->NewInstance();
+//  v8::Handle<v8::Object> result = class_templ->InstanceTemplate()->NewInstance();
+  v8::Local<v8::Object> result = class_templ->InstanceTemplate()->NewInstance();
  SWIGV8_SetPrivateData(result, ptr, info, flags);

-  return scope.Close(result);
+  SWIGV8_ESCAPE(result);
 }

 #define SWIG_ConvertPtr(obj, ptr, info, flags)    SWIG_V8_ConvertPtr(obj, ptr, info, flags)
@ -273,12 +393,9 @@ v8::Handle<v8::Value> SWIG_V8_NewPointerObj(void *ptr, swig_type_info *info, int

 #define SWIG_GetInstancePtr(obj, ptr)    SWIG_V8_GetInstancePtr(obj, ptr)

-#if (SWIG_V8_VERSION < 0x031900)
-v8::Handle<v8::Value> _SWIGV8_wrap_equals(const v8::Arguments &args) {
-#else
-void _SWIGV8_wrap_equals(const v8::FunctionCallbackInfo<v8::Value>& args) {
-#endif
-  v8::HandleScope scope;
+static SwigV8ReturnValue _SWIGV8_wrap_equals(const SwigV8Arguments &args) {
+  SWIGV8_HANDLESCOPE();
+  
  v8::Handle<v8::Value> jsresult;
  void *arg1 = (void *) 0 ;
  void *arg2 = (void *) 0 ;
@ -298,20 +415,17 @@ void _SWIGV8_wrap_equals(const v8::FunctionCallbackInfo<v8::Value>& args) {
  }

  result = (bool)(arg1 == arg2);
-  jsresult =  v8::Boolean::New(result);
+  jsresult =  SWIGV8_BOOLEAN_NEW(result);

  SWIGV8_RETURN(jsresult);
  goto fail;
 fail:
-  SWIGV8_RETURN(v8::Undefined());
+  SWIGV8_RETURN(SWIGV8_UNDEFINED());
 }

-#if (SWIG_V8_VERSION < 0x031900)
-v8::Handle<v8::Value> _wrap_getCPtr(const v8::Arguments &args) {
-#else
-void _wrap_getCPtr(const v8::FunctionCallbackInfo<v8::Value>& args) {
-#endif
-  v8::HandleScope scope;
+static SwigV8ReturnValue _wrap_getCPtr(const SwigV8Arguments &args) {
+  SWIGV8_HANDLESCOPE();
+  
  v8::Handle<v8::Value> jsresult;
  void *arg1 = (void *) 0 ;
  long result;
@ -323,12 +437,12 @@ void _wrap_getCPtr(const v8::FunctionCallbackInfo<v8::Value>& args) {
  }

  result = (long)arg1;
-  jsresult = v8::Number::New(result);
+  jsresult = SWIGV8_NUMBER_NEW(result);

  SWIGV8_RETURN(jsresult);
  goto fail;
 fail:
-  SWIGV8_RETURN(v8::Undefined());
+  SWIGV8_RETURN(SWIGV8_UNDEFINED());
 }

 /* ---------------------------------------------------------------------------
@ -343,7 +457,7 @@ public:
  ~SwigV8PackedData() {
  };

-  void* data;
+  void *data;
  size_t size;
  swig_type_info *type;

@ -352,22 +466,24 @@ public:

 SWIGRUNTIMEINLINE
 int SwigV8Packed_Check(v8::Handle<v8::Value> valRef) {
-  v8::HandleScope scope;
+  SWIGV8_HANDLESCOPE();
+  
  v8::Handle<v8::Object> objRef = valRef->ToObject();
  if(objRef->InternalFieldCount() < 1) return false;
-  v8::Handle<v8::Value> flag = objRef->GetHiddenValue(v8::String::New("__swig__packed_data__"));
+  v8::Handle<v8::Value> flag = objRef->GetHiddenValue(SWIGV8_STRING_NEW("__swig__packed_data__"));
  return (flag->IsBoolean() && flag->BooleanValue());
 }

 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)) {
-    v8::HandleScope scope;
+    SWIGV8_HANDLESCOPE();
+    
    SwigV8PackedData *sobj;

    v8::Handle<v8::Object> objRef = valRef->ToObject();

-#if (SWIG_V8_VERSION < 0x031900)
+#if (SWIG_V8_VERSION < 0x031511)
    v8::Handle<v8::Value> cdataRef = objRef->GetInternalField(0);
    sobj = static_cast<SwigV8PackedData*>(v8::External::Unwrap(cdataRef));
 #else
@ -395,57 +511,82 @@ int SWIGV8_ConvertPacked(v8::Handle<v8::Value> valRef, void *ptr, size_t sz, swi
  return SWIG_OK;
 }

-#if (SWIG_V8_VERSION < 0x031900)
-void _wrap_SwigV8PackedData_delete(v8::Persistent< v8::Value > object, void *parameter)
-{
+#if (SWIG_V8_VERSION < 0x031710)
+static void _wrap_SwigV8PackedData_delete(v8::Persistent< v8::Value > object, void *parameter) {
  SwigV8PackedData *cdata = static_cast<SwigV8PackedData *>(parameter);
+#elif (SWIG_V8_VERSION < 0x031900)
+static void _wrap_SwigV8PackedData_delete(v8::Isolate *isolate, v8::Persistent<v8::Value> object, void *parameter) {
+  SwigV8PackedData *cdata = static_cast<SwigV8PackedData *>(parameter);
+#elif (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
+static void _wrap_SwigV8PackedData_delete(v8::Isolate *isolate, v8::Persistent<v8::Object> *object, SwigV8PackedData *cdata) {
 #else
-void _wrap_SwigV8PackedData_delete(v8::Isolate *isolate, v8::Persistent< v8::Object > * object, SwigV8PackedData *cdata)
-{
+static void _wrap_SwigV8PackedData_delete(const v8::WeakCallbackData<v8::Object, SwigV8PackedData> &data) {
+  v8::Local<v8::Object> object = data.GetValue();
+  SwigV8PackedData *cdata = data.GetParameter();
 #endif

  delete cdata;

-#if (SWIG_V8_VERSION < 0x031900)
+#if (SWIG_V8_VERSION < 0x031710)
  object.Clear();
  object.Dispose();
+#elif (SWIG_V8_VERSION < 0x031900)
+  object.Clear();
+  object.Dispose(isolate);
 #elif (SWIG_V8_VERSION < 0x032100)
  object->Dispose(isolate);
-#else
+#elif (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
  object->Dispose();
+#else
+  object.Clear();
 #endif
 }

 SWIGRUNTIME
 v8::Handle<v8::Value> SWIGV8_NewPackedObj(void *data, size_t size, swig_type_info *type) {
-  v8::HandleScope scope;
+  SWIGV8_HANDLESCOPE_ESC();

-  SwigV8PackedData* cdata = new SwigV8PackedData(data, size, type);
-  v8::Handle<v8::Object> obj = v8::Object::New();
+  SwigV8PackedData *cdata = new SwigV8PackedData(data, size, type);
+//  v8::Handle<v8::Object> obj = SWIGV8_OBJECT_NEW();
+  v8::Local<v8::Object> obj = SWIGV8_OBJECT_NEW();

-  obj->SetHiddenValue(v8::String::New("__swig__packed_data__"), v8::Boolean::New(true));
+  obj->SetHiddenValue(SWIGV8_STRING_NEW("__swig__packed_data__"), SWIGV8_BOOLEAN_NEW(true));

-#if (SWIG_V8_VERSION < 0x031900)
+#if (SWIG_V8_VERSION < 0x031511)
  obj->SetPointerInInternalField(0, cdata);
-  cdata->handle = v8::Persistent<v8::Object>::New(obj);
 #else
  obj->SetAlignedPointerInInternalField(0, cdata);
+#endif
+
+#if (SWIG_V8_VERSION < 0x031710)
+  cdata->handle = v8::Persistent<v8::Object>::New(obj);
+#elif (SWIG_V8_VERSION < 0x031900)
+  cdata->handle = v8::Persistent<v8::Object>::New(v8::Isolate::GetCurrent(), obj);
+#else
  cdata->handle.Reset(v8::Isolate::GetCurrent(), obj);
 #endif

-#if (SWIG_V8_VERSION < 0x031900)
+
+#if (SWIG_V8_VERSION < 0x031710)
  cdata->handle.MakeWeak(cdata, _wrap_SwigV8PackedData_delete);
-  cdata->handle.MarkIndependent();
-#else
+#elif (SWIG_V8_VERSION < 0x031918)
  cdata->handle.MakeWeak(v8::Isolate::GetCurrent(), cdata, _wrap_SwigV8PackedData_delete);
-# if (SWIG_V8_VERSION < 0x032100)
-  cdata->handle.MarkIndependent(v8::Isolate::GetCurrent());
-# else
-  cdata->handle.MarkIndependent();
-# endif
+#elif (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
+  cdata->handle.MakeWeak(cdata, _wrap_SwigV8PackedData_delete);
+#else
+  cdata->handle.SetWeak(cdata, _wrap_SwigV8PackedData_delete);
+//  v8::V8::SetWeak(&cdata->handle, cdata, _wrap_SwigV8PackedData_delete);
 #endif

-  return scope.Close(obj);
+#if (SWIG_V8_VERSION < 0x031710)
+  cdata->handle.MarkIndependent();
+#elif (SWIG_V8_VERSION < 0x032100)
+  cdata->handle.MarkIndependent(v8::Isolate::GetCurrent());
+#else
+  cdata->handle.MarkIndependent();
+#endif
+
+  SWIGV8_ESCAPE(obj);
 }

 #define SWIG_ConvertMember(obj, ptr, sz, ty)            SWIGV8_ConvertPacked(obj, ptr, sz, ty)
@ -458,13 +599,23 @@ v8::Handle<v8::Value> SWIGV8_NewPackedObj(void *data, size_t size, swig_type_inf
 * ---------------------------------------------------------------------------*/

 SWIGRUNTIME
+
+#if (SWIG_V8_VERSION < 0x031903)
 v8::Handle<v8::Value> SWIGV8_AppendOutput(v8::Handle<v8::Value> result, v8::Handle<v8::Value> obj) {
-  v8::HandleScope scope;
+#else
+v8::Handle<v8::Value> SWIGV8_AppendOutput(v8::Local<v8::Value> result, v8::Handle<v8::Value> obj) {
+#endif
+  SWIGV8_HANDLESCOPE_ESC();
+  
  if (result->IsUndefined()) {
-    result = v8::Array::New();
+    result = SWIGV8_ARRAY_NEW();
  }
+#if (SWIG_V8_VERSION < 0x031903)
  v8::Handle<v8::Array> arr = v8::Handle<v8::Array>::Cast(result);
+#else  
+  v8::Local<v8::Array> arr = v8::Local<v8::Array>::Cast(result);
+#endif  
  arr->Set(arr->Length(), obj);

-  return scope.Close(arr);
+  SWIGV8_ESCAPE(arr);
 }
--- a/Lib/javascript/v8/javascriptstrings.swg
+++ b/Lib/javascript/v8/javascriptstrings.swg
@ -47,13 +47,13 @@ SWIG_FromCharPtrAndSize(const char* carray, size_t size)
  if (carray) {
    if (size > INT_MAX) {
      // TODO: handle extra long strings
-      return v8::Undefined();
+      return SWIGV8_UNDEFINED();
    } else {
-      v8::Handle<v8::String> js_str = v8::String::New(carray, size);
+      v8::Handle<v8::String> js_str = SWIGV8_STRING_NEW2(carray, size);
      return js_str;
    }
  } else {
-    return v8::Undefined();
+    return SWIGV8_UNDEFINED();
  }
 }
 }
--- a/Lib/javascript/v8/javascripttypemaps.swg
+++ b/Lib/javascript/v8/javascripttypemaps.swg
@ -26,7 +26,7 @@
 /* Javascript types */

 #define SWIG_Object                     v8::Handle<v8::Value>
-#define VOID_Object                     v8::Undefined()
+#define VOID_Object                     SWIGV8_UNDEFINED()

 /* Overload of the output/constant/exception/dirout handling */

--- a/Lib/lua/lua.swg
+++ b/Lib/lua/lua.swg
@ -44,6 +44,9 @@
 %typemap(consttab) SWIGTYPE *, SWIGTYPE *const, SWIGTYPE &, SWIGTYPE &&, SWIGTYPE []
       { SWIG_LUA_CONSTTAB_POINTER("$symname",$value, $1_descriptor) }

+%typemap(consttab) SWIGTYPE
+       { SWIG_LUA_CONSTTAB_POINTER("$symname",&$value, $&1_descriptor) }
+
 // member function pointers
 %typemap(consttab) SWIGTYPE (CLASS::*)
       { SWIG_LUA_CONSTTAB_BINARY("$symname", sizeof($type),&$value, $1_descriptor) }
--- a/Lib/lua/luarun.swg
+++ b/Lib/lua/luarun.swg
@ -1161,7 +1161,7 @@ SWIGINTERN void SWIG_Lua_init_base_class(lua_State *L,swig_lua_class *clss)

 #if defined(SWIG_LUA_SQUASH_BASES) && (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA)
 /* Merges two tables  */
-SWIGINTERN int SWIG_Lua_merge_tables_by_index(lua_State *L, int target, int source)
+SWIGINTERN void SWIG_Lua_merge_tables_by_index(lua_State *L, int target, int source)
 {
  /* iterating */
  lua_pushnil(L);
@ -1177,7 +1177,7 @@ SWIGINTERN int SWIG_Lua_merge_tables_by_index(lua_State *L, int target, int sour
 }

 /* Merges two tables with given name. original - index of target metatable, base - index of source metatable */
-SWIGINTERN int SWIG_Lua_merge_tables(lua_State *L, const char* name, int original, int base)
+SWIGINTERN void SWIG_Lua_merge_tables(lua_State *L, const char* name, int original, int base)
 {
  /* push original[name], then base[name] */
  lua_pushstring(L,name);
@ -1192,7 +1192,7 @@ SWIGINTERN int SWIG_Lua_merge_tables(lua_State *L, const char* name, int origina
 }

 /* Function takes all symbols from base and adds it to derived class. It's just a helper. */
-SWIGINTERN int SWIG_Lua_class_squash_base(lua_State *L, swig_lua_class *base_cls)
+SWIGINTERN void SWIG_Lua_class_squash_base(lua_State *L, swig_lua_class *base_cls)
 {
  /* There is one parameter - original, i.e. 'derived' class metatable */
  assert(lua_istable(L,-1));
@ -1206,7 +1206,7 @@ SWIGINTERN int SWIG_Lua_class_squash_base(lua_State *L, swig_lua_class *base_cls
 }

 /* Function squashes all symbols from 'clss' bases into itself */
-SWIGINTERN int  SWIG_Lua_class_squash_bases(lua_State *L, swig_lua_class *clss)
+SWIGINTERN void  SWIG_Lua_class_squash_bases(lua_State *L, swig_lua_class *clss)
 {
  int i;
  SWIG_Lua_get_class_metatable(L,clss->fqname);
--- a/Lib/octave/boost_shared_ptr.i
+++ b/Lib/octave/boost_shared_ptr.i
@ -29,7 +29,8 @@
  }
 }
 %typemap(out) CONST TYPE {
-  %set_output(SWIG_NewPointerObj(new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(new $1_ltype(($1_ltype &)$1)), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
+  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(new $1_ltype(($1_ltype &)$1));
+  %set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
 }

 %typemap(varin) CONST TYPE {
@ -47,7 +48,8 @@
  }
 }
 %typemap(varout) CONST TYPE {
-  %set_varoutput(SWIG_NewPointerObj(new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(new $1_ltype(($1_ltype &)$1)), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
+  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(new $1_ltype(($1_ltype &)$1));
+  %set_varoutput(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
 }

 // plain pointer
--- a/Lib/octave/octrun.swg
+++ b/Lib/octave/octrun.swg
@ -578,26 +578,40 @@ SWIGRUNTIME void swig_acquire_ownership_obj(void *vptr, int own);
    swig_member_const_iterator swig_members_begin() { return members.begin(); }
    swig_member_const_iterator swig_members_end() { return members.end(); }

-    void *cast(swig_type_info *type, int *_own, int flags) {
+    int cast(void **vptr, swig_type_info *type, int *_own, int flags) {
+      int res = SWIG_ERROR;
      if (_own)
 	*_own = own;
      if (flags &SWIG_POINTER_DISOWN)
 	own = 0;
-      if (!type && types.size())
-	return types[0].second.ptr;
+      if (!type && types.size()) {
+	if(vptr)
+          *vptr = types[0].second.ptr;
+        return SWIG_OK;
+      }
      for (unsigned int j = 0; j < types.size(); ++j)
-	if (type == types[j].first)
-	  return types[j].second.ptr;
+	if (type == types[j].first) {
+	  if(vptr)
+            *vptr = types[j].second.ptr;
+          return SWIG_OK;
+        }
      for (unsigned int j = 0; j < types.size(); ++j) {
 	swig_cast_info *tc = SWIG_TypeCheck(types[j].first->name, type);
 	if (!tc)
 	  continue;
-	int newmemory = 0;
-	void *vptr = SWIG_TypeCast(tc, types[j].second.ptr, &newmemory);
-	assert(!newmemory);	// newmemory handling not yet implemented
-	return vptr;
+        if(vptr) {
+	  int newmemory = 0;
+	  *vptr = SWIG_TypeCast(tc, types[j].second.ptr, &newmemory);
+	    if (newmemory == SWIG_CAST_NEW_MEMORY) {
+              assert(_own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
+              if (_own)
+                *_own = *_own | SWIG_CAST_NEW_MEMORY;
+            }
+        }
+        res = SWIG_OK;
+        break;
      }
-      return 0;
+      return res;
    }

    bool is_owned() const {
@ -1327,12 +1341,7 @@ SWIGRUNTIME int SWIG_Octave_ConvertPtrAndOwn(octave_value ov, void **ptr, swig_t
    return SWIG_ERROR;
  octave_swig_ref *osr = static_cast < octave_swig_ref *>(ov.internal_rep());
  octave_swig_type *ost = osr->get_ptr();
-  void *vptr = ost->cast(type, own, flags);
-  if (!vptr)
-    return SWIG_ERROR;
-  if (ptr)
-    *ptr = vptr;
-  return SWIG_OK;
+  return ost->cast(ptr, type, own, flags);
 }

 SWIGRUNTIME octave_value SWIG_Octave_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
--- a/Lib/octave/std_shared_ptr.i
+++ b/Lib/octave/std_shared_ptr.i
@ -0,0 +1,2 @@
+#define SWIG_SHARED_PTR_NAMESPACE std
+%include <boost_shared_ptr.i>
--- a/Lib/perl5/perlinit.swg
+++ b/Lib/perl5/perlinit.swg
@ -21,7 +21,7 @@ SWIGEXPORT void SWIG_init (CV *cv, CPerlObj *);

 %init %{

-#ifdef __cplusplus
+#if defined(__cplusplus) && ! defined(XSPROTO)
 extern "C"
 #endif

--- a/Lib/php/const.i
+++ b/Lib/php/const.i
@ -14,7 +14,7 @@
                   signed char,
                   bool,
                   enum SWIGTYPE
-  "SWIG_LONG_CONSTANT($symname, $value);";
+  "SWIG_LONG_CONSTANT($symname, ($1_type)$value);";

 %typemap(consttab) float,
                   double
--- a/Lib/php/director.swg
+++ b/Lib/php/director.swg
@ -98,8 +98,7 @@ namespace Swig {
        TSRMLS_SET_CTX(swig_zts_ctx);
      }

-      bool swig_is_overridden_method(char *cname, char *lc_fname) {
-        TSRMLS_FETCH_FROM_CTX(swig_zts_ctx);
+      static bool swig_is_overridden_method(char *cname, char *lc_fname TSRMLS_DC) {
        zend_class_entry **ce;
        zend_function *mptr;

--- a/Lib/php/globalvar.i
+++ b/Lib/php/globalvar.i
@ -34,7 +34,7 @@
  zval *z_var;
  MAKE_STD_ZVAL(z_var);
  z_var->type = IS_LONG;
-  z_var->value.lval = $1;
+  z_var->value.lval = (long)$1;
  zend_hash_add(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void *)&z_var, sizeof(zval *), NULL);
 }

--- a/Lib/php/php.swg
+++ b/Lib/php/php.swg
@ -93,10 +93,12 @@

 %typemap(directorout) SWIGTYPE ($&1_ltype tmp)
 {
-	if(SWIG_ConvertPtr($input, (void **) &tmp, $&1_descriptor, 0) < 0 || tmp == NULL) {
-          SWIG_PHP_Error(E_ERROR, "Type error in argument $argnum of $symname. Expected $&1_descriptor");
+	/* If exit was via exception, PHP NULL is returned so skip the conversion. */
+	if (!EG(exception)) {
+	  if(SWIG_ConvertPtr($input, (void **) &tmp, $&1_descriptor, 0) < 0 || tmp == NULL)
+	    SWIG_PHP_Error(E_ERROR, "Type error in argument $argnum of $symname. Expected $&1_descriptor");
+	  $result = *tmp;
 	}
-	$result = *tmp;
 }

 %typemap(in) SWIGTYPE *,
--- a/Lib/php/phpkw.swg
+++ b/Lib/php/phpkw.swg
@ -625,6 +625,28 @@ PHPBN2(MYSQLI_SERVER_PUBLIC_KEY);
 /* Added in PHP 5.6 */
 PHPBN2(LDAP_ESCAPE_DN);
 PHPBN2(LDAP_ESCAPE_FILTER);
+PHPBN2(OPENSSL_DEFAULT_STREAM_CIPHERS);
+PHPBN2(STREAM_CRYPTO_METHOD_ANY_CLIENT);
+PHPBN2(STREAM_CRYPTO_METHOD_ANY_SERVER);
+PHPBN2(STREAM_CRYPTO_METHOD_TLSv1_0_CLIENT);
+PHPBN2(STREAM_CRYPTO_METHOD_TLSv1_0_SERVER);
+PHPBN2(STREAM_CRYPTO_METHOD_TLSv1_1_CLIENT);
+PHPBN2(STREAM_CRYPTO_METHOD_TLSv1_1_SERVER);
+PHPBN2(STREAM_CRYPTO_METHOD_TLSv1_2_CLIENT);
+PHPBN2(STREAM_CRYPTO_METHOD_TLSv1_2_SERVER);
+PHPBN2(PGSQL_CONNECT_ASYNC);
+PHPBN2(PGSQL_CONNECTION_AUTH_OK);
+PHPBN2(PGSQL_CONNECTION_AWAITING_RESPONSE);
+PHPBN2(PGSQL_CONNECTION_MADE);
+PHPBN2(PGSQL_CONNECTION_SETENV);
+PHPBN2(PGSQL_CONNECTION_SSL_STARTUP);
+PHPBN2(PGSQL_CONNECTION_STARTED);
+PHPBN2(PGSQL_DML_ESCAPE);
+PHPBN2(PGSQL_POLLING_ACTIVE);
+PHPBN2(PGSQL_POLLING_FAILED);
+PHPBN2(PGSQL_POLLING_OK);
+PHPBN2(PGSQL_POLLING_READING);
+PHPBN2(PGSQL_POLLING_WRITING);

 /* Class names reserved by PHP (case insensitive) */
 PHPCN(directory);
--- a/Lib/php/phprun.swg
+++ b/Lib/php/phprun.swg
@ -153,7 +153,7 @@ SWIG_ZTS_SetPointerZval(zval *z, void *ptr, swig_type_info *type, int newobject
      }
      Z_SET_REFCOUNT_P(z, 1);
      Z_SET_ISREF_P(z);
-      zend_hash_update(HASH_OF(z), (char*)"_cPtr", sizeof("_cPtr"), (void*)&resource, sizeof(zval), NULL);
+      zend_hash_update(HASH_OF(z), (char*)"_cPtr", sizeof("_cPtr"), (void*)&resource, sizeof(zval*), NULL);
    }
    return;
  }
--- a/Lib/pointer.i
+++ b/Lib/pointer.i
@ -4,7 +4,7 @@


 %echo "pointer.i is deprecated.  Use cpointer.i instead."
-%echo "See http://www.swig.org/Doc1.3/Library.html"
+%echo "See http://www.swig.org/Doc3.0/Library.html"



--- a/Lib/python/pyclasses.swg
+++ b/Lib/python/pyclasses.swg
@ -72,27 +72,35 @@ namespace swig {

    SwigPtr_PyObject(const SwigPtr_PyObject& item) : _obj(item._obj)
    {
+      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      Py_XINCREF(_obj);      
+      SWIG_PYTHON_THREAD_END_BLOCK;
    }
    
    SwigPtr_PyObject(PyObject *obj, bool initial_ref = true) :_obj(obj)
    {
      if (initial_ref) {
+        SWIG_PYTHON_THREAD_BEGIN_BLOCK;
        Py_XINCREF(_obj);
+        SWIG_PYTHON_THREAD_END_BLOCK;
      }
    }
    
    SwigPtr_PyObject & operator=(const SwigPtr_PyObject& item) 
    {
+      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      Py_XINCREF(item._obj);
      Py_XDECREF(_obj);
      _obj = item._obj;
+      SWIG_PYTHON_THREAD_END_BLOCK;
      return *this;      
    }
    
    ~SwigPtr_PyObject() 
    {
+      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      Py_XDECREF(_obj);
+      SWIG_PYTHON_THREAD_END_BLOCK;
    }
    
    operator PyObject *() const
--- a/Lib/python/pycontainer.swg
+++ b/Lib/python/pycontainer.swg
@ -710,7 +710,8 @@ namespace swig
 #if defined(SWIGPYTHON_BUILTIN)
  %feature("python:slot", "tp_iter", functype="getiterfunc") iterator;
 #else
-  %pythoncode {def __iter__(self): return self.iterator()}
+  %pythoncode {def __iter__(self):
+    return self.iterator()}
 #endif
  }

@ -873,6 +874,13 @@ namespace swig
      *(swig::getpos(self,i)) = x;
    }

+#if defined(SWIGPYTHON_BUILTIN)
+    // This will be called through the mp_ass_subscript slot to delete an entry.
+    void __setitem__(difference_type i) throw (std::out_of_range) {
+      self->erase(swig::getpos(self,i));
+    }
+#endif
+
    void append(const value_type& x) {
      self->push_back(x);
    }
@ -891,6 +899,13 @@ namespace swig
      *(swig::getpos(self,i)) = x;
    }

+#if defined(SWIGPYTHON_BUILTIN)
+    // This will be called through the mp_ass_subscript slot to delete an entry.
+    void __setitem__(difference_type i) throw (std::out_of_range) {
+      self->erase(swig::getpos(self,i));
+    }
+#endif
+
    void append(value_type x) {
      self->push_back(x);
    }
--- a/Lib/python/pyinit.swg
+++ b/Lib/python/pyinit.swg
@ -375,6 +375,7 @@ SWIG_init(void) {
  PyObject *public_interface, *public_symbol;
  PyObject *this_descr;
  PyObject *thisown_descr;
+  PyObject *self = 0;
  int i;

  (void)builtin_pytype;
@ -382,6 +383,7 @@ SWIG_init(void) {
  (void)builtin_basetype;
  (void)tuple;
  (void)static_getset;
+  (void)self;

  /* metatype is used to implement static member variables. */
  metatype_args = Py_BuildValue("(s(O){})", "SwigPyObjectType", &PyType_Type);
@ -401,6 +403,7 @@ SWIG_init(void) {
 #else
  m = Py_InitModule((char *) SWIG_name, SwigMethods);
 #endif
+
  md = d = PyModule_GetDict(m);
  (void)md;

--- a/Lib/python/pyiterators.swg
+++ b/Lib/python/pyiterators.swg
@ -344,7 +344,8 @@ namespace swig
  %feature("python:slot", "tp_iternext", functype="iternextfunc") SwigPyIterator::__next__;
 #else
  %extend SwigPyIterator {
-  %pythoncode {def __iter__(self): return self}
+  %pythoncode {def __iter__(self):
+    return self}
  }
 #endif

--- a/Lib/python/pythonkw.swg
+++ b/Lib/python/pythonkw.swg
@ -130,7 +130,7 @@ PYTHONKW(None);
 /* 
   'self' is also a bad Name
 */
-PYTHONBN(self);
+PYTHONKW(self);

 #undef PYTHONBN
 #undef PYTHONKW
--- a/Lib/python/pyuserdir.swg
+++ b/Lib/python/pyuserdir.swg
@ -185,7 +185,6 @@ These methods "may be called" if needed.
 #define %clearpythonappend    %feature("pythonappend","")


-
 /* ------------------------------------------------------------------------- */
 /* 
   %extend_smart_pointer extend the smart pointer support.
--- a/Lib/python/std_map.i
+++ b/Lib/python/std_map.i
@ -176,10 +176,14 @@

 #else
  %extend {
-    %pythoncode {def __iter__(self): return self.key_iterator()}    
-    %pythoncode {def iterkeys(self): return self.key_iterator()}
-    %pythoncode {def itervalues(self): return self.value_iterator()}
-    %pythoncode {def iteritems(self): return self.iterator()}
+    %pythoncode {def __iter__(self):
+    return self.key_iterator()}    
+    %pythoncode {def iterkeys(self):
+    return self.key_iterator()}
+    %pythoncode {def itervalues(self):
+    return self.value_iterator()}
+    %pythoncode {def iteritems(self):
+    return self.iterator()}
  }
 #endif

--- a/Lib/python/std_pair.i
+++ b/Lib/python/std_pair.i
@ -176,18 +176,20 @@ SwigPython_std_pair_setitem (PyObject *a, Py_ssize_t b, PyObject *c)
 %define %swig_pair_methods(pair...)
 #if !defined(SWIGPYTHON_BUILTIN)
 %extend {      
-%pythoncode {def __len__(self): return 2
-def __repr__(self): return str((self.first, self.second))
+%pythoncode {def __len__(self):
+    return 2
+def __repr__(self):
+    return str((self.first, self.second))
 def __getitem__(self, index): 
-  if not (index % 2): 
-    return self.first
-  else:
-    return self.second
+    if not (index % 2):
+        return self.first
+    else:
+        return self.second
 def __setitem__(self, index, val):
-  if not (index % 2): 
-    self.first = val
-  else:
-    self.second = val}
+    if not (index % 2):
+        self.first = val
+    else:
+        self.second = val}
 }
 #endif
 %enddef
--- a/Lib/python/std_unordered_map.i
+++ b/Lib/python/std_unordered_map.i
@ -231,10 +231,14 @@
      return swig::make_output_value_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }

-    %pythoncode {def __iter__(self): return self.key_iterator()}    
-    %pythoncode {def iterkeys(self): return self.key_iterator()}
-    %pythoncode {def itervalues(self): return self.value_iterator()}
-    %pythoncode {def iteritems(self): return self.iterator()}
+    %pythoncode {def __iter__(self):
+    return self.key_iterator()}    
+    %pythoncode {def iterkeys(self):
+    return self.key_iterator()}
+    %pythoncode {def itervalues(self):
+    return self.value_iterator()}
+    %pythoncode {def iteritems(self):
+    return self.iterator()}
  }
 %enddef

--- a/Lib/r/rfragments.swg
+++ b/Lib/r/rfragments.swg
@ -153,7 +153,7 @@ SWIG_strdup(const char *str)
 }
 }

-# This is modified from the R header files
+//# This is modified from the R header files

 %fragment("SWIG_FromCharPtrAndSize","header") 
 {
--- a/Lib/r/rtype.swg
+++ b/Lib/r/rtype.swg
@ -149,34 +149,22 @@ string &, std::string &
 %typemap(scoerceout) enum SWIGTYPE *const
  %{  $result = enumToInteger($result, "$R_class"); %}

-#%typemap(scoerceout) SWIGTYPE 
-#  %{ class($result) <- "$&R_class"; %}
+%typemap(scoerceout) SEXP %{ %}

-#%typemap(scoerceout) SWIGTYPE & 
-#  %{ class($result) <- "$R_class"; %}
-
-#%typemap(scoerceout) SWIGTYPE * 
-#  %{ class($result) <- "$R_class"; %}
-
-#%typemap(scoerceout) SWIGTYPE *const
-#  %{ class($result) <- "$R_class"; %}
-
- %typemap(scoerceout) SEXP %{ %}
-
- %typemap(scoerceout) SWIGTYPE 
- %{ $result <- new("$&R_class", ref=$result); %}
+%typemap(scoerceout) SWIGTYPE
+  %{ $result <- new("$&R_class", ref=$result); %}
 
- %typemap(scoerceout) SWIGTYPE & 
- %{ $result <- new("$R_class", ref=$result) ; %}
+%typemap(scoerceout) SWIGTYPE &
+  %{ $result <- new("$R_class", ref=$result) ; %}
 
- %typemap(scoerceout) SWIGTYPE && 
- %{ $result <- new("$R_class", ref=$result) ; %}
+%typemap(scoerceout) SWIGTYPE &&
+  %{ $result <- new("$R_class", ref=$result) ; %}
 
- %typemap(scoerceout) SWIGTYPE * 
- %{ $result <- new("$R_class", ref=$result) ; %}
+%typemap(scoerceout) SWIGTYPE *
+  %{ $result <- new("$R_class", ref=$result) ; %}
 
- %typemap(scoerceout) SWIGTYPE *const
- %{ $result <- new("$R_class", ref=$result) ; %}
+%typemap(scoerceout) SWIGTYPE *const
+  %{ $result <- new("$R_class", ref=$result) ; %}


 /* Override the SWIGTYPE * above. */
--- a/Lib/ruby/rubyclasses.swg
+++ b/Lib/ruby/rubyclasses.swg
@ -37,9 +37,6 @@
 %fragment("GC_VALUE_definition","header") {
 namespace swig {
  class SwigGCReferences {
-    // Hash of all GC_VALUE's currently in use
-    static SwigGCReferences s_references;
-
    VALUE _hash;

    SwigGCReferences() : _hash(Qnil) {
@ -50,13 +47,18 @@ namespace swig {
    }
    static void EndProcHandler(VALUE) {
      // Ruby interpreter ending - _hash can no longer be accessed.
+      SwigGCReferences &s_references = instance();
      s_references._hash = Qnil;
    }
  public:
    static SwigGCReferences& instance() {
+      // Hash of all GC_VALUE's currently in use
+      static SwigGCReferences s_references;
+
      return s_references;
    }
    static void initialize() {
+      SwigGCReferences &s_references = instance();
      if (s_references._hash == Qnil) {
        rb_set_end_proc(&EndProcHandler, Qnil);
        s_references._hash = rb_hash_new();
@ -81,13 +83,13 @@ namespace swig {
      if (BUILTIN_TYPE(obj) == T_NONE)
        return;
      if (_hash != Qnil) {
-        VALUE val = rb_hash_aref(s_references._hash, obj);
+        VALUE val = rb_hash_aref(_hash, obj);
        unsigned n = FIXNUM_P(val) ? NUM2UINT(val) : 1;
        --n;
        if (n)
-          rb_hash_aset(s_references._hash, obj, INT2NUM(n));
+          rb_hash_aset(_hash, obj, INT2NUM(n));
        else
-          rb_hash_delete(s_references._hash, obj);
+          rb_hash_delete(_hash, obj);
      }
    }
  };
@ -302,8 +304,6 @@ namespace swig {
  ID  GC_VALUE::lshift_id = rb_intern("<<");
  ID  GC_VALUE::rshift_id = rb_intern(">>");

-  SwigGCReferences SwigGCReferences::s_references;
-
  typedef GC_VALUE LANGUAGE_OBJ;

 } // namespace swig
--- a/Lib/std/std_ios.i
+++ b/Lib/std/std_ios.i
@ -242,17 +242,19 @@ namespace std {
    // 27.4.5.1  basic_ios constructors
    basic_ios();
  private:
-    ios_base(const ios_base&);
+    basic_ios(const basic_ios&);

-    ios_base& 
-    operator=(const ios_base&);
+    basic_ios&
+    operator=(const basic_ios&);
  };
  
 }

 namespace std {
+  typedef basic_ios<char> ios;
  %template(ios) basic_ios<char>;
 #if defined(SWIG_WCHAR)
+ typedef basic_ios<wchar_t> wios;
  %template(wios) basic_ios<wchar_t>;
 #endif
 }
--- a/Lib/swiginit.swg
+++ b/Lib/swiginit.swg
@ -55,7 +55,7 @@ SWIGRUNTIME void
 SWIG_InitializeModule(void *clientdata) {
  size_t i;
  swig_module_info *module_head, *iter;
-  int found, init;
+  int init;

  /* check to see if the circular list has been setup, if not, set it up */
  if (swig_module.next==0) {
@ -74,22 +74,18 @@ SWIG_InitializeModule(void *clientdata) {
    /* This is the first module loaded for this interpreter */
    /* so set the swig module into the interpreter */
    SWIG_SetModule(clientdata, &swig_module);
-    module_head = &swig_module;
  } else {
    /* the interpreter has loaded a SWIG module, but has it loaded this one? */
-    found=0;
    iter=module_head;
    do {
      if (iter==&swig_module) {
-        found=1;
-        break;
+        /* Our module is already in the list, so there's nothing more to do. */
+        return;
      }
      iter=iter->next;
    } while (iter!= module_head);

-    /* if the is found in the list, then all is done and we may leave */
-    if (found) return;
-    /* otherwise we must add out module into the list */
+    /* otherwise we must add our module into the list */
    swig_module.next = module_head->next;
    module_head->next = &swig_module;
  }
--- a/Lib/tcl/std_map.i
+++ b/Lib/tcl/std_map.i
@ -1,7 +1,5 @@
 //
 // SWIG typemaps for std::map
-// Luigi Ballabio
-// Jan. 2003
 //
 // Common implementation

--- a/Lib/typemaps/attribute.swg
+++ b/Lib/typemaps/attribute.swg
@ -137,7 +137,7 @@

 //
 // Define SWIG_ATTRIBUTE_TEMPLATE if you want to use templates instead of macros for the C++ get and set wrapper methods
-// Does not always generate compileable code, use at your peril!
+// Does not always generate compilable code, use at your peril!
 //
 //#define SWIG_ATTRIBUTE_TEMPLATE