diff mbox series

[v2] libiberty: d-demangle: rename function symbols to be more consistent

Message ID 20211012165608.345135-1-contact@lsferreira.net
State New
Headers show
Series [v2] libiberty: d-demangle: rename function symbols to be more consistent | expand

Commit Message

Luís Ferreira Oct. 12, 2021, 4:56 p.m. UTC
There is some function names with `dlang_parse_` prefix and some with only
`dlang_` prefix that does parsing. The same happens with `dlang_decode_`.

To make things a bit more consistent and easier to understand, this patch adds
the missing prefix, according to the functions signatures.

ChangeLog:
libiberty/
	* d-demangle.c (dlang_function_type): Rename function to
	                                      dlang_parse_function_type
	* d-demangle.c (dlang_function_args): Rename function to
	                                      dlang_parse_function_args
	* d-demangle.c (dlang_type): Rename function to dlang_parse_type
	* d-demangle.c (dlang_value): Rename function to dlang_parse_value
	* d-demangle.c (dlang_lname): Rename function to dlang_parse_lname
	* d-demangle.c (dlang_number): Rename function to dlang_decode_number
	* d-demangle.c (dlang_hexdigit): Rename function to
	                                 dlang_decode_hexdigit
	* d-demangle.c (dlang_decode_backref): Rename function to
	                                       dlang_decode_backref_pos
	* d-demangle.c (dlang_backref): Rename function to dlang_decode_backref
	* d-demangle.c (dlang_symbol_backref): Rename function to
	                                       dlang_parse_symbol_backref
	* d-demangle.c (dlang_type_backref): Rename function to
	                                     dlang_parse_type_backref
	* d-demangle.c (dlang_call_convention): Rename function to
	                                        dlang_parse_call_convention
	* d-demangle.c (dlang_type_modifiers): Rename function to
	                                       dlang_parse_type_modifiers
	* d-demangle.c (dlang_attributes): Rename function to
	                                   dlang_parse_attributes
	* d-demangle.c (dlang_function_type_noreturn): Rename function to
					               dlang_parse_function_type_noreturn
	* d-demangle.c (dlang_identifier): Rename function to
	                                   dlang_parse_identifier
	* d-demangle.c (dlang_template_symbol_param): Rename function to
	                                              dlang_parse_template_symbol_param
	* d-demangle.c (dlang_template_args): Rename function to
	                                      dlang_parse_template_args

Signed-off-by: Luís Ferreira <contact@lsferreira.net>
---
 libiberty/d-demangle.c | 168 ++++++++++++++++++++---------------------
 1 file changed, 84 insertions(+), 84 deletions(-)
diff mbox series

Patch

diff --git a/libiberty/d-demangle.c b/libiberty/d-demangle.c
index 3adf7b562d1..161bd7abd91 100644
--- a/libiberty/d-demangle.c
+++ b/libiberty/d-demangle.c
@@ -183,15 +183,15 @@  struct dlang_info
 #define TEMPLATE_LENGTH_UNKNOWN (-1UL)
 
 /* Prototypes for forward referenced functions */
