Changeset 609 for branches/GNU/src/binutils/libiberty/cp-demangle.c

Timestamp:

Aug 16, 2003, 6:59:22 PM (22 years ago)

Author:

bird

Message:

binutils v2.14 - offical sources.

File:

• branches/GNU/src/binutils/libiberty/cp-demangle.c (modified) (42 diffs, 1 prop)

branches/GNU/src/binutils/libiberty/cp-demangle.c

@@ -1 +1 @@
 /* Demangler for IA64 / g++ V3 ABI.
-   Copyright (C) 2000 Free Software Foundation, Inc.
+   Copyright (C) 2000, 2001, 2002 Free Software Foundation, Inc.
    Written by Alex Samuel <samuel@codesourcery.com>. 
 
@@ -9 +9 @@
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.
+
+   In addition to the permissions in the GNU General Public License, the
+   Free Software Foundation gives you unlimited permission to link the
+   compiled version of this file into combinations with other programs,
+   and to distribute those combinations without any restriction coming
+   from the use of this file.  (The General Public License restrictions
+   do apply in other respects; for example, they cover modification of
+   the file, and distribution when not linked into a combined
+   executable.)
 
    This program is distributed in the hope that it will be useful,
@@ -42 +51 @@
 #include <string.h>
 #endif
+
+#include <ctype.h>
 
 #include "ansidecl.h"
@@ -69 +80 @@
 #define ANONYMOUS_NAMESPACE_PREFIX "_GLOBAL_"
 
+/* Character(s) to use for namespace separation in demangled output */
+#define NAMESPACE_SEPARATOR (dm->style == DMGL_JAVA ? "." : "::")
+
 /* If flag_verbose is zero, some simplifications will be made to the
    output to make it easier to read and supress details that are
@@ -167 +181 @@
   /* The most recently demangled source-name.  */
   dyn_string_t last_source_name;
+  
+  /* Language style to use for demangled output. */
+  int style;
+
+  /* Set to non-zero iff this name is a constructor.  The actual value
+     indicates what sort of constructor this is; see demangle.h.  */
+  enum gnu_v3_ctor_kinds is_constructor;
+
+  /* Set to non-zero iff this name is a destructor.  The actual value
+     indicates what sort of destructor this is; see demangle.h.  */
+  enum gnu_v3_dtor_kinds is_destructor;
+
 };
 
@@ -241 +267 @@
   PARAMS ((demangling_t));
 static demangling_t demangling_new
-  PARAMS ((const char *));
+  PARAMS ((const char *, int));
 static void demangling_delete 
   PARAMS ((demangling_t));
@@ -410 +436 @@
     {
       string_list_t next = node->next;
-      free (node);
+      dyn_string_delete ((dyn_string_t) node);
       node = next;
     }
@@ -784 +810 @@
 
 static demangling_t
-demangling_new (name)
+demangling_new (name, style)
      const char *name;
+     int style;
 {
   demangling_t dm;
@@ -808 +835 @@
       return NULL;
     }
+  dm->style = style;
+  dm->is_constructor = (enum gnu_v3_ctor_kinds) 0;
+  dm->is_destructor = (enum gnu_v3_dtor_kinds) 0;
 
   return dm;
@@ -871 +901 @@
   PARAMS ((demangling_t, int, dyn_string_t));
 static status_t demangle_operator_name
-  PARAMS ((demangling_t, int, int *));
+  PARAMS ((demangling_t, int, int *, int *));
 static status_t demangle_nv_offset
   PARAMS ((demangling_t));
@@ -919 +949 @@
   PARAMS ((demangling_t, int));
 static status_t cp_demangle
-  PARAMS ((const char *, dyn_string_t));
-#ifdef IN_LIBGCC2
+  PARAMS ((const char *, dyn_string_t, int));
 static status_t cp_demangle_type
   PARAMS ((const char*, dyn_string_t));
-#endif
 
 /* When passed to demangle_bare_function_type, indicates that the
@@ -947 +975 @@
     {
       if (error_message == NULL)
-        error_message = strdup ("Expected ?");
+        error_message = (char *) strdup ("Expected ?");
       error_message[9] = c;
       return error_message;
@@ -1223 +1251 @@
           /* We have another level of scope qualification.  */
           if (nested)
