wxruby3 0.9.0 → 0.9.2

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

@@ -0,0 +1,296 @@
+/* -----------------------------------------------------------------------------
+ * director.swg
+ *
+ * This file contains support for director classes so that Ruby proxy
+ * methods can be called from C++.
+ *
+ * Customized for wxRuby3.
+ * Copyright (c) 2023 M.J.N. Corino, The Netherlands
+ *
+ * This software is released under the MIT license.
+ * ----------------------------------------------------------------------------- */
+
+// fixed
+#ifndef SWIG_DIRECTOR_NOUEH
+#define SWIG_DIRECTOR_NOUEH
+#endif
+
+#include <string>
+#include <iostream>
+#include <exception>
+#include <map>
+
+# define SWIG_DIRECTOR_CAST(ARG) dynamic_cast<Swig::Director *>(ARG)
+
+namespace Swig {
+
+  /* memory handler */
+  struct WXRUBY_EXPORT GCItem
+  {
+    virtual ~GCItem();
+
+    virtual swig_ruby_owntype get_own() const;
+  };
+
+  struct WXRUBY_EXPORT GCItem_var
+  {
+    GCItem_var(GCItem *item = 0) : _item(item) {}
+
+    GCItem_var& operator=(GCItem *item);
+
+    ~GCItem_var()
+    {
+      delete _item;
+    }
+
+    GCItem *operator->() const
+    {
+      return _item;
+    }
+
+  private:
+    GCItem *_item;
+  };
+
+  template <typename Type>
+  struct GCItem_T : GCItem
+  {
+    GCItem_T(Type *ptr) : _ptr(ptr) {}
+
+    virtual ~GCItem_T()
+    {
+      delete _ptr;
+    }
+
+  private:
+    Type *_ptr;
+  };
+
+  struct WXRUBY_EXPORT GCItem_Object : GCItem
+  {
+    GCItem_Object(swig_ruby_owntype own) : _own(own) {}
+
+    virtual ~GCItem_Object() {}
+
+    swig_ruby_owntype get_own() const
+    {
+      return _own;
+    }
+
+  private:
+    swig_ruby_owntype _own;
+  };
+
+  template <typename Type>
+  struct GCArray_T : GCItem
+  {
+    GCArray_T(Type *ptr) : _ptr(ptr) {}
+
+    virtual ~GCArray_T()
+    {
+      delete[] _ptr;
+    }
+
+  private:
+    Type *_ptr;
+  };
+
+  /* Base class for director exceptions */
+  class WXRUBY_EXPORT DirectorException : public std::exception
+  {
+  protected:
+    VALUE swig_error;
+    std::string swig_msg;
+  protected:
+    DirectorException(VALUE error) : swig_error(error) {}
+
+    DirectorException(VALUE error, const char *hdr, const char *msg ="");
+
+    void setup_error(VALUE error);
+
+  public:
+    virtual ~DirectorException() throw();
+
+    VALUE getType() const
+    {
+      return CLASS_OF(swig_error);
+    }
+
+    VALUE getError() const
+    {
+      return swig_error;
+    }
+
+    /* Deprecated, use what() instead */
+    const std::string& getMessage() const
+    {
+      return swig_msg;
+    }
+
+    const char *what() const throw()
+    {
+      return swig_msg.c_str();
+    }
+  };
+
+  /* Type mismatch in the return value from a Ruby method call */
+  class WXRUBY_EXPORT DirectorTypeMismatchException : public DirectorException
+  {
+  public:
+    DirectorTypeMismatchException(VALUE error, const char *msg="")
+      : DirectorException(error, "SWIG director type mismatch", msg)
+    {}
+
+    DirectorTypeMismatchException(const char *msg="")
+      : DirectorException(rb_eTypeError, "SWIG director type mismatch", msg)
+    {}
+
+    DirectorTypeMismatchException(VALUE self, const char *method, VALUE error, const char *msg="");
+
+    static inline void raise(VALUE error, const char *msg)
+    {
+      throw DirectorTypeMismatchException(error, msg);
+    }
+
+    static inline void raise(const char *msg)
+    {
+      throw DirectorTypeMismatchException(msg);
+    }
+
+    static inline void raise(VALUE self, const char* method, VALUE error, const char *msg)
+    {
+      throw DirectorTypeMismatchException(self, method, error, msg);
+    }
+  };
+
+  /* Any Ruby exception that occurs during a director method call */
+  class WXRUBY_EXPORT DirectorMethodException : public DirectorException
+  {
+  public:
+    DirectorMethodException(VALUE error)
+      : DirectorException(error)
+    {}
+
+    DirectorMethodException(const char *msg = "")
+      : DirectorException(rb_eRuntimeError, "SWIG director method error.", msg)
+    {}
+
+    static void raise(VALUE error)
+    {
+      throw DirectorMethodException(error);
+    }
+  };
+
+  /* Attempted to call a pure virtual method via a director method */
+  class WXRUBY_EXPORT DirectorPureVirtualException : public DirectorException
+  {
+  public:
+    DirectorPureVirtualException(const char *msg = "")
+      : DirectorException(rb_eRuntimeError, "SWIG director pure virtual method called", msg)
+    {}
+
+    static void raise(const char *msg)
+    {
+      throw DirectorPureVirtualException(msg);
+    }
+  };
+
+  /* Simple thread abstraction for pthreads on win32 */
+#ifdef __THREAD__
+# define __PTHREAD__
+# if defined(_WIN32) || defined(__WIN32__)
+#  define pthread_mutex_lock EnterCriticalSection
+#  define pthread_mutex_unlock LeaveCriticalSection
+#  define pthread_mutex_t CRITICAL_SECTION
+#  define SWIG_MUTEX_INIT(var) var
+# else
+#  include <pthread.h>
+#  define SWIG_MUTEX_INIT(var) var = PTHREAD_MUTEX_INITIALIZER
+# endif
+#endif
+
+#ifdef  __PTHREAD__
+  struct Guard
+  {
+    pthread_mutex_t *_mutex;
+
+    Guard(pthread_mutex_t &mutex) : _mutex(&mutex)
+    {
+      pthread_mutex_lock(_mutex);
+    }
+
+    ~Guard()
+    {
+      pthread_mutex_unlock(_mutex);
+    }
+  };
+# define SWIG_GUARD(mutex) Guard _guard(mutex)
+#else
+# define SWIG_GUARD(mutex)
+#endif
+
+  /* director base class */
+  class WXRUBY_EXPORT Director
+  {
+  private:
+    /* pointer to the wrapped Ruby object */
+    VALUE swig_self;
+    /* flag indicating whether the object is owned by Ruby or c++ */
+    mutable bool swig_disown_flag;
+
+  public:
+    /* wrap a Ruby object. */
+    Director(VALUE self);
+
+    /* discard our reference at destruction */
+    virtual ~Director();
+
+    /* return a pointer to the wrapped Ruby object */
+    VALUE swig_get_self() const
+    {
+      return swig_self;
+    }
+
+    /* acquire ownership of the wrapped Ruby object (the sense of "disown" is from Ruby) */
+    void swig_disown() const
+    {
+      if (!swig_disown_flag)
+      {
+        swig_disown_flag = true;
+      }
+    }
+
+  /* ownership management */
+  private:
+    typedef std::map<void *, GCItem_var> swig_ownership_map;
+    mutable swig_ownership_map swig_owner;
+#ifdef __PTHREAD__
+    static pthread_mutex_t swig_mutex_own;
+#endif
+
+  public:
+    template <typename Type>
+    void swig_acquire_ownership_array(Type *vptr) const
+    {
+      if (vptr)
+      {
+        SWIG_GUARD(swig_mutex_own);
+        swig_owner[vptr] = new GCArray_T<Type>(vptr);
+      }
+    }
+
+    template <typename Type>
+    void swig_acquire_ownership(Type *vptr)  const
+    {
+      if (vptr)
+      {
+        SWIG_GUARD(swig_mutex_own);
+        swig_owner[vptr] = new GCItem_T<Type>(vptr);
+      }
+    }
+
+    void swig_acquire_ownership_obj(void *vptr, swig_ruby_owntype own) const;
+
+    swig_ruby_owntype swig_release_ownership(void *vptr) const;
+  };
+}

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

