fxruby 1.6.50 → 1.6.51

data/ext/fox16_c/swigruby.h

@@ -1,11 +1,41 @@
 /* ----------------------------------------------------------------------------
  * This file was automatically generated by SWIG (https://www.swig.org).
- * Version 4.2.0
+ * Version 4.5.0
  *
  * Do not make changes to this file unless you know what you are doing - modify
  * the SWIG interface file instead.
  * ----------------------------------------------------------------------------- */
 
+#ifndef SWIG_RUNTIME_HEADER_
+#define SWIG_RUNTIME_HEADER_
+
+/* -----------------------------------------------------------------------------
+ * 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.
@@ -130,11 +160,14 @@
 # pragma warning disable 592
 #endif
 
-#if __cplusplus >=201103L
-# define SWIG_NULLPTR nullptr
+#if defined(__cplusplus) && __cplusplus >= 201103L
+# define SWIG_NOEXCEPT noexcept
 #else
-# define SWIG_NULLPTR NULL
+# define SWIG_NOEXCEPT throw()
 #endif 
+
+#define SWIG_QUOTE_STRING(x) #x
+#define SWIG_STRINGIFY(x) SWIG_QUOTE_STRING(x)
 /* SWIG Errors applicable to all language modules, values are reserved from -1 to -99 */
 #define  SWIG_UnknownError    	   -1
 #define  SWIG_IOError        	   -2
@@ -159,13 +192,11 @@
 
 /* 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
-# define SWIG_QUOTE_STRING(x) #x
-# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
-# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
+# define SWIG_TYPE_TABLE_NAME SWIG_STRINGIFY(SWIG_TYPE_TABLE)
 #else
 # define SWIG_TYPE_TABLE_NAME
 #endif
@@ -333,23 +364,6 @@ SWIGINTERNINLINE int SWIG_CheckState(int r) {
 #  define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
 #endif
 
-/* 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
 
 #include <string.h>
 
@@ -374,8 +388,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
@@ -436,55 +450,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 -= (int)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(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;
@@ -547,20 +653,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; (unsigned int)(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);
@@ -699,7 +809,7 @@ SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
   if ((2*sizeof(void *) + 2) > bsz) return 0;
   *(r++) = '_';
   r = SWIG_PackData(r,&ptr,sizeof(void *));
-  if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
+  if (strlen(name) + 1 > (bsz - (size_t)(r - buff))) return 0;
   strcpy(r,name);
   return buff;
 }
@@ -761,20 +871,7 @@ SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
 #endif
 #endif
 
-      #include <ruby.h>
-
-      #if defined(RB_METHOD_DEFINITION_DECL)
-      # define RUBY_VALUE_METHOD_FUNC(func) (func)
-      # define RUBY_INT_METHOD_FUNC(func) (func)
-      # define RUBY_VOID_METHOD_FUNC(func) (func)
-      # define RUBY_VOIDP_METHOD_FUNC(func) (func)
-      #else
-      # define RUBY_VALUE_METHOD_FUNC(func) ((VALUE (*)(ANYARGS))(func))
-      # define RUBY_INT_METHOD_FUNC(func) ((int (*)(ANYARGS))(func))
-      # define RUBY_VOID_METHOD_FUNC(func) ((void (*)(ANYARGS))(func))
-      # define RUBY_VOIDP_METHOD_FUNC(func) ((void *(*)(ANYARGS))(func))
-      #endif
-
+#include <ruby.h>
 #include <ruby/version.h> /* For RUBY_API_VERSION_CODE */
 
 #if __GNUC__ >= 7
@@ -875,7 +972,15 @@ SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
 #ifndef RTYPEDDATA_P
 # define RTYPEDDATA_P(x) (TYPE(x) != T_DATA)
 #endif
+#ifndef TYPED_DATA_EMBEDDED
+# define RTYPEDDATA_GET_DATA(x) RTYPEDDATA_DATA(x)
+#endif
 
