Update swig, fix warnings, upgrade to 4.1.0 release (#315)

linux/bin/swig/share/swig/4.1.0/allkw.swg

@@ -1,5 +1,5 @@
-#ifndef __Lib_allkw_swg__
+#ifndef SWIG_INCLUDED_LIB_ALLKW_SWG
-#define __Lib_allkw_swg__
+#define SWIG_INCLUDED_LIB_ALLKW_SWG
 
 
 /*  
@@ -30,4 +30,4 @@
 %include <tcl/tclkw.swg>
 
 
-#endif //__Lib_allkw_swg__
+#endif // SWIG_INCLUDED_LIB_ALLKW_SWG

linux/bin/swig/share/swig/4.1.0/cffi/cffi.swg

@@ -1,294 +0,0 @@
-/* Define a C preprocessor symbol that can be used in interface files
-   to distinguish between the SWIG language modules. */ 
-
-#define SWIG_CFFI
-
-/* Typespecs for basic types. */
-
-%typemap(cin) void ":void";
-
-%typemap(cin) char ":char";
-%typemap(cin) char * ":string";
-%typemap(cin) unsigned char ":unsigned-char";
-%typemap(cin) signed char ":char";
-
-%typemap(cin) short ":short";
-%typemap(cin) signed short ":short";
-%typemap(cin) unsigned short ":unsigned-short";
-
-%typemap(cin) int ":int";
-%typemap(cin) signed int ":int";
-%typemap(cin) unsigned int ":unsigned-int";
-
-%typemap(cin) long ":long";
-%typemap(cin) signed long ":long";
-%typemap(cin) unsigned long ":unsigned-long";
-
-%typemap(cin) long long ":long-long";
-%typemap(cin) signed long long ":long-long";
-%typemap(cin) unsigned long long ":unsigned-long-long";
-
-%typemap(cin) float ":float";
-%typemap(cin) double ":double";
-%typemap(cin) SWIGTYPE ":pointer";
-
-%typemap(cout) void ":void";
-
-%typemap(cout) char ":char";
-%typemap(cout) char * ":string";
-%typemap(cout) unsigned char ":unsigned-char";
-%typemap(cout) signed char ":char";
-
-%typemap(cout) short ":short";
-%typemap(cout) signed short ":short";
-%typemap(cout) unsigned short ":unsigned-short";
-
-%typemap(cout) int ":int";
-%typemap(cout) signed int ":int";
-%typemap(cout) unsigned int ":unsigned-int";
-
-%typemap(cout) long ":long";
-%typemap(cout) signed long ":long";
-%typemap(cout) unsigned long ":unsigned-long";
-
-%typemap(cout) long long ":long-long";
-%typemap(cout) signed long long ":long-long";
-%typemap(cout) unsigned long long ":unsigned-long-long";
-
-%typemap(cout) float ":float";
-%typemap(cout) double ":double";
-%typemap(cout) SWIGTYPE ":pointer";
-
-
-%typemap(ctype) bool                       "int";
-%typemap(ctype) char, unsigned char, signed char,
-                short, signed short, unsigned short,
-                int, signed int, unsigned int,
-                long, signed long, unsigned long,
-                float, double, long double, char *, void *, void,
-                enum SWIGTYPE, SWIGTYPE *,
-                SWIGTYPE[ANY], SWIGTYPE &, SWIGTYPE && "$1_ltype";
-%typemap(ctype) SWIGTYPE                   "$&1_type";
-
-%typemap(in) bool                          "$1 = (bool)$input;";
-%typemap(in) char, unsigned char, signed char,
-             short, signed short, unsigned short,
-             int, signed int, unsigned int,
-             long, signed long, unsigned long,
-             float, double, long double, char *, void *, void,
-             enum SWIGTYPE, SWIGTYPE *,
-             SWIGTYPE[ANY], SWIGTYPE &, SWIGTYPE && "$1 = $input;";
-%typemap(in) SWIGTYPE                      "$1 = *$input;";
-
-%typemap(out) void                         "";
-%typemap(out) bool                          "$result = (int)$1;";
-%typemap(out) char, unsigned char, signed char,
-              short, signed short, unsigned short,
-              int, signed int, unsigned int,
-              long, signed long, unsigned long,
-              float, double, long double, char *, void *,
-              enum SWIGTYPE, SWIGTYPE *,
-              SWIGTYPE[ANY], SWIGTYPE &, SWIGTYPE && "$result = $1;";
-#ifdef __cplusplus
-%typemap(out) SWIGTYPE                     "$result = new $1_type($1);";
-#else
-%typemap(out) SWIGTYPE {
-  $result = ($&1_ltype) malloc(sizeof($1_type));
-  memmove($result, &$1, sizeof($1_type));
-}
-#endif
-
-%typecheck(SWIG_TYPECHECK_BOOL) bool { $1 = 1; };
-%typecheck(SWIG_TYPECHECK_CHAR) char { $1 = 1; };
-%typecheck(SWIG_TYPECHECK_FLOAT) float { $1 = 1; };
-%typecheck(SWIG_TYPECHECK_DOUBLE) double { $1 = 1; };
-%typecheck(SWIG_TYPECHECK_STRING) char * { $1 = 1; };
-%typecheck(SWIG_TYPECHECK_INTEGER)
-                    unsigned char, signed char,
-                    short, signed short, unsigned short,
-                    int, signed int, unsigned int,
-                    long, signed long, unsigned long,
-                    enum SWIGTYPE { $1 = 1; };
-%typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE *, SWIGTYPE &, SWIGTYPE &&,
-                                   SWIGTYPE[ANY], SWIGTYPE { $1 = 1; };
-/* This maps C/C++ types to Lisp classes for overload dispatch */
-
-%typemap(lisptype) bool "cl:boolean";
-%typemap(lisptype) char "cl:character";
-%typemap(lisptype) unsigned char "cl:integer";
-%typemap(lisptype) signed char "cl:integer";
-
-%typemap(lispclass) bool "t";
-%typemap(lispclass) char "cl:character";
-%typemap(lispclass) unsigned char, signed char,
-                    short, signed short, unsigned short,
-                    int, signed int, unsigned int,
-                    long, signed long, unsigned long,
-                    enum SWIGTYPE       "cl:integer";
-/* CLOS methods can't be specialized on single-float or double-float */
-%typemap(lispclass) float "cl:number";
-%typemap(lispclass) double "cl:number";
-%typemap(lispclass) char * "cl:string";
-
-/* Array reference typemaps */
-%apply SWIGTYPE & { SWIGTYPE ((&)[ANY]) }
-%apply SWIGTYPE && { SWIGTYPE ((&&)[ANY]) }
-
-/* const pointers */
-%apply SWIGTYPE * { SWIGTYPE *const }
-%apply SWIGTYPE (CLASS::*) { SWIGTYPE (CLASS::*const) }
-%apply SWIGTYPE & { SWIGTYPE (CLASS::*const&) }
-
-%{
-
-#ifdef __cplusplus
-#  define EXTERN   extern "C"
-#else
-#  define EXTERN   extern
-#endif
-
-#define EXPORT   EXTERN SWIGEXPORT
-
-#include <string.h>
-%}
-
-%insert("swiglisp") %{
-;;;SWIG wrapper code starts here
-
-(cl:defmacro defanonenum (cl:&body enums)
-   "Converts anonymous enums to defconstants."
-  `(cl:progn ,@(cl:loop for value in enums
-                        for index = 0 then (cl:1+ index)
-                        when (cl:listp value) do (cl:setf index (cl:second value)
-                                                          value (cl:first value))
-                        collect `(cl:defconstant ,value ,index))))
-
-(cl:eval-when (:compile-toplevel :load-toplevel)
-  (cl:unless (cl:fboundp 'swig-lispify)
-    (cl:defun swig-lispify (name flag cl:&optional (package cl:*package*))
-      (cl:labels ((helper (lst last rest cl:&aux (c (cl:car lst)))
-                    (cl:cond
-                      ((cl:null lst)
-                       rest)
-                      ((cl:upper-case-p c)
-                       (helper (cl:cdr lst) 'upper
-                               (cl:case last
-                                 ((lower digit) (cl:list* c #\- rest))
-                                 (cl:t (cl:cons c rest)))))
-                      ((cl:lower-case-p c)
-                       (helper (cl:cdr lst) 'lower (cl:cons (cl:char-upcase c) rest)))
-                      ((cl:digit-char-p c)
-                       (helper (cl:cdr lst) 'digit 
-                               (cl:case last
-                                 ((upper lower) (cl:list* c #\- rest))
-                                 (cl:t (cl:cons c rest)))))
-                      ((cl:char-equal c #\_)
-                       (helper (cl:cdr lst) '_ (cl:cons #\- rest)))
-                      (cl:t
-                       (cl:error "Invalid character: ~A" c)))))
-        (cl:let ((fix (cl:case flag
-                        ((constant enumvalue) "+")
-                        (variable "*")
-                        (cl:t ""))))
-          (cl:intern
-           (cl:concatenate
-            'cl:string
-            fix
-            (cl:nreverse (helper (cl:concatenate 'cl:list name) cl:nil cl:nil))
-            fix)
-           package))))))
-
-;;;SWIG wrapper code ends here
-%}
-
-#ifdef __cplusplus
-%typemap(out) SWIGTYPE                     "$result = new $1_type($1);";
-#else
-%typemap(out) SWIGTYPE {
-  $result = ($&1_ltype) malloc(sizeof($1_type));
-  memmove($result, &$1, sizeof($1_type));
-}
-#endif
-
-//////////////////////////////////////////////////////////////
-
-/* name conversion for overloaded operators. */
-#ifdef __cplusplus
-%rename(__add__)	     *::operator+;
-%rename(__pos__)	     *::operator+();
-%rename(__pos__)	     *::operator+() const;
-
-%rename(__sub__)	     *::operator-;
-%rename(__neg__)	     *::operator-() const;
-%rename(__neg__)	     *::operator-();
-
-%rename(__mul__)	     *::operator*;
-%rename(__deref__)	     *::operator*();
-%rename(__deref__)	     *::operator*() const;
-
-%rename(__div__)	     *::operator/;
-%rename(__mod__)	     *::operator%;
-%rename(__logxor__)	     *::operator^;
-%rename(__logand__)	     *::operator&;
-%rename(__logior__)	     *::operator|;
-%rename(__lognot__)	     *::operator~();
-%rename(__lognot__)	     *::operator~() const;
-
-%rename(__not__)	     *::operator!();
-%rename(__not__)	     *::operator!() const;
-
-%rename(__assign__)	     *::operator=;
-
-%rename(__add_assign__)      *::operator+=;
-%rename(__sub_assign__)	     *::operator-=;
-%rename(__mul_assign__)	     *::operator*=;
-%rename(__div_assign__)	     *::operator/=;
-%rename(__mod_assign__)	     *::operator%=;
-%rename(__logxor_assign__)   *::operator^=;
-%rename(__logand_assign__)   *::operator&=;
-%rename(__logior_assign__)   *::operator|=;
-
-%rename(__lshift__)	     *::operator<<;
-%rename(__lshift_assign__)   *::operator<<=;
-%rename(__rshift__)	     *::operator>>;
-%rename(__rshift_assign__)   *::operator>>=;
-
-%rename(__eq__)		     *::operator==;
-%rename(__ne__)		     *::operator!=;
-%rename(__lt__)		     *::operator<;
-%rename(__gt__)		     *::operator>;
-%rename(__lte__)	     *::operator<=;
-%rename(__gte__)	     *::operator>=;
-
-%rename(__and__)	     *::operator&&;
-%rename(__or__)		     *::operator||;
-
-%rename(__preincr__)	     *::operator++();
-%rename(__postincr__)	     *::operator++(int);
-%rename(__predecr__)	     *::operator--();
-%rename(__postdecr__)	     *::operator--(int);
-
-%rename(__comma__)	     *::operator,();
-%rename(__comma__)	     *::operator,() const;
-
-%rename(__member_ref__)      *::operator->;
-%rename(__member_func_ref__) *::operator->*;
-
-%rename(__funcall__)	     *::operator();
-%rename(__aref__)	     *::operator[];
-#endif
-
-
-%{
-
-#ifdef __cplusplus
-#  define EXTERN   extern "C"
-#else
-#  define EXTERN   extern
-#endif
-
-#define EXPORT   EXTERN SWIGEXPORT
-
-#include <string.h>
-#include <stdlib.h>
-%}

linux/bin/swig/share/swig/4.1.0/csharp/boost_intrusive_ptr.i

@@ -32,7 +32,7 @@
 %}
 %typemap(out, fragment="SWIG_intrusive_deleter") CONST TYPE %{
   //plain value(out)
-  $1_ltype* resultp = new $1_ltype(($1_ltype &)$1);
+  $1_ltype* resultp = new $1_ltype($1);
   intrusive_ptr_add_ref(resultp);
   *(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > **)&$result = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(resultp, SWIG_intrusive_deleter< CONST TYPE >());
 %}
@@ -372,7 +372,7 @@
   }
   $1 = *argp; %}
 %typemap(out) CONST TYPE
-%{ *(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > **)&$result = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(new $1_ltype(($1_ltype &)$1)); %}
+%{ *(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > **)&$result = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(new $1_ltype($1)); %}
 
 // plain pointer
 %typemap(in) CONST TYPE * (SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartarg = 0) %{

linux/bin/swig/share/swig/4.1.0/csharp/boost_shared_ptr.i

@@ -29,10 +29,10 @@
   }
   $1 = *argp; %}
 %typemap(out) CONST TYPE
-%{ $result = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(new $1_ltype(($1_ltype &)$1)); %}
+%{ $result = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(new $1_ltype($1)); %}
 
 %typemap(directorin) CONST TYPE
-%{ $input = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > (new $1_ltype((const $1_ltype &)$1)); %}
+%{ $input = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > (new $1_ltype(SWIG_STD_MOVE($1))); %}
 
 %typemap(directorout) CONST TYPE
 %{ if (!$input) {
@@ -122,7 +122,7 @@
 %typemap(in) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > * ($*1_ltype tempnull)
 %{ $1 = $input ? ($1_ltype)$input : &tempnull; %}
 %typemap(out, fragment="SWIG_null_deleter") SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *
-%{ $result = ($1 && *$1) ? new $*1_ltype(*($1_ltype)$1) : 0;
+%{ $result = ($1 && *$1) ? new $*1_ltype(*$1) : 0;
    if ($owner) delete $1; %}
 
 %typemap(directorin) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *

linux/bin/swig/share/swig/4.1.0/csharp/csharp.swg

@@ -399,7 +399,7 @@ SWIGINTERN const char * SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
 
 %typemap(out) SWIGTYPE 
 #ifdef __cplusplus
-%{ $result = new $1_ltype((const $1_ltype &)$1); %}
+%{ $result = new $1_ltype($1); %}
 #else
 {
   $&1_ltype $1ptr = ($&1_ltype) malloc(sizeof($1_ltype));
@@ -409,7 +409,7 @@ SWIGINTERN const char * SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
 #endif
 
 %typemap(directorin) SWIGTYPE 
-%{ $input = (void *)new $1_ltype((const $1_ltype &)$1); %}
+%{ $input = (void *)new $1_ltype(SWIG_STD_MOVE($1)); %}
 %typemap(csdirectorin) SWIGTYPE "new $&csclassname($iminput, true)"
 %typemap(csdirectorout) SWIGTYPE "$&csclassname.getCPtr($cscall).Handle"
 
@@ -420,14 +420,15 @@ SWIGINTERN const char * SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
 %}
 %typemap(in, canthrow=1) SWIGTYPE & %{ $1 = ($1_ltype)$input;
   if (!$1) {
-    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "$1_type type is null", 0);
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "$1_type is null", 0);
     return $null;
   } %}
-%typemap(in, canthrow=1) SWIGTYPE && %{ $1 = ($1_ltype)$input;
+%typemap(in, canthrow=1, fragment="<memory>") SWIGTYPE && (std::unique_ptr<$*1_ltype> rvrdeleter) %{ $1 = ($1_ltype)$input;
   if (!$1) {
-    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "$1_type type is null", 0);
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "$1_type is null", 0);
     return $null;
-  } %}
+  }
+  rvrdeleter.reset($1); %}
 %typemap(out) SWIGTYPE * %{ $result = (void *)$1; %} 
 %typemap(out, fragment="SWIG_PackData") SWIGTYPE (CLASS::*) %{
   char buf[128];
@@ -613,7 +614,8 @@ SWIGINTERN const char * SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
     "$csinput"
 %typemap(csin) char *, char *&, char[ANY], char[] "$csinput"
 %typemap(csin) SWIGTYPE "$&csclassname.getCPtr($csinput)"
-%typemap(csin) SWIGTYPE *, SWIGTYPE &, SWIGTYPE &&, SWIGTYPE [] "$csclassname.getCPtr($csinput)"
+%typemap(csin) SWIGTYPE *, SWIGTYPE &, SWIGTYPE [] "$csclassname.getCPtr($csinput)"
+%typemap(csin) SWIGTYPE && "$csclassname.swigRelease($csinput)"
 %typemap(csin) SWIGTYPE (CLASS::*) "$csclassname.getCMemberPtr($csinput)"
 
 /* The csout typemap is used for converting function return types from the return type
@@ -913,6 +915,19 @@ SWIGINTERN const char * SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
   CPTR_VISIBILITY static global::System.Runtime.InteropServices.HandleRef getCPtr($csclassname obj) {
     return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
   }
+
+  CPTR_VISIBILITY static global::System.Runtime.InteropServices.HandleRef swigRelease($csclassname obj) {
+    if (obj != null) {
+      if (!obj.swigCMemOwn)
+        throw new global::System.ApplicationException("Cannot release ownership as memory is not owned");
+      global::System.Runtime.InteropServices.HandleRef ptr = obj.swigCPtr;
+      obj.swigCMemOwn = false;
+      obj.Dispose();
+      return ptr;
+    } else {
+      return new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
+    }
+  }
 %}
 
 // Derived proxy classes
@@ -926,6 +941,19 @@ SWIGINTERN const char * SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
   CPTR_VISIBILITY static global::System.Runtime.InteropServices.HandleRef getCPtr($csclassname obj) {
     return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
   }
+
+  CPTR_VISIBILITY static global::System.Runtime.InteropServices.HandleRef swigRelease($csclassname obj) {
+    if (obj != null) {
+      if (!obj.swigCMemOwn)
+        throw new global::System.ApplicationException("Cannot release ownership as memory is not owned");
+      global::System.Runtime.InteropServices.HandleRef ptr = obj.swigCPtr;
+      obj.swigCMemOwn = false;
+      obj.Dispose();
+      return ptr;
+    } else {
+      return new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
+    }
+  }
 %}
 %enddef
 
@@ -945,6 +973,10 @@ SWIGINTERN const char * SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
   CPTR_VISIBILITY static global::System.Runtime.InteropServices.HandleRef getCPtr($csclassname obj) {
     return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
   }
+
+  CPTR_VISIBILITY static global::System.Runtime.InteropServices.HandleRef swigRelease($csclassname obj) {
+    return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
+  }
 %}
 
 %typemap(csbody) TYPE (CLASS::*) %{

linux/bin/swig/share/swig/4.1.0/csharp/std_array.i

@@ -16,7 +16,7 @@
 
 
 %define SWIG_STD_ARRAY_INTERNAL(T, N)
-%typemap(csinterfaces) std::array< T, N > "global::System.IDisposable, global::System.Collections.IEnumerable\n    , global::System.Collections.Generic.IEnumerable<$typemap(cstype, T)>\n";
+%typemap(csinterfaces) std::array< T, N > "global::System.IDisposable, global::System.Collections.IEnumerable\n    , global::System.Collections.Generic.IEnumerable<$typemap(cstype, T)>\n"
 %proxycode %{
   public $csclassname(global::System.Collections.ICollection c) : this() {
     if (c == null)

linux/bin/swig/share/swig/4.1.0/csharp/std_auto_ptr.i

@@ -1,22 +1,35 @@
-/*
+/* -----------------------------------------------------------------------------
-    The typemaps here allow handling functions returning std::auto_ptr<>,
+ * std_auto_ptr.i
-    which is the most common use of this type. If you have functions taking it
+ *
-    as parameter, these typemaps can't be used for them and you need to do
+ * SWIG library file for handling std::auto_ptr.
-    something else (e.g. use shared_ptr<> which SWIG supports fully).
+ * Memory ownership is passed from the std::auto_ptr C++ layer to the proxy
- */
+ * class when returning a std::auto_ptr from a function.
+ * Memory ownership is passed from the proxy class to the std::auto_ptr in the
+ * C++ layer when passed as a parameter to a wrapped function.
+ * ----------------------------------------------------------------------------- */
 
 %define %auto_ptr(TYPE)
 %typemap (ctype) std::auto_ptr< TYPE > "void *"
-%typemap (imtype, out="System.IntPtr") std::auto_ptr<TYPE > "HandleRef"
+%typemap (imtype, out="System.IntPtr") std::auto_ptr< TYPE > "global::System.Runtime.InteropServices.HandleRef"
 %typemap (cstype) std::auto_ptr< TYPE > "$typemap(cstype, TYPE)"
+
+%typemap(in) std::auto_ptr< TYPE >
+%{ $1.reset((TYPE *)$input); %}
+
+%typemap(csin) std::auto_ptr< TYPE > "$typemap(cstype, TYPE).swigRelease($csinput)"
+
 %typemap (out) std::auto_ptr< TYPE > %{
   $result = (void *)$1.release();
 %}
+
 %typemap(csout, excode=SWIGEXCODE) std::auto_ptr< TYPE > {
     System.IntPtr cPtr = $imcall;
     $typemap(cstype, TYPE) ret = (cPtr == System.IntPtr.Zero) ? null : new $typemap(cstype, TYPE)(cPtr, true);$excode
     return ret;
   }
+
+%typemap(typecheck, precedence=SWIG_TYPECHECK_POINTER, equivalent="TYPE *") std::auto_ptr< TYPE > ""
+
 %template() std::auto_ptr< TYPE >;
 %enddef
 

linux/bin/swig/share/swig/4.1.0/csharp/std_list.i

@@ -19,7 +19,7 @@
 
 // MACRO for use within the std::list class body
 %define SWIG_STD_LIST_MINIMUM_INTERNAL(CSINTERFACE, CTYPE...)
-%typemap(csinterfaces) std::list< CTYPE > "global::System.IDisposable, global::System.Collections.IEnumerable, global::System.Collections.Generic.CSINTERFACE<$typemap(cstype, CTYPE)>\n";
+%typemap(csinterfaces) std::list< CTYPE > "global::System.IDisposable, global::System.Collections.IEnumerable, global::System.Collections.Generic.CSINTERFACE<$typemap(cstype, CTYPE)>\n"
 
 %apply void *VOID_INT_PTR { std::list< CTYPE >::iterator * };
 

linux/bin/swig/share/swig/4.1.0/csharp/std_map.i

@@ -26,7 +26,7 @@
 /* K is the C++ key type, T is the C++ value type */
 %define SWIG_STD_MAP_INTERNAL(K, T, C)
 
-%typemap(csinterfaces) std::map< K, T, C > "global::System.IDisposable \n    , global::System.Collections.Generic.IDictionary<$typemap(cstype, K), $typemap(cstype, T)>\n";
+%typemap(csinterfaces) std::map< K, T, C > "global::System.IDisposable \n    , global::System.Collections.Generic.IDictionary<$typemap(cstype, K), $typemap(cstype, T)>\n"
 %proxycode %{
 
   public $typemap(cstype, T) this[$typemap(cstype, K) key] {

linux/bin/swig/share/swig/4.1.0/csharp/std_set.i

@@ -28,7 +28,7 @@ namespace std {
 template <class T>
 class set {
 
-%typemap(csinterfaces) std::set<T> "global::System.IDisposable, global::System.Collections.Generic.ISet<$typemap(cstype, T)>\n";
+%typemap(csinterfaces) std::set<T> "global::System.IDisposable, global::System.Collections.Generic.ISet<$typemap(cstype, T)>\n"
 %proxycode %{
   void global::System.Collections.Generic.ICollection<$typemap(cstype, T)>.Add($typemap(cstype, T) item) {
       ((global::System.Collections.Generic.ISet<$typemap(cstype, T)>)this).Add(item);

linux/bin/swig/share/swig/4.1.0/csharp/std_unique_ptr.i

@@ -0,0 +1,38 @@
+/* -----------------------------------------------------------------------------
+ * std_unique_ptr.i
+ *
+ * SWIG library file for handling std::unique_ptr.
+ * Memory ownership is passed from the std::unique_ptr C++ layer to the proxy
+ * class when returning a std::unique_ptr from a function.
+ * Memory ownership is passed from the proxy class to the std::unique_ptr in the
+ * C++ layer when passed as a parameter to a wrapped function.
+ * ----------------------------------------------------------------------------- */
+
+%define %unique_ptr(TYPE)
+%typemap (ctype) std::unique_ptr< TYPE > "void *"
+%typemap (imtype, out="System.IntPtr") std::unique_ptr< TYPE > "global::System.Runtime.InteropServices.HandleRef"
+%typemap (cstype) std::unique_ptr< TYPE > "$typemap(cstype, TYPE)"
+
+%typemap(in) std::unique_ptr< TYPE >
+%{ $1.reset((TYPE *)$input); %}
+
+%typemap(csin) std::unique_ptr< TYPE > "$typemap(cstype, TYPE).swigRelease($csinput)"
+
+%typemap (out) std::unique_ptr< TYPE > %{
+  $result = (void *)$1.release();
+%}
+
+%typemap(csout, excode=SWIGEXCODE) std::unique_ptr< TYPE > {
+    System.IntPtr cPtr = $imcall;
+    $typemap(cstype, TYPE) ret = (cPtr == System.IntPtr.Zero) ? null : new $typemap(cstype, TYPE)(cPtr, true);$excode
+    return ret;
+  }
+
+%typemap(typecheck, precedence=SWIG_TYPECHECK_POINTER, equivalent="TYPE *") std::unique_ptr< TYPE > ""
+
+%template() std::unique_ptr< TYPE >;
+%enddef
+
+namespace std {
+  template <class T> class unique_ptr {};
+}

linux/bin/swig/share/swig/4.1.0/csharp/std_vector.i

@@ -19,7 +19,7 @@
 
 // MACRO for use within the std::vector class body
 %define SWIG_STD_VECTOR_MINIMUM_INTERNAL(CSINTERFACE, CONST_REFERENCE, CTYPE...)
-%typemap(csinterfaces) std::vector< CTYPE > "global::System.IDisposable, global::System.Collections.IEnumerable, global::System.Collections.Generic.CSINTERFACE<$typemap(cstype, CTYPE)>\n";
+%typemap(csinterfaces) std::vector< CTYPE > "global::System.IDisposable, global::System.Collections.IEnumerable, global::System.Collections.Generic.CSINTERFACE<$typemap(cstype, CTYPE)>\n"
 %proxycode %{
   public $csclassname(global::System.Collections.IEnumerable c) : this() {
     if (c == null)

linux/bin/swig/share/swig/4.1.0/csharp/std_wstring.i

@@ -2,7 +2,9 @@
  * std_wstring.i
  *
  * Typemaps for std::wstring and const std::wstring&
- * These are mapped to a C# String and are passed around by value.
+ * std::wstring is mapped to a C# Unicode string (UTF16) and is passed around by value.
+ * std::wstring support includes wchar_t as a 2 byte type (Windows) and a 4 byte type
+ * (most Unix systems).
  *
  * To use non-const std::wstring references use the following %apply.  Note 
  * that they are passed by value.
@@ -15,6 +17,28 @@
 #include <string>
 %}
 
+%fragment("Swig_csharp_UTF16ToWString", "header") %{
+/* For converting from .NET UTF16 (2 byte unicode) strings. wchar_t is 2 bytes on Windows, 4 bytes on Linux. */
+static std::wstring Swig_csharp_UTF16ToWString(const unsigned short *str) {
+  if (sizeof(wchar_t) == 2) {
+    return std::wstring((wchar_t *)str);
+  } else {
+    const unsigned short *pBegin(str);
+    const unsigned short *ptr(pBegin);
+
+    while (*ptr != 0)
+      ++ptr;
+
+    std::wstring result;
+    result.reserve(ptr - pBegin);
+    while(pBegin != ptr)
+      result.push_back(*pBegin++);
+
+    return result;
+  }
+}
+%}
+
 namespace std {
 
 %naturalvar wstring;
@@ -22,31 +46,33 @@ namespace std {
 class wstring;
 
 // wstring
-%typemap(ctype, out="void *") wstring "wchar_t *"
+%typemap(ctype, out="void *") wstring "unsigned short *"
 %typemap(imtype,
          inattributes="[global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.LPWStr)]",
-         outattributes="[return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.LPWStr)]"
+         outattributes="[return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.LPWStr)]",
+         directorinattributes="[global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.LPWStr)]",
+         directoroutattributes="[return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.LPWStr)]"
          ) wstring "string"
 %typemap(cstype) wstring "string"
 %typemap(csdirectorin) wstring "$iminput"
 %typemap(csdirectorout) wstring "$cscall"
 
-%typemap(in, canthrow=1) wstring 
+%typemap(in, canthrow=1, fragment="Swig_csharp_UTF16ToWString") wstring
 %{ if (!$input) {
     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null wstring", 0);
     return $null;
    }
-   $1.assign($input); %}
+   $1 = Swig_csharp_UTF16ToWString($input); %}
-%typemap(out) wstring %{ $result = SWIG_csharp_wstring_callback($1.c_str()); %}
+%typemap(out) wstring %{ $result = SWIG_csharp_wstring_with_length_callback($1.c_str(), (int)$1.size()); %}
 
 %typemap(directorout, canthrow=1) wstring
 %{ if (!$input) {
     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null wstring", 0);
     return $null;
    }
-   $result.assign($input); %}
+   $result = Swig_csharp_UTF16ToWString($input); %}
 
-%typemap(directorin) wstring %{ $input = SWIG_csharp_wstring_callback($1.c_str()); %}
+%typemap(directorin) wstring %{ $input = SWIG_csharp_wstring_with_length_callback($1.c_str(), (int)$1.size()); %}
 
 %typemap(csin) wstring "$csinput"
 %typemap(csout, excode=SWIGEXCODE) wstring {
@@ -57,29 +83,30 @@ class wstring;
 %typemap(typecheck) wstring = wchar_t *;
 
 %typemap(throws, canthrow=1) wstring
-%{ std::string message($1.begin(), $1.end());
+%{ SWIG_csharp_ApplicationException_callback($1.c_str(), (int)$1.size());
-   SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, message.c_str());
    return $null; %}
 
 // const wstring &
-%typemap(ctype, out="void *") const wstring & "wchar_t *"
+%typemap(ctype, out="void *") const wstring & "unsigned short *"
 %typemap(imtype,
          inattributes="[global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.LPWStr)]",
-         outattributes="[return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.LPWStr)]"
+         outattributes="[return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.LPWStr)]",
+         directorinattributes="[global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.LPWStr)]",
+         directoroutattributes="[return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.LPWStr)]"
          ) const wstring & "string"
 %typemap(cstype) const wstring & "string"
 
 %typemap(csdirectorin) const wstring & "$iminput"
 %typemap(csdirectorout) const wstring & "$cscall"
 
-%typemap(in, canthrow=1) const wstring &
+%typemap(in, canthrow=1, fragment="Swig_csharp_UTF16ToWString") const wstring &
 %{ if (!$input) {
     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null wstring", 0);
     return $null;
    }
-   std::wstring $1_str($input);
+   std::wstring $1_str(Swig_csharp_UTF16ToWString($input));
    $1 = &$1_str; %}
-%typemap(out) const wstring & %{ $result = SWIG_csharp_wstring_callback($1->c_str()); %}
+%typemap(out) const wstring & %{ $result = SWIG_csharp_wstring_with_length_callback($1->c_str(), (int)$1->size()); %}
 
 %typemap(csin) const wstring & "$csinput"
 %typemap(csout, excode=SWIGEXCODE) const wstring & {
@@ -94,10 +121,10 @@ class wstring;
    }
    /* possible thread/reentrant code problem */
    static std::wstring $1_str;
-   $1_str = $input;
+   $1_str = Swig_csharp_UTF16ToWString($input);
    $result = &$1_str; %}
 
-%typemap(directorin) const wstring & %{ $input = SWIG_csharp_wstring_callback($1.c_str()); %}
+%typemap(directorin) const wstring & %{ $input = SWIG_csharp_wstring_with_length_callback($1.c_str(), (int)$1.size()); %}
 
 %typemap(csvarin, excode=SWIGEXCODE2) const wstring & %{
     set {
@@ -112,8 +139,7 @@ class wstring;
 %typemap(typecheck) const wstring & = wchar_t *;
 
 %typemap(throws, canthrow=1) const wstring &
-%{ std::string message($1.begin(), $1.end());
+%{ SWIG_csharp_ApplicationException_callback($1.c_str(), (int)$1.size());
-   SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, message.c_str());
    return $null; %}
 
 }

linux/bin/swig/share/swig/4.1.0/csharp/swigmove.i

@@ -0,0 +1,16 @@
+/* -----------------------------------------------------------------------------
+ * swigmove.i
+ *
+ * Input typemaps library for implementing full move semantics when passing
+ * parameters by value.
+ * ----------------------------------------------------------------------------- */
+
+%typemap(in, canthrow=1, fragment="<memory>") SWIGTYPE MOVE ($&1_type argp)
+%{ argp = ($&1_ltype)$input;
+   if (!argp) {
+     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null $1_type", 0);
+     return $null;
+   }
+   SwigValueWrapper< $1_ltype >::reset($1, argp); %}
+
+%typemap(csin) SWIGTYPE MOVE "$&csclassname.swigRelease($csinput)"

linux/bin/swig/share/swig/4.1.0/csharp/wchar.i

@@ -2,37 +2,58 @@
  * wchar.i
  *
  * Typemaps for the wchar_t type
- * These are mapped to a C# String and are passed around by value.
+ * wchar_t * is mapped to a C# Unicode string (UTF16) and is passed around by value.
+ * wchar_t * support includes wchar_t as a 2 byte type (Windows) and a 4 byte type
+ * (most Unix systems).
  *
  * Support code for wide strings can be turned off by defining SWIG_CSHARP_NO_WSTRING_HELPER
- *
  * ----------------------------------------------------------------------------- */
 
 #if !defined(SWIG_CSHARP_NO_WSTRING_HELPER)
 #if !defined(SWIG_CSHARP_WSTRING_HELPER_)
 #define SWIG_CSHARP_WSTRING_HELPER_
+
+%fragment("<wchar.h>"); // TODO: %fragment("<wchar.h", "runtime");
+
 %insert(runtime) %{
 /* Callback for returning strings to C# without leaking memory */
-typedef void * (SWIGSTDCALL* SWIG_CSharpWStringHelperCallback)(const wchar_t *);
+typedef void * (SWIGSTDCALL* SWIG_CSharpWStringHelperCallback)(const wchar_t *, int length);
-static SWIG_CSharpWStringHelperCallback SWIG_csharp_wstring_callback = NULL;
+static SWIG_CSharpWStringHelperCallback SWIG_csharp_wstring_with_length_callback = NULL;
 %}
 
+%insert(header) %{
+static void * SWIG_csharp_wstring_callback(const wchar_t *s) {
+  return SWIG_csharp_wstring_with_length_callback(s, (int)wcslen(s));
+}
+%}
+
+
 %pragma(csharp) imclasscode=%{
   protected class SWIGWStringHelper {
 
     [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.LPWStr)]
-    public delegate string SWIGWStringDelegate(global::System.IntPtr message);
+    public delegate string SWIGWStringDelegate(global::System.IntPtr message, int length);
-    static SWIGWStringDelegate wstringDelegate = new SWIGWStringDelegate(CreateWString);
+    static SWIGWStringDelegate wstringUTF16Delegate = new SWIGWStringDelegate(CreateWStringFromUTF16);
+    static SWIGWStringDelegate wstringUTF32Delegate = new SWIGWStringDelegate(CreateWStringFromUTF32);
 
     [global::System.Runtime.InteropServices.DllImport("$dllimport", EntryPoint="SWIGRegisterWStringCallback_$module")]
-    public static extern void SWIGRegisterWStringCallback_$module(SWIGWStringDelegate wstringDelegate);
+    public static extern void SWIGRegisterWStringCallback_$module(SWIGWStringDelegate wstringUTF16Delegate, SWIGWStringDelegate wstringUTF32Delegate);
 
-    static string CreateWString([global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.LPWStr)]global::System.IntPtr cString) {
+    public static string CreateWStringFromUTF16([global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.LPWStr)]global::System.IntPtr cString, int length) {
-      return global::System.Runtime.InteropServices.Marshal.PtrToStringUni(cString);
+      return global::System.Runtime.InteropServices.Marshal.PtrToStringUni(cString, length);
+    }
+
+    public static string CreateWStringFromUTF32([global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.LPWStr)]global::System.IntPtr cString, int length) {
+      if (length == 0)
+        return string.Empty;
+
+      byte[] buffer = new byte[length * 4];
+      global::System.Runtime.InteropServices.Marshal.Copy(cString, buffer, 0, buffer.Length);
+      return global::System.Text.Encoding.UTF32.GetString(buffer);
     }
 
     static SWIGWStringHelper() {
-      SWIGRegisterWStringCallback_$module(wstringDelegate);
+      SWIGRegisterWStringCallback_$module(wstringUTF16Delegate, wstringUTF32Delegate);
     }
   }
 
@@ -43,13 +64,76 @@ static SWIG_CSharpWStringHelperCallback SWIG_csharp_wstring_callback = NULL;
 #ifdef __cplusplus
 extern "C"
 #endif
-SWIGEXPORT void SWIGSTDCALL SWIGRegisterWStringCallback_$module(SWIG_CSharpWStringHelperCallback callback) {
+SWIGEXPORT void SWIGSTDCALL SWIGRegisterWStringCallback_$module(SWIG_CSharpWStringHelperCallback callback_utf16, SWIG_CSharpWStringHelperCallback callback_utf32) {
-  SWIG_csharp_wstring_callback = callback;
+  SWIG_csharp_wstring_with_length_callback = sizeof(wchar_t) == 2 ? callback_utf16 : callback_utf32;
 }
 %}
 #endif // SWIG_CSHARP_WSTRING_HELPER_
 #endif // SWIG_CSHARP_NO_WSTRING_HELPER
 
+#if !defined(SWIG_CSHARP_NO_WSTRING_EXCEPTION_HELPER)
+#if !defined(SWIG_CSHARP_WSTRING_EXCEPTION_HELPER_)
+#define SWIG_CSHARP_WSTRING_EXCEPTION_HELPER_
+
+%insert(runtime) %{
+/* Callback for returning strings to C# without leaking memory */
+typedef void (SWIGSTDCALL* SWIG_CSharpWStringExceptionHelperCallback)(const wchar_t *, int length);
+static SWIG_CSharpWStringExceptionHelperCallback SWIG_csharp_ApplicationException_callback = NULL;
+%}
+
+%pragma(csharp) imclasscode=%{
+  protected class SWIGWStringExceptionHelper {
+
+    [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.LPWStr)]
+    public delegate void SWIGWStringExceptionDelegate(global::System.IntPtr message, int length);
+    static SWIGWStringExceptionDelegate applicationExceptionUTF16Delegate = new SWIGWStringExceptionDelegate(SetPendingApplicationExceptionUTF16);
+    static SWIGWStringExceptionDelegate applicationExceptionUTF32Delegate = new SWIGWStringExceptionDelegate(SetPendingApplicationExceptionUTF32);
+
+    [global::System.Runtime.InteropServices.DllImport("$dllimport", EntryPoint="SWIGRegisterWStringExceptionCallback_$module")]
+    public static extern void SWIGRegisterWStringExceptionCallback_$module(SWIGWStringExceptionDelegate applicationExceptionUTF16Delegate, SWIGWStringExceptionDelegate applicationExceptionUTF32Delegate);
+
+    static string CreateWStringFromUTF16([global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.LPWStr)]global::System.IntPtr cString, int length) {
+      return global::System.Runtime.InteropServices.Marshal.PtrToStringUni(cString, length);
+    }
+
+    public static string CreateWStringFromUTF32([global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.LPWStr)]global::System.IntPtr cString, int length) {
+      if (length == 0)
+        return string.Empty;
+
+      byte[] buffer = new byte[length * 4];
+      return global::System.Text.Encoding.UTF32.GetString(buffer);
+    }
+
+    static void SetPendingApplicationExceptionUTF16([global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.LPWStr)]global::System.IntPtr cString, int length) {
+      string message = SWIGWStringHelper.CreateWStringFromUTF16(cString, length);
+      SWIGPendingException.Set(new global::System.ApplicationException(message, SWIGPendingException.Retrieve()));
+    }
+
+    static void SetPendingApplicationExceptionUTF32([global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.LPWStr)]global::System.IntPtr cString, int length) {
+      string message = SWIGWStringHelper.CreateWStringFromUTF32(cString, length);
+      SWIGPendingException.Set(new global::System.ApplicationException(message, SWIGPendingException.Retrieve()));
+    }
+
+    static SWIGWStringExceptionHelper() {
+      SWIGRegisterWStringExceptionCallback_$module(applicationExceptionUTF16Delegate, applicationExceptionUTF32Delegate);
+    }
+  }
+
+  static protected SWIGWStringExceptionHelper swigWStringExceptionHelper = new SWIGWStringExceptionHelper();
+%}
+
+%insert(runtime) %{
+#ifdef __cplusplus
+extern "C"
+#endif
+SWIGEXPORT void SWIGSTDCALL SWIGRegisterWStringExceptionCallback_$module(SWIG_CSharpWStringExceptionHelperCallback callback_utf16, SWIG_CSharpWStringExceptionHelperCallback callback_utf32) {
+  SWIG_csharp_ApplicationException_callback = sizeof(wchar_t) == 2 ? callback_utf16 : callback_utf32;
+}
+%}
+
+#endif // SWIG_CSHARP_WSTRING_EXCEPTION_HELPER_
+#endif // SWIG_CSHARP_NO_WSTRING_EXCEPTION_HELPER
+
 
 // wchar_t
 %typemap(ctype) wchar_t "wchar_t"
@@ -77,13 +161,64 @@ SWIGEXPORT void SWIGSTDCALL SWIGRegisterWStringCallback_$module(SWIG_CSharpWStri
 %typemap(typecheck) wchar_t = char;
 
 // wchar_t *
-%typemap(ctype) wchar_t * "wchar_t *"
+
-%typemap(imtype, inattributes="[global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.LPWStr)]", out="global::System.IntPtr" ) wchar_t * "string"
+%fragment("Swig_csharp_UTF16ToWCharPtr", "header") %{
+/* For converting from .NET UTF16 (2 byte unicode) strings. wchar_t is 2 bytes on Windows, 4 bytes on Linux. */
+static wchar_t * Swig_csharp_UTF16ToWCharPtr(const unsigned short *str) {
+  if (sizeof(wchar_t) == 2) {
+    return (wchar_t *)str;
+  } else {
+    wchar_t *result = 0;
+
+    if (str) {
+      const unsigned short *pBegin(str);
+      const unsigned short *pEnd(pBegin);
+      wchar_t *ptr = 0;
+
+      while (*pEnd != 0)
+        ++pEnd;
+
+#ifdef __cplusplus
+      result = ptr = new wchar_t[pEnd - pBegin + 1];
+#else
+      result = ptr = (wchar_t *)malloc(sizeof(wchar_t) * (pEnd - pBegin + 1));
+#endif
+      while(pBegin != pEnd)
+        *ptr++ = *pBegin++;
+      *ptr++ = 0;
+    }
+
+    return result;
+  }
+}
+%}
+
+%fragment("Swig_csharp_UTF16ToWCharPtrFree", "header") %{
+static void Swig_csharp_UTF16ToWCharPtrFree(wchar_t *str) {
+  if (sizeof(wchar_t) != 2) {
+#ifdef __cplusplus
+    delete [] str;
+#else
+    free(str);
+#endif
+  }
+}
+%}
+
+%typemap(ctype, out="void *") wchar_t * "unsigned short *"
+%typemap(imtype,
+         inattributes="[global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.LPWStr)]",
+         outattributes="[return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.LPWStr)]",
+         directorinattributes="[global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.LPWStr)]",
+         directoroutattributes="[return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.LPWStr)]"
+         ) wchar_t * "string"
 %typemap(cstype) wchar_t * "string"
+%typemap(csdirectorin) wchar_t * "$iminput"
+%typemap(csdirectorout) wchar_t * "$cscall"
 
 %typemap(csin) wchar_t * "$csinput"
 %typemap(csout, excode=SWIGEXCODE) wchar_t * {
-    string ret = global::System.Runtime.InteropServices.Marshal.PtrToStringUni($imcall);$excode
+    string ret = $imcall;$excode
     return ret;
   }
 %typemap(csvarin, excode=SWIGEXCODE2) wchar_t * %{
@@ -92,12 +227,109 @@ SWIGEXPORT void SWIGSTDCALL SWIGRegisterWStringCallback_$module(SWIG_CSharpWStri
     } %}
 %typemap(csvarout, excode=SWIGEXCODE2) wchar_t * %{
     get {
-      string ret = global::System.Runtime.InteropServices.Marshal.PtrToStringUni($imcall);$excode
+      string ret = $imcall;$excode
       return ret;
     } %}
 
-%typemap(in) wchar_t * %{ $1 = ($1_ltype)$input; %}
+%typemap(in, fragment="Swig_csharp_UTF16ToWCharPtr") wchar_t *
-%typemap(out) wchar_t * %{ $result = (wchar_t *)$1; %}
+%{ $1 = Swig_csharp_UTF16ToWCharPtr($input); %}
+
+%typemap(out) wchar_t * %{ $result = $1 ? SWIG_csharp_wstring_callback($1) : 0; %}
+
+%typemap(freearg, fragment="Swig_csharp_UTF16ToWCharPtrFree") wchar_t *
+%{ Swig_csharp_UTF16ToWCharPtrFree($1); %}
+
+%typemap(directorout, warning=SWIGWARN_TYPEMAP_DIRECTOROUT_PTR_MSG) wchar_t *
+%{ $result = Swig_csharp_UTF16ToWCharPtr($input); %}
+
+%typemap(directorin) wchar_t * %{ $input = SWIG_csharp_wstring_with_length_callback($1, (int)wcslen($1)); %}
 
 %typemap(typecheck) wchar_t * = char *;
 
+%typemap(throws, canthrow=1, fragment="<wchar.h>") wchar_t *
+%{ SWIG_csharp_ApplicationException_callback($1, (int)wcslen($1));
+   return $null; %}
+
+
+/* Default typemap for handling wchar_t * members (based on char * in swig.swg) */
+
+#ifdef __cplusplus
+%typemap(memberin,fragment="<wchar.h>") wchar_t * {
+  delete [] $1;
+  if ($input && sizeof(wchar_t) == 2) {
+    $1 = ($1_type) (new wchar_t[wcslen((const wchar_t *)$input)+1]);
+    wcscpy((wchar_t *)$1, (const wchar_t *)$input);
+  } else {
+    $1 = $input;
+    $input = 0;
+  }
+}
+%typemap(memberin,warning=SWIGWARN_TYPEMAP_WCHARLEAK_MSG,fragment="<wchar.h>") const wchar_t * {
+  if ($input && sizeof(wchar_t) == 2) {
+    $1 = ($1_type) (new wchar_t[wcslen((const wchar_t *)$input)+1]);
+    wcscpy((wchar_t *)$1, (const wchar_t *)$input);
+  } else {
+    $1 = $input;
+    $input = 0;
+  }
+}
+%typemap(globalin,fragment="<wchar.h>") wchar_t * {
+  delete [] $1;
+  if ($input && sizeof(wchar_t) == 2) {
+    $1 = ($1_type) (new wchar_t[wcslen((const wchar_t *)$input)+1]);
+    wcscpy((wchar_t *)$1, (const wchar_t *)$input);
+  } else {
+    $1 = $input;
+    $input = 0;
+  }
+}
+%typemap(globalin,warning=SWIGWARN_TYPEMAP_WCHARLEAK_MSG,fragment="<wchar.h>") const wchar_t * {
+  if ($input && sizeof(wchar_t) == 2) {
+    $1 = ($1_type) (new wchar_t[wcslen((const wchar_t *)$input)+1]);
+    wcscpy((wchar_t *)$1, (const wchar_t *)$input);
+  } else {
+    $1 = $input;
+    $input = 0;
+  }
+}
+#else
+%typemap(memberin,fragment="<wchar.h>") wchar_t * {
+  free($1);
+  if ($input && sizeof(wchar_t) == 2) {
+    $1 = ($1_type) malloc(wcslen((const wchar_t *)$input)+1);
+    wcscpy((wchar_t *)$1, (const wchar_t *)$input);
+  } else {
+    $1 = $input;
+    $input = 0;
+  }
+}
+%typemap(memberin,warning=SWIGWARN_TYPEMAP_WCHARLEAK_MSG,fragment="<wchar.h>") const wchar_t * {
+  if ($input && sizeof(wchar_t) == 2) {
+    $1 = ($1_type) malloc(wcslen((const wchar_t *)$input)+1);
+    wcscpy((wchar_t *)$1, (const wchar_t *)$input);
+  } else {
+    $1 = $input;
+    $input = 0;
+  }
+}
+%typemap(globalin,fragment="<wchar.h>") wchar_t * {
+  free($1);
+  if ($input && sizeof(wchar_t) == 2) {
+    $1 = ($1_type) malloc(wcslen((const wchar_t *)$input)+1);
+    wcscpy((wchar_t *)$1, (const wchar_t *)$input);
+  } else {
+    $1 = $input;
+    $input = 0;
+  }
+}
+%typemap(globalin,warning=SWIGWARN_TYPEMAP_WCHARLEAK_MSG,fragment="<wchar.h>") const wchar_t * {
+  if ($input && sizeof(wchar_t) == 2) {
+    $1 = ($1_type) malloc(wcslen((const wchar_t *)$input)+1);
+    wcscpy((wchar_t *)$1, (const wchar_t *)$input);
+  } else {
+    $1 = $input;
+    $input = 0;
+  }
+}
+
+#endif

linux/bin/swig/share/swig/4.1.0/d/boost_shared_ptr.i

@@ -23,10 +23,10 @@
   }
   $1 = *argp; %}
 %typemap(out) CONST TYPE
-%{ $result = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(new $1_ltype(($1_ltype &)$1)); %}
+%{ $result = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(new $1_ltype($1)); %}
 
 %typemap(directorin) CONST TYPE
-%{ $input = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > (new $1_ltype((const $1_ltype &)$1)); %}
+%{ $input = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > (new $1_ltype(SWIG_STD_MOVE($1))); %}
 
 %typemap(directorout) CONST TYPE
 %{ if (!$input) {
@@ -116,7 +116,7 @@
 %typemap(in) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > * ($*1_ltype tempnull)
 %{ $1 = $input ? ($1_ltype)$input : &tempnull; %}
 %typemap(out, fragment="SWIG_null_deleter") SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *
-%{ $result = ($1 && *$1) ? new $*1_ltype(*($1_ltype)$1) : 0;
+%{ $result = ($1 && *$1) ? new $*1_ltype(*$1) : 0;
    if ($owner) delete $1; %}
 
 %typemap(directorin) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *

linux/bin/swig/share/swig/4.1.0/d/dclassgen.swg

@@ -76,6 +76,19 @@ public static void* swigGetCPtr(typeof(this) obj) {
   return (obj is null) ? null : obj.swigCPtr;
 }
 
+public static void* swigRelease(typeof(this) obj) {
+  if (obj !is null) {
+    if (!obj.swigCMemOwn)
+      throw new Exception("Cannot release ownership as memory is not owned");
+    void* ptr = obj.swigCPtr;
+    obj.swigCMemOwn = false;
+    obj.dispose();
+    return ptr;
+  } else {
+    return null;
+  }
+}
+
 mixin $imdmodule.SwigOperatorDefinitions;
 %}
 
@@ -92,6 +105,19 @@ public static void* swigGetCPtr(typeof(this) obj) {
   return (obj is null) ? null : obj.swigCPtr;
 }
 
+public static void* swigRelease(typeof(this) obj) {
+  if (obj !is null) {
+    if (!obj.swigCMemOwn)
+      throw new Exception("Cannot release ownership as memory is not owned");
+    void* ptr = obj.swigCPtr;
+    obj.swigCMemOwn = false;
+    obj.dispose();
+    return ptr;
+  } else {
+    return null;
+  }
+}
+
 mixin $imdmodule.SwigOperatorDefinitions;
 %}
 
@@ -100,7 +126,7 @@ mixin $imdmodule.SwigOperatorDefinitions;
  * Type wrapper classes.
  */
 
-%typemap(dbody) SWIGTYPE *, SWIGTYPE &, SWIGTYPE [] %{
+%typemap(dbody) SWIGTYPE *, SWIGTYPE &, SWIGTYPE &&, SWIGTYPE [] %{
 private void* swigCPtr;
 
 public this(void* cObject, bool futureUse) {
@@ -115,6 +141,10 @@ public static void* swigGetCPtr(typeof(this) obj) {
   return (obj is null) ? null : obj.swigCPtr;
 }
 
+public static void* swigRelease(typeof(this) obj) {
+  return (obj is null) ? null : obj.swigCPtr;
+}
+
 mixin $imdmodule.SwigOperatorDefinitions;
 %}
 

linux/bin/swig/share/swig/4.1.0/d/dswigtype.swg

@@ -52,7 +52,7 @@
 
 %typemap(out) SWIGTYPE
 #ifdef __cplusplus
-%{ $result = new $1_ltype((const $1_ltype &)$1); %}
+%{ $result = new $1_ltype($1); %}
 #else
 {
   $&1_ltype $1ptr = ($&1_ltype) malloc(sizeof($1_ltype));
@@ -62,7 +62,7 @@
 #endif
 
 %typemap(directorin) SWIGTYPE
-  "$input = (void *)new $1_ltype((const $1_ltype &)$1);"
+  "$input = (void *)new $1_ltype(SWIG_STD_MOVE($1));"
 %typemap(directorout) SWIGTYPE
 %{ if (!$input) {
      SWIG_DSetPendingException(SWIG_DIllegalArgumentException, "Unexpected null return for type $1_type");
@@ -122,7 +122,7 @@
 
 %typemap(in, canthrow=1) SWIGTYPE & %{ $1 = ($1_ltype)$input;
   if (!$1) {
-    SWIG_DSetPendingException(SWIG_DIllegalArgumentException, "$1_type type is null");
+    SWIG_DSetPendingException(SWIG_DIllegalArgumentException, "$1_type is null");
     return $null;
   } %}
 %typemap(out) SWIGTYPE & "$result = (void *)$1;"
@@ -157,11 +157,12 @@
  * Rvalue reference conversion typemaps.
  */
 
-%typemap(in, canthrow=1) SWIGTYPE && %{ $1 = ($1_ltype)$input;
+%typemap(in, canthrow=1, fragment="<memory>") SWIGTYPE && (std::unique_ptr<$*1_ltype> rvrdeleter) %{ $1 = ($1_ltype)$input;
   if (!$1) {
-    SWIG_DSetPendingException(SWIG_DIllegalArgumentException, "$1_type type is null");
+    SWIG_DSetPendingException(SWIG_DIllegalArgumentException, "$1_type is null");
     return $null;
-  } %}
+  }
+  rvrdeleter.reset($1); %}
 %typemap(out) SWIGTYPE && "$result = (void *)$1;"
 
 %typemap(directorin) SWIGTYPE &&
@@ -182,7 +183,7 @@
 
 %typemap(din,
   nativepointer="cast(void*)$dinput"
-) SWIGTYPE && "$dclassname.swigGetCPtr($dinput)"
+) SWIGTYPE && "$dclassname.swigRelease($dinput)"
 %typemap(dout, excode=SWIGEXCODE,
   nativepointer="{\n  auto ret = cast($dtype)$imcall;$excode\n  return ret;\n}") SWIGTYPE && {
   $dclassname ret = new $dclassname($imcall, $owner);$excode

linux/bin/swig/share/swig/4.1.0/d/std_auto_ptr.i

@@ -0,0 +1,42 @@
+/* -----------------------------------------------------------------------------
+ * std_auto_ptr.i
+ *
+ * SWIG library file for handling std::auto_ptr.
+ * Memory ownership is passed from the std::auto_ptr C++ layer to the proxy
+ * class when returning a std::auto_ptr from a function.
+ * Memory ownership is passed from the proxy class to the std::auto_ptr in the
+ * C++ layer when passed as a parameter to a wrapped function.
+ * ----------------------------------------------------------------------------- */
+
+%define %auto_ptr(TYPE)
+%typemap (ctype) std::auto_ptr< TYPE > "void *"
+%typemap (imtype) std::auto_ptr< TYPE > "void*"
+%typemap (dtype) std::auto_ptr< TYPE > "$typemap(dtype, TYPE)"
+
+%typemap(in) std::auto_ptr< TYPE >
+%{ $1.reset((TYPE *)$input); %}
+
+%typemap(din,
+  nativepointer="cast(void*)$dinput"
+) std::auto_ptr< TYPE > "$typemap(dtype, TYPE).swigRelease($dinput)"
+
+%typemap (out) std::auto_ptr< TYPE > %{
+  $result = (void *)$1.release();
+%}
+
+%typemap(dout, excode=SWIGEXCODE,
+  nativepointer="{\n  auto ret = cast($dtype)$imcall;$excode\n  return ret;\n}"
+) std::auto_ptr< TYPE > {
+  void* cPtr = $imcall;
+  $typemap(dtype, TYPE) ret = (cPtr is null) ? null : new $typemap(dtype, TYPE)(cPtr, true);$excode
+  return ret;
+}
+
+%typemap(typecheck, precedence=SWIG_TYPECHECK_POINTER, equivalent="TYPE *") std::auto_ptr< TYPE > ""
+
+%template() std::auto_ptr< TYPE >;
+%enddef
+
+namespace std {
+  template <class T> class auto_ptr {};
+}

linux/bin/swig/share/swig/4.1.0/d/std_unique_ptr.i

@@ -0,0 +1,42 @@
+/* -----------------------------------------------------------------------------
+ * std_unique_ptr.i
+ *
+ * SWIG library file for handling std::unique_ptr.
+ * Memory ownership is passed from the std::unique_ptr C++ layer to the proxy
+ * class when returning a std::unique_ptr from a function.
+ * Memory ownership is passed from the proxy class to the std::unique_ptr in the
+ * C++ layer when passed as a parameter to a wrapped function.
+ * ----------------------------------------------------------------------------- */
+
+%define %unique_ptr(TYPE)
+%typemap (ctype) std::unique_ptr< TYPE > "void *"
+%typemap (imtype) std::unique_ptr< TYPE > "void*"
+%typemap (dtype) std::unique_ptr< TYPE > "$typemap(dtype, TYPE)"
+
+%typemap(in) std::unique_ptr< TYPE >
+%{ $1.reset((TYPE *)$input); %}
+
+%typemap(din,
+  nativepointer="cast(void*)$dinput"
+) std::unique_ptr< TYPE > "$typemap(dtype, TYPE).swigRelease($dinput)"
+
+%typemap (out) std::unique_ptr< TYPE > %{
+  $result = (void *)$1.release();
+%}
+
+%typemap(dout, excode=SWIGEXCODE,
+  nativepointer="{\n  auto ret = cast($dtype)$imcall;$excode\n  return ret;\n}"
+) std::unique_ptr< TYPE > {
+  void* cPtr = $imcall;
+  $typemap(dtype, TYPE) ret = (cPtr is null) ? null : new $typemap(dtype, TYPE)(cPtr, true);$excode
+  return ret;
+}
+
+%typemap(typecheck, precedence=SWIG_TYPECHECK_POINTER, equivalent="TYPE *") std::unique_ptr< TYPE > ""
+
+%template() std::unique_ptr< TYPE >;
+%enddef
+
+namespace std {
+  template <class T> class unique_ptr {};
+}

linux/bin/swig/share/swig/4.1.0/d/swigmove.i

@@ -0,0 +1,16 @@
+/* -----------------------------------------------------------------------------
+ * swigmove.i
+ *
+ * Input typemaps library for implementing full move semantics when passing
+ * parameters by value.
+ * ----------------------------------------------------------------------------- */
+
+%typemap(in, canthrow=1) SWIGTYPE MOVE ($&1_type argp)
+%{ argp = ($&1_ltype)$input;
+   if (!argp) {
+     SWIG_DSetPendingException(SWIG_DIllegalArgumentException, "Attempt to dereference null $1_type");
+     return $null;
+   }
+   SwigValueWrapper< $1_ltype >::reset($1, argp); %}
+
+%typemap(din) SWIGTYPE MOVE "$dclassname.swigRelease($dinput)"

linux/bin/swig/share/swig/4.1.0/go/go.swg

@@ -388,8 +388,9 @@
 %typemap(gotype) SWIGTYPE &&
 %{$gotypename%}
 
-%typemap(in) SWIGTYPE &&
+%typemap(in, fragment="<memory>") SWIGTYPE && (std::unique_ptr<$*1_ltype> rvrdeleter)
-%{ $1 = *($&1_ltype)&$input; %}
+%{ $1 = *($&1_ltype)&$input;
+rvrdeleter.reset($1); %}
 
 %typemap(out) SWIGTYPE &&
 %{ *($&1_ltype)&$result = $1; %}
@@ -625,7 +626,7 @@
 %typemap(goout) SWIGTYPE ""
 
 %typemap(directorin) SWIGTYPE
-%{ $input = new $1_ltype((const $1_ltype &)$1); %}
+%{ $input = new $1_ltype(SWIG_STD_MOVE($1)); %}
 
 %typemap(godirectorin) SWIGTYPE ""
 

linux/bin/swig/share/swig/4.1.0/go/std_string.i

@@ -52,6 +52,9 @@ class string;
 %typemap(godirectorin,fragment="CopyString") string
 %{ $result = swigCopyString($input) %}
 
+%typemap(throws) string
+%{ _swig_gopanic($1.c_str()); %}
+
 %typemap(in) const string &
 %{
   $*1_ltype $1_str($input.p, $input.n);
@@ -88,22 +91,30 @@ class string;
 %typemap(godirectorin,fragment="CopyString") const string &
 %{ $result = swigCopyString($input) %}
 
+%typemap(throws) const string &
+%{ _swig_gopanic($1.c_str()); %}
+
 
 %typemap(gotype) string * "*string"
 
 %typemap(in) string * (string temp)
 %{
+  if ($input) {
     temp.assign($input->p, $input->n);
     $1 = &temp;
+  } else
+    $1 = 0;
 %}
 
 %typemap(godirectorout) string *
 %{
-  {
+  if $input != nil {
     p := Swig_malloc(len(*$input))
     s := (*[1<<30]byte)(unsafe.Pointer(p))[:len(*$input)]
     copy(s, *$input)
     $result = (*string)(unsafe.Pointer(&s))
+  } else {
+    $result = nil
   }
 %}
 
@@ -125,17 +136,27 @@ class string;
 
 %typemap(directorin,fragment="AllocateString") string * (_gostring_ temp)
 %{
+  if ($1) {
     temp = Swig_AllocateString($1->data(), $1->length());
     $input = &temp;
+  } else
+    $input = 0;
 %}
 
 %typemap(godirectorin,fragment="CopyString") string *
 %{ *$result = swigCopyString(*$input); %}
 
 %typemap(argout,fragment="AllocateString") string *
-%{ *$input = Swig_AllocateString($1->data(), $1->length()); %}
+%{
+  if ($1)
+    *$input = Swig_AllocateString($1->data(), $1->length());
+%}
 
 %typemap(goargout,fragment="CopyString") string *
-%{ *$input = swigCopyString(*$1) %}
+%{
+  if $input != nil {
+    *$1 = swigCopyString(*$input)
+  }
+%}
 
 }

linux/bin/swig/share/swig/4.1.0/go/swigmove.i

@@ -0,0 +1,15 @@
+/* -----------------------------------------------------------------------------
+ * swigmove.i
+ *
+ * Input typemaps library for implementing full move semantics when passing
+ * parameters by value.
+ * ----------------------------------------------------------------------------- */
+
+%typemap(in) SWIGTYPE MOVE ($&1_type argp)
+%{
+  argp = ($&1_ltype)$input;
+  if (argp == NULL) {
+    _swig_gopanic("Attempt to dereference null $1_type");
+  }
+  SwigValueWrapper< $1_ltype >::reset($1, argp);
+%}

linux/bin/swig/share/swig/4.1.0/guile/guile_scm_run.swg

@@ -2,6 +2,12 @@
  * guile_scm_run.swg
  * ----------------------------------------------------------------------------- */
 
+#if __GNUC__ >= 10
+#if defined(__cplusplus)
+#pragma GCC diagnostic ignored "-Wvolatile" /* For 'volatile SCM *' in at least Guile 3.0 and earlier */
+#endif
+#endif
+
 #include <libguile.h>
 #include <stdio.h>
 #include <string.h>
@@ -112,6 +118,8 @@ static SCM swig_symbol = SCM_EOL;
   ( !scm_is_null(x) && SCM_INSTANCEP(x) && scm_is_true(scm_slot_exists_p(x, swig_symbol)) \
       ? scm_slot_ref(x, swig_symbol) : (x) )
 
+SWIGINTERN void SWIG_Guile_MarkPointerNoncollectable(SCM s);
+
 SWIGINTERN SCM
 SWIG_Guile_NewPointerObj(void *ptr, swig_type_info *type, int owner)
 {
@@ -125,7 +133,7 @@ SWIG_Guile_NewPointerObj(void *ptr, swig_type_info *type, int owner)
     else
       SCM_NEWSMOB2(smob, swig_tag, ptr, (void *) type);
 
-    if (!cdata || SCM_NULLP(cdata->goops_class) || swig_make_func == SCM_EOL ) {
+    if (!cdata || scm_is_null(cdata->goops_class) || swig_make_func == SCM_EOL ) {
       return smob;
     } else {
       /* the scm_make() C function only handles the creation of gf,
@@ -145,7 +153,7 @@ SWIGINTERN unsigned long
 SWIG_Guile_PointerAddress(SCM object)
 {
   SCM smob = SWIG_Guile_GetSmob(object);
-  if (SCM_NULLP(smob)) return 0;
+  if (scm_is_null(smob)) return 0;
   else if (SCM_SMOB_PREDICATE(swig_tag, smob)
 	   || SCM_SMOB_PREDICATE(swig_collectable_tag, smob)
 	   || SCM_SMOB_PREDICATE(swig_destroyed_tag, smob)) {
@@ -158,7 +166,7 @@ SWIGINTERN swig_type_info *
 SWIG_Guile_PointerType(SCM object)
 {
   SCM smob = SWIG_Guile_GetSmob(object);
-  if (SCM_NULLP(smob)) return NULL;
+  if (scm_is_null(smob)) return NULL;
   else if (SCM_SMOB_PREDICATE(swig_tag, smob)
 	   || SCM_SMOB_PREDICATE(swig_collectable_tag, smob)
 	   || SCM_SMOB_PREDICATE(swig_destroyed_tag, smob)) {
@@ -185,8 +193,9 @@ SWIG_Guile_ConvertPtr(SCM s, void **result, swig_type_info *type, int flags)
   swig_cast_info *cast;
   swig_type_info *from;
   SCM smob = SWIG_Guile_GetSmob(s);
+  int ret = SWIG_ERROR;
 
-  if (SCM_NULLP(smob)) {
+  if (scm_is_null(smob)) {
     *result = NULL;
     return (flags & SWIG_POINTER_NO_NULL) ? SWIG_NullReferenceError : SWIG_OK;
 #if SCM_MAJOR_VERSION >= 2
@@ -197,22 +206,36 @@ SWIG_Guile_ConvertPtr(SCM s, void **result, swig_type_info *type, int flags)
   } else if (SWIG_Guile_IsValidSmob(smob)) {
     from = (swig_type_info *) SCM_CELL_WORD_2(smob);
     if (!from) return SWIG_ERROR;
+
+    if ((flags & SWIG_POINTER_RELEASE) == SWIG_POINTER_RELEASE) {
+      if ((SCM_CELL_TYPE(smob) == swig_collectable_tag && SCM_CELL_WORD_1(smob) == 0) || SCM_CELL_TYPE(smob) == swig_tag) {
+        return SWIG_ERROR_RELEASE_NOT_OWNED;
+      }
+    }
+
     if (type) {
       cast = SWIG_TypeCheckStruct(from, type);
       if (cast) {
         int newmemory = 0;
         *result = SWIG_TypeCast(cast, (void *) SCM_CELL_WORD_1(smob), &newmemory);
         assert(!newmemory); /* newmemory handling not yet implemented */
-        return SWIG_OK;
+        ret = SWIG_OK;
       } else {
         return SWIG_ERROR;
       }
     } else {
       *result = (void *) SCM_CELL_WORD_1(smob);
-      return SWIG_OK;
+      ret = SWIG_OK;
+    }
+
+    if (flags & SWIG_POINTER_DISOWN) {
+      SWIG_Guile_MarkPointerNoncollectable(smob);
+    }
+    if (flags & SWIG_POINTER_CLEAR) {
+      SCM_SET_CELL_WORD_1(smob, 0);
     }
   }
-  return SWIG_ERROR;
+  return ret;
 }
 
 SWIGINTERNINLINE void *
@@ -252,7 +275,7 @@ SWIGINTERN void
 SWIG_Guile_MarkPointerNoncollectable(SCM s)
 {
   SCM smob = SWIG_Guile_GetSmob(s);
-  if (!SCM_NULLP(smob)) {
+  if (!scm_is_null(smob)) {
     if (SWIG_Guile_IsValidSmob(smob)) {
       SCM_SET_CELL_TYPE(smob, swig_tag);
     }
@@ -265,7 +288,7 @@ SWIGINTERN void
 SWIG_Guile_MarkPointerDestroyed(SCM s)
 {
   SCM smob = SWIG_Guile_GetSmob(s);
-  if (!SCM_NULLP(smob)) {
+  if (!scm_is_null(smob)) {
     if (SWIG_Guile_IsValidSmob(smob)) {
       SCM_SET_CELL_TYPE(smob, swig_destroyed_tag);
     }
@@ -486,20 +509,20 @@ SWIG_Guile_GetArgs (SCM *dest, SCM rest,
   int i;
   int num_args_passed = 0;
   for (i = 0; i<reqargs; i++) {
-    if (!SCM_CONSP(rest))
+    if (!scm_is_pair(rest))
       scm_wrong_num_args(scm_from_utf8_string(procname ? (char *) procname : "unknown procedure"));
     *dest++ = SCM_CAR(rest);
     rest = SCM_CDR(rest);
     num_args_passed++;
   }
-  for (i = 0; i<optargs && SCM_CONSP(rest); i++) {
+  for (i = 0; i<optargs && scm_is_pair(rest); i++) {
     *dest++ = SCM_CAR(rest);
     rest = SCM_CDR(rest);
     num_args_passed++;
   }
   for (; i<optargs; i++)
     *dest++ = SCM_UNDEFINED;
-  if (!SCM_NULLP(rest))
+  if (!scm_is_null(rest))
       scm_wrong_num_args(scm_from_utf8_string(procname ? (char *) procname : "unknown procedure"));
   return num_args_passed;
 }

linux/bin/swig/share/swig/4.1.0/guile/std_auto_ptr.i

@@ -0,0 +1,39 @@
+/* -----------------------------------------------------------------------------
+ * std_auto_ptr.i
+ *
+ * SWIG library file for handling std::auto_ptr.
+ * Memory ownership is passed from the std::auto_ptr C++ layer to the proxy
+ * class when returning a std::auto_ptr from a function.
+ * Memory ownership is passed from the proxy class to the std::auto_ptr in the
+ * C++ layer when passed as a parameter to a wrapped function.
+ * ----------------------------------------------------------------------------- */
+
+%define %auto_ptr(TYPE)
+%typemap(in, noblock=1) std::auto_ptr< TYPE > (void *argp = 0, int res = 0) {
+  res = SWIG_ConvertPtr($input, &argp, $descriptor(TYPE *), SWIG_POINTER_RELEASE);
+  if (!SWIG_IsOK(res)) {
+    if (res == SWIG_ERROR_RELEASE_NOT_OWNED) {
+      scm_misc_error(FUNC_NAME, "Cannot release ownership as memory is not owned for argument $argnum of type 'TYPE *'", SCM_EOL);
+    } else {
+      %argument_fail(res, "TYPE *", $symname, $argnum);
+    }
+  }
+  $1.reset((TYPE *)argp);
+}
+
+%typemap (out) std::auto_ptr< TYPE > %{
+  %set_output(SWIG_NewPointerObj($1.release(), $descriptor(TYPE *), SWIG_POINTER_OWN));
+%}
+
+%typemap(typecheck, precedence=SWIG_TYPECHECK_POINTER, equivalent="TYPE *", noblock=1) std::auto_ptr< TYPE > {
+  void *vptr = 0;
+  int res = SWIG_ConvertPtr($input, &vptr, $descriptor(TYPE *), 0);
+  $1 = SWIG_CheckState(res);
+}
+
+%template() std::auto_ptr< TYPE >;
+%enddef
+
+namespace std {
+  template <class T> class auto_ptr {};
+}

linux/bin/swig/share/swig/4.1.0/guile/std_string.i

@@ -83,4 +83,13 @@ namespace std {
         $result = SWIG_str02scm($1.c_str());
     }
 
+    %typemap(throws) string {
+      scm_throw(scm_from_locale_symbol((char *) "swig-exception"),
+                scm_list_n(SWIG_str02scm($1.c_str()), SCM_UNDEFINED));
+    }
+
+    %typemap(throws) const string & {
+      scm_throw(scm_from_locale_symbol((char *) "swig-exception"),
+                scm_list_n(SWIG_str02scm($1.c_str()), SCM_UNDEFINED));
+    }
 }

linux/bin/swig/share/swig/4.1.0/guile/std_unique_ptr.i

@@ -0,0 +1,39 @@
+/* -----------------------------------------------------------------------------
+ * std_unique_ptr.i
+ *
+ * SWIG library file for handling std::unique_ptr.
+ * Memory ownership is passed from the std::unique_ptr C++ layer to the proxy
+ * class when returning a std::unique_ptr from a function.
+ * Memory ownership is passed from the proxy class to the std::unique_ptr in the
+ * C++ layer when passed as a parameter to a wrapped function.
+ * ----------------------------------------------------------------------------- */
+
+%define %unique_ptr(TYPE)
+%typemap(in, noblock=1) std::unique_ptr< TYPE > (void *argp = 0, int res = 0) {
+  res = SWIG_ConvertPtr($input, &argp, $descriptor(TYPE *), SWIG_POINTER_RELEASE);
+  if (!SWIG_IsOK(res)) {
+    if (res == SWIG_ERROR_RELEASE_NOT_OWNED) {
+      scm_misc_error(FUNC_NAME, "Cannot release ownership as memory is not owned for argument $argnum of type 'TYPE *'", SCM_EOL);
+    } else {
+      %argument_fail(res, "TYPE *", $symname, $argnum);
+    }
+  }
+  $1.reset((TYPE *)argp);
+}
+
+%typemap (out) std::unique_ptr< TYPE > %{
+  %set_output(SWIG_NewPointerObj($1.release(), $descriptor(TYPE *), SWIG_POINTER_OWN));
+%}
+
+%typemap(typecheck, precedence=SWIG_TYPECHECK_POINTER, equivalent="TYPE *", noblock=1) std::unique_ptr< TYPE > {
+  void *vptr = 0;
+  int res = SWIG_ConvertPtr($input, &vptr, $descriptor(TYPE *), 0);
+  $1 = SWIG_CheckState(res);
+}
+
+%template() std::unique_ptr< TYPE >;
+%enddef
+
+namespace std {
+  template <class T> class unique_ptr {};
+}

linux/bin/swig/share/swig/4.1.0/guile/swigmove.i

@@ -0,0 +1,19 @@
+/* -----------------------------------------------------------------------------
+ * swigmove.i
+ *
+ * Input typemaps library for implementing full move semantics when passing
+ * parameters by value.
+ * ----------------------------------------------------------------------------- */
+
+%typemap(in, noblock=1) SWIGTYPE MOVE (void *argp = 0, int res = 0) {
+  res = SWIG_ConvertPtr($input, &argp, $&1_descriptor, SWIG_POINTER_RELEASE);
+  if (!SWIG_IsOK(res)) {
+    if (res == SWIG_ERROR_RELEASE_NOT_OWNED) {
+      %releasenotowned_fail(res, "$1_type", $symname, $argnum);
+    } else {
+      %argument_fail(res, "$1_type", $symname, $argnum);
+    }
+  }
+  if (!argp) { %argument_nullref("$1_type", $symname, $argnum); }
+  SwigValueWrapper< $1_ltype >::reset($1, ($&1_type)argp);
+}

linux/bin/swig/share/swig/4.1.0/guile/swigrun.i

@@ -4,8 +4,6 @@
 
 #ifdef SWIGGUILE_SCM
 
-/* Hook the runtime module initialization
-   into the shared initialization function SWIG_Guile_Init. */
 %runtime %{
 /* Hook the runtime module initialization
    into the shared initialization function SWIG_Guile_Init. */

linux/bin/swig/share/swig/4.1.0/guile/typemaps.i

@@ -4,17 +4,43 @@
  * Guile-specific typemaps
  * ----------------------------------------------------------------------------- */
 
+/* These are defined with a view to eventually merging with those defined for other target languages in swigtypemaps.swg and exception.swg */
+#define %set_output(obj)                  $result = obj
+#define %set_varoutput(obj)               $result = obj
+#define %argument_fail(_code, _type, _name, _argn)	scm_wrong_type_arg((char *) FUNC_NAME, _argn, $input)
+#define %as_voidptr(ptr)		(void*)(ptr)
+#define %argument_nullref(_type, _name, _argn) scm_misc_error(FUNC_NAME, "invalid null reference for argument " #_argn " of type '" _type "'", SCM_EOL)
+#define %releasenotowned_fail(_code, _type, _name, _argn) scm_misc_error(FUNC_NAME, "cannot release ownership as memory is not owned for argument " #_argn " of type '" _type "'", SCM_EOL)
+
 /* Pointers */
 
-%typemap(in) SWIGTYPE *, SWIGTYPE &, SWIGTYPE &&, SWIGTYPE [] {
+%typemap(in) SWIGTYPE *, SWIGTYPE [] {
   $1 = ($1_ltype)SWIG_MustGetPtr($input, $descriptor, $argnum, 0);
 }
-%typemap(freearg) SWIGTYPE *, SWIGTYPE &, SWIGTYPE &&, SWIGTYPE [] "";
+%typemap(in) SWIGTYPE & ($1_ltype argp) {
+  argp = ($1_ltype)SWIG_MustGetPtr($input, $descriptor, $argnum, 0);
+  if (!argp) { %argument_nullref("$1_type", $symname, $argnum); }
+  $1 = argp;
+}
+%typemap(in, noblock=1, fragment="<memory>") SWIGTYPE && (void *argp = 0, int res = 0, std::unique_ptr<$*1_ltype> rvrdeleter) {
+  res = SWIG_ConvertPtr($input, &argp, $descriptor, SWIG_POINTER_RELEASE);
+  if (!SWIG_IsOK(res)) {
+    if (res == SWIG_ERROR_RELEASE_NOT_OWNED) {
+      %releasenotowned_fail(res, "$1_type", $symname, $argnum);
+    } else {
+      %argument_fail(res, "$1_type", $symname, $argnum);
+    }
+  }
+  if (!argp) { %argument_nullref("$1_type", $symname, $argnum); }
+  $1 = ($1_ltype)argp;
+  rvrdeleter.reset($1);
+}
+%typemap(freearg) SWIGTYPE *, SWIGTYPE &, SWIGTYPE &&, SWIGTYPE [] ""
 
 %typemap(in) void * {
   $1 = ($1_ltype)SWIG_MustGetPtr($input, NULL, $argnum, 0);
 }
-%typemap(freearg) void * "";
+%typemap(freearg) void * ""
 
 %typemap(varin) SWIGTYPE * {
   $1 = ($1_ltype)SWIG_MustGetPtr($input, $descriptor, 1, 0);
@@ -117,6 +143,7 @@
 
 %typemap(in) SWIGTYPE ($&1_ltype argp) {
   argp = ($&1_ltype)SWIG_MustGetPtr($input, $&1_descriptor, $argnum, 0);
+  if (!argp) { %argument_nullref("$1_type", $symname, $argnum); }
   $1 = *argp;
 }
 
@@ -130,7 +157,7 @@
 #ifdef __cplusplus
 {
   $&1_ltype resultptr;
-  resultptr = new $1_ltype((const $1_ltype &) $1);
+  resultptr = new $1_ltype($1);
   $result =  SWIG_NewPointerObj (resultptr, $&1_descriptor, 1);
 } 
 #else
@@ -145,8 +172,7 @@
 %typemap(varout) SWIGTYPE 
 #ifdef __cplusplus
 {
-  $&1_ltype resultptr;
+  $&1_ltype resultptr = ($&1_ltype)&$1;
-  resultptr = new $1_ltype((const $1_ltype&) $1);
   $result =  SWIG_NewPointerObj (resultptr, $&1_descriptor, 0);
 } 
 #else
@@ -322,14 +348,14 @@ SIMPLE_MAP(unsigned long long, scm_to_ulong_long, scm_from_ulong_long, integer);
 /* SWIG_scm2str makes a malloc'ed copy of the string, so get rid of it after
    the function call. */
 
-%typemap (freearg) char * "if (must_free$argnum) SWIG_free($1);";
+%typemap (freearg) char * "if (must_free$argnum) SWIG_free($1);"
 %typemap (freearg) char **INPUT, char **BOTH "if (must_free$argnum) SWIG_free(*$1);"
 %typemap (freearg) char **OUTPUT "SWIG_free(*$1);"
   
 /* But this shall not apply if we try to pass a single char by
    reference. */
 
-%typemap (freearg) char *OUTPUT, char *BOTH "";
+%typemap (freearg) char *OUTPUT, char *BOTH ""
 
 /* If we set a string variable, delete the old result first, unless const. */
 
@@ -349,13 +375,13 @@ SIMPLE_MAP(unsigned long long, scm_to_ulong_long, scm_from_ulong_long, integer);
 
 /* Void */
 
-%typemap (out,doc="") void "gswig_result = SCM_UNSPECIFIED;";
+%typemap (out,doc="") void "gswig_result = SCM_UNSPECIFIED;"
 
 /* SCM is passed through */
 
 typedef unsigned long SCM;
-%typemap (in) SCM "$1=$input;";
+%typemap (in) SCM "$1=$input;"
-%typemap (out) SCM "$result=$1;";
+%typemap (out) SCM "$result=$1;"
 %typecheck(SWIG_TYPECHECK_POINTER) SCM "$1=1;";
 
 /* ------------------------------------------------------------
@@ -373,11 +399,6 @@ typedef unsigned long SCM;
  * taken from typemaps/swigtype.swg
  * ------------------------------------------------------------ */
 
-#define %set_output(obj)                  $result = obj
-#define %set_varoutput(obj)               $result = obj
-#define %argument_fail(code, type, name, argn)	scm_wrong_type_arg((char *) FUNC_NAME, argn, $input);
-#define %as_voidptr(ptr)		(void*)(ptr)
-
 %typemap(in) SWIGTYPE (CLASS::*) {
   int res = SWIG_ConvertMember($input, %as_voidptr(&$1), sizeof($1), $descriptor);
   if (!SWIG_IsOK(res)) {
@@ -426,7 +447,7 @@ typedef unsigned long SCM;
 %typecheck(SWIG_TYPECHECK_BOOL)
 	bool, bool&, const bool&
 {
-  $1 = SCM_BOOLP($input) ? 1 : 0;
+  $1 = scm_is_bool($input) ? 1 : 0;
 }
 
 %typecheck(SWIG_TYPECHECK_DOUBLE)

linux/bin/swig/share/swig/4.1.0/java/boost_intrusive_ptr.i

@@ -33,7 +33,7 @@
 %}
 %typemap(out, fragment="SWIG_intrusive_deleter") CONST TYPE %{
   //plain value(out)
-  $1_ltype* resultp = new $1_ltype(($1_ltype &)$1);
+  $1_ltype* resultp = new $1_ltype($1);
   intrusive_ptr_add_ref(resultp);
   *(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > **)&$result = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(resultp, SWIG_intrusive_deleter< CONST TYPE >());
 %}
@@ -342,7 +342,7 @@
   }
   $1 = *argp; %}
 %typemap(out) CONST TYPE
-%{ *(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > **)&$result = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(new $1_ltype(($1_ltype &)$1)); %}
+%{ *(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > **)&$result = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(new $1_ltype($1)); %}
 
 // plain pointer
 %typemap(in) CONST TYPE * (SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartarg = 0) %{

linux/bin/swig/share/swig/4.1.0/java/boost_shared_ptr.i

@@ -29,11 +29,11 @@
   }
   $1 = *argp; %}
 %typemap(out) CONST TYPE
-%{ *(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > **)&$result = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(new $1_ltype(($1_ltype &)$1)); %}
+%{ *(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > **)&$result = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(new $1_ltype($1)); %}
 
 %typemap(directorin,descriptor="L$packagepath/$&javaclassname;") CONST TYPE
 %{ $input = 0;
-  *((SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > **)&$input) = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > (new $1_ltype((const $1_ltype &)$1)); %}
+  *((SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > **)&$input) = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > (new $1_ltype(SWIG_STD_MOVE($1))); %}
 
 %typemap(directorout) CONST TYPE
 %{ if (!$input) {

linux/bin/swig/share/swig/4.1.0/java/director.swg

@@ -51,6 +51,10 @@ SWIGINTERN int Swig::GetThreadName(char *name, size_t len) {
 
 #endif
 
+#if defined(SWIG_JAVA_DETACH_ON_THREAD_END)
+#include <pthread.h>
+#endif
+
 namespace Swig {
 
   /* Java object wrapper */
@@ -133,6 +137,19 @@ namespace Swig {
       }
     }
 
+#if defined(SWIG_JAVA_DETACH_ON_THREAD_END)
+    static void detach(void *jvm) {
+      static_cast<JavaVM *>(jvm)->DetachCurrentThread();
+    }
+
+    static void make_detach_key() {
+      pthread_key_create(&detach_key_, detach);
+    }
+
+    /* thread-local key to register a destructor */
+    static pthread_key_t detach_key_;
+#endif
+
   private:
     /* pointer to Java object */
     jobject jthis_;
@@ -140,6 +157,10 @@ namespace Swig {
     bool weak_global_;
   };
 
+#if defined(SWIG_JAVA_DETACH_ON_THREAD_END)
+  pthread_key_t JObjectWrapper::detach_key_;
+#endif
+
   /* Local JNI reference deleter */
   class LocalRefGuard {
     JNIEnv *jenv_;
@@ -201,9 +222,19 @@ namespace Swig {
 #else
         director_->swig_jvm_->AttachCurrentThread(jenv, &args);
 #endif
+
+#if defined(SWIG_JAVA_DETACH_ON_THREAD_END)
+        // At least on Android 6, detaching after every call causes a memory leak.
+        // Instead, register a thread desructor and detach only when the thread ends.
+        // See https://developer.android.com/training/articles/perf-jni#threads
+        static pthread_once_t once = PTHREAD_ONCE_INIT;
+
+        pthread_once(&once, JObjectWrapper::make_detach_key);
+        pthread_setspecific(JObjectWrapper::detach_key_, director->swig_jvm_);
+#endif
       }
       ~JNIEnvWrapper() {
-#if !defined(SWIG_JAVA_NO_DETACH_CURRENT_THREAD)
+#if !defined(SWIG_JAVA_DETACH_ON_THREAD_END) && !defined(SWIG_JAVA_NO_DETACH_CURRENT_THREAD)
         // Some JVMs, eg jdk-1.4.2 and lower on Solaris have a bug and crash with the DetachCurrentThread call.
         // However, without this call, the JVM hangs on exit when the thread was not created by the JVM and creates a memory leak.
         if (env_status == JNI_EDETACHED)

linux/bin/swig/share/swig/4.1.0/java/java.swg

@@ -665,7 +665,7 @@ Swig::LocalRefGuard $1_refguard(jenv, $input); }
 
 %typemap(out) SWIGTYPE 
 #ifdef __cplusplus
-%{ *($&1_ltype*)&$result = new $1_ltype((const $1_ltype &)$1); %}
+%{ *($&1_ltype*)&$result = new $1_ltype($1); %}
 #else
 {
   $&1_ltype $1ptr = ($&1_ltype) malloc(sizeof($1_ltype));
@@ -676,7 +676,7 @@ Swig::LocalRefGuard $1_refguard(jenv, $input); }
 
 %typemap(directorin,descriptor="L$packagepath/$&javaclassname;") SWIGTYPE 
 %{ $input = 0;
-   *(($&1_ltype*)&$input) = new $1_ltype((const $1_ltype &)$1); %}
+   *(($&1_ltype*)&$input) = new $1_ltype(SWIG_STD_MOVE($1)); %}
 %typemap(javadirectorin) SWIGTYPE "new $&javaclassname($jniinput, true)"
 %typemap(javadirectorout) SWIGTYPE "$&javaclassname.getCPtr($javacall)"
 
@@ -692,14 +692,15 @@ Swig::LocalRefGuard $1_refguard(jenv, $input); }
 }
 %typemap(in) SWIGTYPE & %{ $1 = *($&1_ltype)&$input;
   if (!$1) {
-    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "$1_type reference is null");
+    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "$1_type is null");
     return $null;
   } %}
-%typemap(in) SWIGTYPE && %{ $1 = *($&1_ltype)&$input;
+%typemap(in, fragment="<memory>") SWIGTYPE && (std::unique_ptr<$*1_ltype> rvrdeleter) %{ $1 = *($&1_ltype)&$input;
   if (!$1) {
-    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "$1_type reference is null");
+    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "$1_type is null");
     return $null;
-  } %}
+  }
+  rvrdeleter.reset($1); %}
 %typemap(out) SWIGTYPE *
 %{ *($&1_ltype)&$result = $1; %} 
 %typemap(out, fragment="SWIG_PackData", noblock=1) SWIGTYPE (CLASS::*) {
@@ -1101,7 +1102,8 @@ Swig::LocalRefGuard $1_refguard(jenv, $input); }
                  jobjectArray
     "$javainput"
 %typemap(javain) SWIGTYPE "$&javaclassname.getCPtr($javainput)"
-%typemap(javain) SWIGTYPE *, SWIGTYPE &, SWIGTYPE &&, SWIGTYPE [] "$javaclassname.getCPtr($javainput)"
+%typemap(javain) SWIGTYPE *, SWIGTYPE &, SWIGTYPE [] "$javaclassname.getCPtr($javainput)"
+%typemap(javain) SWIGTYPE && "$javaclassname.swigRelease($javainput)"
 %typemap(javain) SWIGTYPE (CLASS::*) "$javaclassname.getCMemberPtr($javainput)"
 
 /* The javaout typemap is used for converting function return types from the return type
@@ -1216,6 +1218,18 @@ Swig::LocalRefGuard $1_refguard(jenv, $input); }
   CPTR_VISIBILITY static long getCPtr($javaclassname obj) {
     return (obj == null) ? 0 : obj.swigCPtr;
   }
+
+  CPTR_VISIBILITY static long swigRelease($javaclassname obj) {
+    long ptr = 0;
+    if (obj != null) {
+      if (!obj.swigCMemOwn)
+        throw new RuntimeException("Cannot release ownership as memory is not owned");
+      ptr = obj.swigCPtr;
+      obj.swigCMemOwn = false;
+      obj.delete();
+    }
+    return ptr;
+  }
 %}
 
 // Derived proxy classes
@@ -1230,6 +1244,18 @@ Swig::LocalRefGuard $1_refguard(jenv, $input); }
   CPTR_VISIBILITY static long getCPtr($javaclassname obj) {
     return (obj == null) ? 0 : obj.swigCPtr;
   }
+
+  CPTR_VISIBILITY static long swigRelease($javaclassname obj) {
+    long ptr = 0;
+    if (obj != null) {
+      if (!obj.swigCMemOwn)
+        throw new RuntimeException("Cannot release ownership as memory is not owned");
+      ptr = obj.swigCPtr;
+      obj.swigCMemOwn = false;
+      obj.delete();
+    }
+    return ptr;
+  }
 %}
 %enddef
 
@@ -1249,6 +1275,10 @@ Swig::LocalRefGuard $1_refguard(jenv, $input); }
   CPTR_VISIBILITY static long getCPtr($javaclassname obj) {
     return (obj == null) ? 0 : obj.swigCPtr;
   }
+
+  CPTR_VISIBILITY static long swigRelease($javaclassname obj) {
+    return (obj == null) ? 0 : obj.swigCPtr;
+  }
 %}
 
 %typemap(javabody) TYPE (CLASS::*) %{

linux/bin/swig/share/swig/4.1.0/java/std_auto_ptr.i

@@ -1,24 +1,38 @@
-/*
+/* -----------------------------------------------------------------------------
-    The typemaps here allow handling functions returning std::auto_ptr<>,
+ * std_auto_ptr.i
-    which is the most common use of this type. If you have functions taking it
+ *
-    as parameter, these typemaps can't be used for them and you need to do
+ * SWIG library file for handling std::auto_ptr.
-    something else (e.g. use shared_ptr<> which SWIG supports fully).
+ * Memory ownership is passed from the std::auto_ptr C++ layer to the proxy
- */
+ * class when returning a std::auto_ptr from a function.
+ * Memory ownership is passed from the proxy class to the std::auto_ptr in the
+ * C++ layer when passed as a parameter to a wrapped function.
+ * ----------------------------------------------------------------------------- */
 
 %define %auto_ptr(TYPE)
+
 %typemap (jni) std::auto_ptr< TYPE > "jlong"
 %typemap (jtype) std::auto_ptr< TYPE > "long"
 %typemap (jstype) std::auto_ptr< TYPE > "$typemap(jstype, TYPE)"
 
+%typemap(in) std::auto_ptr< TYPE > (TYPE *auto_temp)
+%{ auto_temp = *(TYPE **)&$input;
+  $1.reset(auto_temp); %}
+
+%typemap(javain) std::auto_ptr< TYPE > "$typemap(jstype, TYPE).swigRelease($javainput)"
+
 %typemap (out) std::auto_ptr< TYPE > %{
   jlong lpp = 0;
   *(TYPE **) &lpp = $1.release();
   $result = lpp;
 %}
+
 %typemap(javaout) std::auto_ptr< TYPE > {
     long cPtr = $jnicall;
     return (cPtr == 0) ? null : new $typemap(jstype, TYPE)(cPtr, true);
   }
+
+%typemap(typecheck, precedence=SWIG_TYPECHECK_POINTER, equivalent="TYPE *") std::auto_ptr< TYPE > ""
+
 %template() std::auto_ptr< TYPE >;
 %enddef
 

linux/bin/swig/share/swig/4.1.0/java/std_set.i

@@ -96,6 +96,10 @@ class set {
       public boolean hasNext() {
         return curr.isNot(end);
       }
+
+      public void remove() {
+        throw new java.lang.UnsupportedOperationException();
+      }
     }.init();
   }
 

linux/bin/swig/share/swig/4.1.0/java/std_unique_ptr.i

@@ -0,0 +1,41 @@
+/* -----------------------------------------------------------------------------
+ * std_unique_ptr.i
+ *
+ * SWIG library file for handling std::unique_ptr.
+ * Memory ownership is passed from the std::unique_ptr C++ layer to the proxy
+ * class when returning a std::unique_ptr from a function.
+ * Memory ownership is passed from the proxy class to the std::unique_ptr in the
+ * C++ layer when passed as a parameter to a wrapped function.
+ * ----------------------------------------------------------------------------- */
+
+%define %unique_ptr(TYPE)
+
+%typemap (jni) std::unique_ptr< TYPE > "jlong"
+%typemap (jtype) std::unique_ptr< TYPE > "long"
+%typemap (jstype) std::unique_ptr< TYPE > "$typemap(jstype, TYPE)"
+
+%typemap(in) std::unique_ptr< TYPE > (TYPE *unique_temp)
+%{ unique_temp = *(TYPE **)&$input;
+  $1.reset(unique_temp); %}
+
+%typemap(javain) std::unique_ptr< TYPE > "$typemap(jstype, TYPE).swigRelease($javainput)"
+
+%typemap (out) std::unique_ptr< TYPE > %{
+  jlong lpp = 0;
+  *(TYPE **) &lpp = $1.release();
+  $result = lpp;
+%}
+
+%typemap(javaout) std::unique_ptr< TYPE > {
+    long cPtr = $jnicall;
+    return (cPtr == 0) ? null : new $typemap(jstype, TYPE)(cPtr, true);
+  }
+
+%typemap(typecheck, precedence=SWIG_TYPECHECK_POINTER, equivalent="TYPE *") std::unique_ptr< TYPE > ""
+
+%template() std::unique_ptr< TYPE >;
+%enddef
+
+namespace std {
+  template <class T> class unique_ptr {};
+}

linux/bin/swig/share/swig/4.1.0/java/std_unordered_set.i

@@ -92,6 +92,10 @@ class unordered_set {
       public boolean hasNext() {
         return curr.isNot(end);
       }
+
+      public void remove() {
+        throw new java.lang.UnsupportedOperationException();
+      }
     }.init();
   }
 

linux/bin/swig/share/swig/4.1.0/java/std_wstring.i

@@ -88,7 +88,10 @@ class wstring;
 //%typemap(typecheck) wstring = wchar_t *;
 
 %typemap(throws) wstring
-%{ std::string message($1.begin(), $1.end());
+%{std::string message($1.size(), '\0');
+  for (size_t i = 0; i < $1.size(); ++i) {
+    message[i] = (char)$1[i];
+  }
   SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, message.c_str());
   return $null; %}
 
@@ -166,7 +169,10 @@ class wstring;
 //%typemap(typecheck) const wstring & = wchar_t *;
 
 %typemap(throws) const wstring &
-%{ std::string message($1.begin(), $1.end());
+%{std::string message($1.size(), '\0');
+  for (size_t i = 0; i < $1.size(); ++i) {
+    message[i] = (char)$1[i];
+  }
   SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, message.c_str());
   return $null; %}
 

linux/bin/swig/share/swig/4.1.0/java/swiginterface.i

@@ -40,7 +40,7 @@
 %typemap(javadirectorout) CTYPE *const& "$javacall.$*interfacename_GetInterfaceCPtr()"
 %typemap(directorin,descriptor="L$packagepath/$&javainterfacename;") CTYPE
 %{ $input = 0;
-   *(($&1_ltype*)&$input) = new $1_ltype((const $1_ltype &)$1); %}
+   *(($&1_ltype*)&$input) = new $1_ltype(SWIG_STD_MOVE($1)); %}
 %typemap(directorin,descriptor="L$packagepath/$javainterfacename;") CTYPE *, CTYPE []
 %{ *(($&1_ltype)&$input) = ($1_ltype) $1; %}
 %typemap(directorin,descriptor="L$packagepath/$javainterfacename;") CTYPE &

linux/bin/swig/share/swig/4.1.0/java/swigmove.i

@@ -0,0 +1,16 @@
+/* -----------------------------------------------------------------------------
+ * swigmove.i
+ *
+ * Input typemaps library for implementing full move semantics when passing
+ * parameters by value.
+ * ----------------------------------------------------------------------------- */
+
+%typemap(in) SWIGTYPE MOVE ($&1_type argp)
+%{ argp = *($&1_ltype*)&$input; 
+   if (!argp) {
+     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null $1_type");
+     return $null;
+   }
+  SwigValueWrapper< $1_ltype >::reset($1, argp); %}
+
+%typemap(javain) SWIGTYPE MOVE "$&javaclassname.swigRelease($javainput)"

linux/bin/swig/share/swig/4.1.0/javascript/cocos/javascriptcode.swg

@@ -1,6 +1,6 @@
 %fragment ("js_check_arg_count", "templates") %{
     if (argc != $jsargcount) {
-        SE_REPORT_ERROR("$jswrapper: wrong number of arguments: %d, was expecting %d", (int)argc, $jsargcount);
+        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, $jsargcount);
         return false;
     }%}
 
@@ -14,7 +14,6 @@
  * ----------------------------------------------------------------------------- */
 %fragment ("js_ctor", "templates")
 %{
-// js_ctor
 static bool $jswrapper(se::State& s) // NOLINT(readability-identifier-naming)
 {
     CC_UNUSED bool ok = true;
@@ -39,14 +38,9 @@ SE_BIND_CTOR($jswrapper, __jsb_$jsmangledname_class, js_delete_$jsdtor)%}
 %{
 static bool $jswrapper(se::State& s) // NOLINT(readability-identifier-naming)
 {
-    // js_ctor_dispatcher
     size_t argc = s.args().size();
     bool ret = false;
-
-    // switch all cases by means of series of if-returns.
     $jsdispatchcases
-
-    // default:
     SE_REPORT_ERROR("Illegal arguments for construction of $jsname");
     return false;
 }
@@ -64,7 +58,6 @@ SE_BIND_CTOR($jswrapper, __jsb_$jsmangledname_class, js_delete_$jsdtor)%}
 %{
 static bool $jswrapper(se::State& s) // NOLINT(readability-identifier-naming)
 {
-    // js_overloaded_ctor
     const auto& args = s.args();
     CC_UNUSED bool ok = true;
     $jslocals
@@ -84,7 +77,6 @@ static bool $jswrapper(se::State& s) // NOLINT(readability-identifier-naming)
  * ----------------------------------------------------------------------------- */
 %fragment ("js_ctor_dispatch_case", "templates")
 %{
-  // js_ctor_dispatch_case
   if(argc == $jsargcount) {
     ret = $jswrapper(s);
     if (ret) { return ret; } /* reset exception and return */
@@ -99,7 +91,6 @@ static bool $jswrapper(se::State& s) // NOLINT(readability-identifier-naming)
  * ----------------------------------------------------------------------------- */
 %fragment ("js_dtor", "templates")
 %{
-// js_dtor
 static bool $jswrapper(se::State& s) {
   return true;
 }
@@ -114,7 +105,7 @@ SE_BIND_FINALIZE_FUNC($jswrapper) %}
 %fragment ("js_dtoroverride", "templates")
 %{
 static bool $jswrapper(se::State& s)
-{// js_dtoroverride
+{
   return true;
 }
 SE_BIND_FINALIZE_FUNC($jswrapper) %}
@@ -169,7 +160,6 @@ SE_BIND_PROP_SET($jswrapper) %}
 %{
 static bool $jswrapper(se::State& s)
 {
-  // js_function
   $js_func_begin
   CC_UNUSED bool ok = true;
   const auto& args = s.args();
@@ -196,7 +186,6 @@ SE_BIND_FUNC($jswrapper) %}
 %{
 static bool $jswrapper(se::State& s)
 {
-  // js_function_dispatcher
   CC_UNUSED bool ok = true;
   const auto& args = s.args();
   size_t argc = args.size();
@@ -216,7 +205,7 @@ SE_BIND_FUNC($jswrapper) %}
 %fragment ("js_overloaded_function", "templates")
 %{
 static bool $jswrapper(se::State& s)
-{// js_overloaded_function
+{
   $js_func_begin
   CC_UNUSED bool ok = true;
   const auto& args = s.args();
@@ -233,7 +222,7 @@ static bool $jswrapper(se::State& s)
  *   - $jscode:     code part of wrapper
  * ----------------------------------------------------------------------------- */
 %fragment ("js_function_dispatch_case", "templates")
-%{// js_function_dispatch_case
+%{
   if (argc == $jsargcount) {
      ok = $jswrapper(s);
      if (ok) { return true; }

linux/bin/swig/share/swig/4.1.0/javascript/cocos/javascripttypemaps.swg

@@ -38,36 +38,32 @@
 /* -----------------------------------------------------------------------------
  *                          standard typemaps
  * ----------------------------------------------------------------------------- */
-/* NEW LANGUAGE NOTE:
-   the 'checkfn' param is something that I added for typemap(in)
-   it is an optional fn call to check the type of the lua object
-   the fn call must be of the form
-     int checkfn(lua_State *L, int index);
-   and return 1/0 depending upon if this is the correct type
-   For the typemap(out), an additional SWIG_arg parameter must be incremented
-   to reflect the number of values returned (normally SWIG_arg++; will do)
-*/
 // number
-
+%typemap(in) char, int, short, long, signed char, float, double, int8_t, int16_t, int32_t, int64_t, size_t, ssize_t
-%typemap(in) int, short, long, signed char, float, double
+%{
-%{// %typemap(in) int, short, long, signed char, float, double
+  ok &= sevalue_to_native($input, &$1, s.thisObject());
-  ok &= sevalue_to_native($input, &$1, nullptr);
+  SE_PRECONDITION2(ok, false, "Error processing arguments"); %}
-  SE_PRECONDITION2(ok, false, "$symname,$argnum,$descriptor"); %}
  
 // additional check for unsigned numbers, to not permit negative input
-%typemap(in) unsigned int, unsigned short, unsigned long, unsigned char
+%typemap(in) unsigned char, unsigned int, unsigned short, unsigned long, unsigned char, uint8_t, uint16_t, uint32_t, uint64_t, size_t, ssize_t
-%{// %typemap(in) unsigned int, unsigned short, unsigned long, unsigned char
+%{
-  ok &= sevalue_to_native($input, &$1, nullptr);
+  ok &= sevalue_to_native($input, &$1, s.thisObject());
-  SE_PRECONDITION2(ok, false, "$symname,$argnum,$descriptor");
+  SE_PRECONDITION2(ok, false, "Error processing arguments");
 %}
 
-%typemap(out) int,short,long,
+%typemap(out) char, int,short,long,
-             unsigned int,unsigned short,unsigned long,
+             unsigned char, unsigned int,unsigned short,unsigned long,
              signed char,unsigned char,
-             float,double
+             float,double,
+             int8_t, int16_t, int32_t, int64_t,
+             uint8_t, uint16_t, uint32_t, uint64_t,
+             size_t, ssize_t
 %{
-  // out 1
+   ok &= nativevalue_to_se($1, s.rval(), s.thisObject()); %}
-   ok &= nativevalue_to_se($1, s.rval(), s.thisObject() /*ctx*/); %}
+
+%apply long {long long, signed long long, unsigned long long};
+// size_t (which is just a unsigned long)
+%apply unsigned long { size_t };
 
 // we must also provide typemaps for primitives by const reference:
 // given a function:
@@ -75,27 +71,17 @@
 // SWIG assumes that this code will need a pointer to int to be passed in
 // (this might be ok for objects by const ref, but not for numeric primitives)
 // therefore we add a set of typemaps to fix this (for both in & out)
-%typemap(in,checkfn="lua_isnumber") const int& ($*1_ltype temp)
+%typemap(in) const int& ($*1_ltype temp), const unsigned int& ($*1_ltype temp)
 %{ 
-  //temp=($*1_ltype)lua_tonumber(L,$input); $1=&temp;
+  ok &= sevalue_to_native($input, &temp, s.thisObject());
-  ok &= sevalue_to_native($input, &temp, nullptr /*ctx*/);
+  SE_PRECONDITION2(ok, false, "Error processing arguments"); 
-  SE_PRECONDITION2(ok, false, "$symname, Error processing arguments"); 
-  $1 = &temp;
-%}
-
-%typemap(in,checkfn="lua_isnumber") const unsigned int& //($*1_ltype temp)
-%{
-  //SWIG_contract_assert((lua_tonumber(L,$input)>=0),"number must not be negative");
-  // temp=($*1_ltype)lua_tonumber(L,$input); $1=&temp;
-  ok &= sevalue_to_native($input, &temp, nullptr /*ctx*/);
-  SE_PRECONDITION2(ok, false, "$symname, Error processing arguments"); 
   $1 = &temp;
 %}
 
 %typemap(out) const int&, const unsigned int&
-%{ // out 2
+%{
-  ok &= nativevalue_to_se(*$1, s.rval(), s.thisObject() /*ctx*/);
+  ok &= nativevalue_to_se(*$1, s.rval(), s.thisObject());
-  SE_PRECONDITION2(ok, false, "$symname, Error processing arguments"); 
+  SE_PRECONDITION2(ok, false, "Error processing arguments"); 
 %}
 
 // for the other numbers we can just use an apply statement to cover them
@@ -105,192 +91,101 @@
 %apply const unsigned int & {const unsigned short&,const unsigned long&,
              const unsigned char&};
 
-/* enums have to be handled slightly differently
+%apply const long& {const long long&, const signed long long&, const unsigned long long&};
-   VC++ .net will not allow a cast from lua_Number(double) to enum directly.
+%apply const unsigned long & { const size_t & };
-*/
-%typemap(in) enum SWIGTYPE (int32_t temp)
-%{ // %typemap(in) enum SWIGTYPE (int32_t temp)
-   ok &= sevalue_to_native($input, &temp);
-   SE_PRECONDITION2(ok, false, "$symname,$argnum,$descriptor");
-   $1 = ($ltype)temp;%}
-
-%typemap(out) enum SWIGTYPE (int32_t temp)
-%{  // out 4
-  s.rval().setInt32(static_cast<int32_t>($1));%}
-
-// and const refs
-%typemap(in) const enum SWIGTYPE &($basetype temp)
-%{ // %typemap(in) const enum SWIGTYPE &
- temp=($basetype)(int)lua_tonumber(L,$input); $1=&temp;%}
-
-%typemap(in) const enum SWIGTYPE &&($basetype temp)
-%{ // %typemap(in) const enum SWIGTYPE && 
-  temp=($basetype)(int)lua_tonumber(L,$input); $1=&temp;%}
-
-%typemap(out) const enum SWIGTYPE &
-%{  lua_pushnumber(L, (lua_Number) *$1); SWIG_arg++;%}
-%typemap(out) const enum SWIGTYPE &&
-%{  lua_pushnumber(L, (lua_Number) *$1); SWIG_arg++;%}
 
 %typemap(in) bool
-%{ // %typemap(in) bool
+%{
   ok &= sevalue_to_native($input, &$1);
-  SE_PRECONDITION2(ok, false, "$symname,$argnum,$descriptor"); %}
+  SE_PRECONDITION2(ok, false, "Error processing arguments"); %}
 
 %typemap(out) bool
-%{// out 5
+%{
-  ok &= nativevalue_to_se($1, s.rval(), s.thisObject() /*ctx*/);%}
+  ok &= nativevalue_to_se($1, s.rval(), s.thisObject());%}
 
-// for const bool&, SWIG treats this as a const bool* so we must dereference it
+%typemap(out) bool &
-%typemap(in,checkfn="lua_isboolean") const bool& (bool temp)
+%{
-%{temp=(lua_toboolean(L, $input)!=0);
+  ok &= nativevalue_to_se(*$1, s.rval(), s.thisObject());%}
-  $1=&temp;%}
 
-%typemap(out) const bool&
+%typemap(in) const char * (ccstd::string temp)
-%{  lua_pushboolean(L,(int)((*$1)!=0)); SWIG_arg++;%}
-
-// strings (char * and char[])
-
-%typemap(in) const char * (ccstd::string temp), char * (ccstd::string temp)
 %{
    ok &= sevalue_to_native($input, &temp);
-   SE_PRECONDITION2(ok, false, "$symname,$argnum,$descriptor");
+   SE_PRECONDITION2(ok, false, "Error processing arguments");
    $1 = ($ltype) temp.c_str(); %}
 
-%typemap(in) const char[ANY], char[ANY]
-%{$1 = ($ltype)lua_tostring(L, $input);%}
-
 %typemap(out) const char *, char *
-%{  // out 6
+%{
   ok &= nativevalue_to_se($1, s.rval(), nullptr /*ctx*/);
-  SE_PRECONDITION2(ok, false, "$symname, Error processing arguments");
+  SE_PRECONDITION2(ok, false, "Error processing arguments");
-  SE_HOLD_RETURN_VALUE($1, s.thisObject(), s.rval()); 
 %}
 
-%typemap(out) const char[ANY], char[ANY]
+%apply const char* {char*, const char[ANY], char[ANY]}
-%{  lua_pushstring(L,(const char *)$1); SWIG_arg++;%}
-
-// char's
-// currently treating chars as small strings, not as numbers
-// (however signed & unsigned char's are numbers...)
-%typemap(in) char
-%{$1 = (lua_tostring(L, $input))[0];%}
-
-%typemap(out) char
-%{  lua_pushlstring(L, &$1, 1); SWIG_arg++;%}
-
-// by const ref
-%typemap(in) const char& (char temp)
-%{temp = (lua_tostring(L, $input))[0]; $1=&temp;%}
-
-%typemap(out) const char&
-%{  lua_pushlstring(L, $1, 1); SWIG_arg++;%}
 
 // pointers and references
-// under SWIG rules, it is ok, to have a pass in a lua nil,
+// under SWIG rules, it is ok, to have a pass in a javascript null,
 // it should be converted to a SWIG NULL.
 // This will only be allowed for pointers & arrays, not refs or by value
-// the checkfn lua_isuserdata will only work for userdata
-// the checkfn SWIG_isptrtype will work for both userdata and nil
 %typemap(in) SWIGTYPE*
-%{ // %typemap(in) SWIGTYPE*
+%{
   ok &= sevalue_to_native($input, &$1, s.thisObject());
-  SE_PRECONDITION2(ok, false, "$symname,$argnum,$descriptor"); %}
+  SE_PRECONDITION2(ok, false, "Error processing arguments"); %}
 
 %typemap(in) SWIGTYPE[]
-%{ // %typemap(in) SWIGTYPE[]
+%{
   ok &= sevalue_to_native($input, &$1, s.thisObject());
-  SE_PRECONDITION2(ok, false, "$symname,$argnum,$descriptor"); %}
+  SE_PRECONDITION2(ok, false, "Error processing arguments"); %}
 
 %typemap(in) SWIGTYPE& ($*ltype temp)
-%{// %typemap(in) SWIGTYPE&
+%{
   ok &= sevalue_to_native($input, &temp, s.thisObject());
-  SE_PRECONDITION2(ok, false, "$symname,$argnum,$descriptor");
+  SE_PRECONDITION2(ok, false, "Error processing arguments");
   $1 = &temp;
 %}
 
 %typemap(in) SWIGTYPE&& ($*ltype temp)
-%{// %typemap(in) SWIGTYPE&&
+%{
   ok &= sevalue_to_native($input, &temp, s.thisObject());
-  SE_PRECONDITION2(ok, false, "$symname,$argnum,$descriptor");
+  SE_PRECONDITION2(ok, false, "Error processing arguments");
   $1 = &temp;
 %}
 
 // out is simple
 %typemap(out) SWIGTYPE&
-%{  // %typemap(out) SWIGTYPE&
+%{
-  ok &= nativevalue_to_se(*$1, s.rval(), s.thisObject() /*ctx*/);
+  ok &= nativevalue_to_se(*$1, s.rval(), s.thisObject());
-    SE_PRECONDITION2(ok, false, "$symname, Error processing arguments");
+    SE_PRECONDITION2(ok, false, "Error processing arguments");
     SE_HOLD_RETURN_VALUE(*$1, s.thisObject(), s.rval()); %}
 
 %typemap(out) SWIGTYPE*
-%{ // %typemap(out) SWIGTYPE*
+%{
-  ok &= nativevalue_to_se($1, s.rval(), s.thisObject() /*ctx*/);
+  ok &= nativevalue_to_se($1, s.rval(), s.thisObject());
-   SE_PRECONDITION2(ok, false, "$symname, Error processing arguments");
+   SE_PRECONDITION2(ok, false, "Error processing arguments");
    SE_HOLD_RETURN_VALUE($1, s.thisObject(), s.rval()); %}
 
 %typemap(out) SWIGTYPE&&
-%{ // %typemap(out) SWIGTYPE&&
+%{
-  ok &= nativevalue_to_se($1, s.rval(), s.thisObject() /*ctx*/);
+  ok &= nativevalue_to_se($1, s.rval(), s.thisObject());
-   SE_PRECONDITION2(ok, false, "$symname, Error processing arguments");
+   SE_PRECONDITION2(ok, false, "Error processing arguments");
    SE_HOLD_RETURN_VALUE($1, s.thisObject(), s.rval()); %}
 
-// dynamic casts
-// this uses the SWIG_TypeDynamicCast() which relies on RTTI to find out what the pointer really is
-// the we return it as the correct type
-%typemap(out) SWIGTYPE *DYNAMIC,
-              SWIGTYPE &DYNAMIC
-{
-  swig_type_info *ty = SWIG_TypeDynamicCast($1_descriptor, (void **) &$1);
-  SWIG_NewPointerObj222(L,(void*)$1,ty,$owner); SWIG_arg++; 
-}
-
-
 // passing objects by value
 // SWIG_ConvertPtr wants an object pointer (the $&ltype argp)
 // then dereferences it to get the object
 %typemap(in) SWIGTYPE //($&ltype argp)
 %{
-  // %typemap(in) SWIGTYPE value in
   ok &= sevalue_to_native($input, &$1, s.thisObject());
-  SE_PRECONDITION2(ok, false, "$symname,$argnum,$descriptor"); 
+  SE_PRECONDITION2(ok, false, "Error processing arguments"); 
 %}
 
-
-// Also needed for object ptrs by const ref
-// eg A* const& ref_pointer(A* const& a);
-// found in mixed_types.i
-%typemap(in,checkfn="SWIG_isptrtype") SWIGTYPE *const&($*ltype temp)
-%{temp=($*ltype)SWIG_MustGetPtr111(L,$input,$*descriptor,0,$argnum,"$symname");
-$1=($1_ltype)&temp;%}
-
-%typemap(out) SWIGTYPE *const&
-%{ // %typemap(out) SWIGTYPE *const&
-  SWIG_NewPointerObj333(L,*$1,$*descriptor,$owner); SWIG_arg++; %}
-
-
-// DISOWN-ing typemaps
-// if you have an object pointer which must be disowned, use this typemap
-// eg. for void destroy_foo(Foo* toDie);
-// use %apply SWIGTYPE* DISOWN {Foo* toDie};
-// you could just use %delobject, but this is more flexible
-%typemap(in,checkfn="SWIG_isptrtype") SWIGTYPE* DISOWN,SWIGTYPE DISOWN[]
-%{ // %typemap(in,checkfn="SWIG_isptrtype") SWIGTYPE* DISOWN,SWIGTYPE DISOWN[]
-   if (!SWIG_IsOK(SWIG_ConvertPtrIn222(L,$input,(void**)&$1,$descriptor,SWIG_POINTER_DISOWN))){
-    SWIG_fail_ptr("$symname",$argnum,$descriptor);
-  }
-%}
-
-
 // Primitive types--return by value
 // must make a new object, copy the data & return the new object
 // Note: the brackets are {...} and not %{..%}, because we want them to be included in the wrapper
 // this is because typemap(out) does not support local variables, like in typemap(in) does
 // and we need the $&1_ltype resultptr; to be declared
 %typemap(out) SWIGTYPE 
-%{ // %typemap(out) SWIGTYPE
+%{
     ok &= nativevalue_to_se($1, s.rval(), s.thisObject() /*ctx*/);
-    SE_PRECONDITION2(ok, false, "$symname, Error processing arguments");
+    SE_PRECONDITION2(ok, false, "Error processing arguments");
     SE_HOLD_RETURN_VALUE($1, s.thisObject(), s.rval());
 %}
 
@@ -299,17 +194,14 @@ $1=($1_ltype)&temp;%}
 // so the standard wrapping cannot be done
 // nor can you cast a member function pointer to a void* (obviously)
 // therefore a special wrapping functions SWIG_ConvertMember() & SWIG_NewMemberObj() were written
-%typemap(in,checkfn="lua_isuserdata") SWIGTYPE (CLASS::*)
+%typemap(in) SWIGTYPE (CLASS::*)
 %{
-  // %typemap(in,checkfn="lua_isuserdata") SWIGTYPE (CLASS::*)
+  static_assert(false, "Binding member function pointer is not supported!");
-  if (!SWIG_IsOK(SWIG_ConvertMember(L,$input,(void*)(&$1),sizeof($1),$descriptor)))
-    SWIG_fail_ptr("$symname",$argnum,$descriptor);
 %}
 
 %typemap(out) SWIGTYPE (CLASS::*)
 %{
-  // %typemap(out) SWIGTYPE (CLASS::*)
+  static_assert(false, "Returning member function pointer is not supported!");
-  SWIG_NewMemberObj(L,(void*)(&$1),sizeof($1),$descriptor); SWIG_arg++;
 %}
 
 
@@ -320,20 +212,9 @@ $1=($1_ltype)&temp;%}
 A function void fn(void*) should take any kind of pointer as a parameter (just like C/C++ does)
 but if it's an output, then it should be wrapped like any other SWIG object (using default typemap)
 */
-%typemap(in,checkfn="SWIG_isptrtype") void*
+%typemap(in) void*
 %{  ok &= sevalue_to_native($input, &$1);
-    SE_PRECONDITION2(ok, false, "$symname,$argnum,$descriptor");%}
+    SE_PRECONDITION2(ok, false, "Error processing arguments");%}
-
-/* long long is another special case:
-as lua only supports one numeric type (lua_Number), we will just
-cast it to that & accept the loss of precision.
-An alternative solution would be a long long struct or class
-with the relevant operators.
-*/
-%apply long {long long, signed long long, unsigned long long};
-%apply const long& {const long long&, const signed long long&, const unsigned long long&};
-
-
 
 /* -----------------------------------------------------------------------------
  *                          typecheck rules
@@ -343,100 +224,10 @@ These define the detection routines which will spot what
 parameters match which function
 */
 
-// unfortunately lua only considers one type of number
-// so all numbers (int,float,double) match
-// you could add an advanced fn to get type & check if it's integral
-%typecheck(SWIG_TYPECHECK_INTEGER)
-    int, short, long,
-    unsigned int, unsigned short, unsigned long,
-    signed char, unsigned char,
-    long long, unsigned long long, signed long long,
-    const int &, const short &, const long &,
-    const unsigned int &, const unsigned short &, const unsigned long &,
-    const signed char&, const unsigned char&,
-    const long long &, const unsigned long long &,
-    enum SWIGTYPE,   const enum SWIGTYPE&, const enum SWIGTYPE &&,
-    float, double, const float &, const double&
-{
-  $1 = lua_isnumber(L,$input);
-}
-
-// %typecheck(SWIG_TYPECHECK_BOOL)
-//     bool, const bool &
-// {
-//   $1 = lua_isboolean(L,$input);
-// }
-
-// special check for a char (string of length 1)
-// %typecheck(SWIG_TYPECHECK_CHAR,fragment="SWIG_lua_isnilstring") char, const char& {
-//   $1 = SWIG_lua_isnilstring(L,$input) && (lua_rawlen(L,$input)==1);
-// }
-
-// %typecheck(SWIG_TYPECHECK_STRING,fragment="SWIG_lua_isnilstring") char *, char[] {
-//   $1 = SWIG_lua_isnilstring(L,$input);
-// }
-
 %typemap(in) SWIGTYPE *self 
 %{ $1 = SE_THIS_OBJECT<$*ltype>(s);
-   SE_PRECONDITION2($1, false, "%s: Invalid Native Object", __FUNCTION__); %}
+   if (nullptr == $1) return true;%}
 
-// %typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE *, SWIGTYPE [] {
-//   void *ptr;
-//   if (SWIG_isptrtype(L,$input)==0 || SWIG_ConvertPtr61(L,$input, (void **) &ptr, $1_descriptor, 0)) {
-//     $1 = 0;
-//   } else {
-//     $1 = 1;
-//   }
-// }
-
-// %typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE & {
-//   void *ptr;
-//   if (lua_isuserdata(L,$input)==0 || SWIG_ConvertPtr62(L,$input, (void **) &ptr, $1_descriptor, SWIG_POINTER_NO_NULL)) {
-//     $1 = 0;
-//   } else {
-//     $1 = 1;
-//   }
-// }
-
-// %typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE && {
-//   void *ptr;
-//   if (lua_isuserdata(L,$input)==0 || SWIG_ConvertPtr63(L,$input, (void **) &ptr, $1_descriptor, SWIG_POINTER_NO_NULL)) {
-//     $1 = 0;
-//   } else {
-//     $1 = 1;
-//   }
-// }
-
-// %typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE {
-//   void *ptr;
-//   if (lua_isuserdata(L,$input)==0 || SWIG_ConvertPtr64(L,$input, (void **) &ptr, $&1_descriptor, SWIG_POINTER_NO_NULL)) {
-//     $1 = 0;
-//   } else {
-//     $1 = 1;
-//   }
-// }
-
-// %typecheck(SWIG_TYPECHECK_VOIDPTR) void * {
-//   void *ptr;
-//   if (SWIG_isptrtype(L,$input)==0 || SWIG_ConvertPtr65(L,$input, (void **) &ptr, 0, 0)) {
-//     $1 = 0;
-//   } else {
-//     $1 = 1;
-//   }
-// }
-
-// // Also needed for object pointers by const ref
-// // eg const A* ref_pointer(A* const& a);
-// // found in mixed_types.i
-// %typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE *const&
-// {
-//   void *ptr;
-//   if (SWIG_isptrtype(L,$input)==0 || SWIG_ConvertPtr66(L,$input, (void **) &ptr, $*descriptor, 0)) {
-//     $1 = 0;
-//   } else {
-//     $1 = 1;
-//   }
-// }
 
 /* -----------------------------------------------------------------------------
  *                          Others
@@ -451,16 +242,14 @@ parameters match which function
 %apply SWIGTYPE (CLASS::*) { SWIGTYPE (CLASS::*const) }
 %apply SWIGTYPE & { SWIGTYPE (CLASS::*const&) }
 
-// size_t (which is just a unsigned long)
+
-%apply unsigned long { size_t };
-%apply const unsigned long & { const size_t & };
 
 
 /* -----------------------------------------------------------------------------
  *                          Specials
  * ----------------------------------------------------------------------------- */
 // swig::LANGUAGE_OBJ was added to allow containers of native objects
-// however it's rather difficult to do this in lua, as you cannot hold pointers
+// however it's rather difficult to do this in javascript, as you cannot hold pointers
 // to native objects (they are held in the interpreter)
 // therefore for now: just ignoring this feature
 #ifdef __cplusplus
@@ -475,40 +264,16 @@ parameters match which function
 
 #endif // __cplusplus
 
-// %typemap(memberin) float [ANY] {
-//   int i;
-//   for (i = 0; i < $1_dim0; i++) {
-//     $1[i] = $input[i];
-//   }
-// }
-
-// %typemap(out) float [ANY] {
-//   int i;
-//   $result = PyList_New($1_dim0);
-//   for (i = 0; i < $1_dim0; i++) {
-//     PyObject *o = PyFloat_FromDouble((double) $1[i]);
-//     PyList_SetItem($result, i, o);
-//   }
-// }
-
-// %typemap(check) double %{ 
-//   if ($1 < 0) {
-//     croak("hahaha Expecting a positive number"); 
-//   }
-// %}
-
 // Cocos custom type
 
 %typemap(in) cc::Mat4* (cc::Mat4 temp) %{
-  // %typemap(in) cc::Mat4* (cc::Mat4 temp) %{
   ok &= sevalue_to_native($input, &temp);
-  SE_PRECONDITION2(ok, false, "$symname,$argnum,$descriptor");
+  SE_PRECONDITION2(ok, false, "Error processing arguments");
   $1 = ($ltype) &temp;
 %}
 
 %typemap(out) cc::Float32Array %{
-    // %typemap(out) cc::Float32Array
     ok &= nativevalue_to_se($1, s.rval(), s.thisObject() /*ctx*/);
-    SE_PRECONDITION2(ok, false, "$symname, Error processing arguments");
+    SE_PRECONDITION2(ok, false, "Error processing arguments");
     SE_HOLD_RETURN_VALUE($1, s.thisObject(), s.rval());
 %}

linux/bin/swig/share/swig/4.1.0/javascript/cocos/std_string.i

@@ -32,71 +32,71 @@ assert(s==s2)
 
 namespace std {
 
-%naturalvar string;
+// %naturalvar string;
 
-%typemap(in) string
+// %typemap(in) string
-%{// string
+// %{// string
-     ok &= sevalue_to_native($input, &$1);
+//      ok &= sevalue_to_native($input, &$1);
-   SE_PRECONDITION2(ok, false, "$symname,$argnum,$descriptor"); %}
+//    SE_PRECONDITION2(ok, false, "Error processing arguments"); %}
 
-%typemap(out) string
+// %typemap(out) string
-%{ lua_pushlstring(L,$1.data(),$1.size()); SWIG_arg++;%}
+// %{ lua_pushlstring(L,$1.data(),$1.size()); SWIG_arg++;%}
 
-%typemap(in) string *self 
+// %typemap(in) string *self 
-%{ $1 = SE_THIS_OBJECT<$*ltype>(s);
+// %{ $1 = SE_THIS_OBJECT<$*ltype>(s);
-   SE_PRECONDITION2($1, false, "%s: Invalid Native Object", __FUNCTION__); %}
+//    SE_PRECONDITION2($1, false, "Invalid Native Object"); %}
 
-%typemap(in,checkfn="lua_isstring") string*
+// %typemap(in,checkfn="lua_isstring") string*
-%{// string*
+// %{// string*
-    std::string
+//     std::string
-    ok &= sevalue_to_native($input, &$1);
+//     ok &= sevalue_to_native($input, &$1);
-    SE_PRECONDITION2(ok, false, "$symname,$argnum,$descriptor");
+//     SE_PRECONDITION2(ok, false, "Error processing arguments");
-    $1.assign(lua_tostringxxx(L,$input),lua_rawlen(L,$input));%}
+//     $1.assign(lua_tostringxxx(L,$input),lua_rawlen(L,$input));%}
 
-%typemap(out) string*
+// %typemap(out) string*
-%{// out string*
+// %{// out string*
-     lua_pushlstringxxx(L,$1.data(),$1.size()); SWIG_arg++;%}
+//      lua_pushlstringxxx(L,$1.data(),$1.size()); SWIG_arg++;%}
 
-%typemap(in,checkfn="lua_isstring") const string& ($*1_ltype temp)
+// %typemap(in,checkfn="lua_isstring") const string& ($*1_ltype temp)
-%{ // const std::string&
+// %{ // const std::string&
-    temp.assign(lua_tostring(L,$input),lua_rawlen(L,$input)); $1=&temp;%}
+//     temp.assign(lua_tostring(L,$input),lua_rawlen(L,$input)); $1=&temp;%}
 
-%typemap(out) const string&
+// %typemap(out) const string&
-%{ // out const string&
+// %{ // out const string&
-    lua_pushlstring(L,$1->data(),$1->size()); SWIG_arg++;%}
+//     lua_pushlstring(L,$1->data(),$1->size()); SWIG_arg++;%}
 
-// %typecheck(SWIG_TYPECHECK_STRING) string, const string& {
+// // %typecheck(SWIG_TYPECHECK_STRING) string, const string& {
-//   $1 = lua_isstring(L,$input);
+// //   $1 = lua_isstring(L,$input);
-// }
+// // }
 
-/*
+// /*
-std::string& can be wrapped, but you must inform SWIG if it is in or out
+// std::string& can be wrapped, but you must inform SWIG if it is in or out
 
-eg:
+// eg:
-void fn(std::string& str);
+// void fn(std::string& str);
-Is this an in/out/inout value?
+// Is this an in/out/inout value?
 
-Therefore you need the usual
+// Therefore you need the usual
-%apply (std::string& INOUT) {std::string& str};
+// %apply (std::string& INOUT) {std::string& str};
-or
+// or
-%apply std::string& INOUT {std::string& str};
+// %apply std::string& INOUT {std::string& str};
-typemaps to tell SWIG what to do.
+// typemaps to tell SWIG what to do.
-*/
+// */
 
-%typemap(in) string &INPUT=const string &;
+// %typemap(in) string &INPUT=const string &;
 
-%typemap(in, numinputs=0) string &OUTPUT ($*1_ltype temp)
+// %typemap(in, numinputs=0) string &OUTPUT ($*1_ltype temp)
-%{ $1 = &temp; %}
+// %{ $1 = &temp; %}
 
-%typemap(argout) string &OUTPUT
+// %typemap(argout) string &OUTPUT
-%{ lua_pushlstring(L,$1->data(),$1->size()); SWIG_arg++;%}
+// %{ lua_pushlstring(L,$1->data(),$1->size()); SWIG_arg++;%}
 
-%typemap(in) string &INOUT =const string &;
+// %typemap(in) string &INOUT =const string &;
-%typemap(in) string *INOUT %{
+// %typemap(in) string *INOUT %{
-    // inout ... string*
+//     // inout ... string*
-%};
+// %};
 
-%typemap(argout) string &INOUT = string &OUTPUT;
+// %typemap(argout) string &INOUT = string &OUTPUT;
 
 /*
 A really cut down version of the string class

linux/bin/swig/share/swig/4.1.0/javascript/jsc/javascriptrun.swg

@@ -7,23 +7,27 @@
 #define SWIG_exception(code, msg) do { SWIG_JSC_exception(context, exception, code, msg); SWIG_fail; } while (0)
 #define SWIG_fail                 goto fail
 
-SWIGRUNTIME void SWIG_Javascript_Raise(JSContextRef context, JSValueRef *exception, const char* type) {
+SWIGRUNTIME void SWIG_Javascript_Raise_ValueRef(JSContextRef context, JSValueRef *exception, JSValueRef valRef) {
-  JSStringRef message = JSStringCreateWithUTF8CString(type);
   JSValueRef error_arguments[1]; 
   JSObjectRef exception_object;
-  JSValueRef exception_value;
-  exception_value = JSValueMakeString(context, message);
   /* Converting the result to an object will let JavascriptCore add 
      "sourceURL" (file) and "line" (number) and "message" to the exception,
      instead of just returning a raw string. This is extremely important for debugging your errors.
      Using JSObjectMakeError is better than JSValueToObject because the latter only populates
      "sourceURL" and "line", but not "message" or any others I don't know about.
    */
-  error_arguments[0] = exception_value;
+  error_arguments[0] = valRef;
   exception_object = JSObjectMakeError(context, 1, error_arguments, NULL);
 
   /* Return the exception_object */
   *exception = exception_object;
+}
+
+SWIGRUNTIME void SWIG_Javascript_Raise(JSContextRef context, JSValueRef *exception, const char* msg) {
+  JSStringRef message = JSStringCreateWithUTF8CString(msg);
+  JSValueRef exception_value = JSValueMakeString(context, message);
+
+  SWIG_Javascript_Raise_ValueRef(context, exception, exception_value);
 
   JSStringRelease(message);
 }
@@ -135,9 +139,16 @@ SWIGRUNTIME int SWIG_JSC_ConvertInstancePtr(JSContextRef context, JSObjectRef ob
     }
   }
 
+  if (((flags & SWIG_POINTER_RELEASE) == SWIG_POINTER_RELEASE) && !cdata->swigCMemOwn) {
+    return SWIG_ERROR_RELEASE_NOT_OWNED;
+  } else {
     if (flags & SWIG_POINTER_DISOWN) {
       cdata->swigCMemOwn = false;
     }
+    if (flags & SWIG_POINTER_CLEAR) {
+      cdata->swigCObject = 0;
+    }
+  }
 
   return SWIG_OK;
 }

linux/bin/swig/share/swig/4.1.0/javascript/jsc/javascriptstrings.swg

@@ -75,6 +75,7 @@ SWIG_JSC_FromCharPtrAndSize(JSContextRef context, const char* carray, size_t siz
 }
 
 %define %_typemap2_string(StringCode, CharCode,
+			 WarningLeakMsg,
 			 Char, CharName,
 			 SWIG_AsCharPtrAndSize,
 			 SWIG_FromCharPtrAndSize,
@@ -166,6 +167,7 @@ SWIG_AsVal_dec(Char)(SWIG_Object obj, Char *val)
 
 %_typemap_string(StringCode,
                  Char,
+                 WarningLeakMsg,
                  SWIG_AsCharPtrAndSize,
                  SWIG_FromCharPtrAndSize,
                  SWIG_CharPtrLen,

linux/bin/swig/share/swig/4.1.0/javascript/jsc/javascripttypemaps.swg

@@ -41,7 +41,7 @@
 #define SWIG_SetConstant(name, obj)
 
 /* raise */
-#define SWIG_Raise(obj, type, desc)  SWIG_Javascript_Raise(context, exception, type)
+#define SWIG_Raise(obj, type, desc)  SWIG_Javascript_Raise_ValueRef(context, exception, obj)
 
 %insert("runtime") %{
 #define SWIG_JSC_FROM_DECL_ARGS(arg1)              (JSContextRef context, arg1)

linux/bin/swig/share/swig/4.1.0/javascript/jsc/std_auto_ptr.i

@@ -0,0 +1,39 @@
+/* -----------------------------------------------------------------------------
+ * std_auto_ptr.i
+ *
+ * SWIG library file for handling std::auto_ptr.
+ * Memory ownership is passed from the std::auto_ptr C++ layer to the proxy
+ * class when returning a std::auto_ptr from a function.
+ * Memory ownership is passed from the proxy class to the std::auto_ptr in the
+ * C++ layer when passed as a parameter to a wrapped function.
+ * ----------------------------------------------------------------------------- */
+
+%define %auto_ptr(TYPE)
+%typemap(in, noblock=1) std::auto_ptr< TYPE > (void *argp = 0, int res = 0) {
+  res = SWIG_ConvertPtr($input, &argp, $descriptor(TYPE *), SWIG_POINTER_RELEASE | %convertptr_flags);
+  if (!SWIG_IsOK(res)) {
+    if (res == SWIG_ERROR_RELEASE_NOT_OWNED) {
+      %releasenotowned_fail(res, "TYPE *", $symname, $argnum);
+    } else {
+      %argument_fail(res, "TYPE *", $symname, $argnum);
+    }
+  }
+  $1.reset((TYPE *)argp);
+}
+
+%typemap (out) std::auto_ptr< TYPE > %{
+  %set_output(SWIG_NewPointerObj($1.release(), $descriptor(TYPE *), SWIG_POINTER_OWN | %newpointer_flags));
+%}
+
+%typemap(typecheck, precedence=SWIG_TYPECHECK_POINTER, equivalent="TYPE *", noblock=1) std::auto_ptr< TYPE > {
+  void *vptr = 0;
+  int res = SWIG_ConvertPtr($input, &vptr, $descriptor(TYPE *), 0);
+  $1 = SWIG_CheckState(res);
+}
+
+%template() std::auto_ptr< TYPE >;
+%enddef
+
+namespace std {
+  template <class T> class auto_ptr {};
+}

linux/bin/swig/share/swig/4.1.0/javascript/jsc/std_unique_ptr.i

@@ -0,0 +1,39 @@
+/* -----------------------------------------------------------------------------
+ * std_unique_ptr.i
+ *
+ * SWIG library file for handling std::unique_ptr.
+ * Memory ownership is passed from the std::unique_ptr C++ layer to the proxy
+ * class when returning a std::unique_ptr from a function.
+ * Memory ownership is passed from the proxy class to the std::unique_ptr in the
+ * C++ layer when passed as a parameter to a wrapped function.
+ * ----------------------------------------------------------------------------- */
+
+%define %unique_ptr(TYPE)
+%typemap(in, noblock=1) std::unique_ptr< TYPE > (void *argp = 0, int res = 0) {
+  res = SWIG_ConvertPtr($input, &argp, $descriptor(TYPE *), SWIG_POINTER_RELEASE | %convertptr_flags);
+  if (!SWIG_IsOK(res)) {
+    if (res == SWIG_ERROR_RELEASE_NOT_OWNED) {
+      %releasenotowned_fail(res, "TYPE *", $symname, $argnum);
+    } else {
+      %argument_fail(res, "TYPE *", $symname, $argnum);
+    }
+  }
+  $1.reset((TYPE *)argp);
+}
+
+%typemap (out) std::unique_ptr< TYPE > %{
+  %set_output(SWIG_NewPointerObj($1.release(), $descriptor(TYPE *), SWIG_POINTER_OWN | %newpointer_flags));
+%}
+
+%typemap(typecheck, precedence=SWIG_TYPECHECK_POINTER, equivalent="TYPE *", noblock=1) std::unique_ptr< TYPE > {
+  void *vptr = 0;
+  int res = SWIG_ConvertPtr($input, &vptr, $descriptor(TYPE *), 0);
+  $1 = SWIG_CheckState(res);
+}
+
+%template() std::unique_ptr< TYPE >;
+%enddef
+
+namespace std {
+  template <class T> class unique_ptr {};
+}

linux/bin/swig/share/swig/4.1.0/javascript/jsc/swigmove.i

@@ -0,0 +1 @@
+%include <typemaps/swigmove.swg>

linux/bin/swig/share/swig/4.1.0/javascript/v8/javascriptprimtypes.swg

@@ -81,7 +81,7 @@ int SWIG_AsVal_dec(long)(SWIGV8_VALUE obj, long* val)
 SWIGINTERNINLINE
 SWIGV8_VALUE SWIG_From_dec(unsigned long)(unsigned long value)
 {
-  return SWIGV8_INTEGER_NEW_UNS(value);
+  return value <= UINT32_MAX ? (SWIGV8_VALUE)SWIGV8_INTEGER_NEW_UNS(value) : (SWIGV8_VALUE)SWIGV8_NUMBER_NEW(static_cast<double>(value));
 }
 }
 
@@ -149,7 +149,7 @@ int SWIG_AsVal_dec(long long)(SWIGV8_VALUE obj, long long* val)
 SWIGINTERNINLINE
 SWIGV8_VALUE SWIG_From_dec(unsigned long long)(unsigned long long value)
 {
-  return SWIGV8_INTEGER_NEW_UNS(value);
+  return value <= UINT32_MAX ? (SWIGV8_VALUE)SWIGV8_INTEGER_NEW_UNS(value) : (SWIGV8_VALUE)SWIGV8_NUMBER_NEW(static_cast<double>(value));
 }
 %#endif
 }

linux/bin/swig/share/swig/4.1.0/javascript/v8/javascriptrun.swg

@@ -96,6 +96,11 @@ SWIGINTERN void SWIG_V8_Raise(const char *msg) {
   SWIGV8_THROW_EXCEPTION(v8::Exception::Error(SWIGV8_STRING_NEW(msg)));
 }
 
+SWIGINTERN void SWIG_V8_Raise(SWIGV8_VALUE obj, const char *msg) {
+  SWIGV8_THROW_EXCEPTION(v8::Exception::Error(SWIGV8_TO_STRING(obj)));
+}
+
+
 /*
   Note: There are two contexts for handling errors.
   A static V8ErrorHandler is used in not overloaded methods.
@@ -194,9 +199,16 @@ SWIGRUNTIME int SWIG_V8_ConvertInstancePtr(SWIGV8_OBJECT objRef, void **ptr, swi
     *ptr = cdata->swigCObject;
   }
 
+  if (((flags & SWIG_POINTER_RELEASE) == SWIG_POINTER_RELEASE) && !cdata->swigCMemOwn) {
+    return SWIG_ERROR_RELEASE_NOT_OWNED;
+  } else {
     if (flags & SWIG_POINTER_DISOWN) {
       cdata->swigCMemOwn = false;
     }
+    if (flags & SWIG_POINTER_CLEAR) {
+      cdata->swigCObject = 0;
+    }
+  }
   return SWIG_OK;
 }
 

linux/bin/swig/share/swig/4.1.0/javascript/v8/javascripttypemaps.swg

@@ -37,7 +37,7 @@
 #define SWIG_SetConstant(name, obj)
 
 /* raise */
-#define SWIG_Raise(obj, type, desc)  SWIG_V8_Raise(type)
+#define SWIG_Raise(obj, type, desc)  SWIG_V8_Raise(obj, type)
 
 /* Include the unified typemap library */
 %include <typemaps/swigtypemaps.swg>

linux/bin/swig/share/swig/4.1.0/javascript/v8/std_auto_ptr.i

@@ -0,0 +1,39 @@
+/* -----------------------------------------------------------------------------
+ * std_auto_ptr.i
+ *
+ * SWIG library file for handling std::auto_ptr.
+ * Memory ownership is passed from the std::auto_ptr C++ layer to the proxy
+ * class when returning a std::auto_ptr from a function.
+ * Memory ownership is passed from the proxy class to the std::auto_ptr in the
+ * C++ layer when passed as a parameter to a wrapped function.
+ * ----------------------------------------------------------------------------- */
+
+%define %auto_ptr(TYPE)
+%typemap(in, noblock=1) std::auto_ptr< TYPE > (void *argp = 0, int res = 0) {
+  res = SWIG_ConvertPtr($input, &argp, $descriptor(TYPE *), SWIG_POINTER_RELEASE | %convertptr_flags);
+  if (!SWIG_IsOK(res)) {
+    if (res == SWIG_ERROR_RELEASE_NOT_OWNED) {
+      %releasenotowned_fail(res, "TYPE *", $symname, $argnum);
+    } else {
+      %argument_fail(res, "TYPE *", $symname, $argnum);
+    }
+  }
+  $1.reset((TYPE *)argp);
+}
+
+%typemap (out) std::auto_ptr< TYPE > %{
+  %set_output(SWIG_NewPointerObj($1.release(), $descriptor(TYPE *), SWIG_POINTER_OWN | %newpointer_flags));
+%}
+
+%typemap(typecheck, precedence=SWIG_TYPECHECK_POINTER, equivalent="TYPE *", noblock=1) std::auto_ptr< TYPE > {
+  void *vptr = 0;
+  int res = SWIG_ConvertPtr($input, &vptr, $descriptor(TYPE *), 0);
+  $1 = SWIG_CheckState(res);
+}
+
+%template() std::auto_ptr< TYPE >;
+%enddef
+
+namespace std {
+  template <class T> class auto_ptr {};
+}

linux/bin/swig/share/swig/4.1.0/javascript/v8/std_unique_ptr.i

@@ -0,0 +1,39 @@
+/* -----------------------------------------------------------------------------
+ * std_unique_ptr.i
+ *
+ * SWIG library file for handling std::unique_ptr.
+ * Memory ownership is passed from the std::unique_ptr C++ layer to the proxy
+ * class when returning a std::unique_ptr from a function.
+ * Memory ownership is passed from the proxy class to the std::unique_ptr in the
+ * C++ layer when passed as a parameter to a wrapped function.
+ * ----------------------------------------------------------------------------- */
+
+%define %unique_ptr(TYPE)
+%typemap(in, noblock=1) std::unique_ptr< TYPE > (void *argp = 0, int res = 0) {
+  res = SWIG_ConvertPtr($input, &argp, $descriptor(TYPE *), SWIG_POINTER_RELEASE | %convertptr_flags);
+  if (!SWIG_IsOK(res)) {
+    if (res == SWIG_ERROR_RELEASE_NOT_OWNED) {
+      %releasenotowned_fail(res, "TYPE *", $symname, $argnum);
+    } else {
+      %argument_fail(res, "TYPE *", $symname, $argnum);
+    }
+  }
+  $1.reset((TYPE *)argp);
+}
+
+%typemap (out) std::unique_ptr< TYPE > %{
+  %set_output(SWIG_NewPointerObj($1.release(), $descriptor(TYPE *), SWIG_POINTER_OWN | %newpointer_flags));
+%}
+
+%typemap(typecheck, precedence=SWIG_TYPECHECK_POINTER, equivalent="TYPE *", noblock=1) std::unique_ptr< TYPE > {
+  void *vptr = 0;
+  int res = SWIG_ConvertPtr($input, &vptr, $descriptor(TYPE *), 0);
+  $1 = SWIG_CheckState(res);
+}
+
+%template() std::unique_ptr< TYPE >;
+%enddef
+
+namespace std {
+  template <class T> class unique_ptr {};
+}

linux/bin/swig/share/swig/4.1.0/javascript/v8/swigmove.i

@@ -0,0 +1 @@
+%include <typemaps/swigmove.swg>

linux/bin/swig/share/swig/4.1.0/lua/argcargv.i

@@ -0,0 +1,57 @@
+/* ------------------------------------------------------------
+ * SWIG library containing argc and argv multi-argument typemaps
+
+   Use it as follows:
+
+     %apply (int ARGC, char **ARGV) { (size_t argc, const char **argv) }
+     extern int mainApp(size_t argc, const char **argv);
+
+   then from lua:
+
+     args = { "arg0", "arg1" }
+     mainApp(args)
+
+ * ------------------------------------------------------------ */
+
+%{
+SWIGINTERN int SWIG_argv_size(lua_State* L, int index) {
+  int n=0;
+  while(1){
+    lua_rawgeti(L,index,n+1);
+    if (lua_isnil(L,-1))
+      break;
+    ++n;
+    lua_pop(L,1);
+  }
+  lua_pop(L,1);
+  return n;
+}
+%}
+
+%typemap(in) (int ARGC, char **ARGV) {
+  if (lua_istable(L,$input)) {
+    int i, size = SWIG_argv_size(L,$input);
+    $1 = ($1_ltype) size;
+    $2 = (char **) malloc((size+1)*sizeof(char *));
+    for (i = 0; i < size; i++) {
+      lua_rawgeti(L,$input,i+1);
+      if (lua_isnil(L,-1))
+   break;
+      $2[i] = (char *)lua_tostring(L, -1);
+      lua_pop(L,1);
+    }
+    $2[i]=NULL;
+  } else {
+    $1 = 0; $2 = 0;
+    lua_pushstring(L,"Expecting argv array");
+    lua_error(L);
+  }
+}
+
+%typemap(typecheck, precedence=SWIG_TYPECHECK_STRING_ARRAY) (int ARGC, char **ARGV) {
+  $1 = lua_istable(L,$input);
+}
+
+%typemap(freearg) (int ARGC, char **ARGV) {
+  free((char *) $2);
+}

linux/bin/swig/share/swig/4.1.0/lua/lua.swg

@@ -213,7 +213,7 @@ SWIG_fail;%}
 //	%apply SWIGTYPE EXCEPTION_BY_VAL {FooBar};
 //	%apply SWIGTYPE& EXCEPTION_BY_VAL {FooBar&}; // note: need & twice
 %typemap(throws) SWIGTYPE EXCEPTION_BY_VAL
-%{SWIG_NewPointerObj(L,(void *)new $1_ltype(($1_ltype &) $1),$&1_descriptor,1);
+%{SWIG_NewPointerObj(L,(void *)new $1_ltype($1),$&1_descriptor,1);
 SWIG_fail;%}
 
 // similar for object reference

linux/bin/swig/share/swig/4.1.0/lua/luarun.swg

@@ -1757,6 +1757,7 @@ SWIGRUNTIME void SWIG_Lua_NewPointerObj(lua_State *L,void *ptr,swig_type_info *t
  (if possible) */
 SWIGRUNTIME int  SWIG_Lua_ConvertPtr(lua_State *L,int index,void **ptr,swig_type_info *type,int flags)
 {
+  int ret = SWIG_ERROR;
   swig_lua_userdata *usr;
   swig_cast_info *cast;
   /* special case: lua nil => NULL pointer */
@@ -1773,6 +1774,10 @@ SWIGRUNTIME int  SWIG_Lua_ConvertPtr(lua_State *L,int index,void **ptr,swig_type
   usr=(swig_lua_userdata*)lua_touserdata(L,index);  /* get data */
   if (usr)
   {
+    if (((flags & SWIG_POINTER_RELEASE) == SWIG_POINTER_RELEASE) && !usr->own)
+    {
+      return SWIG_ERROR_RELEASE_NOT_OWNED;
+    }
     if (flags & SWIG_POINTER_DISOWN) /* must disown the object */
     {
       usr->own = 0;
@@ -1780,18 +1785,25 @@ SWIGRUNTIME int  SWIG_Lua_ConvertPtr(lua_State *L,int index,void **ptr,swig_type
     if (!type)            /* special cast void*, no casting fn */
     {
       *ptr=usr->ptr;
-      return SWIG_OK; /* ok */
+      ret = SWIG_OK;
     }
-    cast=SWIG_TypeCheckStruct(usr->type,type); /* performs normal type checking */
+    else
+    {
+      cast=SWIG_TypeCheck(usr->type->name,type); /* performs normal type checking */
       if (cast)
       {
         int newmemory = 0;
         *ptr=SWIG_TypeCast(cast,usr->ptr,&newmemory);
         assert(!newmemory); /* newmemory handling not yet implemented */
-      return SWIG_OK;  /* ok */
+        ret = SWIG_OK;
       }
     }
-  return SWIG_ERROR;  /* error */
+    if ((ret == SWIG_OK) && (flags & SWIG_POINTER_CLEAR))
+    {
+      usr->ptr = 0;
+    }
+  }
+  return ret;
 }
 
 SWIGRUNTIME void* SWIG_Lua_MustGetPtr(lua_State *L,int index,swig_type_info *type,int flags,

linux/bin/swig/share/swig/4.1.0/lua/luatypemaps.swg

@@ -151,11 +151,17 @@ SWIGINTERN int SWIG_lua_isnilstring(lua_State *L, int idx) {
   }
 %}
 
-%typemap(in,checkfn="lua_isuserdata") SWIGTYPE&&
+%typemap(in,checkfn="lua_isuserdata",fragment="<memory>") SWIGTYPE&& (void *argp = 0, int res = 0, std::unique_ptr<$*1_ltype> rvrdeleter) %{
-%{
+  res = SWIG_ConvertPtr(L, $input, &argp, $descriptor, SWIG_POINTER_RELEASE);
-  if (!SWIG_IsOK(SWIG_ConvertPtr(L,$input,(void**)&$1,$descriptor,$disown))){
+  if (!SWIG_IsOK(res)) {
+    if (res == SWIG_ERROR_RELEASE_NOT_OWNED) {
+      lua_pushfstring(L, "Cannot release ownership as memory is not owned for argument $argnum of type '$1_type' in $symname"); SWIG_fail;
+    } else {
       SWIG_fail_ptr("$symname", $argnum, $descriptor);
     }
+  }
+  $1 = ($1_ltype)argp;
+  rvrdeleter.reset($1);
 %}
 
 // out is simple
@@ -217,7 +223,7 @@ $1=($1_ltype)&temp;%}
 #ifdef __cplusplus
 %typemap(out) SWIGTYPE
 {
-  $&1_ltype resultptr = new $1_ltype((const $1_ltype &) $1);
+  $&1_ltype resultptr = new $1_ltype($1);
   SWIG_NewPointerObj(L,(void *) resultptr,$&1_descriptor,1); SWIG_arg++;
 }
 #else
@@ -248,7 +254,7 @@ $1=($1_ltype)&temp;%}
 
 
 // void (must be empty without the SWIG_arg++)
-%typemap(out) void "";
+%typemap(out) void ""
 
 /* void* is a special case
 A function void fn(void*) should take any kind of pointer as a parameter (just like C/C++ does)

linux/bin/swig/share/swig/4.1.0/lua/std_auto_ptr.i

@@ -0,0 +1,39 @@
+/* -----------------------------------------------------------------------------
+ * std_auto_ptr.i
+ *
+ * SWIG library file for handling std::auto_ptr.
+ * Memory ownership is passed from the std::auto_ptr C++ layer to the proxy
+ * class when returning a std::auto_ptr from a function.
+ * Memory ownership is passed from the proxy class to the std::auto_ptr in the
+ * C++ layer when passed as a parameter to a wrapped function.
+ * ----------------------------------------------------------------------------- */
+
+%define %auto_ptr(TYPE)
+%typemap(in, checkfn="SWIG_isptrtype", noblock=1) std::auto_ptr< TYPE > (void *argp = 0, int res = 0) {
+  res = SWIG_ConvertPtr(L, $input, &argp, $descriptor(TYPE *), SWIG_POINTER_RELEASE);
+  if (!SWIG_IsOK(res)) {
+    if (res == SWIG_ERROR_RELEASE_NOT_OWNED) {
+      lua_pushfstring(L, "Cannot release ownership as memory is not owned for argument $argnum of type 'TYPE *' in $symname"); SWIG_fail;
+    } else {
+      SWIG_fail_ptr("$symname", $argnum, $descriptor(TYPE *));
+    }
+  }
+  $1.reset((TYPE *)argp);
+}
+
+%typemap (out) std::auto_ptr< TYPE > %{
+  SWIG_NewPointerObj(L, $1.release(), $descriptor(TYPE *), SWIG_POINTER_OWN); SWIG_arg++;
+%}
+
+%typemap(typecheck, precedence=SWIG_TYPECHECK_POINTER, equivalent="TYPE *", noblock=1) std::auto_ptr< TYPE > {
+  void *vptr = 0;
+  int res = SWIG_ConvertPtr(L, $input, &vptr, $descriptor(TYPE *), 0);
+  $1 = SWIG_CheckState(res);
+}
+
+%template() std::auto_ptr< TYPE >;
+%enddef
+
+namespace std {
+  template <class T> class auto_ptr {};
+}

linux/bin/swig/share/swig/4.1.0/lua/std_unique_ptr.i

@@ -0,0 +1,39 @@
+/* -----------------------------------------------------------------------------
+ * std_unique_ptr.i
+ *
+ * SWIG library file for handling std::unique_ptr.
+ * Memory ownership is passed from the std::unique_ptr C++ layer to the proxy
+ * class when returning a std::unique_ptr from a function.
+ * Memory ownership is passed from the proxy class to the std::unique_ptr in the
+ * C++ layer when passed as a parameter to a wrapped function.
+ * ----------------------------------------------------------------------------- */
+
+%define %unique_ptr(TYPE)
+%typemap(in, checkfn="SWIG_isptrtype", noblock=1) std::unique_ptr< TYPE > (void *argp = 0, int res = 0) {
+  res = SWIG_ConvertPtr(L, $input, &argp, $descriptor(TYPE *), SWIG_POINTER_RELEASE);
+  if (!SWIG_IsOK(res)) {
+    if (res == SWIG_ERROR_RELEASE_NOT_OWNED) {
+      lua_pushfstring(L, "Cannot release ownership as memory is not owned for argument $argnum of type 'TYPE *' in $symname"); SWIG_fail;
+    } else {
+      SWIG_fail_ptr("$symname", $argnum, $descriptor(TYPE *));
+    }
+  }
+  $1.reset((TYPE *)argp);
+}
+
+%typemap (out) std::unique_ptr< TYPE > %{
+  SWIG_NewPointerObj(L, $1.release(), $descriptor(TYPE *), SWIG_POINTER_OWN); SWIG_arg++;
+%}
+
+%typemap(typecheck, precedence=SWIG_TYPECHECK_POINTER, equivalent="TYPE *", noblock=1) std::unique_ptr< TYPE > {
+  void *vptr = 0;
+  int res = SWIG_ConvertPtr(L, $input, &vptr, $descriptor(TYPE *), 0);
+  $1 = SWIG_CheckState(res);
+}
+
+%template() std::unique_ptr< TYPE >;
+%enddef
+
+namespace std {
+  template <class T> class unique_ptr {};
+}

linux/bin/swig/share/swig/4.1.0/lua/swigmove.i

@@ -0,0 +1,18 @@
+/* -----------------------------------------------------------------------------
+ * swigmove.i
+ *
+ * Input typemaps library for implementing full move semantics when passing
+ * parameters by value.
+ * ----------------------------------------------------------------------------- */
+
+%typemap(in, checkfn="lua_isuserdata", noblock=1) SWIGTYPE MOVE (void *argp = 0, int res = 0) {
+  res = SWIG_ConvertPtr(L, $input, &argp, $&1_descriptor, SWIG_POINTER_RELEASE);
+  if (!SWIG_IsOK(res)) {
+    if (res == SWIG_ERROR_RELEASE_NOT_OWNED) {
+      lua_pushfstring(L, "Cannot release ownership as memory is not owned for argument $argnum of type '$1_type' in $symname"); SWIG_fail;
+    } else {
+      SWIG_fail_ptr("$symname", $argnum, $&1_descriptor);
+    }
+  }
+  SwigValueWrapper< $1_ltype >::reset($1, ($&1_type)argp);
+}

linux/bin/swig/share/swig/4.1.0/mzscheme/mzrun.swg

@@ -125,6 +125,7 @@ struct swig_mz_proxy {
   Scheme_Type mztype;
   swig_type_info *type;
   void *object;
+  int own;
 };
 
 static Scheme_Type swig_type;
@@ -135,7 +136,7 @@ mz_free_swig(void *p, void *data) {
   if (SCHEME_NULLP((Scheme_Object*)p) || SCHEME_TYPE((Scheme_Object*)p) != swig_type)
     return;
   if (proxy->type) {
-    if (proxy->type->clientdata) {
+    if (proxy->type->clientdata && proxy->own) {
       ((Scheme_Prim *)proxy->type->clientdata)(1, (Scheme_Object **)&proxy);
     }
   }
@@ -143,42 +144,61 @@ mz_free_swig(void *p, void *data) {
 
 static Scheme_Object *
 SWIG_MzScheme_NewPointerObj(void *ptr, swig_type_info *type, int owner) {
+  if (ptr) {
     struct swig_mz_proxy *new_proxy;
     new_proxy = (struct swig_mz_proxy *) scheme_malloc(sizeof(struct swig_mz_proxy));
     new_proxy->mztype = swig_type;
     new_proxy->type = type;
     new_proxy->object = ptr;
-  if (owner) {
+    new_proxy->own = owner & SWIG_POINTER_OWN;
+    if (new_proxy->own) {
       scheme_add_finalizer(new_proxy, mz_free_swig, NULL);
     }
     return (Scheme_Object *) new_proxy;
+  } else {
+    return scheme_make_null();
+  }
 }
 
 static int
 SWIG_MzScheme_ConvertPtr(Scheme_Object *s, void **result, swig_type_info *type, int flags) {
   swig_cast_info *cast;
+  int ret = SWIG_ERROR;
 
   if (SCHEME_NULLP(s)) {
     *result = NULL;
     return (flags & SWIG_POINTER_NO_NULL) ? SWIG_NullReferenceError : SWIG_OK;
   } else if (SCHEME_TYPE(s) == swig_type) {
     struct swig_mz_proxy *proxy = (struct swig_mz_proxy *) s;
+
+    if ((flags & SWIG_POINTER_RELEASE) == SWIG_POINTER_RELEASE && !proxy->own) {
+      return SWIG_ERROR_RELEASE_NOT_OWNED;
+    }
+
     if (type) {
       cast = SWIG_TypeCheckStruct(proxy->type, type);
       if (cast) {
         int newmemory = 0;
         *result = SWIG_TypeCast(cast, proxy->object, &newmemory);
         assert(!newmemory); /* newmemory handling not yet implemented */
-        return 0;
+        ret = SWIG_OK;
       } else {
-        return 1;
+        return SWIG_ERROR;
       }
     } else {
       *result = proxy->object;
-      return 0;
+      ret = SWIG_OK;
+    }
+
+    if (flags & SWIG_POINTER_DISOWN) {
+      scheme_subtract_finalizer(proxy, mz_free_swig, NULL);
+      proxy->own = 0;
+    }
+    if (flags & SWIG_POINTER_CLEAR) {
+      proxy->object = 0;
     }
   }
-  return 1;
+  return ret;
 }
 
 static SWIGINLINE void *

linux/bin/swig/share/swig/4.1.0/mzscheme/std_auto_ptr.i

@@ -0,0 +1,39 @@
+/* -----------------------------------------------------------------------------
+ * std_auto_ptr.i
+ *
+ * SWIG library file for handling std::auto_ptr.
+ * Memory ownership is passed from the std::auto_ptr C++ layer to the proxy
+ * class when returning a std::auto_ptr from a function.
+ * Memory ownership is passed from the proxy class to the std::auto_ptr in the
+ * C++ layer when passed as a parameter to a wrapped function.
+ * ----------------------------------------------------------------------------- */
+
+%define %auto_ptr(TYPE)
+%typemap(in, noblock=1) std::auto_ptr< TYPE > (void *argp = 0, int res = 0) {
+  res = SWIG_ConvertPtr($input, &argp, $descriptor(TYPE *), SWIG_POINTER_RELEASE);
+  if (!SWIG_IsOK(res)) {
+    if (res == SWIG_ERROR_RELEASE_NOT_OWNED) {
+      scheme_signal_error(FUNC_NAME ": cannot release ownership as memory is not owned for argument $argnum of type 'TYPE *'");
+    } else {
+      %argument_fail(res, "TYPE *", $symname, $argnum);
+    }
+  }
+  $1.reset((TYPE *)argp);
+}
+
+%typemap (out) std::auto_ptr< TYPE > %{
+  %set_output(SWIG_NewPointerObj($1.release(), $descriptor(TYPE *), SWIG_POINTER_OWN));
+%}
+
+%typemap(typecheck, precedence=SWIG_TYPECHECK_POINTER, equivalent="TYPE *", noblock=1) std::auto_ptr< TYPE > {
+  void *vptr = 0;
+  int res = SWIG_ConvertPtr($input, &vptr, $descriptor(TYPE *), 0);
+  $1 = SWIG_CheckState(res);
+}
+
+%template() std::auto_ptr< TYPE >;
+%enddef
+
+namespace std {
+  template <class T> class auto_ptr {};
+}

linux/bin/swig/share/swig/4.1.0/mzscheme/std_string.i

@@ -52,6 +52,13 @@ namespace std {
         $result = scheme_make_string($1->c_str());
     }
 
+    %typemap(throws) string {
+      scheme_signal_error("%s: %s", FUNC_NAME, $1.c_str());
+    }
+
+    %typemap(throws) const string & {
+      scheme_signal_error("%s: %s", FUNC_NAME, $1.c_str());
+    }
 }
 
 

linux/bin/swig/share/swig/4.1.0/mzscheme/std_unique_ptr.i

@@ -0,0 +1,39 @@
+/* -----------------------------------------------------------------------------
+ * std_unique_ptr.i
+ *
+ * SWIG library file for handling std::unique_ptr.
+ * Memory ownership is passed from the std::unique_ptr C++ layer to the proxy
+ * class when returning a std::unique_ptr from a function.
+ * Memory ownership is passed from the proxy class to the std::unique_ptr in the
+ * C++ layer when passed as a parameter to a wrapped function.
+ * ----------------------------------------------------------------------------- */
+
+%define %unique_ptr(TYPE)
+%typemap(in, noblock=1) std::unique_ptr< TYPE > (void *argp = 0, int res = 0) {
+  res = SWIG_ConvertPtr($input, &argp, $descriptor(TYPE *), SWIG_POINTER_RELEASE);
+  if (!SWIG_IsOK(res)) {
+    if (res == SWIG_ERROR_RELEASE_NOT_OWNED) {
+      scheme_signal_error(FUNC_NAME ": cannot release ownership as memory is not owned for argument $argnum of type 'TYPE *'");
+    } else {
+      %argument_fail(res, "TYPE *", $symname, $argnum);
+    }
+  }
+  $1.reset((TYPE *)argp);
+}
+
+%typemap (out) std::unique_ptr< TYPE > %{
+  %set_output(SWIG_NewPointerObj($1.release(), $descriptor(TYPE *), SWIG_POINTER_OWN));
+%}
+
+%typemap(typecheck, precedence=SWIG_TYPECHECK_POINTER, equivalent="TYPE *", noblock=1) std::unique_ptr< TYPE > {
+  void *vptr = 0;
+  int res = SWIG_ConvertPtr($input, &vptr, $descriptor(TYPE *), 0);
+  $1 = SWIG_CheckState(res);
+}
+
+%template() std::unique_ptr< TYPE >;
+%enddef
+
+namespace std {
+  template <class T> class unique_ptr {};
+}

linux/bin/swig/share/swig/4.1.0/mzscheme/swigmove.i

@@ -0,0 +1,19 @@
+/* -----------------------------------------------------------------------------
+ * swigmove.i
+ *
+ * Input typemaps library for implementing full move semantics when passing
+ * parameters by value.
+ * ----------------------------------------------------------------------------- */
+
+%typemap(in, noblock=1) SWIGTYPE MOVE (void *argp = 0, int res = 0) {
+  res = SWIG_ConvertPtr($input, &argp, $&1_descriptor, SWIG_POINTER_RELEASE);
+  if (!SWIG_IsOK(res)) {
+    if (res == SWIG_ERROR_RELEASE_NOT_OWNED) {
+      scheme_signal_error(FUNC_NAME ": cannot release ownership as memory is not owned for argument $argnum of type '$1_type'");
+    } else {
+      %argument_fail(res, "$1_type", $symname, $argnum);
+    }
+  }
+  if (argp == NULL) scheme_signal_error(FUNC_NAME ": swig-type-error (null reference)");
+  SwigValueWrapper< $1_ltype >::reset($1, ($&1_type)argp);
+}

linux/bin/swig/share/swig/4.1.0/mzscheme/typemaps.i

@@ -2,6 +2,12 @@
  * typemaps.i
  * ----------------------------------------------------------------------------- */
 
+#define %set_output(obj)                  $result = obj
+#define %set_varoutput(obj)               $result = obj
+#define %argument_fail(code, type, name, argn)	scheme_wrong_type(FUNC_NAME, type, argn, argc, argv)
+#define %as_voidptr(ptr)		(void*)(ptr)
+
+
 /* The MzScheme module handles all types uniformly via typemaps. Here
    are the definitions.  */
 
@@ -66,9 +72,23 @@
 
 #ifdef __cplusplus
 
-%typemap(in) SWIGTYPE &, SWIGTYPE && { 
+%typemap(in) SWIGTYPE & {
   $1 = ($ltype) SWIG_MustGetPtr($input, $descriptor, $argnum, 0);
-  if ($1 == NULL) scheme_signal_error("swig-type-error (null reference)");
+  if ($1 == NULL) scheme_signal_error(FUNC_NAME ": swig-type-error (null reference)");
+}
+
+%typemap(in, noblock=1, fragment="<memory>") SWIGTYPE && (void *argp = 0, int res = 0, std::unique_ptr<$*1_ltype> rvrdeleter) {
+  res = SWIG_ConvertPtr($input, &argp, $descriptor, SWIG_POINTER_RELEASE);
+  if (!SWIG_IsOK(res)) {
+    if (res == SWIG_ERROR_RELEASE_NOT_OWNED) {
+      scheme_signal_error(FUNC_NAME ": cannot release ownership as memory is not owned for argument $argnum of type '$1_type'");
+    } else {
+      %argument_fail(res, "$1_type", $symname, $argnum);
+    }
+  }
+  if (argp == NULL) scheme_signal_error(FUNC_NAME ": swig-type-error (null reference)");
+  $1 = ($1_ltype)argp;
+  rvrdeleter.reset($1);
 }
 
 %typemap(out) SWIGTYPE &, SWIGTYPE && {
@@ -105,8 +125,8 @@
   $1 = ($1_type) SWIG_convert_int($input);
 }
 
-%typemap(out) enum SWIGTYPE "$result = scheme_make_integer_value($1);";
+%typemap(out) enum SWIGTYPE "$result = scheme_make_integer_value($1);"
-%typemap(varout) enum SWIGTYPE "$result = scheme_make_integer_value($1);";
+%typemap(varout) enum SWIGTYPE "$result = scheme_make_integer_value($1);"
 
 
 /* Pass-by-value */
@@ -127,7 +147,7 @@
 #ifdef __cplusplus
 {
   $&1_ltype resultptr;
-  resultptr = new $1_ltype(($1_ltype &) $1);
+  resultptr = new $1_ltype($1);
   $result =  SWIG_NewPointerObj (resultptr, $&1_descriptor, 1);
 } 
 #else
@@ -143,7 +163,7 @@
 #ifdef __cplusplus
 {
   $&1_ltype resultptr;
-  resultptr = new $1_ltype(($1_ltype &) $1);
+  resultptr = new $1_ltype($1);
   $result =  SWIG_NewPointerObj (resultptr, $&1_descriptor, 0);
 } 
 #else
@@ -270,14 +290,18 @@ REF_MAP(float, SCHEME_REALP, scheme_real_to_double,
 REF_MAP(double, SCHEME_REALP, scheme_real_to_double,
 	   scheme_make_double, real);
 
+%typemap(throws) char * {
+  scheme_signal_error("%s: %s", FUNC_NAME, $1);
+}
+
 /* Void */
 
-%typemap(out) void "$result = scheme_void;";
+%typemap(out) void "$result = scheme_void;"
 
 /* Pass through Scheme_Object * */
 
-%typemap (in) Scheme_Object * "$1=$input;";
+%typemap (in) Scheme_Object * "$1=$input;"
-%typemap (out) Scheme_Object * "$result=$1;";
+%typemap (out) Scheme_Object * "$result=$1;"
 %typecheck(SWIG_TYPECHECK_POINTER) Scheme_Object * "$1=1;";
 
 
@@ -291,7 +315,6 @@ REF_MAP(double, SCHEME_REALP, scheme_real_to_double,
 //    $2 = ($2_ltype) temp;
 //}
 
-
 /* ------------------------------------------------------------
  * Typechecking rules
  * ------------------------------------------------------------ */

linux/bin/swig/share/swig/4.1.0/ocaml/ocaml.swg

@@ -40,9 +40,10 @@
     $1 = ($ltype) caml_ptr_val($input,$1_descriptor);
 }
 
-%typemap(in) SWIGTYPE && {
+%typemap(in, fragment="<memory>") SWIGTYPE && (std::unique_ptr<$*1_ltype> rvrdeleter) %{
     $1 = ($ltype) caml_ptr_val($input,$1_descriptor);
-}
+    rvrdeleter.reset($1);
+%}
 
 %typemap(varin) SWIGTYPE & {
     $1 = *(($ltype) caml_ptr_val($input,$1_descriptor));
@@ -93,10 +94,14 @@
     $1 = *(($&1_ltype) caml_ptr_val($input,$&1_descriptor)) ;
 }
 
+%typemap(varout) SWIGTYPE {
+    $result = SWIG_Ocaml_ptr_to_val("create_$ntype_from_ptr", (void *)&$1, $&1_descriptor);
+}
+
 #ifdef __cplusplus
 
 %typemap(out) SWIGTYPE {
-    $&1_ltype temp = new $ltype((const $1_ltype &) $1);
+    $&1_ltype temp = new $1_ltype($1);
     $result = SWIG_Ocaml_ptr_to_val("create_$ntype_from_ptr", (void *)temp, $&1_descriptor);
 }
 
@@ -110,8 +115,12 @@
 
 #endif
 
+%typemap(varout) SWIGTYPE * {
+    $result = SWIG_Ocaml_ptr_to_val("create_$ntype_from_ptr", (void *)$1, $1_descriptor);
+}
+
 %typemap(directorin) SWIGTYPE {
-    $&ltype temp = new $ltype((const $ltype &)$1);
+    $&ltype temp = new $1_ltype(SWIG_STD_MOVE($1));
     swig_result = SWIG_Ocaml_ptr_to_val("create_$ltype_from_ptr", (void *)temp, $&1_descriptor);
     args = caml_list_append(args, swig_result);
 }
@@ -180,12 +189,12 @@ SIMPLE_MAP(unsigned long long,caml_val_ulong,caml_long_val);
 
 /* Void */
 
-%typemap(out) void "$result = Val_unit;";
+%typemap(out) void "$result = Val_unit;"
 
 /* Pass through value */
 
-%typemap (in) CAML_VALUE "$1=$input;";
+%typemap (in) CAML_VALUE "$1=$input;"
-%typemap (out) CAML_VALUE "$result=$1;";
+%typemap (out) CAML_VALUE "$result=$1;"
 
 #if 0
 %include <carray.i>
@@ -302,7 +311,7 @@ SIMPLE_MAP(unsigned long long,caml_val_ulong,caml_long_val);
 
 /* Array reference typemaps */
 %apply SWIGTYPE & { SWIGTYPE ((&)[ANY]) }
-%apply SWIGTYPE && { SWIGTYPE ((&)[ANY]) }
+%apply SWIGTYPE && { SWIGTYPE ((&&)[ANY]) }
 
 /* const pointers */
 %apply SWIGTYPE * { SWIGTYPE *const }

linux/bin/swig/share/swig/4.1.0/ocaml/std_string.i

@@ -83,10 +83,22 @@ class wstring;
   $result = caml_val_string_len($1.c_str(),$1.size());
 }
 
+%typemap(varout) string {
+  $result = caml_val_string_len($1.c_str(),$1.size());
+}
+
 %typemap(out) string * {
 	$result = caml_val_string_len((*$1).c_str(),(*$1).size());
 }
+
+%typemap(varout) string * {
+	$result = caml_val_string_len((*$1).c_str(),(*$1).size());
+}
+
 %typemap(typecheck) string, const string & = char *;
+
+%typemap(throws) string, const string & "SWIG_OCamlThrowException(SWIG_OCamlRuntimeException, $1.c_str());"
+
 }
 
 #ifdef ENABLE_CHARPTR_ARRAY

linux/bin/swig/share/swig/4.1.0/ocaml/swigmove.i

@@ -0,0 +1,11 @@
+/* -----------------------------------------------------------------------------
+ * swigmove.i
+ *
+ * Input typemaps library for implementing full move semantics when passing
+ * parameters by value.
+ * ----------------------------------------------------------------------------- */
+
+%typemap(in, noblock=1) SWIGTYPE MOVE (void *argp = 0) {
+  argp1 = ($&1_ltype) caml_ptr_val($input,$&1_descriptor);
+  SwigValueWrapper< $1_ltype >::reset($1, ($&1_type)argp);
+}

linux/bin/swig/share/swig/4.1.0/octave/argcargv.i

@@ -0,0 +1,44 @@
+/* ------------------------------------------------------------
+ * SWIG library containing argc and argv multi-argument typemaps
+ * ------------------------------------------------------------ */
+
+%typemap(in) (int ARGC, char **ARGV) {
+  if ($input.is_scalar_type()) {
+    $1 = 0; $2 = NULL;
+    %argument_fail(SWIG_TypeError, "'int ARGC, char **ARGV' is not a list", $symname, $argnum);
+  }
+  octave_value_list list = $input.list_value();
+  int i, len = list.length();
+  $1 = ($1_ltype) len;
+  $2 = (char **) malloc((len+1)*sizeof(char *));
+  for (i = 0; i < len; i++) {
+    if (!list(i).is_string()) {
+      $1 = 0;
+      %argument_fail(SWIG_TypeError, "'int ARGC, char **ARGV' use a non-string", $symname, $argnum);
+    }
+    $2[i] = (char *)list(i).string_value().c_str();
+  }
+  $2[i] = NULL;
+}
+
+%typemap(typecheck, precedence=SWIG_TYPECHECK_STRING_ARRAY) (int ARGC, char **ARGV) {
+  $1 = 0;
+  const octave_value& ov = $input;
+  if (!ov.is_scalar_type()) {
+    octave_value_list list = ov.list_value();
+    int i, len = list.length();
+    $1 = 1;
+    for (i = 0; i < len; i++) {
+      if (!list(i).is_string()) {
+        $1 = 0;
+        break;
+      }
+    }
+  }
+}
+
+%typemap(freearg) (int ARGC, char **ARGV) {
+  if ($2 != NULL) {
+    free((void *)$2);
+  }
+}

linux/bin/swig/share/swig/4.1.0/octave/boost_shared_ptr.i

@@ -35,7 +35,7 @@
   }
 }
 %typemap(out) CONST TYPE {
-  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(new $1_ltype(($1_ltype &)$1));
+  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(new $1_ltype($1));
   %set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
 }
 
@@ -54,12 +54,12 @@
   }
 }
 %typemap(varout) CONST TYPE {
-  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(new $1_ltype(($1_ltype &)$1));
+  SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(new $1_ltype($1));
   %set_varoutput(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
 }
 
 %typemap(directorin,noblock=1) CONST TYPE (SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartarg = 0) %{
-  smartarg = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(new $1_ltype(($1_ltype &)$1));
+  smartarg = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(new $1_ltype(SWIG_STD_MOVE($1)));
   $input = SWIG_NewPointerObj(%as_voidptr(smartarg), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN | %newpointer_flags);
 %}
 %typemap(directorout,noblock=1) CONST TYPE (void *swig_argp, int swig_res = 0) {

linux/bin/swig/share/swig/4.1.0/octave/octheaders.hpp

@@ -9,8 +9,8 @@
 //     g++ -c -include octheaders.hpp ...
 //
 
-#if !defined(_SWIG_OCTAVE_OCTHEADERS_HPP)
+#if !defined(SWIG_OCTAVE_OCTHEADERS_HPP)
-#define _SWIG_OCTAVE_OCTHEADERS_HPP
+#define SWIG_OCTAVE_OCTHEADERS_HPP
 
 // Required C++ headers
 #include <cstdlib>
@@ -127,4 +127,4 @@
 #include <octave/call-stack.h>
 #endif
 
-#endif // !defined(_SWIG_OCTAVE_OCTHEADERS_HPP)
+#endif // !defined(SWIG_OCTAVE_OCTHEADERS_HPP)

linux/bin/swig/share/swig/4.1.0/octave/octrun.swg

@@ -232,7 +232,7 @@ SWIGRUNTIME void swig_acquire_ownership_obj(void *vptr, int own);
 
     const swig_type_info *construct_type;	// type of special type object
     std::vector < type_ptr_pair > types;	// our c++ base classes
-    int own;			// whether we call c++ destructors when we die
+    int thisown; // whether we call c++ destructors when we die
 
     typedef std::pair < const swig_octave_member *, octave_value > member_value_pair;
     typedef std::map < std::string, member_value_pair > member_map;
@@ -412,7 +412,7 @@ SWIGRUNTIME void swig_acquire_ownership_obj(void *vptr, int own);
 
     octave_swig_type(void *_ptr = 0, const swig_type_info *_type = 0, int _own = 0,
 		     bool _always_static = false)
-      :	module(0), construct_type(_ptr ? 0 : _type), own(_own), 
+      :	module(0), construct_type(_ptr ? 0 : _type), thisown(_own), 
       always_static(_always_static) {
       if (_type || _ptr)
 	types.push_back(std::make_pair(_type, _ptr));
@@ -426,7 +426,7 @@ SWIGRUNTIME void swig_acquire_ownership_obj(void *vptr, int own);
     }
 
     ~octave_swig_type() {
-      if (own) {
+      if (thisown) {
 	++count;
 	for (unsigned int j = 0; j < types.size(); ++j) {
 	  if (!types[j].first || !types[j].first->clientdata)
@@ -559,7 +559,7 @@ SWIGRUNTIME void swig_acquire_ownership_obj(void *vptr, int own);
     }
 
     void merge(octave_swig_type &rhs) {
-      rhs.own = 0;
+      rhs.thisown = 0;
       for (unsigned int j = 0; j < rhs.types.size(); ++j) {
 	assert(!rhs.types[j].second.destroyed);
 #ifdef SWIG_DIRECTORS
@@ -582,21 +582,40 @@ SWIGRUNTIME void swig_acquire_ownership_obj(void *vptr, int own);
     swig_member_const_iterator swig_members_begin() { return members.begin(); }
     swig_member_const_iterator swig_members_end() { return members.end(); }
 
-    int cast(void **vptr, swig_type_info *type, int *_own, int flags) {
+    int cast(void **vptr, swig_type_info *type, int *own, int flags) {
       int res = SWIG_ERROR;
-      if (_own)
+      int clear_pointer = 0;
-	*_own = own;
+
-      if (flags &SWIG_POINTER_DISOWN)
+      if (own)
-	own = 0;
+	*own = 0;
+      if (((flags & SWIG_POINTER_RELEASE) == SWIG_POINTER_RELEASE) && !thisown) {
+	return SWIG_ERROR_RELEASE_NOT_OWNED;
+      } else {
+	if (own)
+	  *own = *own | thisown;
+	if (flags & SWIG_POINTER_DISOWN) {
+	  thisown = 0;
+	}
+	if (flags & SWIG_POINTER_CLEAR) {
+	  clear_pointer = 1;
+	}
+      }
+
       if (!type && types.size()) {
-	if(vptr)
+	if (vptr) {
           *vptr = types[0].second.ptr;
+	  if (clear_pointer)
+	    types[0].second.ptr = 0;
+        }
         return SWIG_OK;
       }
       for (unsigned int j = 0; j < types.size(); ++j)
 	if (type == types[j].first) {
-	  if(vptr)
+	  if (vptr) {
             *vptr = types[j].second.ptr;
+	    if (clear_pointer)
+	      types[j].second.ptr = 0;
+	  }
           return SWIG_OK;
         }
       for (unsigned int j = 0; j < types.size(); ++j) {
@@ -607,10 +626,12 @@ SWIGRUNTIME void swig_acquire_ownership_obj(void *vptr, int own);
 	  int newmemory = 0;
 	  *vptr = SWIG_TypeCast(tc, types[j].second.ptr, &newmemory);
 	  if (newmemory == SWIG_CAST_NEW_MEMORY) {
-              assert(_own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
+	    assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
-              if (_own)
+	    if (own)
-                *_own = *_own | SWIG_CAST_NEW_MEMORY;
+	      *own = *own | SWIG_CAST_NEW_MEMORY;
 	  }
+	  if (clear_pointer)
+	    types[j].second.ptr = 0;
         }
         res = SWIG_OK;
         break;
@@ -619,7 +640,7 @@ SWIGRUNTIME void swig_acquire_ownership_obj(void *vptr, int own);
     }
 
     bool is_owned() const {
-      return own;
+      return thisown;
     }
 
 #ifdef SWIG_DIRECTORS
@@ -1526,6 +1547,7 @@ octave_value_typeinfo::register_binary_op(octave_value::op_##name,tid1,tid2,swig
 SWIGRUNTIME octave_value SWIG_Octave_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
   int own = (flags &SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
 
+  if (ptr) {
 #ifdef SWIG_DIRECTORS
     Swig::Director *d = Swig::get_rtdir(ptr);
     if (d && Swig::swig_director_get_self(d))
@@ -1533,6 +1555,8 @@ SWIGRUNTIME octave_value SWIG_Octave_NewPointerObj(void *ptr, swig_type_info *ty
 #endif
     return Swig::swig_value_ref(new octave_swig_type(ptr, type, own));
   }
+  return octave_value(Matrix()); // null matrix
+}
 
 SWIGRUNTIME int SWIG_Octave_ConvertPtrAndOwn(octave_value ov, void **ptr, swig_type_info *type, int flags, int *own) {
     if (

linux/bin/swig/share/swig/4.1.0/octave/octtypemaps.swg

@@ -32,8 +32,15 @@
 #define SWIG_SetConstant(name, obj)     SWIG_Octave_SetConstant(module_ns,name,obj) 
 
 // raise
-#define SWIG_Octave_Raise(OBJ, TYPE, DESC) error("C++ side threw an exception of type " TYPE)
+%runtime %{
-#define SWIG_Raise(obj, type, desc)     SWIG_Octave_Raise(obj, type, desc)
+SWIGINTERN void SWIG_Octave_Raise(const octave_value &obj, const char *type) {
+  if (obj.is_string())
+    error("%s", obj.string_value().c_str());
+  else
+    error("C++ side threw an exception of type %s", type);
+}
+%}
+#define SWIG_Raise(obj, type, desc)     SWIG_Octave_Raise(obj, type)
 
 // Include the unified typemap library
 %include <typemaps/swigtypemaps.swg>

linux/bin/swig/share/swig/4.1.0/octave/std_auto_ptr.i

@@ -0,0 +1,39 @@
+/* -----------------------------------------------------------------------------
+ * std_auto_ptr.i
+ *
+ * SWIG library file for handling std::auto_ptr.
+ * Memory ownership is passed from the std::auto_ptr C++ layer to the proxy
+ * class when returning a std::auto_ptr from a function.
+ * Memory ownership is passed from the proxy class to the std::auto_ptr in the
+ * C++ layer when passed as a parameter to a wrapped function.
+ * ----------------------------------------------------------------------------- */
+
+%define %auto_ptr(TYPE)
+%typemap(in, noblock=1) std::auto_ptr< TYPE > (void *argp = 0, int res = 0) {
+  res = SWIG_ConvertPtr($input, &argp, $descriptor(TYPE *), SWIG_POINTER_RELEASE | %convertptr_flags);
+  if (!SWIG_IsOK(res)) {
+    if (res == SWIG_ERROR_RELEASE_NOT_OWNED) {
+      %releasenotowned_fail(res, "TYPE *", $symname, $argnum);
+    } else {
+      %argument_fail(res, "TYPE *", $symname, $argnum);
+    }
+  }
+  $1.reset((TYPE *)argp);
+}
+
+%typemap (out) std::auto_ptr< TYPE > %{
+  %set_output(SWIG_NewPointerObj($1.release(), $descriptor(TYPE *), SWIG_POINTER_OWN | %newpointer_flags));
+%}
+
+%typemap(typecheck, precedence=SWIG_TYPECHECK_POINTER, equivalent="TYPE *", noblock=1) std::auto_ptr< TYPE > {
+  void *vptr = 0;
+  int res = SWIG_ConvertPtr($input, &vptr, $descriptor(TYPE *), 0);
+  $1 = SWIG_CheckState(res);
+}
+
+%template() std::auto_ptr< TYPE >;
+%enddef
+
+namespace std {
+  template <class T> class auto_ptr {};
+}

linux/bin/swig/share/swig/4.1.0/octave/std_unique_ptr.i

@@ -0,0 +1,39 @@
+/* -----------------------------------------------------------------------------
+ * std_unique_ptr.i
+ *
+ * SWIG library file for handling std::unique_ptr.
+ * Memory ownership is passed from the std::unique_ptr C++ layer to the proxy
+ * class when returning a std::unique_ptr from a function.
+ * Memory ownership is passed from the proxy class to the std::unique_ptr in the
+ * C++ layer when passed as a parameter to a wrapped function.
+ * ----------------------------------------------------------------------------- */
+
+%define %unique_ptr(TYPE)
+%typemap(in, noblock=1) std::unique_ptr< TYPE > (void *argp = 0, int res = 0) {
+  res = SWIG_ConvertPtr($input, &argp, $descriptor(TYPE *), SWIG_POINTER_RELEASE | %convertptr_flags);
+  if (!SWIG_IsOK(res)) {
+    if (res == SWIG_ERROR_RELEASE_NOT_OWNED) {
+      %releasenotowned_fail(res, "TYPE *", $symname, $argnum);
+    } else {
+      %argument_fail(res, "TYPE *", $symname, $argnum);
+    }
+  }
+  $1.reset((TYPE *)argp);
+}
+
+%typemap (out) std::unique_ptr< TYPE > %{
+  %set_output(SWIG_NewPointerObj($1.release(), $descriptor(TYPE *), SWIG_POINTER_OWN | %newpointer_flags));
+%}
+
+%typemap(typecheck, precedence=SWIG_TYPECHECK_POINTER, equivalent="TYPE *", noblock=1) std::unique_ptr< TYPE > {
+  void *vptr = 0;
+  int res = SWIG_ConvertPtr($input, &vptr, $descriptor(TYPE *), 0);
+  $1 = SWIG_CheckState(res);
+}
+
+%template() std::unique_ptr< TYPE >;
+%enddef
+
+namespace std {
+  template <class T> class unique_ptr {};
+}

linux/bin/swig/share/swig/4.1.0/octave/swigmove.i

@@ -0,0 +1 @@
+%include <typemaps/swigmove.swg>

linux/bin/swig/share/swig/4.1.0/perl5/argcargv.i

@@ -0,0 +1,32 @@
+/* ------------------------------------------------------------
+ * SWIG library containing argc and argv multi-argument typemaps
+ * ------------------------------------------------------------ */
+
+%typemap(in) (int ARGC, char **ARGV) {
+  int i;
+  I32 len;
+  AV *av = (AV *)SvRV($input);
+  if (SvTYPE(av) != SVt_PVAV) {
+    SWIG_croak("in method '$symname', Expecting reference to argv array");
+    goto fail;
+  }
+  len = av_len(av) + 1;
+  $1 = ($1_ltype) len;
+  $2 = (char **) malloc((len+1)*sizeof(char *));
+  for (i = 0; i < len; i++) {
+    SV **tv = av_fetch(av, i, 0);
+    $2[i] = SvPV_nolen(*tv);
+  }
+  $2[i] = NULL;
+}
+
+%typemap(typecheck, precedence=SWIG_TYPECHECK_STRING_ARRAY) (int ARGC, char **ARGV) {
+  AV *av = (AV *)SvRV($input);
+  $1 = SvTYPE(av) == SVt_PVAV;
+}
+
+%typemap(freearg) (int ARGC, char **ARGV) {
+  if ($2 != NULL) {
+    free((void *)$2);
+  }
+}

linux/bin/swig/share/swig/4.1.0/perl5/perlhead.swg

@@ -4,10 +4,21 @@
 #include <stdlib.h>
 extern "C" {
 #endif
+
+#if __GNUC__ >= 10
+#if defined(__cplusplus)
+#pragma GCC diagnostic ignored "-Wvolatile"
+#endif
+#endif
+
 #include "EXTERN.h"
 #include "perl.h"
 #include "XSUB.h"
 
+#if __GNUC__ >= 10
+#pragma GCC diagnostic pop
+#endif
+
 /* PERL_REVISION was added in Perl 5.6. */
 #if !defined PERL_REVISION || (PERL_REVISION-0 == 5 && PERL_VERSION-0 < 8)
 # error SWIG requires Perl >= 5.8.0

linux/bin/swig/share/swig/4.1.0/perl5/perlrun.swg

@@ -210,6 +210,7 @@ SWIG_Perl_ConvertPtrAndOwn(SWIG_MAYBE_PERL_OBJECT SV *sv, void **ptr, swig_type_
   swig_cast_info *tc;
   void *voidptr = (void *)0;
   SV *tsv = 0;
+  int check_owned_pointer_release = (flags & SWIG_POINTER_RELEASE) == SWIG_POINTER_RELEASE;
 
   if (own)
     *own = 0;
@@ -286,13 +287,14 @@ SWIG_Perl_ConvertPtrAndOwn(SWIG_MAYBE_PERL_OBJECT SV *sv, void **ptr, swig_type_
   /* 
    *  DISOWN implementation: we need a perl guru to check this one.
    */
-  if (tsv && (flags & SWIG_POINTER_DISOWN)) {
+  if (tsv && ((flags & SWIG_POINTER_DISOWN) || check_owned_pointer_release)) {
     /* 
      *  almost copy paste code from below SWIG_POINTER_OWN setting
      */
     SV *obj = sv;
     HV *stash = SvSTASH(SvRV(obj));
     GV *gv = *(GV**)hv_fetch(stash, "OWNER", 5, TRUE);
+    int owned = 0;
     if (isGV(gv)) {
       HV *hv = GvHVn(gv);
       /*
@@ -300,10 +302,21 @@ SWIG_Perl_ConvertPtrAndOwn(SWIG_MAYBE_PERL_OBJECT SV *sv, void **ptr, swig_type_
        * Hence, to remove ownership, we delete the entry.
        */
       if (hv_exists_ent(hv, obj, 0)) {
+        owned = 1;
+        if (flags & SWIG_POINTER_DISOWN) {
           hv_delete_ent(hv, obj, 0, 0);
         }
       }
     }
+    if (check_owned_pointer_release && !owned) {
+      return SWIG_ERROR_RELEASE_NOT_OWNED;
+    }
+  }
+
+  if (tsv && (flags & SWIG_POINTER_CLEAR)) {
+    SvIV_set(tsv, 0);
+  }
+
   return SWIG_OK;
 }
 

linux/bin/swig/share/swig/4.1.0/perl5/std_auto_ptr.i

@@ -0,0 +1,39 @@
+/* -----------------------------------------------------------------------------
+ * std_auto_ptr.i
+ *
+ * SWIG library file for handling std::auto_ptr.
+ * Memory ownership is passed from the std::auto_ptr C++ layer to the proxy
+ * class when returning a std::auto_ptr from a function.
+ * Memory ownership is passed from the proxy class to the std::auto_ptr in the
+ * C++ layer when passed as a parameter to a wrapped function.
+ * ----------------------------------------------------------------------------- */
+
+%define %auto_ptr(TYPE)
+%typemap(in, noblock=1) std::auto_ptr< TYPE > (void *argp = 0, int res = 0) {
+  res = SWIG_ConvertPtr($input, &argp, $descriptor(TYPE *), SWIG_POINTER_RELEASE | %convertptr_flags);
+  if (!SWIG_IsOK(res)) {
+    if (res == SWIG_ERROR_RELEASE_NOT_OWNED) {
+      %releasenotowned_fail(res, "TYPE *", $symname, $argnum);
+    } else {
+      %argument_fail(res, "TYPE *", $symname, $argnum);
+    }
+  }
+  $1.reset((TYPE *)argp);
+}
+
+%typemap (out) std::auto_ptr< TYPE > %{
+  %set_output(SWIG_NewPointerObj($1.release(), $descriptor(TYPE *), SWIG_POINTER_OWN | %newpointer_flags));
+%}
+
+%typemap(typecheck, precedence=SWIG_TYPECHECK_POINTER, equivalent="TYPE *", noblock=1) std::auto_ptr< TYPE > {
+  void *vptr = 0;
+  int res = SWIG_ConvertPtr($input, &vptr, $descriptor(TYPE *), 0);
+  $1 = SWIG_CheckState(res);
+}
+
+%template() std::auto_ptr< TYPE >;
+%enddef
+
+namespace std {
+  template <class T> class auto_ptr {};
+}

linux/bin/swig/share/swig/4.1.0/perl5/std_unique_ptr.i

@@ -0,0 +1,39 @@
+/* -----------------------------------------------------------------------------
+ * std_unique_ptr.i
+ *
+ * SWIG library file for handling std::unique_ptr.
+ * Memory ownership is passed from the std::unique_ptr C++ layer to the proxy
+ * class when returning a std::unique_ptr from a function.
+ * Memory ownership is passed from the proxy class to the std::unique_ptr in the
+ * C++ layer when passed as a parameter to a wrapped function.
+ * ----------------------------------------------------------------------------- */
+
+%define %unique_ptr(TYPE)
+%typemap(in, noblock=1) std::unique_ptr< TYPE > (void *argp = 0, int res = 0) {
+  res = SWIG_ConvertPtr($input, &argp, $descriptor(TYPE *), SWIG_POINTER_RELEASE | %convertptr_flags);
+  if (!SWIG_IsOK(res)) {
+    if (res == SWIG_ERROR_RELEASE_NOT_OWNED) {
+      %releasenotowned_fail(res, "TYPE *", $symname, $argnum);
+    } else {
+      %argument_fail(res, "TYPE *", $symname, $argnum);
+    }
+  }
+  $1.reset((TYPE *)argp);
+}
+
+%typemap (out) std::unique_ptr< TYPE > %{
+  %set_output(SWIG_NewPointerObj($1.release(), $descriptor(TYPE *), SWIG_POINTER_OWN | %newpointer_flags));
+%}
+
+%typemap(typecheck, precedence=SWIG_TYPECHECK_POINTER, equivalent="TYPE *", noblock=1) std::unique_ptr< TYPE > {
+  void *vptr = 0;
+  int res = SWIG_ConvertPtr($input, &vptr, $descriptor(TYPE *), 0);
+  $1 = SWIG_CheckState(res);
+}
+
+%template() std::unique_ptr< TYPE >;
+%enddef
+
+namespace std {
+  template <class T> class unique_ptr {};
+}

linux/bin/swig/share/swig/4.1.0/perl5/swigmove.i

@@ -0,0 +1 @@
+%include <typemaps/swigmove.swg>

linux/bin/swig/share/swig/4.1.0/php/argcargv.i

@@ -0,0 +1,40 @@
+/* ------------------------------------------------------------
+ * SWIG library containing argc and argv multi-argument typemaps
+ * ------------------------------------------------------------ */
+
+%typemap(in) (int ARGC, char **ARGV) {
+  int len, i;
+  zval *val;
+  zend_array *ar;
+  if (Z_TYPE($input) != IS_ARRAY) {
+    SWIG_PHP_Error(E_ERROR, "Type error in '$symname'. Expected array");
+    goto fail;
+  }
+  ar = Z_ARR($input);
+  len = zend_array_count(ar);
+  $1 = ($1_ltype) len;
+  $2 = (char **) malloc((len+1)*sizeof(char *));
+  i = 0;
+  ZEND_HASH_FOREACH_VAL(ar, val) {
+    if (Z_TYPE(*val) != IS_STRING) {
+      SWIG_PHP_Error(E_ERROR, "Array must use strings only, in '$symname'.");
+      goto fail;
+    }
+    if (i == len) {
+      SWIG_PHP_Error(E_ERROR, "Array is bigger than zend report in '$symname'.");
+      goto fail;
+    }
+    $2[i++] = Z_STRVAL(*val);
+  } ZEND_HASH_FOREACH_END();
+  $2[i] = NULL;
+}
+
+%typemap(typecheck, precedence=SWIG_TYPECHECK_STRING_ARRAY) (int ARGC, char **ARGV) {
+  $1 = Z_TYPE($input) == IS_ARRAY;
+}
+
+%typemap(freearg) (int ARGC, char **ARGV) {
+  if ($2 != NULL) {
+    free((void *)$2);
+  }
+}

linux/bin/swig/share/swig/4.1.0/php/const.i

@@ -12,11 +12,11 @@
                         unsigned char,
                         signed char,
                         enum SWIGTYPE %{
-  zend_declare_class_constant_long(SWIG_Php_ce_$class, "$const_name", sizeof("$const_name") - 1, ($1_type)$value);
+  zend_declare_class_constant_long(SWIG_Php_ce_$class, "$const_name", sizeof("$const_name") - 1, ($1_type)($value));
 %}
 
 %typemap(classconsttab) bool %{
-  zend_declare_class_constant_bool(SWIG_Php_ce_$class, "$const_name", sizeof("$const_name") - 1, ($1_type)$value);
+  zend_declare_class_constant_bool(SWIG_Php_ce_$class, "$const_name", sizeof("$const_name") - 1, ($1_type)($value));
 %}
 
 %typemap(classconsttab) float,
@@ -48,13 +48,13 @@
 {
   zval z;
   ZVAL_UNDEF(&z);
-  SWIG_SetPointerZval(&z, (void*)$value, $1_descriptor, 0);
+  SWIG_SetPointerZval(&z, (void*)($value), $1_descriptor, 0);
   zval_copy_ctor(&z);
   zend_declare_class_constant(SWIG_Php_ce_$class, "$const_name", sizeof("$const_name") - 1, &z);
 }
 %}
 
-%typemap(classconsttab) SWIGTYPE (CLASS::*) "";
+%typemap(classconsttab) SWIGTYPE (CLASS::*) ""
 
 %typemap(consttab) int,
                    unsigned int,
@@ -65,10 +65,10 @@
                    unsigned char,
                    signed char,
                    enum SWIGTYPE
-  "SWIG_LONG_CONSTANT($symname, ($1_type)$value);";
+  "SWIG_LONG_CONSTANT($symname, ($1_type)($value));";
 
 %typemap(consttab) bool
-  "SWIG_BOOL_CONSTANT($symname, ($1_type)$value);";
+  "SWIG_BOOL_CONSTANT($symname, ($1_type)($value));";
 
 %typemap(consttab) float,
                    double
@@ -92,7 +92,7 @@
                    SWIGTYPE [] {
   zend_constant c;
   ZVAL_UNDEF(&c.value);
-  SWIG_SetPointerZval(&c.value, (void*)$value, $1_descriptor, 0);
+  SWIG_SetPointerZval(&c.value, (void*)($value), $1_descriptor, 0);
   zval_copy_ctor(&c.value);
   c.name = zend_string_init("$symname", sizeof("$symname") - 1, 0);
   SWIG_ZEND_CONSTANT_SET_FLAGS(&c, CONST_CS, module_number);
@@ -100,4 +100,4 @@
 }
 
 /* Handled as a global variable. */
-%typemap(consttab) SWIGTYPE (CLASS::*) "";
+%typemap(consttab) SWIGTYPE (CLASS::*) ""

linux/bin/swig/share/swig/4.1.0/php/php.swg

@@ -125,14 +125,31 @@
   swig_acquire_ownership_obj((void*)$result, own);
 %}
 
-%typemap(in, phptype="SWIGTYPE") SWIGTYPE &,
+%typemap(in, phptype="SWIGTYPE") SWIGTYPE &
-             SWIGTYPE &&
 %{
   if (SWIG_ConvertPtr(&$input, (void **) &$1, $1_descriptor, 0) < 0 || $1 == NULL) {
     zend_type_error("Expected $1_descriptor for argument $argnum of $symname");
     return;
   }
 %}
+%typemap(in, fragment="<memory>") SWIGTYPE && (void *argp = 0, int res = 0, std::unique_ptr<$*1_ltype> rvrdeleter) %{
+  res = SWIG_ConvertPtr(&$input, &argp, $descriptor, SWIG_POINTER_RELEASE);
+  if (!SWIG_IsOK(res)) {
+    if (res == SWIG_ERROR_RELEASE_NOT_OWNED) {
+      zend_type_error("Cannot release ownership as memory is not owned for argument $argnum of $1_descriptor of $symname");
+      return;
+    } else {
+      zend_type_error("Expected $1_descriptor for argument $argnum of $symname");
+      return;
+    }
+  }
+  if (!argp) {
+    zend_type_error("Invalid null reference for argument $argnum of $1_descriptor of $symname");
+    return;
+  }
+  $1 = ($1_ltype)argp;
+  rvrdeleter.reset($1);
+%}
 
 %typemap(directorout) SWIGTYPE & ($1_ltype tmp),
 		      SWIGTYPE && ($1_ltype tmp)
@@ -240,9 +257,7 @@
   if ((long long)LONG_MIN <= $1 && $1 <= (long long)LONG_MAX) {
     RETVAL_LONG((long)($1));
   } else {
-    char temp[256];
+    RETVAL_NEW_STR(zend_strpprintf(0, "%lld", (long long)$1));
-    sprintf(temp, "%lld", (long long)$1);
-    RETVAL_STRING(temp);
   }
 %}
 %typemap(out, phptype="int|string") unsigned long long
@@ -250,9 +265,7 @@
   if ($1 <= (unsigned long long)LONG_MAX) {
     RETVAL_LONG((long)($1));
   } else {
-    char temp[256];
+    RETVAL_NEW_STR(zend_strpprintf(0, "%llu", (unsigned long long)$1));
-    sprintf(temp, "%llu", (unsigned long long)$1);
-    RETVAL_STRING(temp);
   }
 %}
 
@@ -286,9 +299,7 @@
   if ((long long)LONG_MIN <= *$1 && *$1 <= (long long)LONG_MAX) {
     RETVAL_LONG((long)(*$1));
   } else {
-    char temp[256];
+    RETVAL_NEW_STR(zend_strpprintf(0, "%lld", (long long)(*$1)));
-    sprintf(temp, "%lld", (long long)(*$1));
-    RETVAL_STRING(temp);
   }
 %}
 %typemap(out, phptype="int|string") const unsigned long long &
@@ -296,9 +307,7 @@
   if (*$1 <= (unsigned long long)LONG_MAX) {
     RETVAL_LONG((long)(*$1));
   } else {
-    char temp[256];
+    RETVAL_NEW_STR(zend_strpprintf(0, "%llu", (unsigned long long)(*$1)));
-    sprintf(temp, "%llu", (unsigned long long)(*$1));
-    RETVAL_STRING(temp);
   }
 %}
 
@@ -451,7 +460,7 @@
 %typemap(out, phptype="SWIGTYPE") SWIGTYPE
 {
 #ifdef __cplusplus
-  $&1_ltype resultobj = new $1_ltype((const $1_ltype &) $1);
+  $&1_ltype resultobj = new $1_ltype($1);
 #else
   $&1_ltype resultobj = ($&1_ltype) malloc(sizeof($1_type));
   memcpy(resultobj, &$1, sizeof($1_type));
@@ -462,10 +471,10 @@
 %typemap(directorin) SWIGTYPE
 %{
   ZVAL_UNDEF($input);
-  SWIG_SetPointerZval($input, SWIG_as_voidptr(new $1_ltype((const $1_ltype &)$1)), $&1_descriptor, 1);
+  SWIG_SetPointerZval($input, (new $1_ltype(SWIG_STD_MOVE($1))), $&1_descriptor, 1);
 %}
 
-%typemap(out, phptype="void") void "";
+%typemap(out, phptype="void") void ""
 
 %typemap(out, phptype="string") char [ANY]
 {

linux/bin/swig/share/swig/4.1.0/php/phpinit.swg

@@ -9,4 +9,8 @@
 SWIG_php_minit {
   zend_class_entry SWIGUNUSED internal_ce;
   SWIG_InitializeModule((void*)&module_number);
+#if PHP_MAJOR_VERSION == 8 && PHP_MINOR_VERSION == 0
+  /* This hack is needed to avoid segfaults. */
+  EG(class_table) = CG(class_table);
+#endif
 %}

linux/bin/swig/share/swig/4.1.0/php/phprun.swg

@@ -10,8 +10,6 @@
 extern "C" {
 #endif
 
-#include "php.h"
-
 #if PHP_MAJOR_VERSION < 7
 # error These bindings need PHP 7 or later - to generate PHP5 bindings use: SWIG < 4.0.0 and swig -php5
 #endif
@@ -195,7 +193,7 @@ SWIG_ConvertPtrAndOwn(zval *z, void **ptr, swig_type_info *ty, int flags, swig_o
 	/* They don't care about the target type, so just pass on the pointer! */
 	*ptr = value->ptr;
       } else {
-	swig_cast_info *tc = SWIG_TypeCheckStruct(value->type, ty);
+	swig_cast_info *tc = SWIG_TypeCheck(value->type->name, ty);
 	if (tc) {
 	  int newmemory = 0;
 	  *ptr = SWIG_TypeCast(tc, value->ptr, &newmemory);
@@ -208,10 +206,20 @@ SWIG_ConvertPtrAndOwn(zval *z, void **ptr, swig_type_info *ty, int flags, swig_o
 	  *ptr = NULL;
 	}
       }
-      if (*ptr == NULL) return SWIG_ERROR;
+
+      if (((flags & SWIG_POINTER_RELEASE) == SWIG_POINTER_RELEASE) && !value->newobject) {
+        return SWIG_ERROR_RELEASE_NOT_OWNED;
+      } else {
+        if (*ptr == NULL)
+          return SWIG_ERROR; /* should be SWIG_NullReferenceError?? */
         if (flags & SWIG_POINTER_DISOWN) {
           value->newobject = 0;
         }
+        if (flags & SWIG_POINTER_CLEAR) {
+          value->ptr = 0;
+        }
+      }
+
       return SWIG_OK;
     }
     case IS_NULL:

linux/bin/swig/share/swig/4.1.0/php/std_auto_ptr.i

@@ -0,0 +1,41 @@
+/* -----------------------------------------------------------------------------
+ * std_auto_ptr.i
+ *
+ * SWIG library file for handling std::auto_ptr.
+ * Memory ownership is passed from the std::auto_ptr C++ layer to the proxy
+ * class when returning a std::auto_ptr from a function.
+ * Memory ownership is passed from the proxy class to the std::auto_ptr in the
+ * C++ layer when passed as a parameter to a wrapped function.
+ * ----------------------------------------------------------------------------- */
+
+%define %auto_ptr(TYPE)
+%typemap(in, noblock=1) std::auto_ptr< TYPE > (void *argp = 0, int res = 0) {
+  res = SWIG_ConvertPtr(&$input, &argp, $descriptor(TYPE *), SWIG_POINTER_RELEASE);
+  if (!SWIG_IsOK(res)) {
+    if (res == SWIG_ERROR_RELEASE_NOT_OWNED) {
+      zend_type_error("Cannot release ownership as memory is not owned for argument $argnum of $descriptor(TYPE *) of $symname");
+      return;
+    } else {
+      zend_type_error("Expected $descriptor(TYPE *) for argument $argnum of $symname");
+      return;
+    }
+  }
+  $1.reset((TYPE *)argp);
+}
+
+%typemap (out) std::auto_ptr< TYPE > %{
+  SWIG_SetPointerZval($result, (void *)$1.release(), $descriptor(TYPE *), SWIG_POINTER_OWN);
+%}
+
+%typemap(typecheck, precedence=SWIG_TYPECHECK_POINTER, equivalent="TYPE *", noblock=1) std::auto_ptr< TYPE > {
+  void *vptr = 0;
+  int res = SWIG_ConvertPtr(&$input, &vptr, $descriptor(TYPE *), 0);
+  $1 = SWIG_CheckState(res);
+}
+
+%template() std::auto_ptr< TYPE >;
+%enddef
+
+namespace std {
+  template <class T> class auto_ptr {};
+}

linux/bin/swig/share/swig/4.1.0/php/std_string.i

@@ -86,5 +86,5 @@ namespace std {
 
     /* SWIG will apply the non-const typemap above to const string& without
      * this more specific typemap. */
-    %typemap(argout) const string & "";
+    %typemap(argout) const string & ""
 }

linux/bin/swig/share/swig/4.1.0/php/std_unique_ptr.i

@@ -0,0 +1,41 @@
+/* -----------------------------------------------------------------------------
+ * std_unique_ptr.i
+ *
+ * SWIG library file for handling std::unique_ptr.
+ * Memory ownership is passed from the std::unique_ptr C++ layer to the proxy
+ * class when returning a std::unique_ptr from a function.
+ * Memory ownership is passed from the proxy class to the std::unique_ptr in the
+ * C++ layer when passed as a parameter to a wrapped function.
+ * ----------------------------------------------------------------------------- */
+
+%define %unique_ptr(TYPE)
+%typemap(in, noblock=1) std::unique_ptr< TYPE > (void *argp = 0, int res = 0) {
+  res = SWIG_ConvertPtr(&$input, &argp, $descriptor(TYPE *), SWIG_POINTER_RELEASE);
+  if (!SWIG_IsOK(res)) {
+    if (res == SWIG_ERROR_RELEASE_NOT_OWNED) {
+      zend_type_error("Cannot release ownership as memory is not owned for argument $argnum of $descriptor(TYPE *) of $symname");
+      return;
+    } else {
+      zend_type_error("Expected $descriptor(TYPE *) for argument $argnum of $symname");
+      return;
+    }
+  }
+  $1.reset((TYPE *)argp);
+}
+
+%typemap (out) std::unique_ptr< TYPE > %{
+  SWIG_SetPointerZval($result, (void *)$1.release(), $descriptor(TYPE *), SWIG_POINTER_OWN);
+%}
+
+%typemap(typecheck, precedence=SWIG_TYPECHECK_POINTER, equivalent="TYPE *", noblock=1) std::unique_ptr< TYPE > {
+  void *vptr = 0;
+  int res = SWIG_ConvertPtr(&$input, &vptr, $descriptor(TYPE *), 0);
+  $1 = SWIG_CheckState(res);
+}
+
+%template() std::unique_ptr< TYPE >;
+%enddef
+
+namespace std {
+  template <class T> class unique_ptr {};
+}

linux/bin/swig/share/swig/4.1.0/php/swigmove.i

@@ -0,0 +1,24 @@
+/* -----------------------------------------------------------------------------
+ * swigmove.i
+ *
+ * Input typemaps library for implementing full move semantics when passing
+ * parameters by value.
+ * ----------------------------------------------------------------------------- */
+
+%typemap(in, noblock=1) SWIGTYPE MOVE (void *argp = 0, int res = 0) {
+  res = SWIG_ConvertPtr(&$input, &argp, $&1_descriptor, SWIG_POINTER_RELEASE);
+  if (!SWIG_IsOK(res)) {
+    if (res == SWIG_ERROR_RELEASE_NOT_OWNED) {
+      zend_type_error("Cannot release ownership as memory is not owned for argument $argnum of $&1_descriptor of $symname");
+      return;
+    } else {
+      zend_type_error("Expected $&1_descriptor for argument $argnum of $symname");
+      return;
+    }
+  }
+  if (!argp) {
+    zend_type_error("Invalid null reference for argument $argnum of $&1_descriptor of $symname");
+    return;
+  }
+  SwigValueWrapper< $1_ltype >::reset($1, ($&1_type)argp);
+}

linux/bin/swig/share/swig/4.1.0/php/typemaps.i

@@ -31,8 +31,8 @@
   temp = (Z_TYPE($input) == IS_TRUE);
   $1 = &temp;
 %}
-%typemap(argout) TYPE *INPUT, TYPE &INPUT "";
+%typemap(argout) TYPE *INPUT, TYPE &INPUT ""
-%typemap(in,numinputs=0) TYPE *OUTPUT(TYPE temp), TYPE &OUTPUT(TYPE temp) "$1 = &temp;";
+%typemap(in,numinputs=0) TYPE *OUTPUT(TYPE temp), TYPE &OUTPUT(TYPE temp) "$1 = &temp;"
 %typemap(argout,fragment="t_output_helper") TYPE *OUTPUT, TYPE &OUTPUT
 {
   zval o;
@@ -57,8 +57,8 @@
   temp = (TYPE) zval_get_double(&$input);
   $1 = &temp;
 %}
-%typemap(argout) TYPE *INPUT, TYPE &INPUT "";
+%typemap(argout) TYPE *INPUT, TYPE &INPUT ""
-%typemap(in,numinputs=0) TYPE *OUTPUT(TYPE temp), TYPE &OUTPUT(TYPE temp) "$1 = &temp;";
+%typemap(in,numinputs=0) TYPE *OUTPUT(TYPE temp), TYPE &OUTPUT(TYPE temp) "$1 = &temp;"
 %typemap(argout,fragment="t_output_helper") TYPE *OUTPUT, TYPE &OUTPUT
 {
   zval o;
@@ -82,8 +82,8 @@
   temp = (TYPE) zval_get_long(&$input);
   $1 = &temp;
 %}
-%typemap(argout) TYPE *INPUT, TYPE &INPUT "";
+%typemap(argout) TYPE *INPUT, TYPE &INPUT ""
-%typemap(in,numinputs=0) TYPE *OUTPUT(TYPE temp), TYPE &OUTPUT(TYPE temp) "$1 = &temp;";
+%typemap(in,numinputs=0) TYPE *OUTPUT(TYPE temp), TYPE &OUTPUT(TYPE temp) "$1 = &temp;"
 %typemap(argout,fragment="t_output_helper") TYPE *OUTPUT, TYPE &OUTPUT
 {
   zval o;
@@ -122,9 +122,7 @@ INT_TYPEMAP(long long);
   if ((long long)LONG_MIN <= temp$argnum && temp$argnum <= (long long)LONG_MAX) {
     ZVAL_LONG(&o, (long)temp$argnum);
   } else {
-    char temp[256];
+    ZVAL_NEW_STR(&o, zend_strpprintf(0, "%lld", (long long)temp$argnum));
-    sprintf(temp, "%lld", (long long)temp$argnum);
-    ZVAL_STRING(&o, temp);
   }
   t_output_helper($result, &o);
 }
@@ -138,9 +136,7 @@ INT_TYPEMAP(long long);
   if ((long long)LONG_MIN <= lvalue$argnum && lvalue$argnum <= (long long)LONG_MAX) {
     ZVAL_LONG(&$arg, (long)temp$argnum);
   } else {
-    char temp[256];
+    ZVAL_NEW_STR(&$arg, zend_strpprintf(0, "%lld", (long long)lvalue$argnum));
-    sprintf(temp, "%lld", (long long)lvalue$argnum);
-    ZVAL_STRING(&$arg, temp);
   }
 %}
 %typemap(argout) long long &OUTPUT
@@ -148,9 +144,7 @@ INT_TYPEMAP(long long);
   if ((long long)LONG_MIN <= *arg$argnum && *arg$argnum <= (long long)LONG_MAX) {
     ZVAL_LONG($result, (long)(*arg$argnum));
   } else {
-    char temp[256];
+    ZVAL_NEW_STR($result, zend_strpprintf(0, "%lld", (long long)(*arg$argnum)));
-    sprintf(temp, "%lld", (long long)(*arg$argnum));
-    ZVAL_STRING($result, temp);
   }
 %}
 
@@ -161,9 +155,7 @@ INT_TYPEMAP(unsigned long long);
   if (temp$argnum <= (unsigned long long)LONG_MAX) {
     ZVAL_LONG(&o, temp$argnum);
   } else {
-    char temp[256];
+    ZVAL_NEW_STR(&o, zend_strpprintf(0, "%llu", (unsigned long long)temp$argnum));
-    sprintf(temp, "%llu", (unsigned long long)temp$argnum);
-    ZVAL_STRING(&o, temp);
   }
   t_output_helper($result, &o);
 }
@@ -177,9 +169,7 @@ INT_TYPEMAP(unsigned long long);
   if (lvalue$argnum <= (unsigned long long)LONG_MAX) {
     ZVAL_LONG($arg, (long)(lvalue$argnum));
   } else {
-    char temp[256];
+    ZVAL_NEW_STR((*$arg), zend_strpprintf(0, "%llu", (unsigned long long)lvalue$argnum));
-    sprintf(temp, "%llu", (unsigned long long)lvalue$argnum);
-    ZVAL_STRING((*$arg), temp);
   }
 %}
 %typemap(argout) unsigned long long &OUTPUT
@@ -187,9 +177,7 @@ INT_TYPEMAP(unsigned long long);
   if (*arg$argnum <= (unsigned long long)LONG_MAX) {
     ZVAL_LONG($result, (long)(*arg$argnum));
   } else {
-    char temp[256];
+    ZVAL_NEW_STR($result, zend_strpprintf(0, "%llu", (unsigned long long)(*arg$argnum)));
-    sprintf(temp, "%llu", (unsigned long long)(*arg$argnum));
-    ZVAL_STRING($result, temp);
   }
 %}
 

linux/bin/swig/share/swig/4.1.0/php/utils.i

@@ -81,7 +81,7 @@
 %{
   $*1_ltype swig_val;
   CONVERT_IN(swig_val, $*1_ltype, *$input);
-  $1_ltype temp = new $*1_ltype(($*1_ltype)swig_val);
+  $1_ltype temp = new $*1_ltype(swig_val);
   swig_acquire_ownership(temp);
   $result = temp;
 %}

linux/bin/swig/share/swig/4.1.0/pointer.i

@@ -4,7 +4,7 @@
 
 
 %echo "pointer.i is deprecated.  Use cpointer.i instead."
-%echo "See http://www.swig.org/Doc3.0/Library.html"
+%echo "See https://www.swig.org/Doc3.0/Library.html"