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