OSDN Git Service

in include/ChangeLog:
authorsamuel <samuel@138bc75d-0d04-0410-961f-82ee72b054a4>
Fri, 23 Jun 2000 03:58:44 +0000 (03:58 +0000)
committersamuel <samuel@138bc75d-0d04-0410-961f-82ee72b054a4>
Fri, 23 Jun 2000 03:58:44 +0000 (03:58 +0000)
* dyn-string.h (dyn_string_init, dyn_string_new,
dyn_string_delete, dyn_string_release, dyn_string_resize,
dyn_string_clear, dyn_string_copy, dyn_string_copy_cstr,
dyn_string_prepend, dyn_string_prepend_cstr, dyn_string_insert,
dyn_string_insert_cstr, dyn_string_append, dyn_string_append_cstr,
dyn_string_append_char, dyn_string_substring_dyn_string_eq):
Define as same name with __cxa_ prepended, if IN_LIBGCC2.
(dyn_string_init, dyn_string_copy, dyn_string_copy_cstr,
dyn_string_prepend, dyn_string_prepend_cstr, dyn_string_insert,
dyn_string_insert_cstr, dyn_string_append, dyn_string_append_cstr,
dyn_string_append_char, dyn_string_substring): Change return type
to int.

in libiberty/ChangeLog:

* cp-demangle.c: Don't include ctype.h.
(IS_DIGIT): New macro.
(IS_ALPHA): Likewise.  Use IS_DIGIT and IS_ALPHA throughout
instead of isdigit and isalpanum.
(demangling_def): Make name and next const pointers.
(STATUS_ALLOCATION_FAILED): New status code.
(dyn_string_append_space): Handle failure in
dyn_string_append_char.
(int_to_dyn_string): Likewise.  Change return value to status_t.
(string_list_new): Handle failure of dyn_string_init.
(result_close_template_list): Change return type to status_t.
Handle failure in dyn_string_append.
(result_push): Change return value to status_t.  Handle failure in
string_list_new.  Handle failure of result_push throughout.
(substitution_add): Change return value to status_t.  Handle
dyn_string failures.  Handle failure of substitution_add
throughout.
(template_arg_list_new): Return NULL on allocation failure.
(result_append_string): Return STATUS_ALLOCATION_FAILED on error.
Handle error result throughout.
(result_append): Likewise.
(result_append_char): Likewise.
(result_append_space): Likewise.
(demangling_new): Make argument a const pointer.  Handle
allocation failures.
(demangle_template_args): Handle failure in template_arg_list_new
and result_close_template_list.
(demangle_discriminator): Return if int_to_dyn_string fails.
(cp_demangle): Likewise.
(cp_demangle_type): New function.
(cplus_demangle_new_abi): Don't call dyn_string_delete.  Abort on
memory allocation failure.
(main): Likewise.
* dyn-string.c (RETURN_ON_ALLOCATION_FAILURE): Define if
IN_LIBGCC2.
(dyn_string_init): Change return value to int.  Handle
RETURN_ON_ALLOCATION_FAILURE case.
(dyn_string_new): Handle RETURN_ON_ALLOCATION_FAILURE case.
(dyn_string_release): Delete the dyn_string.
(dyn_string_resize): Handle RETURN_ON_ALLOCATION_FAILURE case.
(dyn_string_copy): Change return type to int.
(dyn_string_copy_cstr): Likewise.
(dyn_string_prepend): Likewise.
(dyn_string_prepend_cstr): Likewise.
(dyn_string_insert): Likewise.
(dyn_string_insert_cstr): Likewise.
(dyn_string_append): Likewise.
(dyn_string_append_cstr): Likewise.
(dyn_string_append_char): Likewise.
(dyn_string_substring): Likewise.

in gcc/cp/ChangeLog:

* Make-lang.in (CXX_LIB2FUNCS): Add cp-demangle.o and dyn-string.o.
(CXX_LIB2SRCS): Add cp-demangle.c and dyn-string.c.
(cp-demangle.o): New rule.
(dyn-string.o): Likewise.
* inc/cxxabi.h (__cxa_demangle): New declaration.

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

gcc/cp/ChangeLog
gcc/cp/Make-lang.in
gcc/cp/inc/cxxabi.h
include/ChangeLog
include/dyn-string.h
libiberty/ChangeLog
libiberty/cp-demangle.c
libiberty/dyn-string.c

index 0cebeac..71cad2a 100644 (file)
@@ -1,3 +1,11 @@
+2000-06-21  Alex Samuel  <samuel@codesourcery.com>
+
+       * Make-lang.in (CXX_LIB2FUNCS): Add cp-demangle.o and dyn-string.o.
+       (CXX_LIB2SRCS): Add cp-demangle.c and dyn-string.c.
+       (cp-demangle.o): New rule.
+       (dyn-string.o): Likewise.
+       * inc/cxxabi.h (__cxa_demangle): New declaration.
+
 2000-06-22  Mark Mitchell  <mark@codesourcery.com>
 
        * cp-tree.h (BV_USE_VCALL_INDEX_P): New macro.
index 6763d62..91a1a54 100644 (file)
@@ -62,10 +62,13 @@ CXX_EXTRA_HEADERS = $(srcdir)/cp/inc/typeinfo $(srcdir)/cp/inc/exception \
 
 # Extra code to include in libgcc2.
 CXX_LIB2FUNCS = tinfo.o tinfo2.o new.o opnew.o opnewnt.o opvnew.o opvnewnt.o \
-       opdel.o opdelnt.o opvdel.o opvdelnt.o exception.o vec.o
+       opdel.o opdelnt.o opvdel.o opvdelnt.o exception.o vec.o \
+       cp-demangle.o dyn-string.o
 CXX_LIB2SRCS = $(srcdir)/cp/new.cc $(srcdir)/cp/new1.cc $(srcdir)/cp/new2.cc \
        $(srcdir)/cp/exception.cc $(srcdir)/cp/tinfo.cc \
-       $(srcdir)/cp/tinfo2.cc $(srcdir)/cp/tinfo.h
+       $(srcdir)/cp/tinfo2.cc $(srcdir)/cp/tinfo.h \
+       $(srcdir)/../libiberty/cp-demangle.c \
+       $(srcdir)/../libiberty/dyn-string.c
 #\f
 # Define the names for selecting c++ in LANGUAGES.
 # Note that it would be nice to move the dependency on g++
@@ -178,6 +181,14 @@ opvdelnt.o: cc1plus$(exeext) $(srcdir)/cp/new2.cc
 vec.o: cc1plus$(exeext) $(srcdir)/cp/vec.cc
        $(GCC_FOR_TARGET) $(LIBGCC2_CFLAGS) $(GXX_ABI_FLAG) $(CXXFLAGS) $(INCLUDES) \
          -c $(srcdir)/cp/vec.cc -o vec.o
+cp-demangle.o: $(srcdir)/../libiberty/cp-demangle.c
+       $(GCC_FOR_TARGET) $(LIBGCC2_CFLAGS) $(CFLAGS) $(INCLUDES) \
+        -DHAVE_CONFIG_H \
+         -c $(srcdir)/../libiberty/cp-demangle.c -o cp-demangle.o
+dyn-string.o: $(srcdir)/../libiberty/dyn-string.c
+       $(GCC_FOR_TARGET) $(LIBGCC2_CFLAGS) $(CFLAGS) $(INCLUDES) \
+        -DHAVE_CONFIG_H \
+        -c $(srcdir)/../libiberty/dyn-string.c -o dyn-string.o
 
 # We want to update cplib2.txt if any of the source files change...
 cplib2.txt: $(CXX_LIB2SRCS) $(CXX_EXTRA_HEADERS)
index ad918c4..8987b6d 100644 (file)
@@ -459,6 +459,14 @@ void __cxa_vec_delete (void *__array_address,
                        __SIZE_TYPE__ __padding_size,
                        void (*__destructor) (void *));
 
+/* demangling routines */
+
+extern "C" 
+char *__cxa_demangle (const char *__mangled_name,
+                     char *__output_buffer,
+                     __SIZE_TYPE__ *__length,
+                     int *__status);
+
 } /* namespace __cxxabiv1 */
 
 /* User programs should use the alias `abi'. */
index 9e5617d..3c0e92d 100644 (file)
@@ -1,3 +1,18 @@
+2000-06-21  Alex Samuel  <samuel@codesourcery.com>
+
+       * dyn-string.h (dyn_string_init, dyn_string_new,
+       dyn_string_delete, dyn_string_release, dyn_string_resize,
+       dyn_string_clear, dyn_string_copy, dyn_string_copy_cstr,
+       dyn_string_prepend, dyn_string_prepend_cstr, dyn_string_insert,
+       dyn_string_insert_cstr, dyn_string_append, dyn_string_append_cstr,
+       dyn_string_append_char, dyn_string_substring_dyn_string_eq):
+       Define as same name with __cxa_ prepended, if IN_LIBGCC2.
+       (dyn_string_init, dyn_string_copy, dyn_string_copy_cstr,
+       dyn_string_prepend, dyn_string_prepend_cstr, dyn_string_insert,
+       dyn_string_insert_cstr, dyn_string_append, dyn_string_append_cstr,
+       dyn_string_append_char, dyn_string_substring): Change return type
+       to int.
+       
 2000-06-07  Kaveh R. Ghazi  <ghazi@caip.rutgers.edu>
 
        * demangle.h (demangling_styles): Remove trailing comma in enum.
index 3e2213e..103f947 100644 (file)
@@ -40,25 +40,53 @@ typedef struct dyn_string
   (strcmp ((DS1)->s, (DS2)->s))
 
 
