From 7268f58c4c019353d987689d80bd22eedfbfc423 Mon Sep 17 00:00:00 2001 From: William S Fulton Date: Mon, 28 Nov 2016 22:44:28 +0000 Subject: [PATCH] Fix %rename override of wildcard %rename for templates %rename(GlobalIntOperator) *::operator bool; // wildcard %rename %rename(XIntOperator) X::operator bool; // fix now overrides first %rename above OR %rename(XIntOperator) X::operator bool; // fix now overrides first %rename above template struct X { operator bool(); ... }; %template(Xint) X; --- CHANGES.current | 15 ++ Examples/test-suite/common.mk | 1 + .../java/rename_wildcard_runme.java | 90 +++++++++++ Examples/test-suite/rename_wildcard.i | 140 ++++++++++++++++++ Source/Swig/naming.c | 12 +- 5 files changed, 257 insertions(+), 1 deletion(-) create mode 100644 Examples/test-suite/java/rename_wildcard_runme.java create mode 100644 Examples/test-suite/rename_wildcard.i diff --git a/CHANGES.current b/CHANGES.current index 3fbad554c..14f6fb4cb 100644 --- a/CHANGES.current +++ b/CHANGES.current @@ -5,6 +5,21 @@ See the RELEASENOTES file for a summary of changes in each release. Version 3.0.11 (in progress) ============================ +2016-11-28: wsfulton + Fix %rename override of wildcard %rename for templates. For example: + + %rename(GlobalIntOperator) *::operator bool; // wildcard %rename + + %rename(XIntOperator) X::operator bool; // fix now overrides first %rename above + OR + %rename(XIntOperator) X::operator bool; // fix now overrides first %rename above + + template struct X { + operator bool(); + ... + }; + %template(Xint) X; + 2016-11-26: m7thon [Python] Issue #709 - improved wrapping of division operators 'from __future__ import division' now works in Python 2 whether or not the diff --git a/Examples/test-suite/common.mk b/Examples/test-suite/common.mk index c6a02f487..e3881afd6 100644 --- a/Examples/test-suite/common.mk +++ b/Examples/test-suite/common.mk @@ -353,6 +353,7 @@ CPP_TEST_CASES += \ rename_pcre_encoder \ rename_pcre_enum \ rename_predicates \ + rename_wildcard \ restrict_cplusplus \ return_const_value \ return_value_scope \ diff --git a/Examples/test-suite/java/rename_wildcard_runme.java b/Examples/test-suite/java/rename_wildcard_runme.java new file mode 100644 index 000000000..1553af2c5 --- /dev/null +++ b/Examples/test-suite/java/rename_wildcard_runme.java @@ -0,0 +1,90 @@ + +import rename_wildcard.*; + +public class rename_wildcard_runme { + + static { + try { + System.loadLibrary("rename_wildcard"); + } 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[]) { + // Wildcard check + { + new GlobalWildStruct().mm1(); + new GlobalWildTemplateStructInt().mm1(); + new SpaceWildStruct().mm1(); + new SpaceWildTemplateStructInt().mm1(); + } + // No declaration + { + new GlobalWildStruct().mm2a(); + new GlobalWildTemplateStructInt().mm2b(); + new SpaceWildStruct().mm2c(); + new SpaceWildTemplateStructInt().mm2d(); + + new GlobalWildTemplateStructInt().tt2b(); + new SpaceWildTemplateStructInt().tt2d(); + } + // With declaration + { + new GlobalWildStruct().mm3a(); + new GlobalWildTemplateStructInt().mm3b(); + new SpaceWildStruct().mm3c(); + new SpaceWildTemplateStructInt().mm3d(); + + new GlobalWildTemplateStructInt().tt3b(); + new SpaceWildTemplateStructInt().tt3d(); + } + // Global override too + { + new GlobalWildStruct().mm4a(); + new GlobalWildTemplateStructInt().mm4b(); + new SpaceWildStruct().mm4c(); + new SpaceWildTemplateStructInt().mm4d(); + + new GlobalWildTemplateStructInt().tt4b(); + new SpaceWildTemplateStructInt().tt4d(); + } + // %extend renames + { + new GlobalWildStruct().mm5a(); + new GlobalWildTemplateStructInt().mm5b(); + new SpaceWildStruct().mm5c(); + new SpaceWildTemplateStructInt().mm5d(); + + new GlobalWildTemplateStructInt().tt5b(); + new SpaceWildTemplateStructInt().tt5d(); + } + // operators + { + new GlobalWildStruct().opinta(); + new GlobalWildTemplateStructInt().opintb(); + new SpaceWildStruct().opintc(); + new SpaceWildTemplateStructInt().opintd(); + + new GlobalWildTemplateStructInt().opdoubleb(); + new SpaceWildTemplateStructInt().opdoubled(); + } + // Wildcard renames expected for these + { + new NoChangeStruct().mm1(); + new NoChangeStruct().mm2(); + new NoChangeStruct().mm3(); + new NoChangeStruct().mm4(); + new NoChangeStruct().mm5(); + new NoChangeStruct().opint(); + new SpaceNoChangeStruct().mm1(); + new SpaceNoChangeStruct().mm2(); + new SpaceNoChangeStruct().mm3(); + new SpaceNoChangeStruct().mm4(); + new SpaceNoChangeStruct().mm5(); + new SpaceNoChangeStruct().opint(); + } + } +} + diff --git a/Examples/test-suite/rename_wildcard.i b/Examples/test-suite/rename_wildcard.i new file mode 100644 index 000000000..f9e0347b0 --- /dev/null +++ b/Examples/test-suite/rename_wildcard.i @@ -0,0 +1,140 @@ +// Test rename overriding a wildcard rename +%module rename_wildcard + +%rename(mm1) *::m1; +%rename(mm2) *::m2; +%rename(tt2) *::t2; +%rename(mm3) *::m3(); +%rename(tt3) *::t3(); +%rename(m_4) m4; +%rename(t_4) t4; +%rename(mm4) *::m4; +%rename(tt4) *::t4; +%rename(mm5) *::m5; +%rename(tt5) *::t5; +%rename(opint) *::operator int; +%rename(opdouble) *::operator double; + +// No declaration +%rename(mm2a) GlobalWildStruct::m2; +%rename(mm2b) GlobalWildTemplateStruct::m2; +%rename(mm2c) Space::SpaceWildStruct::m2; +%rename(mm2d) Space::SpaceWildTemplateStruct::m2; +%rename(tt2b) GlobalWildTemplateStruct::t2; +%rename(tt2d) Space::SpaceWildTemplateStruct::t2; + +// With declaration +%rename(mm3a) GlobalWildStruct::m3; +%rename(mm3b) GlobalWildTemplateStruct::m3; +%rename(mm3c) Space::SpaceWildStruct::m3; +%rename(mm3d) Space::SpaceWildTemplateStruct::m3; +%rename(tt3b) GlobalWildTemplateStruct::t3; +%rename(tt3d) Space::SpaceWildTemplateStruct::t3; + +// Global override too +%rename(mm4a) GlobalWildStruct::m4; +%rename(mm4b) GlobalWildTemplateStruct::m4; +%rename(mm4c) Space::SpaceWildStruct::m4; +%rename(mm4d) Space::SpaceWildTemplateStruct::m4; +%rename(tt4b) GlobalWildTemplateStruct::t4; +%rename(tt4d) Space::SpaceWildTemplateStruct::t4; + +// %extend renames +%extend GlobalWildStruct { + %rename(mm5a) m5; +} +%extend GlobalWildTemplateStruct { + %rename(mm5b) m5; +} +%extend GlobalWildTemplateStruct { + %rename(tt5b) t5; +} +namespace Space { + %extend SpaceWildStruct { + %rename(mm5c) m5; + } + %extend SpaceWildTemplateStruct { + %rename(mm5d) m5; + } + %extend SpaceWildTemplateStruct { + %rename(tt5d) t5; + } +} + +// operators +%rename(opinta) GlobalWildStruct::operator int; +%rename(opintb) GlobalWildTemplateStruct::operator int; +%rename(opintc) Space::SpaceWildStruct::operator int; +%rename(opintd) Space::SpaceWildTemplateStruct::operator int; +%rename(opdoubleb) GlobalWildTemplateStruct::operator double; +%rename(opdoubled) Space::SpaceWildTemplateStruct::operator double; + +%inline %{ +struct GlobalWildStruct { + void m1() {} + void m2() {} + void m3() {} + void m4() {} + void m5() {} + operator int() { return 0; } +}; +template struct GlobalWildTemplateStruct { + void m1() {} + void m2() {} + void t2() {} + void m3() {} + void t3() {} + void m4() {} + void t4() {} + void m5() {} + void t5() {} + operator int() { return 0; } + operator double() { return 0.0; } +}; +namespace Space { + struct SpaceWildStruct { + void m1() {} + void m2() {} + void m3() {} + void m4() {} + void m5() {} + operator int() { return 0; } + }; + template struct SpaceWildTemplateStruct { + void m1() {} + void m2() {} + void t2() {} + void m3() {} + void t3() {} + void m4() {} + void t4() {} + void m5() {} + void t5() {} + operator int() { return 0; } + operator double() { return 0.0; } + }; +} + +// Wild card renames expected for these +struct NoChangeStruct { + void m1() {} + void m2() {} + void m3() {} + void m4() {} + void m5() {} + operator int() { return 0; } +}; +namespace Space { + struct SpaceNoChangeStruct { + void m1() {} + void m2() {} + void m3() {} + void m4() {} + void m5() {} + operator int() { return 0; } + }; +} +%} + +%template(GlobalWildTemplateStructInt) GlobalWildTemplateStruct; +%template(SpaceWildTemplateStructInt) Space::SpaceWildTemplateStruct; diff --git a/Source/Swig/naming.c b/Source/Swig/naming.c index c7f187177..ea059aa28 100644 --- a/Source/Swig/naming.c +++ b/Source/Swig/naming.c @@ -404,7 +404,17 @@ DOH *Swig_name_object_get(Hash *namehash, String *prefix, String *name, SwigType } Delete(cls); } - /* A template-based class lookup, check name first */ + /* Lookup a name within a templated-based class */ + if (!rn) { + String *t_name = SwigType_istemplate_templateprefix(prefix); + if (t_name) { + Clear(tname); + Printf(tname, "%s::%s", t_name, name); + rn = name_object_get(namehash, tname, decl, ncdecl); + Delete(t_name); + } + } + /* Lookup a template-based name within a class */ if (!rn) { String *t_name = SwigType_istemplate_templateprefix(name); if (t_name)