* Makefile.in (SFILES): Add cp-names.y.

	(libiberty_h, safe_ctype_h): New.
	(YYFILES): Add cp-names.c.
	(YYOBJ): Add cp-names.o.
	(test-cp-names.o, test-cp-names$(EXEEXT), cp-names.o): New rules.
	(clean): Remove test-cp-names$(EXEEXT).
	(local-maintainer-clean): Remove cp-names.c.
	* cp-names.y: New file.
	* cp-support.c (find_last_component): Delete.
	(d_left, d_right): Define.
	(cp_canonicalize_string, mangled_name_to_comp): New functions.
	(cp_class_name_from_physname, method_name_from_physname): Rewrite
	to use mangled_name_to_comp.
	* cp-support.h (cp_canonicalize_string, cp_demangled_name_to_comp)
	(cp_comp_to_string): New prototypes.
	* config/djgpp/fnchange.lst: Add cp-names.c.

1 files changed, 2131 insertions, 0 deletions

diff --git a/gdb/cp-names.y b/gdb/cp-names.y
new file mode 100644
index 0000000..589d8d9
--- /dev/null
+++ b/gdb/cp-names.y
@@ -0,0 +1,2131 @@
+/* YACC parser for C++ names, for GDB.
+
+   Copyright 2003, 2004, 2005
+   Free Software Foundation, Inc.
+
+   Parts of the lexer are based on c-exp.y from GDB.
+
+This file is part of GDB.
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+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.  */
+
+/* Note that malloc's and realloc's in this file are transformed to
+   xmalloc and xrealloc respectively by the same sed command in the
+   makefile that remaps any other malloc/realloc inserted by the parser
+   generator.  Doing this with #defines and trying to control the interaction
+   with include files (<malloc.h> and <stdlib.h> for example) just became
+   too messy, particularly when such includes can be inserted at random
+   times by the parser generator.  */
+
+%{
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+
+#include "safe-ctype.h"
+#include "libiberty.h"
+#include "demangle.h"
+
+/* Bison does not make it easy to create a parser without global
+   state, unfortunately.  Here are all the global variables used
+   in this parser.  */
+
+/* LEXPTR is the current pointer into our lex buffer.  PREV_LEXPTR
+   is the start of the last token lexed, only used for diagnostics.
+   ERROR_LEXPTR is the first place an error occurred.  GLOBAL_ERRMSG
+   is the first error message encountered.  */
+
+static const char *lexptr, *prev_lexptr, *error_lexptr, *global_errmsg;
+
+/* The components built by the parser are allocated ahead of time,
+   and cached in this structure.  */
+
+struct demangle_info {
+  int used;
+  struct demangle_component comps[1];
+};
+
+static struct demangle_info *demangle_info;
+#define d_grab() (&demangle_info->comps[demangle_info->used++])
+
+/* The parse tree created by the parser is stored here after a successful
+   parse.  */
+
+static struct demangle_component *global_result;
+
+/* Prototypes for helper functions used when constructing the parse
+   tree.  */
+
+static struct demangle_component *d_qualify (struct demangle_component *, int,
+					     int);
+
+static struct demangle_component *d_int_type (int);
+
+static struct demangle_component *d_unary (const char *,
+					   struct demangle_component *);
+static struct demangle_component *d_binary (const char *,
+					    struct demangle_component *,
+					    struct demangle_component *);
+
+/* Flags passed to d_qualify.  */
+
+#define QUAL_CONST 1
+#define QUAL_RESTRICT 2
+#define QUAL_VOLATILE 4
+
+/* Flags passed to d_int_type.  */
+
+#define INT_CHAR	(1 << 0)
+#define INT_SHORT	(1 << 1)
+#define INT_LONG	(1 << 2)
+#define INT_LLONG	(1 << 3)
+
+#define INT_SIGNED	(1 << 4)
+#define INT_UNSIGNED	(1 << 5)
+
+/* Remap normal yacc parser interface names (yyparse, yylex, yyerror, etc),
+   as well as gratuitiously global symbol names, so we can have multiple
+   yacc generated parsers in gdb.  Note that these are only the variables
+   produced by yacc.  If other parser generators (bison, byacc, etc) produce
+   additional global names that conflict at link time, then those parser
+   generators need to be fixed instead of adding those names to this list. */
+
+#define	yymaxdepth cpname_maxdepth
+#define	yyparse	cpname_parse
+#define	yylex	cpname_lex
+#define	yyerror	cpname_error
+#define	yylval	cpname_lval
+#define	yychar	cpname_char
+#define	yydebug	cpname_debug
+#define	yypact	cpname_pact	
+#define	yyr1	cpname_r1			
+#define	yyr2	cpname_r2			
+#define	yydef	cpname_def		
+#define	yychk	cpname_chk		
+#define	yypgo	cpname_pgo		
+#define	yyact	cpname_act		
+#define	yyexca	cpname_exca
+#define yyerrflag cpname_errflag
+#define yynerrs	cpname_nerrs
+#define	yyps	cpname_ps
+#define	yypv	cpname_pv
+#define	yys	cpname_s
+#define	yy_yys	cpname_yys
+#define	yystate	cpname_state
+#define	yytmp	cpname_tmp
+#define	yyv	cpname_v
+#define	yy_yyv	cpname_yyv
+#define	yyval	cpname_val
+#define	yylloc	cpname_lloc
+#define yyreds	cpname_reds		/* With YYDEBUG defined */
+#define yytoks	cpname_toks		/* With YYDEBUG defined */
+#define yyname	cpname_name		/* With YYDEBUG defined */
+#define yyrule	cpname_rule		/* With YYDEBUG defined */
+#define yylhs	cpname_yylhs
+#define yylen	cpname_yylen
+#define yydefred cpname_yydefred
+#define yydgoto	cpname_yydgoto
+#define yysindex cpname_yysindex
+#define yyrindex cpname_yyrindex
+#define yygindex cpname_yygindex
+#define yytable	 cpname_yytable
+#define yycheck	 cpname_yycheck
+
+static int yylex (void);
+static void yyerror (char *);
+
+/* Enable yydebug for the stand-alone parser.  */
+#ifdef TEST_CPNAMES
+# define YYDEBUG	1
+#endif
+
+/* Helper functions.  These wrap the demangler tree interface, handle
+   allocation from our global store, and return the allocated component.  */
+
+static struct demangle_component *
+fill_comp (enum demangle_component_type d_type, struct demangle_component *lhs,
+	   struct demangle_component *rhs)
+{
+  struct demangle_component *ret = d_grab ();
+  cplus_demangle_fill_component (ret, d_type, lhs, rhs);
+  return ret;
+}
+
+static struct demangle_component *
+make_empty (enum demangle_component_type d_type)
+{
+  struct demangle_component *ret = d_grab ();
+  ret->type = d_type;
+  return ret;
+}
+
+static struct demangle_component *
+make_operator (const char *name, int args)
+{
+  struct demangle_component *ret = d_grab ();
+  cplus_demangle_fill_operator (ret, name, args);
+  return ret;
+}
+
+static struct demangle_component *
+make_dtor (enum gnu_v3_dtor_kinds kind, struct demangle_component *name)
+{
+  struct demangle_component *ret = d_grab ();
+  cplus_demangle_fill_dtor (ret, kind, name);
+  return ret;
+}
+
+static struct demangle_component *
+make_builtin_type (const char *name)
+{
+  struct demangle_component *ret = d_grab ();
+  cplus_demangle_fill_builtin_type (ret, name);
+  return ret;
+}
+
+static struct demangle_component *
+make_name (const char *name, int len)
+{
+  struct demangle_component *ret = d_grab ();
+  cplus_demangle_fill_name (ret, name, len);
+  return ret;
+}
+
+#define d_left(dc) (dc)->u.s_binary.left
+#define d_right(dc) (dc)->u.s_binary.right
+
+%}
+
+%union
+  {
+    struct demangle_component *comp;
+    struct nested {
+      struct demangle_component *comp;
+      struct demangle_component **last;
+    } nested;
+    struct {
+      struct demangle_component *comp, *last;
+    } nested1;
+    struct {
+      struct demangle_component *comp, **last;
+      struct nested fn;
+      struct demangle_component *start;
+      int fold_flag;
+    } abstract;
+    int lval;
+    struct {
+      int val;
+      struct demangle_component *type;
+    } typed_val_int;
+    const char *opname;
+  }
+
+%type <comp> exp exp1 type start start_opt operator colon_name
+%type <comp> unqualified_name colon_ext_name
+%type <comp> template template_arg
+%type <comp> builtin_type
+%type <comp> typespec_2 array_indicator
+%type <comp> colon_ext_only ext_only_name
+
+%type <comp> demangler_special function conversion_op
+%type <nested> conversion_op_name
+
+%type <abstract> abstract_declarator direct_abstract_declarator
+%type <abstract> abstract_declarator_fn
+%type <nested> declarator direct_declarator function_arglist
+
+%type <nested> declarator_1 direct_declarator_1
+
+%type <nested> template_params function_args
+%type <nested> ptr_operator
+
+%type <nested1> nested_name
+
+%type <lval> qualifier qualifiers qualifiers_opt
+
+%type <lval> int_part int_seq
+
+%token <comp> INT
+%token <comp> FLOAT
+
+%token <comp> NAME
+%type <comp> name
+
+%token STRUCT CLASS UNION ENUM SIZEOF UNSIGNED COLONCOLON
+%token TEMPLATE
+%token ERROR
+%token NEW DELETE OPERATOR
+%token STATIC_CAST REINTERPRET_CAST DYNAMIC_CAST
+
+/* Special type cases, put in to allow the parser to distinguish different
+   legal basetypes.  */
+%token SIGNED_KEYWORD LONG SHORT INT_KEYWORD CONST_KEYWORD VOLATILE_KEYWORD DOUBLE_KEYWORD BOOL
+%token ELLIPSIS RESTRICT VOID FLOAT_KEYWORD CHAR WCHAR_T
+
+%token <opname> ASSIGN_MODIFY
+
+/* C++ */
+%token TRUEKEYWORD
+%token FALSEKEYWORD
+
+/* Non-C++ things we get from the demangler.  */
+%token <lval> DEMANGLER_SPECIAL
+%token CONSTRUCTION_VTABLE CONSTRUCTION_IN
+%token <typed_val_int> GLOBAL
+
+%{
+enum {
+  GLOBAL_CONSTRUCTORS = DEMANGLE_COMPONENT_LITERAL + 20,
+  GLOBAL_DESTRUCTORS = DEMANGLE_COMPONENT_LITERAL + 21
+};
+%}
+
+/* Precedence declarations.  */
+
+/* Give NAME lower precedence than COLONCOLON, so that nested_name will
+   associate greedily.  */
+%nonassoc NAME
+
+/* Give NEW and DELETE lower precedence than ']', because we can not
+   have an array of type operator new.  This causes NEW '[' to be
+   parsed as operator new[].  */
+%nonassoc NEW DELETE
+
+/* Give VOID higher precedence than NAME.  Then we can use %prec NAME
+   to prefer (VOID) to (function_args).  */
+%nonassoc VOID
+
+/* Give VOID lower precedence than ')' for similar reasons.  */
+%nonassoc ')'
+
+%left ','
+%right '=' ASSIGN_MODIFY
+%right '?'
+%left OROR
+%left ANDAND
+%left '|'
+%left '^'
+%left '&'
+%left EQUAL NOTEQUAL
+%left '<' '>' LEQ GEQ
+%left LSH RSH
+%left '@'
+%left '+' '-'
+%left '*' '/' '%'
+%right UNARY INCREMENT DECREMENT
+
+/* We don't need a precedence for '(' in this reduced grammar, and it
+   can mask some unpleasant bugs, so disable it for now.  */
+
+%right ARROW '.' '[' /* '(' */
+%left COLONCOLON
+
+
+%%
+
+result		:	start
+			{ global_result = $1; }
+		;
+
+start		:	type
+
+		|	demangler_special
+
+		|	function
+
+		;
+
+start_opt	:	/* */
+			{ $$ = NULL; }
+		|	COLONCOLON start
+			{ $$ = $2; }
+		;
+
+function
+		/* Function with a return type.  declarator_1 is used to prevent
+		   ambiguity with the next rule.  */
+		:	typespec_2 declarator_1
+			{ $$ = $2.comp;
+			  *$2.last = $1;
+			}
+
+		/* Function without a return type.  We need to use typespec_2
+		   to prevent conflicts from qualifiers_opt - harmless.  The
+		   start_opt is used to handle "function-local" variables and
+		   types.  */
+		|	typespec_2 function_arglist start_opt
+			{ $$ = fill_comp (DEMANGLE_COMPONENT_TYPED_NAME, $1, $2.comp);
+			  if ($3) $$ = fill_comp (DEMANGLE_COMPONENT_LOCAL_NAME, $$, $3); }
+		|	colon_ext_only function_arglist start_opt
+			{ $$ = fill_comp (DEMANGLE_COMPONENT_TYPED_NAME, $1, $2.comp);
+			  if ($3) $$ = fill_comp (DEMANGLE_COMPONENT_LOCAL_NAME, $$, $3); }
+
+		|	conversion_op_name start_opt
+			{ $$ = $1.comp;
+			  if ($2) $$ = fill_comp (DEMANGLE_COMPONENT_LOCAL_NAME, $$, $2); }
+		|	conversion_op_name abstract_declarator_fn
+			{ if ($2.last)
+			    {
+			       /* First complete the abstract_declarator's type using
+				  the typespec from the conversion_op_name.  */
+			      *$2.last = *$1.last;
+			      /* Then complete the conversion_op_name with the type.  */
+			      *$1.last = $2.comp;
+			    }
+			  /* If we have an arglist, build a function type.  */
+			  if ($2.fn.comp)
+			    $$ = fill_comp (DEMANGLE_COMPONENT_TYPED_NAME, $1.comp, $2.fn.comp);
+			  else
+			    $$ = $1.comp;
+			  if ($2.start) $$ = fill_comp (DEMANGLE_COMPONENT_LOCAL_NAME, $$, $2.start);
+			}
+		;
+
+demangler_special
+		:	DEMANGLER_SPECIAL start
+			{ $$ = make_empty ($1);
+			  d_left ($$) = $2;
+			  d_right ($$) = NULL; }
+		|	CONSTRUCTION_VTABLE start CONSTRUCTION_IN start
+			{ $$ = fill_comp (DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE, $2, $4); }
+		|	GLOBAL
+			{ $$ = make_empty ($1.val);
+			  d_left ($$) = $1.type;
+			  d_right ($$) = NULL; }
+		;
+
+operator	:	OPERATOR NEW
+			{ $$ = make_operator ("new", 1); }
+		|	OPERATOR DELETE
+			{ $$ = make_operator ("delete", 1); }
+		|	OPERATOR NEW '[' ']'
+			{ $$ = make_operator ("new[]", 1); }
+		|	OPERATOR DELETE '[' ']'
+			{ $$ = make_operator ("delete[]", 1); }
+		|	OPERATOR '+'
+			{ $$ = make_operator ("+", 2); }
+		|	OPERATOR '-'
+			{ $$ = make_operator ("-", 2); }
+		|	OPERATOR '*'
+			{ $$ = make_operator ("*", 2); }
+		|	OPERATOR '/'
+			{ $$ = make_operator ("/", 2); }
+		|	OPERATOR '%'
+			{ $$ = make_operator ("%", 2); }
+		|	OPERATOR '^'
+			{ $$ = make_operator ("^", 2); }
+		|	OPERATOR '&'
+			{ $$ = make_operator ("&", 2); }
+		|	OPERATOR '|'
+			{ $$ = make_operator ("|", 2); }
+		|	OPERATOR '~'
+			{ $$ = make_operator ("~", 1); }
+		|	OPERATOR '!'
+			{ $$ = make_operator ("!", 1); }
+		|	OPERATOR '='
+			{ $$ = make_operator ("=", 2); }
+		|	OPERATOR '<'
+			{ $$ = make_operator ("<", 2); }
+		|	OPERATOR '>'
+			{ $$ = make_operator (">", 2); }
+		|	OPERATOR ASSIGN_MODIFY
+			{ $$ = make_operator ($2, 2); }
+		|	OPERATOR LSH
+			{ $$ = make_operator ("<<", 2); }
+		|	OPERATOR RSH
+			{ $$ = make_operator (">>", 2); }
+		|	OPERATOR EQUAL
+			{ $$ = make_operator ("==", 2); }
+		|	OPERATOR NOTEQUAL
+			{ $$ = make_operator ("!=", 2); }
+		|	OPERATOR LEQ
+			{ $$ = make_operator ("<=", 2); }
+		|	OPERATOR GEQ
+			{ $$ = make_operator (">=", 2); }
+		|	OPERATOR ANDAND
+			{ $$ = make_operator ("&&", 2); }
+		|	OPERATOR OROR
+			{ $$ = make_operator ("||", 2); }
+		|	OPERATOR INCREMENT
+			{ $$ = make_operator ("++", 1); }
+		|	OPERATOR DECREMENT
+			{ $$ = make_operator ("--", 1); }
+		|	OPERATOR ','
+			{ $$ = make_operator (",", 2); }
+		|	OPERATOR ARROW '*'
+			{ $$ = make_operator ("->*", 2); }
+		|	OPERATOR ARROW
+			{ $$ = make_operator ("->", 2); }
+		|	OPERATOR '(' ')'
+			{ $$ = make_operator ("()", 0); }
+		|	OPERATOR '[' ']'
+			{ $$ = make_operator ("[]", 2); }
+		;
+
+		/* Conversion operators.  We don't try to handle some of
+		   the wackier demangler output for function pointers,
+		   since it's not clear that it's parseable.  */
+conversion_op
+		:	OPERATOR typespec_2
+			{ $$ = fill_comp (DEMANGLE_COMPONENT_CAST, $2, NULL); }
+		;
+
+conversion_op_name
+		:	nested_name conversion_op
+			{ $$.comp = $1.comp;
+			  d_right ($1.last) = $2;
+			  $$.last = &d_left ($2);
+			}
+		|	conversion_op
+			{ $$.comp = $1;
+			  $$.last = &d_left ($1);
+			}
+		|	COLONCOLON nested_name conversion_op
+			{ $$.comp = $2.comp;
+			  d_right ($2.last) = $3;
+			  $$.last = &d_left ($3);
+			}
+		|	COLONCOLON conversion_op
+			{ $$.comp = $2;
+			  $$.last = &d_left ($2);
+			}
+		;
+
+/* DEMANGLE_COMPONENT_NAME */
+/* This accepts certain invalid placements of '~'.  */
+unqualified_name:	operator
+		|	operator '<' template_params '>'
+			{ $$ = fill_comp (DEMANGLE_COMPONENT_TEMPLATE, $1, $3.comp); }
+		|	'~' NAME
+			{ $$ = make_dtor (gnu_v3_complete_object_dtor, $2); }
+		;
+
+/* This rule is used in name and nested_name, and expanded inline there
+   for efficiency.  */
+/*
+scope_id	:	NAME
+		|	template
+		;
+*/
+
+colon_name	:	name
+		|	COLONCOLON name
+			{ $$ = $2; }
+		;
+
+/* DEMANGLE_COMPONENT_QUAL_NAME */
+/* DEMANGLE_COMPONENT_CTOR / DEMANGLE_COMPONENT_DTOR ? */
+name		:	nested_name NAME %prec NAME
+			{ $$ = $1.comp; d_right ($1.last) = $2; }
+		|	NAME %prec NAME
+		|	nested_name template %prec NAME
+			{ $$ = $1.comp; d_right ($1.last) = $2; }
+		|	template %prec NAME
+		;
+
+colon_ext_name	:	colon_name
+		|	colon_ext_only
+		;
+
+colon_ext_only	:	ext_only_name
+		|	COLONCOLON ext_only_name
+			{ $$ = $2; }
+		;
+
+ext_only_name	:	nested_name unqualified_name
+			{ $$ = $1.comp; d_right ($1.last) = $2; }
+		|	unqualified_name
+		;
+
+nested_name	:	NAME COLONCOLON
+			{ $$.comp = make_empty (DEMANGLE_COMPONENT_QUAL_NAME);
+			  d_left ($$.comp) = $1;
+			  d_right ($$.comp) = NULL;
+			  $$.last = $$.comp;
+			}
+		|	nested_name NAME COLONCOLON
+			{ $$.comp = $1.comp;
+			  d_right ($1.last) = make_empty (DEMANGLE_COMPONENT_QUAL_NAME);
+			  $$.last = d_right ($1.last);
+			  d_left ($$.last) = $2;
+			  d_right ($$.last) = NULL;
+			}
+		|	template COLONCOLON
+			{ $$.comp = make_empty (DEMANGLE_COMPONENT_QUAL_NAME);
+			  d_left ($$.comp) = $1;
+			  d_right ($$.comp) = NULL;
+			  $$.last = $$.comp;
+			}
+		|	nested_name template COLONCOLON
+			{ $$.comp = $1.comp;
+			  d_right ($1.last) = make_empty (DEMANGLE_COMPONENT_QUAL_NAME);
+			  $$.last = d_right ($1.last);
+			  d_left ($$.last) = $2;
+			  d_right ($$.last) = NULL;
+			}
+		;
+
+/* DEMANGLE_COMPONENT_TEMPLATE */
+/* DEMANGLE_COMPONENT_TEMPLATE_ARGLIST */
+template	:	NAME '<' template_params '>'
+			{ $$ = fill_comp (DEMANGLE_COMPONENT_TEMPLATE, $1, $3.comp); }
+		;
+
+template_params	:	template_arg
+			{ $$.comp = fill_comp (DEMANGLE_COMPONENT_TEMPLATE_ARGLIST, $1, NULL);
+			$$.last = &d_right ($$.comp); }
+		|	template_params ',' template_arg
+			{ $$.comp = $1.comp;
+			  *$1.last = fill_comp (DEMANGLE_COMPONENT_TEMPLATE_ARGLIST, $3, NULL);
+			  $$.last = &d_right (*$1.last);
+			}
+		;
+
+/* "type" is inlined into template_arg and function_args.  */
+
+/* Also an integral constant-expression of integral type, and a
+   pointer to member (?) */
+template_arg	:	typespec_2
+		|	typespec_2 abstract_declarator
+			{ $$ = $2.comp;
+			  *$2.last = $1;
+			}
+		|	'&' start
+			{ $$ = fill_comp (DEMANGLE_COMPONENT_UNARY, make_operator ("&", 1), $2); }
+		|	'&' '(' start ')'
+			{ $$ = fill_comp (DEMANGLE_COMPONENT_UNARY, make_operator ("&", 1), $3); }
+		|	exp
+		;
+
+function_args	:	typespec_2
+			{ $$.comp = fill_comp (DEMANGLE_COMPONENT_ARGLIST, $1, NULL);
+			  $$.last = &d_right ($$.comp);
+			}
+		|	typespec_2 abstract_declarator
+			{ *$2.last = $1;
+			  $$.comp = fill_comp (DEMANGLE_COMPONENT_ARGLIST, $2.comp, NULL);
+			  $$.last = &d_right ($$.comp);
+			}
+		|	function_args ',' typespec_2
+			{ *$1.last = fill_comp (DEMANGLE_COMPONENT_ARGLIST, $3, NULL);
+			  $$.comp = $1.comp;
+			  $$.last = &d_right (*$1.last);
+			}
+		|	function_args ',' typespec_2 abstract_declarator
+			{ *$4.last = $3;
+			  *$1.last = fill_comp (DEMANGLE_COMPONENT_ARGLIST, $4.comp, NULL);
+			  $$.comp = $1.comp;
+			  $$.last = &d_right (*$1.last);
+			}
+		|	function_args ',' ELLIPSIS
+			{ *$1.last
+			    = fill_comp (DEMANGLE_COMPONENT_ARGLIST,
+					   make_builtin_type ("..."),
+					   NULL);
+			  $$.comp = $1.comp;
+			  $$.last = &d_right (*$1.last);
+			}
+		;
+
+function_arglist:	'(' function_args ')' qualifiers_opt %prec NAME
+			{ $$.comp = fill_comp (DEMANGLE_COMPONENT_FUNCTION_TYPE, NULL, $2.comp);
+			  $$.last = &d_left ($$.comp);
+			  $$.comp = d_qualify ($$.comp, $4, 1); }
+		|	'(' VOID ')' qualifiers_opt
+			{ $$.comp = fill_comp (DEMANGLE_COMPONENT_FUNCTION_TYPE, NULL, NULL);
+			  $$.last = &d_left ($$.comp);
+			  $$.comp = d_qualify ($$.comp, $4, 1); }
+		|	'(' ')' qualifiers_opt
+			{ $$.comp = fill_comp (DEMANGLE_COMPONENT_FUNCTION_TYPE, NULL, NULL);
+			  $$.last = &d_left ($$.comp);
+			  $$.comp = d_qualify ($$.comp, $3, 1); }
+		;
+
+/* Should do something about DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL */
+qualifiers_opt	:	/* epsilon */
+			{ $$ = 0; }
+		|	qualifiers
+		;
+
+qualifier	:	RESTRICT
+			{ $$ = QUAL_RESTRICT; }
+		|	VOLATILE_KEYWORD
+			{ $$ = QUAL_VOLATILE; }
+		|	CONST_KEYWORD
+			{ $$ = QUAL_CONST; }
+		;
+
+qualifiers	:	qualifier
+		|	qualifier qualifiers
+			{ $$ = $1 | $2; }
+		;
+
+/* This accepts all sorts of invalid constructions and produces
+   invalid output for them - an error would be better.  */
+
+int_part	:	INT_KEYWORD
+			{ $$ = 0; }
+		|	SIGNED_KEYWORD
+			{ $$ = INT_SIGNED; }
+		|	UNSIGNED
+			{ $$ = INT_UNSIGNED; }
+		|	CHAR
+			{ $$ = INT_CHAR; }
+		|	LONG
+			{ $$ = INT_LONG; }
+		|	SHORT
+			{ $$ = INT_SHORT; }
+		;
+
+int_seq		:	int_part
+		|	int_seq int_part
+			{ $$ = $1 | $2; if ($1 & $2 & INT_LONG) $$ = $1 | INT_LLONG; }
+		;
+
+builtin_type	:	int_seq
+			{ $$ = d_int_type ($1); }
+		|	FLOAT_KEYWORD
+			{ $$ = make_builtin_type ("float"); }
+		|	DOUBLE_KEYWORD
+			{ $$ = make_builtin_type ("double"); }
+		|	LONG DOUBLE_KEYWORD
+			{ $$ = make_builtin_type ("long double"); }
+		|	BOOL
+			{ $$ = make_builtin_type ("bool"); }
+		|	WCHAR_T
+			{ $$ = make_builtin_type ("wchar_t"); }
+		|	VOID
+			{ $$ = make_builtin_type ("void"); }
+		;
+
+ptr_operator	:	'*' qualifiers_opt
+			{ $$.comp = make_empty (DEMANGLE_COMPONENT_POINTER);
+			  $$.comp->u.s_binary.left = $$.comp->u.s_binary.right = NULL;
+			  $$.last = &d_left ($$.comp);
+			  $$.comp = d_qualify ($$.comp, $2, 0); }
+		/* g++ seems to allow qualifiers after the reference?  */
+		|	'&'
+			{ $$.comp = make_empty (DEMANGLE_COMPONENT_REFERENCE);
+			  $$.comp->u.s_binary.left = $$.comp->u.s_binary.right = NULL;
+			  $$.last = &d_left ($$.comp); }
+		|	nested_name '*' qualifiers_opt
+			{ $$.comp = make_empty (DEMANGLE_COMPONENT_PTRMEM_TYPE);
+			  $$.comp->u.s_binary.left = $1.comp;
+			  /* Convert the innermost DEMANGLE_COMPONENT_QUAL_NAME to a DEMANGLE_COMPONENT_NAME.  */
+			  *$1.last = *d_left ($1.last);
+			  $$.comp->u.s_binary.right = NULL;
+			  $$.last = &d_right ($$.comp);
+			  $$.comp = d_qualify ($$.comp, $3, 0); }
+		|	COLONCOLON nested_name '*' qualifiers_opt
+			{ $$.comp = make_empty (DEMANGLE_COMPONENT_PTRMEM_TYPE);
+			  $$.comp->u.s_binary.left = $2.comp;
+			  /* Convert the innermost DEMANGLE_COMPONENT_QUAL_NAME to a DEMANGLE_COMPONENT_NAME.  */
+			  *$2.last = *d_left ($2.last);
+			  $$.comp->u.s_binary.right = NULL;
+			  $$.last = &d_right ($$.comp);
+			  $$.comp = d_qualify ($$.comp, $4, 0); }
+		;
+
+array_indicator	:	'[' ']'
+			{ $$ = make_empty (DEMANGLE_COMPONENT_ARRAY_TYPE);
+			  d_left ($$) = NULL;
+			}
+		|	'[' INT ']'
+			{ $$ = make_empty (DEMANGLE_COMPONENT_ARRAY_TYPE);
+			  d_left ($$) = $2;
+			}
+		;
+
+/* Details of this approach inspired by the G++ < 3.4 parser.  */
+
+/* This rule is only used in typespec_2, and expanded inline there for
+   efficiency.  */
+/*
+typespec	:	builtin_type
+		|	colon_name
+		;
+*/
+
+typespec_2	:	builtin_type qualifiers
+			{ $$ = d_qualify ($1, $2, 0); }
+		|	builtin_type
+		|	qualifiers builtin_type qualifiers
+			{ $$ = d_qualify ($2, $1 | $3, 0); }
+		|	qualifiers builtin_type
+			{ $$ = d_qualify ($2, $1, 0); }
+
+		|	name qualifiers
+			{ $$ = d_qualify ($1, $2, 0); }
+		|	name
+		|	qualifiers name qualifiers
+			{ $$ = d_qualify ($2, $1 | $3, 0); }
+		|	qualifiers name
+			{ $$ = d_qualify ($2, $1, 0); }
+
+		|	COLONCOLON name qualifiers
+			{ $$ = d_qualify ($2, $3, 0); }
+		|	COLONCOLON name
+			{ $$ = $2; }
+		|	qualifiers COLONCOLON name qualifiers
+			{ $$ = d_qualify ($3, $1 | $4, 0); }
+		|	qualifiers COLONCOLON name
+			{ $$ = d_qualify ($3, $1, 0); }
+		;
+
+abstract_declarator
+		:	ptr_operator
+			{ $$.comp = $1.comp; $$.last = $1.last;
+			  $$.fn.comp = NULL; $$.fn.last = NULL; }
+		|	ptr_operator abstract_declarator
+			{ $$ = $2; $$.fn.comp = NULL; $$.fn.last = NULL;
+			  if ($2.fn.comp) { $$.last = $2.fn.last; *$2.last = $2.fn.comp; }
+			  *$$.last = $1.comp;
+			  $$.last = $1.last; }
+		|	direct_abstract_declarator
+			{ $$.fn.comp = NULL; $$.fn.last = NULL;
+			  if ($1.fn.comp) { $$.last = $1.fn.last; *$1.last = $1.fn.comp; }
+			}
+		;
+
+direct_abstract_declarator
+		:	'(' abstract_declarator ')'
+			{ $$ = $2; $$.fn.comp = NULL; $$.fn.last = NULL; $$.fold_flag = 1;
+			  if ($2.fn.comp) { $$.last = $2.fn.last; *$2.last = $2.fn.comp; }
+			}
+		|	direct_abstract_declarator function_arglist
+			{ $$.fold_flag = 0;
+			  if ($1.fn.comp) { $$.last = $1.fn.last; *$1.last = $1.fn.comp; }
+			  if ($1.fold_flag)
+			    {
+			      *$$.last = $2.comp;
+			      $$.last = $2.last;
+			    }
+			  else
+			    $$.fn = $2;
+			}
+		|	direct_abstract_declarator array_indicator
+			{ $$.fn.comp = NULL; $$.fn.last = NULL; $$.fold_flag = 0;
+			  if ($1.fn.comp) { $$.last = $1.fn.last; *$1.last = $1.fn.comp; }
+			  *$1.last = $2;
+			  $$.last = &d_right ($2);
+			}
+		|	array_indicator
+			{ $$.fn.comp = NULL; $$.fn.last = NULL; $$.fold_flag = 0;
+			  $$.comp = $1;
+			  $$.last = &d_right ($1);
+			}
+		/* G++ has the following except for () and (type).  Then
+		   (type) is handled in regcast_or_absdcl and () is handled
+		   in fcast_or_absdcl.
+
+		   However, this is only useful for function types, and
+		   generates reduce/reduce conflicts with direct_declarator.
+		   We're interested in pointer-to-function types, and in
+		   functions, but not in function types - so leave this
+		   out.  */
+		/* |	function_arglist */
+		;
+
+abstract_declarator_fn
+		:	ptr_operator
+			{ $$.comp = $1.comp; $$.last = $1.last;
+			  $$.fn.comp = NULL; $$.fn.last = NULL; $$.start = NULL; }
+		|	ptr_operator abstract_declarator_fn
+			{ $$ = $2;
+			  if ($2.last)
+			    *$$.last = $1.comp;
+			  else
+			    $$.comp = $1.comp;
+			  $$.last = $1.last;
+			}
+		|	direct_abstract_declarator
+			{ $$.comp = $1.comp; $$.last = $1.last; $$.fn = $1.fn; $$.start = NULL; }
+		|	direct_abstract_declarator function_arglist COLONCOLON start
+			{ $$.start = $4;
+			  if ($1.fn.comp) { $$.last = $1.fn.last; *$1.last = $1.fn.comp; }
+			  if ($1.fold_flag)
+			    {
+			      *$$.last = $2.comp;
+			      $$.last = $2.last;
+			    }
+			  else
+			    $$.fn = $2;
+			}
+		|	function_arglist start_opt
+			{ $$.fn = $1;
+			  $$.start = $2;
+			  $$.comp = NULL; $$.last = NULL;
+			}
+		;
+
+type		:	typespec_2
+		|	typespec_2 abstract_declarator
+			{ $$ = $2.comp;
+			  *$2.last = $1;
+			}
+		;
+
+declarator	:	ptr_operator declarator
+			{ $$.comp = $2.comp;
+			  $$.last = $1.last;
+			  *$2.last = $1.comp; }
+		|	direct_declarator
+		;
+
+direct_declarator
+		:	'(' declarator ')'
+			{ $$ = $2; }
+		|	direct_declarator function_arglist
+			{ $$.comp = $1.comp;
+			  *$1.last = $2.comp;
+			  $$.last = $2.last;
+			}
+		|	direct_declarator array_indicator
+			{ $$.comp = $1.comp;
+			  *$1.last = $2;
+			  $$.last = &d_right ($2);
+			}
+		|	colon_ext_name
+			{ $$.comp = make_empty (DEMANGLE_COMPONENT_TYPED_NAME);
+			  d_left ($$.comp) = $1;
+			  $$.last = &d_right ($$.comp);
+			}
+		;
+
+/* These are similar to declarator and direct_declarator except that they
+   do not permit ( colon_ext_name ), which is ambiguous with a function
+   argument list.  They also don't permit a few other forms with redundant
+   parentheses around the colon_ext_name; any colon_ext_name in parentheses
+   must be followed by an argument list or an array indicator, or preceded
+   by a pointer.  */
+declarator_1	:	ptr_operator declarator_1
+			{ $$.comp = $2.comp;
+			  $$.last = $1.last;
+			  *$2.last = $1.comp; }
+		|	colon_ext_name
+			{ $$.comp = make_empty (DEMANGLE_COMPONENT_TYPED_NAME);
+			  d_left ($$.comp) = $1;
+			  $$.last = &d_right ($$.comp);
+			}
+		|	direct_declarator_1
+
+			/* Function local variable or type.  The typespec to
+			   our left is the type of the containing function. 
+			   This should be OK, because function local types
+			   can not be templates, so the return types of their
+			   members will not be mangled.  If they are hopefully
+			   they'll end up to the right of the ::.  */
+		|	colon_ext_name function_arglist COLONCOLON start
+			{ $$.comp = fill_comp (DEMANGLE_COMPONENT_TYPED_NAME, $1, $2.comp);
+			  $$.last = $2.last;
+			  $$.comp = fill_comp (DEMANGLE_COMPONENT_LOCAL_NAME, $$.comp, $4);
+			}
+		|	direct_declarator_1 function_arglist COLONCOLON start
+			{ $$.comp = $1.comp;
+			  *$1.last = $2.comp;
+			  $$.last = $2.last;
+			  $$.comp = fill_comp (DEMANGLE_COMPONENT_LOCAL_NAME, $$.comp, $4);
+			}
+		;
+
+direct_declarator_1
+		:	'(' ptr_operator declarator ')'
+			{ $$.comp = $3.comp;
+			  $$.last = $2.last;
+			  *$3.last = $2.comp; }
+		|	direct_declarator_1 function_arglist
+			{ $$.comp = $1.comp;
+			  *$1.last = $2.comp;
+			  $$.last = $2.last;
+			}
+		|	direct_declarator_1 array_indicator
+			{ $$.comp = $1.comp;
+			  *$1.last = $2;
+			  $$.last = &d_right ($2);
+			}
+		|	colon_ext_name function_arglist
+			{ $$.comp = fill_comp (DEMANGLE_COMPONENT_TYPED_NAME, $1, $2.comp);
+			  $$.last = $2.last;
+			}
+		|	colon_ext_name array_indicator
+			{ $$.comp = fill_comp (DEMANGLE_COMPONENT_TYPED_NAME, $1, $2);
+			  $$.last = &d_right ($2);
+			}
+		;
+
+exp	:	'(' exp1 ')'
+		{ $$ = $2; }
+	;
+
+/* Silly trick.  Only allow '>' when parenthesized, in order to
+   handle conflict with templates.  */
+exp1	:	exp
+	;
+
+exp1	:	exp '>' exp
+		{ $$ = d_binary (">", $1, $3); }
+	;
+
+/* References.  Not allowed everywhere in template parameters, only
+   at the top level, but treat them as expressions in case they are wrapped
+   in parentheses.  */
+exp1	:	'&' start
+		{ $$ = fill_comp (DEMANGLE_COMPONENT_UNARY, make_operator ("&", 1), $2); }
+	;
+
+/* Expressions, not including the comma operator.  */
+exp	:	'-' exp    %prec UNARY
+		{ $$ = d_unary ("-", $2); }
+	;
+
+exp	:	'!' exp    %prec UNARY
+		{ $$ = d_unary ("!", $2); }
+	;
+
+exp	:	'~' exp    %prec UNARY
+		{ $$ = d_unary ("~", $2); }
+	;
+
+/* Casts.  First your normal C-style cast.  If exp is a LITERAL, just change
+   its type.  */
+
+exp	:	'(' type ')' exp  %prec UNARY
+		{ if ($4->type == DEMANGLE_COMPONENT_LITERAL
+		      || $4->type == DEMANGLE_COMPONENT_LITERAL_NEG)
+		    {
+		      $$ = $4;
+		      d_left ($4) = $2;
+		    }
+		  else
+		    $$ = fill_comp (DEMANGLE_COMPONENT_UNARY,
+				      fill_comp (DEMANGLE_COMPONENT_CAST, $2, NULL),
+				      $4);
+		}
+	;
+
+/* Mangling does not differentiate between these, so we don't need to
+   either.  */
+exp	:	STATIC_CAST '<' type '>' '(' exp1 ')' %prec UNARY
+		{ $$ = fill_comp (DEMANGLE_COMPONENT_UNARY,
+				    fill_comp (DEMANGLE_COMPONENT_CAST, $3, NULL),
+				    $6);
+		}
+	;
+
+exp	:	DYNAMIC_CAST '<' type '>' '(' exp1 ')' %prec UNARY
+		{ $$ = fill_comp (DEMANGLE_COMPONENT_UNARY,
+				    fill_comp (DEMANGLE_COMPONENT_CAST, $3, NULL),
+				    $6);
+		}
+	;
+
+exp	:	REINTERPRET_CAST '<' type '>' '(' exp1 ')' %prec UNARY
+		{ $$ = fill_comp (DEMANGLE_COMPONENT_UNARY,
+				    fill_comp (DEMANGLE_COMPONENT_CAST, $3, NULL),
+				    $6);
+		}
+	;
+
+/* Another form of C++-style cast.  "type ( exp1 )" is not allowed (it's too
+   ambiguous), but "name ( exp1 )" is.  Because we don't need to support
+   function types, we can handle this unambiguously (the use of typespec_2
+   prevents a silly, harmless conflict with qualifiers_opt).  This does not
+   appear in demangler output so it's not a great loss if we need to
+   disable it.  */
+exp	:	typespec_2 '(' exp1 ')' %prec UNARY
+		{ $$ = fill_comp (DEMANGLE_COMPONENT_UNARY,
+				    fill_comp (DEMANGLE_COMPONENT_CAST, $1, NULL),
+				    $3);
+		}
+	;
+
+/* TO INVESTIGATE: ._0 style anonymous names; anonymous namespaces */
+
+/* Binary operators in order of decreasing precedence.  */
+
+exp	:	exp '*' exp
+		{ $$ = d_binary ("*", $1, $3); }
+	;
+
+exp	:	exp '/' exp
+		{ $$ = d_binary ("/", $1, $3); }
+	;
+
+exp	:	exp '%' exp
+		{ $$ = d_binary ("%", $1, $3); }
+	;
+
+exp	:	exp '+' exp
+		{ $$ = d_binary ("+", $1, $3); }
+	;
+
+exp	:	exp '-' exp
+		{ $$ = d_binary ("-", $1, $3); }
+	;
+
+exp	:	exp LSH exp
+		{ $$ = d_binary ("<<", $1, $3); }
+	;
+
+exp	:	exp RSH exp
+		{ $$ = d_binary (">>", $1, $3); }
+	;
+
+exp	:	exp EQUAL exp
+		{ $$ = d_binary ("==", $1, $3); }
+	;
+
+exp	:	exp NOTEQUAL exp
+		{ $$ = d_binary ("!=", $1, $3); }
+	;
+
+exp	:	exp LEQ exp
+		{ $$ = d_binary ("<=", $1, $3); }
+	;
+
+exp	:	exp GEQ exp
+		{ $$ = d_binary (">=", $1, $3); }
+	;
+
+exp	:	exp '<' exp
+		{ $$ = d_binary ("<", $1, $3); }
+	;
+
+exp	:	exp '&' exp
+		{ $$ = d_binary ("&", $1, $3); }
+	;
+
+exp	:	exp '^' exp
+		{ $$ = d_binary ("^", $1, $3); }
+	;
+
+exp	:	exp '|' exp
+		{ $$ = d_binary ("|", $1, $3); }
+	;
+
+exp	:	exp ANDAND exp
+		{ $$ = d_binary ("&&", $1, $3); }
+	;
+
+exp	:	exp OROR exp
+		{ $$ = d_binary ("||", $1, $3); }
+	;
+
+/* Not 100% sure these are necessary, but they're harmless.  */
+exp	:	exp ARROW NAME
+		{ $$ = d_binary ("->", $1, $3); }
+	;
+
+exp	:	exp '.' NAME
+		{ $$ = d_binary (".", $1, $3); }
+	;
+
+exp	:	exp '?' exp ':' exp	%prec '?'
+		{ $$ = fill_comp (DEMANGLE_COMPONENT_TRINARY, make_operator ("?", 3),
+				    fill_comp (DEMANGLE_COMPONENT_TRINARY_ARG1, $1,
+						 fill_comp (DEMANGLE_COMPONENT_TRINARY_ARG2, $3, $5)));
+		}
+	;
+			  
+exp	:	INT
+	;
+
+/* Not generally allowed.  */
+exp	:	FLOAT
+	;
+
+exp	:	SIZEOF '(' type ')'	%prec UNARY
+		{ $$ = d_unary ("sizeof", $3); }
+	;
+
+/* C++.  */
+exp     :       TRUEKEYWORD    
+		{ struct demangle_component *i;
+		  i = make_name ("1", 1);
+		  $$ = fill_comp (DEMANGLE_COMPONENT_LITERAL,
+				    make_builtin_type ("bool"),
+				    i);
+		}
+	;
+
+exp     :       FALSEKEYWORD   
+		{ struct demangle_component *i;
+		  i = make_name ("0", 1);
+		  $$ = fill_comp (DEMANGLE_COMPONENT_LITERAL,
+				    make_builtin_type ("bool"),
+				    i);
+		}
+	;
+
+/* end of C++.  */
+
+%%
+
+/* Apply QUALIFIERS to LHS and return a qualified component.  IS_METHOD
+   is set if LHS is a method, in which case the qualifiers are logically
+   applied to "this".  We apply qualifiers in a consistent order; LHS
+   may already be qualified; duplicate qualifiers are not created.  */
+
+struct demangle_component *
+d_qualify (struct demangle_component *lhs, int qualifiers, int is_method)
+{
+  struct demangle_component **inner_p;
+  enum demangle_component_type type;
+
+  /* For now the order is CONST (innermost), VOLATILE, RESTRICT.  */
+
+#define HANDLE_QUAL(TYPE, MTYPE, QUAL)				\
+  if ((qualifiers & QUAL) && (type != TYPE) && (type != MTYPE))	\
+    {								\
+      *inner_p = fill_comp (is_method ? MTYPE : TYPE,	\
+			      *inner_p, NULL);			\
+      inner_p = &d_left (*inner_p);				\
+      type = (*inner_p)->type;					\
+    }								\
+  else if (type == TYPE || type == MTYPE)			\
+    {								\
+      inner_p = &d_left (*inner_p);				\
+      type = (*inner_p)->type;					\
+    }
+
+  inner_p = &lhs;
+
+  type = (*inner_p)->type;
+
+  HANDLE_QUAL (DEMANGLE_COMPONENT_RESTRICT, DEMANGLE_COMPONENT_RESTRICT_THIS, QUAL_RESTRICT);
+  HANDLE_QUAL (DEMANGLE_COMPONENT_VOLATILE, DEMANGLE_COMPONENT_VOLATILE_THIS, QUAL_VOLATILE);
+  HANDLE_QUAL (DEMANGLE_COMPONENT_CONST, DEMANGLE_COMPONENT_CONST_THIS, QUAL_CONST);
+
+  return lhs;
+}
+
+/* Return a builtin type corresponding to FLAGS.  */
+
+static struct demangle_component *
+d_int_type (int flags)
+{
+  const char *name;
+
+  switch (flags)
+    {
+    case INT_SIGNED | INT_CHAR:
+      name = "signed char";
+      break;
+    case INT_CHAR:
+      name = "char";
+      break;
+    case INT_UNSIGNED | INT_CHAR:
+      name = "unsigned char";
+      break;
+    case 0:
+    case INT_SIGNED:
+      name = "int";
+      break;
+    case INT_UNSIGNED:
+      name = "unsigned int";
+      break;
+    case INT_LONG:
+    case INT_SIGNED | INT_LONG:
+      name = "long";
+      break;
+    case INT_UNSIGNED | INT_LONG:
+      name = "unsigned long";
+      break;
+    case INT_SHORT:
+    case INT_SIGNED | INT_SHORT:
+      name = "short";
+      break;
+    case INT_UNSIGNED | INT_SHORT:
+      name = "unsigned short";
+      break;
+    case INT_LLONG | INT_LONG:
+    case INT_SIGNED | INT_LLONG | INT_LONG:
+      name = "long long";
+      break;
+    case INT_UNSIGNED | INT_LLONG | INT_LONG:
+      name = "unsigned long long";
+      break;
+    default:
+      return NULL;
+    }
+
+  return make_builtin_type (name);
+}
+
+/* Wrapper to create a unary operation.  */
+
+static struct demangle_component *
+d_unary (const char *name, struct demangle_component *lhs)
+{
+  return fill_comp (DEMANGLE_COMPONENT_UNARY, make_operator (name, 1), lhs);
+}
+
+/* Wrapper to create a binary operation.  */
+
+static struct demangle_component *
+d_binary (const char *name, struct demangle_component *lhs, struct demangle_component *rhs)
+{
+  return fill_comp (DEMANGLE_COMPONENT_BINARY, make_operator (name, 2),
+		      fill_comp (DEMANGLE_COMPONENT_BINARY_ARGS, lhs, rhs));
+}
+
+/* Find the end of a symbol name starting at LEXPTR.  */
+
+static const char *
+symbol_end (const char *lexptr)
+{
+  const char *p = lexptr;
+
+  while (*p && (ISALNUM (*p) || *p == '_' || *p == '$' || *p == '.'))
+    p++;
+
+  return p;
+}
+
+/* Take care of parsing a number (anything that starts with a digit).
+   The number starts at P and contains LEN characters.  Store the result in
+   YYLVAL.  */
+
+static int
+parse_number (const char *p, int len, int parsed_float)
+{
+  int unsigned_p = 0;
+
+  /* Number of "L" suffixes encountered.  */
+  int long_p = 0;
+
+  struct demangle_component *signed_type;
+  struct demangle_component *unsigned_type;
+  struct demangle_component *type, *name;
+  enum demangle_component_type literal_type;
+
+  if (p[0] == '-')
+    {
+      literal_type = DEMANGLE_COMPONENT_LITERAL_NEG;
+      p++;
+      len--;
+    }
+  else
+    literal_type = DEMANGLE_COMPONENT_LITERAL;
+
+  if (parsed_float)
+    {
+      /* It's a float since it contains a point or an exponent.  */
+      char c;
+
+      /* The GDB lexer checks the result of scanf at this point.  Not doing
+         this leaves our error checking slightly weaker but only for invalid
+         data.  */
+
+      /* See if it has `f' or `l' suffix (float or long double).  */
+
+      c = TOLOWER (p[len - 1]);
+
+      if (c == 'f')
+      	{
+      	  len--;
+      	  type = make_builtin_type ("float");
+      	}
+      else if (c == 'l')
+	{
+	  len--;
+	  type = make_builtin_type ("long double");
+	}
+      else if (ISDIGIT (c) || c == '.')
+	type = make_builtin_type ("double");
+      else
+	return ERROR;
+
+      name = make_name (p, len);
+      yylval.comp = fill_comp (literal_type, type, name);
+
+      return FLOAT;
+    }
+
+  /* This treats 0x1 and 1 as different literals.  We also do not
+     automatically generate unsigned types.  */
+
+  long_p = 0;
+  unsigned_p = 0;
+  while (len > 0)
+    {
+      if (p[len - 1] == 'l' || p[len - 1] == 'L')
+	{
+	  len--;
+	  long_p++;
+	  continue;
+	}
+      if (p[len - 1] == 'u' || p[len - 1] == 'U')
+	{
+	  len--;
+	  unsigned_p++;
+	  continue;
+	}
+      break;
+    }
+
+  if (long_p == 0)
+    {
+      unsigned_type = make_builtin_type ("unsigned int");
+      signed_type = make_builtin_type ("int");
+    }
+  else if (long_p == 1)
+    {
+      unsigned_type = make_builtin_type ("unsigned long");
+      signed_type = make_builtin_type ("long");
+    }
+  else
+    {
+      unsigned_type = make_builtin_type ("unsigned long long");
+      signed_type = make_builtin_type ("long long");
+    }
+
+   if (unsigned_p)
+     type = unsigned_type;
+   else
+     type = signed_type;
+
+   name = make_name (p, len);
+   yylval.comp = fill_comp (literal_type, type, name);
+
+   return INT;
+}
+
+static char backslashable[] = "abefnrtv";
+static char represented[] = "\a\b\e\f\n\r\t\v";
+
+/* Translate the backslash the way we would in the host character set.  */
+static int
+c_parse_backslash (int host_char, int *target_char)
+{
+  const char *ix;
+  ix = strchr (backslashable, host_char);
+  if (! ix)
+    return 0;
+  else
+    *target_char = represented[ix - backslashable];
+  return 1;
+}
+
+/* Parse a C escape sequence.  STRING_PTR points to a variable
+   containing a pointer to the string to parse.  That pointer
+   should point to the character after the \.  That pointer
+   is updated past the characters we use.  The value of the
+   escape sequence is returned.
+
+   A negative value means the sequence \ newline was seen,
+   which is supposed to be equivalent to nothing at all.
+
+   If \ is followed by a null character, we return a negative
+   value and leave the string pointer pointing at the null character.
+
+   If \ is followed by 000, we return 0 and leave the string pointer
+   after the zeros.  A value of 0 does not mean end of string.  */
+
+static int
+parse_escape (const char **string_ptr)
+{
+  int target_char;
+  int c = *(*string_ptr)++;
+  if (c_parse_backslash (c, &target_char))
+    return target_char;
+  else
+    switch (c)
+      {
+      case '\n':
+	return -2;
+      case 0:
+	(*string_ptr)--;
+	return 0;
+      case '^':
+	{
+	  c = *(*string_ptr)++;
+
+	  if (c == '?')
+	    return 0177;
+	  else if (c == '\\')
+	    target_char = parse_escape (string_ptr);
+	  else
+	    target_char = c;
+
+	  /* Now target_char is something like `c', and we want to find
+	     its control-character equivalent.  */
+	  target_char = target_char & 037;
+
+	  return target_char;
+	}
+
+      case '0':
+      case '1':
+      case '2':
+      case '3':
+      case '4':
+      case '5':
+      case '6':
+      case '7':
+	{
+	  int i = c - '0';
+	  int count = 0;
+	  while (++count < 3)
+	    {
+	      c = (**string_ptr);
+	      if (c >= '0' && c <= '7')
+		{
+		  (*string_ptr)++;
+		  i *= 8;
+		  i += c - '0';
+		}
+	      else
+		{
+		  break;
+		}
+	    }
+	  return i;
+	}
+      default:
+	return target_char;
+      }
+}
+
+#define HANDLE_SPECIAL(string, comp)				\
+  if (strncmp (tokstart, string, sizeof (string) - 1) == 0)	\
+    {								\
+      lexptr = tokstart + sizeof (string) - 1;			\
+      yylval.lval = comp;					\
+      return DEMANGLER_SPECIAL;					\
+    }
+
+#define HANDLE_TOKEN2(string, token)			\
+  if (lexptr[1] == string[1])				\
+    {							\
+      lexptr += 2;					\
+      yylval.opname = string;				\
+      return token;					\
+    }      
+
+#define HANDLE_TOKEN3(string, token)			\
+  if (lexptr[1] == string[1] && lexptr[2] == string[2])	\
+    {							\
+      lexptr += 3;					\
+      yylval.opname = string;				\
+      return token;					\
+    }      
+
+/* Read one token, getting characters through LEXPTR.  */
+
+static int
+yylex (void)
+{
+  int c;
+  int namelen;
+  const char *tokstart, *tokptr;
+
+ retry:
+  prev_lexptr = lexptr;
+  tokstart = lexptr;
+
+  switch (c = *tokstart)
+    {
+    case 0:
+      return 0;
+
+    case ' ':
+    case '\t':
+    case '\n':
+      lexptr++;
+      goto retry;
+
+    case '\'':
+      /* We either have a character constant ('0' or '\177' for example)
+	 or we have a quoted symbol reference ('foo(int,int)' in C++
+	 for example). */
+      lexptr++;
+      c = *lexptr++;
+      if (c == '\\')
+	c = parse_escape (&lexptr);
+      else if (c == '\'')
+	{
+	  yyerror ("empty character constant");
+	  return ERROR;
+	}
+
+      c = *lexptr++;
+      if (c != '\'')
+	{
+	  yyerror ("invalid character constant");
+	  return ERROR;
+	}
+
+      /* FIXME: We should refer to a canonical form of the character,
+	 presumably the same one that appears in manglings - the decimal
+	 representation.  But if that isn't in our input then we have to
+	 allocate memory for it somewhere.  */
+      yylval.comp = fill_comp (DEMANGLE_COMPONENT_LITERAL,
+				 make_builtin_type ("char"),
+				 make_name (tokstart, lexptr - tokstart));
+
+      return INT;
+
+    case '(':
+      if (strncmp (tokstart, "(anonymous namespace)", 21) == 0)
+	{
+	  lexptr += 21;
+	  yylval.comp = make_name ("(anonymous namespace)",
+				     sizeof "(anonymous namespace)" - 1);
+	  return NAME;
+	}
+	/* FALL THROUGH */
+
+    case ')':
+    case ',':
+      lexptr++;
+      return c;
+
+    case '.':
+      if (lexptr[1] == '.' && lexptr[2] == '.')
+	{
+	  lexptr += 3;
+	  return ELLIPSIS;
+	}
+
+      /* Might be a floating point number.  */
+      if (lexptr[1] < '0' || lexptr[1] > '9')
+	goto symbol;		/* Nope, must be a symbol. */
+
+      goto try_number;
+
+    case '-':
+      HANDLE_TOKEN2 ("-=", ASSIGN_MODIFY);
+      HANDLE_TOKEN2 ("--", DECREMENT);
+      HANDLE_TOKEN2 ("->", ARROW);
+
+      /* For construction vtables.  This is kind of hokey.  */
+      if (strncmp (tokstart, "-in-", 4) == 0)
+	{
+	  lexptr += 4;
+	  return CONSTRUCTION_IN;
+	}
+
+      if (lexptr[1] < '0' || lexptr[1] > '9')
+	{
+	  lexptr++;
+	  return '-';
+	}
+      /* FALL THRU into number case.  */
+
+    try_number:
+    case '0':
+    case '1':
+    case '2':
+    case '3':
+    case '4':
+    case '5':
+    case '6':
+    case '7':
+    case '8':
+    case '9':
+      {
+	/* It's a number.  */
+	int got_dot = 0, got_e = 0, toktype;
+	const char *p = tokstart;
+	int hex = 0;
+
+	if (c == '-')
+	  p++;
+
+	if (c == '0' && (p[1] == 'x' || p[1] == 'X'))
+	  {
+	    p += 2;
+	    hex = 1;
+	  }
+	else if (c == '0' && (p[1]=='t' || p[1]=='T' || p[1]=='d' || p[1]=='D'))
+	  {
+	    p += 2;
+	    hex = 0;
+	  }
+
+	for (;; ++p)
+	  {
+	    /* This test includes !hex because 'e' is a valid hex digit
+	       and thus does not indicate a floating point number when
+	       the radix is hex.  */
+	    if (!hex && !got_e && (*p == 'e' || *p == 'E'))
+	      got_dot = got_e = 1;
+	    /* This test does not include !hex, because a '.' always indicates
+	       a decimal floating point number regardless of the radix.
+
+	       NOTE drow/2005-03-09: This comment is not accurate in C99;
+	       however, it's not clear that all the floating point support
+	       in this file is doing any good here.  */
+	    else if (!got_dot && *p == '.')
+	      got_dot = 1;
+	    else if (got_e && (p[-1] == 'e' || p[-1] == 'E')
+		     && (*p == '-' || *p == '+'))
+	      /* This is the sign of the exponent, not the end of the
+		 number.  */
+	      continue;
+	    /* We will take any letters or digits.  parse_number will
+	       complain if past the radix, or if L or U are not final.  */
+	    else if (! ISALNUM (*p))
+	      break;
+	  }
+	toktype = parse_number (tokstart, p - tokstart, got_dot|got_e);
+        if (toktype == ERROR)
+	  {
+	    char *err_copy = (char *) alloca (p - tokstart + 1);
+
+	    memcpy (err_copy, tokstart, p - tokstart);
+	    err_copy[p - tokstart] = 0;
+	    yyerror ("invalid number");
+	    return ERROR;
+	  }
+	lexptr = p;
+	return toktype;
+      }
+
+    case '+':
+      HANDLE_TOKEN2 ("+=", ASSIGN_MODIFY);
+      HANDLE_TOKEN2 ("++", INCREMENT);
+      lexptr++;
+      return c;
+    case '*':
+      HANDLE_TOKEN2 ("*=", ASSIGN_MODIFY);
+      lexptr++;
+      return c;
+    case '/':
+      HANDLE_TOKEN2 ("/=", ASSIGN_MODIFY);
+      lexptr++;
+      return c;
+    case '%':
+      HANDLE_TOKEN2 ("%=", ASSIGN_MODIFY);
+      lexptr++;
+      return c;
+    case '|':
+      HANDLE_TOKEN2 ("|=", ASSIGN_MODIFY);
+      HANDLE_TOKEN2 ("||", OROR);
+      lexptr++;
+      return c;
+    case '&':
+      HANDLE_TOKEN2 ("&=", ASSIGN_MODIFY);
+      HANDLE_TOKEN2 ("&&", ANDAND);
+      lexptr++;
+      return c;
+    case '^':
+      HANDLE_TOKEN2 ("^=", ASSIGN_MODIFY);
+      lexptr++;
+      return c;
+    case '!':
+      HANDLE_TOKEN2 ("!=", NOTEQUAL);
+      lexptr++;
+      return c;
+    case '<':
+      HANDLE_TOKEN3 ("<<=", ASSIGN_MODIFY);
+      HANDLE_TOKEN2 ("<=", LEQ);
+      HANDLE_TOKEN2 ("<<", LSH);
+      lexptr++;
+      return c;
+    case '>':
+      HANDLE_TOKEN3 (">>=", ASSIGN_MODIFY);
+      HANDLE_TOKEN2 (">=", GEQ);
+      HANDLE_TOKEN2 (">>", RSH);
+      lexptr++;
+      return c;
+    case '=':
+      HANDLE_TOKEN2 ("==", EQUAL);
+      lexptr++;
+      return c;
+    case ':':
+      HANDLE_TOKEN2 ("::", COLONCOLON);
+      lexptr++;
+      return c;
+
+    case '[':
+    case ']':
+    case '?':
+    case '@':
+    case '~':
+    case '{':
+    case '}':
+    symbol:
+      lexptr++;
+      return c;
+
+    case '"':
+      /* These can't occur in C++ names.  */
+      yyerror ("unexpected string literal");
+      return ERROR;
+    }
+
+  if (!(c == '_' || c == '$' || ISALPHA (c)))
+    {
+      /* We must have come across a bad character (e.g. ';').  */
+      yyerror ("invalid character");
+      return ERROR;
+    }
+
+  /* It's a name.  See how long it is.  */
+  namelen = 0;
+  do
+    c = tokstart[++namelen];
+  while (ISALNUM (c) || c == '_' || c == '$');
+
+  lexptr += namelen;
+
+  /* Catch specific keywords.  Notice that some of the keywords contain
+     spaces, and are sorted by the length of the first word.  They must
+     all include a trailing space in the string comparison.  */
+  switch (namelen)
+    {
+    case 16:
+      if (strncmp (tokstart, "reinterpret_cast", 16) == 0)
+        return REINTERPRET_CAST;
+      break;
+    case 12:
+      if (strncmp (tokstart, "construction vtable for ", 24) == 0)
+	{
+	  lexptr = tokstart + 24;
+	  return CONSTRUCTION_VTABLE;
+	}
+      if (strncmp (tokstart, "dynamic_cast", 12) == 0)
+        return DYNAMIC_CAST;
+      break;
+    case 11:
+      if (strncmp (tokstart, "static_cast", 11) == 0)
+        return STATIC_CAST;
+      break;
+    case 9:
+      HANDLE_SPECIAL ("covariant return thunk to ", DEMANGLE_COMPONENT_COVARIANT_THUNK);
+      HANDLE_SPECIAL ("reference temporary for ", DEMANGLE_COMPONENT_REFTEMP);
+      break;
+    case 8:
+      HANDLE_SPECIAL ("typeinfo for ", DEMANGLE_COMPONENT_TYPEINFO);
+      HANDLE_SPECIAL ("typeinfo fn for ", DEMANGLE_COMPONENT_TYPEINFO_FN);
+      HANDLE_SPECIAL ("typeinfo name for ", DEMANGLE_COMPONENT_TYPEINFO_NAME);
+      if (strncmp (tokstart, "operator", 8) == 0)
+	return OPERATOR;
+      if (strncmp (tokstart, "restrict", 8) == 0)
+	return RESTRICT;
+      if (strncmp (tokstart, "unsigned", 8) == 0)
+	return UNSIGNED;
+      if (strncmp (tokstart, "template", 8) == 0)
+	return TEMPLATE;
+      if (strncmp (tokstart, "volatile", 8) == 0)
+	return VOLATILE_KEYWORD;
+      break;
+    case 7:
+      HANDLE_SPECIAL ("virtual thunk to ", DEMANGLE_COMPONENT_VIRTUAL_THUNK);
+      if (strncmp (tokstart, "wchar_t", 7) == 0)
+	return WCHAR_T;
+      break;
+    case 6:
+      if (strncmp (tokstart, "global constructors keyed to ", 29) == 0)
+	{
+	  const char *p;
+	  lexptr = tokstart + 29;
+	  yylval.typed_val_int.val = GLOBAL_CONSTRUCTORS;
+	  /* Find the end of the symbol.  */
+	  p = symbol_end (lexptr);
+	  yylval.typed_val_int.type = make_name (lexptr, p - lexptr);
+	  lexptr = p;
+	  return GLOBAL;
+	}
+      if (strncmp (tokstart, "global destructors keyed to ", 28) == 0)
+	{
+	  const char *p;
+	  lexptr = tokstart + 28;
+	  yylval.typed_val_int.val = GLOBAL_DESTRUCTORS;
+	  /* Find the end of the symbol.  */
+	  p = symbol_end (lexptr);
+	  yylval.typed_val_int.type = make_name (lexptr, p - lexptr);
+	  lexptr = p;
+	  return GLOBAL;
+	}
+
+      HANDLE_SPECIAL ("vtable for ", DEMANGLE_COMPONENT_VTABLE);
+      if (strncmp (tokstart, "delete", 6) == 0)
+	return DELETE;
+      if (strncmp (tokstart, "struct", 6) == 0)
+	return STRUCT;
+      if (strncmp (tokstart, "signed", 6) == 0)
+	return SIGNED_KEYWORD;
+      if (strncmp (tokstart, "sizeof", 6) == 0)
+	return SIZEOF;
+      if (strncmp (tokstart, "double", 6) == 0)
+	return DOUBLE_KEYWORD;
+      break;
+    case 5:
+      HANDLE_SPECIAL ("guard variable for ", DEMANGLE_COMPONENT_GUARD);
+      if (strncmp (tokstart, "false", 5) == 0)
+	return FALSEKEYWORD;
+      if (strncmp (tokstart, "class", 5) == 0)
+	return CLASS;
+      if (strncmp (tokstart, "union", 5) == 0)
+	return UNION;
+      if (strncmp (tokstart, "float", 5) == 0)
+	return FLOAT_KEYWORD;
+      if (strncmp (tokstart, "short", 5) == 0)
+	return SHORT;
+      if (strncmp (tokstart, "const", 5) == 0)
+	return CONST_KEYWORD;
+      break;
+    case 4:
+      if (strncmp (tokstart, "void", 4) == 0)
+	return VOID;
+      if (strncmp (tokstart, "bool", 4) == 0)
+	return BOOL;
+      if (strncmp (tokstart, "char", 4) == 0)
+	return CHAR;
+      if (strncmp (tokstart, "enum", 4) == 0)
+	return ENUM;
+      if (strncmp (tokstart, "long", 4) == 0)
+	return LONG;
+      if (strncmp (tokstart, "true", 4) == 0)
+	return TRUEKEYWORD;
+      break;
+    case 3:
+      HANDLE_SPECIAL ("VTT for ", DEMANGLE_COMPONENT_VTT);
+      HANDLE_SPECIAL ("non-virtual thunk to ", DEMANGLE_COMPONENT_THUNK);
+      if (strncmp (tokstart, "new", 3) == 0)
+	return NEW;
+      if (strncmp (tokstart, "int", 3) == 0)
+	return INT_KEYWORD;
+      break;
+    default:
+      break;
+    }
+
+  yylval.comp = make_name (tokstart, namelen);
+  return NAME;
+}
+
+static void
+yyerror (char *msg)
+{
+  if (global_errmsg)
+    return;
+
+  error_lexptr = prev_lexptr;
+  global_errmsg = msg ? msg : "parse error";
+}
+
+/* Allocate all the components we'll need to build a tree.  We generally
+   allocate too many components, but the extra memory usage doesn't hurt
+   because the trees are temporary.  If we start keeping the trees for
+   a longer lifetime we'll need to be cleverer.  */
+static struct demangle_info *
+allocate_info (int comps)
+{
+  struct demangle_info *ret;
+
+  ret = malloc (sizeof (struct demangle_info)
+		+ sizeof (struct demangle_component) * (comps - 1));
+  ret->used = 0;
+  return ret;
+}
+
+/* Convert RESULT to a string.  The return value is allocated
+   using xmalloc.  ESTIMATED_LEN is used only as a guide to the
+   length of the result.  This functions handles a few cases that
+   cplus_demangle_print does not, specifically the global destructor
+   and constructor labels.  */
+
+char *
+cp_comp_to_string (struct demangle_component *result, int estimated_len)
+{
+  char *str, *prefix = NULL, *buf;
+  size_t err = 0;
+
+  if (result->type == GLOBAL_DESTRUCTORS)
+    {
+      result = d_left (result);
+      prefix = "global destructors keyed to ";
+    }
+  else if (result->type == GLOBAL_CONSTRUCTORS)
+    {
+      result = d_left (result);
+      prefix = "global constructors keyed to ";
+    }
+
+  str = cplus_demangle_print (DMGL_PARAMS | DMGL_ANSI, result, estimated_len, &err);
+  if (str == NULL)
+    return NULL;
+
+  if (prefix == NULL)
+    return str;
+
+  buf = malloc (strlen (str) + strlen (prefix) + 1);
+  strcpy (buf, prefix);
+  strcat (buf, str);
+  free (str);
+  return (buf);
+}
+
+/* Convert a demangled name to a demangle_component tree.  *MEMORY is set to the
+   block of used memory that should be freed when finished with the
+   tree.  On error, NULL is returned, and an error message will be
+   set in *ERRMSG (which does not need to be freed).  */
+
+struct demangle_component *
+cp_demangled_name_to_comp (const char *demangled_name, void **memory,
+			   const char **errmsg)
+{
+  static char errbuf[60];
+  struct demangle_component *result;
+
+  int len = strlen (demangled_name);
+
+  len = len + len / 8;
+  prev_lexptr = lexptr = demangled_name;
+  error_lexptr = NULL;
+  global_errmsg = NULL;
+
+  demangle_info = allocate_info (len);
+
+  if (yyparse ())
+    {
+      if (global_errmsg && errmsg)
+	{
+	  snprintf (errbuf, sizeof (errbuf) - 2, "%s, near `%s",
+		    global_errmsg, error_lexptr);
+	  strcat (errbuf, "'");
+	  *errmsg = errbuf;
+	}
+      free (demangle_info);
+      return NULL;
+    }
+
+  *memory = demangle_info;
+  result = global_result;
+  global_result = NULL;
+
+  return result;
+}
+
+#ifdef TEST_CPNAMES
+
+static void
+cp_print (struct demangle_component *result)
+{
+  char *str;
+  size_t err = 0;
+
+  if (result->type == GLOBAL_DESTRUCTORS)
+    {
+      result = d_left (result);
+      fputs ("global destructors keyed to ", stdout);
+    }
+  else if (result->type == GLOBAL_CONSTRUCTORS)
+    {
+      result = d_left (result);
+      fputs ("global constructors keyed to ", stdout);
+    }
+
+  str = cplus_demangle_print (DMGL_PARAMS | DMGL_ANSI, result, 64, &err);
+  if (str == NULL)
+    return;
+
+  fputs (str, stdout);
+
+  free (str);
+}
+
+static char
+trim_chars (char *lexptr, char **extra_chars)
+{
+  char *p = (char *) symbol_end (lexptr);
+  char c = 0;
+
+  if (*p)
+    {
+      c = *p;
+      *p = 0;
+      *extra_chars = p + 1;
+    }
+
+  return c;
+}
+
+int
+main (int argc, char **argv)
+{
+  char *str2, *extra_chars, c;
+  char buf[65536];
+  int arg;
+  const char *errmsg;
+  void *memory;
+  struct demangle_component *result;
+
+  arg = 1;
+  if (argv[arg] && strcmp (argv[arg], "--debug") == 0)
+    {
+      yydebug = 1;
+      arg++;
+    }
+
+  if (argv[arg] == NULL)
+    while (fgets (buf, 65536, stdin) != NULL)
+      {
+	int len;
+	buf[strlen (buf) - 1] = 0;
+	/* Use DMGL_VERBOSE to get expanded standard substitutions.  */
+	c = trim_chars (buf, &extra_chars);
+	str2 = cplus_demangle (buf, DMGL_PARAMS | DMGL_ANSI | DMGL_VERBOSE);
+	if (str2 == NULL)
+	  {
+	    /* printf ("Demangling error\n"); */
+	    if (c)
+	      printf ("%s%c%s\n", buf, c, extra_chars);
+	    else
+	      printf ("%s\n", buf);
+	    continue;
+	  }
+	result = cp_demangled_name_to_comp (str2, &memory, &errmsg);
+	if (result == NULL)
+	  {
+	    fputs (errmsg, stderr);
+	    fputc ('\n', stderr);
+	    continue;
+	  }
+
+	cp_print (result);
+	free (memory);
+
+	free (str2);
+	if (c)
+	  {
+	    putchar (c);
+	    fputs (extra_chars, stdout);
+	  }
+	putchar ('\n');
+      }
+  else
+    {
+      result = cp_demangled_name_to_comp (argv[arg], &memory, &errmsg);
+      if (result == NULL)
+	{
+	  fputs (errmsg, stderr);
+	  fputc ('\n', stderr);
+	  return 0;
+	}
+      cp_print (result);
+      putchar ('\n');
+      free (memory);
+    }
+  return 0;
+}
+
+#endif