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