X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=libiberty%2Fcp-demangle.c;h=8f1cfb17f87f2734e0b756390eeaa94a69dc87ab;hb=7b96829ccc499ace9643b8e04ff531a4a0985c51;hp=bd67958410b517e3bd8235a834bb6a117c9cbe81;hpb=331c3da232126f8a9a25e17395e65ab3698ef8a5;p=deliverable%2Fbinutils-gdb.git diff --git a/libiberty/cp-demangle.c b/libiberty/cp-demangle.c index bd67958410..8f1cfb17f8 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, 2005 Free Software Foundation, Inc. Written by Ian Lance Taylor . This file is part of the libiberty library, which is part of GCC. @@ -25,7 +25,61 @@ You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software - Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. +*/ + +/* This code implements a demangler for the g++ V3 ABI. The ABI is + described on this web page: + http://www.codesourcery.com/cxx-abi/abi.html#mangling + + This code was written while looking at the demangler written by + Alex Samuel . + + This code first pulls the mangled name apart into a list of + components, and then walks the list generating the demangled + name. + + This file will normally define the following functions, q.v.: + char *cplus_demangle_v3(const char *mangled, int options) + char *java_demangle_v3(const char *mangled) + 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 + If defined, this file defines the following function, q.v.: + char *__cxa_demangle (const char *mangled, char *buf, size_t *len, + int *status) + instead of cplus_demangle_v3() and java_demangle_v3(). + + IN_GLIBCPP_V3 + 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 + any arguments, or, if none, demangles stdin. + + CP_DEMANGLE_DEBUG + If defined, turns on debugging mode, which prints information on + stdout about the mangled string. This is not generally useful. */ #ifdef HAVE_CONFIG_H @@ -44,272 +98,111 @@ #include "ansidecl.h" #include "libiberty.h" #include "demangle.h" +#include "cp-demangle.h" -/* This code implements a demangler for the g++ V3 ABI. The ABI is - described on this web page: - http://www.codesourcery.com/cxx-abi/abi.html#mangling +/* 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 - This code was written while looking at the demangler written by - Alex Samuel . +#define CP_STATIC_IF_GLIBCPP_V3 static - This code first pulls the mangled name apart into a list of - components, and then walks the list generating the demangled - name. */ - -/* Avoid pulling in the ctype tables for this simple usage. */ -#define IS_DIGIT(c) ((c) >= '0' && (c) <= '9') - -/* The prefix prepended by GCC to an identifier represnting the - anonymous namespace. */ -#define ANONYMOUS_NAMESPACE_PREFIX "_GLOBAL_" -#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; -}; +#define cplus_demangle_fill_name d_fill_name +static int d_fill_name (struct demangle_component *, const char *, int); -/* How to print the value of a builtin type. */ +#define cplus_demangle_fill_extended_operator d_fill_extended_operator +static int +d_fill_extended_operator (struct demangle_component *, int, + struct demangle_component *); -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 -}; +#define cplus_demangle_fill_ctor d_fill_ctor +static int +d_fill_ctor (struct demangle_component *, enum gnu_v3_ctor_kinds, + struct demangle_component *); -/* Information we keep for a builtin type. */ +#define cplus_demangle_fill_dtor d_fill_dtor +static int +d_fill_dtor (struct demangle_component *, enum gnu_v3_dtor_kinds, + struct demangle_component *); -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; -}; +#define cplus_demangle_mangled_name d_mangled_name +static struct demangle_component *d_mangled_name (struct d_info *, int); -/* 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, - /* 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 -}; +#define cplus_demangle_type d_type +static struct demangle_component *d_type (struct d_info *); -/* A component of the mangled name. */ +#define cplus_demangle_print d_print +static char *d_print (int, const struct demangle_component *, int, size_t *); -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; +#define cplus_demangle_init_info d_init_info +static void d_init_info (const char *, int, size_t, struct d_info *); - /* For D_COMP_OPERATOR. */ - struct - { - /* Operator. */ - const struct d_operator_info *op; - } s_operator; +#else /* ! defined(IN_GLIBCPP_V3) */ +#define CP_STATIC_IF_GLIBCPP_V3 +#endif /* ! defined(IN_GLIBCPP_V3) */ - /* For D_COMP_EXTENDED_OPERATOR. */ - struct - { - /* Number of arguments. */ - int args; - /* Name. */ - struct d_comp *name; - } s_extended_operator; +/* See if the compiler supports dynamic arrays. */ - /* For D_COMP_CTOR. */ - struct - { - enum gnu_v3_ctor_kinds kind; - struct d_comp *name; - } s_ctor; +#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__) */ - /* For D_COMP_DTOR. */ - struct - { - enum gnu_v3_dtor_kinds kind; - struct d_comp *name; - } s_dtor; +/* We avoid pulling in the ctype tables, to prevent pulling in + additional unresolved symbols when this code is used in a library. + FIXME: Is this really a valid reason? This comes from the original + V3 demangler code. - /* For D_COMP_BUILTIN_TYPE. */ - struct - { - const struct d_builtin_type_info *type; - } s_builtin; + As of this writing this file has the following undefined references + when compiled with -DIN_GLIBCPP_V3: malloc, realloc, free, memcpy, + strcpy, strcat, strlen. */ - /* For D_COMP_SUB_STD. */ - struct - { - const char* string; - } s_string; +#define IS_DIGIT(c) ((c) >= '0' && (c) <= '9') +#define IS_UPPER(c) ((c) >= 'A' && (c) <= 'Z') +#define IS_LOWER(c) ((c) >= 'a' && (c) <= 'z') - /* For D_COMP_TEMPLATE_PARAM. */ - struct - { - long number; - } s_number; +/* The prefix prepended by GCC to an identifier represnting the + anonymous namespace. */ +#define ANONYMOUS_NAMESPACE_PREFIX "_GLOBAL_" +#define ANONYMOUS_NAMESPACE_PREFIX_LEN \ + (sizeof (ANONYMOUS_NAMESPACE_PREFIX) - 1) - /* For other types. */ - struct - { - struct d_comp *left; - struct d_comp *right; - } s_binary; +/* Information we keep for the standard substitutions. */ - } u; +struct d_standard_sub_info +{ + /* The code for this substitution. */ + 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; }; +/* 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 @@ -317,7 +210,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_decl; }; /* A list of type modifiers. This is used while printing. */ @@ -328,7 +221,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. */ @@ -381,103 +274,164 @@ 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 (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 **)); -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 *)); -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 *)); -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 (struct d_info *); + +static struct demangle_component * +d_make_comp (struct d_info *, enum demangle_component_type, + struct demangle_component *, + struct demangle_component *); + +static struct demangle_component * +d_make_name (struct d_info *, const char *, int); + +static struct demangle_component * +d_make_builtin_type (struct d_info *, + const struct demangle_builtin_type_info *); + +static struct demangle_component * +d_make_operator (struct d_info *, + const struct demangle_operator_info *); + +static struct demangle_component * +d_make_extended_operator (struct d_info *, int, + struct demangle_component *); + +static struct demangle_component * +d_make_ctor (struct d_info *, enum gnu_v3_ctor_kinds, + struct demangle_component *); + +static struct demangle_component * +d_make_dtor (struct d_info *, enum gnu_v3_dtor_kinds, + struct demangle_component *); + +static struct demangle_component * +d_make_template_param (struct d_info *, long); + +static struct demangle_component * +d_make_sub (struct d_info *, const char *, int); + +static int +has_return_type (struct demangle_component *); + +static int +is_ctor_dtor_or_conversion (struct demangle_component *); + +static struct demangle_component *d_encoding (struct d_info *, int); + +static struct demangle_component *d_name (struct d_info *); + +static struct demangle_component *d_nested_name (struct d_info *); + +static struct demangle_component *d_prefix (struct d_info *); + +static struct demangle_component *d_unqualified_name (struct d_info *); + +static struct demangle_component *d_source_name (struct d_info *); + +static long d_number (struct d_info *); + +static struct demangle_component *d_identifier (struct d_info *, int); + +static struct demangle_component *d_operator_name (struct d_info *); + +static struct demangle_component *d_special_name (struct d_info *); + +static int d_call_offset (struct d_info *, int); + +static struct demangle_component *d_ctor_dtor_name (struct d_info *); + +static struct demangle_component ** +d_cv_qualifiers (struct d_info *, struct demangle_component **, int); + +static struct demangle_component * +d_function_type (struct d_info *); + +static struct demangle_component * +d_bare_function_type (struct d_info *, int); + +static struct demangle_component * +d_class_enum_type (struct d_info *); + +static struct demangle_component *d_array_type (struct d_info *); + +static struct demangle_component * +d_pointer_to_member_type (struct d_info *); + +static struct demangle_component * +d_template_param (struct d_info *); + +static struct demangle_component *d_template_args (struct d_info *); + +static struct demangle_component * +d_template_arg (struct d_info *); + +static struct demangle_component *d_expression (struct d_info *); + +static struct demangle_component *d_expr_primary (struct d_info *); + +static struct demangle_component *d_local_name (struct d_info *); + +static int d_discriminator (struct d_info *); + +static int +d_add_substitution (struct d_info *, struct demangle_component *); + +static struct demangle_component *d_substitution (struct d_info *, int); + +static void d_print_resize (struct d_print_info *, size_t); + +static void d_print_append_char (struct d_print_info *, int); + +static void +d_print_append_buffer (struct d_print_info *, const char *, size_t); + +static void d_print_error (struct d_print_info *); + +static void +d_print_comp (struct d_print_info *, const struct demangle_component *); + +static void +d_print_java_identifier (struct d_print_info *, const char *, int); + +static void +d_print_mod_list (struct d_print_info *, struct d_print_mod *, int); + +static void +d_print_mod (struct d_print_info *, const struct demangle_component *); + +static void +d_print_function_type (struct d_print_info *, + const struct demangle_component *, + struct d_print_mod *); + +static void +d_print_array_type (struct d_print_info *, + const struct demangle_component *, + struct d_print_mod *); + +static void +d_print_expr_op (struct d_print_info *, const struct demangle_component *); + +static void +d_print_cast (struct d_print_info *, const struct demangle_component *); + +static char *d_demangle (const char *, int, size_t *); #ifdef CP_DEMANGLE_DEBUG static void -d_dump (dc, indent) - struct d_comp *dc; - int indent; +d_dump (struct demangle_component *dc, int indent) { int i; @@ -489,146 +443,164 @@ 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_HIDDEN_ALIAS: + printf ("hidden alias\n"); + break; + 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_VENDOR_TYPE_QUAL: + case DEMANGLE_COMPONENT_RESTRICT_THIS: + printf ("restrict this\n"); + break; + case DEMANGLE_COMPONENT_VOLATILE_THIS: + printf ("volatile this\n"); + break; + case DEMANGLE_COMPONENT_CONST_THIS: + printf ("const this\n"); + break; + 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 DEMANGLE_COMPONENT_LITERAL_NEG: + printf ("negative literal\n"); + break; } d_dump (d_left (dc), indent + 2); @@ -637,33 +609,95 @@ d_dump (dc, indent) #endif /* CP_DEMANGLE_DEBUG */ +/* Fill in a DEMANGLE_COMPONENT_NAME. */ + +CP_STATIC_IF_GLIBCPP_V3 +int +cplus_demangle_fill_name (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 (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 (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 (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) - struct d_info *di; - enum d_comp_type type; +static struct demangle_component * +d_make_empty (struct d_info *di) { - 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 * -d_make_comp (di, type, left, right) - struct d_info *di; - enum d_comp_type type; - struct d_comp *left; - struct d_comp *right; +static struct demangle_component * +d_make_comp (struct d_info *di, 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 @@ -671,60 +705,66 @@ 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 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_HIDDEN_ALIAS: + 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 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. */ @@ -732,9 +772,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; } @@ -743,145 +784,124 @@ d_make_comp (di, type, left, right) /* Add a new name component. */ -static struct d_comp * -d_make_name (di, s, len) - struct d_info *di; - const char *s; - int len; +static struct demangle_component * +d_make_name (struct d_info *di, const char *s, int len) { - struct d_comp *p; + struct demangle_component *p; - p = d_make_empty (di, D_COMP_NAME); - if (p != NULL) - { - p->u.s_name.s = s; - p->u.s_name.len = len; - } + p = d_make_empty (di); + if (! cplus_demangle_fill_name (p, s, len)) + return NULL; return p; } /* Add a new builtin type component. */ -static struct d_comp * -d_make_builtin_type (di, type) - struct d_info *di; - const struct d_builtin_type_info *type; +static struct demangle_component * +d_make_builtin_type (struct d_info *di, + 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 * -d_make_operator (di, op) - struct d_info *di; - const struct d_operator_info *op; +static struct demangle_component * +d_make_operator (struct d_info *di, 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 * -d_make_extended_operator (di, args, name) - struct d_info *di; - int args; - struct d_comp *name; +static struct demangle_component * +d_make_extended_operator (struct d_info *di, int args, + 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 * -d_make_ctor (di, kind, name) - struct d_info *di; - enum gnu_v3_ctor_kinds kind; - struct d_comp *name; +static struct demangle_component * +d_make_ctor (struct d_info *di, enum gnu_v3_ctor_kinds kind, + 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 * -d_make_dtor (di, kind, name) - struct d_info *di; - enum gnu_v3_dtor_kinds kind; - struct d_comp *name; +static struct demangle_component * +d_make_dtor (struct d_info *di, enum gnu_v3_dtor_kinds kind, + 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 * -d_make_template_param (di, i) - struct d_info *di; - long i; +static struct demangle_component * +d_make_template_param (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) - struct d_info *di; - const char *name; +static struct demangle_component * +d_make_sub (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; } @@ -889,10 +909,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) - struct d_info *di; - int top_level; +CP_STATIC_IF_GLIBCPP_V3 +struct demangle_component * +cplus_demangle_mangled_name (struct d_info *di, int top_level) { if (d_next_char (di) != '_') return NULL; @@ -911,8 +930,7 @@ d_mangled_name (di, top_level) return types. */ static int -has_return_type (dc) - struct d_comp *dc; +has_return_type (struct demangle_component *dc) { if (dc == NULL) return 0; @@ -920,12 +938,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: - case D_COMP_VOLATILE: - case D_COMP_CONST: - case D_COMP_VENDOR_TYPE_QUAL: + case DEMANGLE_COMPONENT_RESTRICT_THIS: + case DEMANGLE_COMPONENT_VOLATILE_THIS: + case DEMANGLE_COMPONENT_CONST_THIS: return has_return_type (d_left (dc)); } } @@ -934,8 +951,7 @@ has_return_type (dc) conversion operator. */ static int -is_ctor_dtor_or_conversion (dc) - struct d_comp *dc; +is_ctor_dtor_or_conversion (struct demangle_component *dc) { if (dc == NULL) return 0; @@ -943,11 +959,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; } } @@ -961,10 +978,8 @@ 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 * -d_encoding (di, top_level) - struct d_info *di; - int top_level; +static struct demangle_component * +d_encoding (struct d_info *di, int top_level) { char peek = d_peek_char (di); @@ -972,7 +987,7 @@ d_encoding (di, top_level) return d_special_name (di); else { - struct d_comp *dc; + struct demangle_component *dc; dc = d_name (di); @@ -981,17 +996,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 - || dc->type == D_COMP_VOLATILE - || dc->type == D_COMP_CONST) + 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))); } } @@ -1008,12 +1040,11 @@ d_encoding (di, top_level) ::= */ -static struct d_comp * -d_name (di) - struct d_info *di; +static struct demangle_component * +d_name (struct d_info *di) { char peek = d_peek_char (di); - struct d_comp *dc; + struct demangle_component *dc; switch (peek) { @@ -1029,14 +1060,16 @@ d_name (di) if (d_peek_next_char (di) != 't') { - dc = d_substitution (di); + dc = d_substitution (di, 0); subst = 1; } 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; } @@ -1057,7 +1090,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; @@ -1072,7 +1106,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; } @@ -1082,17 +1117,16 @@ d_name (di) ::= N [] E */ -static struct d_comp * -d_nested_name (di) - struct d_info *di; +static struct demangle_component * +d_nested_name (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; - pret = d_cv_qualifiers (di, &ret); + pret = d_cv_qualifiers (di, &ret, 1); if (pret == NULL) return NULL; @@ -1117,17 +1151,16 @@ d_nested_name (di) ::= */ -static struct d_comp * -d_prefix (di) - struct d_info *di; +static struct demangle_component * +d_prefix (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') @@ -1137,19 +1170,19 @@ d_prefix (di) that in the grammar. The older code does not accept a here. */ - comb_type = D_COMP_QUAL_NAME; + comb_type = DEMANGLE_COMPONENT_QUAL_NAME; if (IS_DIGIT (peek) - || (peek >= 'a' && peek <= 'z') + || IS_LOWER (peek) || peek == 'C' || peek == 'D') dc = d_unqualified_name (di); else if (peek == 'S') - dc = d_substitution (di); + dc = d_substitution (di, 1); else if (peek == 'I') { if (ret == NULL) return NULL; - comb_type = D_COMP_TEMPLATE; + comb_type = DEMANGLE_COMPONENT_TEMPLATE; dc = d_template_args (di); } else if (peek == 'T') @@ -1177,17 +1210,23 @@ d_prefix (di) ::= */ -static struct d_comp * -d_unqualified_name (di) - struct d_info *di; +static struct demangle_component * +d_unqualified_name (struct d_info *di) { char peek; peek = d_peek_char (di); if (IS_DIGIT (peek)) return d_source_name (di); - else if (peek >= 'a' && peek <= 'z') - return d_operator_name (di); + else if (IS_LOWER (peek)) + { + 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 @@ -1196,12 +1235,11 @@ d_unqualified_name (di) /* ::= <(positive length) number> */ -static struct d_comp * -d_source_name (di) - struct d_info *di; +static struct demangle_component * +d_source_name (struct d_info *di) { long len; - struct d_comp *ret; + struct demangle_component *ret; len = d_number (di); if (len <= 0) @@ -1214,18 +1252,17 @@ d_source_name (di) /* number ::= [n] <(non-negative decimal integer)> */ static long -d_number (di) - struct d_info *di; +d_number (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); } @@ -1234,7 +1271,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); @@ -1243,16 +1284,25 @@ d_number (di) /* identifier ::= <(unqualified source code identifier)> */ -static struct d_comp * -d_identifier (di, len) - struct d_info *di; - int len; +static struct demangle_component * +d_identifier (struct d_info *di, int 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. */ @@ -1265,8 +1315,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); @@ -1277,62 +1330,65 @@ d_identifier (di, len) ::= v */ -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 * -d_operator_name (di) - struct d_info *di; +static struct demangle_component * +d_operator_name (struct d_info *di) { char c1; char c2; @@ -1342,19 +1398,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); @@ -1381,70 +1443,81 @@ d_operator_name (di) ::= TF ::= TJ ::= GR + ::= GA */ -static struct d_comp * -d_special_name (di) - struct d_info *di; +static struct demangle_component * +d_special_name (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; @@ -1455,10 +1528,15 @@ 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); + + case 'A': + return d_make_comp (di, DEMANGLE_COMPONENT_HIDDEN_ALIAS, + d_encoding (di, 0), NULL); default: return NULL; @@ -1482,24 +1560,19 @@ d_special_name (di) display it in verbose mode. */ static int -d_call_offset (di, c) - struct d_info *di; - int c; +d_call_offset (struct d_info *di, int c) { - long offset; - long virtual_offset; - if (c == '\0') c = d_next_char (di); if (c == 'h') - offset = d_number (di); + d_number (di); else if (c == 'v') { - offset = d_number (di); + d_number (di); if (d_next_char (di) != '_') return 0; - virtual_offset = d_number (di); + d_number (di); } else return 0; @@ -1518,10 +1591,16 @@ d_call_offset (di, c) ::= D2 */ -static struct d_comp * -d_ctor_dtor_name (di) - struct d_info *di; +static struct demangle_component * +d_ctor_dtor_name (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': @@ -1590,42 +1669,46 @@ d_ctor_dtor_name (di) ::= u */ -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_DEFAULT }, + /* b */ { NL ("bool"), NL ("boolean"), D_PRINT_BOOL }, + /* c */ { NL ("char"), NL ("byte"), D_PRINT_DEFAULT }, + /* d */ { NL ("double"), NL ("double"), D_PRINT_FLOAT }, + /* e */ { NL ("long double"), NL ("long double"), D_PRINT_FLOAT }, + /* f */ { NL ("float"), NL ("float"), D_PRINT_FLOAT }, + /* g */ { NL ("__float128"), NL ("__float128"), D_PRINT_FLOAT }, + /* h */ { NL ("unsigned char"), NL ("unsigned char"), D_PRINT_DEFAULT }, + /* i */ { NL ("int"), NL ("int"), D_PRINT_INT }, + /* j */ { NL ("unsigned int"), NL ("unsigned"), D_PRINT_UNSIGNED }, + /* k */ { NULL, 0, NULL, 0, D_PRINT_DEFAULT }, + /* l */ { NL ("long"), NL ("long"), D_PRINT_LONG }, + /* m */ { NL ("unsigned long"), NL ("unsigned long"), D_PRINT_UNSIGNED_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_DEFAULT }, + /* t */ { NL ("unsigned short"), NL ("unsigned short"), D_PRINT_DEFAULT }, + /* u */ { NULL, 0, NULL, 0, D_PRINT_DEFAULT }, + /* v */ { NL ("void"), NL ("void"), D_PRINT_VOID }, + /* w */ { NL ("wchar_t"), NL ("char"), D_PRINT_DEFAULT }, + /* x */ { NL ("long long"), NL ("long"), D_PRINT_LONG_LONG }, + /* y */ { NL ("unsigned long long"), NL ("unsigned long long"), + D_PRINT_UNSIGNED_LONG_LONG }, + /* z */ { NL ("..."), NL ("..."), D_PRINT_DEFAULT }, }; -static struct d_comp * -d_type (di) - struct d_info *di; +CP_STATIC_IF_GLIBCPP_V3 +struct demangle_component * +cplus_demangle_type (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 @@ -1646,12 +1729,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); + 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; @@ -1665,14 +1748,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': @@ -1703,7 +1789,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; @@ -1716,13 +1803,13 @@ d_type (di) peek_next = d_peek_next_char (di); if (IS_DIGIT (peek_next) || peek_next == '_' - || (peek_next >= 'A' && peek_next <= 'Z')) + || IS_UPPER (peek_next)) { - ret = d_substitution (di); + ret = d_substitution (di, 0); /* 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; @@ -1734,7 +1821,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; } } @@ -1742,28 +1829,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: @@ -1781,25 +1873,39 @@ d_type (di) /* ::= [r] [V] [K] */ -static struct d_comp ** -d_cv_qualifiers (di, pret) - struct d_info *di; - struct d_comp **pret; +static struct demangle_component ** +d_cv_qualifiers (struct d_info *di, + struct demangle_component **pret, int member_fn) { char peek; 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 = D_COMP_RESTRICT; + { + t = (member_fn + ? DEMANGLE_COMPONENT_RESTRICT_THIS + : DEMANGLE_COMPONENT_RESTRICT); + di->expansion += sizeof "restrict"; + } else if (peek == 'V') - t = D_COMP_VOLATILE; + { + t = (member_fn + ? DEMANGLE_COMPONENT_VOLATILE_THIS + : DEMANGLE_COMPONENT_VOLATILE); + di->expansion += sizeof "volatile"; + } else - t = 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) @@ -1814,11 +1920,10 @@ d_cv_qualifiers (di, pret) /* ::= F [Y] E */ -static struct d_comp * -d_function_type (di) - struct d_info *di; +static struct demangle_component * +d_function_type (struct d_info *di) { - struct d_comp *ret; + struct demangle_component *ret; if (d_next_char (di) != 'F') return NULL; @@ -1836,14 +1941,12 @@ d_function_type (di) /* ::= + */ -static struct d_comp * -d_bare_function_type (di, has_return_type) - struct d_info *di; - int has_return_type; +static struct demangle_component * +d_bare_function_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; @@ -1851,12 +1954,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) @@ -1866,7 +1969,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); @@ -1881,18 +1984,20 @@ 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); } /* ::= */ -static struct d_comp * -d_class_enum_type (di) - struct d_info *di; +static struct demangle_component * +d_class_enum_type (struct d_info *di) { return d_name (di); } @@ -1901,12 +2006,11 @@ d_class_enum_type (di) ::= A [<(dimension) expression>] _ <(element) type> */ -static struct d_comp * -d_array_type (di) - struct d_info *di; +static struct demangle_component * +d_array_type (struct d_info *di) { char peek; - struct d_comp *dim; + struct demangle_component *dim; if (d_next_char (di) != 'A') return NULL; @@ -1939,23 +2043,23 @@ 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)); } /* ::= M <(class) type> <(member) type> */ -static struct d_comp * -d_pointer_to_member_type (di) - struct d_info *di; +static struct demangle_component * +d_pointer_to_member_type (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 @@ -1968,23 +2072,22 @@ 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); + 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); } /* ::= T_ ::= T <(parameter-2 non-negative) number> _ */ -static struct d_comp * -d_template_param (di) - struct d_info *di; +static struct demangle_component * +d_template_param (struct d_info *di) { long param; @@ -2004,18 +2107,19 @@ d_template_param (di) if (d_next_char (di) != '_') return NULL; + ++di->did_subs; + return d_make_template_param (di, param); } /* ::= I + E */ -static struct d_comp * -d_template_args (di) - struct d_info *di; +static struct demangle_component * +d_template_args (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 @@ -2029,13 +2133,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); @@ -2057,11 +2161,10 @@ d_template_args (di) ::= */ -static struct d_comp * -d_template_arg (di) - struct d_info *di; +static struct demangle_component * +d_template_arg (struct d_info *di) { - struct d_comp *ret; + struct demangle_component *ret; switch (d_peek_char (di)) { @@ -2076,7 +2179,7 @@ d_template_arg (di) return d_expr_primary (di); default: - return d_type (di); + return cplus_demangle_type (di); } } @@ -2090,9 +2193,8 @@ d_template_arg (di) ::= */ -static struct d_comp * -d_expression (di) - struct d_info *di; +static struct demangle_component * +d_expression (struct d_info *di) { char peek; @@ -2103,43 +2205,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; } @@ -2147,27 +2253,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)))); } @@ -2182,22 +2293,30 @@ d_expression (di) ::= L E */ -static struct d_comp * -d_expr_primary (di) - struct d_info *di; +static struct demangle_component * +d_expr_primary (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; + struct demangle_component *type; + enum demangle_component_type t; const char *s; - type = d_type (di); + type = cplus_demangle_type (di); + if (type == NULL) + return NULL; + + /* If we have a type we know how to print, we aren't going to + print the type name itself. */ + 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 @@ -2210,11 +2329,20 @@ d_expr_primary (di) constant in any readable form anyhow. We don't attempt to handle these cases. */ + t = DEMANGLE_COMPONENT_LITERAL; + if (d_peek_char (di) == 'n') + { + t = DEMANGLE_COMPONENT_LITERAL_NEG; + d_advance (di, 1); + } s = d_str (di); while (d_peek_char (di) != 'E') - d_advance (di, 1); - ret = d_make_comp (di, D_COMP_LITERAL, type, - d_make_name (di, s, d_str (di) - s)); + { + if (d_peek_char (di) == '\0') + return NULL; + d_advance (di, 1); + } + ret = d_make_comp (di, t, type, d_make_name (di, s, d_str (di) - s)); } if (d_next_char (di) != 'E') return NULL; @@ -2225,11 +2353,10 @@ d_expr_primary (di) ::= Z <(function) encoding> E s [] */ -static struct d_comp * -d_local_name (di) - struct d_info *di; +static struct demangle_component * +d_local_name (struct d_info *di) { - struct d_comp *function; + struct demangle_component *function; if (d_next_char (di) != 'Z') return NULL; @@ -2244,18 +2371,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); } } @@ -2265,8 +2392,7 @@ d_local_name (di) We should print it out in verbose mode. */ static int -d_discriminator (di) - struct d_info *di; +d_discriminator (struct d_info *di) { long discrim; @@ -2282,9 +2408,7 @@ d_discriminator (di) /* Add a new substitution. */ static int -d_add_substitution (di, dc) - struct d_info *di; - struct d_comp *dc; +d_add_substitution (struct d_info *di, struct demangle_component *dc) { if (dc == NULL) return 0; @@ -2304,11 +2428,43 @@ d_add_substitution (di, dc) ::= Si ::= So ::= Sd + + If PREFIX is non-zero, then this type is being used as a prefix in + a qualified name. In this case, for the standard substitutions, we + need to check whether we are being used as a prefix for a + constructor or destructor, and return a full template name. + Otherwise we will get something like std::iostream::~iostream() + which does not correspond particularly well to any function which + actually appears in the source. */ -static struct d_comp * -d_substitution (di) - struct d_info *di; +static const struct d_standard_sub_info standard_subs[] = +{ + { '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, std::allocator >"), + NL ("basic_string") }, + { 'i', NL ("std::istream"), + NL ("std::basic_istream >"), + NL ("basic_istream") }, + { 'o', NL ("std::ostream"), + NL ("std::basic_ostream >"), + NL ("basic_ostream") }, + { 'd', NL ("std::iostream"), + NL ("std::basic_iostream >"), + NL ("basic_iostream") } +}; + +static struct demangle_component * +d_substitution (struct d_info *di, int prefix) { char c; @@ -2316,7 +2472,7 @@ d_substitution (di) return NULL; c = d_next_char (di); - if (c == '_' || IS_DIGIT (c) || (c >= 'A' && c <= 'Z')) + if (c == '_' || IS_DIGIT (c) || IS_UPPER (c)) { int id; @@ -2327,7 +2483,7 @@ d_substitution (di) { if (IS_DIGIT (c)) id = id * 36 + c - '0'; - else if (c >= 'A' && c <= 'Z') + else if (IS_UPPER (c)) id = id * 36 + c - 'A' + 10; else return NULL; @@ -2341,44 +2497,61 @@ d_substitution (di) if (id >= di->next_sub) return NULL; + ++di->did_subs; + return di->subs[id]; } else { - switch (c) + int verbose; + const struct d_standard_sub_info *p; + const struct d_standard_sub_info *pend; + + verbose = (di->options & DMGL_VERBOSE) != 0; + if (! verbose && prefix) { - case 't': - return d_make_sub (di, "std"); - case 'a': - di->last_name = d_make_sub (di, "allocator"); - return d_make_sub (di, "std::allocator"); - case 'b': - di->last_name = d_make_sub (di, "basic_string"); - return d_make_sub (di, "std::basic_string"); - case 's': - di->last_name = d_make_sub (di, "string"); - return d_make_sub (di, "std::string"); - case 'i': - di->last_name = d_make_sub (di, "istream"); - return d_make_sub (di, "std::istream"); - case 'o': - di->last_name = d_make_sub (di, "ostream"); - return d_make_sub (di, "std::ostream"); - case 'd': - di->last_name = d_make_sub (di, "iostream"); - return d_make_sub (di, "std::iostream"); - default: - return NULL; + char peek; + + peek = d_peek_char (di); + if (peek == 'C' || peek == 'D') + verbose = 1; } + + pend = (&standard_subs[0] + + sizeof standard_subs / sizeof standard_subs[0]); + for (p = &standard_subs[0]; p < pend; ++p) + { + 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, + p->set_last_name_len); + if (verbose) + { + s = p->full_expansion; + len = p->full_len; + } + else + { + s = p->simple_expansion; + len = p->simple_len; + } + di->expansion += len; + return d_make_sub (di, s, len); + } + } + + return NULL; } } /* Resize the print buffer. */ static void -d_print_resize (dpi, add) - struct d_print_info *dpi; - size_t add; +d_print_resize (struct d_print_info *dpi, size_t add) { size_t need; @@ -2391,7 +2564,7 @@ d_print_resize (dpi, add) char *newbuf; newalc = dpi->alc * 2; - newbuf = realloc (dpi->buf, newalc); + newbuf = (char *) realloc (dpi->buf, newalc); if (newbuf == NULL) { free (dpi->buf); @@ -2407,9 +2580,7 @@ d_print_resize (dpi, add) /* Append a character to the print buffer. */ static void -d_print_append_char (dpi, c) - struct d_print_info *dpi; - int c; +d_print_append_char (struct d_print_info *dpi, int c) { if (dpi->buf != NULL) { @@ -2428,10 +2599,7 @@ d_print_append_char (dpi, c) /* Append a buffer to the print buffer. */ static void -d_print_append_buffer (dpi, s, l) - struct d_print_info *dpi; - const char *s; - size_t l; +d_print_append_buffer (struct d_print_info *dpi, const char *s, size_t l) { if (dpi->buf != NULL) { @@ -2450,30 +2618,31 @@ d_print_append_buffer (dpi, s, l) /* Indicate that an error occurred during printing. */ static void -d_print_error (dpi) - struct d_print_info *dpi; +d_print_error (struct d_print_info *dpi) { free (dpi->buf); dpi->buf = NULL; } -/* 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) - int options; - const struct d_comp *dc; - size_t *palc; +CP_STATIC_IF_GLIBCPP_V3 +char * +cplus_demangle_print (int options, const struct demangle_component *dc, + int estimate, size_t *palc) { struct d_print_info dpi; dpi.options = options; - dpi.alc = 64; - dpi.buf = malloc (dpi.alc); + dpi.alc = estimate + 1; + dpi.buf = (char *) malloc (dpi.alc); if (dpi.buf == NULL) { *palc = 1; @@ -2501,9 +2670,8 @@ d_print (options, dc, palc) /* Subroutine to handle components. */ static void -d_print_comp (dpi, dc) - struct d_print_info *dpi; - const struct d_comp *dc; +d_print_comp (struct d_print_info *dpi, + const struct demangle_component *dc) { if (dc == NULL) { @@ -2515,80 +2683,124 @@ 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: { - const struct d_comp *typed_name; - struct d_print_mod dpm; + struct d_print_mod *hold_modifiers; + struct demangle_component *typed_name; + struct d_print_mod adpm[4]; + unsigned int i; struct d_print_template dpt; /* Pass the name down to the type so that it can be printed in - the right place for the type. If the name has - CV-qualifiers, they are really method qualifiers; pull them - off now and print them after everything else. Note that we - don't handle D_COMP_VENDOR_TYPE_QUAL here; it's not - accepted by d_cv_qualifiers() either. */ + the right place for the type. We also have to pass down + any CV-qualifiers, which apply to the this parameter. */ + hold_modifiers = dpi->modifiers; + i = 0; typed_name = d_left (dc); - while (typed_name != NULL - && (typed_name->type == D_COMP_RESTRICT - || typed_name->type == D_COMP_VOLATILE - || typed_name->type == D_COMP_CONST)) - typed_name = d_left (typed_name); + while (typed_name != NULL) + { + if (i >= sizeof adpm / sizeof adpm[0]) + { + d_print_error (dpi); + return; + } - dpm.next = dpi->modifiers; - dpi->modifiers = &dpm; - dpm.mod = typed_name; - dpm.printed = 0; - dpm.templates = dpi->templates; + adpm[i].next = dpi->modifiers; + dpi->modifiers = &adpm[i]; + adpm[i].mod = typed_name; + adpm[i].printed = 0; + adpm[i].templates = dpi->templates; + ++i; + + 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); + } /* 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; + dpt.template_decl = 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 modifier didn't get printed by the type, print it + /* If the modifiers didn't get printed by the type, print them now. */ - if (! dpm.printed) + while (i > 0) { - d_append_char (dpi, ' '); - d_print_comp (dpi, typed_name); + --i; + if (! adpm[i].printed) + { + d_append_char (dpi, ' '); + d_print_mod (dpi, adpm[i].mod); + } } - dpi->modifiers = dpm.next; - - /* Now print any CV-qualifiers on the type. */ - typed_name = d_left (dc); - while (typed_name != NULL - && (typed_name->type == D_COMP_RESTRICT - || typed_name->type == D_COMP_VOLATILE - || typed_name->type == D_COMP_CONST)) - { - d_print_mod (dpi, typed_name); - typed_name = d_left (typed_name); - } + dpi->modifiers = hold_modifiers; return; } - case D_COMP_TEMPLATE: + case DEMANGLE_COMPONENT_TEMPLATE: { struct d_print_mod *hold_dpm; @@ -2600,11 +2812,13 @@ d_print_comp (dpi, dc) dpi->modifiers = NULL; d_print_comp (dpi, d_left (dc)); + if (d_last_char (dpi) == '<') + d_append_char (dpi, ' '); d_append_char (dpi, '<'); d_print_comp (dpi, d_right (dc)); /* Avoid generating two consecutive '>' characters, to avoid the C++ syntactic ambiguity. */ - if (dpi->buf != NULL && dpi->buf[dpi->len - 1] == '>') + if (d_last_char (dpi) == '>') d_append_char (dpi, ' '); d_append_char (dpi, '>'); @@ -2613,10 +2827,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) @@ -2625,11 +2839,11 @@ d_print_comp (dpi, dc) return; } i = dc->u.s_number.number; - for (a = d_right (dpi->templates->template); + for (a = d_right (dpi->templates->template_decl); 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; @@ -2659,89 +2873,121 @@ 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_HIDDEN_ALIAS: + d_append_string_constant (dpi, "hidden alias for "); + d_print_comp (dpi, d_left (dc)); return; - 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 DEMANGLE_COMPONENT_SUB_STD: + d_append_buffer (dpi, dc->u.s_string.string, dc->u.s_string.len); + return; + + case DEMANGLE_COMPONENT_RESTRICT: + case DEMANGLE_COMPONENT_VOLATILE: + case DEMANGLE_COMPONENT_CONST: + { + struct d_print_mod *pdpm; + + /* When printing arrays, it's possible to have cases where the + same CV-qualifier gets pushed on the stack multiple times. + We only need to print it once. */ + + for (pdpm = dpi->modifiers; pdpm != NULL; pdpm = pdpm->next) + { + if (! pdpm->printed) + { + if (pdpm->mod->type != DEMANGLE_COMPONENT_RESTRICT + && pdpm->mod->type != DEMANGLE_COMPONENT_VOLATILE + && pdpm->mod->type != DEMANGLE_COMPONENT_CONST) + break; + if (pdpm->mod->type == dc->type) + { + d_print_comp (dpi, d_left (dc)); + return; + } + } + } + } + /* Fall through. */ + 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; @@ -2764,18 +3010,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) { @@ -2805,54 +3053,83 @@ d_print_comp (dpi, dc) return; } - case D_COMP_ARRAY_TYPE: + case DEMANGLE_COMPONENT_ARRAY_TYPE: { - struct d_print_mod dpm; + struct d_print_mod *hold_modifiers; + struct d_print_mod adpm[4]; + unsigned int i; + struct d_print_mod *pdpm; /* We must pass this type down as a modifier in order to print - multi-dimensional arrays correctly. */ + multi-dimensional arrays correctly. If the array itself is + CV-qualified, we act as though the element type were + CV-qualified. We do this by copying the modifiers down + rather than fiddling pointers, so that we don't wind up + with a d_print_mod higher on the stack pointing into our + stack frame after we return. */ + + hold_modifiers = dpi->modifiers; + + adpm[0].next = hold_modifiers; + dpi->modifiers = &adpm[0]; + adpm[0].mod = dc; + adpm[0].printed = 0; + adpm[0].templates = dpi->templates; + + i = 1; + pdpm = hold_modifiers; + while (pdpm != NULL + && (pdpm->mod->type == DEMANGLE_COMPONENT_RESTRICT + || pdpm->mod->type == DEMANGLE_COMPONENT_VOLATILE + || pdpm->mod->type == DEMANGLE_COMPONENT_CONST)) + { + if (! pdpm->printed) + { + if (i >= sizeof adpm / sizeof adpm[0]) + { + d_print_error (dpi); + return; + } + + adpm[i] = *pdpm; + adpm[i].next = dpi->modifiers; + dpi->modifiers = &adpm[i]; + pdpm->printed = 1; + ++i; + } - dpm.next = dpi->modifiers; - dpi->modifiers = &dpm; - dpm.mod = dc; - dpm.printed = 0; - dpm.templates = dpi->templates; + pdpm = pdpm->next; + } d_print_comp (dpi, d_right (dc)); - dpi->modifiers = dpm.next; + dpi->modifiers = hold_modifiers; - if (dpm.printed) + if (adpm[0].printed) return; + while (i > 1) + { + --i; + d_print_mod (dpi, adpm[i].mod); + } + d_print_array_type (dpi, dc, dpi->modifiers); return; } - case D_COMP_PTRMEM_TYPE: + case DEMANGLE_COMPONENT_PTRMEM_TYPE: { - const struct d_comp *target_type; struct d_print_mod dpm; - /* Pass the name down to the type so that it can be printed in - the right place for the type. If the type has - CV-qualifiers, they are really method qualifiers; pull them - off now and print them after everything else. */ - target_type = d_right (dc); - while (target_type != NULL - && (target_type->type == D_COMP_RESTRICT - || target_type->type == D_COMP_VOLATILE - || target_type->type == D_COMP_CONST)) - target_type = d_left (target_type); - dpm.next = dpi->modifiers; dpi->modifiers = &dpm; dpm.mod = dc; dpm.printed = 0; dpm.templates = dpi->templates; - d_print_comp (dpi, target_type); + d_print_comp (dpi, d_right (dc)); /* If the modifier didn't get printed by the type, print it now. */ @@ -2860,167 +3137,202 @@ 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; - /* Now print any CV-qualifiers on the type. */ - target_type = d_right (dc); - while (target_type != NULL - && (target_type->type == D_COMP_RESTRICT - || target_type->type == D_COMP_VOLATILE - || target_type->type == D_COMP_CONST)) - { - d_print_mod (dpi, target_type); - target_type = d_left (target_type); - } - 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 (c >= 'a' && c <= 'z') + 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_char (dpi, '('); d_print_cast (dpi, d_left (dc)); d_append_char (dpi, ')'); } d_append_char (dpi, '('); d_print_comp (dpi, d_right (dc)); d_append_char (dpi, ')'); - if (d_left (dc)->type == D_COMP_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; } + + /* 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 == 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 == 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: - /* For some builtin types, produce simpler output. */ - if (d_left (dc)->type == D_COMP_BUILTIN_TYPE) - { - switch (d_left (dc)->u.s_builtin.type->print) - { - case D_PRINT_INT: - if (d_right (dc)->type == D_COMP_NAME) - { - d_print_comp (dpi, d_right (dc)); - return; - } - break; + case DEMANGLE_COMPONENT_LITERAL: + case DEMANGLE_COMPONENT_LITERAL_NEG: + { + enum d_builtin_type_print tp; - case D_PRINT_LONG: - if (d_right (dc)->type == D_COMP_NAME) - { - d_print_comp (dpi, d_right (dc)); - d_append_char (dpi, 'l'); - return; - } - break; + /* For some builtin types, produce simpler output. */ + tp = D_PRINT_DEFAULT; + if (d_left (dc)->type == DEMANGLE_COMPONENT_BUILTIN_TYPE) + { + tp = d_left (dc)->u.s_builtin.type->print; + switch (tp) + { + case D_PRINT_INT: + case D_PRINT_UNSIGNED: + case D_PRINT_LONG: + case D_PRINT_UNSIGNED_LONG: + case D_PRINT_LONG_LONG: + case D_PRINT_UNSIGNED_LONG_LONG: + if (d_right (dc)->type == DEMANGLE_COMPONENT_NAME) + { + if (dc->type == DEMANGLE_COMPONENT_LITERAL_NEG) + d_append_char (dpi, '-'); + d_print_comp (dpi, d_right (dc)); + switch (tp) + { + default: + break; + case D_PRINT_UNSIGNED: + d_append_char (dpi, 'u'); + break; + case D_PRINT_LONG: + d_append_char (dpi, 'l'); + break; + case D_PRINT_UNSIGNED_LONG: + d_append_string_constant (dpi, "ul"); + break; + case D_PRINT_LONG_LONG: + d_append_string_constant (dpi, "ll"); + break; + case D_PRINT_UNSIGNED_LONG_LONG: + d_append_string_constant (dpi, "ull"); + break; + } + return; + } + break; - case D_PRINT_BOOL: - if (d_right (dc)->type == D_COMP_NAME - && d_right (dc)->u.s_name.len == 1) - { - switch (d_right (dc)->u.s_name.s[0]) - { - case '0': - d_append_string (dpi, "false"); - return; - case '1': - d_append_string (dpi, "true"); - return; - default: - break; - } - } - break; + case D_PRINT_BOOL: + if (d_right (dc)->type == DEMANGLE_COMPONENT_NAME + && d_right (dc)->u.s_name.len == 1 + && dc->type == DEMANGLE_COMPONENT_LITERAL) + { + switch (d_right (dc)->u.s_name.s[0]) + { + case '0': + d_append_string_constant (dpi, "false"); + return; + case '1': + d_append_string_constant (dpi, "true"); + return; + default: + break; + } + } + break; - default: - break; - } - } + default: + break; + } + } - d_append_char (dpi, '('); - d_print_comp (dpi, d_left (dc)); - d_append_char (dpi, ')'); - d_print_comp (dpi, d_right (dc)); + d_append_char (dpi, '('); + d_print_comp (dpi, d_left (dc)); + d_append_char (dpi, ')'); + if (dc->type == DEMANGLE_COMPONENT_LITERAL_NEG) + d_append_char (dpi, '-'); + if (tp == D_PRINT_FLOAT) + d_append_char (dpi, '['); + d_print_comp (dpi, d_right (dc)); + if (tp == D_PRINT_FLOAT) + d_append_char (dpi, ']'); + } return; default: @@ -3029,147 +3341,181 @@ 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+_. */ static void -d_print_identifier (dpi, name, len) - struct d_print_info *dpi; - const char *name; - int len; +d_print_java_identifier (struct d_print_info *dpi, const char *name, int len) { - 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+_. */ - 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 (*q >= '0' && *q <= '9') - 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); } } -/* Print a list of modifiers. */ +/* Print a list of modifiers. SUFFIX is 1 if we are printing + qualifiers on this after printing a function. */ static void -d_print_mod_list (dpi, mods) - struct d_print_info *dpi; - struct d_print_mod *mods; +d_print_mod_list (struct d_print_info *dpi, + struct d_print_mod *mods, int suffix) { struct d_print_template *hold_dpt; - if (mods == NULL || mods->printed || d_print_saw_error (dpi)) + if (mods == NULL || d_print_saw_error (dpi)) return; + if (mods->printed + || (! suffix + && (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; + } + mods->printed = 1; 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); dpi->templates = hold_dpt; - d_print_mod_list (dpi, mods->next); + d_print_mod_list (dpi, mods->next, suffix); } /* Print a modifier. */ static void -d_print_mod (dpi, mod) - struct d_print_info *dpi; - const struct d_comp *mod; +d_print_mod (struct d_print_info *dpi, + const struct demangle_component *mod) { switch (mod->type) { - case D_COMP_RESTRICT: - 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: - 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: - 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: - if (dpi->buf != NULL && dpi->buf[dpi->len - 1] != '(') + 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: @@ -3183,17 +3529,19 @@ d_print_mod (dpi, mod) /* Print a function type, except for the return type. */ static void -d_print_function_type (dpi, dc, mods) - struct d_print_info *dpi; - const struct d_comp *dc; - struct d_print_mod *mods; +d_print_function_type (struct d_print_info *dpi, + const struct demangle_component *dc, + struct d_print_mod *mods) { int need_paren; int saw_mod; + int need_space; struct d_print_mod *p; + struct d_print_mod *hold_modifiers; need_paren = 0; saw_mod = 0; + need_space = 0; for (p = mods; p != NULL; p = p->next) { if (p->printed) @@ -3202,17 +3550,24 @@ 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_POINTER: + case DEMANGLE_COMPONENT_REFERENCE: + need_paren = 1; + break; + case DEMANGLE_COMPONENT_RESTRICT: + case DEMANGLE_COMPONENT_VOLATILE: + case DEMANGLE_COMPONENT_CONST: + case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL: + case DEMANGLE_COMPONENT_COMPLEX: + case DEMANGLE_COMPONENT_IMAGINARY: + case DEMANGLE_COMPONENT_PTRMEM_TYPE: + need_space = 1; need_paren = 1; break; + case DEMANGLE_COMPONENT_RESTRICT_THIS: + case DEMANGLE_COMPONENT_VOLATILE_THIS: + case DEMANGLE_COMPONENT_CONST_THIS: + break; default: break; } @@ -3224,9 +3579,22 @@ d_print_function_type (dpi, dc, mods) need_paren = 1; if (need_paren) - d_append_char (dpi, '('); + { + if (! need_space) + { + if (d_last_char (dpi) != '(' + && d_last_char (dpi) != '*') + need_space = 1; + } + if (need_space && d_last_char (dpi) != ' ') + d_append_char (dpi, ' '); + d_append_char (dpi, '('); + } + + hold_modifiers = dpi->modifiers; + dpi->modifiers = NULL; - d_print_mod_list (dpi, mods); + d_print_mod_list (dpi, mods, 0); if (need_paren) d_append_char (dpi, ')'); @@ -3237,15 +3605,18 @@ d_print_function_type (dpi, dc, mods) d_print_comp (dpi, d_right (dc)); d_append_char (dpi, ')'); + + d_print_mod_list (dpi, mods, 1); + + dpi->modifiers = hold_modifiers; } /* Print an array type, except for the element type. */ static void -d_print_array_type (dpi, dc, mods) - struct d_print_info *dpi; - const struct d_comp *dc; - struct d_print_mod *mods; +d_print_array_type (struct d_print_info *dpi, + const struct demangle_component *dc, + struct d_print_mod *mods) { int need_space; @@ -3258,26 +3629,26 @@ d_print_array_type (dpi, dc, mods) need_paren = 0; for (p = mods; p != NULL; p = p->next) { - if (p->printed) - break; - - if (p->mod->type == D_COMP_ARRAY_TYPE) - { - need_space = 0; - break; - } - else + if (! p->printed) { - need_paren = 1; - need_space = 1; - break; + if (p->mod->type == DEMANGLE_COMPONENT_ARRAY_TYPE) + { + need_space = 0; + break; + } + else + { + need_paren = 1; + need_space = 1; + break; + } } } if (need_paren) - d_append_string (dpi, " ("); + d_append_string_constant (dpi, " ("); - d_print_mod_list (dpi, mods); + d_print_mod_list (dpi, mods, 0); if (need_paren) d_append_char (dpi, ')'); @@ -3297,12 +3668,12 @@ d_print_array_type (dpi, dc, mods) /* Print an operator in an expression. */ static void -d_print_expr_op (dpi, dc) - struct d_print_info *dpi; - const struct d_comp *dc; +d_print_expr_op (struct d_print_info *dpi, + 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); } @@ -3310,11 +3681,10 @@ d_print_expr_op (dpi, dc) /* Print a cast. */ static void -d_print_cast (dpi, dc) - struct d_print_info *dpi; - const struct d_comp *dc; +d_print_cast (struct d_print_info *dpi, + 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 { @@ -3324,24 +3694,26 @@ d_print_cast (dpi, dc) /* It appears that for a templated cast operator, we need to put the template parameters in scope for the operator name, but not for the parameters. The effect is that we need to handle - the template printing here. FIXME: Verify this. */ + the template printing here. */ hold_dpm = dpi->modifiers; dpi->modifiers = NULL; dpt.next = dpi->templates; dpi->templates = &dpt; - dpt.template = d_left (dc); + dpt.template_decl = d_left (dc); d_print_comp (dpi, d_left (d_left (dc))); dpi->templates = dpt.next; + if (d_last_char (dpi) == '<') + d_append_char (dpi, ' '); d_append_char (dpi, '<'); d_print_comp (dpi, d_right (d_left (dc))); /* Avoid generating two consecutive '>' characters, to avoid the C++ syntactic ambiguity. */ - if (dpi->buf != NULL && dpi->buf[dpi->len - 1] == '>') + if (d_last_char (dpi) == '>') d_append_char (dpi, ' '); d_append_char (dpi, '>'); @@ -3352,14 +3724,13 @@ d_print_cast (dpi, dc) /* Initialize the information structure we use to pass around information. */ -static int -d_init_info (mangled, options, len, di) - const char *mangled; - int options; - size_t len; - struct d_info *di; +CP_STATIC_IF_GLIBCPP_V3 +void +cplus_demangle_init_info (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; @@ -3368,29 +3739,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 @@ -3401,15 +3760,13 @@ d_init_info (mangled, options, len, di) a memory allocation failure. On failure, this returns NULL. */ static char * -d_demangle (mangled, options, palc) - const char* mangled; - int options; - size_t *palc; +d_demangle (const char* mangled, int options, size_t *palc) { size_t len; int type; struct d_info di; - struct d_comp *dc; + struct demangle_component *dc; + int estimate; char *ret; *palc = 0; @@ -3425,7 +3782,7 @@ d_demangle (mangled, options, palc) { char *r; - r = malloc (40 + len - 11); + r = (char *) malloc (40 + len - 11); if (r == NULL) *palc = 1; else @@ -3445,39 +3802,89 @@ 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; #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; } #if defined(IN_LIBGCC2) || defined(IN_GLIBCPP_V3) -extern char *__cxa_demangle PARAMS ((const char *, char *, size_t *, int *)); +extern char *__cxa_demangle (const char *, char *, size_t *, int *); /* ia64 ABI-mandated entry point in the C++ runtime library for performing demangling. MANGLED_NAME is a NUL-terminated character @@ -3506,38 +3913,37 @@ extern char *__cxa_demangle PARAMS ((const char *, char *, size_t *, int *)); GNU extensions. */ char * -__cxa_demangle (mangled_name, output_buffer, length, status) - const char *mangled_name; - char *output_buffer; - size_t *length; - int *status; +__cxa_demangle (const char *mangled_name, char *output_buffer, + size_t *length, int *status) { char *demangled; size_t alc; - if (status == NULL) - return NULL; - if (mangled_name == NULL) { - *status = -3; + if (status != NULL) + *status = -3; return NULL; } if (output_buffer != NULL && length == NULL) { - *status = -3; + if (status != NULL) + *status = -3; return NULL; } - demangled = d_demangle (mangled_name, DMGL_TYPES, &alc); + demangled = d_demangle (mangled_name, DMGL_PARAMS | DMGL_TYPES, &alc); if (demangled == NULL) { - if (alc == 1) - *status = -1; - else - *status = -2; + if (status != NULL) + { + if (alc == 1) + *status = -1; + else + *status = -2; + } return NULL; } @@ -3561,7 +3967,8 @@ __cxa_demangle (mangled_name, output_buffer, length, status) } } - *status = 0; + if (status != NULL) + *status = 0; return demangled; } @@ -3573,9 +3980,7 @@ __cxa_demangle (mangled_name, output_buffer, length, status) demangled name. Otherwise, return NULL. */ char * -cplus_demangle_v3 (mangled, options) - const char* mangled; - int options; +cplus_demangle_v3 (const char* mangled, int options) { size_t alc; @@ -3590,8 +3995,7 @@ cplus_demangle_v3 (mangled, options) of JArray with TYPE[]. */ char * -java_demangle_v3 (mangled) - const char* mangled; +java_demangle_v3 (const char* mangled) { size_t alc; char *demangled; @@ -3641,60 +4045,92 @@ java_demangle_v3 (mangled) *DTOR_KIND appropriately. */ static int -is_ctor_or_dtor (mangled, ctor_kind, dtor_kind) - const char *mangled; - enum gnu_v3_ctor_kinds *ctor_kind; - enum gnu_v3_dtor_kinds *dtor_kind; +is_ctor_or_dtor (const char *mangled, + enum gnu_v3_ctor_kinds *ctor_kind, + enum gnu_v3_dtor_kinds *dtor_kind) { struct d_info di; - struct 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); + + { +#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 - dc = d_mangled_name (&di, 1); + dc = cplus_demangle_mangled_name (&di, 1); - if (dc == NULL) - return 0; + /* Note that because we did not pass DMGL_PARAMS, we don't expect + to demangle the entire string. */ - while (dc != NULL) - { - switch (dc->type) - { - default: - return 0; - case D_COMP_TYPED_NAME: - case D_COMP_TEMPLATE: - case D_COMP_RESTRICT: - case D_COMP_VOLATILE: - case D_COMP_CONST: - case D_COMP_VENDOR_TYPE_QUAL: - 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; - return 1; - case D_COMP_DTOR: - *dtor_kind = dc->u.s_dtor.kind; - return 1; - } - } + 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; + } + } - return 0; +#ifndef CP_DYNAMIC_ARRAYS + free (di.subs); + free (di.comps); +#endif + } + + return ret; } /* Return whether NAME is the mangled form of a g++ V3 ABI constructor name. A non-zero return indicates the type of constructor. */ enum gnu_v3_ctor_kinds -is_gnu_v3_mangled_ctor (name) - const char *name; +is_gnu_v3_mangled_ctor (const char *name) { enum gnu_v3_ctor_kinds ctor_kind; enum gnu_v3_dtor_kinds dtor_kind; @@ -3709,8 +4145,7 @@ is_gnu_v3_mangled_ctor (name) name. A non-zero return indicates the type of destructor. */ enum gnu_v3_dtor_kinds -is_gnu_v3_mangled_dtor (name) - const char *name; +is_gnu_v3_mangled_dtor (const char *name) { enum gnu_v3_ctor_kinds ctor_kind; enum gnu_v3_dtor_kinds dtor_kind; @@ -3727,7 +4162,7 @@ is_gnu_v3_mangled_dtor (name) #include "getopt.h" #include "dyn-string.h" -static void print_usage PARAMS ((FILE* fp, int exit_value)); +static void print_usage (FILE* fp, int exit_value); #define IS_ALPHA(CHAR) \ (((CHAR) >= 'a' && (CHAR) <= 'z') \ @@ -3744,9 +4179,7 @@ const char* program_name; /* Prints usage summary to FP and then exits with EXIT_VALUE. */ static void -print_usage (fp, exit_value) - FILE* fp; - int exit_value; +print_usage (FILE* fp, int exit_value) { fprintf (fp, "Usage: %s [options] [names ...]\n", program_name); fprintf (fp, "Options:\n"); @@ -3773,9 +4206,7 @@ static const struct option long_options[] = with their demangled equivalents. */ int -main (argc, argv) - int argc; - char *argv[]; +main (int argc, char *argv[]) { int i; int opt_char; @@ -3833,7 +4264,11 @@ main (argc, argv) if (dyn_string_length (mangled) > 0) { +#ifdef IN_GLIBCPP_V3 + s = __cxa_demangle (dyn_string_buf (mangled), NULL, NULL, NULL); +#else s = cplus_demangle_v3 (dyn_string_buf (mangled), options); +#endif if (s != NULL) { @@ -3865,9 +4300,16 @@ main (argc, argv) for (i = optind; i < argc; ++i) { char *s; +#ifdef IN_GLIBCPP_V3 + int status; +#endif /* Attempt to demangle. */ +#ifdef IN_GLIBCPP_V3 + s = __cxa_demangle (argv[i], NULL, NULL, &status); +#else s = cplus_demangle_v3 (argv[i], options); +#endif /* If it worked, print the demangled name. */ if (s != NULL) @@ -3876,7 +4318,13 @@ main (argc, argv) free (s); } else - fprintf (stderr, "Failed: %s\n", argv[i]); + { +#ifdef IN_GLIBCPP_V3 + fprintf (stderr, "Failed: %s (status %d)\n", argv[i], status); +#else + fprintf (stderr, "Failed: %s\n", argv[i]); +#endif + } } }