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