-extern void dyn_string_init             PARAMS ((struct dyn_string *, int));
+/* dyn_string functions are used in the demangling implementation
+   included in the G++ runtime library.  To prevent collisions with
+   names in user programs, the functions that are used in the
+   demangler are given implementation-reserved names.  */
+
+#ifdef IN_LIBGCC2
+
+#define dyn_string_init                 __cxa_dyn_string_init
+#define dyn_string_new                  __cxa_dyn_string_new
+#define dyn_string_delete               __cxa_dyn_string_delete
+#define dyn_string_release              __cxa_dyn_string_release
+#define dyn_string_resize               __cxa_dyn_string_resize
+#define dyn_string_clear                __cxa_dyn_string_clear
+#define dyn_string_copy                 __cxa_dyn_string_copy
+#define dyn_string_copy_cstr            __cxa_dyn_string_copy_cstr
+#define dyn_string_prepend              __cxa_dyn_string_prepend
+#define dyn_string_prepend_cstr         __cxa_dyn_string_prepend_cstr
+#define dyn_string_insert               __cxa_dyn_string_insert
+#define dyn_string_insert_cstr          __cxa_dyn_string_insert_cstr
+#define dyn_string_append               __cxa_dyn_string_append
+#define dyn_string_append_cstr          __cxa_dyn_string_append_cstr
+#define dyn_string_append_char          __cxa_dyn_string_append_char
+#define dyn_string_substring            __cxa_dyn_string_substring
+#define dyn_string_eq                   __cxa_dyn_string_eq
+
+#endif /* IN_LIBGCC2 */
+
+
+extern int dyn_string_init              PARAMS ((struct dyn_string *, int));
 extern dyn_string_t dyn_string_new      PARAMS ((int));
 extern void dyn_string_delete           PARAMS ((dyn_string_t));
 extern char *dyn_string_release         PARAMS ((dyn_string_t));
 extern dyn_string_t dyn_string_resize   PARAMS ((dyn_string_t, int));
 extern void dyn_string_clear            PARAMS ((dyn_string_t));
-extern void dyn_string_copy             PARAMS ((dyn_string_t, dyn_string_t));
-extern void dyn_string_copy_cstr        PARAMS ((dyn_string_t, const char *));
-extern void dyn_string_prepend          PARAMS ((dyn_string_t, dyn_string_t));
-extern void dyn_string_prepend_cstr     PARAMS ((dyn_string_t, const char *));
-extern void dyn_string_insert           PARAMS ((dyn_string_t, int,
+extern int dyn_string_copy              PARAMS ((dyn_string_t, dyn_string_t));
+extern int dyn_string_copy_cstr         PARAMS ((dyn_string_t, const char *));
+extern int dyn_string_prepend           PARAMS ((dyn_string_t, dyn_string_t));
+extern int dyn_string_prepend_cstr      PARAMS ((dyn_string_t, const char *));
+extern int dyn_string_insert            PARAMS ((dyn_string_t, int,
                                                 dyn_string_t));
-extern void dyn_string_insert_cstr      PARAMS ((dyn_string_t, int,
+extern int dyn_string_insert_cstr       PARAMS ((dyn_string_t, int,
                                                 const char *));
-extern dyn_string_t dyn_string_append   PARAMS ((dyn_string_t, dyn_string_t));
-extern dyn_string_t dyn_string_append_cstr   
+extern int dyn_string_append            PARAMS ((dyn_string_t, dyn_string_t));
+extern int dyn_string_append_cstr   
                                         PARAMS ((dyn_string_t, const char *));
-extern dyn_string_t dyn_string_append_char
+extern int dyn_string_append_char
                                         PARAMS ((dyn_string_t, int));
-extern void dyn_string_substring        PARAMS ((dyn_string_t, 
+extern int dyn_string_substring         PARAMS ((dyn_string_t, 
                                                 dyn_string_t, int, int));
 extern int dyn_string_eq                PARAMS ((dyn_string_t, dyn_string_t));
index e7bac6d..5bac397 100644 (file)
@@ -1,3 +1,56 @@
+2000-06-21  Alex Samuel  <samuel@codesourcery.com>
+
+       * cp-demangle.c: Don't include ctype.h.
+       (IS_DIGIT): New macro.
+       (IS_ALPHA): Likewise.  Use IS_DIGIT and IS_ALPHA throughout
+       instead of isdigit and isalpanum.
+       (demangling_def): Make name and next const pointers.
+       (STATUS_ALLOCATION_FAILED): New status code.
+       (dyn_string_append_space): Handle failure in
+       dyn_string_append_char.
+       (int_to_dyn_string): Likewise.  Change return value to status_t.
+       (string_list_new): Handle failure of dyn_string_init.
+       (result_close_template_list): Change return type to status_t.
+       Handle failure in dyn_string_append.
+       (result_push): Change return value to status_t.  Handle failure in
+       string_list_new.  Handle failure of result_push throughout.
+       (substitution_add): Change return value to status_t.  Handle
+       dyn_string failures.  Handle failure of substitution_add
+       throughout.
+       (template_arg_list_new): Return NULL on allocation failure.
+       (result_append_string): Return STATUS_ALLOCATION_FAILED on error.
+       Handle error result throughout.
+       (result_append): Likewise.
+       (result_append_char): Likewise.
+       (result_append_space): Likewise.
+       (demangling_new): Make argument a const pointer.  Handle
+       allocation failures.
+       (demangle_template_args): Handle failure in template_arg_list_new
+       and result_close_template_list.
+       (demangle_discriminator): Return if int_to_dyn_string fails.
+       (cp_demangle): Likewise.
+       (cp_demangle_type): New function.
+       (cplus_demangle_new_abi): Don't call dyn_string_delete.  Abort on
+       memory allocation failure.
+       (main): Likewise.
+       * dyn-string.c (RETURN_ON_ALLOCATION_FAILURE): Define if
+       IN_LIBGCC2.
+       (dyn_string_init): Change return value to int.  Handle
+       RETURN_ON_ALLOCATION_FAILURE case.
+       (dyn_string_new): Handle RETURN_ON_ALLOCATION_FAILURE case.
+       (dyn_string_release): Delete the dyn_string.
+       (dyn_string_resize): Handle RETURN_ON_ALLOCATION_FAILURE case.
+       (dyn_string_copy): Change return type to int.
+       (dyn_string_copy_cstr): Likewise.
+       (dyn_string_prepend): Likewise.
+       (dyn_string_prepend_cstr): Likewise.
+       (dyn_string_insert): Likewise.
+       (dyn_string_insert_cstr): Likewise.
+       (dyn_string_append): Likewise.
+       (dyn_string_append_cstr): Likewise.
+       (dyn_string_append_char): Likewise.
+       (dyn_string_substring): Likewise.
+       
 2000-06-09  Zack Weinberg  <zack@wolery.cumb.org>
 
        * cp-demangle.c (demangle_operator_name): Add spaces before
index b1c4055..651f7aa 100644 (file)
@@ -27,8 +27,6 @@
 #include "config.h"
 #endif
 
-#include <ctype.h>
-
 #ifdef HAVE_STDLIB_H
 #include <stdlib.h>
 #endif
 /* 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", \
+#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'))
+
 /* 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.
@@ -118,10 +123,10 @@ typedef struct template_arg_list_def *template_arg_list_t;
 struct demangling_def
 {
   /* The full mangled name being mangled.  */
-  char *name;
+  const char *name;
 
   /* Pointer into name at the current position.  */
-  char *next;
+  const char *next;
 
   /* Stack for strings containing demangled result generated so far.
      Text is emitted to the topmost (first) string.  */
@@ -159,26 +164,45 @@ typedef struct demangling_def *demangling_t;
 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."
+#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 void int_to_dyn_string 
+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 void result_close_template_list 
+static status_t result_close_template_list 
   PARAMS ((demangling_t));
-static void result_push
+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 void substitution_add
+static status_t substitution_add
   PARAMS ((demangling_t, int, int, int));
 static dyn_string_t substitution_get
   PARAMS ((demangling_t, int, int *));
@@ -205,7 +229,7 @@ static void template_arg_list_print
 static template_arg_list_t current_template_arg_list
   PARAMS ((demangling_t));
 static demangling_t demangling_new
-  PARAMS ((char *));
+  PARAMS ((const char *));
 static void demangling_delete 
   PARAMS ((demangling_t));
 
@@ -214,15 +238,12 @@ static void demangling_delete
   (dyn_string_buf (DS)[dyn_string_length (DS) - 1])
 
 /* Append a space character (` ') to DS if it does not already end
-   with one.  */
+   with one.  Evaluates to 1 on success, or 0 on allocation failure.  */
 #define dyn_string_append_space(DS)                                     \
-  do                                                                    \
-    {                                                                   \
-      if (dyn_string_length (DS) > 0                                    \
-          && dyn_string_last_char (DS) != ' ')                          \
-       dyn_string_append_char ((DS), ' ');                             \
-    }                                                                   \
-  while (0)
+      ((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)
@@ -251,15 +272,18 @@ static void demangling_delete
 
 /* Appends a dyn_string_t to the demangled result.  */
 #define result_append_string(DM, STRING)                                \
-  dyn_string_append (&(DM)->result->string, (STRING))
+  (dyn_string_append (&(DM)->result->string, (STRING))                  \
+   ? STATUS_OK : STATUS_ALLOCATION_FAILED)
 
 /* Appends NUL-terminated string CSTR to the demangled result.  */
 #define result_append(DM, CSTR)                                         \
-  dyn_string_append_cstr (&(DM)->result->string, (CSTR))
+  (dyn_string_append_cstr (&(DM)->result->string, (CSTR))               \
+   ? STATUS_OK : STATUS_ALLOCATION_FAILED)
 
 /* Appends character CHAR to the demangled result.  */
 #define result_append_char(DM, CHAR)                                    \
-  dyn_string_append_char (&(DM)->result->string, (CHAR))
+  (dyn_string_append_char (&(DM)->result->string, (CHAR))               \
+   ? STATUS_OK : STATUS_ALLOCATION_FAILED)
 
 /* The length of the current demangled result.  */
 #define result_length(DM)                                               \
@@ -268,23 +292,13 @@ static void demangling_delete
 /* Appends a space to the demangled result if the last character is
    not a space.  */
 #define result_append_space(DM)                                         \
-  dyn_string_append_space (&(DM)->result->string)
-
-/* 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 (s != STATUS_OK)                                               \
-       return s;                                                       \
-    }                                                                   \
-  while (0)
+  (dyn_string_append_space (&(DM)->result->string)                      \
+   ? STATUS_OK : STATUS_ALLOCATION_FAILED)
 
-/* Appends a base 10 representation of VALUE to DS.  */
+/* Appends a base 10 representation of VALUE to DS.  STATUS_OK on
+   success.  On failure, deletes DS and returns an error code.  */
 
-static void 
+static status_t
 int_to_dyn_string (value, ds)
      int value;
      dyn_string_t ds;
@@ -295,14 +309,16 @@ int_to_dyn_string (value, ds)
   /* Handle zero up front.  */
   if (value == 0)
     {
-      dyn_string_append_char (ds, '0');
-      return;
+      if (!dyn_string_append_char (ds, '0'))
+       return STATUS_ALLOCATION_FAILED;
+      return STATUS_OK;
     }
 
   /* For negative numbers, emit a minus sign.  */
   if (value < 0)
     {
-      dyn_string_append_char (ds, '-');
+      if (!dyn_string_append_char (ds, '-'))
+       return STATUS_ALLOCATION_FAILED;
       value = -value;
     }
   
@@ -318,23 +334,31 @@ int_to_dyn_string (value, ds)
   while (mask > 0)
     {
       int digit = value / mask;
-      dyn_string_append_char (ds, '0' + digit);
+
+      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.  */
+   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) xmalloc (sizeof (struct string_list_def));
-  dyn_string_init ((dyn_string_t) s, length);
+  string_list_t s = (string_list_t) malloc (sizeof (struct string_list_def));
+  if (s == NULL)
+    return NULL;
+  if (!dyn_string_init ((dyn_string_t) s, length))
+    return NULL;
   return s;
 }  
 
@@ -357,26 +381,46 @@ string_list_delete (node)
    first, so that the two greater-than characters don't look like a
    right shift token.  */
 
-static void
+static status_t
 result_close_template_list (dm)
      demangling_t dm;
 {
   dyn_string_t s = &dm->result->string;
+
+  /* Add a space if the last character is already a closing angle
+     bracket, so that a nested template arg list doesn't look like
+     it's closed with a right-shift operator.  */
   if (dyn_string_last_char (s) == '>')
-    dyn_string_append_char (s, ' ');
-  dyn_string_append_char (s, '>');
+    {
+      if (!dyn_string_append_char (s, ' '))
+       return STATUS_ALLOCATION_FAILED;
+    }
+
+  /* Add closing angle brackets.  */
+  if (!dyn_string_append_char (s, '>'))
+    return STATUS_ALLOCATION_FAILED;
+
+  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.  */
+   for DM.  Subsequent demangling with DM will emit to the new string.
+   Returns STATUS_OK on success, STATUS_ALLOCATION_FAILED on
+   allocation failure.  */
 
-static void
+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
@@ -412,7 +456,7 @@ substitution_start (dm)
    otherwise-identical types and other <template-param>s with
    different indices.  */
 
-static void
+static status_t
 substitution_add (dm, start_position, template_p, template_parm_number)
      demangling_t dm;
      int start_position;
@@ -423,8 +467,17 @@ substitution_add (dm, start_position, template_p, template_parm_number)
   dyn_string_t substitution = dyn_string_new (0);
   int i;
 
-  dyn_string_substring (substitution, 
-                       result, start_position, result_length (dm));
+  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_length (dm)))
+    {
+      dyn_string_delete (substitution);
+      return STATUS_ALLOCATION_FAILED;
+    }
 
   /* Check whether SUBSTITUTION already occurs.  */
   for (i = 0; i < dm->num_substitutions; ++i)
@@ -435,17 +488,25 @@ substitution_add (dm, start_position, template_p, template_parm_number)
        /* Callers expect this function to take ownership of
           SUBSTITUTION, so delete it.  */
        dyn_string_delete (substitution);
-       return;
+       return STATUS_OK;
       }
 
   /* If there's no room for the new entry, grow the array.  */
   if (dm->substitutions_allocated == dm->num_substitutions)
     {
+      size_t new_array_size;
       dm->substitutions_allocated *= 2;
-      dm->substitutions = (struct substitution_def *) 
-       xrealloc (dm->substitutions,
-                 sizeof (struct substitution_def) 
-                 * dm->substitutions_allocated);
+      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.  */
@@ -457,6 +518,8 @@ substitution_add (dm, start_position, template_p, template_parm_number)
 #ifdef CP_DEMANGLE_DEBUG
   substitutions_print (dm, stderr);
 #endif
+
+  return STATUS_OK;
 }
 
 /* Returns the Nth-most-recent substitution.  Sets *TEMPLATE_P to
@@ -509,13 +572,16 @@ substitutions_print (dm, fp)
 
 #endif /* CP_DEMANGLE_DEBUG */
 
-/* Creates a new template argument list.  */
+/* 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) xmalloc (sizeof (struct template_arg_list_def));
+  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;
@@ -652,24 +718,34 @@ current_template_arg_list (dm)
 }
 
 /* Allocates a demangling_t object for demangling mangled NAME.  A new
-   result must be pushed before the returned object can be used.  */
+   result must be pushed before the returned object can be used.
+   Returns NULL if allocation fails.  */
 
 static demangling_t
 demangling_new (name)
-     char *name;
+     const char *name;
 {
-  demangling_t dm = (demangling_t) 
-    xmalloc (sizeof (struct demangling_def));
+  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->last_source_name = dyn_string_new (0);
   dm->num_substitutions = 0;
   dm->substitutions_allocated = 10;
-  dm->substitutions = (struct substitution_def *) 
-    xmalloc (dm->substitutions_allocated * sizeof (struct substitution_def));
   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;
+    }
 
   return dm;
 }
@@ -775,7 +851,9 @@ static status_t demangle_local_name
 static status_t demangle_discriminator 
   PARAMS ((demangling_t, int));
 static status_t cp_demangle
-  PARAMS ((char *, dyn_string_t));
+  PARAMS ((const char *, dyn_string_t));
+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.  */
@@ -850,7 +928,7 @@ demangle_encoding (dm)
       if (special_std_substitution)
        {
          /* This was the magic `std::' substitution.  */
-         result_append (dm, "::");
+         RETURN_IF_ERROR (result_append (dm, "::"));
          RETURN_IF_ERROR (demangle_encoding (dm));
        }
     }
@@ -878,7 +956,8 @@ demangle_encoding (dm)
              (demangle_bare_function_type (dm, BFT_NO_RETURN_TYPE)); 
        }
 
-      substitution_add (dm, start, template_p, NOT_TEMPLATE_PARM);
+      RETURN_IF_ERROR (substitution_add (dm, start, template_p, 
+                                        NOT_TEMPLATE_PARM));
     }
 
   /* Pop off template argument lists that were built during the
@@ -931,7 +1010,7 @@ demangle_name (dm, template_p)
        {
          (void) next_char (dm);
          (void) next_char (dm);
-         result_append (dm, "std::");
+         RETURN_IF_ERROR (result_append (dm, "std::"));
          RETURN_IF_ERROR (demangle_unqualified_name (dm));
        }
       else
@@ -943,7 +1022,7 @@ demangle_name (dm, template_p)
              /* This was the magic `std::' substitution.  We can have
                 a <nested-name> or one of the unscoped names
                 following.  */
