Skip to content

R
riscv-gcc-1
Commit 5d644692 by Mike Stump
Options

cplus-dem.c: Fix indenting; note that this file also lives in libiberty. 

        * cplus-dem.c: Fix indenting; note that this file also lives in
        libiberty.
        (do_type, case 'M'): Check for a template as well as a class.

From-SVN: r13503
parent 79aff5ac
Showing with 476 additions and 456 deletions
gcc/cplus-dem.c
...@@ -25,6 +25,9 @@ Boston, MA 02111-1307, USA. */ ...@@ -25,6 +25,9 @@ Boston, MA 02111-1307, USA. */
realloc except that they generate a fatal error if there is no realloc except that they generate a fatal error if there is no
available memory. */ available memory. */
/* This file lives in both GCC and libiberty. When making changes, please
try not to break either. */
#include <ctype.h> #include <ctype.h>
#include <string.h> #include <string.h>
#include <stdio.h> #include <stdio.h>
...@@ -38,7 +41,7 @@ extern char *xrealloc PARAMS((char *, unsigned)); ...@@ -38,7 +41,7 @@ extern char *xrealloc PARAMS((char *, unsigned));
char * char *
mystrstr (s1, s2) mystrstr (s1, s2)
char *s1, *s2; char *s1, *s2;
{ {
register char *p = s1; register char *p = s1;
register int len = strlen (s2); register int len = strlen (s2);
...@@ -81,7 +84,7 @@ void ...@@ -81,7 +84,7 @@ void
set_cplus_marker_for_demangling (ch) set_cplus_marker_for_demangling (ch)
int ch; int ch;
{ {
cplus_markers[0] = ch; cplus_markers[0] = ch;
} }
/* Stuff that is shared between sub-routines. /* Stuff that is shared between sub-routines.
...@@ -198,9 +201,9 @@ typedef struct string /* Beware: these aren't required to be */ ...@@ -198,9 +201,9 @@ typedef struct string /* Beware: these aren't required to be */
#define STRING_EMPTY(str) ((str) -> b == (str) -> p) #define STRING_EMPTY(str) ((str) -> b == (str) -> p)
#define PREPEND_BLANK(str) {if (!STRING_EMPTY(str)) \ #define PREPEND_BLANK(str) {if (!STRING_EMPTY(str)) \
string_prepend(str, " ");} string_prepend(str, " ");}
#define APPEND_BLANK(str) {if (!STRING_EMPTY(str)) \ #define APPEND_BLANK(str) {if (!STRING_EMPTY(str)) \
string_append(str, " ");} string_append(str, " ");}
#define ARM_VTABLE_STRING "__vtbl__" /* Lucid/ARM virtual table prefix */ #define ARM_VTABLE_STRING "__vtbl__" /* Lucid/ARM virtual table prefix */
#define ARM_VTABLE_STRLEN 8 /* strlen (ARM_VTABLE_STRING) */ #define ARM_VTABLE_STRLEN 8 /* strlen (ARM_VTABLE_STRING) */
...@@ -308,17 +311,17 @@ string_prepends PARAMS ((string *, string *)); ...@@ -308,17 +311,17 @@ string_prepends PARAMS ((string *, string *));
static int static int
consume_count (type) consume_count (type)
const char **type; const char **type;
{ {
int count = 0; int count = 0;
while (isdigit (**type)) while (isdigit (**type))
{ {
count *= 10; count *= 10;
count += **type - '0'; count += **type - '0';
(*type)++; (*type)++;
} }
return (count); return (count);
} }
int int
...@@ -338,7 +341,7 @@ cplus_demangle_opname (opname, result, options) ...@@ -338,7 +341,7 @@ cplus_demangle_opname (opname, result, options)
work->options = options; work->options = options;
if (opname[0] == '_' && opname[1] == '_' if (opname[0] == '_' && opname[1] == '_'
&& opname[2] == 'o' && opname[3] == 'p') && opname[2] == 'o' && opname[3] == 'p')
{ {
/* ANSI. */ /* ANSI. */
/* type conversion operator. */ /* type conversion operator. */
...@@ -390,9 +393,9 @@ cplus_demangle_opname (opname, result, options) ...@@ -390,9 +393,9 @@ cplus_demangle_opname (opname, result, options)
} }
} }
else if (len >= 3 else if (len >= 3
&& opname[0] == 'o' && opname[0] == 'o'
&& opname[1] == 'p' && opname[1] == 'p'
&& strchr (cplus_markers, opname[2]) != NULL) && strchr (cplus_markers, opname[2]) != NULL)
{ {
/* see if it's an assignment expression */ /* see if it's an assignment expression */
if (len >= 10 /* op$assign_ */ if (len >= 10 /* op$assign_ */
...@@ -643,150 +646,150 @@ demangle_signature (work, mangled, declp) ...@@ -643,150 +646,150 @@ demangle_signature (work, mangled, declp)
{ {
switch (**mangled) switch (**mangled)
{ {
case 'Q': case 'Q':
oldmangled = *mangled; oldmangled = *mangled;
success = demangle_qualified (work, mangled, declp, 1, 0); success = demangle_qualified (work, mangled, declp, 1, 0);
if (success) if (success)
{ {
remember_type (work, oldmangled, *mangled - oldmangled); remember_type (work, oldmangled, *mangled - oldmangled);
} }
if (AUTO_DEMANGLING || GNU_DEMANGLING) if (AUTO_DEMANGLING || GNU_DEMANGLING)
{ {
expect_func = 1; expect_func = 1;
} }
oldmangled = NULL; oldmangled = NULL;
break; break;
case 'S': case 'S':
/* Static member function */ /* Static member function */
if (oldmangled == NULL) if (oldmangled == NULL)
{ {
oldmangled = *mangled; oldmangled = *mangled;
} }
(*mangled)++; (*mangled)++;
work -> static_type = 1; work -> static_type = 1;
break; break;
case 'C': case 'C':
/* a const member function */ /* a const member function */
if (oldmangled == NULL) if (oldmangled == NULL)
{ {
oldmangled = *mangled; oldmangled = *mangled;
} }
(*mangled)++; (*mangled)++;
work -> const_type = 1; work -> const_type = 1;
break; break;
case '0': case '1': case '2': case '3': case '4': case '0': case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9': case '5': case '6': case '7': case '8': case '9':
if (oldmangled == NULL) if (oldmangled == NULL)
{ {
oldmangled = *mangled; oldmangled = *mangled;
} }
success = demangle_class (work, mangled, declp); success = demangle_class (work, mangled, declp);
if (success) if (success)
{ {
remember_type (work, oldmangled, *mangled - oldmangled); remember_type (work, oldmangled, *mangled - oldmangled);
} }
if (AUTO_DEMANGLING || GNU_DEMANGLING) if (AUTO_DEMANGLING || GNU_DEMANGLING)
{ {
expect_func = 1; expect_func = 1;
} }
oldmangled = NULL; oldmangled = NULL;
break; break;
case 'F': case 'F':
/* Function */ /* Function */
/* ARM style demangling includes a specific 'F' character after /* ARM style demangling includes a specific 'F' character after
the class name. For GNU style, it is just implied. So we can the class name. For GNU style, it is just implied. So we can
safely just consume any 'F' at this point and be compatible safely just consume any 'F' at this point and be compatible
with either style. */ with either style. */
oldmangled = NULL; oldmangled = NULL;
func_done = 1; func_done = 1;
(*mangled)++; (*mangled)++;
/* For lucid/ARM style we have to forget any types we might /* For lucid/ARM style we have to forget any types we might
have remembered up to this point, since they were not argument have remembered up to this point, since they were not argument
types. GNU style considers all types seen as available for types. GNU style considers all types seen as available for
back references. See comment in demangle_args() */ back references. See comment in demangle_args() */
if (LUCID_DEMANGLING || ARM_DEMANGLING) if (LUCID_DEMANGLING || ARM_DEMANGLING)
{ {
forget_types (work); forget_types (work);
} }
success = demangle_args (work, mangled, declp); success = demangle_args (work, mangled, declp);
break; break;
case 't': case 't':
/* G++ Template */ /* G++ Template */
string_init(&trawname); string_init(&trawname);
string_init(&tname); string_init(&tname);
if (oldmangled == NULL) if (oldmangled == NULL)
{ {
oldmangled = *mangled; oldmangled = *mangled;
} }
success = demangle_template (work, mangled, &tname, &trawname); success = demangle_template (work, mangled, &tname, &trawname);
if (success) if (success)
{ {
remember_type (work, oldmangled, *mangled - oldmangled); remember_type (work, oldmangled, *mangled - oldmangled);
} }
string_append(&tname, "::"); string_append(&tname, "::");
string_prepends(declp, &tname); string_prepends(declp, &tname);
if (work -> destructor & 1) if (work -> destructor & 1)
{ {
string_prepend (&trawname, "~"); string_prepend (&trawname, "~");
string_appends (declp, &trawname); string_appends (declp, &trawname);
work->destructor -= 1; work->destructor -= 1;
} }
if ((work->constructor & 1) || (work->destructor & 1)) if ((work->constructor & 1) || (work->destructor & 1))
{ {
string_appends (declp, &trawname); string_appends (declp, &trawname);
work->constructor -= 1; work->constructor -= 1;
} }
string_delete(&trawname); string_delete(&trawname);
string_delete(&tname); string_delete(&tname);
oldmangled = NULL; oldmangled = NULL;
expect_func = 1; expect_func = 1;
break; break;
case '_': case '_':
/* At the outermost level, we cannot have a return type specified, /* At the outermost level, we cannot have a return type specified,
so if we run into another '_' at this point we are dealing with so if we run into another '_' at this point we are dealing with
a mangled name that is either bogus, or has been mangled by a mangled name that is either bogus, or has been mangled by
some algorithm we don't know how to deal with. So just some algorithm we don't know how to deal with. So just
reject the entire demangling. */ reject the entire demangling. */
success = 0; success = 0;
break; break;
default: default:
if (AUTO_DEMANGLING || GNU_DEMANGLING) if (AUTO_DEMANGLING || GNU_DEMANGLING)
{
/* Assume we have stumbled onto the first outermost function
argument token, and start processing args. */
func_done = 1;
success = demangle_args (work, mangled, declp);
}
else
{
/* Non-GNU demanglers use a specific token to mark the start
of the outermost function argument tokens. Typically 'F',
for ARM-demangling, for example. So if we find something
we are not prepared for, it must be an error. */
success = 0;
}
break;
}
/*
if (AUTO_DEMANGLING || GNU_DEMANGLING)
*/
{
if (success && expect_func)
{ {
/* Assume we have stumbled onto the first outermost function
argument token, and start processing args. */
func_done = 1; func_done = 1;
success = demangle_args (work, mangled, declp); success = demangle_args (work, mangled, declp);
} }
else
{
/* Non-GNU demanglers use a specific token to mark the start
of the outermost function argument tokens. Typically 'F',
for ARM-demangling, for example. So if we find something
we are not prepared for, it must be an error. */
success = 0;
}
break;
} }
/*
if (AUTO_DEMANGLING || GNU_DEMANGLING)
*/
{
if (success && expect_func)
{
func_done = 1;
success = demangle_args (work, mangled, declp);
}
}
} }
if (success && !func_done) if (success && !func_done)
{ {
...@@ -910,70 +913,70 @@ demangle_template (work, mangled, tname, trawname) ...@@ -910,70 +913,70 @@ demangle_template (work, mangled, tname, trawname)
done = 0; done = 0;
/* temp is initialized in do_type */ /* temp is initialized in do_type */
success = do_type (work, mangled, &temp); success = do_type (work, mangled, &temp);
/* /*
if (success) if (success)
{ {
string_appends (tname, &temp); string_appends (tname, &temp);
} }
*/ */
string_delete(&temp); string_delete(&temp);
if (!success) if (!success)
{ {
break; break;
} }
/* /*
string_append (tname, "="); string_append (tname, "=");
*/ */
while (*old_p && !done) while (*old_p && !done)
{ {
switch (*old_p) switch (*old_p)
{ {
case 'P': case 'P':
case 'p': case 'p':
case 'R': case 'R':
done = is_pointer = 1; done = is_pointer = 1;
break; break;
case 'C': /* const */ case 'C': /* const */
case 'S': /* explicitly signed [char] */ case 'S': /* explicitly signed [char] */
case 'U': /* unsigned */ case 'U': /* unsigned */
case 'V': /* volatile */ case 'V': /* volatile */
case 'F': /* function */ case 'F': /* function */
case 'M': /* member function */ case 'M': /* member function */
case 'O': /* ??? */ case 'O': /* ??? */
old_p++; old_p++;
continue; continue;
case 'Q': /* qualified name */ case 'Q': /* qualified name */
done = is_integral = 1; done = is_integral = 1;
break; break;
case 'T': /* remembered type */ case 'T': /* remembered type */
abort (); abort ();
break; break;
case 'v': /* void */ case 'v': /* void */
abort (); abort ();
break; break;
case 'x': /* long long */ case 'x': /* long long */
case 'l': /* long */ case 'l': /* long */
case 'i': /* int */ case 'i': /* int */
case 's': /* short */ case 's': /* short */
case 'w': /* wchar_t */ case 'w': /* wchar_t */
done = is_integral = 1; done = is_integral = 1;
break; break;
case 'b': /* bool */ case 'b': /* bool */
done = is_bool = 1; done = is_bool = 1;
break; break;
case 'c': /* char */ case 'c': /* char */
done = is_char = 1; done = is_char = 1;
break; break;
case 'r': /* long double */ case 'r': /* long double */
case 'd': /* double */ case 'd': /* double */
case 'f': /* float */ case 'f': /* float */
done = is_real = 1; done = is_real = 1;
break; break;
default: default:
/* it's probably user defined type, let's assume /* it's probably user defined type, let's assume
it's integral, it seems hard to figure out it's integral, it seems hard to figure out
what it really is */ what it really is */
done = is_integral = 1; done = is_integral = 1;
} }
} }
if (is_integral) if (is_integral)
...@@ -991,8 +994,8 @@ demangle_template (work, mangled, tname, trawname) ...@@ -991,8 +994,8 @@ demangle_template (work, mangled, tname, trawname)
} }
else if (is_char) else if (is_char)
{ {
char tmp[2]; char tmp[2];
int val; int val;
if (**mangled == 'm') if (**mangled == 'm')
{ {
string_appendn (tname, "-", 1); string_appendn (tname, "-", 1);
...@@ -1088,19 +1091,19 @@ demangle_template (work, mangled, tname, trawname) ...@@ -1088,19 +1091,19 @@ demangle_template (work, mangled, tname, trawname)
string_append (tname, " "); string_append (tname, " ");
string_append (tname, ">"); string_append (tname, ">");
/* /*
if (work -> static_type) if (work -> static_type)
{ {
string_append (declp, *mangled + 1); string_append (declp, *mangled + 1);
*mangled += strlen (*mangled); *mangled += strlen (*mangled);
success = 1; success = 1;
}
else
{
success = demangle_args (work, mangled, declp);
}
} }
*/ else
{
success = demangle_args (work, mangled, declp);
}
}
*/
return (success); return (success);
} }
...@@ -1114,14 +1117,14 @@ arm_pt (work, mangled, n, anchor, args) ...@@ -1114,14 +1117,14 @@ arm_pt (work, mangled, n, anchor, args)
/* ARM template? */ /* ARM template? */
if (ARM_DEMANGLING && (*anchor = mystrstr (mangled, "__pt__"))) if (ARM_DEMANGLING && (*anchor = mystrstr (mangled, "__pt__")))
{ {
int len; int len;
*args = *anchor + 6; *args = *anchor + 6;
len = consume_count (args); len = consume_count (args);
if (*args + len == mangled + n && **args == '_') if (*args + len == mangled + n && **args == '_')
{ {
++*args; ++*args;
return 1; return 1;
} }
} }
return 0; return 0;
} }
...@@ -1139,26 +1142,26 @@ demangle_arm_pt (work, mangled, n, declp) ...@@ -1139,26 +1142,26 @@ demangle_arm_pt (work, mangled, n, declp)
/* ARM template? */ /* ARM template? */
if (arm_pt (work, *mangled, n, &p, &args)) if (arm_pt (work, *mangled, n, &p, &args))
{ {
string arg; string arg;
string_init (&arg); string_init (&arg);
string_appendn (declp, *mangled, p - *mangled); string_appendn (declp, *mangled, p - *mangled);
string_append (declp, "<"); string_append (declp, "<");
/* should do error checking here */ /* should do error checking here */
while (args < e) { while (args < e) {
string_clear (&arg); string_clear (&arg);
do_type (work, &args, &arg); do_type (work, &args, &arg);
string_appends (declp, &arg); string_appends (declp, &arg);
string_append (declp, ","); string_append (declp, ",");
} }
string_delete (&arg); string_delete (&arg);
--declp->p; --declp->p;
string_append (declp, ">"); string_append (declp, ">");
} }
else else
{ {
string_appendn (declp, *mangled, n); string_appendn (declp, *mangled, n);
} }
*mangled += n; *mangled += n;
} }
...@@ -1173,10 +1176,10 @@ demangle_class_name (work, mangled, declp) ...@@ -1173,10 +1176,10 @@ demangle_class_name (work, mangled, declp)
n = consume_count (mangled); n = consume_count (mangled);
if (strlen (*mangled) >= n) if (strlen (*mangled) >= n)
{ {
demangle_arm_pt (work, mangled, n, declp); demangle_arm_pt (work, mangled, n, declp);
success = 1; success = 1;
} }
return (success); return (success);
} }
...@@ -1326,9 +1329,9 @@ demangle_prefix (work, mangled, declp) ...@@ -1326,9 +1329,9 @@ demangle_prefix (work, mangled, declp)
work->constructor = 2; work->constructor = 2;
} }
/* This block of code is a reduction in strength time optimization /* This block of code is a reduction in strength time optimization
of: of:
scan = mystrstr (*mangled, "__"); */ scan = mystrstr (*mangled, "__"); */
{ {
scan = *mangled; scan = *mangled;
...@@ -1491,9 +1494,9 @@ gnu_special (work, mangled, declp) ...@@ -1491,9 +1494,9 @@ gnu_special (work, mangled, declp)
&& (*mangled)[2] == 'v' && (*mangled)[2] == 'v'
&& (*mangled)[3] == 't' && (*mangled)[3] == 't'
&& (*mangled)[4] == '_') && (*mangled)[4] == '_')
|| ((*mangled)[1] == 'v' || ((*mangled)[1] == 'v'
&& (*mangled)[2] == 't' && (*mangled)[2] == 't'
&& strchr (cplus_markers, (*mangled)[3]) != NULL))) && strchr (cplus_markers, (*mangled)[3]) != NULL)))
{ {
/* Found a GNU style virtual table, get past "_vt<CPLUS_MARKER>" /* Found a GNU style virtual table, get past "_vt<CPLUS_MARKER>"
and create the decl. Note that we consume the entire mangled and create the decl. Note that we consume the entire mangled
...@@ -1552,16 +1555,16 @@ gnu_special (work, mangled, declp) ...@@ -1552,16 +1555,16 @@ gnu_special (work, mangled, declp)
(*mangled)++; (*mangled)++;
switch (**mangled) switch (**mangled)
{ {
case 'Q': case 'Q':
success = demangle_qualified (work, mangled, declp, 0, 1); success = demangle_qualified (work, mangled, declp, 0, 1);
break; break;
case 't': case 't':
success = demangle_template (work, mangled, declp, 0); success = demangle_template (work, mangled, declp, 0);
break; break;
default: default:
n = consume_count (mangled); n = consume_count (mangled);
string_appendn (declp, *mangled, n); string_appendn (declp, *mangled, n);
(*mangled) += n; (*mangled) += n;
} }
if (success && (p == *mangled)) if (success && (p == *mangled))
{ {
...@@ -1604,16 +1607,16 @@ gnu_special (work, mangled, declp) ...@@ -1604,16 +1607,16 @@ gnu_special (work, mangled, declp)
(*mangled) += 4; (*mangled) += 4;
switch (**mangled) switch (**mangled)
{ {
case 'Q': case 'Q':
success = demangle_qualified (work, mangled, declp, 0, 1); success = demangle_qualified (work, mangled, declp, 0, 1);
break; break;
case 't': case 't':
success = demangle_template (work, mangled, declp, 0); success = demangle_template (work, mangled, declp, 0);
break; break;
default: default:
n = consume_count (mangled); n = consume_count (mangled);
string_appendn (declp, *mangled, n); string_appendn (declp, *mangled, n);
(*mangled) += n; (*mangled) += n;
} }
if (success && **mangled != '\0') if (success && **mangled != '\0')
success = 0; success = 0;
...@@ -1819,9 +1822,9 @@ demangle_qualified (work, mangled, result, isfuncname, append) ...@@ -1819,9 +1822,9 @@ demangle_qualified (work, mangled, result, isfuncname, append)
namelength = consume_count (mangled); namelength = consume_count (mangled);
if (strlen (*mangled) < namelength) if (strlen (*mangled) < namelength)
{ {
/* Simple sanity check failed */ /* Simple sanity check failed */
success = 0; success = 0;
break; break;
} }
string_appendn (&temp, *mangled, namelength); string_appendn (&temp, *mangled, namelength);
*mangled += namelength; *mangled += namelength;
...@@ -1947,20 +1950,20 @@ do_type (work, mangled, result) ...@@ -1947,20 +1950,20 @@ do_type (work, mangled, result)
switch (**mangled) switch (**mangled)
{ {
/* A pointer type */ /* A pointer type */
case 'P': case 'P':
case 'p': case 'p':
(*mangled)++; (*mangled)++;
string_prepend (&decl, "*"); string_prepend (&decl, "*");
break; break;
/* A reference type */ /* A reference type */
case 'R': case 'R':
(*mangled)++; (*mangled)++;
string_prepend (&decl, "&"); string_prepend (&decl, "&");
break; break;
/* An array */ /* An array */
case 'A': case 'A':
{ {
const char *p = ++(*mangled); const char *p = ++(*mangled);
...@@ -1996,7 +1999,7 @@ do_type (work, mangled, result) ...@@ -1996,7 +1999,7 @@ do_type (work, mangled, result)
} }
break; break;
/* A function */ /* A function */
case 'F': case 'F':
(*mangled)++; (*mangled)++;
if (!STRING_EMPTY (&decl) && decl.b[0] == '*') if (!STRING_EMPTY (&decl) && decl.b[0] == '*')
...@@ -2026,22 +2029,39 @@ do_type (work, mangled, result) ...@@ -2026,22 +2029,39 @@ do_type (work, mangled, result)
member = **mangled == 'M'; member = **mangled == 'M';
(*mangled)++; (*mangled)++;
if (!isdigit (**mangled)) if (!isdigit (**mangled) && **mangled != 't')
{
success = 0;
break;
}
n = consume_count (mangled);
if (strlen (*mangled) < n)
{ {
success = 0; success = 0;
break; break;
} }
string_append (&decl, ")"); string_append (&decl, ")");
string_prepend (&decl, "::"); string_prepend (&decl, "::");
string_prependn (&decl, *mangled, n); if (isdigit (**mangled))
{
n = consume_count (mangled);
if (strlen (*mangled) < n)
{
success = 0;
break;
}
string_prependn (&decl, *mangled, n);
*mangled += n;
}
else
{
string temp;
string_init (&temp);
success = demangle_template (work, mangled, &temp, NULL);
if (success)
{
string_prependn (&decl, temp.b, temp.p - temp.b);
string_clear (&temp);
}
else
break;
}
string_prepend (&decl, "("); string_prepend (&decl, "(");
*mangled += n;
if (member) if (member)
{ {
if (**mangled == 'C') if (**mangled == 'C')
...@@ -2084,27 +2104,27 @@ do_type (work, mangled, result) ...@@ -2084,27 +2104,27 @@ do_type (work, mangled, result)
break; break;
} }
case 'G': case 'G':
(*mangled)++; (*mangled)++;
break; break;
case 'C': case 'C':
(*mangled)++; (*mangled)++;
/* /*
if ((*mangled)[1] == 'P') if ((*mangled)[1] == 'P')
{ {
*/ */
if (PRINT_ANSI_QUALIFIERS) if (PRINT_ANSI_QUALIFIERS)
{
if (!STRING_EMPTY (&decl))
{ {
if (!STRING_EMPTY (&decl)) string_prepend (&decl, " ");
{
string_prepend (&decl, " ");
}
string_prepend (&decl, "const");
} }
break; string_prepend (&decl, "const");
/*
} }
*/ break;
/*
}
*/
/* fall through */ /* fall through */
default: default:
...@@ -2116,13 +2136,13 @@ do_type (work, mangled, result) ...@@ -2116,13 +2136,13 @@ do_type (work, mangled, result)
switch (**mangled) switch (**mangled)
{ {
/* A qualified name, such as "Outer::Inner". */ /* A qualified name, such as "Outer::Inner". */
case 'Q': case 'Q':
success = demangle_qualified (work, mangled, result, 0, 1); success = demangle_qualified (work, mangled, result, 0, 1);
break; break;
default: default:
success = demangle_fund_type (work, mangled, result); success = demangle_fund_type (work, mangled, result);
break; break;
} }
if (success) if (success)
...@@ -2169,35 +2189,35 @@ demangle_fund_type (work, mangled, result) ...@@ -2169,35 +2189,35 @@ demangle_fund_type (work, mangled, result)
{ {
switch (**mangled) switch (**mangled)
{ {
case 'C': case 'C':
(*mangled)++; (*mangled)++;
if (PRINT_ANSI_QUALIFIERS) if (PRINT_ANSI_QUALIFIERS)
{ {
APPEND_BLANK (result); APPEND_BLANK (result);
string_append (result, "const"); string_append (result, "const");
} }
break; break;
case 'U': case 'U':
(*mangled)++; (*mangled)++;
APPEND_BLANK (result); APPEND_BLANK (result);
string_append (result, "unsigned"); string_append (result, "unsigned");
break; break;
case 'S': /* signed char only */ case 'S': /* signed char only */
(*mangled)++; (*mangled)++;
APPEND_BLANK (result); APPEND_BLANK (result);
string_append (result, "signed"); string_append (result, "signed");
break; break;
case 'V': case 'V':
(*mangled)++; (*mangled)++;
if (PRINT_ANSI_QUALIFIERS) if (PRINT_ANSI_QUALIFIERS)
{ {
APPEND_BLANK (result); APPEND_BLANK (result);
string_append (result, "volatile"); string_append (result, "volatile");
} }
break; break;
default: default:
done = 1; done = 1;
break; break;
} }
} }
...@@ -2205,96 +2225,96 @@ demangle_fund_type (work, mangled, result) ...@@ -2205,96 +2225,96 @@ demangle_fund_type (work, mangled, result)
switch (**mangled) switch (**mangled)
{ {
case '\0': case '\0':
case '_': case '_':
break; break;
case 'v': case 'v':
(*mangled)++; (*mangled)++;
APPEND_BLANK (result); APPEND_BLANK (result);
string_append (result, "void"); string_append (result, "void");
break; break;
case 'x': case 'x':
(*mangled)++; (*mangled)++;
APPEND_BLANK (result); APPEND_BLANK (result);
string_append (result, "long long"); string_append (result, "long long");
break; break;
case 'l': case 'l':
(*mangled)++; (*mangled)++;
APPEND_BLANK (result); APPEND_BLANK (result);
string_append (result, "long"); string_append (result, "long");
break; break;
case 'i': case 'i':
(*mangled)++; (*mangled)++;
APPEND_BLANK (result); APPEND_BLANK (result);
string_append (result, "int"); string_append (result, "int");
break; break;
case 's': case 's':
(*mangled)++; (*mangled)++;
APPEND_BLANK (result); APPEND_BLANK (result);
string_append (result, "short"); string_append (result, "short");
break; break;
case 'b': case 'b':
(*mangled)++; (*mangled)++;
APPEND_BLANK (result); APPEND_BLANK (result);
string_append (result, "bool"); string_append (result, "bool");
break; break;
case 'c': case 'c':
(*mangled)++; (*mangled)++;
APPEND_BLANK (result); APPEND_BLANK (result);
string_append (result, "char"); string_append (result, "char");
break; break;
case 'w': case 'w':
(*mangled)++; (*mangled)++;
APPEND_BLANK (result); APPEND_BLANK (result);
string_append (result, "wchar_t"); string_append (result, "wchar_t");
break; break;
case 'r': case 'r':
(*mangled)++; (*mangled)++;
APPEND_BLANK (result); APPEND_BLANK (result);
string_append (result, "long double"); string_append (result, "long double");
break; break;
case 'd': case 'd':
(*mangled)++; (*mangled)++;
APPEND_BLANK (result); APPEND_BLANK (result);
string_append (result, "double"); string_append (result, "double");
break; break;
case 'f': case 'f':
(*mangled)++; (*mangled)++;
APPEND_BLANK (result); APPEND_BLANK (result);
string_append (result, "float"); string_append (result, "float");
break; break;
case 'G': case 'G':
(*mangled)++; (*mangled)++;
if (!isdigit (**mangled)) if (!isdigit (**mangled))
{ {
success = 0;
break;
}
/* fall through */
/* An explicit type, such as "6mytype" or "7integer" */
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
APPEND_BLANK (result);
if (!demangle_class_name (work, mangled, result)) {
--result->p;
success = 0; success = 0;
break;
} }
break; /* fall through */
case 't': /* An explicit type, such as "6mytype" or "7integer" */
success = demangle_template(work,mangled, result, 0); case '0':
break; case '1':
default: case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
APPEND_BLANK (result);
if (!demangle_class_name (work, mangled, result)) {
--result->p;
success = 0; success = 0;
break;
} }
break;
case 't':
success = demangle_template(work,mangled, result, 0);
break;
default:
success = 0;
break;
}
return (success); return (success);
} }
...@@ -2635,7 +2655,7 @@ demangle_function_name (work, mangled, declp, scan) ...@@ -2635,7 +2655,7 @@ demangle_function_name (work, mangled, declp, scan)
} }
} }
else if (declp->b[0] == '_' && declp->b[1] == '_' else if (declp->b[0] == '_' && declp->b[1] == '_'
&& declp->b[2] == 'o' && declp->b[3] == 'p') && declp->b[2] == 'o' && declp->b[3] == 'p')
{ {
/* ANSI. */ /* ANSI. */
/* type conversion operator. */ /* type conversion operator. */
...@@ -2846,7 +2866,7 @@ string_prependn (p, s, n) ...@@ -2846,7 +2866,7 @@ string_prependn (p, s, n)
static void static void
demangle_it (mangled_name) demangle_it (mangled_name)
char *mangled_name; char *mangled_name;
{ {
char *result; char *result;
...@@ -2874,8 +2894,8 @@ usage (stream, status) ...@@ -2874,8 +2894,8 @@ usage (stream, status)
{ {
fprintf (stream, "\ fprintf (stream, "\
Usage: %s [-_] [-n] [-s {gnu,lucid,arm}] [--strip-underscores]\n\ Usage: %s [-_] [-n] [-s {gnu,lucid,arm}] [--strip-underscores]\n\
[--no-strip-underscores] [--format={gnu,lucid,arm}]\n\ [--no-strip-underscores] [--format={gnu,lucid,arm}]\n\
[--help] [--version] [arg...]\n", [--help] [--version] [arg...]\n",
program_name); program_name);
exit (status); exit (status);
} }
...@@ -2913,40 +2933,40 @@ main (argc, argv) ...@@ -2913,40 +2933,40 @@ main (argc, argv)
{ {
switch (c) switch (c)
{ {
case '?': case '?':
usage (stderr, 1); usage (stderr, 1);
break; break;
case 'h': case 'h':
usage (stdout, 0); usage (stdout, 0);
case 'n': case 'n':
strip_underscore = 0; strip_underscore = 0;
break; break;
case 'v': case 'v':
printf ("GNU %s version %s\n", program_name, program_version); printf ("GNU %s version %s\n", program_name, program_version);
exit (0); exit (0);
case '_': case '_':
strip_underscore = 1; strip_underscore = 1;
break; break;
case 's': case 's':
if (strcmp (optarg, "gnu") == 0) if (strcmp (optarg, "gnu") == 0)
{ {
current_demangling_style = gnu_demangling; current_demangling_style = gnu_demangling;
} }
else if (strcmp (optarg, "lucid") == 0) else if (strcmp (optarg, "lucid") == 0)
{ {
current_demangling_style = lucid_demangling; current_demangling_style = lucid_demangling;
} }
else if (strcmp (optarg, "arm") == 0) else if (strcmp (optarg, "arm") == 0)
{ {
current_demangling_style = arm_demangling; current_demangling_style = arm_demangling;
} }
else else
{ {
fprintf (stderr, "%s: unknown demangling style `%s'\n", fprintf (stderr, "%s: unknown demangling style `%s'\n",
program_name, optarg); program_name, optarg);
exit (1); exit (1);
} }
break; break;
} }
} }
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment