merge with gcc

1 files changed, 668 insertions, 276 deletions

diff --git a/libiberty/cp-demangle.c b/libiberty/cp-demangle.c
index b1c4055..de70b89 100644
--- a/libiberty/cp-demangle.c
+++ b/libiberty/cp-demangle.c
@@ -27,8 +27,6 @@
 #include "config.h"
 #endif
 
-#include <ctype.h>
-
 #ifdef HAVE_STDLIB_H
 #include <stdlib.h>
 #endif
@@ -47,13 +45,20 @@
 /* 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)
 
-static void int_to_dyn_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 (!STATUS_NO_ERROR (s))                                         \
+	return s;                                                       \
+    }                                                                   \
+  while (0)
+
+static status_t int_to_dyn_string 
   PARAMS ((int, dyn_string_t));
 static string_list_t string_list_new
   PARAMS ((int));
 static void string_list_delete
   PARAMS ((string_list_t));
-static 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.  */
@@ -824,16 +902,14 @@ demangle_mangled_name (dm)
 
     <encoding>		::= <function name> <bare-function-type>
 			::= <data name>
-			::= <substitution>  */
+			::= <special-name>  */
 
 static status_t
 demangle_encoding (dm)
      demangling_t dm;
 {
   int template_p;
-  int special_std_substitution;
   int start_position;
-  int start = substitution_start (dm);
   template_arg_list_t old_arg_list = current_template_arg_list (dm);
   char peek = peek_char (dm);
 
@@ -843,18 +919,7 @@ demangle_encoding (dm)
      function, we'll have to insert the return type here.  */
   start_position = result_length (dm);
 
-  if (peek == 'S')
-    {
-      RETURN_IF_ERROR (demangle_substitution (dm, &template_p,
-					      &special_std_substitution));
-      if (special_std_substitution)
-	{
-	  /* This was the magic `std::' substitution.  */
-	  result_append (dm, "::");
-	  RETURN_IF_ERROR (demangle_encoding (dm));
-	}
-    }
-  else if (peek == 'G' || peek == 'T')
+  if (peek == 'G' || peek == 'T')
     RETURN_IF_ERROR (demangle_special_name (dm));
   else
     {
@@ -877,8 +942,6 @@ demangle_encoding (dm)
 	    RETURN_IF_ERROR 
 	      (demangle_bare_function_type (dm, BFT_NO_RETURN_TYPE)); 
 	}
-
-      substitution_add (dm, start, template_p, NOT_TEMPLATE_PARM);
     }
 
   /* Pop off template argument lists that were built during the
@@ -925,13 +988,12 @@ demangle_name (dm, template_p)
 
     case 'S':
       /* The `St' substitution allows a name nested in std:: to appear
-	 without being enclosed in a nested name.
-	   <name> ::= St <unqualified-name>     # ::std::  */
+	 without being enclosed in a nested name.  */
       if (peek_char_next (dm) == 't') 
 	{
 	  (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,10 +1005,18 @@ 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));
 	    }
 	}
+      /* Check if a template argument list immediately follows.
+	 If so, then we just demangled an <unqualified-template-name>.  */
+      if (peek_char (dm) == 'I') 
+	{
+	  RETURN_IF_ERROR (substitution_add (dm, start, 0, 
+					     NOT_TEMPLATE_PARM));
+	  RETURN_IF_ERROR (demangle_template_args (dm));
+	}
       break;
 
     default:
@@ -958,7 +1028,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 +1061,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 +1120,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 +1149,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 +1160,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 +1182,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 +1220,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 +1246,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 +1282,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 +1317,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 +1468,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 +1477,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 +1495,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 +1549,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 +1564,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;
 
