Fix #2933129 - typemaps not being found when the unary scope operator (::) is used to denote global scope
git-svn-id: https://swig.svn.sourceforge.net/svnroot/swig/trunk@11827 626c5289-ae23-0410-ae9c-e8d60b6d4f22
This commit is contained in:
William S Fulton
parent
cc53e6c69e
commit
f112e4bac1
10 changed files with 290 additions and 30 deletions
|
|
@ -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 @@ Version 1.3.41 (in progress)
|
|||
-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;
|
||||
|
|
|
|||
|
|
@ -198,6 +198,7 @@ CPP_TEST_CASES += \
|
|||
fvirtual \
|
||||
global_namespace \
|
||||
global_ns_arg \
|
||||
global_scope_types \
|
||||
global_vars \
|
||||
grouping \
|
||||
ignore_parameter \
|
||||
|
|
@ -381,6 +382,7 @@ CPP_TEST_CASES += \
|
|||
typedef_scope \
|
||||
typedef_sizet \
|
||||
typedef_struct \
|
||||
typemap_global_scope \
|
||||
typemap_namespace \
|
||||
typemap_ns_using \
|
||||
typemap_numinputs \
|
||||
|
|
|
|||
|
|
@ -11,8 +11,8 @@ class Klass6 {};
|
|||
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 @@ class XYZ7 {};
|
|||
}
|
||||
|
||||
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) {}
|
||||
};
|
||||
%}
|
||||
|
||||
|
|
|
|||
215
Examples/test-suite/typemap_global_scope.i
Normal file
215
Examples/test-suite/typemap_global_scope.i
Normal file
|
|
@ -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
|
||||
|
|
@ -782,7 +782,7 @@ int Language::typemapcopyDirective(Node *n) {
|
|||
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);
|
||||
|
|
|
|||
|
|
@ -893,7 +893,11 @@ String *Swig_scopename_suffix(const String *s) {
|
|||
/* -----------------------------------------------------------------------------
|
||||
* 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) {
|
||||
|
|
|
|||
|
|
@ -1094,6 +1094,25 @@ void SwigType_typename_replace(SwigType *t, String *pat, String *rep) {
|
|||
Delete(elem);
|
||||
}
|
||||
|
||||
/* -----------------------------------------------------------------------------
|
||||
* 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()
|
||||
*
|
||||
|
|
|
|||
|
|
@ -166,6 +166,7 @@ extern "C" {
|
|||
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);
|
||||
|
|
|
|||
|
|
@ -62,47 +62,53 @@ static void replace_embedded_typemap(String *s, ParmList *parm_sublist, Wrapper
|
|||
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);
|
||||
}
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -840,7 +840,8 @@ SwigType *SwigType_typedef_resolve_all(SwigType *t) {
|
|||
*
|
||||
* 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 @@ SwigType *SwigType_typedef_qualified(SwigType *t) {
|
|||
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 @@ SwigType *SwigType_typedef_qualified(SwigType *t) {
|
|||
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)) {
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue