OSDN Git Service

* demangle.h (enum demangle_component_type): Define.
authorian <ian@138bc75d-0d04-0410-961f-82ee72b054a4>
Mon, 12 Jan 2004 19:46:31 +0000 (19:46 +0000)
committerian <ian@138bc75d-0d04-0410-961f-82ee72b054a4>
Mon, 12 Jan 2004 19:46:31 +0000 (19:46 +0000)
(struct demangle_operator_info): Declare.
(struct demangle_builtin_type_info): Declare.
(struct demangle_component): Define.
(cplus_demangle_fill_component): Declare.
(cplus_demangle_fill_name): Declare.
(cplus_demangle_fill_builtin_type): Declare.
(cplus_demangle_fill_operator): Declare.
(cplus_demangle_fill_extended_operator): Declare.
(cplus_demangle_fill_ctor, cplus_demangle_fill_dtor): Declare.
(cplus_demangle_v3_components): Declare.
(cplus_demangle_print): Declare.

* cp-demangle.c: Include "cp-demangle.h".  If IN_GLIBCPP_V3 is
defined, rename some functions which are to become static via
#define.
(CP_STATIC_IF_GLIBCPP_V3): Define.
(struct d_operator_info): Move definition to cp-demangle.h, and
rename to demangle_operator_info.  Change all uses.
(enum d_builtin_type_print): Move definition to cp-demangle.h.
(struct d_builtin_type_info): Move definition to cp-demangle.h,
and rename to demangle_builtin_type_info.  Change all uses.
(enum d_comp_type): Move definition to include/demangle.h, and
rename to demangle_component_type, and change all enums to start
with DEMANGLE_COMPONENT_ instead of D_.  Change all uses.
(struct d_comp): Move definition to include/demangle.h, and rename
to demangle_component.  Change all uses.
(struct d_info): Move definition to cp-demangle.h.
(cplus_demangle_fill_name): New function.
(cplus_demangle_fill_extended_operator): New function.
(cplus_demangle_fill_ctor): New function.
(cplus_demangle_fill_dtor): New function.
(d_make_empty): Remove type parameter.  Change all callers.
(d_make_name): Use cplus_demangle_fill_name.
(d_make_extended_operator): Use
cplus_demangle_fill_extended_operator.
(d_make_ctor): Use cplus_demangle_fill_ctor.
(d_make_dtor): Use cplus_demangle_fill_dtor.
(cplus_demangle_mangled_name): Rename from d_mangled_name.  Make
non-static by default.  Change all callers.
(cplus_demangle_operators): Rename from d_operators.  Change all
uses.  Make non-static by default.  Add sentinel at end of array.
(d_operator_name): Adjust initialization of high for new sentinel
in cplus_demangle_operators.
(cplus_demangle_builtin_types): Rename from d_builtin_types.
Change all uses.  Make non-static by default.  Change initializer
to use D_BUILTIN_TYPE_COUNT instead of magic number 26.
(cplus_demangle_type): Rename from d_type.  Make non-static by
default.  Change all callers.
(cplus_demangle_init_info): Rename from d_init_info.  Make
non-static by default.  Change all callers.
* cp-demangle.h: New file.
* cp-demint.c: New file.
* Makefile.in: Rebuild dependencies.
(CFILES): Add cp-demint.c.
(REQUIRED_OFILES): Add cp-demint.o.

git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@75748 138bc75d-0d04-0410-961f-82ee72b054a4

include/ChangeLog
include/demangle.h
libiberty/ChangeLog
libiberty/Makefile.in
libiberty/cp-demangle.c
libiberty/cp-demangle.h [new file with mode: 0644]
libiberty/cp-demint.c [new file with mode: 0644]

index 69db5b7..2e291cc 100644 (file)
@@ -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
index bff2669..c3fdb03 100644 (file)
@@ -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 */
index 25f563a..9bc2903 100644 (file)
@@ -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 ...
index 0e1c8f2..139cb68 100644 (file)
@@ -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
index a5d1817..1c43eb8 100644 (file)
       enum gnu_v3_ctor_kinds is_gnu_v3_mangled_ctor (const char *name)
       enum gnu_v3_dtor_kinds is_gnu_v3_mangled_dtor (const char *name)
 
+   Also, the interface to the component list is public, and defined in
+   demangle.h.  The interface consists of these types, which are
+   defined in demangle.h:
+      enum demangle_component_type
+      struct demangle_component
+   and these functions defined in this file:
+      cplus_demangle_fill_name
+      cplus_demangle_fill_extended_operator
+      cplus_demangle_fill_ctor
+      cplus_demangle_fill_dtor
+      cplus_demangle_print
+   and other functions defined in the file cp-demint.c.
+
+   This file also defines some other functions and variables which are
+   only to be used by the file cp-demint.c.
+
    Preprocessor macros you can define while compiling this file:
 
    IN_LIBGCC2
@@ -54,7 +70,8 @@
       instead of cplus_demangle_v3() and java_demangle_v3().
 
    IN_GLIBCPP_V3
-      If defined, this file defines only __cxa_demangle().
+      If defined, this file defines only __cxa_demangle(), and no other
+      publically visible functions or variables.
 
    STANDALONE_DEMANGLER
       If defined, this file defines a main() function which demangles
 #include "ansidecl.h"
 #include "libiberty.h"
 #include "demangle.h"
+#include "cp-demangle.h"
+
+/* If IN_GLIBCPP_V3 is defined, some functions are made static.  We
+   also rename them via #define to avoid compiler errors when the
+   static definition conflicts with the extern declaration in a header
+   file.  */
+#ifdef IN_GLIBCPP_V3
+
+#define CP_STATIC_IF_GLIBCPP_V3 static
+
+#define cplus_demangle_fill_name d_fill_name
+static int
+d_fill_name PARAMS ((struct demangle_component *, const char *, int));
+
+#define cplus_demangle_fill_extended_operator d_fill_extended_operator
+static int
+d_fill_extended_operator PARAMS ((struct demangle_component *, int,
+                                 struct demangle_component *));
+
+#define cplus_demangle_fill_ctor d_fill_ctor
+static int
+d_fill_ctor PARAMS ((struct demangle_component *, enum gnu_v3_ctor_kinds,
+                    struct demangle_component *));
+
+#define cplus_demangle_fill_dtor d_fill_dtor
+static int
+d_fill_dtor PARAMS ((struct demangle_component *, enum gnu_v3_dtor_kinds,
+                    struct demangle_component *));
+
+#define cplus_demangle_mangled_name d_mangled_name
+static struct demangle_component *
+d_mangled_name PARAMS ((struct d_info *, int));
+
+#define cplus_demangle_type d_type
+static struct demangle_component *
+d_type PARAMS ((struct d_info *));
+
+#define cplus_demangle_print d_print
+static char *
+d_print PARAMS ((int, const struct demangle_component *, int, size_t *));
+
+#define cplus_demangle_init_info d_init_info
+static void
+d_init_info PARAMS ((const char *, int, size_t, struct d_info *));
+
+#else /* ! defined(IN_GLIBCPP_V3) */
+#define CP_STATIC_IF_GLIBCPP_V3
+#endif /* ! defined(IN_GLIBCPP_V3) */
 
 /* See if the compiler supports dynamic arrays.  */
 
 #define ANONYMOUS_NAMESPACE_PREFIX_LEN \
   (sizeof (ANONYMOUS_NAMESPACE_PREFIX) - 1)
 
-/* Information we keep for operators.  */
-
-struct d_operator_info
-{
-  /* Mangled name.  */
-  const char *code;
-  /* Real name.  */
-  const char *name;
-  /* Length of real name.  */
-  int len;
-  /* Number of arguments.  */
-  int args;
-};
-
-/* How to print the value of a builtin type.  */
-
-enum d_builtin_type_print
-{
-  /* Print as (type)val.  */
-  D_PRINT_DEFAULT,
-  /* Print as integer.  */
-  D_PRINT_INT,
-  /* Print as long, with trailing `l'.  */
-  D_PRINT_LONG,
-  /* Print as bool.  */
-  D_PRINT_BOOL,
-  /* Print in usual way, but here to detect void.  */
-  D_PRINT_VOID
-};
-
-/* Information we keep for a builtin type.  */
-
-struct d_builtin_type_info
-{
-  /* Type name.  */
-  const char *name;
-  /* Length of type name.  */
-  int len;
-  /* Type name when using Java.  */
-  const char *java_name;
-  /* Length of java name.  */
-  int java_len;
-  /* How to print a value of this type.  */
-  enum d_builtin_type_print print;
-};
-
 /* Information we keep for the standard substitutions.  */
 
 struct d_standard_sub_info
@@ -184,232 +203,11 @@ struct d_standard_sub_info
   int set_last_name_len;
 };
 
-/* Component types found in mangled names.  */
-
-enum d_comp_type
-{
-  /* A name.  */
-  D_COMP_NAME,
-  /* A qualified name.  */
-  D_COMP_QUAL_NAME,
-  /* A local name.  */
-  D_COMP_LOCAL_NAME,
-  /* A typed name.  */
-  D_COMP_TYPED_NAME,
-  /* A template.  */
-  D_COMP_TEMPLATE,
-  /* A template parameter.  */
-  D_COMP_TEMPLATE_PARAM,
-  /* A constructor.  */
-  D_COMP_CTOR,
-  /* A destructor.  */
-  D_COMP_DTOR,
-  /* A vtable.  */
-  D_COMP_VTABLE,
-  /* A VTT structure.  */
-  D_COMP_VTT,
-  /* A construction vtable.  */
-  D_COMP_CONSTRUCTION_VTABLE,
-  /* A typeinfo structure.  */
-  D_COMP_TYPEINFO,
-  /* A typeinfo name.  */
-  D_COMP_TYPEINFO_NAME,
-  /* A typeinfo function.  */
-  D_COMP_TYPEINFO_FN,
-  /* A thunk.  */
-  D_COMP_THUNK,
-  /* A virtual thunk.  */
-  D_COMP_VIRTUAL_THUNK,
-  /* A covariant thunk.  */
-  D_COMP_COVARIANT_THUNK,
-  /* A Java class.  */
-  D_COMP_JAVA_CLASS,
-  /* A guard variable.  */
-  D_COMP_GUARD,
-  /* A reference temporary.  */
-  D_COMP_REFTEMP,
-  /* A standard substitution.  */
-  D_COMP_SUB_STD,
-  /* The restrict qualifier.  */
-  D_COMP_RESTRICT,
-  /* The volatile qualifier.  */
-  D_COMP_VOLATILE,
-  /* The const qualifier.  */
-  D_COMP_CONST,
-  /* The restrict qualifier modifying a member function.  */
-  D_COMP_RESTRICT_THIS,
-  /* The volatile qualifier modifying a member function.  */
-  D_COMP_VOLATILE_THIS,
-  /* The const qualifier modifying a member function.  */
-  D_COMP_CONST_THIS,
-  /* A vendor qualifier.  */
-  D_COMP_VENDOR_TYPE_QUAL,
-  /* A pointer.  */
-  D_COMP_POINTER,
-  /* A reference.  */
-  D_COMP_REFERENCE,
-  /* A complex type.  */
-  D_COMP_COMPLEX,
-  /* An imaginary type.  */
-  D_COMP_IMAGINARY,
-  /* A builtin type.  */
-  D_COMP_BUILTIN_TYPE,
-  /* A vendor's builtin type.  */
-  D_COMP_VENDOR_TYPE,
-  /* A function type.  */
-  D_COMP_FUNCTION_TYPE,
-  /* An array type.  */
-  D_COMP_ARRAY_TYPE,
-  /* A pointer to member type.  */
-  D_COMP_PTRMEM_TYPE,
-  /* An argument list.  */
-  D_COMP_ARGLIST,
-  /* A template argument list.  */
-  D_COMP_TEMPLATE_ARGLIST,
-  /* An operator.  */
-  D_COMP_OPERATOR,
-  /* An extended operator.  */
-  D_COMP_EXTENDED_OPERATOR,
-  /* A typecast.  */
-  D_COMP_CAST,
-  /* A unary expression.  */
-  D_COMP_UNARY,
-  /* A binary expression.  */
-  D_COMP_BINARY,
-  /* Arguments to a binary expression.  */
-  D_COMP_BINARY_ARGS,
-  /* A trinary expression.  */
-  D_COMP_TRINARY,
-  /* Arguments to a trinary expression.  */
-  D_COMP_TRINARY_ARG1,
-  D_COMP_TRINARY_ARG2,
-  /* A literal.  */
-  D_COMP_LITERAL,
-  /* A negative literal.  */
-  D_COMP_LITERAL_NEG
-};
-
-/* A component of the mangled name.  */
-
-struct d_comp
-{
-  /* The type of this component.  */
-  enum d_comp_type type;
-  union
-  {
-    /* For D_COMP_NAME.  */
-    struct
-    {
-      /* A pointer to the name (not NULL terminated) and it's
-        length.  */
-      const char *s;
-      int len;
-    } s_name;
-
-    /* For D_COMP_OPERATOR.  */
-    struct
-    {
-      /* Operator.  */
-      const struct d_operator_info *op;
-    } s_operator;
-
-    /* For D_COMP_EXTENDED_OPERATOR.  */
-    struct
-    {
-      /* Number of arguments.  */
-      int args;
-      /* Name.  */
-      struct d_comp *name;
-    } s_extended_operator;
-
-    /* For D_COMP_CTOR.  */
-    struct
-    {
-      enum gnu_v3_ctor_kinds kind;
-      struct d_comp *name;
-    } s_ctor;
-
-    /* For D_COMP_DTOR.  */
-    struct
-    {
-      enum gnu_v3_dtor_kinds kind;
-      struct d_comp *name;
-    } s_dtor;
-
-    /* For D_COMP_BUILTIN_TYPE.  */
-    struct
-    {
-      const struct d_builtin_type_info *type;
-    } s_builtin;
-
-    /* For D_COMP_SUB_STD.  */
-    struct
-    {
-      const char* string;
-      int len;
-    } s_string;
-
-    /* For D_COMP_TEMPLATE_PARAM.  */
-    struct
-    {
-      long number;
-    } s_number;
-
-    /* For other types.  */
-    struct
-    {
-      struct d_comp *left;
-      struct d_comp *right;
-    } s_binary;
-
-  } u;
-};
+/* Accessors for subtrees of struct demangle_component.  */
 
 #define d_left(dc) ((dc)->u.s_binary.left)
 #define d_right(dc) ((dc)->u.s_binary.right)
 
