wxruby3 1.6.1 → 1.8.0

data/ext/wxruby3/include/wxruby-SharedPtr.h

@@ -0,0 +1,104 @@
+// Copyright (c) 2023 M.J.N. Corino, The Netherlands
+//
+// This software is released under the MIT license.
+
+#ifndef _WXRUBY_SHAREDPTR_H_
+#define _WXRUBY_SHAREDPTR_H_
+
+/*
+  A shared pointer class to wrap wxSharedPtr for derived classes and allowing implicit
+  conversion to wxSharedPtr without loosing reference counting and implicit down casting.
+*/
+#include <wx/sharedptr.h>
+
+template <class T, class Base = T>
+class WxRubySharedPtr
+{
+public:
+  typedef T* ptr_t;
+  typedef wxSharedPtr<Base> shared_ptr_t;
+
+  explicit WxRubySharedPtr( T* ptr = nullptr )
+    : shared_ptr_(ptr)
+  {
+  }
+
+  WxRubySharedPtr(const WxRubySharedPtr& other)
+    : shared_ptr_(other.get_shared())
+  {}
+
+  WxRubySharedPtr(WxRubySharedPtr&& other)
+    : shared_ptr_(std::move (other.get_shared()))
+  {}
+
+#if !defined(SWIG)
+  template<typename _Tp1, typename = typename
+    std::enable_if<std::is_convertible<typename _Tp1::ptr_t, T*>::value>::type>
+  WxRubySharedPtr(const _Tp1& other)
+    : shared_ptr_(other.get_shared())
+  {}
+
+  template<typename _Tp1, typename = typename
+    std::enable_if<std::is_convertible<typename _Tp1::ptr_t, T*>::value>::type>
+  WxRubySharedPtr(_Tp1&& other)
+    : shared_ptr_(std::move(other.get_shared()))
+  {}
+#endif
+
+  WxRubySharedPtr& operator=(const WxRubySharedPtr& other)
+  {
+    this->shared_ptr_ = other.get_shared();
+    return *this;
+  }
+
+  WxRubySharedPtr& operator=( T* ptr )
+  {
+    this->shared_ptr_ = ptr;
+    return *this;
+  }
+
+#if !defined(SWIG)
+  template<typename _Tp1, typename = typename
+    std::enable_if<std::is_convertible<typename _Tp1::ptr_t, T*>::value>::type>
+  WxRubySharedPtr& operator=(const _Tp1& other)
+  {
+    this->shared_ptr_ = other.get_shared();
+    return *this;
+  }
+#endif
+
+  T* operator->()
+  {
+    return const_cast<T*> (this->_get());
+  }
+
+  const T* operator->() const
+  {
+    return this->_get();
+  }
+
+  const T* get() const
+  {
+    return this->_get();
+  }
+
+  void reset( T* ptr = nullptr )
+  {
+    this->shared_ptr_.reset(ptr);
+  }
+
+  shared_ptr_t get_shared() const { return this->shared_ptr_; }
+
+  operator shared_ptr_t() const { return this->get_shared(); }
+
+private:
+
+  const T* _get() const
+  {
+    return dynamic_cast<const T*> (this->shared_ptr_.get());
+  }
+
+  shared_ptr_t shared_ptr_;
+};
+
+#endif

data/ext/wxruby3/include/wxruby-runtime.h

@@ -39,8 +39,85 @@ private:
 
 // Exported runtime helper methods
 
+// Debug tracing support
 #ifdef __WXRB_DEBUG__
