Merged from trunk

git-svn-id: https://swig.svn.sourceforge.net/svnroot/swig/branches/gsoc2009-sploving@12656 626c5289-ae23-0410-ae9c-e8d60b6d4f22

Lib/allkw.swg

@@ -18,6 +18,7 @@
 
 %include <chicken/chickenkw.swg>
 %include <csharp/csharpkw.swg>
+%include <d/dkw.swg>
 %include <java/javakw.swg>
 %include <php/phpkw.swg>
 %include <pike/pikekw.swg>

Lib/chicken/chicken.swg

@@ -538,7 +538,7 @@ $result = C_SCHEME_UNDEFINED;
  * String & length
  * ------------------------------------------------------------ */
 
-%typemap(in) (char *STRING, int LENGTH) {
+%typemap(in) (char *STRING, int LENGTH), (char *STRING, size_t LENGTH) {
   if ($input == C_SCHEME_FALSE) {
     swig_barf (SWIG_BARF1_BAD_ARGUMENT_TYPE, "Cannot use a null/#f string for a char*, int arguments");
   }

Lib/csharp/std_map.i

@@ -269,7 +269,7 @@
 
       const key_type& get_next_key(std::map< K, T >::iterator *swigiterator) {
         std::map< K, T >::iterator iter = *swigiterator;
-        swigiterator++;
+        (*swigiterator)++;
         return (*iter).first;
       }
 

Lib/csharp/typemaps.i

@@ -51,29 +51,17 @@ or you can use the %apply directive :
 
 In C# you could then use it like this:
         double answer = modulename.fadd(10.0, 20.0);
-
 */
 
 %define INPUT_TYPEMAP(TYPE, CTYPE, CSTYPE)
-%typemap(ctype) TYPE *INPUT, TYPE &INPUT "CTYPE"
-%typemap(imtype) TYPE *INPUT, TYPE &INPUT "CSTYPE"
-%typemap(cstype) TYPE *INPUT, TYPE &INPUT "CSTYPE"
+%typemap(ctype, out="void *") TYPE *INPUT, TYPE &INPUT "CTYPE"
+%typemap(imtype, out="IntPtr") TYPE *INPUT, TYPE &INPUT "CSTYPE"
+%typemap(cstype, out="$csclassname") TYPE *INPUT, TYPE &INPUT "CSTYPE"
 %typemap(csin) TYPE *INPUT, TYPE &INPUT "$csinput"
-%typemap(csdirectorin) TYPE *INPUT, TYPE &INPUT "$iminput"
-%typemap(csdirectorout) TYPE *INPUT, TYPE &INPUT "$cscall"
 
 %typemap(in) TYPE *INPUT, TYPE &INPUT
 %{ $1 = ($1_ltype)&$input; %}
 
-%typemap(directorout) TYPE *INPUT, TYPE &INPUT
-%{ $result = ($1_ltype)&$input; %}
-
-%typemap(directorin) TYPE &INPUT
-%{ $input = (CTYPE *)$1; %}
-
-%typemap(directorin) TYPE *INPUT
-%{ $input = (CTYPE *)$1; %}
-
 %typemap(typecheck) TYPE *INPUT = TYPE;
 %typemap(typecheck) TYPE &INPUT = TYPE;
 %enddef
@@ -143,32 +131,17 @@ value returned in the second output parameter. In C# you would use it like this:
 
     double dptr;
     double fraction = modulename.modf(5, out dptr);
-
 */
 
 %define OUTPUT_TYPEMAP(TYPE, CTYPE, CSTYPE, TYPECHECKPRECEDENCE)
-%typemap(ctype) TYPE *OUTPUT, TYPE &OUTPUT "CTYPE *"
-%typemap(imtype) TYPE *OUTPUT, TYPE &OUTPUT "out CSTYPE"
-%typemap(cstype) TYPE *OUTPUT, TYPE &OUTPUT "out CSTYPE"
+%typemap(ctype, out="void *") TYPE *OUTPUT, TYPE &OUTPUT "CTYPE *"
+%typemap(imtype, out="IntPtr") TYPE *OUTPUT, TYPE &OUTPUT "out CSTYPE"
+%typemap(cstype, out="$csclassname") TYPE *OUTPUT, TYPE &OUTPUT "out CSTYPE"
 %typemap(csin) TYPE *OUTPUT, TYPE &OUTPUT "out $csinput"
-%typemap(csdirectorin) TYPE *OUTPUT, TYPE &OUTPUT "$iminput"
-%typemap(csdirectorout) TYPE *OUTPUT, TYPE &OUTPUT "$cscall"
-
 
 %typemap(in) TYPE *OUTPUT, TYPE &OUTPUT
 %{ $1 = ($1_ltype)$input; %}
 
-%typemap(directorout,warning="Need to provide TYPE *OUTPUT directorout typemap") TYPE *OUTPUT, TYPE &OUTPUT {
-}
-
-%typemap(directorin) TYPE &OUTPUT
-%{ $input = &$1; %}
-
-%typemap(directorin,warning="Need to provide TYPE *OUTPUT directorin typemap, TYPE array length is unknown") TYPE *OUTPUT
-{
-}
-
-
 %typecheck(SWIG_TYPECHECK_##TYPECHECKPRECEDENCE) TYPE *OUTPUT, TYPE &OUTPUT ""
 %enddef
 
@@ -250,26 +223,14 @@ of the function return value.
 */
 
 %define INOUT_TYPEMAP(TYPE, CTYPE, CSTYPE, TYPECHECKPRECEDENCE)
-%typemap(ctype) TYPE *INOUT, TYPE &INOUT "CTYPE *"
-%typemap(imtype) TYPE *INOUT, TYPE &INOUT "ref CSTYPE"
-%typemap(cstype) TYPE *INOUT, TYPE &INOUT "ref CSTYPE"
+%typemap(ctype, out="void *") TYPE *INOUT, TYPE &INOUT "CTYPE *"
+%typemap(imtype, out="IntPtr") TYPE *INOUT, TYPE &INOUT "ref CSTYPE"
+%typemap(cstype, out="$csclassname") TYPE *INOUT, TYPE &INOUT "ref CSTYPE"
 %typemap(csin) TYPE *INOUT, TYPE &INOUT "ref $csinput"
-%typemap(csdirectorin) TYPE *INOUT, TYPE &INOUT "$iminput"
-%typemap(csdirectorout) TYPE *INOUT, TYPE &INOUT "$cscall"
 
 %typemap(in) TYPE *INOUT, TYPE &INOUT
 %{ $1 = ($1_ltype)$input; %}
 
-%typemap(directorout,warning="Need to provide TYPE *INOUT directorout typemap") TYPE *INOUT, TYPE &INOUT {
-}
-
-%typemap(directorin) TYPE &INOUT
-%{ $input = &$1; %}
-
-%typemap(directorin,warning="Need to provide TYPE *INOUT directorin typemap, TYPE array length is unknown") TYPE *INOUT, TYPE &INOUT
-{
-}
-
 %typecheck(SWIG_TYPECHECK_##TYPECHECKPRECEDENCE) TYPE *INOUT, TYPE &INOUT ""
 %enddef
 

Lib/d/boost_shared_ptr.i

@@ -0,0 +1,201 @@
+%include <shared_ptr.i>
+
+%define SWIG_SHARED_PTR_TYPEMAPS(CONST, TYPE...)
+
+%naturalvar TYPE;
+%naturalvar SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >;
+
+// destructor mods
+%feature("unref") TYPE
+//"if (debug_shared) { cout << \"deleting use_count: \" << (*smartarg1).use_count() << \" [\" << (boost::get_deleter<SWIG_null_deleter>(*smartarg1) ? std::string(\"CANNOT BE DETERMINED SAFELY\") : ((*smartarg1).get() ? (*smartarg1)->getValue() : std::string(\"NULL PTR\"))) << \"]\" << endl << flush; }\n"
+                               "(void)arg1; delete smartarg1;"
+
+
+// plain value
+%typemap(in, canthrow=1) CONST TYPE ($&1_type argp = 0) %{
+  argp = ((SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *)$input) ? ((SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *)$input)->get() : 0;
+  if (!argp) {
+    SWIG_DSetPendingException(SWIG_DIllegalArgumentException, "Attempt to dereference null $1_type");
+    return $null;
+  }
+  $1 = *argp; %}
+%typemap(out) CONST TYPE
+%{ $result = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(new $1_ltype(($1_ltype &)$1)); %}
+
+// plain pointer
+%typemap(in, canthrow=1) CONST TYPE * (SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartarg = 0) %{
+  smartarg = (SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *)$input;
+  $1 = (TYPE *)(smartarg ? smartarg->get() : 0); %}
+%typemap(out, fragment="SWIG_null_deleter") CONST TYPE * %{
+  $result = $1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >($1 SWIG_NO_NULL_DELETER_$owner) : 0;
+%}
+
+// plain reference
+%typemap(in, canthrow=1) CONST TYPE & %{
+  $1 = ($1_ltype)(((SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *)$input) ? ((SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *)$input)->get() : 0);
+  if (!$1) {
+    SWIG_DSetPendingException(SWIG_DIllegalArgumentException, "$1_type reference is null");
+    return $null;
+  } %}
+%typemap(out, fragment="SWIG_null_deleter") CONST TYPE &
+%{ $result = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >($1 SWIG_NO_NULL_DELETER_$owner); %}
+
+// plain pointer by reference
+%typemap(in) TYPE *CONST& ($*1_ltype temp = 0)
+%{ temp = (TYPE *)(((SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *)$input) ? ((SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *)$input)->get() : 0);
+   $1 = &temp; %}
+%typemap(out, fragment="SWIG_null_deleter") TYPE *CONST&
+%{ $result = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(*$1 SWIG_NO_NULL_DELETER_$owner); %}
+
+// shared_ptr by value
+%typemap(in) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >
+%{ if ($input) $1 = *($&1_ltype)$input; %}
+%typemap(out) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >
+%{ $result = $1 ? new $1_ltype($1) : 0; %}
+
+// shared_ptr by reference
+%typemap(in, canthrow=1) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > & ($*1_ltype tempnull)
+%{ $1 = $input ? ($1_ltype)$input : &tempnull; %}
+%typemap(out) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > &
+%{ $result = *$1 ? new $*1_ltype(*$1) : 0; %}
+
+// shared_ptr by pointer
+%typemap(in) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > * ($*1_ltype tempnull)
+%{ $1 = $input ? ($1_ltype)$input : &tempnull; %}
+%typemap(out, fragment="SWIG_null_deleter") SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *
+%{ $result = ($1 && *$1) ? new $*1_ltype(*($1_ltype)$1) : 0;
+   if ($owner) delete $1; %}
+
+// shared_ptr by pointer reference
+%typemap(in) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *& (SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > tempnull, $*1_ltype temp = 0)
+%{ temp = $input ? *($1_ltype)&$input : &tempnull;
+   $1 = &temp; %}
+%typemap(out) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *&
+%{ *($1_ltype)&$result = (*$1 && **$1) ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(**$1) : 0; %}
+
+// various missing typemaps - If ever used (unlikely) ensure compilation error rather than runtime bug
+%typemap(in) CONST TYPE[], CONST TYPE[ANY], CONST TYPE (CLASS::*) %{
+#error "typemaps for $1_type not available"
+%}
+%typemap(out) CONST TYPE[], CONST TYPE[ANY], CONST TYPE (CLASS::*) %{
+#error "typemaps for $1_type not available"
+%}
+
+
+%typemap (ctype)  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >,
+                  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > &,
+                  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *,
+                  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *& "void *"
+%typemap (imtype) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >,
+                  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > &,
+                  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *,
+                  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *& "void*"
+%typemap (dtype) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >,
+                  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > &,
+                  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *,
+                  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *& "$typemap(dtype, TYPE)"
+
+%typemap(din) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >,
+               SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > &,
+               SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *,
+               SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *& "$typemap(dtype, TYPE).swigGetCPtr($dinput)"
+
+%typemap(dout, excode=SWIGEXCODE) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > {
+  void* cPtr = $imcall;
+  auto ret = (cPtr is null) ? null : new $typemap(dtype, TYPE)(cPtr, true);$excode
+  return ret;
+}
+%typemap(dout, excode=SWIGEXCODE) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > & {
+  void* cPtr = $imcall;
+  auto ret = (cPtr is null) ? null : new $typemap(dtype, TYPE)(cPtr, true);$excode
+  return ret;
+}
+%typemap(dout, excode=SWIGEXCODE) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > * {
+  void* cPtr = $imcall;
+  auto ret = (cPtr is null) ? null : new $typemap(dtype, TYPE)(cPtr, true);$excode
+  return ret;
+}
+%typemap(dout, excode=SWIGEXCODE) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *& {
+  void* cPtr = $imcall;
+  auto ret = (cPtr is null) ? null : new $typemap(dtype, TYPE)(cPtr, true);$excode
+  return ret;
+}
+
+
+%typemap(dout, excode=SWIGEXCODE) CONST TYPE {
+  auto ret = new $typemap(dtype, TYPE)($imcall, true);$excode
+  return ret;
+}
+%typemap(dout, excode=SWIGEXCODE) CONST TYPE & {
+  auto ret = new $typemap(dtype, TYPE)($imcall, true);$excode
+  return ret;
+}
+%typemap(dout, excode=SWIGEXCODE) CONST TYPE * {
+  void* cPtr = $imcall;
+  auto ret = (cPtr is null) ? null : new $typemap(dtype, TYPE)(cPtr, true);$excode
+  return ret;
+}
+%typemap(dout, excode=SWIGEXCODE) TYPE *CONST& {
+  void* cPtr = $imcall;
+  auto ret = (cPtr is null) ? null : new $typemap(dtype, TYPE)(cPtr, true);$excode
+  return ret;
+}
+
+// For shared pointers, both the derived and the base class have to »own« their
+// pointer; otherwise the reference count is not decreased properly on destruction.
+%typemap(dbody) SWIGTYPE %{
+private void* swigCPtr;
+private bool swigCMemOwn;
+
+public this(void* cObject, bool ownCObject) {
+  swigCPtr = cObject;
+  swigCMemOwn = ownCObject;
+}
+
+public static void* swigGetCPtr($dclassname obj) {
+  return (obj is null) ? null : obj.swigCPtr;
+}
+%}
+
+%typemap(dbody_derived) SWIGTYPE %{
+private void* swigCPtr;
+private bool swigCMemOwn;
+
+public this(void* cObject, bool ownCObject) {
+  super($imdmodule.$dclazznameSmartPtrUpcast(cObject), ownCObject);
+  swigCPtr = cObject;
+  swigCMemOwn = ownCObject;
+}
+
+public static void* swigGetCPtr($dclassname obj) {
+  return (obj is null) ? null : obj.swigCPtr;
+}
+%}
+
+%typemap(ddispose, methodname="dispose", methodmodifiers="public") TYPE {
+  synchronized(this) {
+    if (swigCPtr !is null) {
+      if (swigCMemOwn) {
+        swigCMemOwn = false;
+        $imcall;
+      }
+      swigCPtr = null;
+    }
+  }
+}
+
+%typemap(ddispose_derived, methodname="dispose", methodmodifiers="public") TYPE {
+  synchronized(this) {
+    if (swigCPtr !is null) {
+      if (swigCMemOwn) {
+        swigCMemOwn = false;
+        $imcall;
+      }
+      swigCPtr = null;
+      super.dispose();
+    }
+  }
+}
+
+%template() SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >;
+%enddef

Lib/d/carrays.i

@@ -0,0 +1,111 @@
+/* -----------------------------------------------------------------------------
+ * carrays.i
+ *
+ * D-specific version of ../carrays.i.
+ * ----------------------------------------------------------------------------- */
+
+/* -----------------------------------------------------------------------------
+ * %array_functions(TYPE,NAME)
+ *
+ * Generates functions for creating and accessing elements of a C array
+ * (as pointers).  Creates the following functions:
+ *
+ *        TYPE *new_NAME(int nelements)
+ *        void delete_NAME(TYPE *);
+ *        TYPE NAME_getitem(TYPE *, int index);
+ *        void NAME_setitem(TYPE *, int index, TYPE value);
+ *
+ * ----------------------------------------------------------------------------- */
+
+%define %array_functions(TYPE,NAME)
+%{
+static TYPE *new_##NAME(int nelements) { %}
+#ifdef __cplusplus
+%{  return new TYPE[nelements]; %}
+#else
+%{  return (TYPE *) calloc(nelements,sizeof(TYPE)); %}
+#endif
+%{}
+
+static void delete_##NAME(TYPE *ary) { %}
+#ifdef __cplusplus
+%{  delete [] ary; %}
+#else
+%{  free(ary); %}
+#endif
+%{}
+
+static TYPE NAME##_getitem(TYPE *ary, int index) {
+    return ary[index];
+}
+static void NAME##_setitem(TYPE *ary, int index, TYPE value) {
+    ary[index] = value;
+}
+%}
+
+TYPE *new_##NAME(int nelements);
+void delete_##NAME(TYPE *ary);
+TYPE NAME##_getitem(TYPE *ary, int index);
+void NAME##_setitem(TYPE *ary, int index, TYPE value);
+
+%enddef
+
+
+/* -----------------------------------------------------------------------------
+ * %array_class(TYPE,NAME)
+ *
+ * Generates a class wrapper around a C array.  The class has the following
+ * interface:
+ *
+ *          struct NAME {
+ *              NAME(int nelements);
+ *             ~NAME();
+ *              TYPE getitem(int index);
+ *              void setitem(int index, TYPE value);
+ *              TYPE * ptr();
+ *              static NAME *frompointer(TYPE *t);
+  *         }
+ *
+ * ----------------------------------------------------------------------------- */
+
+%define %array_class(TYPE,NAME)
+%{
+typedef TYPE NAME;
+%}
+
+typedef struct NAME {} NAME;
+
+%extend NAME {
+#ifdef __cplusplus
+  NAME(int nelements) {
+    return new TYPE[nelements];
+  }
+  ~NAME() {
+    delete [] self;
+  }
+#else
+  NAME(int nelements) {
+    return (TYPE *) calloc(nelements,sizeof(TYPE));
+  }
+  ~NAME() {
+    free(self);
+  }
+#endif
+
+  TYPE getitem(int index) {
+    return self[index];
+  }
+  void setitem(int index, TYPE value) {
+    self[index] = value;
+  }
+  TYPE * ptr() {
+    return self;
+  }
+  static NAME *frompointer(TYPE *t) {
+    return (NAME *) t;
+  }
+};
+
+%types(NAME = TYPE);
+
+%enddef

Lib/d/cpointer.i

@@ -0,0 +1,171 @@
+/* -----------------------------------------------------------------------------
+ * cpointer.i
+ *
+ * D-specific version of ../cpointer.i.
+ * ----------------------------------------------------------------------------- */
+
+/* -----------------------------------------------------------------------------
+ * %pointer_class(type,name)
+ *
+ * Places a simple proxy around a simple type like 'int', 'float', or whatever.
+ * The proxy provides this interface:
+ *
+ *       class type {
+ *       public:
+ *           type();
+ *          ~type();
+ *           type value();
+ *           void assign(type value);
+ *       };
+ *
+ * Example:
+ *
+ *    %pointer_class(int, intp);
+ *
+ *    int add(int *x, int *y) { return *x + *y; }
+ *
+ * In python (with proxies)
+ *
+ *    >>> a = intp()
+ *    >>> a.assign(10)
+ *    >>> a.value()
+ *    10
+ *    >>> b = intp()
+ *    >>> b.assign(20)
+ *    >>> print add(a,b)
+ *    30
+ *
+ * As a general rule, this macro should not be used on class/structures that
+ * are already defined in the interface.
+ * ----------------------------------------------------------------------------- */
+
+
+%define %pointer_class(TYPE, NAME)
+%{
+typedef TYPE NAME;
+%}
+
+typedef struct {
+} NAME;
+
+%extend NAME {
+#ifdef __cplusplus
+NAME() {
+  return new TYPE();
+}
+~NAME() {
+  if (self) delete self;
+}
+#else
+NAME() {
+  return (TYPE *) calloc(1,sizeof(TYPE));
+}
+~NAME() {
+  if (self) free(self);
+}
+#endif
+}
+
+%extend NAME {
+
+void assign(TYPE value) {
+  *self = value;
+}
+TYPE value() {
+  return *self;
+}
+TYPE * ptr() {
+  return self;
+}
+static NAME * frompointer(TYPE *t) {
+  return (NAME *) t;
+}
+
+}
+
+%types(NAME = TYPE);
+
+%enddef
+
+/* -----------------------------------------------------------------------------
+ * %pointer_functions(type,name)
+ *
+ * Create functions for allocating/deallocating pointers.   This can be used
+ * if you don't want to create a proxy class or if the pointer is complex.
+ *
+ *    %pointer_functions(int, intp)
+ *
+ *    int add(int *x, int *y) { return *x + *y; }
+ *
+ * In python (with proxies)
+ *
+ *    >>> a = copy_intp(10)
+ *    >>> intp_value(a)
+ *    10
+ *    >>> b = new_intp()
+ *    >>> intp_assign(b,20)
+ *    >>> print add(a,b)
+ *    30
+ *    >>> delete_intp(a)
+ *    >>> delete_intp(b)
+ *
+ * ----------------------------------------------------------------------------- */
+
+%define %pointer_functions(TYPE,NAME)
+%{
+static TYPE *new_##NAME() { %}
+#ifdef __cplusplus
+%{  return new TYPE(); %}
+#else
+%{  return (TYPE *) calloc(1,sizeof(TYPE)); %}
+#endif
+%{}
+
+static TYPE *copy_##NAME(TYPE value) { %}
+#ifdef __cplusplus
+%{  return new TYPE(value); %}
+#else
+%{  TYPE *self = (TYPE *) calloc(1,sizeof(TYPE));
+  *self = value;
+  return self; %}
+#endif
+%{}
+
+static void delete_##NAME(TYPE *self) { %}
+#ifdef __cplusplus
+%{  if (self) delete self; %}
+#else
+%{  if (self) free(self); %}
+#endif
+%{}
+
+static void NAME ##_assign(TYPE *self, TYPE value) {
+  *self = value;
+}
+
+static TYPE NAME ##_value(TYPE *self) {
+  return *self;
+}
+%}
+
+TYPE *new_##NAME();
+TYPE *copy_##NAME(TYPE value);
+void  delete_##NAME(TYPE *self);
+void  NAME##_assign(TYPE *self, TYPE value);
+TYPE  NAME##_value(TYPE *self);
+
+%enddef
+
+/* -----------------------------------------------------------------------------
+ * %pointer_cast(type1,type2,name)
+ *
+ * Generates a pointer casting function.
+ * ----------------------------------------------------------------------------- */
+
+%define %pointer_cast(TYPE1,TYPE2,NAME)
+%inline %{
+TYPE2 NAME(TYPE1 x) {
+   return (TYPE2) x;
+}
+%}
+%enddef

Lib/d/d.swg

@@ -0,0 +1,46 @@
+/* -----------------------------------------------------------------------------
+ * d.swg
+ *
+ * Main library file for the D language module. See the D chapter in the SWIG
+ * manual for explanation on the typemaps, pragmas, etc. used.
+ * ----------------------------------------------------------------------------- */
+
+// Typemaps for exception handling.
+%include <dexception.swg>
+
+// Typemaps for primitive types.
+%include <dprimitives.swg>
+
+// Typemaps for non-primitive types (C/C++ classes and structs).
+%include <dswigtype.swg>
+
+// Typemaps for enumeration types.
+%include <denums.swg>
+
+// Typemaps for member function pointers.
+%include <dmemberfunctionpointers.swg>
+
+// Typemaps for wrapping pointers to/arrays of C chars as D strings.
+%include <dstrings.swg>
+
+// Typemaps for handling void function return types and empty parameter lists.
+%include <dvoid.swg>
+
+// Typemaps containing D code used when generating D proxy classes.
+%include <dclassgen.swg>
+
+// Mapping of C++ operator overloading methods to D.
+%include <doperators.swg>
+
+// Helper code string and exception handling.
+%include <dhead.swg>
+
+// Wrapper loader code for dynamically linking the C wrapper library from the D
+// wrapper module.
+%include <wrapperloader.swg>
+
+// List of all reserved D keywords.
+%include <dkw.swg>
+
+// D-specific directives.
+%include <ddirectives.swg>

Lib/d/dclassgen.swg

@@ -0,0 +1,142 @@
+/* -----------------------------------------------------------------------------
+ * dclassgen.swg
+ *
+ * Typemaps containing D code used when generating D proxy classes.
+ * ----------------------------------------------------------------------------- */
+
+%typemap(dbase)               SWIGTYPE, SWIGTYPE *, SWIGTYPE &, SWIGTYPE [], SWIGTYPE (CLASS::*) ""
+%typemap(dclassmodifiers)     SWIGTYPE, SWIGTYPE *, SWIGTYPE &, SWIGTYPE [], SWIGTYPE (CLASS::*) "class"
+%typemap(dcode)               SWIGTYPE, SWIGTYPE *, SWIGTYPE &, SWIGTYPE [], SWIGTYPE (CLASS::*) ""
+%typemap(dimports)            SWIGTYPE, SWIGTYPE *, SWIGTYPE &, SWIGTYPE [], SWIGTYPE (CLASS::*) ""
+%typemap(dinterfaces)         SWIGTYPE, SWIGTYPE *, SWIGTYPE &, SWIGTYPE [], SWIGTYPE (CLASS::*) ""
+%typemap(dinterfaces_derived) SWIGTYPE, SWIGTYPE *, SWIGTYPE &, SWIGTYPE [], SWIGTYPE (CLASS::*) ""
+
+// See <denums.swg>.
+%typemap(dclassmodifiers) enum SWIGTYPE "enum"
+%typemap(dcode) enum SWIGTYPE ""
+
+
+/*
+ * Proxy classes.
+ */
+
+%typemap(dconstructor, excode=SWIGEXCODE,directorconnect="\n  swigDirectorConnect();") SWIGTYPE {
+  this($imcall, true);$excode$directorconnect
+}
+
+%typemap(ddestructor) SWIGTYPE %{
+~this() {
+  dispose();
+}
+%}
+
+// We do not use »override« attribute for generated dispose() methods to stay
+// somewhat compatible to Phobos and older Tango versions where Object.dispose()
+// does not exist.
+%typemap(ddispose, methodname="dispose", methodmodifiers="public") SWIGTYPE {
+  synchronized(this) {
+    if (swigCPtr !is null) {
+      if (swigCMemOwn) {
+        swigCMemOwn = false;
+        $imcall;
+      }
+      swigCPtr = null;
+    }
+  }
+}
+
+%typemap(ddispose_derived, methodname="dispose", methodmodifiers="public") SWIGTYPE {
+  synchronized(this) {
+    if (swigCPtr !is null) {
+      if (swigCMemOwn) {
+        swigCMemOwn = false;
+        $imcall;
+      }
+      swigCPtr = null;
+      super.dispose();
+    }
+  }
+}
+
+
+// Unfortunately, the »package« visibility attribute does not work in D when the
+// module in question is in the root package (happens if no -package is specified
+// at the SWIG command line), so we are stuck with public visibility for
+// swigGetCPtr().
+%typemap(dbody) SWIGTYPE %{
+private void* swigCPtr;
+protected bool swigCMemOwn;
+
+public this(void* cObject, bool ownCObject) {
+  swigCPtr = cObject;
+  swigCMemOwn = ownCObject;
+}
+
+public static void* swigGetCPtr($dclassname obj) {
+  return (obj is null) ? null : obj.swigCPtr;
+}
+
+mixin $imdmodule.SwigOperatorDefinitions;
+%}
+
+
+%typemap(dbody_derived) SWIGTYPE %{
+private void* swigCPtr;
+
+public this(void* cObject, bool ownCObject) {
+  super($imdmodule.$dclazznameUpcast(cObject), ownCObject);
+  swigCPtr = cObject;
+}
+
+public static void* swigGetCPtr($dclassname obj) {
+  return (obj is null) ? null : obj.swigCPtr;
+}
+
+mixin $imdmodule.SwigOperatorDefinitions;
+%}
+
+
+/*
+ * Type wrapper classes.
+ */
+
+%typemap(dbody) SWIGTYPE *, SWIGTYPE &, SWIGTYPE [] %{
+private void* swigCPtr;
+
+public this(void* cObject, bool futureUse) {
+  swigCPtr = cObject;
+}
+
+protected this() {
+  swigCPtr = null;
+}
+
+public static void* swigGetCPtr($dclassname obj) {
+  return (obj is null) ? null : obj.swigCPtr;
+}
+
+mixin $imdmodule.SwigOperatorDefinitions;
+%}
+
+
+/*
+ * Member function pointer wrapper classes (see <dmemberfunctionpointers.swg>).
+ */
+
+%typemap(dbody) SWIGTYPE (CLASS::*) %{
+private char* swigCPtr;
+
+public this(char* cMemberPtr, bool futureUse) {
+  swigCPtr = cMemberPtr;
+}
+
+protected this() {
+  swigCPtr = null;
+}
+
+package static char* swigGetCMemberPtr($dclassname obj) {
+  return (obj is null) ? null : obj.swigCPtr;
+}
+
+mixin $imdmodule.SwigOperatorDefinitions;
+%}

Lib/d/ddirectives.swg

@@ -0,0 +1,10 @@
+/* -----------------------------------------------------------------------------
+ * ddirectives.swg
+ *
+ * D-specifiv directives.
+ * ----------------------------------------------------------------------------- */
+
+#define %dmanifestconst             %feature("d:manifestconst")
+#define %dconstvalue(value)         %feature("d:constvalue",value)
+#define %dmethodmodifiers           %feature("d:methodmodifiers")
+#define %dnothrowexception          %feature("except")

Lib/d/denums.swg

@@ -0,0 +1,60 @@
+/* -----------------------------------------------------------------------------
+ * denums.swg
+ *
+ * Typemaps for enumerations.
+ * ----------------------------------------------------------------------------- */
+
+
+/*
+ * Typemaps for enumeration types.
+ */
+
+%typemap(ctype) enum SWIGTYPE "int"
+%typemap(imtype) enum SWIGTYPE "int"
+%typemap(dtype, cprimitive="1") enum SWIGTYPE "$dclassname"
+
+%typecheck(SWIG_TYPECHECK_POINTER) enum SWIGTYPE ""
+
+%typemap(in) enum SWIGTYPE %{ $1 = ($1_ltype)$input; %}
+%typemap(out) enum SWIGTYPE %{ $result = $1; %}
+
+%typemap(directorout) enum SWIGTYPE %{ $result = ($1_ltype)$input; %}
+%typemap(directorin) enum SWIGTYPE "$input = $1;"
+%typemap(ddirectorin) enum SWIGTYPE "cast($dclassname)$winput"
+%typemap(ddirectorout) enum SWIGTYPE "cast(int)$dcall"
+
+%typemap(din) enum SWIGTYPE "cast(int)$dinput"
+%typemap(dout, excode=SWIGEXCODE) enum SWIGTYPE {
+  $dclassname ret = cast($dclassname)$imcall;$excode
+  return ret;
+}
+
+
+/*
+ * Typemaps for (const) references to enumeration types.
+ */
+
+%typemap(ctype) const enum SWIGTYPE & "int"
+%typemap(imtype) const enum SWIGTYPE & "int"
+%typemap(dtype) const enum SWIGTYPE & "$*dclassname"
+
+%typecheck(SWIG_TYPECHECK_POINTER) const enum SWIGTYPE & ""
+
+%typemap(in) const enum SWIGTYPE & ($*1_ltype temp)
+%{ temp = ($*1_ltype)$input;
+   $1 = &temp; %}
+%typemap(out) const enum SWIGTYPE & %{ $result = *$1; %}
+
+%typemap(directorin) const enum SWIGTYPE & "$input = $1_name;"
+%typemap(directorout,warning=SWIGWARN_TYPEMAP_THREAD_UNSAFE_MSG) const enum SWIGTYPE &
+%{ static $*1_ltype temp = ($*1_ltype)$input;
+   $result = &temp; %}
+
+%typemap(ddirectorin) const enum SWIGTYPE & "cast($*dclassname)$winput"
+%typemap(ddirectorout) const enum SWIGTYPE & "cast(int)$dcall"
+
+%typemap(din) const enum SWIGTYPE & "cast(int)$dinput"
+%typemap(dout, excode=SWIGEXCODE) const enum SWIGTYPE & {
+  $*dclassname ret = cast($*dclassname)$imcall;$excode
+  return ret;
+}

Lib/d/dexception.swg

@@ -0,0 +1,30 @@
+/* -----------------------------------------------------------------------------
+ * dexception.swg
+ *
+ * Typemaps used for propagating C++ exceptions to D.
+ * ----------------------------------------------------------------------------- */
+
+// Code which is inserted into the dout typemaps and class constructors via
+// excode if exceptions can be thrown.
+%define SWIGEXCODE "\n  if ($imdmodule.SwigPendingException.isPending) throw $imdmodule.SwigPendingException.retrieve();" %enddef
+
+%typemap(throws, canthrow=1) int,
+                 long,
+                 short,
+                 unsigned int,
+                 unsigned long,
+                 unsigned short
+%{ char error_msg[256];
+   sprintf(error_msg, "C++ $1_type exception thrown, value: %d", $1);
+   SWIG_DSetPendingException(SWIG_DException, error_msg);
+   return $null; %}
+
+%typemap(throws, canthrow=1) SWIGTYPE, SWIGTYPE &, SWIGTYPE *, SWIGTYPE [ANY],
+  enum SWIGTYPE, const enum SWIGTYPE &
+%{ (void)$1;
+   SWIG_DSetPendingException(SWIG_DException, "C++ $1_type exception thrown");
+   return $null; %}
+
+%typemap(throws, canthrow=1) char *
+%{ SWIG_DSetPendingException(SWIG_DException, $1);
+   return $null; %}

Lib/d/dhead.swg

