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

Move rename/namewarn engine from parser.y to naming.c. The code was getting

Browse source 
too large to be in the parser.

Centralize the swig keys to avoid replication and wrong spellings.

Use more HashGetAttr where possible and other speed improvements
to compensate for the extra work introduced by the new rename/namewarn
mechanism.


git-svn-id: https://swig.svn.sourceforge.net/svnroot/swig/trunk/SWIG@8170 626c5289-ae23-0410-ae9c-e8d60b6d4f22
This commit is contained in:
Marcelo Matus 2006-01-02 04:33:19 +00:00
commit 55005e98ee
18 changed files with 938 additions and 823 deletions
Download patch file Download diff file Expand all files Collapse all files

14
Source/CParse/cparse.h
View file

@ -43,8 +43,6 @@ extern int yylex();
/* parser.y */
extern SwigType *Swig_cparse_type(String *);
extern Node *Swig_cparse(File *);
extern String *Swig_cparse_name_warning(Node *n, String *prefix, String *name,SwigType *decl);
extern String *Swig_cparse_symbol_name(Node *n,String *prefix, String *name, SwigType *decl, String *oldname);
extern Hash *Swig_cparse_features();
extern void SWIG_cparse_set_compact_default_args(int defargs);
extern int SWIG_cparse_template_reduce(int treduce);
@ -52,10 +50,7 @@ extern int SWIG_cparse_template_reduce(int treduce);
/* util.c */
extern void Swig_cparse_replace_descriptor(String *s);
extern void cparse_normalize_void(Node *);
extern int need_protected(Node *n, int dirprot_mode);
extern Parm *Swig_cparse_parm(String *s);
extern int need_name_warning(Node *n);
extern int need_redefined_warn(Node* a, Node* b, int InClass);
/* templ.c */
@ -67,5 +62,14 @@ extern void Swig_cparse_debug_templates(int);
}
#endif
#define SWIG_WARN_NODE_BEGIN(Node) \
{ \
String *wrnfilter = Node ? Getattr(Node,"feature:warnfilter") : 0; \
if (wrnfilter) Swig_warnfilter(wrnfilter,1)
#define SWIG_WARN_NODE_END(Node) \
if (wrnfilter) Swig_warnfilter(wrnfilter,0); \
}
#endif

430
Source/CParse/parser.y
View file

