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