@@ -0,0 +1,310 @@
+/* -----------------------------------------------------------------------------
+ * dhead.swg
+ *
+ * Support code for exceptions if the SWIG_D_NO_EXCEPTION_HELPER is not defined
+ * Support code for strings if the SWIG_D_NO_STRING_HELPER is not defined
+ * ----------------------------------------------------------------------------- */
+
+%insert(runtime) %{
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+%}
+
+
+#if !defined(SWIG_D_NO_EXCEPTION_HELPER)
+%insert(runtime) %{
+// Support for throwing D exceptions from C/C++.
+typedef enum {
+  SWIG_DException = 0,
+  SWIG_DIllegalArgumentException,
+  SWIG_DIllegalElementException,
+  SWIG_DIOException,
+  SWIG_DNoSuchElementException,
+} SWIG_DExceptionCodes;
+
+typedef void (* SWIG_DExceptionCallback_t)(const char *);
+
+typedef struct {
+  SWIG_DExceptionCodes code;
+  SWIG_DExceptionCallback_t callback;
+} SWIG_DException_t;
+
+static SWIG_DException_t SWIG_d_exceptions[] = {
+  { SWIG_DException, NULL },
+  { SWIG_DIllegalArgumentException, NULL },
+  { SWIG_DIllegalElementException, NULL },
+  { SWIG_DIOException, NULL },
+  { SWIG_DNoSuchElementException, NULL }
+};
+
+static void SWIGUNUSED SWIG_DSetPendingException(SWIG_DExceptionCodes code, const char *msg) {
+  if ((size_t)code < sizeof(SWIG_d_exceptions)/sizeof(SWIG_DException_t)) {
+    SWIG_d_exceptions[code].callback(msg);
+  } else {
+    SWIG_d_exceptions[SWIG_DException].callback(msg);
+  }
+}
+
+#ifdef __cplusplus
+extern "C"
+#endif
+SWIGEXPORT void SWIGRegisterExceptionCallbacks_$module(
+  SWIG_DExceptionCallback_t exceptionCallback,
+  SWIG_DExceptionCallback_t illegalArgumentCallback,
+  SWIG_DExceptionCallback_t illegalElementCallback,
+  SWIG_DExceptionCallback_t ioCallback,
+  SWIG_DExceptionCallback_t noSuchElementCallback) {
+  SWIG_d_exceptions[SWIG_DException].callback = exceptionCallback;
+  SWIG_d_exceptions[SWIG_DIllegalArgumentException].callback = illegalArgumentCallback;
+  SWIG_d_exceptions[SWIG_DIllegalElementException].callback = illegalElementCallback;
+  SWIG_d_exceptions[SWIG_DIOException].callback = ioCallback;
+  SWIG_d_exceptions[SWIG_DNoSuchElementException].callback = noSuchElementCallback;
+}
+%}
+
+#if (SWIG_D_VERSION == 1)
+%pragma(d) imdmoduleimports=%{
+// Exception throwing support currently requires Tango, but there is no reason
+// why it could not support Phobos.
+static import tango.core.Exception;
+static import tango.core.Thread;
+static import tango.stdc.stringz;
+%}
+
+%pragma(d) imdmodulecode=%{
+private class SwigExceptionHelper {
+  static this() {
+    swigRegisterExceptionCallbacks(
+      &setException,
+      &setIllegalArgumentException,
+      &setIllegalElementException,
+      &setIOException,
+      &setNoSuchElementException);
+  }
+
+  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);
+  }
+}
+
+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;
+  }
+
+  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);
+    }
+
+    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;
+        }
+      }
+    }
+    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;
+}
+alias void function(char* message) SwigExceptionCallback;
+%}
+#else
+%pragma(d) imdmoduleimports=%{
+static import std.conv;
+%}
+
+%pragma(d) imdmodulecode=%{
+private class SwigExceptionHelper {
+  static this() {
+	// The D1/Tango version maps C++ exceptions to multiple exception types.
+    swigRegisterExceptionCallbacks(
+      &setException,
+      &setException,
+      &setException,
+      &setException,
+      &setException
+    );
+  }
+
+  static void setException(char* message) {
+    auto exception = new object.Exception(std.conv.to!string(message).idup);
+    exception.next = SwigPendingException.retrieve();
+    SwigPendingException.set(exception);
+  }
+}
+
+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;
+  }
+
+  static void set(object.Exception e) {
+    if (m_sPendingException !is null) {
+      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;
+        }
+      }
+    }
+    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;
+}
+alias void function(const char* message) SwigExceptionCallback;
+%}
+#endif
+// Callback registering function in wrapperloader.swg.
+#endif // SWIG_D_NO_EXCEPTION_HELPER
+
+#if !defined(SWIG_D_NO_STRING_HELPER)
+%insert(runtime) %{
+// Callback for returning strings to D without leaking memory.
+typedef char * (* SWIG_DStringHelperCallback)(const char *);
+static SWIG_DStringHelperCallback SWIG_d_string_callback = NULL;
+
+#ifdef __cplusplus
+extern "C"
+#endif
+SWIGEXPORT void SWIGRegisterStringCallback_$module(SWIG_DStringHelperCallback callback) {
+  SWIG_d_string_callback = callback;
+}
+%}
+
+#if (SWIG_D_VERSION == 1)
+%pragma(d) imdmoduleimports = "static import tango.stdc.stringz;";
+
+%pragma(d) imdmodulecode = %{
+private class SwigStringHelper {
+  static this() {
+    swigRegisterStringCallback(&createString);
+  }
+
+  static char* createString(char* cString) {
+    // We are effectively dup'ing the string here.
+    return tango.stdc.stringz.toStringz(tango.stdc.stringz.fromStringz(cString));
+  }
+}
+alias char* function(char* cString) SwigStringCallback;
+%}
+#else
+%pragma(d) imdmoduleimports = %{
+static import std.conv;
+static import std.string;
+%}
+
+%pragma(d) imdmodulecode = %{
+private class SwigStringHelper {
+  static this() {
+    swigRegisterStringCallback(&createString);
+  }
+
+  static const(char)* createString(const(char*) cString) {
+    // We are effectively dup'ing the string here.
+    // TODO: Is this also correct for D2/Phobos?
+    return std.string.toStringz(std.conv.to!string(cString));
+  }
+}
+alias const(char)* function(const(char*) cString) SwigStringCallback;
+%}
+#endif
+// Callback registering function in wrapperloader.swg.
+#endif // SWIG_D_NO_STRING_HELPER
+
+%insert(runtime) %{
+/* Contract support. */
+#define SWIG_contract_assert(nullreturn, expr, msg) if (!(expr)) {SWIG_DSetPendingException(SWIG_DException, msg); return nullreturn; } else
+%}

Lib/d/director.swg

@@ -0,0 +1,46 @@
+/* -----------------------------------------------------------------------------
+ * director.swg
+ *
+ * This file contains support for director classes so that D proxy
+ * methods can be called from C++.
+ * ----------------------------------------------------------------------------- */
+
+#ifdef __cplusplus
+
+#if defined(DEBUG_DIRECTOR_OWNED)
+#include <iostream>
+#endif
+#include <string>
+
+namespace Swig {
+  // Director base class – not used in D directors.
+  class Director {
+  };
+
+  // Base class for director exceptions.
+  class DirectorException {
+  protected:
+    std::string swig_msg;
+
+  public:
+    DirectorException(const char* msg) : swig_msg(msg) {
+    }
+    DirectorException(const std::string &msg) : swig_msg(msg) {
+    }
+    const std::string& what() const {
+      return swig_msg;
+    }
+    virtual ~DirectorException() {
+    }
+  };
+
+  // Exception which is thrown when attempting to call a pure virtual method
+  // from D code thorugh the director layer.
+  class DirectorPureVirtualException : public Swig::DirectorException {
+  public:
+    DirectorPureVirtualException(const char* msg) : DirectorException(std::string("Attempted to invoke pure virtual method ") + msg) {
+    }
+  };
+}
+
+#endif /* __cplusplus */

Lib/d/dkw.swg

@@ -0,0 +1,126 @@
+#ifndef D_DKW_SWG_
+#define D_DKW_SWG_
+
+/* Warnings for D keywords */
+#define DKEYWORD(x) %keywordwarn("'" `x` "' is a D keyword, renaming to '_" `x` "'",rename="_%s")  `x`
+
+// Source: http://www.digitalmars.com/d/{1.0,2.0}/lex.html and
+DKEYWORD(Object);
+DKEYWORD(__FILE__);
+DKEYWORD(__LINE__);
+DKEYWORD(__gshared);
+DKEYWORD(__thread);
+DKEYWORD(__traits);
+DKEYWORD(abstract);
+DKEYWORD(alias);
+DKEYWORD(align);
+DKEYWORD(asm);
+DKEYWORD(assert);
+DKEYWORD(auto);
+DKEYWORD(body);
+DKEYWORD(bool);
+DKEYWORD(break);
+DKEYWORD(byte);
+DKEYWORD(case);
+DKEYWORD(cast);
+DKEYWORD(catch);
+DKEYWORD(cdouble);
+DKEYWORD(cent);
+DKEYWORD(cfloat);
+DKEYWORD(char);
+DKEYWORD(class);
+DKEYWORD(const);
+DKEYWORD(continue);
+DKEYWORD(creal);
+DKEYWORD(dchar);
+DKEYWORD(debug);
+DKEYWORD(default);
+DKEYWORD(delegate);
+DKEYWORD(delete);
+DKEYWORD(deprecated);
+DKEYWORD(do);
+DKEYWORD(double);
+DKEYWORD(dstring);
+DKEYWORD(else);
+DKEYWORD(enum);
+DKEYWORD(export);
+DKEYWORD(extern);
+DKEYWORD(false);
+DKEYWORD(final);
+DKEYWORD(finally);
+DKEYWORD(float);
+DKEYWORD(for);
+DKEYWORD(foreach);
+DKEYWORD(foreach_reverse);
+DKEYWORD(function);
+DKEYWORD(goto);
+DKEYWORD(idouble);
+DKEYWORD(if);
+DKEYWORD(ifloat);
+DKEYWORD(immutable);
+DKEYWORD(import);
+DKEYWORD(in);
+DKEYWORD(inout);
+DKEYWORD(int);
+DKEYWORD(interface);
+DKEYWORD(invariant);
+DKEYWORD(ireal);
+DKEYWORD(is);
+DKEYWORD(lazy);
+DKEYWORD(long);
+DKEYWORD(macro);
+DKEYWORD(mixin);
+DKEYWORD(module);
+DKEYWORD(new);
+DKEYWORD(nothrow);
+DKEYWORD(null);
+DKEYWORD(out);
+DKEYWORD(override);
+DKEYWORD(package);
+DKEYWORD(pragma);
+DKEYWORD(private);
+DKEYWORD(protected);
+DKEYWORD(public);
+DKEYWORD(pure);
+DKEYWORD(real);
+DKEYWORD(ref);
+DKEYWORD(return);
+DKEYWORD(scope);
+DKEYWORD(shared);
+DKEYWORD(short);
+DKEYWORD(static);
+DKEYWORD(string);
+DKEYWORD(struct);
+DKEYWORD(super);
+DKEYWORD(switch);
+DKEYWORD(synchronized);
+DKEYWORD(template);
+DKEYWORD(this);
+DKEYWORD(throw);
+DKEYWORD(true);
+DKEYWORD(try);
+DKEYWORD(typedef);
+DKEYWORD(typeid);
+DKEYWORD(typeof);
+DKEYWORD(ubyte);
+DKEYWORD(ucent);
+DKEYWORD(uint);
+DKEYWORD(ulong);
+DKEYWORD(union);
+DKEYWORD(unittest);
+DKEYWORD(ushort);
+DKEYWORD(version);
+DKEYWORD(void);
+DKEYWORD(volatile);
+DKEYWORD(wchar);
+DKEYWORD(while);
+DKEYWORD(with);
+DKEYWORD(wstring);
+
+// Not really a keyword, but dispose() methods are generated in proxy classes
+// and it's a special method name for D1/Tango.
+DKEYWORD(dispose);
+
+#undef DKEYWORD
+
+#endif //D_DKW_SWG_

Lib/d/dmemberfunctionpointers.swg

@@ -0,0 +1,92 @@
+/* -----------------------------------------------------------------------------
+ * dmemberfunctionpointers.swg
+ *
+ * Typemaps for member function pointers.
+ * ----------------------------------------------------------------------------- */
+
+
+%typemap(ctype) SWIGTYPE (CLASS::*) "char *"
+%typemap(imtype) SWIGTYPE (CLASS::*) "char*"
+%typemap(dtype) SWIGTYPE (CLASS::*) "$dclassname"
+
+%typecheck(SWIG_TYPECHECK_POINTER)
+  SWIGTYPE (CLASS::*)
+  ""
+
+
+/*
+ * Conversion generation typemaps.
+ */
+
+%typemap(in, fragment="SWIG_UnPackData") SWIGTYPE (CLASS::*) %{
+  SWIG_UnpackData($input, (void *)&$1, sizeof($1));
+%}
+%typemap(out, fragment="SWIG_PackData") SWIGTYPE (CLASS::*) %{
+  char buf[128];
+  char *data = SWIG_PackData(buf, (void *)&$1, sizeof($1));
+  *data = '\0';
+  $result = SWIG_d_string_callback(buf);
+%}
+
+%typemap(directorin) SWIGTYPE (CLASS::*) "$input = (void *) $1;"
+%typemap(directorout, warning=SWIGWARN_TYPEMAP_DIRECTOROUT_PTR_MSG) SWIGTYPE (CLASS::*)
+  "$result = ($1_ltype)$input;"
+
+%typemap(ddirectorin) SWIGTYPE (CLASS::*)
+  "($winput is null) ? null : new $dclassname($winput, false)"
+%typemap(ddirectorout) SWIGTYPE (CLASS::*) "$dclassname.swigGetCPtr($dcall)"
+
+%typemap(din) SWIGTYPE (CLASS::*) "$dclassname.swigGetCMemberPtr($dinput)"
+%typemap(dout, excode=SWIGEXCODE) SWIGTYPE (CLASS::*) {
+  char* cMemberPtr = $imcall;
+  $dclassname ret = (cMemberPtr is null) ? null : new $dclassname(cMemberPtr, $owner);$excode
+  return ret;
+}
+
+
+/*
+ * Helper functions to pack/unpack arbitrary binary data (member function
+ * pointers in this case) into a string.
+ */
+
+%fragment("SWIG_PackData", "header") {
+/* Pack binary data into a string */
+SWIGINTERN char * SWIG_PackData(char *c, void *ptr, size_t sz) {
+  static const char hex[17] = "0123456789abcdef";
+  register const unsigned char *u = (unsigned char *) ptr;
+  register const unsigned char *eu =  u + sz;
+  for (; u != eu; ++u) {
+    register unsigned char uu = *u;
+    *(c++) = hex[(uu & 0xf0) >> 4];
+    *(c++) = hex[uu & 0xf];
+  }
+  return c;
+}
+}
+
+%fragment("SWIG_UnPackData", "header") {
+/* Unpack binary data from a string */
+SWIGINTERN const char * SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
+  register unsigned char *u = (unsigned char *) ptr;
+  register const unsigned char *eu = u + sz;
+  for (; u != eu; ++u) {
+    register char d = *(c++);
+    register unsigned char uu;
+    if ((d >= '0') && (d <= '9'))
+      uu = ((d - '0') << 4);
+    else if ((d >= 'a') && (d <= 'f'))
+      uu = ((d - ('a'-10)) << 4);
+    else
+      return (char *) 0;
+    d = *(c++);
+    if ((d >= '0') && (d <= '9'))
+      uu |= (d - '0');
+    else if ((d >= 'a') && (d <= 'f'))
+      uu |= (d - ('a'-10));
+    else
+      return (char *) 0;
+    *u = uu;
+  }
+  return c;
+}
+}

Lib/d/doperators.swg

@@ -0,0 +1,259 @@
+/* -----------------------------------------------------------------------------
+ * doperators.swg
+ *
+ * Mapping of C++ operator overloading methods to D.
+ * ----------------------------------------------------------------------------- */
+
+#if (SWIG_D_VERSION == 1)
+
+%pragma(d) imdmodulecode=%{
+template SwigOperatorDefinitions() {
+  public override int opEquals(Object o) {
+    if (auto rhs = cast(typeof(this))o) {
+      if (swigCPtr == rhs.swigCPtr) return 1;
+      static if (is(typeof(swigOpEquals(rhs)))) {
+        return swigOpEquals(rhs) ? 1 : 0;
+      } else {
+        return 0; 
+      }
+    }
+    return super.opEquals(o);
+  }
+%}
+// opEquals is emitted in pure C mode as well to define two proxy classes
+// pointing to the same struct as equal.
+
+#ifdef __cplusplus
+%rename(opPos) *::operator+();
+%rename(opPos) *::operator+() const;
+%rename(opNeg) *::operator-();
+%rename(opNeg) *::operator-() const;
+%rename(opCom) *::operator~();
+%rename(opCom) *::operator~() const;
+
+%rename(opAdd) *::operator+;
+%rename(opAddAssign) *::operator+=;
+%rename(opSub) *::operator-;
+%rename(opSubAssign) *::operator-=;
+%rename(opMul) *::operator*;
+%rename(opMulAssign) *::operator*=;
+%rename(opDiv) *::operator/;
+%rename(opDivAssign) *::operator/=;
+%rename(opMod) *::operator%;
+%rename(opModAssign) *::operator%=;
+%rename(opAnd) *::operator&;
+%rename(opAndAssign) *::operator&=;
+%rename(opOr) *::operator|;
+%rename(opOrAssign) *::operator|=;
+%rename(opXor) *::operator^;
+%rename(opXorAssign) *::operator^=;
+%rename(opShl) *::operator<<;
+%rename(opShlAssign) *::operator<<=;
+%rename(opShr) *::operator>>;
+%rename(opShrAssign) *::operator>>=;
+
+%rename(opIndex) *::operator[](unsigned) const;
+// opIndexAssign is not currently generated, it needs more extensive support
+// mechanisms.
+
+%rename(opCall) *::operator();
+  
+// !a is not overrideable in D1.
+%ignoreoperator(LNOT) operator!;
+
+// opCmp is used in D.
+%rename(swigOpEquals) *::operator==;
+%rename(swigOpLt) *::operator<;
+%rename(swigOpLtEquals) *::operator<=;
+%rename(swigOpGt) *::operator>;
+%rename(swigOpGtEquals) *::operator>=;
+
+// a != b is rewritten as !a.opEquals(b) in D.
+%ignoreoperator(NOTEQUAL) operator!=;
+
+// The logic operators are not overrideable in D.
+%ignoreoperator(LAND) operator&&;
+%ignoreoperator(LOR) operator||;
+
+// ++/--a is rewritten as a +/-= 1 in D1,so ignore the prefix operators.
+%ignoreoperator(PLUSPLUS) *::operator++();
+%ignoreoperator(MINUSMINUS) *::operator--();
+%rename(swigOpInc) *::operator++(int);
+%rename(swigOpDec) *::operator--(int);
+
+// The C++ assignment operator does not translate well to D where the proxy
+// classes have reference semantics.
+%ignoreoperator(EQ) operator=;
+
+%pragma(d) imdmodulecode=%{
+  public override int opCmp(Object o) {
+    static if (is(typeof(swigOpLt(typeof(this).init) &&
+        swigOpEquals(typeof(this).init)))) {
+      if (auto rhs = cast(typeof(this))o) {
+        if (swigOpLt(rhs)) {
+          return -1;
+        } else if (swigOpEquals(rhs)) {
+          return 0;
+        } else {
+          return 1;
+        }
+      }
+    }
+    return super.opCmp(o);
+  }
+
+  public typeof(this) opPostInc(T = int)(T unused = 0) {
+    static assert(
+      is(typeof(swigOpInc(int.init))),
+      "opPostInc called on " ~ typeof(this).stringof ~ ", but no postfix " ~
+        "increment operator exists in the corresponding C++ class."
+    );
+    return swigOpInc(int.init);
+  }
+
+  public typeof(this) opPostDec(T = int)(T unused = 0) {
+    static assert(
+      is(typeof(swigOpDec(int.init))),
+      "opPostInc called on " ~ typeof(this).stringof ~ ", but no postfix " ~
+        "decrement operator exists in the corresponding C++ class."
+    );
+    return swigOpDec(int.init);
+  }
+%}
+#endif
+
+%pragma(d) imdmodulecode=%{
+}
+%}
+
+#else
+%pragma(d) imdmodulecode=%{
+mixin template SwigOperatorDefinitions() {
+  public override bool opEquals(Object o) {
+    if (auto rhs = cast(typeof(this))o) {
+      if (swigCPtr == rhs.swigCPtr) return true;
+      static if (is(typeof(swigOpEquals(rhs)))) {
+        return swigOpEquals(rhs);
+      } else {
+        return false; 
+      }
+    }
+    return super.opEquals(o);
+  }
+%}
+// opEquals is emitted in pure C mode as well to define two proxy classes
+// pointing to the same struct as equal.
+
+#ifdef __cplusplus
+%rename(swigOpPos) *::operator+();
+%rename(swigOpPos) *::operator+() const;
+%rename(swigOpNeg) *::operator-();
+%rename(swigOpNeg) *::operator-() const;
+%rename(swigOpCom) *::operator~();
+%rename(swigOpCom) *::operator~() const;
+%rename(swigOpInc) *::operator++();
+%rename(swigOpDec) *::operator--();
+%ignoreoperator(PLUSPLUS) *::operator++(int);
+%ignoreoperator(MINUSMINUS) *::operator--(int);
+// The postfix increment/decrement operators are ignored because they are
+// rewritten to (auto t = e, ++e, t) in D2. The unary * operator (used for
+// pointer dereferencing in C/C++) isn't mapped to opUnary("*") by default,
+// despite this would be possible in D2 – the difference in member access
+// semantics would only lead to confusion in most cases.
+
+%rename(swigOpAdd) *::operator+;
+%rename(swigOpSub) *::operator-;
+%rename(swigOpMul) *::operator*;
+%rename(swigOpDiv) *::operator/;
+%rename(swigOpMod) *::operator%;
+%rename(swigOpAnd) *::operator&;
+%rename(swigOpOr) *::operator|;
+%rename(swigOpXor) *::operator^;
+%rename(swigOpShl) *::operator<<;
+%rename(swigOpShr) *::operator>>;
+
+%rename(swigOpAddAssign) *::operator+=;
+%rename(swigOpSubAssign) *::operator-=;
+%rename(swigOpMulAssign) *::operator*=;
+%rename(swigOpDivAssign) *::operator/=;
+%rename(swigOpModAssign) *::operator%=;
+%rename(swigOpAndAssign) *::operator&=;
+%rename(swigOpOrAssign) *::operator|=;
+%rename(swigOpXorAssign) *::operator^=;
+%rename(swigOpShlAssign) *::operator<<=;
+%rename(swigOpShrAssign) *::operator>>=;
+
+%rename(opIndex) *::operator[];
+// opIndexAssign is not currently generated, it needs more extensive support
+// mechanisms.
+
+%rename(opCall) *::operator();
+
+%rename(swigOpEquals) *::operator==;
+%rename(swigOpLt) *::operator<;
+%rename(swigOpLtEquals) *::operator<=;
+%rename(swigOpGt) *::operator>;
+%rename(swigOpGtEquals) *::operator>=;
+
+// a != b is rewritten as !a.opEquals(b) in D.
+%ignoreoperator(NOTEQUAL) operator!=;
+
+// The logic operators are not overrideable in D.
+%ignoreoperator(LAND) operator&&;
+%ignoreoperator(LOR) operator||;
+
+// The C++ assignment operator does not translate well to D where the proxy
+// classes have reference semantics.
+%ignoreoperator(EQ) operator=;
+
+%pragma(d) imdmodulecode=%{  
+  public override int opCmp(Object o) {
+    static if (__traits(compiles, swigOpLt(typeof(this).init) &&
+        swigOpEquals(typeof(this).init))) {
+      if (auto rhs = cast(typeof(this))o) {
+        if (swigOpLt(rhs)) {
+          return -1;
+        } else if (swigOpEquals(rhs)) {
+          return 0;
+        } else {
+          return 1;
+        }
+      }
+    }
+    return super.opCmp(o);
+  }
+
+  private template swigOpBinary(string operator, string name) {
+    enum swigOpBinary = `public void opOpAssign(string op, T)(T rhs) if (op == "` ~ operator ~
+      `" && __traits(compiles, swigOp` ~ name ~ `Assign(rhs))) { swigOp` ~ name ~ `Assign(rhs);}` ~
+      `public auto opBinary(string op, T)(T rhs) if (op == "` ~ operator ~
+      `" && __traits(compiles, swigOp` ~ name ~ `(rhs))) { return swigOp` ~ name ~ `(rhs);}`;
+  }
+  mixin(swigOpBinary!("+", "Add"));
+  mixin(swigOpBinary!("-", "Sub"));
+  mixin(swigOpBinary!("*", "Mul"));
+  mixin(swigOpBinary!("/", "Div"));
+  mixin(swigOpBinary!("%", "Mod"));
+  mixin(swigOpBinary!("&", "And"));
+  mixin(swigOpBinary!("|", "Or"));
+  mixin(swigOpBinary!("^", "Xor"));
+  mixin(swigOpBinary!("<<", "Shl"));
+  mixin(swigOpBinary!(">>", "Shr"));
+  
+  private template swigOpUnary(string operator, string name) {
+    enum swigOpUnary = `public auto opUnary(string op)() if (op == "` ~ operator ~
+      `" && __traits(compiles, swigOp` ~ name ~ `())) { return swigOp` ~ name ~ `();}`;   
+  }
+  mixin(swigOpUnary!("+", "Pos"));
+  mixin(swigOpUnary!("-", "Neg"));
+  mixin(swigOpUnary!("~", "Com"));
+  mixin(swigOpUnary!("++", "Inc"));
+  mixin(swigOpUnary!("--", "Dec"));
+%}
+#endif
+
+%pragma(d) imdmodulecode=%{
+}
+%}
+
+#endif

Lib/d/dprimitives.swg

@@ -0,0 +1,158 @@
+/* -----------------------------------------------------------------------------
+ * dprimitves.swg
+ *
+ * Typemaps for primitive types.
+ * ----------------------------------------------------------------------------- */
+
+/*
+ * The SWIG_D_PRIMITIVE macro is used to define the typemaps for the primitive
+ * types, because are more or less the same for all of them. The few special
+ * cases are handeled below.
+ */
+%define SWIG_D_PRIMITIVE(TYPE, DTYPE)
+%typemap(ctype) TYPE, const TYPE & "TYPE"
+%typemap(imtype) TYPE, const TYPE & "DTYPE"
+%typemap(dtype, cprimitive="1") TYPE, const TYPE & "DTYPE"
+
+%typemap(in) TYPE "$1 = ($1_ltype)$input;"
+%typemap(out) TYPE "$result = $1;"
+%typemap(directorin) TYPE "$input = $1;"
+%typemap(directorout) TYPE "$result = ($1_ltype)$input;"
+%typemap(ddirectorin) TYPE "$winput"
+%typemap(ddirectorout) TYPE "$dcall"
+
+%typemap(in) const TYPE & ($*1_ltype temp)
+%{ temp = ($*1_ltype)$input;
+   $1 = &temp; %}
+%typemap(out) const TYPE & "$result = *$1;"
+%typemap(directorin) const TYPE & "$input = $1_name;"
+%typemap(directorout,warning=SWIGWARN_TYPEMAP_THREAD_UNSAFE_MSG) const TYPE &
+%{ static $*1_ltype temp;
+   temp = ($*1_ltype)$input;
+   $result = &temp; %}
+%typemap(ddirectorin) const TYPE & "$winput"
+%typemap(ddirectorout) const TYPE & "$dcall"
+
+%typemap(din) TYPE, const TYPE & "$dinput"
+%typemap(dout, excode=SWIGEXCODE) TYPE, const TYPE & {
+  auto ret = $imcall;$excode
+  return ret;
+}
+%enddef
+
+
+SWIG_D_PRIMITIVE(bool, bool)
+SWIG_D_PRIMITIVE(char, char)
+SWIG_D_PRIMITIVE(signed char, byte)
+SWIG_D_PRIMITIVE(unsigned char, ubyte)
+SWIG_D_PRIMITIVE(short, short)
+SWIG_D_PRIMITIVE(unsigned short, ushort)
+SWIG_D_PRIMITIVE(int, int)
+SWIG_D_PRIMITIVE(unsigned int, uint)
+SWIG_D_PRIMITIVE(long, int)
+SWIG_D_PRIMITIVE(unsigned long, uint)
+SWIG_D_PRIMITIVE(size_t, size_t)
+SWIG_D_PRIMITIVE(long long, long)
+SWIG_D_PRIMITIVE(unsigned long long, ulong)
+SWIG_D_PRIMITIVE(float, float)
+SWIG_D_PRIMITIVE(double, double)
+
+
+// The C++ boolean type needs some special casing since it is not part of the
+// C standard and is thus represented as unsigned int in the C wrapper layer.
+%typemap(ctype) bool, const bool & "unsigned int"
+%typemap(imtype) bool, const bool & "uint"
+
+%typemap(in) bool "$1 = $input ? true : false;"
+%typemap(in) const bool & ($*1_ltype temp)
+%{ temp = $input ? true : false;
+   $1 = &temp; %}
+
+%typemap(directorout) bool
+  "$result = $input ? true : false;"
+%typemap(directorout,warning=SWIGWARN_TYPEMAP_THREAD_UNSAFE_MSG) const bool &
+%{ static $*1_ltype temp;
+   temp = $input ? true : false;
+   $result = &temp; %}
+
+%typemap(ddirectorin) bool "($winput ? true : false)"
+
+%typemap(dout, excode=SWIGEXCODE) bool, const bool & {
+  bool ret = $imcall ? true : false;$excode
+  return ret;
+}
+
+
+// Judging from the history of the C# module, the explicit casts are needed for
+// certain versions of VC++.
+%typemap(out) unsigned long "$result = (unsigned long)$1;"
+%typemap(out) const unsigned long & "$result = (unsigned long)*$1;"
+
+
+/*
+ * Typecheck typemaps.
+ */
+
+%typecheck(SWIG_TYPECHECK_BOOL)
+    bool,
+    const bool &
+    ""
+
+%typecheck(SWIG_TYPECHECK_CHAR)
+    char,
+    const char &
+    ""
+
+%typecheck(SWIG_TYPECHECK_INT8)
+    signed char,
+    const signed char &
+    ""
+
+%typecheck(SWIG_TYPECHECK_UINT8)
+    unsigned char,
+    const unsigned char &
+    ""
+
+%typecheck(SWIG_TYPECHECK_INT16)
+    short,
+    const short &
+    ""
+
+%typecheck(SWIG_TYPECHECK_UINT16)
+    unsigned short,
+    const unsigned short &
+    ""
+
+%typecheck(SWIG_TYPECHECK_INT32)
+    int,
+    long,
+    const int &,
+    const long &
+    ""
+
+%typecheck(SWIG_TYPECHECK_UINT32)
+    unsigned int,
+    unsigned long,
+    const unsigned int &,
+    const unsigned long &
+    ""
+
+%typecheck(SWIG_TYPECHECK_INT64)
+    long long,
+    const long long &
+    ""
+
+%typecheck(SWIG_TYPECHECK_UINT64)
+    unsigned long long,
+    const unsigned long long &
+    ""
+
+%typecheck(SWIG_TYPECHECK_FLOAT)
+    float,
+    const float &
+    ""
+
+%typecheck(SWIG_TYPECHECK_DOUBLE)
+    double,
+    const double &
+    ""

Lib/d/dstrings.swg

@@ -0,0 +1,80 @@
+/* -----------------------------------------------------------------------------
+ * dstrings.swg
+ *
+ * Typemaps for wrapping pointers to/arrays of C chars as D strings.
+ * ----------------------------------------------------------------------------- */
+
+%define SWIGD_STRING_TYPEMAPS(DW_STRING_TYPE, DP_STRING_TYPE, FROM_STRINGZ, TO_STRINGZ)
+%typemap(ctype) char *, char *&, char[ANY], char[]   "char *"
+%typemap(imtype) char *, char *&, char[ANY], char[]   #DW_STRING_TYPE
+%typemap(dtype) char *, char *&, char[ANY], char[]   #DP_STRING_TYPE
+
+
+/*
+ * char* typemaps.
+ */
+
+%typemap(in) char * %{ $1 = ($1_ltype)$input; %}
+%typemap(out) char * %{ $result = SWIG_d_string_callback((const char *)$1); %}
+%typemap(directorout, warning=SWIGWARN_TYPEMAP_DIRECTOROUT_PTR_MSG) char * %{ $result = ($1_ltype)$input; %}
+%typemap(directorin) char * %{ $input = SWIG_d_string_callback((const char *)$1); %}
+%typemap(ddirectorin) char * "FROM_STRINGZ($winput)"
+%typemap(ddirectorout) char * "TO_STRINGZ($dcall)"
+
+
+/*
+ * char*& typemaps.
+ */
+
+%typemap(in) char *& ($*1_ltype temp = 0) %{
+  temp = ($*1_ltype)$input;
+  $1 = &temp;
+%}
+%typemap(out) char *& %{ if ($1) $result = SWIG_d_string_callback((const char *)*$1); %}
+
+
+/*
+ * char array typemaps.
+ */
+
+%typemap(in) char[ANY], char[] %{ $1 = ($1_ltype)$input; %}
+%typemap(out) char[ANY], char[] %{ $result = SWIG_d_string_callback((const char *)$1); %}
+
+%typemap(directorout) char[ANY], char[] %{ $result = ($1_ltype)$input; %}
+%typemap(directorin) char[ANY], char[] %{ $input = SWIG_d_string_callback((const char *)$1); %}
+
+%typemap(ddirectorin) char[ANY], char[] "$winput"
+%typemap(ddirectorout) char[ANY], char[] "$dcall"
+
+
+%typemap(din) char *, char *&, char[ANY], char[] "($dinput ? TO_STRINGZ($dinput) : null)"
+%typemap(dout, excode=SWIGEXCODE) char *, char *&, char[ANY], char[] {
+  DP_STRING_TYPE ret = FROM_STRINGZ ## ($imcall);$excode
+  return ret;
+}
+
+%typecheck(SWIG_TYPECHECK_STRING)
+    char *,
+    char *&,
+    char[ANY],
+    char[]
+  ""
+%enddef
+
+
+// We need to have the \0-terminated string conversion functions available in
+// the D proxy modules.
+#if (SWIG_D_VERSION == 1)
+// Could be easily extended to support Phobos as well.
+SWIGD_STRING_TYPEMAPS(char*, char[], tango.stdc.stringz.fromStringz, tango.stdc.stringz.toStringz)
+
+%pragma(d) globalproxyimports = "static import tango.stdc.stringz;";
+#else
+SWIGD_STRING_TYPEMAPS(const(char)*, string, std.conv.to!string, std.string.toStringz)
+
+%pragma(d) globalproxyimports = %{
+static import std.conv;
+static import std.string;
+%}
+#endif
+#undef SWIGD_STRING_TYPEMAPS

Lib/d/dswigtype.swg