-            RETURN_IF_ERROR (result_add (dm, "::"));
+            RETURN_IF_ERROR (result_add (dm, NAMESPACE_SEPARATOR));
           else
             nested = 1;
@@ -1300 +1328 @@
         *suppress_return_type = 1;
 
-      RETURN_IF_ERROR (demangle_operator_name (dm, 0, &num_args));
+      RETURN_IF_ERROR (demangle_operator_name (dm, 0, &num_args, NULL));
     }
   else if (peek == 'C' || peek == 'D')
@@ -1441 +1469 @@
   while (length-- > 0)
     {
+      int ch;
       if (end_of_name_p (dm))
         return "Unexpected end of name in <identifier>.";
-      if (!dyn_string_append_char (identifier, next_char (dm)))
+      ch = next_char (dm);
+
+      /* Handle extended Unicode characters.  We encode them as __U{hex}_,
+         where {hex} omits leading 0's.  For instance, '$' is encoded as
+         "__U24_".  */
+      if (ch == '_'
+          && peek_char (dm) == '_'
+          && peek_char_next (dm) == 'U')
+        {
+          char buf[10];
+          int pos = 0;
+          advance_char (dm); advance_char (dm); length -= 2;
+          while (length-- > 0)
+            {
+              ch = next_char (dm);
+              if (!isxdigit (ch))
+                break;
+              buf[pos++] = ch;
+            }
+          if (ch != '_' || length < 0)
+            return STATUS_ERROR;
+          if (pos == 0)
+            {
+              /* __U_ just means __U.  */
+              if (!dyn_string_append_cstr (identifier, "__U"))
+                return STATUS_ALLOCATION_FAILED;
+              continue;
+            }
+          else
+            {
+              buf[pos] = '\0';
+              ch = strtol (buf, 0, 16);
+            }
+        }
+
+      if (!dyn_string_append_char (identifier, ch))
         return STATUS_ALLOCATION_FAILED;
     }
