osprey/libiberty/cp-demangle.c

Go to the documentation of this file.

/*
 * Copyright 2005 PathScale, Inc.  All Rights Reserved.
 */

/* Demangler for IA64 / g++ V3 ABI.
   Copyright (C) 2000, 2001, 2002 Free Software Foundation, Inc.
   Written by Alex Samuel <samuel@codesourcery.com>. 

   This file is part of GNU CC.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   In addition to the permissions in the GNU General Public License, the
   Free Software Foundation gives you unlimited permission to link the
   compiled version of this file into combinations with other programs,
   and to distribute those combinations without any restriction coming
   from the use of this file.  (The General Public License restrictions
   do apply in other respects; for example, they cover modification of
   the file, and distribution when not linked into a combined
   executable.)

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. 
*/

/* This file implements 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>

#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

/* 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'))

/* The prefix prepended by GCC to an identifier represnting the
   anonymous namespace.  */
#define ANONYMOUS_NAMESPACE_PREFIX "_GLOBAL_"

/* 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;

/* 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
{
  /* The dyn_string; must be first.  */
  struct dyn_string string;

  /* 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;

  /* The next string in the list.  */
  struct string_list_def *next;
};

typedef struct string_list_def *string_list_t;

/* Data structure representing a potential substitution.  */

struct substitution_def
{
  /* The demangled text of the substitution.  */
  dyn_string_t text;

  /* Whether this substitution represents a template item.  */
  int template_p : 1;
};

/* Data structure representing a template argument list.  */

struct template_arg_list_def
{
  /* The next (lower) template argument list in the stack of currently
     active template arguments.  */
  struct template_arg_list_def *next;

  /* The first element in the list of template arguments in
     left-to-right order.  */
  string_list_t first_argument;

  /* The last element in the arguments lists.  */
  string_list_t last_argument;
};

typedef struct template_arg_list_def *template_arg_list_t;

/* Data structure to maintain the state of the current demangling.  */

struct demangling_def
{
  /* The full mangled name being mangled.  */
  const char *name;

  /* Pointer into name at the current position.  */
  const char *next;

  /* Stack for strings containing demangled result generated so far.
     Text is emitted to the topmost (first) string.  */
  string_list_t result;

  /* The number of presently available substitutions.  */
  int num_substitutions;

  /* The allocated size of the substitutions array.  */
  int substitutions_allocated;

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

     The most recent substition is at the end, so

       - `S_'  corresponds to substititutions[num_substitutions - 1] 
       - `S0_' corresponds to substititutions[num_substitutions - 2]

     etc. */
  struct substitution_def *substitutions;

  /* The stack of template argument lists.  */
  template_arg_list_t template_arg_lists;

  /* The most recently demangled source-name.  */
  dyn_string_t last_source_name;
  
  /* Language style to use for demangled output. */
  int style;

  /* 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;

  /* 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;

};

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;                                                       \
    }                                                                   \
  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 *));
#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));
#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;
{
  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;
    }

  /* For negative numbers, emit a minus sign.  */
  if (value < 0)
    {
      if (!dyn_string_append_char (ds, '-'))
  return STATUS_ALLOCATION_FAILED;
      value = -value;
    }
  
  /* Find the power of 10 of the first digit.  */
  i = value;
  while (i > 9)
    {
      mask *= 10;
      i /= 10;
    }

  /* Write the digits.  */
  while (mask > 0)
    {
      int digit = value / mask;

      if (!dyn_string_append_char (ds, '0' + digit))
  return STATUS_ALLOCATION_FAILED;

      value -= digit * mask;
      mask /= 10;
    }

  return STATUS_OK;
}

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

static string_list_t 
string_list_new (length)
     int length;
{
  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;
}  

/* Deletes the entire string list starting at NODE.  */

static void
string_list_delete (node)
     string_list_t node;
{
  while (node != NULL)
    {
      string_list_t next = node->next;
      dyn_string_delete ((dyn_string_t) node);
      node = next;
    }
}

/* Appends CHARACTER to the demangled result.  If the current trailing
   character of the result is CHARACTER, a space is inserted first.  */

static status_t
result_add_separated_char (dm, character)
     demangling_t dm;
     int character;
{
  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));

  return STATUS_OK;
}

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

static status_t
result_push (dm)
     demangling_t dm;
{
  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;
}

/* Removes and returns the topmost element on the demangled results
   stack for DM.  The caller assumes ownership for the returned
   string.  */

static string_list_t
result_pop (dm)
     demangling_t dm;
{
  string_list_t top = dm->result;
  dm->result = top->next;
  return top;
}

/* Returns the current value of the caret for the result string.  The
   value is an offet from the end of the result string.  */

