1 /* YACC parser for C++ names, for GDB.
2 
3    Copyright (C) 2003-2013 Free Software Foundation, Inc.
4 
5    Parts of the lexer are based on c-exp.y from GDB.
6 
7    This file is part of GDB.
8 
9    This program is free software; you can redistribute it and/or modify
10    it under the terms of the GNU General Public License as published by
11    the Free Software Foundation; either version 3 of the License, or
12    (at your option) any later version.
13 
14    This program is distributed in the hope that it will be useful,
15    but WITHOUT ANY WARRANTY; without even the implied warranty of
16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17    GNU General Public License for more details.
18 
19    You should have received a copy of the GNU General Public License
20    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
21 
22 /* Note that malloc's and realloc's in this file are transformed to
23    xmalloc and xrealloc respectively by the same sed command in the
24    makefile that remaps any other malloc/realloc inserted by the parser
25    generator.  Doing this with #defines and trying to control the interaction
26    with include files (<malloc.h> and <stdlib.h> for example) just became
27    too messy, particularly when such includes can be inserted at random
28    times by the parser generator.  */
29 
30 %{
31 
32 #include "defs.h"
33 
34 #include <stdio.h>
35 #include <stdlib.h>
36 #include <unistd.h>
37 #include <string.h>
38 
39 #include "safe-ctype.h"
40 #include "libiberty.h"
41 #include "demangle.h"
42 #include "cp-support.h"
43 #include "gdb_assert.h"
44 
45 /* Bison does not make it easy to create a parser without global
46    state, unfortunately.  Here are all the global variables used
47    in this parser.  */
48 
49 /* LEXPTR is the current pointer into our lex buffer.  PREV_LEXPTR
50    is the start of the last token lexed, only used for diagnostics.
51    ERROR_LEXPTR is the first place an error occurred.  GLOBAL_ERRMSG
52    is the first error message encountered.  */
53 
54 static const char *lexptr, *prev_lexptr, *error_lexptr, *global_errmsg;
55 
56 /* The components built by the parser are allocated ahead of time,
57    and cached in this structure.  */
58 
59 #define ALLOC_CHUNK 100
60 
61 struct demangle_info {
62   int used;
63   struct demangle_info *next;
64   struct demangle_component comps[ALLOC_CHUNK];
65 };
66 
67 static struct demangle_info *demangle_info;
68 
69 static struct demangle_component *
d_grab(void)70 d_grab (void)
71 {
72   struct demangle_info *more;
73 
74   if (demangle_info->used >= ALLOC_CHUNK)
75     {
76       if (demangle_info->next == NULL)
77 	{
78 	  more = malloc (sizeof (struct demangle_info));
79 	  more->next = NULL;
80 	  demangle_info->next = more;
81 	}
82       else
83 	more = demangle_info->next;
84 
85       more->used = 0;
86       demangle_info = more;
87     }
88   return &demangle_info->comps[demangle_info->used++];
89 }
90 
91 /* The parse tree created by the parser is stored here after a successful
92    parse.  */
93 
94 static struct demangle_component *global_result;
95 
96 /* Prototypes for helper functions used when constructing the parse
97    tree.  */
98 
99 static struct demangle_component *d_qualify (struct demangle_component *, int,
100 					     int);
101 
102 static struct demangle_component *d_int_type (int);
103 
104 static struct demangle_component *d_unary (const char *,
105 					   struct demangle_component *);
106 static struct demangle_component *d_binary (const char *,
107 					    struct demangle_component *,
108 					    struct demangle_component *);
109 
110 /* Flags passed to d_qualify.  */
111 
112 #define QUAL_CONST 1
113 #define QUAL_RESTRICT 2
114 #define QUAL_VOLATILE 4
115 
116 /* Flags passed to d_int_type.  */
117 
118 #define INT_CHAR	(1 << 0)
119 #define INT_SHORT	(1 << 1)
120 #define INT_LONG	(1 << 2)
121 #define INT_LLONG	(1 << 3)
122 
123 #define INT_SIGNED	(1 << 4)
124 #define INT_UNSIGNED	(1 << 5)
125 
126 /* Remap normal yacc parser interface names (yyparse, yylex, yyerror, etc),
127    as well as gratuitiously global symbol names, so we can have multiple
128    yacc generated parsers in gdb.  Note that these are only the variables
129    produced by yacc.  If other parser generators (bison, byacc, etc) produce
130    additional global names that conflict at link time, then those parser
131    generators need to be fixed instead of adding those names to this list. */
132 
133 #define	yymaxdepth cpname_maxdepth
134 #define	yyparse	cpname_parse
135 #define	yylex	cpname_lex
136 #define	yyerror	cpname_error
137 #define	yylval	cpname_lval
138 #define	yychar	cpname_char
139 #define	yydebug	cpname_debug
140 #define	yypact	cpname_pact
141 #define	yyr1	cpname_r1
142 #define	yyr2	cpname_r2
143 #define	yydef	cpname_def
144 #define	yychk	cpname_chk
145 #define	yypgo	cpname_pgo
146 #define	yyact	cpname_act
147 #define	yyexca	cpname_exca
148 #define yyerrflag cpname_errflag
149 #define yynerrs	cpname_nerrs
150 #define	yyps	cpname_ps
151 #define	yypv	cpname_pv
152 #define	yys	cpname_s
153 #define	yy_yys	cpname_yys
154 #define	yystate	cpname_state
155 #define	yytmp	cpname_tmp
156 #define	yyv	cpname_v
157 #define	yy_yyv	cpname_yyv
158 #define	yyval	cpname_val
159 #define	yylloc	cpname_lloc
160 #define yyreds	cpname_reds		/* With YYDEBUG defined */
161 #define yytoks	cpname_toks		/* With YYDEBUG defined */
162 #define yyname	cpname_name		/* With YYDEBUG defined */
163 #define yyrule	cpname_rule		/* With YYDEBUG defined */
164 #define yylhs	cpname_yylhs
165 #define yylen	cpname_yylen
166 #define yydefred cpname_yydefred
167 #define yydgoto	cpname_yydgoto
168 #define yysindex cpname_yysindex
169 #define yyrindex cpname_yyrindex
170 #define yygindex cpname_yygindex
171 #define yytable	 cpname_yytable
172 #define yycheck	 cpname_yycheck
173 #define yyss	cpname_yyss
174 #define yysslim	cpname_yysslim
175 #define yyssp	cpname_yyssp
176 #define yystacksize cpname_yystacksize
177 #define yyvs	cpname_yyvs
178 #define yyvsp	cpname_yyvsp
179 
180 int yyparse (void);
181 static int yylex (void);
182 static void yyerror (char *);
183 
184 /* Enable yydebug for the stand-alone parser.  */
185 #ifdef TEST_CPNAMES
186 # define YYDEBUG	1
187 #endif
188 
189 /* Helper functions.  These wrap the demangler tree interface, handle
190    allocation from our global store, and return the allocated component.  */
191 
192 static struct demangle_component *
fill_comp(enum demangle_component_type d_type,struct demangle_component * lhs,struct demangle_component * rhs)193 fill_comp (enum demangle_component_type d_type, struct demangle_component *lhs,
194 	   struct demangle_component *rhs)
195 {
196   struct demangle_component *ret = d_grab ();
197   int i;
198 
199   i = cplus_demangle_fill_component (ret, d_type, lhs, rhs);
200   gdb_assert (i);
201 
202   return ret;
203 }
204 
205 static struct demangle_component *
make_empty(enum demangle_component_type d_type)206 make_empty (enum demangle_component_type d_type)
207 {
208   struct demangle_component *ret = d_grab ();
209   ret->type = d_type;
210   return ret;
211 }
212 
213 static struct demangle_component *
make_operator(const char * name,int args)214 make_operator (const char *name, int args)
215 {
216   struct demangle_component *ret = d_grab ();
217   int i;
218 
219   i = cplus_demangle_fill_operator (ret, name, args);
220   gdb_assert (i);
221 
222   return ret;
223 }
224 
225 static struct demangle_component *
make_dtor(enum gnu_v3_dtor_kinds kind,struct demangle_component * name)226 make_dtor (enum gnu_v3_dtor_kinds kind, struct demangle_component *name)
227 {
228   struct demangle_component *ret = d_grab ();
229   int i;
230 
231   i = cplus_demangle_fill_dtor (ret, kind, name);
232   gdb_assert (i);
233 
234   return ret;
235 }
236 
237 static struct demangle_component *
make_builtin_type(const char * name)238 make_builtin_type (const char *name)
239 {
240   struct demangle_component *ret = d_grab ();
241   int i;
242 
243   i = cplus_demangle_fill_builtin_type (ret, name);
244   gdb_assert (i);
245 
246   return ret;
247 }
248 
249 static struct demangle_component *
make_name(const char * name,int len)250 make_name (const char *name, int len)
251 {
252   struct demangle_component *ret = d_grab ();
253   int i;
254 
255   i = cplus_demangle_fill_name (ret, name, len);
256   gdb_assert (i);
257 
258   return ret;
259 }
260 
261 #define d_left(dc) (dc)->u.s_binary.left
262 #define d_right(dc) (dc)->u.s_binary.right
263 
264 %}
265 
266 %union
267   {
268     struct demangle_component *comp;
269     struct nested {
270       struct demangle_component *comp;
271       struct demangle_component **last;
272     } nested;
273     struct {
274       struct demangle_component *comp, *last;
275     } nested1;
276     struct {
277       struct demangle_component *comp, **last;
278       struct nested fn;
279       struct demangle_component *start;
280       int fold_flag;
281     } abstract;
282     int lval;
283     const char *opname;
284   }
285 
286 %type <comp> exp exp1 type start start_opt operator colon_name
287 %type <comp> unqualified_name colon_ext_name
288 %type <comp> template template_arg
289 %type <comp> builtin_type
290 %type <comp> typespec_2 array_indicator
291 %type <comp> colon_ext_only ext_only_name
292 
293 %type <comp> demangler_special function conversion_op
294 %type <nested> conversion_op_name
295 
296 %type <abstract> abstract_declarator direct_abstract_declarator
297 %type <abstract> abstract_declarator_fn
298 %type <nested> declarator direct_declarator function_arglist
299 
300 %type <nested> declarator_1 direct_declarator_1
301 
302 %type <nested> template_params function_args
303 %type <nested> ptr_operator
304 
305 %type <nested1> nested_name
306 
307 %type <lval> qualifier qualifiers qualifiers_opt
308 
309 %type <lval> int_part int_seq
310 
311 %token <comp> INT
312 %token <comp> FLOAT
313 
314 %token <comp> NAME
315 %type <comp> name
316 
317 %token STRUCT CLASS UNION ENUM SIZEOF UNSIGNED COLONCOLON
318 %token TEMPLATE
319 %token ERROR
320 %token NEW DELETE OPERATOR
321 %token STATIC_CAST REINTERPRET_CAST DYNAMIC_CAST
322 
323 /* Special type cases, put in to allow the parser to distinguish different
324    legal basetypes.  */
325 %token SIGNED_KEYWORD LONG SHORT INT_KEYWORD CONST_KEYWORD VOLATILE_KEYWORD DOUBLE_KEYWORD BOOL
326 %token ELLIPSIS RESTRICT VOID FLOAT_KEYWORD CHAR WCHAR_T
327 
328 %token <opname> ASSIGN_MODIFY
329 
330 /* C++ */
331 %token TRUEKEYWORD
332 %token FALSEKEYWORD
333 
334 /* Non-C++ things we get from the demangler.  */
335 %token <lval> DEMANGLER_SPECIAL
336 %token CONSTRUCTION_VTABLE CONSTRUCTION_IN
337 
338 /* Precedence declarations.  */
339 
340 /* Give NAME lower precedence than COLONCOLON, so that nested_name will
341    associate greedily.  */
342 %nonassoc NAME
343 
344 /* Give NEW and DELETE lower precedence than ']', because we can not
345    have an array of type operator new.  This causes NEW '[' to be
346    parsed as operator new[].  */
347 %nonassoc NEW DELETE
348 
349 /* Give VOID higher precedence than NAME.  Then we can use %prec NAME
350    to prefer (VOID) to (function_args).  */
351 %nonassoc VOID
352 
353 /* Give VOID lower precedence than ')' for similar reasons.  */
354 %nonassoc ')'
355 
356 %left ','
357 %right '=' ASSIGN_MODIFY
358 %right '?'
359 %left OROR
360 %left ANDAND
361 %left '|'
362 %left '^'
363 %left '&'
364 %left EQUAL NOTEQUAL
365 %left '<' '>' LEQ GEQ
366 %left LSH RSH
367 %left '@'
368 %left '+' '-'
369 %left '*' '/' '%'
370 %right UNARY INCREMENT DECREMENT
371 
372 /* We don't need a precedence for '(' in this reduced grammar, and it
373    can mask some unpleasant bugs, so disable it for now.  */
374 
375 %right ARROW '.' '[' /* '(' */
376 %left COLONCOLON
377 
378 
379 %%
380 
381 result		:	start
382 			{ global_result = $1; }
383 		;
384 
385 start		:	type
386 
387 		|	demangler_special
388 
389 		|	function
390 
391 		;
392 
393 start_opt	:	/* */
394 			{ $$ = NULL; }
395 		|	COLONCOLON start
396 			{ $$ = $2; }
397 		;
398 
399 function
400 		/* Function with a return type.  declarator_1 is used to prevent
401 		   ambiguity with the next rule.  */
402 		:	typespec_2 declarator_1
403 			{ $$ = $2.comp;
404 			  *$2.last = $1;
405 			}
406 
407 		/* Function without a return type.  We need to use typespec_2
408 		   to prevent conflicts from qualifiers_opt - harmless.  The
409 		   start_opt is used to handle "function-local" variables and
410 		   types.  */
411 		|	typespec_2 function_arglist start_opt
412 			{ $$ = fill_comp (DEMANGLE_COMPONENT_TYPED_NAME, $1, $2.comp);
413 			  if ($3) $$ = fill_comp (DEMANGLE_COMPONENT_LOCAL_NAME, $$, $3); }
414 		|	colon_ext_only function_arglist start_opt
415 			{ $$ = fill_comp (DEMANGLE_COMPONENT_TYPED_NAME, $1, $2.comp);
416 			  if ($3) $$ = fill_comp (DEMANGLE_COMPONENT_LOCAL_NAME, $$, $3); }
417 
418 		|	conversion_op_name start_opt
419 			{ $$ = $1.comp;
420 			  if ($2) $$ = fill_comp (DEMANGLE_COMPONENT_LOCAL_NAME, $$, $2); }
421 		|	conversion_op_name abstract_declarator_fn
422 			{ if ($2.last)
423 			    {
424 			       /* First complete the abstract_declarator's type using
425 				  the typespec from the conversion_op_name.  */
426 			      *$2.last = *$1.last;
427 			      /* Then complete the conversion_op_name with the type.  */
428 			      *$1.last = $2.comp;
429 			    }
430 			  /* If we have an arglist, build a function type.  */
431 			  if ($2.fn.comp)
432 			    $$ = fill_comp (DEMANGLE_COMPONENT_TYPED_NAME, $1.comp, $2.fn.comp);
433 			  else
434 			    $$ = $1.comp;
435 			  if ($2.start) $$ = fill_comp (DEMANGLE_COMPONENT_LOCAL_NAME, $$, $2.start);
436 			}
437 		;
438 
439 demangler_special
440 		:	DEMANGLER_SPECIAL start
441 			{ $$ = make_empty ($1);
442 			  d_left ($$) = $2;
443 			  d_right ($$) = NULL; }
444 		|	CONSTRUCTION_VTABLE start CONSTRUCTION_IN start
445 			{ $$ = fill_comp (DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE, $2, $4); }
446 		;
447 
448 operator	:	OPERATOR NEW
449 			{
450 			  /* Match the whitespacing of cplus_demangle_operators.
451 			     It would abort on unrecognized string otherwise.  */
452 			  $$ = make_operator ("new", 3);
453 			}
454 		|	OPERATOR DELETE
455 			{
456 			  /* Match the whitespacing of cplus_demangle_operators.
457 			     It would abort on unrecognized string otherwise.  */
458 			  $$ = make_operator ("delete ", 1);
459 			}
460 		|	OPERATOR NEW '[' ']'
461 			{
462 			  /* Match the whitespacing of cplus_demangle_operators.
463 			     It would abort on unrecognized string otherwise.  */
464 			  $$ = make_operator ("new[]", 3);
465 			}
466 		|	OPERATOR DELETE '[' ']'
467 			{
468 			  /* Match the whitespacing of cplus_demangle_operators.
469 			     It would abort on unrecognized string otherwise.  */
470 			  $$ = make_operator ("delete[] ", 1);
471 			}
472 		|	OPERATOR '+'
473 			{ $$ = make_operator ("+", 2); }
474 		|	OPERATOR '-'
475 			{ $$ = make_operator ("-", 2); }
476 		|	OPERATOR '*'
477 			{ $$ = make_operator ("*", 2); }
478 		|	OPERATOR '/'
479 			{ $$ = make_operator ("/", 2); }
480 		|	OPERATOR '%'
481 			{ $$ = make_operator ("%", 2); }
482 		|	OPERATOR '^'
483 			{ $$ = make_operator ("^", 2); }
484 		|	OPERATOR '&'
485 			{ $$ = make_operator ("&", 2); }
486 		|	OPERATOR '|'
487 			{ $$ = make_operator ("|", 2); }
488 		|	OPERATOR '~'
489 			{ $$ = make_operator ("~", 1); }
490 		|	OPERATOR '!'
491 			{ $$ = make_operator ("!", 1); }
492 		|	OPERATOR '='
493 			{ $$ = make_operator ("=", 2); }
494 		|	OPERATOR '<'
495 			{ $$ = make_operator ("<", 2); }
496 		|	OPERATOR '>'
497 			{ $$ = make_operator (">", 2); }
498 		|	OPERATOR ASSIGN_MODIFY
499 			{ $$ = make_operator ($2, 2); }
500 		|	OPERATOR LSH
501 			{ $$ = make_operator ("<<", 2); }
502 		|	OPERATOR RSH
503 			{ $$ = make_operator (">>", 2); }
504 		|	OPERATOR EQUAL
505 			{ $$ = make_operator ("==", 2); }
506 		|	OPERATOR NOTEQUAL
507 			{ $$ = make_operator ("!=", 2); }
508 		|	OPERATOR LEQ
509 			{ $$ = make_operator ("<=", 2); }
510 		|	OPERATOR GEQ
511 			{ $$ = make_operator (">=", 2); }
512 		|	OPERATOR ANDAND
513 			{ $$ = make_operator ("&&", 2); }
514 		|	OPERATOR OROR
515 			{ $$ = make_operator ("||", 2); }
516 		|	OPERATOR INCREMENT
517 			{ $$ = make_operator ("++", 1); }
518 		|	OPERATOR DECREMENT
519 			{ $$ = make_operator ("--", 1); }
520 		|	OPERATOR ','
521 			{ $$ = make_operator (",", 2); }
522 		|	OPERATOR ARROW '*'
523 			{ $$ = make_operator ("->*", 2); }
524 		|	OPERATOR ARROW
525 			{ $$ = make_operator ("->", 2); }
526 		|	OPERATOR '(' ')'
527 			{ $$ = make_operator ("()", 2); }
528 		|	OPERATOR '[' ']'
529 			{ $$ = make_operator ("[]", 2); }
530 		;
531 
532 		/* Conversion operators.  We don't try to handle some of
533 		   the wackier demangler output for function pointers,
534 		   since it's not clear that it's parseable.  */
535 conversion_op
536 		:	OPERATOR typespec_2
537 			{ $$ = fill_comp (DEMANGLE_COMPONENT_CAST, $2, NULL); }
538 		;
539 
540 conversion_op_name
541 		:	nested_name conversion_op
542 			{ $$.comp = $1.comp;
543 			  d_right ($1.last) = $2;
544 			  $$.last = &d_left ($2);
545 			}
546 		|	conversion_op
547 			{ $$.comp = $1;
548 			  $$.last = &d_left ($1);
549 			}
550 		|	COLONCOLON nested_name conversion_op
551 			{ $$.comp = $2.comp;
552 			  d_right ($2.last) = $3;
553 			  $$.last = &d_left ($3);
554 			}
555 		|	COLONCOLON conversion_op
556 			{ $$.comp = $2;
557 			  $$.last = &d_left ($2);
558 			}
559 		;
560 
561 /* DEMANGLE_COMPONENT_NAME */
562 /* This accepts certain invalid placements of '~'.  */
563 unqualified_name:	operator
564 		|	operator '<' template_params '>'
565 			{ $$ = fill_comp (DEMANGLE_COMPONENT_TEMPLATE, $1, $3.comp); }
566 		|	'~' NAME
567 			{ $$ = make_dtor (gnu_v3_complete_object_dtor, $2); }
568 		;
569 
570 /* This rule is used in name and nested_name, and expanded inline there
571    for efficiency.  */
572 /*
573 scope_id	:	NAME
574 		|	template
575 		;
576 */
577 
578 colon_name	:	name
579 		|	COLONCOLON name
580 			{ $$ = $2; }
581 		;
582 
583 /* DEMANGLE_COMPONENT_QUAL_NAME */
584 /* DEMANGLE_COMPONENT_CTOR / DEMANGLE_COMPONENT_DTOR ? */
585 name		:	nested_name NAME %prec NAME
586 			{ $$ = $1.comp; d_right ($1.last) = $2; }
587 		|	NAME %prec NAME
588 		|	nested_name template %prec NAME
589 			{ $$ = $1.comp; d_right ($1.last) = $2; }
590 		|	template %prec NAME
591 		;
592 
593 colon_ext_name	:	colon_name
594 		|	colon_ext_only
595 		;
596 
597 colon_ext_only	:	ext_only_name
598 		|	COLONCOLON ext_only_name
599 			{ $$ = $2; }
600 		;
601 
602 ext_only_name	:	nested_name unqualified_name
603 			{ $$ = $1.comp; d_right ($1.last) = $2; }
604 		|	unqualified_name
605 		;
606 
607 nested_name	:	NAME COLONCOLON
608 			{ $$.comp = make_empty (DEMANGLE_COMPONENT_QUAL_NAME);
609 			  d_left ($$.comp) = $1;
610 			  d_right ($$.comp) = NULL;
611 			  $$.last = $$.comp;
612 			}
613 		|	nested_name NAME COLONCOLON
614 			{ $$.comp = $1.comp;
615 			  d_right ($1.last) = make_empty (DEMANGLE_COMPONENT_QUAL_NAME);
616 			  $$.last = d_right ($1.last);
617 			  d_left ($$.last) = $2;
618 			  d_right ($$.last) = NULL;
619 			}
620 		|	template COLONCOLON
621 			{ $$.comp = make_empty (DEMANGLE_COMPONENT_QUAL_NAME);
622 			  d_left ($$.comp) = $1;
623 			  d_right ($$.comp) = NULL;
624 			  $$.last = $$.comp;
625 			}
626 		|	nested_name template COLONCOLON
627 			{ $$.comp = $1.comp;
628 			  d_right ($1.last) = make_empty (DEMANGLE_COMPONENT_QUAL_NAME);
629 			  $$.last = d_right ($1.last);
630 			  d_left ($$.last) = $2;
631 			  d_right ($$.last) = NULL;
632 			}
633 		;
634 
635 /* DEMANGLE_COMPONENT_TEMPLATE */
636 /* DEMANGLE_COMPONENT_TEMPLATE_ARGLIST */
637 template	:	NAME '<' template_params '>'
638 			{ $$ = fill_comp (DEMANGLE_COMPONENT_TEMPLATE, $1, $3.comp); }
639 		;
640 
641 template_params	:	template_arg
642 			{ $$.comp = fill_comp (DEMANGLE_COMPONENT_TEMPLATE_ARGLIST, $1, NULL);
643 			$$.last = &d_right ($$.comp); }
644 		|	template_params ',' template_arg
645 			{ $$.comp = $1.comp;
646 			  *$1.last = fill_comp (DEMANGLE_COMPONENT_TEMPLATE_ARGLIST, $3, NULL);
647 			  $$.last = &d_right (*$1.last);
648 			}
649 		;
650 
651 /* "type" is inlined into template_arg and function_args.  */
652 
653 /* Also an integral constant-expression of integral type, and a
654    pointer to member (?) */
655 template_arg	:	typespec_2
656 		|	typespec_2 abstract_declarator
657 			{ $$ = $2.comp;
658 			  *$2.last = $1;
659 			}
660 		|	'&' start
661 			{ $$ = fill_comp (DEMANGLE_COMPONENT_UNARY, make_operator ("&", 1), $2); }
662 		|	'&' '(' start ')'
663 			{ $$ = fill_comp (DEMANGLE_COMPONENT_UNARY, make_operator ("&", 1), $3); }
664 		|	exp
665 		;
666 
667 function_args	:	typespec_2
668 			{ $$.comp = fill_comp (DEMANGLE_COMPONENT_ARGLIST, $1, NULL);
669 			  $$.last = &d_right ($$.comp);
670 			}
671 		|	typespec_2 abstract_declarator
672 			{ *$2.last = $1;
673 			  $$.comp = fill_comp (DEMANGLE_COMPONENT_ARGLIST, $2.comp, NULL);
674 			  $$.last = &d_right ($$.comp);
675 			}
676 		|	function_args ',' typespec_2
677 			{ *$1.last = fill_comp (DEMANGLE_COMPONENT_ARGLIST, $3, NULL);
678 			  $$.comp = $1.comp;
679 			  $$.last = &d_right (*$1.last);
680 			}
681 		|	function_args ',' typespec_2 abstract_declarator
682 			{ *$4.last = $3;
683 			  *$1.last = fill_comp (DEMANGLE_COMPONENT_ARGLIST, $4.comp, NULL);
684 			  $$.comp = $1.comp;
685 			  $$.last = &d_right (*$1.last);
686 			}
687 		|	function_args ',' ELLIPSIS
688 			{ *$1.last
689 			    = fill_comp (DEMANGLE_COMPONENT_ARGLIST,
690 					   make_builtin_type ("..."),
691 					   NULL);
692 			  $$.comp = $1.comp;
693 			  $$.last = &d_right (*$1.last);
694 			}
695 		;
696 
697 function_arglist:	'(' function_args ')' qualifiers_opt %prec NAME
698 			{ $$.comp = fill_comp (DEMANGLE_COMPONENT_FUNCTION_TYPE, NULL, $2.comp);
699 			  $$.last = &d_left ($$.comp);
700 			  $$.comp = d_qualify ($$.comp, $4, 1); }
701 		|	'(' VOID ')' qualifiers_opt
702 			{ $$.comp = fill_comp (DEMANGLE_COMPONENT_FUNCTION_TYPE, NULL, NULL);
703 			  $$.last = &d_left ($$.comp);
704 			  $$.comp = d_qualify ($$.comp, $4, 1); }
705 		|	'(' ')' qualifiers_opt
706 			{ $$.comp = fill_comp (DEMANGLE_COMPONENT_FUNCTION_TYPE, NULL, NULL);
707 			  $$.last = &d_left ($$.comp);
708 			  $$.comp = d_qualify ($$.comp, $3, 1); }
709 		;
710 
711 /* Should do something about DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL */
712 qualifiers_opt	:	/* epsilon */
713 			{ $$ = 0; }
714 		|	qualifiers
715 		;
716 
717 qualifier	:	RESTRICT
718 			{ $$ = QUAL_RESTRICT; }
719 		|	VOLATILE_KEYWORD
720 			{ $$ = QUAL_VOLATILE; }
721 		|	CONST_KEYWORD
722 			{ $$ = QUAL_CONST; }
723 		;
724 
725 qualifiers	:	qualifier
726 		|	qualifier qualifiers
727 			{ $$ = $1 | $2; }
728 		;
729 
730 /* This accepts all sorts of invalid constructions and produces
731    invalid output for them - an error would be better.  */
732 
733 int_part	:	INT_KEYWORD
734 			{ $$ = 0; }
735 		|	SIGNED_KEYWORD
736 			{ $$ = INT_SIGNED; }
737 		|	UNSIGNED
738 			{ $$ = INT_UNSIGNED; }
739 		|	CHAR
740 			{ $$ = INT_CHAR; }
741 		|	LONG
742 			{ $$ = INT_LONG; }
743 		|	SHORT
744 			{ $$ = INT_SHORT; }
745 		;
746 
747 int_seq		:	int_part
748 		|	int_seq int_part
749 			{ $$ = $1 | $2; if ($1 & $2 & INT_LONG) $$ = $1 | INT_LLONG; }
750 		;
751 
752 builtin_type	:	int_seq
753 			{ $$ = d_int_type ($1); }
754 		|	FLOAT_KEYWORD
755 			{ $$ = make_builtin_type ("float"); }
756 		|	DOUBLE_KEYWORD
757 			{ $$ = make_builtin_type ("double"); }
758 		|	LONG DOUBLE_KEYWORD
759 			{ $$ = make_builtin_type ("long double"); }
760 		|	BOOL
761 			{ $$ = make_builtin_type ("bool"); }
762 		|	WCHAR_T
763 			{ $$ = make_builtin_type ("wchar_t"); }
764 		|	VOID
765 			{ $$ = make_builtin_type ("void"); }
766 		;
767 
768 ptr_operator	:	'*' qualifiers_opt
769 			{ $$.comp = make_empty (DEMANGLE_COMPONENT_POINTER);
770 			  $$.comp->u.s_binary.left = $$.comp->u.s_binary.right = NULL;
771 			  $$.last = &d_left ($$.comp);
772 			  $$.comp = d_qualify ($$.comp, $2, 0); }
773 		/* g++ seems to allow qualifiers after the reference?  */
774 		|	'&'
775 			{ $$.comp = make_empty (DEMANGLE_COMPONENT_REFERENCE);
776 			  $$.comp->u.s_binary.left = $$.comp->u.s_binary.right = NULL;
777 			  $$.last = &d_left ($$.comp); }
778 		|	nested_name '*' qualifiers_opt
779 			{ $$.comp = make_empty (DEMANGLE_COMPONENT_PTRMEM_TYPE);
780 			  $$.comp->u.s_binary.left = $1.comp;
781 			  /* Convert the innermost DEMANGLE_COMPONENT_QUAL_NAME to a DEMANGLE_COMPONENT_NAME.  */
782 			  *$1.last = *d_left ($1.last);
783 			  $$.comp->u.s_binary.right = NULL;
784 			  $$.last = &d_right ($$.comp);
785 			  $$.comp = d_qualify ($$.comp, $3, 0); }
786 		|	COLONCOLON nested_name '*' qualifiers_opt
787 			{ $$.comp = make_empty (DEMANGLE_COMPONENT_PTRMEM_TYPE);
788 			  $$.comp->u.s_binary.left = $2.comp;
789 			  /* Convert the innermost DEMANGLE_COMPONENT_QUAL_NAME to a DEMANGLE_COMPONENT_NAME.  */
790 			  *$2.last = *d_left ($2.last);
791 			  $$.comp->u.s_binary.right = NULL;
792 			  $$.last = &d_right ($$.comp);
793 			  $$.comp = d_qualify ($$.comp, $4, 0); }
794 		;
795 
796 array_indicator	:	'[' ']'
797 			{ $$ = make_empty (DEMANGLE_COMPONENT_ARRAY_TYPE);
798 			  d_left ($$) = NULL;
799 			}
800 		|	'[' INT ']'
801 			{ $$ = make_empty (DEMANGLE_COMPONENT_ARRAY_TYPE);
802 			  d_left ($$) = $2;
803 			}
804 		;
805 
806 /* Details of this approach inspired by the G++ < 3.4 parser.  */
807 
808 /* This rule is only used in typespec_2, and expanded inline there for
809    efficiency.  */
810 /*
811 typespec	:	builtin_type
812 		|	colon_name
813 		;
814 */
815 
816 typespec_2	:	builtin_type qualifiers
817 			{ $$ = d_qualify ($1, $2, 0); }
818 		|	builtin_type
819 		|	qualifiers builtin_type qualifiers
820 			{ $$ = d_qualify ($2, $1 | $3, 0); }
821 		|	qualifiers builtin_type
822 			{ $$ = d_qualify ($2, $1, 0); }
823 
824 		|	name qualifiers
825 			{ $$ = d_qualify ($1, $2, 0); }
826 		|	name
827 		|	qualifiers name qualifiers
828 			{ $$ = d_qualify ($2, $1 | $3, 0); }
829 		|	qualifiers name
830 			{ $$ = d_qualify ($2, $1, 0); }
831 
832 		|	COLONCOLON name qualifiers
833 			{ $$ = d_qualify ($2, $3, 0); }
834 		|	COLONCOLON name
835 			{ $$ = $2; }
836 		|	qualifiers COLONCOLON name qualifiers
837 			{ $$ = d_qualify ($3, $1 | $4, 0); }
838 		|	qualifiers COLONCOLON name
839 			{ $$ = d_qualify ($3, $1, 0); }
840 		;
841 
842 abstract_declarator
843 		:	ptr_operator
844 			{ $$.comp = $1.comp; $$.last = $1.last;
845 			  $$.fn.comp = NULL; $$.fn.last = NULL; }
846 		|	ptr_operator abstract_declarator
847 			{ $$ = $2; $$.fn.comp = NULL; $$.fn.last = NULL;
848 			  if ($2.fn.comp) { $$.last = $2.fn.last; *$2.last = $2.fn.comp; }
849 			  *$$.last = $1.comp;
850 			  $$.last = $1.last; }
851 		|	direct_abstract_declarator
852 			{ $$.fn.comp = NULL; $$.fn.last = NULL;
853 			  if ($1.fn.comp) { $$.last = $1.fn.last; *$1.last = $1.fn.comp; }
854 			}
855 		;
856 
857 direct_abstract_declarator
858 		:	'(' abstract_declarator ')'
859 			{ $$ = $2; $$.fn.comp = NULL; $$.fn.last = NULL; $$.fold_flag = 1;
860 			  if ($2.fn.comp) { $$.last = $2.fn.last; *$2.last = $2.fn.comp; }
861 			}
862 		|	direct_abstract_declarator function_arglist
863 			{ $$.fold_flag = 0;
864 			  if ($1.fn.comp) { $$.last = $1.fn.last; *$1.last = $1.fn.comp; }
865 			  if ($1.fold_flag)
866 			    {
867 			      *$$.last = $2.comp;
868 			      $$.last = $2.last;
869 			    }
870 			  else
871 			    $$.fn = $2;
872 			}
873 		|	direct_abstract_declarator array_indicator
874 			{ $$.fn.comp = NULL; $$.fn.last = NULL; $$.fold_flag = 0;
875 			  if ($1.fn.comp) { $$.last = $1.fn.last; *$1.last = $1.fn.comp; }
876 			  *$1.last = $2;
877 			  $$.last = &d_right ($2);
878 			}
879 		|	array_indicator
880 			{ $$.fn.comp = NULL; $$.fn.last = NULL; $$.fold_flag = 0;
881 			  $$.comp = $1;
882 			  $$.last = &d_right ($1);
883 			}
884 		/* G++ has the following except for () and (type).  Then
885 		   (type) is handled in regcast_or_absdcl and () is handled
886 		   in fcast_or_absdcl.
887 
888 		   However, this is only useful for function types, and
889 		   generates reduce/reduce conflicts with direct_declarator.
890 		   We're interested in pointer-to-function types, and in
891 		   functions, but not in function types - so leave this
892 		   out.  */
893 		/* |	function_arglist */
894 		;
895 
896 abstract_declarator_fn
897 		:	ptr_operator
898 			{ $$.comp = $1.comp; $$.last = $1.last;
899 			  $$.fn.comp = NULL; $$.fn.last = NULL; $$.start = NULL; }
900 		|	ptr_operator abstract_declarator_fn
901 			{ $$ = $2;
902 			  if ($2.last)
903 			    *$$.last = $1.comp;
904 			  else
905 			    $$.comp = $1.comp;
906 			  $$.last = $1.last;
907 			}
908 		|	direct_abstract_declarator
909 			{ $$.comp = $1.comp; $$.last = $1.last; $$.fn = $1.fn; $$.start = NULL; }
910 		|	direct_abstract_declarator function_arglist COLONCOLON start
911 			{ $$.start = $4;
912 			  if ($1.fn.comp) { $$.last = $1.fn.last; *$1.last = $1.fn.comp; }
913 			  if ($1.fold_flag)
914 			    {
915 			      *$$.last = $2.comp;
916 			      $$.last = $2.last;
917 			    }
918 			  else
919 			    $$.fn = $2;
920 			}
921 		|	function_arglist start_opt
922 			{ $$.fn = $1;
923 			  $$.start = $2;
924 			  $$.comp = NULL; $$.last = NULL;
925 			}
926 		;
927 
928 type		:	typespec_2
929 		|	typespec_2 abstract_declarator
930 			{ $$ = $2.comp;
931 			  *$2.last = $1;
932 			}
933 		;
934 
935 declarator	:	ptr_operator declarator
936 			{ $$.comp = $2.comp;
937 			  $$.last = $1.last;
938 			  *$2.last = $1.comp; }
939 		|	direct_declarator
940 		;
941 
942 direct_declarator
943 		:	'(' declarator ')'
944 			{ $$ = $2; }
945 		|	direct_declarator function_arglist
946 			{ $$.comp = $1.comp;
947 			  *$1.last = $2.comp;
948 			  $$.last = $2.last;
949 			}
950 		|	direct_declarator array_indicator
951 			{ $$.comp = $1.comp;
952 			  *$1.last = $2;
953 			  $$.last = &d_right ($2);
954 			}
955 		|	colon_ext_name
956 			{ $$.comp = make_empty (DEMANGLE_COMPONENT_TYPED_NAME);
957 			  d_left ($$.comp) = $1;
958 			  $$.last = &d_right ($$.comp);
959 			}
960 		;
961 
962 /* These are similar to declarator and direct_declarator except that they
963    do not permit ( colon_ext_name ), which is ambiguous with a function
964    argument list.  They also don't permit a few other forms with redundant
965    parentheses around the colon_ext_name; any colon_ext_name in parentheses
966    must be followed by an argument list or an array indicator, or preceded
967    by a pointer.  */
968 declarator_1	:	ptr_operator declarator_1
969 			{ $$.comp = $2.comp;
970 			  $$.last = $1.last;
971 			  *$2.last = $1.comp; }
972 		|	colon_ext_name
973 			{ $$.comp = make_empty (DEMANGLE_COMPONENT_TYPED_NAME);
974 			  d_left ($$.comp) = $1;
975 			  $$.last = &d_right ($$.comp);
976 			}
977 		|	direct_declarator_1
978 
979 			/* Function local variable or type.  The typespec to
980 			   our left is the type of the containing function.
981 			   This should be OK, because function local types
982 			   can not be templates, so the return types of their
983 			   members will not be mangled.  If they are hopefully
984 			   they'll end up to the right of the ::.  */
985 		|	colon_ext_name function_arglist COLONCOLON start
986 			{ $$.comp = fill_comp (DEMANGLE_COMPONENT_TYPED_NAME, $1, $2.comp);
987 			  $$.last = $2.last;
988 			  $$.comp = fill_comp (DEMANGLE_COMPONENT_LOCAL_NAME, $$.comp, $4);
989 			}
990 		|	direct_declarator_1 function_arglist COLONCOLON start
991 			{ $$.comp = $1.comp;
992 			  *$1.last = $2.comp;
993 			  $$.last = $2.last;
994 			  $$.comp = fill_comp (DEMANGLE_COMPONENT_LOCAL_NAME, $$.comp, $4);
995 			}
996 		;
997 
998 direct_declarator_1
999 		:	'(' ptr_operator declarator ')'
1000 			{ $$.comp = $3.comp;
1001 			  $$.last = $2.last;
1002 			  *$3.last = $2.comp; }
1003 		|	direct_declarator_1 function_arglist
1004 			{ $$.comp = $1.comp;
1005 			  *$1.last = $2.comp;
1006 			  $$.last = $2.last;
1007 			}
1008 		|	direct_declarator_1 array_indicator
1009 			{ $$.comp = $1.comp;
1010 			  *$1.last = $2;
1011 			  $$.last = &d_right ($2);
1012 			}
1013 		|	colon_ext_name function_arglist
1014 			{ $$.comp = fill_comp (DEMANGLE_COMPONENT_TYPED_NAME, $1, $2.comp);
1015 			  $$.last = $2.last;
1016 			}
1017 		|	colon_ext_name array_indicator
1018 			{ $$.comp = fill_comp (DEMANGLE_COMPONENT_TYPED_NAME, $1, $2);
1019 			  $$.last = &d_right ($2);
1020 			}
1021 		;
1022 
1023 exp	:	'(' exp1 ')'
1024 		{ $$ = $2; }
1025 	;
1026 
1027 /* Silly trick.  Only allow '>' when parenthesized, in order to
1028    handle conflict with templates.  */
1029 exp1	:	exp
1030 	;
1031 
1032 exp1	:	exp '>' exp
1033 		{ $$ = d_binary (">", $1, $3); }
1034 	;
1035 
1036 /* References.  Not allowed everywhere in template parameters, only
1037    at the top level, but treat them as expressions in case they are wrapped
1038    in parentheses.  */
1039 exp1	:	'&' start
1040 		{ $$ = fill_comp (DEMANGLE_COMPONENT_UNARY, make_operator ("&", 1), $2); }
1041 	|	'&' '(' start ')'
1042 		{ $$ = fill_comp (DEMANGLE_COMPONENT_UNARY, make_operator ("&", 1), $3); }
1043 	;
1044 
1045 /* Expressions, not including the comma operator.  */
1046 exp	:	'-' exp    %prec UNARY
1047 		{ $$ = d_unary ("-", $2); }
1048 	;
1049 
1050 exp	:	'!' exp    %prec UNARY
1051 		{ $$ = d_unary ("!", $2); }
1052 	;
1053 
1054 exp	:	'~' exp    %prec UNARY
1055 		{ $$ = d_unary ("~", $2); }
1056 	;
1057 
1058 /* Casts.  First your normal C-style cast.  If exp is a LITERAL, just change
1059    its type.  */
1060 
1061 exp	:	'(' type ')' exp  %prec UNARY
1062 		{ if ($4->type == DEMANGLE_COMPONENT_LITERAL
1063 		      || $4->type == DEMANGLE_COMPONENT_LITERAL_NEG)
1064 		    {
1065 		      $$ = $4;
1066 		      d_left ($4) = $2;
1067 		    }
1068 		  else
1069 		    $$ = fill_comp (DEMANGLE_COMPONENT_UNARY,
1070 				      fill_comp (DEMANGLE_COMPONENT_CAST, $2, NULL),
1071 				      $4);
1072 		}
1073 	;
1074 
1075 /* Mangling does not differentiate between these, so we don't need to
1076    either.  */
1077 exp	:	STATIC_CAST '<' type '>' '(' exp1 ')' %prec UNARY
1078 		{ $$ = fill_comp (DEMANGLE_COMPONENT_UNARY,
1079 				    fill_comp (DEMANGLE_COMPONENT_CAST, $3, NULL),
1080 				    $6);
1081 		}
1082 	;
1083 
1084 exp	:	DYNAMIC_CAST '<' type '>' '(' exp1 ')' %prec UNARY
1085 		{ $$ = fill_comp (DEMANGLE_COMPONENT_UNARY,
1086 				    fill_comp (DEMANGLE_COMPONENT_CAST, $3, NULL),
1087 				    $6);
1088 		}
1089 	;
1090 
1091 exp	:	REINTERPRET_CAST '<' type '>' '(' exp1 ')' %prec UNARY
1092 		{ $$ = fill_comp (DEMANGLE_COMPONENT_UNARY,
1093 				    fill_comp (DEMANGLE_COMPONENT_CAST, $3, NULL),
1094 				    $6);
1095 		}
1096 	;
1097 
1098 /* Another form of C++-style cast is "type ( exp1 )".  This creates too many
1099    conflicts to support.  For a while we supported the simpler
1100    "typespec_2 ( exp1 )", but that conflicts with "& ( start )" as a
1101    reference, deep within the wilderness of abstract declarators:
1102    Qux<int(&(*))> vs Qux<int(&(var))>, a shift-reduce conflict at the
1103    innermost left parenthesis.  So we do not support function-like casts.
1104    Fortunately they never appear in demangler output.  */
1105 
1106 /* TO INVESTIGATE: ._0 style anonymous names; anonymous namespaces */
1107 
1108 /* Binary operators in order of decreasing precedence.  */
1109 
1110 exp	:	exp '*' exp
1111 		{ $$ = d_binary ("*", $1, $3); }
1112 	;
1113 
1114 exp	:	exp '/' exp
1115 		{ $$ = d_binary ("/", $1, $3); }
1116 	;
1117 
1118 exp	:	exp '%' exp
1119 		{ $$ = d_binary ("%", $1, $3); }
1120 	;
1121 
1122 exp	:	exp '+' exp
1123 		{ $$ = d_binary ("+", $1, $3); }
1124 	;
1125 
1126 exp	:	exp '-' exp
1127 		{ $$ = d_binary ("-", $1, $3); }
1128 	;
1129 
1130 exp	:	exp LSH exp
1131 		{ $$ = d_binary ("<<", $1, $3); }
1132 	;
1133 
1134 exp	:	exp RSH exp
1135 		{ $$ = d_binary (">>", $1, $3); }
1136 	;
1137 
1138 exp	:	exp EQUAL exp
1139 		{ $$ = d_binary ("==", $1, $3); }
1140 	;
1141 
1142 exp	:	exp NOTEQUAL exp
1143 		{ $$ = d_binary ("!=", $1, $3); }
1144 	;
1145 
1146 exp	:	exp LEQ exp
1147 		{ $$ = d_binary ("<=", $1, $3); }
1148 	;
1149 
1150 exp	:	exp GEQ exp
1151 		{ $$ = d_binary (">=", $1, $3); }
1152 	;
1153 
1154 exp	:	exp '<' exp
1155 		{ $$ = d_binary ("<", $1, $3); }
1156 	;
1157 
1158 exp	:	exp '&' exp
1159 		{ $$ = d_binary ("&", $1, $3); }
1160 	;
1161 
1162 exp	:	exp '^' exp
1163 		{ $$ = d_binary ("^", $1, $3); }
1164 	;
1165 
1166 exp	:	exp '|' exp
1167 		{ $$ = d_binary ("|", $1, $3); }
1168 	;
1169 
1170 exp	:	exp ANDAND exp
1171 		{ $$ = d_binary ("&&", $1, $3); }
1172 	;
1173 
1174 exp	:	exp OROR exp
1175 		{ $$ = d_binary ("||", $1, $3); }
1176 	;
1177 
1178 /* Not 100% sure these are necessary, but they're harmless.  */
1179 exp	:	exp ARROW NAME
1180 		{ $$ = d_binary ("->", $1, $3); }
1181 	;
1182 
1183 exp	:	exp '.' NAME
1184 		{ $$ = d_binary (".", $1, $3); }
1185 	;
1186 
1187 exp	:	exp '?' exp ':' exp	%prec '?'
1188 		{ $$ = fill_comp (DEMANGLE_COMPONENT_TRINARY, make_operator ("?", 3),
1189 				    fill_comp (DEMANGLE_COMPONENT_TRINARY_ARG1, $1,
1190 						 fill_comp (DEMANGLE_COMPONENT_TRINARY_ARG2, $3, $5)));
1191 		}
1192 	;
1193 
1194 exp	:	INT
1195 	;
1196 
1197 /* Not generally allowed.  */
1198 exp	:	FLOAT
1199 	;
1200 
1201 exp	:	SIZEOF '(' type ')'	%prec UNARY
1202 		{
1203 		  /* Match the whitespacing of cplus_demangle_operators.
1204 		     It would abort on unrecognized string otherwise.  */
1205 		  $$ = d_unary ("sizeof ", $3);
1206 		}
1207 	;
1208 
1209 /* C++.  */
1210 exp     :       TRUEKEYWORD
1211 		{ struct demangle_component *i;
1212 		  i = make_name ("1", 1);
1213 		  $$ = fill_comp (DEMANGLE_COMPONENT_LITERAL,
1214 				    make_builtin_type ("bool"),
1215 				    i);
1216 		}
1217 	;
1218 
1219 exp     :       FALSEKEYWORD
1220 		{ struct demangle_component *i;
1221 		  i = make_name ("0", 1);
1222 		  $$ = fill_comp (DEMANGLE_COMPONENT_LITERAL,
1223 				    make_builtin_type ("bool"),
1224 				    i);
1225 		}
1226 	;
1227 
1228 /* end of C++.  */
1229 
1230 %%
1231 
1232 /* Apply QUALIFIERS to LHS and return a qualified component.  IS_METHOD
1233    is set if LHS is a method, in which case the qualifiers are logically
1234    applied to "this".  We apply qualifiers in a consistent order; LHS
1235    may already be qualified; duplicate qualifiers are not created.  */
1236 
1237 struct demangle_component *
1238 d_qualify (struct demangle_component *lhs, int qualifiers, int is_method)
1239 {
1240   struct demangle_component **inner_p;
1241   enum demangle_component_type type;
1242 
1243   /* For now the order is CONST (innermost), VOLATILE, RESTRICT.  */
1244 
1245 #define HANDLE_QUAL(TYPE, MTYPE, QUAL)				\
1246   if ((qualifiers & QUAL) && (type != TYPE) && (type != MTYPE))	\
1247     {								\
1248       *inner_p = fill_comp (is_method ? MTYPE : TYPE,	\
1249 			      *inner_p, NULL);			\
1250       inner_p = &d_left (*inner_p);				\
1251       type = (*inner_p)->type;					\
1252     }								\
1253   else if (type == TYPE || type == MTYPE)			\
1254     {								\
1255       inner_p = &d_left (*inner_p);				\
1256       type = (*inner_p)->type;					\
1257     }
1258 
1259   inner_p = &lhs;
1260 
1261   type = (*inner_p)->type;
1262 
1263   HANDLE_QUAL (DEMANGLE_COMPONENT_RESTRICT, DEMANGLE_COMPONENT_RESTRICT_THIS, QUAL_RESTRICT);
1264   HANDLE_QUAL (DEMANGLE_COMPONENT_VOLATILE, DEMANGLE_COMPONENT_VOLATILE_THIS, QUAL_VOLATILE);
1265   HANDLE_QUAL (DEMANGLE_COMPONENT_CONST, DEMANGLE_COMPONENT_CONST_THIS, QUAL_CONST);
1266 
1267   return lhs;
1268 }
1269 
1270 /* Return a builtin type corresponding to FLAGS.  */
1271 
1272 static struct demangle_component *
d_int_type(int flags)1273 d_int_type (int flags)
1274 {
1275   const char *name;
1276 
1277   switch (flags)
1278     {
1279     case INT_SIGNED | INT_CHAR:
1280       name = "signed char";
1281       break;
1282     case INT_CHAR:
1283       name = "char";
1284       break;
1285     case INT_UNSIGNED | INT_CHAR:
1286       name = "unsigned char";
1287       break;
1288     case 0:
1289     case INT_SIGNED:
1290       name = "int";
1291       break;
1292     case INT_UNSIGNED:
1293       name = "unsigned int";
1294       break;
1295     case INT_LONG:
1296     case INT_SIGNED | INT_LONG:
1297       name = "long";
1298       break;
1299     case INT_UNSIGNED | INT_LONG:
1300       name = "unsigned long";
1301       break;
1302     case INT_SHORT:
1303     case INT_SIGNED | INT_SHORT:
1304       name = "short";
1305       break;
1306     case INT_UNSIGNED | INT_SHORT:
1307       name = "unsigned short";
1308       break;
1309     case INT_LLONG | INT_LONG:
1310     case INT_SIGNED | INT_LLONG | INT_LONG:
1311       name = "long long";
1312       break;
1313     case INT_UNSIGNED | INT_LLONG | INT_LONG:
1314       name = "unsigned long long";
1315       break;
1316     default:
1317       return NULL;
1318     }
1319 
1320   return make_builtin_type (name);
1321 }
1322 
1323 /* Wrapper to create a unary operation.  */
1324 
1325 static struct demangle_component *
d_unary(const char * name,struct demangle_component * lhs)1326 d_unary (const char *name, struct demangle_component *lhs)
1327 {
1328   return fill_comp (DEMANGLE_COMPONENT_UNARY, make_operator (name, 1), lhs);
1329 }
1330 
1331 /* Wrapper to create a binary operation.  */
1332 
1333 static struct demangle_component *
d_binary(const char * name,struct demangle_component * lhs,struct demangle_component * rhs)1334 d_binary (const char *name, struct demangle_component *lhs, struct demangle_component *rhs)
1335 {
1336   return fill_comp (DEMANGLE_COMPONENT_BINARY, make_operator (name, 2),
1337 		      fill_comp (DEMANGLE_COMPONENT_BINARY_ARGS, lhs, rhs));
1338 }
1339 
1340 /* Find the end of a symbol name starting at LEXPTR.  */
1341 
1342 static const char *
symbol_end(const char * lexptr)1343 symbol_end (const char *lexptr)
1344 {
1345   const char *p = lexptr;
1346 
1347   while (*p && (ISALNUM (*p) || *p == '_' || *p == '$' || *p == '.'))
1348     p++;
1349 
1350   return p;
1351 }
1352 
1353 /* Take care of parsing a number (anything that starts with a digit).
1354    The number starts at P and contains LEN characters.  Store the result in
1355    YYLVAL.  */
1356 
1357 static int
parse_number(const char * p,int len,int parsed_float)1358 parse_number (const char *p, int len, int parsed_float)
1359 {
1360   int unsigned_p = 0;
1361 
1362   /* Number of "L" suffixes encountered.  */
1363   int long_p = 0;
1364 
1365   struct demangle_component *signed_type;
1366   struct demangle_component *unsigned_type;
1367   struct demangle_component *type, *name;
1368   enum demangle_component_type literal_type;
1369 
1370   if (p[0] == '-')
1371     {
1372       literal_type = DEMANGLE_COMPONENT_LITERAL_NEG;
1373       p++;
1374       len--;
1375     }
1376   else
1377     literal_type = DEMANGLE_COMPONENT_LITERAL;
1378 
1379   if (parsed_float)
1380     {
1381       /* It's a float since it contains a point or an exponent.  */
1382       char c;
1383 
1384       /* The GDB lexer checks the result of scanf at this point.  Not doing
1385          this leaves our error checking slightly weaker but only for invalid
1386          data.  */
1387 
1388       /* See if it has `f' or `l' suffix (float or long double).  */
1389 
1390       c = TOLOWER (p[len - 1]);
1391 
1392       if (c == 'f')
1393       	{
1394       	  len--;
1395       	  type = make_builtin_type ("float");
1396       	}
1397       else if (c == 'l')
1398 	{
1399 	  len--;
1400 	  type = make_builtin_type ("long double");
1401 	}
1402       else if (ISDIGIT (c) || c == '.')
1403 	type = make_builtin_type ("double");
1404       else
1405 	return ERROR;
1406 
1407       name = make_name (p, len);
1408       yylval.comp = fill_comp (literal_type, type, name);
1409 
1410       return FLOAT;
1411     }
1412 
1413   /* This treats 0x1 and 1 as different literals.  We also do not
1414      automatically generate unsigned types.  */
1415 
1416   long_p = 0;
1417   unsigned_p = 0;
1418   while (len > 0)
1419     {
1420       if (p[len - 1] == 'l' || p[len - 1] == 'L')
1421 	{
1422 	  len--;
1423 	  long_p++;
1424 	  continue;
1425 	}
1426       if (p[len - 1] == 'u' || p[len - 1] == 'U')
1427 	{
1428 	  len--;
1429 	  unsigned_p++;
1430 	  continue;
1431 	}
1432       break;
1433     }
1434 
1435   if (long_p == 0)
1436     {
1437       unsigned_type = make_builtin_type ("unsigned int");
1438       signed_type = make_builtin_type ("int");
1439     }
1440   else if (long_p == 1)
1441     {
1442       unsigned_type = make_builtin_type ("unsigned long");
1443       signed_type = make_builtin_type ("long");
1444     }
1445   else
1446     {
1447       unsigned_type = make_builtin_type ("unsigned long long");
1448       signed_type = make_builtin_type ("long long");
1449     }
1450 
1451    if (unsigned_p)
1452      type = unsigned_type;
1453    else
1454      type = signed_type;
1455 
1456    name = make_name (p, len);
1457    yylval.comp = fill_comp (literal_type, type, name);
1458 
1459    return INT;
1460 }
1461 
1462 static char backslashable[] = "abefnrtv";
1463 static char represented[] = "\a\b\e\f\n\r\t\v";
1464 
1465 /* Translate the backslash the way we would in the host character set.  */
1466 static int
c_parse_backslash(int host_char,int * target_char)1467 c_parse_backslash (int host_char, int *target_char)
1468 {
1469   const char *ix;
1470   ix = strchr (backslashable, host_char);
1471   if (! ix)
1472     return 0;
1473   else
1474     *target_char = represented[ix - backslashable];
1475   return 1;
1476 }
1477 
1478 /* Parse a C escape sequence.  STRING_PTR points to a variable
1479    containing a pointer to the string to parse.  That pointer
1480    should point to the character after the \.  That pointer
1481    is updated past the characters we use.  The value of the
1482    escape sequence is returned.
1483 
1484    A negative value means the sequence \ newline was seen,
1485    which is supposed to be equivalent to nothing at all.
1486 
1487    If \ is followed by a null character, we return a negative
1488    value and leave the string pointer pointing at the null character.
1489 
1490    If \ is followed by 000, we return 0 and leave the string pointer
1491    after the zeros.  A value of 0 does not mean end of string.  */
1492 
1493 static int
cp_parse_escape(const char ** string_ptr)1494 cp_parse_escape (const char **string_ptr)
1495 {
1496   int target_char;
1497   int c = *(*string_ptr)++;
1498   if (c_parse_backslash (c, &target_char))
1499     return target_char;
1500   else
1501     switch (c)
1502       {
1503       case '\n':
1504 	return -2;
1505       case 0:
1506 	(*string_ptr)--;
1507 	return 0;
1508       case '^':
1509 	{
1510 	  c = *(*string_ptr)++;
1511 
1512 	  if (c == '?')
1513 	    return 0177;
1514 	  else if (c == '\\')
1515 	    target_char = cp_parse_escape (string_ptr);
1516 	  else
1517 	    target_char = c;
1518 
1519 	  /* Now target_char is something like `c', and we want to find
1520 	     its control-character equivalent.  */
1521 	  target_char = target_char & 037;
1522 
1523 	  return target_char;
1524 	}
1525 
1526       case '0':
1527       case '1':
1528       case '2':
1529       case '3':
1530       case '4':
1531       case '5':
1532       case '6':
1533       case '7':
1534 	{
1535 	  int i = c - '0';
1536 	  int count = 0;
1537 	  while (++count < 3)
1538 	    {
1539 	      c = (**string_ptr);
1540 	      if (c >= '0' && c <= '7')
1541 		{
1542 		  (*string_ptr)++;
1543 		  i *= 8;
1544 		  i += c - '0';
1545 		}
1546 	      else
1547 		{
1548 		  break;
1549 		}
1550 	    }
1551 	  return i;
1552 	}
1553       default:
1554 	return c;
1555       }
1556 }
1557 
1558 #define HANDLE_SPECIAL(string, comp)				\
1559   if (strncmp (tokstart, string, sizeof (string) - 1) == 0)	\
1560     {								\
1561       lexptr = tokstart + sizeof (string) - 1;			\
1562       yylval.lval = comp;					\
1563       return DEMANGLER_SPECIAL;					\
1564     }
1565 
1566 #define HANDLE_TOKEN2(string, token)			\
1567   if (lexptr[1] == string[1])				\
1568     {							\
1569       lexptr += 2;					\
1570       yylval.opname = string;				\
1571       return token;					\
1572     }
1573 
1574 #define HANDLE_TOKEN3(string, token)			\
1575   if (lexptr[1] == string[1] && lexptr[2] == string[2])	\
1576     {							\
1577       lexptr += 3;					\
1578       yylval.opname = string;				\
1579       return token;					\
1580     }
1581 
1582 /* Read one token, getting characters through LEXPTR.  */
1583 
1584 static int
yylex(void)1585 yylex (void)
1586 {
1587   int c;
1588   int namelen;
1589   const char *tokstart;
1590 
1591  retry:
1592   prev_lexptr = lexptr;
1593   tokstart = lexptr;
1594 
1595   switch (c = *tokstart)
1596     {
1597     case 0:
1598       return 0;
1599 
1600     case ' ':
1601     case '\t':
1602     case '\n':
1603       lexptr++;
1604       goto retry;
1605 
1606     case '\'':
1607       /* We either have a character constant ('0' or '\177' for example)
1608 	 or we have a quoted symbol reference ('foo(int,int)' in C++
1609 	 for example). */
1610       lexptr++;
1611       c = *lexptr++;
1612       if (c == '\\')
1613 	c = cp_parse_escape (&lexptr);
1614       else if (c == '\'')
1615 	{
1616 	  yyerror (_("empty character constant"));
1617 	  return ERROR;
1618 	}
1619 
1620       c = *lexptr++;
1621       if (c != '\'')
1622 	{
1623 	  yyerror (_("invalid character constant"));
1624 	  return ERROR;
1625 	}
1626 
1627       /* FIXME: We should refer to a canonical form of the character,
1628 	 presumably the same one that appears in manglings - the decimal
1629 	 representation.  But if that isn't in our input then we have to
1630 	 allocate memory for it somewhere.  */
1631       yylval.comp = fill_comp (DEMANGLE_COMPONENT_LITERAL,
1632 				 make_builtin_type ("char"),
1633 				 make_name (tokstart, lexptr - tokstart));
1634 
1635       return INT;
1636 
1637     case '(':
1638       if (strncmp (tokstart, "(anonymous namespace)", 21) == 0)
1639 	{
1640 	  lexptr += 21;
1641 	  yylval.comp = make_name ("(anonymous namespace)",
1642 				     sizeof "(anonymous namespace)" - 1);
1643 	  return NAME;
1644 	}
1645 	/* FALL THROUGH */
1646 
1647     case ')':
1648     case ',':
1649       lexptr++;
1650       return c;
1651 
1652     case '.':
1653       if (lexptr[1] == '.' && lexptr[2] == '.')
1654 	{
1655 	  lexptr += 3;
1656 	  return ELLIPSIS;
1657 	}
1658 
1659       /* Might be a floating point number.  */
1660       if (lexptr[1] < '0' || lexptr[1] > '9')
1661 	goto symbol;		/* Nope, must be a symbol. */
1662 
1663       goto try_number;
1664 
1665     case '-':
1666       HANDLE_TOKEN2 ("-=", ASSIGN_MODIFY);
1667       HANDLE_TOKEN2 ("--", DECREMENT);
1668       HANDLE_TOKEN2 ("->", ARROW);
1669 
1670       /* For construction vtables.  This is kind of hokey.  */
1671       if (strncmp (tokstart, "-in-", 4) == 0)
1672 	{
1673 	  lexptr += 4;
1674 	  return CONSTRUCTION_IN;
1675 	}
1676 
1677       if (lexptr[1] < '0' || lexptr[1] > '9')
1678 	{
1679 	  lexptr++;
1680 	  return '-';
1681 	}
1682       /* FALL THRU into number case.  */
1683 
1684     try_number:
1685     case '0':
1686     case '1':
1687     case '2':
1688     case '3':
1689     case '4':
1690     case '5':
1691     case '6':
1692     case '7':
1693     case '8':
1694     case '9':
1695       {
1696 	/* It's a number.  */
1697 	int got_dot = 0, got_e = 0, toktype;
1698 	const char *p = tokstart;
1699 	int hex = 0;
1700 
1701 	if (c == '-')
1702 	  p++;
1703 
1704 	if (c == '0' && (p[1] == 'x' || p[1] == 'X'))
1705 	  {
1706 	    p += 2;
1707 	    hex = 1;
1708 	  }
1709 	else if (c == '0' && (p[1]=='t' || p[1]=='T' || p[1]=='d' || p[1]=='D'))
1710 	  {
1711 	    p += 2;
1712 	    hex = 0;
1713 	  }
1714 
1715 	for (;; ++p)
1716 	  {
1717 	    /* This test includes !hex because 'e' is a valid hex digit
1718 	       and thus does not indicate a floating point number when
1719 	       the radix is hex.  */
1720 	    if (!hex && !got_e && (*p == 'e' || *p == 'E'))
1721 	      got_dot = got_e = 1;
1722 	    /* This test does not include !hex, because a '.' always indicates
1723 	       a decimal floating point number regardless of the radix.
1724 
1725 	       NOTE drow/2005-03-09: This comment is not accurate in C99;
1726 	       however, it's not clear that all the floating point support
1727 	       in this file is doing any good here.  */
1728 	    else if (!got_dot && *p == '.')
1729 	      got_dot = 1;
1730 	    else if (got_e && (p[-1] == 'e' || p[-1] == 'E')
1731 		     && (*p == '-' || *p == '+'))
1732 	      /* This is the sign of the exponent, not the end of the
1733 		 number.  */
1734 	      continue;
1735 	    /* We will take any letters or digits.  parse_number will
1736 	       complain if past the radix, or if L or U are not final.  */
1737 	    else if (! ISALNUM (*p))
1738 	      break;
1739 	  }
1740 	toktype = parse_number (tokstart, p - tokstart, got_dot|got_e);
1741         if (toktype == ERROR)
1742 	  {
1743 	    char *err_copy = (char *) alloca (p - tokstart + 1);
1744 
1745 	    memcpy (err_copy, tokstart, p - tokstart);
1746 	    err_copy[p - tokstart] = 0;
1747 	    yyerror (_("invalid number"));
1748 	    return ERROR;
1749 	  }
1750 	lexptr = p;
1751 	return toktype;
1752       }
1753 
1754     case '+':
1755       HANDLE_TOKEN2 ("+=", ASSIGN_MODIFY);
1756       HANDLE_TOKEN2 ("++", INCREMENT);
1757       lexptr++;
1758       return c;
1759     case '*':
1760       HANDLE_TOKEN2 ("*=", ASSIGN_MODIFY);
1761       lexptr++;
1762       return c;
1763     case '/':
1764       HANDLE_TOKEN2 ("/=", ASSIGN_MODIFY);
1765       lexptr++;
1766       return c;
1767     case '%':
1768       HANDLE_TOKEN2 ("%=", ASSIGN_MODIFY);
1769       lexptr++;
1770       return c;
1771     case '|':
1772       HANDLE_TOKEN2 ("|=", ASSIGN_MODIFY);
1773       HANDLE_TOKEN2 ("||", OROR);
1774       lexptr++;
1775       return c;
1776     case '&':
1777       HANDLE_TOKEN2 ("&=", ASSIGN_MODIFY);
1778       HANDLE_TOKEN2 ("&&", ANDAND);
1779       lexptr++;
1780       return c;
1781     case '^':
1782       HANDLE_TOKEN2 ("^=", ASSIGN_MODIFY);
1783       lexptr++;
1784       return c;
1785     case '!':
1786       HANDLE_TOKEN2 ("!=", NOTEQUAL);
1787       lexptr++;
1788       return c;
1789     case '<':
1790       HANDLE_TOKEN3 ("<<=", ASSIGN_MODIFY);
1791       HANDLE_TOKEN2 ("<=", LEQ);
1792       HANDLE_TOKEN2 ("<<", LSH);
1793       lexptr++;
1794       return c;
1795     case '>':
1796       HANDLE_TOKEN3 (">>=", ASSIGN_MODIFY);
1797       HANDLE_TOKEN2 (">=", GEQ);
1798       HANDLE_TOKEN2 (">>", RSH);
1799       lexptr++;
1800       return c;
1801     case '=':
1802       HANDLE_TOKEN2 ("==", EQUAL);
1803       lexptr++;
1804       return c;
1805     case ':':
1806       HANDLE_TOKEN2 ("::", COLONCOLON);
1807       lexptr++;
1808       return c;
1809 
1810     case '[':
1811     case ']':
1812     case '?':
1813     case '@':
1814     case '~':
1815     case '{':
1816     case '}':
1817     symbol:
1818       lexptr++;
1819       return c;
1820 
1821     case '"':
1822       /* These can't occur in C++ names.  */
1823       yyerror (_("unexpected string literal"));
1824       return ERROR;
1825     }
1826 
1827   if (!(c == '_' || c == '$' || ISALPHA (c)))
1828     {
1829       /* We must have come across a bad character (e.g. ';').  */
1830       yyerror (_("invalid character"));
1831       return ERROR;
1832     }
1833 
1834   /* It's a name.  See how long it is.  */
1835   namelen = 0;
1836   do
1837     c = tokstart[++namelen];
1838   while (ISALNUM (c) || c == '_' || c == '$');
1839 
1840   lexptr += namelen;
1841 
1842   /* Catch specific keywords.  Notice that some of the keywords contain
1843      spaces, and are sorted by the length of the first word.  They must
1844      all include a trailing space in the string comparison.  */
1845   switch (namelen)
1846     {
1847     case 16:
1848       if (strncmp (tokstart, "reinterpret_cast", 16) == 0)
1849         return REINTERPRET_CAST;
1850       break;
1851     case 12:
1852       if (strncmp (tokstart, "construction vtable for ", 24) == 0)
1853 	{
1854 	  lexptr = tokstart + 24;
1855 	  return CONSTRUCTION_VTABLE;
1856 	}
1857       if (strncmp (tokstart, "dynamic_cast", 12) == 0)
1858         return DYNAMIC_CAST;
1859       break;
1860     case 11:
1861       if (strncmp (tokstart, "static_cast", 11) == 0)
1862         return STATIC_CAST;
1863       break;
1864     case 9:
1865       HANDLE_SPECIAL ("covariant return thunk to ", DEMANGLE_COMPONENT_COVARIANT_THUNK);
1866       HANDLE_SPECIAL ("reference temporary for ", DEMANGLE_COMPONENT_REFTEMP);
1867       break;
1868     case 8:
1869       HANDLE_SPECIAL ("typeinfo for ", DEMANGLE_COMPONENT_TYPEINFO);
1870       HANDLE_SPECIAL ("typeinfo fn for ", DEMANGLE_COMPONENT_TYPEINFO_FN);
1871       HANDLE_SPECIAL ("typeinfo name for ", DEMANGLE_COMPONENT_TYPEINFO_NAME);
1872       if (strncmp (tokstart, "operator", 8) == 0)
1873 	return OPERATOR;
1874       if (strncmp (tokstart, "restrict", 8) == 0)
1875 	return RESTRICT;
1876       if (strncmp (tokstart, "unsigned", 8) == 0)
1877 	return UNSIGNED;
1878       if (strncmp (tokstart, "template", 8) == 0)
1879 	return TEMPLATE;
1880       if (strncmp (tokstart, "volatile", 8) == 0)
1881 	return VOLATILE_KEYWORD;
1882       break;
1883     case 7:
1884       HANDLE_SPECIAL ("virtual thunk to ", DEMANGLE_COMPONENT_VIRTUAL_THUNK);
1885       if (strncmp (tokstart, "wchar_t", 7) == 0)
1886 	return WCHAR_T;
1887       break;
1888     case 6:
1889       if (strncmp (tokstart, "global constructors keyed to ", 29) == 0)
1890 	{
1891 	  const char *p;
1892 	  lexptr = tokstart + 29;
1893 	  yylval.lval = DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS;
1894 	  /* Find the end of the symbol.  */
1895 	  p = symbol_end (lexptr);
1896 	  yylval.comp = make_name (lexptr, p - lexptr);
1897 	  lexptr = p;
1898 	  return DEMANGLER_SPECIAL;
1899 	}
1900       if (strncmp (tokstart, "global destructors keyed to ", 28) == 0)
1901 	{
1902 	  const char *p;
1903 	  lexptr = tokstart + 28;
1904 	  yylval.lval = DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS;
1905 	  /* Find the end of the symbol.  */
1906 	  p = symbol_end (lexptr);
1907 	  yylval.comp = make_name (lexptr, p - lexptr);
1908 	  lexptr = p;
1909 	  return DEMANGLER_SPECIAL;
1910 	}
1911 
1912       HANDLE_SPECIAL ("vtable for ", DEMANGLE_COMPONENT_VTABLE);
1913       if (strncmp (tokstart, "delete", 6) == 0)
1914 	return DELETE;
1915       if (strncmp (tokstart, "struct", 6) == 0)
1916 	return STRUCT;
1917       if (strncmp (tokstart, "signed", 6) == 0)
1918 	return SIGNED_KEYWORD;
1919       if (strncmp (tokstart, "sizeof", 6) == 0)
1920 	return SIZEOF;
1921       if (strncmp (tokstart, "double", 6) == 0)
1922 	return DOUBLE_KEYWORD;
1923       break;
1924     case 5:
1925       HANDLE_SPECIAL ("guard variable for ", DEMANGLE_COMPONENT_GUARD);
1926       if (strncmp (tokstart, "false", 5) == 0)
1927 	return FALSEKEYWORD;
1928       if (strncmp (tokstart, "class", 5) == 0)
1929 	return CLASS;
1930       if (strncmp (tokstart, "union", 5) == 0)
1931 	return UNION;
1932       if (strncmp (tokstart, "float", 5) == 0)
1933 	return FLOAT_KEYWORD;
1934       if (strncmp (tokstart, "short", 5) == 0)
1935 	return SHORT;
1936       if (strncmp (tokstart, "const", 5) == 0)
1937 	return CONST_KEYWORD;
1938       break;
1939     case 4:
1940       if (strncmp (tokstart, "void", 4) == 0)
1941 	return VOID;
1942       if (strncmp (tokstart, "bool", 4) == 0)
1943 	return BOOL;
1944       if (strncmp (tokstart, "char", 4) == 0)
1945 	return CHAR;
1946       if (strncmp (tokstart, "enum", 4) == 0)
1947 	return ENUM;
1948       if (strncmp (tokstart, "long", 4) == 0)
1949 	return LONG;
1950       if (strncmp (tokstart, "true", 4) == 0)
1951 	return TRUEKEYWORD;
1952       break;
1953     case 3:
1954       HANDLE_SPECIAL ("VTT for ", DEMANGLE_COMPONENT_VTT);
1955       HANDLE_SPECIAL ("non-virtual thunk to ", DEMANGLE_COMPONENT_THUNK);
1956       if (strncmp (tokstart, "new", 3) == 0)
1957 	return NEW;
1958       if (strncmp (tokstart, "int", 3) == 0)
1959 	return INT_KEYWORD;
1960       break;
1961     default:
1962       break;
1963     }
1964 
1965   yylval.comp = make_name (tokstart, namelen);
1966   return NAME;
1967 }
1968 
1969 static void
yyerror(char * msg)1970 yyerror (char *msg)
1971 {
1972   if (global_errmsg)
1973     return;
1974 
1975   error_lexptr = prev_lexptr;
1976   global_errmsg = msg ? msg : "parse error";
1977 }
1978 
1979 /* Allocate a chunk of the components we'll need to build a tree.  We
1980    generally allocate too many components, but the extra memory usage
1981    doesn't hurt because the trees are temporary and the storage is
1982    reused.  More may be allocated later, by d_grab.  */
1983 static struct demangle_info *
allocate_info(void)1984 allocate_info (void)
1985 {
1986   struct demangle_info *info = malloc (sizeof (struct demangle_info));
1987 
1988   info->next = NULL;
1989   info->used = 0;
1990   return info;
1991 }
1992 
1993 /* Convert RESULT to a string.  The return value is allocated
1994    using xmalloc.  ESTIMATED_LEN is used only as a guide to the
1995    length of the result.  This functions handles a few cases that
1996    cplus_demangle_print does not, specifically the global destructor
1997    and constructor labels.  */
1998 
1999 char *
cp_comp_to_string(struct demangle_component * result,int estimated_len)2000 cp_comp_to_string (struct demangle_component *result, int estimated_len)
2001 {
2002   size_t err;
2003 
2004   return cplus_demangle_print (DMGL_PARAMS | DMGL_ANSI, result, estimated_len,
2005 			       &err);
2006 }
2007 
2008 /* A convenience function to allocate and initialize a new struct
2009    demangled_parse_info.  */
2010 
2011 struct demangle_parse_info *
cp_new_demangle_parse_info(void)2012 cp_new_demangle_parse_info (void)
2013 {
2014   struct demangle_parse_info *info;
2015 
2016   info = malloc (sizeof (struct demangle_parse_info));
2017   info->info = NULL;
2018   info->tree = NULL;
2019   obstack_init (&info->obstack);
2020 
2021   return info;
2022 }
2023 
2024 /* Free any memory associated with the given PARSE_INFO.  */
2025 
2026 void
cp_demangled_name_parse_free(struct demangle_parse_info * parse_info)2027 cp_demangled_name_parse_free (struct demangle_parse_info *parse_info)
2028 {
2029   struct demangle_info *info = parse_info->info;
2030 
2031   /* Free any allocated chunks of memory for the parse.  */
2032   while (info != NULL)
2033     {
2034       struct demangle_info *next = info->next;
2035 
2036       free (info);
2037       info = next;
2038     }
2039 
2040   /* Free any memory allocated during typedef replacement.  */
2041   obstack_free (&parse_info->obstack, NULL);
2042 
2043   /* Free the parser info.  */
2044   free (parse_info);
2045 }
2046 
2047 /* Merge the two parse trees given by DEST and SRC.  The parse tree
2048    in SRC is attached to DEST at the node represented by TARGET.
2049    SRC is then freed.
2050 
2051    NOTE 1: Since there is no API to merge obstacks, this function does
2052    even attempt to try it.  Fortunately, we do not (yet?) need this ability.
2053    The code will assert if SRC->obstack is not empty.
2054 
2055    NOTE 2: The string from which SRC was parsed must not be freed, since
2056    this function will place pointers to that string into DEST.  */
2057 
2058 void
cp_merge_demangle_parse_infos(struct demangle_parse_info * dest,struct demangle_component * target,struct demangle_parse_info * src)2059 cp_merge_demangle_parse_infos (struct demangle_parse_info *dest,
2060 			       struct demangle_component *target,
2061 			       struct demangle_parse_info *src)
2062 
2063 {
2064   struct demangle_info *di;
2065 
2066   /* Copy the SRC's parse data into DEST.  */
2067   *target = *src->tree;
2068   di = dest->info;
2069   while (di->next != NULL)
2070     di = di->next;
2071   di->next = src->info;
2072 
2073   /* Clear the (pointer to) SRC's parse data so that it is not freed when
2074      cp_demangled_parse_info_free is called.  */
2075   src->info = NULL;
2076 
2077   /* Free SRC.  */
2078   cp_demangled_name_parse_free (src);
2079 }
2080 
2081 /* Convert a demangled name to a demangle_component tree.  On success,
2082    a structure containing the root of the new tree is returned; it must
2083    be freed by calling cp_demangled_name_parse_free. On error, NULL is
2084    returned, and an error message will be set in *ERRMSG (which does
2085    not need to be freed).  */
2086 
2087 struct demangle_parse_info *
cp_demangled_name_to_comp(const char * demangled_name,const char ** errmsg)2088 cp_demangled_name_to_comp (const char *demangled_name, const char **errmsg)
2089 {
2090   static char errbuf[60];
2091   struct demangle_parse_info *result;
2092 
2093   prev_lexptr = lexptr = demangled_name;
2094   error_lexptr = NULL;
2095   global_errmsg = NULL;
2096 
2097   demangle_info = allocate_info ();
2098 
2099   result = cp_new_demangle_parse_info ();
2100   result->info = demangle_info;
2101 
2102   if (yyparse ())
2103     {
2104       if (global_errmsg && errmsg)
2105 	{
2106 	  snprintf (errbuf, sizeof (errbuf) - 2, "%s, near `%s",
2107 		    global_errmsg, error_lexptr);
2108 	  strcat (errbuf, "'");
2109 	  *errmsg = errbuf;
2110 	}
2111       cp_demangled_name_parse_free (result);
2112       return NULL;
2113     }
2114 
2115   result->tree = global_result;
2116   global_result = NULL;
2117 
2118   return result;
2119 }
2120 
2121 #ifdef TEST_CPNAMES
2122 
2123 static void
cp_print(struct demangle_component * result)2124 cp_print (struct demangle_component *result)
2125 {
2126   char *str;
2127   size_t err = 0;
2128 
2129   str = cplus_demangle_print (DMGL_PARAMS | DMGL_ANSI, result, 64, &err);
2130   if (str == NULL)
2131     return;
2132 
2133   fputs (str, stdout);
2134 
2135   free (str);
2136 }
2137 
2138 static char
trim_chars(char * lexptr,char ** extra_chars)2139 trim_chars (char *lexptr, char **extra_chars)
2140 {
2141   char *p = (char *) symbol_end (lexptr);
2142   char c = 0;
2143 
2144   if (*p)
2145     {
2146       c = *p;
2147       *p = 0;
2148       *extra_chars = p + 1;
2149     }
2150 
2151   return c;
2152 }
2153 
2154 /* When this file is built as a standalone program, xmalloc comes from
2155    libiberty --- in which case we have to provide xfree ourselves.  */
2156 
2157 void
xfree(void * ptr)2158 xfree (void *ptr)
2159 {
2160   if (ptr != NULL)
2161     {
2162       /* Literal `free' would get translated back to xfree again.  */
2163       CONCAT2 (fr,ee) (ptr);
2164     }
2165 }
2166 
2167 /* GDB normally defines internal_error itself, but when this file is built
2168    as a standalone program, we must also provide an implementation.  */
2169 
2170 void
internal_error(const char * file,int line,const char * fmt,...)2171 internal_error (const char *file, int line, const char *fmt, ...)
2172 {
2173   va_list ap;
2174 
2175   va_start (ap, fmt);
2176   fprintf (stderr, "%s:%d: internal error: ", file, line);
2177   vfprintf (stderr, fmt, ap);
2178   exit (1);
2179 }
2180 
2181 int
main(int argc,char ** argv)2182 main (int argc, char **argv)
2183 {
2184   char *str2, *extra_chars = "", c;
2185   char buf[65536];
2186   int arg;
2187   const char *errmsg;
2188   struct demangle_parse_info *result;
2189 
2190   arg = 1;
2191   if (argv[arg] && strcmp (argv[arg], "--debug") == 0)
2192     {
2193       yydebug = 1;
2194       arg++;
2195     }
2196 
2197   if (argv[arg] == NULL)
2198     while (fgets (buf, 65536, stdin) != NULL)
2199       {
2200 	int len;
2201 	buf[strlen (buf) - 1] = 0;
2202 	/* Use DMGL_VERBOSE to get expanded standard substitutions.  */
2203 	c = trim_chars (buf, &extra_chars);
2204 	str2 = cplus_demangle (buf, DMGL_PARAMS | DMGL_ANSI | DMGL_VERBOSE);
2205 	if (str2 == NULL)
2206 	  {
2207 	    printf ("Demangling error\n");
2208 	    if (c)
2209 	      printf ("%s%c%s\n", buf, c, extra_chars);
2210 	    else
2211 	      printf ("%s\n", buf);
2212 	    continue;
2213 	  }
2214 	result = cp_demangled_name_to_comp (str2, &errmsg);
2215 	if (result == NULL)
2216 	  {
2217 	    fputs (errmsg, stderr);
2218 	    fputc ('\n', stderr);
2219 	    continue;
2220 	  }
2221 
2222 	cp_print (result->tree);
2223 	cp_demangled_name_parse_free (result);
2224 
2225 	free (str2);
2226 	if (c)
2227 	  {
2228 	    putchar (c);
2229 	    fputs (extra_chars, stdout);
2230 	  }
2231 	putchar ('\n');
2232       }
2233   else
2234     {
2235       result = cp_demangled_name_to_comp (argv[arg], &errmsg);
2236       if (result == NULL)
2237 	{
2238 	  fputs (errmsg, stderr);
2239 	  fputc ('\n', stderr);
2240 	  return 0;
2241 	}
2242       cp_print (result->tree);
2243       cp_demangled_name_parse_free (result);
2244       putchar ('\n');
2245     }
2246   return 0;
2247 }
2248 
2249 #endif
2250