-WXRUBY_EXPORT int wxRuby_TraceLevel();
+#include <cstdlib>
+#include <string>
+#include <algorithm>
+#include <ctype.h>
+
+class WxRubyTraceGuard
+{
+public:
+  WxRubyTraceGuard(const std::string& trace_id)
+  {
+    std::string trace_env_id = to_uppercase(trace_id);
+    while (!trace_env_id.empty())
+    {
+      // see if we can find a trace setting which starts with 'WXRUBY_TRACE_'
+      // followed by the trace id
+      std::string trace_env_var = std::string("WXRUBY_TRACE_") + trace_env_id;
+      char* env_val = std::getenv(trace_env_var.c_str());
+      if (env_val)
+      {
+        // trace setting found
+        this->_trace_lvl = std::atoi(env_val);
+        break; // done
+      }
+      // see if there is a parent trace category we can check
+      std::string::size_type offs = trace_env_id.find_last_of('_');
+      if (offs != std::string::npos )
+      {
+        // reduce the id to possible parent category
+        trace_env_id = trace_env_id.substr(0, offs);
+      }
+
+      if (offs == std::string::npos || trace_env_id.empty())
+      {
+        // check for global tracing
+        env_val = std::getenv("WXRUBY_TRACE");
+        if (env_val)
+        {
+          // trace setting found
+          this->_trace_lvl = std::atoi(env_val);
+        }
+        break; // done
+      }
+    }
+  }
+
+  int trace_level() { return this->_trace_lvl; }
+
+private:
+  std::string to_uppercase(std::string s)
+  {
+    std::transform(s.begin(), s.end(), s.begin(), [](unsigned char c){ return std::toupper(c); });
+    return s;
+  }
+
+  int _trace_lvl {};
+};
+
+#define WXRUBY_TRACE_GUARD(name, trace_id) static WxRubyTraceGuard name (trace_id);
+
+#define WXRUBY_TRACE_IF(__trace_guard__, __level__) \
+  if (__trace_guard__.trace_level() >= __level__) {
+
+#define WXRUBY_TRACE_WITH(__stmt__) __stmt__ ;
+
+#define WXRUBY_TRACE(__stmt__) \
+  std::wcout << __stmt__ << std::endl;
+
+#define WXRUBY_TRACE_END }
+
+#else
+
+#define WXRUBY_TRACE_GUARD(name, trace_id)
+#define WXRUBY_TRACE_IF(__trace_guard__, __level__)
+#define WXRUBY_TRACE_WITH(__stmt__)
+#define WXRUBY_TRACE(__stmt__)
+#define WXRUBY_TRACE_END
+
 #endif
 
 WXRUBY_EXPORT VALUE wxRuby_Funcall(VALUE rcvr, ID func, int argc, ...);
@@ -57,6 +134,35 @@ WXRUBY_EXPORT void wxRuby_AppendMarker(WXRBMarkFunction marker);
 WXRUBY_EXPORT VALUE wxRuby_GetTopLevelWindowClass(); // used for wxWindow typemap in typemap.i
 WXRUBY_EXPORT bool GC_IsWindowDeleted(void *ptr);
 
+WXRUBY_EXPORT bool GC_IsObjectOwned(VALUE object);
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+WXRUBY_EXPORT void wxRuby_InitializeTracking();
+WXRUBY_EXPORT void wxRuby_AddTracking(void* ptr, VALUE object);
+WXRUBY_EXPORT VALUE wxRuby_FindTracking(void* ptr);
+WXRUBY_EXPORT void wxRuby_RemoveTracking(void* ptr);
+WXRUBY_EXPORT void wxRuby_UnlinkObject(void* ptr);
+
+#ifdef __cplusplus
+}
+#endif
+
+#include <unordered_map>
+
+typedef std::unordered_map<void*, VALUE>  TGCTrackingValueMap;
+typedef void (* TGCMarkerFunction)(const TGCTrackingValueMap&);
+
+WXRUBY_EXPORT void wxRuby_RegisterTrackingCategory(std::string category, TGCMarkerFunction marker, bool has_data = false);
+WXRUBY_EXPORT void wxRuby_RegisterCategoryValue(const std::string &category, void *ptr, VALUE object);
+WXRUBY_EXPORT void wxRuby_UnregisterCategoryValue(const std::string &category, void *ptr);
+WXRUBY_EXPORT VALUE wxRuby_FindCategoryValue(const std::string &category, void *ptr);
+WXRUBY_EXPORT void wxRuby_UnlinkCategoryValue(const std::string &category, void* ptr);
+
+WXRUBY_EXPORT void wxRuby_MarkTracked();
+
 // Defined in wx.i; getting, setting and using swig_type <-> ruby class
 // mappings
 WXRUBY_EXPORT swig_type_info* wxRuby_GetSwigTypeForClass(VALUE cls);

data/ext/wxruby3/swig/common.i

@@ -134,8 +134,8 @@
 #include <wx/variant.h>
 #endif
 
-#if ! wxCHECK_VERSION(3,1,5)
-#error "This version of wxRuby requires WxWidgets 3.1.5 or greater"
+#if ! wxCHECK_VERSION(3,2,0)
+#error "This version of wxRuby requires WxWidgets 3.2.0 or greater"
 #endif
 
 #include "wxruby-runtime.h"

