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