-             result_append (dm, "::");
+             RETURN_IF_ERROR (result_append (dm, "::"));
              RETURN_IF_ERROR (demangle_name (dm, template_p));
            }
        }
@@ -958,7 +1037,8 @@ demangle_name (dm, template_p)
       if (peek_char (dm) == 'I')
        {
          /* Add a substitution for the unqualified template name.  */
-         substitution_add (dm, start, 0, NOT_TEMPLATE_PARM);
+         RETURN_IF_ERROR (substitution_add (dm, start, 0, 
+                                            NOT_TEMPLATE_PARM));
 
          RETURN_IF_ERROR (demangle_template_args (dm));
          *template_p = 1;
@@ -990,12 +1070,18 @@ demangle_nested_name (dm, template_p)
   peek = peek_char (dm);
   if (peek == 'r' || peek == 'V' || peek == 'K')
     {
+      status_t status;
+
       /* Snarf up and emit CV qualifiers.  */
       dyn_string_t cv_qualifiers = dyn_string_new (24);
+      if (cv_qualifiers == NULL)
+       return STATUS_ALLOCATION_FAILED;
+
       demangle_CV_qualifiers (dm, cv_qualifiers);
-      result_append_string (dm, cv_qualifiers);
+      status = result_append_string (dm, cv_qualifiers);
       dyn_string_delete (cv_qualifiers);
-      result_append_space (dm);
+      RETURN_IF_ERROR (status);
+      RETURN_IF_ERROR (result_append_space (dm));
     }
   
   RETURN_IF_ERROR (demangle_prefix (dm, template_p));
@@ -1043,14 +1129,14 @@ demangle_prefix (dm, template_p)
 
       peek = peek_char (dm);
       
-      if (isdigit ((unsigned char) peek)
+      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)
-           result_append (dm, "::");
+           RETURN_IF_ERROR (result_append (dm, "::"));
          else
            nested = 1;
 
@@ -1072,7 +1158,7 @@ demangle_prefix (dm, template_p)
          if (*template_p)
            return STATUS_INTERNAL_ERROR;
          /* The template name is a substitution candidate.  */
-         substitution_add (dm, start, 0, NOT_TEMPLATE_PARM);
+         RETURN_IF_ERROR (substitution_add (dm, start, 0, NOT_TEMPLATE_PARM));
          RETURN_IF_ERROR (demangle_template_args (dm));
          *template_p = 1;
        }
@@ -1083,7 +1169,8 @@ demangle_prefix (dm, template_p)
        return "Unexpected character in <compound-name>.";
 
       /* Add a new substitution for the prefix thus far.  */
-      substitution_add (dm, start, *template_p, NOT_TEMPLATE_PARM);
+      RETURN_IF_ERROR (substitution_add (dm, start, *template_p, 
+                                        NOT_TEMPLATE_PARM));
     }
 }
 
@@ -1104,7 +1191,7 @@ demangle_unqualified_name (dm)
 
   DEMANGLE_TRACE ("unqualified-name", dm);
 
-  if (isdigit ((unsigned char) peek))
+  if (IS_DIGIT ((unsigned char) peek))
     RETURN_IF_ERROR (demangle_source_name (dm));
   else if (peek >= 'a' && peek <= 'z')
     {
@@ -1142,7 +1229,7 @@ demangle_source_name (dm)
                                        dm->last_source_name));
 
   /* Emit it.  */
-  result_append_string (dm, dm->last_source_name);
+  RETURN_IF_ERROR (result_append_string (dm, dm->last_source_name));
 
   return STATUS_OK;
 }
@@ -1168,6 +1255,9 @@ demangle_number (dm, value, base, is_signed)
 
   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);
@@ -1201,17 +1291,21 @@ demangle_number_literally (dm, str, base, is_signed)
       advance_char (dm);
       /* The normal way to write a negative number is with a minus
         sign.  */
