X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=libiberty%2Fcp-demangle.c;h=8f1cfb17f87f2734e0b756390eeaa94a69dc87ab;hb=7b96829ccc499ace9643b8e04ff531a4a0985c51;hp=19f191ed8b8b2fc9c35c01f02b34a2e79ebad77e;hpb=2d6520ee207ec339308f7876b2036b7dbeb5cbd1;p=deliverable%2Fbinutils-gdb.git

diff --git a/libiberty/cp-demangle.c b/libiberty/cp-demangle.c
index 19f191ed8b..8f1cfb17f8 100644
--- a/libiberty/cp-demangle.c
+++ b/libiberty/cp-demangle.c
@@ -1,5 +1,5 @@
 /* Demangler for g++ V3 ABI.
-   Copyright (C) 2003, 2004 Free Software Foundation, Inc.
+   Copyright (C) 2003, 2004, 2005 Free Software Foundation, Inc.
    Written by Ian Lance Taylor <ian@wasabisystems.com>.
 
    This file is part of the libiberty library, which is part of GCC.
@@ -25,7 +25,7 @@
 
    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
-   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. 
+   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. 
 */
 
 /* This code implements a demangler for the g++ V3 ABI.  The ABI is
@@ -109,39 +109,34 @@
 #define CP_STATIC_IF_GLIBCPP_V3 static
 
 #define cplus_demangle_fill_name d_fill_name
-static int
-d_fill_name PARAMS ((struct demangle_component *, const char *, int));
+static int d_fill_name (struct demangle_component *, const char *, int);
 
 #define cplus_demangle_fill_extended_operator d_fill_extended_operator
 static int
-d_fill_extended_operator PARAMS ((struct demangle_component *, int,
-				  struct demangle_component *));
+d_fill_extended_operator (struct demangle_component *, int,
+                          struct demangle_component *);
 
 #define cplus_demangle_fill_ctor d_fill_ctor
 static int
-d_fill_ctor PARAMS ((struct demangle_component *, enum gnu_v3_ctor_kinds,
-		     struct demangle_component *));
+d_fill_ctor (struct demangle_component *, enum gnu_v3_ctor_kinds,
+             struct demangle_component *);
 
 #define cplus_demangle_fill_dtor d_fill_dtor
 static int
-d_fill_dtor PARAMS ((struct demangle_component *, enum gnu_v3_dtor_kinds,
-		     struct demangle_component *));
+d_fill_dtor (struct demangle_component *, enum gnu_v3_dtor_kinds,
+             struct demangle_component *);
 
 #define cplus_demangle_mangled_name d_mangled_name
-static struct demangle_component *
-d_mangled_name PARAMS ((struct d_info *, int));
+static struct demangle_component *d_mangled_name (struct d_info *, int);
 
 #define cplus_demangle_type d_type
-static struct demangle_component *
-d_type PARAMS ((struct d_info *));
+static struct demangle_component *d_type (struct d_info *);
 
 #define cplus_demangle_print d_print
-static char *
-d_print PARAMS ((int, const struct demangle_component *, int, size_t *));
+static char *d_print (int, const struct demangle_component *, int, size_t *);
 
 #define cplus_demangle_init_info d_init_info
-static void
-d_init_info PARAMS ((const char *, int, size_t, struct d_info *));
+static void d_init_info (const char *, int, size_t, struct d_info *);
 
 #else /* ! defined(IN_GLIBCPP_V3) */
 #define CP_STATIC_IF_GLIBCPP_V3
@@ -215,7 +210,7 @@ struct d_print_template
   /* Next template on the list.  */
   struct d_print_template *next;
   /* This template.  */
-  const struct demangle_component *template;
+  const struct demangle_component *template_decl;
 };
 
 /* A list of type modifiers.  This is used while printing.  */
@@ -286,187 +281,157 @@ struct d_print_info
   ((dpi)->buf == NULL || (dpi)->len == 0 ? '\0' : (dpi)->buf[(dpi)->len - 1])
 
 #ifdef CP_DEMANGLE_DEBUG
-static void 
-d_dump PARAMS ((struct demangle_component *, int));
+static void d_dump (struct demangle_component *, int);
 #endif
 
 static struct demangle_component *
-d_make_empty PARAMS ((struct d_info *));
+d_make_empty (struct d_info *);
 
 static struct demangle_component *
-d_make_comp PARAMS ((struct d_info *, enum demangle_component_type,
-		     struct demangle_component *,
-		     struct demangle_component *));
+d_make_comp (struct d_info *, enum demangle_component_type,
+             struct demangle_component *,
+             struct demangle_component *);
 
 static struct demangle_component *
-d_make_name PARAMS ((struct d_info *, const char *, int));
+d_make_name (struct d_info *, const char *, int);
 
 static struct demangle_component *
-d_make_builtin_type PARAMS ((struct d_info *,
-			     const struct demangle_builtin_type_info *));
+d_make_builtin_type (struct d_info *,
+                     const struct demangle_builtin_type_info *);
 
 static struct demangle_component *
-d_make_operator PARAMS ((struct d_info *,
-			 const struct demangle_operator_info *));
+d_make_operator (struct d_info *,
+                 const struct demangle_operator_info *);
 
 static struct demangle_component *
-d_make_extended_operator PARAMS ((struct d_info *, int,
-				  struct demangle_component *));
+d_make_extended_operator (struct d_info *, int,
+                          struct demangle_component *);
 
 static struct demangle_component *
-d_make_ctor PARAMS ((struct d_info *, enum gnu_v3_ctor_kinds,
-		     struct demangle_component *));
+d_make_ctor (struct d_info *, enum gnu_v3_ctor_kinds,
+             struct demangle_component *);
 
 static struct demangle_component *
-d_make_dtor PARAMS ((struct d_info *, enum gnu_v3_dtor_kinds,
-		     struct demangle_component *));
+d_make_dtor (struct d_info *, enum gnu_v3_dtor_kinds,
+             struct demangle_component *);
 
 static struct demangle_component *
-d_make_template_param PARAMS ((struct d_info *, long));
+d_make_template_param (struct d_info *, long);
 
 static struct demangle_component *
-d_make_sub PARAMS ((struct d_info *, const char *, int));
+d_make_sub (struct d_info *, const char *, int);
 
 static int
-has_return_type PARAMS ((struct demangle_component *));
+has_return_type (struct demangle_component *);
 
 static int
-is_ctor_dtor_or_conversion PARAMS ((struct demangle_component *));
+is_ctor_dtor_or_conversion (struct demangle_component *);
 
-static struct demangle_component *
-d_encoding PARAMS ((struct d_info *, int));
+static struct demangle_component *d_encoding (struct d_info *, int);
 
-static struct demangle_component *
-d_name PARAMS ((struct d_info *));
+static struct demangle_component *d_name (struct d_info *);
 
-static struct demangle_component *
-d_nested_name PARAMS ((struct d_info *));
+static struct demangle_component *d_nested_name (struct d_info *);
 
-static struct demangle_component *
-d_prefix PARAMS ((struct d_info *));
+static struct demangle_component *d_prefix (struct d_info *);
 
-static struct demangle_component *
-d_unqualified_name PARAMS ((struct d_info *));
+static struct demangle_component *d_unqualified_name (struct d_info *);
 
-static struct demangle_component *
-d_source_name PARAMS ((struct d_info *));
+static struct demangle_component *d_source_name (struct d_info *);
 
-static long
-d_number PARAMS ((struct d_info *));
+static long d_number (struct d_info *);
 
-static struct demangle_component *
-d_identifier PARAMS ((struct d_info *, int));
+static struct demangle_component *d_identifier (struct d_info *, int);
 
-static struct demangle_component *
-d_operator_name PARAMS ((struct d_info *));
+static struct demangle_component *d_operator_name (struct d_info *);
 
-static struct demangle_component *
-d_special_name PARAMS ((struct d_info *));
+static struct demangle_component *d_special_name (struct d_info *);
 
