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