static int
result_get_caret (dm)
     demangling_t dm;
{
  return ((string_list_t) result_string (dm))->caret_position;
}

/* Sets the value of the caret for the result string, counted as an
   offet from the end of the result string.  */

static void
result_set_caret (dm, position)
     demangling_t dm;
     int position;
{
  ((string_list_t) result_string (dm))->caret_position = position;
}

/* Shifts the position of the next addition to the result by
   POSITION_OFFSET.  A negative value shifts the caret to the left.  */

static void
result_shift_caret (dm, position_offset)
     demangling_t dm;
     int position_offset;
{
  ((string_list_t) result_string (dm))->caret_position += position_offset;
}

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

static int
result_previous_char_is_space (dm)
     demangling_t dm;
{
  char *result = dyn_string_buf (result_string (dm));
  int pos = result_caret_pos (dm);
  return pos > 0 && result[pos - 1] == ' ';
}

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

static int
substitution_start (dm)
     demangling_t dm;
{
  return result_caret_pos (dm);
}

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

static status_t
substitution_add (dm, start_position, template_p)
     demangling_t dm;
     int start_position;
     int template_p;
{
  dyn_string_t result = result_string (dm);
  dyn_string_t substitution = dyn_string_new (0);
  int i;

  if (substitution == NULL)
    return STATUS_ALLOCATION_FAILED;

  /* 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)))
    {
      dyn_string_delete (substitution);
      return STATUS_ALLOCATION_FAILED;
    }

  /* If there's no room for the new entry, grow the array.  */
  if (dm->substitutions_allocated == dm->num_substitutions)
    {
      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.  */
  {
    dyn_string_delete (substitution);
    return STATUS_ALLOCATION_FAILED;
  }
    }

  /* Add the substitution to the array.  */
  i = dm->num_substitutions++;
  dm->substitutions[i].text = substitution;
  dm->substitutions[i].template_p = template_p;

#ifdef CP_DEMANGLE_DEBUG
  substitutions_print (dm, stderr);
#endif

  return STATUS_OK;
}

/* 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;

  /* Make sure N is in the valid range.  */
  if (n < 0 || n >= dm->num_substitutions)
    return NULL;

  sub = &(dm->substitutions[n]);
  *template_p = sub->template_p;
  return sub->text;
}

#ifdef CP_DEMANGLE_DEBUG
/* Debugging routine to print the current substitutions to FP.  */

static void
substitutions_print (dm, fp)
     demangling_t dm;
     FILE *fp;
{
  int seq_id;
  int num = dm->num_substitutions;

  fprintf (fp, "SUBSTITUTIONS:\n");
  for (seq_id = -1; seq_id < num - 1; ++seq_id)
    {
      int template_p;
      dyn_string_t text = substitution_get (dm, seq_id + 1, &template_p);

      if (seq_id == -1)
  fprintf (fp, " S_ ");
      else
  fprintf (fp, " S%d_", seq_id);
      fprintf (fp, " %c: %s\n", template_p ? '*' : ' ', dyn_string_buf (text));
    }
}

#endif /* CP_DEMANGLE_DEBUG */

/* Creates a new template argument list.  Returns NULL if allocation
   fails.  */

static template_arg_list_t
template_arg_list_new ()
{
  template_arg_list_t new_list =
    (template_arg_list_t) malloc (sizeof (struct template_arg_list_def));
  if (new_list == NULL)
    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.  */

static void
template_arg_list_delete (list)
     template_arg_list_t list;
{
  /* If there are any arguments on LIST, delete them.  */
  if (list->first_argument != NULL)
    string_list_delete (list->first_argument);
  /* Delete LIST.  */
  free (list);
}

/* Adds ARG to the template argument list ARG_LIST.  */

static void 
template_arg_list_add_arg (arg_list, arg)
     template_arg_list_t arg_list;
     string_list_t arg;
{
  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;
}

/* Returns the template arugment at position INDEX in template
   argument list ARG_LIST.  */

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--)
    {
      arg = arg->next;
      if (arg == NULL)
  /* Ran out of arguments before INDEX hit zero.  That's an
     error.  */
  return NULL;
    }
  /* Return the argument at position INDEX.  */
  return arg;
}

/* Pushes ARG_LIST onto the top of the template argument list stack.  */

static void
push_template_arg_list (dm, arg_list)
     demangling_t dm;
     template_arg_list_t arg_list;
{
  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 
}

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

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)
    {
      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
    }
}

#ifdef CP_DEMANGLE_DEBUG

/* Prints the contents of ARG_LIST to FP.  */