+struct ruby_wrapped_object {
+  void *data;
+  void (*dmark)(void *);
+  void (*dfree)(void *);
+};
 
 
 /*
@@ -957,15 +1062,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;
@@ -973,10 +1075,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;
@@ -1214,7 +1314,7 @@ SWIGRUNTIME void SWIG_RubyUnlinkObjects(void* ptr) {
     // 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;
+    ((struct ruby_wrapped_object *)RTYPEDDATA_GET_DATA(object))->data = 0;
   }
 }
 
@@ -1246,8 +1346,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) {
@@ -1344,6 +1444,7 @@ typedef struct {
   VALUE mImpl;
   void  (*mark)(void *);
   void  (*destroy)(void *);
+  rb_data_type_t cext_type;
   int trackObjects;
 } swig_class;
 
@@ -1389,10 +1490,8 @@ static ID swig_lowerthan_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;
@@ -1439,6 +1538,27 @@ SWIG_Ruby_define_class(swig_type_info *type)
   free((void *) klass_name);
 }
 
+static void SWIG_Ruby_mark_swig_type(void *_wrobj)
+{
+  struct ruby_wrapped_object *wrobj = (struct ruby_wrapped_object *)_wrobj;
+  if (wrobj->dmark) {
+    wrobj->dmark(wrobj->data);
+  }
+}
+
+static void SWIG_Ruby_free_swig_type(void *_wrobj)
+{
+  struct ruby_wrapped_object *wrobj = (struct ruby_wrapped_object *)_wrobj;
+  if (wrobj->dfree) {
+    wrobj->dfree(wrobj->data);
+  }
+  free(wrobj);
+}
+
+static const rb_data_type_t swig_type_type = {
+    .wrap_struct_name = "swig_type"
+};
+
 /* Create a new pointer object */
 SWIGRUNTIME VALUE
 SWIG_Ruby_NewPointerObj(void *ptr, swig_type_info *type, int flags)
@@ -1449,6 +1569,7 @@ SWIG_Ruby_NewPointerObj(void *ptr, swig_type_info *type, int flags)
   swig_class *sklass;
   VALUE klass;
   VALUE obj;
+  struct ruby_wrapped_object *wrobj;
 
   if (!ptr)
     return Qnil;
@@ -1476,10 +1597,11 @@ SWIG_Ruby_NewPointerObj(void *ptr, swig_type_info *type, int flags)
     }
 
     /* Create a new Ruby object */
-    obj = Data_Wrap_Struct(sklass->klass, VOIDFUNC(sklass->mark), 
-			   ( own ? VOIDFUNC(sklass->destroy) : 
-			     (track ? VOIDFUNC(SWIG_RubyRemoveTracking) : 0 )
-			     ), ptr);
+    obj = TypedData_Make_Struct(sklass->klass, struct ruby_wrapped_object, &sklass->cext_type, wrobj);
+    wrobj->data = ptr;
+    wrobj->dmark = sklass->mark;
+    wrobj->dfree = own ? sklass->destroy:
+                  (track ? VOIDFUNC(SWIG_RubyRemoveTracking) : 0 );
 
     /* If tracking is on for this class then track this object. */
     if (track) {
@@ -1491,7 +1613,11 @@ SWIG_Ruby_NewPointerObj(void *ptr, swig_type_info *type, int flags)
     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);
+
+    obj = TypedData_Make_Struct(klass, struct ruby_wrapped_object, &swig_type_type, wrobj);
+    wrobj->data = ptr;
+    wrobj->dmark = 0;
+    wrobj->dfree = 0;
   }
   rb_iv_set(obj, "@__swigtype__", rb_str_new2(type->name));
 
@@ -1504,7 +1630,13 @@ SWIG_Ruby_NewClassInstance(VALUE klass, swig_type_info *type)
 {
   VALUE obj;
   swig_class *sklass = (swig_class *) type->clientdata;
-  obj = Data_Wrap_Struct(klass, VOIDFUNC(sklass->mark), VOIDFUNC(sklass->destroy), 0);
+  struct ruby_wrapped_object *wrobj;
+
+  obj = TypedData_Make_Struct(klass, struct ruby_wrapped_object, &sklass->cext_type, wrobj);
+  wrobj->data = 0;
+  wrobj->dmark = sklass->mark;
+  wrobj->dfree = sklass->destroy;
+
   rb_iv_set(obj, "@__swigtype__", rb_str_new2(type->name));
   return obj;
 }