-/* The information structure we pass around.  */
-
-struct d_info
-{
-  /* The string we are demangling.  */
-  const char *s;
-  /* The end of the string we are demangling.  */
-  const char *send;
-  /* The options passed to the demangler.  */
-  int options;
-  /* The next character in the string to consider.  */
-  const char *n;
-  /* The array of components.  */
-  struct d_comp *comps;
-  /* The index of the next available component.  */
-  int next_comp;
-  /* The number of available component structures.  */
-  int num_comps;
-  /* The array of substitutions.  */
-  struct d_comp **subs;
-  /* The index of the next substitution.  */
-  int next_sub;
-  /* The number of available entries in the subs array.  */
-  int num_subs;
-  /* The number of substitutions which we actually made from the subs
-     array, plus the number of template parameter references we
-     saw.  */
-  int did_subs;
-  /* The last name we saw, for constructors and destructors.  */
-  struct d_comp *last_name;
-  /* A running total of the length of large expansions from the
-     mangled name to the demangled name, such as standard
-     substitutions and builtin types.  */
-  int expansion;
-};
-
-#define d_peek_char(di) (*((di)->n))
-#define d_peek_next_char(di) ((di)->n[1])
-#define d_advance(di, i) ((di)->n += (i))
-#define d_next_char(di) (*((di)->n++))
-#define d_str(di) ((di)->n)
-
 /* A list of templates.  This is used while printing.  */
 
 struct d_print_template
@@ -417,7 +215,7 @@ struct d_print_template
   /* Next template on the list.  */
   struct d_print_template *next;
   /* This template.  */
-  const struct d_comp *template;
+  const struct demangle_component *template;
 };
 
 /* A list of type modifiers.  This is used while printing.  */
@@ -428,7 +226,7 @@ struct d_print_mod
      in which they appeared in the mangled string.  */
   struct d_print_mod *next;
   /* The modifier.  */
-  const struct d_comp *mod;
+  const struct demangle_component *mod;
   /* Whether this modifier was printed.  */
   int printed;
   /* The list of templates which applies to this modifier.  */
@@ -488,93 +286,186 @@ struct d_print_info
   ((dpi)->buf == NULL || (dpi)->len == 0 ? '\0' : (dpi)->buf[(dpi)->len - 1])
 
 #ifdef CP_DEMANGLE_DEBUG
-static void d_dump PARAMS ((struct d_comp *, int));
+static void 
+d_dump PARAMS ((struct demangle_component *, int));
 #endif
-static struct d_comp *d_make_empty PARAMS ((struct d_info *,
-                                           enum d_comp_type));
-static struct d_comp *d_make_comp PARAMS ((struct d_info *, enum d_comp_type,
-                                          struct d_comp *, struct d_comp *));
-static struct d_comp *d_make_name PARAMS ((struct d_info *, const char *,
-                                          int));
-static struct d_comp *d_make_builtin_type PARAMS ((struct d_info *,
-                                                  const struct d_builtin_type_info *));
-static struct d_comp *d_make_operator PARAMS ((struct d_info *,
-                                              const struct d_operator_info *));
-static struct d_comp *d_make_extended_operator PARAMS ((struct d_info *,
-                                                       int,
-                                                       struct d_comp *));
-static struct d_comp *d_make_ctor PARAMS ((struct d_info *,
-                                          enum gnu_v3_ctor_kinds,
-                                          struct d_comp *));
-static struct d_comp *d_make_dtor PARAMS ((struct d_info *,
-                                          enum gnu_v3_dtor_kinds,
-                                          struct d_comp *));
-static struct d_comp *d_make_template_param PARAMS ((struct d_info *, long));
-static struct d_comp *d_make_sub PARAMS ((struct d_info *, const char *, int));
-static struct d_comp *d_mangled_name PARAMS ((struct d_info *, int));
-static int has_return_type PARAMS ((struct d_comp *));
-static int is_ctor_dtor_or_conversion PARAMS ((struct d_comp *));
-static struct d_comp *d_encoding PARAMS ((struct d_info *, int));
-static struct d_comp *d_name PARAMS ((struct d_info *));
-static struct d_comp *d_nested_name PARAMS ((struct d_info *));
-static struct d_comp *d_prefix PARAMS ((struct d_info *));
-static struct d_comp *d_unqualified_name PARAMS ((struct d_info *));
-static struct d_comp *d_source_name PARAMS ((struct d_info *));
-static long d_number PARAMS ((struct d_info *));
-static struct d_comp *d_identifier PARAMS ((struct d_info *, int));
-static struct d_comp *d_operator_name PARAMS ((struct d_info *));
-static struct d_comp *d_special_name PARAMS ((struct d_info *));
-static int d_call_offset PARAMS ((struct d_info *, int));
-static struct d_comp *d_ctor_dtor_name PARAMS ((struct d_info *));
-static struct d_comp *d_type PARAMS ((struct d_info *));
-static struct d_comp **d_cv_qualifiers PARAMS ((struct d_info *,
-                                               struct d_comp **, int));
-static struct d_comp *d_function_type PARAMS ((struct d_info *));
-static struct d_comp *d_bare_function_type PARAMS ((struct d_info *, int));
-static struct d_comp *d_class_enum_type PARAMS ((struct d_info *));
-static struct d_comp *d_array_type PARAMS ((struct d_info *));
-static struct d_comp *d_pointer_to_member_type PARAMS ((struct d_info *));
-static struct d_comp *d_template_param PARAMS ((struct d_info *));
-static struct d_comp *d_template_args PARAMS ((struct d_info *));
-static struct d_comp *d_template_arg PARAMS ((struct d_info *));
-static struct d_comp *d_expression PARAMS ((struct d_info *));
-static struct d_comp *d_expr_primary PARAMS ((struct d_info *));
-static struct d_comp *d_local_name PARAMS ((struct d_info *));
-static int d_discriminator PARAMS ((struct d_info *));
-static int d_add_substitution PARAMS ((struct d_info *, struct d_comp *));
-static struct d_comp *d_substitution PARAMS ((struct d_info *, int));
-static void d_print_resize PARAMS ((struct d_print_info *, size_t));
-static void d_print_append_char PARAMS ((struct d_print_info *, int));
-static void d_print_append_buffer PARAMS ((struct d_print_info *, const char *,
-                                          size_t));
-static void d_print_error PARAMS ((struct d_print_info *));
-static char *d_print PARAMS ((int, const struct d_comp *, int, size_t *));
-static void d_print_comp PARAMS ((struct d_print_info *,
-                                 const struct d_comp *));
-static void d_print_java_identifier PARAMS ((struct d_print_info *,
-                                            const char *, int));
-static void d_print_mod_list PARAMS ((struct d_print_info *,
-                                     struct d_print_mod *, int));
-static void d_print_mod PARAMS ((struct d_print_info *,
-                                const struct d_comp *));
-static void d_print_function_type PARAMS ((struct d_print_info *,
-                                          const struct d_comp *,
-                                          struct d_print_mod *));
-static void d_print_array_type PARAMS ((struct d_print_info *,
-                                       const struct d_comp *,
-                                       struct d_print_mod *));
-static void d_print_expr_op PARAMS ((struct d_print_info *,
-                                    const struct d_comp *));
-static void d_print_cast PARAMS ((struct d_print_info *,
-                                 const struct d_comp *));
-static void d_init_info PARAMS ((const char *, int, size_t, struct d_info *));
-static char *d_demangle PARAMS ((const char *, int, size_t *));
+
+static struct demangle_component *
+d_make_empty PARAMS ((struct d_info *));
+
+static struct demangle_component *
+d_make_comp PARAMS ((struct d_info *, enum demangle_component_type,
+                    struct demangle_component *,
+                    struct demangle_component *));
+
+static struct demangle_component *
+d_make_name PARAMS ((struct d_info *, const char *, int));
+
+static struct demangle_component *
+d_make_builtin_type PARAMS ((struct d_info *,
+                            const struct demangle_builtin_type_info *));
+
+static struct demangle_component *
+d_make_operator PARAMS ((struct d_info *,
+                        const struct demangle_operator_info *));
+
+static struct demangle_component *
+d_make_extended_operator PARAMS ((struct d_info *, int,
+                                 struct demangle_component *));
+
+static struct demangle_component *
+d_make_ctor PARAMS ((struct d_info *, enum gnu_v3_ctor_kinds,
+                    struct demangle_component *));
+
+static struct demangle_component *
+d_make_dtor PARAMS ((struct d_info *, enum gnu_v3_dtor_kinds,
+                    struct demangle_component *));
+
+static struct demangle_component *
+d_make_template_param PARAMS ((struct d_info *, long));
+
+static struct demangle_component *
+d_make_sub PARAMS ((struct d_info *, const char *, int));
+
+static int
+has_return_type PARAMS ((struct demangle_component *));
+
+static int
+is_ctor_dtor_or_conversion PARAMS ((struct demangle_component *));
+
+static struct demangle_component *
+d_encoding PARAMS ((struct d_info *, int));
+
+static struct demangle_component *
+d_name PARAMS ((struct d_info *));
+
+static struct demangle_component *
+d_nested_name PARAMS ((struct d_info *));
+
+static struct demangle_component *
+d_prefix PARAMS ((struct d_info *));
+
+static struct demangle_component *
+d_unqualified_name PARAMS ((struct d_info *));
+
+static struct demangle_component *
+d_source_name PARAMS ((struct d_info *));
+
+static long
+d_number PARAMS ((struct d_info *));
+
+static struct demangle_component *
+d_identifier PARAMS ((struct d_info *, int));
+
+static struct demangle_component *
+d_operator_name PARAMS ((struct d_info *));
+
+static struct demangle_component *
+d_special_name PARAMS ((struct d_info *));
+
+static int
+d_call_offset PARAMS ((struct d_info *, int));
+
+static struct demangle_component *
+d_ctor_dtor_name PARAMS ((struct d_info *));
+
+static struct demangle_component **
+d_cv_qualifiers PARAMS ((struct d_info *, struct demangle_component **, int));
+
+static struct demangle_component *
+d_function_type PARAMS ((struct d_info *));
+
+static struct demangle_component *
+d_bare_function_type PARAMS ((struct d_info *, int));
+
+static struct demangle_component *
+d_class_enum_type PARAMS ((struct d_info *));
+
+static struct demangle_component *
+d_array_type PARAMS ((struct d_info *));
+
+static struct demangle_component *
+d_pointer_to_member_type PARAMS ((struct d_info *));
+
+static struct demangle_component *
+d_template_param PARAMS ((struct d_info *));
+
+static struct demangle_component *
+d_template_args PARAMS ((struct d_info *));
+
+static struct demangle_component *
+d_template_arg PARAMS ((struct d_info *));
+
+static struct demangle_component *
+d_expression PARAMS ((struct d_info *));
+
+static struct demangle_component *
+d_expr_primary PARAMS ((struct d_info *));
+
+static struct demangle_component *
+d_local_name PARAMS ((struct d_info *));
+
+static int
+d_discriminator PARAMS ((struct d_info *));
+
+static int
+d_add_substitution PARAMS ((struct d_info *, struct demangle_component *));
+
+static struct demangle_component *
+d_substitution PARAMS ((struct d_info *, int));
+
+static void
+d_print_resize PARAMS ((struct d_print_info *, size_t));
+
+static void
+d_print_append_char PARAMS ((struct d_print_info *, int));
+
+static void
+d_print_append_buffer PARAMS ((struct d_print_info *, const char *, size_t));
+
+static void
+d_print_error PARAMS ((struct d_print_info *));
+
+static void
+d_print_comp PARAMS ((struct d_print_info *,
+                     const struct demangle_component *));
+
+static void
+d_print_java_identifier PARAMS ((struct d_print_info *, const char *, int));
+
+static void
+d_print_mod_list PARAMS ((struct d_print_info *, struct d_print_mod *, int));
+
+static void
+d_print_mod PARAMS ((struct d_print_info *,
+                    const struct demangle_component *));
+
+static void
+d_print_function_type PARAMS ((struct d_print_info *,
+                              const struct demangle_component *,
+                              struct d_print_mod *));
+
+static void
+d_print_array_type PARAMS ((struct d_print_info *,
+                           const struct demangle_component *,
+                           struct d_print_mod *));
+
+static void
+d_print_expr_op PARAMS ((struct d_print_info *,
+                        const struct demangle_component *));
+
+static void
+d_print_cast PARAMS ((struct d_print_info *,
+                     const struct demangle_component *));
+
+static char *
+d_demangle PARAMS ((const char *, int, size_t *));
 
 #ifdef CP_DEMANGLE_DEBUG
 
 static void
 d_dump (dc, indent)
