1 /* Demangler for GNU C++ 2 Copyright 1989, 1991, 1994, 1995, 1996, 1997, 1998, 1999, 3 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc. 4 Written by James Clark (jjc@jclark.uucp) 5 Rewritten by Fred Fish (fnf@cygnus.com) for ARM and Lucid demangling 6 Modified by Satish Pai (pai@apollo.hp.com) for HP demangling 7 8 This file is part of the libiberty library. 9 Libiberty is free software; you can redistribute it and/or 10 modify it under the terms of the GNU Library General Public 11 License as published by the Free Software Foundation; either 12 version 2 of the License, or (at your option) any later version. 13 14 In addition to the permissions in the GNU Library General Public 15 License, the Free Software Foundation gives you unlimited permission 16 to link the compiled version of this file into combinations with other 17 programs, and to distribute those combinations without any restriction 18 coming from the use of this file. (The Library Public License 19 restrictions do apply in other respects; for example, they cover 20 modification of the file, and distribution when not linked into a 21 combined executable.) 22 23 Libiberty is distributed in the hope that it will be useful, 24 but WITHOUT ANY WARRANTY; without even the implied warranty of 25 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 26 Library General Public License for more details. 27 28 You should have received a copy of the GNU Library General Public 29 License along with libiberty; see the file COPYING.LIB. If 30 not, write to the Free Software Foundation, Inc., 51 Franklin Street - Fifth Floor, 31 Boston, MA 02110-1301, USA. */ 32 33 /* This file exports two functions; cplus_mangle_opname and cplus_demangle. 34 35 This file imports xmalloc and xrealloc, which are like malloc and 36 realloc except that they generate a fatal error if there is no 37 available memory. */ 38 39 /* This file lives in both GCC and libiberty. When making changes, please 40 try not to break either. */ 41 42 #ifdef HAVE_CONFIG_H 43 #include "config.h" 44 #endif 45 46 #include "safe-ctype.h" 47 48 #include <sys/types.h> 49 #include <string.h> 50 #include <stdio.h> 51 52 #ifdef HAVE_STDLIB_H 53 #include <stdlib.h> 54 #else 55 void * malloc (); 56 void * realloc (); 57 #endif 58 59 #include <demangle.h> 60 #undef CURRENT_DEMANGLING_STYLE 61 #define CURRENT_DEMANGLING_STYLE work->options 62 63 #include "libiberty.h" 64 65 static char *ada_demangle (const char *, int); 66 67 #define min(X,Y) (((X) < (Y)) ? (X) : (Y)) 68 69 /* A value at least one greater than the maximum number of characters 70 that will be output when using the `%d' format with `printf'. */ 71 #define INTBUF_SIZE 32 72 73 extern void fancy_abort (void) ATTRIBUTE_NORETURN; 74 75 /* In order to allow a single demangler executable to demangle strings 76 using various common values of CPLUS_MARKER, as well as any specific 77 one set at compile time, we maintain a string containing all the 78 commonly used ones, and check to see if the marker we are looking for 79 is in that string. CPLUS_MARKER is usually '$' on systems where the 80 assembler can deal with that. Where the assembler can't, it's usually 81 '.' (but on many systems '.' is used for other things). We put the 82 current defined CPLUS_MARKER first (which defaults to '$'), followed 83 by the next most common value, followed by an explicit '$' in case 84 the value of CPLUS_MARKER is not '$'. 85 86 We could avoid this if we could just get g++ to tell us what the actual 87 cplus marker character is as part of the debug information, perhaps by 88 ensuring that it is the character that terminates the gcc<n>_compiled 89 marker symbol (FIXME). */ 90 91 #if !defined (CPLUS_MARKER) 92 #define CPLUS_MARKER '$' 93 #endif 94 95 enum demangling_styles current_demangling_style = auto_demangling; 96 97 static char cplus_markers[] = { CPLUS_MARKER, '.', '$', '\0' }; 98 99 static char char_str[2] = { '\000', '\000' }; 100 101 void 102 set_cplus_marker_for_demangling (int ch) 103 { 104 cplus_markers[0] = ch; 105 } 106 107 typedef struct string /* Beware: these aren't required to be */ 108 { /* '\0' terminated. */ 109 char *b; /* pointer to start of string */ 110 char *p; /* pointer after last character */ 111 char *e; /* pointer after end of allocated space */ 112 } string; 113 114 /* Stuff that is shared between sub-routines. 115 Using a shared structure allows cplus_demangle to be reentrant. */ 116 117 struct work_stuff 118 { 119 int options; 120 char **typevec; 121 char **ktypevec; 122 char **btypevec; 123 int numk; 124 int numb; 125 int ksize; 126 int bsize; 127 int ntypes; 128 int typevec_size; 129 int constructor; 130 int destructor; 131 int static_type; /* A static member function */ 132 int temp_start; /* index in demangled to start of template args */ 133 int type_quals; /* The type qualifiers. */ 134 int dllimported; /* Symbol imported from a PE DLL */ 135 char **tmpl_argvec; /* Template function arguments. */ 136 int ntmpl_args; /* The number of template function arguments. */ 137 int forgetting_types; /* Nonzero if we are not remembering the types 138 we see. */ 139 string* previous_argument; /* The last function argument demangled. */ 140 int nrepeats; /* The number of times to repeat the previous 141 argument. */ 142 }; 143 144 #define PRINT_ANSI_QUALIFIERS (work -> options & DMGL_ANSI) 145 #define PRINT_ARG_TYPES (work -> options & DMGL_PARAMS) 146 147 static const struct optable 148 { 149 const char *const in; 150 const char *const out; 151 const int flags; 152 } optable[] = { 153 {"nw", " new", DMGL_ANSI}, /* new (1.92, ansi) */ 154 {"dl", " delete", DMGL_ANSI}, /* new (1.92, ansi) */ 155 {"new", " new", 0}, /* old (1.91, and 1.x) */ 156 {"delete", " delete", 0}, /* old (1.91, and 1.x) */ 157 {"vn", " new []", DMGL_ANSI}, /* GNU, pending ansi */ 158 {"vd", " delete []", DMGL_ANSI}, /* GNU, pending ansi */ 159 {"as", "=", DMGL_ANSI}, /* ansi */ 160 {"ne", "!=", DMGL_ANSI}, /* old, ansi */ 161 {"eq", "==", DMGL_ANSI}, /* old, ansi */ 162 {"ge", ">=", DMGL_ANSI}, /* old, ansi */ 163 {"gt", ">", DMGL_ANSI}, /* old, ansi */ 164 {"le", "<=", DMGL_ANSI}, /* old, ansi */ 165 {"lt", "<", DMGL_ANSI}, /* old, ansi */ 166 {"plus", "+", 0}, /* old */ 167 {"pl", "+", DMGL_ANSI}, /* ansi */ 168 {"apl", "+=", DMGL_ANSI}, /* ansi */ 169 {"minus", "-", 0}, /* old */ 170 {"mi", "-", DMGL_ANSI}, /* ansi */ 171 {"ami", "-=", DMGL_ANSI}, /* ansi */ 172 {"mult", "*", 0}, /* old */ 173 {"ml", "*", DMGL_ANSI}, /* ansi */ 174 {"amu", "*=", DMGL_ANSI}, /* ansi (ARM/Lucid) */ 175 {"aml", "*=", DMGL_ANSI}, /* ansi (GNU/g++) */ 176 {"convert", "+", 0}, /* old (unary +) */ 177 {"negate", "-", 0}, /* old (unary -) */ 178 {"trunc_mod", "%", 0}, /* old */ 179 {"md", "%", DMGL_ANSI}, /* ansi */ 180 {"amd", "%=", DMGL_ANSI}, /* ansi */ 181 {"trunc_div", "/", 0}, /* old */ 182 {"dv", "/", DMGL_ANSI}, /* ansi */ 183 {"adv", "/=", DMGL_ANSI}, /* ansi */ 184 {"truth_andif", "&&", 0}, /* old */ 185 {"aa", "&&", DMGL_ANSI}, /* ansi */ 186 {"truth_orif", "||", 0}, /* old */ 187 {"oo", "||", DMGL_ANSI}, /* ansi */ 188 {"truth_not", "!", 0}, /* old */ 189 {"nt", "!", DMGL_ANSI}, /* ansi */ 190 {"postincrement","++", 0}, /* old */ 191 {"pp", "++", DMGL_ANSI}, /* ansi */ 192 {"postdecrement","--", 0}, /* old */ 193 {"mm", "--", DMGL_ANSI}, /* ansi */ 194 {"bit_ior", "|", 0}, /* old */ 195 {"or", "|", DMGL_ANSI}, /* ansi */ 196 {"aor", "|=", DMGL_ANSI}, /* ansi */ 197 {"bit_xor", "^", 0}, /* old */ 198 {"er", "^", DMGL_ANSI}, /* ansi */ 199 {"aer", "^=", DMGL_ANSI}, /* ansi */ 200 {"bit_and", "&", 0}, /* old */ 201 {"ad", "&", DMGL_ANSI}, /* ansi */ 202 {"aad", "&=", DMGL_ANSI}, /* ansi */ 203 {"bit_not", "~", 0}, /* old */ 204 {"co", "~", DMGL_ANSI}, /* ansi */ 205 {"call", "()", 0}, /* old */ 206 {"cl", "()", DMGL_ANSI}, /* ansi */ 207 {"alshift", "<<", 0}, /* old */ 208 {"ls", "<<", DMGL_ANSI}, /* ansi */ 209 {"als", "<<=", DMGL_ANSI}, /* ansi */ 210 {"arshift", ">>", 0}, /* old */ 211 {"rs", ">>", DMGL_ANSI}, /* ansi */ 212 {"ars", ">>=", DMGL_ANSI}, /* ansi */ 213 {"component", "->", 0}, /* old */ 214 {"pt", "->", DMGL_ANSI}, /* ansi; Lucid C++ form */ 215 {"rf", "->", DMGL_ANSI}, /* ansi; ARM/GNU form */ 216 {"indirect", "*", 0}, /* old */ 217 {"method_call", "->()", 0}, /* old */ 218 {"addr", "&", 0}, /* old (unary &) */ 219 {"array", "[]", 0}, /* old */ 220 {"vc", "[]", DMGL_ANSI}, /* ansi */ 221 {"compound", ", ", 0}, /* old */ 222 {"cm", ", ", DMGL_ANSI}, /* ansi */ 223 {"cond", "?:", 0}, /* old */ 224 {"cn", "?:", DMGL_ANSI}, /* pseudo-ansi */ 225 {"max", ">?", 0}, /* old */ 226 {"mx", ">?", DMGL_ANSI}, /* pseudo-ansi */ 227 {"min", "<?", 0}, /* old */ 228 {"mn", "<?", DMGL_ANSI}, /* pseudo-ansi */ 229 {"nop", "", 0}, /* old (for operator=) */ 230 {"rm", "->*", DMGL_ANSI}, /* ansi */ 231 {"sz", "sizeof ", DMGL_ANSI} /* pseudo-ansi */ 232 }; 233 234 /* These values are used to indicate the various type varieties. 235 They are all non-zero so that they can be used as `success' 236 values. */ 237 typedef enum type_kind_t 238 { 239 tk_none, 240 tk_pointer, 241 tk_reference, 242 tk_integral, 243 tk_bool, 244 tk_char, 245 tk_real 246 } type_kind_t; 247 248 const struct demangler_engine libiberty_demanglers[] = 249 { 250 { 251 NO_DEMANGLING_STYLE_STRING, 252 no_demangling, 253 "Demangling disabled" 254 } 255 , 256 { 257 AUTO_DEMANGLING_STYLE_STRING, 258 auto_demangling, 259 "Automatic selection based on executable" 260 } 261 , 262 { 263 GNU_DEMANGLING_STYLE_STRING, 264 gnu_demangling, 265 "GNU (g++) style demangling" 266 } 267 , 268 { 269 LUCID_DEMANGLING_STYLE_STRING, 270 lucid_demangling, 271 "Lucid (lcc) style demangling" 272 } 273 , 274 { 275 ARM_DEMANGLING_STYLE_STRING, 276 arm_demangling, 277 "ARM style demangling" 278 } 279 , 280 { 281 HP_DEMANGLING_STYLE_STRING, 282 hp_demangling, 283 "HP (aCC) style demangling" 284 } 285 , 286 { 287 EDG_DEMANGLING_STYLE_STRING, 288 edg_demangling, 289 "EDG style demangling" 290 } 291 , 292 { 293 GNU_V3_DEMANGLING_STYLE_STRING, 294 gnu_v3_demangling, 295 "GNU (g++) V3 ABI-style demangling" 296 } 297 , 298 { 299 JAVA_DEMANGLING_STYLE_STRING, 300 java_demangling, 301 "Java style demangling" 302 } 303 , 304 { 305 GNAT_DEMANGLING_STYLE_STRING, 306 gnat_demangling, 307 "GNAT style demangling" 308 } 309 , 310 { 311 NULL, unknown_demangling, NULL 312 } 313 }; 314 315 #define STRING_EMPTY(str) ((str) -> b == (str) -> p) 316 #define APPEND_BLANK(str) {if (!STRING_EMPTY(str)) \ 317 string_append(str, " ");} 318 #define LEN_STRING(str) ( (STRING_EMPTY(str))?0:((str)->p - (str)->b)) 319 320 /* The scope separator appropriate for the language being demangled. */ 321 322 #define SCOPE_STRING(work) ((work->options & DMGL_JAVA) ? "." : "::") 323 324 #define ARM_VTABLE_STRING "__vtbl__" /* Lucid/ARM virtual table prefix */ 325 #define ARM_VTABLE_STRLEN 8 /* strlen (ARM_VTABLE_STRING) */ 326 327 /* Prototypes for local functions */ 328 329 static void delete_work_stuff (struct work_stuff *); 330 331 static void delete_non_B_K_work_stuff (struct work_stuff *); 332 333 static char *mop_up (struct work_stuff *, string *, int); 334 335 static void squangle_mop_up (struct work_stuff *); 336 337 static void work_stuff_copy_to_from (struct work_stuff *, struct work_stuff *); 338 339 #if 0 340 static int 341 demangle_method_args (struct work_stuff *, const char **, string *); 342 #endif 343 344 static char * 345 internal_cplus_demangle (struct work_stuff *, const char *); 346 347 static int 348 demangle_template_template_parm (struct work_stuff *work, 349 const char **, string *); 350 351 static int 352 demangle_template (struct work_stuff *work, const char **, string *, 353 string *, int, int); 354 355 static int 356 arm_pt (struct work_stuff *, const char *, int, const char **, 357 const char **); 358 359 static int 360 demangle_class_name (struct work_stuff *, const char **, string *); 361 362 static int 363 demangle_qualified (struct work_stuff *, const char **, string *, 364 int, int); 365 366 static int demangle_class (struct work_stuff *, const char **, string *); 367 368 static int demangle_fund_type (struct work_stuff *, const char **, string *); 369 370 static int demangle_signature (struct work_stuff *, const char **, string *); 371 372 static int demangle_prefix (struct work_stuff *, const char **, string *); 373 374 static int gnu_special (struct work_stuff *, const char **, string *); 375 376 static int arm_special (const char **, string *); 377 378 static void string_need (string *, int); 379 380 static void string_delete (string *); 381 382 static void 383 string_init (string *); 384 385 static void string_clear (string *); 386 387 #if 0 388 static int string_empty (string *); 389 #endif 390 391 static void string_append (string *, const char *); 392 393 static void string_appends (string *, string *); 394 395 static void string_appendn (string *, const char *, int); 396 397 static void string_prepend (string *, const char *); 398 399 static void string_prependn (string *, const char *, int); 400 401 static void string_append_template_idx (string *, int); 402 403 static int get_count (const char **, int *); 404 405 static int consume_count (const char **); 406 407 static int consume_count_with_underscores (const char**); 408 409 static int demangle_args (struct work_stuff *, const char **, string *); 410 411 static int demangle_nested_args (struct work_stuff*, const char**, string*); 412 413 static int do_type (struct work_stuff *, const char **, string *); 414 415 static int do_arg (struct work_stuff *, const char **, string *); 416 417 static int 418 demangle_function_name (struct work_stuff *, const char **, string *, 419 const char *); 420 421 static int 422 iterate_demangle_function (struct work_stuff *, 423 const char **, string *, const char *); 424 425 static void remember_type (struct work_stuff *, const char *, int); 426 427 static void remember_Btype (struct work_stuff *, const char *, int, int); 428 429 static int register_Btype (struct work_stuff *); 430 431 static void remember_Ktype (struct work_stuff *, const char *, int); 432 433 static void forget_types (struct work_stuff *); 434 435 static void forget_B_and_K_types (struct work_stuff *); 436 437 static void string_prepends (string *, string *); 438 439 static int 440 demangle_template_value_parm (struct work_stuff*, const char**, 441 string*, type_kind_t); 442 443 static int 444 do_hpacc_template_const_value (struct work_stuff *, const char **, string *); 445 446 static int 447 do_hpacc_template_literal (struct work_stuff *, const char **, string *); 448 449 static int snarf_numeric_literal (const char **, string *); 450 451 /* There is a TYPE_QUAL value for each type qualifier. They can be 452 combined by bitwise-or to form the complete set of qualifiers for a 453 type. */ 454 455 #define TYPE_UNQUALIFIED 0x0 456 #define TYPE_QUAL_CONST 0x1 457 #define TYPE_QUAL_VOLATILE 0x2 458 #define TYPE_QUAL_RESTRICT 0x4 459 460 static int code_for_qualifier (int); 461 462 static const char* qualifier_string (int); 463 464 static const char* demangle_qualifier (int); 465 466 static int demangle_expression (struct work_stuff *, const char **, string *, 467 type_kind_t); 468 469 static int 470 demangle_integral_value (struct work_stuff *, const char **, string *); 471 472 static int 473 demangle_real_value (struct work_stuff *, const char **, string *); 474 475 static void 476 demangle_arm_hp_template (struct work_stuff *, const char **, int, string *); 477 478 static void 479 recursively_demangle (struct work_stuff *, const char **, string *, int); 480 481 static void grow_vect (char **, size_t *, size_t, int); 482 483 /* Translate count to integer, consuming tokens in the process. 484 Conversion terminates on the first non-digit character. 485 486 Trying to consume something that isn't a count results in no 487 consumption of input and a return of -1. 488 489 Overflow consumes the rest of the digits, and returns -1. */ 490 491 static int 492 consume_count (const char **type) 493 { 494 int count = 0; 495 496 if (! ISDIGIT ((unsigned char)**type)) 497 return -1; 498 499 while (ISDIGIT ((unsigned char)**type)) 500 { 501 count *= 10; 502 503 /* Check for overflow. 504 We assume that count is represented using two's-complement; 505 no power of two is divisible by ten, so if an overflow occurs 506 when multiplying by ten, the result will not be a multiple of 507 ten. */ 508 if ((count % 10) != 0) 509 { 510 while (ISDIGIT ((unsigned char) **type)) 511 (*type)++; 512 return -1; 513 } 514 515 count += **type - '0'; 516 (*type)++; 517 } 518 519 if (count < 0) 520 count = -1; 521 522 return (count); 523 } 524 525 526 /* Like consume_count, but for counts that are preceded and followed 527 by '_' if they are greater than 10. Also, -1 is returned for 528 failure, since 0 can be a valid value. */ 529 530 static int 531 consume_count_with_underscores (const char **mangled) 532 { 533 int idx; 534 535 if (**mangled == '_') 536 { 537 (*mangled)++; 538 if (!ISDIGIT ((unsigned char)**mangled)) 539 return -1; 540 541 idx = consume_count (mangled); 542 if (**mangled != '_') 543 /* The trailing underscore was missing. */ 544 return -1; 545 546 (*mangled)++; 547 } 548 else 549 { 550 if (**mangled < '0' || **mangled > '9') 551 return -1; 552 553 idx = **mangled - '0'; 554 (*mangled)++; 555 } 556 557 return idx; 558 } 559 560 /* C is the code for a type-qualifier. Return the TYPE_QUAL 561 corresponding to this qualifier. */ 562 563 static int 564 code_for_qualifier (int c) 565 { 566 switch (c) 567 { 568 case 'C': 569 return TYPE_QUAL_CONST; 570 571 case 'V': 572 return TYPE_QUAL_VOLATILE; 573 574 case 'u': 575 return TYPE_QUAL_RESTRICT; 576 577 default: 578 break; 579 } 580 581 /* C was an invalid qualifier. */ 582 abort (); 583 } 584 585 /* Return the string corresponding to the qualifiers given by 586 TYPE_QUALS. */ 587 588 static const char* 589 qualifier_string (int type_quals) 590 { 591 switch (type_quals) 592 { 593 case TYPE_UNQUALIFIED: 594 return ""; 595 596 case TYPE_QUAL_CONST: 597 return "const"; 598 599 case TYPE_QUAL_VOLATILE: 600 return "volatile"; 601 602 case TYPE_QUAL_RESTRICT: 603 return "__restrict"; 604 605 case TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE: 606 return "const volatile"; 607 608 case TYPE_QUAL_CONST | TYPE_QUAL_RESTRICT: 609 return "const __restrict"; 610 611 case TYPE_QUAL_VOLATILE | TYPE_QUAL_RESTRICT: 612 return "volatile __restrict"; 613 614 case TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE | TYPE_QUAL_RESTRICT: 615 return "const volatile __restrict"; 616 617 default: 618 break; 619 } 620 621 /* TYPE_QUALS was an invalid qualifier set. */ 622 abort (); 623 } 624 625 /* C is the code for a type-qualifier. Return the string 626 corresponding to this qualifier. This function should only be 627 called with a valid qualifier code. */ 628 629 static const char* 630 demangle_qualifier (int c) 631 { 632 return qualifier_string (code_for_qualifier (c)); 633 } 634 635 int 636 cplus_demangle_opname (const char *opname, char *result, int options) 637 { 638 int len, len1, ret; 639 string type; 640 struct work_stuff work[1]; 641 const char *tem; 642 643 len = strlen(opname); 644 result[0] = '\0'; 645 ret = 0; 646 memset ((char *) work, 0, sizeof (work)); 647 work->options = options; 648 649 if (opname[0] == '_' && opname[1] == '_' 650 && opname[2] == 'o' && opname[3] == 'p') 651 { 652 /* ANSI. */ 653 /* type conversion operator. */ 654 tem = opname + 4; 655 if (do_type (work, &tem, &type)) 656 { 657 strcat (result, "operator "); 658 strncat (result, type.b, type.p - type.b); 659 string_delete (&type); 660 ret = 1; 661 } 662 } 663 else if (opname[0] == '_' && opname[1] == '_' 664 && ISLOWER((unsigned char)opname[2]) 665 && ISLOWER((unsigned char)opname[3])) 666 { 667 if (opname[4] == '\0') 668 { 669 /* Operator. */ 670 size_t i; 671 for (i = 0; i < ARRAY_SIZE (optable); i++) 672 { 673 if (strlen (optable[i].in) == 2 674 && memcmp (optable[i].in, opname + 2, 2) == 0) 675 { 676 strcat (result, "operator"); 677 strcat (result, optable[i].out); 678 ret = 1; 679 break; 680 } 681 } 682 } 683 else 684 { 685 if (opname[2] == 'a' && opname[5] == '\0') 686 { 687 /* Assignment. */ 688 size_t i; 689 for (i = 0; i < ARRAY_SIZE (optable); i++) 690 { 691 if (strlen (optable[i].in) == 3 692 && memcmp (optable[i].in, opname + 2, 3) == 0) 693 { 694 strcat (result, "operator"); 695 strcat (result, optable[i].out); 696 ret = 1; 697 break; 698 } 699 } 700 } 701 } 702 } 703 else if (len >= 3 704 && opname[0] == 'o' 705 && opname[1] == 'p' 706 && strchr (cplus_markers, opname[2]) != NULL) 707 { 708 /* see if it's an assignment expression */ 709 if (len >= 10 /* op$assign_ */ 710 && memcmp (opname + 3, "assign_", 7) == 0) 711 { 712 size_t i; 713 for (i = 0; i < ARRAY_SIZE (optable); i++) 714 { 715 len1 = len - 10; 716 if ((int) strlen (optable[i].in) == len1 717 && memcmp (optable[i].in, opname + 10, len1) == 0) 718 { 719 strcat (result, "operator"); 720 strcat (result, optable[i].out); 721 strcat (result, "="); 722 ret = 1; 723 break; 724 } 725 } 726 } 727 else 728 { 729 size_t i; 730 for (i = 0; i < ARRAY_SIZE (optable); i++) 731 { 732 len1 = len - 3; 733 if ((int) strlen (optable[i].in) == len1 734 && memcmp (optable[i].in, opname + 3, len1) == 0) 735 { 736 strcat (result, "operator"); 737 strcat (result, optable[i].out); 738 ret = 1; 739 break; 740 } 741 } 742 } 743 } 744 else if (len >= 5 && memcmp (opname, "type", 4) == 0 745 && strchr (cplus_markers, opname[4]) != NULL) 746 { 747 /* type conversion operator */ 748 tem = opname + 5; 749 if (do_type (work, &tem, &type)) 750 { 751 strcat (result, "operator "); 752 strncat (result, type.b, type.p - type.b); 753 string_delete (&type); 754 ret = 1; 755 } 756 } 757 squangle_mop_up (work); 758 return ret; 759 760 } 761 762 /* Takes operator name as e.g. "++" and returns mangled 763 operator name (e.g. "postincrement_expr"), or NULL if not found. 764 765 If OPTIONS & DMGL_ANSI == 1, return the ANSI name; 766 if OPTIONS & DMGL_ANSI == 0, return the old GNU name. */ 767 768 const char * 769 cplus_mangle_opname (const char *opname, int options) 770 { 771 size_t i; 772 int len; 773 774 len = strlen (opname); 775 for (i = 0; i < ARRAY_SIZE (optable); i++) 776 { 777 if ((int) strlen (optable[i].out) == len 778 && (options & DMGL_ANSI) == (optable[i].flags & DMGL_ANSI) 779 && memcmp (optable[i].out, opname, len) == 0) 780 return optable[i].in; 781 } 782 return (0); 783 } 784 785 /* Add a routine to set the demangling style to be sure it is valid and 786 allow for any demangler initialization that maybe necessary. */ 787 788 enum demangling_styles 789 cplus_demangle_set_style (enum demangling_styles style) 790 { 791 const struct demangler_engine *demangler = libiberty_demanglers; 792 793 for (; demangler->demangling_style != unknown_demangling; ++demangler) 794 if (style == demangler->demangling_style) 795 { 796 current_demangling_style = style; 797 return current_demangling_style; 798 } 799 800 return unknown_demangling; 801 } 802 803 /* Do string name to style translation */ 804 805 enum demangling_styles 806 cplus_demangle_name_to_style (const char *name) 807 { 808 const struct demangler_engine *demangler = libiberty_demanglers; 809 810 for (; demangler->demangling_style != unknown_demangling; ++demangler) 811 if (strcmp (name, demangler->demangling_style_name) == 0) 812 return demangler->demangling_style; 813 814 return unknown_demangling; 815 } 816 817 /* char *cplus_demangle (const char *mangled, int options) 818 819 If MANGLED is a mangled function name produced by GNU C++, then 820 a pointer to a @code{malloc}ed string giving a C++ representation 821 of the name will be returned; otherwise NULL will be returned. 822 It is the caller's responsibility to free the string which 823 is returned. 824 825 The OPTIONS arg may contain one or more of the following bits: 826 827 DMGL_ANSI ANSI qualifiers such as `const' and `void' are 828 included. 829 DMGL_PARAMS Function parameters are included. 830 831 For example, 832 833 cplus_demangle ("foo__1Ai", DMGL_PARAMS) => "A::foo(int)" 834 cplus_demangle ("foo__1Ai", DMGL_PARAMS | DMGL_ANSI) => "A::foo(int)" 835 cplus_demangle ("foo__1Ai", 0) => "A::foo" 836 837 cplus_demangle ("foo__1Afe", DMGL_PARAMS) => "A::foo(float,...)" 838 cplus_demangle ("foo__1Afe", DMGL_PARAMS | DMGL_ANSI)=> "A::foo(float,...)" 839 cplus_demangle ("foo__1Afe", 0) => "A::foo" 840 841 Note that any leading underscores, or other such characters prepended by 842 the compilation system, are presumed to have already been stripped from 843 MANGLED. */ 844 845 char * 846 cplus_demangle (const char *mangled, int options) 847 { 848 char *ret; 849 struct work_stuff work[1]; 850 851 if (current_demangling_style == no_demangling) 852 return xstrdup (mangled); 853 854 memset ((char *) work, 0, sizeof (work)); 855 work->options = options; 856 if ((work->options & DMGL_STYLE_MASK) == 0) 857 work->options |= (int) current_demangling_style & DMGL_STYLE_MASK; 858 859 /* The V3 ABI demangling is implemented elsewhere. */ 860 if (GNU_V3_DEMANGLING || AUTO_DEMANGLING) 861 { 862 ret = cplus_demangle_v3 (mangled, work->options); 863 if (ret || GNU_V3_DEMANGLING) 864 return ret; 865 } 866 867 if (JAVA_DEMANGLING) 868 { 869 ret = java_demangle_v3 (mangled); 870 if (ret) 871 return ret; 872 } 873 874 if (GNAT_DEMANGLING) 875 return ada_demangle(mangled,options); 876 877 ret = internal_cplus_demangle (work, mangled); 878 squangle_mop_up (work); 879 return (ret); 880 } 881 882 883 /* Assuming *OLD_VECT points to an array of *SIZE objects of size 884 ELEMENT_SIZE, grow it to contain at least MIN_SIZE objects, 885 updating *OLD_VECT and *SIZE as necessary. */ 886 887 static void 888 grow_vect (char **old_vect, size_t *size, size_t min_size, int element_size) 889 { 890 if (*size < min_size) 891 { 892 *size *= 2; 893 if (*size < min_size) 894 *size = min_size; 895 *old_vect = XRESIZEVAR (char, *old_vect, *size * element_size); 896 } 897 } 898 899 /* Demangle ada names: 900 1. Discard final __{DIGIT}+ or ${DIGIT}+ 901 2. Convert other instances of embedded "__" to `.'. 902 3. Discard leading _ada_. 903 4. Remove everything after first ___ if it is followed by 'X'. 904 5. Put symbols that should be suppressed in <...> brackets. 905 The resulting string is valid until the next call of ada_demangle. */ 906 907 static char * 908 ada_demangle (const char *mangled, int option ATTRIBUTE_UNUSED) 909 { 910 int i, j; 911 int len0; 912 const char* p; 913 char *demangled = NULL; 914 int changed; 915 size_t demangled_size = 0; 916 917 changed = 0; 918 919 if (strncmp (mangled, "_ada_", 5) == 0) 920 { 921 mangled += 5; 922 changed = 1; 923 } 924 925 if (mangled[0] == '_' || mangled[0] == '<') 926 goto Suppress; 927 928 p = strstr (mangled, "___"); 929 if (p == NULL) 930 len0 = strlen (mangled); 931 else 932 { 933 if (p[3] == 'X') 934 { 935 len0 = p - mangled; 936 changed = 1; 937 } 938 else 939 goto Suppress; 940 } 941 942 /* Make demangled big enough for possible expansion by operator name. */ 943 grow_vect (&demangled, 944 &demangled_size, 2 * len0 + 1, 945 sizeof (char)); 946 947 if (ISDIGIT ((unsigned char) mangled[len0 - 1])) { 948 for (i = len0 - 2; i >= 0 && ISDIGIT ((unsigned char) mangled[i]); i -= 1) 949 ; 950 if (i > 1 && mangled[i] == '_' && mangled[i - 1] == '_') 951 { 952 len0 = i - 1; 953 changed = 1; 954 } 955 else if (mangled[i] == '$') 956 { 957 len0 = i; 958 changed = 1; 959 } 960 } 961 962 for (i = 0, j = 0; i < len0 && ! ISALPHA ((unsigned char)mangled[i]); 963 i += 1, j += 1) 964 demangled[j] = mangled[i]; 965 966 while (i < len0) 967 { 968 if (i < len0 - 2 && mangled[i] == '_' && mangled[i + 1] == '_') 969 { 970 demangled[j] = '.'; 971 changed = 1; 972 i += 2; j += 1; 973 } 974 else 975 { 976 demangled[j] = mangled[i]; 977 i += 1; j += 1; 978 } 979 } 980 demangled[j] = '\000'; 981 982 for (i = 0; demangled[i] != '\0'; i += 1) 983 if (ISUPPER ((unsigned char)demangled[i]) || demangled[i] == ' ') 984 goto Suppress; 985 986 if (! changed) 987 return NULL; 988 else 989 return demangled; 990 991 Suppress: 992 grow_vect (&demangled, 993 &demangled_size, strlen (mangled) + 3, 994 sizeof (char)); 995 996 if (mangled[0] == '<') 997 strcpy (demangled, mangled); 998 else 999 sprintf (demangled, "<%s>", mangled); 1000 1001 return demangled; 1002 } 1003 1004 /* This function performs most of what cplus_demangle use to do, but 1005 to be able to demangle a name with a B, K or n code, we need to 1006 have a longer term memory of what types have been seen. The original 1007 now initializes and cleans up the squangle code info, while internal 1008 calls go directly to this routine to avoid resetting that info. */ 1009 1010 static char * 1011 internal_cplus_demangle (struct work_stuff *work, const char *mangled) 1012 { 1013 1014 string decl; 1015 int success = 0; 1016 char *demangled = NULL; 1017 int s1, s2, s3, s4; 1018 s1 = work->constructor; 1019 s2 = work->destructor; 1020 s3 = work->static_type; 1021 s4 = work->type_quals; 1022 work->constructor = work->destructor = 0; 1023 work->type_quals = TYPE_UNQUALIFIED; 1024 work->dllimported = 0; 1025 1026 if ((mangled != NULL) && (*mangled != '\0')) 1027 { 1028 string_init (&decl); 1029 1030 /* First check to see if gnu style demangling is active and if the 1031 string to be demangled contains a CPLUS_MARKER. If so, attempt to 1032 recognize one of the gnu special forms rather than looking for a 1033 standard prefix. In particular, don't worry about whether there 1034 is a "__" string in the mangled string. Consider "_$_5__foo" for 1035 example. */ 1036 1037 if ((AUTO_DEMANGLING || GNU_DEMANGLING)) 1038 { 1039 success = gnu_special (work, &mangled, &decl); 1040 } 1041 if (!success) 1042 { 1043 success = demangle_prefix (work, &mangled, &decl); 1044 } 1045 if (success && (*mangled != '\0')) 1046 { 1047 success = demangle_signature (work, &mangled, &decl); 1048 } 1049 if (work->constructor == 2) 1050 { 1051 string_prepend (&decl, "global constructors keyed to "); 1052 work->constructor = 0; 1053 } 1054 else if (work->destructor == 2) 1055 { 1056 string_prepend (&decl, "global destructors keyed to "); 1057 work->destructor = 0; 1058 } 1059 else if (work->dllimported == 1) 1060 { 1061 string_prepend (&decl, "import stub for "); 1062 work->dllimported = 0; 1063 } 1064 demangled = mop_up (work, &decl, success); 1065 } 1066 work->constructor = s1; 1067 work->destructor = s2; 1068 work->static_type = s3; 1069 work->type_quals = s4; 1070 return demangled; 1071 } 1072 1073 1074 /* Clear out and squangling related storage */ 1075 static void 1076 squangle_mop_up (struct work_stuff *work) 1077 { 1078 /* clean up the B and K type mangling types. */ 1079 forget_B_and_K_types (work); 1080 if (work -> btypevec != NULL) 1081 { 1082 free ((char *) work -> btypevec); 1083 } 1084 if (work -> ktypevec != NULL) 1085 { 1086 free ((char *) work -> ktypevec); 1087 } 1088 } 1089 1090 1091 /* Copy the work state and storage. */ 1092 1093 static void 1094 work_stuff_copy_to_from (struct work_stuff *to, struct work_stuff *from) 1095 { 1096 int i; 1097 1098 delete_work_stuff (to); 1099 1100 /* Shallow-copy scalars. */ 1101 memcpy (to, from, sizeof (*to)); 1102 1103 /* Deep-copy dynamic storage. */ 1104 if (from->typevec_size) 1105 to->typevec = XNEWVEC (char *, from->typevec_size); 1106 1107 for (i = 0; i < from->ntypes; i++) 1108 { 1109 int len = strlen (from->typevec[i]) + 1; 1110 1111 to->typevec[i] = XNEWVEC (char, len); 1112 memcpy (to->typevec[i], from->typevec[i], len); 1113 } 1114 1115 if (from->ksize) 1116 to->ktypevec = XNEWVEC (char *, from->ksize); 1117 1118 for (i = 0; i < from->numk; i++) 1119 { 1120 int len = strlen (from->ktypevec[i]) + 1; 1121 1122 to->ktypevec[i] = XNEWVEC (char, len); 1123 memcpy (to->ktypevec[i], from->ktypevec[i], len); 1124 } 1125 1126 if (from->bsize) 1127 to->btypevec = XNEWVEC (char *, from->bsize); 1128 1129 for (i = 0; i < from->numb; i++) 1130 { 1131 int len = strlen (from->btypevec[i]) + 1; 1132 1133 to->btypevec[i] = XNEWVEC (char , len); 1134 memcpy (to->btypevec[i], from->btypevec[i], len); 1135 } 1136 1137 if (from->ntmpl_args) 1138 to->tmpl_argvec = XNEWVEC (char *, from->ntmpl_args); 1139 1140 for (i = 0; i < from->ntmpl_args; i++) 1141 { 1142 int len = strlen (from->tmpl_argvec[i]) + 1; 1143 1144 to->tmpl_argvec[i] = XNEWVEC (char, len); 1145 memcpy (to->tmpl_argvec[i], from->tmpl_argvec[i], len); 1146 } 1147 1148 if (from->previous_argument) 1149 { 1150 to->previous_argument = XNEW (string); 1151 string_init (to->previous_argument); 1152 string_appends (to->previous_argument, from->previous_argument); 1153 } 1154 } 1155 1156 1157 /* Delete dynamic stuff in work_stuff that is not to be re-used. */ 1158 1159 static void 1160 delete_non_B_K_work_stuff (struct work_stuff *work) 1161 { 1162 /* Discard the remembered types, if any. */ 1163 1164 forget_types (work); 1165 if (work -> typevec != NULL) 1166 { 1167 free ((char *) work -> typevec); 1168 work -> typevec = NULL; 1169 work -> typevec_size = 0; 1170 } 1171 if (work->tmpl_argvec) 1172 { 1173 int i; 1174 1175 for (i = 0; i < work->ntmpl_args; i++) 1176 if (work->tmpl_argvec[i]) 1177 free ((char*) work->tmpl_argvec[i]); 1178 1179 free ((char*) work->tmpl_argvec); 1180 work->tmpl_argvec = NULL; 1181 } 1182 if (work->previous_argument) 1183 { 1184 string_delete (work->previous_argument); 1185 free ((char*) work->previous_argument); 1186 work->previous_argument = NULL; 1187 } 1188 } 1189 1190 1191 /* Delete all dynamic storage in work_stuff. */ 1192 static void 1193 delete_work_stuff (struct work_stuff *work) 1194 { 1195 delete_non_B_K_work_stuff (work); 1196 squangle_mop_up (work); 1197 } 1198 1199 1200 /* Clear out any mangled storage */ 1201 1202 static char * 1203 mop_up (struct work_stuff *work, string *declp, int success) 1204 { 1205 char *demangled = NULL; 1206 1207 delete_non_B_K_work_stuff (work); 1208 1209 /* If demangling was successful, ensure that the demangled string is null 1210 terminated and return it. Otherwise, free the demangling decl. */ 1211 1212 if (!success) 1213 { 1214 string_delete (declp); 1215 } 1216 else 1217 { 1218 string_appendn (declp, "", 1); 1219 demangled = declp->b; 1220 } 1221 return (demangled); 1222 } 1223 1224 /* 1225 1226 LOCAL FUNCTION 1227 1228 demangle_signature -- demangle the signature part of a mangled name 1229 1230 SYNOPSIS 1231 1232 static int 1233 demangle_signature (struct work_stuff *work, const char **mangled, 1234 string *declp); 1235 1236 DESCRIPTION 1237 1238 Consume and demangle the signature portion of the mangled name. 1239 1240 DECLP is the string where demangled output is being built. At 1241 entry it contains the demangled root name from the mangled name 1242 prefix. I.E. either a demangled operator name or the root function 1243 name. In some special cases, it may contain nothing. 1244 1245 *MANGLED points to the current unconsumed location in the mangled 1246 name. As tokens are consumed and demangling is performed, the 1247 pointer is updated to continuously point at the next token to 1248 be consumed. 1249 1250 Demangling GNU style mangled names is nasty because there is no 1251 explicit token that marks the start of the outermost function 1252 argument list. */ 1253 1254 static int 1255 demangle_signature (struct work_stuff *work, 1256 const char **mangled, string *declp) 1257 { 1258 int success = 1; 1259 int func_done = 0; 1260 int expect_func = 0; 1261 int expect_return_type = 0; 1262 const char *oldmangled = NULL; 1263 string trawname; 1264 string tname; 1265 1266 while (success && (**mangled != '\0')) 1267 { 1268 switch (**mangled) 1269 { 1270 case 'Q': 1271 oldmangled = *mangled; 1272 success = demangle_qualified (work, mangled, declp, 1, 0); 1273 if (success) 1274 remember_type (work, oldmangled, *mangled - oldmangled); 1275 if (AUTO_DEMANGLING || GNU_DEMANGLING) 1276 expect_func = 1; 1277 oldmangled = NULL; 1278 break; 1279 1280 case 'K': 1281 oldmangled = *mangled; 1282 success = demangle_qualified (work, mangled, declp, 1, 0); 1283 if (AUTO_DEMANGLING || GNU_DEMANGLING) 1284 { 1285 expect_func = 1; 1286 } 1287 oldmangled = NULL; 1288 break; 1289 1290 case 'S': 1291 /* Static member function */ 1292 if (oldmangled == NULL) 1293 { 1294 oldmangled = *mangled; 1295 } 1296 (*mangled)++; 1297 work -> static_type = 1; 1298 break; 1299 1300 case 'C': 1301 case 'V': 1302 case 'u': 1303 work->type_quals |= code_for_qualifier (**mangled); 1304 1305 /* a qualified member function */ 1306 if (oldmangled == NULL) 1307 oldmangled = *mangled; 1308 (*mangled)++; 1309 break; 1310 1311 case 'L': 1312 /* Local class name follows after "Lnnn_" */ 1313 if (HP_DEMANGLING) 1314 { 1315 while (**mangled && (**mangled != '_')) 1316 (*mangled)++; 1317 if (!**mangled) 1318 success = 0; 1319 else 1320 (*mangled)++; 1321 } 1322 else 1323 success = 0; 1324 break; 1325 1326 case '0': case '1': case '2': case '3': case '4': 1327 case '5': case '6': case '7': case '8': case '9': 1328 if (oldmangled == NULL) 1329 { 1330 oldmangled = *mangled; 1331 } 1332 work->temp_start = -1; /* uppermost call to demangle_class */ 1333 success = demangle_class (work, mangled, declp); 1334 if (success) 1335 { 1336 remember_type (work, oldmangled, *mangled - oldmangled); 1337 } 1338 if (AUTO_DEMANGLING || GNU_DEMANGLING || EDG_DEMANGLING) 1339 { 1340 /* EDG and others will have the "F", so we let the loop cycle 1341 if we are looking at one. */ 1342 if (**mangled != 'F') 1343 expect_func = 1; 1344 } 1345 oldmangled = NULL; 1346 break; 1347 1348 case 'B': 1349 { 1350 string s; 1351 success = do_type (work, mangled, &s); 1352 if (success) 1353 { 1354 string_append (&s, SCOPE_STRING (work)); 1355 string_prepends (declp, &s); 1356 string_delete (&s); 1357 } 1358 oldmangled = NULL; 1359 expect_func = 1; 1360 } 1361 break; 1362 1363 case 'F': 1364 /* Function */ 1365 /* ARM/HP style demangling includes a specific 'F' character after 1366 the class name. For GNU style, it is just implied. So we can 1367 safely just consume any 'F' at this point and be compatible 1368 with either style. */ 1369 1370 oldmangled = NULL; 1371 func_done = 1; 1372 (*mangled)++; 1373 1374 /* For lucid/ARM/HP style we have to forget any types we might 1375 have remembered up to this point, since they were not argument 1376 types. GNU style considers all types seen as available for 1377 back references. See comment in demangle_args() */ 1378 1379 if (LUCID_DEMANGLING || ARM_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING) 1380 { 1381 forget_types (work); 1382 } 1383 success = demangle_args (work, mangled, declp); 1384 /* After picking off the function args, we expect to either 1385 find the function return type (preceded by an '_') or the 1386 end of the string. */ 1387 if (success && (AUTO_DEMANGLING || EDG_DEMANGLING) && **mangled == '_') 1388 { 1389 ++(*mangled); 1390 /* At this level, we do not care about the return type. */ 1391 success = do_type (work, mangled, &tname); 1392 string_delete (&tname); 1393 } 1394 1395 break; 1396 1397 case 't': 1398 /* G++ Template */ 1399 string_init(&trawname); 1400 string_init(&tname); 1401 if (oldmangled == NULL) 1402 { 1403 oldmangled = *mangled; 1404 } 1405 success = demangle_template (work, mangled, &tname, 1406 &trawname, 1, 1); 1407 if (success) 1408 { 1409 remember_type (work, oldmangled, *mangled - oldmangled); 1410 } 1411 string_append (&tname, SCOPE_STRING (work)); 1412 1413 string_prepends(declp, &tname); 1414 if (work -> destructor & 1) 1415 { 1416 string_prepend (&trawname, "~"); 1417 string_appends (declp, &trawname); 1418 work->destructor -= 1; 1419 } 1420 if ((work->constructor & 1) || (work->destructor & 1)) 1421 { 1422 string_appends (declp, &trawname); 1423 work->constructor -= 1; 1424 } 1425 string_delete(&trawname); 1426 string_delete(&tname); 1427 oldmangled = NULL; 1428 expect_func = 1; 1429 break; 1430 1431 case '_': 1432 if ((AUTO_DEMANGLING || GNU_DEMANGLING) && expect_return_type) 1433 { 1434 /* Read the return type. */ 1435 string return_type; 1436 1437 (*mangled)++; 1438 success = do_type (work, mangled, &return_type); 1439 APPEND_BLANK (&return_type); 1440 1441 string_prepends (declp, &return_type); 1442 string_delete (&return_type); 1443 break; 1444 } 1445 else 1446 /* At the outermost level, we cannot have a return type specified, 1447 so if we run into another '_' at this point we are dealing with 1448 a mangled name that is either bogus, or has been mangled by 1449 some algorithm we don't know how to deal with. So just 1450 reject the entire demangling. */ 1451 /* However, "_nnn" is an expected suffix for alternate entry point 1452 numbered nnn for a function, with HP aCC, so skip over that 1453 without reporting failure. pai/1997-09-04 */ 1454 if (HP_DEMANGLING) 1455 { 1456 (*mangled)++; 1457 while (**mangled && ISDIGIT ((unsigned char)**mangled)) 1458 (*mangled)++; 1459 } 1460 else 1461 success = 0; 1462 break; 1463 1464 case 'H': 1465 if (AUTO_DEMANGLING || GNU_DEMANGLING) 1466 { 1467 /* A G++ template function. Read the template arguments. */ 1468 success = demangle_template (work, mangled, declp, 0, 0, 1469 0); 1470 if (!(work->constructor & 1)) 1471 expect_return_type = 1; 1472 (*mangled)++; 1473 break; 1474 } 1475 else 1476 /* fall through */ 1477 {;} 1478 1479 default: 1480 if (AUTO_DEMANGLING || GNU_DEMANGLING) 1481 { 1482 /* Assume we have stumbled onto the first outermost function 1483 argument token, and start processing args. */ 1484 func_done = 1; 1485 success = demangle_args (work, mangled, declp); 1486 } 1487 else 1488 { 1489 /* Non-GNU demanglers use a specific token to mark the start 1490 of the outermost function argument tokens. Typically 'F', 1491 for ARM/HP-demangling, for example. So if we find something 1492 we are not prepared for, it must be an error. */ 1493 success = 0; 1494 } 1495 break; 1496 } 1497 /* 1498 if (AUTO_DEMANGLING || GNU_DEMANGLING) 1499 */ 1500 { 1501 if (success && expect_func) 1502 { 1503 func_done = 1; 1504 if (LUCID_DEMANGLING || ARM_DEMANGLING || EDG_DEMANGLING) 1505 { 1506 forget_types (work); 1507 } 1508 success = demangle_args (work, mangled, declp); 1509 /* Since template include the mangling of their return types, 1510 we must set expect_func to 0 so that we don't try do 1511 demangle more arguments the next time we get here. */ 1512 expect_func = 0; 1513 } 1514 } 1515 } 1516 if (success && !func_done) 1517 { 1518 if (AUTO_DEMANGLING || GNU_DEMANGLING) 1519 { 1520 /* With GNU style demangling, bar__3foo is 'foo::bar(void)', and 1521 bar__3fooi is 'foo::bar(int)'. We get here when we find the 1522 first case, and need to ensure that the '(void)' gets added to 1523 the current declp. Note that with ARM/HP, the first case 1524 represents the name of a static data member 'foo::bar', 1525 which is in the current declp, so we leave it alone. */ 1526 success = demangle_args (work, mangled, declp); 1527 } 1528 } 1529 if (success && PRINT_ARG_TYPES) 1530 { 1531 if (work->static_type) 1532 string_append (declp, " static"); 1533 if (work->type_quals != TYPE_UNQUALIFIED) 1534 { 1535 APPEND_BLANK (declp); 1536 string_append (declp, qualifier_string (work->type_quals)); 1537 } 1538 } 1539 1540 return (success); 1541 } 1542 1543 #if 0 1544 1545 static int 1546 demangle_method_args (struct work_stuff *work, const char **mangled, 1547 string *declp) 1548 { 1549 int success = 0; 1550 1551 if (work -> static_type) 1552 { 1553 string_append (declp, *mangled + 1); 1554 *mangled += strlen (*mangled); 1555 success = 1; 1556 } 1557 else 1558 { 1559 success = demangle_args (work, mangled, declp); 1560 } 1561 return (success); 1562 } 1563 1564 #endif 1565 1566 static int 1567 demangle_template_template_parm (struct work_stuff *work, 1568 const char **mangled, string *tname) 1569 { 1570 int i; 1571 int r; 1572 int need_comma = 0; 1573 int success = 1; 1574 string temp; 1575 1576 string_append (tname, "template <"); 1577 /* get size of template parameter list */ 1578 if (get_count (mangled, &r)) 1579 { 1580 for (i = 0; i < r; i++) 1581 { 1582 if (need_comma) 1583 { 1584 string_append (tname, ", "); 1585 } 1586 1587 /* Z for type parameters */ 1588 if (**mangled == 'Z') 1589 { 1590 (*mangled)++; 1591 string_append (tname, "class"); 1592 } 1593 /* z for template parameters */ 1594 else if (**mangled == 'z') 1595 { 1596 (*mangled)++; 1597 success = 1598 demangle_template_template_parm (work, mangled, tname); 1599 if (!success) 1600 { 1601 break; 1602 } 1603 } 1604 else 1605 { 1606 /* temp is initialized in do_type */ 1607 success = do_type (work, mangled, &temp); 1608 if (success) 1609 { 1610 string_appends (tname, &temp); 1611 } 1612 string_delete(&temp); 1613 if (!success) 1614 { 1615 break; 1616 } 1617 } 1618 need_comma = 1; 1619 } 1620 1621 } 1622 if (tname->p[-1] == '>') 1623 string_append (tname, " "); 1624 string_append (tname, "> class"); 1625 return (success); 1626 } 1627 1628 static int 1629 demangle_expression (struct work_stuff *work, const char **mangled, 1630 string *s, type_kind_t tk) 1631 { 1632 int need_operator = 0; 1633 int success; 1634 1635 success = 1; 1636 string_appendn (s, "(", 1); 1637 (*mangled)++; 1638 while (success && **mangled != 'W' && **mangled != '\0') 1639 { 1640 if (need_operator) 1641 { 1642 size_t i; 1643 size_t len; 1644 1645 success = 0; 1646 1647 len = strlen (*mangled); 1648 1649 for (i = 0; i < ARRAY_SIZE (optable); ++i) 1650 { 1651 size_t l = strlen (optable[i].in); 1652 1653 if (l <= len 1654 && memcmp (optable[i].in, *mangled, l) == 0) 1655 { 1656 string_appendn (s, " ", 1); 1657 string_append (s, optable[i].out); 1658 string_appendn (s, " ", 1); 1659 success = 1; 1660 (*mangled) += l; 1661 break; 1662 } 1663 } 1664 1665 if (!success) 1666 break; 1667 } 1668 else 1669 need_operator = 1; 1670 1671 success = demangle_template_value_parm (work, mangled, s, tk); 1672 } 1673 1674 if (**mangled != 'W') 1675 success = 0; 1676 else 1677 { 1678 string_appendn (s, ")", 1); 1679 (*mangled)++; 1680 } 1681 1682 return success; 1683 } 1684 1685 static int 1686 demangle_integral_value (struct work_stuff *work, 1687 const char **mangled, string *s) 1688 { 1689 int success; 1690 1691 if (**mangled == 'E') 1692 success = demangle_expression (work, mangled, s, tk_integral); 1693 else if (**mangled == 'Q' || **mangled == 'K') 1694 success = demangle_qualified (work, mangled, s, 0, 1); 1695 else 1696 { 1697 int value; 1698 1699 /* By default, we let the number decide whether we shall consume an 1700 underscore. */ 1701 int multidigit_without_leading_underscore = 0; 1702 int leave_following_underscore = 0; 1703 1704 success = 0; 1705 1706 if (**mangled == '_') 1707 { 1708 if (mangled[0][1] == 'm') 1709 { 1710 /* Since consume_count_with_underscores does not handle the 1711 `m'-prefix we must do it here, using consume_count and 1712 adjusting underscores: we have to consume the underscore 1713 matching the prepended one. */ 1714 multidigit_without_leading_underscore = 1; 1715 string_appendn (s, "-", 1); 1716 (*mangled) += 2; 1717 } 1718 else 1719 { 1720 /* Do not consume a following underscore; 1721 consume_count_with_underscores will consume what 1722 should be consumed. */ 1723 leave_following_underscore = 1; 1724 } 1725 } 1726 else 1727 { 1728 /* Negative numbers are indicated with a leading `m'. */ 1729 if (**mangled == 'm') 1730 { 1731 string_appendn (s, "-", 1); 1732 (*mangled)++; 1733 } 1734 /* Since consume_count_with_underscores does not handle 1735 multi-digit numbers that do not start with an underscore, 1736 and this number can be an integer template parameter, 1737 we have to call consume_count. */ 1738 multidigit_without_leading_underscore = 1; 1739 /* These multi-digit numbers never end on an underscore, 1740 so if there is one then don't eat it. */ 1741 leave_following_underscore = 1; 1742 } 1743 1744 /* We must call consume_count if we expect to remove a trailing 1745 underscore, since consume_count_with_underscores expects 1746 the leading underscore (that we consumed) if it is to handle 1747 multi-digit numbers. */ 1748 if (multidigit_without_leading_underscore) 1749 value = consume_count (mangled); 1750 else 1751 value = consume_count_with_underscores (mangled); 1752 1753 if (value != -1) 1754 { 1755 char buf[INTBUF_SIZE]; 1756 sprintf (buf, "%d", value); 1757 string_append (s, buf); 1758 1759 /* Numbers not otherwise delimited, might have an underscore 1760 appended as a delimeter, which we should skip. 1761 1762 ??? This used to always remove a following underscore, which 1763 is wrong. If other (arbitrary) cases are followed by an 1764 underscore, we need to do something more radical. */ 1765 1766 if ((value > 9 || multidigit_without_leading_underscore) 1767 && ! leave_following_underscore 1768 && **mangled == '_') 1769 (*mangled)++; 1770 1771 /* All is well. */ 1772 success = 1; 1773 } 1774 } 1775 1776 return success; 1777 } 1778 1779 /* Demangle the real value in MANGLED. */ 1780 1781 static int 1782 demangle_real_value (struct work_stuff *work, 1783 const char **mangled, string *s) 1784 { 1785 if (**mangled == 'E') 1786 return demangle_expression (work, mangled, s, tk_real); 1787 1788 if (**mangled == 'm') 1789 { 1790 string_appendn (s, "-", 1); 1791 (*mangled)++; 1792 } 1793 while (ISDIGIT ((unsigned char)**mangled)) 1794 { 1795 string_appendn (s, *mangled, 1); 1796 (*mangled)++; 1797 } 1798 if (**mangled == '.') /* fraction */ 1799 { 1800 string_appendn (s, ".", 1); 1801 (*mangled)++; 1802 while (ISDIGIT ((unsigned char)**mangled)) 1803 { 1804 string_appendn (s, *mangled, 1); 1805 (*mangled)++; 1806 } 1807 } 1808 if (**mangled == 'e') /* exponent */ 1809 { 1810 string_appendn (s, "e", 1); 1811 (*mangled)++; 1812 while (ISDIGIT ((unsigned char)**mangled)) 1813 { 1814 string_appendn (s, *mangled, 1); 1815 (*mangled)++; 1816 } 1817 } 1818 1819 return 1; 1820 } 1821 1822 static int 1823 demangle_template_value_parm (struct work_stuff *work, const char **mangled, 1824 string *s, type_kind_t tk) 1825 { 1826 int success = 1; 1827 1828 if (**mangled == 'Y') 1829 { 1830 /* The next argument is a template parameter. */ 1831 int idx; 1832 1833 (*mangled)++; 1834 idx = consume_count_with_underscores (mangled); 1835 if (idx == -1 1836 || (work->tmpl_argvec && idx >= work->ntmpl_args) 1837 || consume_count_with_underscores (mangled) == -1) 1838 return -1; 1839 if (work->tmpl_argvec) 1840 string_append (s, work->tmpl_argvec[idx]); 1841 else 1842 string_append_template_idx (s, idx); 1843 } 1844 else if (tk == tk_integral) 1845 success = demangle_integral_value (work, mangled, s); 1846 else if (tk == tk_char) 1847 { 1848 char tmp[2]; 1849 int val; 1850 if (**mangled == 'm') 1851 { 1852 string_appendn (s, "-", 1); 1853 (*mangled)++; 1854 } 1855 string_appendn (s, "'", 1); 1856 val = consume_count(mangled); 1857 if (val <= 0) 1858 success = 0; 1859 else 1860 { 1861 tmp[0] = (char)val; 1862 tmp[1] = '\0'; 1863 string_appendn (s, &tmp[0], 1); 1864 string_appendn (s, "'", 1); 1865 } 1866 } 1867 else if (tk == tk_bool) 1868 { 1869 int val = consume_count (mangled); 1870 if (val == 0) 1871 string_appendn (s, "false", 5); 1872 else if (val == 1) 1873 string_appendn (s, "true", 4); 1874 else 1875 success = 0; 1876 } 1877 else if (tk == tk_real) 1878 success = demangle_real_value (work, mangled, s); 1879 else if (tk == tk_pointer || tk == tk_reference) 1880 { 1881 if (**mangled == 'Q') 1882 success = demangle_qualified (work, mangled, s, 1883 /*isfuncname=*/0, 1884 /*append=*/1); 1885 else 1886 { 1887 int symbol_len = consume_count (mangled); 1888 if (symbol_len == -1) 1889 return -1; 1890 if (symbol_len == 0) 1891 string_appendn (s, "0", 1); 1892 else 1893 { 1894 char *p = XNEWVEC (char, symbol_len + 1), *q; 1895 strncpy (p, *mangled, symbol_len); 1896 p [symbol_len] = '\0'; 1897 /* We use cplus_demangle here, rather than 1898 internal_cplus_demangle, because the name of the entity 1899 mangled here does not make use of any of the squangling 1900 or type-code information we have built up thus far; it is 1901 mangled independently. */ 1902 q = cplus_demangle (p, work->options); 1903 if (tk == tk_pointer) 1904 string_appendn (s, "&", 1); 1905 /* FIXME: Pointer-to-member constants should get a 1906 qualifying class name here. */ 1907 if (q) 1908 { 1909 string_append (s, q); 1910 free (q); 1911 } 1912 else 1913 string_append (s, p); 1914 free (p); 1915 } 1916 *mangled += symbol_len; 1917 } 1918 } 1919 1920 return success; 1921 } 1922 1923 /* Demangle the template name in MANGLED. The full name of the 1924 template (e.g., S<int>) is placed in TNAME. The name without the 1925 template parameters (e.g. S) is placed in TRAWNAME if TRAWNAME is 1926 non-NULL. If IS_TYPE is nonzero, this template is a type template, 1927 not a function template. If both IS_TYPE and REMEMBER are nonzero, 1928 the template is remembered in the list of back-referenceable 1929 types. */ 1930 1931 static int 1932 demangle_template (struct work_stuff *work, const char **mangled, 1933 string *tname, string *trawname, 1934 int is_type, int remember) 1935 { 1936 int i; 1937 int r; 1938 int need_comma = 0; 1939 int success = 0; 1940 int is_java_array = 0; 1941 string temp; 1942 1943 (*mangled)++; 1944 if (is_type) 1945 { 1946 /* get template name */ 1947 if (**mangled == 'z') 1948 { 1949 int idx; 1950 (*mangled)++; 1951 (*mangled)++; 1952 1953 idx = consume_count_with_underscores (mangled); 1954 if (idx == -1 1955 || (work->tmpl_argvec && idx >= work->ntmpl_args) 1956 || consume_count_with_underscores (mangled) == -1) 1957 return (0); 1958 1959 if (work->tmpl_argvec) 1960 { 1961 string_append (tname, work->tmpl_argvec[idx]); 1962 if (trawname) 1963 string_append (trawname, work->tmpl_argvec[idx]); 1964 } 1965 else 1966 { 1967 string_append_template_idx (tname, idx); 1968 if (trawname) 1969 string_append_template_idx (trawname, idx); 1970 } 1971 } 1972 else 1973 { 1974 if ((r = consume_count (mangled)) <= 0 1975 || (int) strlen (*mangled) < r) 1976 { 1977 return (0); 1978 } 1979 is_java_array = (work -> options & DMGL_JAVA) 1980 && strncmp (*mangled, "JArray1Z", 8) == 0; 1981 if (! is_java_array) 1982 { 1983 string_appendn (tname, *mangled, r); 1984 } 1985 if (trawname) 1986 string_appendn (trawname, *mangled, r); 1987 *mangled += r; 1988 } 1989 } 1990 if (!is_java_array) 1991 string_append (tname, "<"); 1992 /* get size of template parameter list */ 1993 if (!get_count (mangled, &r)) 1994 { 1995 return (0); 1996 } 1997 if (!is_type) 1998 { 1999 /* Create an array for saving the template argument values. */ 2000 work->tmpl_argvec = XNEWVEC (char *, r); 2001 work->ntmpl_args = r; 2002 for (i = 0; i < r; i++) 2003 work->tmpl_argvec[i] = 0; 2004 } 2005 for (i = 0; i < r; i++) 2006 { 2007 if (need_comma) 2008 { 2009 string_append (tname, ", "); 2010 } 2011 /* Z for type parameters */ 2012 if (**mangled == 'Z') 2013 { 2014 (*mangled)++; 2015 /* temp is initialized in do_type */ 2016 success = do_type (work, mangled, &temp); 2017 if (success) 2018 { 2019 string_appends (tname, &temp); 2020 2021 if (!is_type) 2022 { 2023 /* Save the template argument. */ 2024 int len = temp.p - temp.b; 2025 work->tmpl_argvec[i] = XNEWVEC (char, len + 1); 2026 memcpy (work->tmpl_argvec[i], temp.b, len); 2027 work->tmpl_argvec[i][len] = '\0'; 2028 } 2029 } 2030 string_delete(&temp); 2031 if (!success) 2032 { 2033 break; 2034 } 2035 } 2036 /* z for template parameters */ 2037 else if (**mangled == 'z') 2038 { 2039 int r2; 2040 (*mangled)++; 2041 success = demangle_template_template_parm (work, mangled, tname); 2042 2043 if (success 2044 && (r2 = consume_count (mangled)) > 0 2045 && (int) strlen (*mangled) >= r2) 2046 { 2047 string_append (tname, " "); 2048 string_appendn (tname, *mangled, r2); 2049 if (!is_type) 2050 { 2051 /* Save the template argument. */ 2052 int len = r2; 2053 work->tmpl_argvec[i] = XNEWVEC (char, len + 1); 2054 memcpy (work->tmpl_argvec[i], *mangled, len); 2055 work->tmpl_argvec[i][len] = '\0'; 2056 } 2057 *mangled += r2; 2058 } 2059 if (!success) 2060 { 2061 break; 2062 } 2063 } 2064 else 2065 { 2066 string param; 2067 string* s; 2068 2069 /* otherwise, value parameter */ 2070 2071 /* temp is initialized in do_type */ 2072 success = do_type (work, mangled, &temp); 2073 string_delete(&temp); 2074 if (!success) 2075 break; 2076 2077 if (!is_type) 2078 { 2079 s = ¶m; 2080 string_init (s); 2081 } 2082 else 2083 s = tname; 2084 2085 success = demangle_template_value_parm (work, mangled, s, 2086 (type_kind_t) success); 2087 2088 if (!success) 2089 { 2090 if (!is_type) 2091 string_delete (s); 2092 success = 0; 2093 break; 2094 } 2095 2096 if (!is_type) 2097 { 2098 int len = s->p - s->b; 2099 work->tmpl_argvec[i] = XNEWVEC (char, len + 1); 2100 memcpy (work->tmpl_argvec[i], s->b, len); 2101 work->tmpl_argvec[i][len] = '\0'; 2102 2103 string_appends (tname, s); 2104 string_delete (s); 2105 } 2106 } 2107 need_comma = 1; 2108 } 2109 if (is_java_array) 2110 { 2111 string_append (tname, "[]"); 2112 } 2113 else 2114 { 2115 if (tname->p[-1] == '>') 2116 string_append (tname, " "); 2117 string_append (tname, ">"); 2118 } 2119 2120 if (is_type && remember) 2121 { 2122 const int bindex = register_Btype (work); 2123 remember_Btype (work, tname->b, LEN_STRING (tname), bindex); 2124 } 2125 2126 /* 2127 if (work -> static_type) 2128 { 2129 string_append (declp, *mangled + 1); 2130 *mangled += strlen (*mangled); 2131 success = 1; 2132 } 2133 else 2134 { 2135 success = demangle_args (work, mangled, declp); 2136 } 2137 } 2138 */ 2139 return (success); 2140 } 2141 2142 static int 2143 arm_pt (struct work_stuff *work, const char *mangled, 2144 int n, const char **anchor, const char **args) 2145 { 2146 /* Check if ARM template with "__pt__" in it ("parameterized type") */ 2147 /* Allow HP also here, because HP's cfront compiler follows ARM to some extent */ 2148 if ((ARM_DEMANGLING || HP_DEMANGLING) && (*anchor = strstr (mangled, "__pt__"))) 2149 { 2150 int len; 2151 *args = *anchor + 6; 2152 len = consume_count (args); 2153 if (len == -1) 2154 return 0; 2155 if (*args + len == mangled + n && **args == '_') 2156 { 2157 ++*args; 2158 return 1; 2159 } 2160 } 2161 if (AUTO_DEMANGLING || EDG_DEMANGLING) 2162 { 2163 if ((*anchor = strstr (mangled, "__tm__")) 2164 || (*anchor = strstr (mangled, "__ps__")) 2165 || (*anchor = strstr (mangled, "__pt__"))) 2166 { 2167 int len; 2168 *args = *anchor + 6; 2169 len = consume_count (args); 2170 if (len == -1) 2171 return 0; 2172 if (*args + len == mangled + n && **args == '_') 2173 { 2174 ++*args; 2175 return 1; 2176 } 2177 } 2178 else if ((*anchor = strstr (mangled, "__S"))) 2179 { 2180 int len; 2181 *args = *anchor + 3; 2182 len = consume_count (args); 2183 if (len == -1) 2184 return 0; 2185 if (*args + len == mangled + n && **args == '_') 2186 { 2187 ++*args; 2188 return 1; 2189 } 2190 } 2191 } 2192 2193 return 0; 2194 } 2195 2196 static void 2197 demangle_arm_hp_template (struct work_stuff *work, const char **mangled, 2198 int n, string *declp) 2199 { 2200 const char *p; 2201 const char *args; 2202 const char *e = *mangled + n; 2203 string arg; 2204 2205 /* Check for HP aCC template spec: classXt1t2 where t1, t2 are 2206 template args */ 2207 if (HP_DEMANGLING && ((*mangled)[n] == 'X')) 2208 { 2209 char *start_spec_args = NULL; 2210 int hold_options; 2211 2212 /* First check for and omit template specialization pseudo-arguments, 2213 such as in "Spec<#1,#1.*>" */ 2214 start_spec_args = strchr (*mangled, '<'); 2215 if (start_spec_args && (start_spec_args - *mangled < n)) 2216 string_appendn (declp, *mangled, start_spec_args - *mangled); 2217 else 2218 string_appendn (declp, *mangled, n); 2219 (*mangled) += n + 1; 2220 string_init (&arg); 2221 if (work->temp_start == -1) /* non-recursive call */ 2222 work->temp_start = declp->p - declp->b; 2223 2224 /* We want to unconditionally demangle parameter types in 2225 template parameters. */ 2226 hold_options = work->options; 2227 work->options |= DMGL_PARAMS; 2228 2229 string_append (declp, "<"); 2230 while (1) 2231 { 2232 string_delete (&arg); 2233 switch (**mangled) 2234 { 2235 case 'T': 2236 /* 'T' signals a type parameter */ 2237 (*mangled)++; 2238 if (!do_type (work, mangled, &arg)) 2239 goto hpacc_template_args_done; 2240 break; 2241 2242 case 'U': 2243 case 'S': 2244 /* 'U' or 'S' signals an integral value */ 2245 if (!do_hpacc_template_const_value (work, mangled, &arg)) 2246 goto hpacc_template_args_done; 2247 break; 2248 2249 case 'A': 2250 /* 'A' signals a named constant expression (literal) */ 2251 if (!do_hpacc_template_literal (work, mangled, &arg)) 2252 goto hpacc_template_args_done; 2253 break; 2254 2255 default: 2256 /* Today, 1997-09-03, we have only the above types 2257 of template parameters */ 2258 /* FIXME: maybe this should fail and return null */ 2259 goto hpacc_template_args_done; 2260 } 2261 string_appends (declp, &arg); 2262 /* Check if we're at the end of template args. 2263 0 if at end of static member of template class, 2264 _ if done with template args for a function */ 2265 if ((**mangled == '\000') || (**mangled == '_')) 2266 break; 2267 else 2268 string_append (declp, ","); 2269 } 2270 hpacc_template_args_done: 2271 string_append (declp, ">"); 2272 string_delete (&arg); 2273 if (**mangled == '_') 2274 (*mangled)++; 2275 work->options = hold_options; 2276 return; 2277 } 2278 /* ARM template? (Also handles HP cfront extensions) */ 2279 else if (arm_pt (work, *mangled, n, &p, &args)) 2280 { 2281 int hold_options; 2282 string type_str; 2283 2284 string_init (&arg); 2285 string_appendn (declp, *mangled, p - *mangled); 2286 if (work->temp_start == -1) /* non-recursive call */ 2287 work->temp_start = declp->p - declp->b; 2288 2289 /* We want to unconditionally demangle parameter types in 2290 template parameters. */ 2291 hold_options = work->options; 2292 work->options |= DMGL_PARAMS; 2293 2294 string_append (declp, "<"); 2295 /* should do error checking here */ 2296 while (args < e) { 2297 string_delete (&arg); 2298 2299 /* Check for type or literal here */ 2300 switch (*args) 2301 { 2302 /* HP cfront extensions to ARM for template args */ 2303 /* spec: Xt1Lv1 where t1 is a type, v1 is a literal value */ 2304 /* FIXME: We handle only numeric literals for HP cfront */ 2305 case 'X': 2306 /* A typed constant value follows */ 2307 args++; 2308 if (!do_type (work, &args, &type_str)) 2309 goto cfront_template_args_done; 2310 string_append (&arg, "("); 2311 string_appends (&arg, &type_str); 2312 string_delete (&type_str); 2313 string_append (&arg, ")"); 2314 if (*args != 'L') 2315 goto cfront_template_args_done; 2316 args++; 2317 /* Now snarf a literal value following 'L' */ 2318 if (!snarf_numeric_literal (&args, &arg)) 2319 goto cfront_template_args_done; 2320 break; 2321 2322 case 'L': 2323 /* Snarf a literal following 'L' */ 2324 args++; 2325 if (!snarf_numeric_literal (&args, &arg)) 2326 goto cfront_template_args_done; 2327 break; 2328 default: 2329 /* Not handling other HP cfront stuff */ 2330 { 2331 const char* old_args = args; 2332 if (!do_type (work, &args, &arg)) 2333 goto cfront_template_args_done; 2334 2335 /* Fail if we didn't make any progress: prevent infinite loop. */ 2336 if (args == old_args) 2337 { 2338 work->options = hold_options; 2339 return; 2340 } 2341 } 2342 } 2343 string_appends (declp, &arg); 2344 string_append (declp, ","); 2345 } 2346 cfront_template_args_done: 2347 string_delete (&arg); 2348 if (args >= e) 2349 --declp->p; /* remove extra comma */ 2350 string_append (declp, ">"); 2351 work->options = hold_options; 2352 } 2353 else if (n>10 && strncmp (*mangled, "_GLOBAL_", 8) == 0 2354 && (*mangled)[9] == 'N' 2355 && (*mangled)[8] == (*mangled)[10] 2356 && strchr (cplus_markers, (*mangled)[8])) 2357 { 2358 /* A member of the anonymous namespace. */ 2359 string_append (declp, "{anonymous}"); 2360 } 2361 else 2362 { 2363 if (work->temp_start == -1) /* non-recursive call only */ 2364 work->temp_start = 0; /* disable in recursive calls */ 2365 string_appendn (declp, *mangled, n); 2366 } 2367 *mangled += n; 2368 } 2369 2370 /* Extract a class name, possibly a template with arguments, from the 2371 mangled string; qualifiers, local class indicators, etc. have 2372 already been dealt with */ 2373 2374 static int 2375 demangle_class_name (struct work_stuff *work, const char **mangled, 2376 string *declp) 2377 { 2378 int n; 2379 int success = 0; 2380 2381 n = consume_count (mangled); 2382 if (n == -1) 2383 return 0; 2384 if ((int) strlen (*mangled) >= n) 2385 { 2386 demangle_arm_hp_template (work, mangled, n, declp); 2387 success = 1; 2388 } 2389 2390 return (success); 2391 } 2392 2393 /* 2394 2395 LOCAL FUNCTION 2396 2397 demangle_class -- demangle a mangled class sequence 2398 2399 SYNOPSIS 2400 2401 static int 2402 demangle_class (struct work_stuff *work, const char **mangled, 2403 strint *declp) 2404 2405 DESCRIPTION 2406 2407 DECLP points to the buffer into which demangling is being done. 2408 2409 *MANGLED points to the current token to be demangled. On input, 2410 it points to a mangled class (I.E. "3foo", "13verylongclass", etc.) 2411 On exit, it points to the next token after the mangled class on 2412 success, or the first unconsumed token on failure. 2413 2414 If the CONSTRUCTOR or DESTRUCTOR flags are set in WORK, then 2415 we are demangling a constructor or destructor. In this case 2416 we prepend "class::class" or "class::~class" to DECLP. 2417 2418 Otherwise, we prepend "class::" to the current DECLP. 2419 2420 Reset the constructor/destructor flags once they have been 2421 "consumed". This allows demangle_class to be called later during 2422 the same demangling, to do normal class demangling. 2423 2424 Returns 1 if demangling is successful, 0 otherwise. 2425 2426 */ 2427 2428 static int 2429 demangle_class (struct work_stuff *work, const char **mangled, string *declp) 2430 { 2431 int success = 0; 2432 int btype; 2433 string class_name; 2434 char *save_class_name_end = 0; 2435 2436 string_init (&class_name); 2437 btype = register_Btype (work); 2438 if (demangle_class_name (work, mangled, &class_name)) 2439 { 2440 save_class_name_end = class_name.p; 2441 if ((work->constructor & 1) || (work->destructor & 1)) 2442 { 2443 /* adjust so we don't include template args */ 2444 if (work->temp_start && (work->temp_start != -1)) 2445 { 2446 class_name.p = class_name.b + work->temp_start; 2447 } 2448 string_prepends (declp, &class_name); 2449 if (work -> destructor & 1) 2450 { 2451 string_prepend (declp, "~"); 2452 work -> destructor -= 1; 2453 } 2454 else 2455 { 2456 work -> constructor -= 1; 2457 } 2458 } 2459 class_name.p = save_class_name_end; 2460 remember_Ktype (work, class_name.b, LEN_STRING(&class_name)); 2461 remember_Btype (work, class_name.b, LEN_STRING(&class_name), btype); 2462 string_prepend (declp, SCOPE_STRING (work)); 2463 string_prepends (declp, &class_name); 2464 success = 1; 2465 } 2466 string_delete (&class_name); 2467 return (success); 2468 } 2469 2470 2471 /* Called when there's a "__" in the mangled name, with `scan' pointing to 2472 the rightmost guess. 2473 2474 Find the correct "__"-sequence where the function name ends and the 2475 signature starts, which is ambiguous with GNU mangling. 2476 Call demangle_signature here, so we can make sure we found the right 2477 one; *mangled will be consumed so caller will not make further calls to 2478 demangle_signature. */ 2479 2480 static int 2481 iterate_demangle_function (struct work_stuff *work, const char **mangled, 2482 string *declp, const char *scan) 2483 { 2484 const char *mangle_init = *mangled; 2485 int success = 0; 2486 string decl_init; 2487 struct work_stuff work_init; 2488 2489 if (*(scan + 2) == '\0') 2490 return 0; 2491 2492 /* Do not iterate for some demangling modes, or if there's only one 2493 "__"-sequence. This is the normal case. */ 2494 if (ARM_DEMANGLING || LUCID_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING 2495 || strstr (scan + 2, "__") == NULL) 2496 return demangle_function_name (work, mangled, declp, scan); 2497 2498 /* Save state so we can restart if the guess at the correct "__" was 2499 wrong. */ 2500 string_init (&decl_init); 2501 string_appends (&decl_init, declp); 2502 memset (&work_init, 0, sizeof work_init); 2503 work_stuff_copy_to_from (&work_init, work); 2504 2505 /* Iterate over occurrences of __, allowing names and types to have a 2506 "__" sequence in them. We must start with the first (not the last) 2507 occurrence, since "__" most often occur between independent mangled 2508 parts, hence starting at the last occurence inside a signature 2509 might get us a "successful" demangling of the signature. */ 2510 2511 while (scan[2]) 2512 { 2513 if (demangle_function_name (work, mangled, declp, scan)) 2514 { 2515 success = demangle_signature (work, mangled, declp); 2516 if (success) 2517 break; 2518 } 2519 2520 /* Reset demangle state for the next round. */ 2521 *mangled = mangle_init; 2522 string_clear (declp); 2523 string_appends (declp, &decl_init); 2524 work_stuff_copy_to_from (work, &work_init); 2525 2526 /* Leave this underscore-sequence. */ 2527 scan += 2; 2528 2529 /* Scan for the next "__" sequence. */ 2530 while (*scan && (scan[0] != '_' || scan[1] != '_')) 2531 scan++; 2532 2533 /* Move to last "__" in this sequence. */ 2534 while (*scan && *scan == '_') 2535 scan++; 2536 scan -= 2; 2537 } 2538 2539 /* Delete saved state. */ 2540 delete_work_stuff (&work_init); 2541 string_delete (&decl_init); 2542 2543 return success; 2544 } 2545 2546 /* 2547 2548 LOCAL FUNCTION 2549 2550 demangle_prefix -- consume the mangled name prefix and find signature 2551 2552 SYNOPSIS 2553 2554 static int 2555 demangle_prefix (struct work_stuff *work, const char **mangled, 2556 string *declp); 2557 2558 DESCRIPTION 2559 2560 Consume and demangle the prefix of the mangled name. 2561 While processing the function name root, arrange to call 2562 demangle_signature if the root is ambiguous. 2563 2564 DECLP points to the string buffer into which demangled output is 2565 placed. On entry, the buffer is empty. On exit it contains 2566 the root function name, the demangled operator name, or in some 2567 special cases either nothing or the completely demangled result. 2568 2569 MANGLED points to the current pointer into the mangled name. As each 2570 token of the mangled name is consumed, it is updated. Upon entry 2571 the current mangled name pointer points to the first character of 2572 the mangled name. Upon exit, it should point to the first character 2573 of the signature if demangling was successful, or to the first 2574 unconsumed character if demangling of the prefix was unsuccessful. 2575 2576 Returns 1 on success, 0 otherwise. 2577 */ 2578 2579 static int 2580 demangle_prefix (struct work_stuff *work, const char **mangled, 2581 string *declp) 2582 { 2583 int success = 1; 2584 const char *scan; 2585 int i; 2586 2587 if (strlen(*mangled) > 6 2588 && (strncmp(*mangled, "_imp__", 6) == 0 2589 || strncmp(*mangled, "__imp_", 6) == 0)) 2590 { 2591 /* it's a symbol imported from a PE dynamic library. Check for both 2592 new style prefix _imp__ and legacy __imp_ used by older versions 2593 of dlltool. */ 2594 (*mangled) += 6; 2595 work->dllimported = 1; 2596 } 2597 else if (strlen(*mangled) >= 11 && strncmp(*mangled, "_GLOBAL_", 8) == 0) 2598 { 2599 char *marker = strchr (cplus_markers, (*mangled)[8]); 2600 if (marker != NULL && *marker == (*mangled)[10]) 2601 { 2602 if ((*mangled)[9] == 'D') 2603 { 2604 /* it's a GNU global destructor to be executed at program exit */ 2605 (*mangled) += 11; 2606 work->destructor = 2; 2607 if (gnu_special (work, mangled, declp)) 2608 return success; 2609 } 2610 else if ((*mangled)[9] == 'I') 2611 { 2612 /* it's a GNU global constructor to be executed at program init */ 2613 (*mangled) += 11; 2614 work->constructor = 2; 2615 if (gnu_special (work, mangled, declp)) 2616 return success; 2617 } 2618 } 2619 } 2620 else if ((ARM_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING) && strncmp(*mangled, "__std__", 7) == 0) 2621 { 2622 /* it's a ARM global destructor to be executed at program exit */ 2623 (*mangled) += 7; 2624 work->destructor = 2; 2625 } 2626 else if ((ARM_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING) && strncmp(*mangled, "__sti__", 7) == 0) 2627 { 2628 /* it's a ARM global constructor to be executed at program initial */ 2629 (*mangled) += 7; 2630 work->constructor = 2; 2631 } 2632 2633 /* This block of code is a reduction in strength time optimization 2634 of: 2635 scan = strstr (*mangled, "__"); */ 2636 2637 { 2638 scan = *mangled; 2639 2640 do { 2641 scan = strchr (scan, '_'); 2642 } while (scan != NULL && *++scan != '_'); 2643 2644 if (scan != NULL) --scan; 2645 } 2646 2647 if (scan != NULL) 2648 { 2649 /* We found a sequence of two or more '_', ensure that we start at 2650 the last pair in the sequence. */ 2651 i = strspn (scan, "_"); 2652 if (i > 2) 2653 { 2654 scan += (i - 2); 2655 } 2656 } 2657 2658 if (scan == NULL) 2659 { 2660 success = 0; 2661 } 2662 else if (work -> static_type) 2663 { 2664 if (!ISDIGIT ((unsigned char)scan[0]) && (scan[0] != 't')) 2665 { 2666 success = 0; 2667 } 2668 } 2669 else if ((scan == *mangled) 2670 && (ISDIGIT ((unsigned char)scan[2]) || (scan[2] == 'Q') 2671 || (scan[2] == 't') || (scan[2] == 'K') || (scan[2] == 'H'))) 2672 { 2673 /* The ARM says nothing about the mangling of local variables. 2674 But cfront mangles local variables by prepending __<nesting_level> 2675 to them. As an extension to ARM demangling we handle this case. */ 2676 if ((LUCID_DEMANGLING || ARM_DEMANGLING || HP_DEMANGLING) 2677 && ISDIGIT ((unsigned char)scan[2])) 2678 { 2679 *mangled = scan + 2; 2680 consume_count (mangled); 2681 string_append (declp, *mangled); 2682 *mangled += strlen (*mangled); 2683 success = 1; 2684 } 2685 else 2686 { 2687 /* A GNU style constructor starts with __[0-9Qt]. But cfront uses 2688 names like __Q2_3foo3bar for nested type names. So don't accept 2689 this style of constructor for cfront demangling. A GNU 2690 style member-template constructor starts with 'H'. */ 2691 if (!(LUCID_DEMANGLING || ARM_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING)) 2692 work -> constructor += 1; 2693 *mangled = scan + 2; 2694 } 2695 } 2696 else if (ARM_DEMANGLING && scan[2] == 'p' && scan[3] == 't') 2697 { 2698 /* Cfront-style parameterized type. Handled later as a signature. */ 2699 success = 1; 2700 2701 /* ARM template? */ 2702 demangle_arm_hp_template (work, mangled, strlen (*mangled), declp); 2703 } 2704 else if (EDG_DEMANGLING && ((scan[2] == 't' && scan[3] == 'm') 2705 || (scan[2] == 'p' && scan[3] == 's') 2706 || (scan[2] == 'p' && scan[3] == 't'))) 2707 { 2708 /* EDG-style parameterized type. Handled later as a signature. */ 2709 success = 1; 2710 2711 /* EDG template? */ 2712 demangle_arm_hp_template (work, mangled, strlen (*mangled), declp); 2713 } 2714 else if ((scan == *mangled) && !ISDIGIT ((unsigned char)scan[2]) 2715 && (scan[2] != 't')) 2716 { 2717 /* Mangled name starts with "__". Skip over any leading '_' characters, 2718 then find the next "__" that separates the prefix from the signature. 2719 */ 2720 if (!(ARM_DEMANGLING || LUCID_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING) 2721 || (arm_special (mangled, declp) == 0)) 2722 { 2723 while (*scan == '_') 2724 { 2725 scan++; 2726 } 2727 if ((scan = strstr (scan, "__")) == NULL || (*(scan + 2) == '\0')) 2728 { 2729 /* No separator (I.E. "__not_mangled"), or empty signature 2730 (I.E. "__not_mangled_either__") */ 2731 success = 0; 2732 } 2733 else 2734 return iterate_demangle_function (work, mangled, declp, scan); 2735 } 2736 } 2737 else if (*(scan + 2) != '\0') 2738 { 2739 /* Mangled name does not start with "__" but does have one somewhere 2740 in there with non empty stuff after it. Looks like a global 2741 function name. Iterate over all "__":s until the right 2742 one is found. */ 2743 return iterate_demangle_function (work, mangled, declp, scan); 2744 } 2745 else 2746 { 2747 /* Doesn't look like a mangled name */ 2748 success = 0; 2749 } 2750 2751 if (!success && (work->constructor == 2 || work->destructor == 2)) 2752 { 2753 string_append (declp, *mangled); 2754 *mangled += strlen (*mangled); 2755 success = 1; 2756 } 2757 return (success); 2758 } 2759 2760 /* 2761 2762 LOCAL FUNCTION 2763 2764 gnu_special -- special handling of gnu mangled strings 2765 2766 SYNOPSIS 2767 2768 static int 2769 gnu_special (struct work_stuff *work, const char **mangled, 2770 string *declp); 2771 2772 2773 DESCRIPTION 2774 2775 Process some special GNU style mangling forms that don't fit 2776 the normal pattern. For example: 2777 2778 _$_3foo (destructor for class foo) 2779 _vt$foo (foo virtual table) 2780 _vt$foo$bar (foo::bar virtual table) 2781 __vt_foo (foo virtual table, new style with thunks) 2782 _3foo$varname (static data member) 2783 _Q22rs2tu$vw (static data member) 2784 __t6vector1Zii (constructor with template) 2785 __thunk_4__$_7ostream (virtual function thunk) 2786 */ 2787 2788 static int 2789 gnu_special (struct work_stuff *work, const char **mangled, string *declp) 2790 { 2791 int n; 2792 int success = 1; 2793 const char *p; 2794 2795 if ((*mangled)[0] == '_' 2796 && strchr (cplus_markers, (*mangled)[1]) != NULL 2797 && (*mangled)[2] == '_') 2798 { 2799 /* Found a GNU style destructor, get past "_<CPLUS_MARKER>_" */ 2800 (*mangled) += 3; 2801 work -> destructor += 1; 2802 } 2803 else if ((*mangled)[0] == '_' 2804 && (((*mangled)[1] == '_' 2805 && (*mangled)[2] == 'v' 2806 && (*mangled)[3] == 't' 2807 && (*mangled)[4] == '_') 2808 || ((*mangled)[1] == 'v' 2809 && (*mangled)[2] == 't' 2810 && strchr (cplus_markers, (*mangled)[3]) != NULL))) 2811 { 2812 /* Found a GNU style virtual table, get past "_vt<CPLUS_MARKER>" 2813 and create the decl. Note that we consume the entire mangled 2814 input string, which means that demangle_signature has no work 2815 to do. */ 2816 if ((*mangled)[2] == 'v') 2817 (*mangled) += 5; /* New style, with thunks: "__vt_" */ 2818 else 2819 (*mangled) += 4; /* Old style, no thunks: "_vt<CPLUS_MARKER>" */ 2820 while (**mangled != '\0') 2821 { 2822 switch (**mangled) 2823 { 2824 case 'Q': 2825 case 'K': 2826 success = demangle_qualified (work, mangled, declp, 0, 1); 2827 break; 2828 case 't': 2829 success = demangle_template (work, mangled, declp, 0, 1, 2830 1); 2831 break; 2832 default: 2833 if (ISDIGIT((unsigned char)*mangled[0])) 2834 { 2835 n = consume_count(mangled); 2836 /* We may be seeing a too-large size, or else a 2837 ".<digits>" indicating a static local symbol. In 2838 any case, declare victory and move on; *don't* try 2839 to use n to allocate. */ 2840 if (n > (int) strlen (*mangled)) 2841 { 2842 success = 1; 2843 break; 2844 } 2845 } 2846 else 2847 { 2848 n = strcspn (*mangled, cplus_markers); 2849 } 2850 string_appendn (declp, *mangled, n); 2851 (*mangled) += n; 2852 } 2853 2854 p = strpbrk (*mangled, cplus_markers); 2855 if (success && ((p == NULL) || (p == *mangled))) 2856 { 2857 if (p != NULL) 2858 { 2859 string_append (declp, SCOPE_STRING (work)); 2860 (*mangled)++; 2861 } 2862 } 2863 else 2864 { 2865 success = 0; 2866 break; 2867 } 2868 } 2869 if (success) 2870 string_append (declp, " virtual table"); 2871 } 2872 else if ((*mangled)[0] == '_' 2873 && (strchr("0123456789Qt", (*mangled)[1]) != NULL) 2874 && (p = strpbrk (*mangled, cplus_markers)) != NULL) 2875 { 2876 /* static data member, "_3foo$varname" for example */ 2877 (*mangled)++; 2878 switch (**mangled) 2879 { 2880 case 'Q': 2881 case 'K': 2882 success = demangle_qualified (work, mangled, declp, 0, 1); 2883 break; 2884 case 't': 2885 success = demangle_template (work, mangled, declp, 0, 1, 1); 2886 break; 2887 default: 2888 n = consume_count (mangled); 2889 if (n < 0 || n > (long) strlen (*mangled)) 2890 { 2891 success = 0; 2892 break; 2893 } 2894 2895 if (n > 10 && strncmp (*mangled, "_GLOBAL_", 8) == 0 2896 && (*mangled)[9] == 'N' 2897 && (*mangled)[8] == (*mangled)[10] 2898 && strchr (cplus_markers, (*mangled)[8])) 2899 { 2900 /* A member of the anonymous namespace. There's information 2901 about what identifier or filename it was keyed to, but 2902 it's just there to make the mangled name unique; we just 2903 step over it. */ 2904 string_append (declp, "{anonymous}"); 2905 (*mangled) += n; 2906 2907 /* Now p points to the marker before the N, so we need to 2908 update it to the first marker after what we consumed. */ 2909 p = strpbrk (*mangled, cplus_markers); 2910 break; 2911 } 2912 2913 string_appendn (declp, *mangled, n); 2914 (*mangled) += n; 2915 } 2916 if (success && (p == *mangled)) 2917 { 2918 /* Consumed everything up to the cplus_marker, append the 2919 variable name. */ 2920 (*mangled)++; 2921 string_append (declp, SCOPE_STRING (work)); 2922 n = strlen (*mangled); 2923 string_appendn (declp, *mangled, n); 2924 (*mangled) += n; 2925 } 2926 else 2927 { 2928 success = 0; 2929 } 2930 } 2931 else if (strncmp (*mangled, "__thunk_", 8) == 0) 2932 { 2933 int delta; 2934 2935 (*mangled) += 8; 2936 delta = consume_count (mangled); 2937 if (delta == -1) 2938 success = 0; 2939 else 2940 { 2941 char *method = internal_cplus_demangle (work, ++*mangled); 2942 2943 if (method) 2944 { 2945 char buf[50]; 2946 sprintf (buf, "virtual function thunk (delta:%d) for ", -delta); 2947 string_append (declp, buf); 2948 string_append (declp, method); 2949 free (method); 2950 n = strlen (*mangled); 2951 (*mangled) += n; 2952 } 2953 else 2954 { 2955 success = 0; 2956 } 2957 } 2958 } 2959 else if (strncmp (*mangled, "__t", 3) == 0 2960 && ((*mangled)[3] == 'i' || (*mangled)[3] == 'f')) 2961 { 2962 p = (*mangled)[3] == 'i' ? " type_info node" : " type_info function"; 2963 (*mangled) += 4; 2964 switch (**mangled) 2965 { 2966 case 'Q': 2967 case 'K': 2968 success = demangle_qualified (work, mangled, declp, 0, 1); 2969 break; 2970 case 't': 2971 success = demangle_template (work, mangled, declp, 0, 1, 1); 2972 break; 2973 default: 2974 success = do_type (work, mangled, declp); 2975 break; 2976 } 2977 if (success && **mangled != '\0') 2978 success = 0; 2979 if (success) 2980 string_append (declp, p); 2981 } 2982 else 2983 { 2984 success = 0; 2985 } 2986 return (success); 2987 } 2988 2989 static void 2990 recursively_demangle(struct work_stuff *work, const char **mangled, 2991 string *result, int namelength) 2992 { 2993 char * recurse = (char *)NULL; 2994 char * recurse_dem = (char *)NULL; 2995 2996 recurse = XNEWVEC (char, namelength + 1); 2997 memcpy (recurse, *mangled, namelength); 2998 recurse[namelength] = '\000'; 2999 3000 recurse_dem = cplus_demangle (recurse, work->options); 3001 3002 if (recurse_dem) 3003 { 3004 string_append (result, recurse_dem); 3005 free (recurse_dem); 3006 } 3007 else 3008 { 3009 string_appendn (result, *mangled, namelength); 3010 } 3011 free (recurse); 3012 *mangled += namelength; 3013 } 3014 3015 /* 3016 3017 LOCAL FUNCTION 3018 3019 arm_special -- special handling of ARM/lucid mangled strings 3020 3021 SYNOPSIS 3022 3023 static int 3024 arm_special (const char **mangled, 3025 string *declp); 3026 3027 3028 DESCRIPTION 3029 3030 Process some special ARM style mangling forms that don't fit 3031 the normal pattern. For example: 3032 3033 __vtbl__3foo (foo virtual table) 3034 __vtbl__3foo__3bar (bar::foo virtual table) 3035 3036 */ 3037 3038 static int 3039 arm_special (const char **mangled, string *declp) 3040 { 3041 int n; 3042 int success = 1; 3043 const char *scan; 3044 3045 if (strncmp (*mangled, ARM_VTABLE_STRING, ARM_VTABLE_STRLEN) == 0) 3046 { 3047 /* Found a ARM style virtual table, get past ARM_VTABLE_STRING 3048 and create the decl. Note that we consume the entire mangled 3049 input string, which means that demangle_signature has no work 3050 to do. */ 3051 scan = *mangled + ARM_VTABLE_STRLEN; 3052 while (*scan != '\0') /* first check it can be demangled */ 3053 { 3054 n = consume_count (&scan); 3055 if (n == -1) 3056 { 3057 return (0); /* no good */ 3058 } 3059 scan += n; 3060 if (scan[0] == '_' && scan[1] == '_') 3061 { 3062 scan += 2; 3063 } 3064 } 3065 (*mangled) += ARM_VTABLE_STRLEN; 3066 while (**mangled != '\0') 3067 { 3068 n = consume_count (mangled); 3069 if (n == -1 3070 || n > (long) strlen (*mangled)) 3071 return 0; 3072 string_prependn (declp, *mangled, n); 3073 (*mangled) += n; 3074 if ((*mangled)[0] == '_' && (*mangled)[1] == '_') 3075 { 3076 string_prepend (declp, "::"); 3077 (*mangled) += 2; 3078 } 3079 } 3080 string_append (declp, " virtual table"); 3081 } 3082 else 3083 { 3084 success = 0; 3085 } 3086 return (success); 3087 } 3088 3089 /* 3090 3091 LOCAL FUNCTION 3092 3093 demangle_qualified -- demangle 'Q' qualified name strings 3094 3095 SYNOPSIS 3096 3097 static int 3098 demangle_qualified (struct work_stuff *, const char *mangled, 3099 string *result, int isfuncname, int append); 3100 3101 DESCRIPTION 3102 3103 Demangle a qualified name, such as "Q25Outer5Inner" which is 3104 the mangled form of "Outer::Inner". The demangled output is 3105 prepended or appended to the result string according to the 3106 state of the append flag. 3107 3108 If isfuncname is nonzero, then the qualified name we are building 3109 is going to be used as a member function name, so if it is a 3110 constructor or destructor function, append an appropriate 3111 constructor or destructor name. I.E. for the above example, 3112 the result for use as a constructor is "Outer::Inner::Inner" 3113 and the result for use as a destructor is "Outer::Inner::~Inner". 3114 3115 BUGS 3116 3117 Numeric conversion is ASCII dependent (FIXME). 3118 3119 */ 3120 3121 static int 3122 demangle_qualified (struct work_stuff *work, const char **mangled, 3123 string *result, int isfuncname, int append) 3124 { 3125 int qualifiers = 0; 3126 int success = 1; 3127 char num[2]; 3128 string temp; 3129 string last_name; 3130 int bindex = register_Btype (work); 3131 3132 /* We only make use of ISFUNCNAME if the entity is a constructor or 3133 destructor. */ 3134 isfuncname = (isfuncname 3135 && ((work->constructor & 1) || (work->destructor & 1))); 3136 3137 string_init (&temp); 3138 string_init (&last_name); 3139 3140 if ((*mangled)[0] == 'K') 3141 { 3142 /* Squangling qualified name reuse */ 3143 int idx; 3144 (*mangled)++; 3145 idx = consume_count_with_underscores (mangled); 3146 if (idx == -1 || idx >= work -> numk) 3147 success = 0; 3148 else 3149 string_append (&temp, work -> ktypevec[idx]); 3150 } 3151 else 3152 switch ((*mangled)[1]) 3153 { 3154 case '_': 3155 /* GNU mangled name with more than 9 classes. The count is preceded 3156 by an underscore (to distinguish it from the <= 9 case) and followed 3157 by an underscore. */ 3158 (*mangled)++; 3159 qualifiers = consume_count_with_underscores (mangled); 3160 if (qualifiers == -1) 3161 success = 0; 3162 break; 3163 3164 case '1': 3165 case '2': 3166 case '3': 3167 case '4': 3168 case '5': 3169 case '6': 3170 case '7': 3171 case '8': 3172 case '9': 3173 /* The count is in a single digit. */ 3174 num[0] = (*mangled)[1]; 3175 num[1] = '\0'; 3176 qualifiers = atoi (num); 3177 3178 /* If there is an underscore after the digit, skip it. This is 3179 said to be for ARM-qualified names, but the ARM makes no 3180 mention of such an underscore. Perhaps cfront uses one. */ 3181 if ((*mangled)[2] == '_') 3182 { 3183 (*mangled)++; 3184 } 3185 (*mangled) += 2; 3186 break; 3187 3188 case '0': 3189 default: 3190 success = 0; 3191 } 3192 3193 if (!success) 3194 return success; 3195 3196 /* Pick off the names and collect them in the temp buffer in the order 3197 in which they are found, separated by '::'. */ 3198 3199 while (qualifiers-- > 0) 3200 { 3201 int remember_K = 1; 3202 string_clear (&last_name); 3203 3204 if (*mangled[0] == '_') 3205 (*mangled)++; 3206 3207 if (*mangled[0] == 't') 3208 { 3209 /* Here we always append to TEMP since we will want to use 3210 the template name without the template parameters as a 3211 constructor or destructor name. The appropriate 3212 (parameter-less) value is returned by demangle_template 3213 in LAST_NAME. We do not remember the template type here, 3214 in order to match the G++ mangling algorithm. */ 3215 success = demangle_template(work, mangled, &temp, 3216 &last_name, 1, 0); 3217 if (!success) 3218 break; 3219 } 3220 else if (*mangled[0] == 'K') 3221 { 3222 int idx; 3223 (*mangled)++; 3224 idx = consume_count_with_underscores (mangled); 3225 if (idx == -1 || idx >= work->numk) 3226 success = 0; 3227 else 3228 string_append (&temp, work->ktypevec[idx]); 3229 remember_K = 0; 3230 3231 if (!success) break; 3232 } 3233 else 3234 { 3235 if (EDG_DEMANGLING) 3236 { 3237 int namelength; 3238 /* Now recursively demangle the qualifier 3239 * This is necessary to deal with templates in 3240 * mangling styles like EDG */ 3241 namelength = consume_count (mangled); 3242 if (namelength == -1) 3243 { 3244 success = 0; 3245 break; 3246 } 3247 recursively_demangle(work, mangled, &temp, namelength); 3248 } 3249 else 3250 { 3251 string_delete (&last_name); 3252 success = do_type (work, mangled, &last_name); 3253 if (!success) 3254 break; 3255 string_appends (&temp, &last_name); 3256 } 3257 } 3258 3259 if (remember_K) 3260 remember_Ktype (work, temp.b, LEN_STRING (&temp)); 3261 3262 if (qualifiers > 0) 3263 string_append (&temp, SCOPE_STRING (work)); 3264 } 3265 3266 remember_Btype (work, temp.b, LEN_STRING (&temp), bindex); 3267 3268 /* If we are using the result as a function name, we need to append 3269 the appropriate '::' separated constructor or destructor name. 3270 We do this here because this is the most convenient place, where 3271 we already have a pointer to the name and the length of the name. */ 3272 3273 if (isfuncname) 3274 { 3275 string_append (&temp, SCOPE_STRING (work)); 3276 if (work -> destructor & 1) 3277 string_append (&temp, "~"); 3278 string_appends (&temp, &last_name); 3279 } 3280 3281 /* Now either prepend the temp buffer to the result, or append it, 3282 depending upon the state of the append flag. */ 3283 3284 if (append) 3285 string_appends (result, &temp); 3286 else 3287 { 3288 if (!STRING_EMPTY (result)) 3289 string_append (&temp, SCOPE_STRING (work)); 3290 string_prepends (result, &temp); 3291 } 3292 3293 string_delete (&last_name); 3294 string_delete (&temp); 3295 return (success); 3296 } 3297 3298 /* 3299 3300 LOCAL FUNCTION 3301 3302 get_count -- convert an ascii count to integer, consuming tokens 3303 3304 SYNOPSIS 3305 3306 static int 3307 get_count (const char **type, int *count) 3308 3309 DESCRIPTION 3310 3311 Assume that *type points at a count in a mangled name; set 3312 *count to its value, and set *type to the next character after 3313 the count. There are some weird rules in effect here. 3314 3315 If *type does not point at a string of digits, return zero. 3316 3317 If *type points at a string of digits followed by an 3318 underscore, set *count to their value as an integer, advance 3319 *type to point *after the underscore, and return 1. 3320 3321 If *type points at a string of digits not followed by an 3322 underscore, consume only the first digit. Set *count to its 3323 value as an integer, leave *type pointing after that digit, 3324 and return 1. 3325 3326 The excuse for this odd behavior: in the ARM and HP demangling 3327 styles, a type can be followed by a repeat count of the form 3328 `Nxy', where: 3329 3330 `x' is a single digit specifying how many additional copies 3331 of the type to append to the argument list, and 3332 3333 `y' is one or more digits, specifying the zero-based index of 3334 the first repeated argument in the list. Yes, as you're 3335 unmangling the name you can figure this out yourself, but 3336 it's there anyway. 3337 3338 So, for example, in `bar__3fooFPiN51', the first argument is a 3339 pointer to an integer (`Pi'), and then the next five arguments 3340 are the same (`N5'), and the first repeat is the function's 3341 second argument (`1'). 3342 */ 3343 3344 static int 3345 get_count (const char **type, int *count) 3346 { 3347 const char *p; 3348 int n; 3349 3350 if (!ISDIGIT ((unsigned char)**type)) 3351 return (0); 3352 else 3353 { 3354 *count = **type - '0'; 3355 (*type)++; 3356 if (ISDIGIT ((unsigned char)**type)) 3357 { 3358 p = *type; 3359 n = *count; 3360 do 3361 { 3362 n *= 10; 3363 n += *p - '0'; 3364 p++; 3365 } 3366 while (ISDIGIT ((unsigned char)*p)); 3367 if (*p == '_') 3368 { 3369 *type = p + 1; 3370 *count = n; 3371 } 3372 } 3373 } 3374 return (1); 3375 } 3376 3377 /* RESULT will be initialised here; it will be freed on failure. The 3378 value returned is really a type_kind_t. */ 3379 3380 static int 3381 do_type (struct work_stuff *work, const char **mangled, string *result) 3382 { 3383 int n; 3384 int done; 3385 int success; 3386 string decl; 3387 const char *remembered_type; 3388 int type_quals; 3389 type_kind_t tk = tk_none; 3390 3391 string_init (&decl); 3392 string_init (result); 3393 3394 done = 0; 3395 success = 1; 3396 while (success && !done) 3397 { 3398 int member; 3399 switch (**mangled) 3400 { 3401 3402 /* A pointer type */ 3403 case 'P': 3404 case 'p': 3405 (*mangled)++; 3406 if (! (work -> options & DMGL_JAVA)) 3407 string_prepend (&decl, "*"); 3408 if (tk == tk_none) 3409 tk = tk_pointer; 3410 break; 3411 3412 /* A reference type */ 3413 case 'R': 3414 (*mangled)++; 3415 string_prepend (&decl, "&"); 3416 if (tk == tk_none) 3417 tk = tk_reference; 3418 break; 3419 3420 /* An array */ 3421 case 'A': 3422 { 3423 ++(*mangled); 3424 if (!STRING_EMPTY (&decl) 3425 && (decl.b[0] == '*' || decl.b[0] == '&')) 3426 { 3427 string_prepend (&decl, "("); 3428 string_append (&decl, ")"); 3429 } 3430 string_append (&decl, "["); 3431 if (**mangled != '_') 3432 success = demangle_template_value_parm (work, mangled, &decl, 3433 tk_integral); 3434 if (**mangled == '_') 3435 ++(*mangled); 3436 string_append (&decl, "]"); 3437 break; 3438 } 3439 3440 /* A back reference to a previously seen type */ 3441 case 'T': 3442 (*mangled)++; 3443 if (!get_count (mangled, &n) || n >= work -> ntypes) 3444 { 3445 success = 0; 3446 } 3447 else 3448 { 3449 remembered_type = work -> typevec[n]; 3450 mangled = &remembered_type; 3451 } 3452 break; 3453 3454 /* A function */ 3455 case 'F': 3456 (*mangled)++; 3457 if (!STRING_EMPTY (&decl) 3458 && (decl.b[0] == '*' || decl.b[0] == '&')) 3459 { 3460 string_prepend (&decl, "("); 3461 string_append (&decl, ")"); 3462 } 3463 /* After picking off the function args, we expect to either find the 3464 function return type (preceded by an '_') or the end of the 3465 string. */ 3466 if (!demangle_nested_args (work, mangled, &decl) 3467 || (**mangled != '_' && **mangled != '\0')) 3468 { 3469 success = 0; 3470 break; 3471 } 3472 if (success && (**mangled == '_')) 3473 (*mangled)++; 3474 break; 3475 3476 case 'M': 3477 case 'O': 3478 { 3479 type_quals = TYPE_UNQUALIFIED; 3480 3481 member = **mangled == 'M'; 3482 (*mangled)++; 3483 3484 string_append (&decl, ")"); 3485 3486 /* We don't need to prepend `::' for a qualified name; 3487 demangle_qualified will do that for us. */ 3488 if (**mangled != 'Q') 3489 string_prepend (&decl, SCOPE_STRING (work)); 3490 3491 if (ISDIGIT ((unsigned char)**mangled)) 3492 { 3493 n = consume_count (mangled); 3494 if (n == -1 3495 || (int) strlen (*mangled) < n) 3496 { 3497 success = 0; 3498 break; 3499 } 3500 string_prependn (&decl, *mangled, n); 3501 *mangled += n; 3502 } 3503 else if (**mangled == 'X' || **mangled == 'Y') 3504 { 3505 string temp; 3506 do_type (work, mangled, &temp); 3507 string_prepends (&decl, &temp); 3508 string_delete (&temp); 3509 } 3510 else if (**mangled == 't') 3511 { 3512 string temp; 3513 string_init (&temp); 3514 success = demangle_template (work, mangled, &temp, 3515 NULL, 1, 1); 3516 if (success) 3517 { 3518 string_prependn (&decl, temp.b, temp.p - temp.b); 3519 string_delete (&temp); 3520 } 3521 else 3522 break; 3523 } 3524 else if (**mangled == 'Q') 3525 { 3526 success = demangle_qualified (work, mangled, &decl, 3527 /*isfuncnam=*/0, 3528 /*append=*/0); 3529 if (!success) 3530 break; 3531 } 3532 else 3533 { 3534 success = 0; 3535 break; 3536 } 3537 3538 string_prepend (&decl, "("); 3539 if (member) 3540 { 3541 switch (**mangled) 3542 { 3543 case 'C': 3544 case 'V': 3545 case 'u': 3546 type_quals |= code_for_qualifier (**mangled); 3547 (*mangled)++; 3548 break; 3549 3550 default: 3551 break; 3552 } 3553 3554 if (*(*mangled)++ != 'F') 3555 { 3556 success = 0; 3557 break; 3558 } 3559 } 3560 if ((member && !demangle_nested_args (work, mangled, &decl)) 3561 || **mangled != '_') 3562 { 3563 success = 0; 3564 break; 3565 } 3566 (*mangled)++; 3567 if (! PRINT_ANSI_QUALIFIERS) 3568 { 3569 break; 3570 } 3571 if (type_quals != TYPE_UNQUALIFIED) 3572 { 3573 APPEND_BLANK (&decl); 3574 string_append (&decl, qualifier_string (type_quals)); 3575 } 3576 break; 3577 } 3578 case 'G': 3579 (*mangled)++; 3580 break; 3581 3582 case 'C': 3583 case 'V': 3584 case 'u': 3585 if (PRINT_ANSI_QUALIFIERS) 3586 { 3587 if (!STRING_EMPTY (&decl)) 3588 string_prepend (&decl, " "); 3589 3590 string_prepend (&decl, demangle_qualifier (**mangled)); 3591 } 3592 (*mangled)++; 3593 break; 3594 /* 3595 } 3596 */ 3597 3598 /* fall through */ 3599 default: 3600 done = 1; 3601 break; 3602 } 3603 } 3604 3605 if (success) switch (**mangled) 3606 { 3607 /* A qualified name, such as "Outer::Inner". */ 3608 case 'Q': 3609 case 'K': 3610 { 3611 success = demangle_qualified (work, mangled, result, 0, 1); 3612 break; 3613 } 3614 3615 /* A back reference to a previously seen squangled type */ 3616 case 'B': 3617 (*mangled)++; 3618 if (!get_count (mangled, &n) || n >= work -> numb) 3619 success = 0; 3620 else 3621 string_append (result, work->btypevec[n]); 3622 break; 3623 3624 case 'X': 3625 case 'Y': 3626 /* A template parm. We substitute the corresponding argument. */ 3627 { 3628 int idx; 3629 3630 (*mangled)++; 3631 idx = consume_count_with_underscores (mangled); 3632 3633 if (idx == -1 3634 || (work->tmpl_argvec && idx >= work->ntmpl_args) 3635 || consume_count_with_underscores (mangled) == -1) 3636 { 3637 success = 0; 3638 break; 3639 } 3640 3641 if (work->tmpl_argvec) 3642 string_append (result, work->tmpl_argvec[idx]); 3643 else 3644 string_append_template_idx (result, idx); 3645 3646 success = 1; 3647 } 3648 break; 3649 3650 default: 3651 success = demangle_fund_type (work, mangled, result); 3652 if (tk == tk_none) 3653 tk = (type_kind_t) success; 3654 break; 3655 } 3656 3657 if (success) 3658 { 3659 if (!STRING_EMPTY (&decl)) 3660 { 3661 string_append (result, " "); 3662 string_appends (result, &decl); 3663 } 3664 } 3665 else 3666 string_delete (result); 3667 string_delete (&decl); 3668 3669 if (success) 3670 /* Assume an integral type, if we're not sure. */ 3671 return (int) ((tk == tk_none) ? tk_integral : tk); 3672 else 3673 return 0; 3674 } 3675 3676 /* Given a pointer to a type string that represents a fundamental type 3677 argument (int, long, unsigned int, etc) in TYPE, a pointer to the 3678 string in which the demangled output is being built in RESULT, and 3679 the WORK structure, decode the types and add them to the result. 3680 3681 For example: 3682 3683 "Ci" => "const int" 3684 "Sl" => "signed long" 3685 "CUs" => "const unsigned short" 3686 3687 The value returned is really a type_kind_t. */ 3688 3689 static int 3690 demangle_fund_type (struct work_stuff *work, 3691 const char **mangled, string *result) 3692 { 3693 int done = 0; 3694 int success = 1; 3695 char buf[INTBUF_SIZE + 5 /* 'int%u_t' */]; 3696 unsigned int dec = 0; 3697 type_kind_t tk = tk_integral; 3698 3699 /* First pick off any type qualifiers. There can be more than one. */ 3700 3701 while (!done) 3702 { 3703 switch (**mangled) 3704 { 3705 case 'C': 3706 case 'V': 3707 case 'u': 3708 if (PRINT_ANSI_QUALIFIERS) 3709 { 3710 if (!STRING_EMPTY (result)) 3711 string_prepend (result, " "); 3712 string_prepend (result, demangle_qualifier (**mangled)); 3713 } 3714 (*mangled)++; 3715 break; 3716 case 'U': 3717 (*mangled)++; 3718 APPEND_BLANK (result); 3719 string_append (result, "unsigned"); 3720 break; 3721 case 'S': /* signed char only */ 3722 (*mangled)++; 3723 APPEND_BLANK (result); 3724 string_append (result, "signed"); 3725 break; 3726 case 'J': 3727 (*mangled)++; 3728 APPEND_BLANK (result); 3729 string_append (result, "__complex"); 3730 break; 3731 default: 3732 done = 1; 3733 break; 3734 } 3735 } 3736 3737 /* Now pick off the fundamental type. There can be only one. */ 3738 3739 switch (**mangled) 3740 { 3741 case '\0': 3742 case '_': 3743 break; 3744 case 'v': 3745 (*mangled)++; 3746 APPEND_BLANK (result); 3747 string_append (result, "void"); 3748 break; 3749 case 'x': 3750 (*mangled)++; 3751 APPEND_BLANK (result); 3752 string_append (result, "long long"); 3753 break; 3754 case 'l': 3755 (*mangled)++; 3756 APPEND_BLANK (result); 3757 string_append (result, "long"); 3758 break; 3759 case 'i': 3760 (*mangled)++; 3761 APPEND_BLANK (result); 3762 string_append (result, "int"); 3763 break; 3764 case 's': 3765 (*mangled)++; 3766 APPEND_BLANK (result); 3767 string_append (result, "short"); 3768 break; 3769 case 'b': 3770 (*mangled)++; 3771 APPEND_BLANK (result); 3772 string_append (result, "bool"); 3773 tk = tk_bool; 3774 break; 3775 case 'c': 3776 (*mangled)++; 3777 APPEND_BLANK (result); 3778 string_append (result, "char"); 3779 tk = tk_char; 3780 break; 3781 case 'w': 3782 (*mangled)++; 3783 APPEND_BLANK (result); 3784 string_append (result, "wchar_t"); 3785 tk = tk_char; 3786 break; 3787 case 'r': 3788 (*mangled)++; 3789 APPEND_BLANK (result); 3790 string_append (result, "long double"); 3791 tk = tk_real; 3792 break; 3793 case 'd': 3794 (*mangled)++; 3795 APPEND_BLANK (result); 3796 string_append (result, "double"); 3797 tk = tk_real; 3798 break; 3799 case 'f': 3800 (*mangled)++; 3801 APPEND_BLANK (result); 3802 string_append (result, "float"); 3803 tk = tk_real; 3804 break; 3805 case 'G': 3806 (*mangled)++; 3807 if (!ISDIGIT ((unsigned char)**mangled)) 3808 { 3809 success = 0; 3810 break; 3811 } 3812 case 'I': 3813 (*mangled)++; 3814 if (**mangled == '_') 3815 { 3816 int i; 3817 (*mangled)++; 3818 for (i = 0; 3819 i < (long) sizeof (buf) - 1 && **mangled && **mangled != '_'; 3820 (*mangled)++, i++) 3821 buf[i] = **mangled; 3822 if (**mangled != '_') 3823 { 3824 success = 0; 3825 break; 3826 } 3827 buf[i] = '\0'; 3828 (*mangled)++; 3829 } 3830 else 3831 { 3832 strncpy (buf, *mangled, 2); 3833 buf[2] = '\0'; 3834 *mangled += min (strlen (*mangled), 2); 3835 } 3836 sscanf (buf, "%x", &dec); 3837 sprintf (buf, "int%u_t", dec); 3838 APPEND_BLANK (result); 3839 string_append (result, buf); 3840 break; 3841 3842 /* fall through */ 3843 /* An explicit type, such as "6mytype" or "7integer" */ 3844 case '0': 3845 case '1': 3846 case '2': 3847 case '3': 3848 case '4': 3849 case '5': 3850 case '6': 3851 case '7': 3852 case '8': 3853 case '9': 3854 { 3855 int bindex = register_Btype (work); 3856 string btype; 3857 string_init (&btype); 3858 if (demangle_class_name (work, mangled, &btype)) { 3859 remember_Btype (work, btype.b, LEN_STRING (&btype), bindex); 3860 APPEND_BLANK (result); 3861 string_appends (result, &btype); 3862 } 3863 else 3864 success = 0; 3865 string_delete (&btype); 3866 break; 3867 } 3868 case 't': 3869 { 3870 string btype; 3871 string_init (&btype); 3872 success = demangle_template (work, mangled, &btype, 0, 1, 1); 3873 string_appends (result, &btype); 3874 string_delete (&btype); 3875 break; 3876 } 3877 default: 3878 success = 0; 3879 break; 3880 } 3881 3882 return success ? ((int) tk) : 0; 3883 } 3884 3885 3886 /* Handle a template's value parameter for HP aCC (extension from ARM) 3887 **mangled points to 'S' or 'U' */ 3888 3889 static int 3890 do_hpacc_template_const_value (struct work_stuff *work ATTRIBUTE_UNUSED, 3891 const char **mangled, string *result) 3892 { 3893 int unsigned_const; 3894 3895 if (**mangled != 'U' && **mangled != 'S') 3896 return 0; 3897 3898 unsigned_const = (**mangled == 'U'); 3899 3900 (*mangled)++; 3901 3902 switch (**mangled) 3903 { 3904 case 'N': 3905 string_append (result, "-"); 3906 /* fall through */ 3907 case 'P': 3908 (*mangled)++; 3909 break; 3910 case 'M': 3911 /* special case for -2^31 */ 3912 string_append (result, "-2147483648"); 3913 (*mangled)++; 3914 return 1; 3915 default: 3916 return 0; 3917 } 3918 3919 /* We have to be looking at an integer now */ 3920 if (!(ISDIGIT ((unsigned char)**mangled))) 3921 return 0; 3922 3923 /* We only deal with integral values for template 3924 parameters -- so it's OK to look only for digits */ 3925 while (ISDIGIT ((unsigned char)**mangled)) 3926 { 3927 char_str[0] = **mangled; 3928 string_append (result, char_str); 3929 (*mangled)++; 3930 } 3931 3932 if (unsigned_const) 3933 string_append (result, "U"); 3934 3935 /* FIXME? Some day we may have 64-bit (or larger :-) ) constants 3936 with L or LL suffixes. pai/1997-09-03 */ 3937 3938 return 1; /* success */ 3939 } 3940 3941 /* Handle a template's literal parameter for HP aCC (extension from ARM) 3942 **mangled is pointing to the 'A' */ 3943 3944 static int 3945 do_hpacc_template_literal (struct work_stuff *work, const char **mangled, 3946 string *result) 3947 { 3948 int literal_len = 0; 3949 char * recurse; 3950 char * recurse_dem; 3951 3952 if (**mangled != 'A') 3953 return 0; 3954 3955 (*mangled)++; 3956 3957 literal_len = consume_count (mangled); 3958 3959 if (literal_len <= 0) 3960 return 0; 3961 3962 /* Literal parameters are names of arrays, functions, etc. and the 3963 canonical representation uses the address operator */ 3964 string_append (result, "&"); 3965 3966 /* Now recursively demangle the literal name */ 3967 recurse = XNEWVEC (char, literal_len + 1); 3968 memcpy (recurse, *mangled, literal_len); 3969 recurse[literal_len] = '\000'; 3970 3971 recurse_dem = cplus_demangle (recurse, work->options); 3972 3973 if (recurse_dem) 3974 { 3975 string_append (result, recurse_dem); 3976 free (recurse_dem); 3977 } 3978 else 3979 { 3980 string_appendn (result, *mangled, literal_len); 3981 } 3982 (*mangled) += literal_len; 3983 free (recurse); 3984 3985 return 1; 3986 } 3987 3988 static int 3989 snarf_numeric_literal (const char **args, string *arg) 3990 { 3991 if (**args == '-') 3992 { 3993 char_str[0] = '-'; 3994 string_append (arg, char_str); 3995 (*args)++; 3996 } 3997 else if (**args == '+') 3998 (*args)++; 3999 4000 if (!ISDIGIT ((unsigned char)**args)) 4001 return 0; 4002 4003 while (ISDIGIT ((unsigned char)**args)) 4004 { 4005 char_str[0] = **args; 4006 string_append (arg, char_str); 4007 (*args)++; 4008 } 4009 4010 return 1; 4011 } 4012 4013 /* Demangle the next argument, given by MANGLED into RESULT, which 4014 *should be an uninitialized* string. It will be initialized here, 4015 and free'd should anything go wrong. */ 4016 4017 static int 4018 do_arg (struct work_stuff *work, const char **mangled, string *result) 4019 { 4020 /* Remember where we started so that we can record the type, for 4021 non-squangling type remembering. */ 4022 const char *start = *mangled; 4023 4024 string_init (result); 4025 4026 if (work->nrepeats > 0) 4027 { 4028 --work->nrepeats; 4029 4030 if (work->previous_argument == 0) 4031 return 0; 4032 4033 /* We want to reissue the previous type in this argument list. */ 4034 string_appends (result, work->previous_argument); 4035 return 1; 4036 } 4037 4038 if (**mangled == 'n') 4039 { 4040 /* A squangling-style repeat. */ 4041 (*mangled)++; 4042 work->nrepeats = consume_count(mangled); 4043 4044 if (work->nrepeats <= 0) 4045 /* This was not a repeat count after all. */ 4046 return 0; 4047 4048 if (work->nrepeats > 9) 4049 { 4050 if (**mangled != '_') 4051 /* The repeat count should be followed by an '_' in this 4052 case. */ 4053 return 0; 4054 else 4055 (*mangled)++; 4056 } 4057 4058 /* Now, the repeat is all set up. */ 4059 return do_arg (work, mangled, result); 4060 } 4061 4062 /* Save the result in WORK->previous_argument so that we can find it 4063 if it's repeated. Note that saving START is not good enough: we 4064 do not want to add additional types to the back-referenceable 4065 type vector when processing a repeated type. */ 4066 if (work->previous_argument) 4067 string_delete (work->previous_argument); 4068 else 4069 work->previous_argument = XNEW (string); 4070 4071 if (!do_type (work, mangled, work->previous_argument)) 4072 return 0; 4073 4074 string_appends (result, work->previous_argument); 4075 4076 remember_type (work, start, *mangled - start); 4077 return 1; 4078 } 4079 4080 static void 4081 remember_type (struct work_stuff *work, const char *start, int len) 4082 { 4083 char *tem; 4084 4085 if (work->forgetting_types) 4086 return; 4087 4088 if (work -> ntypes >= work -> typevec_size) 4089 { 4090 if (work -> typevec_size == 0) 4091 { 4092 work -> typevec_size = 3; 4093 work -> typevec = XNEWVEC (char *, work->typevec_size); 4094 } 4095 else 4096 { 4097 work -> typevec_size *= 2; 4098 work -> typevec 4099 = XRESIZEVEC (char *, work->typevec, work->typevec_size); 4100 } 4101 } 4102 tem = XNEWVEC (char, len + 1); 4103 memcpy (tem, start, len); 4104 tem[len] = '\0'; 4105 work -> typevec[work -> ntypes++] = tem; 4106 } 4107 4108 4109 /* Remember a K type class qualifier. */ 4110 static void 4111 remember_Ktype (struct work_stuff *work, const char *start, int len) 4112 { 4113 char *tem; 4114 4115 if (work -> numk >= work -> ksize) 4116 { 4117 if (work -> ksize == 0) 4118 { 4119 work -> ksize = 5; 4120 work -> ktypevec = XNEWVEC (char *, work->ksize); 4121 } 4122 else 4123 { 4124 work -> ksize *= 2; 4125 work -> ktypevec 4126 = XRESIZEVEC (char *, work->ktypevec, work->ksize); 4127 } 4128 } 4129 tem = XNEWVEC (char, len + 1); 4130 memcpy (tem, start, len); 4131 tem[len] = '\0'; 4132 work -> ktypevec[work -> numk++] = tem; 4133 } 4134 4135 /* Register a B code, and get an index for it. B codes are registered 4136 as they are seen, rather than as they are completed, so map<temp<char> > 4137 registers map<temp<char> > as B0, and temp<char> as B1 */ 4138 4139 static int 4140 register_Btype (struct work_stuff *work) 4141 { 4142 int ret; 4143 4144 if (work -> numb >= work -> bsize) 4145 { 4146 if (work -> bsize == 0) 4147 { 4148 work -> bsize = 5; 4149 work -> btypevec = XNEWVEC (char *, work->bsize); 4150 } 4151 else 4152 { 4153 work -> bsize *= 2; 4154 work -> btypevec 4155 = XRESIZEVEC (char *, work->btypevec, work->bsize); 4156 } 4157 } 4158 ret = work -> numb++; 4159 work -> btypevec[ret] = NULL; 4160 return(ret); 4161 } 4162 4163 /* Store a value into a previously registered B code type. */ 4164 4165 static void 4166 remember_Btype (struct work_stuff *work, const char *start, 4167 int len, int index) 4168 { 4169 char *tem; 4170 4171 tem = XNEWVEC (char, len + 1); 4172 memcpy (tem, start, len); 4173 tem[len] = '\0'; 4174 work -> btypevec[index] = tem; 4175 } 4176 4177 /* Lose all the info related to B and K type codes. */ 4178 static void 4179 forget_B_and_K_types (struct work_stuff *work) 4180 { 4181 int i; 4182 4183 while (work -> numk > 0) 4184 { 4185 i = --(work -> numk); 4186 if (work -> ktypevec[i] != NULL) 4187 { 4188 free (work -> ktypevec[i]); 4189 work -> ktypevec[i] = NULL; 4190 } 4191 } 4192 4193 while (work -> numb > 0) 4194 { 4195 i = --(work -> numb); 4196 if (work -> btypevec[i] != NULL) 4197 { 4198 free (work -> btypevec[i]); 4199 work -> btypevec[i] = NULL; 4200 } 4201 } 4202 } 4203 /* Forget the remembered types, but not the type vector itself. */ 4204 4205 static void 4206 forget_types (struct work_stuff *work) 4207 { 4208 int i; 4209 4210 while (work -> ntypes > 0) 4211 { 4212 i = --(work -> ntypes); 4213 if (work -> typevec[i] != NULL) 4214 { 4215 free (work -> typevec[i]); 4216 work -> typevec[i] = NULL; 4217 } 4218 } 4219 } 4220 4221 /* Process the argument list part of the signature, after any class spec 4222 has been consumed, as well as the first 'F' character (if any). For 4223 example: 4224 4225 "__als__3fooRT0" => process "RT0" 4226 "complexfunc5__FPFPc_PFl_i" => process "PFPc_PFl_i" 4227 4228 DECLP must be already initialised, usually non-empty. It won't be freed 4229 on failure. 4230 4231 Note that g++ differs significantly from ARM and lucid style mangling 4232 with regards to references to previously seen types. For example, given 4233 the source fragment: 4234 4235 class foo { 4236 public: 4237 foo::foo (int, foo &ia, int, foo &ib, int, foo &ic); 4238 }; 4239 4240 foo::foo (int, foo &ia, int, foo &ib, int, foo &ic) { ia = ib = ic; } 4241 void foo (int, foo &ia, int, foo &ib, int, foo &ic) { ia = ib = ic; } 4242 4243 g++ produces the names: 4244 4245 __3fooiRT0iT2iT2 4246 foo__FiR3fooiT1iT1 4247 4248 while lcc (and presumably other ARM style compilers as well) produces: 4249 4250 foo__FiR3fooT1T2T1T2 4251 __ct__3fooFiR3fooT1T2T1T2 4252 4253 Note that g++ bases its type numbers starting at zero and counts all 4254 previously seen types, while lucid/ARM bases its type numbers starting 4255 at one and only considers types after it has seen the 'F' character 4256 indicating the start of the function args. For lucid/ARM style, we 4257 account for this difference by discarding any previously seen types when 4258 we see the 'F' character, and subtracting one from the type number 4259 reference. 4260 4261 */ 4262 4263 static int 4264 demangle_args (struct work_stuff *work, const char **mangled, 4265 string *declp) 4266 { 4267 string arg; 4268 int need_comma = 0; 4269 int r; 4270 int t; 4271 const char *tem; 4272 char temptype; 4273 4274 if (PRINT_ARG_TYPES) 4275 { 4276 string_append (declp, "("); 4277 if (**mangled == '\0') 4278 { 4279 string_append (declp, "void"); 4280 } 4281 } 4282 4283 while ((**mangled != '_' && **mangled != '\0' && **mangled != 'e') 4284 || work->nrepeats > 0) 4285 { 4286 if ((**mangled == 'N') || (**mangled == 'T')) 4287 { 4288 temptype = *(*mangled)++; 4289 4290 if (temptype == 'N') 4291 { 4292 if (!get_count (mangled, &r)) 4293 { 4294 return (0); 4295 } 4296 } 4297 else 4298 { 4299 r = 1; 4300 } 4301 if ((HP_DEMANGLING || ARM_DEMANGLING || EDG_DEMANGLING) && work -> ntypes >= 10) 4302 { 4303 /* If we have 10 or more types we might have more than a 1 digit 4304 index so we'll have to consume the whole count here. This 4305 will lose if the next thing is a type name preceded by a 4306 count but it's impossible to demangle that case properly 4307 anyway. Eg if we already have 12 types is T12Pc "(..., type1, 4308 Pc, ...)" or "(..., type12, char *, ...)" */ 4309 if ((t = consume_count(mangled)) <= 0) 4310 { 4311 return (0); 4312 } 4313 } 4314 else 4315 { 4316 if (!get_count (mangled, &t)) 4317 { 4318 return (0); 4319 } 4320 } 4321 if (LUCID_DEMANGLING || ARM_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING) 4322 { 4323 t--; 4324 } 4325 /* Validate the type index. Protect against illegal indices from 4326 malformed type strings. */ 4327 if ((t < 0) || (t >= work -> ntypes)) 4328 { 4329 return (0); 4330 } 4331 while (work->nrepeats > 0 || --r >= 0) 4332 { 4333 tem = work -> typevec[t]; 4334 if (need_comma && PRINT_ARG_TYPES) 4335 { 4336 string_append (declp, ", "); 4337 } 4338 if (!do_arg (work, &tem, &arg)) 4339 { 4340 return (0); 4341 } 4342 if (PRINT_ARG_TYPES) 4343 { 4344 string_appends (declp, &arg); 4345 } 4346 string_delete (&arg); 4347 need_comma = 1; 4348 } 4349 } 4350 else 4351 { 4352 if (need_comma && PRINT_ARG_TYPES) 4353 string_append (declp, ", "); 4354 if (!do_arg (work, mangled, &arg)) 4355 return (0); 4356 if (PRINT_ARG_TYPES) 4357 string_appends (declp, &arg); 4358 string_delete (&arg); 4359 need_comma = 1; 4360 } 4361 } 4362 4363 if (**mangled == 'e') 4364 { 4365 (*mangled)++; 4366 if (PRINT_ARG_TYPES) 4367 { 4368 if (need_comma) 4369 { 4370 string_append (declp, ","); 4371 } 4372 string_append (declp, "..."); 4373 } 4374 } 4375 4376 if (PRINT_ARG_TYPES) 4377 { 4378 string_append (declp, ")"); 4379 } 4380 return (1); 4381 } 4382 4383 /* Like demangle_args, but for demangling the argument lists of function 4384 and method pointers or references, not top-level declarations. */ 4385 4386 static int 4387 demangle_nested_args (struct work_stuff *work, const char **mangled, 4388 string *declp) 4389 { 4390 string* saved_previous_argument; 4391 int result; 4392 int saved_nrepeats; 4393 4394 /* The G++ name-mangling algorithm does not remember types on nested 4395 argument lists, unless -fsquangling is used, and in that case the 4396 type vector updated by remember_type is not used. So, we turn 4397 off remembering of types here. */ 4398 ++work->forgetting_types; 4399 4400 /* For the repeat codes used with -fsquangling, we must keep track of 4401 the last argument. */ 4402 saved_previous_argument = work->previous_argument; 4403 saved_nrepeats = work->nrepeats; 4404 work->previous_argument = 0; 4405 work->nrepeats = 0; 4406 4407 /* Actually demangle the arguments. */ 4408 result = demangle_args (work, mangled, declp); 4409 4410 /* Restore the previous_argument field. */ 4411 if (work->previous_argument) 4412 { 4413 string_delete (work->previous_argument); 4414 free ((char *) work->previous_argument); 4415 } 4416 work->previous_argument = saved_previous_argument; 4417 --work->forgetting_types; 4418 work->nrepeats = saved_nrepeats; 4419 4420 return result; 4421 } 4422 4423 /* Returns 1 if a valid function name was found or 0 otherwise. */ 4424 4425 static int 4426 demangle_function_name (struct work_stuff *work, const char **mangled, 4427 string *declp, const char *scan) 4428 { 4429 size_t i; 4430 string type; 4431 const char *tem; 4432 4433 string_appendn (declp, (*mangled), scan - (*mangled)); 4434 string_need (declp, 1); 4435 *(declp -> p) = '\0'; 4436 4437 /* Consume the function name, including the "__" separating the name 4438 from the signature. We are guaranteed that SCAN points to the 4439 separator. */ 4440 4441 (*mangled) = scan + 2; 4442 /* We may be looking at an instantiation of a template function: 4443 foo__Xt1t2_Ft3t4, where t1, t2, ... are template arguments and a 4444 following _F marks the start of the function arguments. Handle 4445 the template arguments first. */ 4446 4447 if (HP_DEMANGLING && (**mangled == 'X')) 4448 { 4449 demangle_arm_hp_template (work, mangled, 0, declp); 4450 /* This leaves MANGLED pointing to the 'F' marking func args */ 4451 } 4452 4453 if (LUCID_DEMANGLING || ARM_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING) 4454 { 4455 4456 /* See if we have an ARM style constructor or destructor operator. 4457 If so, then just record it, clear the decl, and return. 4458 We can't build the actual constructor/destructor decl until later, 4459 when we recover the class name from the signature. */ 4460 4461 if (strcmp (declp -> b, "__ct") == 0) 4462 { 4463 work -> constructor += 1; 4464 string_clear (declp); 4465 return 1; 4466 } 4467 else if (strcmp (declp -> b, "__dt") == 0) 4468 { 4469 work -> destructor += 1; 4470 string_clear (declp); 4471 return 1; 4472 } 4473 } 4474 4475 if (declp->p - declp->b >= 3 4476 && declp->b[0] == 'o' 4477 && declp->b[1] == 'p' 4478 && strchr (cplus_markers, declp->b[2]) != NULL) 4479 { 4480 /* see if it's an assignment expression */ 4481 if (declp->p - declp->b >= 10 /* op$assign_ */ 4482 && memcmp (declp->b + 3, "assign_", 7) == 0) 4483 { 4484 for (i = 0; i < ARRAY_SIZE (optable); i++) 4485 { 4486 int len = declp->p - declp->b - 10; 4487 if ((int) strlen (optable[i].in) == len 4488 && memcmp (optable[i].in, declp->b + 10, len) == 0) 4489 { 4490 string_clear (declp); 4491 string_append (declp, "operator"); 4492 string_append (declp, optable[i].out); 4493 string_append (declp, "="); 4494 break; 4495 } 4496 } 4497 } 4498 else 4499 { 4500 for (i = 0; i < ARRAY_SIZE (optable); i++) 4501 { 4502 int len = declp->p - declp->b - 3; 4503 if ((int) strlen (optable[i].in) == len 4504 && memcmp (optable[i].in, declp->b + 3, len) == 0) 4505 { 4506 string_clear (declp); 4507 string_append (declp, "operator"); 4508 string_append (declp, optable[i].out); 4509 break; 4510 } 4511 } 4512 } 4513 } 4514 else if (declp->p - declp->b >= 5 && memcmp (declp->b, "type", 4) == 0 4515 && strchr (cplus_markers, declp->b[4]) != NULL) 4516 { 4517 /* type conversion operator */ 4518 tem = declp->b + 5; 4519 if (do_type (work, &tem, &type)) 4520 { 4521 string_clear (declp); 4522 string_append (declp, "operator "); 4523 string_appends (declp, &type); 4524 string_delete (&type); 4525 } 4526 } 4527 else if (declp->b[0] == '_' && declp->b[1] == '_' 4528 && declp->b[2] == 'o' && declp->b[3] == 'p') 4529 { 4530 /* ANSI. */ 4531 /* type conversion operator. */ 4532 tem = declp->b + 4; 4533 if (do_type (work, &tem, &type)) 4534 { 4535 string_clear (declp); 4536 string_append (declp, "operator "); 4537 string_appends (declp, &type); 4538 string_delete (&type); 4539 } 4540 } 4541 else if (declp->b[0] == '_' && declp->b[1] == '_' 4542 && ISLOWER((unsigned char)declp->b[2]) 4543 && ISLOWER((unsigned char)declp->b[3])) 4544 { 4545 if (declp->b[4] == '\0') 4546 { 4547 /* Operator. */ 4548 for (i = 0; i < ARRAY_SIZE (optable); i++) 4549 { 4550 if (strlen (optable[i].in) == 2 4551 && memcmp (optable[i].in, declp->b + 2, 2) == 0) 4552 { 4553 string_clear (declp); 4554 string_append (declp, "operator"); 4555 string_append (declp, optable[i].out); 4556 break; 4557 } 4558 } 4559 } 4560 else 4561 { 4562 if (declp->b[2] == 'a' && declp->b[5] == '\0') 4563 { 4564 /* Assignment. */ 4565 for (i = 0; i < ARRAY_SIZE (optable); i++) 4566 { 4567 if (strlen (optable[i].in) == 3 4568 && memcmp (optable[i].in, declp->b + 2, 3) == 0) 4569 { 4570 string_clear (declp); 4571 string_append (declp, "operator"); 4572 string_append (declp, optable[i].out); 4573 break; 4574 } 4575 } 4576 } 4577 } 4578 } 4579 4580 /* If a function name was obtained but it's not valid, we were not 4581 successful. */ 4582 if (LEN_STRING (declp) == 1 && declp->b[0] == '.') 4583 return 0; 4584 else 4585 return 1; 4586 } 4587 4588 /* a mini string-handling package */ 4589 4590 static void 4591 string_need (string *s, int n) 4592 { 4593 int tem; 4594 4595 if (s->b == NULL) 4596 { 4597 if (n < 32) 4598 { 4599 n = 32; 4600 } 4601 s->p = s->b = XNEWVEC (char, n); 4602 s->e = s->b + n; 4603 } 4604 else if (s->e - s->p < n) 4605 { 4606 tem = s->p - s->b; 4607 n += tem; 4608 n *= 2; 4609 s->b = XRESIZEVEC (char, s->b, n); 4610 s->p = s->b + tem; 4611 s->e = s->b + n; 4612 } 4613 } 4614 4615 static void 4616 string_delete (string *s) 4617 { 4618 if (s->b != NULL) 4619 { 4620 free (s->b); 4621 s->b = s->e = s->p = NULL; 4622 } 4623 } 4624 4625 static void 4626 string_init (string *s) 4627 { 4628 s->b = s->p = s->e = NULL; 4629 } 4630 4631 static void 4632 string_clear (string *s) 4633 { 4634 s->p = s->b; 4635 } 4636 4637 #if 0 4638 4639 static int 4640 string_empty (string *s) 4641 { 4642 return (s->b == s->p); 4643 } 4644 4645 #endif 4646 4647 static void 4648 string_append (string *p, const char *s) 4649 { 4650 int n; 4651 if (s == NULL || *s == '\0') 4652 return; 4653 n = strlen (s); 4654 string_need (p, n); 4655 memcpy (p->p, s, n); 4656 p->p += n; 4657 } 4658 4659 static void 4660 string_appends (string *p, string *s) 4661 { 4662 int n; 4663 4664 if (s->b != s->p) 4665 { 4666 n = s->p - s->b; 4667 string_need (p, n); 4668 memcpy (p->p, s->b, n); 4669 p->p += n; 4670 } 4671 } 4672 4673 static void 4674 string_appendn (string *p, const char *s, int n) 4675 { 4676 if (n != 0) 4677 { 4678 string_need (p, n); 4679 memcpy (p->p, s, n); 4680 p->p += n; 4681 } 4682 } 4683 4684 static void 4685 string_prepend (string *p, const char *s) 4686 { 4687 if (s != NULL && *s != '\0') 4688 { 4689 string_prependn (p, s, strlen (s)); 4690 } 4691 } 4692 4693 static void 4694 string_prepends (string *p, string *s) 4695 { 4696 if (s->b != s->p) 4697 { 4698 string_prependn (p, s->b, s->p - s->b); 4699 } 4700 } 4701 4702 static void 4703 string_prependn (string *p, const char *s, int n) 4704 { 4705 char *q; 4706 4707 if (n != 0) 4708 { 4709 string_need (p, n); 4710 for (q = p->p - 1; q >= p->b; q--) 4711 { 4712 q[n] = q[0]; 4713 } 4714 memcpy (p->b, s, n); 4715 p->p += n; 4716 } 4717 } 4718 4719 static void 4720 string_append_template_idx (string *s, int idx) 4721 { 4722 char buf[INTBUF_SIZE + 1 /* 'T' */]; 4723 sprintf(buf, "T%d", idx); 4724 string_append (s, buf); 4725 } 4726