/* Demangler for GNU C++
- Copyright 1989, 1991, 1994, 1995, 1996, 1997 Free Software Foundation, Inc.
+ Copyright 1989, 1991, 1994, 1995, 1996, 1997, 1998 Free Software Foundation, Inc.
Written by James Clark (jjc@jclark.uucp)
Rewritten by Fred Fish (fnf@cygnus.com) for ARM and Lucid demangling
cplus_markers[0] = ch;
}
+typedef struct string /* Beware: these aren't required to be */
+{ /* '\0' terminated. */
+ char *b; /* pointer to start of string */
+ char *p; /* pointer after last character */
+ char *e; /* pointer after end of allocated space */
+} string;
+
/* Stuff that is shared between sub-routines.
Using a shared structure allows cplus_demangle to be reentrant. */
int destructor;
int static_type; /* A static member function */
int const_type; /* A const member function */
+ int volatile_type; /* A volatile member function */
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
+ we see. */
+ string* previous_argument; /* The last function argument demangled. */
+ int nrepeats; /* The number of times to repeat the previous
+ argument. */
};
#define PRINT_ANSI_QUALIFIERS (work -> options & DMGL_ANSI)
};
-typedef struct string /* Beware: these aren't required to be */
-{ /* '\0' terminated. */
- char *b; /* pointer to start of string */
- char *p; /* pointer after last character */
- char *e; /* pointer after end of allocated space */
-} string;
-
#define STRING_EMPTY(str) ((str) -> b == (str) -> p)
#define PREPEND_BLANK(str) {if (!STRING_EMPTY(str)) \
string_prepend(str, " ");}
string_append(str, " ");}
#define LEN_STRING(str) ( (STRING_EMPTY(str))?0:((str)->p - (str)->b))
+/* The scope separator appropriate for the language being demangled. */
+#define SCOPE_STRING(work) "::"
+
#define ARM_VTABLE_STRING "__vtbl__" /* Lucid/ARM virtual table prefix */
#define ARM_VTABLE_STRLEN 8 /* strlen (ARM_VTABLE_STRING) */
static int
demangle_template PARAMS ((struct work_stuff *work, const char **, string *,
- string *, int));
+ string *, int, int));
static int
arm_pt PARAMS ((struct work_stuff *, const char *, int, const char **,
static int
demangle_args PARAMS ((struct work_stuff *, const char **, string *));
+static int
+demangle_nested_args PARAMS ((struct work_stuff*, const char**, string*));
+
static int
do_type PARAMS ((struct work_stuff *, const char **, string *));
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;
work->constructor = work->destructor = 0;
work->static_type = work->const_type = 0;
+ work->volatile_type = 0;
if ((mangled != NULL) && (*mangled != '\0'))
{
work->destructor = s2;
work->static_type = s3;
work->const_type = s4;
+ work->volatile_type = saved_volatile_type;
return (demangled);
}
free ((char*) work->tmpl_argvec);
work->tmpl_argvec = NULL;
}
+ if (work->previous_argument)
+ {
+ string_delete (work->previous_argument);
+ free ((char*) work->previous_argument);
+ }
/* If demangling was successful, ensure that the demangled string is null
terminated and return it. Otherwise, free the demangling decl. */
oldmangled = *mangled;
success = demangle_qualified (work, mangled, declp, 1, 0);
if (success)
- {
- remember_type (work, oldmangled, *mangled - oldmangled);
- }
+ remember_type (work, oldmangled, *mangled - oldmangled);
if (AUTO_DEMANGLING || GNU_DEMANGLING)
- {
- expect_func = 1;
- }
+ expect_func = 1;
oldmangled = NULL;
break;
break;
case 'C':
- /* a const member function */
+ case 'V':
+ if (**mangled == 'C')
+ work -> const_type = 1;
+ else
+ work->volatile_type = 1;
+
+ /* a qualified member function */
if (oldmangled == NULL)
- {
- oldmangled = *mangled;
- }
+ oldmangled = *mangled;
(*mangled)++;
- work -> const_type = 1;
break;
case '0': case '1': case '2': case '3': case '4':
}
oldmangled = NULL;
break;
-
+
+ case 'B':
+ {
+ string s;
+ success = do_type (work, mangled, &s);
+ if (success)
+ {
+ string_append (&s, SCOPE_STRING (work));
+ string_prepends (declp, &s);
+ }
+ oldmangled = NULL;
+ expect_func = 1;
+ }
+ break;
+
case 'F':
/* Function */
/* ARM style demangling includes a specific 'F' character after
{
oldmangled = *mangled;
}
- success = demangle_template (work, mangled, &tname, &trawname, 1);
+ success = demangle_template (work, mangled, &tname,
+ &trawname, 1, 1);
if (success)
{
remember_type (work, oldmangled, *mangled - oldmangled);
}
- string_append (&tname, "::");
-
+ string_append(&tname, SCOPE_STRING (work));
string_prepends(declp, &tname);
if (work -> destructor & 1)
{
if (GNU_DEMANGLING)
{
/* A G++ template function. Read the template arguments. */
- success = demangle_template (work, mangled, declp, 0, 0);
+ success = demangle_template (work, mangled, declp, 0, 0,
+ 0);
if (!(work->constructor & 1))
expect_return_type = 1;
(*mangled)++;
}
}
if (success && work -> static_type && PRINT_ARG_TYPES)
- {
- string_append (declp, " static");
- }
+ string_append (declp, " static");
if (success && work -> const_type && PRINT_ARG_TYPES)
- {
- string_append (declp, " const");
- }
+ string_append (declp, " const");
+ else if (success && work->volatile_type && PRINT_ARG_TYPES)
+ string_append (declp, " volatile");
+
return (success);
}
continue;
case 'E': /* expression */
case 'Q': /* qualified name */
- case 'K': /* qualified name */
- done = is_integral = 1;
- break;
- case 'B': /* squangled name */
+ case 'K': /* qualified name */
done = is_integral = 1;
break;
+ case 'B': /* remembered type */
case 'T': /* remembered type */
abort ();
break;
return success;
}
+/* Demangle the template name in MANGLED. The full name of the
+ template (e.g., S<int>) is placed in TNAME. The name without the
+ template parameters (e.g. S) is placed in TRAWNAME if TRAWNAME is
+ non-NULL. If IS_TYPE is nonzero, this template is a type template,
+ not a function template. If both IS_TYPE and REMEMBER are nonzero,
+ the tmeplate is remembered in the list of back-referenceable
+ types. */
+
static int
-demangle_template (work, mangled, tname, trawname, is_type)
+demangle_template (work, mangled, tname, trawname, is_type, remember)
struct work_stuff *work;
const char **mangled;
string *tname;
string *trawname;
int is_type;
+ int remember;
{
int i;
int r;
int success = 0;
const char *start;
string temp;
+ int bindex;
(*mangled)++;
if (is_type)
{
+ if (remember)
+ bindex = register_Btype (work);
start = *mangled;
/* get template name */
if (**mangled == 'z')
if (idx == -1
|| (work->tmpl_argvec && idx >= work->ntmpl_args)
|| consume_count_with_underscores (mangled) == -1)
- {
- return (0);
- }
+ return (0);
+
if (work->tmpl_argvec)
{
string_append (tname, work->tmpl_argvec[idx]);
sprintf(buf, "T%d", idx);
string_append (tname, buf);
if (trawname)
- string_append (trawname, work->tmpl_argvec[idx]);
+ string_append (trawname, buf);
}
}
else
{
return (0);
}
+ string_appendn (tname, *mangled, r);
if (trawname)
string_appendn (trawname, *mangled, r);
- string_appendn (tname, *mangled, r);
*mangled += r;
}
}
- string_append (tname, "<");
+ string_append (tname, "<");
/* get size of template parameter list */
if (!get_count (mangled, &r))
{
}
need_comma = 1;
}
- {
- if (tname->p[-1] == '>')
- string_append (tname, " ");
- string_append (tname, ">");
- }
+ if (tname->p[-1] == '>')
+ string_append (tname, " ");
+ string_append (tname, ">");
+ if (is_type && remember)
+ remember_Btype (work, tname->b, LEN_STRING (tname), bindex);
+
/*
if (work -> static_type)
{
}
remember_Ktype (work, class_name.b, LEN_STRING(&class_name));
remember_Btype (work, class_name.b, LEN_STRING(&class_name), btype);
- string_prepend (declp, "::");
+ string_prepend (declp, SCOPE_STRING (work));
string_prepends (declp, &class_name);
success = 1;
}
success = demangle_qualified (work, mangled, declp, 0, 1);
break;
case 't':
- success = demangle_template (work, mangled, declp, 0, 1);
+ success = demangle_template (work, mangled, declp, 0, 1,
+ 1);
break;
default:
if (isdigit(*mangled[0]))
{
if (p != NULL)
{
- string_append (declp, "::");
+ string_append (declp, SCOPE_STRING (work));
(*mangled)++;
}
}
success = demangle_qualified (work, mangled, declp, 0, 1);
break;
case 't':
- success = demangle_template (work, mangled, declp, 0, 1);
+ success = demangle_template (work, mangled, declp, 0, 1, 1);
break;
default:
n = consume_count (mangled);
/* Consumed everything up to the cplus_marker, append the
variable name. */
(*mangled)++;
- string_append (declp, "::");
+ string_append (declp, SCOPE_STRING (work));
n = strlen (*mangled);
string_appendn (declp, *mangled, n);
(*mangled) += n;
success = demangle_qualified (work, mangled, declp, 0, 1);
break;
case 't':
- success = demangle_template (work, mangled, declp, 0, 1);
+ success = demangle_template (work, mangled, declp, 0, 1, 1);
break;
default:
success = demangle_fund_type (work, mangled, declp);
int append;
{
int qualifiers = 0;
- int namelength;
int success = 1;
const char *p;
char num[2];
string temp;
+ string last_name;
+ int bindex = register_Btype (work);
+
+ /* We only make use of ISFUNCNAME if the entity is a constructor or
+ destructor. */
+ isfuncname = (isfuncname
+ && ((work->constructor & 1) || (work->destructor & 1)));
string_init (&temp);
+ string_init (&last_name);
if ((*mangled)[0] == 'K')
{
while (qualifiers-- > 0)
{
int remember_K = 1;
+ string_clear (&last_name);
+
if (*mangled[0] == '_')
- *mangled = *mangled + 1;
+ (*mangled)++;
+
if (*mangled[0] == 't')
{
- success = demangle_template(work, mangled, &temp, 0, 1);
- if (!success) break;
- }
- else if (*mangled[0] == 'X')
- {
- success = do_type (work, mangled, &temp);
- if (!success) break;
- }
+ /* Here we always append to TEMP since we will want to use
+ the template name without the template parameters as a
+ constructor or destructor name. The appropriate
+ (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,
+ &last_name, 1, 0);
+ if (!success)
+ break;
+ }
else if (*mangled[0] == 'K')
{
int idx;
if (!success) break;
}
else
- {
- namelength = consume_count (mangled);
- if (strlen (*mangled) < namelength)
- {
- /* Simple sanity check failed */
- success = 0;
- break;
- }
- string_appendn (&temp, *mangled, namelength);
- *mangled += namelength;
+ {
+ success = do_type (work, mangled, &last_name);
+ if (!success)
+ break;
+ string_appends (&temp, &last_name);
}
if (remember_K)
- {
- remember_Ktype (work, temp.b, LEN_STRING (&temp));
- }
+ remember_Ktype (work, temp.b, LEN_STRING (&temp));
if (qualifiers > 0)
- {
- string_append (&temp, "::");
- }
+ string_append (&temp, SCOPE_STRING (work));
}
+ remember_Btype (work, temp.b, LEN_STRING (&temp), bindex);
+
/* If we are using the result as a function name, we need to append
the appropriate '::' separated constructor or destructor name.
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 && (work->constructor & 1 || work->destructor & 1))
+ if (isfuncname)
{
- string_append (&temp, "::");
+ string_append (&temp, SCOPE_STRING (work));
if (work -> destructor & 1)
- {
- string_append (&temp, "~");
- }
- string_appendn (&temp, (*mangled) - namelength, namelength);
+ string_append (&temp, "~");
+ string_appends (&temp, &last_name);
}
/* Now either prepend the temp buffer to the result, or append it,
depending upon the state of the append flag. */
if (append)
- {
- string_appends (result, &temp);
- }
+ string_appends (result, &temp);
else
{
if (!STRING_EMPTY (result))
- {
- string_append (&temp, "::");
- }
+ string_append (&temp, SCOPE_STRING (work));
string_prepends (result, &temp);
}
+ string_delete (&last_name);
string_delete (&temp);
return (success);
}
case 'P':
case 'p':
(*mangled)++;
- string_prepend (&decl, "*");
+ string_prepend (&decl, "*");
break;
/* A reference type */
/* 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 (!demangle_args (work, mangled, &decl)
+ if (!demangle_nested_args (work, mangled, &decl)
|| (**mangled != '_' && **mangled != '\0'))
{
success = 0;
+ break;
}
if (success && (**mangled == '_'))
- {
- (*mangled)++;
- }
+ (*mangled)++;
break;
case 'M':
}
string_append (&decl, ")");
- string_prepend (&decl, "::");
+ string_prepend (&decl, SCOPE_STRING (work));
if (isdigit (**mangled))
{
n = consume_count (mangled);
{
string temp;
string_init (&temp);
- success = demangle_template (work, mangled, &temp, NULL, 1);
+ success = demangle_template (work, mangled, &temp,
+ NULL, 1, 1);
if (success)
{
string_prependn (&decl, temp.b, temp.p - temp.b);
break;
}
}
- if ((member && !demangle_args (work, mangled, &decl))
+ if ((member && !demangle_nested_args (work, mangled, &decl))
|| **mangled != '_')
{
success = 0;
case 'Q':
case 'K':
{
- int btype = register_Btype (work);
success = demangle_qualified (work, mangled, result, 0, 1);
- remember_Btype (work, result->b, LEN_STRING (result), btype);
-
break;
}
}
case 't':
{
- int bindex= register_Btype (work);
- success = demangle_template (work, mangled, &btype, 0, 1);
- remember_Btype (work, btype.b, LEN_STRING (&btype), bindex);
+ success = demangle_template (work, mangled, &btype, 0, 1, 1);
string_appends (result, &btype);
break;
}
return (success);
}
-/* `result' will be initialized in do_type; it will be freed on failure */
+/* Demangle the next argument, given by MANGLED into RESULT, which
+ *should be an uninitialized* string. It will be initialized here,
+ and free'd should anything go wrong. */
static int
do_arg (work, mangled, result)
const char **mangled;
string *result;
{
+ /* Remember where we started so that we can record the type, for
+ non-squangling type remembering. */
const char *start = *mangled;
- if (!do_type (work, mangled, result))
+ string_init (result);
+
+ if (work->nrepeats > 0)
{
- return (0);
+ --work->nrepeats;
+
+ if (work->previous_argument == 0)
+ return 0;
+
+ /* We want to reissue the previous type in this argument list. */
+ string_appends (result, work->previous_argument);
+ return 1;
+ }
+
+ if (**mangled == 'n')
+ {
+ /* A squangling-style repeat. */
+ (*mangled)++;
+ work->nrepeats = consume_count(mangled);
+
+ if (work->nrepeats == 0)
+ /* This was not a repeat count after all. */
+ return 0;
+
+ if (work->nrepeats > 9)
+ {
+ if (**mangled != '_')
+ /* The repeat count should be followed by an '_' in this
+ case. */
+ return 0;
+ else
+ (*mangled)++;
+ }
+
+ /* Now, the repeat is all set up. */
+ return do_arg (work, mangled, result);
}
+
+ /* Save the result in WORK->previous_argument so that we can find it
+ if it's repeated. Note that saving START is not good enough: we
+ do not want to add additional types to the back-referenceable
+ type vector when processing a repeated type. */
+ if (work->previous_argument)
+ string_clear (work->previous_argument);
else
{
- remember_type (work, start, *mangled - start);
- return (1);
+ work->previous_argument = (string*) xmalloc (sizeof (string));
+ string_init (work->previous_argument);
}
+
+ if (!do_type (work, mangled, work->previous_argument))
+ return 0;
+
+ string_appends (result, work->previous_argument);
+
+ remember_type (work, start, *mangled - start);
+ return 1;
}
static void
{
char *tem;
+ if (work->forgetting_types)
+ return;
+
if (work -> ntypes >= work -> typevec_size)
{
if (work -> typevec_size == 0)
foo__FiR3fooT1T2T1T2
__ct__3fooFiR3fooT1T2T1T2
- Note that g++ bases it's type numbers starting at zero and counts all
- previously seen types, while lucid/ARM bases it's type numbers starting
+ Note that g++ bases its type numbers starting at zero and counts all
+ previously seen types, while lucid/ARM bases its type numbers starting
at one and only considers types after it has seen the 'F' character
indicating the start of the function args. For lucid/ARM style, we
account for this difference by discarding any previously seen types when
}
}
- while (**mangled != '_' && **mangled != '\0' && **mangled != 'e')
+ while ((**mangled != '_' && **mangled != '\0' && **mangled != 'e')
+ || work->nrepeats > 0)
{
if ((**mangled == 'N') || (**mangled == 'T'))
{
{
return (0);
}
- while (--r >= 0)
+ while (work->nrepeats > 0 || --r >= 0)
{
tem = work -> typevec[t];
if (need_comma && PRINT_ARG_TYPES)
}
else
{
- if (need_comma & PRINT_ARG_TYPES)
- {
- string_append (declp, ", ");
- }
+ if (need_comma && PRINT_ARG_TYPES)
+ string_append (declp, ", ");
if (!do_arg (work, mangled, &arg))
- {
- return (0);
- }
+ return (0);
if (PRINT_ARG_TYPES)
- {
- string_appends (declp, &arg);
- }
+ string_appends (declp, &arg);
string_delete (&arg);
need_comma = 1;
}
return (1);
}
+/* Like demangle_args, but for demangling the argument lists of function
+ and method pointers or references, not top-level declarations. */
+
+int
+demangle_nested_args (work, mangled, declp)
+ struct work_stuff *work;
+ const char **mangled;
+ string *declp;
+{
+ string* saved_previous_argument;
+ int result;
+ int saved_nrepeats;
+
+ /* The G++ name-mangling algorithm does not remember types on nested
+ argument lists, unless -fsquangling is used, and in that case the
+ type vector updated by remember_type is not used. So, we turn
+ off remembering of types here. */
+ ++work->forgetting_types;
+
+ /* For the repeat codes used with -fsquangling, we must keep track of
+ the last argument. */
+ saved_previous_argument = work->previous_argument;
+ saved_nrepeats = work->nrepeats;
+ work->previous_argument = 0;
+ work->nrepeats = 0;
+
+ /* Actually demangle the arguments. */
+ result = demangle_args (work, mangled, declp);
+
+ /* Restore the previous_argument field. */
+ if (work->previous_argument)
+ string_delete (work->previous_argument);
+ work->previous_argument = saved_previous_argument;
+ work->nrepeats = saved_nrepeats;
+
+ return result;
+}
+
static void
demangle_function_name (work, mangled, declp, scan)
struct work_stuff *work;
projects / thirdparty / gcc.git / commitdiff