data/ext/wxruby3/swig/custom/director.swg

@@ -109,7 +109,7 @@ namespace Swig {
     void setup_error(VALUE error);
 
   public:
-    virtual ~DirectorException() throw();
+    virtual ~DirectorException() SWIG_NOEXCEPT;
 
     VALUE getType() const
     {
@@ -127,7 +127,7 @@ namespace Swig {
       return swig_msg;
     }
 
-    const char *what() const throw()
+    const char *what() const SWIG_NOEXCEPT
     {
       return swig_msg.c_str();
     }

data/ext/wxruby3/swig/custom/rubyprimtypes.swg

@@ -7,6 +7,8 @@
 
 /* auxiliary ruby fail method */
 
+// SWIG < 4.4.0
+#if SWIG_VERSION < 0x040400
 %fragment("SWIG_ruby_failed","header")
 {
 SWIGINTERN VALUE
@@ -15,18 +17,16 @@ SWIG_ruby_failed(void)
   return Qnil;
 } 
 }
-
-%define %ruby_aux_method(Type, Method, Action)
-SWIGINTERN VALUE SWIG_AUX_##Method##(VALUE *args)
+#else
+%fragment("SWIG_ruby_failed","header")
 {
-  VALUE obj = args[0];
-  VALUE type = TYPE(obj);
-  Type *res = (Type *)(args[1]);
-  *res = Action;
-  return obj;
+SWIGINTERN VALUE
+SWIG_ruby_failed(VALUE SWIGUNUSEDPARM(arg1), VALUE SWIGUNUSEDPARM(arg2))
+{
+  return Qnil;
 }
-%enddef
-
+}
+#endif
 
 /* boolean */
 
@@ -68,7 +68,14 @@ SWIG_AsVal_dec(bool)(VALUE obj, bool *val)
 }
 
 %fragment(SWIG_AsVal_frag(long),"header",fragment="SWIG_ruby_failed") {
-%ruby_aux_method(long, NUM2LONG, (type != T_BIGNUM) ? NUM2LONG(obj) : rb_big2long(obj))
+SWIGINTERN VALUE SWIG_AUX_NUM2LONG(VALUE* args)
+{
+  VALUE obj = args[0];
+  VALUE type = TYPE(obj);
+  long *res = (long *)(args[1]);
+  *res = (type != T_BIGNUM) ? NUM2LONG(obj) : rb_big2long(obj);
+  return obj;
+}
 
 SWIGINTERN int
 SWIG_AsVal_dec(long)(VALUE obj, long* val)
@@ -100,7 +107,14 @@ SWIG_From_dec(unsigned long)(unsigned long value)
 }
 
 %fragment(SWIG_AsVal_frag(unsigned long),"header",fragment="SWIG_ruby_failed") {
-%ruby_aux_method(unsigned long, NUM2ULONG, (type != T_BIGNUM) ? NUM2ULONG(obj) : rb_big2ulong(obj))
+SWIGINTERN VALUE SWIG_AUX_NUM2ULONG(VALUE* args)
+{
+  VALUE obj = args[0];
+  VALUE type = TYPE(obj);
+  unsigned long *res = (unsigned long *)(args[1]);
+  *res = (type != T_BIGNUM) ? NUM2ULONG(obj) : rb_big2ulong(obj);
+  return obj;
+}
 
 SWIGINTERN int
 SWIG_AsVal_dec(unsigned long)(VALUE obj, unsigned long *val) 
@@ -112,6 +126,10 @@ SWIG_AsVal_dec(unsigned long)(VALUE obj, unsigned long *val)
     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 SWIG_VERSION >= 0x040400
+      if (rb_funcall(obj, swig_lowerthan_id, 1, INT2FIX(0)) != Qfalse)
+        return SWIG_OverflowError;
+#endif
       if (val) *val = v;
       return SWIG_OK;
     }
