1 /* YACC parser for C++ names, for GDB.
3 Copyright (C) 2003-2017 Free Software Foundation, Inc.
5 Parts of the lexer are based on c-exp.y from GDB.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
22 /* Note that malloc's and realloc's in this file are transformed to
23 xmalloc and xrealloc respectively by the same sed command in the
24 makefile that remaps any other malloc/realloc inserted by the parser
25 generator. Doing this with #defines and trying to control the interaction
26 with include files (<malloc.h> and <stdlib.h> for example) just became
27 too messy, particularly when such includes can be inserted at random
28 times by the parser generator. */
35 #include "safe-ctype.h"
37 #include "cp-support.h"
39 /* Bison does not make it easy to create a parser without global
40 state, unfortunately. Here are all the global variables used
43 /* LEXPTR is the current pointer into our lex buffer. PREV_LEXPTR
44 is the start of the last token lexed, only used for diagnostics.
45 ERROR_LEXPTR is the first place an error occurred. GLOBAL_ERRMSG
46 is the first error message encountered. */
48 static const char *lexptr, *prev_lexptr, *error_lexptr, *global_errmsg;
50 /* The components built by the parser are allocated ahead of time,
51 and cached in this structure. */
53 #define ALLOC_CHUNK 100
55 struct demangle_info {
57 struct demangle_info *next;
58 struct demangle_component comps[ALLOC_CHUNK];
61 static struct demangle_info *demangle_info;
63 static struct demangle_component *
66 struct demangle_info *more;
68 if (demangle_info->used >= ALLOC_CHUNK)
70 if (demangle_info->next == NULL)
72 more = XNEW (struct demangle_info);
74 demangle_info->next = more;
77 more = demangle_info->next;
82 return &demangle_info->comps[demangle_info->used++];
85 /* The parse tree created by the parser is stored here after a successful
88 static struct demangle_component *global_result;
90 /* Prototypes for helper functions used when constructing the parse
93 static struct demangle_component *d_qualify (struct demangle_component *, int,
96 static struct demangle_component *d_int_type (int);
98 static struct demangle_component *d_unary (const char *,
99 struct demangle_component *);
100 static struct demangle_component *d_binary (const char *,
101 struct demangle_component *,
102 struct demangle_component *);
104 /* Flags passed to d_qualify. */
107 #define QUAL_RESTRICT 2
108 #define QUAL_VOLATILE 4
110 /* Flags passed to d_int_type. */
112 #define INT_CHAR (1 << 0)
113 #define INT_SHORT (1 << 1)
114 #define INT_LONG (1 << 2)
115 #define INT_LLONG (1 << 3)
117 #define INT_SIGNED (1 << 4)
118 #define INT_UNSIGNED (1 << 5)
120 /* Remap normal yacc parser interface names (yyparse, yylex, yyerror, etc),
121 as well as gratuitiously global symbol names, so we can have multiple
122 yacc generated parsers in gdb. Note that these are only the variables
123 produced by yacc. If other parser generators (bison, byacc, etc) produce
124 additional global names that conflict at link time, then those parser
125 generators need to be fixed instead of adding those names to this list. */
127 #define yymaxdepth cpname_maxdepth
128 #define yyparse cpname_parse
129 #define yylex cpname_lex
130 #define yyerror cpname_error
131 #define yylval cpname_lval
132 #define yychar cpname_char
133 #define yydebug cpname_debug
134 #define yypact cpname_pact
135 #define yyr1 cpname_r1
136 #define yyr2 cpname_r2
137 #define yydef cpname_def
138 #define yychk cpname_chk
139 #define yypgo cpname_pgo
140 #define yyact cpname_act
141 #define yyexca cpname_exca
142 #define yyerrflag cpname_errflag
143 #define yynerrs cpname_nerrs
144 #define yyps cpname_ps
145 #define yypv cpname_pv
147 #define yy_yys cpname_yys
148 #define yystate cpname_state
149 #define yytmp cpname_tmp
151 #define yy_yyv cpname_yyv
152 #define yyval cpname_val
153 #define yylloc cpname_lloc
154 #define yyreds cpname_reds /* With YYDEBUG defined */
155 #define yytoks cpname_toks /* With YYDEBUG defined */
156 #define yyname cpname_name /* With YYDEBUG defined */
157 #define yyrule cpname_rule /* With YYDEBUG defined */
158 #define yylhs cpname_yylhs
159 #define yylen cpname_yylen
160 #define yydefred cpname_yydefred
161 #define yydgoto cpname_yydgoto
162 #define yysindex cpname_yysindex
163 #define yyrindex cpname_yyrindex
164 #define yygindex cpname_yygindex
165 #define yytable cpname_yytable
166 #define yycheck cpname_yycheck
167 #define yyss cpname_yyss
168 #define yysslim cpname_yysslim
169 #define yyssp cpname_yyssp
170 #define yystacksize cpname_yystacksize
171 #define yyvs cpname_yyvs
172 #define yyvsp cpname_yyvsp
175 static int yylex (void);
176 static void yyerror (char *);
178 /* Enable yydebug for the stand-alone parser. */
183 /* Helper functions. These wrap the demangler tree interface, handle
184 allocation from our global store, and return the allocated component. */
186 static struct demangle_component *
187 fill_comp (enum demangle_component_type d_type, struct demangle_component *lhs,
188 struct demangle_component *rhs)
190 struct demangle_component *ret = d_grab ();
193 i = cplus_demangle_fill_component (ret, d_type, lhs, rhs);
199 static struct demangle_component *
200 make_empty (enum demangle_component_type d_type)
202 struct demangle_component *ret = d_grab ();
208 static struct demangle_component *
209 make_operator (const char *name, int args)
211 struct demangle_component *ret = d_grab ();
214 i = cplus_demangle_fill_operator (ret, name, args);
220 static struct demangle_component *
221 make_dtor (enum gnu_v3_dtor_kinds kind, struct demangle_component *name)
223 struct demangle_component *ret = d_grab ();
226 i = cplus_demangle_fill_dtor (ret, kind, name);
232 static struct demangle_component *
233 make_builtin_type (const char *name)
235 struct demangle_component *ret = d_grab ();
238 i = cplus_demangle_fill_builtin_type (ret, name);
244 static struct demangle_component *
245 make_name (const char *name, int len)
247 struct demangle_component *ret = d_grab ();
250 i = cplus_demangle_fill_name (ret, name, len);
256 #define d_left(dc) (dc)->u.s_binary.left
257 #define d_right(dc) (dc)->u.s_binary.right
263 struct demangle_component *comp;
265 struct demangle_component *comp;
266 struct demangle_component **last;
269 struct demangle_component *comp, *last;
272 struct demangle_component *comp, **last;
274 struct demangle_component *start;
281 %type <comp> exp exp1 type start start_opt oper colon_name
282 %type <comp> unqualified_name colon_ext_name
283 %type <comp> templ template_arg
284 %type <comp> builtin_type
285 %type <comp> typespec_2 array_indicator
286 %type <comp> colon_ext_only ext_only_name
288 %type <comp> demangler_special function conversion_op
289 %type <nested> conversion_op_name
291 %type <abstract> abstract_declarator direct_abstract_declarator
292 %type <abstract> abstract_declarator_fn
293 %type <nested> declarator direct_declarator function_arglist
295 %type <nested> declarator_1 direct_declarator_1
297 %type <nested> template_params function_args
298 %type <nested> ptr_operator
300 %type <nested1> nested_name
302 %type <lval> qualifier qualifiers qualifiers_opt
304 %type <lval> int_part int_seq
312 %token STRUCT CLASS UNION ENUM SIZEOF UNSIGNED COLONCOLON
315 %token NEW DELETE OPERATOR
316 %token STATIC_CAST REINTERPRET_CAST DYNAMIC_CAST
318 /* Special type cases, put in to allow the parser to distinguish different
320 %token SIGNED_KEYWORD LONG SHORT INT_KEYWORD CONST_KEYWORD VOLATILE_KEYWORD DOUBLE_KEYWORD BOOL
321 %token ELLIPSIS RESTRICT VOID FLOAT_KEYWORD CHAR WCHAR_T
323 %token <opname> ASSIGN_MODIFY
329 /* Non-C++ things we get from the demangler. */
330 %token <lval> DEMANGLER_SPECIAL
331 %token CONSTRUCTION_VTABLE CONSTRUCTION_IN
333 /* Precedence declarations. */
335 /* Give NAME lower precedence than COLONCOLON, so that nested_name will
336 associate greedily. */
339 /* Give NEW and DELETE lower precedence than ']', because we can not
340 have an array of type operator new. This causes NEW '[' to be
341 parsed as operator new[]. */
344 /* Give VOID higher precedence than NAME. Then we can use %prec NAME
345 to prefer (VOID) to (function_args). */
348 /* Give VOID lower precedence than ')' for similar reasons. */
352 %right '=' ASSIGN_MODIFY
360 %left '<' '>' LEQ GEQ
365 %right UNARY INCREMENT DECREMENT
367 /* We don't need a precedence for '(' in this reduced grammar, and it
368 can mask some unpleasant bugs, so disable it for now. */
370 %right ARROW '.' '[' /* '(' */
377 { global_result = $1; }
395 /* Function with a return type. declarator_1 is used to prevent
396 ambiguity with the next rule. */
397 : typespec_2 declarator_1
402 /* Function without a return type. We need to use typespec_2
403 to prevent conflicts from qualifiers_opt - harmless. The
404 start_opt is used to handle "function-local" variables and
406 | typespec_2 function_arglist start_opt
407 { $$ = fill_comp (DEMANGLE_COMPONENT_TYPED_NAME, $1, $2.comp);
408 if ($3) $$ = fill_comp (DEMANGLE_COMPONENT_LOCAL_NAME, $$, $3); }
409 | colon_ext_only function_arglist start_opt
410 { $$ = fill_comp (DEMANGLE_COMPONENT_TYPED_NAME, $1, $2.comp);
411 if ($3) $$ = fill_comp (DEMANGLE_COMPONENT_LOCAL_NAME, $$, $3); }
413 | conversion_op_name start_opt
415 if ($2) $$ = fill_comp (DEMANGLE_COMPONENT_LOCAL_NAME, $$, $2); }
416 | conversion_op_name abstract_declarator_fn
419 /* First complete the abstract_declarator's type using
420 the typespec from the conversion_op_name. */
422 /* Then complete the conversion_op_name with the type. */
425 /* If we have an arglist, build a function type. */
427 $$ = fill_comp (DEMANGLE_COMPONENT_TYPED_NAME, $1.comp, $2.fn.comp);
430 if ($2.start) $$ = fill_comp (DEMANGLE_COMPONENT_LOCAL_NAME, $$, $2.start);
435 : DEMANGLER_SPECIAL start
436 { $$ = make_empty ((enum demangle_component_type) $1);
438 d_right ($$) = NULL; }
439 | CONSTRUCTION_VTABLE start CONSTRUCTION_IN start
440 { $$ = fill_comp (DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE, $2, $4); }
445 /* Match the whitespacing of cplus_demangle_operators.
446 It would abort on unrecognized string otherwise. */
447 $$ = make_operator ("new", 3);
451 /* Match the whitespacing of cplus_demangle_operators.
452 It would abort on unrecognized string otherwise. */
453 $$ = make_operator ("delete ", 1);
455 | OPERATOR NEW '[' ']'
457 /* Match the whitespacing of cplus_demangle_operators.
458 It would abort on unrecognized string otherwise. */
459 $$ = make_operator ("new[]", 3);
461 | OPERATOR DELETE '[' ']'
463 /* Match the whitespacing of cplus_demangle_operators.
464 It would abort on unrecognized string otherwise. */
465 $$ = make_operator ("delete[] ", 1);
468 { $$ = make_operator ("+", 2); }
470 { $$ = make_operator ("-", 2); }
472 { $$ = make_operator ("*", 2); }
474 { $$ = make_operator ("/", 2); }
476 { $$ = make_operator ("%", 2); }
478 { $$ = make_operator ("^", 2); }
480 { $$ = make_operator ("&", 2); }
482 { $$ = make_operator ("|", 2); }
484 { $$ = make_operator ("~", 1); }
486 { $$ = make_operator ("!", 1); }
488 { $$ = make_operator ("=", 2); }
490 { $$ = make_operator ("<", 2); }
492 { $$ = make_operator (">", 2); }
493 | OPERATOR ASSIGN_MODIFY
494 { $$ = make_operator ($2, 2); }
496 { $$ = make_operator ("<<", 2); }
498 { $$ = make_operator (">>", 2); }
500 { $$ = make_operator ("==", 2); }
502 { $$ = make_operator ("!=", 2); }
504 { $$ = make_operator ("<=", 2); }
506 { $$ = make_operator (">=", 2); }
508 { $$ = make_operator ("&&", 2); }
510 { $$ = make_operator ("||", 2); }
512 { $$ = make_operator ("++", 1); }
514 { $$ = make_operator ("--", 1); }
516 { $$ = make_operator (",", 2); }
518 { $$ = make_operator ("->*", 2); }
520 { $$ = make_operator ("->", 2); }
522 { $$ = make_operator ("()", 2); }
524 { $$ = make_operator ("[]", 2); }
527 /* Conversion operators. We don't try to handle some of
528 the wackier demangler output for function pointers,
529 since it's not clear that it's parseable. */
531 : OPERATOR typespec_2
532 { $$ = fill_comp (DEMANGLE_COMPONENT_CONVERSION, $2, NULL); }
536 : nested_name conversion_op
538 d_right ($1.last) = $2;
539 $$.last = &d_left ($2);
543 $$.last = &d_left ($1);
545 | COLONCOLON nested_name conversion_op
547 d_right ($2.last) = $3;
548 $$.last = &d_left ($3);
550 | COLONCOLON conversion_op
552 $$.last = &d_left ($2);
556 /* DEMANGLE_COMPONENT_NAME */
557 /* This accepts certain invalid placements of '~'. */
558 unqualified_name: oper
559 | oper '<' template_params '>'
560 { $$ = fill_comp (DEMANGLE_COMPONENT_TEMPLATE, $1, $3.comp); }
562 { $$ = make_dtor (gnu_v3_complete_object_dtor, $2); }
565 /* This rule is used in name and nested_name, and expanded inline there
578 /* DEMANGLE_COMPONENT_QUAL_NAME */
579 /* DEMANGLE_COMPONENT_CTOR / DEMANGLE_COMPONENT_DTOR ? */
580 name : nested_name NAME %prec NAME
581 { $$ = $1.comp; d_right ($1.last) = $2; }
583 | nested_name templ %prec NAME
584 { $$ = $1.comp; d_right ($1.last) = $2; }
588 colon_ext_name : colon_name
592 colon_ext_only : ext_only_name
593 | COLONCOLON ext_only_name
597 ext_only_name : nested_name unqualified_name
598 { $$ = $1.comp; d_right ($1.last) = $2; }
602 nested_name : NAME COLONCOLON
603 { $$.comp = make_empty (DEMANGLE_COMPONENT_QUAL_NAME);
604 d_left ($$.comp) = $1;
605 d_right ($$.comp) = NULL;
608 | nested_name NAME COLONCOLON
610 d_right ($1.last) = make_empty (DEMANGLE_COMPONENT_QUAL_NAME);
611 $$.last = d_right ($1.last);
612 d_left ($$.last) = $2;
613 d_right ($$.last) = NULL;
616 { $$.comp = make_empty (DEMANGLE_COMPONENT_QUAL_NAME);
617 d_left ($$.comp) = $1;
618 d_right ($$.comp) = NULL;
621 | nested_name templ COLONCOLON
623 d_right ($1.last) = make_empty (DEMANGLE_COMPONENT_QUAL_NAME);
624 $$.last = d_right ($1.last);
625 d_left ($$.last) = $2;
626 d_right ($$.last) = NULL;
630 /* DEMANGLE_COMPONENT_TEMPLATE */
631 /* DEMANGLE_COMPONENT_TEMPLATE_ARGLIST */
632 templ : NAME '<' template_params '>'
633 { $$ = fill_comp (DEMANGLE_COMPONENT_TEMPLATE, $1, $3.comp); }
636 template_params : template_arg
637 { $$.comp = fill_comp (DEMANGLE_COMPONENT_TEMPLATE_ARGLIST, $1, NULL);
638 $$.last = &d_right ($$.comp); }
639 | template_params ',' template_arg
641 *$1.last = fill_comp (DEMANGLE_COMPONENT_TEMPLATE_ARGLIST, $3, NULL);
642 $$.last = &d_right (*$1.last);
646 /* "type" is inlined into template_arg and function_args. */
648 /* Also an integral constant-expression of integral type, and a
649 pointer to member (?) */
650 template_arg : typespec_2
651 | typespec_2 abstract_declarator
656 { $$ = fill_comp (DEMANGLE_COMPONENT_UNARY, make_operator ("&", 1), $2); }
658 { $$ = fill_comp (DEMANGLE_COMPONENT_UNARY, make_operator ("&", 1), $3); }
662 function_args : typespec_2
663 { $$.comp = fill_comp (DEMANGLE_COMPONENT_ARGLIST, $1, NULL);
664 $$.last = &d_right ($$.comp);
666 | typespec_2 abstract_declarator
668 $$.comp = fill_comp (DEMANGLE_COMPONENT_ARGLIST, $2.comp, NULL);
669 $$.last = &d_right ($$.comp);
671 | function_args ',' typespec_2
672 { *$1.last = fill_comp (DEMANGLE_COMPONENT_ARGLIST, $3, NULL);
674 $$.last = &d_right (*$1.last);
676 | function_args ',' typespec_2 abstract_declarator
678 *$1.last = fill_comp (DEMANGLE_COMPONENT_ARGLIST, $4.comp, NULL);
680 $$.last = &d_right (*$1.last);
682 | function_args ',' ELLIPSIS
684 = fill_comp (DEMANGLE_COMPONENT_ARGLIST,
685 make_builtin_type ("..."),
688 $$.last = &d_right (*$1.last);
692 function_arglist: '(' function_args ')' qualifiers_opt %prec NAME
693 { $$.comp = fill_comp (DEMANGLE_COMPONENT_FUNCTION_TYPE, NULL, $2.comp);
694 $$.last = &d_left ($$.comp);
695 $$.comp = d_qualify ($$.comp, $4, 1); }
696 | '(' VOID ')' qualifiers_opt
697 { $$.comp = fill_comp (DEMANGLE_COMPONENT_FUNCTION_TYPE, NULL, NULL);
698 $$.last = &d_left ($$.comp);
699 $$.comp = d_qualify ($$.comp, $4, 1); }
700 | '(' ')' qualifiers_opt
701 { $$.comp = fill_comp (DEMANGLE_COMPONENT_FUNCTION_TYPE, NULL, NULL);
702 $$.last = &d_left ($$.comp);
703 $$.comp = d_qualify ($$.comp, $3, 1); }
706 /* Should do something about DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL */
707 qualifiers_opt : /* epsilon */
713 { $$ = QUAL_RESTRICT; }
715 { $$ = QUAL_VOLATILE; }
720 qualifiers : qualifier
721 | qualifier qualifiers
725 /* This accepts all sorts of invalid constructions and produces
726 invalid output for them - an error would be better. */
728 int_part : INT_KEYWORD
733 { $$ = INT_UNSIGNED; }
744 { $$ = $1 | $2; if ($1 & $2 & INT_LONG) $$ = $1 | INT_LLONG; }
747 builtin_type : int_seq
748 { $$ = d_int_type ($1); }
750 { $$ = make_builtin_type ("float"); }
752 { $$ = make_builtin_type ("double"); }
753 | LONG DOUBLE_KEYWORD
754 { $$ = make_builtin_type ("long double"); }
756 { $$ = make_builtin_type ("bool"); }
758 { $$ = make_builtin_type ("wchar_t"); }
760 { $$ = make_builtin_type ("void"); }
763 ptr_operator : '*' qualifiers_opt
764 { $$.comp = make_empty (DEMANGLE_COMPONENT_POINTER);
765 $$.comp->u.s_binary.left = $$.comp->u.s_binary.right = NULL;
766 $$.last = &d_left ($$.comp);
767 $$.comp = d_qualify ($$.comp, $2, 0); }
768 /* g++ seems to allow qualifiers after the reference? */
770 { $$.comp = make_empty (DEMANGLE_COMPONENT_REFERENCE);
771 $$.comp->u.s_binary.left = $$.comp->u.s_binary.right = NULL;
772 $$.last = &d_left ($$.comp); }
774 { $$.comp = make_empty (DEMANGLE_COMPONENT_RVALUE_REFERENCE);
775 $$.comp->u.s_binary.left = $$.comp->u.s_binary.right = NULL;
776 $$.last = &d_left ($$.comp); }
777 | nested_name '*' qualifiers_opt
778 { $$.comp = make_empty (DEMANGLE_COMPONENT_PTRMEM_TYPE);
779 $$.comp->u.s_binary.left = $1.comp;
780 /* Convert the innermost DEMANGLE_COMPONENT_QUAL_NAME to a DEMANGLE_COMPONENT_NAME. */
781 *$1.last = *d_left ($1.last);
782 $$.comp->u.s_binary.right = NULL;
783 $$.last = &d_right ($$.comp);
784 $$.comp = d_qualify ($$.comp, $3, 0); }
785 | COLONCOLON nested_name '*' qualifiers_opt
786 { $$.comp = make_empty (DEMANGLE_COMPONENT_PTRMEM_TYPE);
787 $$.comp->u.s_binary.left = $2.comp;
788 /* Convert the innermost DEMANGLE_COMPONENT_QUAL_NAME to a DEMANGLE_COMPONENT_NAME. */
789 *$2.last = *d_left ($2.last);
790 $$.comp->u.s_binary.right = NULL;
791 $$.last = &d_right ($$.comp);
792 $$.comp = d_qualify ($$.comp, $4, 0); }
795 array_indicator : '[' ']'
796 { $$ = make_empty (DEMANGLE_COMPONENT_ARRAY_TYPE);
800 { $$ = make_empty (DEMANGLE_COMPONENT_ARRAY_TYPE);
805 /* Details of this approach inspired by the G++ < 3.4 parser. */
807 /* This rule is only used in typespec_2, and expanded inline there for
810 typespec : builtin_type
815 typespec_2 : builtin_type qualifiers
816 { $$ = d_qualify ($1, $2, 0); }
818 | qualifiers builtin_type qualifiers
819 { $$ = d_qualify ($2, $1 | $3, 0); }
820 | qualifiers builtin_type
821 { $$ = d_qualify ($2, $1, 0); }
824 { $$ = d_qualify ($1, $2, 0); }
826 | qualifiers name qualifiers
827 { $$ = d_qualify ($2, $1 | $3, 0); }
829 { $$ = d_qualify ($2, $1, 0); }
831 | COLONCOLON name qualifiers
832 { $$ = d_qualify ($2, $3, 0); }
835 | qualifiers COLONCOLON name qualifiers
836 { $$ = d_qualify ($3, $1 | $4, 0); }
837 | qualifiers COLONCOLON name
838 { $$ = d_qualify ($3, $1, 0); }
843 { $$.comp = $1.comp; $$.last = $1.last;
844 $$.fn.comp = NULL; $$.fn.last = NULL; }
845 | ptr_operator abstract_declarator
846 { $$ = $2; $$.fn.comp = NULL; $$.fn.last = NULL;
847 if ($2.fn.comp) { $$.last = $2.fn.last; *$2.last = $2.fn.comp; }
850 | direct_abstract_declarator
851 { $$.fn.comp = NULL; $$.fn.last = NULL;
852 if ($1.fn.comp) { $$.last = $1.fn.last; *$1.last = $1.fn.comp; }
856 direct_abstract_declarator
857 : '(' abstract_declarator ')'
858 { $$ = $2; $$.fn.comp = NULL; $$.fn.last = NULL; $$.fold_flag = 1;
859 if ($2.fn.comp) { $$.last = $2.fn.last; *$2.last = $2.fn.comp; }
861 | direct_abstract_declarator function_arglist
863 if ($1.fn.comp) { $$.last = $1.fn.last; *$1.last = $1.fn.comp; }
872 | direct_abstract_declarator array_indicator
873 { $$.fn.comp = NULL; $$.fn.last = NULL; $$.fold_flag = 0;
874 if ($1.fn.comp) { $$.last = $1.fn.last; *$1.last = $1.fn.comp; }
876 $$.last = &d_right ($2);
879 { $$.fn.comp = NULL; $$.fn.last = NULL; $$.fold_flag = 0;
881 $$.last = &d_right ($1);
883 /* G++ has the following except for () and (type). Then
884 (type) is handled in regcast_or_absdcl and () is handled
887 However, this is only useful for function types, and
888 generates reduce/reduce conflicts with direct_declarator.
889 We're interested in pointer-to-function types, and in
890 functions, but not in function types - so leave this
892 /* | function_arglist */
895 abstract_declarator_fn
897 { $$.comp = $1.comp; $$.last = $1.last;
898 $$.fn.comp = NULL; $$.fn.last = NULL; $$.start = NULL; }
899 | ptr_operator abstract_declarator_fn
907 | direct_abstract_declarator
908 { $$.comp = $1.comp; $$.last = $1.last; $$.fn = $1.fn; $$.start = NULL; }
909 | direct_abstract_declarator function_arglist COLONCOLON start
911 if ($1.fn.comp) { $$.last = $1.fn.last; *$1.last = $1.fn.comp; }
920 | function_arglist start_opt
923 $$.comp = NULL; $$.last = NULL;
928 | typespec_2 abstract_declarator
934 declarator : ptr_operator declarator
937 *$2.last = $1.comp; }
944 | direct_declarator function_arglist
949 | direct_declarator array_indicator
952 $$.last = &d_right ($2);
955 { $$.comp = make_empty (DEMANGLE_COMPONENT_TYPED_NAME);
956 d_left ($$.comp) = $1;
957 $$.last = &d_right ($$.comp);
961 /* These are similar to declarator and direct_declarator except that they
962 do not permit ( colon_ext_name ), which is ambiguous with a function
963 argument list. They also don't permit a few other forms with redundant
964 parentheses around the colon_ext_name; any colon_ext_name in parentheses
965 must be followed by an argument list or an array indicator, or preceded
967 declarator_1 : ptr_operator declarator_1
970 *$2.last = $1.comp; }
972 { $$.comp = make_empty (DEMANGLE_COMPONENT_TYPED_NAME);
973 d_left ($$.comp) = $1;
974 $$.last = &d_right ($$.comp);
976 | direct_declarator_1
978 /* Function local variable or type. The typespec to
979 our left is the type of the containing function.
980 This should be OK, because function local types
981 can not be templates, so the return types of their
982 members will not be mangled. If they are hopefully
983 they'll end up to the right of the ::. */
984 | colon_ext_name function_arglist COLONCOLON start
985 { $$.comp = fill_comp (DEMANGLE_COMPONENT_TYPED_NAME, $1, $2.comp);
987 $$.comp = fill_comp (DEMANGLE_COMPONENT_LOCAL_NAME, $$.comp, $4);
989 | direct_declarator_1 function_arglist COLONCOLON start
993 $$.comp = fill_comp (DEMANGLE_COMPONENT_LOCAL_NAME, $$.comp, $4);
998 : '(' ptr_operator declarator ')'
1001 *$3.last = $2.comp; }
1002 | direct_declarator_1 function_arglist
1003 { $$.comp = $1.comp;
1007 | direct_declarator_1 array_indicator
1008 { $$.comp = $1.comp;
1010 $$.last = &d_right ($2);
1012 | colon_ext_name function_arglist
1013 { $$.comp = fill_comp (DEMANGLE_COMPONENT_TYPED_NAME, $1, $2.comp);
1016 | colon_ext_name array_indicator
1017 { $$.comp = fill_comp (DEMANGLE_COMPONENT_TYPED_NAME, $1, $2);
1018 $$.last = &d_right ($2);
1026 /* Silly trick. Only allow '>' when parenthesized, in order to
1027 handle conflict with templates. */
1032 { $$ = d_binary (">", $1, $3); }
1035 /* References. Not allowed everywhere in template parameters, only
1036 at the top level, but treat them as expressions in case they are wrapped
1039 { $$ = fill_comp (DEMANGLE_COMPONENT_UNARY, make_operator ("&", 1), $2); }
1041 { $$ = fill_comp (DEMANGLE_COMPONENT_UNARY, make_operator ("&", 1), $3); }
1044 /* Expressions, not including the comma operator. */
1045 exp : '-' exp %prec UNARY
1046 { $$ = d_unary ("-", $2); }
1049 exp : '!' exp %prec UNARY
1050 { $$ = d_unary ("!", $2); }
1053 exp : '~' exp %prec UNARY
1054 { $$ = d_unary ("~", $2); }
1057 /* Casts. First your normal C-style cast. If exp is a LITERAL, just change
1060 exp : '(' type ')' exp %prec UNARY
1061 { if ($4->type == DEMANGLE_COMPONENT_LITERAL
1062 || $4->type == DEMANGLE_COMPONENT_LITERAL_NEG)
1068 $$ = fill_comp (DEMANGLE_COMPONENT_UNARY,
1069 fill_comp (DEMANGLE_COMPONENT_CAST, $2, NULL),
1074 /* Mangling does not differentiate between these, so we don't need to
1076 exp : STATIC_CAST '<' type '>' '(' exp1 ')' %prec UNARY
1077 { $$ = fill_comp (DEMANGLE_COMPONENT_UNARY,
1078 fill_comp (DEMANGLE_COMPONENT_CAST, $3, NULL),
1083 exp : DYNAMIC_CAST '<' type '>' '(' exp1 ')' %prec UNARY
1084 { $$ = fill_comp (DEMANGLE_COMPONENT_UNARY,
1085 fill_comp (DEMANGLE_COMPONENT_CAST, $3, NULL),
1090 exp : REINTERPRET_CAST '<' type '>' '(' exp1 ')' %prec UNARY
1091 { $$ = fill_comp (DEMANGLE_COMPONENT_UNARY,
1092 fill_comp (DEMANGLE_COMPONENT_CAST, $3, NULL),
1097 /* Another form of C++-style cast is "type ( exp1 )". This creates too many
1098 conflicts to support. For a while we supported the simpler
1099 "typespec_2 ( exp1 )", but that conflicts with "& ( start )" as a
1100 reference, deep within the wilderness of abstract declarators:
1101 Qux<int(&(*))> vs Qux<int(&(var))>, a shift-reduce conflict at the
1102 innermost left parenthesis. So we do not support function-like casts.
1103 Fortunately they never appear in demangler output. */
1105 /* TO INVESTIGATE: ._0 style anonymous names; anonymous namespaces */
1107 /* Binary operators in order of decreasing precedence. */
1110 { $$ = d_binary ("*", $1, $3); }
1114 { $$ = d_binary ("/", $1, $3); }
1118 { $$ = d_binary ("%", $1, $3); }
1122 { $$ = d_binary ("+", $1, $3); }
1126 { $$ = d_binary ("-", $1, $3); }
1130 { $$ = d_binary ("<<", $1, $3); }
1134 { $$ = d_binary (">>", $1, $3); }
1138 { $$ = d_binary ("==", $1, $3); }
1141 exp : exp NOTEQUAL exp
1142 { $$ = d_binary ("!=", $1, $3); }
1146 { $$ = d_binary ("<=", $1, $3); }
1150 { $$ = d_binary (">=", $1, $3); }
1154 { $$ = d_binary ("<", $1, $3); }
1158 { $$ = d_binary ("&", $1, $3); }
1162 { $$ = d_binary ("^", $1, $3); }
1166 { $$ = d_binary ("|", $1, $3); }
1169 exp : exp ANDAND exp
1170 { $$ = d_binary ("&&", $1, $3); }
1174 { $$ = d_binary ("||", $1, $3); }
1177 /* Not 100% sure these are necessary, but they're harmless. */
1178 exp : exp ARROW NAME
1179 { $$ = d_binary ("->", $1, $3); }
1183 { $$ = d_binary (".", $1, $3); }
1186 exp : exp '?' exp ':' exp %prec '?'
1187 { $$ = fill_comp (DEMANGLE_COMPONENT_TRINARY, make_operator ("?", 3),
1188 fill_comp (DEMANGLE_COMPONENT_TRINARY_ARG1, $1,
1189 fill_comp (DEMANGLE_COMPONENT_TRINARY_ARG2, $3, $5)));
1196 /* Not generally allowed. */
1200 exp : SIZEOF '(' type ')' %prec UNARY
1202 /* Match the whitespacing of cplus_demangle_operators.
1203 It would abort on unrecognized string otherwise. */
1204 $$ = d_unary ("sizeof ", $3);
1210 { struct demangle_component *i;
1211 i = make_name ("1", 1);
1212 $$ = fill_comp (DEMANGLE_COMPONENT_LITERAL,
1213 make_builtin_type ("bool"),
1219 { struct demangle_component *i;
1220 i = make_name ("0", 1);
1221 $$ = fill_comp (DEMANGLE_COMPONENT_LITERAL,
1222 make_builtin_type ("bool"),
1231 /* Apply QUALIFIERS to LHS and return a qualified component. IS_METHOD
1232 is set if LHS is a method, in which case the qualifiers are logically
1233 applied to "this". We apply qualifiers in a consistent order; LHS
1234 may already be qualified; duplicate qualifiers are not created. */
1236 struct demangle_component *
1237 d_qualify (struct demangle_component *lhs, int qualifiers, int is_method)
1239 struct demangle_component **inner_p;
1240 enum demangle_component_type type;
1242 /* For now the order is CONST (innermost), VOLATILE, RESTRICT. */
1244 #define HANDLE_QUAL(TYPE, MTYPE, QUAL) \
1245 if ((qualifiers & QUAL) && (type != TYPE) && (type != MTYPE)) \
1247 *inner_p = fill_comp (is_method ? MTYPE : TYPE, \
1249 inner_p = &d_left (*inner_p); \
1250 type = (*inner_p)->type; \
1252 else if (type == TYPE || type == MTYPE) \
1254 inner_p = &d_left (*inner_p); \
1255 type = (*inner_p)->type; \
1260 type = (*inner_p)->type;
1262 HANDLE_QUAL (DEMANGLE_COMPONENT_RESTRICT, DEMANGLE_COMPONENT_RESTRICT_THIS, QUAL_RESTRICT);
1263 HANDLE_QUAL (DEMANGLE_COMPONENT_VOLATILE, DEMANGLE_COMPONENT_VOLATILE_THIS, QUAL_VOLATILE);
1264 HANDLE_QUAL (DEMANGLE_COMPONENT_CONST, DEMANGLE_COMPONENT_CONST_THIS, QUAL_CONST);
1269 /* Return a builtin type corresponding to FLAGS. */
1271 static struct demangle_component *
1272 d_int_type (int flags)
1278 case INT_SIGNED | INT_CHAR:
1279 name = "signed char";
1284 case INT_UNSIGNED | INT_CHAR:
1285 name = "unsigned char";
1292 name = "unsigned int";
1295 case INT_SIGNED | INT_LONG:
1298 case INT_UNSIGNED | INT_LONG:
1299 name = "unsigned long";
1302 case INT_SIGNED | INT_SHORT:
1305 case INT_UNSIGNED | INT_SHORT:
1306 name = "unsigned short";
1308 case INT_LLONG | INT_LONG:
1309 case INT_SIGNED | INT_LLONG | INT_LONG:
1312 case INT_UNSIGNED | INT_LLONG | INT_LONG:
1313 name = "unsigned long long";
1319 return make_builtin_type (name);
1322 /* Wrapper to create a unary operation. */
1324 static struct demangle_component *
1325 d_unary (const char *name, struct demangle_component *lhs)
1327 return fill_comp (DEMANGLE_COMPONENT_UNARY, make_operator (name, 1), lhs);
1330 /* Wrapper to create a binary operation. */
1332 static struct demangle_component *
1333 d_binary (const char *name, struct demangle_component *lhs, struct demangle_component *rhs)
1335 return fill_comp (DEMANGLE_COMPONENT_BINARY, make_operator (name, 2),
1336 fill_comp (DEMANGLE_COMPONENT_BINARY_ARGS, lhs, rhs));
1339 /* Find the end of a symbol name starting at LEXPTR. */
1342 symbol_end (const char *lexptr)
1344 const char *p = lexptr;
1346 while (*p && (ISALNUM (*p) || *p == '_' || *p == '$' || *p == '.'))
1352 /* Take care of parsing a number (anything that starts with a digit).
1353 The number starts at P and contains LEN characters. Store the result in
1357 parse_number (const char *p, int len, int parsed_float)
1361 /* Number of "L" suffixes encountered. */
1364 struct demangle_component *signed_type;
1365 struct demangle_component *unsigned_type;
1366 struct demangle_component *type, *name;
1367 enum demangle_component_type literal_type;
1371 literal_type = DEMANGLE_COMPONENT_LITERAL_NEG;
1376 literal_type = DEMANGLE_COMPONENT_LITERAL;
1380 /* It's a float since it contains a point or an exponent. */
1383 /* The GDB lexer checks the result of scanf at this point. Not doing
1384 this leaves our error checking slightly weaker but only for invalid
1387 /* See if it has `f' or `l' suffix (float or long double). */
1389 c = TOLOWER (p[len - 1]);
1394 type = make_builtin_type ("float");
1399 type = make_builtin_type ("long double");
1401 else if (ISDIGIT (c) || c == '.')
1402 type = make_builtin_type ("double");
1406 name = make_name (p, len);
1407 yylval.comp = fill_comp (literal_type, type, name);
1412 /* This treats 0x1 and 1 as different literals. We also do not
1413 automatically generate unsigned types. */
1419 if (p[len - 1] == 'l' || p[len - 1] == 'L')
1425 if (p[len - 1] == 'u' || p[len - 1] == 'U')
1436 unsigned_type = make_builtin_type ("unsigned int");
1437 signed_type = make_builtin_type ("int");
1439 else if (long_p == 1)
1441 unsigned_type = make_builtin_type ("unsigned long");
1442 signed_type = make_builtin_type ("long");
1446 unsigned_type = make_builtin_type ("unsigned long long");
1447 signed_type = make_builtin_type ("long long");
1451 type = unsigned_type;
1455 name = make_name (p, len);
1456 yylval.comp = fill_comp (literal_type, type, name);
1461 static char backslashable[] = "abefnrtv";
1462 static char represented[] = "\a\b\e\f\n\r\t\v";
1464 /* Translate the backslash the way we would in the host character set. */
1466 c_parse_backslash (int host_char, int *target_char)
1469 ix = strchr (backslashable, host_char);
1473 *target_char = represented[ix - backslashable];
1477 /* Parse a C escape sequence. STRING_PTR points to a variable
1478 containing a pointer to the string to parse. That pointer
1479 should point to the character after the \. That pointer
1480 is updated past the characters we use. The value of the
1481 escape sequence is returned.
1483 A negative value means the sequence \ newline was seen,
1484 which is supposed to be equivalent to nothing at all.
1486 If \ is followed by a null character, we return a negative
1487 value and leave the string pointer pointing at the null character.
1489 If \ is followed by 000, we return 0 and leave the string pointer
1490 after the zeros. A value of 0 does not mean end of string. */
1493 cp_parse_escape (const char **string_ptr)
1496 int c = *(*string_ptr)++;
1497 if (c_parse_backslash (c, &target_char))
1509 c = *(*string_ptr)++;
1514 target_char = cp_parse_escape (string_ptr);
1518 /* Now target_char is something like `c', and we want to find
1519 its control-character equivalent. */
1520 target_char = target_char & 037;
1539 if (c >= '0' && c <= '7')
1557 #define HANDLE_SPECIAL(string, comp) \
1558 if (strncmp (tokstart, string, sizeof (string) - 1) == 0) \
1560 lexptr = tokstart + sizeof (string) - 1; \
1561 yylval.lval = comp; \
1562 return DEMANGLER_SPECIAL; \
1565 #define HANDLE_TOKEN2(string, token) \
1566 if (lexptr[1] == string[1]) \
1569 yylval.opname = string; \
1573 #define HANDLE_TOKEN3(string, token) \
1574 if (lexptr[1] == string[1] && lexptr[2] == string[2]) \
1577 yylval.opname = string; \
1581 /* Read one token, getting characters through LEXPTR. */
1588 const char *tokstart;
1591 prev_lexptr = lexptr;
1594 switch (c = *tokstart)
1606 /* We either have a character constant ('0' or '\177' for example)
1607 or we have a quoted symbol reference ('foo(int,int)' in C++
1612 c = cp_parse_escape (&lexptr);
1615 yyerror (_("empty character constant"));
1622 yyerror (_("invalid character constant"));
1626 /* FIXME: We should refer to a canonical form of the character,
1627 presumably the same one that appears in manglings - the decimal
1628 representation. But if that isn't in our input then we have to
1629 allocate memory for it somewhere. */
1630 yylval.comp = fill_comp (DEMANGLE_COMPONENT_LITERAL,
1631 make_builtin_type ("char"),
1632 make_name (tokstart, lexptr - tokstart));
1637 if (strncmp (tokstart, "(anonymous namespace)", 21) == 0)
1640 yylval.comp = make_name ("(anonymous namespace)",
1641 sizeof "(anonymous namespace)" - 1);
1652 if (lexptr[1] == '.' && lexptr[2] == '.')
1658 /* Might be a floating point number. */
1659 if (lexptr[1] < '0' || lexptr[1] > '9')
1660 goto symbol; /* Nope, must be a symbol. */
1665 HANDLE_TOKEN2 ("-=", ASSIGN_MODIFY);
1666 HANDLE_TOKEN2 ("--", DECREMENT);
1667 HANDLE_TOKEN2 ("->", ARROW);
1669 /* For construction vtables. This is kind of hokey. */
1670 if (strncmp (tokstart, "-in-", 4) == 0)
1673 return CONSTRUCTION_IN;
1676 if (lexptr[1] < '0' || lexptr[1] > '9')
1681 /* FALL THRU into number case. */
1695 /* It's a number. */
1696 int got_dot = 0, got_e = 0, toktype;
1697 const char *p = tokstart;
1703 if (c == '0' && (p[1] == 'x' || p[1] == 'X'))
1708 else if (c == '0' && (p[1]=='t' || p[1]=='T' || p[1]=='d' || p[1]=='D'))
1716 /* This test includes !hex because 'e' is a valid hex digit
1717 and thus does not indicate a floating point number when
1718 the radix is hex. */
1719 if (!hex && !got_e && (*p == 'e' || *p == 'E'))
1720 got_dot = got_e = 1;
1721 /* This test does not include !hex, because a '.' always indicates
1722 a decimal floating point number regardless of the radix.
1724 NOTE drow/2005-03-09: This comment is not accurate in C99;
1725 however, it's not clear that all the floating point support
1726 in this file is doing any good here. */
1727 else if (!got_dot && *p == '.')
1729 else if (got_e && (p[-1] == 'e' || p[-1] == 'E')
1730 && (*p == '-' || *p == '+'))
1731 /* This is the sign of the exponent, not the end of the
1734 /* We will take any letters or digits. parse_number will
1735 complain if past the radix, or if L or U are not final. */
1736 else if (! ISALNUM (*p))
1739 toktype = parse_number (tokstart, p - tokstart, got_dot|got_e);
1740 if (toktype == ERROR)
1742 char *err_copy = (char *) alloca (p - tokstart + 1);
1744 memcpy (err_copy, tokstart, p - tokstart);
1745 err_copy[p - tokstart] = 0;
1746 yyerror (_("invalid number"));
1754 HANDLE_TOKEN2 ("+=", ASSIGN_MODIFY);
1755 HANDLE_TOKEN2 ("++", INCREMENT);
1759 HANDLE_TOKEN2 ("*=", ASSIGN_MODIFY);
1763 HANDLE_TOKEN2 ("/=", ASSIGN_MODIFY);
1767 HANDLE_TOKEN2 ("%=", ASSIGN_MODIFY);
1771 HANDLE_TOKEN2 ("|=", ASSIGN_MODIFY);
1772 HANDLE_TOKEN2 ("||", OROR);
1776 HANDLE_TOKEN2 ("&=", ASSIGN_MODIFY);
1777 HANDLE_TOKEN2 ("&&", ANDAND);
1781 HANDLE_TOKEN2 ("^=", ASSIGN_MODIFY);
1785 HANDLE_TOKEN2 ("!=", NOTEQUAL);
1789 HANDLE_TOKEN3 ("<<=", ASSIGN_MODIFY);
1790 HANDLE_TOKEN2 ("<=", LEQ);
1791 HANDLE_TOKEN2 ("<<", LSH);
1795 HANDLE_TOKEN3 (">>=", ASSIGN_MODIFY);
1796 HANDLE_TOKEN2 (">=", GEQ);
1797 HANDLE_TOKEN2 (">>", RSH);
1801 HANDLE_TOKEN2 ("==", EQUAL);
1805 HANDLE_TOKEN2 ("::", COLONCOLON);
1821 /* These can't occur in C++ names. */
1822 yyerror (_("unexpected string literal"));
1826 if (!(c == '_' || c == '$' || ISALPHA (c)))
1828 /* We must have come across a bad character (e.g. ';'). */
1829 yyerror (_("invalid character"));
1833 /* It's a name. See how long it is. */
1836 c = tokstart[++namelen];
1837 while (ISALNUM (c) || c == '_' || c == '$');
1841 /* Catch specific keywords. Notice that some of the keywords contain
1842 spaces, and are sorted by the length of the first word. They must
1843 all include a trailing space in the string comparison. */
1847 if (strncmp (tokstart, "reinterpret_cast", 16) == 0)
1848 return REINTERPRET_CAST;
1851 if (strncmp (tokstart, "construction vtable for ", 24) == 0)
1853 lexptr = tokstart + 24;
1854 return CONSTRUCTION_VTABLE;
1856 if (strncmp (tokstart, "dynamic_cast", 12) == 0)
1857 return DYNAMIC_CAST;
1860 if (strncmp (tokstart, "static_cast", 11) == 0)
1864 HANDLE_SPECIAL ("covariant return thunk to ", DEMANGLE_COMPONENT_COVARIANT_THUNK);
1865 HANDLE_SPECIAL ("reference temporary for ", DEMANGLE_COMPONENT_REFTEMP);
1868 HANDLE_SPECIAL ("typeinfo for ", DEMANGLE_COMPONENT_TYPEINFO);
1869 HANDLE_SPECIAL ("typeinfo fn for ", DEMANGLE_COMPONENT_TYPEINFO_FN);
1870 HANDLE_SPECIAL ("typeinfo name for ", DEMANGLE_COMPONENT_TYPEINFO_NAME);
1871 if (strncmp (tokstart, "operator", 8) == 0)
1873 if (strncmp (tokstart, "restrict", 8) == 0)
1875 if (strncmp (tokstart, "unsigned", 8) == 0)
1877 if (strncmp (tokstart, "template", 8) == 0)
1879 if (strncmp (tokstart, "volatile", 8) == 0)
1880 return VOLATILE_KEYWORD;
1883 HANDLE_SPECIAL ("virtual thunk to ", DEMANGLE_COMPONENT_VIRTUAL_THUNK);
1884 if (strncmp (tokstart, "wchar_t", 7) == 0)
1888 if (strncmp (tokstart, "global constructors keyed to ", 29) == 0)
1891 lexptr = tokstart + 29;
1892 yylval.lval = DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS;
1893 /* Find the end of the symbol. */
1894 p = symbol_end (lexptr);
1895 yylval.comp = make_name (lexptr, p - lexptr);
1897 return DEMANGLER_SPECIAL;
1899 if (strncmp (tokstart, "global destructors keyed to ", 28) == 0)
1902 lexptr = tokstart + 28;
1903 yylval.lval = DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS;
1904 /* Find the end of the symbol. */
1905 p = symbol_end (lexptr);
1906 yylval.comp = make_name (lexptr, p - lexptr);
1908 return DEMANGLER_SPECIAL;
1911 HANDLE_SPECIAL ("vtable for ", DEMANGLE_COMPONENT_VTABLE);
1912 if (strncmp (tokstart, "delete", 6) == 0)
1914 if (strncmp (tokstart, "struct", 6) == 0)
1916 if (strncmp (tokstart, "signed", 6) == 0)
1917 return SIGNED_KEYWORD;
1918 if (strncmp (tokstart, "sizeof", 6) == 0)
1920 if (strncmp (tokstart, "double", 6) == 0)
1921 return DOUBLE_KEYWORD;
1924 HANDLE_SPECIAL ("guard variable for ", DEMANGLE_COMPONENT_GUARD);
1925 if (strncmp (tokstart, "false", 5) == 0)
1926 return FALSEKEYWORD;
1927 if (strncmp (tokstart, "class", 5) == 0)
1929 if (strncmp (tokstart, "union", 5) == 0)
1931 if (strncmp (tokstart, "float", 5) == 0)
1932 return FLOAT_KEYWORD;
1933 if (strncmp (tokstart, "short", 5) == 0)
1935 if (strncmp (tokstart, "const", 5) == 0)
1936 return CONST_KEYWORD;
1939 if (strncmp (tokstart, "void", 4) == 0)
1941 if (strncmp (tokstart, "bool", 4) == 0)
1943 if (strncmp (tokstart, "char", 4) == 0)
1945 if (strncmp (tokstart, "enum", 4) == 0)
1947 if (strncmp (tokstart, "long", 4) == 0)
1949 if (strncmp (tokstart, "true", 4) == 0)
1953 HANDLE_SPECIAL ("VTT for ", DEMANGLE_COMPONENT_VTT);
1954 HANDLE_SPECIAL ("non-virtual thunk to ", DEMANGLE_COMPONENT_THUNK);
1955 if (strncmp (tokstart, "new", 3) == 0)
1957 if (strncmp (tokstart, "int", 3) == 0)
1964 yylval.comp = make_name (tokstart, namelen);
1974 error_lexptr = prev_lexptr;
1975 global_errmsg = msg ? msg : "parse error";
1978 /* Allocate a chunk of the components we'll need to build a tree. We
1979 generally allocate too many components, but the extra memory usage
1980 doesn't hurt because the trees are temporary and the storage is
1981 reused. More may be allocated later, by d_grab. */
1982 static struct demangle_info *
1983 allocate_info (void)
1985 struct demangle_info *info = XNEW (struct demangle_info);
1992 /* Convert RESULT to a string. The return value is allocated
1993 using xmalloc. ESTIMATED_LEN is used only as a guide to the
1994 length of the result. This functions handles a few cases that
1995 cplus_demangle_print does not, specifically the global destructor
1996 and constructor labels. */
1999 cp_comp_to_string (struct demangle_component *result, int estimated_len)
2003 return cplus_demangle_print (DMGL_PARAMS | DMGL_ANSI, result, estimated_len,
2007 /* Constructor for demangle_parse_info. */
2009 demangle_parse_info::demangle_parse_info ()
2013 obstack_init (&obstack);
2016 /* Destructor for demangle_parse_info. */
2018 demangle_parse_info::~demangle_parse_info ()
2020 /* Free any allocated chunks of memory for the parse. */
2021 while (info != NULL)
2023 struct demangle_info *next = info->next;
2029 /* Free any memory allocated during typedef replacement. */
2030 obstack_free (&obstack, NULL);
2033 /* Merge the two parse trees given by DEST and SRC. The parse tree
2034 in SRC is attached to DEST at the node represented by TARGET.
2036 NOTE 1: Since there is no API to merge obstacks, this function does
2037 even attempt to try it. Fortunately, we do not (yet?) need this ability.
2038 The code will assert if SRC->obstack is not empty.
2040 NOTE 2: The string from which SRC was parsed must not be freed, since
2041 this function will place pointers to that string into DEST. */
2044 cp_merge_demangle_parse_infos (struct demangle_parse_info *dest,
2045 struct demangle_component *target,
2046 struct demangle_parse_info *src)
2049 struct demangle_info *di;
2051 /* Copy the SRC's parse data into DEST. */
2052 *target = *src->tree;
2054 while (di->next != NULL)
2056 di->next = src->info;
2058 /* Clear the (pointer to) SRC's parse data so that it is not freed when
2059 cp_demangled_parse_info_free is called. */
2063 /* Convert a demangled name to a demangle_component tree. On success,
2064 a structure containing the root of the new tree is returned. On
2065 error, NULL is returned, and an error message will be set in
2066 *ERRMSG (which does not need to be freed). */
2068 struct std::unique_ptr<demangle_parse_info>
2069 cp_demangled_name_to_comp (const char *demangled_name, const char **errmsg)
2071 static char errbuf[60];
2073 prev_lexptr = lexptr = demangled_name;
2074 error_lexptr = NULL;
2075 global_errmsg = NULL;
2077 demangle_info = allocate_info ();
2079 std::unique_ptr<demangle_parse_info> result (new demangle_parse_info);
2080 result->info = demangle_info;
2084 if (global_errmsg && errmsg)
2086 snprintf (errbuf, sizeof (errbuf) - 2, "%s, near `%s",
2087 global_errmsg, error_lexptr);
2088 strcat (errbuf, "'");
2094 result->tree = global_result;
2095 global_result = NULL;
2103 cp_print (struct demangle_component *result)
2108 str = cplus_demangle_print (DMGL_PARAMS | DMGL_ANSI, result, 64, &err);
2112 fputs (str, stdout);
2118 trim_chars (char *lexptr, char **extra_chars)
2120 char *p = (char *) symbol_end (lexptr);
2127 *extra_chars = p + 1;
2133 /* When this file is built as a standalone program, xmalloc comes from
2134 libiberty --- in which case we have to provide xfree ourselves. */
2141 /* Literal `free' would get translated back to xfree again. */
2142 CONCAT2 (fr,ee) (ptr);
2146 /* GDB normally defines internal_error itself, but when this file is built
2147 as a standalone program, we must also provide an implementation. */
2150 internal_error (const char *file, int line, const char *fmt, ...)
2155 fprintf (stderr, "%s:%d: internal error: ", file, line);
2156 vfprintf (stderr, fmt, ap);
2161 main (int argc, char **argv)
2163 char *str2, *extra_chars = "", c;
2169 if (argv[arg] && strcmp (argv[arg], "--debug") == 0)
2175 if (argv[arg] == NULL)
2176 while (fgets (buf, 65536, stdin) != NULL)
2179 buf[strlen (buf) - 1] = 0;
2180 /* Use DMGL_VERBOSE to get expanded standard substitutions. */
2181 c = trim_chars (buf, &extra_chars);
2182 str2 = cplus_demangle (buf, DMGL_PARAMS | DMGL_ANSI | DMGL_VERBOSE);
2185 printf ("Demangling error\n");
2187 printf ("%s%c%s\n", buf, c, extra_chars);
2189 printf ("%s\n", buf);
2193 std::unique_ptr<demangle_parse_info> result
2194 = cp_demangled_name_to_comp (str2, &errmsg);
2197 fputs (errmsg, stderr);
2198 fputc ('\n', stderr);
2202 cp_print (result->tree);
2208 fputs (extra_chars, stdout);
2214 std::unique_ptr<demangle_parse_info> result
2215 = cp_demangled_name_to_comp (argv[arg], &errmsg);
2218 fputs (errmsg, stderr);
2219 fputc ('\n', stderr);
2222 cp_print (result->tree);