| 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 (in progress) |
| =========================== |
| |
| 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. |
| Currently int is not supported due to the parser misusing T_INT |
| for situations where the type isn't actually known. |
| |
| 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 |
| SWIG now defines __STDC__ to 1 to match the behaviour of ISO C/C++ |
| compilers, rather than to have an empty value. |
| |
| *** POTENTIAL INCOMPATIBILITY *** |
| |
| 2023-05-18: olly |
| #2591 The value of __cplusplus SWIG defines can now be overridden |
| on the command line, e.g. using -D__cplusplus=201103L which is |
| useful if you're wrapping headers which have preprocessor checks |
| based on its value. By default SWIG now defines __cplusplus to |
| 199711L (the value for C++98) rather than setting its value to |
| be __cplusplus. |
| |
| *** POTENTIAL INCOMPATIBILITY *** |
| |
| 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, 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 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 `-gatewayxml6` options to generate an 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<char>; |
| } |
| |
| 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<typename T> struct GlobalVector {}; |
| %template(GVI) test5::GlobalVector<int>; |
| |
| 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 <typename T> struct Conster { |
| void cccc1(T const& t) {} |
| }; |
| %template(ConsterInt) Conster<const int>; |
| |
| 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<class Y, class T=int> struct X { void primary() {} }; |
| // Previously the specialization below resulted in: |
| // Error: Inconsistent argument count in template partial specialization. 1 2 |
| template<class YY> struct X<YY*> { void special(YY*) {} }; |
| |
| // Both of these correctly wrap the partially specialized template |
| %template(StringPtr) X<const char *>; |
| %template(ShortPtr) X<short *, int>; |
| |
| 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<typename V> struct Vect {}; |
| template<class T, typename TT> class Foo { ... }; |
| template<class TS, typename TTS> class Foo<Vect<TS>, TTS> { ... }; |
| %template(VectInt) Vect<int>; |
| %template(FooVectIntDouble) Foo<Vect<int>, double>; // was previously attempting to use primary template |
| |
| Also fixes partial specialization where the same template parameter name is used twice, |
| for example: |
| |
| template<typename X, typename Y> struct H { ... }; |
| template<typename T> struct H<T, T> { ... }; |
| %template(HInts) H<int, int>; // 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 <typename T> struct XX {}; |
| template <typename T> struct XX<T &> { void fn(T t) {} }; |
| %template(XXD) XX<DoubleRef>; |
| |
| 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<int(std::vector<int>)>; |
| |
| 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 <typename... V> 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<A>; |
| |
| Also in various other places such as within noexcept specifiers: |
| |
| template<typename T, typename... Args> |
| void emplace(Args &&... args) noexcept( |
| std::is_nothrow_constructible<T, Args &&...>::value); |
| |
| 2022-12-27: wsfulton |
| Fix instantiation of variadic class templates containing parameter pack arguments that |
| are function pointers. |
| |
| template <typename... V> struct VariadicParms { |
| void ParmsFuncPtrVal(int (*)(V...)) {} |
| }; |
| |
| %template(VariadicParms0) VariadicParms<>; |
| %template(VariadicParms1) VariadicParms<A>; |
| |
| 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 <template<template<class> class, class> class Op, template<class> class X, class Y> |
| class C { ... }; |
| |
| 2022-11-26: wsfulton |
| #1589 #1590 Slightly better decltype() support for expressions, such as: |
| |
| int i,j; |
| ... decltype(i+j) ... |
| ... decltype(&i) ... |
| |
| These result in a warning for non-trivial expressions which SWIG cannot evaluate: |
| |
| Warning 344: Unable to deduce decltype for 'i+j'. |
| |
| 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<int>; |
| %template(Aint2) A<int>; // 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 instantation 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<int>; |
| %template(Bint) B<int>; // OK |
| |
| %template() C<int>; |
| %template() C<int>; // Quietly ignored now |
| %template(Cint) C<int>; // OK |
| |
| Note that default template parameters are considered when looking for duplicates such as: |
| |
| template <typename T, typename U = short> struct D {}; |
| %template(Dint) D<int>; |
| %template(Dintshort) D<int, short>; |
| |
| 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<int>; |
| %template(Eint) E<int>; // 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 *** |
