| /* Demangler for g++ V3 ABI. |
| Copyright (C) 2003-2024 Free Software Foundation, Inc. |
| Written by Ian Lance Taylor <ian@wasabisystems.com>. |
| |
| This file is part of the libiberty library, which is part of GCC. |
| |
| This file is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by |
| the Free Software Foundation; either version 2 of the License, or |
| (at your option) any later version. |
| |
| In addition to the permissions in the GNU General Public License, the |
| Free Software Foundation gives you unlimited permission to link the |
| compiled version of this file into combinations with other programs, |
| and to distribute those combinations without any restriction coming |
| from the use of this file. (The General Public License restrictions |
| do apply in other respects; for example, they cover modification of |
| the file, and distribution when not linked into a combined |
| executable.) |
| |
| This program is distributed in the hope that it will be useful, |
| but WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| GNU General Public License for more details. |
| |
| 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., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. |
| */ |
| |
| /* This code implements a demangler for the g++ V3 ABI. The ABI is |
| described on this web page: |
| https://itanium-cxx-abi.github.io/cxx-abi/abi.html#mangling |
| |
| This code was written while looking at the demangler written by |
| Alex Samuel <samuel@codesourcery.com>. |
| |
| This code first pulls the mangled name apart into a list of |
| components, and then walks the list generating the demangled |
| name. |
| |
| This file will normally define the following functions, q.v.: |
| char *cplus_demangle_v3(const char *mangled, int options) |
| char *java_demangle_v3(const char *mangled) |
| int cplus_demangle_v3_callback(const char *mangled, int options, |
| demangle_callbackref callback) |
| int java_demangle_v3_callback(const char *mangled, |
| demangle_callbackref callback) |
| enum gnu_v3_ctor_kinds is_gnu_v3_mangled_ctor (const char *name) |
| enum gnu_v3_dtor_kinds is_gnu_v3_mangled_dtor (const char *name) |
| |
| Also, the interface to the component list is public, and defined in |
| demangle.h. The interface consists of these types, which are |
| defined in demangle.h: |
| enum demangle_component_type |
| struct demangle_component |
| demangle_callbackref |
| and these functions defined in this file: |
| cplus_demangle_fill_name |
| cplus_demangle_fill_extended_operator |
| cplus_demangle_fill_ctor |
| cplus_demangle_fill_dtor |
| cplus_demangle_print |
| cplus_demangle_print_callback |
| and other functions defined in the file cp-demint.c. |
| |
| This file also defines some other functions and variables which are |
| only to be used by the file cp-demint.c. |
| |
| Preprocessor macros you can define while compiling this file: |
| |
| IN_LIBGCC2 |
| If defined, this file defines the following functions, q.v.: |
| char *__cxa_demangle (const char *mangled, char *buf, size_t *len, |
| int *status) |
| 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 |
| __gcclibcxx_demangle_callback(), and no other publically visible |
| functions or variables. |
| |
| STANDALONE_DEMANGLER |
| If defined, this file defines a main() function which demangles |
| any arguments, or, if none, demangles stdin. |
| |
| CP_DEMANGLE_DEBUG |
| If defined, turns on debugging mode, which prints information on |
| stdout about the mangled string. This is not generally useful. |
| |
| CHECK_DEMANGLER |
| If defined, additional sanity checks will be performed. It will |
| cause some slowdown, but will allow to catch out-of-bound access |
| errors earlier. This macro is intended for testing and debugging. */ |
| |
| #if defined (_AIX) && !defined (__GNUC__) |
| #pragma alloca |
| #endif |
| |
| #ifdef HAVE_CONFIG_H |
| #include "config.h" |
| #endif |
| |
| #include <stdio.h> |
| |
| #ifdef HAVE_STDLIB_H |
| #include <stdlib.h> |
| #endif |
| #ifdef HAVE_STRING_H |
| #include <string.h> |
| #endif |
| |
| #ifdef HAVE_ALLOCA_H |
| # include <alloca.h> |
| #else |
| # ifndef alloca |
| # ifdef __GNUC__ |
| # define alloca __builtin_alloca |
| # else |
| extern char *alloca (); |
| # endif /* __GNUC__ */ |
| # endif /* alloca */ |
| #endif /* HAVE_ALLOCA_H */ |
| |
| #ifdef HAVE_LIMITS_H |
| #include <limits.h> |
| #endif |
| #ifndef INT_MAX |
| # define INT_MAX (int)(((unsigned int) ~0) >> 1) /* 0x7FFFFFFF */ |
| #endif |
| |
| #include "ansidecl.h" |
| #include "libiberty.h" |
| #include "demangle.h" |
| #include "cp-demangle.h" |
| |
| /* If IN_GLIBCPP_V3 is defined, some functions are made static. We |
| also rename them via #define to avoid compiler errors when the |
| static definition conflicts with the extern declaration in a header |
| file. */ |
| #ifdef IN_GLIBCPP_V3 |
| |
| #define CP_STATIC_IF_GLIBCPP_V3 static |
| |
| #define cplus_demangle_fill_name d_fill_name |
| static int d_fill_name (struct demangle_component *, const char *, int); |
| |
| #define cplus_demangle_fill_extended_operator d_fill_extended_operator |
| static int |
| d_fill_extended_operator (struct demangle_component *, int, |
| struct demangle_component *); |
| |
| #define cplus_demangle_fill_ctor d_fill_ctor |
| static int |
| d_fill_ctor (struct demangle_component *, enum gnu_v3_ctor_kinds, |
| struct demangle_component *); |
| |
| #define cplus_demangle_fill_dtor d_fill_dtor |
| static int |
| d_fill_dtor (struct demangle_component *, enum gnu_v3_dtor_kinds, |
| struct demangle_component *); |
| |
| #define cplus_demangle_mangled_name d_mangled_name |
| static struct demangle_component *d_mangled_name (struct d_info *, int); |
| |
| #define cplus_demangle_type d_type |
| static struct demangle_component *d_type (struct d_info *); |
| |
| #define cplus_demangle_print d_print |
| static char *d_print (int, struct demangle_component *, int, size_t *); |
| |
| #define cplus_demangle_print_callback d_print_callback |
| static int d_print_callback (int, struct demangle_component *, |
| demangle_callbackref, void *); |
| |
| #define cplus_demangle_init_info d_init_info |
| static void d_init_info (const char *, int, size_t, struct d_info *); |
| |
| #else /* ! defined(IN_GLIBCPP_V3) */ |
| #define CP_STATIC_IF_GLIBCPP_V3 |
| #endif /* ! defined(IN_GLIBCPP_V3) */ |
| |
| /* See if the compiler supports dynamic arrays. */ |
| |
| #ifdef __GNUC__ |
| #define CP_DYNAMIC_ARRAYS |
| #else |
| #ifdef __STDC__ |
| #ifdef __STDC_VERSION__ |
| #if __STDC_VERSION__ >= 199901L && !__STDC_NO_VLA__ |
| #define CP_DYNAMIC_ARRAYS |
| #endif /* __STDC_VERSION__ >= 199901L && !__STDC_NO_VLA__ */ |
| #endif /* defined (__STDC_VERSION__) */ |
| #endif /* defined (__STDC__) */ |
| #endif /* ! defined (__GNUC__) */ |
| |
| /* We avoid pulling in the ctype tables, to prevent pulling in |
| additional unresolved symbols when this code is used in a library. |
| FIXME: Is this really a valid reason? This comes from the original |
| V3 demangler code. |
| |
| As of this writing this file has the following undefined references |
| 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') |
| #define IS_LOWER(c) ((c) >= 'a' && (c) <= 'z') |
| |
| /* The prefix prepended by GCC to an identifier represnting the |
| anonymous namespace. */ |
| #define ANONYMOUS_NAMESPACE_PREFIX "_GLOBAL_" |
| #define ANONYMOUS_NAMESPACE_PREFIX_LEN \ |
| (sizeof (ANONYMOUS_NAMESPACE_PREFIX) - 1) |
| |
| /* Information we keep for the standard substitutions. */ |
| |
| struct d_standard_sub_info |
| { |
| /* The code for this substitution. */ |
| char code; |
| /* The simple string it expands to. */ |
| const char *simple_expansion; |
| /* The length of the simple expansion. */ |
| int simple_len; |
| /* The results of a full, verbose, expansion. This is used when |
| qualifying a constructor/destructor, or when in verbose mode. */ |
| const char *full_expansion; |
| /* The length of the full expansion. */ |
| int full_len; |
| /* What to set the last_name field of d_info to; NULL if we should |
| not set it. This is only relevant when qualifying a |
| constructor/destructor. */ |
| const char *set_last_name; |
| /* The length of set_last_name. */ |
| int set_last_name_len; |
| }; |
| |
| /* Accessors for subtrees of struct demangle_component. */ |
| |
| #define d_left(dc) ((dc)->u.s_binary.left) |
| #define d_right(dc) ((dc)->u.s_binary.right) |
| |
| /* A list of templates. This is used while printing. */ |
| |
| struct d_print_template |
| { |
| /* Next template on the list. */ |
| struct d_print_template *next; |
| /* This template. */ |
| const struct demangle_component *template_decl; |
| }; |
| |
| /* A list of type modifiers. This is used while printing. */ |
| |
| struct d_print_mod |
| { |
| /* Next modifier on the list. These are in the reverse of the order |
| in which they appeared in the mangled string. */ |
| struct d_print_mod *next; |
| /* The modifier. */ |
| struct demangle_component *mod; |
| /* Whether this modifier was printed. */ |
| int printed; |
| /* The list of templates which applies to this modifier. */ |
| struct d_print_template *templates; |
| }; |
| |
| /* We use these structures to hold information during printing. */ |
| |
| struct d_growable_string |
| { |
| /* Buffer holding the result. */ |
| char *buf; |
| /* Current length of data in buffer. */ |
| size_t len; |
| /* Allocated size of buffer. */ |
| size_t alc; |
| /* Set to 1 if we had a memory allocation failure. */ |
| int allocation_failure; |
| }; |
| |
| /* Stack of components, innermost first, used to avoid loops. */ |
| |
| struct d_component_stack |
| { |
| /* This component. */ |
| const struct demangle_component *dc; |
| /* This component's parent. */ |
| const struct d_component_stack *parent; |
| }; |
| |
| /* A demangle component and some scope captured when it was first |
| traversed. */ |
| |
| struct d_saved_scope |
| { |
| /* The component whose scope this is. */ |
| const struct demangle_component *container; |
| /* The list of templates, if any, that was current when this |
| scope was captured. */ |
| struct d_print_template *templates; |
| }; |
| |
| /* Checkpoint structure to allow backtracking. This holds copies |
| of the fields of struct d_info that need to be restored |
| if a trial parse needs to be backtracked over. */ |
| |
| struct d_info_checkpoint |
| { |
| const char *n; |
| int next_comp; |
| int next_sub; |
| int expansion; |
| }; |
| |
| /* Maximum number of times d_print_comp may be called recursively. */ |
| #define MAX_RECURSION_COUNT 1024 |
| |
| enum { D_PRINT_BUFFER_LENGTH = 256 }; |
| struct d_print_info |
| { |
| /* Fixed-length allocated buffer for demangled data, flushed to the |
| callback with a NUL termination once full. */ |
| char buf[D_PRINT_BUFFER_LENGTH]; |
| /* Current length of data in buffer. */ |
| size_t len; |
| /* The last character printed, saved individually so that it survives |
| any buffer flush. */ |
| char last_char; |
| /* Callback function to handle demangled buffer flush. */ |
| demangle_callbackref callback; |
| /* Opaque callback argument. */ |
| void *opaque; |
| /* The current list of templates, if any. */ |
| struct d_print_template *templates; |
| /* The current list of modifiers (e.g., pointer, reference, etc.), |
| if any. */ |
| struct d_print_mod *modifiers; |
| /* Set to 1 if we saw a demangling error. */ |
| int demangle_failure; |
| /* Number of times d_print_comp was recursively called. Should not |
| be bigger than MAX_RECURSION_COUNT. */ |
| int recursion; |
| /* 1 more than the number of explicit template parms of a lambda. Template |
| parm references >= are actually 'auto'. */ |
| int lambda_tpl_parms; |
| /* The current index into any template argument packs we are using |
| for printing, or -1 to print the whole pack. */ |
| int pack_index; |
| /* Number of d_print_flush calls so far. */ |
| unsigned long int flush_count; |
| /* Stack of components, innermost first, used to avoid loops. */ |
| const struct d_component_stack *component_stack; |
| /* Array of saved scopes for evaluating substitutions. */ |
| struct d_saved_scope *saved_scopes; |
| /* Index of the next unused saved scope in the above array. */ |
| int next_saved_scope; |
| /* Number of saved scopes in the above array. */ |
| int num_saved_scopes; |
| /* Array of templates for saving into scopes. */ |
| struct d_print_template *copy_templates; |
| /* Index of the next unused copy template in the above array. */ |
| int next_copy_template; |
| /* Number of copy templates in the above array. */ |
| int num_copy_templates; |
| /* The nearest enclosing template, if any. */ |
| const struct demangle_component *current_template; |
| }; |
| |
| #ifdef CP_DEMANGLE_DEBUG |
| static void d_dump (struct demangle_component *, int); |
| #endif |
| |
| static struct demangle_component * |
| d_make_empty (struct d_info *); |
| |
| static struct demangle_component * |
| d_make_comp (struct d_info *, enum demangle_component_type, |
| struct demangle_component *, |
| struct demangle_component *); |
| |
| static struct demangle_component * |
| d_make_name (struct d_info *, const char *, int); |
| |
| static struct demangle_component * |
| d_make_demangle_mangled_name (struct d_info *, const char *); |
| |
| static struct demangle_component * |
| d_make_builtin_type (struct d_info *, |
| const struct demangle_builtin_type_info *); |
| |
| static struct demangle_component * |
| d_make_operator (struct d_info *, |
| const struct demangle_operator_info *); |
| |
| static struct demangle_component * |
| d_make_extended_operator (struct d_info *, int, |
| struct demangle_component *); |
| |
| static struct demangle_component * |
| d_make_ctor (struct d_info *, enum gnu_v3_ctor_kinds, |
| struct demangle_component *); |
| |
| static struct demangle_component * |
| d_make_dtor (struct d_info *, enum gnu_v3_dtor_kinds, |
| struct demangle_component *); |
| |
| static struct demangle_component * |
| d_make_template_param (struct d_info *, int); |
| |
| static struct demangle_component * |
| d_make_sub (struct d_info *, const char *, int); |
| |
| static int |
| has_return_type (struct demangle_component *); |
| |
| static int |
| is_ctor_dtor_or_conversion (struct demangle_component *); |
| |
| static struct demangle_component *d_encoding (struct d_info *, int); |
| |
| static struct demangle_component *d_name (struct d_info *, int substable); |
| |
| static struct demangle_component *d_nested_name (struct d_info *); |
| |
| static int d_maybe_module_name (struct d_info *, struct demangle_component **); |
| |
| static struct demangle_component *d_prefix (struct d_info *, int); |
| |
| static struct demangle_component *d_unqualified_name (struct d_info *, |
| struct demangle_component *scope, struct demangle_component *module); |
| |
| static struct demangle_component *d_source_name (struct d_info *); |
| |
| static int d_number (struct d_info *); |
| |
| static struct demangle_component *d_identifier (struct d_info *, int); |
| |
| static struct demangle_component *d_operator_name (struct d_info *); |
| |
| static struct demangle_component *d_special_name (struct d_info *); |
| |
| static struct demangle_component *d_parmlist (struct d_info *); |
| |
| static int d_call_offset (struct d_info *, int); |
| |
| static struct demangle_component *d_ctor_dtor_name (struct d_info *); |
| |
| static struct demangle_component ** |
| d_cv_qualifiers (struct d_info *, struct demangle_component **, int); |
| |
| static struct demangle_component * |
| d_ref_qualifier (struct d_info *, struct demangle_component *); |
| |
| static struct demangle_component * |
| d_function_type (struct d_info *); |
| |
| static struct demangle_component * |
| d_bare_function_type (struct d_info *, int); |
| |
| static struct demangle_component * |
| d_class_enum_type (struct d_info *, int); |
| |
| static struct demangle_component *d_array_type (struct d_info *); |
| |
| static struct demangle_component *d_vector_type (struct d_info *); |
| |
| static struct demangle_component * |
| d_pointer_to_member_type (struct d_info *); |
| |
| static struct demangle_component * |
| d_template_param (struct d_info *); |
| |
| static struct demangle_component *d_template_args (struct d_info *); |
| static struct demangle_component *d_template_args_1 (struct d_info *); |
| |
| static struct demangle_component * |
| d_template_arg (struct d_info *); |
| |
| static struct demangle_component *d_expression (struct d_info *); |
| |
| static struct demangle_component *d_expr_primary (struct d_info *); |
| |
| static struct demangle_component *d_local_name (struct d_info *); |
| |
| static int d_discriminator (struct d_info *); |
| |
| static struct demangle_component *d_template_parm (struct d_info *, int *bad); |
| |
| static struct demangle_component *d_template_head (struct d_info *, int *bad); |
| |
| static struct demangle_component *d_lambda (struct d_info *); |
| |
| static struct demangle_component *d_unnamed_type (struct d_info *); |
| |
| static struct demangle_component * |
| d_clone_suffix (struct d_info *, struct demangle_component *); |
| |
| static int |
| d_add_substitution (struct d_info *, struct demangle_component *); |
| |
| static struct demangle_component *d_substitution (struct d_info *, int); |
| |
| static void d_checkpoint (struct d_info *, struct d_info_checkpoint *); |
| |
| static void d_backtrack (struct d_info *, struct d_info_checkpoint *); |
| |
| static void d_growable_string_init (struct d_growable_string *, size_t); |
| |
| static inline void |
| d_growable_string_resize (struct d_growable_string *, size_t); |
| |
| static inline void |
| d_growable_string_append_buffer (struct d_growable_string *, |
| const char *, size_t); |
| static void |
| d_growable_string_callback_adapter (const char *, size_t, void *); |
| |
| static void |
| d_print_init (struct d_print_info *, demangle_callbackref, void *, |
| struct demangle_component *); |
| |
| static inline void d_print_error (struct d_print_info *); |
| |
| static inline int d_print_saw_error (struct d_print_info *); |
| |
| static inline void d_print_flush (struct d_print_info *); |
| |
| static inline void d_append_char (struct d_print_info *, char); |
| |
| static inline void d_append_buffer (struct d_print_info *, |
| const char *, size_t); |
| |
| static inline void d_append_string (struct d_print_info *, const char *); |
| |
| static inline char d_last_char (struct d_print_info *); |
| |
| static void |
| d_print_comp (struct d_print_info *, int, struct demangle_component *); |
| |
| static void |
| d_print_java_identifier (struct d_print_info *, const char *, int); |
| |
| static void |
| d_print_mod_list (struct d_print_info *, int, struct d_print_mod *, int); |
| |
| static void |
| d_print_mod (struct d_print_info *, int, struct demangle_component *); |
| |
| static void |
| d_print_function_type (struct d_print_info *, int, |
| struct demangle_component *, |
| struct d_print_mod *); |
| |
| static void |
| d_print_array_type (struct d_print_info *, int, |
| struct demangle_component *, |
| struct d_print_mod *); |
| |
| static void |
| d_print_expr_op (struct d_print_info *, int, struct demangle_component *); |
| |
| static void d_print_cast (struct d_print_info *, int, |
| struct demangle_component *); |
| static void d_print_conversion (struct d_print_info *, int, |
| struct demangle_component *); |
| |
| static int d_demangle_callback (const char *, int, |
| demangle_callbackref, void *); |
| static char *d_demangle (const char *, int, size_t *); |
| |
| #define FNQUAL_COMPONENT_CASE \ |
| case DEMANGLE_COMPONENT_RESTRICT_THIS: \ |
| case DEMANGLE_COMPONENT_VOLATILE_THIS: \ |
| case DEMANGLE_COMPONENT_CONST_THIS: \ |
| case DEMANGLE_COMPONENT_REFERENCE_THIS: \ |
| case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS: \ |
| case DEMANGLE_COMPONENT_XOBJ_MEMBER_FUNCTION: \ |
| case DEMANGLE_COMPONENT_TRANSACTION_SAFE: \ |
| case DEMANGLE_COMPONENT_NOEXCEPT: \ |
| case DEMANGLE_COMPONENT_THROW_SPEC |
| |
| /* True iff TYPE is a demangling component representing a |
| function-type-qualifier. */ |
| |
| static int |
| is_fnqual_component_type (enum demangle_component_type type) |
| { |
| switch (type) |
| { |
| FNQUAL_COMPONENT_CASE: |
| return 1; |
| default: |
| break; |
| } |
| return 0; |
| } |
| |
| |
| #ifdef CP_DEMANGLE_DEBUG |
| |
| static void |
| d_dump (struct demangle_component *dc, int indent) |
| { |
| int i; |
| |
| if (dc == NULL) |
| { |
| if (indent == 0) |
| printf ("failed demangling\n"); |
| return; |
| } |
| |
| for (i = 0; i < indent; ++i) |
| putchar (' '); |
| |
| switch (dc->type) |
| { |
| case DEMANGLE_COMPONENT_NAME: |
| printf ("name '%.*s'\n", dc->u.s_name.len, dc->u.s_name.s); |
| return; |
| case DEMANGLE_COMPONENT_TAGGED_NAME: |
| printf ("tagged name\n"); |
| d_dump (dc->u.s_binary.left, indent + 2); |
| d_dump (dc->u.s_binary.right, indent + 2); |
| return; |
| case DEMANGLE_COMPONENT_TEMPLATE_PARAM: |
| printf ("template parameter %ld\n", dc->u.s_number.number); |
| return; |
| case DEMANGLE_COMPONENT_TPARM_OBJ: |
| printf ("template parameter object\n"); |
| break; |
| case DEMANGLE_COMPONENT_FUNCTION_PARAM: |
| printf ("function parameter %ld\n", dc->u.s_number.number); |
| return; |
| case DEMANGLE_COMPONENT_CTOR: |
| printf ("constructor %d\n", (int) dc->u.s_ctor.kind); |
| d_dump (dc->u.s_ctor.name, indent + 2); |
| return; |
| case DEMANGLE_COMPONENT_DTOR: |
| printf ("destructor %d\n", (int) dc->u.s_dtor.kind); |
| d_dump (dc->u.s_dtor.name, indent + 2); |
| return; |
| case DEMANGLE_COMPONENT_SUB_STD: |
| printf ("standard substitution %s\n", dc->u.s_string.string); |
| return; |
| case DEMANGLE_COMPONENT_BUILTIN_TYPE: |
| printf ("builtin type %s\n", dc->u.s_builtin.type->name); |
| return; |
| case DEMANGLE_COMPONENT_EXTENDED_BUILTIN_TYPE: |
| { |
| char suffix[2] = { dc->u.s_extended_builtin.type->suffix, 0 }; |
| printf ("builtin type %s%d%s\n", dc->u.s_extended_builtin.type->name, |
| dc->u.s_extended_builtin.type->arg, suffix); |
| } |
| return; |
| case DEMANGLE_COMPONENT_OPERATOR: |
| printf ("operator %s\n", dc->u.s_operator.op->name); |
| return; |
| case DEMANGLE_COMPONENT_EXTENDED_OPERATOR: |
| printf ("extended operator with %d args\n", |
| dc->u.s_extended_operator.args); |
| d_dump (dc->u.s_extended_operator.name, indent + 2); |
| return; |
| |
| case DEMANGLE_COMPONENT_QUAL_NAME: |
| printf ("qualified name\n"); |
| break; |
| case DEMANGLE_COMPONENT_LOCAL_NAME: |
| printf ("local name\n"); |
| break; |
| case DEMANGLE_COMPONENT_TYPED_NAME: |
| printf ("typed name\n"); |
| break; |
| case DEMANGLE_COMPONENT_TEMPLATE: |
| printf ("template\n"); |
| break; |
| case DEMANGLE_COMPONENT_VTABLE: |
| printf ("vtable\n"); |
| break; |
| case DEMANGLE_COMPONENT_VTT: |
| printf ("VTT\n"); |
| break; |
| case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE: |
| printf ("construction vtable\n"); |
| break; |
| case DEMANGLE_COMPONENT_TYPEINFO: |
| printf ("typeinfo\n"); |
| break; |
| case DEMANGLE_COMPONENT_TYPEINFO_NAME: |
| printf ("typeinfo name\n"); |
| break; |
| case DEMANGLE_COMPONENT_TYPEINFO_FN: |
| printf ("typeinfo function\n"); |
| break; |
| case DEMANGLE_COMPONENT_THUNK: |
| printf ("thunk\n"); |
| break; |
| case DEMANGLE_COMPONENT_VIRTUAL_THUNK: |
| printf ("virtual thunk\n"); |
| break; |
| case DEMANGLE_COMPONENT_COVARIANT_THUNK: |
| printf ("covariant thunk\n"); |
| break; |
| case DEMANGLE_COMPONENT_JAVA_CLASS: |
| printf ("java class\n"); |
| break; |
| case DEMANGLE_COMPONENT_GUARD: |
| printf ("guard\n"); |
| break; |
| case DEMANGLE_COMPONENT_REFTEMP: |
| printf ("reference temporary\n"); |
| break; |
| case DEMANGLE_COMPONENT_HIDDEN_ALIAS: |
| printf ("hidden alias\n"); |
| break; |
| case DEMANGLE_COMPONENT_TRANSACTION_CLONE: |
| printf ("transaction clone\n"); |
| break; |
| case DEMANGLE_COMPONENT_NONTRANSACTION_CLONE: |
| printf ("non-transaction clone\n"); |
| break; |
| case DEMANGLE_COMPONENT_RESTRICT: |
| printf ("restrict\n"); |
| break; |
| case DEMANGLE_COMPONENT_VOLATILE: |
| printf ("volatile\n"); |
| break; |
| case DEMANGLE_COMPONENT_CONST: |
| printf ("const\n"); |
| break; |
| case DEMANGLE_COMPONENT_RESTRICT_THIS: |
| printf ("restrict this\n"); |
| break; |
| case DEMANGLE_COMPONENT_VOLATILE_THIS: |
| printf ("volatile this\n"); |
| break; |
| case DEMANGLE_COMPONENT_CONST_THIS: |
| printf ("const this\n"); |
| break; |
| case DEMANGLE_COMPONENT_REFERENCE_THIS: |
| printf ("reference this\n"); |
| break; |
| case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS: |
| printf ("rvalue reference this\n"); |
| break; |
| case DEMANGLE_COMPONENT_XOBJ_MEMBER_FUNCTION: |
| printf ("explicit object parameter\n"); |
| break; |
| case DEMANGLE_COMPONENT_TRANSACTION_SAFE: |
| printf ("transaction_safe this\n"); |
| break; |
| case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL: |
| printf ("vendor type qualifier\n"); |
| break; |
| case DEMANGLE_COMPONENT_POINTER: |
| printf ("pointer\n"); |
| break; |
| 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; |
| case DEMANGLE_COMPONENT_IMAGINARY: |
| printf ("imaginary\n"); |
| break; |
| case DEMANGLE_COMPONENT_VENDOR_TYPE: |
| printf ("vendor type\n"); |
| break; |
| case DEMANGLE_COMPONENT_FUNCTION_TYPE: |
| printf ("function type\n"); |
| break; |
| case DEMANGLE_COMPONENT_ARRAY_TYPE: |
| printf ("array type\n"); |
| break; |
| case DEMANGLE_COMPONENT_PTRMEM_TYPE: |
| printf ("pointer to member type\n"); |
| break; |
| case DEMANGLE_COMPONENT_ARGLIST: |
| printf ("argument list\n"); |
| break; |
| case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST: |
| printf ("template argument list\n"); |
| break; |
| case DEMANGLE_COMPONENT_INITIALIZER_LIST: |
| printf ("initializer list\n"); |
| break; |
| case DEMANGLE_COMPONENT_CAST: |
| printf ("cast\n"); |
| break; |
| case DEMANGLE_COMPONENT_CONVERSION: |
| printf ("conversion operator\n"); |
| break; |
| case DEMANGLE_COMPONENT_NULLARY: |
| printf ("nullary operator\n"); |
| break; |
| case DEMANGLE_COMPONENT_UNARY: |
| printf ("unary operator\n"); |
| break; |
| case DEMANGLE_COMPONENT_BINARY: |
| printf ("binary operator\n"); |
| break; |
| case DEMANGLE_COMPONENT_BINARY_ARGS: |
| printf ("binary operator arguments\n"); |
| break; |
| case DEMANGLE_COMPONENT_TRINARY: |
| printf ("trinary operator\n"); |
| break; |
| case DEMANGLE_COMPONENT_TRINARY_ARG1: |
| printf ("trinary operator arguments 1\n"); |
| break; |
| case DEMANGLE_COMPONENT_TRINARY_ARG2: |
| printf ("trinary operator arguments 1\n"); |
| break; |
| case DEMANGLE_COMPONENT_LITERAL: |
| printf ("literal\n"); |
| break; |
| case DEMANGLE_COMPONENT_LITERAL_NEG: |
| printf ("negative literal\n"); |
| break; |
| case DEMANGLE_COMPONENT_VENDOR_EXPR: |
| printf ("vendor expression\n"); |
| break; |
| case DEMANGLE_COMPONENT_JAVA_RESOURCE: |
| printf ("java resource\n"); |
| break; |
| case DEMANGLE_COMPONENT_COMPOUND_NAME: |
| printf ("compound name\n"); |
| break; |
| case DEMANGLE_COMPONENT_CHARACTER: |
| printf ("character '%c'\n", dc->u.s_character.character); |
| return; |
| case DEMANGLE_COMPONENT_NUMBER: |
| printf ("number %ld\n", dc->u.s_number.number); |
| return; |
| case DEMANGLE_COMPONENT_DECLTYPE: |
| printf ("decltype\n"); |
| break; |
| case DEMANGLE_COMPONENT_PACK_EXPANSION: |
| printf ("pack expansion\n"); |
| break; |
| case DEMANGLE_COMPONENT_TLS_INIT: |
| printf ("tls init function\n"); |
| break; |
| case DEMANGLE_COMPONENT_TLS_WRAPPER: |
| printf ("tls wrapper function\n"); |
| break; |
| case DEMANGLE_COMPONENT_DEFAULT_ARG: |
| printf ("default argument %d\n", dc->u.s_unary_num.num); |
| d_dump (dc->u.s_unary_num.sub, indent+2); |
| return; |
| case DEMANGLE_COMPONENT_LAMBDA: |
| printf ("lambda %d\n", dc->u.s_unary_num.num); |
| d_dump (dc->u.s_unary_num.sub, indent+2); |
| return; |
| } |
| |
| d_dump (d_left (dc), indent + 2); |
| d_dump (d_right (dc), indent + 2); |
| } |
| |
| #endif /* CP_DEMANGLE_DEBUG */ |
| |
| /* Fill in a DEMANGLE_COMPONENT_NAME. */ |
| |
| CP_STATIC_IF_GLIBCPP_V3 |
| int |
| cplus_demangle_fill_name (struct demangle_component *p, const char *s, int len) |
| { |
| if (p == NULL || s == NULL || len <= 0) |
| return 0; |
| p->d_printing = 0; |
| p->d_counting = 0; |
| p->type = DEMANGLE_COMPONENT_NAME; |
| p->u.s_name.s = s; |
| p->u.s_name.len = len; |
| return 1; |
| } |
| |
| /* Fill in a DEMANGLE_COMPONENT_EXTENDED_OPERATOR. */ |
| |
| CP_STATIC_IF_GLIBCPP_V3 |
| int |
| cplus_demangle_fill_extended_operator (struct demangle_component *p, int args, |
| struct demangle_component *name) |
| { |
| if (p == NULL || args < 0 || name == NULL) |
| return 0; |
| p->d_printing = 0; |
| p->d_counting = 0; |
| p->type = DEMANGLE_COMPONENT_EXTENDED_OPERATOR; |
| p->u.s_extended_operator.args = args; |
| p->u.s_extended_operator.name = name; |
| return 1; |
| } |
| |
| /* Fill in a DEMANGLE_COMPONENT_CTOR. */ |
| |
| CP_STATIC_IF_GLIBCPP_V3 |
| int |
| cplus_demangle_fill_ctor (struct demangle_component *p, |
| enum gnu_v3_ctor_kinds kind, |
| struct demangle_component *name) |
| { |
| if (p == NULL |
| || name == NULL |
| || (int) kind < gnu_v3_complete_object_ctor |
| || (int) kind > gnu_v3_object_ctor_group) |
| return 0; |
| p->d_printing = 0; |
| p->d_counting = 0; |
| p->type = DEMANGLE_COMPONENT_CTOR; |
| p->u.s_ctor.kind = kind; |
| p->u.s_ctor.name = name; |
| return 1; |
| } |
| |
| /* Fill in a DEMANGLE_COMPONENT_DTOR. */ |
| |
| CP_STATIC_IF_GLIBCPP_V3 |
| int |
| cplus_demangle_fill_dtor (struct demangle_component *p, |
| enum gnu_v3_dtor_kinds kind, |
| struct demangle_component *name) |
| { |
| if (p == NULL |
| || name == NULL |
| || (int) kind < gnu_v3_deleting_dtor |
| || (int) kind > gnu_v3_object_dtor_group) |
| return 0; |
| p->d_printing = 0; |
| p->d_counting = 0; |
| p->type = DEMANGLE_COMPONENT_DTOR; |
| p->u.s_dtor.kind = kind; |
| p->u.s_dtor.name = name; |
| return 1; |
| } |
| |
| /* Add a new component. */ |
| |
| static struct demangle_component * |
| d_make_empty (struct d_info *di) |
| { |
| struct demangle_component *p; |
| |
| if (di->next_comp >= di->num_comps) |
| return NULL; |
| p = &di->comps[di->next_comp]; |
| p->d_printing = 0; |
| p->d_counting = 0; |
| ++di->next_comp; |
| return p; |
| } |
| |
| /* Add a new generic component. */ |
| |
| static struct demangle_component * |
| d_make_comp (struct d_info *di, enum demangle_component_type type, |
| struct demangle_component *left, |
| struct demangle_component *right) |
| { |
| struct demangle_component *p; |
| |
| /* We check for errors here. A typical error would be a NULL return |
| from a subroutine. We catch those here, and return NULL |
| upward. */ |
| switch (type) |
| { |
| /* These types require two parameters. */ |
| case DEMANGLE_COMPONENT_QUAL_NAME: |
| case DEMANGLE_COMPONENT_LOCAL_NAME: |
| case DEMANGLE_COMPONENT_TYPED_NAME: |
| case DEMANGLE_COMPONENT_TAGGED_NAME: |
| case DEMANGLE_COMPONENT_TEMPLATE: |
| case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE: |
| case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL: |
| case DEMANGLE_COMPONENT_PTRMEM_TYPE: |
| case DEMANGLE_COMPONENT_UNARY: |
| case DEMANGLE_COMPONENT_BINARY: |
| case DEMANGLE_COMPONENT_BINARY_ARGS: |
| case DEMANGLE_COMPONENT_TRINARY: |
| case DEMANGLE_COMPONENT_TRINARY_ARG1: |
| case DEMANGLE_COMPONENT_LITERAL: |
| case DEMANGLE_COMPONENT_LITERAL_NEG: |
| case DEMANGLE_COMPONENT_VENDOR_EXPR: |
| case DEMANGLE_COMPONENT_COMPOUND_NAME: |
| case DEMANGLE_COMPONENT_VECTOR_TYPE: |
| case DEMANGLE_COMPONENT_CLONE: |
| case DEMANGLE_COMPONENT_MODULE_ENTITY: |
| case DEMANGLE_COMPONENT_CONSTRAINTS: |
| if (left == NULL || right == NULL) |
| return NULL; |
| break; |
| |
| /* These types only require one parameter. */ |
| case DEMANGLE_COMPONENT_VTABLE: |
| case DEMANGLE_COMPONENT_VTT: |
| case DEMANGLE_COMPONENT_TYPEINFO: |
| case DEMANGLE_COMPONENT_TYPEINFO_NAME: |
| case DEMANGLE_COMPONENT_TYPEINFO_FN: |
| case DEMANGLE_COMPONENT_THUNK: |
| case DEMANGLE_COMPONENT_VIRTUAL_THUNK: |
| case DEMANGLE_COMPONENT_COVARIANT_THUNK: |
| case DEMANGLE_COMPONENT_JAVA_CLASS: |
| case DEMANGLE_COMPONENT_GUARD: |
| case DEMANGLE_COMPONENT_TLS_INIT: |
| case DEMANGLE_COMPONENT_TLS_WRAPPER: |
| case DEMANGLE_COMPONENT_REFTEMP: |
| case DEMANGLE_COMPONENT_HIDDEN_ALIAS: |
| case DEMANGLE_COMPONENT_TRANSACTION_CLONE: |
| case DEMANGLE_COMPONENT_NONTRANSACTION_CLONE: |
| case DEMANGLE_COMPONENT_POINTER: |
| case DEMANGLE_COMPONENT_REFERENCE: |
| case DEMANGLE_COMPONENT_RVALUE_REFERENCE: |
| case DEMANGLE_COMPONENT_COMPLEX: |
| case DEMANGLE_COMPONENT_IMAGINARY: |
| case DEMANGLE_COMPONENT_VENDOR_TYPE: |
| case DEMANGLE_COMPONENT_CAST: |
| case DEMANGLE_COMPONENT_CONVERSION: |
| case DEMANGLE_COMPONENT_JAVA_RESOURCE: |
| case DEMANGLE_COMPONENT_DECLTYPE: |
| case DEMANGLE_COMPONENT_PACK_EXPANSION: |
| case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS: |
| case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS: |
| case DEMANGLE_COMPONENT_NULLARY: |
| case DEMANGLE_COMPONENT_TRINARY_ARG2: |
| case DEMANGLE_COMPONENT_TPARM_OBJ: |
| case DEMANGLE_COMPONENT_STRUCTURED_BINDING: |
| case DEMANGLE_COMPONENT_MODULE_INIT: |
| case DEMANGLE_COMPONENT_TEMPLATE_HEAD: |
| case DEMANGLE_COMPONENT_TEMPLATE_NON_TYPE_PARM: |
| case DEMANGLE_COMPONENT_TEMPLATE_TEMPLATE_PARM: |
| case DEMANGLE_COMPONENT_TEMPLATE_PACK_PARM: |
| case DEMANGLE_COMPONENT_FRIEND: |
| if (left == NULL) |
| return NULL; |
| break; |
| |
| /* This needs a right parameter, but the left parameter can be |
| empty. */ |
| case DEMANGLE_COMPONENT_ARRAY_TYPE: |
| case DEMANGLE_COMPONENT_INITIALIZER_LIST: |
| case DEMANGLE_COMPONENT_MODULE_NAME: |
| case DEMANGLE_COMPONENT_MODULE_PARTITION: |
| if (right == NULL) |
| return NULL; |
| break; |
| |
| /* These are allowed to have no parameters--in some cases they |
| will be filled in later. */ |
| case DEMANGLE_COMPONENT_FUNCTION_TYPE: |
| case DEMANGLE_COMPONENT_RESTRICT: |
| case DEMANGLE_COMPONENT_VOLATILE: |
| case DEMANGLE_COMPONENT_CONST: |
| case DEMANGLE_COMPONENT_ARGLIST: |
| case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST: |
| case DEMANGLE_COMPONENT_TEMPLATE_TYPE_PARM: |
| FNQUAL_COMPONENT_CASE: |
| break; |
| |
| /* Other types should not be seen here. */ |
| default: |
| return NULL; |
| } |
| |
| p = d_make_empty (di); |
| if (p != NULL) |
| { |
| p->type = type; |
| p->u.s_binary.left = left; |
| p->u.s_binary.right = right; |
| } |
| return p; |
| } |
| |
| /* Add a new demangle mangled name component. */ |
| |
| static struct demangle_component * |
| d_make_demangle_mangled_name (struct d_info *di, const char *s) |
| { |
| if (d_peek_char (di) != '_' || d_peek_next_char (di) != 'Z') |
| return d_make_name (di, s, strlen (s)); |
| d_advance (di, 2); |
| return d_encoding (di, 0); |
| } |
| |
| /* Add a new name component. */ |
| |
| static struct demangle_component * |
| d_make_name (struct d_info *di, const char *s, int len) |
| { |
| struct demangle_component *p; |
| |
| p = d_make_empty (di); |
| if (! cplus_demangle_fill_name (p, s, len)) |
| return NULL; |
| return p; |
| } |
| |
| /* Add a new builtin type component. */ |
| |
| static struct demangle_component * |
| d_make_builtin_type (struct d_info *di, |
| const struct demangle_builtin_type_info *type) |
| { |
| struct demangle_component *p; |
| |
| if (type == NULL) |
| return NULL; |
| p = d_make_empty (di); |
| if (p != NULL) |
| { |
| p->type = DEMANGLE_COMPONENT_BUILTIN_TYPE; |
| p->u.s_builtin.type = type; |
| } |
| return p; |
| } |
| |
| /* Add a new extended builtin type component. */ |
| |
| static struct demangle_component * |
| d_make_extended_builtin_type (struct d_info *di, |
| const struct demangle_builtin_type_info *type, |
| short arg, char suffix) |
| { |
| struct demangle_component *p; |
| |
| if (type == NULL) |
| return NULL; |
| p = d_make_empty (di); |
| if (p != NULL) |
| { |
| p->type = DEMANGLE_COMPONENT_EXTENDED_BUILTIN_TYPE; |
| p->u.s_extended_builtin.type = type; |
| p->u.s_extended_builtin.arg = arg; |
| p->u.s_extended_builtin.suffix = suffix; |
| } |
| return p; |
| } |
| |
| /* Add a new operator component. */ |
| |
| static struct demangle_component * |
| d_make_operator (struct d_info *di, const struct demangle_operator_info *op) |
| { |
| struct demangle_component *p; |
| |
| p = d_make_empty (di); |
| if (p != NULL) |
| { |
| p->type = DEMANGLE_COMPONENT_OPERATOR; |
| p->u.s_operator.op = op; |
| } |
| return p; |
| } |
| |
| /* Add a new extended operator component. */ |
| |
| static struct demangle_component * |
| d_make_extended_operator (struct d_info *di, int args, |
| struct demangle_component *name) |
| { |
| struct demangle_component *p; |
| |
| p = d_make_empty (di); |
| if (! cplus_demangle_fill_extended_operator (p, args, name)) |
| return NULL; |
| return p; |
| } |
| |
| static struct demangle_component * |
| d_make_default_arg (struct d_info *di, int num, |
| struct demangle_component *sub) |
| { |
| struct demangle_component *p = d_make_empty (di); |
| if (p) |
| { |
| p->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 (struct d_info *di, enum gnu_v3_ctor_kinds kind, |
| struct demangle_component *name) |
| { |
| struct demangle_component *p; |
| |
| p = d_make_empty (di); |
| if (! cplus_demangle_fill_ctor (p, kind, name)) |
| return NULL; |
| return p; |
| } |
| |
| /* Add a new destructor component. */ |
| |
| static struct demangle_component * |
| d_make_dtor (struct d_info *di, enum gnu_v3_dtor_kinds kind, |
| struct demangle_component *name) |
| { |
| struct demangle_component *p; |
| |
| p = d_make_empty (di); |
| if (! cplus_demangle_fill_dtor (p, kind, name)) |
| return NULL; |
| return p; |
| } |
| |
| /* Add a new template parameter. */ |
| |
| static struct demangle_component * |
| d_make_template_param (struct d_info *di, int i) |
| { |
| struct demangle_component *p; |
| |
| p = d_make_empty (di); |
| if (p != NULL) |
| { |
| p->type = DEMANGLE_COMPONENT_TEMPLATE_PARAM; |
| p->u.s_number.number = i; |
| } |
| return p; |
| } |
| |
| /* Add a new function parameter. */ |
| |
| static struct demangle_component * |
| d_make_function_param (struct d_info *di, int 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 (struct d_info *di, const char *name, int len) |
| { |
| struct demangle_component *p; |
| |
| p = d_make_empty (di); |
| if (p != NULL) |
| { |
| p->type = DEMANGLE_COMPONENT_SUB_STD; |
| p->u.s_string.string = name; |
| p->u.s_string.len = len; |
| } |
| return p; |
| } |
| |
| /* <mangled-name> ::= _Z <encoding> [<clone-suffix>]* |
| |
| TOP_LEVEL is non-zero when called at the top level. */ |
| |
| CP_STATIC_IF_GLIBCPP_V3 |
| struct demangle_component * |
| cplus_demangle_mangled_name (struct d_info *di, int top_level) |
| { |
| struct demangle_component *p; |
| |
| if (! d_check_char (di, '_') |
| /* Allow missing _ if not at toplevel to work around a |
| bug in G++ abi-version=2 mangling; see the comment in |
| write_template_arg. */ |
| && top_level) |
| return NULL; |
| if (! d_check_char (di, 'Z')) |
| return NULL; |
| p = d_encoding (di, top_level); |
| |
| /* If at top level and parsing parameters, check for a clone |
| suffix. */ |
| if (top_level && (di->options & DMGL_PARAMS) != 0) |
| while (d_peek_char (di) == '.' |
| && (IS_LOWER (d_peek_next_char (di)) |
| || d_peek_next_char (di) == '_' |
| || IS_DIGIT (d_peek_next_char (di)))) |
| p = d_clone_suffix (di, p); |
| |
| return p; |
| } |
| |
| /* Return whether a function should have a return type. The argument |
| is the function name, which may be qualified in various ways. The |
| rules are that template functions have return types with some |
| exceptions, function types which are not part of a function name |
| mangling have return types with some exceptions, and non-template |
| function names do not have return types. The exceptions are that |
| constructors, destructors, and conversion operators do not have |
| return types. */ |
| |
| static int |
| has_return_type (struct demangle_component *dc) |
| { |
| if (dc == NULL) |
| return 0; |
| switch (dc->type) |
| { |
| default: |
| return 0; |
| case DEMANGLE_COMPONENT_LOCAL_NAME: |
| return has_return_type (d_right (dc)); |
| case DEMANGLE_COMPONENT_TEMPLATE: |
| return ! is_ctor_dtor_or_conversion (d_left (dc)); |
| FNQUAL_COMPONENT_CASE: |
| return has_return_type (d_left (dc)); |
| } |
| } |
| |
| /* Return whether a name is a constructor, a destructor, or a |
| conversion operator. */ |
| |
| static int |
| is_ctor_dtor_or_conversion (struct demangle_component *dc) |
| { |
| if (dc == NULL) |
| return 0; |
| switch (dc->type) |
| { |
| default: |
| return 0; |
| case DEMANGLE_COMPONENT_QUAL_NAME: |
| case DEMANGLE_COMPONENT_LOCAL_NAME: |
| return is_ctor_dtor_or_conversion (d_right (dc)); |
| case DEMANGLE_COMPONENT_CTOR: |
| case DEMANGLE_COMPONENT_DTOR: |
| case DEMANGLE_COMPONENT_CONVERSION: |
| return 1; |
| } |
| } |
| |
| /* [ Q <constraint-expression> ] */ |
| |
| static struct demangle_component * |
| d_maybe_constraints (struct d_info *di, struct demangle_component *dc) |
| { |
| if (d_peek_char (di) == 'Q') |
| { |
| d_advance (di, 1); |
| struct demangle_component *expr = d_expression (di); |
| if (expr == NULL) |
| return NULL; |
| dc = d_make_comp (di, DEMANGLE_COMPONENT_CONSTRAINTS, dc, expr); |
| } |
| return dc; |
| } |
| |
| /* <encoding> ::= <(function) name> <bare-function-type> |
| ::= <(data) name> |
| ::= <special-name> |
| |
| TOP_LEVEL is non-zero when called at the top level, in which case |
| if DMGL_PARAMS is not set we do not demangle the function |
| parameters. We only set this at the top level, because otherwise |
| we would not correctly demangle names in local scopes. */ |
| |
| static struct demangle_component * |
| d_encoding (struct d_info *di, int top_level) |
| { |
| char peek = d_peek_char (di); |
| struct demangle_component *dc; |
| |
| if (peek == 'G' || peek == 'T') |
| dc = d_special_name (di); |
| else |
| { |
| dc = d_name (di, 0); |
| |
| if (!dc) |
| /* Failed already. */; |
| else if (top_level && (di->options & DMGL_PARAMS) == 0) |
| { |
| /* Strip off any initial CV-qualifiers, as they really apply |
| to the `this' parameter, and they were not output by the |
| v2 demangler without DMGL_PARAMS. */ |
| while (is_fnqual_component_type (dc->type)) |
| dc = d_left (dc); |
| |
| /* If the top level is a DEMANGLE_COMPONENT_LOCAL_NAME, then |
| there may be function-qualifiers on its right argument which |
| really apply here; this happens when parsing a class |
| which is local to a function. */ |
| if (dc->type == DEMANGLE_COMPONENT_LOCAL_NAME) |
| { |
| while (d_right (dc) != NULL |
| && is_fnqual_component_type (d_right (dc)->type)) |
| d_right (dc) = d_left (d_right (dc)); |
| |
| if (d_right (dc) == NULL) |
| dc = NULL; |
| } |
| } |
| else |
| { |
| peek = d_peek_char (di); |
| if (peek != '\0' && peek != 'E') |
| { |
| struct demangle_component *ftype; |
| |
| ftype = d_bare_function_type (di, has_return_type (dc)); |
| if (!ftype) |
| return NULL; |
| |
| /* If this is a non-top-level local-name, clear the |
| return type, so it doesn't confuse the user by |
| being confused with the return type of whaever |
| this is nested within. */ |
| if (!top_level && dc->type == DEMANGLE_COMPONENT_LOCAL_NAME |
| && ftype->type == DEMANGLE_COMPONENT_FUNCTION_TYPE) |
| d_left (ftype) = NULL; |
| |
| ftype = d_maybe_constraints (di, ftype); |
| |
| dc = d_make_comp (di, DEMANGLE_COMPONENT_TYPED_NAME, |
| dc, ftype); |
| } |
| } |
| } |
| |
| return dc; |
| } |
| |
| /* <tagged-name> ::= <name> B <source-name> */ |
| |
| static struct demangle_component * |
| d_abi_tags (struct d_info *di, struct demangle_component *dc) |
| { |
| struct demangle_component *hold_last_name; |
| char peek; |
| |
| /* Preserve the last name, so the ABI tag doesn't clobber it. */ |
| hold_last_name = di->last_name; |
| |
| while (peek = d_peek_char (di), |
| peek == 'B') |
| { |
| struct demangle_component *tag; |
| d_advance (di, 1); |
| tag = d_source_name (di); |
| dc = d_make_comp (di, DEMANGLE_COMPONENT_TAGGED_NAME, dc, tag); |
| } |
| |
| di->last_name = hold_last_name; |
| |
| return dc; |
| } |
| |
| /* <name> ::= <nested-name> |
| ::= <unscoped-name> |
| ::= <unscoped-template-name> <template-args> |
| ::= <local-name> |
| |
| <unscoped-name> ::= <unqualified-name> |
| ::= St <unqualified-name> |
| |
| <unscoped-template-name> ::= <unscoped-name> |
| ::= <substitution> |
| */ |
| |
| static struct demangle_component * |
| d_name (struct d_info *di, int substable) |
| { |
| char peek = d_peek_char (di); |
| struct demangle_component *dc = NULL; |
| struct demangle_component *module = NULL; |
| int subst = 0; |
| |
| switch (peek) |
| { |
| case 'N': |
| dc = d_nested_name (di); |
| break; |
| |
| case 'Z': |
| dc = d_local_name (di); |
| break; |
| |
| case 'U': |
| dc = d_unqualified_name (di, NULL, NULL); |
| break; |
| |
| case 'S': |
| { |
| if (d_peek_next_char (di) == 't') |
| { |
| d_advance (di, 2); |
| dc = d_make_name (di, "std", 3); |
| di->expansion += 3; |
| } |
| |
| if (d_peek_char (di) == 'S') |
| { |
| module = d_substitution (di, 0); |
| if (!module) |
| return NULL; |
| if (!(module->type == DEMANGLE_COMPONENT_MODULE_NAME |
| || module->type == DEMANGLE_COMPONENT_MODULE_PARTITION)) |
| { |
| if (dc) |
| return NULL; |
| subst = 1; |
| dc = module; |
| module = NULL; |
| } |
| } |
| } |
| /* FALLTHROUGH */ |
| |
| case 'L': |
| default: |
| if (!subst) |
| dc = d_unqualified_name (di, dc, module); |
| if (d_peek_char (di) == 'I') |
| { |
| /* This is <template-args>, which means that we just saw |
| <unscoped-template-name>, which is a substitution |
| candidate. */ |
| if (!subst && !d_add_substitution (di, dc)) |
| return NULL; |
| dc = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, dc, |
| d_template_args (di)); |
| subst = 0; |
| } |
| break; |
| } |
| if (substable && !subst && !d_add_substitution (di, dc)) |
| return NULL; |
| return dc; |
| } |
| |
| /* <nested-name> ::= N [<CV-qualifiers>] [<ref-qualifier>] <prefix> <unqualified-name> E |
| ::= N [<CV-qualifiers>] [<ref-qualifier>] <template-prefix> <template-args> E |
| ::= N H <prefix> <unqualified-name> E |
| ::= N H <template-prefix> <template-args> E |
| */ |
| |
| static struct demangle_component * |
| d_nested_name (struct d_info *di) |
| { |
| struct demangle_component *ret; |
| struct demangle_component **pret; |
| struct demangle_component *rqual; |
| |
| if (! d_check_char (di, 'N')) |
| return NULL; |
| |
| if (d_peek_char (di) == 'H') |
| { |
| d_advance (di, 1); |
| di->expansion += sizeof "this"; |
| pret = &ret; |
| rqual = d_make_comp (di, DEMANGLE_COMPONENT_XOBJ_MEMBER_FUNCTION, |
| NULL, NULL); |
| } |
| else |
| { |
| pret = d_cv_qualifiers (di, &ret, 1); |
| if (pret == NULL) |
| return NULL; |
| |
| /* Parse the ref-qualifier now and then attach it |
| once we have something to attach it to. */ |
| rqual = d_ref_qualifier (di, NULL); |
| } |
| |
| *pret = d_prefix (di, 1); |
| if (*pret == NULL) |
| return NULL; |
| |
| if (rqual) |
| { |
| d_left (rqual) = ret; |
| ret = rqual; |
| } |
| |
| if (! d_check_char (di, 'E')) |
| return NULL; |
| |
| return ret; |
| } |
| |
| /* <prefix> ::= <prefix> <unqualified-name> |
| ::= <template-prefix> <template-args> |
| ::= <template-param> |
| ::= <decltype> |
| ::= |
| ::= <substitution> |
| |
| <template-prefix> ::= <prefix> <(template) unqualified-name> |
| ::= <template-param> |
| ::= <substitution> |
| |
| SUBST is true if we should add substitutions (as normal), false |
| if not (in an unresolved-name). */ |
| |
| static struct demangle_component * |
| d_prefix (struct d_info *di, int substable) |
| { |
| struct demangle_component *ret = NULL; |
| |
| for (;;) |
| { |
| char peek = d_peek_char (di); |
| |
| /* The older code accepts a <local-name> here, but I don't see |
| that in the grammar. The older code does not accept a |
| <template-param> here. */ |
| |
| if (peek == 'D' |
| && (d_peek_next_char (di) == 'T' |
| || d_peek_next_char (di) == 't')) |
| { |
| /* Decltype. */ |
| if (ret) |
| return NULL; |
| ret = cplus_demangle_type (di); |
| } |
| else if (peek == 'I') |
| { |
| if (ret == NULL) |
| return NULL; |
| struct demangle_component *dc = d_template_args (di); |
| if (!dc) |
| return NULL; |
| ret = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, ret, dc); |
| } |
| else if (peek == 'T') |
| { |
| if (ret) |
| return NULL; |
| ret = d_template_param (di); |
| } |
| else if (peek == 'M') |
| { |
| /* Initializer scope for a lambda. We already added it as a |
| substitution candidate, don't do that again. */ |
| d_advance (di, 1); |
| continue; |
| } |
| else |
| { |
| struct demangle_component *module = NULL; |
| if (peek == 'S') |
| { |
| module = d_substitution (di, 1); |
| if (!module) |
| return NULL; |
| if (!(module->type == DEMANGLE_COMPONENT_MODULE_NAME |
| || module->type == DEMANGLE_COMPONENT_MODULE_PARTITION)) |
| { |
| if (ret) |
| return NULL; |
| ret = module; |
| continue; |
| } |
| } |
| ret = d_unqualified_name (di, ret, module); |
| } |
| |
| if (!ret) |
| break; |
| |
| if (d_peek_char (di) == 'E') |
| break; |
| |
| if (substable && !d_add_substitution (di, ret)) |
| return NULL; |
| } |
| |
| return ret; |
| } |
| |
| static int |
| d_maybe_module_name (struct d_info *di, struct demangle_component **name) |
| { |
| while (d_peek_char (di) == 'W') |
| { |
| d_advance (di, 1); |
| enum demangle_component_type code = DEMANGLE_COMPONENT_MODULE_NAME; |
| if (d_peek_char (di) == 'P') |
| { |
| code = DEMANGLE_COMPONENT_MODULE_PARTITION; |
| d_advance (di, 1); |
| } |
| |
| *name = d_make_comp (di, code, *name, d_source_name (di)); |
| if (!*name) |
| return 0; |
| if (!d_add_substitution (di, *name)) |
| return 0; |
| } |
| return 1; |
| } |
| |
| /* <unqualified-name> ::= [<module-name>] <operator-name> [<abi-tags>] |
| ::= [<module-name>] <ctor-dtor-name> [<abi-tags>] |
| ::= [<module-name>] <source-name> [<abi-tags>] |
| ::= [<module-name>] F <source-name> [<abi-tags>] |
| ::= [<module-name>] <local-source-name> [<abi-tags>] |
| ::= [<module-name>] DC <source-name>+ E [<abi-tags>] |
| <local-source-name> ::= L <source-name> <discriminator> [<abi-tags>] |
| */ |
| |
| static struct demangle_component * |
| d_unqualified_name (struct d_info *di, struct demangle_component *scope, |
| struct demangle_component *module) |
| { |
| struct demangle_component *ret; |
| char peek; |
| int member_like_friend = 0; |
| |
| if (!d_maybe_module_name (di, &module)) |
| return NULL; |
| |
| peek = d_peek_char (di); |
| if (peek == 'F') |
| { |
| member_like_friend = 1; |
| d_advance (di, 1); |
| peek = d_peek_char (di); |
| } |
| if (IS_DIGIT (peek)) |
| ret = d_source_name (di); |
| else if (IS_LOWER (peek)) |
| { |
| int was_expr = di->is_expression; |
| if (peek == 'o' && d_peek_next_char (di) == 'n') |
| { |
| d_advance (di, 2); |
| /* Treat cv as naming a conversion operator. */ |
| di->is_expression = 0; |
| } |
| ret = d_operator_name (di); |
| di->is_expression = was_expr; |
| if (ret != NULL && ret->type == DEMANGLE_COMPONENT_OPERATOR) |
| { |
| di->expansion += sizeof "operator" + ret->u.s_operator.op->len - 2; |
| if (!strcmp (ret->u.s_operator.op->code, "li")) |
| ret = d_make_comp (di, DEMANGLE_COMPONENT_UNARY, ret, |
| d_source_name (di)); |
| } |
| } |
| else if (peek == 'D' && d_peek_next_char (di) == 'C') |
| { |
| // structured binding |
| d_advance (di, 2); |
| struct demangle_component *prev = NULL; |
| do |
| { |
| struct demangle_component *next = |
| d_make_comp (di, DEMANGLE_COMPONENT_STRUCTURED_BINDING, |
| d_source_name (di), NULL); |
| if (prev) |
| d_right (prev) = next; |
| else |
| ret = next; |
| prev = next; |
| } |
| while (prev && d_peek_char (di) != 'E'); |
| if (prev) |
| d_advance (di, 1); |
| else |
| ret = NULL; |
| } |
| else if (peek == 'C' || peek == 'D') |
| ret = d_ctor_dtor_name (di); |
| else if (peek == 'L') |
| { |
| d_advance (di, 1); |
| |
| ret = d_source_name (di); |
| if (ret == NULL) |
| return NULL; |
| if (! d_discriminator (di)) |
| return NULL; |
| } |
| else if (peek == 'U') |
| { |
| switch (d_peek_next_char (di)) |
| { |
| case 'l': |
| ret = d_lambda (di); |
| break; |
| case 't': |
| ret = d_unnamed_type (di); |
| break; |
| default: |
| return NULL; |
| } |
| } |
| else |
| return NULL; |
| |
| if (module) |
| ret = d_make_comp (di, DEMANGLE_COMPONENT_MODULE_ENTITY, ret, module); |
| if (d_peek_char (di) == 'B') |
| ret = d_abi_tags (di, ret); |
| if (member_like_friend) |
| ret = d_make_comp (di, DEMANGLE_COMPONENT_FRIEND, ret, NULL); |
| if (scope) |
| ret = d_make_comp (di, DEMANGLE_COMPONENT_QUAL_NAME, scope, ret); |
| |
| return ret; |
| } |
| |
| /* <source-name> ::= <(positive length) number> <identifier> */ |
| |
| static struct demangle_component * |
| d_source_name (struct d_info *di) |
| { |
| int len; |
| struct demangle_component *ret; |
| |
| len = d_number (di); |
| if (len <= 0) |
| return NULL; |
| ret = d_identifier (di, len); |
| di->last_name = ret; |
| return ret; |
| } |
| |
| /* number ::= [n] <(non-negative decimal integer)> */ |
| |
| static int |
| d_number (struct d_info *di) |
| { |
| int negative; |
| char peek; |
| int ret; |
| |
| negative = 0; |
| peek = d_peek_char (di); |
| if (peek == 'n') |
| { |
| negative = 1; |
| d_advance (di, 1); |
| peek = d_peek_char (di); |
| } |
| |
| ret = 0; |
| while (1) |
| { |
| if (! IS_DIGIT (peek)) |
| { |
| if (negative) |
| ret = - ret; |
| return ret; |
| } |
| if (ret > ((INT_MAX - (peek - '0')) / 10)) |
| return -1; |
| ret = ret * 10 + (peek - '0'); |
| d_advance (di, 1); |
| peek = d_peek_char (di); |
| } |
| } |
| |
| /* Like d_number, but returns a demangle_component. */ |
| |
| static struct demangle_component * |
| d_number_component (struct d_info *di) |
| { |
| struct demangle_component *ret = d_make_empty (di); |
| if (ret) |
| { |
| ret->type = DEMANGLE_COMPONENT_NUMBER; |
| ret->u.s_number.number = d_number (di); |
| } |
| return ret; |
| } |
| |
| /* identifier ::= <(unqualified source code identifier)> */ |
| |
| static struct demangle_component * |
| d_identifier (struct d_info *di, int len) |
| { |
| const char *name; |
| |
| name = d_str (di); |
| |
| if (di->send - name < len) |
| return NULL; |
| |
| d_advance (di, len); |
| |
| /* A Java mangled name may have a trailing '$' if it is a C++ |
| keyword. This '$' is not included in the length count. We just |
| ignore the '$'. */ |
| if ((di->options & DMGL_JAVA) != 0 |
| && d_peek_char (di) == '$') |
| d_advance (di, 1); |
| |
| /* Look for something which looks like a gcc encoding of an |
| anonymous namespace, and replace it with a more user friendly |
| name. */ |
| if (len >= (int) ANONYMOUS_NAMESPACE_PREFIX_LEN + 2 |
| && memcmp (name, ANONYMOUS_NAMESPACE_PREFIX, |
| ANONYMOUS_NAMESPACE_PREFIX_LEN) == 0) |
| { |
| const char *s; |
| |
| s = name + ANONYMOUS_NAMESPACE_PREFIX_LEN; |
| if ((*s == '.' || *s == '_' || *s == '$') |
| && s[1] == 'N') |
| { |
| di->expansion -= len - sizeof "(anonymous namespace)"; |
| return d_make_name (di, "(anonymous namespace)", |
| sizeof "(anonymous namespace)" - 1); |
| } |
| } |
| |
| return d_make_name (di, name, len); |
| } |
| |
| /* operator_name ::= many different two character encodings. |
| ::= cv <type> |
| ::= v <digit> <source-name> |
| |
| This list is sorted for binary search. */ |
| |
| #define NL(s) s, (sizeof s) - 1 |
| |
| CP_STATIC_IF_GLIBCPP_V3 |
| const struct demangle_operator_info cplus_demangle_operators[] = |
| { |
| { "aN", NL ("&="), 2 }, |
| { "aS", NL ("="), 2 }, |
| { "aa", NL ("&&"), 2 }, |
| { "ad", NL ("&"), 1 }, |
| { "an", NL ("&"), 2 }, |
| { "at", NL ("alignof "), 1 }, |
| { "aw", NL ("co_await "), 1 }, |
| { "az", NL ("alignof "), 1 }, |
| { "cc", NL ("const_cast"), 2 }, |
| { "cl", NL ("()"), 2 }, |
| { "cm", NL (","), 2 }, |
| { "co", NL ("~"), 1 }, |
| { "dV", NL ("/="), 2 }, |
| { "dX", NL ("[...]="), 3 }, /* [expr...expr] = expr */ |
| { "da", NL ("delete[] "), 1 }, |
| { "dc", NL ("dynamic_cast"), 2 }, |
| { "de", NL ("*"), 1 }, |
| { "di", NL ("="), 2 }, /* .name = expr */ |
| { "dl", NL ("delete "), 1 }, |
| { "ds", NL (".*"), 2 }, |
| { "dt", NL ("."), 2 }, |
| { "dv", NL ("/"), 2 }, |
| { "dx", NL ("]="), 2 }, /* [expr] = expr */ |
| { "eO", NL ("^="), 2 }, |
| { "eo", NL ("^"), 2 }, |
| { "eq", NL ("=="), 2 }, |
| { "fL", NL ("..."), 3 }, |
| { "fR", NL ("..."), 3 }, |
| { "fl", NL ("..."), 2 }, |
| { "fr", NL ("..."), 2 }, |
| { "ge", NL (">="), 2 }, |
| { "gs", NL ("::"), 1 }, |
| { "gt", NL (">"), 2 }, |
| { "ix", NL ("[]"), 2 }, |
| { "lS", NL ("<<="), 2 }, |
| { "le", NL ("<="), 2 }, |
| { "li", NL ("operator\"\" "), 1 }, |
| { "ls", NL ("<<"), 2 }, |
| { "lt", NL ("<"), 2 }, |
| { "mI", NL ("-="), 2 }, |
| { "mL", NL ("*="), 2 }, |
| { "mi", NL ("-"), 2 }, |
| { "ml", NL ("*"), 2 }, |
| { "mm", NL ("--"), 1 }, |
| { "na", NL ("new[]"), 3 }, |
| { "ne", NL ("!="), 2 }, |
| { "ng", NL ("-"), 1 }, |
| { "nt", NL ("!"), 1 }, |
| { "nw", NL ("new"), 3 }, |
| { "nx", NL ("noexcept"), 1 }, |
| { "oR", NL ("|="), 2 }, |
| { "oo", NL ("||"), 2 }, |
| { "or", NL ("|"), 2 }, |
| { "pL", NL ("+="), 2 }, |
| { "pl", NL ("+"), 2 }, |
| { "pm", NL ("->*"), 2 }, |
| { "pp", NL ("++"), 1 }, |
| { "ps", NL ("+"), 1 }, |
| { "pt", NL ("->"), 2 }, |
| { "qu", NL ("?"), 3 }, |
| { "rM", NL ("%="), 2 }, |
| { "rS", NL (">>="), 2 }, |
| { "rc", NL ("reinterpret_cast"), 2 }, |
| { "rm", NL ("%"), 2 }, |
| { "rs", NL (">>"), 2 }, |
| { "sP", NL ("sizeof..."), 1 }, |
| { "sZ", NL ("sizeof..."), 1 }, |
| { "sc", NL ("static_cast"), 2 }, |
| { "ss", NL ("<=>"), 2 }, |
| { "st", NL ("sizeof "), 1 }, |
| { "sz", NL ("sizeof "), 1 }, |
| { "tr", NL ("throw"), 0 }, |
| { "tw", NL ("throw "), 1 }, |
| { NULL, NULL, 0, 0 } |
| }; |
| |
| static struct demangle_component * |
| d_operator_name (struct d_info *di) |
| { |
| char c1; |
| char c2; |
| |
| c1 = d_next_char (di); |
| c2 = d_next_char (di); |
| if (c1 == 'v' && IS_DIGIT (c2)) |
| return d_make_extended_operator (di, c2 - '0', d_source_name (di)); |
| else if (c1 == 'c' && c2 == 'v') |
| { |
| struct demangle_component *type; |
| int was_conversion = di->is_conversion; |
| struct demangle_component *res; |
| |
| di->is_conversion = ! di->is_expression; |
| type = cplus_demangle_type (di); |
| if (di->is_conversion) |
| res = d_make_comp (di, DEMANGLE_COMPONENT_CONVERSION, type, NULL); |
| else |
| res = d_make_comp (di, DEMANGLE_COMPONENT_CAST, type, NULL); |
| di->is_conversion = was_conversion; |
| return res; |
| } |
| else |
| { |
| /* LOW is the inclusive lower bound. */ |
| int low = 0; |
| /* HIGH is the exclusive upper bound. We subtract one to ignore |
| the sentinel at the end of the array. */ |
| int high = ((sizeof (cplus_demangle_operators) |
| / sizeof (cplus_demangle_operators[0])) |
| - 1); |
| |
| while (1) |
| { |
| int i; |
| const struct demangle_operator_info *p; |
| |
| i = low + (high - low) / 2; |
| p = cplus_demangle_operators + i; |
| |
| if (c1 == p->code[0] && c2 == p->code[1]) |
| return d_make_operator (di, p); |
| |
| if (c1 < p->code[0] || (c1 == p->code[0] && c2 < p->code[1])) |
| high = i; |
| else |
| low = i + 1; |
| if (low == high) |
| return NULL; |
| } |
| } |
| } |
| |
| 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; |
| int 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; |
| } |
| |
| /* <special-name> ::= TV <type> |
| ::= TT <type> |
| ::= TI <type> |
| ::= TS <type> |
| ::= TA <template-arg> |
| ::= GV <(object) name> |
| ::= T <call-offset> <(base) encoding> |
| ::= Tc <call-offset> <call-offset> <(base) encoding> |
| Also g++ extensions: |
| ::= TC <type> <(offset) number> _ <(base) type> |
| ::= TF <type> |
| ::= TJ <type> |
| ::= GR <name> |
| ::= GA <encoding> |
| ::= Gr <resource name> |
| ::= GTt <encoding> |
| ::= GTn <encoding> |
| */ |
| |
| static struct demangle_component * |
| d_special_name (struct d_info *di) |
| { |
| di->expansion += 20; |
| if (d_check_char (di, 'T')) |
| { |
| switch (d_next_char (di)) |
| { |
| case 'V': |
| di->expansion -= 5; |
| return d_make_comp (di, DEMANGLE_COMPONENT_VTABLE, |
| cplus_demangle_type (di), NULL); |
| case 'T': |
| di->expansion -= 10; |
| return d_make_comp (di, DEMANGLE_COMPONENT_VTT, |
| cplus_demangle_type (di), NULL); |
| case 'I': |
| return d_make_comp (di, DEMANGLE_COMPONENT_TYPEINFO, |
| cplus_demangle_type (di), NULL); |
| case 'S': |
| return d_make_comp (di, DEMANGLE_COMPONENT_TYPEINFO_NAME, |
| cplus_demangle_type (di), NULL); |
| |
| case 'h': |
| if (! d_call_offset (di, 'h')) |
| return NULL; |
| return d_make_comp (di, DEMANGLE_COMPONENT_THUNK, |
| d_encoding (di, 0), NULL); |
| |
| case 'v': |
| if (! d_call_offset (di, 'v')) |
| return NULL; |
| return d_make_comp (di, DEMANGLE_COMPONENT_VIRTUAL_THUNK, |
| d_encoding (di, 0), NULL); |
| |
| case 'c': |
| if (! d_call_offset (di, '\0')) |
| return NULL; |
| if (! d_call_offset (di, '\0')) |
| return NULL; |
| return d_make_comp (di, DEMANGLE_COMPONENT_COVARIANT_THUNK, |
| d_encoding (di, 0), NULL); |
| |
| case 'C': |
| { |
| struct demangle_component *derived_type; |
| int offset; |
| struct demangle_component *base_type; |
| |
| derived_type = cplus_demangle_type (di); |
| offset = d_number (di); |
| if (offset < 0) |
| return NULL; |
| if (! d_check_char (di, '_')) |
| return NULL; |
| base_type = cplus_demangle_type (di); |
| /* We don't display the offset. FIXME: We should display |
| it in verbose mode. */ |
| di->expansion += 5; |
| return d_make_comp (di, DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE, |
| base_type, derived_type); |
| } |
| |
| case 'F': |
| return d_make_comp (di, DEMANGLE_COMPONENT_TYPEINFO_FN, |
| cplus_demangle_type (di), NULL); |
| case 'J': |
| return d_make_comp (di, DEMANGLE_COMPONENT_JAVA_CLASS, |
| cplus_demangle_type (di), NULL); |
| |
| case 'H': |
| return d_make_comp (di, DEMANGLE_COMPONENT_TLS_INIT, |
| d_name (di, 0), NULL); |
| |
| case 'W': |
| return d_make_comp (di, DEMANGLE_COMPONENT_TLS_WRAPPER, |
| d_name (di, 0), NULL); |
| |
| case 'A': |
| return d_make_comp (di, DEMANGLE_COMPONENT_TPARM_OBJ, |
| d_template_arg (di), NULL); |
| |
| default: |
| return NULL; |
| } |
| } |
| else if (d_check_char (di, 'G')) |
| { |
| switch (d_next_char (di)) |
| { |
| case 'V': |
| return d_make_comp (di, DEMANGLE_COMPONENT_GUARD, |
| d_name (di, 0), NULL); |
| |
| case 'R': |
| { |
| struct demangle_component *name = d_name (di, 0); |
| return d_make_comp (di, DEMANGLE_COMPONENT_REFTEMP, name, |
| d_number_component (di)); |
| } |
| |
| case 'A': |
| return d_make_comp (di, DEMANGLE_COMPONENT_HIDDEN_ALIAS, |
| d_encoding (di, 0), NULL); |
| |
| case 'I': |
| { |
| struct demangle_component *module = NULL; |
| if (!d_maybe_module_name (di, &module) || !module) |
| return NULL; |
| return d_make_comp (di, DEMANGLE_COMPONENT_MODULE_INIT, |
| module, NULL); |
| } |
| case 'T': |
| switch (d_next_char (di)) |
| { |
| case 'n': |
| return d_make_comp (di, DEMANGLE_COMPONENT_NONTRANSACTION_CLONE, |
| d_encoding (di, 0), NULL); |
| default: |
| /* ??? The proposal is that other letters (such as 'h') stand |
| for different variants of transaction cloning, such as |
| compiling directly for hardware transaction support. But |
| they still should all be transactional clones of some sort |
| so go ahead and call them that. */ |
| case 't': |
| return d_make_comp (di, DEMANGLE_COMPONENT_TRANSACTION_CLONE, |
| d_encoding (di, 0), NULL); |
| } |
| |
| case 'r': |
| return d_java_resource (di); |
| |
| default: |
| return NULL; |
| } |
| } |
| else |
| return NULL; |
| } |
| |
| /* <call-offset> ::= h <nv-offset> _ |
| ::= v <v-offset> _ |
| |
| <nv-offset> ::= <(offset) number> |
| |
| <v-offset> ::= <(offset) number> _ <(virtual offset) number> |
| |
| The C parameter, if not '\0', is a character we just read which is |
| the start of the <call-offset>. |
| |
| We don't display the offset information anywhere. FIXME: We should |
| display it in verbose mode. */ |
| |
| static int |
| d_call_offset (struct d_info *di, int c) |
| { |
| if (c == '\0') |
| c = d_next_char (di); |
| |
| if (c == 'h') |
| d_number (di); |
| else if (c == 'v') |
| { |
| d_number (di); |
| if (! d_check_char (di, '_')) |
| return 0; |
| d_number (di); |
| } |
| else |
| return 0; |
| |
| if (! d_check_char (di, '_')) |
| return 0; |
| |
| return 1; |
| } |
| |
| /* <ctor-dtor-name> ::= C1 |
| ::= C2 |
| ::= C3 |
| ::= D0 |
| ::= D1 |
| ::= D2 |
| */ |
| |
| static struct demangle_component * |
| d_ctor_dtor_name (struct d_info *di) |
| { |
| if (di->last_name != NULL) |
| { |
| if (di->last_name->type == DEMANGLE_COMPONENT_NAME) |
| di->expansion += di->last_name->u.s_name.len; |
| else if (di->last_name->type == DEMANGLE_COMPONENT_SUB_STD) |
| di->expansion += di->last_name->u.s_string.len; |
| } |
| switch (d_peek_char (di)) |
| { |
| case 'C': |
| { |
| enum gnu_v3_ctor_kinds kind; |
| int inheriting = 0; |
| |
| if (d_peek_next_char (di) == 'I') |
| { |
| inheriting = 1; |
| d_advance (di, 1); |
| } |
| |
| switch (d_peek_next_char (di)) |
| { |
| case '1': |
| kind = gnu_v3_complete_object_ctor; |
| break; |
| case '2': |
| kind = gnu_v3_base_object_ctor; |
| break; |
| case '3': |
| kind = gnu_v3_complete_object_allocating_ctor; |
| break; |
| case '4': |
| kind = gnu_v3_unified_ctor; |
| break; |
| case '5': |
| kind = gnu_v3_object_ctor_group; |
| break; |
| default: |
| return NULL; |
| } |
| |
| d_advance (di, 2); |
| |
| if (inheriting) |
| cplus_demangle_type (di); |
| |
| return d_make_ctor (di, kind, di->last_name); |
| } |
| |
| case 'D': |
| { |
| enum gnu_v3_dtor_kinds kind; |
| |
| switch (d_peek_next_char (di)) |
| { |
| case '0': |
| kind = gnu_v3_deleting_dtor; |
| break; |
| case '1': |
| kind = gnu_v3_complete_object_dtor; |
| break; |
| case '2': |
| kind = gnu_v3_base_object_dtor; |
| break; |
| /* digit '3' is not used */ |
| case '4': |
| kind = gnu_v3_unified_dtor; |
| break; |
| case '5': |
| kind = gnu_v3_object_dtor_group; |
| break; |
| default: |
| return NULL; |
| } |
| d_advance (di, 2); |
| return d_make_dtor (di, kind, di->last_name); |
| } |
| |
| default: |
| return NULL; |
| } |
| } |
| |
| /* True iff we're looking at an order-insensitive type-qualifier, including |
| function-type-qualifiers. */ |
| |
| static int |
| next_is_type_qual (struct d_info *di) |
| { |
| char peek = d_peek_char (di); |
| if (peek == 'r' || peek == 'V' || peek == 'K') |
| return 1; |
| if (peek == 'D') |
| { |
| peek = d_peek_next_char (di); |
| if (peek == 'x' || peek == 'o' || peek == 'O' || peek == 'w') |
| return 1; |
| } |
| return 0; |
| } |
| |
| /* <type> ::= <builtin-type> |
| ::= <function-type> |
| ::= <class-enum-type> |
| ::= <array-type> |
| ::= <pointer-to-member-type> |
| ::= <template-param> |
| ::= <template-template-param> <template-args> |
| ::= <substitution> |
| ::= <CV-qualifiers> <type> |
| ::= P <type> |
| ::= R <type> |
| ::= O <type> (C++0x) |
| ::= C <type> |
| ::= G <type> |
| ::= U <source-name> <type> |
| |
| <builtin-type> ::= various one letter codes |
| ::= u <source-name> |
| */ |
| |
| CP_STATIC_IF_GLIBCPP_V3 |
| const struct demangle_builtin_type_info |
| cplus_demangle_builtin_types[D_BUILTIN_TYPE_COUNT] = |
| { |
| /* a */ { NL ("signed char"), NL ("signed char"), D_PRINT_DEFAULT }, |
| /* b */ { NL ("bool"), NL ("boolean"), D_PRINT_BOOL }, |
| /* c */ { NL ("char"), NL ("byte"), D_PRINT_DEFAULT }, |
| /* d */ { NL ("double"), NL ("double"), D_PRINT_FLOAT }, |
| /* e */ { NL ("long double"), NL ("long double"), D_PRINT_FLOAT }, |
| /* f */ { NL ("float"), NL ("float"), D_PRINT_FLOAT }, |
| /* g */ { NL ("__float128"), NL ("__float128"), D_PRINT_FLOAT }, |
| /* h */ { NL ("unsigned char"), NL ("unsigned char"), D_PRINT_DEFAULT }, |
| /* i */ { NL ("int"), NL ("int"), D_PRINT_INT }, |
| /* j */ { NL ("unsigned int"), NL ("unsigned"), D_PRINT_UNSIGNED }, |
| /* k */ { NULL, 0, NULL, 0, D_PRINT_DEFAULT }, |
| /* l */ { NL ("long"), NL ("long"), D_PRINT_LONG }, |
| /* m */ { NL ("unsigned long"), NL ("unsigned long"), D_PRINT_UNSIGNED_LONG }, |
| /* n */ { NL ("__int128"), NL ("__int128"), D_PRINT_DEFAULT }, |
| /* o */ { NL ("unsigned __int128"), NL ("unsigned __int128"), |
| D_PRINT_DEFAULT }, |
| /* p */ { NULL, 0, NULL, 0, D_PRINT_DEFAULT }, |
| /* q */ { NULL, 0, NULL, 0, D_PRINT_DEFAULT }, |
| /* r */ { NULL, 0, NULL, 0, D_PRINT_DEFAULT }, |
| /* s */ { NL ("short"), NL ("short"), D_PRINT_DEFAULT }, |
| /* t */ { NL ("unsigned short"), NL ("unsigned short"), D_PRINT_DEFAULT }, |
| /* u */ { NULL, 0, NULL, 0, D_PRINT_DEFAULT }, |
| /* v */ { NL ("void"), NL ("void"), D_PRINT_VOID }, |
| /* w */ { NL ("wchar_t"), NL ("char"), D_PRINT_DEFAULT }, |
| /* x */ { NL ("long long"), NL ("long"), D_PRINT_LONG_LONG }, |
| /* y */ { NL ("unsigned long long"), NL ("unsigned long long"), |
| D_PRINT_UNSIGNED_LONG_LONG }, |
| /* z */ { NL ("..."), NL ("..."), D_PRINT_DEFAULT }, |
| /* 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 ("char8_t"), NL ("char8_t"), D_PRINT_DEFAULT }, |
| /* 31 */ { NL ("char16_t"), NL ("char16_t"), D_PRINT_DEFAULT }, |
| /* 32 */ { NL ("char32_t"), NL ("char32_t"), D_PRINT_DEFAULT }, |
| /* 33 */ { NL ("decltype(nullptr)"), NL ("decltype(nullptr)"), |
| D_PRINT_DEFAULT }, |
| /* 34 */ { NL ("_Float"), NL ("_Float"), D_PRINT_FLOAT }, |
| /* 35 */ { NL ("std::bfloat16_t"), NL ("std::bfloat16_t"), D_PRINT_FLOAT }, |
| }; |
| |
| CP_STATIC_IF_GLIBCPP_V3 |
| struct demangle_component * |
| cplus_demangle_type (struct d_info *di) |
| { |
| char peek; |
| struct demangle_component *ret; |
| int can_subst; |
| |
| /* The ABI specifies that when CV-qualifiers are used, the base type |
| is substitutable, and the fully qualified type is substitutable, |
| but the base type with a strict subset of the CV-qualifiers is |
| not substitutable. The natural recursive implementation of the |
| CV-qualifiers would cause subsets to be substitutable, so instead |
| we pull them all off now. |
| |
| FIXME: The ABI says that order-insensitive vendor qualifiers |
| should be handled in the same way, but we have no way to tell |
| which vendor qualifiers are order-insensitive and which are |
| order-sensitive. So we just assume that they are all |
| order-sensitive. g++ 3.4 supports only one vendor qualifier, |
| __vector, and it treats it as order-sensitive when mangling |
| names. */ |
| |
| if (next_is_type_qual (di)) |
| { |
| struct demangle_component **pret; |
| |
| pret = d_cv_qualifiers (di, &ret, 0); |
| if (pret == NULL) |
| return NULL; |
| if (d_peek_char (di) == 'F') |
| { |
| /* cv-qualifiers before a function type apply to 'this', |
| so avoid adding the unqualified function type to |
| the substitution list. */ |
| *pret = d_function_type (di); |
| } |
| else |
| *pret = cplus_demangle_type (di); |
| if (!*pret) |
| return NULL; |
| if ((*pret)->type == DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS |
| || (*pret)->type == DEMANGLE_COMPONENT_REFERENCE_THIS) |
| { |
| /* Move the ref-qualifier outside the cv-qualifiers so that |
| they are printed in the right order. */ |
| struct demangle_component *fn = d_left (*pret); |
| d_left (*pret) = ret; |
| ret = *pret; |
| *pret = fn; |
| } |
| if (! d_add_substitution (di, ret)) |
| return NULL; |
| return ret; |
| } |
| |
| can_subst = 1; |
| |
| peek = d_peek_char (di); |
| switch (peek) |
| { |
| case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': case 'g': |
| case 'h': case 'i': case 'j': case 'l': case 'm': case 'n': |
| case 'o': case 's': case 't': |
| case 'v': case 'w': case 'x': case 'y': case 'z': |
| ret = d_make_builtin_type (di, |
| &cplus_demangle_builtin_types[peek - 'a']); |
| di->expansion += ret->u.s_builtin.type->len; |
| can_subst = 0; |
| d_advance (di, 1); |
| break; |
| |
| case 'u': |
| d_advance (di, 1); |
| ret = d_make_comp (di, DEMANGLE_COMPONENT_VENDOR_TYPE, |
| d_source_name (di), NULL); |
| break; |
| |
| case 'F': |
| ret = d_function_type (di); |
| break; |
| |
| case 'A': |
| ret = d_array_type (di); |
| break; |
| |
| case 'M': |
| ret = d_pointer_to_member_type (di); |
| break; |
| |
| case 'T': |
| ret = d_template_param (di); |
| if (d_peek_char (di) == 'I') |
| { |
| /* This may be <template-template-param> <template-args>. |
| If this is the type for a conversion operator, we can |
| have a <template-template-param> here only by following |
| a derivation like this: |
| |
| <nested-name> |
| -> <template-prefix> <template-args> |
| -> <prefix> <template-unqualified-name> <template-args> |
| -> <unqualified-name> <template-unqualified-name> <template-args> |
| -> <source-name> <template-unqualified-name> <template-args> |
| -> <source-name> <operator-name> <template-args> |
| -> <source-name> cv <type> <template-args> |
| -> <source-name> cv <template-template-param> <template-args> <template-args> |
| |
| where the <template-args> is followed by another. |
| Otherwise, we must have a derivation like this: |
| |
| <nested-name> |
| -> <template-prefix> <template-args> |
| -> <prefix> <template-unqualified-name> <template-args> |
| -> <unqualified-name> <template-unqualified-name> <template-args> |
| -> <source-name> <template-unqualified-name> <template-args> |
| -> <source-name> <operator-name> <template-args> |
| -> <source-name> cv <type> <template-args> |
| -> <source-name> cv <template-param> <template-args> |
| |
| where we need to leave the <template-args> to be processed |
| by d_prefix (following the <template-prefix>). |
| |
| The <template-template-param> part is a substitution |
| candidate. */ |
| if (! di->is_conversion) |
| { |
| if (! d_add_substitution (di, ret)) |
| return NULL; |
| ret = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, ret, |
| d_template_args (di)); |
| } |
| else |
| { |
| struct demangle_component *args; |
| struct d_info_checkpoint checkpoint; |
| |
| d_checkpoint (di, &checkpoint); |
| args = d_template_args (di); |
| if (d_peek_char (di) == 'I') |
| { |
| if (! d_add_substitution (di, ret)) |
| return NULL; |
| ret = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, ret, |
| args); |
| } |
| else |
| d_backtrack (di, &checkpoint); |
| } |
| } |
| break; |
| |
| 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, |
| cplus_demangle_type (di), NULL); |
| break; |
| |
| case 'R': |
| d_advance (di, 1); |
| ret = d_make_comp (di, DEMANGLE_COMPONENT_REFERENCE, |
| cplus_demangle_type (di), NULL); |
| break; |
| |
| case 'C': |
| d_advance (di, 1); |
| ret = d_make_comp (di, DEMANGLE_COMPONENT_COMPLEX, |
| cplus_demangle_type (di), NULL); |
| break; |
| |
| case 'G': |
| d_advance (di, 1); |
| ret = d_make_comp (di, DEMANGLE_COMPONENT_IMAGINARY, |
| cplus_demangle_type (di), NULL); |
| break; |
| |
| case 'U': |
| d_advance (di, 1); |
| ret = d_source_name (di); |
| if (d_peek_char (di) == 'I') |
| ret = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, ret, |
| d_template_args (di)); |
| ret = d_make_comp (di, DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL, |
| cplus_demangle_type (di), ret); |
| break; |
| |
| case 'D': |
| can_subst = 0; |
| d_advance (di, 1); |
| peek = d_next_char (di); |
| switch (peek) |
| { |
| case 'T': |
| case 't': |
| /* decltype (expression) */ |
| ret = d_make_comp (di, DEMANGLE_COMPONENT_DECLTYPE, |
| d_expression (di), NULL); |
| if (ret && d_next_char (di) != 'E') |
| ret = NULL; |
| can_subst = 1; |
| break; |
| |
| case 'p': |
| /* Pack expansion. */ |
| ret = d_make_comp (di, DEMANGLE_COMPONENT_PACK_EXPANSION, |
| cplus_demangle_type (di), NULL); |
| can_subst = 1; |
| break; |
| |
| case 'a': |
| /* auto */ |
| ret = d_make_name (di, "auto", 4); |
| break; |
| case 'c': |
| /* decltype(auto) */ |
| ret = d_make_name (di, "decltype(auto)", 14); |
| 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 'u': |
| /* char8_t */ |
| ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[30]); |
| di->expansion += ret->u.s_builtin.type->len; |
| break; |
| case 's': |
| /* char16_t */ |
| ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[31]); |
| di->expansion += ret->u.s_builtin.type->len; |
| break; |
| case 'i': |
| /* char32_t */ |
| ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[32]); |
| di->expansion += ret->u.s_builtin.type->len; |
| break; |
| |
| case 'F': |
| /* DF<number>_ - _Float<number>. |
| DF<number>x - _Float<number>x |
| DF16b - std::bfloat16_t. */ |
| { |
| int arg = d_number (di); |
| char buf[12]; |
| char suffix = 0; |
| if (d_peek_char (di) == 'b') |
| { |
| if (arg != 16) |
| return NULL; |
| d_advance (di, 1); |
| ret = d_make_builtin_type (di, |
| &cplus_demangle_builtin_types[35]); |
| di->expansion += ret->u.s_builtin.type->len; |
| break; |
| } |
| if (d_peek_char (di) == 'x') |
| suffix = 'x'; |
| if (!suffix && d_peek_char (di) != '_') |
| return NULL; |
| ret |
| = d_make_extended_builtin_type (di, |
| &cplus_demangle_builtin_types[34], |
| arg, suffix); |
| d_advance (di, 1); |
| sprintf (buf, "%d", arg); |
| di->expansion += ret->u.s_extended_builtin.type->len |
| + strlen (buf) + (suffix != 0); |
| break; |
| } |
| |
| case 'v': |
| ret = d_vector_type (di); |
| can_subst = 1; |
| break; |
| |
| case 'n': |
| /* decltype(nullptr) */ |
| ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[33]); |
| di->expansion += ret->u.s_builtin.type->len; |
| break; |
| |
| default: |
| return NULL; |
| } |
| break; |
| |
| default: |
| return d_class_enum_type (di, 1); |
| } |
| |
| if (can_subst) |
| { |
| if (! d_add_substitution (di, ret)) |
| return NULL; |
| } |
| |
| return ret; |
| } |
| |
| /* <CV-qualifiers> ::= [r] [V] [K] [Dx] */ |
| |
| static struct demangle_component ** |
| d_cv_qualifiers (struct d_info *di, |
| struct demangle_component **pret, int member_fn) |
| { |
| struct demangle_component **pstart; |
| char peek; |
| |
| pstart = pret; |
| peek = d_peek_char (di); |
| while (next_is_type_qual (di)) |
| { |
| enum demangle_component_type t; |
| struct demangle_component *right = NULL; |
| |
| d_advance (di, 1); |
| if (peek == 'r') |
| { |
| t = (member_fn |
| ? DEMANGLE_COMPONENT_RESTRICT_THIS |
| : DEMANGLE_COMPONENT_RESTRICT); |
| di->expansion += sizeof "restrict"; |
| } |
| else if (peek == 'V') |
| { |
| t = (member_fn |
| ? DEMANGLE_COMPONENT_VOLATILE_THIS |
| : DEMANGLE_COMPONENT_VOLATILE); |
| di->expansion += sizeof "volatile"; |
| } |
| else if (peek == 'K') |
| { |
| t = (member_fn |
| ? DEMANGLE_COMPONENT_CONST_THIS |
| : DEMANGLE_COMPONENT_CONST); |
| di->expansion += sizeof "const"; |
| } |
| else |
| { |
| peek = d_next_char (di); |
| if (peek == 'x') |
| { |
| t = DEMANGLE_COMPONENT_TRANSACTION_SAFE; |
| di->expansion += sizeof "transaction_safe"; |
| } |
| else if (peek == 'o' |
| || peek == 'O') |
| { |
| t = DEMANGLE_COMPONENT_NOEXCEPT; |
| di->expansion += sizeof "noexcept"; |
| if (peek == 'O') |
| { |
| right = d_expression (di); |
| if (right == NULL) |
| return NULL; |
| if (! d_check_char (di, 'E')) |
| return NULL; |
| } |
| } |
| else if (peek == 'w') |
| { |
| t = DEMANGLE_COMPONENT_THROW_SPEC; |
| di->expansion += sizeof "throw"; |
| right = d_parmlist (di); |
| if (right == NULL) |
| return NULL; |
| if (! d_check_char (di, 'E')) |
| return NULL; |
| } |
| else |
| return NULL; |
| } |
| |
| *pret = d_make_comp (di, t, NULL, right); |
| if (*pret == NULL) |
| return NULL; |
| pret = &d_left (*pret); |
| |
| peek = d_peek_char (di); |
| } |
| |
| if (!member_fn && peek == 'F') |
| { |
| while (pstart != pret) |
| { |
| switch ((*pstart)->type) |
| { |
| case DEMANGLE_COMPONENT_RESTRICT: |
| (*pstart)->type = DEMANGLE_COMPONENT_RESTRICT_THIS; |
| break; |
| case DEMANGLE_COMPONENT_VOLATILE: |
| (*pstart)->type = DEMANGLE_COMPONENT_VOLATILE_THIS; |
| break; |
| case DEMANGLE_COMPONENT_CONST: |
| (*pstart)->type = DEMANGLE_COMPONENT_CONST_THIS; |
| break; |
| default: |
| break; |
| } |
| pstart = &d_left (*pstart); |
| } |
| } |
| |
| return pret; |
| } |
| |
| /* <ref-qualifier> ::= R |
| ::= O */ |
| |
| static struct demangle_component * |
| d_ref_qualifier (struct d_info *di, struct demangle_component *sub) |
| { |
| struct demangle_component *ret = sub; |
| char peek; |
| |
| peek = d_peek_char (di); |
| if (peek == 'R' || peek == 'O') |
| { |
| enum demangle_component_type t; |
| if (peek == 'R') |
| { |
| t = DEMANGLE_COMPONENT_REFERENCE_THIS; |
| di->expansion += sizeof "&"; |
| } |
| else |
| { |
| t = DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS; |
| di->expansion += sizeof "&&"; |
| } |
| d_advance (di, 1); |
| |
| ret = d_make_comp (di, t, ret, NULL); |
| } |
| |
| return ret; |
| } |
| |
| /* <function-type> ::= F [Y] <bare-function-type> [<ref-qualifier>] [T] E */ |
| |
| static struct demangle_component * |
| d_function_type (struct d_info *di) |
| { |
| struct demangle_component *ret = NULL; |
| |
| if ((di->options & DMGL_NO_RECURSE_LIMIT) == 0) |
| { |
| if (di->recursion_level > DEMANGLE_RECURSION_LIMIT) |
| /* FIXME: There ought to be a way to report |
| that the recursion limit has been reached. */ |
| return NULL; |
| |
| di->recursion_level ++; |
| } |
| |
| if (d_check_char (di, 'F')) |
| { |
| if (d_peek_char (di) == 'Y') |
| { |
| /* Function has C linkage. We don't print this information. |
| FIXME: We should print it in verbose mode. */ |
| d_advance (di, 1); |
| } |
| ret = d_bare_function_type (di, 1); |
| ret = d_ref_qualifier (di, ret); |
| |
| if (! d_check_char (di, 'E')) |
| ret = NULL; |
| } |
| |
| if ((di->options & DMGL_NO_RECURSE_LIMIT) == 0) |
| di->recursion_level --; |
| return ret; |
| } |
| |
| /* <type>+ */ |
| |
| static struct demangle_component * |
| d_parmlist (struct d_info *di) |
| { |
| struct demangle_component *tl; |
| struct demangle_component **ptl; |
| |
| tl = NULL; |
| ptl = &tl; |
| while (1) |
| { |
| struct demangle_component *type; |
| |
| char peek = d_peek_char (di); |
| if (peek == '\0' || peek == 'E' || peek == '.' || peek == 'Q') |
| break; |
| if ((peek == 'R' || peek == 'O') |
| && d_peek_next_char (di) == 'E') |
| /* Function ref-qualifier, not a ref prefix for a parameter type. */ |
| break; |
| type = cplus_demangle_type (di); |
| if (type == NULL) |
| return NULL; |
| *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 |
| return type. A function which takes no arguments will have a |
| single parameter type void. */ |
| if (tl == NULL) |
| return NULL; |
| |
| /* If we have a single parameter type void, omit it. */ |
| if (d_right (tl) == NULL |
| && d_left (tl)->type == DEMANGLE_COMPONENT_BUILTIN_TYPE |
| && d_left (tl)->u.s_builtin.type->print == D_PRINT_VOID) |
| { |
| di->expansion -= d_left (tl)->u.s_builtin.type->len; |
| d_left (tl) = NULL; |
| } |
| |
| return tl; |
| } |
| |
| /* <bare-function-type> ::= [J]<type>+ */ |
| |
| 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; |
| |
| tl = d_parmlist (di); |
| if (tl == NULL) |
| return NULL; |
| |
| return d_make_comp (di, DEMANGLE_COMPONENT_FUNCTION_TYPE, |
| return_type, tl); |
| } |
| |
| /* <class-enum-type> ::= <name> */ |
| |
| static struct demangle_component * |
| d_class_enum_type (struct d_info *di, int substable) |
| { |
| return d_name (di, substable); |
| } |
| |
| /* <array-type> ::= A <(positive dimension) number> _ <(element) type> |
| ::= A [<(dimension) expression>] _ <(element) type> |
| */ |
| |
| static struct demangle_component * |
| d_array_type (struct d_info *di) |
| { |
| char peek; |
| struct demangle_component *dim; |
| |
| if (! d_check_char (di, 'A')) |
| return NULL; |
| |
| peek = d_peek_char (di); |
| if (peek == '_') |
| dim = NULL; |
| else if (IS_DIGIT (peek)) |
| { |
| const char *s; |
| |