-/* Demangler for IA64 / g++ V3 ABI.
- Copyright (C) 2000, 2001, 2002 Free Software Foundation, Inc.
- Written by Alex Samuel <samuel@codesourcery.com>.
+/* Demangler for g++ V3 ABI.
+ Copyright (C) 2003 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.
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
-/* This file implements demangling of C++ names mangled according to
- the IA64 / g++ V3 ABI. Use the cp_demangle function to
- demangle a mangled name, or compile with the preprocessor macro
- STANDALONE_DEMANGLER defined to create a demangling filter
- executable (functionally similar to c++filt, but includes this
- demangler only). */
-
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
-#include <sys/types.h>
+#include <stdio.h>
#ifdef HAVE_STDLIB_H
#include <stdlib.h>
#endif
-
-#include <stdio.h>
-
#ifdef HAVE_STRING_H
#include <string.h>
#endif
-#include <ctype.h>
-
#include "ansidecl.h"
#include "libiberty.h"
-#include "dyn-string.h"
#include "demangle.h"
-/* If CP_DEMANGLE_DEBUG is defined, a trace of the grammar evaluation,
- and other debugging output, will be generated. */
-#ifdef CP_DEMANGLE_DEBUG
-#define DEMANGLE_TRACE(PRODUCTION, DM) \
- fprintf (stderr, " -> %-24s at position %3d\n", \
- (PRODUCTION), current_position (DM));
-#else
-#define DEMANGLE_TRACE(PRODUCTION, DM)
-#endif
+/* This code implements a demangler for the g++ V3 ABI. The ABI is
+ described on this web page:
+ http://www.codesourcery.com/cxx-abi/abi.html#mangling
-/* Don't include <ctype.h>, to prevent additional unresolved symbols
- from being dragged into the C++ runtime library. */
-#define IS_DIGIT(CHAR) ((CHAR) >= '0' && (CHAR) <= '9')
-#define IS_ALPHA(CHAR) \
- (((CHAR) >= 'a' && (CHAR) <= 'z') \
- || ((CHAR) >= 'A' && (CHAR) <= 'Z'))
+ 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. */
+
+/* Avoid pulling in the ctype tables for this simple usage. */
+#define IS_DIGIT(c) ((c) >= '0' && (c) <= '9')
/* The prefix prepended by GCC to an identifier represnting the
anonymous namespace. */
#define ANONYMOUS_NAMESPACE_PREFIX "_GLOBAL_"
+#define ANONYMOUS_NAMESPACE_PREFIX_LEN \
+ (sizeof (ANONYMOUS_NAMESPACE_PREFIX) - 1)
-/* Character(s) to use for namespace separation in demangled output */
-#define NAMESPACE_SEPARATOR (dm->style == DMGL_JAVA ? "." : "::")
-
-/* If flag_verbose is zero, some simplifications will be made to the
- output to make it easier to read and supress details that are
- generally not of interest to the average C++ programmer.
- Otherwise, the demangled representation will attempt to convey as
- much information as the mangled form. */
-static int flag_verbose;
+/* Information we keep for operators. */
-/* If flag_strict is non-zero, demangle strictly according to the
- specification -- don't demangle special g++ manglings. */
-static int flag_strict;
-
-/* String_list_t is an extended form of dyn_string_t which provides a
- link field and a caret position for additions to the string. A
- string_list_t may safely be cast to and used as a dyn_string_t. */
-
-struct string_list_def
+struct d_operator_info
{
- /* The dyn_string; must be first. */
- struct dyn_string string;
+ /* Mangled name. */
+ const char *code;
+ /* Real name. */
+ const char *name;
+ /* Number of arguments. */
+ int args;
+};
- /* The position at which additional text is added to this string
- (using the result_add* macros). This value is an offset from the
- end of the string, not the beginning (and should be
- non-positive). */
- int caret_position;
+/* How to print the value of a builtin type. */
- /* The next string in the list. */
- struct string_list_def *next;
+enum d_builtin_type_print
+{
+ /* Print as (type)val. */
+ D_PRINT_DEFAULT,
+ /* Print as integer. */
+ D_PRINT_INT,
+ /* Print as long, with trailing `l'. */
+ D_PRINT_LONG,
+ /* Print as bool. */
+ D_PRINT_BOOL,
+ /* Print in usual way, but here to detect void. */
+ D_PRINT_VOID
};
-typedef struct string_list_def *string_list_t;
-
-/* Data structure representing a potential substitution. */
+/* Information we keep for a builtin type. */
-struct substitution_def
+struct d_builtin_type_info
{
- /* The demangled text of the substitution. */
- dyn_string_t text;
+ /* Type name. */
+ const char *name;
+ /* Type name when using Java. */
+ const char *java_name;
+ /* How to print a value of this type. */
+ enum d_builtin_type_print print;
+};
- /* Whether this substitution represents a template item. */
- int template_p : 1;
+/* Component types found in mangled names. */
+
+enum d_comp_type
+{
+ /* A name. */
+ D_COMP_NAME,
+ /* A qualified name. */
+ D_COMP_QUAL_NAME,
+ /* A typed name. */
+ D_COMP_TYPED_NAME,
+ /* A template. */
+ D_COMP_TEMPLATE,
+ /* A template parameter. */
+ D_COMP_TEMPLATE_PARAM,
+ /* A constructor. */
+ D_COMP_CTOR,
+ /* A destructor. */
+ D_COMP_DTOR,
+ /* A vtable. */
+ D_COMP_VTABLE,
+ /* A VTT structure. */
+ D_COMP_VTT,
+ /* A construction vtable. */
+ D_COMP_CONSTRUCTION_VTABLE,
+ /* A typeinfo structure. */
+ D_COMP_TYPEINFO,
+ /* A typeinfo name. */
+ D_COMP_TYPEINFO_NAME,
+ /* A typeinfo function. */
+ D_COMP_TYPEINFO_FN,
+ /* A thunk. */
+ D_COMP_THUNK,
+ /* A virtual thunk. */
+ D_COMP_VIRTUAL_THUNK,
+ /* A covariant thunk. */
+ D_COMP_COVARIANT_THUNK,
+ /* A Java class. */
+ D_COMP_JAVA_CLASS,
+ /* A guard variable. */
+ D_COMP_GUARD,
+ /* A reference temporary. */
+ D_COMP_REFTEMP,
+ /* A standard substitution. */
+ D_COMP_SUB_STD,
+ /* The restrict qualifier. */
+ D_COMP_RESTRICT,
+ /* The volatile qualifier. */
+ D_COMP_VOLATILE,
+ /* The const qualifier. */
+ D_COMP_CONST,
+ /* A vendor qualifier. */
+ D_COMP_VENDOR_TYPE_QUAL,
+ /* A pointer. */
+ D_COMP_POINTER,
+ /* A reference. */
+ D_COMP_REFERENCE,
+ /* A complex type. */
+ D_COMP_COMPLEX,
+ /* An imaginary type. */
+ D_COMP_IMAGINARY,
+ /* A builtin type. */
+ D_COMP_BUILTIN_TYPE,
+ /* A vendor's builtin type. */
+ D_COMP_VENDOR_TYPE,
+ /* A function type. */
+ D_COMP_FUNCTION_TYPE,
+ /* An array type. */
+ D_COMP_ARRAY_TYPE,
+ /* A pointer to member type. */
+ D_COMP_PTRMEM_TYPE,
+ /* An argument list. */
+ D_COMP_ARGLIST,
+ /* A template argument list. */
+ D_COMP_TEMPLATE_ARGLIST,
+ /* An operator. */
+ D_COMP_OPERATOR,
+ /* An extended operator. */
+ D_COMP_EXTENDED_OPERATOR,
+ /* A typecast. */
+ D_COMP_CAST,
+ /* A unary expression. */
+ D_COMP_UNARY,
+ /* A binary expression. */
+ D_COMP_BINARY,
+ /* Arguments to a binary expression. */
+ D_COMP_BINARY_ARGS,
+ /* A trinary expression. */
+ D_COMP_TRINARY,
+ /* Arguments to a trinary expression. */
+ D_COMP_TRINARY_ARG1,
+ D_COMP_TRINARY_ARG2,
+ /* A literal. */
+ D_COMP_LITERAL
};
-/* Data structure representing a template argument list. */
+/* A component of the mangled name. */
-struct template_arg_list_def
+struct d_comp
{
- /* The next (lower) template argument list in the stack of currently
- active template arguments. */
- struct template_arg_list_def *next;
+ /* The type of this component. */
+ enum d_comp_type type;
+ union
+ {
+ /* For D_COMP_NAME. */
+ struct
+ {
+ /* A pointer to the name (not NULL terminated) and it's
+ length. */
+ const char *s;
+ int len;
+ } s_name;
- /* The first element in the list of template arguments in
- left-to-right order. */
- string_list_t first_argument;
+ /* For D_COMP_OPERATOR. */
+ struct
+ {
+ /* Operator. */
+ const struct d_operator_info *op;
+ } s_operator;
- /* The last element in the arguments lists. */
- string_list_t last_argument;
-};
+ /* For D_COMP_EXTENDED_OPERATOR. */
+ struct
+ {
+ /* Number of arguments. */
+ int args;
+ /* Name. */
+ struct d_comp *name;
+ } s_extended_operator;
-typedef struct template_arg_list_def *template_arg_list_t;
+ /* For D_COMP_CTOR. */
+ struct
+ {
+ enum gnu_v3_ctor_kinds kind;
+ struct d_comp *name;
+ } s_ctor;
-/* Data structure to maintain the state of the current demangling. */
+ /* For D_COMP_DTOR. */
+ struct
+ {
+ enum gnu_v3_dtor_kinds kind;
+ struct d_comp *name;
+ } s_dtor;
-struct demangling_def
-{
- /* The full mangled name being mangled. */
- const char *name;
+ /* For D_COMP_BUILTIN_TYPE. */
+ struct
+ {
+ const struct d_builtin_type_info *type;
+ } s_builtin;
+
+ /* For D_COMP_SUB_STD. */
+ struct
+ {
+ const char* string;
+ } s_string;
- /* Pointer into name at the current position. */
- const char *next;
+ /* For D_COMP_TEMPLATE_PARAM. */
+ struct
+ {
+ long number;
+ } s_number;
- /* Stack for strings containing demangled result generated so far.
- Text is emitted to the topmost (first) string. */
- string_list_t result;
+ /* For other types. */
+ struct
+ {
+ struct d_comp *left;
+ struct d_comp *right;
+ } s_binary;
- /* The number of presently available substitutions. */
- int num_substitutions;
+ } u;
+};
- /* The allocated size of the substitutions array. */
- int substitutions_allocated;
+#define d_left(dc) ((dc)->u.s_binary.left)
+#define d_right(dc) ((dc)->u.s_binary.right)
+
+/* The information structure we pass around. */
+
+struct d_info
+{
+ /* The string we are demangling. */
+ const char *s;
+ /* The options passed to the demangler. */
+ int options;
+ /* The next character in the string to consider. */
+ const char *n;
+ /* The array of components. */
+ struct d_comp *comps;
+ /* The index of the next available component. */
+ int next_comp;
+ /* The number of available component structures. */
+ int num_comps;
+ /* The array of substitutions. */
+ struct d_comp **subs;
+ /* The index of the next substitution. */
+ int next_sub;
+ /* The number of available entries in the subs array. */
+ int num_subs;
+ /* The last name we saw, for constructors and destructors. */
+ struct d_comp *last_name;
+};
- /* An array of available substitutions. The number of elements in
- the array is given by num_substitions, and the allocated array
- size in substitutions_size.
+#define d_peek_char(di) (*((di)->n))
+#define d_peek_next_char(di) ((di)->n[1])
+#define d_advance(di, i) ((di)->n += (i))
+#define d_next_char(di) (*((di)->n++))
+#define d_str(di) ((di)->n)
- The most recent substition is at the end, so
+/* A list of templates. This is used while printing. */
- - `S_' corresponds to substititutions[num_substitutions - 1]
- - `S0_' corresponds to substititutions[num_substitutions - 2]
+struct d_print_template
+{
+ /* Next template on the list. */
+ struct d_print_template *next;
+ /* This template. */
+ const struct d_comp *template;
+};
- etc. */
- struct substitution_def *substitutions;
+/* A list of type modifiers. This is used while printing. */
- /* The stack of template argument lists. */
- template_arg_list_t template_arg_lists;
+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. */
+ const struct d_comp *mod;
+ /* Whether this modifier was printed. */
+ int printed;
+};
- /* The most recently demangled source-name. */
- dyn_string_t last_source_name;
-
- /* Language style to use for demangled output. */
- int style;
+/* We use this structure to hold information during printing. */
+
+struct d_print_info
+{
+ /* 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;
+ /* 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 non-zero iff this name is a constructor. The actual value
- indicates what sort of constructor this is; see demangle.h. */
- enum gnu_v3_ctor_kinds is_constructor;
+#define d_print_saw_error(dpi) ((dpi)->buf == NULL)
- /* Set to non-zero iff this name is a destructor. The actual value
- indicates what sort of destructor this is; see demangle.h. */
- enum gnu_v3_dtor_kinds is_destructor;
+#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)
-typedef struct demangling_def *demangling_t;
-
-/* This type is the standard return code from most functions. Values
- other than STATUS_OK contain descriptive messages. */
-typedef const char *status_t;
-
-/* Special values that can be used as a status_t. */
-#define STATUS_OK NULL
-#define STATUS_ERROR "Error."
-#define STATUS_UNIMPLEMENTED "Unimplemented."
-#define STATUS_INTERNAL_ERROR "Internal error."
-
-/* This status code indicates a failure in malloc or realloc. */
-static const char *const status_allocation_failed = "Allocation failed.";
-#define STATUS_ALLOCATION_FAILED status_allocation_failed
-
-/* Non-zero if STATUS indicates that no error has occurred. */
-#define STATUS_NO_ERROR(STATUS) ((STATUS) == STATUS_OK)
-
-/* Evaluate EXPR, which must produce a status_t. If the status code
- indicates an error, return from the current function with that
- status code. */
-#define RETURN_IF_ERROR(EXPR) \
- do \
- { \
- status_t s = EXPR; \
- if (!STATUS_NO_ERROR (s)) \
- return s; \
- } \
+#define d_append_string(dpi, s) \
+ do \
+ { \
+ size_t d_append_string_len = strlen (s); \
+ d_append_buffer ((dpi), (s), d_append_string_len); \
+ } \
while (0)
-static status_t int_to_dyn_string
- PARAMS ((int, dyn_string_t));
-static string_list_t string_list_new
- PARAMS ((int));
-static void string_list_delete
- PARAMS ((string_list_t));
-static status_t result_add_separated_char
- PARAMS ((demangling_t, int));
-static status_t result_push
- PARAMS ((demangling_t));
-static string_list_t result_pop
- PARAMS ((demangling_t));
-static int substitution_start
- PARAMS ((demangling_t));
-static status_t substitution_add
- PARAMS ((demangling_t, int, int));
-static dyn_string_t substitution_get
- PARAMS ((demangling_t, int, int *));
#ifdef CP_DEMANGLE_DEBUG
-static void substitutions_print
- PARAMS ((demangling_t, FILE *));
+static void d_dump PARAMS ((struct d_comp *, int));
#endif
-static template_arg_list_t template_arg_list_new
- PARAMS ((void));
-static void template_arg_list_delete
- PARAMS ((template_arg_list_t));
-static void template_arg_list_add_arg
- PARAMS ((template_arg_list_t, string_list_t));
-static string_list_t template_arg_list_get_arg
- PARAMS ((template_arg_list_t, int));
-static void push_template_arg_list
- PARAMS ((demangling_t, template_arg_list_t));
-static void pop_to_template_arg_list
- PARAMS ((demangling_t, template_arg_list_t));
+static struct d_comp *d_make_empty PARAMS ((struct d_info *,
+ enum d_comp_type));
+static struct d_comp *d_make_comp PARAMS ((struct d_info *, enum d_comp_type,
+ struct d_comp *, struct d_comp *));
+static struct d_comp *d_make_name PARAMS ((struct d_info *, const char *,
+ int));
+static struct d_comp *d_make_builtin_type PARAMS ((struct d_info *,
+ const struct d_builtin_type_info *));
+static struct d_comp *d_make_operator PARAMS ((struct d_info *,
+ const struct d_operator_info *));
+static struct d_comp *d_make_extended_operator PARAMS ((struct d_info *,
+ int,
+ struct d_comp *));
+static struct d_comp *d_make_ctor PARAMS ((struct d_info *,
+ enum gnu_v3_ctor_kinds,
+ struct d_comp *));
+static struct d_comp *d_make_dtor PARAMS ((struct d_info *,
+ enum gnu_v3_dtor_kinds,
+ struct d_comp *));
+static struct d_comp *d_make_template_param PARAMS ((struct d_info *, long));
+static struct d_comp *d_make_sub PARAMS ((struct d_info *, const char *));
+static struct d_comp *d_mangled_name PARAMS ((struct d_info *));
+static int has_return_type PARAMS ((struct d_comp *));
+static int is_ctor_dtor_or_conversion PARAMS ((struct d_comp *));
+static struct d_comp *d_encoding PARAMS ((struct d_info *));
+static struct d_comp *d_name PARAMS ((struct d_info *));
+static struct d_comp *d_nested_name PARAMS ((struct d_info *));
+static struct d_comp *d_prefix PARAMS ((struct d_info *));
+static struct d_comp *d_unqualified_name PARAMS ((struct d_info *));
+static struct d_comp *d_source_name PARAMS ((struct d_info *));
+static long d_number PARAMS ((struct d_info *));
+static struct d_comp *d_identifier PARAMS ((struct d_info *, int));
+static struct d_comp *d_operator_name PARAMS ((struct d_info *));
+static struct d_comp *d_special_name PARAMS ((struct d_info *));
+static int d_call_offset PARAMS ((struct d_info *, int));
+static struct d_comp *d_ctor_dtor_name PARAMS ((struct d_info *));
+static struct d_comp *d_type PARAMS ((struct d_info *));
+static struct d_comp **d_cv_qualifiers PARAMS ((struct d_info *,
+ struct d_comp **));
+static struct d_comp *d_function_type PARAMS ((struct d_info *));
+static struct d_comp *d_bare_function_type PARAMS ((struct d_info *, int));
+static struct d_comp *d_class_enum_type PARAMS ((struct d_info *));
+static struct d_comp *d_array_type PARAMS ((struct d_info *));
+static struct d_comp *d_pointer_to_member_type PARAMS ((struct d_info *));
+static struct d_comp *d_template_param PARAMS ((struct d_info *));
+static struct d_comp *d_template_args PARAMS ((struct d_info *));
+static struct d_comp *d_template_arg PARAMS ((struct d_info *));
+static struct d_comp *d_expression PARAMS ((struct d_info *));
+static struct d_comp *d_expr_primary PARAMS ((struct d_info *));
+static struct d_comp *d_local_name PARAMS ((struct d_info *));
+static int d_discriminator PARAMS ((struct d_info *));
+static int d_add_substitution PARAMS ((struct d_info *, struct d_comp *));
+static struct d_comp *d_substitution PARAMS ((struct d_info *));
+static void d_print_resize PARAMS ((struct d_print_info *, size_t));
+static void d_print_append_char PARAMS ((struct d_print_info *, int));
+static void d_print_append_buffer PARAMS ((struct d_print_info *, const char *,
+ size_t));
+static void d_print_error PARAMS ((struct d_print_info *));
+static char *d_print PARAMS ((int, const struct d_comp *, size_t *));
+static void d_print_comp PARAMS ((struct d_print_info *,
+ const struct d_comp *));
+static void d_print_identifier PARAMS ((struct d_print_info *, const char *,
+ int));
+static void d_print_mod_list PARAMS ((struct d_print_info *,
+ struct d_print_mod *));
+static void d_print_mod PARAMS ((struct d_print_info *,
+ const struct d_comp *));
+static void d_print_function_type PARAMS ((struct d_print_info *,
+ const struct d_comp *,
+ struct d_print_mod *));
+static void d_print_array_type PARAMS ((struct d_print_info *,
+ const struct d_comp *,
+ struct d_print_mod *));
+static void d_print_expr_op PARAMS ((struct d_print_info *,
+ const struct d_comp *));
+static void d_print_cast PARAMS ((struct d_print_info *,
+ const struct d_comp *));
+static int d_init_info PARAMS ((const char *, int, size_t, struct d_info *));
+static char *d_demangle PARAMS ((const char *, int, size_t *));
+
#ifdef CP_DEMANGLE_DEBUG
-static void template_arg_list_print
- PARAMS ((template_arg_list_t, FILE *));
-#endif
-static template_arg_list_t current_template_arg_list
- PARAMS ((demangling_t));
-static demangling_t demangling_new
- PARAMS ((const char *, int));
-static void demangling_delete
- PARAMS ((demangling_t));
-
-/* The last character of DS. Warning: DS is evaluated twice. */
-#define dyn_string_last_char(DS) \
- (dyn_string_buf (DS)[dyn_string_length (DS) - 1])
-
-/* Append a space character (` ') to DS if it does not already end
- with one. Evaluates to 1 on success, or 0 on allocation failure. */
-#define dyn_string_append_space(DS) \
- ((dyn_string_length (DS) > 0 \
- && dyn_string_last_char (DS) != ' ') \
- ? dyn_string_append_char ((DS), ' ') \
- : 1)
-
-/* Returns the index of the current position in the mangled name. */
-#define current_position(DM) ((DM)->next - (DM)->name)
-
-/* Returns the character at the current position of the mangled name. */
-#define peek_char(DM) (*((DM)->next))
-
-/* Returns the character one past the current position of the mangled
- name. */
-#define peek_char_next(DM) \
- (peek_char (DM) == '\0' ? '\0' : (*((DM)->next + 1)))
-
-/* Returns the character at the current position, and advances the
- current position to the next character. */
-#define next_char(DM) (*((DM)->next)++)
-
-/* Returns non-zero if the current position is the end of the mangled
- name, i.e. one past the last character. */
-#define end_of_name_p(DM) (peek_char (DM) == '\0')
-
-/* Advances the current position by one character. */
-#define advance_char(DM) (++(DM)->next)
-
-/* Returns the string containing the current demangled result. */
-#define result_string(DM) (&(DM)->result->string)
-
-/* Returns the position at which new text is inserted into the
- demangled result. */
-#define result_caret_pos(DM) \
- (result_length (DM) + \
- ((string_list_t) result_string (DM))->caret_position)
-
-/* Adds a dyn_string_t to the demangled result. */
-#define result_add_string(DM, STRING) \
- (dyn_string_insert (&(DM)->result->string, \
- result_caret_pos (DM), (STRING)) \
- ? STATUS_OK : STATUS_ALLOCATION_FAILED)
-
-/* Adds NUL-terminated string CSTR to the demangled result. */
-#define result_add(DM, CSTR) \
- (dyn_string_insert_cstr (&(DM)->result->string, \
- result_caret_pos (DM), (CSTR)) \
- ? STATUS_OK : STATUS_ALLOCATION_FAILED)
-
-/* Adds character CHAR to the demangled result. */
-#define result_add_char(DM, CHAR) \
- (dyn_string_insert_char (&(DM)->result->string, \
- result_caret_pos (DM), (CHAR)) \
- ? STATUS_OK : STATUS_ALLOCATION_FAILED)
-
-/* Inserts a dyn_string_t to the demangled result at position POS. */
-#define result_insert_string(DM, POS, STRING) \
- (dyn_string_insert (&(DM)->result->string, (POS), (STRING)) \
- ? STATUS_OK : STATUS_ALLOCATION_FAILED)
-
-/* Inserts NUL-terminated string CSTR to the demangled result at
- position POS. */
-#define result_insert(DM, POS, CSTR) \
- (dyn_string_insert_cstr (&(DM)->result->string, (POS), (CSTR)) \
- ? STATUS_OK : STATUS_ALLOCATION_FAILED)
-
-/* Inserts character CHAR to the demangled result at position POS. */
-#define result_insert_char(DM, POS, CHAR) \
- (dyn_string_insert_char (&(DM)->result->string, (POS), (CHAR)) \
- ? STATUS_OK : STATUS_ALLOCATION_FAILED)
-
-/* The length of the current demangled result. */
-#define result_length(DM) \
- dyn_string_length (&(DM)->result->string)
-
-/* Appends a (less-than, greater-than) character to the result in DM
- to (open, close) a template argument or parameter list. Appends a
- space first if necessary to prevent spurious elision of angle
- brackets with the previous character. */
-#define result_open_template_list(DM) result_add_separated_char(DM, '<')
-#define result_close_template_list(DM) result_add_separated_char(DM, '>')
-
-/* Appends a base 10 representation of VALUE to DS. STATUS_OK on
- success. On failure, deletes DS and returns an error code. */
-
-static status_t
-int_to_dyn_string (value, ds)
- int value;
- dyn_string_t ds;
+
+static void
+d_dump (dc, indent)
+ struct d_comp *dc;
+ int indent;
{
int i;
- int mask = 1;
- /* Handle zero up front. */
- if (value == 0)
- {
- if (!dyn_string_append_char (ds, '0'))
- return STATUS_ALLOCATION_FAILED;
- return STATUS_OK;
+ if (dc == NULL)
+ return;
+
+ for (i = 0; i < indent; ++i)
+ putchar (' ');
+
+ switch (dc->type)
+ {
+ case D_COMP_NAME:
+ printf ("name '%.*s'\n", dc->u.s_name.len, dc->u.s_name.s);
+ return;
+ case D_COMP_TEMPLATE_PARAM:
+ printf ("template parameter %ld\n", dc->u.s_number.number);
+ return;
+ case D_COMP_CTOR:
+ printf ("constructor %d\n", (int) dc->u.s_ctor.kind);
+ d_dump (dc->u.s_ctor.name, indent + 2);
+ return;
+ case D_COMP_DTOR:
+ printf ("destructor %d\n", (int) dc->u.s_dtor.kind);
+ d_dump (dc->u.s_dtor.name, indent + 2);
+ return;
+ case D_COMP_SUB_STD:
+ printf ("standard substitution %s\n", dc->u.s_string.string);
+ return;
+ case D_COMP_BUILTIN_TYPE:
+ printf ("builtin type %s\n", dc->u.s_builtin.type->name);
+ return;
+ case D_COMP_OPERATOR:
+ printf ("operator %s\n", dc->u.s_operator.op->name);
+ return;
+ case D_COMP_EXTENDED_OPERATOR:
+ printf ("extended operator with %d args\n",
+ dc->u.s_extended_operator.args);
+ d_dump (dc->u.s_extended_operator.name, indent + 2);
+ return;
+
+ case D_COMP_QUAL_NAME:
+ printf ("qualified name\n");
+ break;
+ case D_COMP_TYPED_NAME:
+ printf ("typed name\n");
+ break;
+ case D_COMP_TEMPLATE:
+ printf ("template\n");
+ break;
+ case D_COMP_VTABLE:
+ printf ("vtable\n");
+ break;
+ case D_COMP_VTT:
+ printf ("VTT\n");
+ break;
+ case D_COMP_CONSTRUCTION_VTABLE:
+ printf ("construction vtable\n");
+ break;
+ case D_COMP_TYPEINFO:
+ printf ("typeinfo\n");
+ break;
+ case D_COMP_TYPEINFO_NAME:
+ printf ("typeinfo name\n");
+ break;
+ case D_COMP_TYPEINFO_FN:
+ printf ("typeinfo function\n");
+ break;
+ case D_COMP_THUNK:
+ printf ("thunk\n");
+ break;
+ case D_COMP_VIRTUAL_THUNK:
+ printf ("virtual thunk\n");
+ break;
+ case D_COMP_COVARIANT_THUNK:
+ printf ("covariant thunk\n");
+ break;
+ case D_COMP_JAVA_CLASS:
+ printf ("java class\n");
+ break;
+ case D_COMP_GUARD:
+ printf ("guard\n");
+ break;
+ case D_COMP_REFTEMP:
+ printf ("reference temporary\n");
+ break;
+ case D_COMP_RESTRICT:
+ printf ("restrict\n");
+ break;
+ case D_COMP_VOLATILE:
+ printf ("volatile\n");
+ break;
+ case D_COMP_CONST:
+ printf ("const\n");
+ break;
+ case D_COMP_VENDOR_TYPE_QUAL:
+ printf ("vendor type qualifier\n");
+ break;
+ case D_COMP_POINTER:
+ printf ("pointer\n");
+ break;
+ case D_COMP_REFERENCE:
+ printf ("reference\n");
+ break;
+ case D_COMP_COMPLEX:
+ printf ("complex\n");
+ break;
+ case D_COMP_IMAGINARY:
+ printf ("imaginary\n");
+ break;
+ case D_COMP_VENDOR_TYPE:
+ printf ("vendor type\n");
+ break;
+ case D_COMP_FUNCTION_TYPE:
+ printf ("function type\n");
+ break;
+ case D_COMP_ARRAY_TYPE:
+ printf ("array type\n");
+ break;
+ case D_COMP_PTRMEM_TYPE:
+ printf ("pointer to member type\n");
+ break;
+ case D_COMP_ARGLIST:
+ printf ("argument list\n");
+ break;
+ case D_COMP_TEMPLATE_ARGLIST:
+ printf ("template argument list\n");
+ break;
+ case D_COMP_CAST:
+ printf ("cast\n");
+ break;
+ case D_COMP_UNARY:
+ printf ("unary operator\n");
+ break;
+ case D_COMP_BINARY:
+ printf ("binary operator\n");
+ break;
+ case D_COMP_BINARY_ARGS:
+ printf ("binary operator arguments\n");
+ break;
+ case D_COMP_TRINARY:
+ printf ("trinary operator\n");
+ break;
+ case D_COMP_TRINARY_ARG1:
+ printf ("trinary operator arguments 1\n");
+ break;
+ case D_COMP_TRINARY_ARG2:
+ printf ("trinary operator arguments 1\n");
+ break;
+ case D_COMP_LITERAL:
+ printf ("literal\n");
+ break;
}
- /* For negative numbers, emit a minus sign. */
- if (value < 0)
- {
- if (!dyn_string_append_char (ds, '-'))
- return STATUS_ALLOCATION_FAILED;
- value = -value;
+ d_dump (d_left (dc), indent + 2);
+ d_dump (d_right (dc), indent + 2);
+}
+
+#endif /* CP_DEMANGLE_DEBUG */
+
+/* Add a new component. */
+
+static struct d_comp *
+d_make_empty (di, type)
+ struct d_info *di;
+ enum d_comp_type type;
+{
+ struct d_comp *p;
+
+ if (di->next_comp >= di->num_comps)
+ return NULL;
+ p = &di->comps[di->next_comp];
+ p->type = type;
+ ++di->next_comp;
+ return p;
+}
+
+/* Add a new generic component. */
+
+static struct d_comp *
+d_make_comp (di, type, left, right)
+ struct d_info *di;
+ enum d_comp_type type;
+ struct d_comp *left;
+ struct d_comp *right;
+{
+ struct d_comp *p;
+
+ /* We check for errors here. A typical error would be a NULL return
+ from a subroutine. We catch here, and return NULL on upward. */
+ switch (type)
+ {
+ /* These types require two parameters. */
+ case D_COMP_QUAL_NAME:
+ case D_COMP_TYPED_NAME:
+ case D_COMP_TEMPLATE:
+ case D_COMP_VENDOR_TYPE_QUAL:
+ case D_COMP_PTRMEM_TYPE:
+ case D_COMP_UNARY:
+ case D_COMP_BINARY:
+ case D_COMP_BINARY_ARGS:
+ case D_COMP_TRINARY:
+ case D_COMP_TRINARY_ARG1:
+ case D_COMP_TRINARY_ARG2:
+ case D_COMP_LITERAL:
+ if (left == NULL || right == NULL)
+ return NULL;
+ break;
+
+ /* These types only require one parameter. */
+ case D_COMP_VTABLE:
+ case D_COMP_VTT:
+ case D_COMP_CONSTRUCTION_VTABLE:
+ case D_COMP_TYPEINFO:
+ case D_COMP_TYPEINFO_NAME:
+ case D_COMP_TYPEINFO_FN:
+ case D_COMP_THUNK:
+ case D_COMP_VIRTUAL_THUNK:
+ case D_COMP_COVARIANT_THUNK:
+ case D_COMP_JAVA_CLASS:
+ case D_COMP_GUARD:
+ case D_COMP_REFTEMP:
+ case D_COMP_POINTER:
+ case D_COMP_REFERENCE:
+ case D_COMP_COMPLEX:
+ case D_COMP_IMAGINARY:
+ case D_COMP_VENDOR_TYPE:
+ case D_COMP_ARGLIST:
+ case D_COMP_TEMPLATE_ARGLIST:
+ case D_COMP_CAST:
+ if (left == NULL)
+ return NULL;
+ break;
+
+ /* This needs a right parameter, but the left parameter can be
+ empty. */
+ case D_COMP_ARRAY_TYPE:
+ if (right == NULL)
+ return NULL;
+ break;
+
+ /* These are allowed to have no parameters--in some cases they
+ will be filled in later. */
+ case D_COMP_FUNCTION_TYPE:
+ case D_COMP_RESTRICT:
+ case D_COMP_VOLATILE:
+ case D_COMP_CONST:
+ break;
+
+ /* Other types should not be seen here. */
+ default:
+ return NULL;
}
-
- /* Find the power of 10 of the first digit. */
- i = value;
- while (i > 9)
+
+ p = d_make_empty (di, type);
+ if (p != NULL)
{
- mask *= 10;
- i /= 10;
+ p->u.s_binary.left = left;
+ p->u.s_binary.right = right;
}
+ return p;
+}
- /* Write the digits. */
- while (mask > 0)
- {
- int digit = value / mask;
+/* Add a new name component. */
- if (!dyn_string_append_char (ds, '0' + digit))
- return STATUS_ALLOCATION_FAILED;
+static struct d_comp *
+d_make_name (di, s, len)
+ struct d_info *di;
+ const char *s;
+ int len;
+{
+ struct d_comp *p;
- value -= digit * mask;
- mask /= 10;
+ p = d_make_empty (di, D_COMP_NAME);
+ if (p != NULL)
+ {
+ p->u.s_name.s = s;
+ p->u.s_name.len = len;
}
-
- return STATUS_OK;
+ return p;
}
-/* Creates a new string list node. The contents of the string are
- empty, but the initial buffer allocation is LENGTH. The string
- list node should be deleted with string_list_delete. Returns NULL
- if allocation fails. */
+/* Add a new builtin type component. */
-static string_list_t
-string_list_new (length)
- int length;
+static struct d_comp *
+d_make_builtin_type (di, type)
+ struct d_info *di;
+ const struct d_builtin_type_info *type;
{
- string_list_t s = (string_list_t) malloc (sizeof (struct string_list_def));
- s->caret_position = 0;
- if (s == NULL)
- return NULL;
- if (!dyn_string_init ((dyn_string_t) s, length))
- return NULL;
- return s;
-}
+ struct d_comp *p;
+
+ p = d_make_empty (di, D_COMP_BUILTIN_TYPE);
+ if (p != NULL)
+ p->u.s_builtin.type = type;
+ return p;
+}
-/* Deletes the entire string list starting at NODE. */
+/* Add a new operator component. */
-static void
-string_list_delete (node)
- string_list_t node;
+static struct d_comp *
+d_make_operator (di, op)
+ struct d_info *di;
+ const struct d_operator_info *op;
{
- while (node != NULL)
- {
- string_list_t next = node->next;
- dyn_string_delete ((dyn_string_t) node);
- node = next;
- }
+ struct d_comp *p;
+
+ p = d_make_empty (di, D_COMP_OPERATOR);
+ if (p != NULL)
+ p->u.s_operator.op = op;
+ return p;
}
-/* Appends CHARACTER to the demangled result. If the current trailing
- character of the result is CHARACTER, a space is inserted first. */
+/* Add a new extended operator component. */
-static status_t
-result_add_separated_char (dm, character)
- demangling_t dm;
- int character;
+static struct d_comp *
+d_make_extended_operator (di, args, name)
+ struct d_info *di;
+ int args;
+ struct d_comp *name;
{
- char *result = dyn_string_buf (result_string (dm));
- int caret_pos = result_caret_pos (dm);
-
- /* Add a space if the last character is already the character we
- want to add. */
- if (caret_pos > 0 && result[caret_pos - 1] == character)
- RETURN_IF_ERROR (result_add_char (dm, ' '));
- /* Add the character. */
- RETURN_IF_ERROR (result_add_char (dm, character));
+ struct d_comp *p;
- return STATUS_OK;
+ p = d_make_empty (di, D_COMP_EXTENDED_OPERATOR);
+ if (p != NULL)
+ {
+ p->u.s_extended_operator.args = args;
+ p->u.s_extended_operator.name = name;
+ }
+ return p;
}
-/* Allocates and pushes a new string onto the demangled results stack
- for DM. Subsequent demangling with DM will emit to the new string.
- Returns STATUS_OK on success, STATUS_ALLOCATION_FAILED on
- allocation failure. */
+/* Add a new constructor component. */
-static status_t
-result_push (dm)
- demangling_t dm;
+static struct d_comp *
+d_make_ctor (di, kind, name)
+ struct d_info *di;
+ enum gnu_v3_ctor_kinds kind;
+ struct d_comp *name;
{
- string_list_t new_string = string_list_new (0);
- if (new_string == NULL)
- /* Allocation failed. */
- return STATUS_ALLOCATION_FAILED;
-
- /* Link the new string to the front of the list of result strings. */
- new_string->next = (string_list_t) dm->result;
- dm->result = new_string;
- return STATUS_OK;
+ struct d_comp *p;
+
+ p = d_make_empty (di, D_COMP_CTOR);
+ if (p != NULL)
+ {
+ p->u.s_ctor.kind = kind;
+ p->u.s_ctor.name = name;
+ }
+ return p;
}
-/* Removes and returns the topmost element on the demangled results
- stack for DM. The caller assumes ownership for the returned
- string. */
+/* Add a new destructor component. */
-static string_list_t
-result_pop (dm)
- demangling_t dm;
+static struct d_comp *
+d_make_dtor (di, kind, name)
+ struct d_info *di;
+ enum gnu_v3_dtor_kinds kind;
+ struct d_comp *name;
{
- string_list_t top = dm->result;
- dm->result = top->next;
- return top;
+ struct d_comp *p;
+
+ p = d_make_empty (di, D_COMP_DTOR);
+ if (p != NULL)
+ {
+ p->u.s_dtor.kind = kind;
+ p->u.s_dtor.name = name;
+ }
+ return p;
}
-/* Returns the current value of the caret for the result string. The
- value is an offet from the end of the result string. */
+/* Add a new template parameter. */
-static int
-result_get_caret (dm)
- demangling_t dm;
+static struct d_comp *
+d_make_template_param (di, i)
+ struct d_info *di;
+ long i;
{
- return ((string_list_t) result_string (dm))->caret_position;
+ struct d_comp *p;
+
+ p = d_make_empty (di, D_COMP_TEMPLATE_PARAM);
+ if (p != NULL)
+ p->u.s_number.number = i;
+ return p;
}
-/* Sets the value of the caret for the result string, counted as an
- offet from the end of the result string. */
+/* Add a new standard substitution component. */
-static void
-result_set_caret (dm, position)
- demangling_t dm;
- int position;
+static struct d_comp *
+d_make_sub (di, name)
+ struct d_info *di;
+ const char *name;
{
- ((string_list_t) result_string (dm))->caret_position = position;
+ struct d_comp *p;
+
+ p = d_make_empty (di, D_COMP_SUB_STD);
+ if (p != NULL)
+ p->u.s_string.string = name;
+ return p;
}
-/* Shifts the position of the next addition to the result by
- POSITION_OFFSET. A negative value shifts the caret to the left. */
+/* <mangled-name> ::= _Z <encoding> */
-static void
-result_shift_caret (dm, position_offset)
- demangling_t dm;
- int position_offset;
+static struct d_comp *
+d_mangled_name (di)
+ struct d_info *di;
{
- ((string_list_t) result_string (dm))->caret_position += position_offset;
+ if (d_next_char (di) != '_')
+ return NULL;
+ if (d_next_char (di) != 'Z')
+ return NULL;
+ return d_encoding (di);
}
-/* Returns non-zero if the character that comes right before the place
- where text will be added to the result is a space. In this case,
- the caller should supress adding another space. */
+/* 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
-result_previous_char_is_space (dm)
- demangling_t dm;
+has_return_type (dc)
+ struct d_comp *dc;
{
- char *result = dyn_string_buf (result_string (dm));
- int pos = result_caret_pos (dm);
- return pos > 0 && result[pos - 1] == ' ';
+ if (dc == NULL)
+ return 0;
+ switch (dc->type)
+ {
+ default:
+ return 0;
+ case D_COMP_TEMPLATE:
+ return ! is_ctor_dtor_or_conversion (d_left (dc));
+ }
}
-/* Returns the start position of a fragment of the demangled result
- that will be a substitution candidate. Should be called at the
- start of productions that can add substitutions. */
+/* Return whether a name is a constructor, a destructor, or a
+ conversion operator. */
static int
-substitution_start (dm)
- demangling_t dm;
+is_ctor_dtor_or_conversion (dc)
+ struct d_comp *dc;
{
- return result_caret_pos (dm);
+ if (dc == NULL)
+ return 0;
+ switch (dc->type)
+ {
+ default:
+ return 0;
+ case D_COMP_QUAL_NAME:
+ return is_ctor_dtor_or_conversion (d_right (dc));
+ case D_COMP_CTOR:
+ case D_COMP_DTOR:
+ case D_COMP_CAST:
+ return 1;
+ }
}
-/* Adds the suffix of the current demangled result of DM starting at
- START_POSITION as a potential substitution. If TEMPLATE_P is
- non-zero, this potential substitution is a template-id. */
+/* <encoding> ::= <(function) name> <bare-function-type>
+ ::= <(data) name>
+ ::= <special-name> */
-static status_t
-substitution_add (dm, start_position, template_p)
- demangling_t dm;
- int start_position;
- int template_p;
+static struct d_comp *
+d_encoding (di)
+ struct d_info *di;
{
- dyn_string_t result = result_string (dm);
- dyn_string_t substitution = dyn_string_new (0);
- int i;
-
- if (substitution == NULL)
- return STATUS_ALLOCATION_FAILED;
+ char peek = d_peek_char (di);
- /* Extract the substring of the current demangling result that
- represents the subsitution candidate. */
- if (!dyn_string_substring (substitution,
- result, start_position, result_caret_pos (dm)))
+ if (peek == 'G' || peek == 'T')
+ return d_special_name (di);
+ else
{
- dyn_string_delete (substitution);
- return STATUS_ALLOCATION_FAILED;
+ struct d_comp *dc;
+
+ dc = d_name (di);
+ peek = d_peek_char (di);
+ if (peek == '\0' || peek == 'E')
+ return dc;
+ return d_make_comp (di, D_COMP_TYPED_NAME, dc,
+ d_bare_function_type (di, has_return_type (dc)));
}
+}
+
+/* <name> ::= <nested-name>
+ ::= <unscoped-name>
+ ::= <unscoped-template-name> <template-args>
+ ::= <local-name>
+
+ <unscoped-name> ::= <unqualified-name>
+ ::= St <unqualified-name>
- /* If there's no room for the new entry, grow the array. */
- if (dm->substitutions_allocated == dm->num_substitutions)
+ <unscoped-template-name> ::= <unscoped-name>
+ ::= <substitution>
+*/
+
+static struct d_comp *
+d_name (di)
+ struct d_info *di;
+{
+ char peek = d_peek_char (di);
+ struct d_comp *dc;
+
+ switch (peek)
{
- size_t new_array_size;
- if (dm->substitutions_allocated > 0)
- dm->substitutions_allocated *= 2;
- else
- dm->substitutions_allocated = 2;
- new_array_size =
- sizeof (struct substitution_def) * dm->substitutions_allocated;
-
- dm->substitutions = (struct substitution_def *)
- realloc (dm->substitutions, new_array_size);
- if (dm->substitutions == NULL)
- /* Realloc failed. */
+ case 'N':
+ return d_nested_name (di);
+
+ case 'Z':
+ return d_local_name (di);
+
+ case 'S':
+ {
+ int subst;
+
+ if (d_peek_next_char (di) != 't')
+ {
+ dc = d_substitution (di);
+ subst = 1;
+ }
+ else
+ {
+ d_advance (di, 2);
+ dc = d_make_comp (di, D_COMP_QUAL_NAME, d_make_name (di, "std", 3),
+ d_unqualified_name (di));
+ subst = 0;
+ }
+
+ if (d_peek_char (di) != 'I')
+ {
+ /* The grammar does not permit this case to occur if we
+ called d_substitution() above (i.e., subst == 1). We
+ don't bother to check. */
+ }
+ else
+ {
+ /* This is <template-args>, which means that we just saw
+ <unscoped-template-name>, which is a substitution
+ candidate if we didn't just get it from a
+ substitution. */
+ if (! subst)
+ {
+ if (! d_add_substitution (di, dc))
+ return NULL;
+ }
+ dc = d_make_comp (di, D_COMP_TEMPLATE, dc, d_template_args (di));
+ }
+
+ return dc;
+ }
+
+ default:
+ dc = d_unqualified_name (di);
+ if (d_peek_char (di) == 'I')
{
- dyn_string_delete (substitution);
- return STATUS_ALLOCATION_FAILED;
+ /* This is <template-args>, which means that we just saw
+ <unscoped-template-name>, which is a substitution
+ candidate. */
+ if (! d_add_substitution (di, dc))
+ return NULL;
+ dc = d_make_comp (di, D_COMP_TEMPLATE, dc, d_template_args (di));
}
+ return dc;
}
+}
- /* Add the substitution to the array. */
- i = dm->num_substitutions++;
- dm->substitutions[i].text = substitution;
- dm->substitutions[i].template_p = template_p;
+/* <nested-name> ::= N [<CV-qualifiers>] <prefix> <unqualified-name> E
+ ::= N [<CV-qualifiers>] <template-prefix> <template-args> E
+*/
-#ifdef CP_DEMANGLE_DEBUG
- substitutions_print (dm, stderr);
-#endif
+static struct d_comp *
+d_nested_name (di)
+ struct d_info *di;
+{
+ struct d_comp *ret;
+ struct d_comp **pret;
- return STATUS_OK;
-}
+ if (d_next_char (di) != 'N')
+ return NULL;
-/* Returns the Nth-most-recent substitution. Sets *TEMPLATE_P to
- non-zero if the substitution is a template-id, zero otherwise.
- N is numbered from zero. DM retains ownership of the returned
- string. If N is negative, or equal to or greater than the current
- number of substitution candidates, returns NULL. */
-
-static dyn_string_t
-substitution_get (dm, n, template_p)
- demangling_t dm;
- int n;
- int *template_p;
-{
- struct substitution_def *sub;
+ pret = d_cv_qualifiers (di, &ret);
+ if (pret == NULL)
+ return NULL;
+
+ *pret = d_prefix (di);
+ if (*pret == NULL)
+ return NULL;
- /* Make sure N is in the valid range. */
- if (n < 0 || n >= dm->num_substitutions)
+ if (d_next_char (di) != 'E')
return NULL;
- sub = &(dm->substitutions[n]);
- *template_p = sub->template_p;
- return sub->text;
+ return ret;
}
-#ifdef CP_DEMANGLE_DEBUG
-/* Debugging routine to print the current substitutions to FP. */
+/* <prefix> ::= <prefix> <unqualified-name>
+ ::= <template-prefix> <template-args>
+ ::= <template-param>
+ ::=
+ ::= <substitution>
-static void
-substitutions_print (dm, fp)
- demangling_t dm;
- FILE *fp;
+ <template-prefix> ::= <prefix> <(template) unqualified-name>
+ ::= <template-param>
+ ::= <substitution>
+*/
+
+static struct d_comp *
+d_prefix (di)
+ struct d_info *di;
{
- int seq_id;
- int num = dm->num_substitutions;
+ struct d_comp *ret = NULL;
- fprintf (fp, "SUBSTITUTIONS:\n");
- for (seq_id = -1; seq_id < num - 1; ++seq_id)
+ while (1)
{
- int template_p;
- dyn_string_t text = substitution_get (dm, seq_id + 1, &template_p);
+ char peek;
+ enum d_comp_type comb_type;
+ struct d_comp *dc;
+
+ peek = d_peek_char (di);
+ if (peek == '\0')
+ return NULL;
+
+ /* 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 (seq_id == -1)
- fprintf (fp, " S_ ");
+ comb_type = D_COMP_QUAL_NAME;
+ if (IS_DIGIT (peek)
+ || (peek >= 'a' && peek <= 'z')
+ || peek == 'C'
+ || peek == 'D')
+ dc = d_unqualified_name (di);
+ else if (peek == 'S')
+ dc = d_substitution (di);
+ else if (peek == 'I')
+ {
+ if (ret == NULL)
+ return NULL;
+ comb_type = D_COMP_TEMPLATE;
+ dc = d_template_args (di);
+ }
+ else if (peek == 'T')
+ dc = d_template_param (di);
+ else if (peek == 'E')
+ return ret;
+ else
+ return NULL;
+
+ if (ret == NULL)
+ ret = dc;
else
- fprintf (fp, " S%d_", seq_id);
- fprintf (fp, " %c: %s\n", template_p ? '*' : ' ', dyn_string_buf (text));
+ ret = d_make_comp (di, comb_type, ret, dc);
+
+ if (peek != 'S' && d_peek_char (di) != 'E')
+ {
+ if (! d_add_substitution (di, ret))
+ return NULL;
+ }
}
}
-#endif /* CP_DEMANGLE_DEBUG */
-
-/* Creates a new template argument list. Returns NULL if allocation
- fails. */
+/* <unqualified-name> ::= <operator-name>
+ ::= <ctor-dtor-name>
+ ::= <source-name>
+*/
-static template_arg_list_t
-template_arg_list_new ()
+static struct d_comp *
+d_unqualified_name (di)
+ struct d_info *di;
{
- template_arg_list_t new_list =
- (template_arg_list_t) malloc (sizeof (struct template_arg_list_def));
- if (new_list == NULL)
+ char peek;
+
+ peek = d_peek_char (di);
+ if (IS_DIGIT (peek))
+ return d_source_name (di);
+ else if (peek >= 'a' && peek <= 'z')
+ return d_operator_name (di);
+ else if (peek == 'C' || peek == 'D')
+ return d_ctor_dtor_name (di);
+ else
return NULL;
- /* Initialize the new list to have no arguments. */
- new_list->first_argument = NULL;
- new_list->last_argument = NULL;
- /* Return the new list. */
- return new_list;
}
-/* Deletes a template argument list and the template arguments it
- contains. */
+/* <source-name> ::= <(positive length) number> <identifier> */
-static void
-template_arg_list_delete (list)
- template_arg_list_t list;
+static struct d_comp *
+d_source_name (di)
+ struct d_info *di;
{
- /* If there are any arguments on LIST, delete them. */
- if (list->first_argument != NULL)
- string_list_delete (list->first_argument);
- /* Delete LIST. */
- free (list);
+ long len;
+ struct d_comp *ret;
+
+ len = d_number (di);
+ if (len <= 0)
+ return NULL;
+ ret = d_identifier (di, len);
+ di->last_name = ret;
+ return ret;
}
-/* Adds ARG to the template argument list ARG_LIST. */
+/* number ::= [n] <(non-negative decimal integer)> */
-static void
-template_arg_list_add_arg (arg_list, arg)
- template_arg_list_t arg_list;
- string_list_t arg;
+static long
+d_number (di)
+ struct d_info *di;
{
- if (arg_list->first_argument == NULL)
- /* If there were no arguments before, ARG is the first one. */
- arg_list->first_argument = arg;
- else
- /* Make ARG the last argument on the list. */
- arg_list->last_argument->next = arg;
- /* Make ARG the last on the list. */
- arg_list->last_argument = arg;
- arg->next = NULL;
-}
+ int sign;
+ char peek;
+ long ret;
-/* Returns the template arugment at position INDEX in template
- argument list ARG_LIST. */
+ sign = 1;
+ peek = d_peek_char (di);
+ if (peek == 'n')
+ {
+ sign = -1;
+ d_advance (di, 1);
+ peek = d_peek_char (di);
+ }
-static string_list_t
-template_arg_list_get_arg (arg_list, index)
- template_arg_list_t arg_list;
- int index;
-{
- string_list_t arg = arg_list->first_argument;
- /* Scan down the list of arguments to find the one at position
- INDEX. */
- while (index--)
+ ret = 0;
+ while (1)
{
- arg = arg->next;
- if (arg == NULL)
- /* Ran out of arguments before INDEX hit zero. That's an
- error. */
- return NULL;
+ if (! IS_DIGIT (peek))
+ return ret * sign;
+ ret = ret * 10 + peek - '0';
+ d_advance (di, 1);
+ peek = d_peek_char (di);
}
- /* Return the argument at position INDEX. */
- return arg;
}
-/* Pushes ARG_LIST onto the top of the template argument list stack. */
+/* identifier ::= <(unqualified source code identifier)> */
-static void
-push_template_arg_list (dm, arg_list)
- demangling_t dm;
- template_arg_list_t arg_list;
+static struct d_comp *
+d_identifier (di, len)
+ struct d_info *di;
+ int len;
{
- arg_list->next = dm->template_arg_lists;
- dm->template_arg_lists = arg_list;
-#ifdef CP_DEMANGLE_DEBUG
- fprintf (stderr, " ** pushing template arg list\n");
- template_arg_list_print (arg_list, stderr);
-#endif
-}
+ const char *name;
-/* Pops and deletes elements on the template argument list stack until
- arg_list is the topmost element. If arg_list is NULL, all elements
- are popped and deleted. */
+ name = d_str (di);
+ d_advance (di, len);
-static void
-pop_to_template_arg_list (dm, arg_list)
- demangling_t dm;
- template_arg_list_t arg_list;
-{
- while (dm->template_arg_lists != arg_list)
+ /* 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)
{
- template_arg_list_t top = dm->template_arg_lists;
- /* Disconnect the topmost element from the list. */
- dm->template_arg_lists = top->next;
- /* Delete the popped element. */
- template_arg_list_delete (top);
-#ifdef CP_DEMANGLE_DEBUG
- fprintf (stderr, " ** removing template arg list\n");
-#endif
+ const char *s;
+
+ s = name + ANONYMOUS_NAMESPACE_PREFIX_LEN;
+ if ((*s == '.' || *s == '_' || *s == '$')
+ && s[1] == 'N')
+ return d_make_name (di, "(anonymous namespace)",
+ sizeof "(anonymous namespace)" - 1);
}
+
+ return d_make_name (di, name, len);
}
-#ifdef CP_DEMANGLE_DEBUG
+/* operator_name ::= many different two character encodings.
+ ::= cv <type>
+ ::= v <digit> <source-name>
+*/
-/* Prints the contents of ARG_LIST to FP. */
+static const struct d_operator_info d_operators[] =
+{
+ { "aN", "&=", 2 },
+ { "aS", "=", 2 },
+ { "aa", "&&", 2 },
+ { "ad", "&", 1 },
+ { "an", "&", 2 },
+ { "cl", "()", 0 },
+ { "cm", ",", 2 },
+ { "co", "~", 1 },
+ { "dV", "/=", 2 },
+ { "da", "delete[]", 1 },
+ { "de", "*", 1 },
+ { "dl", "delete", 1 },
+ { "dv", "/", 2 },
+ { "eO", "^=", 2 },
+ { "eo", "^", 2 },
+ { "eq", "==", 2 },
+ { "ge", ">=", 2 },
+ { "gt", ">", 2 },
+ { "ix", "[]", 2 },
+ { "lS", "<<=", 2 },
+ { "le", "<=", 2 },
+ { "ls", "<<", 2 },
+ { "lt", "<", 2 },
+ { "mI", "-=", 2 },
+ { "mL", "*=", 2 },
+ { "mi", "-", 2 },
+ { "ml", "*", 2 },
+ { "mm", "--", 1 },
+ { "na", "new[]", 1 },
+ { "ne", "!=", 2 },
+ { "ng", "-", 1 },
+ { "nt", "!", 1 },
+ { "nw", "new", 1 },
+ { "oR", "|=", 2 },
+ { "oo", "||", 2 },
+ { "or", "|", 2 },
+ { "pL", "+=", 2 },
+ { "pl", "+", 2 },
+ { "pm", "->*", 2 },
+ { "pp", "++", 1 },
+ { "ps", "+", 1 },
+ { "pt", "->", 2 },
+ { "qu", "?", 3 },
+ { "rM", "%=", 2 },
+ { "rS", ">>=", 2 },
+ { "rm", "%", 2 },
+ { "rs", ">>", 2 },
+ { "st", "sizeof ", 1 },
+ { "sz", "sizeof ", 1 }
+};
-static void
-template_arg_list_print (arg_list, fp)
- template_arg_list_t arg_list;
- FILE *fp;
+static struct d_comp *
+d_operator_name (di)
+ struct d_info *di;
{
- string_list_t arg;
- int index = -1;
+ char c1;
+ char c2;
- fprintf (fp, "TEMPLATE ARGUMENT LIST:\n");
- for (arg = arg_list->first_argument; arg != NULL; arg = arg->next)
+ 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')
+ return d_make_comp (di, D_COMP_CAST, d_type (di), NULL);
+ else
{
- if (index == -1)
- fprintf (fp, " T_ : ");
- else
- fprintf (fp, " T%d_ : ", index);
- ++index;
- fprintf (fp, "%s\n", dyn_string_buf ((dyn_string_t) arg));
- }
-}
+ int low = 0;
+ int high = sizeof (d_operators) / sizeof (d_operators[0]);
-#endif /* CP_DEMANGLE_DEBUG */
+ while (1)
+ {
+ int i;
+ const struct d_operator_info *p;
-/* Returns the topmost element on the stack of template argument
- lists. If there is no list of template arguments, returns NULL. */
+ i = low + (high - low) / 2;
+ p = d_operators + i;
-static template_arg_list_t
-current_template_arg_list (dm)
- demangling_t dm;
-{
- return dm->template_arg_lists;
+ 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;
+ }
+ }
}
-/* Allocates a demangling_t object for demangling mangled NAME. A new
- result must be pushed before the returned object can be used.
- Returns NULL if allocation fails. */
+/* <special-name> ::= TV <type>
+ ::= TT <type>
+ ::= TI <type>
+ ::= TS <type>
+ ::= 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>
+*/
-static demangling_t
-demangling_new (name, style)
- const char *name;
- int style;
+static struct d_comp *
+d_special_name (di)
+ struct d_info *di;
{
- demangling_t dm;
- dm = (demangling_t) malloc (sizeof (struct demangling_def));
- if (dm == NULL)
- return NULL;
+ char c;
- dm->name = name;
- dm->next = name;
- dm->result = NULL;
- dm->num_substitutions = 0;
- dm->substitutions_allocated = 10;
- dm->template_arg_lists = NULL;
- dm->last_source_name = dyn_string_new (0);
- if (dm->last_source_name == NULL)
- return NULL;
- dm->substitutions = (struct substitution_def *)
- malloc (dm->substitutions_allocated * sizeof (struct substitution_def));
- if (dm->substitutions == NULL)
+ c = d_next_char (di);
+ if (c == 'T')
{
- dyn_string_delete (dm->last_source_name);
- return NULL;
- }
- dm->style = style;
- dm->is_constructor = (enum gnu_v3_ctor_kinds) 0;
- dm->is_destructor = (enum gnu_v3_dtor_kinds) 0;
+ switch (d_next_char (di))
+ {
+ case 'V':
+ return d_make_comp (di, D_COMP_VTABLE, d_type (di), NULL);
+ case 'T':
+ return d_make_comp (di, D_COMP_VTT, d_type (di), NULL);
+ case 'I':
+ return d_make_comp (di, D_COMP_TYPEINFO, d_type (di), NULL);
+ case 'S':
+ return d_make_comp (di, D_COMP_TYPEINFO_NAME, d_type (di), NULL);
- return dm;
-}
+ case 'h':
+ if (! d_call_offset (di, 'h'))
+ return NULL;
+ return d_make_comp (di, D_COMP_THUNK, d_encoding (di), NULL);
-/* Deallocates a demangling_t object and all memory associated with
- it. */
+ case 'v':
+ if (! d_call_offset (di, 'v'))
+ return NULL;
+ return d_make_comp (di, D_COMP_VIRTUAL_THUNK, d_encoding (di),
+ NULL);
-static void
-demangling_delete (dm)
- demangling_t dm;
-{
- int i;
- template_arg_list_t arg_list = dm->template_arg_lists;
+ case 'c':
+ if (! d_call_offset (di, '\0'))
+ return NULL;
+ if (! d_call_offset (di, '\0'))
+ return NULL;
+ return d_make_comp (di, D_COMP_COVARIANT_THUNK, d_encoding (di),
+ NULL);
- /* Delete the stack of template argument lists. */
- while (arg_list != NULL)
- {
- template_arg_list_t next = arg_list->next;
- template_arg_list_delete (arg_list);
- arg_list = next;
- }
- /* Delete the list of substitutions. */
- for (i = dm->num_substitutions; --i >= 0; )
- dyn_string_delete (dm->substitutions[i].text);
- free (dm->substitutions);
- /* Delete the demangled result. */
- string_list_delete (dm->result);
- /* Delete the stored identifier name. */
- dyn_string_delete (dm->last_source_name);
- /* Delete the context object itself. */
- free (dm);
-}
+ case 'C':
+ {
+ struct d_comp *derived_type;
+ long offset;
+ struct d_comp *base_type;
+
+ derived_type = d_type (di);
+ offset = d_number (di);
+ if (offset < 0)
+ return NULL;
+ if (d_next_char (di) != '_')
+ return NULL;
+ base_type = d_type (di);
+ /* We don't display the offset. FIXME: We should display
+ it in verbose mode. */
+ return d_make_comp (di, D_COMP_CONSTRUCTION_VTABLE, base_type,
+ derived_type);
+ }
-/* These functions demangle an alternative of the corresponding
- production in the mangling spec. The first argument of each is a
- demangling context structure for the current demangling
- operation. Most emit demangled text directly to the topmost result
- string on the result string stack in the demangling context
- structure. */
-
-static status_t demangle_char
- PARAMS ((demangling_t, int));
-static status_t demangle_mangled_name
- PARAMS ((demangling_t));
-static status_t demangle_encoding
- PARAMS ((demangling_t));
-static status_t demangle_name
- PARAMS ((demangling_t, int *));
-static status_t demangle_nested_name
- PARAMS ((demangling_t, int *));
-static status_t demangle_prefix
- PARAMS ((demangling_t, int *));
-static status_t demangle_unqualified_name
- PARAMS ((demangling_t, int *));
-static status_t demangle_source_name
- PARAMS ((demangling_t));
-static status_t demangle_number
- PARAMS ((demangling_t, int *, int, int));
-static status_t demangle_number_literally
- PARAMS ((demangling_t, dyn_string_t, int, int));
-static status_t demangle_identifier
- PARAMS ((demangling_t, int, dyn_string_t));
-static status_t demangle_operator_name
- PARAMS ((demangling_t, int, int *, int *));
-static status_t demangle_nv_offset
- PARAMS ((demangling_t));
-static status_t demangle_v_offset
- PARAMS ((demangling_t));
-static status_t demangle_call_offset
- PARAMS ((demangling_t));
-static status_t demangle_special_name
- PARAMS ((demangling_t));
-static status_t demangle_ctor_dtor_name
- PARAMS ((demangling_t));
-static status_t demangle_type_ptr
- PARAMS ((demangling_t, int *, int));
-static status_t demangle_type
- PARAMS ((demangling_t));
-static status_t demangle_CV_qualifiers
- PARAMS ((demangling_t, dyn_string_t));
-static status_t demangle_builtin_type
- PARAMS ((demangling_t));
-static status_t demangle_function_type
- PARAMS ((demangling_t, int *));
-static status_t demangle_bare_function_type
- PARAMS ((demangling_t, int *));
-static status_t demangle_class_enum_type
- PARAMS ((demangling_t, int *));
-static status_t demangle_array_type
- PARAMS ((demangling_t, int *));
-static status_t demangle_template_param
- PARAMS ((demangling_t));
-static status_t demangle_template_args
- PARAMS ((demangling_t));
-static status_t demangle_literal
- PARAMS ((demangling_t));
-static status_t demangle_template_arg
- PARAMS ((demangling_t));
-static status_t demangle_expression
- PARAMS ((demangling_t));
-static status_t demangle_scope_expression
- PARAMS ((demangling_t));
-static status_t demangle_expr_primary
- PARAMS ((demangling_t));
-static status_t demangle_substitution
- PARAMS ((demangling_t, int *));
-static status_t demangle_local_name
- PARAMS ((demangling_t));
-static status_t demangle_discriminator
- PARAMS ((demangling_t, int));
-static status_t cp_demangle
- PARAMS ((const char *, dyn_string_t, int));
-static status_t cp_demangle_type
- PARAMS ((const char*, dyn_string_t));
-
-/* When passed to demangle_bare_function_type, indicates that the
- function's return type is not encoded before its parameter types. */
-#define BFT_NO_RETURN_TYPE NULL
-
-/* Check that the next character is C. If so, consume it. If not,
- return an error. */
-
-static status_t
-demangle_char (dm, c)
- demangling_t dm;
- int c;
-{
- static char *error_message = NULL;
+ case 'F':
+ return d_make_comp (di, D_COMP_TYPEINFO_FN, d_type (di), NULL);
+ case 'J':
+ return d_make_comp (di, D_COMP_JAVA_CLASS, d_type (di), NULL);
- if (peek_char (dm) == c)
- {
- advance_char (dm);
- return STATUS_OK;
+ default:
+ return NULL;
+ }
}
- else
+ else if (c == 'G')
{
- if (error_message == NULL)
- error_message = (char *) strdup ("Expected ?");
- error_message[9] = c;
- return error_message;
+ switch (d_next_char (di))
+ {
+ case 'V':
+ return d_make_comp (di, D_COMP_GUARD, d_name (di), NULL);
+
+ case 'R':
+ return d_make_comp (di, D_COMP_REFTEMP, d_name (di), NULL);
+
+ default:
+ return NULL;
+ }
}
+ else
+ return NULL;
}
-/* Demangles and emits a <mangled-name>.
+/* <call-offset> ::= h <nv-offset> _
+ ::= v <v-offset> _
- <mangled-name> ::= _Z <encoding> */
+ <nv-offset> ::= <(offset) number>
-static status_t
-demangle_mangled_name (dm)
- demangling_t dm;
-{
- DEMANGLE_TRACE ("mangled-name", dm);
- RETURN_IF_ERROR (demangle_char (dm, '_'));
- RETURN_IF_ERROR (demangle_char (dm, 'Z'));
- RETURN_IF_ERROR (demangle_encoding (dm));
- return STATUS_OK;
-}
+ <v-offset> ::= <(offset) number> _ <(virtual offset) number>
-/* Demangles and emits an <encoding>.
+ The C parameter, if not '\0', is a character we just read which is
+ the start of the <call-offset>.
- <encoding> ::= <function name> <bare-function-type>
- ::= <data name>
- ::= <special-name> */
+ We don't display the offset information anywhere. FIXME: We should
+ display it in verbose mode. */
-static status_t
-demangle_encoding (dm)
- demangling_t dm;
+static int
+d_call_offset (di, c)
+ struct d_info *di;
+ int c;
{
- int encode_return_type;
- int start_position;
- template_arg_list_t old_arg_list = current_template_arg_list (dm);
- char peek = peek_char (dm);
+ long offset;
+ long virtual_offset;
- DEMANGLE_TRACE ("encoding", dm);
-
- /* Remember where the name starts. If it turns out to be a template
- function, we'll have to insert the return type here. */
- start_position = result_caret_pos (dm);
+ if (c == '\0')
+ c = d_next_char (di);
- if (peek == 'G' || peek == 'T')
- RETURN_IF_ERROR (demangle_special_name (dm));
- else
+ if (c == 'h')
+ offset = d_number (di);
+ else if (c == 'v')
{
- /* Now demangle the name. */
- RETURN_IF_ERROR (demangle_name (dm, &encode_return_type));
-
- /* If there's anything left, the name was a function name, with
- maybe its return type, and its parameter types, following. */
- if (!end_of_name_p (dm)
- && peek_char (dm) != 'E')
- {
- if (encode_return_type)
- /* Template functions have their return type encoded. The
- return type should be inserted at start_position. */
- RETURN_IF_ERROR
- (demangle_bare_function_type (dm, &start_position));
- else
- /* Non-template functions don't have their return type
- encoded. */
- RETURN_IF_ERROR
- (demangle_bare_function_type (dm, BFT_NO_RETURN_TYPE));
- }
+ offset = d_number (di);
+ if (d_next_char (di) != '_')
+ return 0;
+ virtual_offset = d_number (di);
}
+ else
+ return 0;
- /* Pop off template argument lists that were built during the
- mangling of this name, to restore the old template context. */
- pop_to_template_arg_list (dm, old_arg_list);
+ if (d_next_char (di) != '_')
+ return 0;
- return STATUS_OK;
+ return 1;
}
-/* Demangles and emits a <name>.
+/* <ctor-dtor-name> ::= C1
+ ::= C2
+ ::= C3
+ ::= D0
+ ::= D1
+ ::= D2
+*/
+
+static struct d_comp *
+d_ctor_dtor_name (di)
+ struct d_info *di;
+{
+ switch (d_next_char (di))
+ {
+ case 'C':
+ {
+ enum gnu_v3_ctor_kinds kind;
+
+ switch (d_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;
+ default:
+ return NULL;
+ }
+ return d_make_ctor (di, kind, di->last_name);
+ }
+
+ case 'D':
+ {
+ enum gnu_v3_dtor_kinds kind;
+
+ switch (d_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;
+ default:
+ return NULL;
+ }
+ return d_make_dtor (di, kind, di->last_name);
+ }
- <name> ::= <unscoped-name>
- ::= <unscoped-template-name> <template-args>
- ::= <nested-name>
- ::= <local-name>
+ default:
+ return NULL;
+ }
+}
- <unscoped-name> ::= <unqualified-name>
- ::= St <unqualified-name> # ::std::
+/* <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>
+ ::= C <type>
+ ::= G <type>
+ ::= U <source-name> <type>
+
+ <builtin-type> ::= various one letter codes
+ ::= u <source-name>
+*/
- <unscoped-template-name>
- ::= <unscoped-name>
- ::= <substitution> */
+static const struct d_builtin_type_info d_builtin_types[26] =
+{
+ /* a */ { "signed char", "signed char", D_PRINT_INT },
+ /* b */ { "bool", "boolean", D_PRINT_BOOL },
+ /* c */ { "char", "byte", D_PRINT_INT },
+ /* d */ { "double", "double", D_PRINT_DEFAULT },
+ /* e */ { "long double", "long double", D_PRINT_DEFAULT },
+ /* f */ { "float", "float", D_PRINT_DEFAULT },
+ /* g */ { "__float128", "__float128", D_PRINT_DEFAULT },
+ /* h */ { "unsigned char", "unsigned char", D_PRINT_INT },
+ /* i */ { "int", "int", D_PRINT_INT },
+ /* j */ { "unsigned int", "unsigned", D_PRINT_INT },
+ /* k */ { NULL, NULL, D_PRINT_DEFAULT },
+ /* l */ { "long", "long", D_PRINT_LONG },
+ /* m */ { "unsigned long", "unsigned long", D_PRINT_LONG },
+ /* n */ { "__int128", "__int128", D_PRINT_DEFAULT },
+ /* o */ { "unsigned __int128", "unsigned __int128", D_PRINT_DEFAULT },
+ /* p */ { NULL, NULL, D_PRINT_DEFAULT },
+ /* q */ { NULL, NULL, D_PRINT_DEFAULT },
+ /* r */ { NULL, NULL, D_PRINT_DEFAULT },
+ /* s */ { "short", "short", D_PRINT_INT },
+ /* t */ { "unsigned short", "unsigned short", D_PRINT_INT },
+ /* u */ { NULL, NULL, D_PRINT_DEFAULT },
+ /* v */ { "void", "void", D_PRINT_VOID },
+ /* w */ { "wchar_t", "char", D_PRINT_INT },
+ /* x */ { "long long", "long", D_PRINT_DEFAULT },
+ /* y */ { "unsigned long long", "unsigned long long", D_PRINT_DEFAULT },
+ /* z */ { "...", "...", D_PRINT_DEFAULT },
+};
-static status_t
-demangle_name (dm, encode_return_type)
- demangling_t dm;
- int *encode_return_type;
+static struct d_comp *
+d_type (di)
+ struct d_info *di;
{
- int start = substitution_start (dm);
- char peek = peek_char (dm);
- int is_std_substitution = 0;
+ char peek;
+ struct d_comp *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 specifies that vendor qualifiers are handled just
+ like the standard CV-qualifiers with respect to subsetting and
+ substitution, but g++ does not appear to work this way. */
+
+ peek = d_peek_char (di);
+ if (peek == 'r' || peek == 'V' || peek == 'K')
+ {
+ struct d_comp **pret;
- /* Generally, the return type is encoded if the function is a
- template-id, and suppressed otherwise. There are a few cases,
- though, in which the return type is not encoded even for a
- templated function. In these cases, this flag is set. */
- int suppress_return_type = 0;
+ pret = d_cv_qualifiers (di, &ret);
+ *pret = d_type (di);
+ if (! d_add_substitution (di, ret))
+ return NULL;
+ return ret;
+ }
- DEMANGLE_TRACE ("name", dm);
+ can_subst = 1;
switch (peek)
{
- case 'N':
- /* This is a <nested-name>. */
- RETURN_IF_ERROR (demangle_nested_name (dm, encode_return_type));
+ 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':
+ /* FIXME: The old demangler handles Java types here. */
+ ret = d_make_builtin_type (di, &d_builtin_types[peek - 'a']);
+ can_subst = 0;
+ d_advance (di, 1);
+ break;
+
+ case 'u':
+ d_advance (di, 1);
+ ret = d_make_comp (di, D_COMP_VENDOR_TYPE, d_source_name (di), NULL);
+ break;
+
+ case 'F':
+ ret = d_function_type (di);
break;
+ case '0': case '1': case '2': case '3': case '4':
+ case '5': case '6': case '7': case '8': case '9':
+ case 'N':
case 'Z':
- RETURN_IF_ERROR (demangle_local_name (dm));
- *encode_return_type = 0;
+ ret = d_class_enum_type (di);
break;
- case 'S':
- /* The `St' substitution allows a name nested in std:: to appear
- without being enclosed in a nested name. */
- if (peek_char_next (dm) == 't')
- {
- (void) next_char (dm);
- (void) next_char (dm);
- RETURN_IF_ERROR (result_add (dm, "std::"));
- RETURN_IF_ERROR
- (demangle_unqualified_name (dm, &suppress_return_type));
- is_std_substitution = 1;
- }
- else
- RETURN_IF_ERROR (demangle_substitution (dm, encode_return_type));
- /* Check if a template argument list immediately follows.
- If so, then we just demangled an <unqualified-template-name>. */
- if (peek_char (dm) == 'I')
+ 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')
{
- /* A template name of the form std::<unqualified-name> is a
- substitution candidate. */
- if (is_std_substitution)
- RETURN_IF_ERROR (substitution_add (dm, start, 0));
- /* Demangle the <template-args> here. */
- RETURN_IF_ERROR (demangle_template_args (dm));
- *encode_return_type = !suppress_return_type;
+ /* This is <template-template-param> <template-args>. The
+ <template-template-param> part is a substitution
+ candidate. */
+ if (! d_add_substitution (di, ret))
+ return NULL;
+ ret = d_make_comp (di, D_COMP_TEMPLATE, ret, d_template_args (di));
}
- else
- *encode_return_type = 0;
+ break;
+
+ case 'S':
+ /* If this is a special substitution, then it is the start of
+ <class-enum-type>. */
+ {
+ char peek_next;
+ peek_next = d_peek_next_char (di);
+ if (IS_DIGIT (peek_next)
+ || peek_next == '_'
+ || (peek_next >= 'A' && peek_next <= 'Z'))
+ {
+ ret = d_substitution (di);
+ /* The substituted name may have been a template name and
+ may be followed by tepmlate args. */
+ if (d_peek_char (di) == 'I')
+ ret = d_make_comp (di, D_COMP_TEMPLATE, ret,
+ d_template_args (di));
+ else
+ can_subst = 0;
+ }
+ else
+ {
+ ret = d_class_enum_type (di);
+ /* If the substitution was a complete type, then it is not
+ a new substitution candidate. However, if the
+ substitution was followed by template arguments, then
+ the whole thing is a substitution candidate. */
+ if (ret->type == D_COMP_SUB_STD)
+ can_subst = 0;
+ }
+ }
break;
- default:
- /* This is an <unscoped-name> or <unscoped-template-name>. */
- RETURN_IF_ERROR (demangle_unqualified_name (dm, &suppress_return_type));
+ case 'P':
+ d_advance (di, 1);
+ ret = d_make_comp (di, D_COMP_POINTER, d_type (di), NULL);
+ break;
- /* If the <unqualified-name> is followed by template args, this
- is an <unscoped-template-name>. */
- if (peek_char (dm) == 'I')
- {
- /* Add a substitution for the unqualified template name. */
- RETURN_IF_ERROR (substitution_add (dm, start, 0));
+ case 'R':
+ d_advance (di, 1);
+ ret = d_make_comp (di, D_COMP_REFERENCE, d_type (di), NULL);
+ break;
- RETURN_IF_ERROR (demangle_template_args (dm));
- *encode_return_type = !suppress_return_type;
- }
- else
- *encode_return_type = 0;
+ case 'C':
+ d_advance (di, 1);
+ ret = d_make_comp (di, D_COMP_COMPLEX, d_type (di), NULL);
+ break;
+
+ case 'G':
+ d_advance (di, 1);
+ ret = d_make_comp (di, D_COMP_IMAGINARY, d_type (di), NULL);
+ break;
+ case 'U':
+ d_advance (di, 1);
+ ret = d_source_name (di);
+ ret = d_make_comp (di, D_COMP_VENDOR_TYPE_QUAL, d_type (di), ret);
break;
+
+ default:
+ return NULL;
}
- return STATUS_OK;
-}
+ if (can_subst)
+ {
+ if (! d_add_substitution (di, ret))
+ return NULL;
+ }
-/* Demangles and emits a <nested-name>.
+ return ret;
+}
- <nested-name> ::= N [<CV-qualifiers>] <prefix> <unqualified-name> E */
+/* <CV-qualifiers> ::= [r] [V] [K] */
-static status_t
-demangle_nested_name (dm, encode_return_type)
- demangling_t dm;
- int *encode_return_type;
+static struct d_comp **
+d_cv_qualifiers (di, pret)
+ struct d_info *di;
+ struct d_comp **pret;
{
char peek;
- DEMANGLE_TRACE ("nested-name", dm);
-
- RETURN_IF_ERROR (demangle_char (dm, 'N'));
-
- peek = peek_char (dm);
- if (peek == 'r' || peek == 'V' || peek == 'K')
+ peek = d_peek_char (di);
+ while (peek == 'r' || peek == 'V' || peek == 'K')
{
- dyn_string_t cv_qualifiers;
- status_t status;
-
- /* Snarf up CV qualifiers. */
- cv_qualifiers = dyn_string_new (24);
- if (cv_qualifiers == NULL)
- return STATUS_ALLOCATION_FAILED;
- demangle_CV_qualifiers (dm, cv_qualifiers);
-
- /* Emit them, preceded by a space. */
- status = result_add_char (dm, ' ');
- if (STATUS_NO_ERROR (status))
- status = result_add_string (dm, cv_qualifiers);
- /* The CV qualifiers that occur in a <nested-name> will be
- qualifiers for member functions. These are placed at the end
- of the function. Therefore, shift the caret to the left by
- the length of the qualifiers, so other text is inserted
- before them and they stay at the end. */
- result_shift_caret (dm, -dyn_string_length (cv_qualifiers) - 1);
- /* Clean up. */
- dyn_string_delete (cv_qualifiers);
- RETURN_IF_ERROR (status);
- }
+ enum d_comp_type t;
- RETURN_IF_ERROR (demangle_prefix (dm, encode_return_type));
- /* No need to demangle the final <unqualified-name>; demangle_prefix
- will handle it. */
- RETURN_IF_ERROR (demangle_char (dm, 'E'));
+ d_advance (di, 1);
+ if (peek == 'r')
+ t = D_COMP_RESTRICT;
+ else if (peek == 'V')
+ t = D_COMP_VOLATILE;
+ else
+ t = D_COMP_CONST;
- return STATUS_OK;
-}
+ *pret = d_make_comp (di, t, NULL, NULL);
+ if (*pret == NULL)
+ return NULL;
+ pret = &d_left (*pret);
-/* Demangles and emits a <prefix>.
+ peek = d_peek_char (di);
+ }
- <prefix> ::= <prefix> <unqualified-name>
- ::= <template-prefix> <template-args>
- ::= # empty
- ::= <substitution>
+ return pret;
+}
- <template-prefix> ::= <prefix>
- ::= <substitution> */
+/* <function-type> ::= F [Y] <bare-function-type> E */
-static status_t
-demangle_prefix (dm, encode_return_type)
- demangling_t dm;
- int *encode_return_type;
+static struct d_comp *
+d_function_type (di)
+ struct d_info *di;
{
- int start = substitution_start (dm);
- int nested = 0;
+ struct d_comp *ret;
- /* ENCODE_RETURN_TYPE is updated as we decend the nesting chain.
- After <template-args>, it is set to non-zero; after everything
- else it is set to zero. */
+ if (d_next_char (di) != 'F')
+ return NULL;
+ 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);
+ if (d_next_char (di) != 'E')
+ return NULL;
+ return ret;
+}
- /* Generally, the return type is encoded if the function is a
- template-id, and suppressed otherwise. There are a few cases,
- though, in which the return type is not encoded even for a
- templated function. In these cases, this flag is set. */
- int suppress_return_type = 0;
+/* <bare-function-type> ::= <type>+ */
- DEMANGLE_TRACE ("prefix", dm);
+static struct d_comp *
+d_bare_function_type (di, has_return_type)
+ struct d_info *di;
+ int has_return_type;
+{
+ struct d_comp *return_type;
+ struct d_comp *tl;
+ struct d_comp **ptl;
+ return_type = NULL;
+ tl = NULL;
+ ptl = &tl;
while (1)
{
char peek;
+ struct d_comp *type;
- if (end_of_name_p (dm))
- return "Unexpected end of name in <compound-name>.";
-
- peek = peek_char (dm);
-
- /* We'll initialize suppress_return_type to false, and set it to true
- if we end up demangling a constructor name. However, make
- sure we're not actually about to demangle template arguments
- -- if so, this is the <template-args> following a
- <template-prefix>, so we'll want the previous flag value
- around. */
- if (peek != 'I')
- suppress_return_type = 0;
-
- if (IS_DIGIT ((unsigned char) peek)
- || (peek >= 'a' && peek <= 'z')
- || peek == 'C' || peek == 'D'
- || peek == 'S')
+ peek = d_peek_char (di);
+ if (peek == '\0' || peek == 'E')
+ break;
+ type = d_type (di);
+ if (type == NULL)
+ return NULL;
+ if (has_return_type)
{
- /* We have another level of scope qualification. */
- if (nested)
- RETURN_IF_ERROR (result_add (dm, NAMESPACE_SEPARATOR));
- else
- nested = 1;
-
- if (peek == 'S')
- /* The substitution determines whether this is a
- template-id. */
- RETURN_IF_ERROR (demangle_substitution (dm, encode_return_type));
- else
- {
- /* It's just a name. */
- RETURN_IF_ERROR
- (demangle_unqualified_name (dm, &suppress_return_type));
- *encode_return_type = 0;
- }
+ return_type = type;
+ has_return_type = 0;
}
- else if (peek == 'Z')
- RETURN_IF_ERROR (demangle_local_name (dm));
- else if (peek == 'I')
+ else
{
- RETURN_IF_ERROR (demangle_template_args (dm));
-
- /* Now we want to indicate to the caller that we've
- demangled template arguments, thus the prefix was a
- <template-prefix>. That's so that the caller knows to
- demangle the function's return type, if this turns out to
- be a function name. But, if it's a member template
- constructor or a templated conversion operator, report it
- as untemplated. Those never get encoded return types. */
- *encode_return_type = !suppress_return_type;
+ *ptl = d_make_comp (di, D_COMP_ARGLIST, type, NULL);
+ ptl = &d_right (*ptl);
}
- else if (peek == 'E')
- /* All done. */
- return STATUS_OK;
- else
- return "Unexpected character in <compound-name>.";
-
- if (peek != 'S'
- && peek_char (dm) != 'E')
- /* Add a new substitution for the prefix thus far. */
- RETURN_IF_ERROR (substitution_add (dm, start, *encode_return_type));
}
-}
-/* Demangles and emits an <unqualified-name>. If this
- <unqualified-name> is for a special function type that should never
- have its return type encoded (particularly, a constructor or
- conversion operator), *SUPPRESS_RETURN_TYPE is set to 1; otherwise,
- it is set to zero.
+ /* 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;
- <unqualified-name> ::= <operator-name>
- ::= <special-name>
- ::= <source-name> */
+ /* If we have a single parameter type void, omit it. */
+ if (d_right (tl) == NULL
+ && d_left (tl)->type == D_COMP_BUILTIN_TYPE
+ && d_left (tl)->u.s_builtin.type->print == D_PRINT_VOID)
+ tl = NULL;
-static status_t
-demangle_unqualified_name (dm, suppress_return_type)
- demangling_t dm;
- int *suppress_return_type;
-{
- char peek = peek_char (dm);
+ return d_make_comp (di, D_COMP_FUNCTION_TYPE, return_type, tl);
+}
- DEMANGLE_TRACE ("unqualified-name", dm);
+/* <class-enum-type> ::= <name> */
- /* By default, don't force suppression of the return type (though
- non-template functions still don't get a return type encoded). */
- *suppress_return_type = 0;
+static struct d_comp *
+d_class_enum_type (di)
+ struct d_info *di;
+{
+ return d_name (di);
+}
- if (IS_DIGIT ((unsigned char) peek))
- RETURN_IF_ERROR (demangle_source_name (dm));
- else if (peek >= 'a' && peek <= 'z')
- {
- int num_args;
+/* <array-type> ::= A <(positive dimension) number> _ <(element) type>
+ ::= A [<(dimension) expression>] _ <(element) type>
+*/
- /* Conversion operators never have a return type encoded. */
- if (peek == 'c' && peek_char_next (dm) == 'v')
- *suppress_return_type = 1;
+static struct d_comp *
+d_array_type (di)
+ struct d_info *di;
+{
+ char peek;
+ struct d_comp *dim;
- RETURN_IF_ERROR (demangle_operator_name (dm, 0, &num_args, NULL));
- }
- else if (peek == 'C' || peek == 'D')
+ if (d_next_char (di) != 'A')
+ return NULL;
+
+ peek = d_peek_char (di);
+ if (peek == '_')
+ dim = NULL;
+ else if (IS_DIGIT (peek))
{
- /* Constructors never have a return type encoded. */
- if (peek == 'C')
- *suppress_return_type = 1;
+ const char *s;
- RETURN_IF_ERROR (demangle_ctor_dtor_name (dm));
+ s = d_str (di);
+ do
+ {
+ d_advance (di, 1);
+ peek = d_peek_char (di);
+ }
+ while (IS_DIGIT (peek));
+ dim = d_make_name (di, s, d_str (di) - s);
}
else
- return "Unexpected character in <unqualified-name>.";
+ {
+ dim = d_expression (di);
+ if (dim == NULL)
+ return NULL;
+ }
- return STATUS_OK;
-}
+ if (d_next_char (di) != '_')
+ return NULL;
-/* Demangles and emits <source-name>.
+ return d_make_comp (di, D_COMP_ARRAY_TYPE, dim, d_type (di));
+}
- <source-name> ::= <length number> <identifier> */
+/* <pointer-to-member-type> ::= M <(class) type> <(member) type> */
-static status_t
-demangle_source_name (dm)
- demangling_t dm;
+static struct d_comp *
+d_pointer_to_member_type (di)
+ struct d_info *di;
{
- int length;
+ struct d_comp *cl;
+ struct d_comp *mem;
+ struct d_comp **pmem;
- DEMANGLE_TRACE ("source-name", dm);
+ if (d_next_char (di) != 'M')
+ return NULL;
- /* Decode the length of the identifier. */
- RETURN_IF_ERROR (demangle_number (dm, &length, 10, 0));
- if (length == 0)
- return "Zero length in <source-name>.";
+ cl = d_type (di);
- /* Now the identifier itself. It's placed into last_source_name,
- where it can be used to build a constructor or destructor name. */
- RETURN_IF_ERROR (demangle_identifier (dm, length,
- dm->last_source_name));
+ /* The ABI specifies that any type can be a substitution source, and
+ that M is followed by two types, and that when a CV-qualified
+ type is seen both the base type and the CV-qualified types are
+ substitution sources. The ABI also specifies that for a pointer
+ to a CV-qualified member function, the qualifiers are attached to
+ the second type. Given the grammar, a plain reading of the ABI
+ suggests that both the CV-qualified member function and the
+ non-qualified member function are substitution sources. However,
+ g++ does not work that way. g++ treats only the CV-qualified
+ member function as a substitution source. FIXME. So to work
+ with g++, we need to pull off the CV-qualifiers here, in order to
+ avoid calling add_substitution() in d_type(). */
- /* Emit it. */
- RETURN_IF_ERROR (result_add_string (dm, dm->last_source_name));
+ pmem = d_cv_qualifiers (di, &mem);
+ *pmem = d_type (di);
- return STATUS_OK;
+ return d_make_comp (di, D_COMP_PTRMEM_TYPE, cl, mem);
}
-/* Demangles a number, either a <number> or a <positive-number> at the
- current position, consuming all consecutive digit characters. Sets
- *VALUE to the resulting numberand returns STATUS_OK. The number is
- interpreted as BASE, which must be either 10 or 36. If IS_SIGNED
- is non-zero, negative numbers -- prefixed with `n' -- are accepted.
-
- <number> ::= [n] <positive-number>
-
- <positive-number> ::= <decimal integer> */
+/* <template-param> ::= T_
+ ::= T <(parameter-2 non-negative) number> _
+*/
-static status_t
-demangle_number (dm, value, base, is_signed)
- demangling_t dm;
- int *value;
- int base;
- int is_signed;
+static struct d_comp *
+d_template_param (di)
+ struct d_info *di;
{
- dyn_string_t number = dyn_string_new (10);
+ long param;
- DEMANGLE_TRACE ("number", dm);
+ if (d_next_char (di) != 'T')
+ return NULL;
- if (number == NULL)
- return STATUS_ALLOCATION_FAILED;
+ if (d_peek_char (di) == '_')
+ param = 0;
+ else
+ {
+ param = d_number (di);
+ if (param < 0)
+ return NULL;
+ param += 1;
+ }
- demangle_number_literally (dm, number, base, is_signed);
- *value = strtol (dyn_string_buf (number), NULL, base);
- dyn_string_delete (number);
+ if (d_next_char (di) != '_')
+ return NULL;
- return STATUS_OK;
+ return d_make_template_param (di, param);
}
-/* Demangles a number at the current position. The digits (and minus
- sign, if present) that make up the number are appended to STR.
- Only base-BASE digits are accepted; BASE must be either 10 or 36.
- If IS_SIGNED, negative numbers -- prefixed with `n' -- are
- accepted. Does not consume a trailing underscore or other
- terminating character. */
-
-static status_t
-demangle_number_literally (dm, str, base, is_signed)
- demangling_t dm;
- dyn_string_t str;
- int base;
- int is_signed;
+/* <template-args> ::= I <template-arg>+ E */
+
+static struct d_comp *
+d_template_args (di)
+ struct d_info *di;
{
- DEMANGLE_TRACE ("number*", dm);
+ struct d_comp *hold_last_name;
+ struct d_comp *al;
+ struct d_comp **pal;
- if (base != 10 && base != 36)
- return STATUS_INTERNAL_ERROR;
+ /* Preserve the last name we saw--don't let the template arguments
+ clobber it, as that would give us the wrong name for a subsequent
+ constructor or destructor. */
+ hold_last_name = di->last_name;
- /* An `n' denotes a negative number. */
- if (is_signed && peek_char (dm) == 'n')
- {
- /* Skip past the n. */
- advance_char (dm);
- /* The normal way to write a negative number is with a minus
- sign. */
- if (!dyn_string_append_char (str, '-'))
- return STATUS_ALLOCATION_FAILED;
- }
+ if (d_next_char (di) != 'I')
+ return NULL;
- /* Loop until we hit a non-digit. */
+ al = NULL;
+ pal = &al;
while (1)
{
- char peek = peek_char (dm);
- if (IS_DIGIT ((unsigned char) peek)
- || (base == 36 && peek >= 'A' && peek <= 'Z'))
+ struct d_comp *a;
+
+ a = d_template_arg (di);
+ if (a == NULL)
+ return NULL;
+
+ *pal = d_make_comp (di, D_COMP_TEMPLATE_ARGLIST, a, NULL);
+ pal = &d_right (*pal);
+
+ if (d_peek_char (di) == 'E')
{
- /* Accumulate digits. */
- if (!dyn_string_append_char (str, next_char (dm)))
- return STATUS_ALLOCATION_FAILED;
+ d_advance (di, 1);
+ break;
}
- else
- /* Not a digit? All done. */
- break;
}
- return STATUS_OK;
+ di->last_name = hold_last_name;
+
+ return al;
}
-/* Demangles an identifier at the current position of LENGTH
- characters and places it in IDENTIFIER. */
+/* <template-arg> ::= <type>
+ ::= X <expression> E
+ ::= <expr-primary>
+*/
-static status_t
-demangle_identifier (dm, length, identifier)
- demangling_t dm;
- int length;
- dyn_string_t identifier;
+static struct d_comp *
+d_template_arg (di)
+ struct d_info *di;
{
- DEMANGLE_TRACE ("identifier", dm);
-
- dyn_string_clear (identifier);
- if (!dyn_string_resize (identifier, length))
- return STATUS_ALLOCATION_FAILED;
+ struct d_comp *ret;
- while (length-- > 0)
+ switch (d_peek_char (di))
{
- int ch;
- if (end_of_name_p (dm))
- return "Unexpected end of name in <identifier>.";
- ch = next_char (dm);
-
- /* Handle extended Unicode characters. We encode them as __U{hex}_,
- where {hex} omits leading 0's. For instance, '$' is encoded as
- "__U24_". */
- if (ch == '_'
- && peek_char (dm) == '_'
- && peek_char_next (dm) == 'U')
- {
- char buf[10];
- int pos = 0;
- advance_char (dm); advance_char (dm); length -= 2;
- while (length-- > 0)
- {
- ch = next_char (dm);
- if (!isxdigit (ch))
- break;
- buf[pos++] = ch;
- }
- if (ch != '_' || length < 0)
- return STATUS_ERROR;
- if (pos == 0)
- {
- /* __U_ just means __U. */
- if (!dyn_string_append_cstr (identifier, "__U"))
- return STATUS_ALLOCATION_FAILED;
- continue;
- }
- else
- {
- buf[pos] = '\0';
- ch = strtol (buf, 0, 16);
- }
- }
+ case 'X':
+ d_advance (di, 1);
+ ret = d_expression (di);
+ if (d_next_char (di) != 'E')
+ return NULL;
+ return ret;
- if (!dyn_string_append_char (identifier, ch))
- return STATUS_ALLOCATION_FAILED;
- }
+ case 'L':
+ return d_expr_primary (di);
- /* GCC encodes anonymous namespaces using a `_GLOBAL_[_.$]N.'
- followed by the source file name and some random characters.
- Unless we're in strict mode, decipher these names appropriately. */
- if (!flag_strict)
- {
- char *name = dyn_string_buf (identifier);
- int prefix_length = strlen (ANONYMOUS_NAMESPACE_PREFIX);
-
- /* Compare the first, fixed part. */
- if (strncmp (name, ANONYMOUS_NAMESPACE_PREFIX, prefix_length) == 0)
- {
- name += prefix_length;
- /* The next character might be a period, an underscore, or
- dollar sign, depending on the target architecture's
- assembler's capabilities. After that comes an `N'. */
- if ((*name == '.' || *name == '_' || *name == '$')
- && *(name + 1) == 'N')
- /* This looks like the anonymous namespace identifier.
- Replace it with something comprehensible. */
- dyn_string_copy_cstr (identifier, "(anonymous namespace)");
- }
+ default:
+ return d_type (di);
}
-
- return STATUS_OK;
}
-/* Demangles and emits an <operator-name>. If SHORT_NAME is non-zero,
- the short form is emitted; otherwise the full source form
- (`operator +' etc.) is emitted. *NUM_ARGS is set to the number of
- operands that the operator takes. If TYPE_ARG is non-NULL,
- *TYPE_ARG is set to 1 if the first argument is a type and 0
- otherwise.
-
- <operator-name>
- ::= nw # new
- ::= na # new[]
- ::= dl # delete
- ::= da # delete[]
- ::= ps # + (unary)
- ::= ng # - (unary)
- ::= ad # & (unary)
- ::= de # * (unary)
- ::= co # ~
- ::= pl # +
- ::= mi # -
- ::= ml # *
- ::= dv # /
- ::= rm # %
- ::= an # &
- ::= or # |
- ::= eo # ^
- ::= aS # =
- ::= pL # +=
- ::= mI # -=
- ::= mL # *=
- ::= dV # /=
- ::= rM # %=
- ::= aN # &=
- ::= oR # |=
- ::= eO # ^=
- ::= ls # <<
- ::= rs # >>
- ::= lS # <<=
- ::= rS # >>=
- ::= eq # ==
- ::= ne # !=
- ::= lt # <
- ::= gt # >
- ::= le # <=
- ::= ge # >=
- ::= nt # !
- ::= aa # &&
- ::= oo # ||
- ::= pp # ++
- ::= mm # --
- ::= cm # ,
- ::= pm # ->*
- ::= pt # ->
- ::= cl # ()
- ::= ix # []
- ::= qu # ?
- ::= st # sizeof (a type)
- ::= sz # sizeof (an expression)
- ::= cv <type> # cast
- ::= v [0-9] <source-name> # vendor extended operator */
-
-static status_t
-demangle_operator_name (dm, short_name, num_args, type_arg)
- demangling_t dm;
- int short_name;
- int *num_args;
- int *type_arg;
+/* <expression> ::= <(unary) operator-name> <expression>
+ ::= <(binary) operator-name> <expression> <expression>
+ ::= <(trinary) operator-name> <expression> <expression> <expression>
+ ::= st <type>
+ ::= <template-param>
+ ::= sr <type> <unqualified-name>
+ ::= sr <type> <unqualified-name> <template-args>
+ ::= <expr-primary>
+*/
+
+static struct d_comp *
+d_expression (di)
+ struct d_info *di;
{
- struct operator_code
- {
- /* The mangled code for this operator. */
- const char *const code;
- /* The source name of this operator. */
- const char *const name;
- /* The number of arguments this operator takes. */
- const int num_args;
- };
-
- static const struct operator_code operators[] =
- {
- { "aN", "&=" , 2 },
- { "aS", "=" , 2 },
- { "aa", "&&" , 2 },
- { "ad", "&" , 1 },
- { "an", "&" , 2 },
- { "cl", "()" , 0 },
- { "cm", "," , 2 },
- { "co", "~" , 1 },
- { "dV", "/=" , 2 },
- { "da", " delete[]", 1 },
- { "de", "*" , 1 },
- { "dl", " delete" , 1 },
- { "dv", "/" , 2 },
- { "eO", "^=" , 2 },
- { "eo", "^" , 2 },
- { "eq", "==" , 2 },
- { "ge", ">=" , 2 },
- { "gt", ">" , 2 },
- { "ix", "[]" , 2 },
- { "lS", "<<=" , 2 },
- { "le", "<=" , 2 },
- { "ls", "<<" , 2 },
- { "lt", "<" , 2 },
- { "mI", "-=" , 2 },
- { "mL", "*=" , 2 },
- { "mi", "-" , 2 },
- { "ml", "*" , 2 },
- { "mm", "--" , 1 },
- { "na", " new[]" , 1 },
- { "ne", "!=" , 2 },
- { "ng", "-" , 1 },
- { "nt", "!" , 1 },
- { "nw", " new" , 1 },
- { "oR", "|=" , 2 },
- { "oo", "||" , 2 },
- { "or", "|" , 2 },
- { "pL", "+=" , 2 },
- { "pl", "+" , 2 },
- { "pm", "->*" , 2 },
- { "pp", "++" , 1 },
- { "ps", "+" , 1 },
- { "pt", "->" , 2 },
- { "qu", "?" , 3 },
- { "rM", "%=" , 2 },
- { "rS", ">>=" , 2 },
- { "rm", "%" , 2 },
- { "rs", ">>" , 2 },
- { "sz", "sizeof" , 1 }
- };
-
- const int num_operators =
- sizeof (operators) / sizeof (struct operator_code);
-
- int c0 = next_char (dm);
- int c1 = next_char (dm);
- const struct operator_code* p1 = operators;
- const struct operator_code* p2 = operators + num_operators;
-
- DEMANGLE_TRACE ("operator-name", dm);
-
- /* Assume the first argument is not a type. */
- if (type_arg)
- *type_arg = 0;
-
- /* Is this a vendor-extended operator? */
- if (c0 == 'v' && IS_DIGIT (c1))
- {
- RETURN_IF_ERROR (result_add (dm, "operator "));
- RETURN_IF_ERROR (demangle_source_name (dm));
- *num_args = 0;
- return STATUS_OK;
- }
+ char peek;
- /* Is this a conversion operator? */
- if (c0 == 'c' && c1 == 'v')
+ peek = d_peek_char (di);
+ if (peek == 'L')
+ return d_expr_primary (di);
+ else if (peek == 'T')
+ return d_template_param (di);
+ else if (peek == 's' && d_peek_next_char (di) == 'r')
{
- RETURN_IF_ERROR (result_add (dm, "operator "));
- /* Demangle the converted-to type. */
- RETURN_IF_ERROR (demangle_type (dm));
- *num_args = 0;
- return STATUS_OK;
- }
+ struct d_comp *type;
+ struct d_comp *name;
- /* Is it the sizeof variant that takes a type? */
- if (c0 == 's' && c1 == 't')
- {
- RETURN_IF_ERROR (result_add (dm, " sizeof"));
- *num_args = 1;
- if (type_arg)
- *type_arg = 1;
- return STATUS_OK;
+ d_advance (di, 2);
+ type = d_type (di);
+ name = d_unqualified_name (di);
+ if (d_peek_char (di) != 'I')
+ return d_make_comp (di, D_COMP_QUAL_NAME, type, name);
+ else
+ return d_make_comp (di, D_COMP_QUAL_NAME, type,
+ d_make_comp (di, D_COMP_TEMPLATE, name,
+ d_template_args (di)));
}
-
- /* Perform a binary search for the operator code. */
- while (1)
+ else
{
- const struct operator_code* p = p1 + (p2 - p1) / 2;
- char match0 = p->code[0];
- char match1 = p->code[1];
+ struct d_comp *op;
+ int args;
- if (c0 == match0 && c1 == match1)
- /* Found it. */
- {
- if (!short_name)
- RETURN_IF_ERROR (result_add (dm, "operator"));
- RETURN_IF_ERROR (result_add (dm, p->name));
- *num_args = p->num_args;
-
- return STATUS_OK;
- }
+ op = d_operator_name (di);
+ if (op == NULL)
+ return NULL;
- if (p == p1)
- /* Couldn't find it. */
- return "Unknown code in <operator-name>.";
+ if (op->type == D_COMP_OPERATOR
+ && strcmp (op->u.s_operator.op->code, "st") == 0)
+ return d_make_comp (di, D_COMP_UNARY, op, d_type (di));
- /* Try again. */
- if (c0 < match0 || (c0 == match0 && c1 < match1))
- p2 = p;
- else
- p1 = p;
+ switch (op->type)
+ {
+ default:
+ return NULL;
+ case D_COMP_OPERATOR:
+ args = op->u.s_operator.op->args;
+ break;
+ case D_COMP_EXTENDED_OPERATOR:
+ args = op->u.s_extended_operator.args;
+ break;
+ case D_COMP_CAST:
+ args = 1;
+ break;
+ }
+
+ switch (args)
+ {
+ case 1:
+ return d_make_comp (di, D_COMP_UNARY, op, d_expression (di));
+ case 2:
+ {
+ struct d_comp *left;
+
+ left = d_expression (di);
+ return d_make_comp (di, D_COMP_BINARY, op,
+ d_make_comp (di, D_COMP_BINARY_ARGS, left,
+ d_expression (di)));
+ }
+ case 3:
+ {
+ struct d_comp *first;
+ struct d_comp *second;
+
+ first = d_expression (di);
+ second = d_expression (di);
+ return d_make_comp (di, D_COMP_TRINARY, op,
+ d_make_comp (di, D_COMP_TRINARY_ARG1, first,
+ d_make_comp (di,
+ D_COMP_TRINARY_ARG2,
+ second,
+ d_expression (di))));
+ }
+ default:
+ return NULL;
+ }
}
}
-/* Demangles and omits an <nv-offset>.
-
- <nv-offset> ::= <offset number> # non-virtual base override */
+/* <expr-primary> ::= L <type> <(value) number> E
+ ::= L <type> <(value) float> E
+ ::= L <mangled-name> E
+*/
-static status_t
-demangle_nv_offset (dm)
- demangling_t dm;
+static struct d_comp *
+d_expr_primary (di)
+ struct d_info *di;
{
- dyn_string_t number;
- status_t status = STATUS_OK;
-
- DEMANGLE_TRACE ("h-offset", dm);
+ struct d_comp *ret;
- /* Demangle the offset. */
- number = dyn_string_new (4);
- if (number == NULL)
- return STATUS_ALLOCATION_FAILED;
- demangle_number_literally (dm, number, 10, 1);
-
- /* Don't display the offset unless in verbose mode. */
- if (flag_verbose)
+ if (d_next_char (di) != 'L')
+ return NULL;
+ if (d_peek_char (di) == '_')
+ ret = d_mangled_name (di);
+ else
{
- status = result_add (dm, " [nv:");
- if (STATUS_NO_ERROR (status))
- status = result_add_string (dm, number);
- if (STATUS_NO_ERROR (status))
- status = result_add_char (dm, ']');
- }
-
- /* Clean up. */
- dyn_string_delete (number);
- RETURN_IF_ERROR (status);
- return STATUS_OK;
+ struct d_comp *type;
+ const char *s;
+
+ type = d_type (di);
+
+ /* Rather than try to interpret the literal value, we just
+ collect it as a string. Note that it's possible to have a
+ floating point literal here. The ABI specifies that the
+ format of such literals is machine independent. That's fine,
+ but what's not fine is that versions of g++ up to 3.2 with
+ -fabi-version=1 used upper case letters in the hex constant,
+ and dumped out gcc's internal representation. That makes it
+ hard to tell where the constant ends, and hard to dump the
+ constant in any readable form anyhow. We don't attempt to
+ handle these cases. */
+
+ s = d_str (di);
+ while (d_peek_char (di) != 'E')
+ d_advance (di, 1);
+ ret = d_make_comp (di, D_COMP_LITERAL, type,
+ d_make_name (di, s, d_str (di) - s));
+ }
+ if (d_next_char (di) != 'E')
+ return NULL;
+ return ret;
}
-/* Demangles and emits a <v-offset>.
-
- <v-offset> ::= <offset number> _ <virtual offset number>
- # virtual base override, with vcall offset */
+/* <local-name> ::= Z <(function) encoding> E <(entity) name> [<discriminator>]
+ ::= Z <(function) encoding> E s [<discriminator>]
+*/
-static status_t
-demangle_v_offset (dm)
- demangling_t dm;
+static struct d_comp *
+d_local_name (di)
+ struct d_info *di;
{
- dyn_string_t number;
- status_t status = STATUS_OK;
-
- DEMANGLE_TRACE ("v-offset", dm);
+ struct d_comp *function;
- /* Demangle the offset. */
- number = dyn_string_new (4);
- if (number == NULL)
- return STATUS_ALLOCATION_FAILED;
- demangle_number_literally (dm, number, 10, 1);
-
- /* Don't display the offset unless in verbose mode. */
- if (flag_verbose)
- {
- status = result_add (dm, " [v:");
- if (STATUS_NO_ERROR (status))
- status = result_add_string (dm, number);
- if (STATUS_NO_ERROR (status))
- result_add_char (dm, ',');
- }
- dyn_string_delete (number);
- RETURN_IF_ERROR (status);
+ if (d_next_char (di) != 'Z')
+ return NULL;
- /* Demangle the separator. */
- RETURN_IF_ERROR (demangle_char (dm, '_'));
+ function = d_encoding (di);
- /* Demangle the vcall offset. */
- number = dyn_string_new (4);
- if (number == NULL)
- return STATUS_ALLOCATION_FAILED;
- demangle_number_literally (dm, number, 10, 1);
+ if (d_next_char (di) != 'E')
+ return NULL;
- /* Don't display the vcall offset unless in verbose mode. */
- if (flag_verbose)
+ if (d_peek_char (di) == 's')
{
- status = result_add_string (dm, number);
- if (STATUS_NO_ERROR (status))
- status = result_add_char (dm, ']');
+ d_advance (di, 1);
+ if (! d_discriminator (di))
+ return NULL;
+ return d_make_comp (di, D_COMP_QUAL_NAME, function,
+ d_make_name (di, "string literal",
+ sizeof "string literal" - 1));
}
- dyn_string_delete (number);
- RETURN_IF_ERROR (status);
-
- return STATUS_OK;
-}
-
-/* Demangles and emits a <call-offset>.
-
- <call-offset> ::= h <nv-offset> _
- ::= v <v-offset> _ */
-
-static status_t
-demangle_call_offset (dm)
- demangling_t dm;
-{
- DEMANGLE_TRACE ("call-offset", dm);
-
- switch (peek_char (dm))
+ else
{
- case 'h':
- advance_char (dm);
- /* Demangle the offset. */
- RETURN_IF_ERROR (demangle_nv_offset (dm));
- /* Demangle the separator. */
- RETURN_IF_ERROR (demangle_char (dm, '_'));
- break;
+ struct d_comp *name;
- case 'v':
- advance_char (dm);
- /* Demangle the offset. */
- RETURN_IF_ERROR (demangle_v_offset (dm));
- /* Demangle the separator. */
- RETURN_IF_ERROR (demangle_char (dm, '_'));
- break;
-
- default:
- return "Unrecognized <call-offset>.";
+ name = d_name (di);
+ if (! d_discriminator (di))
+ return NULL;
+ return d_make_comp (di, D_COMP_QUAL_NAME, function, name);
}
-
- return STATUS_OK;
}
-/* Demangles and emits a <special-name>.
-
- <special-name> ::= GV <object name> # Guard variable
- ::= TV <type> # virtual table
- ::= TT <type> # VTT
- ::= TI <type> # typeinfo structure
- ::= TS <type> # typeinfo name
+/* <discriminator> ::= _ <(non-negative) number>
- Other relevant productions include thunks:
+ We demangle the discriminator, but we don't print it out. FIXME:
+ We should print it out in verbose mode. */
- <special-name> ::= T <call-offset> <base encoding>
- # base is the nominal target function of thunk
-
- <special-name> ::= Tc <call-offset> <call-offset> <base encoding>
- # base is the nominal target function of thunk
- # first call-offset is 'this' adjustment
- # second call-offset is result adjustment
-
- where
-
- <call-offset> ::= h <nv-offset> _
- ::= v <v-offset> _
+static int
+d_discriminator (di)
+ struct d_info *di;
+{
+ long discrim;
- Also demangles the special g++ manglings,
+ if (d_peek_char (di) != '_')
+ return 1;
+ d_advance (di, 1);
+ discrim = d_number (di);
+ if (discrim < 0)
+ return 0;
+ return 1;
+}
- <special-name> ::= TC <type> <offset number> _ <base type>
- # construction vtable
- ::= TF <type> # typeinfo function (old ABI only)
- ::= TJ <type> # java Class structure */
+/* Add a new substitution. */
-static status_t
-demangle_special_name (dm)
- demangling_t dm;
+static int
+d_add_substitution (di, dc)
+ struct d_info *di;
+ struct d_comp *dc;
{
- dyn_string_t number;
- int unused;
- char peek = peek_char (dm);
+ if (di->next_sub >= di->num_subs)
+ return 0;
+ di->subs[di->next_sub] = dc;
+ ++di->next_sub;
+ return 1;
+}
+
+/* <substitution> ::= S <seq-id> _
+ ::= S_
+ ::= St
+ ::= Sa
+ ::= Sb
+ ::= Ss
+ ::= Si
+ ::= So
+ ::= Sd
+*/
- DEMANGLE_TRACE ("special-name", dm);
+static struct d_comp *
+d_substitution (di)
+ struct d_info *di;
+{
+ char c;
- if (peek == 'G')
- {
- /* Consume the G. */
- advance_char (dm);
- switch (peek_char (dm))
- {
- case 'V':
- /* A guard variable name. */
- advance_char (dm);
- RETURN_IF_ERROR (result_add (dm, "guard variable for "));
- RETURN_IF_ERROR (demangle_name (dm, &unused));
- break;
+ if (d_next_char (di) != 'S')
+ return NULL;
- case 'R':
- /* A reference temporary. */
- advance_char (dm);
- RETURN_IF_ERROR (result_add (dm, "reference temporary for "));
- RETURN_IF_ERROR (demangle_name (dm, &unused));
- break;
-
- default:
- return "Unrecognized <special-name>.";
- }
- }
- else if (peek == 'T')
+ c = d_next_char (di);
+ if (c == '_' || IS_DIGIT (c) || (c >= 'A' && c <= 'Z'))
{
- status_t status = STATUS_OK;
-
- /* Other C++ implementation miscellania. Consume the T. */
- advance_char (dm);
+ int id;
- switch (peek_char (dm))
+ id = 0;
+ if (c != '_')
{
- case 'V':
- /* Virtual table. */
- advance_char (dm);
- RETURN_IF_ERROR (result_add (dm, "vtable for "));
- RETURN_IF_ERROR (demangle_type (dm));
- break;
-
- case 'T':
- /* VTT structure. */
- advance_char (dm);
- RETURN_IF_ERROR (result_add (dm, "VTT for "));
- RETURN_IF_ERROR (demangle_type (dm));
- break;
-
- case 'I':
- /* Typeinfo structure. */
- advance_char (dm);
- RETURN_IF_ERROR (result_add (dm, "typeinfo for "));
- RETURN_IF_ERROR (demangle_type (dm));
- break;
-
- case 'F':
- /* Typeinfo function. Used only in old ABI with new mangling. */
- advance_char (dm);
- RETURN_IF_ERROR (result_add (dm, "typeinfo fn for "));
- RETURN_IF_ERROR (demangle_type (dm));
- break;
-
- case 'S':
- /* Character string containing type name, used in typeinfo. */
- advance_char (dm);
- RETURN_IF_ERROR (result_add (dm, "typeinfo name for "));
- RETURN_IF_ERROR (demangle_type (dm));
- break;
-
- case 'J':
- /* The java Class variable corresponding to a C++ class. */
- advance_char (dm);
- RETURN_IF_ERROR (result_add (dm, "java Class for "));
- RETURN_IF_ERROR (demangle_type (dm));
- break;
-
- case 'h':
- /* Non-virtual thunk. */
- advance_char (dm);
- RETURN_IF_ERROR (result_add (dm, "non-virtual thunk"));
- RETURN_IF_ERROR (demangle_nv_offset (dm));
- /* Demangle the separator. */
- RETURN_IF_ERROR (demangle_char (dm, '_'));
- /* Demangle and emit the target name and function type. */
- RETURN_IF_ERROR (result_add (dm, " to "));
- RETURN_IF_ERROR (demangle_encoding (dm));
- break;
-
- case 'v':
- /* Virtual thunk. */
- advance_char (dm);
- RETURN_IF_ERROR (result_add (dm, "virtual thunk"));
- RETURN_IF_ERROR (demangle_v_offset (dm));
- /* Demangle the separator. */
- RETURN_IF_ERROR (demangle_char (dm, '_'));
- /* Demangle and emit the target function. */
- RETURN_IF_ERROR (result_add (dm, " to "));
- RETURN_IF_ERROR (demangle_encoding (dm));
- break;
-
- case 'c':
- /* Covariant return thunk. */
- advance_char (dm);
- RETURN_IF_ERROR (result_add (dm, "covariant return thunk"));
- RETURN_IF_ERROR (demangle_call_offset (dm));
- RETURN_IF_ERROR (demangle_call_offset (dm));
- /* Demangle and emit the target function. */
- RETURN_IF_ERROR (result_add (dm, " to "));
- RETURN_IF_ERROR (demangle_encoding (dm));
- break;
-
- case 'C':
- /* TC is a special g++ mangling for a construction vtable. */
- if (!flag_strict)
+ do
{
- dyn_string_t derived_type;
-
- advance_char (dm);
- RETURN_IF_ERROR (result_add (dm, "construction vtable for "));
-
- /* Demangle the derived type off to the side. */
- RETURN_IF_ERROR (result_push (dm));
- RETURN_IF_ERROR (demangle_type (dm));
- derived_type = (dyn_string_t) result_pop (dm);
-
- /* Demangle the offset. */
- number = dyn_string_new (4);
- if (number == NULL)
- {
- dyn_string_delete (derived_type);
- return STATUS_ALLOCATION_FAILED;
- }
- demangle_number_literally (dm, number, 10, 1);
- /* Demangle the underscore separator. */
- status = demangle_char (dm, '_');
-
- /* Demangle the base type. */
- if (STATUS_NO_ERROR (status))
- status = demangle_type (dm);
-
- /* Emit the derived type. */
- if (STATUS_NO_ERROR (status))
- status = result_add (dm, "-in-");
- if (STATUS_NO_ERROR (status))
- status = result_add_string (dm, derived_type);
- dyn_string_delete (derived_type);
-
- /* Don't display the offset unless in verbose mode. */
- if (flag_verbose)
- {
- status = result_add_char (dm, ' ');
- if (STATUS_NO_ERROR (status))
- result_add_string (dm, number);
- }
- dyn_string_delete (number);
- RETURN_IF_ERROR (status);
- break;
+ if (IS_DIGIT (c))
+ id = id * 36 + c - '0';
+ else if (c >= 'A' && c <= 'Z')
+ id = id * 36 + c - 'A' + 10;
+ else
+ return NULL;
+ c = d_next_char (di);
}
- /* If flag_strict, fall through. */
+ while (c != '_');
- default:
- return "Unrecognized <special-name>.";
+ ++id;
}
- }
- else
- return STATUS_ERROR;
-
- return STATUS_OK;
-}
-
-/* Demangles and emits a <ctor-dtor-name>.
-
- <ctor-dtor-name>
- ::= C1 # complete object (in-charge) ctor
- ::= C2 # base object (not-in-charge) ctor
- ::= C3 # complete object (in-charge) allocating ctor
- ::= D0 # deleting (in-charge) dtor
- ::= D1 # complete object (in-charge) dtor
- ::= D2 # base object (not-in-charge) dtor */
-
-static status_t
-demangle_ctor_dtor_name (dm)
- demangling_t dm;
-{
- static const char *const ctor_flavors[] =
- {
- "in-charge",
- "not-in-charge",
- "allocating"
- };
- static const char *const dtor_flavors[] =
- {
- "in-charge deleting",
- "in-charge",
- "not-in-charge"
- };
- int flavor;
- char peek = peek_char (dm);
+ if (id >= di->next_sub)
+ return NULL;
- DEMANGLE_TRACE ("ctor-dtor-name", dm);
-
- if (peek == 'C')
- {
- /* A constructor name. Consume the C. */
- advance_char (dm);
- flavor = next_char (dm);
- if (flavor < '1' || flavor > '3')
- return "Unrecognized constructor.";
- RETURN_IF_ERROR (result_add_string (dm, dm->last_source_name));
- switch (flavor)
- {
- case '1': dm->is_constructor = gnu_v3_complete_object_ctor;
- break;
- case '2': dm->is_constructor = gnu_v3_base_object_ctor;
- break;
- case '3': dm->is_constructor = gnu_v3_complete_object_allocating_ctor;
- break;
- }
- /* Print the flavor of the constructor if in verbose mode. */
- if (flag_verbose)
- {
- RETURN_IF_ERROR (result_add (dm, "["));
- RETURN_IF_ERROR (result_add (dm, ctor_flavors[flavor - '1']));
- RETURN_IF_ERROR (result_add_char (dm, ']'));
- }
+ return di->subs[id];
}
- else if (peek == 'D')
+ else
{
- /* A destructor name. Consume the D. */
- advance_char (dm);
- flavor = next_char (dm);
- if (flavor < '0' || flavor > '2')
- return "Unrecognized destructor.";
- RETURN_IF_ERROR (result_add_char (dm, '~'));
- RETURN_IF_ERROR (result_add_string (dm, dm->last_source_name));
- switch (flavor)
+ switch (c)
{
- case '0': dm->is_destructor = gnu_v3_deleting_dtor;
- break;
- case '1': dm->is_destructor = gnu_v3_complete_object_dtor;
- break;
- case '2': dm->is_destructor = gnu_v3_base_object_dtor;
- break;
- }
- /* Print the flavor of the destructor if in verbose mode. */
- if (flag_verbose)
- {
- RETURN_IF_ERROR (result_add (dm, " ["));
- RETURN_IF_ERROR (result_add (dm, dtor_flavors[flavor - '0']));
- RETURN_IF_ERROR (result_add_char (dm, ']'));
+ case 't':
+ return d_make_sub (di, "std");
+ case 'a':
+ di->last_name = d_make_sub (di, "allocator");
+ return d_make_sub (di, "std::allocator");
+ case 'b':
+ di->last_name = d_make_sub (di, "basic_string");
+ return d_make_sub (di, "std::basic_string");
+ case 's':
+ di->last_name = d_make_sub (di, "string");
+ return d_make_sub (di, "std::string");
+ case 'i':
+ di->last_name = d_make_sub (di, "istream");
+ return d_make_sub (di, "std::istream");
+ case 'o':
+ di->last_name = d_make_sub (di, "ostream");
+ return d_make_sub (di, "std::ostream");
+ case 'd':
+ di->last_name = d_make_sub (di, "iostream");
+ return d_make_sub (di, "std::iostream");
+ default:
+ return NULL;
}
}
- else
- return STATUS_ERROR;
-
- return STATUS_OK;
}
-/* Handle pointer, reference, and pointer-to-member cases for
- demangle_type. All consecutive `P's, `R's, and 'M's are joined to
- build a pointer/reference type. We snarf all these, plus the
- following <type>, all at once since we need to know whether we have
- a pointer to data or pointer to function to construct the right
- output syntax. C++'s pointer syntax is hairy.
-
- This function adds substitution candidates for every nested
- pointer/reference type it processes, including the outermost, final
- type, assuming the substitution starts at SUBSTITUTION_START in the
- demangling result. For example, if this function demangles
- `PP3Foo', it will add a substitution for `Foo', `Foo*', and
- `Foo**', in that order.
-
- *INSERT_POS is a quantity used internally, when this function calls
- itself recursively, to figure out where to insert pointer
- punctuation on the way up. On entry to this function, INSERT_POS
- should point to a temporary value, but that value need not be
- initialized.
-
- <type> ::= P <type>
- ::= R <type>
- ::= <pointer-to-member-type>
-
- <pointer-to-member-type> ::= M </class/ type> </member/ type> */
-
-static status_t
-demangle_type_ptr (dm, insert_pos, substitution_start)
- demangling_t dm;
- int *insert_pos;
- int substitution_start;
-{
- status_t status;
- int is_substitution_candidate = 1;
+/* Resize the print buffer. */
- DEMANGLE_TRACE ("type*", dm);
+static void
+d_print_resize (dpi, add)
+ struct d_print_info *dpi;
+ size_t add;
+{
+ size_t need;
- /* Scan forward, collecting pointers and references into symbols,
- until we hit something else. Then emit the type. */
- switch (peek_char (dm))
+ need = dpi->len + add;
+ while (need > dpi->alc)
{
- case 'P':
- /* A pointer. Snarf the `P'. */
- advance_char (dm);
- /* Demangle the underlying type. */
- RETURN_IF_ERROR (demangle_type_ptr (dm, insert_pos,
- substitution_start));
- /* Insert an asterisk where we're told to; it doesn't
- necessarily go at the end. If we're doing Java style output,
- there is no pointer symbol. */
- if (dm->style != DMGL_JAVA)
- RETURN_IF_ERROR (result_insert_char (dm, *insert_pos, '*'));
- /* The next (outermost) pointer or reference character should go
- after this one. */
- ++(*insert_pos);
- break;
-
- case 'R':
- /* A reference. Snarf the `R'. */
- advance_char (dm);
- /* Demangle the underlying type. */
- RETURN_IF_ERROR (demangle_type_ptr (dm, insert_pos,
- substitution_start));
- /* Insert an ampersand where we're told to; it doesn't
- necessarily go at the end. */
- RETURN_IF_ERROR (result_insert_char (dm, *insert_pos, '&'));
- /* The next (outermost) pointer or reference character should go
- after this one. */
- ++(*insert_pos);
- break;
+ size_t newalc;
+ char *newbuf;
- case 'M':
- {
- /* A pointer-to-member. */
- dyn_string_t class_type;
- char peek;
- int reset_caret = 0;
- int old_caret_position;
-
- /* Eat the 'M'. */
- advance_char (dm);
-
- /* Capture the type of which this is a pointer-to-member. */
- RETURN_IF_ERROR (result_push (dm));
- RETURN_IF_ERROR (demangle_type (dm));
- class_type = (dyn_string_t) result_pop (dm);
-
- peek = peek_char (dm);
- old_caret_position = result_get_caret (dm);
- if (peek == 'r' || peek == 'V' || peek == 'K')
+ newalc = dpi->alc * 2;
+ newbuf = realloc (dpi->buf, newalc);
+ if (newbuf == NULL)
{
- dyn_string_t cv_qualifiers = dyn_string_new (24);
- status_t status;
-
- if (cv_qualifiers == NULL)
- return STATUS_ALLOCATION_FAILED;
-
- /* Decode all adjacent CV qualifiers. */
- demangle_CV_qualifiers (dm, cv_qualifiers);
-
- /* Emit them, and shift the caret left so that the
- underlying type will be emitted before the
- qualifiers. */
- status = result_add_string (dm, cv_qualifiers);
- result_shift_caret (dm, -dyn_string_length (cv_qualifiers));
-
- dyn_string_delete (cv_qualifiers);
- RETURN_IF_ERROR (status);
- /* Prepend a blank. */
- RETURN_IF_ERROR (result_add_char (dm, ' '));
- result_shift_caret (dm, -1);
-
- peek = peek_char (dm);
- reset_caret = 1;
- }
-
- if (peek == 'F')
- /* A pointer-to-member function. We want output along the
- lines of `void (C::*) (int, int)'. Demangle the function
- type, which would in this case give `void () (int, int)'
- and set *insert_pos to the spot between the first
- parentheses. */
- status = demangle_type_ptr (dm, insert_pos, substitution_start);
- else if (peek == 'A')
- /* A pointer-to-member array variable. We want output that
- looks like `int (Klass::*) [10]'. Demangle the array type
- as `int () [10]', and set *insert_pos to the spot between
- the parentheses. */
- status = demangle_array_type (dm, insert_pos);
- else
- {
- /* A pointer-to-member variable. Demangle the type of the
- pointed-to member. */
- status = demangle_type (dm);
- /* Make it pretty. */
- if (STATUS_NO_ERROR (status)
- && !result_previous_char_is_space (dm))
- status = result_add_char (dm, ' ');
- /* The pointer-to-member notation (e.g. `C::*') follows the
- member's type. */
- *insert_pos = result_caret_pos (dm);
+ free (dpi->buf);
+ dpi->buf = NULL;
+ dpi->allocation_failure = 1;
+ return;
}
-
- /* Build the pointer-to-member notation. */
- if (STATUS_NO_ERROR (status))
- status = result_insert (dm, *insert_pos, "::*");
- if (STATUS_NO_ERROR (status))
- status = result_insert_string (dm, *insert_pos, class_type);
- /* There may be additional levels of (pointer or reference)
- indirection in this type. If so, the `*' and `&' should be
- added after the pointer-to-member notation (e.g. `C::*&' for
- a reference to a pointer-to-member of class C). */
- *insert_pos += dyn_string_length (class_type) + 3;
-
- /* Clean up. */
- dyn_string_delete (class_type);
-
- if (reset_caret)
- result_set_caret (dm, old_caret_position);
-
- RETURN_IF_ERROR (status);
+ dpi->buf = newbuf;
+ dpi->alc = newalc;
}
- break;
-
- case 'F':
- /* Ooh, tricky, a pointer-to-function. When we demangle the
- function type, the return type should go at the very
- beginning. */
- *insert_pos = result_caret_pos (dm);
- /* The parentheses indicate this is a function pointer or
- reference type. */
- RETURN_IF_ERROR (result_add (dm, "()"));
- /* Now demangle the function type. The return type will be
- inserted before the `()', and the argument list will go after
- it. */
- RETURN_IF_ERROR (demangle_function_type (dm, insert_pos));
- /* We should now have something along the lines of
- `void () (int, int)'. The pointer or reference characters
- have to inside the first set of parentheses. *insert_pos has
- already been updated to point past the end of the return
- type. Move it one character over so it points inside the
- `()'. */
- ++(*insert_pos);
- break;
-
- case 'A':
- /* An array pointer or reference. demangle_array_type will figure
- out where the asterisks and ampersands go. */
- RETURN_IF_ERROR (demangle_array_type (dm, insert_pos));
- break;
-
- case 'r':
- case 'V':
- case 'K':
- /* Qualified base type. Pick up the qualifiers. */
- {
- dyn_string_t cv_qualifiers = dyn_string_new (24);
-
- if (cv_qualifiers == NULL)
- return STATUS_ALLOCATION_FAILED;
-
- /* Pick up all adjacent CV qualifiers. */
- demangle_CV_qualifiers (dm, cv_qualifiers);
-
- /* Demangle the underlying type. */
- status = demangle_type_ptr (dm, insert_pos, substitution_start);
-
- /* Insert the qualifiers where we're told to. */
- if (STATUS_NO_ERROR (status))
- {
- status = result_insert_char (dm, *insert_pos, ' ');
- ++(*insert_pos);
- if (STATUS_NO_ERROR (status))
- status = result_insert_string (dm, *insert_pos, cv_qualifiers);
- }
+}
- /* The next character should go after the qualifiers. */
- *insert_pos += dyn_string_length (cv_qualifiers);
+/* Append a character to the print buffer. */
- dyn_string_delete (cv_qualifiers);
- RETURN_IF_ERROR (status);
- }
- break;
+static void
+d_print_append_char (dpi, c)
+ struct d_print_info *dpi;
+ int c;
+{
+ if (dpi->buf != NULL)
+ {
+ if (dpi->len >= dpi->alc)
+ {
+ d_print_resize (dpi, 1);
+ if (dpi->buf == NULL)
+ return;
+ }
- default:
- /* No more pointer or reference tokens; this is therefore a
- pointer to data. Finish up by demangling the underlying
- type. */
- RETURN_IF_ERROR (demangle_type (dm));
- /* The pointer or reference characters follow the underlying
- type, as in `int*&'. */
- *insert_pos = result_caret_pos (dm);
- /* Because of the production <type> ::= <substitution>,
- demangle_type will already have added the underlying type as
- a substitution candidate. Don't do it again. */
- is_substitution_candidate = 0;
- break;
+ dpi->buf[dpi->len] = c;
+ ++dpi->len;
}
-
- if (is_substitution_candidate)
- RETURN_IF_ERROR (substitution_add (dm, substitution_start, 0));
-
- return STATUS_OK;
}
-/* Demangles and emits a <type>.
-
- <type> ::= <builtin-type>
- ::= <function-type>
- ::= <class-enum-type>
- ::= <array-type>
- ::= <pointer-to-member-type>
- ::= <template-param>
- ::= <template-template-param> <template-args>
- ::= <CV-qualifiers> <type>
- ::= P <type> # pointer-to
- ::= R <type> # reference-to
- ::= C <type> # complex pair (C 2000)
- ::= G <type> # imaginary (C 2000)
- ::= U <source-name> <type> # vendor extended type qualifier
- ::= <substitution> */
-
-static status_t
-demangle_type (dm)
- demangling_t dm;
+/* Append a buffer to the print buffer. */
+
+static void
+d_print_append_buffer (dpi, s, l)
+ struct d_print_info *dpi;
+ const char *s;
+ size_t l;
{
- int start = substitution_start (dm);
- char peek = peek_char (dm);
- char peek_next;
- int encode_return_type = 0;
- template_arg_list_t old_arg_list = current_template_arg_list (dm);
- int insert_pos;
-
- /* A <type> can be a <substitution>; therefore, this <type> is a
- substitution candidate unless a special condition holds (see
- below). */
- int is_substitution_candidate = 1;
-
- DEMANGLE_TRACE ("type", dm);
-
- /* A <class-enum-type> can start with a digit (a <source-name>), an
- N (a <nested-name>), or a Z (a <local-name>). */
- if (IS_DIGIT ((unsigned char) peek) || peek == 'N' || peek == 'Z')
- RETURN_IF_ERROR (demangle_class_enum_type (dm, &encode_return_type));
- /* Lower-case letters begin <builtin-type>s, except for `r', which
- denotes restrict. */
- else if (peek >= 'a' && peek <= 'z' && peek != 'r')
+ if (dpi->buf != NULL)
{
- RETURN_IF_ERROR (demangle_builtin_type (dm));
- /* Built-in types are not substitution candidates. */
- is_substitution_candidate = 0;
- }
- else
- switch (peek)
- {
- case 'r':
- case 'V':
- case 'K':
- /* CV-qualifiers (including restrict). We have to demangle
- them off to the side, since C++ syntax puts them in a funny
- place for qualified pointer and reference types. */
+ if (dpi->len + l > dpi->alc)
{
- status_t status;
- dyn_string_t cv_qualifiers = dyn_string_new (24);
- int old_caret_position = result_get_caret (dm);
-
- if (cv_qualifiers == NULL)
- return STATUS_ALLOCATION_FAILED;
-
- /* Decode all adjacent CV qualifiers. */
- demangle_CV_qualifiers (dm, cv_qualifiers);
-
- /* If the underlying type is a pointer or reference type, we
- need to call demangle_type_ptr to find out where to put
- the qualifiers. */
- peek = peek_char (dm);
- if (peek == 'P' || peek == 'R' || peek == 'M')
- {
- status = demangle_type_ptr (dm, &insert_pos,
- substitution_start (dm));
- if (STATUS_NO_ERROR (status))
- {
- status = result_insert_char (dm, insert_pos, ' ');
- if (STATUS_NO_ERROR (status))
- status = result_insert_string (dm, insert_pos + 1,
- cv_qualifiers);
- }
- dyn_string_delete (cv_qualifiers);
- RETURN_IF_ERROR (status);
- }
- else
- {
- /* Emit the qualifiers, and shift the caret left so that
- the underlying type will be emitted first. */
- status = result_add_string (dm, cv_qualifiers);
- result_shift_caret (dm, -dyn_string_length (cv_qualifiers));
- /* Clean up. */
- dyn_string_delete (cv_qualifiers);
- RETURN_IF_ERROR (status);
- /* Also prepend a blank, if needed. */
- RETURN_IF_ERROR (result_add_char (dm, ' '));
- result_shift_caret (dm, -1);
-
- /* Demangle the underlying type. It will be emitted before
- the CV qualifiers, since we moved the caret. */
- RETURN_IF_ERROR (demangle_type (dm));
-
- /* Put the caret back where it was previously. */
- result_set_caret (dm, old_caret_position);
- }
+ d_print_resize (dpi, l);
+ if (dpi->buf == NULL)
+ return;
}
- break;
- case 'F':
- /* The return type should go at the current position. */
- insert_pos = result_caret_pos (dm);
- /* Put in parentheses to indicate that this is a function. */
- RETURN_IF_ERROR (result_add (dm, "()"));
- /* Demangle the function type. The return type will be
- inserted before the '()', and the argument list will go
- after it. */
- RETURN_IF_ERROR (demangle_function_type (dm, &insert_pos));
- break;
-
- case 'A':
- RETURN_IF_ERROR (demangle_array_type (dm, NULL));
- break;
-
- case 'T':
- /* It's either a <template-param> or a
- <template-template-param>. In either case, demangle the
- `T' token first. */
- RETURN_IF_ERROR (demangle_template_param (dm));
-
- /* Check for a template argument list; if one is found, it's a
- <template-template-param> ::= <template-param>
- ::= <substitution> */
- if (peek_char (dm) == 'I')
- {
- /* Add a substitution candidate. The template parameter
- `T' token is a substitution candidate by itself,
- without the template argument list. */
- RETURN_IF_ERROR (substitution_add (dm, start, encode_return_type));
-
- /* Now demangle the template argument list. */
- RETURN_IF_ERROR (demangle_template_args (dm));
- /* The entire type, including the template template
- parameter and its argument list, will be added as a
- substitution candidate below. */
- }
-
- break;
-
- case 'S':
- /* First check if this is a special substitution. If it is,
- this is a <class-enum-type>. Special substitutions have a
- lower-case letter following the `S'; other substitutions
- have a digit, upper-case letter, or underscore. */
- peek_next = peek_char_next (dm);
- if (IS_DIGIT (peek_next)
- || (peek_next >= 'A' && peek_next <= 'Z')
- || peek_next == '_')
- {
- RETURN_IF_ERROR (demangle_substitution (dm, &encode_return_type));
-
- /* The substituted name may have been a template name.
- Check if template arguments follow, and if so, demangle
- them. */
- if (peek_char (dm) == 'I')
- RETURN_IF_ERROR (demangle_template_args (dm));
- else
- /* A substitution token is not itself a substitution
- candidate. (However, if the substituted template is
- instantiated, the resulting type is.) */
- is_substitution_candidate = 0;
- }
- else
- {
- /* Now some trickiness. We have a special substitution
- here. Often, the special substitution provides the
- name of a template that's subsequently instantiated,
- for instance `SaIcE' => std::allocator<char>. In these
- cases we need to add a substitution candidate for the
- entire <class-enum-type> and thus don't want to clear
- the is_substitution_candidate flag.
-
- However, it's possible that what we have here is a
- substitution token representing an entire type, such as
- `Ss' => std::string. In this case, we mustn't add a
- new substitution candidate for this substitution token.
- To detect this case, remember where the start of the
- substitution token is. */
- const char *next = dm->next;
- /* Now demangle the <class-enum-type>. */
- RETURN_IF_ERROR
- (demangle_class_enum_type (dm, &encode_return_type));
- /* If all that was just demangled is the two-character
- special substitution token, supress the addition of a
- new candidate for it. */
- if (dm->next == next + 2)
- is_substitution_candidate = 0;
- }
-
- break;
-
- case 'P':
- case 'R':
- case 'M':
- RETURN_IF_ERROR (demangle_type_ptr (dm, &insert_pos, start));
- /* demangle_type_ptr adds all applicable substitution
- candidates. */
- is_substitution_candidate = 0;
- break;
-
- case 'C':
- /* A C99 complex type. */
- RETURN_IF_ERROR (result_add (dm, "complex "));
- advance_char (dm);
- RETURN_IF_ERROR (demangle_type (dm));
- break;
-
- case 'G':
- /* A C99 imaginary type. */
- RETURN_IF_ERROR (result_add (dm, "imaginary "));
- advance_char (dm);
- RETURN_IF_ERROR (demangle_type (dm));
- break;
-
- case 'U':
- /* Vendor-extended type qualifier. */
- advance_char (dm);
- RETURN_IF_ERROR (demangle_source_name (dm));
- RETURN_IF_ERROR (result_add_char (dm, ' '));
- RETURN_IF_ERROR (demangle_type (dm));
- break;
-
- default:
- return "Unexpected character in <type>.";
- }
-
- if (is_substitution_candidate)
- /* Add a new substitution for the type. If this type was a
- <template-param>, pass its index since from the point of
- substitutions; a <template-param> token is a substitution
- candidate distinct from the type that is substituted for it. */
- RETURN_IF_ERROR (substitution_add (dm, start, encode_return_type));
-
- /* Pop off template argument lists added during mangling of this
- type. */
- pop_to_template_arg_list (dm, old_arg_list);
-
- return STATUS_OK;
+ memcpy (dpi->buf + dpi->len, s, l);
+ dpi->len += l;
+ }
}
-/* C++ source names of builtin types, indexed by the mangled code
- letter's position in the alphabet ('a' -> 0, 'b' -> 1, etc). */
-static const char *const builtin_type_names[26] =
-{
- "signed char", /* a */
- "bool", /* b */
- "char", /* c */
- "double", /* d */
- "long double", /* e */
- "float", /* f */
- "__float128", /* g */
- "unsigned char", /* h */
- "int", /* i */
- "unsigned", /* j */
- NULL, /* k */
- "long", /* l */
- "unsigned long", /* m */
- "__int128", /* n */
- "unsigned __int128", /* o */
- NULL, /* p */
- NULL, /* q */
- NULL, /* r */
- "short", /* s */
- "unsigned short", /* t */
- NULL, /* u */
- "void", /* v */
- "wchar_t", /* w */
- "long long", /* x */
- "unsigned long long", /* y */
- "..." /* z */
-};
+/* Indicate that an error occurred during printing. */
-/* Java source names of builtin types. Types that arn't valid in Java
- are also included here - we don't fail if someone attempts to demangle a
- C++ symbol in Java style. */
-static const char *const java_builtin_type_names[26] =
+static void
+d_print_error (dpi)
+ struct d_print_info *dpi;
{
- "signed char", /* a */
- "boolean", /* C++ "bool" */ /* b */
- "byte", /* C++ "char" */ /* c */
- "double", /* d */
- "long double", /* e */
- "float", /* f */
- "__float128", /* g */
- "unsigned char", /* h */
- "int", /* i */
- "unsigned", /* j */
- NULL, /* k */
- "long", /* l */
- "unsigned long", /* m */
- "__int128", /* n */
- "unsigned __int128", /* o */
- NULL, /* p */
- NULL, /* q */
- NULL, /* r */
- "short", /* s */
- "unsigned short", /* t */
- NULL, /* u */
- "void", /* v */
- "char", /* C++ "wchar_t" */ /* w */
- "long", /* C++ "long long" */ /* x */
- "unsigned long long", /* y */
- "..." /* z */
-};
+ free (dpi->buf);
+ dpi->buf = NULL;
+}
-/* Demangles and emits a <builtin-type>.
-
- <builtin-type> ::= v # void
- ::= w # wchar_t
- ::= b # bool
- ::= c # char
- ::= a # signed char
- ::= h # unsigned char
- ::= s # short
- ::= t # unsigned short
- ::= i # int
- ::= j # unsigned int
- ::= l # long
- ::= m # unsigned long
- ::= x # long long, __int64
- ::= y # unsigned long long, __int64
- ::= n # __int128
- ::= o # unsigned __int128
- ::= f # float
- ::= d # double
- ::= e # long double, __float80
- ::= g # __float128
- ::= z # ellipsis
- ::= u <source-name> # vendor extended type */
-
-static status_t
-demangle_builtin_type (dm)
- demangling_t dm;
-{
+/* Turn components into a human readable string. Returns a string
+ allocated by malloc, or NULL on error. On success, this sets *PALC
+ to the size of the allocated buffer. On failure, this sets *PALC
+ to 0 for a bad parse, or to 1 for a memory allocation failure. */
- char code = peek_char (dm);
+static char *
+d_print (options, dc, palc)
+ int options;
+ const struct d_comp *dc;
+ size_t *palc;
+{
+ struct d_print_info dpi;
- DEMANGLE_TRACE ("builtin-type", dm);
+ dpi.options = options;
- if (code == 'u')
- {
- advance_char (dm);
- RETURN_IF_ERROR (demangle_source_name (dm));
- return STATUS_OK;
- }
- else if (code >= 'a' && code <= 'z')
+ dpi.alc = 64;
+ dpi.buf = malloc (dpi.alc);
+ if (dpi.buf == NULL)
{
- const char *type_name;
- /* Java uses different names for some built-in types. */
- if (dm->style == DMGL_JAVA)
- type_name = java_builtin_type_names[code - 'a'];
- else
- type_name = builtin_type_names[code - 'a'];
- if (type_name == NULL)
- return "Unrecognized <builtin-type> code.";
-
- RETURN_IF_ERROR (result_add (dm, type_name));
- advance_char (dm);
- return STATUS_OK;
+ *palc = 1;
+ return NULL;
}
- else
- return "Non-alphabetic <builtin-type> code.";
-}
-
-/* Demangles all consecutive CV-qualifiers (const, volatile, and
- restrict) at the current position. The qualifiers are appended to
- QUALIFIERS. Returns STATUS_OK. */
-static status_t
-demangle_CV_qualifiers (dm, qualifiers)
- demangling_t dm;
- dyn_string_t qualifiers;
-{
- DEMANGLE_TRACE ("CV-qualifiers", dm);
+ dpi.len = 0;
+ dpi.templates = NULL;
+ dpi.modifiers = NULL;
- while (1)
- {
- switch (peek_char (dm))
- {
- case 'r':
- if (!dyn_string_append_space (qualifiers))
- return STATUS_ALLOCATION_FAILED;
- if (!dyn_string_append_cstr (qualifiers, "restrict"))
- return STATUS_ALLOCATION_FAILED;
- break;
+ dpi.allocation_failure = 0;
- case 'V':
- if (!dyn_string_append_space (qualifiers))
- return STATUS_ALLOCATION_FAILED;
- if (!dyn_string_append_cstr (qualifiers, "volatile"))
- return STATUS_ALLOCATION_FAILED;
- break;
+ d_print_comp (&dpi, dc);
- case 'K':
- if (!dyn_string_append_space (qualifiers))
- return STATUS_ALLOCATION_FAILED;
- if (!dyn_string_append_cstr (qualifiers, "const"))
- return STATUS_ALLOCATION_FAILED;
- break;
+ d_append_char (&dpi, '\0');
- default:
- return STATUS_OK;
- }
+ if (dpi.buf != NULL)
+ *palc = dpi.alc;
+ else
+ *palc = dpi.allocation_failure;
- advance_char (dm);
- }
+ return dpi.buf;
}
-/* Demangles and emits a <function-type>. *FUNCTION_NAME_POS is the
- position in the result string of the start of the function
- identifier, at which the function's return type will be inserted;
- *FUNCTION_NAME_POS is updated to position past the end of the
- function's return type.
+/* Subroutine to handle components. */
- <function-type> ::= F [Y] <bare-function-type> E */
-
-static status_t
-demangle_function_type (dm, function_name_pos)
- demangling_t dm;
- int *function_name_pos;
+static void
+d_print_comp (dpi, dc)
+ struct d_print_info *dpi;
+ const struct d_comp *dc;
{
- DEMANGLE_TRACE ("function-type", dm);
- RETURN_IF_ERROR (demangle_char (dm, 'F'));
- if (peek_char (dm) == 'Y')
+ if (dc == NULL)
{
- /* Indicate this function has C linkage if in verbose mode. */
- if (flag_verbose)
- RETURN_IF_ERROR (result_add (dm, " [extern \"C\"] "));
- advance_char (dm);
+ d_print_error (dpi);
+ return;
}
- RETURN_IF_ERROR (demangle_bare_function_type (dm, function_name_pos));
- RETURN_IF_ERROR (demangle_char (dm, 'E'));
- return STATUS_OK;
-}
-
-/* Demangles and emits a <bare-function-type>. RETURN_TYPE_POS is the
- position in the result string at which the function return type
- should be inserted. If RETURN_TYPE_POS is BFT_NO_RETURN_TYPE, the
- function's return type is assumed not to be encoded.
-
- <bare-function-type> ::= <signature type>+ */
-
-static status_t
-demangle_bare_function_type (dm, return_type_pos)
- demangling_t dm;
- int *return_type_pos;
-{
- /* Sequence is the index of the current function parameter, counting
- from zero. The value -1 denotes the return type. */
- int sequence =
- (return_type_pos == BFT_NO_RETURN_TYPE ? 0 : -1);
-
- DEMANGLE_TRACE ("bare-function-type", dm);
+ if (d_print_saw_error (dpi))
+ return;
- RETURN_IF_ERROR (result_add_char (dm, '('));
- while (!end_of_name_p (dm) && peek_char (dm) != 'E')
+ switch (dc->type)
{
- if (sequence == -1)
- /* We're decoding the function's return type. */
- {
- dyn_string_t return_type;
- status_t status = STATUS_OK;
-
- /* Decode the return type off to the side. */
- RETURN_IF_ERROR (result_push (dm));
- RETURN_IF_ERROR (demangle_type (dm));
- return_type = (dyn_string_t) result_pop (dm);
-
- /* Add a space to the end of the type. Insert the return
- type where we've been asked to. */
- if (!dyn_string_append_space (return_type))
- status = STATUS_ALLOCATION_FAILED;
- if (STATUS_NO_ERROR (status))
- {
- if (!dyn_string_insert (result_string (dm), *return_type_pos,
- return_type))
- status = STATUS_ALLOCATION_FAILED;
- else
- *return_type_pos += dyn_string_length (return_type);
- }
+ case D_COMP_NAME:
+ d_print_identifier (dpi, dc->u.s_name.s, dc->u.s_name.len);
+ return;
- dyn_string_delete (return_type);
- RETURN_IF_ERROR (status);
- }
- else
- {
- /* Skip `void' parameter types. One should only occur as
- the only type in a parameter list; in that case, we want
- to print `foo ()' instead of `foo (void)'. */
- if (peek_char (dm) == 'v')
- /* Consume the v. */
- advance_char (dm);
- else
- {
- /* Separate parameter types by commas. */
- if (sequence > 0)
- RETURN_IF_ERROR (result_add (dm, ", "));
- /* Demangle the type. */
- RETURN_IF_ERROR (demangle_type (dm));
- }
- }
+ case D_COMP_QUAL_NAME:
+ d_print_comp (dpi, d_left (dc));
+ d_append_string (dpi, (dpi->options & DMGL_JAVA) == 0 ? "::" : ".");
+ d_print_comp (dpi, d_right (dc));
+ return;
- ++sequence;
- }
- RETURN_IF_ERROR (result_add_char (dm, ')'));
+ case D_COMP_TYPED_NAME:
+ {
+ const struct d_comp *typed_name;
+ struct d_print_mod dpm;
+ struct d_print_template dpt;
+
+ /* Pass the name down to the type so that it can be printed in
+ the right place for the type. If the name has
+ CV-qualifiers, they are really method qualifiers; pull them
+ off now and print them after everything else. Note that we
+ don't handle D_COMP_VENDOR_TYPE_QUAL here; it's not
+ accepted by d_cv_qualifiers() either. */
+ typed_name = d_left (dc);
+ while (typed_name != NULL
+ && (typed_name->type == D_COMP_RESTRICT
+ || typed_name->type == D_COMP_VOLATILE
+ || typed_name->type == D_COMP_CONST))
+ typed_name = d_left (typed_name);
+
+ dpm.next = dpi->modifiers;
+ dpi->modifiers = &dpm;
+ dpm.mod = typed_name;
+ dpm.printed = 0;
+
+ /* If typed_name is a template, then it applies to the
+ function type as well. */
+ if (typed_name->type == D_COMP_TEMPLATE)
+ {
+ dpt.next = dpi->templates;
+ dpi->templates = &dpt;
+ dpt.template = typed_name;
+ }
- /* We should have demangled at least one parameter type (which would
- be void, for a function that takes no parameters), plus the
- return type, if we were supposed to demangle that. */
- if (sequence == -1)
- return "Missing function return type.";
- else if (sequence == 0)
- return "Missing function parameter.";
+ d_print_comp (dpi, d_right (dc));
- return STATUS_OK;
-}
+ if (typed_name->type == D_COMP_TEMPLATE)
+ dpi->templates = dpt.next;
-/* Demangles and emits a <class-enum-type>. *ENCODE_RETURN_TYPE is set to
- non-zero if the type is a template-id, zero otherwise.
+ /* If the modifier didn't get printed by the type, print it
+ now. */
+ if (! dpm.printed)
+ {
+ d_append_char (dpi, ' ');
+ d_print_comp (dpi, typed_name);
+ }
- <class-enum-type> ::= <name> */
+ dpi->modifiers = dpm.next;
-static status_t
-demangle_class_enum_type (dm, encode_return_type)
- demangling_t dm;
- int *encode_return_type;
-{
- DEMANGLE_TRACE ("class-enum-type", dm);
+ /* Now print any CV-qualifiers on the type. */
+ typed_name = d_left (dc);
+ while (typed_name != NULL
+ && (typed_name->type == D_COMP_RESTRICT
+ || typed_name->type == D_COMP_VOLATILE
+ || typed_name->type == D_COMP_CONST))
+ {
+ d_print_mod (dpi, typed_name);
+ typed_name = d_left (typed_name);
+ }
- RETURN_IF_ERROR (demangle_name (dm, encode_return_type));
- return STATUS_OK;
-}
+ return;
+ }
-/* Demangles and emits an <array-type>.
+ case D_COMP_TEMPLATE:
+ d_print_comp (dpi, d_left (dc));
+ d_append_char (dpi, '<');
+ d_print_comp (dpi, d_right (dc));
+ /* Avoid generating two consecutive '>' characters, to avoid the
+ C++ syntactic ambiguity. */
+ if (dpi->buf[dpi->len - 1] == '>')
+ d_append_char (dpi, ' ');
+ d_append_char (dpi, '>');
+ return;
+
+ case D_COMP_TEMPLATE_PARAM:
+ {
+ long i;
+ struct d_comp *a;
+ struct d_print_template *hold_dpt;
- If PTR_INSERT_POS is not NULL, the array type is formatted as a
- pointer or reference to an array, except that asterisk and
- ampersand punctuation is omitted (since it's not know at this
- point). *PTR_INSERT_POS is set to the position in the demangled
- name at which this punctuation should be inserted. For example,
- `A10_i' is demangled to `int () [10]' and *PTR_INSERT_POS points
- between the parentheses.
+ if (dpi->templates == NULL)
+ {
+ d_print_error (dpi);
+ return;
+ }
+ i = dc->u.s_number.number;
+ for (a = d_right (dpi->templates->template);
+ a != NULL;
+ a = d_right (a))
+ {
+ if (a->type != D_COMP_TEMPLATE_ARGLIST)
+ {
+ d_print_error (dpi);
+ return;
+ }
+ if (i <= 0)
+ break;
+ --i;
+ }
+ if (i != 0 || a == NULL)
+ {
+ d_print_error (dpi);
+ return;
+ }
- If PTR_INSERT_POS is NULL, the array type is assumed not to be
- pointer- or reference-qualified. Then, for example, `A10_i' is
- demangled simply as `int[10]'.
+ /* While processing this parameter, we need to pop the list of
+ templates. This is because the template parameter may
+ itself be a reference to a parameter of an outer
+ template. */
- <array-type> ::= A [<dimension number>] _ <element type>
- ::= A <dimension expression> _ <element type> */
+ hold_dpt = dpi->templates;
+ dpi->templates = hold_dpt->next;
-static status_t
-demangle_array_type (dm, ptr_insert_pos)
- demangling_t dm;
- int *ptr_insert_pos;
-{
- status_t status = STATUS_OK;
- dyn_string_t array_size = NULL;
- char peek;
+ d_print_comp (dpi, d_left (a));
- DEMANGLE_TRACE ("array-type", dm);
+ dpi->templates = hold_dpt;
- RETURN_IF_ERROR (demangle_char (dm, 'A'));
+ return;
+ }
- /* Demangle the array size into array_size. */
- peek = peek_char (dm);
- if (peek == '_')
- /* Array bound is omitted. This is a C99-style VLA. */
- ;
- else if (IS_DIGIT (peek_char (dm)))
- {
- /* It looks like a constant array bound. */
- array_size = dyn_string_new (10);
- if (array_size == NULL)
- return STATUS_ALLOCATION_FAILED;
- status = demangle_number_literally (dm, array_size, 10, 0);
- }
- else
- {
- /* Anything is must be an expression for a nont-constant array
- bound. This happens if the array type occurs in a template
- and the array bound references a template parameter. */
- RETURN_IF_ERROR (result_push (dm));
- RETURN_IF_ERROR (demangle_expression (dm));
- array_size = (dyn_string_t) result_pop (dm);
- }
- /* array_size may have been allocated by now, so we can't use
- RETURN_IF_ERROR until it's been deallocated. */
+ case D_COMP_CTOR:
+ d_print_comp (dpi, dc->u.s_ctor.name);
+ return;
+
+ case D_COMP_DTOR:
+ d_append_char (dpi, '~');
+ d_print_comp (dpi, dc->u.s_dtor.name);
+ return;
+
+ case D_COMP_VTABLE:
+ d_append_string (dpi, "vtable for ");
+ d_print_comp (dpi, d_left (dc));
+ return;
+
+ case D_COMP_VTT:
+ d_append_string (dpi, "VTT for ");
+ d_print_comp (dpi, d_left (dc));
+ return;
+
+ case D_COMP_CONSTRUCTION_VTABLE:
+ d_append_string (dpi, "construction vtable for ");
+ d_print_comp (dpi, d_left (dc));
+ d_append_string (dpi, "-in-");
+ d_print_comp (dpi, d_right (dc));
+ return;
+
+ case D_COMP_TYPEINFO:
+ d_append_string (dpi, "typeinfo for ");
+ d_print_comp (dpi, d_left (dc));
+ return;
+
+ case D_COMP_TYPEINFO_NAME:
+ d_append_string (dpi, "typeinfo name for ");
+ d_print_comp (dpi, d_left (dc));
+ return;
+
+ case D_COMP_TYPEINFO_FN:
+ d_append_string (dpi, "typeinfo fn for ");
+ d_print_comp (dpi, d_left (dc));
+ return;
+
+ case D_COMP_THUNK:
+ d_append_string (dpi, "non-virtual thunk to ");
+ d_print_comp (dpi, d_left (dc));
+ return;
+
+ case D_COMP_VIRTUAL_THUNK:
+ d_append_string (dpi, "virtual thunk to ");
+ d_print_comp (dpi, d_left (dc));
+ return;
+
+ case D_COMP_COVARIANT_THUNK:
+ d_append_string (dpi, "covariant return thunk to ");
+ d_print_comp (dpi, d_left (dc));
+ return;
+
+ case D_COMP_JAVA_CLASS:
+ d_append_string (dpi, "java Class for ");
+ d_print_comp (dpi, d_left (dc));
+ return;
+
+ case D_COMP_GUARD:
+ d_append_string (dpi, "guard variable for ");
+ d_print_comp (dpi, d_left (dc));
+ return;
+
+ case D_COMP_REFTEMP:
+ d_append_string (dpi, "reference temporary for ");
+ d_print_comp (dpi, d_left (dc));
+ return;
+
+ case D_COMP_SUB_STD:
+ d_append_string (dpi, dc->u.s_string.string);
+ return;
+
+ case D_COMP_RESTRICT:
+ case D_COMP_VOLATILE:
+ case D_COMP_CONST:
+ case D_COMP_VENDOR_TYPE_QUAL:
+ case D_COMP_POINTER:
+ case D_COMP_REFERENCE:
+ case D_COMP_COMPLEX:
+ case D_COMP_IMAGINARY:
+ {
+ /* We keep a list of modifiers on the stack. */
+ struct d_print_mod dpm;
- /* Demangle the base type of the array. */
- if (STATUS_NO_ERROR (status))
- status = demangle_char (dm, '_');
- if (STATUS_NO_ERROR (status))
- status = demangle_type (dm);
+ dpm.next = dpi->modifiers;
+ dpi->modifiers = &dpm;
+ dpm.mod = dc;
+ dpm.printed = 0;
- if (ptr_insert_pos != NULL)
- {
- /* This array is actually part of an pointer- or
- reference-to-array type. Format appropriately, except we
- don't know which and how much punctuation to use. */
- if (STATUS_NO_ERROR (status))
- status = result_add (dm, " () ");
- /* Let the caller know where to insert the punctuation. */
- *ptr_insert_pos = result_caret_pos (dm) - 2;
- }
+ d_print_comp (dpi, d_left (dc));
- /* Emit the array dimension syntax. */
- if (STATUS_NO_ERROR (status))
- status = result_add_char (dm, '[');
- if (STATUS_NO_ERROR (status) && array_size != NULL)
- status = result_add_string (dm, array_size);
- if (STATUS_NO_ERROR (status))
- status = result_add_char (dm, ']');
- if (array_size != NULL)
- dyn_string_delete (array_size);
-
- RETURN_IF_ERROR (status);
-
- return STATUS_OK;
-}
+ /* If the modifier didn't get printed by the type, print it
+ now. */
+ if (! dpm.printed)
+ d_print_mod (dpi, dc);
-/* Demangles and emits a <template-param>.
+ dpi->modifiers = dpm.next;
- <template-param> ::= T_ # first template parameter
- ::= T <parameter-2 number> _ */
+ return;
+ }
-static status_t
-demangle_template_param (dm)
- demangling_t dm;
-{
- int parm_number;
- template_arg_list_t current_arg_list = current_template_arg_list (dm);
- string_list_t arg;
+ case D_COMP_BUILTIN_TYPE:
+ if ((dpi->options & DMGL_JAVA) == 0)
+ d_append_string (dpi, dc->u.s_builtin.type->name);
+ else
+ d_append_string (dpi, dc->u.s_builtin.type->java_name);
+ return;
- DEMANGLE_TRACE ("template-param", dm);
+ case D_COMP_VENDOR_TYPE:
+ d_print_comp (dpi, d_left (dc));
+ return;
- /* Make sure there is a template argmust list in which to look up
- this parameter reference. */
- if (current_arg_list == NULL)
- return "Template parameter outside of template.";
+ case D_COMP_FUNCTION_TYPE:
+ {
+ if (d_left (dc) != NULL)
+ {
+ struct d_print_mod dpm;
- RETURN_IF_ERROR (demangle_char (dm, 'T'));
- if (peek_char (dm) == '_')
- parm_number = 0;
- else
- {
- RETURN_IF_ERROR (demangle_number (dm, &parm_number, 10, 0));
- ++parm_number;
- }
- RETURN_IF_ERROR (demangle_char (dm, '_'));
+ /* We must pass this type down as a modifier in order to
+ print it in the right location. */
- arg = template_arg_list_get_arg (current_arg_list, parm_number);
- if (arg == NULL)
- /* parm_number exceeded the number of arguments in the current
- template argument list. */
- return "Template parameter number out of bounds.";
- RETURN_IF_ERROR (result_add_string (dm, (dyn_string_t) arg));
+ dpm.next = dpi->modifiers;
+ dpi->modifiers = &dpm;
+ dpm.mod = dc;
+ dpm.printed = 0;
- return STATUS_OK;
-}
+ d_print_comp (dpi, d_left (dc));
-/* Demangles and emits a <template-args>.
+ dpi->modifiers = dpm.next;
- <template-args> ::= I <template-arg>+ E */
+ if (dpm.printed)
+ return;
-static status_t
-demangle_template_args (dm)
- demangling_t dm;
-{
- int first = 1;
- dyn_string_t old_last_source_name;
- template_arg_list_t arg_list = template_arg_list_new ();
+ d_append_char (dpi, ' ');
+ }
- if (arg_list == NULL)
- return STATUS_ALLOCATION_FAILED;
+ d_print_function_type (dpi, dc, dpi->modifiers);
- /* Preserve the most recently demangled source name. */
- old_last_source_name = dm->last_source_name;
- dm->last_source_name = dyn_string_new (0);
+ return;
+ }
- DEMANGLE_TRACE ("template-args", dm);
+ case D_COMP_ARRAY_TYPE:
+ {
+ struct d_print_mod dpm;
- if (dm->last_source_name == NULL)
- return STATUS_ALLOCATION_FAILED;
+ /* We must pass this type down as a modifier in order to print
+ multi-dimensional arrays correctly. */
- RETURN_IF_ERROR (demangle_char (dm, 'I'));
- RETURN_IF_ERROR (result_open_template_list (dm));
- do
- {
- string_list_t arg;
+ dpm.next = dpi->modifiers;
+ dpi->modifiers = &dpm;
+ dpm.mod = dc;
+ dpm.printed = 0;
- if (first)
- first = 0;
- else
- RETURN_IF_ERROR (result_add (dm, ", "));
+ d_print_comp (dpi, d_right (dc));
- /* Capture the template arg. */
- RETURN_IF_ERROR (result_push (dm));
- RETURN_IF_ERROR (demangle_template_arg (dm));
- arg = result_pop (dm);
+ dpi->modifiers = dpm.next;
- /* Emit it in the demangled name. */
- RETURN_IF_ERROR (result_add_string (dm, (dyn_string_t) arg));
+ if (dpm.printed)
+ return;
- /* Save it for use in expanding <template-param>s. */
- template_arg_list_add_arg (arg_list, arg);
- }
- while (peek_char (dm) != 'E');
- /* Append the '>'. */
- RETURN_IF_ERROR (result_close_template_list (dm));
+ d_print_array_type (dpi, dc, dpi->modifiers);
- /* Consume the 'E'. */
- advance_char (dm);
+ return;
+ }
- /* Restore the most recent demangled source name. */
- dyn_string_delete (dm->last_source_name);
- dm->last_source_name = old_last_source_name;
+ case D_COMP_PTRMEM_TYPE:
+ {
+ const struct d_comp *target_type;
+ struct d_print_mod dpm;
+
+ /* Pass the name down to the type so that it can be printed in
+ the right place for the type. If the type has
+ CV-qualifiers, they are really method qualifiers; pull them
+ off now and print them after everything else. */
+ target_type = d_right (dc);
+ while (target_type != NULL
+ && (target_type->type == D_COMP_RESTRICT
+ || target_type->type == D_COMP_VOLATILE
+ || target_type->type == D_COMP_CONST))
+ target_type = d_left (target_type);
+
+ dpm.next = dpi->modifiers;
+ dpi->modifiers = &dpm;
+ dpm.mod = dc;
+ dpm.printed = 0;
+
+ d_print_comp (dpi, target_type);
+
+ /* If the modifier didn't get printed by the type, print it
+ now. */
+ if (! dpm.printed)
+ {
+ d_append_char (dpi, ' ');
+ d_print_comp (dpi, d_left (dc));
+ d_append_string (dpi, "::*");
+ }
- /* Push the list onto the top of the stack of template argument
- lists, so that arguments from it are used from now on when
- expanding <template-param>s. */
- push_template_arg_list (dm, arg_list);
+ dpi->modifiers = dpm.next;
- return STATUS_OK;
-}
+ /* Now print any CV-qualifiers on the type. */
+ target_type = d_right (dc);
+ while (target_type != NULL
+ && (target_type->type == D_COMP_RESTRICT
+ || target_type->type == D_COMP_VOLATILE
+ || target_type->type == D_COMP_CONST))
+ {
+ d_print_mod (dpi, target_type);
+ target_type = d_left (target_type);
+ }
-/* This function, which does not correspond to a production in the
- mangling spec, handles the `literal' production for both
- <template-arg> and <expr-primary>. It does not expect or consume
- the initial `L' or final `E'. The demangling is given by:
+ return;
+ }
- <literal> ::= <type> </value/ number>
+ case D_COMP_ARGLIST:
+ case D_COMP_TEMPLATE_ARGLIST:
+ d_print_comp (dpi, d_left (dc));
+ if (d_right (dc) != NULL)
+ {
+ d_append_string (dpi, ", ");
+ d_print_comp (dpi, d_right (dc));
+ }
+ return;
- and the emitted output is `(type)number'. */
+ case D_COMP_OPERATOR:
+ {
+ char c;
+
+ d_append_string (dpi, "operator");
+ c = dc->u.s_operator.op->name[0];
+ if (c >= 'a' && c <= 'z')
+ d_append_char (dpi, ' ');
+ d_append_string (dpi, dc->u.s_operator.op->name);
+ return;
+ }
-static status_t
-demangle_literal (dm)
- demangling_t dm;
-{
- char peek = peek_char (dm);
- dyn_string_t value_string;
- status_t status;
+ case D_COMP_EXTENDED_OPERATOR:
+ d_append_string (dpi, "operator ");
+ d_print_comp (dpi, dc->u.s_extended_operator.name);
+ return;
- DEMANGLE_TRACE ("literal", dm);
+ case D_COMP_CAST:
+ d_append_string (dpi, "operator ");
+ d_print_cast (dpi, dc);
+ return;
- if (!flag_verbose && peek >= 'a' && peek <= 'z')
- {
- /* If not in verbose mode and this is a builtin type, see if we
- can produce simpler numerical output. In particular, for
- integer types shorter than `long', just write the number
- without type information; for bools, write `true' or `false'.
- Other refinements could be made here too. */
-
- /* This constant string is used to map from <builtin-type> codes
- (26 letters of the alphabet) to codes that determine how the
- value will be displayed. The codes are:
- b: display as bool
- i: display as int
- l: display as long
- A space means the value will be represented using cast
- notation. */
- static const char *const code_map = "ibi iii ll ii i ";
-
- char code = code_map[peek - 'a'];
- /* FIXME: Implement demangling of floats and doubles. */
- if (code == 'u')
- return STATUS_UNIMPLEMENTED;
- if (code == 'b')
+ case D_COMP_UNARY:
+ if (d_left (dc)->type != D_COMP_CAST)
+ d_print_expr_op (dpi, d_left (dc));
+ else
{
- /* It's a boolean. */
- char value;
-
- /* Consume the b. */
- advance_char (dm);
- /* Look at the next character. It should be 0 or 1,
- corresponding to false or true, respectively. */
- value = peek_char (dm);
- if (value == '0')
- RETURN_IF_ERROR (result_add (dm, "false"));
- else if (value == '1')
- RETURN_IF_ERROR (result_add (dm, "true"));
- else
- return "Unrecognized bool constant.";
- /* Consume the 0 or 1. */
- advance_char (dm);
- return STATUS_OK;
+ d_append_string (dpi, "((");
+ d_print_cast (dpi, d_left (dc));
+ d_append_char (dpi, ')');
}
- else if (code == 'i' || code == 'l')
+ d_append_char (dpi, '(');
+ d_print_comp (dpi, d_right (dc));
+ d_append_char (dpi, ')');
+ if (d_left (dc)->type == D_COMP_CAST)
+ d_append_char (dpi, ')');
+ return;
+
+ case D_COMP_BINARY:
+ if (d_right (dc)->type != D_COMP_BINARY_ARGS)
{
- /* It's an integer or long. */
-
- /* Consume the type character. */
- advance_char (dm);
-
- /* Demangle the number and write it out. */
- value_string = dyn_string_new (0);
- status = demangle_number_literally (dm, value_string, 10, 1);
- if (STATUS_NO_ERROR (status))
- status = result_add_string (dm, value_string);
- /* For long integers, append an l. */
- if (code == 'l' && STATUS_NO_ERROR (status))
- status = result_add_char (dm, code);
- dyn_string_delete (value_string);
-
- RETURN_IF_ERROR (status);
- return STATUS_OK;
+ d_print_error (dpi);
+ return;
}
- /* ...else code == ' ', so fall through to represent this
- literal's type explicitly using cast syntax. */
- }
+ d_append_char (dpi, '(');
+ d_print_comp (dpi, d_left (d_right (dc)));
+ d_append_string (dpi, ") ");
+ d_print_expr_op (dpi, d_left (dc));
+ d_append_string (dpi, " (");
+ d_print_comp (dpi, d_right (d_right (dc)));
+ d_append_char (dpi, ')');
+ return;
+
+ case D_COMP_BINARY_ARGS:
+ /* We should only see this as part of D_COMP_BINARY. */
+ d_print_error (dpi);
+ return;
+
+ case D_COMP_TRINARY:
+ if (d_right (dc)->type != D_COMP_TRINARY_ARG1
+ || d_right (d_right (dc))->type != D_COMP_TRINARY_ARG2)
+ {
+ d_print_error (dpi);
+ return;
+ }
+ d_append_char (dpi, '(');
+ d_print_comp (dpi, d_left (d_right (dc)));
+ d_append_string (dpi, ") ");
+ d_print_expr_op (dpi, d_left (dc));
+ d_append_string (dpi, " (");
+ d_print_comp (dpi, d_left (d_right (d_right (dc))));
+ d_append_string (dpi, ") : (");
+ d_print_comp (dpi, d_right (d_right (d_right (dc))));
+ d_append_char (dpi, ')');
+ return;
+
+ case D_COMP_TRINARY_ARG1:
+ case D_COMP_TRINARY_ARG2:
+ /* We should only see these are part of D_COMP_TRINARY. */
+ d_print_error (dpi);
+ return;
+
+ case D_COMP_LITERAL:
+ /* For some builtin types, produce simpler output. */
+ if (d_left (dc)->type == D_COMP_BUILTIN_TYPE)
+ {
+ switch (d_left (dc)->u.s_builtin.type->print)
+ {
+ case D_PRINT_INT:
+ if (d_right (dc)->type == D_COMP_NAME)
+ {
+ d_print_comp (dpi, d_right (dc));
+ return;
+ }
+ break;
+
+ case D_PRINT_LONG:
+ if (d_right (dc)->type == D_COMP_NAME)
+ {
+ d_print_comp (dpi, d_right (dc));
+ d_append_char (dpi, 'l');
+ return;
+ }
+ break;
- RETURN_IF_ERROR (result_add_char (dm, '('));
- RETURN_IF_ERROR (demangle_type (dm));
- RETURN_IF_ERROR (result_add_char (dm, ')'));
+ case D_PRINT_BOOL:
+ if (d_right (dc)->type == D_COMP_NAME
+ && d_right (dc)->u.s_name.len == 1)
+ {
+ switch (d_right (dc)->u.s_name.s[0])
+ {
+ case '0':
+ d_append_string (dpi, "false");
+ return;
+ case '1':
+ d_append_string (dpi, "true");
+ return;
+ default:
+ break;
+ }
+ }
+ break;
- value_string = dyn_string_new (0);
- if (value_string == NULL)
- return STATUS_ALLOCATION_FAILED;
+ default:
+ break;
+ }
+ }
- status = demangle_number_literally (dm, value_string, 10, 1);
- if (STATUS_NO_ERROR (status))
- status = result_add_string (dm, value_string);
- dyn_string_delete (value_string);
- RETURN_IF_ERROR (status);
+ d_append_char (dpi, '(');
+ d_print_comp (dpi, d_left (dc));
+ d_append_char (dpi, ')');
+ d_print_comp (dpi, d_right (dc));
+ return;
- return STATUS_OK;
+ default:
+ d_print_error (dpi);
+ return;
+ }
}
-/* Demangles and emits a <template-arg>.
-
- <template-arg> ::= <type> # type
- ::= L <type> <value number> E # literal
- ::= LZ <encoding> E # external name
- ::= X <expression> E # expression */
+/* Print an identifier. */
-static status_t
-demangle_template_arg (dm)
- demangling_t dm;
+static void
+d_print_identifier (dpi, name, len)
+ struct d_print_info *dpi;
+ const char *name;
+ int len;
{
- DEMANGLE_TRACE ("template-arg", dm);
-
- switch (peek_char (dm))
+ if ((dpi->options & DMGL_JAVA) == 0)
+ d_append_buffer (dpi, name, len);
+ else
{
- case 'L':
- advance_char (dm);
+ const char *p;
+ const char *end;
- if (peek_char (dm) == 'Z')
+ /* For Java we try to handle encoded extended Unicode
+ characters. The C++ ABI doesn't mention Unicode encoding, so
+ we don't it for C++. Characters are encoded as
+ __U<hex-char>+_. */
+ end = name + len;
+ for (p = name; p < end; ++p)
{
- /* External name. */
- advance_char (dm);
- /* FIXME: Standard is contradictory here. */
- RETURN_IF_ERROR (demangle_encoding (dm));
- }
- else
- RETURN_IF_ERROR (demangle_literal (dm));
- RETURN_IF_ERROR (demangle_char (dm, 'E'));
- break;
+ if (end - p > 3
+ && p[0] == '_'
+ && p[1] == '_'
+ && p[2] == 'U')
+ {
+ unsigned long c;
+ const char *q;
- case 'X':
- /* Expression. */
- advance_char (dm);
- RETURN_IF_ERROR (demangle_expression (dm));
- RETURN_IF_ERROR (demangle_char (dm, 'E'));
- break;
+ c = 0;
+ for (q = p + 3; q < end; ++q)
+ {
+ int dig;
+
+ if (*q >= '0' && *q <= '9')
+ dig = *q - '0';
+ else if (*q >= 'A' && *q <= 'F')
+ dig = *q - 'A' + 10;
+ else if (*q >= 'a' && *q <= 'f')
+ dig = *q - 'a' + 10;
+ else
+ break;
+
+ c = c * 16 + dig;
+ }
+ /* If the Unicode character is larger than 256, we don't
+ try to deal with it here. FIXME. */
+ if (q < end && *q == '_' && c < 256)
+ {
+ d_append_char (dpi, c);
+ p = q;
+ continue;
+ }
+ }
- default:
- RETURN_IF_ERROR (demangle_type (dm));
- break;
+ d_append_char (dpi, *p);
+ }
}
-
- return STATUS_OK;
}
-/* Demangles and emits an <expression>.
+/* Print a list of modifiers. */
- <expression> ::= <unary operator-name> <expression>
- ::= <binary operator-name> <expression> <expression>
- ::= <expr-primary>
- ::= <scope-expression> */
-
-static status_t
-demangle_expression (dm)
- demangling_t dm;
+static void
+d_print_mod_list (dpi, mods)
+ struct d_print_info *dpi;
+ struct d_print_mod *mods;
{
- char peek = peek_char (dm);
+ if (mods == NULL || mods->printed || d_print_saw_error (dpi))
+ return;
- DEMANGLE_TRACE ("expression", dm);
-
- if (peek == 'L' || peek == 'T')
- RETURN_IF_ERROR (demangle_expr_primary (dm));
- else if (peek == 's' && peek_char_next (dm) == 'r')
- RETURN_IF_ERROR (demangle_scope_expression (dm));
- else
- /* An operator expression. */
+ if (mods->mod->type == D_COMP_FUNCTION_TYPE)
{
- int num_args;
- int type_arg;
- status_t status = STATUS_OK;
- dyn_string_t operator_name;
-
- /* We have an operator name. Since we want to output binary
- operations in infix notation, capture the operator name
- first. */
- RETURN_IF_ERROR (result_push (dm));
- RETURN_IF_ERROR (demangle_operator_name (dm, 1, &num_args,
- &type_arg));
- operator_name = (dyn_string_t) result_pop (dm);
-
- /* If it's binary, do an operand first. */
- if (num_args > 1)
- {
- status = result_add_char (dm, '(');
- if (STATUS_NO_ERROR (status))
- status = demangle_expression (dm);
- if (STATUS_NO_ERROR (status))
- status = result_add_char (dm, ')');
- }
+ mods->printed = 1;
+ d_print_function_type (dpi, mods->mod, mods->next);
+ return;
+ }
+ else if (mods->mod->type == D_COMP_ARRAY_TYPE)
+ {
+ mods->printed = 1;
+ d_print_array_type (dpi, mods->mod, mods->next);
+ return;
+ }
- /* Emit the operator. */
- if (STATUS_NO_ERROR (status))
- status = result_add_string (dm, operator_name);
- dyn_string_delete (operator_name);
- RETURN_IF_ERROR (status);
-
- /* Emit its second (if binary) or only (if unary) operand. */
- RETURN_IF_ERROR (result_add_char (dm, '('));
- if (type_arg)
- RETURN_IF_ERROR (demangle_type (dm));
- else
- RETURN_IF_ERROR (demangle_expression (dm));
- RETURN_IF_ERROR (result_add_char (dm, ')'));
+ mods->printed = 1;
- /* The ternary operator takes a third operand. */
- if (num_args == 3)
- {
- RETURN_IF_ERROR (result_add (dm, ":("));
- RETURN_IF_ERROR (demangle_expression (dm));
- RETURN_IF_ERROR (result_add_char (dm, ')'));
- }
- }
+ d_print_mod (dpi, mods->mod);
- return STATUS_OK;
+ d_print_mod_list (dpi, mods->next);
}
+
+/* Print a modifier. */
-/* Demangles and emits a <scope-expression>.
+static void
+d_print_mod (dpi, mod)
+ struct d_print_info *dpi;
+ const struct d_comp *mod;
+{
+ switch (mod->type)
+ {
+ case D_COMP_RESTRICT:
+ d_append_string (dpi, " restrict");
+ return;
+ case D_COMP_VOLATILE:
+ d_append_string (dpi, " volatile");
+ return;
+ case D_COMP_CONST:
+ d_append_string (dpi, " const");
+ return;
+ case D_COMP_VENDOR_TYPE_QUAL:
+ d_append_char (dpi, ' ');
+ d_print_comp (dpi, d_right (mod));
+ return;
+ case D_COMP_POINTER:
+ /* There is no pointer symbol in Java. */
+ if ((dpi->options & DMGL_JAVA) == 0)
+ d_append_char (dpi, '*');
+ return;
+ case D_COMP_REFERENCE:
+ d_append_char (dpi, '&');
+ return;
+ case D_COMP_COMPLEX:
+ d_append_string (dpi, "complex ");
+ return;
+ case D_COMP_IMAGINARY:
+ d_append_string (dpi, "imaginary ");
+ return;
+ case D_COMP_PTRMEM_TYPE:
+ if (dpi->buf[dpi->len - 1] != '(')
+ d_append_char (dpi, ' ');
+ d_print_comp (dpi, d_left (mod));
+ d_append_string (dpi, "::*");
+ return;
+ case D_COMP_TYPED_NAME:
+ d_print_comp (dpi, d_left (mod));
+ return;
+ default:
+ /* Otherwise, we have something that won't go back on the
+ modifier stack, so we can just print it. */
+ d_print_comp (dpi, mod);
+ return;
+ }
+}
- <scope-expression> ::= sr <qualifying type> <source-name>
- ::= sr <qualifying type> <encoding> */
+/* Print a function type, except for the return type. */
-static status_t
-demangle_scope_expression (dm)
- demangling_t dm;
+static void
+d_print_function_type (dpi, dc, mods)
+ struct d_print_info *dpi;
+ const struct d_comp *dc;
+ struct d_print_mod *mods;
{
- RETURN_IF_ERROR (demangle_char (dm, 's'));
- RETURN_IF_ERROR (demangle_char (dm, 'r'));
- RETURN_IF_ERROR (demangle_type (dm));
- RETURN_IF_ERROR (result_add (dm, "::"));
- RETURN_IF_ERROR (demangle_encoding (dm));
- return STATUS_OK;
-}
-
-/* Demangles and emits an <expr-primary>.
+ if (mods != NULL)
+ {
+ int need_paren;
+ int saw_mod;
+ struct d_print_mod *p;
- <expr-primary> ::= <template-param>
- ::= L <type> <value number> E # literal
- ::= L <mangled-name> E # external name */
+ need_paren = 0;
+ saw_mod = 0;
+ for (p = mods; p != NULL; p = p->next)
+ {
+ if (p->printed)
+ break;
-static status_t
-demangle_expr_primary (dm)
- demangling_t dm;
-{
- char peek = peek_char (dm);
+ saw_mod = 1;
+ switch (p->mod->type)
+ {
+ case D_COMP_RESTRICT:
+ case D_COMP_VOLATILE:
+ case D_COMP_CONST:
+ case D_COMP_VENDOR_TYPE_QUAL:
+ case D_COMP_POINTER:
+ case D_COMP_REFERENCE:
+ case D_COMP_COMPLEX:
+ case D_COMP_IMAGINARY:
+ case D_COMP_PTRMEM_TYPE:
+ need_paren = 1;
+ break;
+ default:
+ break;
+ }
+ if (need_paren)
+ break;
+ }
- DEMANGLE_TRACE ("expr-primary", dm);
+ if (d_left (dc) != NULL && ! saw_mod)
+ need_paren = 1;
- if (peek == 'T')
- RETURN_IF_ERROR (demangle_template_param (dm));
- else if (peek == 'L')
- {
- /* Consume the `L'. */
- advance_char (dm);
- peek = peek_char (dm);
+ if (need_paren)
+ d_append_char (dpi, '(');
- if (peek == '_')
- RETURN_IF_ERROR (demangle_mangled_name (dm));
- else
- RETURN_IF_ERROR (demangle_literal (dm));
+ d_print_mod_list (dpi, mods);
- RETURN_IF_ERROR (demangle_char (dm, 'E'));
+ if (need_paren)
+ d_append_char (dpi, ')');
}
- else
- return STATUS_ERROR;
- return STATUS_OK;
-}
+ d_append_char (dpi, '(');
-/* Demangles and emits a <substitution>. Sets *TEMPLATE_P to non-zero
- if the substitution is the name of a template, zero otherwise.
-
- <substitution> ::= S <seq-id> _
- ::= S_
-
- ::= St # ::std::
- ::= Sa # ::std::allocator
- ::= Sb # ::std::basic_string
- ::= Ss # ::std::basic_string<char,
- ::std::char_traits<char>,
- ::std::allocator<char> >
- ::= Si # ::std::basic_istream<char,
- std::char_traits<char> >
- ::= So # ::std::basic_ostream<char,
- std::char_traits<char> >
- ::= Sd # ::std::basic_iostream<char,
- std::char_traits<char> >
-*/
+ if (d_right (dc) != NULL)
+ d_print_comp (dpi, d_right (dc));
-static status_t
-demangle_substitution (dm, template_p)
- demangling_t dm;
- int *template_p;
-{
- int seq_id;
- int peek;
- dyn_string_t text;
+ d_append_char (dpi, ')');
+}
- DEMANGLE_TRACE ("substitution", dm);
+/* Print an array type, except for the element type. */
- RETURN_IF_ERROR (demangle_char (dm, 'S'));
+static void
+d_print_array_type (dpi, dc, mods)
+ struct d_print_info *dpi;
+ const struct d_comp *dc;
+ struct d_print_mod *mods;
+{
+ int need_space;
- /* Scan the substitution sequence index. A missing number denotes
- the first index. */
- peek = peek_char (dm);
- if (peek == '_')
- seq_id = -1;
- /* If the following character is 0-9 or a capital letter, interpret
- the sequence up to the next underscore as a base-36 substitution
- index. */
- else if (IS_DIGIT ((unsigned char) peek)
- || (peek >= 'A' && peek <= 'Z'))
- RETURN_IF_ERROR (demangle_number (dm, &seq_id, 36, 0));
- else
+ need_space = 1;
+ if (mods != NULL)
{
- const char *new_last_source_name = NULL;
+ int need_paren;
+ struct d_print_mod *p;
- switch (peek)
+ need_paren = 0;
+ for (p = mods; p != NULL; p = p->next)
{
- case 't':
- RETURN_IF_ERROR (result_add (dm, "std"));
- break;
-
- case 'a':
- RETURN_IF_ERROR (result_add (dm, "std::allocator"));
- new_last_source_name = "allocator";
- *template_p = 1;
- break;
+ if (p->printed)
+ break;
- case 'b':
- RETURN_IF_ERROR (result_add (dm, "std::basic_string"));
- new_last_source_name = "basic_string";
- *template_p = 1;
- break;
-
- case 's':
- if (!flag_verbose)
+ if (p->mod->type == D_COMP_ARRAY_TYPE)
{
- RETURN_IF_ERROR (result_add (dm, "std::string"));
- new_last_source_name = "string";
+ need_space = 0;
+ break;
}
else
{
- RETURN_IF_ERROR (result_add (dm, "std::basic_string<char, std::char_traits<char>, std::allocator<char> >"));
- new_last_source_name = "basic_string";
+ need_paren = 1;
+ need_space = 1;
+ break;
}
- *template_p = 0;
- break;
+ }
- case 'i':
- if (!flag_verbose)
- {
- RETURN_IF_ERROR (result_add (dm, "std::istream"));
- new_last_source_name = "istream";
- }
- else
- {
- RETURN_IF_ERROR (result_add (dm, "std::basic_istream<char, std::char_traits<char> >"));
- new_last_source_name = "basic_istream";
- }
- *template_p = 0;
- break;
+ if (need_paren)
+ d_append_string (dpi, " (");
- case 'o':
- if (!flag_verbose)
- {
- RETURN_IF_ERROR (result_add (dm, "std::ostream"));
- new_last_source_name = "ostream";
- }
- else
- {
- RETURN_IF_ERROR (result_add (dm, "std::basic_ostream<char, std::char_traits<char> >"));
- new_last_source_name = "basic_ostream";
- }
- *template_p = 0;
- break;
+ d_print_mod_list (dpi, mods);
- case 'd':
- if (!flag_verbose)
- {
- RETURN_IF_ERROR (result_add (dm, "std::iostream"));
- new_last_source_name = "iostream";
- }
- else
- {
- RETURN_IF_ERROR (result_add (dm, "std::basic_iostream<char, std::char_traits<char> >"));
- new_last_source_name = "basic_iostream";
- }
- *template_p = 0;
- break;
+ if (need_paren)
+ d_append_char (dpi, ')');
+ }
- default:
- return "Unrecognized <substitution>.";
- }
-
- /* Consume the character we just processed. */
- advance_char (dm);
+ if (need_space)
+ d_append_char (dpi, ' ');
- if (new_last_source_name != NULL)
- {
- if (!dyn_string_copy_cstr (dm->last_source_name,
- new_last_source_name))
- return STATUS_ALLOCATION_FAILED;
- }
+ d_append_char (dpi, '[');
- return STATUS_OK;
- }
+ if (d_left (dc) != NULL)
+ d_print_comp (dpi, d_left (dc));
- /* Look up the substitution text. Since `S_' is the most recent
- substitution, `S0_' is the second-most-recent, etc., shift the
- numbering by one. */
- text = substitution_get (dm, seq_id + 1, template_p);
- if (text == NULL)
- return "Substitution number out of range.";
+ d_append_char (dpi, ']');
+}
- /* Emit the substitution text. */
- RETURN_IF_ERROR (result_add_string (dm, text));
+/* Print an operator in an expression. */
- RETURN_IF_ERROR (demangle_char (dm, '_'));
- return STATUS_OK;
+static void
+d_print_expr_op (dpi, dc)
+ struct d_print_info *dpi;
+ const struct d_comp *dc;
+{
+ if (dc->type == D_COMP_OPERATOR)
+ d_append_string (dpi, dc->u.s_operator.op->name);
+ else
+ d_print_comp (dpi, dc);
}
-/* Demangles and emits a <local-name>.
+/* Print a cast. */
- <local-name> := Z <function encoding> E <entity name> [<discriminator>]
- := Z <function encoding> E s [<discriminator>] */
-
-static status_t
-demangle_local_name (dm)
- demangling_t dm;
+static void
+d_print_cast (dpi, dc)
+ struct d_print_info *dpi;
+ const struct d_comp *dc;
{
- int old_caret_position = result_get_caret (dm);
+ if (d_left (dc)->type != D_COMP_TEMPLATE)
+ d_print_comp (dpi, d_left (dc));
+ else
+ {
+ struct d_print_template dpt;
- DEMANGLE_TRACE ("local-name", dm);
+ /* It appears that for a templated cast operator, we need to put
+ the template parameters in scope for the operator name, but
+ not for the parameters. The effect is that we need to handle
+ the template printing here. FIXME: Verify this. */
- RETURN_IF_ERROR (demangle_char (dm, 'Z'));
- RETURN_IF_ERROR (demangle_encoding (dm));
+ dpt.next = dpi->templates;
+ dpi->templates = &dpt;
+ dpt.template = d_left (dc);
- /* Restore the caret to avoid being confused by any qualifiers we
- may have found during the encoding. */
- result_set_caret (dm, old_caret_position);
+ d_print_comp (dpi, d_left (d_left (dc)));
- RETURN_IF_ERROR (demangle_char (dm, 'E'));
- RETURN_IF_ERROR (result_add (dm, "::"));
+ dpi->templates = dpt.next;
- if (peek_char (dm) == 's')
- {
- /* Local character string literal. */
- RETURN_IF_ERROR (result_add (dm, "string literal"));
- /* Consume the s. */
- advance_char (dm);
- RETURN_IF_ERROR (demangle_discriminator (dm, 0));
+ d_append_char (dpi, '<');
+ d_print_comp (dpi, d_right (d_left (dc)));
+ /* Avoid generating two consecutive '>' characters, to avoid
+ the C++ syntactic ambiguity. */
+ if (dpi->buf[dpi->len - 1] == '>')
+ d_append_char (dpi, ' ');
+ d_append_char (dpi, '>');
}
- else
- {
- int unused;
- /* Local name for some other entity. Demangle its name. */
- RETURN_IF_ERROR (demangle_name (dm, &unused));
- RETURN_IF_ERROR (demangle_discriminator (dm, 1));
- }
-
- return STATUS_OK;
- }
-
- /* Optimonally demangles and emits a <discriminator>. If there is no
- <discriminator> at the current position in the mangled string, the
- descriminator is assumed to be zero. Emit the discriminator number
- in parentheses, unless SUPPRESS_FIRST is non-zero and the
- discriminator is zero.
-
- <discriminator> ::= _ <number> */
-
-static status_t
-demangle_discriminator (dm, suppress_first)
- demangling_t dm;
- int suppress_first;
+}
+
+/* Initialize the information structure we use to pass around
+ information. */
+
+static int
+d_init_info (mangled, options, len, di)
+ const char *mangled;
+ int options;
+ size_t len;
+ struct d_info *di;
{
- /* Output for <discriminator>s to the demangled name is completely
- suppressed if not in verbose mode. */
+ di->s = mangled;
+ di->options = options;
- if (peek_char (dm) == '_')
- {
- /* Consume the underscore. */
- advance_char (dm);
- if (flag_verbose)
- RETURN_IF_ERROR (result_add (dm, " [#"));
- /* Check if there's a number following the underscore. */
- if (IS_DIGIT ((unsigned char) peek_char (dm)))
- {
- int discriminator;
- /* Demangle the number. */
- RETURN_IF_ERROR (demangle_number (dm, &discriminator, 10, 0));
- if (flag_verbose)
- /* Write the discriminator. The mangled number is two
- less than the discriminator ordinal, counting from
- zero. */
- RETURN_IF_ERROR (int_to_dyn_string (discriminator + 1,
- (dyn_string_t) dm->result));
- }
- else
- return STATUS_ERROR;
- if (flag_verbose)
- RETURN_IF_ERROR (result_add_char (dm, ']'));
- }
- else if (!suppress_first)
+ di->n = mangled;
+
+ /* We can not need more components than twice the number of chars in
+ the mangled string. Most components correspond directly to
+ chars, but the ARGLIST types are exceptions. */
+ di->num_comps = 2 * len;
+ di->comps = (struct d_comp *) malloc (di->num_comps
+ * sizeof (struct d_comp));
+ di->next_comp = 0;
+
+ /* Similarly, we can not need more substitutions than there are
+ chars in the mangled string divided by 2, since it takes at least
+ two chars to refer to a substitution. */
+ di->num_subs = (len + 1) / 2;
+ di->subs = (struct d_comp **) malloc (di->num_subs
+ * sizeof (struct d_comp *));
+ di->next_sub = 0;
+
+ di->last_name = NULL;
+
+ if (di->comps == NULL || di->subs == NULL)
{
- if (flag_verbose)
- RETURN_IF_ERROR (result_add (dm, " [#0]"));
+ if (di->comps != NULL)
+ free (di->comps);
+ if (di->subs != NULL)
+ free (di->subs);
+ return 0;
}
- return STATUS_OK;
+ return 1;
}
-/* Demangle NAME into RESULT, which must be an initialized
- dyn_string_t. On success, returns STATUS_OK. On failure, returns
- an error message, and the contents of RESULT are unchanged. */
+/* 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. */
-static status_t
-cp_demangle (name, result, style)
- const char *name;
- dyn_string_t result;
- int style;
+static char *
+d_demangle (mangled, options, palc)
+ const char* mangled;
+ int options;
+ size_t *palc;
{
- status_t status;
- int length = strlen (name);
+ size_t len;
+ int type;
+ struct d_info di;
+ struct d_comp *dc;
+ char *ret;
- if (length > 2 && name[0] == '_' && name[1] == 'Z')
- {
- demangling_t dm = demangling_new (name, style);
- if (dm == NULL)
- return STATUS_ALLOCATION_FAILED;
+ *palc = 0;
- status = result_push (dm);
- if (status != STATUS_OK)
- {
- demangling_delete (dm);
- return status;
- }
+ len = strlen (mangled);
+
+ if (mangled[0] == '_' && mangled[1] == 'Z')
+ type = 0;
+ else if (strncmp (mangled, "_GLOBAL_", 8) == 0
+ && (mangled[8] == '.' || mangled[8] == '_' || mangled[8] == '$')
+ && (mangled[9] == 'D' || mangled[9] == 'I')
+ && mangled[10] == '_')
+ {
+ char *r;
- status = demangle_mangled_name (dm);
- if (STATUS_NO_ERROR (status))
+ r = malloc (40 + len - 11);
+ if (r == NULL)
+ *palc = 1;
+ else
{
- dyn_string_t demangled = (dyn_string_t) result_pop (dm);
- if (!dyn_string_copy (result, demangled))
- return STATUS_ALLOCATION_FAILED;
- dyn_string_delete (demangled);
+ if (mangled[9] == 'I')
+ strcpy (r, "global constructors keyed to ");
+ else
+ strcpy (r, "global destructors keyed to ");
+ strcat (r, mangled + 11);
}
-
- demangling_delete (dm);
+ return r;
}
else
{
- /* It's evidently not a mangled C++ name. It could be the name
- of something with C linkage, though, so just copy NAME into
- RESULT. */
- if (!dyn_string_copy_cstr (result, name))
- return STATUS_ALLOCATION_FAILED;
- status = STATUS_OK;
+ if ((options & DMGL_TYPES) == 0)
+ return NULL;
+ type = 1;
}
- return status;
-}
-
-/* Demangle TYPE_NAME into RESULT, which must be an initialized
- dyn_string_t. On success, returns STATUS_OK. On failiure, returns
- an error message, and the contents of RESULT are unchanged. */
-
-static status_t
-cp_demangle_type (type_name, result)
- const char* type_name;
- dyn_string_t result;
-{
- status_t status;
- demangling_t dm = demangling_new (type_name, DMGL_GNU_V3);
-
- if (dm == NULL)
- return STATUS_ALLOCATION_FAILED;
-
- /* Demangle the type name. The demangled name is stored in dm. */
- status = result_push (dm);
- if (status != STATUS_OK)
+ if (! d_init_info (mangled, options, len, &di))
{
- demangling_delete (dm);
- return status;
+ *palc = 1;
+ return NULL;
}
- status = demangle_type (dm);
+ if (! type)
+ dc = d_mangled_name (&di);
+ else
+ dc = d_type (&di);
+
+#ifdef CP_DEMANGLE_DEBUG
+ if (dc == NULL)
+ printf ("failed demangling\n");
+ else
+ d_dump (dc, 0);
+#endif
+
+ free (di.subs);
+ di.subs = NULL;
- if (STATUS_NO_ERROR (status))
- {
- /* The demangling succeeded. Pop the result out of dm and copy
- it into RESULT. */
- dyn_string_t demangled = (dyn_string_t) result_pop (dm);
- if (!dyn_string_copy (result, demangled))
- return STATUS_ALLOCATION_FAILED;
- dyn_string_delete (demangled);
- }
+ ret = NULL;
+ if (dc != NULL)
+ ret = d_print (options, dc, palc);
- /* Clean up. */
- demangling_delete (dm);
+ free (di.comps);
- return status;
+ return ret;
}
#if defined(IN_LIBGCC2) || defined(IN_GLIBCPP_V3)
+
extern char *__cxa_demangle PARAMS ((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 string
- containing the name to be demangled.
+/* ia64 ABI-mandated entry point in the C++ runtime library for
+ performing demangling. MANGLED_NAME is a NUL-terminated character
+ string containing the name to be demangled.
OUTPUT_BUFFER is a region of memory, allocated with malloc, of
*LENGTH bytes, into which the demangled name is stored. If
OUTPUT_BUFFER is not long enough, it is expanded using realloc.
OUTPUT_BUFFER may instead be NULL; in that case, the demangled name
- is placed in a region of memory allocated with malloc.
+ is placed in a region of memory allocated with malloc.
If LENGTH is non-NULL, the length of the buffer conaining the
- demangled name, is placed in *LENGTH.
+ demangled name, is placed in *LENGTH.
The return value is a pointer to the start of the NUL-terminated
demangled name, or NULL if the demangling fails. The caller is
- responsible for deallocating this memory using free.
+ responsible for deallocating this memory using free.
*STATUS is set to one of the following values:
0: The demangling operation succeeded.
- -1: A memory allocation failiure occurred.
+ -1: A memory allocation failure occurred.
-2: MANGLED_NAME is not a valid name under the C++ ABI mangling rules.
-3: One of the arguments is invalid.
- The demagling is performed using the C++ ABI mangling rules, with
+ The demangling is performed using the C++ ABI mangling rules, with
GNU extensions. */
char *
size_t *length;
int *status;
{
- struct dyn_string demangled_name;
- status_t result;
+ char *demangled;
+ size_t alc;
if (status == NULL)
return NULL;
- if (mangled_name == NULL) {
- *status = -3;
- return NULL;
- }
-
- /* Did the caller provide a buffer for the demangled name? */
- if (output_buffer == NULL) {
- /* No; dyn_string will malloc a buffer for us. */
- if (!dyn_string_init (&demangled_name, 0))
- {
- *status = -1;
- return NULL;
- }
- }
- else {
- /* Yes. Check that the length was provided. */
- if (length == NULL) {
+ if (mangled_name == NULL)
+ {
*status = -3;
return NULL;
}
- /* Install the buffer into a dyn_string. */
- demangled_name.allocated = *length;
- demangled_name.length = 0;
- demangled_name.s = output_buffer;
- }
-
- if (mangled_name[0] == '_' && mangled_name[1] == 'Z')
- /* MANGLED_NAME apprears to be a function or variable name.
- Demangle it accordingly. */
- result = cp_demangle (mangled_name, &demangled_name, 0);
- else
- /* Try to demangled MANGLED_NAME as the name of a type. */
- result = cp_demangle_type (mangled_name, &demangled_name);
- if (result == STATUS_OK)
- /* The demangling succeeded. */
+ if (output_buffer != NULL && length == NULL)
{
- /* If LENGTH isn't NULL, store the allocated buffer length
- there; the buffer may have been realloced by dyn_string
- functions. */
- if (length != NULL)
- *length = demangled_name.allocated;
- /* The operation was a success. */
- *status = 0;
- return dyn_string_buf (&demangled_name);
+ *status = -3;
+ return NULL;
}
- else if (result == STATUS_ALLOCATION_FAILED)
- /* A call to malloc or realloc failed during the demangling
- operation. */
+
+ demangled = d_demangle (mangled_name, DMGL_TYPES, &alc);
+
+ if (demangled == NULL)
{
- *status = -1;
+ if (alc == 1)
+ *status = -1;
+ else
+ *status = -2;
return NULL;
}
+
+ if (output_buffer == NULL)
+ {
+ if (length != NULL)
+ *length = alc;
+ }
else
- /* The demangling failed for another reason, most probably because
- MANGLED_NAME isn't a valid mangled name. */
{
- /* If the buffer containing the demangled name wasn't provided
- by the caller, free it. */
- if (output_buffer == NULL)
- free (dyn_string_buf (&demangled_name));
- *status = -2;
- return NULL;
+ if (strlen (demangled) < *length)
+ {
+ strcpy (output_buffer, demangled);
+ free (demangled);
+ demangled = output_buffer;
+ }
+ else
+ {
+ free (output_buffer);
+ *length = alc;
+ }
}
+
+ *status = 0;
+
+ return demangled;
}
#else /* ! (IN_LIBGCC2 || IN_GLIBCPP_V3) */
-/* Variant entry point for integration with the existing cplus-dem
- demangler. Attempts to demangle MANGLED. If the demangling
- succeeds, returns a buffer, allocated with malloc, containing the
- demangled name. The caller must deallocate the buffer using free.
- If the demangling failes, returns NULL. */
+/* Entry point for libiberty demangler. If MANGLED is a g++ v3 ABI
+ mangled name, return a buffer allocated with malloc holding the
+ demangled name. Otherwise, return NULL. */
char *
cplus_demangle_v3 (mangled, options)
const char* mangled;
int options;
{
- dyn_string_t demangled;
- status_t status;
- int type = !!(options & DMGL_TYPES);
-
- if (mangled[0] == '_' && mangled[1] == 'Z')
- /* It is not a type. */
- type = 0;
- else
- {
- /* It is a type. Stop if we don't want to demangle types. */
- if (!type)
- return NULL;
- }
-
- flag_verbose = !!(options & DMGL_VERBOSE);
-
- /* Create a dyn_string to hold the demangled name. */
- demangled = dyn_string_new (0);
- /* Attempt the demangling. */
- if (!type)
- /* Appears to be a function or variable name. */
- status = cp_demangle (mangled, demangled, 0);
- else
- /* Try to demangle it as the name of a type. */
- status = cp_demangle_type (mangled, demangled);
+ size_t alc;
- if (STATUS_NO_ERROR (status))
- /* Demangling succeeded. */
- {
- /* Grab the demangled result from the dyn_string. It was
- allocated with malloc, so we can return it directly. */
- char *return_value = dyn_string_release (demangled);
- /* Hand back the demangled name. */
- return return_value;
- }
- else if (status == STATUS_ALLOCATION_FAILED)
- {
- fprintf (stderr, "Memory allocation failed.\n");
- abort ();
- }
- else
- /* Demangling failed. */
- {
- dyn_string_delete (demangled);
- return NULL;
- }
+ return d_demangle (mangled, options, &alc);
}
/* Demangle a Java symbol. Java uses a subset of the V3 ABI C++ mangling
java_demangle_v3 (mangled)
const char* mangled;
{
- dyn_string_t demangled;
- char *next;
- char *end;
- int len;
- status_t status;
- int nesting = 0;
- char *cplus_demangled;
- char *return_value;
-
- /* Create a dyn_string to hold the demangled name. */
- demangled = dyn_string_new (0);
-
- /* Attempt the demangling. */
- status = cp_demangle ((char *) mangled, demangled, DMGL_JAVA);
-
- if (STATUS_NO_ERROR (status))
- /* Demangling succeeded. */
- {
- /* Grab the demangled result from the dyn_string. */
- cplus_demangled = dyn_string_release (demangled);
- }
- else if (status == STATUS_ALLOCATION_FAILED)
- {
- fprintf (stderr, "Memory allocation failed.\n");
- abort ();
- }
- else
- /* Demangling failed. */
- {
- dyn_string_delete (demangled);
- return NULL;
- }
-
- len = strlen (cplus_demangled);
- next = cplus_demangled;
- end = next + len;
- demangled = NULL;
-
- /* Replace occurances of JArray<TYPE> with TYPE[]. */
- while (next < end)
+ size_t alc;
+ char *demangled;
+ int nesting;
+ char *from;
+ char *to;
+
+ demangled = d_demangle (mangled, DMGL_JAVA, &alc);
+
+ if (demangled == NULL)
+ return NULL;
+
+ nesting = 0;
+ from = demangled;
+ to = from;
+ while (*from != '\0')
{
- char *open_str = strstr (next, "JArray<");
- char *close_str = NULL;
- if (nesting > 0)
- close_str = strchr (next, '>');
-
- if (open_str != NULL && (close_str == NULL || close_str > open_str))
- {
+ if (strncmp (from, "JArray<", 7) == 0)
+ {
+ from += 7;
++nesting;
-
- if (!demangled)
- demangled = dyn_string_new(len);
-
- /* Copy prepending symbols, if any. */
- if (open_str > next)
- {
- open_str[0] = 0;
- dyn_string_append_cstr (demangled, next);
- }
- next = open_str + 7;
}
- else if (close_str != NULL)
- {
+ else if (nesting > 0 && *from == '>')
+ {
+ while (to > demangled && to[-1] == ' ')
+ --to;
+ *to++ = '[';
+ *to++ = ']';
--nesting;
-
- /* Copy prepending type symbol, if any. Squash any spurious
- whitespace. */
- if (close_str > next && next[0] != ' ')
- {
- close_str[0] = 0;
- dyn_string_append_cstr (demangled, next);
- }
- dyn_string_append_cstr (demangled, "[]");
- next = close_str + 1;
+ ++from;
}
else
- {
- /* There are no more arrays. Copy the rest of the symbol, or
- simply return the original symbol if no changes were made. */
- if (next == cplus_demangled)
- return cplus_demangled;
-
- dyn_string_append_cstr (demangled, next);
- next = end;
- }
+ *to++ = *from++;
}
- free (cplus_demangled);
-
- if (demangled)
- return_value = dyn_string_release (demangled);
- else
- return_value = NULL;
+ *to = '\0';
- return return_value;
+ return demangled;
}
#endif /* IN_LIBGCC2 || IN_GLIBCPP_V3 */
-
#ifndef IN_GLIBCPP_V3
-/* Demangle NAME in the G++ V3 ABI demangling style, and return either
- zero, indicating that some error occurred, or a demangling_t
- holding the results. */
-static demangling_t
-demangle_v3_with_details (name)
- const char *name;
+
+/* Demangle a string in order to find out whether it is a constructor
+ or destructor. Return non-zero on success. Set *CTOR_KIND and
+ *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;
{
- demangling_t dm;
- status_t status;
+ struct d_info di;
+ struct d_comp *dc;
- if (strncmp (name, "_Z", 2))
+ *ctor_kind = (enum gnu_v3_ctor_kinds) 0;
+ *dtor_kind = (enum gnu_v3_dtor_kinds) 0;
+
+ if (! d_init_info (mangled, DMGL_GNU_V3, strlen (mangled), &di))
return 0;
- dm = demangling_new (name, DMGL_GNU_V3);
- if (dm == NULL)
- {
- fprintf (stderr, "Memory allocation failed.\n");
- abort ();
- }
+ dc = d_mangled_name (&di);
+
+ if (dc == NULL)
+ return 0;
- status = result_push (dm);
- if (! STATUS_NO_ERROR (status))
+ while (dc != NULL)
{
- demangling_delete (dm);
- fprintf (stderr, "%s\n", status);
- abort ();
+ switch (dc->type)
+ {
+ default:
+ return 0;
+ case D_COMP_TYPED_NAME:
+ case D_COMP_TEMPLATE:
+ case D_COMP_RESTRICT:
+ case D_COMP_VOLATILE:
+ case D_COMP_CONST:
+ case D_COMP_VENDOR_TYPE_QUAL:
+ dc = d_left (dc);
+ break;
+ case D_COMP_QUAL_NAME:
+ dc = d_right (dc);
+ break;
+ case D_COMP_CTOR:
+ *ctor_kind = dc->u.s_ctor.kind;
+ return 1;
+ case D_COMP_DTOR:
+ *dtor_kind = dc->u.s_dtor.kind;
+ return 1;
+ }
}
- status = demangle_mangled_name (dm);
- if (STATUS_NO_ERROR (status))
- return dm;
-
- demangling_delete (dm);
return 0;
}
+/* Return whether NAME is the mangled form of a g++ V3 ABI constructor
+ name. A non-zero return indicates the type of constructor. */
-/* Return non-zero iff NAME is the mangled form of a constructor name
- in the G++ V3 ABI demangling style. Specifically, return:
- - '1' if NAME is a complete object constructor,
- - '2' if NAME is a base object constructor, or
- - '3' if NAME is a complete object allocating constructor. */
enum gnu_v3_ctor_kinds
is_gnu_v3_mangled_ctor (name)
const char *name;
{
- demangling_t dm = demangle_v3_with_details (name);
+ enum gnu_v3_ctor_kinds ctor_kind;
+ enum gnu_v3_dtor_kinds dtor_kind;
- if (dm)
- {
- enum gnu_v3_ctor_kinds result = dm->is_constructor;
- demangling_delete (dm);
- return result;
- }
- else
+ if (! is_ctor_or_dtor (name, &ctor_kind, &dtor_kind))
return (enum gnu_v3_ctor_kinds) 0;
+ return ctor_kind;
}
-/* Return non-zero iff NAME is the mangled form of a destructor name
- in the G++ V3 ABI demangling style. Specifically, return:
- - '0' if NAME is a deleting destructor,
- - '1' if NAME is a complete object destructor, or
- - '2' if NAME is a base object destructor. */
+/* Return whether NAME is the mangled form of a g++ V3 ABI destructor
+ name. A non-zero return indicates the type of destructor. */
+
enum gnu_v3_dtor_kinds
is_gnu_v3_mangled_dtor (name)
const char *name;
{
- demangling_t dm = demangle_v3_with_details (name);
+ enum gnu_v3_ctor_kinds ctor_kind;
+ enum gnu_v3_dtor_kinds dtor_kind;
- if (dm)
- {
- enum gnu_v3_dtor_kinds result = dm->is_destructor;
- demangling_delete (dm);
- return result;
- }
- else
+ if (! is_ctor_or_dtor (name, &ctor_kind, &dtor_kind))
return (enum gnu_v3_dtor_kinds) 0;
+ return dtor_kind;
}
-#endif /* IN_GLIBCPP_V3 */
+#endif /* IN_GLIBCPP_V3 */
#ifdef STANDALONE_DEMANGLER
#include "getopt.h"
+#include "dyn-string.h"
+
+static void print_usage PARAMS ((FILE* fp, int exit_value));
-static void print_usage
- PARAMS ((FILE* fp, int exit_value));
+#define IS_ALPHA(CHAR) \
+ (((CHAR) >= 'a' && (CHAR) <= 'z') \
+ || ((CHAR) >= 'A' && (CHAR) <= 'Z'))
/* Non-zero if CHAR is a character than can occur in a mangled name. */
#define is_mangled_char(CHAR) \
fprintf (fp, "Usage: %s [options] [names ...]\n", program_name);
fprintf (fp, "Options:\n");
fprintf (fp, " -h,--help Display this message.\n");
- fprintf (fp, " -s,--strict Demangle standard names only.\n");
fprintf (fp, " -v,--verbose Produce verbose demanglings.\n");
fprintf (fp, "If names are provided, they are demangled. Otherwise filters standard input.\n");
static const struct option long_options[] =
{
{ "help", no_argument, NULL, 'h' },
- { "strict", no_argument, NULL, 's' },
{ "verbose", no_argument, NULL, 'v' },
{ NULL, no_argument, NULL, 0 },
};
int argc;
char *argv[];
{
- status_t status;
int i;
int opt_char;
+ int options = DMGL_PARAMS | DMGL_ANSI | DMGL_TYPES;
/* Use the program name of this program, as invoked. */
program_name = argv[0];
/* Parse options. */
do
{
- opt_char = getopt_long (argc, argv, "hsv", long_options, NULL);
+ opt_char = getopt_long (argc, argv, "hv", long_options, NULL);
switch (opt_char)
{
case '?': /* Unrecognized option. */
print_usage (stdout, 0);
break;
- case 's':
- flag_strict = 1;
- break;
-
case 'v':
- flag_verbose = 1;
+ options |= DMGL_VERBOSE;
break;
}
}
/* No command line arguments were provided. Filter stdin. */
{
dyn_string_t mangled = dyn_string_new (3);
- dyn_string_t demangled = dyn_string_new (0);
- status_t status;
+ char *s;
/* Read all of input. */
while (!feof (stdin))
{
- char c = getchar ();
-
- /* The first character of a mangled name is an underscore. */
- if (feof (stdin))
- break;
- if (c != '_')
- {
- /* It's not a mangled name. Print the character and go
- on. */
- putchar (c);
- continue;
- }
- c = getchar ();
-
- /* The second character of a mangled name is a capital `Z'. */
- if (feof (stdin))
- break;
- if (c != 'Z')
- {
- /* It's not a mangled name. Print the previous
- underscore, the `Z', and go on. */
- putchar ('_');
- putchar (c);
- continue;
- }
-
- /* Start keeping track of the candidate mangled name. */
- dyn_string_append_char (mangled, '_');
- dyn_string_append_char (mangled, 'Z');
+ char c;
/* Pile characters into mangled until we hit one that can't
occur in a mangled name. */
c = getchar ();
}
- /* Attempt to demangle the name. */
- status = cp_demangle (dyn_string_buf (mangled), demangled, 0);
-
- /* If the demangling succeeded, great! Print out the
- demangled version. */
- if (STATUS_NO_ERROR (status))
- fputs (dyn_string_buf (demangled), stdout);
- /* Abort on allocation failures. */
- else if (status == STATUS_ALLOCATION_FAILED)
+ if (dyn_string_length (mangled) > 0)
{
- fprintf (stderr, "Memory allocation failed.\n");
- abort ();
+ s = cplus_demangle_v3 (dyn_string_buf (mangled), options);
+
+ if (s != NULL)
+ {
+ fputs (s, stdout);
+ free (s);
+ }
+ else
+ {
+ /* It might not have been a mangled name. Print the
+ original text. */
+ fputs (dyn_string_buf (mangled), stdout);
+ }
+
+ dyn_string_clear (mangled);
}
- /* Otherwise, it might not have been a mangled name. Just
- print out the original text. */
- else
- fputs (dyn_string_buf (mangled), stdout);
/* If we haven't hit EOF yet, we've read one character that
can't occur in a mangled name, so print it out. */
if (!feof (stdin))
putchar (c);
-
- /* Clear the candidate mangled name, to start afresh next
- time we hit a `_Z'. */
- dyn_string_clear (mangled);
}
dyn_string_delete (mangled);
- dyn_string_delete (demangled);
}
else
/* Demangle command line arguments. */
{
- dyn_string_t result = dyn_string_new (0);
-
/* Loop over command line arguments. */
for (i = optind; i < argc; ++i)
{
+ char *s;
+
/* Attempt to demangle. */
- status = cp_demangle (argv[i], result, 0);
+ s = cplus_demangle_v3 (argv[i], options);
/* If it worked, print the demangled name. */
- if (STATUS_NO_ERROR (status))
- printf ("%s\n", dyn_string_buf (result));
- /* Abort on allocaiton failures. */
- else if (status == STATUS_ALLOCATION_FAILED)
+ if (s != NULL)
{
- fprintf (stderr, "Memory allocation failed.\n");
- abort ();
+ printf ("%s\n", s);
+ free (s);
}
- /* If not, print the error message to stderr instead. */
- else
- fprintf (stderr, "%s\n", status);
+ else
+ fprintf (stderr, "Failed: %s\n", argv[i]);
}
- dyn_string_delete (result);
}
return 0;
projects / binutils-gdb.git / commitdiff