-      dyn_string_append_char (str, '-');
+      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 (isdigit ((unsigned char) peek)
+      if (IS_DIGIT ((unsigned char) peek)
          || (base == 36 && peek >= 'A' && peek <= 'Z'))
-       /* Accumulate digits.  */
-       dyn_string_append_char (str, next_char (dm));
+       {
+         /* Accumulate digits.  */
+         if (!dyn_string_append_char (str, next_char (dm)))
+           return STATUS_ALLOCATION_FAILED;
+       }
       else
        /* Not a digit?  All done.  */
        break;
@@ -1232,12 +1326,15 @@ demangle_identifier (dm, length, identifier)
   DEMANGLE_TRACE ("identifier", dm);
 
   dyn_string_clear (identifier);
-  dyn_string_resize (identifier, length);
+  if (!dyn_string_resize (identifier, length))
+    return STATUS_ALLOCATION_FAILED;
+
   while (length-- > 0)
     {
       if (end_of_name_p (dm))
        return "Unexpected end of name in <identifier>.";
-      dyn_string_append_char (identifier, next_char (dm));
+      if (!dyn_string_append_char (identifier, next_char (dm)))
+       return STATUS_ALLOCATION_FAILED;
     }
 
   return STATUS_OK;
@@ -1380,7 +1477,7 @@ demangle_operator_name (dm, short_name, num_args)
   /* Is this a vendor extended operator?  */
   if (c0 == 'v' && c1 == 'x')
     {
-      result_append (dm, "operator");
+      RETURN_IF_ERROR (result_append (dm, "operator"));
       RETURN_IF_ERROR (demangle_source_name (dm));
       *num_args = 0;
       return STATUS_OK;
@@ -1389,7 +1486,7 @@ demangle_operator_name (dm, short_name, num_args)
   /* Is this a conversion operator?  */
   if (c0 == 'c' && c1 == 'v')
     {
-      result_append (dm, "operator ");
+      RETURN_IF_ERROR (result_append (dm, "operator "));
       /* Demangle the converted-to type.  */
       RETURN_IF_ERROR (demangle_type (dm));
       *num_args = 0;
@@ -1407,8 +1504,8 @@ demangle_operator_name (dm, short_name, num_args)
        /* Found it.  */
        {
          if (!short_name)
-           result_append (dm, "operator");
-         result_append (dm, p->name);
+           RETURN_IF_ERROR (result_append (dm, "operator"));
+         RETURN_IF_ERROR (result_append (dm, p->name));
          *num_args = p->num_args;
 
          return STATUS_OK;
@@ -1461,11 +1558,13 @@ demangle_special_name (dm)
       /* A guard variable name.  Consume the G.  */
       advance_char (dm);
       RETURN_IF_ERROR (demangle_char (dm, 'V'));
-      result_append (dm, "guard variable for ");
+      RETURN_IF_ERROR (result_append (dm, "guard variable for "));
       RETURN_IF_ERROR (demangle_name (dm, &unused));
     }
   else if (peek == 'T')
     {
+      status_t status = STATUS_OK;
+
       /* Other C++ implementation miscellania.  Consume the T.  */
       advance_char (dm);
 
@@ -1474,96 +1573,108 @@ demangle_special_name (dm)
        case 'V':
          /* Virtual table.  */
          advance_char (dm);
-         result_append (dm, "vtable for ");
+         RETURN_IF_ERROR (result_append (dm, "vtable for "));
          RETURN_IF_ERROR (demangle_type (dm));
          break;
 
        case 'T':
          /* VTT structure.  */
          advance_char (dm);
-         result_append (dm, "VTT for ");
+         RETURN_IF_ERROR (result_append (dm, "VTT for "));
          RETURN_IF_ERROR (demangle_type (dm));
          break;
 
        case 'I':
          /* Typeinfo structure.  */
          advance_char (dm);
-         result_append (dm, "typeinfo for ");
+         RETURN_IF_ERROR (result_append (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);
-         result_append (dm, "typeinfo fn for ");
+         RETURN_IF_ERROR (result_append (dm, "typeinfo fn for "));
          RETURN_IF_ERROR (demangle_type (dm));
          break;
 
        case 'S':
          /* Character string containing type name, used in typeinfo. */
          advance_char (dm);
-         result_append (dm, "typeinfo name for ");
+         RETURN_IF_ERROR (result_append (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);
-         result_append (dm, "java Class for ");
+         RETURN_IF_ERROR (result_append (dm, "java Class for "));
          RETURN_IF_ERROR (demangle_type (dm));
          break;
 
        case 'h':
          /* Non-virtual thunk.  */
          advance_char (dm);
-         result_append (dm, "non-virtual thunk");
+         RETURN_IF_ERROR (result_append (dm, "non-virtual thunk"));
          /* Demangle and emit 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)
            {
-             result_append_char (dm, ' ');
-             result_append_string (dm, number);
+             status = result_append_char (dm, ' ');
+             if (STATUS_NO_ERROR (status))
+               status = result_append_string (dm, number);
            }
          dyn_string_delete (number);
+         RETURN_IF_ERROR (status);
          /* Demangle the separator.  */
          RETURN_IF_ERROR (demangle_char (dm, '_'));
          /* Demangle and emit the target name and function type.  */
-         result_append (dm, " to ");
+         RETURN_IF_ERROR (result_append (dm, " to "));
          RETURN_IF_ERROR (demangle_encoding (dm));
          break;
 
        case 'v':
          /* Virtual thunk.  */
          advance_char (dm);
-         result_append (dm, "virtual thunk ");
+         RETURN_IF_ERROR (result_append (dm, "virtual thunk "));
          /* Demangle and emit 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)
            {
-             result_append_string (dm, number);
-             result_append_char (dm, ' ');
+             status = result_append_string (dm, number);
+             if (STATUS_NO_ERROR (status))
+               result_append_char (dm, ' ');
            }
          dyn_string_delete (number);
+         RETURN_IF_ERROR (status);
          /* Demangle the separator.  */
          RETURN_IF_ERROR (demangle_char (dm, '_'));
          /* Demangle and emit 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)
            {
-             result_append_string (dm, number);
-             result_append_char (dm, ' ');
+             status = result_append_string (dm, number);
+             if (STATUS_NO_ERROR (status))
+               status = result_append_char (dm, ' ');
            }
          dyn_string_delete (number);
+         RETURN_IF_ERROR (status);
          /* Demangle the separator.  */
          RETURN_IF_ERROR (demangle_char (dm, '_'));
          /* Demangle and emit the target function.  */
-         result_append (dm, "to ");
+         RETURN_IF_ERROR (result_append (dm, "to "));
          RETURN_IF_ERROR (demangle_encoding (dm));
          break;
 
@@ -1572,23 +1683,27 @@ demangle_special_name (dm)
          if (!flag_strict)
            {
              advance_char (dm);
-             result_append (dm, "construction vtable for ");
+             RETURN_IF_ERROR (result_append (dm, "construction vtable for "));
              RETURN_IF_ERROR (demangle_type (dm));
              /* Demangle the offset.  */
              number = dyn_string_new (4);
+             if (number == NULL)
+               return STATUS_ALLOCATION_FAILED;
              demangle_number_literally (dm, number, 10, 1);
              /* Demangle the underscore separator.  */
              RETURN_IF_ERROR (demangle_char (dm, '_'));
              /* Demangle the base type.  */
-             result_append (dm, "-in-");
+             RETURN_IF_ERROR (result_append (dm, "-in-"));
              RETURN_IF_ERROR (demangle_type (dm));
              /* Don't display the offset unless in verbose mode.  */
              if (flag_verbose)
                {
-                 result_append_char (dm, ' ');
-                 result_append_string (dm, number);
+                 status = result_append_char (dm, ' ');
+                 if (STATUS_NO_ERROR (status))
+                   result_append_string (dm, number);
                }
              dyn_string_delete (number);
+             RETURN_IF_ERROR (status);
              break;
            }
          /* If flag_strict, fall through.  */
@@ -1643,14 +1758,14 @@ demangle_ctor_dtor_name (dm)
       advance_char (dm);
       if (peek_char (dm) < '1' || peek_char (dm) > '4')
        return "Unrecognized constructor.";
-      result_append_string (dm, dm->last_source_name);
+      RETURN_IF_ERROR (result_append_string (dm, dm->last_source_name));
       /* Print the flavor of the constructor if in verbose mode.  */
       flavor = next_char (dm) - '1';
       if (flag_verbose)
        {
-         result_append (dm, "[");
-         result_append (dm, ctor_flavors[flavor]);
-         result_append_char (dm, ']');
+         RETURN_IF_ERROR (result_append (dm, "["));
+         RETURN_IF_ERROR (result_append (dm, ctor_flavors[flavor]));
+         RETURN_IF_ERROR (result_append_char (dm, ']'));
        }
     }
   else if (peek == 'D')
@@ -1659,15 +1774,15 @@ demangle_ctor_dtor_name (dm)
       advance_char (dm);
       if (peek_char (dm) < '0' || peek_char (dm) > '2')
        return "Unrecognized destructor.";
-      result_append_char (dm, '~');
-      result_append_string (dm, dm->last_source_name);
+      RETURN_IF_ERROR (result_append_char (dm, '~'));
+      RETURN_IF_ERROR (result_append_string (dm, dm->last_source_name));
       /* Print the flavor of the destructor if in verbose mode.  */
       flavor = next_char (dm) - '0';
       if (flag_verbose)
        {
-         result_append (dm, " [");
-         result_append (dm, dtor_flavors[flavor]);
-         result_append_char (dm, ']');
+         RETURN_IF_ERROR (result_append (dm, " ["));
+         RETURN_IF_ERROR (result_append (dm, dtor_flavors[flavor]));
+         RETURN_IF_ERROR (result_append_char (dm, ']'));
        }
     }
   else
@@ -1701,6 +1816,9 @@ demangle_type_ptr (dm)
 
   DEMANGLE_TRACE ("type*", dm);
 
+  if (symbols == NULL)
+    return STATUS_ALLOCATION_FAILED;
+
   /* Scan forward, collecting pointers and references into symbols,
      until we hit something else.  Then emit the type.  */
   while (1)
@@ -1708,12 +1826,14 @@ demangle_type_ptr (dm)
       next = peek_char (dm);
       if (next == 'P')
        {
-         dyn_string_append_char (symbols, '*');
+         if (!dyn_string_append_char (symbols, '*'))
+           return STATUS_ALLOCATION_FAILED;
          advance_char (dm);
        }
       else if (next == 'R')
        {
-         dyn_string_append_char (symbols, '&');
+         if (!dyn_string_append_char (symbols, '&'))
+           return STATUS_ALLOCATION_FAILED;
          advance_char (dm);
        }
       else if (next == 'M')
@@ -1725,14 +1845,16 @@ demangle_type_ptr (dm)
          advance_char (dm);
 
          /* Capture the type of which this is a pointer-to-member.  */
-         result_push (dm);
+         RETURN_IF_ERROR (result_push (dm));
          RETURN_IF_ERROR (demangle_type (dm));
          class_type = (dyn_string_t) result_pop (dm);
 
          /* Build the pointer-to-member notation.  It comes before
             other pointer and reference qualifiers -- */
-         dyn_string_prepend_cstr (symbols, "::*");
-         dyn_string_prepend (symbols, class_type);
+         if (!dyn_string_prepend_cstr (symbols, "::*"))
+           return STATUS_ALLOCATION_FAILED;
+         if (!dyn_string_prepend (symbols, class_type))
+           return STATUS_ALLOCATION_FAILED;
          dyn_string_delete (class_type);
 
          if (peek_char (dm) == 'F')
@@ -1741,10 +1863,12 @@ demangle_type_ptr (dm)
          /* Demangle the type of the pointed-to member.  */
          status = demangle_type (dm);
          /* Make it pretty.  */
-         result_append_space (dm);
+         if (STATUS_NO_ERROR (status))
+           status = result_append_space (dm);
          /* Add the pointer-to-member syntax, and other pointer and
             reference symbols.  */
-         result_append_string (dm, symbols);
+         if (STATUS_NO_ERROR (status))
+           status = result_append_string (dm, symbols);
          /* Clean up.  */
          dyn_string_delete (symbols);
 
@@ -1755,10 +1879,13 @@ demangle_type_ptr (dm)
        {
          /* Ooh, tricky, a pointer-to-function.  */
          int position = result_length (dm);
-         result_append_char (dm, '(');
-         result_append_string (dm, symbols);
-         result_append_char (dm, ')');
+         status = result_append_char (dm, '(');
+         if (STATUS_NO_ERROR (status))
+           status = result_append_string (dm, symbols);
+         if (STATUS_NO_ERROR (status))
+           status = result_append_char (dm, ')');
          dyn_string_delete (symbols);
+         RETURN_IF_ERROR (status);
 
          RETURN_IF_ERROR (demangle_function_type (dm, position));
          return STATUS_OK;
@@ -1768,8 +1895,10 @@ demangle_type_ptr (dm)
          /* No more pointe or reference tokens.  Finish up.  */
          status = demangle_type (dm);
 
-         result_append_string (dm, symbols);
+         if (STATUS_NO_ERROR (status))
+           status = result_append_string (dm, symbols);
          dyn_string_delete (symbols);
+         RETURN_IF_ERROR (status);
 
          RETURN_IF_ERROR (status);
          return STATUS_OK;
@@ -1809,7 +1938,7 @@ demangle_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 (isdigit ((unsigned char) peek) || peek == 'N' || peek == 'Z')
+  if (IS_DIGIT ((unsigned char) peek) || peek == 'N' || peek == 'Z')
     RETURN_IF_ERROR (demangle_class_enum_type (dm, &template_p));
   else if (peek >= 'a' && peek <= 'z')
     {
@@ -1825,6 +1954,10 @@ demangle_type (dm)
        {
          status_t status;
          dyn_string_t cv_qualifiers = dyn_string_new (24);
+
+         if (cv_qualifiers == NULL)
+           return STATUS_ALLOCATION_FAILED;
+
          demangle_CV_qualifiers (dm, cv_qualifiers);
 
          /* If the qualifiers apply to a pointer or reference, they
@@ -1832,15 +1965,19 @@ demangle_type (dm)
          if (peek_char (dm) == 'P' || peek_char (dm) == 'R')
            {
              status = demangle_type (dm);
-             result_append_space (dm);
-             result_append_string (dm, cv_qualifiers);
+             if (STATUS_NO_ERROR (status))
+               status = result_append_space (dm);
+             if (STATUS_NO_ERROR (status))
+               status = result_append_string (dm, cv_qualifiers);
            }
          /* Otherwise, the qualifiers come first.  */
          else
            {
-             result_append_string (dm, cv_qualifiers);
-             result_append_space (dm);
-             status = demangle_type (dm);
+             status = result_append_string (dm, cv_qualifiers);
+             if (STATUS_NO_ERROR (status))
+               status = result_append_space (dm);
+             if (STATUS_NO_ERROR (status))
+               status = demangle_type (dm);
            }
 
          dyn_string_delete (cv_qualifiers);
@@ -1866,7 +2003,7 @@ demangle_type (dm)
          {
            /* This was the magic `std::' substitution.  What follows
               must be a class name in that namespace.  */
-           result_append (dm, "::");
+           RETURN_IF_ERROR (result_append (dm, "::"));
            RETURN_IF_ERROR (demangle_class_enum_type (dm, &template_p));
          }
        break;
@@ -1879,14 +2016,14 @@ demangle_type (dm)
 
       case 'C':
        /* A C99 complex type.  */
-       result_append (dm, "complex ");
+       RETURN_IF_ERROR (result_append (dm, "complex "));
        advance_char (dm);
        RETURN_IF_ERROR (demangle_type (dm));
        break;
 
       case 'G':
        /* A C99 imaginary type.  */
-       result_append (dm, "imaginary ");
+       RETURN_IF_ERROR (result_append (dm, "imaginary "));
        advance_char (dm);
        RETURN_IF_ERROR (demangle_type (dm));
        break;
@@ -1895,7 +2032,7 @@ demangle_type (dm)
        /* Vendor extended type qualifier.  */
        advance_char (dm);
        RETURN_IF_ERROR (demangle_source_name (dm));
-       result_append_char (dm, ' ');
+       RETURN_IF_ERROR (result_append_char (dm, ' '));
        RETURN_IF_ERROR (demangle_type (dm));
        break;
 
@@ -1909,7 +2046,7 @@ demangle_type (dm)
        <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.  */
-    substitution_add (dm, start, template_p, template_parm);
+    RETURN_IF_ERROR (substitution_add (dm, start, template_p, template_parm));
 
   /* Pop off template argument lists added during mangling of this
      type.  */
@@ -1996,7 +2133,7 @@ demangle_builtin_type (dm)
       if (type_name == NULL)
        return "Unrecognized <builtin-type> code.";
 
-      result_append (dm, type_name);
+      RETURN_IF_ERROR (result_append (dm, type_name));
       advance_char (dm);
       return STATUS_OK;
     }
@@ -2020,18 +2157,24 @@ demangle_CV_qualifiers (dm, qualifiers)
       switch (peek_char (dm))
        {
        case 'r':
-         dyn_string_append_space (qualifiers);
-         dyn_string_append_cstr (qualifiers, "restrict");
+         if (!dyn_string_append_space (qualifiers))
+           return STATUS_ALLOCATION_FAILED;
+         if (!dyn_string_append_cstr (qualifiers, "restrict"))
+           return STATUS_ALLOCATION_FAILED;
          break;
 
        case 'V':
-         dyn_string_append_space (qualifiers);
-         dyn_string_append_cstr (qualifiers, "volatile");
+         if (!dyn_string_append_space (qualifiers))
+           return STATUS_ALLOCATION_FAILED;
+         if (!dyn_string_append_cstr (qualifiers, "volatile"))
+           return STATUS_ALLOCATION_FAILED;
          break;
 
        case 'K':
-         dyn_string_append_space (qualifiers);
-         dyn_string_append_cstr (qualifiers, "const");
+         if (!dyn_string_append_space (qualifiers))
+           return STATUS_ALLOCATION_FAILED;
+         if (!dyn_string_append_cstr (qualifiers, "const"))
+           return STATUS_ALLOCATION_FAILED;
          break;
 
        default:
@@ -2059,7 +2202,7 @@ demangle_function_type (dm, function_name_pos)
     {
       /* Indicate this function has C linkage if in verbose mode.  */
       if (flag_verbose)
-       result_append (dm, " [extern \"C\"] ");
+       RETURN_IF_ERROR (result_append (dm, " [extern \"C\"] "));
       advance_char (dm);
     }
   RETURN_IF_ERROR (demangle_bare_function_type (dm, function_name_pos));
@@ -2086,26 +2229,29 @@ demangle_bare_function_type (dm, return_type_pos)
 
   DEMANGLE_TRACE ("bare-function-type", dm);
 
-  result_append_char (dm, '(');
+  RETURN_IF_ERROR (result_append_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.  */
-         result_push (dm);
+         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.  */
-         dyn_string_append_space (return_type);
+         /* 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) 
+             || !dyn_string_insert (result_string (dm), return_type_pos, 
+                                    return_type))
+           status = STATUS_ALLOCATION_FAILED;
 
-         /* Insert the return type where we've been asked to.  */
-         dyn_string_insert (result_string (dm), return_type_pos, 
-                        return_type);
          dyn_string_delete (return_type);
+         RETURN_IF_ERROR (status);
        }
       else 
        {
@@ -2120,14 +2266,14 @@ demangle_bare_function_type (dm, return_type_pos)
            }
          /* Separate parameter types by commas.  */
          if (sequence > 0)
-           result_append (dm, ", ");
+           RETURN_IF_ERROR (result_append (dm, ", "));
          /* Demangle the type.  */
          RETURN_IF_ERROR (demangle_type (dm));
        }
 
       ++sequence;
     }
-  result_append_char (dm, ')');
+  RETURN_IF_ERROR (result_append_char (dm, ')'));
 
   return STATUS_OK;
 }
@@ -2156,23 +2302,35 @@ static status_t
 demangle_array_type (dm)
      demangling_t dm;
 {
+  status_t status;
   dyn_string_t array_size = dyn_string_new (10);
 
-  RETURN_IF_ERROR (demangle_char (dm, 'A'));
+  if (array_size == NULL)
+    return STATUS_ALLOCATION_FAILED;
+
+  status = demangle_char (dm, 'A');
 
   /* Demangle the array size into array_size.  */
-  RETURN_IF_ERROR (demangle_number_literally (dm, array_size, 10, 0));
+  if (STATUS_NO_ERROR (status))
+    status = demangle_number_literally (dm, array_size, 10, 0);
 
   /* Demangle the base type of the array.  */
-  RETURN_IF_ERROR (demangle_char (dm, '_'));
-  RETURN_IF_ERROR (demangle_type (dm));
+  if (STATUS_NO_ERROR (status))
+    status = demangle_char (dm, '_');
+  if (STATUS_NO_ERROR (status))
+    status = demangle_type (dm);
 
   /* Emit the array dimension syntax.  */
-  result_append_char (dm, '[');
-  result_append_string (dm, array_size);
-  result_append_char (dm, ']');
+  if (STATUS_NO_ERROR (status))
+    status = result_append_char (dm, '[');
+  if (STATUS_NO_ERROR (status))
+    status = result_append_string (dm, array_size);
+  if (STATUS_NO_ERROR (status))
+    status = result_append_char (dm, ']');
   dyn_string_delete (array_size);
   
+  RETURN_IF_ERROR (status);
+
   return STATUS_OK;
 }
 
@@ -2213,7 +2371,7 @@ demangle_template_param (dm, template_parm_number)
     /* parm_number exceeded the number of arguments in the current
        template argument list.  */
     return "Template parameter number out of bounds.";
-  result_append_string (dm, (dyn_string_t) arg);
+  RETURN_IF_ERROR (result_append_string (dm, (dyn_string_t) arg));
 
   if (peek_char (dm) == 'I')
     RETURN_IF_ERROR (demangle_template_args (dm));
@@ -2231,16 +2389,23 @@ 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.  */
-  dyn_string_t old_last_source_name = dm->last_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'));
-  result_append_char (dm, '<');
+  RETURN_IF_ERROR (result_append_char (dm, '<'));
   do
     {
       string_list_t arg;
@@ -2248,22 +2413,22 @@ demangle_template_args (dm)
       if (first)
        first = 0;
       else
-       result_append (dm, ", ");
+       RETURN_IF_ERROR (result_append (dm, ", "));
 
       /* Capture the template arg.  */
-      result_push (dm);
+      RETURN_IF_ERROR (result_push (dm));
       RETURN_IF_ERROR (demangle_template_arg (dm));
       arg = result_pop (dm);
 
       /* Emit it in the demangled name.  */
-      result_append_string (dm, (dyn_string_t) arg);
+      RETURN_IF_ERROR (result_append_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 '>'.  */
-  result_close_template_list (dm);
+  RETURN_IF_ERROR (result_close_template_list (dm));
 
   /* Consume the 'E'.  */
   advance_char (dm);
@@ -2293,8 +2458,9 @@ static status_t
 demangle_literal (dm)
      demangling_t dm;
 {
-  dyn_string_t value = dyn_string_new (0);
   char peek = peek_char (dm);
+  dyn_string_t value_string;
+  status_t status;
 
   DEMANGLE_TRACE ("literal", dm);
 
@@ -2331,9 +2497,9 @@ demangle_literal (dm)
             corresponding to false or true, respectively.  */
          value = peek_char (dm);
          if (value == '0')
-           result_append (dm, "false");
+           RETURN_IF_ERROR (result_append (dm, "false"));
          else if (value == '1')
-           result_append (dm, "true");
+           RETURN_IF_ERROR (result_append (dm, "true"));
          else
            return "Unrecognized bool constant.";
          /* Consume the 0 or 1.  */
@@ -2346,25 +2512,37 @@ demangle_literal (dm)
 
          /* Consume the type character.  */
          advance_char (dm);
+
          /* Demangle the number and write it out.  */
-         RETURN_IF_ERROR (demangle_number_literally (dm, value, 10, 1));
-         result_append_string (dm, value);
+         value_string = dyn_string_new (0);
+         status = demangle_number_literally (dm, value_string, 10, 1);
+         if (STATUS_NO_ERROR (status))
+           status = result_append_string (dm, value_string);
          /* For long integers, append an l.  */
-         if (code == 'l')
-           result_append_char (dm, code);
+         if (code == 'l' && STATUS_NO_ERROR (status))
+           status = result_append_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.  */
     }
 
-  result_append_char (dm, '(');
+  RETURN_IF_ERROR (result_append_char (dm, '('));
   RETURN_IF_ERROR (demangle_type (dm));
-  result_append_char (dm, ')');
+  RETURN_IF_ERROR (result_append_char (dm, ')'));
+
+  value_string = dyn_string_new (0);
+  if (value_string == NULL)
+    return STATUS_ALLOCATION_FAILED;
 
-  RETURN_IF_ERROR (demangle_number_literally (dm, value, 10, 1));
-  result_append_string (dm, value);
-  dyn_string_delete (value);
+  status = demangle_number_literally (dm, value_string, 10, 1);
+  if (STATUS_NO_ERROR (status))
+    status = result_append_string (dm, value_string);
+  dyn_string_delete (value_string);
+  RETURN_IF_ERROR (status);
 
   return STATUS_OK;
 }
@@ -2436,37 +2614,43 @@ demangle_expression (dm)
     /* An operator expression.  */
     {
       int num_args;
+      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.  */
-      result_push (dm);
+      RETURN_IF_ERROR (result_push (dm));
       RETURN_IF_ERROR (demangle_operator_name (dm, 1, &num_args));
       operator_name = (dyn_string_t) result_pop (dm);
 
       /* If it's binary, do an operand first.  */
       if (num_args > 1)
        {
-         result_append_char (dm, '(');
-         RETURN_IF_ERROR (demangle_expression (dm));
-         result_append_char (dm, ')');
+         status = result_append_char (dm, '(');
+         if (STATUS_NO_ERROR (status))
+           status = demangle_expression (dm);
+         if (STATUS_NO_ERROR (status))
+           status = result_append_char (dm, ')');
        }
 
-      /* Now emit the operator, followed by its second (if binary) or
-        only (if unary) operand.  */
-      result_append_string (dm, operator_name);
+      /* Emit the operator.  */  
+      if (STATUS_NO_ERROR (status))
+       status = result_append_string (dm, operator_name);
       dyn_string_delete (operator_name);
-      result_append_char (dm, '(');
+      RETURN_IF_ERROR (status);
+      
+      /* Emit its second (if binary) or only (if unary) operand.  */
+      RETURN_IF_ERROR (result_append_char (dm, '('));
       RETURN_IF_ERROR (demangle_expression (dm));
-      result_append_char (dm, ')');
+      RETURN_IF_ERROR (result_append_char (dm, ')'));
 
       /* The ternary operator takes a third operand.  */
       if (num_args == 3)
        {
-         result_append (dm, ":(");
+         RETURN_IF_ERROR (result_append (dm, ":("));
          RETURN_IF_ERROR (demangle_expression (dm));
-         result_append_char (dm, ')');
+         RETURN_IF_ERROR (result_append_char (dm, ')'));
        }
     }
 
@@ -2485,7 +2669,7 @@ demangle_scope_expression (dm)
   RETURN_IF_ERROR (demangle_char (dm, 's'));
   RETURN_IF_ERROR (demangle_char (dm, 'r'));
   RETURN_IF_ERROR (demangle_type (dm));
-  result_append (dm, "::");
+  RETURN_IF_ERROR (result_append (dm, "::"));
   RETURN_IF_ERROR (demangle_encoding (dm));
   return STATUS_OK;
 }
@@ -2572,77 +2756,79 @@ demangle_substitution (dm, template_p, special_std_substitution)
   /* 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 (isdigit ((unsigned char) peek) 
+  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':
-         result_append (dm, "std");
+         RETURN_IF_ERROR (result_append (dm, "std"));
          *special_std_substitution = 1;
          break;
 
        case 'a':
-         result_append (dm, "std::allocator");
-         dyn_string_copy_cstr (dm->last_source_name, "allocator");
+         RETURN_IF_ERROR (result_append (dm, "std::allocator"));
+         new_last_source_name = "allocator";
          break;
 
        case 'b':
-         result_append (dm, "std::basic_string");
-         dyn_string_copy_cstr (dm->last_source_name, "basic_string");
+         RETURN_IF_ERROR (result_append (dm, "std::basic_string"));
+         new_last_source_name = "basic_string";
          break;
          
        case 's':
          if (!flag_verbose)
            {
-             result_append (dm, "std::string");
-             dyn_string_copy_cstr (dm->last_source_name, "string");
+             RETURN_IF_ERROR (result_append (dm, "std::string"));
+             new_last_source_name = "string";
            }
          else
            {
-             result_append (dm, "std::basic_string<char, std::char_traits<char>, std::allocator<char> >");
-             dyn_string_copy_cstr (dm->last_source_name, "basic_string");
+             RETURN_IF_ERROR (result_append (dm, "std::basic_string<char, std::char_traits<char>, std::allocator<char> >"));
+             new_last_source_name = "basic_string";
            }
          break;
 
        case 'i':
          if (!flag_verbose)
            {
-             result_append (dm, "std::istream");
-             dyn_string_copy_cstr (dm->last_source_name, "istream");
+             RETURN_IF_ERROR (result_append (dm, "std::istream"));
+             new_last_source_name = "istream";
            }
          else
            {
-             result_append (dm, "std::basic_istream<char, std::char_traints<char> >");
-             dyn_string_copy_cstr (dm->last_source_name, "basic_istream");
+             RETURN_IF_ERROR (result_append (dm, "std::basic_istream<char, std::char_traints<char> >"));
+             new_last_source_name = "basic_istream";
            }
          break;
 
        case 'o':
          if (!flag_verbose)
            {
-             result_append (dm, "std::ostream");
-             dyn_string_copy_cstr (dm->last_source_name, "ostream");
+             RETURN_IF_ERROR (result_append (dm, "std::ostream"));
+             new_last_source_name = "ostream";
            }
          else
            {
-             result_append (dm, "std::basic_ostream<char, std::char_traits<char> >");
-             dyn_string_copy_cstr (dm->last_source_name, "basic_ostream");
+             RETURN_IF_ERROR (result_append (dm, "std::basic_ostream<char, std::char_traits<char> >"));
+             new_last_source_name = "basic_ostream";
            }
          break;
 
        case 'd':
          if (!flag_verbose) 
            {
-             result_append (dm, "std::iostream");
-             dyn_string_copy_cstr (dm->last_source_name, "iostream");
+             RETURN_IF_ERROR (result_append (dm, "std::iostream"));
+             new_last_source_name = "iostream";
            }
          else
            {
-             result_append (dm, "std::basic_iostream<char, std::char_traits<char> >");
-             dyn_string_copy_cstr (dm->last_source_name, "basic_iostream");
+             RETURN_IF_ERROR (result_append (dm, "std::basic_iostream<char, std::char_traits<char> >"));
+             new_last_source_name = "basic_iostream";
            }
          break;
 
@@ -2650,7 +2836,16 @@ demangle_substitution (dm, template_p, special_std_substitution)
          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;
     }
 
@@ -2662,7 +2857,7 @@ demangle_substitution (dm, template_p, special_std_substitution)
     return "Substitution number out of range.";
 
   /* Emit the substitution text.  */
-  result_append_string (dm, text);
+  RETURN_IF_ERROR (result_append_string (dm, text));
 
   RETURN_IF_ERROR (demangle_char (dm, '_'));
   return STATUS_OK;
@@ -2682,12 +2877,12 @@ demangle_local_name (dm)
   RETURN_IF_ERROR (demangle_char (dm, 'Z'));
   RETURN_IF_ERROR (demangle_encoding (dm));
   RETURN_IF_ERROR (demangle_char (dm, 'E'));
-  result_append (dm, "'s ");
+  RETURN_IF_ERROR (result_append (dm, "'s "));
 
   if (peek_char (dm) == 's')
     {
       /* Local character string literal.  */
-      result_append (dm, "string literal");
+      RETURN_IF_ERROR (result_append (dm, "string literal"));
       /* Consume the s.  */
       advance_char (dm);
       RETURN_IF_ERROR (demangle_discriminator (dm, 0));
@@ -2695,7 +2890,7 @@ demangle_local_name (dm)
   else
     {
       int unused;
-      result_append (dm, "local ");
+      RETURN_IF_ERROR (result_append (dm, "local "));
       /* Local name for some other entity.  Demangle its name.  */
       RETURN_IF_ERROR (demangle_name (dm, &unused));
       RETURN_IF_ERROR (demangle_discriminator (dm, 1));
@@ -2725,9 +2920,9 @@ demangle_discriminator (dm, suppress_first)
       /* Consume the underscore.  */
       advance_char (dm);
       if (flag_verbose)
-       result_append (dm, " [#");
+       RETURN_IF_ERROR (result_append (dm, " [#"));
       /* Check if there's a number following the underscore.  */
-      if (isdigit ((unsigned char) peek_char (dm)))
+      if (IS_DIGIT ((unsigned char) peek_char (dm)))
        {
          int discriminator;
          /* Demangle the number.  */
@@ -2736,22 +2931,22 @@ demangle_discriminator (dm, suppress_first)
            /* Write the discriminator.  The mangled number is two
               less than the discriminator ordinal, counting from
               zero.  */
-           int_to_dyn_string (discriminator + 2, 
-                              (dyn_string_t) dm->result);
+           RETURN_IF_ERROR (int_to_dyn_string (discriminator + 2, 
+                                               (dyn_string_t) dm->result));
        }
       else
        {
          if (flag_verbose)
            /* A missing digit correspond to one.  */
-           result_append_char (dm, '1');
+           RETURN_IF_ERROR (result_append_char (dm, '1'));
        }
       if (flag_verbose)
-       result_append_char (dm, ']');
+       RETURN_IF_ERROR (result_append_char (dm, ']'));
     }
   else if (!suppress_first)
     {
       if (flag_verbose)
-       result_append (dm, " [#0]");
+       RETURN_IF_ERROR (result_append (dm, " [#0]"));
     }
 
   return STATUS_OK;
@@ -2763,7 +2958,7 @@ demangle_discriminator (dm, suppress_first)
 
 static status_t
 cp_demangle (name, result)
-     char *name;
+     const char *name;
      dyn_string_t result;
 {
   status_t status;
@@ -2772,14 +2967,22 @@ cp_demangle (name, result)
   if (length > 2 && name[0] == '_' && name[1] == 'Z')
     {
       demangling_t dm = demangling_new (name);
+      if (dm == NULL)
+       return STATUS_ALLOCATION_FAILED;
 
-      result_push (dm);
-      status = demangle_mangled_name (dm);
+      status = result_push (dm);
+      if (status != STATUS_OK)
+       {
+         demangling_delete (dm);
+         return status;
+       }
 
-      if (status == STATUS_OK)
+      status = demangle_mangled_name (dm);
+      if (STATUS_NO_ERROR (status))
        {
          dyn_string_t demangled = (dyn_string_t) result_pop (dm);
-         dyn_string_copy (result, demangled);
+         if (!dyn_string_copy (result, demangled))
+           return STATUS_ALLOCATION_FAILED;
          dyn_string_delete (demangled);
        }
       
@@ -2790,13 +2993,167 @@ cp_demangle (name, result)
       /* 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.  */
-      dyn_string_copy_cstr (result, name);
+      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);
+  
+  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;
 }
 
+
+#ifdef IN_LIBGCC2
+
+extern char *__cxa_demangle PARAMS ((const char *, char *, size_t *, int *));
+
+/* 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);
+  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 */
+
 /* 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
@@ -2811,17 +3168,20 @@ cplus_demangle_new_abi (mangled)
   dyn_string_t demangled = dyn_string_new (0);
   /* Attempt the demangling.  */
   status_t status = cp_demangle ((char *) mangled, demangled);
-  if (status == STATUS_OK)
+  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);
-      /* The dyn_string can go away.  */
-      dyn_string_delete (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.  */
     {
@@ -2830,6 +3190,8 @@ cplus_demangle_new_abi (mangled)
     }
 }
 
+#endif /* IN_LIBGCC2 */
+
 #ifdef STANDALONE_DEMANGLER
 
 #include "getopt.h"
@@ -2839,7 +3201,7 @@ static void print_usage
 
 /* Non-zero if CHAR is a character than can occur in a mangled name.  */
 #define is_mangled_char(CHAR)                                           \
-  (isalnum ((unsigned char) (CHAR)) || (CHAR) == '_')
+  (IS_ALPHA (CHAR) || IS_DIGIT (CHAR) || (CHAR) == '_')
 
 /* The name of this program, as invoked.  */
 const char* program_name;
@@ -2968,8 +3330,14 @@ main (argc, argv)
 
          /* If the demangling succeeded, great!  Print out the
             demangled version.  */
-         if (status == STATUS_OK)
+         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
@@ -3000,8 +3368,14 @@ main (argc, argv)
          status = cp_demangle (argv[i], result);
 
          /* If it worked, print the demangled name.  */
-         if (status == STATUS_OK)
+         if (STATUS_NO_ERROR (status))
            printf ("%s\n", dyn_string_buf (result));
+         /* Abort on allocaiton failures.  */
+         if (status == STATUS_ALLOCATION_FAILED)
+           {
+             fprintf (stderr, "Memory allocaiton failed.\n");
+             abort ():
+           }
          /* If not, print the error message to stderr instead.  */
          else 
            fprintf (stderr, "%s\n", status);
index f4a9d9a..69897f8 100644 (file)
@@ -36,14 +36,26 @@ Boston, MA 02111-1307, USA.  */
 #include "libiberty.h"
 #include "dyn-string.h"
 
+/* If this file is being compiled for inclusion in the C++ runtime
+   library, as part of the demangler implementation, we don't want to
+   abort if an allocation fails.  Instead, percolate an error code up
+   through the call chain.  */
+
+#ifdef IN_LIBGCC2
+#define RETURN_ON_ALLOCATION_FAILURE
+#endif
+
 /* Performs in-place initialization of a dyn_string struct.  This
    function can be used with a dyn_string struct on the stack or
    embedded in another object.  The contents of of the string itself
    are still dynamically allocated.  The string initially is capable
    of holding at least SPACE characeters, including the terminating
-   NUL.  If SPACE is 0, it will silently be increated to 1.  */
+   NUL.  If SPACE is 0, it will silently be increated to 1.  
 
-void
+   If RETURN_ON_ALLOCATION_FAILURE is defined and memory allocation
+   fails, returns 0.  Otherwise returns 1.  */
+
+int
 dyn_string_init (ds_struct_ptr, space)
      struct dyn_string *ds_struct_ptr;
      int space;
@@ -52,22 +64,44 @@ dyn_string_init (ds_struct_ptr, space)
   if (space == 0)
     space = 1;
 
-  ds_struct_ptr->allocated = space;
+#ifdef RETURN_ON_ALLOCATION_FAILURE
+  ds_struct_ptr->s = (char *) malloc (space);
+  if (ds_struct_ptr->s == NULL)
+    return 0;
+#else
   ds_struct_ptr->s = (char *) xmalloc (space);
+#endif
+  ds_struct_ptr->allocated = space;
   ds_struct_ptr->length = 0;
   ds_struct_ptr->s[0] = '\0';
-}    
 
-/* Create a new dynamic string capable of holding at least SPACE characters,
-   including the terminating NUL.  If SPACE is 0, it will be silently
-   increased to 1.  */
+  return 1;
+}
+
+/* Create a new dynamic string capable of holding at least SPACE
+   characters, including the terminating NUL.  If SPACE is 0, it will
+   be silently increased to 1.  If RETURN_ON_ALLOCATION_FAILURE is
+   defined and memory allocation fails, returns NULL.  Otherwise
+   returns the newly allocated string.  */
 
 dyn_string_t 
 dyn_string_new (space)
      int space;
 {
-  dyn_string_t result = (dyn_string_t) xmalloc (sizeof (struct dyn_string));
+  dyn_string_t result;
+#ifdef RETURN_ON_ALLOCATION_FAILURE
+  result = (dyn_string_t) malloc (sizeof (struct dyn_string));
+  if (result == NULL)
+    return NULL;
+  if (!dyn_string_init (result, space))
+    {
+      free (result);
+      return NULL;
+    }
+#else
+  result = (dyn_string_t) xmalloc (sizeof (struct dyn_string));
   dyn_string_init (result, space);
+#endif
   return result;
 }
 
@@ -83,7 +117,7 @@ dyn_string_delete (ds)
 
 /* Returns the contents of DS in a buffer allocated with malloc.  It
    is the caller's responsibility to deallocate the buffer using free.
-   DS is then set to the empty string.  */
+   DS is then set to the empty string.  Deletes DS itself.  */
 
 char*
 dyn_string_release (ds)
@@ -93,15 +127,18 @@ dyn_string_release (ds)
   char* result = ds->s;
   /* The buffer is no longer owned by DS.  */
   ds->s = NULL;
-  /* Reinitialize DS to the empty string.  */
-  dyn_string_init (ds, 0);
+  /* Delete DS.  */
+  free (ds);
   /* Return the old buffer.  */
   return result;
 }
 
 /* Increase the capacity of DS so it can hold at least SPACE
    characters, plus the terminating NUL.  This function will not (at
-   present) reduce the capacity of DS.  */
+   present) reduce the capacity of DS.  Returns DS on success. 
+
+   If RETURN_ON_ALLOCATION_FAILURE is defined and a memory allocation
+   operation fails, deletes DS and returns NULL.  */
 
 dyn_string_t 
 dyn_string_resize (ds, space)
