summaryrefslogtreecommitdiff
path: root/gnu
diff options
context:
space:
mode:
authortv <tv@NetBSD.org>1999-02-02 21:00:32 +0000
committertv <tv@NetBSD.org>1999-02-02 21:00:32 +0000
commit3b3908f06faa5ffedb00c6aa21fe7ecfc3f66c95 (patch)
tree0341a04bb99d67561f9f84e14463a8f39738851c /gnu
parentf108f0164ea6fce3fbba310856779870449d68c9 (diff)
Update the C++ demangler to one from the egcs 1.2 trunk, dated 19980131.
This is a bit more robust than that in egcs 1.1.1, and recognizes more (but not yet all) template constructions.
Diffstat (limited to 'gnu')
-rw-r--r--gnu/dist/gcc/cplus-dem.c1161
-rw-r--r--gnu/dist/include/demangle.h16
-rw-r--r--gnu/dist/libiberty/cplus-dem.c1161
3 files changed, 1687 insertions, 651 deletions
diff --git a/gnu/dist/gcc/cplus-dem.c b/gnu/dist/gcc/cplus-dem.c
index 1a3ec90ec40..a3eb85f013e 100644
--- a/gnu/dist/gcc/cplus-dem.c
+++ b/gnu/dist/gcc/cplus-dem.c
@@ -1,8 +1,9 @@
-/* Demangler for GNU C++
- Copyright 1989, 1991, 1994, 1995, 1996, 1997, 1998 Free Software Foundation, Inc.
+/* Demangler for GNU C++
+ Copyright 1989, 91, 94, 95, 96, 97, 98, 1999 Free Software Foundation, Inc.
Written by James Clark (jjc@jclark.uucp)
Rewritten by Fred Fish (fnf@cygnus.com) for ARM and Lucid demangling
-
+ Modified by Satish Pai (pai@apollo.hp.com) for HP demangling
+
This file is part of the libiberty library.
Libiberty is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
@@ -28,6 +29,10 @@ Boston, MA 02111-1307, USA. */
/* This file lives in both GCC and libiberty. When making changes, please
try not to break either. */
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
#include <ctype.h>
#include <sys/types.h>
#include <string.h>
@@ -35,14 +40,16 @@ Boston, MA 02111-1307, USA. */
#ifdef HAVE_STDLIB_H
#include <stdlib.h>
+#else
+char * malloc ();
+char * realloc ();
#endif
#include <demangle.h>
#undef CURRENT_DEMANGLING_STYLE
#define CURRENT_DEMANGLING_STYLE work->options
-extern char *xmalloc PARAMS((unsigned));
-extern char *xrealloc PARAMS((char *, unsigned));
+#include "libiberty.h"
static const char *mystrstr PARAMS ((const char *, const char *));
@@ -87,6 +94,8 @@ enum demangling_styles current_demangling_style = gnu_demangling;
static char cplus_markers[] = { CPLUS_MARKER, '.', '$', '\0' };
+static char char_str[2] = { '\000', '\000' };
+
void
set_cplus_marker_for_demangling (ch)
int ch;
@@ -119,8 +128,9 @@ struct work_stuff
int constructor;
int destructor;
int static_type; /* A static member function */
- int const_type; /* A const member function */
- int volatile_type; /* A volatile member function */
+ int temp_start; /* index in demangled to start of template args */
+ int type_quals; /* The type qualifiers. */
+ int dllimported; /* Symbol imported from a PE DLL */
char **tmpl_argvec; /* Template function arguments. */
int ntmpl_args; /* The number of template function arguments. */
int forgetting_types; /* Nonzero if we are not remembering the types
@@ -220,6 +230,19 @@ static const struct optable
{"sz", "sizeof ", DMGL_ANSI} /* pseudo-ansi */
};
+/* These values are used to indicate the various type varieties.
+ They are all non-zero so that they can be used as `success'
+ values. */
+typedef enum type_kind_t
+{
+ tk_none,
+ tk_pointer,
+ tk_reference,
+ tk_integral,
+ tk_bool,
+ tk_char,
+ tk_real
+} type_kind_t;
#define STRING_EMPTY(str) ((str) -> b == (str) -> p)
#define PREPEND_BLANK(str) {if (!STRING_EMPTY(str)) \
@@ -251,7 +274,7 @@ static char *
internal_cplus_demangle PARAMS ((struct work_stuff *, const char *));
static int
-demangle_template_template_parm PARAMS ((struct work_stuff *work,
+demangle_template_template_parm PARAMS ((struct work_stuff *work,
const char **, string *));
static int
@@ -262,9 +285,6 @@ static int
arm_pt PARAMS ((struct work_stuff *, const char *, int, const char **,
const char **));
-static void
-demangle_arm_pt PARAMS ((struct work_stuff *, const char **, int, string *));
-
static int
demangle_class_name PARAMS ((struct work_stuff *, const char **, string *));
@@ -328,7 +348,7 @@ get_count PARAMS ((const char **, int *));
static int
consume_count PARAMS ((const char **));
-static int
+static int
consume_count_with_underscores PARAMS ((const char**));
static int
@@ -368,9 +388,36 @@ forget_B_and_K_types PARAMS ((struct work_stuff *));
static void
string_prepends PARAMS ((string *, string *));
-static int
-demangle_template_value_parm PARAMS ((struct work_stuff*,
- const char**, string*));
+static int
+demangle_template_value_parm PARAMS ((struct work_stuff*, const char**,
+ string*, type_kind_t));
+
+static int
+do_hpacc_template_const_value PARAMS ((struct work_stuff *, const char **, string *));
+
+static int
+do_hpacc_template_literal PARAMS ((struct work_stuff *, const char **, string *));
+
+static int
+snarf_numeric_literal PARAMS ((const char **, string *));
+
+/* There is a TYPE_QUAL value for each type qualifier. They can be
+ combined by bitwise-or to form the complete set of qualifiers for a
+ type. */
+
+#define TYPE_UNQUALIFIED 0x0
+#define TYPE_QUAL_CONST 0x1
+#define TYPE_QUAL_VOLATILE 0x2
+#define TYPE_QUAL_RESTRICT 0x4
+
+static int
+code_for_qualifier PARAMS ((int));
+
+static const char*
+qualifier_string PARAMS ((int));
+
+static const char*
+demangle_qualifier PARAMS ((int));
/* Translate count to integer, consuming tokens in the process.
Conversion terminates on the first non-digit character.
@@ -383,7 +430,7 @@ consume_count (type)
{
int count = 0;
- while (isdigit (**type))
+ while (isdigit ((unsigned char)**type))
{
count *= 10;
count += **type - '0';
@@ -406,21 +453,21 @@ consume_count_with_underscores (mangled)
if (**mangled == '_')
{
(*mangled)++;
- if (!isdigit (**mangled))
+ if (!isdigit ((unsigned char)**mangled))
return -1;
idx = consume_count (mangled);
if (**mangled != '_')
/* The trailing underscore was missing. */
return -1;
-
+
(*mangled)++;
}
else
{
if (**mangled < '0' || **mangled > '9')
return -1;
-
+
idx = **mangled - '0';
(*mangled)++;
}
@@ -428,6 +475,84 @@ consume_count_with_underscores (mangled)
return idx;
}
+/* C is the code for a type-qualifier. Return the TYPE_QUAL
+ corresponding to this qualifier. */
+
+static int
+code_for_qualifier (c)
+ int c;
+{
+ switch (c)
+ {
+ case 'C':
+ return TYPE_QUAL_CONST;
+
+ case 'V':
+ return TYPE_QUAL_VOLATILE;
+
+ case 'u':
+ return TYPE_QUAL_RESTRICT;
+
+ default:
+ break;
+ }
+
+ /* C was an invalid qualifier. */
+ abort ();
+}
+
+/* Return the string corresponding to the qualifiers given by
+ TYPE_QUALS. */
+
+static const char*
+qualifier_string (type_quals)
+ int type_quals;
+{
+ switch (type_quals)
+ {
+ case TYPE_UNQUALIFIED:
+ return "";
+
+ case TYPE_QUAL_CONST:
+ return "const";
+
+ case TYPE_QUAL_VOLATILE:
+ return "volatile";
+
+ case TYPE_QUAL_RESTRICT:
+ return "__restrict";
+
+ case TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE:
+ return "const volatile";
+
+ case TYPE_QUAL_CONST | TYPE_QUAL_RESTRICT:
+ return "const __restrict";
+
+ case TYPE_QUAL_VOLATILE | TYPE_QUAL_RESTRICT:
+ return "volatile __restrict";
+
+ case TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE | TYPE_QUAL_RESTRICT:
+ return "const volatile __restrict";
+
+ default:
+ break;
+ }
+
+ /* TYPE_QUALS was an invalid qualifier set. */
+ abort ();
+}
+
+/* C is the code for a type-qualifier. Return the string
+ corresponding to this qualifier. This function should only be
+ called with a valid qualifier code. */
+
+static const char*
+demangle_qualifier (c)
+ int c;
+{
+ return qualifier_string (code_for_qualifier (c));
+}
+
int
cplus_demangle_opname (opname, result, options)
const char *opname;
@@ -444,7 +569,7 @@ cplus_demangle_opname (opname, result, options)
ret = 0;
memset ((char *) work, 0, sizeof (work));
work->options = options;
-
+
if (opname[0] == '_' && opname[1] == '_'
&& opname[2] == 'o' && opname[3] == 'p')
{
@@ -494,12 +619,12 @@ cplus_demangle_opname (opname, result, options)
strcat (result, optable[i].out);
ret = 1;
break;
- }
+ }
}
}
}
}
- else if (len >= 3
+ else if (len >= 3
&& opname[0] == 'o'
&& opname[1] == 'p'
&& strchr (cplus_markers, opname[2]) != NULL)
@@ -512,7 +637,7 @@ cplus_demangle_opname (opname, result, options)
for (i = 0; i < sizeof (optable) / sizeof (optable[0]); i++)
{
len1 = len - 10;
- if (strlen (optable[i].in) == len1
+ if ((int) strlen (optable[i].in) == len1
&& memcmp (optable[i].in, opname + 10, len1) == 0)
{
strcat (result, "operator");
@@ -529,7 +654,7 @@ cplus_demangle_opname (opname, result, options)
for (i = 0; i < sizeof (optable) / sizeof (optable[0]); i++)
{
len1 = len - 3;
- if (strlen (optable[i].in) == len1
+ if ((int) strlen (optable[i].in) == len1
&& memcmp (optable[i].in, opname + 3, len1) == 0)
{
strcat (result, "operator");
@@ -574,7 +699,7 @@ cplus_mangle_opname (opname, options)
len = strlen (opname);
for (i = 0; i < sizeof (optable) / sizeof (optable[0]); i++)
{
- if (strlen (optable[i].out) == len
+ if ((int) strlen (optable[i].out) == len
&& (options & DMGL_ANSI) == (optable[i].flags & DMGL_ANSI)
&& memcmp (optable[i].out, opname, len) == 0)
return optable[i].in;
@@ -597,7 +722,7 @@ cplus_mangle_opname (opname, options)
DMGL_PARAMS Function parameters are included.
For example,
-
+
cplus_demangle ("foo__1Ai", DMGL_PARAMS) => "A::foo(int)"
cplus_demangle ("foo__1Ai", DMGL_PARAMS | DMGL_ANSI) => "A::foo(int)"
cplus_demangle ("foo__1Ai", 0) => "A::foo"
@@ -626,9 +751,9 @@ cplus_demangle (mangled, options)
squangle_mop_up (work);
return (ret);
}
-
-/* This function performs most of what cplus_demangle use to do, but
+
+/* This function performs most of what cplus_demangle use to do, but
to be able to demangle a name with a B, K or n code, we need to
have a longer term memory of what types have been seen. The original
now intializes and cleans up the squangle code info, while internal
@@ -644,15 +769,13 @@ internal_cplus_demangle (work, mangled)
int success = 0;
char *demangled = NULL;
int s1,s2,s3,s4;
- int saved_volatile_type;
s1 = work->constructor;
s2 = work->destructor;
s3 = work->static_type;
- s4 = work->const_type;
- saved_volatile_type = work->volatile_type;
+ s4 = work->type_quals;
work->constructor = work->destructor = 0;
- work->static_type = work->const_type = 0;
- work->volatile_type = 0;
+ work->type_quals = TYPE_UNQUALIFIED;
+ work->dllimported = 0;
if ((mangled != NULL) && (*mangled != '\0'))
{
@@ -687,13 +810,17 @@ internal_cplus_demangle (work, mangled)
string_prepend (&decl, "global destructors keyed to ");
work->destructor = 0;
}
+ else if (work->dllimported == 1)
+ {
+ string_prepend (&decl, "import stub for ");
+ work->dllimported = 0;
+ }
demangled = mop_up (work, &decl, success);
}
work->constructor = s1;
work->destructor = s2;
work->static_type = s3;
- work->const_type = s4;
- work->volatile_type = saved_volatile_type;
+ work->type_quals = s4;
return (demangled);
}
@@ -726,7 +853,7 @@ mop_up (work, declp, success)
char *demangled = NULL;
/* Discard the remembered types, if any. */
-
+
forget_types (work);
if (work -> typevec != NULL)
{
@@ -740,7 +867,7 @@ mop_up (work, declp, success)
for (i = 0; i < work->ntmpl_args; i++)
if (work->tmpl_argvec[i])
free ((char*) work->tmpl_argvec[i]);
-
+
free ((char*) work->tmpl_argvec);
work->tmpl_argvec = NULL;
}
@@ -748,11 +875,12 @@ mop_up (work, declp, success)
{
string_delete (work->previous_argument);
free ((char*) work->previous_argument);
+ work->previous_argument = NULL;
}
/* If demangling was successful, ensure that the demangled string is null
terminated and return it. Otherwise, free the demangling decl. */
-
+
if (!success)
{
string_delete (declp);
@@ -832,7 +960,7 @@ demangle_signature (work, mangled, declp)
}
oldmangled = NULL;
break;
-
+
case 'S':
/* Static member function */
if (oldmangled == NULL)
@@ -845,31 +973,48 @@ demangle_signature (work, mangled, declp)
case 'C':
case 'V':
- if (**mangled == 'C')
- work -> const_type = 1;
- else
- work->volatile_type = 1;
+ case 'u':
+ work->type_quals |= code_for_qualifier (**mangled);
/* a qualified member function */
if (oldmangled == NULL)
oldmangled = *mangled;
(*mangled)++;
break;
-
+
+ case 'L':
+ /* Local class name follows after "Lnnn_" */
+ if (HP_DEMANGLING)
+ {
+ while (**mangled && (**mangled != '_'))
+ (*mangled)++;
+ if (!**mangled)
+ success = 0;
+ else
+ (*mangled)++;
+ }
+ else
+ success = 0;
+ break;
+
case '0': case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9':
if (oldmangled == NULL)
{
oldmangled = *mangled;
}
+ work->temp_start = -1; /* uppermost call to demangle_class */
success = demangle_class (work, mangled, declp);
if (success)
{
remember_type (work, oldmangled, *mangled - oldmangled);
}
- if (AUTO_DEMANGLING || GNU_DEMANGLING)
+ if (AUTO_DEMANGLING || GNU_DEMANGLING || EDG_DEMANGLING)
{
- expect_func = 1;
+ /* EDG and others will have the "F", so we let the loop cycle
+ if we are looking at one. */
+ if (**mangled != 'F')
+ expect_func = 1;
}
oldmangled = NULL;
break;
@@ -890,7 +1035,7 @@ demangle_signature (work, mangled, declp)
case 'F':
/* Function */
- /* ARM style demangling includes a specific 'F' character after
+ /* ARM/HP style demangling includes a specific 'F' character after
the class name. For GNU style, it is just implied. So we can
safely just consume any 'F' at this point and be compatible
with either style. */
@@ -899,21 +1044,32 @@ demangle_signature (work, mangled, declp)
func_done = 1;
(*mangled)++;
- /* For lucid/ARM style we have to forget any types we might
+ /* For lucid/ARM/HP style we have to forget any types we might
have remembered up to this point, since they were not argument
types. GNU style considers all types seen as available for
back references. See comment in demangle_args() */
- if (LUCID_DEMANGLING || ARM_DEMANGLING)
+ if (LUCID_DEMANGLING || ARM_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING)
{
forget_types (work);
}
success = demangle_args (work, mangled, declp);
+ /* After picking off the function args, we expect to either
+ find the function return type (preceded by an '_') or the
+ end of the string. */
+ if (success && (AUTO_DEMANGLING || EDG_DEMANGLING) && **mangled == '_')
+ {
+ ++(*mangled);
+ /* At this level, we do not care about the return type. */
+ success = do_type (work, mangled, &tname);
+ string_delete (&tname);
+ }
+
break;
-
+
case 't':
/* G++ Template */
- string_init(&trawname);
+ string_init(&trawname);
string_init(&tname);
if (oldmangled == NULL)
{
@@ -925,7 +1081,8 @@ demangle_signature (work, mangled, declp)
{
remember_type (work, oldmangled, *mangled - oldmangled);
}
- string_append(&tname, SCOPE_STRING (work));
+ string_append (&tname, SCOPE_STRING (work));
+
string_prepends(declp, &tname);
if (work -> destructor & 1)
{
@@ -945,7 +1102,7 @@ demangle_signature (work, mangled, declp)
break;
case '_':
- if (GNU_DEMANGLING && expect_return_type)
+ if (GNU_DEMANGLING && expect_return_type)
{
/* Read the return type. */
string return_type;
@@ -965,11 +1122,21 @@ demangle_signature (work, mangled, declp)
a mangled name that is either bogus, or has been mangled by
some algorithm we don't know how to deal with. So just
reject the entire demangling. */
- success = 0;
+ /* However, "_nnn" is an expected suffix for alternate entry point
+ numbered nnn for a function, with HP aCC, so skip over that
+ without reporting failure. pai/1997-09-04 */
+ if (HP_DEMANGLING)
+ {
+ (*mangled)++;
+ while (**mangled && isdigit ((unsigned char)**mangled))
+ (*mangled)++;
+ }
+ else
+ success = 0;
break;
case 'H':
- if (GNU_DEMANGLING)
+ if (GNU_DEMANGLING)
{
/* A G++ template function. Read the template arguments. */
success = demangle_template (work, mangled, declp, 0, 0,
@@ -995,7 +1162,7 @@ demangle_signature (work, mangled, declp)
{
/* 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
+ for ARM/HP-demangling, for example. So if we find something
we are not prepared for, it must be an error. */
success = 0;
}
@@ -1008,6 +1175,10 @@ demangle_signature (work, mangled, declp)
if (success && expect_func)
{
func_done = 1;
+ if (LUCID_DEMANGLING || ARM_DEMANGLING || EDG_DEMANGLING)
+ {
+ forget_types (work);
+ }
success = demangle_args (work, mangled, declp);
/* Since template include the mangling of their return types,
we must set expect_func to 0 so that we don't try do
@@ -1023,18 +1194,22 @@ demangle_signature (work, mangled, declp)
/* With GNU style demangling, bar__3foo is 'foo::bar(void)', and
bar__3fooi is 'foo::bar(int)'. We get here when we find the
first case, and need to ensure that the '(void)' gets added to
- the current declp. Note that with ARM, the first case
+ the current declp. Note that with ARM/HP, the first case
represents the name of a static data member 'foo::bar',
which is in the current declp, so we leave it alone. */
success = demangle_args (work, mangled, declp);
}
}
- if (success && work -> static_type && PRINT_ARG_TYPES)
- string_append (declp, " static");
- if (success && work -> const_type && PRINT_ARG_TYPES)
- string_append (declp, " const");
- else if (success && work->volatile_type && PRINT_ARG_TYPES)
- string_append (declp, " volatile");
+ if (success && PRINT_ARG_TYPES)
+ {
+ if (work->static_type)
+ string_append (declp, " static");
+ if (work->type_quals != TYPE_UNQUALIFIED)
+ {
+ APPEND_BLANK (declp);
+ string_append (declp, qualifier_string (work->type_quals));
+ }
+ }
return (success);
}
@@ -1097,7 +1272,7 @@ demangle_template_template_parm (work, mangled, tname)
else if (**mangled == 'z')
{
(*mangled)++;
- success =
+ success =
demangle_template_template_parm (work, mangled, tname);
if (!success)
{
@@ -1139,7 +1314,7 @@ demangle_integral_value (work, mangled, s)
if (**mangled == 'E')
{
int need_operator = 0;
-
+
success = 1;
string_appendn (s, "(", 1);
(*mangled)++;
@@ -1154,7 +1329,7 @@ demangle_integral_value (work, mangled, s)
len = strlen (*mangled);
- for (i = 0;
+ for (i = 0;
i < sizeof (optable) / sizeof (optable [0]);
++i)
{
@@ -1178,12 +1353,13 @@ demangle_integral_value (work, mangled, s)
else
need_operator = 1;
- success = demangle_template_value_parm (work, mangled, s);
+ success = demangle_template_value_parm (work, mangled, s,
+ tk_integral);
}
if (**mangled != 'W')
success = 0;
- else
+ else
{
string_appendn (s, ")", 1);
(*mangled)++;
@@ -1200,88 +1376,26 @@ demangle_integral_value (work, mangled, s)
string_appendn (s, "-", 1);
(*mangled)++;
}
- while (isdigit (**mangled))
+ while (isdigit ((unsigned char)**mangled))
{
string_appendn (s, *mangled, 1);
(*mangled)++;
success = 1;
}
}
-
+
return success;
}
-static int
-demangle_template_value_parm (work, mangled, s)
+static int
+demangle_template_value_parm (work, mangled, s, tk)
struct work_stuff *work;
const char **mangled;
string* s;
+ type_kind_t tk;
{
- const char *old_p = *mangled;
- int is_pointer = 0;
- int is_real = 0;
- int is_integral = 0;
- int is_char = 0;
- int is_bool = 0;
- int done = 0;
int success = 1;
- while (*old_p && !done)
- {
- switch (*old_p)
- {
- case 'P':
- case 'p':
- case 'R':
- done = is_pointer = 1;
- break;
- case 'C': /* const */
- case 'S': /* explicitly signed [char] */
- case 'U': /* unsigned */
- case 'V': /* volatile */
- case 'F': /* function */
- case 'M': /* member function */
- case 'O': /* ??? */
- case 'J': /* complex */
- old_p++;
- continue;
- case 'E': /* expression */
- case 'Q': /* qualified name */
- case 'K': /* qualified name */
- done = is_integral = 1;
- break;
- case 'B': /* remembered type */
- case 'T': /* remembered type */
- abort ();
- break;
- case 'v': /* void */
- abort ();
- break;
- case 'x': /* long long */
- case 'l': /* long */
- case 'i': /* int */
- case 's': /* short */
- case 'w': /* wchar_t */
- done = is_integral = 1;
- break;
- case 'b': /* bool */
- done = is_bool = 1;
- break;
- case 'c': /* char */
- done = is_char = 1;
- break;
- case 'r': /* long double */
- case 'd': /* double */
- case 'f': /* float */
- done = is_real = 1;
- break;
- default:
- /* it's probably user defined type, let's assume
- it's integral, it seems hard to figure out
- what it really is */
- done = is_integral = 1;
- }
- }
if (**mangled == 'Y')
{
/* The next argument is a template parameter. */
@@ -1289,7 +1403,7 @@ demangle_template_value_parm (work, mangled, s)
(*mangled)++;
idx = consume_count_with_underscores (mangled);
- if (idx == -1
+ if (idx == -1
|| (work->tmpl_argvec && idx >= work->ntmpl_args)
|| consume_count_with_underscores (mangled) == -1)
return -1;
@@ -1302,9 +1416,9 @@ demangle_template_value_parm (work, mangled, s)
string_append (s, buf);
}
}
- else if (is_integral)
+ else if (tk == tk_integral)
success = demangle_integral_value (work, mangled, s);
- else if (is_char)
+ else if (tk == tk_char)
{
char tmp[2];
int val;
@@ -1322,7 +1436,7 @@ demangle_template_value_parm (work, mangled, s)
string_appendn (s, &tmp[0], 1);
string_appendn (s, "'", 1);
}
- else if (is_bool)
+ else if (tk == tk_bool)
{
int val = consume_count (mangled);
if (val == 0)
@@ -1332,14 +1446,14 @@ demangle_template_value_parm (work, mangled, s)
else
success = 0;
}
- else if (is_real)
+ else if (tk == tk_real)
{
if (**mangled == 'm')
{
string_appendn (s, "-", 1);
(*mangled)++;
}
- while (isdigit (**mangled))
+ while (isdigit ((unsigned char)**mangled))
{
string_appendn (s, *mangled, 1);
(*mangled)++;
@@ -1348,7 +1462,7 @@ demangle_template_value_parm (work, mangled, s)
{
string_appendn (s, ".", 1);
(*mangled)++;
- while (isdigit (**mangled))
+ while (isdigit ((unsigned char)**mangled))
{
string_appendn (s, *mangled, 1);
(*mangled)++;
@@ -1358,14 +1472,14 @@ demangle_template_value_parm (work, mangled, s)
{
string_appendn (s, "e", 1);
(*mangled)++;
- while (isdigit (**mangled))
+ while (isdigit ((unsigned char)**mangled))
{
string_appendn (s, *mangled, 1);
(*mangled)++;
}
}
}
- else if (is_pointer)
+ else if (tk == tk_pointer || tk == tk_reference)
{
int symbol_len = consume_count (mangled);
if (symbol_len == 0)
@@ -1377,8 +1491,16 @@ demangle_template_value_parm (work, mangled, s)
char *p = xmalloc (symbol_len + 1), *q;
strncpy (p, *mangled, symbol_len);
p [symbol_len] = '\0';
- q = internal_cplus_demangle (work, p);
- string_appendn (s, "&", 1);
+ /* We use cplus_demangle here, rather than
+ internal_cplus_demangle, because the name of the entity
+ mangled here does not make use of any of the squangling
+ or type-code information we have built up thus far; it is
+ mangled independently. */
+ q = cplus_demangle (p, work->options);
+ if (tk == tk_pointer)
+ string_appendn (s, "&", 1);
+ /* FIXME: Pointer-to-member constants should get a
+ qualifying class name here. */
if (q)
{
string_append (s, q);
@@ -1417,7 +1539,7 @@ demangle_template (work, mangled, tname, trawname, is_type, remember)
int success = 0;
const char *start;
string temp;
- int bindex;
+ int bindex = 0;
(*mangled)++;
if (is_type)
@@ -1433,7 +1555,7 @@ demangle_template (work, mangled, tname, trawname, is_type, remember)
(*mangled)++;
idx = consume_count_with_underscores (mangled);
- if (idx == -1
+ if (idx == -1
|| (work->tmpl_argvec && idx >= work->ntmpl_args)
|| consume_count_with_underscores (mangled) == -1)
return (0);
@@ -1455,7 +1577,8 @@ demangle_template (work, mangled, tname, trawname, is_type, remember)
}
else
{
- if ((r = consume_count (mangled)) == 0 || strlen (*mangled) < r)
+ if ((r = consume_count (mangled)) == 0
+ || (int) strlen (*mangled) < r)
{
return (0);
}
@@ -1516,9 +1639,10 @@ demangle_template (work, mangled, tname, trawname, is_type, remember)
int r2;
(*mangled)++;
success = demangle_template_template_parm (work, mangled, tname);
-
+
if (success
- && (r2 = consume_count (mangled)) > 0 && strlen (*mangled) >= r2)
+ && (r2 = consume_count (mangled)) > 0
+ && (int) strlen (*mangled) >= r2)
{
string_append (tname, " ");
string_appendn (tname, *mangled, r2);
@@ -1546,20 +1670,9 @@ demangle_template (work, mangled, tname, trawname, is_type, remember)
/* temp is initialized in do_type */
success = do_type (work, mangled, &temp);
- /*
- if (success)
- {
- string_appends (s, &temp);
- }
- */
string_delete(&temp);
if (!success)
- {
- break;
- }
- /*
- string_append (s, "=");
- */
+ break;
if (!is_type)
{
@@ -1569,7 +1682,8 @@ demangle_template (work, mangled, tname, trawname, is_type, remember)
else
s = tname;
- success = demangle_template_value_parm (work, mangled, s);
+ success = demangle_template_value_parm (work, mangled, s,
+ (type_kind_t) success);
if (!success)
{
@@ -1585,17 +1699,19 @@ demangle_template (work, mangled, tname, trawname, is_type, remember)
work->tmpl_argvec[i] = xmalloc (len + 1);
memcpy (work->tmpl_argvec[i], s->b, len);
work->tmpl_argvec[i][len] = '\0';
-
+
string_appends (tname, s);
string_delete (s);
}
}
need_comma = 1;
}
+ {
if (tname->p[-1] == '>')
string_append (tname, " ");
string_append (tname, ">");
-
+ }
+
if (is_type && remember)
remember_Btype (work, tname->b, LEN_STRING (tname), bindex);
@@ -1622,8 +1738,9 @@ arm_pt (work, mangled, n, anchor, args)
int n;
const char **anchor, **args;
{
- /* ARM template? */
- if (ARM_DEMANGLING && (*anchor = mystrstr (mangled, "__pt__")))
+ /* Check if ARM template with "__pt__" in it ("parameterized type") */
+ /* Allow HP also here, because HP's cfront compiler follows ARM to some extent */
+ if ((ARM_DEMANGLING || HP_DEMANGLING) && (*anchor = mystrstr (mangled, "__pt__")))
{
int len;
*args = *anchor + 6;
@@ -1634,11 +1751,39 @@ arm_pt (work, mangled, n, anchor, args)
return 1;
}
}
+ if (AUTO_DEMANGLING || EDG_DEMANGLING)
+ {
+ if ((*anchor = mystrstr (mangled, "__tm__"))
+ || (*anchor = mystrstr (mangled, "__ps__"))
+ || (*anchor = mystrstr (mangled, "__pt__")))
+ {
+ int len;
+ *args = *anchor + 6;
+ len = consume_count (args);
+ if (*args + len == mangled + n && **args == '_')
+ {
+ ++*args;
+ return 1;
+ }
+ }
+ else if ((*anchor = mystrstr (mangled, "__S")))
+ {
+ int len;
+ *args = *anchor + 3;
+ len = consume_count (args);
+ if (*args + len == mangled + n && **args == '_')
+ {
+ ++*args;
+ return 1;
+ }
+ }
+ }
+
return 0;
}
static void
-demangle_arm_pt (work, mangled, n, declp)
+demangle_arm_hp_template (work, mangled, n, declp)
struct work_stuff *work;
const char **mangled;
int n;
@@ -1647,32 +1792,150 @@ demangle_arm_pt (work, mangled, n, declp)
const char *p;
const char *args;
const char *e = *mangled + n;
+ string arg;
- /* ARM template? */
- if (arm_pt (work, *mangled, n, &p, &args))
+ /* Check for HP aCC template spec: classXt1t2 where t1, t2 are
+ template args */
+ if (HP_DEMANGLING && ((*mangled)[n] == 'X'))
{
- string arg;
+ char *start_spec_args = NULL;
+
+ /* First check for and omit template specialization pseudo-arguments,
+ such as in "Spec<#1,#1.*>" */
+ start_spec_args = strchr (*mangled, '<');
+ if (start_spec_args && (start_spec_args - *mangled < n))
+ string_appendn (declp, *mangled, start_spec_args - *mangled);
+ else
+ string_appendn (declp, *mangled, n);
+ (*mangled) += n + 1;
+ string_init (&arg);
+ if (work->temp_start == -1) /* non-recursive call */
+ work->temp_start = declp->p - declp->b;
+ string_append (declp, "<");
+ while (1)
+ {
+ string_clear (&arg);
+ switch (**mangled)
+ {
+ case 'T':
+ /* 'T' signals a type parameter */
+ (*mangled)++;
+ if (!do_type (work, mangled, &arg))
+ goto hpacc_template_args_done;
+ break;
+
+ case 'U':
+ case 'S':
+ /* 'U' or 'S' signals an integral value */
+ if (!do_hpacc_template_const_value (work, mangled, &arg))
+ goto hpacc_template_args_done;
+ break;
+
+ case 'A':
+ /* 'A' signals a named constant expression (literal) */
+ if (!do_hpacc_template_literal (work, mangled, &arg))
+ goto hpacc_template_args_done;
+ break;
+
+ default:
+ /* Today, 1997-09-03, we have only the above types
+ of template parameters */
+ /* FIXME: maybe this should fail and return null */
+ goto hpacc_template_args_done;
+ }
+ string_appends (declp, &arg);
+ /* Check if we're at the end of template args.
+ 0 if at end of static member of template class,
+ _ if done with template args for a function */
+ if ((**mangled == '\000') || (**mangled == '_'))
+ break;
+ else
+ string_append (declp, ",");
+ }
+ hpacc_template_args_done:
+ string_append (declp, ">");
+ string_delete (&arg);
+ if (**mangled == '_')
+ (*mangled)++;
+ return;
+ }
+ /* ARM template? (Also handles HP cfront extensions) */
+ else if (arm_pt (work, *mangled, n, &p, &args))
+ {
+ string type_str;
+
string_init (&arg);
string_appendn (declp, *mangled, p - *mangled);
+ if (work->temp_start == -1) /* non-recursive call */
+ work->temp_start = declp->p - declp->b;
string_append (declp, "<");
/* should do error checking here */
while (args < e) {
string_clear (&arg);
- do_type (work, &args, &arg);
+
+ /* Check for type or literal here */
+ switch (*args)
+ {
+ /* HP cfront extensions to ARM for template args */
+ /* spec: Xt1Lv1 where t1 is a type, v1 is a literal value */
+ /* FIXME: We handle only numeric literals for HP cfront */
+ case 'X':
+ /* A typed constant value follows */
+ args++;
+ if (!do_type (work, &args, &type_str))
+ goto cfront_template_args_done;
+ string_append (&arg, "(");
+ string_appends (&arg, &type_str);
+ string_append (&arg, ")");
+ if (*args != 'L')
+ goto cfront_template_args_done;
+ args++;
+ /* Now snarf a literal value following 'L' */
+ if (!snarf_numeric_literal (&args, &arg))
+ goto cfront_template_args_done;
+ break;
+
+ case 'L':
+ /* Snarf a literal following 'L' */
+ args++;
+ if (!snarf_numeric_literal (&args, &arg))
+ goto cfront_template_args_done;
+ break;
+ default:
+ /* Not handling other HP cfront stuff */
+ if (!do_type (work, &args, &arg))
+ goto cfront_template_args_done;
+ }
string_appends (declp, &arg);
string_append (declp, ",");
}
+ cfront_template_args_done:
string_delete (&arg);
- --declp->p;
+ if (args >= e)
+ --declp->p; /* remove extra comma */
string_append (declp, ">");
}
+ else if (n>10 && strncmp (*mangled, "_GLOBAL_", 8) == 0
+ && (*mangled)[9] == 'N'
+ && (*mangled)[8] == (*mangled)[10]
+ && strchr (cplus_markers, (*mangled)[8]))
+ {
+ /* A member of the anonymous namespace. */
+ string_append (declp, "{anonymous}");
+ }
else
{
+ if (work->temp_start == -1) /* non-recursive call only */
+ work->temp_start = 0; /* disable in recursive calls */
string_appendn (declp, *mangled, n);
}
*mangled += n;
}
+/* Extract a class name, possibly a template with arguments, from the
+ mangled string; qualifiers, local class indicators, etc. have
+ already been dealt with */
+
static int
demangle_class_name (work, mangled, declp)
struct work_stuff *work;
@@ -1683,9 +1946,9 @@ demangle_class_name (work, mangled, declp)
int success = 0;
n = consume_count (mangled);
- if (strlen (*mangled) >= n)
+ if ((int) strlen (*mangled) >= n)
{
- demangle_arm_pt (work, mangled, n, declp);
+ demangle_arm_hp_template (work, mangled, n, declp);
success = 1;
}
@@ -1736,13 +1999,20 @@ demangle_class (work, mangled, declp)
int success = 0;
int btype;
string class_name;
+ char *save_class_name_end = 0;
string_init (&class_name);
btype = register_Btype (work);
if (demangle_class_name (work, mangled, &class_name))
{
+ save_class_name_end = class_name.p;
if ((work->constructor & 1) || (work->destructor & 1))
{
+ /* adjust so we don't include template args */
+ if (work->temp_start && (work->temp_start != -1))
+ {
+ class_name.p = class_name.b + work->temp_start;
+ }
string_prepends (declp, &class_name);
if (work -> destructor & 1)
{
@@ -1751,9 +2021,10 @@ demangle_class (work, mangled, declp)
}
else
{
- work -> constructor -= 1;
+ work -> constructor -= 1;
}
}
+ class_name.p = save_class_name_end;
remember_Ktype (work, class_name.b, LEN_STRING(&class_name));
remember_Btype (work, class_name.b, LEN_STRING(&class_name), btype);
string_prepend (declp, SCOPE_STRING (work));
@@ -1791,7 +2062,7 @@ DESCRIPTION
the mangled name. Upon exit, it should point to the first character
of the signature if demangling was successful, or to the first
unconsumed character if demangling of the prefix was unsuccessful.
-
+
Returns 1 on success, 0 otherwise.
*/
@@ -1805,7 +2076,17 @@ demangle_prefix (work, mangled, declp)
const char *scan;
int i;
- if (strlen(*mangled) >= 11 && strncmp(*mangled, "_GLOBAL_", 8) == 0)
+ if (strlen(*mangled) > 6
+ && (strncmp(*mangled, "_imp__", 6) == 0
+ || strncmp(*mangled, "__imp_", 6) == 0))
+ {
+ /* it's a symbol imported from a PE dynamic library. Check for both
+ new style prefix _imp__ and legacy __imp_ used by older versions
+ of dlltool. */
+ (*mangled) += 6;
+ work->dllimported = 1;
+ }
+ else if (strlen(*mangled) >= 11 && strncmp(*mangled, "_GLOBAL_", 8) == 0)
{
char *marker = strchr (cplus_markers, (*mangled)[8]);
if (marker != NULL && *marker == (*mangled)[10])
@@ -1828,13 +2109,13 @@ demangle_prefix (work, mangled, declp)
}
}
}
- else if (ARM_DEMANGLING && strncmp(*mangled, "__std__", 7) == 0)
+ else if ((ARM_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING) && strncmp(*mangled, "__std__", 7) == 0)
{
/* it's a ARM global destructor to be executed at program exit */
(*mangled) += 7;
work->destructor = 2;
}
- else if (ARM_DEMANGLING && strncmp(*mangled, "__sti__", 7) == 0)
+ else if ((ARM_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING) && strncmp(*mangled, "__sti__", 7) == 0)
{
/* it's a ARM global constructor to be executed at program initial */
(*mangled) += 7;
@@ -1862,35 +2143,36 @@ demangle_prefix (work, mangled, declp)
i = strspn (scan, "_");
if (i > 2)
{
- scan += (i - 2);
+ scan += (i - 2);
}
}
-
+
if (scan == NULL)
{
success = 0;
}
else if (work -> static_type)
{
- if (!isdigit (scan[0]) && (scan[0] != 't'))
+ if (!isdigit ((unsigned char)scan[0]) && (scan[0] != 't'))
{
success = 0;
}
}
else if ((scan == *mangled)
- && (isdigit (scan[2]) || (scan[2] == 'Q') || (scan[2] == 't')
- || (scan[2] == 'K') || (scan[2] == 'H')))
+ && (isdigit ((unsigned char)scan[2]) || (scan[2] == 'Q')
+ || (scan[2] == 't') || (scan[2] == 'K') || (scan[2] == 'H')))
{
/* The ARM says nothing about the mangling of local variables.
But cfront mangles local variables by prepending __<nesting_level>
to them. As an extension to ARM demangling we handle this case. */
- if ((LUCID_DEMANGLING || ARM_DEMANGLING) && isdigit (scan[2]))
+ if ((LUCID_DEMANGLING || ARM_DEMANGLING || HP_DEMANGLING)
+ && isdigit ((unsigned char)scan[2]))
{
*mangled = scan + 2;
consume_count (mangled);
string_append (declp, *mangled);
*mangled += strlen (*mangled);
- success = 1;
+ success = 1;
}
else
{
@@ -1898,17 +2180,36 @@ demangle_prefix (work, mangled, declp)
names like __Q2_3foo3bar for nested type names. So don't accept
this style of constructor for cfront demangling. A GNU
style member-template constructor starts with 'H'. */
- if (!(LUCID_DEMANGLING || ARM_DEMANGLING))
+ if (!(LUCID_DEMANGLING || ARM_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING))
work -> constructor += 1;
*mangled = scan + 2;
}
}
- else if ((scan == *mangled) && !isdigit (scan[2]) && (scan[2] != 't'))
+ else if (ARM_DEMANGLING && scan[2] == 'p' && scan[3] == 't')
+ {
+ /* Cfront-style parameterized type. Handled later as a signature. */
+ success = 1;
+
+ /* ARM template? */
+ demangle_arm_hp_template (work, mangled, strlen (*mangled), declp);
+ }
+ else if (EDG_DEMANGLING && ((scan[2] == 't' && scan[3] == 'm')
+ || (scan[2] == 'p' && scan[3] == 's')
+ || (scan[2] == 'p' && scan[3] == 't')))
+ {
+ /* EDG-style parameterized type. Handled later as a signature. */
+ success = 1;
+
+ /* EDG template? */
+ demangle_arm_hp_template (work, mangled, strlen (*mangled), declp);
+ }
+ else if ((scan == *mangled) && !isdigit ((unsigned char)scan[2])
+ && (scan[2] != 't'))
{
/* Mangled name starts with "__". Skip over any leading '_' characters,
then find the next "__" that separates the prefix from the signature.
*/
- if (!(ARM_DEMANGLING || LUCID_DEMANGLING)
+ if (!(ARM_DEMANGLING || LUCID_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING)
|| (arm_special (mangled, declp) == 0))
{
while (*scan == '_')
@@ -1935,14 +2236,6 @@ demangle_prefix (work, mangled, declp)
}
}
}
- else if (ARM_DEMANGLING && scan[2] == 'p' && scan[3] == 't')
- {
- /* Cfront-style parameterized type. Handled later as a signature. */
- success = 1;
-
- /* ARM template? */
- demangle_arm_pt (work, mangled, strlen (*mangled), declp);
- }
else if (*(scan + 2) != '\0')
{
/* Mangled name does not start with "__" but does have one somewhere
@@ -1961,7 +2254,7 @@ demangle_prefix (work, mangled, declp)
string_append (declp, *mangled);
*mangled += strlen (*mangled);
success = 1;
- }
+ }
return (success);
}
@@ -2030,7 +2323,6 @@ gnu_special (work, mangled, declp)
(*mangled) += 4; /* Old style, no thunks: "_vt<CPLUS_MARKER>" */
while (**mangled != '\0')
{
- p = strpbrk (*mangled, cplus_markers);
switch (**mangled)
{
case 'Q':
@@ -2042,14 +2334,14 @@ gnu_special (work, mangled, declp)
1);
break;
default:
- if (isdigit(*mangled[0]))
+ if (isdigit((unsigned char)*mangled[0]))
{
n = consume_count(mangled);
/* We may be seeing a too-large size, or else a
".<digits>" indicating a static local symbol. In
any case, declare victory and move on; *don't* try
to use n to allocate. */
- if (n > strlen (*mangled))
+ if (n > (int) strlen (*mangled))
{
success = 1;
break;
@@ -2063,6 +2355,7 @@ gnu_special (work, mangled, declp)
(*mangled) += n;
}
+ p = strpbrk (*mangled, cplus_markers);
if (success && ((p == NULL) || (p == *mangled)))
{
if (p != NULL)
@@ -2164,6 +2457,35 @@ gnu_special (work, mangled, declp)
return (success);
}
+static void
+recursively_demangle(work, mangled, result, namelength)
+ struct work_stuff *work;
+ const char **mangled;
+ string *result;
+ int namelength;
+{
+ char * recurse = (char *)NULL;
+ char * recurse_dem = (char *)NULL;
+
+ recurse = (char *) xmalloc (namelength + 1);
+ memcpy (recurse, *mangled, namelength);
+ recurse[namelength] = '\000';
+
+ recurse_dem = cplus_demangle (recurse, work->options);
+
+ if (recurse_dem)
+ {
+ string_append (result, recurse_dem);
+ free (recurse_dem);
+ }
+ else
+ {
+ string_appendn (result, *mangled, namelength);
+ }
+ free (recurse);
+ *mangled += namelength;
+}
+
/*
LOCAL FUNCTION
@@ -2287,7 +2609,7 @@ demangle_qualified (work, mangled, result, isfuncname, append)
/* We only make use of ISFUNCNAME if the entity is a constructor or
destructor. */
- isfuncname = (isfuncname
+ isfuncname = (isfuncname
&& ((work->constructor & 1) || (work->destructor & 1)));
string_init (&temp);
@@ -2299,7 +2621,7 @@ demangle_qualified (work, mangled, result, isfuncname, append)
int idx;
(*mangled)++;
idx = consume_count_with_underscores (mangled);
- if (idx == -1 || idx > work -> numk)
+ if (idx == -1 || idx >= work -> numk)
success = 0;
else
string_append (&temp, work -> ktypevec[idx]);
@@ -2313,11 +2635,11 @@ demangle_qualified (work, mangled, result, isfuncname, append)
by an underscore. */
p = *mangled + 2;
qualifiers = atoi (p);
- if (!isdigit (*p) || *p == '0')
+ if (!isdigit ((unsigned char)*p) || *p == '0')
success = 0;
/* Skip the digits. */
- while (isdigit (*p))
+ while (isdigit ((unsigned char)*p))
++p;
if (*p != '_')
@@ -2366,7 +2688,7 @@ demangle_qualified (work, mangled, result, isfuncname, append)
int remember_K = 1;
string_clear (&last_name);
- if (*mangled[0] == '_')
+ if (*mangled[0] == '_')
(*mangled)++;
if (*mangled[0] == 't')
@@ -2377,17 +2699,17 @@ demangle_qualified (work, mangled, result, isfuncname, append)
(parameter-less) value is returned by demangle_template
in LAST_NAME. We do not remember the template type here,
in order to match the G++ mangling algorithm. */
- success = demangle_template(work, mangled, &temp,
+ success = demangle_template(work, mangled, &temp,
&last_name, 1, 0);
- if (!success)
+ if (!success)
break;
- }
+ }
else if (*mangled[0] == 'K')
{
int idx;
(*mangled)++;
idx = consume_count_with_underscores (mangled);
- if (idx == -1 || idx > work->numk)
+ if (idx == -1 || idx >= work->numk)
success = 0;
else
string_append (&temp, work->ktypevec[idx]);
@@ -2397,10 +2719,22 @@ demangle_qualified (work, mangled, result, isfuncname, append)
}
else
{
- success = do_type (work, mangled, &last_name);
- if (!success)
- break;
- string_appends (&temp, &last_name);
+ if (EDG_DEMANGLING)
+ {
+ int namelength;
+ /* Now recursively demangle the qualifier
+ * This is necessary to deal with templates in
+ * mangling styles like EDG */
+ namelength = consume_count (mangled);
+ recursively_demangle(work, mangled, &temp, namelength);
+ }
+ else
+ {
+ success = do_type (work, mangled, &last_name);
+ if (!success)
+ break;
+ string_appends (&temp, &last_name);
+ }
}
if (remember_K)
@@ -2417,7 +2751,7 @@ demangle_qualified (work, mangled, result, isfuncname, append)
We do this here because this is the most convenient place, where
we already have a pointer to the name and the length of the name. */
- if (isfuncname)
+ if (isfuncname)
{
string_append (&temp, SCOPE_STRING (work));
if (work -> destructor & 1)
@@ -2425,7 +2759,7 @@ demangle_qualified (work, mangled, result, isfuncname, append)
string_appends (&temp, &last_name);
}
- /* Now either prepend the temp buffer to the result, or append it,
+ /* Now either prepend the temp buffer to the result, or append it,
depending upon the state of the append flag. */
if (append)
@@ -2466,7 +2800,7 @@ get_count (type, count)
const char *p;
int n;
- if (!isdigit (**type))
+ if (!isdigit ((unsigned char)**type))
{
return (0);
}
@@ -2474,17 +2808,17 @@ get_count (type, count)
{
*count = **type - '0';
(*type)++;
- if (isdigit (**type))
+ if (isdigit ((unsigned char)**type))
{
p = *type;
n = *count;
- do
+ do
{
n *= 10;
n += *p - '0';
p++;
- }
- while (isdigit (*p));
+ }
+ while (isdigit ((unsigned char)*p));
if (*p == '_')
{
*type = p + 1;
@@ -2495,7 +2829,8 @@ get_count (type, count)
return (1);
}
-/* result will be initialised here; it will be freed on failure */
+/* RESULT will be initialised here; it will be freed on failure. The
+ value returned is really a type_kind_t. */
static int
do_type (work, mangled, result)
@@ -2508,9 +2843,9 @@ do_type (work, mangled, result)
int success;
string decl;
const char *remembered_type;
- int constp;
- int volatilep;
+ int type_quals;
string btype;
+ type_kind_t tk = tk_none;
string_init (&btype);
string_init (&decl);
@@ -2529,33 +2864,35 @@ do_type (work, mangled, result)
case 'p':
(*mangled)++;
string_prepend (&decl, "*");
+ if (tk == tk_none)
+ tk = tk_pointer;
break;
/* A reference type */
case 'R':
(*mangled)++;
string_prepend (&decl, "&");
+ if (tk == tk_none)
+ tk = tk_reference;
break;
/* An array */
case 'A':
{
- const char *p = ++(*mangled);
-
- string_prepend (&decl, "(");
- string_append (&decl, ")[");
- /* Copy anything up until the next underscore (the size of the
- array). */
- while (**mangled && **mangled != '_')
- ++(*mangled);
- if (**mangled == '_')
+ ++(*mangled);
+ if (!STRING_EMPTY (&decl)
+ && (decl.b[0] == '*' || decl.b[0] == '&'))
{
- string_appendn (&decl, p, *mangled - p);
- string_append (&decl, "]");
- *mangled += 1;
+ string_prepend (&decl, "(");
+ string_append (&decl, ")");
}
- else
- success = 0;
+ string_append (&decl, "[");
+ if (**mangled != '_')
+ success = demangle_template_value_parm (work, mangled, &decl,
+ tk_integral);
+ if (**mangled == '_')
+ ++(*mangled);
+ string_append (&decl, "]");
break;
}
@@ -2576,7 +2913,8 @@ do_type (work, mangled, result)
/* A function */
case 'F':
(*mangled)++;
- if (!STRING_EMPTY (&decl) && decl.b[0] == '*')
+ if (!STRING_EMPTY (&decl)
+ && (decl.b[0] == '*' || decl.b[0] == '&'))
{
string_prepend (&decl, "(");
string_append (&decl, ")");
@@ -2597,12 +2935,11 @@ do_type (work, mangled, result)
case 'M':
case 'O':
{
- constp = 0;
- volatilep = 0;
+ type_quals = TYPE_UNQUALIFIED;
member = **mangled == 'M';
(*mangled)++;
- if (!isdigit (**mangled) && **mangled != 't')
+ if (!isdigit ((unsigned char)**mangled) && **mangled != 't')
{
success = 0;
break;
@@ -2610,10 +2947,10 @@ do_type (work, mangled, result)
string_append (&decl, ")");
string_prepend (&decl, SCOPE_STRING (work));
- if (isdigit (**mangled))
+ if (isdigit ((unsigned char)**mangled))
{
n = consume_count (mangled);
- if (strlen (*mangled) < n)
+ if ((int) strlen (*mangled) < n)
{
success = 0;
break;
@@ -2638,16 +2975,19 @@ do_type (work, mangled, result)
string_prepend (&decl, "(");
if (member)
{
- if (**mangled == 'C')
- {
- (*mangled)++;
- constp = 1;
- }
- if (**mangled == 'V')
+ switch (**mangled)
{
+ case 'C':
+ case 'V':
+ case 'u':
+ type_quals |= code_for_qualifier (**mangled);
(*mangled)++;
- volatilep = 1;
+ break;
+
+ default:
+ break;
}
+
if (*(*mangled)++ != 'F')
{
success = 0;
@@ -2665,15 +3005,10 @@ do_type (work, mangled, result)
{
break;
}
- if (constp)
- {
- APPEND_BLANK (&decl);
- string_append (&decl, "const");
- }
- if (volatilep)
+ if (type_quals != TYPE_UNQUALIFIED)
{
APPEND_BLANK (&decl);
- string_append (&decl, "volatile");
+ string_append (&decl, qualifier_string (type_quals));
}
break;
}
@@ -2683,18 +3018,13 @@ do_type (work, mangled, result)
case 'C':
case 'V':
- /*
- if ((*mangled)[1] == 'P')
- {
- */
+ case 'u':
if (PRINT_ANSI_QUALIFIERS)
{
if (!STRING_EMPTY (&decl))
- {
- string_prepend (&decl, " ");
- }
- string_prepend (&decl,
- (**mangled) == 'C' ? "const" : "volatile");
+ string_prepend (&decl, " ");
+
+ string_prepend (&decl, demangle_qualifier (**mangled));
}
(*mangled)++;
break;
@@ -2709,7 +3039,7 @@ do_type (work, mangled, result)
}
}
- switch (**mangled)
+ if (success) switch (**mangled)
{
/* A qualified name, such as "Outer::Inner". */
case 'Q':
@@ -2723,11 +3053,9 @@ do_type (work, mangled, result)
case 'B':
(*mangled)++;
if (!get_count (mangled, &n) || n >= work -> numb)
- success = 0;
+ success = 0;
else
- {
- string_append (result, work->btypevec[n]);
- }
+ string_append (result, work->btypevec[n]);
break;
case 'X':
@@ -2739,7 +3067,7 @@ do_type (work, mangled, result)
(*mangled)++;
idx = consume_count_with_underscores (mangled);
- if (idx == -1
+ if (idx == -1
|| (work->tmpl_argvec && idx >= work->ntmpl_args)
|| consume_count_with_underscores (mangled) == -1)
{
@@ -2762,6 +3090,8 @@ do_type (work, mangled, result)
default:
success = demangle_fund_type (work, mangled, result);
+ if (tk == tk_none)
+ tk = (type_kind_t) success;
break;
}
@@ -2774,11 +3104,14 @@ do_type (work, mangled, result)
}
}
else
- {
- string_delete (result);
- }
+ string_delete (result);
string_delete (&decl);
- return (success);
+
+ if (success)
+ /* Assume an integral type, if we're not sure. */
+ return (int) ((tk == tk_none) ? tk_integral : tk);
+ else
+ return 0;
}
/* Given a pointer to a type string that represents a fundamental type
@@ -2792,7 +3125,7 @@ do_type (work, mangled, result)
"Sl" => "signed long"
"CUs" => "const unsigned short"
- */
+ The value returned is really a type_kind_t. */
static int
demangle_fund_type (work, mangled, result)
@@ -2802,7 +3135,11 @@ demangle_fund_type (work, mangled, result)
{
int done = 0;
int success = 1;
+ char buf[10];
+ int dec = 0;
string btype;
+ type_kind_t tk = tk_integral;
+
string_init (&btype);
/* First pick off any type qualifiers. There can be more than one. */
@@ -2812,12 +3149,15 @@ demangle_fund_type (work, mangled, result)
switch (**mangled)
{
case 'C':
- (*mangled)++;
+ case 'V':
+ case 'u':
if (PRINT_ANSI_QUALIFIERS)
{
- APPEND_BLANK (result);
- string_append (result, "const");
+ if (!STRING_EMPTY (result))
+ string_prepend (result, " ");
+ string_prepend (result, demangle_qualifier (**mangled));
}
+ (*mangled)++;
break;
case 'U':
(*mangled)++;
@@ -2829,14 +3169,6 @@ demangle_fund_type (work, mangled, result)
APPEND_BLANK (result);
string_append (result, "signed");
break;
- case 'V':
- (*mangled)++;
- if (PRINT_ANSI_QUALIFIERS)
- {
- APPEND_BLANK (result);
- string_append (result, "volatile");
- }
- break;
case 'J':
(*mangled)++;
APPEND_BLANK (result);
@@ -2884,39 +3216,67 @@ demangle_fund_type (work, mangled, result)
(*mangled)++;
APPEND_BLANK (result);
string_append (result, "bool");
+ tk = tk_bool;
break;
case 'c':
(*mangled)++;
APPEND_BLANK (result);
string_append (result, "char");
+ tk = tk_char;
break;
case 'w':
(*mangled)++;
APPEND_BLANK (result);
string_append (result, "wchar_t");
+ tk = tk_char;
break;
case 'r':
(*mangled)++;
APPEND_BLANK (result);
string_append (result, "long double");
+ tk = tk_real;
break;
case 'd':
(*mangled)++;
APPEND_BLANK (result);
string_append (result, "double");
+ tk = tk_real;
break;
case 'f':
(*mangled)++;
APPEND_BLANK (result);
string_append (result, "float");
+ tk = tk_real;
break;
case 'G':
(*mangled)++;
- if (!isdigit (**mangled))
+ if (!isdigit ((unsigned char)**mangled))
{
success = 0;
break;
}
+ case 'I':
+ ++(*mangled);
+ if (**mangled == '_')
+ {
+ int i;
+ ++(*mangled);
+ for (i = 0; **mangled != '_'; ++(*mangled), ++i)
+ buf[i] = **mangled;
+ buf[i] = '\0';
+ ++(*mangled);
+ }
+ else
+ {
+ strncpy (buf, *mangled, 2);
+ *mangled += 2;
+ }
+ sscanf (buf, "%x", &dec);
+ sprintf (buf, "int%i_t", dec);
+ APPEND_BLANK (result);
+ string_append (result, buf);
+ break;
+
/* fall through */
/* An explicit type, such as "6mytype" or "7integer" */
case '0':
@@ -2938,7 +3298,7 @@ demangle_fund_type (work, mangled, result)
APPEND_BLANK (result);
string_appends (result, &btype);
}
- else
+ else
success = 0;
string_delete (&btype);
break;
@@ -2954,7 +3314,141 @@ demangle_fund_type (work, mangled, result)
break;
}
- return (success);
+ return success ? ((int) tk) : 0;
+}
+
+
+/* Handle a template's value parameter for HP aCC (extension from ARM)
+ **mangled points to 'S' or 'U' */
+
+static int
+do_hpacc_template_const_value (work, mangled, result)
+ struct work_stuff *work;
+ const char **mangled;
+ string *result;
+{
+ int unsigned_const;
+
+ if (**mangled != 'U' && **mangled != 'S')
+ return 0;
+
+ unsigned_const = (**mangled == 'U');
+
+ (*mangled)++;
+
+ switch (**mangled)
+ {
+ case 'N':
+ string_append (result, "-");
+ /* fall through */
+ case 'P':
+ (*mangled)++;
+ break;
+ case 'M':
+ /* special case for -2^31 */
+ string_append (result, "-2147483648");
+ (*mangled)++;
+ return 1;
+ default:
+ return 0;
+ }
+
+ /* We have to be looking at an integer now */
+ if (!(isdigit ((unsigned char)**mangled)))
+ return 0;
+
+ /* We only deal with integral values for template
+ parameters -- so it's OK to look only for digits */
+ while (isdigit ((unsigned char)**mangled))
+ {
+ char_str[0] = **mangled;
+ string_append (result, char_str);
+ (*mangled)++;
+ }
+
+ if (unsigned_const)
+ string_append (result, "U");
+
+ /* FIXME? Some day we may have 64-bit (or larger :-) ) constants
+ with L or LL suffixes. pai/1997-09-03 */
+
+ return 1; /* success */
+}
+
+/* Handle a template's literal parameter for HP aCC (extension from ARM)
+ **mangled is pointing to the 'A' */
+
+static int
+do_hpacc_template_literal (work, mangled, result)
+ struct work_stuff *work;
+ const char **mangled;
+ string *result;
+{
+ int literal_len = 0;
+ char * recurse;
+ char * recurse_dem;
+
+ if (**mangled != 'A')
+ return 0;
+
+ (*mangled)++;
+
+ literal_len = consume_count (mangled);
+
+ if (!literal_len)
+ return 0;
+
+ /* Literal parameters are names of arrays, functions, etc. and the
+ canonical representation uses the address operator */
+ string_append (result, "&");
+
+ /* Now recursively demangle the literal name */
+ recurse = (char *) xmalloc (literal_len + 1);
+ memcpy (recurse, *mangled, literal_len);
+ recurse[literal_len] = '\000';
+
+ recurse_dem = cplus_demangle (recurse, work->options);
+
+ if (recurse_dem)
+ {
+ string_append (result, recurse_dem);
+ free (recurse_dem);
+ }
+ else
+ {
+ string_appendn (result, *mangled, literal_len);
+ }
+ (*mangled) += literal_len;
+ free (recurse);
+
+ return 1;
+}
+
+static int
+snarf_numeric_literal (args, arg)
+ const char ** args;
+ string * arg;
+{
+ if (**args == '-')
+ {
+ char_str[0] = '-';
+ string_append (arg, char_str);
+ (*args)++;
+ }
+ else if (**args == '+')
+ (*args)++;
+
+ if (!isdigit ((unsigned char)**args))
+ return 0;
+
+ while (isdigit ((unsigned char)**args))
+ {
+ char_str[0] = **args;
+ string_append (arg, char_str);
+ (*args)++;
+ }
+
+ return 1;
}
/* Demangle the next argument, given by MANGLED into RESULT, which
@@ -2980,7 +3474,7 @@ do_arg (work, mangled, result)
if (work->previous_argument == 0)
return 0;
- /* We want to reissue the previous type in this argument list. */
+ /* We want to reissue the previous type in this argument list. */
string_appends (result, work->previous_argument);
return 1;
}
@@ -3004,7 +3498,7 @@ do_arg (work, mangled, result)
else
(*mangled)++;
}
-
+
/* Now, the repeat is all set up. */
return do_arg (work, mangled, result);
}
@@ -3096,7 +3590,7 @@ remember_Ktype (work, start, len)
}
/* Register a B code, and get an index for it. B codes are registered
- as they are seen, rather than as they are completed, so map<temp<char> >
+ as they are seen, rather than as they are completed, so map<temp<char> >
registers map<temp<char> > as B0, and temp<char> as B1 */
static int
@@ -3104,7 +3598,7 @@ register_Btype (work)
struct work_stuff *work;
{
int ret;
-
+
if (work -> numb >= work -> bsize)
{
if (work -> bsize == 0)
@@ -3258,7 +3752,7 @@ demangle_args (work, mangled, declp)
if ((**mangled == 'N') || (**mangled == 'T'))
{
temptype = *(*mangled)++;
-
+
if (temptype == 'N')
{
if (!get_count (mangled, &r))
@@ -3270,7 +3764,7 @@ demangle_args (work, mangled, declp)
{
r = 1;
}
- if (ARM_DEMANGLING && work -> ntypes >= 10)
+ if ((HP_DEMANGLING || ARM_DEMANGLING || EDG_DEMANGLING) && work -> ntypes >= 10)
{
/* If we have 10 or more types we might have more than a 1 digit
index so we'll have to consume the whole count here. This
@@ -3290,7 +3784,7 @@ demangle_args (work, mangled, declp)
return (0);
}
}
- if (LUCID_DEMANGLING || ARM_DEMANGLING)
+ if (LUCID_DEMANGLING || ARM_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING)
{
t--;
}
@@ -3380,7 +3874,7 @@ demangle_nested_args (work, mangled, declp)
/* Actually demangle the arguments. */
result = demangle_args (work, mangled, declp);
-
+
/* Restore the previous_argument field. */
if (work->previous_argument)
string_delete (work->previous_argument);
@@ -3410,8 +3904,18 @@ demangle_function_name (work, mangled, declp, scan)
separator. */
(*mangled) = scan + 2;
+ /* We may be looking at an instantiation of a template function:
+ foo__Xt1t2_Ft3t4, where t1, t2, ... are template arguments and a
+ following _F marks the start of the function arguments. Handle
+ the template arguments first. */
- if (LUCID_DEMANGLING || ARM_DEMANGLING)
+ if (HP_DEMANGLING && (**mangled == 'X'))
+ {
+ demangle_arm_hp_template (work, mangled, 0, declp);
+ /* This leaves MANGLED pointing to the 'F' marking func args */
+ }
+
+ if (LUCID_DEMANGLING || ARM_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING)
{
/* See if we have an ARM style constructor or destructor operator.
@@ -3433,7 +3937,7 @@ demangle_function_name (work, mangled, declp, scan)
}
}
- if (declp->p - declp->b >= 3
+ if (declp->p - declp->b >= 3
&& declp->b[0] == 'o'
&& declp->b[1] == 'p'
&& strchr (cplus_markers, declp->b[2]) != NULL)
@@ -3445,7 +3949,7 @@ demangle_function_name (work, mangled, declp, scan)
for (i = 0; i < sizeof (optable) / sizeof (optable[0]); i++)
{
int len = declp->p - declp->b - 10;
- if (strlen (optable[i].in) == len
+ if ((int) strlen (optable[i].in) == len
&& memcmp (optable[i].in, declp->b + 10, len) == 0)
{
string_clear (declp);
@@ -3461,7 +3965,7 @@ demangle_function_name (work, mangled, declp, scan)
for (i = 0; i < sizeof (optable) / sizeof (optable[0]); i++)
{
int len = declp->p - declp->b - 3;
- if (strlen (optable[i].in) == len
+ if ((int) strlen (optable[i].in) == len
&& memcmp (optable[i].in, declp->b + 3, len) == 0)
{
string_clear (declp);
@@ -3532,7 +4036,7 @@ demangle_function_name (work, mangled, declp, scan)
string_append (declp, "operator");
string_append (declp, optable[i].out);
break;
- }
+ }
}
}
}
@@ -3586,7 +4090,7 @@ string_init (s)
s->b = s->p = s->e = NULL;
}
-static void
+static void
string_clear (s)
string *s;
{
@@ -3727,10 +4231,10 @@ static void
usage (stream, status)
FILE *stream;
int status;
-{
+{
fprintf (stream, "\
-Usage: %s [-_] [-n] [-s {gnu,lucid,arm}] [--strip-underscores]\n\
- [--no-strip-underscores] [--format={gnu,lucid,arm}]\n\
+Usage: %s [-_] [-n] [-s {gnu,lucid,arm,hp,edg}] [--strip-underscores]\n\
+ [--no-strip-underscores] [--format={gnu,lucid,arm,hp,edg}]\n\
[--help] [--version] [arg...]\n",
program_name);
exit (status);
@@ -3787,7 +4291,7 @@ main (argc, argv)
strip_underscore = 0;
break;
case 'v':
- printf ("GNU %s version %s\n", program_name, program_version);
+ printf ("GNU %s (C++ demangler), version %s\n", program_name, program_version);
exit (0);
case '_':
strip_underscore = 1;
@@ -3805,6 +4309,14 @@ main (argc, argv)
{
current_demangling_style = arm_demangling;
}
+ else if (strcmp (optarg, "hp") == 0)
+ {
+ current_demangling_style = hp_demangling;
+ }
+ else if (strcmp (optarg, "edg") == 0)
+ {
+ current_demangling_style = edg_demangling;
+ }
else
{
fprintf (stderr, "%s: unknown demangling style `%s'\n",
@@ -3829,7 +4341,11 @@ main (argc, argv)
int i = 0;
c = getchar ();
/* Try to read a label. */
- while (c != EOF && (isalnum(c) || c == '_' || c == '$' || c == '.'))
+ while (c != EOF && (isalnum(c) || c == '_' || c == '$' || c == '.' ||
+ c == '<' || c == '>' || c == '#' || c == ',' || c == '*' || c == '&' ||
+ c == '[' || c == ']' || c == ':' || c == '(' || c == ')'))
+ /* the ones in the 2nd & 3rd lines were added to handle
+ HP aCC template specialization manglings */
{
if (i >= MBUF_SIZE-1)
break;
@@ -3849,7 +4365,7 @@ main (argc, argv)
skip_first = i;
mbuffer[i] = 0;
-
+
result = cplus_demangle (mbuffer + skip_first, flags);
if (result)
{
@@ -3880,25 +4396,22 @@ fatal (str)
exit (1);
}
-char * malloc ();
-char * realloc ();
-
-char *
+PTR
xmalloc (size)
- unsigned size;
+ size_t size;
{
- register char *value = (char *) malloc (size);
+ register PTR value = (PTR) malloc (size);
if (value == 0)
fatal ("virtual memory exhausted");
return value;
}
-char *
+PTR
xrealloc (ptr, size)
- char *ptr;
- unsigned size;
+ PTR ptr;
+ size_t size;
{
- register char *value = (char *) realloc (ptr, size);
+ register PTR value = (PTR) realloc (ptr, size);
if (value == 0)
fatal ("virtual memory exhausted");
return value;
diff --git a/gnu/dist/include/demangle.h b/gnu/dist/include/demangle.h
index 00f6a0c3bc0..917973cac64 100644
--- a/gnu/dist/include/demangle.h
+++ b/gnu/dist/include/demangle.h
@@ -38,8 +38,12 @@
#define DMGL_GNU (1 << 9)
#define DMGL_LUCID (1 << 10)
#define DMGL_ARM (1 << 11)
+#define DMGL_HP (1 << 12) /* For the HP aCC compiler; same as ARM
+ except for template arguments, etc. */
+#define DMGL_EDG (1 << 13)
+
/* If none of these are set, use 'current_demangling_style' as the default. */
-#define DMGL_STYLE_MASK (DMGL_AUTO|DMGL_GNU|DMGL_LUCID|DMGL_ARM)
+#define DMGL_STYLE_MASK (DMGL_AUTO|DMGL_GNU|DMGL_LUCID|DMGL_ARM|DMGL_HP|DMGL_EDG)
/* Enumeration of possible demangling styles.
@@ -55,7 +59,9 @@ extern enum demangling_styles
auto_demangling = DMGL_AUTO,
gnu_demangling = DMGL_GNU,
lucid_demangling = DMGL_LUCID,
- arm_demangling = DMGL_ARM
+ arm_demangling = DMGL_ARM,
+ hp_demangling = DMGL_HP,
+ edg_demangling = DMGL_EDG
} current_demangling_style;
/* Define string names for the various demangling styles. */
@@ -64,6 +70,8 @@ extern enum demangling_styles
#define GNU_DEMANGLING_STYLE_STRING "gnu"
#define LUCID_DEMANGLING_STYLE_STRING "lucid"
#define ARM_DEMANGLING_STYLE_STRING "arm"
+#define HP_DEMANGLING_STYLE_STRING "hp"
+#define EDG_DEMANGLING_STYLE_STRING "edg"
/* Some macros to test what demangling style is active. */
@@ -71,7 +79,9 @@ extern enum demangling_styles
#define AUTO_DEMANGLING (((int) CURRENT_DEMANGLING_STYLE) & DMGL_AUTO)
#define GNU_DEMANGLING (((int) CURRENT_DEMANGLING_STYLE) & DMGL_GNU)
#define LUCID_DEMANGLING (((int) CURRENT_DEMANGLING_STYLE) & DMGL_LUCID)
-#define ARM_DEMANGLING (CURRENT_DEMANGLING_STYLE & DMGL_ARM)
+#define ARM_DEMANGLING (((int) CURRENT_DEMANGLING_STYLE) & DMGL_ARM)
+#define HP_DEMANGLING (((int) CURRENT_DEMANGLING_STYLE) & DMGL_HP)
+#define EDG_DEMANGLING (((int) CURRENT_DEMANGLING_STYLE) & DMGL_EDG)
extern char *
cplus_demangle PARAMS ((const char *mangled, int options));
diff --git a/gnu/dist/libiberty/cplus-dem.c b/gnu/dist/libiberty/cplus-dem.c
index 1a3ec90ec40..a3eb85f013e 100644
--- a/gnu/dist/libiberty/cplus-dem.c
+++ b/gnu/dist/libiberty/cplus-dem.c
@@ -1,8 +1,9 @@
-/* Demangler for GNU C++
- Copyright 1989, 1991, 1994, 1995, 1996, 1997, 1998 Free Software Foundation, Inc.
+/* Demangler for GNU C++
+ Copyright 1989, 91, 94, 95, 96, 97, 98, 1999 Free Software Foundation, Inc.
Written by James Clark (jjc@jclark.uucp)
Rewritten by Fred Fish (fnf@cygnus.com) for ARM and Lucid demangling
-
+ Modified by Satish Pai (pai@apollo.hp.com) for HP demangling
+
This file is part of the libiberty library.
Libiberty is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
@@ -28,6 +29,10 @@ Boston, MA 02111-1307, USA. */
/* This file lives in both GCC and libiberty. When making changes, please
try not to break either. */
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
#include <ctype.h>
#include <sys/types.h>
#include <string.h>
@@ -35,14 +40,16 @@ Boston, MA 02111-1307, USA. */
#ifdef HAVE_STDLIB_H
#include <stdlib.h>
+#else
+char * malloc ();
+char * realloc ();
#endif
#include <demangle.h>
#undef CURRENT_DEMANGLING_STYLE
#define CURRENT_DEMANGLING_STYLE work->options
-extern char *xmalloc PARAMS((unsigned));
-extern char *xrealloc PARAMS((char *, unsigned));
+#include "libiberty.h"
static const char *mystrstr PARAMS ((const char *, const char *));
@@ -87,6 +94,8 @@ enum demangling_styles current_demangling_style = gnu_demangling;
static char cplus_markers[] = { CPLUS_MARKER, '.', '$', '\0' };
+static char char_str[2] = { '\000', '\000' };
+
void
set_cplus_marker_for_demangling (ch)
int ch;
@@ -119,8 +128,9 @@ struct work_stuff
int constructor;
int destructor;
int static_type; /* A static member function */
- int const_type; /* A const member function */
- int volatile_type; /* A volatile member function */
+ int temp_start; /* index in demangled to start of template args */
+ int type_quals; /* The type qualifiers. */
+ int dllimported; /* Symbol imported from a PE DLL */
char **tmpl_argvec; /* Template function arguments. */
int ntmpl_args; /* The number of template function arguments. */
int forgetting_types; /* Nonzero if we are not remembering the types
@@ -220,6 +230,19 @@ static const struct optable
{"sz", "sizeof ", DMGL_ANSI} /* pseudo-ansi */
};
+/* These values are used to indicate the various type varieties.
+ They are all non-zero so that they can be used as `success'
+ values. */
+typedef enum type_kind_t
+{
+ tk_none,
+ tk_pointer,
+ tk_reference,
+ tk_integral,
+ tk_bool,
+ tk_char,
+ tk_real
+} type_kind_t;
#define STRING_EMPTY(str) ((str) -> b == (str) -> p)
#define PREPEND_BLANK(str) {if (!STRING_EMPTY(str)) \
@@ -251,7 +274,7 @@ static char *
internal_cplus_demangle PARAMS ((struct work_stuff *, const char *));
static int
-demangle_template_template_parm PARAMS ((struct work_stuff *work,
+demangle_template_template_parm PARAMS ((struct work_stuff *work,
const char **, string *));
static int
@@ -262,9 +285,6 @@ static int
arm_pt PARAMS ((struct work_stuff *, const char *, int, const char **,
const char **));
-static void
-demangle_arm_pt PARAMS ((struct work_stuff *, const char **, int, string *));
-
static int
demangle_class_name PARAMS ((struct work_stuff *, const char **, string *));
@@ -328,7 +348,7 @@ get_count PARAMS ((const char **, int *));
static int
consume_count PARAMS ((const char **));
-static int
+static int
consume_count_with_underscores PARAMS ((const char**));
static int
@@ -368,9 +388,36 @@ forget_B_and_K_types PARAMS ((struct work_stuff *));
static void
string_prepends PARAMS ((string *, string *));
-static int
-demangle_template_value_parm PARAMS ((struct work_stuff*,
- const char**, string*));
+static int
+demangle_template_value_parm PARAMS ((struct work_stuff*, const char**,
+ string*, type_kind_t));
+
+static int
+do_hpacc_template_const_value PARAMS ((struct work_stuff *, const char **, string *));
+
+static int
+do_hpacc_template_literal PARAMS ((struct work_stuff *, const char **, string *));
+
+static int
+snarf_numeric_literal PARAMS ((const char **, string *));
+
+/* There is a TYPE_QUAL value for each type qualifier. They can be
+ combined by bitwise-or to form the complete set of qualifiers for a
+ type. */
+
+#define TYPE_UNQUALIFIED 0x0
+#define TYPE_QUAL_CONST 0x1
+#define TYPE_QUAL_VOLATILE 0x2
+#define TYPE_QUAL_RESTRICT 0x4
+
+static int
+code_for_qualifier PARAMS ((int));
+
+static const char*
+qualifier_string PARAMS ((int));
+
+static const char*
+demangle_qualifier PARAMS ((int));
/* Translate count to integer, consuming tokens in the process.
Conversion terminates on the first non-digit character.
@@ -383,7 +430,7 @@ consume_count (type)
{
int count = 0;
- while (isdigit (**type))
+ while (isdigit ((unsigned char)**type))
{
count *= 10;
count += **type - '0';
@@ -406,21 +453,21 @@ consume_count_with_underscores (mangled)
if (**mangled == '_')
{
(*mangled)++;
- if (!isdigit (**mangled))
+ if (!isdigit ((unsigned char)**mangled))
return -1;
idx = consume_count (mangled);
if (**mangled != '_')
/* The trailing underscore was missing. */
return -1;
-
+
(*mangled)++;
}
else
{
if (**mangled < '0' || **mangled > '9')
return -1;
-
+
idx = **mangled - '0';
(*mangled)++;
}
@@ -428,6 +475,84 @@ consume_count_with_underscores (mangled)
return idx;
}
+/* C is the code for a type-qualifier. Return the TYPE_QUAL
+ corresponding to this qualifier. */
+
+static int
+code_for_qualifier (c)
+ int c;
+{
+ switch (c)
+ {
+ case 'C':
+ return TYPE_QUAL_CONST;
+
+ case 'V':
+ return TYPE_QUAL_VOLATILE;
+
+ case 'u':
+ return TYPE_QUAL_RESTRICT;
+
+ default:
+ break;
+ }
+
+ /* C was an invalid qualifier. */
+ abort ();
+}
+
+/* Return the string corresponding to the qualifiers given by
+ TYPE_QUALS. */
+
+static const char*
+qualifier_string (type_quals)
+ int type_quals;
+{
+ switch (type_quals)
+ {
+ case TYPE_UNQUALIFIED:
+ return "";
+
+ case TYPE_QUAL_CONST:
+ return "const";
+
+ case TYPE_QUAL_VOLATILE:
+ return "volatile";
+
+ case TYPE_QUAL_RESTRICT:
+ return "__restrict";
+
+ case TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE:
+ return "const volatile";
+
+ case TYPE_QUAL_CONST | TYPE_QUAL_RESTRICT:
+ return "const __restrict";
+
+ case TYPE_QUAL_VOLATILE | TYPE_QUAL_RESTRICT:
+ return "volatile __restrict";
+
+ case TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE | TYPE_QUAL_RESTRICT:
+ return "const volatile __restrict";
+
+ default:
+ break;
+ }
+
+ /* TYPE_QUALS was an invalid qualifier set. */
+ abort ();
+}
+
+/* C is the code for a type-qualifier. Return the string
+ corresponding to this qualifier. This function should only be
+ called with a valid qualifier code. */
+
+static const char*
+demangle_qualifier (c)
+ int c;
+{
+ return qualifier_string (code_for_qualifier (c));
+}
+
int
cplus_demangle_opname (opname, result, options)
const char *opname;
@@ -444,7 +569,7 @@ cplus_demangle_opname (opname, result, options)
ret = 0;
memset ((char *) work, 0, sizeof (work));
work->options = options;
-
+
if (opname[0] == '_' && opname[1] == '_'
&& opname[2] == 'o' && opname[3] == 'p')
{
@@ -494,12 +619,12 @@ cplus_demangle_opname (opname, result, options)
strcat (result, optable[i].out);
ret = 1;
break;
- }
+ }
}
}
}
}
- else if (len >= 3
+ else if (len >= 3
&& opname[0] == 'o'
&& opname[1] == 'p'
&& strchr (cplus_markers, opname[2]) != NULL)
@@ -512,7 +637,7 @@ cplus_demangle_opname (opname, result, options)
for (i = 0; i < sizeof (optable) / sizeof (optable[0]); i++)
{
len1 = len - 10;
- if (strlen (optable[i].in) == len1
+ if ((int) strlen (optable[i].in) == len1
&& memcmp (optable[i].in, opname + 10, len1) == 0)
{
strcat (result, "operator");
@@ -529,7 +654,7 @@ cplus_demangle_opname (opname, result, options)
for (i = 0; i < sizeof (optable) / sizeof (optable[0]); i++)
{
len1 = len - 3;
- if (strlen (optable[i].in) == len1
+ if ((int) strlen (optable[i].in) == len1
&& memcmp (optable[i].in, opname + 3, len1) == 0)
{
strcat (result, "operator");
@@ -574,7 +699,7 @@ cplus_mangle_opname (opname, options)
len = strlen (opname);
for (i = 0; i < sizeof (optable) / sizeof (optable[0]); i++)
{
- if (strlen (optable[i].out) == len
+ if ((int) strlen (optable[i].out) == len
&& (options & DMGL_ANSI) == (optable[i].flags & DMGL_ANSI)
&& memcmp (optable[i].out, opname, len) == 0)
return optable[i].in;
@@ -597,7 +722,7 @@ cplus_mangle_opname (opname, options)
DMGL_PARAMS Function parameters are included.
For example,
-
+
cplus_demangle ("foo__1Ai", DMGL_PARAMS) => "A::foo(int)"
cplus_demangle ("foo__1Ai", DMGL_PARAMS | DMGL_ANSI) => "A::foo(int)"
cplus_demangle ("foo__1Ai", 0) => "A::foo"
@@ -626,9 +751,9 @@ cplus_demangle (mangled, options)
squangle_mop_up (work);
return (ret);
}
-
-/* This function performs most of what cplus_demangle use to do, but
+
+/* This function performs most of what cplus_demangle use to do, but
to be able to demangle a name with a B, K or n code, we need to
have a longer term memory of what types have been seen. The original
now intializes and cleans up the squangle code info, while internal
@@ -644,15 +769,13 @@ internal_cplus_demangle (work, mangled)
int success = 0;
char *demangled = NULL;
int s1,s2,s3,s4;
- int saved_volatile_type;
s1 = work->constructor;
s2 = work->destructor;
s3 = work->static_type;
- s4 = work->const_type;
- saved_volatile_type = work->volatile_type;
+ s4 = work->type_quals;
work->constructor = work->destructor = 0;
- work->static_type = work->const_type = 0;
- work->volatile_type = 0;
+ work->type_quals = TYPE_UNQUALIFIED;
+ work->dllimported = 0;
if ((mangled != NULL) && (*mangled != '\0'))
{
@@ -687,13 +810,17 @@ internal_cplus_demangle (work, mangled)
string_prepend (&decl, "global destructors keyed to ");
work->destructor = 0;
}
+ else if (work->dllimported == 1)
+ {
+ string_prepend (&decl, "import stub for ");
+ work->dllimported = 0;
+ }
demangled = mop_up (work, &decl, success);
}
work->constructor = s1;
work->destructor = s2;
work->static_type = s3;
- work->const_type = s4;
- work->volatile_type = saved_volatile_type;
+ work->type_quals = s4;
return (demangled);
}
@@ -726,7 +853,7 @@ mop_up (work, declp, success)
char *demangled = NULL;
/* Discard the remembered types, if any. */
-
+
forget_types (work);
if (work -> typevec != NULL)
{
@@ -740,7 +867,7 @@ mop_up (work, declp, success)
for (i = 0; i < work->ntmpl_args; i++)
if (work->tmpl_argvec[i])
free ((char*) work->tmpl_argvec[i]);
-
+
free ((char*) work->tmpl_argvec);
work->tmpl_argvec = NULL;
}
@@ -748,11 +875,12 @@ mop_up (work, declp, success)
{
string_delete (work->previous_argument);
free ((char*) work->previous_argument);
+ work->previous_argument = NULL;
}
/* If demangling was successful, ensure that the demangled string is null
terminated and return it. Otherwise, free the demangling decl. */
-
+
if (!success)
{
string_delete (declp);
@@ -832,7 +960,7 @@ demangle_signature (work, mangled, declp)
}
oldmangled = NULL;
break;
-
+
case 'S':
/* Static member function */
if (oldmangled == NULL)
@@ -845,31 +973,48 @@ demangle_signature (work, mangled, declp)
case 'C':
case 'V':
- if (**mangled == 'C')
- work -> const_type = 1;
- else
- work->volatile_type = 1;
+ case 'u':
+ work->type_quals |= code_for_qualifier (**mangled);
/* a qualified member function */
if (oldmangled == NULL)
oldmangled = *mangled;
(*mangled)++;
break;
-
+
+ case 'L':
+ /* Local class name follows after "Lnnn_" */
+ if (HP_DEMANGLING)
+ {
+ while (**mangled && (**mangled != '_'))
+ (*mangled)++;
+ if (!**mangled)
+ success = 0;
+ else
+ (*mangled)++;
+ }
+ else
+ success = 0;
+ break;
+
case '0': case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9':
if (oldmangled == NULL)
{
oldmangled = *mangled;
}
+ work->temp_start = -1; /* uppermost call to demangle_class */
success = demangle_class (work, mangled, declp);
if (success)
{
remember_type (work, oldmangled, *mangled - oldmangled);
}
- if (AUTO_DEMANGLING || GNU_DEMANGLING)
+ if (AUTO_DEMANGLING || GNU_DEMANGLING || EDG_DEMANGLING)
{
- expect_func = 1;
+ /* EDG and others will have the "F", so we let the loop cycle
+ if we are looking at one. */
+ if (**mangled != 'F')
+ expect_func = 1;
}
oldmangled = NULL;
break;
@@ -890,7 +1035,7 @@ demangle_signature (work, mangled, declp)
case 'F':
/* Function */
- /* ARM style demangling includes a specific 'F' character after
+ /* ARM/HP style demangling includes a specific 'F' character after
the class name. For GNU style, it is just implied. So we can
safely just consume any 'F' at this point and be compatible
with either style. */
@@ -899,21 +1044,32 @@ demangle_signature (work, mangled, declp)
func_done = 1;
(*mangled)++;
- /* For lucid/ARM style we have to forget any types we might
+ /* For lucid/ARM/HP style we have to forget any types we might
have remembered up to this point, since they were not argument
types. GNU style considers all types seen as available for
back references. See comment in demangle_args() */
- if (LUCID_DEMANGLING || ARM_DEMANGLING)
+ if (LUCID_DEMANGLING || ARM_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING)
{
forget_types (work);
}
success = demangle_args (work, mangled, declp);
+ /* After picking off the function args, we expect to either
+ find the function return type (preceded by an '_') or the
+ end of the string. */
+ if (success && (AUTO_DEMANGLING || EDG_DEMANGLING) && **mangled == '_')
+ {
+ ++(*mangled);
+ /* At this level, we do not care about the return type. */
+ success = do_type (work, mangled, &tname);
+ string_delete (&tname);
+ }
+
break;
-
+
case 't':
/* G++ Template */
- string_init(&trawname);
+ string_init(&trawname);
string_init(&tname);
if (oldmangled == NULL)
{
@@ -925,7 +1081,8 @@ demangle_signature (work, mangled, declp)
{
remember_type (work, oldmangled, *mangled - oldmangled);
}
- string_append(&tname, SCOPE_STRING (work));
+ string_append (&tname, SCOPE_STRING (work));
+
string_prepends(declp, &tname);
if (work -> destructor & 1)
{
@@ -945,7 +1102,7 @@ demangle_signature (work, mangled, declp)
break;
case '_':
- if (GNU_DEMANGLING && expect_return_type)
+ if (GNU_DEMANGLING && expect_return_type)
{
/* Read the return type. */
string return_type;
@@ -965,11 +1122,21 @@ demangle_signature (work, mangled, declp)
a mangled name that is either bogus, or has been mangled by
some algorithm we don't know how to deal with. So just
reject the entire demangling. */
- success = 0;
+ /* However, "_nnn" is an expected suffix for alternate entry point
+ numbered nnn for a function, with HP aCC, so skip over that
+ without reporting failure. pai/1997-09-04 */
+ if (HP_DEMANGLING)
+ {
+ (*mangled)++;
+ while (**mangled && isdigit ((unsigned char)**mangled))
+ (*mangled)++;
+ }
+ else
+ success = 0;
break;
case 'H':
- if (GNU_DEMANGLING)
+ if (GNU_DEMANGLING)
{
/* A G++ template function. Read the template arguments. */
success = demangle_template (work, mangled, declp, 0, 0,
@@ -995,7 +1162,7 @@ demangle_signature (work, mangled, declp)
{
/* 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
+ for ARM/HP-demangling, for example. So if we find something
we are not prepared for, it must be an error. */
success = 0;
}
@@ -1008,6 +1175,10 @@ demangle_signature (work, mangled, declp)
if (success && expect_func)
{
func_done = 1;
+ if (LUCID_DEMANGLING || ARM_DEMANGLING || EDG_DEMANGLING)
+ {
+ forget_types (work);
+ }
success = demangle_args (work, mangled, declp);
/* Since template include the mangling of their return types,
we must set expect_func to 0 so that we don't try do
@@ -1023,18 +1194,22 @@ demangle_signature (work, mangled, declp)
/* With GNU style demangling, bar__3foo is 'foo::bar(void)', and
bar__3fooi is 'foo::bar(int)'. We get here when we find the
first case, and need to ensure that the '(void)' gets added to
- the current declp. Note that with ARM, the first case
+ the current declp. Note that with ARM/HP, the first case
represents the name of a static data member 'foo::bar',
which is in the current declp, so we leave it alone. */
success = demangle_args (work, mangled, declp);
}
}
- if (success && work -> static_type && PRINT_ARG_TYPES)
- string_append (declp, " static");
- if (success && work -> const_type && PRINT_ARG_TYPES)
- string_append (declp, " const");
- else if (success && work->volatile_type && PRINT_ARG_TYPES)
- string_append (declp, " volatile");
+ if (success && PRINT_ARG_TYPES)
+ {
+ if (work->static_type)
+ string_append (declp, " static");
+ if (work->type_quals != TYPE_UNQUALIFIED)
+ {
+ APPEND_BLANK (declp);
+ string_append (declp, qualifier_string (work->type_quals));
+ }
+ }
return (success);
}
@@ -1097,7 +1272,7 @@ demangle_template_template_parm (work, mangled, tname)
else if (**mangled == 'z')
{
(*mangled)++;
- success =
+ success =
demangle_template_template_parm (work, mangled, tname);
if (!success)
{
@@ -1139,7 +1314,7 @@ demangle_integral_value (work, mangled, s)
if (**mangled == 'E')
{
int need_operator = 0;
-
+
success = 1;
string_appendn (s, "(", 1);
(*mangled)++;
@@ -1154,7 +1329,7 @@ demangle_integral_value (work, mangled, s)
len = strlen (*mangled);
- for (i = 0;
+ for (i = 0;
i < sizeof (optable) / sizeof (optable [0]);
++i)
{
@@ -1178,12 +1353,13 @@ demangle_integral_value (work, mangled, s)
else
need_operator = 1;
- success = demangle_template_value_parm (work, mangled, s);
+ success = demangle_template_value_parm (work, mangled, s,
+ tk_integral);
}
if (**mangled != 'W')
success = 0;
- else
+ else
{
string_appendn (s, ")", 1);
(*mangled)++;
@@ -1200,88 +1376,26 @@ demangle_integral_value (work, mangled, s)
string_appendn (s, "-", 1);
(*mangled)++;
}
- while (isdigit (**mangled))
+ while (isdigit ((unsigned char)**mangled))
{
string_appendn (s, *mangled, 1);
(*mangled)++;
success = 1;
}
}
-
+
return success;
}
-static int
-demangle_template_value_parm (work, mangled, s)
+static int
+demangle_template_value_parm (work, mangled, s, tk)
struct work_stuff *work;
const char **mangled;
string* s;
+ type_kind_t tk;
{
- const char *old_p = *mangled;
- int is_pointer = 0;
- int is_real = 0;
- int is_integral = 0;
- int is_char = 0;
- int is_bool = 0;
- int done = 0;
int success = 1;
- while (*old_p && !done)
- {
- switch (*old_p)
- {
- case 'P':
- case 'p':
- case 'R':
- done = is_pointer = 1;
- break;
- case 'C': /* const */
- case 'S': /* explicitly signed [char] */
- case 'U': /* unsigned */
- case 'V': /* volatile */
- case 'F': /* function */
- case 'M': /* member function */
- case 'O': /* ??? */
- case 'J': /* complex */
- old_p++;
- continue;
- case 'E': /* expression */
- case 'Q': /* qualified name */
- case 'K': /* qualified name */
- done = is_integral = 1;
- break;
- case 'B': /* remembered type */
- case 'T': /* remembered type */
- abort ();
- break;
- case 'v': /* void */
- abort ();
- break;
- case 'x': /* long long */
- case 'l': /* long */
- case 'i': /* int */
- case 's': /* short */
- case 'w': /* wchar_t */
- done = is_integral = 1;
- break;
- case 'b': /* bool */
- done = is_bool = 1;
- break;
- case 'c': /* char */
- done = is_char = 1;
- break;
- case 'r': /* long double */
- case 'd': /* double */
- case 'f': /* float */
- done = is_real = 1;
- break;
- default:
- /* it's probably user defined type, let's assume
- it's integral, it seems hard to figure out
- what it really is */
- done = is_integral = 1;
- }
- }
if (**mangled == 'Y')
{
/* The next argument is a template parameter. */
@@ -1289,7 +1403,7 @@ demangle_template_value_parm (work, mangled, s)
(*mangled)++;
idx = consume_count_with_underscores (mangled);
- if (idx == -1
+ if (idx == -1
|| (work->tmpl_argvec && idx >= work->ntmpl_args)
|| consume_count_with_underscores (mangled) == -1)
return -1;
@@ -1302,9 +1416,9 @@ demangle_template_value_parm (work, mangled, s)
string_append (s, buf);
}
}
- else if (is_integral)
+ else if (tk == tk_integral)
success = demangle_integral_value (work, mangled, s);
- else if (is_char)
+ else if (tk == tk_char)
{
char tmp[2];
int val;
@@ -1322,7 +1436,7 @@ demangle_template_value_parm (work, mangled, s)
string_appendn (s, &tmp[0], 1);
string_appendn (s, "'", 1);
}
- else if (is_bool)
+ else if (tk == tk_bool)
{
int val = consume_count (mangled);
if (val == 0)
@@ -1332,14 +1446,14 @@ demangle_template_value_parm (work, mangled, s)
else
success = 0;
}
- else if (is_real)
+ else if (tk == tk_real)
{
if (**mangled == 'm')
{
string_appendn (s, "-", 1);
(*mangled)++;
}
- while (isdigit (**mangled))
+ while (isdigit ((unsigned char)**mangled))
{
string_appendn (s, *mangled, 1);
(*mangled)++;
@@ -1348,7 +1462,7 @@ demangle_template_value_parm (work, mangled, s)
{
string_appendn (s, ".", 1);
(*mangled)++;
- while (isdigit (**mangled))
+ while (isdigit ((unsigned char)**mangled))
{
string_appendn (s, *mangled, 1);
(*mangled)++;
@@ -1358,14 +1472,14 @@ demangle_template_value_parm (work, mangled, s)
{
string_appendn (s, "e", 1);
(*mangled)++;
- while (isdigit (**mangled))
+ while (isdigit ((unsigned char)**mangled))
{
string_appendn (s, *mangled, 1);
(*mangled)++;
}
}
}
- else if (is_pointer)
+ else if (tk == tk_pointer || tk == tk_reference)
{
int symbol_len = consume_count (mangled);
if (symbol_len == 0)
@@ -1377,8 +1491,16 @@ demangle_template_value_parm (work, mangled, s)
char *p = xmalloc (symbol_len + 1), *q;
strncpy (p, *mangled, symbol_len);
p [symbol_len] = '\0';
- q = internal_cplus_demangle (work, p);
- string_appendn (s, "&", 1);
+ /* We use cplus_demangle here, rather than
+ internal_cplus_demangle, because the name of the entity
+ mangled here does not make use of any of the squangling
+ or type-code information we have built up thus far; it is
+ mangled independently. */
+ q = cplus_demangle (p, work->options);
+ if (tk == tk_pointer)
+ string_appendn (s, "&", 1);
+ /* FIXME: Pointer-to-member constants should get a
+ qualifying class name here. */
if (q)
{
string_append (s, q);
@@ -1417,7 +1539,7 @@ demangle_template (work, mangled, tname, trawname, is_type, remember)
int success = 0;
const char *start;
string temp;
- int bindex;
+ int bindex = 0;
(*mangled)++;
if (is_type)
@@ -1433,7 +1555,7 @@ demangle_template (work, mangled, tname, trawname, is_type, remember)
(*mangled)++;
idx = consume_count_with_underscores (mangled);
- if (idx == -1
+ if (idx == -1
|| (work->tmpl_argvec && idx >= work->ntmpl_args)
|| consume_count_with_underscores (mangled) == -1)
return (0);
@@ -1455,7 +1577,8 @@ demangle_template (work, mangled, tname, trawname, is_type, remember)
}
else
{
- if ((r = consume_count (mangled)) == 0 || strlen (*mangled) < r)
+ if ((r = consume_count (mangled)) == 0
+ || (int) strlen (*mangled) < r)
{
return (0);
}
@@ -1516,9 +1639,10 @@ demangle_template (work, mangled, tname, trawname, is_type, remember)
int r2;
(*mangled)++;
success = demangle_template_template_parm (work, mangled, tname);
-
+
if (success
- && (r2 = consume_count (mangled)) > 0 && strlen (*mangled) >= r2)
+ && (r2 = consume_count (mangled)) > 0
+ && (int) strlen (*mangled) >= r2)
{
string_append (tname, " ");
string_appendn (tname, *mangled, r2);
@@ -1546,20 +1670,9 @@ demangle_template (work, mangled, tname, trawname, is_type, remember)
/* temp is initialized in do_type */
success = do_type (work, mangled, &temp);
- /*
- if (success)
- {
- string_appends (s, &temp);
- }
- */
string_delete(&temp);
if (!success)
- {
- break;
- }
- /*
- string_append (s, "=");
- */
+ break;
if (!is_type)
{
@@ -1569,7 +1682,8 @@ demangle_template (work, mangled, tname, trawname, is_type, remember)
else
s = tname;
- success = demangle_template_value_parm (work, mangled, s);
+ success = demangle_template_value_parm (work, mangled, s,
+ (type_kind_t) success);
if (!success)
{
@@ -1585,17 +1699,19 @@ demangle_template (work, mangled, tname, trawname, is_type, remember)
work->tmpl_argvec[i] = xmalloc (len + 1);
memcpy (work->tmpl_argvec[i], s->b, len);
work->tmpl_argvec[i][len] = '\0';
-
+
string_appends (tname, s);
string_delete (s);
}
}
need_comma = 1;
}
+ {
if (tname->p[-1] == '>')
string_append (tname, " ");
string_append (tname, ">");
-
+ }
+
if (is_type && remember)
remember_Btype (work, tname->b, LEN_STRING (tname), bindex);
@@ -1622,8 +1738,9 @@ arm_pt (work, mangled, n, anchor, args)
int n;
const char **anchor, **args;
{
- /* ARM template? */
- if (ARM_DEMANGLING && (*anchor = mystrstr (mangled, "__pt__")))
+ /* Check if ARM template with "__pt__" in it ("parameterized type") */
+ /* Allow HP also here, because HP's cfront compiler follows ARM to some extent */
+ if ((ARM_DEMANGLING || HP_DEMANGLING) && (*anchor = mystrstr (mangled, "__pt__")))
{
int len;
*args = *anchor + 6;
@@ -1634,11 +1751,39 @@ arm_pt (work, mangled, n, anchor, args)
return 1;
}
}
+ if (AUTO_DEMANGLING || EDG_DEMANGLING)
+ {
+ if ((*anchor = mystrstr (mangled, "__tm__"))
+ || (*anchor = mystrstr (mangled, "__ps__"))
+ || (*anchor = mystrstr (mangled, "__pt__")))
+ {
+ int len;
+ *args = *anchor + 6;
+ len = consume_count (args);
+ if (*args + len == mangled + n && **args == '_')
+ {
+ ++*args;
+ return 1;
+ }
+ }
+ else if ((*anchor = mystrstr (mangled, "__S")))
+ {
+ int len;
+ *args = *anchor + 3;
+ len = consume_count (args);
+ if (*args + len == mangled + n && **args == '_')
+ {
+ ++*args;
+ return 1;
+ }
+ }
+ }
+
return 0;
}
static void
-demangle_arm_pt (work, mangled, n, declp)
+demangle_arm_hp_template (work, mangled, n, declp)
struct work_stuff *work;
const char **mangled;
int n;
@@ -1647,32 +1792,150 @@ demangle_arm_pt (work, mangled, n, declp)
const char *p;
const char *args;
const char *e = *mangled + n;
+ string arg;
- /* ARM template? */
- if (arm_pt (work, *mangled, n, &p, &args))
+ /* Check for HP aCC template spec: classXt1t2 where t1, t2 are
+ template args */
+ if (HP_DEMANGLING && ((*mangled)[n] == 'X'))
{
- string arg;
+ char *start_spec_args = NULL;
+
+ /* First check for and omit template specialization pseudo-arguments,
+ such as in "Spec<#1,#1.*>" */
+ start_spec_args = strchr (*mangled, '<');
+ if (start_spec_args && (start_spec_args - *mangled < n))
+ string_appendn (declp, *mangled, start_spec_args - *mangled);
+ else
+ string_appendn (declp, *mangled, n);
+ (*mangled) += n + 1;
+ string_init (&arg);
+ if (work->temp_start == -1) /* non-recursive call */
+ work->temp_start = declp->p - declp->b;
+ string_append (declp, "<");
+ while (1)
+ {
+ string_clear (&arg);
+ switch (**mangled)
+ {
+ case 'T':
+ /* 'T' signals a type parameter */
+ (*mangled)++;
+ if (!do_type (work, mangled, &arg))
+ goto hpacc_template_args_done;
+ break;
+
+ case 'U':
+ case 'S':
+ /* 'U' or 'S' signals an integral value */
+ if (!do_hpacc_template_const_value (work, mangled, &arg))
+ goto hpacc_template_args_done;
+ break;
+
+ case 'A':
+ /* 'A' signals a named constant expression (literal) */
+ if (!do_hpacc_template_literal (work, mangled, &arg))
+ goto hpacc_template_args_done;
+ break;
+
+ default:
+ /* Today, 1997-09-03, we have only the above types
+ of template parameters */
+ /* FIXME: maybe this should fail and return null */
+ goto hpacc_template_args_done;
+ }
+ string_appends (declp, &arg);
+ /* Check if we're at the end of template args.
+ 0 if at end of static member of template class,
+ _ if done with template args for a function */
+ if ((**mangled == '\000') || (**mangled == '_'))
+ break;
+ else
+ string_append (declp, ",");
+ }
+ hpacc_template_args_done:
+ string_append (declp, ">");
+ string_delete (&arg);
+ if (**mangled == '_')
+ (*mangled)++;
+ return;
+ }
+ /* ARM template? (Also handles HP cfront extensions) */
+ else if (arm_pt (work, *mangled, n, &p, &args))
+ {
+ string type_str;
+
string_init (&arg);
string_appendn (declp, *mangled, p - *mangled);
+ if (work->temp_start == -1) /* non-recursive call */
+ work->temp_start = declp->p - declp->b;
string_append (declp, "<");
/* should do error checking here */
while (args < e) {
string_clear (&arg);
- do_type (work, &args, &arg);
+
+ /* Check for type or literal here */
+ switch (*args)
+ {
+ /* HP cfront extensions to ARM for template args */
+ /* spec: Xt1Lv1 where t1 is a type, v1 is a literal value */
+ /* FIXME: We handle only numeric literals for HP cfront */
+ case 'X':
+ /* A typed constant value follows */
+ args++;
+ if (!do_type (work, &args, &type_str))
+ goto cfront_template_args_done;
+ string_append (&arg, "(");
+ string_appends (&arg, &type_str);
+ string_append (&arg, ")");
+ if (*args != 'L')
+ goto cfront_template_args_done;
+ args++;
+ /* Now snarf a literal value following 'L' */
+ if (!snarf_numeric_literal (&args, &arg))
+ goto cfront_template_args_done;
+ break;
+
+ case 'L':
+ /* Snarf a literal following 'L' */
+ args++;
+ if (!snarf_numeric_literal (&args, &arg))
+ goto cfront_template_args_done;
+ break;
+ default:
+ /* Not handling other HP cfront stuff */
+ if (!do_type (work, &args, &arg))
+ goto cfront_template_args_done;
+ }
string_appends (declp, &arg);
string_append (declp, ",");
}
+ cfront_template_args_done:
string_delete (&arg);
- --declp->p;
+ if (args >= e)
+ --declp->p; /* remove extra comma */
string_append (declp, ">");
}
+ else if (n>10 && strncmp (*mangled, "_GLOBAL_", 8) == 0
+ && (*mangled)[9] == 'N'
+ && (*mangled)[8] == (*mangled)[10]
+ && strchr (cplus_markers, (*mangled)[8]))
+ {
+ /* A member of the anonymous namespace. */
+ string_append (declp, "{anonymous}");
+ }
else
{
+ if (work->temp_start == -1) /* non-recursive call only */
+ work->temp_start = 0; /* disable in recursive calls */
string_appendn (declp, *mangled, n);
}
*mangled += n;
}
+/* Extract a class name, possibly a template with arguments, from the
+ mangled string; qualifiers, local class indicators, etc. have
+ already been dealt with */
+
static int
demangle_class_name (work, mangled, declp)
struct work_stuff *work;
@@ -1683,9 +1946,9 @@ demangle_class_name (work, mangled, declp)
int success = 0;
n = consume_count (mangled);
- if (strlen (*mangled) >= n)
+ if ((int) strlen (*mangled) >= n)
{
- demangle_arm_pt (work, mangled, n, declp);
+ demangle_arm_hp_template (work, mangled, n, declp);
success = 1;
}
@@ -1736,13 +1999,20 @@ demangle_class (work, mangled, declp)
int success = 0;
int btype;
string class_name;
+ char *save_class_name_end = 0;
string_init (&class_name);
btype = register_Btype (work);
if (demangle_class_name (work, mangled, &class_name))
{
+ save_class_name_end = class_name.p;
if ((work->constructor & 1) || (work->destructor & 1))
{
+ /* adjust so we don't include template args */
+ if (work->temp_start && (work->temp_start != -1))
+ {
+ class_name.p = class_name.b + work->temp_start;
+ }
string_prepends (declp, &class_name);
if (work -> destructor & 1)
{
@@ -1751,9 +2021,10 @@ demangle_class (work, mangled, declp)
}
else
{
- work -> constructor -= 1;
+ work -> constructor -= 1;
}
}
+ class_name.p = save_class_name_end;
remember_Ktype (work, class_name.b, LEN_STRING(&class_name));
remember_Btype (work, class_name.b, LEN_STRING(&class_name), btype);
string_prepend (declp, SCOPE_STRING (work));
@@ -1791,7 +2062,7 @@ DESCRIPTION
the mangled name. Upon exit, it should point to the first character
of the signature if demangling was successful, or to the first
unconsumed character if demangling of the prefix was unsuccessful.
-
+
Returns 1 on success, 0 otherwise.
*/
@@ -1805,7 +2076,17 @@ demangle_prefix (work, mangled, declp)
const char *scan;
int i;
- if (strlen(*mangled) >= 11 && strncmp(*mangled, "_GLOBAL_", 8) == 0)
+ if (strlen(*mangled) > 6
+ && (strncmp(*mangled, "_imp__", 6) == 0
+ || strncmp(*mangled, "__imp_", 6) == 0))
+ {
+ /* it's a symbol imported from a PE dynamic library. Check for both
+ new style prefix _imp__ and legacy __imp_ used by older versions
+ of dlltool. */
+ (*mangled) += 6;
+ work->dllimported = 1;
+ }
+ else if (strlen(*mangled) >= 11 && strncmp(*mangled, "_GLOBAL_", 8) == 0)
{
char *marker = strchr (cplus_markers, (*mangled)[8]);
if (marker != NULL && *marker == (*mangled)[10])
@@ -1828,13 +2109,13 @@ demangle_prefix (work, mangled, declp)
}
}
}
- else if (ARM_DEMANGLING && strncmp(*mangled, "__std__", 7) == 0)
+ else if ((ARM_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING) && strncmp(*mangled, "__std__", 7) == 0)
{
/* it's a ARM global destructor to be executed at program exit */
(*mangled) += 7;
work->destructor = 2;
}
- else if (ARM_DEMANGLING && strncmp(*mangled, "__sti__", 7) == 0)
+ else if ((ARM_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING) && strncmp(*mangled, "__sti__", 7) == 0)
{
/* it's a ARM global constructor to be executed at program initial */
(*mangled) += 7;
@@ -1862,35 +2143,36 @@ demangle_prefix (work, mangled, declp)
i = strspn (scan, "_");
if (i > 2)
{
- scan += (i - 2);
+ scan += (i - 2);
}
}
-
+
if (scan == NULL)
{
success = 0;
}
else if (work -> static_type)
{
- if (!isdigit (scan[0]) && (scan[0] != 't'))
+ if (!isdigit ((unsigned char)scan[0]) && (scan[0] != 't'))
{
success = 0;
}
}
else if ((scan == *mangled)
- && (isdigit (scan[2]) || (scan[2] == 'Q') || (scan[2] == 't')
- || (scan[2] == 'K') || (scan[2] == 'H')))
+ && (isdigit ((unsigned char)scan[2]) || (scan[2] == 'Q')
+ || (scan[2] == 't') || (scan[2] == 'K') || (scan[2] == 'H')))
{
/* The ARM says nothing about the mangling of local variables.
But cfront mangles local variables by prepending __<nesting_level>
to them. As an extension to ARM demangling we handle this case. */
- if ((LUCID_DEMANGLING || ARM_DEMANGLING) && isdigit (scan[2]))
+ if ((LUCID_DEMANGLING || ARM_DEMANGLING || HP_DEMANGLING)
+ && isdigit ((unsigned char)scan[2]))
{
*mangled = scan + 2;
consume_count (mangled);
string_append (declp, *mangled);
*mangled += strlen (*mangled);
- success = 1;
+ success = 1;
}
else
{
@@ -1898,17 +2180,36 @@ demangle_prefix (work, mangled, declp)
names like __Q2_3foo3bar for nested type names. So don't accept
this style of constructor for cfront demangling. A GNU
style member-template constructor starts with 'H'. */
- if (!(LUCID_DEMANGLING || ARM_DEMANGLING))
+ if (!(LUCID_DEMANGLING || ARM_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING))
work -> constructor += 1;
*mangled = scan + 2;
}
}
- else if ((scan == *mangled) && !isdigit (scan[2]) && (scan[2] != 't'))
+ else if (ARM_DEMANGLING && scan[2] == 'p' && scan[3] == 't')
+ {
+ /* Cfront-style parameterized type. Handled later as a signature. */
+ success = 1;
+
+ /* ARM template? */
+ demangle_arm_hp_template (work, mangled, strlen (*mangled), declp);
+ }
+ else if (EDG_DEMANGLING && ((scan[2] == 't' && scan[3] == 'm')
+ || (scan[2] == 'p' && scan[3] == 's')
+ || (scan[2] == 'p' && scan[3] == 't')))
+ {
+ /* EDG-style parameterized type. Handled later as a signature. */
+ success = 1;
+
+ /* EDG template? */
+ demangle_arm_hp_template (work, mangled, strlen (*mangled), declp);
+ }
+ else if ((scan == *mangled) && !isdigit ((unsigned char)scan[2])
+ && (scan[2] != 't'))
{
/* Mangled name starts with "__". Skip over any leading '_' characters,
then find the next "__" that separates the prefix from the signature.
*/
- if (!(ARM_DEMANGLING || LUCID_DEMANGLING)
+ if (!(ARM_DEMANGLING || LUCID_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING)
|| (arm_special (mangled, declp) == 0))
{
while (*scan == '_')
@@ -1935,14 +2236,6 @@ demangle_prefix (work, mangled, declp)
}
}
}
- else if (ARM_DEMANGLING && scan[2] == 'p' && scan[3] == 't')
- {
- /* Cfront-style parameterized type. Handled later as a signature. */
- success = 1;
-
- /* ARM template? */
- demangle_arm_pt (work, mangled, strlen (*mangled), declp);
- }
else if (*(scan + 2) != '\0')
{
/* Mangled name does not start with "__" but does have one somewhere
@@ -1961,7 +2254,7 @@ demangle_prefix (work, mangled, declp)
string_append (declp, *mangled);
*mangled += strlen (*mangled);
success = 1;
- }
+ }
return (success);
}
@@ -2030,7 +2323,6 @@ gnu_special (work, mangled, declp)
(*mangled) += 4; /* Old style, no thunks: "_vt<CPLUS_MARKER>" */
while (**mangled != '\0')
{
- p = strpbrk (*mangled, cplus_markers);
switch (**mangled)
{
case 'Q':
@@ -2042,14 +2334,14 @@ gnu_special (work, mangled, declp)
1);
break;
default:
- if (isdigit(*mangled[0]))
+ if (isdigit((unsigned char)*mangled[0]))
{
n = consume_count(mangled);
/* We may be seeing a too-large size, or else a
".<digits>" indicating a static local symbol. In
any case, declare victory and move on; *don't* try
to use n to allocate. */
- if (n > strlen (*mangled))
+ if (n > (int) strlen (*mangled))
{
success = 1;
break;
@@ -2063,6 +2355,7 @@ gnu_special (work, mangled, declp)
(*mangled) += n;
}
+ p = strpbrk (*mangled, cplus_markers);
if (success && ((p == NULL) || (p == *mangled)))
{
if (p != NULL)
@@ -2164,6 +2457,35 @@ gnu_special (work, mangled, declp)
return (success);
}
+static void
+recursively_demangle(work, mangled, result, namelength)
+ struct work_stuff *work;
+ const char **mangled;
+ string *result;
+ int namelength;
+{
+ char * recurse = (char *)NULL;
+ char * recurse_dem = (char *)NULL;
+
+ recurse = (char *) xmalloc (namelength + 1);
+ memcpy (recurse, *mangled, namelength);
+ recurse[namelength] = '\000';
+
+ recurse_dem = cplus_demangle (recurse, work->options);
+
+ if (recurse_dem)
+ {
+ string_append (result, recurse_dem);
+ free (recurse_dem);
+ }
+ else
+ {
+ string_appendn (result, *mangled, namelength);
+ }
+ free (recurse);
+ *mangled += namelength;
+}
+
/*
LOCAL FUNCTION
@@ -2287,7 +2609,7 @@ demangle_qualified (work, mangled, result, isfuncname, append)
/* We only make use of ISFUNCNAME if the entity is a constructor or
destructor. */
- isfuncname = (isfuncname
+ isfuncname = (isfuncname
&& ((work->constructor & 1) || (work->destructor & 1)));
string_init (&temp);
@@ -2299,7 +2621,7 @@ demangle_qualified (work, mangled, result, isfuncname, append)
int idx;
(*mangled)++;
idx = consume_count_with_underscores (mangled);
- if (idx == -1 || idx > work -> numk)
+ if (idx == -1 || idx >= work -> numk)
success = 0;
else
string_append (&temp, work -> ktypevec[idx]);
@@ -2313,11 +2635,11 @@ demangle_qualified (work, mangled, result, isfuncname, append)
by an underscore. */
p = *mangled + 2;
qualifiers = atoi (p);
- if (!isdigit (*p) || *p == '0')
+ if (!isdigit ((unsigned char)*p) || *p == '0')
success = 0;
/* Skip the digits. */
- while (isdigit (*p))
+ while (isdigit ((unsigned char)*p))
++p;
if (*p != '_')
@@ -2366,7 +2688,7 @@ demangle_qualified (work, mangled, result, isfuncname, append)
int remember_K = 1;
string_clear (&last_name);
- if (*mangled[0] == '_')
+ if (*mangled[0] == '_')
(*mangled)++;
if (*mangled[0] == 't')
@@ -2377,17 +2699,17 @@ demangle_qualified (work, mangled, result, isfuncname, append)
(parameter-less) value is returned by demangle_template
in LAST_NAME. We do not remember the template type here,
in order to match the G++ mangling algorithm. */
- success = demangle_template(work, mangled, &temp,
+ success = demangle_template(work, mangled, &temp,
&last_name, 1, 0);
- if (!success)
+ if (!success)
break;
- }
+ }
else if (*mangled[0] == 'K')
{
int idx;
(*mangled)++;
idx = consume_count_with_underscores (mangled);
- if (idx == -1 || idx > work->numk)
+ if (idx == -1 || idx >= work->numk)
success = 0;
else
string_append (&temp, work->ktypevec[idx]);
@@ -2397,10 +2719,22 @@ demangle_qualified (work, mangled, result, isfuncname, append)
}
else
{
- success = do_type (work, mangled, &last_name);
- if (!success)
- break;
- string_appends (&temp, &last_name);
+ if (EDG_DEMANGLING)
+ {
+ int namelength;
+ /* Now recursively demangle the qualifier
+ * This is necessary to deal with templates in
+ * mangling styles like EDG */
+ namelength = consume_count (mangled);
+ recursively_demangle(work, mangled, &temp, namelength);
+ }
+ else
+ {
+ success = do_type (work, mangled, &last_name);
+ if (!success)
+ break;
+ string_appends (&temp, &last_name);
+ }
}
if (remember_K)
@@ -2417,7 +2751,7 @@ demangle_qualified (work, mangled, result, isfuncname, append)
We do this here because this is the most convenient place, where
we already have a pointer to the name and the length of the name. */
- if (isfuncname)
+ if (isfuncname)
{
string_append (&temp, SCOPE_STRING (work));
if (work -> destructor & 1)
@@ -2425,7 +2759,7 @@ demangle_qualified (work, mangled, result, isfuncname, append)
string_appends (&temp, &last_name);
}
- /* Now either prepend the temp buffer to the result, or append it,
+ /* Now either prepend the temp buffer to the result, or append it,
depending upon the state of the append flag. */
if (append)
@@ -2466,7 +2800,7 @@ get_count (type, count)
const char *p;
int n;
- if (!isdigit (**type))
+ if (!isdigit ((unsigned char)**type))
{
return (0);
}
@@ -2474,17 +2808,17 @@ get_count (type, count)
{
*count = **type - '0';
(*type)++;
- if (isdigit (**type))
+ if (isdigit ((unsigned char)**type))
{
p = *type;
n = *count;
- do
+ do
{
n *= 10;
n += *p - '0';
p++;
- }
- while (isdigit (*p));
+ }
+ while (isdigit ((unsigned char)*p));
if (*p == '_')
{
*type = p + 1;
@@ -2495,7 +2829,8 @@ get_count (type, count)
return (1);
}
-/* result will be initialised here; it will be freed on failure */
+/* RESULT will be initialised here; it will be freed on failure. The
+ value returned is really a type_kind_t. */
static int
do_type (work, mangled, result)
@@ -2508,9 +2843,9 @@ do_type (work, mangled, result)
int success;
string decl;
const char *remembered_type;
- int constp;
- int volatilep;
+ int type_quals;
string btype;
+ type_kind_t tk = tk_none;
string_init (&btype);
string_init (&decl);
@@ -2529,33 +2864,35 @@ do_type (work, mangled, result)
case 'p':
(*mangled)++;
string_prepend (&decl, "*");
+ if (tk == tk_none)
+ tk = tk_pointer;
break;
/* A reference type */
case 'R':
(*mangled)++;
string_prepend (&decl, "&");
+ if (tk == tk_none)
+ tk = tk_reference;
break;
/* An array */
case 'A':
{
- const char *p = ++(*mangled);
-
- string_prepend (&decl, "(");
- string_append (&decl, ")[");
- /* Copy anything up until the next underscore (the size of the
- array). */
- while (**mangled && **mangled != '_')
- ++(*mangled);
- if (**mangled == '_')
+ ++(*mangled);
+ if (!STRING_EMPTY (&decl)
+ && (decl.b[0] == '*' || decl.b[0] == '&'))
{
- string_appendn (&decl, p, *mangled - p);
- string_append (&decl, "]");
- *mangled += 1;
+ string_prepend (&decl, "(");
+ string_append (&decl, ")");
}
- else
- success = 0;
+ string_append (&decl, "[");
+ if (**mangled != '_')
+ success = demangle_template_value_parm (work, mangled, &decl,
+ tk_integral);
+ if (**mangled == '_')
+ ++(*mangled);
+ string_append (&decl, "]");
break;
}
@@ -2576,7 +2913,8 @@ do_type (work, mangled, result)
/* A function */
case 'F':
(*mangled)++;
- if (!STRING_EMPTY (&decl) && decl.b[0] == '*')
+ if (!STRING_EMPTY (&decl)
+ && (decl.b[0] == '*' || decl.b[0] == '&'))
{
string_prepend (&decl, "(");
string_append (&decl, ")");
@@ -2597,12 +2935,11 @@ do_type (work, mangled, result)
case 'M':
case 'O':
{
- constp = 0;
- volatilep = 0;
+ type_quals = TYPE_UNQUALIFIED;
member = **mangled == 'M';
(*mangled)++;
- if (!isdigit (**mangled) && **mangled != 't')
+ if (!isdigit ((unsigned char)**mangled) && **mangled != 't')
{
success = 0;
break;
@@ -2610,10 +2947,10 @@ do_type (work, mangled, result)
string_append (&decl, ")");
string_prepend (&decl, SCOPE_STRING (work));
- if (isdigit (**mangled))
+ if (isdigit ((unsigned char)**mangled))
{
n = consume_count (mangled);
- if (strlen (*mangled) < n)
+ if ((int) strlen (*mangled) < n)
{
success = 0;
break;
@@ -2638,16 +2975,19 @@ do_type (work, mangled, result)
string_prepend (&decl, "(");
if (member)
{
- if (**mangled == 'C')
- {
- (*mangled)++;
- constp = 1;
- }
- if (**mangled == 'V')
+ switch (**mangled)
{
+ case 'C':
+ case 'V':
+ case 'u':
+ type_quals |= code_for_qualifier (**mangled);
(*mangled)++;
- volatilep = 1;
+ break;
+
+ default:
+ break;
}
+
if (*(*mangled)++ != 'F')
{
success = 0;
@@ -2665,15 +3005,10 @@ do_type (work, mangled, result)
{
break;
}
- if (constp)
- {
- APPEND_BLANK (&decl);
- string_append (&decl, "const");
- }
- if (volatilep)
+ if (type_quals != TYPE_UNQUALIFIED)
{
APPEND_BLANK (&decl);
- string_append (&decl, "volatile");
+ string_append (&decl, qualifier_string (type_quals));
}
break;
}
@@ -2683,18 +3018,13 @@ do_type (work, mangled, result)
case 'C':
case 'V':
- /*
- if ((*mangled)[1] == 'P')
- {
- */
+ case 'u':
if (PRINT_ANSI_QUALIFIERS)
{
if (!STRING_EMPTY (&decl))
- {
- string_prepend (&decl, " ");
- }
- string_prepend (&decl,
- (**mangled) == 'C' ? "const" : "volatile");
+ string_prepend (&decl, " ");
+
+ string_prepend (&decl, demangle_qualifier (**mangled));
}
(*mangled)++;
break;
@@ -2709,7 +3039,7 @@ do_type (work, mangled, result)
}
}
- switch (**mangled)
+ if (success) switch (**mangled)
{
/* A qualified name, such as "Outer::Inner". */
case 'Q':
@@ -2723,11 +3053,9 @@ do_type (work, mangled, result)
case 'B':
(*mangled)++;
if (!get_count (mangled, &n) || n >= work -> numb)
- success = 0;
+ success = 0;
else
- {
- string_append (result, work->btypevec[n]);
- }
+ string_append (result, work->btypevec[n]);
break;
case 'X':
@@ -2739,7 +3067,7 @@ do_type (work, mangled, result)
(*mangled)++;
idx = consume_count_with_underscores (mangled);
- if (idx == -1
+ if (idx == -1
|| (work->tmpl_argvec && idx >= work->ntmpl_args)
|| consume_count_with_underscores (mangled) == -1)
{
@@ -2762,6 +3090,8 @@ do_type (work, mangled, result)
default:
success = demangle_fund_type (work, mangled, result);
+ if (tk == tk_none)
+ tk = (type_kind_t) success;
break;
}
@@ -2774,11 +3104,14 @@ do_type (work, mangled, result)
}
}
else
- {
- string_delete (result);
- }
+ string_delete (result);
string_delete (&decl);
- return (success);
+
+ if (success)
+ /* Assume an integral type, if we're not sure. */
+ return (int) ((tk == tk_none) ? tk_integral : tk);
+ else
+ return 0;
}
/* Given a pointer to a type string that represents a fundamental type
@@ -2792,7 +3125,7 @@ do_type (work, mangled, result)
"Sl" => "signed long"
"CUs" => "const unsigned short"
- */
+ The value returned is really a type_kind_t. */
static int
demangle_fund_type (work, mangled, result)
@@ -2802,7 +3135,11 @@ demangle_fund_type (work, mangled, result)
{
int done = 0;
int success = 1;
+ char buf[10];
+ int dec = 0;
string btype;
+ type_kind_t tk = tk_integral;
+
string_init (&btype);
/* First pick off any type qualifiers. There can be more than one. */
@@ -2812,12 +3149,15 @@ demangle_fund_type (work, mangled, result)
switch (**mangled)
{
case 'C':
- (*mangled)++;
+ case 'V':
+ case 'u':
if (PRINT_ANSI_QUALIFIERS)
{
- APPEND_BLANK (result);
- string_append (result, "const");
+ if (!STRING_EMPTY (result))
+ string_prepend (result, " ");
+ string_prepend (result, demangle_qualifier (**mangled));
}
+ (*mangled)++;
break;
case 'U':
(*mangled)++;
@@ -2829,14 +3169,6 @@ demangle_fund_type (work, mangled, result)
APPEND_BLANK (result);
string_append (result, "signed");
break;
- case 'V':
- (*mangled)++;
- if (PRINT_ANSI_QUALIFIERS)
- {
- APPEND_BLANK (result);
- string_append (result, "volatile");
- }
- break;
case 'J':
(*mangled)++;
APPEND_BLANK (result);
@@ -2884,39 +3216,67 @@ demangle_fund_type (work, mangled, result)
(*mangled)++;
APPEND_BLANK (result);
string_append (result, "bool");
+ tk = tk_bool;
break;
case 'c':
(*mangled)++;
APPEND_BLANK (result);
string_append (result, "char");
+ tk = tk_char;
break;
case 'w':
(*mangled)++;
APPEND_BLANK (result);
string_append (result, "wchar_t");
+ tk = tk_char;
break;
case 'r':
(*mangled)++;
APPEND_BLANK (result);
string_append (result, "long double");
+ tk = tk_real;
break;
case 'd':
(*mangled)++;
APPEND_BLANK (result);
string_append (result, "double");
+ tk = tk_real;
break;
case 'f':
(*mangled)++;
APPEND_BLANK (result);
string_append (result, "float");
+ tk = tk_real;
break;
case 'G':
(*mangled)++;
- if (!isdigit (**mangled))
+ if (!isdigit ((unsigned char)**mangled))
{
success = 0;
break;
}
+ case 'I':
+ ++(*mangled);
+ if (**mangled == '_')
+ {
+ int i;
+ ++(*mangled);
+ for (i = 0; **mangled != '_'; ++(*mangled), ++i)
+ buf[i] = **mangled;
+ buf[i] = '\0';
+ ++(*mangled);
+ }
+ else
+ {
+ strncpy (buf, *mangled, 2);
+ *mangled += 2;
+ }
+ sscanf (buf, "%x", &dec);
+ sprintf (buf, "int%i_t", dec);
+ APPEND_BLANK (result);
+ string_append (result, buf);
+ break;
+
/* fall through */
/* An explicit type, such as "6mytype" or "7integer" */
case '0':
@@ -2938,7 +3298,7 @@ demangle_fund_type (work, mangled, result)
APPEND_BLANK (result);
string_appends (result, &btype);
}
- else
+ else
success = 0;
string_delete (&btype);
break;
@@ -2954,7 +3314,141 @@ demangle_fund_type (work, mangled, result)
break;
}
- return (success);
+ return success ? ((int) tk) : 0;
+}
+
+
+/* Handle a template's value parameter for HP aCC (extension from ARM)
+ **mangled points to 'S' or 'U' */
+
+static int
+do_hpacc_template_const_value (work, mangled, result)
+ struct work_stuff *work;
+ const char **mangled;
+ string *result;
+{
+ int unsigned_const;
+
+ if (**mangled != 'U' && **mangled != 'S')
+ return 0;
+
+ unsigned_const = (**mangled == 'U');
+
+ (*mangled)++;
+
+ switch (**mangled)
+ {
+ case 'N':
+ string_append (result, "-");
+ /* fall through */
+ case 'P':
+ (*mangled)++;
+ break;
+ case 'M':
+ /* special case for -2^31 */
+ string_append (result, "-2147483648");
+ (*mangled)++;
+ return 1;
+ default:
+ return 0;
+ }
+
+ /* We have to be looking at an integer now */
+ if (!(isdigit ((unsigned char)**mangled)))
+ return 0;
+
+ /* We only deal with integral values for template
+ parameters -- so it's OK to look only for digits */
+ while (isdigit ((unsigned char)**mangled))
+ {
+ char_str[0] = **mangled;
+ string_append (result, char_str);
+ (*mangled)++;
+ }
+
+ if (unsigned_const)
+ string_append (result, "U");
+
+ /* FIXME? Some day we may have 64-bit (or larger :-) ) constants
+ with L or LL suffixes. pai/1997-09-03 */
+
+ return 1; /* success */
+}
+
+/* Handle a template's literal parameter for HP aCC (extension from ARM)
+ **mangled is pointing to the 'A' */
+
+static int
+do_hpacc_template_literal (work, mangled, result)
+ struct work_stuff *work;
+ const char **mangled;
+ string *result;
+{
+ int literal_len = 0;
+ char * recurse;
+ char * recurse_dem;
+
+ if (**mangled != 'A')
+ return 0;
+
+ (*mangled)++;
+
+ literal_len = consume_count (mangled);
+
+ if (!literal_len)
+ return 0;
+
+ /* Literal parameters are names of arrays, functions, etc. and the
+ canonical representation uses the address operator */
+ string_append (result, "&");
+
+ /* Now recursively demangle the literal name */
+ recurse = (char *) xmalloc (literal_len + 1);
+ memcpy (recurse, *mangled, literal_len);
+ recurse[literal_len] = '\000';
+
+ recurse_dem = cplus_demangle (recurse, work->options);
+
+ if (recurse_dem)
+ {
+ string_append (result, recurse_dem);
+ free (recurse_dem);
+ }
+ else
+ {
+ string_appendn (result, *mangled, literal_len);
+ }
+ (*mangled) += literal_len;
+ free (recurse);
+
+ return 1;
+}
+
+static int
+snarf_numeric_literal (args, arg)
+ const char ** args;
+ string * arg;
+{
+ if (**args == '-')
+ {
+ char_str[0] = '-';
+ string_append (arg, char_str);
+ (*args)++;
+ }
+ else if (**args == '+')
+ (*args)++;
+
+ if (!isdigit ((unsigned char)**args))
+ return 0;
+
+ while (isdigit ((unsigned char)**args))
+ {
+ char_str[0] = **args;
+ string_append (arg, char_str);
+ (*args)++;
+ }
+
+ return 1;
}
/* Demangle the next argument, given by MANGLED into RESULT, which
@@ -2980,7 +3474,7 @@ do_arg (work, mangled, result)
if (work->previous_argument == 0)
return 0;
- /* We want to reissue the previous type in this argument list. */
+ /* We want to reissue the previous type in this argument list. */
string_appends (result, work->previous_argument);
return 1;
}
@@ -3004,7 +3498,7 @@ do_arg (work, mangled, result)
else
(*mangled)++;
}
-
+
/* Now, the repeat is all set up. */
return do_arg (work, mangled, result);
}
@@ -3096,7 +3590,7 @@ remember_Ktype (work, start, len)
}
/* Register a B code, and get an index for it. B codes are registered
- as they are seen, rather than as they are completed, so map<temp<char> >
+ as they are seen, rather than as they are completed, so map<temp<char> >
registers map<temp<char> > as B0, and temp<char> as B1 */
static int
@@ -3104,7 +3598,7 @@ register_Btype (work)
struct work_stuff *work;
{
int ret;
-
+
if (work -> numb >= work -> bsize)
{
if (work -> bsize == 0)
@@ -3258,7 +3752,7 @@ demangle_args (work, mangled, declp)
if ((**mangled == 'N') || (**mangled == 'T'))
{
temptype = *(*mangled)++;
-
+
if (temptype == 'N')
{
if (!get_count (mangled, &r))
@@ -3270,7 +3764,7 @@ demangle_args (work, mangled, declp)
{
r = 1;
}
- if (ARM_DEMANGLING && work -> ntypes >= 10)
+ if ((HP_DEMANGLING || ARM_DEMANGLING || EDG_DEMANGLING) && work -> ntypes >= 10)
{
/* If we have 10 or more types we might have more than a 1 digit
index so we'll have to consume the whole count here. This
@@ -3290,7 +3784,7 @@ demangle_args (work, mangled, declp)
return (0);
}
}
- if (LUCID_DEMANGLING || ARM_DEMANGLING)
+ if (LUCID_DEMANGLING || ARM_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING)
{
t--;
}
@@ -3380,7 +3874,7 @@ demangle_nested_args (work, mangled, declp)
/* Actually demangle the arguments. */
result = demangle_args (work, mangled, declp);
-
+
/* Restore the previous_argument field. */
if (work->previous_argument)
string_delete (work->previous_argument);
@@ -3410,8 +3904,18 @@ demangle_function_name (work, mangled, declp, scan)
separator. */
(*mangled) = scan + 2;
+ /* We may be looking at an instantiation of a template function:
+ foo__Xt1t2_Ft3t4, where t1, t2, ... are template arguments and a
+ following _F marks the start of the function arguments. Handle
+ the template arguments first. */
- if (LUCID_DEMANGLING || ARM_DEMANGLING)
+ if (HP_DEMANGLING && (**mangled == 'X'))
+ {
+ demangle_arm_hp_template (work, mangled, 0, declp);
+ /* This leaves MANGLED pointing to the 'F' marking func args */
+ }
+
+ if (LUCID_DEMANGLING || ARM_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING)
{
/* See if we have an ARM style constructor or destructor operator.
@@ -3433,7 +3937,7 @@ demangle_function_name (work, mangled, declp, scan)
}
}
- if (declp->p - declp->b >= 3
+ if (declp->p - declp->b >= 3
&& declp->b[0] == 'o'
&& declp->b[1] == 'p'
&& strchr (cplus_markers, declp->b[2]) != NULL)
@@ -3445,7 +3949,7 @@ demangle_function_name (work, mangled, declp, scan)
for (i = 0; i < sizeof (optable) / sizeof (optable[0]); i++)
{
int len = declp->p - declp->b - 10;
- if (strlen (optable[i].in) == len
+ if ((int) strlen (optable[i].in) == len
&& memcmp (optable[i].in, declp->b + 10, len) == 0)
{
string_clear (declp);
@@ -3461,7 +3965,7 @@ demangle_function_name (work, mangled, declp, scan)
for (i = 0; i < sizeof (optable) / sizeof (optable[0]); i++)
{
int len = declp->p - declp->b - 3;
- if (strlen (optable[i].in) == len
+ if ((int) strlen (optable[i].in) == len
&& memcmp (optable[i].in, declp->b + 3, len) == 0)
{
string_clear (declp);
@@ -3532,7 +4036,7 @@ demangle_function_name (work, mangled, declp, scan)
string_append (declp, "operator");
string_append (declp, optable[i].out);
break;
- }
+ }
}
}
}
@@ -3586,7 +4090,7 @@ string_init (s)
s->b = s->p = s->e = NULL;
}
-static void
+static void
string_clear (s)
string *s;
{
@@ -3727,10 +4231,10 @@ static void
usage (stream, status)
FILE *stream;
int status;
-{
+{
fprintf (stream, "\
-Usage: %s [-_] [-n] [-s {gnu,lucid,arm}] [--strip-underscores]\n\
- [--no-strip-underscores] [--format={gnu,lucid,arm}]\n\
+Usage: %s [-_] [-n] [-s {gnu,lucid,arm,hp,edg}] [--strip-underscores]\n\
+ [--no-strip-underscores] [--format={gnu,lucid,arm,hp,edg}]\n\
[--help] [--version] [arg...]\n",
program_name);
exit (status);
@@ -3787,7 +4291,7 @@ main (argc, argv)
strip_underscore = 0;
break;
case 'v':
- printf ("GNU %s version %s\n", program_name, program_version);
+ printf ("GNU %s (C++ demangler), version %s\n", program_name, program_version);
exit (0);
case '_':
strip_underscore = 1;
@@ -3805,6 +4309,14 @@ main (argc, argv)
{
current_demangling_style = arm_demangling;
}
+ else if (strcmp (optarg, "hp") == 0)
+ {
+ current_demangling_style = hp_demangling;
+ }
+ else if (strcmp (optarg, "edg") == 0)
+ {
+ current_demangling_style = edg_demangling;
+ }
else
{
fprintf (stderr, "%s: unknown demangling style `%s'\n",
@@ -3829,7 +4341,11 @@ main (argc, argv)
int i = 0;
c = getchar ();
/* Try to read a label. */
- while (c != EOF && (isalnum(c) || c == '_' || c == '$' || c == '.'))
+ while (c != EOF && (isalnum(c) || c == '_' || c == '$' || c == '.' ||
+ c == '<' || c == '>' || c == '#' || c == ',' || c == '*' || c == '&' ||
+ c == '[' || c == ']' || c == ':' || c == '(' || c == ')'))
+ /* the ones in the 2nd & 3rd lines were added to handle
+ HP aCC template specialization manglings */
{
if (i >= MBUF_SIZE-1)
break;
@@ -3849,7 +4365,7 @@ main (argc, argv)
skip_first = i;
mbuffer[i] = 0;
-
+
result = cplus_demangle (mbuffer + skip_first, flags);
if (result)
{
@@ -3880,25 +4396,22 @@ fatal (str)
exit (1);
}
-char * malloc ();
-char * realloc ();
-
-char *
+PTR
xmalloc (size)
- unsigned size;
+ size_t size;
{
- register char *value = (char *) malloc (size);
+ register PTR value = (PTR) malloc (size);
if (value == 0)
fatal ("virtual memory exhausted");
return value;
}
-char *
+PTR
xrealloc (ptr, size)
- char *ptr;
- unsigned size;
+ PTR ptr;
+ size_t size;
{
- register char *value = (char *) realloc (ptr, size);
+ register PTR value = (PTR) realloc (ptr, size);
if (value == 0)
fatal ("virtual memory exhausted");
return value;