@@ -138,7 +156,14 @@ SWIG_From_dec(long long)(long long value)
 	  fragment="SWIG_ruby_failed",
 	  fragment="SWIG_LongLongAvailable") {
 %#ifdef SWIG_LONG_LONG_AVAILABLE
-%ruby_aux_method(long long, NUM2LL, (type != T_BIGNUM) ? NUM2LL(obj) : rb_big2ll(obj))
+SWIGINTERN VALUE SWIG_AUX_NUM2LL(VALUE* args)
+{
+  VALUE obj = args[0];
+  VALUE type = TYPE(obj);
+  long long *res = (long long *)(args[1]);
+  *res = (type != T_BIGNUM) ? NUM2LL(obj) : rb_big2ll(obj);
+  return obj;
+}
 
 SWIGINTERN int
 SWIG_AsVal_dec(long long)(VALUE obj, long long *val)
@@ -176,7 +201,14 @@ SWIG_From_dec(unsigned long long)(unsigned long long value)
 	  fragment="SWIG_ruby_failed",
 	  fragment="SWIG_LongLongAvailable") {
 %#ifdef SWIG_LONG_LONG_AVAILABLE
-%ruby_aux_method(long long, NUM2ULL,  (type != T_BIGNUM) ? NUM2ULL(obj) : rb_big2ull(obj))
+SWIGINTERN VALUE SWIG_AUX_NUM2ULL(VALUE* args)
+{
+  VALUE obj = args[0];
+  VALUE type = TYPE(obj);
+  long long *res = (long long *)(args[1]);
+  *res = (type != T_BIGNUM) ? NUM2ULL(obj) : rb_big2ull(obj);
+  return obj;
+}
 
 SWIGINTERN int
 SWIG_AsVal_dec(unsigned long long)(VALUE obj, unsigned long long *val)
@@ -188,6 +220,10 @@ SWIG_AsVal_dec(unsigned long long)(VALUE obj, unsigned long long *val)
     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 SWIG_VERSION >= 0x040400
+      if (rb_funcall(obj, swig_lowerthan_id, 1, INT2FIX(0)) != Qfalse)
+        return SWIG_OverflowError;
+#endif
       if (val) *val = v;
       return SWIG_OK;
     }
