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