jyapayne/swig
Watch
1
0
Fork
You've already forked swig
 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Merge branch 'cpp11-ref-qualifiers'

Browse source 
* cpp11-ref-qualifiers:
  Warnings in testcases fix
  Add support for %typemap and member function pointers with qualifiers
  Fix wrapping of some member function pointer parameters
  Add support for member function pointers with ref-qualifiers
  Add error for constructors, destructors, static methods declared with qualifiers
  Add support for conversion operators with ref-qualifiers
  Alternate function syntax parsing improvement
  Re-organise parser grammar for initializer rules
  Re-organise parser grammar for declarator and initializer rules
  Add docs for C++11 ref-qualifiers
  Add unignore for rvalue ref-qualifiers
  Improve ref-qualifier implementation
  Fix support for member const function pointer variables
  Use normal SWIG encodings for ref-qualifiers
  C++11 ref-qualifier support added
This commit is contained in:
William S Fulton 2017-09-11 19:33:27 +01:00
commit 4d2d8dd80e
32 changed files with 1248 additions and 231 deletions
Download patch file Download diff file Expand all files Collapse all files

23
CHANGES.current
View file

@ -11,6 +11,29 @@ Version 4.0.0 (in progress)
[Python] Patch #1083. Define_DEBUG to 1 to do exactly like Visual Studio
/LDd, /MDd or /MTd compiler options.
2017-08-25: wsfulton
Issue #1059. Add support for C++11 ref-qualifiers on non-static member functions.
Members with lvalue ref-qualifiers such as:
struct RQ {
void m1(int x) &;
void m2(int x) const &;
};
are wrapped like any other member function. Member functions with rvalue ref-qualifiers
are ignored by default, such as:
struct RQ {
void m3(int x) &&;
void m4(int x) const &&;
};
example.i:7: Warning 405: Method with rvalue ref-qualifier m3(int) && ignored.
example.i:8: Warning 405: Method with rvalue ref-qualifier m4(int) const && ignored.
These can be unignored and exposed to the target language, see further documentation in
CPlusPlus11.html.
2017-08-16: wsfulton
Fix #1063. Add using declarations to templates into typedef table.

100
Doc/Manual/CPlusPlus11.html
View file

@ -42,6 +42,7 @@
<li><a href="#CPlusPlus11_noexcept">Exception specifications and noexcept</a>
<li><a href="#CPlusPlus11_alignment">Control and query object alignment</a>
<li><a href="#CPlusPlus11_attributes">Attributes</a>
<li><a href="#CPlusPlus11_ref_qualifiers">Methods with ref-qualifiers</a>
</ul>
<li><a href="#CPlusPlus11_standard_library_changes">Standard library changes</a>
<ul>
@ -971,6 +972,104 @@ int [[attr1]] i [[attr2, attr3]];
[[noreturn, nothrow]] void f [[noreturn]] ();
</pre></div>
<H3><a name="CPlusPlus11_ref_qualifiers">7.2.29 Methods with ref-qualifiers</a></H3>
<p>
C++11 non-static member functions can be declared with ref-qualifiers.
Member functions declared with a <tt>&amp;</tt> lvalue ref-qualifiers are wrapped like any other function without ref-qualifiers.
Member functions declared with a <tt>&amp;&amp;</tt> rvalue ref-qualifiers are ignored by default
as they are unlikely to be required from non-C++ languages where the concept of <i>rvalue-ness</i>
for the implied *this pointer does not apply.
The warning is hidden by default, but can be displayed as described in the section on <a href="Warnings.html#Warnings_nn4">Enabling extra warnings</a>.
</p>
<p>
Consider:
</p>
<div class="code"><pre>
struct RQ {
void m1(int x) &amp;;
void m2(int x) &amp;&amp;;
};
</pre></div>
<p>
The only wrapped method will be the lvalue ref-qualified method <tt>m1</tt>
and if SWIG is run with the <tt>-Wextra</tt> command-line option, the following warning will be issued indicating <tt>m2</tt> is not wrapped:
</p>
<div class="shell">
<pre>
example.i:7: Warning 405: Method with rvalue ref-qualifier m2(int) &amp;&amp; ignored.
</pre>
</div>
<p>
If you unignore the method as follows, wrappers for <tt>m2</tt> will be generated:
</p>
<div class="code"><pre>
%feature("ignore", "0") RQ::m2(int x) &amp;&amp;;
struct RQ {
void m1(int x) &amp;;
void m2(int x) &amp;&amp;;
};
</pre></div>
<p>
Inspection of the generated C++ code, will show that <tt>std::move</tt> is used on the instance
of the <tt>RQ *</tt> class:
</p>
<div class="code"><pre>
RQ *arg1 = (RQ *) 0 ;
int arg2 ;
arg1 = ...marshalled from target language...
arg2 = ...marshalled from target language...
std::move(*arg1).m2(arg2);
</pre></div>
<p>
This will compile but when run, the move effects may not be what you want.
As stated earlier, rvalue ref-qualifiers aren't really applicable outside the world of C++.
However, if you really know what you are doing, full control over the call to the method is
possible via the low-level "action" feature.
This feature completely replaces the call to the underlying function, that is, the last line in the snippet of code above.
</p>
<div class="code"><pre>
%feature("ignore", "0") RQ::m2(int x) &amp;&amp;;
%feature("action") RQ::m2(int x) &amp;&amp; %{
RQ().m2(arg2);
%}
struct RQ {
void m1(int x) &amp;;
void m2(int x) &amp;&amp;;
};
</pre></div>
<p>
resulting in:
</p>
<div class="code"><pre>
RQ *arg1 = (RQ *) 0 ;
int arg2 ;
arg1 = ...marshalled from target language...
arg2 = ...marshalled from target language...
RQ().m2(arg2);
</pre></div>
<p>
<b>Compatibility note:</b> SWIG-4.0.0 was the first version to support ref-qualifiers.
</p>
<H2><a name="CPlusPlus11_standard_library_changes">7.3 Standard library changes</a></H2>
@ -1177,5 +1276,6 @@ Phew, that is a lot of hard work to get a callback working.
You could just go with the more attractive option of just using <tt>double</tt> as the return type in the function declaration instead of <tt>result_of</tt>!
</p>
</body>
</html>

