SWIG (Simplified Wrapper and Interface Generator) Tagline: SWIG is a compiler that integrates C and C++ with languages including Perl, Python, Tcl, Ruby, PHP, Java, C#, D, Go, Lua, Octave, R, Scheme (Guile, MzScheme/Racket), Scilab, Ocaml. SWIG can also export its parse tree into XML. SWIG reads annotated C/C++ header files and creates wrapper code (glue code) in order to make the corresponding C/C++ libraries available to the listed languages, or to extend C/C++ programs with a scripting language. Up-to-date SWIG related information can be found at https://www.swig.org A SWIG FAQ and other hints can be found on the SWIG Wiki: https://github.com/swig/swig/wiki License ======= Please see the LICENSE file for details of the SWIG license. For further insight into the license including the license of SWIG's output code, please visit https://www.swig.org/legal.html Release Notes ============= Please see the CHANGES.current file for a detailed list of bug fixes and new features for the current release. The CHANGES file contains bug fixes and new features for older versions. A summary of changes in each release can be found in the RELEASENOTES file. Documentation ============= The Doc/Manual directory contains the most recent set of updated documentation for this release. The documentation is available in three different formats, each of which contains identical content. These format are, pdf (Doc/Manual/SWIGDocumentation.pdf), single page html (Doc/Manual/SWIGDocumentation.html) or multiple page html (other files in Doc/Manual). Please select your chosen format and copy/install to wherever takes your fancy. There is some technical developer documentation available in the Doc/Devel subdirectory. This is not necessarily up-to-date, but it has some information on SWIG internals. Documentation is also online at https://www.swig.org/doc.html. Backwards Compatibility ======================= The developers strive their best to preserve backwards compatibility between releases, but this is not always possible as the overriding aim is to provide the best wrapping experience. Where backwards compatibility is known to be broken, it is clearly marked as an incompatibility in the CHANGES and CHANGES.current files. See the documentation for details of the SWIG_VERSION preprocessor symbol if you have backward compatibility issues and need to use more than one version of SWIG. Installation ============ Please read the Doc/Manual/Preface.html#Preface_installation for full installation instructions for Windows, Unix and Mac OS X using the release tarball/zip file. The INSTALL file has generic build and installation instructions for Unix users. Users wishing to build and install code from Github should visit https://swig.org/svn.html to obtain the more detailed instructions required for building code obtained from Github - extra steps are required compared to building from the release tarball. Testing ======= The typical 'make -k check' can be performed on Unix operating systems. Please read Doc/Manual/Preface.html#Preface_testing for details. Examples ======== The Examples directory contains a variety of examples of using SWIG and it has some browsable documentation. Simply point your browser to the file "Example/index.html". The Examples directory also includes Visual C++ project 6 (.dsp) files for building some of the examples on Windows. Later versions of Visual Studio will convert these old style project files into a current solution file. Known Issues ============ There are minor known bugs, details of which are in the bug tracker, see https://www.swig.org/bugs.html. Troubleshooting =============== In order to operate correctly, SWIG relies upon a set of library files. If after building SWIG, you get error messages like this, $ swig foo.i :1. Unable to find 'swig.swg' :3. Unable to find 'tcl8.swg' it means that SWIG has either been incorrectly configured or installed. To fix this: 1. Make sure you remembered to do a 'make install' and that the installation actually worked. Make sure you have write permission on the install directory. 2. If that doesn't work, type 'swig -swiglib' to find out where SWIG thinks its library is located. 3. If the location is not where you expect, perhaps you supplied a bad option to configure. Use ./configure --prefix=pathname to set the SWIG install location. Also, make sure you don't include a shell escape character such as ~ when you specify the path. 4. The SWIG library can be changed by setting the SWIG_LIB environment variable. However, you really shouldn't have to do this. If you are having other troubles, you might look at the SWIG Wiki at https://github.com/swig/swig/wiki. Participate! ============ Please report any errors and submit patches (if possible)! We only have access to a limited variety of hardware (Linux, Solaris, OS-X, and Windows). All contributions help. If you would like to join the SWIG development team or contribute a language module to the distribution, please contact the swig-devel mailing list, details at https://www.swig.org/mail.html. -- The SWIG Maintainers Below are the changes for the current release. See the CHANGES file for changes in older releases. See the RELEASENOTES file for a summary of changes in each release. Issue # numbers mentioned below can be found on Github. For more details, add the issue number to the end of the URL: https://github.com/swig/swig/issues/ Version 4.2.0 (30 Dec 2023) =========================== 2023-12-24: degasus [Python] #2494 Fix integer overflow / undefined behavior for python castmode on sizeof(long)==8 platforms for implicit conversions around edge cases of LONG_MAX and ULONG_MAX, for example: void as_l(long x); // C interface Usage from Python: lmaxd = math.nextafter(float(2**63), 0.0) # LONG_MAX == 2**63-1 # Now below correctly raises a TypeError due to the overflow as_l(math.nextafter(lmaxd, float('inf'))) 2023-12-21: olly [PHP] `%feature("php:allowdynamicproperties", 0) Foo;` is now handled as the feature being off to match other boolean features. Previously any value set was treated as on. 2023-12-20: treitmayr [Ruby] #2033 Fix missing checks for negative numbers when passing numbers to unsigned long/unsigned long long C types. 2023-12-20: crhilton [C#] #2722 Add support the "cs:defaultargs" feature. This adds a way to wrap C++ functions that have default arguments with an equivalent C# function with default arguments, instead of generating an overloaded C# method for each defaulted argument. 2023-12-20: vadz, vadimcn, wangito33, wsfulton, clintonstimpson [Python] #1613 #1687 #1727 #2190 #2727 #2428 Add support for the Python stable ABI using default Python options. Code is generated that compiles when setting the C macro Py_LIMITED_API to 0x03040000 (at C/C++ compile time). Note that the -builtin, -fast (used by -O) options are not supported. 2023-12-20: wsfulton [Python] More efficient input string marshalling for Python 3. Previously a copy of a string was made while converting from a Python 3 string to a char * or std::string. This copy is no longer needed making string marshalling more efficient. Does not apply to the stable ABI targetting Python < 3.10 where a copy is still required where the stable ABI does not provide PyUnicode_AsUTF8AndSize. 2023-12-20: wsfulton #2190 Replace SWIG_Python_str_AsChar with SWIG_PyUnicode_AsUTF8AndSize. SWIG_Python_str_AsChar has undefined behaviour when Py_LIMITED_API is defined as it returns a pointer to a string in a PyBytes object that no longer exists. SWIG_PyUnicode_AsUTF8AndSize is an efficient replacement, but requires a different API and the caller to decrement the refcount on the intermediate PyObject in the Py_LIMITED_API < 0x030A0000 implementation. The alternative would have required copying the returned char * string as was done in a previous implementation requiring a call to the defunct SWIG_Python_str_DelForPy3 function. *** POTENTIAL INCOMPATIBILITY *** 2023-12-14: PaulObermeier [Tcl] #2730 Rename SWIG’s Tcl_GetBoolFromObj() since Tcl 8.7 (TIP 618) introduces a function with the same name. 2023-12-13: chrstphrchvz [Tcl] #2729 Use Tcl_GetString() instead of Tcl_GetStringFromObj(…, NULL) for compatibility with Tcl 9. 2023-12-03: olly [Ocaml] Remove -suffix command line option which has emitted a deprecation warning since SWIG 3.0.4 - if you want to specify a different filename extension for generated C++ files use -cppext instead, which works for all SWIG target language backends. 2023-12-01: saiarcot895 [Python] #2413 Prevent potential multi-threading crash; gracefully exit running daemon threads on main thread exit. 2023-11-24: wsfulton Add support for parsing C++20 constexpr destructors. 2023-11-19: olly Fix handling of constant expressions containing < and > to not drop parentheses around the subexpression as doing so can change its value in some cases. 2023-11-18: yasamoka, jmarrec [Python] #2639 Add std_filesystem.i for wrapping std::filesystem::path with pathlib.Path. 2023-11-17: chrstphrchvz [Tcl] #2711 Fix -Wmissing-braces warning in generated code. 2023-11-17: chrstphrchvz [Tcl] #2710 Stop using Tcl's CONST macro. It's no longer needed and is set to be deprecated in Tcl 8.7, and removed in Tcl 9.0. 2023-11-08: wsfulton [C#] Replace empty() method with IsEmpty property for std::vector, std::list, std::map containers for consistency across all containers. The empty() method is actually still wrapped, but as a private proxy method. For backwards compatibility, the method can be made public again using %csmethodmodifiers for all vectors as follows: %extend std::vector { %csmethodmodifiers empty() const "public" } %include "std_vector.i" or alternatively for each individual %template instantiation as follows: %csmethodmodifiers std::vector::empty() const "public" %template(VectorDouble) std::vector; *** POTENTIAL INCOMPATIBILITY *** 2023-11-08: wsfulton [C#] Add std_unordered_set.i for wrapping std::std_unordered_set, implementing C# System.Collections.Generic.ISet<>. 2023-11-09: olly #2591 SWIG now supports command line options -std=cXX and -std=c++XX to specify the C/C++ standards version. The only effect of these options is to set appropriate values for __STDC_VERSION__ and __cplusplus respectively, which is useful if you're wrapping headers which have preprocessor checks based on their values. 2023-11-09: olly SWIG now defines __STDC__ to 1 to match the behaviour of ISO C/C++ compilers - previously it had an empty value. *** POTENTIAL INCOMPATIBILITY *** 2023-11-09: olly When -c++ is used, SWIG now defines __cplusplus to be 199711L (the value for C++98) by default - previously its value was set to __cplusplus. *** POTENTIAL INCOMPATIBILITY *** 2023-11-08: emmenlau #2480 [C#] Add std_unordered_map.i for wrapping std::std_unordered_map, implementing C# System.Collections.Generic.IDictionary<>. 2023-11-06: wsfulton [D, Java] Add the dbegin option to the %module directive for generating code at the beginning of every D file. Similarly javabegin for Java. This enables one to add a common comment at the start of each D/Java file. 2023-11-06: wsfulton [C#] #2681 Support nullable reference types. A generic C# option to the %module directive allows one to add in any code at the beginning of every C# file. This can add the #nullable enable preprocessor directive at the beginning of every C# file in order to enable nullable reference types as follows: %module(csbegin="#nullable enable\n") mymodule 2023-10-21: wsfulton [Python] #1783 Don't swallow all exceptions into a NotImplemented return when wrapping operators which are marked with %pythonmaybecall. Corrects the implementation of PEP 207. 2023-10-18: wsfulton [C#, D] #902 Use the C++11 enum base, that is, the underlying enum type. For C#, it is used as the underlying type in the generated C# enum. For D, it is used as the enum base type in the generated D enum. 2023-10-16: wsfulton #2687 Another using declarations fix for inheritance hierarchies more than two deep and the using declarations are overloaded. Using declarations from a base class' base were not available for use in the target language when the using declaration was before a method declaration. 2023-10-11: wsfulton [C#, D, Go, Guile, Java, Javascript, Lua, Ocaml, R, Racket] #1680 carrays.i library modified to use size_t instead of int for the functions provided by %array_functions and %array_class. If the old types are required for backwards compatibility, use %apply to restore the old types as follows: %include "carrays.i" %apply int { size_t nelements, size_t index } ... %array_functions and %array_class ... %clear size_t nelements, size_t index; # To be safe in case used elsewhere *** POTENTIAL INCOMPATIBILITY *** 2023-10-11: olly [PHP] #2685 Fix testcase director_finalizer to work with PHP 8.3. 2023-10-06: wsfulton #2307 std::vector::capacity and std::vector::reserve signature changes. Java api changes from: public long capacity() { ... } public void reserve(long n) { ... } to: public int capacity() { ... } public void reserve(int n) { ... } to fit in with the usual Java convention of using int for container indexing and sizing. The original api for std::vector::reserve can be also be made available via %extend to add in an overloaded method as follows: %include %extend std::vector { void reserve(jlong n) throw (std::length_error, std::out_of_range) { if (n < 0) throw std::out_of_range("vector reserve size must be positive"); self->reserve(n); } } This change is partially driven by the need to seamlessly support the full 64-bit range for size_t generically, apart from the customisations for the STL containers, by using: %apply unsigned long long { size_t }; %apply const unsigned long long & { const size_t & }; *** POTENTIAL INCOMPATIBILITY *** 2023-10-05: wsfulton [C#] #2379 Defining SWIGWORDSIZE64 now applies the (unsigned) long long typemaps to (unsigned) long for a better match on systems where long is 64-bits. A new "Type mapping" section has been added into the CSharp.html documentation covering this and marshalling of primitive types. C (unsigned) long handling remains as is by default, that is, marshall as 32-bit. The INPUT[], OUTPUT[], INOUT[], FIXED[] typemaps for long and unsigned long in arrays_csharp.i can now be used and compiled on 64-bit platforms where sizeof(long) != sizeof(int). Requires SWIGWORDSIZE64 to be defined. 2023-09-27: wsfulton [Java] #646 #649 Defining SWIGWORDSIZE64 now applies the (unsigned) long long typemaps to (unsigned) long for a better match on systems where long is 64-bits. 2023-09-18: christophe-calmejane #2631 C++17 std::map fix for values that are not default constructible. Enhancements for all target languages except Python and Ruby. 2023-09-14: mmomtchev #2675 #2676 Temporary variable zero initialisation in the wrappers for consistency with handling pointers. 2023-09-11: emmenlau #2394 Add support to preprocessor for true and false. Note that this is for C++ not C. 2023-09-11: wsfulton [R] #2605 Complete transition to rtypecheck typemaps from hard coded logic. Also see entry dated 2022-10-28 for swig-4.1.1. The rtypecheck typemaps implement typechecking in R for each function parameter using functions such as is.numeric, is.character, is.logical, is.null etc. 2023-09-09: wsfulton https://sourceforge.net/p/swig/bugs/919/ Fix incorrect variable setters being generated when wrapping arrays. A setter is no longer generated if the type of the array members are non-assignable. 2023-09-09: wsfulton Non-assignable detection fixes when wrapping const member variables. Const member variables such as the following are non-assignable by by default: char * const x; const int x; const int x[1]; but not: const char * x; Variable setters are not generated when wrapping these non-assignable variables and classes containing such non-assignable variables. 2023-09-07: wsfulton Non-assignable detection fixes when wrapping rvalue reference variables. Rvalue reference variables such as the following are non-assignable by by default: X &&v; Variable setters are not generated when wrapping these non-assignable variables and classes containing such non-assignable variables. 2023-09-06: wsfulton Non-assignable detection fixes when wrapping reference variables. Reference variables such as the following are non-assignable by by default: int &v; Variable setters are not generated when wrapping these non-assignable variables and classes containing such non-assignable variables. 2023-09-06: wsfulton Assignment operator detection fixes when wrapping static member variables. 2023-09-06: wsfulton #1416 Implicit assignment operator detection fixes. A class that does not have an explicit assignment operator does not have an implicit assignment operator if a member variable is not assignable. Similarly should one of the base classes also not be assignable. Detection of these scenarios has been fixed so that when wrapping a variable that is not assignable, a variable setter is not generated in order to avoid a compiler error. Template instantiation via %template is required in order for this to work for templates that are not assignable. 2023-09-03: wsfulton https://sourceforge.net/p/swig/bugs/1006/ Fix incorrect variable setters being generated when the type of the variable is not assignable, due to variable type inheriting a private assignment operator further up the inheritance chain (further up than the immediate base). 2023-09-03: wsfulton [Guile, Ocaml, Perl] Don't attempt to generate a setter when wrapping variables which have a private assignment operator as assignment is not possible. This now matches the behaviour of all the other target languages. 2023-09-02: wsfulton Fix problems wrapping deleted destructors. Derived classes are not constructible, so don't attempt to generate default constructor or copy constructor wrappers. struct StackOnly1 { // Only constructible on the stack ~StackOnly1() = delete; }; struct StackOnlyDerived1 : StackOnly1 { // this class is not constructible due to deleted base destructor }; 2023-09-02: wsfulton Fix %copyctor feature when used on classes with deleted copy constructors. A default constructor wrapper was sometimes incorrectly generated. 2023-09-02: wsfulton #1644 Fix wrapping types passed by value where the type has a deleted default constructor. 2023-08-16: shadchin [Python] #2665 Fix missing-field-initializers warning to provide support for python-3.12. 2023-08-09: olly [Ruby] Remove -feature command line option which has been deprecated since SWIG 1.3.32 in 2007. Use -initname instead. 2023-08-06: wsfulton Add support for using declarations to introduce templated member methods and for inheriting templated constructors, such as: struct Base { // templated constructor template Base(const T &t, const char *s) {} // templated member method template void template_method(const T &t, const char *s) {} }; %template(Base) Base::Base; %template(template_method) Base::template_method; struct Derived : Base { using Base::Base; using Base::template_method; }; Previously the templated methods and constructors were ignored and not introduced into the Derived class. 2023-08-04: wsfulton Fix using declarations for inheritance hierarchies more than two deep and the using declarations are overloaded. Using declarations from a base class' base were not available for use in the target language. For example in the code below, Using1::usingmethod(int i) was not wrapped for use in Using3: struct Using1 { protected: void usingmethod(int i) {} }; struct Using2 : Using1 { protected: void usingmethod(int i, int j) {} using Using1::usingmethod; }; struct Using3 : Using2 { void usingmethod(int i, int j, int k) {} using Using2::usingmethod; }; Similarly for C++11 using declarations for inheriting constructors. 2023-08-02: wsfulton https://sourceforge.net/p/swig/bugs/932/ Fix missing constructor generation due to abstract class test failure when a method is declared in the class along with a using declaration and the using declaration is declared before the method that implemented the pure virtual method, such as: struct ConcreteDerived : AbstractBase { ConcreteDerived() {} // was not wrapped using AbstractBase::f; virtual void f(int n) override {} }; 2023-08-02: olly [PHP] Implement overloading between different integer types and between double and float. 2023-07-29: wsfulton https://sourceforge.net/p/swig/bugs/678/ Fix %copyctor used on class hierarchies with non-const copy constructors. Previously SWIG always attempted to call a copy constructor taking a const reference parameter instead of a non-const reference parameter. 2023-07-28: wsfulton #2541 Fix overloading of templated constructors and %copyctor. 2023-07-21: wsfulton Don't generate a default constructor wrapper when a class has a templated constructor, as there isn't actually an implied default constructor. For example: struct TConstructor3 { template TConstructor3(T val) {} }; Previously wrappers were generated for a non-existent default constructor which failed to compile. 2023-07-15: wsfulton C++11 using declarations for inheriting constructors has now been extended to support the directors feature. 2023-07-13: wsfulton C++11 using declarations for inheriting constructors support now also includes inheriting implicitly defined default constructors from the base class. 2023-07-04: wsfulton #2641 Add support for C++11 using declarations for inheriting constructors. 2023-06-30: wsfulton #2640 Fix syntax error parsing an expression which calls a function with no parameters within additional brackets. 2023-06-27: mmomtchev [Javascript] #2545 New Javascript generator targeting the Node.js binary stable ABI Node-API. 2023-06-27: olly [Java] Completely remove pragmas which were deprecated in 2002 and have triggered an error since SWIG 2.0: moduleimport Use the moduleimports pragma moduleinterface Use the moduleinterfaces pragma modulemethodmodifiers Use %javamethodmodifiers allshadowimport Use %typemap(javaimports) allshadowcode Use %typemap(javacode) allshadowbase Use %typemap(javabase) allshadowinterface Use %typemap(javainterfaces) allshadowclassmodifiers Use %typemap(javaclassmodifiers) shadowcode Use %typemap(javacode) shadowimport Use %typemap(javaimports) shadowbase Use %typemap(javabase) shadowinterface Use %typemap(javainterfaces) shadowclassmodifiers Use %typemap(javaclassmodifiers) 2023-06-24: wsfulton #2616 https://sourceforge.net/p/swig/bugs/1102/ Fix directors and allprotected mode and using declarations. Previously SWIG either seg faulted or generated code that did not compile. 2023-06-20: olly #2486 Fix handling of template in array size, which was being rejected by SWIG because the type string contains '<' not followed by '('. Drop this check as it should be unnecessary now since the fixes that ensure that template parameters are enclosed within '<(' and ')>'. 2023-06-16: olly [Java] Remove deprecated command line options which have done nothing except emit a deprecation message since 2002 or before: -jnic / -jnicpp JNI calling convention now automatic. -nofinalize Use javafinalize typemap instead. -proxy / -shadow Now on by default. 2023-06-16: olly [Guile] Drop support for -Linkage ltdlmod which was only useful for Guile <= 1.4 which we no longer support. 2023-06-15: olly [Guile] The -gh and -scm command line options have been removed. These have done nothing except emit a message since 2013 when SWIG dropped support for generating bindings which used GH. 2023-06-15: olly Remove pointer.i from the SWIG library. It's been a dummy file which has done nothing except %echo a deprecation message since 2002. The replacement is cpointer.i. 2023-06-15: olly SWIG will no longer fall back to using the include path to find the input file, which has been deprecated and emitted a warning since SWIG 1.3.37 (2009-01-13). This makes the behaviour of SWIG the same as C/C++ compilers and works with ccache. 2023-06-15: olly Remove features deprecated in SWIG 1.x and 2.x. Most of these have emitted a deprecation warning or error for well over a decade and have replacements with fewer shortcomings so we expect users will have migrated away from them long ago, but in case you need them replacements are noted below: %addmethods Use %extend instead. %attribute_ref Use %attributeref instead (NB: If called with 4 parameters, the 3rd and 4th need switching). %disabledoc Use Doxygen support instead. %doconly Use Doxygen support instead. %enabledoc Use Doxygen support instead. %except Use %exception instead. %extern Use %import instead. %localstyle Use Doxygen support instead. %name Use %rename instead. %new Use %newobject instead. %out %apply OUTPUT typemap rule instead. %readonly Use %immutable instead. %readwrite Use %mutable instead. %section Use Doxygen support instead. %style Use Doxygen support instead. %subsection Use Doxygen support instead. %subsubsection Use Doxygen support instead. %text Use Doxygen support instead. %title Use Doxygen support instead. %typemap(except) Use %exception instead. %typemap(ignore) Use %typemap(in,numinputs=0) instead. %val Use typemaps instead. -debug_template Use -debug-template instead. -debug_typemap Use -debug-typemap instead. -dump_classes Use -debug-classes instead. -dump_memory Use -debug-memory instead. -dump_module Use -debug-module 4 instead. -dump_parse_module Use -debug-module 1 instead. -dump_parse_top Use -debug-top 1 instead. -dump_tags Use -debug-tags instead. -dump_top Use -debug-top 4 instead. -dump_tree Use -debug-top 4 instead. -dump_typedef Use -debug-typedef instead. -dump_xml Use -xmlout /dev/stdout instead. -make_default On by default since SWIG 1.3.7 (2001-09-03). -makedefault On by default since SWIG 1.3.7 (2001-09-03). -no_default Use %nodefaultctor/%nodedefaultdtor instead. -nodefault Use %nodefaultctor/%nodedefaultdtor instead. -noextern option On by default since SWIG 1.3.26 (2005-10-09). -noruntime Type sharing happens via target lang global. -runtime Type sharing happens via target lang global. -show_templates Use -debug-template instead. -tm_debug Use -debug-typemap instead. -xml out.xml Use -xml -o out.xml instead. BOTH typemap rule Use INOUT typemap rule instead. SWIG_INTRUSIVE_PTR(PROXYCLASS, TYPE) Use %intrusive_ptr(TYPE) instead. SWIG_INTRUSIVE_PTR_DERIVED(PROXYCLASS, BASECLASSTYPE, TYPE) Use %intrusive_ptr(TYPE) instead. SWIG_INTRUSIVE_PTR_NO_WRAP(PROXYCLASS, TYPE) Use %intrusive_ptr_no_wrap(TYPE) instead. SWIG_INTRUSIVE_PTR_DERIVED_NO_WRAP(PROXYCLASS, BASECLASSTYPE, TYPE) Use %intrusive_ptr_no_wrap(TYPE) instead. SWIG_SHARED_PTR(PROXYCLASS, TYPE) Use %shared_ptr(TYPE) instead. SWIG_SHARED_PTR_DERIVED(PROXYCLASS, BASECLASSTYPE, TYPE...) Use %shared_ptr(TYPE) instead. SWIG_STD_VECTOR_SPECIALIZE(CSTYPE, CTYPE) Use SWIG_STD_VECTOR_ENHANCED(CTYPE) instead. SWIG_STD_VECTOR_SPECIALIZE_MINIMUM(CSTYPE, CTYPE) No longer required - remove uses. specialize_std_map_on_both No longer required - remove uses. specialize_std_map_on_key No longer required - remove uses. specialize_std_map_on_value No longer required - remove uses. 2023-06-15: olly [Guile] Fix freearg typemaps to go with char **INOUT and char *INOUT in typemaps. Previously the char **INOUT typemap would leak memory if must_free$argnum was true, and the char *INOUT typemap would generate code that didn't compile. 2023-06-07: olly #2630 Fix preprocessor handling of a slash immediately followed by a single quote, which wasn't getting recognised as starting a character literal. 2023-06-07: olly #2630 Fix parsing of <= and >= in templated lambda. Skipping between matching delimiters is now done at the token level rather than the character level. 2023-06-02: mmomtchev [Javascript] #2622 Fix support for %typemap(default) and improve support for default arguments in general. 2023-06-01: olly [Perl] #2470 Fix some integer truncation warnings in generated wrappers. 2023-05-30: olly [Lua] Fix bug when passing a Lua number to a C++ function expected std::string. Order of evaluation of C++ function arguments is not defined, and if lua_rawlen() was called before lua_tostring() then it would return 0 (because the value was still a number) and an empty string would be passed. 2023-05-30: mmomtchev [Javascript] #2618 Fix handling of C++ pointer to member function. 2023-05-25: olly #1032 Allow typename disambiguator in: using typename NodeT::links_type; 2023-05-25: olly SWIG now discriminates between long double, double and float constants. For example, this means that for target languages which support a separate float type (such as C# and D) this will now create a float constant instead of a double constant in the target language: #define PI_ISH 3.1414f 2023-05-25: olly C++11 `auto` variables and `decltype()` can now deduce the type of some expressions which involve literals of built-in types. 2023-05-25: olly #1125 Support parsing C++11 auto variables. This uses the existing type deduction code from decltype so has the same limitations, and such variables will only actually be wrapped when SWIG can deduce the type. 2023-05-23: olly [Ruby] Fix deprecation warnings about ANYARGS when compiling C++ code for SWIG-generated Ruby wrappers with Ruby 3.x. This is a recurrence of a problem fixed in 4.0.2. Our fix was conditional on RB_METHOD_DEFINITION_DECL being defined, but Ruby 3.0 stopped defining this. 2023-05-23: olly #2606 Improve error output when SWIG reaches EOF while looking for a closing delimiter. This is reported with an error like: Error: Missing '}'. Reached end of input. We now exit after reporting this and so no longer report a second more generic error like: Error: Syntax error in input(1). 2023-05-22: mmomtchev [Javascript] #2600 Improve test coverage by adding _runme.js files for 22 test cases. 2023-05-20: erezgeva [C#, D, Java, Javascript, Guile, Scilab] #2552 Implement argcargv.i library multi-argument typemaps. 2023-05-20: erezgeva [D] #56 #2538 #2570 The generated code now works with recent D releases: adds override keyword on overridden methods. Support is now working using DMD, gcc D and LLVM D compilers. 2023-05-20: olly Support deducing the type for decltype(false) and decltype(true). 2023-05-19: olly #2446 Add support for auto without trailing return type, which is a C++14 feature. 2023-05-19: olly SWIG no longer defines preprocessor symbols corresponding to command line options (e.g. `-module blah` was resulting in `SWIGOPT_MODULE` being set to `blah`). This feature was added in 2001 so that "[m]odules can look for these symbols to alter their code generation if needed", but it's never been used for that purpose in over 20 years, and has never been documented outside of CHANGES. 2023-05-18: olly #2591 Add new -U command line option to undefine a preprocessor symbol. 2023-05-18: olly #1589 #2335 Support parsing arbitrary expression in decltype. Use parser error recovery to skip to the closing matching `)` and issue a warning that we can't deduce the decltype for the expression (like we already do for any expression which isn't a simple variable or similar). 2023-05-12: mmomtchev, erezgeva [Javascript] #2561 Support check typemaps for Javascript. 2023-05-12: olly [Java] #2556 Suppress Java removal warnings on finalize method. SWIG will need to stop relying on finalize methods, but we know that and meanwhile these warnings make the testsuite output very noisy. 2023-05-11: olly #302 #2079 #2474 Parse storage class more flexibly. Previously we had a hard-coded list of allowed combinations in the grammar, but this suffers from combinatorial explosion, and results in a vague `Syntax error in input` error for invalid (and missing) combinations. This means we now support a number of cases which are valid C++ but weren't supported, including `friend constexpr` and `virtual explicit`. 2023-05-08: olly #1567 Add support for std::string_view (new in C++17) for C#, Java, Lua, Perl, PHP, Python, Ruby and Tcl. 2023-05-08: olly [PHP] #2544 Wrap overloaded method with both static and non-static forms. We now wrap this as a non-static method in PHP, which means the static form is only callable via an object. Previously this case could end up wrapped as static or non-static in PHP. If it was wrapped as static, attempting to call non-static overloaded forms would crash with a segmentation fault. 2023-05-06: mmomtchev, wsfulton #2550 Fix typedef/using declarations to a typedef struct/class. 2023-05-04: erezgeva [D] #2538 Drop support for D1/Tango, which was discontinued in 2012. Wrappers for D2/Phobos are now generated by default, though the -d2 command line option is still accepted (and now ignored) for backward compatibility. *** POTENTIAL INCOMPATIBILITY *** 2023-04-27: olly #2502 Allow using snprintf() instead of sprintf() in wrappers. We aim to produce code that works with C90 or C++98 so we can't assume snprintf() is available, but it almost always is (even on systems from before it was standardised) so having a way to use it is helpful. We enable this automatically if the compiler claims conformance with at least C99 or C++11. It can also be enabled manually by defining SWIG_HAVE_SNPRINTF. Define SWIG_NO_SNPRINTF to disable completely. The fallback is to call sprintf() without a buffer size check, which is what we've done until now. Adding a check after the call seems of limited benefit - if the buffer was overflowed then it's too late to block it, and most of our uses either have a fixed maximum possible size or dynamically allocate a buffer that's large enough. 2023-04-26: mmomtchev [Javascript] Take into account numinputs when counting arguments. 2023-04-24: olly [PHP] Add throws typemaps for std:string* and const std::string*. 2023-04-23: olly [Javascript] #2453 The testsuite and examples now select which Javascript engine to test based on what was detected by configure. Previously they'd always test with node you specified a different engine (e.g. with `ENGINE=jsc` on the make command line). Now you only need to specify ENGINE if you have more than one engine installed. 2023-04-23: olly [Javascript] Turn on C++ output when wrapping for node, like we already do when wrapping for V8-without-node. The testsuite was masking this bug by using SWIG options `-v8 -DBUILDING_NODE_EXTENSION=1` rather than `-node` when testing with nodejs, while the javascript examples were masking this by all getting processed with -c++. This shouldn't be an incompatible change for users, as if you're wrapping a C API you'd have to be working around the problem before this change (like our testsuite and examples were), and this change shouldn't break your workaround - it just makes it unnecessary. 2023-04-21: mmomtchev [Javascript] Fix naming of internal C++ helper for wrapping variables for node to use the "getter" naming scheme rather than the function wrapping one. In practice this didn't actually cause problems because Node wrappers are always compiled as C++ and the parameters are always different even if the names are the same. 2023-04-21: olly [PHP] Support INPUT,INOUT,OUTPUT for std::string&. By default SWIG/PHP wraps std::string& as a pass-by-reference PHP string parameter, but sometimes such a parameter is only for input or only for output, so add support for the named typemaps that other target languages support. 2023-04-21: degasus #2519 Fix CanCastAsInteger range check to clear errno first to fix bogus failures for valid inputs.if errno is set. 2023-04-21: ZackerySpytz [OCaml] #1439 Fix reference typemaps for std::string 2023-04-21: olly #2183 Fix #ifdef and #ifndef to work inside a %define. Previously they were silently ignored in this context (but #if defined already worked here if you need a workaround which works for older versions). 2023-04-20: erezgeva [Go] #2533 Implement argcargv.i library for Go. 2023-04-19: davidcl [Scilab] Add support for Scilab 2023.x. Introduce a new `-gatewayxml6` option to generate XML with full function names. 2023-04-19: mmomtchev https://sourceforge.net/p/swig/bugs/1163/ #1882 #2525 Fix preprocessor expansion when a macro expands to the name of another macro which takes parameters from the input following the original macro expansion. 2023-04-19: wildmaples [Ruby] #2527 Fix "undefining the allocator of T_DATA" warning seen with Ruby 3.2. 2023-04-18: davidcl [Scilab] #894 extract values with ":" for typemap (int* IN, int IN_SIZE) 2023-04-14: olly [PHP7] Support for PHP7 has been removed. PHP7 security support ended 2022-11-28 so it doesn't make sense to include support for it in the SWIG 4.2.x release series. *** POTENTIAL INCOMPATIBILITY *** 2023-04-05: wsfulton [Python] #2515 Add support for all STL containers to be constructible from a Python set. The previous implementation used the Python Sequence Protocol to convert from Python types to STL containers. The new implementation uses the Python Iterator Protocol instead and thereby can convert from a Python set too. 2023-03-25: alatina [Octave] #2512 Add support for Octave 8.1. 2023-03-22: wsfulton [C#] #2478 Minor enhancements to std::array wrappers in std_array.i. 2023-03-13: wsfulton Improved error checking when using %template to instantiate templates within the correct scope. 1. When a template is instantiated via %template and uses the unary scope operator ::, an error occurs if the instantiation is attempted within a namespace that does not enclose the instantiated template. For example, the following will now error as ::test::max is not enclosed within test1: Error: '::test::max' resolves to 'test::max' and was incorrectly instantiated in scope 'test1' instead of within scope 'test'. namespace test1 { %template(maxchar) ::test::max; } 2. SWIG previously failed to always detect a template did not exist when using %template. In particular when instantiating a global template incorrectly within namespace. The code below now correctly emits an error: Error: Template 'test5::GlobalVector' undefined. namespace test5 { } template struct GlobalVector {}; %template(GVI) test5::GlobalVector; 2023-03-13: wsfulton Error out if an attempt is made to define a class using the unary scope operator ::. The following is not legal C++ and now results in an error: Error: Using the unary scope operator :: in class definition '::Space2::B' is invalid. namespace Space2 { struct B; } struct ::Space2::B {}; 2023-03-08: wsfulton Fix duplicate const in generated code when template instantiation type is const and use of template parameter is also explicitly const, such as: template struct Conster { void cccc1(T const& t) {} }; %template(ConsterInt) Conster; Above previously led to generated code: (arg1)->cccc1((int const const &)*arg2); instead of (arg1)->cccc1((int const &)*arg2); 2023-03-01: wsfulton Partial template specialization fixes to support default arguments from the primary template's parameter list. template struct X { void primary() {} }; // Previously the specialization below resulted in: // Error: Inconsistent argument count in template partial specialization. 1 2 template struct X { void special(YY*) {} }; // Both of these correctly wrap the partially specialized template %template(StringPtr) X; %template(ShortPtr) X; 2023-02-15: wsfulton #1300 Further partial template specialization fixes. Fixes when templates are used as a template parameter in a partially specialized instantiation such as: template struct Vect {}; template class Foo { ... }; template class Foo, TTS> { ... }; %template(VectInt) Vect; %template(FooVectIntDouble) Foo, double>; // was previously attempting to use primary template Also fixes partial specialization where the same template parameter name is used twice, for example: template struct H { ... }; template struct H { ... }; %template(HInts) H; // was previously attempting to use primary template 2023-01-27: jschueller #2492 [python] Fix unused parameter warnings for self parameter in generated C/C++ wrapper code. 2023-01-14: wsfulton Fix deduction of partially specialized template parameters when the specialized parameter is non-trivial, used in a wrapped method and the type to %template uses typedefs. For example: typedef double & DoubleRef; template struct XX {}; template struct XX { void fn(T t) {} }; %template(XXD) XX; The type of the parameter in the instantiated template for fn is now correctly deduced as double. 2023-01-03: wsfulton #983 Fix seg fault when instantiating templates with parameters that are function parameters containing templates, such as: %template(MyC) C)>; 2023-01-03: wsfulton Complete support for C++11 variadic function templates. Support was previously limited to just one template parameter. Now zero or more template parameters are supported in the %template instantiation. 2022-12-29: wsfulton #1863 Syntax error fixes parsing more elaborate parameter pack arguments that are used in function pointers, member function pointers: template struct VariadicParms { void ParmsFuncPtrPtr(int (*)(V*...)) {} void ParmsFuncPtrPtrRef(int (*)(V*&...)) {} void ParmsFuncPtrPtrRValueRef(int (*)(V*&&...)) {} void ParmsFuncPtrRef(int (*)(V&...)) {} void ParmsFuncPtrRValueRef(int (*)(V&&...)) {} void ParmsMemFuncPtrPtr(int (KlassMemFuncs::*)(V*...)) {} void ParmsMemFuncPtrPtrRef(int (KlassMemFuncs::*)(V*&...)) {} void ParmsMemFuncPtrPtrRValueRef(int (KlassMemFuncs::*)(V*&&...)) {} void ParmsMemFuncPtrRef(int (KlassMemFuncs::*)(V&...)) {} void ParmsMemFuncPtrRValueRef(int (KlassMemFuncs::*)(V&&...)) {} }; %template(VariadicParms0) VariadicParms<>; %template(VariadicParms1) VariadicParms; Also in various other places such as within noexcept specifiers: template void emplace(Args &&... args) noexcept( std::is_nothrow_constructible::value); 2022-12-27: wsfulton Fix instantiation of variadic class templates containing parameter pack arguments that are function pointers. template struct VariadicParms { void ParmsFuncPtrVal(int (*)(V...)) {} }; %template(VariadicParms0) VariadicParms<>; %template(VariadicParms1) VariadicParms; 2022-12-23: wsfulton #1863 Fix syntax error parsing variadic templates containing parameter pack arguments that are function pointers. 2022-12-22: wsfulton Complete support for C++11 variadic class templates. Support was previously limited to just one template parameter. Now zero or more template parameters are supported. 2022-12-06: wsfulton #1636 Fix syntax error for misplaced Doxygen comment after struct/class member. Fix syntax error using Doxygen member groups syntax, "///*}", when used after final struct/class member. 2022-12-05: wsfulton #2023 Fix garbled Doxygen post comments in parameter lists. Fix syntax error parsing a trailing Doxygen comment in parameter lists. 2022-12-03: wsfulton #1609 Fix syntax error parsing of Doxygen comments after last enum item. 2022-12-03: wsfulton #1715 Fix syntax error parsing of unconventionally placed Doxygen post comments for enum items. 2022-12-02: wsfulton #624 #1021 Improved template template parameters support. Previously, specifying more than one simple template template parameter resulted in a parse error. Now multiple template template parameters are working including instantiation with %template. Example: template class, class> class Op, template class X, class Y> class C { ... }; 2022-11-26: wsfulton #1589 #1590 Slightly better decltype() support for expressions, such as: int i; ... decltype(&i) ... These result in a warning for non-trivial expressions which SWIG cannot evaluate: Warning 344: Unable to deduce decltype for '&i'. See 'Type Inference' in CPlusPlus.html for workarounds. 2022-11-22: wsfulton #366 #1037 Fix seg fault handling template parameter expressions containing '<=' or '>='. 2022-11-18: wsfulton Duplicate class template instantiations via %template now issue a warning and are ignored. %template(Aint) A; %template(Aint2) A; // Now ignored and issues a warning example.i:7: Warning 404: Duplicate template instantiation of 'A< int >' with name 'Aint2' ignored, example.i:6: Warning 404: previous instantiation of 'A< int >' with name 'Aint'. A single empty template instantiation before a named instantiation is the one exception for allowing duplicate template instantiations as the empty template instantiation does not create a wrapper for the template, it merely adds the instantiation into SWIG's internal type system. Duplicate empty template instantiations are quietly ignored. %template() B; %template(Bint) B; // OK %template() C; %template() C; // Quietly ignored now %template(Cint) C; // OK Note that default template parameters are considered when looking for duplicates such as: template struct D {}; %template(Dint) D; %template(Dintshort) D; example.i:7: Warning 404: Duplicate template instantiation of 'D< int,short >' with name 'Dintshort' ignored, example.i:6: Warning 404: previous instantiation of 'D< int >' with name 'Dint'. Note that the following always was ignored, but that was because the chosen name was a duplicate rather than the template being a duplicate: %template(Eint) E; %template(Eint) E; // Always has been ignored as a redefined identifier The old warning was: example.i:7: Warning 302: Identifier 'Eint' redefined (ignored) (Renamed from 'E< int >'), example.i:6: Warning 302: previous definition of 'Eint' (Renamed from 'E< int >'). *** POTENTIAL INCOMPATIBILITY *** This file contains a brief overview of the changes made in each release. A detailed description of changes are available in the CHANGES.current and CHANGES files. Release Notes ============= Detailed release notes are available with the release and are also published on the SWIG web site at https://swig.org/release.html. SWIG-4.2.0 summary: - Various template wrapping improvements: template template parameters, variadic templates, partially specialized templates, const template parameters and improved error checking instantiating templates. - Improved decltype() support for expressions. - C++14 auto without trailing return type and C++11 auto variables. - Numerous C++ using declarations improvements. - Numerous fixes for constructors, destructors and assignment operators: implicit, default and deleted and related non-assignable variable wrappers. - STL: std::array and std::map improvements, std::string_view support added. - Various C preprocessor improvements. - Various issues fixed to do with architecture specific long type. - Various Doxygen improvements. - D1/Tango support removed. D2/Phobos is now the supported D version and SWIG now generates code which works with recent D2 releases. - New Javascript generator targeting Node.js binary stable ABI Node-API. - Octave 8.1 support added. - PHP7 support removed, PHP8 is now the supported PHP version. - Python STL container wrappers now use the Python Iterator Protocol. - Python stable ABI support added. - Python 3.12 support added. - Ruby 3.2 and 3.3 support. - Scilab 2023.* support added. - Various minor enhancements for C#, Go, Guile, Javascript, Lua, Ocaml, Perl, PHP, R, Racket, Ruby, Scilab and Tcl. - A number of deprecated features have been removed. SWIG-4.1.1 summary: - Couple of stability fixes. - Stability fix in ccache-swig when calculating hashes of inputs. - Some template handling improvements. - R - minor fixes plus deprecation for rtypecheck typemaps being optional. SWIG-4.1.0 summary: - Add Javascript Node v12-v18 support, remove support prior to v6. - Octave 6.0 to 6.4 support added. - Add PHP 8 support. - PHP wrapping is now done entirely via PHP's C API - no more .php wrapper. - Perl 5.8.0 is now the oldest version SWIG supports. - Python 3.3 is now the oldest Python 3 version SWIG supports. - Python 3.9-3.11 support added. - Various memory leak fixes in Python generated code. - Scilab 5.5-6.1 support improved. - Many improvements for each and every target language. - Various preprocessor expression handling improvements. - Improved C99, C++11, C++14, C++17 support. Start adding C++20 standard. - Make SWIG much more move semantics friendly. - Add C++ std::unique_ptr support. - Few minor C++ template handling improvements. - Various C++ using declaration fixes. - Few fixes for handling Doxygen comments. - GitHub Actions is now used instead of Travis CI for continuous integration. - Add building SWIG using CMake as a secondary build system. - Update optional SWIG build dependency for regex support from PCRE to PCRE2. SWIG-4.0.2 summary: - A few fixes around doxygen comment handling. - Ruby 2.7 support added. - Various minor improvements to C#, D, Java, OCaml, Octave, Python, R, Ruby. - Considerable performance improvement running SWIG on large interface files. SWIG-4.0.1 summary: - SWIG now cleans up on error by removing all generated files. - Add Python 3.8 support. - Python Sphinx compatibility added for Doxygen comments. - Some minor regressions introduced in 4.0.0 were fixed. - Fix some C++17 compatibility problems in Python and Ruby generated code. - Minor improvements/fixes for C#, Java, Javascript, Lua, MzScheme, Ocaml, Octave and Python. SWIG-4.0.0 summary: - Support for Doxygen documentation comments which are parsed and converted into JavaDoc or PyDoc comments. - STL wrappers improved for C#, Java and Ruby. - C++11 STL containers added for Java, Python and Ruby. - Improved support for parsing C++11 and C++14 code. - Various fixes for shared_ptr. - Various C preprocessor corner case fixes. - Corner case fixes for member function pointers. - Python module overhaul by simplifying the generated code and turning most optimizations on by default. - %template improvements wrt scoping to align with C++ explicit template instantiations. - Added support for a command-line options file (sometimes called a response file). - Numerous enhancements and fixes for all supported target languages. - SWIG now classifies the status of target languages into either 'Experimental' or 'Supported' to indicate the expected maturity level. - Support for CFFI, Allegrocl, Chicken, CLISP, S-EXP, UFFI, Pike, Modula3 has been removed. - Octave 4.4-5.1 support added. - PHP5 support removed, PHP7 is now the supported PHP version. - Minimum Python version required is now 2.7, 3.2-3.7 are the only other versions supported. - Added support for Javascript NodeJS versions 2-10. - OCaml support is much improved and updated, minimum OCaml version required is now 3.12.0. SWIG-3.0.12 summary: - Add support for Octave-4.2. - Enhance %extend to support template functions. - Language specific enhancements and fixes for C#, D, Guile, Java, PHP7. SWIG-3.0.11 summary: - PHP 7 support added. - C++11 alias templates and type aliasing support added. - Minor fixes and enhancements for C# Go Guile Java Javascript Octave PHP Python R Ruby Scilab XML. SWIG-3.0.10 summary: - Regression fixes for smart pointers and importing Python modules. SWIG-3.0.9 summary: - Add support for Python's implicit namespace packages. - Fixes to support Go 1.6. - C++11 std::array support added for Java. - Improved C++ multiple inheritance support for Java/C# wrappers. - Various other minor fixes and improvements for C#, D, Go, Java, Javascript, Lua, Python, R, Ruby, Scilab. SWIG-3.0.8 summary: - pdf documentation enhancements. - Various Python 3.5 issues fixed. - std::array support added for Ruby and Python. - shared_ptr support added for Ruby. - Minor improvements for CFFI, Go, Java, Perl, Python, Ruby. SWIG-3.0.7 summary: - Add support for Octave-4.0.0. - Remove potential Android security exploit in generated Java classes. - Minor new features and bug fixes. SWIG-3.0.6 summary: - Stability and regression fixes. - Fixed parsing of C++ corner cases. - Language improvements and bug fixes for C#, Go, Java, Lua, Python, R. SWIG-3.0.5 summary: - Added support for Scilab. - Important Python regression fix when wrapping C++ default arguments. - Minor improvements for C#, Go, Octave, PHP and Python. SWIG-3.0.4 summary: - Python regression fix when wrapping C++ default arguments. - Improved error messages. SWIG-3.0.3 summary: - Add support for C++11 strongly typed enumerations. - Numerous bug fixes and minor enhancements for C#, D, Go, Java, Javascript, PHP, Perl and Python wrappers. SWIG-3.0.2 summary: - Bug fix during install and a couple of other minor changes. SWIG-3.0.1 summary: - Javascript module added. This supports JavascriptCore (Safari/Webkit), v8 (Chromium) and node.js currently. - A few notable regressions introduced in 3.0.0 have been fixed - in Lua, nested classes and parsing of operator <<. - The usual round of bug fixes and minor improvements for: C#, GCJ, Go, Java, Lua, PHP and Python. SWIG-3.0.0 summary: - This is a major new release focusing primarily on C++ improvements. - C++11 support added. Please see documentation for details of supported features: https://www.swig.org/Doc3.0/CPlusPlus11.html - Nested class support added. This has been taken full advantage of in Java and C#. Other languages can use the nested classes, but require further work for a more natural integration into the target language. We urge folk knowledgeable in the other target languages to step forward and help with this effort. - Lua: improved metatables and support for %nspace. - Go 1.3 support added. - Python import improvements including relative imports. - Python 3.3 support completed. - Perl director support added. - C# .NET 2 support is now the minimum. Generated using statements are replaced by fully qualified names. - Bug fixes and improvements to the following languages: C#, Go, Guile, Java, Lua, Perl, PHP, Python, Octave, R, Ruby, Tcl - Various other bug fixes and improvements affecting all languages. - Note that this release contains some backwards incompatible changes in some languages. - Full detailed release notes are in the changes file. SWIG-2.0.12 summary: - This is a maintenance release backporting some fixes from the pending 3.0.0 release. - Octave 3.8 support added. - C++11 support for new versions of erase/insert in the STL containers. - Compilation fixes on some systems for the generated Lua, PHP, Python and R wrappers. SWIG-2.0.11 summary: - Minor bug fixes and enhancements mostly in Python, but also C#, Lua, Ocaml, Octave, Perl, PHP, Python, R, Ruby, Tcl. SWIG-2.0.10 summary: - Ruby 1.9 support is now complete. - Add support for Guile 2.0 and Guile 1.6 support (GH interface) has been dropped. - Various small language neutral improvements and fixes. - Various bug fixes and minor improvements specific to C#, CFFI, D, Java, Octave, PHP, Python, - Minor bug fix in ccache-swig. - Development has moved to Github with Travis continuous integration testing - patches using https://github.com/swig/swig are welcome. SWIG-2.0.9 summary: - Improved typemap matching. - Ruby 1.9 support is much improved. - Various bug fixes and minor improvements in C#, CFFI, Go, Java, Modula3, Octave, Perl, Python, R, Ruby, Tcl and in ccache-swig. SWIG-2.0.8 summary: - Fix a couple of regressions introduced in 2.0.5 and 2.0.7. - Improved using declarations and using directives support. - Minor fixes/enhancements for C#, Java, Octave, Perl and Python. SWIG-2.0.7 summary: - Important regression fixes since 2.0.5 for typemaps in general and in Python. - Fixes and enhancements for Go, Java, Octave and PHP. SWIG-2.0.6 summary: - Regression fix for Python STL wrappers on some systems. SWIG-2.0.5 summary: - Official Android support added including documentation and examples. - Improvements involving templates: 1) Various fixes with templates and typedef types. 2) Some template lookup problems fixed. 3) Templated type fixes to use correct typemaps. - Autodoc documentation generation improvements. - Python STL container wrappers improvements including addition of stepped slicing. - Approximately 70 fixes and minor enhancements for the following target languages: AllegroCL, C#, D, Go, Java, Lua, Ocaml, Octave, Perl, PHP, Python, R, Ruby, Tcl, Xml. SWIG-2.0.4 summary: - This is mainly a Python oriented release including support for Python built-in types for superior performance with the new -builtin option. The -builtin option is especially suitable for performance-critical libraries and applications that call wrapped methods repeatedly. See the python-specific chapter of the SWIG manual for more info. - Python 3.2 support has also been added and various Python bugs have been fixed. - Octave 3.4 support has also been added. - There are also the usual minor generic improvements, as well as bug fixes and enhancements for D, Guile, Lua, Octave, Perl and Tcl. SWIG-2.0.3 summary: - A bug fix release including a couple of fixes for regressions in the 2.0 series. SWIG-2.0.2 summary: - Support for the D language has been added. - Various bug fixes and minor enhancements. - Bug fixes particular to the Clisp, C#, Go, MzScheme, Ocaml, PHP, R, Ruby target languages. SWIG-2.0.1 summary: - Support for the Go language has been added. - New regular expression (regex) encoder for renaming symbols based on the Perl Compatible Regular Expressions (PCRE) library. - Numerous fixes in reporting file and line numbers in error and warning messages. - Various bug fixes and improvements in the C#, Lua, Perl, PHP, Ruby and Python language modules. SWIG-2.0.0 summary: - License changes, see LICENSE file and https://www.swig.org/legal.html. - Much better nested class/struct support. - Much improved template partial specialization and explicit specialization handling. - Namespace support improved with the 'nspace' feature where namespaces can be automatically translated into Java packages or C# namespaces. - Improved typemap and symbol table debugging. - Numerous subtle typemap matching rule changes when using the default (SWIGTYPE) type. These now work much like C++ class template partial specialization matching. - Other small enhancements for typemaps. Typemap fragments are also now official and documented. - Warning and error display refinements. - Wrapping of shared_ptr is improved and documented now. - Numerous C++ unary scope operator (::) fixes. - Better support for boolean expressions. - Various bug fixes and improvements in the Allegrocl, C#, Java, Lua, Octave, PHP, Python, R, Ruby and XML modules. SWIG-1.3.40 summary: - SWIG now supports directors for PHP. - PHP support improved in general. - Octave 3.2 support added. - Various bug fixes/enhancements for Allegrocl, C#, Java, Octave, Perl, Python, Ruby and Tcl. - Other generic fixes and minor new features. SWIG-1.3.39 summary: - Some new small feature enhancements. - Improved C# std::vector wrappers. - Bug fixes: mainly Python, but also Perl, MzScheme, CFFI, Allegrocl and Ruby SWIG-1.3.38 summary: - Output directory regression fix and other minor bug fixes SWIG-1.3.37 summary: - Python 3 support added - SWIG now ships with a version of ccache that can be used with SWIG. This enables the files generated by SWIG to be cached so that repeated use of SWIG on unchanged input files speeds up builds quite considerably. - PHP 4 support removed and PHP support improved in general - Improved C# array support - Numerous Allegro CL improvements - Bug fixes/enhancements for Python, PHP, Java, C#, Chicken, Allegro CL, CFFI, Ruby, Tcl, Perl, R, Lua. - Other minor generic bug fixes and enhancements SWIG-1.3.36 summary: - Enhancement to directors to wrap all protected members - Optimisation feature for objects returned by value - A few bugs fixes in the PHP, Java, Ruby, R, C#, Python, Lua and Perl modules - Other minor generic bug fixes SWIG-1.3.35 summary: - Octave language module added - Bug fixes in Python, Lua, Java, C#, Perl modules - A few other generic bugs and runtime assertions fixed SWIG-1.3.34 summary: - shared_ptr support for Python - Support for latest R - version 2.6 - Various minor improvements/bug fixes for R, Lua, Python, Java, C# - A few other generic bug fixes, mainly for templates and using statements SWIG-1.3.33 summary: - Fix regression for Perl where C++ wrappers would not compile - Fix regression parsing macros SWIG-1.3.32 summary: - shared_ptr support for Java and C# - Enhanced STL support for Ruby - Windows support for R - Fixed long-standing memory leak in PHP Module - Numerous fixes and minor enhancements for Allegrocl, C#, cffi, Chicken, Guile, Java, Lua, Ocaml, Perl, PHP, Python, Ruby, Tcl. - Improved warning support SWIG-1.3.31 summary: - Python modern classes regression fix SWIG-1.3.30 summary: - Python-2.5 support - New language module: R - Director support added for C# - Numerous director fixes and improvements - Improved mingw/msys support - Better constants support in Guile and chicken modules - Support for generating PHP5 class wrappers - Important Java premature garbage collection fix - Minor improvements/fixes in cffi, php, allegrocl, perl, chicken, lua, ruby, ocaml, python, java, c# and guile language modules - Many many other bug fixes SWIG-1.3.29 summary: - Numerous important bug fixes - Few minor new features - Some performance improvements in generated code for Python SWIG-1.3.28 summary: - More powerful renaming (%rename) capability. - More user friendly warning handling. - Add finer control for default constructors and destructors. We discourage the use of the 'nodefault' option, which disables both constructors and destructors, leading to possible memory leaks. Use instead 'nodefaultctor' and/or 'nodefaultdtor'. - Automatic copy constructor wrapper generation via the 'copyctor' option/feature. - Better handling of Windows extensions and types. - Better runtime error reporting. - Add the %catches directive to catch and dispatch exceptions. - Add the %naturalvar directive for more 'natural' variable wrapping. - Better default handling of std::string variables using the %naturalvar directive. - Add the %allowexcept and %exceptionvar directives to handle exceptions when accessing a variable. - Add the %delobject directive to mark methods that act like destructors. - Add the -fastdispatch option to enable smaller and faster overload dispatch mechanism. - Template support for %rename, %feature and %typemap improved. - Add/doc more debug options, such as -dump_module, -debug_typemaps, etc. - Unified typemap library (UTL) potentially providing core typemaps for all scripting languages based on the recently evolving Python typemaps. - New language module: Common Lisp with CFFI. - Python, Ruby, Perl and Tcl use the new UTL, many old reported and hidden errors with typemaps are now fixed. - Initial Java support for languages using the UTL via GCJ, you can now use Java libraries in your favorite script language using gcj + swig. - Tcl support for std::wstring. - PHP4 module update, many error fixes and actively maintained again. - Allegrocl support for C++, also enhanced C support. - Ruby support for bang methods. - Ruby support for user classes as native exceptions. - Perl improved dispatching in overloaded functions via the new cast and rank mechanism. - Perl improved backward compatibility, 5.004 and later tested and working. - Python improved backward compatibility, 1.5.2 and later tested and working. - Python can use the same cast/rank mechanism via the -castmode option. - Python implicit conversion mechanism similar to C++, via the %implicitconv directive (replaces and improves the implicit.i library). - Python threading support added. - Python STL support improved, iterators are supported and STL containers can use now the native PyObject type. - Python many performance options and improvements, try the -O option to test all of them. Python runtime benchmarks show up to 20 times better performance compared to 1.3.27 and older versions. - Python support for 'multi-inheritance' on the python side. - Python simplified proxy classes, now swig doesn't need to generate the additional 'ClassPtr' classes. - Python extended support for smart pointers. - Python better support for static member variables. - Python backward compatibility improved, many projects that used to work only with swig-1.3.21 to swig-1.3.24 are working again with swig-1.3.28 - Python test-suite is now 'valgrinded' before release, and swig also reports memory leaks due to missing destructors. - Minor bug fixes and improvements to the Lua, Ruby, Java, C#, Python, Guile, Chicken, Tcl and Perl modules. SWIG-1.3.27 summary: - Fix bug in anonymous typedef structures which was leading to strange behaviour SWIG-1.3.26 summary: - New language modules: Lua, CLISP and Common Lisp with UFFI. - Big overhaul to the PHP module. - Change to the way 'extern' is handled. - Minor bug fixes specific to C#, Java, Modula3, Ocaml, Allegro CL, XML, Lisp s-expressions, Tcl, Ruby and Python modules. - Other minor improvements and bug fixes. SWIG-1.3.25 summary: - Improved runtime type system. Speed of module loading improved in modules with lots of types. SWIG_RUNTIME_VERSION has been increased from 1 to 2, but the API is exactly the same; only internal changes were made. - The languages that use the runtime type system now support external access to the runtime type system. - Various improvements with typemaps and template handling. - Fewer warnings in generated code. - Improved colour documentation. - Many C# module improvements (exception handling, prevention of early garbage collection, C# attributes support added, more flexible type marshalling/asymmetric types.) - Minor improvements and bug fixes specific to the C#, Java, TCL, Guile, Chicken, MzScheme, Perl, Php, Python, Ruby and Ocaml modules). - Various other bug fixes and memory leak fixes. SWIG-1.3.24 summary: - Improved enum handling - More runtime library options - More bugs fixes for templates and template default arguments, directors and other areas. - Better smart pointer support, including data members, static members and %extend. SWIG-1.3.23 summary: - Improved support for callbacks - Python docstring support and better error handling - C++ default argument support for Java and C# added. - Improved c++ default argument support for the scripting languages plus option to use original (compact) default arguments. - %feature and %ignore/%rename bug fixes and mods - they might need default arguments specified to maintain compatible behaviour when using the new default arguments wrapping. - Runtime library changes: Runtime code can now exist in more than one module and so need not be compiled into just one module - Further improved support for templates and namespaces - Overloaded templated function support added - More powerful default typemaps (mixed default typemaps) - Some important %extend and director code bug fixes - Guile now defaults to using SCM API. The old interface can be obtained by the -gh option. - Various minor improvements and bug fixes for C#, Chicken, Guile, Java, MzScheme, Perl, Python and Ruby - Improved dependencies generation for constructing Makefiles. SWIG-1.3.22 summary: - Improved exception handling and translation of C errors or C++ exceptions into target language exceptions. - Improved enum support, mapping to built-in Java 1.5 enums and C# enums or the typesafe enum pattern for these two languages. - Python - much better STL support and support for std::wstring, wchar_t and FILE *. - Initial support for Modula3 and Allegro CL. - 64 bit TCL support. - Java and C#'s proxy classes are now nearly 100% generated from typemaps and/or features for finer control on the generated code. - SWIG runtime library support deprecation. - Improved documentation. SWIG now additionally provides documentation in the form of a single HTML page as well as a pdf document. - Enhanced C++ friend declaration support. - Better support for reference counted classes. - Various %fragment improvements. - RPM fixes. - Various minor improvements and bug fixes for C#, Chicken, Guile, Java, MzScheme, Perl, Php, Python, Ruby and XML.