Skip to content

R
riscv-gcc-1
Commit 5e777af5 by Ian Lance Taylor Committed by Ian Lance Taylor
Options

demangle.h (enum demangle_component_type): Define. 

	* 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.

From-SVN: r75748
parent 5c881655
Showing with 1655 additions and 849 deletions
include/ChangeLog
2004-01-12 Ian Lance Taylor <ian@wasabisystems.com>
* 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 <a.tobler@schweiz.ch> 2003-12-19 Andreas Tobler <a.tobler@schweiz.ch>
* include/fibheap.h (fibnode): Use __extension__ for * include/fibheap.h (fibnode): Use __extension__ for
......
include/demangle.h
/* Defs for interface to demanglers. /* Defs for interface to demanglers.
Copyright 1992, 1993, 1994, 1995, 1996, 1997, 1998, 2000, 2001, 2002 Copyright 1992, 1993, 1994, 1995, 1996, 1997, 1998, 2000, 2001, 2002,
Free Software Foundation, Inc. 2003, 2004 Free Software Foundation, Inc.
This program is free software; you can redistribute it and/or modify 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 it under the terms of the GNU General Public License as published by
...@@ -164,6 +164,368 @@ enum gnu_v3_dtor_kinds { ...@@ -164,6 +164,368 @@ enum gnu_v3_dtor_kinds {
extern enum gnu_v3_dtor_kinds extern enum gnu_v3_dtor_kinds
is_gnu_v3_mangled_dtor PARAMS ((const char *name)); 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 #ifdef __cplusplus
} }
#endif /* __cplusplus */ #endif /* __cplusplus */
......
libiberty/ChangeLog
2004-01-12 Ian Lance Taylor <ian@wasabisystems.com>
* 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 <kcook@gcc.gnu.org> 2004-01-09 Kelley Cook <kcook@gcc.gnu.org>
* configure.in: Rename file to ... * configure.in: Rename file to ...
......
libiberty/Makefile.in
# #
# Makefile # Makefile
# Copyright (C) 1990, 91-99, 2000, 2001, 2002, 2003 # Copyright (C) 1990, 91-99, 2000, 2001, 2002, 2003, 2004
# Free Software Foundation # Free Software Foundation
# #
# This file is part of the libiberty library. # This file is part of the libiberty library.
...@@ -130,7 +130,7 @@ COMPILE.c = $(CC) -c @DEFS@ $(LIBCFLAGS) -I. -I$(INCDIR) $(HDEFINES) @ac_libiber ...@@ -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 \ CFILES = alloca.c argv.c asprintf.c atexit.c \
basename.c bcmp.c bcopy.c bsearch.c bzero.c \ basename.c bcmp.c bcopy.c bsearch.c bzero.c \
calloc.c choose-temp.c clock.c concat.c cp-demangle.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 \ dyn-string.c \
fdmatch.c ffs.c fibheap.c floatformat.c fnmatch.c \ fdmatch.c ffs.c fibheap.c floatformat.c fnmatch.c \
getcwd.c getopt.c getopt1.c getpagesize.c getpwd.c getruntime.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 \ ...@@ -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 # These are always included in the library. The first four are listed
# first and by compile time to optimize parallel builds. # 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 \ alloca.o argv.o \
choose-temp.o concat.o \ choose-temp.o concat.o \
dyn-string.o \ dyn-string.o \
...@@ -428,8 +428,11 @@ choose-temp.o: config.h $(INCDIR)/ansidecl.h $(INCDIR)/libiberty.h ...@@ -428,8 +428,11 @@ choose-temp.o: config.h $(INCDIR)/ansidecl.h $(INCDIR)/libiberty.h
clock.o: config.h clock.o: config.h
concat.o: config.h $(INCDIR)/ansidecl.h $(INCDIR)/libiberty.h concat.o: config.h $(INCDIR)/ansidecl.h $(INCDIR)/libiberty.h
copysign.o: $(INCDIR)/ansidecl.h copysign.o: $(INCDIR)/ansidecl.h
cp-demangle.o: config.h $(INCDIR)/ansidecl.h $(INCDIR)/demangle.h \ cp-demangle.o: config.h $(INCDIR)/ansidecl.h $(srcdir)/cp-demangle.h \
$(INCDIR)/dyn-string.h $(INCDIR)/getopt.h $(INCDIR)/libiberty.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 \ cplus-dem.o: config.h $(INCDIR)/ansidecl.h $(INCDIR)/demangle.h \
$(INCDIR)/libiberty.h $(INCDIR)/safe-ctype.h $(INCDIR)/libiberty.h $(INCDIR)/safe-ctype.h
dyn-string.o: config.h $(INCDIR)/ansidecl.h $(INCDIR)/dyn-string.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 \ ...@@ -450,8 +453,8 @@ hashtab.o: config.h $(INCDIR)/ansidecl.h $(INCDIR)/hashtab.h \
$(INCDIR)/libiberty.h $(INCDIR)/libiberty.h
hex.o: $(INCDIR)/ansidecl.h $(INCDIR)/libiberty.h \ hex.o: $(INCDIR)/ansidecl.h $(INCDIR)/libiberty.h \
$(INCDIR)/safe-ctype.h $(INCDIR)/safe-ctype.h
lbasename.o: $(INCDIR)/ansidecl.h $(INCDIR)/libiberty.h \ lbasename.o: $(INCDIR)/ansidecl.h $(INCDIR)/filenames.h \
$(INCDIR)/safe-ctype.h $(INCDIR)/filenames.h $(INCDIR)/libiberty.h $(INCDIR)/safe-ctype.h
lrealpath.o: config.h $(INCDIR)/ansidecl.h $(INCDIR)/libiberty.h lrealpath.o: config.h $(INCDIR)/ansidecl.h $(INCDIR)/libiberty.h
make-relative-prefix.o: config.h $(INCDIR)/ansidecl.h \ make-relative-prefix.o: config.h $(INCDIR)/ansidecl.h \
$(INCDIR)/libiberty.h $(INCDIR)/libiberty.h
......
libiberty/cp-demangle.c
...@@ -45,6 +45,22 @@ ...@@ -45,6 +45,22 @@
enum gnu_v3_ctor_kinds is_gnu_v3_mangled_ctor (const char *name) 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) 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: Preprocessor macros you can define while compiling this file:
IN_LIBGCC2 IN_LIBGCC2
...@@ -54,7 +70,8 @@ ...@@ -54,7 +70,8 @@
instead of cplus_demangle_v3() and java_demangle_v3(). instead of cplus_demangle_v3() and java_demangle_v3().
IN_GLIBCPP_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 STANDALONE_DEMANGLER
If defined, this file defines a main() function which demangles If defined, this file defines a main() function which demangles
...@@ -81,6 +98,54 @@ ...@@ -81,6 +98,54 @@
#include "ansidecl.h" #include "ansidecl.h"
#include "libiberty.h" #include "libiberty.h"
#include "demangle.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. */ /* See if the compiler supports dynamic arrays. */
...@@ -115,52 +180,6 @@ ...@@ -115,52 +180,6 @@
#define ANONYMOUS_NAMESPACE_PREFIX_LEN \ #define ANONYMOUS_NAMESPACE_PREFIX_LEN \
(sizeof (ANONYMOUS_NAMESPACE_PREFIX) - 1) (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. */ /* Information we keep for the standard substitutions. */
struct d_standard_sub_info struct d_standard_sub_info
...@@ -184,232 +203,11 @@ struct d_standard_sub_info ...@@ -184,232 +203,11 @@ struct d_standard_sub_info
int set_last_name_len; int set_last_name_len;
}; };
/* Component types found in mangled names. */ /* Accessors for subtrees of struct demangle_component. */
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;
};
#define d_left(dc) ((dc)->u.s_binary.left) #define d_left(dc) ((dc)->u.s_binary.left)
#define d_right(dc) ((dc)->u.s_binary.right) #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. */ /* A list of templates. This is used while printing. */
struct d_print_template struct d_print_template
...@@ -417,7 +215,7 @@ struct d_print_template ...@@ -417,7 +215,7 @@ struct d_print_template
/* Next template on the list. */ /* Next template on the list. */
struct d_print_template *next; struct d_print_template *next;
/* This template. */ /* This template. */
const struct d_comp *template; const struct demangle_component *template;
}; };
/* A list of type modifiers. This is used while printing. */ /* A list of type modifiers. This is used while printing. */
...@@ -428,7 +226,7 @@ struct d_print_mod ...@@ -428,7 +226,7 @@ struct d_print_mod
in which they appeared in the mangled string. */ in which they appeared in the mangled string. */
struct d_print_mod *next; struct d_print_mod *next;
/* The modifier. */ /* The modifier. */
const struct d_comp *mod; const struct demangle_component *mod;
/* Whether this modifier was printed. */ /* Whether this modifier was printed. */
int printed; int printed;
/* The list of templates which applies to this modifier. */ /* The list of templates which applies to this modifier. */
...@@ -488,93 +286,186 @@ struct d_print_info ...@@ -488,93 +286,186 @@ struct d_print_info
((dpi)->buf == NULL || (dpi)->len == 0 ? '\0' : (dpi)->buf[(dpi)->len - 1]) ((dpi)->buf == NULL || (dpi)->len == 0 ? '\0' : (dpi)->buf[(dpi)->len - 1])
#ifdef CP_DEMANGLE_DEBUG #ifdef CP_DEMANGLE_DEBUG
static void d_dump PARAMS ((struct d_comp *, int)); static void
d_dump PARAMS ((struct demangle_component *, int));
#endif #endif
static struct d_comp *d_make_empty PARAMS ((struct d_info *,
enum d_comp_type)); static struct demangle_component *
static struct d_comp *d_make_comp PARAMS ((struct d_info *, enum d_comp_type, d_make_empty PARAMS ((struct d_info *));
struct d_comp *, struct d_comp *));
static struct d_comp *d_make_name PARAMS ((struct d_info *, const char *, static struct demangle_component *
int)); d_make_comp PARAMS ((struct d_info *, enum demangle_component_type,
static struct d_comp *d_make_builtin_type PARAMS ((struct d_info *, struct demangle_component *,
const struct d_builtin_type_info *)); struct demangle_component *));
static struct d_comp *d_make_operator PARAMS ((struct d_info *,
const struct d_operator_info *)); static struct demangle_component *
static struct d_comp *d_make_extended_operator PARAMS ((struct d_info *, d_make_name PARAMS ((struct d_info *, const char *, int));
int,
struct d_comp *)); static struct demangle_component *
static struct d_comp *d_make_ctor PARAMS ((struct d_info *, d_make_builtin_type PARAMS ((struct d_info *,
enum gnu_v3_ctor_kinds, const struct demangle_builtin_type_info *));
struct d_comp *));
static struct d_comp *d_make_dtor PARAMS ((struct d_info *, static struct demangle_component *
enum gnu_v3_dtor_kinds, d_make_operator PARAMS ((struct d_info *,
struct d_comp *)); const struct demangle_operator_info *));
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 demangle_component *
static struct d_comp *d_mangled_name PARAMS ((struct d_info *, int)); d_make_extended_operator PARAMS ((struct d_info *, int,
static int has_return_type PARAMS ((struct d_comp *)); struct demangle_component *));
static int is_ctor_dtor_or_conversion PARAMS ((struct d_comp *));
static struct d_comp *d_encoding PARAMS ((struct d_info *, int)); static struct demangle_component *
static struct d_comp *d_name PARAMS ((struct d_info *)); d_make_ctor PARAMS ((struct d_info *, enum gnu_v3_ctor_kinds,
static struct d_comp *d_nested_name PARAMS ((struct d_info *)); struct demangle_component *));
static struct d_comp *d_prefix PARAMS ((struct d_info *));
static struct d_comp *d_unqualified_name PARAMS ((struct d_info *)); static struct demangle_component *
static struct d_comp *d_source_name PARAMS ((struct d_info *)); d_make_dtor PARAMS ((struct d_info *, enum gnu_v3_dtor_kinds,
static long d_number PARAMS ((struct d_info *)); struct demangle_component *));
static struct d_comp *d_identifier PARAMS ((struct d_info *, int));
static struct d_comp *d_operator_name PARAMS ((struct d_info *)); static struct demangle_component *
static struct d_comp *d_special_name PARAMS ((struct d_info *)); d_make_template_param PARAMS ((struct d_info *, long));
static int d_call_offset PARAMS ((struct d_info *, int));
static struct d_comp *d_ctor_dtor_name PARAMS ((struct d_info *)); static struct demangle_component *
static struct d_comp *d_type PARAMS ((struct d_info *)); d_make_sub PARAMS ((struct d_info *, const char *, int));
static struct d_comp **d_cv_qualifiers PARAMS ((struct d_info *,
struct d_comp **, int)); static int
static struct d_comp *d_function_type PARAMS ((struct d_info *)); has_return_type PARAMS ((struct demangle_component *));
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 int
static struct d_comp *d_array_type PARAMS ((struct d_info *)); is_ctor_dtor_or_conversion PARAMS ((struct demangle_component *));
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 demangle_component *
static struct d_comp *d_template_args PARAMS ((struct d_info *)); d_encoding PARAMS ((struct d_info *, int));
static struct d_comp *d_template_arg PARAMS ((struct d_info *));
static struct d_comp *d_expression PARAMS ((struct d_info *)); static struct demangle_component *
static struct d_comp *d_expr_primary PARAMS ((struct d_info *)); d_name PARAMS ((struct d_info *));
static struct d_comp *d_local_name PARAMS ((struct d_info *));
static int d_discriminator PARAMS ((struct d_info *)); static struct demangle_component *
static int d_add_substitution PARAMS ((struct d_info *, struct d_comp *)); d_nested_name PARAMS ((struct d_info *));
static struct d_comp *d_substitution PARAMS ((struct d_info *, int));
static void d_print_resize PARAMS ((struct d_print_info *, size_t)); static struct demangle_component *
static void d_print_append_char PARAMS ((struct d_print_info *, int)); d_prefix PARAMS ((struct d_info *));
static void d_print_append_buffer PARAMS ((struct d_print_info *, const char *,
size_t)); static struct demangle_component *
static void d_print_error PARAMS ((struct d_print_info *)); d_unqualified_name PARAMS ((struct d_info *));
static char *d_print PARAMS ((int, const struct d_comp *, int, size_t *));
static void d_print_comp PARAMS ((struct d_print_info *, static struct demangle_component *
const struct d_comp *)); d_source_name PARAMS ((struct d_info *));
static void d_print_java_identifier PARAMS ((struct d_print_info *,
const char *, int)); static long
static void d_print_mod_list PARAMS ((struct d_print_info *, d_number PARAMS ((struct d_info *));
struct d_print_mod *, int));
static void d_print_mod PARAMS ((struct d_print_info *, static struct demangle_component *
const struct d_comp *)); d_identifier PARAMS ((struct d_info *, int));
static void d_print_function_type PARAMS ((struct d_print_info *,
const struct d_comp *, 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 *)); struct d_print_mod *));
static void d_print_array_type PARAMS ((struct d_print_info *,
const struct d_comp *, static void
d_print_array_type PARAMS ((struct d_print_info *,
const struct demangle_component *,
struct d_print_mod *)); struct d_print_mod *));
static void d_print_expr_op PARAMS ((struct d_print_info *,
const struct d_comp *)); static void
static void d_print_cast PARAMS ((struct d_print_info *, d_print_expr_op PARAMS ((struct d_print_info *,
const struct d_comp *)); const struct demangle_component *));
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 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 #ifdef CP_DEMANGLE_DEBUG
static void static void
d_dump (dc, indent) d_dump (dc, indent)
struct d_comp *dc; struct demangle_component *dc;
int indent; int indent;
{ {
int i; int i;
...@@ -587,159 +478,159 @@ d_dump (dc, indent) ...@@ -587,159 +478,159 @@ d_dump (dc, indent)
switch (dc->type) 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); printf ("name '%.*s'\n", dc->u.s_name.len, dc->u.s_name.s);
return; return;
case D_COMP_TEMPLATE_PARAM: case DEMANGLE_COMPONENT_TEMPLATE_PARAM:
printf ("template parameter %ld\n", dc->u.s_number.number); printf ("template parameter %ld\n", dc->u.s_number.number);
return; return;
case D_COMP_CTOR: case DEMANGLE_COMPONENT_CTOR:
printf ("constructor %d\n", (int) dc->u.s_ctor.kind); printf ("constructor %d\n", (int) dc->u.s_ctor.kind);
d_dump (dc->u.s_ctor.name, indent + 2); d_dump (dc->u.s_ctor.name, indent + 2);
return; return;
case D_COMP_DTOR: case DEMANGLE_COMPONENT_DTOR:
printf ("destructor %d\n", (int) dc->u.s_dtor.kind); printf ("destructor %d\n", (int) dc->u.s_dtor.kind);
d_dump (dc->u.s_dtor.name, indent + 2); d_dump (dc->u.s_dtor.name, indent + 2);
return; return;
case D_COMP_SUB_STD: case DEMANGLE_COMPONENT_SUB_STD:
printf ("standard substitution %s\n", dc->u.s_string.string); printf ("standard substitution %s\n", dc->u.s_string.string);
return; return;
case D_COMP_BUILTIN_TYPE: case DEMANGLE_COMPONENT_BUILTIN_TYPE:
printf ("builtin type %s\n", dc->u.s_builtin.type->name); printf ("builtin type %s\n", dc->u.s_builtin.type->name);
return; return;
case D_COMP_OPERATOR: case DEMANGLE_COMPONENT_OPERATOR:
printf ("operator %s\n", dc->u.s_operator.op->name); printf ("operator %s\n", dc->u.s_operator.op->name);
return; return;
case D_COMP_EXTENDED_OPERATOR: case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
printf ("extended operator with %d args\n", printf ("extended operator with %d args\n",
dc->u.s_extended_operator.args); dc->u.s_extended_operator.args);
d_dump (dc->u.s_extended_operator.name, indent + 2); d_dump (dc->u.s_extended_operator.name, indent + 2);
return; return;
case D_COMP_QUAL_NAME: case DEMANGLE_COMPONENT_QUAL_NAME:
printf ("qualified name\n"); printf ("qualified name\n");
break; break;
case D_COMP_LOCAL_NAME: case DEMANGLE_COMPONENT_LOCAL_NAME:
printf ("local name\n"); printf ("local name\n");
break; break;
case D_COMP_TYPED_NAME: case DEMANGLE_COMPONENT_TYPED_NAME:
printf ("typed name\n"); printf ("typed name\n");
break; break;
case D_COMP_TEMPLATE: case DEMANGLE_COMPONENT_TEMPLATE:
printf ("template\n"); printf ("template\n");
break; break;
case D_COMP_VTABLE: case DEMANGLE_COMPONENT_VTABLE:
printf ("vtable\n"); printf ("vtable\n");
break; break;
case D_COMP_VTT: case DEMANGLE_COMPONENT_VTT:
printf ("VTT\n"); printf ("VTT\n");
break; break;
case D_COMP_CONSTRUCTION_VTABLE: case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE:
printf ("construction vtable\n"); printf ("construction vtable\n");
break; break;
case D_COMP_TYPEINFO: case DEMANGLE_COMPONENT_TYPEINFO:
printf ("typeinfo\n"); printf ("typeinfo\n");
break; break;
case D_COMP_TYPEINFO_NAME: case DEMANGLE_COMPONENT_TYPEINFO_NAME:
printf ("typeinfo name\n"); printf ("typeinfo name\n");
break; break;
case D_COMP_TYPEINFO_FN: case DEMANGLE_COMPONENT_TYPEINFO_FN:
printf ("typeinfo function\n"); printf ("typeinfo function\n");
break; break;
case D_COMP_THUNK: case DEMANGLE_COMPONENT_THUNK:
printf ("thunk\n"); printf ("thunk\n");
break; break;
case D_COMP_VIRTUAL_THUNK: case DEMANGLE_COMPONENT_VIRTUAL_THUNK:
printf ("virtual thunk\n"); printf ("virtual thunk\n");
break; break;
case D_COMP_COVARIANT_THUNK: case DEMANGLE_COMPONENT_COVARIANT_THUNK:
printf ("covariant thunk\n"); printf ("covariant thunk\n");
break; break;
case D_COMP_JAVA_CLASS: case DEMANGLE_COMPONENT_JAVA_CLASS:
printf ("java class\n"); printf ("java class\n");
break; break;
case D_COMP_GUARD: case DEMANGLE_COMPONENT_GUARD:
printf ("guard\n"); printf ("guard\n");
break; break;
case D_COMP_REFTEMP: case DEMANGLE_COMPONENT_REFTEMP:
printf ("reference temporary\n"); printf ("reference temporary\n");
break; break;
case D_COMP_RESTRICT: case DEMANGLE_COMPONENT_RESTRICT:
printf ("restrict\n"); printf ("restrict\n");
break; break;
case D_COMP_VOLATILE: case DEMANGLE_COMPONENT_VOLATILE:
printf ("volatile\n"); printf ("volatile\n");
break; break;
case D_COMP_CONST: case DEMANGLE_COMPONENT_CONST:
printf ("const\n"); printf ("const\n");
break; break;
case D_COMP_RESTRICT_THIS: case DEMANGLE_COMPONENT_RESTRICT_THIS:
printf ("restrict this\n"); printf ("restrict this\n");
break; break;
case D_COMP_VOLATILE_THIS: case DEMANGLE_COMPONENT_VOLATILE_THIS:
printf ("volatile this\n"); printf ("volatile this\n");
break; break;
case D_COMP_CONST_THIS: case DEMANGLE_COMPONENT_CONST_THIS:
printf ("const this\n"); printf ("const this\n");
break; break;
case D_COMP_VENDOR_TYPE_QUAL: case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
printf ("vendor type qualifier\n"); printf ("vendor type qualifier\n");
break; break;
case D_COMP_POINTER: case DEMANGLE_COMPONENT_POINTER:
printf ("pointer\n"); printf ("pointer\n");
break; break;
case D_COMP_REFERENCE: case DEMANGLE_COMPONENT_REFERENCE:
printf ("reference\n"); printf ("reference\n");
break; break;
case D_COMP_COMPLEX: case DEMANGLE_COMPONENT_COMPLEX:
printf ("complex\n"); printf ("complex\n");
break; break;
case D_COMP_IMAGINARY: case DEMANGLE_COMPONENT_IMAGINARY:
printf ("imaginary\n"); printf ("imaginary\n");
break; break;
case D_COMP_VENDOR_TYPE: case DEMANGLE_COMPONENT_VENDOR_TYPE:
printf ("vendor type\n"); printf ("vendor type\n");
break; break;
case D_COMP_FUNCTION_TYPE: case DEMANGLE_COMPONENT_FUNCTION_TYPE:
printf ("function type\n"); printf ("function type\n");
break; break;
case D_COMP_ARRAY_TYPE: case DEMANGLE_COMPONENT_ARRAY_TYPE:
printf ("array type\n"); printf ("array type\n");
break; break;
case D_COMP_PTRMEM_TYPE: case DEMANGLE_COMPONENT_PTRMEM_TYPE:
printf ("pointer to member type\n"); printf ("pointer to member type\n");
break; break;
case D_COMP_ARGLIST: case DEMANGLE_COMPONENT_ARGLIST:
printf ("argument list\n"); printf ("argument list\n");
break; break;
case D_COMP_TEMPLATE_ARGLIST: case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
printf ("template argument list\n"); printf ("template argument list\n");
break; break;
case D_COMP_CAST: case DEMANGLE_COMPONENT_CAST:
printf ("cast\n"); printf ("cast\n");
break; break;
case D_COMP_UNARY: case DEMANGLE_COMPONENT_UNARY:
printf ("unary operator\n"); printf ("unary operator\n");
break; break;
case D_COMP_BINARY: case DEMANGLE_COMPONENT_BINARY:
printf ("binary operator\n"); printf ("binary operator\n");
break; break;
case D_COMP_BINARY_ARGS: case DEMANGLE_COMPONENT_BINARY_ARGS:
printf ("binary operator arguments\n"); printf ("binary operator arguments\n");
break; break;
case D_COMP_TRINARY: case DEMANGLE_COMPONENT_TRINARY:
printf ("trinary operator\n"); printf ("trinary operator\n");
break; break;
case D_COMP_TRINARY_ARG1: case DEMANGLE_COMPONENT_TRINARY_ARG1:
printf ("trinary operator arguments 1\n"); printf ("trinary operator arguments 1\n");
break; break;
case D_COMP_TRINARY_ARG2: case DEMANGLE_COMPONENT_TRINARY_ARG2:
printf ("trinary operator arguments 1\n"); printf ("trinary operator arguments 1\n");
break; break;
case D_COMP_LITERAL: case DEMANGLE_COMPONENT_LITERAL:
printf ("literal\n"); printf ("literal\n");
break; break;
case D_COMP_LITERAL_NEG: case DEMANGLE_COMPONENT_LITERAL_NEG:
printf ("negative literal\n"); printf ("negative literal\n");
break; break;
} }
...@@ -750,33 +641,105 @@ d_dump (dc, indent) ...@@ -750,33 +641,105 @@ d_dump (dc, indent)
#endif /* CP_DEMANGLE_DEBUG */ #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. */ /* Add a new component. */
static struct d_comp * static struct demangle_component *
d_make_empty (di, type) d_make_empty (di)
struct d_info *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) if (di->next_comp >= di->num_comps)
return NULL; return NULL;
p = &di->comps[di->next_comp]; p = &di->comps[di->next_comp];
p->type = type;
++di->next_comp; ++di->next_comp;
return p; return p;
} }
/* Add a new generic component. */ /* Add a new generic component. */
static struct d_comp * static struct demangle_component *
d_make_comp (di, type, left, right) d_make_comp (di, type, left, right)
struct d_info *di; struct d_info *di;
enum d_comp_type type; enum demangle_component_type type;
struct d_comp *left; struct demangle_component *left;
struct d_comp *right; 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 /* We check for errors here. A typical error would be a NULL return
from a subroutine. We catch those here, and return NULL from a subroutine. We catch those here, and return NULL
...@@ -784,65 +747,65 @@ d_make_comp (di, type, left, right) ...@@ -784,65 +747,65 @@ d_make_comp (di, type, left, right)
switch (type) switch (type)
{ {
/* These types require two parameters. */ /* These types require two parameters. */
case D_COMP_QUAL_NAME: case DEMANGLE_COMPONENT_QUAL_NAME:
case D_COMP_LOCAL_NAME: case DEMANGLE_COMPONENT_LOCAL_NAME:
case D_COMP_TYPED_NAME: case DEMANGLE_COMPONENT_TYPED_NAME:
case D_COMP_TEMPLATE: case DEMANGLE_COMPONENT_TEMPLATE:
case D_COMP_VENDOR_TYPE_QUAL: case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
case D_COMP_PTRMEM_TYPE: case DEMANGLE_COMPONENT_PTRMEM_TYPE:
case D_COMP_UNARY: case DEMANGLE_COMPONENT_UNARY:
case D_COMP_BINARY: case DEMANGLE_COMPONENT_BINARY:
case D_COMP_BINARY_ARGS: case DEMANGLE_COMPONENT_BINARY_ARGS:
case D_COMP_TRINARY: case DEMANGLE_COMPONENT_TRINARY:
case D_COMP_TRINARY_ARG1: case DEMANGLE_COMPONENT_TRINARY_ARG1:
case D_COMP_TRINARY_ARG2: case DEMANGLE_COMPONENT_TRINARY_ARG2:
case D_COMP_LITERAL: case DEMANGLE_COMPONENT_LITERAL:
case D_COMP_LITERAL_NEG: case DEMANGLE_COMPONENT_LITERAL_NEG:
if (left == NULL || right == NULL) if (left == NULL || right == NULL)
return NULL; return NULL;
break; break;
/* These types only require one parameter. */ /* These types only require one parameter. */
case D_COMP_VTABLE: case DEMANGLE_COMPONENT_VTABLE:
case D_COMP_VTT: case DEMANGLE_COMPONENT_VTT:
case D_COMP_CONSTRUCTION_VTABLE: case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE:
case D_COMP_TYPEINFO: case DEMANGLE_COMPONENT_TYPEINFO:
case D_COMP_TYPEINFO_NAME: case DEMANGLE_COMPONENT_TYPEINFO_NAME:
case D_COMP_TYPEINFO_FN: case DEMANGLE_COMPONENT_TYPEINFO_FN:
case D_COMP_THUNK: case DEMANGLE_COMPONENT_THUNK:
case D_COMP_VIRTUAL_THUNK: case DEMANGLE_COMPONENT_VIRTUAL_THUNK:
case D_COMP_COVARIANT_THUNK: case DEMANGLE_COMPONENT_COVARIANT_THUNK:
case D_COMP_JAVA_CLASS: case DEMANGLE_COMPONENT_JAVA_CLASS:
case D_COMP_GUARD: case DEMANGLE_COMPONENT_GUARD:
case D_COMP_REFTEMP: case DEMANGLE_COMPONENT_REFTEMP:
case D_COMP_POINTER: case DEMANGLE_COMPONENT_POINTER:
case D_COMP_REFERENCE: case DEMANGLE_COMPONENT_REFERENCE:
case D_COMP_COMPLEX: case DEMANGLE_COMPONENT_COMPLEX:
case D_COMP_IMAGINARY: case DEMANGLE_COMPONENT_IMAGINARY:
case D_COMP_VENDOR_TYPE: case DEMANGLE_COMPONENT_VENDOR_TYPE:
case D_COMP_ARGLIST: case DEMANGLE_COMPONENT_ARGLIST:
case D_COMP_TEMPLATE_ARGLIST: case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
case D_COMP_CAST: case DEMANGLE_COMPONENT_CAST:
if (left == NULL) if (left == NULL)
return NULL; return NULL;
break; break;
/* This needs a right parameter, but the left parameter can be /* This needs a right parameter, but the left parameter can be
empty. */ empty. */
case D_COMP_ARRAY_TYPE: case DEMANGLE_COMPONENT_ARRAY_TYPE:
if (right == NULL) if (right == NULL)
return NULL; return NULL;
break; break;
/* These are allowed to have no parameters--in some cases they /* These are allowed to have no parameters--in some cases they
will be filled in later. */ will be filled in later. */
case D_COMP_FUNCTION_TYPE: case DEMANGLE_COMPONENT_FUNCTION_TYPE:
case D_COMP_RESTRICT: case DEMANGLE_COMPONENT_RESTRICT:
case D_COMP_VOLATILE: case DEMANGLE_COMPONENT_VOLATILE:
case D_COMP_CONST: case DEMANGLE_COMPONENT_CONST:
case D_COMP_RESTRICT_THIS: case DEMANGLE_COMPONENT_RESTRICT_THIS:
case D_COMP_VOLATILE_THIS: case DEMANGLE_COMPONENT_VOLATILE_THIS:
case D_COMP_CONST_THIS: case DEMANGLE_COMPONENT_CONST_THIS:
break; break;
/* Other types should not be seen here. */ /* Other types should not be seen here. */
...@@ -850,9 +813,10 @@ d_make_comp (di, type, left, right) ...@@ -850,9 +813,10 @@ d_make_comp (di, type, left, right)
return NULL; return NULL;
} }
p = d_make_empty (di, type); p = d_make_empty (di);
if (p != NULL) if (p != NULL)
{ {
p->type = type;
p->u.s_binary.left = left; p->u.s_binary.left = left;
p->u.s_binary.right = right; p->u.s_binary.right = right;
} }
...@@ -861,148 +825,138 @@ d_make_comp (di, type, left, right) ...@@ -861,148 +825,138 @@ d_make_comp (di, type, left, right)
/* Add a new name component. */ /* Add a new name component. */
static struct d_comp * static struct demangle_component *
d_make_name (di, s, len) d_make_name (di, s, len)
struct d_info *di; struct d_info *di;
const char *s; const char *s;
int len; 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; 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; return p;
} }
/* Add a new builtin type component. */ /* Add a new builtin type component. */
static struct d_comp * static struct demangle_component *
d_make_builtin_type (di, type) d_make_builtin_type (di, type)
struct d_info *di; 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) if (type == NULL)
return NULL; return NULL;
p = d_make_empty (di, D_COMP_BUILTIN_TYPE); p = d_make_empty (di);
if (p != NULL) if (p != NULL)
{
p->type = DEMANGLE_COMPONENT_BUILTIN_TYPE;
p->u.s_builtin.type = type; p->u.s_builtin.type = type;
}
return p; return p;
} }
/* Add a new operator component. */ /* Add a new operator component. */
static struct d_comp * static struct demangle_component *
d_make_operator (di, op) d_make_operator (di, op)
struct d_info *di; 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) if (p != NULL)
{
p->type = DEMANGLE_COMPONENT_OPERATOR;
p->u.s_operator.op = op; p->u.s_operator.op = op;
}
return p; return p;
} }
/* Add a new extended operator component. */ /* Add a new extended operator component. */
static struct d_comp * static struct demangle_component *
d_make_extended_operator (di, args, name) d_make_extended_operator (di, args, name)
struct d_info *di; struct d_info *di;
int args; 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; 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; return p;
} }
/* Add a new constructor component. */ /* Add a new constructor component. */
static struct d_comp * static struct demangle_component *
d_make_ctor (di, kind, name) d_make_ctor (di, kind, name)
struct d_info *di; struct d_info *di;
enum gnu_v3_ctor_kinds kind; 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; 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; return p;
} }
/* Add a new destructor component. */ /* Add a new destructor component. */
static struct d_comp * static struct demangle_component *
d_make_dtor (di, kind, name) d_make_dtor (di, kind, name)
struct d_info *di; struct d_info *di;
enum gnu_v3_dtor_kinds kind; 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; 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; return p;
} }
/* Add a new template parameter. */ /* Add a new template parameter. */
static struct d_comp * static struct demangle_component *
d_make_template_param (di, i) d_make_template_param (di, i)
struct d_info *di; struct d_info *di;
long i; 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) if (p != NULL)
{
p->type = DEMANGLE_COMPONENT_TEMPLATE_PARAM;
p->u.s_number.number = i; p->u.s_number.number = i;
}
return p; return p;
} }
/* Add a new standard substitution component. */ /* Add a new standard substitution component. */
static struct d_comp * static struct demangle_component *
d_make_sub (di, name, len) d_make_sub (di, name, len)
struct d_info *di; struct d_info *di;
const char *name; const char *name;
int len; 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) if (p != NULL)
{ {
p->type = DEMANGLE_COMPONENT_SUB_STD;
p->u.s_string.string = name; p->u.s_string.string = name;
p->u.s_string.len = len; p->u.s_string.len = len;
} }
...@@ -1013,8 +967,9 @@ d_make_sub (di, name, len) ...@@ -1013,8 +967,9 @@ d_make_sub (di, name, len)
TOP_LEVEL is non-zero when called at the top level. */ TOP_LEVEL is non-zero when called at the top level. */
static struct d_comp * CP_STATIC_IF_GLIBCPP_V3
d_mangled_name (di, top_level) struct demangle_component *
cplus_demangle_mangled_name (di, top_level)
struct d_info *di; struct d_info *di;
int top_level; int top_level;
{ {
...@@ -1036,7 +991,7 @@ d_mangled_name (di, top_level) ...@@ -1036,7 +991,7 @@ d_mangled_name (di, top_level)
static int static int
has_return_type (dc) has_return_type (dc)
struct d_comp *dc; struct demangle_component *dc;
{ {
if (dc == NULL) if (dc == NULL)
return 0; return 0;
...@@ -1044,11 +999,11 @@ has_return_type (dc) ...@@ -1044,11 +999,11 @@ has_return_type (dc)
{ {
default: default:
return 0; return 0;
case D_COMP_TEMPLATE: case DEMANGLE_COMPONENT_TEMPLATE:
return ! is_ctor_dtor_or_conversion (d_left (dc)); return ! is_ctor_dtor_or_conversion (d_left (dc));
case D_COMP_RESTRICT_THIS: case DEMANGLE_COMPONENT_RESTRICT_THIS:
case D_COMP_VOLATILE_THIS: case DEMANGLE_COMPONENT_VOLATILE_THIS:
case D_COMP_CONST_THIS: case DEMANGLE_COMPONENT_CONST_THIS:
return has_return_type (d_left (dc)); return has_return_type (d_left (dc));
} }
} }
...@@ -1058,7 +1013,7 @@ has_return_type (dc) ...@@ -1058,7 +1013,7 @@ has_return_type (dc)
static int static int
is_ctor_dtor_or_conversion (dc) is_ctor_dtor_or_conversion (dc)
struct d_comp *dc; struct demangle_component *dc;
{ {
if (dc == NULL) if (dc == NULL)
return 0; return 0;
...@@ -1066,12 +1021,12 @@ is_ctor_dtor_or_conversion (dc) ...@@ -1066,12 +1021,12 @@ is_ctor_dtor_or_conversion (dc)
{ {
default: default:
return 0; return 0;
case D_COMP_QUAL_NAME: case DEMANGLE_COMPONENT_QUAL_NAME:
case D_COMP_LOCAL_NAME: case DEMANGLE_COMPONENT_LOCAL_NAME:
return is_ctor_dtor_or_conversion (d_right (dc)); return is_ctor_dtor_or_conversion (d_right (dc));
case D_COMP_CTOR: case DEMANGLE_COMPONENT_CTOR:
case D_COMP_DTOR: case DEMANGLE_COMPONENT_DTOR:
case D_COMP_CAST: case DEMANGLE_COMPONENT_CAST:
return 1; return 1;
} }
} }
...@@ -1085,7 +1040,7 @@ is_ctor_dtor_or_conversion (dc) ...@@ -1085,7 +1040,7 @@ is_ctor_dtor_or_conversion (dc)
parameters. We only set this at the top level, because otherwise parameters. We only set this at the top level, because otherwise
we would not correctly demangle names in local scopes. */ we would not correctly demangle names in local scopes. */
static struct d_comp * static struct demangle_component *
d_encoding (di, top_level) d_encoding (di, top_level)
struct d_info *di; struct d_info *di;
int top_level; int top_level;
...@@ -1096,7 +1051,7 @@ d_encoding (di, top_level) ...@@ -1096,7 +1051,7 @@ d_encoding (di, top_level)
return d_special_name (di); return d_special_name (di);
else else
{ {
struct d_comp *dc; struct demangle_component *dc;
dc = d_name (di); dc = d_name (di);
...@@ -1105,23 +1060,23 @@ d_encoding (di, top_level) ...@@ -1105,23 +1060,23 @@ d_encoding (di, top_level)
/* Strip off any initial CV-qualifiers, as they really apply /* Strip off any initial CV-qualifiers, as they really apply
to the `this' parameter, and they were not output by the to the `this' parameter, and they were not output by the
v2 demangler without DMGL_PARAMS. */ v2 demangler without DMGL_PARAMS. */
while (dc->type == D_COMP_RESTRICT_THIS while (dc->type == DEMANGLE_COMPONENT_RESTRICT_THIS
|| dc->type == D_COMP_VOLATILE_THIS || dc->type == DEMANGLE_COMPONENT_VOLATILE_THIS
|| dc->type == D_COMP_CONST_THIS) || dc->type == DEMANGLE_COMPONENT_CONST_THIS)
dc = d_left (dc); dc = d_left (dc);
/* If the top level is a D_COMP_LOCAL_NAME, then there may /* If the top level is a DEMANGLE_COMPONENT_LOCAL_NAME, then
be CV-qualifiers on its right argument which really apply there may be CV-qualifiers on its right argument which
here; this happens when parsing a class which is local to really apply here; this happens when parsing a class
a function. */ which is local to a function. */
if (dc->type == D_COMP_LOCAL_NAME) if (dc->type == DEMANGLE_COMPONENT_LOCAL_NAME)
{ {
struct d_comp *dcr; struct demangle_component *dcr;
dcr = d_right (dc); dcr = d_right (dc);
while (dcr->type == D_COMP_RESTRICT_THIS while (dcr->type == DEMANGLE_COMPONENT_RESTRICT_THIS
|| dcr->type == D_COMP_VOLATILE_THIS || dcr->type == DEMANGLE_COMPONENT_VOLATILE_THIS
|| dcr->type == D_COMP_CONST_THIS) || dcr->type == DEMANGLE_COMPONENT_CONST_THIS)
dcr = d_left (dcr); dcr = d_left (dcr);
dc->u.s_binary.right = dcr; dc->u.s_binary.right = dcr;
} }
...@@ -1132,7 +1087,7 @@ d_encoding (di, top_level) ...@@ -1132,7 +1087,7 @@ d_encoding (di, top_level)
peek = d_peek_char (di); peek = d_peek_char (di);
if (peek == '\0' || peek == 'E') if (peek == '\0' || peek == 'E')
return dc; 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))); d_bare_function_type (di, has_return_type (dc)));
} }
} }
...@@ -1149,12 +1104,12 @@ d_encoding (di, top_level) ...@@ -1149,12 +1104,12 @@ d_encoding (di, top_level)
::= <substitution> ::= <substitution>
*/ */
static struct d_comp * static struct demangle_component *
d_name (di) d_name (di)
struct d_info *di; struct d_info *di;
{ {
char peek = d_peek_char (di); char peek = d_peek_char (di);
struct d_comp *dc; struct demangle_component *dc;
switch (peek) switch (peek)
{ {
...@@ -1176,7 +1131,8 @@ d_name (di) ...@@ -1176,7 +1131,8 @@ d_name (di)
else else
{ {
d_advance (di, 2); 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)); d_unqualified_name (di));
di->expansion += 3; di->expansion += 3;
subst = 0; subst = 0;
...@@ -1199,7 +1155,8 @@ d_name (di) ...@@ -1199,7 +1155,8 @@ d_name (di)
if (! d_add_substitution (di, dc)) if (! d_add_substitution (di, dc))
return NULL; 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; return dc;
...@@ -1214,7 +1171,8 @@ d_name (di) ...@@ -1214,7 +1171,8 @@ d_name (di)
candidate. */ candidate. */
if (! d_add_substitution (di, dc)) if (! d_add_substitution (di, dc))
return NULL; 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; return dc;
} }
...@@ -1224,12 +1182,12 @@ d_name (di) ...@@ -1224,12 +1182,12 @@ d_name (di)
::= N [<CV-qualifiers>] <template-prefix> <template-args> E ::= N [<CV-qualifiers>] <template-prefix> <template-args> E
*/ */
static struct d_comp * static struct demangle_component *
d_nested_name (di) d_nested_name (di)
struct d_info *di; struct d_info *di;
{ {
struct d_comp *ret; struct demangle_component *ret;
struct d_comp **pret; struct demangle_component **pret;
if (d_next_char (di) != 'N') if (d_next_char (di) != 'N')
return NULL; return NULL;
...@@ -1259,17 +1217,17 @@ d_nested_name (di) ...@@ -1259,17 +1217,17 @@ d_nested_name (di)
::= <substitution> ::= <substitution>
*/ */
static struct d_comp * static struct demangle_component *
d_prefix (di) d_prefix (di)
struct d_info *di; struct d_info *di;
{ {
struct d_comp *ret = NULL; struct demangle_component *ret = NULL;
while (1) while (1)
{ {
char peek; char peek;
enum d_comp_type comb_type; enum demangle_component_type comb_type;
struct d_comp *dc; struct demangle_component *dc;
peek = d_peek_char (di); peek = d_peek_char (di);
if (peek == '\0') if (peek == '\0')
...@@ -1279,7 +1237,7 @@ d_prefix (di) ...@@ -1279,7 +1237,7 @@ d_prefix (di)
that in the grammar. The older code does not accept a that in the grammar. The older code does not accept a
<template-param> here. */ <template-param> here. */
comb_type = D_COMP_QUAL_NAME; comb_type = DEMANGLE_COMPONENT_QUAL_NAME;
if (IS_DIGIT (peek) if (IS_DIGIT (peek)
|| IS_LOWER (peek) || IS_LOWER (peek)
|| peek == 'C' || peek == 'C'
...@@ -1291,7 +1249,7 @@ d_prefix (di) ...@@ -1291,7 +1249,7 @@ d_prefix (di)
{ {
if (ret == NULL) if (ret == NULL)
return NULL; return NULL;
comb_type = D_COMP_TEMPLATE; comb_type = DEMANGLE_COMPONENT_TEMPLATE;
dc = d_template_args (di); dc = d_template_args (di);
} }
else if (peek == 'T') else if (peek == 'T')
...@@ -1319,7 +1277,7 @@ d_prefix (di) ...@@ -1319,7 +1277,7 @@ d_prefix (di)
::= <source-name> ::= <source-name>
*/ */
static struct d_comp * static struct demangle_component *
d_unqualified_name (di) d_unqualified_name (di)
struct d_info *di; struct d_info *di;
{ {
...@@ -1330,10 +1288,10 @@ d_unqualified_name (di) ...@@ -1330,10 +1288,10 @@ d_unqualified_name (di)
return d_source_name (di); return d_source_name (di);
else if (IS_LOWER (peek)) else if (IS_LOWER (peek))
{ {
struct d_comp *ret; struct demangle_component *ret;
ret = d_operator_name (di); 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; di->expansion += sizeof "operator" + ret->u.s_operator.op->len - 2;
return ret; return ret;
} }
...@@ -1345,12 +1303,12 @@ d_unqualified_name (di) ...@@ -1345,12 +1303,12 @@ d_unqualified_name (di)
/* <source-name> ::= <(positive length) number> <identifier> */ /* <source-name> ::= <(positive length) number> <identifier> */
static struct d_comp * static struct demangle_component *
d_source_name (di) d_source_name (di)
struct d_info *di; struct d_info *di;
{ {
long len; long len;
struct d_comp *ret; struct demangle_component *ret;
len = d_number (di); len = d_number (di);
if (len <= 0) if (len <= 0)
...@@ -1396,7 +1354,7 @@ d_number (di) ...@@ -1396,7 +1354,7 @@ d_number (di)
/* identifier ::= <(unqualified source code identifier)> */ /* identifier ::= <(unqualified source code identifier)> */
static struct d_comp * static struct demangle_component *
d_identifier (di, len) d_identifier (di, len)
struct d_info *di; struct d_info *di;
int len; int len;
...@@ -1446,7 +1404,8 @@ d_identifier (di, len) ...@@ -1446,7 +1404,8 @@ d_identifier (di, len)
#define NL(s) s, (sizeof s) - 1 #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 }, { "aN", NL ("&="), 2 },
{ "aS", NL ("="), 2 }, { "aS", NL ("="), 2 },
...@@ -1496,10 +1455,11 @@ static const struct d_operator_info d_operators[] = ...@@ -1496,10 +1455,11 @@ static const struct d_operator_info d_operators[] =
{ "rm", NL ("%"), 2 }, { "rm", NL ("%"), 2 },
{ "rs", NL (">>"), 2 }, { "rs", NL (">>"), 2 },
{ "st", NL ("sizeof "), 1 }, { "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) d_operator_name (di)
struct d_info *di; struct d_info *di;
{ {
...@@ -1511,19 +1471,25 @@ d_operator_name (di) ...@@ -1511,19 +1471,25 @@ d_operator_name (di)
if (c1 == 'v' && IS_DIGIT (c2)) if (c1 == 'v' && IS_DIGIT (c2))
return d_make_extended_operator (di, c2 - '0', d_source_name (di)); return d_make_extended_operator (di, c2 - '0', d_source_name (di));
else if (c1 == 'c' && c2 == 'v') 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 else
{ {
/* LOW is the inclusive lower bound. */
int low = 0; 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) while (1)
{ {
int i; int i;
const struct d_operator_info *p; const struct demangle_operator_info *p;
i = low + (high - low) / 2; i = low + (high - low) / 2;
p = d_operators + i; p = cplus_demangle_operators + i;
if (c1 == p->code[0] && c2 == p->code[1]) if (c1 == p->code[0] && c2 == p->code[1])
return d_make_operator (di, p); return d_make_operator (di, p);
...@@ -1552,7 +1518,7 @@ d_operator_name (di) ...@@ -1552,7 +1518,7 @@ d_operator_name (di)
::= GR <name> ::= GR <name>
*/ */
static struct d_comp * static struct demangle_component *
d_special_name (di) d_special_name (di)
struct d_info *di; struct d_info *di;
{ {
...@@ -1566,58 +1532,65 @@ d_special_name (di) ...@@ -1566,58 +1532,65 @@ d_special_name (di)
{ {
case 'V': case 'V':
di->expansion -= 5; 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': case 'T':
di->expansion -= 10; 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': 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': 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': case 'h':
if (! d_call_offset (di, 'h')) if (! d_call_offset (di, 'h'))
return NULL; 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': case 'v':
if (! d_call_offset (di, 'v')) if (! d_call_offset (di, 'v'))
return NULL; return NULL;
return d_make_comp (di, D_COMP_VIRTUAL_THUNK, d_encoding (di, 0), return d_make_comp (di, DEMANGLE_COMPONENT_VIRTUAL_THUNK,
NULL); d_encoding (di, 0), NULL);
case 'c': case 'c':
if (! d_call_offset (di, '\0')) if (! d_call_offset (di, '\0'))
return NULL; return NULL;
if (! d_call_offset (di, '\0')) if (! d_call_offset (di, '\0'))
return NULL; return NULL;
return d_make_comp (di, D_COMP_COVARIANT_THUNK, d_encoding (di, 0), return d_make_comp (di, DEMANGLE_COMPONENT_COVARIANT_THUNK,
NULL); d_encoding (di, 0), NULL);
case 'C': case 'C':
{ {
struct d_comp *derived_type; struct demangle_component *derived_type;
long offset; 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); offset = d_number (di);
if (offset < 0) if (offset < 0)
return NULL; return NULL;
if (d_next_char (di) != '_') if (d_next_char (di) != '_')
return NULL; return NULL;
base_type = d_type (di); base_type = cplus_demangle_type (di);
/* We don't display the offset. FIXME: We should display /* We don't display the offset. FIXME: We should display
it in verbose mode. */ it in verbose mode. */
di->expansion += 5; di->expansion += 5;
return d_make_comp (di, D_COMP_CONSTRUCTION_VTABLE, base_type, return d_make_comp (di, DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE,
derived_type); base_type, derived_type);
} }
case 'F': 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': 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: default:
return NULL; return NULL;
...@@ -1628,10 +1601,11 @@ d_special_name (di) ...@@ -1628,10 +1601,11 @@ d_special_name (di)
switch (d_next_char (di)) switch (d_next_char (di))
{ {
case 'V': 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': 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: default:
return NULL; return NULL;
...@@ -1691,15 +1665,15 @@ d_call_offset (di, c) ...@@ -1691,15 +1665,15 @@ d_call_offset (di, c)
::= D2 ::= D2
*/ */
static struct d_comp * static struct demangle_component *
d_ctor_dtor_name (di) d_ctor_dtor_name (di)
struct d_info *di; struct d_info *di;
{ {
if (di->last_name != NULL) 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; 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; di->expansion += di->last_name->u.s_string.len;
} }
switch (d_next_char (di)) switch (d_next_char (di))
...@@ -1770,7 +1744,9 @@ d_ctor_dtor_name (di) ...@@ -1770,7 +1744,9 @@ d_ctor_dtor_name (di)
::= u <source-name> ::= u <source-name>
*/ */
static const struct d_builtin_type_info d_builtin_types[26] = CP_STATIC_IF_GLIBCPP_V3
const struct demangle_builtin_type_info
cplus_demangle_builtin_types[D_BUILTIN_TYPE_COUNT] =
{ {
/* a */ { NL ("signed char"), NL ("signed char"), D_PRINT_INT }, /* a */ { NL ("signed char"), NL ("signed char"), D_PRINT_INT },
/* b */ { NL ("bool"), NL ("boolean"), D_PRINT_BOOL }, /* b */ { NL ("bool"), NL ("boolean"), D_PRINT_BOOL },
...@@ -1800,12 +1776,13 @@ static const struct d_builtin_type_info d_builtin_types[26] = ...@@ -1800,12 +1776,13 @@ static const struct d_builtin_type_info d_builtin_types[26] =
/* z */ { NL ("..."), NL ("..."), D_PRINT_DEFAULT }, /* z */ { NL ("..."), NL ("..."), D_PRINT_DEFAULT },
}; };
static struct d_comp * CP_STATIC_IF_GLIBCPP_V3
d_type (di) struct demangle_component *
cplus_demangle_type (di)
struct d_info *di; struct d_info *di;
{ {
char peek; char peek;
struct d_comp *ret; struct demangle_component *ret;
int can_subst; int can_subst;
/* The ABI specifies that when CV-qualifiers are used, the base type /* The ABI specifies that when CV-qualifiers are used, the base type
...@@ -1826,12 +1803,12 @@ d_type (di) ...@@ -1826,12 +1803,12 @@ d_type (di)
peek = d_peek_char (di); peek = d_peek_char (di);
if (peek == 'r' || peek == 'V' || peek == 'K') if (peek == 'r' || peek == 'V' || peek == 'K')
{ {
struct d_comp **pret; struct demangle_component **pret;
pret = d_cv_qualifiers (di, &ret, 0); pret = d_cv_qualifiers (di, &ret, 0);
if (pret == NULL) if (pret == NULL)
return NULL; return NULL;
*pret = d_type (di); *pret = cplus_demangle_type (di);
if (! d_add_substitution (di, ret)) if (! d_add_substitution (di, ret))
return NULL; return NULL;
return ret; return ret;
...@@ -1845,7 +1822,8 @@ d_type (di) ...@@ -1845,7 +1822,8 @@ d_type (di)
case 'h': case 'i': case 'j': case 'l': case 'm': case 'n': case 'h': case 'i': case 'j': case 'l': case 'm': case 'n':
case 'o': case 's': case 't': case 'o': case 's': case 't':
case 'v': case 'w': case 'x': case 'y': case 'z': 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; di->expansion += ret->u.s_builtin.type->len;
can_subst = 0; can_subst = 0;
d_advance (di, 1); d_advance (di, 1);
...@@ -1853,7 +1831,8 @@ d_type (di) ...@@ -1853,7 +1831,8 @@ d_type (di)
case 'u': case 'u':
d_advance (di, 1); 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; break;
case 'F': case 'F':
...@@ -1884,7 +1863,8 @@ d_type (di) ...@@ -1884,7 +1863,8 @@ d_type (di)
candidate. */ candidate. */
if (! d_add_substitution (di, ret)) if (! d_add_substitution (di, ret))
return NULL; 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; break;
...@@ -1903,7 +1883,7 @@ d_type (di) ...@@ -1903,7 +1883,7 @@ d_type (di)
/* The substituted name may have been a template name and /* The substituted name may have been a template name and
may be followed by tepmlate args. */ may be followed by tepmlate args. */
if (d_peek_char (di) == 'I') 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)); d_template_args (di));
else else
can_subst = 0; can_subst = 0;
...@@ -1915,7 +1895,7 @@ d_type (di) ...@@ -1915,7 +1895,7 @@ d_type (di)
a new substitution candidate. However, if the a new substitution candidate. However, if the
substitution was followed by template arguments, then substitution was followed by template arguments, then
the whole thing is a substitution candidate. */ 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; can_subst = 0;
} }
} }
...@@ -1923,28 +1903,33 @@ d_type (di) ...@@ -1923,28 +1903,33 @@ d_type (di)
case 'P': case 'P':
d_advance (di, 1); 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; break;
case 'R': case 'R':
d_advance (di, 1); 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; break;
case 'C': case 'C':
d_advance (di, 1); 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; break;
case 'G': case 'G':
d_advance (di, 1); 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; break;
case 'U': case 'U':
d_advance (di, 1); d_advance (di, 1);
ret = d_source_name (di); 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; break;
default: default:
...@@ -1962,10 +1947,10 @@ d_type (di) ...@@ -1962,10 +1947,10 @@ d_type (di)
/* <CV-qualifiers> ::= [r] [V] [K] */ /* <CV-qualifiers> ::= [r] [V] [K] */
static struct d_comp ** static struct demangle_component **
d_cv_qualifiers (di, pret, member_fn) d_cv_qualifiers (di, pret, member_fn)
struct d_info *di; struct d_info *di;
struct d_comp **pret; struct demangle_component **pret;
int member_fn; int member_fn;
{ {
char peek; char peek;
...@@ -1973,22 +1958,28 @@ d_cv_qualifiers (di, pret, member_fn) ...@@ -1973,22 +1958,28 @@ d_cv_qualifiers (di, pret, member_fn)
peek = d_peek_char (di); peek = d_peek_char (di);
while (peek == 'r' || peek == 'V' || peek == 'K') while (peek == 'r' || peek == 'V' || peek == 'K')
{ {
enum d_comp_type t; enum demangle_component_type t;
d_advance (di, 1); d_advance (di, 1);
if (peek == 'r') 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"; di->expansion += sizeof "restrict";
} }
else if (peek == 'V') 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"; di->expansion += sizeof "volatile";
} }
else 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"; di->expansion += sizeof "const";
} }
...@@ -2005,11 +1996,11 @@ d_cv_qualifiers (di, pret, member_fn) ...@@ -2005,11 +1996,11 @@ d_cv_qualifiers (di, pret, member_fn)
/* <function-type> ::= F [Y] <bare-function-type> E */ /* <function-type> ::= F [Y] <bare-function-type> E */
static struct d_comp * static struct demangle_component *
d_function_type (di) d_function_type (di)
struct d_info *di; struct d_info *di;
{ {
struct d_comp *ret; struct demangle_component *ret;
if (d_next_char (di) != 'F') if (d_next_char (di) != 'F')
return NULL; return NULL;
...@@ -2027,14 +2018,14 @@ d_function_type (di) ...@@ -2027,14 +2018,14 @@ d_function_type (di)
/* <bare-function-type> ::= <type>+ */ /* <bare-function-type> ::= <type>+ */
static struct d_comp * static struct demangle_component *
d_bare_function_type (di, has_return_type) d_bare_function_type (di, has_return_type)
struct d_info *di; struct d_info *di;
int has_return_type; int has_return_type;
{ {
struct d_comp *return_type; struct demangle_component *return_type;
struct d_comp *tl; struct demangle_component *tl;
struct d_comp **ptl; struct demangle_component **ptl;
return_type = NULL; return_type = NULL;
tl = NULL; tl = NULL;
...@@ -2042,12 +2033,12 @@ d_bare_function_type (di, has_return_type) ...@@ -2042,12 +2033,12 @@ d_bare_function_type (di, has_return_type)
while (1) while (1)
{ {
char peek; char peek;
struct d_comp *type; struct demangle_component *type;
peek = d_peek_char (di); peek = d_peek_char (di);
if (peek == '\0' || peek == 'E') if (peek == '\0' || peek == 'E')
break; break;
type = d_type (di); type = cplus_demangle_type (di);
if (type == NULL) if (type == NULL)
return NULL; return NULL;
if (has_return_type) if (has_return_type)
...@@ -2057,7 +2048,7 @@ d_bare_function_type (di, has_return_type) ...@@ -2057,7 +2048,7 @@ d_bare_function_type (di, has_return_type)
} }
else else
{ {
*ptl = d_make_comp (di, D_COMP_ARGLIST, type, NULL); *ptl = d_make_comp (di, DEMANGLE_COMPONENT_ARGLIST, type, NULL);
if (*ptl == NULL) if (*ptl == NULL)
return NULL; return NULL;
ptl = &d_right (*ptl); ptl = &d_right (*ptl);
...@@ -2072,19 +2063,19 @@ d_bare_function_type (di, has_return_type) ...@@ -2072,19 +2063,19 @@ d_bare_function_type (di, has_return_type)
/* If we have a single parameter type void, omit it. */ /* If we have a single parameter type void, omit it. */
if (d_right (tl) == NULL 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) && d_left (tl)->u.s_builtin.type->print == D_PRINT_VOID)
{ {
di->expansion -= d_left (tl)->u.s_builtin.type->len; di->expansion -= d_left (tl)->u.s_builtin.type->len;
tl = NULL; 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);
} }
/* <class-enum-type> ::= <name> */ /* <class-enum-type> ::= <name> */
static struct d_comp * static struct demangle_component *
d_class_enum_type (di) d_class_enum_type (di)
struct d_info *di; struct d_info *di;
{ {
...@@ -2095,12 +2086,12 @@ d_class_enum_type (di) ...@@ -2095,12 +2086,12 @@ d_class_enum_type (di)
::= A [<(dimension) expression>] _ <(element) type> ::= A [<(dimension) expression>] _ <(element) type>
*/ */
static struct d_comp * static struct demangle_component *
d_array_type (di) d_array_type (di)
struct d_info *di; struct d_info *di;
{ {
char peek; char peek;
struct d_comp *dim; struct demangle_component *dim;
if (d_next_char (di) != 'A') if (d_next_char (di) != 'A')
return NULL; return NULL;
...@@ -2133,23 +2124,24 @@ d_array_type (di) ...@@ -2133,23 +2124,24 @@ d_array_type (di)
if (d_next_char (di) != '_') if (d_next_char (di) != '_')
return NULL; 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));
} }
/* <pointer-to-member-type> ::= M <(class) type> <(member) type> */ /* <pointer-to-member-type> ::= M <(class) type> <(member) type> */
static struct d_comp * static struct demangle_component *
d_pointer_to_member_type (di) d_pointer_to_member_type (di)
struct d_info *di; struct d_info *di;
{ {
struct d_comp *cl; struct demangle_component *cl;
struct d_comp *mem; struct demangle_component *mem;
struct d_comp **pmem; struct demangle_component **pmem;
if (d_next_char (di) != 'M') if (d_next_char (di) != 'M')
return NULL; return NULL;
cl = d_type (di); cl = cplus_demangle_type (di);
/* The ABI specifies that any type can be a substitution source, and /* 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 that M is followed by two types, and that when a CV-qualified
...@@ -2162,21 +2154,21 @@ d_pointer_to_member_type (di) ...@@ -2162,21 +2154,21 @@ d_pointer_to_member_type (di)
g++ does not work that way. g++ treats only the CV-qualified g++ does not work that way. g++ treats only the CV-qualified
member function as a substitution source. FIXME. So to work member function as a substitution source. FIXME. So to work
with g++, we need to pull off the CV-qualifiers here, in order to 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); pmem = d_cv_qualifiers (di, &mem, 1);
if (pmem == NULL) if (pmem == NULL)
return 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);
} }
/* <template-param> ::= T_ /* <template-param> ::= T_
::= T <(parameter-2 non-negative) number> _ ::= T <(parameter-2 non-negative) number> _
*/ */
static struct d_comp * static struct demangle_component *
d_template_param (di) d_template_param (di)
struct d_info *di; struct d_info *di;
{ {
...@@ -2205,13 +2197,13 @@ d_template_param (di) ...@@ -2205,13 +2197,13 @@ d_template_param (di)
/* <template-args> ::= I <template-arg>+ E */ /* <template-args> ::= I <template-arg>+ E */
static struct d_comp * static struct demangle_component *
d_template_args (di) d_template_args (di)
struct d_info *di; struct d_info *di;
{ {
struct d_comp *hold_last_name; struct demangle_component *hold_last_name;
struct d_comp *al; struct demangle_component *al;
struct d_comp **pal; struct demangle_component **pal;
/* Preserve the last name we saw--don't let the template arguments /* 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 clobber it, as that would give us the wrong name for a subsequent
...@@ -2225,13 +2217,13 @@ d_template_args (di) ...@@ -2225,13 +2217,13 @@ d_template_args (di)
pal = &al; pal = &al;
while (1) while (1)
{ {
struct d_comp *a; struct demangle_component *a;
a = d_template_arg (di); a = d_template_arg (di);
if (a == NULL) if (a == NULL)
return 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) if (*pal == NULL)
return NULL; return NULL;
pal = &d_right (*pal); pal = &d_right (*pal);
...@@ -2253,11 +2245,11 @@ d_template_args (di) ...@@ -2253,11 +2245,11 @@ d_template_args (di)
::= <expr-primary> ::= <expr-primary>
*/ */
static struct d_comp * static struct demangle_component *
d_template_arg (di) d_template_arg (di)
struct d_info *di; struct d_info *di;
{ {
struct d_comp *ret; struct demangle_component *ret;
switch (d_peek_char (di)) switch (d_peek_char (di))
{ {
...@@ -2272,7 +2264,7 @@ d_template_arg (di) ...@@ -2272,7 +2264,7 @@ d_template_arg (di)
return d_expr_primary (di); return d_expr_primary (di);
default: default:
return d_type (di); return cplus_demangle_type (di);
} }
} }
...@@ -2286,7 +2278,7 @@ d_template_arg (di) ...@@ -2286,7 +2278,7 @@ d_template_arg (di)
::= <expr-primary> ::= <expr-primary>
*/ */
static struct d_comp * static struct demangle_component *
d_expression (di) d_expression (di)
struct d_info *di; struct d_info *di;
{ {
...@@ -2299,46 +2291,47 @@ d_expression (di) ...@@ -2299,46 +2291,47 @@ d_expression (di)
return d_template_param (di); return d_template_param (di);
else if (peek == 's' && d_peek_next_char (di) == 'r') else if (peek == 's' && d_peek_next_char (di) == 'r')
{ {
struct d_comp *type; struct demangle_component *type;
struct d_comp *name; struct demangle_component *name;
d_advance (di, 2); d_advance (di, 2);
type = d_type (di); type = cplus_demangle_type (di);
name = d_unqualified_name (di); name = d_unqualified_name (di);
if (d_peek_char (di) != 'I') 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 else
return d_make_comp (di, D_COMP_QUAL_NAME, type, return d_make_comp (di, DEMANGLE_COMPONENT_QUAL_NAME, type,
d_make_comp (di, D_COMP_TEMPLATE, name, d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, name,
d_template_args (di))); d_template_args (di)));
} }
else else
{ {
struct d_comp *op; struct demangle_component *op;
int args; int args;
op = d_operator_name (di); op = d_operator_name (di);
if (op == NULL) if (op == NULL)
return NULL; return NULL;
if (op->type == D_COMP_OPERATOR) if (op->type == DEMANGLE_COMPONENT_OPERATOR)
di->expansion += op->u.s_operator.op->len - 2; 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) && 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) switch (op->type)
{ {
default: default:
return NULL; return NULL;
case D_COMP_OPERATOR: case DEMANGLE_COMPONENT_OPERATOR:
args = op->u.s_operator.op->args; args = op->u.s_operator.op->args;
break; break;
case D_COMP_EXTENDED_OPERATOR: case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
args = op->u.s_extended_operator.args; args = op->u.s_extended_operator.args;
break; break;
case D_COMP_CAST: case DEMANGLE_COMPONENT_CAST:
args = 1; args = 1;
break; break;
} }
...@@ -2346,27 +2339,32 @@ d_expression (di) ...@@ -2346,27 +2339,32 @@ d_expression (di)
switch (args) switch (args)
{ {
case 1: 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: case 2:
{ {
struct d_comp *left; struct demangle_component *left;
left = d_expression (di); left = d_expression (di);
return d_make_comp (di, D_COMP_BINARY, op, return d_make_comp (di, DEMANGLE_COMPONENT_BINARY, op,
d_make_comp (di, D_COMP_BINARY_ARGS, left, d_make_comp (di,
DEMANGLE_COMPONENT_BINARY_ARGS,
left,
d_expression (di))); d_expression (di)));
} }
case 3: case 3:
{ {
struct d_comp *first; struct demangle_component *first;
struct d_comp *second; struct demangle_component *second;
first = d_expression (di); first = d_expression (di);
second = d_expression (di); second = d_expression (di);
return d_make_comp (di, D_COMP_TRINARY, op, return d_make_comp (di, DEMANGLE_COMPONENT_TRINARY, op,
d_make_comp (di, D_COMP_TRINARY_ARG1, first, d_make_comp (di,
DEMANGLE_COMPONENT_TRINARY_ARG1,
first,
d_make_comp (di, d_make_comp (di,
D_COMP_TRINARY_ARG2, DEMANGLE_COMPONENT_TRINARY_ARG2,
second, second,
d_expression (di)))); d_expression (di))));
} }
...@@ -2381,27 +2379,27 @@ d_expression (di) ...@@ -2381,27 +2379,27 @@ d_expression (di)
::= L <mangled-name> E ::= L <mangled-name> E
*/ */
static struct d_comp * static struct demangle_component *
d_expr_primary (di) d_expr_primary (di)
struct d_info *di; struct d_info *di;
{ {
struct d_comp *ret; struct demangle_component *ret;
if (d_next_char (di) != 'L') if (d_next_char (di) != 'L')
return NULL; return NULL;
if (d_peek_char (di) == '_') if (d_peek_char (di) == '_')
ret = d_mangled_name (di, 0); ret = cplus_demangle_mangled_name (di, 0);
else else
{ {
struct d_comp *type; struct demangle_component *type;
enum d_comp_type t; enum demangle_component_type t;
const char *s; 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 /* If we have a type we know how to print, we aren't going to
print the type name itself. */ 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) && type->u.s_builtin.type->print != D_PRINT_DEFAULT)
di->expansion -= type->u.s_builtin.type->len; di->expansion -= type->u.s_builtin.type->len;
...@@ -2416,10 +2414,10 @@ d_expr_primary (di) ...@@ -2416,10 +2414,10 @@ d_expr_primary (di)
constant in any readable form anyhow. We don't attempt to constant in any readable form anyhow. We don't attempt to
handle these cases. */ handle these cases. */
t = D_COMP_LITERAL; t = DEMANGLE_COMPONENT_LITERAL;
if (d_peek_char (di) == 'n') if (d_peek_char (di) == 'n')
{ {
t = D_COMP_LITERAL_NEG; t = DEMANGLE_COMPONENT_LITERAL_NEG;
d_advance (di, 1); d_advance (di, 1);
} }
s = d_str (di); s = d_str (di);
...@@ -2436,11 +2434,11 @@ d_expr_primary (di) ...@@ -2436,11 +2434,11 @@ d_expr_primary (di)
::= Z <(function) encoding> E s [<discriminator>] ::= Z <(function) encoding> E s [<discriminator>]
*/ */
static struct d_comp * static struct demangle_component *
d_local_name (di) d_local_name (di)
struct d_info *di; struct d_info *di;
{ {
struct d_comp *function; struct demangle_component *function;
if (d_next_char (di) != 'Z') if (d_next_char (di) != 'Z')
return NULL; return NULL;
...@@ -2455,18 +2453,18 @@ d_local_name (di) ...@@ -2455,18 +2453,18 @@ d_local_name (di)
d_advance (di, 1); d_advance (di, 1);
if (! d_discriminator (di)) if (! d_discriminator (di))
return NULL; 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", d_make_name (di, "string literal",
sizeof "string literal" - 1)); sizeof "string literal" - 1));
} }
else else
{ {
struct d_comp *name; struct demangle_component *name;
name = d_name (di); name = d_name (di);
if (! d_discriminator (di)) if (! d_discriminator (di))
return NULL; 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) ...@@ -2495,7 +2493,7 @@ d_discriminator (di)
static int static int
d_add_substitution (di, dc) d_add_substitution (di, dc)
struct d_info *di; struct d_info *di;
struct d_comp *dc; struct demangle_component *dc;
{ {
if (dc == NULL) if (dc == NULL)
return 0; return 0;
...@@ -2550,7 +2548,7 @@ static const struct d_standard_sub_info standard_subs[] = ...@@ -2550,7 +2548,7 @@ static const struct d_standard_sub_info standard_subs[] =
NL ("basic_iostream") } NL ("basic_iostream") }
}; };
static struct d_comp * static struct demangle_component *
d_substitution (di, prefix) d_substitution (di, prefix)
struct d_info *di; struct d_info *di;
int prefix; int prefix;
...@@ -2729,10 +2727,11 @@ d_print_error (dpi) ...@@ -2729,10 +2727,11 @@ d_print_error (dpi)
sets *PALC to 0 for a bad parse, or to 1 for a memory allocation sets *PALC to 0 for a bad parse, or to 1 for a memory allocation
failure. */ failure. */
static char * CP_STATIC_IF_GLIBCPP_V3
d_print (options, dc, estimate, palc) char *
cplus_demangle_print (options, dc, estimate, palc)
int options; int options;
const struct d_comp *dc; const struct demangle_component *dc;
int estimate; int estimate;
size_t *palc; size_t *palc;
{ {
...@@ -2771,7 +2770,7 @@ d_print (options, dc, estimate, palc) ...@@ -2771,7 +2770,7 @@ d_print (options, dc, estimate, palc)
static void static void
d_print_comp (dpi, dc) d_print_comp (dpi, dc)
struct d_print_info *dpi; struct d_print_info *dpi;
const struct d_comp *dc; const struct demangle_component *dc;
{ {
if (dc == NULL) if (dc == NULL)
{ {
...@@ -2783,15 +2782,15 @@ d_print_comp (dpi, dc) ...@@ -2783,15 +2782,15 @@ d_print_comp (dpi, dc)
switch (dc->type) switch (dc->type)
{ {
case D_COMP_NAME: case DEMANGLE_COMPONENT_NAME:
if ((dpi->options & DMGL_JAVA) == 0) if ((dpi->options & DMGL_JAVA) == 0)
d_append_buffer (dpi, dc->u.s_name.s, dc->u.s_name.len); d_append_buffer (dpi, dc->u.s_name.s, dc->u.s_name.len);
else else
d_print_java_identifier (dpi, dc->u.s_name.s, dc->u.s_name.len); d_print_java_identifier (dpi, dc->u.s_name.s, dc->u.s_name.len);
return; return;
case D_COMP_QUAL_NAME: case DEMANGLE_COMPONENT_QUAL_NAME:
case D_COMP_LOCAL_NAME: case DEMANGLE_COMPONENT_LOCAL_NAME:
d_print_comp (dpi, d_left (dc)); d_print_comp (dpi, d_left (dc));
if ((dpi->options & DMGL_JAVA) == 0) if ((dpi->options & DMGL_JAVA) == 0)
d_append_string_constant (dpi, "::"); d_append_string_constant (dpi, "::");
...@@ -2800,10 +2799,10 @@ d_print_comp (dpi, dc) ...@@ -2800,10 +2799,10 @@ d_print_comp (dpi, dc)
d_print_comp (dpi, d_right (dc)); d_print_comp (dpi, d_right (dc));
return; return;
case D_COMP_TYPED_NAME: case DEMANGLE_COMPONENT_TYPED_NAME:
{ {
struct d_print_mod *hold_modifiers; struct d_print_mod *hold_modifiers;
struct d_comp *typed_name; struct demangle_component *typed_name;
struct d_print_mod adpm[4]; struct d_print_mod adpm[4];
unsigned int i; unsigned int i;
struct d_print_template dpt; struct d_print_template dpt;
...@@ -2829,9 +2828,9 @@ d_print_comp (dpi, dc) ...@@ -2829,9 +2828,9 @@ d_print_comp (dpi, dc)
adpm[i].templates = dpi->templates; adpm[i].templates = dpi->templates;
++i; ++i;
if (typed_name->type != D_COMP_RESTRICT_THIS if (typed_name->type != DEMANGLE_COMPONENT_RESTRICT_THIS
&& typed_name->type != D_COMP_VOLATILE_THIS && typed_name->type != DEMANGLE_COMPONENT_VOLATILE_THIS
&& typed_name->type != D_COMP_CONST_THIS) && typed_name->type != DEMANGLE_COMPONENT_CONST_THIS)
break; break;
typed_name = d_left (typed_name); typed_name = d_left (typed_name);
...@@ -2839,25 +2838,25 @@ d_print_comp (dpi, dc) ...@@ -2839,25 +2838,25 @@ d_print_comp (dpi, dc)
/* If typed_name is a template, then it applies to the /* If typed_name is a template, then it applies to the
function type as well. */ function type as well. */
if (typed_name->type == D_COMP_TEMPLATE) if (typed_name->type == DEMANGLE_COMPONENT_TEMPLATE)
{ {
dpt.next = dpi->templates; dpt.next = dpi->templates;
dpi->templates = &dpt; dpi->templates = &dpt;
dpt.template = typed_name; dpt.template = typed_name;
} }
/* If typed_name is a D_COMP_LOCAL_NAME, then there may be /* If typed_name is a DEMANGLE_COMPONENT_LOCAL_NAME, then
CV-qualifiers on its right argument which really apply there may be CV-qualifiers on its right argument which
here; this happens when parsing a class which is local to a really apply here; this happens when parsing a class which
function. */ is local to a function. */
if (typed_name->type == D_COMP_LOCAL_NAME) if (typed_name->type == DEMANGLE_COMPONENT_LOCAL_NAME)
{ {
struct d_comp *local_name; struct demangle_component *local_name;
local_name = d_right (typed_name); local_name = d_right (typed_name);
while (local_name->type == D_COMP_RESTRICT_THIS while (local_name->type == DEMANGLE_COMPONENT_RESTRICT_THIS
|| local_name->type == D_COMP_VOLATILE_THIS || local_name->type == DEMANGLE_COMPONENT_VOLATILE_THIS
|| local_name->type == D_COMP_CONST_THIS) || local_name->type == DEMANGLE_COMPONENT_CONST_THIS)
{ {
if (i >= sizeof adpm / sizeof adpm[0]) if (i >= sizeof adpm / sizeof adpm[0])
{ {
...@@ -2880,7 +2879,7 @@ d_print_comp (dpi, dc) ...@@ -2880,7 +2879,7 @@ d_print_comp (dpi, dc)
d_print_comp (dpi, d_right (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; dpi->templates = dpt.next;
/* If the modifiers didn't get printed by the type, print them /* If the modifiers didn't get printed by the type, print them
...@@ -2900,7 +2899,7 @@ d_print_comp (dpi, dc) ...@@ -2900,7 +2899,7 @@ d_print_comp (dpi, dc)
return; return;
} }
case D_COMP_TEMPLATE: case DEMANGLE_COMPONENT_TEMPLATE:
{ {
struct d_print_mod *hold_dpm; struct d_print_mod *hold_dpm;
...@@ -2927,10 +2926,10 @@ d_print_comp (dpi, dc) ...@@ -2927,10 +2926,10 @@ d_print_comp (dpi, dc)
return; return;
} }
case D_COMP_TEMPLATE_PARAM: case DEMANGLE_COMPONENT_TEMPLATE_PARAM:
{ {
long i; long i;
struct d_comp *a; struct demangle_component *a;
struct d_print_template *hold_dpt; struct d_print_template *hold_dpt;
if (dpi->templates == NULL) if (dpi->templates == NULL)
...@@ -2943,7 +2942,7 @@ d_print_comp (dpi, dc) ...@@ -2943,7 +2942,7 @@ d_print_comp (dpi, dc)
a != NULL; a != NULL;
a = d_right (a)) a = d_right (a))
{ {
if (a->type != D_COMP_TEMPLATE_ARGLIST) if (a->type != DEMANGLE_COMPONENT_TEMPLATE_ARGLIST)
{ {
d_print_error (dpi); d_print_error (dpi);
return; return;
...@@ -2973,92 +2972,92 @@ d_print_comp (dpi, dc) ...@@ -2973,92 +2972,92 @@ d_print_comp (dpi, dc)
return; return;
} }
case D_COMP_CTOR: case DEMANGLE_COMPONENT_CTOR:
d_print_comp (dpi, dc->u.s_ctor.name); d_print_comp (dpi, dc->u.s_ctor.name);
return; return;
case D_COMP_DTOR: case DEMANGLE_COMPONENT_DTOR:
d_append_char (dpi, '~'); d_append_char (dpi, '~');
d_print_comp (dpi, dc->u.s_dtor.name); d_print_comp (dpi, dc->u.s_dtor.name);
return; return;
case D_COMP_VTABLE: case DEMANGLE_COMPONENT_VTABLE:
d_append_string_constant (dpi, "vtable for "); d_append_string_constant (dpi, "vtable for ");
d_print_comp (dpi, d_left (dc)); d_print_comp (dpi, d_left (dc));
return; return;
case D_COMP_VTT: case DEMANGLE_COMPONENT_VTT:
d_append_string_constant (dpi, "VTT for "); d_append_string_constant (dpi, "VTT for ");
d_print_comp (dpi, d_left (dc)); d_print_comp (dpi, d_left (dc));
return; return;
case D_COMP_CONSTRUCTION_VTABLE: case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE:
d_append_string_constant (dpi, "construction vtable for "); d_append_string_constant (dpi, "construction vtable for ");
d_print_comp (dpi, d_left (dc)); d_print_comp (dpi, d_left (dc));
d_append_string_constant (dpi, "-in-"); d_append_string_constant (dpi, "-in-");
d_print_comp (dpi, d_right (dc)); d_print_comp (dpi, d_right (dc));
return; return;
case D_COMP_TYPEINFO: case DEMANGLE_COMPONENT_TYPEINFO:
d_append_string_constant (dpi, "typeinfo for "); d_append_string_constant (dpi, "typeinfo for ");
d_print_comp (dpi, d_left (dc)); d_print_comp (dpi, d_left (dc));
return; return;
case D_COMP_TYPEINFO_NAME: case DEMANGLE_COMPONENT_TYPEINFO_NAME:
d_append_string_constant (dpi, "typeinfo name for "); d_append_string_constant (dpi, "typeinfo name for ");
d_print_comp (dpi, d_left (dc)); d_print_comp (dpi, d_left (dc));
return; return;
case D_COMP_TYPEINFO_FN: case DEMANGLE_COMPONENT_TYPEINFO_FN:
d_append_string_constant (dpi, "typeinfo fn for "); d_append_string_constant (dpi, "typeinfo fn for ");
d_print_comp (dpi, d_left (dc)); d_print_comp (dpi, d_left (dc));
return; return;
case D_COMP_THUNK: case DEMANGLE_COMPONENT_THUNK:
d_append_string_constant (dpi, "non-virtual thunk to "); d_append_string_constant (dpi, "non-virtual thunk to ");
d_print_comp (dpi, d_left (dc)); d_print_comp (dpi, d_left (dc));
return; return;
case D_COMP_VIRTUAL_THUNK: case DEMANGLE_COMPONENT_VIRTUAL_THUNK:
d_append_string_constant (dpi, "virtual thunk to "); d_append_string_constant (dpi, "virtual thunk to ");
d_print_comp (dpi, d_left (dc)); d_print_comp (dpi, d_left (dc));
return; return;
case D_COMP_COVARIANT_THUNK: case DEMANGLE_COMPONENT_COVARIANT_THUNK:
d_append_string_constant (dpi, "covariant return thunk to "); d_append_string_constant (dpi, "covariant return thunk to ");
d_print_comp (dpi, d_left (dc)); d_print_comp (dpi, d_left (dc));
return; return;
case D_COMP_JAVA_CLASS: case DEMANGLE_COMPONENT_JAVA_CLASS:
d_append_string_constant (dpi, "java Class for "); d_append_string_constant (dpi, "java Class for ");
d_print_comp (dpi, d_left (dc)); d_print_comp (dpi, d_left (dc));
return; return;
case D_COMP_GUARD: case DEMANGLE_COMPONENT_GUARD:
d_append_string_constant (dpi, "guard variable for "); d_append_string_constant (dpi, "guard variable for ");
d_print_comp (dpi, d_left (dc)); d_print_comp (dpi, d_left (dc));
return; return;
case D_COMP_REFTEMP: case DEMANGLE_COMPONENT_REFTEMP:
d_append_string_constant (dpi, "reference temporary for "); d_append_string_constant (dpi, "reference temporary for ");
d_print_comp (dpi, d_left (dc)); d_print_comp (dpi, d_left (dc));
return; 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); d_append_buffer (dpi, dc->u.s_string.string, dc->u.s_string.len);
return; return;
case D_COMP_RESTRICT: case DEMANGLE_COMPONENT_RESTRICT:
case D_COMP_VOLATILE: case DEMANGLE_COMPONENT_VOLATILE:
case D_COMP_CONST: case DEMANGLE_COMPONENT_CONST:
case D_COMP_RESTRICT_THIS: case DEMANGLE_COMPONENT_RESTRICT_THIS:
case D_COMP_VOLATILE_THIS: case DEMANGLE_COMPONENT_VOLATILE_THIS:
case D_COMP_CONST_THIS: case DEMANGLE_COMPONENT_CONST_THIS:
case D_COMP_VENDOR_TYPE_QUAL: case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
case D_COMP_POINTER: case DEMANGLE_COMPONENT_POINTER:
case D_COMP_REFERENCE: case DEMANGLE_COMPONENT_REFERENCE:
case D_COMP_COMPLEX: case DEMANGLE_COMPONENT_COMPLEX:
case D_COMP_IMAGINARY: case DEMANGLE_COMPONENT_IMAGINARY:
{ {
/* We keep a list of modifiers on the stack. */ /* We keep a list of modifiers on the stack. */
struct d_print_mod dpm; struct d_print_mod dpm;
...@@ -3081,7 +3080,7 @@ d_print_comp (dpi, dc) ...@@ -3081,7 +3080,7 @@ d_print_comp (dpi, dc)
return; return;
} }
case D_COMP_BUILTIN_TYPE: case DEMANGLE_COMPONENT_BUILTIN_TYPE:
if ((dpi->options & DMGL_JAVA) == 0) if ((dpi->options & DMGL_JAVA) == 0)
d_append_buffer (dpi, dc->u.s_builtin.type->name, d_append_buffer (dpi, dc->u.s_builtin.type->name,
dc->u.s_builtin.type->len); dc->u.s_builtin.type->len);
...@@ -3090,11 +3089,11 @@ d_print_comp (dpi, dc) ...@@ -3090,11 +3089,11 @@ d_print_comp (dpi, dc)
dc->u.s_builtin.type->java_len); dc->u.s_builtin.type->java_len);
return; return;
case D_COMP_VENDOR_TYPE: case DEMANGLE_COMPONENT_VENDOR_TYPE:
d_print_comp (dpi, d_left (dc)); d_print_comp (dpi, d_left (dc));
return; return;
case D_COMP_FUNCTION_TYPE: case DEMANGLE_COMPONENT_FUNCTION_TYPE:
{ {
if (d_left (dc) != NULL) if (d_left (dc) != NULL)
{ {
...@@ -3124,7 +3123,7 @@ d_print_comp (dpi, dc) ...@@ -3124,7 +3123,7 @@ d_print_comp (dpi, dc)
return; return;
} }
case D_COMP_ARRAY_TYPE: case DEMANGLE_COMPONENT_ARRAY_TYPE:
{ {
struct d_print_mod dpm; struct d_print_mod dpm;
...@@ -3149,7 +3148,7 @@ d_print_comp (dpi, dc) ...@@ -3149,7 +3148,7 @@ d_print_comp (dpi, dc)
return; return;
} }
case D_COMP_PTRMEM_TYPE: case DEMANGLE_COMPONENT_PTRMEM_TYPE:
{ {
struct d_print_mod dpm; struct d_print_mod dpm;
...@@ -3175,8 +3174,8 @@ d_print_comp (dpi, dc) ...@@ -3175,8 +3174,8 @@ d_print_comp (dpi, dc)
return; return;
} }
case D_COMP_ARGLIST: case DEMANGLE_COMPONENT_ARGLIST:
case D_COMP_TEMPLATE_ARGLIST: case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
d_print_comp (dpi, d_left (dc)); d_print_comp (dpi, d_left (dc));
if (d_right (dc) != NULL) if (d_right (dc) != NULL)
{ {
...@@ -3185,7 +3184,7 @@ d_print_comp (dpi, dc) ...@@ -3185,7 +3184,7 @@ d_print_comp (dpi, dc)
} }
return; return;
case D_COMP_OPERATOR: case DEMANGLE_COMPONENT_OPERATOR:
{ {
char c; char c;
...@@ -3198,18 +3197,18 @@ d_print_comp (dpi, dc) ...@@ -3198,18 +3197,18 @@ d_print_comp (dpi, dc)
return; return;
} }
case D_COMP_EXTENDED_OPERATOR: case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
d_append_string_constant (dpi, "operator "); d_append_string_constant (dpi, "operator ");
d_print_comp (dpi, dc->u.s_extended_operator.name); d_print_comp (dpi, dc->u.s_extended_operator.name);
return; return;
case D_COMP_CAST: case DEMANGLE_COMPONENT_CAST:
d_append_string_constant (dpi, "operator "); d_append_string_constant (dpi, "operator ");
d_print_cast (dpi, dc); d_print_cast (dpi, dc);
return; return;
case D_COMP_UNARY: case DEMANGLE_COMPONENT_UNARY:
if (d_left (dc)->type != D_COMP_CAST) if (d_left (dc)->type != DEMANGLE_COMPONENT_CAST)
d_print_expr_op (dpi, d_left (dc)); d_print_expr_op (dpi, d_left (dc));
else else
{ {
...@@ -3220,12 +3219,12 @@ d_print_comp (dpi, dc) ...@@ -3220,12 +3219,12 @@ d_print_comp (dpi, dc)
d_append_char (dpi, '('); d_append_char (dpi, '(');
d_print_comp (dpi, d_right (dc)); d_print_comp (dpi, d_right (dc));
d_append_char (dpi, ')'); d_append_char (dpi, ')');
if (d_left (dc)->type == D_COMP_CAST) if (d_left (dc)->type == DEMANGLE_COMPONENT_CAST)
d_append_char (dpi, ')'); d_append_char (dpi, ')');
return; return;
case D_COMP_BINARY: case DEMANGLE_COMPONENT_BINARY:
if (d_right (dc)->type != D_COMP_BINARY_ARGS) if (d_right (dc)->type != DEMANGLE_COMPONENT_BINARY_ARGS)
{ {
d_print_error (dpi); d_print_error (dpi);
return; return;
...@@ -3234,7 +3233,7 @@ d_print_comp (dpi, dc) ...@@ -3234,7 +3233,7 @@ d_print_comp (dpi, dc)
/* We wrap an expression which uses the greater-than operator in /* We wrap an expression which uses the greater-than operator in
an extra layer of parens so that it does not get confused an extra layer of parens so that it does not get confused
with the '>' which ends the template parameters. */ 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->len == 1
&& d_left (dc)->u.s_operator.op->name[0] == '>') && d_left (dc)->u.s_operator.op->name[0] == '>')
d_append_char (dpi, '('); d_append_char (dpi, '(');
...@@ -3247,21 +3246,21 @@ d_print_comp (dpi, dc) ...@@ -3247,21 +3246,21 @@ d_print_comp (dpi, dc)
d_print_comp (dpi, d_right (d_right (dc))); d_print_comp (dpi, d_right (d_right (dc)));
d_append_char (dpi, ')'); 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->len == 1
&& d_left (dc)->u.s_operator.op->name[0] == '>') && d_left (dc)->u.s_operator.op->name[0] == '>')
d_append_char (dpi, ')'); d_append_char (dpi, ')');
return; return;
case D_COMP_BINARY_ARGS: case DEMANGLE_COMPONENT_BINARY_ARGS:
/* We should only see this as part of D_COMP_BINARY. */ /* We should only see this as part of DEMANGLE_COMPONENT_BINARY. */
d_print_error (dpi); d_print_error (dpi);
return; return;
case D_COMP_TRINARY: case DEMANGLE_COMPONENT_TRINARY:
if (d_right (dc)->type != D_COMP_TRINARY_ARG1 if (d_right (dc)->type != DEMANGLE_COMPONENT_TRINARY_ARG1
|| d_right (d_right (dc))->type != D_COMP_TRINARY_ARG2) || d_right (d_right (dc))->type != DEMANGLE_COMPONENT_TRINARY_ARG2)
{ {
d_print_error (dpi); d_print_error (dpi);
return; return;
...@@ -3277,23 +3276,23 @@ d_print_comp (dpi, dc) ...@@ -3277,23 +3276,23 @@ d_print_comp (dpi, dc)
d_append_char (dpi, ')'); d_append_char (dpi, ')');
return; return;
case D_COMP_TRINARY_ARG1: case DEMANGLE_COMPONENT_TRINARY_ARG1:
case D_COMP_TRINARY_ARG2: case DEMANGLE_COMPONENT_TRINARY_ARG2:
/* We should only see these are part of D_COMP_TRINARY. */ /* We should only see these are part of DEMANGLE_COMPONENT_TRINARY. */
d_print_error (dpi); d_print_error (dpi);
return; return;
case D_COMP_LITERAL: case DEMANGLE_COMPONENT_LITERAL:
case D_COMP_LITERAL_NEG: case DEMANGLE_COMPONENT_LITERAL_NEG:
/* For some builtin types, produce simpler output. */ /* 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) switch (d_left (dc)->u.s_builtin.type->print)
{ {
case D_PRINT_INT: 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_append_char (dpi, '-');
d_print_comp (dpi, d_right (dc)); d_print_comp (dpi, d_right (dc));
return; return;
...@@ -3301,9 +3300,9 @@ d_print_comp (dpi, dc) ...@@ -3301,9 +3300,9 @@ d_print_comp (dpi, dc)
break; break;
case D_PRINT_LONG: 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_append_char (dpi, '-');
d_print_comp (dpi, d_right (dc)); d_print_comp (dpi, d_right (dc));
d_append_char (dpi, 'l'); d_append_char (dpi, 'l');
...@@ -3312,9 +3311,9 @@ d_print_comp (dpi, dc) ...@@ -3312,9 +3311,9 @@ d_print_comp (dpi, dc)
break; break;
case D_PRINT_BOOL: 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 && 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]) switch (d_right (dc)->u.s_name.s[0])
{ {
...@@ -3338,7 +3337,7 @@ d_print_comp (dpi, dc) ...@@ -3338,7 +3337,7 @@ d_print_comp (dpi, dc)
d_append_char (dpi, '('); d_append_char (dpi, '(');
d_print_comp (dpi, d_left (dc)); d_print_comp (dpi, d_left (dc));
d_append_char (dpi, ')'); d_append_char (dpi, ')');
if (dc->type == D_COMP_LITERAL_NEG) if (dc->type == DEMANGLE_COMPONENT_LITERAL_NEG)
d_append_char (dpi, '-'); d_append_char (dpi, '-');
d_print_comp (dpi, d_right (dc)); d_print_comp (dpi, d_right (dc));
return; return;
...@@ -3420,9 +3419,9 @@ d_print_mod_list (dpi, mods, suffix) ...@@ -3420,9 +3419,9 @@ d_print_mod_list (dpi, mods, suffix)
if (mods->printed if (mods->printed
|| (! suffix || (! suffix
&& (mods->mod->type == D_COMP_RESTRICT_THIS && (mods->mod->type == DEMANGLE_COMPONENT_RESTRICT_THIS
|| mods->mod->type == D_COMP_VOLATILE_THIS || mods->mod->type == DEMANGLE_COMPONENT_VOLATILE_THIS
|| mods->mod->type == D_COMP_CONST_THIS))) || mods->mod->type == DEMANGLE_COMPONENT_CONST_THIS)))
{ {
d_print_mod_list (dpi, mods->next, suffix); d_print_mod_list (dpi, mods->next, suffix);
return; return;
...@@ -3433,22 +3432,22 @@ d_print_mod_list (dpi, mods, suffix) ...@@ -3433,22 +3432,22 @@ d_print_mod_list (dpi, mods, suffix)
hold_dpt = dpi->templates; hold_dpt = dpi->templates;
dpi->templates = mods->templates; dpi->templates = mods->templates;
if (mods->mod->type == D_COMP_FUNCTION_TYPE) if (mods->mod->type == DEMANGLE_COMPONENT_FUNCTION_TYPE)
{ {
d_print_function_type (dpi, mods->mod, mods->next); d_print_function_type (dpi, mods->mod, mods->next);
dpi->templates = hold_dpt; dpi->templates = hold_dpt;
return; return;
} }
else if (mods->mod->type == D_COMP_ARRAY_TYPE) else if (mods->mod->type == DEMANGLE_COMPONENT_ARRAY_TYPE)
{ {
d_print_array_type (dpi, mods->mod, mods->next); d_print_array_type (dpi, mods->mod, mods->next);
dpi->templates = hold_dpt; dpi->templates = hold_dpt;
return; 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_print_mod *hold_modifiers;
struct d_comp *dc; struct demangle_component *dc;
/* When this is on the modifier stack, we have pulled any /* When this is on the modifier stack, we have pulled any
qualifiers off the right argument already. Otherwise, we qualifiers off the right argument already. Otherwise, we
...@@ -3466,9 +3465,9 @@ d_print_mod_list (dpi, mods, suffix) ...@@ -3466,9 +3465,9 @@ d_print_mod_list (dpi, mods, suffix)
d_append_char (dpi, '.'); d_append_char (dpi, '.');
dc = d_right (mods->mod); dc = d_right (mods->mod);
while (dc->type == D_COMP_RESTRICT_THIS while (dc->type == DEMANGLE_COMPONENT_RESTRICT_THIS
|| dc->type == D_COMP_VOLATILE_THIS || dc->type == DEMANGLE_COMPONENT_VOLATILE_THIS
|| dc->type == D_COMP_CONST_THIS) || dc->type == DEMANGLE_COMPONENT_CONST_THIS)
dc = d_left (dc); dc = d_left (dc);
d_print_comp (dpi, dc); d_print_comp (dpi, dc);
...@@ -3489,47 +3488,47 @@ d_print_mod_list (dpi, mods, suffix) ...@@ -3489,47 +3488,47 @@ d_print_mod_list (dpi, mods, suffix)
static void static void
d_print_mod (dpi, mod) d_print_mod (dpi, mod)
struct d_print_info *dpi; struct d_print_info *dpi;
const struct d_comp *mod; const struct demangle_component *mod;
{ {
switch (mod->type) switch (mod->type)
{ {
case D_COMP_RESTRICT: case DEMANGLE_COMPONENT_RESTRICT:
case D_COMP_RESTRICT_THIS: case DEMANGLE_COMPONENT_RESTRICT_THIS:
d_append_string_constant (dpi, " restrict"); d_append_string_constant (dpi, " restrict");
return; return;
case D_COMP_VOLATILE: case DEMANGLE_COMPONENT_VOLATILE:
case D_COMP_VOLATILE_THIS: case DEMANGLE_COMPONENT_VOLATILE_THIS:
d_append_string_constant (dpi, " volatile"); d_append_string_constant (dpi, " volatile");
return; return;
case D_COMP_CONST: case DEMANGLE_COMPONENT_CONST:
case D_COMP_CONST_THIS: case DEMANGLE_COMPONENT_CONST_THIS:
d_append_string_constant (dpi, " const"); d_append_string_constant (dpi, " const");
return; return;
case D_COMP_VENDOR_TYPE_QUAL: case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
d_append_char (dpi, ' '); d_append_char (dpi, ' ');
d_print_comp (dpi, d_right (mod)); d_print_comp (dpi, d_right (mod));
return; return;
case D_COMP_POINTER: case DEMANGLE_COMPONENT_POINTER:
/* There is no pointer symbol in Java. */ /* There is no pointer symbol in Java. */
if ((dpi->options & DMGL_JAVA) == 0) if ((dpi->options & DMGL_JAVA) == 0)
d_append_char (dpi, '*'); d_append_char (dpi, '*');
return; return;
case D_COMP_REFERENCE: case DEMANGLE_COMPONENT_REFERENCE:
d_append_char (dpi, '&'); d_append_char (dpi, '&');
return; return;
case D_COMP_COMPLEX: case DEMANGLE_COMPONENT_COMPLEX:
d_append_string_constant (dpi, "complex "); d_append_string_constant (dpi, "complex ");
return; return;
case D_COMP_IMAGINARY: case DEMANGLE_COMPONENT_IMAGINARY:
d_append_string_constant (dpi, "imaginary "); d_append_string_constant (dpi, "imaginary ");
return; return;
case D_COMP_PTRMEM_TYPE: case DEMANGLE_COMPONENT_PTRMEM_TYPE:
if (d_last_char (dpi) != '(') if (d_last_char (dpi) != '(')
d_append_char (dpi, ' '); d_append_char (dpi, ' ');
d_print_comp (dpi, d_left (mod)); d_print_comp (dpi, d_left (mod));
d_append_string_constant (dpi, "::*"); d_append_string_constant (dpi, "::*");
return; return;
case D_COMP_TYPED_NAME: case DEMANGLE_COMPONENT_TYPED_NAME:
d_print_comp (dpi, d_left (mod)); d_print_comp (dpi, d_left (mod));
return; return;
default: default:
...@@ -3545,7 +3544,7 @@ d_print_mod (dpi, mod) ...@@ -3545,7 +3544,7 @@ d_print_mod (dpi, mod)
static void static void
d_print_function_type (dpi, dc, mods) d_print_function_type (dpi, dc, mods)
struct d_print_info *dpi; struct d_print_info *dpi;
const struct d_comp *dc; const struct demangle_component *dc;
struct d_print_mod *mods; struct d_print_mod *mods;
{ {
int need_paren; int need_paren;
...@@ -3563,20 +3562,20 @@ d_print_function_type (dpi, dc, mods) ...@@ -3563,20 +3562,20 @@ d_print_function_type (dpi, dc, mods)
saw_mod = 1; saw_mod = 1;
switch (p->mod->type) switch (p->mod->type)
{ {
case D_COMP_RESTRICT: case DEMANGLE_COMPONENT_RESTRICT:
case D_COMP_VOLATILE: case DEMANGLE_COMPONENT_VOLATILE:
case D_COMP_CONST: case DEMANGLE_COMPONENT_CONST:
case D_COMP_VENDOR_TYPE_QUAL: case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
case D_COMP_POINTER: case DEMANGLE_COMPONENT_POINTER:
case D_COMP_REFERENCE: case DEMANGLE_COMPONENT_REFERENCE:
case D_COMP_COMPLEX: case DEMANGLE_COMPONENT_COMPLEX:
case D_COMP_IMAGINARY: case DEMANGLE_COMPONENT_IMAGINARY:
case D_COMP_PTRMEM_TYPE: case DEMANGLE_COMPONENT_PTRMEM_TYPE:
need_paren = 1; need_paren = 1;
break; break;
case D_COMP_RESTRICT_THIS: case DEMANGLE_COMPONENT_RESTRICT_THIS:
case D_COMP_VOLATILE_THIS: case DEMANGLE_COMPONENT_VOLATILE_THIS:
case D_COMP_CONST_THIS: case DEMANGLE_COMPONENT_CONST_THIS:
break; break;
default: default:
break; break;
...@@ -3630,7 +3629,7 @@ d_print_function_type (dpi, dc, mods) ...@@ -3630,7 +3629,7 @@ d_print_function_type (dpi, dc, mods)
static void static void
d_print_array_type (dpi, dc, mods) d_print_array_type (dpi, dc, mods)
struct d_print_info *dpi; struct d_print_info *dpi;
const struct d_comp *dc; const struct demangle_component *dc;
struct d_print_mod *mods; struct d_print_mod *mods;
{ {
int need_space; int need_space;
...@@ -3647,7 +3646,7 @@ d_print_array_type (dpi, dc, mods) ...@@ -3647,7 +3646,7 @@ d_print_array_type (dpi, dc, mods)
if (p->printed) if (p->printed)
break; break;
if (p->mod->type == D_COMP_ARRAY_TYPE) if (p->mod->type == DEMANGLE_COMPONENT_ARRAY_TYPE)
{ {
need_space = 0; need_space = 0;
break; break;
...@@ -3685,9 +3684,9 @@ d_print_array_type (dpi, dc, mods) ...@@ -3685,9 +3684,9 @@ d_print_array_type (dpi, dc, mods)
static void static void
d_print_expr_op (dpi, dc) d_print_expr_op (dpi, dc)
struct d_print_info *dpi; 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, d_append_buffer (dpi, dc->u.s_operator.op->name,
dc->u.s_operator.op->len); dc->u.s_operator.op->len);
else else
...@@ -3699,9 +3698,9 @@ d_print_expr_op (dpi, dc) ...@@ -3699,9 +3698,9 @@ d_print_expr_op (dpi, dc)
static void static void
d_print_cast (dpi, dc) d_print_cast (dpi, dc)
struct d_print_info *dpi; 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)); d_print_comp (dpi, d_left (dc));
else else
{ {
...@@ -3741,8 +3740,9 @@ d_print_cast (dpi, dc) ...@@ -3741,8 +3740,9 @@ d_print_cast (dpi, dc)
/* Initialize the information structure we use to pass around /* Initialize the information structure we use to pass around
information. */ information. */
static void CP_STATIC_IF_GLIBCPP_V3
d_init_info (mangled, options, len, di) void
cplus_demangle_init_info (mangled, options, len, di)
const char *mangled; const char *mangled;
int options; int options;
size_t len; size_t len;
...@@ -3787,7 +3787,7 @@ d_demangle (mangled, options, palc) ...@@ -3787,7 +3787,7 @@ d_demangle (mangled, options, palc)
size_t len; size_t len;
int type; int type;
struct d_info di; struct d_info di;
struct d_comp *dc; struct demangle_component *dc;
int estimate; int estimate;
char *ret; char *ret;
...@@ -3824,20 +3824,20 @@ d_demangle (mangled, options, palc) ...@@ -3824,20 +3824,20 @@ d_demangle (mangled, options, palc)
type = 1; type = 1;
} }
d_init_info (mangled, options, len, &di); cplus_demangle_init_info (mangled, options, len, &di);
{ {
#ifdef CP_DYNAMIC_ARRAYS #ifdef CP_DYNAMIC_ARRAYS
__extension__ struct d_comp comps[di.num_comps]; __extension__ struct demangle_component comps[di.num_comps];
__extension__ struct d_comp *subs[di.num_subs]; __extension__ struct demangle_component *subs[di.num_subs];
di.comps = &comps[0]; di.comps = &comps[0];
di.subs = &subs[0]; di.subs = &subs[0];
#else #else
di.comps = (struct d_comp *) malloc (di.num_comps di.comps = ((struct demangle_component *)
* sizeof (struct d_comp)); malloc (di.num_comps * sizeof (struct demangle_component)));
di.subs = (struct d_comp **) malloc (di.num_subs di.subs = ((struct demangle_component **)
* sizeof (struct d_comp *)); malloc (di.num_subs * sizeof (struct demangle_component *)));
if (di.comps == NULL || di.subs == NULL) if (di.comps == NULL || di.subs == NULL)
{ {
if (di.comps != NULL) if (di.comps != NULL)
...@@ -3850,9 +3850,9 @@ d_demangle (mangled, options, palc) ...@@ -3850,9 +3850,9 @@ d_demangle (mangled, options, palc)
#endif #endif
if (! type) if (! type)
dc = d_mangled_name (&di, 1); dc = cplus_demangle_mangled_name (&di, 1);
else else
dc = d_type (&di); dc = cplus_demangle_type (&di);
/* If DMGL_PARAMS is set, then if we didn't consume the entire /* If DMGL_PARAMS is set, then if we didn't consume the entire
mangled string, then we didn't successfully demangle it. If mangled string, then we didn't successfully demangle it. If
...@@ -3875,7 +3875,7 @@ d_demangle (mangled, options, palc) ...@@ -3875,7 +3875,7 @@ d_demangle (mangled, options, palc)
ret = NULL; ret = NULL;
if (dc != NULL) if (dc != NULL)
ret = d_print (options, dc, estimate, palc); ret = cplus_demangle_print (options, dc, estimate, palc);
#ifndef CP_DYNAMIC_ARRAYS #ifndef CP_DYNAMIC_ARRAYS
free (di.comps); free (di.comps);
...@@ -4076,26 +4076,26 @@ is_ctor_or_dtor (mangled, ctor_kind, dtor_kind) ...@@ -4076,26 +4076,26 @@ is_ctor_or_dtor (mangled, ctor_kind, dtor_kind)
enum gnu_v3_dtor_kinds *dtor_kind; enum gnu_v3_dtor_kinds *dtor_kind;
{ {
struct d_info di; struct d_info di;
struct d_comp *dc; struct demangle_component *dc;
int ret; int ret;
*ctor_kind = (enum gnu_v3_ctor_kinds) 0; *ctor_kind = (enum gnu_v3_ctor_kinds) 0;
*dtor_kind = (enum gnu_v3_dtor_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 #ifdef CP_DYNAMIC_ARRAYS
__extension__ struct d_comp comps[di.num_comps]; __extension__ struct demangle_component comps[di.num_comps];
__extension__ struct d_comp *subs[di.num_subs]; __extension__ struct demangle_component *subs[di.num_subs];
di.comps = &comps[0]; di.comps = &comps[0];
di.subs = &subs[0]; di.subs = &subs[0];
#else #else
di.comps = (struct d_comp *) malloc (di.num_comps di.comps = ((struct demangle_component *)
* sizeof (struct d_comp)); malloc (di.num_comps * sizeof (struct demangle_component)));
di.subs = (struct d_comp **) malloc (di.num_subs di.subs = ((struct demangle_component **)
* sizeof (struct d_comp *)); malloc (di.num_subs * sizeof (struct demangle_component *)));
if (di.comps == NULL || di.subs == NULL) if (di.comps == NULL || di.subs == NULL)
{ {
if (di.comps != NULL) if (di.comps != NULL)
...@@ -4106,7 +4106,7 @@ is_ctor_or_dtor (mangled, ctor_kind, dtor_kind) ...@@ -4106,7 +4106,7 @@ is_ctor_or_dtor (mangled, ctor_kind, dtor_kind)
} }
#endif #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 /* Note that because we did not pass DMGL_PARAMS, we don't expect
to demangle the entire string. */ to demangle the entire string. */
...@@ -4119,23 +4119,23 @@ is_ctor_or_dtor (mangled, ctor_kind, dtor_kind) ...@@ -4119,23 +4119,23 @@ is_ctor_or_dtor (mangled, ctor_kind, dtor_kind)
default: default:
dc = NULL; dc = NULL;
break; break;
case D_COMP_TYPED_NAME: case DEMANGLE_COMPONENT_TYPED_NAME:
case D_COMP_TEMPLATE: case DEMANGLE_COMPONENT_TEMPLATE:
case D_COMP_RESTRICT_THIS: case DEMANGLE_COMPONENT_RESTRICT_THIS:
case D_COMP_VOLATILE_THIS: case DEMANGLE_COMPONENT_VOLATILE_THIS:
case D_COMP_CONST_THIS: case DEMANGLE_COMPONENT_CONST_THIS:
dc = d_left (dc); dc = d_left (dc);
break; break;
case D_COMP_QUAL_NAME: case DEMANGLE_COMPONENT_QUAL_NAME:
case D_COMP_LOCAL_NAME: case DEMANGLE_COMPONENT_LOCAL_NAME:
dc = d_right (dc); dc = d_right (dc);
break; break;
case D_COMP_CTOR: case DEMANGLE_COMPONENT_CTOR:
*ctor_kind = dc->u.s_ctor.kind; *ctor_kind = dc->u.s_ctor.kind;
ret = 1; ret = 1;
dc = NULL; dc = NULL;
break; break;
case D_COMP_DTOR: case DEMANGLE_COMPONENT_DTOR:
*dtor_kind = dc->u.s_dtor.kind; *dtor_kind = dc->u.s_dtor.kind;
ret = 1; ret = 1;
dc = NULL; dc = NULL;
......
libiberty/cp-demangle.h 0 → 100644
/* Internal demangler interface for g++ V3 ABI.
Copyright (C) 2003, 2004 Free Software Foundation, Inc.
Written by Ian Lance Taylor <ian@wasabisystems.com>.
This file is part of the libiberty library, which is part of GCC.
This file is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
In addition to the permissions in the GNU General Public License, the
Free Software Foundation gives you unlimited permission to link the
compiled version of this file into combinations with other programs,
and to distribute those combinations without any restriction coming
from the use of this file. (The General Public License restrictions
do apply in other respects; for example, they cover modification of
the file, and distribution when not linked into a combined
executable.)
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 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 *));
libiberty/cp-demint.c 0 → 100644
/* Demangler component interface functions.
Copyright (C) 2004 Free Software Foundation, Inc.
Written by Ian Lance Taylor <ian@wasabisystems.com>.
This file is part of the libiberty library, which is part of GCC.
This file is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
In addition to the permissions in the GNU General Public License, the
Free Software Foundation gives you unlimited permission to link the
compiled version of this file into combinations with other programs,
and to distribute those combinations without any restriction coming
from the use of this file. (The General Public License restrictions
do apply in other respects; for example, they cover modification of
the file, and distribution when not linked into a combined
executable.)
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 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 <stdlib.h>
#endif
#ifdef HAVE_STRING_H
#include <string.h>
#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;
}
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment