X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=libiberty%2Fcp-demangle.c;h=c0d2ffee7d9d84617e2d0f63fe8fb5d48b4bb064;hb=173373c6f6388171d1d62a217fae90a052395be2;hp=b54cbe2bc316b6c7c69898ad3a30712849c51e03;hpb=b6fb00c07bfde584d9359115ab6e0986627a21a0;p=deliverable%2Fbinutils-gdb.git diff --git a/libiberty/cp-demangle.c b/libiberty/cp-demangle.c index b54cbe2bc3..c0d2ffee7d 100644 --- a/libiberty/cp-demangle.c +++ b/libiberty/cp-demangle.c @@ -1,5 +1,6 @@ /* Demangler for g++ V3 ABI. - Copyright (C) 2003 Free Software Foundation, Inc. + Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2014 + Free Software Foundation, Inc. Written by Ian Lance Taylor . This file is part of the libiberty library, which is part of GCC. @@ -25,7 +26,7 @@ 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 @@ -42,19 +43,48 @@ 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) + int cplus_demangle_v3_callback(const char *mangled, int options, + demangle_callbackref callback) + int java_demangle_v3_callback(const char *mangled, + demangle_callbackref callback) 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 + demangle_callbackref + 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 + cplus_demangle_print_callback + 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.: + If defined, this file defines the following functions, q.v.: char *__cxa_demangle (const char *mangled, char *buf, size_t *len, int *status) - instead of cplus_demangle_v3() and java_demangle_v3(). + int __gcclibcxx_demangle_callback (const char *, + void (*) + (const char *, size_t, void *), + void *) + instead of cplus_demangle_v3[_callback]() and + java_demangle_v3[_callback](). IN_GLIBCPP_V3 - If defined, this file defines only __cxa_demangle(). + If defined, this file defines only __cxa_demangle() and + __gcclibcxx_demangle_callback(), and no other publically visible + functions or variables. STANDALONE_DEMANGLER If defined, this file defines a main() function which demangles @@ -65,6 +95,10 @@ stdout about the mangled string. This is not generally useful. */ +#if defined (_AIX) && !defined (__GNUC__) + #pragma alloca +#endif + #ifdef HAVE_CONFIG_H #include "config.h" #endif @@ -78,9 +112,68 @@ #include #endif +#ifdef HAVE_ALLOCA_H +# include +#else +# ifndef alloca +# ifdef __GNUC__ +# define alloca __builtin_alloca +# else +extern char *alloca (); +# endif /* __GNUC__ */ +# endif /* alloca */ +#endif /* HAVE_ALLOCA_H */ + #include "ansidecl.h" #include "libiberty.h" #include "demangle.h" +#include "cp-demangle.h" + +/* If IN_GLIBCPP_V3 is defined, some functions are made static. We + also rename them via #define to avoid compiler errors when the + static definition conflicts with the extern declaration in a header + file. */ +#ifdef IN_GLIBCPP_V3 + +#define CP_STATIC_IF_GLIBCPP_V3 static + +#define cplus_demangle_fill_name d_fill_name +static int d_fill_name (struct demangle_component *, const char *, int); + +#define cplus_demangle_fill_extended_operator d_fill_extended_operator +static int +d_fill_extended_operator (struct demangle_component *, int, + struct demangle_component *); + +#define cplus_demangle_fill_ctor d_fill_ctor +static int +d_fill_ctor (struct demangle_component *, enum gnu_v3_ctor_kinds, + struct demangle_component *); + +#define cplus_demangle_fill_dtor d_fill_dtor +static int +d_fill_dtor (struct demangle_component *, enum gnu_v3_dtor_kinds, + struct demangle_component *); + +#define cplus_demangle_mangled_name d_mangled_name +static struct demangle_component *d_mangled_name (struct d_info *, int); + +#define cplus_demangle_type d_type +static struct demangle_component *d_type (struct d_info *); + +#define cplus_demangle_print d_print +static char *d_print (int, const struct demangle_component *, int, size_t *); + +#define cplus_demangle_print_callback d_print_callback +static int d_print_callback (int, const struct demangle_component *, + demangle_callbackref, void *); + +#define cplus_demangle_init_info d_init_info +static void d_init_info (const char *, int, size_t, struct d_info *); + +#else /* ! defined(IN_GLIBCPP_V3) */ +#define CP_STATIC_IF_GLIBCPP_V3 +#endif /* ! defined(IN_GLIBCPP_V3) */ /* See if the compiler supports dynamic arrays. */ @@ -102,8 +195,8 @@ V3 demangler code. As of this writing this file has the following undefined references - when compiled with -DIN_GLIBCPP_V3: malloc, realloc, free, memcpy, - strcpy, strcat, strlen. */ + when compiled with -DIN_GLIBCPP_V3: realloc, free, memcpy, strcpy, + strcat, strlen. */ #define IS_DIGIT(c) ((c) >= '0' && (c) <= '9') #define IS_UPPER(c) ((c) >= 'A' && (c) <= 'Z') @@ -115,52 +208,6 @@ #define ANONYMOUS_NAMESPACE_PREFIX_LEN \ (sizeof (ANONYMOUS_NAMESPACE_PREFIX) - 1) -/* Information we keep for operators. */ - -struct d_operator_info -{ - /* Mangled name. */ - const char *code; - /* Real name. */ - const char *name; - /* Length of real name. */ - int len; - /* Number of arguments. */ - int args; -}; - -/* How to print the value of a builtin type. */ - -enum d_builtin_type_print -{ - /* Print as (type)val. */ - D_PRINT_DEFAULT, - /* Print as integer. */ - D_PRINT_INT, - /* Print as long, with trailing `l'. */ - D_PRINT_LONG, - /* Print as bool. */ - D_PRINT_BOOL, - /* Print in usual way, but here to detect void. */ - D_PRINT_VOID -}; - -/* Information we keep for a builtin type. */ - -struct d_builtin_type_info -{ - /* Type name. */ - const char *name; - /* Length of type name. */ - int len; - /* Type name when using Java. */ - const char *java_name; - /* Length of java name. */ - int java_len; - /* How to print a value of this type. */ - enum d_builtin_type_print print; -}; - /* Information we keep for the standard substitutions. */ struct d_standard_sub_info @@ -184,232 +231,11 @@ struct d_standard_sub_info int set_last_name_len; }; -/* Component types found in mangled names. */ - -enum d_comp_type -{ - /* A name. */ - D_COMP_NAME, - /* A qualified name. */ - D_COMP_QUAL_NAME, - /* A local name. */ - D_COMP_LOCAL_NAME, - /* A typed name. */ - D_COMP_TYPED_NAME, - /* A template. */ - D_COMP_TEMPLATE, - /* A template parameter. */ - D_COMP_TEMPLATE_PARAM, - /* A constructor. */ - D_COMP_CTOR, - /* A destructor. */ - D_COMP_DTOR, - /* A vtable. */ - D_COMP_VTABLE, - /* A VTT structure. */ - D_COMP_VTT, - /* A construction vtable. */ - D_COMP_CONSTRUCTION_VTABLE, - /* A typeinfo structure. */ - D_COMP_TYPEINFO, - /* A typeinfo name. */ - D_COMP_TYPEINFO_NAME, - /* A typeinfo function. */ - D_COMP_TYPEINFO_FN, - /* A thunk. */ - D_COMP_THUNK, - /* A virtual thunk. */ - D_COMP_VIRTUAL_THUNK, - /* A covariant thunk. */ - D_COMP_COVARIANT_THUNK, - /* A Java class. */ - D_COMP_JAVA_CLASS, - /* A guard variable. */ - D_COMP_GUARD, - /* A reference temporary. */ - D_COMP_REFTEMP, - /* A standard substitution. */ - D_COMP_SUB_STD, - /* The restrict qualifier. */ - D_COMP_RESTRICT, - /* The volatile qualifier. */ - D_COMP_VOLATILE, - /* The const qualifier. */ - D_COMP_CONST, - /* The restrict qualifier modifying a member function. */ - D_COMP_RESTRICT_THIS, - /* The volatile qualifier modifying a member function. */ - D_COMP_VOLATILE_THIS, - /* The const qualifier modifying a member function. */ - D_COMP_CONST_THIS, - /* A vendor qualifier. */ - D_COMP_VENDOR_TYPE_QUAL, - /* A pointer. */ - D_COMP_POINTER, - /* A reference. */ - D_COMP_REFERENCE, - /* A complex type. */ - D_COMP_COMPLEX, - /* An imaginary type. */ - D_COMP_IMAGINARY, - /* A builtin type. */ - D_COMP_BUILTIN_TYPE, - /* A vendor's builtin type. */ - D_COMP_VENDOR_TYPE, - /* A function type. */ - D_COMP_FUNCTION_TYPE, - /* An array type. */ - D_COMP_ARRAY_TYPE, - /* A pointer to member type. */ - D_COMP_PTRMEM_TYPE, - /* An argument list. */ - D_COMP_ARGLIST, - /* A template argument list. */ - D_COMP_TEMPLATE_ARGLIST, - /* An operator. */ - D_COMP_OPERATOR, - /* An extended operator. */ - D_COMP_EXTENDED_OPERATOR, - /* A typecast. */ - D_COMP_CAST, - /* A unary expression. */ - D_COMP_UNARY, - /* A binary expression. */ - D_COMP_BINARY, - /* Arguments to a binary expression. */ - D_COMP_BINARY_ARGS, - /* A trinary expression. */ - D_COMP_TRINARY, - /* Arguments to a trinary expression. */ - D_COMP_TRINARY_ARG1, - D_COMP_TRINARY_ARG2, - /* A literal. */ - D_COMP_LITERAL, - /* A negative literal. */ - D_COMP_LITERAL_NEG -}; - -/* A component of the mangled name. */ - -struct d_comp -{ - /* The type of this component. */ - enum d_comp_type type; - union - { - /* For D_COMP_NAME. */ - struct - { - /* A pointer to the name (not NULL terminated) and it's - length. */ - const char *s; - int len; - } s_name; - - /* For D_COMP_OPERATOR. */ - struct - { - /* Operator. */ - const struct d_operator_info *op; - } s_operator; - - /* For D_COMP_EXTENDED_OPERATOR. */ - struct - { - /* Number of arguments. */ - int args; - /* Name. */ - struct d_comp *name; - } s_extended_operator; - - /* For D_COMP_CTOR. */ - struct - { - enum gnu_v3_ctor_kinds kind; - struct d_comp *name; - } s_ctor; - - /* For D_COMP_DTOR. */ - struct - { - enum gnu_v3_dtor_kinds kind; - struct d_comp *name; - } s_dtor; - - /* For D_COMP_BUILTIN_TYPE. */ - struct - { - const struct d_builtin_type_info *type; - } s_builtin; - - /* For D_COMP_SUB_STD. */ - struct - { - const char* string; - int len; - } s_string; - - /* For D_COMP_TEMPLATE_PARAM. */ - struct - { - long number; - } s_number; - - /* For other types. */ - struct - { - struct d_comp *left; - struct d_comp *right; - } s_binary; - - } u; -}; +/* Accessors for subtrees of struct demangle_component. */ #define d_left(dc) ((dc)->u.s_binary.left) #define d_right(dc) ((dc)->u.s_binary.right) -/* The information structure we pass around. */ - -struct d_info -{ - /* The string we are demangling. */ - const char *s; - /* The end of the string we are demangling. */ - const char *send; - /* 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 number of substitutions which we actually made from the subs - array, plus the number of template parameter references we - saw. */ - int did_subs; - /* The last name we saw, for constructors and destructors. */ - struct d_comp *last_name; - /* A running total of the length of large expansions from the - mangled name to the demangled name, such as standard - substitutions and builtin types. */ - int expansion; -}; - -#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 @@ -417,7 +243,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. */ @@ -428,320 +254,538 @@ 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. */ struct d_print_template *templates; }; -/* We use this structure to hold information during printing. */ +/* We use these structures to hold information during printing. */ -struct d_print_info +struct d_growable_string { - /* The options passed to the demangler. */ - int options; /* Buffer holding the result. */ char *buf; /* Current length of data in buffer. */ size_t len; /* Allocated size of buffer. */ size_t alc; + /* Set to 1 if we had a memory allocation failure. */ + int allocation_failure; +}; + +/* Stack of components, innermost first, used to avoid loops. */ + +struct d_component_stack +{ + /* This component. */ + const struct demangle_component *dc; + /* This component's parent. */ + const struct d_component_stack *parent; +}; + +/* A demangle component and some scope captured when it was first + traversed. */ + +struct d_saved_scope +{ + /* The component whose scope this is. */ + const struct demangle_component *container; + /* The list of templates, if any, that was current when this + scope was captured. */ + struct d_print_template *templates; +}; + +/* Checkpoint structure to allow backtracking. This holds copies + of the fields of struct d_info that need to be restored + if a trial parse needs to be backtracked over. */ + +struct d_info_checkpoint +{ + const char *n; + int next_comp; + int next_sub; + int did_subs; + int expansion; +}; + +enum { D_PRINT_BUFFER_LENGTH = 256 }; +struct d_print_info +{ + /* Fixed-length allocated buffer for demangled data, flushed to the + callback with a NUL termination once full. */ + char buf[D_PRINT_BUFFER_LENGTH]; + /* Current length of data in buffer. */ + size_t len; + /* The last character printed, saved individually so that it survives + any buffer flush. */ + char last_char; + /* Callback function to handle demangled buffer flush. */ + demangle_callbackref callback; + /* Opaque callback argument. */ + void *opaque; /* The current list of templates, if any. */ struct d_print_template *templates; /* The current list of modifiers (e.g., pointer, reference, etc.), if any. */ struct d_print_mod *modifiers; - /* Set to 1 if we had a memory allocation failure. */ - int allocation_failure; + /* Set to 1 if we saw a demangling error. */ + int demangle_failure; + /* The current index into any template argument packs we are using + for printing. */ + int pack_index; + /* Number of d_print_flush calls so far. */ + unsigned long int flush_count; + /* Stack of components, innermost first, used to avoid loops. */ + const struct d_component_stack *component_stack; + /* Array of saved scopes for evaluating substitutions. */ + struct d_saved_scope *saved_scopes; + /* Index of the next unused saved scope in the above array. */ + int next_saved_scope; + /* Number of saved scopes in the above array. */ + int num_saved_scopes; + /* Array of templates for saving into scopes. */ + struct d_print_template *copy_templates; + /* Index of the next unused copy template in the above array. */ + int next_copy_template; + /* Number of copy templates in the above array. */ + int num_copy_templates; + /* The nearest enclosing template, if any. */ + const struct demangle_component *current_template; }; -#define d_print_saw_error(dpi) ((dpi)->buf == NULL) - -#define d_append_char(dpi, c) \ - do \ - { \ - if ((dpi)->buf != NULL && (dpi)->len < (dpi)->alc) \ - (dpi)->buf[(dpi)->len++] = (c); \ - else \ - d_print_append_char ((dpi), (c)); \ - } \ - while (0) - -#define d_append_buffer(dpi, s, l) \ - do \ - { \ - if ((dpi)->buf != NULL && (dpi)->len + (l) <= (dpi)->alc) \ - { \ - memcpy ((dpi)->buf + (dpi)->len, (s), (l)); \ - (dpi)->len += l; \ - } \ - else \ - d_print_append_buffer ((dpi), (s), (l)); \ - } \ - 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 *, int)); -static struct d_comp *d_mangled_name PARAMS ((struct d_info *, int)); -static int has_return_type PARAMS ((struct d_comp *)); -static int is_ctor_dtor_or_conversion PARAMS ((struct d_comp *)); -static struct d_comp *d_encoding PARAMS ((struct d_info *, int)); -static struct d_comp *d_name PARAMS ((struct d_info *)); -static struct d_comp *d_nested_name PARAMS ((struct d_info *)); -static struct d_comp *d_prefix PARAMS ((struct d_info *)); -static struct d_comp *d_unqualified_name PARAMS ((struct d_info *)); -static struct d_comp *d_source_name PARAMS ((struct d_info *)); -static long d_number PARAMS ((struct d_info *)); -static struct d_comp *d_identifier PARAMS ((struct d_info *, int)); -static struct d_comp *d_operator_name PARAMS ((struct d_info *)); -static struct d_comp *d_special_name PARAMS ((struct d_info *)); -static int d_call_offset PARAMS ((struct d_info *, int)); -static struct d_comp *d_ctor_dtor_name PARAMS ((struct d_info *)); -static struct d_comp *d_type PARAMS ((struct d_info *)); -static struct d_comp **d_cv_qualifiers PARAMS ((struct d_info *, - struct d_comp **, int)); -static struct d_comp *d_function_type PARAMS ((struct d_info *)); -static struct d_comp *d_bare_function_type PARAMS ((struct d_info *, int)); -static struct d_comp *d_class_enum_type PARAMS ((struct d_info *)); -static struct d_comp *d_array_type PARAMS ((struct d_info *)); -static struct d_comp *d_pointer_to_member_type PARAMS ((struct d_info *)); -static struct d_comp *d_template_param PARAMS ((struct d_info *)); -static struct d_comp *d_template_args PARAMS ((struct d_info *)); -static struct d_comp *d_template_arg PARAMS ((struct d_info *)); -static struct d_comp *d_expression PARAMS ((struct d_info *)); -static struct d_comp *d_expr_primary PARAMS ((struct d_info *)); -static struct d_comp *d_local_name PARAMS ((struct d_info *)); -static int d_discriminator PARAMS ((struct d_info *)); -static int d_add_substitution PARAMS ((struct d_info *, struct d_comp *)); -static struct d_comp *d_substitution PARAMS ((struct d_info *, int)); -static void d_print_resize PARAMS ((struct d_print_info *, size_t)); -static void d_print_append_char PARAMS ((struct d_print_info *, int)); -static void d_print_append_buffer PARAMS ((struct d_print_info *, const char *, - size_t)); -static void d_print_error PARAMS ((struct d_print_info *)); -static char *d_print PARAMS ((int, const struct d_comp *, int, size_t *)); -static void d_print_comp PARAMS ((struct d_print_info *, - const struct d_comp *)); -static void d_print_java_identifier PARAMS ((struct d_print_info *, - const char *, int)); -static void d_print_mod_list PARAMS ((struct d_print_info *, - struct d_print_mod *, int)); -static void d_print_mod PARAMS ((struct d_print_info *, - const struct 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 void 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_demangle_mangled_name (struct d_info *, const char *); + +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_ref_qualifier (struct d_info *, struct demangle_component *); + +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_vector_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 struct demangle_component *d_lambda (struct d_info *); + +static struct demangle_component *d_unnamed_type (struct d_info *); + +static struct demangle_component * +d_clone_suffix (struct d_info *, struct demangle_component *); + +static int +d_add_substitution (struct d_info *, struct demangle_component *); + +static struct demangle_component *d_substitution (struct d_info *, int); + +static void d_checkpoint (struct d_info *, struct d_info_checkpoint *); + +static void d_backtrack (struct d_info *, struct d_info_checkpoint *); + +static void d_growable_string_init (struct d_growable_string *, size_t); + +static inline void +d_growable_string_resize (struct d_growable_string *, size_t); + +static inline void +d_growable_string_append_buffer (struct d_growable_string *, + const char *, size_t); +static void +d_growable_string_callback_adapter (const char *, size_t, void *); + +static void +d_print_init (struct d_print_info *, demangle_callbackref, void *, + const struct demangle_component *); + +static inline void d_print_error (struct d_print_info *); + +static inline int d_print_saw_error (struct d_print_info *); + +static inline void d_print_flush (struct d_print_info *); + +static inline void d_append_char (struct d_print_info *, char); + +static inline void d_append_buffer (struct d_print_info *, + const char *, size_t); + +static inline void d_append_string (struct d_print_info *, const char *); + +static inline char d_last_char (struct d_print_info *); + +static void +d_print_comp (struct d_print_info *, int, 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 *, int, struct d_print_mod *, int); + +static void +d_print_mod (struct d_print_info *, int, const struct demangle_component *); + +static void +d_print_function_type (struct d_print_info *, int, + const struct demangle_component *, + struct d_print_mod *); + +static void +d_print_array_type (struct d_print_info *, int, + const struct demangle_component *, + struct d_print_mod *); + +static void +d_print_expr_op (struct d_print_info *, int, const struct demangle_component *); + +static void +d_print_cast (struct d_print_info *, int, const struct demangle_component *); + +static int d_demangle_callback (const char *, int, + demangle_callbackref, void *); +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; if (dc == NULL) - return; + { + if (indent == 0) + printf ("failed demangling\n"); + return; + } for (i = 0; i < indent; ++i) putchar (' '); 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_TAGGED_NAME: + printf ("tagged name\n"); + d_dump (dc->u.s_binary.left, indent + 2); + d_dump (dc->u.s_binary.right, indent + 2); + return; + case DEMANGLE_COMPONENT_TEMPLATE_PARAM: printf ("template parameter %ld\n", dc->u.s_number.number); return; - case D_COMP_CTOR: + case DEMANGLE_COMPONENT_FUNCTION_PARAM: + printf ("function parameter %ld\n", dc->u.s_number.number); + return; + 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_LOCAL_NAME: + case DEMANGLE_COMPONENT_LOCAL_NAME: printf ("local name\n"); break; - case D_COMP_TYPED_NAME: + 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_TRANSACTION_CLONE: + printf ("transaction clone\n"); + break; + case DEMANGLE_COMPONENT_NONTRANSACTION_CLONE: + printf ("non-transaction clone\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_RESTRICT_THIS: + case DEMANGLE_COMPONENT_RESTRICT_THIS: printf ("restrict this\n"); break; - case D_COMP_VOLATILE_THIS: + case DEMANGLE_COMPONENT_VOLATILE_THIS: printf ("volatile this\n"); break; - case D_COMP_CONST_THIS: + case DEMANGLE_COMPONENT_CONST_THIS: printf ("const this\n"); break; - case D_COMP_VENDOR_TYPE_QUAL: + case DEMANGLE_COMPONENT_REFERENCE_THIS: + printf ("reference this\n"); + break; + case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS: + printf ("rvalue reference 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_RVALUE_REFERENCE: + printf ("rvalue reference\n"); + break; + 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_FIXED_TYPE: + printf ("fixed-point type\n"); + break; + 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_INITIALIZER_LIST: + printf ("initializer list\n"); + break; + case DEMANGLE_COMPONENT_CAST: printf ("cast\n"); break; - case D_COMP_UNARY: + case DEMANGLE_COMPONENT_NULLARY: + printf ("nullary operator\n"); + break; + case DEMANGLE_COMPONENT_UNARY: printf ("unary operator\n"); break; - case D_COMP_BINARY: + case DEMANGLE_COMPONENT_BINARY: printf ("binary operator\n"); break; - case D_COMP_BINARY_ARGS: + case DEMANGLE_COMPONENT_BINARY_ARGS: printf ("binary operator arguments\n"); break; - case D_COMP_TRINARY: + case DEMANGLE_COMPONENT_TRINARY: printf ("trinary operator\n"); break; - case D_COMP_TRINARY_ARG1: + case DEMANGLE_COMPONENT_TRINARY_ARG1: printf ("trinary operator arguments 1\n"); break; - case D_COMP_TRINARY_ARG2: + case DEMANGLE_COMPONENT_TRINARY_ARG2: printf ("trinary operator arguments 1\n"); break; - case D_COMP_LITERAL: + case DEMANGLE_COMPONENT_LITERAL: printf ("literal\n"); break; - case D_COMP_LITERAL_NEG: + case DEMANGLE_COMPONENT_LITERAL_NEG: printf ("negative literal\n"); break; + case DEMANGLE_COMPONENT_JAVA_RESOURCE: + printf ("java resource\n"); + break; + case DEMANGLE_COMPONENT_COMPOUND_NAME: + printf ("compound name\n"); + break; + case DEMANGLE_COMPONENT_CHARACTER: + printf ("character '%c'\n", dc->u.s_character.character); + return; + case DEMANGLE_COMPONENT_NUMBER: + printf ("number %ld\n", dc->u.s_number.number); + return; + case DEMANGLE_COMPONENT_DECLTYPE: + printf ("decltype\n"); + break; + case DEMANGLE_COMPONENT_PACK_EXPANSION: + printf ("pack expansion\n"); + break; + case DEMANGLE_COMPONENT_TLS_INIT: + printf ("tls init function\n"); + break; + case DEMANGLE_COMPONENT_TLS_WRAPPER: + printf ("tls wrapper function\n"); + break; + case DEMANGLE_COMPONENT_DEFAULT_ARG: + printf ("default argument %d\n", dc->u.s_unary_num.num); + d_dump (dc->u.s_unary_num.sub, indent+2); + return; + case DEMANGLE_COMPONENT_LAMBDA: + printf ("lambda %d\n", dc->u.s_unary_num.num); + d_dump (dc->u.s_unary_num.sub, indent+2); + return; } d_dump (d_left (dc), indent + 2); @@ -750,33 +794,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 + || (int) kind < gnu_v3_complete_object_ctor + || (int) kind > gnu_v3_object_ctor_group) + 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 + || (int) kind < gnu_v3_deleting_dtor + || (int) kind > gnu_v3_object_dtor_group) + 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 @@ -784,65 +890,84 @@ d_make_comp (di, type, left, right) switch (type) { /* These types require two parameters. */ - case D_COMP_QUAL_NAME: - case D_COMP_LOCAL_NAME: - case D_COMP_TYPED_NAME: - case D_COMP_TEMPLATE: - case D_COMP_VENDOR_TYPE_QUAL: - case D_COMP_PTRMEM_TYPE: - case D_COMP_UNARY: - case D_COMP_BINARY: - case D_COMP_BINARY_ARGS: - case D_COMP_TRINARY: - case D_COMP_TRINARY_ARG1: - case D_COMP_TRINARY_ARG2: - case D_COMP_LITERAL: - case D_COMP_LITERAL_NEG: + case DEMANGLE_COMPONENT_QUAL_NAME: + case DEMANGLE_COMPONENT_LOCAL_NAME: + case DEMANGLE_COMPONENT_TYPED_NAME: + case DEMANGLE_COMPONENT_TAGGED_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_LITERAL: + case DEMANGLE_COMPONENT_LITERAL_NEG: + case DEMANGLE_COMPONENT_COMPOUND_NAME: + case DEMANGLE_COMPONENT_VECTOR_TYPE: + case DEMANGLE_COMPONENT_CLONE: 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_TLS_INIT: + case DEMANGLE_COMPONENT_TLS_WRAPPER: + case DEMANGLE_COMPONENT_REFTEMP: + case DEMANGLE_COMPONENT_HIDDEN_ALIAS: + case DEMANGLE_COMPONENT_TRANSACTION_CLONE: + case DEMANGLE_COMPONENT_NONTRANSACTION_CLONE: + case DEMANGLE_COMPONENT_POINTER: + case DEMANGLE_COMPONENT_REFERENCE: + case DEMANGLE_COMPONENT_RVALUE_REFERENCE: + case DEMANGLE_COMPONENT_COMPLEX: + case DEMANGLE_COMPONENT_IMAGINARY: + case DEMANGLE_COMPONENT_VENDOR_TYPE: + case DEMANGLE_COMPONENT_CAST: + case DEMANGLE_COMPONENT_JAVA_RESOURCE: + case DEMANGLE_COMPONENT_DECLTYPE: + case DEMANGLE_COMPONENT_PACK_EXPANSION: + case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS: + case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS: + case DEMANGLE_COMPONENT_NULLARY: + case DEMANGLE_COMPONENT_TRINARY_ARG2: 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: + case DEMANGLE_COMPONENT_INITIALIZER_LIST: if (right == NULL) return NULL; break; /* These are allowed to have no parameters--in some cases they will be filled in later. */ - case D_COMP_FUNCTION_TYPE: - case D_COMP_RESTRICT: - case D_COMP_VOLATILE: - case D_COMP_CONST: - case D_COMP_RESTRICT_THIS: - case D_COMP_VOLATILE_THIS: - case D_COMP_CONST_THIS: + case DEMANGLE_COMPONENT_FUNCTION_TYPE: + case DEMANGLE_COMPONENT_RESTRICT: + case DEMANGLE_COMPONENT_VOLATILE: + case DEMANGLE_COMPONENT_CONST: + case DEMANGLE_COMPONENT_RESTRICT_THIS: + case DEMANGLE_COMPONENT_VOLATILE_THIS: + case DEMANGLE_COMPONENT_CONST_THIS: + case DEMANGLE_COMPONENT_REFERENCE_THIS: + case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS: + case DEMANGLE_COMPONENT_ARGLIST: + case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST: break; /* Other types should not be seen here. */ @@ -850,179 +975,210 @@ 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; } return p; } +/* Add a new demangle mangled name component. */ + +static struct demangle_component * +d_make_demangle_mangled_name (struct d_info *di, const char *s) +{ + if (d_peek_char (di) != '_' || d_peek_next_char (di) != 'Z') + return d_make_name (di, s, strlen (s)); + d_advance (di, 2); + return d_encoding (di, 0); +} + /* 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; - if (s == NULL || len == 0) + p = d_make_empty (di); + if (! cplus_demangle_fill_name (p, s, len)) return NULL; - p = d_make_empty (di, D_COMP_NAME); - if (p != NULL) - { - p->u.s_name.s = s; - p->u.s_name.len = len; - } return p; } /* Add a new builtin type component. */ -static struct d_comp * -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) + return p; +} + +static struct demangle_component * +d_make_default_arg (struct d_info *di, int num, + struct demangle_component *sub) +{ + struct demangle_component *p = d_make_empty (di); + if (p) { - p->u.s_extended_operator.args = args; - p->u.s_extended_operator.name = name; + p->type = DEMANGLE_COMPONENT_DEFAULT_ARG; + p->u.s_unary_num.num = num; + p->u.s_unary_num.sub = sub; } 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 demangle_component *p; + + p = d_make_empty (di); + if (p != NULL) + { + p->type = DEMANGLE_COMPONENT_TEMPLATE_PARAM; + p->u.s_number.number = i; + } + return p; +} + +/* Add a new function parameter. */ + +static struct demangle_component * +d_make_function_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_FUNCTION_PARAM; + p->u.s_number.number = i; + } return p; } /* Add a new standard substitution component. */ -static struct d_comp * -d_make_sub (di, name, len) - struct d_info *di; - const char *name; - int len; +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->type = DEMANGLE_COMPONENT_SUB_STD; p->u.s_string.string = name; p->u.s_string.len = len; } return p; } -/* ::= _Z +/* ::= _Z []* 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) != '_') + struct demangle_component *p; + + if (! d_check_char (di, '_') + /* Allow missing _ if not at toplevel to work around a + bug in G++ abi-version=2 mangling; see the comment in + write_template_arg. */ + && top_level) return NULL; - if (d_next_char (di) != 'Z') + if (! d_check_char (di, 'Z')) return NULL; - return d_encoding (di, top_level); + p = d_encoding (di, top_level); + + /* If at top level and parsing parameters, check for a clone + suffix. */ + if (top_level && (di->options & DMGL_PARAMS) != 0) + while (d_peek_char (di) == '.' + && (IS_LOWER (d_peek_next_char (di)) + || d_peek_next_char (di) == '_' + || IS_DIGIT (d_peek_next_char (di)))) + p = d_clone_suffix (di, p); + + return p; } /* Return whether a function should have a return type. The argument @@ -1035,8 +1191,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; @@ -1044,11 +1199,13 @@ has_return_type (dc) { default: return 0; - case D_COMP_TEMPLATE: + case DEMANGLE_COMPONENT_TEMPLATE: return ! is_ctor_dtor_or_conversion (d_left (dc)); - case D_COMP_RESTRICT_THIS: - case D_COMP_VOLATILE_THIS: - case D_COMP_CONST_THIS: + case DEMANGLE_COMPONENT_RESTRICT_THIS: + case DEMANGLE_COMPONENT_VOLATILE_THIS: + case DEMANGLE_COMPONENT_CONST_THIS: + case DEMANGLE_COMPONENT_REFERENCE_THIS: + case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS: return has_return_type (d_left (dc)); } } @@ -1057,8 +1214,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; @@ -1066,12 +1222,12 @@ is_ctor_dtor_or_conversion (dc) { default: return 0; - case D_COMP_QUAL_NAME: - case D_COMP_LOCAL_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; } } @@ -1085,10 +1241,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); @@ -1096,7 +1250,7 @@ d_encoding (di, top_level) return d_special_name (di); else { - struct d_comp *dc; + struct demangle_component *dc; dc = d_name (di); @@ -1105,21 +1259,59 @@ d_encoding (di, top_level) /* Strip off any initial CV-qualifiers, as they really apply to the `this' parameter, and they were not output by the v2 demangler without DMGL_PARAMS. */ - while (dc->type == D_COMP_RESTRICT_THIS - || dc->type == D_COMP_VOLATILE_THIS - || dc->type == D_COMP_CONST_THIS) + while (dc->type == DEMANGLE_COMPONENT_RESTRICT_THIS + || dc->type == DEMANGLE_COMPONENT_VOLATILE_THIS + || dc->type == DEMANGLE_COMPONENT_CONST_THIS + || dc->type == DEMANGLE_COMPONENT_REFERENCE_THIS + || dc->type == DEMANGLE_COMPONENT_RVALUE_REFERENCE_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->type == DEMANGLE_COMPONENT_REFERENCE_THIS + || dcr->type == DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS) + dcr = d_left (dcr); + dc->u.s_binary.right = dcr; + } + return dc; } peek = d_peek_char (di); - if (peek == '\0' || peek == 'E') + if (dc == NULL || 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))); } } +/* ::= B */ + +static struct demangle_component * +d_abi_tags (struct d_info *di, struct demangle_component *dc) +{ + char peek; + while (peek = d_peek_char (di), + peek == 'B') + { + struct demangle_component *tag; + d_advance (di, 1); + tag = d_source_name (di); + dc = d_make_comp (di, DEMANGLE_COMPONENT_TAGGED_NAME, dc, tag); + } + return dc; +} + /* ::= ::= ::= @@ -1132,12 +1324,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) { @@ -1147,6 +1338,9 @@ d_name (di) case 'Z': return d_local_name (di); + case 'U': + return d_unqualified_name (di); + case 'S': { int subst; @@ -1159,7 +1353,8 @@ d_name (di) else { d_advance (di, 2); - dc = d_make_comp (di, D_COMP_QUAL_NAME, d_make_name (di, "std", 3), + dc = d_make_comp (di, DEMANGLE_COMPONENT_QUAL_NAME, + d_make_name (di, "std", 3), d_unqualified_name (di)); di->expansion += 3; subst = 0; @@ -1182,12 +1377,14 @@ 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; } + case 'L': default: dc = d_unqualified_name (di); if (d_peek_char (di) == 'I') @@ -1197,35 +1394,46 @@ 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; } } -/* ::= N [] E - ::= N [] E +/* ::= N [] [] E + ::= 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; + struct demangle_component *rqual; - if (d_next_char (di) != 'N') + if (! d_check_char (di, 'N')) return NULL; pret = d_cv_qualifiers (di, &ret, 1); if (pret == NULL) return NULL; + /* Parse the ref-qualifier now and then attach it + once we have something to attach it to. */ + rqual = d_ref_qualifier (di, NULL); + *pret = d_prefix (di); if (*pret == NULL) return NULL; - if (d_next_char (di) != 'E') + if (rqual) + { + d_left (rqual) = ret; + ret = rqual; + } + + if (! d_check_char (di, 'E')) return NULL; return ret; @@ -1234,6 +1442,7 @@ d_nested_name (di) /* ::= ::= ::= + ::= ::= ::= @@ -1242,17 +1451,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') @@ -1262,11 +1470,22 @@ d_prefix (di) that in the grammar. The older code does not accept a here. */ - comb_type = D_COMP_QUAL_NAME; - if (IS_DIGIT (peek) + comb_type = DEMANGLE_COMPONENT_QUAL_NAME; + if (peek == 'D') + { + char peek2 = d_peek_next_char (di); + if (peek2 == 'T' || peek2 == 't') + /* Decltype. */ + dc = cplus_demangle_type (di); + else + /* Destructor name. */ + dc = d_unqualified_name (di); + } + else if (IS_DIGIT (peek) || IS_LOWER (peek) || peek == 'C' - || peek == 'D') + || peek == 'U' + || peek == 'L') dc = d_unqualified_name (di); else if (peek == 'S') dc = d_substitution (di, 1); @@ -1274,13 +1493,23 @@ d_prefix (di) { if (ret == NULL) return NULL; - comb_type = D_COMP_TEMPLATE; + comb_type = DEMANGLE_COMPONENT_TEMPLATE; dc = d_template_args (di); } else if (peek == 'T') dc = d_template_param (di); else if (peek == 'E') return ret; + else if (peek == 'M') + { + /* Initializer scope for a lambda. We don't need to represent + this; the normal code will just treat the variable as a type + scope, which gives appropriate output. */ + if (ret == NULL) + return NULL; + d_advance (di, 1); + continue; + } else return NULL; @@ -1300,40 +1529,72 @@ d_prefix (di) /* ::= ::= ::= + ::= + + ::= L */ -static struct d_comp * -d_unqualified_name (di) - struct d_info *di; +static struct demangle_component * +d_unqualified_name (struct d_info *di) { + struct demangle_component *ret; char peek; peek = d_peek_char (di); if (IS_DIGIT (peek)) - return d_source_name (di); + ret = d_source_name (di); else if (IS_LOWER (peek)) { - struct d_comp *ret; - ret = d_operator_name (di); - if (ret != NULL && ret->type == D_COMP_OPERATOR) - di->expansion += sizeof "operator" + ret->u.s_operator.op->len - 2; - return ret; + if (ret != NULL && ret->type == DEMANGLE_COMPONENT_OPERATOR) + { + di->expansion += sizeof "operator" + ret->u.s_operator.op->len - 2; + if (!strcmp (ret->u.s_operator.op->code, "li")) + ret = d_make_comp (di, DEMANGLE_COMPONENT_UNARY, ret, + d_source_name (di)); + } } else if (peek == 'C' || peek == 'D') - return d_ctor_dtor_name (di); + ret = d_ctor_dtor_name (di); + else if (peek == 'L') + { + d_advance (di, 1); + + ret = d_source_name (di); + if (ret == NULL) + return NULL; + if (! d_discriminator (di)) + return NULL; + } + else if (peek == 'U') + { + switch (d_peek_next_char (di)) + { + case 'l': + ret = d_lambda (di); + break; + case 't': + ret = d_unnamed_type (di); + break; + default: + return NULL; + } + } else return NULL; + + if (d_peek_char (di) == 'B') + ret = d_abi_tags (di, ret); + return ret; } /* ::= <(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) @@ -1346,8 +1607,7 @@ 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 negative; char peek; @@ -1377,12 +1637,24 @@ d_number (di) } } +/* Like d_number, but returns a demangle_component. */ + +static struct demangle_component * +d_number_component (struct d_info *di) +{ + struct demangle_component *ret = d_make_empty (di); + if (ret) + { + ret->type = DEMANGLE_COMPONENT_NUMBER; + ret->u.s_number.number = d_number (di); + } + return ret; +} + /* 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; @@ -1425,33 +1697,43 @@ d_identifier (di, len) /* operator_name ::= many different two character encodings. ::= cv ::= v -*/ + + This list is sorted for binary search. */ #define NL(s) s, (sizeof s) - 1 -static const struct d_operator_info d_operators[] = +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 }, + { "at", NL ("alignof "), 1 }, + { "az", NL ("alignof "), 1 }, + { "cc", NL ("const_cast"), 2 }, + { "cl", NL ("()"), 2 }, { "cm", NL (","), 2 }, { "co", NL ("~"), 1 }, { "dV", NL ("/="), 2 }, - { "da", NL ("delete[]"), 1 }, + { "da", NL ("delete[] "), 1 }, + { "dc", NL ("dynamic_cast"), 2 }, { "de", NL ("*"), 1 }, - { "dl", NL ("delete"), 1 }, + { "dl", NL ("delete "), 1 }, + { "ds", NL (".*"), 2 }, + { "dt", NL ("."), 2 }, { "dv", NL ("/"), 2 }, { "eO", NL ("^="), 2 }, { "eo", NL ("^"), 2 }, { "eq", NL ("=="), 2 }, { "ge", NL (">="), 2 }, + { "gs", NL ("::"), 1 }, { "gt", NL (">"), 2 }, { "ix", NL ("[]"), 2 }, { "lS", NL ("<<="), 2 }, { "le", NL ("<="), 2 }, + { "li", NL ("operator\"\" "), 1 }, { "ls", NL ("<<"), 2 }, { "lt", NL ("<"), 2 }, { "mI", NL ("-="), 2 }, @@ -1459,11 +1741,11 @@ static const struct d_operator_info d_operators[] = { "mi", NL ("-"), 2 }, { "ml", NL ("*"), 2 }, { "mm", NL ("--"), 1 }, - { "na", NL ("new[]"), 1 }, + { "na", NL ("new[]"), 3 }, { "ne", NL ("!="), 2 }, { "ng", NL ("-"), 1 }, { "nt", NL ("!"), 1 }, - { "nw", NL ("new"), 1 }, + { "nw", NL ("new"), 3 }, { "oR", NL ("|="), 2 }, { "oo", NL ("||"), 2 }, { "or", NL ("|"), 2 }, @@ -1476,15 +1758,19 @@ static const struct d_operator_info d_operators[] = { "qu", NL ("?"), 3 }, { "rM", NL ("%="), 2 }, { "rS", NL (">>="), 2 }, + { "rc", NL ("reinterpret_cast"), 2 }, { "rm", NL ("%"), 2 }, { "rs", NL (">>"), 2 }, + { "sc", NL ("static_cast"), 2 }, { "st", NL ("sizeof "), 1 }, - { "sz", NL ("sizeof "), 1 } + { "sz", NL ("sizeof "), 1 }, + { "tr", NL ("throw"), 0 }, + { "tw", NL ("throw "), 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; @@ -1494,19 +1780,32 @@ 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); + { + struct demangle_component *type; + int was_conversion = di->is_conversion; + + di->is_conversion = ! di->is_expression; + type = cplus_demangle_type (di); + di->is_conversion = was_conversion; + return d_make_comp (di, DEMANGLE_COMPONENT_CAST, type, 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); @@ -1521,6 +1820,102 @@ d_operator_name (di) } } +static struct demangle_component * +d_make_character (struct d_info *di, int c) +{ + struct demangle_component *p; + p = d_make_empty (di); + if (p != NULL) + { + p->type = DEMANGLE_COMPONENT_CHARACTER; + p->u.s_character.character = c; + } + return p; +} + +static struct demangle_component * +d_java_resource (struct d_info *di) +{ + struct demangle_component *p = NULL; + struct demangle_component *next = NULL; + long len, i; + char c; + const char *str; + + len = d_number (di); + if (len <= 1) + return NULL; + + /* Eat the leading '_'. */ + if (d_next_char (di) != '_') + return NULL; + len--; + + str = d_str (di); + i = 0; + + while (len > 0) + { + c = str[i]; + if (!c) + return NULL; + + /* Each chunk is either a '$' escape... */ + if (c == '$') + { + i++; + switch (str[i++]) + { + case 'S': + c = '/'; + break; + case '_': + c = '.'; + break; + case '$': + c = '$'; + break; + default: + return NULL; + } + next = d_make_character (di, c); + d_advance (di, i); + str = d_str (di); + len -= i; + i = 0; + if (next == NULL) + return NULL; + } + /* ... or a sequence of characters. */ + else + { + while (i < len && str[i] && str[i] != '$') + i++; + + next = d_make_name (di, str, i); + d_advance (di, i); + str = d_str (di); + len -= i; + i = 0; + if (next == NULL) + return NULL; + } + + if (p == NULL) + p = next; + else + { + p = d_make_comp (di, DEMANGLE_COMPONENT_COMPOUND_NAME, p, next); + if (p == NULL) + return NULL; + } + } + + p = d_make_comp (di, DEMANGLE_COMPONENT_JAVA_RESOURCE, p, NULL); + + return p; +} + /* ::= TV ::= TT ::= TI @@ -1533,88 +1928,131 @@ d_operator_name (di) ::= TF ::= TJ ::= GR + ::= GA + ::= Gr + ::= GTt + ::= GTn */ -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') + if (d_check_char (di, 'T')) { switch (d_next_char (di)) { case 'V': di->expansion -= 5; - return d_make_comp (di, D_COMP_VTABLE, d_type (di), NULL); + return d_make_comp (di, DEMANGLE_COMPONENT_VTABLE, + cplus_demangle_type (di), NULL); case 'T': di->expansion -= 10; - return d_make_comp (di, D_COMP_VTT, d_type (di), NULL); + 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) != '_') + if (! d_check_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. */ di->expansion += 5; - return d_make_comp (di, D_COMP_CONSTRUCTION_VTABLE, base_type, - derived_type); + 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); + + case 'H': + return d_make_comp (di, DEMANGLE_COMPONENT_TLS_INIT, + d_name (di), NULL); + + case 'W': + return d_make_comp (di, DEMANGLE_COMPONENT_TLS_WRAPPER, + d_name (di), NULL); default: return NULL; } } - else if (c == 'G') + else if (d_check_char (di, 'G')) { 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); + { + struct demangle_component *name = d_name (di); + return d_make_comp (di, DEMANGLE_COMPONENT_REFTEMP, name, + d_number_component (di)); + } + + case 'A': + return d_make_comp (di, DEMANGLE_COMPONENT_HIDDEN_ALIAS, + d_encoding (di, 0), NULL); + + case 'T': + switch (d_next_char (di)) + { + case 'n': + return d_make_comp (di, DEMANGLE_COMPONENT_NONTRANSACTION_CLONE, + d_encoding (di, 0), NULL); + default: + /* ??? The proposal is that other letters (such as 'h') stand + for different variants of transaction cloning, such as + compiling directly for hardware transaction support. But + they still should all be transactional clones of some sort + so go ahead and call them that. */ + case 't': + return d_make_comp (di, DEMANGLE_COMPONENT_TRANSACTION_CLONE, + d_encoding (di, 0), NULL); + } + + case 'r': + return d_java_resource (di); default: return NULL; @@ -1638,29 +2076,24 @@ 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); - if (d_next_char (di) != '_') + d_number (di); + if (! d_check_char (di, '_')) return 0; - virtual_offset = d_number (di); + d_number (di); } else return 0; - if (d_next_char (di) != '_') + if (! d_check_char (di, '_')) return 0; return 1; @@ -1674,24 +2107,23 @@ 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 == D_COMP_NAME) + if (di->last_name->type == DEMANGLE_COMPONENT_NAME) di->expansion += di->last_name->u.s_name.len; - else if (di->last_name->type == D_COMP_SUB_STD) + else if (di->last_name->type == DEMANGLE_COMPONENT_SUB_STD) di->expansion += di->last_name->u.s_string.len; } - switch (d_next_char (di)) + switch (d_peek_char (di)) { case 'C': { enum gnu_v3_ctor_kinds kind; - switch (d_next_char (di)) + switch (d_peek_next_char (di)) { case '1': kind = gnu_v3_complete_object_ctor; @@ -1702,9 +2134,16 @@ d_ctor_dtor_name (di) case '3': kind = gnu_v3_complete_object_allocating_ctor; break; + case '4': + kind = gnu_v3_unified_ctor; + break; + case '5': + kind = gnu_v3_object_ctor_group; + break; default: return NULL; } + d_advance (di, 2); return d_make_ctor (di, kind, di->last_name); } @@ -1712,7 +2151,7 @@ d_ctor_dtor_name (di) { enum gnu_v3_dtor_kinds kind; - switch (d_next_char (di)) + switch (d_peek_next_char (di)) { case '0': kind = gnu_v3_deleting_dtor; @@ -1723,9 +2162,17 @@ d_ctor_dtor_name (di) case '2': kind = gnu_v3_base_object_dtor; break; + /* digit '3' is not used */ + case '4': + kind = gnu_v3_unified_dtor; + break; + case '5': + kind = gnu_v3_object_dtor_group; + break; default: return NULL; } + d_advance (di, 2); return d_make_dtor (di, kind, di->last_name); } @@ -1745,6 +2192,7 @@ d_ctor_dtor_name (di) ::= ::= P ::= R + ::= O (C++0x) ::= C ::= G ::= U @@ -1753,42 +2201,54 @@ d_ctor_dtor_name (di) ::= u */ -static const struct d_builtin_type_info d_builtin_types[26] = +CP_STATIC_IF_GLIBCPP_V3 +const struct demangle_builtin_type_info +cplus_demangle_builtin_types[D_BUILTIN_TYPE_COUNT] = { - /* a */ { NL ("signed char"), NL ("signed char"), D_PRINT_INT }, + /* a */ { NL ("signed char"), NL ("signed char"), D_PRINT_DEFAULT }, /* b */ { NL ("bool"), NL ("boolean"), D_PRINT_BOOL }, - /* c */ { NL ("char"), NL ("byte"), D_PRINT_INT }, - /* d */ { NL ("double"), NL ("double"), D_PRINT_DEFAULT }, - /* e */ { NL ("long double"), NL ("long double"), D_PRINT_DEFAULT }, - /* f */ { NL ("float"), NL ("float"), D_PRINT_DEFAULT }, - /* g */ { NL ("__float128"), NL ("__float128"), D_PRINT_DEFAULT }, - /* h */ { NL ("unsigned char"), NL ("unsigned char"), D_PRINT_INT }, + /* c */ { NL ("char"), NL ("byte"), D_PRINT_DEFAULT }, + /* d */ { NL ("double"), NL ("double"), D_PRINT_FLOAT }, + /* e */ { NL ("long double"), NL ("long double"), D_PRINT_FLOAT }, + /* f */ { NL ("float"), NL ("float"), D_PRINT_FLOAT }, + /* g */ { NL ("__float128"), NL ("__float128"), D_PRINT_FLOAT }, + /* h */ { NL ("unsigned char"), NL ("unsigned char"), D_PRINT_DEFAULT }, /* i */ { NL ("int"), NL ("int"), D_PRINT_INT }, - /* j */ { NL ("unsigned int"), NL ("unsigned"), D_PRINT_INT }, + /* j */ { NL ("unsigned int"), NL ("unsigned"), D_PRINT_UNSIGNED }, /* k */ { NULL, 0, NULL, 0, D_PRINT_DEFAULT }, /* l */ { NL ("long"), NL ("long"), D_PRINT_LONG }, - /* m */ { NL ("unsigned long"), NL ("unsigned long"), D_PRINT_LONG }, + /* m */ { NL ("unsigned long"), NL ("unsigned long"), D_PRINT_UNSIGNED_LONG }, /* n */ { NL ("__int128"), NL ("__int128"), D_PRINT_DEFAULT }, - /* o */ { NL ("unsigned __int128"), NL ("unsigned __int128"), D_PRINT_DEFAULT }, + /* o */ { NL ("unsigned __int128"), NL ("unsigned __int128"), + D_PRINT_DEFAULT }, /* p */ { NULL, 0, NULL, 0, D_PRINT_DEFAULT }, /* q */ { NULL, 0, NULL, 0, D_PRINT_DEFAULT }, /* r */ { NULL, 0, NULL, 0, D_PRINT_DEFAULT }, - /* s */ { NL ("short"), NL ("short"), D_PRINT_INT }, - /* t */ { NL ("unsigned short"), NL ("unsigned short"), D_PRINT_INT }, + /* s */ { NL ("short"), NL ("short"), D_PRINT_DEFAULT }, + /* t */ { NL ("unsigned short"), NL ("unsigned short"), D_PRINT_DEFAULT }, /* u */ { NULL, 0, NULL, 0, D_PRINT_DEFAULT }, /* v */ { NL ("void"), NL ("void"), D_PRINT_VOID }, - /* w */ { NL ("wchar_t"), NL ("char"), D_PRINT_INT }, - /* x */ { NL ("long long"), NL ("long"), D_PRINT_DEFAULT }, - /* y */ { NL ("unsigned long long"), NL ("unsigned long long"), D_PRINT_DEFAULT }, + /* w */ { NL ("wchar_t"), NL ("char"), D_PRINT_DEFAULT }, + /* x */ { NL ("long long"), NL ("long"), D_PRINT_LONG_LONG }, + /* y */ { NL ("unsigned long long"), NL ("unsigned long long"), + D_PRINT_UNSIGNED_LONG_LONG }, /* z */ { NL ("..."), NL ("..."), D_PRINT_DEFAULT }, + /* 26 */ { NL ("decimal32"), NL ("decimal32"), D_PRINT_DEFAULT }, + /* 27 */ { NL ("decimal64"), NL ("decimal64"), D_PRINT_DEFAULT }, + /* 28 */ { NL ("decimal128"), NL ("decimal128"), D_PRINT_DEFAULT }, + /* 29 */ { NL ("half"), NL ("half"), D_PRINT_FLOAT }, + /* 30 */ { NL ("char16_t"), NL ("char16_t"), D_PRINT_DEFAULT }, + /* 31 */ { NL ("char32_t"), NL ("char32_t"), D_PRINT_DEFAULT }, + /* 32 */ { NL ("decltype(nullptr)"), NL ("decltype(nullptr)"), + 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 @@ -1809,12 +2269,32 @@ d_type (di) peek = d_peek_char (di); if (peek == 'r' || peek == 'V' || peek == 'K') { - struct d_comp **pret; + struct demangle_component **pret; pret = d_cv_qualifiers (di, &ret, 0); if (pret == NULL) return NULL; - *pret = d_type (di); + if (d_peek_char (di) == 'F') + { + /* cv-qualifiers before a function type apply to 'this', + so avoid adding the unqualified function type to + the substitution list. */ + *pret = d_function_type (di); + } + else + *pret = cplus_demangle_type (di); + if (!*pret) + return NULL; + if ((*pret)->type == DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS + || (*pret)->type == DEMANGLE_COMPONENT_REFERENCE_THIS) + { + /* Move the ref-qualifier outside the cv-qualifiers so that + they are printed in the right order. */ + struct demangle_component *fn = d_left (*pret); + d_left (*pret) = ret; + ret = *pret; + *pret = fn; + } if (! d_add_substitution (di, ret)) return NULL; return ret; @@ -1828,7 +2308,8 @@ 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); @@ -1836,7 +2317,8 @@ d_type (di) 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': @@ -1862,12 +2344,61 @@ d_type (di) ret = d_template_param (di); if (d_peek_char (di) == 'I') { - /* This is . The - part is a substitution + /* This may be . + If this is the type for a conversion operator, we can + have a here only by following + a derivation like this: + + + -> + -> + -> + -> + -> + -> cv + -> cv + + where the is followed by another. + Otherwise, we must have a derivation like this: + + + -> + -> + -> + -> + -> + -> cv + -> cv + + where we need to leave the to be processed + by d_prefix (following the ). + + The part is a substitution candidate. */ - if (! d_add_substitution (di, ret)) - return NULL; - ret = d_make_comp (di, D_COMP_TEMPLATE, ret, d_template_args (di)); + if (! di->is_conversion) + { + if (! d_add_substitution (di, ret)) + return NULL; + ret = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, ret, + d_template_args (di)); + } + else + { + struct demangle_component *args; + struct d_info_checkpoint checkpoint; + + d_checkpoint (di, &checkpoint); + args = d_template_args (di); + if (d_peek_char (di) == 'I') + { + if (! d_add_substitution (di, ret)) + return NULL; + ret = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, ret, + args); + } + else + d_backtrack (di, &checkpoint); + } } break; @@ -1886,7 +2417,7 @@ d_type (di) /* The substituted name may have been a template name and may be followed by tepmlate args. */ if (d_peek_char (di) == 'I') - ret = d_make_comp (di, D_COMP_TEMPLATE, ret, + ret = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, ret, d_template_args (di)); else can_subst = 0; @@ -1898,36 +2429,137 @@ 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; } } break; + case 'O': + d_advance (di, 1); + ret = d_make_comp (di, DEMANGLE_COMPONENT_RVALUE_REFERENCE, + cplus_demangle_type (di), NULL); + break; + 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; + + case 'D': + can_subst = 0; + d_advance (di, 1); + peek = d_next_char (di); + switch (peek) + { + case 'T': + case 't': + /* decltype (expression) */ + ret = d_make_comp (di, DEMANGLE_COMPONENT_DECLTYPE, + d_expression (di), NULL); + if (ret && d_next_char (di) != 'E') + ret = NULL; + can_subst = 1; + break; + + case 'p': + /* Pack expansion. */ + ret = d_make_comp (di, DEMANGLE_COMPONENT_PACK_EXPANSION, + cplus_demangle_type (di), NULL); + can_subst = 1; + break; + + case 'a': + /* auto */ + ret = d_make_name (di, "auto", 4); + break; + + case 'f': + /* 32-bit decimal floating point */ + ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[26]); + di->expansion += ret->u.s_builtin.type->len; + break; + case 'd': + /* 64-bit DFP */ + ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[27]); + di->expansion += ret->u.s_builtin.type->len; + break; + case 'e': + /* 128-bit DFP */ + ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[28]); + di->expansion += ret->u.s_builtin.type->len; + break; + case 'h': + /* 16-bit half-precision FP */ + ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[29]); + di->expansion += ret->u.s_builtin.type->len; + break; + case 's': + /* char16_t */ + ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[30]); + di->expansion += ret->u.s_builtin.type->len; + break; + case 'i': + /* char32_t */ + ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[31]); + di->expansion += ret->u.s_builtin.type->len; + break; + + case 'F': + /* Fixed point types. DF */ + ret = d_make_empty (di); + ret->type = DEMANGLE_COMPONENT_FIXED_TYPE; + if ((ret->u.s_fixed.accum = IS_DIGIT (d_peek_char (di)))) + /* For demangling we don't care about the bits. */ + d_number (di); + ret->u.s_fixed.length = cplus_demangle_type (di); + if (ret->u.s_fixed.length == NULL) + return NULL; + d_number (di); + peek = d_next_char (di); + ret->u.s_fixed.sat = (peek == 's'); + break; + + case 'v': + ret = d_vector_type (di); + can_subst = 1; + break; + + case 'n': + /* decltype(nullptr) */ + ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[32]); + di->expansion += ret->u.s_builtin.type->len; + break; + + default: + return NULL; + } break; default: @@ -1945,33 +2577,39 @@ d_type (di) /* ::= [r] [V] [K] */ -static struct d_comp ** -d_cv_qualifiers (di, pret, member_fn) - struct d_info *di; - struct d_comp **pret; - int member_fn; +static struct demangle_component ** +d_cv_qualifiers (struct d_info *di, + struct demangle_component **pret, int member_fn) { + struct demangle_component **pstart; char peek; + pstart = pret; peek = d_peek_char (di); while (peek == 'r' || peek == 'V' || peek == 'K') { - enum d_comp_type t; + enum demangle_component_type t; d_advance (di, 1); if (peek == 'r') { - t = member_fn ? D_COMP_RESTRICT_THIS : D_COMP_RESTRICT; + t = (member_fn + ? DEMANGLE_COMPONENT_RESTRICT_THIS + : DEMANGLE_COMPONENT_RESTRICT); di->expansion += sizeof "restrict"; } else if (peek == 'V') { - t = member_fn ? D_COMP_VOLATILE_THIS : D_COMP_VOLATILE; + t = (member_fn + ? DEMANGLE_COMPONENT_VOLATILE_THIS + : DEMANGLE_COMPONENT_VOLATILE); di->expansion += sizeof "volatile"; } else { - t = member_fn ? D_COMP_CONST_THIS : D_COMP_CONST; + t = (member_fn + ? DEMANGLE_COMPONENT_CONST_THIS + : DEMANGLE_COMPONENT_CONST); di->expansion += sizeof "const"; } @@ -1983,18 +2621,70 @@ d_cv_qualifiers (di, pret, member_fn) peek = d_peek_char (di); } + if (!member_fn && peek == 'F') + { + while (pstart != pret) + { + switch ((*pstart)->type) + { + case DEMANGLE_COMPONENT_RESTRICT: + (*pstart)->type = DEMANGLE_COMPONENT_RESTRICT_THIS; + break; + case DEMANGLE_COMPONENT_VOLATILE: + (*pstart)->type = DEMANGLE_COMPONENT_VOLATILE_THIS; + break; + case DEMANGLE_COMPONENT_CONST: + (*pstart)->type = DEMANGLE_COMPONENT_CONST_THIS; + break; + default: + break; + } + pstart = &d_left (*pstart); + } + } + return pret; } -/* ::= F [Y] E */ +/* ::= R + ::= O */ + +static struct demangle_component * +d_ref_qualifier (struct d_info *di, struct demangle_component *sub) +{ + struct demangle_component *ret = sub; + char peek; + + peek = d_peek_char (di); + if (peek == 'R' || peek == 'O') + { + enum demangle_component_type t; + if (peek == 'R') + { + t = DEMANGLE_COMPONENT_REFERENCE_THIS; + di->expansion += sizeof "&"; + } + else + { + t = DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS; + di->expansion += sizeof "&&"; + } + d_advance (di, 1); + + ret = d_make_comp (di, t, ret, NULL); + } + + return ret; +} + +/* ::= 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') + if (! d_check_char (di, 'F')) return NULL; if (d_peek_char (di) == 'Y') { @@ -2003,48 +2693,41 @@ d_function_type (di) d_advance (di, 1); } ret = d_bare_function_type (di, 1); - if (d_next_char (di) != 'E') + ret = d_ref_qualifier (di, ret); + + if (! d_check_char (di, 'E')) return NULL; return ret; } -/* ::= + */ +/* + */ -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_parmlist (struct d_info *di) { - struct d_comp *return_type; - struct d_comp *tl; - struct d_comp **ptl; + struct demangle_component *tl; + struct demangle_component **ptl; - return_type = NULL; tl = NULL; ptl = &tl; while (1) { - char peek; - struct d_comp *type; + struct demangle_component *type; - peek = d_peek_char (di); - if (peek == '\0' || peek == 'E') + char peek = d_peek_char (di); + if (peek == '\0' || peek == 'E' || peek == '.') + break; + if ((peek == 'R' || peek == 'O') + && d_peek_next_char (di) == 'E') + /* Function ref-qualifier, not a ref prefix for a parameter type. */ break; - type = d_type (di); + type = cplus_demangle_type (di); if (type == NULL) return NULL; - if (has_return_type) - { - return_type = type; - has_return_type = 0; - } - else - { - *ptl = d_make_comp (di, D_COMP_ARGLIST, type, NULL); - if (*ptl == NULL) - return NULL; - ptl = &d_right (*ptl); - } + *ptl = d_make_comp (di, DEMANGLE_COMPONENT_ARGLIST, type, NULL); + if (*ptl == NULL) + return NULL; + ptl = &d_right (*ptl); } /* There should be at least one parameter type besides the optional @@ -2055,45 +2738,78 @@ 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) { di->expansion -= d_left (tl)->u.s_builtin.type->len; - tl = NULL; + d_left (tl) = NULL; } - return d_make_comp (di, D_COMP_FUNCTION_TYPE, return_type, tl); -} - -/* ::= */ - -static struct d_comp * -d_class_enum_type (di) - struct d_info *di; -{ - return d_name (di); + return tl; } -/* ::= A <(positive dimension) number> _ <(element) type> - ::= A [<(dimension) expression>] _ <(element) type> -*/ +/* ::= [J]+ */ -static struct d_comp * -d_array_type (di) - struct d_info *di; +static struct demangle_component * +d_bare_function_type (struct d_info *di, int has_return_type) { + struct demangle_component *return_type; + struct demangle_component *tl; char peek; - struct d_comp *dim; - - if (d_next_char (di) != 'A') - return NULL; + /* Detect special qualifier indicating that the first argument + is the return type. */ peek = d_peek_char (di); - if (peek == '_') - dim = NULL; - else if (IS_DIGIT (peek)) + if (peek == 'J') { - const char *s; + d_advance (di, 1); + has_return_type = 1; + } + + if (has_return_type) + { + return_type = cplus_demangle_type (di); + if (return_type == NULL) + return NULL; + } + else + return_type = NULL; + + tl = d_parmlist (di); + if (tl == NULL) + return NULL; + + return d_make_comp (di, DEMANGLE_COMPONENT_FUNCTION_TYPE, + return_type, tl); +} + +/* ::= */ + +static struct demangle_component * +d_class_enum_type (struct d_info *di) +{ + return d_name (di); +} + +/* ::= A <(positive dimension) number> _ <(element) type> + ::= A [<(dimension) expression>] _ <(element) type> +*/ + +static struct demangle_component * +d_array_type (struct d_info *di) +{ + char peek; + struct demangle_component *dim; + + if (! d_check_char (di, 'A')) + return NULL; + + peek = d_peek_char (di); + if (peek == '_') + dim = NULL; + else if (IS_DIGIT (peek)) + { + const char *s; s = d_str (di); do @@ -2113,72 +2829,110 @@ d_array_type (di) return NULL; } - if (d_next_char (di) != '_') + if (! d_check_char (di, '_')) + return NULL; + + return d_make_comp (di, DEMANGLE_COMPONENT_ARRAY_TYPE, dim, + cplus_demangle_type (di)); +} + +/* ::= Dv _ + ::= Dv _ _ */ + +static struct demangle_component * +d_vector_type (struct d_info *di) +{ + char peek; + struct demangle_component *dim; + + peek = d_peek_char (di); + if (peek == '_') + { + d_advance (di, 1); + dim = d_expression (di); + } + else + dim = d_number_component (di); + + if (dim == NULL) + return NULL; + + if (! d_check_char (di, '_')) return NULL; - return d_make_comp (di, D_COMP_ARRAY_TYPE, dim, d_type (di)); + return d_make_comp (di, DEMANGLE_COMPONENT_VECTOR_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; + + if (! d_check_char (di, 'M')) + return NULL; - if (d_next_char (di) != 'M') + cl = cplus_demangle_type (di); + if (cl == NULL) return NULL; - cl = d_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 - type is seen both the base type and the CV-qualified types are - substitution sources. The ABI also specifies that for a pointer - to a CV-qualified member function, the qualifiers are attached to - the second type. Given the grammar, a plain reading of the ABI - suggests that both the CV-qualified member function and the - non-qualified member function are substitution sources. However, - 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(). */ - - pmem = d_cv_qualifiers (di, &mem, 1); - if (pmem == NULL) + /* The ABI says, "The type of a non-static member function is considered + to be different, for the purposes of substitution, from the type of a + namespace-scope or static member function whose type appears + similar. The types of two non-static member functions are considered + to be different, for the purposes of substitution, if the functions + are members of different classes. In other words, for the purposes of + substitution, the class of which the function is a member is + considered part of the type of function." + + For a pointer to member function, this call to cplus_demangle_type + will end up adding a (possibly qualified) non-member function type to + the substitution table, which is not correct; however, the member + function type will never be used in a substitution, so putting the + wrong type in the substitution table is harmless. */ + + mem = cplus_demangle_type (di); + if (mem == NULL) return NULL; - *pmem = d_type (di); - return d_make_comp (di, D_COMP_PTRMEM_TYPE, cl, mem); + return d_make_comp (di, DEMANGLE_COMPONENT_PTRMEM_TYPE, cl, mem); +} + +/* _ */ + +static long +d_compact_number (struct d_info *di) +{ + long num; + if (d_peek_char (di) == '_') + num = 0; + else if (d_peek_char (di) == 'n') + return -1; + else + num = d_number (di) + 1; + + if (! d_check_char (di, '_')) + return -1; + return num; } /* ::= 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; - if (d_next_char (di) != 'T') + if (! d_check_char (di, 'T')) return NULL; - if (d_peek_char (di) == '_') - param = 0; - else - { - param = d_number (di); - if (param < 0) - return NULL; - param += 1; - } - - if (d_next_char (di) != '_') + param = d_compact_number (di); + if (param < 0) return NULL; ++di->did_subs; @@ -2188,33 +2942,41 @@ d_template_param (di) /* ::= 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 constructor or destructor. */ hold_last_name = di->last_name; - if (d_next_char (di) != 'I') + if (d_peek_char (di) != 'I' + && d_peek_char (di) != 'J') return NULL; + d_advance (di, 1); + + if (d_peek_char (di) == 'E') + { + /* An argument pack can be empty. */ + d_advance (di, 1); + return d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE_ARGLIST, NULL, NULL); + } al = NULL; 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); @@ -2236,32 +2998,85 @@ 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)) { case 'X': d_advance (di, 1); ret = d_expression (di); - if (d_next_char (di) != 'E') + if (! d_check_char (di, 'E')) return NULL; return ret; case 'L': return d_expr_primary (di); + case 'I': + case 'J': + /* An argument pack. */ + return d_template_args (di); + default: - return d_type (di); + return cplus_demangle_type (di); + } +} + +/* Parse a sequence of expressions until we hit the terminator + character. */ + +static struct demangle_component * +d_exprlist (struct d_info *di, char terminator) +{ + struct demangle_component *list = NULL; + struct demangle_component **p = &list; + + if (d_peek_char (di) == terminator) + { + d_advance (di, 1); + return d_make_comp (di, DEMANGLE_COMPONENT_ARGLIST, NULL, NULL); + } + + while (1) + { + struct demangle_component *arg = d_expression (di); + if (arg == NULL) + return NULL; + + *p = d_make_comp (di, DEMANGLE_COMPONENT_ARGLIST, arg, NULL); + if (*p == NULL) + return NULL; + p = &d_right (*p); + + if (d_peek_char (di) == terminator) + { + d_advance (di, 1); + break; + } } + + return list; +} + +/* Returns nonzero iff OP is an operator for a C++ cast: const_cast, + dynamic_cast, static_cast or reinterpret_cast. */ + +static int +op_is_new_cast (struct demangle_component *op) +{ + const char *code = op->u.s_operator.op->code; + return (code[1] == 'c' + && (code[0] == 's' || code[0] == 'd' + || code[0] == 'c' || code[0] == 'r')); } /* ::= <(unary) operator-name> ::= <(binary) operator-name> ::= <(trinary) operator-name> + ::= cl + E ::= st ::= ::= sr @@ -2269,9 +3084,8 @@ d_template_arg (di) ::= */ -static struct d_comp * -d_expression (di) - struct d_info *di; +static inline struct demangle_component * +d_expression_1 (struct d_info *di) { char peek; @@ -2282,76 +3096,214 @@ 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 if (peek == 's' && d_peek_next_char (di) == 'p') + { + d_advance (di, 2); + return d_make_comp (di, DEMANGLE_COMPONENT_PACK_EXPANSION, + d_expression_1 (di), NULL); + } + else if (peek == 'f' && d_peek_next_char (di) == 'p') + { + /* Function parameter used in a late-specified return type. */ + int index; + d_advance (di, 2); + if (d_peek_char (di) == 'T') + { + /* 'this' parameter. */ + d_advance (di, 1); + index = 0; + } + else + { + index = d_compact_number (di) + 1; + if (index == 0) + return NULL; + } + return d_make_function_param (di, index); + } + else if (IS_DIGIT (peek) + || (peek == 'o' && d_peek_next_char (di) == 'n')) + { + /* We can get an unqualified name as an expression in the case of + a dependent function call, i.e. decltype(f(t)). */ + struct demangle_component *name; + + if (peek == 'o') + /* operator-function-id, i.e. operator+(t). */ + d_advance (di, 2); + + name = d_unqualified_name (di); + if (name == NULL) + return NULL; + if (d_peek_char (di) == 'I') + return d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, name, + d_template_args (di)); + else + return name; + } + else if ((peek == 'i' || peek == 't') + && d_peek_next_char (di) == 'l') + { + /* Brace-enclosed initializer list, untyped or typed. */ + struct demangle_component *type = NULL; + if (peek == 't') + type = cplus_demangle_type (di); + d_advance (di, 2); + return d_make_comp (di, DEMANGLE_COMPONENT_INITIALIZER_LIST, + type, d_exprlist (di, 'E')); + } else { - struct d_comp *op; + struct demangle_component *op; + const char *code = NULL; int args; op = d_operator_name (di); if (op == NULL) return NULL; - if (op->type == D_COMP_OPERATOR) - di->expansion += op->u.s_operator.op->len - 2; - - if (op->type == D_COMP_OPERATOR - && strcmp (op->u.s_operator.op->code, "st") == 0) - return d_make_comp (di, D_COMP_UNARY, op, d_type (di)); + if (op->type == DEMANGLE_COMPONENT_OPERATOR) + { + code = op->u.s_operator.op->code; + di->expansion += op->u.s_operator.op->len - 2; + if (strcmp (code, "st") == 0) + 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; } switch (args) { + case 0: + return d_make_comp (di, DEMANGLE_COMPONENT_NULLARY, op, NULL); + case 1: - return d_make_comp (di, D_COMP_UNARY, op, d_expression (di)); + { + struct demangle_component *operand; + int suffix = 0; + + if (code && (code[0] == 'p' || code[0] == 'm') + && code[1] == code[0]) + /* pp_ and mm_ are the prefix variants. */ + suffix = !d_check_char (di, '_'); + + if (op->type == DEMANGLE_COMPONENT_CAST + && d_check_char (di, '_')) + operand = d_exprlist (di, 'E'); + else + operand = d_expression_1 (di); + + if (suffix) + /* Indicate the suffix variant for d_print_comp. */ + return d_make_comp (di, DEMANGLE_COMPONENT_UNARY, op, + d_make_comp (di, + DEMANGLE_COMPONENT_BINARY_ARGS, + operand, operand)); + else + return d_make_comp (di, DEMANGLE_COMPONENT_UNARY, op, + operand); + } case 2: { - struct d_comp *left; + struct demangle_component *left; + struct demangle_component *right; - left = d_expression (di); - return d_make_comp (di, D_COMP_BINARY, op, - d_make_comp (di, D_COMP_BINARY_ARGS, left, - d_expression (di))); + if (op_is_new_cast (op)) + left = cplus_demangle_type (di); + else + left = d_expression_1 (di); + if (!strcmp (code, "cl")) + right = d_exprlist (di, 'E'); + else if (!strcmp (code, "dt") || !strcmp (code, "pt")) + { + right = d_unqualified_name (di); + if (d_peek_char (di) == 'I') + right = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, + right, d_template_args (di)); + } + else + right = d_expression_1 (di); + + return d_make_comp (di, DEMANGLE_COMPONENT_BINARY, op, + d_make_comp (di, + DEMANGLE_COMPONENT_BINARY_ARGS, + left, right)); } case 3: { - struct d_comp *first; - struct d_comp *second; + struct demangle_component *first; + struct demangle_component *second; + struct demangle_component *third; - 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, + if (!strcmp (code, "qu")) + { + /* ?: expression. */ + first = d_expression_1 (di); + second = d_expression_1 (di); + third = d_expression_1 (di); + } + else if (code[0] == 'n') + { + /* new-expression. */ + if (code[1] != 'w' && code[1] != 'a') + return NULL; + first = d_exprlist (di, '_'); + second = cplus_demangle_type (di); + if (d_peek_char (di) == 'E') + { + d_advance (di, 1); + third = NULL; + } + else if (d_peek_char (di) == 'p' + && d_peek_next_char (di) == 'i') + { + /* Parenthesized initializer. */ + d_advance (di, 2); + third = d_exprlist (di, 'E'); + } + else if (d_peek_char (di) == 'i' + && d_peek_next_char (di) == 'l') + /* initializer-list. */ + third = d_expression_1 (di); + else + return NULL; + } + else + return NULL; + 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, - second, - d_expression (di)))); + DEMANGLE_COMPONENT_TRINARY_ARG2, + second, third))); } default: return NULL; @@ -2359,32 +3311,47 @@ d_expression (di) } } +static struct demangle_component * +d_expression (struct d_info *di) +{ + struct demangle_component *ret; + int was_expression = di->is_expression; + + di->is_expression = 1; + ret = d_expression_1 (di); + di->is_expression = was_expression; + return ret; +} + /* ::= L <(value) number> E ::= L <(value) float> E ::= 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') + if (! d_check_char (di, 'L')) return NULL; - if (d_peek_char (di) == '_') - ret = d_mangled_name (di, 0); + if (d_peek_char (di) == '_' + /* Workaround for G++ bug; see comment in write_template_arg. */ + || d_peek_char (di) == 'Z') + ret = cplus_demangle_mangled_name (di, 0); else { - struct d_comp *type; - enum d_comp_type t; + struct demangle_component *type; + enum demangle_component_type t; const char *s; - type = d_type (di); + type = cplus_demangle_type (di); + if (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 == D_COMP_BUILTIN_TYPE + if (type->type == DEMANGLE_COMPONENT_BUILTIN_TYPE && type->u.s_builtin.type->print != D_PRINT_DEFAULT) di->expansion -= type->u.s_builtin.type->len; @@ -2399,38 +3366,42 @@ d_expr_primary (di) constant in any readable form anyhow. We don't attempt to handle these cases. */ - t = D_COMP_LITERAL; + t = DEMANGLE_COMPONENT_LITERAL; if (d_peek_char (di) == 'n') { - t = D_COMP_LITERAL_NEG; + t = DEMANGLE_COMPONENT_LITERAL_NEG; d_advance (di, 1); } s = d_str (di); while (d_peek_char (di) != 'E') - d_advance (di, 1); + { + 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') + if (! d_check_char (di, 'E')) return NULL; return ret; } /* ::= Z <(function) encoding> E <(entity) name> [] ::= Z <(function) encoding> E s [] + ::= Z <(function) encoding> E d [ number>] _ */ -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') + if (! d_check_char (di, 'Z')) return NULL; function = d_encoding (di, 0); - if (d_next_char (di) != 'E') + if (! d_check_char (di, 'E')) return NULL; if (d_peek_char (di) == 's') @@ -2438,18 +3409,39 @@ d_local_name (di) d_advance (di, 1); if (! d_discriminator (di)) return NULL; - return d_make_comp (di, D_COMP_LOCAL_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; + int num = -1; + + if (d_peek_char (di) == 'd') + { + /* Default argument scope: d _. */ + d_advance (di, 1); + num = d_compact_number (di); + if (num < 0) + return NULL; + } name = d_name (di); - if (! d_discriminator (di)) - return NULL; - return d_make_comp (di, D_COMP_LOCAL_NAME, function, name); + if (name) + switch (name->type) + { + /* Lambdas and unnamed types have internal discriminators. */ + case DEMANGLE_COMPONENT_LAMBDA: + case DEMANGLE_COMPONENT_UNNAMED_TYPE: + break; + default: + if (! d_discriminator (di)) + return NULL; + } + if (num >= 0) + name = d_make_default_arg (di, num, name); + return d_make_comp (di, DEMANGLE_COMPONENT_LOCAL_NAME, function, name); } } @@ -2459,8 +3451,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; @@ -2473,12 +3464,106 @@ d_discriminator (di) return 1; } +/* ::= Ul E [ ] _ */ + +static struct demangle_component * +d_lambda (struct d_info *di) +{ + struct demangle_component *tl; + struct demangle_component *ret; + int num; + + if (! d_check_char (di, 'U')) + return NULL; + if (! d_check_char (di, 'l')) + return NULL; + + tl = d_parmlist (di); + if (tl == NULL) + return NULL; + + if (! d_check_char (di, 'E')) + return NULL; + + num = d_compact_number (di); + if (num < 0) + return NULL; + + ret = d_make_empty (di); + if (ret) + { + ret->type = DEMANGLE_COMPONENT_LAMBDA; + ret->u.s_unary_num.sub = tl; + ret->u.s_unary_num.num = num; + } + + if (! d_add_substitution (di, ret)) + return NULL; + + return ret; +} + +/* ::= Ut [ ] _ */ + +static struct demangle_component * +d_unnamed_type (struct d_info *di) +{ + struct demangle_component *ret; + long num; + + if (! d_check_char (di, 'U')) + return NULL; + if (! d_check_char (di, 't')) + return NULL; + + num = d_compact_number (di); + if (num < 0) + return NULL; + + ret = d_make_empty (di); + if (ret) + { + ret->type = DEMANGLE_COMPONENT_UNNAMED_TYPE; + ret->u.s_number.number = num; + } + + if (! d_add_substitution (di, ret)) + return NULL; + + return ret; +} + +/* ::= [ . ] [ . ]* +*/ + +static struct demangle_component * +d_clone_suffix (struct d_info *di, struct demangle_component *encoding) +{ + const char *suffix = d_str (di); + const char *pend = suffix; + struct demangle_component *n; + + if (*pend == '.' && (IS_LOWER (pend[1]) || pend[1] == '_')) + { + pend += 2; + while (IS_LOWER (*pend) || *pend == '_') + ++pend; + } + while (*pend == '.' && IS_DIGIT (pend[1])) + { + pend += 2; + while (IS_DIGIT (*pend)) + ++pend; + } + d_advance (di, pend - suffix); + n = d_make_name (di, suffix, pend - suffix); + return d_make_comp (di, DEMANGLE_COMPONENT_CLONE, encoding, n); +} + /* 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; @@ -2533,32 +3618,35 @@ static const struct d_standard_sub_info standard_subs[] = NL ("basic_iostream") } }; -static struct d_comp * -d_substitution (di, prefix) - struct d_info *di; - int prefix; +static struct demangle_component * +d_substitution (struct d_info *di, int prefix) { char c; - if (d_next_char (di) != 'S') + if (! d_check_char (di, 'S')) return NULL; c = d_next_char (di); if (c == '_' || IS_DIGIT (c) || IS_UPPER (c)) { - int id; + unsigned int id; id = 0; if (c != '_') { do { + unsigned int new_id; + if (IS_DIGIT (c)) - id = id * 36 + c - '0'; + new_id = id * 36 + c - '0'; else if (IS_UPPER (c)) - id = id * 36 + c - 'A' + 10; + new_id = id * 36 + c - 'A' + 10; else return NULL; + if (new_id < id) + return NULL; + id = new_id; c = d_next_char (di); } while (c != '_'); @@ -2566,7 +3654,7 @@ d_substitution (di, prefix) ++id; } - if (id >= di->next_sub) + if (id >= (unsigned int) di->next_sub) return NULL; ++di->did_subs; @@ -2620,89 +3708,373 @@ d_substitution (di, prefix) } } -/* Resize the print buffer. */ - static void -d_print_resize (dpi, add) - struct d_print_info *dpi; - size_t add; +d_checkpoint (struct d_info *di, struct d_info_checkpoint *checkpoint) { - size_t need; - - if (dpi->buf == NULL) - return; - need = dpi->len + add; - while (need > dpi->alc) - { - size_t newalc; - char *newbuf; + checkpoint->n = di->n; + checkpoint->next_comp = di->next_comp; + checkpoint->next_sub = di->next_sub; + checkpoint->did_subs = di->did_subs; + checkpoint->expansion = di->expansion; +} - newalc = dpi->alc * 2; - newbuf = realloc (dpi->buf, newalc); - if (newbuf == NULL) - { - free (dpi->buf); - dpi->buf = NULL; - dpi->allocation_failure = 1; - return; - } - dpi->buf = newbuf; - dpi->alc = newalc; - } +static void +d_backtrack (struct d_info *di, struct d_info_checkpoint *checkpoint) +{ + di->n = checkpoint->n; + di->next_comp = checkpoint->next_comp; + di->next_sub = checkpoint->next_sub; + di->did_subs = checkpoint->did_subs; + di->expansion = checkpoint->expansion; } -/* Append a character to the print buffer. */ +/* Initialize a growable string. */ static void -d_print_append_char (dpi, c) - struct d_print_info *dpi; - int c; +d_growable_string_init (struct d_growable_string *dgs, size_t estimate) { - if (dpi->buf != NULL) - { - if (dpi->len >= dpi->alc) - { - d_print_resize (dpi, 1); - if (dpi->buf == NULL) - return; - } + dgs->buf = NULL; + dgs->len = 0; + dgs->alc = 0; + dgs->allocation_failure = 0; - dpi->buf[dpi->len] = c; - ++dpi->len; - } + if (estimate > 0) + d_growable_string_resize (dgs, estimate); } -/* Append a buffer to the print buffer. */ +/* Grow a growable string to a given size. */ -static void -d_print_append_buffer (dpi, s, l) - struct d_print_info *dpi; - const char *s; - size_t l; +static inline void +d_growable_string_resize (struct d_growable_string *dgs, size_t need) { - if (dpi->buf != NULL) - { - if (dpi->len + l > dpi->alc) - { - d_print_resize (dpi, l); - if (dpi->buf == NULL) - return; - } + size_t newalc; + char *newbuf; - memcpy (dpi->buf + dpi->len, s, l); - dpi->len += l; + if (dgs->allocation_failure) + return; + + /* Start allocation at two bytes to avoid any possibility of confusion + with the special value of 1 used as a return in *palc to indicate + allocation failures. */ + newalc = dgs->alc > 0 ? dgs->alc : 2; + while (newalc < need) + newalc <<= 1; + + newbuf = (char *) realloc (dgs->buf, newalc); + if (newbuf == NULL) + { + free (dgs->buf); + dgs->buf = NULL; + dgs->len = 0; + dgs->alc = 0; + dgs->allocation_failure = 1; + return; } + dgs->buf = newbuf; + dgs->alc = newalc; } -/* Indicate that an error occurred during printing. */ +/* Append a buffer to a growable string. */ -static void -d_print_error (dpi) - struct d_print_info *dpi; +static inline void +d_growable_string_append_buffer (struct d_growable_string *dgs, + const char *s, size_t l) { - free (dpi->buf); - dpi->buf = NULL; -} + size_t need; + + need = dgs->len + l + 1; + if (need > dgs->alc) + d_growable_string_resize (dgs, need); + + if (dgs->allocation_failure) + return; + + memcpy (dgs->buf + dgs->len, s, l); + dgs->buf[dgs->len + l] = '\0'; + dgs->len += l; +} + +/* Bridge growable strings to the callback mechanism. */ + +static void +d_growable_string_callback_adapter (const char *s, size_t l, void *opaque) +{ + struct d_growable_string *dgs = (struct d_growable_string*) opaque; + + d_growable_string_append_buffer (dgs, s, l); +} + +/* Walk the tree, counting the number of templates encountered, and + the number of times a scope might be saved. These counts will be + used to allocate data structures for d_print_comp, so the logic + here must mirror the logic d_print_comp will use. It is not + important that the resulting numbers are exact, so long as they + are larger than the actual numbers encountered. */ + +static void +d_count_templates_scopes (int *num_templates, int *num_scopes, + const struct demangle_component *dc) +{ + if (dc == NULL) + return; + + switch (dc->type) + { + case DEMANGLE_COMPONENT_NAME: + case DEMANGLE_COMPONENT_TEMPLATE_PARAM: + case DEMANGLE_COMPONENT_FUNCTION_PARAM: + case DEMANGLE_COMPONENT_SUB_STD: + case DEMANGLE_COMPONENT_BUILTIN_TYPE: + case DEMANGLE_COMPONENT_OPERATOR: + case DEMANGLE_COMPONENT_CHARACTER: + case DEMANGLE_COMPONENT_NUMBER: + case DEMANGLE_COMPONENT_UNNAMED_TYPE: + break; + + case DEMANGLE_COMPONENT_TEMPLATE: + (*num_templates)++; + goto recurse_left_right; + + case DEMANGLE_COMPONENT_REFERENCE: + case DEMANGLE_COMPONENT_RVALUE_REFERENCE: + if (d_left (dc)->type == DEMANGLE_COMPONENT_TEMPLATE_PARAM) + (*num_scopes)++; + goto recurse_left_right; + + case DEMANGLE_COMPONENT_QUAL_NAME: + case DEMANGLE_COMPONENT_LOCAL_NAME: + case DEMANGLE_COMPONENT_TYPED_NAME: + case DEMANGLE_COMPONENT_VTABLE: + case DEMANGLE_COMPONENT_VTT: + case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE: + 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_TLS_INIT: + case DEMANGLE_COMPONENT_TLS_WRAPPER: + case DEMANGLE_COMPONENT_REFTEMP: + case DEMANGLE_COMPONENT_HIDDEN_ALIAS: + case DEMANGLE_COMPONENT_RESTRICT: + case DEMANGLE_COMPONENT_VOLATILE: + case DEMANGLE_COMPONENT_CONST: + case DEMANGLE_COMPONENT_RESTRICT_THIS: + case DEMANGLE_COMPONENT_VOLATILE_THIS: + case DEMANGLE_COMPONENT_CONST_THIS: + case DEMANGLE_COMPONENT_REFERENCE_THIS: + case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS: + case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL: + case DEMANGLE_COMPONENT_POINTER: + case DEMANGLE_COMPONENT_COMPLEX: + case DEMANGLE_COMPONENT_IMAGINARY: + case DEMANGLE_COMPONENT_VENDOR_TYPE: + case DEMANGLE_COMPONENT_FUNCTION_TYPE: + case DEMANGLE_COMPONENT_ARRAY_TYPE: + case DEMANGLE_COMPONENT_PTRMEM_TYPE: + case DEMANGLE_COMPONENT_FIXED_TYPE: + case DEMANGLE_COMPONENT_VECTOR_TYPE: + case DEMANGLE_COMPONENT_ARGLIST: + case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST: + case DEMANGLE_COMPONENT_INITIALIZER_LIST: + case DEMANGLE_COMPONENT_CAST: + case DEMANGLE_COMPONENT_NULLARY: + 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: + case DEMANGLE_COMPONENT_JAVA_RESOURCE: + case DEMANGLE_COMPONENT_COMPOUND_NAME: + case DEMANGLE_COMPONENT_DECLTYPE: + case DEMANGLE_COMPONENT_TRANSACTION_CLONE: + case DEMANGLE_COMPONENT_NONTRANSACTION_CLONE: + case DEMANGLE_COMPONENT_PACK_EXPANSION: + case DEMANGLE_COMPONENT_TAGGED_NAME: + case DEMANGLE_COMPONENT_CLONE: + recurse_left_right: + d_count_templates_scopes (num_templates, num_scopes, + d_left (dc)); + d_count_templates_scopes (num_templates, num_scopes, + d_right (dc)); + break; + + case DEMANGLE_COMPONENT_CTOR: + d_count_templates_scopes (num_templates, num_scopes, + dc->u.s_ctor.name); + break; + + case DEMANGLE_COMPONENT_DTOR: + d_count_templates_scopes (num_templates, num_scopes, + dc->u.s_dtor.name); + break; + + case DEMANGLE_COMPONENT_EXTENDED_OPERATOR: + d_count_templates_scopes (num_templates, num_scopes, + dc->u.s_extended_operator.name); + break; + + case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS: + case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS: + d_count_templates_scopes (num_templates, num_scopes, + d_left (dc)); + break; + + case DEMANGLE_COMPONENT_LAMBDA: + case DEMANGLE_COMPONENT_DEFAULT_ARG: + d_count_templates_scopes (num_templates, num_scopes, + dc->u.s_unary_num.sub); + break; + } +} + +/* Initialize a print information structure. */ + +static void +d_print_init (struct d_print_info *dpi, demangle_callbackref callback, + void *opaque, const struct demangle_component *dc) +{ + dpi->len = 0; + dpi->last_char = '\0'; + dpi->templates = NULL; + dpi->modifiers = NULL; + dpi->pack_index = 0; + dpi->flush_count = 0; + + dpi->callback = callback; + dpi->opaque = opaque; + + dpi->demangle_failure = 0; + + dpi->component_stack = NULL; + + dpi->saved_scopes = NULL; + dpi->next_saved_scope = 0; + dpi->num_saved_scopes = 0; + + dpi->copy_templates = NULL; + dpi->next_copy_template = 0; + dpi->num_copy_templates = 0; + + d_count_templates_scopes (&dpi->num_copy_templates, + &dpi->num_saved_scopes, dc); + dpi->num_copy_templates *= dpi->num_saved_scopes; + + dpi->current_template = NULL; +} + +/* Indicate that an error occurred during printing, and test for error. */ + +static inline void +d_print_error (struct d_print_info *dpi) +{ + dpi->demangle_failure = 1; +} + +static inline int +d_print_saw_error (struct d_print_info *dpi) +{ + return dpi->demangle_failure != 0; +} + +/* Flush buffered characters to the callback. */ + +static inline void +d_print_flush (struct d_print_info *dpi) +{ + dpi->buf[dpi->len] = '\0'; + dpi->callback (dpi->buf, dpi->len, dpi->opaque); + dpi->len = 0; + dpi->flush_count++; +} + +/* Append characters and buffers for printing. */ + +static inline void +d_append_char (struct d_print_info *dpi, char c) +{ + if (dpi->len == sizeof (dpi->buf) - 1) + d_print_flush (dpi); + + dpi->buf[dpi->len++] = c; + dpi->last_char = c; +} + +static inline void +d_append_buffer (struct d_print_info *dpi, const char *s, size_t l) +{ + size_t i; + + for (i = 0; i < l; i++) + d_append_char (dpi, s[i]); +} + +static inline void +d_append_string (struct d_print_info *dpi, const char *s) +{ + d_append_buffer (dpi, s, strlen (s)); +} + +static inline void +d_append_num (struct d_print_info *dpi, long l) +{ + char buf[25]; + sprintf (buf,"%ld", l); + d_append_string (dpi, buf); +} + +static inline char +d_last_char (struct d_print_info *dpi) +{ + return dpi->last_char; +} + +/* Turn components into a human readable string. OPTIONS is the + options bits passed to the demangler. DC is the tree to print. + CALLBACK is a function to call to flush demangled string segments + as they fill the intermediate buffer, and OPAQUE is a generalized + callback argument. On success, this returns 1. On failure, + it returns 0, indicating a bad parse. It does not use heap + memory to build an output string, so cannot encounter memory + allocation failure. */ + +CP_STATIC_IF_GLIBCPP_V3 +int +cplus_demangle_print_callback (int options, + const struct demangle_component *dc, + demangle_callbackref callback, void *opaque) +{ + struct d_print_info dpi; + + d_print_init (&dpi, callback, opaque, dc); + + { +#ifdef CP_DYNAMIC_ARRAYS + __extension__ struct d_saved_scope scopes[dpi.num_saved_scopes]; + __extension__ struct d_print_template temps[dpi.num_copy_templates]; + + dpi.saved_scopes = scopes; + dpi.copy_templates = temps; +#else + dpi.saved_scopes = alloca (dpi.num_saved_scopes + * sizeof (*dpi.saved_scopes)); + dpi.copy_templates = alloca (dpi.num_copy_templates + * sizeof (*dpi.copy_templates)); +#endif + + d_print_comp (&dpi, options, dc); + } + + d_print_flush (&dpi); + + return ! d_print_saw_error (&dpi); +} /* Turn components into a human readable string. OPTIONS is the options bits passed to the demangler. DC is the tree to print. @@ -2712,50 +4084,225 @@ d_print_error (dpi) sets *PALC to 0 for a bad parse, or to 1 for a memory allocation failure. */ -static char * -d_print (options, dc, estimate, palc) - int options; - const struct d_comp *dc; - int estimate; - 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; + struct d_growable_string dgs; - dpi.options = options; + d_growable_string_init (&dgs, estimate); - dpi.alc = estimate + 1; - dpi.buf = malloc (dpi.alc); - if (dpi.buf == NULL) + if (! cplus_demangle_print_callback (options, dc, + d_growable_string_callback_adapter, + &dgs)) { - *palc = 1; + free (dgs.buf); + *palc = 0; return NULL; } - dpi.len = 0; - dpi.templates = NULL; - dpi.modifiers = NULL; + *palc = dgs.allocation_failure ? 1 : dgs.alc; + return dgs.buf; +} - dpi.allocation_failure = 0; +/* Returns the I'th element of the template arglist ARGS, or NULL on + failure. */ - d_print_comp (&dpi, dc); +static struct demangle_component * +d_index_template_argument (struct demangle_component *args, int i) +{ + struct demangle_component *a; - d_append_char (&dpi, '\0'); + for (a = args; + a != NULL; + a = d_right (a)) + { + if (a->type != DEMANGLE_COMPONENT_TEMPLATE_ARGLIST) + return NULL; + if (i <= 0) + break; + --i; + } + if (i != 0 || a == NULL) + return NULL; - if (dpi.buf != NULL) - *palc = dpi.alc; - else - *palc = dpi.allocation_failure; + return d_left (a); +} + +/* Returns the template argument from the current context indicated by DC, + which is a DEMANGLE_COMPONENT_TEMPLATE_PARAM, or NULL. */ + +static struct demangle_component * +d_lookup_template_argument (struct d_print_info *dpi, + const struct demangle_component *dc) +{ + if (dpi->templates == NULL) + { + d_print_error (dpi); + return NULL; + } + + return d_index_template_argument + (d_right (dpi->templates->template_decl), + dc->u.s_number.number); +} + +/* Returns a template argument pack used in DC (any will do), or NULL. */ + +static struct demangle_component * +d_find_pack (struct d_print_info *dpi, + const struct demangle_component *dc) +{ + struct demangle_component *a; + if (dc == NULL) + return NULL; + + switch (dc->type) + { + case DEMANGLE_COMPONENT_TEMPLATE_PARAM: + a = d_lookup_template_argument (dpi, dc); + if (a && a->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST) + return a; + return NULL; + + case DEMANGLE_COMPONENT_PACK_EXPANSION: + return NULL; + + case DEMANGLE_COMPONENT_LAMBDA: + case DEMANGLE_COMPONENT_NAME: + case DEMANGLE_COMPONENT_TAGGED_NAME: + case DEMANGLE_COMPONENT_OPERATOR: + case DEMANGLE_COMPONENT_BUILTIN_TYPE: + case DEMANGLE_COMPONENT_SUB_STD: + case DEMANGLE_COMPONENT_CHARACTER: + case DEMANGLE_COMPONENT_FUNCTION_PARAM: + case DEMANGLE_COMPONENT_UNNAMED_TYPE: + return NULL; + + case DEMANGLE_COMPONENT_EXTENDED_OPERATOR: + return d_find_pack (dpi, dc->u.s_extended_operator.name); + case DEMANGLE_COMPONENT_CTOR: + return d_find_pack (dpi, dc->u.s_ctor.name); + case DEMANGLE_COMPONENT_DTOR: + return d_find_pack (dpi, dc->u.s_dtor.name); + + default: + a = d_find_pack (dpi, d_left (dc)); + if (a) + return a; + return d_find_pack (dpi, d_right (dc)); + } +} + +/* Returns the length of the template argument pack DC. */ + +static int +d_pack_length (const struct demangle_component *dc) +{ + int count = 0; + while (dc && dc->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST + && d_left (dc) != NULL) + { + ++count; + dc = d_right (dc); + } + return count; +} + +/* DC is a component of a mangled expression. Print it, wrapped in parens + if needed. */ + +static void +d_print_subexpr (struct d_print_info *dpi, int options, + const struct demangle_component *dc) +{ + int simple = 0; + if (dc->type == DEMANGLE_COMPONENT_NAME + || dc->type == DEMANGLE_COMPONENT_QUAL_NAME + || dc->type == DEMANGLE_COMPONENT_INITIALIZER_LIST + || dc->type == DEMANGLE_COMPONENT_FUNCTION_PARAM) + simple = 1; + if (!simple) + d_append_char (dpi, '('); + d_print_comp (dpi, options, dc); + if (!simple) + d_append_char (dpi, ')'); +} + +/* Save the current scope. */ + +static void +d_save_scope (struct d_print_info *dpi, + const struct demangle_component *container) +{ + struct d_saved_scope *scope; + struct d_print_template *src, **link; + + if (dpi->next_saved_scope >= dpi->num_saved_scopes) + { + d_print_error (dpi); + return; + } + scope = &dpi->saved_scopes[dpi->next_saved_scope]; + dpi->next_saved_scope++; + + scope->container = container; + link = &scope->templates; + + for (src = dpi->templates; src != NULL; src = src->next) + { + struct d_print_template *dst; + + if (dpi->next_copy_template >= dpi->num_copy_templates) + { + d_print_error (dpi); + return; + } + dst = &dpi->copy_templates[dpi->next_copy_template]; + dpi->next_copy_template++; + + dst->template_decl = src->template_decl; + *link = dst; + link = &dst->next; + } + + *link = NULL; +} + +/* Attempt to locate a previously saved scope. Returns NULL if no + corresponding saved scope was found. */ - return dpi.buf; +static struct d_saved_scope * +d_get_saved_scope (struct d_print_info *dpi, + const struct demangle_component *container) +{ + int i; + + for (i = 0; i < dpi->next_saved_scope; i++) + if (dpi->saved_scopes[i].container == container) + return &dpi->saved_scopes[i]; + + return NULL; } /* Subroutine to handle components. */ static void -d_print_comp (dpi, dc) - struct d_print_info *dpi; - const struct d_comp *dc; +d_print_comp_inner (struct d_print_info *dpi, int options, + const struct demangle_component *dc) { + /* Magic variable to let reference smashing skip over the next modifier + without needing to modify *dc. */ + const struct demangle_component *mod_inner = NULL; + + /* Variable used to store the current templates while a previously + captured scope is used. */ + struct d_print_template *saved_templates; + + /* Nonzero if templates have been stored in the above variable. */ + int need_template_restore = 0; + if (dc == NULL) { d_print_error (dpi); @@ -2766,27 +4313,44 @@ d_print_comp (dpi, dc) switch (dc->type) { - case D_COMP_NAME: - if ((dpi->options & DMGL_JAVA) == 0) + case DEMANGLE_COMPONENT_NAME: + if ((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 D_COMP_LOCAL_NAME: - d_print_comp (dpi, d_left (dc)); - if ((dpi->options & DMGL_JAVA) == 0) - d_append_string_constant (dpi, "::"); + case DEMANGLE_COMPONENT_TAGGED_NAME: + d_print_comp (dpi, options, d_left (dc)); + d_append_string (dpi, "[abi:"); + d_print_comp (dpi, options, d_right (dc)); + d_append_char (dpi, ']'); + return; + + case DEMANGLE_COMPONENT_QUAL_NAME: + case DEMANGLE_COMPONENT_LOCAL_NAME: + d_print_comp (dpi, options, d_left (dc)); + if ((options & DMGL_JAVA) == 0) + d_append_string (dpi, "::"); else d_append_char (dpi, '.'); - d_print_comp (dpi, d_right (dc)); + { + struct demangle_component *local_name = d_right (dc); + if (local_name->type == DEMANGLE_COMPONENT_DEFAULT_ARG) + { + d_append_string (dpi, "{default arg#"); + d_append_num (dpi, local_name->u.s_unary_num.num + 1); + d_append_string (dpi, "}::"); + local_name = local_name->u.s_unary_num.sub; + } + d_print_comp (dpi, options, local_name); + } return; - case D_COMP_TYPED_NAME: + case DEMANGLE_COMPONENT_TYPED_NAME: { struct d_print_mod *hold_modifiers; - struct d_comp *typed_name; + struct demangle_component *typed_name; struct d_print_mod adpm[4]; unsigned int i; struct d_print_template dpt; @@ -2795,6 +4359,7 @@ d_print_comp (dpi, dc) 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; + dpi->modifiers = 0; i = 0; typed_name = d_left (dc); while (typed_name != NULL) @@ -2812,35 +4377,48 @@ d_print_comp (dpi, dc) adpm[i].templates = dpi->templates; ++i; - if (typed_name->type != D_COMP_RESTRICT_THIS - && typed_name->type != D_COMP_VOLATILE_THIS - && typed_name->type != D_COMP_CONST_THIS) + if (typed_name->type != DEMANGLE_COMPONENT_RESTRICT_THIS + && typed_name->type != DEMANGLE_COMPONENT_VOLATILE_THIS + && typed_name->type != DEMANGLE_COMPONENT_CONST_THIS + && typed_name->type != DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS + && typed_name->type != DEMANGLE_COMPONENT_REFERENCE_THIS) break; typed_name = d_left (typed_name); } + if (typed_name == NULL) + { + d_print_error (dpi); + return; + } + /* 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 D_COMP_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 == D_COMP_LOCAL_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 d_comp *local_name; + struct demangle_component *local_name; local_name = d_right (typed_name); - while (local_name->type == D_COMP_RESTRICT_THIS - || local_name->type == D_COMP_VOLATILE_THIS - || local_name->type == D_COMP_CONST_THIS) + if (local_name->type == DEMANGLE_COMPONENT_DEFAULT_ARG) + local_name = local_name->u.s_unary_num.sub; + while (local_name->type == DEMANGLE_COMPONENT_RESTRICT_THIS + || local_name->type == DEMANGLE_COMPONENT_VOLATILE_THIS + || local_name->type == DEMANGLE_COMPONENT_CONST_THIS + || local_name->type == DEMANGLE_COMPONENT_REFERENCE_THIS + || (local_name->type + == DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS)) { if (i >= sizeof adpm / sizeof adpm[0]) { @@ -2861,9 +4439,9 @@ d_print_comp (dpi, dc) } } - d_print_comp (dpi, d_right (dc)); + d_print_comp (dpi, options, d_right (dc)); - if (typed_name->type == D_COMP_TEMPLATE) + if (typed_name->type == DEMANGLE_COMPONENT_TEMPLATE) dpi->templates = dpt.next; /* If the modifiers didn't get printed by the type, print them @@ -2874,7 +4452,7 @@ d_print_comp (dpi, dc) if (! adpm[i].printed) { d_append_char (dpi, ' '); - d_print_mod (dpi, adpm[i].mod); + d_print_mod (dpi, options, adpm[i].mod); } } @@ -2883,9 +4461,16 @@ d_print_comp (dpi, dc) return; } - case D_COMP_TEMPLATE: + case DEMANGLE_COMPONENT_TEMPLATE: { struct d_print_mod *hold_dpm; + struct demangle_component *dcl; + const struct demangle_component *hold_current; + + /* This template may need to be referenced by a cast operator + contained in its subtree. */ + hold_current = dpi->current_template; + dpi->current_template = dc; /* Don't push modifiers into a template definition. Doing so could give the wrong definition for a template argument. @@ -2894,48 +4479,48 @@ d_print_comp (dpi, dc) hold_dpm = dpi->modifiers; 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 (d_last_char (dpi) == '>') - d_append_char (dpi, ' '); - d_append_char (dpi, '>'); + dcl = d_left (dc); + + if ((options & DMGL_JAVA) != 0 + && dcl->type == DEMANGLE_COMPONENT_NAME + && dcl->u.s_name.len == 6 + && strncmp (dcl->u.s_name.s, "JArray", 6) == 0) + { + /* Special-case Java arrays, so that JArray appears + instead as TYPE[]. */ + + d_print_comp (dpi, options, d_right (dc)); + d_append_string (dpi, "[]"); + } + else + { + d_print_comp (dpi, options, dcl); + if (d_last_char (dpi) == '<') + d_append_char (dpi, ' '); + d_append_char (dpi, '<'); + d_print_comp (dpi, options, d_right (dc)); + /* Avoid generating two consecutive '>' characters, to avoid + the C++ syntactic ambiguity. */ + if (d_last_char (dpi) == '>') + d_append_char (dpi, ' '); + d_append_char (dpi, '>'); + } dpi->modifiers = hold_dpm; + dpi->current_template = hold_current; return; } - case D_COMP_TEMPLATE_PARAM: + case DEMANGLE_COMPONENT_TEMPLATE_PARAM: { - long i; - struct d_comp *a; struct d_print_template *hold_dpt; + struct demangle_component *a = d_lookup_template_argument (dpi, dc); - if (dpi->templates == NULL) - { - d_print_error (dpi); - return; - } - i = dc->u.s_number.number; - for (a = d_right (dpi->templates->template); - a != NULL; - a = d_right (a)) - { - if (a->type != D_COMP_TEMPLATE_ARGLIST) - { - d_print_error (dpi); - return; - } - if (i <= 0) - break; - --i; - } - if (i != 0 || a == NULL) + if (a && a->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST) + a = d_index_template_argument (a, dpi->pack_index); + + if (a == NULL) { d_print_error (dpi); return; @@ -2949,99 +4534,225 @@ d_print_comp (dpi, dc) hold_dpt = dpi->templates; dpi->templates = hold_dpt->next; - d_print_comp (dpi, d_left (a)); + d_print_comp (dpi, options, a); dpi->templates = hold_dpt; return; } - case D_COMP_CTOR: - d_print_comp (dpi, dc->u.s_ctor.name); + case DEMANGLE_COMPONENT_CTOR: + d_print_comp (dpi, options, 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); + d_print_comp (dpi, options, dc->u.s_dtor.name); + return; + + case DEMANGLE_COMPONENT_VTABLE: + d_append_string (dpi, "vtable for "); + d_print_comp (dpi, options, d_left (dc)); return; - case D_COMP_VTABLE: - d_append_string_constant (dpi, "vtable for "); - d_print_comp (dpi, d_left (dc)); + case DEMANGLE_COMPONENT_VTT: + d_append_string (dpi, "VTT for "); + d_print_comp (dpi, options, d_left (dc)); return; - case D_COMP_VTT: - d_append_string_constant (dpi, "VTT for "); - d_print_comp (dpi, d_left (dc)); + case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE: + d_append_string (dpi, "construction vtable for "); + d_print_comp (dpi, options, d_left (dc)); + d_append_string (dpi, "-in-"); + d_print_comp (dpi, options, d_right (dc)); return; - case D_COMP_CONSTRUCTION_VTABLE: - d_append_string_constant (dpi, "construction vtable for "); - d_print_comp (dpi, d_left (dc)); - d_append_string_constant (dpi, "-in-"); - d_print_comp (dpi, d_right (dc)); + case DEMANGLE_COMPONENT_TYPEINFO: + d_append_string (dpi, "typeinfo for "); + d_print_comp (dpi, options, d_left (dc)); return; - case D_COMP_TYPEINFO: - d_append_string_constant (dpi, "typeinfo for "); - d_print_comp (dpi, d_left (dc)); + case DEMANGLE_COMPONENT_TYPEINFO_NAME: + d_append_string (dpi, "typeinfo name for "); + d_print_comp (dpi, options, d_left (dc)); return; - case D_COMP_TYPEINFO_NAME: - d_append_string_constant (dpi, "typeinfo name for "); - d_print_comp (dpi, d_left (dc)); + case DEMANGLE_COMPONENT_TYPEINFO_FN: + d_append_string (dpi, "typeinfo fn for "); + d_print_comp (dpi, options, d_left (dc)); return; - case D_COMP_TYPEINFO_FN: - d_append_string_constant (dpi, "typeinfo fn for "); - d_print_comp (dpi, d_left (dc)); + case DEMANGLE_COMPONENT_THUNK: + d_append_string (dpi, "non-virtual thunk to "); + d_print_comp (dpi, options, d_left (dc)); return; - case D_COMP_THUNK: - d_append_string_constant (dpi, "non-virtual thunk to "); - d_print_comp (dpi, d_left (dc)); + case DEMANGLE_COMPONENT_VIRTUAL_THUNK: + d_append_string (dpi, "virtual thunk to "); + d_print_comp (dpi, options, d_left (dc)); return; - case D_COMP_VIRTUAL_THUNK: - d_append_string_constant (dpi, "virtual thunk to "); - d_print_comp (dpi, d_left (dc)); + case DEMANGLE_COMPONENT_COVARIANT_THUNK: + d_append_string (dpi, "covariant return thunk to "); + d_print_comp (dpi, options, d_left (dc)); return; - case D_COMP_COVARIANT_THUNK: - d_append_string_constant (dpi, "covariant return thunk to "); - d_print_comp (dpi, d_left (dc)); + case DEMANGLE_COMPONENT_JAVA_CLASS: + d_append_string (dpi, "java Class for "); + d_print_comp (dpi, options, d_left (dc)); return; - case D_COMP_JAVA_CLASS: - d_append_string_constant (dpi, "java Class for "); - d_print_comp (dpi, d_left (dc)); + case DEMANGLE_COMPONENT_GUARD: + d_append_string (dpi, "guard variable for "); + d_print_comp (dpi, options, d_left (dc)); return; - case D_COMP_GUARD: - d_append_string_constant (dpi, "guard variable for "); - d_print_comp (dpi, d_left (dc)); + case DEMANGLE_COMPONENT_TLS_INIT: + d_append_string (dpi, "TLS init function for "); + d_print_comp (dpi, options, d_left (dc)); return; - case D_COMP_REFTEMP: - d_append_string_constant (dpi, "reference temporary for "); - d_print_comp (dpi, d_left (dc)); + case DEMANGLE_COMPONENT_TLS_WRAPPER: + d_append_string (dpi, "TLS wrapper function for "); + d_print_comp (dpi, options, d_left (dc)); return; - case D_COMP_SUB_STD: + case DEMANGLE_COMPONENT_REFTEMP: + d_append_string (dpi, "reference temporary #"); + d_print_comp (dpi, options, d_right (dc)); + d_append_string (dpi, " for "); + d_print_comp (dpi, options, d_left (dc)); + return; + + case DEMANGLE_COMPONENT_HIDDEN_ALIAS: + d_append_string (dpi, "hidden alias for "); + d_print_comp (dpi, options, d_left (dc)); + return; + + case DEMANGLE_COMPONENT_TRANSACTION_CLONE: + d_append_string (dpi, "transaction clone for "); + d_print_comp (dpi, options, d_left (dc)); + return; + + case DEMANGLE_COMPONENT_NONTRANSACTION_CLONE: + d_append_string (dpi, "non-transaction clone for "); + d_print_comp (dpi, options, d_left (dc)); + return; + + case DEMANGLE_COMPONENT_SUB_STD: d_append_buffer (dpi, dc->u.s_string.string, dc->u.s_string.len); return; - case D_COMP_RESTRICT: - case D_COMP_VOLATILE: - case D_COMP_CONST: - case D_COMP_RESTRICT_THIS: - case D_COMP_VOLATILE_THIS: - case D_COMP_CONST_THIS: - case D_COMP_VENDOR_TYPE_QUAL: - case D_COMP_POINTER: - case D_COMP_REFERENCE: - case D_COMP_COMPLEX: - case D_COMP_IMAGINARY: + case DEMANGLE_COMPONENT_RESTRICT: + case DEMANGLE_COMPONENT_VOLATILE: + case DEMANGLE_COMPONENT_CONST: + { + 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, options, d_left (dc)); + return; + } + } + } + } + goto modifier; + + case DEMANGLE_COMPONENT_REFERENCE: + case DEMANGLE_COMPONENT_RVALUE_REFERENCE: + { + /* Handle reference smashing: & + && = &. */ + const struct demangle_component *sub = d_left (dc); + if (sub->type == DEMANGLE_COMPONENT_TEMPLATE_PARAM) + { + struct d_saved_scope *scope = d_get_saved_scope (dpi, sub); + struct demangle_component *a; + + if (scope == NULL) + { + /* This is the first time SUB has been traversed. + We need to capture the current templates so + they can be restored if SUB is reentered as a + substitution. */ + d_save_scope (dpi, sub); + if (d_print_saw_error (dpi)) + return; + } + else + { + const struct d_component_stack *dcse; + int found_self_or_parent = 0; + + /* This traversal is reentering SUB as a substition. + If we are not beneath SUB or DC in the tree then we + need to restore SUB's template stack temporarily. */ + for (dcse = dpi->component_stack; dcse != NULL; + dcse = dcse->parent) + { + if (dcse->dc == sub + || (dcse->dc == dc + && dcse != dpi->component_stack)) + { + found_self_or_parent = 1; + break; + } + } + + if (!found_self_or_parent) + { + saved_templates = dpi->templates; + dpi->templates = scope->templates; + need_template_restore = 1; + } + } + + a = d_lookup_template_argument (dpi, sub); + if (a && a->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST) + a = d_index_template_argument (a, dpi->pack_index); + + if (a == NULL) + { + if (need_template_restore) + dpi->templates = saved_templates; + + d_print_error (dpi); + return; + } + + sub = a; + } + + if (sub->type == DEMANGLE_COMPONENT_REFERENCE + || sub->type == dc->type) + dc = sub; + else if (sub->type == DEMANGLE_COMPONENT_RVALUE_REFERENCE) + mod_inner = d_left (sub); + } + /* Fall through. */ + + case DEMANGLE_COMPONENT_RESTRICT_THIS: + case DEMANGLE_COMPONENT_VOLATILE_THIS: + case DEMANGLE_COMPONENT_CONST_THIS: + case DEMANGLE_COMPONENT_REFERENCE_THIS: + case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS: + case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL: + case DEMANGLE_COMPONENT_POINTER: + case DEMANGLE_COMPONENT_COMPLEX: + case DEMANGLE_COMPONENT_IMAGINARY: + modifier: { /* We keep a list of modifiers on the stack. */ struct d_print_mod dpm; @@ -3052,20 +4763,26 @@ d_print_comp (dpi, dc) dpm.printed = 0; dpm.templates = dpi->templates; - d_print_comp (dpi, d_left (dc)); + if (!mod_inner) + mod_inner = d_left (dc); + + d_print_comp (dpi, options, mod_inner); /* If the modifier didn't get printed by the type, print it now. */ if (! dpm.printed) - d_print_mod (dpi, dc); + d_print_mod (dpi, options, dc); dpi->modifiers = dpm.next; + if (need_template_restore) + dpi->templates = saved_templates; + return; } - case D_COMP_BUILTIN_TYPE: - if ((dpi->options & DMGL_JAVA) == 0) + case DEMANGLE_COMPONENT_BUILTIN_TYPE: + if ((options & DMGL_JAVA) == 0) d_append_buffer (dpi, dc->u.s_builtin.type->name, dc->u.s_builtin.type->len); else @@ -3073,66 +4790,123 @@ d_print_comp (dpi, dc) dc->u.s_builtin.type->java_len); return; - case D_COMP_VENDOR_TYPE: - d_print_comp (dpi, d_left (dc)); + case DEMANGLE_COMPONENT_VENDOR_TYPE: + d_print_comp (dpi, options, d_left (dc)); return; - case D_COMP_FUNCTION_TYPE: + case DEMANGLE_COMPONENT_FUNCTION_TYPE: { - if (d_left (dc) != NULL) + if ((options & DMGL_RET_POSTFIX) != 0) + d_print_function_type (dpi, + options & ~(DMGL_RET_POSTFIX | DMGL_RET_DROP), + dc, dpi->modifiers); + + /* Print return type if present */ + if (d_left (dc) != NULL && (options & DMGL_RET_POSTFIX) != 0) + d_print_comp (dpi, options & ~(DMGL_RET_POSTFIX | DMGL_RET_DROP), + d_left (dc)); + else if (d_left (dc) != NULL && (options & DMGL_RET_DROP) == 0) { struct d_print_mod dpm; /* We must pass this type down as a modifier in order to print it in the right location. */ - dpm.next = dpi->modifiers; dpi->modifiers = &dpm; dpm.mod = dc; dpm.printed = 0; dpm.templates = dpi->templates; - d_print_comp (dpi, d_left (dc)); + d_print_comp (dpi, options & ~(DMGL_RET_POSTFIX | DMGL_RET_DROP), + d_left (dc)); dpi->modifiers = dpm.next; if (dpm.printed) return; - d_append_char (dpi, ' '); + /* In standard prefix notation, there is a space between the + return type and the function signature. */ + if ((options & DMGL_RET_POSTFIX) == 0) + d_append_char (dpi, ' '); } - d_print_function_type (dpi, dc, dpi->modifiers); + if ((options & DMGL_RET_POSTFIX) == 0) + d_print_function_type (dpi, + options & ~(DMGL_RET_POSTFIX | DMGL_RET_DROP), + dc, dpi->modifiers); 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. */ - dpm.next = dpi->modifiers; - dpi->modifiers = &dpm; - dpm.mod = dc; - dpm.printed = 0; - dpm.templates = dpi->templates; + 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; + } - d_print_comp (dpi, d_right (dc)); + adpm[i] = *pdpm; + adpm[i].next = dpi->modifiers; + dpi->modifiers = &adpm[i]; + pdpm->printed = 1; + ++i; + } - dpi->modifiers = dpm.next; + pdpm = pdpm->next; + } + + d_print_comp (dpi, options, d_right (dc)); - if (dpm.printed) + dpi->modifiers = hold_modifiers; + + if (adpm[0].printed) return; - d_print_array_type (dpi, dc, dpi->modifiers); + while (i > 1) + { + --i; + d_print_mod (dpi, options, adpm[i].mod); + } + + d_print_array_type (dpi, options, dc, dpi->modifiers); return; } - case D_COMP_PTRMEM_TYPE: + case DEMANGLE_COMPONENT_PTRMEM_TYPE: + case DEMANGLE_COMPONENT_VECTOR_TYPE: { struct d_print_mod dpm; @@ -3142,188 +4916,437 @@ d_print_comp (dpi, dc) dpm.printed = 0; dpm.templates = dpi->templates; - d_print_comp (dpi, d_right (dc)); + d_print_comp (dpi, options, d_right (dc)); /* If the modifier didn't get printed by the type, print it now. */ if (! dpm.printed) - { - d_append_char (dpi, ' '); - d_print_comp (dpi, d_left (dc)); - d_append_string_constant (dpi, "::*"); - } + d_print_mod (dpi, options, dc); dpi->modifiers = dpm.next; return; } - case D_COMP_ARGLIST: - case D_COMP_TEMPLATE_ARGLIST: - d_print_comp (dpi, d_left (dc)); - if (d_right (dc) != NULL) - { - d_append_string_constant (dpi, ", "); - d_print_comp (dpi, d_right (dc)); - } + case DEMANGLE_COMPONENT_FIXED_TYPE: + if (dc->u.s_fixed.sat) + d_append_string (dpi, "_Sat "); + /* Don't print "int _Accum". */ + if (dc->u.s_fixed.length->u.s_builtin.type + != &cplus_demangle_builtin_types['i'-'a']) + { + d_print_comp (dpi, options, dc->u.s_fixed.length); + d_append_char (dpi, ' '); + } + if (dc->u.s_fixed.accum) + d_append_string (dpi, "_Accum"); + else + d_append_string (dpi, "_Fract"); + return; + + case DEMANGLE_COMPONENT_ARGLIST: + case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST: + if (d_left (dc) != NULL) + d_print_comp (dpi, options, d_left (dc)); + if (d_right (dc) != NULL) + { + size_t len; + unsigned long int flush_count; + /* Make sure ", " isn't flushed by d_append_string, otherwise + dpi->len -= 2 wouldn't work. */ + if (dpi->len >= sizeof (dpi->buf) - 2) + d_print_flush (dpi); + d_append_string (dpi, ", "); + len = dpi->len; + flush_count = dpi->flush_count; + d_print_comp (dpi, options, d_right (dc)); + /* If that didn't print anything (which can happen with empty + template argument packs), remove the comma and space. */ + if (dpi->flush_count == flush_count && dpi->len == len) + dpi->len -= 2; + } + return; + + case DEMANGLE_COMPONENT_INITIALIZER_LIST: + { + struct demangle_component *type = d_left (dc); + struct demangle_component *list = d_right (dc); + + if (type) + d_print_comp (dpi, options, type); + d_append_char (dpi, '{'); + d_print_comp (dpi, options, list); + d_append_char (dpi, '}'); + } + return; + + case DEMANGLE_COMPONENT_OPERATOR: + { + const struct demangle_operator_info *op = dc->u.s_operator.op; + int len = op->len; + + d_append_string (dpi, "operator"); + /* Add a space before new/delete. */ + if (IS_LOWER (op->name[0])) + d_append_char (dpi, ' '); + /* Omit a trailing space. */ + if (op->name[len-1] == ' ') + --len; + d_append_buffer (dpi, op->name, len); + return; + } + + case DEMANGLE_COMPONENT_EXTENDED_OPERATOR: + d_append_string (dpi, "operator "); + d_print_comp (dpi, options, dc->u.s_extended_operator.name); + return; + + case DEMANGLE_COMPONENT_CAST: + d_append_string (dpi, "operator "); + d_print_cast (dpi, options, dc); + return; + + case DEMANGLE_COMPONENT_NULLARY: + d_print_expr_op (dpi, options, d_left (dc)); + return; + + case DEMANGLE_COMPONENT_UNARY: + { + struct demangle_component *op = d_left (dc); + struct demangle_component *operand = d_right (dc); + const char *code = NULL; + + if (op->type == DEMANGLE_COMPONENT_OPERATOR) + { + code = op->u.s_operator.op->code; + if (!strcmp (code, "ad")) + { + /* Don't print the argument list for the address of a + function. */ + if (operand->type == DEMANGLE_COMPONENT_TYPED_NAME + && d_left (operand)->type == DEMANGLE_COMPONENT_QUAL_NAME + && d_right (operand)->type == DEMANGLE_COMPONENT_FUNCTION_TYPE) + operand = d_left (operand); + } + if (operand->type == DEMANGLE_COMPONENT_BINARY_ARGS) + { + /* This indicates a suffix operator. */ + operand = d_left (operand); + d_print_subexpr (dpi, options, operand); + d_print_expr_op (dpi, options, op); + return; + } + } + + if (op->type != DEMANGLE_COMPONENT_CAST) + d_print_expr_op (dpi, options, op); + else + { + d_append_char (dpi, '('); + d_print_cast (dpi, options, op); + d_append_char (dpi, ')'); + } + if (code && !strcmp (code, "gs")) + /* Avoid parens after '::'. */ + d_print_comp (dpi, options, operand); + else if (code && !strcmp (code, "st")) + /* Always print parens for sizeof (type). */ + { + d_append_char (dpi, '('); + d_print_comp (dpi, options, operand); + d_append_char (dpi, ')'); + } + else + d_print_subexpr (dpi, options, operand); + } + return; + + case DEMANGLE_COMPONENT_BINARY: + if (d_right (dc)->type != DEMANGLE_COMPONENT_BINARY_ARGS) + { + d_print_error (dpi); + return; + } + + if (op_is_new_cast (d_left (dc))) + { + d_print_expr_op (dpi, options, d_left (dc)); + d_append_char (dpi, '<'); + d_print_comp (dpi, options, d_left (d_right (dc))); + d_append_string (dpi, ">("); + d_print_comp (dpi, options, d_right (d_right (dc))); + d_append_char (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, '('); + + if (strcmp (d_left (dc)->u.s_operator.op->code, "cl") == 0 + && d_left (d_right (dc))->type == DEMANGLE_COMPONENT_TYPED_NAME) + { + /* Function call used in an expression should not have printed types + of the function arguments. Values of the function arguments still + get printed below. */ + + const struct demangle_component *func = d_left (d_right (dc)); + + if (d_right (func)->type != DEMANGLE_COMPONENT_FUNCTION_TYPE) + d_print_error (dpi); + d_print_subexpr (dpi, options, d_left (func)); + } + else + d_print_subexpr (dpi, options, d_left (d_right (dc))); + if (strcmp (d_left (dc)->u.s_operator.op->code, "ix") == 0) + { + d_append_char (dpi, '['); + d_print_comp (dpi, options, d_right (d_right (dc))); + d_append_char (dpi, ']'); + } + else + { + if (strcmp (d_left (dc)->u.s_operator.op->code, "cl") != 0) + d_print_expr_op (dpi, options, d_left (dc)); + d_print_subexpr (dpi, options, d_right (d_right (dc))); + } + + 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 DEMANGLE_COMPONENT_BINARY_ARGS: + /* We should only see this as part of DEMANGLE_COMPONENT_BINARY. */ + d_print_error (dpi); + return; + + 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; + } + { + struct demangle_component *op = d_left (dc); + struct demangle_component *first = d_left (d_right (dc)); + struct demangle_component *second = d_left (d_right (d_right (dc))); + struct demangle_component *third = d_right (d_right (d_right (dc))); + + if (!strcmp (op->u.s_operator.op->code, "qu")) + { + d_print_subexpr (dpi, options, first); + d_print_expr_op (dpi, options, op); + d_print_subexpr (dpi, options, second); + d_append_string (dpi, " : "); + d_print_subexpr (dpi, options, third); + } + else + { + d_append_string (dpi, "new "); + if (d_left (first) != NULL) + { + d_print_subexpr (dpi, options, first); + d_append_char (dpi, ' '); + } + d_print_comp (dpi, options, second); + if (third) + d_print_subexpr (dpi, options, third); + } + } + return; + + 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_OPERATOR: + case DEMANGLE_COMPONENT_LITERAL: + case DEMANGLE_COMPONENT_LITERAL_NEG: { - char c; + enum d_builtin_type_print tp; - d_append_string_constant (dpi, "operator"); - c = dc->u.s_operator.op->name[0]; - if (IS_LOWER (c)) - d_append_char (dpi, ' '); - d_append_buffer (dpi, dc->u.s_operator.op->name, - dc->u.s_operator.op->len); - return; - } + /* 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, options, 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 (dpi, "ul"); + break; + case D_PRINT_LONG_LONG: + d_append_string (dpi, "ll"); + break; + case D_PRINT_UNSIGNED_LONG_LONG: + d_append_string (dpi, "ull"); + break; + } + return; + } + break; + + case D_PRINT_BOOL: + if (d_right (dc)->type == DEMANGLE_COMPONENT_NAME + && d_right (dc)->u.s_name.len == 1 + && dc->type == DEMANGLE_COMPONENT_LITERAL) + { + switch (d_right (dc)->u.s_name.s[0]) + { + case '0': + d_append_string (dpi, "false"); + return; + case '1': + d_append_string (dpi, "true"); + return; + default: + break; + } + } + break; + + default: + break; + } + } - case D_COMP_EXTENDED_OPERATOR: - d_append_string_constant (dpi, "operator "); - d_print_comp (dpi, dc->u.s_extended_operator.name); + d_append_char (dpi, '('); + d_print_comp (dpi, options, 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, options, d_right (dc)); + if (tp == D_PRINT_FLOAT) + d_append_char (dpi, ']'); + } return; - case D_COMP_CAST: - d_append_string_constant (dpi, "operator "); - d_print_cast (dpi, dc); + case DEMANGLE_COMPONENT_NUMBER: + d_append_num (dpi, dc->u.s_number.number); return; - case D_COMP_UNARY: - if (d_left (dc)->type != D_COMP_CAST) - d_print_expr_op (dpi, d_left (dc)); - else - { - d_append_string_constant (dpi, "(("); - d_print_cast (dpi, d_left (dc)); - d_append_char (dpi, ')'); - } - d_append_char (dpi, '('); - d_print_comp (dpi, d_right (dc)); - d_append_char (dpi, ')'); - if (d_left (dc)->type == D_COMP_CAST) - d_append_char (dpi, ')'); + case DEMANGLE_COMPONENT_JAVA_RESOURCE: + d_append_string (dpi, "java resource "); + d_print_comp (dpi, options, d_left (dc)); return; - case D_COMP_BINARY: - if (d_right (dc)->type != D_COMP_BINARY_ARGS) - { - d_print_error (dpi); - return; - } + case DEMANGLE_COMPONENT_COMPOUND_NAME: + d_print_comp (dpi, options, d_left (dc)); + d_print_comp (dpi, options, d_right (dc)); + 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 == D_COMP_OPERATOR - && d_left (dc)->u.s_operator.op->len == 1 - && d_left (dc)->u.s_operator.op->name[0] == '>') - d_append_char (dpi, '('); + case DEMANGLE_COMPONENT_CHARACTER: + d_append_char (dpi, dc->u.s_character.character); + return; - d_append_char (dpi, '('); - d_print_comp (dpi, d_left (d_right (dc))); - d_append_string_constant (dpi, ") "); - d_print_expr_op (dpi, d_left (dc)); - d_append_string_constant (dpi, " ("); - d_print_comp (dpi, d_right (d_right (dc))); + case DEMANGLE_COMPONENT_DECLTYPE: + d_append_string (dpi, "decltype ("); + d_print_comp (dpi, options, d_left (dc)); d_append_char (dpi, ')'); + return; - if (d_left (dc)->type == D_COMP_OPERATOR - && d_left (dc)->u.s_operator.op->len == 1 - && d_left (dc)->u.s_operator.op->name[0] == '>') - d_append_char (dpi, ')'); + case DEMANGLE_COMPONENT_PACK_EXPANSION: + { + int len; + int i; + struct demangle_component *a = d_find_pack (dpi, d_left (dc)); + if (a == NULL) + { + /* d_find_pack won't find anything if the only packs involved + in this expansion are function parameter packs; in that + case, just print the pattern and "...". */ + d_print_subexpr (dpi, options, d_left (dc)); + d_append_string (dpi, "..."); + return; + } + len = d_pack_length (a); + dc = d_left (dc); + for (i = 0; i < len; ++i) + { + dpi->pack_index = i; + d_print_comp (dpi, options, dc); + if (i < len-1) + d_append_string (dpi, ", "); + } + } return; - case D_COMP_BINARY_ARGS: - /* We should only see this as part of D_COMP_BINARY. */ - d_print_error (dpi); + case DEMANGLE_COMPONENT_FUNCTION_PARAM: + { + long num = dc->u.s_number.number; + if (num == 0) + d_append_string (dpi, "this"); + else + { + d_append_string (dpi, "{parm#"); + d_append_num (dpi, num); + d_append_char (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) - { - d_print_error (dpi); - return; - } - d_append_char (dpi, '('); - d_print_comp (dpi, d_left (d_right (dc))); - d_append_string_constant (dpi, ") "); - d_print_expr_op (dpi, d_left (dc)); - d_append_string_constant (dpi, " ("); - d_print_comp (dpi, d_left (d_right (d_right (dc)))); - d_append_string_constant (dpi, ") : ("); - d_print_comp (dpi, d_right (d_right (d_right (dc)))); - d_append_char (dpi, ')'); + case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS: + d_append_string (dpi, "global constructors keyed to "); + d_print_comp (dpi, options, dc->u.s_binary.left); return; - case D_COMP_TRINARY_ARG1: - case D_COMP_TRINARY_ARG2: - /* We should only see these are part of D_COMP_TRINARY. */ - d_print_error (dpi); + case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS: + d_append_string (dpi, "global destructors keyed to "); + d_print_comp (dpi, options, dc->u.s_binary.left); return; - case D_COMP_LITERAL: - case D_COMP_LITERAL_NEG: - /* 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) - { - if (dc->type == D_COMP_LITERAL_NEG) - d_append_char (dpi, '-'); - d_print_comp (dpi, d_right (dc)); - return; - } - break; - - case D_PRINT_LONG: - if (d_right (dc)->type == D_COMP_NAME) - { - if (dc->type == D_COMP_LITERAL_NEG) - d_append_char (dpi, '-'); - d_print_comp (dpi, d_right (dc)); - d_append_char (dpi, 'l'); - return; - } - break; - - case D_PRINT_BOOL: - if (d_right (dc)->type == D_COMP_NAME - && d_right (dc)->u.s_name.len == 1 - && dc->type == D_COMP_LITERAL) - { - switch (d_right (dc)->u.s_name.s[0]) - { - case '0': - d_append_string_constant (dpi, "false"); - return; - case '1': - d_append_string_constant (dpi, "true"); - return; - default: - break; - } - } - break; + case DEMANGLE_COMPONENT_LAMBDA: + d_append_string (dpi, "{lambda("); + d_print_comp (dpi, options, dc->u.s_unary_num.sub); + d_append_string (dpi, ")#"); + d_append_num (dpi, dc->u.s_unary_num.num + 1); + d_append_char (dpi, '}'); + return; - default: - break; - } - } + case DEMANGLE_COMPONENT_UNNAMED_TYPE: + d_append_string (dpi, "{unnamed type#"); + d_append_num (dpi, dc->u.s_number.number + 1); + d_append_char (dpi, '}'); + return; - d_append_char (dpi, '('); - d_print_comp (dpi, d_left (dc)); - d_append_char (dpi, ')'); - if (dc->type == D_COMP_LITERAL_NEG) - d_append_char (dpi, '-'); - d_print_comp (dpi, d_right (dc)); + case DEMANGLE_COMPONENT_CLONE: + d_print_comp (dpi, options, d_left (dc)); + d_append_string (dpi, " [clone "); + d_print_comp (dpi, options, d_right (dc)); + d_append_char (dpi, ']'); return; default: @@ -3332,16 +5355,28 @@ d_print_comp (dpi, dc) } } +static void +d_print_comp (struct d_print_info *dpi, int options, + const struct demangle_component *dc) +{ + struct d_component_stack self; + + self.dc = dc; + self.parent = dpi->component_stack; + dpi->component_stack = &self; + + d_print_comp_inner (dpi, options, dc); + + dpi->component_stack = self.parent; +} + /* 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_java_identifier (dpi, name, len) - struct d_print_info *dpi; - const char *name; - int len; +d_print_java_identifier (struct d_print_info *dpi, const char *name, int len) { const char *p; const char *end; @@ -3391,10 +5426,8 @@ d_print_java_identifier (dpi, name, len) qualifiers on this after printing a function. */ static void -d_print_mod_list (dpi, mods, suffix) - struct d_print_info *dpi; - struct d_print_mod *mods; - int suffix; +d_print_mod_list (struct d_print_info *dpi, int options, + struct d_print_mod *mods, int suffix) { struct d_print_template *hold_dpt; @@ -3403,11 +5436,14 @@ d_print_mod_list (dpi, mods, suffix) if (mods->printed || (! suffix - && (mods->mod->type == D_COMP_RESTRICT_THIS - || mods->mod->type == D_COMP_VOLATILE_THIS - || mods->mod->type == D_COMP_CONST_THIS))) + && (mods->mod->type == DEMANGLE_COMPONENT_RESTRICT_THIS + || mods->mod->type == DEMANGLE_COMPONENT_VOLATILE_THIS + || mods->mod->type == DEMANGLE_COMPONENT_CONST_THIS + || mods->mod->type == DEMANGLE_COMPONENT_REFERENCE_THIS + || (mods->mod->type + == DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS)))) { - d_print_mod_list (dpi, mods->next, suffix); + d_print_mod_list (dpi, options, mods->next, suffix); return; } @@ -3416,22 +5452,22 @@ d_print_mod_list (dpi, mods, suffix) hold_dpt = dpi->templates; dpi->templates = mods->templates; - if (mods->mod->type == D_COMP_FUNCTION_TYPE) + if (mods->mod->type == DEMANGLE_COMPONENT_FUNCTION_TYPE) { - d_print_function_type (dpi, mods->mod, mods->next); + d_print_function_type (dpi, options, 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); + d_print_array_type (dpi, options, mods->mod, mods->next); dpi->templates = hold_dpt; return; } - else if (mods->mod->type == D_COMP_LOCAL_NAME) + else if (mods->mod->type == DEMANGLE_COMPONENT_LOCAL_NAME) { struct d_print_mod *hold_modifiers; - struct d_comp *dc; + struct demangle_component *dc; /* When this is on the modifier stack, we have pulled any qualifiers off the right argument already. Otherwise, we @@ -3440,85 +5476,109 @@ d_print_mod_list (dpi, mods, suffix) hold_modifiers = dpi->modifiers; dpi->modifiers = NULL; - d_print_comp (dpi, d_left (mods->mod)); + d_print_comp (dpi, options, d_left (mods->mod)); dpi->modifiers = hold_modifiers; - if ((dpi->options & DMGL_JAVA) == 0) - d_append_string_constant (dpi, "::"); + if ((options & DMGL_JAVA) == 0) + d_append_string (dpi, "::"); else d_append_char (dpi, '.'); dc = d_right (mods->mod); - while (dc->type == D_COMP_RESTRICT_THIS - || dc->type == D_COMP_VOLATILE_THIS - || dc->type == D_COMP_CONST_THIS) + + if (dc->type == DEMANGLE_COMPONENT_DEFAULT_ARG) + { + d_append_string (dpi, "{default arg#"); + d_append_num (dpi, dc->u.s_unary_num.num + 1); + d_append_string (dpi, "}::"); + dc = dc->u.s_unary_num.sub; + } + + while (dc->type == DEMANGLE_COMPONENT_RESTRICT_THIS + || dc->type == DEMANGLE_COMPONENT_VOLATILE_THIS + || dc->type == DEMANGLE_COMPONENT_CONST_THIS + || dc->type == DEMANGLE_COMPONENT_REFERENCE_THIS + || dc->type == DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS) dc = d_left (dc); - d_print_comp (dpi, dc); + d_print_comp (dpi, options, dc); dpi->templates = hold_dpt; return; } - d_print_mod (dpi, mods->mod); + d_print_mod (dpi, options, mods->mod); dpi->templates = hold_dpt; - d_print_mod_list (dpi, mods->next, suffix); + d_print_mod_list (dpi, options, 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, int options, + const struct demangle_component *mod) { switch (mod->type) { - case D_COMP_RESTRICT: - case D_COMP_RESTRICT_THIS: - d_append_string_constant (dpi, " restrict"); + case DEMANGLE_COMPONENT_RESTRICT: + case DEMANGLE_COMPONENT_RESTRICT_THIS: + d_append_string (dpi, " restrict"); return; - case D_COMP_VOLATILE: - case D_COMP_VOLATILE_THIS: - d_append_string_constant (dpi, " volatile"); + case DEMANGLE_COMPONENT_VOLATILE: + case DEMANGLE_COMPONENT_VOLATILE_THIS: + d_append_string (dpi, " volatile"); return; - case D_COMP_CONST: - case D_COMP_CONST_THIS: - d_append_string_constant (dpi, " const"); + case DEMANGLE_COMPONENT_CONST: + case DEMANGLE_COMPONENT_CONST_THIS: + d_append_string (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)); + d_print_comp (dpi, options, 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) + if ((options & DMGL_JAVA) == 0) d_append_char (dpi, '*'); return; - case D_COMP_REFERENCE: + case DEMANGLE_COMPONENT_REFERENCE_THIS: + /* For the ref-qualifier, put a space before the &. */ + d_append_char (dpi, ' '); + case DEMANGLE_COMPONENT_REFERENCE: d_append_char (dpi, '&'); return; - case D_COMP_COMPLEX: - d_append_string_constant (dpi, "complex "); + case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS: + d_append_char (dpi, ' '); + case DEMANGLE_COMPONENT_RVALUE_REFERENCE: + d_append_string (dpi, "&&"); + return; + case DEMANGLE_COMPONENT_COMPLEX: + d_append_string (dpi, "complex "); return; - case D_COMP_IMAGINARY: - d_append_string_constant (dpi, "imaginary "); + case DEMANGLE_COMPONENT_IMAGINARY: + d_append_string (dpi, "imaginary "); return; - case D_COMP_PTRMEM_TYPE: + case DEMANGLE_COMPONENT_PTRMEM_TYPE: if (d_last_char (dpi) != '(') d_append_char (dpi, ' '); - d_print_comp (dpi, d_left (mod)); - d_append_string_constant (dpi, "::*"); + d_print_comp (dpi, options, d_left (mod)); + d_append_string (dpi, "::*"); + return; + case DEMANGLE_COMPONENT_TYPED_NAME: + d_print_comp (dpi, options, d_left (mod)); return; - case D_COMP_TYPED_NAME: - d_print_comp (dpi, d_left (mod)); + case DEMANGLE_COMPONENT_VECTOR_TYPE: + d_append_string (dpi, " __vector("); + d_print_comp (dpi, options, d_left (mod)); + d_append_char (dpi, ')'); return; + default: /* Otherwise, we have something that won't go back on the modifier stack, so we can just print it. */ - d_print_comp (dpi, mod); + d_print_comp (dpi, options, mod); return; } } @@ -3526,40 +5586,44 @@ 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, int options, + 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) break; - 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: + case DEMANGLE_COMPONENT_RVALUE_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 D_COMP_RESTRICT_THIS: - case D_COMP_VOLATILE_THIS: - case D_COMP_CONST_THIS: + case DEMANGLE_COMPONENT_RESTRICT_THIS: + case DEMANGLE_COMPONENT_VOLATILE_THIS: + case DEMANGLE_COMPONENT_CONST_THIS: + case DEMANGLE_COMPONENT_REFERENCE_THIS: + case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS: break; default: break; @@ -3568,30 +5632,23 @@ d_print_function_type (dpi, dc, mods) break; } - if (d_left (dc) != NULL && ! saw_mod) - need_paren = 1; - if (need_paren) { - switch (d_last_char (dpi)) + if (! need_space) { - case ' ': - case '(': - case '*': - break; - - default: - d_append_char (dpi, ' '); - break; + if (d_last_char (dpi) != '(' + && d_last_char (dpi) != '*') + need_space = 1; } - + if (need_space && d_last_char (dpi) != ' ') + d_append_char (dpi, ' '); d_append_char (dpi, '('); } hold_modifiers = dpi->modifiers; dpi->modifiers = NULL; - d_print_mod_list (dpi, mods, 0); + d_print_mod_list (dpi, options, mods, 0); if (need_paren) d_append_char (dpi, ')'); @@ -3599,11 +5656,11 @@ d_print_function_type (dpi, dc, mods) d_append_char (dpi, '('); if (d_right (dc) != NULL) - d_print_comp (dpi, d_right (dc)); + d_print_comp (dpi, options, d_right (dc)); d_append_char (dpi, ')'); - d_print_mod_list (dpi, mods, 1); + d_print_mod_list (dpi, options, mods, 1); dpi->modifiers = hold_modifiers; } @@ -3611,10 +5668,9 @@ d_print_function_type (dpi, dc, mods) /* 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, int options, + const struct demangle_component *dc, + struct d_print_mod *mods) { int need_space; @@ -3627,26 +5683,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_constant (dpi, " ("); + d_append_string (dpi, " ("); - d_print_mod_list (dpi, mods, 0); + d_print_mod_list (dpi, options, mods, 0); if (need_paren) d_append_char (dpi, ')'); @@ -3658,7 +5714,7 @@ d_print_array_type (dpi, dc, mods) d_append_char (dpi, '['); if (d_left (dc) != NULL) - d_print_comp (dpi, d_left (dc)); + d_print_comp (dpi, options, d_left (dc)); d_append_char (dpi, ']'); } @@ -3666,70 +5722,68 @@ 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, int options, + const struct demangle_component *dc) { - if (dc->type == D_COMP_OPERATOR) + 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); + d_print_comp (dpi, options, 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, int options, + const struct demangle_component *dc) { - if (d_left (dc)->type != D_COMP_TEMPLATE) - d_print_comp (dpi, d_left (dc)); - else - { - struct d_print_mod *hold_dpm; - struct d_print_template dpt; - - /* 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. */ - - hold_dpm = dpi->modifiers; - dpi->modifiers = NULL; + struct d_print_template dpt; + /* For a cast operator, we need the template parameters from + the enclosing template in scope for processing the type. */ + if (dpi->current_template != NULL) + { dpt.next = dpi->templates; dpi->templates = &dpt; - dpt.template = d_left (dc); + dpt.template_decl = dpi->current_template; + } - d_print_comp (dpi, d_left (d_left (dc))); + if (d_left (dc)->type != DEMANGLE_COMPONENT_TEMPLATE) + { + d_print_comp (dpi, options, d_left (dc)); + if (dpi->current_template != NULL) + dpi->templates = dpt.next; + } + else + { + d_print_comp (dpi, options, d_left (d_left (dc))); - dpi->templates = dpt.next; + /* For a templated cast operator, we need to remove the template + parameters from scope after printing the operator name, + so we need to handle the template printing here. */ + if (dpi->current_template != NULL) + 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))); + d_print_comp (dpi, options, d_right (d_left (dc))); /* Avoid generating two consecutive '>' characters, to avoid the C++ syntactic ambiguity. */ if (d_last_char (dpi) == '>') d_append_char (dpi, ' '); d_append_char (dpi, '>'); - - dpi->modifiers = hold_dpm; } } /* Initialize the information structure we use to pass around information. */ -static void -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; @@ -3752,90 +5806,81 @@ d_init_info (mangled, options, len, di) di->last_name = NULL; di->expansion = 0; + di->is_expression = 0; + di->is_conversion = 0; } -/* Entry point for the demangler. If MANGLED is a g++ v3 ABI mangled - name, return a buffer allocated with malloc holding the demangled - name. OPTIONS is the usual libiberty demangler options. On - success, this sets *PALC to the allocated size of the returned - buffer. On failure, this sets *PALC to 0 for a bad name, or 1 for - a memory allocation failure. On failure, this returns NULL. */ +/* Internal implementation for the demangler. If MANGLED is a g++ v3 ABI + mangled name, return strings in repeated callback giving the demangled + name. OPTIONS is the usual libiberty demangler options. On success, + this returns 1. On failure, returns 0. */ -static char * -d_demangle (mangled, options, palc) - const char* mangled; - int options; - size_t *palc; +static int +d_demangle_callback (const char *mangled, int options, + demangle_callbackref callback, void *opaque) { - size_t len; - int type; + enum + { + DCT_TYPE, + DCT_MANGLED, + DCT_GLOBAL_CTORS, + DCT_GLOBAL_DTORS + } + type; struct d_info di; - struct d_comp *dc; - int estimate; - char *ret; - - *palc = 0; - - len = strlen (mangled); + struct demangle_component *dc; + int status; if (mangled[0] == '_' && mangled[1] == 'Z') - type = 0; + type = DCT_MANGLED; else if (strncmp (mangled, "_GLOBAL_", 8) == 0 && (mangled[8] == '.' || mangled[8] == '_' || mangled[8] == '$') && (mangled[9] == 'D' || mangled[9] == 'I') && mangled[10] == '_') - { - char *r; - - r = malloc (40 + len - 11); - if (r == NULL) - *palc = 1; - else - { - if (mangled[9] == 'I') - strcpy (r, "global constructors keyed to "); - else - strcpy (r, "global destructors keyed to "); - strcat (r, mangled + 11); - } - return r; - } + type = mangled[9] == 'I' ? DCT_GLOBAL_CTORS : DCT_GLOBAL_DTORS; else { if ((options & DMGL_TYPES) == 0) - return NULL; - type = 1; + return 0; + type = DCT_TYPE; } - d_init_info (mangled, options, len, &di); + cplus_demangle_init_info (mangled, options, strlen (mangled), &di); { #ifdef CP_DYNAMIC_ARRAYS - __extension__ struct d_comp comps[di.num_comps]; - __extension__ struct d_comp *subs[di.num_subs]; + __extension__ struct demangle_component comps[di.num_comps]; + __extension__ struct demangle_component *subs[di.num_subs]; - di.comps = &comps[0]; - di.subs = &subs[0]; + di.comps = comps; + di.subs = subs; #else - di.comps = (struct d_comp *) malloc (di.num_comps - * sizeof (struct d_comp)); - di.subs = (struct d_comp **) malloc (di.num_subs - * sizeof (struct d_comp *)); - 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; - } + di.comps = alloca (di.num_comps * sizeof (*di.comps)); + di.subs = alloca (di.num_subs * sizeof (*di.subs)); #endif - if (! type) - dc = d_mangled_name (&di, 1); - else - dc = d_type (&di); + switch (type) + { + case DCT_TYPE: + dc = cplus_demangle_type (&di); + break; + case DCT_MANGLED: + dc = cplus_demangle_mangled_name (&di, 1); + break; + case DCT_GLOBAL_CTORS: + case DCT_GLOBAL_DTORS: + d_advance (&di, 11); + dc = d_make_comp (&di, + (type == DCT_GLOBAL_CTORS + ? DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS + : DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS), + d_make_demangle_mangled_name (&di, d_str (&di)), + NULL); + d_advance (&di, strlen (d_str (&di))); + break; + default: + abort (); /* We have listed all the cases. */ + } /* If DMGL_PARAMS is set, then if we didn't consume the entire mangled string, then we didn't successfully demangle it. If @@ -3845,51 +5890,48 @@ d_demangle (mangled, options, palc) dc = NULL; #ifdef CP_DEMANGLE_DEBUG - if (dc == NULL) - printf ("failed demangling\n"); - else - d_dump (dc, 0); + d_dump (dc, 0); #endif - /* 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; + status = (dc != NULL) + ? cplus_demangle_print_callback (options, dc, callback, opaque) + : 0; + } + + return status; +} - ret = NULL; - if (dc != NULL) - ret = d_print (options, dc, estimate, palc); +/* Entry point for the demangler. If MANGLED is a g++ v3 ABI mangled + name, return a buffer allocated with malloc holding the demangled + name. OPTIONS is the usual libiberty demangler options. On + success, this sets *PALC to the allocated size of the returned + buffer. On failure, this sets *PALC to 0 for a bad name, or 1 for + a memory allocation failure, and returns NULL. */ -#ifndef CP_DYNAMIC_ARRAYS - free (di.comps); - free (di.subs); -#endif +static char * +d_demangle (const char *mangled, int options, size_t *palc) +{ + struct d_growable_string dgs; + int status; -#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 - } + d_growable_string_init (&dgs, 0); - return ret; + status = d_demangle_callback (mangled, options, + d_growable_string_callback_adapter, &dgs); + if (status == 0) + { + free (dgs.buf); + *palc = 0; + return NULL; + } + + *palc = dgs.allocation_failure ? 1 : dgs.alc; + return dgs.buf; } #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 @@ -3901,7 +5943,7 @@ extern char *__cxa_demangle PARAMS ((const char *, char *, size_t *, int *)); OUTPUT_BUFFER may instead be NULL; in that case, the demangled name is placed in a region of memory allocated with malloc. - If LENGTH is non-NULL, the length of the buffer conaining the + If LENGTH is non-NULL, the length of the buffer containing the demangled name, is placed in *LENGTH. The return value is a pointer to the start of the NUL-terminated @@ -3918,38 +5960,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; } @@ -3973,11 +6014,54 @@ __cxa_demangle (mangled_name, output_buffer, length, status) } } - *status = 0; + if (status != NULL) + *status = 0; return demangled; } +extern int __gcclibcxx_demangle_callback (const char *, + void (*) + (const char *, size_t, void *), + void *); + +/* Alternative, allocationless entry point in the C++ runtime library + for performing demangling. MANGLED_NAME is a NUL-terminated character + string containing the name to be demangled. + + CALLBACK is a callback function, called with demangled string + segments as demangling progresses; it is called at least once, + but may be called more than once. OPAQUE is a generalized pointer + used as a callback argument. + + The return code is one of the following values, equivalent to + the STATUS values of __cxa_demangle() (excluding -1, since this + function performs no memory allocations): + 0: The demangling operation succeeded. + -2: MANGLED_NAME is not a valid name under the C++ ABI mangling rules. + -3: One of the arguments is invalid. + + The demangling is performed using the C++ ABI mangling rules, with + GNU extensions. */ + +int +__gcclibcxx_demangle_callback (const char *mangled_name, + void (*callback) (const char *, size_t, void *), + void *opaque) +{ + int status; + + if (mangled_name == NULL || callback == NULL) + return -3; + + status = d_demangle_callback (mangled_name, DMGL_PARAMS | DMGL_TYPES, + callback, opaque); + if (status == 0) + return -2; + + return 0; +} + #else /* ! (IN_LIBGCC2 || IN_GLIBCPP_V3) */ /* Entry point for libiberty demangler. If MANGLED is a g++ v3 ABI @@ -3985,63 +6069,41 @@ __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; return d_demangle (mangled, options, &alc); } +int +cplus_demangle_v3_callback (const char *mangled, int options, + demangle_callbackref callback, void *opaque) +{ + return d_demangle_callback (mangled, options, callback, opaque); +} + /* Demangle a Java symbol. Java uses a subset of the V3 ABI C++ mangling conventions, but the output formatting is a little different. - This instructs the C++ demangler not to emit pointer characters ("*"), and - to use Java's namespace separator symbol ("." instead of "::"). It then - does an additional pass over the demangled output to replace instances - of JArray with TYPE[]. */ + This instructs the C++ demangler not to emit pointer characters ("*"), to + use Java's namespace separator symbol ("." instead of "::"), and to output + JArray as TYPE[]. */ char * -java_demangle_v3 (mangled) - const char* mangled; +java_demangle_v3 (const char *mangled) { size_t alc; - char *demangled; - int nesting; - char *from; - char *to; - - demangled = d_demangle (mangled, DMGL_JAVA | DMGL_PARAMS, &alc); - - if (demangled == NULL) - return NULL; - - nesting = 0; - from = demangled; - to = from; - while (*from != '\0') - { - if (strncmp (from, "JArray<", 7) == 0) - { - from += 7; - ++nesting; - } - else if (nesting > 0 && *from == '>') - { - while (to > demangled && to[-1] == ' ') - --to; - *to++ = '['; - *to++ = ']'; - --nesting; - ++from; - } - else - *to++ = *from++; - } - *to = '\0'; + return d_demangle (mangled, DMGL_JAVA | DMGL_PARAMS | DMGL_RET_POSTFIX, &alc); +} - return demangled; +int +java_demangle_v3_callback (const char *mangled, + demangle_callbackref callback, void *opaque) +{ + return d_demangle_callback (mangled, + DMGL_JAVA | DMGL_PARAMS | DMGL_RET_POSTFIX, + callback, opaque); } #endif /* IN_LIBGCC2 || IN_GLIBCPP_V3 */ @@ -4053,44 +6115,32 @@ 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; - d_init_info (mangled, DMGL_GNU_V3, strlen (mangled), &di); + cplus_demangle_init_info (mangled, DMGL_GNU_V3, strlen (mangled), &di); { #ifdef CP_DYNAMIC_ARRAYS - __extension__ struct d_comp comps[di.num_comps]; - __extension__ struct d_comp *subs[di.num_subs]; + __extension__ struct demangle_component comps[di.num_comps]; + __extension__ struct demangle_component *subs[di.num_subs]; - di.comps = &comps[0]; - di.subs = &subs[0]; + di.comps = comps; + di.subs = subs; #else - di.comps = (struct d_comp *) malloc (di.num_comps - * sizeof (struct d_comp)); - di.subs = (struct d_comp **) malloc (di.num_subs - * sizeof (struct d_comp *)); - 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; - } + di.comps = alloca (di.num_comps * sizeof (*di.comps)); + di.subs = alloca (di.num_subs * sizeof (*di.subs)); #endif - dc = d_mangled_name (&di, 1); + dc = cplus_demangle_mangled_name (&di, 1); /* Note that because we did not pass DMGL_PARAMS, we don't expect to demangle the entire string. */ @@ -4100,37 +6150,35 @@ is_ctor_or_dtor (mangled, ctor_kind, dtor_kind) { switch (dc->type) { + /* These cannot appear on a constructor or destructor. */ + case DEMANGLE_COMPONENT_RESTRICT_THIS: + case DEMANGLE_COMPONENT_VOLATILE_THIS: + case DEMANGLE_COMPONENT_CONST_THIS: + case DEMANGLE_COMPONENT_REFERENCE_THIS: + case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS: default: dc = NULL; break; - case D_COMP_TYPED_NAME: - case D_COMP_TEMPLATE: - case D_COMP_RESTRICT_THIS: - case D_COMP_VOLATILE_THIS: - case D_COMP_CONST_THIS: + case DEMANGLE_COMPONENT_TYPED_NAME: + case DEMANGLE_COMPONENT_TEMPLATE: dc = d_left (dc); break; - case D_COMP_QUAL_NAME: - case D_COMP_LOCAL_NAME: + case DEMANGLE_COMPONENT_QUAL_NAME: + case DEMANGLE_COMPONENT_LOCAL_NAME: dc = d_right (dc); break; - case D_COMP_CTOR: + case DEMANGLE_COMPONENT_CTOR: *ctor_kind = dc->u.s_ctor.kind; ret = 1; dc = NULL; break; - case D_COMP_DTOR: + case DEMANGLE_COMPONENT_DTOR: *dtor_kind = dc->u.s_dtor.kind; ret = 1; dc = NULL; break; } } - -#ifndef CP_DYNAMIC_ARRAYS - free (di.subs); - free (di.comps); -#endif } return ret; @@ -4140,8 +6188,7 @@ is_ctor_or_dtor (mangled, ctor_kind, dtor_kind) 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; @@ -4156,8 +6203,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; @@ -4174,7 +6220,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') \ @@ -4191,9 +6237,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"); @@ -4220,9 +6264,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; @@ -4280,7 +6322,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) { @@ -4312,9 +6358,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) @@ -4323,7 +6376,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 + } } }