@@ -0,0 +1,19 @@
+/* -----------------------------------------------------------------------------
+ * Ruby API portion that goes into the runtime
+ *
+ * Customized for wxRuby3.
+ * Copyright (c) 2023 M.J.N. Corino, The Netherlands
+ *
+ * This software is released under the MIT license.
+ * ----------------------------------------------------------------------------- */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+WXRUBY_EXPORT VALUE
+SWIG_Ruby_AppendOutput(VALUE target, VALUE o);
+
+#ifdef __cplusplus
+}
+#endif

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

@@ -0,0 +1,45 @@
+/* -----------------------------------------------------------------------------
+ * error manipulation
+ *
+ * Customized for wxRuby3.
+ * Copyright (c) 2023 M.J.N. Corino, The Netherlands
+ *
+ * This software is released under the MIT license.
+ * ----------------------------------------------------------------------------- */
+
+
+/* Define some additional error types */
+#define SWIG_ObjectPreviouslyDeletedError  -100
+
+
+/* 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.*/
+
+WXRUBY_EXPORT VALUE
+getNullReferenceError(void);
+
+WXRUBY_EXPORT VALUE
+getObjectPreviouslyDeletedError(void);
+
+WXRUBY_EXPORT VALUE
+SWIG_Ruby_ErrorType(int SWIG_code);
+
+/* This function is called when a user inputs a wrong argument to
+   a method.
+ */
+WXRUBY_EXPORT
+const char* Ruby_Format_TypeError( const char* msg,
+				   const char* type, 
+				   const char* name, 
+				   const int argn,
+				   VALUE input );
+
+/* This function is called when an overloaded method fails */
+WXRUBY_EXPORT
+void Ruby_Format_OverloadedError(
+				 const int argc,
+				 const int maxargs,
+				 const char* method, 
+				 const char* prototypes 
+				 );

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

