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
This commit is contained in:
Ian Lance Taylor
Ian Lance Taylor
parent
5c88165592
commit
5e777af517
|
|
@ -1,3 +1,18 @@
|
|||
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>
|
||||
|
||||
* include/fibheap.h (fibnode): Use __extension__ for
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
/* Defs for interface to demanglers.
|
||||
Copyright 1992, 1993, 1994, 1995, 1996, 1997, 1998, 2000, 2001, 2002
|
||||
Free Software Foundation, Inc.
|
||||
Copyright 1992, 1993, 1994, 1995, 1996, 1997, 1998, 2000, 2001, 2002,
|
||||
2003, 2004 Free Software Foundation, Inc.
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
|
|
@ -164,6 +164,368 @@ enum gnu_v3_dtor_kinds {
|
|||
extern enum gnu_v3_dtor_kinds
|
||||
is_gnu_v3_mangled_dtor PARAMS ((const char *name));
|
||||
|
||||
/* The V3 demangler works in two passes. The first pass builds a tree
|
||||
representation of the mangled name, and the second pass turns the
|
||||
tree representation into a demangled string. Here we define an
|
||||
interface to permit a caller to build their own tree
|
||||
representation, which they can pass to the demangler to get a
|
||||
demangled string. This can be used to canonicalize user input into
|
||||
something which the demangler might output. It could also be used
|
||||
by other demanglers in the future. */
|
||||
|
||||
/* These are the component types which may be found in the tree. Many
|
||||
component types have one or two subtrees, referred to as left and
|
||||
right (a component type with only one subtree puts it in the left
|
||||
subtree). */
|
||||
|
||||
enum demangle_component_type
|
||||
{
|
||||
/* A name, with a length and a pointer to a string. */
|
||||
DEMANGLE_COMPONENT_NAME,
|
||||
/* A qualified name. The left subtree is a class or namespace or
|
||||
some such thing, and the right subtree is a name qualified by
|
||||
that class. */
|
||||
DEMANGLE_COMPONENT_QUAL_NAME,
|
||||
/* A local name. The left subtree describes a function, and the
|
||||
right subtree is a name which is local to that function. */
|
||||
DEMANGLE_COMPONENT_LOCAL_NAME,
|
||||
/* A typed name. The left subtree is a name, and the right subtree
|
||||
describes that name as a function. */
|
||||
DEMANGLE_COMPONENT_TYPED_NAME,
|
||||
/* A template. The left subtree is a template name, and the right
|
||||
subtree is a template argument list. */
|
||||
DEMANGLE_COMPONENT_TEMPLATE,
|
||||
/* A template parameter. This holds a number, which is the template
|
||||
parameter index. */
|
||||
DEMANGLE_COMPONENT_TEMPLATE_PARAM,
|
||||
/* A constructor. This holds a name and the kind of
|
||||
constructor. */
|
||||
DEMANGLE_COMPONENT_CTOR,
|
||||
/* A destructor. This holds a name and the kind of destructor. */
|
||||
DEMANGLE_COMPONENT_DTOR,
|
||||
/* A vtable. This has one subtree, the type for which this is a
|
||||
vtable. */
|
||||
DEMANGLE_COMPONENT_VTABLE,
|
||||
/* A VTT structure. This has one subtree, the type for which this
|
||||
is a VTT. */
|
||||
DEMANGLE_COMPONENT_VTT,
|
||||
/* A construction vtable. The left subtree is the type for which
|
||||
this is a vtable, and the right subtree is the derived type for
|
||||
which this vtable is built. */
|
||||
DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE,
|
||||
/* A typeinfo structure. This has one subtree, the type for which
|
||||
this is the tpeinfo structure. */
|
||||
DEMANGLE_COMPONENT_TYPEINFO,
|
||||
/* A typeinfo name. This has one subtree, the type for which this
|
||||
is the typeinfo name. */
|
||||
DEMANGLE_COMPONENT_TYPEINFO_NAME,
|
||||
/* A typeinfo function. This has one subtree, the type for which
|
||||
this is the tpyeinfo function. */
|
||||
DEMANGLE_COMPONENT_TYPEINFO_FN,
|
||||
/* A thunk. This has one subtree, the name for which this is a
|
||||
thunk. */
|
||||
DEMANGLE_COMPONENT_THUNK,
|
||||
/* A virtual thunk. This has one subtree, the name for which this
|
||||
is a virtual thunk. */
|
||||
DEMANGLE_COMPONENT_VIRTUAL_THUNK,
|
||||
/* A covariant thunk. This has one subtree, the name for which this
|
||||
is a covariant thunk. */
|
||||
DEMANGLE_COMPONENT_COVARIANT_THUNK,
|
||||
/* A Java class. This has one subtree, the type. */
|
||||
DEMANGLE_COMPONENT_JAVA_CLASS,
|
||||
/* A guard variable. This has one subtree, the name for which this
|
||||
is a guard variable. */
|
||||
DEMANGLE_COMPONENT_GUARD,
|
||||
/* A reference temporary. This has one subtree, the name for which
|
||||
this is a temporary. */
|
||||
DEMANGLE_COMPONENT_REFTEMP,
|
||||
/* A standard substitution. This holds the name of the
|
||||
substitution. */
|
||||
DEMANGLE_COMPONENT_SUB_STD,
|
||||
/* The restrict qualifier. The one subtree is the type which is
|
||||
being qualified. */
|
||||
DEMANGLE_COMPONENT_RESTRICT,
|
||||
/* The volatile qualifier. The one subtree is the type which is
|
||||
being qualified. */
|
||||
DEMANGLE_COMPONENT_VOLATILE,
|
||||
/* The const qualifier. The one subtree is the type which is being
|
||||
qualified. */
|
||||
DEMANGLE_COMPONENT_CONST,
|
||||
/* The restrict qualifier modifying a member function. The one
|
||||
subtree is the type which is being qualified. */
|
||||
DEMANGLE_COMPONENT_RESTRICT_THIS,
|
||||
/* The volatile qualifier modifying a member function. The one
|
||||
subtree is the type which is being qualified. */
|
||||
DEMANGLE_COMPONENT_VOLATILE_THIS,
|
||||
/* The const qualifier modifying a member function. The one subtree
|
||||
is the type which is being qualified. */
|
||||
DEMANGLE_COMPONENT_CONST_THIS,
|
||||
/* A vendor qualifier. The left subtree is the type which is being
|
||||
qualified, and the right subtree is the name of the
|
||||
qualifier. */
|
||||
DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL,
|
||||
/* A pointer. The one subtree is the type which is being pointed
|
||||
to. */
|
||||
DEMANGLE_COMPONENT_POINTER,
|
||||
/* A reference. The one subtree is the type which is being
|
||||
referenced. */
|
||||
DEMANGLE_COMPONENT_REFERENCE,
|
||||
/* A complex type. The one subtree is the base type. */
|
||||
DEMANGLE_COMPONENT_COMPLEX,
|
||||
/* An imaginary type. The one subtree is the base type. */
|
||||
DEMANGLE_COMPONENT_IMAGINARY,
|
||||
/* A builtin type. This holds the builtin type information. */
|
||||
DEMANGLE_COMPONENT_BUILTIN_TYPE,
|
||||
/* A vendor's builtin type. This holds the name of the type. */
|
||||
DEMANGLE_COMPONENT_VENDOR_TYPE,
|
||||
/* A function type. The left subtree is the return type. The right
|
||||
subtree is a list of ARGLIST nodes. Either or both may be
|
||||
NULL. */
|
||||
DEMANGLE_COMPONENT_FUNCTION_TYPE,
|
||||
/* An array type. The left subtree is the dimension, which may be
|
||||
NULL, or a string (represented as DEMANGLE_COMPONENT_NAME), or an
|
||||
expression. The right subtree is the element type. */
|
||||
DEMANGLE_COMPONENT_ARRAY_TYPE,
|
||||
/* A pointer to member type. The left subtree is the class type,
|
||||
and the right subtree is the member type. CV-qualifiers appear
|
||||
on the latter. */
|
||||
DEMANGLE_COMPONENT_PTRMEM_TYPE,
|
||||
/* An argument list. The left subtree is the current argument, and
|
||||
the right subtree is either NULL or another ARGLIST node. */
|
||||
DEMANGLE_COMPONENT_ARGLIST,
|
||||
/* A template argument list. The left subtree is the current
|
||||
template argument, and the right subtree is either NULL or
|
||||
another TEMPLATE_ARGLIST node. */
|
||||
DEMANGLE_COMPONENT_TEMPLATE_ARGLIST,
|
||||
/* An operator. This holds information about a standard
|
||||
operator. */
|
||||
DEMANGLE_COMPONENT_OPERATOR,
|
||||
/* An extended operator. This holds the number of arguments, and
|
||||
the name of the extended operator. */
|
||||
DEMANGLE_COMPONENT_EXTENDED_OPERATOR,
|
||||
/* A typecast, represented as a unary operator. The one subtree is
|
||||
the type to which the argument should be cast. */
|
||||
DEMANGLE_COMPONENT_CAST,
|
||||
/* A unary expression. The left subtree is the operator, and the
|
||||
right subtree is the single argument. */
|
||||
DEMANGLE_COMPONENT_UNARY,
|
||||
/* A binary expression. The left subtree is the operator, and the
|
||||
right subtree is a BINARY_ARGS. */
|
||||
DEMANGLE_COMPONENT_BINARY,
|
||||
/* Arguments to a binary expression. The left subtree is the first
|
||||
argument, and the right subtree is the second argument. */
|
||||
DEMANGLE_COMPONENT_BINARY_ARGS,
|
||||
/* A trinary expression. The left subtree is the operator, and the
|
||||
right subtree is a TRINARY_ARG1. */
|
||||
DEMANGLE_COMPONENT_TRINARY,
|
||||
/* Arguments to a trinary expression. The left subtree is the first
|
||||
argument, and the right subtree is a TRINARY_ARG2. */
|
||||
DEMANGLE_COMPONENT_TRINARY_ARG1,
|
||||
/* More arguments to a trinary expression. The left subtree is the
|
||||
second argument, and the right subtree is the third argument. */
|
||||
DEMANGLE_COMPONENT_TRINARY_ARG2,
|
||||
/* A literal. The left subtree is the type, and the right subtree
|
||||
is the value, represented as a DEMANGLE_COMPONENT_NAME. */
|
||||
DEMANGLE_COMPONENT_LITERAL,
|
||||
/* A negative literal. Like LITERAL, but the value is negated.
|
||||
This is a minor hack: the NAME used for LITERAL points directly
|
||||
to the mangled string, but since negative numbers are mangled
|
||||
using 'n' instead of '-', we want a way to indicate a negative
|
||||
number which involves neither modifying the mangled string nor
|
||||
allocating a new copy of the literal in memory. */
|
||||
DEMANGLE_COMPONENT_LITERAL_NEG
|
||||
};
|
||||
|
||||
/* Types which are only used internally. */
|
||||
|
||||
struct demangle_operator_info;
|
||||
struct demangle_builtin_type_info;
|
||||
|
||||
/* A node in the tree representation is an instance of a struct
|
||||
demangle_component. Note that the field names of the struct are
|
||||
not well protected against macros defined by the file including
|
||||
this one. We can fix this if it ever becomes a problem. */
|
||||
|
||||
struct demangle_component
|
||||
{
|
||||
/* The type of this component. */
|
||||
enum demangle_component_type type;
|
||||
|
||||
union
|
||||
{
|
||||
/* For DEMANGLE_COMPONENT_NAME. */
|
||||
struct
|
||||
{
|
||||
/* A pointer to the name (which need not NULL terminated) and
|
||||
its length. */
|
||||
const char *s;
|
||||
int len;
|
||||
} s_name;
|
||||
|
||||
/* For DEMANGLE_COMPONENT_OPERATOR. */
|
||||
struct
|
||||
{
|
||||
/* Operator. */
|
||||
const struct demangle_operator_info *op;
|
||||
} s_operator;
|
||||
|
||||
/* For DEMANGLE_COMPONENT_EXTENDED_OPERATOR. */
|
||||
struct
|
||||
{
|
||||
/* Number of arguments. */
|
||||
int args;
|
||||
/* Name. */
|
||||
struct demangle_component *name;
|
||||
} s_extended_operator;
|
||||
|
||||
/* For DEMANGLE_COMPONENT_CTOR. */
|
||||
struct
|
||||
{
|
||||
/* Kind of constructor. */
|
||||
enum gnu_v3_ctor_kinds kind;
|
||||
/* Name. */
|
||||
struct demangle_component *name;
|
||||
} s_ctor;
|
||||
|
||||
/* For DEMANGLE_COMPONENT_DTOR. */
|
||||
struct
|
||||
{
|
||||
/* Kind of destructor. */
|
||||
enum gnu_v3_dtor_kinds kind;
|
||||
/* Name. */
|
||||
struct demangle_component *name;
|
||||
} s_dtor;
|
||||
|
||||
/* For DEMANGLE_COMPONENT_BUILTIN_TYPE. */
|
||||
struct
|
||||
{
|
||||
/* Builtin type. */
|
||||
const struct demangle_builtin_type_info *type;
|
||||
} s_builtin;
|
||||
|
||||
/* For DEMANGLE_COMPONENT_SUB_STD. */
|
||||
struct
|
||||
{
|
||||
/* Standard substitution string. */
|
||||
const char* string;
|
||||
/* Length of string. */
|
||||
int len;
|
||||
} s_string;
|
||||
|
||||
/* For DEMANGLE_COMPONENT_TEMPLATE_PARAM. */
|
||||
struct
|
||||
{
|
||||
/* Template parameter index. */
|
||||
long number;
|
||||
} s_number;
|
||||
|
||||
/* For other types. */
|
||||
struct
|
||||
{
|
||||
/* Left (or only) subtree. */
|
||||
struct demangle_component *left;
|
||||
/* Right subtree. */
|
||||
struct demangle_component *right;
|
||||
} s_binary;
|
||||
|
||||
} u;
|
||||
};
|
||||
|
||||
/* People building mangled trees are expected to allocate instances of
|
||||
struct demangle_component themselves. They can then call one of
|
||||
the following functions to fill them in. */
|
||||
|
||||
/* Fill in most component types with a left subtree and a right
|
||||
subtree. Returns non-zero on success, zero on failure, such as an
|
||||
unrecognized or inappropriate component type. */
|
||||
|
||||
extern int
|
||||
cplus_demangle_fill_component PARAMS ((struct demangle_component *fill,
|
||||
enum demangle_component_type,
|
||||
struct demangle_component *left,
|
||||
struct demangle_component *right));
|
||||
|
||||
/* Fill in a DEMANGLE_COMPONENT_NAME. Returns non-zero on success,
|
||||
zero for bad arguments. */
|
||||
|
||||
extern int
|
||||
cplus_demangle_fill_name PARAMS ((struct demangle_component *fill,
|
||||
const char *, int));
|
||||
|
||||
/* Fill in a DEMANGLE_COMPONENT_BUILTIN_TYPE, using the name of the
|
||||
builtin type (e.g., "int", etc.). Returns non-zero on success,
|
||||
zero if the type is not recognized. */
|
||||
|
||||
extern int
|
||||
cplus_demangle_fill_builtin_type PARAMS ((struct demangle_component *fill,
|
||||
const char *typename));
|
||||
|
||||
/* Fill in a DEMANGLE_COMPONENT_OPERATOR, using the name of the
|
||||
operator and the number of arguments which it takes (the latter is
|
||||
used to disambiguate operators which can be both binary and unary,
|
||||
such as '-'). Returns non-zero on success, zero if the operator is
|
||||
not recognized. */
|
||||
|
||||
extern int
|
||||
cplus_demangle_fill_operator PARAMS ((struct demangle_component *fill,
|
||||
const char *opname, int args));
|
||||
|
||||
/* Fill in a DEMANGLE_COMPONENT_EXTENDED_OPERATOR, providing the
|
||||
number of arguments and the name. Returns non-zero on success,
|
||||
zero for bad arguments. */
|
||||
|
||||
extern int
|
||||
cplus_demangle_fill_extended_operator PARAMS ((struct demangle_component *fill,
|
||||
int numargs,
|
||||
struct demangle_component *nm));
|
||||
|
||||
/* Fill in a DEMANGLE_COMPONENT_CTOR. Returns non-zero on success,
|
||||
zero for bad arguments. */
|
||||
|
||||
extern int
|
||||
cplus_demangle_fill_ctor PARAMS ((struct demangle_component *fill,
|
||||
enum gnu_v3_ctor_kinds kind,
|
||||
struct demangle_component *name));
|
||||
|
||||
/* Fill in a DEMANGLE_COMPONENT_DTOR. Returns non-zero on success,
|
||||
zero for bad arguments. */
|
||||
|
||||
extern int
|
||||
cplus_demangle_fill_dtor PARAMS ((struct demangle_component *fill,
|
||||
enum gnu_v3_dtor_kinds kind,
|
||||
struct demangle_component *name));
|
||||
|
||||
/* This function translates a mangled name into a struct
|
||||
demangle_component tree. The first argument is the mangled name.
|
||||
The second argument is DMGL_* options. This returns a pointer to a
|
||||
tree on success, or NULL on failure. On success, the third
|
||||
argument is set to a block of memory allocated by malloc. This
|
||||
block should be passed to free when the tree is no longer
|
||||
needed. */
|
||||
|
||||
extern struct demangle_component *
|
||||
cplus_demangle_v3_components PARAMS ((const char *mangled,
|
||||
int options,
|
||||
void **mem));
|
||||
|
||||
/* This function takes a struct demangle_component tree and returns
|
||||
the corresponding demangled string. The first argument is DMGL_*
|
||||
options. The second is the tree to demangle. The third is a guess
|
||||
at the length of the demangled string, used to initially allocate
|
||||
the return buffer. The fourth is a pointer to a size_t. On
|
||||
success, this function returns a buffer allocated by malloc(), and
|
||||
sets the size_t pointed to by the fourth argument to the size of
|
||||
the allocated buffer (not the length of the returned string). On
|
||||
failure, this function returns NULL, and sets the size_t pointed to
|
||||
by the fourth argument to 0 for an invalid tree, or to 1 for a
|
||||
memory allocation error. */
|
||||
|
||||
extern char *
|
||||
cplus_demangle_print PARAMS ((int options,
|
||||
const struct demangle_component *tree,
|
||||
int estimated_length,
|
||||
size_t *p_allocated_size));
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif /* __cplusplus */
|
||||
|
|
|
|||
|
|
@ -1,3 +1,49 @@
|
|||
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>
|
||||
|
||||
* configure.in: Rename file to ...
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
#
|
||||
# Makefile
|
||||
# Copyright (C) 1990, 91-99, 2000, 2001, 2002, 2003
|
||||
# Copyright (C) 1990, 91-99, 2000, 2001, 2002, 2003, 2004
|
||||
# Free Software Foundation
|
||||
#
|
||||
# This file is part of the libiberty library.
|
||||
|
|
@ -130,7 +130,7 @@ COMPILE.c = $(CC) -c @DEFS@ $(LIBCFLAGS) -I. -I$(INCDIR) $(HDEFINES) @ac_libiber
|
|||
CFILES = alloca.c argv.c asprintf.c atexit.c \
|
||||
basename.c bcmp.c bcopy.c bsearch.c bzero.c \
|
||||
calloc.c choose-temp.c clock.c concat.c cp-demangle.c \
|
||||
cplus-dem.c \
|
||||
cp-demint.c cplus-dem.c \
|
||||
dyn-string.c \
|
||||
fdmatch.c ffs.c fibheap.c floatformat.c fnmatch.c \
|
||||
getcwd.c getopt.c getopt1.c getpagesize.c getpwd.c getruntime.c \
|
||||
|
|
@ -158,7 +158,7 @@ CFILES = alloca.c argv.c asprintf.c atexit.c \
|
|||
|
||||
# These are always included in the library. The first four are listed
|
||||
# first and by compile time to optimize parallel builds.
|
||||
REQUIRED_OFILES = regex.o cplus-dem.o cp-demangle.o md5.o \
|
||||
REQUIRED_OFILES = regex.o cplus-dem.o cp-demangle.o cp-demint.o md5.o \
|
||||
alloca.o argv.o \
|
||||
choose-temp.o concat.o \
|
||||
dyn-string.o \
|
||||
|
|
@ -428,8 +428,11 @@ choose-temp.o: config.h $(INCDIR)/ansidecl.h $(INCDIR)/libiberty.h
|
|||
clock.o: config.h
|
||||
concat.o: config.h $(INCDIR)/ansidecl.h $(INCDIR)/libiberty.h
|
||||
copysign.o: $(INCDIR)/ansidecl.h
|
||||
cp-demangle.o: config.h $(INCDIR)/ansidecl.h $(INCDIR)/demangle.h \
|
||||
$(INCDIR)/dyn-string.h $(INCDIR)/getopt.h $(INCDIR)/libiberty.h
|
||||
cp-demangle.o: config.h $(INCDIR)/ansidecl.h $(srcdir)/cp-demangle.h \
|
||||
$(INCDIR)/demangle.h $(INCDIR)/dyn-string.h $(INCDIR)/getopt.h \
|
||||
$(INCDIR)/libiberty.h
|
||||
cp-demint.o: config.h $(INCDIR)/ansidecl.h $(srcdir)/cp-demangle.h \
|
||||
$(INCDIR)/demangle.h $(INCDIR)/libiberty.h
|
||||
cplus-dem.o: config.h $(INCDIR)/ansidecl.h $(INCDIR)/demangle.h \
|
||||
$(INCDIR)/libiberty.h $(INCDIR)/safe-ctype.h
|
||||
dyn-string.o: config.h $(INCDIR)/ansidecl.h $(INCDIR)/dyn-string.h \
|
||||
|
|
@ -450,8 +453,8 @@ hashtab.o: config.h $(INCDIR)/ansidecl.h $(INCDIR)/hashtab.h \
|
|||
$(INCDIR)/libiberty.h
|
||||
hex.o: $(INCDIR)/ansidecl.h $(INCDIR)/libiberty.h \
|
||||
$(INCDIR)/safe-ctype.h
|
||||
lbasename.o: $(INCDIR)/ansidecl.h $(INCDIR)/libiberty.h \
|
||||
$(INCDIR)/safe-ctype.h $(INCDIR)/filenames.h
|
||||
lbasename.o: $(INCDIR)/ansidecl.h $(INCDIR)/filenames.h \
|
||||
$(INCDIR)/libiberty.h $(INCDIR)/safe-ctype.h
|
||||
lrealpath.o: config.h $(INCDIR)/ansidecl.h $(INCDIR)/libiberty.h
|
||||
make-relative-prefix.o: config.h $(INCDIR)/ansidecl.h \
|
||||
$(INCDIR)/libiberty.h
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,139 @@
|
|||
/* 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 *));
|
||||
|
|
@ -0,0 +1,241 @@
|
|||
/* 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;
|
||||
}
|
||||
Loading…
Reference in New Issue