@@ -0,0 +1,184 @@
+/* -----------------------------------------------------------------------------
+ * dswigtype.swg
+ *
+ * Typemaps for non-primitive types (C/C++ classes and structs).
+ * ----------------------------------------------------------------------------- */
+
+%typemap(ctype) SWIGTYPE "void *"
+%typemap(imtype) SWIGTYPE "void*"
+%typemap(dtype) SWIGTYPE "$&dclassname"
+
+%typemap(ctype) SWIGTYPE [] "void *"
+%typemap(imtype) SWIGTYPE [] "void*"
+%typemap(dtype) SWIGTYPE [] "$dclassname"
+
+%typemap(ctype) SWIGTYPE * "void *"
+%typemap(imtype) SWIGTYPE * "void*"
+%typemap(dtype, nativepointer="$dtype") SWIGTYPE * "$dclassname"
+
+%typemap(ctype) SWIGTYPE & "void *"
+%typemap(imtype) SWIGTYPE & "void*"
+%typemap(dtype, nativepointer="$dtype") SWIGTYPE & "$dclassname"
+
+%typemap(ctype) SWIGTYPE *const& "void *"
+%typemap(imtype) SWIGTYPE *const& "void*"
+%typemap(dtype) SWIGTYPE *const& "$*dclassname"
+
+%typecheck(SWIG_TYPECHECK_POINTER)
+    SWIGTYPE,
+    SWIGTYPE *,
+    SWIGTYPE &,
+    SWIGTYPE [],
+    SWIGTYPE *const&
+  ""
+
+
+/*
+ * By-value conversion typemaps (parameter is converted to a pointer).
+ */
+
+%typemap(in, canthrow=1) SWIGTYPE ($&1_type argp)
+%{ argp = ($&1_ltype)$input;
+   if (!argp) {
+     SWIG_DSetPendingException(SWIG_DIllegalArgumentException, "Attempt to dereference null $1_type");
+     return $null;
+   }
+   $1 = *argp; %}
+
+%typemap(out) SWIGTYPE
+#ifdef __cplusplus
+%{ $result = new $1_ltype((const $1_ltype &)$1); %}
+#else
+{
+  $&1_ltype $1ptr = ($&1_ltype) malloc(sizeof($1_ltype));
+  memmove($1ptr, &$1, sizeof($1_type));
+  $result = $1ptr;
+}
+#endif
+
+%typemap(directorin) SWIGTYPE
+  "$input = (void *)&$1;"
+%typemap(directorout) SWIGTYPE
+%{ if (!$input) {
+     SWIG_DSetPendingException(SWIG_DIllegalArgumentException, "Unexpected null return for type $1_type");
+     return $null;
+   }
+   $result = *($&1_ltype)$input; %}
+
+%typemap(ddirectorin) SWIGTYPE "new $&dclassname($winput, false)"
+%typemap(ddirectorout) SWIGTYPE "$&dclassname.swigGetCPtr($dcall)"
+
+%typemap(din) SWIGTYPE "$&dclassname.swigGetCPtr($dinput)"
+%typemap(dout, excode=SWIGEXCODE) SWIGTYPE {
+  $&dclassname ret = new $&dclassname($imcall, true);$excode
+  return ret;
+}
+
+
+/*
+ * Pointer conversion typemaps.
+ */
+
+%typemap(in) SWIGTYPE * "$1 = ($1_ltype)$input;"
+%typemap(out) SWIGTYPE * "$result = (void *)$1;"
+
+%typemap(directorin) SWIGTYPE *
+  "$input = (void *) $1;"
+%typemap(directorout, warning=SWIGWARN_TYPEMAP_DIRECTOROUT_PTR_MSG) SWIGTYPE *
+  "$result = ($1_ltype)$input;"
+
+%typemap(ddirectorin,
+  nativepointer="cast($dtype)$winput"
+) SWIGTYPE * "($winput is null) ? null : new $dclassname($winput, false)"
+
+%typemap(ddirectorout,
+  nativepointer="cast(void*)$dcall"
+) SWIGTYPE * "$dclassname.swigGetCPtr($dcall)"
+
+%typemap(din,
+  nativepointer="cast(void*)$dinput"
+) SWIGTYPE * "$dclassname.swigGetCPtr($dinput)"
+
+%typemap(dout, excode=SWIGEXCODE,
+  nativepointer="{\n  auto ret = cast($dtype)$imcall;$excode\n  return ret;\n}"
+) SWIGTYPE * {
+  void* cPtr = $imcall;
+  $dclassname ret = (cPtr is null) ? null : new $dclassname(cPtr, $owner);$excode
+  return ret;
+}
+
+// Use the same typemaps for const pointers.
+%apply SWIGTYPE * { SWIGTYPE *const }
+
+
+/*
+ * Reference conversion typemaps.
+ */
+
+%typemap(in, canthrow=1) SWIGTYPE & %{ $1 = ($1_ltype)$input;
+  if (!$1) {
+    SWIG_DSetPendingException(SWIG_DIllegalArgumentException, "$1_type type is null");
+    return $null;
+  } %}
+%typemap(out) SWIGTYPE & "$result = (void *)$1;"
+
+%typemap(directorin) SWIGTYPE &
+  "$input = ($1_ltype) &$1;"
+%typemap(directorout, warning=SWIGWARN_TYPEMAP_DIRECTOROUT_PTR_MSG) SWIGTYPE &
+%{ if (!$input) {
+     SWIG_DSetPendingException(SWIG_DIllegalArgumentException, "Unexpected null return for type $1_type");
+     return $null;
+   }
+   $result = ($1_ltype)$input; %}
+
+%typemap(ddirectorin,
+  nativepointer="cast($dtype)$winput"
+) SWIGTYPE & "new $dclassname($winput, false)"
+%typemap(ddirectorout,
+  nativepointer="cast(void*)$dcall"
+) SWIGTYPE & "$dclassname.swigGetCPtr($dcall)"
+
+%typemap(din,
+  nativepointer="cast(void*)$dinput"
+) SWIGTYPE & "$dclassname.swigGetCPtr($dinput)"
+%typemap(dout, excode=SWIGEXCODE,
+  nativepointer="{\n  auto ret = cast($dtype)$imcall;$excode\n  return ret;\n}") SWIGTYPE & {
+  $dclassname ret = new $dclassname($imcall, $owner);$excode
+  return ret;
+}
+
+
+/*
+ * Array conversion typemaps.
+ */
+
+%typemap(in) SWIGTYPE [] %{ $1 = ($1_ltype)$input; %}
+%typemap(out) SWIGTYPE [] %{ $result = $1; %}
+
+%typemap(din) SWIGTYPE [] "$dclassname.swigGetCPtr($dinput)"
+%typemap(dout, excode=SWIGEXCODE) SWIGTYPE [] {
+  void* cPtr = $imcall;
+  $dclassname ret = (cPtr is null) ? null : new $dclassname(cPtr, $owner);$excode
+  return ret;
+}
+
+// Treat references to arrays like like references to a single element.
+%apply SWIGTYPE & { SWIGTYPE ((&)[ANY]) }
+
+
+/*
+ * Pointer reference conversion typemaps.
+ */
+
+%typemap(in) SWIGTYPE *const& ($*1_ltype temp = 0)
+%{ temp = ($*1_ltype)$input;
+   $1 = ($1_ltype)&temp; %}
+%typemap(out) SWIGTYPE *const&
+%{ $result = (void *)*$1; %}
+
+%typemap(din) SWIGTYPE *const& "$*dclassname.swigGetCPtr($dinput)"
+%typemap(dout, excode=SWIGEXCODE) SWIGTYPE *const& {
+  void* cPtr = $imcall;
+  $*dclassname ret = (cPtr is null) ? null : new $*dclassname(cPtr, $owner);$excode
+  return ret;
+}

Lib/d/dvoid.swg

@@ -0,0 +1,18 @@
+/* -----------------------------------------------------------------------------
+ * dvoid.swg
+ *
+ * Typemaps for handling void function return types and empty parameter lists.
+ * ----------------------------------------------------------------------------- */
+
+%typemap(ctype) void "void"
+%typemap(imtype) void "void"
+%typemap(dtype, cprimitive="1") void "void"
+
+%typemap(out, null="") void ""
+%typemap(ddirectorin) void "$winput"
+%typemap(ddirectorout) void "$dcall"
+%typemap(directorin) void ""
+
+%typemap(dout, excode=SWIGEXCODE) void {
+  $imcall;$excode
+}

Lib/d/std_common.i

@@ -0,0 +1,5 @@
+%include <std_except.i>
+
+%apply size_t { std::size_t };
+%apply const size_t& { const std::size_t& };
+

Lib/d/std_deque.i

@@ -0,0 +1 @@
+%include <std/_std_deque.i>

Lib/d/std_except.i

@@ -0,0 +1,30 @@
+/* -----------------------------------------------------------------------------
+ * std_except.i
+ *
+ * Typemaps used by the STL wrappers that throw exceptions. These typemaps are
+ * used when methods are declared with an STL exception specification, such as
+ *   size_t at() const throw (std::out_of_range);
+ * ----------------------------------------------------------------------------- */
+
+%{
+#include <stdexcept>
+%}
+
+namespace std
+{
+  %ignore exception;
+  struct exception {};
+}
+
+%typemap(throws, canthrow=1) std::bad_exception     "SWIG_DSetPendingException(SWIG_DException, $1.what());\n return $null;"
+%typemap(throws, canthrow=1) std::domain_error      "SWIG_DSetPendingException(SWIG_DException, $1.what());\n return $null;"
+%typemap(throws, canthrow=1) std::exception         "SWIG_DSetPendingException(SWIG_DException, $1.what());\n return $null;"
+%typemap(throws, canthrow=1) std::invalid_argument  "SWIG_DSetPendingException(SWIG_DIllegalArgumentException, $1.what());\n return $null;"
+%typemap(throws, canthrow=1) std::length_error      "SWIG_DSetPendingException(SWIG_DNoSuchElementException, $1.what());\n return $null;"
+%typemap(throws, canthrow=1) std::logic_error       "SWIG_DSetPendingException(SWIG_DException, $1.what());\n return $null;"
+%typemap(throws, canthrow=1) std::out_of_range      "SWIG_DSetPendingException(SWIG_DNoSuchElementException, $1.what());\n return $null;"
+%typemap(throws, canthrow=1) std::overflow_error    "SWIG_DSetPendingException(SWIG_DException, $1.what());\n return $null;"
+%typemap(throws, canthrow=1) std::range_error       "SWIG_DSetPendingException(SWIG_DException, $1.what());\n return $null;"
+%typemap(throws, canthrow=1) std::runtime_error     "SWIG_DSetPendingException(SWIG_DException, $1.what());\n return $null;"
+%typemap(throws, canthrow=1) std::underflow_error   "SWIG_DSetPendingException(SWIG_DException, $1.what());\n return $null;"
+

Lib/d/std_map.i

@@ -0,0 +1,59 @@
+/* -----------------------------------------------------------------------------
+ * std_map.i
+ *
+ * SWIG typemaps for std::map
+ * ----------------------------------------------------------------------------- */
+
+%include <std_common.i>
+
+// ------------------------------------------------------------------------
+// std::map
+// ------------------------------------------------------------------------
+
+%{
+#include <map>
+#include <algorithm>
+#include <stdexcept>
+%}
+
+// exported class
+
+namespace std {
+    template<class K, class T> class map {
+        // add typemaps here
+      public:
+        typedef size_t size_type;
+        typedef ptrdiff_t difference_type;
+        typedef K key_type;
+        typedef T mapped_type;
+        map();
+        map(const map<K,T> &);
+
+        unsigned int size() const;
+        bool empty() const;
+        void clear();
+        %extend {
+            const T& get(const K& key) throw (std::out_of_range) {
+                std::map<K,T >::iterator i = self->find(key);
+                if (i != self->end())
+                    return i->second;
+                else
+                    throw std::out_of_range("key not found");
+            }
+            void set(const K& key, const T& x) {
+                (*self)[key] = x;
+            }
+            void del(const K& key) throw (std::out_of_range) {
+                std::map<K,T >::iterator i = self->find(key);
+                if (i != self->end())
+                    self->erase(i);
+                else
+                    throw std::out_of_range("key not found");
+            }
+            bool has_key(const K& key) {
+                std::map<K,T >::iterator i = self->find(key);
+                return i != self->end();
+            }
+        }
+    };
+}

Lib/d/std_pair.i

@@ -0,0 +1,34 @@
+/* -----------------------------------------------------------------------------
+ * std_pair.i
+ *
+ * SWIG typemaps for std::pair
+ * ----------------------------------------------------------------------------- */
+
+%include <std_common.i>
+%include <exception.i>
+
+// ------------------------------------------------------------------------
+// std::pair
+// ------------------------------------------------------------------------
+
+%{
+#include <utility>
+%}
+
+namespace std {
+
+  template<class T, class U> struct pair {
+
+    pair();
+    pair(T t, U u);
+    pair(const pair& p);
+
+    template <class U1, class U2> pair(const pair<U1, U2> &p);
+
+    T first;
+    U second;
+  };
+
+  // add specializations here
+
+}

Lib/d/std_shared_ptr.i

@@ -0,0 +1,2 @@
+#define SWIG_SHARED_PTR_NAMESPACE std
+%include <boost_shared_ptr.i>

Lib/d/std_string.i

@@ -0,0 +1,98 @@
+/* -----------------------------------------------------------------------------
+ * std_string.i
+ *
+ * Typemaps for std::string and const std::string&
+ * These are mapped to a D char[] and are passed around by value.
+ *
+ * To use non-const std::string references, use the following %apply. Note
+ * that they are passed by value.
+ * %apply const std::string & {std::string &};
+ * ----------------------------------------------------------------------------- */
+
+%{
+#include <string>
+%}
+
+namespace std {
+
+%naturalvar string;
+
+class string;
+
+%define SWIGD_STD_STRING_TYPEMAPS(DW_STRING_TYPE, DP_STRING_TYPE, FROM_STRINGZ, TO_STRINGZ)
+// string
+%typemap(ctype) string, const string & "char *"
+%typemap(imtype) string, const string & #DW_STRING_TYPE
+%typemap(dtype) string, const string & #DP_STRING_TYPE
+
+%typemap(in, canthrow=1) string, const string &
+%{ if (!$input) {
+    SWIG_DSetPendingException(SWIG_DIllegalArgumentException, "null string");
+    return $null;
+  }
+  $1.assign($input); %}
+%typemap(in, canthrow=1) const string &
+%{ if (!$input) {
+    SWIG_DSetPendingException(SWIG_DIllegalArgumentException, "null string");
+    return $null;
+   }
+   std::string $1_str($input);
+   $1 = &$1_str; %}
+
+%typemap(out) string %{ $result = SWIG_d_string_callback($1.c_str()); %}
+%typemap(out) const string & %{ $result = SWIG_d_string_callback($1->c_str()); %}
+
+%typemap(din) string, const string & "($dinput ? TO_STRINGZ($dinput) : null)"
+%typemap(dout, excode=SWIGEXCODE) string, const string & {
+  DP_STRING_TYPE ret = FROM_STRINGZ($imcall);$excode
+  return ret;
+}
+
+%typemap(directorin) string, const string & %{ $input = SWIG_d_string_callback($1.c_str()); %}
+
+%typemap(directorout, canthrow=1) string
+%{ if (!$input) {
+    SWIG_DSetPendingException(SWIG_DIllegalArgumentException, "null string");
+    return $null;
+  }
+  $result.assign($input); %}
+
+%typemap(directorout, canthrow=1, warning=SWIGWARN_TYPEMAP_THREAD_UNSAFE_MSG) const string &
+%{ if (!$input) {
+    SWIG_DSetPendingException(SWIG_DIllegalArgumentException, "null string");
+    return $null;
+  }
+  /* possible thread/reentrant code problem */
+  static std::string $1_str;
+  $1_str = $input;
+  $result = &$1_str; %}
+
+%typemap(ddirectorin) string, const string & "FROM_STRINGZ($winput)"
+%typemap(ddirectorout) string, const string & "TO_STRINGZ($dcall)"
+
+%typemap(throws, canthrow=1) string, const string &
+%{ SWIG_DSetPendingException(SWIG_DException, $1.c_str());
+  return $null; %}
+
+%typemap(typecheck) string, const string & = char *;
+%enddef
+
+// We need to have the \0-terminated string conversion functions available in
+// the D proxy modules.
+#if (SWIG_D_VERSION == 1)
+// Could be easily extended to support Phobos as well.
+SWIGD_STD_STRING_TYPEMAPS(char*, char[], tango.stdc.stringz.fromStringz, tango.stdc.stringz.toStringz)
+
+%pragma(d) globalproxyimports = "static import tango.stdc.stringz;";
+#else
+SWIGD_STD_STRING_TYPEMAPS(const(char)*, string, std.conv.to!string, std.string.toStringz)
+
+%pragma(d) globalproxyimports = %{
+static import std.conv;
+static import std.string;
+%}
+#endif
+
+#undef SWIGD_STD_STRING_TYPEMAPS
+
+} // namespace std

Lib/d/std_vector.i

@@ -0,0 +1,591 @@
+/* -----------------------------------------------------------------------------
+ * std_vector.i
+ *
+ * SWIG typemaps for std::vector<T>, D implementation.
+ *
+ * The D wrapper is made to loosely resemble a tango.util.container.more.Vector
+ * and to provide built-in array-like access.
+ *
+ * If T does define an operator==, then use the SWIG_STD_VECTOR_ENHANCED
+ * macro to obtain enhanced functionality (none yet), for example:
+ *
+ *   SWIG_STD_VECTOR_ENHANCED(SomeNamespace::Klass)
+ *   %template(VectKlass) std::vector<SomeNamespace::Klass>;
+ *
+ * Warning: heavy macro usage in this file. Use swig -E to get a sane view on
+ * the real file contents!
+ * ----------------------------------------------------------------------------- */
+
+// Warning: Use the typemaps here in the expectation that the macros they are in will change name.
+
+%include <std_common.i>
+
+// MACRO for use within the std::vector class body
+%define SWIG_STD_VECTOR_MINIMUM_INTERNAL(CONST_REFERENCE, CTYPE...)
+#if (SWIG_D_VERSION == 1)
+%typemap(dimports) std::vector< CTYPE > "static import tango.core.Exception;"
+%typemap(dcode) std::vector< CTYPE > %{
+public this($typemap(dtype, CTYPE)[] values) {
+  this();
+  append(values);
+}
+
+alias push_back add;
+alias push_back push;
+alias push_back opCatAssign;
+alias size length;
+alias opSlice slice;
+
+public $typemap(dtype, CTYPE) opIndexAssign($typemap(dtype, CTYPE) value, size_t index) {
+  if (index >= size()) {
+    throw new tango.core.Exception.NoSuchElementException("Tried to assign to element out of vector bounds.");
+  }
+  setElement(index, value);
+  return value;
+}
+
+public $typemap(dtype, CTYPE) opIndex(size_t index) {
+  if (index >= size()) {
+    throw new tango.core.Exception.NoSuchElementException("Tried to read from element out of vector bounds.");
+  }
+  return getElement(index);
+}
+
+public void append($typemap(dtype, CTYPE)[] value...) {
+  foreach (v; value) {
+    add(v);
+  }
+}
+
+public $typemap(dtype, CTYPE)[] opSlice() {
+  $typemap(dtype, CTYPE)[] array = new $typemap(dtype, CTYPE)[size()];
+  foreach (i, ref value; array) {
+    value = getElement(i);
+  }
+  return array;
+}
+
+public int opApply(int delegate(ref $typemap(dtype, CTYPE) value) dg) {
+  int result;
+
+  size_t currentSize = size();
+  for (size_t i = 0; i < currentSize; ++i) {
+    auto value = getElement(i);
+    result = dg(value);
+    setElement(i, value);
+  }
+  return result;
+}
+
+public int opApply(int delegate(ref size_t index, ref $typemap(dtype, CTYPE) value) dg) {
+  int result;
+
+  size_t currentSize = size();
+  for (size_t i = 0; i < currentSize; ++i) {
+    auto value = getElement(i);
+
+    // Workaround for http://d.puremagic.com/issues/show_bug.cgi?id=2443.
+    auto index = i;
+
+    result = dg(index, value);
+    setElement(i, value);
+  }
+  return result;
+}
+
+public void capacity(size_t value) {
+  if (value < size()) {
+    throw new tango.core.Exception.IllegalArgumentException("Tried to make the capacity of a vector smaller than its size.");
+  }
+
+  reserve(value);
+}
+%}
+
+  public:
+    typedef size_t size_type;
+    typedef CTYPE value_type;
+    typedef CONST_REFERENCE const_reference;
+    void clear();
+    void push_back(CTYPE const& x);
+    size_type size() const;
+    size_type capacity() const;
+    void reserve(size_type n) throw (std::length_error);
+    vector();
+    vector(const vector &other);
+    %extend {
+      vector(size_type capacity) throw (std::length_error) {
+        std::vector< CTYPE >* pv = 0;
+        pv = new std::vector< CTYPE >();
+
+        // Might throw std::length_error.
+        pv->reserve(capacity);
+
+        return pv;
+      }
+
+      size_type unused() const {
+        return $self->capacity() - $self->size();
+      }
+
+      const_reference remove() throw (std::out_of_range) {
+        if ($self->empty()) {
+          throw std::out_of_range("Tried to remove last element from empty vector.");
+        }
+
+        std::vector< CTYPE >::const_reference value = $self->back();
+        $self->pop_back();
+        return value;
+      }
+
+      const_reference remove(size_type index) throw (std::out_of_range) {
+        if (index >= $self->size()) {
+          throw std::out_of_range("Tried to remove element with invalid index.");
+        }
+
+        std::vector< CTYPE >::iterator it = $self->begin() + index;
+        std::vector< CTYPE >::const_reference value = *it;
+        $self->erase(it);
+        return value;
+      }
+    }
+
+    // Wrappers for setting/getting items with the possibly thrown exception
+    // specified (important for SWIG wrapper generation).
+    %extend {
+      const_reference getElement(size_type index) throw (std::out_of_range) {
+        if ((index < 0) || ($self->size() <= index)) {
+          throw std::out_of_range("Tried to get value of element with invalid index.");
+        }
+        return (*$self)[index];
+      }
+    }
+
+    // Use CTYPE const& instead of const_reference to work around SWIG code
+    // generation issue when using const pointers as vector elements (like
+    // std::vector< const int* >).
+    %extend {
+      void setElement(size_type index, CTYPE const& val) throw (std::out_of_range) {
+        if ((index < 0) || ($self->size() <= index)) {
+          throw std::out_of_range("Tried to set value of element with invalid index.");
+        }
+        (*$self)[index] = val;
+      }
+    }
+
+%dmethodmodifiers std::vector::getElement "private"
+%dmethodmodifiers std::vector::setElement "private"
+%dmethodmodifiers std::vector::reserve "private"
+
+#else
+
+%typemap(dimports) std::vector< CTYPE > %{
+static import std.algorithm;
+static import std.exception;
+static import std.range;
+static import std.traits;
+%}
+%typemap(dcode) std::vector< CTYPE > %{
+alias size_t KeyType;
+alias $typemap(dtype, CTYPE) ValueType;
+
+this(ValueType[] values...) {
+  this();
+  reserve(values.length);
+  foreach (e; values) {
+    this ~= e;
+  }
+}
+
+struct Range {
+  private $typemap(dtype, std::vector< CTYPE >) _outer;
+  private size_t _a, _b;
+
+  this($typemap(dtype, std::vector< CTYPE >) data, size_t a, size_t b) {
+    _outer = data;
+    _a = a;
+    _b = b;
+  }
+
+  @property bool empty() const {
+    assert((cast($typemap(dtype, std::vector< CTYPE >))_outer).length >= _b);
+    return _a >= _b;
+  }
+
+  @property Range save() {
+    return this;
+  }
+
+  @property ValueType front() {
+    std.exception.enforce(!empty);
+    return _outer[_a];
+  }
+
+  @property void front(ValueType value) {
+    std.exception.enforce(!empty);
+    _outer[_a] = std.algorithm.move(value);
+  }
+
+  void popFront() {
+    std.exception.enforce(!empty);
+    ++_a;
+  }
+
+  void opIndexAssign(ValueType value, size_t i) {
+    i += _a;
+    std.exception.enforce(i < _b && _b <= _outer.length);
+    _outer[i] = value;
+  }
+
+  void opIndexOpAssign(string op)(ValueType value, size_t i) {
+    std.exception.enforce(_outer && _a + i < _b && _b <= _outer.length);
+    auto element = _outer[i];
+    mixin("element "~op~"= value;");
+    _outer[i] = element;
+  }
+}
+
+// TODO: dup?
+
+Range opSlice() {
+  return Range(this, 0, length);
+}
+
+Range opSlice(size_t a, size_t b) {
+  std.exception.enforce(a <= b && b <= length);
+  return Range(this, a, b);
+}
+
+size_t opDollar() const {
+  return length;
+}
+
+@property ValueType front() {
+  std.exception.enforce(!empty);
+  return getElement(0);
+}
+
+@property void front(ValueType value) {
+  std.exception.enforce(!empty);
+  setElement(0, value);
+}
+
+@property ValueType back() {
+  std.exception.enforce(!empty);
+  return getElement(length - 1);
+}
+
+@property void back(ValueType value) {
+  std.exception.enforce(!empty);
+  setElement(length - 1, value);
+}
+
+ValueType opIndex(size_t i) {
+  return getElement(i);
+}
+
+void opIndexAssign(ValueType value, size_t i) {
+  setElement(i, value);
+}
+
+void opIndexOpAssign(string op)(ValueType value, size_t i) {
+  auto element = this[i];
+  mixin("element "~op~"= value;");
+  this[i] = element;
+}
+
+ValueType[] opBinary(string op, Stuff)(Stuff stuff) if (op == "~") {
+  ValueType[] result;
+  result ~= this[];
+  assert(result.length == length);
+  result ~= stuff[];
+  return result;
+}
+
+void opOpAssign(string op, Stuff)(Stuff stuff) if (op == "~") {
+  static if (is(typeof(insertBack(stuff)))) {
+    insertBack(stuff);
+  } else if (is(typeof(insertBack(stuff[])))) {
+    insertBack(stuff[]);
+  } else {
+    static assert(false, "Cannot append " ~ Stuff.stringof ~ " to " ~ typeof(this).stringof);
+  }
+}
+
+alias size length;
+
+alias remove removeAny;
+alias removeAny stableRemoveAny;
+
+size_t insertBack(Stuff)(Stuff stuff)
+if (std.traits.isImplicitlyConvertible!(Stuff, ValueType)){
+  push_back(stuff);
+  return 1;
+}
+size_t insertBack(Stuff)(Stuff stuff)
+if (std.range.isInputRange!Stuff &&
+    std.traits.isImplicitlyConvertible!(std.range.ElementType!Stuff, ValueType)) {
+  size_t itemCount;
+  foreach(item; stuff) {
+    insertBack(item);
+    ++itemCount;
+  }
+  return itemCount;
+}
+alias insertBack insert;
+
+alias pop_back removeBack;
+alias pop_back stableRemoveBack;
+
+size_t insertBefore(Stuff)(Range r, Stuff stuff)
+if (std.traits.isImplicitlyConvertible!(Stuff, ValueType)) {
+  std.exception.enforce(r._outer.swigCPtr == swigCPtr && r._a < length);
+  insertAt(r._a, stuff);
+  return 1;
+}
+
+size_t insertBefore(Stuff)(Range r, Stuff stuff)
+if (std.range.isInputRange!Stuff && std.traits.isImplicitlyConvertible!(ElementType!Stuff, ValueType)) {
+  std.exception.enforce(r._outer.swigCPtr == swigCPtr && r._a <= length);
+
+  size_t insertCount;
+  foreach(i, item; stuff) {
+    insertAt(r._a + i, item);
+    ++insertCount;
+  }
+
+  return insertCount;
+}
+
+size_t insertAfter(Stuff)(Range r, Stuff stuff) {
+  // TODO: optimize
+  immutable offset = r._a + r.length;
+  std.exception.enforce(offset <= length);
+  auto result = insertBack(stuff);
+  std.algorithm.bringToFront(this[offset .. length - result],
+    this[length - result .. length]);
+  return result;
+}
+
+size_t replace(Stuff)(Range r, Stuff stuff)
+if (std.range.isInputRange!Stuff &&
+    std.traits.isImplicitlyConvertible!(ElementType!Stuff, ValueType)) {
+  immutable offset = r._a;
+  std.exception.enforce(offset <= length);
+  size_t result;
+  for (; !stuff.empty; stuff.popFront()) {
+    if (r.empty) {
+      // append the rest
+      return result + insertBack(stuff);
+    }
+    r.front = stuff.front;
+    r.popFront();
+    ++result;
+  }
+  // Remove remaining stuff in r
+  remove(r);
+  return result;
+}
+
+size_t replace(Stuff)(Range r, Stuff stuff)
+if (std.traits.isImplicitlyConvertible!(Stuff, ValueType))
+{
+    if (r.empty)
+    {
+        insertBefore(r, stuff);
+    }
+    else
+    {
+        r.front = stuff;
+        r.popFront();
+        remove(r);
+    }
+    return 1;
+}
+
+Range linearRemove(Range r) {
+  std.exception.enforce(r._a <= r._b && r._b <= length);
+  immutable tailLength = length - r._b;
+  linearRemove(r._a, r._b);
+  return this[length - tailLength .. length];
+}
+alias remove stableLinearRemove;
+
+int opApply(int delegate(ref $typemap(dtype, CTYPE) value) dg) {
+  int result;
+
+  size_t currentSize = size();
+  for (size_t i = 0; i < currentSize; ++i) {
+    auto value = getElement(i);
+    result = dg(value);
+    setElement(i, value);
+  }
+  return result;
+}
+
+int opApply(int delegate(ref size_t index, ref $typemap(dtype, CTYPE) value) dg) {
+  int result;
+
+  size_t currentSize = size();
+  for (size_t i = 0; i < currentSize; ++i) {
+    auto value = getElement(i);
+
+    // Workaround for http://d.puremagic.com/issues/show_bug.cgi?id=2443.
+    auto index = i;
+
+    result = dg(index, value);
+    setElement(i, value);
+  }
+  return result;
+}
+%}
+
+  public:
+    typedef size_t size_type;
+    typedef CTYPE value_type;
+    typedef CONST_REFERENCE const_reference;
+    bool empty() const;
+    void clear();
+    void push_back(CTYPE const& x);
+    void pop_back();
+    size_type size() const;
+    size_type capacity() const;
+    void reserve(size_type n) throw (std::length_error);
+    vector();
+    vector(const vector &other);
+    %extend {
+      vector(size_type capacity) throw (std::length_error) {
+        std::vector< CTYPE >* pv = 0;
+        pv = new std::vector< CTYPE >();
+
+        // Might throw std::length_error.
+        pv->reserve(capacity);
+
+        return pv;
+      }
+
+      const_reference remove() throw (std::out_of_range) {
+        if ($self->empty()) {
+          throw std::out_of_range("Tried to remove last element from empty vector.");
+        }
+
+        std::vector< CTYPE >::const_reference value = $self->back();
+        $self->pop_back();
+        return value;
+      }
+
+      const_reference remove(size_type index) throw (std::out_of_range) {
+        if (index >= $self->size()) {
+          throw std::out_of_range("Tried to remove element with invalid index.");
+        }
+
+        std::vector< CTYPE >::iterator it = $self->begin() + index;
+        std::vector< CTYPE >::const_reference value = *it;
+        $self->erase(it);
+        return value;
+      }
+
+      void removeBack(size_type how_many) throw (std::out_of_range) {
+        std::vector< CTYPE >::iterator end = $self->end();
+        std::vector< CTYPE >::iterator start = end - how_many;
+        $self->erase(start, end);
+      }
+
+      void linearRemove(size_type start_index, size_type end_index) throw (std::out_of_range) {
+        std::vector< CTYPE >::iterator start = $self->begin() + start_index;
+        std::vector< CTYPE >::iterator end = $self->begin() + end_index;
+        $self->erase(start, end);
+      }
+
+      void insertAt(size_type index, CTYPE const& x) throw (std::out_of_range) {
+        std::vector< CTYPE >::iterator it = $self->begin() + index;
+        $self->insert(it, x);
+      }
+    }
+
+    // Wrappers for setting/getting items with the possibly thrown exception
+    // specified (important for SWIG wrapper generation).
+    %extend {
+      const_reference getElement(size_type index) throw (std::out_of_range) {
+        if ((index < 0) || ($self->size() <= index)) {
+          throw std::out_of_range("Tried to get value of element with invalid index.");
+        }
+        return (*$self)[index];
+      }
+    }
+    // Use CTYPE const& instead of const_reference to work around SWIG code
+    // generation issue when using const pointers as vector elements (like
+    // std::vector< const int* >).
+    %extend {
+      void setElement(size_type index, CTYPE const& val) throw (std::out_of_range) {
+        if ((index < 0) || ($self->size() <= index)) {
+          throw std::out_of_range("Tried to set value of element with invalid index.");
+        }
+        (*$self)[index] = val;
+      }
+    }
+
+%dmethodmodifiers std::vector::getElement "private"
+%dmethodmodifiers std::vector::setElement "private"
+#endif
+%enddef
+
+// Extra methods added to the collection class if operator== is defined for the class being wrapped
+// The class will then implement IList<>, which adds extra functionality
+%define SWIG_STD_VECTOR_EXTRA_OP_EQUALS_EQUALS(CTYPE...)
+    %extend {
+    }
+%enddef
+
+// For vararg handling in macros, from swigmacros.swg
+#define %arg(X...) X
+
+// Macros for std::vector class specializations/enhancements
+%define SWIG_STD_VECTOR_ENHANCED(CTYPE...)
+namespace std {
+  template<> class vector<CTYPE > {
+    SWIG_STD_VECTOR_MINIMUM_INTERNAL(%arg(CTYPE const&), %arg(CTYPE))
+    SWIG_STD_VECTOR_EXTRA_OP_EQUALS_EQUALS(CTYPE)
+  };
+}
+%enddef
+
+%{
+#include <vector>
+#include <stdexcept>
+%}
+
+namespace std {
+  // primary (unspecialized) class template for std::vector
+  // does not require operator== to be defined
+  template<class T> class vector {
+    SWIG_STD_VECTOR_MINIMUM_INTERNAL(T const&, T)
+  };
+  // specializations for pointers
+  template<class T> class vector<T *> {
+    SWIG_STD_VECTOR_MINIMUM_INTERNAL(T *const&, T *)
+    SWIG_STD_VECTOR_EXTRA_OP_EQUALS_EQUALS(T *)
+  };
+  // bool is a bit different in the C++ standard - const_reference in particular
+  template<> class vector<bool> {
+    SWIG_STD_VECTOR_MINIMUM_INTERNAL(bool, bool)
+    SWIG_STD_VECTOR_EXTRA_OP_EQUALS_EQUALS(bool)
+  };
+}
+
+// template specializations for std::vector
+// these provide extra collections methods as operator== is defined
+SWIG_STD_VECTOR_ENHANCED(char)
+SWIG_STD_VECTOR_ENHANCED(signed char)
+SWIG_STD_VECTOR_ENHANCED(unsigned char)
+SWIG_STD_VECTOR_ENHANCED(short)
+SWIG_STD_VECTOR_ENHANCED(unsigned short)
+SWIG_STD_VECTOR_ENHANCED(int)
+SWIG_STD_VECTOR_ENHANCED(unsigned int)
+SWIG_STD_VECTOR_ENHANCED(long)
+SWIG_STD_VECTOR_ENHANCED(unsigned long)
+SWIG_STD_VECTOR_ENHANCED(long long)
+SWIG_STD_VECTOR_ENHANCED(unsigned long long)
+SWIG_STD_VECTOR_ENHANCED(float)
+SWIG_STD_VECTOR_ENHANCED(double)
+SWIG_STD_VECTOR_ENHANCED(std::string) // also requires a %include <std_string.i>