static void
template_arg_list_print (arg_list, fp)
  template_arg_list_t arg_list;
  FILE *fp;
{
  string_list_t arg;
  int index = -1;

  fprintf (fp, "TEMPLATE ARGUMENT LIST:\n");
  for (arg = arg_list->first_argument; arg != NULL; arg = arg->next)
    {
      if (index == -1)
  fprintf (fp, " T_  : ");
      else
  fprintf (fp, " T%d_ : ", index);
      ++index;
      fprintf (fp, "%s\n", dyn_string_buf ((dyn_string_t) arg));
    }
}

#endif /* CP_DEMANGLE_DEBUG */

/* Returns the topmost element on the stack of template argument
   lists.  If there is no list of template arguments, returns NULL.  */

static template_arg_list_t
current_template_arg_list (dm)
     demangling_t dm;
{
  return dm->template_arg_lists;
}

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

static demangling_t
demangling_new (name, style)
     const char *name;
     int style;
{
  demangling_t dm;
  dm = (demangling_t) malloc (sizeof (struct demangling_def));
  if (dm == NULL)
    return NULL;

  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)
    {
      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;

  return dm;
}

/* Deallocates a demangling_t object and all memory associated with
   it.  */

static void
demangling_delete (dm)
     demangling_t dm;
{
  int i;
  template_arg_list_t arg_list = dm->template_arg_lists;

  /* 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);
}

/* 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;

  if (peek_char (dm) == c)
    {
      advance_char (dm);
      return STATUS_OK;
    }
  else
    {
      if (error_message == NULL)
  error_message = (char *) strdup ("Expected ?");
      error_message[9] = c;
      return error_message;
    }
}

/* Demangles and emits a <mangled-name>.  

    <mangled-name>      ::= _Z <encoding>  */

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;
}

/* Demangles and emits an <encoding>.  

    <encoding>    ::= <function name> <bare-function-type>
      ::= <data name>
      ::= <special-name>  */