@@ -1476 +1540 @@
    the short form is emitted; otherwise the full source form
    (`operator +' etc.) is emitted.  *NUM_ARGS is set to the number of
-   operands that the operator takes.  
+   operands that the operator takes.  If TYPE_ARG is non-NULL,
+   *TYPE_ARG is set to 1 if the first argument is a type and 0
+   otherwise.
 
     <operator-name>
@@ -1526 +1592 @@
                   ::= ix        # []            
                   ::= qu        # ?
-                  ::= sz        # sizeof 
+                  ::= st        # sizeof (a type)
+                  ::= sz        # sizeof (an expression)
                   ::= cv <type> # cast        
                   ::= v [0-9] <source-name>  # vendor extended operator  */
 
 static status_t
-demangle_operator_name (dm, short_name, num_args)
+demangle_operator_name (dm, short_name, num_args, type_arg)
      demangling_t dm;
      int short_name;
      int *num_args;
+     int *type_arg;
 {
   struct operator_code
   {
     /* The mangled code for this operator.  */
-    const char *code;
+    const char *const code;
     /* The source name of this operator.  */
-    const char *name;
+    const char *const name;
     /* The number of arguments this operator takes.  */
-    int num_args;
+    const int num_args;
   };
 
@@ -1608 +1676 @@
   DEMANGLE_TRACE ("operator-name", dm);
 
+  /* Assume the first argument is not a type.  */
+  if (type_arg)
+    *type_arg = 0;
+
   /* Is this a vendor-extended operator?  */
   if (c0 == 'v' && IS_DIGIT (c1))
@@ -1624 +1696 @@
       RETURN_IF_ERROR (demangle_type (dm));
       *num_args = 0;
+      return STATUS_OK;
+    }
+
+  /* Is it the sizeof variant that takes a type?  */
+  if (c0 == 's' && c1 == 't')
+    {
+      RETURN_IF_ERROR (result_add (dm, " sizeof"));
+      *num_args = 1;
+      if (type_arg)
+        *type_arg = 1;
       return STATUS_OK;
     }
@@ -1824 +1906 @@
   if (peek == 'G')
     {
-      /* A guard variable name.  Consume the G.  */
+      /* Consume the G.  */
       advance_char (dm);
-      RETURN_IF_ERROR (demangle_char (dm, 'V'));
-      RETURN_IF_ERROR (result_add (dm, "guard variable for "));
-      RETURN_IF_ERROR (demangle_name (dm, &unused));
+      switch (peek_char (dm))
+        {
+        case 'V':
+          /* A guard variable name.  */
+          advance_char (dm);
+          RETURN_IF_ERROR (result_add (dm, "guard variable for "));
+          RETURN_IF_ERROR (demangle_name (dm, &unused));
+          break;
+
+        case 'R':
+          /* A reference temporary.  */
+          advance_char (dm);
+          RETURN_IF_ERROR (result_add (dm, "reference temporary for "));
+          RETURN_IF_ERROR (demangle_name (dm, &unused));
+          break;
+          
+        default:
+          return "Unrecognized <special-name>.";
+        }
     }
   else if (peek == 'T')
@@ -2011 +2109 @@
       /* A constructor name.  Consume the C.  */
       advance_char (dm);
-      if (peek_char (dm) < '1' || peek_char (dm) > '3')
+      flavor = next_char (dm);
+      if (flavor < '1' || flavor > '3')
         return "Unrecognized constructor.";
       RETURN_IF_ERROR (result_add_string (dm, dm->last_source_name));
+      switch (flavor)
+        {
+        case '1': dm->is_constructor = gnu_v3_complete_object_ctor;
+          break;
+        case '2': dm->is_constructor = gnu_v3_base_object_ctor;
+          break;
+        case '3': dm->is_constructor = gnu_v3_complete_object_allocating_ctor;
+          break;
+        }
       /* Print the flavor of the constructor if in verbose mode.  */
-      flavor = next_char (dm) - '1';
       if (flag_verbose)
         {
           RETURN_IF_ERROR (result_add (dm, "["));
-          RETURN_IF_ERROR (result_add (dm, ctor_flavors[flavor]));
+          RETURN_IF_ERROR (result_add (dm, ctor_flavors[flavor - '1']));
           RETURN_IF_ERROR (result_add_char (dm, ']'));
         }
@@ -2027 +2134 @@
       /* A destructor name.  Consume the D.  */
       advance_char (dm);
-      if (peek_char (dm) < '0' || peek_char (dm) > '2')
+      flavor = next_char (dm);
+      if (flavor < '0' || flavor > '2')
         return "Unrecognized destructor.";
       RETURN_IF_ERROR (result_add_char (dm, '~'));
       RETURN_IF_ERROR (result_add_string (dm, dm->last_source_name));
+      switch (flavor)
+        {
+        case '0': dm->is_destructor = gnu_v3_deleting_dtor;
+          break;
+        case '1': dm->is_destructor = gnu_v3_complete_object_dtor;
+          break;
+        case '2': dm->is_destructor = gnu_v3_base_object_dtor;
+          break;
+        }
       /* Print the flavor of the destructor if in verbose mode.  */
-      flavor = next_char (dm) - '0';
       if (flag_verbose)
         {
           RETURN_IF_ERROR (result_add (dm, " ["));
-          RETURN_IF_ERROR (result_add (dm, dtor_flavors[flavor]));
+          RETURN_IF_ERROR (result_add (dm, dtor_flavors[flavor - '0']));
           RETURN_IF_ERROR (result_add_char (dm, ']'));
         }
@@ -2094 +2210 @@
                                           substitution_start));
       /* Insert an asterisk where we're told to; it doesn't
-         necessarily go at the end.  */
-      RETURN_IF_ERROR (result_insert_char (dm, *insert_pos, '*'));
+         necessarily go at the end.  If we're doing Java style output, 
+         there is no pointer symbol.  */
+      if (dm->style != DMGL_JAVA)
+        RETURN_IF_ERROR (result_insert_char (dm, *insert_pos, '*'));
       /* The next (outermost) pointer or reference character should go
          after this one.  */
@@ -2470 +2588 @@
 };
 
+/* Java source names of builtin types.  Types that arn't valid in Java
+   are also included here - we don't fail if someone attempts to demangle a 
+   C++ symbol in Java style. */
+static const char *const java_builtin_type_names[26] = 
+{
+  "signed char",                /* a */
+  "boolean", /* C++ "bool" */   /* b */
+  "byte", /* C++ "char" */      /* c */
+  "double",                     /* d */
+  "long double",                /* e */
+  "float",                      /* f */
+  "__float128",                 /* g */
+  "unsigned char",              /* h */
+  "int",                        /* i */
+  "unsigned",                   /* j */
+  NULL,                         /* k */
+  "long",                       /* l */
+  "unsigned long",              /* m */
+  "__int128",                   /* n */
+  "unsigned __int128",          /* o */
+  NULL,                         /* p */
+  NULL,                         /* q */
+  NULL,                         /* r */
+  "short",                      /* s */
+  "unsigned short",             /* t */
+  NULL,                         /* u */
+  "void",                       /* v */
+  "char", /* C++ "wchar_t" */   /* w */
+  "long", /* C++ "long long" */ /* x */
+  "unsigned long long",         /* y */
+  "..."                         /* z */
+};
+
 /* Demangles and emits a <builtin-type>.  
 
@@ -2512 +2663 @@
   else if (code >= 'a' && code <= 'z')
     {
-      const char *type_name = builtin_type_names[code - 'a'];
+      const char *type_name;
+      /* Java uses different names for some built-in types. */
+      if (dm->style == DMGL_JAVA)
+        type_name = java_builtin_type_names[code - 'a'];
+      else
+        type_name = builtin_type_names[code - 'a'];
       if (type_name == NULL)
         return "Unrecognized <builtin-type> code.";
@@ -3055 +3211 @@
     {
       int num_args;
+      int type_arg;
       status_t status = STATUS_OK;
       dyn_string_t operator_name;
@@ -3062 +3219 @@
          first.  */
       RETURN_IF_ERROR (result_push (dm));
-      RETURN_IF_ERROR (demangle_operator_name (dm, 1, &num_args));
+      RETURN_IF_ERROR (demangle_operator_name (dm, 1, &num_args,
+                                               &type_arg));
       operator_name = (dyn_string_t) result_pop (dm);
 
@@ -3083 +3241 @@
       /* Emit its second (if binary) or only (if unary) operand.  */
       RETURN_IF_ERROR (result_add_char (dm, '('));
-      RETURN_IF_ERROR (demangle_expression (dm));
+      if (type_arg)
+        RETURN_IF_ERROR (demangle_type (dm));
+      else
+        RETURN_IF_ERROR (demangle_expression (dm));
       RETURN_IF_ERROR (result_add_char (dm, ')'));
 
@@ -3370 +3531 @@
                less than the discriminator ordinal, counting from
                zero.  */
-            RETURN_IF_ERROR (int_to_dyn_string (discriminator + 2, 
+            RETURN_IF_ERROR (int_to_dyn_string (discriminator + 1,
                                                 (dyn_string_t) dm->result));
         }
       else
-        {
-          if (flag_verbose)
-            /* A missing digit correspond to one.  */
-            RETURN_IF_ERROR (result_add_char (dm, '1'));
-        }
+        return STATUS_ERROR;
       if (flag_verbose)
         RETURN_IF_ERROR (result_add_char (dm, ']'));
@@ -3396 +3553 @@
 
 static status_t
-cp_demangle (name, result)
+cp_demangle (name, result, style)
      const char *name;
      dyn_string_t result;
+     int style;
 {
   status_t status;
@@ -3405 +3563 @@
   if (length > 2 && name[0] == '_' && name[1] == 'Z')
     {
-      demangling_t dm = demangling_new (name);
+      demangling_t dm = demangling_new (name, style);
       if (dm == NULL)
         return STATUS_ALLOCATION_FAILED;
@@ -3444 +3602 @@
    an error message, and the contents of RESULT are unchanged.  */
 
-#ifdef IN_LIBGCC2
 static status_t
 cp_demangle_type (type_name, result)
@@ -3451 +3608 @@
 {
   status_t status;
-  demangling_t dm = demangling_new (type_name);
+  demangling_t dm = demangling_new (type_name, DMGL_GNU_V3);
   
   if (dm == NULL)
@@ -3482 +3639 @@
 }
 
+#if defined(IN_LIBGCC2) || defined(IN_GLIBCPP_V3)
 extern char *__cxa_demangle PARAMS ((const char *, char *, size_t *, int *));
 
@@ -3552 +3710 @@
     /* MANGLED_NAME apprears to be a function or variable name.
        Demangle it accordingly.  */
-    result = cp_demangle (mangled_name, &demangled_name);
+    result = cp_demangle (mangled_name, &demangled_name, 0);
   else
     /* Try to demangled MANGLED_NAME as the name of a type.  */
@@ -3589 +3747 @@
 }
 
-#else /* !IN_LIBGCC2 */
+#else /* ! (IN_LIBGCC2 || IN_GLIBCPP_V3) */
 
 /* Variant entry point for integration with the existing cplus-dem
@@ -3598 +3756 @@
 
 char *
-cplus_demangle_v3 (mangled)
+cplus_demangle_v3 (mangled, options)
      const char* mangled;
+     int options;
 {
   dyn_string_t demangled;
   status_t status;
-
-  /* If this isn't a mangled name, don't pretend to demangle it.  */
-  if (strncmp (mangled, "_Z", 2) != 0)
-    return NULL;
+  int type = !!(options & DMGL_TYPES);
+
+  if (mangled[0] == '_' && mangled[1] == 'Z')
+    /* It is not a type.  */
+    type = 0;
+  else
+    {
+      /* It is a type. Stop if we don't want to demangle types. */
+      if (!type)
+        return NULL;
+    }
+
+  flag_verbose = !!(options & DMGL_VERBOSE);
 
   /* Create a dyn_string to hold the demangled name.  */
   demangled = dyn_string_new (0);
   /* Attempt the demangling.  */
-  status = cp_demangle ((char *) mangled, demangled);
+  if (!type)
+    /* Appears to be a function or variable name.  */
+    status = cp_demangle (mangled, demangled, 0);
+  else
+    /* Try to demangle it as the name of a type.  */
+    status = cp_demangle_type (mangled, demangled);
 
   if (STATUS_NO_ERROR (status))
@@ -3635 +3808 @@
 }
 
-#endif /* IN_LIBGCC2 */
+/* Demangle a Java symbol.  Java uses a subset of the V3 ABI C++ mangling 
+   conventions, but the output formatting is a little different.
+   This instructs the C++ demangler not to emit pointer characters ("*"), and 
+   to use Java's namespace separator symbol ("." instead of "::").  It then 
+   does an additional pass over the demangled output to replace instances 
+   of JArray<TYPE> with TYPE[].  */
+
+char *
+java_demangle_v3 (mangled)
+     const char* mangled;
+{
+  dyn_string_t demangled;
+  char *next;
+  char *end;
+  int len;
+  status_t status;
+  int nesting = 0;
+  char *cplus_demangled;
+  char *return_value;
+    
+  /* Create a dyn_string to hold the demangled name.  */
+  demangled = dyn_string_new (0);
+
+  /* Attempt the demangling.  */
+  status = cp_demangle ((char *) mangled, demangled, DMGL_JAVA);
+
+  if (STATUS_NO_ERROR (status))
+    /* Demangling succeeded.  */
+    {
+      /* Grab the demangled result from the dyn_string. */
+      cplus_demangled = dyn_string_release (demangled);
+    }
+  else if (status == STATUS_ALLOCATION_FAILED)
+    {
+      fprintf (stderr, "Memory allocation failed.\n");
+      abort ();
+    }
+  else
+    /* Demangling failed.  */
+    {
+      dyn_string_delete (demangled);
+      return NULL;
+    }
+  
+  len = strlen (cplus_demangled);
+  next = cplus_demangled;
+  end = next + len;
+  demangled = NULL;
+
+  /* Replace occurances of JArray<TYPE> with TYPE[]. */
+  while (next < end)
+    {
+      char *open_str = strstr (next, "JArray<");
+      char *close_str = NULL;
+      if (nesting > 0)
+        close_str = strchr (next, '>');
+    
+      if (open_str != NULL && (close_str == NULL || close_str > open_str))
+        {
+          ++nesting;
+          
+          if (!demangled)
+            demangled = dyn_string_new(len);
+
+          /* Copy prepending symbols, if any. */
+          if (open_str > next)
+            {
+              open_str[0] = 0;
+              dyn_string_append_cstr (demangled, next);
+            }     
+          next = open_str + 7;
+        }
+      else if (close_str != NULL)
+        {
+          --nesting;
+          
+          /* Copy prepending type symbol, if any. Squash any spurious 
+             whitespace. */
+          if (close_str > next && next[0] != ' ')
+            {
+              close_str[0] = 0;
+              dyn_string_append_cstr (demangled, next);
+            }
+          dyn_string_append_cstr (demangled, "[]");       
+          next = close_str + 1;
+        }
+      else
+        {
+          /* There are no more arrays. Copy the rest of the symbol, or
+             simply return the original symbol if no changes were made. */
+          if (next == cplus_demangled)
+            return cplus_demangled;
+
+          dyn_string_append_cstr (demangled, next);
+          next = end;
+        }
+    }
+
+  free (cplus_demangled);
+  
+  if (demangled)
+    return_value = dyn_string_release (demangled);
+  else
+    return_value = NULL;
+
+  return return_value;
+}
+
+#endif /* IN_LIBGCC2 || IN_GLIBCPP_V3 */
+
+
+#ifndef IN_GLIBCPP_V3
+/* Demangle NAME in the G++ V3 ABI demangling style, and return either
+   zero, indicating that some error occurred, or a demangling_t
+   holding the results.  */
+static demangling_t
+demangle_v3_with_details (name)
+     const char *name;
+{
+  demangling_t dm;
+  status_t status;
+
+  if (strncmp (name, "_Z", 2))
+    return 0;
+
+  dm = demangling_new (name, DMGL_GNU_V3);
+  if (dm == NULL)
+    {
+      fprintf (stderr, "Memory allocation failed.\n");
+      abort ();
+    }
+
+  status = result_push (dm);
+  if (! STATUS_NO_ERROR (status))
+    {
+      demangling_delete (dm);
+      fprintf (stderr, "%s\n", status);
+      abort ();
+    }
+
+  status = demangle_mangled_name (dm);
+  if (STATUS_NO_ERROR (status))
+    return dm;
+
+  demangling_delete (dm);
+  return 0;
+}
+
+
+/* Return non-zero iff NAME is the mangled form of a constructor name
+   in the G++ V3 ABI demangling style.  Specifically, return:
+   - '1' if NAME is a complete object constructor,
+   - '2' if NAME is a base object constructor, or
+   - '3' if NAME is a complete object allocating constructor.  */
+enum gnu_v3_ctor_kinds
+is_gnu_v3_mangled_ctor (name)
+     const char *name;
+{
+  demangling_t dm = demangle_v3_with_details (name);
+
+  if (dm)
+    {
+      enum gnu_v3_ctor_kinds result = dm->is_constructor;
+      demangling_delete (dm);
+      return result;
+    }
+  else
+    return (enum gnu_v3_ctor_kinds) 0;
+}
+
+
+/* Return non-zero iff NAME is the mangled form of a destructor name
+   in the G++ V3 ABI demangling style.  Specifically, return:
+   - '0' if NAME is a deleting destructor,
+   - '1' if NAME is a complete object destructor, or
+   - '2' if NAME is a base object destructor.  */
+enum gnu_v3_dtor_kinds
+is_gnu_v3_mangled_dtor (name)
+     const char *name;
+{
+  demangling_t dm = demangle_v3_with_details (name);
+
+  if (dm)
+    {
+      enum gnu_v3_dtor_kinds result = dm->is_destructor;
+      demangling_delete (dm);
+      return result;
+    }
+  else
+    return (enum gnu_v3_dtor_kinds) 0;
+}
+#endif /* IN_GLIBCPP_V3 */
+
 
 #ifdef STANDALONE_DEMANGLER
@@ -3670 +4035 @@
 
 /* Option specification for getopt_long.  */
-static struct option long_options[] = 
+static const struct option long_options[] = 
 {
   { "help",    no_argument, NULL, 'h' },
@@ -3772 +4137 @@
 
           /* Attempt to demangle the name.  */
-          status = cp_demangle (dyn_string_buf (mangled), demangled);
+          status = cp_demangle (dyn_string_buf (mangled), demangled, 0);
 
           /* If the demangling succeeded, great!  Print out the
@@ -3811 +4176 @@
         {
           /* Attempt to demangle.  */
-          status = cp_demangle (argv[i], result);
+          status = cp_demangle (argv[i], result, 0);
 
           /* If it worked, print the demangled name.  */
@@ -3819 +4184 @@
           else if (status == STATUS_ALLOCATION_FAILED)
             {
-              fprintf (stderr, "Memory allocaiton failed.\n");
+              fprintf (stderr, "Memory allocation failed.\n");
               abort ();
             }