XS-MLVP
/
swig
mirror of https://github.com/swig/swig
5
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Consolidate name mangling functions 

Swig_string_mangle      => Swig_name_mangle_string
Swig_name_mangle        => Swig_name_mangle_string
Swig_string_mangle_type => Swig_name_mangle_type
This commit is contained in:
William S Fulton 2022-11-12 09:18:19 +00:00
parent 3364c18d06
commit 46f2778412
16 changed files with 194 additions and 210 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
Source/Modules/go.cxx
View File

@ -4677,7 +4677,7 @@ private:
u[2] = '\0';
Replace(copy, l, u, DOH_REPLACE_FIRST);
}
String *ret = Swig_string_mangle_type(copy);
String *ret = Swig_name_mangle_type(copy);
Delete(copy);
return ret;
}
@ -4725,7 +4725,7 @@ private:
Append(nw, c3);
Delete(c2);
Delete(c3);
String *ret = Swig_name_mangle(nw);
String *ret = Swig_name_mangle_string(nw);
Delete(nw);
return ret;
}
@ -4742,7 +4742,7 @@ private:
String *buildGoWrapperName(String *name, String *overname) {
String *s1 = NewString("_swig_wrap_");
Append(s1, name);
String *s2 = Swig_name_mangle(s1);
String *s2 = Swig_name_mangle_string(s1);
Delete(s1);
if (overname) {
Append(s2, overname);
@ -5576,7 +5576,7 @@ private:
}
}
ret = Swig_string_mangle_type(s);
ret = Swig_name_mangle_type(s);
Delete(s);
return ret;
}

2
Source/Modules/guile.cxx
View File

@ -1396,7 +1396,7 @@ public:
SwigType *ct = NewStringf("p.%s", Getattr(n, "name"));
swigtype_ptr = SwigType_manglestr(ct);
String *mangled_classname = Swig_name_mangle(Getattr(n, "sym:name"));
String *mangled_classname = Swig_name_mangle_string(Getattr(n, "sym:name"));
/* Export clientdata structure */
Printf(f_runtime, "static swig_guile_clientdata _swig_guile_clientdata%s = { NULL, SCM_EOL };\n", mangled_classname);

2
Source/Modules/javascript.cxx
View File