static status_t
demangle_encoding (dm)
     demangling_t dm;
{
  int encode_return_type;
  int start_position;
  template_arg_list_t old_arg_list = current_template_arg_list (dm);
  char peek = peek_char (dm);

  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 (peek == 'G' || peek == 'T')
    RETURN_IF_ERROR (demangle_special_name (dm));
  else
    {
      /* 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)); 
  }
    }

  /* 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);

  return STATUS_OK;
}

/* Demangles and emits a <name>.

    <name>              ::= <unscoped-name>
                        ::= <unscoped-template-name> <template-args>
      ::= <nested-name>
                        ::= <local-name>

    <unscoped-name>     ::= <unqualified-name>
      ::= St <unqualified-name>   # ::std::

    <unscoped-template-name>    
                        ::= <unscoped-name>
                        ::= <substitution>  */

static status_t
demangle_name (dm, encode_return_type)
     demangling_t dm;
     int *encode_return_type;
{
  int start = substitution_start (dm);
  char peek = peek_char (dm);
  int is_std_substitution = 0;

  /* 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;

  DEMANGLE_TRACE ("name", dm);

  switch (peek)
    {
    case 'N':
      /* This is a <nested-name>.  */
      RETURN_IF_ERROR (demangle_nested_name (dm, encode_return_type));
      break;

    case 'Z':
      RETURN_IF_ERROR (demangle_local_name (dm));
      *encode_return_type = 0;
      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') 
  {
    /* 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;
  }
      else
  *encode_return_type = 0;

      break;

    default:
      /* This is an <unscoped-name> or <unscoped-template-name>.  */
      RETURN_IF_ERROR (demangle_unqualified_name (dm, &suppress_return_type));

      /* 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));

    RETURN_IF_ERROR (demangle_template_args (dm));
    *encode_return_type = !suppress_return_type;
  }
      else
  *encode_return_type = 0;

      break;
    }

  return STATUS_OK;
}

/* Demangles and emits a <nested-name>. 

    <nested-name>     ::= N [<CV-qualifiers>] <prefix> <unqulified-name> E  */

static status_t
demangle_nested_name (dm, encode_return_type)
     demangling_t dm;
     int *encode_return_type;
{
  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')
    {
      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);
    }

  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'));

  return STATUS_OK;
}

/* Demangles and emits a <prefix>.

    <prefix>            ::= <prefix> <unqualified-name>
                        ::= <template-prefix> <template-args>
      ::= # empty
      ::= <substitution>

    <template-prefix>   ::= <prefix>
                        ::= <substitution>  */

static status_t
demangle_prefix (dm, encode_return_type)
     demangling_t dm;
     int *encode_return_type;
{
  int start = substitution_start (dm);
  int nested = 0;

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

  /* 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;

  DEMANGLE_TRACE ("prefix", dm);

  while (1)
    {
      char peek;

      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')
  {
    /* 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;
      }
  }
      else if (peek == 'Z')
  RETURN_IF_ERROR (demangle_local_name (dm));
      else if (peek == 'I')
  {
    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;
  }
      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.

    <unqualified-name>  ::= <operator-name>
      ::= <special-name>  
      ::= <source-name>  */

static status_t
demangle_unqualified_name (dm, suppress_return_type)
     demangling_t dm;
     int *suppress_return_type;
{
  char peek = peek_char (dm);

  DEMANGLE_TRACE ("unqualified-name", dm);

  /* 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;

  if (IS_DIGIT ((unsigned char) peek))
    RETURN_IF_ERROR (demangle_source_name (dm));
  else if (peek >= 'a' && peek <= 'z')
    {
      int num_args;

      /* Conversion operators never have a return type encoded.  */
      if (peek == 'c' && peek_char_next (dm) == 'v')
  *suppress_return_type = 1;

      RETURN_IF_ERROR (demangle_operator_name (dm, 0, &num_args, NULL));
    }
  else if (peek == 'C' || peek == 'D')
    {
      /* Constructors never have a return type encoded.  */
      if (peek == 'C')
  *suppress_return_type = 1;

      RETURN_IF_ERROR (demangle_ctor_dtor_name (dm));
    }
  else
    return "Unexpected character in <unqualified-name>.";

  return STATUS_OK;
}

/* Demangles and emits <source-name>.  

    <source-name> ::= <length number> <identifier>  */

static status_t
demangle_source_name (dm)
     demangling_t dm;
{
  int length;

  DEMANGLE_TRACE ("source-name", dm);

  /* Decode the length of the identifier.  */
  RETURN_IF_ERROR (demangle_number (dm, &length, 10, 0));
  if (length == 0)
    return "Zero length in <source-name>.";

  /* 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));

  /* Emit it.  */
  RETURN_IF_ERROR (result_add_string (dm, dm->last_source_name));

  return STATUS_OK;
}

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

static status_t
demangle_number (dm, value, base, is_signed)
     demangling_t dm;
     int *value;
     int base;
     int is_signed;
{
  dyn_string_t number = dyn_string_new (10);

  DEMANGLE_TRACE ("number", dm);

  if (number == NULL)
    return STATUS_ALLOCATION_FAILED;

  demangle_number_literally (dm, number, base, is_signed);
  *value = strtol (dyn_string_buf (number), NULL, base);
  dyn_string_delete (number);

  return STATUS_OK;
}

/* 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;
{
  DEMANGLE_TRACE ("number*", dm);

  if (base != 10 && base != 36)
    return STATUS_INTERNAL_ERROR;

  /* 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;
    }

  /* Loop until we hit a non-digit.  */
  while (1)
    {
      char peek = peek_char (dm);
      if (IS_DIGIT ((unsigned char) peek)
    || (base == 36 && peek >= 'A' && peek <= 'Z'))
  {
    /* Accumulate digits.  */
    if (!dyn_string_append_char (str, next_char (dm)))
      return STATUS_ALLOCATION_FAILED;
  }
      else
  /* Not a digit?  All done.  */
  break;
    }

  return STATUS_OK;
}

/* Demangles an identifier at the current position of LENGTH
   characters and places it in IDENTIFIER.  */

static status_t
demangle_identifier (dm, length, identifier)
     demangling_t dm;
     int length;
     dyn_string_t identifier;
{
  DEMANGLE_TRACE ("identifier", dm);

  dyn_string_clear (identifier);
  if (!dyn_string_resize (identifier, length))
    return STATUS_ALLOCATION_FAILED;

  while (length-- > 0)
    {
      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);
      }
  }

      if (!dyn_string_append_char (identifier, ch))
  return STATUS_ALLOCATION_FAILED;
    }

  /* 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)");
  }
    }

  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;
{
  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;
    }

  /* Is this a conversion operator?  */
  if (c0 == 'c' && c1 == 'v')
    {
      RETURN_IF_ERROR (result_add (dm, "operator "));
      /* Demangle the converted-to type.  */
      RETURN_IF_ERROR (demangle_type (dm));
      *num_args = 0;
      return STATUS_OK;
    }

  /* 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;
    }

  /* Perform a binary search for the operator code.  */
  while (1)
    {
      const struct operator_code* p = p1 + (p2 - p1) / 2;
      char match0 = p->code[0];
      char match1 = p->code[1];

      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;
  }

      if (p == p1)
  /* Couldn't find it.  */
  return "Unknown code in <operator-name>.";

      /* Try again.  */
      if (c0 < match0 || (c0 == match0 && c1 < match1))
  p2 = p;
      else
  p1 = p;
    }
}