@@ -1571,24 +1673,47 @@ demangle_special_name (dm)
 	  /* TC is a special g++ mangling for a construction vtable. */
 	  if (!flag_strict)
 	    {
+	      dyn_string_t derived_type;
+
 	      advance_char (dm);
-	      result_append (dm, "construction vtable for ");
+	      RETURN_IF_ERROR (result_append (dm, "construction vtable for "));
+
+	      /* Demangle the derived type off to the side.  */
+	      RETURN_IF_ERROR (result_push (dm));
 	      RETURN_IF_ERROR (demangle_type (dm));
+	      derived_type = (dyn_string_t) result_pop (dm);
+
 	      /* Demangle the offset.  */
 	      number = dyn_string_new (4);
+	      if (number == NULL)
+		{
+		  dyn_string_delete (derived_type);
+		  return STATUS_ALLOCATION_FAILED;
+		}
 	      demangle_number_literally (dm, number, 10, 1);
 	      /* Demangle the underscore separator.  */
-	      RETURN_IF_ERROR (demangle_char (dm, '_'));
+	      status = demangle_char (dm, '_');
+
 	      /* Demangle the base type.  */
-	      result_append (dm, "-in-");
-	      RETURN_IF_ERROR (demangle_type (dm));
+	      if (STATUS_NO_ERROR (status))
+		status = demangle_type (dm);
+
+	      /* Emit the derived type.  */
+	      if (STATUS_NO_ERROR (status))
+		status = result_append (dm, "-in-");
+	      if (STATUS_NO_ERROR (status))
+		status = result_append_string (dm, derived_type);
+	      dyn_string_delete (derived_type);
+
 	      /* 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 +1768,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 +1784,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 +1826,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 +1836,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 +1855,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 +1873,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 +1889,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 +1905,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;
@@ -1799,6 +1938,7 @@ demangle_type (dm)
 {
   int start = substitution_start (dm);
   char peek = peek_char (dm);
+  char peek_next;
   int template_p = 0;
   int special_std_substitution;
   int is_builtin_type = 0;
@@ -1809,7 +1949,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 +1965,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 +1976,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);
@@ -1860,15 +2008,16 @@ demangle_type (dm)
 	break;
 
       case 'S':
-	RETURN_IF_ERROR (demangle_substitution (dm, &template_p,
-						&special_std_substitution));
-	if (special_std_substitution)
-	  {
-	    /* This was the magic `std::' substitution.  What follows
-	       must be a class name in that namespace.  */
-	    result_append (dm, "::");
-	    RETURN_IF_ERROR (demangle_class_enum_type (dm, &template_p));
-	  }
+	/* First check if this is a special substitution.  If it is,
+	   this is a <class-enum-type>.  Special substitutions have a
+	   letter following the `S'; other substitutions have a digit
+	   or underscore.  */
+	peek_next = peek_char_next (dm);
+	if (IS_DIGIT (peek_next) || peek_next == '_')
+	  RETURN_IF_ERROR (demangle_substitution (dm, &template_p,
+						  &special_std_substitution));
+	else
+	  demangle_class_enum_type (dm, &template_p);
 	break;
 
       case 'P':
@@ -1879,14 +2028,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 +2044,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 +2058,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 +2145,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 +2169,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 +2214,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 +2241,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 +2278,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 +2314,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 +2383,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 +2401,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 +2425,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 +2470,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 +2509,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 +2524,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 +2626,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 +2681,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,85 +2768,102 @@ 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";
+	  *template_p = 1;
 	  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";
+	  *template_p = 1;
 	  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";
 	    }
+	  *template_p = 0;
 	  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";
 	    }
+	  *template_p = 0;
 	  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";
 	    }
+	  *template_p = 0;
 	  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";
 	    }
+	  *template_p = 0;
 	  break;
 
 	default:
 	  return "Unrecognized <substitution>.";
 	}
       
+      /* Consume the character we just processed.  */
       advance_char (dm);
+
+      if (new_last_source_name != NULL)
+	{
+	  if (!dyn_string_copy_cstr (dm->last_source_name, 
+				     new_last_source_name))
+	    return STATUS_ALLOCATION_FAILED;
+	}
+
       return STATUS_OK;
     }
 
@@ -2658,11 +2871,11 @@ demangle_substitution (dm, template_p, special_std_substitution)
      substitution, `S0_' is the second-most-recent, etc., shift the
      numbering by one.  */
   text = substitution_get (dm, seq_id + 1, template_p);
-  if (text == NULL)
+  if (text == NULL) 
     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 +2895,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 +2908,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 +2938,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 +2949,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 +2976,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 +2985,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 +3011,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 +3186,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 +3208,8 @@ cplus_demangle_new_abi (mangled)
     }
 }
 
+#endif /* IN_LIBGCC2 */
+
 #ifdef STANDALONE_DEMANGLER
 
 #include "getopt.h"
@@ -2839,7 +3219,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 +3348,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 +3386,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.  */
+	  else 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);