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