-static int
-d_call_offset PARAMS ((struct d_info *, int));
+static int d_call_offset (struct d_info *, int);
 
-static struct demangle_component *
-d_ctor_dtor_name PARAMS ((struct d_info *));
+static struct demangle_component *d_ctor_dtor_name (struct d_info *);
 
 static struct demangle_component **
-d_cv_qualifiers PARAMS ((struct d_info *, struct demangle_component **, int));
+d_cv_qualifiers (struct d_info *, struct demangle_component **, int);
 
 static struct demangle_component *
-d_function_type PARAMS ((struct d_info *));
+d_function_type (struct d_info *);
 
 static struct demangle_component *
-d_bare_function_type PARAMS ((struct d_info *, int));
+d_bare_function_type (struct d_info *, int);
 
 static struct demangle_component *
-d_class_enum_type PARAMS ((struct d_info *));
+d_class_enum_type (struct d_info *);
 
-static struct demangle_component *
-d_array_type PARAMS ((struct d_info *));
+static struct demangle_component *d_array_type (struct d_info *);
 
 static struct demangle_component *
-d_pointer_to_member_type PARAMS ((struct d_info *));
+d_pointer_to_member_type (struct d_info *);
 
 static struct demangle_component *
-d_template_param PARAMS ((struct d_info *));
+d_template_param (struct d_info *);
 
-static struct demangle_component *
-d_template_args PARAMS ((struct d_info *));
+static struct demangle_component *d_template_args (struct d_info *);
 
 static struct demangle_component *
-d_template_arg PARAMS ((struct d_info *));
+d_template_arg (struct d_info *);
 
-static struct demangle_component *
-d_expression PARAMS ((struct d_info *));
+static struct demangle_component *d_expression (struct d_info *);
 
-static struct demangle_component *
-d_expr_primary PARAMS ((struct d_info *));
+static struct demangle_component *d_expr_primary (struct d_info *);
 
-static struct demangle_component *
-d_local_name PARAMS ((struct d_info *));
+static struct demangle_component *d_local_name (struct d_info *);
 
-static int
-d_discriminator PARAMS ((struct d_info *));
+static int d_discriminator (struct d_info *);
 
 static int
-d_add_substitution PARAMS ((struct d_info *, struct demangle_component *));
+d_add_substitution (struct d_info *, struct demangle_component *);
 
-static struct demangle_component *
-d_substitution PARAMS ((struct d_info *, int));
+static struct demangle_component *d_substitution (struct d_info *, int);
 
-static void
-d_print_resize PARAMS ((struct d_print_info *, size_t));
+static void d_print_resize (struct d_print_info *, size_t);
 
-static void
-d_print_append_char PARAMS ((struct d_print_info *, int));
+static void d_print_append_char (struct d_print_info *, int);
 
 static void
-d_print_append_buffer PARAMS ((struct d_print_info *, const char *, size_t));
+d_print_append_buffer (struct d_print_info *, const char *, size_t);
 
-static void
-d_print_error PARAMS ((struct d_print_info *));
+static void d_print_error (struct d_print_info *);
 
 static void
-d_print_comp PARAMS ((struct d_print_info *,
-		      const struct demangle_component *));
+d_print_comp (struct d_print_info *, const struct demangle_component *);
 
 static void
-d_print_java_identifier PARAMS ((struct d_print_info *, const char *, int));
+d_print_java_identifier (struct d_print_info *, const char *, int);
 
 static void
-d_print_mod_list PARAMS ((struct d_print_info *, struct d_print_mod *, int));
+d_print_mod_list (struct d_print_info *, struct d_print_mod *, int);
 
 static void
-d_print_mod PARAMS ((struct d_print_info *,
-		     const struct demangle_component *));
+d_print_mod (struct d_print_info *, const struct demangle_component *);
 
 static void
-d_print_function_type PARAMS ((struct d_print_info *,
-			       const struct demangle_component *,
-			       struct d_print_mod *));
+d_print_function_type (struct d_print_info *,
+                       const struct demangle_component *,
+                       struct d_print_mod *);
 
 static void
-d_print_array_type PARAMS ((struct d_print_info *,
-			    const struct demangle_component *,
-			    struct d_print_mod *));
+d_print_array_type (struct d_print_info *,
+                    const struct demangle_component *,
+                    struct d_print_mod *);
 
 static void
-d_print_expr_op PARAMS ((struct d_print_info *,
-			 const struct demangle_component *));
+d_print_expr_op (struct d_print_info *, const struct demangle_component *);
 
 static void
-d_print_cast PARAMS ((struct d_print_info *,
-		      const struct demangle_component *));
+d_print_cast (struct d_print_info *, const struct demangle_component *);
 
-static char *
-d_demangle PARAMS ((const char *, int, size_t *));
+static char *d_demangle (const char *, int, size_t *);
 
 #ifdef CP_DEMANGLE_DEBUG
 
 static void
