X-Git-Url: http://git.sourceforge.jp/view?p=pf3gnuchains%2Fgcc-fork.git;a=blobdiff_plain;f=libiberty%2Fcp-demangle.c;h=ac1dfe56071a207dc0fdd29fcf6d25470ad0cb80;hp=47ec0956fb26b06fb83157aba250778144f44a5c;hb=b785de4a32d5e0cfc9052d44bbcb8c48dc1b2946;hpb=1649ae17b74bd50a248a0cdeff23bf7017db5aae

diff --git a/libiberty/cp-demangle.c b/libiberty/cp-demangle.c
index 47ec0956fb2..ac1dfe56071 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,13 +911,11 @@ 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) != '_')
+  if (! d_check_char (di, '_'))
     return NULL;
-  if (d_next_char (di) != 'Z')
+  if (! d_check_char (di, 'Z'))
     return NULL;
   return d_encoding (di, top_level);
 }
@@ -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,13 +1118,12 @@ 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;
 
-  if (d_next_char (di) != 'N')
+  if (! d_check_char (di, 'N'))
     return NULL;
 
   pret = d_cv_qualifiers (di, &ret, 1);
@@ -1200,7 +1134,7 @@ d_nested_name (di)
   if (*pret == NULL)
     return NULL;
 
-  if (d_next_char (di) != 'E')
+  if (! d_check_char (di, 'E'))
     return NULL;
 
   return ret;
@@ -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,17 +1443,14 @@ 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;
-
   di->expansion += 20;
