jyapayne/swig
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

add direct HashCheckAttr

Browse source 
git-svn-id: https://swig.svn.sourceforge.net/svnroot/swig/trunk/SWIG@7889 626c5289-ae23-0410-ae9c-e8d60b6d4f22
This commit is contained in:
Marcelo Matus 2005-11-27 09:58:26 +00:00
commit 72469f2d26
7 changed files with 136 additions and 77 deletions
Download patch file Download diff file Expand all files Collapse all files

5
Source/DOH/doh.h
View file

@ -42,7 +42,7 @@
#define DohCmp DOH_NAMESPACE(Cmp) #define DohCmp DOH_NAMESPACE(Cmp)
#define DohEqual DOH_NAMESPACE(Equal) #define DohEqual DOH_NAMESPACE(Equal)
#define DohIncref DOH_NAMESPACE(Incref) #define DohIncref DOH_NAMESPACE(Incref)
#define DohGetattr DOH_NAMESPACE(Getattr) #define DohCheckattr DOH_NAMESPACE(Checkattr)
#define DohSetattr DOH_NAMESPACE(Setattr) #define DohSetattr DOH_NAMESPACE(Setattr)
#define DohDelattr DOH_NAMESPACE(Delattr) #define DohDelattr DOH_NAMESPACE(Delattr)
#define DohKeys DOH_NAMESPACE(Keys) #define DohKeys DOH_NAMESPACE(Keys)
@ -108,6 +108,7 @@
#define DohCopyto DOH_NAMESPACE(Copyto) #define DohCopyto DOH_NAMESPACE(Copyto)
#define DohNewList DOH_NAMESPACE(NewList) #define DohNewList DOH_NAMESPACE(NewList)
#define DohNewHash DOH_NAMESPACE(NewHash) #define DohNewHash DOH_NAMESPACE(NewHash)
#define DohHashCheckAttr DOH_NAMESPACE(HashCheckAttr)
#define DohNewVoid DOH_NAMESPACE(NewVoid) #define DohNewVoid DOH_NAMESPACE(NewVoid)
#define DohSplit DOH_NAMESPACE(Split) #define DohSplit DOH_NAMESPACE(Split)
#define DohSplitLines DOH_NAMESPACE(SplitLines) #define DohSplitLines DOH_NAMESPACE(SplitLines)
@ -331,6 +332,7 @@ extern void DohSortList(DOH *lo, int (*cmp)(const DOH *, const DOH *));
* ----------------------------------------------------------------------------- */ * ----------------------------------------------------------------------------- */
extern DOHHash *DohNewHash(); extern DOHHash *DohNewHash();
extern int DohHashCheckAttr(DOH *hash, DOH *key, DOH *value);
/* ----------------------------------------------------------------------------- /* -----------------------------------------------------------------------------
* Void * Void
@ -414,6 +416,7 @@ extern void DohMemoryDebug(void);
#define NewStringWithSize DohNewStringWithSize #define NewStringWithSize DohNewStringWithSize
#define NewStringf DohNewStringf #define NewStringf DohNewStringf
#define NewHash DohNewHash #define NewHash DohNewHash
#define HashCheckAttr DohHashCheckAttr
#define NewList DohNewList #define NewList DohNewList
#define NewFile DohNewFile #define NewFile DohNewFile
#define NewFileFromFile DohNewFileFromFile #define NewFileFromFile DohNewFileFromFile

62
Source/DOH/hash.c
View file

@ -244,26 +244,58 @@ Hash_setattr(DOH *ho, DOH *k, DOH *obj) {
* *
* Get an attribute from the hash table. Returns 0 if it doesn't exist. * Get an attribute from the hash table. Returns 0 if it doesn't exist.
* ----------------------------------------------------------------------------- */ * ----------------------------------------------------------------------------- */
typedef int (*binop)(DOH *obj1, DOH *obj2);
#define _Hash_getattr(h, k, o) \
int hv = Hashval(k) % h->hashsize; \
DohObjInfo *k_type = ((DohBase*)k)->type; \
HashNode *n = h->hashtable[hv]; \
if (k_type->doh_equal) { \
binop equal = k_type->doh_equal; \
while (n) { \
DohBase *nk = (DohBase *)n->key; \
if ((k_type == nk->type) && equal(k, nk)) o = n->object; \
n = n->next; \
} \
} else { \
binop cmp = k_type->doh_cmp; \
while (n) { \
DohBase *nk = (DohBase *)n->key; \
if ((k_type == nk->type) && (cmp(k, nk) == 0)) o = n->object; \
n = n->next; \
} \
}
static DOH * static DOH *
Hash_getattr(DOH *ho, DOH *k) { Hash_getattr(DOH *h, DOH *k) {
int hv; DOH *obj = 0;
HashNode *n; Hash *ho = (Hash *) ObjData(h);
DohObjInfo *k_type; DOH *ko = DohCheck(k) ? k : find_key(k);
DohBase *nk; _Hash_getattr(ho, ko, obj);
return obj;
}
Hash *h = (Hash *) ObjData(ho);
if (!DohCheck(k)) k = find_key(k); /* -----------------------------------------------------------------------------
hv = Hashval(k) % h->hashsize; * Hash_checkattr()
n = h->hashtable[hv]; *
k_type = ((DohBase*)k)->type; * Get an attribute from the hash table. Returns 0 if it doesn't exist.
while (n) { * ----------------------------------------------------------------------------- */
nk = (DohBase *)n->key;
if ((k_type == nk->type) && ((k_type->doh_equal)(k, nk))) return n->object; int
n = n->next; DohHashCheckAttr(DOH *h, DOH *k, DOH *v) {
DOH *obj = 0;
Hash *ho = (Hash *) ObjData(h);
_Hash_getattr(ho, k, obj);
if (obj) {
DohObjInfo *o_type = ((DohBase*)obj)->type;
if (o_type == ((DohBase*)v)->type) {
binop equal = o_type->doh_equal;
return equal ? equal(obj, v) : (o_type->doh_cmp(obj, v) == 0);
} }
return 0; }
return 0;
} }
/* ----------------------------------------------------------------------------- /* -----------------------------------------------------------------------------

4
Source/DOH/string.c
View file

@ -988,7 +988,7 @@ DohNewString(const DOH *so)
char *s; char *s;
if (DohCheck(so)) { if (DohCheck(so)) {
str = (String *) ObjData(so); str = (String *) ObjData(so);
s = String_data(so); s = String_data((String *)so);
l = s ? str->len : 0; l = s ? str->len : 0;
} else { } else {
s = (char *) so; s = (char *) so;
@ -1029,7 +1029,7 @@ DohNewStringWithSize(const DOH *so, int len)
String *str; String *str;
char *s; char *s;
if (DohCheck(so)) { if (DohCheck(so)) {
s = String_data(so); s = String_data((String *)so);
} }
else { else {
s = (char *) so; s = (char *) so;

12
Source/Preprocessor/cpp.c
View file

@ -432,7 +432,7 @@ Hash *Preprocessor_define(const String_or_char *_str, int swigmacro)
} }
symbols = Getattr(cpp,k_symbols); symbols = Getattr(cpp,k_symbols);
if ((m1 = Getattr(symbols,macroname))) { if ((m1 = Getattr(symbols,macroname))) {
if (!StringEqual(Getattr(m1,k_value),macrovalue)) { if (!HashCheckAttr(m1,k_value,macrovalue)) {
Swig_error(Getfile(str),Getline(str),"Macro '%s' redefined,\n",macroname); Swig_error(Getfile(str),Getline(str),"Macro '%s' redefined,\n",macroname);
Swig_error(Getfile(m1),Getline(m1),"previous definition of '%s'.\n",macroname); Swig_error(Getfile(m1),Getline(m1),"previous definition of '%s'.\n",macroname);
goto macro_error; goto macro_error;
@ -858,7 +858,7 @@ List *evaluate_args(List *x) {
* which are then expanded. * which are then expanded.
* ----------------------------------------------------------------------------- */ * ----------------------------------------------------------------------------- */
/* #define SWIG_PUT_BUFF */ /* #define SWIG_PUT_BUFF */
DOH * DOH *
Preprocessor_replace(DOH *s) Preprocessor_replace(DOH *s)
@ -920,7 +920,7 @@ Preprocessor_replace(DOH *s)
StringUngetc(c,s); StringUngetc(c,s);
/* See if this is the special "defined" macro */ /* See if this is the special "defined" macro */
#ifndef SWIG_PUT_BUFF #ifndef SWIG_PUT_BUFF
if (StringEqual(id,k_defined)) { if (StringEqual(k_defined,id)) {
#else #else
if (strcmp(id,"defined") == 0) { if (strcmp(id,"defined") == 0) {
#endif #endif
@ -966,7 +966,7 @@ Preprocessor_replace(DOH *s)
break; break;
} }
#ifndef SWIG_PUT_BUFF #ifndef SWIG_PUT_BUFF
if (StringEqual(id,k_LINE)) { if (StringEqual(k_LINE,id)) {
#else #else
if (strcmp(id,"__LINE__") == 0) { if (strcmp(id,"__LINE__") == 0) {
#endif #endif
@ -975,7 +975,7 @@ Preprocessor_replace(DOH *s)
break; break;
} }
#ifndef SWIG_PUT_BUFF #ifndef SWIG_PUT_BUFF
if (StringEqual(id,k_FILE)) { if (StringEqual(k_FILE,id)) {
#else #else
if (strcmp(id,"__FILE__") == 0) { if (strcmp(id,"__FILE__") == 0) {
#endif #endif
@ -1046,7 +1046,7 @@ Preprocessor_replace(DOH *s)
if (state == 1) { if (state == 1) {
/* See if this is the special "defined" macro */ /* See if this is the special "defined" macro */
#ifndef SWIG_PUT_BUFF #ifndef SWIG_PUT_BUFF
if (StringEqual(id,k_defined)) { if (StringEqual(k_defined,id)) {
#else #else
if (strcmp(id,"defined") == 0) { if (strcmp(id,"defined") == 0) {
#endif #endif

5
Source/Swig/swig.h
View file

@ -537,6 +537,11 @@ extern void Swig_fragment_emit(String *name);
extern int Swig_need_protected(); extern int Swig_need_protected();
extern int Swig_director_mode(); extern int Swig_director_mode();
/* -- template init -- */
extern void SwigType_template_init();
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

119
Source/Swig/symbol.c
View file

@ -175,6 +175,8 @@ static Hash *symtabs = 0; /* Hash of all symbol tables by fully-qualifie
static Hash *global_scope = 0; /* Global scope */ static Hash *global_scope = 0; /* Global scope */
/* common attribute keys, to avoid calling find_key all the times */ /* common attribute keys, to avoid calling find_key all the times */
static String *k_allowstypedef = 0;
static String *k_cdecl = 0; static String *k_cdecl = 0;
static String *k_coloncolon = 0; static String *k_coloncolon = 0;
static String *k_constructor = 0; static String *k_constructor = 0;
@ -182,9 +184,11 @@ static String *k_csymnextSibling = 0;
static String *k_csympreviousSibling = 0; static String *k_csympreviousSibling = 0;
static String *k_csymtab = 0; static String *k_csymtab = 0;
static String *k_decl = 0; static String *k_decl = 0;
static String *k_empty = 0;
static String *k_enumitem = 0; static String *k_enumitem = 0;
static String *k_inherit = 0; static String *k_inherit = 0;
static String *k_name = 0; static String *k_name = 0;
static String *k_namespace = 0;
static String *k_nodetype = 0; static String *k_nodetype = 0;
static String *k_parentnode = 0; static String *k_parentnode = 0;
static String *k_storage = 0; static String *k_storage = 0;
@ -196,7 +200,12 @@ static String *k_symovername = 0;
static String *k_sympreviousSibling = 0; static String *k_sympreviousSibling = 0;
static String *k_symsymtab = 0; static String *k_symsymtab = 0;
static String *k_symtab = 0; static String *k_symtab = 0;
static String *k_symtypename = 0;
static String *k_symweak = 0;
static String *k_template = 0;
static String *k_templateparm = 0;
static String *k_templateparms = 0; static String *k_templateparms = 0;
static String *k_templatetype = 0;
static String *k_type = 0; static String *k_type = 0;
static String *k_typedef = 0; static String *k_typedef = 0;
static String *k_uname = 0; static String *k_uname = 0;
@ -209,7 +218,7 @@ void
Swig_symbol_dump_symtable() { Swig_symbol_dump_symtable() {
Printf(stdout, "DUMPING SYMTABLE start =======================================\n"); Printf(stdout, "DUMPING SYMTABLE start =======================================\n");
{ {
Hash* cst = Getattr(current_symtab, "csymtab"); Hash* cst = Getattr(current_symtab, k_csymtab);
Swig_print_tree(cst); Swig_print_tree(cst);
/* /*
Swig_print_tree(Getattr(cst, "NumSpace")); Swig_print_tree(Getattr(cst, "NumSpace"));
@ -227,6 +236,7 @@ Swig_symbol_dump_symtable() {
void void
Swig_symbol_init() { Swig_symbol_init() {
k_allowstypedef = NewString("allows_typedef");
k_cdecl = NewString("cdecl"); k_cdecl = NewString("cdecl");
k_coloncolon = NewString("::"); k_coloncolon = NewString("::");
k_constructor = NewString("constructor"); k_constructor = NewString("constructor");
@ -234,9 +244,11 @@ Swig_symbol_init() {
k_csympreviousSibling = NewString("csym:previousSibling"); k_csympreviousSibling = NewString("csym:previousSibling");
k_csymtab = NewString("csymtab"); k_csymtab = NewString("csymtab");
k_decl = NewString("decl"); k_decl = NewString("decl");
k_empty = NewString("empty");
k_enumitem = NewString("enumitem"); k_enumitem = NewString("enumitem");
k_inherit = NewString("inherit"); k_inherit = NewString("inherit");
k_name = NewString("name"); k_name = NewString("name");
k_namespace = NewString("namespace");
k_nodetype = NewString("nodeType"); k_nodetype = NewString("nodeType");
k_parentnode = NewString("parentNode"); k_parentnode = NewString("parentNode");
k_storage = NewString("storage"); k_storage = NewString("storage");
@ -248,7 +260,12 @@ Swig_symbol_init() {
k_sympreviousSibling = NewString("sym:previousSibling"); k_sympreviousSibling = NewString("sym:previousSibling");
k_symsymtab = NewString("sym:symtab"); k_symsymtab = NewString("sym:symtab");
k_symtab = NewString("symtab"); k_symtab = NewString("symtab");
k_symtypename = NewString("sym:typename");
k_symweak = NewString("sym:weak");
k_template = NewString("template");
k_templateparm = NewString("templateparm");
k_templateparms = NewString("templateparms"); k_templateparms = NewString("templateparms");
k_templatetype = NewString("templatetype");
k_type = NewString("type"); k_type = NewString("type");
k_typedef = NewString("typedef"); k_typedef = NewString("typedef");
k_uname = NewString("uname"); k_uname = NewString("uname");
@ -264,7 +281,7 @@ Swig_symbol_init() {
/* Set the global scope */ /* Set the global scope */
symtabs = NewHash(); symtabs = NewHash();
Setattr(symtabs,"",current_symtab); Setattr(symtabs,k_empty,current_symtab);
global_scope = current_symtab; global_scope = current_symtab;
} }
@ -277,7 +294,7 @@ Swig_symbol_init() {
void void
Swig_symbol_setscopename(const String_or_char *name) { Swig_symbol_setscopename(const String_or_char *name) {
String *qname; String *qname;
assert(!Getattr(current_symtab,k_name)); /* assert(!Getattr(current_symtab,k_name)); */
Setattr(current_symtab,k_name,name); Setattr(current_symtab,k_name,name);
/* Set nested scope in parent */ /* Set nested scope in parent */
@ -309,7 +326,7 @@ Swig_symbol_getscopename() {
Symtab * Symtab *
Swig_symbol_getscope(const String_or_char *name) { Swig_symbol_getscope(const String_or_char *name) {
if (!symtabs) return 0; if (!symtabs) return 0;
if (Strcmp(name,k_coloncolon) == 0) name = ""; if (StringEqual(k_coloncolon,(String_or_char *)name)) name = k_empty;
return Getattr(symtabs,name); return Getattr(symtabs,name);
} }
@ -496,7 +513,7 @@ Swig_symbol_cadd(String_or_char *name, Node *n) {
if (SwigType_istemplate(name)) { if (SwigType_istemplate(name)) {
String *cname = NewString(name); String *cname = NewString(name);
String *dname = Swig_symbol_template_deftype(cname,0); String *dname = Swig_symbol_template_deftype(cname,0);
if (Strcmp(dname,name)) { if (!StringEqual(dname,name)) {
Swig_symbol_cadd(dname, n); Swig_symbol_cadd(dname, n);
} }
Delete(dname); Delete(dname);
@ -508,20 +525,20 @@ Swig_symbol_cadd(String_or_char *name, Node *n) {
#endif #endif
cn = Getattr(ccurrent,name); cn = Getattr(ccurrent,name);
if (cn && (Getattr(cn,"sym:typename"))) { if (cn && (Getattr(cn,k_symtypename))) {
/* The node in the C symbol table is a typename. Do nothing */ /* The node in the C symbol table is a typename. Do nothing */
/* We might append the symbol at the end */ /* We might append the symbol at the end */
append = n; append = n;
} else if (cn && (Getattr(cn,"sym:weak"))) { } else if (cn && (Getattr(cn,k_symweak))) {
/* The node in the symbol table is weak. Replace it */ /* The node in the symbol table is weak. Replace it */
Setattr(ccurrent,name, n); Setattr(ccurrent,name, n);
} else if (cn && (Getattr(n,"sym:weak"))) { } else if (cn && (Getattr(n,k_symweak))) {
/* The node being added is weak. Don't worry about it */ /* The node being added is weak. Don't worry about it */
} else if (cn && (Getattr(n,"sym:typename"))) { } else if (cn && (Getattr(n,k_symtypename))) {
/* The node being added is a typename. We definitely add it */ /* The node being added is a typename. We definitely add it */
Setattr(ccurrent,name,n); Setattr(ccurrent,name,n);
append = cn; append = cn;
} else if (cn && (Strcmp(nodeType(cn),"templateparm") == 0)) { } else if (cn && (HashCheckAttr(cn, k_nodetype, k_templateparm))) {
Swig_error(Getfile(n),Getline(n), Swig_error(Getfile(n),Getline(n),
"Declaration of '%s' shadows template parameter,\n", "Declaration of '%s' shadows template parameter,\n",
name); name);
@ -567,7 +584,7 @@ Swig_symbol_cadd(String_or_char *name, Node *n) {
{ {
Node *td = n; Node *td = n;
while (td && (Strcmp(nodeType(td),k_cdecl) == 0) && (checkAttribute(td,k_storage,k_typedef))) { while (td && HashCheckAttr(td,k_nodetype,k_cdecl) && HashCheckAttr(td,k_storage,k_typedef)) {
SwigType *type; SwigType *type;
Node *td1; Node *td1;
type = Copy(Getattr(td,k_type)); type = Copy(Getattr(td,k_type));
@ -591,10 +608,10 @@ Swig_symbol_cadd(String_or_char *name, Node *n) {
ie, when Foo -> FooBar -> Foo, jump one scope up when possible. ie, when Foo -> FooBar -> Foo, jump one scope up when possible.
*/ */
if (td1 && checkAttribute(td1,k_storage,k_typedef)) { if (td1 && HashCheckAttr(td1,k_storage,k_typedef)) {
String *st = Getattr(td1,k_type); String *st = Getattr(td1,k_type);
String *sn = Getattr(td,k_name); String *sn = Getattr(td,k_name);
if (st && sn && (Strcmp(st, sn) == 0)) { if (st && sn && StringEqual(st, sn)) {
Symtab *sc = Getattr(current_symtab,k_parentnode); Symtab *sc = Getattr(current_symtab,k_parentnode);
if (sc) td1 = Swig_symbol_clookup(type,sc); if (sc) td1 = Swig_symbol_clookup(type,sc);
} }
@ -683,7 +700,7 @@ Swig_symbol_add(String_or_char *symname, Node *n) {
In this case, "Foo" sits in the symbol table. However, the In this case, "Foo" sits in the symbol table. However, the
definition of Foo would replace the entry if it appeared later. */ definition of Foo would replace the entry if it appeared later. */
if (c && Getattr(c,"sym:weak")) { if (c && Getattr(c,k_symweak)) {
c = 0; c = 0;
} }
if (c) { if (c) {
@ -698,7 +715,8 @@ Swig_symbol_add(String_or_char *symname, Node *n) {
*/ */
/* Check for namespaces */ /* Check for namespaces */
if ((Strcmp(nodeType(n),nodeType(c)) == 0) && ((Strcmp(nodeType(n),"namespace") == 0))) { String *ntype = Getattr(n, k_nodetype);
if ((StringEqual(ntype,Getattr(c,k_nodetype))) && ((StringEqual(ntype,k_namespace)))) {
Node *cl, *pcl = 0; Node *cl, *pcl = 0;
cl = c; cl = c;
while (cl) { while (cl) {
@ -711,8 +729,8 @@ Swig_symbol_add(String_or_char *symname, Node *n) {
Setattr(n,k_sympreviousSibling, pcl); Setattr(n,k_sympreviousSibling, pcl);
return n; return n;
} }
if (Getattr(n,"allows_typedef")) nt = 1; if (Getattr(n,k_allowstypedef)) nt = 1;
if (Getattr(c,"allows_typedef")) ct = 1; if (Getattr(c,k_allowstypedef)) ct = 1;
if (nt || ct) { if (nt || ct) {
Node *td, *other; Node *td, *other;
String *s; String *s;
@ -731,7 +749,7 @@ Swig_symbol_add(String_or_char *symname, Node *n) {
} }
/* Make sure the other node is a typedef */ /* Make sure the other node is a typedef */
s = Getattr(other,k_storage); s = Getattr(other,k_storage);
if (!s || (Strcmp(s,k_typedef))) return c; /* No. This is a conflict */ if (!s || (!StringEqual(s,k_typedef))) return c; /* No. This is a conflict */
/* Hmmm. This appears to be okay. Make sure the symbol table refers to the allow_type node */ /* Hmmm. This appears to be okay. Make sure the symbol table refers to the allow_type node */
@ -748,14 +766,14 @@ Swig_symbol_add(String_or_char *symname, Node *n) {
{ {
String *nt1, *nt2; String *nt1, *nt2;
nt1 = nodeType(n); nt1 = Getattr(n,k_nodetype);
if (Strcmp(nt1,"template") == 0) nt1 = Getattr(n,"templatetype"); if (StringEqual(nt1,k_template)) nt1 = Getattr(n,k_templatetype);
nt2 = nodeType(c); nt2 = Getattr(c,k_nodetype);
if (Strcmp(nt2,"template") == 0) nt2 = Getattr(c,"templatetype"); if (StringEqual(nt2,k_template)) nt2 = Getattr(c,k_templatetype);
if (Strcmp(nt1,"using") == 0) u1 = 1; if (StringEqual(nt1,k_using)) u1 = 1;
if (Strcmp(nt2,"using") == 0) u2 = 1; if (StringEqual(nt2,k_using)) u2 = 1;
if ((Strcmp(nt1,nt2) != 0) && !(u1 || u2)) return c; if ((!StringEqual(nt1,nt2)) && !(u1 || u2)) return c;
} }
if (!(u1 || u2)) { if (!(u1 || u2)) {
if ((!SwigType_isfunction(decl)) || (!SwigType_isfunction(ndecl))) { if ((!SwigType_isfunction(decl)) || (!SwigType_isfunction(ndecl))) {
@ -779,8 +797,9 @@ Swig_symbol_add(String_or_char *symname, Node *n) {
/* Okay. Walk down the list of symbols and see if we get a declarator match */ /* Okay. Walk down the list of symbols and see if we get a declarator match */
{ {
int n_template = (Strcmp(nodeType(n),"template") == 0) && (Strcmp(Getattr(n,"templatetype"),k_cdecl) == 0); String *nt = Getattr(n,k_nodetype);
int n_plain_cdecl = (Strcmp(nodeType(n),k_cdecl) == 0); int n_template = StringEqual(nt,k_template) && HashCheckAttr(n,k_templatetype,k_cdecl);
int n_plain_cdecl = StringEqual(nt,k_cdecl);
cn = c; cn = c;
pn = 0; pn = 0;
while (cn) { while (cn) {
@ -790,8 +809,9 @@ Swig_symbol_add(String_or_char *symname, Node *n) {
/* Declarator conflict */ /* Declarator conflict */
/* Now check we don't have a non-templated function overloaded by a templated function with same params, /* Now check we don't have a non-templated function overloaded by a templated function with same params,
* eg void foo(); template<typename> void foo(); */ * eg void foo(); template<typename> void foo(); */
int cn_template = (Strcmp(nodeType(cn),"template") == 0) && (Strcmp(Getattr(cn,"templatetype"),k_cdecl) == 0); String *cnt = Getattr(cn,k_nodetype);
int cn_plain_cdecl = (Strcmp(nodeType(cn),k_cdecl) == 0); int cn_template = StringEqual(cnt,k_template) && HashCheckAttr(cn,k_templatetype,k_cdecl);
int cn_plain_cdecl = StringEqual(cnt,k_cdecl);
if (!((n_template && cn_plain_cdecl) || (cn_template && n_plain_cdecl))) { if (!((n_template && cn_plain_cdecl) || (cn_template && n_plain_cdecl))) {
/* found a conflict */ /* found a conflict */
return cn; return cn;
@ -883,7 +903,7 @@ symbol_lookup(String_or_char *name, Symtab *symtab, int (*check)(Node *n)) {
String *dname = 0; String *dname = 0;
Setmark(symtab,0); Setmark(symtab,0);
dname = Swig_symbol_template_deftype(name,symtab); dname = Swig_symbol_template_deftype(name,symtab);
if (Strcmp(name,dname)) { if (!StringEqual(dname,name)) {
n = symbol_lookup(dname, symtab, check); n = symbol_lookup(dname, symtab, check);
} }
Delete(dname); Delete(dname);
@ -977,7 +997,7 @@ Swig_symbol_clookup(String_or_char *name, Symtab *n) {
if (!n) { if (!n) {
hsym = current_symtab; hsym = current_symtab;
} else { } else {
if (!checkAttribute(n,k_nodetype,k_symboltable)) { if (!HashCheckAttr(n,k_nodetype,k_symboltable)) {
n = Getattr(n,k_symsymtab); n = Getattr(n,k_symsymtab);
} }
assert(n); assert(n);
@ -1016,10 +1036,10 @@ Swig_symbol_clookup(String_or_char *name, Symtab *n) {
return 0; return 0;
} }
/* Check if s is a 'using' node */ /* Check if s is a 'using' node */
while (s && checkAttribute(s,k_nodetype,k_using)) { while (s && HashCheckAttr(s,k_nodetype,k_using)) {
String *uname = Getattr(s,k_uname); String *uname = Getattr(s,k_uname);
Symtab *un = Getattr(s,k_symsymtab); Symtab *un = Getattr(s,k_symsymtab);
Node *ss = (Strcmp(name,uname) || (un != n)) ? Node *ss = (!StringEqual(name,uname) || (un != n)) ?
Swig_symbol_clookup(uname, un) : 0; /* avoid infinity loop */ Swig_symbol_clookup(uname, un) : 0; /* avoid infinity loop */
if (!ss) { if (!ss) {
Swig_warning(WARN_PARSE_USING_UNDEF, Getfile(s), Getline(s), "Nothing known about '%s'.\n", Getattr(s,k_uname)); Swig_warning(WARN_PARSE_USING_UNDEF, Getfile(s), Getline(s), "Nothing known about '%s'.\n", Getattr(s,k_uname));
@ -1047,7 +1067,7 @@ Swig_symbol_clookup_check(String_or_char *name, Symtab *n, int (*checkfunc)(Node
if (!n) { if (!n) {
hsym = current_symtab; hsym = current_symtab;
} else { } else {
if (!checkAttribute(n,k_nodetype,k_symboltable)) { if (!HashCheckAttr(n,k_nodetype,k_symboltable)) {
n = Getattr(n,k_symsymtab); n = Getattr(n,k_symsymtab);
} }
assert(n); assert(n);
@ -1086,7 +1106,7 @@ Swig_symbol_clookup_check(String_or_char *name, Symtab *n, int (*checkfunc)(Node
return 0; return 0;
} }
/* Check if s is a 'using' node */ /* Check if s is a 'using' node */
while (s && checkAttribute(s,k_nodetype,k_using)) { while (s && HashCheckAttr(s,k_nodetype,k_using)) {
Node *ss; Node *ss;
ss = Swig_symbol_clookup(Getattr(s,k_uname), Getattr(s,k_symsymtab)); ss = Swig_symbol_clookup(Getattr(s,k_uname), Getattr(s,k_symsymtab));
if (!ss && !checkfunc) { if (!ss && !checkfunc) {
@ -1110,7 +1130,7 @@ Swig_symbol_clookup_local(String_or_char *name, Symtab *n) {
hsym = current_symtab; hsym = current_symtab;
h = ccurrent; h = ccurrent;
} else { } else {
if (!checkAttribute(n,k_nodetype,k_symboltable)) { if (!HashCheckAttr(n,k_nodetype,k_symboltable)) {
n = Getattr(n,k_symsymtab); n = Getattr(n,k_symsymtab);
} }
assert(n); assert(n);
@ -1134,7 +1154,7 @@ Swig_symbol_clookup_local(String_or_char *name, Symtab *n) {
} }
if (!s) return 0; if (!s) return 0;
/* Check if s is a 'using' node */ /* Check if s is a 'using' node */
while (s && checkAttribute(s,k_nodetype,k_using)) { while (s && HashCheckAttr(s,k_nodetype,k_using)) {
Node *ss = Swig_symbol_clookup_local(Getattr(s,k_uname), Getattr(s,k_symsymtab)); Node *ss = Swig_symbol_clookup_local(Getattr(s,k_uname), Getattr(s,k_symsymtab));
if (!ss) { if (!ss) {
Swig_warning(WARN_PARSE_USING_UNDEF, Getfile(s), Getline(s), "Nothing known about '%s'.\n", Getattr(s,k_uname)); Swig_warning(WARN_PARSE_USING_UNDEF, Getfile(s), Getline(s), "Nothing known about '%s'.\n", Getattr(s,k_uname));
@ -1157,7 +1177,7 @@ Swig_symbol_clookup_local_check(String_or_char *name, Symtab *n, int (*checkfunc
hsym = current_symtab; hsym = current_symtab;
h = ccurrent; h = ccurrent;
} else { } else {
if (!checkAttribute(n,k_nodetype,k_symboltable)) { if (!HashCheckAttr(n,k_nodetype,k_symboltable)) {
n = Getattr(n,k_symsymtab); n = Getattr(n,k_symsymtab);
} }
assert(n); assert(n);
@ -1181,7 +1201,7 @@ Swig_symbol_clookup_local_check(String_or_char *name, Symtab *n, int (*checkfunc
} }
if (!s) return 0; if (!s) return 0;
/* Check if s is a 'using' node */ /* Check if s is a 'using' node */
while (s && checkAttribute(s,k_nodetype,k_using)) { while (s && HashCheckAttr(s,k_nodetype,k_using)) {
Node *ss = Swig_symbol_clookup_local_check(Getattr(s,k_uname), Getattr(s,k_symsymtab),checkfunc); Node *ss = Swig_symbol_clookup_local_check(Getattr(s,k_uname), Getattr(s,k_symsymtab),checkfunc);
if (!ss && !checkfunc) { if (!ss && !checkfunc) {
Swig_warning(WARN_PARSE_USING_UNDEF, Getfile(s), Getline(s), "Nothing known about '%s'.\n", Getattr(s,k_uname)); Swig_warning(WARN_PARSE_USING_UNDEF, Getfile(s), Getline(s), "Nothing known about '%s'.\n", Getattr(s,k_uname));
@ -1293,7 +1313,7 @@ Swig_symbol_remove(Node *n) {
String * String *
Swig_symbol_qualified(Node *n) { Swig_symbol_qualified(Node *n) {
Hash *symtab; Hash *symtab;
if (checkAttribute(n,k_nodetype,k_symboltable)) { if (HashCheckAttr(n,k_nodetype,k_symboltable)) {
symtab = n; symtab = n;
} else { } else {
symtab = Getattr(n,k_symsymtab); symtab = Getattr(n,k_symsymtab);
@ -1326,7 +1346,7 @@ static int no_constructor(Node *n) {
#ifdef SWIG_DEBUG #ifdef SWIG_DEBUG
Printf(stderr,"node type %s\n", Getattr(n,k_name), type); Printf(stderr,"node type %s\n", Getattr(n,k_name), type);
#endif #endif
return !checkAttribute(n, k_nodetype, k_constructor); return !HashCheckAttr(n, k_nodetype, k_constructor);
} }
static SwigType * static SwigType *
@ -1342,7 +1362,7 @@ Swig_symbol_template_qualify(const SwigType *e, Symtab *st) {
qprefix = Swig_symbol_type_qualify(tprefix,st); qprefix = Swig_symbol_type_qualify(tprefix,st);
targs = SwigType_parmlist(e); targs = SwigType_parmlist(e);
tempn = Swig_symbol_clookup_local(tprefix,st); tempn = Swig_symbol_clookup_local(tprefix,st);
tscope = tempn ? Getattr(tempn,"sym:symtab") : 0; tscope = tempn ? Getattr(tempn,k_symsymtab) : 0;
Printf(qprefix,"<("); Printf(qprefix,"<(");
for (ti = First(targs); ti.item;) { for (ti = First(targs); ti.item;) {
String *vparm; String *vparm;
@ -1523,7 +1543,7 @@ SwigType *Swig_symbol_typedef_reduce(SwigType *ty, Symtab *tab) {
} }
} }
nt = Getattr(n,k_nodetype); nt = Getattr(n,k_nodetype);
if (Strcmp(nt,k_using) == 0) { if (StringEqual(nt,k_using)) {
String *uname = Getattr(n,k_uname); String *uname = Getattr(n,k_uname);
if (uname) { if (uname) {
n = Swig_symbol_clookup(base,Getattr(n,k_symsymtab)); n = Swig_symbol_clookup(base,Getattr(n,k_symsymtab));
@ -1537,9 +1557,9 @@ SwigType *Swig_symbol_typedef_reduce(SwigType *ty, Symtab *tab) {
} }
} }
} }
if (Strcmp(nt,k_cdecl) == 0) { if (StringEqual(nt,k_cdecl)) {
String *storage = Getattr(n,k_storage); String *storage = Getattr(n,k_storage);
if (storage && (Strcmp(storage,k_typedef) == 0)) { if (storage && (StringEqual(storage,k_typedef))) {
SwigType *decl; SwigType *decl;
SwigType *rt; SwigType *rt;
SwigType *qt; SwigType *qt;
@ -1746,13 +1766,12 @@ Swig_symbol_template_deftype(const SwigType *type, Symtab *tscope) {
Symtab *tsdecl = Getattr(tempn,k_symsymtab); Symtab *tsdecl = Getattr(tempn,k_symsymtab);
#ifdef SWIG_DEBUG #ifdef SWIG_DEBUG
Printf(stderr,"deftype type %s %s %s\n", tprefix, targs, Printf(stderr,"deftype type %s %s %s\n", tprefix, targs,tsuffix);
tsuffix);
#endif #endif
Append(tprefix,"<("); Append(tprefix,"<(");
Swig_symbol_template_defargs(tparms, tnargs,tscope,tsdecl); Swig_symbol_template_defargs(tparms, tnargs,tscope,tsdecl);
p = tparms; p = tparms;
tscope = Getattr(tempn,"sym:symtab"); tscope = tsdecl;
while (p) { while (p) {
SwigType *ptype = Getattr(p,k_type); SwigType *ptype = Getattr(p,k_type);
SwigType *ttr = ptype ? ptype : Getattr(p,k_value); SwigType *ttr = ptype ? ptype : Getattr(p,k_value);
@ -1809,7 +1828,7 @@ SwigType *Swig_symbol_template_param_eval(const SwigType *p, Symtab *symtab)
lastnode = n; lastnode = n;
if (n) { if (n) {
String *nt = Getattr(n,k_nodetype); String *nt = Getattr(n,k_nodetype);
if (Strcmp(nt,k_enumitem) == 0) { if (StringEqual(nt,k_enumitem)) {
/* An enum item. Generate a fully qualified name */ /* An enum item. Generate a fully qualified name */
String *qn = Swig_symbol_qualified(n); String *qn = Swig_symbol_qualified(n);
if (Len(qn)) { if (Len(qn)) {
@ -1822,7 +1841,7 @@ SwigType *Swig_symbol_template_param_eval(const SwigType *p, Symtab *symtab)
Delete(qn); Delete(qn);
break; break;
} }
} else if ((Strcmp(nt,k_cdecl) == 0)) { } else if ((StringEqual(nt,k_cdecl))) {
String *nv = Getattr(n,k_value); String *nv = Getattr(n,k_value);
if (nv) { if (nv) {
Delete(value); Delete(value);

6
Source/Swig/typemap.c
View file

@ -661,7 +661,7 @@ Swig_typemap_search(const String_or_char *op, SwigType *type, const String_or_ch
if (!unstripped) { if (!unstripped) {
unstripped = ctype; unstripped = ctype;
ctype = SwigType_strip_qualifiers(ctype); ctype = SwigType_strip_qualifiers(ctype);
if (Strcmp(ctype,unstripped) != 0) continue; /* Types are different */ if (!StringEqual(ctype,unstripped)) continue; /* Types are different */
Delete(ctype); Delete(ctype);
ctype = unstripped; ctype = unstripped;
unstripped = 0; unstripped = 0;
@ -1325,7 +1325,7 @@ Printf(stdout, "Swig_typemap_lookup %s [%s %s]\n", op, type, pname ? pname : "NO
Delete(locals); Delete(locals);
} }
if (checkAttribute(tm,k_type,k_SWIGTYPE)) { if (HashCheckAttr(tm,k_type,k_SWIGTYPE)) {
sprintf(temp,"%s:SWIGTYPE", Char(op)); sprintf(temp,"%s:SWIGTYPE", Char(op));
Setattr(node,tmop_name(temp),k_one); Setattr(node,tmop_name(temp),k_one);
} }
@ -1499,7 +1499,7 @@ Swig_typemap_attach_parms(const String_or_char *op, ParmList *parms, Wrapper *f)
typemap_replace_vars(s,locals,type,type,pname,lname,i+1); typemap_replace_vars(s,locals,type,type,pname,lname,i+1);
} }
if (checkAttribute(tm,k_type,k_SWIGTYPE)) { if (HashCheckAttr(tm,k_type,k_SWIGTYPE)) {
sprintf(temp,"%s:SWIGTYPE", Char(op)); sprintf(temp,"%s:SWIGTYPE", Char(op));
Setattr(p,tmop_name(temp),k_one); Setattr(p,tmop_name(temp),k_one);
} }