Move rename/namewarn engine from parser.y to naming.c. The code was getting
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
parent
d4969b4d0e
commit
55005e98ee
18 changed files with 938 additions and 823 deletions
|
|
@ -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();
|
||||
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -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
176
Source/Swig/swigkeys.c
Normal 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
94
Source/Swig/swigkeys.h
Normal 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__ */
|
||||
|
|
@ -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;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
}
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue