X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=libiberty%2Fcplus-dem.c;h=1f8b1fc31e4b8fd5618059c17948c87c7a47c6c8;hb=9c577e8950071038688208bdf50283836d251c28;hp=5e2e7a7126c1321190b959164ebf8f07cf3b3d50;hpb=eec65ede89d0e086c43206a66614598101f270b4;p=deliverable%2Fbinutils-gdb.git

diff --git a/libiberty/cplus-dem.c b/libiberty/cplus-dem.c
index 5e2e7a7126..1f8b1fc31e 100644
--- a/libiberty/cplus-dem.c
+++ b/libiberty/cplus-dem.c
@@ -1,6 +1,6 @@
 /* Demangler for GNU C++
    Copyright 1989, 1991, 1994, 1995, 1996, 1997, 1998, 1999,
-   2000, 2001 Free Software Foundation, Inc.
+   2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
    Written by James Clark (jjc@jclark.uucp)
    Rewritten by Fred Fish (fnf@cygnus.com) for ARM and Lucid demangling
    Modified by Satish Pai (pai@apollo.hp.com) for HP demangling
@@ -27,8 +27,8 @@ Library General Public License for more details.
 
 You should have received a copy of the GNU Library General Public
 License along with libiberty; see the file COPYING.LIB.  If
-not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
-Boston, MA 02111-1307, USA.  */
+not, write to the Free Software Foundation, Inc., 51 Franklin Street - Fifth Floor,
+Boston, MA 02110-1301, USA.  */
 
 /* This file exports two functions; cplus_mangle_opname and cplus_demangle.
 
@@ -62,7 +62,7 @@ char * realloc ();
 
 #include "libiberty.h"
 
-static char *ada_demangle  PARAMS ((const char *, int));
+static char *ada_demangle (const char *, int);
 
 #define min(X,Y) (((X) < (Y)) ? (X) : (Y))
 
@@ -70,7 +70,7 @@ static char *ada_demangle  PARAMS ((const char *, int));
    that will be output when using the `%d' format with `printf'.  */
 #define INTBUF_SIZE 32
 
-extern void fancy_abort PARAMS ((void)) ATTRIBUTE_NORETURN;
+extern void fancy_abort (void) ATTRIBUTE_NORETURN;
 
 /* In order to allow a single demangler executable to demangle strings
    using various common values of CPLUS_MARKER, as well as any specific
@@ -99,8 +99,7 @@ static char cplus_markers[] = { CPLUS_MARKER, '.', '$', '\0' };
 static char char_str[2] = { '\000', '\000' };
 
 void
-set_cplus_marker_for_demangling (ch)
-     int ch;
+set_cplus_marker_for_demangling (int ch)
 {
   cplus_markers[0] = ch;
 }
@@ -327,163 +326,127 @@ const struct demangler_engine libiberty_demanglers[] =
 
 /* Prototypes for local functions */
 
-static void
-delete_work_stuff PARAMS ((struct work_stuff *));
+static void delete_work_stuff (struct work_stuff *);
 
-static void
-delete_non_B_K_work_stuff PARAMS ((struct work_stuff *));
+static void delete_non_B_K_work_stuff (struct work_stuff *);
 
-static char *
-mop_up PARAMS ((struct work_stuff *, string *, int));
+static char *mop_up (struct work_stuff *, string *, int);
 
-static void
-squangle_mop_up PARAMS ((struct work_stuff *));
+static void squangle_mop_up (struct work_stuff *);
 
-static void
-work_stuff_copy_to_from PARAMS ((struct work_stuff *, struct work_stuff *));
+static void work_stuff_copy_to_from (struct work_stuff *, struct work_stuff *);
 
 #if 0
 static int
-demangle_method_args PARAMS ((struct work_stuff *, const char **, string *));
+demangle_method_args (struct work_stuff *, const char **, string *);
 #endif
 
 static char *
-internal_cplus_demangle PARAMS ((struct work_stuff *, const char *));
+internal_cplus_demangle (struct work_stuff *, const char *);
 
 static int
-demangle_template_template_parm PARAMS ((struct work_stuff *work,
-					 const char **, string *));
+demangle_template_template_parm (struct work_stuff *work,
+                                 const char **, string *);
 
 static int
-demangle_template PARAMS ((struct work_stuff *work, const char **, string *,
-			   string *, int, int));
+demangle_template (struct work_stuff *work, const char **, string *,
+                   string *, int, int);
 
 static int
-arm_pt PARAMS ((struct work_stuff *, const char *, int, const char **,
-		const char **));
+arm_pt (struct work_stuff *, const char *, int, const char **,
+        const char **);
 
 static int
-demangle_class_name PARAMS ((struct work_stuff *, const char **, string *));
+demangle_class_name (struct work_stuff *, const char **, string *);
 
 static int
-demangle_qualified PARAMS ((struct work_stuff *, const char **, string *,
-			    int, int));
+demangle_qualified (struct work_stuff *, const char **, string *,
+                    int, int);
 
-static int
-demangle_class PARAMS ((struct work_stuff *, const char **, string *));
+static int demangle_class (struct work_stuff *, const char **, string *);
 
-static int
-demangle_fund_type PARAMS ((struct work_stuff *, const char **, string *));
+static int demangle_fund_type (struct work_stuff *, const char **, string *);
 
-static int
-demangle_signature PARAMS ((struct work_stuff *, const char **, string *));
+static int demangle_signature (struct work_stuff *, const char **, string *);
 
-static int
-demangle_prefix PARAMS ((struct work_stuff *, const char **, string *));
+static int demangle_prefix (struct work_stuff *, const char **, string *);
 
-static int
-gnu_special PARAMS ((struct work_stuff *, const char **, string *));
+static int gnu_special (struct work_stuff *, const char **, string *);
 
-static int
-arm_special PARAMS ((const char **, string *));
+static int arm_special (const char **, string *);
 
-static void
-string_need PARAMS ((string *, int));
+static void string_need (string *, int);
 
-static void
-string_delete PARAMS ((string *));
+static void string_delete (string *);
 
 static void
-string_init PARAMS ((string *));
+string_init (string *);
 
-static void
-string_clear PARAMS ((string *));
+static void string_clear (string *);
 
 #if 0
-static int
-string_empty PARAMS ((string *));
+static int string_empty (string *);
 #endif
 
-static void
-string_append PARAMS ((string *, const char *));
+static void string_append (string *, const char *);
 
-static void
-string_appends PARAMS ((string *, string *));
+static void string_appends (string *, string *);
 
-static void
-string_appendn PARAMS ((string *, const char *, int));
+static void string_appendn (string *, const char *, int);
 
-static void
-string_prepend PARAMS ((string *, const char *));
+static void string_prepend (string *, const char *);
 
-static void
-string_prependn PARAMS ((string *, const char *, int));
+static void string_prependn (string *, const char *, int);
 
-static void
-string_append_template_idx PARAMS ((string *, int));
+static void string_append_template_idx (string *, int);
 
-static int
-get_count PARAMS ((const char **, int *));
+static int get_count (const char **, int *);
 
-static int
-consume_count PARAMS ((const char **));
+static int consume_count (const char **);
 
-static int
-consume_count_with_underscores PARAMS ((const char**));
+static int consume_count_with_underscores (const char**);
 
-static int
-demangle_args PARAMS ((struct work_stuff *, const char **, string *));
+static int demangle_args (struct work_stuff *, const char **, string *);
 
-static int
-demangle_nested_args PARAMS ((struct work_stuff*, const char**, string*));
+static int demangle_nested_args (struct work_stuff*, const char**, string*);
 
-static int
-do_type PARAMS ((struct work_stuff *, const char **, string *));
+static int do_type (struct work_stuff *, const char **, string *);
 
-static int
-do_arg PARAMS ((struct work_stuff *, const char **, string *));
+static int do_arg (struct work_stuff *, const char **, string *);
 
 static void
-demangle_function_name PARAMS ((struct work_stuff *, const char **, string *,
-				const char *));
+demangle_function_name (struct work_stuff *, const char **, string *,
+                        const char *);
 
 static int
-iterate_demangle_function PARAMS ((struct work_stuff *,
-				   const char **, string *, const char *));
+iterate_demangle_function (struct work_stuff *,
+                           const char **, string *, const char *);
 
-static void
-remember_type PARAMS ((struct work_stuff *, const char *, int));
+static void remember_type (struct work_stuff *, const char *, int);
 
-static void
-remember_Btype PARAMS ((struct work_stuff *, const char *, int, int));
+static void remember_Btype (struct work_stuff *, const char *, int, int);
 
-static int
-register_Btype PARAMS ((struct work_stuff *));
+static int register_Btype (struct work_stuff *);
 
-static void
-remember_Ktype PARAMS ((struct work_stuff *, const char *, int));
+static void remember_Ktype (struct work_stuff *, const char *, int);
 
-static void
-forget_types PARAMS ((struct work_stuff *));
+static void forget_types (struct work_stuff *);
 
-static void
-forget_B_and_K_types PARAMS ((struct work_stuff *));
+static void forget_B_and_K_types (struct work_stuff *);
 
-static void
-string_prepends PARAMS ((string *, string *));
+static void string_prepends (string *, string *);
 
 static int
-demangle_template_value_parm PARAMS ((struct work_stuff*, const char**,
-				      string*, type_kind_t));
+demangle_template_value_parm (struct work_stuff*, const char**,
+                              string*, type_kind_t);
 
 static int
-do_hpacc_template_const_value PARAMS ((struct work_stuff *, const char **, string *));
+do_hpacc_template_const_value (struct work_stuff *, const char **, string *);
 
 static int
-do_hpacc_template_literal PARAMS ((struct work_stuff *, const char **, string *));
+do_hpacc_template_literal (struct work_stuff *, const char **, string *);
 
-static int
-snarf_numeric_literal PARAMS ((const char **, string *));
+static int snarf_numeric_literal (const char **, string *);
 
 /* There is a TYPE_QUAL value for each type qualifier.  They can be
    combined by bitwise-or to form the complete set of qualifiers for a
@@ -494,36 +457,28 @@ snarf_numeric_literal PARAMS ((const char **, string *));
 #define TYPE_QUAL_VOLATILE 0x2
 #define TYPE_QUAL_RESTRICT 0x4
 
-static int
-code_for_qualifier PARAMS ((int));
+static int code_for_qualifier (int);
 
-static const char*
-qualifier_string PARAMS ((int));
+static const char* qualifier_string (int);
 
-static const char*
-demangle_qualifier PARAMS ((int));
+static const char* demangle_qualifier (int);
 
-static int
-demangle_expression PARAMS ((struct work_stuff *, const char **, string *, 
-			     type_kind_t));
+static int demangle_expression (struct work_stuff *, const char **, string *, 
+                                type_kind_t);
 
 static int
-demangle_integral_value PARAMS ((struct work_stuff *, const char **,
-				 string *));
+demangle_integral_value (struct work_stuff *, const char **, string *);
 
 static int
-demangle_real_value PARAMS ((struct work_stuff *, const char **, string *));
+demangle_real_value (struct work_stuff *, const char **, string *);
 
 static void
-demangle_arm_hp_template PARAMS ((struct work_stuff *, const char **, int,
-				  string *));
+demangle_arm_hp_template (struct work_stuff *, const char **, int, string *);
 
 static void
-recursively_demangle PARAMS ((struct work_stuff *, const char **, string *,
-			      int));
+recursively_demangle (struct work_stuff *, const char **, string *, int);
 
-static void
-grow_vect PARAMS ((char **, size_t *, size_t, int));
+static void grow_vect (char **, size_t *, size_t, int);
 
 /* Translate count to integer, consuming tokens in the process.
    Conversion terminates on the first non-digit character.
@@ -534,8 +489,7 @@ grow_vect PARAMS ((char **, size_t *, size_t, int));
    Overflow consumes the rest of the digits, and returns -1.  */
 
 static int