@ -1461,7 +1461,7 @@ Hash *JSEmitter::createNamespaceEntry(const char *_name, const char *parent, con
Hash *entry = NewHash();
String *name = NewString(_name);
Setattr(entry, NAME, Swig_scopename_last(name));
Setattr(entry, NAME_MANGLED, Swig_name_mangle(name));
Setattr(entry, NAME_MANGLED, Swig_name_mangle_string(name));
Setattr(entry, PARENT, NewString(parent));
Setattr(entry, PARENT_MANGLED, NewString(parent_mangled));

6
Source/Modules/lang.cxx
View File

@ -1311,7 +1311,7 @@ int Language::staticmemberfunctionHandler(Node *n) {
cname = NewStringf("%s::%s", sname, name);
} else {
String *classname_str = SwigType_namestr(ClassName);
String *mname = Swig_name_mangle(classname_str);
String *mname = Swig_name_mangle_string(classname_str);
cname = Swig_name_member(NSpace, mname, name);
Delete(mname);
Delete(classname_str);
@ -1321,7 +1321,7 @@ int Language::staticmemberfunctionHandler(Node *n) {
if (Extend) {
String *code = Getattr(n, "code");
String *defaultargs = Getattr(n, "defaultargs");
String *mangled = Swig_name_mangle(mrename);
String *mangled = Swig_name_mangle_string(mrename);
Delete(mrename);
mrename = mangled;
@ -1335,7 +1335,7 @@ int Language::staticmemberfunctionHandler(Node *n) {
if (!defaultargs) {
/* Hmmm. An added static member. We have to create a little wrapper for this */
String *mangled_cname = Swig_name_mangle(cname);
String *mangled_cname = Swig_name_mangle_string(cname);
Swig_add_extension_code(n, mangled_cname, parms, type, code, CPlusPlus, 0);
Setattr(n, "extendname", mangled_cname);
Delete(mangled_cname);

4
Source/Modules/lua.cxx
View File

@ -1269,7 +1269,7 @@ public:
full_proxy_class_name = NewStringf("%s.%s", nspace, proxy_class_name);
assert(full_proxy_class_name);
mangled_full_proxy_class_name = Swig_name_mangle(full_proxy_class_name);
mangled_full_proxy_class_name = Swig_name_mangle_string(full_proxy_class_name);
SwigType *t = Copy(Getattr(n, "name"));
SwigType *fr_t = SwigType_typedef_resolve_all(t); /* Create fully resolved type */
@ -1803,7 +1803,7 @@ public:
if (nspace == 0 || Len(nspace) == 0)
mangled_name = NewString("SwigModule");
else
mangled_name = Swig_name_mangle(nspace);
mangled_name = Swig_name_mangle_string(nspace);
String *cname = NewStringf("swig_%s", mangled_name);
Setattr(carrays_hash, "cname", cname);

4
Source/Modules/mzscheme.cxx
View File

@ -569,7 +569,7 @@ public:
// Make a static variable;
Printf(var_name, "_wrap_const_%s", Swig_name_mangle(Getattr(n, "sym:name")));
Printf(var_name, "_wrap_const_%s", Swig_name_mangle_string(Getattr(n, "sym:name")));
// Build the name for scheme.
Printv(proc_name, iname, NIL);
@ -656,7 +656,7 @@ public:
convert_proto_tab = NewString("");
struct_name = Getattr(n, "sym:name");
mangled_struct_name = Swig_name_mangle(Getattr(n, "sym:name"));
mangled_struct_name = Swig_name_mangle_string(Getattr(n, "sym:name"));
Printv(scm_structname, struct_name, NIL);
Replaceall(scm_structname, "_", "-");

2
Source/Modules/octave.cxx
View File

@ -946,7 +946,7 @@ public:
// This is a bug, due to the fact that swig_type -> octave_class mapping
// is 1-to-n.
static Hash *emitted = NewHash();
String *mangled_classname = Swig_string_mangle_type(Getattr(n, "name"));
String *mangled_classname = Swig_name_mangle_type(Getattr(n, "name"));
if (Getattr(emitted, mangled_classname)) {
Delete(mangled_classname);
return SWIG_NOWRAP;

2
Source/Modules/ruby.cxx
View File

@ -85,7 +85,7 @@ public:
/* Mangled name */
Delete(mname);
mname = Swig_name_mangle(cname);
mname = Swig_name_mangle_string(cname);
/* Renamed class name */
Clear(name);

4
Source/Modules/tcl8.cxx
View File

@ -740,7 +740,7 @@ public:
return SWIG_ERROR;
real_classname = Getattr(n, "name");
mangled_classname = Swig_string_mangle_type(real_classname);
mangled_classname = Swig_name_mangle_type(real_classname);
if (Getattr(emitted, mangled_classname))
return SWIG_NOWRAP;
@ -816,7 +816,7 @@ public:
Printv(base_classes, bname, " ", NIL);
Printv(base_class_init, " ", bname, "Ptr::constructor $ptr\n", NIL);
}
String *bmangle = Swig_string_mangle_type(bname);
String *bmangle = Swig_name_mangle_type(bname);
// Printv(f_wrappers,"extern swig_class _wrap_class_", bmangle, ";\n", NIL);
// Printf(base_class,"&_wrap_class_%s",bmangle);
Printf(base_class, "0");

4
Source/Preprocessor/cpp.c
View File

@ -950,14 +950,14 @@ static String *expand_macro(String *name, List *args, String *line_file) {
/* Non-standard mangle expansions.
The #@Name is replaced by mangle_arg(Name). */
if (strstr(Char(ns), "\004")) {
String *marg = Swig_string_mangle(arg);
String *marg = Swig_name_mangle_string(arg);
Clear(temp);
Printf(temp, "\004%s", aname);
Replace(ns, temp, marg, DOH_REPLACE_ID_END);
Delete(marg);
}
if (strstr(Char(ns), "\005")) {
String *marg = Swig_string_mangle(arg);
String *marg = Swig_name_mangle_string(arg);
Clear(temp);
Clear(tempa);
Printf(temp, "\005%s", aname);

14
Source/Swig/cwrap.c
View File

@ -1075,7 +1075,7 @@ int Swig_MethodToFunction(Node *n, const_String_or_char_ptr nspace, String *clas
String *code = Getattr(n, "code");
String *cname = Getattr(n, "extendsmartclassname") ? Getattr(n, "extendsmartclassname") : classname;
String *membername = Swig_name_member(nspace, cname, name);
String *mangled = Swig_name_mangle(membername);
String *mangled = Swig_name_mangle_string(membername);
int is_smart_pointer = flags & CWRAP_SMART_POINTER;
type = Getattr(n, "type");
@ -1238,7 +1238,7 @@ int Swig_ConstructorToFunction(Node *n, const_String_or_char_ptr nspace, String
String *defaultargs = Getattr(n, "defaultargs");
String *code = Getattr(n, "code");
String *membername = Swig_name_construct(nspace, classname);
String *mangled = Swig_name_mangle(membername);
String *mangled = Swig_name_mangle_string(membername);
/* Check if the constructor is overloaded. If so, and it has code attached, we append an extra suffix
to avoid a name-clash in the generated wrappers. This allows overloaded constructors to be defined
@ -1356,7 +1356,7 @@ int Swig_DestructorToFunction(Node *n, const_String_or_char_ptr nspace, String *
String *call;
String *membername, *mangled, *code;
membername = Swig_name_destroy(nspace, classname);
mangled = Swig_name_mangle(membername);
mangled = Swig_name_mangle_string(membername);
code = Getattr(n, "code");
if (code) {
Swig_add_extension_code(n, mangled, p, type, code, cparse_cplusplus, "self");
@ -1443,7 +1443,7 @@ int Swig_MembersetToFunction(Node *n, String *classname, int flags) {
String *sname = Swig_name_set(0, name);
String *membername = Swig_name_member(0, classname, sname);
String *mangled = Swig_name_mangle(membername);
String *mangled = Swig_name_mangle_string(membername);
if (code) {
/* I don't think this ever gets run - WSF */
@ -1525,7 +1525,7 @@ int Swig_MembergetToFunction(Node *n, String *classname, int flags) {
String *gname = Swig_name_get(0, name);
String *membername = Swig_name_member(0, classname, gname);
String *mangled = Swig_name_mangle(membername);
String *mangled = Swig_name_mangle_string(membername);
if (code) {
/* I don't think this ever gets run - WSF */
@ -1577,7 +1577,7 @@ int Swig_VarsetToFunction(Node *n, int flags) {
if (flags & CWRAP_EXTEND) {
String *sname = Swig_name_set(0, name);
String *mangled = Swig_name_mangle(sname);
String *mangled = Swig_name_mangle_string(sname);
String *call = Swig_cfunction_call(mangled, parms);
String *cres = NewStringf("%s;", call);
Setattr(n, "wrap:action", cres);
@ -1631,7 +1631,7 @@ int Swig_VargetToFunction(Node *n, int flags) {
if (flags & CWRAP_EXTEND) {
String *sname = Swig_name_get(0, name);
String *mangled = Swig_name_mangle(sname);
String *mangled = Swig_name_mangle_string(sname);
call = Swig_cfunction_call(mangled, 0);
cres = Swig_cresult(ty, Swig_cresult_name(), call);
Setattr(n, "wrap:action", cres);

6
Source/Swig/fragment.c
View File

@ -41,7 +41,7 @@ void Swig_fragment_register(Node *fragment) {
String *type = Getattr(fragment, "type");
if (type) {
SwigType *rtype = SwigType_typedef_resolve_all(type);
String *mangle = Swig_string_mangle_type(type);
String *mangle = Swig_name_mangle_type(type);
Append(name, mangle);
Delete(mangle);
Delete(rtype);
@ -106,7 +106,7 @@ void Swig_fragment_emit(Node *n) {
type = Getattr(n, "type");
if (type) {
mangle = Swig_string_mangle_type(type);
mangle = Swig_name_mangle_type(type);
}
if (debug)
@ -162,7 +162,7 @@ void Swig_fragment_emit(Node *n) {
SwigType *rtype = SwigType_typedef_resolve_all(type);
if (!Equal(type, rtype)) {
String *name = Copy(Getattr(n, "value"));
String *mangle = Swig_string_mangle_type(type);
String *mangle = Swig_name_mangle_type(type);
Append(name, mangle);
Setfile(name, Getfile(n));
Setline(name, Getline(n));

168
Source/Swig/misc.c
View File

@ -702,170 +702,8 @@ String *Swig_string_typecode(String *s) {
return ns;
}
/* -----------------------------------------------------------------------------
* Swig_string_mangle_type()
*
* Same as Swig_string_mangle, but converting internal SwigType * to a human
* readable string of the type (for templates). Simplifies a type that is a
* template to the default template if possible.
* ----------------------------------------------------------------------------- */
String *Swig_string_mangle_type(const SwigType *s) {
String *mangled = 0;
String *b = Copy(s);
if (SwigType_istemplate(b)) {
String *st = Swig_symbol_template_deftype(b, 0);
String *sq = Swig_symbol_type_qualify(st, 0);
String *t = SwigType_namestr(sq);
Delete(st);
Delete(sq);
Delete(b);
b = t;
}
mangled = Swig_string_mangle(b);
Delete(b);
return mangled;
}
/* -----------------------------------------------------------------------------
* Swig_string_mangle()
*
* Take a string and mangle it by stripping all non-valid C identifier
* characters.
*
* This routine skips unnecessary blank spaces, therefore mangling
* 'char *' and 'char*', 'std::pair<int, int >' and
* 'std::pair<int,int>', produce the same result.
*
* However, note that 'long long' and 'long_long' produce different
* mangled strings.
*
* The mangling method still is not 'perfect', for example std::pair and
* std_pair return the same mangling. This is just a little better
* than before, but it seems to be enough for most of the purposes.
*
* Having a perfect mangling will break some examples and code which
* assume, for example, that A::get_value will be mangled as
* A_get_value.
* ----------------------------------------------------------------------------- */
String *Swig_string_mangle(const String *s) {
String *result = NewStringEmpty();
int space = 0;
int state = 0;
char *pc, *cb;
pc = cb = Char(s);
while (*pc) {
char c = *pc;
if (isalnum((int) c) || (c == '_')) {
state = 1;
if (space && (space == state)) {
Append(result, "_SS_");
}
space = 0;
Printf(result, "%c", (int) c);
} else {
if (isspace((int) c)) {
space = state;
++pc;
continue;
} else {
state = 3;
space = 0;
}
switch (c) {
case '.':
if ((cb != pc) && (*(pc - 1) == 'p')) {
Append(result, "_");
++pc;
continue;
} else {
c = 'f';
}
break;
case ':':
if (*(pc + 1) == ':') {
Append(result, "_");
++pc;
++pc;
continue;
}
break;
case '*':
c = 'm';
break;
case '&':
c = 'A';
break;
case '<':
c = 'l';
break;
case '>':
c = 'g';
break;
case '=':
c = 'e';
break;
case ',':
c = 'c';
break;
case '(':
c = 'p';
break;
case ')':
c = 'P';
break;
case '[':
c = 'b';
break;
case ']':
c = 'B';
break;
case '^':
c = 'x';
break;
case '|':
c = 'o';
break;
case '~':
c = 'n';
break;
case '!':
c = 'N';
break;
case '%':
c = 'M';
break;
case '?':
c = 'q';
break;
case '+':
c = 'a';
break;
case '-':
c = 's';
break;
case '/':
c = 'd';
break;
default:
break;
}
if (isalpha((int) c)) {
Printf(result, "_S%c_", (int) c);
} else {
Printf(result, "_S%02X_", (int) c);
}
}
++pc;
}
return result;
}
String *Swig_string_emangle(String *s) {
return Swig_string_mangle(s);
static String *string_mangle(String *s) {
return Swig_name_mangle_string(s);
}
@ -1542,7 +1380,7 @@ void Swig_init(void) {
DohEncoding("lctitle", Swig_string_lccase);
DohEncoding("utitle", Swig_string_ucase);
DohEncoding("typecode", Swig_string_typecode);
DohEncoding("mangle", Swig_string_emangle);
DohEncoding("mangle", string_mangle);
DohEncoding("command", Swig_string_command);
DohEncoding("schemify", Swig_string_schemify);
DohEncoding("strip", Swig_string_strip);

169
Source/Swig/naming.c
View File

@ -157,21 +157,168 @@ static void replace_nspace(String *name, const_String_or_char_ptr nspace) {
}
/* -----------------------------------------------------------------------------
* Swig_name_mangle()
*
* Converts all of the non-identifier characters of a string to underscores.
* Swig_name_mangle_type()
*
* Same as Swig_name_mangle_string, but converting internal SwigType * to a human
* readable string of the type (for templates). Simplifies a type that is a
* template to the default template if possible.
* ----------------------------------------------------------------------------- */
String *Swig_name_mangle(const_String_or_char_ptr s) {
#if 0
String *r = NewString(s);
name_mangle(r);
return r;
#else
return Swig_string_mangle(s);
#endif
String *Swig_name_mangle_type(const SwigType *s) {
String *mangled = 0;
String *b = Copy(s);
if (SwigType_istemplate(b)) {
String *st = Swig_symbol_template_deftype(b, 0);
String *sq = Swig_symbol_type_qualify(st, 0);
String *t = SwigType_namestr(sq);
Delete(st);
Delete(sq);
Delete(b);
b = t;
}
mangled = Swig_name_mangle_string(b);
Delete(b);
return mangled;
}
/* -----------------------------------------------------------------------------
* Swig_name_mangle_string()
*
* Take a string and mangle it by stripping all non-valid C identifier
* characters.
*
* This routine skips unnecessary blank spaces, therefore mangling
* 'char *' and 'char*', 'std::pair<int, int >' and
* 'std::pair<int,int>', produce the same result.
*
* However, note that 'long long' and 'long_long' produce different
* mangled strings.
*
* The mangling method still is not 'perfect', for example std::pair and
* std_pair return the same mangling. This is just a little better
* than before, but it seems to be enough for most of the purposes.
*
* Having a perfect mangling will break some examples and code which
* assume, for example, that A::get_value will be mangled as
* A_get_value.
* ----------------------------------------------------------------------------- */
String *Swig_name_mangle_string(const String *s) {
String *result = NewStringEmpty();
int space = 0;
int state = 0;
char *pc, *cb;
pc = cb = Char(s);
while (*pc) {
char c = *pc;
if (isalnum((int) c) || (c == '_')) {
state = 1;
if (space && (space == state)) {
Append(result, "_SS_");
}
space = 0;
Printf(result, "%c", (int) c);
} else {
if (isspace((int) c)) {
space = state;
++pc;
continue;
} else {
state = 3;
space = 0;
}
switch (c) {
case '.':
if ((cb != pc) && (*(pc - 1) == 'p')) {
Append(result, "_");
++pc;
continue;
} else {
c = 'f';
}
break;
case ':':
if (*(pc + 1) == ':') {
Append(result, "_");
++pc;
++pc;
continue;
}
break;
case '*':
c = 'm';
break;
case '&':
c = 'A';
break;
case '<':
c = 'l';
break;
case '>':
c = 'g';
break;
case '=':
c = 'e';
break;
case ',':
c = 'c';
break;
case '(':
c = 'p';
break;
case ')':
c = 'P';
break;
case '[':
c = 'b';
break;
case ']':
c = 'B';
break;
case '^':
c = 'x';
break;
case '|':
c = 'o';
break;
case '~':
c = 'n';
break;
case '!':
c = 'N';
break;
case '%':
c = 'M';
break;
case '?':
c = 'q';
break;
case '+':
c = 'a';
break;
case '-':
c = 's';
break;
case '/':
c = 'd';
break;
default:
break;
}
if (isalpha((int) c)) {
Printf(result, "_S%c_", (int) c);
} else {
Printf(result, "_S%02X_", (int) c);
}
}
++pc;
}
return result;
}
/* -----------------------------------------------------------------------------
* Swig_name_wrapper()
*

5
Source/Swig/swig.h
View File

@ -271,7 +271,8 @@ extern int ParmList_is_compactdefargs(ParmList *p);
extern void Swig_name_register(const_String_or_char_ptr method, const_String_or_char_ptr format);
extern void Swig_name_unregister(const_String_or_char_ptr method);
extern String *Swig_name_mangle(const_String_or_char_ptr s);
extern String *Swig_name_mangle_string(const String *s);
extern String *Swig_name_mangle_type(const SwigType *s);
extern String *Swig_name_wrapper(const_String_or_char_ptr fname);
extern String *Swig_name_member(const_String_or_char_ptr nspace, const_String_or_char_ptr classname, const_String_or_char_ptr membername);
extern String *Swig_name_get(const_String_or_char_ptr nspace, const_String_or_char_ptr vname);
@ -323,8 +324,6 @@ extern int ParmList_is_compactdefargs(ParmList *p);
extern int Swig_storage_isstatic_custom(Node *n, const_String_or_char_ptr storage);
extern int Swig_storage_isstatic(Node *n);
extern String *Swig_string_escape(String *s);
extern String *Swig_string_mangle(const String *s);
extern String *Swig_string_mangle_type(const SwigType *s);
extern void Swig_scopename_split(const String *s, String **prefix, String **last);
extern String *Swig_scopename_prefix(const String *s);
extern String *Swig_scopename_last(const String *s);

4
Source/Swig/typemap.c
View File

@ -1293,7 +1293,7 @@ static void typemap_merge_fragment_kwargs(Parm *kw) {
reattach_kw = prev_kw;
}
if (kwtype) {
String *mangle = Swig_string_mangle_type(kwtype);
String *mangle = Swig_name_mangle_type(kwtype);
Append(fragment, mangle);
Delete(mangle);
/* Remove 'type' from kwargs so it's not duplicated later */
@ -1541,7 +1541,7 @@ static String *Swig_typemap_lookup_impl(const_String_or_char_ptr tmap_method, No
Delete(parm_sublist);
}
if (kwtype) {
String *mangle = Swig_string_mangle_type(kwtype);
String *mangle = Swig_name_mangle_type(kwtype);
Append(value, mangle);
Delete(mangle);
}