Lib/d/stl.i

@@ -0,0 +1,12 @@
+/* -----------------------------------------------------------------------------
+ * stl.i
+ *
+ * Initial STL definition. extended as needed in each language
+ * ----------------------------------------------------------------------------- */
+
+%include <std_common.i>
+%include <std_string.i>
+%include <std_vector.i>
+%include <std_map.i>
+%include <std_pair.i>
+

Lib/d/typemaps.i

@@ -0,0 +1,261 @@
+/* -----------------------------------------------------------------------------
+ * typemaps.i
+ *
+ * Pointer and reference handling typemap library
+ *
+ * These mappings provide support for input/output arguments and common
+ * uses for C/C++ pointers and C++ references.
+ * ----------------------------------------------------------------------------- */
+
+/*
+INPUT typemaps
+--------------
+
+These typemaps are used for pointer/reference parameters that are input only
+and are mapped to a D input parameter.
+
+The following typemaps can be applied to turn a pointer or reference into a simple
+input value.  That is, instead of passing a pointer or reference to an object,
+you would use a real value instead.
+
+        bool               *INPUT, bool               &INPUT
+        signed char        *INPUT, signed char        &INPUT
+        unsigned char      *INPUT, unsigned char      &INPUT
+        short              *INPUT, short              &INPUT
+        unsigned short     *INPUT, unsigned short     &INPUT
+        int                *INPUT, int                &INPUT
+        unsigned int       *INPUT, unsigned int       &INPUT
+        long               *INPUT, long               &INPUT
+        unsigned long      *INPUT, unsigned long      &INPUT
+        long long          *INPUT, long long          &INPUT
+        unsigned long long *INPUT, unsigned long long &INPUT
+        float              *INPUT, float              &INPUT
+        double             *INPUT, double             &INPUT
+
+To use these, suppose you had a C function like this :
+
+        double fadd(double *a, double *b) {
+               return *a+*b;
+        }
+
+You could wrap it with SWIG as follows :
+
+        %include <typemaps.i>
+        double fadd(double *INPUT, double *INPUT);
+
+or you can use the %apply directive :
+
+        %include <typemaps.i>
+        %apply double *INPUT { double *a, double *b };
+        double fadd(double *a, double *b);
+
+In D you could then use it like this:
+        double answer = fadd(10.0, 20.0);
+*/
+
+%define INPUT_TYPEMAP(TYPE, CTYPE, DTYPE)
+%typemap(ctype, out="void *") TYPE *INPUT, TYPE &INPUT "CTYPE"
+%typemap(imtype, out="void*") TYPE *INPUT, TYPE &INPUT "DTYPE"
+%typemap(dtype, out="DTYPE*") TYPE *INPUT, TYPE &INPUT "DTYPE"
+%typemap(din) TYPE *INPUT, TYPE &INPUT "$dinput"
+
+%typemap(in) TYPE *INPUT, TYPE &INPUT
+%{ $1 = ($1_ltype)&$input; %}
+
+%typemap(typecheck) TYPE *INPUT = TYPE;
+%typemap(typecheck) TYPE &INPUT = TYPE;
+%enddef
+
+INPUT_TYPEMAP(bool,               unsigned int,         bool)
+//INPUT_TYPEMAP(char,               char,                 char) // Why was this commented out?
+INPUT_TYPEMAP(signed char,        signed char,          byte)
+INPUT_TYPEMAP(unsigned char,      unsigned char,        ubyte)
+INPUT_TYPEMAP(short,              short,                short)
+INPUT_TYPEMAP(unsigned short,     unsigned short,       ushort)
+INPUT_TYPEMAP(int,                int,                  int)
+INPUT_TYPEMAP(unsigned int,       unsigned int,         uint)
+INPUT_TYPEMAP(long,               long,                 int)
+INPUT_TYPEMAP(unsigned long,      unsigned long,        uint)
+INPUT_TYPEMAP(long long,          long long,            long)
+INPUT_TYPEMAP(unsigned long long, unsigned long long,   ulong)
+INPUT_TYPEMAP(float,              float,                float)
+INPUT_TYPEMAP(double,             double,               double)
+
+INPUT_TYPEMAP(enum SWIGTYPE,      unsigned int,         int)
+%typemap(dtype) enum SWIGTYPE *INPUT, enum SWIGTYPE &INPUT "$*dclassname"
+
+#undef INPUT_TYPEMAP
+
+
+/*
+OUTPUT typemaps
+---------------
+
+These typemaps are used for pointer/reference parameters that are output only and
+are mapped to a D output parameter.
+
+The following typemaps can be applied to turn a pointer or reference into an
+"output" value. When calling a function, no input value would be given for
+a parameter, but an output value would be returned. In D, the 'out' keyword is
+used when passing the parameter to a function that takes an output parameter.
+
+        bool               *OUTPUT, bool               &OUTPUT
+        signed char        *OUTPUT, signed char        &OUTPUT
+        unsigned char      *OUTPUT, unsigned char      &OUTPUT
+        short              *OUTPUT, short              &OUTPUT
+        unsigned short     *OUTPUT, unsigned short     &OUTPUT
+        int                *OUTPUT, int                &OUTPUT
+        unsigned int       *OUTPUT, unsigned int       &OUTPUT
+        long               *OUTPUT, long               &OUTPUT
+        unsigned long      *OUTPUT, unsigned long      &OUTPUT
+        long long          *OUTPUT, long long          &OUTPUT
+        unsigned long long *OUTPUT, unsigned long long &OUTPUT
+        float              *OUTPUT, float              &OUTPUT
+        double             *OUTPUT, double             &OUTPUT
+
+For example, suppose you were trying to wrap the modf() function in the
+C math library which splits x into integral and fractional parts (and
+returns the integer part in one of its parameters):
+
+        double modf(double x, double *ip);
+
+You could wrap it with SWIG as follows :
+
+        %include <typemaps.i>
+        double modf(double x, double *OUTPUT);
+
+or you can use the %apply directive :
+
+        %include <typemaps.i>
+        %apply double *OUTPUT { double *ip };
+        double modf(double x, double *ip);
+
+The D output of the function would be the function return value and the
+value returned in the second output parameter. In D you would use it like this:
+
+    double dptr;
+    double fraction = modf(5, dptr);
+*/
+
+%define OUTPUT_TYPEMAP(TYPE, CTYPE, DTYPE, TYPECHECKPRECEDENCE)
+%typemap(ctype, out="void *") TYPE *OUTPUT, TYPE &OUTPUT "CTYPE *"
+%typemap(imtype, out="void*") TYPE *OUTPUT, TYPE &OUTPUT "out DTYPE"
+%typemap(dtype, out="DTYPE*") TYPE *OUTPUT, TYPE &OUTPUT "out DTYPE"
+%typemap(din) TYPE *OUTPUT, TYPE &OUTPUT "$dinput"
+
+%typemap(in) TYPE *OUTPUT, TYPE &OUTPUT
+%{ $1 = ($1_ltype)$input; %}
+
+%typecheck(SWIG_TYPECHECK_##TYPECHECKPRECEDENCE) TYPE *OUTPUT, TYPE &OUTPUT ""
+%enddef
+
+OUTPUT_TYPEMAP(bool,               unsigned int,         bool,     BOOL_PTR)
+//OUTPUT_TYPEMAP(char,               char,                 char,     CHAR_PTR) // Why was this commented out?
+OUTPUT_TYPEMAP(signed char,        signed char,          byte,     INT8_PTR)
+OUTPUT_TYPEMAP(unsigned char,      unsigned char,        ubyte,    UINT8_PTR)
+OUTPUT_TYPEMAP(short,              short,                short,    INT16_PTR)
+OUTPUT_TYPEMAP(unsigned short,     unsigned short,       ushort,   UINT16_PTR)
+OUTPUT_TYPEMAP(int,                int,                  int,      INT32_PTR)
+OUTPUT_TYPEMAP(unsigned int,       unsigned int,         uint,     UINT32_PTR)
+OUTPUT_TYPEMAP(long,               long,                 int,      INT32_PTR)
+OUTPUT_TYPEMAP(unsigned long,      unsigned long,        uint,     UINT32_PTR)
+OUTPUT_TYPEMAP(long long,          long long,            long,     INT64_PTR)
+OUTPUT_TYPEMAP(unsigned long long, unsigned long long,   ulong,    UINT64_PTR)
+OUTPUT_TYPEMAP(float,              float,                float,    FLOAT_PTR)
+OUTPUT_TYPEMAP(double,             double,               double,   DOUBLE_PTR)
+
+OUTPUT_TYPEMAP(enum SWIGTYPE,      unsigned int,         int,      INT32_PTR)
+%typemap(dtype) enum SWIGTYPE *OUTPUT, enum SWIGTYPE &OUTPUT "out $*dclassname"
+
+#undef OUTPUT_TYPEMAP
+
+%typemap(in) bool *OUTPUT, bool &OUTPUT
+%{ *$input = 0;
+   $1 = ($1_ltype)$input; %}
+
+
+/*
+INOUT typemaps
+--------------
+
+These typemaps are for pointer/reference parameters that are both input and
+output and are mapped to a D reference parameter.
+
+The following typemaps can be applied to turn a pointer or reference into a
+reference parameters, that is the parameter is both an input and an output.
+In D, the 'ref' keyword is used for reference parameters.
+
+        bool               *INOUT, bool               &INOUT
+        signed char        *INOUT, signed char        &INOUT
+        unsigned char      *INOUT, unsigned char      &INOUT
+        short              *INOUT, short              &INOUT
+        unsigned short     *INOUT, unsigned short     &INOUT
+        int                *INOUT, int                &INOUT
+        unsigned int       *INOUT, unsigned int       &INOUT
+        long               *INOUT, long               &INOUT
+        unsigned long      *INOUT, unsigned long      &INOUT
+        long long          *INOUT, long long          &INOUT
+        unsigned long long *INOUT, unsigned long long &INOUT
+        float              *INOUT, float              &INOUT
+        double             *INOUT, double             &INOUT
+
+For example, suppose you were trying to wrap the following function :
+
+        void neg(double *x) {
+             *x = -(*x);
+        }
+
+You could wrap it with SWIG as follows :
+
+        %include <typemaps.i>
+        void neg(double *INOUT);
+
+or you can use the %apply directive :
+
+        %include <typemaps.i>
+        %apply double *INOUT { double *x };
+        void neg(double *x);
+
+The D output of the function would be the new value returned by the
+reference parameter. In D you would use it like this:
+
+
+       double x = 5.0;
+       neg(x);
+
+The implementation of the OUTPUT and INOUT typemaps is different to the scripting
+languages in that the scripting languages will return the output value as part
+of the function return value.
+*/
+
+%define INOUT_TYPEMAP(TYPE, CTYPE, DTYPE, TYPECHECKPRECEDENCE)
+%typemap(ctype, out="void *") TYPE *INOUT, TYPE &INOUT "CTYPE *"
+%typemap(imtype, out="void*") TYPE *INOUT, TYPE &INOUT "ref DTYPE"
+%typemap(dtype, out="DTYPE*") TYPE *INOUT, TYPE &INOUT "ref DTYPE"
+%typemap(din) TYPE *INOUT, TYPE &INOUT "$dinput"
+
+%typemap(in) TYPE *INOUT, TYPE &INOUT
+%{ $1 = ($1_ltype)$input; %}
+
+%typecheck(SWIG_TYPECHECK_##TYPECHECKPRECEDENCE) TYPE *INOUT, TYPE &INOUT ""
+%enddef
+
+INOUT_TYPEMAP(bool,               unsigned int,         bool,     BOOL_PTR)
+//INOUT_TYPEMAP(char,               char,                 char,     CHAR_PTR)
+INOUT_TYPEMAP(signed char,        signed char,          byte,     INT8_PTR)
+INOUT_TYPEMAP(unsigned char,      unsigned char,        ubyte,    UINT8_PTR)
+INOUT_TYPEMAP(short,              short,                short,    INT16_PTR)
+INOUT_TYPEMAP(unsigned short,     unsigned short,       ushort,   UINT16_PTR)
+INOUT_TYPEMAP(int,                int,                  int,      INT32_PTR)
+INOUT_TYPEMAP(unsigned int,       unsigned int,         uint,     UINT32_PTR)
+INOUT_TYPEMAP(long,               long,                 int,      INT32_PTR)
+INOUT_TYPEMAP(unsigned long,      unsigned long,        uint,     UINT32_PTR)
+INOUT_TYPEMAP(long long,          long long,            long,     INT64_PTR)
+INOUT_TYPEMAP(unsigned long long, unsigned long long,   ulong,    UINT64_PTR)
+INOUT_TYPEMAP(float,              float,                float,    FLOAT_PTR)
+INOUT_TYPEMAP(double,             double,               double,   DOUBLE_PTR)
+
+INOUT_TYPEMAP(enum SWIGTYPE,      unsigned int,         int,      INT32_PTR)
+%typemap(dtype) enum SWIGTYPE *INOUT, enum SWIGTYPE &INOUT "ref $*dclassname"
+
+#undef INOUT_TYPEMAP

Lib/d/wrapperloader.swg

@@ -0,0 +1,308 @@
+/* -----------------------------------------------------------------------------
+ * wrapperloader.swg
+ *
+ * Support code for dynamically linking the C wrapper library from the D
+ * wrapper module.
+ *
+ * The loading code was adapted from the Derelict project and is used with
+ * permission from Michael Parker, the original author.
+ * ----------------------------------------------------------------------------- */
+
+%pragma(d) wrapperloadercode = %{
+private {
+  version(linux) {
+    version = Nix;
+  } else version(darwin) {
+    version = Nix;
+  } else version(OSX) {
+    version = Nix;
+  } else version(FreeBSD) {
+    version = Nix;
+    version = freebsd;
+  } else version(freebsd) {
+    version = Nix;
+  } else version(Unix) {
+    version = Nix;
+  } else version(Posix) {
+    version = Nix;
+  }
+
+  version(Tango) {
+    static import tango.stdc.string;
+    static import tango.stdc.stringz;
+
+    version (PhobosCompatibility) {
+    } else {
+      alias char[] string;
+      alias wchar[] wstring;
+      alias dchar[] dstring;
+    }
+  } else {
+    version(D_Version2) {
+      static import std.conv;
+    }
+    static import std.string;
+    static import std.c.string;
+  }
+
+  version(D_Version2) {
+    mixin("alias const(char)* CCPTR;");
+  } else {
+    alias char* CCPTR;
+  }
+
+  CCPTR swigToCString(string str) {
+    version(Tango) {
+      return tango.stdc.stringz.toStringz(str);
+    } else {
+      return std.string.toStringz(str);
+    }
+  }
+
+  string swigToDString(CCPTR cstr) {
+    version(Tango) {
+      return tango.stdc.stringz.fromStringz(cstr);
+    } else {
+      version(D_Version2) {
+        mixin("return std.conv.to!string(cstr);");
+      } else {
+        return std.c.string.toString(cstr);
+      }
+    }
+  }
+}
+
+class SwigSwigSharedLibLoadException : Exception {
+  this(in string[] libNames, in string[] reasons) {
+    string msg = "Failed to load one or more shared libraries:";
+    foreach(i, n; libNames) {
+      msg ~= "\n\t" ~ n ~ " - ";
+      if(i < reasons.length)
+        msg ~= reasons[i];
+      else
+        msg ~= "Unknown";
+    }
+    super(msg);
+  }
+}
+
+class SwigSymbolLoadException : Exception {
+  this(string SwigSharedLibName, string symbolName) {
+    super("Failed to load symbol " ~ symbolName ~ " from shared library " ~ SwigSharedLibName);
+    _symbolName = symbolName;
+  }
+
+  string symbolName() {
+    return _symbolName;
+  }
+
+private:
+  string _symbolName;
+}
+
+private {
+  version(Nix) {
+    version(freebsd) {
+      // the dl* functions are in libc on FreeBSD
+    }
+    else {
+      pragma(lib, "dl");
+    }
+
+    version(Tango) {
+      import tango.sys.Common;
+    } else version(linux) {
+      import std.c.linux.linux;
+    } else {
+      extern(C) {
+        const RTLD_NOW = 2;
+
+        void *dlopen(CCPTR file, int mode);
+        int dlclose(void* handle);
+        void *dlsym(void* handle, CCPTR name);
+        CCPTR dlerror();
+      }
+    }
+
+    alias void* SwigSharedLibHandle;
+
+    SwigSharedLibHandle swigLoadSharedLib(string libName) {
+      return dlopen(swigToCString(libName), RTLD_NOW);
+    }
+
+    void swigUnloadSharedLib(SwigSharedLibHandle hlib) {
+      dlclose(hlib);
+    }
+
+    void* swigGetSymbol(SwigSharedLibHandle hlib, string symbolName) {
+      return dlsym(hlib, swigToCString(symbolName));
+    }
+
+    string swigGetErrorStr() {
+      CCPTR err = dlerror();
+      if (err is null) {
+        return "Unknown Error";
+      }
+      return swigToDString(err);
+    }
+  } else version(Windows) {
+    alias ushort WORD;
+    alias uint DWORD;
+    alias CCPTR LPCSTR;
+    alias void* HMODULE;
+    alias void* HLOCAL;
+    alias int function() FARPROC;
+    struct VA_LIST {}
+
+    extern (Windows) {
+      HMODULE LoadLibraryA(LPCSTR);
+      FARPROC GetProcAddress(HMODULE, LPCSTR);
+      void FreeLibrary(HMODULE);
+      DWORD GetLastError();
+      DWORD FormatMessageA(DWORD, in void*, DWORD, DWORD, LPCSTR, DWORD, VA_LIST*);
+      HLOCAL LocalFree(HLOCAL);
+    }
+
+    DWORD MAKELANGID(WORD p, WORD s) {
+      return (((cast(WORD)s) << 10) | cast(WORD)p);
+    }
+
+    enum {
+      LANG_NEUTRAL                    = 0,
+      SUBLANG_DEFAULT                 = 1,
+      FORMAT_MESSAGE_ALLOCATE_BUFFER  = 256,
+      FORMAT_MESSAGE_IGNORE_INSERTS   = 512,
+      FORMAT_MESSAGE_FROM_SYSTEM      = 4096
+    }
+
+    alias HMODULE SwigSharedLibHandle;
+
+    SwigSharedLibHandle swigLoadSharedLib(string libName) {
+      return LoadLibraryA(swigToCString(libName));
+    }
+
+    void swigUnloadSharedLib(SwigSharedLibHandle hlib) {
+      FreeLibrary(hlib);
+    }
+
+    void* swigGetSymbol(SwigSharedLibHandle hlib, string symbolName) {
+      return GetProcAddress(hlib, swigToCString(symbolName));
+    }
+
+    string swigGetErrorStr() {
+      DWORD errcode = GetLastError();
+
+      LPCSTR msgBuf;
+      DWORD i = FormatMessageA(
+        FORMAT_MESSAGE_ALLOCATE_BUFFER |
+        FORMAT_MESSAGE_FROM_SYSTEM |
+        FORMAT_MESSAGE_IGNORE_INSERTS,
+        null,
+        errcode,
+        MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+        cast(LPCSTR)&msgBuf,
+        0,
+        null);
+
+      string text = swigToDString(msgBuf);
+      LocalFree(cast(HLOCAL)msgBuf);
+
+      if (i >= 2) {
+        i -= 2;
+      }
+      return text[0 .. i];
+    }
+  } else {
+    static assert(0, "Operating system not supported by the wrapper loading code.");
+  }
+
+  final class SwigSharedLib {
+    void load(string[] names) {
+      if (_hlib !is null) return;
+
+      string[] failedLibs;
+      string[] reasons;
+
+      foreach(n; names) {
+        _hlib = swigLoadSharedLib(n);
+        if (_hlib is null) {
+          failedLibs ~= n;
+          reasons ~= swigGetErrorStr();
+          continue;
+        }
+        _name = n;
+        break;
+      }
+
+      if (_hlib is null) {
+        throw new SwigSwigSharedLibLoadException(failedLibs, reasons);
+      }
+    }
+
+    void* loadSymbol(string symbolName, bool doThrow = true) {
+      void* sym = swigGetSymbol(_hlib, symbolName);
+      if(doThrow && (sym is null)) {
+        throw new SwigSymbolLoadException(_name, symbolName);
+      }
+      return sym;
+    }
+
+    void unload() {
+      if(_hlib !is null) {
+        swigUnloadSharedLib(_hlib);
+        _hlib = null;
+      }
+    }
+
+  private:
+    string _name;
+    SwigSharedLibHandle _hlib;
+  }
+}
+
+static this() {
+  string[] possibleFileNames;
+  version (Posix) {
+    version (OSX) {
+      possibleFileNames ~= ["lib$wraplibrary.dylib", "lib$wraplibrary.bundle"];
+    }
+    possibleFileNames ~= ["lib$wraplibrary.so"];
+  } else version (Windows) {
+    possibleFileNames ~= ["$wraplibrary.dll", "lib$wraplibrary.so"];
+  } else {
+    static assert(false, "Operating system not supported by the wrapper loading code.");
+  }
+
+  auto library = new SwigSharedLib;
+  library.load(possibleFileNames);
+
+  string bindCode(string functionPointer, string symbol) {
+    return functionPointer ~ " = cast(typeof(" ~ functionPointer ~
+      "))library.loadSymbol(`" ~ symbol ~ "`);";
+  }
+
+  //#if !defined(SWIG_D_NO_EXCEPTION_HELPER)
+  mixin(bindCode("swigRegisterExceptionCallbacks", "SWIGRegisterExceptionCallbacks_$module"));
+  //#endif // SWIG_D_NO_EXCEPTION_HELPER
+  //#if !defined(SWIG_D_NO_STRING_HELPER)
+  mixin(bindCode("swigRegisterStringCallback", "SWIGRegisterStringCallback_$module"));
+  //#endif // SWIG_D_NO_STRING_HELPER
+  $wrapperloaderbindcode
+}
+
+//#if !defined(SWIG_D_NO_EXCEPTION_HELPER)
+extern(C) void function(
+  SwigExceptionCallback exceptionCallback,
+  SwigExceptionCallback illegalArgumentCallback,
+  SwigExceptionCallback illegalElementCallback,
+  SwigExceptionCallback ioCallback,
+  SwigExceptionCallback noSuchElementCallback) swigRegisterExceptionCallbacks;
+//#endif // SWIG_D_NO_EXCEPTION_HELPER
+
+//#if !defined(SWIG_D_NO_STRING_HELPER)
+extern(C) void function(SwigStringCallback callback) swigRegisterStringCallback;
+//#endif // SWIG_D_NO_STRING_HELPER
+%}
+
+%pragma(d) wrapperloaderbindcommand = %{
+  mixin(bindCode("$function", "$symbol"));%}

Lib/exception.i

@@ -209,6 +209,40 @@ SWIGINTERN void SWIG_CSharpException(int code, const char *msg) {
 
 #endif // SWIGLUA
 
+#ifdef SWIGD
+%{
+SWIGINTERN void SWIG_DThrowException(int code, const char *msg) {
+  SWIG_DExceptionCodes exception_code;
+  switch(code) {
+  case SWIG_IndexError:
+    exception_code = SWIG_DNoSuchElementException;
+    break;
+  case SWIG_IOError:
+    exception_code = SWIG_DIOException;
+    break;
+  case SWIG_ValueError:
+    exception_code = SWIG_DIllegalArgumentException;
+    break;
+  case SWIG_DivisionByZero:
+  case SWIG_MemoryError:
+  case SWIG_OverflowError:
+  case SWIG_RuntimeError:
+  case SWIG_TypeError:
+  case SWIG_SyntaxError:
+  case SWIG_SystemError:
+  case SWIG_UnknownError:
+  default:
+    exception_code = SWIG_DException;
+    break;
+  }
+  SWIG_DSetPendingException(exception_code, msg);
+}
+%}
+
+#define SWIG_exception(code, msg)\
+{ SWIG_DThrowException(code, msg); return $null; }
+#endif // SWIGD
+
 #ifdef __cplusplus
 /*
   You can use the SWIG_CATCH_STDEXCEPT macro with the %exception
@@ -259,7 +293,7 @@ SWIGINTERN void SWIG_CSharpException(int code, const char *msg) {
 
 /* rethrow the unknown exception */
 
-#ifdef SWIGCSHARP
+#if defined(SWIGCSHARP) || defined(SWIGD)
 %typemap(throws,noblock=1, canthrow=1) (...) {
   SWIG_exception(SWIG_RuntimeError,"unknown exception");
 }

Lib/go/cdata.i

@@ -12,83 +12,12 @@ typedef struct SWIGCDATA {
 %}
 
 %typemap(gotype) SWIGCDATA %{ []byte %}
-%typemap(out) SWIGCDATA (swigcdata argp) {
-  argp = _swig_makegobyteslice($1.data, $1.len);
-  $result.data = (char*)argp.data;
-  $result.len = (int)argp.len;
-}
-
-/* The makegobyteslice function.  */
-
-%insert(runtime) %{
-typedef struct {
-  char *data;
-  int len;
-} swigcdata;
-
+%typemap(out) SWIGCDATA %{
+  $result.data = (char*)_swig_goallocate($1.len);
+  memcpy($result.data, $1.data, $1.len);
+  $result.len = (int)$1.len;
 %}
 
-#ifndef SWIGGO_GCCGO
-%insert(runtime) %{
-extern
-#ifdef __cplusplus
-"C"
-#endif
-void _swig_gc_makegobyteslice(void *, int);
-static swigcdata _swig_makegobyteslice(const char *data, int len) {
-  struct {
-    const char *data;
-    int len;
-    swigcdata ret;
-  } a;
-  a.data = data;
-  a.len = len;
-  crosscall2(_swig_gc_makegobyteslice, &a, (int) sizeof a);
-  return a.ret;
-}
-%}
-
-%insert(gc_header) %{
-typedef struct {
-	byte *data;
-	int32 len;
-} swigcdata;
-extern void ·_swig_internal_makegobyteslice(void);
-#pragma dynexport _swig_gc_makegobyteslice _swig_gc_makegobyteslice
-void _swig_gc_makegobyteslice(void *a, int32 n) {
-	cgocallback(·_swig_internal_makegobyteslice, a, n);
-}
-void ·_swig_allocategobyteslice(byte *data, int32 len, swigcdata ret) {
-	ret.data = mal(len);
-	mcpy(ret.data, data, len);
-	ret.len = len;
-	FLUSH(&ret);
-}
-%}
-
-%insert(go_header) %{
-type swigcdata struct { data *byte; len int }
-func _swig_allocategobyteslice(*byte, int) swigcdata
-func _swig_internal_makegobyteslice(data *byte, len int) swigcdata {
-	return _swig_allocategobyteslice(data, len)
-}
-%}
-
-#else
-
-%insert(runtime) %{
-static swigcdata _swig_makegobyteslice(const char *data, int len) {
-  swigcdata ret;
-  ret.data = (char*)__go_alloc(len);
-  memcpy(ret.data, data, len);
-  ret.len = (int)len;
-  return ret;
-}
-
-%}
-
-#endif
-
 /* -----------------------------------------------------------------------------
  * %cdata(TYPE [, NAME]) 
  *

Lib/go/go.swg

@@ -157,8 +157,8 @@
 		      const float &,
 		      const double &
 %{
-  $result = ($1_ltype)_swig_allocate(sizeof($*1_ltype));
-  *$result = *($1_ltype)$input;
+  $result = ($1_ltype)_swig_goallocate(sizeof($*1_ltype));
+  *$result = *($1_ltype)&$input;
 %}
 
 /* The size_t type.  */
@@ -192,7 +192,7 @@
 
 %typemap(directorout) const size_t &
 %{
-  $result = ($1_ltype)_swig_allocate(sizeof($*1_ltype));
+  $result = ($1_ltype)_swig_goallocate(sizeof($*1_ltype));
   *$result = *($1_ltype)$input;
 %}
 
@@ -206,7 +206,7 @@
 
 %typemap(out) SWIGTYPE (CLASS::*)
 %{
-  $result = _swig_allocate(sizeof($1_ltype));
+  $result = _swig_goallocate(sizeof($1_ltype));
   *($&1_ltype)$result = $1;
 %}
 
@@ -215,7 +215,7 @@
 
 %typemap(directorout) SWIGTYPE (CLASS::*)
 %{
-  $result = _swig_allocate(sizeof($1_ltype));
+  $result = _swig_goallocate(sizeof($1_ltype));
   *($&1_ltype)$result = $input;
 %}
 
@@ -254,14 +254,6 @@
 %typemap(out) SWIGTYPE *const&
 %{ *($1_ltype)&$result = *$1; %}
 
-/* Function pointers are translated by the code in go.cxx into
-   _swig_fnptr.  Member pointers are translated to _swig_memberptr.  */
-
-%insert(go_header) %{
-type _swig_fnptr *byte
-type _swig_memberptr *byte
-%}
-
 /* References.  */
 
 /* Converting a C++ reference to Go has to be handled in the C++
@@ -341,6 +333,28 @@ type _swig_memberptr *byte
 	unsigned char *, unsigned char *&, unsigned char[ANY], unsigned char[]
 %{ $result = ($1_ltype)$input.p; %}
 
+/* String & length */
+
+%typemap(gotype) (char *STRING, size_t LENGTH) "string"
+
+%typemap(in) (char *STRING, size_t LENGTH)
+%{
+  $1 = ($1_ltype)$input.p;
+  $2 = ($2_ltype)$input.n;
+%}
+
+%typemap(out) (char *STRING, size_t LENGTH)
+%{ $result = _swig_makegostring((char*)$1, (size_t)$2); %}
+
+%typemap(directorin) (char *STRING, size_t LENGTH)
+%{ $input = _swig_makegostring((char*)$1_name, $2_name); %}
+
+%typemap(directorout) (char *STRING, size_t LENGTH)
+%{
+  $1 = ($1_ltype)$input.p;
+  $2 = ($2_ltype)$input.n;
+%}
+
 /* Enums.  We can't do the right thing for enums in typemap(gotype) so
    we deliberately don't define them.  The right thing would be to
    capitalize the name.  This is instead done in go.cxx.  */
@@ -508,6 +522,7 @@ type _swig_memberptr *byte
     SWIGTYPE [],
     SWIGTYPE (CLASS::*)
     ""
+
 /* Go keywords.  */
 %include <gokw.swg>
 

Lib/go/goruntime.swg

@@ -30,57 +30,32 @@ swiggo_size_assert(swiggo_long_long, 8)
 swiggo_size_assert(float, 4)
 swiggo_size_assert(double, 8)
 
-extern
 #ifdef __cplusplus
-"C"
+extern "C" {
+#endif
+extern void crosscall2(void (*fn)(void *, int), void *, int);
+extern void _cgo_allocate(void *, int);
+extern void _cgo_panic(void *, int);
+#ifdef __cplusplus
+}
 #endif
-void crosscall2(void (*fn)(void *, int), void *, int);
 
-extern
-#ifdef __cplusplus
-"C"
-#endif
-void _swig_gc_allocate(void *, int);
-static void *_swig_allocate(int len) {
+static void *_swig_goallocate(size_t len) {
   struct {
-    int len;
+    size_t len;
     void *ret;
   } a;
   a.len = len;
-  crosscall2(_swig_gc_allocate, &a, (int) sizeof a);
+  crosscall2(_cgo_allocate, &a, (int) sizeof a);
   return a.ret;
 }
 
-extern
-#ifdef __cplusplus
-"C"
-#endif
-void _swig_gc_makegostring(void *, int);
-static _gostring_ _swig_makegostring(const char *p, size_t l) {
-  struct {
-    const char *p;
-    int l;
-    _gostring_ ret;
-  } a;
-  a.p = p;
-  a.l = l;
-  crosscall2(_swig_gc_makegostring, &a, (int) sizeof a);
-  return a.ret;
-}
-
-extern
-#ifdef __cplusplus
-"C"
-#endif
-void _swig_gc_gopanic(void *, int);
 static void _swig_gopanic(const char *p) {
   struct {
     const char *p;
-    int l;
   } a;
   a.p = p;
-  a.l = strlen(p);
-  crosscall2(_swig_gc_gopanic, &a, (int) sizeof a);
+  crosscall2(_cgo_panic, &a, (int) sizeof a);
 }
 
 %}
@@ -91,10 +66,6 @@ static void _swig_gopanic(const char *p) {
 #include "runtime.h"
 #include "cgocall.h"
 
-#pragma dynimport initcgo initcgo "libcgo.so"
-#pragma dynimport libcgo_thread_start libcgo_thread_start "libcgo.so"
-#pragma dynimport libcgo_set_scheduler libcgo_set_scheduler "libcgo.so"
-
 #ifdef _64BIT
 #define SWIG_PARM_SIZE 8
 #else
@@ -102,97 +73,56 @@ static void _swig_gopanic(const char *p) {
 #endif
 %}
 
-/* 6g/8g C boilerplate that is only needed once in a program.  This
-   only gets added to the file if nothing is imported.  */
-%insert(gc_once) %{
-
-extern void ·_swig_internal_allocate(void);
-#pragma dynexport _swig_gc_allocate _swig_gc_allocate
-void _swig_gc_allocate(void *a, int32 n) {
-	cgocallback(·_swig_internal_allocate, a, n);
-}
-
-void ·_swig_allocatememory(int32 len, byte *ret) {
-	ret = mal(len);
-	FLUSH(&ret);
-}
-
-extern void ·_swig_internal_makegostring(void);
-#pragma dynexport _swig_gc_makegostring _swig_gc_makegostring
-void _swig_gc_makegostring(void *a, int32 n) {
-	cgocallback(·_swig_internal_makegostring, a, n);
-}
-
-void ·_swig_allocatestring(byte *p, int32 l, String ret) {
-	ret.str = mal(l+1);
-	mcpy(ret.str, p, l);
-	ret.len = l;
-	FLUSH(&ret);
-}
-
-extern void ·_swig_internal_gopanic(void);
-#pragma dynexport _swig_gc_gopanic _swig_gc_gopanic
-void _swig_gc_gopanic(void *a, int32 n) {
-	cgocallback(·_swig_internal_gopanic, a, n);
-}
-
-%}
-
-/* Go code that is only needed once in a program.  This is only added
-   to the file if nothing is imported.  */
-%insert(go_once) %{
-func _swig_allocatememory(int) *byte
-func _swig_internal_allocate(len int) *byte {
-	return _swig_allocatememory(len)
-}
-
-func _swig_allocatestring(*byte, int) string
-func _swig_internal_makegostring(p *byte, l int) string {
-	return _swig_allocatestring(p, l)
-}
-
-func _swig_internal_gopanic(p *byte, l int) {
-	panic(_swig_allocatestring(p, l))
-}
-%}
-
 #else
 
 /* Boilerplate for C/C++ code when using gccgo.  */
 %insert(runtime) %{
 #define SWIGGO_GCCGO
 
-extern
 #ifdef __cplusplus
-"C"
+extern "C" {
 #endif
-void *__go_alloc (size_t);
-
-static void *_swig_allocate(int len) {
-  return __go_alloc(len);
-}
-
-static _gostring_ _swig_makegostring(const char *p, size_t l) {
-  _gostring_ ret;
-  ret.p = (char*)__go_alloc(l);
-  memcpy(ret.p, p, l);
-  ret.n = l;
-  return ret;
-}
-
-extern
+extern void *_cgo_allocate(size_t);
+extern void _cgo_panic(const char *);
 #ifdef __cplusplus
-"C"
+}
 #endif
-void __go_panic_msg(const char *);
-#define _swig_gopanic __go_panic_msg
+
+#define _swig_goallocate _cgo_allocate
+#define _swig_gopanic _cgo_panic
 
 %}
 
 #endif
 
 %insert(runtime) %{
+
+static _gostring_ _swig_makegostring(const char *p, size_t l) {
+  _gostring_ ret;
+  ret.p = (char*)_swig_goallocate(l + 1);
+  memcpy(ret.p, p, l);
+  ret.n = l;
+  return ret;
+}
+
 #define SWIG_contract_assert(expr, msg) \
   if (!(expr)) { _swig_gopanic(msg); } else
 %}
 
+#ifndef SWIGGO_GCCGO
+
+%insert(go_header) %{
+
+import _ "runtime/cgo"
+
+%}
+
+#endif
+
+/* Function pointers are translated by the code in go.cxx into
+   _swig_fnptr.  Member pointers are translated to _swig_memberptr.  */
+
+%insert(go_header) %{
+type _swig_fnptr *byte
+type _swig_memberptr *byte
+%}

Lib/go/typemaps.i

@@ -68,16 +68,11 @@ char * typemaps instead:
 %typemap(in) TYPE &INPUT
 %{ $1 = ($1_ltype)$input; %}
 
+%typemap(out) TYPE *INPUT, TYPE &INPUT ""
+
 %typemap(freearg) TYPE *INPUT, TYPE &INPUT ""
 
-%typemap(directorout) TYPE *INPUT
-%{ $result = ($1_ltype)&$input; %}
-
-%typemap(directorout) TYPE &INPUT
-%{ $result = ($1_ltype)$input; %}
-
-%typemap(directorin) TYPE &INPUT
-%{ $1 = ($input_ltype)&$input; %}
+%typemap(argout) TYPE *INPUT, TYPE &INPUT ""
 
 // %typemap(typecheck) TYPE *INPUT = TYPE;
 // %typemap(typecheck) TYPE &INPUT = TYPE;
@@ -95,7 +90,7 @@ INPUT_TYPEMAP(long, int64);
 INPUT_TYPEMAP(unsigned long, uint64);
 INPUT_TYPEMAP(long long, int64);
 INPUT_TYPEMAP(unsigned long long, uint64);
-INPUT_TYPEMAP(float, float);
+INPUT_TYPEMAP(float, float32);
 INPUT_TYPEMAP(double, float64);
 
 #undef INPUT_TYPEMAP
@@ -181,6 +176,8 @@ char * typemaps instead:
   $1 = &temp;
 }
 
+%typemap(out) TYPE *OUTPUT, TYPE &OUTPUT ""
+
 %typemap(freearg) TYPE *OUTPUT, TYPE &OUTPUT ""
 
 %typemap(argout) TYPE *OUTPUT
@@ -195,16 +192,6 @@ char * typemaps instead:
   a[0] = temp$argnum;
 }
 
-%typemap(directorout,warning="Need to provide TYPE *OUTPUT directorout typemap") TYPE *OUTPUT, TYPE &OUTPUT {
-}
-
-%typemap(directorin) TYPE &OUTPUT
-%{ *(($&1_ltype) $input = &$1; %}
-
-%typemap(directorin,warning="Need to provide TYPE *OUTPUT directorin typemap, TYPE array length is unknown") TYPE *OUTPUT
-{
-}
-
 %enddef
 
 OUTPUT_TYPEMAP(bool, bool);
@@ -219,7 +206,7 @@ OUTPUT_TYPEMAP(long, int64);
 OUTPUT_TYPEMAP(unsigned long, uint64);
 OUTPUT_TYPEMAP(long long, int64);
 OUTPUT_TYPEMAP(unsigned long long, uint64);
-OUTPUT_TYPEMAP(float, float);
+OUTPUT_TYPEMAP(float, float32);
 OUTPUT_TYPEMAP(double, float64);
 
 #undef OUTPUT_TYPEMAP
@@ -303,17 +290,11 @@ char * typemaps instead:
   $1 = ($1_ltype) $input->array;
 }
 
+%typemap(out) TYPE *INOUT, TYPE &INOUT ""
+
 %typemap(freearg) TYPE *INOUT, TYPE &INOUT ""
 
-%typemap(directorout,warning="Need to provide TYPE *INOUT directorout typemap") TYPE *INOUT, TYPE &INOUT {
-}
-
-%typemap(directorin) TYPE &INOUT
-%{ *(($&1_ltype)&$input) = &$1; %}
-
-%typemap(directorin,warning="Need to provide TYPE *INOUT directorin typemap, TYPE array length is unknown") TYPE *INOUT, TYPE &INOUT
-{
-}
+%typemap(argout) TYPE *INOUT, TYPE &INOUT ""
 
 %enddef
 
@@ -329,7 +310,7 @@ INOUT_TYPEMAP(long, int64);
 INOUT_TYPEMAP(unsigned long, uint64);
 INOUT_TYPEMAP(long long, int64);
 INOUT_TYPEMAP(unsigned long long, uint64);
-INOUT_TYPEMAP(float, float);
+INOUT_TYPEMAP(float, float32);
 INOUT_TYPEMAP(double, float64);
 
 #undef INOUT_TYPEMAP

Lib/guile/typemaps.i

@@ -348,7 +348,7 @@ typedef unsigned long SCM;
  * String & length
  * ------------------------------------------------------------ */
 
-%typemap(in) (char *STRING, int LENGTH) {
+%typemap(in) (char *STRING, int LENGTH), (char *STRING, size_t LENGTH) {
     size_t temp;
     $1 = ($1_ltype) gh_scm2newstr($input, &temp);
     $2 = ($2_ltype) temp;

Lib/java/java.swg

@@ -1290,6 +1290,21 @@ SWIG_PROXY_CONSTRUCTOR(true, true, SWIGTYPE)
 /* const pointers */
 %apply SWIGTYPE * { SWIGTYPE *const }
 
+/* String & length */
+%typemap(jni)     (char *STRING, size_t LENGTH) "jbyteArray"
+%typemap(jtype)   (char *STRING, size_t LENGTH) "byte[]"
+%typemap(jstype)  (char *STRING, size_t LENGTH) "byte[]"
+%typemap(javain)  (char *STRING, size_t LENGTH) "$javainput"
+%typemap(freearg) (char *STRING, size_t LENGTH) ""
+%typemap(in)      (char *STRING, size_t LENGTH) {
+    $1 = (char *) JCALL2(GetByteArrayElements, jenv, $input, 0);
+    $2 = (size_t) JCALL1(GetArrayLength,       jenv, $input);
+}
+%typemap(argout)  (char *STRING, size_t LENGTH) {
+    JCALL3(ReleaseByteArrayElements, jenv, $input, (jbyte *)$1, 0);
+}
+%apply (char *STRING, size_t LENGTH) { (char *STRING, int LENGTH) }
+
 /* java keywords */
 %include <javakw.swg>
 

Lib/java/typemaps.i

@@ -63,23 +63,12 @@ There are no char *INPUT typemaps, however you can apply the signed char * typem
 %typemap(jtype) TYPE *INPUT, TYPE &INPUT "JTYPE"
 %typemap(jstype) TYPE *INPUT, TYPE &INPUT "JTYPE"
 %typemap(javain) TYPE *INPUT, TYPE &INPUT "$javainput"
-%typemap(javadirectorin) TYPE *INPUT, TYPE &INPUT "$jniinput"
-%typemap(javadirectorout) TYPE *INPUT, TYPE &INPUT "$javacall"
 
 %typemap(in) TYPE *INPUT, TYPE &INPUT
 %{ $1 = ($1_ltype)&$input; %}
 
 %typemap(freearg) TYPE *INPUT, TYPE &INPUT ""
 
-%typemap(directorout) TYPE *INPUT, TYPE &INPUT
-%{ $result = ($1_ltype)&$input; %}
-
-%typemap(directorin,descriptor=JNIDESC) TYPE &INPUT
-%{ *(($&1_ltype) $input) = (JNITYPE *) &$1; %}
-
-%typemap(directorin,descriptor=JNIDESC) TYPE *INPUT
-%{ *(($&1_ltype) $input) = (JNITYPE *) $1; %}
-
 %typemap(typecheck) TYPE *INPUT = TYPE;
 %typemap(typecheck) TYPE &INPUT = TYPE;
 %enddef
@@ -195,8 +184,6 @@ There are no char *OUTPUT typemaps, however you can apply the signed char * type
 %typemap(jtype) TYPE *OUTPUT, TYPE &OUTPUT "JTYPE[]"
 %typemap(jstype) TYPE *OUTPUT, TYPE &OUTPUT "JTYPE[]"
 %typemap(javain) TYPE *OUTPUT, TYPE &OUTPUT "$javainput"
-%typemap(javadirectorin) TYPE *OUTPUT, TYPE &OUTPUT "$jniinput"
-%typemap(javadirectorout) TYPE *OUTPUT, TYPE &OUTPUT "$javacall"
 
 %typemap(in) TYPE *OUTPUT($*1_ltype temp), TYPE &OUTPUT($*1_ltype temp)
 {
@@ -219,16 +206,6 @@ There are no char *OUTPUT typemaps, however you can apply the signed char * type
   JCALL4(Set##JAVATYPE##ArrayRegion, jenv, $input, 0, 1, &jvalue);
 }
 
-%typemap(directorout,warning="Need to provide TYPE *OUTPUT directorout typemap") TYPE *OUTPUT, TYPE &OUTPUT {
-}
-
-%typemap(directorin,descriptor=JNIDESC) TYPE &OUTPUT
-%{ *(($&1_ltype) $input = &$1; %}
-
-%typemap(directorin,descriptor=JNIDESC,warning="Need to provide TYPE *OUTPUT directorin typemap, TYPE array length is unknown") TYPE *OUTPUT
-{
-}
-
 %typemap(typecheck) TYPE *INOUT = TYPECHECKTYPE;
 %typemap(typecheck) TYPE &INOUT = TYPECHECKTYPE;
 %enddef
@@ -335,8 +312,6 @@ There are no char *INOUT typemaps, however you can apply the signed char * typem
 %typemap(jtype) TYPE *INOUT, TYPE &INOUT "JTYPE[]"
 %typemap(jstype) TYPE *INOUT, TYPE &INOUT "JTYPE[]"
 %typemap(javain) TYPE *INOUT, TYPE &INOUT "$javainput"
-%typemap(javadirectorin) TYPE *INOUT, TYPE &INOUT "$jniinput"
-%typemap(javadirectorout) TYPE *INOUT, TYPE &INOUT "$javacall"
 
 %typemap(in) TYPE *INOUT, TYPE &INOUT {
   if (!$input) {
@@ -355,15 +330,6 @@ There are no char *INOUT typemaps, however you can apply the signed char * typem
 %typemap(argout) TYPE *INOUT, TYPE &INOUT
 { JCALL3(Release##JAVATYPE##ArrayElements, jenv, $input, (JNITYPE *)$1, 0); }
 
-%typemap(directorout,warning="Need to provide TYPE *INOUT directorout typemap") TYPE *INOUT, TYPE &INOUT {
-}
-
-%typemap(directorin,descriptor=JNIDESC) TYPE &INOUT
-%{ *(($&1_ltype)&$input) = &$1; %}
-
-%typemap(directorin,descriptor=JNIDESC,warning="Need to provide TYPE *INOUT directorin typemap, TYPE array length is unknown") TYPE *INOUT, TYPE &INOUT
-{
-}
 
 %typemap(typecheck) TYPE *INOUT = TYPECHECKTYPE;
 %typemap(typecheck) TYPE &INOUT = TYPECHECKTYPE;

Lib/lua/lua.swg

@@ -35,10 +35,10 @@
 // note: char is treated as a seperate special type
 // signed char & unsigned char are numbers
 %typemap(consttab) char
-       { SWIG_LUA_CHAR,  (char *)"$symname", (long)$value, 0, 0, 0}
+       { SWIG_LUA_CHAR,    (char *)"$symname", (long)$value, 0, 0, 0}
 
 %typemap(consttab) long long, unsigned long long
-       { SWIG_LUA_STRING, (char *) "$symname", 0, 0, (void *)"$value", 0}
+       { SWIG_LUA_STRING,  (char *) "$symname", 0, 0, (void *)"$value", 0}
 
 %typemap(consttab) SWIGTYPE *, SWIGTYPE *const, SWIGTYPE &, SWIGTYPE []
        { SWIG_LUA_POINTER, (char *)"$symname", 0, 0, (void *)$value, &$1_descriptor}

Lib/lua/typemaps.i

@@ -66,8 +66,10 @@ or provide a %apply statement
 %enddef
 
 // now the code
-SWIG_NUMBER_TYPEMAP(int); SWIG_NUMBER_TYPEMAP(unsigned int); SWIG_NUMBER_TYPEMAP(signed int);
+SWIG_NUMBER_TYPEMAP(unsigned char); SWIG_NUMBER_TYPEMAP(signed char);
+
 SWIG_NUMBER_TYPEMAP(short); SWIG_NUMBER_TYPEMAP(unsigned short); SWIG_NUMBER_TYPEMAP(signed short);
+SWIG_NUMBER_TYPEMAP(int); SWIG_NUMBER_TYPEMAP(unsigned int); SWIG_NUMBER_TYPEMAP(signed int);
 SWIG_NUMBER_TYPEMAP(long); SWIG_NUMBER_TYPEMAP(unsigned long); SWIG_NUMBER_TYPEMAP(signed long);
 SWIG_NUMBER_TYPEMAP(float);
 SWIG_NUMBER_TYPEMAP(double);
@@ -345,6 +347,8 @@ for array handling
 // as well as defining typemaps for
 // fixed len arrays in & out, & variable length arrays in
 
+SWIG_TYPEMAP_NUM_ARR(schar,signed char);
+SWIG_TYPEMAP_NUM_ARR(uchar,unsigned char);
 SWIG_TYPEMAP_NUM_ARR(int,int);
 SWIG_TYPEMAP_NUM_ARR(uint,unsigned int);
 SWIG_TYPEMAP_NUM_ARR(short,short);

Lib/ocaml/std_string.i

@@ -11,141 +11,91 @@
 // However, I think I'll wait until someone asks for it...
 // ------------------------------------------------------------------------
 
-%include <exception.i>
-
 %{
 #include <string>
 #include <vector>
-    using std::string;
-    using std::vector;
 %}
-
+  
+%include <exception.i>
 %include <std_vector.i>
 
-%naturalvar std::string;
-%naturalvar std::wstring;
-
 namespace std {
-    template <class charT> class basic_string {
-    public:
-	typedef charT *pointer;
-	typedef charT &reference;
-	typedef const charT &const_reference;
-	typedef size_t size_type;
-	typedef ptrdiff_t difference_type;
-	basic_string();
-	basic_string( charT *str );
-	size_t size();
-	charT operator []( int pos ) const;
-	charT *c_str() const;
-	basic_string<charT> &operator = ( const basic_string &ws );
-	basic_string<charT> &operator = ( const charT *str );
-	basic_string<charT> &append( const basic_string<charT> &other );
-	basic_string<charT> &append( const charT *str );
-	void push_back( charT c );
-	void clear();
-	void reserve( size_type t );
-	void resize( size_type n, charT c = charT() );
-	int compare( const basic_string<charT> &other ) const;
-	int compare( const charT *str ) const;
-	basic_string<charT> &insert( size_type pos, 
-				     const basic_string<charT> &str );
-	size_type find( const basic_string<charT> &other, int pos = 0 ) const;
-	size_type find( charT c, int pos = 0 ) const;
-	%extend {
-	    bool operator == ( const basic_string<charT> &other ) const {
-		return self->compare( other ) == 0;
-	    }
-	    bool operator != ( const basic_string<charT> &other ) const {
-		return self->compare( other ) != 0;
-	    }
-	    bool operator < ( const basic_string<charT> &other ) const {
-		return self->compare( other ) == -1;
-	    }
-	    bool operator > ( const basic_string<charT> &other ) const {
-		return self->compare( other ) == 1;
-	    }
-	    bool operator <= ( const basic_string<charT> &other ) const {
-		return self->compare( other ) != 1;
-	    }
-	    bool operator >= ( const basic_string<charT> &other ) const {
-		return self->compare( other ) != -1;
-	    }
-	}
-    };
 
-    %template(string) basic_string<char>;
-    %template(wstring) basic_string<wchar_t>;
-    typedef basic_string<char> string;
-    typedef basic_string<wchar_t> wstring;
+%naturalvar string;
+%naturalvar wstring;
+  
+class string;
+class wstring;
+  
+/* Overloading check */
+%typemap(in) string {
+  /* %typemap(in) string */
+  if (caml_ptr_check($input))
+    $1.assign((char *)caml_ptr_val($input,0), caml_string_len($input));
+  else
+    SWIG_exception(SWIG_TypeError, "string expected");
+}
 
-    /* Overloading check */
-    %typemap(in) string {
-        if (caml_ptr_check($input))
-            $1.assign((char *)caml_ptr_val($input,0),
-                      caml_string_len($input));
-        else
-            SWIG_exception(SWIG_TypeError, "string expected");
-    }
+%typemap(in) const string & (std::string temp) {
+  /* %typemap(in) const string & */
+  if (caml_ptr_check($input)) {
+    temp.assign((char *)caml_ptr_val($input,0), caml_string_len($input));
+    $1 = &temp;
+  } else {
+    SWIG_exception(SWIG_TypeError, "string expected");
+  }
+}
 
-    %typemap(in) const string & (std::string temp) {
-        if (caml_ptr_check($input)) {
-            temp.assign((char *)caml_ptr_val($input,0),
-                        caml_string_len($input));
-            $1 = &temp;
-        } else {
-            SWIG_exception(SWIG_TypeError, "string expected");
-        }
-    }
+%typemap(in) string & (std::string temp) {
+  /* %typemap(in) string & */
+  if (caml_ptr_check($input)) {
+    temp.assign((char *)caml_ptr_val($input,0), caml_string_len($input));
+    $1 = &temp;
+  } else {
+    SWIG_exception(SWIG_TypeError, "string expected");
+  }
+}
 
-    %typemap(in) string & (std::string temp) {
-        if (caml_ptr_check($input)) {
-            temp.assign((char *)caml_ptr_val($input,0),
-                        caml_string_len($input));
-            $1 = &temp;
-        } else {
-            SWIG_exception(SWIG_TypeError, "string expected");
-        }
-    }
+%typemap(in) string * (std::string *temp) {
+  /* %typemap(in) string * */
+  if (caml_ptr_check($input)) {
+    temp = new std::string((char *)caml_ptr_val($input,0), caml_string_len($input));
+    $1 = temp;
+  } else {
+    SWIG_exception(SWIG_TypeError, "string expected");
+  }
+}
 
-    %typemap(in) string * (std::string *temp) {
-        if (caml_ptr_check($input)) {
-            temp = new std::string((char *)caml_ptr_val($input,0),
-				   caml_string_len($input));
-            $1 = temp;
-        } else {
-            SWIG_exception(SWIG_TypeError, "string expected");
-        }
-    }
+%typemap(free) string * (std::string *temp) {
+  delete temp;
+}
 
-    %typemap(free) string * (std::string *temp) {
-	delete temp;
-    }
+%typemap(argout) string & {
+  /* %typemap(argout) string & */
+  swig_result =	caml_list_append(swig_result,caml_val_string_len((*$1).c_str(), (*$1).size()));
+}
 
-    %typemap(argout) string & {
-	caml_list_append(swig_result,caml_val_string_len((*$1).c_str(),
-							 (*$1).size()));
-    }
+%typemap(directorout) string {
+  /* %typemap(directorout) string */
+	$result.assign((char *)caml_ptr_val($input,0), caml_string_len($input));
+}
 
-    %typemap(directorout) string {
-	$result.assign((char *)caml_ptr_val($input,0),
-		       caml_string_len($input));
-    }
+%typemap(out) string {
+  /* %typemap(out) string */
+  $result = caml_val_string_len($1.c_str(),$1.size());
+}
 
-    %typemap(out) string {
-        $result = caml_val_string_len($1.c_str(),$1.size());
-    }
-
-    %typemap(out) string * {
+%typemap(out) string * {
+  /* %typemap(out) string * */
 	$result = caml_val_string_len((*$1).c_str(),(*$1).size());
-    }
+}
 }
 
 #ifdef ENABLE_CHARPTR_ARRAY
-char **c_charptr_array( const std::vector <string > &str_v );
+char **c_charptr_array( const std::vector <std::string > &str_v );
 
 %{
-  SWIGEXT char **c_charptr_array( const std::vector <string > &str_v ) {
+  SWIGEXT char **c_charptr_array( const std::vector <std::string > &str_v ) {
     char **out = new char *[str_v.size() + 1];
     out[str_v.size()] = 0;
     for( int i = 0; i < str_v.size(); i++ ) {
@@ -157,7 +107,7 @@ char **c_charptr_array( const std::vector <string > &str_v );
 #endif
 
 #ifdef ENABLE_STRING_VECTOR
-%template (StringVector) std::vector<string >;
+%template (StringVector) std::vector<std::string >;
 
 %insert(ml) %{
   (* Some STL convenience items *)

Lib/ocaml/swigp4.ml.in

@@ -1,118 +1,135 @@
-open Pcaml ;;
+open Camlp4
+  
+module Id : Sig.Id = 
+struct 
+  let name = "swigp4" 
+  let version = "0.1" 
+end 
+  
+module Make (Syntax : Sig.Camlp4Syntax) = 
+struct 
+  open Sig 
+  include Syntax 
 
-let lap x y = x :: y
-let c_ify e @OCAMLLOC@ = 	  
-  match e with
-      <:expr< $int:_$ >> -> <:expr< (C_int $e$) >>
-    | <:expr< $str:_$ >> -> <:expr< (C_string $e$) >>
-    | <:expr< $chr:_$ >> -> <:expr< (C_char $e$) >>
-    | <:expr< $flo:_$ >> -> <:expr< (C_double $e$) >>
-    | <:expr< True    >> -> <:expr< (C_bool $e$) >>
-    | <:expr< False   >> -> <:expr< (C_bool $e$) >>
-    | _ -> <:expr< $e$ >>
-let mk_list args @OCAMLLOC@ f =
-  let rec mk_list_inner args @OCAMLLOC@ f =
-    match args with
-	[] -> <:expr< [] >>
-      | x :: xs ->
-	  (let @OCAMLLOC@ = MLast.loc_of_expr x in
-	     <:expr< [ ($f x @OCAMLLOC@$) ] @ ($mk_list_inner xs @OCAMLLOC@ f$) >>) in
-    match args with
-	[] -> <:expr< (Obj.magic C_void) >>
-      | [ a ] -> <:expr< (Obj.magic $f a @OCAMLLOC@$) >>
-      | _ -> <:expr< (Obj.magic (C_list ($mk_list_inner args @OCAMLLOC@ f$))) >>
+  let _loc = Loc.ghost
+  let lap x y = x :: y
+  let c_ify e loc = 	  
+    match e with
+        <:expr< $int:_$ >> -> <:expr< (C_int $e$) >>
+      | <:expr< $str:_$ >> -> <:expr< (C_string $e$) >>
+      | <:expr< $chr:_$ >> -> <:expr< (C_char $e$) >>
+      | <:expr< $flo:_$ >> -> <:expr< (C_double $e$) >>
+      | <:expr< True    >> -> <:expr< (C_bool $e$) >>
+      | <:expr< False   >> -> <:expr< (C_bool $e$) >>
+      | _ -> <:expr< $e$ >>
+        let mk_list args loc f =
+          let rec mk_list_inner args loc f =
+            match args with
+	              [] -> <:expr< [] >>
+              | x :: xs ->
+	              (let loc = Ast.loc_of_expr x in
+	               <:expr< [ ($f x _loc$) ] @ ($mk_list_inner xs loc f$) >>) in
+          match args with
+	            [] -> <:expr< (Obj.magic C_void) >>
+            | [ a ] -> <:expr< (Obj.magic $f a _loc$) >>
+            | _ -> <:expr< (Obj.magic (C_list ($mk_list_inner args loc f$))) >> ;;
+  
+  EXTEND Gram
+    GLOBAL: expr;
 
-EXTEND
-  expr:
-  [ [ e1 = expr ; "'" ; "[" ; e2 = expr ; "]" ->
-	<:expr< (invoke $e1$) "[]" (C_list [ $c_ify e2 @OCAMLLOC@$ ]) >>
-    | e1 = expr ; "->" ; l = LIDENT ; "(" ; args = LIST0 (expr LEVEL "simple") SEP "," ; ")" ->
-	<:expr< (invoke $e1$) $str:l$ ($mk_list args @OCAMLLOC@ c_ify$) >>
-    | e1 = expr ; "->" ; u = UIDENT ; "(" ; args = LIST0 (expr LEVEL "simple") SEP "," ; ")" ->
-	<:expr< (invoke $e1$) $str:u$ ($mk_list args @OCAMLLOC@ c_ify$) >>
-    | e1 = expr ; "->" ; s = expr LEVEL "simple" ; "(" ; args = LIST0 (expr LEVEL "simple") SEP "," ; ")" ->
-	<:expr< (invoke $e1$) $s$ ($mk_list args @OCAMLLOC@ c_ify$) >>
-    | e1 = expr ; "'" ; "." ; "(" ; args = LIST0 (expr LEVEL "simple") SEP "," ; ")" ->
-	<:expr< (invoke $e1$) "()" ($mk_list args @OCAMLLOC@ c_ify$) >>
-    | e1 = expr ; "'" ; "->" ; l = LIDENT ; "(" ; args = LIST0 (expr LEVEL "simple") SEP "," ; ")" ->
-	<:expr< (invoke ((invoke $e1$) "->" C_void)) $str:l$ ($mk_list args @OCAMLLOC@ c_ify$) >>
-    | e1 = expr ; "'" ; "->" ; u = UIDENT ; "(" ; args = LIST0 (expr LEVEL "simple") SEP "," ; ")" ->
-	<:expr< (invoke ((invoke $e1$) "->" C_void)) $str:u$ ($mk_list args @OCAMLLOC@ c_ify$) >>
-    | e1 = expr ; "'" ; "->" ; s = expr LEVEL "simple" ; "(" ; args = LIST0 (expr LEVEL "simple") SEP "," ; ")" ->
-	<:expr< (invoke ((invoke $e1$) "->" C_void)) $s$ ($mk_list args @OCAMLLOC@ c_ify$) >>
-    | e1 = expr ; "'" ; "++" ->
-	<:expr< (invoke $e1$) "++" C_void >>
-    | e1 = expr ; "'" ; "--" ->
-	<:expr< (invoke $e1$) "--" C_void >>
-    | e1 = expr ; "'" ; "-" ; e2 = expr ->
-	<:expr< (invoke $e1$) "-" (C_list [ $c_ify e2 @OCAMLLOC@$ ]) >>
-    | e1 = expr ; "'" ; "+" ; e2 = expr -> <:expr< (invoke $e1$) "+" (C_list [ $c_ify e2 @OCAMLLOC@$ ])  >> 
-    | e1 = expr ; "'" ; "*" ; e2 = expr -> <:expr< (invoke $e1$) "*" (C_list [ $c_ify e2 @OCAMLLOC@$ ])  >> 
-    | "'" ; "&" ; e1 = expr -> 
-	<:expr< (invoke $e1$) "&" C_void >> 
-    | "'" ; "!" ; e1 = expr ->
-	<:expr< (invoke $e1$) "!" C_void >>
-    | "'" ; "~" ; e1 = expr ->
-	<:expr< (invoke $e1$) "~" C_void >>
-    | e1 = expr ; "'" ; "/" ; e2 = expr ->
-	<:expr< (invoke $e1$) "/" (C_list [ $c_ify e2 @OCAMLLOC@$ ]) >>
-    | e1 = expr ; "'" ; "%" ; e2 = expr ->
-	<:expr< (invoke $e1$) "%" (C_list [ $c_ify e2 @OCAMLLOC@$ ]) >>
-    | e1 = expr ; "'" ; "lsl" ; e2 = expr ->
-	<:expr< (invoke $e1$) ("<" ^ "<") (C_list [ $c_ify e2 @OCAMLLOC@$ ]) >>
-    | e1 = expr ; "'" ; "lsr" ; e2 = expr ->
-	<:expr< (invoke $e1$) (">" ^ ">") (C_list [ $c_ify e2 @OCAMLLOC@$ ]) >>
-    | e1 = expr ; "'" ; "<" ; e2 = expr ->
-	<:expr< (invoke $e1$) "<" (C_list [ $c_ify e2 @OCAMLLOC@$ ]) >>
-    | e1 = expr ; "'" ; "<=" ; e2 = expr ->
-	<:expr< (invoke $e1$) "<=" (C_list [ $c_ify e2 @OCAMLLOC@$ ]) >>
-    | e1 = expr ; "'" ; ">" ; e2 = expr ->
-	<:expr< (invoke $e1$) ">" (C_list [ $c_ify e2 @OCAMLLOC@$ ]) >>
-    | e1 = expr ; "'" ; ">=" ; e2 = expr ->
-	<:expr< (invoke $e1$) ">=" (C_list [ $c_ify e2 @OCAMLLOC@$ ]) >>
-    | e1 = expr ; "'" ; "==" ; e2 = expr ->
-	<:expr< (invoke $e1$) "==" (C_list [ $c_ify e2 @OCAMLLOC@$ ]) >>
-    | e1 = expr ; "'" ; "!=" ; e2 = expr ->
-	<:expr< (invoke $e1$) "!=" (C_list [ $c_ify e2 @OCAMLLOC@$ ]) >>
-    | e1 = expr ; "'" ; "&" ; e2 = expr ->
-	<:expr< (invoke $e1$) "&" (C_list [ $c_ify e2 @OCAMLLOC@$ ]) >>
-    | e1 = expr ; "'" ; "^" ; e2 = expr ->
-	<:expr< (invoke $e1$) "^" (C_list [ $c_ify e2 @OCAMLLOC@$ ]) >>
-    | e1 = expr ; "'" ; "|" ; e2 = expr ->
-	<:expr< (invoke $e1$) "|" (C_list [ $c_ify e2 @OCAMLLOC@$ ]) >>
-    | e1 = expr ; "'" ; "&&" ; e2 = expr ->
-	<:expr< (invoke $e1$) "&&" (C_list [ $c_ify e2 @OCAMLLOC@$ ]) >>
-    | e1 = expr ; "'" ; "||" ; e2 = expr ->
-	<:expr< (invoke $e1$) "||" (C_list [ $c_ify e2 @OCAMLLOC@$ ]) >>
-    | e1 = expr ; "'" ; "=" ; e2 = expr ->
-	<:expr< (invoke $e1$) "=" (C_list [ $c_ify e2 @OCAMLLOC@$ ]) >>
-    | e1 = expr ; "'" ; "+=" ; e2 = expr ->
-	<:expr< (invoke $e1$) "+=" (C_list [ $c_ify e2 @OCAMLLOC@$ ]) >>
-    | e1 = expr ; "'" ; "-=" ; e2 = expr ->
-	<:expr< (invoke $e1$) "-=" (C_list [ $c_ify e2 @OCAMLLOC@$ ]) >>
-    | e1 = expr ; "'" ; "*=" ; e2 = expr ->
-	<:expr< (invoke $e1$) "*=" (C_list [ $c_ify e2 @OCAMLLOC@$ ]) >>
-    | e1 = expr ; "'" ; "/=" ; e2 = expr ->
-	<:expr< (invoke $e1$) "/=" (C_list [ $c_ify e2 @OCAMLLOC@$ ]) >>
-    | e1 = expr ; "'" ; "%=" ; e2 = expr ->
-	<:expr< (invoke $e1$) "%=" (C_list [ $c_ify e2 @OCAMLLOC@$ ]) >>
-    | e1 = expr ; "'" ; "lsl" ; "=" ; e2 = expr ->
-	<:expr< (invoke $e1$) ("<" ^ "<=") (C_list [ $c_ify e2 @OCAMLLOC@$ ]) >>
-    | e1 = expr ; "'" ; "lsr" ; "=" ; e2 = expr ->
-	<:expr< (invoke $e1$) (">" ^ ">=") (C_list [ $c_ify e2 @OCAMLLOC@$ ]) >>
-    | e1 = expr ; "'" ; "&=" ; e2 = expr ->
-	<:expr< (invoke $e1$) "&=" (C_list [ $c_ify e2 @OCAMLLOC@$ ]) >>
-    | e1 = expr ; "'" ; "^=" ; e2 = expr ->
-	<:expr< (invoke $e1$) "^=" (C_list [ $c_ify e2 @OCAMLLOC@$ ]) >> 
-    | e1 = expr ; "'" ; "|=" ; e2 = expr ->
-	<:expr< (invoke $e1$) "|=" (C_list [ $c_ify e2 @OCAMLLOC@$ ]) >>
-    | "'" ; e = expr -> c_ify e @OCAMLLOC@
-    | c = expr ; "as" ; id = LIDENT -> <:expr< $lid:"get_" ^ id$ $c$ >>
-    | c = expr ; "to" ; id = LIDENT -> <:expr< $uid:"C_" ^ id$ $c$ >>
-    | "`" ; "`" ; l = LIDENT -> <:expr< C_enum `$lid:l$ >>
-    | "`" ; "`" ; u = UIDENT -> <:expr< C_enum `$uid:u$ >>
-    | f = expr ; "'" ; "(" ; args = LIST0 (expr LEVEL "simple") SEP "," ; ")" -> 
-	<:expr< $f$ ($mk_list args @OCAMLLOC@ c_ify$) >>
-    ] ] ;
-END ;;
-      
+    expr: LEVEL "top"
+    [ [ e1 = expr ; "'" ; "[" ; e2 = expr ; "]" ->
+	  <:expr< (invoke $e1$) "[]" (C_list [ $c_ify e2 _loc$ ]) >>
+      | e1 = expr ; "->" ; l = LIDENT ; "(" ; args = LIST0 (expr LEVEL "simple") SEP "," ; ")" ->
+	    <:expr< (invoke $e1$) $str:l$ ($mk_list args _loc c_ify$) >>
+      | e1 = expr ; "->" ; u = UIDENT ; "(" ; args = LIST0 (expr LEVEL "simple") SEP "," ; ")" ->
+	    <:expr< (invoke $e1$) $str:u$ ($mk_list args _loc c_ify$) >>
+      | e1 = expr ; "->" ; s = expr LEVEL "simple" ; "(" ; args = LIST0 (expr LEVEL "simple") SEP "," ; ")" ->
+	    <:expr< (invoke $e1$) $s$ ($mk_list args _loc c_ify$) >>
+      | e1 = expr ; "'" ; "." ; "(" ; args = LIST0 (expr LEVEL "simple") SEP "," ; ")" ->
+	    <:expr< (invoke $e1$) "()" ($mk_list args _loc c_ify$) >>
+      | e1 = expr ; "'" ; "->" ; l = LIDENT ; "(" ; args = LIST0 (expr LEVEL "simple") SEP "," ; ")" ->
+	    <:expr< (invoke ((invoke $e1$) "->" C_void)) $str:l$ ($mk_list args _loc c_ify$) >>
+      | e1 = expr ; "'" ; "->" ; u = UIDENT ; "(" ; args = LIST0 (expr LEVEL "simple") SEP "," ; ")" ->
+	    <:expr< (invoke ((invoke $e1$) "->" C_void)) $str:u$ ($mk_list args _loc c_ify$) >>
+      | e1 = expr ; "'" ; "->" ; s = expr LEVEL "simple" ; "(" ; args = LIST0 (expr LEVEL "simple") SEP "," ; ")" ->
+	    <:expr< (invoke ((invoke $e1$) "->" C_void)) $s$ ($mk_list args _loc c_ify$) >>
+      | e1 = expr ; "'" ; "++" ->
+	    <:expr< (invoke $e1$) "++" C_void >>
+      | e1 = expr ; "'" ; "--" ->
+	    <:expr< (invoke $e1$) "--" C_void >>
+      | e1 = expr ; "'" ; "-" ; e2 = expr ->
+	    <:expr< (invoke $e1$) "-" (C_list [ $c_ify e2 _loc$ ]) >>
+      | e1 = expr ; "'" ; "+" ; e2 = expr -> <:expr< (invoke $e1$) "+" (C_list [ $c_ify e2 _loc$ ])  >> 
+      | e1 = expr ; "'" ; "*" ; e2 = expr -> <:expr< (invoke $e1$) "*" (C_list [ $c_ify e2 _loc$ ])  >> 
+      | "'" ; "&" ; e1 = expr -> 
+	    <:expr< (invoke $e1$) "&" C_void >> 
+      | "'" ; "!" ; e1 = expr ->
+	    <:expr< (invoke $e1$) "!" C_void >>
+      | "'" ; "~" ; e1 = expr ->
+	    <:expr< (invoke $e1$) "~" C_void >>
+      | e1 = expr ; "'" ; "/" ; e2 = expr ->
+	    <:expr< (invoke $e1$) "/" (C_list [ $c_ify e2 _loc$ ]) >>
+      | e1 = expr ; "'" ; "%" ; e2 = expr ->
+	    <:expr< (invoke $e1$) "%" (C_list [ $c_ify e2 _loc$ ]) >>
+      | e1 = expr ; "'" ; "lsl" ; e2 = expr ->
+	    <:expr< (invoke $e1$) ("<" ^ "<") (C_list [ $c_ify e2 _loc$ ]) >>
+      | e1 = expr ; "'" ; "lsr" ; e2 = expr ->
+	    <:expr< (invoke $e1$) (">" ^ ">") (C_list [ $c_ify e2 _loc$ ]) >>
+      | e1 = expr ; "'" ; "<" ; e2 = expr ->
+	    <:expr< (invoke $e1$) "<" (C_list [ $c_ify e2 _loc$ ]) >>
+      | e1 = expr ; "'" ; "<=" ; e2 = expr ->
+	    <:expr< (invoke $e1$) "<=" (C_list [ $c_ify e2 _loc$ ]) >>
+      | e1 = expr ; "'" ; ">" ; e2 = expr ->
+	    <:expr< (invoke $e1$) ">" (C_list [ $c_ify e2 _loc$ ]) >>
+      | e1 = expr ; "'" ; ">=" ; e2 = expr ->
+	    <:expr< (invoke $e1$) ">=" (C_list [ $c_ify e2 _loc$ ]) >>
+      | e1 = expr ; "'" ; "==" ; e2 = expr ->
+	    <:expr< (invoke $e1$) "==" (C_list [ $c_ify e2 _loc$ ]) >>
+      | e1 = expr ; "'" ; "!=" ; e2 = expr ->
+	    <:expr< (invoke $e1$) "!=" (C_list [ $c_ify e2 _loc$ ]) >>
+      | e1 = expr ; "'" ; "&" ; e2 = expr ->
+	    <:expr< (invoke $e1$) "&" (C_list [ $c_ify e2 _loc$ ]) >>
+      | e1 = expr ; "'" ; "^" ; e2 = expr ->
+	    <:expr< (invoke $e1$) "^" (C_list [ $c_ify e2 _loc$ ]) >>
+      | e1 = expr ; "'" ; "|" ; e2 = expr ->
+	    <:expr< (invoke $e1$) "|" (C_list [ $c_ify e2 _loc$ ]) >>
+      | e1 = expr ; "'" ; "&&" ; e2 = expr ->
+	    <:expr< (invoke $e1$) "&&" (C_list [ $c_ify e2 _loc$ ]) >>
+      | e1 = expr ; "'" ; "||" ; e2 = expr ->
+	    <:expr< (invoke $e1$) "||" (C_list [ $c_ify e2 _loc$ ]) >>
+      | e1 = expr ; "'" ; "=" ; e2 = expr ->
+	    <:expr< (invoke $e1$) "=" (C_list [ $c_ify e2 _loc$ ]) >>
+      | e1 = expr ; "'" ; "+=" ; e2 = expr ->
+	    <:expr< (invoke $e1$) "+=" (C_list [ $c_ify e2 _loc$ ]) >>
+      | e1 = expr ; "'" ; "-=" ; e2 = expr ->
+	    <:expr< (invoke $e1$) "-=" (C_list [ $c_ify e2 _loc$ ]) >>
+      | e1 = expr ; "'" ; "*=" ; e2 = expr ->
+	    <:expr< (invoke $e1$) "*=" (C_list [ $c_ify e2 _loc$ ]) >>
+      | e1 = expr ; "'" ; "/=" ; e2 = expr ->
+	    <:expr< (invoke $e1$) "/=" (C_list [ $c_ify e2 _loc$ ]) >>
+      | e1 = expr ; "'" ; "%=" ; e2 = expr ->
+	    <:expr< (invoke $e1$) "%=" (C_list [ $c_ify e2 _loc$ ]) >>
+      | e1 = expr ; "'" ; "lsl" ; "=" ; e2 = expr ->
+	    <:expr< (invoke $e1$) ("<" ^ "<=") (C_list [ $c_ify e2 _loc$ ]) >>
+      | e1 = expr ; "'" ; "lsr" ; "=" ; e2 = expr ->
+	    <:expr< (invoke $e1$) (">" ^ ">=") (C_list [ $c_ify e2 _loc$ ]) >>
+      | e1 = expr ; "'" ; "&=" ; e2 = expr ->
+	    <:expr< (invoke $e1$) "&=" (C_list [ $c_ify e2 _loc$ ]) >>
+      | e1 = expr ; "'" ; "^=" ; e2 = expr ->
+	    <:expr< (invoke $e1$) "^=" (C_list [ $c_ify e2 _loc$ ]) >> 
+      | e1 = expr ; "'" ; "|=" ; e2 = expr ->
+	    <:expr< (invoke $e1$) "|=" (C_list [ $c_ify e2 _loc$ ]) >>
+      | "'" ; e = expr -> c_ify e _loc
+      | c = expr ; "as" ; id = LIDENT -> <:expr< $lid:"get_" ^ id$ $c$ >>
+      | c = expr ; "to" ; id = LIDENT -> <:expr< $uid:"C_" ^ id$ $c$ >>
+      | "`" ; "`" ; l = LIDENT -> <:expr< C_enum `$lid:l$ >>
+      | "`" ; "`" ; u = UIDENT -> <:expr< C_enum `$uid:u$ >>
+      | f = expr ; "'" ; "(" ; args = LIST0 (expr LEVEL "simple") SEP "," ; ")" -> 
+	    <:expr< $f$ ($mk_list args _loc c_ify$) >>
+      ] ] ;
+    END ;;
+  
+end 
+  
+module M = Register.OCamlSyntaxExtension(Id)(Make)

Lib/ocaml/typemaps.i

@@ -82,6 +82,17 @@
     }
 }
 
+%typemap(in) char *& (char *temp) {
+  /* %typemap(in) char *& */
+  temp = (char*)caml_val_ptr($1,$descriptor);
+  $1 = &temp;
+}
+
+%typemap(argout) char *& {
+  /* %typemap(argout) char *& */
+  swig_result =	caml_list_append(swig_result,caml_val_string_len(*$1, strlen(*$1)));
+}
+
 #else
 
 %typemap(in) SWIGTYPE {

Lib/octave/octcontainer.swg

@@ -4,8 +4,7 @@
  * Octave cell <-> C++ container wrapper
  *
  * This wrapper, and its iterator, allows a general use (and reuse) of
- * the the mapping between C++ and Octave, thanks to the C++
- * templates.
+ * the mapping between C++ and Octave, thanks to the C++ templates.
  *
  * Of course, it needs the C++ compiler to support templates, but
  * since we will use this wrapper with the STL containers, that should

Lib/octave/octtypemaps.swg

@@ -38,11 +38,6 @@
 // Include the unified typemap library
 %include <typemaps/swigtypemaps.swg>
 
-
-%typemap(constcode,noblock=1) int double {
-  SWIG_Octave_SetConstant(module_ns,"$symname",octave_value($value));
-}
-
 %typecheck(SWIG_TYPECHECK_SWIGOBJECT) SWIG_Object "$1 = (*$input).is_defined();";
 %typecheck(SWIG_TYPECHECK_SWIGOBJECT) octave_value_list "$1 = true;";
 

Lib/perl5/noembed.h

@@ -100,3 +100,9 @@
 #ifdef bind
   #undef bind
 #endif
+#ifdef access
+  #undef access
+#endif
+#ifdef stat
+  #undef stat
+#endif

Lib/perl5/reference.i

@@ -195,7 +195,7 @@ as follows :
   if (!SvIOK(tempsv)) {
     SWIG_croak("expected a integer reference");
   }
-  dvalue = (bool) SvIV(tempsv);
+  dvalue = SvIV(tempsv) ? true : false;
   $1 = &dvalue;
 }
 

Lib/php/director.swg

@@ -106,12 +106,6 @@ namespace Swig {
       Director(zval* self) : swig_self(self) {
       }
 
-      ~Director() {
-        for (swig_ownership_map::iterator i = swig_owner.begin(); i != swig_owner.end(); i++) {
-          swig_owner.erase(i);
-        }
-      }
-
       bool swig_is_overridden_method(char *cname, char *lc_fname) {
         zval classname;
         zend_class_entry **ce;

Lib/php/php.swg

@@ -76,8 +76,7 @@
    $1 = ($1_ltype) Z_STRVAL_PP($input);
 }
 
-%typemap(in) (char *STRING, int LENGTH)
-{
+%typemap(in) (char *STRING, int LENGTH), (char *STRING, size_t LENGTH) {
    convert_to_string_ex($input);
    $1 = ($1_ltype) Z_STRVAL_PP($input);
    $2 = ($2_ltype) Z_STRLEN_PP($input);
@@ -202,7 +201,7 @@
     return_value->type = IS_LONG;
   } else {
     char temp[256];
-    sprintf(temp, "%lld", $1);
+    sprintf(temp, "%lld", (long long)$1);
     ZVAL_STRING(return_value, temp, 1);
   }
 %}
@@ -213,7 +212,7 @@
     return_value->type = IS_LONG;
   } else {
     char temp[256];
-    sprintf(temp, "%llu", $1);
+    sprintf(temp, "%llu", (unsigned long long)$1);
     ZVAL_STRING(return_value, temp, 1);
   }
 %}
@@ -240,7 +239,7 @@
     return_value->type = IS_LONG;
   } else {
     char temp[256];
-    sprintf(temp, "%lld", *$1);
+    sprintf(temp, "%lld", (long long)(*$1));
     ZVAL_STRING(return_value, temp, 1);
   }
 %}
@@ -251,7 +250,7 @@
     return_value->type = IS_LONG;
   } else {
     char temp[256];
-    sprintf(temp, "%llu", *$1);
+    sprintf(temp, "%llu", (unsigned long long)(*$1));
     ZVAL_STRING(return_value, temp, 1);
   }
 %}
@@ -415,17 +414,17 @@
 %php_typecheck(unsigned int,SWIG_TYPECHECK_UINT32,IS_LONG)
 %php_typecheck(short,SWIG_TYPECHECK_INT16,IS_LONG)
 %php_typecheck(unsigned short,SWIG_TYPECHECK_UINT16,IS_LONG)
-%php_typecheck(long,SWIG_TYPECHECK_INT64,IS_LONG)
-%php_typecheck(unsigned long,SWIG_TYPECHECK_UINT64,IS_LONG)
+%php_typecheck(long,SWIG_TYPECHECK_INT32,IS_LONG)
+%php_typecheck(unsigned long,SWIG_TYPECHECK_UINT32,IS_LONG)
 %php_typecheck(long long,SWIG_TYPECHECK_INT64,IS_LONG)
 %php_typecheck(unsigned long long,SWIG_TYPECHECK_UINT64,IS_LONG)
 %php_typecheck(signed char,SWIG_TYPECHECK_INT8,IS_LONG)
 %php_typecheck(unsigned char,SWIG_TYPECHECK_UINT8,IS_LONG)
-%php_typecheck(size_t,SWIG_TYPECHECK_INT16,IS_LONG)
-%php_typecheck(enum SWIGTYPE,SWIG_TYPECHECK_INT8,IS_LONG)
+%php_typecheck(size_t,SWIG_TYPECHECK_SIZE,IS_LONG)
+%php_typecheck(enum SWIGTYPE,SWIG_TYPECHECK_INTEGER,IS_LONG)
 %php_typecheck(bool,SWIG_TYPECHECK_BOOL,IS_BOOL)
 %php_typecheck(float,SWIG_TYPECHECK_FLOAT,IS_DOUBLE)
-%php_typecheck(double,SWIG_TYPECHECK_BOOL,IS_DOUBLE)
+%php_typecheck(double,SWIG_TYPECHECK_DOUBLE,IS_DOUBLE)
 %php_typecheck(char,SWIG_TYPECHECK_CHAR,IS_STRING)
 
 %typemap(typecheck,precedence=SWIG_TYPECHECK_STRING) char *, char *&, char []
@@ -447,6 +446,12 @@
   _v = (SWIG_ConvertPtr(*$input, (void**)&tmp, $1_descriptor, 0) >= 0);
 }
 
+%typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE *const&
+{
+  void *tmp;
+  _v = (SWIG_ConvertPtr(*$input, (void**)&tmp, $*1_descriptor, 0) >= 0);
+}
+
 %typecheck(SWIG_TYPECHECK_VOIDPTR) void *
 {
   void *tmp;

Lib/php/phprun.swg

@@ -246,7 +246,7 @@ static swig_module_info *SWIG_Php_GetModule() {
 
   TSRMLS_FETCH();
 
-  if (zend_get_constant(const_name, sizeof(const_name), pointer TSRMLS_CC)) {
+  if (zend_get_constant(const_name, sizeof(const_name) - 1, pointer TSRMLS_CC)) {
     if (pointer->type == IS_LONG) {
       ret = (swig_module_info *) pointer->value.lval;
     }

Lib/php/typemaps.i

@@ -24,76 +24,108 @@
  *                   its value can be changed by foo().
  * ----------------------------------------------------------------------------- */
 
-%define double_typemap(TYPE)
-%typemap(in) TYPE *INPUT(TYPE temp)
+%define BOOL_TYPEMAP(TYPE)
+%typemap(in) TYPE *INPUT(TYPE temp), TYPE &INPUT(TYPE temp)
+%{
+  convert_to_boolean_ex($input);
+  temp = Z_LVAL_PP($input) ? true : false;
+  $1 = &temp;
+%}
+%typemap(argout) TYPE *INPUT, TYPE &INPUT "";
+%typemap(in,numinputs=0) TYPE *OUTPUT(TYPE temp), TYPE &OUTPUT(TYPE temp) "$1 = &temp;";
+%typemap(argout,fragment="t_output_helper") TYPE *OUTPUT, TYPE &OUTPUT
+{
+  zval *o;
+  MAKE_STD_ZVAL(o);
+  ZVAL_BOOL(o,temp$argnum);
+  t_output_helper( &$result, o );
+}
+%typemap(in) TYPE *REFERENCE (TYPE lvalue), TYPE &REFERENCE (TYPE lvalue)
+%{
+  convert_to_boolean_ex($input);
+  lvalue = (*$input)->value.lval ? true : false;
+  $1 = &lvalue;
+%}
+%typemap(argout) TYPE *REFERENCE, TYPE &REFERENCE
+%{
+  (*$arg)->value.lval = lvalue$argnum ? true : false;
+  (*$arg)->type = IS_BOOL;
+%}
+%enddef
+
+%define DOUBLE_TYPEMAP(TYPE)
+%typemap(in) TYPE *INPUT(TYPE temp), TYPE &INPUT(TYPE temp)
 %{
   convert_to_double_ex($input);
   temp = (TYPE) Z_DVAL_PP($input);
   $1 = &temp;
 %}
-%typemap(argout) TYPE *INPUT "";
-%typemap(in,numinputs=0) TYPE *OUTPUT(TYPE temp) "$1 = &temp;";
-%typemap(argout,fragment="t_output_helper") TYPE *OUTPUT
+%typemap(argout) TYPE *INPUT, TYPE &INPUT "";
+%typemap(in,numinputs=0) TYPE *OUTPUT(TYPE temp), TYPE &OUTPUT(TYPE temp) "$1 = &temp;";
+%typemap(argout,fragment="t_output_helper") TYPE *OUTPUT, TYPE &OUTPUT
 {
   zval *o;
   MAKE_STD_ZVAL(o);
   ZVAL_DOUBLE(o,temp$argnum);
   t_output_helper( &$result, o );
 }
-%typemap(in) TYPE *REFERENCE (TYPE dvalue)
+%typemap(in) TYPE *REFERENCE (TYPE dvalue), TYPE &REFERENCE (TYPE dvalue)
 %{
   convert_to_double_ex($input);
   dvalue = (TYPE) (*$input)->value.dval;
   $1 = &dvalue;
 %}
-%typemap(argout) TYPE *REFERENCE
+%typemap(argout) TYPE *REFERENCE, TYPE &REFERENCE
 %{
   $1->value.dval = (double)(lvalue$argnum);
   $1->type = IS_DOUBLE;
 %}
 %enddef
 
-%define int_typemap(TYPE)
-%typemap(in) TYPE *INPUT(TYPE temp)
+%define INT_TYPEMAP(TYPE)
+%typemap(in) TYPE *INPUT(TYPE temp), TYPE &INPUT(TYPE temp)
 %{
   convert_to_long_ex($input);
   temp = (TYPE) Z_LVAL_PP($input);
   $1 = &temp;
 %}
-%typemap(argout) TYPE *INPUT "";
-%typemap(in,numinputs=0) TYPE *OUTPUT(TYPE temp) "$1 = &temp;";
-%typemap(argout,fragment="t_output_helper") TYPE *OUTPUT
+%typemap(argout) TYPE *INPUT, TYPE &INPUT "";
+%typemap(in,numinputs=0) TYPE *OUTPUT(TYPE temp), TYPE &OUTPUT(TYPE temp) "$1 = &temp;";
+%typemap(argout,fragment="t_output_helper") TYPE *OUTPUT, TYPE &OUTPUT
 {
   zval *o;
   MAKE_STD_ZVAL(o);
   ZVAL_LONG(o,temp$argnum);
   t_output_helper( &$result, o );
 }
-%typemap(in) TYPE *REFERENCE (TYPE lvalue)
+%typemap(in) TYPE *REFERENCE (TYPE lvalue), TYPE &REFERENCE (TYPE lvalue)
 %{
   convert_to_long_ex($input);
   lvalue = (TYPE) (*$input)->value.lval;
   $1 = &lvalue;
 %}
-%typemap(argout) TYPE *REFERENCE
+%typemap(argout) TYPE *REFERENCE, TYPE &REFERENCE
 %{
   (*$arg)->value.lval = (long)(lvalue$argnum);
   (*$arg)->type = IS_LONG;
 %}
 %enddef
 
-double_typemap(float);
-double_typemap(double);
+BOOL_TYPEMAP(bool);
 
-int_typemap(int);
-int_typemap(short);
-int_typemap(long);
-int_typemap(unsigned int);
-int_typemap(unsigned short);
-int_typemap(unsigned long);
-int_typemap(unsigned char);
+DOUBLE_TYPEMAP(float);
+DOUBLE_TYPEMAP(double);
 
-int_typemap(long long);
+INT_TYPEMAP(int);
+INT_TYPEMAP(short);
+INT_TYPEMAP(long);
+INT_TYPEMAP(unsigned int);
+INT_TYPEMAP(unsigned short);
+INT_TYPEMAP(unsigned long);
+INT_TYPEMAP(unsigned char);
+INT_TYPEMAP(signed char);
+
+INT_TYPEMAP(long long);
 %typemap(argout,fragment="t_output_helper") long long *OUTPUT
 {
   zval *o;
@@ -102,7 +134,7 @@ int_typemap(long long);
     ZVAL_LONG(o, temp$argnum);
   } else {
     char temp[256];
-    sprintf(temp, "%lld", temp$argnum);
+    sprintf(temp, "%lld", (long long)temp$argnum);
     ZVAL_STRING(o, temp, 1);
   }
   t_output_helper( &$result, o );
@@ -119,7 +151,7 @@ int_typemap(long long);
     (*$arg)->type = IS_LONG;
   } else {
     char temp[256];
-    sprintf(temp, "%lld", lvalue$argnum);
+    sprintf(temp, "%lld", (long long)lvalue$argnum);
     ZVAL_STRING((*$arg), temp, 1);
   }
 %}
@@ -130,11 +162,11 @@ int_typemap(long long);
     ($result)->type = IS_LONG;
   } else {
     char temp[256];
-    sprintf(temp, "%lld", *arg$argnum);
+    sprintf(temp, "%lld", (long long)(*arg$argnum));
     ZVAL_STRING($result, temp, 1);
   }
 %}
-int_typemap(unsigned long long);
+INT_TYPEMAP(unsigned long long);
 %typemap(argout,fragment="t_output_helper") unsigned long long *OUTPUT
 {
   zval *o;
@@ -143,7 +175,7 @@ int_typemap(unsigned long long);
     ZVAL_LONG(o, temp$argnum);
   } else {
     char temp[256];
-    sprintf(temp, "%llu", temp$argnum);
+    sprintf(temp, "%llu", (unsigned long long)temp$argnum);
     ZVAL_STRING(o, temp, 1);
   }
   t_output_helper( &$result, o );
@@ -160,7 +192,7 @@ int_typemap(unsigned long long);
     (*$arg)->type = IS_LONG;
   } else {
     char temp[256];
-    sprintf(temp, "%llu", lvalue$argnum);
+    sprintf(temp, "%llu", (unsigned long long)lvalue$argnum);
     ZVAL_STRING((*$arg), temp, 1);
   }
 %}
@@ -171,11 +203,12 @@ int_typemap(unsigned long long);
     ($result)->type = IS_LONG;
   } else {
     char temp[256];
-    sprintf(temp, "%llu", *arg$argnum);
+    sprintf(temp, "%llu", (unsigned long long)(*arg$argnum));
     ZVAL_STRING($result, temp, 1);
   }
 %}
 
+%typemap(in) bool *INOUT = bool *INPUT;
 %typemap(in) float *INOUT = float *INPUT;
 %typemap(in) double *INOUT = double *INPUT;
 
@@ -188,7 +221,9 @@ int_typemap(unsigned long long);
 %typemap(in) unsigned long *INOUT = unsigned long *INPUT;
 %typemap(in) unsigned char *INOUT = unsigned char *INPUT;
 %typemap(in) unsigned long long *INOUT = unsigned long long *INPUT;
+%typemap(in) signed char *INOUT = signed char *INPUT;
 
+%typemap(in) bool &INOUT = bool *INPUT;
 %typemap(in) float &INOUT = float *INPUT;
 %typemap(in) double &INOUT = double *INPUT;
 
@@ -203,7 +238,9 @@ int_typemap(unsigned long long);
 %typemap(in) unsigned char &INOUT = unsigned char *INPUT;
 %typemap(in) unsigned long long &INOUT = unsigned long long *INPUT;
 %typemap(in) unsigned long long &INPUT = unsigned long long *INPUT;
+%typemap(in) signed char &INOUT = signed char *INPUT;
 
+%typemap(argout) bool *INOUT = bool *OUTPUT;
 %typemap(argout) float *INOUT = float *OUTPUT;
 %typemap(argout) double *INOUT= double *OUTPUT;
 
@@ -215,7 +252,9 @@ int_typemap(unsigned long long);
 %typemap(argout) unsigned long *INOUT = unsigned long *OUTPUT;
 %typemap(argout) unsigned char *INOUT = unsigned char *OUTPUT;
 %typemap(argout) unsigned long long *INOUT = unsigned long long *OUTPUT;
+%typemap(argout) signed char *INOUT = signed char *OUTPUT;
 
+%typemap(argout) bool &INOUT = bool *OUTPUT;
 %typemap(argout) float &INOUT = float *OUTPUT;
 %typemap(argout) double &INOUT= double *OUTPUT;
 
@@ -227,6 +266,7 @@ int_typemap(unsigned long long);
 %typemap(argout) unsigned long &INOUT = unsigned long *OUTPUT;
 %typemap(argout) unsigned char &INOUT = unsigned char *OUTPUT;
 %typemap(argout) unsigned long long &INOUT = unsigned long long *OUTPUT;
+%typemap(argout) signed char &INOUT = signed char *OUTPUT;
 
 %typemap(in) char INPUT[ANY] ( char temp[$1_dim0] )
 %{

Lib/pike/pike.swg

@@ -185,7 +185,7 @@ extern "C" {
  * String & length
  * ------------------------------------------------------------ */
 
-%typemap(in, pikedesc="tStr") (char *STRING, int LENGTH) {
+%typemap(in) (char *STRING, int LENGTH), (char *STRING, size_t LENGTH) {
     if ($input.type != T_STRING)
         Pike_error("Bad argument: Expected a string.\n");
     $1 = ($1_ltype) STR0($input.u.string);

Lib/python/boost_shared_ptr.i

@@ -6,6 +6,10 @@
 #define SHARED_PTR_DISOWN 0
 #endif
 
+%fragment("SWIG_null_deleter_python", "header", fragment="SWIG_null_deleter") {
+%#define SWIG_NO_NULL_DELETER_SWIG_BUILTIN_INIT
+}
+
 // Language specific macro implementing all the customisations for handling the smart pointer
 %define SWIG_SHARED_PTR_TYPEMAPS(CONST, TYPE...)
 
@@ -75,7 +79,8 @@
     $1 = %const_cast((smartarg ? smartarg->get() : 0), $1_ltype);
   }
 }
-%typemap(out, fragment="SWIG_null_deleter") CONST TYPE * {
+
+%typemap(out, fragment="SWIG_null_deleter_python") CONST TYPE * {
   SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = $1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >($1 SWIG_NO_NULL_DELETER_$owner) : 0;
   %set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), $owner | SWIG_POINTER_OWN));
 }
@@ -98,7 +103,7 @@
     $1 = %const_cast((smartarg ? smartarg->get() : 0), $1_ltype);
   }
 }
-%typemap(varout, fragment="SWIG_null_deleter") CONST TYPE * {
+%typemap(varout, fragment="SWIG_null_deleter_python") CONST TYPE * {
   SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = $1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >($1 SWIG_NO_NULL_DELETER_0) : 0;
   %set_varoutput(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
 }
@@ -119,7 +124,7 @@
     $1 = %const_cast(%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *)->get(), $1_ltype);
   }
 }
-%typemap(out, fragment="SWIG_null_deleter") CONST TYPE & {
+%typemap(out, fragment="SWIG_null_deleter_python") CONST TYPE & {
   SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >($1 SWIG_NO_NULL_DELETER_$owner);
   %set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
 }
@@ -141,7 +146,7 @@
     $1 = *%const_cast(%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *)->get(), $1_ltype);
   }
 }