@@ -113,14 +150,24 @@ dyn_string_resize (ds, space)
   /* Increase SPACE to hold the NUL termination.  */
   ++space;
 
+  /* Increase allocation by factors of two.  */
   while (space > new_allocated)
     new_allocated *= 2;
     
   if (new_allocated != ds->allocated)
     {
-      /* We actually need more space.  */
       ds->allocated = new_allocated;
+      /* We actually need more space.  */
+#ifdef RETURN_ON_ALLOCATION_FAILURE
+      ds->s = (char *) realloc (ds->s, ds->allocated);
+      if (ds->s == NULL)
+       {
+         free (ds);
+         return NULL;
+       }
+#else
       ds->s = (char *) xrealloc (ds->s, ds->allocated);
+#endif
     }
 
   return ds;
@@ -138,9 +185,10 @@ dyn_string_clear (ds)
 }
 
 /* Makes the contents of DEST the same as the contents of SRC.  DEST
-   and SRC must be distinct.  */
+   and SRC must be distinct.  Returns 1 on success.  On failure, if
+   RETURN_ON_ALLOCATION_FAILURE, deletes DEST and returns 0.  */
 
-void
+int
 dyn_string_copy (dest, src)
      dyn_string_t dest;
      dyn_string_t src;
@@ -149,55 +197,66 @@ dyn_string_copy (dest, src)
     abort ();
 
   /* Make room in DEST.  */
