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

Consolidate name mangling functions

Browse source 
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
commit 46f2778412
16 changed files with 194 additions and 210 deletions
Download patch file Download diff file Expand all files Collapse all files

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);
}