OSDN Git Service

* cp-demangle.c: Complete rewrite.
authorian <ian@138bc75d-0d04-0410-961f-82ee72b054a4>
Fri, 21 Nov 2003 03:27:58 +0000 (03:27 +0000)
committerian <ian@138bc75d-0d04-0410-961f-82ee72b054a4>
Fri, 21 Nov 2003 03:27:58 +0000 (03:27 +0000)
git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@73788 138bc75d-0d04-0410-961f-82ee72b054a4

libiberty/ChangeLog
libiberty/cp-demangle.c

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