-%typemap(varout, fragment="SWIG_null_deleter") CONST TYPE & {
+%typemap(varout, fragment="SWIG_null_deleter_python") CONST TYPE & {
   SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(&$1 SWIG_NO_NULL_DELETER_0);
   %set_varoutput(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
 }
@@ -163,7 +168,7 @@
   }
   $1 = &temp;
 }
-%typemap(out, fragment="SWIG_null_deleter") TYPE *CONST& {
+%typemap(out, fragment="SWIG_null_deleter_python") TYPE *CONST& {
   SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(*$1 SWIG_NO_NULL_DELETER_$owner);
   %set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
 }
@@ -311,5 +316,7 @@
 
 
 %template() SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >;
+
+
 %enddef
 

Lib/python/builtin.swg

@@ -0,0 +1,481 @@
+#define SWIGPY_UNARYFUNC_CLOSURE(wrapper)	\
+SWIGINTERN PyObject *				\
+wrapper##_closure(PyObject *a) {		\
+  return wrapper(a, NULL);			\
+}
+
+#define SWIGPY_DESTRUCTOR_CLOSURE(wrapper)	\
+SWIGINTERN void					\
+wrapper##_closure(PyObject *a) {		\
+    SwigPyObject *sobj;				\
+    sobj = (SwigPyObject *)a;			\
+    if (sobj->own) {				\
+	PyObject *o = wrapper(a, NULL);		\
+	Py_XDECREF(o);				\
+    }						\
+}
+
+#define SWIGPY_INQUIRY_CLOSURE(wrapper)				\
+SWIGINTERN int							\
+wrapper##_closure(PyObject *a) {				\
+    PyObject *pyresult;						\
+    int result;							\
+    pyresult = wrapper(a, NULL);				\
+    result = pyresult && PyObject_IsTrue(pyresult) ? 1 : 0;	\
+    Py_XDECREF(pyresult);					\
+    return result;						\
+}
+
+#define SWIGPY_BINARYFUNC_CLOSURE(wrapper)	\
+SWIGINTERN PyObject *				\
+wrapper##_closure(PyObject *a, PyObject *b) {	\
+    PyObject *tuple, *result;			\
+    tuple = PyTuple_New(1);			\
+    assert(tuple);				\
+    PyTuple_SET_ITEM(tuple, 0, b);		\
+    Py_XINCREF(b);				\
+    result = wrapper(a, tuple);			\
+    Py_DECREF(tuple);				\
+    return result;				\
+}
+
+#define SWIGPY_TERNARYFUNC_CLOSURE(wrapper)			\
+SWIGINTERN PyObject *						\
+wrapper##_closure(PyObject *a, PyObject *b, PyObject *c) {	\
+    PyObject *tuple, *result;					\
+    tuple = PyTuple_New(2);					\
+    assert(tuple);						\
+    PyTuple_SET_ITEM(tuple, 0, b);				\
+    PyTuple_SET_ITEM(tuple, 1, c);				\
+    Py_XINCREF(b);						\
+    Py_XINCREF(c);						\
+    result = wrapper(a, tuple);					\
+    Py_DECREF(tuple);						\
+    return result;						\
+}
+
+#define SWIGPY_LENFUNC_CLOSURE(wrapper)			\
+SWIGINTERN Py_ssize_t					\
+wrapper##_closure(PyObject *a) {			\
+    PyObject *resultobj;				\
+    Py_ssize_t result;					\
+    resultobj = wrapper(a, NULL);			\
+    result = PyNumber_AsSsize_t(resultobj, NULL);	\
+    Py_DECREF(resultobj);				\
+    return result;					\
+}
+
+#define SWIGPY_SSIZESSIZEARGFUNC_CLOSURE(wrapper)		\
+SWIGINTERN PyObject *						\
+wrapper##_closure(PyObject *a, Py_ssize_t b, Py_ssize_t c) {	\
+    PyObject *tuple, *result;					\
+    tuple = PyTuple_New(2);					\
+    assert(tuple);						\
+    PyTuple_SET_ITEM(tuple, 0, _PyLong_FromSsize_t(b));		\
+    PyTuple_SET_ITEM(tuple, 1, _PyLong_FromSsize_t(c));		\
+    result = wrapper(a, tuple);					\
+    Py_DECREF(tuple);						\
+    return result;						\
+}
+
+#define SWIGPY_SSIZESSIZEOBJARGPROC_CLOSURE(wrapper)			\
+SWIGINTERN int								\
+wrapper##_closure(PyObject *a, Py_ssize_t b, Py_ssize_t c, PyObject *d) { \
+    PyObject *tuple, *resultobj;					\
+    int result;								\
+    tuple = PyTuple_New(d ? 3 : 2);					\
+    assert(tuple);							\
+    PyTuple_SET_ITEM(tuple, 0, _PyLong_FromSsize_t(b));			\
+    PyTuple_SET_ITEM(tuple, 1, _PyLong_FromSsize_t(c));			\
+    if (d) {								\
+        PyTuple_SET_ITEM(tuple, 2, d);					\
+        Py_INCREF(d);							\
+    }									\
+    resultobj = wrapper(a, tuple);					\
+    result = resultobj ? 0 : -1;					\
+    Py_DECREF(tuple);							\
+    Py_XDECREF(resultobj);						\
+    return result;							\
+}
+
+#define SWIGPY_SSIZEARGFUNC_CLOSURE(wrapper)		\
+SWIGINTERN PyObject *					\
+wrapper##_closure(PyObject *a, Py_ssize_t b) {		\
+    PyObject *tuple, *result;				\
+    tuple = PyTuple_New(1);				\
+    assert(tuple);					\
+    PyTuple_SET_ITEM(tuple, 0, _PyLong_FromSsize_t(b));	\
+    result = wrapper(a, tuple);				\
+    Py_DECREF(tuple);					\
+    return result;					\
+}
+
+#define SWIGPY_FUNPACK_SSIZEARGFUNC_CLOSURE(wrapper)		\
+SWIGINTERN PyObject *					\
+wrapper##_closure(PyObject *a, Py_ssize_t b) {		\
+    PyObject *arg, *result;				\
+    arg = _PyLong_FromSsize_t(b);			\
+    result = wrapper(a, arg);				\
+    Py_DECREF(arg);					\
+    return result;					\
+}
+
+#define SWIGPY_SSIZEOBJARGPROC_CLOSURE(wrapper)			\
+SWIGINTERN int							\
+wrapper##_closure(PyObject *a, Py_ssize_t b, PyObject *c) {	\
+    PyObject *tuple, *resultobj;				\
+    int result;							\
+    tuple = PyTuple_New(2);					\
+    assert(tuple);						\
+    PyTuple_SET_ITEM(tuple, 0, _PyLong_FromSsize_t(b));		\
+    PyTuple_SET_ITEM(tuple, 1, c);				\
+    Py_XINCREF(c);						\
+    resultobj = wrapper(a, tuple);				\
+    result = resultobj ? 0 : -1;				\
+    Py_XDECREF(resultobj);					\
+    Py_DECREF(tuple);						\
+    return result;						\
+}
+
+#define SWIGPY_OBJOBJARGPROC_CLOSURE(wrapper)			\
+SWIGINTERN int							\
+wrapper##_closure(PyObject *a, PyObject *b, PyObject *c) {	\
+    PyObject *tuple, *resultobj;				\
+    int result;							\
+    tuple = PyTuple_New(c ? 2 : 1);				\
+    assert(tuple);						\
+    PyTuple_SET_ITEM(tuple, 0, b);				\
+    Py_XINCREF(b);						\
+    if (c) {							\
+        PyTuple_SET_ITEM(tuple, 1, c);				\
+        Py_XINCREF(c);						\
+    }								\
+    resultobj = wrapper(a, tuple);				\
+    result = resultobj ? 0 : -1;				\
+    Py_XDECREF(resultobj);					\
+    Py_DECREF(tuple);						\
+    return result;						\
+}
+
+#define SWIGPY_REPRFUNC_CLOSURE(wrapper)	\
+SWIGINTERN PyObject *				\
+wrapper##_closure(PyObject *a) {		\
+    return wrapper(a, NULL);			\
+}
+
+#define SWIGPY_HASHFUNC_CLOSURE(wrapper)	\
+SWIGINTERN long					\
+wrapper##_closure(PyObject *a) {		\
+    PyObject *pyresult;				\
+    long result;				\
+    pyresult = wrapper(a, NULL);		\
+    if (!pyresult || !PyLong_Check(pyresult))	\
+	return -1;				\
+    result = PyLong_AsLong(pyresult);		\
+    Py_DECREF(pyresult);			\
+    return result;				\
+}
+
+#define SWIGPY_ITERNEXT_CLOSURE(wrapper)	\
+SWIGINTERN PyObject *				\
+wrapper##_closure(PyObject *a) {		\
+    PyObject *result;				\
+    result = wrapper(a, NULL);			\
+    if (result && result == Py_None) {		\
+	Py_DECREF(result);			\
+	result = NULL;				\
+    }						\
+    return result;				\
+}
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+SWIGINTERN int
+SwigPyBuiltin_BadInit(PyObject *self, PyObject *SWIGUNUSEDPARM(args), PyObject *SWIGUNUSEDPARM(kwds)) {
+  PyErr_Format(PyExc_TypeError, "Cannot create new instances of type '%.300s'", self->ob_type->tp_name);
+  return -1;
+}
+
+SWIGINTERN void
+SwigPyBuiltin_BadDealloc(PyObject *pyobj) {
+  SwigPyObject *sobj;
+  sobj = (SwigPyObject *)pyobj;
+  if (sobj->own) {
+    PyErr_Format(PyExc_TypeError, "Swig detected a memory leak in type '%.300s': no callable destructor found.", pyobj->ob_type->tp_name);
+  }
+}
+
+typedef struct {
+  PyCFunction get;
+  PyCFunction set;
+} SwigPyGetSet;
+
+SWIGINTERN PyObject *
+SwigPyBuiltin_GetterClosure (PyObject *obj, void *closure) {
+  SwigPyGetSet *getset;
+  PyObject *tuple, *result;
+  if (!closure)
+    return SWIG_Py_Void();
+  getset = (SwigPyGetSet *)closure;
+  if (!getset->get)
+    return SWIG_Py_Void();
+  tuple = PyTuple_New(0);
+  assert(tuple);
+  result = (*getset->get)(obj, tuple);
+  Py_DECREF(tuple);
+  return result;
+}
+
+SWIGINTERN PyObject *
+SwigPyBuiltin_FunpackGetterClosure (PyObject *obj, void *closure) {
+  SwigPyGetSet *getset;
+  PyObject *result;
+  if (!closure)
+    return SWIG_Py_Void();
+  getset = (SwigPyGetSet *)closure;
+  if (!getset->get)
+    return SWIG_Py_Void();
+  result = (*getset->get)(obj, NULL);
+  return result;
+}
+
+SWIGINTERN int
+SwigPyBuiltin_SetterClosure (PyObject *obj, PyObject *val, void *closure) {
+  SwigPyGetSet *getset;
+  PyObject *tuple, *result;
+  if (!closure) {
+    PyErr_Format(PyExc_TypeError, "Missing getset closure");
+    return -1;
+  }
+  getset = (SwigPyGetSet *)closure;
+  if (!getset->set) {
+    PyErr_Format(PyExc_TypeError, "Illegal member variable assignment in type '%.300s'", obj->ob_type->tp_name);
+    return -1;
+  }
+  tuple = PyTuple_New(1);
+  assert(tuple);
+  PyTuple_SET_ITEM(tuple, 0, val);
+  Py_XINCREF(val);
+  result = (*getset->set)(obj, tuple);
+  Py_DECREF(tuple);
+  Py_XDECREF(result);
+  return result ? 0 : -1;
+}
+
+SWIGINTERN int
+SwigPyBuiltin_FunpackSetterClosure (PyObject *obj, PyObject *val, void *closure) {
+  SwigPyGetSet *getset;
+  PyObject *result;
+  if (!closure) {
+    PyErr_Format(PyExc_TypeError, "Missing getset closure");
+    return -1;
+  }
+  getset = (SwigPyGetSet *)closure;
+  if (!getset->set) {
+    PyErr_Format(PyExc_TypeError, "Illegal member variable assignment in type '%.300s'", obj->ob_type->tp_name);
+    return -1;
+  }
+  result = (*getset->set)(obj, val);
+  Py_XDECREF(result);
+  return result ? 0 : -1;
+}
+
+SWIGINTERN void
+SwigPyStaticVar_dealloc(PyDescrObject *descr) {
+  _PyObject_GC_UNTRACK(descr);
+  Py_XDECREF(descr->d_type);
+  Py_XDECREF(descr->d_name);
+  PyObject_GC_Del(descr);
+}
+
+SWIGINTERN PyObject *
+SwigPyStaticVar_repr(PyGetSetDescrObject *descr) {
+#if PY_VERSION_HEX >= 0x03000000
+  return PyUnicode_FromFormat("<class attribute '%S' of type '%s'>", descr->d_name, descr->d_type->tp_name);
+#else
+  return PyString_FromFormat("<class attribute '%s' of type '%s'>", PyString_AsString(descr->d_name), descr->d_type->tp_name);
+#endif
+}
+
+SWIGINTERN int
+SwigPyStaticVar_traverse(PyObject *self, visitproc visit, void *arg) {
+  PyDescrObject *descr;
+  descr = (PyDescrObject *)self;
+  Py_VISIT((PyObject*) descr->d_type);
+  return 0;
+}
+
+SWIGINTERN PyObject *
+SwigPyStaticVar_get(PyGetSetDescrObject *descr, PyObject *obj, PyObject *SWIGUNUSEDPARM(type)) {
+  if (descr->d_getset->get != NULL)
+    return descr->d_getset->get(obj, descr->d_getset->closure);
+#if PY_VERSION_HEX >= 0x03000000
+  PyErr_Format(PyExc_AttributeError, "attribute '%.300S' of '%.100s' objects is not readable", descr->d_name, descr->d_type->tp_name);
+#else
+  PyErr_Format(PyExc_AttributeError, "attribute '%.300s' of '%.100s' objects is not readable", PyString_AsString(descr->d_name), descr->d_type->tp_name);
+#endif
+  return NULL;
+}
+
+SWIGINTERN int
+SwigPyStaticVar_set(PyGetSetDescrObject *descr, PyObject *obj, PyObject *value) {
+  if (descr->d_getset->set != NULL)
+    return descr->d_getset->set(obj, value, descr->d_getset->closure);
+#if PY_VERSION_HEX >= 0x03000000
+  PyErr_Format(PyExc_AttributeError, "attribute '%.300S' of '%.100s' objects is not writable", descr->d_name, descr->d_type->tp_name);
+#else
+  PyErr_Format(PyExc_AttributeError, "attribute '%.300s' of '%.100s' objects is not writable", PyString_AsString(descr->d_name), descr->d_type->tp_name);
+#endif
+  return -1;
+}
+
+SWIGINTERN PyTypeObject SwigPyStaticVar_Type = {
+#if PY_VERSION_HEX >= 0x03000000
+  PyVarObject_HEAD_INIT(&PyType_Type, 0)
+#else
+  PyObject_HEAD_INIT(&PyType_Type)
+  0,
+#endif
+  "swig_static_var_getset_descriptor",
+  sizeof(PyGetSetDescrObject),
+  0,
+  (destructor)SwigPyStaticVar_dealloc,      /* tp_dealloc */
+  0,                                        /* tp_print */
+  0,                                        /* tp_getattr */
+  0,                                        /* tp_setattr */
+  0,                                        /* tp_compare */
+  (reprfunc)SwigPyStaticVar_repr,           /* tp_repr */
+  0,                                        /* tp_as_number */
+  0,                                        /* tp_as_sequence */
+  0,                                        /* tp_as_mapping */
+  0,                                        /* tp_hash */
+  0,                                        /* tp_call */
+  0,                                        /* tp_str */
+  PyObject_GenericGetAttr,                  /* tp_getattro */
+  0,                                        /* tp_setattro */
+  0,                                        /* tp_as_buffer */
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_CLASS, /* tp_flags */
+  0,                                        /* tp_doc */
+  SwigPyStaticVar_traverse,                 /* tp_traverse */
+  0,                                        /* tp_clear */
+  0,                                        /* tp_richcompare */
+  0,                                        /* tp_weaklistoffset */
+  0,                                        /* tp_iter */
+  0,                                        /* tp_iternext */
+  0,                                        /* tp_methods */
+  0,                                        /* tp_members */
+  0,                                        /* tp_getset */
+  0,                                        /* tp_base */
+  0,                                        /* tp_dict */
+  (descrgetfunc)SwigPyStaticVar_get,        /* tp_descr_get */
+  (descrsetfunc)SwigPyStaticVar_set,        /* tp_descr_set */
+  0,                                        /* tp_dictoffset */
+  0,                                        /* tp_init */
+  0,                                        /* tp_alloc */
+  0,                                        /* tp_new */
+  0,                                        /* tp_free */
+  0,                                        /* tp_is_gc */
+  0,                                        /* tp_bases */
+  0,                                        /* tp_mro */
+  0,                                        /* tp_cache */
+  0,                                        /* tp_subclasses */
+  0,                                        /* tp_weaklist */
+#if PY_VERSION_HEX >= 0x02030000
+  0,                                        /* tp_del */
+#endif
+#if PY_VERSION_HEX >= 0x02060000
+  0,                                        /* tp_version */
+#endif
+#ifdef COUNT_ALLOCS
+  0,0,0,0                                   /* tp_alloc -> tp_next */
+#endif
+};
+
+SWIGINTERN int
+SwigPyObjectType_setattro(PyTypeObject *type, PyObject *name, PyObject *value) {
+  PyObject *attribute;
+  descrsetfunc local_set;
+  attribute = _PyType_Lookup(type, name);
+  if (attribute != NULL) {
+    /* Implement descriptor functionality, if any */
+    local_set = attribute->ob_type->tp_descr_set;
+    if (local_set != NULL)
+      return local_set(attribute, (PyObject *)type, value);
+#if PY_VERSION_HEX >= 0x03000000
+    PyErr_Format(PyExc_AttributeError, "cannot modify read-only attribute '%.50s.%.400S'", type->tp_name, name);
+#else 
+    PyErr_Format(PyExc_AttributeError, "cannot modify read-only attribute '%.50s.%.400s'", type->tp_name, PyString_AS_STRING(name));
+#endif
+  } else {
+#if PY_VERSION_HEX >= 0x03000000
+    PyErr_Format(PyExc_AttributeError, "type '%.50s' has no attribute '%.400S'", type->tp_name, name);
+#else
+    PyErr_Format(PyExc_AttributeError, "type '%.50s' has no attribute '%.400s'", type->tp_name, PyString_AS_STRING(name));
+#endif
+  }
+
+  return -1;
+}
+
+SWIGINTERN PyGetSetDescrObject *
+SwigPyStaticVar_new_getset(PyTypeObject *type, PyGetSetDef *getset) {
+  PyGetSetDescrObject *descr;
+  descr = (PyGetSetDescrObject *)PyType_GenericAlloc(&SwigPyStaticVar_Type, 0);
+  assert(descr);
+  Py_XINCREF(type);
+  descr->d_type = type;
+  descr->d_name = PyString_InternFromString(getset->name);
+  descr->d_getset = getset;
+  if (descr->d_name == NULL) {
+    Py_DECREF(descr);
+    descr = NULL;
+  }
+  return descr;
+}
+
+SWIGINTERN void
+SwigPyBuiltin_InitBases (PyTypeObject *type, PyTypeObject **bases) {
+  int base_count = 0;
+  PyTypeObject **b;
+  PyObject *tuple;
+  int i;
+
+  if (!bases[0]) {
+    bases[0] = SwigPyObject_type();
+    bases[1] = NULL;
+  }
+  type->tp_base = bases[0];
+  Py_INCREF((PyObject *)bases[0]);
+  for (b = bases; *b != NULL; ++b)
+    ++base_count;
+  tuple = PyTuple_New(base_count);
+  for (i = 0; i < base_count; ++i) {
+    PyTuple_SET_ITEM(tuple, i, (PyObject *)bases[i]);
+    Py_INCREF((PyObject *)bases[i]);
+  }
+  type->tp_bases = tuple;
+}
+
+SWIGINTERN PyObject *
+SwigPyBuiltin_ThisClosure (PyObject *self, void *SWIGUNUSEDPARM(closure)) {
+  PyObject *result;
+  result = (PyObject *)SWIG_Python_GetSwigThis(self);
+  Py_XINCREF(result);
+  return result;
+}
+
+SWIGINTERN void
+SwigPyBuiltin_SetMetaType (PyTypeObject *type, PyTypeObject *metatype)
+{
+#if PY_VERSION_HEX >= 0x03000000
+    type->ob_base.ob_base.ob_type = metatype;
+#else
+    type->ob_type = metatype;
+#endif
+}
+
+#ifdef __cplusplus
+}
+#endif