-     struct d_comp *dc;
+     struct demangle_component *dc;
      int indent;
 {
   int i;
@@ -587,159 +478,159 @@ d_dump (dc, indent)
 
   switch (dc->type)
     {
-    case D_COMP_NAME:
+    case DEMANGLE_COMPONENT_NAME:
       printf ("name '%.*s'\n", dc->u.s_name.len, dc->u.s_name.s);
       return;
-    case D_COMP_TEMPLATE_PARAM:
+    case DEMANGLE_COMPONENT_TEMPLATE_PARAM:
       printf ("template parameter %ld\n", dc->u.s_number.number);
       return;
-    case D_COMP_CTOR:
+    case DEMANGLE_COMPONENT_CTOR:
       printf ("constructor %d\n", (int) dc->u.s_ctor.kind);
       d_dump (dc->u.s_ctor.name, indent + 2);
       return;
-    case D_COMP_DTOR:
+    case DEMANGLE_COMPONENT_DTOR:
       printf ("destructor %d\n", (int) dc->u.s_dtor.kind);
       d_dump (dc->u.s_dtor.name, indent + 2);
       return;
-    case D_COMP_SUB_STD:
+    case DEMANGLE_COMPONENT_SUB_STD:
       printf ("standard substitution %s\n", dc->u.s_string.string);
       return;
-    case D_COMP_BUILTIN_TYPE:
+    case DEMANGLE_COMPONENT_BUILTIN_TYPE:
       printf ("builtin type %s\n", dc->u.s_builtin.type->name);
       return;
-    case D_COMP_OPERATOR:
+    case DEMANGLE_COMPONENT_OPERATOR:
       printf ("operator %s\n", dc->u.s_operator.op->name);
       return;
-    case D_COMP_EXTENDED_OPERATOR:
+    case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
       printf ("extended operator with %d args\n",
              dc->u.s_extended_operator.args);
       d_dump (dc->u.s_extended_operator.name, indent + 2);
       return;
 
-    case D_COMP_QUAL_NAME:
+    case DEMANGLE_COMPONENT_QUAL_NAME:
       printf ("qualified name\n");
       break;
-    case D_COMP_LOCAL_NAME:
+    case DEMANGLE_COMPONENT_LOCAL_NAME:
       printf ("local name\n");
       break;
-    case D_COMP_TYPED_NAME:
+    case DEMANGLE_COMPONENT_TYPED_NAME:
       printf ("typed name\n");
       break;
-    case D_COMP_TEMPLATE:
+    case DEMANGLE_COMPONENT_TEMPLATE:
       printf ("template\n");
       break;
-    case D_COMP_VTABLE:
+    case DEMANGLE_COMPONENT_VTABLE:
       printf ("vtable\n");
       break;
-    case D_COMP_VTT:
+    case DEMANGLE_COMPONENT_VTT:
       printf ("VTT\n");
       break;
-    case D_COMP_CONSTRUCTION_VTABLE:
+    case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE:
       printf ("construction vtable\n");
       break;
-    case D_COMP_TYPEINFO:
+    case DEMANGLE_COMPONENT_TYPEINFO:
       printf ("typeinfo\n");
       break;
-    case D_COMP_TYPEINFO_NAME:
+    case DEMANGLE_COMPONENT_TYPEINFO_NAME:
       printf ("typeinfo name\n");
       break;
-    case D_COMP_TYPEINFO_FN:
+    case DEMANGLE_COMPONENT_TYPEINFO_FN:
       printf ("typeinfo function\n");
       break;
-    case D_COMP_THUNK:
+    case DEMANGLE_COMPONENT_THUNK:
       printf ("thunk\n");
       break;
-    case D_COMP_VIRTUAL_THUNK:
+    case DEMANGLE_COMPONENT_VIRTUAL_THUNK:
       printf ("virtual thunk\n");
       break;
-    case D_COMP_COVARIANT_THUNK:
+    case DEMANGLE_COMPONENT_COVARIANT_THUNK:
       printf ("covariant thunk\n");
       break;
-    case D_COMP_JAVA_CLASS:
+    case DEMANGLE_COMPONENT_JAVA_CLASS:
       printf ("java class\n");
       break;
-    case D_COMP_GUARD:
+    case DEMANGLE_COMPONENT_GUARD:
       printf ("guard\n");
       break;
-    case D_COMP_REFTEMP:
+    case DEMANGLE_COMPONENT_REFTEMP:
       printf ("reference temporary\n");
       break;
-    case D_COMP_RESTRICT:
+    case DEMANGLE_COMPONENT_RESTRICT:
       printf ("restrict\n");
       break;
-    case D_COMP_VOLATILE:
+    case DEMANGLE_COMPONENT_VOLATILE:
       printf ("volatile\n");
       break;
-    case D_COMP_CONST:
+    case DEMANGLE_COMPONENT_CONST:
       printf ("const\n");
       break;
-    case D_COMP_RESTRICT_THIS:
+    case DEMANGLE_COMPONENT_RESTRICT_THIS:
       printf ("restrict this\n");
       break;
-    case D_COMP_VOLATILE_THIS:
+    case DEMANGLE_COMPONENT_VOLATILE_THIS:
       printf ("volatile this\n");
       break;
-    case D_COMP_CONST_THIS:
+    case DEMANGLE_COMPONENT_CONST_THIS:
       printf ("const this\n");
       break;
-    case D_COMP_VENDOR_TYPE_QUAL:
+    case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
       printf ("vendor type qualifier\n");
       break;
-    case D_COMP_POINTER:
+    case DEMANGLE_COMPONENT_POINTER:
       printf ("pointer\n");
       break;
-    case D_COMP_REFERENCE:
+    case DEMANGLE_COMPONENT_REFERENCE:
       printf ("reference\n");
       break;
-    case D_COMP_COMPLEX:
+    case DEMANGLE_COMPONENT_COMPLEX:
       printf ("complex\n");
       break;
-    case D_COMP_IMAGINARY:
+    case DEMANGLE_COMPONENT_IMAGINARY:
       printf ("imaginary\n");
       break;
-    case D_COMP_VENDOR_TYPE:
+    case DEMANGLE_COMPONENT_VENDOR_TYPE:
       printf ("vendor type\n");
       break;
-    case D_COMP_FUNCTION_TYPE:
+    case DEMANGLE_COMPONENT_FUNCTION_TYPE:
       printf ("function type\n");
       break;
-    case D_COMP_ARRAY_TYPE:
+    case DEMANGLE_COMPONENT_ARRAY_TYPE:
       printf ("array type\n");
       break;
-    case D_COMP_PTRMEM_TYPE:
+    case DEMANGLE_COMPONENT_PTRMEM_TYPE:
       printf ("pointer to member type\n");
       break;
-    case D_COMP_ARGLIST:
+    case DEMANGLE_COMPONENT_ARGLIST:
       printf ("argument list\n");
       break;
-    case D_COMP_TEMPLATE_ARGLIST:
+    case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
       printf ("template argument list\n");
       break;
-    case D_COMP_CAST:
+    case DEMANGLE_COMPONENT_CAST:
       printf ("cast\n");
       break;
-    case D_COMP_UNARY:
+    case DEMANGLE_COMPONENT_UNARY:
       printf ("unary operator\n");
       break;
-    case D_COMP_BINARY:
+    case DEMANGLE_COMPONENT_BINARY:
       printf ("binary operator\n");
       break;
-    case D_COMP_BINARY_ARGS:
+    case DEMANGLE_COMPONENT_BINARY_ARGS:
       printf ("binary operator arguments\n");
       break;
-    case D_COMP_TRINARY:
+    case DEMANGLE_COMPONENT_TRINARY:
       printf ("trinary operator\n");
       break;
-    case D_COMP_TRINARY_ARG1:
+    case DEMANGLE_COMPONENT_TRINARY_ARG1:
       printf ("trinary operator arguments 1\n");
       break;
-    case D_COMP_TRINARY_ARG2:
+    case DEMANGLE_COMPONENT_TRINARY_ARG2:
       printf ("trinary operator arguments 1\n");
       break;
-    case D_COMP_LITERAL:
+    case DEMANGLE_COMPONENT_LITERAL:
       printf ("literal\n");
       break;
-    case D_COMP_LITERAL_NEG:
+    case DEMANGLE_COMPONENT_LITERAL_NEG:
       printf ("negative literal\n");
       break;
     }
@@ -750,33 +641,105 @@ d_dump (dc, indent)
 
 #endif /* CP_DEMANGLE_DEBUG */
 
+/* Fill in a DEMANGLE_COMPONENT_NAME.  */
+
+CP_STATIC_IF_GLIBCPP_V3
+int
+cplus_demangle_fill_name (p, s, len)
+     struct demangle_component *p;
+     const char *s;
+     int len;
+{
+  if (p == NULL || s == NULL || len == 0)
+    return 0;
+  p->type = DEMANGLE_COMPONENT_NAME;
+  p->u.s_name.s = s;
+  p->u.s_name.len = len;
+  return 1;
+}
+
+/* Fill in a DEMANGLE_COMPONENT_EXTENDED_OPERATOR.  */
+
+CP_STATIC_IF_GLIBCPP_V3
+int
+cplus_demangle_fill_extended_operator (p, args, name)
+     struct demangle_component *p;
+     int args;
+     struct demangle_component *name;
+{
+  if (p == NULL || args < 0 || name == NULL)
+    return 0;
+  p->type = DEMANGLE_COMPONENT_EXTENDED_OPERATOR;
+  p->u.s_extended_operator.args = args;
+  p->u.s_extended_operator.name = name;
+  return 1;
+}
+
+/* Fill in a DEMANGLE_COMPONENT_CTOR.  */
+
+CP_STATIC_IF_GLIBCPP_V3
+int
+cplus_demangle_fill_ctor (p, kind, name)
+     struct demangle_component *p;
+     enum gnu_v3_ctor_kinds kind;
+     struct demangle_component *name;
+{
+  if (p == NULL
+      || name == NULL
+      || (kind < gnu_v3_complete_object_ctor
+         && kind > gnu_v3_complete_object_allocating_ctor))
+    return 0;
+  p->type = DEMANGLE_COMPONENT_CTOR;
+  p->u.s_ctor.kind = kind;
+  p->u.s_ctor.name = name;
+  return 1;
+}
+
+/* Fill in a DEMANGLE_COMPONENT_DTOR.  */
+
+CP_STATIC_IF_GLIBCPP_V3
+int
+cplus_demangle_fill_dtor (p, kind, name)
+     struct demangle_component *p;
+     enum gnu_v3_dtor_kinds kind;
+     struct demangle_component *name;
+{
+  if (p == NULL
+      || name == NULL
+      || (kind < gnu_v3_deleting_dtor
+         && kind > gnu_v3_base_object_dtor))
+    return 0;
+  p->type = DEMANGLE_COMPONENT_DTOR;
+  p->u.s_dtor.kind = kind;
+  p->u.s_dtor.name = name;
+  return 1;
+}
+
 /* Add a new component.  */
 
-static struct d_comp *
-d_make_empty (di, type)
+static struct demangle_component *
+d_make_empty (di)
      struct d_info *di;
-     enum d_comp_type type;
 {
-  struct d_comp *p;
+  struct demangle_component *p;
 
   if (di->next_comp >= di->num_comps)
     return NULL;
   p = &di->comps[di->next_comp];
-  p->type = type;
   ++di->next_comp;
   return p;
 }
 
 /* Add a new generic component.  */
 
-static struct d_comp *
+static struct demangle_component *
 d_make_comp (di, type, left, right)
      struct d_info *di;
-     enum d_comp_type type;
-     struct d_comp *left;
-     struct d_comp *right;
+     enum demangle_component_type type;
+     struct demangle_component *left;
+     struct demangle_component *right;
 {
-  struct d_comp *p;
+  struct demangle_component *p;
 
   /* We check for errors here.  A typical error would be a NULL return
      from a subroutine.  We catch those here, and return NULL
@@ -784,65 +747,65 @@ d_make_comp (di, type, left, right)
   switch (type)
     {
       /* These types require two parameters.  */
-    case D_COMP_QUAL_NAME:
-    case D_COMP_LOCAL_NAME:
-    case D_COMP_TYPED_NAME:
-    case D_COMP_TEMPLATE:
-    case D_COMP_VENDOR_TYPE_QUAL:
-    case D_COMP_PTRMEM_TYPE:
-    case D_COMP_UNARY:
-    case D_COMP_BINARY:
-    case D_COMP_BINARY_ARGS:
-    case D_COMP_TRINARY:
-    case D_COMP_TRINARY_ARG1:
-    case D_COMP_TRINARY_ARG2:
-    case D_COMP_LITERAL:
-    case D_COMP_LITERAL_NEG:
+    case DEMANGLE_COMPONENT_QUAL_NAME:
+    case DEMANGLE_COMPONENT_LOCAL_NAME:
+    case DEMANGLE_COMPONENT_TYPED_NAME:
+    case DEMANGLE_COMPONENT_TEMPLATE:
+    case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
+    case DEMANGLE_COMPONENT_PTRMEM_TYPE:
+    case DEMANGLE_COMPONENT_UNARY:
+    case DEMANGLE_COMPONENT_BINARY:
+    case DEMANGLE_COMPONENT_BINARY_ARGS:
+    case DEMANGLE_COMPONENT_TRINARY:
+    case DEMANGLE_COMPONENT_TRINARY_ARG1:
+    case DEMANGLE_COMPONENT_TRINARY_ARG2:
+    case DEMANGLE_COMPONENT_LITERAL:
+    case DEMANGLE_COMPONENT_LITERAL_NEG:
       if (left == NULL || right == NULL)
        return NULL;
       break;
 
       /* These types only require one parameter.  */
-    case D_COMP_VTABLE:
-    case D_COMP_VTT:
-    case D_COMP_CONSTRUCTION_VTABLE:
-    case D_COMP_TYPEINFO:
-    case D_COMP_TYPEINFO_NAME:
-    case D_COMP_TYPEINFO_FN:
-    case D_COMP_THUNK:
-    case D_COMP_VIRTUAL_THUNK:
-    case D_COMP_COVARIANT_THUNK:
-    case D_COMP_JAVA_CLASS:
-    case D_COMP_GUARD:
-    case D_COMP_REFTEMP:
-    case D_COMP_POINTER:
-    case D_COMP_REFERENCE:
-    case D_COMP_COMPLEX:
-    case D_COMP_IMAGINARY:
-    case D_COMP_VENDOR_TYPE:
-    case D_COMP_ARGLIST:
-    case D_COMP_TEMPLATE_ARGLIST:
-    case D_COMP_CAST:
+    case DEMANGLE_COMPONENT_VTABLE:
+    case DEMANGLE_COMPONENT_VTT:
+    case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE:
+    case DEMANGLE_COMPONENT_TYPEINFO:
+    case DEMANGLE_COMPONENT_TYPEINFO_NAME:
+    case DEMANGLE_COMPONENT_TYPEINFO_FN:
+    case DEMANGLE_COMPONENT_THUNK:
+    case DEMANGLE_COMPONENT_VIRTUAL_THUNK:
+    case DEMANGLE_COMPONENT_COVARIANT_THUNK:
+    case DEMANGLE_COMPONENT_JAVA_CLASS:
+    case DEMANGLE_COMPONENT_GUARD:
+    case DEMANGLE_COMPONENT_REFTEMP:
+    case DEMANGLE_COMPONENT_POINTER:
+    case DEMANGLE_COMPONENT_REFERENCE:
+    case DEMANGLE_COMPONENT_COMPLEX:
+    case DEMANGLE_COMPONENT_IMAGINARY:
+    case DEMANGLE_COMPONENT_VENDOR_TYPE:
+    case DEMANGLE_COMPONENT_ARGLIST:
+    case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
+    case DEMANGLE_COMPONENT_CAST:
       if (left == NULL)
        return NULL;
       break;
 
       /* This needs a right parameter, but the left parameter can be
         empty.  */
-    case D_COMP_ARRAY_TYPE:
+    case DEMANGLE_COMPONENT_ARRAY_TYPE:
       if (right == NULL)
        return NULL;
       break;
 
       /* These are allowed to have no parameters--in some cases they
         will be filled in later.  */
-    case D_COMP_FUNCTION_TYPE:
-    case D_COMP_RESTRICT:
-    case D_COMP_VOLATILE:
-    case D_COMP_CONST:
-    case D_COMP_RESTRICT_THIS:
-    case D_COMP_VOLATILE_THIS:
-    case D_COMP_CONST_THIS:
+    case DEMANGLE_COMPONENT_FUNCTION_TYPE:
+    case DEMANGLE_COMPONENT_RESTRICT:
+    case DEMANGLE_COMPONENT_VOLATILE:
+    case DEMANGLE_COMPONENT_CONST:
+    case DEMANGLE_COMPONENT_RESTRICT_THIS:
+    case DEMANGLE_COMPONENT_VOLATILE_THIS:
+    case DEMANGLE_COMPONENT_CONST_THIS:
       break;
 
       /* Other types should not be seen here.  */
@@ -850,9 +813,10 @@ d_make_comp (di, type, left, right)
       return NULL;
     }
 
-  p = d_make_empty (di, type);
+  p = d_make_empty (di);
   if (p != NULL)
     {
+      p->type = type;
       p->u.s_binary.left = left;
       p->u.s_binary.right = right;
     }
@@ -861,148 +825,138 @@ d_make_comp (di, type, left, right)
 
 /* Add a new name component.  */
 
-static struct d_comp *
+static struct demangle_component *
 d_make_name (di, s, len)
      struct d_info *di;
      const char *s;
      int len;
 {
-  struct d_comp *p;
+  struct demangle_component *p;
 
-  if (s == NULL || len == 0)
+  p = d_make_empty (di);
+  if (! cplus_demangle_fill_name (p, s, len))
     return NULL;
-  p = d_make_empty (di, D_COMP_NAME);
-  if (p != NULL)
-    {
-      p->u.s_name.s = s;
-      p->u.s_name.len = len;
-    }
   return p;
 }
 
 /* Add a new builtin type component.  */
 
-static struct d_comp *
+static struct demangle_component *
 d_make_builtin_type (di, type)
      struct d_info *di;
-     const struct d_builtin_type_info *type;
+     const struct demangle_builtin_type_info *type;
 {
-  struct d_comp *p;
+  struct demangle_component *p;
 
   if (type == NULL)
     return NULL;
-  p = d_make_empty (di, D_COMP_BUILTIN_TYPE);
+  p = d_make_empty (di);
   if (p != NULL)
-    p->u.s_builtin.type = type;
+    {
+      p->type = DEMANGLE_COMPONENT_BUILTIN_TYPE;
+      p->u.s_builtin.type = type;
+    }
   return p;
 }
 
 /* Add a new operator component.  */
 
-static struct d_comp *
+static struct demangle_component *
 d_make_operator (di, op)
      struct d_info *di;
-     const struct d_operator_info *op;
+     const struct demangle_operator_info *op;
 {
-  struct d_comp *p;
+  struct demangle_component *p;
 
-  p = d_make_empty (di, D_COMP_OPERATOR);
+  p = d_make_empty (di);
   if (p != NULL)
-    p->u.s_operator.op = op;
+    {
+      p->type = DEMANGLE_COMPONENT_OPERATOR;
+      p->u.s_operator.op = op;
+    }
   return p;
 }
 
 /* Add a new extended operator component.  */
 
-static struct d_comp *
+static struct demangle_component *
 d_make_extended_operator (di, args, name)
      struct d_info *di;
      int args;
-     struct d_comp *name;
+     struct demangle_component *name;
 {
-  struct d_comp *p;
+  struct demangle_component *p;
 
-  if (name == NULL)
+  p = d_make_empty (di);
+  if (! cplus_demangle_fill_extended_operator (p, args, name))
     return NULL;
-  p = d_make_empty (di, D_COMP_EXTENDED_OPERATOR);
-  if (p != NULL)
-    {
-      p->u.s_extended_operator.args = args;
-      p->u.s_extended_operator.name = name;
-    }
   return p;
 }
 
 /* Add a new constructor component.  */
 
-static struct d_comp *
+static struct demangle_component *
 d_make_ctor (di, kind,  name)
      struct d_info *di;
      enum gnu_v3_ctor_kinds kind;
-     struct d_comp *name;
+     struct demangle_component *name;
 {
-  struct d_comp *p;
+  struct demangle_component *p;
 
-  if (name == NULL)
+  p = d_make_empty (di);
+  if (! cplus_demangle_fill_ctor (p, kind, name))
     return NULL;
-  p = d_make_empty (di, D_COMP_CTOR);
-  if (p != NULL)
-    {
-      p->u.s_ctor.kind = kind;
-      p->u.s_ctor.name = name;
-    }
   return p;
 }
 
 /* Add a new destructor component.  */
 
-static struct d_comp *
+static struct demangle_component *
 d_make_dtor (di, kind, name)
      struct d_info *di;
      enum gnu_v3_dtor_kinds kind;
-     struct d_comp *name;
+     struct demangle_component *name;
 {
-  struct d_comp *p;
+  struct demangle_component *p;
 
-  if (name == NULL)
+  p = d_make_empty (di);
+  if (! cplus_demangle_fill_dtor (p, kind, name))
     return NULL;
-  p = d_make_empty (di, D_COMP_DTOR);
-  if (p != NULL)
-    {
-      p->u.s_dtor.kind = kind;
-      p->u.s_dtor.name = name;
-    }
   return p;
 }
 
 /* Add a new template parameter.  */
 
-static struct d_comp *
+static struct demangle_component *
 d_make_template_param (di, i)
      struct d_info *di;
      long i;
 {
-  struct d_comp *p;
+  struct demangle_component *p;
 
-  p = d_make_empty (di, D_COMP_TEMPLATE_PARAM);
+  p = d_make_empty (di);
   if (p != NULL)
-    p->u.s_number.number = i;
+    {
+      p->type = DEMANGLE_COMPONENT_TEMPLATE_PARAM;
+      p->u.s_number.number = i;
+    }
   return p;
 }
 
 /* Add a new standard substitution component.  */
 
-static struct d_comp *
+static struct demangle_component *
 d_make_sub (di, name, len)
      struct d_info *di;
      const char *name;
      int len;
 {
-  struct d_comp *p;
+  struct demangle_component *p;
 
-  p = d_make_empty (di, D_COMP_SUB_STD);
+  p = d_make_empty (di);
   if (p != NULL)
     {
+      p->type = DEMANGLE_COMPONENT_SUB_STD;
       p->u.s_string.string = name;
       p->u.s_string.len = len;
     }
@@ -1013,8 +967,9 @@ d_make_sub (di, name, len)
 
    TOP_LEVEL is non-zero when called at the top level.  */
 
-static struct d_comp *
-d_mangled_name (di, top_level)
+CP_STATIC_IF_GLIBCPP_V3
+struct demangle_component *
+cplus_demangle_mangled_name (di, top_level)
      struct d_info *di;
      int top_level;
 {
@@ -1036,7 +991,7 @@ d_mangled_name (di, top_level)
 
 static int
 has_return_type (dc)
-     struct d_comp *dc;
+     struct demangle_component *dc;
 {
   if (dc == NULL)
     return 0;
@@ -1044,11 +999,11 @@ has_return_type (dc)
     {
     default:
       return 0;
-    case D_COMP_TEMPLATE:
+    case DEMANGLE_COMPONENT_TEMPLATE:
       return ! is_ctor_dtor_or_conversion (d_left (dc));
-    case D_COMP_RESTRICT_THIS:
-    case D_COMP_VOLATILE_THIS:
-    case D_COMP_CONST_THIS:
+    case DEMANGLE_COMPONENT_RESTRICT_THIS:
+    case DEMANGLE_COMPONENT_VOLATILE_THIS:
+    case DEMANGLE_COMPONENT_CONST_THIS:
       return has_return_type (d_left (dc));
     }
 }
@@ -1058,7 +1013,7 @@ has_return_type (dc)
 
 static int
 is_ctor_dtor_or_conversion (dc)
-     struct d_comp *dc;
+     struct demangle_component *dc;
 {
   if (dc == NULL)
     return 0;
@@ -1066,12 +1021,12 @@ is_ctor_dtor_or_conversion (dc)
     {
     default:
       return 0;
-    case D_COMP_QUAL_NAME:
-    case D_COMP_LOCAL_NAME:
+    case DEMANGLE_COMPONENT_QUAL_NAME:
+    case DEMANGLE_COMPONENT_LOCAL_NAME:
       return is_ctor_dtor_or_conversion (d_right (dc));
-    case D_COMP_CTOR:
-    case D_COMP_DTOR:
-    case D_COMP_CAST:
+    case DEMANGLE_COMPONENT_CTOR:
+    case DEMANGLE_COMPONENT_DTOR:
+    case DEMANGLE_COMPONENT_CAST:
       return 1;
     }
 }
@@ -1085,7 +1040,7 @@ is_ctor_dtor_or_conversion (dc)
    parameters.  We only set this at the top level, because otherwise
    we would not correctly demangle names in local scopes.  */
 
-static struct d_comp *
+static struct demangle_component *
 d_encoding (di, top_level)
      struct d_info *di;
      int top_level;
@@ -1096,7 +1051,7 @@ d_encoding (di, top_level)
     return d_special_name (di);
   else
     {
-      struct d_comp *dc;
+      struct demangle_component *dc;
 
       dc = d_name (di);
 
@@ -1105,23 +1060,23 @@ d_encoding (di, top_level)
          /* Strip off any initial CV-qualifiers, as they really apply
             to the `this' parameter, and they were not output by the
             v2 demangler without DMGL_PARAMS.  */
-         while (dc->type == D_COMP_RESTRICT_THIS
-                || dc->type == D_COMP_VOLATILE_THIS
-                || dc->type == D_COMP_CONST_THIS)
+         while (dc->type == DEMANGLE_COMPONENT_RESTRICT_THIS
+                || dc->type == DEMANGLE_COMPONENT_VOLATILE_THIS
+                || dc->type == DEMANGLE_COMPONENT_CONST_THIS)
            dc = d_left (dc);
 
-         /* If the top level is a D_COMP_LOCAL_NAME, then there may
-            be CV-qualifiers on its right argument which really apply
-            here; this happens when parsing a class which is local to
-            a function.  */
-         if (dc->type == D_COMP_LOCAL_NAME)
+         /* If the top level is a DEMANGLE_COMPONENT_LOCAL_NAME, then
+            there may be CV-qualifiers on its right argument which
+            really apply here; this happens when parsing a class
+            which is local to a function.  */
+         if (dc->type == DEMANGLE_COMPONENT_LOCAL_NAME)
            {
-             struct d_comp *dcr;
+             struct demangle_component *dcr;
 
              dcr = d_right (dc);
-             while (dcr->type == D_COMP_RESTRICT_THIS
-                    || dcr->type == D_COMP_VOLATILE_THIS
-                    || dcr->type == D_COMP_CONST_THIS)
+             while (dcr->type == DEMANGLE_COMPONENT_RESTRICT_THIS
+                    || dcr->type == DEMANGLE_COMPONENT_VOLATILE_THIS
+                    || dcr->type == DEMANGLE_COMPONENT_CONST_THIS)
                dcr = d_left (dcr);
              dc->u.s_binary.right = dcr;
            }
@@ -1132,7 +1087,7 @@ d_encoding (di, top_level)
       peek = d_peek_char (di);
       if (peek == '\0' || peek == 'E')
        return dc;
-      return d_make_comp (di, D_COMP_TYPED_NAME, dc,
+      return d_make_comp (di, DEMANGLE_COMPONENT_TYPED_NAME, dc,
                          d_bare_function_type (di, has_return_type (dc)));
     }
 }
@@ -1149,12 +1104,12 @@ d_encoding (di, top_level)
                             ::= <substitution>
 */
 
-static struct d_comp *
+static struct demangle_component *
 d_name (di)
      struct d_info *di;
 {
   char peek = d_peek_char (di);
-  struct d_comp *dc;
+  struct demangle_component *dc;
 
   switch (peek)
     {
@@ -1176,7 +1131,8 @@ d_name (di)
        else
          {
            d_advance (di, 2);
-           dc = d_make_comp (di, D_COMP_QUAL_NAME, d_make_name (di, "std", 3),
+           dc = d_make_comp (di, DEMANGLE_COMPONENT_QUAL_NAME,
+                             d_make_name (di, "std", 3),
                              d_unqualified_name (di));
            di->expansion += 3;
            subst = 0;
@@ -1199,7 +1155,8 @@ d_name (di)
                if (! d_add_substitution (di, dc))
                  return NULL;
              }
-           dc = d_make_comp (di, D_COMP_TEMPLATE, dc, d_template_args (di));
+           dc = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, dc,
+                             d_template_args (di));
          }
 
        return dc;
@@ -1214,7 +1171,8 @@ d_name (di)
             candidate.  */
          if (! d_add_substitution (di, dc))
            return NULL;
-         dc = d_make_comp (di, D_COMP_TEMPLATE, dc, d_template_args (di));
+         dc = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, dc,
+                           d_template_args (di));
        }
       return dc;
     }
@@ -1224,12 +1182,12 @@ d_name (di)
                  ::= N [<CV-qualifiers>] <template-prefix> <template-args> E
 */
 
-static struct d_comp *
+static struct demangle_component *
 d_nested_name (di)
      struct d_info *di;
 {
-  struct d_comp *ret;
-  struct d_comp **pret;
+  struct demangle_component *ret;
+  struct demangle_component **pret;
 
   if (d_next_char (di) != 'N')
     return NULL;
@@ -1259,17 +1217,17 @@ d_nested_name (di)
                      ::= <substitution>
 */
 
-static struct d_comp *
+static struct demangle_component *
 d_prefix (di)
      struct d_info *di;
 {
-  struct d_comp *ret = NULL;
+  struct demangle_component *ret = NULL;
 
   while (1)
     {
       char peek;
-      enum d_comp_type comb_type;
-      struct d_comp *dc;
+      enum demangle_component_type comb_type;
+      struct demangle_component *dc;
 
       peek = d_peek_char (di);
       if (peek == '\0')
@@ -1279,7 +1237,7 @@ d_prefix (di)
         that in the grammar.  The older code does not accept a
         <template-param> here.  */
 
-      comb_type = D_COMP_QUAL_NAME;
+      comb_type = DEMANGLE_COMPONENT_QUAL_NAME;
       if (IS_DIGIT (peek)
          || IS_LOWER (peek)
          || peek == 'C'
@@ -1291,7 +1249,7 @@ d_prefix (di)
        {
          if (ret == NULL)
            return NULL;
-         comb_type = D_COMP_TEMPLATE;
+         comb_type = DEMANGLE_COMPONENT_TEMPLATE;
          dc = d_template_args (di);
        }
       else if (peek == 'T')
@@ -1319,7 +1277,7 @@ d_prefix (di)
                       ::= <source-name>
 */
 
-static struct d_comp *
+static struct demangle_component *
 d_unqualified_name (di)
      struct d_info *di;
 {
@@ -1330,10 +1288,10 @@ d_unqualified_name (di)
     return d_source_name (di);
   else if (IS_LOWER (peek))
     {
-      struct d_comp *ret;
+      struct demangle_component *ret;
 
       ret = d_operator_name (di);
-      if (ret != NULL && ret->type == D_COMP_OPERATOR)
+      if (ret != NULL && ret->type == DEMANGLE_COMPONENT_OPERATOR)
        di->expansion += sizeof "operator" + ret->u.s_operator.op->len - 2;
       return ret;
     }
@@ -1345,12 +1303,12 @@ d_unqualified_name (di)
 
 /* <source-name> ::= <(positive length) number> <identifier>  */
 
-static struct d_comp *
+static struct demangle_component *
 d_source_name (di)
      struct d_info *di;
 {
   long len;
-  struct d_comp *ret;
+  struct demangle_component *ret;
 
   len = d_number (di);
   if (len <= 0)
@@ -1396,7 +1354,7 @@ d_number (di)
 
 /* identifier ::= <(unqualified source code identifier)>  */
 
-static struct d_comp *
+static struct demangle_component *
 d_identifier (di, len)
      struct d_info *di;
      int len;
@@ -1446,7 +1404,8 @@ d_identifier (di, len)
 
 #define NL(s) s, (sizeof s) - 1
 
-static const struct d_operator_info d_operators[] =
+CP_STATIC_IF_GLIBCPP_V3
+const struct demangle_operator_info cplus_demangle_operators[] =
 {
   { "aN", NL ("&="),        2 },
   { "aS", NL ("="),         2 },
@@ -1496,10 +1455,11 @@ static const struct d_operator_info d_operators[] =
   { "rm", NL ("%"),         2 },
   { "rs", NL (">>"),        2 },
   { "st", NL ("sizeof "),   1 },
-  { "sz", NL ("sizeof "),   1 }
+  { "sz", NL ("sizeof "),   1 },
+  { NULL, NULL, 0,          0 }
 };
 
-static struct d_comp *
+static struct demangle_component *
 d_operator_name (di)
      struct d_info *di;
 {
@@ -1511,19 +1471,25 @@ d_operator_name (di)
   if (c1 == 'v' && IS_DIGIT (c2))
     return d_make_extended_operator (di, c2 - '0', d_source_name (di));
   else if (c1 == 'c' && c2 == 'v')
-    return d_make_comp (di, D_COMP_CAST, d_type (di), NULL);
+    return d_make_comp (di, DEMANGLE_COMPONENT_CAST,
+                       cplus_demangle_type (di), NULL);
   else
     {
+      /* LOW is the inclusive lower bound.  */
       int low = 0;
-      int high = sizeof (d_operators) / sizeof (d_operators[0]);
+      /* HIGH is the exclusive upper bound.  We subtract one to ignore
+        the sentinel at the end of the array.  */
+      int high = ((sizeof (cplus_demangle_operators)
+                  / sizeof (cplus_demangle_operators[0]))
+                 - 1);
 
       while (1)
        {
          int i;
-         const struct d_operator_info *p;
+         const struct demangle_operator_info *p;
 
          i = low + (high - low) / 2;
-         p = d_operators + i;
+         p = cplus_demangle_operators + i;
 
          if (c1 == p->code[0] && c2 == p->code[1])
            return d_make_operator (di, p);
@@ -1552,7 +1518,7 @@ d_operator_name (di)
                   ::= GR <name>
 */
 
-static struct d_comp *
+static struct demangle_component *
 d_special_name (di)
      struct d_info *di;
 {
@@ -1566,58 +1532,65 @@ d_special_name (di)
        {
        case 'V':
          di->expansion -= 5;
-         return d_make_comp (di, D_COMP_VTABLE, d_type (di), NULL);
+         return d_make_comp (di, DEMANGLE_COMPONENT_VTABLE,
+                             cplus_demangle_type (di), NULL);
        case 'T':
          di->expansion -= 10;
-         return d_make_comp (di, D_COMP_VTT, d_type (di), NULL);
+         return d_make_comp (di, DEMANGLE_COMPONENT_VTT,
+                             cplus_demangle_type (di), NULL);
        case 'I':
-         return d_make_comp (di, D_COMP_TYPEINFO, d_type (di), NULL);
+         return d_make_comp (di, DEMANGLE_COMPONENT_TYPEINFO,
+                             cplus_demangle_type (di), NULL);
        case 'S':
-         return d_make_comp (di, D_COMP_TYPEINFO_NAME, d_type (di), NULL);
+         return d_make_comp (di, DEMANGLE_COMPONENT_TYPEINFO_NAME,
+                             cplus_demangle_type (di), NULL);
 
        case 'h':
          if (! d_call_offset (di, 'h'))
            return NULL;
-         return d_make_comp (di, D_COMP_THUNK, d_encoding (di, 0), NULL);
+         return d_make_comp (di, DEMANGLE_COMPONENT_THUNK,
+                             d_encoding (di, 0), NULL);
 
        case 'v':
          if (! d_call_offset (di, 'v'))
            return NULL;
-         return d_make_comp (di, D_COMP_VIRTUAL_THUNK, d_encoding (di, 0),
-                             NULL);
+         return d_make_comp (di, DEMANGLE_COMPONENT_VIRTUAL_THUNK,
+                             d_encoding (di, 0), NULL);
 
        case 'c':
          if (! d_call_offset (di, '\0'))
            return NULL;
          if (! d_call_offset (di, '\0'))
            return NULL;
-         return d_make_comp (di, D_COMP_COVARIANT_THUNK, d_encoding (di, 0),
-                             NULL);
+         return d_make_comp (di, DEMANGLE_COMPONENT_COVARIANT_THUNK,
+                             d_encoding (di, 0), NULL);
 
        case 'C':
          {
-           struct d_comp *derived_type;
+           struct demangle_component *derived_type;
            long offset;
-           struct d_comp *base_type;
+           struct demangle_component *base_type;
 
-           derived_type = d_type (di);
+           derived_type = cplus_demangle_type (di);
            offset = d_number (di);
            if (offset < 0)
              return NULL;
            if (d_next_char (di) != '_')
              return NULL;
-           base_type = d_type (di);
+           base_type = cplus_demangle_type (di);
            /* We don't display the offset.  FIXME: We should display
               it in verbose mode.  */
            di->expansion += 5;
-           return d_make_comp (di, D_COMP_CONSTRUCTION_VTABLE, base_type,
-                               derived_type);
+           return d_make_comp (di, DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE,
+                               base_type, derived_type);
          }
 
        case 'F':
-         return d_make_comp (di, D_COMP_TYPEINFO_FN, d_type (di), NULL);
+         return d_make_comp (di, DEMANGLE_COMPONENT_TYPEINFO_FN,
+                             cplus_demangle_type (di), NULL);
        case 'J':
-         return d_make_comp (di, D_COMP_JAVA_CLASS, d_type (di), NULL);
+         return d_make_comp (di, DEMANGLE_COMPONENT_JAVA_CLASS,
+                             cplus_demangle_type (di), NULL);
 
        default:
          return NULL;
@@ -1628,10 +1601,11 @@ d_special_name (di)
       switch (d_next_char (di))
        {
        case 'V':
-         return d_make_comp (di, D_COMP_GUARD, d_name (di), NULL);
+         return d_make_comp (di, DEMANGLE_COMPONENT_GUARD, d_name (di), NULL);
 
        case 'R':
-         return d_make_comp (di, D_COMP_REFTEMP, d_name (di), NULL);
+         return d_make_comp (di, DEMANGLE_COMPONENT_REFTEMP, d_name (di),
+                             NULL);
 
        default:
          return NULL;
@@ -1691,15 +1665,15 @@ d_call_offset (di, c)
                     ::= D2
 */
 
-static struct d_comp *
+static struct demangle_component *
 d_ctor_dtor_name (di)
      struct d_info *di;
 {
   if (di->last_name != NULL)
     {
-      if (di->last_name->type == D_COMP_NAME)
+      if (di->last_name->type == DEMANGLE_COMPONENT_NAME)
        di->expansion += di->last_name->u.s_name.len;
-      else if (di->last_name->type == D_COMP_SUB_STD)
+      else if (di->last_name->type == DEMANGLE_COMPONENT_SUB_STD)
        di->expansion += di->last_name->u.s_string.len;
     }
   switch (d_next_char (di))
@@ -1770,7 +1744,9 @@ d_ctor_dtor_name (di)
                   ::= u <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 },
   /* b */ { NL ("bool"),       NL ("boolean"),         D_PRINT_BOOL },
@@ -1800,12 +1776,13 @@ static const struct d_builtin_type_info d_builtin_types[26] =
   /* z */ { NL ("..."),                NL ("..."),             D_PRINT_DEFAULT },
 };
 
-static struct d_comp *
-d_type (di)
+CP_STATIC_IF_GLIBCPP_V3
+struct demangle_component *
+cplus_demangle_type (di)
      struct d_info *di;
 {
   char peek;
-  struct d_comp *ret;
+  struct demangle_component *ret;
   int can_subst;
 
   /* The ABI specifies that when CV-qualifiers are used, the base type
@@ -1826,12 +1803,12 @@ d_type (di)
   peek = d_peek_char (di);
   if (peek == 'r' || peek == 'V' || peek == 'K')
     {
-      struct d_comp **pret;
+      struct demangle_component **pret;
 
       pret = d_cv_qualifiers (di, &ret, 0);
       if (pret == NULL)
        return NULL;
-      *pret = d_type (di);
+      *pret = cplus_demangle_type (di);
       if (! d_add_substitution (di, ret))
        return NULL;
       return ret;
@@ -1845,7 +1822,8 @@ d_type (di)
     case 'h': case 'i': case 'j':           case 'l': case 'm': case 'n':
     case 'o':                               case 's': case 't':
     case 'v': case 'w': case 'x': case 'y': case 'z':
-      ret = d_make_builtin_type (di, &d_builtin_types[peek - 'a']);
+      ret = d_make_builtin_type (di,
+                                &cplus_demangle_builtin_types[peek - 'a']);
       di->expansion += ret->u.s_builtin.type->len;
       can_subst = 0;
       d_advance (di, 1);
@@ -1853,7 +1831,8 @@ d_type (di)
 
     case 'u':
       d_advance (di, 1);
-      ret = d_make_comp (di, D_COMP_VENDOR_TYPE, d_source_name (di), NULL);
+      ret = d_make_comp (di, DEMANGLE_COMPONENT_VENDOR_TYPE,
+                        d_source_name (di), NULL);
       break;
 
     case 'F':
@@ -1884,7 +1863,8 @@ d_type (di)
             candidate.  */
          if (! d_add_substitution (di, ret))
            return NULL;
-         ret = d_make_comp (di, D_COMP_TEMPLATE, ret, d_template_args (di));
+         ret = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, ret,
+                            d_template_args (di));
        }
       break;
 
@@ -1903,7 +1883,7 @@ d_type (di)
            /* The substituted name may have been a template name and
               may be followed by tepmlate args.  */
            if (d_peek_char (di) == 'I')
-             ret = d_make_comp (di, D_COMP_TEMPLATE, ret,
+             ret = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, ret,
                                 d_template_args (di));
            else
              can_subst = 0;
@@ -1915,7 +1895,7 @@ d_type (di)
               a new substitution candidate.  However, if the
               substitution was followed by template arguments, then
               the whole thing is a substitution candidate.  */
-           if (ret != NULL && ret->type == D_COMP_SUB_STD)
+           if (ret != NULL && ret->type == DEMANGLE_COMPONENT_SUB_STD)
              can_subst = 0;
          }
       }
@@ -1923,28 +1903,33 @@ d_type (di)
 
     case 'P':
       d_advance (di, 1);
-      ret = d_make_comp (di, D_COMP_POINTER, d_type (di), NULL);
+      ret = d_make_comp (di, DEMANGLE_COMPONENT_POINTER,
+                        cplus_demangle_type (di), NULL);
       break;
 
     case 'R':
       d_advance (di, 1);
-      ret = d_make_comp (di, D_COMP_REFERENCE, d_type (di), NULL);
+      ret = d_make_comp (di, DEMANGLE_COMPONENT_REFERENCE,
+                        cplus_demangle_type (di), NULL);
       break;
 
     case 'C':
       d_advance (di, 1);
-      ret = d_make_comp (di, D_COMP_COMPLEX, d_type (di), NULL);
+      ret = d_make_comp (di, DEMANGLE_COMPONENT_COMPLEX,
+                        cplus_demangle_type (di), NULL);
       break;
 
     case 'G':
       d_advance (di, 1);
-      ret = d_make_comp (di, D_COMP_IMAGINARY, d_type (di), NULL);
+      ret = d_make_comp (di, DEMANGLE_COMPONENT_IMAGINARY,
+                        cplus_demangle_type (di), NULL);
       break;
 
     case 'U':
       d_advance (di, 1);
       ret = d_source_name (di);
-      ret = d_make_comp (di, D_COMP_VENDOR_TYPE_QUAL, d_type (di), ret);
+      ret = d_make_comp (di, DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL,
+                        cplus_demangle_type (di), ret);
       break;
 
     default:
@@ -1962,10 +1947,10 @@ d_type (di)
 
 /* <CV-qualifiers> ::= [r] [V] [K]  */
 
-static struct d_comp **
+static struct demangle_component **
 d_cv_qualifiers (di, pret, member_fn)
      struct d_info *di;
-     struct d_comp **pret;
+     struct demangle_component **pret;
      int member_fn;
 {
   char peek;
@@ -1973,22 +1958,28 @@ d_cv_qualifiers (di, pret, member_fn)
   peek = d_peek_char (di);
   while (peek == 'r' || peek == 'V' || peek == 'K')
     {
-      enum d_comp_type t;
+      enum demangle_component_type t;
 
       d_advance (di, 1);
       if (peek == 'r')
        {
-         t = member_fn ? D_COMP_RESTRICT_THIS : D_COMP_RESTRICT;
+         t = (member_fn
+              ? DEMANGLE_COMPONENT_RESTRICT_THIS
+              : DEMANGLE_COMPONENT_RESTRICT);
          di->expansion += sizeof "restrict";
        }
       else if (peek == 'V')
        {
-         t = member_fn ? D_COMP_VOLATILE_THIS : D_COMP_VOLATILE;
+         t = (member_fn
+              ? DEMANGLE_COMPONENT_VOLATILE_THIS
+              : DEMANGLE_COMPONENT_VOLATILE);
          di->expansion += sizeof "volatile";
        }
       else
        {
-         t = member_fn ? D_COMP_CONST_THIS : D_COMP_CONST;
+         t = (member_fn
+              ? DEMANGLE_COMPONENT_CONST_THIS
+              : DEMANGLE_COMPONENT_CONST);
          di->expansion += sizeof "const";
        }
 
@@ -2005,11 +1996,11 @@ d_cv_qualifiers (di, pret, member_fn)
 
 /* <function-type> ::= F [Y] <bare-function-type> E  */
 
-static struct d_comp *
+static struct demangle_component *
 d_function_type (di)
      struct d_info *di;
 {
-  struct d_comp *ret;
+  struct demangle_component *ret;
 
   if (d_next_char (di) != 'F')
     return NULL;
@@ -2027,14 +2018,14 @@ d_function_type (di)
 
 /* <bare-function-type> ::= <type>+  */
 
-static struct d_comp *
+static struct demangle_component *
 d_bare_function_type (di, has_return_type)
      struct d_info *di;
      int has_return_type;
 {
-  struct d_comp *return_type;
-  struct d_comp *tl;
-  struct d_comp **ptl;
+  struct demangle_component *return_type;
+  struct demangle_component *tl;
+  struct demangle_component **ptl;
 
   return_type = NULL;
   tl = NULL;
@@ -2042,12 +2033,12 @@ d_bare_function_type (di, has_return_type)
   while (1)
     {
       char peek;
-      struct d_comp *type;
+      struct demangle_component *type;
 
       peek = d_peek_char (di);
       if (peek == '\0' || peek == 'E')
        break;
-      type = d_type (di);
+      type = cplus_demangle_type (di);
       if (type == NULL)
        return NULL;
       if (has_return_type)
@@ -2057,7 +2048,7 @@ d_bare_function_type (di, has_return_type)
        }
       else
        {
-         *ptl = d_make_comp (di, D_COMP_ARGLIST, type, NULL);
+         *ptl = d_make_comp (di, DEMANGLE_COMPONENT_ARGLIST, type, NULL);
          if (*ptl == NULL)
            return NULL;
          ptl = &d_right (*ptl);
@@ -2072,19 +2063,19 @@ d_bare_function_type (di, has_return_type)
 
   /* If we have a single parameter type void, omit it.  */
   if (d_right (tl) == NULL
-      && d_left (tl)->type == D_COMP_BUILTIN_TYPE
+      && d_left (tl)->type == DEMANGLE_COMPONENT_BUILTIN_TYPE
       && d_left (tl)->u.s_builtin.type->print == D_PRINT_VOID)
     {
       di->expansion -= d_left (tl)->u.s_builtin.type->len;
       tl = NULL;
     }
 
-  return d_make_comp (di, D_COMP_FUNCTION_TYPE, return_type, tl);
+  return d_make_comp (di, DEMANGLE_COMPONENT_FUNCTION_TYPE, return_type, tl);
 }
 
 /* <class-enum-type> ::= <name>  */
 
-static struct d_comp *
+static struct demangle_component *
 d_class_enum_type (di)
      struct d_info *di;
 {
@@ -2095,12 +2086,12 @@ d_class_enum_type (di)
                 ::= A [<(dimension) expression>] _ <(element) type>
 */
 
-static struct d_comp *
+static struct demangle_component *
 d_array_type (di)
      struct d_info *di;
 {
   char peek;
-  struct d_comp *dim;
+  struct demangle_component *dim;
 
   if (d_next_char (di) != 'A')
     return NULL;
@@ -2133,23 +2124,24 @@ d_array_type (di)
   if (d_next_char (di) != '_')
     return NULL;
 
-  return d_make_comp (di, D_COMP_ARRAY_TYPE, dim, d_type (di));
+  return d_make_comp (di, DEMANGLE_COMPONENT_ARRAY_TYPE, dim,
+                     cplus_demangle_type (di));
 }
 
 /* <pointer-to-member-type> ::= M <(class) type> <(member) type>  */
 
-static struct d_comp *
+static struct demangle_component *
 d_pointer_to_member_type (di)
      struct d_info *di;
 {
-  struct d_comp *cl;
-  struct d_comp *mem;
-  struct d_comp **pmem;
+  struct demangle_component *cl;
+  struct demangle_component *mem;
+  struct demangle_component **pmem;
 
   if (d_next_char (di) != 'M')
     return NULL;
 
-  cl = d_type (di);
+  cl = cplus_demangle_type (di);
 
   /* The ABI specifies that any type can be a substitution source, and
      that M is followed by two types, and that when a CV-qualified
@@ -2162,21 +2154,21 @@ d_pointer_to_member_type (di)
      g++ does not work that way.  g++ treats only the CV-qualified
      member function as a substitution source.  FIXME.  So to work
      with g++, we need to pull off the CV-qualifiers here, in order to
-     avoid calling add_substitution() in d_type().  */
+     avoid calling add_substitution() in cplus_demangle_type().  */
 
   pmem = d_cv_qualifiers (di, &mem, 1);
   if (pmem == NULL)
     return NULL;
-  *pmem = d_type (di);
+  *pmem = cplus_demangle_type (di);
 
-  return d_make_comp (di, D_COMP_PTRMEM_TYPE, cl, mem);
+  return d_make_comp (di, DEMANGLE_COMPONENT_PTRMEM_TYPE, cl, mem);
 }
 
 /* <template-param> ::= T_
                     ::= T <(parameter-2 non-negative) number> _
 */
 
-static struct d_comp *
+static struct demangle_component *
 d_template_param (di)
      struct d_info *di;
 {
@@ -2205,13 +2197,13 @@ d_template_param (di)
 
 /* <template-args> ::= I <template-arg>+ E  */
 
-static struct d_comp *
+static struct demangle_component *
 d_template_args (di)
      struct d_info *di;
 {
-  struct d_comp *hold_last_name;
-  struct d_comp *al;
-  struct d_comp **pal;
+  struct demangle_component *hold_last_name;
+  struct demangle_component *al;
+  struct demangle_component **pal;
 
   /* Preserve the last name we saw--don't let the template arguments
      clobber it, as that would give us the wrong name for a subsequent
@@ -2225,13 +2217,13 @@ d_template_args (di)
   pal = &al;
   while (1)
     {
-      struct d_comp *a;
+      struct demangle_component *a;
 
       a = d_template_arg (di);
       if (a == NULL)
        return NULL;
 
-      *pal = d_make_comp (di, D_COMP_TEMPLATE_ARGLIST, a, NULL);
+      *pal = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE_ARGLIST, a, NULL);
       if (*pal == NULL)
        return NULL;
       pal = &d_right (*pal);
@@ -2253,11 +2245,11 @@ d_template_args (di)
                   ::= <expr-primary>
 */
 
-static struct d_comp *
+static struct demangle_component *
 d_template_arg (di)
      struct d_info *di;
 {
-  struct d_comp *ret;
+  struct demangle_component *ret;
 
   switch (d_peek_char (di))
     {
@@ -2272,7 +2264,7 @@ d_template_arg (di)
       return d_expr_primary (di);
 
     default:
-      return d_type (di);
+      return cplus_demangle_type (di);
     }
 }
 
@@ -2286,7 +2278,7 @@ d_template_arg (di)
                 ::= <expr-primary>
 */
 
-static struct d_comp *
+static struct demangle_component *
 d_expression (di)
      struct d_info *di;
 {
@@ -2299,46 +2291,47 @@ d_expression (di)
     return d_template_param (di);
   else if (peek == 's' && d_peek_next_char (di) == 'r')
     {
-      struct d_comp *type;
-      struct d_comp *name;
+      struct demangle_component *type;
+      struct demangle_component *name;
 
       d_advance (di, 2);
-      type = d_type (di);
+      type = cplus_demangle_type (di);
       name = d_unqualified_name (di);
       if (d_peek_char (di) != 'I')
-       return d_make_comp (di, D_COMP_QUAL_NAME, type, name);
+       return d_make_comp (di, DEMANGLE_COMPONENT_QUAL_NAME, type, name);
       else
-       return d_make_comp (di, D_COMP_QUAL_NAME, type,
-                           d_make_comp (di, D_COMP_TEMPLATE, name,
+       return d_make_comp (di, DEMANGLE_COMPONENT_QUAL_NAME, type,
+                           d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, name,
                                         d_template_args (di)));
     }
   else
     {
-      struct d_comp *op;
+      struct demangle_component *op;
       int args;
 
       op = d_operator_name (di);
       if (op == NULL)
        return NULL;
 
-      if (op->type == D_COMP_OPERATOR)
+      if (op->type == DEMANGLE_COMPONENT_OPERATOR)
        di->expansion += op->u.s_operator.op->len - 2;
 
-      if (op->type == D_COMP_OPERATOR
+      if (op->type == DEMANGLE_COMPONENT_OPERATOR
          && strcmp (op->u.s_operator.op->code, "st") == 0)
-       return d_make_comp (di, D_COMP_UNARY, op, d_type (di));
+       return d_make_comp (di, DEMANGLE_COMPONENT_UNARY, op,
+                           cplus_demangle_type (di));
 
       switch (op->type)
        {
        default:
          return NULL;
-       case D_COMP_OPERATOR:
+       case DEMANGLE_COMPONENT_OPERATOR:
          args = op->u.s_operator.op->args;
          break;
-       case D_COMP_EXTENDED_OPERATOR:
+       case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
          args = op->u.s_extended_operator.args;
          break;
-       case D_COMP_CAST:
+       case DEMANGLE_COMPONENT_CAST:
          args = 1;
          break;
        }
@@ -2346,27 +2339,32 @@ d_expression (di)
       switch (args)
        {
        case 1:
-         return d_make_comp (di, D_COMP_UNARY, op, d_expression (di));
+         return d_make_comp (di, DEMANGLE_COMPONENT_UNARY, op,
+                             d_expression (di));
        case 2:
          {
-           struct d_comp *left;
+           struct demangle_component *left;
 
            left = d_expression (di);
-           return d_make_comp (di, D_COMP_BINARY, op,
-                               d_make_comp (di, D_COMP_BINARY_ARGS, left,
+           return d_make_comp (di, DEMANGLE_COMPONENT_BINARY, op,
+                               d_make_comp (di,
+                                            DEMANGLE_COMPONENT_BINARY_ARGS,
+                                            left,
                                             d_expression (di)));
          }
        case 3:
          {
-           struct d_comp *first;
-           struct d_comp *second;
+           struct demangle_component *first;
+           struct demangle_component *second;
 
            first = d_expression (di);
            second = d_expression (di);
-           return d_make_comp (di, D_COMP_TRINARY, op,
-                               d_make_comp (di, D_COMP_TRINARY_ARG1, first,
+           return d_make_comp (di, DEMANGLE_COMPONENT_TRINARY, op,
+                               d_make_comp (di,
+                                            DEMANGLE_COMPONENT_TRINARY_ARG1,
+                                            first,
                                             d_make_comp (di,
-                                                         D_COMP_TRINARY_ARG2,
+                                                         DEMANGLE_COMPONENT_TRINARY_ARG2,
                                                          second,
                                                          d_expression (di))));
          }
@@ -2381,27 +2379,27 @@ d_expression (di)
                   ::= L <mangled-name> E
 */
 
-static struct d_comp *
+static struct demangle_component *
 d_expr_primary (di)
      struct d_info *di;
 {
-  struct d_comp *ret;
+  struct demangle_component *ret;
 
   if (d_next_char (di) != 'L')
     return NULL;
   if (d_peek_char (di) == '_')
-    ret = d_mangled_name (di, 0);
+    ret = cplus_demangle_mangled_name (di, 0);
   else
     {
-      struct d_comp *type;
-      enum d_comp_type t;
+      struct demangle_component *type;
+      enum demangle_component_type t;
       const char *s;
 
-      type = d_type (di);
+      type = cplus_demangle_type (di);
 
       /* If we have a type we know how to print, we aren't going to
         print the type name itself.  */
-      if (type->type == D_COMP_BUILTIN_TYPE
+      if (type->type == DEMANGLE_COMPONENT_BUILTIN_TYPE
          && type->u.s_builtin.type->print != D_PRINT_DEFAULT)
        di->expansion -= type->u.s_builtin.type->len;
 
@@ -2416,10 +2414,10 @@ d_expr_primary (di)
         constant in any readable form anyhow.  We don't attempt to
         handle these cases.  */
 
-      t = D_COMP_LITERAL;
+      t = DEMANGLE_COMPONENT_LITERAL;
       if (d_peek_char (di) == 'n')
        {
-         t = D_COMP_LITERAL_NEG;
+         t = DEMANGLE_COMPONENT_LITERAL_NEG;
          d_advance (di, 1);
        }
       s = d_str (di);
@@ -2436,11 +2434,11 @@ d_expr_primary (di)
                 ::= Z <(function) encoding> E s [<discriminator>]
 */
 
-static struct d_comp *
+static struct demangle_component *
 d_local_name (di)
      struct d_info *di;
 {
-  struct d_comp *function;
+  struct demangle_component *function;
 
   if (d_next_char (di) != 'Z')
     return NULL;
@@ -2455,18 +2453,18 @@ d_local_name (di)
       d_advance (di, 1);
       if (! d_discriminator (di))
        return NULL;
-      return d_make_comp (di, D_COMP_LOCAL_NAME, function,
+      return d_make_comp (di, DEMANGLE_COMPONENT_LOCAL_NAME, function,
                          d_make_name (di, "string literal",
                                       sizeof "string literal" - 1));
     }
   else
     {
-      struct d_comp *name;
+      struct demangle_component *name;
 
       name = d_name (di);
       if (! d_discriminator (di))
        return NULL;
-      return d_make_comp (di, D_COMP_LOCAL_NAME, function, name);
+      return d_make_comp (di, DEMANGLE_COMPONENT_LOCAL_NAME, function, name);
     }
 }
 
@@ -2495,7 +2493,7 @@ d_discriminator (di)
 static int
 d_add_substitution (di, dc)
      struct d_info *di;
-     struct d_comp *dc;
+     struct demangle_component *dc;
 {
   if (dc == NULL)
     return 0;
@@ -2550,7 +2548,7 @@ static const struct d_standard_sub_info standard_subs[] =
     NL ("basic_iostream") }
 };
 
-static struct d_comp *
+static struct demangle_component *
 d_substitution (di, prefix)
      struct d_info *di;
      int prefix;
@@ -2729,10 +2727,11 @@ d_print_error (dpi)
    sets *PALC to 0 for a bad parse, or to 1 for a memory allocation
    failure.  */
 
-static char *
-d_print (options, dc, estimate, palc)
+CP_STATIC_IF_GLIBCPP_V3
+char *
+cplus_demangle_print (options, dc, estimate, palc)
      int options;
-     const struct d_comp *dc;
+     const struct demangle_component *dc;
      int estimate;
      size_t *palc;
 {
@@ -2771,7 +2770,7 @@ d_print (options, dc, estimate, palc)
 static void
 d_print_comp (dpi, dc)
      struct d_print_info *dpi;
-     const struct d_comp *dc;
+     const struct demangle_component *dc;
 {
   if (dc == NULL)
     {
@@ -2783,15 +2782,15 @@ d_print_comp (dpi, dc)
 
   switch (dc->type)
     {
-    case D_COMP_NAME:
+    case DEMANGLE_COMPONENT_NAME:
       if ((dpi->options & DMGL_JAVA) == 0)
        d_append_buffer (dpi, dc->u.s_name.s, dc->u.s_name.len);
       else
        d_print_java_identifier (dpi, dc->u.s_name.s, dc->u.s_name.len);
       return;
 
-    case D_COMP_QUAL_NAME:
-    case D_COMP_LOCAL_NAME:
+    case DEMANGLE_COMPONENT_QUAL_NAME:
+    case DEMANGLE_COMPONENT_LOCAL_NAME:
       d_print_comp (dpi, d_left (dc));
       if ((dpi->options & DMGL_JAVA) == 0)
        d_append_string_constant (dpi, "::");
@@ -2800,10 +2799,10 @@ d_print_comp (dpi, dc)
       d_print_comp (dpi, d_right (dc));
       return;
 
-    case D_COMP_TYPED_NAME:
+    case DEMANGLE_COMPONENT_TYPED_NAME:
       {
        struct d_print_mod *hold_modifiers;
-       struct d_comp *typed_name;
+       struct demangle_component *typed_name;
        struct d_print_mod adpm[4];
        unsigned int i;
        struct d_print_template dpt;
@@ -2829,9 +2828,9 @@ d_print_comp (dpi, dc)
            adpm[i].templates = dpi->templates;
            ++i;
 
-           if (typed_name->type != D_COMP_RESTRICT_THIS
-               && typed_name->type != D_COMP_VOLATILE_THIS
-               && typed_name->type != D_COMP_CONST_THIS)
+           if (typed_name->type != DEMANGLE_COMPONENT_RESTRICT_THIS
+               && typed_name->type != DEMANGLE_COMPONENT_VOLATILE_THIS
+               && typed_name->type != DEMANGLE_COMPONENT_CONST_THIS)
              break;
 
            typed_name = d_left (typed_name);
@@ -2839,25 +2838,25 @@ d_print_comp (dpi, dc)
 
        /* If typed_name is a template, then it applies to the
           function type as well.  */
-       if (typed_name->type == D_COMP_TEMPLATE)
+       if (typed_name->type == DEMANGLE_COMPONENT_TEMPLATE)
          {
            dpt.next = dpi->templates;
            dpi->templates = &dpt;
            dpt.template = typed_name;
          }
 
-       /* If typed_name is a D_COMP_LOCAL_NAME, then there may be
-          CV-qualifiers on its right argument which really apply
-          here; this happens when parsing a class which is local to a
-          function.  */
-       if (typed_name->type == D_COMP_LOCAL_NAME)
+       /* If typed_name is a DEMANGLE_COMPONENT_LOCAL_NAME, then
+          there may be CV-qualifiers on its right argument which
+          really apply here; this happens when parsing a class which
+          is local to a function.  */
+       if (typed_name->type == DEMANGLE_COMPONENT_LOCAL_NAME)
          {
-           struct d_comp *local_name;
+           struct demangle_component *local_name;
 
            local_name = d_right (typed_name);
-           while (local_name->type == D_COMP_RESTRICT_THIS
-                  || local_name->type == D_COMP_VOLATILE_THIS
-                  || local_name->type == D_COMP_CONST_THIS)
+           while (local_name->type == DEMANGLE_COMPONENT_RESTRICT_THIS
+                  || local_name->type == DEMANGLE_COMPONENT_VOLATILE_THIS
+                  || local_name->type == DEMANGLE_COMPONENT_CONST_THIS)
              {
                if (i >= sizeof adpm / sizeof adpm[0])
                  {
@@ -2880,7 +2879,7 @@ d_print_comp (dpi, dc)
 
        d_print_comp (dpi, d_right (dc));
 
-       if (typed_name->type == D_COMP_TEMPLATE)
+       if (typed_name->type == DEMANGLE_COMPONENT_TEMPLATE)
          dpi->templates = dpt.next;
 
        /* If the modifiers didn't get printed by the type, print them
@@ -2900,7 +2899,7 @@ d_print_comp (dpi, dc)
        return;
       }
 
-    case D_COMP_TEMPLATE:
+    case DEMANGLE_COMPONENT_TEMPLATE:
       {
        struct d_print_mod *hold_dpm;
 
@@ -2927,10 +2926,10 @@ d_print_comp (dpi, dc)
        return;
       }
 
-    case D_COMP_TEMPLATE_PARAM:
+    case DEMANGLE_COMPONENT_TEMPLATE_PARAM:
       {
        long i;
-       struct d_comp *a;
+       struct demangle_component *a;
        struct d_print_template *hold_dpt;
 
        if (dpi->templates == NULL)
@@ -2943,7 +2942,7 @@ d_print_comp (dpi, dc)
             a != NULL;
             a = d_right (a))
          {
-           if (a->type != D_COMP_TEMPLATE_ARGLIST)
+           if (a->type != DEMANGLE_COMPONENT_TEMPLATE_ARGLIST)
              {
                d_print_error (dpi);
                return;
@@ -2973,92 +2972,92 @@ d_print_comp (dpi, dc)
        return;
       }
 
-    case D_COMP_CTOR:
+    case DEMANGLE_COMPONENT_CTOR:
       d_print_comp (dpi, dc->u.s_ctor.name);
       return;
 
-    case D_COMP_DTOR:
+    case DEMANGLE_COMPONENT_DTOR:
       d_append_char (dpi, '~');
       d_print_comp (dpi, dc->u.s_dtor.name);
       return;
 
-    case D_COMP_VTABLE:
+    case DEMANGLE_COMPONENT_VTABLE:
       d_append_string_constant (dpi, "vtable for ");
       d_print_comp (dpi, d_left (dc));
       return;
 
-    case D_COMP_VTT:
+    case DEMANGLE_COMPONENT_VTT:
       d_append_string_constant (dpi, "VTT for ");
       d_print_comp (dpi, d_left (dc));
       return;
 
-    case D_COMP_CONSTRUCTION_VTABLE:
+    case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE:
       d_append_string_constant (dpi, "construction vtable for ");
       d_print_comp (dpi, d_left (dc));
       d_append_string_constant (dpi, "-in-");
       d_print_comp (dpi, d_right (dc));
       return;
 
-    case D_COMP_TYPEINFO:
+    case DEMANGLE_COMPONENT_TYPEINFO:
       d_append_string_constant (dpi, "typeinfo for ");
       d_print_comp (dpi, d_left (dc));
       return;
 
-    case D_COMP_TYPEINFO_NAME:
+    case DEMANGLE_COMPONENT_TYPEINFO_NAME:
       d_append_string_constant (dpi, "typeinfo name for ");
       d_print_comp (dpi, d_left (dc));
       return;
 
-    case D_COMP_TYPEINFO_FN:
+    case DEMANGLE_COMPONENT_TYPEINFO_FN:
       d_append_string_constant (dpi, "typeinfo fn for ");
       d_print_comp (dpi, d_left (dc));
       return;
 
-    case D_COMP_THUNK:
+    case DEMANGLE_COMPONENT_THUNK:
       d_append_string_constant (dpi, "non-virtual thunk to ");
       d_print_comp (dpi, d_left (dc));
       return;
 
-    case D_COMP_VIRTUAL_THUNK:
+    case DEMANGLE_COMPONENT_VIRTUAL_THUNK:
       d_append_string_constant (dpi, "virtual thunk to ");
       d_print_comp (dpi, d_left (dc));
       return;
 
-    case D_COMP_COVARIANT_THUNK:
+    case DEMANGLE_COMPONENT_COVARIANT_THUNK:
       d_append_string_constant (dpi, "covariant return thunk to ");
       d_print_comp (dpi, d_left (dc));
       return;
 
-    case D_COMP_JAVA_CLASS:
+    case DEMANGLE_COMPONENT_JAVA_CLASS:
       d_append_string_constant (dpi, "java Class for ");
       d_print_comp (dpi, d_left (dc));
       return;
 
-    case D_COMP_GUARD:
+    case DEMANGLE_COMPONENT_GUARD:
       d_append_string_constant (dpi, "guard variable for ");
       d_print_comp (dpi, d_left (dc));
       return;
 
-    case D_COMP_REFTEMP:
+    case DEMANGLE_COMPONENT_REFTEMP:
       d_append_string_constant (dpi, "reference temporary for ");
       d_print_comp (dpi, d_left (dc));
       return;
 
-    case D_COMP_SUB_STD:
+    case DEMANGLE_COMPONENT_SUB_STD:
       d_append_buffer (dpi, dc->u.s_string.string, dc->u.s_string.len);
       return;
 
-    case D_COMP_RESTRICT:
-    case D_COMP_VOLATILE:
-    case D_COMP_CONST:
-    case D_COMP_RESTRICT_THIS:
-    case D_COMP_VOLATILE_THIS:
-    case D_COMP_CONST_THIS:
-    case D_COMP_VENDOR_TYPE_QUAL:
-    case D_COMP_POINTER:
-    case D_COMP_REFERENCE:
-    case D_COMP_COMPLEX:
-    case D_COMP_IMAGINARY:
+    case DEMANGLE_COMPONENT_RESTRICT:
+    case DEMANGLE_COMPONENT_VOLATILE:
+    case DEMANGLE_COMPONENT_CONST:
+    case DEMANGLE_COMPONENT_RESTRICT_THIS:
+    case DEMANGLE_COMPONENT_VOLATILE_THIS:
+    case DEMANGLE_COMPONENT_CONST_THIS:
+    case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
+    case DEMANGLE_COMPONENT_POINTER:
+    case DEMANGLE_COMPONENT_REFERENCE:
+    case DEMANGLE_COMPONENT_COMPLEX:
+    case DEMANGLE_COMPONENT_IMAGINARY:
       {
        /* We keep a list of modifiers on the stack.  */
        struct d_print_mod dpm;
@@ -3081,7 +3080,7 @@ d_print_comp (dpi, dc)
        return;
       }
 
-    case D_COMP_BUILTIN_TYPE:
+    case DEMANGLE_COMPONENT_BUILTIN_TYPE:
       if ((dpi->options & DMGL_JAVA) == 0)
        d_append_buffer (dpi, dc->u.s_builtin.type->name,
                         dc->u.s_builtin.type->len);
@@ -3090,11 +3089,11 @@ d_print_comp (dpi, dc)
                         dc->u.s_builtin.type->java_len);
       return;
 
-    case D_COMP_VENDOR_TYPE:
+    case DEMANGLE_COMPONENT_VENDOR_TYPE:
       d_print_comp (dpi, d_left (dc));
       return;
 
-    case D_COMP_FUNCTION_TYPE:
+    case DEMANGLE_COMPONENT_FUNCTION_TYPE:
       {
        if (d_left (dc) != NULL)
          {
@@ -3124,7 +3123,7 @@ d_print_comp (dpi, dc)
        return;
       }
 
-    case D_COMP_ARRAY_TYPE:
+    case DEMANGLE_COMPONENT_ARRAY_TYPE:
       {
        struct d_print_mod dpm;
 
@@ -3149,7 +3148,7 @@ d_print_comp (dpi, dc)
        return;
       }
 
-    case D_COMP_PTRMEM_TYPE:
+    case DEMANGLE_COMPONENT_PTRMEM_TYPE:
       {
        struct d_print_mod dpm;
 
@@ -3175,8 +3174,8 @@ d_print_comp (dpi, dc)
        return;
       }
 
-    case D_COMP_ARGLIST:
-    case D_COMP_TEMPLATE_ARGLIST:
+    case DEMANGLE_COMPONENT_ARGLIST:
+    case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
       d_print_comp (dpi, d_left (dc));
       if (d_right (dc) != NULL)
        {
@@ -3185,7 +3184,7 @@ d_print_comp (dpi, dc)
        }
       return;
 
-    case D_COMP_OPERATOR:
+    case DEMANGLE_COMPONENT_OPERATOR:
       {
        char c;
 
@@ -3198,18 +3197,18 @@ d_print_comp (dpi, dc)
        return;
       }
 
-    case D_COMP_EXTENDED_OPERATOR:
+    case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
       d_append_string_constant (dpi, "operator ");
       d_print_comp (dpi, dc->u.s_extended_operator.name);
       return;
 
-    case D_COMP_CAST:
+    case DEMANGLE_COMPONENT_CAST:
       d_append_string_constant (dpi, "operator ");
       d_print_cast (dpi, dc);
       return;
 
-    case D_COMP_UNARY:
-      if (d_left (dc)->type != D_COMP_CAST)
+    case DEMANGLE_COMPONENT_UNARY:
+      if (d_left (dc)->type != DEMANGLE_COMPONENT_CAST)
        d_print_expr_op (dpi, d_left (dc));
       else
        {
@@ -3220,12 +3219,12 @@ d_print_comp (dpi, dc)
       d_append_char (dpi, '(');
       d_print_comp (dpi, d_right (dc));
       d_append_char (dpi, ')');
-      if (d_left (dc)->type == D_COMP_CAST)
+      if (d_left (dc)->type == DEMANGLE_COMPONENT_CAST)
        d_append_char (dpi, ')');
       return;
 
-    case D_COMP_BINARY:
-      if (d_right (dc)->type != D_COMP_BINARY_ARGS)
+    case DEMANGLE_COMPONENT_BINARY:
+      if (d_right (dc)->type != DEMANGLE_COMPONENT_BINARY_ARGS)
        {
          d_print_error (dpi);
          return;
@@ -3234,7 +3233,7 @@ d_print_comp (dpi, dc)
       /* We wrap an expression which uses the greater-than operator in
         an extra layer of parens so that it does not get confused
         with the '>' which ends the template parameters.  */
-      if (d_left (dc)->type == D_COMP_OPERATOR
+      if (d_left (dc)->type == DEMANGLE_COMPONENT_OPERATOR
          && d_left (dc)->u.s_operator.op->len == 1
          && d_left (dc)->u.s_operator.op->name[0] == '>')
        d_append_char (dpi, '(');
@@ -3247,21 +3246,21 @@ d_print_comp (dpi, dc)
       d_print_comp (dpi, d_right (d_right (dc)));
       d_append_char (dpi, ')');
 
-      if (d_left (dc)->type == D_COMP_OPERATOR
+      if (d_left (dc)->type == DEMANGLE_COMPONENT_OPERATOR
          && d_left (dc)->u.s_operator.op->len == 1
          && d_left (dc)->u.s_operator.op->name[0] == '>')
        d_append_char (dpi, ')');
 
       return;
 
-    case D_COMP_BINARY_ARGS:
-      /* We should only see this as part of D_COMP_BINARY.  */
+    case DEMANGLE_COMPONENT_BINARY_ARGS:
+      /* We should only see this as part of DEMANGLE_COMPONENT_BINARY.  */
       d_print_error (dpi);
       return;
 
-    case D_COMP_TRINARY:
-      if (d_right (dc)->type != D_COMP_TRINARY_ARG1
-         || d_right (d_right (dc))->type != D_COMP_TRINARY_ARG2)
+    case DEMANGLE_COMPONENT_TRINARY:
+      if (d_right (dc)->type != DEMANGLE_COMPONENT_TRINARY_ARG1
+         || d_right (d_right (dc))->type != DEMANGLE_COMPONENT_TRINARY_ARG2)
        {
          d_print_error (dpi);
          return;
@@ -3277,23 +3276,23 @@ d_print_comp (dpi, dc)
       d_append_char (dpi, ')');
       return;
 
-    case D_COMP_TRINARY_ARG1:
-    case D_COMP_TRINARY_ARG2:
-      /* We should only see these are part of D_COMP_TRINARY.  */
+    case DEMANGLE_COMPONENT_TRINARY_ARG1:
+    case DEMANGLE_COMPONENT_TRINARY_ARG2:
+      /* We should only see these are part of DEMANGLE_COMPONENT_TRINARY.  */
       d_print_error (dpi);
       return;
 
-    case D_COMP_LITERAL:
-    case D_COMP_LITERAL_NEG:
+    case DEMANGLE_COMPONENT_LITERAL:
+    case DEMANGLE_COMPONENT_LITERAL_NEG:
       /* For some builtin types, produce simpler output.  */
-      if (d_left (dc)->type == D_COMP_BUILTIN_TYPE)
+      if (d_left (dc)->type == DEMANGLE_COMPONENT_BUILTIN_TYPE)
        {
          switch (d_left (dc)->u.s_builtin.type->print)
            {
            case D_PRINT_INT:
-             if (d_right (dc)->type == D_COMP_NAME)
+             if (d_right (dc)->type == DEMANGLE_COMPONENT_NAME)
                {
-                 if (dc->type == D_COMP_LITERAL_NEG)
+                 if (dc->type == DEMANGLE_COMPONENT_LITERAL_NEG)
                    d_append_char (dpi, '-');
                  d_print_comp (dpi, d_right (dc));
                  return;
@@ -3301,9 +3300,9 @@ d_print_comp (dpi, dc)
              break;
 
            case D_PRINT_LONG:
-             if (d_right (dc)->type == D_COMP_NAME)
+             if (d_right (dc)->type == DEMANGLE_COMPONENT_NAME)
                {
-                 if (dc->type == D_COMP_LITERAL_NEG)
+                 if (dc->type == DEMANGLE_COMPONENT_LITERAL_NEG)
                    d_append_char (dpi, '-');
                  d_print_comp (dpi, d_right (dc));
                  d_append_char (dpi, 'l');
@@ -3312,9 +3311,9 @@ d_print_comp (dpi, dc)
              break;
 
            case D_PRINT_BOOL:
-             if (d_right (dc)->type == D_COMP_NAME
+             if (d_right (dc)->type == DEMANGLE_COMPONENT_NAME
                  && d_right (dc)->u.s_name.len == 1
-                 && dc->type == D_COMP_LITERAL)
+                 && dc->type == DEMANGLE_COMPONENT_LITERAL)
                {
                  switch (d_right (dc)->u.s_name.s[0])
                    {
@@ -3338,7 +3337,7 @@ d_print_comp (dpi, dc)
       d_append_char (dpi, '(');
       d_print_comp (dpi, d_left (dc));
       d_append_char (dpi, ')');
-      if (dc->type == D_COMP_LITERAL_NEG)
+      if (dc->type == DEMANGLE_COMPONENT_LITERAL_NEG)
        d_append_char (dpi, '-');
       d_print_comp (dpi, d_right (dc));
       return;
@@ -3420,9 +3419,9 @@ d_print_mod_list (dpi, mods, suffix)
 
   if (mods->printed
       || (! suffix
-         && (mods->mod->type == D_COMP_RESTRICT_THIS
-             || mods->mod->type == D_COMP_VOLATILE_THIS
-             || mods->mod->type == D_COMP_CONST_THIS)))
+         && (mods->mod->type == DEMANGLE_COMPONENT_RESTRICT_THIS
+             || mods->mod->type == DEMANGLE_COMPONENT_VOLATILE_THIS
+             || mods->mod->type == DEMANGLE_COMPONENT_CONST_THIS)))
     {
       d_print_mod_list (dpi, mods->next, suffix);
       return;
@@ -3433,22 +3432,22 @@ d_print_mod_list (dpi, mods, suffix)
   hold_dpt = dpi->templates;
   dpi->templates = mods->templates;
 
-  if (mods->mod->type == D_COMP_FUNCTION_TYPE)
+  if (mods->mod->type == DEMANGLE_COMPONENT_FUNCTION_TYPE)
     {
       d_print_function_type (dpi, mods->mod, mods->next);
       dpi->templates = hold_dpt;
       return;
     }
-  else if (mods->mod->type == D_COMP_ARRAY_TYPE)
+  else if (mods->mod->type == DEMANGLE_COMPONENT_ARRAY_TYPE)
     {
       d_print_array_type (dpi, mods->mod, mods->next);
       dpi->templates = hold_dpt;
       return;
     }
-  else if (mods->mod->type == D_COMP_LOCAL_NAME)
+  else if (mods->mod->type == DEMANGLE_COMPONENT_LOCAL_NAME)
     {
       struct d_print_mod *hold_modifiers;
-      struct d_comp *dc;
+      struct demangle_component *dc;
 
       /* When this is on the modifier stack, we have pulled any
         qualifiers off the right argument already.  Otherwise, we
@@ -3466,9 +3465,9 @@ d_print_mod_list (dpi, mods, suffix)
        d_append_char (dpi, '.');
 
       dc = d_right (mods->mod);
-      while (dc->type == D_COMP_RESTRICT_THIS
-            || dc->type == D_COMP_VOLATILE_THIS
-            || dc->type == D_COMP_CONST_THIS)
+      while (dc->type == DEMANGLE_COMPONENT_RESTRICT_THIS
+            || dc->type == DEMANGLE_COMPONENT_VOLATILE_THIS
+            || dc->type == DEMANGLE_COMPONENT_CONST_THIS)
        dc = d_left (dc);
 
       d_print_comp (dpi, dc);
@@ -3489,47 +3488,47 @@ d_print_mod_list (dpi, mods, suffix)
 static void
 d_print_mod (dpi, mod)
      struct d_print_info *dpi;
-     const struct d_comp *mod;
+     const struct demangle_component *mod;
 {
   switch (mod->type)
     {
-    case D_COMP_RESTRICT:
-    case D_COMP_RESTRICT_THIS:
+    case DEMANGLE_COMPONENT_RESTRICT:
+    case DEMANGLE_COMPONENT_RESTRICT_THIS:
       d_append_string_constant (dpi, " restrict");
       return;
-    case D_COMP_VOLATILE:
-    case D_COMP_VOLATILE_THIS:
+    case DEMANGLE_COMPONENT_VOLATILE:
+    case DEMANGLE_COMPONENT_VOLATILE_THIS:
       d_append_string_constant (dpi, " volatile");
       return;
-    case D_COMP_CONST:
-    case D_COMP_CONST_THIS:
+    case DEMANGLE_COMPONENT_CONST:
+    case DEMANGLE_COMPONENT_CONST_THIS:
       d_append_string_constant (dpi, " const");
       return;
-    case D_COMP_VENDOR_TYPE_QUAL:
+    case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
       d_append_char (dpi, ' ');
       d_print_comp (dpi, d_right (mod));
       return;
-    case D_COMP_POINTER:
+    case DEMANGLE_COMPONENT_POINTER:
       /* There is no pointer symbol in Java.  */
       if ((dpi->options & DMGL_JAVA) == 0)
        d_append_char (dpi, '*');
       return;
-    case D_COMP_REFERENCE:
+    case DEMANGLE_COMPONENT_REFERENCE:
       d_append_char (dpi, '&');
       return;
-    case D_COMP_COMPLEX:
+    case DEMANGLE_COMPONENT_COMPLEX:
       d_append_string_constant (dpi, "complex ");
       return;
-    case D_COMP_IMAGINARY:
+    case DEMANGLE_COMPONENT_IMAGINARY:
       d_append_string_constant (dpi, "imaginary ");
       return;
-    case D_COMP_PTRMEM_TYPE:
+    case DEMANGLE_COMPONENT_PTRMEM_TYPE:
       if (d_last_char (dpi) != '(')
        d_append_char (dpi, ' ');
       d_print_comp (dpi, d_left (mod));
       d_append_string_constant (dpi, "::*");
       return;
-    case D_COMP_TYPED_NAME:
+    case DEMANGLE_COMPONENT_TYPED_NAME:
       d_print_comp (dpi, d_left (mod));
       return;
     default:
@@ -3545,7 +3544,7 @@ d_print_mod (dpi, mod)
 static void
 d_print_function_type (dpi, dc, mods)
      struct d_print_info *dpi;
-     const struct d_comp *dc;
+     const struct demangle_component *dc;
      struct d_print_mod *mods;
 {
   int need_paren;
@@ -3563,20 +3562,20 @@ d_print_function_type (dpi, dc, mods)
       saw_mod = 1;
       switch (p->mod->type)
        {
-       case D_COMP_RESTRICT:
-       case D_COMP_VOLATILE:
-       case D_COMP_CONST:
-       case D_COMP_VENDOR_TYPE_QUAL:
-       case D_COMP_POINTER:
-       case D_COMP_REFERENCE:
-       case D_COMP_COMPLEX:
-       case D_COMP_IMAGINARY:
-       case D_COMP_PTRMEM_TYPE:
+       case DEMANGLE_COMPONENT_RESTRICT:
+       case DEMANGLE_COMPONENT_VOLATILE:
+       case DEMANGLE_COMPONENT_CONST:
+       case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
+       case DEMANGLE_COMPONENT_POINTER:
+       case DEMANGLE_COMPONENT_REFERENCE:
+       case DEMANGLE_COMPONENT_COMPLEX:
+       case DEMANGLE_COMPONENT_IMAGINARY:
+       case DEMANGLE_COMPONENT_PTRMEM_TYPE:
          need_paren = 1;
          break;
-       case D_COMP_RESTRICT_THIS:
-       case D_COMP_VOLATILE_THIS:
-       case D_COMP_CONST_THIS:
+       case DEMANGLE_COMPONENT_RESTRICT_THIS:
+       case DEMANGLE_COMPONENT_VOLATILE_THIS:
+       case DEMANGLE_COMPONENT_CONST_THIS:
          break;
        default:
          break;
@@ -3630,7 +3629,7 @@ d_print_function_type (dpi, dc, mods)
 static void
 d_print_array_type (dpi, dc, mods)
      struct d_print_info *dpi;
-     const struct d_comp *dc;
+     const struct demangle_component *dc;
      struct d_print_mod *mods;
 {
   int need_space;
@@ -3647,7 +3646,7 @@ d_print_array_type (dpi, dc, mods)
          if (p->printed)
            break;
 
-         if (p->mod->type == D_COMP_ARRAY_TYPE)
+         if (p->mod->type == DEMANGLE_COMPONENT_ARRAY_TYPE)
            {
              need_space = 0;
              break;
@@ -3685,9 +3684,9 @@ d_print_array_type (dpi, dc, mods)
 static void
 d_print_expr_op (dpi, dc)
      struct d_print_info *dpi;
-     const struct d_comp *dc;
+     const struct demangle_component *dc;
 {
-  if (dc->type == D_COMP_OPERATOR)
+  if (dc->type == DEMANGLE_COMPONENT_OPERATOR)
     d_append_buffer (dpi, dc->u.s_operator.op->name,
                     dc->u.s_operator.op->len);
   else
@@ -3699,9 +3698,9 @@ d_print_expr_op (dpi, dc)
 static void
 d_print_cast (dpi, dc)
      struct d_print_info *dpi;
-     const struct d_comp *dc;
+     const struct demangle_component *dc;
 {
-  if (d_left (dc)->type != D_COMP_TEMPLATE)
+  if (d_left (dc)->type != DEMANGLE_COMPONENT_TEMPLATE)
     d_print_comp (dpi, d_left (dc));
   else
     {
@@ -3741,8 +3740,9 @@ d_print_cast (dpi, dc)
 /* Initialize the information structure we use to pass around
    information.  */
 
-static void
-d_init_info (mangled, options, len, di)
+CP_STATIC_IF_GLIBCPP_V3
+void
+cplus_demangle_init_info (mangled, options, len, di)
      const char *mangled;
      int options;
      size_t len;
@@ -3787,7 +3787,7 @@ d_demangle (mangled, options, palc)
   size_t len;
   int type;
   struct d_info di;
-  struct d_comp *dc;
+  struct demangle_component *dc;
   int estimate;
   char *ret;
 
@@ -3824,20 +3824,20 @@ d_demangle (mangled, options, palc)
       type = 1;
     }
 
-  d_init_info (mangled, options, len, &di);
+  cplus_demangle_init_info (mangled, options, len, &di);
 
   {
 #ifdef CP_DYNAMIC_ARRAYS
-    __extension__ struct d_comp comps[di.num_comps];
-    __extension__ struct d_comp *subs[di.num_subs];
+    __extension__ struct demangle_component comps[di.num_comps];
+    __extension__ struct demangle_component *subs[di.num_subs];
 
     di.comps = &comps[0];
     di.subs = &subs[0];
 #else
-    di.comps = (struct d_comp *) malloc (di.num_comps
-                                        * sizeof (struct d_comp));
-    di.subs = (struct d_comp **) malloc (di.num_subs
-                                        * sizeof (struct d_comp *));
+    di.comps = ((struct demangle_component *)
+               malloc (di.num_comps * sizeof (struct demangle_component)));
+    di.subs = ((struct demangle_component **)
+              malloc (di.num_subs * sizeof (struct demangle_component *)));
     if (di.comps == NULL || di.subs == NULL)
       {
        if (di.comps != NULL)
@@ -3850,9 +3850,9 @@ d_demangle (mangled, options, palc)
 #endif
 
     if (! type)
-      dc = d_mangled_name (&di, 1);
+      dc = cplus_demangle_mangled_name (&di, 1);
     else
-      dc = d_type (&di);
+      dc = cplus_demangle_type (&di);
 
     /* If DMGL_PARAMS is set, then if we didn't consume the entire
        mangled string, then we didn't successfully demangle it.  If
@@ -3875,7 +3875,7 @@ d_demangle (mangled, options, palc)
 
     ret = NULL;
     if (dc != NULL)
-      ret = d_print (options, dc, estimate, palc);
+      ret = cplus_demangle_print (options, dc, estimate, palc);
 
 #ifndef CP_DYNAMIC_ARRAYS
     free (di.comps);
@@ -4076,26 +4076,26 @@ is_ctor_or_dtor (mangled, ctor_kind, dtor_kind)
      enum gnu_v3_dtor_kinds *dtor_kind;
 {
   struct d_info di;
-  struct d_comp *dc;
+  struct demangle_component *dc;
   int ret;
 
   *ctor_kind = (enum gnu_v3_ctor_kinds) 0;
   *dtor_kind = (enum gnu_v3_dtor_kinds) 0;
 
-  d_init_info (mangled, DMGL_GNU_V3, strlen (mangled), &di);
+  cplus_demangle_init_info (mangled, DMGL_GNU_V3, strlen (mangled), &di);
 
   {
 #ifdef CP_DYNAMIC_ARRAYS
-    __extension__ struct d_comp comps[di.num_comps];
-    __extension__ struct d_comp *subs[di.num_subs];
+    __extension__ struct demangle_component comps[di.num_comps];
+    __extension__ struct demangle_component *subs[di.num_subs];
 
     di.comps = &comps[0];
     di.subs = &subs[0];
 #else
-    di.comps = (struct d_comp *) malloc (di.num_comps
-                                        * sizeof (struct d_comp));
-    di.subs = (struct d_comp **) malloc (di.num_subs
-                                        * sizeof (struct d_comp *));
+    di.comps = ((struct demangle_component *)
+               malloc (di.num_comps * sizeof (struct demangle_component)));
+    di.subs = ((struct demangle_component **)
+              malloc (di.num_subs * sizeof (struct demangle_component *)));
     if (di.comps == NULL || di.subs == NULL)
       {
        if (di.comps != NULL)
@@ -4106,7 +4106,7 @@ is_ctor_or_dtor (mangled, ctor_kind, dtor_kind)
       }
 #endif
 
-    dc = d_mangled_name (&di, 1);
+    dc = cplus_demangle_mangled_name (&di, 1);
 
     /* Note that because we did not pass DMGL_PARAMS, we don't expect
        to demangle the entire string.  */
@@ -4119,23 +4119,23 @@ is_ctor_or_dtor (mangled, ctor_kind, dtor_kind)
          default:
            dc = NULL;
            break;
-         case D_COMP_TYPED_NAME:
-         case D_COMP_TEMPLATE:
-         case D_COMP_RESTRICT_THIS:
-         case D_COMP_VOLATILE_THIS:
-         case D_COMP_CONST_THIS:
+         case DEMANGLE_COMPONENT_TYPED_NAME:
+         case DEMANGLE_COMPONENT_TEMPLATE:
+         case DEMANGLE_COMPONENT_RESTRICT_THIS:
+         case DEMANGLE_COMPONENT_VOLATILE_THIS:
+         case DEMANGLE_COMPONENT_CONST_THIS:
            dc = d_left (dc);
            break;
-         case D_COMP_QUAL_NAME:
-         case D_COMP_LOCAL_NAME:
+         case DEMANGLE_COMPONENT_QUAL_NAME:
+         case DEMANGLE_COMPONENT_LOCAL_NAME:
            dc = d_right (dc);
            break;
-         case D_COMP_CTOR:
+         case DEMANGLE_COMPONENT_CTOR:
            *ctor_kind = dc->u.s_ctor.kind;
            ret = 1;
            dc = NULL;
            break;
-         case D_COMP_DTOR:
+         case DEMANGLE_COMPONENT_DTOR:
            *dtor_kind = dc->u.s_dtor.kind;
            ret = 1;
            dc = NULL;
diff --git a/libiberty/cp-demangle.h b/libiberty/cp-demangle.h
new file mode 100644 (file)
index 0000000..d3c57ce
--- /dev/null
@@ -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 *));
diff --git a/libiberty/cp-demint.c b/libiberty/cp-demint.c
new file mode 100644 (file)
index 0000000..833e89e
--- /dev/null
@@ -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;
+}