/* Demangler for g++ V3 ABI.
- Copyright (C) 2003, 2004 Free Software Foundation, Inc.
+ Copyright (C) 2003, 2004, 2005 Free Software Foundation, Inc.
Written by Ian Lance Taylor <ian@wasabisystems.com>.
This file is part of the libiberty library, which is part of GCC.
#define CP_STATIC_IF_GLIBCPP_V3 static
#define cplus_demangle_fill_name d_fill_name
-static int
-d_fill_name PARAMS ((struct demangle_component *, const char *, int));
+static int d_fill_name (struct demangle_component *, const char *, int);
#define cplus_demangle_fill_extended_operator d_fill_extended_operator
static int
-d_fill_extended_operator PARAMS ((struct demangle_component *, int,
- struct demangle_component *));
+d_fill_extended_operator (struct demangle_component *, int,
+ struct demangle_component *);
#define cplus_demangle_fill_ctor d_fill_ctor
static int
-d_fill_ctor PARAMS ((struct demangle_component *, enum gnu_v3_ctor_kinds,
- struct demangle_component *));
+d_fill_ctor (struct demangle_component *, enum gnu_v3_ctor_kinds,
+ struct demangle_component *);
#define cplus_demangle_fill_dtor d_fill_dtor
static int
-d_fill_dtor PARAMS ((struct demangle_component *, enum gnu_v3_dtor_kinds,
- struct demangle_component *));
+d_fill_dtor (struct demangle_component *, enum gnu_v3_dtor_kinds,
+ struct demangle_component *);
#define cplus_demangle_mangled_name d_mangled_name
-static struct demangle_component *
-d_mangled_name PARAMS ((struct d_info *, int));
+static struct demangle_component *d_mangled_name (struct d_info *, int);
#define cplus_demangle_type d_type
-static struct demangle_component *
-d_type PARAMS ((struct d_info *));
+static struct demangle_component *d_type (struct d_info *);
#define cplus_demangle_print d_print
-static char *
-d_print PARAMS ((int, const struct demangle_component *, int, size_t *));
+static char *d_print (int, const struct demangle_component *, int, size_t *);
#define cplus_demangle_init_info d_init_info
-static void
-d_init_info PARAMS ((const char *, int, size_t, struct d_info *));
+static void d_init_info (const char *, int, size_t, struct d_info *);
#else /* ! defined(IN_GLIBCPP_V3) */
#define CP_STATIC_IF_GLIBCPP_V3
((dpi)->buf == NULL || (dpi)->len == 0 ? '\0' : (dpi)->buf[(dpi)->len - 1])
#ifdef CP_DEMANGLE_DEBUG
-static void
-d_dump PARAMS ((struct demangle_component *, int));
+static void d_dump (struct demangle_component *, int);
#endif
static struct demangle_component *
-d_make_empty PARAMS ((struct d_info *));
+d_make_empty (struct d_info *);
static struct demangle_component *
-d_make_comp PARAMS ((struct d_info *, enum demangle_component_type,
- struct demangle_component *,
- struct demangle_component *));
+d_make_comp (struct d_info *, enum demangle_component_type,
+ struct demangle_component *,
+ struct demangle_component *);
static struct demangle_component *
-d_make_name PARAMS ((struct d_info *, const char *, int));
+d_make_name (struct d_info *, const char *, int);
static struct demangle_component *
-d_make_builtin_type PARAMS ((struct d_info *,
- const struct demangle_builtin_type_info *));
+d_make_builtin_type (struct d_info *,
+ const struct demangle_builtin_type_info *);
static struct demangle_component *
-d_make_operator PARAMS ((struct d_info *,
- const struct demangle_operator_info *));
+d_make_operator (struct d_info *,
+ const struct demangle_operator_info *);
static struct demangle_component *
-d_make_extended_operator PARAMS ((struct d_info *, int,
- struct demangle_component *));
+d_make_extended_operator (struct d_info *, int,
+ struct demangle_component *);
static struct demangle_component *
-d_make_ctor PARAMS ((struct d_info *, enum gnu_v3_ctor_kinds,
- struct demangle_component *));
+d_make_ctor (struct d_info *, enum gnu_v3_ctor_kinds,
+ struct demangle_component *);
static struct demangle_component *
-d_make_dtor PARAMS ((struct d_info *, enum gnu_v3_dtor_kinds,
- struct demangle_component *));
+d_make_dtor (struct d_info *, enum gnu_v3_dtor_kinds,
+ struct demangle_component *);
static struct demangle_component *
-d_make_template_param PARAMS ((struct d_info *, long));
+d_make_template_param (struct d_info *, long);
static struct demangle_component *
-d_make_sub PARAMS ((struct d_info *, const char *, int));
+d_make_sub (struct d_info *, const char *, int);
static int
-has_return_type PARAMS ((struct demangle_component *));
+has_return_type (struct demangle_component *);
static int
-is_ctor_dtor_or_conversion PARAMS ((struct demangle_component *));
+is_ctor_dtor_or_conversion (struct demangle_component *);
-static struct demangle_component *
-d_encoding PARAMS ((struct d_info *, int));
+static struct demangle_component *d_encoding (struct d_info *, int);
-static struct demangle_component *
-d_name PARAMS ((struct d_info *));
+static struct demangle_component *d_name (struct d_info *);
-static struct demangle_component *
-d_nested_name PARAMS ((struct d_info *));
+static struct demangle_component *d_nested_name (struct d_info *);
-static struct demangle_component *
-d_prefix PARAMS ((struct d_info *));
+static struct demangle_component *d_prefix (struct d_info *);
-static struct demangle_component *
-d_unqualified_name PARAMS ((struct d_info *));
+static struct demangle_component *d_unqualified_name (struct d_info *);
-static struct demangle_component *
-d_source_name PARAMS ((struct d_info *));
+static struct demangle_component *d_source_name (struct d_info *);
-static long
-d_number PARAMS ((struct d_info *));
+static long d_number (struct d_info *);
-static struct demangle_component *
-d_identifier PARAMS ((struct d_info *, int));
+static struct demangle_component *d_identifier (struct d_info *, int);
-static struct demangle_component *
-d_operator_name PARAMS ((struct d_info *));
+static struct demangle_component *d_operator_name (struct d_info *);
-static struct demangle_component *
-d_special_name PARAMS ((struct d_info *));
+static struct demangle_component *d_special_name (struct d_info *);
-static int
-d_call_offset PARAMS ((struct d_info *, int));
+static int d_call_offset (struct d_info *, int);
-static struct demangle_component *
-d_ctor_dtor_name PARAMS ((struct d_info *));
+static struct demangle_component *d_ctor_dtor_name (struct d_info *);
static struct demangle_component **
-d_cv_qualifiers PARAMS ((struct d_info *, struct demangle_component **, int));
+d_cv_qualifiers (struct d_info *, struct demangle_component **, int);
static struct demangle_component *
-d_function_type PARAMS ((struct d_info *));
+d_function_type (struct d_info *);
static struct demangle_component *
-d_bare_function_type PARAMS ((struct d_info *, int));
+d_bare_function_type (struct d_info *, int);
static struct demangle_component *
-d_class_enum_type PARAMS ((struct d_info *));
+d_class_enum_type (struct d_info *);
-static struct demangle_component *
-d_array_type PARAMS ((struct d_info *));
+static struct demangle_component *d_array_type (struct d_info *);
static struct demangle_component *
-d_pointer_to_member_type PARAMS ((struct d_info *));
+d_pointer_to_member_type (struct d_info *);
static struct demangle_component *
-d_template_param PARAMS ((struct d_info *));
+d_template_param (struct d_info *);
-static struct demangle_component *
-d_template_args PARAMS ((struct d_info *));
+static struct demangle_component *d_template_args (struct d_info *);
static struct demangle_component *
-d_template_arg PARAMS ((struct d_info *));
+d_template_arg (struct d_info *);
-static struct demangle_component *
-d_expression PARAMS ((struct d_info *));
+static struct demangle_component *d_expression (struct d_info *);
-static struct demangle_component *
-d_expr_primary PARAMS ((struct d_info *));
+static struct demangle_component *d_expr_primary (struct d_info *);
-static struct demangle_component *
-d_local_name PARAMS ((struct d_info *));
+static struct demangle_component *d_local_name (struct d_info *);
-static int
-d_discriminator PARAMS ((struct d_info *));
+static int d_discriminator (struct d_info *);
static int
-d_add_substitution PARAMS ((struct d_info *, struct demangle_component *));
+d_add_substitution (struct d_info *, struct demangle_component *);
-static struct demangle_component *
-d_substitution PARAMS ((struct d_info *, int));
+static struct demangle_component *d_substitution (struct d_info *, int);
-static void
-d_print_resize PARAMS ((struct d_print_info *, size_t));
+static void d_print_resize (struct d_print_info *, size_t);
-static void
-d_print_append_char PARAMS ((struct d_print_info *, int));
+static void d_print_append_char (struct d_print_info *, int);
static void
-d_print_append_buffer PARAMS ((struct d_print_info *, const char *, size_t));
+d_print_append_buffer (struct d_print_info *, const char *, size_t);
-static void
-d_print_error PARAMS ((struct d_print_info *));
+static void d_print_error (struct d_print_info *);
static void
-d_print_comp PARAMS ((struct d_print_info *,
- const struct demangle_component *));
+d_print_comp (struct d_print_info *, const struct demangle_component *);
static void
-d_print_java_identifier PARAMS ((struct d_print_info *, const char *, int));
+d_print_java_identifier (struct d_print_info *, const char *, int);
static void
-d_print_mod_list PARAMS ((struct d_print_info *, struct d_print_mod *, int));
+d_print_mod_list (struct d_print_info *, struct d_print_mod *, int);
static void
-d_print_mod PARAMS ((struct d_print_info *,
- const struct demangle_component *));
+d_print_mod (struct d_print_info *, const struct demangle_component *);
static void
-d_print_function_type PARAMS ((struct d_print_info *,
- const struct demangle_component *,
- struct d_print_mod *));
+d_print_function_type (struct d_print_info *,
+ const struct demangle_component *,
+ struct d_print_mod *);
static void
-d_print_array_type PARAMS ((struct d_print_info *,
- const struct demangle_component *,
- struct d_print_mod *));
+d_print_array_type (struct d_print_info *,
+ const struct demangle_component *,
+ struct d_print_mod *);
static void
-d_print_expr_op PARAMS ((struct d_print_info *,
- const struct demangle_component *));
+d_print_expr_op (struct d_print_info *, const struct demangle_component *);
static void
-d_print_cast PARAMS ((struct d_print_info *,
- const struct demangle_component *));
+d_print_cast (struct d_print_info *, const struct demangle_component *);
-static char *
-d_demangle PARAMS ((const char *, int, size_t *));
+static char *d_demangle (const char *, int, size_t *);
#ifdef CP_DEMANGLE_DEBUG
static void
-d_dump (dc, indent)
- struct demangle_component *dc;
- int indent;
+d_dump (struct demangle_component *dc, int indent)
{
int i;
CP_STATIC_IF_GLIBCPP_V3
int
-cplus_demangle_fill_name (p, s, len)
- struct demangle_component *p;
- const char *s;
- int len;
+cplus_demangle_fill_name (struct demangle_component *p, const char *s, int len)
{
if (p == NULL || s == NULL || len == 0)
return 0;
CP_STATIC_IF_GLIBCPP_V3
int
-cplus_demangle_fill_extended_operator (p, args, name)
- struct demangle_component *p;
- int args;
- struct demangle_component *name;
+cplus_demangle_fill_extended_operator (struct demangle_component *p, int args,
+ struct demangle_component *name)
{
if (p == NULL || args < 0 || name == NULL)
return 0;
CP_STATIC_IF_GLIBCPP_V3
int
-cplus_demangle_fill_ctor (p, kind, name)
- struct demangle_component *p;
- enum gnu_v3_ctor_kinds kind;
- struct demangle_component *name;
+cplus_demangle_fill_ctor (struct demangle_component *p,
+ enum gnu_v3_ctor_kinds kind,
+ struct demangle_component *name)
{
if (p == NULL
|| name == NULL
CP_STATIC_IF_GLIBCPP_V3
int
-cplus_demangle_fill_dtor (p, kind, name)
- struct demangle_component *p;
- enum gnu_v3_dtor_kinds kind;
- struct demangle_component *name;
+cplus_demangle_fill_dtor (struct demangle_component *p,
+ enum gnu_v3_dtor_kinds kind,
+ struct demangle_component *name)
{
if (p == NULL
|| name == NULL
/* Add a new component. */
static struct demangle_component *
-d_make_empty (di)
- struct d_info *di;
+d_make_empty (struct d_info *di)
{
struct demangle_component *p;
/* Add a new generic component. */
static struct demangle_component *
-d_make_comp (di, type, left, right)
- struct d_info *di;
- enum demangle_component_type type;
- struct demangle_component *left;
- struct demangle_component *right;
+d_make_comp (struct d_info *di, enum demangle_component_type type,
+ struct demangle_component *left,
+ struct demangle_component *right)
{
struct demangle_component *p;
/* Add a new name component. */
static struct demangle_component *
-d_make_name (di, s, len)
- struct d_info *di;
- const char *s;
- int len;
+d_make_name (struct d_info *di, const char *s, int len)
{
struct demangle_component *p;
/* Add a new builtin type component. */
static struct demangle_component *
-d_make_builtin_type (di, type)
- struct d_info *di;
- const struct demangle_builtin_type_info *type;
+d_make_builtin_type (struct d_info *di,
+ const struct demangle_builtin_type_info *type)
{
struct demangle_component *p;
/* Add a new operator component. */
static struct demangle_component *
-d_make_operator (di, op)
- struct d_info *di;
- const struct demangle_operator_info *op;
+d_make_operator (struct d_info *di, const struct demangle_operator_info *op)
{
struct demangle_component *p;
/* Add a new extended operator component. */
static struct demangle_component *
-d_make_extended_operator (di, args, name)
- struct d_info *di;
- int args;
- struct demangle_component *name;
+d_make_extended_operator (struct d_info *di, int args,
+ struct demangle_component *name)
{
struct demangle_component *p;
/* Add a new constructor component. */
static struct demangle_component *
-d_make_ctor (di, kind, name)
- struct d_info *di;
- enum gnu_v3_ctor_kinds kind;
- struct demangle_component *name;
+d_make_ctor (struct d_info *di, enum gnu_v3_ctor_kinds kind,
+ struct demangle_component *name)
{
struct demangle_component *p;
/* Add a new destructor component. */
static struct demangle_component *
-d_make_dtor (di, kind, name)
- struct d_info *di;
- enum gnu_v3_dtor_kinds kind;
- struct demangle_component *name;
+d_make_dtor (struct d_info *di, enum gnu_v3_dtor_kinds kind,
+ struct demangle_component *name)
{
struct demangle_component *p;
/* Add a new template parameter. */
static struct demangle_component *
-d_make_template_param (di, i)
- struct d_info *di;
- long i;
+d_make_template_param (struct d_info *di, long i)
{
struct demangle_component *p;
/* Add a new standard substitution component. */
static struct demangle_component *
-d_make_sub (di, name, len)
- struct d_info *di;
- const char *name;
- int len;
+d_make_sub (struct d_info *di, const char *name, int len)
{
struct demangle_component *p;
CP_STATIC_IF_GLIBCPP_V3
struct demangle_component *
-cplus_demangle_mangled_name (di, top_level)
- struct d_info *di;
- int top_level;
+cplus_demangle_mangled_name (struct d_info *di, int top_level)
{
if (d_next_char (di) != '_')
return NULL;
return types. */
static int
-has_return_type (dc)
- struct demangle_component *dc;
+has_return_type (struct demangle_component *dc)
{
if (dc == NULL)
return 0;
conversion operator. */
static int
-is_ctor_dtor_or_conversion (dc)
- struct demangle_component *dc;
+is_ctor_dtor_or_conversion (struct demangle_component *dc)
{
if (dc == NULL)
return 0;
we would not correctly demangle names in local scopes. */
static struct demangle_component *
-d_encoding (di, top_level)
- struct d_info *di;
- int top_level;
+d_encoding (struct d_info *di, int top_level)
{
char peek = d_peek_char (di);
*/
static struct demangle_component *
-d_name (di)
- struct d_info *di;
+d_name (struct d_info *di)
{
char peek = d_peek_char (di);
struct demangle_component *dc;
*/
static struct demangle_component *
-d_nested_name (di)
- struct d_info *di;
+d_nested_name (struct d_info *di)
{
struct demangle_component *ret;
struct demangle_component **pret;
*/
static struct demangle_component *
-d_prefix (di)
- struct d_info *di;
+d_prefix (struct d_info *di)
{
struct demangle_component *ret = NULL;
*/
static struct demangle_component *
-d_unqualified_name (di)
- struct d_info *di;
+d_unqualified_name (struct d_info *di)
{
char peek;
/* <source-name> ::= <(positive length) number> <identifier> */
static struct demangle_component *
-d_source_name (di)
- struct d_info *di;
+d_source_name (struct d_info *di)
{
long len;
struct demangle_component *ret;
/* number ::= [n] <(non-negative decimal integer)> */
static long
-d_number (di)
- struct d_info *di;
+d_number (struct d_info *di)
{
int negative;
char peek;
/* identifier ::= <(unqualified source code identifier)> */
static struct demangle_component *
-d_identifier (di, len)
- struct d_info *di;
- int len;
+d_identifier (struct d_info *di, int len)
{
const char *name;
};
static struct demangle_component *
-d_operator_name (di)
- struct d_info *di;
+d_operator_name (struct d_info *di)
{
char c1;
char c2;
*/
static struct demangle_component *
-d_special_name (di)
- struct d_info *di;
+d_special_name (struct d_info *di)
{
char c;
display it in verbose mode. */
static int
-d_call_offset (di, c)
- struct d_info *di;
- int c;
+d_call_offset (struct d_info *di, int c)
{
- long offset;
- long virtual_offset;
-
if (c == '\0')
c = d_next_char (di);
if (c == 'h')
- offset = d_number (di);
+ d_number (di);
else if (c == 'v')
{
- offset = d_number (di);
+ d_number (di);
if (d_next_char (di) != '_')
return 0;
- virtual_offset = d_number (di);
+ d_number (di);
}
else
return 0;
*/
static struct demangle_component *
-d_ctor_dtor_name (di)
- struct d_info *di;
+d_ctor_dtor_name (struct d_info *di)
{
if (di->last_name != NULL)
{
const struct demangle_builtin_type_info
cplus_demangle_builtin_types[D_BUILTIN_TYPE_COUNT] =
{
- /* a */ { NL ("signed char"), NL ("signed char"), D_PRINT_INT },
+ /* a */ { NL ("signed char"), NL ("signed char"), D_PRINT_DEFAULT },
/* b */ { NL ("bool"), NL ("boolean"), D_PRINT_BOOL },
- /* c */ { NL ("char"), NL ("byte"), D_PRINT_INT },
- /* d */ { NL ("double"), NL ("double"), D_PRINT_DEFAULT },
- /* e */ { NL ("long double"), NL ("long double"), D_PRINT_DEFAULT },
- /* f */ { NL ("float"), NL ("float"), D_PRINT_DEFAULT },
- /* g */ { NL ("__float128"), NL ("__float128"), D_PRINT_DEFAULT },
- /* h */ { NL ("unsigned char"), NL ("unsigned char"), D_PRINT_INT },
+ /* c */ { NL ("char"), NL ("byte"), D_PRINT_DEFAULT },
+ /* d */ { NL ("double"), NL ("double"), D_PRINT_FLOAT },
+ /* e */ { NL ("long double"), NL ("long double"), D_PRINT_FLOAT },
+ /* f */ { NL ("float"), NL ("float"), D_PRINT_FLOAT },
+ /* g */ { NL ("__float128"), NL ("__float128"), D_PRINT_FLOAT },
+ /* h */ { NL ("unsigned char"), NL ("unsigned char"), D_PRINT_DEFAULT },
/* i */ { NL ("int"), NL ("int"), D_PRINT_INT },
- /* j */ { NL ("unsigned int"), NL ("unsigned"), D_PRINT_INT },
+ /* j */ { NL ("unsigned int"), NL ("unsigned"), D_PRINT_UNSIGNED },
/* k */ { NULL, 0, NULL, 0, D_PRINT_DEFAULT },
/* l */ { NL ("long"), NL ("long"), D_PRINT_LONG },
- /* m */ { NL ("unsigned long"), NL ("unsigned long"), D_PRINT_LONG },
+ /* m */ { NL ("unsigned long"), NL ("unsigned long"), D_PRINT_UNSIGNED_LONG },
/* n */ { NL ("__int128"), NL ("__int128"), D_PRINT_DEFAULT },
- /* o */ { NL ("unsigned __int128"), NL ("unsigned __int128"), D_PRINT_DEFAULT },
+ /* o */ { NL ("unsigned __int128"), NL ("unsigned __int128"),
+ D_PRINT_DEFAULT },
/* p */ { NULL, 0, NULL, 0, D_PRINT_DEFAULT },
/* q */ { NULL, 0, NULL, 0, D_PRINT_DEFAULT },
/* r */ { NULL, 0, NULL, 0, D_PRINT_DEFAULT },
- /* s */ { NL ("short"), NL ("short"), D_PRINT_INT },
- /* t */ { NL ("unsigned short"), NL ("unsigned short"), D_PRINT_INT },
+ /* s */ { NL ("short"), NL ("short"), D_PRINT_DEFAULT },
+ /* t */ { NL ("unsigned short"), NL ("unsigned short"), D_PRINT_DEFAULT },
/* u */ { NULL, 0, NULL, 0, D_PRINT_DEFAULT },
/* v */ { NL ("void"), NL ("void"), D_PRINT_VOID },
- /* w */ { NL ("wchar_t"), NL ("char"), D_PRINT_INT },
- /* x */ { NL ("long long"), NL ("long"), D_PRINT_DEFAULT },
- /* y */ { NL ("unsigned long long"), NL ("unsigned long long"), D_PRINT_DEFAULT },
+ /* w */ { NL ("wchar_t"), NL ("char"), D_PRINT_DEFAULT },
+ /* x */ { NL ("long long"), NL ("long"), D_PRINT_LONG_LONG },
+ /* y */ { NL ("unsigned long long"), NL ("unsigned long long"),
+ D_PRINT_UNSIGNED_LONG_LONG },
/* z */ { NL ("..."), NL ("..."), D_PRINT_DEFAULT },
};
CP_STATIC_IF_GLIBCPP_V3
struct demangle_component *
-cplus_demangle_type (di)
- struct d_info *di;
+cplus_demangle_type (struct d_info *di)
{
char peek;
struct demangle_component *ret;
/* <CV-qualifiers> ::= [r] [V] [K] */
static struct demangle_component **
-d_cv_qualifiers (di, pret, member_fn)
- struct d_info *di;
- struct demangle_component **pret;
- int member_fn;
+d_cv_qualifiers (struct d_info *di,
+ struct demangle_component **pret, int member_fn)
{
char peek;
/* <function-type> ::= F [Y] <bare-function-type> E */
static struct demangle_component *
-d_function_type (di)
- struct d_info *di;
+d_function_type (struct d_info *di)
{
struct demangle_component *ret;
/* <bare-function-type> ::= <type>+ */
static struct demangle_component *
-d_bare_function_type (di, has_return_type)
- struct d_info *di;
- int has_return_type;
+d_bare_function_type (struct d_info *di, int has_return_type)
{
struct demangle_component *return_type;
struct demangle_component *tl;
/* <class-enum-type> ::= <name> */
static struct demangle_component *
-d_class_enum_type (di)
- struct d_info *di;
+d_class_enum_type (struct d_info *di)
{
return d_name (di);
}
*/
static struct demangle_component *
-d_array_type (di)
- struct d_info *di;
+d_array_type (struct d_info *di)
{
char peek;
struct demangle_component *dim;
/* <pointer-to-member-type> ::= M <(class) type> <(member) type> */
static struct demangle_component *
-d_pointer_to_member_type (di)
- struct d_info *di;
+d_pointer_to_member_type (struct d_info *di)
{
struct demangle_component *cl;
struct demangle_component *mem;
*/
static struct demangle_component *
-d_template_param (di)
- struct d_info *di;
+d_template_param (struct d_info *di)
{
long param;
/* <template-args> ::= I <template-arg>+ E */
static struct demangle_component *
-d_template_args (di)
- struct d_info *di;
+d_template_args (struct d_info *di)
{
struct demangle_component *hold_last_name;
struct demangle_component *al;
*/
static struct demangle_component *
-d_template_arg (di)
- struct d_info *di;
+d_template_arg (struct d_info *di)
{
struct demangle_component *ret;
*/
static struct demangle_component *
-d_expression (di)
- struct d_info *di;
+d_expression (struct d_info *di)
{
char peek;
*/
static struct demangle_component *
-d_expr_primary (di)
- struct d_info *di;
+d_expr_primary (struct d_info *di)
{
struct demangle_component *ret;
const char *s;
type = cplus_demangle_type (di);
+ if (type == NULL)
+ return NULL;
/* If we have a type we know how to print, we aren't going to
print the type name itself. */
*/
static struct demangle_component *
-d_local_name (di)
- struct d_info *di;
+d_local_name (struct d_info *di)
{
struct demangle_component *function;
We should print it out in verbose mode. */
static int
-d_discriminator (di)
- struct d_info *di;
+d_discriminator (struct d_info *di)
{
long discrim;
/* Add a new substitution. */
static int
-d_add_substitution (di, dc)
- struct d_info *di;
- struct demangle_component *dc;
+d_add_substitution (struct d_info *di, struct demangle_component *dc)
{
if (dc == NULL)
return 0;
};
static struct demangle_component *
-d_substitution (di, prefix)
- struct d_info *di;
- int prefix;
+d_substitution (struct d_info *di, int prefix)
{
char c;
/* Resize the print buffer. */
static void
-d_print_resize (dpi, add)
- struct d_print_info *dpi;
- size_t add;
+d_print_resize (struct d_print_info *dpi, size_t add)
{
size_t need;
/* Append a character to the print buffer. */
static void
-d_print_append_char (dpi, c)
- struct d_print_info *dpi;
- int c;
+d_print_append_char (struct d_print_info *dpi, int c)
{
if (dpi->buf != NULL)
{
/* Append a buffer to the print buffer. */
static void
-d_print_append_buffer (dpi, s, l)
- struct d_print_info *dpi;
- const char *s;
- size_t l;
+d_print_append_buffer (struct d_print_info *dpi, const char *s, size_t l)
{
if (dpi->buf != NULL)
{
/* Indicate that an error occurred during printing. */
static void
-d_print_error (dpi)
- struct d_print_info *dpi;
+d_print_error (struct d_print_info *dpi)
{
free (dpi->buf);
dpi->buf = NULL;
CP_STATIC_IF_GLIBCPP_V3
char *
-cplus_demangle_print (options, dc, estimate, palc)
- int options;
- const struct demangle_component *dc;
- int estimate;
- size_t *palc;
+cplus_demangle_print (int options, const struct demangle_component *dc,
+ int estimate, size_t *palc)
{
struct d_print_info dpi;
/* Subroutine to handle components. */
static void
-d_print_comp (dpi, dc)
- struct d_print_info *dpi;
- const struct demangle_component *dc;
+d_print_comp (struct d_print_info *dpi,
+ const struct demangle_component *dc)
{
if (dc == NULL)
{
d_print_expr_op (dpi, d_left (dc));
else
{
- d_append_string_constant (dpi, "((");
+ d_append_char (dpi, '(');
d_print_cast (dpi, d_left (dc));
d_append_char (dpi, ')');
}
d_append_char (dpi, '(');
d_print_comp (dpi, d_right (dc));
d_append_char (dpi, ')');
- if (d_left (dc)->type == DEMANGLE_COMPONENT_CAST)
- d_append_char (dpi, ')');
return;
case DEMANGLE_COMPONENT_BINARY:
case DEMANGLE_COMPONENT_LITERAL:
case DEMANGLE_COMPONENT_LITERAL_NEG:
- /* For some builtin types, produce simpler output. */
- if (d_left (dc)->type == DEMANGLE_COMPONENT_BUILTIN_TYPE)
- {
- switch (d_left (dc)->u.s_builtin.type->print)
- {
- case D_PRINT_INT:
- if (d_right (dc)->type == DEMANGLE_COMPONENT_NAME)
- {
- if (dc->type == DEMANGLE_COMPONENT_LITERAL_NEG)
- d_append_char (dpi, '-');
- d_print_comp (dpi, d_right (dc));
- return;
- }
- break;
+ {
+ enum d_builtin_type_print tp;
- case D_PRINT_LONG:
- if (d_right (dc)->type == DEMANGLE_COMPONENT_NAME)
- {
- if (dc->type == DEMANGLE_COMPONENT_LITERAL_NEG)
- d_append_char (dpi, '-');
- d_print_comp (dpi, d_right (dc));
- d_append_char (dpi, 'l');
- return;
- }
- break;
+ /* For some builtin types, produce simpler output. */
+ tp = D_PRINT_DEFAULT;
+ if (d_left (dc)->type == DEMANGLE_COMPONENT_BUILTIN_TYPE)
+ {
+ tp = d_left (dc)->u.s_builtin.type->print;
+ switch (tp)
+ {
+ case D_PRINT_INT:
+ case D_PRINT_UNSIGNED:
+ case D_PRINT_LONG:
+ case D_PRINT_UNSIGNED_LONG:
+ case D_PRINT_LONG_LONG:
+ case D_PRINT_UNSIGNED_LONG_LONG:
+ if (d_right (dc)->type == DEMANGLE_COMPONENT_NAME)
+ {
+ if (dc->type == DEMANGLE_COMPONENT_LITERAL_NEG)
+ d_append_char (dpi, '-');
+ d_print_comp (dpi, d_right (dc));
+ switch (tp)
+ {
+ default:
+ break;
+ case D_PRINT_UNSIGNED:
+ d_append_char (dpi, 'u');
+ break;
+ case D_PRINT_LONG:
+ d_append_char (dpi, 'l');
+ break;
+ case D_PRINT_UNSIGNED_LONG:
+ d_append_string_constant (dpi, "ul");
+ break;
+ case D_PRINT_LONG_LONG:
+ d_append_string_constant (dpi, "ll");
+ break;
+ case D_PRINT_UNSIGNED_LONG_LONG:
+ d_append_string_constant (dpi, "ull");
+ break;
+ }
+ return;
+ }
+ break;
- case D_PRINT_BOOL:
- if (d_right (dc)->type == DEMANGLE_COMPONENT_NAME
- && d_right (dc)->u.s_name.len == 1
- && dc->type == DEMANGLE_COMPONENT_LITERAL)
- {
- switch (d_right (dc)->u.s_name.s[0])
- {
- case '0':
- d_append_string_constant (dpi, "false");
- return;
- case '1':
- d_append_string_constant (dpi, "true");
- return;
- default:
- break;
- }
- }
- break;
+ case D_PRINT_BOOL:
+ if (d_right (dc)->type == DEMANGLE_COMPONENT_NAME
+ && d_right (dc)->u.s_name.len == 1
+ && dc->type == DEMANGLE_COMPONENT_LITERAL)
+ {
+ switch (d_right (dc)->u.s_name.s[0])
+ {
+ case '0':
+ d_append_string_constant (dpi, "false");
+ return;
+ case '1':
+ d_append_string_constant (dpi, "true");
+ return;
+ default:
+ break;
+ }
+ }
+ break;
- default:
- break;
- }
- }
+ default:
+ break;
+ }
+ }
- d_append_char (dpi, '(');
- d_print_comp (dpi, d_left (dc));
- d_append_char (dpi, ')');
- if (dc->type == DEMANGLE_COMPONENT_LITERAL_NEG)
- d_append_char (dpi, '-');
- d_print_comp (dpi, d_right (dc));
+ d_append_char (dpi, '(');
+ d_print_comp (dpi, d_left (dc));
+ d_append_char (dpi, ')');
+ if (dc->type == DEMANGLE_COMPONENT_LITERAL_NEG)
+ d_append_char (dpi, '-');
+ if (tp == D_PRINT_FLOAT)
+ d_append_char (dpi, '[');
+ d_print_comp (dpi, d_right (dc));
+ if (tp == D_PRINT_FLOAT)
+ d_append_char (dpi, ']');
+ }
return;
default:
__U<hex-char>+_. */
static void
-d_print_java_identifier (dpi, name, len)
- struct d_print_info *dpi;
- const char *name;
- int len;
+d_print_java_identifier (struct d_print_info *dpi, const char *name, int len)
{
const char *p;
const char *end;
qualifiers on this after printing a function. */
static void
-d_print_mod_list (dpi, mods, suffix)
- struct d_print_info *dpi;
- struct d_print_mod *mods;
- int suffix;
+d_print_mod_list (struct d_print_info *dpi,
+ struct d_print_mod *mods, int suffix)
{
struct d_print_template *hold_dpt;
/* Print a modifier. */
static void
-d_print_mod (dpi, mod)
- struct d_print_info *dpi;
- const struct demangle_component *mod;
+d_print_mod (struct d_print_info *dpi,
+ const struct demangle_component *mod)
{
switch (mod->type)
{
/* Print a function type, except for the return type. */
static void
-d_print_function_type (dpi, dc, mods)
- struct d_print_info *dpi;
- const struct demangle_component *dc;
- struct d_print_mod *mods;
+d_print_function_type (struct d_print_info *dpi,
+ const struct demangle_component *dc,
+ struct d_print_mod *mods)
{
int need_paren;
int saw_mod;
+ int need_space;
struct d_print_mod *p;
struct d_print_mod *hold_modifiers;
need_paren = 0;
saw_mod = 0;
+ need_space = 0;
for (p = mods; p != NULL; p = p->next)
{
if (p->printed)
saw_mod = 1;
switch (p->mod->type)
{
+ case DEMANGLE_COMPONENT_POINTER:
+ case DEMANGLE_COMPONENT_REFERENCE:
+ need_paren = 1;
+ break;
case DEMANGLE_COMPONENT_RESTRICT:
case DEMANGLE_COMPONENT_VOLATILE:
case DEMANGLE_COMPONENT_CONST:
case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
- case DEMANGLE_COMPONENT_POINTER:
- case DEMANGLE_COMPONENT_REFERENCE:
case DEMANGLE_COMPONENT_COMPLEX:
case DEMANGLE_COMPONENT_IMAGINARY:
case DEMANGLE_COMPONENT_PTRMEM_TYPE:
+ need_space = 1;
need_paren = 1;
break;
case DEMANGLE_COMPONENT_RESTRICT_THIS:
if (need_paren)
{
- switch (d_last_char (dpi))
+ if (! need_space)
{
- case ' ':
- case '(':
- case '*':
- break;
-
- default:
- d_append_char (dpi, ' ');
- break;
+ if (d_last_char (dpi) != '('
+ && d_last_char (dpi) != '*')
+ need_space = 1;
}
-
+ if (need_space && d_last_char (dpi) != ' ')
+ d_append_char (dpi, ' ');
d_append_char (dpi, '(');
}
/* Print an array type, except for the element type. */
static void
-d_print_array_type (dpi, dc, mods)
- struct d_print_info *dpi;
- const struct demangle_component *dc;
- struct d_print_mod *mods;
+d_print_array_type (struct d_print_info *dpi,
+ const struct demangle_component *dc,
+ struct d_print_mod *mods)
{
int need_space;
/* Print an operator in an expression. */
static void
-d_print_expr_op (dpi, dc)
- struct d_print_info *dpi;
- const struct demangle_component *dc;
+d_print_expr_op (struct d_print_info *dpi,
+ const struct demangle_component *dc)
{
if (dc->type == DEMANGLE_COMPONENT_OPERATOR)
d_append_buffer (dpi, dc->u.s_operator.op->name,
/* Print a cast. */
static void
-d_print_cast (dpi, dc)
- struct d_print_info *dpi;
- const struct demangle_component *dc;
+d_print_cast (struct d_print_info *dpi,
+ const struct demangle_component *dc)
{
if (d_left (dc)->type != DEMANGLE_COMPONENT_TEMPLATE)
d_print_comp (dpi, d_left (dc));
CP_STATIC_IF_GLIBCPP_V3
void
-cplus_demangle_init_info (mangled, options, len, di)
- const char *mangled;
- int options;
- size_t len;
- struct d_info *di;
+cplus_demangle_init_info (const char *mangled, int options, size_t len,
+ struct d_info *di)
{
di->s = mangled;
di->send = mangled + len;
a memory allocation failure. On failure, this returns NULL. */
static char *
-d_demangle (mangled, options, palc)
- const char* mangled;
- int options;
- size_t *palc;
+d_demangle (const char* mangled, int options, size_t *palc)
{
size_t len;
int type;
#if defined(IN_LIBGCC2) || defined(IN_GLIBCPP_V3)
-extern char *__cxa_demangle PARAMS ((const char *, char *, size_t *, int *));
+extern char *__cxa_demangle (const char *, char *, size_t *, int *);
/* ia64 ABI-mandated entry point in the C++ runtime library for
performing demangling. MANGLED_NAME is a NUL-terminated character
GNU extensions. */
char *
-__cxa_demangle (mangled_name, output_buffer, length, status)
- const char *mangled_name;
- char *output_buffer;
- size_t *length;
- int *status;
+__cxa_demangle (const char *mangled_name, char *output_buffer,
+ size_t *length, int *status)
{
char *demangled;
size_t alc;
return NULL;
}
- /* The specification for __cxa_demangle() is that if the mangled
- name could be either an extern "C" identifier, or an internal
- built-in type name, then we resolve it as the identifier. All
- internal built-in type names are a single lower case character.
- Frankly, this simplistic disambiguation doesn't make sense to me,
- but it is documented, so we implement it here. */
- if (IS_LOWER (mangled_name[0])
- && mangled_name[1] == '\0'
- && cplus_demangle_builtin_types[mangled_name[0] - 'a'].name != NULL)
- {
- if (status != NULL)
- *status = -2;
- return NULL;
- }
-
- demangled = d_demangle (mangled_name, DMGL_TYPES, &alc);
+ demangled = d_demangle (mangled_name, DMGL_PARAMS | DMGL_TYPES, &alc);
if (demangled == NULL)
{
demangled name. Otherwise, return NULL. */
char *
-cplus_demangle_v3 (mangled, options)
- const char* mangled;
- int options;
+cplus_demangle_v3 (const char* mangled, int options)
{
size_t alc;
of JArray<TYPE> with TYPE[]. */
char *
-java_demangle_v3 (mangled)
- const char* mangled;
+java_demangle_v3 (const char* mangled)
{
size_t alc;
char *demangled;
*DTOR_KIND appropriately. */
static int
-is_ctor_or_dtor (mangled, ctor_kind, dtor_kind)
- const char *mangled;
- enum gnu_v3_ctor_kinds *ctor_kind;
- enum gnu_v3_dtor_kinds *dtor_kind;
+is_ctor_or_dtor (const char *mangled,
+ enum gnu_v3_ctor_kinds *ctor_kind,
+ enum gnu_v3_dtor_kinds *dtor_kind)
{
struct d_info di;
struct demangle_component *dc;
name. A non-zero return indicates the type of constructor. */
enum gnu_v3_ctor_kinds
-is_gnu_v3_mangled_ctor (name)
- const char *name;
+is_gnu_v3_mangled_ctor (const char *name)
{
enum gnu_v3_ctor_kinds ctor_kind;
enum gnu_v3_dtor_kinds dtor_kind;
name. A non-zero return indicates the type of destructor. */
enum gnu_v3_dtor_kinds
-is_gnu_v3_mangled_dtor (name)
- const char *name;
+is_gnu_v3_mangled_dtor (const char *name)
{
enum gnu_v3_ctor_kinds ctor_kind;
enum gnu_v3_dtor_kinds dtor_kind;
#include "getopt.h"
#include "dyn-string.h"
-static void print_usage PARAMS ((FILE* fp, int exit_value));
+static void print_usage (FILE* fp, int exit_value);
#define IS_ALPHA(CHAR) \
(((CHAR) >= 'a' && (CHAR) <= 'z') \
/* Prints usage summary to FP and then exits with EXIT_VALUE. */
static void
-print_usage (fp, exit_value)
- FILE* fp;
- int exit_value;
+print_usage (FILE* fp, int exit_value)
{
fprintf (fp, "Usage: %s [options] [names ...]\n", program_name);
fprintf (fp, "Options:\n");
with their demangled equivalents. */
int
-main (argc, argv)
- int argc;
- char *argv[];
+main (int argc, char *argv[])
{
int i;
int opt_char;
OSDN Git Service