@@ -204,7 +240,15 @@ SWIG_AsVal_dec(unsigned long long)(VALUE obj, unsigned long long *val)
 }
 
 %fragment(SWIG_AsVal_frag(double),"header",fragment="SWIG_ruby_failed") {
-%ruby_aux_method(double, NUM2DBL, NUM2DBL(obj); (void)type)
+SWIGINTERN VALUE SWIG_AUX_NUM2DBL(VALUE* args)
+{
+  //VALUE *args = (VALUE *)arg;
+  VALUE obj = args[0];
+  VALUE type = TYPE(obj);
+  double *res = (double *)(args[1]);
+  *res = NUM2DBL(obj); (void)type;
+  return obj;
+}
 
 SWIGINTERN int
 SWIG_AsVal_dec(double)(VALUE obj, double *val)

data/ext/wxruby3/swig/custom/rubyrun.swg

@@ -77,6 +77,10 @@ typedef struct WXRUBY_EXPORT swig_class {
   int trackObjects;
 } swig_class;
 
+#if SWIG_VERSION >= 0x040400
+extern ID swig_lowerthan_id;
+#endif
+
 /*
   If your swig extension is to be run within an embedded ruby and has
   director callbacks, you should set -DRUBY_EMBEDDED during compilation.  

data/ext/wxruby3/swig/custom/rubytracking.swg

@@ -15,43 +15,33 @@ extern "C" {
 #endif
 
 // Shared custom swig tracking functions
+WXRUBY_EXPORT void wxRuby_InitializeTracking();
 WXRUBY_EXPORT void wxRuby_AddTracking(void* ptr, VALUE object);
 WXRUBY_EXPORT VALUE wxRuby_FindTracking(void* ptr);
 WXRUBY_EXPORT void wxRuby_RemoveTracking(void* ptr);
-WXRUBY_EXPORT void wxRuby_IterateTracking( void(*meth)(void* ptr, VALUE obj) );
 
-/* Setup a Ruby hash table to store Trackings - mostly done in wx.i */
-SWIGRUNTIMEINLINE void SWIG_RubyInitializeTrackings(void) {
-  // no-op
-}
+/* Setup a Ruby hash table to store Trackings */
+#define SWIG_RubyInitializeTrackings()
 
 /* Add a Tracking from a C/C++ struct to a Ruby object */
-SWIGRUNTIMEINLINE void SWIG_RubyAddTracking(void* ptr, VALUE object) {
-  wxRuby_AddTracking(ptr, object);
-}
+#define SWIG_RubyAddTracking wxRuby_AddTracking
 
 /* Get the Ruby object that owns the specified C/C++ struct */
-SWIGRUNTIMEINLINE VALUE SWIG_RubyInstanceFor(void* ptr) {
-  return wxRuby_FindTracking(ptr);
-}
+#define SWIG_RubyInstanceFor wxRuby_FindTracking
 
 /* Remove a Tracking from a C/C++ struct to a Ruby object.  It
    is very important to remove objects once they are destroyed
    since the same memory address may be reused later to create
    a new object. */
-SWIGRUNTIMEINLINE void SWIG_RubyRemoveTracking(void* ptr) {
-  wxRuby_RemoveTracking(ptr);
-}
+#define SWIG_RubyRemoveTracking wxRuby_RemoveTracking
 
 /* 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 */
-SWIGRUNTIMEINLINE void SWIG_RubyUnlinkObjects(void* ptr) {
-  VALUE object = SWIG_RubyInstanceFor(ptr);
+#define SWIG_RubyUnlinkObjects wxRuby_UnlinkObject
 
-  if (object != Qnil) {
-    DATA_PTR(object) = 0;
-  }
+SWIGRUNTIMEINLINE void SWIG_RubyIterateTrackings( void(*meth)(void* ptr, VALUE obj) ) {
+  // noop
 }
 
 

data/ext/wxruby3/swig/custom/swiglabels.swg

@@ -0,0 +1,129 @@
+/* -----------------------------------------------------------------------------
+ *  This section contains generic SWIG labels for method/variable
+ *  declarations/attributes, and other compiler dependent labels.
+ * ----------------------------------------------------------------------------- */
+
+/* template workaround for compilers that cannot correctly implement the C++ standard */
+#ifndef SWIGTEMPLATEDISAMBIGUATOR
+# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
+#  define SWIGTEMPLATEDISAMBIGUATOR template
+# elif defined(__HP_aCC)
+/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
+/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
+#  define SWIGTEMPLATEDISAMBIGUATOR template
+# else
+#  define SWIGTEMPLATEDISAMBIGUATOR
+# endif
+#endif
+
+/* inline attribute */
+#ifndef SWIGINLINE
+# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
+#   define SWIGINLINE inline
+# else
+#   define SWIGINLINE
+# endif
+#endif
+
+/* attribute recognised by some compilers to avoid 'unused' warnings */
+#ifndef SWIGUNUSED
+# if defined(__GNUC__)
+#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
+#     define SWIGUNUSED __attribute__ ((__unused__))
+#   else
+#     define SWIGUNUSED
+#   endif
+# elif defined(__ICC)
+#   define SWIGUNUSED __attribute__ ((__unused__))
+# else
+#   define SWIGUNUSED
+# endif
+#endif
+
+#ifndef SWIG_MSC_UNSUPPRESS_4505
+# if defined(_MSC_VER)
+#   pragma warning(disable : 4505) /* unreferenced local function has been removed */
+# endif
+#endif
+
+#ifndef SWIGUNUSEDPARM
+# ifdef __cplusplus
+#   define SWIGUNUSEDPARM(p)
+# else
+#   define SWIGUNUSEDPARM(p) p SWIGUNUSED
+# endif
+#endif
+
+/* internal SWIG method */
+#ifndef SWIGINTERN
+# define SWIGINTERN static SWIGUNUSED
+#endif
+
+/* internal inline SWIG method */
+#ifndef SWIGINTERNINLINE
+# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
+#endif
+
+/* exporting methods */
+#if defined(__GNUC__)
+#  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
+#    ifndef GCC_HASCLASSVISIBILITY
+#      define GCC_HASCLASSVISIBILITY
+#    endif
+#  endif
+#endif
+
+#ifndef SWIGEXPORT
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+#   if defined(STATIC_LINKED)
+#     define SWIGEXPORT
+#   else
+#     define SWIGEXPORT __declspec(dllexport)
+#   endif
+# else
+#   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
+#     define SWIGEXPORT __attribute__ ((visibility("default")))
+#   else
+#     define SWIGEXPORT
+#   endif
+# endif
+#endif
+
+/* calling conventions for Windows */
+#ifndef SWIGSTDCALL
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+#   define SWIGSTDCALL __stdcall
+# else
+#   define SWIGSTDCALL
+# endif
+#endif
+
+/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
+#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
+# define _CRT_SECURE_NO_DEPRECATE
+#endif
+
+/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
+#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
+# define _SCL_SECURE_NO_DEPRECATE
+#endif
+
+/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
+#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
+# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
+#endif
+
+/* Intel's compiler complains if a variable which was never initialised is
+ * cast to void, which is a common idiom which we use to indicate that we
+ * are aware a variable isn't used.  So we just silence that warning.
+ * See: https://github.com/swig/swig/issues/192 for more discussion.
+ */
+#ifdef __INTEL_COMPILER
+# pragma warning disable 592
+#endif
+
+#if defined(__cplusplus) && __cplusplus >=201103L
+# define SWIG_NOEXCEPT noexcept
+#else
+# define SWIG_NOEXCEPT throw()
+#endif 

data/ext/wxruby3/swig/custom/swigrun.swg

@@ -12,7 +12,11 @@
 
 /* This should only be incremented when either the layout of swig_type_info changes,
    or for whatever reason, the runtime changes incompatibly */
+#if SWIG_VERSION < 0x040400
 #define SWIG_RUNTIME_VERSION "4"
+#else
+#define SWIG_RUNTIME_VERSION "5"
+#endif
 
 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
 #ifdef SWIG_TYPE_TABLE
@@ -213,7 +217,11 @@ typedef struct WXRUBY_EXPORT 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 */
+#if SWIG_VERSION < 0x040400
   struct swig_cast_info  *prev;			/* pointer to the previous cast */
+#else
+  unsigned int            value;		/* index of the last valid element in the array | typename hash value */
+#endif
 } swig_cast_info;
 
 /* Structure used to store module information
@@ -256,6 +264,13 @@ SWIG_TypeEquiv(const char *nb, const char *tb) {
   return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
 }
 
+#if SWIG_VERSION >= 0x040400
+/*
+ * Hash function for type name strings, based on maRushPrime1Hash (http://amsoftware.narod.ru/algo2.html)
+ */
+WXRUBY_EXPORT unsigned int SWIG_Hash(const char *str, unsigned int len);
+#endif
+
 /*
   Check the typename
 */

data/ext/wxruby3/swig/custom/typemaps/swigtypemaps.swg

@@ -126,6 +126,14 @@
 #endif
 #endif
 
+#if SWIG_VERSION >= 0x040400
+/*==== clear errors ====*/
+
+#ifndef %error_clear
+#define %error_clear
+#endif
+#endif
+
 /*==== director output exception ====*/
 
 /* wxRuby : make sure to pass the object and method that caused the failure */
@@ -143,15 +151,27 @@
 #define %error_block(Block...)                 %block(Block)
 #define %default_code(code)                    SWIG_ArgError(code)  
 #define %argument_fail(code, type, name, argn) SWIG_exception_fail(%default_code(code), %argfail_fmt(type, name, argn))
+#if SWIG_VERSION < 0x040400
 #define %argument_nullref(type, name, argn)    SWIG_exception_fail(SWIG_ValueError, %argnullref_fmt(type, name, argn))
+#else
+#define %argument_nullref(type, name, argn)    SWIG_exception_fail(SWIG_NullReferenceError, %argnullref_fmt(type, name, argn))
+#endif
 #define %variable_fail(code, type, name)       SWIG_exception_fail(%default_code(code), %varfail_fmt(type, name))
+#if SWIG_VERSION < 0x040400
 #define %variable_nullref(type, name)          SWIG_exception_fail(SWIG_ValueError, %varnullref_fmt(type, name))
+#else
+#define %variable_nullref(type, name)          SWIG_exception_fail(SWIG_NullReferenceError, %varnullref_fmt(type, name))
+#endif
 #define %releasenotowned_fail(code, type, name, argn) SWIG_exception_fail(%default_code(code), %releasenotownedfail_fmt(type, name, argn))
 
 /* wxRuby : make sure to pass the object and method that caused the failure */
 #if defined(SWIG_DIRECTOR_TYPEMAPS)
 #define %dirout_fail(code, type)          SWIG_DirOutFail(swig_get_self(), "$symname", %default_code(code), %outfail_fmt(type))
+#if SWIG_VERSION < 0x040400
 #define %dirout_nullref(type)             SWIG_DirOutFail(swig_get_self(), "$symname", SWIG_ValueError, %outnullref_fmt(type))
+#else
+#define %dirout_nullref(type)             SWIG_DirOutFail(swig_get_self(), "$symname", SWIG_NullReferenceError, %outnullref_fmt(type))
+#endif
 #endif
 
 /* -----------------------------------------------------------------------------