1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
|
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-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, PHP 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.
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 ***
|