itextomml 1.6.1 → 1.6.2

data/ext/itex2MML_ruby.c

@@ -1,18 +1,14 @@
 /* ----------------------------------------------------------------------------
- * This file was automatically generated by SWIG (http://www.swig.org).
- * Version 3.0.12
+ * This file was automatically generated by SWIG (https://www.swig.org).
+ * Version 4.4.1
  *
- * This file is not intended to be easily readable and contains a number of
- * coding conventions designed to improve portability and efficiency. Do not make
- * changes to this file unless you know what you are doing--modify the SWIG
- * interface file instead.
+ * Do not make changes to this file unless you know what you are doing - modify
+ * the SWIG interface file instead.
  * ----------------------------------------------------------------------------- */
 
 
-#ifndef SWIGRUBY
+#define SWIG_VERSION 0x040401
 #define SWIGRUBY
-#endif
-
 
 /* -----------------------------------------------------------------------------
  *  This section contains generic SWIG labels for method/variable
@@ -138,6 +134,40 @@
 # pragma warning disable 592
 #endif
 
+#if defined(__cplusplus) && __cplusplus >=201103L
+# define SWIG_NOEXCEPT noexcept
+#else
+# define SWIG_NOEXCEPT throw()
+#endif 
+
+/* -----------------------------------------------------------------------------
+ * swigcompat.swg
+ *
+ * Macros to provide support compatibility with older C and C++ standards.
+ *
+ * Note that SWIG expects __cplusplus to be defined to the appropriate C++ standard.
+ * MSVC users are urged to check and examine the /Zc:__cplusplus compiler option.
+ * See https://learn.microsoft.com/en-us/cpp/build/reference/zc-cplusplus.
+ * ----------------------------------------------------------------------------- */
+
+/* C99 and C++11 should provide snprintf, but define SWIG_NO_SNPRINTF
+ * if you're missing it.
+ */
+#if ((defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L) || \
+     (defined __cplusplus && __cplusplus >= 201103L) || \
+     defined SWIG_HAVE_SNPRINTF) && \
+    !defined SWIG_NO_SNPRINTF
+# define SWIG_snprintf(O,S,F,A) snprintf(O,S,F,A)
+# define SWIG_snprintf2(O,S,F,A,B) snprintf(O,S,F,A,B)
+#else
+/* Fallback versions ignore the buffer size, but most of our uses either have a
+ * fixed maximum possible size or dynamically allocate a buffer that's large
+ * enough.
+ */
+# define SWIG_snprintf(O,S,F,A) sprintf(O,F,A)
+# define SWIG_snprintf2(O,S,F,A,B) sprintf(O,F,A,B)
+#endif
+
 /* -----------------------------------------------------------------------------
  *  This section contains generic SWIG labels for method/variable
  *  declarations/attributes, and other compiler dependent labels.
@@ -262,6 +292,12 @@
 # pragma warning disable 592
 #endif
 
+#if defined(__cplusplus) && __cplusplus >=201103L
+# define SWIG_NOEXCEPT noexcept
+#else
+# define SWIG_NOEXCEPT throw()
+#endif 
+
 /* -----------------------------------------------------------------------------
  * swigrun.swg
  *
@@ -271,7 +307,7 @@
 
 /* This should only be incremented when either the layout of swig_type_info changes,
    or for whatever reason, the runtime changes incompatibly */
-#define SWIG_RUNTIME_VERSION "4"
+#define SWIG_RUNTIME_VERSION "5"
 
 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
 #ifdef SWIG_TYPE_TABLE
@@ -307,6 +343,9 @@
 /* Flags for pointer conversions */
 #define SWIG_POINTER_DISOWN        0x1
 #define SWIG_CAST_NEW_MEMORY       0x2
+#define SWIG_POINTER_NO_NULL       0x4
+#define SWIG_POINTER_CLEAR         0x8
+#define SWIG_POINTER_RELEASE       (SWIG_POINTER_CLEAR | SWIG_POINTER_DISOWN)
 
 /* Flags for new pointer objects */
 #define SWIG_POINTER_OWN           0x1
@@ -378,7 +417,7 @@
    SWIG errors code.
 
    Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
-   allows to return the 'cast rank', for example, if you have this
+   allows returning the 'cast rank', for example, if you have this
 
        int food(double)
        int fooi(int);
@@ -392,7 +431,13 @@
 */
 
 #define SWIG_OK                    (0)
+/* Runtime errors are < 0 */
 #define SWIG_ERROR                 (-1)
+/* Errors in range -1 to -99 are in swigerrors.swg (errors for all languages including those not using the runtime) */
+/* Errors in range -100 to -199 are language specific errors defined in *errors.swg */
+/* Errors < -200 are generic runtime specific errors */
+#define SWIG_ERROR_RELEASE_NOT_OWNED (-200)
+
 #define SWIG_IsOK(r)               (r >= 0)
 #define SWIG_ArgError(r)           ((r != SWIG_ERROR) ? r : SWIG_TypeError)
 
@@ -400,14 +445,14 @@
 #define SWIG_CASTRANKLIMIT         (1 << 8)
 /* The NewMask denotes the object was created (using new/malloc) */
 #define SWIG_NEWOBJMASK            (SWIG_CASTRANKLIMIT  << 1)
-/* The TmpMask is for in/out typemaps that use temporal objects */
+/* The TmpMask is for in/out typemaps that use temporary objects */
 #define SWIG_TMPOBJMASK            (SWIG_NEWOBJMASK << 1)
 /* Simple returning values */
 #define SWIG_BADOBJ                (SWIG_ERROR)
 #define SWIG_OLDOBJ                (SWIG_OK)
 #define SWIG_NEWOBJ                (SWIG_OK | SWIG_NEWOBJMASK)
 #define SWIG_TMPOBJ                (SWIG_OK | SWIG_TMPOBJMASK)
-/* Check, add and del mask methods */
+/* Check, add and del object mask methods */
 #define SWIG_AddNewMask(r)         (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
 #define SWIG_DelNewMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
 #define SWIG_IsNewObj(r)           (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