-consume_count (type)
-     const char **type;
+consume_count (const char **type)
 {
   int count = 0;
 
@@ -574,8 +528,7 @@ consume_count (type)
    failure, since 0 can be a valid value.  */
 
 static int
-consume_count_with_underscores (mangled)
-     const char **mangled;
+consume_count_with_underscores (const char **mangled)
 {
   int idx;
 
@@ -608,8 +561,7 @@ consume_count_with_underscores (mangled)
    corresponding to this qualifier.  */
 
 static int
-code_for_qualifier (c)
-  int c;
+code_for_qualifier (int c)
 {
   switch (c)
     {
@@ -634,8 +586,7 @@ code_for_qualifier (c)
    TYPE_QUALS.  */
 
 static const char*
-qualifier_string (type_quals)
-     int type_quals;
+qualifier_string (int type_quals)
 {
   switch (type_quals)
     {
@@ -676,17 +627,13 @@ qualifier_string (type_quals)
    called with a valid qualifier code.  */
 
 static const char*
-demangle_qualifier (c)
-  int c;
+demangle_qualifier (int c)
 {
   return qualifier_string (code_for_qualifier (c));
 }
 
 int
-cplus_demangle_opname (opname, result, options)
-     const char *opname;
-     char *result;
-     int options;
+cplus_demangle_opname (const char *opname, char *result, int options)
 {
   int len, len1, ret;
   string type;
@@ -819,9 +766,7 @@ cplus_demangle_opname (opname, result, options)
    if OPTIONS & DMGL_ANSI == 0, return the old GNU name.  */
 
 const char *
-cplus_mangle_opname (opname, options)
-     const char *opname;
-     int options;
+cplus_mangle_opname (const char *opname, int options)
 {
   size_t i;
   int len;
@@ -841,8 +786,7 @@ cplus_mangle_opname (opname, options)
    allow for any demangler initialization that maybe necessary. */
 
 enum demangling_styles
-cplus_demangle_set_style (style)
-     enum demangling_styles style;
+cplus_demangle_set_style (enum demangling_styles style)
 {
   const struct demangler_engine *demangler = libiberty_demanglers; 
 
@@ -859,8 +803,7 @@ cplus_demangle_set_style (style)
 /* Do string name to style translation */
 
 enum demangling_styles
-cplus_demangle_name_to_style (name)
-     const char *name;
+cplus_demangle_name_to_style (const char *name)
 {
   const struct demangler_engine *demangler = libiberty_demanglers; 
 
@@ -900,9 +843,7 @@ cplus_demangle_name_to_style (name)
    MANGLED.  */
 
 char *
-cplus_demangle (mangled, options)
-     const char *mangled;
-     int options;
+cplus_demangle (const char *mangled, int options)
 {
   char *ret;
   struct work_stuff work[1];
@@ -944,18 +885,14 @@ cplus_demangle (mangled, options)
    updating *OLD_VECT and *SIZE as necessary.  */
 
 static void
-grow_vect (old_vect, size, min_size, element_size)
-     char **old_vect;
-     size_t *size;
-     size_t min_size;
-     int element_size;
+grow_vect (char **old_vect, size_t *size, size_t min_size, int element_size)
 {
   if (*size < min_size)
     {
       *size *= 2;
       if (*size < min_size)
 	*size = min_size;
-      *old_vect = (void *) xrealloc (*old_vect, *size * element_size);
+      *old_vect = XRESIZEVAR (char, *old_vect, *size * element_size);
     }
 }
 
@@ -968,15 +905,12 @@ grow_vect (old_vect, size, min_size, element_size)
    The resulting string is valid until the next call of ada_demangle.  */
 
 static char *
-ada_demangle (mangled, option)
-     const char *mangled;
-     int option ATTRIBUTE_UNUSED;
+ada_demangle (const char *mangled, int option ATTRIBUTE_UNUSED)
 {
   int i, j;
   int len0;
   const char* p;
   char *demangled = NULL;
-  int at_start_name;
   int changed;
   size_t demangled_size = 0;
   
@@ -1029,15 +963,12 @@ ada_demangle (mangled, option)
        i += 1, j += 1)
     demangled[j] = mangled[i];
   
-  at_start_name = 1;
   while (i < len0)
     {
-      at_start_name = 0;
-      
       if (i < len0 - 2 && mangled[i] == '_' && mangled[i + 1] == '_')
 	{
 	  demangled[j] = '.';
-	  changed = at_start_name = 1;
+	  changed = 1;
 	  i += 2; j += 1;
 	}
       else
@@ -1077,9 +1008,7 @@ ada_demangle (mangled, option)
    calls go directly to this routine to avoid resetting that info. */
 
 static char *
-internal_cplus_demangle (work, mangled)
-     struct work_stuff *work;
-     const char *mangled;
+internal_cplus_demangle (struct work_stuff *work, const char *mangled)
 {
 
   string decl;
@@ -1144,8 +1073,7 @@ internal_cplus_demangle (work, mangled)
 
 /* Clear out and squangling related storage */
 static void
-squangle_mop_up (work)
-     struct work_stuff *work;
+squangle_mop_up (struct work_stuff *work)
 {
   /* clean up the B and K type mangling types. */
   forget_B_and_K_types (work);
@@ -1163,9 +1091,7 @@ squangle_mop_up (work)
 /* Copy the work state and storage.  */
 
 static void
-work_stuff_copy_to_from (to, from)
-     struct work_stuff *to;
-     struct work_stuff *from;
+work_stuff_copy_to_from (struct work_stuff *to, struct work_stuff *from)
 {
   int i;
 
@@ -1176,56 +1102,52 @@ work_stuff_copy_to_from (to, from)
 
   /* Deep-copy dynamic storage.  */
   if (from->typevec_size)
-    to->typevec
-      = (char **) xmalloc (from->typevec_size * sizeof (to->typevec[0]));
+    to->typevec = XNEWVEC (char *, from->typevec_size);
 
   for (i = 0; i < from->ntypes; i++)
     {
       int len = strlen (from->typevec[i]) + 1;
 
-      to->typevec[i] = xmalloc (len);
+      to->typevec[i] = XNEWVEC (char, len);
       memcpy (to->typevec[i], from->typevec[i], len);
     }
 
   if (from->ksize)
-    to->ktypevec
-      = (char **) xmalloc (from->ksize * sizeof (to->ktypevec[0]));
+    to->ktypevec = XNEWVEC (char *, from->ksize);
 
   for (i = 0; i < from->numk; i++)
     {
       int len = strlen (from->ktypevec[i]) + 1;
 
-      to->ktypevec[i] = xmalloc (len);
+      to->ktypevec[i] = XNEWVEC (char, len);
       memcpy (to->ktypevec[i], from->ktypevec[i], len);
     }
 
   if (from->bsize)
-    to->btypevec
-      = (char **) xmalloc (from->bsize * sizeof (to->btypevec[0]));
+    to->btypevec = XNEWVEC (char *, from->bsize);
 
   for (i = 0; i < from->numb; i++)
     {
       int len = strlen (from->btypevec[i]) + 1;
 
-      to->btypevec[i] = xmalloc (len);
+      to->btypevec[i] = XNEWVEC (char , len);
       memcpy (to->btypevec[i], from->btypevec[i], len);
     }
 
   if (from->ntmpl_args)
-    to->tmpl_argvec
-      = (char **) xmalloc (from->ntmpl_args * sizeof (to->tmpl_argvec[0]));
+    to->tmpl_argvec = XNEWVEC (char *, from->ntmpl_args);
 
   for (i = 0; i < from->ntmpl_args; i++)
     {
       int len = strlen (from->tmpl_argvec[i]) + 1;
 
-      to->tmpl_argvec[i] = xmalloc (len);
+      to->tmpl_argvec[i] = XNEWVEC (char, len);
       memcpy (to->tmpl_argvec[i], from->tmpl_argvec[i], len);
     }
 
   if (from->previous_argument)
     {
-      to->previous_argument = (string*) xmalloc (sizeof (string));
+      to->previous_argument = XNEW (string);
       string_init (to->previous_argument);
       string_appends (to->previous_argument, from->previous_argument);
     }
@@ -1235,8 +1157,7 @@ work_stuff_copy_to_from (to, from)
 /* Delete dynamic stuff in work_stuff that is not to be re-used.  */
 
 static void
-delete_non_B_K_work_stuff (work)
-     struct work_stuff *work;
+delete_non_B_K_work_stuff (struct work_stuff *work)
 {
   /* Discard the remembered types, if any.  */
 
@@ -1269,8 +1190,7 @@ delete_non_B_K_work_stuff (work)
 
 /* Delete all dynamic storage in work_stuff.  */
 static void
-delete_work_stuff (work)
-     struct work_stuff *work;
+delete_work_stuff (struct work_stuff *work)
 {
   delete_non_B_K_work_stuff (work);
   squangle_mop_up (work);
@@ -1280,10 +1200,7 @@ delete_work_stuff (work)
 /* Clear out any mangled storage */
 
 static char *
-mop_up (work, declp, success)
-     struct work_stuff *work;
-     string *declp;
-     int success;
+mop_up (struct work_stuff *work, string *declp, int success)
 {
   char *demangled = NULL;
 
@@ -1335,10 +1252,8 @@ DESCRIPTION
 	argument list.  */
 
 static int
-demangle_signature (work, mangled, declp)
-     struct work_stuff *work;
-     const char **mangled;
-     string *declp;
+demangle_signature (struct work_stuff *work,
+                    const char **mangled, string *declp)
 {
   int success = 1;
   int func_done = 0;
@@ -1628,10 +1543,8 @@ demangle_signature (work, mangled, declp)
 #if 0
 
 static int
-demangle_method_args (work, mangled, declp)
-     struct work_stuff *work;
-     const char **mangled;
-     string *declp;
+demangle_method_args (struct work_stuff *work, const char **mangled,
+                      string *declp)
 {
   int success = 0;
 
@@ -1651,10 +1564,8 @@ demangle_method_args (work, mangled, declp)
 #endif
 
 static int
-demangle_template_template_parm (work, mangled, tname)
-     struct work_stuff *work;
-     const char **mangled;
-     string *tname;
+demangle_template_template_parm (struct work_stuff *work,
+                                 const char **mangled, string *tname)
 {
   int i;
   int r;
@@ -1715,11 +1626,8 @@ demangle_template_template_parm (work, mangled, tname)
 }
 
 static int
-demangle_expression (work, mangled, s, tk)
-     struct work_stuff *work;
-     const char** mangled;
-     string* s;
-     type_kind_t tk;
+demangle_expression (struct work_stuff *work, const char **mangled,
+                     string *s, type_kind_t tk)
 {
   int need_operator = 0;
   int success;
@@ -1775,10 +1683,8 @@ demangle_expression (work, mangled, s, tk)
 }
 
 static int
-demangle_integral_value (work, mangled, s)
-     struct work_stuff *work;
-     const char** mangled;
-     string* s;
+demangle_integral_value (struct work_stuff *work,
+                         const char **mangled, string *s)
 {
   int success;
 
@@ -1873,10 +1779,8 @@ demangle_integral_value (work, mangled, s)
 /* Demangle the real value in MANGLED.  */
 
 static int
-demangle_real_value (work, mangled, s)
-     struct work_stuff *work;
-     const char **mangled;
-     string* s;
+demangle_real_value (struct work_stuff *work,
+                     const char **mangled, string *s)
 {
   if (**mangled == 'E')
     return demangle_expression (work, mangled, s, tk_real);
@@ -1916,11 +1820,8 @@ demangle_real_value (work, mangled, s)
 }
 
 static int
-demangle_template_value_parm (work, mangled, s, tk)
-     struct work_stuff *work;
-     const char **mangled;
-     string* s;
-     type_kind_t tk;
+demangle_template_value_parm (struct work_stuff *work, const char **mangled,
+                              string *s, type_kind_t tk)
 {
   int success = 1;
 
@@ -1990,7 +1891,7 @@ demangle_template_value_parm (work, mangled, s, tk)
 	    string_appendn (s, "0", 1);
 	  else
 	    {
-	      char *p = xmalloc (symbol_len + 1), *q;
+	      char *p = XNEWVEC (char, symbol_len + 1), *q;
 	      strncpy (p, *mangled, symbol_len);
 	      p [symbol_len] = '\0';
 	      /* We use cplus_demangle here, rather than
@@ -2028,26 +1929,20 @@ demangle_template_value_parm (work, mangled, s, tk)
    types.  */
 
 static int
-demangle_template (work, mangled, tname, trawname, is_type, remember)
-     struct work_stuff *work;
-     const char **mangled;
-     string *tname;
-     string *trawname;
-     int is_type;
-     int remember;
+demangle_template (struct work_stuff *work, const char **mangled,
+                   string *tname, string *trawname,
+                   int is_type, int remember)
 {
   int i;
   int r;
   int need_comma = 0;
   int success = 0;
-  const char *start;
   int is_java_array = 0;
   string temp;
 
   (*mangled)++;
   if (is_type)
     {
-      start = *mangled;
       /* get template name */
       if (**mangled == 'z')
 	{
@@ -2102,7 +1997,7 @@ demangle_template (work, mangled, tname, trawname, is_type, remember)
   if (!is_type)
     {
       /* Create an array for saving the template argument values. */
-      work->tmpl_argvec = (char**) xmalloc (r * sizeof (char *));
+      work->tmpl_argvec = XNEWVEC (char *, r);
       work->ntmpl_args = r;
       for (i = 0; i < r; i++)
 	work->tmpl_argvec[i] = 0;
@@ -2127,7 +2022,7 @@ demangle_template (work, mangled, tname, trawname, is_type, remember)
 		{
 		  /* Save the template argument. */
 		  int len = temp.p - temp.b;
-		  work->tmpl_argvec[i] = xmalloc (len + 1);
+		  work->tmpl_argvec[i] = XNEWVEC (char, len + 1);
 		  memcpy (work->tmpl_argvec[i], temp.b, len);
 		  work->tmpl_argvec[i][len] = '\0';
 		}
@@ -2155,7 +2050,7 @@ demangle_template (work, mangled, tname, trawname, is_type, remember)
 		{
 		  /* Save the template argument. */
 		  int len = r2;
-		  work->tmpl_argvec[i] = xmalloc (len + 1);
+		  work->tmpl_argvec[i] = XNEWVEC (char, len + 1);
 		  memcpy (work->tmpl_argvec[i], *mangled, len);
 		  work->tmpl_argvec[i][len] = '\0';
 		}
@@ -2201,7 +2096,7 @@ demangle_template (work, mangled, tname, trawname, is_type, remember)
 	  if (!is_type)
 	    {
 	      int len = s->p - s->b;
-	      work->tmpl_argvec[i] = xmalloc (len + 1);
+	      work->tmpl_argvec[i] = XNEWVEC (char, len + 1);
 	      memcpy (work->tmpl_argvec[i], s->b, len);
 	      work->tmpl_argvec[i][len] = '\0';
 
@@ -2245,11 +2140,8 @@ demangle_template (work, mangled, tname, trawname, is_type, remember)
 }
 
 static int
-arm_pt (work, mangled, n, anchor, args)
-     struct work_stuff *work;
-     const char *mangled;
-     int n;
-     const char **anchor, **args;
+arm_pt (struct work_stuff *work, const char *mangled,
+        int n, const char **anchor, const char **args)
 {
   /* Check if ARM template with "__pt__" in it ("parameterized type") */
   /* Allow HP also here, because HP's cfront compiler follows ARM to some extent */
@@ -2302,11 +2194,8 @@ arm_pt (work, mangled, n, anchor, args)
 }
 
 static void
-demangle_arm_hp_template (work, mangled, n, declp)
-     struct work_stuff *work;
-     const char **mangled;
-     int n;
-     string *declp;
+demangle_arm_hp_template (struct work_stuff *work, const char **mangled,
+                          int n, string *declp)
 {
   const char *p;
   const char *args;
@@ -2318,6 +2207,7 @@ demangle_arm_hp_template (work, mangled, n, declp)
   if (HP_DEMANGLING && ((*mangled)[n] == 'X'))
     {
       char *start_spec_args = NULL;
+      int hold_options;
 
       /* First check for and omit template specialization pseudo-arguments,
          such as in "Spec<#1,#1.*>" */
@@ -2330,6 +2220,12 @@ demangle_arm_hp_template (work, mangled, n, declp)
       string_init (&arg);
       if (work->temp_start == -1) /* non-recursive call */
         work->temp_start = declp->p - declp->b;
+
+      /* We want to unconditionally demangle parameter types in
+	 template parameters.  */
+      hold_options = work->options;
+      work->options |= DMGL_PARAMS;
+
       string_append (declp, "<");
       while (1)
         {
@@ -2376,17 +2272,25 @@ demangle_arm_hp_template (work, mangled, n, declp)
       string_delete (&arg);
       if (**mangled == '_')
         (*mangled)++;
+      work->options = hold_options;
       return;
     }
   /* ARM template? (Also handles HP cfront extensions) */
   else if (arm_pt (work, *mangled, n, &p, &args))
     {
+      int hold_options;
       string type_str;
 
       string_init (&arg);
       string_appendn (declp, *mangled, p - *mangled);
       if (work->temp_start == -1)  /* non-recursive call */
 	work->temp_start = declp->p - declp->b;
+
+      /* We want to unconditionally demangle parameter types in
+	 template parameters.  */
+      hold_options = work->options;
+      work->options |= DMGL_PARAMS;
+
       string_append (declp, "<");
       /* should do error checking here */
       while (args < e) {
@@ -2430,7 +2334,10 @@ demangle_arm_hp_template (work, mangled, n, declp)
 
               /* Fail if we didn't make any progress: prevent infinite loop. */
               if (args == old_args)
-                return;
+		{
+		  work->options = hold_options;
+		  return;
+		}
             }
 	  }
 	string_appends (declp, &arg);
@@ -2441,6 +2348,7 @@ demangle_arm_hp_template (work, mangled, n, declp)
       if (args >= e)
 	--declp->p; /* remove extra comma */
       string_append (declp, ">");
+      work->options = hold_options;
     }
   else if (n>10 && strncmp (*mangled, "_GLOBAL_", 8) == 0
 	   && (*mangled)[9] == 'N'
@@ -2464,10 +2372,8 @@ demangle_arm_hp_template (work, mangled, n, declp)
    already been dealt with */
 
 static int
-demangle_class_name (work, mangled, declp)
-     struct work_stuff *work;
-     const char **mangled;
-     string *declp;
+demangle_class_name (struct work_stuff *work, const char **mangled,
+                     string *declp)
 {
   int n;
   int success = 0;
@@ -2520,10 +2426,7 @@ DESCRIPTION
 */
 
 static int
-demangle_class (work, mangled, declp)
-     struct work_stuff *work;
-     const char **mangled;
-     string *declp;
+demangle_class (struct work_stuff *work, const char **mangled, string *declp)
 {
   int success = 0;
   int btype;
@@ -2575,11 +2478,8 @@ demangle_class (work, mangled, declp)
    demangle_signature.  */
 
 static int
-iterate_demangle_function (work, mangled, declp, scan)
-     struct work_stuff *work;
-     const char **mangled;
-     string *declp;
-     const char *scan;
+iterate_demangle_function (struct work_stuff *work, const char **mangled,
+                           string *declp, const char *scan)
 {
   const char *mangle_init = *mangled;
   int success = 0;
@@ -2678,10 +2578,8 @@ DESCRIPTION
  */
 
 static int
-demangle_prefix (work, mangled, declp)
-     struct work_stuff *work;
-     const char **mangled;
-     string *declp;
+demangle_prefix (struct work_stuff *work, const char **mangled,
+                 string *declp)
 {
   int success = 1;
   const char *scan;
@@ -2889,10 +2787,7 @@ DESCRIPTION
  */
 
 static int
-gnu_special (work, mangled, declp)
-     struct work_stuff *work;
-     const char **mangled;
-     string *declp;
+gnu_special (struct work_stuff *work, const char **mangled, string *declp)
 {
   int n;
   int success = 1;
@@ -3093,16 +2988,13 @@ gnu_special (work, mangled, declp)
 }
 
 static void
-recursively_demangle(work, mangled, result, namelength)
-     struct work_stuff *work;
-     const char **mangled;
-     string *result;
-     int namelength;
+recursively_demangle(struct work_stuff *work, const char **mangled,
+                     string *result, int namelength)
 {
   char * recurse = (char *)NULL;
   char * recurse_dem = (char *)NULL;
 
-  recurse = (char *) xmalloc (namelength + 1);
+  recurse = XNEWVEC (char, namelength + 1);
   memcpy (recurse, *mangled, namelength);
   recurse[namelength] = '\000';
 
@@ -3145,9 +3037,7 @@ DESCRIPTION
  */
 
 static int
-arm_special (mangled, declp)
-     const char **mangled;
-     string *declp;
+arm_special (const char **mangled, string *declp)
 {
   int n;
   int success = 1;
@@ -3230,12 +3120,8 @@ BUGS
  */
 
 static int
-demangle_qualified (work, mangled, result, isfuncname, append)
-     struct work_stuff *work;
-     const char **mangled;
-     string *result;
-     int isfuncname;
-     int append;
+demangle_qualified (struct work_stuff *work, const char **mangled,
+                    string *result, int isfuncname, int append)
 {
   int qualifiers = 0;
   int success = 1;
@@ -3457,9 +3343,7 @@ DESCRIPTION
 */
 
 static int
-get_count (type, count)
-     const char **type;
-     int *count;
+get_count (const char **type, int *count)
 {
   const char *p;
   int n;
@@ -3495,10 +3379,7 @@ get_count (type, count)
    value returned is really a type_kind_t.  */
 
 static int
-do_type (work, mangled, result)
-     struct work_stuff *work;
-     const char **mangled;
-     string *result;
+do_type (struct work_stuff *work, const char **mangled, string *result)
 {
   int n;
   int done;
@@ -3807,14 +3688,12 @@ do_type (work, mangled, result)
    The value returned is really a type_kind_t.  */
 
 static int
-demangle_fund_type (work, mangled, result)
-     struct work_stuff *work;
-     const char **mangled;
-     string *result;
+demangle_fund_type (struct work_stuff *work,
+                    const char **mangled, string *result)
 {
   int done = 0;
   int success = 1;
-  char buf[10];
+  char buf[INTBUF_SIZE + 5 /* 'int%u_t' */];
   unsigned int dec = 0;
   type_kind_t tk = tk_integral;
 
@@ -4009,10 +3888,8 @@ demangle_fund_type (work, mangled, result)
    **mangled points to 'S' or 'U' */
 
 static int
-do_hpacc_template_const_value (work, mangled, result)
-     struct work_stuff *work ATTRIBUTE_UNUSED;
-     const char **mangled;
-     string *result;
+do_hpacc_template_const_value (struct work_stuff *work ATTRIBUTE_UNUSED,
+                               const char **mangled, string *result)
 {
   int unsigned_const;
 
@@ -4066,10 +3943,8 @@ do_hpacc_template_const_value (work, mangled, result)
    **mangled is pointing to the 'A' */
 
 static int
-do_hpacc_template_literal (work, mangled, result)
-     struct work_stuff *work;
-     const char **mangled;
-     string *result;
+do_hpacc_template_literal (struct work_stuff *work, const char **mangled,
+                           string *result)
 {
   int literal_len = 0;
   char * recurse;
@@ -4090,7 +3965,7 @@ do_hpacc_template_literal (work, mangled, result)
   string_append (result, "&");
 
   /* Now recursively demangle the literal name */
-  recurse = (char *) xmalloc (literal_len + 1);
+  recurse = XNEWVEC (char, literal_len + 1);
   memcpy (recurse, *mangled, literal_len);
   recurse[literal_len] = '\000';
 
@@ -4112,9 +3987,7 @@ do_hpacc_template_literal (work, mangled, result)
 }
 
 static int
-snarf_numeric_literal (args, arg)
-     const char ** args;
-     string * arg;
+snarf_numeric_literal (const char **args, string *arg)
 {
   if (**args == '-')
     {
@@ -4143,10 +4016,7 @@ snarf_numeric_literal (args, arg)
    and free'd should anything go wrong.  */
 
 static int
-do_arg (work, mangled, result)
-     struct work_stuff *work;
-     const char **mangled;
-     string *result;
+do_arg (struct work_stuff *work, const char **mangled, string *result)
 {
   /* Remember where we started so that we can record the type, for
      non-squangling type remembering.  */
@@ -4197,7 +4067,7 @@ do_arg (work, mangled, result)
   if (work->previous_argument)
     string_delete (work->previous_argument);
   else
-    work->previous_argument = (string*) xmalloc (sizeof (string));
+    work->previous_argument = XNEW (string);
 
   if (!do_type (work, mangled, work->previous_argument))
     return 0;
@@ -4209,10 +4079,7 @@ do_arg (work, mangled, result)
 }
 
 static void
-remember_type (work, start, len)
-     struct work_stuff *work;
-     const char *start;
-     int len;
+remember_type (struct work_stuff *work, const char *start, int len)
 {
   char *tem;
 
@@ -4224,18 +4091,16 @@ remember_type (work, start, len)
       if (work -> typevec_size == 0)
 	{
 	  work -> typevec_size = 3;
-	  work -> typevec
-	    = (char **) xmalloc (sizeof (char *) * work -> typevec_size);
+	  work -> typevec = XNEWVEC (char *, work->typevec_size);
 	}
       else
 	{
 	  work -> typevec_size *= 2;
 	  work -> typevec
-	    = (char **) xrealloc ((char *)work -> typevec,
-				  sizeof (char *) * work -> typevec_size);
+	    = XRESIZEVEC (char *, work->typevec, work->typevec_size);
 	}
     }
-  tem = xmalloc (len + 1);
+  tem = XNEWVEC (char, len + 1);
   memcpy (tem, start, len);
   tem[len] = '\0';
   work -> typevec[work -> ntypes++] = tem;
@@ -4244,10 +4109,7 @@ remember_type (work, start, len)
 
 /* Remember a K type class qualifier. */
 static void
-remember_Ktype (work, start, len)
-     struct work_stuff *work;
-     const char *start;
-     int len;
+remember_Ktype (struct work_stuff *work, const char *start, int len)
 {
   char *tem;
 
@@ -4256,18 +4118,16 @@ remember_Ktype (work, start, len)
       if (work -> ksize == 0)
 	{
 	  work -> ksize = 5;
-	  work -> ktypevec
-	    = (char **) xmalloc (sizeof (char *) * work -> ksize);
+	  work -> ktypevec = XNEWVEC (char *, work->ksize);
 	}
       else
 	{
 	  work -> ksize *= 2;
 	  work -> ktypevec
-	    = (char **) xrealloc ((char *)work -> ktypevec,
-				  sizeof (char *) * work -> ksize);
+	    = XRESIZEVEC (char *, work->ktypevec, work->ksize);
 	}
     }
-  tem = xmalloc (len + 1);
+  tem = XNEWVEC (char, len + 1);
   memcpy (tem, start, len);
   tem[len] = '\0';
   work -> ktypevec[work -> numk++] = tem;
@@ -4278,8 +4138,7 @@ remember_Ktype (work, start, len)
    registers map<temp<char> > as B0, and temp<char> as B1 */
 
 static int
-register_Btype (work)
-     struct work_stuff *work;
+register_Btype (struct work_stuff *work)
 {
   int ret;
 
@@ -4288,15 +4147,13 @@ register_Btype (work)
       if (work -> bsize == 0)
 	{
 	  work -> bsize = 5;
-	  work -> btypevec
-	    = (char **) xmalloc (sizeof (char *) * work -> bsize);
+	  work -> btypevec = XNEWVEC (char *, work->bsize);
 	}
       else
 	{
 	  work -> bsize *= 2;
 	  work -> btypevec
-	    = (char **) xrealloc ((char *)work -> btypevec,
-				  sizeof (char *) * work -> bsize);
+	    = XRESIZEVEC (char *, work->btypevec, work->bsize);
 	}
     }
   ret = work -> numb++;
@@ -4307,14 +4164,12 @@ register_Btype (work)
 /* Store a value into a previously registered B code type. */
 
 static void
-remember_Btype (work, start, len, index)
-     struct work_stuff *work;
-     const char *start;
-     int len, index;
+remember_Btype (struct work_stuff *work, const char *start,
+                int len, int index)
 {
   char *tem;
 
-  tem = xmalloc (len + 1);
+  tem = XNEWVEC (char, len + 1);
   memcpy (tem, start, len);
   tem[len] = '\0';
   work -> btypevec[index] = tem;
@@ -4322,8 +4177,7 @@ remember_Btype (work, start, len, index)
 
 /* Lose all the info related to B and K type codes. */
 static void
-forget_B_and_K_types (work)
-     struct work_stuff *work;
+forget_B_and_K_types (struct work_stuff *work)
 {
   int i;
 
@@ -4350,8 +4204,7 @@ forget_B_and_K_types (work)
 /* Forget the remembered types, but not the type vector itself.  */
 
 static void
-forget_types (work)
-     struct work_stuff *work;
+forget_types (struct work_stuff *work)
 {
   int i;
 
@@ -4409,10 +4262,8 @@ forget_types (work)
  */
 
 static int
-demangle_args (work, mangled, declp)
-     struct work_stuff *work;
-     const char **mangled;
-     string *declp;
+demangle_args (struct work_stuff *work, const char **mangled,
+               string *declp)
 {
   string arg;
   int need_comma = 0;
@@ -4534,10 +4385,8 @@ demangle_args (work, mangled, declp)
    and method pointers or references, not top-level declarations.  */
 
 static int
-demangle_nested_args (work, mangled, declp)
-     struct work_stuff *work;
-     const char **mangled;
-     string *declp;
+demangle_nested_args (struct work_stuff *work, const char **mangled,
+                      string *declp)
 {
   string* saved_previous_argument;
   int result;
@@ -4573,11 +4422,8 @@ demangle_nested_args (work, mangled, declp)
 }
 
 static void
-demangle_function_name (work, mangled, declp, scan)
-     struct work_stuff *work;
-     const char **mangled;
-     string *declp;
-     const char *scan;
+demangle_function_name (struct work_stuff *work, const char **mangled,
+                        string *declp, const char *scan)
 {
   size_t i;
   string type;
@@ -4734,9 +4580,7 @@ demangle_function_name (work, mangled, declp, scan)
 /* a mini string-handling package */
 
 static void
-string_need (s, n)
-     string *s;
-     int n;
+string_need (string *s, int n)
 {
   int tem;
 
@@ -4746,7 +4590,7 @@ string_need (s, n)
 	{
 	  n = 32;
 	}
-      s->p = s->b = xmalloc (n);
+      s->p = s->b = XNEWVEC (char, n);
       s->e = s->b + n;
     }
   else if (s->e - s->p < n)
@@ -4754,15 +4598,14 @@ string_need (s, n)
       tem = s->p - s->b;
       n += tem;
       n *= 2;
-      s->b = xrealloc (s->b, n);
+      s->b = XRESIZEVEC (char, s->b, n);
       s->p = s->b + tem;
       s->e = s->b + n;
     }
 }
 
 static void
-string_delete (s)
-     string *s;
+string_delete (string *s)
 {
   if (s->b != NULL)
     {
@@ -4772,15 +4615,13 @@ string_delete (s)
 }
 
 static void
-string_init (s)
-     string *s;
+string_init (string *s)
 {
   s->b = s->p = s->e = NULL;
 }
 
 static void
-string_clear (s)
-     string *s;
+string_clear (string *s)
 {
   s->p = s->b;
 }
@@ -4788,8 +4629,7 @@ string_clear (s)
 #if 0
 
 static int
-string_empty (s)
-     string *s;
+string_empty (string *s)
 {
   return (s->b == s->p);
 }
@@ -4797,9 +4637,7 @@ string_empty (s)
 #endif
 
 static void
-string_append (p, s)
-     string *p;
-     const char *s;
+string_append (string *p, const char *s)
 {
   int n;
   if (s == NULL || *s == '\0')
@@ -4811,8 +4649,7 @@ string_append (p, s)
 }
 
 static void
-string_appends (p, s)
-     string *p, *s;
+string_appends (string *p, string *s)
 {
   int n;
 
@@ -4826,10 +4663,7 @@ string_appends (p, s)
 }
 
 static void
-string_appendn (p, s, n)
-     string *p;
-     const char *s;
-     int n;
+string_appendn (string *p, const char *s, int n)
 {
   if (n != 0)
     {
@@ -4840,9 +4674,7 @@ string_appendn (p, s, n)
 }
 
 static void
-string_prepend (p, s)
-     string *p;
-     const char *s;
+string_prepend (string *p, const char *s)
 {
   if (s != NULL && *s != '\0')
     {
@@ -4851,8 +4683,7 @@ string_prepend (p, s)
 }
 
 static void
-string_prepends (p, s)
-     string *p, *s;
+string_prepends (string *p, string *s)
 {
   if (s->b != s->p)
     {
@@ -4861,10 +4692,7 @@ string_prepends (p, s)
 }
 
 static void
-string_prependn (p, s, n)
-     string *p;
-     const char *s;
-     int n;
+string_prependn (string *p, const char *s, int n)
 {
   char *q;
 
@@ -4881,9 +4709,7 @@ string_prependn (p, s, n)
 }
 
 static void
-string_append_template_idx (s, idx)
-     string *s;
-     int idx;
+string_append_template_idx (string *s, int idx)
 {
   char buf[INTBUF_SIZE + 1 /* 'T' */];
   sprintf(buf, "T%d", idx);