-  dyn_string_resize (dest, src->length);
+  if (dyn_string_resize (dest, src->length) == NULL)
+    return 0;
   /* Copy DEST into SRC.  */
   strcpy (dest->s, src->s);
   /* Update the size of DEST.  */
   dest->length = src->length;
+  return 1;
 }
 
-/* Copies SRC, a NUL-terminated string, into DEST.  */
+/* Copies SRC, a NUL-terminated string, into DEST.  Returns 1 on
+   success.  On failure, if RETURN_ON_ALLOCATION_FAILURE, deletes DEST
+   and returns 0.  */
 
-void
+int
 dyn_string_copy_cstr (dest, src)
      dyn_string_t dest;
      const char *src;
 {
   int length = strlen (src);
   /* Make room in DEST.  */
-  dyn_string_resize (dest, length);
+  if (dyn_string_resize (dest, length) == NULL)
+    return 0;
   /* Copy DEST into SRC.  */
   strcpy (dest->s, src);
   /* Update the size of DEST.  */
   dest->length = length;
+  return 1;
 }
 
 /* Inserts SRC at the beginning of DEST.  DEST is expanded as
-   necessary.  SRC and DEST must be distinct.  */
+   necessary.  SRC and DEST must be distinct.  Returns 1 on success.
+   On failure, if RETURN_ON_ALLOCATION_FAILURE, deletes DEST and
+   returns 0.  */
 