-d_dump (dc, indent)
-     struct demangle_component *dc;
-     int indent;
+d_dump (struct demangle_component *dc, int indent)
 {
   int i;
 
@@ -555,6 +520,9 @@ d_dump (dc, indent)
     case DEMANGLE_COMPONENT_REFTEMP:
       printf ("reference temporary\n");
       break;
+    case DEMANGLE_COMPONENT_HIDDEN_ALIAS:
+      printf ("hidden alias\n");
+      break;
     case DEMANGLE_COMPONENT_RESTRICT:
       printf ("restrict\n");
       break;
@@ -645,10 +613,7 @@ d_dump (dc, indent)
 
 CP_STATIC_IF_GLIBCPP_V3
 int
-cplus_demangle_fill_name (p, s, len)
-     struct demangle_component *p;
-     const char *s;
-     int len;
+cplus_demangle_fill_name (struct demangle_component *p, const char *s, int len)
 {
   if (p == NULL || s == NULL || len == 0)
     return 0;
@@ -662,10 +627,8 @@ cplus_demangle_fill_name (p, s, len)
 
 CP_STATIC_IF_GLIBCPP_V3
 int
-cplus_demangle_fill_extended_operator (p, args, name)
-     struct demangle_component *p;
-     int args;
-     struct demangle_component *name;
+cplus_demangle_fill_extended_operator (struct demangle_component *p, int args,
+                                       struct demangle_component *name)
 {
   if (p == NULL || args < 0 || name == NULL)
     return 0;
@@ -679,10 +642,9 @@ cplus_demangle_fill_extended_operator (p, args, name)
 
 CP_STATIC_IF_GLIBCPP_V3
 int
-cplus_demangle_fill_ctor (p, kind, name)
-     struct demangle_component *p;
-     enum gnu_v3_ctor_kinds kind;
-     struct demangle_component *name;
+cplus_demangle_fill_ctor (struct demangle_component *p,
+                          enum gnu_v3_ctor_kinds kind,
+                          struct demangle_component *name)
 {
   if (p == NULL
       || name == NULL
@@ -699,10 +661,9 @@ cplus_demangle_fill_ctor (p, kind, name)
 
 CP_STATIC_IF_GLIBCPP_V3
 int
-cplus_demangle_fill_dtor (p, kind, name)
-     struct demangle_component *p;
-     enum gnu_v3_dtor_kinds kind;
-     struct demangle_component *name;
+cplus_demangle_fill_dtor (struct demangle_component *p,
+                          enum gnu_v3_dtor_kinds kind,
+                          struct demangle_component *name)
 {
   if (p == NULL
       || name == NULL
@@ -718,8 +679,7 @@ cplus_demangle_fill_dtor (p, kind, name)
 /* Add a new component.  */
 
 static struct demangle_component *
-d_make_empty (di)
-     struct d_info *di;
+d_make_empty (struct d_info *di)
 {
   struct demangle_component *p;
 
@@ -733,11 +693,9 @@ d_make_empty (di)
 /* Add a new generic component.  */
 
 static struct demangle_component *
-d_make_comp (di, type, left, right)
-     struct d_info *di;
-     enum demangle_component_type type;
-     struct demangle_component *left;
-     struct demangle_component *right;
+d_make_comp (struct d_info *di, enum demangle_component_type type,
+             struct demangle_component *left,
+             struct demangle_component *right)
 {
   struct demangle_component *p;
 
@@ -778,6 +736,7 @@ d_make_comp (di, type, left, right)
     case DEMANGLE_COMPONENT_JAVA_CLASS:
     case DEMANGLE_COMPONENT_GUARD:
     case DEMANGLE_COMPONENT_REFTEMP:
+    case DEMANGLE_COMPONENT_HIDDEN_ALIAS:
     case DEMANGLE_COMPONENT_POINTER:
     case DEMANGLE_COMPONENT_REFERENCE:
     case DEMANGLE_COMPONENT_COMPLEX:
@@ -826,10 +785,7 @@ d_make_comp (di, type, left, right)
 /* Add a new name component.  */
 
 static struct demangle_component *
-d_make_name (di, s, len)
-     struct d_info *di;
-     const char *s;
-     int len;
+d_make_name (struct d_info *di, const char *s, int len)
 {
   struct demangle_component *p;
 
@@ -842,9 +798,8 @@ d_make_name (di, s, len)
 /* Add a new builtin type component.  */
 
 static struct demangle_component *
-d_make_builtin_type (di, type)
-     struct d_info *di;
-     const struct demangle_builtin_type_info *type;
+d_make_builtin_type (struct d_info *di,
+                     const struct demangle_builtin_type_info *type)
 {
   struct demangle_component *p;
 
@@ -862,9 +817,7 @@ d_make_builtin_type (di, type)
 /* Add a new operator component.  */
 
 static struct demangle_component *
-d_make_operator (di, op)
-     struct d_info *di;
-     const struct demangle_operator_info *op;
+d_make_operator (struct d_info *di, const struct demangle_operator_info *op)
 {
   struct demangle_component *p;
 
@@ -880,10 +833,8 @@ d_make_operator (di, op)
 /* Add a new extended operator component.  */
 
 static struct demangle_component *
-d_make_extended_operator (di, args, name)
-     struct d_info *di;
-     int args;
-     struct demangle_component *name;
+d_make_extended_operator (struct d_info *di, int args,
+                          struct demangle_component *name)
 {
   struct demangle_component *p;
 
@@ -896,10 +847,8 @@ d_make_extended_operator (di, args, name)
 /* Add a new constructor component.  */
 
 static struct demangle_component *
-d_make_ctor (di, kind,  name)
-     struct d_info *di;
-     enum gnu_v3_ctor_kinds kind;
-     struct demangle_component *name;
+d_make_ctor (struct d_info *di, enum gnu_v3_ctor_kinds kind,
+             struct demangle_component *name)
 {
   struct demangle_component *p;
 
@@ -912,10 +861,8 @@ d_make_ctor (di, kind,  name)
 /* Add a new destructor component.  */
 
 static struct demangle_component *
-d_make_dtor (di, kind, name)
-     struct d_info *di;
-     enum gnu_v3_dtor_kinds kind;
-     struct demangle_component *name;
+d_make_dtor (struct d_info *di, enum gnu_v3_dtor_kinds kind,
+             struct demangle_component *name)
 {
   struct demangle_component *p;
 
@@ -928,9 +875,7 @@ d_make_dtor (di, kind, name)
 /* Add a new template parameter.  */
 
 static struct demangle_component *
-d_make_template_param (di, i)
-     struct d_info *di;
-     long i;
+d_make_template_param (struct d_info *di, long i)
 {
   struct demangle_component *p;
 
@@ -946,10 +891,7 @@ d_make_template_param (di, i)
 /* Add a new standard substitution component.  */
 
 static struct demangle_component *
-d_make_sub (di, name, len)
-     struct d_info *di;
-     const char *name;
-     int len;
+d_make_sub (struct d_info *di, const char *name, int len)
 {
   struct demangle_component *p;
 
@@ -969,9 +911,7 @@ d_make_sub (di, name, len)
 
 CP_STATIC_IF_GLIBCPP_V3
 struct demangle_component *
-cplus_demangle_mangled_name (di, top_level)
-     struct d_info *di;
-     int top_level;
+cplus_demangle_mangled_name (struct d_info *di, int top_level)
 {
   if (d_next_char (di) != '_')
     return NULL;
@@ -990,8 +930,7 @@ cplus_demangle_mangled_name (di, top_level)
    return types.  */
 
 static int
-has_return_type (dc)
-     struct demangle_component *dc;
+has_return_type (struct demangle_component *dc)
 {
   if (dc == NULL)
     return 0;
@@ -1012,8 +951,7 @@ has_return_type (dc)
    conversion operator.  */
 
 static int
-is_ctor_dtor_or_conversion (dc)
-     struct demangle_component *dc;
+is_ctor_dtor_or_conversion (struct demangle_component *dc)
 {
   if (dc == NULL)
     return 0;
@@ -1041,9 +979,7 @@ is_ctor_dtor_or_conversion (dc)
    we would not correctly demangle names in local scopes.  */
 
 static struct demangle_component *
-d_encoding (di, top_level)
-     struct d_info *di;
-     int top_level;
+d_encoding (struct d_info *di, int top_level)
 {
   char peek = d_peek_char (di);
 
@@ -1105,8 +1041,7 @@ d_encoding (di, top_level)
 */
 
 static struct demangle_component *
-d_name (di)
-     struct d_info *di;
+d_name (struct d_info *di)
 {
   char peek = d_peek_char (di);
   struct demangle_component *dc;
@@ -1183,8 +1118,7 @@ d_name (di)
 */
 
 static struct demangle_component *
-d_nested_name (di)
-     struct d_info *di;
+d_nested_name (struct d_info *di)
 {
   struct demangle_component *ret;
   struct demangle_component **pret;
@@ -1218,8 +1152,7 @@ d_nested_name (di)
 */
 
 static struct demangle_component *
-d_prefix (di)
-     struct d_info *di;
+d_prefix (struct d_info *di)
 {
   struct demangle_component *ret = NULL;
 
@@ -1278,8 +1211,7 @@ d_prefix (di)
 */
 
 static struct demangle_component *
-d_unqualified_name (di)
-     struct d_info *di;
+d_unqualified_name (struct d_info *di)
 {
   char peek;
 
@@ -1304,8 +1236,7 @@ d_unqualified_name (di)
 /* <source-name> ::= <(positive length) number> <identifier>  */
 
 static struct demangle_component *
-d_source_name (di)
-     struct d_info *di;
+d_source_name (struct d_info *di)
 {
   long len;
   struct demangle_component *ret;
@@ -1321,8 +1252,7 @@ d_source_name (di)
 /* number ::= [n] <(non-negative decimal integer)>  */
 
 static long
-d_number (di)
-     struct d_info *di;
+d_number (struct d_info *di)
 {
   int negative;
   char peek;
@@ -1355,9 +1285,7 @@ d_number (di)
 /* identifier ::= <(unqualified source code identifier)>  */
 
 static struct demangle_component *
-d_identifier (di, len)
-     struct d_info *di;
-     int len;
+d_identifier (struct d_info *di, int len)
 {
   const char *name;
 
@@ -1460,8 +1388,7 @@ const struct demangle_operator_info cplus_demangle_operators[] =
 };
 
 static struct demangle_component *
-d_operator_name (di)
-     struct d_info *di;
+d_operator_name (struct d_info *di)
 {
   char c1;
   char c2;
@@ -1516,11 +1443,11 @@ d_operator_name (di)
                   ::= TF <type>
                   ::= TJ <type>
                   ::= GR <name>
+		  ::= GA <encoding>
 */
 
 static struct demangle_component *
-d_special_name (di)
-     struct d_info *di;
+d_special_name (struct d_info *di)
 {
   char c;
 
@@ -1607,6 +1534,10 @@ d_special_name (di)
 	  return d_make_comp (di, DEMANGLE_COMPONENT_REFTEMP, d_name (di),
 			      NULL);
 
+	case 'A':
+	  return d_make_comp (di, DEMANGLE_COMPONENT_HIDDEN_ALIAS,
+			      d_encoding (di, 0), NULL);
+
 	default:
 	  return NULL;
 	}
@@ -1629,24 +1560,19 @@ d_special_name (di)
    display it in verbose mode.  */
 
 static int
-d_call_offset (di, c)
-     struct d_info *di;
-     int c;
+d_call_offset (struct d_info *di, int c)
 {
-  long offset;
-  long virtual_offset;
-
   if (c == '\0')
     c = d_next_char (di);
 
   if (c == 'h')
-    offset = d_number (di);
+    d_number (di);
   else if (c == 'v')
     {
-      offset = d_number (di);
+      d_number (di);
       if (d_next_char (di) != '_')
 	return 0;
-      virtual_offset = d_number (di);
+      d_number (di);
     }
   else
     return 0;
@@ -1666,8 +1592,7 @@ d_call_offset (di, c)
 */
 
 static struct demangle_component *
-d_ctor_dtor_name (di)
-     struct d_info *di;
+d_ctor_dtor_name (struct d_info *di)
 {
   if (di->last_name != NULL)
     {
@@ -1748,38 +1673,39 @@ CP_STATIC_IF_GLIBCPP_V3
 const struct demangle_builtin_type_info
 cplus_demangle_builtin_types[D_BUILTIN_TYPE_COUNT] =
 {
-  /* a */ { NL ("signed char"),	NL ("signed char"),	D_PRINT_INT },
+  /* a */ { NL ("signed char"),	NL ("signed char"),	D_PRINT_DEFAULT },
   /* b */ { NL ("bool"),	NL ("boolean"),		D_PRINT_BOOL },
-  /* c */ { NL ("char"),	NL ("byte"),		D_PRINT_INT },
-  /* d */ { NL ("double"),	NL ("double"),		D_PRINT_DEFAULT },
-  /* e */ { NL ("long double"),	NL ("long double"),	D_PRINT_DEFAULT },
-  /* f */ { NL ("float"),	NL ("float"),		D_PRINT_DEFAULT },
-  /* g */ { NL ("__float128"),	NL ("__float128"),	D_PRINT_DEFAULT },
-  /* h */ { NL ("unsigned char"), NL ("unsigned char"),	D_PRINT_INT },
+  /* c */ { NL ("char"),	NL ("byte"),		D_PRINT_DEFAULT },
+  /* d */ { NL ("double"),	NL ("double"),		D_PRINT_FLOAT },
+  /* e */ { NL ("long double"),	NL ("long double"),	D_PRINT_FLOAT },
+  /* f */ { NL ("float"),	NL ("float"),		D_PRINT_FLOAT },
+  /* g */ { NL ("__float128"),	NL ("__float128"),	D_PRINT_FLOAT },
+  /* h */ { NL ("unsigned char"), NL ("unsigned char"),	D_PRINT_DEFAULT },
   /* i */ { NL ("int"),		NL ("int"),		D_PRINT_INT },
-  /* j */ { NL ("unsigned int"), NL ("unsigned"),	D_PRINT_INT },
+  /* j */ { NL ("unsigned int"), NL ("unsigned"),	D_PRINT_UNSIGNED },
   /* k */ { NULL, 0,		NULL, 0,		D_PRINT_DEFAULT },
   /* l */ { NL ("long"),	NL ("long"),		D_PRINT_LONG },
-  /* m */ { NL ("unsigned long"), NL ("unsigned long"),	D_PRINT_LONG },
+  /* m */ { NL ("unsigned long"), NL ("unsigned long"),	D_PRINT_UNSIGNED_LONG },
   /* n */ { NL ("__int128"),	NL ("__int128"),	D_PRINT_DEFAULT },
-  /* o */ { NL ("unsigned __int128"), NL ("unsigned __int128"),	D_PRINT_DEFAULT },
+  /* o */ { NL ("unsigned __int128"), NL ("unsigned __int128"),
+	    D_PRINT_DEFAULT },
   /* p */ { NULL, 0,		NULL, 0,		D_PRINT_DEFAULT },
   /* q */ { NULL, 0,		NULL, 0,		D_PRINT_DEFAULT },
   /* r */ { NULL, 0,		NULL, 0,		D_PRINT_DEFAULT },
-  /* s */ { NL ("short"),	NL ("short"),		D_PRINT_INT },
-  /* t */ { NL ("unsigned short"), NL ("unsigned short"), D_PRINT_INT },
+  /* s */ { NL ("short"),	NL ("short"),		D_PRINT_DEFAULT },
+  /* t */ { NL ("unsigned short"), NL ("unsigned short"), D_PRINT_DEFAULT },
   /* u */ { NULL, 0,		NULL, 0,		D_PRINT_DEFAULT },
   /* v */ { NL ("void"),	NL ("void"),		D_PRINT_VOID },
-  /* w */ { NL ("wchar_t"),	NL ("char"),		D_PRINT_INT },
-  /* x */ { NL ("long long"),	NL ("long"),		D_PRINT_DEFAULT },
-  /* y */ { NL ("unsigned long long"), NL ("unsigned long long"), D_PRINT_DEFAULT },
+  /* w */ { NL ("wchar_t"),	NL ("char"),		D_PRINT_DEFAULT },
+  /* x */ { NL ("long long"),	NL ("long"),		D_PRINT_LONG_LONG },
+  /* y */ { NL ("unsigned long long"), NL ("unsigned long long"),
+	    D_PRINT_UNSIGNED_LONG_LONG },
   /* z */ { NL ("..."),		NL ("..."),		D_PRINT_DEFAULT },
 };
 
 CP_STATIC_IF_GLIBCPP_V3
 struct demangle_component *
-cplus_demangle_type (di)
-     struct d_info *di;
+cplus_demangle_type (struct d_info *di)
 {
   char peek;
   struct demangle_component *ret;
@@ -1948,10 +1874,8 @@ cplus_demangle_type (di)
 /* <CV-qualifiers> ::= [r] [V] [K]  */
 
 static struct demangle_component **
-d_cv_qualifiers (di, pret, member_fn)
-     struct d_info *di;
-     struct demangle_component **pret;
-     int member_fn;
+d_cv_qualifiers (struct d_info *di,
+                 struct demangle_component **pret, int member_fn)
 {
   char peek;
 
@@ -1997,8 +1921,7 @@ d_cv_qualifiers (di, pret, member_fn)
 /* <function-type> ::= F [Y] <bare-function-type> E  */
 
 static struct demangle_component *
-d_function_type (di)
-     struct d_info *di;
+d_function_type (struct d_info *di)
 {
   struct demangle_component *ret;
 
@@ -2019,9 +1942,7 @@ d_function_type (di)
 /* <bare-function-type> ::= <type>+  */
 
 static struct demangle_component *
-d_bare_function_type (di, has_return_type)
-     struct d_info *di;
-     int has_return_type;
+d_bare_function_type (struct d_info *di, int has_return_type)
 {
   struct demangle_component *return_type;
   struct demangle_component *tl;
@@ -2076,8 +1997,7 @@ d_bare_function_type (di, has_return_type)
 /* <class-enum-type> ::= <name>  */
 
 static struct demangle_component *
-d_class_enum_type (di)
-     struct d_info *di;
+d_class_enum_type (struct d_info *di)
 {
   return d_name (di);
 }
@@ -2087,8 +2007,7 @@ d_class_enum_type (di)
 */
 
 static struct demangle_component *
-d_array_type (di)
-     struct d_info *di;
+d_array_type (struct d_info *di)
 {
   char peek;
   struct demangle_component *dim;
@@ -2131,8 +2050,7 @@ d_array_type (di)
 /* <pointer-to-member-type> ::= M <(class) type> <(member) type>  */
 
 static struct demangle_component *
-d_pointer_to_member_type (di)
-     struct d_info *di;
+d_pointer_to_member_type (struct d_info *di)
 {
   struct demangle_component *cl;
   struct demangle_component *mem;
@@ -2169,8 +2087,7 @@ d_pointer_to_member_type (di)
 */
 
 static struct demangle_component *
-d_template_param (di)
-     struct d_info *di;
+d_template_param (struct d_info *di)
 {
   long param;
 
@@ -2198,8 +2115,7 @@ d_template_param (di)
 /* <template-args> ::= I <template-arg>+ E  */
 
 static struct demangle_component *
-d_template_args (di)
-     struct d_info *di;
+d_template_args (struct d_info *di)
 {
   struct demangle_component *hold_last_name;
   struct demangle_component *al;
@@ -2246,8 +2162,7 @@ d_template_args (di)
 */
 
 static struct demangle_component *
-d_template_arg (di)
-     struct d_info *di;
+d_template_arg (struct d_info *di)
 {
   struct demangle_component *ret;
 
@@ -2279,8 +2194,7 @@ d_template_arg (di)
 */
 
 static struct demangle_component *
-d_expression (di)
-     struct d_info *di;
+d_expression (struct d_info *di)
 {
   char peek;
 
@@ -2380,8 +2294,7 @@ d_expression (di)
 */
 
 static struct demangle_component *
-d_expr_primary (di)
-     struct d_info *di;
+d_expr_primary (struct d_info *di)
 {
   struct demangle_component *ret;
 
@@ -2396,6 +2309,8 @@ d_expr_primary (di)
       const char *s;
 
       type = cplus_demangle_type (di);
+      if (type == NULL)
+	return NULL;
 
       /* If we have a type we know how to print, we aren't going to
 	 print the type name itself.  */
@@ -2422,7 +2337,11 @@ d_expr_primary (di)
 	}
       s = d_str (di);
       while (d_peek_char (di) != 'E')
-	d_advance (di, 1);
+	{
+	  if (d_peek_char (di) == '\0')
+	    return NULL;
+	  d_advance (di, 1);
+	}
       ret = d_make_comp (di, t, type, d_make_name (di, s, d_str (di) - s));
     }
   if (d_next_char (di) != 'E')
@@ -2435,8 +2354,7 @@ d_expr_primary (di)
 */
 
 static struct demangle_component *
-d_local_name (di)
-     struct d_info *di;
+d_local_name (struct d_info *di)
 {
   struct demangle_component *function;
 
@@ -2474,8 +2392,7 @@ d_local_name (di)
    We should print it out in verbose mode.  */
 
 static int
-d_discriminator (di)
-     struct d_info *di;
+d_discriminator (struct d_info *di)
 {
   long discrim;
 
@@ -2491,9 +2408,7 @@ d_discriminator (di)
 /* Add a new substitution.  */
 
 static int
-d_add_substitution (di, dc)
-     struct d_info *di;
-     struct demangle_component *dc;
+d_add_substitution (struct d_info *di, struct demangle_component *dc)
 {
   if (dc == NULL)
     return 0;
@@ -2549,9 +2464,7 @@ static const struct d_standard_sub_info standard_subs[] =
 };
 
 static struct demangle_component *
-d_substitution (di, prefix)
-     struct d_info *di;
-     int prefix;
+d_substitution (struct d_info *di, int prefix)
 {
   char c;
 
@@ -2638,9 +2551,7 @@ d_substitution (di, prefix)
 /* Resize the print buffer.  */
 
 static void
-d_print_resize (dpi, add)
-     struct d_print_info *dpi;
-     size_t add;
+d_print_resize (struct d_print_info *dpi, size_t add)
 {
   size_t need;
 
@@ -2653,7 +2564,7 @@ d_print_resize (dpi, add)
       char *newbuf;
 
       newalc = dpi->alc * 2;
-      newbuf = realloc (dpi->buf, newalc);
+      newbuf = (char *) realloc (dpi->buf, newalc);
       if (newbuf == NULL)
 	{
 	  free (dpi->buf);
@@ -2669,9 +2580,7 @@ d_print_resize (dpi, add)
 /* Append a character to the print buffer.  */
 
 static void
-d_print_append_char (dpi, c)
-     struct d_print_info *dpi;
-     int c;
+d_print_append_char (struct d_print_info *dpi, int c)
 {
   if (dpi->buf != NULL)
     {
@@ -2690,10 +2599,7 @@ d_print_append_char (dpi, c)
 /* Append a buffer to the print buffer.  */
 
 static void
-d_print_append_buffer (dpi, s, l)
-     struct d_print_info *dpi;
-     const char *s;
-     size_t l;
+d_print_append_buffer (struct d_print_info *dpi, const char *s, size_t l)
 {
   if (dpi->buf != NULL)
     {
@@ -2712,8 +2618,7 @@ d_print_append_buffer (dpi, s, l)
 /* Indicate that an error occurred during printing.  */
 
 static void
-d_print_error (dpi)
-     struct d_print_info *dpi;
+d_print_error (struct d_print_info *dpi)
 {
   free (dpi->buf);
   dpi->buf = NULL;
@@ -2729,18 +2634,15 @@ d_print_error (dpi)
 
 CP_STATIC_IF_GLIBCPP_V3
 char *
-cplus_demangle_print (options, dc, estimate, palc)
-     int options;
-     const struct demangle_component *dc;
-     int estimate;
-     size_t *palc;
+cplus_demangle_print (int options, const struct demangle_component *dc,
+                      int estimate, size_t *palc)
 {
   struct d_print_info dpi;
 
   dpi.options = options;
 
   dpi.alc = estimate + 1;
-  dpi.buf = malloc (dpi.alc);
+  dpi.buf = (char *) malloc (dpi.alc);
   if (dpi.buf == NULL)
     {
       *palc = 1;
@@ -2768,9 +2670,8 @@ cplus_demangle_print (options, dc, estimate, palc)
 /* Subroutine to handle components.  */
 
 static void
-d_print_comp (dpi, dc)
-     struct d_print_info *dpi;
-     const struct demangle_component *dc;
+d_print_comp (struct d_print_info *dpi,
+              const struct demangle_component *dc)
 {
   if (dc == NULL)
     {
@@ -2842,7 +2743,7 @@ d_print_comp (dpi, dc)
 	  {
 	    dpt.next = dpi->templates;
 	    dpi->templates = &dpt;
-	    dpt.template = typed_name;
+	    dpt.template_decl = typed_name;
 	  }
 
 	/* If typed_name is a DEMANGLE_COMPONENT_LOCAL_NAME, then
@@ -2938,7 +2839,7 @@ d_print_comp (dpi, dc)
 	    return;
 	  }
 	i = dc->u.s_number.number;
-	for (a = d_right (dpi->templates->template);
+	for (a = d_right (dpi->templates->template_decl);
 	     a != NULL;
 	     a = d_right (a))
 	  {
@@ -3043,6 +2944,11 @@ d_print_comp (dpi, dc)
       d_print_comp (dpi, d_left (dc));
       return;
 
+    case DEMANGLE_COMPONENT_HIDDEN_ALIAS:
+      d_append_string_constant (dpi, "hidden alias for ");
+      d_print_comp (dpi, d_left (dc));
+      return;
+
     case DEMANGLE_COMPONENT_SUB_STD:
       d_append_buffer (dpi, dc->u.s_string.string, dc->u.s_string.len);
       return;
@@ -3050,6 +2956,30 @@ d_print_comp (dpi, dc)
     case DEMANGLE_COMPONENT_RESTRICT:
     case DEMANGLE_COMPONENT_VOLATILE:
     case DEMANGLE_COMPONENT_CONST:
+      {
+	struct d_print_mod *pdpm;
+
+	/* When printing arrays, it's possible to have cases where the
+	   same CV-qualifier gets pushed on the stack multiple times.
+	   We only need to print it once.  */
+
+	for (pdpm = dpi->modifiers; pdpm != NULL; pdpm = pdpm->next)
+	  {
+	    if (! pdpm->printed)
+	      {
+		if (pdpm->mod->type != DEMANGLE_COMPONENT_RESTRICT
+		    && pdpm->mod->type != DEMANGLE_COMPONENT_VOLATILE
+		    && pdpm->mod->type != DEMANGLE_COMPONENT_CONST)
+		  break;
+		if (pdpm->mod->type == dc->type)
+		  {
+		    d_print_comp (dpi, d_left (dc));
+		    return;
+		  }
+	      }
+	  }
+      }
+      /* Fall through.  */
     case DEMANGLE_COMPONENT_RESTRICT_THIS:
     case DEMANGLE_COMPONENT_VOLATILE_THIS:
     case DEMANGLE_COMPONENT_CONST_THIS:
@@ -3125,24 +3055,65 @@ d_print_comp (dpi, dc)
 
     case DEMANGLE_COMPONENT_ARRAY_TYPE:
       {
-	struct d_print_mod dpm;
+	struct d_print_mod *hold_modifiers;
+	struct d_print_mod adpm[4];
+	unsigned int i;
+	struct d_print_mod *pdpm;
 
 	/* We must pass this type down as a modifier in order to print
-	   multi-dimensional arrays correctly.  */
+	   multi-dimensional arrays correctly.  If the array itself is
+	   CV-qualified, we act as though the element type were
+	   CV-qualified.  We do this by copying the modifiers down
+	   rather than fiddling pointers, so that we don't wind up
+	   with a d_print_mod higher on the stack pointing into our
+	   stack frame after we return.  */
 
-	dpm.next = dpi->modifiers;
-	dpi->modifiers = &dpm;
-	dpm.mod = dc;
-	dpm.printed = 0;
-	dpm.templates = dpi->templates;
+	hold_modifiers = dpi->modifiers;
+
+	adpm[0].next = hold_modifiers;
+	dpi->modifiers = &adpm[0];
+	adpm[0].mod = dc;
+	adpm[0].printed = 0;
+	adpm[0].templates = dpi->templates;
+
+	i = 1;
+	pdpm = hold_modifiers;
+	while (pdpm != NULL
+	       && (pdpm->mod->type == DEMANGLE_COMPONENT_RESTRICT
+		   || pdpm->mod->type == DEMANGLE_COMPONENT_VOLATILE
+		   || pdpm->mod->type == DEMANGLE_COMPONENT_CONST))
+	  {
+	    if (! pdpm->printed)
+	      {
+		if (i >= sizeof adpm / sizeof adpm[0])
+		  {
+		    d_print_error (dpi);
+		    return;
+		  }
+
+		adpm[i] = *pdpm;
+		adpm[i].next = dpi->modifiers;
+		dpi->modifiers = &adpm[i];
+		pdpm->printed = 1;
+		++i;
+	      }
+
+	    pdpm = pdpm->next;
+	  }
 
 	d_print_comp (dpi, d_right (dc));
 
-	dpi->modifiers = dpm.next;
+	dpi->modifiers = hold_modifiers;
 
-	if (dpm.printed)
+	if (adpm[0].printed)
 	  return;
 
+	while (i > 1)
+	  {
+	    --i;
+	    d_print_mod (dpi, adpm[i].mod);
+	  }
+
 	d_print_array_type (dpi, dc, dpi->modifiers);
 
 	return;
@@ -3212,15 +3183,13 @@ d_print_comp (dpi, dc)
 	d_print_expr_op (dpi, d_left (dc));
       else
 	{
-	  d_append_string_constant (dpi, "((");
+	  d_append_char (dpi, '(');
 	  d_print_cast (dpi, d_left (dc));
 	  d_append_char (dpi, ')');
 	}
       d_append_char (dpi, '(');
       d_print_comp (dpi, d_right (dc));
       d_append_char (dpi, ')');
-      if (d_left (dc)->type == DEMANGLE_COMPONENT_CAST)
-	d_append_char (dpi, ')');
       return;
 
     case DEMANGLE_COMPONENT_BINARY:
@@ -3284,62 +3253,86 @@ d_print_comp (dpi, dc)
 
     case DEMANGLE_COMPONENT_LITERAL:
     case DEMANGLE_COMPONENT_LITERAL_NEG:
-      /* For some builtin types, produce simpler output.  */
-      if (d_left (dc)->type == DEMANGLE_COMPONENT_BUILTIN_TYPE)
-	{
-	  switch (d_left (dc)->u.s_builtin.type->print)
-	    {
-	    case D_PRINT_INT:
-	      if (d_right (dc)->type == DEMANGLE_COMPONENT_NAME)
-		{
-		  if (dc->type == DEMANGLE_COMPONENT_LITERAL_NEG)
-		    d_append_char (dpi, '-');
-		  d_print_comp (dpi, d_right (dc));
-		  return;
-		}
-	      break;
+      {
+	enum d_builtin_type_print tp;
 
-	    case D_PRINT_LONG:
-	      if (d_right (dc)->type == DEMANGLE_COMPONENT_NAME)
-		{
-		  if (dc->type == DEMANGLE_COMPONENT_LITERAL_NEG)
-		    d_append_char (dpi, '-');
-		  d_print_comp (dpi, d_right (dc));
-		  d_append_char (dpi, 'l');
-		  return;
-		}
-	      break;
+	/* For some builtin types, produce simpler output.  */
+	tp = D_PRINT_DEFAULT;
+	if (d_left (dc)->type == DEMANGLE_COMPONENT_BUILTIN_TYPE)
+	  {
+	    tp = d_left (dc)->u.s_builtin.type->print;
+	    switch (tp)
+	      {
+	      case D_PRINT_INT:
+	      case D_PRINT_UNSIGNED:
+	      case D_PRINT_LONG:
+	      case D_PRINT_UNSIGNED_LONG:
+	      case D_PRINT_LONG_LONG:
+	      case D_PRINT_UNSIGNED_LONG_LONG:
+		if (d_right (dc)->type == DEMANGLE_COMPONENT_NAME)
+		  {
+		    if (dc->type == DEMANGLE_COMPONENT_LITERAL_NEG)
+		      d_append_char (dpi, '-');
+		    d_print_comp (dpi, d_right (dc));
+		    switch (tp)
+		      {
+		      default:
+			break;
+		      case D_PRINT_UNSIGNED:
+			d_append_char (dpi, 'u');
+			break;
+		      case D_PRINT_LONG:
+			d_append_char (dpi, 'l');
+			break;
+		      case D_PRINT_UNSIGNED_LONG:
+			d_append_string_constant (dpi, "ul");
+			break;
+		      case D_PRINT_LONG_LONG:
+			d_append_string_constant (dpi, "ll");
+			break;
+		      case D_PRINT_UNSIGNED_LONG_LONG:
+			d_append_string_constant (dpi, "ull");
+			break;
+		      }
+		    return;
+		  }
+		break;
 
-	    case D_PRINT_BOOL:
-	      if (d_right (dc)->type == DEMANGLE_COMPONENT_NAME
-		  && d_right (dc)->u.s_name.len == 1
-		  && dc->type == DEMANGLE_COMPONENT_LITERAL)
-		{
-		  switch (d_right (dc)->u.s_name.s[0])
-		    {
-		    case '0':
-		      d_append_string_constant (dpi, "false");
-		      return;
-		    case '1':
-		      d_append_string_constant (dpi, "true");
-		      return;
-		    default:
-		      break;
-		    }
-		}
-	      break;
+	      case D_PRINT_BOOL:
+		if (d_right (dc)->type == DEMANGLE_COMPONENT_NAME
+		    && d_right (dc)->u.s_name.len == 1
+		    && dc->type == DEMANGLE_COMPONENT_LITERAL)
+		  {
+		    switch (d_right (dc)->u.s_name.s[0])
+		      {
+		      case '0':
+			d_append_string_constant (dpi, "false");
+			return;
+		      case '1':
+			d_append_string_constant (dpi, "true");
+			return;
+		      default:
+			break;
+		      }
+		  }
+		break;
 
-	    default:
-	      break;
-	    }
-	}
+	      default:
+		break;
+	      }
+	  }
 
-      d_append_char (dpi, '(');
-      d_print_comp (dpi, d_left (dc));
-      d_append_char (dpi, ')');
-      if (dc->type == DEMANGLE_COMPONENT_LITERAL_NEG)
-	d_append_char (dpi, '-');
-      d_print_comp (dpi, d_right (dc));
+	d_append_char (dpi, '(');
+	d_print_comp (dpi, d_left (dc));
+	d_append_char (dpi, ')');
+	if (dc->type == DEMANGLE_COMPONENT_LITERAL_NEG)
+	  d_append_char (dpi, '-');
+	if (tp == D_PRINT_FLOAT)
+	  d_append_char (dpi, '[');
+	d_print_comp (dpi, d_right (dc));
+	if (tp == D_PRINT_FLOAT)
+	  d_append_char (dpi, ']');
+      }
       return;
 
     default:
@@ -3354,10 +3347,7 @@ d_print_comp (dpi, dc)
    __U<hex-char>+_.  */
 
 static void
-d_print_java_identifier (dpi, name, len)
-     struct d_print_info *dpi;
-     const char *name;
-     int len;
+d_print_java_identifier (struct d_print_info *dpi, const char *name, int len)
 {
   const char *p;
   const char *end;
@@ -3407,10 +3397,8 @@ d_print_java_identifier (dpi, name, len)
    qualifiers on this after printing a function.  */
 
 static void
-d_print_mod_list (dpi, mods, suffix)
-     struct d_print_info *dpi;
-     struct d_print_mod *mods;
-     int suffix;
+d_print_mod_list (struct d_print_info *dpi,
+                  struct d_print_mod *mods, int suffix)
 {
   struct d_print_template *hold_dpt;
 
@@ -3486,9 +3474,8 @@ d_print_mod_list (dpi, mods, suffix)
 /* Print a modifier.  */
 
 static void
-d_print_mod (dpi, mod)
-     struct d_print_info *dpi;
-     const struct demangle_component *mod;
+d_print_mod (struct d_print_info *dpi,
+             const struct demangle_component *mod)
 {
   switch (mod->type)
     {
@@ -3542,18 +3529,19 @@ d_print_mod (dpi, mod)
 /* Print a function type, except for the return type.  */
 
 static void
-d_print_function_type (dpi, dc, mods)
-     struct d_print_info *dpi;
-     const struct demangle_component *dc;
-     struct d_print_mod *mods;
+d_print_function_type (struct d_print_info *dpi,
+                       const struct demangle_component *dc,
+                       struct d_print_mod *mods)
 {
   int need_paren;
   int saw_mod;
+  int need_space;
   struct d_print_mod *p;
   struct d_print_mod *hold_modifiers;
 
   need_paren = 0;
   saw_mod = 0;
+  need_space = 0;
   for (p = mods; p != NULL; p = p->next)
     {
       if (p->printed)
@@ -3562,15 +3550,18 @@ d_print_function_type (dpi, dc, mods)
       saw_mod = 1;
       switch (p->mod->type)
 	{
+	case DEMANGLE_COMPONENT_POINTER:
+	case DEMANGLE_COMPONENT_REFERENCE:
+	  need_paren = 1;
+	  break;
 	case DEMANGLE_COMPONENT_RESTRICT:
 	case DEMANGLE_COMPONENT_VOLATILE:
 	case DEMANGLE_COMPONENT_CONST:
 	case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
-	case DEMANGLE_COMPONENT_POINTER:
-	case DEMANGLE_COMPONENT_REFERENCE:
 	case DEMANGLE_COMPONENT_COMPLEX:
 	case DEMANGLE_COMPONENT_IMAGINARY:
 	case DEMANGLE_COMPONENT_PTRMEM_TYPE:
+	  need_space = 1;
 	  need_paren = 1;
 	  break;
 	case DEMANGLE_COMPONENT_RESTRICT_THIS:
@@ -3589,18 +3580,14 @@ d_print_function_type (dpi, dc, mods)
 
   if (need_paren)
     {
-      switch (d_last_char (dpi))
+      if (! need_space)
 	{
-	case ' ':
-	case '(':
-	case '*':
-	  break;
-
-	default:
-	  d_append_char (dpi, ' ');
-	  break;
+	  if (d_last_char (dpi) != '('
+	      && d_last_char (dpi) != '*')
+	    need_space = 1;
 	}
-
+      if (need_space && d_last_char (dpi) != ' ')
+	d_append_char (dpi, ' ');
       d_append_char (dpi, '(');
     }
 
@@ -3627,10 +3614,9 @@ d_print_function_type (dpi, dc, mods)
 /* Print an array type, except for the element type.  */
 
 static void
-d_print_array_type (dpi, dc, mods)
-     struct d_print_info *dpi;
-     const struct demangle_component *dc;
-     struct d_print_mod *mods;
+d_print_array_type (struct d_print_info *dpi,
+                    const struct demangle_component *dc,
+                    struct d_print_mod *mods)
 {
   int need_space;
 
@@ -3643,19 +3629,19 @@ d_print_array_type (dpi, dc, mods)
       need_paren = 0;
       for (p = mods; p != NULL; p = p->next)
 	{
-	  if (p->printed)
-	    break;
-
-	  if (p->mod->type == DEMANGLE_COMPONENT_ARRAY_TYPE)
-	    {
-	      need_space = 0;
-	      break;
-	    }
-	  else
+	  if (! p->printed)
 	    {
-	      need_paren = 1;
-	      need_space = 1;
-	      break;
+	      if (p->mod->type == DEMANGLE_COMPONENT_ARRAY_TYPE)
+		{
+		  need_space = 0;
+		  break;
+		}
+	      else
+		{
+		  need_paren = 1;
+		  need_space = 1;
+		  break;
+		}
 	    }
 	}
 
@@ -3682,9 +3668,8 @@ d_print_array_type (dpi, dc, mods)
 /* Print an operator in an expression.  */
 
 static void
-d_print_expr_op (dpi, dc)
-     struct d_print_info *dpi;
-     const struct demangle_component *dc;
+d_print_expr_op (struct d_print_info *dpi,
+                 const struct demangle_component *dc)
 {
   if (dc->type == DEMANGLE_COMPONENT_OPERATOR)
     d_append_buffer (dpi, dc->u.s_operator.op->name,
@@ -3696,9 +3681,8 @@ d_print_expr_op (dpi, dc)
 /* Print a cast.  */
 
 static void
-d_print_cast (dpi, dc)
-     struct d_print_info *dpi;
-     const struct demangle_component *dc;
+d_print_cast (struct d_print_info *dpi,
+              const struct demangle_component *dc)
 {
   if (d_left (dc)->type != DEMANGLE_COMPONENT_TEMPLATE)
     d_print_comp (dpi, d_left (dc));
@@ -3717,7 +3701,7 @@ d_print_cast (dpi, dc)
 
       dpt.next = dpi->templates;
       dpi->templates = &dpt;
-      dpt.template = d_left (dc);
+      dpt.template_decl = d_left (dc);
 
       d_print_comp (dpi, d_left (d_left (dc)));
 
@@ -3742,11 +3726,8 @@ d_print_cast (dpi, dc)
 
 CP_STATIC_IF_GLIBCPP_V3
 void
-cplus_demangle_init_info (mangled, options, len, di)
-     const char *mangled;
-     int options;
-     size_t len;
-     struct d_info *di;
+cplus_demangle_init_info (const char *mangled, int options, size_t len,
+                          struct d_info *di)
 {
   di->s = mangled;
   di->send = mangled + len;
@@ -3779,10 +3760,7 @@ cplus_demangle_init_info (mangled, options, len, di)
    a memory allocation failure.  On failure, this returns NULL.  */
 
 static char *
-d_demangle (mangled, options, palc)
-     const char* mangled;
-     int options;
-     size_t *palc;
+d_demangle (const char* mangled, int options, size_t *palc)
 {
   size_t len;
   int type;
@@ -3804,7 +3782,7 @@ d_demangle (mangled, options, palc)
     {
       char *r;
 
-      r = malloc (40 + len - 11);
+      r = (char *) malloc (40 + len - 11);
       if (r == NULL)
 	*palc = 1;
       else
@@ -3906,7 +3884,7 @@ d_demangle (mangled, options, palc)
 
 #if defined(IN_LIBGCC2) || defined(IN_GLIBCPP_V3)
 
-extern char *__cxa_demangle PARAMS ((const char *, char *, size_t *, int *));
+extern char *__cxa_demangle (const char *, char *, size_t *, int *);
 
 /* ia64 ABI-mandated entry point in the C++ runtime library for
    performing demangling.  MANGLED_NAME is a NUL-terminated character
@@ -3935,38 +3913,37 @@ extern char *__cxa_demangle PARAMS ((const char *, char *, size_t *, int *));
    GNU extensions.  */
 
 char *
-__cxa_demangle (mangled_name, output_buffer, length, status)
-     const char *mangled_name;
-     char *output_buffer;
-     size_t *length;
-     int *status;
+__cxa_demangle (const char *mangled_name, char *output_buffer,
+                size_t *length, int *status)
 {
   char *demangled;
   size_t alc;
 
-  if (status == NULL)
-    return NULL;
-
   if (mangled_name == NULL)
     {
-      *status = -3;
+      if (status != NULL)
+	*status = -3;
       return NULL;
     }
 
   if (output_buffer != NULL && length == NULL)
     {
-      *status = -3;
+      if (status != NULL)
+	*status = -3;
       return NULL;
     }
 
-  demangled = d_demangle (mangled_name, DMGL_TYPES, &alc);
+  demangled = d_demangle (mangled_name, DMGL_PARAMS | DMGL_TYPES, &alc);
 
   if (demangled == NULL)
     {
-      if (alc == 1)
-	*status = -1;
-      else
-	*status = -2;
+      if (status != NULL)
+	{
+	  if (alc == 1)
+	    *status = -1;
+	  else
+	    *status = -2;
+	}
       return NULL;
     }
 
@@ -3990,7 +3967,8 @@ __cxa_demangle (mangled_name, output_buffer, length, status)
 	}
     }
 
-  *status = 0;
+  if (status != NULL)
+    *status = 0;
 
   return demangled;
 }
@@ -4002,9 +3980,7 @@ __cxa_demangle (mangled_name, output_buffer, length, status)
    demangled name.  Otherwise, return NULL.  */
 
 char *
-cplus_demangle_v3 (mangled, options)
-     const char* mangled;
-     int options;
+cplus_demangle_v3 (const char* mangled, int options)
 {
   size_t alc;
 
@@ -4019,8 +3995,7 @@ cplus_demangle_v3 (mangled, options)
    of JArray<TYPE> with TYPE[].  */
 
 char *
-java_demangle_v3 (mangled)
-     const char* mangled;
+java_demangle_v3 (const char* mangled)
 {
   size_t alc;
   char *demangled;
@@ -4070,10 +4045,9 @@ java_demangle_v3 (mangled)
    *DTOR_KIND appropriately.  */
 
 static int
-is_ctor_or_dtor (mangled, ctor_kind, dtor_kind)
-     const char *mangled;
-     enum gnu_v3_ctor_kinds *ctor_kind;
-     enum gnu_v3_dtor_kinds *dtor_kind;
+is_ctor_or_dtor (const char *mangled,
+                 enum gnu_v3_ctor_kinds *ctor_kind,
+                 enum gnu_v3_dtor_kinds *dtor_kind)
 {
   struct d_info di;
   struct demangle_component *dc;
@@ -4156,8 +4130,7 @@ is_ctor_or_dtor (mangled, ctor_kind, dtor_kind)
    name.  A non-zero return indicates the type of constructor.  */
 
 enum gnu_v3_ctor_kinds
-is_gnu_v3_mangled_ctor (name)
-     const char *name;
+is_gnu_v3_mangled_ctor (const char *name)
 {
   enum gnu_v3_ctor_kinds ctor_kind;
   enum gnu_v3_dtor_kinds dtor_kind;
@@ -4172,8 +4145,7 @@ is_gnu_v3_mangled_ctor (name)
    name.  A non-zero return indicates the type of destructor.  */
 
 enum gnu_v3_dtor_kinds
-is_gnu_v3_mangled_dtor (name)
-     const char *name;
+is_gnu_v3_mangled_dtor (const char *name)
 {
   enum gnu_v3_ctor_kinds ctor_kind;
   enum gnu_v3_dtor_kinds dtor_kind;
@@ -4190,7 +4162,7 @@ is_gnu_v3_mangled_dtor (name)
 #include "getopt.h"
 #include "dyn-string.h"
 
-static void print_usage PARAMS ((FILE* fp, int exit_value));
+static void print_usage (FILE* fp, int exit_value);
 
 #define IS_ALPHA(CHAR)                                                  \
   (((CHAR) >= 'a' && (CHAR) <= 'z')                                     \
@@ -4207,9 +4179,7 @@ const char* program_name;
 /* Prints usage summary to FP and then exits with EXIT_VALUE.  */
 
 static void
-print_usage (fp, exit_value)
-     FILE* fp;
-     int exit_value;
+print_usage (FILE* fp, int exit_value)
 {
   fprintf (fp, "Usage: %s [options] [names ...]\n", program_name);
   fprintf (fp, "Options:\n");
@@ -4236,9 +4206,7 @@ static const struct option long_options[] =
    with their demangled equivalents.  */
 
 int
-main (argc, argv)
-     int argc;
-     char *argv[];
+main (int argc, char *argv[])
 {
   int i;
   int opt_char;
@@ -4296,7 +4264,11 @@ main (argc, argv)
 
 	  if (dyn_string_length (mangled) > 0)
 	    {
+#ifdef IN_GLIBCPP_V3
+	      s = __cxa_demangle (dyn_string_buf (mangled), NULL, NULL, NULL);
+#else
 	      s = cplus_demangle_v3 (dyn_string_buf (mangled), options);
+#endif
 
 	      if (s != NULL)
 		{
@@ -4328,9 +4300,16 @@ main (argc, argv)
       for (i = optind; i < argc; ++i)
 	{
 	  char *s;
+#ifdef IN_GLIBCPP_V3
+	  int status;
+#endif
 
 	  /* Attempt to demangle.  */
+#ifdef IN_GLIBCPP_V3
+	  s = __cxa_demangle (argv[i], NULL, NULL, &status);
+#else
 	  s = cplus_demangle_v3 (argv[i], options);
+#endif
 
 	  /* If it worked, print the demangled name.  */
 	  if (s != NULL)
@@ -4339,7 +4318,13 @@ main (argc, argv)
 	      free (s);
 	    }
 	  else
-	    fprintf (stderr, "Failed: %s\n", argv[i]);
+	    {
+#ifdef IN_GLIBCPP_V3
+	      fprintf (stderr, "Failed: %s (status %d)\n", argv[i], status);
+#else
+	      fprintf (stderr, "Failed: %s\n", argv[i]);
+#endif
+	    }
 	}
     }