@@ -460,8 +505,8 @@ typedef struct swig_type_info {
 typedef struct swig_cast_info {
   swig_type_info         *type;			/* pointer to type that is equivalent to this type */
   swig_converter_func     converter;		/* function to cast the void pointers */
-  struct swig_cast_info  *next;			/* pointer to next cast in linked list */
-  struct swig_cast_info  *prev;			/* pointer to the previous cast */
+  struct swig_cast_info  *next;			/* pointer to next array of casts | pointer to cast hashed by value */
+  unsigned int            value;		/* index of the last valid element in the array | typename hash value */
 } swig_cast_info;
 
 /* Structure used to store module information
@@ -522,55 +567,147 @@ SWIG_TypeEquiv(const char *nb, const char *tb) {
   return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
 }
 
+/*
+ * Hash function for type name strings, based on maRushPrime1Hash (http://amsoftware.narod.ru/algo2.html)
+ */
+SWIGRUNTIME unsigned int SWIG_Hash(const char *str, unsigned int len) {
+  const unsigned char *data = (const unsigned char *)str;
+  unsigned int hash = len, i = 0, k;
+  int rem = (int)len;
+
+  while (rem >= (int)sizeof(unsigned int)) {
+    memcpy(&k, data, sizeof(unsigned int));
+    k += i++;
+    hash ^= k;
+    hash *= 171717;
+    data += sizeof(unsigned int);
+    rem -= sizeof(unsigned int);
+  }
+
+  switch (rem) {
+    case 3: k = (unsigned int)(data[2]) << 16;
+            k |= (unsigned int)(data[1]) << 8;
+            k |= (unsigned int)(data[0]);
+            k += i++;
+            hash ^= k;
+            hash *= 171717;
+            break;
+    case 2: k = (unsigned int)(data[1]) << 8;
+            k |= (unsigned int)(data[0]);
+            k += i++;
+            hash ^= k;
+            hash *= 171717;
+            break;
+    case 1: k = (unsigned int)(data[0]);
+            k += i++;
+            hash ^= k;
+            hash *= 171717;
+            break;
+  }
+  return hash;
+}
+
 /*
   Check the typename
 */
 SWIGRUNTIME swig_cast_info *
 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
+  static const unsigned int scan_threshold = 4;
   if (ty) {
-    swig_cast_info *iter = ty->cast;
-    while (iter) {
-      if (strcmp(iter->type->name, c) == 0) {
-        if (iter == ty->cast)
-          return iter;
-        /* Move iter to the top of the linked list */
-        iter->prev->next = iter->next;
-        if (iter->next)
-          iter->next->prev = iter->prev;
-        iter->next = ty->cast;
-        iter->prev = 0;
-        if (ty->cast) ty->cast->prev = iter;
-        ty->cast = iter;
-        return iter;
+    swig_cast_info *head = ty->cast;
+    unsigned int hash_value = 0;
+    int hashed = 0;
+
+    while (head) {
+
+      if (strcmp(head->type->name, c) == 0) {
+        return head;
       }
-      iter = iter->next;
+
+      if (head->value) {
+        swig_cast_info *iter;
+        swig_cast_info *last = head + head->value;
+        swig_cast_info *first = head + 1;
+        int search = 1;
+
+        if (!hashed) {
+          if (head->value < scan_threshold) {
+            for (iter = first; iter <= last; iter++) {
+              if (strcmp(iter->type->name, c) == 0) {
+                return iter;
+              }
+            }
+            search = 0;
+          } else {
+            hashed = 1;
+            hash_value = SWIG_Hash(c, (unsigned int)strlen(c));
+          }
+        }
+
+        if (search) {
+          /* Binary search over sorted <'next'|'value'> pairs */
+          do {
+            iter = first + ((last - first) >> 1);
+            if (iter->value < hash_value) {
+              first = iter + 1;
+            } else if (iter->value == hash_value) {
+
+              if (strcmp(iter->next->type->name, c) == 0) {
+                return iter->next;
+              }
+
+              /* Hash collision check */
+              for (last = iter + 1; last->next && last->value == hash_value; last++) {
+                if (strcmp(last->next->type->name, c) == 0) {
+                  return last->next;
+                }
+              }
+              for (first = iter - 1; first != head && first->value == hash_value; first--) {
+                if (strcmp(first->next->type->name, c) == 0) {
+                  return first->next;
+                }
+              }
+              break;
+            } else
+              last = iter - 1;
+          } while (first <= last);
+        }
+      }
+      head = head->next;
     }
   }
   return 0;
 }
 
 /*
-  Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
+  Check the type by type address
 */
 SWIGRUNTIME swig_cast_info *
-SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
+SWIG_TypeCheckStruct(const swig_type_info *from, swig_type_info *ty) {
   if (ty) {
-    swig_cast_info *iter = ty->cast;
-    while (iter) {
-      if (iter->type == from) {
-        if (iter == ty->cast)
-          return iter;
-        /* Move iter to the top of the linked list */
-        iter->prev->next = iter->next;
-        if (iter->next)
-          iter->next->prev = iter->prev;
-        iter->next = ty->cast;
-        iter->prev = 0;
-        if (ty->cast) ty->cast->prev = iter;
-        ty->cast = iter;
-        return iter;
+    swig_cast_info *head = ty->cast;
+    while (head) {
+      if (head->type == from) {
+        return head;
       }
-      iter = iter->next;
+
+      if (head->value) {
+        swig_cast_info *iter;
+        swig_cast_info *last = head + head->value;
+        swig_cast_info *first = head + 1;
+
+        /* Binary search over sorted array of casts */
+        do {
+          iter = first + ((last - first) >> 1);
+          if (iter->type < from) {
+            first = iter + 1;
+          } else if (iter->type == from) {
+            return iter;
+          } else
+            last = iter - 1;
+        } while (first <= last);
+      }
+      head = head->next;
     }
   }
   return 0;
@@ -613,9 +750,9 @@ SWIG_TypeName(const swig_type_info *ty) {
 SWIGRUNTIME const char *
 SWIG_TypePrettyName(const swig_type_info *type) {
   /* The "str" field contains the equivalent pretty names of the
-     type, separated by vertical-bar characters.  We choose
-     to print the last name, as it is often (?) the most
-     specific. */
+     type, separated by vertical-bar characters.  Choose the last
+     name. It should be the most specific; a fully resolved name
+     but not necessarily with default template parameters expanded. */
   if (!type) return NULL;
   if (type->str != NULL) {
     const char *last_name = type->str;
@@ -633,20 +770,24 @@ SWIG_TypePrettyName(const swig_type_info *type) {
 */
 SWIGRUNTIME void
 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
-  swig_cast_info *cast = ti->cast;
+  swig_cast_info *head = ti->cast;
   /* if (ti->clientdata == clientdata) return; */
   ti->clientdata = clientdata;
 
-  while (cast) {
-    if (!cast->converter) {
-      swig_type_info *tc = cast->type;
-      if (!tc->clientdata) {
-	SWIG_TypeClientData(tc, clientdata);
+  while (head) {
+    swig_cast_info *cast;
+    for (cast = head; (cast - head) <= head->value; cast++) {
+      if (!cast->converter) {
+        swig_type_info *tc = cast->type;
+        if (!tc->clientdata) {
+          SWIG_TypeClientData(tc, clientdata);
+        }
       }
     }
-    cast = cast->next;
+    head = head->next;
   }
 }
+
 SWIGRUNTIME void
 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
   SWIG_TypeClientData(ti, clientdata);
@@ -835,7 +976,7 @@ SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
 }
 #endif
 
-/*  Errors in SWIG */
+/* SWIG Errors applicable to all language modules, values are reserved from -1 to -99 */
 #define  SWIG_UnknownError    	   -1
 #define  SWIG_IOError        	   -2
 #define  SWIG_RuntimeError   	   -3
@@ -851,8 +992,25 @@ SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
 #define  SWIG_NullReferenceError   -13
 
 
+#if __GNUC__ >= 7
+#pragma GCC diagnostic push
+#if defined(__cplusplus)
+#pragma GCC diagnostic ignored "-Wregister"
+#if __GNUC__ >= 10
+#pragma GCC diagnostic ignored "-Wvolatile"
+#if __GNUC__ >= 11
+#pragma GCC diagnostic ignored "-Wdeprecated-enum-enum-conversion"
+#endif
+#endif
+#endif
+#endif
 
 #include <ruby.h>
+#include <ruby/version.h> /* For RUBY_API_VERSION_CODE */
+
+#if __GNUC__ >= 7
+#pragma GCC diagnostic pop
+#endif
 
 /* Ruby 1.9.1 has a "memoisation optimisation" when compiling with GCC which
  * breaks using rb_intern as an lvalue, as SWIG does.  We work around this
@@ -945,42 +1103,53 @@ SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
 #ifndef RSTRUCT_PTR
 # define RSTRUCT_PTR(x) RSTRUCT(x)->ptr
 #endif
+#ifndef RTYPEDDATA_P
+# define RTYPEDDATA_P(x) (TYPE(x) != T_DATA)
+#endif
 
 
 
 /*
- * Need to be very careful about how these macros are defined, especially
- * when compiling C++ code or C code with an ANSI C compiler.
+ * The following macros are used for providing the correct type of a
+ * function pointer to the Ruby C API.
+ *
+ * Starting with Ruby 2.7 these macros act transparently due to Ruby's moving
+ * moving away from ANYARGS and instead employing strict function signatures.
+ *
+ * Note: In case of C (not C++) the macros are transparent even before
+ * Ruby 2.7 due to the fact that the Ruby C API used function declarators
+ * with empty parentheses, which allows for an unspecified number of
+ * arguments.
+ *
+ * PROTECTFUNC(f) is used for the function pointer argument of the Ruby
+ * C API function rb_protect().
  *
- * VALUEFUNC(f) is a macro used to typecast a C function that implements
- * a Ruby method so that it can be passed as an argument to API functions
- * like rb_define_method() and rb_define_singleton_method().
+ * VALUEFUNC(f) is used for the function pointer argument(s) of Ruby C API
+ * functions like rb_define_method() and rb_define_singleton_method().
  *
- * VOIDFUNC(f) is a macro used to typecast a C function that implements
- * either the "mark" or "free" stuff for a Ruby Data object, so that it
- * can be passed as an argument to API functions like Data_Wrap_Struct()
+ * VOIDFUNC(f) is used to typecast a C function that implements either
+ * the "mark" or "free" stuff for a Ruby Data object, so that it can be
+ * passed as an argument to Ruby C API functions like Data_Wrap_Struct()
  * and Data_Make_Struct().
+ *
+ * SWIG_RUBY_VOID_ANYARGS_FUNC(f) is used for the function pointer
+ * argument(s) of Ruby C API functions like rb_define_virtual_variable().
+ *
+ * SWIG_RUBY_INT_ANYARGS_FUNC(f) is used for the function pointer
+ * argument(s) of Ruby C API functions like st_foreach().
  */
- 
-#ifdef __cplusplus
-#  ifndef RUBY_METHOD_FUNC /* These definitions should work for Ruby 1.4.6 */
-#    define PROTECTFUNC(f) ((VALUE (*)()) f)
-#    define VALUEFUNC(f) ((VALUE (*)()) f)
-#    define VOIDFUNC(f)  ((void (*)()) f)
-#  else
-#    ifndef ANYARGS /* These definitions should work for Ruby 1.6 */
-#      define PROTECTFUNC(f) ((VALUE (*)()) f)
-#      define VALUEFUNC(f) ((VALUE (*)()) f)
-#      define VOIDFUNC(f)  ((RUBY_DATA_FUNC) f)
-#    else /* These definitions should work for Ruby 1.7+ */
-#      define PROTECTFUNC(f) ((VALUE (*)(VALUE)) f)
-#      define VALUEFUNC(f) ((VALUE (*)(ANYARGS)) f)
-#      define VOIDFUNC(f)  ((RUBY_DATA_FUNC) f)
-#    endif
-#  endif
+#if defined(__cplusplus) && RUBY_API_VERSION_CODE < 20700
+#  define PROTECTFUNC(f) ((VALUE (*)(VALUE)) f)
+#  define VALUEFUNC(f) ((VALUE (*)(ANYARGS)) f)
+#  define VOIDFUNC(f) ((RUBY_DATA_FUNC) f)
+#  define SWIG_RUBY_VOID_ANYARGS_FUNC(f) ((void (*)(ANYARGS))(f))
+#  define SWIG_RUBY_INT_ANYARGS_FUNC(f) ((int (*)(ANYARGS))(f))
 #else
+#  define PROTECTFUNC(f) (f)
 #  define VALUEFUNC(f) (f)
 #  define VOIDFUNC(f) (f)
+#  define SWIG_RUBY_VOID_ANYARGS_FUNC(f) (f)
+#  define SWIG_RUBY_INT_ANYARGS_FUNC(f) (f)
 #endif
 
 /* Don't use for expressions have side effect */
@@ -1020,15 +1189,12 @@ static VALUE _mSWIG = Qnil;
 
 
 /* Define custom exceptions for errors that do not map to existing Ruby
-   exceptions.  Note this only works for C++ since a global cannot be
-   initialized by a function in C.  For C, fallback to rb_eRuntimeError.*/
+   exceptions. */
 
 SWIGINTERN VALUE 
 getNullReferenceError(void) {
-  static int init = 0;
-  static VALUE rb_eNullReferenceError ;
-  if (!init) {
-    init = 1;
+  static VALUE rb_eNullReferenceError = Qnil;
+  if (rb_eNullReferenceError == Qnil) {
     rb_eNullReferenceError = rb_define_class("NullReferenceError", rb_eRuntimeError);
   }
   return rb_eNullReferenceError;
@@ -1036,10 +1202,8 @@ getNullReferenceError(void) {
 
 SWIGINTERN VALUE 
 getObjectPreviouslyDeletedError(void) {
-  static int init = 0;
-  static VALUE rb_eObjectPreviouslyDeleted ;
-  if (!init) {
-    init = 1;
+  static VALUE rb_eObjectPreviouslyDeleted = Qnil;
+  if (rb_eObjectPreviouslyDeleted == Qnil) {
     rb_eObjectPreviouslyDeleted = rb_define_class("ObjectPreviouslyDeleted", rb_eRuntimeError);
   }
   return rb_eObjectPreviouslyDeleted;
@@ -1122,7 +1286,7 @@ const char* Ruby_Format_TypeError( const char* msg,
     }
 
   str = rb_str_cat2( str, "Expected argument " );
-  sprintf( buf, "%d of type ", argn-1 );
+  SWIG_snprintf( buf, sizeof( buf), "%d of type ", argn-1 );
   str = rb_str_cat2( str, buf );
   str = rb_str_cat2( str, type );
   str = rb_str_cat2( str, ", but got " );
@@ -1168,7 +1332,7 @@ void Ruby_Format_OverloadedError(
 /* -----------------------------------------------------------------------------
  * rubytracking.swg
  *
- * This file contains support for tracking mappings from 
+ * This file contains support for tracking mappings from
  * Ruby objects to C++ objects.  This functionality is needed
  * to implement mark functions for Ruby's mark and sweep
  * garbage collector.
@@ -1195,11 +1359,11 @@ extern "C" {
 #endif
 
 /* Global hash table to store Trackings from C/C++
-   structs to Ruby Objects. 
+   structs to Ruby Objects.
 */
 static st_table* swig_ruby_trackings = NULL;
 
-static VALUE swig_ruby_trackings_count(ANYARGS) {
+static VALUE swig_ruby_trackings_count(ID id, VALUE *var) {
   return SWIG2NUM(swig_ruby_trackings->num_entries);
 }
 
@@ -1209,7 +1373,7 @@ SWIGRUNTIME void SWIG_RubyInitializeTrackings(void) {
   /* Create a hash table to store Trackings from C++
      objects to Ruby objects. */
 
-  /* Try to see if some other .so has already created a 
+  /* Try to see if some other .so has already created a
      tracking hash table, which we keep hidden in an instance var
      in the SWIG module.
      This is done to allow multiple DSOs to share the same
@@ -1236,7 +1400,9 @@ SWIGRUNTIME void SWIG_RubyInitializeTrackings(void) {
     swig_ruby_trackings = (st_table*)NUM2SWIG(trackings_value);
   }
 
-  rb_define_virtual_variable("SWIG_TRACKINGS_COUNT", swig_ruby_trackings_count, NULL);
+  rb_define_virtual_variable("SWIG_TRACKINGS_COUNT",
+                             VALUEFUNC(swig_ruby_trackings_count),
+                             SWIG_RUBY_VOID_ANYARGS_FUNC((rb_gvar_setter_t*)NULL));
 }
 
 /* Add a Tracking from a C/C++ struct to a Ruby object */
@@ -1268,13 +1434,14 @@ SWIGRUNTIME void SWIG_RubyRemoveTracking(void* ptr) {
 
 /* This is a helper method that unlinks a Ruby object from its
    underlying C++ object.  This is needed if the lifetime of the
-   Ruby object is longer than the C++ object */
+   Ruby object is longer than the C++ object. */
 SWIGRUNTIME void SWIG_RubyUnlinkObjects(void* ptr) {
   VALUE object = SWIG_RubyInstanceFor(ptr);
 
   if (object != Qnil) {
-    if (TYPE(object) != T_DATA)
-      abort();
+    // object might have the T_ZOMBIE type, but that's just
+    // because the GC has flagged it as such for a deferred
+    // destruction. Until then, it's still a T_DATA object.
     DATA_PTR(object) = 0;
   }
 }
@@ -1284,13 +1451,15 @@ SWIGRUNTIME void SWIG_RubyUnlinkObjects(void* ptr) {
    to the passed callback function. */
 
 /* Proxy method to abstract the internal trackings datatype */
-static int swig_ruby_internal_iterate_callback(void* ptr, VALUE obj, void(*meth)(void* ptr, VALUE obj)) {
-  (*meth)(ptr, obj);
+static int swig_ruby_internal_iterate_callback(st_data_t ptr, st_data_t obj, st_data_t meth) {
+  ((void (*) (void *, VALUE))meth)((void *)ptr, (VALUE)obj);
   return ST_CONTINUE;
 }
 
 SWIGRUNTIME void SWIG_RubyIterateTrackings( void(*meth)(void* ptr, VALUE obj) ) {
-  st_foreach(swig_ruby_trackings, (int (*)(ANYARGS))&swig_ruby_internal_iterate_callback, (st_data_t)meth);
+  st_foreach(swig_ruby_trackings,
+             SWIG_RUBY_INT_ANYARGS_FUNC(swig_ruby_internal_iterate_callback),
+             (st_data_t)meth);
 }
 
 #ifdef __cplusplus
@@ -1306,8 +1475,8 @@ extern "C" {
 #endif
 
 SWIGINTERN VALUE
-SWIG_Ruby_AppendOutput(VALUE target, VALUE o) {
-  if (NIL_P(target)) {
+SWIG_Ruby_AppendOutput(VALUE target, VALUE o, int is_void) {
+  if (NIL_P(target) && is_void) {
     target = o;
   } else {
     if (TYPE(target) != T_ARRAY) {
@@ -1416,6 +1585,7 @@ static VALUE swig_runtime_data_type_pointer = Qnil;
 /* Global IDs used to keep some internal SWIG stuff */
 static ID swig_arity_id = 0;
 static ID swig_call_id  = 0;
+static ID swig_lowerthan_id = 0;
 
 /*
   If your swig extension is to be run within an embedded ruby and has
@@ -1449,10 +1619,8 @@ static ID swig_call_id  = 0;
 
 SWIGRUNTIME VALUE 
 getExceptionClass(void) {
-  static int init = 0;
-  static VALUE rubyExceptionClass ;
-  if (!init) {
-    init = 1;
+  static VALUE rubyExceptionClass = Qnil;
+  if (rubyExceptionClass == Qnil) {
     rubyExceptionClass = rb_const_get(_mSWIG, rb_intern("Exception"));
   }
   return rubyExceptionClass;
@@ -1467,7 +1635,7 @@ SWIG_Ruby_ExceptionType(swig_type_info *desc, VALUE obj) {
   VALUE exceptionClass = getExceptionClass();
   if (rb_obj_is_kind_of(obj, exceptionClass)) {
     return obj;
-  }  else {
+  } else {
     return rb_exc_new3(rb_eRuntimeError, rb_obj_as_string(obj));
   }
 }
@@ -1480,6 +1648,7 @@ SWIG_Ruby_InitRuntime(void)
     _mSWIG = rb_define_module("SWIG");
     swig_call_id  = rb_intern("call");
     swig_arity_id = rb_intern("arity");
+    swig_lowerthan_id = rb_intern("<");
   }
 }
 
@@ -1487,13 +1656,14 @@ SWIG_Ruby_InitRuntime(void)
 SWIGRUNTIME void
 SWIG_Ruby_define_class(swig_type_info *type)
 {
-  char *klass_name = (char *) malloc(4 + strlen(type->name) + 1);
-  sprintf(klass_name, "TYPE%s", type->name);
+  size_t klass_len = 4 + strlen(type->name) + 1;
+  char *klass_name = (char *) malloc(klass_len);
+  SWIG_snprintf(klass_name, klass_len, "TYPE%s", type->name);
   if (NIL_P(_cSWIG_Pointer)) {
     _cSWIG_Pointer = rb_define_class_under(_mSWIG, "Pointer", rb_cObject);
     rb_undef_method(CLASS_OF(_cSWIG_Pointer), "new");
   }
-  rb_define_class_under(_mSWIG, klass_name, _cSWIG_Pointer);
+  rb_undef_alloc_func(rb_define_class_under(_mSWIG, klass_name, _cSWIG_Pointer));
   free((void *) klass_name);
 }
 
@@ -1507,10 +1677,11 @@ SWIG_Ruby_NewPointerObj(void *ptr, swig_type_info *type, int flags)
   swig_class *sklass;
   VALUE klass;
   VALUE obj;
-  
+
   if (!ptr)
     return Qnil;
-  
+
+  assert(type);
   if (type->clientdata) {
     sklass = (swig_class *) type->clientdata;
 		
@@ -1518,7 +1689,7 @@ SWIG_Ruby_NewPointerObj(void *ptr, swig_type_info *type, int flags)
     track = sklass->trackObjects;
     if (track) {
       obj = SWIG_RubyInstanceFor(ptr);
-      
+
       /* Check the object's type and make sure it has the correct type.
         It might not in cases where methods do things like 
         downcast methods. */
@@ -1543,14 +1714,15 @@ SWIG_Ruby_NewPointerObj(void *ptr, swig_type_info *type, int flags)
       SWIG_RubyAddTracking(ptr, obj);
     }
   } else {
-    klass_name = (char *) malloc(4 + strlen(type->name) + 1);
-    sprintf(klass_name, "TYPE%s", type->name);
+    size_t klass_len = 4 + strlen(type->name) + 1;
+    klass_name = (char *) malloc(klass_len);
+    SWIG_snprintf(klass_name, klass_len, "TYPE%s", type->name);
     klass = rb_const_get(_mSWIG, rb_intern(klass_name));
     free((void *) klass_name);
     obj = Data_Wrap_Struct(klass, 0, 0, ptr);
   }
   rb_iv_set(obj, "@__swigtype__", rb_str_new2(type->name));
-  
+
   return obj;
 }
 
@@ -1570,6 +1742,8 @@ SWIGRUNTIMEINLINE char *
 SWIG_Ruby_MangleStr(VALUE obj)
 {
   VALUE stype = rb_iv_get(obj, "@__swigtype__");
+  if (NIL_P(stype))
+    return NULL;
   return StringValuePtr(stype);
 }
 
@@ -1582,7 +1756,7 @@ typedef struct {
 SWIGRUNTIME swig_ruby_owntype
 SWIG_Ruby_AcquirePtr(VALUE obj, swig_ruby_owntype own) {
   swig_ruby_owntype oldown = {0, 0};
-  if (obj) {
+  if (TYPE(obj) == T_DATA && !RTYPEDDATA_P(obj)) {
     oldown.datafree = RDATA(obj)->dfree;
     RDATA(obj)->dfree = own.datafree;
   }
@@ -1601,9 +1775,9 @@ SWIG_Ruby_ConvertPtrAndOwn(VALUE obj, void **ptr, swig_type_info *ty, int flags,
   if (NIL_P(obj)) {
     if (ptr)
       *ptr = 0;
-    return SWIG_OK;
+    return (flags & SWIG_POINTER_NO_NULL) ? SWIG_NullReferenceError : SWIG_OK;
   } else {
-    if (TYPE(obj) != T_DATA) {
+    if (TYPE(obj) != T_DATA || (TYPE(obj) == T_DATA && RTYPEDDATA_P(obj))) {
       return SWIG_ERROR;
     }
     Data_Get_Struct(obj, void, vptr);
@@ -1614,6 +1788,11 @@ SWIG_Ruby_ConvertPtrAndOwn(VALUE obj, void **ptr, swig_type_info *ty, int flags,
     own->own = 0;
   }
     
+  if (((flags & SWIG_POINTER_RELEASE) == SWIG_POINTER_RELEASE)) {
+    if (!RDATA(obj)->dfree)
+      return SWIG_ERROR_RELEASE_NOT_OWNED;
+  }
+
   /* Check to see if the input object is giving up ownership
      of the underlying C struct or C++ object.  If so then we
      need to reset the destructor since the Ruby object no 
@@ -1625,7 +1804,7 @@ SWIG_Ruby_ConvertPtrAndOwn(VALUE obj, void **ptr, swig_type_info *ty, int flags,
       swig_class *sklass = (swig_class *) ty->clientdata;
       track = sklass->trackObjects;
     }
-		
+
     if (track) {
       /* We are tracking objects for this class.  Thus we change the destructor
        * to SWIG_RubyRemoveTracking.  This allows us to
@@ -1639,6 +1818,10 @@ SWIG_Ruby_ConvertPtrAndOwn(VALUE obj, void **ptr, swig_type_info *ty, int flags,
     }
   }
 
+  if (flags & SWIG_POINTER_CLEAR) {
+    DATA_PTR(obj) = 0;
+  }
+
   /* Do type-checking if type info was provided */
   if (ty) {
     if (ty->clientdata) {
@@ -1698,7 +1881,7 @@ SWIG_Ruby_NewPackedObj(void *ptr, int sz, swig_type_info *type) {
   return rb_str_new2(result);
 }
 
-/* Convert a packed value value */
+/* Convert a packed pointer value */
 SWIGRUNTIME int
 SWIG_Ruby_ConvertPacked(VALUE obj, void *ptr, int sz, swig_type_info *ty) {
   swig_cast_info *tc;
@@ -1745,7 +1928,8 @@ SWIGRUNTIME void
 SWIG_Ruby_SetModule(swig_module_info *pointer)
 {
   /* register a new class */
-  VALUE cl = rb_define_class("Swig_runtime_data", rb_cObject);
+  VALUE cl = rb_define_class("swig_runtime_data", rb_cObject);
+  rb_undef_alloc_func(cl);
   /* create and store the structure pointer to a global variable */
   swig_runtime_data_type_pointer = Data_Wrap_Struct(cl, 0, 0, pointer);
   rb_define_readonly_variable("$swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, &swig_runtime_data_type_pointer);
@@ -1776,7 +1960,7 @@ int SWIG_Ruby_arity( VALUE proc, int minimal )
 {
   if ( rb_respond_to( proc, swig_arity_id ) )
     {
-      VALUE num = rb_funcall( proc, swig_arity_id, 0 );
+      VALUE num = rb_funcall2( proc, swig_arity_id, 0, 0 );
       int arity = NUM2INT(num);
       if ( arity < 0 && (arity+1) < -minimal ) return 1;
       if ( arity == minimal ) return 1;
@@ -1794,7 +1978,7 @@ int SWIG_Ruby_arity( VALUE proc, int minimal )
 
 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0) 
 
-#define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else 
+#define SWIG_contract_assert(expr, msg) do { if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } } while (0) 
 
 
 
@@ -1817,10 +2001,6 @@ static VALUE mItex2MML;
 #define SWIG_RUBY_THREAD_END_BLOCK
 
 
-#define SWIGVERSION 0x030012 
-#define SWIG_VERSION SWIGVERSION
-
-
 #define SWIG_as_voidptr(a) (void *)((const void *)(a)) 
 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a)) 
 
@@ -1832,11 +2012,9 @@ extern const char * itex2MML_output ();
 SWIGINTERN swig_type_info*
 SWIG_pchar_descriptor(void)
 {
-  static int init = 0;
   static swig_type_info* info = 0;
-  if (!init) {
+  if (!info) {
     info = SWIG_TypeQuery("_p_char");
-    init = 1;
   }
   return info;
 }
@@ -1880,22 +2058,21 @@ SWIG_AsCharPtrAndSize(VALUE obj, char** cptr, size_t* psize, int *alloc)
 
 
 SWIGINTERN VALUE
-SWIG_ruby_failed(void)
+SWIG_ruby_failed(VALUE SWIGUNUSEDPARM(arg1), VALUE SWIGUNUSEDPARM(arg2))
 {
   return Qnil;
 } 
 
 
-/*@SWIG:/sw/share/swig/3.0.12/ruby/rubyprimtypes.swg,19,%ruby_aux_method@*/
-SWIGINTERN VALUE SWIG_AUX_NUM2ULONG(VALUE *args)
+SWIGINTERN VALUE SWIG_AUX_NUM2ULONG(VALUE arg)
 {
+  VALUE *args = (VALUE *)arg;
   VALUE obj = args[0];
   VALUE type = TYPE(obj);
   unsigned long *res = (unsigned long *)(args[1]);
   *res = type == T_FIXNUM ? NUM2ULONG(obj) : rb_big2ulong(obj);
   return obj;
 }
-/*@SWIG@*/
 
 SWIGINTERN int
 SWIG_AsVal_unsigned_SS_long (VALUE obj, unsigned long *val) 
@@ -1906,7 +2083,9 @@ SWIG_AsVal_unsigned_SS_long (VALUE obj, unsigned long *val)
     VALUE a[2];
     a[0] = obj;
     a[1] = (VALUE)(&v);
-    if (rb_rescue(RUBY_METHOD_FUNC(SWIG_AUX_NUM2ULONG), (VALUE)a, RUBY_METHOD_FUNC(SWIG_ruby_failed), 0) != Qnil) {
+    if (rb_rescue(VALUEFUNC(SWIG_AUX_NUM2ULONG), (VALUE)a, VALUEFUNC(SWIG_ruby_failed), 0) != Qnil) {
+      if (rb_funcall(obj, swig_lowerthan_id, 1, INT2FIX(0)) != Qfalse)
+        return SWIG_OverflowError;
       if (val) *val = v;
       return SWIG_OK;
     }
@@ -1931,16 +2110,15 @@ SWIG_AsVal_unsigned_SS_long (VALUE obj, unsigned long *val)
 
 
 #ifdef SWIG_LONG_LONG_AVAILABLE
-/*@SWIG:/sw/share/swig/3.0.12/ruby/rubyprimtypes.swg,19,%ruby_aux_method@*/
-SWIGINTERN VALUE SWIG_AUX_NUM2ULL(VALUE *args)
+SWIGINTERN VALUE SWIG_AUX_NUM2ULL(VALUE arg)
 {
+  VALUE *args = (VALUE *)arg;
   VALUE obj = args[0];
   VALUE type = TYPE(obj);
   long long *res = (long long *)(args[1]);
   *res = type == T_FIXNUM ? NUM2ULL(obj) : rb_big2ull(obj);
   return obj;
 }
-/*@SWIG@*/
 
 SWIGINTERN int
 SWIG_AsVal_unsigned_SS_long_SS_long (VALUE obj, unsigned long long *val)
@@ -1951,7 +2129,9 @@ SWIG_AsVal_unsigned_SS_long_SS_long (VALUE obj, unsigned long long *val)
     VALUE a[2];
     a[0] = obj;
     a[1] = (VALUE)(&v);
-    if (rb_rescue(RUBY_METHOD_FUNC(SWIG_AUX_NUM2ULL), (VALUE)a, RUBY_METHOD_FUNC(SWIG_ruby_failed), 0) != Qnil) {
+    if (rb_rescue(VALUEFUNC(SWIG_AUX_NUM2ULL), (VALUE)a, VALUEFUNC(SWIG_ruby_failed), 0) != Qnil) {
+      if (rb_funcall(obj, swig_lowerthan_id, 1, INT2FIX(0)) != Qfalse)
+        return SWIG_OverflowError;
       if (val) *val = v;
       return SWIG_OK;
     }
@@ -2017,7 +2197,7 @@ SWIG_FromCharPtr(const char *cptr)
 
 SWIGINTERN VALUE
 _wrap_itex2MML_filter(int argc, VALUE *argv, VALUE self) {
-  char *arg1 = (char *) 0 ;
+  char *arg1 = 0 ;
   size_t arg2 ;
   int res1 ;
   char *buf1 = 0 ;
@@ -2052,7 +2232,7 @@ fail:
 
 SWIGINTERN VALUE
 _wrap_itex2MML_html_filter(int argc, VALUE *argv, VALUE self) {
-  char *arg1 = (char *) 0 ;
+  char *arg1 = 0 ;
   size_t arg2 ;
   int res1 ;
   char *buf1 = 0 ;
@@ -2121,7 +2301,7 @@ static swig_cast_info *swig_cast_initial[] = {
 
 /* -----------------------------------------------------------------------------
  * Type initialization:
- * This problem is tough by the requirement that no dynamic
+ * This problem is made tough by the requirement that no dynamic
  * memory is used. Also, since swig_type_info structures store pointers to
  * swig_cast_info structures and swig_cast_info structures store pointers back
  * to swig_type_info structures, we need some lookup code at initialization.
@@ -2136,15 +2316,20 @@ static swig_cast_info *swig_cast_initial[] = {
  * array. We just loop through that array, and handle each type individually.
  * First we lookup if this type has been already loaded, and if so, use the
  * loaded structure instead of the generated one. Then we have to fill in the
- * cast linked list. The cast data is initially stored in something like a
+ * cast dependencies. The cast data is initially stored in something like a
  * two-dimensional array. Each row corresponds to a type (there are the same
  * number of rows as there are in the swig_type_initial array). Each entry in
  * a column is one of the swig_cast_info structures for that type.
  * The cast_initial array is actually an array of arrays, because each row has
- * a variable number of columns. So to actually build the cast linked list,
- * we find the array of casts associated with the type, and loop through it
- * adding the casts to the list. The one last trick we need to do is making
- * sure the type pointer in the swig_cast_info struct is correct.
+ * a variable number of columns.
+ *
+ * We loop through the cast[] array associated with the type and mark casts
+ * which have not been defined in previously loaded modules by assigning
+ * cast pointer value to cast->next. We also hash cast->type->name string
+ * and store the value in the cast->value field. If we encounter swig_cast_info
+ * structure that represents a cast to self we move it to the beginning
+ * of the cast array. One trick we need to do is making sure the type pointer
+ * in the swig_cast_info struct is correct.
  *
  * First off, we lookup the cast->type name to see if it is already loaded.
  * There are three cases to handle:
@@ -2156,8 +2341,71 @@ static swig_cast_info *swig_cast_initial[] = {
  *     cast->type) are loaded, THEN the cast info has already been loaded by
  *     the previous module so we just ignore it.
  *  3) Finally, if cast->type has not already been loaded, then we add that
- *     swig_cast_info to the linked list (because the cast->type) pointer will
+ *     swig_cast_info to the list (because the cast->type) pointer will
  *     be correct.
+ *
+ * Once the cast array has been set up AND it does have new casts that need
+ * to be added we sort non-self cast entries to move filtered out entries
+ * to the end of the array and to arrange the rest in the increasing order
+ * of their type pointer values. We store the index of the last added entry
+ * in the cast->value field of the entry[0] (overwriting the name hash). Then
+ * we sort <next|value> fields of the remaining entries to arrange hash values
+ * in the increasing order. This way cast->next->type->name field matches
+ * the cast->value hash.
+ *
+ * Example:
+ * Array of casts for type stored at 0x5000, cast to type stored at 0x3000
+ * has already been loaded
+ *
+ *      After sweep-and-hash:   After sort-by-type:    After sort-by-hash:
+ *        ________________       ________________       ________________
+ *       |                |     |                |     |                |
+ * Entry |  type = 0x5000 |     |  type = 0x5000 |     |  type = 0x5000 |
+ *   0   |                |     |                |     |                |
+ *       |  next = Entry0 |     |  next = Entry0 |     |  next = Entry0 |
+ *       | value = 1212   |     | value = 3      |     | value = 3      |
+ *       |                |     |                |     |                |
+ *       |================|     |================|     |================|
+ *       |                |     |                |     |                |
+ * Entry |  type = 0x2000 |     |  type = 0x1000 |     |  type = 0x1000 |
+ *   1   |                |     |                |     |                |
+ *       |  next = Entry1 |     |  next = Entry1 |     |  next = Entry3 |
+ *       | value = 3434   |     | value = 4545   |     | value = 2323   |
+ *       |________________|     |________________|     |________________|
+ *       |                |     |                |     |                |
+ * Entry |  type = 0x3000 |     |  type = 0x2000 |     |  type = 0x2000 |
+ *   2   |                |     |                |     |                |
+ *       |  next = 0      |     |  next = Entry2 |     |  next = Entry2 |
+ *       | value = 0      |     | value = 3434   |     | value = 3434   |
+ *       |________________|     |________________|     |________________|
+ *       |                |     |                |     |                |
+ * Entry |  type = 0x1000 |     |  type = 0x4000 |     |  type = 0x4000 |
+ *   3   |                |     |                |     |                |
+ *       |  next = Entry3 |     |  next = Entry3 |     |  next = Entry1 |
+ *       | value = 4545   |     | value = 2323   |     | value = 4545   |
+ *       |________________|     |________________|     |________________|
+ *       |                |     |                |     |                |
+ * Entry |  type = 0x4000 |     |  type = 0x3000 |     |  type = 0x3000 |
+ *   4   |                |     |                |     |                |
+ *       |  next = Entry4 |     |  next = 0      |     |  next = 0      |
+ *       | value = 2323   |     | value = 0      |     | value = 0      |
+ *       |________________|     |________________|     |________________|
+ *
+ * Once the cast array has been initialized, we use cast[0]->next field to link
+ * it into the list of cast arrays for the type.
+ *              ____    ____    ____
+ * type->cast->|next|->|next|->|next|->0
+ *             |----|  |----|  |----|
+ *             |----|  |----|  |----|
+ *             |----|  |----|  |----|
+ *
+ * Subsequent cast resolution works as follows:
+ *
+ * 1. Check whether the type matches the first entry in the current cast array.
+ * 2. If not, then do a binary search over the (0:cast->value] interval using
+ *    either type address or the hash value of the type name.
+ * 3. If not found, then move over to the next cast array (cast[0]->next).
+ *
  * ----------------------------------------------------------------------------- */
 
 #ifdef __cplusplus
@@ -2171,9 +2419,52 @@ extern "C" {
 #define SWIGRUNTIME_DEBUG
 #endif
 
+#ifndef SWIG_INIT_CLIENT_DATA_TYPE
+#define SWIG_INIT_CLIENT_DATA_TYPE void *
+#endif
+
+/*
+ * Sort function that puts cast entries with nonzero 'next' at the front
+ * of the array while ordering them by addresses of their 'type' structs.
+ */
+SWIGINTERN int SWIG_CastCmpStruct(const void *pa, const void *pb) {
+  swig_cast_info *pca = (swig_cast_info *)pa;
+  swig_cast_info *pcb = (swig_cast_info *)pb;
+  if (pca->type < pcb->type)
+    return (pca->next || pcb->next == 0) ? -1 : 1;
+  if (pca->type > pcb->type)
+    return (pcb->next || pca->next == 0) ? 1 : -1;
+  return 0;
+}
+
+/*
+ * Shell-sort 'next' and 'value' field pairs to order them by 'value'.
+ */
+SWIGINTERN void SWIG_CastHashSort(swig_cast_info *cast, int size) {
+  const int hmax = size/9;
+  int h, i;
+  for(h = 1; h <= hmax; h = 3*h+1);
+  for(; h > 0; h /= 3)
+  {
+    for(i = h; i < size; ++i)
+    {
+      swig_cast_info *p = cast[i].next;
+      unsigned int hash = cast[i].value;
+      int j = i;
+      while(j >= h && hash < cast[j-h].value)
+      {
+        cast[j].next = cast[j-h].next;
+        cast[j].value = cast[j-h].value;
+        j -= h;
+      }
+      cast[j].next = p;
+      cast[j].value = hash;
+    }
+  }
+}
 
 SWIGRUNTIME void
-SWIG_InitializeModule(void *clientdata) {
+SWIG_InitializeModule(SWIG_INIT_CLIENT_DATA_TYPE clientdata) {
   size_t i;
   swig_module_info *module_head, *iter;
   int init;
@@ -2219,15 +2510,16 @@ SWIG_InitializeModule(void *clientdata) {
 
   /* Now work on filling in swig_module.types */
 #ifdef SWIGRUNTIME_DEBUG
-  printf("SWIG_InitializeModule: size %d\n", swig_module.size);
+  printf("SWIG_InitializeModule: size %lu\n", (unsigned long)swig_module.size);
 #endif
   for (i = 0; i < swig_module.size; ++i) {
     swig_type_info *type = 0;
-    swig_type_info *ret;
-    swig_cast_info *cast;
+    swig_type_info *target_type;
+    swig_cast_info *cast, *first;
+    int num_mapped = 0;
 
 #ifdef SWIGRUNTIME_DEBUG
-    printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
+    printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
 #endif
 
     /* if there is another module already loaded */
@@ -2250,49 +2542,104 @@ SWIG_InitializeModule(void *clientdata) {
     }
 
     /* Insert casting types */
-    cast = swig_module.cast_initial[i];
+    cast = first = swig_module.cast_initial[i];
     while (cast->type) {
 
       /* Don't need to add information already in the list */
-      ret = 0;
+      target_type = 0;
 #ifdef SWIGRUNTIME_DEBUG
       printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
 #endif
       if (swig_module.next != &swig_module) {
-        ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
+        target_type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
+        if (target_type) {
+
+          /* Target type already defined in another module */
 #ifdef SWIGRUNTIME_DEBUG
-	if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
+          printf("SWIG_InitializeModule: found cast %s\n", target_type->name);
 #endif
-      }
-      if (ret) {
-	if (type == swig_module.type_initial[i]) {
+          if (type == swig_module.type_initial[i]) {
 #ifdef SWIGRUNTIME_DEBUG
-	  printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
+            printf("SWIG_InitializeModule: skip old type %s\n", target_type->name);
 #endif
-	  cast->type = ret;
-	  ret = 0;
-	} else {
-	  /* Check for casting already in the list */
-	  swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
+            cast->type = target_type;
+            target_type = 0;
+          } else {
+            /* Check if this cast is already in the list */
+            swig_cast_info *ocast = SWIG_TypeCheck(target_type->name, type);
 #ifdef SWIGRUNTIME_DEBUG
-	  if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
+            if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", target_type->name);
 #endif
-	  if (!ocast) ret = 0;
-	}
+            if (!ocast) target_type = 0;
+          }
+        }
       }
 
-      if (!ret) {
+      if (!target_type) {
+#ifdef SWIGRUNTIME_DEBUG
+        printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
+#endif
+        /* Set inclusion mark for sorting */
+        cast->next = cast;
+        num_mapped++;
+
+        if (type == cast->type) {
 #ifdef SWIGRUNTIME_DEBUG
-	printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
+          printf("%s : self cast at pos [%li]\n", type->name, cast - first);
 #endif
-        if (type->cast) {
-          type->cast->prev = cast;
-          cast->next = type->cast;
+          if (cast - first) {
+
+            /* Move cast to itself to the first entry in the array */
+
+            swig_cast_info tmp = *cast;
+            *cast = *first;
+            *first = tmp;
+          }
+          first++;
+
+        } else {
+          cast->value = SWIG_Hash(cast->type->name, (unsigned int)strlen(cast->type->name));
         }
-        type->cast = cast;
       }
       cast++;
     }
+
+    if (num_mapped) {
+      if (cast - first) {
+        swig_cast_info *tmp;
+
+        /* Sort casts by type address for binary search in SWIG_TypeCheckStruct */
+        qsort(first, cast - first, sizeof(swig_cast_info), SWIG_CastCmpStruct);
+
+        /* Remap back links for added entries */
+        cast = swig_module.cast_initial[i] + num_mapped;
+        for (tmp = first; tmp < cast; tmp++) {
+          tmp->next = tmp;
+        }
+      }
+
+      /* Set the value field of the first entry to the index of the last added entry */
+      cast = swig_module.cast_initial[i];
+      cast->value = num_mapped - 1;
+
+      num_mapped -= (int)(first - cast);
+      if (num_mapped > 1) {
+        /* Sort <'next','value'> pairs by 'value' for binary search in SWIG_TypeCheck */
+
+        SWIG_CastHashSort(first, num_mapped);
+      }
+
+      first = type->cast;
+      if (first) {
+        /* Link the current set into the list of cast arrays */
+        cast->next = first->next;
+        first->next = cast;
+      } else {
+        cast->next = 0;
+        type->cast = cast;
+      }
+    }
+
     /* Set entry in modules->types array equal to the type */
     swig_module.types[i] = type;
   }
@@ -2303,7 +2650,7 @@ SWIG_InitializeModule(void *clientdata) {
   for (i = 0; i < swig_module.size; ++i) {
     int j = 0;
     swig_cast_info *cast = swig_module.cast_initial[i];
-    printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
+    printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
     while (cast->type) {
       printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
       cast++;
@@ -2323,7 +2670,6 @@ SWIG_InitializeModule(void *clientdata) {
 SWIGRUNTIME void
 SWIG_PropagateClientData(void) {
   size_t i;
-  swig_cast_info *equiv;
   static int init_run = 0;
 
   if (init_run) return;
@@ -2331,13 +2677,16 @@ SWIG_PropagateClientData(void) {
 
   for (i = 0; i < swig_module.size; i++) {
     if (swig_module.types[i]->clientdata) {
-      equiv = swig_module.types[i]->cast;
-      while (equiv) {
-        if (!equiv->converter) {
-          if (equiv->type && !equiv->type->clientdata)
-            SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
+      swig_cast_info *head, *cast;
+      head = swig_module.types[i]->cast;
+      while (head) {
+        for (cast = head; (cast - head) <= head->value; cast++) {
+          if (!cast->converter) {
+            if (cast->type && !cast->type->clientdata)
+              SWIG_TypeClientData(cast->type, swig_module.types[i]->clientdata);
+          }
         }
-        equiv = equiv->next;
+        head = head->next;
       }
     }
   }