From: ian Date: Mon, 12 Jan 2004 19:46:31 +0000 (+0000) Subject: * demangle.h (enum demangle_component_type): Define. X-Git-Url: http://git.sourceforge.jp/view?p=pf3gnuchains%2Fgcc-fork.git;a=commitdiff_plain;h=f95cb811b880739ec7b6a5de90940e364cc7465f * demangle.h (enum demangle_component_type): Define. (struct demangle_operator_info): Declare. (struct demangle_builtin_type_info): Declare. (struct demangle_component): Define. (cplus_demangle_fill_component): Declare. (cplus_demangle_fill_name): Declare. (cplus_demangle_fill_builtin_type): Declare. (cplus_demangle_fill_operator): Declare. (cplus_demangle_fill_extended_operator): Declare. (cplus_demangle_fill_ctor, cplus_demangle_fill_dtor): Declare. (cplus_demangle_v3_components): Declare. (cplus_demangle_print): Declare. * cp-demangle.c: Include "cp-demangle.h". If IN_GLIBCPP_V3 is defined, rename some functions which are to become static via #define. (CP_STATIC_IF_GLIBCPP_V3): Define. (struct d_operator_info): Move definition to cp-demangle.h, and rename to demangle_operator_info. Change all uses. (enum d_builtin_type_print): Move definition to cp-demangle.h. (struct d_builtin_type_info): Move definition to cp-demangle.h, and rename to demangle_builtin_type_info. Change all uses. (enum d_comp_type): Move definition to include/demangle.h, and rename to demangle_component_type, and change all enums to start with DEMANGLE_COMPONENT_ instead of D_. Change all uses. (struct d_comp): Move definition to include/demangle.h, and rename to demangle_component. Change all uses. (struct d_info): Move definition to cp-demangle.h. (cplus_demangle_fill_name): New function. (cplus_demangle_fill_extended_operator): New function. (cplus_demangle_fill_ctor): New function. (cplus_demangle_fill_dtor): New function. (d_make_empty): Remove type parameter. Change all callers. (d_make_name): Use cplus_demangle_fill_name. (d_make_extended_operator): Use cplus_demangle_fill_extended_operator. (d_make_ctor): Use cplus_demangle_fill_ctor. (d_make_dtor): Use cplus_demangle_fill_dtor. (cplus_demangle_mangled_name): Rename from d_mangled_name. Make non-static by default. Change all callers. (cplus_demangle_operators): Rename from d_operators. Change all uses. Make non-static by default. Add sentinel at end of array. (d_operator_name): Adjust initialization of high for new sentinel in cplus_demangle_operators. (cplus_demangle_builtin_types): Rename from d_builtin_types. Change all uses. Make non-static by default. Change initializer to use D_BUILTIN_TYPE_COUNT instead of magic number 26. (cplus_demangle_type): Rename from d_type. Make non-static by default. Change all callers. (cplus_demangle_init_info): Rename from d_init_info. Make non-static by default. Change all callers. * cp-demangle.h: New file. * cp-demint.c: New file. * Makefile.in: Rebuild dependencies. (CFILES): Add cp-demint.c. (REQUIRED_OFILES): Add cp-demint.o. git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@75748 138bc75d-0d04-0410-961f-82ee72b054a4 --- diff --git a/include/ChangeLog b/include/ChangeLog index 69db5b765e1..2e291cc6216 100644 --- a/include/ChangeLog +++ b/include/ChangeLog @@ -1,3 +1,18 @@ +2004-01-12 Ian Lance Taylor + + * demangle.h (enum demangle_component_type): Define. + (struct demangle_operator_info): Declare. + (struct demangle_builtin_type_info): Declare. + (struct demangle_component): Define. + (cplus_demangle_fill_component): Declare. + (cplus_demangle_fill_name): Declare. + (cplus_demangle_fill_builtin_type): Declare. + (cplus_demangle_fill_operator): Declare. + (cplus_demangle_fill_extended_operator): Declare. + (cplus_demangle_fill_ctor, cplus_demangle_fill_dtor): Declare. + (cplus_demangle_v3_components): Declare. + (cplus_demangle_print): Declare. + 2003-12-19 Andreas Tobler * include/fibheap.h (fibnode): Use __extension__ for diff --git a/include/demangle.h b/include/demangle.h index bff266931c8..c3fdb036d53 100644 --- a/include/demangle.h +++ b/include/demangle.h @@ -1,6 +1,6 @@ /* Defs for interface to demanglers. - Copyright 1992, 1993, 1994, 1995, 1996, 1997, 1998, 2000, 2001, 2002 - Free Software Foundation, Inc. + Copyright 1992, 1993, 1994, 1995, 1996, 1997, 1998, 2000, 2001, 2002, + 2003, 2004 Free Software Foundation, Inc. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -164,6 +164,368 @@ enum gnu_v3_dtor_kinds { extern enum gnu_v3_dtor_kinds is_gnu_v3_mangled_dtor PARAMS ((const char *name)); +/* The V3 demangler works in two passes. The first pass builds a tree + representation of the mangled name, and the second pass turns the + tree representation into a demangled string. Here we define an + interface to permit a caller to build their own tree + representation, which they can pass to the demangler to get a + demangled string. This can be used to canonicalize user input into + something which the demangler might output. It could also be used + by other demanglers in the future. */ + +/* These are the component types which may be found in the tree. Many + component types have one or two subtrees, referred to as left and + right (a component type with only one subtree puts it in the left + subtree). */ + +enum demangle_component_type +{ + /* A name, with a length and a pointer to a string. */ + DEMANGLE_COMPONENT_NAME, + /* A qualified name. The left subtree is a class or namespace or + some such thing, and the right subtree is a name qualified by + that class. */ + DEMANGLE_COMPONENT_QUAL_NAME, + /* A local name. The left subtree describes a function, and the + right subtree is a name which is local to that function. */ + DEMANGLE_COMPONENT_LOCAL_NAME, + /* A typed name. The left subtree is a name, and the right subtree + describes that name as a function. */ + DEMANGLE_COMPONENT_TYPED_NAME, + /* A template. The left subtree is a template name, and the right + subtree is a template argument list. */ + DEMANGLE_COMPONENT_TEMPLATE, + /* A template parameter. This holds a number, which is the template + parameter index. */ + DEMANGLE_COMPONENT_TEMPLATE_PARAM, + /* A constructor. This holds a name and the kind of + constructor. */ + DEMANGLE_COMPONENT_CTOR, + /* A destructor. This holds a name and the kind of destructor. */ + DEMANGLE_COMPONENT_DTOR, + /* A vtable. This has one subtree, the type for which this is a + vtable. */ + DEMANGLE_COMPONENT_VTABLE, + /* A VTT structure. This has one subtree, the type for which this + is a VTT. */ + DEMANGLE_COMPONENT_VTT, + /* A construction vtable. The left subtree is the type for which + this is a vtable, and the right subtree is the derived type for + which this vtable is built. */ + DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE, + /* A typeinfo structure. This has one subtree, the type for which + this is the tpeinfo structure. */ + DEMANGLE_COMPONENT_TYPEINFO, + /* A typeinfo name. This has one subtree, the type for which this + is the typeinfo name. */ + DEMANGLE_COMPONENT_TYPEINFO_NAME, + /* A typeinfo function. This has one subtree, the type for which + this is the tpyeinfo function. */ + DEMANGLE_COMPONENT_TYPEINFO_FN, + /* A thunk. This has one subtree, the name for which this is a + thunk. */ + DEMANGLE_COMPONENT_THUNK, + /* A virtual thunk. This has one subtree, the name for which this + is a virtual thunk. */ + DEMANGLE_COMPONENT_VIRTUAL_THUNK, + /* A covariant thunk. This has one subtree, the name for which this + is a covariant thunk. */ + DEMANGLE_COMPONENT_COVARIANT_THUNK, + /* A Java class. This has one subtree, the type. */ + DEMANGLE_COMPONENT_JAVA_CLASS, + /* A guard variable. This has one subtree, the name for which this + is a guard variable. */ + DEMANGLE_COMPONENT_GUARD, + /* A reference temporary. This has one subtree, the name for which + this is a temporary. */ + DEMANGLE_COMPONENT_REFTEMP, + /* A standard substitution. This holds the name of the + substitution. */ + DEMANGLE_COMPONENT_SUB_STD, + /* The restrict qualifier. The one subtree is the type which is + being qualified. */ + DEMANGLE_COMPONENT_RESTRICT, + /* The volatile qualifier. The one subtree is the type which is + being qualified. */ + DEMANGLE_COMPONENT_VOLATILE, + /* The const qualifier. The one subtree is the type which is being + qualified. */ + DEMANGLE_COMPONENT_CONST, + /* The restrict qualifier modifying a member function. The one + subtree is the type which is being qualified. */ + DEMANGLE_COMPONENT_RESTRICT_THIS, + /* The volatile qualifier modifying a member function. The one + subtree is the type which is being qualified. */ + DEMANGLE_COMPONENT_VOLATILE_THIS, + /* The const qualifier modifying a member function. The one subtree + is the type which is being qualified. */ + DEMANGLE_COMPONENT_CONST_THIS, + /* A vendor qualifier. The left subtree is the type which is being + qualified, and the right subtree is the name of the + qualifier. */ + DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL, + /* A pointer. The one subtree is the type which is being pointed + to. */ + DEMANGLE_COMPONENT_POINTER, + /* A reference. The one subtree is the type which is being + referenced. */ + DEMANGLE_COMPONENT_REFERENCE, + /* A complex type. The one subtree is the base type. */ + DEMANGLE_COMPONENT_COMPLEX, + /* An imaginary type. The one subtree is the base type. */ + DEMANGLE_COMPONENT_IMAGINARY, + /* A builtin type. This holds the builtin type information. */ + DEMANGLE_COMPONENT_BUILTIN_TYPE, + /* A vendor's builtin type. This holds the name of the type. */ + DEMANGLE_COMPONENT_VENDOR_TYPE, + /* A function type. The left subtree is the return type. The right + subtree is a list of ARGLIST nodes. Either or both may be + NULL. */ + DEMANGLE_COMPONENT_FUNCTION_TYPE, + /* An array type. The left subtree is the dimension, which may be + NULL, or a string (represented as DEMANGLE_COMPONENT_NAME), or an + expression. The right subtree is the element type. */ + DEMANGLE_COMPONENT_ARRAY_TYPE, + /* A pointer to member type. The left subtree is the class type, + and the right subtree is the member type. CV-qualifiers appear + on the latter. */ + DEMANGLE_COMPONENT_PTRMEM_TYPE, + /* An argument list. The left subtree is the current argument, and + the right subtree is either NULL or another ARGLIST node. */ + DEMANGLE_COMPONENT_ARGLIST, + /* A template argument list. The left subtree is the current + template argument, and the right subtree is either NULL or + another TEMPLATE_ARGLIST node. */ + DEMANGLE_COMPONENT_TEMPLATE_ARGLIST, + /* An operator. This holds information about a standard + operator. */ + DEMANGLE_COMPONENT_OPERATOR, + /* An extended operator. This holds the number of arguments, and + the name of the extended operator. */ + DEMANGLE_COMPONENT_EXTENDED_OPERATOR, + /* A typecast, represented as a unary operator. The one subtree is + the type to which the argument should be cast. */ + DEMANGLE_COMPONENT_CAST, + /* A unary expression. The left subtree is the operator, and the + right subtree is the single argument. */ + DEMANGLE_COMPONENT_UNARY, + /* A binary expression. The left subtree is the operator, and the + right subtree is a BINARY_ARGS. */ + DEMANGLE_COMPONENT_BINARY, + /* Arguments to a binary expression. The left subtree is the first + argument, and the right subtree is the second argument. */ + DEMANGLE_COMPONENT_BINARY_ARGS, + /* A trinary expression. The left subtree is the operator, and the + right subtree is a TRINARY_ARG1. */ + DEMANGLE_COMPONENT_TRINARY, + /* Arguments to a trinary expression. The left subtree is the first + argument, and the right subtree is a TRINARY_ARG2. */ + DEMANGLE_COMPONENT_TRINARY_ARG1, + /* More arguments to a trinary expression. The left subtree is the + second argument, and the right subtree is the third argument. */ + DEMANGLE_COMPONENT_TRINARY_ARG2, + /* A literal. The left subtree is the type, and the right subtree + is the value, represented as a DEMANGLE_COMPONENT_NAME. */ + DEMANGLE_COMPONENT_LITERAL, + /* A negative literal. Like LITERAL, but the value is negated. + This is a minor hack: the NAME used for LITERAL points directly + to the mangled string, but since negative numbers are mangled + using 'n' instead of '-', we want a way to indicate a negative + number which involves neither modifying the mangled string nor + allocating a new copy of the literal in memory. */ + DEMANGLE_COMPONENT_LITERAL_NEG +}; + +/* Types which are only used internally. */ + +struct demangle_operator_info; +struct demangle_builtin_type_info; + +/* A node in the tree representation is an instance of a struct + demangle_component. Note that the field names of the struct are + not well protected against macros defined by the file including + this one. We can fix this if it ever becomes a problem. */ + +struct demangle_component +{ + /* The type of this component. */ + enum demangle_component_type type; + + union + { + /* For DEMANGLE_COMPONENT_NAME. */ + struct + { + /* A pointer to the name (which need not NULL terminated) and + its length. */ + const char *s; + int len; + } s_name; + + /* For DEMANGLE_COMPONENT_OPERATOR. */ + struct + { + /* Operator. */ + const struct demangle_operator_info *op; + } s_operator; + + /* For DEMANGLE_COMPONENT_EXTENDED_OPERATOR. */ + struct + { + /* Number of arguments. */ + int args; + /* Name. */ + struct demangle_component *name; + } s_extended_operator; + + /* For DEMANGLE_COMPONENT_CTOR. */ + struct + { + /* Kind of constructor. */ + enum gnu_v3_ctor_kinds kind; + /* Name. */ + struct demangle_component *name; + } s_ctor; + + /* For DEMANGLE_COMPONENT_DTOR. */ + struct + { + /* Kind of destructor. */ + enum gnu_v3_dtor_kinds kind; + /* Name. */ + struct demangle_component *name; + } s_dtor; + + /* For DEMANGLE_COMPONENT_BUILTIN_TYPE. */ + struct + { + /* Builtin type. */ + const struct demangle_builtin_type_info *type; + } s_builtin; + + /* For DEMANGLE_COMPONENT_SUB_STD. */ + struct + { + /* Standard substitution string. */ + const char* string; + /* Length of string. */ + int len; + } s_string; + + /* For DEMANGLE_COMPONENT_TEMPLATE_PARAM. */ + struct + { + /* Template parameter index. */ + long number; + } s_number; + + /* For other types. */ + struct + { + /* Left (or only) subtree. */ + struct demangle_component *left; + /* Right subtree. */ + struct demangle_component *right; + } s_binary; + + } u; +}; + +/* People building mangled trees are expected to allocate instances of + struct demangle_component themselves. They can then call one of + the following functions to fill them in. */ + +/* Fill in most component types with a left subtree and a right + subtree. Returns non-zero on success, zero on failure, such as an + unrecognized or inappropriate component type. */ + +extern int +cplus_demangle_fill_component PARAMS ((struct demangle_component *fill, + enum demangle_component_type, + struct demangle_component *left, + struct demangle_component *right)); + +/* Fill in a DEMANGLE_COMPONENT_NAME. Returns non-zero on success, + zero for bad arguments. */ + +extern int +cplus_demangle_fill_name PARAMS ((struct demangle_component *fill, + const char *, int)); + +/* Fill in a DEMANGLE_COMPONENT_BUILTIN_TYPE, using the name of the + builtin type (e.g., "int", etc.). Returns non-zero on success, + zero if the type is not recognized. */ + +extern int +cplus_demangle_fill_builtin_type PARAMS ((struct demangle_component *fill, + const char *typename)); + +/* Fill in a DEMANGLE_COMPONENT_OPERATOR, using the name of the + operator and the number of arguments which it takes (the latter is + used to disambiguate operators which can be both binary and unary, + such as '-'). Returns non-zero on success, zero if the operator is + not recognized. */ + +extern int +cplus_demangle_fill_operator PARAMS ((struct demangle_component *fill, + const char *opname, int args)); + +/* Fill in a DEMANGLE_COMPONENT_EXTENDED_OPERATOR, providing the + number of arguments and the name. Returns non-zero on success, + zero for bad arguments. */ + +extern int +cplus_demangle_fill_extended_operator PARAMS ((struct demangle_component *fill, + int numargs, + struct demangle_component *nm)); + +/* Fill in a DEMANGLE_COMPONENT_CTOR. Returns non-zero on success, + zero for bad arguments. */ + +extern int +cplus_demangle_fill_ctor PARAMS ((struct demangle_component *fill, + enum gnu_v3_ctor_kinds kind, + struct demangle_component *name)); + +/* Fill in a DEMANGLE_COMPONENT_DTOR. Returns non-zero on success, + zero for bad arguments. */ + +extern int +cplus_demangle_fill_dtor PARAMS ((struct demangle_component *fill, + enum gnu_v3_dtor_kinds kind, + struct demangle_component *name)); + +/* This function translates a mangled name into a struct + demangle_component tree. The first argument is the mangled name. + The second argument is DMGL_* options. This returns a pointer to a + tree on success, or NULL on failure. On success, the third + argument is set to a block of memory allocated by malloc. This + block should be passed to free when the tree is no longer + needed. */ + +extern struct demangle_component * +cplus_demangle_v3_components PARAMS ((const char *mangled, + int options, + void **mem)); + +/* This function takes a struct demangle_component tree and returns + the corresponding demangled string. The first argument is DMGL_* + options. The second is the tree to demangle. The third is a guess + at the length of the demangled string, used to initially allocate + the return buffer. The fourth is a pointer to a size_t. On + success, this function returns a buffer allocated by malloc(), and + sets the size_t pointed to by the fourth argument to the size of + the allocated buffer (not the length of the returned string). On + failure, this function returns NULL, and sets the size_t pointed to + by the fourth argument to 0 for an invalid tree, or to 1 for a + memory allocation error. */ + +extern char * +cplus_demangle_print PARAMS ((int options, + const struct demangle_component *tree, + int estimated_length, + size_t *p_allocated_size)); + #ifdef __cplusplus } #endif /* __cplusplus */ diff --git a/libiberty/ChangeLog b/libiberty/ChangeLog index 25f563af36a..9bc2903b52c 100644 --- a/libiberty/ChangeLog +++ b/libiberty/ChangeLog @@ -1,3 +1,49 @@ +2004-01-12 Ian Lance Taylor + + * cp-demangle.c: Include "cp-demangle.h". If IN_GLIBCPP_V3 is + defined, rename some functions which are to become static via + #define. + (CP_STATIC_IF_GLIBCPP_V3): Define. + (struct d_operator_info): Move definition to cp-demangle.h, and + rename to demangle_operator_info. Change all uses. + (enum d_builtin_type_print): Move definition to cp-demangle.h. + (struct d_builtin_type_info): Move definition to cp-demangle.h, + and rename to demangle_builtin_type_info. Change all uses. + (enum d_comp_type): Move definition to include/demangle.h, and + rename to demangle_component_type, and change all enums to start + with DEMANGLE_COMPONENT_ instead of D_. Change all uses. + (struct d_comp): Move definition to include/demangle.h, and rename + to demangle_component. Change all uses. + (struct d_info): Move definition to cp-demangle.h. + (cplus_demangle_fill_name): New function. + (cplus_demangle_fill_extended_operator): New function. + (cplus_demangle_fill_ctor): New function. + (cplus_demangle_fill_dtor): New function. + (d_make_empty): Remove type parameter. Change all callers. + (d_make_name): Use cplus_demangle_fill_name. + (d_make_extended_operator): Use + cplus_demangle_fill_extended_operator. + (d_make_ctor): Use cplus_demangle_fill_ctor. + (d_make_dtor): Use cplus_demangle_fill_dtor. + (cplus_demangle_mangled_name): Rename from d_mangled_name. Make + non-static by default. Change all callers. + (cplus_demangle_operators): Rename from d_operators. Change all + uses. Make non-static by default. Add sentinel at end of array. + (d_operator_name): Adjust initialization of high for new sentinel + in cplus_demangle_operators. + (cplus_demangle_builtin_types): Rename from d_builtin_types. + Change all uses. Make non-static by default. Change initializer + to use D_BUILTIN_TYPE_COUNT instead of magic number 26. + (cplus_demangle_type): Rename from d_type. Make non-static by + default. Change all callers. + (cplus_demangle_init_info): Rename from d_init_info. Make + non-static by default. Change all callers. + * cp-demangle.h: New file. + * cp-demint.c: New file. + * Makefile.in: Rebuild dependencies. + (CFILES): Add cp-demint.c. + (REQUIRED_OFILES): Add cp-demint.o. + 2004-01-09 Kelley Cook * configure.in: Rename file to ... diff --git a/libiberty/Makefile.in b/libiberty/Makefile.in index 0e1c8f252d9..139cb68a11f 100644 --- a/libiberty/Makefile.in +++ b/libiberty/Makefile.in @@ -1,6 +1,6 @@ # # Makefile -# Copyright (C) 1990, 91-99, 2000, 2001, 2002, 2003 +# Copyright (C) 1990, 91-99, 2000, 2001, 2002, 2003, 2004 # Free Software Foundation # # This file is part of the libiberty library. @@ -130,7 +130,7 @@ COMPILE.c = $(CC) -c @DEFS@ $(LIBCFLAGS) -I. -I$(INCDIR) $(HDEFINES) @ac_libiber CFILES = alloca.c argv.c asprintf.c atexit.c \ basename.c bcmp.c bcopy.c bsearch.c bzero.c \ calloc.c choose-temp.c clock.c concat.c cp-demangle.c \ - cplus-dem.c \ + cp-demint.c cplus-dem.c \ dyn-string.c \ fdmatch.c ffs.c fibheap.c floatformat.c fnmatch.c \ getcwd.c getopt.c getopt1.c getpagesize.c getpwd.c getruntime.c \ @@ -158,7 +158,7 @@ CFILES = alloca.c argv.c asprintf.c atexit.c \ # These are always included in the library. The first four are listed # first and by compile time to optimize parallel builds. -REQUIRED_OFILES = regex.o cplus-dem.o cp-demangle.o md5.o \ +REQUIRED_OFILES = regex.o cplus-dem.o cp-demangle.o cp-demint.o md5.o \ alloca.o argv.o \ choose-temp.o concat.o \ dyn-string.o \ @@ -428,8 +428,11 @@ choose-temp.o: config.h $(INCDIR)/ansidecl.h $(INCDIR)/libiberty.h clock.o: config.h concat.o: config.h $(INCDIR)/ansidecl.h $(INCDIR)/libiberty.h copysign.o: $(INCDIR)/ansidecl.h -cp-demangle.o: config.h $(INCDIR)/ansidecl.h $(INCDIR)/demangle.h \ - $(INCDIR)/dyn-string.h $(INCDIR)/getopt.h $(INCDIR)/libiberty.h +cp-demangle.o: config.h $(INCDIR)/ansidecl.h $(srcdir)/cp-demangle.h \ + $(INCDIR)/demangle.h $(INCDIR)/dyn-string.h $(INCDIR)/getopt.h \ + $(INCDIR)/libiberty.h +cp-demint.o: config.h $(INCDIR)/ansidecl.h $(srcdir)/cp-demangle.h \ + $(INCDIR)/demangle.h $(INCDIR)/libiberty.h cplus-dem.o: config.h $(INCDIR)/ansidecl.h $(INCDIR)/demangle.h \ $(INCDIR)/libiberty.h $(INCDIR)/safe-ctype.h dyn-string.o: config.h $(INCDIR)/ansidecl.h $(INCDIR)/dyn-string.h \ @@ -450,8 +453,8 @@ hashtab.o: config.h $(INCDIR)/ansidecl.h $(INCDIR)/hashtab.h \ $(INCDIR)/libiberty.h hex.o: $(INCDIR)/ansidecl.h $(INCDIR)/libiberty.h \ $(INCDIR)/safe-ctype.h -lbasename.o: $(INCDIR)/ansidecl.h $(INCDIR)/libiberty.h \ - $(INCDIR)/safe-ctype.h $(INCDIR)/filenames.h +lbasename.o: $(INCDIR)/ansidecl.h $(INCDIR)/filenames.h \ + $(INCDIR)/libiberty.h $(INCDIR)/safe-ctype.h lrealpath.o: config.h $(INCDIR)/ansidecl.h $(INCDIR)/libiberty.h make-relative-prefix.o: config.h $(INCDIR)/ansidecl.h \ $(INCDIR)/libiberty.h diff --git a/libiberty/cp-demangle.c b/libiberty/cp-demangle.c index a5d18170536..1c43eb8bd42 100644 --- a/libiberty/cp-demangle.c +++ b/libiberty/cp-demangle.c @@ -45,6 +45,22 @@ enum gnu_v3_ctor_kinds is_gnu_v3_mangled_ctor (const char *name) enum gnu_v3_dtor_kinds is_gnu_v3_mangled_dtor (const char *name) + Also, the interface to the component list is public, and defined in + demangle.h. The interface consists of these types, which are + defined in demangle.h: + enum demangle_component_type + struct demangle_component + and these functions defined in this file: + cplus_demangle_fill_name + cplus_demangle_fill_extended_operator + cplus_demangle_fill_ctor + cplus_demangle_fill_dtor + cplus_demangle_print + and other functions defined in the file cp-demint.c. + + This file also defines some other functions and variables which are + only to be used by the file cp-demint.c. + Preprocessor macros you can define while compiling this file: IN_LIBGCC2 @@ -54,7 +70,8 @@ instead of cplus_demangle_v3() and java_demangle_v3(). IN_GLIBCPP_V3 - If defined, this file defines only __cxa_demangle(). + If defined, this file defines only __cxa_demangle(), and no other + publically visible functions or variables. STANDALONE_DEMANGLER If defined, this file defines a main() function which demangles @@ -81,6 +98,54 @@ #include "ansidecl.h" #include "libiberty.h" #include "demangle.h" +#include "cp-demangle.h" + +/* If IN_GLIBCPP_V3 is defined, some functions are made static. We + also rename them via #define to avoid compiler errors when the + static definition conflicts with the extern declaration in a header + file. */ +#ifdef IN_GLIBCPP_V3 + +#define CP_STATIC_IF_GLIBCPP_V3 static + +#define cplus_demangle_fill_name d_fill_name +static int +d_fill_name PARAMS ((struct demangle_component *, const char *, int)); + +#define cplus_demangle_fill_extended_operator d_fill_extended_operator +static int +d_fill_extended_operator PARAMS ((struct demangle_component *, int, + struct demangle_component *)); + +#define cplus_demangle_fill_ctor d_fill_ctor +static int +d_fill_ctor PARAMS ((struct demangle_component *, enum gnu_v3_ctor_kinds, + struct demangle_component *)); + +#define cplus_demangle_fill_dtor d_fill_dtor +static int +d_fill_dtor PARAMS ((struct demangle_component *, enum gnu_v3_dtor_kinds, + struct demangle_component *)); + +#define cplus_demangle_mangled_name d_mangled_name +static struct demangle_component * +d_mangled_name PARAMS ((struct d_info *, int)); + +#define cplus_demangle_type d_type +static struct demangle_component * +d_type PARAMS ((struct d_info *)); + +#define cplus_demangle_print d_print +static char * +d_print PARAMS ((int, const struct demangle_component *, int, size_t *)); + +#define cplus_demangle_init_info d_init_info +static void +d_init_info PARAMS ((const char *, int, size_t, struct d_info *)); + +#else /* ! defined(IN_GLIBCPP_V3) */ +#define CP_STATIC_IF_GLIBCPP_V3 +#endif /* ! defined(IN_GLIBCPP_V3) */ /* See if the compiler supports dynamic arrays. */ @@ -115,52 +180,6 @@ #define ANONYMOUS_NAMESPACE_PREFIX_LEN \ (sizeof (ANONYMOUS_NAMESPACE_PREFIX) - 1) -/* Information we keep for operators. */ - -struct d_operator_info -{ - /* Mangled name. */ - const char *code; - /* Real name. */ - const char *name; - /* Length of real name. */ - int len; - /* Number of arguments. */ - int args; -}; - -/* How to print the value of a builtin type. */ - -enum d_builtin_type_print -{ - /* Print as (type)val. */ - D_PRINT_DEFAULT, - /* Print as integer. */ - D_PRINT_INT, - /* Print as long, with trailing `l'. */ - D_PRINT_LONG, - /* Print as bool. */ - D_PRINT_BOOL, - /* Print in usual way, but here to detect void. */ - D_PRINT_VOID -}; - -/* Information we keep for a builtin type. */ - -struct d_builtin_type_info -{ - /* Type name. */ - const char *name; - /* Length of type name. */ - int len; - /* Type name when using Java. */ - const char *java_name; - /* Length of java name. */ - int java_len; - /* How to print a value of this type. */ - enum d_builtin_type_print print; -}; - /* Information we keep for the standard substitutions. */ struct d_standard_sub_info @@ -184,232 +203,11 @@ struct d_standard_sub_info int set_last_name_len; }; -/* Component types found in mangled names. */ - -enum d_comp_type -{ - /* A name. */ - D_COMP_NAME, - /* A qualified name. */ - D_COMP_QUAL_NAME, - /* A local name. */ - D_COMP_LOCAL_NAME, - /* A typed name. */ - D_COMP_TYPED_NAME, - /* A template. */ - D_COMP_TEMPLATE, - /* A template parameter. */ - D_COMP_TEMPLATE_PARAM, - /* A constructor. */ - D_COMP_CTOR, - /* A destructor. */ - D_COMP_DTOR, - /* A vtable. */ - D_COMP_VTABLE, - /* A VTT structure. */ - D_COMP_VTT, - /* A construction vtable. */ - D_COMP_CONSTRUCTION_VTABLE, - /* A typeinfo structure. */ - D_COMP_TYPEINFO, - /* A typeinfo name. */ - D_COMP_TYPEINFO_NAME, - /* A typeinfo function. */ - D_COMP_TYPEINFO_FN, - /* A thunk. */ - D_COMP_THUNK, - /* A virtual thunk. */ - D_COMP_VIRTUAL_THUNK, - /* A covariant thunk. */ - D_COMP_COVARIANT_THUNK, - /* A Java class. */ - D_COMP_JAVA_CLASS, - /* A guard variable. */ - D_COMP_GUARD, - /* A reference temporary. */ - D_COMP_REFTEMP, - /* A standard substitution. */ - D_COMP_SUB_STD, - /* The restrict qualifier. */ - D_COMP_RESTRICT, - /* The volatile qualifier. */ - D_COMP_VOLATILE, - /* The const qualifier. */ - D_COMP_CONST, - /* The restrict qualifier modifying a member function. */ - D_COMP_RESTRICT_THIS, - /* The volatile qualifier modifying a member function. */ - D_COMP_VOLATILE_THIS, - /* The const qualifier modifying a member function. */ - D_COMP_CONST_THIS, - /* A vendor qualifier. */ - D_COMP_VENDOR_TYPE_QUAL, - /* A pointer. */ - D_COMP_POINTER, - /* A reference. */ - D_COMP_REFERENCE, - /* A complex type. */ - D_COMP_COMPLEX, - /* An imaginary type. */ - D_COMP_IMAGINARY, - /* A builtin type. */ - D_COMP_BUILTIN_TYPE, - /* A vendor's builtin type. */ - D_COMP_VENDOR_TYPE, - /* A function type. */ - D_COMP_FUNCTION_TYPE, - /* An array type. */ - D_COMP_ARRAY_TYPE, - /* A pointer to member type. */ - D_COMP_PTRMEM_TYPE, - /* An argument list. */ - D_COMP_ARGLIST, - /* A template argument list. */ - D_COMP_TEMPLATE_ARGLIST, - /* An operator. */ - D_COMP_OPERATOR, - /* An extended operator. */ - D_COMP_EXTENDED_OPERATOR, - /* A typecast. */ - D_COMP_CAST, - /* A unary expression. */ - D_COMP_UNARY, - /* A binary expression. */ - D_COMP_BINARY, - /* Arguments to a binary expression. */ - D_COMP_BINARY_ARGS, - /* A trinary expression. */ - D_COMP_TRINARY, - /* Arguments to a trinary expression. */ - D_COMP_TRINARY_ARG1, - D_COMP_TRINARY_ARG2, - /* A literal. */ - D_COMP_LITERAL, - /* A negative literal. */ - D_COMP_LITERAL_NEG -}; - -/* A component of the mangled name. */ - -struct d_comp -{ - /* The type of this component. */ - enum d_comp_type type; - union - { - /* For D_COMP_NAME. */ - struct - { - /* A pointer to the name (not NULL terminated) and it's - length. */ - const char *s; - int len; - } s_name; - - /* For D_COMP_OPERATOR. */ - struct - { - /* Operator. */ - const struct d_operator_info *op; - } s_operator; - - /* For D_COMP_EXTENDED_OPERATOR. */ - struct - { - /* Number of arguments. */ - int args; - /* Name. */ - struct d_comp *name; - } s_extended_operator; - - /* For D_COMP_CTOR. */ - struct - { - enum gnu_v3_ctor_kinds kind; - struct d_comp *name; - } s_ctor; - - /* For D_COMP_DTOR. */ - struct - { - enum gnu_v3_dtor_kinds kind; - struct d_comp *name; - } s_dtor; - - /* For D_COMP_BUILTIN_TYPE. */ - struct - { - const struct d_builtin_type_info *type; - } s_builtin; - - /* For D_COMP_SUB_STD. */ - struct - { - const char* string; - int len; - } s_string; - - /* For D_COMP_TEMPLATE_PARAM. */ - struct - { - long number; - } s_number; - - /* For other types. */ - struct - { - struct d_comp *left; - struct d_comp *right; - } s_binary; - - } u; -}; +/* Accessors for subtrees of struct demangle_component. */ #define d_left(dc) ((dc)->u.s_binary.left) #define d_right(dc) ((dc)->u.s_binary.right) -/* The information structure we pass around. */ - -struct d_info -{ - /* The string we are demangling. */ - const char *s; - /* The end of the string we are demangling. */ - const char *send; - /* The options passed to the demangler. */ - int options; - /* The next character in the string to consider. */ - const char *n; - /* The array of components. */ - struct d_comp *comps; - /* The index of the next available component. */ - int next_comp; - /* The number of available component structures. */ - int num_comps; - /* The array of substitutions. */ - struct d_comp **subs; - /* The index of the next substitution. */ - int next_sub; - /* The number of available entries in the subs array. */ - int num_subs; - /* The number of substitutions which we actually made from the subs - array, plus the number of template parameter references we - saw. */ - int did_subs; - /* The last name we saw, for constructors and destructors. */ - struct d_comp *last_name; - /* A running total of the length of large expansions from the - mangled name to the demangled name, such as standard - substitutions and builtin types. */ - int expansion; -}; - -#define d_peek_char(di) (*((di)->n)) -#define d_peek_next_char(di) ((di)->n[1]) -#define d_advance(di, i) ((di)->n += (i)) -#define d_next_char(di) (*((di)->n++)) -#define d_str(di) ((di)->n) - /* A list of templates. This is used while printing. */ struct d_print_template @@ -417,7 +215,7 @@ struct d_print_template /* Next template on the list. */ struct d_print_template *next; /* This template. */ - const struct d_comp *template; + const struct demangle_component *template; }; /* A list of type modifiers. This is used while printing. */ @@ -428,7 +226,7 @@ struct d_print_mod in which they appeared in the mangled string. */ struct d_print_mod *next; /* The modifier. */ - const struct d_comp *mod; + const struct demangle_component *mod; /* Whether this modifier was printed. */ int printed; /* The list of templates which applies to this modifier. */ @@ -488,93 +286,186 @@ struct d_print_info ((dpi)->buf == NULL || (dpi)->len == 0 ? '\0' : (dpi)->buf[(dpi)->len - 1]) #ifdef CP_DEMANGLE_DEBUG -static void d_dump PARAMS ((struct d_comp *, int)); +static void +d_dump PARAMS ((struct demangle_component *, int)); #endif -static struct d_comp *d_make_empty PARAMS ((struct d_info *, - enum d_comp_type)); -static struct d_comp *d_make_comp PARAMS ((struct d_info *, enum d_comp_type, - struct d_comp *, struct d_comp *)); -static struct d_comp *d_make_name PARAMS ((struct d_info *, const char *, - int)); -static struct d_comp *d_make_builtin_type PARAMS ((struct d_info *, - const struct d_builtin_type_info *)); -static struct d_comp *d_make_operator PARAMS ((struct d_info *, - const struct d_operator_info *)); -static struct d_comp *d_make_extended_operator PARAMS ((struct d_info *, - int, - struct d_comp *)); -static struct d_comp *d_make_ctor PARAMS ((struct d_info *, - enum gnu_v3_ctor_kinds, - struct d_comp *)); -static struct d_comp *d_make_dtor PARAMS ((struct d_info *, - enum gnu_v3_dtor_kinds, - struct d_comp *)); -static struct d_comp *d_make_template_param PARAMS ((struct d_info *, long)); -static struct d_comp *d_make_sub PARAMS ((struct d_info *, const char *, int)); -static struct d_comp *d_mangled_name PARAMS ((struct d_info *, int)); -static int has_return_type PARAMS ((struct d_comp *)); -static int is_ctor_dtor_or_conversion PARAMS ((struct d_comp *)); -static struct d_comp *d_encoding PARAMS ((struct d_info *, int)); -static struct d_comp *d_name PARAMS ((struct d_info *)); -static struct d_comp *d_nested_name PARAMS ((struct d_info *)); -static struct d_comp *d_prefix PARAMS ((struct d_info *)); -static struct d_comp *d_unqualified_name PARAMS ((struct d_info *)); -static struct d_comp *d_source_name PARAMS ((struct d_info *)); -static long d_number PARAMS ((struct d_info *)); -static struct d_comp *d_identifier PARAMS ((struct d_info *, int)); -static struct d_comp *d_operator_name PARAMS ((struct d_info *)); -static struct d_comp *d_special_name PARAMS ((struct d_info *)); -static int d_call_offset PARAMS ((struct d_info *, int)); -static struct d_comp *d_ctor_dtor_name PARAMS ((struct d_info *)); -static struct d_comp *d_type PARAMS ((struct d_info *)); -static struct d_comp **d_cv_qualifiers PARAMS ((struct d_info *, - struct d_comp **, int)); -static struct d_comp *d_function_type PARAMS ((struct d_info *)); -static struct d_comp *d_bare_function_type PARAMS ((struct d_info *, int)); -static struct d_comp *d_class_enum_type PARAMS ((struct d_info *)); -static struct d_comp *d_array_type PARAMS ((struct d_info *)); -static struct d_comp *d_pointer_to_member_type PARAMS ((struct d_info *)); -static struct d_comp *d_template_param PARAMS ((struct d_info *)); -static struct d_comp *d_template_args PARAMS ((struct d_info *)); -static struct d_comp *d_template_arg PARAMS ((struct d_info *)); -static struct d_comp *d_expression PARAMS ((struct d_info *)); -static struct d_comp *d_expr_primary PARAMS ((struct d_info *)); -static struct d_comp *d_local_name PARAMS ((struct d_info *)); -static int d_discriminator PARAMS ((struct d_info *)); -static int d_add_substitution PARAMS ((struct d_info *, struct d_comp *)); -static struct d_comp *d_substitution PARAMS ((struct d_info *, int)); -static void d_print_resize PARAMS ((struct d_print_info *, size_t)); -static void d_print_append_char PARAMS ((struct d_print_info *, int)); -static void d_print_append_buffer PARAMS ((struct d_print_info *, const char *, - size_t)); -static void d_print_error PARAMS ((struct d_print_info *)); -static char *d_print PARAMS ((int, const struct d_comp *, int, size_t *)); -static void d_print_comp PARAMS ((struct d_print_info *, - const struct d_comp *)); -static void d_print_java_identifier PARAMS ((struct d_print_info *, - const char *, int)); -static void d_print_mod_list PARAMS ((struct d_print_info *, - struct d_print_mod *, int)); -static void d_print_mod PARAMS ((struct d_print_info *, - const struct d_comp *)); -static void d_print_function_type PARAMS ((struct d_print_info *, - const struct d_comp *, - struct d_print_mod *)); -static void d_print_array_type PARAMS ((struct d_print_info *, - const struct d_comp *, - struct d_print_mod *)); -static void d_print_expr_op PARAMS ((struct d_print_info *, - const struct d_comp *)); -static void d_print_cast PARAMS ((struct d_print_info *, - const struct d_comp *)); -static void d_init_info PARAMS ((const char *, int, size_t, struct d_info *)); -static char *d_demangle PARAMS ((const char *, int, size_t *)); + +static struct demangle_component * +d_make_empty PARAMS ((struct d_info *)); + +static struct demangle_component * +d_make_comp PARAMS ((struct d_info *, enum demangle_component_type, + struct demangle_component *, + struct demangle_component *)); + +static struct demangle_component * +d_make_name PARAMS ((struct d_info *, const char *, int)); + +static struct demangle_component * +d_make_builtin_type PARAMS ((struct d_info *, + const struct demangle_builtin_type_info *)); + +static struct demangle_component * +d_make_operator PARAMS ((struct d_info *, + const struct demangle_operator_info *)); + +static struct demangle_component * +d_make_extended_operator PARAMS ((struct d_info *, int, + struct demangle_component *)); + +static struct demangle_component * +d_make_ctor PARAMS ((struct d_info *, enum gnu_v3_ctor_kinds, + struct demangle_component *)); + +static struct demangle_component * +d_make_dtor PARAMS ((struct d_info *, enum gnu_v3_dtor_kinds, + struct demangle_component *)); + +static struct demangle_component * +d_make_template_param PARAMS ((struct d_info *, long)); + +static struct demangle_component * +d_make_sub PARAMS ((struct d_info *, const char *, int)); + +static int +has_return_type PARAMS ((struct demangle_component *)); + +static int +is_ctor_dtor_or_conversion PARAMS ((struct demangle_component *)); + +static struct demangle_component * +d_encoding PARAMS ((struct d_info *, int)); + +static struct demangle_component * +d_name PARAMS ((struct d_info *)); + +static struct demangle_component * +d_nested_name PARAMS ((struct d_info *)); + +static struct demangle_component * +d_prefix PARAMS ((struct d_info *)); + +static struct demangle_component * +d_unqualified_name PARAMS ((struct d_info *)); + +static struct demangle_component * +d_source_name PARAMS ((struct d_info *)); + +static long +d_number PARAMS ((struct d_info *)); + +static struct demangle_component * +d_identifier PARAMS ((struct d_info *, int)); + +static struct demangle_component * +d_operator_name PARAMS ((struct d_info *)); + +static struct demangle_component * +d_special_name PARAMS ((struct d_info *)); + +static int +d_call_offset PARAMS ((struct d_info *, int)); + +static struct demangle_component * +d_ctor_dtor_name PARAMS ((struct d_info *)); + +static struct demangle_component ** +d_cv_qualifiers PARAMS ((struct d_info *, struct demangle_component **, int)); + +static struct demangle_component * +d_function_type PARAMS ((struct d_info *)); + +static struct demangle_component * +d_bare_function_type PARAMS ((struct d_info *, int)); + +static struct demangle_component * +d_class_enum_type PARAMS ((struct d_info *)); + +static struct demangle_component * +d_array_type PARAMS ((struct d_info *)); + +static struct demangle_component * +d_pointer_to_member_type PARAMS ((struct d_info *)); + +static struct demangle_component * +d_template_param PARAMS ((struct d_info *)); + +static struct demangle_component * +d_template_args PARAMS ((struct d_info *)); + +static struct demangle_component * +d_template_arg PARAMS ((struct d_info *)); + +static struct demangle_component * +d_expression PARAMS ((struct d_info *)); + +static struct demangle_component * +d_expr_primary PARAMS ((struct d_info *)); + +static struct demangle_component * +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 demangle_component *)); + +static struct demangle_component * +d_substitution PARAMS ((struct d_info *, int)); + +static void +d_print_resize PARAMS ((struct d_print_info *, size_t)); + +static void +d_print_append_char PARAMS ((struct d_print_info *, int)); + +static void +d_print_append_buffer PARAMS ((struct d_print_info *, const char *, size_t)); + +static void +d_print_error PARAMS ((struct d_print_info *)); + +static void +d_print_comp PARAMS ((struct d_print_info *, + const struct demangle_component *)); + +static void +d_print_java_identifier PARAMS ((struct d_print_info *, const char *, int)); + +static void +d_print_mod_list PARAMS ((struct d_print_info *, struct d_print_mod *, int)); + +static void +d_print_mod PARAMS ((struct d_print_info *, + const struct demangle_component *)); + +static void +d_print_function_type PARAMS ((struct d_print_info *, + const struct demangle_component *, + struct d_print_mod *)); + +static void +d_print_array_type PARAMS ((struct d_print_info *, + const struct demangle_component *, + struct d_print_mod *)); + +static void +d_print_expr_op PARAMS ((struct d_print_info *, + const struct demangle_component *)); + +static void +d_print_cast PARAMS ((struct d_print_info *, + const struct demangle_component *)); + +static char * +d_demangle PARAMS ((const char *, int, size_t *)); #ifdef CP_DEMANGLE_DEBUG static void d_dump (dc, indent) - struct d_comp *dc; + struct demangle_component *dc; int indent; { int i; @@ -587,159 +478,159 @@ d_dump (dc, indent) switch (dc->type) { - case D_COMP_NAME: + case DEMANGLE_COMPONENT_NAME: printf ("name '%.*s'\n", dc->u.s_name.len, dc->u.s_name.s); return; - case D_COMP_TEMPLATE_PARAM: + case DEMANGLE_COMPONENT_TEMPLATE_PARAM: printf ("template parameter %ld\n", dc->u.s_number.number); return; - case D_COMP_CTOR: + case DEMANGLE_COMPONENT_CTOR: printf ("constructor %d\n", (int) dc->u.s_ctor.kind); d_dump (dc->u.s_ctor.name, indent + 2); return; - case D_COMP_DTOR: + case DEMANGLE_COMPONENT_DTOR: printf ("destructor %d\n", (int) dc->u.s_dtor.kind); d_dump (dc->u.s_dtor.name, indent + 2); return; - case D_COMP_SUB_STD: + case DEMANGLE_COMPONENT_SUB_STD: printf ("standard substitution %s\n", dc->u.s_string.string); return; - case D_COMP_BUILTIN_TYPE: + case DEMANGLE_COMPONENT_BUILTIN_TYPE: printf ("builtin type %s\n", dc->u.s_builtin.type->name); return; - case D_COMP_OPERATOR: + case DEMANGLE_COMPONENT_OPERATOR: printf ("operator %s\n", dc->u.s_operator.op->name); return; - case D_COMP_EXTENDED_OPERATOR: + case DEMANGLE_COMPONENT_EXTENDED_OPERATOR: printf ("extended operator with %d args\n", dc->u.s_extended_operator.args); d_dump (dc->u.s_extended_operator.name, indent + 2); return; - case D_COMP_QUAL_NAME: + case DEMANGLE_COMPONENT_QUAL_NAME: printf ("qualified name\n"); break; - case D_COMP_LOCAL_NAME: + case DEMANGLE_COMPONENT_LOCAL_NAME: printf ("local name\n"); break; - case D_COMP_TYPED_NAME: + case DEMANGLE_COMPONENT_TYPED_NAME: printf ("typed name\n"); break; - case D_COMP_TEMPLATE: + case DEMANGLE_COMPONENT_TEMPLATE: printf ("template\n"); break; - case D_COMP_VTABLE: + case DEMANGLE_COMPONENT_VTABLE: printf ("vtable\n"); break; - case D_COMP_VTT: + case DEMANGLE_COMPONENT_VTT: printf ("VTT\n"); break; - case D_COMP_CONSTRUCTION_VTABLE: + case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE: printf ("construction vtable\n"); break; - case D_COMP_TYPEINFO: + case DEMANGLE_COMPONENT_TYPEINFO: printf ("typeinfo\n"); break; - case D_COMP_TYPEINFO_NAME: + case DEMANGLE_COMPONENT_TYPEINFO_NAME: printf ("typeinfo name\n"); break; - case D_COMP_TYPEINFO_FN: + case DEMANGLE_COMPONENT_TYPEINFO_FN: printf ("typeinfo function\n"); break; - case D_COMP_THUNK: + case DEMANGLE_COMPONENT_THUNK: printf ("thunk\n"); break; - case D_COMP_VIRTUAL_THUNK: + case DEMANGLE_COMPONENT_VIRTUAL_THUNK: printf ("virtual thunk\n"); break; - case D_COMP_COVARIANT_THUNK: + case DEMANGLE_COMPONENT_COVARIANT_THUNK: printf ("covariant thunk\n"); break; - case D_COMP_JAVA_CLASS: + case DEMANGLE_COMPONENT_JAVA_CLASS: printf ("java class\n"); break; - case D_COMP_GUARD: + case DEMANGLE_COMPONENT_GUARD: printf ("guard\n"); break; - case D_COMP_REFTEMP: + case DEMANGLE_COMPONENT_REFTEMP: printf ("reference temporary\n"); break; - case D_COMP_RESTRICT: + case DEMANGLE_COMPONENT_RESTRICT: printf ("restrict\n"); break; - case D_COMP_VOLATILE: + case DEMANGLE_COMPONENT_VOLATILE: printf ("volatile\n"); break; - case D_COMP_CONST: + case DEMANGLE_COMPONENT_CONST: printf ("const\n"); break; - case D_COMP_RESTRICT_THIS: + case DEMANGLE_COMPONENT_RESTRICT_THIS: printf ("restrict this\n"); break; - case D_COMP_VOLATILE_THIS: + case DEMANGLE_COMPONENT_VOLATILE_THIS: printf ("volatile this\n"); break; - case D_COMP_CONST_THIS: + case DEMANGLE_COMPONENT_CONST_THIS: printf ("const this\n"); break; - case D_COMP_VENDOR_TYPE_QUAL: + case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL: printf ("vendor type qualifier\n"); break; - case D_COMP_POINTER: + case DEMANGLE_COMPONENT_POINTER: printf ("pointer\n"); break; - case D_COMP_REFERENCE: + case DEMANGLE_COMPONENT_REFERENCE: printf ("reference\n"); break; - case D_COMP_COMPLEX: + case DEMANGLE_COMPONENT_COMPLEX: printf ("complex\n"); break; - case D_COMP_IMAGINARY: + case DEMANGLE_COMPONENT_IMAGINARY: printf ("imaginary\n"); break; - case D_COMP_VENDOR_TYPE: + case DEMANGLE_COMPONENT_VENDOR_TYPE: printf ("vendor type\n"); break; - case D_COMP_FUNCTION_TYPE: + case DEMANGLE_COMPONENT_FUNCTION_TYPE: printf ("function type\n"); break; - case D_COMP_ARRAY_TYPE: + case DEMANGLE_COMPONENT_ARRAY_TYPE: printf ("array type\n"); break; - case D_COMP_PTRMEM_TYPE: + case DEMANGLE_COMPONENT_PTRMEM_TYPE: printf ("pointer to member type\n"); break; - case D_COMP_ARGLIST: + case DEMANGLE_COMPONENT_ARGLIST: printf ("argument list\n"); break; - case D_COMP_TEMPLATE_ARGLIST: + case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST: printf ("template argument list\n"); break; - case D_COMP_CAST: + case DEMANGLE_COMPONENT_CAST: printf ("cast\n"); break; - case D_COMP_UNARY: + case DEMANGLE_COMPONENT_UNARY: printf ("unary operator\n"); break; - case D_COMP_BINARY: + case DEMANGLE_COMPONENT_BINARY: printf ("binary operator\n"); break; - case D_COMP_BINARY_ARGS: + case DEMANGLE_COMPONENT_BINARY_ARGS: printf ("binary operator arguments\n"); break; - case D_COMP_TRINARY: + case DEMANGLE_COMPONENT_TRINARY: printf ("trinary operator\n"); break; - case D_COMP_TRINARY_ARG1: + case DEMANGLE_COMPONENT_TRINARY_ARG1: printf ("trinary operator arguments 1\n"); break; - case D_COMP_TRINARY_ARG2: + case DEMANGLE_COMPONENT_TRINARY_ARG2: printf ("trinary operator arguments 1\n"); break; - case D_COMP_LITERAL: + case DEMANGLE_COMPONENT_LITERAL: printf ("literal\n"); break; - case D_COMP_LITERAL_NEG: + case DEMANGLE_COMPONENT_LITERAL_NEG: printf ("negative literal\n"); break; } @@ -750,33 +641,105 @@ d_dump (dc, indent) #endif /* CP_DEMANGLE_DEBUG */ +/* Fill in a DEMANGLE_COMPONENT_NAME. */ + +CP_STATIC_IF_GLIBCPP_V3 +int +cplus_demangle_fill_name (p, s, len) + struct demangle_component *p; + const char *s; + int len; +{ + if (p == NULL || s == NULL || len == 0) + return 0; + p->type = DEMANGLE_COMPONENT_NAME; + p->u.s_name.s = s; + p->u.s_name.len = len; + return 1; +} + +/* Fill in a DEMANGLE_COMPONENT_EXTENDED_OPERATOR. */ + +CP_STATIC_IF_GLIBCPP_V3 +int +cplus_demangle_fill_extended_operator (p, args, name) + struct demangle_component *p; + int args; + struct demangle_component *name; +{ + if (p == NULL || args < 0 || name == NULL) + return 0; + p->type = DEMANGLE_COMPONENT_EXTENDED_OPERATOR; + p->u.s_extended_operator.args = args; + p->u.s_extended_operator.name = name; + return 1; +} + +/* Fill in a DEMANGLE_COMPONENT_CTOR. */ + +CP_STATIC_IF_GLIBCPP_V3 +int +cplus_demangle_fill_ctor (p, kind, name) + struct demangle_component *p; + enum gnu_v3_ctor_kinds kind; + struct demangle_component *name; +{ + if (p == NULL + || name == NULL + || (kind < gnu_v3_complete_object_ctor + && kind > gnu_v3_complete_object_allocating_ctor)) + return 0; + p->type = DEMANGLE_COMPONENT_CTOR; + p->u.s_ctor.kind = kind; + p->u.s_ctor.name = name; + return 1; +} + +/* Fill in a DEMANGLE_COMPONENT_DTOR. */ + +CP_STATIC_IF_GLIBCPP_V3 +int +cplus_demangle_fill_dtor (p, kind, name) + struct demangle_component *p; + enum gnu_v3_dtor_kinds kind; + struct demangle_component *name; +{ + if (p == NULL + || name == NULL + || (kind < gnu_v3_deleting_dtor + && kind > gnu_v3_base_object_dtor)) + return 0; + p->type = DEMANGLE_COMPONENT_DTOR; + p->u.s_dtor.kind = kind; + p->u.s_dtor.name = name; + return 1; +} + /* Add a new component. */ -static struct d_comp * -d_make_empty (di, type) +static struct demangle_component * +d_make_empty (di) struct d_info *di; - enum d_comp_type type; { - struct d_comp *p; + struct demangle_component *p; if (di->next_comp >= di->num_comps) return NULL; p = &di->comps[di->next_comp]; - p->type = type; ++di->next_comp; return p; } /* Add a new generic component. */ -static struct d_comp * +static struct demangle_component * d_make_comp (di, type, left, right) struct d_info *di; - enum d_comp_type type; - struct d_comp *left; - struct d_comp *right; + enum demangle_component_type type; + struct demangle_component *left; + struct demangle_component *right; { - struct d_comp *p; + struct demangle_component *p; /* We check for errors here. A typical error would be a NULL return from a subroutine. We catch those here, and return NULL @@ -784,65 +747,65 @@ d_make_comp (di, type, left, right) switch (type) { /* These types require two parameters. */ - case D_COMP_QUAL_NAME: - case D_COMP_LOCAL_NAME: - case D_COMP_TYPED_NAME: - case D_COMP_TEMPLATE: - case D_COMP_VENDOR_TYPE_QUAL: - case D_COMP_PTRMEM_TYPE: - case D_COMP_UNARY: - case D_COMP_BINARY: - case D_COMP_BINARY_ARGS: - case D_COMP_TRINARY: - case D_COMP_TRINARY_ARG1: - case D_COMP_TRINARY_ARG2: - case D_COMP_LITERAL: - case D_COMP_LITERAL_NEG: + case DEMANGLE_COMPONENT_QUAL_NAME: + case DEMANGLE_COMPONENT_LOCAL_NAME: + case DEMANGLE_COMPONENT_TYPED_NAME: + case DEMANGLE_COMPONENT_TEMPLATE: + case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL: + case DEMANGLE_COMPONENT_PTRMEM_TYPE: + case DEMANGLE_COMPONENT_UNARY: + case DEMANGLE_COMPONENT_BINARY: + case DEMANGLE_COMPONENT_BINARY_ARGS: + case DEMANGLE_COMPONENT_TRINARY: + case DEMANGLE_COMPONENT_TRINARY_ARG1: + case DEMANGLE_COMPONENT_TRINARY_ARG2: + case DEMANGLE_COMPONENT_LITERAL: + case DEMANGLE_COMPONENT_LITERAL_NEG: if (left == NULL || right == NULL) return NULL; break; /* These types only require one parameter. */ - case D_COMP_VTABLE: - case D_COMP_VTT: - case D_COMP_CONSTRUCTION_VTABLE: - case D_COMP_TYPEINFO: - case D_COMP_TYPEINFO_NAME: - case D_COMP_TYPEINFO_FN: - case D_COMP_THUNK: - case D_COMP_VIRTUAL_THUNK: - case D_COMP_COVARIANT_THUNK: - case D_COMP_JAVA_CLASS: - case D_COMP_GUARD: - case D_COMP_REFTEMP: - case D_COMP_POINTER: - case D_COMP_REFERENCE: - case D_COMP_COMPLEX: - case D_COMP_IMAGINARY: - case D_COMP_VENDOR_TYPE: - case D_COMP_ARGLIST: - case D_COMP_TEMPLATE_ARGLIST: - case D_COMP_CAST: + case DEMANGLE_COMPONENT_VTABLE: + case DEMANGLE_COMPONENT_VTT: + case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE: + case DEMANGLE_COMPONENT_TYPEINFO: + case DEMANGLE_COMPONENT_TYPEINFO_NAME: + case DEMANGLE_COMPONENT_TYPEINFO_FN: + case DEMANGLE_COMPONENT_THUNK: + case DEMANGLE_COMPONENT_VIRTUAL_THUNK: + case DEMANGLE_COMPONENT_COVARIANT_THUNK: + case DEMANGLE_COMPONENT_JAVA_CLASS: + case DEMANGLE_COMPONENT_GUARD: + case DEMANGLE_COMPONENT_REFTEMP: + case DEMANGLE_COMPONENT_POINTER: + case DEMANGLE_COMPONENT_REFERENCE: + case DEMANGLE_COMPONENT_COMPLEX: + case DEMANGLE_COMPONENT_IMAGINARY: + case DEMANGLE_COMPONENT_VENDOR_TYPE: + case DEMANGLE_COMPONENT_ARGLIST: + case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST: + case DEMANGLE_COMPONENT_CAST: if (left == NULL) return NULL; break; /* This needs a right parameter, but the left parameter can be empty. */ - case D_COMP_ARRAY_TYPE: + case DEMANGLE_COMPONENT_ARRAY_TYPE: if (right == NULL) return NULL; break; /* These are allowed to have no parameters--in some cases they will be filled in later. */ - case D_COMP_FUNCTION_TYPE: - case D_COMP_RESTRICT: - case D_COMP_VOLATILE: - case D_COMP_CONST: - case D_COMP_RESTRICT_THIS: - case D_COMP_VOLATILE_THIS: - case D_COMP_CONST_THIS: + case DEMANGLE_COMPONENT_FUNCTION_TYPE: + case DEMANGLE_COMPONENT_RESTRICT: + case DEMANGLE_COMPONENT_VOLATILE: + case DEMANGLE_COMPONENT_CONST: + case DEMANGLE_COMPONENT_RESTRICT_THIS: + case DEMANGLE_COMPONENT_VOLATILE_THIS: + case DEMANGLE_COMPONENT_CONST_THIS: break; /* Other types should not be seen here. */ @@ -850,9 +813,10 @@ d_make_comp (di, type, left, right) return NULL; } - p = d_make_empty (di, type); + p = d_make_empty (di); if (p != NULL) { + p->type = type; p->u.s_binary.left = left; p->u.s_binary.right = right; } @@ -861,148 +825,138 @@ d_make_comp (di, type, left, right) /* Add a new name component. */ -static struct d_comp * +static struct demangle_component * d_make_name (di, s, len) struct d_info *di; const char *s; int len; { - struct d_comp *p; + struct demangle_component *p; - if (s == NULL || len == 0) + p = d_make_empty (di); + if (! cplus_demangle_fill_name (p, s, len)) return NULL; - p = d_make_empty (di, D_COMP_NAME); - if (p != NULL) - { - p->u.s_name.s = s; - p->u.s_name.len = len; - } return p; } /* Add a new builtin type component. */ -static struct d_comp * +static struct demangle_component * d_make_builtin_type (di, type) struct d_info *di; - const struct d_builtin_type_info *type; + const struct demangle_builtin_type_info *type; { - struct d_comp *p; + struct demangle_component *p; if (type == NULL) return NULL; - p = d_make_empty (di, D_COMP_BUILTIN_TYPE); + p = d_make_empty (di); if (p != NULL) - p->u.s_builtin.type = type; + { + p->type = DEMANGLE_COMPONENT_BUILTIN_TYPE; + p->u.s_builtin.type = type; + } return p; } /* Add a new operator component. */ -static struct d_comp * +static struct demangle_component * d_make_operator (di, op) struct d_info *di; - const struct d_operator_info *op; + const struct demangle_operator_info *op; { - struct d_comp *p; + struct demangle_component *p; - p = d_make_empty (di, D_COMP_OPERATOR); + p = d_make_empty (di); if (p != NULL) - p->u.s_operator.op = op; + { + p->type = DEMANGLE_COMPONENT_OPERATOR; + p->u.s_operator.op = op; + } return p; } /* Add a new extended operator component. */ -static struct d_comp * +static struct demangle_component * d_make_extended_operator (di, args, name) struct d_info *di; int args; - struct d_comp *name; + struct demangle_component *name; { - struct d_comp *p; + struct demangle_component *p; - if (name == NULL) + p = d_make_empty (di); + if (! cplus_demangle_fill_extended_operator (p, args, name)) return NULL; - p = d_make_empty (di, D_COMP_EXTENDED_OPERATOR); - if (p != NULL) - { - p->u.s_extended_operator.args = args; - p->u.s_extended_operator.name = name; - } return p; } /* Add a new constructor component. */ -static struct d_comp * +static struct demangle_component * d_make_ctor (di, kind, name) struct d_info *di; enum gnu_v3_ctor_kinds kind; - struct d_comp *name; + struct demangle_component *name; { - struct d_comp *p; + struct demangle_component *p; - if (name == NULL) + p = d_make_empty (di); + if (! cplus_demangle_fill_ctor (p, kind, name)) return NULL; - p = d_make_empty (di, D_COMP_CTOR); - if (p != NULL) - { - p->u.s_ctor.kind = kind; - p->u.s_ctor.name = name; - } return p; } /* Add a new destructor component. */ -static struct d_comp * +static struct demangle_component * d_make_dtor (di, kind, name) struct d_info *di; enum gnu_v3_dtor_kinds kind; - struct d_comp *name; + struct demangle_component *name; { - struct d_comp *p; + struct demangle_component *p; - if (name == NULL) + p = d_make_empty (di); + if (! cplus_demangle_fill_dtor (p, kind, name)) return NULL; - p = d_make_empty (di, D_COMP_DTOR); - if (p != NULL) - { - p->u.s_dtor.kind = kind; - p->u.s_dtor.name = name; - } return p; } /* Add a new template parameter. */ -static struct d_comp * +static struct demangle_component * d_make_template_param (di, i) struct d_info *di; long i; { - struct d_comp *p; + struct demangle_component *p; - p = d_make_empty (di, D_COMP_TEMPLATE_PARAM); + p = d_make_empty (di); if (p != NULL) - p->u.s_number.number = i; + { + p->type = DEMANGLE_COMPONENT_TEMPLATE_PARAM; + p->u.s_number.number = i; + } return p; } /* Add a new standard substitution component. */ -static struct d_comp * +static struct demangle_component * d_make_sub (di, name, len) struct d_info *di; const char *name; int len; { - struct d_comp *p; + struct demangle_component *p; - p = d_make_empty (di, D_COMP_SUB_STD); + p = d_make_empty (di); if (p != NULL) { + p->type = DEMANGLE_COMPONENT_SUB_STD; p->u.s_string.string = name; p->u.s_string.len = len; } @@ -1013,8 +967,9 @@ d_make_sub (di, name, len) TOP_LEVEL is non-zero when called at the top level. */ -static struct d_comp * -d_mangled_name (di, top_level) +CP_STATIC_IF_GLIBCPP_V3 +struct demangle_component * +cplus_demangle_mangled_name (di, top_level) struct d_info *di; int top_level; { @@ -1036,7 +991,7 @@ d_mangled_name (di, top_level) static int has_return_type (dc) - struct d_comp *dc; + struct demangle_component *dc; { if (dc == NULL) return 0; @@ -1044,11 +999,11 @@ has_return_type (dc) { default: return 0; - case D_COMP_TEMPLATE: + case DEMANGLE_COMPONENT_TEMPLATE: return ! is_ctor_dtor_or_conversion (d_left (dc)); - case D_COMP_RESTRICT_THIS: - case D_COMP_VOLATILE_THIS: - case D_COMP_CONST_THIS: + case DEMANGLE_COMPONENT_RESTRICT_THIS: + case DEMANGLE_COMPONENT_VOLATILE_THIS: + case DEMANGLE_COMPONENT_CONST_THIS: return has_return_type (d_left (dc)); } } @@ -1058,7 +1013,7 @@ has_return_type (dc) static int is_ctor_dtor_or_conversion (dc) - struct d_comp *dc; + struct demangle_component *dc; { if (dc == NULL) return 0; @@ -1066,12 +1021,12 @@ is_ctor_dtor_or_conversion (dc) { default: return 0; - case D_COMP_QUAL_NAME: - case D_COMP_LOCAL_NAME: + case DEMANGLE_COMPONENT_QUAL_NAME: + case DEMANGLE_COMPONENT_LOCAL_NAME: return is_ctor_dtor_or_conversion (d_right (dc)); - case D_COMP_CTOR: - case D_COMP_DTOR: - case D_COMP_CAST: + case DEMANGLE_COMPONENT_CTOR: + case DEMANGLE_COMPONENT_DTOR: + case DEMANGLE_COMPONENT_CAST: return 1; } } @@ -1085,7 +1040,7 @@ is_ctor_dtor_or_conversion (dc) parameters. We only set this at the top level, because otherwise we would not correctly demangle names in local scopes. */ -static struct d_comp * +static struct demangle_component * d_encoding (di, top_level) struct d_info *di; int top_level; @@ -1096,7 +1051,7 @@ d_encoding (di, top_level) return d_special_name (di); else { - struct d_comp *dc; + struct demangle_component *dc; dc = d_name (di); @@ -1105,23 +1060,23 @@ d_encoding (di, top_level) /* Strip off any initial CV-qualifiers, as they really apply to the `this' parameter, and they were not output by the v2 demangler without DMGL_PARAMS. */ - while (dc->type == D_COMP_RESTRICT_THIS - || dc->type == D_COMP_VOLATILE_THIS - || dc->type == D_COMP_CONST_THIS) + while (dc->type == DEMANGLE_COMPONENT_RESTRICT_THIS + || dc->type == DEMANGLE_COMPONENT_VOLATILE_THIS + || dc->type == DEMANGLE_COMPONENT_CONST_THIS) dc = d_left (dc); - /* If the top level is a D_COMP_LOCAL_NAME, then there may - be CV-qualifiers on its right argument which really apply - here; this happens when parsing a class which is local to - a function. */ - if (dc->type == D_COMP_LOCAL_NAME) + /* If the top level is a DEMANGLE_COMPONENT_LOCAL_NAME, then + there may be CV-qualifiers on its right argument which + really apply here; this happens when parsing a class + which is local to a function. */ + if (dc->type == DEMANGLE_COMPONENT_LOCAL_NAME) { - struct d_comp *dcr; + struct demangle_component *dcr; dcr = d_right (dc); - while (dcr->type == D_COMP_RESTRICT_THIS - || dcr->type == D_COMP_VOLATILE_THIS - || dcr->type == D_COMP_CONST_THIS) + while (dcr->type == DEMANGLE_COMPONENT_RESTRICT_THIS + || dcr->type == DEMANGLE_COMPONENT_VOLATILE_THIS + || dcr->type == DEMANGLE_COMPONENT_CONST_THIS) dcr = d_left (dcr); dc->u.s_binary.right = dcr; } @@ -1132,7 +1087,7 @@ d_encoding (di, top_level) peek = d_peek_char (di); if (peek == '\0' || peek == 'E') return dc; - return d_make_comp (di, D_COMP_TYPED_NAME, dc, + return d_make_comp (di, DEMANGLE_COMPONENT_TYPED_NAME, dc, d_bare_function_type (di, has_return_type (dc))); } } @@ -1149,12 +1104,12 @@ d_encoding (di, top_level) ::= */ -static struct d_comp * +static struct demangle_component * d_name (di) struct d_info *di; { char peek = d_peek_char (di); - struct d_comp *dc; + struct demangle_component *dc; switch (peek) { @@ -1176,7 +1131,8 @@ d_name (di) else { d_advance (di, 2); - dc = d_make_comp (di, D_COMP_QUAL_NAME, d_make_name (di, "std", 3), + dc = d_make_comp (di, DEMANGLE_COMPONENT_QUAL_NAME, + d_make_name (di, "std", 3), d_unqualified_name (di)); di->expansion += 3; subst = 0; @@ -1199,7 +1155,8 @@ d_name (di) if (! d_add_substitution (di, dc)) return NULL; } - dc = d_make_comp (di, D_COMP_TEMPLATE, dc, d_template_args (di)); + dc = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, dc, + d_template_args (di)); } return dc; @@ -1214,7 +1171,8 @@ d_name (di) candidate. */ if (! d_add_substitution (di, dc)) return NULL; - dc = d_make_comp (di, D_COMP_TEMPLATE, dc, d_template_args (di)); + dc = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, dc, + d_template_args (di)); } return dc; } @@ -1224,12 +1182,12 @@ d_name (di) ::= N [] E */ -static struct d_comp * +static struct demangle_component * d_nested_name (di) struct d_info *di; { - struct d_comp *ret; - struct d_comp **pret; + struct demangle_component *ret; + struct demangle_component **pret; if (d_next_char (di) != 'N') return NULL; @@ -1259,17 +1217,17 @@ d_nested_name (di) ::= */ -static struct d_comp * +static struct demangle_component * d_prefix (di) struct d_info *di; { - struct d_comp *ret = NULL; + struct demangle_component *ret = NULL; while (1) { char peek; - enum d_comp_type comb_type; - struct d_comp *dc; + enum demangle_component_type comb_type; + struct demangle_component *dc; peek = d_peek_char (di); if (peek == '\0') @@ -1279,7 +1237,7 @@ d_prefix (di) that in the grammar. The older code does not accept a here. */ - comb_type = D_COMP_QUAL_NAME; + comb_type = DEMANGLE_COMPONENT_QUAL_NAME; if (IS_DIGIT (peek) || IS_LOWER (peek) || peek == 'C' @@ -1291,7 +1249,7 @@ d_prefix (di) { if (ret == NULL) return NULL; - comb_type = D_COMP_TEMPLATE; + comb_type = DEMANGLE_COMPONENT_TEMPLATE; dc = d_template_args (di); } else if (peek == 'T') @@ -1319,7 +1277,7 @@ d_prefix (di) ::= */ -static struct d_comp * +static struct demangle_component * d_unqualified_name (di) struct d_info *di; { @@ -1330,10 +1288,10 @@ d_unqualified_name (di) return d_source_name (di); else if (IS_LOWER (peek)) { - struct d_comp *ret; + struct demangle_component *ret; ret = d_operator_name (di); - if (ret != NULL && ret->type == D_COMP_OPERATOR) + if (ret != NULL && ret->type == DEMANGLE_COMPONENT_OPERATOR) di->expansion += sizeof "operator" + ret->u.s_operator.op->len - 2; return ret; } @@ -1345,12 +1303,12 @@ d_unqualified_name (di) /* ::= <(positive length) number> */ -static struct d_comp * +static struct demangle_component * d_source_name (di) struct d_info *di; { long len; - struct d_comp *ret; + struct demangle_component *ret; len = d_number (di); if (len <= 0) @@ -1396,7 +1354,7 @@ d_number (di) /* identifier ::= <(unqualified source code identifier)> */ -static struct d_comp * +static struct demangle_component * d_identifier (di, len) struct d_info *di; int len; @@ -1446,7 +1404,8 @@ d_identifier (di, len) #define NL(s) s, (sizeof s) - 1 -static const struct d_operator_info d_operators[] = +CP_STATIC_IF_GLIBCPP_V3 +const struct demangle_operator_info cplus_demangle_operators[] = { { "aN", NL ("&="), 2 }, { "aS", NL ("="), 2 }, @@ -1496,10 +1455,11 @@ static const struct d_operator_info d_operators[] = { "rm", NL ("%"), 2 }, { "rs", NL (">>"), 2 }, { "st", NL ("sizeof "), 1 }, - { "sz", NL ("sizeof "), 1 } + { "sz", NL ("sizeof "), 1 }, + { NULL, NULL, 0, 0 } }; -static struct d_comp * +static struct demangle_component * d_operator_name (di) struct d_info *di; { @@ -1511,19 +1471,25 @@ d_operator_name (di) if (c1 == 'v' && IS_DIGIT (c2)) return d_make_extended_operator (di, c2 - '0', d_source_name (di)); else if (c1 == 'c' && c2 == 'v') - return d_make_comp (di, D_COMP_CAST, d_type (di), NULL); + return d_make_comp (di, DEMANGLE_COMPONENT_CAST, + cplus_demangle_type (di), NULL); else { + /* LOW is the inclusive lower bound. */ int low = 0; - int high = sizeof (d_operators) / sizeof (d_operators[0]); + /* HIGH is the exclusive upper bound. We subtract one to ignore + the sentinel at the end of the array. */ + int high = ((sizeof (cplus_demangle_operators) + / sizeof (cplus_demangle_operators[0])) + - 1); while (1) { int i; - const struct d_operator_info *p; + const struct demangle_operator_info *p; i = low + (high - low) / 2; - p = d_operators + i; + p = cplus_demangle_operators + i; if (c1 == p->code[0] && c2 == p->code[1]) return d_make_operator (di, p); @@ -1552,7 +1518,7 @@ d_operator_name (di) ::= GR */ -static struct d_comp * +static struct demangle_component * d_special_name (di) struct d_info *di; { @@ -1566,58 +1532,65 @@ d_special_name (di) { case 'V': di->expansion -= 5; - return d_make_comp (di, D_COMP_VTABLE, d_type (di), NULL); + return d_make_comp (di, DEMANGLE_COMPONENT_VTABLE, + cplus_demangle_type (di), NULL); case 'T': di->expansion -= 10; - return d_make_comp (di, D_COMP_VTT, d_type (di), NULL); + return d_make_comp (di, DEMANGLE_COMPONENT_VTT, + cplus_demangle_type (di), NULL); case 'I': - return d_make_comp (di, D_COMP_TYPEINFO, d_type (di), NULL); + return d_make_comp (di, DEMANGLE_COMPONENT_TYPEINFO, + cplus_demangle_type (di), NULL); case 'S': - return d_make_comp (di, D_COMP_TYPEINFO_NAME, d_type (di), NULL); + return d_make_comp (di, DEMANGLE_COMPONENT_TYPEINFO_NAME, + cplus_demangle_type (di), NULL); case 'h': if (! d_call_offset (di, 'h')) return NULL; - return d_make_comp (di, D_COMP_THUNK, d_encoding (di, 0), NULL); + return d_make_comp (di, DEMANGLE_COMPONENT_THUNK, + d_encoding (di, 0), NULL); case 'v': if (! d_call_offset (di, 'v')) return NULL; - return d_make_comp (di, D_COMP_VIRTUAL_THUNK, d_encoding (di, 0), - NULL); + return d_make_comp (di, DEMANGLE_COMPONENT_VIRTUAL_THUNK, + d_encoding (di, 0), NULL); case 'c': if (! d_call_offset (di, '\0')) return NULL; if (! d_call_offset (di, '\0')) return NULL; - return d_make_comp (di, D_COMP_COVARIANT_THUNK, d_encoding (di, 0), - NULL); + return d_make_comp (di, DEMANGLE_COMPONENT_COVARIANT_THUNK, + d_encoding (di, 0), NULL); case 'C': { - struct d_comp *derived_type; + struct demangle_component *derived_type; long offset; - struct d_comp *base_type; + struct demangle_component *base_type; - derived_type = d_type (di); + derived_type = cplus_demangle_type (di); offset = d_number (di); if (offset < 0) return NULL; if (d_next_char (di) != '_') return NULL; - base_type = d_type (di); + base_type = cplus_demangle_type (di); /* We don't display the offset. FIXME: We should display it in verbose mode. */ di->expansion += 5; - return d_make_comp (di, D_COMP_CONSTRUCTION_VTABLE, base_type, - derived_type); + return d_make_comp (di, DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE, + base_type, derived_type); } case 'F': - return d_make_comp (di, D_COMP_TYPEINFO_FN, d_type (di), NULL); + return d_make_comp (di, DEMANGLE_COMPONENT_TYPEINFO_FN, + cplus_demangle_type (di), NULL); case 'J': - return d_make_comp (di, D_COMP_JAVA_CLASS, d_type (di), NULL); + return d_make_comp (di, DEMANGLE_COMPONENT_JAVA_CLASS, + cplus_demangle_type (di), NULL); default: return NULL; @@ -1628,10 +1601,11 @@ d_special_name (di) switch (d_next_char (di)) { case 'V': - return d_make_comp (di, D_COMP_GUARD, d_name (di), NULL); + return d_make_comp (di, DEMANGLE_COMPONENT_GUARD, d_name (di), NULL); case 'R': - return d_make_comp (di, D_COMP_REFTEMP, d_name (di), NULL); + return d_make_comp (di, DEMANGLE_COMPONENT_REFTEMP, d_name (di), + NULL); default: return NULL; @@ -1691,15 +1665,15 @@ d_call_offset (di, c) ::= D2 */ -static struct d_comp * +static struct demangle_component * d_ctor_dtor_name (di) struct d_info *di; { if (di->last_name != NULL) { - if (di->last_name->type == D_COMP_NAME) + if (di->last_name->type == DEMANGLE_COMPONENT_NAME) di->expansion += di->last_name->u.s_name.len; - else if (di->last_name->type == D_COMP_SUB_STD) + else if (di->last_name->type == DEMANGLE_COMPONENT_SUB_STD) di->expansion += di->last_name->u.s_string.len; } switch (d_next_char (di)) @@ -1770,7 +1744,9 @@ d_ctor_dtor_name (di) ::= u */ -static const struct d_builtin_type_info d_builtin_types[26] = +CP_STATIC_IF_GLIBCPP_V3 +const struct demangle_builtin_type_info +cplus_demangle_builtin_types[D_BUILTIN_TYPE_COUNT] = { /* a */ { NL ("signed char"), NL ("signed char"), D_PRINT_INT }, /* b */ { NL ("bool"), NL ("boolean"), D_PRINT_BOOL }, @@ -1800,12 +1776,13 @@ static const struct d_builtin_type_info d_builtin_types[26] = /* z */ { NL ("..."), NL ("..."), D_PRINT_DEFAULT }, }; -static struct d_comp * -d_type (di) +CP_STATIC_IF_GLIBCPP_V3 +struct demangle_component * +cplus_demangle_type (di) struct d_info *di; { char peek; - struct d_comp *ret; + struct demangle_component *ret; int can_subst; /* The ABI specifies that when CV-qualifiers are used, the base type @@ -1826,12 +1803,12 @@ d_type (di) peek = d_peek_char (di); if (peek == 'r' || peek == 'V' || peek == 'K') { - struct d_comp **pret; + struct demangle_component **pret; pret = d_cv_qualifiers (di, &ret, 0); if (pret == NULL) return NULL; - *pret = d_type (di); + *pret = cplus_demangle_type (di); if (! d_add_substitution (di, ret)) return NULL; return ret; @@ -1845,7 +1822,8 @@ d_type (di) case 'h': case 'i': case 'j': case 'l': case 'm': case 'n': case 'o': case 's': case 't': case 'v': case 'w': case 'x': case 'y': case 'z': - ret = d_make_builtin_type (di, &d_builtin_types[peek - 'a']); + ret = d_make_builtin_type (di, + &cplus_demangle_builtin_types[peek - 'a']); di->expansion += ret->u.s_builtin.type->len; can_subst = 0; d_advance (di, 1); @@ -1853,7 +1831,8 @@ d_type (di) case 'u': d_advance (di, 1); - ret = d_make_comp (di, D_COMP_VENDOR_TYPE, d_source_name (di), NULL); + ret = d_make_comp (di, DEMANGLE_COMPONENT_VENDOR_TYPE, + d_source_name (di), NULL); break; case 'F': @@ -1884,7 +1863,8 @@ d_type (di) candidate. */ if (! d_add_substitution (di, ret)) return NULL; - ret = d_make_comp (di, D_COMP_TEMPLATE, ret, d_template_args (di)); + ret = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, ret, + d_template_args (di)); } break; @@ -1903,7 +1883,7 @@ d_type (di) /* The substituted name may have been a template name and may be followed by tepmlate args. */ if (d_peek_char (di) == 'I') - ret = d_make_comp (di, D_COMP_TEMPLATE, ret, + ret = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, ret, d_template_args (di)); else can_subst = 0; @@ -1915,7 +1895,7 @@ d_type (di) a new substitution candidate. However, if the substitution was followed by template arguments, then the whole thing is a substitution candidate. */ - if (ret != NULL && ret->type == D_COMP_SUB_STD) + if (ret != NULL && ret->type == DEMANGLE_COMPONENT_SUB_STD) can_subst = 0; } } @@ -1923,28 +1903,33 @@ d_type (di) case 'P': d_advance (di, 1); - ret = d_make_comp (di, D_COMP_POINTER, d_type (di), NULL); + ret = d_make_comp (di, DEMANGLE_COMPONENT_POINTER, + cplus_demangle_type (di), NULL); break; case 'R': d_advance (di, 1); - ret = d_make_comp (di, D_COMP_REFERENCE, d_type (di), NULL); + ret = d_make_comp (di, DEMANGLE_COMPONENT_REFERENCE, + cplus_demangle_type (di), NULL); break; case 'C': d_advance (di, 1); - ret = d_make_comp (di, D_COMP_COMPLEX, d_type (di), NULL); + ret = d_make_comp (di, DEMANGLE_COMPONENT_COMPLEX, + cplus_demangle_type (di), NULL); break; case 'G': d_advance (di, 1); - ret = d_make_comp (di, D_COMP_IMAGINARY, d_type (di), NULL); + ret = d_make_comp (di, DEMANGLE_COMPONENT_IMAGINARY, + cplus_demangle_type (di), NULL); break; case 'U': d_advance (di, 1); ret = d_source_name (di); - ret = d_make_comp (di, D_COMP_VENDOR_TYPE_QUAL, d_type (di), ret); + ret = d_make_comp (di, DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL, + cplus_demangle_type (di), ret); break; default: @@ -1962,10 +1947,10 @@ d_type (di) /* ::= [r] [V] [K] */ -static struct d_comp ** +static struct demangle_component ** d_cv_qualifiers (di, pret, member_fn) struct d_info *di; - struct d_comp **pret; + struct demangle_component **pret; int member_fn; { char peek; @@ -1973,22 +1958,28 @@ d_cv_qualifiers (di, pret, member_fn) peek = d_peek_char (di); while (peek == 'r' || peek == 'V' || peek == 'K') { - enum d_comp_type t; + enum demangle_component_type t; d_advance (di, 1); if (peek == 'r') { - t = member_fn ? D_COMP_RESTRICT_THIS : D_COMP_RESTRICT; + t = (member_fn + ? DEMANGLE_COMPONENT_RESTRICT_THIS + : DEMANGLE_COMPONENT_RESTRICT); di->expansion += sizeof "restrict"; } else if (peek == 'V') { - t = member_fn ? D_COMP_VOLATILE_THIS : D_COMP_VOLATILE; + t = (member_fn + ? DEMANGLE_COMPONENT_VOLATILE_THIS + : DEMANGLE_COMPONENT_VOLATILE); di->expansion += sizeof "volatile"; } else { - t = member_fn ? D_COMP_CONST_THIS : D_COMP_CONST; + t = (member_fn + ? DEMANGLE_COMPONENT_CONST_THIS + : DEMANGLE_COMPONENT_CONST); di->expansion += sizeof "const"; } @@ -2005,11 +1996,11 @@ d_cv_qualifiers (di, pret, member_fn) /* ::= F [Y] E */ -static struct d_comp * +static struct demangle_component * d_function_type (di) struct d_info *di; { - struct d_comp *ret; + struct demangle_component *ret; if (d_next_char (di) != 'F') return NULL; @@ -2027,14 +2018,14 @@ d_function_type (di) /* ::= + */ -static struct d_comp * +static struct demangle_component * 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; + struct demangle_component *return_type; + struct demangle_component *tl; + struct demangle_component **ptl; return_type = NULL; tl = NULL; @@ -2042,12 +2033,12 @@ d_bare_function_type (di, has_return_type) while (1) { char peek; - struct d_comp *type; + struct demangle_component *type; peek = d_peek_char (di); if (peek == '\0' || peek == 'E') break; - type = d_type (di); + type = cplus_demangle_type (di); if (type == NULL) return NULL; if (has_return_type) @@ -2057,7 +2048,7 @@ d_bare_function_type (di, has_return_type) } else { - *ptl = d_make_comp (di, D_COMP_ARGLIST, type, NULL); + *ptl = d_make_comp (di, DEMANGLE_COMPONENT_ARGLIST, type, NULL); if (*ptl == NULL) return NULL; ptl = &d_right (*ptl); @@ -2072,19 +2063,19 @@ d_bare_function_type (di, has_return_type) /* If we have a single parameter type void, omit it. */ if (d_right (tl) == NULL - && d_left (tl)->type == D_COMP_BUILTIN_TYPE + && d_left (tl)->type == DEMANGLE_COMPONENT_BUILTIN_TYPE && d_left (tl)->u.s_builtin.type->print == D_PRINT_VOID) { di->expansion -= d_left (tl)->u.s_builtin.type->len; tl = NULL; } - return d_make_comp (di, D_COMP_FUNCTION_TYPE, return_type, tl); + return d_make_comp (di, DEMANGLE_COMPONENT_FUNCTION_TYPE, return_type, tl); } /* ::= */ -static struct d_comp * +static struct demangle_component * d_class_enum_type (di) struct d_info *di; { @@ -2095,12 +2086,12 @@ d_class_enum_type (di) ::= A [<(dimension) expression>] _ <(element) type> */ -static struct d_comp * +static struct demangle_component * d_array_type (di) struct d_info *di; { char peek; - struct d_comp *dim; + struct demangle_component *dim; if (d_next_char (di) != 'A') return NULL; @@ -2133,23 +2124,24 @@ d_array_type (di) if (d_next_char (di) != '_') return NULL; - return d_make_comp (di, D_COMP_ARRAY_TYPE, dim, d_type (di)); + return d_make_comp (di, DEMANGLE_COMPONENT_ARRAY_TYPE, dim, + cplus_demangle_type (di)); } /* ::= M <(class) type> <(member) type> */ -static struct d_comp * +static struct demangle_component * d_pointer_to_member_type (di) struct d_info *di; { - struct d_comp *cl; - struct d_comp *mem; - struct d_comp **pmem; + struct demangle_component *cl; + struct demangle_component *mem; + struct demangle_component **pmem; if (d_next_char (di) != 'M') return NULL; - cl = d_type (di); + cl = cplus_demangle_type (di); /* The ABI specifies that any type can be a substitution source, and that M is followed by two types, and that when a CV-qualified @@ -2162,21 +2154,21 @@ d_pointer_to_member_type (di) g++ does not work that way. g++ treats only the CV-qualified member function as a substitution source. FIXME. So to work with g++, we need to pull off the CV-qualifiers here, in order to - avoid calling add_substitution() in d_type(). */ + avoid calling add_substitution() in cplus_demangle_type(). */ pmem = d_cv_qualifiers (di, &mem, 1); if (pmem == NULL) return NULL; - *pmem = d_type (di); + *pmem = cplus_demangle_type (di); - return d_make_comp (di, D_COMP_PTRMEM_TYPE, cl, mem); + return d_make_comp (di, DEMANGLE_COMPONENT_PTRMEM_TYPE, cl, mem); } /* ::= T_ ::= T <(parameter-2 non-negative) number> _ */ -static struct d_comp * +static struct demangle_component * d_template_param (di) struct d_info *di; { @@ -2205,13 +2197,13 @@ d_template_param (di) /* ::= I + E */ -static struct d_comp * +static struct demangle_component * d_template_args (di) struct d_info *di; { - struct d_comp *hold_last_name; - struct d_comp *al; - struct d_comp **pal; + struct demangle_component *hold_last_name; + struct demangle_component *al; + struct demangle_component **pal; /* Preserve the last name we saw--don't let the template arguments clobber it, as that would give us the wrong name for a subsequent @@ -2225,13 +2217,13 @@ d_template_args (di) pal = &al; while (1) { - struct d_comp *a; + struct demangle_component *a; a = d_template_arg (di); if (a == NULL) return NULL; - *pal = d_make_comp (di, D_COMP_TEMPLATE_ARGLIST, a, NULL); + *pal = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE_ARGLIST, a, NULL); if (*pal == NULL) return NULL; pal = &d_right (*pal); @@ -2253,11 +2245,11 @@ d_template_args (di) ::= */ -static struct d_comp * +static struct demangle_component * d_template_arg (di) struct d_info *di; { - struct d_comp *ret; + struct demangle_component *ret; switch (d_peek_char (di)) { @@ -2272,7 +2264,7 @@ d_template_arg (di) return d_expr_primary (di); default: - return d_type (di); + return cplus_demangle_type (di); } } @@ -2286,7 +2278,7 @@ d_template_arg (di) ::= */ -static struct d_comp * +static struct demangle_component * d_expression (di) struct d_info *di; { @@ -2299,46 +2291,47 @@ d_expression (di) return d_template_param (di); else if (peek == 's' && d_peek_next_char (di) == 'r') { - struct d_comp *type; - struct d_comp *name; + struct demangle_component *type; + struct demangle_component *name; d_advance (di, 2); - type = d_type (di); + type = cplus_demangle_type (di); name = d_unqualified_name (di); if (d_peek_char (di) != 'I') - return d_make_comp (di, D_COMP_QUAL_NAME, type, name); + return d_make_comp (di, DEMANGLE_COMPONENT_QUAL_NAME, type, name); else - return d_make_comp (di, D_COMP_QUAL_NAME, type, - d_make_comp (di, D_COMP_TEMPLATE, name, + return d_make_comp (di, DEMANGLE_COMPONENT_QUAL_NAME, type, + d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, name, d_template_args (di))); } else { - struct d_comp *op; + struct demangle_component *op; int args; op = d_operator_name (di); if (op == NULL) return NULL; - if (op->type == D_COMP_OPERATOR) + if (op->type == DEMANGLE_COMPONENT_OPERATOR) di->expansion += op->u.s_operator.op->len - 2; - if (op->type == D_COMP_OPERATOR + if (op->type == DEMANGLE_COMPONENT_OPERATOR && strcmp (op->u.s_operator.op->code, "st") == 0) - return d_make_comp (di, D_COMP_UNARY, op, d_type (di)); + return d_make_comp (di, DEMANGLE_COMPONENT_UNARY, op, + cplus_demangle_type (di)); switch (op->type) { default: return NULL; - case D_COMP_OPERATOR: + case DEMANGLE_COMPONENT_OPERATOR: args = op->u.s_operator.op->args; break; - case D_COMP_EXTENDED_OPERATOR: + case DEMANGLE_COMPONENT_EXTENDED_OPERATOR: args = op->u.s_extended_operator.args; break; - case D_COMP_CAST: + case DEMANGLE_COMPONENT_CAST: args = 1; break; } @@ -2346,27 +2339,32 @@ d_expression (di) switch (args) { case 1: - return d_make_comp (di, D_COMP_UNARY, op, d_expression (di)); + return d_make_comp (di, DEMANGLE_COMPONENT_UNARY, op, + d_expression (di)); case 2: { - struct d_comp *left; + struct demangle_component *left; left = d_expression (di); - return d_make_comp (di, D_COMP_BINARY, op, - d_make_comp (di, D_COMP_BINARY_ARGS, left, + return d_make_comp (di, DEMANGLE_COMPONENT_BINARY, op, + d_make_comp (di, + DEMANGLE_COMPONENT_BINARY_ARGS, + left, d_expression (di))); } case 3: { - struct d_comp *first; - struct d_comp *second; + struct demangle_component *first; + struct demangle_component *second; first = d_expression (di); second = d_expression (di); - return d_make_comp (di, D_COMP_TRINARY, op, - d_make_comp (di, D_COMP_TRINARY_ARG1, first, + return d_make_comp (di, DEMANGLE_COMPONENT_TRINARY, op, + d_make_comp (di, + DEMANGLE_COMPONENT_TRINARY_ARG1, + first, d_make_comp (di, - D_COMP_TRINARY_ARG2, + DEMANGLE_COMPONENT_TRINARY_ARG2, second, d_expression (di)))); } @@ -2381,27 +2379,27 @@ d_expression (di) ::= L E */ -static struct d_comp * +static struct demangle_component * d_expr_primary (di) struct d_info *di; { - struct d_comp *ret; + struct demangle_component *ret; if (d_next_char (di) != 'L') return NULL; if (d_peek_char (di) == '_') - ret = d_mangled_name (di, 0); + ret = cplus_demangle_mangled_name (di, 0); else { - struct d_comp *type; - enum d_comp_type t; + struct demangle_component *type; + enum demangle_component_type t; const char *s; - type = d_type (di); + type = cplus_demangle_type (di); /* If we have a type we know how to print, we aren't going to print the type name itself. */ - if (type->type == D_COMP_BUILTIN_TYPE + if (type->type == DEMANGLE_COMPONENT_BUILTIN_TYPE && type->u.s_builtin.type->print != D_PRINT_DEFAULT) di->expansion -= type->u.s_builtin.type->len; @@ -2416,10 +2414,10 @@ d_expr_primary (di) constant in any readable form anyhow. We don't attempt to handle these cases. */ - t = D_COMP_LITERAL; + t = DEMANGLE_COMPONENT_LITERAL; if (d_peek_char (di) == 'n') { - t = D_COMP_LITERAL_NEG; + t = DEMANGLE_COMPONENT_LITERAL_NEG; d_advance (di, 1); } s = d_str (di); @@ -2436,11 +2434,11 @@ d_expr_primary (di) ::= Z <(function) encoding> E s [] */ -static struct d_comp * +static struct demangle_component * d_local_name (di) struct d_info *di; { - struct d_comp *function; + struct demangle_component *function; if (d_next_char (di) != 'Z') return NULL; @@ -2455,18 +2453,18 @@ d_local_name (di) d_advance (di, 1); if (! d_discriminator (di)) return NULL; - return d_make_comp (di, D_COMP_LOCAL_NAME, function, + return d_make_comp (di, DEMANGLE_COMPONENT_LOCAL_NAME, function, d_make_name (di, "string literal", sizeof "string literal" - 1)); } else { - struct d_comp *name; + struct demangle_component *name; name = d_name (di); if (! d_discriminator (di)) return NULL; - return d_make_comp (di, D_COMP_LOCAL_NAME, function, name); + return d_make_comp (di, DEMANGLE_COMPONENT_LOCAL_NAME, function, name); } } @@ -2495,7 +2493,7 @@ d_discriminator (di) static int d_add_substitution (di, dc) struct d_info *di; - struct d_comp *dc; + struct demangle_component *dc; { if (dc == NULL) return 0; @@ -2550,7 +2548,7 @@ static const struct d_standard_sub_info standard_subs[] = NL ("basic_iostream") } }; -static struct d_comp * +static struct demangle_component * d_substitution (di, prefix) struct d_info *di; int prefix; @@ -2729,10 +2727,11 @@ d_print_error (dpi) sets *PALC to 0 for a bad parse, or to 1 for a memory allocation failure. */ -static char * -d_print (options, dc, estimate, palc) +CP_STATIC_IF_GLIBCPP_V3 +char * +cplus_demangle_print (options, dc, estimate, palc) int options; - const struct d_comp *dc; + const struct demangle_component *dc; int estimate; size_t *palc; { @@ -2771,7 +2770,7 @@ d_print (options, dc, estimate, palc) static void d_print_comp (dpi, dc) struct d_print_info *dpi; - const struct d_comp *dc; + const struct demangle_component *dc; { if (dc == NULL) { @@ -2783,15 +2782,15 @@ d_print_comp (dpi, dc) switch (dc->type) { - case D_COMP_NAME: + case DEMANGLE_COMPONENT_NAME: if ((dpi->options & DMGL_JAVA) == 0) d_append_buffer (dpi, dc->u.s_name.s, dc->u.s_name.len); else d_print_java_identifier (dpi, dc->u.s_name.s, dc->u.s_name.len); return; - case D_COMP_QUAL_NAME: - case D_COMP_LOCAL_NAME: + case DEMANGLE_COMPONENT_QUAL_NAME: + case DEMANGLE_COMPONENT_LOCAL_NAME: d_print_comp (dpi, d_left (dc)); if ((dpi->options & DMGL_JAVA) == 0) d_append_string_constant (dpi, "::"); @@ -2800,10 +2799,10 @@ d_print_comp (dpi, dc) d_print_comp (dpi, d_right (dc)); return; - case D_COMP_TYPED_NAME: + case DEMANGLE_COMPONENT_TYPED_NAME: { struct d_print_mod *hold_modifiers; - struct d_comp *typed_name; + struct demangle_component *typed_name; struct d_print_mod adpm[4]; unsigned int i; struct d_print_template dpt; @@ -2829,9 +2828,9 @@ d_print_comp (dpi, dc) adpm[i].templates = dpi->templates; ++i; - if (typed_name->type != D_COMP_RESTRICT_THIS - && typed_name->type != D_COMP_VOLATILE_THIS - && typed_name->type != D_COMP_CONST_THIS) + if (typed_name->type != DEMANGLE_COMPONENT_RESTRICT_THIS + && typed_name->type != DEMANGLE_COMPONENT_VOLATILE_THIS + && typed_name->type != DEMANGLE_COMPONENT_CONST_THIS) break; typed_name = d_left (typed_name); @@ -2839,25 +2838,25 @@ d_print_comp (dpi, dc) /* If typed_name is a template, then it applies to the function type as well. */ - if (typed_name->type == D_COMP_TEMPLATE) + if (typed_name->type == DEMANGLE_COMPONENT_TEMPLATE) { dpt.next = dpi->templates; dpi->templates = &dpt; dpt.template = typed_name; } - /* If typed_name is a D_COMP_LOCAL_NAME, then there may be - CV-qualifiers on its right argument which really apply - here; this happens when parsing a class which is local to a - function. */ - if (typed_name->type == D_COMP_LOCAL_NAME) + /* If typed_name is a DEMANGLE_COMPONENT_LOCAL_NAME, then + there may be CV-qualifiers on its right argument which + really apply here; this happens when parsing a class which + is local to a function. */ + if (typed_name->type == DEMANGLE_COMPONENT_LOCAL_NAME) { - struct d_comp *local_name; + struct demangle_component *local_name; local_name = d_right (typed_name); - while (local_name->type == D_COMP_RESTRICT_THIS - || local_name->type == D_COMP_VOLATILE_THIS - || local_name->type == D_COMP_CONST_THIS) + while (local_name->type == DEMANGLE_COMPONENT_RESTRICT_THIS + || local_name->type == DEMANGLE_COMPONENT_VOLATILE_THIS + || local_name->type == DEMANGLE_COMPONENT_CONST_THIS) { if (i >= sizeof adpm / sizeof adpm[0]) { @@ -2880,7 +2879,7 @@ d_print_comp (dpi, dc) d_print_comp (dpi, d_right (dc)); - if (typed_name->type == D_COMP_TEMPLATE) + if (typed_name->type == DEMANGLE_COMPONENT_TEMPLATE) dpi->templates = dpt.next; /* If the modifiers didn't get printed by the type, print them @@ -2900,7 +2899,7 @@ d_print_comp (dpi, dc) return; } - case D_COMP_TEMPLATE: + case DEMANGLE_COMPONENT_TEMPLATE: { struct d_print_mod *hold_dpm; @@ -2927,10 +2926,10 @@ d_print_comp (dpi, dc) return; } - case D_COMP_TEMPLATE_PARAM: + case DEMANGLE_COMPONENT_TEMPLATE_PARAM: { long i; - struct d_comp *a; + struct demangle_component *a; struct d_print_template *hold_dpt; if (dpi->templates == NULL) @@ -2943,7 +2942,7 @@ d_print_comp (dpi, dc) a != NULL; a = d_right (a)) { - if (a->type != D_COMP_TEMPLATE_ARGLIST) + if (a->type != DEMANGLE_COMPONENT_TEMPLATE_ARGLIST) { d_print_error (dpi); return; @@ -2973,92 +2972,92 @@ d_print_comp (dpi, dc) return; } - case D_COMP_CTOR: + case DEMANGLE_COMPONENT_CTOR: d_print_comp (dpi, dc->u.s_ctor.name); return; - case D_COMP_DTOR: + case DEMANGLE_COMPONENT_DTOR: d_append_char (dpi, '~'); d_print_comp (dpi, dc->u.s_dtor.name); return; - case D_COMP_VTABLE: + case DEMANGLE_COMPONENT_VTABLE: d_append_string_constant (dpi, "vtable for "); d_print_comp (dpi, d_left (dc)); return; - case D_COMP_VTT: + case DEMANGLE_COMPONENT_VTT: d_append_string_constant (dpi, "VTT for "); d_print_comp (dpi, d_left (dc)); return; - case D_COMP_CONSTRUCTION_VTABLE: + case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE: d_append_string_constant (dpi, "construction vtable for "); d_print_comp (dpi, d_left (dc)); d_append_string_constant (dpi, "-in-"); d_print_comp (dpi, d_right (dc)); return; - case D_COMP_TYPEINFO: + case DEMANGLE_COMPONENT_TYPEINFO: d_append_string_constant (dpi, "typeinfo for "); d_print_comp (dpi, d_left (dc)); return; - case D_COMP_TYPEINFO_NAME: + case DEMANGLE_COMPONENT_TYPEINFO_NAME: d_append_string_constant (dpi, "typeinfo name for "); d_print_comp (dpi, d_left (dc)); return; - case D_COMP_TYPEINFO_FN: + case DEMANGLE_COMPONENT_TYPEINFO_FN: d_append_string_constant (dpi, "typeinfo fn for "); d_print_comp (dpi, d_left (dc)); return; - case D_COMP_THUNK: + case DEMANGLE_COMPONENT_THUNK: d_append_string_constant (dpi, "non-virtual thunk to "); d_print_comp (dpi, d_left (dc)); return; - case D_COMP_VIRTUAL_THUNK: + case DEMANGLE_COMPONENT_VIRTUAL_THUNK: d_append_string_constant (dpi, "virtual thunk to "); d_print_comp (dpi, d_left (dc)); return; - case D_COMP_COVARIANT_THUNK: + case DEMANGLE_COMPONENT_COVARIANT_THUNK: d_append_string_constant (dpi, "covariant return thunk to "); d_print_comp (dpi, d_left (dc)); return; - case D_COMP_JAVA_CLASS: + case DEMANGLE_COMPONENT_JAVA_CLASS: d_append_string_constant (dpi, "java Class for "); d_print_comp (dpi, d_left (dc)); return; - case D_COMP_GUARD: + case DEMANGLE_COMPONENT_GUARD: d_append_string_constant (dpi, "guard variable for "); d_print_comp (dpi, d_left (dc)); return; - case D_COMP_REFTEMP: + case DEMANGLE_COMPONENT_REFTEMP: d_append_string_constant (dpi, "reference temporary for "); d_print_comp (dpi, d_left (dc)); return; - case D_COMP_SUB_STD: + case DEMANGLE_COMPONENT_SUB_STD: d_append_buffer (dpi, dc->u.s_string.string, dc->u.s_string.len); return; - case D_COMP_RESTRICT: - case D_COMP_VOLATILE: - case D_COMP_CONST: - case D_COMP_RESTRICT_THIS: - case D_COMP_VOLATILE_THIS: - case D_COMP_CONST_THIS: - case D_COMP_VENDOR_TYPE_QUAL: - case D_COMP_POINTER: - case D_COMP_REFERENCE: - case D_COMP_COMPLEX: - case D_COMP_IMAGINARY: + case DEMANGLE_COMPONENT_RESTRICT: + case DEMANGLE_COMPONENT_VOLATILE: + case DEMANGLE_COMPONENT_CONST: + case DEMANGLE_COMPONENT_RESTRICT_THIS: + case DEMANGLE_COMPONENT_VOLATILE_THIS: + case DEMANGLE_COMPONENT_CONST_THIS: + case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL: + case DEMANGLE_COMPONENT_POINTER: + case DEMANGLE_COMPONENT_REFERENCE: + case DEMANGLE_COMPONENT_COMPLEX: + case DEMANGLE_COMPONENT_IMAGINARY: { /* We keep a list of modifiers on the stack. */ struct d_print_mod dpm; @@ -3081,7 +3080,7 @@ d_print_comp (dpi, dc) return; } - case D_COMP_BUILTIN_TYPE: + case DEMANGLE_COMPONENT_BUILTIN_TYPE: if ((dpi->options & DMGL_JAVA) == 0) d_append_buffer (dpi, dc->u.s_builtin.type->name, dc->u.s_builtin.type->len); @@ -3090,11 +3089,11 @@ d_print_comp (dpi, dc) dc->u.s_builtin.type->java_len); return; - case D_COMP_VENDOR_TYPE: + case DEMANGLE_COMPONENT_VENDOR_TYPE: d_print_comp (dpi, d_left (dc)); return; - case D_COMP_FUNCTION_TYPE: + case DEMANGLE_COMPONENT_FUNCTION_TYPE: { if (d_left (dc) != NULL) { @@ -3124,7 +3123,7 @@ d_print_comp (dpi, dc) return; } - case D_COMP_ARRAY_TYPE: + case DEMANGLE_COMPONENT_ARRAY_TYPE: { struct d_print_mod dpm; @@ -3149,7 +3148,7 @@ d_print_comp (dpi, dc) return; } - case D_COMP_PTRMEM_TYPE: + case DEMANGLE_COMPONENT_PTRMEM_TYPE: { struct d_print_mod dpm; @@ -3175,8 +3174,8 @@ d_print_comp (dpi, dc) return; } - case D_COMP_ARGLIST: - case D_COMP_TEMPLATE_ARGLIST: + case DEMANGLE_COMPONENT_ARGLIST: + case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST: d_print_comp (dpi, d_left (dc)); if (d_right (dc) != NULL) { @@ -3185,7 +3184,7 @@ d_print_comp (dpi, dc) } return; - case D_COMP_OPERATOR: + case DEMANGLE_COMPONENT_OPERATOR: { char c; @@ -3198,18 +3197,18 @@ d_print_comp (dpi, dc) return; } - case D_COMP_EXTENDED_OPERATOR: + case DEMANGLE_COMPONENT_EXTENDED_OPERATOR: d_append_string_constant (dpi, "operator "); d_print_comp (dpi, dc->u.s_extended_operator.name); return; - case D_COMP_CAST: + case DEMANGLE_COMPONENT_CAST: d_append_string_constant (dpi, "operator "); d_print_cast (dpi, dc); return; - case D_COMP_UNARY: - if (d_left (dc)->type != D_COMP_CAST) + case DEMANGLE_COMPONENT_UNARY: + if (d_left (dc)->type != DEMANGLE_COMPONENT_CAST) d_print_expr_op (dpi, d_left (dc)); else { @@ -3220,12 +3219,12 @@ d_print_comp (dpi, dc) d_append_char (dpi, '('); d_print_comp (dpi, d_right (dc)); d_append_char (dpi, ')'); - if (d_left (dc)->type == D_COMP_CAST) + if (d_left (dc)->type == DEMANGLE_COMPONENT_CAST) d_append_char (dpi, ')'); return; - case D_COMP_BINARY: - if (d_right (dc)->type != D_COMP_BINARY_ARGS) + case DEMANGLE_COMPONENT_BINARY: + if (d_right (dc)->type != DEMANGLE_COMPONENT_BINARY_ARGS) { d_print_error (dpi); return; @@ -3234,7 +3233,7 @@ d_print_comp (dpi, dc) /* We wrap an expression which uses the greater-than operator in an extra layer of parens so that it does not get confused with the '>' which ends the template parameters. */ - if (d_left (dc)->type == D_COMP_OPERATOR + if (d_left (dc)->type == DEMANGLE_COMPONENT_OPERATOR && d_left (dc)->u.s_operator.op->len == 1 && d_left (dc)->u.s_operator.op->name[0] == '>') d_append_char (dpi, '('); @@ -3247,21 +3246,21 @@ d_print_comp (dpi, dc) d_print_comp (dpi, d_right (d_right (dc))); d_append_char (dpi, ')'); - if (d_left (dc)->type == D_COMP_OPERATOR + if (d_left (dc)->type == DEMANGLE_COMPONENT_OPERATOR && d_left (dc)->u.s_operator.op->len == 1 && d_left (dc)->u.s_operator.op->name[0] == '>') d_append_char (dpi, ')'); return; - case D_COMP_BINARY_ARGS: - /* We should only see this as part of D_COMP_BINARY. */ + case DEMANGLE_COMPONENT_BINARY_ARGS: + /* We should only see this as part of DEMANGLE_COMPONENT_BINARY. */ d_print_error (dpi); return; - case D_COMP_TRINARY: - if (d_right (dc)->type != D_COMP_TRINARY_ARG1 - || d_right (d_right (dc))->type != D_COMP_TRINARY_ARG2) + case DEMANGLE_COMPONENT_TRINARY: + if (d_right (dc)->type != DEMANGLE_COMPONENT_TRINARY_ARG1 + || d_right (d_right (dc))->type != DEMANGLE_COMPONENT_TRINARY_ARG2) { d_print_error (dpi); return; @@ -3277,23 +3276,23 @@ d_print_comp (dpi, dc) d_append_char (dpi, ')'); return; - case D_COMP_TRINARY_ARG1: - case D_COMP_TRINARY_ARG2: - /* We should only see these are part of D_COMP_TRINARY. */ + case DEMANGLE_COMPONENT_TRINARY_ARG1: + case DEMANGLE_COMPONENT_TRINARY_ARG2: + /* We should only see these are part of DEMANGLE_COMPONENT_TRINARY. */ d_print_error (dpi); return; - case D_COMP_LITERAL: - case D_COMP_LITERAL_NEG: + case DEMANGLE_COMPONENT_LITERAL: + case DEMANGLE_COMPONENT_LITERAL_NEG: /* For some builtin types, produce simpler output. */ - if (d_left (dc)->type == D_COMP_BUILTIN_TYPE) + if (d_left (dc)->type == DEMANGLE_COMPONENT_BUILTIN_TYPE) { switch (d_left (dc)->u.s_builtin.type->print) { case D_PRINT_INT: - if (d_right (dc)->type == D_COMP_NAME) + if (d_right (dc)->type == DEMANGLE_COMPONENT_NAME) { - if (dc->type == D_COMP_LITERAL_NEG) + if (dc->type == DEMANGLE_COMPONENT_LITERAL_NEG) d_append_char (dpi, '-'); d_print_comp (dpi, d_right (dc)); return; @@ -3301,9 +3300,9 @@ d_print_comp (dpi, dc) break; case D_PRINT_LONG: - if (d_right (dc)->type == D_COMP_NAME) + if (d_right (dc)->type == DEMANGLE_COMPONENT_NAME) { - if (dc->type == D_COMP_LITERAL_NEG) + if (dc->type == DEMANGLE_COMPONENT_LITERAL_NEG) d_append_char (dpi, '-'); d_print_comp (dpi, d_right (dc)); d_append_char (dpi, 'l'); @@ -3312,9 +3311,9 @@ d_print_comp (dpi, dc) break; case D_PRINT_BOOL: - if (d_right (dc)->type == D_COMP_NAME + if (d_right (dc)->type == DEMANGLE_COMPONENT_NAME && d_right (dc)->u.s_name.len == 1 - && dc->type == D_COMP_LITERAL) + && dc->type == DEMANGLE_COMPONENT_LITERAL) { switch (d_right (dc)->u.s_name.s[0]) { @@ -3338,7 +3337,7 @@ d_print_comp (dpi, dc) d_append_char (dpi, '('); d_print_comp (dpi, d_left (dc)); d_append_char (dpi, ')'); - if (dc->type == D_COMP_LITERAL_NEG) + if (dc->type == DEMANGLE_COMPONENT_LITERAL_NEG) d_append_char (dpi, '-'); d_print_comp (dpi, d_right (dc)); return; @@ -3420,9 +3419,9 @@ d_print_mod_list (dpi, mods, suffix) if (mods->printed || (! suffix - && (mods->mod->type == D_COMP_RESTRICT_THIS - || mods->mod->type == D_COMP_VOLATILE_THIS - || mods->mod->type == D_COMP_CONST_THIS))) + && (mods->mod->type == DEMANGLE_COMPONENT_RESTRICT_THIS + || mods->mod->type == DEMANGLE_COMPONENT_VOLATILE_THIS + || mods->mod->type == DEMANGLE_COMPONENT_CONST_THIS))) { d_print_mod_list (dpi, mods->next, suffix); return; @@ -3433,22 +3432,22 @@ d_print_mod_list (dpi, mods, suffix) hold_dpt = dpi->templates; dpi->templates = mods->templates; - if (mods->mod->type == D_COMP_FUNCTION_TYPE) + if (mods->mod->type == DEMANGLE_COMPONENT_FUNCTION_TYPE) { d_print_function_type (dpi, mods->mod, mods->next); dpi->templates = hold_dpt; return; } - else if (mods->mod->type == D_COMP_ARRAY_TYPE) + else if (mods->mod->type == DEMANGLE_COMPONENT_ARRAY_TYPE) { d_print_array_type (dpi, mods->mod, mods->next); dpi->templates = hold_dpt; return; } - else if (mods->mod->type == D_COMP_LOCAL_NAME) + else if (mods->mod->type == DEMANGLE_COMPONENT_LOCAL_NAME) { struct d_print_mod *hold_modifiers; - struct d_comp *dc; + struct demangle_component *dc; /* When this is on the modifier stack, we have pulled any qualifiers off the right argument already. Otherwise, we @@ -3466,9 +3465,9 @@ d_print_mod_list (dpi, mods, suffix) d_append_char (dpi, '.'); dc = d_right (mods->mod); - while (dc->type == D_COMP_RESTRICT_THIS - || dc->type == D_COMP_VOLATILE_THIS - || dc->type == D_COMP_CONST_THIS) + while (dc->type == DEMANGLE_COMPONENT_RESTRICT_THIS + || dc->type == DEMANGLE_COMPONENT_VOLATILE_THIS + || dc->type == DEMANGLE_COMPONENT_CONST_THIS) dc = d_left (dc); d_print_comp (dpi, dc); @@ -3489,47 +3488,47 @@ d_print_mod_list (dpi, mods, suffix) static void d_print_mod (dpi, mod) struct d_print_info *dpi; - const struct d_comp *mod; + const struct demangle_component *mod; { switch (mod->type) { - case D_COMP_RESTRICT: - case D_COMP_RESTRICT_THIS: + case DEMANGLE_COMPONENT_RESTRICT: + case DEMANGLE_COMPONENT_RESTRICT_THIS: d_append_string_constant (dpi, " restrict"); return; - case D_COMP_VOLATILE: - case D_COMP_VOLATILE_THIS: + case DEMANGLE_COMPONENT_VOLATILE: + case DEMANGLE_COMPONENT_VOLATILE_THIS: d_append_string_constant (dpi, " volatile"); return; - case D_COMP_CONST: - case D_COMP_CONST_THIS: + case DEMANGLE_COMPONENT_CONST: + case DEMANGLE_COMPONENT_CONST_THIS: d_append_string_constant (dpi, " const"); return; - case D_COMP_VENDOR_TYPE_QUAL: + case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL: d_append_char (dpi, ' '); d_print_comp (dpi, d_right (mod)); return; - case D_COMP_POINTER: + case DEMANGLE_COMPONENT_POINTER: /* There is no pointer symbol in Java. */ if ((dpi->options & DMGL_JAVA) == 0) d_append_char (dpi, '*'); return; - case D_COMP_REFERENCE: + case DEMANGLE_COMPONENT_REFERENCE: d_append_char (dpi, '&'); return; - case D_COMP_COMPLEX: + case DEMANGLE_COMPONENT_COMPLEX: d_append_string_constant (dpi, "complex "); return; - case D_COMP_IMAGINARY: + case DEMANGLE_COMPONENT_IMAGINARY: d_append_string_constant (dpi, "imaginary "); return; - case D_COMP_PTRMEM_TYPE: + case DEMANGLE_COMPONENT_PTRMEM_TYPE: if (d_last_char (dpi) != '(') d_append_char (dpi, ' '); d_print_comp (dpi, d_left (mod)); d_append_string_constant (dpi, "::*"); return; - case D_COMP_TYPED_NAME: + case DEMANGLE_COMPONENT_TYPED_NAME: d_print_comp (dpi, d_left (mod)); return; default: @@ -3545,7 +3544,7 @@ d_print_mod (dpi, mod) static void d_print_function_type (dpi, dc, mods) struct d_print_info *dpi; - const struct d_comp *dc; + const struct demangle_component *dc; struct d_print_mod *mods; { int need_paren; @@ -3563,20 +3562,20 @@ d_print_function_type (dpi, dc, mods) saw_mod = 1; switch (p->mod->type) { - case D_COMP_RESTRICT: - case D_COMP_VOLATILE: - case D_COMP_CONST: - case D_COMP_VENDOR_TYPE_QUAL: - case D_COMP_POINTER: - case D_COMP_REFERENCE: - case D_COMP_COMPLEX: - case D_COMP_IMAGINARY: - case D_COMP_PTRMEM_TYPE: + case DEMANGLE_COMPONENT_RESTRICT: + case DEMANGLE_COMPONENT_VOLATILE: + case DEMANGLE_COMPONENT_CONST: + case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL: + case DEMANGLE_COMPONENT_POINTER: + case DEMANGLE_COMPONENT_REFERENCE: + case DEMANGLE_COMPONENT_COMPLEX: + case DEMANGLE_COMPONENT_IMAGINARY: + case DEMANGLE_COMPONENT_PTRMEM_TYPE: need_paren = 1; break; - case D_COMP_RESTRICT_THIS: - case D_COMP_VOLATILE_THIS: - case D_COMP_CONST_THIS: + case DEMANGLE_COMPONENT_RESTRICT_THIS: + case DEMANGLE_COMPONENT_VOLATILE_THIS: + case DEMANGLE_COMPONENT_CONST_THIS: break; default: break; @@ -3630,7 +3629,7 @@ d_print_function_type (dpi, dc, mods) static void d_print_array_type (dpi, dc, mods) struct d_print_info *dpi; - const struct d_comp *dc; + const struct demangle_component *dc; struct d_print_mod *mods; { int need_space; @@ -3647,7 +3646,7 @@ d_print_array_type (dpi, dc, mods) if (p->printed) break; - if (p->mod->type == D_COMP_ARRAY_TYPE) + if (p->mod->type == DEMANGLE_COMPONENT_ARRAY_TYPE) { need_space = 0; break; @@ -3685,9 +3684,9 @@ d_print_array_type (dpi, dc, mods) static void d_print_expr_op (dpi, dc) struct d_print_info *dpi; - const struct d_comp *dc; + const struct demangle_component *dc; { - if (dc->type == D_COMP_OPERATOR) + if (dc->type == DEMANGLE_COMPONENT_OPERATOR) d_append_buffer (dpi, dc->u.s_operator.op->name, dc->u.s_operator.op->len); else @@ -3699,9 +3698,9 @@ d_print_expr_op (dpi, dc) static void d_print_cast (dpi, dc) struct d_print_info *dpi; - const struct d_comp *dc; + const struct demangle_component *dc; { - if (d_left (dc)->type != D_COMP_TEMPLATE) + if (d_left (dc)->type != DEMANGLE_COMPONENT_TEMPLATE) d_print_comp (dpi, d_left (dc)); else { @@ -3741,8 +3740,9 @@ d_print_cast (dpi, dc) /* Initialize the information structure we use to pass around information. */ -static void -d_init_info (mangled, options, len, di) +CP_STATIC_IF_GLIBCPP_V3 +void +cplus_demangle_init_info (mangled, options, len, di) const char *mangled; int options; size_t len; @@ -3787,7 +3787,7 @@ d_demangle (mangled, options, palc) size_t len; int type; struct d_info di; - struct d_comp *dc; + struct demangle_component *dc; int estimate; char *ret; @@ -3824,20 +3824,20 @@ d_demangle (mangled, options, palc) type = 1; } - d_init_info (mangled, options, len, &di); + cplus_demangle_init_info (mangled, options, len, &di); { #ifdef CP_DYNAMIC_ARRAYS - __extension__ struct d_comp comps[di.num_comps]; - __extension__ struct d_comp *subs[di.num_subs]; + __extension__ struct demangle_component comps[di.num_comps]; + __extension__ struct demangle_component *subs[di.num_subs]; di.comps = &comps[0]; di.subs = &subs[0]; #else - di.comps = (struct d_comp *) malloc (di.num_comps - * sizeof (struct d_comp)); - di.subs = (struct d_comp **) malloc (di.num_subs - * sizeof (struct d_comp *)); + di.comps = ((struct demangle_component *) + malloc (di.num_comps * sizeof (struct demangle_component))); + di.subs = ((struct demangle_component **) + malloc (di.num_subs * sizeof (struct demangle_component *))); if (di.comps == NULL || di.subs == NULL) { if (di.comps != NULL) @@ -3850,9 +3850,9 @@ d_demangle (mangled, options, palc) #endif if (! type) - dc = d_mangled_name (&di, 1); + dc = cplus_demangle_mangled_name (&di, 1); else - dc = d_type (&di); + dc = cplus_demangle_type (&di); /* If DMGL_PARAMS is set, then if we didn't consume the entire mangled string, then we didn't successfully demangle it. If @@ -3875,7 +3875,7 @@ d_demangle (mangled, options, palc) ret = NULL; if (dc != NULL) - ret = d_print (options, dc, estimate, palc); + ret = cplus_demangle_print (options, dc, estimate, palc); #ifndef CP_DYNAMIC_ARRAYS free (di.comps); @@ -4076,26 +4076,26 @@ is_ctor_or_dtor (mangled, ctor_kind, dtor_kind) enum gnu_v3_dtor_kinds *dtor_kind; { struct d_info di; - struct d_comp *dc; + struct demangle_component *dc; int ret; *ctor_kind = (enum gnu_v3_ctor_kinds) 0; *dtor_kind = (enum gnu_v3_dtor_kinds) 0; - d_init_info (mangled, DMGL_GNU_V3, strlen (mangled), &di); + cplus_demangle_init_info (mangled, DMGL_GNU_V3, strlen (mangled), &di); { #ifdef CP_DYNAMIC_ARRAYS - __extension__ struct d_comp comps[di.num_comps]; - __extension__ struct d_comp *subs[di.num_subs]; + __extension__ struct demangle_component comps[di.num_comps]; + __extension__ struct demangle_component *subs[di.num_subs]; di.comps = &comps[0]; di.subs = &subs[0]; #else - di.comps = (struct d_comp *) malloc (di.num_comps - * sizeof (struct d_comp)); - di.subs = (struct d_comp **) malloc (di.num_subs - * sizeof (struct d_comp *)); + di.comps = ((struct demangle_component *) + malloc (di.num_comps * sizeof (struct demangle_component))); + di.subs = ((struct demangle_component **) + malloc (di.num_subs * sizeof (struct demangle_component *))); if (di.comps == NULL || di.subs == NULL) { if (di.comps != NULL) @@ -4106,7 +4106,7 @@ is_ctor_or_dtor (mangled, ctor_kind, dtor_kind) } #endif - dc = d_mangled_name (&di, 1); + dc = cplus_demangle_mangled_name (&di, 1); /* Note that because we did not pass DMGL_PARAMS, we don't expect to demangle the entire string. */ @@ -4119,23 +4119,23 @@ is_ctor_or_dtor (mangled, ctor_kind, dtor_kind) default: dc = NULL; break; - case D_COMP_TYPED_NAME: - case D_COMP_TEMPLATE: - case D_COMP_RESTRICT_THIS: - case D_COMP_VOLATILE_THIS: - case D_COMP_CONST_THIS: + case DEMANGLE_COMPONENT_TYPED_NAME: + case DEMANGLE_COMPONENT_TEMPLATE: + case DEMANGLE_COMPONENT_RESTRICT_THIS: + case DEMANGLE_COMPONENT_VOLATILE_THIS: + case DEMANGLE_COMPONENT_CONST_THIS: dc = d_left (dc); break; - case D_COMP_QUAL_NAME: - case D_COMP_LOCAL_NAME: + case DEMANGLE_COMPONENT_QUAL_NAME: + case DEMANGLE_COMPONENT_LOCAL_NAME: dc = d_right (dc); break; - case D_COMP_CTOR: + case DEMANGLE_COMPONENT_CTOR: *ctor_kind = dc->u.s_ctor.kind; ret = 1; dc = NULL; break; - case D_COMP_DTOR: + case DEMANGLE_COMPONENT_DTOR: *dtor_kind = dc->u.s_dtor.kind; ret = 1; dc = NULL; diff --git a/libiberty/cp-demangle.h b/libiberty/cp-demangle.h new file mode 100644 index 00000000000..d3c57ce3766 --- /dev/null +++ b/libiberty/cp-demangle.h @@ -0,0 +1,139 @@ +/* Internal demangler interface for g++ V3 ABI. + Copyright (C) 2003, 2004 Free Software Foundation, Inc. + Written by Ian Lance Taylor . + + This file is part of the libiberty library, which is part of GCC. + + This file is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + In addition to the permissions in the GNU General Public License, the + Free Software Foundation gives you unlimited permission to link the + compiled version of this file into combinations with other programs, + and to distribute those combinations without any restriction coming + from the use of this file. (The General Public License restrictions + do apply in other respects; for example, they cover modification of + the file, and distribution when not linked into a combined + executable.) + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +*/ + +/* This file provides some definitions shared by cp-demangle.c and + cp-demint.c. It should not be included by any other files. */ + +/* Information we keep for operators. */ + +struct demangle_operator_info +{ + /* Mangled name. */ + const char *code; + /* Real name. */ + const char *name; + /* Length of real name. */ + int len; + /* Number of arguments. */ + int args; +}; + +/* How to print the value of a builtin type. */ + +enum d_builtin_type_print +{ + /* Print as (type)val. */ + D_PRINT_DEFAULT, + /* Print as integer. */ + D_PRINT_INT, + /* Print as long, with trailing `l'. */ + D_PRINT_LONG, + /* Print as bool. */ + D_PRINT_BOOL, + /* Print in usual way, but here to detect void. */ + D_PRINT_VOID +}; + +/* Information we keep for a builtin type. */ + +struct demangle_builtin_type_info +{ + /* Type name. */ + const char *name; + /* Length of type name. */ + int len; + /* Type name when using Java. */ + const char *java_name; + /* Length of java name. */ + int java_len; + /* How to print a value of this type. */ + enum d_builtin_type_print print; +}; + +/* The information structure we pass around. */ + +struct d_info +{ + /* The string we are demangling. */ + const char *s; + /* The end of the string we are demangling. */ + const char *send; + /* The options passed to the demangler. */ + int options; + /* The next character in the string to consider. */ + const char *n; + /* The array of components. */ + struct demangle_component *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 demangle_component **subs; + /* The index of the next substitution. */ + int next_sub; + /* The number of available entries in the subs array. */ + int num_subs; + /* The number of substitutions which we actually made from the subs + array, plus the number of template parameter references we + saw. */ + int did_subs; + /* The last name we saw, for constructors and destructors. */ + struct demangle_component *last_name; + /* A running total of the length of large expansions from the + mangled name to the demangled name, such as standard + substitutions and builtin types. */ + int expansion; +}; + +#define d_peek_char(di) (*((di)->n)) +#define d_peek_next_char(di) ((di)->n[1]) +#define d_advance(di, i) ((di)->n += (i)) +#define d_next_char(di) (*((di)->n++)) +#define d_str(di) ((di)->n) + +/* Functions and arrays in cp-demangle.c which are referenced by + functions in cp-demint.c. */ + +extern const struct demangle_operator_info cplus_demangle_operators[]; + +#define D_BUILTIN_TYPE_COUNT (26) + +extern const struct demangle_builtin_type_info +cplus_demangle_builtin_types[D_BUILTIN_TYPE_COUNT]; + +extern struct demangle_component * +cplus_demangle_mangled_name PARAMS ((struct d_info *, int)); + +extern struct demangle_component * +cplus_demangle_type PARAMS ((struct d_info *)); + +extern void +cplus_demangle_init_info PARAMS ((const char *, int, size_t, struct d_info *)); diff --git a/libiberty/cp-demint.c b/libiberty/cp-demint.c new file mode 100644 index 00000000000..833e89e7a90 --- /dev/null +++ b/libiberty/cp-demint.c @@ -0,0 +1,241 @@ +/* Demangler component interface functions. + Copyright (C) 2004 Free Software Foundation, Inc. + Written by Ian Lance Taylor . + + This file is part of the libiberty library, which is part of GCC. + + This file is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + In addition to the permissions in the GNU General Public License, the + Free Software Foundation gives you unlimited permission to link the + compiled version of this file into combinations with other programs, + and to distribute those combinations without any restriction coming + from the use of this file. (The General Public License restrictions + do apply in other respects; for example, they cover modification of + the file, and distribution when not linked into a combined + executable.) + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +*/ + +/* This file implements a few interface functions which are provided + for use with struct demangle_component trees. These functions are + declared in demangle.h. These functions are closely tied to the + demangler code in cp-demangle.c, and other interface functions can + be found in that file. We put these functions in a separate file + because they are not needed by the demangler, and so we avoid + having them pulled in by programs which only need the + demangler. */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#ifdef HAVE_STDLIB_H +#include +#endif +#ifdef HAVE_STRING_H +#include +#endif + +#include "ansidecl.h" +#include "libiberty.h" +#include "demangle.h" +#include "cp-demangle.h" + +/* Fill in most component types. */ + +int +cplus_demangle_fill_component (p, type, left, right) + struct demangle_component *p; + enum demangle_component_type type; + struct demangle_component *left; + struct demangle_component *right; +{ + if (p == NULL) + return 0; + switch (type) + { + case DEMANGLE_COMPONENT_QUAL_NAME: + case DEMANGLE_COMPONENT_LOCAL_NAME: + case DEMANGLE_COMPONENT_TYPED_NAME: + case DEMANGLE_COMPONENT_TEMPLATE: + case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL: + case DEMANGLE_COMPONENT_FUNCTION_TYPE: + case DEMANGLE_COMPONENT_ARRAY_TYPE: + case DEMANGLE_COMPONENT_PTRMEM_TYPE: + case DEMANGLE_COMPONENT_ARGLIST: + case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST: + case DEMANGLE_COMPONENT_UNARY: + case DEMANGLE_COMPONENT_BINARY: + case DEMANGLE_COMPONENT_BINARY_ARGS: + case DEMANGLE_COMPONENT_TRINARY: + case DEMANGLE_COMPONENT_TRINARY_ARG1: + case DEMANGLE_COMPONENT_TRINARY_ARG2: + case DEMANGLE_COMPONENT_LITERAL: + case DEMANGLE_COMPONENT_LITERAL_NEG: + break; + + /* These component types only have one subtree. */ + case DEMANGLE_COMPONENT_VTABLE: + case DEMANGLE_COMPONENT_VTT: + case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE: + case DEMANGLE_COMPONENT_TYPEINFO: + case DEMANGLE_COMPONENT_TYPEINFO_NAME: + case DEMANGLE_COMPONENT_TYPEINFO_FN: + case DEMANGLE_COMPONENT_THUNK: + case DEMANGLE_COMPONENT_VIRTUAL_THUNK: + case DEMANGLE_COMPONENT_COVARIANT_THUNK: + case DEMANGLE_COMPONENT_JAVA_CLASS: + case DEMANGLE_COMPONENT_GUARD: + case DEMANGLE_COMPONENT_REFTEMP: + case DEMANGLE_COMPONENT_RESTRICT: + case DEMANGLE_COMPONENT_VOLATILE: + case DEMANGLE_COMPONENT_CONST: + case DEMANGLE_COMPONENT_RESTRICT_THIS: + case DEMANGLE_COMPONENT_VOLATILE_THIS: + case DEMANGLE_COMPONENT_CONST_THIS: + case DEMANGLE_COMPONENT_POINTER: + case DEMANGLE_COMPONENT_REFERENCE: + case DEMANGLE_COMPONENT_COMPLEX: + case DEMANGLE_COMPONENT_IMAGINARY: + case DEMANGLE_COMPONENT_VENDOR_TYPE: + case DEMANGLE_COMPONENT_CAST: + if (right != NULL) + return 0; + break; + + default: + /* Other types do not use subtrees. */ + return 0; + } + + p->type = type; + p->u.s_binary.left = left; + p->u.s_binary.right = right; + + return 1; +} + +/* Fill in a DEMANGLE_COMPONENT_BUILTIN_TYPE. */ + +int +cplus_demangle_fill_builtin_type (p, typename) + struct demangle_component *p; + const char *typename; +{ + int len; + unsigned int i; + + if (p == NULL || typename == NULL) + return 0; + len = strlen (typename); + for (i = 0; i < D_BUILTIN_TYPE_COUNT; ++i) + { + if (len == cplus_demangle_builtin_types[i].len + && strcmp (typename, cplus_demangle_builtin_types[i].name) == 0) + { + p->type = DEMANGLE_COMPONENT_BUILTIN_TYPE; + p->u.s_builtin.type = &cplus_demangle_builtin_types[i]; + return 1; + } + } + return 0; +} + +/* Fill in a DEMANGLE_COMPONENT_OPERATOR. */ + +int +cplus_demangle_fill_operator (p, opname, args) + struct demangle_component *p; + const char *opname; + int args; +{ + int len; + unsigned int i; + + if (p == NULL || opname == NULL) + return 0; + len = strlen (opname); + for (i = 0; cplus_demangle_operators[i].name != NULL; ++i) + { + if (len == cplus_demangle_operators[i].len + && args == cplus_demangle_operators[i].args + && strcmp (opname, cplus_demangle_operators[i].name) == 0) + { + p->type = DEMANGLE_COMPONENT_OPERATOR; + p->u.s_operator.op = &cplus_demangle_operators[i]; + return 1; + } + } + return 0; +} + +/* Translate a mangled name into components. */ + +struct demangle_component * +cplus_demangle_v3_components (mangled, options, mem) + const char *mangled; + int options; + void **mem; +{ + size_t len; + int type; + struct d_info di; + struct demangle_component *dc; + + len = strlen (mangled); + + if (mangled[0] == '_' && mangled[1] == 'Z') + type = 0; + else + { + if ((options & DMGL_TYPES) == 0) + return NULL; + type = 1; + } + + cplus_demangle_init_info (mangled, options, len, &di); + + di.comps = ((struct demangle_component *) + malloc (di.num_comps * sizeof (struct demangle_component))); + di.subs = ((struct demangle_component **) + malloc (di.num_subs * sizeof (struct demangle_component *))); + if (di.comps == NULL || di.subs == NULL) + { + if (di.comps != NULL) + free (di.comps); + if (di.subs != NULL) + free (di.subs); + return NULL; + } + + if (! type) + dc = cplus_demangle_mangled_name (&di, 1); + else + dc = cplus_demangle_type (&di); + + /* If DMGL_PARAMS is set, then if we didn't consume the entire + mangled string, then we didn't successfully demangle it. */ + if ((options & DMGL_PARAMS) != 0 && d_peek_char (&di) != '\0') + dc = NULL; + + free (di.subs); + + if (dc != NULL) + *mem = di.comps; + else + free (di.comps); + + return dc; +}