1
Doc/Manual/Contents.html
View file

@ -310,6 +310,7 @@
<li><a href="CPlusPlus11.html#CPlusPlus11_noexcept">Exception specifications and noexcept</a>
<li><a href="CPlusPlus11.html#CPlusPlus11_alignment">Control and query object alignment</a>
<li><a href="CPlusPlus11.html#CPlusPlus11_attributes">Attributes</a>
<li><a href="CPlusPlus11.html#CPlusPlus11_ref_qualifiers">Methods with ref-qualifiers</a>
</ul>
<li><a href="CPlusPlus11.html#CPlusPlus11_standard_library_changes">Standard library changes</a>
<ul>

28
Doc/Manual/SWIGPlus.html
View file

@ -2409,8 +2409,8 @@ the first renaming rule found on a depth-first traversal of the class hierarchy
is used.
</li>
<li><p>The name matching rules strictly follow member qualification rules.
For example, if you have a class like this:</p>
<li><p>The name matching rules strictly follow member qualifier rules.
For example, if you have a class and member with a member that is const qualified like this:</p>
<div class="code">
<pre>
@ -2434,7 +2434,7 @@ the declaration
</div>
<p>
will not apply as there is no unqualified member <tt>bar()</tt>. The following will apply as
will not apply as there is no unqualified member <tt>bar()</tt>. The following will apply the rename as
the qualifier matches correctly:
</p>
@ -2444,6 +2444,26 @@ the qualifier matches correctly:
</pre>
</div>
<p>
Similarly for combinations of cv-qualifiers and ref-qualifiers, all the qualifiers must be specified to match correctly:
</p>
<div class="code">
<pre>
%rename(name) Jam::bar(); // will not match
%rename(name) Jam::bar() &amp;; // will not match
%rename(name) Jam::bar() const; // will not match
%rename(name) Jam::bar() const &amp;; // ok, will match
class Jam {
public:
...
void bar() const &amp;;
...
};
</pre>
</div>
<p>
An often overlooked C++ feature is that classes can define two different overloaded members
that differ only in their qualifiers, like this:
@ -2476,7 +2496,7 @@ For example we can give them separate names in the target language:
<p>
Similarly, if you
merely wanted to ignore one of the declarations, use <tt>%ignore</tt>
with the full qualification. For example, the following directive
with the full qualifier. For example, the following directive
would tell SWIG to ignore the <tt>const</tt> version of <tt>bar()</tt>
above:
</p>

4
Doc/Manual/Typemaps.html
View file