/* Demangles and omits an <nv-offset>.

    <nv-offset> ::= <offset number>   # non-virtual base override  */

static status_t
demangle_nv_offset (dm)
     demangling_t dm;
{
  dyn_string_t number;
  status_t status = STATUS_OK;

  DEMANGLE_TRACE ("h-offset", dm);

  /* 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, " [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;
}

/* Demangles and emits a <v-offset>. 

    <v-offset>  ::= <offset number> _ <virtual offset number>
      # virtual base override, with vcall offset  */

static status_t
demangle_v_offset (dm)
     demangling_t dm;
{
  dyn_string_t number;
  status_t status = STATUS_OK;

  DEMANGLE_TRACE ("v-offset", dm);

  /* 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);

  /* Demangle the separator.  */
  RETURN_IF_ERROR (demangle_char (dm, '_'));

  /* Demangle the vcall offset.  */
  number = dyn_string_new (4);
  if (number == NULL)
    return STATUS_ALLOCATION_FAILED;
  demangle_number_literally (dm, number, 10, 1);

  /* Don't display the vcall offset unless in verbose mode.  */
  if (flag_verbose)
    {
      status = result_add_string (dm, number);
      if (STATUS_NO_ERROR (status))
  status = result_add_char (dm, ']');
    }
  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))
    {
    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;

    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>.";
    }

  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  

   Other relevant productions include thunks:

    <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> _

   Also demangles the special g++ manglings,

    <special-name> ::= TC <type> <offset number> _ <base type>
                                          # construction vtable
       ::= TF <type>    # typeinfo function (old ABI only)
       ::= TJ <type>    # java Class structure  */

static status_t
demangle_special_name (dm)
     demangling_t dm;
{
  dyn_string_t number;
  int unused;
  char peek = peek_char (dm);

  DEMANGLE_TRACE ("special-name", dm);

  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;

  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')
    {
      status_t status = STATUS_OK;

      /* Other C++ implementation miscellania.  Consume the T.  */
      advance_char (dm);

      switch (peek_char (dm))
  {
  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)
      {
        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 flag_strict, fall through.  */

  default:
    return "Unrecognized <special-name>.";
  }
    }
  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);

  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, ']'));
  }
    }
  else if (peek == 'D')
    {
      /* 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)
  {
  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, ']'));
  }
    }
  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;

  DEMANGLE_TRACE ("type*", dm);

  /* Scan forward, collecting pointers and references into symbols,
     until we hit something else.  Then emit the type.  */
  switch (peek_char (dm))
    {
    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;

    case 'M':
    {
      /* A pointer-to-member.  */
      dyn_string_t class_type;
      
      /* 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);
      
      if (peek_char (dm) == '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_char (dm) == '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);
  }

      /* 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);

      RETURN_IF_ERROR (status);
    }
    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;

    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;
    }
  
  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;
{
  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')
    {
      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.  */
  {
    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);
    /* 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));
    /* 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);
  }
  break;

      case 'F':
  return "Non-pointer or -reference function type.";

      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
     letter following the `S'; other substitutions have a digit
     or underscore.  */
  peek_next = peek_char_next (dm);
  if (IS_DIGIT (peek_next) || 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;
}

/* 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 */
};

/* 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] = 
{
  "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 */
};

/* 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;
{

  char code = peek_char (dm);

  DEMANGLE_TRACE ("builtin-type", dm);

  if (code == 'u')
    {
      advance_char (dm);
      RETURN_IF_ERROR (demangle_source_name (dm));
      return STATUS_OK;
    }
  else if (code >= 'a' && code <= 'z')
    {
      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;
    }
  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);

  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;

  case 'V':
    if (!dyn_string_append_space (qualifiers))
      return STATUS_ALLOCATION_FAILED;
    if (!dyn_string_append_cstr (qualifiers, "volatile"))
      return STATUS_ALLOCATION_FAILED;
    break;

  case 'K':
    if (!dyn_string_append_space (qualifiers))
      return STATUS_ALLOCATION_FAILED;
    if (!dyn_string_append_cstr (qualifiers, "const"))
      return STATUS_ALLOCATION_FAILED;
    break;

  default:
    return STATUS_OK;
  }

      advance_char (dm);
    }
}

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

    <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;
{
  DEMANGLE_TRACE ("function-type", dm);
  RETURN_IF_ERROR (demangle_char (dm, 'F'));  
  if (peek_char (dm) == 'Y')
    {
      /* Indicate this function has C linkage if in verbose mode.  */
      if (flag_verbose)
  RETURN_IF_ERROR (result_add (dm, " [extern \"C\"] "));
      advance_char (dm);
    }
  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);

  RETURN_IF_ERROR (result_add_char (dm, '('));
  while (!end_of_name_p (dm) && peek_char (dm) != 'E')
    {
      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);
      }

    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));
      }
  }

      ++sequence;
    }
  RETURN_IF_ERROR (result_add_char (dm, ')'));

  /* 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.";

  return STATUS_OK;
}

/* Demangles and emits a <class-enum-type>.  *ENCODE_RETURN_TYPE is set to
   non-zero if the type is a template-id, zero otherwise.  

    <class-enum-type> ::= <name>  */

