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

Source/Modules/go.cxx

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

Source/Modules/guile.cxx

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

Source/Modules/javascript.cxx

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

Source/Modules/lang.cxx

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

Source/Modules/lua.cxx

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

Source/Modules/mzscheme.cxx

@@ -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, "_", "-");

Source/Modules/octave.cxx

@@ -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;

Source/Modules/ruby.cxx

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

Source/Modules/tcl8.cxx

@@ -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");

Source/Preprocessor/cpp.c

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

Source/Swig/cwrap.c

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

Source/Swig/fragment.c

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

Source/Swig/misc.c

@@ -702,170 +702,8 @@ String *Swig_string_typecode(String *s) {
   return ns;
 }
 
-/* -----------------------------------------------------------------------------
+static String *string_mangle(String *s) {
- * Swig_string_mangle_type()
+  return Swig_name_mangle_string(s);
- * 
- * 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);
 }
 
 
@@ -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);

Source/Swig/naming.c

@@ -157,21 +157,168 @@ static void replace_nspace(String *name, const_String_or_char_ptr nspace) {
 }
 
 /* -----------------------------------------------------------------------------
- * Swig_name_mangle()
+ * Swig_name_mangle_type()
- *
+ * 
- * Converts all of the non-identifier characters of a string to underscores.
+ * 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) {
+String *Swig_name_mangle_type(const SwigType *s) {
-#if 0
+  String *mangled = 0;
-  String *r = NewString(s);
+  String *b = Copy(s);
-  name_mangle(r);
+  if (SwigType_istemplate(b)) {
-  return r;
+    String *st = Swig_symbol_template_deftype(b, 0);
-#else
+    String *sq = Swig_symbol_type_qualify(st, 0);
-  return Swig_string_mangle(s);
+    String *t = SwigType_namestr(sq);
-#endif
+    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()
  *

Source/Swig/swig.h

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

Source/Swig/typemap.c

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