@ -4021,7 +4021,7 @@ struct X {
Forced inclusion of fragments can be used as a replacement for <a href="SWIG.html#SWIG_nn42">code insertion block</a>, ensuring the
code block is only generated once.
Consider the contents of FileA.i below which first uses a code insertion block and then a forced fragment inclusion to generate code:
<p>
</p>
<div class="code">
<pre>
// FileA.i
@ -4058,7 +4058,7 @@ The resulting code in the wrappers for FileB.i is:
<p>
A note of caution must be mentioned when using <tt>%fragment</tt> forced inclusion or code insertion blocks with <tt>%import</tt>.
If <tt>%import</tt> is used instead:
<p>
</p>
<div class="code">
<pre>

3
Examples/test-suite/common.mk
View file

@ -561,6 +561,9 @@ CPP11_TEST_CASES += \
cpp11_noexcept \
cpp11_null_pointer_constant \
cpp11_raw_string_literals \
cpp11_ref_qualifiers \
cpp11_ref_qualifiers_rvalue_unignore \
cpp11_ref_qualifiers_typemaps \
cpp11_result_of \
cpp11_rvalue_reference \
cpp11_rvalue_reference2 \

226
Examples/test-suite/cpp11_ref_qualifiers.i Normal file
View file

@ -0,0 +1,226 @@
%module cpp11_ref_qualifiers
%warnfilter(SWIGWARN_TYPEMAP_SWIGTYPELEAK_MSG) ccextra2;
%warnfilter(SWIGWARN_TYPEMAP_SWIGTYPELEAK_MSG) ccextra3;
%warnfilter(SWIGWARN_TYPEMAP_SWIGTYPELEAK_MSG) cc2;
%warnfilter(SWIGWARN_TYPEMAP_SWIGTYPELEAK_MSG) cc3;
%warnfilter(SWIGWARN_TYPEMAP_SWIGTYPELEAK_MSG) cc5;
%include <std_string.i>
%ignore Host::h() const &;
// Basic testing
%inline %{
using std::string;
class Host {
string s;
public:
string h1() & { return string(); }
string h2() const & { return string(); }
string h3() && { return std::move(string()); }
string h4() const && { return std::move(string()); }
string h5() const { return string(); }
string h6() volatile const & { return string(); }
string h7() const volatile & { return string(); }
string h8() volatile const && { return std::move(string()); }
string h9() const volatile && { return std::move(string()); }
string h() & { return string(); }
string h() const & { return string(); }
string h() && { return std::move(string()); }
string h() const && { return std::move(string()); }
};
%}
// %feature testing
%feature("except") F1() & %{ result = "F1"; %}
%feature("except") F2 %{ result = "F2"; %}
%feature("except") F3 %{ result = "F3"; %}
%feature("except") F3() %{ _should_not_be_used_ %}
%feature("except") C1(int i) const & %{ result = "C1"; %}
%feature("except") C2 %{ result = "C2"; %}
%feature("except") C3 %{ result = "C3"; %}
%feature("except") C3(int i) %{ _should_not_be_used_ %}
%inline %{
struct Features {
string F1() & { return string(); }
string F2() & { return string(); }
string F3() & { return string(); }
string C1(int i) const & { return string(); }
string C2(int i) const & { return string(); }
string C3(int i) const & { return string(); }
};
%}
// %rename testing
%rename(RR1) R1;
%rename(RR2) R2() &;
%rename(RR3) R3;
%rename(RR3Bad) R3();
%rename(SS1) S1;
%rename(SS2) S2(int i) const &;
%rename(SS3) S3;
%rename(SS3Bad) S3(int i);
%rename(SS3BadConst) S3(int i) const;
%rename(SS3BadLValue) S3(int i) &;
%inline %{
struct Renames {
string R1() & { return string(); }
string R2() & { return string(); }
string R3() & { return string(); }
string S1(int i) const & { return string(); }
string S2(int i) const & { return string(); }
string S3(int i) const & { return string(); }
};
%}
// Conversion operators
%rename(StringConvertCopy) operator string() &;
%rename(StringConvertMove) operator string() &&;
%feature("ignore", "0") operator string() &&; // unignore as it is ignored by default
%inline %{
struct ConversionOperators {
virtual operator string() & { return string(); }
virtual operator string() && { return std::move(string()); }
virtual ~ConversionOperators() {}
};
struct ConversionOperators2 {
virtual operator string() && { return std::move(string()); }
virtual ~ConversionOperators2() {}
};
%}
%inline %{
struct Funcs {
short FF(bool) { return 0; }
short CC(bool) const & { return 0; }
};
class MemberFuncPtrs
{
public:
// member ref-qualified function pointers, unnamed parameters
int aaa1(short (Funcs::*)(bool) &) const;
int aaa2(short (Funcs::* const *&)(bool) &) const;
int aaa3(short (Funcs::* *&)(bool) &) const;
int aaa4(short (Funcs::* *const&)(bool) &) const;
int aaa5(short (Funcs::* &)(bool) &) const;
int aaa6(short (Funcs::* const)(bool) &) const;
int aaa7(short (Funcs::* const&)(bool) &) const;
int aaa8(short (Funcs::* const&)(bool) &&) const;
// member cv-qualified and ref-qualified function pointers, unnamed parameters
int bbb1(short (Funcs::*)(bool) const &) const;
int bbb2(short (Funcs::* const *&)(bool) const &) const;
int bbb3(short (Funcs::* *&)(bool) const &) const;
int bbb4(short (Funcs::* *const&)(bool) const &) const;
int bbb5(short (Funcs::* &)(bool) const &) const;
int bbb6(short (Funcs::* const)(bool) const &) const;
int bbb7(short (Funcs::* const&)(bool) const &) const;
int bbb8(short (Funcs::*)(bool) const &&) const;
// member ref-qualified function pointers, named parameters
int qqq1(short (Funcs::* qq1)(bool) &) const;
int qqq2(short (Funcs::* const *& qq2)(bool) &) const;
int qqq3(short (Funcs::* *& qq3)(bool) &) const;
int qqq4(short (Funcs::* *const& qq4)(bool) &) const;
int qqq5(short (Funcs::* & qq5)(bool) &) const;
int qqq6(short (Funcs::* const qq6)(bool) &) const;
int qqq7(short (Funcs::* const& qq7)(bool) &) const;
int qqq8(short (Funcs::* const& qq8)(bool) &&) const;
// member cv-qualified and ref-qualified function pointers, named parameters
int rrr1(short (Funcs::* rr1)(bool) const &) const;
int rrr2(short (Funcs::* const *& rr2)(bool) const &) const;
int rrr3(short (Funcs::* *& rr3)(bool) const &) const;
int rrr4(short (Funcs::* *const& rr4)(bool) const &) const;
int rrr5(short (Funcs::* & rr5)(bool) const &) const;
int rrr6(short (Funcs::* const rr6)(bool) const &) const;
int rrr7(short (Funcs::* const& rr7)(bool) const &) const;
int rrr8(short (Funcs::* rr1)(bool) const &&) const;
};
// member ref-qualified function pointers, unnamed parameters
int MemberFuncPtrs::aaa1(short (Funcs::*)(bool) &) const { return 0; }
int MemberFuncPtrs::aaa2(short (Funcs::* const *&)(bool) &) const { return 0; }
int MemberFuncPtrs::aaa3(short (Funcs::* *&)(bool) &) const { return 0; }
int MemberFuncPtrs::aaa4(short (Funcs::* *const&)(bool) &) const { return 0; }
int MemberFuncPtrs::aaa5(short (Funcs::* &)(bool) &) const { return 0; }
int MemberFuncPtrs::aaa6(short (Funcs::* const)(bool) &) const { return 0; }
int MemberFuncPtrs::aaa7(short (Funcs::* const&)(bool) &) const { return 0; }
int MemberFuncPtrs::aaa8(short (Funcs::* const&)(bool) &&) const { return 0; }
// member cv-qualified and ref-qualified function pointers, unnamed parameters
int MemberFuncPtrs::bbb1(short (Funcs::*)(bool) const &) const { return 0; }
int MemberFuncPtrs::bbb2(short (Funcs::* const *&)(bool) const &) const { return 0; }
int MemberFuncPtrs::bbb3(short (Funcs::* *&)(bool) const &) const { return 0; }
int MemberFuncPtrs::bbb4(short (Funcs::* *const&)(bool) const &) const { return 0; }
int MemberFuncPtrs::bbb5(short (Funcs::* &)(bool) const &) const { return 0; }
int MemberFuncPtrs::bbb6(short (Funcs::* const)(bool) const &) const { return 0; }
int MemberFuncPtrs::bbb7(short (Funcs::* const&)(bool) const &) const { return 0; }
int MemberFuncPtrs::bbb8(short (Funcs::*)(bool) const &&) const { return 0; }
// member ref-qualified function pointers, named parameters
int MemberFuncPtrs::qqq1(short (Funcs::* qq1)(bool) &) const { return 0; }
int MemberFuncPtrs::qqq2(short (Funcs::* const *& qq2)(bool) &) const { return 0; }
int MemberFuncPtrs::qqq3(short (Funcs::* *& qq3)(bool) &) const { return 0; }
int MemberFuncPtrs::qqq4(short (Funcs::* *const& qq4)(bool) &) const { return 0; }
int MemberFuncPtrs::qqq5(short (Funcs::* & qq5)(bool) &) const { return 0; }
int MemberFuncPtrs::qqq6(short (Funcs::* const qq6)(bool) &) const { return 0; }
int MemberFuncPtrs::qqq7(short (Funcs::* const& qq7)(bool) &) const { return 0; }
int MemberFuncPtrs::qqq8(short (Funcs::* const& qq8)(bool) &&) const { return 0; }
// member cv-qualified and ref-qualified function pointers, named parameters
int MemberFuncPtrs::rrr1(short (Funcs::* rr1)(bool) const &) const { return 0; }
int MemberFuncPtrs::rrr2(short (Funcs::* const *& rr2)(bool) const &) const { return 0; }
int MemberFuncPtrs::rrr3(short (Funcs::* *& rr3)(bool) const &) const { return 0; }
int MemberFuncPtrs::rrr4(short (Funcs::* *const& rr4)(bool) const &) const { return 0; }
int MemberFuncPtrs::rrr5(short (Funcs::* & rr5)(bool) const &) const { return 0; }
int MemberFuncPtrs::rrr6(short (Funcs::* const rr6)(bool) const &) const { return 0; }
int MemberFuncPtrs::rrr7(short (Funcs::* const& rr7)(bool) const &) const { return 0; }
int MemberFuncPtrs::rrr8(short (Funcs::* rr1)(bool) const &&) const { return 0; }
// member cv-qualified and ref-qualified pointer variables
short (Funcs::* cc1)(bool) const & = &Funcs::CC;
short (Funcs::* const * ccextra2)(bool) const & = &cc1;
short (Funcs::* * ccextra3)(bool) const & = &cc1;
short (Funcs::* *const ccextra4)(bool) const & = &cc1;
short (Funcs::* const *& cc2)(bool) const & = ccextra2;
short (Funcs::* *& cc3)(bool) const & = ccextra3;
short (Funcs::* *const& cc4)(bool) const & = ccextra4;
short (Funcs::* & cc5)(bool) const & = cc1;
short (Funcs::* const cc6)(bool) const & = &Funcs::CC;
short (Funcs::* const& cc7)(bool) const & = cc1;
%}
%inline %{
struct Funktions {
int addByValue(const int &a, int b) const & { return a+b; }
int * addByPointer(const int &a, int b) const & { static int val; val = a+b; return &val; }
int & addByReference(const int &a, int b) const & { static int val; val = a+b; return val; }
};
int call1(int (Funktions::*d)(const int &, int) const &, int a, int b) { Funktions f; return (f.*d)(a, b); }
//int call2(int * (Funktions::*d)(const int &, int) const &, int a, int b) { Funktions f; return *(f.*d)(a, b); }
//int call3(int & (Funktions::*d)(const int &, int) const &, int a, int b) { Funktions f; return (f.*d)(a, b); }
%}
%constant int (Funktions::*ADD_BY_VALUE)(const int &, int) const & = &Funktions::addByValue;

15
Examples/test-suite/cpp11_ref_qualifiers_rvalue_unignore.i Normal file
View file

@ -0,0 +1,15 @@
%module cpp11_ref_qualifiers_rvalue_unignore
// This is a minimal test that does not include any C++ headers to make sure the required
// <memory> header is generated from a fragment for the generated std::move call
// m1 and m2 are ignored by default, unignore them
%feature("ignore", "0") RefQualifier::m1() &&;
%feature("ignore", "0") RefQualifier::m2() const &&;
%inline %{
struct RefQualifier {
void m1() && {}
void m2() const && {}
};
%}

74
Examples/test-suite/cpp11_ref_qualifiers_typemaps.i Normal file
View file

@ -0,0 +1,74 @@
%module cpp11_ref_qualifiers_typemaps
%typemap(in) SWIGTYPE (CLASS::*) %{
_this_will_fail_to_compile_if_used_
%}
// typemaps to completely ignore the input parm and override it
%typemap(in) short (Funcs::*ff)(bool) const %{ $1 = &Funcs::FF2; %}
%typemap(in) short (Funcs::*cc)(bool) & %{ $1 = &Funcs::CC5; %}
%typemap(in) short (Funcs::*gg)(bool) const & %{ $1 = &Funcs::GG8; %}
%typemap(in) short (Funcs::*hh)(bool) && %{ $1 = &Funcs::HH11; %}
%typemap(in) short (Funcs::*)(bool) const %{ $1 = &Funcs::FF3; %}
%typemap(in) short (Funcs::*)(bool) & %{ $1 = &Funcs::CC6; %}
%typemap(in) short (Funcs::*)(bool) const & %{ $1 = &Funcs::GG9; %}
%typemap(in) short (Funcs::*)(bool) && %{ $1 = &Funcs::HH12; %}
%inline %{
struct Funcs {
short FF1(bool) const { return 1; }
short FF2(bool) const { return 2; }
short FF3(bool) const { return 3; }
short CC4(bool) & { return 4; }
short CC5(bool) & { return 5; }
short CC6(bool) & { return 6; }
short GG7(bool) const & { return 7; }
short GG8(bool) const & { return 8; }
short GG9(bool) const & { return 9; }
short HH10(bool) && { return 10; }
short HH11(bool) && { return 11; }
short HH12(bool) && { return 12; }
};
struct TypemapsNamedParms
{
short fff(short (Funcs::*ff)(bool) const) {
Funcs funcs;
return (funcs.*ff)(true);
}
short ccc(short (Funcs::*cc)(bool) &) {
Funcs funcs;
return (funcs.*cc)(true);
}
short ggg(short (Funcs::*gg)(bool) const &) {
Funcs funcs;
return (funcs.*gg)(true);
}
short hhh(short (Funcs::*hh)(bool) &&) {
return (Funcs().*hh)(true);
}
};
struct TypemapsUnnamedParms
{
short fff(short (Funcs::*f)(bool) const) {
Funcs funcs;
return (funcs.*f)(true);
}
short ccc(short (Funcs::*c)(bool) &) {
Funcs funcs;
return (funcs.*c)(true);
}
short ggg(short (Funcs::*g)(bool) const &) {
Funcs funcs;
return (funcs.*g)(true);
}
short hhh(short (Funcs::*h)(bool) &&) {
return (Funcs().*h)(true);
}
};
%}
%constant short (Funcs::*FF1_MFP)(bool) const = &Funcs::FF1;
%constant short (Funcs::*CC4_MFP)(bool) & = &Funcs::CC4;
%constant short (Funcs::*GG7_MFP)(bool) const & = &Funcs::GG7;
%constant short (Funcs::*HH10_MFP)(bool) && = &Funcs::HH10;

43
Examples/test-suite/errors/cpp_invalid_qualifiers.i Normal file
View file

@ -0,0 +1,43 @@
%module cpp_invalid_qualifiers
// Constructors, destructors and static methods cannot have qualifiers
struct A {
~A() const;
};
struct B {
virtual ~B() const;
};
struct C {
~C() &;
};
struct D {
virtual ~D() &;
};
struct E {
~E() &&;
};
struct F {
virtual ~F() &&;
};
struct J {
J() const;
J(int) const;
};
struct K {
K() &;
K(int) &;
};
struct L {
L() &&;
L(int) &&;
};
struct M {
static void m1() const;
static void m2() &;
thread_local static void m3() &&;
static auto m4() const -> int;
static auto m5() & -> int;
static auto m6() && -> int;
};

20
Examples/test-suite/errors/cpp_invalid_qualifiers.stderr Normal file
View file

@ -0,0 +1,20 @@
cpp_invalid_qualifiers.i:5: Error: Destructor ~A() const cannot have a qualifier.
cpp_invalid_qualifiers.i:8: Error: Destructor ~B() const cannot have a qualifier.
cpp_invalid_qualifiers.i:11: Error: Destructor ~C() & cannot have a qualifier.
cpp_invalid_qualifiers.i:14: Error: Destructor ~D() & cannot have a qualifier.
cpp_invalid_qualifiers.i:17: Error: Destructor ~E() && cannot have a qualifier.
cpp_invalid_qualifiers.i:20: Error: Destructor ~F() && cannot have a qualifier.
cpp_invalid_qualifiers.i:24: Error: Constructor cannot have a qualifier.
cpp_invalid_qualifiers.i:25: Error: Constructor cannot have a qualifier.
cpp_invalid_qualifiers.i:28: Error: Constructor cannot have a qualifier.
cpp_invalid_qualifiers.i:29: Error: Constructor cannot have a qualifier.
cpp_invalid_qualifiers.i:32: Error: Constructor cannot have a qualifier.
cpp_invalid_qualifiers.i:33: Error: Constructor cannot have a qualifier.
cpp_invalid_qualifiers.i:37: Error: Static function m1() const cannot have a qualifier.
cpp_invalid_qualifiers.i:38: Error: Static function m2() & cannot have a qualifier.
cpp_invalid_qualifiers.i:39: Error: Static function m3() && cannot have a qualifier.
cpp_invalid_qualifiers.i:39: Warning 405: Method with rvalue ref-qualifier m3() && ignored.
cpp_invalid_qualifiers.i:40: Error: Static function m4() const cannot have a qualifier.
cpp_invalid_qualifiers.i:41: Error: Static function m5() & cannot have a qualifier.
cpp_invalid_qualifiers.i:42: Error: Static function m6() && cannot have a qualifier.
cpp_invalid_qualifiers.i:42: Warning 405: Method with rvalue ref-qualifier m6() && ignored.

28
Examples/test-suite/errors/cpp_refqualifier.i Normal file
View file

@ -0,0 +1,28 @@
%module cpp_refqualifier
%ignore Host::h_ignored;
%ignore Host::i_ignored() &&;
%ignore Host::j_ignored() const &&;
class Host {
public:
void h1() &;
void h2() const &;
void h3() &&;
void h4() const &&;
void h() &;
void h() const &;
void h() &&;
void h() const &&;
void h_ignored() &&;
void i_ignored() &&;
void i_ignored() &&;
};
%feature("ignore", "0") Unignore::k_unignored() const &&;
struct Unignore {
void k_unignored() const &&;
};

6
Examples/test-suite/errors/cpp_refqualifier.stderr Normal file
View file

@ -0,0 +1,6 @@
cpp_refqualifier.i:11: Warning 405: Method with rvalue ref-qualifier h3() && ignored.
cpp_refqualifier.i:12: Warning 405: Method with rvalue ref-qualifier h4() const && ignored.
cpp_refqualifier.i:16: Warning 405: Method with rvalue ref-qualifier h() && ignored.
cpp_refqualifier.i:17: Warning 405: Method with rvalue ref-qualifier h() const && ignored.
cpp_refqualifier.i:15: Warning 512: Overloaded method Host::h() const & ignored,
cpp_refqualifier.i:14: Warning 512: using non-const method Host::h() & instead.

56
Examples/test-suite/java/cpp11_ref_qualifiers_runme.java Normal file
View file

@ -0,0 +1,56 @@
import cpp11_ref_qualifiers.*;
public class cpp11_ref_qualifiers_runme {
static {
try {
System.loadLibrary("cpp11_ref_qualifiers");
} catch (UnsatisfiedLinkError e) {
System.err.println("Native code library failed to load. See the chapter on Dynamic Linking Problems in the SWIG Java documentation for help.\n" + e);
System.exit(1);
}
}
public static void main(String argv[]) {
Host h = new Host();
// Basic testing
h.h1();
h.h2();
h.h6();
h.h7();
h.h();
// %feature testing
Features f = new Features();
if (!f.F1().equals("F1")) throw new RuntimeException("Fail");
if (!f.F2().equals("F2")) throw new RuntimeException("Fail");
if (!f.F3().equals("F3")) throw new RuntimeException("Fail");
if (!f.C1(0).equals("C1")) throw new RuntimeException("Fail");
if (!f.C2(0).equals("C2")) throw new RuntimeException("Fail");
if (!f.C3(0).equals("C3")) throw new RuntimeException("Fail");
// %rename testing
Renames r = new Renames();
r.RR1();
r.RR2();
r.RR3();
r.SS1(0);
r.SS2(0);
r.SS3(0);
// Conversion operators
String s = null;
ConversionOperators co = new ConversionOperators();
s = co.StringConvertCopy();
s = co.StringConvertMove();
ConversionOperators2 co2 = new ConversionOperators2();
s = co2.StringConvertMove();
}
}

20
Examples/test-suite/java/cpp11_ref_qualifiers_rvalue_unignore_runme.java Normal file
View file

@ -0,0 +1,20 @@
import cpp11_ref_qualifiers_rvalue_unignore.*;
public class cpp11_ref_qualifiers_rvalue_unignore_runme {
static {
try {
System.loadLibrary("cpp11_ref_qualifiers_rvalue_unignore");
} catch (UnsatisfiedLinkError e) {
System.err.println("Native code library failed to load. See the chapter on Dynamic Linking Problems in the SWIG Java documentation for help.\n" + e);
System.exit(1);
}
}
public static void main(String argv[]) {
new RefQualifier().m1();
new RefQualifier().m2();
}
}

39
Examples/test-suite/java/cpp11_ref_qualifiers_typemaps_runme.java Normal file
View file

@ -0,0 +1,39 @@
import cpp11_ref_qualifiers_typemaps.*;
public class cpp11_ref_qualifiers_typemaps_runme {
static {
try {
System.loadLibrary("cpp11_ref_qualifiers_typemaps");
} catch (UnsatisfiedLinkError e) {
System.err.println("Native code library failed to load. See the chapter on Dynamic Linking Problems in the SWIG Java documentation for help.\n" + e);
System.exit(1);
}
}
public static void main(String argv[])
{
{
TypemapsNamedParms tm = new TypemapsNamedParms();
if (tm.fff(cpp11_ref_qualifiers_typemaps.FF1_MFP) != 2)
throw new RuntimeException("failed");
if (tm.ccc(cpp11_ref_qualifiers_typemaps.CC4_MFP) != 5)
throw new RuntimeException("failed");
if (tm.ggg(cpp11_ref_qualifiers_typemaps.GG7_MFP) != 8)
throw new RuntimeException("failed");
if (tm.hhh(cpp11_ref_qualifiers_typemaps.HH10_MFP) != 11)
throw new RuntimeException("failed");
}
{
TypemapsUnnamedParms tm = new TypemapsUnnamedParms();
if (tm.fff(cpp11_ref_qualifiers_typemaps.FF1_MFP) != 3)
throw new RuntimeException("failed");
if (tm.ccc(cpp11_ref_qualifiers_typemaps.CC4_MFP) != 6)
throw new RuntimeException("failed");
if (tm.ggg(cpp11_ref_qualifiers_typemaps.GG7_MFP) != 9)
throw new RuntimeException("failed");
if (tm.hhh(cpp11_ref_qualifiers_typemaps.HH10_MFP) != 12)
throw new RuntimeException("failed");
}
}
}

24
Examples/test-suite/member_funcptr_galore.i
View file

@ -6,6 +6,12 @@
%warnfilter(SWIGWARN_TYPEMAP_SWIGTYPELEAK_MSG) pp3;
%warnfilter(SWIGWARN_TYPEMAP_SWIGTYPELEAK_MSG) pp5;
%warnfilter(SWIGWARN_TYPEMAP_SWIGTYPELEAK_MSG) ccextra2;
%warnfilter(SWIGWARN_TYPEMAP_SWIGTYPELEAK_MSG) ccextra3;
%warnfilter(SWIGWARN_TYPEMAP_SWIGTYPELEAK_MSG) cc2;
%warnfilter(SWIGWARN_TYPEMAP_SWIGTYPELEAK_MSG) cc3;
%warnfilter(SWIGWARN_TYPEMAP_SWIGTYPELEAK_MSG) cc5;
%{
#if defined(__SUNPRO_CC)
#pragma error_messages (off, badargtype2w) /* Formal argument ... is being passed extern "C" ... */
@ -155,7 +161,7 @@ public:
int qqq7(short (Funcs::* const& qq7)(bool)) const;
};
// member const function pointers, unnamed parameters
// member const function pointers, unnamed parameters
int MemberFuncPtrs::aaa1(short (Funcs::* )(bool) const) const { return 0; }
int MemberFuncPtrs::aaa2(short (Funcs::* const *&)(bool) const) const { return 0; }
int MemberFuncPtrs::aaa3(short (Funcs::* *& )(bool) const) const { return 0; }
@ -191,7 +197,7 @@ int MemberFuncPtrs::qqq5(short (Funcs::* & qq5)(bool)) const { return 0; }
int MemberFuncPtrs::qqq6(short (Funcs::* const qq6)(bool)) const { return 0; }
int MemberFuncPtrs::qqq7(short (Funcs::* const& qq7)(bool)) const { return 0; }
// member function pointer variables
// member non-const function pointer variables
short (Funcs::* pp1)(bool) = &Funcs::FF;
short (Funcs::* const * extra2)(bool) = &pp1;
@ -204,4 +210,18 @@ short (Funcs::* *const& pp4)(bool) = extra4;
short (Funcs::* & pp5)(bool) = pp1;
short (Funcs::* const pp6)(bool) = &Funcs::FF;
short (Funcs::* const& pp7)(bool) = pp1;
// member const function pointer variables
short (Funcs::* cc1)(bool) const = &Funcs::CC;
short (Funcs::* const * ccextra2)(bool) const = &cc1;
short (Funcs::* * ccextra3)(bool) const = &cc1;
short (Funcs::* *const ccextra4)(bool) const = &cc1;
short (Funcs::* const *& cc2)(bool) const = ccextra2;
short (Funcs::* *& cc3)(bool) const = ccextra3;
short (Funcs::* *const& cc4)(bool) const = ccextra4;
short (Funcs::* & cc5)(bool) const = cc1;
short (Funcs::* const cc6)(bool) const = &Funcs::CC;
short (Funcs::* const& cc7)(bool) const = cc1;
%}