static status_t
demangle_class_enum_type (dm, encode_return_type)
     demangling_t dm;
     int *encode_return_type;
{
  DEMANGLE_TRACE ("class-enum-type", dm);

  RETURN_IF_ERROR (demangle_name (dm, encode_return_type));
  return STATUS_OK;
}

/* Demangles and emits an <array-type>.  

   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 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]'.  

    <array-type> ::= A [<dimension number>] _ <element type>  
                 ::= A <dimension expression> _ <element type>  */

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;

  DEMANGLE_TRACE ("array-type", dm);

  RETURN_IF_ERROR (demangle_char (dm, 'A'));

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

  /* 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);

  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;
    }

  /* 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;
}

/* Demangles and emits a <template-param>.  

    <template-param> ::= T_       # first template parameter
                     ::= T <parameter-2 number> _  */

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;

  DEMANGLE_TRACE ("template-param", dm);

  /* 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.";

  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, '_'));

  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));

  return STATUS_OK;
}

/* Demangles and emits a <template-args>.  

    <template-args> ::= I <template-arg>+ E  */

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 ();

  if (arg_list == NULL)
    return STATUS_ALLOCATION_FAILED;

  /* Preserve the most recently demangled source name.  */
  old_last_source_name = dm->last_source_name;
  dm->last_source_name = dyn_string_new (0);

  DEMANGLE_TRACE ("template-args", dm);

  if (dm->last_source_name == NULL)
    return STATUS_ALLOCATION_FAILED;

  RETURN_IF_ERROR (demangle_char (dm, 'I'));
  RETURN_IF_ERROR (result_open_template_list (dm));
  do
    {
      string_list_t arg;

      if (first)
  first = 0;
      else
  RETURN_IF_ERROR (result_add (dm, ", "));

      /* Capture the template arg.  */
      RETURN_IF_ERROR (result_push (dm));
      RETURN_IF_ERROR (demangle_template_arg (dm));
      arg = result_pop (dm);

      /* Emit it in the demangled name.  */
      RETURN_IF_ERROR (result_add_string (dm, (dyn_string_t) arg));

      /* 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));

  /* Consume the 'E'.  */
  advance_char (dm);

  /* Restore the most recent demangled source name.  */
  dyn_string_delete (dm->last_source_name);
  dm->last_source_name = old_last_source_name;

  /* 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);

  return STATUS_OK;
}

/* 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:

     <literal> ::= <type> </value/ number>

   and the emitted output is `(type)number'.  */

static status_t
demangle_literal (dm)
     demangling_t dm;
{
  char peek = peek_char (dm);
  dyn_string_t value_string;
  status_t status;

  DEMANGLE_TRACE ("literal", dm);

  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')
  {
    /* 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;
  }
      else if (code == 'i' || code == 'l')
  {
    /* 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;
  }
      /* ...else code == ' ', so fall through to represent this
   literal's type explicitly using cast syntax.  */
    }

  RETURN_IF_ERROR (result_add_char (dm, '('));
  RETURN_IF_ERROR (demangle_type (dm));
  RETURN_IF_ERROR (result_add_char (dm, ')'));

  value_string = dyn_string_new (0);
  if (value_string == NULL)
    return STATUS_ALLOCATION_FAILED;

  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);

  return STATUS_OK;
}

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