-  c = d_next_char (di);
-  if (c == 'T')
+  if (d_check_char (di, 'T'))
     {
       switch (d_next_char (di))
 	{
@@ -1575,7 +1499,7 @@ d_special_name (di)
 	    offset = d_number (di);
 	    if (offset < 0)
 	      return NULL;
-	    if (d_next_char (di) != '_')
+	    if (! d_check_char (di, '_'))
 	      return NULL;
 	    base_type = cplus_demangle_type (di);
 	    /* We don't display the offset.  FIXME: We should display
@@ -1596,7 +1520,7 @@ d_special_name (di)
 	  return NULL;
 	}
     }
-  else if (c == 'G')
+  else if (d_check_char (di, 'G'))
     {
       switch (d_next_char (di))
 	{
@@ -1607,6 +1531,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,29 +1557,24 @@ 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);
-      if (d_next_char (di) != '_')
+      d_number (di);
+      if (! d_check_char (di, '_'))
 	return 0;
-      virtual_offset = d_number (di);
+      d_number (di);
     }
   else
     return 0;
 
-  if (d_next_char (di) != '_')
+  if (! d_check_char (di, '_'))
     return 0;
 
   return 1;
@@ -1666,8 +1589,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)
     {
@@ -1676,13 +1598,13 @@ d_ctor_dtor_name (di)
       else if (di->last_name->type == DEMANGLE_COMPONENT_SUB_STD)
 	di->expansion += di->last_name->u.s_string.len;
     }
-  switch (d_next_char (di))
+  switch (d_peek_char (di))
     {
     case 'C':
       {
 	enum gnu_v3_ctor_kinds kind;
 
-	switch (d_next_char (di))
+	switch (d_peek_next_char (di))
 	  {
 	  case '1':
 	    kind = gnu_v3_complete_object_ctor;
@@ -1696,6 +1618,7 @@ d_ctor_dtor_name (di)
 	  default:
 	    return NULL;
 	  }
+	d_advance (di, 2);
 	return d_make_ctor (di, kind, di->last_name);
       }
 
@@ -1703,7 +1626,7 @@ d_ctor_dtor_name (di)
       {
 	enum gnu_v3_dtor_kinds kind;
 
-	switch (d_next_char (di))
+	switch (d_peek_next_char (di))
 	  {
 	  case '0':
 	    kind = gnu_v3_deleting_dtor;
@@ -1717,6 +1640,7 @@ d_ctor_dtor_name (di)
 	  default:
 	    return NULL;
 	  }
+	d_advance (di, 2);
 	return d_make_dtor (di, kind, di->last_name);
       }
 
@@ -1748,38 +1672,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 +1873,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,12 +1920,11 @@ 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;
 
-  if (d_next_char (di) != 'F')
+  if (! d_check_char (di, 'F'))
     return NULL;
   if (d_peek_char (di) == 'Y')
     {
@@ -2011,28 +1933,35 @@ d_function_type (di)
       d_advance (di, 1);
     }
   ret = d_bare_function_type (di, 1);
-  if (d_next_char (di) != 'E')
+  if (! d_check_char (di, 'E'))
     return NULL;
   return ret;
 }
 
-/* <bare-function-type> ::= <type>+  */
+/* <bare-function-type> ::= [J]<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;
   struct demangle_component **ptl;
+  char peek;
+
+  /* Detect special qualifier indicating that the first argument
+     is the return type.  */
+  peek = d_peek_char (di);
+  if (peek == 'J')
+    {
+      d_advance (di, 1);
+      has_return_type = 1;
+    }
 
   return_type = NULL;
   tl = NULL;
   ptl = &tl;
   while (1)
     {
-      char peek;
       struct demangle_component *type;
 
       peek = d_peek_char (di);
@@ -2076,8 +2005,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,13 +2015,12 @@ 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;
 
-  if (d_next_char (di) != 'A')
+  if (! d_check_char (di, 'A'))
     return NULL;
 
   peek = d_peek_char (di);
@@ -2121,7 +2048,7 @@ d_array_type (di)
 	return NULL;
     }
 
-  if (d_next_char (di) != '_')
+  if (! d_check_char (di, '_'))
     return NULL;
 
   return d_make_comp (di, DEMANGLE_COMPONENT_ARRAY_TYPE, dim,
@@ -2131,14 +2058,13 @@ 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;
   struct demangle_component **pmem;
 
-  if (d_next_char (di) != 'M')
+  if (! d_check_char (di, 'M'))
     return NULL;
 
   cl = cplus_demangle_type (di);
@@ -2154,13 +2080,22 @@ d_pointer_to_member_type (di)
      g++ does not work that way.  g++ treats only the CV-qualified
      member function as a substitution source.  FIXME.  So to work
      with g++, we need to pull off the CV-qualifiers here, in order to
-     avoid calling add_substitution() in cplus_demangle_type().  */
+     avoid calling add_substitution() in cplus_demangle_type().  But
+     for a CV-qualified member which is not a function, g++ does
+     follow the ABI, so we need to handle that case here by calling
+     d_add_substitution ourselves.  */
 
   pmem = d_cv_qualifiers (di, &mem, 1);
   if (pmem == NULL)
     return NULL;
   *pmem = cplus_demangle_type (di);
 
+  if (pmem != &mem && (*pmem)->type != DEMANGLE_COMPONENT_FUNCTION_TYPE)
+    {
+      if (! d_add_substitution (di, mem))
+	return NULL;
+    }
+
   return d_make_comp (di, DEMANGLE_COMPONENT_PTRMEM_TYPE, cl, mem);
 }
 
@@ -2169,12 +2104,11 @@ 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;
 
-  if (d_next_char (di) != 'T')
+  if (! d_check_char (di, 'T'))
     return NULL;
 
   if (d_peek_char (di) == '_')
@@ -2187,7 +2121,7 @@ d_template_param (di)
       param += 1;
     }
 
-  if (d_next_char (di) != '_')
+  if (! d_check_char (di, '_'))
     return NULL;
 
   ++di->did_subs;
@@ -2198,8 +2132,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;
@@ -2210,7 +2143,7 @@ d_template_args (di)
      constructor or destructor.  */
   hold_last_name = di->last_name;
 
-  if (d_next_char (di) != 'I')
+  if (! d_check_char (di, 'I'))
     return NULL;
 
   al = NULL;
@@ -2246,8 +2179,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;
 
@@ -2256,7 +2188,7 @@ d_template_arg (di)
     case 'X':
       d_advance (di, 1);
       ret = d_expression (di);
-      if (d_next_char (di) != 'E')
+      if (! d_check_char (di, 'E'))
 	return NULL;
       return ret;
 
@@ -2279,8 +2211,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,12 +2311,11 @@ 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;
 
-  if (d_next_char (di) != 'L')
+  if (! d_check_char (di, 'L'))
     return NULL;
   if (d_peek_char (di) == '_')
     ret = cplus_demangle_mangled_name (di, 0);
@@ -2396,6 +2326,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,10 +2354,14 @@ 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')
+  if (! d_check_char (di, 'E'))
     return NULL;
   return ret;
 }
@@ -2435,17 +2371,16 @@ 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;
 
-  if (d_next_char (di) != 'Z')
+  if (! d_check_char (di, 'Z'))
     return NULL;
 
   function = d_encoding (di, 0);
 
-  if (d_next_char (di) != 'E')
+  if (! d_check_char (di, 'E'))
     return NULL;
 
   if (d_peek_char (di) == 's')
