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