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