@@ -2474,8 +2409,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 +2425,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,13 +2481,11 @@ 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;
 
-  if (d_next_char (di) != 'S')
+  if (! d_check_char (di, 'S'))
     return NULL;
 
   c = d_next_char (di);
@@ -2574,6 +2504,8 @@ d_substitution (di, prefix)
 		id = id * 36 + c - 'A' + 10;
 	      else
 		return NULL;
+	      if (id < 0)
+		return NULL;
 	      c = d_next_char (di);
 	    }
 	  while (c != '_');
@@ -2638,9 +2570,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 +2583,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 +2599,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 +2618,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 +2637,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 +2653,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 +2689,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 +2762,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 +2858,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 +2963,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;
@@ -3119,13 +3044,16 @@ d_print_comp (dpi, dc)
 
     case DEMANGLE_COMPONENT_FUNCTION_TYPE:
       {
+	if ((dpi->options & DMGL_RET_POSTFIX) != 0)
+	  d_print_function_type (dpi, dc, dpi->modifiers);
+
+	/* Print return type if present */
 	if (d_left (dc) != NULL)
 	  {
 	    struct d_print_mod dpm;
 
 	    /* We must pass this type down as a modifier in order to
 	       print it in the right location.  */
-
 	    dpm.next = dpi->modifiers;
 	    dpi->modifiers = &dpm;
 	    dpm.mod = dc;
@@ -3139,10 +3067,14 @@ d_print_comp (dpi, dc)
 	    if (dpm.printed)
 	      return;
 
-	    d_append_char (dpi, ' ');
+	    /* In standard prefix notation, there is a space between the
+	       return type and the function signature.  */
+	    if ((dpi->options & DMGL_RET_POSTFIX) == 0)
+	      d_append_char (dpi, ' ');
 	  }
 
-	d_print_function_type (dpi, dc, dpi->modifiers);
+	if ((dpi->options & DMGL_RET_POSTFIX) == 0) 
+	  d_print_function_type (dpi, dc, dpi->modifiers);
 
 	return;
       }
@@ -3347,62 +3279,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:
@@ -3417,10 +3373,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;
@@ -3470,10 +3423,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;
 
@@ -3549,9 +3500,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)
     {
@@ -3605,18 +3555,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)
@@ -3625,15 +3576,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:
@@ -3652,18 +3606,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, '(');
     }
 
@@ -3690,10 +3640,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;
 
@@ -3745,9 +3694,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,
@@ -3759,9 +3707,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));
@@ -3780,7 +3727,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)));
 
@@ -3805,11 +3752,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;
@@ -3842,10 +3786,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;
@@ -3867,7 +3808,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
@@ -3969,7 +3910,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
@@ -3998,11 +3939,8 @@ 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;
@@ -4021,21 +3959,6 @@ __cxa_demangle (mangled_name, output_buffer, length, status)
       return NULL;
     }
 
-  /* The specification for __cxa_demangle() is that if the mangled
-     name could be either an extern "C" identifier, or an internal
-     built-in type name, then we resolve it as the identifier.  All
-     internal built-in type names are a single lower case character.
-     Frankly, this simplistic disambiguation doesn't make sense to me,
-     but it is documented, so we implement it here.  */
-  if (IS_LOWER (mangled_name[0])
-      && mangled_name[1] == '\0'
-      && cplus_demangle_builtin_types[mangled_name[0] - 'a'].name != NULL)
-    {
-      if (status != NULL)
-	*status = -2;
-      return NULL;
-    }
-
   demangled = d_demangle (mangled_name, DMGL_PARAMS | DMGL_TYPES, &alc);
 
   if (demangled == NULL)
@@ -4083,9 +4006,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;
 
@@ -4100,8 +4021,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;
@@ -4109,7 +4029,8 @@ java_demangle_v3 (mangled)
   char *from;
   char *to;
 
-  demangled = d_demangle (mangled, DMGL_JAVA | DMGL_PARAMS, &alc);
+  demangled = d_demangle (mangled, DMGL_JAVA | DMGL_PARAMS | DMGL_RET_POSTFIX, 
+			  &alc);
 
   if (demangled == NULL)
     return NULL;
@@ -4151,10 +4072,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;
@@ -4237,8 +4157,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;
@@ -4253,8 +4172,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;
@@ -4271,7 +4189,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')                                     \
@@ -4288,9 +4206,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");
@@ -4317,9 +4233,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;