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