static status_t
demangle_template_arg (dm)
     demangling_t dm;
{
  DEMANGLE_TRACE ("template-arg", dm);

  switch (peek_char (dm))
    {
    case 'L':
      advance_char (dm);

      if (peek_char (dm) == 'Z')
  {
    /* 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;

    case 'X':
      /* Expression.  */
      advance_char (dm);
      RETURN_IF_ERROR (demangle_expression (dm));
      RETURN_IF_ERROR (demangle_char (dm, 'E'));
      break;

    default:
      RETURN_IF_ERROR (demangle_type (dm));
      break;
    }

  return STATUS_OK;
}

/* Demangles and emits an <expression>.

    <expression> ::= <unary operator-name> <expression>
     ::= <binary operator-name> <expression> <expression>
     ::= <expr-primary>  
                 ::= <scope-expression>  */

static status_t
demangle_expression (dm)
     demangling_t dm;
{
  char peek = peek_char (dm);

  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.  */
    {
      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, ')');
  }

      /* 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, ')'));

      /* 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, ')'));
  }
    }

  return STATUS_OK;
}

/* Demangles and emits a <scope-expression>.  

    <scope-expression> ::= sr <qualifying type> <source-name>
                       ::= sr <qualifying type> <encoding>  */

static status_t
demangle_scope_expression (dm)
     demangling_t dm;
{
  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>.  

    <expr-primary> ::= <template-param>
       ::= L <type> <value number> E  # literal
       ::= L <mangled-name> E         # external name  */

static status_t
demangle_expr_primary (dm)
     demangling_t dm;
{
  char peek = peek_char (dm);

  DEMANGLE_TRACE ("expr-primary", dm);

  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 (peek == '_')
  RETURN_IF_ERROR (demangle_mangled_name (dm));
      else
  RETURN_IF_ERROR (demangle_literal (dm));

      RETURN_IF_ERROR (demangle_char (dm, 'E'));
    }
  else
    return STATUS_ERROR;

  return STATUS_OK;
}

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

static status_t
demangle_substitution (dm, template_p)
     demangling_t dm;
     int *template_p;
{
  int seq_id;
  int peek;
  dyn_string_t text;

  DEMANGLE_TRACE ("substitution", dm);

  RETURN_IF_ERROR (demangle_char (dm, 'S'));

  /* 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 
    {
      const char *new_last_source_name = NULL;

      switch (peek)
  {
  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;

  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)
      {
        RETURN_IF_ERROR (result_add (dm, "std::string"));
        new_last_source_name = "string";
      }
    else
      {
        RETURN_IF_ERROR (result_add (dm, "std::basic_string<char, std::char_traits<char>, std::allocator<char> >"));
        new_last_source_name = "basic_string";
      }
    *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;

  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;

  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;

  default:
    return "Unrecognized <substitution>.";
  }
      
      /* Consume the character we just processed.  */
      advance_char (dm);

      if (new_last_source_name != NULL)
  {
    if (!dyn_string_copy_cstr (dm->last_source_name, 
             new_last_source_name))
      return STATUS_ALLOCATION_FAILED;
  }

      return STATUS_OK;
    }

  /* 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.";

  /* Emit the substitution text.  */
  RETURN_IF_ERROR (result_add_string (dm, text));

  RETURN_IF_ERROR (demangle_char (dm, '_'));
  return STATUS_OK;
}

/* Demangles and emits a <local-name>.  

    <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;
{
  DEMANGLE_TRACE ("local-name", dm);

  RETURN_IF_ERROR (demangle_char (dm, 'Z'));
  RETURN_IF_ERROR (demangle_encoding (dm));
  RETURN_IF_ERROR (demangle_char (dm, 'E'));
  RETURN_IF_ERROR (result_add (dm, "::"));

  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));
    }
  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;
{
  /* Output for <discriminator>s to the demangled name is completely
     suppressed if not in verbose mode.  */

  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)
    {
      if (flag_verbose)
  RETURN_IF_ERROR (result_add (dm, " [#0]"));
    }

  return STATUS_OK;
}

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

static status_t
cp_demangle (name, result, style)
     const char *name;
     dyn_string_t result;
     int style;
{
  status_t status;
  int length = strlen (name);

  if (length > 2 && name[0] == '_' && name[1] == 'Z')
    {
      demangling_t dm = demangling_new (name, style);
      if (dm == NULL)
  return STATUS_ALLOCATION_FAILED;

      status = result_push (dm);
      if (status != STATUS_OK)
  {
    demangling_delete (dm);
    return status;
  }

      status = demangle_mangled_name (dm);
      if (STATUS_NO_ERROR (status))
  {
    dyn_string_t demangled = (dyn_string_t) result_pop (dm);
    if (!dyn_string_copy (result, demangled))
      return STATUS_ALLOCATION_FAILED;
    dyn_string_delete (demangled);
  }
      
      demangling_delete (dm);
    }
  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;
    }

  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)
    {
      demangling_delete (dm);
      return status;
    }

  status = demangle_type (dm);

  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);
    }

  /* Clean up.  */
  demangling_delete (dm);

  return status;
}

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

   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.  

   If LENGTH is non-NULL, the length of the buffer conaining the
   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.  

   *STATUS is set to one of the following values:
      0: The demangling operation succeeded.
     -1: A memory allocation failiure 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
   GNU extensions.  */

char *
__cxa_demangle (mangled_name, output_buffer, length, status)
     const char *mangled_name;
     char *output_buffer;
     size_t *length;
     int *status;
{
  struct dyn_string demangled_name;
  status_t result;

  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) {
      *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 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);
    }
  else if (result == STATUS_ALLOCATION_FAILED)
    /* A call to malloc or realloc failed during the demangling
       operation.  */
    {
      *status = -1;
      return NULL;
    }
  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;
    }
}

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

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);

  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;
    }
}