@@ -0,0 +1,192 @@
+/* -----------------------------------------------------------------------------
+ * rubyhead.swg
+ *
+ * Customized for wxRuby3.
+ * Copyright (c) 2023 M.J.N. Corino, The Netherlands
+ *
+ * This software is released under the MIT license.
+ * ----------------------------------------------------------------------------- */
+#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
+ * issue for now by disabling this.
+ * https://sourceforge.net/tracker/?func=detail&aid=2859614&group_id=1645&atid=101645
+ */
+#ifdef rb_intern
+# undef rb_intern
+#endif
+
+/* Remove global macros defined in Ruby's win32.h */
+#ifdef write
+# undef write
+#endif
+#ifdef read
+# undef read
+#endif
+#ifdef bind
+# undef bind
+#endif
+#ifdef close
+# undef close
+#endif
+#ifdef connect
+# undef connect
+#endif
+
+
+/* Ruby 1.7 defines NUM2LL(), LL2NUM() and ULL2NUM() macros */
+#ifndef NUM2LL
+#define NUM2LL(x) NUM2LONG((x))
+#endif
+#ifndef LL2NUM
+#define LL2NUM(x) INT2NUM((long) (x))
+#endif
+#ifndef ULL2NUM
+#define ULL2NUM(x) UINT2NUM((unsigned long) (x))
+#endif
+
+/* Ruby 1.7 doesn't (yet) define NUM2ULL() */
+#ifndef NUM2ULL
+#ifdef HAVE_LONG_LONG
+#define NUM2ULL(x) rb_num2ull((x))
+#else
+#define NUM2ULL(x) NUM2ULONG(x)
+#endif
+#endif
+
+/* RSTRING_LEN, etc are new in Ruby 1.9, but ->ptr and ->len no longer work */
+/* Define these for older versions so we can just write code the new way */
+#ifndef RSTRING_LEN
+# define RSTRING_LEN(x) RSTRING(x)->len
+#endif
+#ifndef RSTRING_PTR
+# define RSTRING_PTR(x) RSTRING(x)->ptr
+#endif
+#ifndef RSTRING_END
+# define RSTRING_END(x) (RSTRING_PTR(x) + RSTRING_LEN(x))
+#endif
+#ifndef RARRAY_LEN
+# define RARRAY_LEN(x) RARRAY(x)->len
+#endif
+#ifndef RARRAY_PTR
+# define RARRAY_PTR(x) RARRAY(x)->ptr
+#endif
+#ifndef RFLOAT_VALUE
+# define RFLOAT_VALUE(x) RFLOAT(x)->value
+#endif
+#ifndef DOUBLE2NUM
+# define DOUBLE2NUM(x) rb_float_new(x)
+#endif
+#ifndef RHASH_TBL
+# define RHASH_TBL(x) (RHASH(x)->tbl)
+#endif
+#ifndef RHASH_ITER_LEV
+# define RHASH_ITER_LEV(x) (RHASH(x)->iter_lev)
+#endif
+#ifndef RHASH_IFNONE
+# define RHASH_IFNONE(x) (RHASH(x)->ifnone)
+#endif
+#ifndef RHASH_SIZE
+# define RHASH_SIZE(x) (RHASH(x)->tbl->num_entries)
+#endif
+#ifndef RHASH_EMPTY_P
+# define RHASH_EMPTY_P(x) (RHASH_SIZE(x) == 0)
+#endif
+#ifndef RSTRUCT_LEN
+# define RSTRUCT_LEN(x) RSTRUCT(x)->len
+#endif
+#ifndef RSTRUCT_PTR
+# define RSTRUCT_PTR(x) RSTRUCT(x)->ptr
+#endif
+#ifndef RTYPEDDATA_P
+# define RTYPEDDATA_P(x) (TYPE(x) != T_DATA)
+#endif
+
+
+
+/*
+ * 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 used for the function pointer argument(s) of Ruby C API
+ * functions like rb_define_method() and rb_define_singleton_method().
+ *
+ * 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().
+ */
+#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 */
+#ifndef RB_STRING_VALUE
+#define RB_STRING_VALUE(s) (TYPE(s) == T_STRING ? (s) : (*(volatile VALUE *)&(s) = rb_str_to_str(s)))
+#endif
+#ifndef StringValue
+#define StringValue(s) RB_STRING_VALUE(s)
+#endif
+#ifndef StringValuePtr
+#define StringValuePtr(s) RSTRING_PTR(RB_STRING_VALUE(s))
+#endif
+#ifndef StringValueLen
+#define StringValueLen(s) RSTRING_LEN(RB_STRING_VALUE(s))
+#endif
+#ifndef SafeStringValue
+#define SafeStringValue(v) do {\
+    StringValue(v);\
+    rb_check_safe_str(v);\
+} while (0)
+#endif
+
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+#define rb_define_alloc_func(klass, func) rb_define_singleton_method((klass), "new", VALUEFUNC((func)), -1)
+#define rb_undef_alloc_func(klass) rb_undef_method(CLASS_OF((klass)), "new")
+#endif