-void 
+int
 dyn_string_prepend (dest, src)
      dyn_string_t dest;
      dyn_string_t src;
 {
-  dyn_string_insert (dest, 0, src);
+  return dyn_string_insert (dest, 0, src);
 }
 
 /* Inserts SRC, a NUL-terminated string, at the beginning of DEST.
-   DEST is expanded as necessary.  */
+   DEST is expanded as necessary.  Returns 1 on success.  On failure,
+   if RETURN_ON_ALLOCATION_FAILURE, deletes DEST and returns 0. */
 
-void 
+int
 dyn_string_prepend_cstr (dest, src)
      dyn_string_t dest;
      const char *src;
 {
-  dyn_string_insert_cstr (dest, 0, src);
+  return dyn_string_insert_cstr (dest, 0, src);
 }
 
-/* Inserts SRC into DEST starting at position POS.  DEST is expanded as
-   necessary.  SRC and DEST must be distinct.  */
+/* Inserts SRC into DEST starting at position POS.  DEST is expanded
+   as necessary.  SRC and DEST must be distinct.  Returns 1 on
+   success.  On failure, if RETURN_ON_ALLOCATION_FAILURE, deletes DEST
+   and returns 0.  */
 
-void 
+int
 dyn_string_insert (dest, pos, src)
      dyn_string_t dest;
      int pos;