-static const char *dlang_function_type (string *, const char *,
+static const char *dlang_parse_function_type (string *, const char *,
 					struct dlang_info *);
 
-static const char *dlang_function_args (string *, const char *,
+static const char *dlang_parse_function_args (string *, const char *,
 					struct dlang_info *);
 
-static const char *dlang_type (string *, const char *, struct dlang_info *);
+static const char *dlang_parse_type (string *, const char *, struct dlang_info *);
 
-static const char *dlang_value (string *, const char *, const char *, char,
+static const char *dlang_parse_value (string *, const char *, const char *, char,
 				struct dlang_info *);
 
 static const char *dlang_parse_qualified (string *, const char *,
@@ -206,14 +206,14 @@  static const char *dlang_parse_tuple (string *, const char *,
 static const char *dlang_parse_template (string *, const char *,
 					 struct dlang_info *, unsigned long);
 
-static const char *dlang_lname (string *, const char *, unsigned long);
+static const char *dlang_parse_lname (string *, const char *, unsigned long);
 
 
 /* Extract the number from MANGLED, and assign the result to RET.
    Return the remaining string on success or NULL on failure.
    A result larger than UINT_MAX is considered a failure.  */
 static const char *
-dlang_number (const char *mangled, unsigned long *ret)
+dlang_decode_number (const char *mangled, unsigned long *ret)
 {
   /* Return NULL if trying to extract something that isn't a digit.  */
   if (mangled == NULL || !ISDIGIT (*mangled))
@@ -243,7 +243,7 @@  dlang_number (const char *mangled, unsigned long *ret)
 /* Extract the hex-digit from MANGLED, and assign the result to RET.
    Return the remaining string on success or NULL on failure.  */
 static const char *
-dlang_hexdigit (const char *mangled, char *ret)
+dlang_decode_hexdigit (const char *mangled, char *ret)
 {
   char c;
 
@@ -288,7 +288,7 @@  dlang_call_convention_p (const char *mangled)
    to RET.  Return the remaining string on success or NULL on failure.
    A result <= 0 is a failure.  */
 static const char *
-dlang_decode_backref (const char *mangled, long *ret)
+dlang_decode_backref_pos (const char *mangled, long *ret)
 {
   /* Return NULL if trying to extract something that isn't a digit.  */
   if (mangled == NULL || !ISALPHA (*mangled))
@@ -336,7 +336,7 @@  dlang_decode_backref (const char *mangled, long *ret)
 /* Extract the symbol pointed at by the back reference and assign the result
    to RET.  Return the remaining string on success or NULL on failure.  */
 static const char *
-dlang_backref (const char *mangled, const char **ret, struct dlang_info *info)
+dlang_decode_backref (const char *mangled, const char **ret, struct dlang_info *info)
 {
   (*ret) = NULL;
 
@@ -348,7 +348,7 @@  dlang_backref (const char *mangled, const char **ret, struct dlang_info *info)
   long refpos;
   mangled++;
 
-  mangled = dlang_decode_backref (mangled, &refpos);
+  mangled = dlang_decode_backref_pos (mangled, &refpos);
   if (mangled == NULL)
     return NULL;
 
@@ -364,7 +364,7 @@  dlang_backref (const char *mangled, const char **ret, struct dlang_info *info)
 /* Demangle a back referenced symbol from MANGLED and append it to DECL.
    Return the remaining string on success or NULL on failure.  */
 static const char *
-dlang_symbol_backref (string *decl, const char *mangled,
+dlang_parse_symbol_backref (string *decl, const char *mangled,
 		      struct dlang_info *info)
 {
   /* An identifier back reference always points to a digit 0 to 9.
@@ -377,14 +377,14 @@  dlang_symbol_backref (string *decl, const char *mangled,
   unsigned long len;
 
   /* Get position of the back reference.  */
-  mangled = dlang_backref (mangled, &backref, info);
+  mangled = dlang_decode_backref (mangled, &backref, info);
 
   /* Must point to a simple identifier.  */
-  backref = dlang_number (backref, &len);
+  backref = dlang_decode_number (backref, &len);
   if (backref == NULL || strlen(backref) < len)
     return NULL;
 
-  backref = dlang_lname (decl, backref, len);
+  backref = dlang_parse_lname (decl, backref, len);
   if (backref == NULL)
     return NULL;
 
@@ -395,7 +395,7 @@  dlang_symbol_backref (string *decl, const char *mangled,
    IS_FUNCTION is 1 if the back referenced type is expected to be a function.
    Return the remaining string on success or NULL on failure.  */
 static const char *
-dlang_type_backref (string *decl, const char *mangled, struct dlang_info *info,
+dlang_parse_type_backref (string *decl, const char *mangled, struct dlang_info *info,
 		    int is_function)
 {
   /* A type back reference always points to a letter.
@@ -415,13 +415,13 @@  dlang_type_backref (string *decl, const char *mangled, struct dlang_info *info,
   info->last_backref = mangled - info->s;
 
   /* Get position of the back reference.  */
-  mangled = dlang_backref (mangled, &backref, info);
+  mangled = dlang_decode_backref (mangled, &backref, info);
 
   /* Must point to a type.  */
   if (is_function)
-    backref = dlang_function_type (decl, backref, info);
+    backref = dlang_parse_function_type (decl, backref, info);
   else
-    backref = dlang_type (decl, backref, info);
+    backref = dlang_parse_type (decl, backref, info);
 
   info->last_backref = save_refpos;
 
@@ -449,7 +449,7 @@  dlang_symbol_name_p (const char *mangled, struct dlang_info *info)
   if (*mangled != 'Q')
     return 0;
 
-  mangled = dlang_decode_backref (mangled + 1, &ret);
+  mangled = dlang_decode_backref_pos (mangled + 1, &ret);
   if (mangled == NULL || ret > qref - info->s)
     return 0;
 
@@ -459,7 +459,7 @@  dlang_symbol_name_p (const char *mangled, struct dlang_info *info)
 /* Demangle the calling convention from MANGLED and append it to DECL.
    Return the remaining string on success or NULL on failure.  */
 static const char *
-dlang_call_convention (string *decl, const char *mangled)
+dlang_parse_call_convention (string *decl, const char *mangled)
 {
   if (mangled == NULL || *mangled == '\0')
     return NULL;
@@ -499,7 +499,7 @@  dlang_call_convention (string *decl, const char *mangled)
 /* Extract the type modifiers from MANGLED and append them to DECL.
    Returns the remaining signature on success or NULL on failure.  */
 static const char *
-dlang_type_modifiers (string *decl, const char *mangled)
+dlang_parse_type_modifiers (string *decl, const char *mangled)
 {
   if (mangled == NULL || *mangled == '\0')
     return NULL;
@@ -517,14 +517,14 @@  dlang_type_modifiers (string *decl, const char *mangled)
     case 'O': /* shared */
       mangled++;
       string_append (decl, " shared");
-      return dlang_type_modifiers (decl, mangled);
+      return dlang_parse_type_modifiers (decl, mangled);
     case 'N':
       mangled++;
       if (*mangled == 'g') /* wild */
 	{
 	  mangled++;
 	  string_append (decl, " inout");
-	  return dlang_type_modifiers (decl, mangled);
+	  return dlang_parse_type_modifiers (decl, mangled);
 	}
       else
 	return NULL;
@@ -537,7 +537,7 @@  dlang_type_modifiers (string *decl, const char *mangled)
 /* Demangle the D function attributes from MANGLED and append it to DECL.
    Return the remaining string on success or NULL on failure.  */
 static const char *
-dlang_attributes (string *decl, const char *mangled)
+dlang_parse_attributes (string *decl, const char *mangled)
 {
   if (mangled == NULL || *mangled == '\0')
     return NULL;
@@ -615,20 +615,20 @@  dlang_attributes (string *decl, const char *mangled)
    to throw the information away.  Return the remaining string on success
    or NULL on failure.  */
 static const char *
-dlang_function_type_noreturn (string *args, string *call, string *attr,
+dlang_parse_function_type_noreturn (string *args, string *call, string *attr,
 			      const char *mangled, struct dlang_info *info)
 {
   string dump;
   string_init (&dump);
 
   /* Skip over calling convention and attributes.  */
-  mangled = dlang_call_convention (call ? call : &dump, mangled);
-  mangled = dlang_attributes (attr ? attr : &dump, mangled);
+  mangled = dlang_parse_call_convention (call ? call : &dump, mangled);
+  mangled = dlang_parse_attributes (attr ? attr : &dump, mangled);
 
   if (args)
     string_append (args, "(");
 
-  mangled = dlang_function_args (args ? args : &dump, mangled, info);
+  mangled = dlang_parse_function_args (args ? args : &dump, mangled, info);
   if (args)
     string_append (args, ")");
 
@@ -639,7 +639,7 @@  dlang_function_type_noreturn (string *args, string *call, string *attr,
 /* Demangle the function type from MANGLED and append it to DECL.
    Return the remaining string on success or NULL on failure.  */
 static const char *
-dlang_function_type (string *decl, const char *mangled, struct dlang_info *info)
+dlang_parse_function_type (string *decl, const char *mangled, struct dlang_info *info)
 {
   string attr, args, type;
 
@@ -656,10 +656,10 @@  dlang_function_type (string *decl, const char *mangled, struct dlang_info *info)
   string_init (&args);
   string_init (&type);
 
-  mangled = dlang_function_type_noreturn (&args, decl, &attr, mangled, info);
+  mangled = dlang_parse_function_type_noreturn (&args, decl, &attr, mangled, info);
 
   /* Function return type.  */
-  mangled = dlang_type (&type, mangled, info);
+  mangled = dlang_parse_type (&type, mangled, info);
 
   /* Append to decl in order. */
   string_appendn (decl, type.b, string_length (&type));
@@ -676,7 +676,7 @@  dlang_function_type (string *decl, const char *mangled, struct dlang_info *info)
 /* Demangle the argument list from MANGLED and append it to DECL.
    Return the remaining string on success or NULL on failure.  */
 static const char *
-dlang_function_args (string *decl, const char *mangled, struct dlang_info *info)
+dlang_parse_function_args (string *decl, const char *mangled, struct dlang_info *info)
 {
   size_t n = 0;
 
@@ -738,7 +738,7 @@  dlang_function_args (string *decl, const char *mangled, struct dlang_info *info)
 	  string_append (decl, "lazy ");
 	  break;
 	}
-      mangled = dlang_type (decl, mangled, info);
+      mangled = dlang_parse_type (decl, mangled, info);
     }
 
   return mangled;
@@ -747,7 +747,7 @@  dlang_function_args (string *decl, const char *mangled, struct dlang_info *info)
 /* Demangle the type from MANGLED and append it to DECL.
    Return the remaining string on success or NULL on failure.  */
 static const char *
-dlang_type (string *decl, const char *mangled, struct dlang_info *info)
+dlang_parse_type (string *decl, const char *mangled, struct dlang_info *info)
 {
   if (mangled == NULL || *mangled == '\0')
     return NULL;
@@ -757,19 +757,19 @@  dlang_type (string *decl, const char *mangled, struct dlang_info *info)
     case 'O': /* shared(T) */
       mangled++;
       string_append (decl, "shared(");
-      mangled = dlang_type (decl, mangled, info);
+      mangled = dlang_parse_type (decl, mangled, info);
       string_append (decl, ")");
       return mangled;
     case 'x': /* const(T) */
       mangled++;
       string_append (decl, "const(");
-      mangled = dlang_type (decl, mangled, info);
+      mangled = dlang_parse_type (decl, mangled, info);
       string_append (decl, ")");
       return mangled;
     case 'y': /* immutable(T) */
       mangled++;
       string_append (decl, "immutable(");
-      mangled = dlang_type (decl, mangled, info);
+      mangled = dlang_parse_type (decl, mangled, info);
       string_append (decl, ")");
       return mangled;
     case 'N':
@@ -778,7 +778,7 @@  dlang_type (string *decl, const char *mangled, struct dlang_info *info)
 	{
 	  mangled++;
 	  string_append (decl, "inout(");
-	  mangled = dlang_type (decl, mangled, info);
+	  mangled = dlang_parse_type (decl, mangled, info);
 	  string_append (decl, ")");
 	  return mangled;
 	}
@@ -786,7 +786,7 @@  dlang_type (string *decl, const char *mangled, struct dlang_info *info)
 	{
 	  mangled++;
 	  string_append (decl, "__vector(");
-	  mangled = dlang_type (decl, mangled, info);
+	  mangled = dlang_parse_type (decl, mangled, info);
 	  string_append (decl, ")");
 	  return mangled;
 	}
@@ -800,7 +800,7 @@  dlang_type (string *decl, const char *mangled, struct dlang_info *info)
 	return NULL;
     case 'A': /* dynamic array (T[]) */
       mangled++;
-      mangled = dlang_type (decl, mangled, info);
+      mangled = dlang_parse_type (decl, mangled, info);
       string_append (decl, "[]");
       return mangled;
     case 'G': /* static array (T[N]) */
@@ -815,7 +815,7 @@  dlang_type (string *decl, const char *mangled, struct dlang_info *info)
 	  num++;
 	  mangled++;
 	}
-      mangled = dlang_type (decl, mangled, info);
+      mangled = dlang_parse_type (decl, mangled, info);
       string_append (decl, "[");
       string_appendn (decl, numptr, num);
       string_append (decl, "]");
@@ -828,10 +828,10 @@  dlang_type (string *decl, const char *mangled, struct dlang_info *info)
       mangled++;
 
       string_init (&type);
-      mangled = dlang_type (&type, mangled, info);
+      mangled = dlang_parse_type (&type, mangled, info);
       sztype = string_length (&type);
 
-      mangled = dlang_type (decl, mangled, info);
+      mangled = dlang_parse_type (decl, mangled, info);
       string_append (decl, "[");
       string_appendn (decl, type.b, sztype);
       string_append (decl, "]");
@@ -843,7 +843,7 @@  dlang_type (string *decl, const char *mangled, struct dlang_info *info)
       mangled++;
       if (!dlang_call_convention_p (mangled))
 	{
-	  mangled = dlang_type (decl, mangled, info);
+	  mangled = dlang_parse_type (decl, mangled, info);
 	  string_append (decl, "*");
 	  return mangled;
 	}
@@ -855,7 +855,7 @@  dlang_type (string *decl, const char *mangled, struct dlang_info *info)
     case 'R': /* function T (C++) */
     case 'Y': /* function T (Objective-C) */
       /* Function pointer types don't include the trailing asterisk.  */
-      mangled = dlang_function_type (decl, mangled, info);
+      mangled = dlang_parse_function_type (decl, mangled, info);
       string_append (decl, "function");
       return mangled;
     case 'C': /* class T */
@@ -871,14 +871,14 @@  dlang_type (string *decl, const char *mangled, struct dlang_info *info)
       mangled++;
 
       string_init (&mods);
-      mangled = dlang_type_modifiers (&mods, mangled);
+      mangled = dlang_parse_type_modifiers (&mods, mangled);
       szmods = string_length (&mods);
 
       /* Back referenced function type.  */
       if (mangled && *mangled == 'Q')
-	mangled = dlang_type_backref (decl, mangled, info, 1);
+	mangled = dlang_parse_type_backref (decl, mangled, info, 1);
       else
-	mangled = dlang_function_type (decl, mangled, info);
+	mangled = dlang_parse_function_type (decl, mangled, info);
 
       string_append (decl, "delegate");
       string_appendn (decl, mods.b, szmods);
@@ -1004,7 +1004,7 @@  dlang_type (string *decl, const char *mangled, struct dlang_info *info)
 
     /* Back referenced type.  */
     case 'Q':
-      return dlang_type_backref (decl, mangled, info, 0);
+      return dlang_parse_type_backref (decl, mangled, info, 0);
 
     default: /* unhandled */
       return NULL;
@@ -1014,7 +1014,7 @@  dlang_type (string *decl, const char *mangled, struct dlang_info *info)
 /* Extract the identifier from MANGLED and append it to DECL.
    Return the remaining string on success or NULL on failure.  */
 static const char *
-dlang_identifier (string *decl, const char *mangled, struct dlang_info *info)
+dlang_parse_identifier (string *decl, const char *mangled, struct dlang_info *info)
 {
   unsigned long len;
 
@@ -1022,14 +1022,14 @@  dlang_identifier (string *decl, const char *mangled, struct dlang_info *info)
     return NULL;
 
   if (*mangled == 'Q')
-    return dlang_symbol_backref (decl, mangled, info);
+    return dlang_parse_symbol_backref (decl, mangled, info);
 
   /* May be a template instance without a length prefix.  */
   if (mangled[0] == '_' && mangled[1] == '_'
       && (mangled[2] == 'T' || mangled[2] == 'U'))
     return dlang_parse_template (decl, mangled, info, TEMPLATE_LENGTH_UNKNOWN);
 
-  const char *endptr = dlang_number (mangled, &len);
+  const char *endptr = dlang_decode_number (mangled, &len);
 
   if (endptr == NULL || len == 0)
     return NULL;
@@ -1057,20 +1057,20 @@  dlang_identifier (string *decl, const char *mangled, struct dlang_info *info)
 	{
 	  /* Skip over the fake parent.  */
 	  mangled += len;
-	  return dlang_identifier (decl, mangled, info);
+	  return dlang_parse_identifier (decl, mangled, info);
 	}
 
       /* else demangle it as a plain identifier.  */
     }
 
-  return dlang_lname (decl, mangled, len);
+  return dlang_parse_lname (decl, mangled, len);
 }
 
 /* Extract the plain identifier from MANGLED and prepend/append it to DECL
    with special treatment for some magic compiler generted symbols.
    Return the remaining string on success or NULL on failure.  */
 static const char *
-dlang_lname (string *decl, const char *mangled, unsigned long len)
+dlang_parse_lname (string *decl, const char *mangled, unsigned long len)
 {
   switch (len)
     {
@@ -1171,7 +1171,7 @@  dlang_parse_integer (string *decl, const char *mangled, char type)
       int width = 0;
       unsigned long val;
 
-      mangled = dlang_number (mangled, &val);
+      mangled = dlang_decode_number (mangled, &val);
       if (mangled == NULL)
 	return NULL;
 
@@ -1227,7 +1227,7 @@  dlang_parse_integer (string *decl, const char *mangled, char type)
       /* Parse boolean value.  */
       unsigned long val;
 
-      mangled = dlang_number (mangled, &val);
+      mangled = dlang_decode_number (mangled, &val);
       if (mangled == NULL)
 	return NULL;
 
@@ -1347,7 +1347,7 @@  dlang_parse_string (string *decl, const char *mangled)
   unsigned long len;
 
   mangled++;
-  mangled = dlang_number (mangled, &len);
+  mangled = dlang_decode_number (mangled, &len);
   if (mangled == NULL || *mangled != '_')
     return NULL;
 
@@ -1356,7 +1356,7 @@  dlang_parse_string (string *decl, const char *mangled)
   while (len--)
     {
       char val;
-      const char *endptr = dlang_hexdigit (mangled, &val);
+      const char *endptr = dlang_decode_hexdigit (mangled, &val);
 
       if (endptr == NULL)
 	return NULL;
@@ -1411,14 +1411,14 @@  dlang_parse_arrayliteral (string *decl, const char *mangled,
 {
   unsigned long elements;
 
-  mangled = dlang_number (mangled, &elements);
+  mangled = dlang_decode_number (mangled, &elements);
   if (mangled == NULL)
     return NULL;
 
   string_append (decl, "[");
   while (elements--)
     {
-      mangled = dlang_value (decl, mangled, NULL, '\0', info);
+      mangled = dlang_parse_value (decl, mangled, NULL, '\0', info);
       if (mangled == NULL)
 	return NULL;
 
@@ -1438,19 +1438,19 @@  dlang_parse_assocarray (string *decl, const char *mangled,
 {
   unsigned long elements;
 
-  mangled = dlang_number (mangled, &elements);
+  mangled = dlang_decode_number (mangled, &elements);
   if (mangled == NULL)
     return NULL;
 
   string_append (decl, "[");
   while (elements--)
     {
-      mangled = dlang_value (decl, mangled, NULL, '\0', info);
+      mangled = dlang_parse_value (decl, mangled, NULL, '\0', info);
       if (mangled == NULL)
 	return NULL;
 
       string_append (decl, ":");
-      mangled = dlang_value (decl, mangled, NULL, '\0', info);
+      mangled = dlang_parse_value (decl, mangled, NULL, '\0', info);
       if (mangled == NULL)
 	return NULL;
 
@@ -1470,7 +1470,7 @@  dlang_parse_structlit (string *decl, const char *mangled, const char *name,
 {
   unsigned long args;
 
-  mangled = dlang_number (mangled, &args);
+  mangled = dlang_decode_number (mangled, &args);
   if (mangled == NULL)
     return NULL;
 
@@ -1480,7 +1480,7 @@  dlang_parse_structlit (string *decl, const char *mangled, const char *name,
   string_append (decl, "(");
   while (args--)
     {
-      mangled = dlang_value (decl, mangled, NULL, '\0', info);
+      mangled = dlang_parse_value (decl, mangled, NULL, '\0', info);
       if (mangled == NULL)
 	return NULL;
 
@@ -1495,7 +1495,7 @@  dlang_parse_structlit (string *decl, const char *mangled, const char *name,
 /* Extract the value from MANGLED and append it to DECL.
    Return the remaining string on success or NULL on failure.  */
 static const char *
-dlang_value (string *decl, const char *mangled, const char *name, char type,
+dlang_parse_value (string *decl, const char *mangled, const char *name, char type,
 	     struct dlang_info *info)
 {
   if (mangled == NULL || *mangled == '\0')
@@ -1615,7 +1615,7 @@  dlang_parse_mangle (string *decl, const char *mangled, struct dlang_info *info)
 	  string type;
 
 	  string_init (&type);
-	  mangled = dlang_type (&type, mangled, info);
+	  mangled = dlang_parse_type (&type, mangled, info);
 	  string_delete (&type);
 	}
     }
@@ -1657,7 +1657,7 @@  dlang_parse_qualified (string *decl, const char *mangled,
       while (*mangled == '0')
 	mangled++;
 
-      mangled = dlang_identifier (decl, mangled, info);
+      mangled = dlang_parse_identifier (decl, mangled, info);
 
       /* Consume the encoded arguments.  However if this is not followed by the
 	 next encoded length or mangle type, then this is not a continuation of
@@ -1676,11 +1676,11 @@  dlang_parse_qualified (string *decl, const char *mangled,
 	  if (*mangled == 'M')
 	    {
 	      mangled++;
-	      mangled = dlang_type_modifiers (&mods, mangled);
+	      mangled = dlang_parse_type_modifiers (&mods, mangled);
 	      string_setlength (decl, saved);
 	    }
 
-	  mangled = dlang_function_type_noreturn (decl, NULL, NULL,
+	  mangled = dlang_parse_function_type_noreturn (decl, NULL, NULL,
 						  mangled, info);
 	  if (suffix_modifiers)
 	    string_appendn (decl, mods.b, string_length (&mods));
@@ -1707,7 +1707,7 @@  dlang_parse_tuple (string *decl, const char *mangled, struct dlang_info *info)
 {
   unsigned long elements;
 
-  mangled = dlang_number (mangled, &elements);
+  mangled = dlang_decode_number (mangled, &elements);
   if (mangled == NULL)
     return NULL;
 
@@ -1715,7 +1715,7 @@  dlang_parse_tuple (string *decl, const char *mangled, struct dlang_info *info)
 
   while (elements--)
     {
-      mangled = dlang_type (decl, mangled, info);
+      mangled = dlang_parse_type (decl, mangled, info);
       if (mangled == NULL)
 	return NULL;
 
@@ -1730,7 +1730,7 @@  dlang_parse_tuple (string *decl, const char *mangled, struct dlang_info *info)
 /* Demangle the template symbol parameter from MANGLED and append it to DECL.
    Return the remaining string on success or NULL on failure.  */
 static const char *
-dlang_template_symbol_param (string *decl, const char *mangled,
+dlang_parse_template_symbol_param (string *decl, const char *mangled,
 			     struct dlang_info *info)
 {
   if (strncmp (mangled, "_D", 2) == 0
@@ -1741,7 +1741,7 @@  dlang_template_symbol_param (string *decl, const char *mangled,
     return dlang_parse_qualified (decl, mangled, info, 0);
 
   unsigned long len;
-  const char *endptr = dlang_number (mangled, &len);
+  const char *endptr = dlang_decode_number (mangled, &len);
 
   if (endptr == NULL || len == 0)
     return NULL;
@@ -1791,7 +1791,7 @@  dlang_template_symbol_param (string *decl, const char *mangled,
 /* Demangle the argument list from MANGLED and append it to DECL.
    Return the remaining string on success or NULL on failure.  */
 static const char *
-dlang_template_args (string *decl, const char *mangled, struct dlang_info *info)
+dlang_parse_template_args (string *decl, const char *mangled, struct dlang_info *info)
 {
   size_t n = 0;
 
@@ -1815,11 +1815,11 @@  dlang_template_args (string *decl, const char *mangled, struct dlang_info *info)
 	{
 	case 'S': /* Symbol parameter.  */
 	  mangled++;
-	  mangled = dlang_template_symbol_param (decl, mangled, info);
+	  mangled = dlang_parse_template_symbol_param (decl, mangled, info);
 	  break;
 	case 'T': /* Type parameter.  */
 	  mangled++;
-	  mangled = dlang_type (decl, mangled, info);
+	  mangled = dlang_parse_type (decl, mangled, info);
 	  break;
 	case 'V': /* Value parameter.  */
 	{
@@ -1834,7 +1834,7 @@  dlang_template_args (string *decl, const char *mangled, struct dlang_info *info)
 	    {
 	      /* Value type is a back reference, peek at the real type.  */
 	      const char *backref;
-	      if (dlang_backref (mangled, &backref, info) == NULL)
+	      if (dlang_decode_backref (mangled, &backref, info) == NULL)
 		return NULL;
 
 	      type = *backref;
@@ -1843,11 +1843,11 @@  dlang_template_args (string *decl, const char *mangled, struct dlang_info *info)
 	  /* In the few instances where the type is actually desired in
 	     the output, it should precede the value from dlang_value.  */
 	  string_init (&name);
-	  mangled = dlang_type (&name, mangled, info);
+	  mangled = dlang_parse_type (&name, mangled, info);
 	  string_need (&name, 1);
 	  *(name.p) = '\0';
 
-	  mangled = dlang_value (decl, mangled, name.b, type, info);
+	  mangled = dlang_parse_value (decl, mangled, name.b, type, info);
 	  string_delete (&name);
 	  break;
 	}
@@ -1857,7 +1857,7 @@  dlang_template_args (string *decl, const char *mangled, struct dlang_info *info)
 	  const char *endptr;
 
 	  mangled++;
-	  endptr = dlang_number (mangled, &len);
+	  endptr = dlang_decode_number (mangled, &len);
 	  if (endptr == NULL || strlen (endptr) < len)
 	    return NULL;
 
@@ -1901,11 +1901,11 @@  dlang_parse_template (string *decl, const char *mangled,
   mangled += 3;
 
   /* Template identifier.  */
-  mangled = dlang_identifier (decl, mangled, info);
+  mangled = dlang_parse_identifier (decl, mangled, info);
 
   /* Template arguments.  */
   string_init (&args);
-  mangled = dlang_template_args (&args, mangled, info);
+  mangled = dlang_parse_template_args (&args, mangled, info);
 
   string_append (decl, "!(");
   string_appendn (decl, args.b, string_length (&args));