X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=libiberty%2Fcp-demangle.c;h=43cf34a36cf2c9ff8cd3b4ebe2c6b826fa554238;hb=a192ba05083cb72a218e7c7722f30eadb9973833;hp=fe4b36712d35da9798d59f9e8da8e8155c8f3793;hpb=2d7332114ad6d55dd4a79fd55a568f3fa0595d2a;p=deliverable%2Fbinutils-gdb.git diff --git a/libiberty/cp-demangle.c b/libiberty/cp-demangle.c index fe4b36712d..43cf34a36c 100644 --- a/libiberty/cp-demangle.c +++ b/libiberty/cp-demangle.c @@ -1,5 +1,6 @@ /* Demangler for g++ V3 ABI. - Copyright (C) 2003, 2004 Free Software Foundation, Inc. + Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008 + 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,6 +43,10 @@ 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) @@ -50,12 +55,14 @@ 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 @@ -64,14 +71,20 @@ 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(), and no other - publically visible functions or variables. + 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 @@ -82,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 @@ -95,6 +112,18 @@ #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" @@ -109,39 +138,38 @@ #define CP_STATIC_IF_GLIBCPP_V3 static #define cplus_demangle_fill_name d_fill_name -static int -d_fill_name PARAMS ((struct demangle_component *, const char *, int)); +static int d_fill_name (struct demangle_component *, const char *, int); #define cplus_demangle_fill_extended_operator d_fill_extended_operator static int -d_fill_extended_operator PARAMS ((struct demangle_component *, int, - struct demangle_component *)); +d_fill_extended_operator (struct demangle_component *, int, + struct demangle_component *); #define cplus_demangle_fill_ctor d_fill_ctor static int -d_fill_ctor PARAMS ((struct demangle_component *, enum gnu_v3_ctor_kinds, - struct demangle_component *)); +d_fill_ctor (struct demangle_component *, enum gnu_v3_ctor_kinds, + struct demangle_component *); #define cplus_demangle_fill_dtor d_fill_dtor static int -d_fill_dtor PARAMS ((struct demangle_component *, enum gnu_v3_dtor_kinds, - struct demangle_component *)); +d_fill_dtor (struct demangle_component *, enum gnu_v3_dtor_kinds, + struct demangle_component *); #define cplus_demangle_mangled_name d_mangled_name -static struct demangle_component * -d_mangled_name PARAMS ((struct d_info *, int)); +static struct demangle_component *d_mangled_name (struct d_info *, int); #define cplus_demangle_type d_type -static struct demangle_component * -d_type PARAMS ((struct d_info *)); +static struct demangle_component *d_type (struct d_info *); #define cplus_demangle_print d_print -static char * -d_print PARAMS ((int, const struct demangle_component *, int, size_t *)); +static char *d_print (int, const struct demangle_component *, int, size_t *); + +#define cplus_demangle_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 PARAMS ((const char *, int, size_t, struct d_info *)); +static void d_init_info (const char *, int, size_t, struct d_info *); #else /* ! defined(IN_GLIBCPP_V3) */ #define CP_STATIC_IF_GLIBCPP_V3 @@ -167,8 +195,8 @@ d_init_info PARAMS ((const char *, int, size_t, struct d_info *)); 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') @@ -215,7 +243,7 @@ struct d_print_template /* Next template on the list. */ struct d_print_template *next; /* This template. */ - const struct demangle_component *template; + const struct demangle_component *template_decl; }; /* A list of type modifiers. This is used while printing. */ @@ -233,245 +261,236 @@ struct d_print_mod 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; +}; + +enum { D_PRINT_BUFFER_LENGTH = 256 }; +struct d_print_info +{ + /* The options passed to the demangler. */ + int options; + /* 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; }; -#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 demangle_component *, int)); +static void d_dump (struct demangle_component *, int); #endif static struct demangle_component * -d_make_empty PARAMS ((struct d_info *)); +d_make_empty (struct d_info *); static struct demangle_component * -d_make_comp PARAMS ((struct d_info *, enum demangle_component_type, - struct demangle_component *, - struct demangle_component *)); +d_make_comp (struct d_info *, enum demangle_component_type, + struct demangle_component *, + struct demangle_component *); static struct demangle_component * -d_make_name PARAMS ((struct d_info *, const char *, int)); +d_make_name (struct d_info *, const char *, int); static struct demangle_component * -d_make_builtin_type PARAMS ((struct d_info *, - const struct demangle_builtin_type_info *)); +d_make_builtin_type (struct d_info *, + const struct demangle_builtin_type_info *); static struct demangle_component * -d_make_operator PARAMS ((struct d_info *, - const struct demangle_operator_info *)); +d_make_operator (struct d_info *, + const struct demangle_operator_info *); static struct demangle_component * -d_make_extended_operator PARAMS ((struct d_info *, int, - struct demangle_component *)); +d_make_extended_operator (struct d_info *, int, + struct demangle_component *); static struct demangle_component * -d_make_ctor PARAMS ((struct d_info *, enum gnu_v3_ctor_kinds, - struct demangle_component *)); +d_make_ctor (struct d_info *, enum gnu_v3_ctor_kinds, + struct demangle_component *); static struct demangle_component * -d_make_dtor PARAMS ((struct d_info *, enum gnu_v3_dtor_kinds, - struct demangle_component *)); +d_make_dtor (struct d_info *, enum gnu_v3_dtor_kinds, + struct demangle_component *); static struct demangle_component * -d_make_template_param PARAMS ((struct d_info *, long)); +d_make_template_param (struct d_info *, long); static struct demangle_component * -d_make_sub PARAMS ((struct d_info *, const char *, int)); +d_make_sub (struct d_info *, const char *, int); static int -has_return_type PARAMS ((struct demangle_component *)); +has_return_type (struct demangle_component *); static int -is_ctor_dtor_or_conversion PARAMS ((struct demangle_component *)); +is_ctor_dtor_or_conversion (struct demangle_component *); -static struct demangle_component * -d_encoding PARAMS ((struct d_info *, int)); +static struct demangle_component *d_encoding (struct d_info *, int); -static struct demangle_component * -d_name PARAMS ((struct d_info *)); +static struct demangle_component *d_name (struct d_info *); -static struct demangle_component * -d_nested_name PARAMS ((struct d_info *)); +static struct demangle_component *d_nested_name (struct d_info *); -static struct demangle_component * -d_prefix PARAMS ((struct d_info *)); +static struct demangle_component *d_prefix (struct d_info *); -static struct demangle_component * -d_unqualified_name PARAMS ((struct d_info *)); +static struct demangle_component *d_unqualified_name (struct d_info *); -static struct demangle_component * -d_source_name PARAMS ((struct d_info *)); +static struct demangle_component *d_source_name (struct d_info *); -static long -d_number PARAMS ((struct d_info *)); +static long d_number (struct d_info *); -static struct demangle_component * -d_identifier PARAMS ((struct d_info *, int)); +static struct demangle_component *d_identifier (struct d_info *, int); -static struct demangle_component * -d_operator_name PARAMS ((struct d_info *)); +static struct demangle_component *d_operator_name (struct d_info *); -static struct demangle_component * -d_special_name PARAMS ((struct d_info *)); +static struct demangle_component *d_special_name (struct d_info *); -static int -d_call_offset PARAMS ((struct d_info *, int)); +static int d_call_offset (struct d_info *, int); -static struct demangle_component * -d_ctor_dtor_name PARAMS ((struct d_info *)); +static struct demangle_component *d_ctor_dtor_name (struct d_info *); static struct demangle_component ** -d_cv_qualifiers PARAMS ((struct d_info *, struct demangle_component **, int)); +d_cv_qualifiers (struct d_info *, struct demangle_component **, int); static struct demangle_component * -d_function_type PARAMS ((struct d_info *)); +d_function_type (struct d_info *); static struct demangle_component * -d_bare_function_type PARAMS ((struct d_info *, int)); +d_bare_function_type (struct d_info *, int); static struct demangle_component * -d_class_enum_type PARAMS ((struct d_info *)); +d_class_enum_type (struct d_info *); -static struct demangle_component * -d_array_type PARAMS ((struct d_info *)); +static struct demangle_component *d_array_type (struct d_info *); static struct demangle_component * -d_pointer_to_member_type PARAMS ((struct d_info *)); +d_pointer_to_member_type (struct d_info *); static struct demangle_component * -d_template_param PARAMS ((struct d_info *)); +d_template_param (struct d_info *); -static struct demangle_component * -d_template_args PARAMS ((struct d_info *)); +static struct demangle_component *d_template_args (struct d_info *); static struct demangle_component * -d_template_arg PARAMS ((struct d_info *)); +d_template_arg (struct d_info *); -static struct demangle_component * -d_expression PARAMS ((struct d_info *)); +static struct demangle_component *d_expression (struct d_info *); -static struct demangle_component * -d_expr_primary PARAMS ((struct d_info *)); +static struct demangle_component *d_expr_primary (struct d_info *); -static struct demangle_component * -d_local_name PARAMS ((struct d_info *)); +static struct demangle_component *d_local_name (struct d_info *); -static int -d_discriminator PARAMS ((struct d_info *)); +static int d_discriminator (struct d_info *); + +static struct demangle_component *d_lambda (struct d_info *); + +static struct demangle_component *d_unnamed_type (struct d_info *); static int -d_add_substitution PARAMS ((struct d_info *, struct demangle_component *)); +d_add_substitution (struct d_info *, struct demangle_component *); -static struct demangle_component * -d_substitution PARAMS ((struct d_info *, int)); +static struct demangle_component *d_substitution (struct d_info *, int); -static void -d_print_resize PARAMS ((struct d_print_info *, size_t)); +static void d_growable_string_init (struct d_growable_string *, size_t); -static void -d_print_append_char PARAMS ((struct d_print_info *, int)); +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_print_append_buffer PARAMS ((struct d_print_info *, const char *, size_t)); +d_growable_string_callback_adapter (const char *, size_t, void *); static void -d_print_error PARAMS ((struct d_print_info *)); +d_print_init (struct d_print_info *, int, demangle_callbackref, void *); + +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 PARAMS ((struct d_print_info *, - const struct demangle_component *)); +d_print_comp (struct d_print_info *, const struct demangle_component *); static void -d_print_java_identifier PARAMS ((struct d_print_info *, const char *, int)); +d_print_java_identifier (struct d_print_info *, const char *, int); static void -d_print_mod_list PARAMS ((struct d_print_info *, struct d_print_mod *, int)); +d_print_mod_list (struct d_print_info *, struct d_print_mod *, int); static void -d_print_mod PARAMS ((struct d_print_info *, - const struct demangle_component *)); +d_print_mod (struct d_print_info *, const struct demangle_component *); static void -d_print_function_type PARAMS ((struct d_print_info *, - const struct demangle_component *, - struct d_print_mod *)); +d_print_function_type (struct d_print_info *, + const struct demangle_component *, + struct d_print_mod *); static void -d_print_array_type PARAMS ((struct d_print_info *, - const struct demangle_component *, - struct d_print_mod *)); +d_print_array_type (struct d_print_info *, + const struct demangle_component *, + struct d_print_mod *); static void -d_print_expr_op PARAMS ((struct d_print_info *, - const struct demangle_component *)); +d_print_expr_op (struct d_print_info *, const struct demangle_component *); static void -d_print_cast PARAMS ((struct d_print_info *, - const struct demangle_component *)); +d_print_cast (struct d_print_info *, const struct demangle_component *); -static char * -d_demangle PARAMS ((const char *, int, size_t *)); +static 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 demangle_component *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 (' '); @@ -555,6 +574,9 @@ d_dump (dc, indent) case DEMANGLE_COMPONENT_REFTEMP: printf ("reference temporary\n"); break; + case DEMANGLE_COMPONENT_HIDDEN_ALIAS: + printf ("hidden alias\n"); + break; case DEMANGLE_COMPONENT_RESTRICT: printf ("restrict\n"); break; @@ -582,6 +604,9 @@ d_dump (dc, indent) case DEMANGLE_COMPONENT_REFERENCE: printf ("reference\n"); break; + case DEMANGLE_COMPONENT_RVALUE_REFERENCE: + printf ("rvalue reference\n"); + break; case DEMANGLE_COMPONENT_COMPLEX: printf ("complex\n"); break; @@ -600,6 +625,9 @@ d_dump (dc, indent) case DEMANGLE_COMPONENT_PTRMEM_TYPE: printf ("pointer to member type\n"); break; + case DEMANGLE_COMPONENT_FIXED_TYPE: + printf ("fixed-point type\n"); + break; case DEMANGLE_COMPONENT_ARGLIST: printf ("argument list\n"); break; @@ -633,6 +661,21 @@ d_dump (dc, indent) 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_DECLTYPE: + printf ("decltype\n"); + break; + case DEMANGLE_COMPONENT_PACK_EXPANSION: + printf ("pack expansion\n"); + break; } d_dump (d_left (dc), indent + 2); @@ -645,10 +688,7 @@ d_dump (dc, indent) CP_STATIC_IF_GLIBCPP_V3 int -cplus_demangle_fill_name (p, s, len) - struct demangle_component *p; - const char *s; - int len; +cplus_demangle_fill_name (struct demangle_component *p, const char *s, int len) { if (p == NULL || s == NULL || len == 0) return 0; @@ -662,10 +702,8 @@ cplus_demangle_fill_name (p, s, len) CP_STATIC_IF_GLIBCPP_V3 int -cplus_demangle_fill_extended_operator (p, args, name) - struct demangle_component *p; - int args; - struct demangle_component *name; +cplus_demangle_fill_extended_operator (struct demangle_component *p, int args, + struct demangle_component *name) { if (p == NULL || args < 0 || name == NULL) return 0; @@ -679,15 +717,14 @@ cplus_demangle_fill_extended_operator (p, args, name) CP_STATIC_IF_GLIBCPP_V3 int -cplus_demangle_fill_ctor (p, kind, name) - struct demangle_component *p; - enum gnu_v3_ctor_kinds kind; - struct demangle_component *name; +cplus_demangle_fill_ctor (struct demangle_component *p, + enum gnu_v3_ctor_kinds kind, + struct demangle_component *name) { if (p == NULL || name == NULL - || (kind < gnu_v3_complete_object_ctor - && kind > gnu_v3_complete_object_allocating_ctor)) + || (int) kind < gnu_v3_complete_object_ctor + || (int) kind > gnu_v3_complete_object_allocating_ctor) return 0; p->type = DEMANGLE_COMPONENT_CTOR; p->u.s_ctor.kind = kind; @@ -699,15 +736,14 @@ cplus_demangle_fill_ctor (p, kind, name) CP_STATIC_IF_GLIBCPP_V3 int -cplus_demangle_fill_dtor (p, kind, name) - struct demangle_component *p; - enum gnu_v3_dtor_kinds kind; - struct demangle_component *name; +cplus_demangle_fill_dtor (struct demangle_component *p, + enum gnu_v3_dtor_kinds kind, + struct demangle_component *name) { if (p == NULL || name == NULL - || (kind < gnu_v3_deleting_dtor - && kind > gnu_v3_base_object_dtor)) + || (int) kind < gnu_v3_deleting_dtor + || (int) kind > gnu_v3_base_object_dtor) return 0; p->type = DEMANGLE_COMPONENT_DTOR; p->u.s_dtor.kind = kind; @@ -718,8 +754,7 @@ cplus_demangle_fill_dtor (p, kind, name) /* Add a new component. */ static struct demangle_component * -d_make_empty (di) - struct d_info *di; +d_make_empty (struct d_info *di) { struct demangle_component *p; @@ -733,11 +768,9 @@ d_make_empty (di) /* Add a new generic component. */ static struct demangle_component * -d_make_comp (di, type, left, right) - struct d_info *di; - enum demangle_component_type type; - struct demangle_component *left; - struct demangle_component *right; +d_make_comp (struct d_info *di, enum demangle_component_type type, + struct demangle_component *left, + struct demangle_component *right) { struct demangle_component *p; @@ -762,6 +795,7 @@ d_make_comp (di, type, left, right) case DEMANGLE_COMPONENT_TRINARY_ARG2: case DEMANGLE_COMPONENT_LITERAL: case DEMANGLE_COMPONENT_LITERAL_NEG: + case DEMANGLE_COMPONENT_COMPOUND_NAME: if (left == NULL || right == NULL) return NULL; break; @@ -778,14 +812,19 @@ d_make_comp (di, type, left, right) case DEMANGLE_COMPONENT_JAVA_CLASS: case DEMANGLE_COMPONENT_GUARD: case DEMANGLE_COMPONENT_REFTEMP: + case DEMANGLE_COMPONENT_HIDDEN_ALIAS: case DEMANGLE_COMPONENT_POINTER: case DEMANGLE_COMPONENT_REFERENCE: + case DEMANGLE_COMPONENT_RVALUE_REFERENCE: case DEMANGLE_COMPONENT_COMPLEX: case DEMANGLE_COMPONENT_IMAGINARY: case DEMANGLE_COMPONENT_VENDOR_TYPE: - case DEMANGLE_COMPONENT_ARGLIST: - case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST: case DEMANGLE_COMPONENT_CAST: + case DEMANGLE_COMPONENT_JAVA_RESOURCE: + case DEMANGLE_COMPONENT_DECLTYPE: + case DEMANGLE_COMPONENT_PACK_EXPANSION: + case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS: + case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS: if (left == NULL) return NULL; break; @@ -806,6 +845,8 @@ d_make_comp (di, type, left, right) case DEMANGLE_COMPONENT_RESTRICT_THIS: case DEMANGLE_COMPONENT_VOLATILE_THIS: case DEMANGLE_COMPONENT_CONST_THIS: + case DEMANGLE_COMPONENT_ARGLIST: + case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST: break; /* Other types should not be seen here. */ @@ -826,10 +867,7 @@ d_make_comp (di, type, left, right) /* Add a new name component. */ static struct demangle_component * -d_make_name (di, s, len) - struct d_info *di; - const char *s; - int len; +d_make_name (struct d_info *di, const char *s, int len) { struct demangle_component *p; @@ -842,9 +880,8 @@ d_make_name (di, s, len) /* Add a new builtin type component. */ static struct demangle_component * -d_make_builtin_type (di, type) - struct d_info *di; - const struct demangle_builtin_type_info *type; +d_make_builtin_type (struct d_info *di, + const struct demangle_builtin_type_info *type) { struct demangle_component *p; @@ -862,9 +899,7 @@ d_make_builtin_type (di, type) /* Add a new operator component. */ static struct demangle_component * -d_make_operator (di, op) - struct d_info *di; - const struct demangle_operator_info *op; +d_make_operator (struct d_info *di, const struct demangle_operator_info *op) { struct demangle_component *p; @@ -880,10 +915,8 @@ d_make_operator (di, op) /* Add a new extended operator component. */ static struct demangle_component * -d_make_extended_operator (di, args, name) - struct d_info *di; - int args; - struct demangle_component *name; +d_make_extended_operator (struct d_info *di, int args, + struct demangle_component *name) { struct demangle_component *p; @@ -893,13 +926,25 @@ d_make_extended_operator (di, args, name) 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->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 demangle_component * -d_make_ctor (di, kind, name) - struct d_info *di; - enum gnu_v3_ctor_kinds kind; - struct demangle_component *name; +d_make_ctor (struct d_info *di, enum gnu_v3_ctor_kinds kind, + struct demangle_component *name) { struct demangle_component *p; @@ -912,10 +957,8 @@ d_make_ctor (di, kind, name) /* Add a new destructor component. */ static struct demangle_component * -d_make_dtor (di, kind, name) - struct d_info *di; - enum gnu_v3_dtor_kinds kind; - struct demangle_component *name; +d_make_dtor (struct d_info *di, enum gnu_v3_dtor_kinds kind, + struct demangle_component *name) { struct demangle_component *p; @@ -928,9 +971,7 @@ d_make_dtor (di, kind, name) /* Add a new template parameter. */ static struct demangle_component * -d_make_template_param (di, i) - struct d_info *di; - long i; +d_make_template_param (struct d_info *di, long i) { struct demangle_component *p; @@ -943,13 +984,26 @@ d_make_template_param (di, i) return p; } +/* Add a new function parameter. */ + +static struct demangle_component * +d_make_function_param (struct d_info *di, long i) +{ + struct demangle_component *p; + + p = d_make_empty (di); + if (p != NULL) + { + p->type = DEMANGLE_COMPONENT_FUNCTION_PARAM; + p->u.s_number.number = i; + } + return p; +} + /* Add a new standard substitution component. */ static struct demangle_component * -d_make_sub (di, name, len) - struct d_info *di; - const char *name; - int len; +d_make_sub (struct d_info *di, const char *name, int len) { struct demangle_component *p; @@ -969,13 +1023,15 @@ d_make_sub (di, name, len) CP_STATIC_IF_GLIBCPP_V3 struct demangle_component * -cplus_demangle_mangled_name (di, top_level) - struct d_info *di; - int top_level; +cplus_demangle_mangled_name (struct d_info *di, int top_level) { - if (d_next_char (di) != '_') + 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); } @@ -990,8 +1046,7 @@ cplus_demangle_mangled_name (di, top_level) return types. */ static int -has_return_type (dc) - struct demangle_component *dc; +has_return_type (struct demangle_component *dc) { if (dc == NULL) return 0; @@ -1012,8 +1067,7 @@ has_return_type (dc) conversion operator. */ static int -is_ctor_dtor_or_conversion (dc) - struct demangle_component *dc; +is_ctor_dtor_or_conversion (struct demangle_component *dc) { if (dc == NULL) return 0; @@ -1041,9 +1095,7 @@ is_ctor_dtor_or_conversion (dc) we would not correctly demangle names in local scopes. */ static struct demangle_component * -d_encoding (di, top_level) - struct d_info *di; - int top_level; +d_encoding (struct d_info *di, int top_level) { char peek = d_peek_char (di); @@ -1085,7 +1137,7 @@ d_encoding (di, top_level) } peek = d_peek_char (di); - if (peek == '\0' || peek == 'E') + if (dc == NULL || peek == '\0' || peek == 'E') return dc; return d_make_comp (di, DEMANGLE_COMPONENT_TYPED_NAME, dc, d_bare_function_type (di, has_return_type (dc))); @@ -1105,8 +1157,7 @@ d_encoding (di, top_level) */ static struct demangle_component * -d_name (di) - struct d_info *di; +d_name (struct d_info *di) { char peek = d_peek_char (di); struct demangle_component *dc; @@ -1119,6 +1170,10 @@ d_name (di) case 'Z': return d_local_name (di); + case 'L': + case 'U': + return d_unqualified_name (di); + case 'S': { int subst; @@ -1183,13 +1238,12 @@ d_name (di) */ static struct demangle_component * -d_nested_name (di) - struct d_info *di; +d_nested_name (struct d_info *di) { struct demangle_component *ret; struct demangle_component **pret; - if (d_next_char (di) != 'N') + if (! d_check_char (di, 'N')) return NULL; pret = d_cv_qualifiers (di, &ret, 1); @@ -1200,7 +1254,7 @@ d_nested_name (di) if (*pret == NULL) return NULL; - if (d_next_char (di) != 'E') + if (! d_check_char (di, 'E')) return NULL; return ret; @@ -1218,8 +1272,7 @@ d_nested_name (di) */ static struct demangle_component * -d_prefix (di) - struct d_info *di; +d_prefix (struct d_info *di) { struct demangle_component *ret = NULL; @@ -1241,7 +1294,9 @@ d_prefix (di) if (IS_DIGIT (peek) || IS_LOWER (peek) || peek == 'C' - || peek == 'D') + || peek == 'D' + || peek == 'U' + || peek == 'L') dc = d_unqualified_name (di); else if (peek == 'S') dc = d_substitution (di, 1); @@ -1256,6 +1311,16 @@ d_prefix (di) 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; @@ -1275,11 +1340,13 @@ d_prefix (di) /* ::= ::= ::= + ::= + + ::= L */ static struct demangle_component * -d_unqualified_name (di) - struct d_info *di; +d_unqualified_name (struct d_info *di) { char peek; @@ -1297,6 +1364,31 @@ d_unqualified_name (di) } else if (peek == 'C' || peek == 'D') return d_ctor_dtor_name (di); + else if (peek == 'L') + { + struct demangle_component * ret; + + d_advance (di, 1); + + ret = d_source_name (di); + if (ret == NULL) + return NULL; + if (! d_discriminator (di)) + return NULL; + return ret; + } + else if (peek == 'U') + { + switch (d_peek_next_char (di)) + { + case 'l': + return d_lambda (di); + case 't': + return d_unnamed_type (di); + default: + return NULL; + } + } else return NULL; } @@ -1304,8 +1396,7 @@ d_unqualified_name (di) /* ::= <(positive length) number> */ static struct demangle_component * -d_source_name (di) - struct d_info *di; +d_source_name (struct d_info *di) { long len; struct demangle_component *ret; @@ -1321,8 +1412,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; @@ -1355,9 +1445,7 @@ d_number (di) /* identifier ::= <(unqualified source code identifier)> */ static struct demangle_component * -d_identifier (di, len) - struct d_info *di; - int len; +d_identifier (struct d_info *di, int len) { const char *name; @@ -1412,13 +1500,14 @@ const struct demangle_operator_info cplus_demangle_operators[] = { "aa", NL ("&&"), 2 }, { "ad", NL ("&"), 1 }, { "an", NL ("&"), 2 }, - { "cl", NL ("()"), 0 }, + { "cl", NL ("()"), 2 }, { "cm", NL (","), 2 }, { "co", NL ("~"), 1 }, { "dV", NL ("/="), 2 }, { "da", NL ("delete[]"), 1 }, { "de", NL ("*"), 1 }, { "dl", NL ("delete"), 1 }, + { "dt", NL ("."), 2 }, { "dv", NL ("/"), 2 }, { "eO", NL ("^="), 2 }, { "eo", NL ("^"), 2 }, @@ -1456,12 +1545,13 @@ const struct demangle_operator_info cplus_demangle_operators[] = { "rs", NL (">>"), 2 }, { "st", NL ("sizeof "), 1 }, { "sz", NL ("sizeof "), 1 }, + { "at", NL ("alignof "), 1 }, + { "az", NL ("alignof "), 1 }, { NULL, NULL, 0, 0 } }; static struct demangle_component * -d_operator_name (di) - struct d_info *di; +d_operator_name (struct d_info *di) { char c1; char c2; @@ -1504,6 +1594,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 @@ -1516,17 +1702,15 @@ d_operator_name (di) ::= TF ::= TJ ::= GR + ::= GA + ::= Gr */ static struct demangle_component * -d_special_name (di) - struct d_info *di; +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)) { @@ -1575,7 +1759,7 @@ d_special_name (di) offset = d_number (di); if (offset < 0) return NULL; - if (d_next_char (di) != '_') + if (! d_check_char (di, '_')) return NULL; base_type = cplus_demangle_type (di); /* We don't display the offset. FIXME: We should display @@ -1596,7 +1780,7 @@ d_special_name (di) return NULL; } } - else if (c == 'G') + else if (d_check_char (di, 'G')) { switch (d_next_char (di)) { @@ -1607,6 +1791,13 @@ d_special_name (di) return d_make_comp (di, DEMANGLE_COMPONENT_REFTEMP, d_name (di), NULL); + case 'A': + return d_make_comp (di, DEMANGLE_COMPONENT_HIDDEN_ALIAS, + d_encoding (di, 0), NULL); + + case 'r': + return d_java_resource (di); + default: return NULL; } @@ -1629,29 +1820,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; @@ -1666,8 +1852,7 @@ d_call_offset (di, c) */ static struct demangle_component * -d_ctor_dtor_name (di) - struct d_info *di; +d_ctor_dtor_name (struct d_info *di) { if (di->last_name != NULL) { @@ -1676,13 +1861,13 @@ d_ctor_dtor_name (di) 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; @@ -1696,6 +1881,7 @@ d_ctor_dtor_name (di) default: return NULL; } + d_advance (di, 2); return d_make_ctor (di, kind, di->last_name); } @@ -1703,7 +1889,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; @@ -1717,6 +1903,7 @@ d_ctor_dtor_name (di) default: return NULL; } + d_advance (di, 2); return d_make_dtor (di, kind, di->last_name); } @@ -1736,6 +1923,7 @@ d_ctor_dtor_name (di) ::= ::= P ::= R + ::= O (C++0x) ::= C ::= G ::= U @@ -1776,12 +1964,17 @@ cplus_demangle_builtin_types[D_BUILTIN_TYPE_COUNT] = /* 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 }, }; CP_STATIC_IF_GLIBCPP_V3 struct demangle_component * -cplus_demangle_type (di) - struct d_info *di; +cplus_demangle_type (struct d_info *di) { char peek; struct demangle_component *ret; @@ -1811,7 +2004,7 @@ cplus_demangle_type (di) if (pret == NULL) return NULL; *pret = cplus_demangle_type (di); - if (! d_add_substitution (di, ret)) + if (! *pret || ! d_add_substitution (di, ret)) return NULL; return ret; } @@ -1903,6 +2096,12 @@ cplus_demangle_type (di) } 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, DEMANGLE_COMPONENT_POINTER, @@ -1912,7 +2111,7 @@ cplus_demangle_type (di) case 'R': d_advance (di, 1); ret = d_make_comp (di, DEMANGLE_COMPONENT_REFERENCE, - cplus_demangle_type (di), NULL); + cplus_demangle_type (di), NULL); break; case 'C': @@ -1934,6 +2133,76 @@ cplus_demangle_type (di) 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; + break; + + case 'p': + /* Pack expansion. */ + ret = d_make_comp (di, DEMANGLE_COMPONENT_PACK_EXPANSION, + cplus_demangle_type (di), NULL); + 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); + d_number (di); + peek = d_next_char (di); + ret->u.s_fixed.sat = (peek == 's'); + break; + + default: + return NULL; + } + break; + default: return NULL; } @@ -1950,10 +2219,8 @@ cplus_demangle_type (di) /* ::= [r] [V] [K] */ static struct demangle_component ** -d_cv_qualifiers (di, pret, member_fn) - struct d_info *di; - struct demangle_component **pret; - int member_fn; +d_cv_qualifiers (struct d_info *di, + struct demangle_component **pret, int member_fn) { char peek; @@ -1999,12 +2266,11 @@ d_cv_qualifiers (di, pret, member_fn) /* ::= F [Y] E */ static struct demangle_component * -d_function_type (di) - struct d_info *di; +d_function_type (struct d_info *di) { struct demangle_component *ret; - if (d_next_char (di) != 'F') + if (! d_check_char (di, 'F')) return NULL; if (d_peek_char (di) == 'Y') { @@ -2013,48 +2279,35 @@ d_function_type (di) d_advance (di, 1); } ret = d_bare_function_type (di, 1); - if (d_next_char (di) != 'E') + if (! d_check_char (di, 'E')) return NULL; return ret; } -/* ::= + */ +/* + */ static struct demangle_component * -d_bare_function_type (di, has_return_type) - struct d_info *di; - int has_return_type; +d_parmlist (struct d_info *di) { - struct demangle_component *return_type; struct demangle_component *tl; struct demangle_component **ptl; - return_type = NULL; tl = NULL; ptl = &tl; while (1) { - char peek; struct demangle_component *type; - peek = d_peek_char (di); + char peek = d_peek_char (di); if (peek == '\0' || peek == 'E') break; 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, DEMANGLE_COMPONENT_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 @@ -2069,17 +2322,51 @@ d_bare_function_type (di, has_return_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 tl; +} + +/* ::= [J]+ */ + +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; + + /* Detect special qualifier indicating that the first argument + is the return type. */ + peek = d_peek_char (di); + if (peek == 'J') + { + 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; - return d_make_comp (di, DEMANGLE_COMPONENT_FUNCTION_TYPE, return_type, tl); + 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 (di) - struct d_info *di; +d_class_enum_type (struct d_info *di) { return d_name (di); } @@ -2089,13 +2376,12 @@ d_class_enum_type (di) */ static struct demangle_component * -d_array_type (di) - struct d_info *di; +d_array_type (struct d_info *di) { char peek; struct demangle_component *dim; - if (d_next_char (di) != 'A') + if (! d_check_char (di, 'A')) return NULL; peek = d_peek_char (di); @@ -2123,7 +2409,7 @@ 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, @@ -2133,14 +2419,13 @@ d_array_type (di) /* ::= M <(class) type> <(member) type> */ static struct demangle_component * -d_pointer_to_member_type (di) - struct d_info *di; +d_pointer_to_member_type (struct d_info *di) { struct demangle_component *cl; struct demangle_component *mem; struct demangle_component **pmem; - if (d_next_char (di) != 'M') + if (! d_check_char (di, 'M')) return NULL; cl = cplus_demangle_type (di); @@ -2156,40 +2441,59 @@ d_pointer_to_member_type (di) g++ does not work that way. g++ treats only the CV-qualified member function as a substitution source. FIXME. So to work with g++, we need to pull off the CV-qualifiers here, in order to - avoid calling add_substitution() in cplus_demangle_type(). */ + avoid calling add_substitution() in cplus_demangle_type(). But + for a CV-qualified member which is not a function, g++ does + follow the ABI, so we need to handle that case here by calling + d_add_substitution ourselves. */ pmem = d_cv_qualifiers (di, &mem, 1); if (pmem == NULL) return NULL; *pmem = cplus_demangle_type (di); + if (*pmem == NULL) + return NULL; + + if (pmem != &mem && (*pmem)->type != DEMANGLE_COMPONENT_FUNCTION_TYPE) + { + if (! d_add_substitution (di, mem)) + return NULL; + } 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 demangle_component * -d_template_param (di) - struct d_info *di; +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; @@ -2200,8 +2504,7 @@ d_template_param (di) /* ::= I + E */ static struct demangle_component * -d_template_args (di) - struct d_info *di; +d_template_args (struct d_info *di) { struct demangle_component *hold_last_name; struct demangle_component *al; @@ -2212,9 +2515,16 @@ d_template_args (di) constructor or destructor. */ hold_last_name = di->last_name; - if (d_next_char (di) != 'I') + if (! d_check_char (di, 'I')) return NULL; + 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) @@ -2248,8 +2558,7 @@ d_template_args (di) */ static struct demangle_component * -d_template_arg (di) - struct d_info *di; +d_template_arg (struct d_info *di) { struct demangle_component *ret; @@ -2258,21 +2567,61 @@ d_template_arg (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': + /* An argument pack. */ + return d_template_args (di); + default: return cplus_demangle_type (di); } } +/* Subroutine of ::= cl + E */ + +static struct demangle_component * +d_exprlist (struct d_info *di) +{ + struct demangle_component *list = NULL; + struct demangle_component **p = &list; + + if (d_peek_char (di) == 'E') + { + 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) == 'E') + { + d_advance (di, 1); + break; + } + } + + return list; +} + /* ::= <(unary) operator-name> ::= <(binary) operator-name> ::= <(trinary) operator-name> + ::= cl + E ::= st ::= ::= sr @@ -2281,8 +2630,7 @@ d_template_arg (di) */ static struct demangle_component * -d_expression (di) - struct d_info *di; +d_expression (struct d_info *di) { char peek; @@ -2306,6 +2654,36 @@ d_expression (di) 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 (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); + index = d_compact_number (di); + if (index < 0) + return NULL; + + return d_make_function_param (di, index); + } + else if (IS_DIGIT (peek)) + { + /* We can get an unqualified name as an expression in the case of + a dependent member access, i.e. decltype(T().i). */ + struct demangle_component *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 { struct demangle_component *op; @@ -2341,18 +2719,31 @@ d_expression (di) switch (args) { case 1: - return d_make_comp (di, DEMANGLE_COMPONENT_UNARY, op, - d_expression (di)); + { + struct demangle_component *operand; + if (op->type == DEMANGLE_COMPONENT_CAST + && d_check_char (di, '_')) + operand = d_exprlist (di); + else + operand = d_expression (di); + return d_make_comp (di, DEMANGLE_COMPONENT_UNARY, op, + operand); + } case 2: { struct demangle_component *left; + struct demangle_component *right; left = d_expression (di); + if (!strcmp (op->u.s_operator.op->code, "cl")) + right = d_exprlist (di); + else + right = d_expression (di); + return d_make_comp (di, DEMANGLE_COMPONENT_BINARY, op, d_make_comp (di, DEMANGLE_COMPONENT_BINARY_ARGS, - left, - d_expression (di))); + left, right)); } case 3: { @@ -2382,14 +2773,15 @@ d_expression (di) */ static struct demangle_component * -d_expr_primary (di) - struct d_info *di; +d_expr_primary (struct d_info *di) { struct demangle_component *ret; - if (d_next_char (di) != 'L') + if (! d_check_char (di, 'L')) return NULL; - if (d_peek_char (di) == '_') + 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 { @@ -2398,6 +2790,8 @@ d_expr_primary (di) const char *s; type = cplus_demangle_type (di); + if (type == NULL) + return NULL; /* If we have a type we know how to print, we aren't going to print the type name itself. */ @@ -2424,10 +2818,14 @@ d_expr_primary (di) } 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; } @@ -2437,17 +2835,16 @@ d_expr_primary (di) */ static struct demangle_component * -d_local_name (di) - struct d_info *di; +d_local_name (struct d_info *di) { 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') @@ -2462,10 +2859,31 @@ d_local_name (di) else { 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; + 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); } } @@ -2476,8 +2894,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; @@ -2490,12 +2907,79 @@ 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; +} + /* Add a new substitution. */ static int -d_add_substitution (di, dc) - struct d_info *di; - struct demangle_component *dc; +d_add_substitution (struct d_info *di, struct demangle_component *dc) { if (dc == NULL) return 0; @@ -2551,31 +3035,34 @@ static const struct d_standard_sub_info standard_subs[] = }; static struct demangle_component * -d_substitution (di, prefix) - struct d_info *di; - int prefix; +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 != '_'); @@ -2583,7 +3070,7 @@ d_substitution (di, prefix) ++id; } - if (id >= di->next_sub) + if (id >= (unsigned int) di->next_sub) return NULL; ++di->did_subs; @@ -2637,88 +3124,189 @@ d_substitution (di, prefix) } } -/* Resize the print buffer. */ +/* Initialize a growable string. */ static void -d_print_resize (dpi, add) - struct d_print_info *dpi; - size_t add; +d_growable_string_init (struct d_growable_string *dgs, size_t estimate) { - size_t need; + dgs->buf = NULL; + dgs->len = 0; + dgs->alc = 0; + dgs->allocation_failure = 0; + + if (estimate > 0) + d_growable_string_resize (dgs, estimate); +} + +/* Grow a growable string to a given size. */ - if (dpi->buf == NULL) +static inline void +d_growable_string_resize (struct d_growable_string *dgs, size_t need) +{ + size_t newalc; + char *newbuf; + + if (dgs->allocation_failure) return; - need = dpi->len + add; - while (need > dpi->alc) - { - size_t newalc; - char *newbuf; - 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; + /* 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; } -/* Append a character to the print buffer. */ +/* Append a buffer to a growable string. */ -static void -d_print_append_char (dpi, c) - struct d_print_info *dpi; - int c; +static inline void +d_growable_string_append_buffer (struct d_growable_string *dgs, + const char *s, size_t l) { - if (dpi->buf != NULL) - { - if (dpi->len >= dpi->alc) - { - d_print_resize (dpi, 1); - if (dpi->buf == NULL) - return; - } + size_t need; - dpi->buf[dpi->len] = c; - ++dpi->len; - } + 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; } -/* Append a buffer to the print buffer. */ +/* Bridge growable strings to the callback mechanism. */ static void -d_print_append_buffer (dpi, s, l) - struct d_print_info *dpi; - const char *s; - size_t l; +d_growable_string_callback_adapter (const char *s, size_t l, void *opaque) { - if (dpi->buf != NULL) - { - if (dpi->len + l > dpi->alc) - { - d_print_resize (dpi, l); - if (dpi->buf == NULL) - return; - } + struct d_growable_string *dgs = (struct d_growable_string*) opaque; - memcpy (dpi->buf + dpi->len, s, l); - dpi->len += l; - } + d_growable_string_append_buffer (dgs, s, l); } -/* Indicate that an error occurred during printing. */ +/* Initialize a print information structure. */ static void -d_print_error (dpi) - struct d_print_info *dpi; +d_print_init (struct d_print_info *dpi, int options, + demangle_callbackref callback, void *opaque) +{ + dpi->options = options; + dpi->len = 0; + dpi->last_char = '\0'; + dpi->templates = NULL; + dpi->modifiers = NULL; + + dpi->callback = callback; + dpi->opaque = opaque; + + dpi->demangle_failure = 0; +} + +/* 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; +} + +/* 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) { - free (dpi->buf); - dpi->buf = NULL; + 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, options, callback, opaque); + + d_print_comp (&dpi, dc); + + d_print_flush (&dpi); + + return ! d_print_saw_error (&dpi); } /* Turn components into a human readable string. OPTIONS is the @@ -2731,48 +3319,150 @@ d_print_error (dpi) CP_STATIC_IF_GLIBCPP_V3 char * -cplus_demangle_print (options, dc, estimate, palc) - int options; - const struct demangle_component *dc; - int estimate; - size_t *palc; +cplus_demangle_print (int options, const struct demangle_component *dc, + int estimate, size_t *palc) { - struct d_print_info dpi; + 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; + + 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; - d_append_char (&dpi, '\0'); + return d_left (a); +} - if (dpi.buf != NULL) - *palc = dpi.alc; - else - *palc = dpi.allocation_failure; +/* 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_NAME: + case DEMANGLE_COMPONENT_OPERATOR: + case DEMANGLE_COMPONENT_BUILTIN_TYPE: + case DEMANGLE_COMPONENT_SUB_STD: + case DEMANGLE_COMPONENT_CHARACTER: + case DEMANGLE_COMPONENT_FUNCTION_PARAM: + 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. */ - return dpi.buf; +static void +d_print_subexpr (struct d_print_info *dpi, + const struct demangle_component *dc) +{ + int simple = 0; + if (dc->type == DEMANGLE_COMPONENT_NAME + || dc->type == DEMANGLE_COMPONENT_FUNCTION_PARAM) + simple = 1; + if (!simple) + d_append_char (dpi, '('); + d_print_comp (dpi, dc); + if (!simple) + d_append_char (dpi, ')'); } /* Subroutine to handle components. */ static void -d_print_comp (dpi, dc) - struct d_print_info *dpi; - const struct demangle_component *dc; +d_print_comp (struct d_print_info *dpi, + const struct demangle_component *dc) { if (dc == NULL) { @@ -2795,7 +3485,7 @@ d_print_comp (dpi, dc) case DEMANGLE_COMPONENT_LOCAL_NAME: d_print_comp (dpi, d_left (dc)); if ((dpi->options & DMGL_JAVA) == 0) - d_append_string_constant (dpi, "::"); + d_append_string (dpi, "::"); else d_append_char (dpi, '.'); d_print_comp (dpi, d_right (dc)); @@ -2813,6 +3503,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) @@ -2838,13 +3529,19 @@ d_print_comp (dpi, dc) 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 == DEMANGLE_COMPONENT_TEMPLATE) { dpt.next = dpi->templates; dpi->templates = &dpt; - dpt.template = typed_name; + dpt.template_decl = typed_name; } /* If typed_name is a DEMANGLE_COMPONENT_LOCAL_NAME, then @@ -2856,6 +3553,8 @@ d_print_comp (dpi, dc) struct demangle_component *local_name; local_name = d_right (typed_name); + 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) @@ -2904,6 +3603,7 @@ d_print_comp (dpi, dc) case DEMANGLE_COMPONENT_TEMPLATE: { struct d_print_mod *hold_dpm; + struct demangle_component *dcl; /* Don't push modifiers into a template definition. Doing so could give the wrong definition for a template argument. @@ -2912,16 +3612,32 @@ 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 ((dpi->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, d_right (dc)); + d_append_string (dpi, "[]"); + } + else + { + d_print_comp (dpi, dcl); + 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, '>'); + } dpi->modifiers = hold_dpm; @@ -2930,30 +3646,13 @@ d_print_comp (dpi, dc) case DEMANGLE_COMPONENT_TEMPLATE_PARAM: { - long i; - struct demangle_component *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 != DEMANGLE_COMPONENT_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; @@ -2967,7 +3666,7 @@ 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, a); dpi->templates = hold_dpt; @@ -2984,64 +3683,69 @@ d_print_comp (dpi, dc) return; case DEMANGLE_COMPONENT_VTABLE: - d_append_string_constant (dpi, "vtable for "); + d_append_string (dpi, "vtable for "); d_print_comp (dpi, d_left (dc)); return; case DEMANGLE_COMPONENT_VTT: - d_append_string_constant (dpi, "VTT for "); + d_append_string (dpi, "VTT for "); d_print_comp (dpi, d_left (dc)); return; case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE: - d_append_string_constant (dpi, "construction vtable for "); + d_append_string (dpi, "construction vtable for "); d_print_comp (dpi, d_left (dc)); - d_append_string_constant (dpi, "-in-"); + d_append_string (dpi, "-in-"); d_print_comp (dpi, d_right (dc)); return; case DEMANGLE_COMPONENT_TYPEINFO: - d_append_string_constant (dpi, "typeinfo for "); + d_append_string (dpi, "typeinfo for "); d_print_comp (dpi, d_left (dc)); return; case DEMANGLE_COMPONENT_TYPEINFO_NAME: - d_append_string_constant (dpi, "typeinfo name for "); + d_append_string (dpi, "typeinfo name for "); d_print_comp (dpi, d_left (dc)); return; case DEMANGLE_COMPONENT_TYPEINFO_FN: - d_append_string_constant (dpi, "typeinfo fn for "); + d_append_string (dpi, "typeinfo fn for "); d_print_comp (dpi, d_left (dc)); return; case DEMANGLE_COMPONENT_THUNK: - d_append_string_constant (dpi, "non-virtual thunk to "); + d_append_string (dpi, "non-virtual thunk to "); d_print_comp (dpi, d_left (dc)); return; case DEMANGLE_COMPONENT_VIRTUAL_THUNK: - d_append_string_constant (dpi, "virtual thunk to "); + d_append_string (dpi, "virtual thunk to "); d_print_comp (dpi, d_left (dc)); return; case DEMANGLE_COMPONENT_COVARIANT_THUNK: - d_append_string_constant (dpi, "covariant return thunk to "); + d_append_string (dpi, "covariant return thunk to "); d_print_comp (dpi, d_left (dc)); return; case DEMANGLE_COMPONENT_JAVA_CLASS: - d_append_string_constant (dpi, "java Class for "); + d_append_string (dpi, "java Class for "); d_print_comp (dpi, d_left (dc)); return; case DEMANGLE_COMPONENT_GUARD: - d_append_string_constant (dpi, "guard variable for "); + d_append_string (dpi, "guard variable for "); d_print_comp (dpi, d_left (dc)); return; case DEMANGLE_COMPONENT_REFTEMP: - d_append_string_constant (dpi, "reference temporary for "); + d_append_string (dpi, "reference temporary for "); + d_print_comp (dpi, d_left (dc)); + return; + + case DEMANGLE_COMPONENT_HIDDEN_ALIAS: + d_append_string (dpi, "hidden alias for "); d_print_comp (dpi, d_left (dc)); return; @@ -3082,6 +3786,7 @@ d_print_comp (dpi, dc) case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL: case DEMANGLE_COMPONENT_POINTER: case DEMANGLE_COMPONENT_REFERENCE: + case DEMANGLE_COMPONENT_RVALUE_REFERENCE: case DEMANGLE_COMPONENT_COMPLEX: case DEMANGLE_COMPONENT_IMAGINARY: { @@ -3121,13 +3826,16 @@ d_print_comp (dpi, dc) case DEMANGLE_COMPONENT_FUNCTION_TYPE: { + if ((dpi->options & DMGL_RET_POSTFIX) != 0) + d_print_function_type (dpi, dc, dpi->modifiers); + + /* Print return type if present */ if (d_left (dc) != NULL) { 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; @@ -3141,10 +3849,14 @@ d_print_comp (dpi, dc) 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 ((dpi->options & DMGL_RET_POSTFIX) == 0) + d_append_char (dpi, ' '); } - d_print_function_type (dpi, dc, dpi->modifiers); + if ((dpi->options & DMGL_RET_POSTFIX) == 0) + d_print_function_type (dpi, dc, dpi->modifiers); return; } @@ -3233,7 +3945,7 @@ d_print_comp (dpi, dc) { d_append_char (dpi, ' '); d_print_comp (dpi, d_left (dc)); - d_append_string_constant (dpi, "::*"); + d_append_string (dpi, "::*"); } dpi->modifiers = dpm.next; @@ -3241,13 +3953,36 @@ d_print_comp (dpi, dc) return; } + 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, 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: - d_print_comp (dpi, d_left (dc)); + if (d_left (dc) != NULL) + d_print_comp (dpi, d_left (dc)); if (d_right (dc) != NULL) { - d_append_string_constant (dpi, ", "); + size_t len; + d_append_string (dpi, ", "); + len = dpi->len; d_print_comp (dpi, d_right (dc)); + /* If that didn't print anything (which can happen with empty + template argument packs), remove the comma and space. */ + if (dpi->len == len) + dpi->len -= 2; } return; @@ -3255,7 +3990,7 @@ d_print_comp (dpi, dc) { char c; - d_append_string_constant (dpi, "operator"); + d_append_string (dpi, "operator"); c = dc->u.s_operator.op->name[0]; if (IS_LOWER (c)) d_append_char (dpi, ' '); @@ -3265,12 +4000,12 @@ d_print_comp (dpi, dc) } case DEMANGLE_COMPONENT_EXTENDED_OPERATOR: - d_append_string_constant (dpi, "operator "); + d_append_string (dpi, "operator "); d_print_comp (dpi, dc->u.s_extended_operator.name); return; case DEMANGLE_COMPONENT_CAST: - d_append_string_constant (dpi, "operator "); + d_append_string (dpi, "operator "); d_print_cast (dpi, dc); return; @@ -3283,9 +4018,7 @@ d_print_comp (dpi, dc) 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, ')'); + d_print_subexpr (dpi, d_right (dc)); return; case DEMANGLE_COMPONENT_BINARY: @@ -3303,13 +4036,10 @@ d_print_comp (dpi, dc) && d_left (dc)->u.s_operator.op->name[0] == '>') d_append_char (dpi, '('); - d_append_char (dpi, '('); - d_print_comp (dpi, d_left (d_right (dc))); - d_append_string_constant (dpi, ") "); - d_print_expr_op (dpi, d_left (dc)); - d_append_string_constant (dpi, " ("); - d_print_comp (dpi, d_right (d_right (dc))); - d_append_char (dpi, ')'); + d_print_subexpr (dpi, d_left (d_right (dc))); + if (strcmp (d_left (dc)->u.s_operator.op->code, "cl") != 0) + d_print_expr_op (dpi, d_left (dc)); + d_print_subexpr (dpi, d_right (d_right (dc))); if (d_left (dc)->type == DEMANGLE_COMPONENT_OPERATOR && d_left (dc)->u.s_operator.op->len == 1 @@ -3330,15 +4060,11 @@ d_print_comp (dpi, dc) 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_subexpr (dpi, d_left (d_right (dc))); 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, ')'); + d_print_subexpr (dpi, d_left (d_right (d_right (dc)))); + d_append_string (dpi, " : "); + d_print_subexpr (dpi, d_right (d_right (d_right (dc)))); return; case DEMANGLE_COMPONENT_TRINARY_ARG1: @@ -3381,13 +4107,13 @@ d_print_comp (dpi, dc) d_append_char (dpi, 'l'); break; case D_PRINT_UNSIGNED_LONG: - d_append_string_constant (dpi, "ul"); + d_append_string (dpi, "ul"); break; case D_PRINT_LONG_LONG: - d_append_string_constant (dpi, "ll"); + d_append_string (dpi, "ll"); break; case D_PRINT_UNSIGNED_LONG_LONG: - d_append_string_constant (dpi, "ull"); + d_append_string (dpi, "ull"); break; } return; @@ -3402,10 +4128,10 @@ d_print_comp (dpi, dc) switch (d_right (dc)->u.s_name.s[0]) { case '0': - d_append_string_constant (dpi, "false"); + d_append_string (dpi, "false"); return; case '1': - d_append_string_constant (dpi, "true"); + d_append_string (dpi, "true"); return; default: break; @@ -3431,6 +4157,83 @@ d_print_comp (dpi, dc) } return; + case DEMANGLE_COMPONENT_JAVA_RESOURCE: + d_append_string (dpi, "java resource "); + d_print_comp (dpi, d_left (dc)); + return; + + case DEMANGLE_COMPONENT_COMPOUND_NAME: + d_print_comp (dpi, d_left (dc)); + d_print_comp (dpi, d_right (dc)); + return; + + case DEMANGLE_COMPONENT_CHARACTER: + d_append_char (dpi, dc->u.s_character.character); + return; + + case DEMANGLE_COMPONENT_DECLTYPE: + d_append_string (dpi, "decltype ("); + d_print_comp (dpi, d_left (dc)); + d_append_char (dpi, ')'); + return; + + 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, 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, dc); + if (i < len-1) + d_append_string (dpi, ", "); + } + } + return; + + case DEMANGLE_COMPONENT_FUNCTION_PARAM: + d_append_string (dpi, "{parm#"); + d_append_num (dpi, dc->u.s_number.number + 1); + d_append_char (dpi, '}'); + return; + + case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS: + d_append_string (dpi, "global constructors keyed to "); + d_print_comp (dpi, dc->u.s_binary.left); + return; + + case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS: + d_append_string (dpi, "global destructors keyed to "); + d_print_comp (dpi, dc->u.s_binary.left); + return; + + case DEMANGLE_COMPONENT_LAMBDA: + d_append_string (dpi, "{lambda("); + d_print_comp (dpi, 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; + + 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; + default: d_print_error (dpi); return; @@ -3443,10 +4246,7 @@ d_print_comp (dpi, dc) __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; @@ -3496,10 +4296,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, + struct d_print_mod *mods, int suffix) { struct d_print_template *hold_dpt; @@ -3549,11 +4347,20 @@ d_print_mod_list (dpi, mods, suffix) dpi->modifiers = hold_modifiers; if ((dpi->options & DMGL_JAVA) == 0) - d_append_string_constant (dpi, "::"); + d_append_string (dpi, "::"); else d_append_char (dpi, '.'); dc = d_right (mods->mod); + + 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) @@ -3575,23 +4382,22 @@ d_print_mod_list (dpi, mods, suffix) /* Print a modifier. */ static void -d_print_mod (dpi, mod) - struct d_print_info *dpi; - const struct demangle_component *mod; +d_print_mod (struct d_print_info *dpi, + const struct demangle_component *mod) { switch (mod->type) { case DEMANGLE_COMPONENT_RESTRICT: case DEMANGLE_COMPONENT_RESTRICT_THIS: - d_append_string_constant (dpi, " restrict"); + d_append_string (dpi, " restrict"); return; case DEMANGLE_COMPONENT_VOLATILE: case DEMANGLE_COMPONENT_VOLATILE_THIS: - d_append_string_constant (dpi, " volatile"); + d_append_string (dpi, " volatile"); return; case DEMANGLE_COMPONENT_CONST: case DEMANGLE_COMPONENT_CONST_THIS: - d_append_string_constant (dpi, " const"); + d_append_string (dpi, " const"); return; case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL: d_append_char (dpi, ' '); @@ -3605,17 +4411,20 @@ d_print_mod (dpi, mod) case DEMANGLE_COMPONENT_REFERENCE: d_append_char (dpi, '&'); return; + case DEMANGLE_COMPONENT_RVALUE_REFERENCE: + d_append_string (dpi, "&&"); + return; case DEMANGLE_COMPONENT_COMPLEX: - d_append_string_constant (dpi, "complex "); + d_append_string (dpi, "complex "); return; case DEMANGLE_COMPONENT_IMAGINARY: - d_append_string_constant (dpi, "imaginary "); + d_append_string (dpi, "imaginary "); return; 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_append_string (dpi, "::*"); return; case DEMANGLE_COMPONENT_TYPED_NAME: d_print_comp (dpi, d_left (mod)); @@ -3631,10 +4440,9 @@ 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 demangle_component *dc; - struct d_print_mod *mods; +d_print_function_type (struct d_print_info *dpi, + const struct demangle_component *dc, + struct d_print_mod *mods) { int need_paren; int saw_mod; @@ -3655,6 +4463,7 @@ d_print_function_type (dpi, dc, mods) { case DEMANGLE_COMPONENT_POINTER: case DEMANGLE_COMPONENT_REFERENCE: + case DEMANGLE_COMPONENT_RVALUE_REFERENCE: need_paren = 1; break; case DEMANGLE_COMPONENT_RESTRICT: @@ -3717,10 +4526,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 demangle_component *dc; - struct d_print_mod *mods; +d_print_array_type (struct d_print_info *dpi, + const struct demangle_component *dc, + struct d_print_mod *mods) { int need_space; @@ -3750,7 +4558,7 @@ d_print_array_type (dpi, dc, mods) } if (need_paren) - d_append_string_constant (dpi, " ("); + d_append_string (dpi, " ("); d_print_mod_list (dpi, mods, 0); @@ -3772,9 +4580,8 @@ 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 demangle_component *dc; +d_print_expr_op (struct d_print_info *dpi, + const struct demangle_component *dc) { if (dc->type == DEMANGLE_COMPONENT_OPERATOR) d_append_buffer (dpi, dc->u.s_operator.op->name, @@ -3786,9 +4593,8 @@ d_print_expr_op (dpi, dc) /* Print a cast. */ static void -d_print_cast (dpi, dc) - struct d_print_info *dpi; - const struct demangle_component *dc; +d_print_cast (struct d_print_info *dpi, + const struct demangle_component *dc) { if (d_left (dc)->type != DEMANGLE_COMPONENT_TEMPLATE) d_print_comp (dpi, d_left (dc)); @@ -3807,7 +4613,7 @@ d_print_cast (dpi, dc) dpt.next = dpi->templates; dpi->templates = &dpt; - dpt.template = d_left (dc); + dpt.template_decl = d_left (dc); d_print_comp (dpi, d_left (d_left (dc))); @@ -3832,11 +4638,8 @@ d_print_cast (dpi, dc) CP_STATIC_IF_GLIBCPP_V3 void -cplus_demangle_init_info (mangled, options, len, di) - const char *mangled; - int options; - size_t len; - struct d_info *di; +cplus_demangle_init_info (const char *mangled, int options, size_t len, + struct d_info *di) { di->s = mangled; di->send = mangled + len; @@ -3861,88 +4664,75 @@ cplus_demangle_init_info (mangled, options, len, di) di->expansion = 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 demangle_component *dc; - int estimate; - char *ret; - - *palc = 0; - - len = strlen (mangled); + 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; } - cplus_demangle_init_info (mangled, options, len, &di); + cplus_demangle_init_info (mangled, options, strlen (mangled), &di); { #ifdef CP_DYNAMIC_ARRAYS __extension__ struct demangle_component comps[di.num_comps]; __extension__ struct demangle_component *subs[di.num_subs]; - di.comps = &comps[0]; - di.subs = &subs[0]; + di.comps = comps; + di.subs = subs; #else - di.comps = ((struct demangle_component *) - malloc (di.num_comps * sizeof (struct demangle_component))); - di.subs = ((struct demangle_component **) - malloc (di.num_subs * sizeof (struct demangle_component *))); - if (di.comps == NULL || di.subs == NULL) - { - if (di.comps != NULL) - free (di.comps); - if (di.subs != NULL) - free (di.subs); - *palc = 1; - return NULL; - } + di.comps = alloca (di.num_comps * sizeof (*di.comps)); + di.subs = alloca (di.num_subs * sizeof (*di.subs)); #endif - if (! type) - dc = cplus_demangle_mangled_name (&di, 1); - else - dc = cplus_demangle_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_name (&di, d_str (&di), strlen (d_str (&di))), + NULL); + d_advance (&di, strlen (d_str (&di))); + break; + } /* If DMGL_PARAMS is set, then if we didn't consume the entire mangled string, then we didn't successfully demangle it. If @@ -3952,51 +4742,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; + } - ret = NULL; - if (dc != NULL) - ret = cplus_demangle_print (options, dc, estimate, palc); + return status; +} -#ifndef CP_DYNAMIC_ARRAYS - free (di.comps); - free (di.subs); -#endif +/* 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. */ -#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 - } +static char * +d_demangle (const char *mangled, int options, size_t *palc) +{ + struct d_growable_string dgs; + int status; - return ret; + d_growable_string_init (&dgs, 0); + + 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 : 0; + 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 @@ -4008,7 +4795,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 @@ -4025,11 +4812,8 @@ 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; @@ -4048,21 +4832,6 @@ __cxa_demangle (mangled_name, output_buffer, length, status) return NULL; } - /* The specification for __cxa_demangle() is that if the mangled - name could be either an extern "C" identifier, or an internal - built-in type name, then we resolve it as the identifier. All - internal built-in type names are a single lower case character. - Frankly, this simplistic disambiguation doesn't make sense to me, - but it is documented, so we implement it here. */ - if (IS_LOWER (mangled_name[0]) - && mangled_name[1] == '\0' - && cplus_demangle_builtin_types[mangled_name[0] - 'a'].name != NULL) - { - if (status != NULL) - *status = -2; - return NULL; - } - demangled = d_demangle (mangled_name, DMGL_PARAMS | DMGL_TYPES, &alc); if (demangled == NULL) @@ -4103,6 +4872,48 @@ __cxa_demangle (mangled_name, output_buffer, length, status) 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 @@ -4110,63 +4921,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 */ @@ -4178,10 +4967,9 @@ 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 demangle_component *dc; @@ -4197,21 +4985,11 @@ is_ctor_or_dtor (mangled, ctor_kind, dtor_kind) __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 demangle_component *) - malloc (di.num_comps * sizeof (struct demangle_component))); - di.subs = ((struct demangle_component **) - malloc (di.num_subs * sizeof (struct demangle_component *))); - if (di.comps == NULL || di.subs == NULL) - { - if (di.comps != NULL) - free (di.comps); - if (di.subs != NULL) - free (di.subs); - return 0; - } + di.comps = alloca (di.num_comps * sizeof (*di.comps)); + di.subs = alloca (di.num_subs * sizeof (*di.subs)); #endif dc = cplus_demangle_mangled_name (&di, 1); @@ -4250,11 +5028,6 @@ is_ctor_or_dtor (mangled, ctor_kind, dtor_kind) break; } } - -#ifndef CP_DYNAMIC_ARRAYS - free (di.subs); - free (di.comps); -#endif } return ret; @@ -4264,8 +5037,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; @@ -4280,8 +5052,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; @@ -4298,7 +5069,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') \ @@ -4315,9 +5086,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"); @@ -4344,9 +5113,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;