diff options
Diffstat (limited to 'libiberty/cp-demangle.c')
| -rw-r--r-- | libiberty/cp-demangle.c | 2375 |
1 files changed, 1328 insertions, 1047 deletions
diff --git a/libiberty/cp-demangle.c b/libiberty/cp-demangle.c index 7a806dc44b2..19f191ed8b8 100644 --- a/libiberty/cp-demangle.c +++ b/libiberty/cp-demangle.c @@ -1,5 +1,5 @@ /* Demangler for g++ V3 ABI. - Copyright (C) 2003 Free Software Foundation, Inc. + Copyright (C) 2003, 2004 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. @@ -45,6 +45,22 @@ enum gnu_v3_ctor_kinds is_gnu_v3_mangled_ctor (const char *name) enum gnu_v3_dtor_kinds is_gnu_v3_mangled_dtor (const char *name) + Also, the interface to the component list is public, and defined in + demangle.h. The interface consists of these types, which are + defined in demangle.h: + enum demangle_component_type + struct demangle_component + and these functions defined in this file: + cplus_demangle_fill_name + cplus_demangle_fill_extended_operator + cplus_demangle_fill_ctor + cplus_demangle_fill_dtor + cplus_demangle_print + and other functions defined in the file cp-demint.c. + + This file also defines some other functions and variables which are + only to be used by the file cp-demint.c. + Preprocessor macros you can define while compiling this file: IN_LIBGCC2 @@ -54,7 +70,8 @@ instead of cplus_demangle_v3() and java_demangle_v3(). IN_GLIBCPP_V3 - If defined, this file defines only __cxa_demangle(). + If defined, this file defines only __cxa_demangle(), and no other + publically visible functions or variables. STANDALONE_DEMANGLER If defined, this file defines a main() function which demangles @@ -81,6 +98,68 @@ #include "ansidecl.h" #include "libiberty.h" #include "demangle.h" +#include "cp-demangle.h" + +/* If IN_GLIBCPP_V3 is defined, some functions are made static. We + also rename them via #define to avoid compiler errors when the + static definition conflicts with the extern declaration in a header + file. */ +#ifdef IN_GLIBCPP_V3 + +#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)); + +#define cplus_demangle_fill_extended_operator d_fill_extended_operator +static int +d_fill_extended_operator PARAMS ((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 *)); + +#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 *)); + +#define cplus_demangle_mangled_name d_mangled_name +static struct demangle_component * +d_mangled_name PARAMS ((struct d_info *, int)); + +#define cplus_demangle_type d_type +static struct demangle_component * +d_type PARAMS ((struct d_info *)); + +#define cplus_demangle_print d_print +static char * +d_print PARAMS ((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 *)); + +#else /* ! defined(IN_GLIBCPP_V3) */ +#define CP_STATIC_IF_GLIBCPP_V3 +#endif /* ! defined(IN_GLIBCPP_V3) */ + +/* See if the compiler supports dynamic arrays. */ + +#ifdef __GNUC__ +#define CP_DYNAMIC_ARRAYS +#else +#ifdef __STDC__ +#ifdef __STDC_VERSION__ +#if __STDC_VERSION__ >= 199901L +#define CP_DYNAMIC_ARRAYS +#endif /* __STDC__VERSION >= 199901L */ +#endif /* defined (__STDC_VERSION__) */ +#endif /* defined (__STDC__) */ +#endif /* ! defined (__GNUC__) */ /* We avoid pulling in the ctype tables, to prevent pulling in additional unresolved symbols when this code is used in a library. @@ -101,46 +180,6 @@ #define ANONYMOUS_NAMESPACE_PREFIX_LEN \ (sizeof (ANONYMOUS_NAMESPACE_PREFIX) - 1) -/* Information we keep for operators. */ - -struct d_operator_info -{ - /* Mangled name. */ - const char *code; - /* Real name. */ - const char *name; - /* Number of arguments. */ - int args; -}; - -/* How to print the value of a builtin type. */ - -enum d_builtin_type_print -{ - /* Print as (type)val. */ - D_PRINT_DEFAULT, - /* Print as integer. */ - D_PRINT_INT, - /* Print as long, with trailing `l'. */ - D_PRINT_LONG, - /* Print as bool. */ - D_PRINT_BOOL, - /* Print in usual way, but here to detect void. */ - D_PRINT_VOID -}; - -/* Information we keep for a builtin type. */ - -struct d_builtin_type_info -{ - /* Type name. */ - const char *name; - /* Type name when using Java. */ - const char *java_name; - /* How to print a value of this type. */ - enum d_builtin_type_print print; -}; - /* Information we keep for the standard substitutions. */ struct d_standard_sub_info @@ -149,228 +188,26 @@ struct d_standard_sub_info char code; /* The simple string it expands to. */ const char *simple_expansion; + /* The length of the simple expansion. */ + int simple_len; /* The results of a full, verbose, expansion. This is used when qualifying a constructor/destructor, or when in verbose mode. */ const char *full_expansion; + /* The length of the full expansion. */ + int full_len; /* What to set the last_name field of d_info to; NULL if we should not set it. This is only relevant when qualifying a constructor/destructor. */ const char *set_last_name; + /* The length of set_last_name. */ + int set_last_name_len; }; -/* Component types found in mangled names. */ - -enum d_comp_type -{ - /* A name. */ - D_COMP_NAME, - /* A qualified name. */ - D_COMP_QUAL_NAME, - /* A typed name. */ - D_COMP_TYPED_NAME, - /* A template. */ - D_COMP_TEMPLATE, - /* A template parameter. */ - D_COMP_TEMPLATE_PARAM, - /* A constructor. */ - D_COMP_CTOR, - /* A destructor. */ - D_COMP_DTOR, - /* A vtable. */ - D_COMP_VTABLE, - /* A VTT structure. */ - D_COMP_VTT, - /* A construction vtable. */ - D_COMP_CONSTRUCTION_VTABLE, - /* A typeinfo structure. */ - D_COMP_TYPEINFO, - /* A typeinfo name. */ - D_COMP_TYPEINFO_NAME, - /* A typeinfo function. */ - D_COMP_TYPEINFO_FN, - /* A thunk. */ - D_COMP_THUNK, - /* A virtual thunk. */ - D_COMP_VIRTUAL_THUNK, - /* A covariant thunk. */ - D_COMP_COVARIANT_THUNK, - /* A Java class. */ - D_COMP_JAVA_CLASS, - /* A guard variable. */ - D_COMP_GUARD, - /* A reference temporary. */ - D_COMP_REFTEMP, - /* A standard substitution. */ - D_COMP_SUB_STD, - /* The restrict qualifier. */ - D_COMP_RESTRICT, - /* The volatile qualifier. */ - D_COMP_VOLATILE, - /* The const qualifier. */ - D_COMP_CONST, - /* The restrict qualifier modifying a member function. */ - D_COMP_RESTRICT_THIS, - /* The volatile qualifier modifying a member function. */ - D_COMP_VOLATILE_THIS, - /* The const qualifier modifying a member function. */ - D_COMP_CONST_THIS, - /* A vendor qualifier. */ - D_COMP_VENDOR_TYPE_QUAL, - /* A pointer. */ - D_COMP_POINTER, - /* A reference. */ - D_COMP_REFERENCE, - /* A complex type. */ - D_COMP_COMPLEX, - /* An imaginary type. */ - D_COMP_IMAGINARY, - /* A builtin type. */ - D_COMP_BUILTIN_TYPE, - /* A vendor's builtin type. */ - D_COMP_VENDOR_TYPE, - /* A function type. */ - D_COMP_FUNCTION_TYPE, - /* An array type. */ - D_COMP_ARRAY_TYPE, - /* A pointer to member type. */ - D_COMP_PTRMEM_TYPE, - /* An argument list. */ - D_COMP_ARGLIST, - /* A template argument list. */ - D_COMP_TEMPLATE_ARGLIST, - /* An operator. */ - D_COMP_OPERATOR, - /* An extended operator. */ - D_COMP_EXTENDED_OPERATOR, - /* A typecast. */ - D_COMP_CAST, - /* A unary expression. */ - D_COMP_UNARY, - /* A binary expression. */ - D_COMP_BINARY, - /* Arguments to a binary expression. */ - D_COMP_BINARY_ARGS, - /* A trinary expression. */ - D_COMP_TRINARY, - /* Arguments to a trinary expression. */ - D_COMP_TRINARY_ARG1, - D_COMP_TRINARY_ARG2, - /* A literal. */ - D_COMP_LITERAL, - /* A negative literal. */ - D_COMP_LITERAL_NEG -}; - -/* A component of the mangled name. */ - -struct d_comp -{ - /* The type of this component. */ - enum d_comp_type type; - union - { - /* For D_COMP_NAME. */ - struct - { - /* A pointer to the name (not NULL terminated) and it's - length. */ - const char *s; - int len; - } s_name; - - /* For D_COMP_OPERATOR. */ - struct - { - /* Operator. */ - const struct d_operator_info *op; - } s_operator; - - /* For D_COMP_EXTENDED_OPERATOR. */ - struct - { - /* Number of arguments. */ - int args; - /* Name. */ - struct d_comp *name; - } s_extended_operator; - - /* For D_COMP_CTOR. */ - struct - { - enum gnu_v3_ctor_kinds kind; - struct d_comp *name; - } s_ctor; - - /* For D_COMP_DTOR. */ - struct - { - enum gnu_v3_dtor_kinds kind; - struct d_comp *name; - } s_dtor; - - /* For D_COMP_BUILTIN_TYPE. */ - struct - { - const struct d_builtin_type_info *type; - } s_builtin; - - /* For D_COMP_SUB_STD. */ - struct - { - const char* string; - } s_string; - - /* For D_COMP_TEMPLATE_PARAM. */ - struct - { - long number; - } s_number; - - /* For other types. */ - struct - { - struct d_comp *left; - struct d_comp *right; - } s_binary; - - } u; -}; +/* Accessors for subtrees of struct demangle_component. */ #define d_left(dc) ((dc)->u.s_binary.left) #define d_right(dc) ((dc)->u.s_binary.right) -/* The information structure we pass around. */ - -struct d_info -{ - /* The string we are demangling. */ - const char *s; - /* The options passed to the demangler. */ - int options; - /* The next character in the string to consider. */ - const char *n; - /* The array of components. */ - struct d_comp *comps; - /* The index of the next available component. */ - int next_comp; - /* The number of available component structures. */ - int num_comps; - /* The array of substitutions. */ - struct d_comp **subs; - /* The index of the next substitution. */ - int next_sub; - /* The number of available entries in the subs array. */ - int num_subs; - /* The last name we saw, for constructors and destructors. */ - struct d_comp *last_name; -}; - -#define d_peek_char(di) (*((di)->n)) -#define d_peek_next_char(di) ((di)->n[1]) -#define d_advance(di, i) ((di)->n += (i)) -#define d_next_char(di) (*((di)->n++)) -#define d_str(di) ((di)->n) - /* A list of templates. This is used while printing. */ struct d_print_template @@ -378,7 +215,7 @@ struct d_print_template /* Next template on the list. */ struct d_print_template *next; /* This template. */ - const struct d_comp *template; + const struct demangle_component *template; }; /* A list of type modifiers. This is used while printing. */ @@ -389,7 +226,7 @@ struct d_print_mod in which they appeared in the mangled string. */ struct d_print_mod *next; /* The modifier. */ - const struct d_comp *mod; + const struct demangle_component *mod; /* Whether this modifier was printed. */ int printed; /* The list of templates which applies to this modifier. */ @@ -442,105 +279,193 @@ struct d_print_info } \ while (0) -#define d_append_string(dpi, s) \ - do \ - { \ - size_t d_append_string_len = strlen (s); \ - d_append_buffer ((dpi), (s), d_append_string_len); \ - } \ - while (0) +#define d_append_string_constant(dpi, s) \ + d_append_buffer (dpi, (s), sizeof (s) - 1) #define d_last_char(dpi) \ ((dpi)->buf == NULL || (dpi)->len == 0 ? '\0' : (dpi)->buf[(dpi)->len - 1]) #ifdef CP_DEMANGLE_DEBUG -static void d_dump PARAMS ((struct d_comp *, int)); +static void +d_dump PARAMS ((struct demangle_component *, int)); #endif -static struct d_comp *d_make_empty PARAMS ((struct d_info *, - enum d_comp_type)); -static struct d_comp *d_make_comp PARAMS ((struct d_info *, enum d_comp_type, - struct d_comp *, struct d_comp *)); -static struct d_comp *d_make_name PARAMS ((struct d_info *, const char *, - int)); -static struct d_comp *d_make_builtin_type PARAMS ((struct d_info *, - const struct d_builtin_type_info *)); -static struct d_comp *d_make_operator PARAMS ((struct d_info *, - const struct d_operator_info *)); -static struct d_comp *d_make_extended_operator PARAMS ((struct d_info *, - int, - struct d_comp *)); -static struct d_comp *d_make_ctor PARAMS ((struct d_info *, - enum gnu_v3_ctor_kinds, - struct d_comp *)); -static struct d_comp *d_make_dtor PARAMS ((struct d_info *, - enum gnu_v3_dtor_kinds, - struct d_comp *)); -static struct d_comp *d_make_template_param PARAMS ((struct d_info *, long)); -static struct d_comp *d_make_sub PARAMS ((struct d_info *, const char *)); -static struct d_comp *d_mangled_name PARAMS ((struct d_info *, int)); -static int has_return_type PARAMS ((struct d_comp *)); -static int is_ctor_dtor_or_conversion PARAMS ((struct d_comp *)); -static struct d_comp *d_encoding PARAMS ((struct d_info *, int)); -static struct d_comp *d_name PARAMS ((struct d_info *)); -static struct d_comp *d_nested_name PARAMS ((struct d_info *)); -static struct d_comp *d_prefix PARAMS ((struct d_info *)); -static struct d_comp *d_unqualified_name PARAMS ((struct d_info *)); -static struct d_comp *d_source_name PARAMS ((struct d_info *)); -static long d_number PARAMS ((struct d_info *)); -static struct d_comp *d_identifier PARAMS ((struct d_info *, int)); -static struct d_comp *d_operator_name PARAMS ((struct d_info *)); -static struct d_comp *d_special_name PARAMS ((struct d_info *)); -static int d_call_offset PARAMS ((struct d_info *, int)); -static struct d_comp *d_ctor_dtor_name PARAMS ((struct d_info *)); -static struct d_comp *d_type PARAMS ((struct d_info *)); -static struct d_comp **d_cv_qualifiers PARAMS ((struct d_info *, - struct d_comp **, int)); -static struct d_comp *d_function_type PARAMS ((struct d_info *)); -static struct d_comp *d_bare_function_type PARAMS ((struct d_info *, int)); -static struct d_comp *d_class_enum_type PARAMS ((struct d_info *)); -static struct d_comp *d_array_type PARAMS ((struct d_info *)); -static struct d_comp *d_pointer_to_member_type PARAMS ((struct d_info *)); -static struct d_comp *d_template_param PARAMS ((struct d_info *)); -static struct d_comp *d_template_args PARAMS ((struct d_info *)); -static struct d_comp *d_template_arg PARAMS ((struct d_info *)); -static struct d_comp *d_expression PARAMS ((struct d_info *)); -static struct d_comp *d_expr_primary PARAMS ((struct d_info *)); -static struct d_comp *d_local_name PARAMS ((struct d_info *)); -static int d_discriminator PARAMS ((struct d_info *)); -static int d_add_substitution PARAMS ((struct d_info *, struct d_comp *)); -static struct d_comp *d_substitution PARAMS ((struct d_info *, int)); -static void d_print_resize PARAMS ((struct d_print_info *, size_t)); -static void d_print_append_char PARAMS ((struct d_print_info *, int)); -static void d_print_append_buffer PARAMS ((struct d_print_info *, const char *, - size_t)); -static void d_print_error PARAMS ((struct d_print_info *)); -static char *d_print PARAMS ((int, const struct d_comp *, size_t *)); -static void d_print_comp PARAMS ((struct d_print_info *, - const struct d_comp *)); -static void d_print_identifier PARAMS ((struct d_print_info *, const char *, - int)); -static void d_print_mod_list PARAMS ((struct d_print_info *, - struct d_print_mod *, int)); -static void d_print_mod PARAMS ((struct d_print_info *, - const struct d_comp *)); -static void d_print_function_type PARAMS ((struct d_print_info *, - const struct d_comp *, - struct d_print_mod *)); -static void d_print_array_type PARAMS ((struct d_print_info *, - const struct d_comp *, - struct d_print_mod *)); -static void d_print_expr_op PARAMS ((struct d_print_info *, - const struct d_comp *)); -static void d_print_cast PARAMS ((struct d_print_info *, - const struct d_comp *)); -static int d_init_info PARAMS ((const char *, int, size_t, struct d_info *)); -static char *d_demangle PARAMS ((const char *, int, size_t *)); + +static struct demangle_component * +d_make_empty PARAMS ((struct d_info *)); + +static struct demangle_component * +d_make_comp PARAMS ((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)); + +static struct demangle_component * +d_make_builtin_type PARAMS ((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 *)); + +static struct demangle_component * +d_make_extended_operator PARAMS ((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 *)); + +static struct demangle_component * +d_make_dtor PARAMS ((struct d_info *, enum gnu_v3_dtor_kinds, + struct demangle_component *)); + +static struct demangle_component * +d_make_template_param PARAMS ((struct d_info *, long)); + +static struct demangle_component * +d_make_sub PARAMS ((struct d_info *, const char *, int)); + +static int +has_return_type PARAMS ((struct demangle_component *)); + +static int +is_ctor_dtor_or_conversion PARAMS ((struct demangle_component *)); + +static struct demangle_component * +d_encoding PARAMS ((struct d_info *, int)); + +static struct demangle_component * +d_name PARAMS ((struct d_info *)); + +static struct demangle_component * +d_nested_name PARAMS ((struct d_info *)); + +static struct demangle_component * +d_prefix PARAMS ((struct d_info *)); + +static struct demangle_component * +d_unqualified_name PARAMS ((struct d_info *)); + +static struct demangle_component * +d_source_name PARAMS ((struct d_info *)); + +static long +d_number PARAMS ((struct d_info *)); + +static struct demangle_component * +d_identifier PARAMS ((struct d_info *, int)); + +static struct demangle_component * +d_operator_name PARAMS ((struct d_info *)); + +static struct demangle_component * +d_special_name PARAMS ((struct d_info *)); + +static int +d_call_offset PARAMS ((struct d_info *, int)); + +static struct demangle_component * +d_ctor_dtor_name PARAMS ((struct d_info *)); + +static struct demangle_component ** +d_cv_qualifiers PARAMS ((struct d_info *, struct demangle_component **, int)); + +static struct demangle_component * +d_function_type PARAMS ((struct d_info *)); + +static struct demangle_component * +d_bare_function_type PARAMS ((struct d_info *, int)); + +static struct demangle_component * +d_class_enum_type PARAMS ((struct d_info *)); + +static struct demangle_component * +d_array_type PARAMS ((struct d_info *)); + +static struct demangle_component * +d_pointer_to_member_type PARAMS ((struct d_info *)); + +static struct demangle_component * +d_template_param PARAMS ((struct d_info *)); + +static struct demangle_component * +d_template_args PARAMS ((struct d_info *)); + +static struct demangle_component * +d_template_arg PARAMS ((struct d_info *)); + +static struct demangle_component * +d_expression PARAMS ((struct d_info *)); + +static struct demangle_component * +d_expr_primary PARAMS ((struct d_info *)); + +static struct demangle_component * +d_local_name PARAMS ((struct d_info *)); + +static int +d_discriminator PARAMS ((struct d_info *)); + +static int +d_add_substitution PARAMS ((struct d_info *, struct demangle_component *)); + +static struct demangle_component * +d_substitution PARAMS ((struct d_info *, int)); + +static void +d_print_resize PARAMS ((struct d_print_info *, size_t)); + +static void +d_print_append_char PARAMS ((struct d_print_info *, int)); + +static void +d_print_append_buffer PARAMS ((struct d_print_info *, const char *, size_t)); + +static void +d_print_error PARAMS ((struct d_print_info *)); + +static void +d_print_comp PARAMS ((struct d_print_info *, + const struct demangle_component *)); + +static void +d_print_java_identifier PARAMS ((struct d_print_info *, const char *, int)); + +static void +d_print_mod_list PARAMS ((struct d_print_info *, struct d_print_mod *, int)); + +static void +d_print_mod PARAMS ((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 *)); + +static void +d_print_array_type PARAMS ((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 *)); + +static void +d_print_cast PARAMS ((struct d_print_info *, + const struct demangle_component *)); + +static char * +d_demangle PARAMS ((const char *, int, size_t *)); #ifdef CP_DEMANGLE_DEBUG static void d_dump (dc, indent) - struct d_comp *dc; + struct demangle_component *dc; int indent; { int i; @@ -553,156 +478,159 @@ d_dump (dc, indent) switch (dc->type) { - case D_COMP_NAME: + case DEMANGLE_COMPONENT_NAME: printf ("name '%.*s'\n", dc->u.s_name.len, dc->u.s_name.s); return; - case D_COMP_TEMPLATE_PARAM: + case DEMANGLE_COMPONENT_TEMPLATE_PARAM: printf ("template parameter %ld\n", dc->u.s_number.number); return; - case D_COMP_CTOR: + case DEMANGLE_COMPONENT_CTOR: printf ("constructor %d\n", (int) dc->u.s_ctor.kind); d_dump (dc->u.s_ctor.name, indent + 2); return; - case D_COMP_DTOR: + case DEMANGLE_COMPONENT_DTOR: printf ("destructor %d\n", (int) dc->u.s_dtor.kind); d_dump (dc->u.s_dtor.name, indent + 2); return; - case D_COMP_SUB_STD: + case DEMANGLE_COMPONENT_SUB_STD: printf ("standard substitution %s\n", dc->u.s_string.string); return; - case D_COMP_BUILTIN_TYPE: + case DEMANGLE_COMPONENT_BUILTIN_TYPE: printf ("builtin type %s\n", dc->u.s_builtin.type->name); return; - case D_COMP_OPERATOR: + case DEMANGLE_COMPONENT_OPERATOR: printf ("operator %s\n", dc->u.s_operator.op->name); return; - case D_COMP_EXTENDED_OPERATOR: + case DEMANGLE_COMPONENT_EXTENDED_OPERATOR: printf ("extended operator with %d args\n", dc->u.s_extended_operator.args); d_dump (dc->u.s_extended_operator.name, indent + 2); return; - case D_COMP_QUAL_NAME: + case DEMANGLE_COMPONENT_QUAL_NAME: printf ("qualified name\n"); break; - case D_COMP_TYPED_NAME: + case DEMANGLE_COMPONENT_LOCAL_NAME: + printf ("local name\n"); + break; + case DEMANGLE_COMPONENT_TYPED_NAME: printf ("typed name\n"); break; - case D_COMP_TEMPLATE: + case DEMANGLE_COMPONENT_TEMPLATE: printf ("template\n"); break; - case D_COMP_VTABLE: + case DEMANGLE_COMPONENT_VTABLE: printf ("vtable\n"); break; - case D_COMP_VTT: + case DEMANGLE_COMPONENT_VTT: printf ("VTT\n"); break; - case D_COMP_CONSTRUCTION_VTABLE: + case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE: printf ("construction vtable\n"); break; - case D_COMP_TYPEINFO: + case DEMANGLE_COMPONENT_TYPEINFO: printf ("typeinfo\n"); break; - case D_COMP_TYPEINFO_NAME: + case DEMANGLE_COMPONENT_TYPEINFO_NAME: printf ("typeinfo name\n"); break; - case D_COMP_TYPEINFO_FN: + case DEMANGLE_COMPONENT_TYPEINFO_FN: printf ("typeinfo function\n"); break; - case D_COMP_THUNK: + case DEMANGLE_COMPONENT_THUNK: printf ("thunk\n"); break; - case D_COMP_VIRTUAL_THUNK: + case DEMANGLE_COMPONENT_VIRTUAL_THUNK: printf ("virtual thunk\n"); break; - case D_COMP_COVARIANT_THUNK: + case DEMANGLE_COMPONENT_COVARIANT_THUNK: printf ("covariant thunk\n"); break; - case D_COMP_JAVA_CLASS: + case DEMANGLE_COMPONENT_JAVA_CLASS: printf ("java class\n"); break; - case D_COMP_GUARD: + case DEMANGLE_COMPONENT_GUARD: printf ("guard\n"); break; - case D_COMP_REFTEMP: + case DEMANGLE_COMPONENT_REFTEMP: printf ("reference temporary\n"); break; - case D_COMP_RESTRICT: + case DEMANGLE_COMPONENT_RESTRICT: printf ("restrict\n"); break; - case D_COMP_VOLATILE: + case DEMANGLE_COMPONENT_VOLATILE: printf ("volatile\n"); break; - case D_COMP_CONST: + case DEMANGLE_COMPONENT_CONST: printf ("const\n"); break; - case D_COMP_RESTRICT_THIS: + case DEMANGLE_COMPONENT_RESTRICT_THIS: printf ("restrict this\n"); break; - case D_COMP_VOLATILE_THIS: + case DEMANGLE_COMPONENT_VOLATILE_THIS: printf ("volatile this\n"); break; - case D_COMP_CONST_THIS: + case DEMANGLE_COMPONENT_CONST_THIS: printf ("const this\n"); break; - case D_COMP_VENDOR_TYPE_QUAL: + case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL: printf ("vendor type qualifier\n"); break; - case D_COMP_POINTER: + case DEMANGLE_COMPONENT_POINTER: printf ("pointer\n"); break; - case D_COMP_REFERENCE: + case DEMANGLE_COMPONENT_REFERENCE: printf ("reference\n"); break; - case D_COMP_COMPLEX: + case DEMANGLE_COMPONENT_COMPLEX: printf ("complex\n"); break; - case D_COMP_IMAGINARY: + case DEMANGLE_COMPONENT_IMAGINARY: printf ("imaginary\n"); break; - case D_COMP_VENDOR_TYPE: + case DEMANGLE_COMPONENT_VENDOR_TYPE: printf ("vendor type\n"); break; - case D_COMP_FUNCTION_TYPE: + case DEMANGLE_COMPONENT_FUNCTION_TYPE: printf ("function type\n"); break; - case D_COMP_ARRAY_TYPE: + case DEMANGLE_COMPONENT_ARRAY_TYPE: printf ("array type\n"); break; - case D_COMP_PTRMEM_TYPE: + case DEMANGLE_COMPONENT_PTRMEM_TYPE: printf ("pointer to member type\n"); break; - case D_COMP_ARGLIST: + case DEMANGLE_COMPONENT_ARGLIST: printf ("argument list\n"); break; - case D_COMP_TEMPLATE_ARGLIST: + case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST: printf ("template argument list\n"); break; - case D_COMP_CAST: + case DEMANGLE_COMPONENT_CAST: printf ("cast\n"); break; - case D_COMP_UNARY: + case DEMANGLE_COMPONENT_UNARY: printf ("unary operator\n"); break; - case D_COMP_BINARY: + case DEMANGLE_COMPONENT_BINARY: printf ("binary operator\n"); break; - case D_COMP_BINARY_ARGS: + case DEMANGLE_COMPONENT_BINARY_ARGS: printf ("binary operator arguments\n"); break; - case D_COMP_TRINARY: + case DEMANGLE_COMPONENT_TRINARY: printf ("trinary operator\n"); break; - case D_COMP_TRINARY_ARG1: + case DEMANGLE_COMPONENT_TRINARY_ARG1: printf ("trinary operator arguments 1\n"); break; - case D_COMP_TRINARY_ARG2: + case DEMANGLE_COMPONENT_TRINARY_ARG2: printf ("trinary operator arguments 1\n"); break; - case D_COMP_LITERAL: + case DEMANGLE_COMPONENT_LITERAL: printf ("literal\n"); break; - case D_COMP_LITERAL_NEG: + case DEMANGLE_COMPONENT_LITERAL_NEG: printf ("negative literal\n"); break; } @@ -713,33 +641,105 @@ d_dump (dc, indent) #endif /* CP_DEMANGLE_DEBUG */ +/* Fill in a DEMANGLE_COMPONENT_NAME. */ + +CP_STATIC_IF_GLIBCPP_V3 +int +cplus_demangle_fill_name (p, s, len) + struct demangle_component *p; + const char *s; + int len; +{ + if (p == NULL || s == NULL || len == 0) + return 0; + p->type = DEMANGLE_COMPONENT_NAME; + p->u.s_name.s = s; + p->u.s_name.len = len; + return 1; +} + +/* Fill in a DEMANGLE_COMPONENT_EXTENDED_OPERATOR. */ + +CP_STATIC_IF_GLIBCPP_V3 +int +cplus_demangle_fill_extended_operator (p, args, name) + struct demangle_component *p; + int args; + struct demangle_component *name; +{ + if (p == NULL || args < 0 || name == NULL) + return 0; + p->type = DEMANGLE_COMPONENT_EXTENDED_OPERATOR; + p->u.s_extended_operator.args = args; + p->u.s_extended_operator.name = name; + return 1; +} + +/* Fill in a DEMANGLE_COMPONENT_CTOR. */ + +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; +{ + if (p == NULL + || name == NULL + || (kind < gnu_v3_complete_object_ctor + && kind > gnu_v3_complete_object_allocating_ctor)) + return 0; + p->type = DEMANGLE_COMPONENT_CTOR; + p->u.s_ctor.kind = kind; + p->u.s_ctor.name = name; + return 1; +} + +/* Fill in a DEMANGLE_COMPONENT_DTOR. */ + +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; +{ + if (p == NULL + || name == NULL + || (kind < gnu_v3_deleting_dtor + && kind > gnu_v3_base_object_dtor)) + return 0; + p->type = DEMANGLE_COMPONENT_DTOR; + p->u.s_dtor.kind = kind; + p->u.s_dtor.name = name; + return 1; +} + /* Add a new component. */ -static struct d_comp * -d_make_empty (di, type) +static struct demangle_component * +d_make_empty (di) struct d_info *di; - enum d_comp_type type; { - struct d_comp *p; + struct demangle_component *p; if (di->next_comp >= di->num_comps) return NULL; p = &di->comps[di->next_comp]; - p->type = type; ++di->next_comp; return p; } /* Add a new generic component. */ -static struct d_comp * +static struct demangle_component * d_make_comp (di, type, left, right) struct d_info *di; - enum d_comp_type type; - struct d_comp *left; - struct d_comp *right; + enum demangle_component_type type; + struct demangle_component *left; + struct demangle_component *right; { - struct d_comp *p; + struct demangle_component *p; /* We check for errors here. A typical error would be a NULL return from a subroutine. We catch those here, and return NULL @@ -747,64 +747,65 @@ d_make_comp (di, type, left, right) switch (type) { /* These types require two parameters. */ - case D_COMP_QUAL_NAME: - case D_COMP_TYPED_NAME: - case D_COMP_TEMPLATE: - case D_COMP_VENDOR_TYPE_QUAL: - case D_COMP_PTRMEM_TYPE: - case D_COMP_UNARY: - case D_COMP_BINARY: - case D_COMP_BINARY_ARGS: - case D_COMP_TRINARY: - case D_COMP_TRINARY_ARG1: - case D_COMP_TRINARY_ARG2: - case D_COMP_LITERAL: - case D_COMP_LITERAL_NEG: + case DEMANGLE_COMPONENT_QUAL_NAME: + case DEMANGLE_COMPONENT_LOCAL_NAME: + case DEMANGLE_COMPONENT_TYPED_NAME: + case DEMANGLE_COMPONENT_TEMPLATE: + case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE: + case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL: + case DEMANGLE_COMPONENT_PTRMEM_TYPE: + case DEMANGLE_COMPONENT_UNARY: + case DEMANGLE_COMPONENT_BINARY: + case DEMANGLE_COMPONENT_BINARY_ARGS: + case DEMANGLE_COMPONENT_TRINARY: + case DEMANGLE_COMPONENT_TRINARY_ARG1: + case DEMANGLE_COMPONENT_TRINARY_ARG2: + case DEMANGLE_COMPONENT_LITERAL: + case DEMANGLE_COMPONENT_LITERAL_NEG: if (left == NULL || right == NULL) return NULL; break; /* These types only require one parameter. */ - case D_COMP_VTABLE: - case D_COMP_VTT: - case D_COMP_CONSTRUCTION_VTABLE: - case D_COMP_TYPEINFO: - case D_COMP_TYPEINFO_NAME: - case D_COMP_TYPEINFO_FN: - case D_COMP_THUNK: - case D_COMP_VIRTUAL_THUNK: - case D_COMP_COVARIANT_THUNK: - case D_COMP_JAVA_CLASS: - case D_COMP_GUARD: - case D_COMP_REFTEMP: - case D_COMP_POINTER: - case D_COMP_REFERENCE: - case D_COMP_COMPLEX: - case D_COMP_IMAGINARY: - case D_COMP_VENDOR_TYPE: - case D_COMP_ARGLIST: - case D_COMP_TEMPLATE_ARGLIST: - case D_COMP_CAST: + case DEMANGLE_COMPONENT_VTABLE: + case DEMANGLE_COMPONENT_VTT: + case DEMANGLE_COMPONENT_TYPEINFO: + case DEMANGLE_COMPONENT_TYPEINFO_NAME: + case DEMANGLE_COMPONENT_TYPEINFO_FN: + case DEMANGLE_COMPONENT_THUNK: + case DEMANGLE_COMPONENT_VIRTUAL_THUNK: + case DEMANGLE_COMPONENT_COVARIANT_THUNK: + case DEMANGLE_COMPONENT_JAVA_CLASS: + case DEMANGLE_COMPONENT_GUARD: + case DEMANGLE_COMPONENT_REFTEMP: + case DEMANGLE_COMPONENT_POINTER: + case DEMANGLE_COMPONENT_REFERENCE: + case DEMANGLE_COMPONENT_COMPLEX: + case DEMANGLE_COMPONENT_IMAGINARY: + case DEMANGLE_COMPONENT_VENDOR_TYPE: + case DEMANGLE_COMPONENT_ARGLIST: + case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST: + case DEMANGLE_COMPONENT_CAST: if (left == NULL) return NULL; break; /* This needs a right parameter, but the left parameter can be empty. */ - case D_COMP_ARRAY_TYPE: + case DEMANGLE_COMPONENT_ARRAY_TYPE: if (right == NULL) return NULL; break; /* These are allowed to have no parameters--in some cases they will be filled in later. */ - case D_COMP_FUNCTION_TYPE: - case D_COMP_RESTRICT: - case D_COMP_VOLATILE: - case D_COMP_CONST: - case D_COMP_RESTRICT_THIS: - case D_COMP_VOLATILE_THIS: - case D_COMP_CONST_THIS: + case DEMANGLE_COMPONENT_FUNCTION_TYPE: + case DEMANGLE_COMPONENT_RESTRICT: + case DEMANGLE_COMPONENT_VOLATILE: + case DEMANGLE_COMPONENT_CONST: + case DEMANGLE_COMPONENT_RESTRICT_THIS: + case DEMANGLE_COMPONENT_VOLATILE_THIS: + case DEMANGLE_COMPONENT_CONST_THIS: break; /* Other types should not be seen here. */ @@ -812,9 +813,10 @@ d_make_comp (di, type, left, right) return NULL; } - p = d_make_empty (di, type); + p = d_make_empty (di); if (p != NULL) { + p->type = type; p->u.s_binary.left = left; p->u.s_binary.right = right; } @@ -823,147 +825,141 @@ d_make_comp (di, type, left, right) /* Add a new name component. */ -static struct d_comp * +static struct demangle_component * d_make_name (di, s, len) struct d_info *di; const char *s; int len; { - struct d_comp *p; + struct demangle_component *p; - if (s == NULL || len == 0) + p = d_make_empty (di); + if (! cplus_demangle_fill_name (p, s, len)) return NULL; - p = d_make_empty (di, D_COMP_NAME); - if (p != NULL) - { - p->u.s_name.s = s; - p->u.s_name.len = len; - } return p; } /* Add a new builtin type component. */ -static struct d_comp * +static struct demangle_component * d_make_builtin_type (di, type) struct d_info *di; - const struct d_builtin_type_info *type; + const struct demangle_builtin_type_info *type; { - struct d_comp *p; + struct demangle_component *p; if (type == NULL) return NULL; - p = d_make_empty (di, D_COMP_BUILTIN_TYPE); + p = d_make_empty (di); if (p != NULL) - p->u.s_builtin.type = type; + { + p->type = DEMANGLE_COMPONENT_BUILTIN_TYPE; + p->u.s_builtin.type = type; + } return p; } /* Add a new operator component. */ -static struct d_comp * +static struct demangle_component * d_make_operator (di, op) struct d_info *di; - const struct d_operator_info *op; + const struct demangle_operator_info *op; { - struct d_comp *p; + struct demangle_component *p; - p = d_make_empty (di, D_COMP_OPERATOR); + p = d_make_empty (di); if (p != NULL) - p->u.s_operator.op = op; + { + p->type = DEMANGLE_COMPONENT_OPERATOR; + p->u.s_operator.op = op; + } return p; } /* Add a new extended operator component. */ -static struct d_comp * +static struct demangle_component * d_make_extended_operator (di, args, name) struct d_info *di; int args; - struct d_comp *name; + struct demangle_component *name; { - struct d_comp *p; + struct demangle_component *p; - if (name == NULL) + p = d_make_empty (di); + if (! cplus_demangle_fill_extended_operator (p, args, name)) return NULL; - p = d_make_empty (di, D_COMP_EXTENDED_OPERATOR); - if (p != NULL) - { - p->u.s_extended_operator.args = args; - p->u.s_extended_operator.name = name; - } return p; } /* Add a new constructor component. */ -static struct d_comp * +static struct demangle_component * d_make_ctor (di, kind, name) struct d_info *di; enum gnu_v3_ctor_kinds kind; - struct d_comp *name; + struct demangle_component *name; { - struct d_comp *p; + struct demangle_component *p; - if (name == NULL) + p = d_make_empty (di); + if (! cplus_demangle_fill_ctor (p, kind, name)) return NULL; - p = d_make_empty (di, D_COMP_CTOR); - if (p != NULL) - { - p->u.s_ctor.kind = kind; - p->u.s_ctor.name = name; - } return p; } /* Add a new destructor component. */ -static struct d_comp * +static struct demangle_component * d_make_dtor (di, kind, name) struct d_info *di; enum gnu_v3_dtor_kinds kind; - struct d_comp *name; + struct demangle_component *name; { - struct d_comp *p; + struct demangle_component *p; - if (name == NULL) + p = d_make_empty (di); + if (! cplus_demangle_fill_dtor (p, kind, name)) return NULL; - p = d_make_empty (di, D_COMP_DTOR); - if (p != NULL) - { - p->u.s_dtor.kind = kind; - p->u.s_dtor.name = name; - } return p; } /* Add a new template parameter. */ -static struct d_comp * +static struct demangle_component * d_make_template_param (di, i) struct d_info *di; long i; { - struct d_comp *p; + struct demangle_component *p; - p = d_make_empty (di, D_COMP_TEMPLATE_PARAM); + p = d_make_empty (di); if (p != NULL) - p->u.s_number.number = i; + { + p->type = DEMANGLE_COMPONENT_TEMPLATE_PARAM; + p->u.s_number.number = i; + } return p; } /* Add a new standard substitution component. */ -static struct d_comp * -d_make_sub (di, name) +static struct demangle_component * +d_make_sub (di, name, len) struct d_info *di; const char *name; + int len; { - struct d_comp *p; + struct demangle_component *p; - p = d_make_empty (di, D_COMP_SUB_STD); + p = d_make_empty (di); if (p != NULL) - p->u.s_string.string = name; + { + p->type = DEMANGLE_COMPONENT_SUB_STD; + p->u.s_string.string = name; + p->u.s_string.len = len; + } return p; } @@ -971,8 +967,9 @@ d_make_sub (di, name) TOP_LEVEL is non-zero when called at the top level. */ -static struct d_comp * -d_mangled_name (di, top_level) +CP_STATIC_IF_GLIBCPP_V3 +struct demangle_component * +cplus_demangle_mangled_name (di, top_level) struct d_info *di; int top_level; { @@ -994,7 +991,7 @@ d_mangled_name (di, top_level) static int has_return_type (dc) - struct d_comp *dc; + struct demangle_component *dc; { if (dc == NULL) return 0; @@ -1002,11 +999,11 @@ has_return_type (dc) { default: return 0; - case D_COMP_TEMPLATE: + case DEMANGLE_COMPONENT_TEMPLATE: return ! is_ctor_dtor_or_conversion (d_left (dc)); - case D_COMP_RESTRICT_THIS: - case D_COMP_VOLATILE_THIS: - case D_COMP_CONST_THIS: + case DEMANGLE_COMPONENT_RESTRICT_THIS: + case DEMANGLE_COMPONENT_VOLATILE_THIS: + case DEMANGLE_COMPONENT_CONST_THIS: return has_return_type (d_left (dc)); } } @@ -1016,7 +1013,7 @@ has_return_type (dc) static int is_ctor_dtor_or_conversion (dc) - struct d_comp *dc; + struct demangle_component *dc; { if (dc == NULL) return 0; @@ -1024,11 +1021,12 @@ is_ctor_dtor_or_conversion (dc) { default: return 0; - case D_COMP_QUAL_NAME: + case DEMANGLE_COMPONENT_QUAL_NAME: + case DEMANGLE_COMPONENT_LOCAL_NAME: return is_ctor_dtor_or_conversion (d_right (dc)); - case D_COMP_CTOR: - case D_COMP_DTOR: - case D_COMP_CAST: + case DEMANGLE_COMPONENT_CTOR: + case DEMANGLE_COMPONENT_DTOR: + case DEMANGLE_COMPONENT_CAST: return 1; } } @@ -1042,7 +1040,7 @@ is_ctor_dtor_or_conversion (dc) parameters. We only set this at the top level, because otherwise we would not correctly demangle names in local scopes. */ -static struct d_comp * +static struct demangle_component * d_encoding (di, top_level) struct d_info *di; int top_level; @@ -1053,7 +1051,7 @@ d_encoding (di, top_level) return d_special_name (di); else { - struct d_comp *dc; + struct demangle_component *dc; dc = d_name (di); @@ -1062,17 +1060,34 @@ d_encoding (di, top_level) /* Strip off any initial CV-qualifiers, as they really apply to the `this' parameter, and they were not output by the v2 demangler without DMGL_PARAMS. */ - while (dc->type == D_COMP_RESTRICT_THIS - || dc->type == D_COMP_VOLATILE_THIS - || dc->type == D_COMP_CONST_THIS) + while (dc->type == DEMANGLE_COMPONENT_RESTRICT_THIS + || dc->type == DEMANGLE_COMPONENT_VOLATILE_THIS + || dc->type == DEMANGLE_COMPONENT_CONST_THIS) dc = d_left (dc); + + /* If the top level is a DEMANGLE_COMPONENT_LOCAL_NAME, then + there may be CV-qualifiers on its right argument which + really apply here; this happens when parsing a class + which is local to a function. */ + if (dc->type == DEMANGLE_COMPONENT_LOCAL_NAME) + { + struct demangle_component *dcr; + + dcr = d_right (dc); + while (dcr->type == DEMANGLE_COMPONENT_RESTRICT_THIS + || dcr->type == DEMANGLE_COMPONENT_VOLATILE_THIS + || dcr->type == DEMANGLE_COMPONENT_CONST_THIS) + dcr = d_left (dcr); + dc->u.s_binary.right = dcr; + } + return dc; } peek = d_peek_char (di); if (peek == '\0' || peek == 'E') return dc; - return d_make_comp (di, D_COMP_TYPED_NAME, dc, + return d_make_comp (di, DEMANGLE_COMPONENT_TYPED_NAME, dc, d_bare_function_type (di, has_return_type (dc))); } } @@ -1089,12 +1104,12 @@ d_encoding (di, top_level) ::= <substitution> */ -static struct d_comp * +static struct demangle_component * d_name (di) struct d_info *di; { char peek = d_peek_char (di); - struct d_comp *dc; + struct demangle_component *dc; switch (peek) { @@ -1116,8 +1131,10 @@ d_name (di) else { d_advance (di, 2); - dc = d_make_comp (di, D_COMP_QUAL_NAME, d_make_name (di, "std", 3), + dc = d_make_comp (di, DEMANGLE_COMPONENT_QUAL_NAME, + d_make_name (di, "std", 3), d_unqualified_name (di)); + di->expansion += 3; subst = 0; } @@ -1138,7 +1155,8 @@ d_name (di) if (! d_add_substitution (di, dc)) return NULL; } - dc = d_make_comp (di, D_COMP_TEMPLATE, dc, d_template_args (di)); + dc = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, dc, + d_template_args (di)); } return dc; @@ -1153,7 +1171,8 @@ d_name (di) candidate. */ if (! d_add_substitution (di, dc)) return NULL; - dc = d_make_comp (di, D_COMP_TEMPLATE, dc, d_template_args (di)); + dc = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, dc, + d_template_args (di)); } return dc; } @@ -1163,12 +1182,12 @@ d_name (di) ::= N [<CV-qualifiers>] <template-prefix> <template-args> E */ -static struct d_comp * +static struct demangle_component * d_nested_name (di) struct d_info *di; { - struct d_comp *ret; - struct d_comp **pret; + struct demangle_component *ret; + struct demangle_component **pret; if (d_next_char (di) != 'N') return NULL; @@ -1198,17 +1217,17 @@ d_nested_name (di) ::= <substitution> */ -static struct d_comp * +static struct demangle_component * d_prefix (di) struct d_info *di; { - struct d_comp *ret = NULL; + struct demangle_component *ret = NULL; while (1) { char peek; - enum d_comp_type comb_type; - struct d_comp *dc; + enum demangle_component_type comb_type; + struct demangle_component *dc; peek = d_peek_char (di); if (peek == '\0') @@ -1218,7 +1237,7 @@ d_prefix (di) that in the grammar. The older code does not accept a <template-param> here. */ - comb_type = D_COMP_QUAL_NAME; + comb_type = DEMANGLE_COMPONENT_QUAL_NAME; if (IS_DIGIT (peek) || IS_LOWER (peek) || peek == 'C' @@ -1230,7 +1249,7 @@ d_prefix (di) { if (ret == NULL) return NULL; - comb_type = D_COMP_TEMPLATE; + comb_type = DEMANGLE_COMPONENT_TEMPLATE; dc = d_template_args (di); } else if (peek == 'T') @@ -1258,7 +1277,7 @@ d_prefix (di) ::= <source-name> */ -static struct d_comp * +static struct demangle_component * d_unqualified_name (di) struct d_info *di; { @@ -1268,7 +1287,14 @@ d_unqualified_name (di) if (IS_DIGIT (peek)) return d_source_name (di); else if (IS_LOWER (peek)) - return d_operator_name (di); + { + struct demangle_component *ret; + + ret = d_operator_name (di); + if (ret != NULL && ret->type == DEMANGLE_COMPONENT_OPERATOR) + di->expansion += sizeof "operator" + ret->u.s_operator.op->len - 2; + return ret; + } else if (peek == 'C' || peek == 'D') return d_ctor_dtor_name (di); else @@ -1277,12 +1303,12 @@ d_unqualified_name (di) /* <source-name> ::= <(positive length) number> <identifier> */ -static struct d_comp * +static struct demangle_component * d_source_name (di) struct d_info *di; { long len; - struct d_comp *ret; + struct demangle_component *ret; len = d_number (di); if (len <= 0) @@ -1298,15 +1324,15 @@ static long d_number (di) struct d_info *di; { - int sign; + int negative; char peek; long ret; - sign = 1; + negative = 0; peek = d_peek_char (di); if (peek == 'n') { - sign = -1; + negative = 1; d_advance (di, 1); peek = d_peek_char (di); } @@ -1315,7 +1341,11 @@ d_number (di) while (1) { if (! IS_DIGIT (peek)) - return ret * sign; + { + if (negative) + ret = - ret; + return ret; + } ret = ret * 10 + peek - '0'; d_advance (di, 1); peek = d_peek_char (di); @@ -1324,7 +1354,7 @@ d_number (di) /* identifier ::= <(unqualified source code identifier)> */ -static struct d_comp * +static struct demangle_component * d_identifier (di, len) struct d_info *di; int len; @@ -1332,8 +1362,19 @@ d_identifier (di, len) const char *name; name = d_str (di); + + if (di->send - name < len) + return NULL; + d_advance (di, len); + /* A Java mangled name may have a trailing '$' if it is a C++ + keyword. This '$' is not included in the length count. We just + ignore the '$'. */ + if ((di->options & DMGL_JAVA) != 0 + && d_peek_char (di) == '$') + d_advance (di, 1); + /* Look for something which looks like a gcc encoding of an anonymous namespace, and replace it with a more user friendly name. */ @@ -1346,8 +1387,11 @@ d_identifier (di, len) s = name + ANONYMOUS_NAMESPACE_PREFIX_LEN; if ((*s == '.' || *s == '_' || *s == '$') && s[1] == 'N') - return d_make_name (di, "(anonymous namespace)", - sizeof "(anonymous namespace)" - 1); + { + di->expansion -= len - sizeof "(anonymous namespace)"; + return d_make_name (di, "(anonymous namespace)", + sizeof "(anonymous namespace)" - 1); + } } return d_make_name (di, name, len); @@ -1358,60 +1402,64 @@ d_identifier (di, len) ::= v <digit> <source-name> */ -static const struct d_operator_info d_operators[] = -{ - { "aN", "&=", 2 }, - { "aS", "=", 2 }, - { "aa", "&&", 2 }, - { "ad", "&", 1 }, - { "an", "&", 2 }, - { "cl", "()", 0 }, - { "cm", ",", 2 }, - { "co", "~", 1 }, - { "dV", "/=", 2 }, - { "da", "delete[]", 1 }, - { "de", "*", 1 }, - { "dl", "delete", 1 }, - { "dv", "/", 2 }, - { "eO", "^=", 2 }, - { "eo", "^", 2 }, - { "eq", "==", 2 }, - { "ge", ">=", 2 }, - { "gt", ">", 2 }, - { "ix", "[]", 2 }, - { "lS", "<<=", 2 }, - { "le", "<=", 2 }, - { "ls", "<<", 2 }, - { "lt", "<", 2 }, - { "mI", "-=", 2 }, - { "mL", "*=", 2 }, - { "mi", "-", 2 }, - { "ml", "*", 2 }, - { "mm", "--", 1 }, - { "na", "new[]", 1 }, - { "ne", "!=", 2 }, - { "ng", "-", 1 }, - { "nt", "!", 1 }, - { "nw", "new", 1 }, - { "oR", "|=", 2 }, - { "oo", "||", 2 }, - { "or", "|", 2 }, - { "pL", "+=", 2 }, - { "pl", "+", 2 }, - { "pm", "->*", 2 }, - { "pp", "++", 1 }, - { "ps", "+", 1 }, - { "pt", "->", 2 }, - { "qu", "?", 3 }, - { "rM", "%=", 2 }, - { "rS", ">>=", 2 }, - { "rm", "%", 2 }, - { "rs", ">>", 2 }, - { "st", "sizeof ", 1 }, - { "sz", "sizeof ", 1 } +#define NL(s) s, (sizeof s) - 1 + +CP_STATIC_IF_GLIBCPP_V3 +const struct demangle_operator_info cplus_demangle_operators[] = +{ + { "aN", NL ("&="), 2 }, + { "aS", NL ("="), 2 }, + { "aa", NL ("&&"), 2 }, + { "ad", NL ("&"), 1 }, + { "an", NL ("&"), 2 }, + { "cl", NL ("()"), 0 }, + { "cm", NL (","), 2 }, + { "co", NL ("~"), 1 }, + { "dV", NL ("/="), 2 }, + { "da", NL ("delete[]"), 1 }, + { "de", NL ("*"), 1 }, + { "dl", NL ("delete"), 1 }, + { "dv", NL ("/"), 2 }, + { "eO", NL ("^="), 2 }, + { "eo", NL ("^"), 2 }, + { "eq", NL ("=="), 2 }, + { "ge", NL (">="), 2 }, + { "gt", NL (">"), 2 }, + { "ix", NL ("[]"), 2 }, + { "lS", NL ("<<="), 2 }, + { "le", NL ("<="), 2 }, + { "ls", NL ("<<"), 2 }, + { "lt", NL ("<"), 2 }, + { "mI", NL ("-="), 2 }, + { "mL", NL ("*="), 2 }, + { "mi", NL ("-"), 2 }, + { "ml", NL ("*"), 2 }, + { "mm", NL ("--"), 1 }, + { "na", NL ("new[]"), 1 }, + { "ne", NL ("!="), 2 }, + { "ng", NL ("-"), 1 }, + { "nt", NL ("!"), 1 }, + { "nw", NL ("new"), 1 }, + { "oR", NL ("|="), 2 }, + { "oo", NL ("||"), 2 }, + { "or", NL ("|"), 2 }, + { "pL", NL ("+="), 2 }, + { "pl", NL ("+"), 2 }, + { "pm", NL ("->*"), 2 }, + { "pp", NL ("++"), 1 }, + { "ps", NL ("+"), 1 }, + { "pt", NL ("->"), 2 }, + { "qu", NL ("?"), 3 }, + { "rM", NL ("%="), 2 }, + { "rS", NL (">>="), 2 }, + { "rm", NL ("%"), 2 }, + { "rs", NL (">>"), 2 }, + { "st", NL ("sizeof "), 1 }, + { "sz", NL ("sizeof "), 1 }, + { NULL, NULL, 0, 0 } }; -static struct d_comp * +static struct demangle_component * d_operator_name (di) struct d_info *di; { @@ -1423,19 +1471,25 @@ d_operator_name (di) if (c1 == 'v' && IS_DIGIT (c2)) return d_make_extended_operator (di, c2 - '0', d_source_name (di)); else if (c1 == 'c' && c2 == 'v') - return d_make_comp (di, D_COMP_CAST, d_type (di), NULL); + return d_make_comp (di, DEMANGLE_COMPONENT_CAST, + cplus_demangle_type (di), NULL); else { + /* LOW is the inclusive lower bound. */ int low = 0; - int high = sizeof (d_operators) / sizeof (d_operators[0]); + /* HIGH is the exclusive upper bound. We subtract one to ignore + the sentinel at the end of the array. */ + int high = ((sizeof (cplus_demangle_operators) + / sizeof (cplus_demangle_operators[0])) + - 1); while (1) { int i; - const struct d_operator_info *p; + const struct demangle_operator_info *p; i = low + (high - low) / 2; - p = d_operators + i; + p = cplus_demangle_operators + i; if (c1 == p->code[0] && c2 == p->code[1]) return d_make_operator (di, p); @@ -1464,68 +1518,79 @@ d_operator_name (di) ::= GR <name> */ -static struct d_comp * +static struct demangle_component * d_special_name (di) struct d_info *di; { char c; + di->expansion += 20; c = d_next_char (di); if (c == 'T') { switch (d_next_char (di)) { case 'V': - return d_make_comp (di, D_COMP_VTABLE, d_type (di), NULL); + di->expansion -= 5; + return d_make_comp (di, DEMANGLE_COMPONENT_VTABLE, + cplus_demangle_type (di), NULL); case 'T': - return d_make_comp (di, D_COMP_VTT, d_type (di), NULL); + di->expansion -= 10; + return d_make_comp (di, DEMANGLE_COMPONENT_VTT, + cplus_demangle_type (di), NULL); case 'I': - return d_make_comp (di, D_COMP_TYPEINFO, d_type (di), NULL); + return d_make_comp (di, DEMANGLE_COMPONENT_TYPEINFO, + cplus_demangle_type (di), NULL); case 'S': - return d_make_comp (di, D_COMP_TYPEINFO_NAME, d_type (di), NULL); + return d_make_comp (di, DEMANGLE_COMPONENT_TYPEINFO_NAME, + cplus_demangle_type (di), NULL); case 'h': if (! d_call_offset (di, 'h')) return NULL; - return d_make_comp (di, D_COMP_THUNK, d_encoding (di, 0), NULL); + return d_make_comp (di, DEMANGLE_COMPONENT_THUNK, + d_encoding (di, 0), NULL); case 'v': if (! d_call_offset (di, 'v')) return NULL; - return d_make_comp (di, D_COMP_VIRTUAL_THUNK, d_encoding (di, 0), - NULL); + return d_make_comp (di, DEMANGLE_COMPONENT_VIRTUAL_THUNK, + d_encoding (di, 0), NULL); case 'c': if (! d_call_offset (di, '\0')) return NULL; if (! d_call_offset (di, '\0')) return NULL; - return d_make_comp (di, D_COMP_COVARIANT_THUNK, d_encoding (di, 0), - NULL); + return d_make_comp (di, DEMANGLE_COMPONENT_COVARIANT_THUNK, + d_encoding (di, 0), NULL); case 'C': { - struct d_comp *derived_type; + struct demangle_component *derived_type; long offset; - struct d_comp *base_type; + struct demangle_component *base_type; - derived_type = d_type (di); + derived_type = cplus_demangle_type (di); offset = d_number (di); if (offset < 0) return NULL; if (d_next_char (di) != '_') return NULL; - base_type = d_type (di); + base_type = cplus_demangle_type (di); /* We don't display the offset. FIXME: We should display it in verbose mode. */ - return d_make_comp (di, D_COMP_CONSTRUCTION_VTABLE, base_type, - derived_type); + di->expansion += 5; + return d_make_comp (di, DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE, + base_type, derived_type); } case 'F': - return d_make_comp (di, D_COMP_TYPEINFO_FN, d_type (di), NULL); + return d_make_comp (di, DEMANGLE_COMPONENT_TYPEINFO_FN, + cplus_demangle_type (di), NULL); case 'J': - return d_make_comp (di, D_COMP_JAVA_CLASS, d_type (di), NULL); + return d_make_comp (di, DEMANGLE_COMPONENT_JAVA_CLASS, + cplus_demangle_type (di), NULL); default: return NULL; @@ -1536,10 +1601,11 @@ d_special_name (di) switch (d_next_char (di)) { case 'V': - return d_make_comp (di, D_COMP_GUARD, d_name (di), NULL); + return d_make_comp (di, DEMANGLE_COMPONENT_GUARD, d_name (di), NULL); case 'R': - return d_make_comp (di, D_COMP_REFTEMP, d_name (di), NULL); + return d_make_comp (di, DEMANGLE_COMPONENT_REFTEMP, d_name (di), + NULL); default: return NULL; @@ -1599,10 +1665,17 @@ d_call_offset (di, c) ::= D2 */ -static struct d_comp * +static struct demangle_component * d_ctor_dtor_name (di) struct d_info *di; { + if (di->last_name != NULL) + { + if (di->last_name->type == DEMANGLE_COMPONENT_NAME) + di->expansion += di->last_name->u.s_name.len; + else if (di->last_name->type == DEMANGLE_COMPONENT_SUB_STD) + di->expansion += di->last_name->u.s_string.len; + } switch (d_next_char (di)) { case 'C': @@ -1671,42 +1744,45 @@ d_ctor_dtor_name (di) ::= u <source-name> */ -static const struct d_builtin_type_info d_builtin_types[26] = -{ - /* a */ { "signed char", "signed char", D_PRINT_INT }, - /* b */ { "bool", "boolean", D_PRINT_BOOL }, - /* c */ { "char", "byte", D_PRINT_INT }, - /* d */ { "double", "double", D_PRINT_DEFAULT }, - /* e */ { "long double", "long double", D_PRINT_DEFAULT }, - /* f */ { "float", "float", D_PRINT_DEFAULT }, - /* g */ { "__float128", "__float128", D_PRINT_DEFAULT }, - /* h */ { "unsigned char", "unsigned char", D_PRINT_INT }, - /* i */ { "int", "int", D_PRINT_INT }, - /* j */ { "unsigned int", "unsigned", D_PRINT_INT }, - /* k */ { NULL, NULL, D_PRINT_DEFAULT }, - /* l */ { "long", "long", D_PRINT_LONG }, - /* m */ { "unsigned long", "unsigned long", D_PRINT_LONG }, - /* n */ { "__int128", "__int128", D_PRINT_DEFAULT }, - /* o */ { "unsigned __int128", "unsigned __int128", D_PRINT_DEFAULT }, - /* p */ { NULL, NULL, D_PRINT_DEFAULT }, - /* q */ { NULL, NULL, D_PRINT_DEFAULT }, - /* r */ { NULL, NULL, D_PRINT_DEFAULT }, - /* s */ { "short", "short", D_PRINT_INT }, - /* t */ { "unsigned short", "unsigned short", D_PRINT_INT }, - /* u */ { NULL, NULL, D_PRINT_DEFAULT }, - /* v */ { "void", "void", D_PRINT_VOID }, - /* w */ { "wchar_t", "char", D_PRINT_INT }, - /* x */ { "long long", "long", D_PRINT_DEFAULT }, - /* y */ { "unsigned long long", "unsigned long long", D_PRINT_DEFAULT }, - /* z */ { "...", "...", D_PRINT_DEFAULT }, +CP_STATIC_IF_GLIBCPP_V3 +const struct demangle_builtin_type_info +cplus_demangle_builtin_types[D_BUILTIN_TYPE_COUNT] = +{ + /* a */ { NL ("signed char"), NL ("signed char"), D_PRINT_INT }, + /* 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 }, + /* i */ { NL ("int"), NL ("int"), D_PRINT_INT }, + /* j */ { NL ("unsigned int"), NL ("unsigned"), D_PRINT_INT }, + /* 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 }, + /* n */ { NL ("__int128"), NL ("__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 }, + /* 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 }, + /* z */ { NL ("..."), NL ("..."), D_PRINT_DEFAULT }, }; -static struct d_comp * -d_type (di) +CP_STATIC_IF_GLIBCPP_V3 +struct demangle_component * +cplus_demangle_type (di) struct d_info *di; { char peek; - struct d_comp *ret; + struct demangle_component *ret; int can_subst; /* The ABI specifies that when CV-qualifiers are used, the base type @@ -1727,12 +1803,12 @@ d_type (di) peek = d_peek_char (di); if (peek == 'r' || peek == 'V' || peek == 'K') { - struct d_comp **pret; + struct demangle_component **pret; pret = d_cv_qualifiers (di, &ret, 0); if (pret == NULL) return NULL; - *pret = d_type (di); + *pret = cplus_demangle_type (di); if (! d_add_substitution (di, ret)) return NULL; return ret; @@ -1746,14 +1822,17 @@ d_type (di) case 'h': case 'i': case 'j': case 'l': case 'm': case 'n': case 'o': case 's': case 't': case 'v': case 'w': case 'x': case 'y': case 'z': - ret = d_make_builtin_type (di, &d_builtin_types[peek - 'a']); + ret = d_make_builtin_type (di, + &cplus_demangle_builtin_types[peek - 'a']); + di->expansion += ret->u.s_builtin.type->len; can_subst = 0; d_advance (di, 1); break; case 'u': d_advance (di, 1); - ret = d_make_comp (di, D_COMP_VENDOR_TYPE, d_source_name (di), NULL); + ret = d_make_comp (di, DEMANGLE_COMPONENT_VENDOR_TYPE, + d_source_name (di), NULL); break; case 'F': @@ -1784,7 +1863,8 @@ d_type (di) candidate. */ if (! d_add_substitution (di, ret)) return NULL; - ret = d_make_comp (di, D_COMP_TEMPLATE, ret, d_template_args (di)); + ret = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, ret, + d_template_args (di)); } break; @@ -1803,7 +1883,7 @@ d_type (di) /* The substituted name may have been a template name and may be followed by tepmlate args. */ if (d_peek_char (di) == 'I') - ret = d_make_comp (di, D_COMP_TEMPLATE, ret, + ret = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, ret, d_template_args (di)); else can_subst = 0; @@ -1815,7 +1895,7 @@ d_type (di) a new substitution candidate. However, if the substitution was followed by template arguments, then the whole thing is a substitution candidate. */ - if (ret != NULL && ret->type == D_COMP_SUB_STD) + if (ret != NULL && ret->type == DEMANGLE_COMPONENT_SUB_STD) can_subst = 0; } } @@ -1823,28 +1903,33 @@ d_type (di) case 'P': d_advance (di, 1); - ret = d_make_comp (di, D_COMP_POINTER, d_type (di), NULL); + ret = d_make_comp (di, DEMANGLE_COMPONENT_POINTER, + cplus_demangle_type (di), NULL); break; case 'R': d_advance (di, 1); - ret = d_make_comp (di, D_COMP_REFERENCE, d_type (di), NULL); + ret = d_make_comp (di, DEMANGLE_COMPONENT_REFERENCE, + cplus_demangle_type (di), NULL); break; case 'C': d_advance (di, 1); - ret = d_make_comp (di, D_COMP_COMPLEX, d_type (di), NULL); + ret = d_make_comp (di, DEMANGLE_COMPONENT_COMPLEX, + cplus_demangle_type (di), NULL); break; case 'G': d_advance (di, 1); - ret = d_make_comp (di, D_COMP_IMAGINARY, d_type (di), NULL); + ret = d_make_comp (di, DEMANGLE_COMPONENT_IMAGINARY, + cplus_demangle_type (di), NULL); break; case 'U': d_advance (di, 1); ret = d_source_name (di); - ret = d_make_comp (di, D_COMP_VENDOR_TYPE_QUAL, d_type (di), ret); + ret = d_make_comp (di, DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL, + cplus_demangle_type (di), ret); break; default: @@ -1862,10 +1947,10 @@ d_type (di) /* <CV-qualifiers> ::= [r] [V] [K] */ -static struct d_comp ** +static struct demangle_component ** d_cv_qualifiers (di, pret, member_fn) struct d_info *di; - struct d_comp **pret; + struct demangle_component **pret; int member_fn; { char peek; @@ -1873,15 +1958,30 @@ d_cv_qualifiers (di, pret, member_fn) peek = d_peek_char (di); while (peek == 'r' || peek == 'V' || peek == 'K') { - enum d_comp_type t; + enum demangle_component_type t; d_advance (di, 1); if (peek == 'r') - t = member_fn ? D_COMP_RESTRICT_THIS: D_COMP_RESTRICT; + { + t = (member_fn + ? DEMANGLE_COMPONENT_RESTRICT_THIS + : DEMANGLE_COMPONENT_RESTRICT); + di->expansion += sizeof "restrict"; + } else if (peek == 'V') - t = member_fn ? D_COMP_VOLATILE_THIS : D_COMP_VOLATILE; + { + t = (member_fn + ? DEMANGLE_COMPONENT_VOLATILE_THIS + : DEMANGLE_COMPONENT_VOLATILE); + di->expansion += sizeof "volatile"; + } else - t = member_fn ? D_COMP_CONST_THIS: D_COMP_CONST; + { + t = (member_fn + ? DEMANGLE_COMPONENT_CONST_THIS + : DEMANGLE_COMPONENT_CONST); + di->expansion += sizeof "const"; + } *pret = d_make_comp (di, t, NULL, NULL); if (*pret == NULL) @@ -1896,11 +1996,11 @@ d_cv_qualifiers (di, pret, member_fn) /* <function-type> ::= F [Y] <bare-function-type> E */ -static struct d_comp * +static struct demangle_component * d_function_type (di) struct d_info *di; { - struct d_comp *ret; + struct demangle_component *ret; if (d_next_char (di) != 'F') return NULL; @@ -1918,14 +2018,14 @@ d_function_type (di) /* <bare-function-type> ::= <type>+ */ -static struct d_comp * +static struct demangle_component * d_bare_function_type (di, has_return_type) struct d_info *di; int has_return_type; { - struct d_comp *return_type; - struct d_comp *tl; - struct d_comp **ptl; + struct demangle_component *return_type; + struct demangle_component *tl; + struct demangle_component **ptl; return_type = NULL; tl = NULL; @@ -1933,12 +2033,12 @@ d_bare_function_type (di, has_return_type) while (1) { char peek; - struct d_comp *type; + struct demangle_component *type; peek = d_peek_char (di); if (peek == '\0' || peek == 'E') break; - type = d_type (di); + type = cplus_demangle_type (di); if (type == NULL) return NULL; if (has_return_type) @@ -1948,7 +2048,7 @@ d_bare_function_type (di, has_return_type) } else { - *ptl = d_make_comp (di, D_COMP_ARGLIST, type, NULL); + *ptl = d_make_comp (di, DEMANGLE_COMPONENT_ARGLIST, type, NULL); if (*ptl == NULL) return NULL; ptl = &d_right (*ptl); @@ -1963,16 +2063,19 @@ d_bare_function_type (di, has_return_type) /* If we have a single parameter type void, omit it. */ if (d_right (tl) == NULL - && d_left (tl)->type == D_COMP_BUILTIN_TYPE + && d_left (tl)->type == DEMANGLE_COMPONENT_BUILTIN_TYPE && d_left (tl)->u.s_builtin.type->print == D_PRINT_VOID) - tl = NULL; + { + di->expansion -= d_left (tl)->u.s_builtin.type->len; + tl = NULL; + } - return d_make_comp (di, D_COMP_FUNCTION_TYPE, return_type, tl); + return d_make_comp (di, DEMANGLE_COMPONENT_FUNCTION_TYPE, return_type, tl); } /* <class-enum-type> ::= <name> */ -static struct d_comp * +static struct demangle_component * d_class_enum_type (di) struct d_info *di; { @@ -1983,12 +2086,12 @@ d_class_enum_type (di) ::= A [<(dimension) expression>] _ <(element) type> */ -static struct d_comp * +static struct demangle_component * d_array_type (di) struct d_info *di; { char peek; - struct d_comp *dim; + struct demangle_component *dim; if (d_next_char (di) != 'A') return NULL; @@ -2021,23 +2124,24 @@ d_array_type (di) if (d_next_char (di) != '_') return NULL; - return d_make_comp (di, D_COMP_ARRAY_TYPE, dim, d_type (di)); + return d_make_comp (di, DEMANGLE_COMPONENT_ARRAY_TYPE, dim, + cplus_demangle_type (di)); } /* <pointer-to-member-type> ::= M <(class) type> <(member) type> */ -static struct d_comp * +static struct demangle_component * d_pointer_to_member_type (di) struct d_info *di; { - struct d_comp *cl; - struct d_comp *mem; - struct d_comp **pmem; + struct demangle_component *cl; + struct demangle_component *mem; + struct demangle_component **pmem; if (d_next_char (di) != 'M') return NULL; - cl = d_type (di); + cl = cplus_demangle_type (di); /* The ABI specifies that any type can be a substitution source, and that M is followed by two types, and that when a CV-qualified @@ -2050,21 +2154,21 @@ d_pointer_to_member_type (di) g++ does not work that way. g++ treats only the CV-qualified member function as a substitution source. FIXME. So to work with g++, we need to pull off the CV-qualifiers here, in order to - avoid calling add_substitution() in d_type(). */ + avoid calling add_substitution() in cplus_demangle_type(). */ pmem = d_cv_qualifiers (di, &mem, 1); if (pmem == NULL) return NULL; - *pmem = d_type (di); + *pmem = cplus_demangle_type (di); - return d_make_comp (di, D_COMP_PTRMEM_TYPE, cl, mem); + return d_make_comp (di, DEMANGLE_COMPONENT_PTRMEM_TYPE, cl, mem); } /* <template-param> ::= T_ ::= T <(parameter-2 non-negative) number> _ */ -static struct d_comp * +static struct demangle_component * d_template_param (di) struct d_info *di; { @@ -2086,18 +2190,20 @@ d_template_param (di) if (d_next_char (di) != '_') return NULL; + ++di->did_subs; + return d_make_template_param (di, param); } /* <template-args> ::= I <template-arg>+ E */ -static struct d_comp * +static struct demangle_component * d_template_args (di) struct d_info *di; { - struct d_comp *hold_last_name; - struct d_comp *al; - struct d_comp **pal; + struct demangle_component *hold_last_name; + struct demangle_component *al; + struct demangle_component **pal; /* Preserve the last name we saw--don't let the template arguments clobber it, as that would give us the wrong name for a subsequent @@ -2111,13 +2217,13 @@ d_template_args (di) pal = &al; while (1) { - struct d_comp *a; + struct demangle_component *a; a = d_template_arg (di); if (a == NULL) return NULL; - *pal = d_make_comp (di, D_COMP_TEMPLATE_ARGLIST, a, NULL); + *pal = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE_ARGLIST, a, NULL); if (*pal == NULL) return NULL; pal = &d_right (*pal); @@ -2139,11 +2245,11 @@ d_template_args (di) ::= <expr-primary> */ -static struct d_comp * +static struct demangle_component * d_template_arg (di) struct d_info *di; { - struct d_comp *ret; + struct demangle_component *ret; switch (d_peek_char (di)) { @@ -2158,7 +2264,7 @@ d_template_arg (di) return d_expr_primary (di); default: - return d_type (di); + return cplus_demangle_type (di); } } @@ -2172,7 +2278,7 @@ d_template_arg (di) ::= <expr-primary> */ -static struct d_comp * +static struct demangle_component * d_expression (di) struct d_info *di; { @@ -2185,43 +2291,47 @@ d_expression (di) return d_template_param (di); else if (peek == 's' && d_peek_next_char (di) == 'r') { - struct d_comp *type; - struct d_comp *name; + struct demangle_component *type; + struct demangle_component *name; d_advance (di, 2); - type = d_type (di); + type = cplus_demangle_type (di); name = d_unqualified_name (di); if (d_peek_char (di) != 'I') - return d_make_comp (di, D_COMP_QUAL_NAME, type, name); + return d_make_comp (di, DEMANGLE_COMPONENT_QUAL_NAME, type, name); else - return d_make_comp (di, D_COMP_QUAL_NAME, type, - d_make_comp (di, D_COMP_TEMPLATE, name, + return d_make_comp (di, DEMANGLE_COMPONENT_QUAL_NAME, type, + d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, name, d_template_args (di))); } else { - struct d_comp *op; + struct demangle_component *op; int args; op = d_operator_name (di); if (op == NULL) return NULL; - if (op->type == D_COMP_OPERATOR + if (op->type == DEMANGLE_COMPONENT_OPERATOR) + di->expansion += op->u.s_operator.op->len - 2; + + if (op->type == DEMANGLE_COMPONENT_OPERATOR && strcmp (op->u.s_operator.op->code, "st") == 0) - return d_make_comp (di, D_COMP_UNARY, op, d_type (di)); + return d_make_comp (di, DEMANGLE_COMPONENT_UNARY, op, + cplus_demangle_type (di)); switch (op->type) { default: return NULL; - case D_COMP_OPERATOR: + case DEMANGLE_COMPONENT_OPERATOR: args = op->u.s_operator.op->args; break; - case D_COMP_EXTENDED_OPERATOR: + case DEMANGLE_COMPONENT_EXTENDED_OPERATOR: args = op->u.s_extended_operator.args; break; - case D_COMP_CAST: + case DEMANGLE_COMPONENT_CAST: args = 1; break; } @@ -2229,27 +2339,32 @@ d_expression (di) switch (args) { case 1: - return d_make_comp (di, D_COMP_UNARY, op, d_expression (di)); + return d_make_comp (di, DEMANGLE_COMPONENT_UNARY, op, + d_expression (di)); case 2: { - struct d_comp *left; + struct demangle_component *left; left = d_expression (di); - return d_make_comp (di, D_COMP_BINARY, op, - d_make_comp (di, D_COMP_BINARY_ARGS, left, + return d_make_comp (di, DEMANGLE_COMPONENT_BINARY, op, + d_make_comp (di, + DEMANGLE_COMPONENT_BINARY_ARGS, + left, d_expression (di))); } case 3: { - struct d_comp *first; - struct d_comp *second; + struct demangle_component *first; + struct demangle_component *second; first = d_expression (di); second = d_expression (di); - return d_make_comp (di, D_COMP_TRINARY, op, - d_make_comp (di, D_COMP_TRINARY_ARG1, first, + return d_make_comp (di, DEMANGLE_COMPONENT_TRINARY, op, + d_make_comp (di, + DEMANGLE_COMPONENT_TRINARY_ARG1, + first, d_make_comp (di, - D_COMP_TRINARY_ARG2, + DEMANGLE_COMPONENT_TRINARY_ARG2, second, d_expression (di)))); } @@ -2264,23 +2379,29 @@ d_expression (di) ::= L <mangled-name> E */ -static struct d_comp * +static struct demangle_component * d_expr_primary (di) struct d_info *di; { - struct d_comp *ret; + struct demangle_component *ret; if (d_next_char (di) != 'L') return NULL; if (d_peek_char (di) == '_') - ret = d_mangled_name (di, 0); + ret = cplus_demangle_mangled_name (di, 0); else { - struct d_comp *type; - enum d_comp_type t; + struct demangle_component *type; + enum demangle_component_type t; const char *s; - type = d_type (di); + type = cplus_demangle_type (di); + + /* If we have a type we know how to print, we aren't going to + print the type name itself. */ + if (type->type == DEMANGLE_COMPONENT_BUILTIN_TYPE + && type->u.s_builtin.type->print != D_PRINT_DEFAULT) + di->expansion -= type->u.s_builtin.type->len; /* Rather than try to interpret the literal value, we just collect it as a string. Note that it's possible to have a @@ -2293,10 +2414,10 @@ d_expr_primary (di) constant in any readable form anyhow. We don't attempt to handle these cases. */ - t = D_COMP_LITERAL; + t = DEMANGLE_COMPONENT_LITERAL; if (d_peek_char (di) == 'n') { - t = D_COMP_LITERAL_NEG; + t = DEMANGLE_COMPONENT_LITERAL_NEG; d_advance (di, 1); } s = d_str (di); @@ -2313,11 +2434,11 @@ d_expr_primary (di) ::= Z <(function) encoding> E s [<discriminator>] */ -static struct d_comp * +static struct demangle_component * d_local_name (di) struct d_info *di; { - struct d_comp *function; + struct demangle_component *function; if (d_next_char (di) != 'Z') return NULL; @@ -2332,18 +2453,18 @@ d_local_name (di) d_advance (di, 1); if (! d_discriminator (di)) return NULL; - return d_make_comp (di, D_COMP_QUAL_NAME, function, + return d_make_comp (di, DEMANGLE_COMPONENT_LOCAL_NAME, function, d_make_name (di, "string literal", sizeof "string literal" - 1)); } else { - struct d_comp *name; + struct demangle_component *name; name = d_name (di); if (! d_discriminator (di)) return NULL; - return d_make_comp (di, D_COMP_QUAL_NAME, function, name); + return d_make_comp (di, DEMANGLE_COMPONENT_LOCAL_NAME, function, name); } } @@ -2372,7 +2493,7 @@ d_discriminator (di) static int d_add_substitution (di, dc) struct d_info *di; - struct d_comp *dc; + struct demangle_component *dc; { if (dc == NULL) return 0; @@ -2404,24 +2525,30 @@ d_add_substitution (di, dc) static const struct d_standard_sub_info standard_subs[] = { - { 't', "std", "std", NULL }, - { 'a', "std::allocator", "std::allocator", "allocator" }, - { 'b', "std::basic_string", "std::basic_string", "basic_string" }, - { 's', "std::string", - "std::basic_string<char, std::char_traits<char>, std::allocator<char> >", - "basic_string" }, - { 'i', "std::istream", - "std::basic_istream<char, std::char_traits<char> >", - "basic_istream" }, - { 'o', "std::ostream", - "std::basic_ostream<char, std::char_traits<char> >", - "basic_ostream" }, - { 'd', "std::iostream", - "std::basic_iostream<char, std::char_traits<char> >", - "basic_iostream" } + { 't', NL ("std"), + NL ("std"), + NULL, 0 }, + { 'a', NL ("std::allocator"), + NL ("std::allocator"), + NL ("allocator") }, + { 'b', NL ("std::basic_string"), + NL ("std::basic_string"), + NL ("basic_string") }, + { 's', NL ("std::string"), + NL ("std::basic_string<char, std::char_traits<char>, std::allocator<char> >"), + NL ("basic_string") }, + { 'i', NL ("std::istream"), + NL ("std::basic_istream<char, std::char_traits<char> >"), + NL ("basic_istream") }, + { 'o', NL ("std::ostream"), + NL ("std::basic_ostream<char, std::char_traits<char> >"), + NL ("basic_ostream") }, + { 'd', NL ("std::iostream"), + NL ("std::basic_iostream<char, std::char_traits<char> >"), + NL ("basic_iostream") } }; -static struct d_comp * +static struct demangle_component * d_substitution (di, prefix) struct d_info *di; int prefix; @@ -2457,6 +2584,8 @@ d_substitution (di, prefix) if (id >= di->next_sub) return NULL; + ++di->did_subs; + return di->subs[id]; } else @@ -2481,12 +2610,24 @@ d_substitution (di, prefix) { if (c == p->code) { + const char *s; + int len; + if (p->set_last_name != NULL) - di->last_name = d_make_sub (di, p->set_last_name); + di->last_name = d_make_sub (di, p->set_last_name, + p->set_last_name_len); if (verbose) - return d_make_sub (di, p->full_expansion); + { + s = p->full_expansion; + len = p->full_len; + } else - return d_make_sub (di, p->simple_expansion); + { + s = p->simple_expansion; + len = p->simple_len; + } + di->expansion += len; + return d_make_sub (di, s, len); } } @@ -2578,22 +2719,27 @@ d_print_error (dpi) dpi->buf = NULL; } -/* Turn components into a human readable string. Returns a string - allocated by malloc, or NULL on error. On success, this sets *PALC - to the size of the allocated buffer. On failure, this sets *PALC - to 0 for a bad parse, or to 1 for a memory allocation failure. */ +/* Turn components into a human readable string. OPTIONS is the + options bits passed to the demangler. DC is the tree to print. + ESTIMATE is a guess at the length of the result. This returns a + string allocated by malloc, or NULL on error. On success, this + sets *PALC to the size of the allocated buffer. On failure, this + sets *PALC to 0 for a bad parse, or to 1 for a memory allocation + failure. */ -static char * -d_print (options, dc, palc) +CP_STATIC_IF_GLIBCPP_V3 +char * +cplus_demangle_print (options, dc, estimate, palc) int options; - const struct d_comp *dc; + const struct demangle_component *dc; + int estimate; size_t *palc; { struct d_print_info dpi; dpi.options = options; - dpi.alc = 64; + dpi.alc = estimate + 1; dpi.buf = malloc (dpi.alc); if (dpi.buf == NULL) { @@ -2624,7 +2770,7 @@ d_print (options, dc, palc) static void d_print_comp (dpi, dc) struct d_print_info *dpi; - const struct d_comp *dc; + const struct demangle_component *dc; { if (dc == NULL) { @@ -2636,20 +2782,27 @@ d_print_comp (dpi, dc) switch (dc->type) { - case D_COMP_NAME: - d_print_identifier (dpi, dc->u.s_name.s, dc->u.s_name.len); + case DEMANGLE_COMPONENT_NAME: + if ((dpi->options & DMGL_JAVA) == 0) + d_append_buffer (dpi, dc->u.s_name.s, dc->u.s_name.len); + else + d_print_java_identifier (dpi, dc->u.s_name.s, dc->u.s_name.len); return; - case D_COMP_QUAL_NAME: + case DEMANGLE_COMPONENT_QUAL_NAME: + case DEMANGLE_COMPONENT_LOCAL_NAME: d_print_comp (dpi, d_left (dc)); - d_append_string (dpi, (dpi->options & DMGL_JAVA) == 0 ? "::" : "."); + if ((dpi->options & DMGL_JAVA) == 0) + d_append_string_constant (dpi, "::"); + else + d_append_char (dpi, '.'); d_print_comp (dpi, d_right (dc)); return; - case D_COMP_TYPED_NAME: + case DEMANGLE_COMPONENT_TYPED_NAME: { struct d_print_mod *hold_modifiers; - struct d_comp *typed_name; + struct demangle_component *typed_name; struct d_print_mod adpm[4]; unsigned int i; struct d_print_template dpt; @@ -2675,9 +2828,9 @@ d_print_comp (dpi, dc) adpm[i].templates = dpi->templates; ++i; - if (typed_name->type != D_COMP_RESTRICT_THIS - && typed_name->type != D_COMP_VOLATILE_THIS - && typed_name->type != D_COMP_CONST_THIS) + if (typed_name->type != DEMANGLE_COMPONENT_RESTRICT_THIS + && typed_name->type != DEMANGLE_COMPONENT_VOLATILE_THIS + && typed_name->type != DEMANGLE_COMPONENT_CONST_THIS) break; typed_name = d_left (typed_name); @@ -2685,16 +2838,48 @@ d_print_comp (dpi, dc) /* If typed_name is a template, then it applies to the function type as well. */ - if (typed_name->type == D_COMP_TEMPLATE) + if (typed_name->type == DEMANGLE_COMPONENT_TEMPLATE) { dpt.next = dpi->templates; dpi->templates = &dpt; dpt.template = typed_name; } + /* If typed_name is a DEMANGLE_COMPONENT_LOCAL_NAME, then + there may be CV-qualifiers on its right argument which + really apply here; this happens when parsing a class which + is local to a function. */ + if (typed_name->type == DEMANGLE_COMPONENT_LOCAL_NAME) + { + struct demangle_component *local_name; + + local_name = d_right (typed_name); + while (local_name->type == DEMANGLE_COMPONENT_RESTRICT_THIS + || local_name->type == DEMANGLE_COMPONENT_VOLATILE_THIS + || local_name->type == DEMANGLE_COMPONENT_CONST_THIS) + { + if (i >= sizeof adpm / sizeof adpm[0]) + { + d_print_error (dpi); + return; + } + + adpm[i] = adpm[i - 1]; + adpm[i].next = &adpm[i - 1]; + dpi->modifiers = &adpm[i]; + + adpm[i - 1].mod = local_name; + adpm[i - 1].printed = 0; + adpm[i - 1].templates = dpi->templates; + ++i; + + local_name = d_left (local_name); + } + } + d_print_comp (dpi, d_right (dc)); - if (typed_name->type == D_COMP_TEMPLATE) + if (typed_name->type == DEMANGLE_COMPONENT_TEMPLATE) dpi->templates = dpt.next; /* If the modifiers didn't get printed by the type, print them @@ -2714,7 +2899,7 @@ d_print_comp (dpi, dc) return; } - case D_COMP_TEMPLATE: + case DEMANGLE_COMPONENT_TEMPLATE: { struct d_print_mod *hold_dpm; @@ -2741,10 +2926,10 @@ d_print_comp (dpi, dc) return; } - case D_COMP_TEMPLATE_PARAM: + case DEMANGLE_COMPONENT_TEMPLATE_PARAM: { long i; - struct d_comp *a; + struct demangle_component *a; struct d_print_template *hold_dpt; if (dpi->templates == NULL) @@ -2757,7 +2942,7 @@ d_print_comp (dpi, dc) a != NULL; a = d_right (a)) { - if (a->type != D_COMP_TEMPLATE_ARGLIST) + if (a->type != DEMANGLE_COMPONENT_TEMPLATE_ARGLIST) { d_print_error (dpi); return; @@ -2787,92 +2972,92 @@ d_print_comp (dpi, dc) return; } - case D_COMP_CTOR: + case DEMANGLE_COMPONENT_CTOR: d_print_comp (dpi, dc->u.s_ctor.name); return; - case D_COMP_DTOR: + case DEMANGLE_COMPONENT_DTOR: d_append_char (dpi, '~'); d_print_comp (dpi, dc->u.s_dtor.name); return; - case D_COMP_VTABLE: - d_append_string (dpi, "vtable for "); + case DEMANGLE_COMPONENT_VTABLE: + d_append_string_constant (dpi, "vtable for "); d_print_comp (dpi, d_left (dc)); return; - case D_COMP_VTT: - d_append_string (dpi, "VTT for "); + case DEMANGLE_COMPONENT_VTT: + d_append_string_constant (dpi, "VTT for "); d_print_comp (dpi, d_left (dc)); return; - case D_COMP_CONSTRUCTION_VTABLE: - d_append_string (dpi, "construction vtable for "); + case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE: + d_append_string_constant (dpi, "construction vtable for "); d_print_comp (dpi, d_left (dc)); - d_append_string (dpi, "-in-"); + d_append_string_constant (dpi, "-in-"); d_print_comp (dpi, d_right (dc)); return; - case D_COMP_TYPEINFO: - d_append_string (dpi, "typeinfo for "); + case DEMANGLE_COMPONENT_TYPEINFO: + d_append_string_constant (dpi, "typeinfo for "); d_print_comp (dpi, d_left (dc)); return; - case D_COMP_TYPEINFO_NAME: - d_append_string (dpi, "typeinfo name for "); + case DEMANGLE_COMPONENT_TYPEINFO_NAME: + d_append_string_constant (dpi, "typeinfo name for "); d_print_comp (dpi, d_left (dc)); return; - case D_COMP_TYPEINFO_FN: - d_append_string (dpi, "typeinfo fn for "); + case DEMANGLE_COMPONENT_TYPEINFO_FN: + d_append_string_constant (dpi, "typeinfo fn for "); d_print_comp (dpi, d_left (dc)); return; - case D_COMP_THUNK: - d_append_string (dpi, "non-virtual thunk to "); + case DEMANGLE_COMPONENT_THUNK: + d_append_string_constant (dpi, "non-virtual thunk to "); d_print_comp (dpi, d_left (dc)); return; - case D_COMP_VIRTUAL_THUNK: - d_append_string (dpi, "virtual thunk to "); + case DEMANGLE_COMPONENT_VIRTUAL_THUNK: + d_append_string_constant (dpi, "virtual thunk to "); d_print_comp (dpi, d_left (dc)); return; - case D_COMP_COVARIANT_THUNK: - d_append_string (dpi, "covariant return thunk to "); + case DEMANGLE_COMPONENT_COVARIANT_THUNK: + d_append_string_constant (dpi, "covariant return thunk to "); d_print_comp (dpi, d_left (dc)); return; - case D_COMP_JAVA_CLASS: - d_append_string (dpi, "java Class for "); + case DEMANGLE_COMPONENT_JAVA_CLASS: + d_append_string_constant (dpi, "java Class for "); d_print_comp (dpi, d_left (dc)); return; - case D_COMP_GUARD: - d_append_string (dpi, "guard variable for "); + case DEMANGLE_COMPONENT_GUARD: + d_append_string_constant (dpi, "guard variable for "); d_print_comp (dpi, d_left (dc)); return; - case D_COMP_REFTEMP: - d_append_string (dpi, "reference temporary for "); + case DEMANGLE_COMPONENT_REFTEMP: + d_append_string_constant (dpi, "reference temporary for "); d_print_comp (dpi, d_left (dc)); return; - case D_COMP_SUB_STD: - d_append_string (dpi, dc->u.s_string.string); + case DEMANGLE_COMPONENT_SUB_STD: + d_append_buffer (dpi, dc->u.s_string.string, dc->u.s_string.len); return; - case D_COMP_RESTRICT: - case D_COMP_VOLATILE: - case D_COMP_CONST: - case D_COMP_RESTRICT_THIS: - case D_COMP_VOLATILE_THIS: - case D_COMP_CONST_THIS: - case D_COMP_VENDOR_TYPE_QUAL: - case D_COMP_POINTER: - case D_COMP_REFERENCE: - case D_COMP_COMPLEX: - case D_COMP_IMAGINARY: + case DEMANGLE_COMPONENT_RESTRICT: + case DEMANGLE_COMPONENT_VOLATILE: + case DEMANGLE_COMPONENT_CONST: + case DEMANGLE_COMPONENT_RESTRICT_THIS: + case DEMANGLE_COMPONENT_VOLATILE_THIS: + case DEMANGLE_COMPONENT_CONST_THIS: + case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL: + case DEMANGLE_COMPONENT_POINTER: + case DEMANGLE_COMPONENT_REFERENCE: + case DEMANGLE_COMPONENT_COMPLEX: + case DEMANGLE_COMPONENT_IMAGINARY: { /* We keep a list of modifiers on the stack. */ struct d_print_mod dpm; @@ -2895,18 +3080,20 @@ d_print_comp (dpi, dc) return; } - case D_COMP_BUILTIN_TYPE: + case DEMANGLE_COMPONENT_BUILTIN_TYPE: if ((dpi->options & DMGL_JAVA) == 0) - d_append_string (dpi, dc->u.s_builtin.type->name); + d_append_buffer (dpi, dc->u.s_builtin.type->name, + dc->u.s_builtin.type->len); else - d_append_string (dpi, dc->u.s_builtin.type->java_name); + d_append_buffer (dpi, dc->u.s_builtin.type->java_name, + dc->u.s_builtin.type->java_len); return; - case D_COMP_VENDOR_TYPE: + case DEMANGLE_COMPONENT_VENDOR_TYPE: d_print_comp (dpi, d_left (dc)); return; - case D_COMP_FUNCTION_TYPE: + case DEMANGLE_COMPONENT_FUNCTION_TYPE: { if (d_left (dc) != NULL) { @@ -2936,7 +3123,7 @@ d_print_comp (dpi, dc) return; } - case D_COMP_ARRAY_TYPE: + case DEMANGLE_COMPONENT_ARRAY_TYPE: { struct d_print_mod dpm; @@ -2961,7 +3148,7 @@ d_print_comp (dpi, dc) return; } - case D_COMP_PTRMEM_TYPE: + case DEMANGLE_COMPONENT_PTRMEM_TYPE: { struct d_print_mod dpm; @@ -2979,7 +3166,7 @@ d_print_comp (dpi, dc) { d_append_char (dpi, ' '); d_print_comp (dpi, d_left (dc)); - d_append_string (dpi, "::*"); + d_append_string_constant (dpi, "::*"); } dpi->modifiers = dpm.next; @@ -2987,56 +3174,57 @@ d_print_comp (dpi, dc) return; } - case D_COMP_ARGLIST: - case D_COMP_TEMPLATE_ARGLIST: + case DEMANGLE_COMPONENT_ARGLIST: + case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST: d_print_comp (dpi, d_left (dc)); if (d_right (dc) != NULL) { - d_append_string (dpi, ", "); + d_append_string_constant (dpi, ", "); d_print_comp (dpi, d_right (dc)); } return; - case D_COMP_OPERATOR: + case DEMANGLE_COMPONENT_OPERATOR: { char c; - d_append_string (dpi, "operator"); + d_append_string_constant (dpi, "operator"); c = dc->u.s_operator.op->name[0]; if (IS_LOWER (c)) d_append_char (dpi, ' '); - d_append_string (dpi, dc->u.s_operator.op->name); + d_append_buffer (dpi, dc->u.s_operator.op->name, + dc->u.s_operator.op->len); return; } - case D_COMP_EXTENDED_OPERATOR: - d_append_string (dpi, "operator "); + case DEMANGLE_COMPONENT_EXTENDED_OPERATOR: + d_append_string_constant (dpi, "operator "); d_print_comp (dpi, dc->u.s_extended_operator.name); return; - case D_COMP_CAST: - d_append_string (dpi, "operator "); + case DEMANGLE_COMPONENT_CAST: + d_append_string_constant (dpi, "operator "); d_print_cast (dpi, dc); return; - case D_COMP_UNARY: - if (d_left (dc)->type != D_COMP_CAST) + case DEMANGLE_COMPONENT_UNARY: + if (d_left (dc)->type != DEMANGLE_COMPONENT_CAST) d_print_expr_op (dpi, d_left (dc)); else { - d_append_string (dpi, "(("); + d_append_string_constant (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 == D_COMP_CAST) + if (d_left (dc)->type == DEMANGLE_COMPONENT_CAST) d_append_char (dpi, ')'); return; - case D_COMP_BINARY: - if (d_right (dc)->type != D_COMP_BINARY_ARGS) + case DEMANGLE_COMPONENT_BINARY: + if (d_right (dc)->type != DEMANGLE_COMPONENT_BINARY_ARGS) { d_print_error (dpi); return; @@ -3045,64 +3233,66 @@ d_print_comp (dpi, dc) /* We wrap an expression which uses the greater-than operator in an extra layer of parens so that it does not get confused with the '>' which ends the template parameters. */ - if (d_left (dc)->type == D_COMP_OPERATOR - && strcmp (d_left (dc)->u.s_operator.op->name, ">") == 0) + if (d_left (dc)->type == DEMANGLE_COMPONENT_OPERATOR + && d_left (dc)->u.s_operator.op->len == 1 + && d_left (dc)->u.s_operator.op->name[0] == '>') d_append_char (dpi, '('); d_append_char (dpi, '('); d_print_comp (dpi, d_left (d_right (dc))); - d_append_string (dpi, ") "); + d_append_string_constant (dpi, ") "); d_print_expr_op (dpi, d_left (dc)); - d_append_string (dpi, " ("); + d_append_string_constant (dpi, " ("); d_print_comp (dpi, d_right (d_right (dc))); d_append_char (dpi, ')'); - if (d_left (dc)->type == D_COMP_OPERATOR - && strcmp (d_left (dc)->u.s_operator.op->name, ">") == 0) + if (d_left (dc)->type == DEMANGLE_COMPONENT_OPERATOR + && d_left (dc)->u.s_operator.op->len == 1 + && d_left (dc)->u.s_operator.op->name[0] == '>') d_append_char (dpi, ')'); return; - case D_COMP_BINARY_ARGS: - /* We should only see this as part of D_COMP_BINARY. */ + case DEMANGLE_COMPONENT_BINARY_ARGS: + /* We should only see this as part of DEMANGLE_COMPONENT_BINARY. */ d_print_error (dpi); return; - case D_COMP_TRINARY: - if (d_right (dc)->type != D_COMP_TRINARY_ARG1 - || d_right (d_right (dc))->type != D_COMP_TRINARY_ARG2) + case DEMANGLE_COMPONENT_TRINARY: + if (d_right (dc)->type != DEMANGLE_COMPONENT_TRINARY_ARG1 + || d_right (d_right (dc))->type != DEMANGLE_COMPONENT_TRINARY_ARG2) { d_print_error (dpi); return; } d_append_char (dpi, '('); d_print_comp (dpi, d_left (d_right (dc))); - d_append_string (dpi, ") "); + d_append_string_constant (dpi, ") "); d_print_expr_op (dpi, d_left (dc)); - d_append_string (dpi, " ("); + d_append_string_constant (dpi, " ("); d_print_comp (dpi, d_left (d_right (d_right (dc)))); - d_append_string (dpi, ") : ("); + d_append_string_constant (dpi, ") : ("); d_print_comp (dpi, d_right (d_right (d_right (dc)))); d_append_char (dpi, ')'); return; - case D_COMP_TRINARY_ARG1: - case D_COMP_TRINARY_ARG2: - /* We should only see these are part of D_COMP_TRINARY. */ + case DEMANGLE_COMPONENT_TRINARY_ARG1: + case DEMANGLE_COMPONENT_TRINARY_ARG2: + /* We should only see these are part of DEMANGLE_COMPONENT_TRINARY. */ d_print_error (dpi); return; - case D_COMP_LITERAL: - case D_COMP_LITERAL_NEG: + case DEMANGLE_COMPONENT_LITERAL: + case DEMANGLE_COMPONENT_LITERAL_NEG: /* For some builtin types, produce simpler output. */ - if (d_left (dc)->type == D_COMP_BUILTIN_TYPE) + 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 == D_COMP_NAME) + if (d_right (dc)->type == DEMANGLE_COMPONENT_NAME) { - if (dc->type == D_COMP_LITERAL_NEG) + if (dc->type == DEMANGLE_COMPONENT_LITERAL_NEG) d_append_char (dpi, '-'); d_print_comp (dpi, d_right (dc)); return; @@ -3110,9 +3300,9 @@ d_print_comp (dpi, dc) break; case D_PRINT_LONG: - if (d_right (dc)->type == D_COMP_NAME) + if (d_right (dc)->type == DEMANGLE_COMPONENT_NAME) { - if (dc->type == D_COMP_LITERAL_NEG) + if (dc->type == DEMANGLE_COMPONENT_LITERAL_NEG) d_append_char (dpi, '-'); d_print_comp (dpi, d_right (dc)); d_append_char (dpi, 'l'); @@ -3121,17 +3311,17 @@ d_print_comp (dpi, dc) break; case D_PRINT_BOOL: - if (d_right (dc)->type == D_COMP_NAME + if (d_right (dc)->type == DEMANGLE_COMPONENT_NAME && d_right (dc)->u.s_name.len == 1 - && dc->type == D_COMP_LITERAL) + && dc->type == DEMANGLE_COMPONENT_LITERAL) { switch (d_right (dc)->u.s_name.s[0]) { case '0': - d_append_string (dpi, "false"); + d_append_string_constant (dpi, "false"); return; case '1': - d_append_string (dpi, "true"); + d_append_string_constant (dpi, "true"); return; default: break; @@ -3147,7 +3337,7 @@ d_print_comp (dpi, dc) d_append_char (dpi, '('); d_print_comp (dpi, d_left (dc)); d_append_char (dpi, ')'); - if (dc->type == D_COMP_LITERAL_NEG) + if (dc->type == DEMANGLE_COMPONENT_LITERAL_NEG) d_append_char (dpi, '-'); d_print_comp (dpi, d_right (dc)); return; @@ -3158,64 +3348,58 @@ d_print_comp (dpi, dc) } } -/* Print an identifier. */ +/* Print a Java dentifier. For Java we try to handle encoded extended + Unicode characters. The C++ ABI doesn't mention Unicode encoding, + so we don't it for C++. Characters are encoded as + __U<hex-char>+_. */ static void -d_print_identifier (dpi, name, len) +d_print_java_identifier (dpi, name, len) struct d_print_info *dpi; const char *name; int len; { - if ((dpi->options & DMGL_JAVA) == 0) - d_append_buffer (dpi, name, len); - else - { - const char *p; - const char *end; + const char *p; + const char *end; - /* For Java we try to handle encoded extended Unicode - characters. The C++ ABI doesn't mention Unicode encoding, so - we don't it for C++. Characters are encoded as - __U<hex-char>+_. */ - end = name + len; - for (p = name; p < end; ++p) + end = name + len; + for (p = name; p < end; ++p) + { + if (end - p > 3 + && p[0] == '_' + && p[1] == '_' + && p[2] == 'U') { - if (end - p > 3 - && p[0] == '_' - && p[1] == '_' - && p[2] == 'U') + unsigned long c; + const char *q; + + c = 0; + for (q = p + 3; q < end; ++q) { - unsigned long c; - const char *q; + int dig; + + if (IS_DIGIT (*q)) + dig = *q - '0'; + else if (*q >= 'A' && *q <= 'F') + dig = *q - 'A' + 10; + else if (*q >= 'a' && *q <= 'f') + dig = *q - 'a' + 10; + else + break; - c = 0; - for (q = p + 3; q < end; ++q) - { - int dig; - - if (IS_DIGIT (*q)) - dig = *q - '0'; - else if (*q >= 'A' && *q <= 'F') - dig = *q - 'A' + 10; - else if (*q >= 'a' && *q <= 'f') - dig = *q - 'a' + 10; - else - break; - - c = c * 16 + dig; - } - /* If the Unicode character is larger than 256, we don't - try to deal with it here. FIXME. */ - if (q < end && *q == '_' && c < 256) - { - d_append_char (dpi, c); - p = q; - continue; - } + c = c * 16 + dig; + } + /* If the Unicode character is larger than 256, we don't try + to deal with it here. FIXME. */ + if (q < end && *q == '_' && c < 256) + { + d_append_char (dpi, c); + p = q; + continue; } - - d_append_char (dpi, *p); } + + d_append_char (dpi, *p); } } @@ -3235,9 +3419,9 @@ d_print_mod_list (dpi, mods, suffix) if (mods->printed || (! suffix - && (mods->mod->type == D_COMP_RESTRICT_THIS - || mods->mod->type == D_COMP_VOLATILE_THIS - || mods->mod->type == D_COMP_CONST_THIS))) + && (mods->mod->type == DEMANGLE_COMPONENT_RESTRICT_THIS + || mods->mod->type == DEMANGLE_COMPONENT_VOLATILE_THIS + || mods->mod->type == DEMANGLE_COMPONENT_CONST_THIS))) { d_print_mod_list (dpi, mods->next, suffix); return; @@ -3248,18 +3432,49 @@ d_print_mod_list (dpi, mods, suffix) hold_dpt = dpi->templates; dpi->templates = mods->templates; - if (mods->mod->type == D_COMP_FUNCTION_TYPE) + if (mods->mod->type == DEMANGLE_COMPONENT_FUNCTION_TYPE) { d_print_function_type (dpi, mods->mod, mods->next); dpi->templates = hold_dpt; return; } - else if (mods->mod->type == D_COMP_ARRAY_TYPE) + else if (mods->mod->type == DEMANGLE_COMPONENT_ARRAY_TYPE) { d_print_array_type (dpi, mods->mod, mods->next); dpi->templates = hold_dpt; return; } + else if (mods->mod->type == DEMANGLE_COMPONENT_LOCAL_NAME) + { + struct d_print_mod *hold_modifiers; + struct demangle_component *dc; + + /* When this is on the modifier stack, we have pulled any + qualifiers off the right argument already. Otherwise, we + print it as usual, but don't let the left argument see any + modifiers. */ + + hold_modifiers = dpi->modifiers; + dpi->modifiers = NULL; + d_print_comp (dpi, d_left (mods->mod)); + dpi->modifiers = hold_modifiers; + + if ((dpi->options & DMGL_JAVA) == 0) + d_append_string_constant (dpi, "::"); + else + d_append_char (dpi, '.'); + + dc = d_right (mods->mod); + while (dc->type == DEMANGLE_COMPONENT_RESTRICT_THIS + || dc->type == DEMANGLE_COMPONENT_VOLATILE_THIS + || dc->type == DEMANGLE_COMPONENT_CONST_THIS) + dc = d_left (dc); + + d_print_comp (dpi, dc); + + dpi->templates = hold_dpt; + return; + } d_print_mod (dpi, mods->mod); @@ -3273,47 +3488,47 @@ d_print_mod_list (dpi, mods, suffix) static void d_print_mod (dpi, mod) struct d_print_info *dpi; - const struct d_comp *mod; + const struct demangle_component *mod; { switch (mod->type) { - case D_COMP_RESTRICT: - case D_COMP_RESTRICT_THIS: - d_append_string (dpi, " restrict"); + case DEMANGLE_COMPONENT_RESTRICT: + case DEMANGLE_COMPONENT_RESTRICT_THIS: + d_append_string_constant (dpi, " restrict"); return; - case D_COMP_VOLATILE: - case D_COMP_VOLATILE_THIS: - d_append_string (dpi, " volatile"); + case DEMANGLE_COMPONENT_VOLATILE: + case DEMANGLE_COMPONENT_VOLATILE_THIS: + d_append_string_constant (dpi, " volatile"); return; - case D_COMP_CONST: - case D_COMP_CONST_THIS: - d_append_string (dpi, " const"); + case DEMANGLE_COMPONENT_CONST: + case DEMANGLE_COMPONENT_CONST_THIS: + d_append_string_constant (dpi, " const"); return; - case D_COMP_VENDOR_TYPE_QUAL: + case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL: d_append_char (dpi, ' '); d_print_comp (dpi, d_right (mod)); return; - case D_COMP_POINTER: + case DEMANGLE_COMPONENT_POINTER: /* There is no pointer symbol in Java. */ if ((dpi->options & DMGL_JAVA) == 0) d_append_char (dpi, '*'); return; - case D_COMP_REFERENCE: + case DEMANGLE_COMPONENT_REFERENCE: d_append_char (dpi, '&'); return; - case D_COMP_COMPLEX: - d_append_string (dpi, "complex "); + case DEMANGLE_COMPONENT_COMPLEX: + d_append_string_constant (dpi, "complex "); return; - case D_COMP_IMAGINARY: - d_append_string (dpi, "imaginary "); + case DEMANGLE_COMPONENT_IMAGINARY: + d_append_string_constant (dpi, "imaginary "); return; - case D_COMP_PTRMEM_TYPE: + case DEMANGLE_COMPONENT_PTRMEM_TYPE: if (d_last_char (dpi) != '(') d_append_char (dpi, ' '); d_print_comp (dpi, d_left (mod)); - d_append_string (dpi, "::*"); + d_append_string_constant (dpi, "::*"); return; - case D_COMP_TYPED_NAME: + case DEMANGLE_COMPONENT_TYPED_NAME: d_print_comp (dpi, d_left (mod)); return; default: @@ -3329,12 +3544,13 @@ d_print_mod (dpi, mod) static void d_print_function_type (dpi, dc, mods) struct d_print_info *dpi; - const struct d_comp *dc; + const struct demangle_component *dc; struct d_print_mod *mods; { int need_paren; int saw_mod; struct d_print_mod *p; + struct d_print_mod *hold_modifiers; need_paren = 0; saw_mod = 0; @@ -3346,20 +3562,20 @@ d_print_function_type (dpi, dc, mods) saw_mod = 1; switch (p->mod->type) { - case D_COMP_RESTRICT: - case D_COMP_VOLATILE: - case D_COMP_CONST: - case D_COMP_VENDOR_TYPE_QUAL: - case D_COMP_POINTER: - case D_COMP_REFERENCE: - case D_COMP_COMPLEX: - case D_COMP_IMAGINARY: - case D_COMP_PTRMEM_TYPE: + 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_paren = 1; break; - case D_COMP_RESTRICT_THIS: - case D_COMP_VOLATILE_THIS: - case D_COMP_CONST_THIS: + case DEMANGLE_COMPONENT_RESTRICT_THIS: + case DEMANGLE_COMPONENT_VOLATILE_THIS: + case DEMANGLE_COMPONENT_CONST_THIS: break; default: break; @@ -3388,6 +3604,9 @@ d_print_function_type (dpi, dc, mods) d_append_char (dpi, '('); } + hold_modifiers = dpi->modifiers; + dpi->modifiers = NULL; + d_print_mod_list (dpi, mods, 0); if (need_paren) @@ -3401,6 +3620,8 @@ d_print_function_type (dpi, dc, mods) d_append_char (dpi, ')'); d_print_mod_list (dpi, mods, 1); + + dpi->modifiers = hold_modifiers; } /* Print an array type, except for the element type. */ @@ -3408,7 +3629,7 @@ d_print_function_type (dpi, dc, mods) static void d_print_array_type (dpi, dc, mods) struct d_print_info *dpi; - const struct d_comp *dc; + const struct demangle_component *dc; struct d_print_mod *mods; { int need_space; @@ -3425,7 +3646,7 @@ d_print_array_type (dpi, dc, mods) if (p->printed) break; - if (p->mod->type == D_COMP_ARRAY_TYPE) + if (p->mod->type == DEMANGLE_COMPONENT_ARRAY_TYPE) { need_space = 0; break; @@ -3439,7 +3660,7 @@ d_print_array_type (dpi, dc, mods) } if (need_paren) - d_append_string (dpi, " ("); + d_append_string_constant (dpi, " ("); d_print_mod_list (dpi, mods, 0); @@ -3463,10 +3684,11 @@ d_print_array_type (dpi, dc, mods) static void d_print_expr_op (dpi, dc) struct d_print_info *dpi; - const struct d_comp *dc; + const struct demangle_component *dc; { - if (dc->type == D_COMP_OPERATOR) - d_append_string (dpi, dc->u.s_operator.op->name); + if (dc->type == DEMANGLE_COMPONENT_OPERATOR) + d_append_buffer (dpi, dc->u.s_operator.op->name, + dc->u.s_operator.op->len); else d_print_comp (dpi, dc); } @@ -3476,9 +3698,9 @@ d_print_expr_op (dpi, dc) static void d_print_cast (dpi, dc) struct d_print_info *dpi; - const struct d_comp *dc; + const struct demangle_component *dc; { - if (d_left (dc)->type != D_COMP_TEMPLATE) + if (d_left (dc)->type != DEMANGLE_COMPONENT_TEMPLATE) d_print_comp (dpi, d_left (dc)); else { @@ -3518,14 +3740,16 @@ d_print_cast (dpi, dc) /* Initialize the information structure we use to pass around information. */ -static int -d_init_info (mangled, options, len, di) +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; { di->s = mangled; + di->send = mangled + len; di->options = options; di->n = mangled; @@ -3534,29 +3758,17 @@ d_init_info (mangled, options, len, di) the mangled string. Most components correspond directly to chars, but the ARGLIST types are exceptions. */ di->num_comps = 2 * len; - di->comps = (struct d_comp *) malloc (di->num_comps - * sizeof (struct d_comp)); di->next_comp = 0; /* Similarly, we can not need more substitutions than there are chars in the mangled string. */ di->num_subs = len; - di->subs = (struct d_comp **) malloc (di->num_subs - * sizeof (struct d_comp *)); di->next_sub = 0; + di->did_subs = 0; di->last_name = NULL; - if (di->comps == NULL || di->subs == NULL) - { - if (di->comps != NULL) - free (di->comps); - if (di->subs != NULL) - free (di->subs); - return 0; - } - - return 1; + di->expansion = 0; } /* Entry point for the demangler. If MANGLED is a g++ v3 ABI mangled @@ -3575,7 +3787,8 @@ d_demangle (mangled, options, palc) size_t len; int type; struct d_info di; - struct d_comp *dc; + struct demangle_component *dc; + int estimate; char *ret; *palc = 0; @@ -3611,39 +3824,82 @@ d_demangle (mangled, options, palc) type = 1; } - if (! d_init_info (mangled, options, len, &di)) - { - *palc = 1; - return NULL; - } + cplus_demangle_init_info (mangled, options, len, &di); - if (! type) - dc = d_mangled_name (&di, 1); - else - dc = d_type (&di); + { +#ifdef CP_DYNAMIC_ARRAYS + __extension__ struct demangle_component comps[di.num_comps]; + __extension__ struct demangle_component *subs[di.num_subs]; + + di.comps = &comps[0]; + di.subs = &subs[0]; +#else + di.comps = ((struct demangle_component *) + malloc (di.num_comps * sizeof (struct demangle_component))); + di.subs = ((struct demangle_component **) + malloc (di.num_subs * sizeof (struct demangle_component *))); + if (di.comps == NULL || di.subs == NULL) + { + if (di.comps != NULL) + free (di.comps); + if (di.subs != NULL) + free (di.subs); + *palc = 1; + return NULL; + } +#endif + + if (! type) + dc = cplus_demangle_mangled_name (&di, 1); + else + dc = cplus_demangle_type (&di); - /* If DMGL_PARAMS is set, then if we didn't consume the entire - mangled string, then we didn't successfully demangle it. If - DMGL_PARAMS is not set, we didn't look at the trailing - parameters. */ - if (((options & DMGL_PARAMS) != 0) && d_peek_char (&di) != '\0') - dc = NULL; + /* If DMGL_PARAMS is set, then if we didn't consume the entire + mangled string, then we didn't successfully demangle it. If + DMGL_PARAMS is not set, we didn't look at the trailing + parameters. */ + if (((options & DMGL_PARAMS) != 0) && d_peek_char (&di) != '\0') + dc = NULL; #ifdef CP_DEMANGLE_DEBUG - if (dc == NULL) - printf ("failed demangling\n"); - else - d_dump (dc, 0); + if (dc == NULL) + printf ("failed demangling\n"); + else + d_dump (dc, 0); #endif - free (di.subs); - di.subs = NULL; + /* We try to guess the length of the demangled string, to minimize + calls to realloc during demangling. */ + estimate = len + di.expansion + 10 * di.did_subs; + estimate += estimate / 8; - ret = NULL; - if (dc != NULL) - ret = d_print (options, dc, palc); + ret = NULL; + if (dc != NULL) + ret = cplus_demangle_print (options, dc, estimate, palc); - free (di.comps); +#ifndef CP_DYNAMIC_ARRAYS + free (di.comps); + free (di.subs); +#endif + +#ifdef CP_DEMANGLE_DEBUG + if (ret != NULL) + { + int rlen; + + rlen = strlen (ret); + if (rlen > 2 * estimate) + printf ("*** Length %d much greater than estimate %d\n", + rlen, estimate); + else if (rlen > estimate) + printf ("*** Length %d greater than estimate %d\n", + rlen, estimate); + else if (rlen < estimate / 2) + printf ("*** Length %d much less than estimate %d\n", + rlen, estimate); + } +#endif + } return ret; } @@ -3820,53 +4076,78 @@ is_ctor_or_dtor (mangled, ctor_kind, dtor_kind) enum gnu_v3_dtor_kinds *dtor_kind; { struct d_info di; - struct d_comp *dc; + struct demangle_component *dc; int ret; *ctor_kind = (enum gnu_v3_ctor_kinds) 0; *dtor_kind = (enum gnu_v3_dtor_kinds) 0; - if (! d_init_info (mangled, DMGL_GNU_V3, strlen (mangled), &di)) - return 0; + cplus_demangle_init_info (mangled, DMGL_GNU_V3, strlen (mangled), &di); - dc = d_mangled_name (&di, 1); + { +#ifdef CP_DYNAMIC_ARRAYS + __extension__ struct demangle_component comps[di.num_comps]; + __extension__ struct demangle_component *subs[di.num_subs]; + + di.comps = &comps[0]; + di.subs = &subs[0]; +#else + di.comps = ((struct demangle_component *) + malloc (di.num_comps * sizeof (struct demangle_component))); + di.subs = ((struct demangle_component **) + malloc (di.num_subs * sizeof (struct demangle_component *))); + if (di.comps == NULL || di.subs == NULL) + { + if (di.comps != NULL) + free (di.comps); + if (di.subs != NULL) + free (di.subs); + return 0; + } +#endif - /* Note that because we did not pass DMGL_PARAMS, we don't expect to - demangle the entire string. */ + dc = cplus_demangle_mangled_name (&di, 1); - ret = 0; - while (dc != NULL) - { - switch (dc->type) - { - default: - dc = NULL; - break; - case D_COMP_TYPED_NAME: - case D_COMP_TEMPLATE: - case D_COMP_RESTRICT_THIS: - case D_COMP_VOLATILE_THIS: - case D_COMP_CONST_THIS: - dc = d_left (dc); - break; - case D_COMP_QUAL_NAME: - dc = d_right (dc); - break; - case D_COMP_CTOR: - *ctor_kind = dc->u.s_ctor.kind; - ret = 1; - dc = NULL; - break; - case D_COMP_DTOR: - *dtor_kind = dc->u.s_dtor.kind; - ret = 1; - dc = NULL; - break; - } - } + /* Note that because we did not pass DMGL_PARAMS, we don't expect + to demangle the entire string. */ + + ret = 0; + while (dc != NULL) + { + switch (dc->type) + { + default: + dc = NULL; + break; + case DEMANGLE_COMPONENT_TYPED_NAME: + case DEMANGLE_COMPONENT_TEMPLATE: + case DEMANGLE_COMPONENT_RESTRICT_THIS: + case DEMANGLE_COMPONENT_VOLATILE_THIS: + case DEMANGLE_COMPONENT_CONST_THIS: + dc = d_left (dc); + break; + case DEMANGLE_COMPONENT_QUAL_NAME: + case DEMANGLE_COMPONENT_LOCAL_NAME: + dc = d_right (dc); + break; + case DEMANGLE_COMPONENT_CTOR: + *ctor_kind = dc->u.s_ctor.kind; + ret = 1; + dc = NULL; + break; + case DEMANGLE_COMPONENT_DTOR: + *dtor_kind = dc->u.s_dtor.kind; + ret = 1; + dc = NULL; + break; + } + } - free (di.subs); - free (di.comps); +#ifndef CP_DYNAMIC_ARRAYS + free (di.subs); + free (di.comps); +#endif + } return ret; } |