45
Examples/test-suite/python/cpp11_ref_qualifiers_runme.py Normal file
View file

@ -0,0 +1,45 @@
import cpp11_ref_qualifiers
h = cpp11_ref_qualifiers.Host()
# Basic testing
h.h1()
h.h2()
h.h6()
h.h7()
h.h()
# %feature testing
f = cpp11_ref_qualifiers.Features()
if f.F1() != "F1":
raise RuntimeException("Fail")
if f.F2() != "F2":
raise RuntimeException("Fail")
if f.F3() != "F3":
raise RuntimeException("Fail")
if f.C1(0) != "C1":
raise RuntimeException("Fail")
if f.C2(0) != "C2":
raise RuntimeException("Fail")
if f.C3(0) != "C3":
raise RuntimeException("Fail")
# %rename testing
r = cpp11_ref_qualifiers.Renames()
r.RR1()
r.RR2()
r.RR3()
r.SS1(0)
r.SS2(0)
r.SS3(0)
# Conversion operators
co = cpp11_ref_qualifiers.ConversionOperators()
s = co.StringConvertCopy()
s = co.StringConvertMove()
co2 = cpp11_ref_qualifiers.ConversionOperators2()
s = co2.StringConvertMove()

4
Examples/test-suite/python/cpp11_ref_qualifiers_rvalue_unignore_runme.py Normal file
View file

@ -0,0 +1,4 @@
import cpp11_ref_qualifiers_rvalue_unignore
cpp11_ref_qualifiers_rvalue_unignore.RefQualifier().m1()
cpp11_ref_qualifiers_rvalue_unignore.RefQualifier().m2()

1
Examples/test-suite/template_empty_inherit.i
View file

@ -5,6 +5,7 @@
%inline %{
template<class Arg, typename Result> struct Functor {
virtual Result operator()(Arg x) const = 0;
virtual ~Functor() {}
};
%}

Some files were not shown because too many files have changed in this diff Show more