/* Demangle a Java symbol.  Java uses a subset of the V3 ABI C++ mangling 
   conventions, but the output formatting is a little different.
   This instructs the C++ demangler not to emit pointer characters ("*"), and 
   to use Java's namespace separator symbol ("." instead of "::").  It then 
   does an additional pass over the demangled output to replace instances 
   of JArray<TYPE> with TYPE[].  */

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)
    {
      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))
        {
    ++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)
        {
    --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;
  }
      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;
  }
    }

  free (cplus_demangled);
  
  if (demangled)
    return_value = dyn_string_release (demangled);
  else
    return_value = NULL;

  return return_value;
}

#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;
{
  demangling_t dm;
  status_t status;

  if (strncmp (name, "_Z", 2))
    return 0;

  dm = demangling_new (name, DMGL_GNU_V3);
  if (dm == NULL)
    {
      fprintf (stderr, "Memory allocation failed.\n");
      abort ();
    }

  status = result_push (dm);
  if (! STATUS_NO_ERROR (status))
    {
      demangling_delete (dm);
      fprintf (stderr, "%s\n", status);
      abort ();
    }

  status = demangle_mangled_name (dm);
  if (STATUS_NO_ERROR (status))
    return dm;

  demangling_delete (dm);
  return 0;
}


/* 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);

  if (dm)
    {
      enum gnu_v3_ctor_kinds result = dm->is_constructor;
      demangling_delete (dm);
      return result;
    }
  else
    return (enum gnu_v3_ctor_kinds) 0;
}


/* 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.  */
enum gnu_v3_dtor_kinds
is_gnu_v3_mangled_dtor (name)
     const char *name;
{
  demangling_t dm = demangle_v3_with_details (name);

  if (dm)
    {
      enum gnu_v3_dtor_kinds result = dm->is_destructor;
      demangling_delete (dm);
      return result;
    }
  else
    return (enum gnu_v3_dtor_kinds) 0;
}
#endif /* IN_GLIBCPP_V3 */


#ifdef STANDALONE_DEMANGLER

#include "getopt.h"

static void print_usage
  PARAMS ((FILE* fp, int exit_value));

/* Non-zero if CHAR is a character than can occur in a mangled name.  */
#define is_mangled_char(CHAR)                                           \
  (IS_ALPHA (CHAR) || IS_DIGIT (CHAR)                                   \
   || (CHAR) == '_' || (CHAR) == '.' || (CHAR) == '$')

/* The name of this program, as invoked.  */
const char* program_name;

/* Prints usage summary to FP and then exits with EXIT_VALUE.  */

static void
print_usage (fp, exit_value)
     FILE* fp;
     int 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");

  exit (exit_value);
}

/* Option specification for getopt_long.  */
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   },
};

/* Main entry for a demangling filter executable.  It will demangle
   its command line arguments, if any.  If none are provided, it will
   filter stdin to stdout, replacing any recognized mangled C++ names
   with their demangled equivalents.  */

int
main (argc, argv)
     int argc;
     char *argv[];
{
  status_t status;
  int i;
  int opt_char;

  /* Use the program name of this program, as invoked.  */
  program_name = argv[0];

  /* Parse options.  */
  do 
    {
      opt_char = getopt_long (argc, argv, "hsv", long_options, NULL);
      switch (opt_char)
  {
  case '?':  /* Unrecognized option.  */
    print_usage (stderr, 1);
    break;

  case 'h':
    print_usage (stdout, 0);
    break;

  case 's':
    flag_strict = 1;
    break;

  case 'v':
    flag_verbose = 1;
    break;
  }
    }
  while (opt_char != -1);

  if (optind == argc) 
    /* 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;

      /* 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');

    /* Pile characters into mangled until we hit one that can't
       occur in a mangled name.  */
    c = getchar ();
    while (!feof (stdin) && is_mangled_char (c))
      {
        dyn_string_append_char (mangled, c);
        if (feof (stdin))
    break;
        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)
      {
        fprintf (stderr, "Memory allocation failed.\n");
        abort ();
      }
    /* 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)
  {
    /* Attempt to demangle.  */
    status = cp_demangle (argv[i], result, 0);

    /* 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)
      {
        fprintf (stderr, "Memory allocation failed.\n");
        abort ();
      }
    /* If not, print the error message to stderr instead.  */
    else 
      fprintf (stderr, "%s\n", status);
  }
      dyn_string_delete (result);
    }

  return 0;
}

#endif /* STANDALONE_DEMANGLER */

---