@@ -208,7 +267,8 @@ dyn_string_insert (dest, pos, src)
   if (src == dest)
     abort ();
 
-  dyn_string_resize (dest, dest->length + src->length);
+  if (dyn_string_resize (dest, dest->length + src->length) == NULL)
+    return 0;
   /* Make room for the insertion.  Be sure to copy the NUL.  */
   for (i = dest->length; i >= pos; --i)
     dest->s[i + src->length] = dest->s[i];
@@ -216,12 +276,15 @@ dyn_string_insert (dest, pos, src)
   strncpy (dest->s + pos, src->s, src->length);
   /* Compute the new length.  */
   dest->length += src->length;
+  return 1;
 }
 
 /* Inserts SRC, a NUL-terminated string, into DEST starting at
-   position POS.  DEST is expanded as necessary.  */
+   position POS.  DEST is expanded as necessary.  Returns 1 on
+   success.  On failure, RETURN_ON_ALLOCATION_FAILURE, deletes DEST
+   and returns 0.  */
 
-void 
+int
 dyn_string_insert_cstr (dest, pos, src)
      dyn_string_t dest;
      int pos;
@@ -230,7 +293,8 @@ dyn_string_insert_cstr (dest, pos, src)
   int i;
   int length = strlen (src);
 
-  dyn_string_resize (dest, dest->length + length);
+  if (dyn_string_resize (dest, dest->length + length) == NULL)
+    return 0;
   /* Make room for the insertion.  Be sure to copy the NUL.  */
   for (i = dest->length; i >= pos; --i)
     dest->s[i + length] = dest->s[i];
@@ -238,63 +302,72 @@ dyn_string_insert_cstr (dest, pos, src)
   strncpy (dest->s + pos, src, length);
   /* Compute the new length.  */
   dest->length += length;
+  return 1;
 }
 
-/* Append S to DS, resizing DS if necessary.  Returns DS.  */
+/* Append S to DS, resizing DS if necessary.  Returns 1 on success.
+   On failure, if RETURN_ON_ALLOCATION_FAILURE, deletes DEST and
+   returns 0.  */
 
-dyn_string_t
-dyn_string_append (ds, s)
-     dyn_string_t ds;
+int
+dyn_string_append (dest, s)
+     dyn_string_t dest;
      dyn_string_t s;
 {
-  dyn_string_resize (ds, ds->length + s->length);
-  strcpy (ds->s + ds->length, s->s);
-  ds->length += s->length;
-  return ds;
+  if (dyn_string_resize (dest, dest->length + s->length) == 0)
+    return 0;
+  strcpy (dest->s + dest->length, s->s);
+  dest->length += s->length;
+  return 1;
 }
 
 /* Append the NUL-terminated string S to DS, resizing DS if necessary.
-   Returns DS.  */
+   Returns 1 on success.  On failure, if RETURN_ON_ALLOCATION_FAILURE,
+   deletes DEST and returns 0.  */
 
-dyn_string_t 
-dyn_string_append_cstr (ds, s)
-     dyn_string_t ds;
+int
+dyn_string_append_cstr (dest, s)
+     dyn_string_t dest;
      const char *s;
 {
   int len = strlen (s);
 
   /* The new length is the old length plus the size of our string, plus
      one for the null at the end.  */
-  dyn_string_resize (ds, ds->length + len);
-  strcpy (ds->s + ds->length, s);
-  ds->length += len;
-
-  return ds;
+  if (dyn_string_resize (dest, dest->length + len) == NULL)
+    return 0;
+  strcpy (dest->s + dest->length, s);
+  dest->length += len;
+  return 1;
 }
 
-/* Appends C to the end of DS.  */
+/* Appends C to the end of DEST.  Returns 1 on success.  On failiure,
+   if RETURN_ON_ALLOCATION_FAILURE, deletes DEST and returns 0.  */
 
-dyn_string_t 
-dyn_string_append_char (ds, c)
-     dyn_string_t ds;
+int
+dyn_string_append_char (dest, c)
+     dyn_string_t dest;
      int c;
 {
   /* Make room for the extra character.  */
-  dyn_string_resize (ds, ds->length + 1);
+  if (dyn_string_resize (dest, dest->length + 1) == NULL)
+    return 0;
   /* Append the character; it will overwrite the old NUL.  */
-  ds->s[ds->length] = c;
+  dest->s[dest->length] = c;
   /* Add a new NUL at the end.  */
-  ds->s[ds->length + 1] = '\0';
+  dest->s[dest->length + 1] = '\0';
   /* Update the length.  */
-  ++(ds->length);
-  return ds;
+  ++(dest->length);
+  return 1;
 }
 
 /* Sets the contents of DEST to the substring of SRC starting at START
    and ending before END.  START must be less than or equal to END,
-   and both must be between zero and the length of SRC, inclusive.  */
+   and both must be between zero and the length of SRC, inclusive.
+   Returns 1 on success.  On failure, if RETURN_ON_ALLOCATION_FAILURE,
+   deletes DEST and returns 0.  */
 
-void
+int
 dyn_string_substring (dest, src, start, end)
      dyn_string_t dest;
      dyn_string_t src;
@@ -308,7 +381,8 @@ dyn_string_substring (dest, src, start, end)
     abort ();
 
   /* Make room for the substring.  */
-  dyn_string_resize (dest, length);
+  if (dyn_string_resize (dest, length) == NULL)
+    return 0;
   /* Copy the characters in the substring,  */
   for (i = length; --i >= 0; )
     dest->s[i] = src->s[start + i];
@@ -316,6 +390,8 @@ dyn_string_substring (dest, src, start, end)
   dest->s[length] = '\0';
   /* Record the length of the substring.  */
   dest->length = length;
+
+  return 1;
 }
 
 /* Returns non-zero if DS1 and DS2 have the same contents.  */