@ -54,7 +54,6 @@ static char *last_cpptype = 0;
static int inherit_list = 0;
static Parm *template_parameters = 0;
static int extendmode = 0;
static int dirprot_mode = 0;
static int compact_default_args = 0;
static int template_reduce = 0;
static int cparse_externc = 0;
@ -63,14 +62,6 @@ static int cparse_externc = 0;
* Assist Functions
* ----------------------------------------------------------------------------- */
#define SWIG_WARN_NODE_BEGIN(Node) \
{ \
String *wrnfilter = Node ? Getattr(Node,"feature:warnfilter") : 0; \
if (wrnfilter) Swig_warnfilter(wrnfilter,1)
#define SWIG_WARN_NODE_END(Node) \
if (wrnfilter) Swig_warnfilter(wrnfilter,0); \
}
/* Called by the parser (yyparse) when an error is found.*/
@ -204,41 +195,16 @@ static int promote(int t1, int t2) {
static String *yyrename = 0;
/* Forward renaming operator */
static Hash *rename_hash = 0;
static Hash *namewarn_hash = 0;
static Hash *features_hash = 0;
static List *rename_list = 0;
static List *namewarn_list = 0;
static String *resolve_node_scope(String *cname);
Hash *Swig_cparse_namewarn_hash() {
if (!namewarn_hash) namewarn_hash = NewHash();
return namewarn_hash;
}
Hash *Swig_cparse_rename_hash() {
if (!rename_hash) rename_hash = NewHash();
return rename_hash;
}
Hash *Swig_cparse_features() {
static Hash *features_hash = 0;
if (!features_hash) features_hash = NewHash();
return features_hash;
}
List *Swig_cparse_namewarn_list() {
if (!namewarn_list) namewarn_list = NewList();
return namewarn_list;
}
List *Swig_cparse_rename_list() {
if (!rename_list) rename_list = NewList();
return rename_list;
}
static String *feature_identifier_fix(String *s) {
if (SwigType_istemplate(s)) {
String *tp, *ts, *ta, *tq;
@ -257,317 +223,20 @@ static String *feature_identifier_fix(String *s) {
}
}
static void
Swig_cparse_add_name_object(Hash *name_hash, List *name_list,
String *prefix, const char *name, SwigType *decl, Hash *nameobj) {
String *nname = 0;
if (name && Len(name)) {
String *target_fmt = Getattr(nameobj,"target_fmt");
nname = prefix ? NewStringf("%s::%s",prefix, name) : NewString(name);
if (target_fmt) {
String *tmp = NewStringf(Getattr(nameobj,"target_fmt"), nname);
Delete(nname);
nname = tmp;
}
}
if (!nname || !Len(nname) || Getattr(nameobj,"source_fmt")) {
if (decl) Setattr(nameobj,"decl", decl);
if (nname && Len(nname)) Setattr(nameobj,"target_name", nname);
Append(name_list, nameobj);
} else {
Swig_name_object_set(name_hash,nname,decl,nameobj);
}
Delete(nname);
}
static void single_rename_add(const char *name, SwigType *decl, Hash *newname) {
Swig_cparse_add_name_object(Swig_cparse_rename_hash(), Swig_cparse_rename_list(),
Namespaceprefix, name, decl, newname);
}
static void Swig_name_object_attach_keys(const char *keys[], Hash *nameobj)
{
Node *kw = nextSibling(nameobj);
while (kw) {
Node *next = nextSibling(kw);
String *kname = Getattr(kw,"name");
char *ckey = kname ? Char(kname) : 0;
if (ckey) {
const char **rkey;
for (rkey = keys; *rkey != 0; ++rkey) {
if (strcmp(ckey,*rkey) == 0) {
Setattr(nameobj, *rkey, Getattr(kw,"value"));
deleteNode(kw);
}
}
}
kw = next;
}
}
/* Add a new rename. Works much like new_feature including default argument handling. */
static void rename_add(const char *name, SwigType *decl, Hash *newname, ParmList *declaratorparms) {
ParmList *declparms = declaratorparms;
const char *rename_keys[] = {"fullname", "source_fmt", "target_fmt", 0};
Swig_name_object_attach_keys(rename_keys, newname);
/* Add the name */
single_rename_add(name, decl, newname);
/* Add extra names if there are default parameters in the parameter list */
if (decl) {
int constqualifier = SwigType_isconst(decl);
while (declparms) {
if (ParmList_has_defaultargs(declparms)) {
/* Create a parameter list for the new rename by copying all
but the last (defaulted) parameter */
ParmList* newparms = ParmList_copy_all_except_last_parm(declparms);
/* Create new declaration - with the last parameter removed */
SwigType *newdecl = Copy(decl);
Delete(SwigType_pop_function(newdecl)); /* remove the old parameter list from newdecl */
SwigType_add_function(newdecl,newparms);
if (constqualifier)
SwigType_add_qualifier(newdecl,"const");
single_rename_add(name, newdecl, newname);
declparms = newparms;
Delete(newdecl);
} else {
declparms = 0;
}
}
}
}
static void namewarn_add(const char *name, SwigType *decl, Hash *namewrn) {
const char *namewrn_keys[] = {"rename", "error", "fullname", "source_fmt", "target_fmt", 0};
Swig_name_object_attach_keys(namewrn_keys, namewrn);
Swig_cparse_add_name_object(Swig_cparse_namewarn_hash(), Swig_cparse_namewarn_list(),
Namespaceprefix, name, decl, namewrn);
}
static void rename_inherit(String *base, String *derived) {
/* Printf(stdout,"base = '%s', derived = '%s'\n", base, derived); */
Swig_name_object_inherit(Swig_cparse_rename_hash(),base,derived);
Swig_name_object_inherit(Swig_cparse_namewarn_hash(),base,derived);
Swig_name_object_inherit(features_hash,base,derived);
}
/* Generate the symbol table name for an object */
/* This is a bit of a mess. Need to clean up */
static String *add_oldname = 0;
DOH *Swig_node_getattr(Node *n, const char *cattr)
{
const char *rattr = strstr(cattr,"$");
if (rattr) {
String *nattr = NewStringWithSize(cattr, rattr-cattr);
Node *rn = Getattr(n,nattr);
if (rn) {
DOH *res = Swig_node_getattr(rn, rattr + 1);
Delete(nattr);
return res;
} else {
return 0;
}
} else {
return Getattr(n,cattr);
}
}
int Swig_cparse_match(Hash *rn, Node *n) {
int match = 1;
Node *kw = nextSibling(rn);
while (match && kw) {
String *key = Getattr(kw,"name");
char *ckey = key ? Char(key) : 0;
if (ckey && (strncmp(ckey,"match",5) == 0)) {
match = 0;
if (n) {
const char *csep = strstr(ckey,"$");
const char *cattr = csep ? csep + 1 : "nodeType";
String *nval = Swig_node_getattr(n,cattr);
String *kwval = Getattr(kw,"value");
if (nval && Equal(nval, kwval)) {
match = 1;
}
}
}
kw = nextSibling(kw);
}
return match;
}
Hash *Swig_cparse_name_object(List *namelist, Node *n, String *prefix, String *name, String *decl) {
Hash *res = 0;
if (namelist) {
int len = Len(namelist);
int i;
int match = 0;
for (i = 0; !match && (i < len); i++) {
Hash *rn = Getitem(namelist,i);
String *rdecl = Getattr(rn,"decl");
if (rdecl && (!decl || !Equal(rdecl,decl))) {
continue;
} else {
String *tname = Getattr(rn,"target_name");
String *sfmt = Getattr(rn,"source_fmt");
String *sname = 0;
int fullname = GetFlag(namelist,"fullname");
if (sfmt) {
if (fullname && prefix) {
sname = NewStringf(sfmt, prefix, name);
} else {
sname = NewStringf(sfmt, name);
}
} else {
if (fullname && prefix) {
sname = NewStringf("%s::%s", prefix, name);
} else {
sname = NewString(name);
}
}
match = (!tname || Equal(sname,tname)) && Swig_cparse_match(rn, n);
Delete(sname);
}
if (match) {
res = rn;
break;
}
}
}
return res;
}
/* Return the node name when it requires to emit a name warning */
Hash *Swig_cparse_warning_object(Node *n, String *prefix, String *name,SwigType *decl) {
if (n) {
/* Return in the obvious cases */
if (!Swig_cparse_namewarn_hash() || !name || !need_name_warning(n)) {
return 0;
} else {
String *access = Getattr(n,"access");
int is_public = !access || (Strcmp(access,"public") == 0);
if (!is_public && !need_protected(n,dirprot_mode)) {
return 0;
}
}
}
if (name) {
/* Check to see if the name is in the hash */
Hash *wrn = Swig_name_object_get(Swig_cparse_namewarn_hash(),prefix,name,decl);
if (!wrn || !Swig_cparse_match(wrn, n)) {
wrn = Swig_cparse_name_object(Swig_cparse_namewarn_list(), n, prefix, name, decl);
}
if (wrn && Getattr(wrn,"error")) {
if (n) {
Swig_error(Getfile(n), Getline(n), "%s\n", Getattr(wrn,"name"));
} else {
Swig_error(cparse_file, cparse_line,"%s\n", Getattr(wrn,"name"));
}
}
return wrn;
} else {
return 0;
}
}
String *Swig_cparse_name_warning(Node *n, String *prefix, String *name,SwigType *decl) {
Hash *wrn = Swig_cparse_warning_object(n, prefix, name,decl);
return (name && wrn) ? Getattr(wrn,"name") : 0;
}
/* Create a name applying rename/namewarn if needed */
String *apply_rename(String *newname, int fullname, String *prefix, String *name)
{
String *result = 0;
if (newname) {
if (Strcmp(newname,"$ignore") == 0) {
result = Copy(newname);
} else {
int destructor = name && (*(Char(name)) == '~');
String *fmt = newname;
String *tmp = 0;
if (destructor && (*(Char(newname)) != '~')) {
fmt = tmp = NewStringf("~%s", newname);
}
/* use name as a fmt, but avoid C++ "%" and "%=" operators */
if (Len(newname) > 1 && strstr(Char(newname),"%") && !Equal(newname,"%=")) {
if (fullname && prefix) {
result = NewStringf(fmt,prefix,name);
} else {
result = NewStringf(fmt,name);
}
} else {
result = Copy(newname);
}
if (tmp) Delete(tmp);
}
}
return result;
}
String *
Swig_cparse_symbol_name(Node *n, String *prefix, String *name, SwigType *decl, String *oldname) {
String *nname = 0;
String *result = 0;
Hash *wrn = 0;
Hash *rn = Swig_name_object_get(Swig_cparse_rename_hash(), prefix, name, decl);
if (!rn || !Swig_cparse_match(rn,n)) {
rn = Swig_cparse_name_object(Swig_cparse_rename_list(), n, prefix, name, decl);
}
if (rn) {
String *newname = Getattr(rn,"name");
int fullname = GetFlag(rn,"fullname");
result = apply_rename(newname, fullname, prefix, name);
}
nname = result ? result : name;
wrn = Swig_cparse_warning_object(n, prefix, nname, decl);
if (wrn) {
String *rename = Getattr(wrn,"rename");
if (rename) {
String *msg = Getattr(wrn,"name");
int fullname = GetFlag(wrn,"fullname");
if (result) Delete(result);
result = apply_rename(rename, fullname, prefix, name);
if ((msg) && (Len(msg))) {
if (n) {
SWIG_WARN_NODE_BEGIN(n);
Swig_warning(0,Getfile(n), Getline(n), "%s\n", msg);
SWIG_WARN_NODE_END(n);
} else {
Swig_warning(0,Getfile(name),Getline(name), "%s\n", msg);
}
}
}
}
if (!result || !Len(result)) {
if (result) Delete(result);
result = oldname ? Copy(oldname): Copy(name);
}
return result;
}
static String *make_name(Node *n, String *name,SwigType *decl) {
String *origname = name;
int destructor = name && (*(Char(name)) == '~');
if (yyrename) {
String *s = (yyrename);
yyrename = 0;
if (destructor) {
if (destructor && (*(Char(s)) != '~')) {
Insert(s,0,"~");
}
return s;
@ -575,11 +244,7 @@ static String *make_name(Node *n, String *name,SwigType *decl) {
if (!name) return 0;
/* Check to see if the name is in the hash */
if (!rename_hash) {
if (add_oldname) return Copy(add_oldname);
return Copy(origname);
}
return Swig_cparse_symbol_name(n,Namespaceprefix,name,decl,add_oldname);
return Swig_name_make(n,Namespaceprefix,name,decl,add_oldname);
}
/* Generate an unnamed identifier */
@ -661,13 +326,13 @@ static void add_symbols(Node *n) {
int only_csymbol = 1;
if (cplus_mode == CPLUS_PROTECTED) {
Setattr(n,"access", "protected");
only_csymbol = !need_protected(n, dirprot_mode);
only_csymbol = !Swig_need_protected(n);
} else {
/* private are needed only when they are pure virtuals */
Setattr(n,"access", "private");
if ((Cmp(Getattr(n,"storage"),"virtual") == 0)
&& (Cmp(Getattr(n,"value"),"0") == 0)) {
only_csymbol = !need_protected(n, dirprot_mode);
only_csymbol = !Swig_need_protected(n);
}
}
if (only_csymbol) {
@ -697,17 +362,17 @@ static void add_symbols(Node *n) {
symname = Copy(Getattr(n,"unnamed"));
}
if (symname) {
wrn = Swig_cparse_name_warning(n, Namespaceprefix, symname,0);
Swig_features_get(features_hash, Namespaceprefix, Getattr(n,"name"), 0, n);
wrn = Swig_name_warning(n, Namespaceprefix, symname,0);
Swig_features_get(Swig_cparse_features(), Namespaceprefix, Getattr(n,"name"), 0, n);
}
} else {
SwigType *fdecl = Copy(decl);
SwigType *fun = SwigType_pop_function(fdecl);
symname = make_name(n, Getattr(n,"name"),fun);
wrn = Swig_cparse_name_warning(n, Namespaceprefix,symname,fun);
wrn = Swig_name_warning(n, Namespaceprefix,symname,fun);
Swig_features_get(features_hash,Namespaceprefix,Getattr(n,"name"),fun,n);
Swig_features_get(Swig_cparse_features(),Namespaceprefix,Getattr(n,"name"),fun,n);
Delete(fdecl);
Delete(fun);
@ -746,7 +411,7 @@ static void add_symbols(Node *n) {
String *e = NewStringEmpty();
String *en = NewStringEmpty();
String *ec = NewStringEmpty();
int redefined = need_redefined_warn(n,c,inclass);
int redefined = Swig_need_redefined_warn(n,c,inclass);
if (redefined) {
Printf(en,"Identifier '%s' redefined (ignored)",symname);
Printf(ec,"previous definition of '%s'",symname);
@ -1083,7 +748,7 @@ static List *make_inherit_list(String *clsname, List *names) {
base = NewString(n);
}
if (base) {
rename_inherit(base,derived);
Swig_name_inherit(base,derived);
Delete(base);
}
}
@ -1390,7 +1055,6 @@ static void single_new_feature(const char *featurename, String *val, Hash *featu
/* Printf(stdout, "single_new_feature: [%s] [%s] [%s] [%s] [%s] [%s]\n", featurename, val, declaratorid, t, ParmList_str_defaultargs(declaratorparms), qualifier); */
if (!features_hash) features_hash = NewHash();
fname = NewStringf("feature:%s",featurename);
if (declaratorid) {
fixname = feature_identifier_fix(declaratorid);
@ -1411,20 +1075,20 @@ static void single_new_feature(const char *featurename, String *val, Hash *featu
SwigType *decl = SwigType_pop_function(t);
if (SwigType_ispointer(t)) {
String *nname = NewStringf("*%s",name);
Swig_feature_set(features_hash, nname, decl, fname, val, featureattribs);
Swig_feature_set(Swig_cparse_features(), nname, decl, fname, val, featureattribs);
Delete(nname);
} else {
Swig_feature_set(features_hash, name, decl, fname, val, featureattribs);
Swig_feature_set(Swig_cparse_features(), name, decl, fname, val, featureattribs);
}
Delete(decl);
} else if (SwigType_ispointer(t)) {
String *nname = NewStringf("*%s",name);
Swig_feature_set(features_hash,nname,0,fname,val, featureattribs);
Swig_feature_set(Swig_cparse_features(),nname,0,fname,val, featureattribs);
Delete(nname);
}
} else {
/* Global feature, that is, feature not associated with any particular symbol */
Swig_feature_set(features_hash,name,0,fname,val, featureattribs);
Swig_feature_set(Swig_cparse_features(),name,0,fname,val, featureattribs);
}
Delete(fname);
Delete(name);
@ -2271,12 +1935,7 @@ module_directive: MODULE options idstring {
if ($2) {
Setattr($$,"options",$2);
if (Getattr($2,"directors")) {
/*
we set dirprot_mode here to 1, just to save the
symbols. Later, the language module must decide
what to do with them.
*/
dirprot_mode = 1;
/* Wrapper_director_mode_set(1);*/
}
if (Getattr($2,"templatereduce")) {
template_reduce = 1;
@ -2389,9 +2048,9 @@ rename_directive : rename_namewarn declarator idstring SEMI {
if (!Len(t)) t = 0;
if ($1) {
rename_add($2.id,t,kws,$2.parms);
Swig_name_rename_add(Namespaceprefix,$2.id,t,kws,$2.parms);
} else {
namewarn_add($2.id,t,kws);
Swig_name_namewarn_add(Namespaceprefix,$2.id,t,kws);
}
$$ = 0;
scanner_clear_rename();
@ -2409,33 +2068,33 @@ rename_directive : rename_namewarn declarator idstring SEMI {
if (SwigType_ispointer(t)) {
String *nname = NewStringf("*%s",fixname);
if ($1) {
rename_add(Char(nname),decl,$3,$5.parms);
Swig_name_rename_add(Namespaceprefix, nname,decl,$3,$5.parms);
} else {
namewarn_add(Char(nname),decl,$3);
Swig_name_namewarn_add(Namespaceprefix,nname,decl,$3);
}
Delete(nname);
} else {
if ($1) {
rename_add(Char(fixname),decl,$3,$5.parms);
Swig_name_rename_add(Namespaceprefix,(fixname),decl,$3,$5.parms);
} else {
namewarn_add(Char(fixname),decl,$3);
Swig_name_namewarn_add(Namespaceprefix,(fixname),decl,$3);
}
}
Delete(decl);
} else if (SwigType_ispointer(t)) {
String *nname = NewStringf("*%s",fixname);
if ($1) {
rename_add(Char(nname),0,$3,$5.parms);
Swig_name_rename_add(Namespaceprefix,(nname),0,$3,$5.parms);
} else {
namewarn_add(Char(nname),0,$3);
Swig_name_namewarn_add(Namespaceprefix,(nname),0,$3);
}
Delete(nname);
}
} else {
if ($1) {
rename_add(Char(fixname),0,$3,$5.parms);
Swig_name_rename_add(Namespaceprefix,(fixname),0,$3,$5.parms);
} else {
namewarn_add(Char(fixname),0,$3);
Swig_name_namewarn_add(Namespaceprefix,(fixname),0,$3);
}
}
$$ = 0;
@ -2443,9 +2102,9 @@ rename_directive : rename_namewarn declarator idstring SEMI {
}
| rename_namewarn LPAREN kwargs RPAREN string SEMI {
if ($1) {
rename_add($5,0,$3,0);
Swig_name_rename_add(Namespaceprefix,$5,0,$3,0);
} else {
namewarn_add($5,0,$3);
Swig_name_namewarn_add(Namespaceprefix,$5,0,$3);
}
$$ = 0;
scanner_clear_rename();
@ -2550,7 +2209,6 @@ varargs_directive : VARARGS LPAREN varargs_parms RPAREN declarator cpp_const SEM
Parm *val;
String *name;
SwigType *t;
if (!features_hash) features_hash = NewHash();
if (Namespaceprefix) name = NewStringf("%s::%s", Namespaceprefix, $5.id);
else name = NewString($5.id);
val = $3;
@ -2565,19 +2223,19 @@ varargs_directive : VARARGS LPAREN varargs_parms RPAREN declarator cpp_const SEM
SwigType *decl = SwigType_pop_function(t);
if (SwigType_ispointer(t)) {
String *nname = NewStringf("*%s",name);
Swig_feature_set(features_hash, nname, decl, "feature:varargs", val, 0);
Swig_feature_set(Swig_cparse_features(), nname, decl, "feature:varargs", val, 0);
Delete(nname);
} else {
Swig_feature_set(features_hash, name, decl, "feature:varargs", val, 0);
Swig_feature_set(Swig_cparse_features(), name, decl, "feature:varargs", val, 0);
}
Delete(decl);
} else if (SwigType_ispointer(t)) {
String *nname = NewStringf("*%s",name);
Swig_feature_set(features_hash,nname,0,"feature:varargs",val, 0);
Swig_feature_set(Swig_cparse_features(),nname,0,"feature:varargs",val, 0);
Delete(nname);
}
} else {
Swig_feature_set(features_hash,name,0,"feature:varargs",val, 0);
Swig_feature_set(Swig_cparse_features(),name,0,"feature:varargs",val, 0);
}
Delete(name);
$$ = 0;
@ -3340,12 +2998,17 @@ cpp_class_decl :
/* A simple class/struct/union definition */
storage_class cpptype idcolon inherit LBRACE {
List *bases = 0;
Node *scope = 0;
$$ = new_node("class");
/* preserve the current scope */
prev_symtab = Swig_symbol_current();
/* If the class name is qualified. We need to create or lookup namespace/scope entries */
$3 = resolve_node_scope($3);
scope = resolve_node_scope($3);
Setfile(scope,cparse_file);
Setline(scope,cparse_line);
$3 = scope;
/* support for old nested classes "pseudo" support, such as:
@ -3367,7 +3030,7 @@ cpp_class_decl :
}
Delete(class_rename);
class_rename = make_name(0,$3,0);
class_rename = make_name($$,$3,0);
Classprefix = NewString($3);
/* Deal with inheritance */
if ($4) {
@ -3383,7 +3046,7 @@ cpp_class_decl :
fbase = Copy($3);
tbase = Copy(prefix);
}
rename_inherit(tbase,fbase);
Swig_name_inherit(tbase,fbase);
Delete(fbase);
Delete(tbase);
Delete(prefix);
@ -3551,8 +3214,9 @@ cpp_class_decl :
/* An unnamed struct, possibly with a typedef */
| storage_class cpptype LBRACE {
$$ = new_node("class");
Delete(class_rename);
class_rename = make_name(0,0,0);
class_rename = make_name($$,0,0);
if (strcmp($2,"class") == 0) {
cplus_mode = CPLUS_PRIVATE;
} else {
@ -3569,8 +3233,8 @@ cpp_class_decl :
Node *n;
Classprefix = 0;
inclass = 0;
unnamed = make_unnamed();
$$ = new_node("class");
unnamed = make_unnamed();
Setline($$,cparse_start_line);
Setattr($$,"kind",$2);
Setattr($$,"storage",$1);
@ -4148,7 +3812,7 @@ cpp_member : c_declaration { $$ = $1; }
$$ = $1;
if (extendmode) {
String *symname;
symname= make_name(0,Getattr($$,"name"), Getattr($$,"decl"));
symname= make_name($$,Getattr($$,"name"), Getattr($$,"decl"));
if (Strcmp(symname,Getattr($$,"name")) == 0) {
/* No renaming operation. Set name to class name */
Delete(yyrename);
@ -4211,7 +3875,8 @@ cpp_constructor_decl : storage_class type LPAREN parms RPAREN ctor_end {
/* A destructor (hopefully) */
cpp_destructor_decl : NOT idtemplate LPAREN parms RPAREN cpp_end {
String *name = NewStringf("~%s",$2);
String *name = NewStringf("%s",$2);
if (*(Char(name)) != '~') Insert(name,0,"~");
$$ = new_node("destructor");
Setattr($$,"name",name);
Delete(name);
@ -4246,7 +3911,8 @@ cpp_destructor_decl : NOT idtemplate LPAREN parms RPAREN cpp_end {
}
}
Setattr($$,"storage","virtual");
name = NewStringf("~%s",$3);
name = NewStringf("%s",$3);
if (*(Char(name)) != '~') Insert(name,0,"~");
Setattr($$,"name",name);
Delete(name);
Setattr($$,"throws",$7.throws);

64
Source/CParse/templ.c
View file

@ -12,78 +12,16 @@
char cvsroot_templ_c[] = "$Header$";
#include "swig.h"
#include "swigkeys.h"
#include "cparse.h"
static int template_debug = 0;
static String *k_baselist = 0;
static String *k_cdecl = 0;
static String *k_class = 0;
static String *k_code = 0;
static String *k_constructor = 0;
static String *k_conversionoperator = 0;
static String *k_decl = 0;
static String *k_destructor = 0;
static String *k_error = 0;
static String *k_kwargs = 0;
static String *k_name = 0;
static String *k_namespace = 0;
static String *k_nodetype = 0;
static String *k_parms = 0;
static String *k_partialargs = 0;
static String *k_partials = 0;
static String *k_pattern = 0;
static String *k_privatebaselist = 0;
static String *k_protectedbaselist = 0;
static String *k_symname = 0;
static String *k_symnextSibling = 0;
static String *k_symsymtab = 0;
static String *k_template = 0;
static String *k_templateparms = 0;
static String *k_templatetype = 0;
static String *k_throws = 0;
static String *k_type = 0;
static String *k_typedef = 0;
static String *k_uname = 0;
static String *k_using = 0;
static String *k_value = 0;
String *baselists[3];
void SwigType_template_init()
{
k_baselist = NewString("baselist");
k_cdecl = NewString("cdecl");
k_class = NewString("class");
k_code = NewString("code");
k_constructor = NewString("constructor");
k_conversionoperator = NewString("conversion_operator");
k_decl = NewString("decl");
k_destructor = NewString("destructor");
k_error = NewString("error");
k_kwargs = NewString("kwargs");
k_name = NewString("name");
k_namespace = NewString("namespace");
k_nodetype = NewString("nodeType");
k_parms = NewString("parms");
k_partialargs = NewString("partialargs");
k_partials = NewString("partials");
k_pattern = NewString("pattern");
k_privatebaselist = NewString("privatebaselist");
k_protectedbaselist = NewString("protectedbaselist");
k_symname = NewString("sym:name");
k_symnextSibling = NewString("sym:nextSibling");
k_symsymtab = NewString("sym:symtab");
k_template = NewString("template");
k_templateparms = NewString("templateparms");
k_templatetype = NewString("templatetype");
k_throws = NewString("throws");
k_type = NewString("type");
k_typedef = NewString("typedef");
k_uname = NewString("uname");
k_using = NewString("using");
k_value = NewString("value");
baselists[0] = k_baselist;
baselists[1] = k_protectedbaselist;
baselists[2] = k_privatebaselist;

146
Source/CParse/util.c
View file

@ -87,151 +87,5 @@ void cparse_normalize_void(Node *n) {
}
}
}
/* -----------------------------------------------------------------------------
* int need_protected(Node* n, int dirprot_mode)
*
* Detects when we need to fully register the protected member.
*
* ----------------------------------------------------------------------------- */
int need_protected(Node* n, int dirprot_mode)
{
/* First, 'n' looks like a function */
if (!dirprot_mode && !Swig_director_mode()) return 0;
if ((Strcmp(nodeType(n),"cdecl") == 0) &&
SwigType_isfunction(Getattr(n,"decl"))) {
String *storage = Getattr(n,"storage");
/* and the function is declared like virtual, or it has no
storage. This eliminates typedef, static and so on. */
return (!storage || (Strcmp(storage,"virtual") == 0));
} else if ((Strcmp(nodeType(n),"constructor") == 0)) {
return 1;
}
return 0;
}
/* -----------------------------------------------------------------------------
* int need_name_warning(Node *n)
*
* Detects if a node needs name warnings
*
* ----------------------------------------------------------------------------- */
int need_name_warning(Node *n)
{
int need = 1;
/*
we don't use name warnings for:
- class forwards, no symbol is generated at the target language.
- template declarations, only for real instances using %template(name).
- typedefs, they have no effect at the target language.
*/
if (Strcmp(nodeType(n),"classforward") == 0) {
need = 0;
} else if (Getattr(n,"templatetype")) {
need = 0;
} else {
String *storage = Getattr(n,"storage");
if (storage && (Strcmp(storage,"typedef") == 0)) {
need = 0;
}
}
return need;
}
int are_equivalent_nodes(Node* a, Node* b, int a_inclass)
{
/* they must have the same type */
SwigType *ta = nodeType(a);
SwigType *tb = nodeType(b);
if (Cmp(ta, tb) != 0) return 0;
/* cdecl case */
if (Cmp(ta, "cdecl") == 0) {
/* typedef */
String *a_storage = Getattr(a,"storage");
String *b_storage = Getattr(b,"storage");
if ((Cmp(a_storage,"typedef") == 0)
|| (Cmp(b_storage,"typedef") == 0)) {
if (Cmp(a_storage, b_storage) == 0) {
String *a_type = (Getattr(a,"type"));
String *b_type = (Getattr(b,"type"));
if (Cmp(a_type, b_type) == 0) return 1;
}
return 0;
}
/* static functions */
if ((Cmp(a_storage, "static") == 0)
|| (Cmp(b_storage, "static") == 0)) {
if (Cmp(a_storage, b_storage) != 0) return 0;
}
/* friend methods */
if (!a_inclass || (Cmp(a_storage,"friend") == 0)) {
/* check declaration */
String *a_decl = (Getattr(a,"decl"));
String *b_decl = (Getattr(b,"decl"));
if (Cmp(a_decl, b_decl) == 0) {
/* check return type */
String *a_type = (Getattr(a,"type"));
String *b_type = (Getattr(b,"type"));
if (Cmp(a_type, b_type) == 0) {
/* check parameters */
Parm *ap = (Getattr(a,"parms"));
Parm *bp = (Getattr(b,"parms"));
while (ap && bp) {
SwigType *at = Getattr(ap,"type");
SwigType *bt = Getattr(bp,"type");
if (Cmp(at, bt) != 0) return 0;
ap = nextSibling(ap);
bp = nextSibling(bp);
}
if (ap || bp) {
return 0;
} else {
Node *a_template = Getattr(a,"template");
Node *b_template = Getattr(b,"template");
/* Not equivalent if one is a template instantiation (via %template) and the other is a non-templated function */
if ((a_template && !b_template) || (!a_template && b_template)) return 0;
}
return 1;
}
}
}
} else {
/* %constant case */
String *a_storage = Getattr(a,"storage");
String *b_storage = Getattr(b,"storage");
if ((Cmp(a_storage, "%constant") == 0)
|| (Cmp(b_storage, "%constant") == 0)) {
if (Cmp(a_storage, b_storage) == 0) {
String *a_type = (Getattr(a,"type"));
String *b_type = (Getattr(b,"type"));
if ((Cmp(a_type, b_type) == 0)
&& (Cmp(Getattr(a,"value"), Getattr(b,"value")) == 0))
return 1;
}
return 0;
}
}
return 0;
}
int need_redefined_warn(Node* a, Node* b, int InClass)
{
String *a_symname = Getattr(a,"sym:name");
String *b_symname = Getattr(b,"sym:name");
/* always send a warning if a 'rename' is involved */
if ((a_symname && Cmp(a_symname,Getattr(a,"name")))
|| (b_symname && Cmp(b_symname,Getattr(b,"name"))))
return 1;
return !are_equivalent_nodes(a, b, InClass);
}

2
Source/Modules/csharp.cxx
View file

@ -2392,7 +2392,7 @@ class CSHARP : public Language {
count++;
plist = nextSibling(plist);
}
String *wrn = pn ? Swig_cparse_name_warning(0,0,pn,0) : 0;
String *wrn = pn ? Swig_name_warning(p,0,pn,0) : 0;
arg = (!pn || (count > 1) || wrn) ? NewStringf("arg%d",arg_num) : Copy(pn);
}

2
Source/Modules/java.cxx
View file

@ -2546,7 +2546,7 @@ class JAVA : public Language {
count++;
plist = nextSibling(plist);
}
String *wrn = pn ? Swig_cparse_name_warning(0, 0, pn, 0) : 0;
String *wrn = pn ? Swig_name_warning(p, 0, pn, 0) : 0;
arg = (!pn || (count > 1) || wrn) ? NewStringf("arg%d",arg_num) : Copy(pn);
}

17
Source/Modules/lang.cxx
View file

@ -40,11 +40,6 @@ extern "C" {
{
return director_mode;
}
int Swig_need_protected()
{
return director_protected_mode;
}
}
@ -1973,6 +1968,8 @@ static void addCopyConstructor(Node *n)
Node *cn = NewHash();
set_nodeType(cn,"constructor");
Setattr(cn,"access","public");
Setfile(cn,Getfile(n));
Setline(cn,Getline(n));
String *cname = Getattr(n,"name");
SwigType *type = Copy(cname);
@ -1981,7 +1978,7 @@ static void addCopyConstructor(Node *n)
String *cc = NewStringf("r.q(const).%s", type);
String *decl = NewStringf("f(%s).",cc);
String *csymname = Getattr(n,"sym:name");
String *symname = Swig_cparse_symbol_name(cn, cname, last, decl, 0);
String *symname = Swig_name_make(cn, cname, last, decl, 0);
if (!symname) {
symname = Copy(csymname);
}
@ -2023,13 +2020,15 @@ static void addDefaultConstructor(Node *n)
Node *cn = NewHash();
set_nodeType(cn,"constructor");
Setattr(cn,"access","public");
Setfile(cn,Getfile(n));
Setline(cn,Getline(n));
String *cname = Getattr(n,"name");
String *last = Swig_scopename_last(cname);
String *name = NewStringf("%s::%s",cname,last);
String *decl = NewString("f().");
String *csymname = Getattr(n,"sym:name");
String *symname = Swig_cparse_symbol_name(cn, cname, last, decl, 0);
String *symname = Swig_name_make(cn, cname, last, decl, 0);
if (!symname) {
symname = Copy(csymname);
}
@ -2068,13 +2067,15 @@ static void addDestructor(Node *n)
Node *cn = NewHash();
set_nodeType(cn,"destructor");
Setattr(cn,"access","public");
Setfile(cn,Getfile(n));
Setline(cn,Getline(n));
String *cname = Getattr(n,"name");
String *last = Swig_scopename_last(cname);
Insert(last,0,"~");
String *name = NewStringf("%s::%s",cname,last);
String *decl = NewString("f().");
String *symname = Swig_cparse_symbol_name(cn, cname, last, decl, 0);
String *symname = Swig_name_make(cn, cname, last, decl, 0);
if (!symname) {
symname = NewStringf("~%s",Getattr(n,"sym:name"));
}

4
Source/Modules/python.cxx
View file

@ -1575,7 +1575,7 @@ public:
if (i == num_required) Putc('|', parse_args); /* Optional argument separator */
/* Keyword argument handling */
String *wrn = (allow_kwargs && pn) ? Swig_cparse_name_warning(0,0,pn,0) : 0;
String *wrn = (allow_kwargs && pn) ? Swig_name_warning(p,0,pn,0) : 0;
if (!wrn && Len(pn)) {
Printf(kwargs,"(char *) \"%s\",", pn);
} else {
@ -1585,7 +1585,7 @@ public:
do we need to emit a warning?
*/
Printf(kwargs,"(char *) \"_%s\",", pn);
Swig_warning(0,Getfile(n),Getline(n), "%s, renaming parameter to _%s\n", wrn, pn);
Swig_warning(0,Getfile(n),Getline(n), "314:, '%s' is a renaming parameter to _%s\n", wrn, pn);
} else {
Printf(kwargs,"(char *)\"arg%d\",", i+1);
}

15
Source/Swig/misc.c
View file

@ -12,6 +12,7 @@
char cvsroot_misc_c[] = "$Header$";
#include "swig.h"
#include "swigkeys.h"
#include <errno.h>
#include <ctype.h>
#include <limits.h>
@ -656,9 +657,11 @@ int Swig_scopename_check(String *s) {
#if defined(HAVE_POPEN)
extern FILE *popen(const char *command, const char *type);
extern int pclose(FILE *stream);
#endif
String *Swig_string_command(String *s) {
String *res = NewStringEmpty();
#if defined(HAVE_POPEN)
if (Len(s)) {
char *command = Char(s);
FILE *fp = popen(command,"r");
@ -669,14 +672,14 @@ String *Swig_string_command(String *s) {
}
pclose(fp);
}
if (!fp || (errno)) {
if (!fp || errno) {
Swig_error("SWIG",Getline(s), "Command encoder fails attempting '%s'.\n", s);
exit(1);
}
}
#endif
return res;
}
#endif
/* -----------------------------------------------------------------------------
@ -695,9 +698,10 @@ Swig_init() {
DohEncoding("ctitle", Swig_string_ctitle);
DohEncoding("typecode",Swig_string_typecode);
DohEncoding("mangle",Swig_string_emangle);
#if defined(HAVE_POPEN)
DohEncoding("command",Swig_string_command);
#endif
/* Initialize the swig keys */
Swig_keys_init();
/* Initialize typemaps */
Swig_typemap_init();
@ -705,9 +709,6 @@ Swig_init() {
/* Initialize symbol table */
Swig_symbol_init();
/* Initialize naming system */
Swig_naming_init();
/* Initialize type system */
SwigType_typesystem_init();

573
Source/Swig/naming.c
View file

@ -12,6 +12,8 @@
char cvsroot_naming_c[] = "$Header$";
#include "swig.h"
#include "cparse.h"
#include "swigkeys.h"
#include <ctype.h>
/* Hash table containing naming data */
@ -20,43 +22,6 @@ static Hash *naming_hash = 0;
/* #define SWIG_DEBUG */
/* -----------------------------------------------------------------------------
* Swig_naming_init()
*
* Init the naming system
* ----------------------------------------------------------------------------- */
static String *k_construct = 0;
static String *k_constructor = 0;
static String *k_destroy= 0;
static String *k_destructor = 0;
static String *k_disown = 0;
static String *k_name = 0;
static String *k_start = 0;
static String *k_value = 0;
static String *k_wrapper = 0;
static String *k_nodetype = 0;
static String *k_member = 0;
static String *k_get = 0;
static String *k_set = 0;
void
Swig_naming_init() {
k_construct = NewString("construct");
k_constructor = NewString("constructor");
k_destroy = NewString("destroy");
k_destructor = NewString("destructor");
k_disown = NewString("disown");
k_name = NewString("name");
k_nodetype = NewString("nodeType");
k_start = NewString("*");
k_value = NewString("value");
k_wrapper = NewString("wrapper");
k_member = NewString("member");
k_set = NewString("set");
k_get = NewString("get");
}
/* -----------------------------------------------------------------------------
* Swig_name_register()
*
@ -187,7 +152,7 @@ Swig_name_wrapper(const String_or_char *fname) {
r = NewStringEmpty();
if (!naming_hash) naming_hash = NewHash();
f = Getattr(naming_hash,k_wrapper);
f = HashGetAttr(naming_hash,k_wrapper);
if (!f) {
Append(r,"_wrap_%f");
} else {
@ -215,7 +180,7 @@ Swig_name_member(const String_or_char *classname, const String_or_char *mname) {
rclassname = SwigType_namestr(classname);
r = NewStringEmpty();
if (!naming_hash) naming_hash = NewHash();
f = Getattr(naming_hash,k_member);
f = HashGetAttr(naming_hash,k_member);
if (!f) {
Append(r,"%c_%m");
} else {
@ -251,7 +216,7 @@ Swig_name_get(const String_or_char *vname) {
r = NewStringEmpty();
if (!naming_hash) naming_hash = NewHash();
f = Getattr(naming_hash,k_get);
f = HashGetAttr(naming_hash,k_get);
if (!f) {
Append(r,"%v_get");
} else {
@ -275,7 +240,7 @@ Swig_name_set(const String_or_char *vname) {
r = NewStringEmpty();
if (!naming_hash) naming_hash = NewHash();
f = Getattr(naming_hash,k_set);
f = HashGetAttr(naming_hash,k_set);
if (!f) {
Append(r,"%v_set");
} else {
@ -302,7 +267,7 @@ Swig_name_construct(const String_or_char *classname) {
rclassname = SwigType_namestr(classname);
r = NewStringEmpty();
if (!naming_hash) naming_hash = NewHash();
f = Getattr(naming_hash,k_construct);
f = HashGetAttr(naming_hash,k_construct);
if (!f) {
Append(r,"new_%c");
} else {
@ -337,7 +302,7 @@ Swig_name_copyconstructor(const String_or_char *classname) {
rclassname = SwigType_namestr(classname);
r = NewStringEmpty();
if (!naming_hash) naming_hash = NewHash();
f = Getattr(naming_hash,k_construct);
f = HashGetAttr(naming_hash,k_construct);
if (!f) {
Append(r,"copy_%c");
} else {
@ -370,7 +335,7 @@ String *Swig_name_destroy(const String_or_char *classname) {
rclassname = SwigType_namestr(classname);
r = NewStringEmpty();
if (!naming_hash) naming_hash = NewHash();
f = Getattr(naming_hash,k_destroy);
f = HashGetAttr(naming_hash,k_destroy);
if (!f) {
Append(r,"delete_%c");
} else {
@ -403,7 +368,7 @@ String *Swig_name_disown(const String_or_char *classname) {
rclassname = SwigType_namestr(classname);
r = NewStringEmpty();
if (!naming_hash) naming_hash = NewHash();
f = Getattr(naming_hash,k_disown);
f = HashGetAttr(naming_hash,k_disown);
if (!f) {
Append(r,"disown_%c");
} else {
@ -435,7 +400,7 @@ Swig_name_object_set(Hash *namehash, String *name, SwigType *decl, DOH *object)
#ifdef SWIG_DEBUG
Printf(stdout,"Swig_name_object_set: '%s', '%s'\n", name, decl);
#endif
n = Getattr(namehash,name);
n = HashGetAttr(namehash,name);
if (!n) {
n = NewHash();
Setattr(namehash,name,n);
@ -474,7 +439,7 @@ static
DOH *
name_object_get(Hash *namehash, String *tname, SwigType *decl, SwigType *ncdecl) {
DOH* rn = 0;
Hash *n = Getattr(namehash,tname);
Hash *n = HashGetAttr(namehash,tname);
if (n) {
rn = get_object(n,decl);
if ((!rn) && ncdecl) rn = get_object(n,ncdecl);
@ -585,7 +550,7 @@ Swig_name_object_inherit(Hash *namehash, String *base, String *derived) {
Iterator oi;
String *nkey = NewStringf("%s%s",dprefix,k+plen);
Hash *n = ki.item;
Hash *newh = Getattr(namehash,nkey);
Hash *newh = HashGetAttr(namehash,nkey);
if (!newh) {
newh = NewHash();
Setattr(namehash,nkey,newh);
@ -812,6 +777,518 @@ Swig_feature_set(Hash *features, const String_or_char *name, SwigType *decl, con
}
/*
The rename/namewarn engine
*/
static Hash *namewarn_hash = 0;
Hash *Swig_name_namewarn_hash() {
if (!namewarn_hash) namewarn_hash = NewHash();
return namewarn_hash;
}
static Hash *rename_hash = 0;
Hash *Swig_name_rename_hash() {
if (!rename_hash) rename_hash = NewHash();
return rename_hash;
}
static List *namewarn_list = 0;
List *Swig_name_namewarn_list() {
if (!namewarn_list) namewarn_list = NewList();
return namewarn_list;
}
static List *rename_list = 0;
List *Swig_name_rename_list() {
if (!rename_list) rename_list = NewList();
return rename_list;
}
/* -----------------------------------------------------------------------------
* int Swig_need_name_warning(Node *n)
*
* Detects if a node needs name warnings
*
* ----------------------------------------------------------------------------- */
int Swig_need_name_warning(Node *n)
{
int need = 1;
/*
we don't use name warnings for:
- class forwards, no symbol is generated at the target language.
- template declarations, only for real instances using %template(name).
- typedefs, they have no effect at the target language.
*/
if (checkAttribute(n,k_nodetype,k_classforward)) {
need = 0;
} else if (checkAttribute(n,k_storage,k_typedef)) {
need = 0;
} else if (Getattr(n,k_hidden)) {
need = 0;
} else if (Getattr(n,k_ignore)) {
need = 0;
} else if (Getattr(n,k_templatetype)) {
need = 0;
}
return need;
}
/* -----------------------------------------------------------------------------
* Swig_nodes_are_equivalent(Node* a, Node* b, int a_inclass)
* Restores attributes saved by a previous call to Swig_require() or Swig_save().
* ----------------------------------------------------------------------------- */
static int nodes_are_equivalent(Node* a, Node* b, int a_inclass)
{
/* they must have the same type */
String *ta = Getattr(a,k_nodetype);
String *tb = Getattr(b,k_nodetype);
if (Cmp(ta, tb) != 0) return 0;
/* cdecl case */
if (Cmp(ta, k_cdecl) == 0) {
/* typedef */
String *a_storage = Getattr(a,k_storage);
String *b_storage = Getattr(b,k_storage);
if ((Cmp(a_storage,k_typedef) == 0)
|| (Cmp(b_storage,k_typedef) == 0)) {
if (Cmp(a_storage, b_storage) == 0) {
String *a_type = (Getattr(a,k_type));
String *b_type = (Getattr(b,k_type));
if (Cmp(a_type, b_type) == 0) return 1;
}
return 0;
}
/* static functions */
if ((Cmp(a_storage, k_static) == 0)
|| (Cmp(b_storage, k_static) == 0)) {
if (Cmp(a_storage, b_storage) != 0) return 0;
}
/* friend methods */
if (!a_inclass || (Cmp(a_storage,k_friend) == 0)) {
/* check declaration */
String *a_decl = (Getattr(a,k_decl));
String *b_decl = (Getattr(b,k_decl));
if (Cmp(a_decl, b_decl) == 0) {
/* check return type */
String *a_type = (Getattr(a,k_type));
String *b_type = (Getattr(b,k_type));
if (Cmp(a_type, b_type) == 0) {
/* check parameters */
Parm *ap = (Getattr(a,k_parms));
Parm *bp = (Getattr(b,k_parms));
while (ap && bp) {
SwigType *at = Getattr(ap,k_type);
SwigType *bt = Getattr(bp,k_type);
if (Cmp(at, bt) != 0) return 0;
ap = nextSibling(ap);
bp = nextSibling(bp);
}
if (ap || bp) {
return 0;
} else {
Node *a_template = Getattr(a,k_template);
Node *b_template = Getattr(b,k_template);
/* Not equivalent if one is a template instantiation (via %template) and the other is a non-templated function */
if ((a_template && !b_template) || (!a_template && b_template)) return 0;
}
return 1;
}
}
}
} else {
/* %constant case */
String *a_storage = Getattr(a,k_storage);
String *b_storage = Getattr(b,k_storage);
if ((Cmp(a_storage, "%constant") == 0)
|| (Cmp(b_storage, "%constant") == 0)) {
if (Cmp(a_storage, b_storage) == 0) {
String *a_type = (Getattr(a,k_type));
String *b_type = (Getattr(b,k_type));
if ((Cmp(a_type, b_type) == 0)
&& (Cmp(Getattr(a,k_value), Getattr(b,k_value)) == 0))
return 1;
}
return 0;
}
}
return 0;
}
int Swig_need_redefined_warn(Node* a, Node* b, int InClass)
{
String *a_symname = Getattr(a,k_symname);
String *b_symname = Getattr(b,k_symname);
/* always send a warning if a 'rename' is involved */
if ((a_symname && Cmp(a_symname,Getattr(a,k_name)))
|| (b_symname && Cmp(b_symname,Getattr(b,k_name))))
return 1;
return !nodes_are_equivalent(a, b, InClass);
}
/* -----------------------------------------------------------------------------
* int Swig_need_protected(Node* n)
*
* Detects when we need to fully register the protected member.
*
* ----------------------------------------------------------------------------- */
int Swig_need_protected(Node* n)
{
/* First, 'n' looks like a function */
/* if (!Swig_director_mode()) return 0; */
String *nodetype = Getattr(n,k_nodetype);
if ((Equal(nodetype,k_cdecl)) && SwigType_isfunction(Getattr(n,k_decl))) {
String *storage = Getattr(n,k_storage);
/* and the function is declared like virtual, or it has no
storage. This eliminates typedef, static and so on. */
return !storage || Equal(storage,k_virtual);
} else if (Equal(nodetype,k_constructor) || Equal(nodetype,k_destructor)) {
return 1;
}
return 0;
}
static void Swig_name_object_attach_keys(const char *keys[], Hash *nameobj)
{
Node *kw = nextSibling(nameobj);
List *matchlist = 0;
while (kw) {
Node *next = nextSibling(kw);
String *kname = Getattr(kw,k_name);
char *ckey = kname ? Char(kname) : 0;
if (ckey) {
const char **rkey;
if (strncmp(ckey,"match",5) == 0) {
if (!matchlist) matchlist = NewList();
Append(matchlist,kw);
deleteNode(kw);
} else {
for (rkey = keys; *rkey != 0; ++rkey) {
if (strcmp(ckey,*rkey) == 0) {
Setattr(nameobj, *rkey, Getattr(kw,k_value));
deleteNode(kw);
}
}
}
}
kw = next;
}
if (matchlist) {
Setattr(nameobj,k_matchlist,matchlist);
Delete(matchlist);
}
}
void
Swig_name_nameobj_add(Hash *name_hash, List *name_list,
String *prefix, const char *name, SwigType *decl, Hash *nameobj) {
String *nname = 0;
if (name && Len(name)) {
String *target_fmt = Getattr(nameobj,k_targetfmt);
nname = prefix ? NewStringf("%s::%s",prefix, name) : NewString(name);
if (target_fmt) {
String *tmp = NewStringf(Getattr(nameobj,k_targetfmt), nname);
Delete(nname);
nname = tmp;
}
}
if (!nname || !Len(nname) || Getattr(nameobj,k_sourcefmt) || Getattr(nameobj,k_matchlist)) {
if (decl) Setattr(nameobj,k_decl, decl);
if (nname && Len(nname)) Setattr(nameobj,k_targetname, nname);
Append(name_list, nameobj);
} else {
Swig_name_object_set(name_hash,nname,decl,nameobj);
}
Delete(nname);
}
DOH *Swig_node_getattr(Node *n, const char *cattr)
{
const char *rattr = strstr(cattr,"$");
if (rattr) {
String *nattr = NewStringWithSize(cattr, rattr-cattr);
Node *rn = Getattr(n,nattr);
if (rn) {
DOH *res = Swig_node_getattr(rn, rattr + 1);
Delete(nattr);
return res;
} else {
return 0;
}
} else {
DOH *res = Getattr(n,cattr);
return res;
}
}
int Swig_name_match_nameobj(Hash *rn, Node *n) {
int match = 1;
List *matchlist = HashGetAttr(rn,k_matchlist);
if (matchlist) {
int i;
int ilen = Len(matchlist);
for (i = 0; match && (i < ilen); ++i) {
Node *kw = Getitem(matchlist,i);
String *key = Getattr(kw,k_name);
char *ckey = key ? Char(key) : 0;
if (ckey && (strncmp(ckey,"match",5) == 0)) {
match = 0;
if (n) {
const char *csep = strstr(ckey,"$");
String *nval = csep ? Swig_node_getattr(n,csep + 1) : Getattr(n,k_nodetype);
String *kwval = Getattr(kw,k_value);
if (nval && Equal(nval, kwval)) {
match = 1;
}
}
}
}
}
return match;
}
Hash *Swig_name_nameobj_lget(List *namelist, Node *n, String *prefix, String *name, String *decl) {
Hash *res = 0;
if (namelist) {
int len = Len(namelist);
int i;
int match = 0;
for (i = 0; !match && (i < len); i++) {
Hash *rn = Getitem(namelist,i);
String *rdecl = HashGetAttr(rn,k_decl);
if (rdecl && (!decl || !Equal(rdecl,decl))) {
continue;
} else if (Swig_name_match_nameobj(rn, n)) {
String *tname = HashGetAttr(rn,k_targetname);
String *sfmt = HashGetAttr(rn,k_sourcefmt);
String *sname = 0;
int fullname = GetFlag(namelist,k_fullname);
if (sfmt) {
if (fullname && prefix) {
sname = NewStringf(sfmt, prefix, name);
} else {
sname = NewStringf(sfmt, name);
}
} else {
if (fullname && prefix) {
sname = NewStringf("%s::%s", prefix, name);
} else {
sname = NewString(name);
}
}
match = !tname || Equal(sname,tname);
Delete(sname);
}
if (match) {
res = rn;
break;
}
}
}
return res;
}
void Swig_name_namewarn_add(String *prefix, String *name, SwigType *decl, Hash *namewrn) {
const char *namewrn_keys[] = {"rename", "error", "fullname", "sourcefmt", "targetfmt", 0};
Swig_name_object_attach_keys(namewrn_keys, namewrn);
Swig_name_nameobj_add(Swig_name_namewarn_hash(), Swig_name_namewarn_list(),
prefix, name, decl, namewrn);
}
/* Return the node name when it requires to emit a name warning */
Hash *Swig_name_namewarn_get(Node *n, String *prefix, String *name,SwigType *decl) {
if (!namewarn_hash && !namewarn_list) return 0;
if (n) {
/* Return in the obvious cases */
if (!name || !Swig_need_name_warning(n)) {
return 0;
} else {
String *access = Getattr(n,k_access);
int is_public = !access || Equal(access,k_public);
if (!is_public && !Swig_need_protected(n)) {
return 0;
}
}
}
if (name) {
/* Check to see if the name is in the hash */
Hash *wrn = Swig_name_object_get(Swig_name_namewarn_hash(),prefix,name,decl);
if (wrn && !Swig_name_match_nameobj(wrn, n)) wrn = 0;
if (!wrn) {
wrn = Swig_name_nameobj_lget(Swig_name_namewarn_list(), n, prefix, name, decl);
}
if (wrn && HashGetAttr(wrn,k_error)) {
if (n) {
Swig_error(Getfile(n), Getline(n), "%s\n", HashGetAttr(wrn,k_name));
} else {
Swig_error(cparse_file, cparse_line,"%s\n", HashGetAttr(wrn,k_name));
}
}
return wrn;
} else {
return 0;
}
}
String *Swig_name_warning(Node *n, String *prefix, String *name,SwigType *decl) {
Hash *wrn = Swig_name_namewarn_get(n, prefix, name,decl);
return (name && wrn) ? HashGetAttr(wrn,k_name) : 0;
}
static void single_rename_add(String *prefix, String *name, SwigType *decl, Hash *newname) {
Swig_name_nameobj_add(Swig_name_rename_hash(), Swig_name_rename_list(),
prefix, name, decl, newname);
}
/* Add a new rename. Works much like new_feature including default argument handling. */
void Swig_name_rename_add(String *prefix, String *name, SwigType *decl, Hash *newname,
ParmList *declaratorparms) {
ParmList *declparms = declaratorparms;
const char *rename_keys[] = {"fullname", "sourcefmt", "targetfmt", 0};
Swig_name_object_attach_keys(rename_keys, newname);
/* Add the name */
single_rename_add(prefix, name, decl, newname);
/* Add extra names if there are default parameters in the parameter list */
if (decl) {
int constqualifier = SwigType_isconst(decl);
while (declparms) {
if (ParmList_has_defaultargs(declparms)) {
/* Create a parameter list for the new rename by copying all
but the last (defaulted) parameter */
ParmList* newparms = ParmList_copy_all_except_last_parm(declparms);
/* Create new declaration - with the last parameter removed */
SwigType *newdecl = Copy(decl);
Delete(SwigType_pop_function(newdecl)); /* remove the old parameter list from newdecl */
SwigType_add_function(newdecl,newparms);
if (constqualifier)
SwigType_add_qualifier(newdecl,"const");
single_rename_add(prefix, name, newdecl, newname);
declparms = newparms;
Delete(newdecl);
} else {
declparms = 0;
}
}
}
}
/* Create a name applying rename/namewarn if needed */
static String *apply_rename(String *newname, int fullname, String *prefix, String *name)
{
String *result = 0;
if (newname && Len(newname)) {
if (Strcmp(newname,"$ignore") == 0) {
result = Copy(newname);
} else {
char *cnewname = Char(newname);
if (cnewname) {
int destructor = name && (*(Char(name)) == '~');
String *fmt = newname;
String *tmp = 0;
if (destructor && (*cnewname != '~')) {
fmt = tmp = NewStringf("~%s", newname);
}
/* use name as a fmt, but avoid C++ "%" and "%=" operators */
if (Len(newname) > 1 && strstr(cnewname,"%") && !(strcmp(cnewname,"%=") == 0)) {
if (fullname && prefix) {
result = NewStringf(fmt,prefix,name);
} else {
result = NewStringf(fmt,name);
}
} else {
result = Copy(newname);
}
if (tmp) Delete(tmp);
}
}
}
return result;
}
String *
Swig_name_make(Node *n, String *prefix, String *name, SwigType *decl, String *oldname) {
String *nname = 0;
String *result = 0;
Hash *wrn = 0;
if (namewarn_hash || namewarn_list) {
Hash *rn = Swig_name_object_get(Swig_name_rename_hash(), prefix, name, decl);
if (!rn || !Swig_name_match_nameobj(rn,n)) {
rn = Swig_name_nameobj_lget(Swig_name_rename_list(), n, prefix, name, decl);
}
if (rn) {
String *newname = HashGetAttr(rn,k_name);
int fullname = GetFlag(rn,k_fullname);
result = apply_rename(newname, fullname, prefix, name);
}
nname = result ? result : name;
wrn = Swig_name_namewarn_get(n, prefix, nname, decl);
if (wrn) {
String *rename = HashGetAttr(wrn,k_rename);
if (rename) {
String *msg = HashGetAttr(wrn,k_name);
int fullname = GetFlag(wrn,k_fullname);
if (result) Delete(result);
result = apply_rename(rename, fullname, prefix, name);
if ((msg) && (Len(msg))) {
if (!Getmeta(nname,"already_warned")) {
if (n) {
SWIG_WARN_NODE_BEGIN(n);
Swig_warning(0,Getfile(n), Getline(n), "%s\n", msg);
SWIG_WARN_NODE_END(n);
} else {
Swig_warning(0,Getfile(name),Getline(name), "%s\n", msg);
}
Setmeta(nname,"already_warned","1");
}
}
}
}
}
if (!result || !Len(result)) {
if (result) Delete(result);
result = oldname ? Copy(oldname): Copy(name);
}
return result;
}
void Swig_name_inherit(String *base, String *derived) {
/* Printf(stdout,"base = '%s', derived = '%s'\n", base, derived); */
Swig_name_object_inherit(Swig_name_rename_hash(),base,derived);
Swig_name_object_inherit(Swig_name_namewarn_hash(),base,derived);
Swig_name_object_inherit(Swig_cparse_features(),base,derived);
}

68
Source/Swig/parms.c
View file

@ -17,8 +17,7 @@
char cvsroot_parms_c[] = "$Header$";
#include "swig.h"
#define MAXPARMS 16
#include "swigkeys.h"
/* ------------------------------------------------------------------------
* NewParm()
@ -28,13 +27,13 @@ char cvsroot_parms_c[] = "$Header$";
Parm *NewParm(SwigType *type, const String_or_char *name) {
Parm *p = NewHash();
Setattr(p,k_nodetype,k_parm);
if (type) {
SwigType *ntype = Copy(type);
Setattr(p,"type",ntype);
Setattr(p,k_type,ntype);
Delete(ntype);
}
Setattr(p,"name",name);
Setattr(p,k_name,name);
return p;
}
@ -60,59 +59,59 @@ Parm *NewParmFromNode(SwigType *type, const String_or_char *name, Node *n) {
Parm *CopyParm(Parm *p) {
Parm *np = NewHash();
SwigType *t = Getattr(p,"type");
String *name = Getattr(p,"name");
String *lname = Getattr(p,"lname");
String *value = Getattr(p,"value");
String *ignore = Getattr(p,"ignore");
String *alttype = Getattr(p,"alttype");
String *byname = Getattr(p, "arg:byname");
String *compactdefargs = Getattr(p, "compactdefargs");
String *self = Getattr(p, "self");
SwigType *t = HashGetAttr(p,k_type);
String *name = HashGetAttr(p,k_name);
String *lname = HashGetAttr(p,k_lname);
String *value = HashGetAttr(p,k_value);
String *ignore = HashGetAttr(p,k_ignore);
String *alttype = HashGetAttr(p,k_alttype);
String *byname = HashGetAttr(p, k_argbyname);
String *compactdefargs = HashGetAttr(p, k_compactdefargs);
String *self = HashGetAttr(p, k_self);
if (t) {
SwigType *nt = Copy(t);
Setattr(np,"type",nt);
Setattr(np,k_type,nt);
Delete(nt);
}
if (name) {
String *str = Copy(name);
Setattr(np,"name",str);
Setattr(np,k_name,str);
Delete(str);
}
if (lname) {
String *str = Copy(lname);
Setattr(np,"lname", str);
Setattr(np,k_lname, str);
Delete(str);
}
if (value) {
String *str = Copy(value);
Setattr(np,"value", str);
Setattr(np,k_value, str);
Delete(str);
}
if (ignore) {
String *str = Copy(ignore);
Setattr(np,"ignore", str);
Setattr(np,k_ignore, str);
Delete(str);
}
if (alttype) {
String *str = Copy(alttype);
Setattr(np,"alttype", str);
Setattr(np,k_alttype, str);
Delete(str);
}
if (byname) {
String *str = Copy(byname);
Setattr(np, "arg:byname", str);
Setattr(np, k_argbyname, str);
Delete(str);
}
if (compactdefargs) {
String *str = Copy(compactdefargs);
Setattr(np, "compactdefargs", str);
Setattr(np, k_compactdefargs, str);
Delete(str);
}
if (self) {
String *str = Copy(self);
Setattr(np, "self", str);
Setattr(np, k_self, str);
Delete(str);
}
@ -155,7 +154,7 @@ CopyParmList(ParmList *p) {
int ParmList_numarg(ParmList *p) {
int n = 0;
while (p) {
if (!Getattr(p,"ignore")) n++;
if (!HashGetAttr(p,k_ignore)) n++;
p = nextSibling(p);
}
return n;
@ -168,8 +167,8 @@ int ParmList_numarg(ParmList *p) {
int ParmList_numrequired(ParmList *p) {
int i = 0;
while (p) {
SwigType *t = Getattr(p,"type");
String *value = Getattr(p,"value");
SwigType *t = HashGetAttr(p,k_type);
String *value = HashGetAttr(p,k_value);
if (value) return i;
if (!(SwigType_type(t) == T_VOID)) i++;
else break;
@ -200,7 +199,7 @@ int ParmList_len(ParmList *p) {
String *ParmList_str(ParmList *p) {
String *out = NewStringEmpty();
while(p) {
String *pstr = SwigType_str(Getattr(p,"type"), Getattr(p,"name"));
String *pstr = SwigType_str(HashGetAttr(p,k_type), HashGetAttr(p,k_name));
StringAppend(out,pstr);
p = nextSibling(p);
if (p) {
@ -220,8 +219,8 @@ String *ParmList_str(ParmList *p) {
String *ParmList_str_defaultargs(ParmList *p) {
String *out = NewStringEmpty();
while(p) {
String *value = Getattr(p,"value");
String *pstr = SwigType_str(Getattr(p,"type"), Getattr(p,"name"));
String *value = HashGetAttr(p,k_value);
String *pstr = SwigType_str(HashGetAttr(p,k_type), HashGetAttr(p,k_name));
StringAppend(out,pstr);
if (value) {
Printf(out,"=%s", value);
@ -244,10 +243,10 @@ String *ParmList_str_defaultargs(ParmList *p) {
String *ParmList_protostr(ParmList *p) {
String *out = NewStringEmpty();
while(p) {
if (Getattr(p,"hidden")) {
if (HashGetAttr(p,k_hidden)) {
p = nextSibling(p);
} else {
String *pstr = SwigType_str(Getattr(p,"type"), 0);
String *pstr = SwigType_str(HashGetAttr(p,k_type), 0);
StringAppend(out,pstr);
p = nextSibling(p);
if (p) {
@ -270,14 +269,14 @@ int ParmList_is_compactdefargs(ParmList *p) {
int compactdefargs = 0;
if (p) {
compactdefargs = Getattr(p,"compactdefargs") ? 1 : 0;
compactdefargs = HashGetAttr(p,k_compactdefargs) ? 1 : 0;
/* The "compactdefargs" attribute should only be set on the first parameter in the list.
* However, sometimes an extra parameter is inserted at the beginning of the parameter list,
* so we check the 2nd parameter too. */
if (!compactdefargs) {
Parm *nextparm = nextSibling(p);
compactdefargs = (nextparm && Getattr(nextparm,"compactdefargs")) ? 1 : 0;
compactdefargs = (nextparm && HashGetAttr(nextparm,k_compactdefargs)) ? 1 : 0;
}
}
@ -295,7 +294,7 @@ int ParmList_is_compactdefargs(ParmList *p) {
int ParmList_has_defaultargs(ParmList *p) {
int default_args = 0;
while (p) {
if (Getattr(p, "value")) {
if (HashGetAttr(p, k_value)) {
default_args = 1;
break;
}
@ -330,4 +329,3 @@ ParmList *ParmList_copy_all_except_last_parm(ParmList *p) {
newparms = fp;
return newparms;
}

26
Source/Swig/swig.h
View file

@ -22,6 +22,9 @@
#ifdef __cplusplus
extern "C" {
#if 0
} /* cc-mode*/
#endif
#endif
#ifndef MACSWIG
@ -421,6 +424,18 @@ extern String *Swig_name_copyconstructor(const String_or_char *classname);
extern String *Swig_name_destroy(const String_or_char *classname);
extern String *Swig_name_disown(const String_or_char *classname);
extern void Swig_naming_init();
extern void Swig_name_namewarn_add(String *prefix, String *name, SwigType *decl, Hash *namewrn);
extern Hash *Swig_name_namewarn_get(Node *n, String *prefix, String *name,SwigType *decl);
extern void Swig_name_rename_add(String *prefix, String *name, SwigType *decl, Hash *namewrn, ParmList *declaratorparms);
extern void Swig_name_inherit(String *base, String *derived);
extern int Swig_need_protected(Node *n);
extern int Swig_need_name_warning(Node *n);
extern int Swig_need_redefined_warn(Node* a, Node* b, int InClass);
extern String *Swig_name_make(Node *n, String *prefix, String *name, SwigType *decl, String *oldname);
extern String *Swig_name_warning(Node *n, String *prefix, String *name,SwigType *decl);
/* --- parameterized rename functions --- */
extern void Swig_name_object_set(Hash *namehash, String_or_char *name, SwigType *decl, DOH *object);
@ -536,19 +551,18 @@ extern void Swig_fragment_register(Node* fragment);
extern void Swig_fragment_emit(String *name);
/* hacks defined in C++ ! */
extern int Swig_need_protected();
extern int Swig_director_mode();
extern int Swig_director_mode();
extern void Wrapper_director_mode_set(int);
/* -- template init -- */
extern void SwigType_template_init();
/* -- naming init -- */
extern void Swig_naming_init();
#ifdef __cplusplus
#if 0
{ /* cc-mode*/
#endif
}
#endif

176
Source/Swig/swigkeys.c Normal file
View file

@ -0,0 +1,176 @@
#include "swigkeys.h"
String *empty_string = 0;
String *k_1 = 0;
String *k_SWIGTYPE = 0;
String *k_access = 0;
String *k_allowstypedef = 0;
String *k_alttype = 0;
String *k_argbyname = 0;
String *k_baselist = 0;
String *k_cdecl = 0;
String *k_class = 0;
String *k_classforward = 0;
String *k_code = 0;
String *k_coloncolon = 0;
String *k_compactdefargs = 0;
String *k_construct = 0;
String *k_constructor = 0;
String *k_conversionoperator = 0;
String *k_csymnextSibling = 0;
String *k_csympreviousSibling = 0;
String *k_csymtab = 0;
String *k_decl = 0;
String *k_destroy = 0;
String *k_destructor = 0;
String *k_disown = 0;
String *k_enumitem = 0;
String *k_error = 0;
String *k_extern = 0;
String *k_friend = 0;
String *k_fullname = 0;
String *k_get = 0;
String *k_hidden = 0;
String *k_ignore = 0;
String *k_inherit = 0;
String *k_kwargs = 0;
String *k_lname = 0;
String *k_locals = 0;
String *k_matchlist = 0;
String *k_member = 0;
String *k_name = 0;
String *k_namespace = 0;
String *k_nodetype = 0;
String *k_parent = 0;
String *k_parentnode = 0;
String *k_parm = 0;
String *k_parms = 0;
String *k_partialargs = 0;
String *k_partials = 0;
String *k_pattern = 0;
String *k_privatebaselist = 0;
String *k_protectedbaselist = 0;
String *k_public = 0;
String *k_qname = 0;
String *k_rename = 0;
String *k_scope = 0;
String *k_self = 0;
String *k_set = 0;
String *k_sourcefmt = 0;
String *k_start = 0;
String *k_static = 0;
String *k_storage = 0;
String *k_symboltable = 0;
String *k_symname = 0;
String *k_symnextSibling = 0;
String *k_symoverloaded = 0;
String *k_symovername = 0;
String *k_sympreviousSibling = 0;
String *k_symsymtab = 0;
String *k_symtab = 0;
String *k_symtypename = 0;
String *k_symweak = 0;
String *k_targetfmt = 0;
String *k_targetname = 0;
String *k_template = 0;
String *k_templateparm = 0;
String *k_templateparms = 0;
String *k_templatetype = 0;
String *k_throws = 0;
String *k_tmapmatch = 0;
String *k_type = 0;
String *k_typedef = 0;
String *k_typetab = 0;
String *k_uname = 0;
String *k_using = 0;
String *k_value = 0;
String *k_virtual = 0;
String *k_wrapper = 0;
void Swig_keys_init() {
empty_string = NewString("");
k_1 = NewString("1");
k_SWIGTYPE = NewString("SWIGTYPE");
k_access = NewString("access");
k_allowstypedef = NewString("allows_typedef");
k_alttype = NewString("alttype");
k_argbyname = NewString("arg:byname");
k_baselist = NewString("baselist");
k_cdecl = NewString("cdecl");
k_class = NewString("class");
k_classforward = NewString("classforward");
k_code = NewString("code");
k_coloncolon = NewString("::");
k_compactdefargs = NewString("compactdefargs");
k_construct = NewString("construct");
k_constructor = NewString("constructor");
k_conversionoperator = NewString("conversion_operator");
k_csymnextSibling = NewString("csym:nextSibling");
k_csympreviousSibling = NewString("csym:previousSibling");
k_csymtab = NewString("csymtab");
k_decl = NewString("decl");
k_destroy = NewString("destroy");
k_destructor = NewString("destructor");
k_disown = NewString("disown");
k_enumitem = NewString("enumitem");
k_error = NewString("error");
k_friend = NewString("friend");
k_fullname = NewString("fullname");
k_get = NewString("get");
k_hidden = NewString("hidden");
k_ignore = NewString("ignore");
k_inherit = NewString("inherit");
k_kwargs = NewString("kwargs");
k_lname = NewString("lname");
k_locals = NewString("locals");
k_matchlist = NewString("matchlist");
k_member = NewString("member");
k_name = NewString("name");
k_namespace = NewString("namespace");
k_nodetype = NewString("nodeType");
k_parent = NewString("parent");
k_parentnode = NewString("parentNode");
k_parm = NewString("parm");
k_parms = NewString("parms");
k_partialargs = NewString("partialargs");
k_partials = NewString("partials");
k_pattern = NewString("pattern");
k_privatebaselist = NewString("privatebaselist");
k_protectedbaselist = NewString("protectedbaselist");
k_public = NewString("public");
k_qname = NewString("qname");
k_rename = NewString("rename");
k_scope = NewString("scope");
k_self = NewString("self");
k_set = NewString("set");
k_sourcefmt = NewString("sourcefmt");
k_start = NewString("*");
k_static = NewString("static");
k_storage = NewString("storage");
k_symboltable = NewString("symboltable");
k_symname = NewString("sym:name");
k_symnextSibling = NewString("sym:nextSibling");
k_symoverloaded = NewString("sym:overloaded");
k_symovername = NewString("sym:overname");
k_sympreviousSibling = NewString("sym:previousSibling");
k_symsymtab = NewString("sym:symtab");
k_symtab = NewString("symtab");
k_symtypename = NewString("sym:typename");
k_symweak = NewString("sym:weak");
k_targetfmt = NewString("targetfmt");
k_targetname = NewString("targetname");
k_template = NewString("template");
k_templateparm = NewString("templateparm");
k_templateparms = NewString("templateparms");
k_templatetype = NewString("templatetype");
k_throws = NewString("throws");
k_tmapmatch = NewString("tmap:match");
k_type = NewString("type");
k_typedef = NewString("typedef");
k_typetab = NewString("typetab");
k_uname = NewString("uname");
k_using = NewString("using");
k_value = NewString("value");
k_virtual = NewString("virtual");
k_wrapper = NewString("wrapper");
}

94
Source/Swig/swigkeys.h Normal file
View file

@ -0,0 +1,94 @@
#ifndef __Swig_swigkeys_h__
#define __Swig_swigkeys_h__
#include "swig.h"
extern void Swig_keys_init();
extern String *empty_string;
extern String *k_1;
extern String *k_SWIGTYPE;
extern String *k_access;
extern String *k_allowstypedef;
extern String *k_alttype;
extern String *k_argbyname;
extern String *k_baselist;
extern String *k_cdecl;
extern String *k_class;
extern String *k_classforward;
extern String *k_code;
extern String *k_coloncolon;
extern String *k_compactdefargs;
extern String *k_construct;
extern String *k_constructor;
extern String *k_conversionoperator;
extern String *k_csymnextSibling;
extern String *k_csympreviousSibling;
extern String *k_csymtab;
extern String *k_decl;
extern String *k_destroy;
extern String *k_destructor;
extern String *k_disown;
extern String *k_enumitem;
extern String *k_error;
extern String *k_extern;
extern String *k_friend;
extern String *k_fullname;
extern String *k_get;
extern String *k_hidden;
extern String *k_ignore;
extern String *k_inherit;
extern String *k_kwargs;
extern String *k_lname;
extern String *k_locals;
extern String *k_matchlist;
extern String *k_member;
extern String *k_name;
extern String *k_namespace;
extern String *k_nodetype;
extern String *k_parent;
extern String *k_parentnode;
extern String *k_parm;
extern String *k_parms;
extern String *k_partialargs;
extern String *k_partials;
extern String *k_pattern;
extern String *k_privatebaselist;
extern String *k_protectedbaselist;
extern String *k_public;
extern String *k_qname;
extern String *k_rename;
extern String *k_scope;
extern String *k_self;
extern String *k_set;
extern String *k_sourcefmt;
extern String *k_start;
extern String *k_static;
extern String *k_storage;
extern String *k_symboltable;
extern String *k_symname;
extern String *k_symnextSibling;
extern String *k_symoverloaded;
extern String *k_symovername;
extern String *k_sympreviousSibling;
extern String *k_symsymtab;
extern String *k_symtab;
extern String *k_symtypename;
extern String *k_symweak;
extern String *k_targetfmt;
extern String *k_targetname;
extern String *k_template;
extern String *k_templateparm;
extern String *k_templateparms;
extern String *k_templatetype;
extern String *k_throws;
extern String *k_tmapmatch;
extern String *k_type;
extern String *k_typedef;
extern String *k_typetab;
extern String *k_uname;
extern String *k_using;
extern String *k_value;
extern String *k_virtual;
extern String *k_wrapper;
#endif /* __Swig_swigkeys_h__ */

74
Source/Swig/symbol.c
View file

@ -13,6 +13,7 @@ char cvsroot_symbol_c[] = "$Header$";
#include "swig.h"
#include "swigwarn.h"
#include "swigkeys.h"
#include <ctype.h>
/* #define SWIG_DEBUG*/
@ -176,41 +177,6 @@ static Hash *global_scope = 0; /* Global scope */
/* common attribute keys, to avoid calling find_key all the times */
static String *empty_string = 0;
static String *k_allowstypedef = 0;
static String *k_cdecl = 0;
static String *k_coloncolon = 0;
static String *k_constructor = 0;
static String *k_csymnextSibling = 0;
static String *k_csympreviousSibling = 0;
static String *k_csymtab = 0;
static String *k_decl = 0;
static String *k_enumitem = 0;
static String *k_inherit = 0;
static String *k_name = 0;
static String *k_namespace = 0;
static String *k_nodetype = 0;
static String *k_parentnode = 0;
static String *k_storage = 0;
static String *k_symboltable = 0;
static String *k_symname = 0;
static String *k_symnextSibling = 0;
static String *k_symoverloaded = 0;
static String *k_symovername = 0;
static String *k_sympreviousSibling = 0;
static String *k_symsymtab = 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_templatetype = 0;
static String *k_type = 0;
static String *k_typedef = 0;
static String *k_uname = 0;
static String *k_using = 0;
static String *k_value = 0;
#if 0
@ -236,41 +202,6 @@ Swig_symbol_dump_symtable() {
void
Swig_symbol_init() {
empty_string = NewString("");
k_allowstypedef = NewString("allows_typedef");
k_cdecl = NewString("cdecl");
k_coloncolon = NewString("::");
k_constructor = NewString("constructor");
k_csymnextSibling = NewString("csym:nextSibling");
k_csympreviousSibling = NewString("csym:previousSibling");
k_csymtab = NewString("csymtab");
k_decl = NewString("decl");
k_enumitem = NewString("enumitem");
k_inherit = NewString("inherit");
k_name = NewString("name");
k_namespace = NewString("namespace");
k_nodetype = NewString("nodeType");
k_parentnode = NewString("parentNode");
k_storage = NewString("storage");
k_symboltable = NewString("symboltable");
k_symname = NewString("sym:name");
k_symnextSibling = NewString("sym:nextSibling");
k_symoverloaded = NewString("sym:overloaded");
k_symovername = NewString("sym:overname");
k_sympreviousSibling = NewString("sym:previousSibling");
k_symsymtab = NewString("sym: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_templatetype = NewString("templatetype");
k_type = NewString("type");
k_typedef = NewString("typedef");
k_uname = NewString("uname");
k_using = NewString("using");
k_value = NewString("value");
current = NewHash();
current_symtab = NewHash();
@ -1947,3 +1878,6 @@ SwigType *Swig_symbol_template_param_eval(const SwigType *p, Symtab *symtab)
}
return value;
}

6
Source/Swig/tree.c
View file

@ -247,9 +247,7 @@ Swig_tag_nodes(Node *n, const String_or_char *attrname, DOH *value) {
int
checkAttribute(Node *n, const String_or_char *name, const String_or_char *value) {
String *v = Getattr(n,name);
if (!v) return 0;
if (Equal(v,value)) return 1;
return 0;
return v ? Equal(v,value) : 0;
}
/* -----------------------------------------------------------------------------
@ -410,3 +408,5 @@ Swig_restore(Node *n) {
}
Delete(l);
}

26
Source/Swig/typemap.c
View file

@ -12,6 +12,7 @@
char cvsroot_typemap_c[] = "$Header$";
#include "swig.h"
#include "swigkeys.h"
#include "cparse.h"
#include <ctype.h>
@ -85,16 +86,6 @@ static void set_typemap(int tm_scope, SwigType* type, Hash* tm)
*
* Initialize the typemap system
* ----------------------------------------------------------------------------- */
static String *k_type = 0;
static String *k_code = 0;
static String *k_name = 0;
static String *k_lname = 0;
static String *k_locals = 0;
static String *k_value = 0;
static String *k_tmapmatch = 0;
static String *k_kwargs = 0;
static String *k_SWIGTYPE = 0;
static String *k_one = 0;
void Swig_typemap_init() {
int i;
@ -103,17 +94,6 @@ void Swig_typemap_init() {
}
typemaps[0] = NewHash();
tm_scope = 0;
k_type = NewString("type");
k_code = NewString("code");
k_name = NewString("name");
k_lname = NewString("lname");
k_locals = NewString("locals");
k_value = NewString("value");
k_tmapmatch = NewString("tmap:match");
k_SWIGTYPE = NewString("SWIGTYPE");
k_kwargs = NewString("kwargs");
k_one = NewString("1");
}
static String *tmop_name(const String_or_char *op) {
@ -1338,7 +1318,7 @@ Printf(stdout, "Swig_typemap_lookup %s [%s %s]\n", op, type, pname ? pname : "NO
if (HashCheckAttr(tm,k_type,k_SWIGTYPE)) {
sprintf(temp,"%s:SWIGTYPE", cop);
Setattr(node,tmop_name(temp),k_one);
Setattr(node,tmop_name(temp),k_1);
}
/* Attach kwargs */
@ -1565,7 +1545,7 @@ Swig_typemap_attach_parms(const String_or_char *op, ParmList *parms, Wrapper *f)
if (HashCheckAttr(tm,k_type,k_SWIGTYPE)) {
sprintf(temp,"%s:SWIGTYPE", cop);
Setattr(p,tmop_name(temp),k_one);
Setattr(p,tmop_name(temp),k_1);
}
p = nextSibling(p);
}

24
Source/Swig/typesys.c
View file

@ -15,6 +15,7 @@
char cvsroot_typesys_c[] = "$Header$";
#include "swig.h"
#include "swigkeys.h"
#include "cparse.h"
/* -----------------------------------------------------------------------------
@ -111,17 +112,6 @@ static Hash *typedef_all_cache = 0;
static Hash *typedef_qualified_cache = 0;
/* common attribute keys, to avoid calling find_key all the times */
static String *k_name = 0;
static String *k_qname = 0;
static String *k_symtab = 0;
static String *k_using = 0;
static String *k_scope = 0;
static String *k_typetab = 0;
static String *k_inherit = 0;
static String *k_parent = 0;
static String *k_value = 0;
static String *k_nodetype = 0;
static String *k_class = 0;
/*
Enable this one if your language fully support SwigValueWrapper<T>.
@ -150,18 +140,6 @@ static void flush_cache() {
/* Initialize the scoping system */
void SwigType_typesystem_init() {
k_name = NewString("name");
k_qname = NewString("qname");
k_symtab = NewString("symtab");
k_using = NewString("using");
k_scope = NewString("scope");
k_typetab = NewString("typetab");
k_inherit = NewString("inherit");
k_parent = NewString("parent");
k_value = NewString("value");
k_nodetype = NewString("nodeType");
k_class = NewString("class");
if (global_scope) Delete(global_scope);
if (scopes) Delete(scopes);