Lib/python/carrays.i

@@ -1,5 +1,49 @@
 %define %array_class(TYPE,NAME)
+#if defined(SWIGPYTHON_BUILTIN)
+  %feature("python:slot", "sq_item", functype="ssizeargfunc") NAME::__getitem__;
+  %feature("python:slot", "sq_ass_item", functype="ssizeobjargproc") NAME::__setitem__;
+
+%inline %{
+typedef struct NAME {
+    TYPE *el;
+} NAME;
+%}
+
+%extend NAME {
+
+  NAME(size_t nelements) {
+      NAME *arr = %new_instance(NAME);
+      arr->el = %new_array(nelements, TYPE);
+      return arr;
+  }
+
+  ~NAME() {
+      %delete_array(self->el);
+      %delete(self);
+  }
+  
+  TYPE __getitem__(size_t index) {
+      return self->el[index];
+  }
+
+  void __setitem__(size_t index, TYPE value) {
+      self->el[index] = value;
+  }
+
+  TYPE * cast() {
+      return self->el;
+  }
+
+  static NAME *frompointer(TYPE *t) {
+      return %reinterpret_cast(t, NAME *);
+  }
+};
+
+%types(NAME = TYPE);
+
+#else
   %array_class_wrap(TYPE,NAME,__getitem__,__setitem__)
