| 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-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-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 |
| #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 *** |
