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