+#endif
 %enddef
 
 %include <typemaps/carrays.swg>

Lib/python/director.swg

@@ -404,11 +404,11 @@ namespace Swig {
     }
 
     /* methods to implement pseudo protected director members */
-    virtual bool swig_get_inner(const char* /* protected_method_name */) const {
+    virtual bool swig_get_inner(const char* /* swig_protected_method_name */) const {
       return true;
     }
     
-    virtual void swig_set_inner(const char* /* protected_method_name */, bool /* val */) const {
+    virtual void swig_set_inner(const char* /* swig_protected_method_name */, bool /* swig_val */) const {
     }
 
   /* ownership management */
@@ -459,6 +459,18 @@ namespace Swig {
       }
       return own;
     }
+
+    template <typename Type>
+    static PyObject* swig_pyobj_disown(PyObject *pyobj, PyObject *SWIGUNUSEDPARM(args))
+    {
+      SwigPyObject *sobj = (SwigPyObject *)pyobj;
+      sobj->own = 0;
+      Director *d = SWIG_DIRECTOR_CAST(reinterpret_cast<Type *>(sobj->ptr));
+      if (d)
+        d->swig_disown();
+      return PyWeakref_NewProxy(pyobj, NULL);
+    }
+
   };
 
 #ifdef __THREAD__

Lib/python/pyapi.swg

@@ -4,9 +4,6 @@
 
 #ifdef __cplusplus
 extern "C" {
-#if 0
-} /* cc-mode */
-#endif
 #endif
 
 /* -----------------------------------------------------------------------------
@@ -32,19 +29,19 @@ typedef struct swig_const_info {
  * Wrapper of PyInstanceMethod_New() used in Python 3
  * It is exported to the generated module, used for -fastproxy
  * ----------------------------------------------------------------------------- */
-SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *self, PyObject *func)
-{
 #if PY_VERSION_HEX >= 0x03000000
+SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func)
+{
   return PyInstanceMethod_New(func);
-#else
-  return NULL;
-#endif
 }
+#else
+SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *SWIGUNUSEDPARM(func))
+{
+  return NULL;
+}
+#endif
 
 #ifdef __cplusplus
-#if 0
-{ /* cc-mode */
-#endif
 }
 #endif
 

Lib/python/pyclasses.swg

@@ -43,6 +43,9 @@ namespace swig {
   %apply PyObject * {SwigPtr_PyObject};
   %apply PyObject * const& {SwigPtr_PyObject const&};
 
+  %typemap(typecheck,precedence=SWIG_TYPECHECK_SWIGOBJECT,noblock=1) SwigPtr_PyObject const& "$1 = ($input != 0);";
+
+
   /* For output */
   %typemap(out,noblock=1)  SwigPtr_PyObject {
     $result = (PyObject *)$1;

Lib/python/pycontainer.swg

@@ -4,8 +4,7 @@
  * Python sequence <-> C++ container wrapper
  *
  * This wrapper, and its iterator, allows a general use (and reuse) of
- * the the mapping between C++ and Python, thanks to the C++
- * templates.
+ * the mapping between C++ and Python, thanks to the C++ templates.
  *
  * Of course, it needs the C++ compiler to support templates, but
  * since we will use this wrapper with the STL containers, that should
@@ -14,6 +13,12 @@
 
 %{
 #include <iostream>
+
+#if PY_VERSION_HEX >= 0x03020000
+# define SWIGPY_SLICE_ARG(obj) ((PyObject*) (obj))
+#else
+# define SWIGPY_SLICE_ARG(obj) ((PySliceObject*) (obj))
+#endif
 %}
 
 
@@ -246,7 +251,7 @@ namespace swig {
 
   template <class Sequence, class Difference, class InputSeq>
   inline void
-  setslice(Sequence* self, Difference i, Difference j, const InputSeq& v) {
+  setslice(Sequence* self, Difference i, Difference j, const InputSeq& v = InputSeq()) {
     typename Sequence::size_type size = self->size();
     typename Sequence::size_type ii = swig::check_index(i, size, true);
     typename Sequence::size_type jj = swig::slice_index(j, size);
@@ -587,19 +592,28 @@ namespace swig
       return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
     }
 
-    %pythoncode {def __iter__(self): return self.iterator()}
+#if defined(SWIGPYTHON_BUILTIN)
+  %feature("python:slot", "tp_iter", functype="getiterfunc") iterator;
+#else
+  %pythoncode {def __iter__(self): return self.iterator()}
+#endif
   }
+
 #endif //SWIG_EXPORT_ITERATOR_METHODS
 %enddef
 
 
 /**** The python container methods  ****/
 
-
 %define %swig_container_methods(Container...)
 
   %newobject __getslice__;
 
+#if defined(SWIGPYTHON_BUILTIN)
+  %feature("python:slot", "nb_nonzero", functype="inquiry") __nonzero__;
+  %feature("python:slot", "sq_length", functype="lenfunc") __len__;
+#endif // SWIGPYTHON_BUILTIN
+
   %extend {
     bool __nonzero__() const {
       return !(self->empty());
@@ -614,14 +628,26 @@ namespace swig
       return self->size();
     }
   }
+
 %enddef
 
+
+
 %define %swig_sequence_methods_common(Sequence...)
   %swig_sequence_iterator(%arg(Sequence))
   %swig_container_methods(%arg(Sequence))
   
   %fragment("SwigPySequence_Base");
 
+#if defined(SWIGPYTHON_BUILTIN)
+  //%feature("python:slot", "sq_item", functype="ssizeargfunc") __getitem__;
+  //%feature("python:slot", "sq_slice", functype="ssizessizeargfunc") __getslice__;
+  //%feature("python:slot", "sq_ass_item", functype="ssizeobjargproc") __setitem__;
+  //%feature("python:slot", "sq_ass_slice", functype="ssizessizeobjargproc") __setslice__;
+  %feature("python:slot", "mp_subscript", functype="binaryfunc") __getitem__;
+  %feature("python:slot", "mp_ass_subscript", functype="objobjargproc") __setitem__;
+#endif // SWIGPYTHON_BUILTIN
+
   %extend {
     value_type pop() throw (std::out_of_range) {
       if (self->size() == 0)
@@ -633,6 +659,9 @@ namespace swig
 
     /* typemap for slice object support */
     %typemap(in) PySliceObject* {
+      if (!PySlice_Check($input)) {
+        %argument_fail(SWIG_TypeError, "$type", $symname, $argnum);
+      }
       $1 = (PySliceObject *) $input;
     }
     %typemap(typecheck,precedence=SWIG_TYPECHECK_POINTER) PySliceObject* {
@@ -643,7 +672,7 @@ namespace swig
       return swig::getslice(self, i, j);
     }
 
-    void __setslice__(difference_type i, difference_type j, const Sequence& v) 
+    void __setslice__(difference_type i, difference_type j, const Sequence& v = Sequence()) 
       throw (std::out_of_range, std::invalid_argument) {
       swig::setslice(self, i, j, v);
     }
@@ -666,7 +695,7 @@ namespace swig
         SWIG_Error(SWIG_TypeError, "Slice object expected.");
         return NULL;
       }
-      PySlice_GetIndices(slice, self->size(), &i, &j, &step);
+      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), self->size(), &i, &j, &step);
       return swig::getslice(self, i, j);
     }
 
@@ -677,10 +706,21 @@ namespace swig
         SWIG_Error(SWIG_TypeError, "Slice object expected.");
         return;
       }
-      PySlice_GetIndices(slice, self->size(), &i, &j, &step);
+      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), self->size(), &i, &j, &step);
       swig::setslice(self, i, j, v);
     }
 
+    void __setitem__(PySliceObject *slice)
+      throw (std::out_of_range) {
+      Py_ssize_t i, j, step;
+      if( !PySlice_Check(slice) ) {
+        SWIG_Error(SWIG_TypeError, "Slice object expected.");
+        return;
+      }
+      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), self->size(), &i, &j, &step);
+      swig::delslice(self, i,j);
+    }
+
     void __delitem__(PySliceObject *slice)
       throw (std::out_of_range) {
       Py_ssize_t i, j, step;
@@ -688,11 +728,12 @@ namespace swig
         SWIG_Error(SWIG_TypeError, "Slice object expected.");
         return;
       }
-      PySlice_GetIndices(slice, self->size(), &i, &j, &step);
+      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), self->size(), &i, &j, &step);
       swig::delslice(self, i,j);
     }
      
   }
+
 %enddef
 
 %define %swig_sequence_methods(Sequence...)
@@ -710,6 +751,7 @@ namespace swig
       self->push_back(x);
     }
  }
+
 %enddef
 
 %define %swig_sequence_methods_val(Sequence...)
@@ -727,6 +769,7 @@ namespace swig
       self->push_back(x);
     }
  }
+
 %enddef
 
 

Lib/python/pyhead.swg

@@ -5,7 +5,15 @@
 #define PyInt_Check(x) PyLong_Check(x)
 #define PyInt_AsLong(x) PyLong_AsLong(x)
 #define PyInt_FromLong(x) PyLong_FromLong(x)
+#define PyString_Check(name) PyBytes_Check(name)
+#define PyString_FromString(x) PyUnicode_FromString(x)
 #define PyString_Format(fmt, args)  PyUnicode_Format(fmt, args)
+#define PyString_AsString(str) PyBytes_AsString(str)
+#define PyString_Size(str) PyBytes_Size(str)	
+#define PyString_InternFromString(key) PyUnicode_InternFromString(key)
+#define Py_TPFLAGS_HAVE_CLASS Py_TPFLAGS_BASETYPE
+#define PyString_AS_STRING(x) PyUnicode_AS_STRING(x)
+#define _PyLong_FromSsize_t(x) PyLong_FromSsize_t(x)
 
 #endif
 
@@ -145,4 +153,56 @@ PyObject *PyBool_FromLong(long ok)
 typedef int Py_ssize_t;
 # define PY_SSIZE_T_MAX INT_MAX
 # define PY_SSIZE_T_MIN INT_MIN
+typedef inquiry lenfunc;
+typedef intargfunc ssizeargfunc;
+typedef intintargfunc ssizessizeargfunc;
+typedef intobjargproc ssizeobjargproc;
+typedef intintobjargproc ssizessizeobjargproc;
+typedef getreadbufferproc readbufferproc;
+typedef getwritebufferproc writebufferproc;
+typedef getsegcountproc segcountproc;
+typedef getcharbufferproc charbufferproc;
+static long PyNumber_AsSsize_t (PyObject *x, void *SWIGUNUSEDPARM(exc))
+{
+  long result = 0;
+  PyObject *i = PyNumber_Int(x);
+  if (i) {
+    result = PyInt_AsLong(i);
+    Py_DECREF(i);
+  }
+  return result;
+}
+#endif
+
+#if PY_VERSION_HEX < 0x02040000
+#define Py_VISIT(op)				\
+  do { 						\
+    if (op) {					\
+      int vret = visit((op), arg);		\
+      if (vret)					\
+        return vret;				\
+    }						\
+  } while (0)
+#endif
+
+#if PY_VERSION_HEX < 0x02030000
+typedef struct {
+  PyTypeObject type;
+  PyNumberMethods as_number;
+  PyMappingMethods as_mapping;
+  PySequenceMethods as_sequence;
+  PyBufferProcs as_buffer;
+  PyObject *name, *slots;
+} PyHeapTypeObject;
+#endif
+
+#if PY_VERSION_HEX < 0x02030000
+typedef destructor freefunc;
+#endif
+
+#if ((PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION > 6) || \
+     (PY_MAJOR_VERSION == 3 && PY_MINOR_VERSION > 0) || \
+     (PY_MAJOR_VERSION > 3))
+# define SWIGPY_USE_CAPSULE
+# define SWIGPY_CAPSULE_NAME ((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION ".type_pointer_capsule" SWIG_TYPE_TABLE_NAME)
 #endif

Lib/python/pyinit.swg

