-/* Demangler for GNU C++
- Copyright 1989, 91, 94, 95, 96, 97, 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
int constructor;
int destructor;
int static_type; /* A static member function */
- int temp_start; /* index in demangled to start of template args */
+ 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. */
/* 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
-{
+typedef enum type_kind_t
+{
tk_none,
tk_pointer,
tk_reference,
- tk_integral,
+ tk_integral,
tk_bool,
- tk_char,
+ tk_char,
tk_real
} type_kind_t;
-
+
#define STRING_EMPTY(str) ((str) -> b == (str) -> p)
#define PREPEND_BLANK(str) {if (!STRING_EMPTY(str)) \
string_prepend(str, " ");}
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
static int
consume_count PARAMS ((const char **));
-static int
+static int
consume_count_with_underscores PARAMS ((const char**));
static int
static void
string_prepends PARAMS ((string *, string *));
-static int
-demangle_template_value_parm PARAMS ((struct work_stuff*, const char**,
+static int
+demangle_template_value_parm PARAMS ((struct work_stuff*, const char**,
string*, type_kind_t));
-static int
+static int
do_hpacc_template_const_value PARAMS ((struct work_stuff *, const char **, string *));
-static int
+static int
do_hpacc_template_literal PARAMS ((struct work_stuff *, const char **, string *));
-static int
+static int
snarf_numeric_literal PARAMS ((const char **, string *));
/* There is a TYPE_QUAL value for each type qualifier. They can be
#define TYPE_QUAL_VOLATILE 0x2
#define TYPE_QUAL_RESTRICT 0x4
-static int
+static int
code_for_qualifier PARAMS ((int));
static const char*
if (**mangled != '_')
/* The trailing underscore was missing. */
return -1;
-
+
(*mangled)++;
}
else
{
if (**mangled < '0' || **mangled > '9')
return -1;
-
+
idx = **mangled - '0';
(*mangled)++;
}
code_for_qualifier (c)
int c;
{
- switch (c)
+ switch (c)
{
case 'C':
return TYPE_QUAL_CONST;
case 'V':
return TYPE_QUAL_VOLATILE;
-
+
case 'u':
return TYPE_QUAL_RESTRICT;
ret = 0;
memset ((char *) work, 0, sizeof (work));
work->options = options;
-
+
if (opname[0] == '_' && opname[1] == '_'
&& opname[2] == 'o' && opname[3] == 'p')
{
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)
for (i = 0; i < sizeof (optable) / sizeof (optable[0]); i++)
{
len1 = len - 3;
- if ((int) strlen (optable[i].in) == len1
+ if ((int) strlen (optable[i].in) == len1
&& memcmp (optable[i].in, opname + 3, len1) == 0)
{
strcat (result, "operator");
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"
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
char *demangled = NULL;
/* Discard the remembered types, if any. */
-
+
forget_types (work);
if (work -> typevec != NULL)
{
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;
}
{
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);
}
oldmangled = NULL;
break;
-
+
case 'S':
/* Static member function */
if (oldmangled == NULL)
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 */
+ work->temp_start = -1; /* uppermost call to demangle_class */
success = demangle_class (work, mangled, declp);
if (success)
{
}
if (AUTO_DEMANGLING || GNU_DEMANGLING || EDG_DEMANGLING)
{
- /* EDG and others will have the "F", so we let the loop cycle
+ /* 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;
}
break;
-
+
case 't':
/* G++ Template */
- string_init(&trawname);
+ string_init(&trawname);
string_init(&tname);
if (oldmangled == NULL)
{
break;
case '_':
- if (GNU_DEMANGLING && expect_return_type)
+ if (GNU_DEMANGLING && expect_return_type)
{
/* Read the return type. */
string return_type;
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,
else if (**mangled == 'z')
{
(*mangled)++;
- success =
+ success =
demangle_template_template_parm (work, mangled, tname);
if (!success)
{
if (**mangled == 'E')
{
int need_operator = 0;
-
+
success = 1;
string_appendn (s, "(", 1);
(*mangled)++;
len = strlen (*mangled);
- for (i = 0;
+ for (i = 0;
i < sizeof (optable) / sizeof (optable [0]);
++i)
{
if (**mangled != 'W')
success = 0;
- else
+ else
{
string_appendn (s, ")", 1);
(*mangled)++;
success = 1;
}
}
-
+
return success;
}
-static int
+static int
demangle_template_value_parm (work, mangled, s, tk)
struct work_stuff *work;
const char **mangled;
(*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;
(*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);
int r2;
(*mangled)++;
success = demangle_template_template_parm (work, mangled, tname);
-
+
if (success
&& (r2 = consume_count (mangled)) > 0
&& (int) strlen (*mangled) >= r2)
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);
}
string_append (tname, " ");
string_append (tname, ">");
}
-
+
if (is_type && remember)
remember_Btype (work, tname->b, LEN_STRING (tname), bindex);
string_appendn (declp, *mangled, n);
(*mangled) += n + 1;
string_init (&arg);
- if (work->temp_start == -1) /* non-recursive call */
+ if (work->temp_start == -1) /* non-recursive call */
work->temp_start = declp->p - declp->b;
string_append (declp, "<");
while (1)
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 */
+ 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;
+ _ if done with template args for a function */
+ if ((**mangled == '\000') || (**mangled == '_'))
+ break;
else
string_append (declp, ",");
}
string_init (&arg);
string_appendn (declp, *mangled, p - *mangled);
if (work->temp_start == -1) /* non-recursive call */
- work->temp_start = declp->p - declp->b;
+ work->temp_start = declp->p - declp->b;
string_append (declp, "<");
/* should do error checking here */
while (args < e) {
/* 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 */
+ /* A typed constant value follows */
args++;
if (!do_type (work, &args, &type_str))
goto cfront_template_args_done;
goto cfront_template_args_done;
break;
default:
- /* Not handling other HP cfront stuff */
+ /* Not handling other HP cfront stuff */
if (!do_type (work, &args, &arg))
goto cfront_template_args_done;
}
cfront_template_args_done:
string_delete (&arg);
if (args >= e)
- --declp->p; /* remove extra comma */
+ --declp->p; /* remove extra comma */
string_append (declp, ">");
}
else if (n>10 && strncmp (*mangled, "_GLOBAL_", 8) == 0
}
else
{
- if (work->temp_start == -1) /* non-recursive call only */
- work->temp_start = 0; /* disable in recursive calls */
+ if (work->temp_start == -1) /* non-recursive call only */
+ work->temp_start = 0; /* disable in recursive calls */
string_appendn (declp, *mangled, n);
}
*mangled += n;
int success = 0;
int btype;
string class_name;
- char *save_class_name_end = 0;
+ char *save_class_name_end = 0;
string_init (&class_name);
btype = register_Btype (work);
}
else
{
- work -> constructor -= 1;
+ work -> constructor -= 1;
}
}
class_name.p = save_class_name_end;
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.
*/
int i;
if (strlen(*mangled) > 6
- && (strncmp(*mangled, "_imp__", 6) == 0
+ && (strncmp(*mangled, "_imp__", 6) == 0
|| strncmp(*mangled, "__imp_", 6) == 0))
{
/* it's a symbol imported from a PE dynamic library. Check for both
i = strspn (scan, "_");
if (i > 2)
{
- scan += (i - 2);
+ scan += (i - 2);
}
}
-
+
if (scan == NULL)
{
success = 0;
consume_count (mangled);
string_append (declp, *mangled);
*mangled += strlen (*mangled);
- success = 1;
+ success = 1;
}
else
{
{
/* Cfront-style parameterized type. Handled later as a signature. */
success = 1;
-
+
/* ARM template? */
demangle_arm_hp_template (work, mangled, strlen (*mangled), declp);
}
{
/* EDG-style parameterized type. Handled later as a signature. */
success = 1;
-
+
/* EDG template? */
demangle_arm_hp_template (work, mangled, strlen (*mangled), declp);
}
string_append (declp, *mangled);
*mangled += strlen (*mangled);
success = 1;
- }
+ }
return (success);
}
{
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);
/* 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);
int remember_K = 1;
string_clear (&last_name);
- if (*mangled[0] == '_')
+ if (*mangled[0] == '_')
(*mangled)++;
if (*mangled[0] == 't')
(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;
{
int namelength;
/* Now recursively demangle the qualifier
- * This is necessary to deal with templates in
- * mangling styles like EDG */
+ * This is necessary to deal with templates in
+ * mangling styles like EDG */
namelength = consume_count (mangled);
recursively_demangle(work, mangled, &temp, namelength);
}
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)
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)
{
p = *type;
n = *count;
- do
+ do
{
n *= 10;
n += *p - '0';
p++;
- }
+ }
while (isdigit ((unsigned char)*p));
if (*p == '_')
{
(*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)
{
strncpy (buf, *mangled, 2);
*mangled += 2;
}
- sscanf (buf, "%x", &dec);
+ sscanf (buf, "%x", &dec);
sprintf (buf, "int%i_t", dec);
APPEND_BLANK (result);
string_append (result, buf);
APPEND_BLANK (result);
string_appends (result, &btype);
}
- else
+ else
success = 0;
string_delete (&btype);
break;
if (**mangled != 'U' && **mangled != 'S')
return 0;
-
+
unsigned_const = (**mangled == 'U');
(*mangled)++;
{
case 'N':
string_append (result, "-");
- /* fall through */
+ /* fall through */
case 'P':
(*mangled)++;
break;
case 'M':
- /* special case for -2^31 */
+ /* special case for -2^31 */
string_append (result, "-2147483648");
(*mangled)++;
return 1;
/* FIXME? Some day we may have 64-bit (or larger :-) ) constants
with L or LL suffixes. pai/1997-09-03 */
-
- return 1; /* success */
+
+ return 1; /* success */
}
/* Handle a template's literal parameter for HP aCC (extension from ARM)
int literal_len = 0;
char * recurse;
char * recurse_dem;
-
+
if (**mangled != 'A')
return 0;
canonical representation uses the address operator */
string_append (result, "&");
- /* Now recursively demangle the literal name */
+ /* 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);
}
else if (**args == '+')
(*args)++;
-
+
if (!isdigit ((unsigned char)**args))
return 0;
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;
}
else
(*mangled)++;
}
-
+
/* Now, the repeat is all set up. */
return do_arg (work, mangled, result);
}
}
/* 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
struct work_stuff *work;
{
int ret;
-
+
if (work -> numb >= work -> bsize)
{
if (work -> bsize == 0)
if ((**mangled == 'N') || (**mangled == 'T'))
{
temptype = *(*mangled)++;
-
+
if (temptype == 'N')
{
if (!get_count (mangled, &r))
/* Actually demangle the arguments. */
result = demangle_args (work, mangled, declp);
-
+
/* Restore the previous_argument field. */
if (work->previous_argument)
string_delete (work->previous_argument);
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 (HP_DEMANGLING && (**mangled == 'X'))
{
demangle_arm_hp_template (work, mangled, 0, declp);
}
}
- 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)
for (i = 0; i < sizeof (optable) / sizeof (optable[0]); i++)
{
int len = declp->p - declp->b - 3;
- if ((int) strlen (optable[i].in) == len
+ if ((int) strlen (optable[i].in) == len
&& memcmp (optable[i].in, declp->b + 3, len) == 0)
{
string_clear (declp);
string_append (declp, "operator");
string_append (declp, optable[i].out);
break;
- }
+ }
}
}
}
s->b = s->p = s->e = NULL;
}
-static void
+static void
string_clear (s)
string *s;
{
usage (stream, status)
FILE *stream;
int status;
-{
+{
fprintf (stream, "\
Usage: %s [-_] [-n] [-s {gnu,lucid,arm,hp,edg}] [--strip-underscores]\n\
[--no-strip-underscores] [--format={gnu,lucid,arm,hp,edg}]\n\
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 */
+ HP aCC template specialization manglings */
{
if (i >= MBUF_SIZE-1)
break;
skip_first = i;
mbuffer[i] = 0;
-
+
result = cplus_demangle (mbuffer + skip_first, flags);
if (result)
{
return value;
}
#endif /* main */
-
projects / thirdparty / gcc.git / commitdiff