@@ -1528,9 +1660,10 @@ typedef struct {
 SWIGRUNTIME swig_ruby_owntype
 SWIG_Ruby_AcquirePtr(VALUE obj, swig_ruby_owntype own) {
   swig_ruby_owntype oldown = {0, 0};
-  if (TYPE(obj) == T_DATA && !RTYPEDDATA_P(obj)) {
-    oldown.datafree = RDATA(obj)->dfree;
-    RDATA(obj)->dfree = own.datafree;
+  if (RB_TYPE_P(obj, RUBY_T_DATA) && RTYPEDDATA_P(obj)) {
+    struct ruby_wrapped_object *wrobj = (struct ruby_wrapped_object *)RTYPEDDATA_GET_DATA(obj);
+    oldown.datafree = wrobj->dfree;
+    wrobj->dfree = own.datafree;
   }
   return oldown;
 }
@@ -1542,26 +1675,27 @@ SWIG_Ruby_ConvertPtrAndOwn(VALUE obj, void **ptr, swig_type_info *ty, int flags,
   char *c;
   swig_cast_info *tc;
   void *vptr = 0;
+  struct ruby_wrapped_object *wrobj;
 
   /* Grab the pointer */
   if (NIL_P(obj)) {
     if (ptr)
       *ptr = 0;
     return (flags & SWIG_POINTER_NO_NULL) ? SWIG_NullReferenceError : SWIG_OK;
+  } else if (RB_TYPE_P(obj, RUBY_T_DATA) && RTYPEDDATA_P(obj)) {
+    wrobj = (struct ruby_wrapped_object *)RTYPEDDATA_GET_DATA(obj);
+    vptr = wrobj->data;
   } else {
-    if (TYPE(obj) != T_DATA || (TYPE(obj) == T_DATA && RTYPEDDATA_P(obj))) {
-      return SWIG_ERROR;
-    }
-    Data_Get_Struct(obj, void, vptr);
+    return SWIG_ERROR;
   }
   
   if (own) {
-    own->datafree = RDATA(obj)->dfree;
+    own->datafree = wrobj->dfree;
     own->own = 0;
   }
     
   if (((flags & SWIG_POINTER_RELEASE) == SWIG_POINTER_RELEASE)) {
-    if (!RDATA(obj)->dfree)
+    if (!wrobj->dfree)
       return SWIG_ERROR_RELEASE_NOT_OWNED;
   }
 
@@ -1584,14 +1718,14 @@ SWIG_Ruby_ConvertPtrAndOwn(VALUE obj, void **ptr, swig_type_info *ty, int flags,
        * when the Ruby object is garbage collected.  If we don't
        * do this, then it is possible we will return a reference 
        * to a Ruby object that no longer exists thereby crashing Ruby. */
-      RDATA(obj)->dfree = SWIG_RubyRemoveTracking;
+      wrobj->dfree = SWIG_RubyRemoveTracking;
     } else {    
-      RDATA(obj)->dfree = 0;
+      wrobj->dfree = 0;
     }
   }
 
   if (flags & SWIG_POINTER_CLEAR) {
-    DATA_PTR(obj) = 0;
+    wrobj->data = 0;
   }
 
   /* Do type-checking if type info was provided */
@@ -1675,6 +1809,11 @@ SWIG_Ruby_ConvertPacked(VALUE obj, void *ptr, int sz, swig_type_info *ty) {
   return SWIG_ERROR;
 }
 
+
+static const rb_data_type_t swig_runtime_data_type = {
+    .wrap_struct_name = "swig_runtime_data" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME
+};
+
 SWIGRUNTIME swig_module_info *
 SWIG_Ruby_GetModule(void *SWIGUNUSEDPARM(clientdata))
 {
@@ -1684,11 +1823,13 @@ SWIG_Ruby_GetModule(void *SWIGUNUSEDPARM(clientdata))
 
  /* temporarily disable warnings, since the pointer check causes warnings with 'ruby -w' */
   rb_gv_set("VERBOSE", Qfalse);
-  
+
   /* first check if pointer already created */
   pointer = rb_gv_get("$swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME);
   if (pointer != Qnil) {
-    Data_Get_Struct(pointer, swig_module_info, ret);
+    /* Can not use TypedData_Get_Struct because swig_runtime_data_type is not global, but once per file. */
+    if (!RB_TYPE_P(pointer, RUBY_T_DATA)) rb_check_typeddata(pointer, &swig_runtime_data_type);
+    ret = (swig_module_info *)RTYPEDDATA_GET_DATA(pointer);
   }
 
   /* reinstate warnings */
@@ -1700,10 +1841,10 @@ SWIGRUNTIME void
 SWIG_Ruby_SetModule(swig_module_info *pointer)
 {
   /* register a new class */
-  VALUE cl = rb_define_class("SWIG_RUNTIME_DATA", rb_cObject);rb_undef_alloc_func(cl);
+  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);
+  swig_runtime_data_type_pointer = TypedData_Wrap_Struct(cl, &swig_runtime_data_type, pointer);
   rb_define_readonly_variable("$swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, &swig_runtime_data_type_pointer);
 }
 
@@ -1783,3 +1924,5 @@ SWIG_MangledTypeQuery(const char *name) {
 }
 
 #endif
+
+#endif /* SWIG_RUNTIME_HEADER_ */