@@ -138,24 +138,23 @@ SWIGINTERN PyTypeObject*
 swig_varlink_type(void) {
   static char varlink__doc__[] = "Swig var link object";
   static PyTypeObject varlink_type;
-  static int type_init = 0;  
+  static int type_init = 0;
   if (!type_init) {
-    const PyTypeObject tmp
-      = {
+    const PyTypeObject tmp = {
       /* PyObject header changed in Python 3 */
 #if PY_VERSION_HEX >= 0x03000000
       PyVarObject_HEAD_INIT(&PyType_Type, 0)
 #else
       PyObject_HEAD_INIT(NULL)
-      0,                                  /* Number of items in variable part (ob_size) */
+      0,                                  /* ob_size */
 #endif
-      (char *)"swigvarlink",              /* Type name (tp_name) */
-      sizeof(swig_varlinkobject),         /* Basic size (tp_basicsize) */
-      0,                                  /* Itemsize (tp_itemsize) */
-      (destructor) swig_varlink_dealloc,  /* Deallocator (tp_dealloc) */ 
-      (printfunc) swig_varlink_print,     /* Print (tp_print) */
-      (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
-      (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
+      (char *)"swigvarlink",              /* tp_name */
+      sizeof(swig_varlinkobject),         /* tp_basicsize */
+      0,                                  /* tp_itemsize */
+      (destructor) swig_varlink_dealloc,  /* tp_dealloc */
+      (printfunc) swig_varlink_print,     /* tp_print */
+      (getattrfunc) swig_varlink_getattr, /* tp_getattr */
+      (setattrfunc) swig_varlink_setattr, /* tp_setattr */
       0,                                  /* tp_compare */
       (reprfunc) swig_varlink_repr,       /* tp_repr */
       0,                                  /* tp_as_number */
@@ -179,6 +178,9 @@ swig_varlink_type(void) {
 #if PY_VERSION_HEX >= 0x02030000
       0,                                  /* tp_del */
 #endif
+#if PY_VERSION_HEX >= 0x02060000
+      0,                                  /* tp_version */
+#endif
 #ifdef COUNT_ALLOCS
       0,0,0,0                             /* tp_alloc -> tp_next */
 #endif
@@ -239,7 +241,7 @@ SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
   for (i = 0; constants[i].type; ++i) {
     switch(constants[i].type) {
     case SWIG_PY_POINTER:
-      obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
+      obj = SWIG_InternalNewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
       break;
     case SWIG_PY_BINARY:
       obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
@@ -320,7 +322,7 @@ SWIGEXPORT
   void
 #endif
 SWIG_init(void) {
-  PyObject *m, *d;  
+  PyObject *m, *d, *md;
 #if PY_VERSION_HEX >= 0x03000000
   static struct PyModuleDef SWIG_module = {
     PyModuleDef_HEAD_INIT,
@@ -335,6 +337,47 @@ SWIG_init(void) {
   };
 #endif
 
+#if defined(SWIGPYTHON_BUILTIN)
+  static SwigPyClientData SwigPyObject_clientdata = {0, 0, 0, 0, 0, 0, 0};
+  static PyGetSetDef this_getset_def = {
+    (char *)"this", &SwigPyBuiltin_ThisClosure, NULL, NULL, NULL
+  };
+  static SwigPyGetSet thisown_getset_closure = {
+    (PyCFunction) SwigPyObject_own,
+    (PyCFunction) SwigPyObject_own
+  };
+  static PyGetSetDef thisown_getset_def = {
+    (char *)"thisown", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, NULL, &thisown_getset_closure
+  };
+  PyObject *metatype_args;
+  PyTypeObject *builtin_pytype;
+  int builtin_base_count;
+  swig_type_info *builtin_basetype;
+  PyObject *tuple;
+  PyGetSetDescrObject *static_getset;
+  PyTypeObject *metatype;
+  SwigPyClientData *cd;
+  PyObject *public_interface, *public_symbol;
+  PyObject *this_descr;
+  PyObject *thisown_descr;
+  int i;
+
+  (void)builtin_pytype;
+  (void)builtin_base_count;
+  (void)builtin_basetype;
+  (void)tuple;
+  (void)static_getset;
+
+  /* metatype is used to implement static member variables. */
+  metatype_args = Py_BuildValue("(s(O){})", "SwigPyObjectType", &PyType_Type);
+  assert(metatype_args);
+  metatype = (PyTypeObject *) PyType_Type.tp_call((PyObject *) &PyType_Type, metatype_args, NULL);
+  assert(metatype);
+  Py_DECREF(metatype_args);
+  metatype->tp_setattro = (setattrofunc) &SwigPyObjectType_setattro;
+  assert(PyType_Ready(metatype) >= 0);
+#endif
+
   /* Fix SwigMethods to carry the callback ptrs when needed */
   SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
 
@@ -343,10 +386,46 @@ SWIG_init(void) {
 #else
   m = Py_InitModule((char *) SWIG_name, SwigMethods);
 #endif
-  d = PyModule_GetDict(m);
-  
+  md = d = PyModule_GetDict(m);
+
   SWIG_InitializeModule(0);
+
+#ifdef SWIGPYTHON_BUILTIN
+  SwigPyObject_stype = SWIG_MangledTypeQuery("_p_SwigPyObject");
+  assert(SwigPyObject_stype);
+  cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
+  if (!cd) {
+    SwigPyObject_stype->clientdata = &SwigPyObject_clientdata;
+    SwigPyObject_clientdata.pytype = SwigPyObject_TypeOnce();
+  } else if (SwigPyObject_TypeOnce()->tp_basicsize != cd->pytype->tp_basicsize) {
+    PyErr_SetString(PyExc_RuntimeError, "Import error: attempted to load two incompatible swig-generated modules.");
+# if PY_VERSION_HEX >= 0x03000000
+    return NULL;
+# else
+    return;
+# endif
+  }
+
+  /* All objects have a 'this' attribute */
+  this_descr = PyDescr_NewGetSet(SwigPyObject_type(), &this_getset_def);
+  (void)this_descr;
+
+  /* All objects have a 'thisown' attribute */
+  thisown_descr = PyDescr_NewGetSet(SwigPyObject_type(), &thisown_getset_def);
+  (void)thisown_descr;
+
+  public_interface = PyList_New(0);
+  public_symbol = 0;
+  (void)public_symbol;
+
+  PyDict_SetItemString(md, "__all__", public_interface);
+  Py_DECREF(public_interface);
+  for (i = 0; SwigMethods[i].ml_name != NULL; ++i)
+    SwigPyBuiltin_AddPublicSymbol(public_interface, SwigMethods[i].ml_name);
+  for (i = 0; swig_const_table[i].name != 0; ++i)
+    SwigPyBuiltin_AddPublicSymbol(public_interface, swig_const_table[i].name);
+#endif
+
   SWIG_InstallConstants(d,swig_const_table);
-  
 %}
 

Lib/python/pyiterators.swg

@@ -128,6 +128,14 @@ namespace swig {
       return desc;
     }    
   };
+
+%#if defined(SWIGPYTHON_BUILTIN)
+  inline PyObject* make_output_iterator_builtin (PyObject *pyself)
+  {
+    Py_INCREF(pyself);
+    return pyself;
+  }
+%#endif
 }
 }
 
@@ -302,6 +310,7 @@ namespace swig {
   {
     return new SwigPyIteratorOpen_T<OutIter>(current, seq);
   }
+
 }
 }
 
@@ -329,9 +338,15 @@ namespace swig
   %newobject SwigPyIterator::operator - (ptrdiff_t n) const;
 
   %nodirector SwigPyIterator;
+
+#if defined(SWIGPYTHON_BUILTIN)
+  %feature("python:tp_iter") SwigPyIterator "&swig::make_output_iterator_builtin";
+  %feature("python:slot", "tp_iternext", functype="iternextfunc") SwigPyIterator::__next__;
+#else
   %extend SwigPyIterator {
   %pythoncode {def __iter__(self): return self}
   }
+#endif
 
   %catches(swig::stop_iteration) SwigPyIterator::value() const;
   %catches(swig::stop_iteration) SwigPyIterator::incr(size_t n = 1);
@@ -347,7 +362,6 @@ namespace swig
   %catches(swig::stop_iteration) SwigPyIterator::operator + (ptrdiff_t n) const;
   %catches(swig::stop_iteration) SwigPyIterator::operator - (ptrdiff_t n) const;
 
-
   struct SwigPyIterator
   {
   protected:

Lib/python/pyopers.swg

@@ -1,45 +1,140 @@
 /* ------------------------------------------------------------
  * Overloaded operator support
+
+ The directives in this file apply whether or not you use the
+ -builtin option to SWIG, but operator overloads are particularly
+ attractive when using -builtin, because they are much faster
+ than named methods.
+
+ If you're using the -builtin option to SWIG, and you want to define
+ python operator overloads beyond the defaults defined in this file,
+ here's what you need to know:
+
+ There are two ways to define a python slot function: dispatch to a
+ statically defined function; or dispatch to a method defined on the
+ operand.
+
+ To dispatch to a statically defined function, use %feature("python:<slot>"),
+ where <slot> is the name of a field in a PyTypeObject, PyNumberMethods,
+ PyMappingMethods, PySequenceMethods, or PyBufferProcs.  For example:
+
+   %{
+   
+   static long myHashFunc (PyObject *pyobj) {
+     MyClass *cobj;
+     // Convert pyobj to cobj
+     return (cobj->field1 * (cobj->field2 << 7));
+   }
+   
+   %}
+
+   %feature("python:tp_hash") MyClass "myHashFunc";
+
+ NOTE: It is the responsibility of the programmer (that's you) to ensure
+ that a statically defined slot function has the correct signature.
+
+ If, instead, you want to dispatch to an instance method, you can
+ use %feature("python:slot").  For example:
+
+   class MyClass {
+     public:
+       long myHashFunc () const;
+       ...
+   };
+   
+   %feature("python:slot", "tp_hash", functype="hashfunc") MyClass::myHashFunc;
+
+ NOTE: Some python slots use a method signature which does not
+ match the signature of SWIG-wrapped methods.  For those slots,
+ SWIG will automatically generate a "closure" function to re-marshall
+ the arguments before dispatching to the wrapped method.  Setting
+ the "functype" attribute of the feature enables SWIG to generate
+ a correct closure function.
+
+ --------------------------------------------------------------
+
+ The tp_richcompare slot is a special case: SWIG automatically generates
+ a rich compare function for all wrapped types.  If a type defines C++
+ operator overloads for comparison (operator==, operator<, etc.), they
+ will be called from the generated rich compare function.  If you
+ want to explicitly choose a method to handle a certain comparison
+ operation, you may use %feature("python:slot") like this:
+
+   class MyClass {
+     public:
+       bool lessThan (const MyClass& x) const;
+       ...
+   };
+   
+   %feature("python:slot", "Py_LT") MyClass::lessThan;
+
+ ... where "Py_LT" is one of the rich comparison opcodes defined in the
+ python header file object.h.
+
+ If there's no method defined to handle a particular comparsion operation,
+ the default behavior is to compare pointer values of the wrapped
+ C++ objects.
+
+ --------------------------------------------------------------
+
+
+ For more information about python slots, including their names and
+ signatures, you may refer to the python documentation :
+
+   http://docs.python.org/c-api/typeobj.html
+
  * ------------------------------------------------------------ */
 
 
 #ifdef __cplusplus
 
-#define %pybinoperator(pyname,oper) %rename(pyname) oper; %pythonmaybecall oper
-
-%pybinoperator(__add__,      *::operator+);
-%pybinoperator(__pos__,      *::operator+());
-%pybinoperator(__pos__,      *::operator+() const);
-%pybinoperator(__sub__,      *::operator-);
-%pybinoperator(__neg__,      *::operator-());
-%pybinoperator(__neg__,      *::operator-() const);
-%pybinoperator(__mul__,      *::operator*);
-%pybinoperator(__div__,      *::operator/);
-%pybinoperator(__mod__,      *::operator%);
-%pybinoperator(__lshift__,   *::operator<<);
-%pybinoperator(__rshift__,   *::operator>>);
-%pybinoperator(__and__,      *::operator&);
-%pybinoperator(__or__,       *::operator|);
-%pybinoperator(__xor__,      *::operator^);
-%pybinoperator(__lt__,       *::operator<);
-%pybinoperator(__le__,       *::operator<=);
-%pybinoperator(__gt__,       *::operator>);
-%pybinoperator(__ge__,       *::operator>=);
-%pybinoperator(__eq__,       *::operator==);
-%pybinoperator(__ne__,       *::operator!=);
+#if defined(SWIGPYTHON_BUILTIN)
+#define %pybinoperator(pyname,oper,functp,slt) %rename(pyname) oper; %pythonmaybecall oper; %feature("python:slot", #slt, functype=#functp) oper; %feature("python:slot", #slt, functype=#functp) pyname;
+#define %pycompare(pyname,oper,comptype) %rename(pyname) oper; %pythonmaybecall oper; %feature("python:compare", #comptype) oper; %feature("python:compare", #comptype) pyname;
+#else
+#define %pybinoperator(pyname,oper,functp,slt) %rename(pyname) oper; %pythonmaybecall oper
+#define %pycompare(pyname,oper,comptype) %pybinoperator(pyname,oper,,comptype)
+#endif
 
+%pybinoperator(__add__,      *::operator+,		binaryfunc, nb_add);
+%pybinoperator(__pos__,      *::operator+(),		unaryfunc, nb_positive);
+%pybinoperator(__pos__,      *::operator+() const,	unaryfunc, nb_positive);
+%pybinoperator(__sub__,      *::operator-,		binaryfunc, nb_subtract);
+%pybinoperator(__neg__,      *::operator-(),		unaryfunc, nb_negative);
+%pybinoperator(__neg__,      *::operator-() const,	unaryfunc, nb_negative);
+%pybinoperator(__mul__,      *::operator*,		binaryfunc, nb_multiply);
+%pybinoperator(__div__,      *::operator/,		binaryfunc, nb_div);
+%pybinoperator(__mod__,      *::operator%,		binaryfunc, nb_remainder);
+%pybinoperator(__lshift__,   *::operator<<,		binaryfunc, nb_lshift);
+%pybinoperator(__rshift__,   *::operator>>,		binaryfunc, nb_rshift);
+%pybinoperator(__and__,      *::operator&,		binaryfunc, nb_and);
+%pybinoperator(__or__,       *::operator|,		binaryfunc, nb_or);
+%pybinoperator(__xor__,      *::operator^,		binaryfunc, nb_xor);
+%pycompare(__lt__,           *::operator<,		Py_LT);
+%pycompare(__le__,           *::operator<=,		Py_LE);
+%pycompare(__gt__,           *::operator>,		Py_GT);
+%pycompare(__ge__,           *::operator>=,		Py_GE);
+%pycompare(__eq__,           *::operator==,		Py_EQ);
+%pycompare(__ne__,           *::operator!=,		Py_NE);
 
+%feature("python:slot", "nb_truediv", functype="binaryfunc") *::operator/;
 
 /* Special cases */
 %rename(__invert__)     *::operator~;
+%feature("python:slot", "nb_invert", functype="unaryfunc") *::operator~;
 %rename(__call__)       *::operator();
+%feature("python:slot", "tp_call", functype="ternaryfunc") *::operator();
 
+#if defined(SWIGPYTHON_BUILTIN)
+%pybinoperator(__nonzero__,   *::operator bool,		inquiry, nb_nonzero);
+#else
 %feature("shadow")      *::operator bool %{
 def __nonzero__(self):
     return $action(self)
 __bool__ = __nonzero__
 %};
 %rename(__nonzero__)    *::operator bool;
+#endif
 
 /* Ignored operators */
 %ignoreoperator(LNOT)       operator!;
@@ -90,18 +185,22 @@ __bool__ = __nonzero__
 
 */
 
-#define %pyinplaceoper(SwigPyOper, Oper) %delobject Oper; %newobject Oper; %rename(SwigPyOper) Oper
+#if defined(SWIGPYTHON_BUILTIN)
+#define %pyinplaceoper(SwigPyOper, Oper, functp, slt) %delobject Oper; %newobject Oper; %feature("python:slot", #slt, functype=#functp) Oper; %rename(SwigPyOper) Oper
+#else
+#define %pyinplaceoper(SwigPyOper, Oper, functp, slt) %delobject Oper; %newobject Oper; %rename(SwigPyOper) Oper
+#endif
 
-%pyinplaceoper(__iadd__   , *::operator +=);
-%pyinplaceoper(__isub__   , *::operator -=);
-%pyinplaceoper(__imul__   , *::operator *=);
-%pyinplaceoper(__idiv__   , *::operator /=);
-%pyinplaceoper(__imod__   , *::operator %=);
-%pyinplaceoper(__iand__   , *::operator &=);
-%pyinplaceoper(__ior__    , *::operator |=);
-%pyinplaceoper(__ixor__   , *::operator ^=);
-%pyinplaceoper(__ilshift__, *::operator <<=);
-%pyinplaceoper(__irshift__, *::operator >>=);
+%pyinplaceoper(__iadd__   , *::operator +=,	binaryfunc, nb_inplace_add);
+%pyinplaceoper(__isub__   , *::operator -=,	binaryfunc, nb_inplace_subtract);
+%pyinplaceoper(__imul__   , *::operator *=,	binaryfunc, nb_inplace_multiply);
+%pyinplaceoper(__idiv__   , *::operator /=,	binaryfunc, nb_inplace_divide);
+%pyinplaceoper(__imod__   , *::operator %=,	binaryfunc, nb_inplace_remainder);
+%pyinplaceoper(__iand__   , *::operator &=,	binaryfunc, nb_inplace_and);
+%pyinplaceoper(__ior__    , *::operator |=,	binaryfunc, nb_inplace_or);
+%pyinplaceoper(__ixor__   , *::operator ^=,	binaryfunc, nb_inplace_xor);
+%pyinplaceoper(__ilshift__, *::operator <<=,	binaryfunc, nb_inplace_lshift);
+%pyinplaceoper(__irshift__, *::operator >>=,	binaryfunc, nb_inplace_rshift);
 
 
 /* Finally, in python we need to mark the binary operations to fail as

Lib/python/pyruntime.swg

@@ -11,3 +11,6 @@
 %insert(runtime) "pyapi.swg";           /* Python API */
 %insert(runtime) "pyrun.swg";           /* Python run-time code */
 
+#if defined(SWIGPYTHON_BUILTIN)
+%insert(runtime) "builtin.swg";		/* Specialization for classes with single inheritance */
+#endif

Lib/python/pystdcommon.swg

@@ -6,7 +6,7 @@ namespace swig {
   */
   template <class Type> struct traits_from_ptr {
     static PyObject *from(Type *val, int owner = 0) {
-      return SWIG_NewPointerObj(val, type_info<Type>(), owner);
+      return SWIG_InternalNewPointerObj(val, type_info<Type>(), owner);
     }
   };
 

Lib/python/pystrings.swg

@@ -86,7 +86,7 @@ SWIG_FromCharPtrAndSize(const char* carray, size_t size)
     if (size > INT_MAX) {
       swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
       return pchar_descriptor ? 
-	SWIG_NewPointerObj(%const_cast(carray,char *), pchar_descriptor, 0) : SWIG_Py_Void();
+	SWIG_InternalNewPointerObj(%const_cast(carray,char *), pchar_descriptor, 0) : SWIG_Py_Void();
     } else {
 %#if PY_VERSION_HEX >= 0x03000000
       return PyUnicode_FromStringAndSize(carray, %numeric_cast(size,int));

Lib/python/pythonkw.swg

@@ -124,7 +124,8 @@ PYTHONBN(zip);
 */
 PYTHONBN(True);
 PYTHONBN(False);
-PYTHONBN(None);
+
+PYTHONKW(None);
 
 
 /* 

Lib/python/pytypemaps.swg

@@ -51,7 +51,11 @@
 #define SWIG_AppendOutput(result, obj)  SWIG_Python_AppendOutput(result, obj)
 
 /* set constant */
-#define SWIG_SetConstant(name, obj)     SWIG_Python_SetConstant(d, name,obj) 
+#if defined(SWIGPYTHON_BUILTIN)
+#define SWIG_SetConstant(name, obj) SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, name,obj) 
+#else
+#define SWIG_SetConstant(name, obj) SWIG_Python_SetConstant(d, name,obj) 
+#endif
 
 /* raise */
 #define SWIG_Raise(obj, type, desc)     SWIG_Python_Raise(obj, type, desc)
@@ -95,4 +99,3 @@
   }
 }
 
-

Lib/python/pywstrings.swg

@@ -2,6 +2,14 @@
  *  utility methods for wchar_t strings 
  * ------------------------------------------------------------ */
 
+%{
+#if PY_VERSION_HEX >= 0x03020000
+# define SWIGPY_UNICODE_ARG(obj) ((PyObject*) (obj))
+#else
+# define SWIGPY_UNICODE_ARG(obj) ((PyUnicodeObject*) (obj))
+#endif
+%}
+
 %fragment("SWIG_AsWCharPtrAndSize","header",fragment="<wchar.h>",fragment="SWIG_pwchar_descriptor") {
 SWIGINTERN int
 SWIG_AsWCharPtrAndSize(PyObject *obj, wchar_t **cptr, size_t *psize, int *alloc)
@@ -20,7 +28,7 @@ SWIG_AsWCharPtrAndSize(PyObject *obj, wchar_t **cptr, size_t *psize, int *alloc)
     Py_ssize_t len = PyUnicode_GetSize(obj);
     if (cptr) {
       *cptr = %new_array(len + 1, wchar_t);
-      PyUnicode_AsWideChar((PyUnicodeObject *)obj, *cptr, len);
+      PyUnicode_AsWideChar(SWIGPY_UNICODE_ARG(obj), *cptr, len);
       (*cptr)[len] = 0;
     }
     if (psize) *psize = (size_t) len + 1;
@@ -50,7 +58,7 @@ SWIG_FromWCharPtrAndSize(const wchar_t * carray, size_t size)
     if (size > INT_MAX) {
       swig_type_info* pwchar_descriptor = SWIG_pwchar_descriptor();
       return pwchar_descriptor ? 
-	SWIG_NewPointerObj(%const_cast(carray,wchar_t *), pwchar_descriptor, 0) : SWIG_Py_Void();
+	SWIG_InternalNewPointerObj(%const_cast(carray,wchar_t *), pwchar_descriptor, 0) : SWIG_Py_Void();
     } else {
       return PyUnicode_FromWideChar(carray, %numeric_cast(size,int));
     }

Lib/python/std_map.i

@@ -43,29 +43,33 @@
       typedef std::map<K,T> map_type;
       typedef typename map_type::const_iterator const_iterator;
       typedef typename map_type::size_type size_type;
-            
+
+      static PyObject *asdict(const map_type& map) {
+	SWIG_PYTHON_THREAD_BEGIN_BLOCK;
+	size_type size = map.size();
+	int pysize = (size <= (size_type) INT_MAX) ? (int) size : -1;
+	if (pysize < 0) {
+	  PyErr_SetString(PyExc_OverflowError,
+			  "map size not valid in python");
+	  SWIG_PYTHON_THREAD_END_BLOCK;
+	  return NULL;
+	}
+	PyObject *obj = PyDict_New();
+	for (const_iterator i= map.begin(); i!= map.end(); ++i) {
+	  swig::SwigVar_PyObject key = swig::from(i->first);
+	  swig::SwigVar_PyObject val = swig::from(i->second);
+	  PyDict_SetItem(obj, key, val);
+	}
+	SWIG_PYTHON_THREAD_END_BLOCK;
+	return obj;
+      }
+                
       static PyObject *from(const map_type& map) {
 	swig_type_info *desc = swig::type_info<map_type>();
 	if (desc && desc->clientdata) {
-	  return SWIG_NewPointerObj(new map_type(map), desc, SWIG_POINTER_OWN);
+	  return SWIG_InternalNewPointerObj(new map_type(map), desc, SWIG_POINTER_OWN);
 	} else {
-	  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
-	  size_type size = map.size();
-	  int pysize = (size <= (size_type) INT_MAX) ? (int) size : -1;
-	  if (pysize < 0) {
-	    PyErr_SetString(PyExc_OverflowError,
-			    "map size not valid in python");
-	    SWIG_PYTHON_THREAD_END_BLOCK;
-	    return NULL;
-	  }
-	  PyObject *obj = PyDict_New();
-	  for (const_iterator i= map.begin(); i!= map.end(); ++i) {
-	    swig::SwigVar_PyObject key = swig::from(i->first);
-	    swig::SwigVar_PyObject val = swig::from(i->second);
-	    PyDict_SetItem(obj, key, val);
-	  }
-	  SWIG_PYTHON_THREAD_END_BLOCK;
-	  return obj;
+	  return asdict(map);
 	}
       }
     };
@@ -136,6 +140,7 @@
     {
       return new SwigPyMapValueITerator_T<OutIter>(current, begin, end, seq);
     }
+
   }
 }
 
@@ -143,15 +148,50 @@
   %swig_sequence_iterator(Map);
   %swig_container_methods(Map)
 
+#if defined(SWIGPYTHON_BUILTIN)
+  %feature("python:slot", "mp_length", functype="lenfunc") __len__;
+  %feature("python:slot", "mp_subscript", functype="binaryfunc") __getitem__;
+  %feature("python:slot", "tp_iter", functype="getiterfunc") key_iterator;
+
   %extend {
-    mapped_type __getitem__(const key_type& key) const throw (std::out_of_range) {
+    %newobject iterkeys(PyObject **PYTHON_SELF);
+    swig::SwigPyIterator* iterkeys(PyObject **PYTHON_SELF) {
+      return swig::make_output_key_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
+    }
+      
+    %newobject itervalues(PyObject **PYTHON_SELF);
+    swig::SwigPyIterator* itervalues(PyObject **PYTHON_SELF) {
+      return swig::make_output_value_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
+    }
+
+    %newobject iteritems(PyObject **PYTHON_SELF);
+    swig::SwigPyIterator* iteritems(PyObject **PYTHON_SELF) {
+      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
+    }
+
+    PyObject* asdict() {
+      return swig::traits_from< Map >::asdict(*self);
+    }
+  }
+
+#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()}
+  }
+#endif
+
+  %extend {
+    mapped_type const & __getitem__(const key_type& key) throw (std::out_of_range) {
       Map::const_iterator i = self->find(key);
       if (i != self->end())
 	return i->second;
       else
 	throw std::out_of_range("key not found");
     }
-    
+
     void __delitem__(const key_type& key) throw (std::out_of_range) {
       Map::iterator i = self->find(key);
       if (i != self->end())
@@ -236,21 +276,30 @@
     swig::SwigPyIterator* value_iterator(PyObject **PYTHON_SELF) {
       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()}
   }
+
 %enddef
 
 %define %swig_map_methods(Map...)
   %swig_map_common(Map)
+
+#if defined(SWIGPYTHON_BUILTIN)
+  %feature("python:slot", "mp_ass_subscript", functype="objobjargproc") __setitem__;
+#endif
+
+  %extend {
+    // This will be called through the mp_ass_subscript slot to delete an entry.
+    void __setitem__(const key_type& key) {
+      self->erase(key);
+    }
+  }
+
   %extend {
     void __setitem__(const key_type& key, const mapped_type& x) throw (std::out_of_range) {
       (*self)[key] = x;
     }
   }
+
 %enddef
 
 

Lib/python/std_multimap.i

@@ -42,7 +42,7 @@
       static PyObject *from(const multimap_type& multimap) {
 	swig_type_info *desc = swig::type_info<multimap_type>();
 	if (desc && desc->clientdata) {
-	  return SWIG_NewPointerObj(new multimap_type(multimap), desc, SWIG_POINTER_OWN);
+	  return SWIG_InternalNewPointerObj(new multimap_type(multimap), desc, SWIG_POINTER_OWN);
 	} else {
 	  size_type size = multimap.size();
 	  int pysize = (size <= (size_type) INT_MAX) ? (int) size : -1;

Lib/python/std_pair.i

@@ -116,9 +116,65 @@
       }
     };
   }
+
+#if defined(SWIGPYTHON_BUILTIN)
+SWIGINTERN Py_ssize_t
+SwigPython_std_pair_len (PyObject *a)
+{
+    return 2;
 }
 
+SWIGINTERN PyObject*
+SwigPython_std_pair_repr (PyObject *o)
+{
+    PyObject *tuple = PyTuple_New(2);
+    assert(tuple);
+    PyTuple_SET_ITEM(tuple, 0, PyObject_GetAttrString(o, (char*) "first"));
+    PyTuple_SET_ITEM(tuple, 1, PyObject_GetAttrString(o, (char*) "second"));
+    PyObject *result = PyObject_Repr(tuple);
+    Py_DECREF(tuple);
+    return result;
+}
+
+SWIGINTERN PyObject*
+SwigPython_std_pair_getitem (PyObject *a, Py_ssize_t b)
+{
+    PyObject *result = PyObject_GetAttrString(a, b % 2 ? (char*) "second" : (char*) "first");
+    return result;
+}
+
+SWIGINTERN int
+SwigPython_std_pair_setitem (PyObject *a, Py_ssize_t b, PyObject *c)
+{
+    int result = PyObject_SetAttrString(a, b % 2 ? (char*) "second" : (char*) "first", c);
+    return result;
+}
+#endif
+
+}
+
+%feature("python:sq_length") std::pair "SwigPython_std_pair_len";
+%feature("python:sq_length") std::pair<T*,U> "SwigPython_std_pair_len";
+%feature("python:sq_length") std::pair<T,U*> "SwigPython_std_pair_len";
+%feature("python:sq_length") std::pair<T*,U*> "SwigPython_std_pair_len";
+
+%feature("python:tp_repr") std::pair "SwigPython_std_pair_repr";
+%feature("python:tp_repr") std::pair<T*,U> "SwigPython_std_pair_repr";
+%feature("python:tp_repr") std::pair<T,U*> "SwigPython_std_pair_repr";
+%feature("python:tp_repr") std::pair<T*,U*> "SwigPython_std_pair_repr";
+
+%feature("python:sq_item") std::pair "SwigPython_std_pair_getitem";
+%feature("python:sq_item") std::pair<T*,U> "SwigPython_std_pair_getitem";
+%feature("python:sq_item") std::pair<T,U*> "SwigPython_std_pair_getitem";
+%feature("python:sq_item") std::pair<T*,U*> "SwigPython_std_pair_getitem";
+
+%feature("python:sq_ass_item") std::pair "SwigPython_std_pair_setitem";
+%feature("python:sq_ass_item") std::pair<T*,U> "SwigPython_std_pair_setitem";
+%feature("python:sq_ass_item") std::pair<T,U*> "SwigPython_std_pair_setitem";
+%feature("python:sq_ass_item") std::pair<T*,U*> "SwigPython_std_pair_setitem";
+
 %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))
@@ -133,6 +189,7 @@ def __setitem__(self, index, val):
   else:
     self.second = val}
 }
+#endif
 %enddef
 
 %include <std/std_pair.i>

Lib/r/rfragments.swg

@@ -170,12 +170,12 @@ SWIG_FromCharPtrAndSize(const char* carray, size_t size)
    order to allow for use of CHARSXP caches. */
 
   Rf_protect(t = Rf_allocVector(STRSXP, 1));
-#if R_VERSION >=  R_Version(2,7,0)
+%#if R_VERSION >=  R_Version(2,7,0)
   c = Rf_mkCharLen(carray, size);
-#else
+%#else
   c = Rf_allocVector(CHARSXP, size);
   strncpy((char *)CHAR(c), carray, size);
-#endif
+%#endif
   SET_STRING_ELT(t, 0, c);
   Rf_unprotect(1);
   return t;

Lib/ruby/rubycontainer.swg

@@ -4,8 +4,7 @@
  * Ruby sequence <-> C++ container wrapper
  *
  * This wrapper, and its iterator, allows a general use (and reuse) of
- * the the mapping between C++ and Ruby, thanks to the C++
- * templates.
+ * the mapping between C++ and Ruby, thanks to the C++ templates.
  *
  * Of course, it needs the C++ compiler to support templates, but
  * since we will use this wrapper with the STL containers, that should

Lib/ruby/timeval.i

@@ -58,6 +58,11 @@ struct timeval rb_time_timeval(VALUE);
 	$1 = NUM2LONG(rb_funcall($input, rb_intern("tv_sec"), 0));
 }
 
+%typemap(typecheck) time_t
+{
+  $1 = (NIL_P($input) || TYPE(rb_funcall($input, rb_intern("respond_to?"), 1, ID2SYM(rb_intern("tv_sec")))) == T_TRUE);
+}
+
 %typemap(out) time_t
 {
     $result = rb_time_new($1, 0);

Lib/std/std_common.i

@@ -20,12 +20,13 @@
 %}
 
 //
-// Common code for supporting the STD C++ namespace
+// Common code for supporting the C++ std namespace
 //
 
 %{
 #include <string>
 #include <stdexcept>
+#include <stddef.h>
 %}
 
 

Lib/std/std_container.i

@@ -26,10 +26,10 @@
   class const_iterator;
   class const_reverse_iterator;
 
-  const_iterator begin() const;
-  const_iterator end() const;
-  const_reverse_iterator rbegin() const;
-  const_reverse_iterator rend() const;
+  iterator begin();
+  iterator end();
+  reverse_iterator rbegin();
+  reverse_iterator rend();
   #endif
 
 %enddef

Lib/std_except.i

@@ -19,7 +19,7 @@
  * a new std_except.i file in the target library directory.
  * ----------------------------------------------------------------------------- */
 
-#if defined(SWIGJAVA) || defined(SWIGCSHARP) || defined(SWIGGUILE) || defined(SWIGUTL)
+#if defined(SWIGJAVA) || defined(SWIGCSHARP) || defined(SWIGGUILE) || defined(SWIGUTL) || defined(SWIGD)
 #error "This version of std_except.i should not be used"
 #endif
 

Lib/swig.swg

@@ -77,7 +77,7 @@
 #define %clearoldnodefault  %feature("oldnodefault","")
 
 /* the %exception directive */
-#ifdef SWIGCSHARP
+#if defined(SWIGCSHARP) || defined(SWIGD)
 #define %exception      %feature("except", canthrow=1)
 #else
 #define %exception      %feature("except")
@@ -95,7 +95,7 @@
    to set/get variable methods. You don't need to use the
    %allowexception directive when using %exceptionvar.
 */
-#ifdef SWIGCSHARP
+#if defined(SWIGCSHARP) || defined(SWIGD)
 #define %exceptionvar      %feature("exceptvar", canthrow=1)
 #else
 #define %exceptionvar      %feature("exceptvar")

Lib/tcl/tclapi.swg

@@ -49,6 +49,7 @@ typedef struct swig_class {
   struct swig_class **bases;
   const char              **base_names;
   swig_module_info   *module;
+  Tcl_HashTable       hashtable;
 } swig_class;
 
 typedef struct swig_instance {

Lib/tcl/tclinit.swg

@@ -42,7 +42,7 @@ extern "C" {
 
 SWIGINTERN void
 SWIG_Tcl_InstallConstants(Tcl_Interp *interp, swig_const_info constants[]) {
-  int i;
+  size_t i;
   Tcl_Obj *obj;
 
   if (!swigconstTableinit) {
@@ -67,6 +67,28 @@ SWIG_Tcl_InstallConstants(Tcl_Interp *interp, swig_const_info constants[]) {
   }
 }
 
+/* Create fast method lookup tables */
+
+SWIGINTERN void
+SWIG_Tcl_InstallMethodLookupTables(void) {
+  size_t i;
+
+  for (i = 0; i < swig_module.size; ++i) {
+    swig_type_info *type = swig_module.type_initial[i];
+    if (type->clientdata) {
+      swig_class* klass = (swig_class*) type->clientdata;
+      Tcl_InitHashTable(&(klass->hashtable), TCL_STRING_KEYS);
+      swig_method* meth = klass->methods;
+      while (meth && meth->name) {
+        int newEntry;
+        Tcl_HashEntry* hashentry = Tcl_CreateHashEntry(&(klass->hashtable), meth->name, &newEntry);
+        Tcl_SetHashValue(hashentry, (ClientData)meth->method);
+        ++meth;
+      }
+    }
+  }
+}
+
 #ifdef __cplusplus
 }
 #endif
@@ -76,7 +98,7 @@ SWIG_Tcl_InstallConstants(Tcl_Interp *interp, swig_const_info constants[]) {
  * -----------------------------------------------------------------------------*/
 
 SWIGEXPORT int SWIG_init(Tcl_Interp *interp) {
-  int i;
+  size_t i;
   if (interp == 0) return TCL_ERROR;
 #ifdef USE_TCL_STUBS
   /* (char*) cast is required to avoid compiler warning/error for Tcl < 8.4. */
@@ -113,6 +135,7 @@ SWIGEXPORT int SWIG_init(Tcl_Interp *interp) {
   }
 
   SWIG_Tcl_InstallConstants(interp, swig_constants);
+  SWIG_Tcl_InstallMethodLookupTables();
 
 %}
 

Lib/tcl/tclrun.swg

@@ -71,9 +71,6 @@
 
 #ifdef __cplusplus
 extern "C" {
-#if 0
-} /* cc-mode */
-#endif
 #endif
 
 /* Object support */
@@ -367,19 +364,17 @@ SWIG_Tcl_MethodCommand(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_
     }
     cls_stack_bi[cls_stack_top]++;
 
-    meth = cls->methods;
-    /* Check for methods */
-    while (meth && meth->name) {
-      if (strcmp(meth->name,method) == 0) {
+    Tcl_HashEntry* hashentry = Tcl_FindHashEntry(&(cls->hashtable), method);
+    if (hashentry) {
+        ClientData cd = Tcl_GetHashValue(hashentry);
+        swig_wrapper method_wrapper = (swig_wrapper)cd;
         oldarg = objv[1];
         objv[1] = inst->thisptr;
         Tcl_IncrRefCount(inst->thisptr);
-        rcode = (*meth->method)(clientData,interp,objc,objv);
+        rcode = (method_wrapper)(clientData,interp,objc,objv);
         objv[1] = oldarg;
         Tcl_DecrRefCount(inst->thisptr);
         return rcode;
-      }
-      meth++;
     }
     /* Check class methods for a match */
     if (strcmp(method,"cget") == 0) {
@@ -486,7 +481,7 @@ SWIGRUNTIME Tcl_Obj *
 SWIG_Tcl_NewInstanceObj(Tcl_Interp *interp, void *thisvalue, swig_type_info *type, int flags) {
   Tcl_Obj *robj = SWIG_NewPointerObj(thisvalue, type,0);
   /* Check to see if this pointer belongs to a class or not */
-  if ((type->clientdata) && (interp)) {
+  if (thisvalue && (type->clientdata) && (interp)) {
     Tcl_CmdInfo    ci;
     char          *name;
     name = Tcl_GetStringFromObj(robj,NULL);
@@ -685,8 +680,5 @@ SWIG_Tcl_GetArgs(Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[], const char
 }
 
 #ifdef __cplusplus
-#if 0
-{ /* cc-mode */
-#endif
 }
 #endif

Lib/typemaps/std_strings.swg

@@ -40,11 +40,7 @@ SWIG_AsPtr_dec(String)(SWIG_Object obj, String **val)
 SWIGINTERNINLINE SWIG_Object
 SWIG_From_dec(String)(const String& s)
 {
-  if (s.size()) {
-    return SWIG_FromCharPtrAndSize(s.data(), s.size());
-  } else {
-    return SWIG_FromCharPtrAndSize(s.c_str(), 0);
-  }
+  return SWIG_FromCharPtrAndSize(s.data(), s.size());
 }
 }
 %enddef

Lib/typemaps/strings.swg

@@ -206,7 +206,7 @@
 /* typecheck */
 
 %typemap(typecheck,noblock=1,precedence=StringCode,
-	 fragment=#SWIG_AsCharPtr) Char *, Char const*& {
+	 fragment=#SWIG_AsCharPtr) Char *, const Char *, Char const*& {
   int res = SWIG_AsCharPtr($input, 0, 0);
   $1 = SWIG_CheckState(res);
 }
@@ -351,7 +351,7 @@
 %typemap(typecheck,noblock=1,precedence=StringCode,
 	 fragment=#SWIG_AsCharArray)  
   Char [ANY], const Char[ANY] {
-  int res = SWIG_AsCharArray($input, (Char *)0, 0);
+  int res = SWIG_AsCharArray($input, (Char *)0, $1_dim0);
   $1 = SWIG_CheckState(res);
 }
 
@@ -577,8 +577,6 @@ SWIG_AsVal_dec(Char)(SWIG_Object obj, Char *val)
 }
 }
 
-%typemaps_asvalfromn(CharCode, Char);
-
 %_typemap_string(StringCode, 
 		 Char,
 		 SWIG_AsCharPtrAndSize,

Lib/typemaps/swigtype.swg

@@ -301,7 +301,7 @@
 
 %typemap(typecheck,precedence=SWIG_TYPECHECK_POINTER,noblock=1) SWIGTYPE *const& {
   void *vptr = 0;
-  int res = SWIG_ConvertPtr($input, &vptr, $descriptor, 0);
+  int res = SWIG_ConvertPtr($input, &vptr, $*descriptor, 0);
   $1 = SWIG_CheckState(res);
 }