From: <wsf...@us...> - 2010-01-22 20:40:01
|
Revision: 11827 http://swig.svn.sourceforge.net/swig/?rev=11827&view=rev Author: wsfulton Date: 2010-01-22 20:39:54 +0000 (Fri, 22 Jan 2010) Log Message: ----------- Fix #2933129 - typemaps not being found when the unary scope operator (::) is used to denote global scope Modified Paths: -------------- trunk/CHANGES.current trunk/Examples/test-suite/common.mk trunk/Examples/test-suite/global_namespace.i trunk/Source/Modules/lang.cxx trunk/Source/Swig/misc.c trunk/Source/Swig/stype.c trunk/Source/Swig/swig.h trunk/Source/Swig/typemap.c trunk/Source/Swig/typesys.c Added Paths: ----------- trunk/Examples/test-suite/typemap_global_scope.i Modified: trunk/CHANGES.current =================================================================== --- trunk/CHANGES.current 2010-01-22 04:50:28 UTC (rev 11826) +++ trunk/CHANGES.current 2010-01-22 20:39:54 UTC (rev 11827) @@ -1,6 +1,26 @@ Version 1.3.41 (in progress) ============================ +2010-01-22: wsfulton + Fix #2933129 - typemaps not being found when the unary scope operator (::) is used to denote + global scope, the typemap is now used in situations like this: + + struct X {}; + %typemap(in) const X & "..." + void m(const ::X &); + + and this: + + struct X {}; + %typemap(in) const ::X & "..." + void m(const X &); + +2010-01-20: wsfulton + Fix some unary scope operator (::) denoting global scope problems in the types generated + into the C++ layer. Previously the unary scope operator was dropped in the generated code + if the type had any sort of qualifier, for example when using pointers, references, like + ::foo*, ::foo&, bar< ::foo* >. + 2010-01-13: olly [PHP] Add datetime to the list of PHP predefined classes (patch from David Fletcher in SF#2931042). @@ -217,7 +237,7 @@ -debug-csymbols - Display C symbols in the symbol tables 2009-11-03: wsfulton - Fix some usage of global scope operator, for example: + Fix some usage of unary scope operator (::) denoting global scope, for example: namespace AA { /* ... */ } using namespace ::AA; Modified: trunk/Examples/test-suite/common.mk =================================================================== --- trunk/Examples/test-suite/common.mk 2010-01-22 04:50:28 UTC (rev 11826) +++ trunk/Examples/test-suite/common.mk 2010-01-22 20:39:54 UTC (rev 11827) @@ -198,6 +198,7 @@ fvirtual \ global_namespace \ global_ns_arg \ + global_scope_types \ global_vars \ grouping \ ignore_parameter \ @@ -381,6 +382,7 @@ typedef_scope \ typedef_sizet \ typedef_struct \ + typemap_global_scope \ typemap_namespace \ typemap_ns_using \ typemap_numinputs \ Modified: trunk/Examples/test-suite/global_namespace.i =================================================================== --- trunk/Examples/test-suite/global_namespace.i 2010-01-22 04:50:28 UTC (rev 11826) +++ trunk/Examples/test-suite/global_namespace.i 2010-01-22 20:39:54 UTC (rev 11827) @@ -11,8 +11,8 @@ class Klass7 {}; struct KlassMethods { - static void methodA(::Klass1 v, const ::Klass2 cv, const ::Klass3 *cp, ::Klass4 *p, const ::Klass5 &cr, ::Klass6 &r, Klass7*& pr) {} - static void methodB( Klass1 v, const Klass2 cv, const Klass3 *cp, Klass4 *p, const Klass5 &cr, Klass6 &r, Klass7*& pr) {} + static void methodA(::Klass1 v, const ::Klass2 cv, const ::Klass3 *cp, ::Klass4 *p, const ::Klass5 &cr, ::Klass6 &r, ::Klass7*& pr) {} + static void methodB( Klass1 v, const Klass2 cv, const Klass3 *cp, Klass4 *p, const Klass5 &cr, Klass6 &r, Klass7*& pr) {} }; %} @@ -28,8 +28,8 @@ } struct XYZMethods { - static void methodA(::Space::XYZ1 v, const ::Space::XYZ2 cv, const ::Space::XYZ3 *cp, ::Space::XYZ4 *p, const ::Space::XYZ5 &cr, ::Space::XYZ6 &r, Space::XYZ7*& pr) {} - static void methodB( Space::XYZ1 v, const Space::XYZ2 cv, const Space::XYZ3 *cp, Space::XYZ4 *p, const Space::XYZ5 &cr, Space::XYZ6 &r, Space::XYZ7*& pr) {} + static void methodA(::Space::XYZ1 v, const ::Space::XYZ2 cv, const ::Space::XYZ3 *cp, ::Space::XYZ4 *p, const ::Space::XYZ5 &cr, ::Space::XYZ6 &r, ::Space::XYZ7*& pr) {} + static void methodB( Space::XYZ1 v, const Space::XYZ2 cv, const Space::XYZ3 *cp, Space::XYZ4 *p, const Space::XYZ5 &cr, Space::XYZ6 &r, Space::XYZ7*& pr) {} }; %} Added: trunk/Examples/test-suite/typemap_global_scope.i =================================================================== --- trunk/Examples/test-suite/typemap_global_scope.i (rev 0) +++ trunk/Examples/test-suite/typemap_global_scope.i 2010-01-22 20:39:54 UTC (rev 11827) @@ -0,0 +1,215 @@ +%module typemap_global_scope + +// Test global scope operator :: for typemaps. Previously SWIG would not use a typemap that did not specify the global scope +// operator for a type that did have it, and vice-versa. + +%typemap(in) SWIGTYPE "_this_will_not_compile_SWIGTYPE_ \"$type\"" +%typemap(in) const SWIGTYPE & "_this_will_not_compile_const_SWIGTYPE_REF_ \"$type\"" +%typemap(in) enum SWIGTYPE "_this_will_not_compile_enum_SWIGTYPE_ \"$type\"" +%typemap(in) const enum SWIGTYPE & "_this_will_not_compile_const_enum_SWIGTYPE_REF_ \"$type\"" + +///////////////////////////////////////////////////////////////////// +// Structs +///////////////////////////////////////////////////////////////////// + +%typemap(in) Test1, ::Test2, Space::Test3, ::Space::Test4 "/*in typemap for $type*/" +%typemap(in) const Test1 &, const ::Test2 &, const Space::Test3 &, const ::Space::Test4 & "/*in typemap for $type*/" +%inline %{ +struct Test1 {}; +struct Test2 {}; +namespace Space { + struct Test3 {}; + struct Test4 {}; +} +%} + +%inline %{ +void test1a(Test1 t, const Test1 &tt) {} +void test1b(::Test1 t, const ::Test1 &tt) {} + +void test2a(Test2 t, const Test2 &tt) {} +void test2b(::Test2 t, const ::Test2 &tt) {} + +void test3a(Space::Test3 t, const Space::Test3 &tt) {} +void test3b(::Space::Test3 t, const ::Space::Test3 &tt) {} +namespace Space { + void test3c(Space::Test3 t, const Space::Test3 &tt) {} + void test3d(::Space::Test3 t, const ::Space::Test3 &tt) {} + void test3e(Test3 t, const Test3 &tt) {} +} + +void test4a(Space::Test4 t, const Space::Test4 &tt) {} +void test4b(::Space::Test4 t, const ::Space::Test4 &tt) {} +namespace Space { + void test4c(Space::Test4 t, const Space::Test4 &tt) {} + void test4d(::Space::Test4 t, const ::Space::Test4 &tt) {} + void test4e(Test4 t, const Test4 &tt) {} +} +%} + +///////////////////////////////////////////////////////////////////// +// Templates +///////////////////////////////////////////////////////////////////// + +%inline %{ +struct XX {}; +%} + +%typemap(in) TemplateTest1< ::XX >, ::TemplateTest2< ::XX >, Space::TemplateTest3< ::XX >, ::Space::TemplateTest4< ::XX > "/* in typemap for $type */" +%typemap(in) const TemplateTest1< XX > &, const ::TemplateTest2< XX > &, const Space::TemplateTest3< XX > &, const ::Space::TemplateTest4< XX > & "/* in typemap for $type */" +%inline %{ +template<typename T> struct TemplateTest1 { T m_t; }; +template<typename T> struct TemplateTest2 { T m_t; }; +namespace Space { + template<typename T> struct TemplateTest3 { T m_t; }; + template<typename T> struct TemplateTest4 { T m_t; }; +} +%} + +%template(TemplateTest1XX) TemplateTest1< ::XX >; +%template(TemplateTest2XX) TemplateTest2< ::XX >; +%template(TemplateTest3XX) Space::TemplateTest3< ::XX >; +%template(TemplateTest4XX) Space::TemplateTest4< ::XX >; + +%inline %{ +void test_template_1a(TemplateTest1< ::XX > t, const TemplateTest1< ::XX > &tt) {} +void test_template_1b(::TemplateTest1< ::XX > t, const ::TemplateTest1< ::XX > &tt) {} + +void test_template_2a(TemplateTest2< ::XX > t, const TemplateTest2< ::XX > &tt) {} +void test_template_2b(::TemplateTest2< ::XX > t, const ::TemplateTest2< ::XX > &tt) {} + +void test_template_3a(Space::TemplateTest3< ::XX > t, const Space::TemplateTest3< ::XX > &tt) {} +void test_template_3b(::Space::TemplateTest3< ::XX > t, const ::Space::TemplateTest3< ::XX > &tt) {} +namespace Space { + void test_template_3c(Space::TemplateTest3< ::XX > t, const Space::TemplateTest3< ::XX > &tt) {} + void test_template_3d(::Space::TemplateTest3< ::XX > t, const ::Space::TemplateTest3< ::XX > &tt) {} + void test_template_3e(TemplateTest3< ::XX > t, const TemplateTest3< ::XX > &tt) {} +} + +void test_template_4a(Space::TemplateTest4< ::XX > t, const Space::TemplateTest4< ::XX > &tt) {} +void test_template_4b(::Space::TemplateTest4< ::XX > t, const ::Space::TemplateTest4< ::XX > &tt) {} +namespace Space { + void test_template_4c(Space::TemplateTest4< ::XX > t, const Space::TemplateTest4< ::XX > &tt) {} + void test_template_4d(::Space::TemplateTest4< ::XX > t, const ::Space::TemplateTest4< ::XX > &tt) {} + void test_template_4e(TemplateTest4< ::XX > t, const TemplateTest4< ::XX > &tt) {} +} +%} + +///////////////////////////////////////////////////////////////////// +// Enums +///////////////////////////////////////////////////////////////////// + +%typemap(in) Enum1, ::Enum2, Space::Enum3, ::Space::Enum4 "/*in typemap for $type*/" +%typemap(in) const Enum1 &, const ::Enum2 &, const Space::Enum3 &, const ::Space::Enum4 & "/*in typemap for $type*/" +%inline %{ +enum Enum1 { enum_1 }; +enum Enum2 { enum_2 }; +namespace Space { + enum Enum3 { enum_3 }; + enum Enum4 { enum_4 }; +} +%} + +%inline %{ +void test_enum_1a(Enum1 t, const Enum1 &tt) {} +void test_enum_1b(::Enum1 t, const ::Enum1 &tt) {} + +void test_enum_2a(Enum2 t, const Enum2 &tt) {} +void test_enum_2b(::Enum2 t, const ::Enum2 &tt) {} + +void test_enum_3a(Space::Enum3 t, const Space::Enum3 &tt) {} +void test_enum_3b(::Space::Enum3 t, const ::Space::Enum3 &tt) {} +namespace Space { + void test_enum_3c(Space::Enum3 t, const Space::Enum3 &tt) {} + void test_enum_3d(::Space::Enum3 t, const ::Space::Enum3 &tt) {} + void test_enum_3e(Enum3 t, const Enum3 &tt) {} +} + +void test_enum_4a(Space::Enum4 t, const Space::Enum4 &tt) {} +void test_enum_4b(::Space::Enum4 t, const ::Space::Enum4 &tt) {} +namespace Space { + void test_enum_4c(Space::Enum4 t, const Space::Enum4 &tt) {} + void test_enum_4d(::Space::Enum4 t, const ::Space::Enum4 &tt) {} + void test_enum_4e(Enum4 t, const Enum4 &tt) {} +} +%} + +#if 0 +///////////////////////////////////////////////////////////////////// +// Enums with enum specified in typemap +///////////////////////////////////////////////////////////////////// + +%typemap(in) enum Mune1, enum ::Mune2, enum Space::Mune3, enum ::Space::Mune4 "/*in typemap for $type*/" +%typemap(in) const enum Mune1 &, const enum ::Mune2 &, const enum Space::Mune3 &, const enum ::Space::Mune4 & "/*in typemap for $type*/" +%inline %{ +enum Mune1 { mune_1 }; +enum Mune2 { mune_2 }; +namespace Space { + enum Mune3 { mune_3 }; + enum Mune4 { mune_4 }; +} +%} + +%inline %{ +void test_mune_1a(Mune1 t, const Mune1 &tt) {} +void test_mune_1b(::Mune1 t, const ::Mune1 &tt) {} + +void test_mune_2a(Mune2 t, const Mune2 &tt) {} +void test_mune_2b(::Mune2 t, const ::Mune2 &tt) {} + +void test_mune_3a(Space::Mune3 t, const Space::Mune3 &tt) {} +void test_mune_3b(::Space::Mune3 t, const ::Space::Mune3 &tt) {} +namespace Space { + void test_mune_3c(Space::Mune3 t, const Space::Mune3 &tt) {} + void test_mune_3d(::Space::Mune3 t, const ::Space::Mune3 &tt) {} + void test_mune_3e(Mune3 t, const Mune3 &tt) {} +} + +void test_mune_4a(Space::Mune4 t, const Space::Mune4 &tt) {} +void test_mune_4b(::Space::Mune4 t, const ::Space::Mune4 &tt) {} +namespace Space { + void test_mune_4c(Space::Mune4 t, const Space::Mune4 &tt) {} + void test_mune_4d(::Space::Mune4 t, const ::Space::Mune4 &tt) {} + void test_mune_4e(Mune4 t, const Mune4 &tt) {} +} +%} + +///////////////////////////////////////////////////////////////////// +// Enums with enum specified in type +///////////////////////////////////////////////////////////////////// + +%typemap(in) Nemu1, ::Nemu2, Space::Nemu3, ::Space::Nemu4 "/*in typemap for $type*/" +%typemap(in) const Nemu1 &, const ::Nemu2 &, const Space::Nemu3 &, const ::Space::Nemu4 & "/*in typemap for $type*/" +%inline %{ +enum Nemu1 { nemu_1 }; +enum Nemu2 { nemu_2 }; +namespace Space { + enum Nemu3 { nemu_3 }; + enum Nemu4 { nemu_4 }; +} +%} + +%inline %{ +void test_nemu_1a(enum Nemu1 t, const enum Nemu1 &tt) {} +void test_nemu_1b(enum ::Nemu1 t, const enum ::Nemu1 &tt) {} + +void test_nemu_2a(enum Nemu2 t, const enum Nemu2 &tt) {} +void test_nemu_2b(enum ::Nemu2 t, const enum ::Nemu2 &tt) {} + +void test_nemu_3a(enum Space::Nemu3 t, const enum Space::Nemu3 &tt) {} +void test_nemu_3b(enum ::Space::Nemu3 t, const enum ::Space::Nemu3 &tt) {} +namespace Space { + void test_nemu_3c(enum Space::Nemu3 t, const enum Space::Nemu3 &tt) {} + void test_nemu_3d(enum ::Space::Nemu3 t, const enum ::Space::Nemu3 &tt) {} + void test_nemu_3e(enum Nemu3 t, const enum Nemu3 &tt) {} +} + +void test_nemu_4a(enum Space::Nemu4 t, const enum Space::Nemu4 &tt) {} +void test_nemu_4b(enum ::Space::Nemu4 t, const enum ::Space::Nemu4 &tt) {} +namespace Space { + void test_nemu_4c(enum Space::Nemu4 t, const enum Space::Nemu4 &tt) {} + void test_nemu_4d(enum ::Space::Nemu4 t, const enum ::Space::Nemu4 &tt) {} + void test_nemu_4e(enum Nemu4 t, const enum Nemu4 &tt) {} +} +%} +#endif Modified: trunk/Source/Modules/lang.cxx =================================================================== --- trunk/Source/Modules/lang.cxx 2010-01-22 04:50:28 UTC (rev 11826) +++ trunk/Source/Modules/lang.cxx 2010-01-22 20:39:54 UTC (rev 11827) @@ -782,7 +782,7 @@ Swig_error(input_file, line_number, "Can't copy typemap. Number of types differ.\n"); } else { if (Swig_typemap_copy(method, pattern, npattern) < 0) { - Swig_error(input_file, line_number, "Can't copy typemap.\n"); + Swig_error(input_file, line_number, "Can't copy typemap (%s) %s = %s\n", method, ParmList_str(pattern), ParmList_str(npattern)); } } items = nextSibling(items); Modified: trunk/Source/Swig/misc.c =================================================================== --- trunk/Source/Swig/misc.c 2010-01-22 04:50:28 UTC (rev 11826) +++ trunk/Source/Swig/misc.c 2010-01-22 20:39:54 UTC (rev 11827) @@ -893,7 +893,11 @@ /* ----------------------------------------------------------------------------- * Swig_scopename_check() * - * Checks to see if a name is qualified with a scope name + * Checks to see if a name is qualified with a scope name, examples: + * foo -> 0 + * ::foo -> 1 + * foo::bar -> 1 + * foo< ::bar > -> 0 * ----------------------------------------------------------------------------- */ int Swig_scopename_check(const String *s) { Modified: trunk/Source/Swig/stype.c =================================================================== --- trunk/Source/Swig/stype.c 2010-01-22 04:50:28 UTC (rev 11826) +++ trunk/Source/Swig/stype.c 2010-01-22 20:39:54 UTC (rev 11827) @@ -1095,6 +1095,25 @@ } /* ----------------------------------------------------------------------------- + * SwigType_remove_global_scope_prefix() + * + * Removes the unary scope operator (::) prefix indicating global scope in all + * components of the type + * ----------------------------------------------------------------------------- */ + +SwigType *SwigType_remove_global_scope_prefix(const SwigType *t) { + SwigType *result; + const char *type = Char(t); + if (strncmp(type, "::", 2) == 0) + type += 2; + result = NewString(type); + Replaceall(result, ".::", "."); + Replaceall(result, "(::", "("); + Replaceall(result, "enum ::", "enum "); + return result; +} + +/* ----------------------------------------------------------------------------- * SwigType_check_decl() * * Checks type declarators for a match Modified: trunk/Source/Swig/swig.h =================================================================== --- trunk/Source/Swig/swig.h 2010-01-22 04:50:28 UTC (rev 11826) +++ trunk/Source/Swig/swig.h 2010-01-22 20:39:54 UTC (rev 11827) @@ -166,6 +166,7 @@ extern SwigType *SwigType_array_type(SwigType *t); extern String *SwigType_default(SwigType *t); extern void SwigType_typename_replace(SwigType *t, String *pat, String *rep); + extern SwigType *SwigType_remove_global_scope_prefix(const SwigType *t); extern SwigType *SwigType_alttype(SwigType *t, int ltmap); extern void SwigType_template_defargs(Parm *parms, Parm *targs, Symtab *tscope, Symtab *tsdecl); Modified: trunk/Source/Swig/typemap.c =================================================================== --- trunk/Source/Swig/typemap.c 2010-01-22 04:50:28 UTC (rev 11826) +++ trunk/Source/Swig/typemap.c 2010-01-22 20:39:54 UTC (rev 11827) @@ -62,47 +62,53 @@ static Hash *typemaps[MAX_SCOPE]; static int tm_scope = 0; -static Hash *get_typemap(int tm_scope, SwigType *type) { +static Hash *get_typemap(int tm_scope, const SwigType *type) { Hash *tm = 0; SwigType *dtype = 0; + SwigType *hashtype; + if (SwigType_istemplate(type)) { String *ty = Swig_symbol_template_deftype(type, 0); dtype = Swig_symbol_type_qualify(ty, 0); - /* Printf(stderr,"gettm %s %s\n", type, dtype); */ type = dtype; Delete(ty); } - tm = Getattr(typemaps[tm_scope], type); + /* remove unary scope operator (::) prefix indicating global scope for looking up in the hashmap */ + hashtype = SwigType_remove_global_scope_prefix(type); + tm = Getattr(typemaps[tm_scope], hashtype); if (dtype) { if (!tm) { - String *t_name = SwigType_templateprefix(type); - if (!Equal(t_name, type)) { + String *t_name = SwigType_templateprefix(hashtype); + if (!Equal(t_name, hashtype)) { tm = Getattr(typemaps[tm_scope], t_name); } Delete(t_name); } Delete(dtype); } + Delete(hashtype); return tm; } -static void set_typemap(int tm_scope, SwigType *type, Hash *tm) { - SwigType *dtype = 0; +static void set_typemap(int tm_scope, const SwigType *type, Hash *tm) { + SwigType *hashtype = 0; if (SwigType_istemplate(type)) { String *ty = Swig_symbol_template_deftype(type, 0); - dtype = Swig_symbol_type_qualify(ty, 0); - /* Printf(stderr,"settm %s %s\n", type, dtype); */ - type = dtype; + String *tyq = Swig_symbol_type_qualify(ty, 0); + hashtype = SwigType_remove_global_scope_prefix(tyq); + Delete(tyq); Delete(ty); } else { - dtype = Copy(type); - type = dtype; + hashtype = SwigType_remove_global_scope_prefix(type); } - Setattr(typemaps[tm_scope], type, tm); - Delete(dtype); + + /* note that the unary scope operator (::) prefix indicating global scope has been removed for storing in the hashmap */ + Setattr(typemaps[tm_scope], hashtype, tm); + + Delete(hashtype); } Modified: trunk/Source/Swig/typesys.c =================================================================== --- trunk/Source/Swig/typesys.c 2010-01-22 04:50:28 UTC (rev 11826) +++ trunk/Source/Swig/typesys.c 2010-01-22 20:39:54 UTC (rev 11827) @@ -840,7 +840,8 @@ * * Given a type declaration, this function tries to fully qualify it according to * typedef scope rules. - * Inconsistency to be fixed: ::Foo returns ::Foo, whereas ::Foo * returns Foo * + * If the unary scope operator (::) is used as a prefix to the type to denote global + * scope, it is left in place. * ----------------------------------------------------------------------------- */ SwigType *SwigType_typedef_qualified(SwigType *t) { @@ -848,10 +849,6 @@ String *result; int i, len; - if (strncmp(Char(t), "::", 2) == 0) { - return Copy(t); - } - if (!typedef_qualified_cache) typedef_qualified_cache = NewHash(); result = Getattr(typedef_qualified_cache, t); @@ -999,10 +996,6 @@ Delete(qprefix); Delete(parms); } - if (strncmp(Char(e), "::", 2) == 0) { - Delitem(e, 0); - Delitem(e, 0); - } Append(result, e); Delete(ty); } else if (SwigType_isfunction(e)) { This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |