![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cplus-dem.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GCC 2.x] / gcc|
Return to cplus-dem.c CVS log | Up to [GCC 2.x] / gcc |
1.1 ! root 1: /* Demangler for GNU C++ ! 2: Copyright 1989, 1991, 1994, 1995 Free Software Foundation, Inc. ! 3: Written by James Clark ([email protected]) ! 4: Rewritten by Fred Fish ([email protected]) for ARM and Lucid demangling ! 5: ! 6: This file is part of the libiberty library. ! 7: Libiberty is free software; you can redistribute it and/or ! 8: modify it under the terms of the GNU Library General Public ! 9: License as published by the Free Software Foundation; either ! 10: version 2 of the License, or (at your option) any later version. ! 11: ! 12: Libiberty is distributed in the hope that it will be useful, ! 13: but WITHOUT ANY WARRANTY; without even the implied warranty of ! 14: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ! 15: Library General Public License for more details. ! 16: ! 17: You should have received a copy of the GNU Library General Public ! 18: License along with libiberty; see the file COPYING.LIB. If ! 19: not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, ! 20: Boston, MA 02111-1307, USA. */ ! 21: ! 22: /* This file exports two functions; cplus_mangle_opname and cplus_demangle. ! 23: ! 24: This file imports xmalloc and xrealloc, which are like malloc and ! 25: realloc except that they generate a fatal error if there is no ! 26: available memory. */ ! 27: ! 28: #include <ctype.h> ! 29: #include <string.h> ! 30: #include <stdio.h> ! 31: ! 32: #include <demangle.h> ! 33: #undef CURRENT_DEMANGLING_STYLE ! 34: #define CURRENT_DEMANGLING_STYLE work->options ! 35: ! 36: extern char *xmalloc PARAMS((unsigned)); ! 37: extern char *xrealloc PARAMS((char *, unsigned)); ! 38: ! 39: char * ! 40: mystrstr (s1, s2) ! 41: char *s1, *s2; ! 42: { ! 43: register char *p = s1; ! 44: register int len = strlen (s2); ! 45: ! 46: for (; (p = strchr (p, *s2)) != 0; p++) ! 47: { ! 48: if (strncmp (p, s2, len) == 0) ! 49: { ! 50: return (p); ! 51: } ! 52: } ! 53: return (0); ! 54: } ! 55: ! 56: /* In order to allow a single demangler executable to demangle strings ! 57: using various common values of CPLUS_MARKER, as well as any specific ! 58: one set at compile time, we maintain a string containing all the ! 59: commonly used ones, and check to see if the marker we are looking for ! 60: is in that string. CPLUS_MARKER is usually '$' on systems where the ! 61: assembler can deal with that. Where the assembler can't, it's usually ! 62: '.' (but on many systems '.' is used for other things). We put the ! 63: current defined CPLUS_MARKER first (which defaults to '$'), followed ! 64: by the next most common value, followed by an explicit '$' in case ! 65: the value of CPLUS_MARKER is not '$'. ! 66: ! 67: We could avoid this if we could just get g++ to tell us what the actual ! 68: cplus marker character is as part of the debug information, perhaps by ! 69: ensuring that it is the character that terminates the gcc<n>_compiled ! 70: marker symbol (FIXME). */ ! 71: ! 72: #if !defined (CPLUS_MARKER) ! 73: #define CPLUS_MARKER '$' ! 74: #endif ! 75: ! 76: enum demangling_styles current_demangling_style = gnu_demangling; ! 77: ! 78: static char cplus_markers[] = { CPLUS_MARKER, '.', '$', '\0' }; ! 79: ! 80: void ! 81: set_cplus_marker_for_demangling (ch) ! 82: int ch; ! 83: { ! 84: cplus_markers[0] = ch; ! 85: } ! 86: ! 87: /* Stuff that is shared between sub-routines. ! 88: * Using a shared structure allows cplus_demangle to be reentrant. */ ! 89: ! 90: struct work_stuff ! 91: { ! 92: int options; ! 93: char **typevec; ! 94: int ntypes; ! 95: int typevec_size; ! 96: int constructor; ! 97: int destructor; ! 98: int static_type; /* A static member function */ ! 99: int const_type; /* A const member function */ ! 100: }; ! 101: ! 102: #define PRINT_ANSI_QUALIFIERS (work -> options & DMGL_ANSI) ! 103: #define PRINT_ARG_TYPES (work -> options & DMGL_PARAMS) ! 104: ! 105: static const struct optable ! 106: { ! 107: const char *in; ! 108: const char *out; ! 109: int flags; ! 110: } optable[] = { ! 111: {"nw", " new", DMGL_ANSI}, /* new (1.92, ansi) */ ! 112: {"dl", " delete", DMGL_ANSI}, /* new (1.92, ansi) */ ! 113: {"new", " new", 0}, /* old (1.91, and 1.x) */ ! 114: {"delete", " delete", 0}, /* old (1.91, and 1.x) */ ! 115: {"vn", " new []", DMGL_ANSI}, /* GNU, pending ansi */ ! 116: {"vd", " delete []", DMGL_ANSI}, /* GNU, pending ansi */ ! 117: {"as", "=", DMGL_ANSI}, /* ansi */ ! 118: {"ne", "!=", DMGL_ANSI}, /* old, ansi */ ! 119: {"eq", "==", DMGL_ANSI}, /* old, ansi */ ! 120: {"ge", ">=", DMGL_ANSI}, /* old, ansi */ ! 121: {"gt", ">", DMGL_ANSI}, /* old, ansi */ ! 122: {"le", "<=", DMGL_ANSI}, /* old, ansi */ ! 123: {"lt", "<", DMGL_ANSI}, /* old, ansi */ ! 124: {"plus", "+", 0}, /* old */ ! 125: {"pl", "+", DMGL_ANSI}, /* ansi */ ! 126: {"apl", "+=", DMGL_ANSI}, /* ansi */ ! 127: {"minus", "-", 0}, /* old */ ! 128: {"mi", "-", DMGL_ANSI}, /* ansi */ ! 129: {"ami", "-=", DMGL_ANSI}, /* ansi */ ! 130: {"mult", "*", 0}, /* old */ ! 131: {"ml", "*", DMGL_ANSI}, /* ansi */ ! 132: {"amu", "*=", DMGL_ANSI}, /* ansi (ARM/Lucid) */ ! 133: {"aml", "*=", DMGL_ANSI}, /* ansi (GNU/g++) */ ! 134: {"convert", "+", 0}, /* old (unary +) */ ! 135: {"negate", "-", 0}, /* old (unary -) */ ! 136: {"trunc_mod", "%", 0}, /* old */ ! 137: {"md", "%", DMGL_ANSI}, /* ansi */ ! 138: {"amd", "%=", DMGL_ANSI}, /* ansi */ ! 139: {"trunc_div", "/", 0}, /* old */ ! 140: {"dv", "/", DMGL_ANSI}, /* ansi */ ! 141: {"adv", "/=", DMGL_ANSI}, /* ansi */ ! 142: {"truth_andif", "&&", 0}, /* old */ ! 143: {"aa", "&&", DMGL_ANSI}, /* ansi */ ! 144: {"truth_orif", "||", 0}, /* old */ ! 145: {"oo", "||", DMGL_ANSI}, /* ansi */ ! 146: {"truth_not", "!", 0}, /* old */ ! 147: {"nt", "!", DMGL_ANSI}, /* ansi */ ! 148: {"postincrement","++", 0}, /* old */ ! 149: {"pp", "++", DMGL_ANSI}, /* ansi */ ! 150: {"postdecrement","--", 0}, /* old */ ! 151: {"mm", "--", DMGL_ANSI}, /* ansi */ ! 152: {"bit_ior", "|", 0}, /* old */ ! 153: {"or", "|", DMGL_ANSI}, /* ansi */ ! 154: {"aor", "|=", DMGL_ANSI}, /* ansi */ ! 155: {"bit_xor", "^", 0}, /* old */ ! 156: {"er", "^", DMGL_ANSI}, /* ansi */ ! 157: {"aer", "^=", DMGL_ANSI}, /* ansi */ ! 158: {"bit_and", "&", 0}, /* old */ ! 159: {"ad", "&", DMGL_ANSI}, /* ansi */ ! 160: {"aad", "&=", DMGL_ANSI}, /* ansi */ ! 161: {"bit_not", "~", 0}, /* old */ ! 162: {"co", "~", DMGL_ANSI}, /* ansi */ ! 163: {"call", "()", 0}, /* old */ ! 164: {"cl", "()", DMGL_ANSI}, /* ansi */ ! 165: {"alshift", "<<", 0}, /* old */ ! 166: {"ls", "<<", DMGL_ANSI}, /* ansi */ ! 167: {"als", "<<=", DMGL_ANSI}, /* ansi */ ! 168: {"arshift", ">>", 0}, /* old */ ! 169: {"rs", ">>", DMGL_ANSI}, /* ansi */ ! 170: {"ars", ">>=", DMGL_ANSI}, /* ansi */ ! 171: {"component", "->", 0}, /* old */ ! 172: {"pt", "->", DMGL_ANSI}, /* ansi; Lucid C++ form */ ! 173: {"rf", "->", DMGL_ANSI}, /* ansi; ARM/GNU form */ ! 174: {"indirect", "*", 0}, /* old */ ! 175: {"method_call", "->()", 0}, /* old */ ! 176: {"addr", "&", 0}, /* old (unary &) */ ! 177: {"array", "[]", 0}, /* old */ ! 178: {"vc", "[]", DMGL_ANSI}, /* ansi */ ! 179: {"compound", ", ", 0}, /* old */ ! 180: {"cm", ", ", DMGL_ANSI}, /* ansi */ ! 181: {"cond", "?:", 0}, /* old */ ! 182: {"cn", "?:", DMGL_ANSI}, /* pseudo-ansi */ ! 183: {"max", ">?", 0}, /* old */ ! 184: {"mx", ">?", DMGL_ANSI}, /* pseudo-ansi */ ! 185: {"min", "<?", 0}, /* old */ ! 186: {"mn", "<?", DMGL_ANSI}, /* pseudo-ansi */ ! 187: {"nop", "", 0}, /* old (for operator=) */ ! 188: {"rm", "->*", DMGL_ANSI} /* ansi */ ! 189: }; ! 190: ! 191: ! 192: typedef struct string /* Beware: these aren't required to be */ ! 193: { /* '\0' terminated. */ ! 194: char *b; /* pointer to start of string */ ! 195: char *p; /* pointer after last character */ ! 196: char *e; /* pointer after end of allocated space */ ! 197: } string; ! 198: ! 199: #define STRING_EMPTY(str) ((str) -> b == (str) -> p) ! 200: #define PREPEND_BLANK(str) {if (!STRING_EMPTY(str)) \ ! 201: string_prepend(str, " ");} ! 202: #define APPEND_BLANK(str) {if (!STRING_EMPTY(str)) \ ! 203: string_append(str, " ");} ! 204: ! 205: #define ARM_VTABLE_STRING "__vtbl__" /* Lucid/ARM virtual table prefix */ ! 206: #define ARM_VTABLE_STRLEN 8 /* strlen (ARM_VTABLE_STRING) */ ! 207: ! 208: /* Prototypes for local functions */ ! 209: ! 210: static char * ! 211: mop_up PARAMS ((struct work_stuff *, string *, int)); ! 212: ! 213: #if 0 ! 214: static int ! 215: demangle_method_args PARAMS ((struct work_stuff *work, const char **, string *)); ! 216: #endif ! 217: ! 218: static int ! 219: demangle_template PARAMS ((struct work_stuff *work, const char **, string *, ! 220: string *)); ! 221: ! 222: static int ! 223: demangle_qualified PARAMS ((struct work_stuff *, const char **, string *, ! 224: int, int)); ! 225: ! 226: static int ! 227: demangle_class PARAMS ((struct work_stuff *, const char **, string *)); ! 228: ! 229: static int ! 230: demangle_fund_type PARAMS ((struct work_stuff *, const char **, string *)); ! 231: ! 232: static int ! 233: demangle_signature PARAMS ((struct work_stuff *, const char **, string *)); ! 234: ! 235: static int ! 236: demangle_prefix PARAMS ((struct work_stuff *, const char **, string *)); ! 237: ! 238: static int ! 239: gnu_special PARAMS ((struct work_stuff *, const char **, string *)); ! 240: ! 241: static int ! 242: arm_special PARAMS ((struct work_stuff *, const char **, string *)); ! 243: ! 244: static void ! 245: string_need PARAMS ((string *, int)); ! 246: ! 247: static void ! 248: string_delete PARAMS ((string *)); ! 249: ! 250: static void ! 251: string_init PARAMS ((string *)); ! 252: ! 253: static void ! 254: string_clear PARAMS ((string *)); ! 255: ! 256: #if 0 ! 257: static int ! 258: string_empty PARAMS ((string *)); ! 259: #endif ! 260: ! 261: static void ! 262: string_append PARAMS ((string *, const char *)); ! 263: ! 264: static void ! 265: string_appends PARAMS ((string *, string *)); ! 266: ! 267: static void ! 268: string_appendn PARAMS ((string *, const char *, int)); ! 269: ! 270: static void ! 271: string_prepend PARAMS ((string *, const char *)); ! 272: ! 273: static void ! 274: string_prependn PARAMS ((string *, const char *, int)); ! 275: ! 276: static int ! 277: get_count PARAMS ((const char **, int *)); ! 278: ! 279: static int ! 280: consume_count PARAMS ((const char **)); ! 281: ! 282: static int ! 283: demangle_args PARAMS ((struct work_stuff *, const char **, string *)); ! 284: ! 285: static int ! 286: do_type PARAMS ((struct work_stuff *, const char **, string *)); ! 287: ! 288: static int ! 289: do_arg PARAMS ((struct work_stuff *, const char **, string *)); ! 290: ! 291: static void ! 292: demangle_function_name PARAMS ((struct work_stuff *, const char **, string *, ! 293: const char *)); ! 294: ! 295: static void ! 296: remember_type PARAMS ((struct work_stuff *, const char *, int)); ! 297: ! 298: static void ! 299: forget_types PARAMS ((struct work_stuff *)); ! 300: ! 301: static void ! 302: string_prepends PARAMS ((string *, string *)); ! 303: ! 304: /* Translate count to integer, consuming tokens in the process. ! 305: Conversion terminates on the first non-digit character. ! 306: Trying to consume something that isn't a count results in ! 307: no consumption of input and a return of 0. */ ! 308: ! 309: static int ! 310: consume_count (type) ! 311: const char **type; ! 312: { ! 313: int count = 0; ! 314: ! 315: while (isdigit (**type)) ! 316: { ! 317: count *= 10; ! 318: count += **type - '0'; ! 319: (*type)++; ! 320: } ! 321: return (count); ! 322: } ! 323: ! 324: int ! 325: cplus_demangle_opname (opname, result, options) ! 326: char *opname; ! 327: char *result; ! 328: int options; ! 329: { ! 330: int len, i, len1, ret; ! 331: string type; ! 332: struct work_stuff work[1]; ! 333: const char *tem; ! 334: ! 335: len = strlen(opname); ! 336: result[0] = '\0'; ! 337: ret = 0; ! 338: work->options = options; ! 339: ! 340: if (opname[0] == '_' && opname[1] == '_' ! 341: && opname[2] == 'o' && opname[3] == 'p') ! 342: { ! 343: /* ANSI. */ ! 344: /* type conversion operator. */ ! 345: tem = opname + 4; ! 346: if (do_type (work, &tem, &type)) ! 347: { ! 348: strcat (result, "operator "); ! 349: strncat (result, type.b, type.p - type.b); ! 350: string_delete (&type); ! 351: ret = 1; ! 352: } ! 353: } ! 354: else if (opname[0] == '_' && opname[1] == '_' ! 355: && opname[2] >= 'a' && opname[2] <= 'z' ! 356: && opname[3] >= 'a' && opname[3] <= 'z') ! 357: { ! 358: if (opname[4] == '\0') ! 359: { ! 360: /* Operator. */ ! 361: for (i = 0; i < sizeof (optable) / sizeof (optable[0]); i++) ! 362: { ! 363: if (strlen (optable[i].in) == 2 ! 364: && memcmp (optable[i].in, opname + 2, 2) == 0) ! 365: { ! 366: strcat (result, "operator"); ! 367: strcat (result, optable[i].out); ! 368: ret = 1; ! 369: break; ! 370: } ! 371: } ! 372: } ! 373: else ! 374: { ! 375: if (opname[2] == 'a' && opname[5] == '\0') ! 376: { ! 377: /* Assignment. */ ! 378: for (i = 0; i < sizeof (optable) / sizeof (optable[0]); i++) ! 379: { ! 380: if (strlen (optable[i].in) == 3 ! 381: && memcmp (optable[i].in, opname + 2, 3) == 0) ! 382: { ! 383: strcat (result, "operator"); ! 384: strcat (result, optable[i].out); ! 385: ret = 1; ! 386: break; ! 387: } ! 388: } ! 389: } ! 390: } ! 391: } ! 392: else if (len >= 3 ! 393: && opname[0] == 'o' ! 394: && opname[1] == 'p' ! 395: && strchr (cplus_markers, opname[2]) != NULL) ! 396: { ! 397: /* see if it's an assignment expression */ ! 398: if (len >= 10 /* op$assign_ */ ! 399: && memcmp (opname + 3, "assign_", 7) == 0) ! 400: { ! 401: for (i = 0; i < sizeof (optable) / sizeof (optable[0]); i++) ! 402: { ! 403: len1 = len - 10; ! 404: if (strlen (optable[i].in) == len1 ! 405: && memcmp (optable[i].in, opname + 10, len1) == 0) ! 406: { ! 407: strcat (result, "operator"); ! 408: strcat (result, optable[i].out); ! 409: strcat (result, "="); ! 410: ret = 1; ! 411: break; ! 412: } ! 413: } ! 414: } ! 415: else ! 416: { ! 417: for (i = 0; i < sizeof (optable) / sizeof (optable[0]); i++) ! 418: { ! 419: len1 = len - 3; ! 420: if (strlen (optable[i].in) == len1 ! 421: && memcmp (optable[i].in, opname + 3, len1) == 0) ! 422: { ! 423: strcat (result, "operator"); ! 424: strcat (result, optable[i].out); ! 425: ret = 1; ! 426: break; ! 427: } ! 428: } ! 429: } ! 430: } ! 431: else if (len >= 5 && memcmp (opname, "type", 4) == 0 ! 432: && strchr (cplus_markers, opname[4]) != NULL) ! 433: { ! 434: /* type conversion operator */ ! 435: tem = opname + 5; ! 436: if (do_type (work, &tem, &type)) ! 437: { ! 438: strcat (result, "operator "); ! 439: strncat (result, type.b, type.p - type.b); ! 440: string_delete (&type); ! 441: ret = 1; ! 442: } ! 443: } ! 444: return ret; ! 445: ! 446: } ! 447: /* Takes operator name as e.g. "++" and returns mangled ! 448: operator name (e.g. "postincrement_expr"), or NULL if not found. ! 449: ! 450: If OPTIONS & DMGL_ANSI == 1, return the ANSI name; ! 451: if OPTIONS & DMGL_ANSI == 0, return the old GNU name. */ ! 452: ! 453: char * ! 454: cplus_mangle_opname (opname, options) ! 455: char *opname; ! 456: int options; ! 457: { ! 458: int i; ! 459: int len; ! 460: ! 461: len = strlen (opname); ! 462: for (i = 0; i < sizeof (optable) / sizeof (optable[0]); i++) ! 463: { ! 464: if (strlen (optable[i].out) == len ! 465: && (options & DMGL_ANSI) == (optable[i].flags & DMGL_ANSI) ! 466: && memcmp (optable[i].out, opname, len) == 0) ! 467: return ((char *)optable[i].in); ! 468: } ! 469: return (0); ! 470: } ! 471: ! 472: /* check to see whether MANGLED can match TEXT in the first TEXT_LEN ! 473: characters. */ ! 474: ! 475: int cplus_match (mangled, text, text_len) ! 476: const char *mangled; ! 477: char *text; ! 478: int text_len; ! 479: { ! 480: if (strncmp (mangled, text, text_len) != 0) { ! 481: return(0); /* cannot match either */ ! 482: } else { ! 483: return(1); /* matches mangled, may match demangled */ ! 484: } ! 485: } ! 486: ! 487: /* char *cplus_demangle (const char *mangled, int options) ! 488: ! 489: If MANGLED is a mangled function name produced by GNU C++, then ! 490: a pointer to a malloced string giving a C++ representation ! 491: of the name will be returned; otherwise NULL will be returned. ! 492: It is the caller's responsibility to free the string which ! 493: is returned. ! 494: ! 495: The OPTIONS arg may contain one or more of the following bits: ! 496: ! 497: DMGL_ANSI ANSI qualifiers such as `const' and `void' are ! 498: included. ! 499: DMGL_PARAMS Function parameters are included. ! 500: ! 501: For example, ! 502: ! 503: cplus_demangle ("foo__1Ai", DMGL_PARAMS) => "A::foo(int)" ! 504: cplus_demangle ("foo__1Ai", DMGL_PARAMS | DMGL_ANSI) => "A::foo(int)" ! 505: cplus_demangle ("foo__1Ai", 0) => "A::foo" ! 506: ! 507: cplus_demangle ("foo__1Afe", DMGL_PARAMS) => "A::foo(float,...)" ! 508: cplus_demangle ("foo__1Afe", DMGL_PARAMS | DMGL_ANSI)=> "A::foo(float,...)" ! 509: cplus_demangle ("foo__1Afe", 0) => "A::foo" ! 510: ! 511: Note that any leading underscores, or other such characters prepended by ! 512: the compilation system, are presumed to have already been stripped from ! 513: MANGLED. */ ! 514: ! 515: char * ! 516: cplus_demangle (mangled, options) ! 517: const char *mangled; ! 518: int options; ! 519: { ! 520: string decl; ! 521: int success = 0; ! 522: struct work_stuff work[1]; ! 523: char *demangled = NULL; ! 524: ! 525: if ((mangled != NULL) && (*mangled != '\0')) ! 526: { ! 527: memset ((char *) work, 0, sizeof (work)); ! 528: work -> options = options; ! 529: if ((work->options & DMGL_STYLE_MASK) == 0) ! 530: work->options |= (int)current_demangling_style & DMGL_STYLE_MASK; ! 531: ! 532: string_init (&decl); ! 533: ! 534: /* First check to see if gnu style demangling is active and if the ! 535: string to be demangled contains a CPLUS_MARKER. If so, attempt to ! 536: recognize one of the gnu special forms rather than looking for a ! 537: standard prefix. In particular, don't worry about whether there ! 538: is a "__" string in the mangled string. Consider "_$_5__foo" for ! 539: example. */ ! 540: ! 541: if ((AUTO_DEMANGLING || GNU_DEMANGLING)) ! 542: { ! 543: success = gnu_special (work, &mangled, &decl); ! 544: } ! 545: if (!success) ! 546: { ! 547: success = demangle_prefix (work, &mangled, &decl); ! 548: } ! 549: if (success && (*mangled != '\0')) ! 550: { ! 551: success = demangle_signature (work, &mangled, &decl); ! 552: } ! 553: if (work->constructor == 2) ! 554: { ! 555: string_prepend(&decl, "global constructors keyed to "); ! 556: work->constructor = 0; ! 557: } ! 558: else if (work->destructor == 2) ! 559: { ! 560: string_prepend(&decl, "global destructors keyed to "); ! 561: work->destructor = 0; ! 562: } ! 563: demangled = mop_up (work, &decl, success); ! 564: } ! 565: return (demangled); ! 566: } ! 567: ! 568: static char * ! 569: mop_up (work, declp, success) ! 570: struct work_stuff *work; ! 571: string *declp; ! 572: int success; ! 573: { ! 574: char *demangled = NULL; ! 575: ! 576: /* Discard the remembered types, if any. */ ! 577: ! 578: forget_types (work); ! 579: if (work -> typevec != NULL) ! 580: { ! 581: free ((char *) work -> typevec); ! 582: } ! 583: ! 584: /* If demangling was successful, ensure that the demangled string is null ! 585: terminated and return it. Otherwise, free the demangling decl. */ ! 586: ! 587: if (!success) ! 588: { ! 589: string_delete (declp); ! 590: } ! 591: else ! 592: { ! 593: string_appendn (declp, "", 1); ! 594: demangled = declp -> b; ! 595: } ! 596: return (demangled); ! 597: } ! 598: ! 599: /* ! 600: ! 601: LOCAL FUNCTION ! 602: ! 603: demangle_signature -- demangle the signature part of a mangled name ! 604: ! 605: SYNOPSIS ! 606: ! 607: static int ! 608: demangle_signature (struct work_stuff *work, const char **mangled, ! 609: string *declp); ! 610: ! 611: DESCRIPTION ! 612: ! 613: Consume and demangle the signature portion of the mangled name. ! 614: ! 615: DECLP is the string where demangled output is being built. At ! 616: entry it contains the demangled root name from the mangled name ! 617: prefix. I.E. either a demangled operator name or the root function ! 618: name. In some special cases, it may contain nothing. ! 619: ! 620: *MANGLED points to the current unconsumed location in the mangled ! 621: name. As tokens are consumed and demangling is performed, the ! 622: pointer is updated to continuously point at the next token to ! 623: be consumed. ! 624: ! 625: Demangling GNU style mangled names is nasty because there is no ! 626: explicit token that marks the start of the outermost function ! 627: argument list. ! 628: */ ! 629: ! 630: static int ! 631: demangle_signature (work, mangled, declp) ! 632: struct work_stuff *work; ! 633: const char **mangled; ! 634: string *declp; ! 635: { ! 636: int success = 1; ! 637: int func_done = 0; ! 638: int expect_func = 0; ! 639: const char *oldmangled = NULL; ! 640: string trawname; ! 641: string tname; ! 642: ! 643: while (success && (**mangled != '\0')) ! 644: { ! 645: switch (**mangled) ! 646: { ! 647: case 'Q': ! 648: oldmangled = *mangled; ! 649: success = demangle_qualified (work, mangled, declp, 1, 0); ! 650: if (success) ! 651: { ! 652: remember_type (work, oldmangled, *mangled - oldmangled); ! 653: } ! 654: if (AUTO_DEMANGLING || GNU_DEMANGLING) ! 655: { ! 656: expect_func = 1; ! 657: } ! 658: oldmangled = NULL; ! 659: break; ! 660: ! 661: case 'S': ! 662: /* Static member function */ ! 663: if (oldmangled == NULL) ! 664: { ! 665: oldmangled = *mangled; ! 666: } ! 667: (*mangled)++; ! 668: work -> static_type = 1; ! 669: break; ! 670: ! 671: case 'C': ! 672: /* a const member function */ ! 673: if (oldmangled == NULL) ! 674: { ! 675: oldmangled = *mangled; ! 676: } ! 677: (*mangled)++; ! 678: work -> const_type = 1; ! 679: break; ! 680: ! 681: case '0': case '1': case '2': case '3': case '4': ! 682: case '5': case '6': case '7': case '8': case '9': ! 683: if (oldmangled == NULL) ! 684: { ! 685: oldmangled = *mangled; ! 686: } ! 687: success = demangle_class (work, mangled, declp); ! 688: if (success) ! 689: { ! 690: remember_type (work, oldmangled, *mangled - oldmangled); ! 691: } ! 692: if (AUTO_DEMANGLING || GNU_DEMANGLING) ! 693: { ! 694: expect_func = 1; ! 695: } ! 696: oldmangled = NULL; ! 697: break; ! 698: ! 699: case 'F': ! 700: /* Function */ ! 701: /* ARM style demangling includes a specific 'F' character after ! 702: the class name. For GNU style, it is just implied. So we can ! 703: safely just consume any 'F' at this point and be compatible ! 704: with either style. */ ! 705: ! 706: oldmangled = NULL; ! 707: func_done = 1; ! 708: (*mangled)++; ! 709: ! 710: /* For lucid/ARM style we have to forget any types we might ! 711: have remembered up to this point, since they were not argument ! 712: types. GNU style considers all types seen as available for ! 713: back references. See comment in demangle_args() */ ! 714: ! 715: if (LUCID_DEMANGLING || ARM_DEMANGLING) ! 716: { ! 717: forget_types (work); ! 718: } ! 719: success = demangle_args (work, mangled, declp); ! 720: break; ! 721: ! 722: case 't': ! 723: /* G++ Template */ ! 724: string_init(&trawname); ! 725: string_init(&tname); ! 726: if (oldmangled == NULL) ! 727: { ! 728: oldmangled = *mangled; ! 729: } ! 730: success = demangle_template (work, mangled, &tname, &trawname); ! 731: if (success) ! 732: { ! 733: remember_type (work, oldmangled, *mangled - oldmangled); ! 734: } ! 735: string_append(&tname, "::"); ! 736: string_prepends(declp, &tname); ! 737: if (work -> destructor & 1) ! 738: { ! 739: string_prepend (&trawname, "~"); ! 740: string_appends (declp, &trawname); ! 741: work->destructor -= 1; ! 742: } ! 743: if ((work->constructor & 1) || (work->destructor & 1)) ! 744: { ! 745: string_appends (declp, &trawname); ! 746: work->constructor -= 1; ! 747: } ! 748: string_delete(&trawname); ! 749: string_delete(&tname); ! 750: oldmangled = NULL; ! 751: expect_func = 1; ! 752: break; ! 753: ! 754: case '_': ! 755: /* At the outermost level, we cannot have a return type specified, ! 756: so if we run into another '_' at this point we are dealing with ! 757: a mangled name that is either bogus, or has been mangled by ! 758: some algorithm we don't know how to deal with. So just ! 759: reject the entire demangling. */ ! 760: success = 0; ! 761: break; ! 762: ! 763: default: ! 764: if (AUTO_DEMANGLING || GNU_DEMANGLING) ! 765: { ! 766: /* Assume we have stumbled onto the first outermost function ! 767: argument token, and start processing args. */ ! 768: func_done = 1; ! 769: success = demangle_args (work, mangled, declp); ! 770: } ! 771: else ! 772: { ! 773: /* Non-GNU demanglers use a specific token to mark the start ! 774: of the outermost function argument tokens. Typically 'F', ! 775: for ARM-demangling, for example. So if we find something ! 776: we are not prepared for, it must be an error. */ ! 777: success = 0; ! 778: } ! 779: break; ! 780: } ! 781: /* ! 782: if (AUTO_DEMANGLING || GNU_DEMANGLING) ! 783: */ ! 784: { ! 785: if (success && expect_func) ! 786: { ! 787: func_done = 1; ! 788: success = demangle_args (work, mangled, declp); ! 789: } ! 790: } ! 791: } ! 792: if (success && !func_done) ! 793: { ! 794: if (AUTO_DEMANGLING || GNU_DEMANGLING) ! 795: { ! 796: /* With GNU style demangling, bar__3foo is 'foo::bar(void)', and ! 797: bar__3fooi is 'foo::bar(int)'. We get here when we find the ! 798: first case, and need to ensure that the '(void)' gets added to ! 799: the current declp. Note that with ARM, the first case ! 800: represents the name of a static data member 'foo::bar', ! 801: which is in the current declp, so we leave it alone. */ ! 802: success = demangle_args (work, mangled, declp); ! 803: } ! 804: } ! 805: if (success && work -> static_type && PRINT_ARG_TYPES) ! 806: { ! 807: string_append (declp, " static"); ! 808: } ! 809: if (success && work -> const_type && PRINT_ARG_TYPES) ! 810: { ! 811: string_append (declp, " const"); ! 812: } ! 813: return (success); ! 814: } ! 815: ! 816: #if 0 ! 817: ! 818: static int ! 819: demangle_method_args (work, mangled, declp) ! 820: struct work_stuff *work; ! 821: const char **mangled; ! 822: string *declp; ! 823: { ! 824: int success = 0; ! 825: ! 826: if (work -> static_type) ! 827: { ! 828: string_append (declp, *mangled + 1); ! 829: *mangled += strlen (*mangled); ! 830: success = 1; ! 831: } ! 832: else ! 833: { ! 834: success = demangle_args (work, mangled, declp); ! 835: } ! 836: return (success); ! 837: } ! 838: ! 839: #endif ! 840: ! 841: static int ! 842: demangle_template (work, mangled, tname, trawname) ! 843: struct work_stuff *work; ! 844: const char **mangled; ! 845: string *tname; ! 846: string *trawname; ! 847: { ! 848: int i; ! 849: int is_pointer; ! 850: int is_real; ! 851: int is_integral; ! 852: int is_char; ! 853: int is_bool; ! 854: int r; ! 855: int need_comma = 0; ! 856: int success = 0; ! 857: int done; ! 858: const char *old_p; ! 859: const char *start; ! 860: int symbol_len; ! 861: string temp; ! 862: ! 863: (*mangled)++; ! 864: start = *mangled; ! 865: /* get template name */ ! 866: if ((r = consume_count (mangled)) == 0 || strlen (*mangled) < r) ! 867: { ! 868: return (0); ! 869: } ! 870: if (trawname) ! 871: string_appendn (trawname, *mangled, r); ! 872: string_appendn (tname, *mangled, r); ! 873: *mangled += r; ! 874: string_append (tname, "<"); ! 875: /* get size of template parameter list */ ! 876: if (!get_count (mangled, &r)) ! 877: { ! 878: return (0); ! 879: } ! 880: for (i = 0; i < r; i++) ! 881: { ! 882: if (need_comma) ! 883: { ! 884: string_append (tname, ", "); ! 885: } ! 886: /* Z for type parameters */ ! 887: if (**mangled == 'Z') ! 888: { ! 889: (*mangled)++; ! 890: /* temp is initialized in do_type */ ! 891: success = do_type (work, mangled, &temp); ! 892: if (success) ! 893: { ! 894: string_appends (tname, &temp); ! 895: } ! 896: string_delete(&temp); ! 897: if (!success) ! 898: { ! 899: break; ! 900: } ! 901: } ! 902: else ! 903: { ! 904: /* otherwise, value parameter */ ! 905: old_p = *mangled; ! 906: is_pointer = 0; ! 907: is_real = 0; ! 908: is_integral = 0; ! 909: is_char = 0; ! 910: done = 0; ! 911: /* temp is initialized in do_type */ ! 912: success = do_type (work, mangled, &temp); ! 913: /* ! 914: if (success) ! 915: { ! 916: string_appends (tname, &temp); ! 917: } ! 918: */ ! 919: string_delete(&temp); ! 920: if (!success) ! 921: { ! 922: break; ! 923: } ! 924: /* ! 925: string_append (tname, "="); ! 926: */ ! 927: while (*old_p && !done) ! 928: { ! 929: switch (*old_p) ! 930: { ! 931: case 'P': ! 932: case 'p': ! 933: case 'R': ! 934: done = is_pointer = 1; ! 935: break; ! 936: case 'C': /* const */ ! 937: case 'S': /* explicitly signed [char] */ ! 938: case 'U': /* unsigned */ ! 939: case 'V': /* volatile */ ! 940: case 'F': /* function */ ! 941: case 'M': /* member function */ ! 942: case 'O': /* ??? */ ! 943: old_p++; ! 944: continue; ! 945: case 'Q': /* qualified name */ ! 946: done = is_integral = 1; ! 947: break; ! 948: case 'T': /* remembered type */ ! 949: abort (); ! 950: break; ! 951: case 'v': /* void */ ! 952: abort (); ! 953: break; ! 954: case 'x': /* long long */ ! 955: case 'l': /* long */ ! 956: case 'i': /* int */ ! 957: case 's': /* short */ ! 958: case 'w': /* wchar_t */ ! 959: done = is_integral = 1; ! 960: break; ! 961: case 'b': /* bool */ ! 962: done = is_bool = 1; ! 963: break; ! 964: case 'c': /* char */ ! 965: done = is_char = 1; ! 966: break; ! 967: case 'r': /* long double */ ! 968: case 'd': /* double */ ! 969: case 'f': /* float */ ! 970: done = is_real = 1; ! 971: break; ! 972: default: ! 973: /* it's probably user defined type, let's assume ! 974: it's integral, it seems hard to figure out ! 975: what it really is */ ! 976: done = is_integral = 1; ! 977: } ! 978: } ! 979: if (is_integral) ! 980: { ! 981: if (**mangled == 'm') ! 982: { ! 983: string_appendn (tname, "-", 1); ! 984: (*mangled)++; ! 985: } ! 986: while (isdigit (**mangled)) ! 987: { ! 988: string_appendn (tname, *mangled, 1); ! 989: (*mangled)++; ! 990: } ! 991: } ! 992: else if (is_char) ! 993: { ! 994: char tmp[2]; ! 995: int val; ! 996: if (**mangled == 'm') ! 997: { ! 998: string_appendn (tname, "-", 1); ! 999: (*mangled)++; ! 1000: } ! 1001: string_appendn (tname, "'", 1); ! 1002: val = consume_count(mangled); ! 1003: if (val == 0) ! 1004: { ! 1005: success = 0; ! 1006: break; ! 1007: } ! 1008: tmp[0] = (char)val; ! 1009: tmp[1] = '\0'; ! 1010: string_appendn (tname, &tmp[0], 1); ! 1011: string_appendn (tname, "'", 1); ! 1012: } ! 1013: else if (is_bool) ! 1014: { ! 1015: int val = consume_count (mangled); ! 1016: if (val == 0) ! 1017: string_appendn (tname, "false", 5); ! 1018: else if (val == 1) ! 1019: string_appendn (tname, "true", 4); ! 1020: else ! 1021: success = 0; ! 1022: } ! 1023: else if (is_real) ! 1024: { ! 1025: if (**mangled == 'm') ! 1026: { ! 1027: string_appendn (tname, "-", 1); ! 1028: (*mangled)++; ! 1029: } ! 1030: while (isdigit (**mangled)) ! 1031: { ! 1032: string_appendn (tname, *mangled, 1); ! 1033: (*mangled)++; ! 1034: } ! 1035: if (**mangled == '.') /* fraction */ ! 1036: { ! 1037: string_appendn (tname, ".", 1); ! 1038: (*mangled)++; ! 1039: while (isdigit (**mangled)) ! 1040: { ! 1041: string_appendn (tname, *mangled, 1); ! 1042: (*mangled)++; ! 1043: } ! 1044: } ! 1045: if (**mangled == 'e') /* exponent */ ! 1046: { ! 1047: string_appendn (tname, "e", 1); ! 1048: (*mangled)++; ! 1049: while (isdigit (**mangled)) ! 1050: { ! 1051: string_appendn (tname, *mangled, 1); ! 1052: (*mangled)++; ! 1053: } ! 1054: } ! 1055: } ! 1056: else if (is_pointer) ! 1057: { ! 1058: if (!get_count (mangled, &symbol_len)) ! 1059: { ! 1060: success = 0; ! 1061: break; ! 1062: } ! 1063: string_appendn (tname, *mangled, symbol_len); ! 1064: *mangled += symbol_len; ! 1065: } ! 1066: } ! 1067: need_comma = 1; ! 1068: } ! 1069: if (tname->p[-1] == '>') ! 1070: string_append (tname, " "); ! 1071: string_append (tname, ">"); ! 1072: ! 1073: /* ! 1074: if (work -> static_type) ! 1075: { ! 1076: string_append (declp, *mangled + 1); ! 1077: *mangled += strlen (*mangled); ! 1078: success = 1; ! 1079: } ! 1080: else ! 1081: { ! 1082: success = demangle_args (work, mangled, declp); ! 1083: } ! 1084: } ! 1085: */ ! 1086: return (success); ! 1087: } ! 1088: ! 1089: static int ! 1090: arm_pt (work, mangled, n, anchor, args) ! 1091: struct work_stuff *work; ! 1092: const char *mangled; ! 1093: int n; ! 1094: const char **anchor, **args; ! 1095: { ! 1096: /* ARM template? */ ! 1097: if (ARM_DEMANGLING && (*anchor = mystrstr (mangled, "__pt__"))) ! 1098: { ! 1099: int len; ! 1100: *args = *anchor + 6; ! 1101: len = consume_count (args); ! 1102: if (*args + len == mangled + n && **args == '_') ! 1103: { ! 1104: ++*args; ! 1105: return 1; ! 1106: } ! 1107: } ! 1108: return 0; ! 1109: } ! 1110: ! 1111: static void ! 1112: demangle_arm_pt (work, mangled, n, declp) ! 1113: struct work_stuff *work; ! 1114: const char **mangled; ! 1115: int n; ! 1116: string *declp; ! 1117: { ! 1118: const char *p; ! 1119: const char *args; ! 1120: const char *e = *mangled + n; ! 1121: ! 1122: /* ARM template? */ ! 1123: if (arm_pt (work, *mangled, n, &p, &args)) ! 1124: { ! 1125: string arg; ! 1126: string_init (&arg); ! 1127: string_appendn (declp, *mangled, p - *mangled); ! 1128: string_append (declp, "<"); ! 1129: /* should do error checking here */ ! 1130: while (args < e) { ! 1131: string_clear (&arg); ! 1132: do_type (work, &args, &arg); ! 1133: string_appends (declp, &arg); ! 1134: string_append (declp, ","); ! 1135: } ! 1136: string_delete (&arg); ! 1137: --declp->p; ! 1138: string_append (declp, ">"); ! 1139: } ! 1140: else ! 1141: { ! 1142: string_appendn (declp, *mangled, n); ! 1143: } ! 1144: *mangled += n; ! 1145: } ! 1146: ! 1147: static int ! 1148: demangle_class_name (work, mangled, declp) ! 1149: struct work_stuff *work; ! 1150: const char **mangled; ! 1151: string *declp; ! 1152: { ! 1153: int n; ! 1154: int success = 0; ! 1155: ! 1156: n = consume_count (mangled); ! 1157: if (strlen (*mangled) >= n) ! 1158: { ! 1159: demangle_arm_pt (work, mangled, n, declp); ! 1160: success = 1; ! 1161: } ! 1162: ! 1163: return (success); ! 1164: } ! 1165: ! 1166: /* ! 1167: ! 1168: LOCAL FUNCTION ! 1169: ! 1170: demangle_class -- demangle a mangled class sequence ! 1171: ! 1172: SYNOPSIS ! 1173: ! 1174: static int ! 1175: demangle_class (struct work_stuff *work, const char **mangled, ! 1176: strint *declp) ! 1177: ! 1178: DESCRIPTION ! 1179: ! 1180: DECLP points to the buffer into which demangling is being done. ! 1181: ! 1182: *MANGLED points to the current token to be demangled. On input, ! 1183: it points to a mangled class (I.E. "3foo", "13verylongclass", etc.) ! 1184: On exit, it points to the next token after the mangled class on ! 1185: success, or the first unconsumed token on failure. ! 1186: ! 1187: If the CONSTRUCTOR or DESTRUCTOR flags are set in WORK, then ! 1188: we are demangling a constructor or destructor. In this case ! 1189: we prepend "class::class" or "class::~class" to DECLP. ! 1190: ! 1191: Otherwise, we prepend "class::" to the current DECLP. ! 1192: ! 1193: Reset the constructor/destructor flags once they have been ! 1194: "consumed". This allows demangle_class to be called later during ! 1195: the same demangling, to do normal class demangling. ! 1196: ! 1197: Returns 1 if demangling is successful, 0 otherwise. ! 1198: ! 1199: */ ! 1200: ! 1201: static int ! 1202: demangle_class (work, mangled, declp) ! 1203: struct work_stuff *work; ! 1204: const char **mangled; ! 1205: string *declp; ! 1206: { ! 1207: int success = 0; ! 1208: string class_name; ! 1209: ! 1210: string_init (&class_name); ! 1211: if (demangle_class_name (work, mangled, &class_name)) ! 1212: { ! 1213: if ((work->constructor & 1) || (work->destructor & 1)) ! 1214: { ! 1215: string_prepends (declp, &class_name); ! 1216: if (work -> destructor & 1) ! 1217: { ! 1218: string_prepend (declp, "~"); ! 1219: work -> destructor -= 1; ! 1220: } ! 1221: else ! 1222: { ! 1223: work -> constructor -= 1; ! 1224: } ! 1225: } ! 1226: string_prepend (declp, "::"); ! 1227: string_prepends (declp, &class_name); ! 1228: success = 1; ! 1229: } ! 1230: string_delete (&class_name); ! 1231: return (success); ! 1232: } ! 1233: ! 1234: /* ! 1235: ! 1236: LOCAL FUNCTION ! 1237: ! 1238: demangle_prefix -- consume the mangled name prefix and find signature ! 1239: ! 1240: SYNOPSIS ! 1241: ! 1242: static int ! 1243: demangle_prefix (struct work_stuff *work, const char **mangled, ! 1244: string *declp); ! 1245: ! 1246: DESCRIPTION ! 1247: ! 1248: Consume and demangle the prefix of the mangled name. ! 1249: ! 1250: DECLP points to the string buffer into which demangled output is ! 1251: placed. On entry, the buffer is empty. On exit it contains ! 1252: the root function name, the demangled operator name, or in some ! 1253: special cases either nothing or the completely demangled result. ! 1254: ! 1255: MANGLED points to the current pointer into the mangled name. As each ! 1256: token of the mangled name is consumed, it is updated. Upon entry ! 1257: the current mangled name pointer points to the first character of ! 1258: the mangled name. Upon exit, it should point to the first character ! 1259: of the signature if demangling was successful, or to the first ! 1260: unconsumed character if demangling of the prefix was unsuccessful. ! 1261: ! 1262: Returns 1 on success, 0 otherwise. ! 1263: */ ! 1264: ! 1265: static int ! 1266: demangle_prefix (work, mangled, declp) ! 1267: struct work_stuff *work; ! 1268: const char **mangled; ! 1269: string *declp; ! 1270: { ! 1271: int success = 1; ! 1272: const char *scan; ! 1273: int i; ! 1274: ! 1275: if (strlen(*mangled) >= 11 && strncmp(*mangled, "_GLOBAL_", 8) == 0) ! 1276: { ! 1277: char *marker = strchr (cplus_markers, (*mangled)[8]); ! 1278: if (marker != NULL && *marker == (*mangled)[10]) ! 1279: { ! 1280: if ((*mangled)[9] == 'D') ! 1281: { ! 1282: /* it's a GNU global destructor to be executed at program exit */ ! 1283: (*mangled) += 11; ! 1284: work->destructor = 2; ! 1285: if (gnu_special (work, mangled, declp)) ! 1286: return success; ! 1287: } ! 1288: else if ((*mangled)[9] == 'I') ! 1289: { ! 1290: /* it's a GNU global constructor to be executed at program init */ ! 1291: (*mangled) += 11; ! 1292: work->constructor = 2; ! 1293: if (gnu_special (work, mangled, declp)) ! 1294: return success; ! 1295: } ! 1296: } ! 1297: } ! 1298: else if (ARM_DEMANGLING && strncmp(*mangled, "__std__", 7) == 0) ! 1299: { ! 1300: /* it's a ARM global destructor to be executed at program exit */ ! 1301: (*mangled) += 7; ! 1302: work->destructor = 2; ! 1303: } ! 1304: else if (ARM_DEMANGLING && strncmp(*mangled, "__sti__", 7) == 0) ! 1305: { ! 1306: /* it's a ARM global constructor to be executed at program initial */ ! 1307: (*mangled) += 7; ! 1308: work->constructor = 2; ! 1309: } ! 1310: ! 1311: /* This block of code is a reduction in strength time optimization ! 1312: of: ! 1313: scan = mystrstr (*mangled, "__"); */ ! 1314: ! 1315: { ! 1316: scan = *mangled; ! 1317: ! 1318: do { ! 1319: scan = strchr (scan, '_'); ! 1320: } while (scan != NULL && *++scan != '_'); ! 1321: ! 1322: if (scan != NULL) --scan; ! 1323: } ! 1324: ! 1325: if (scan != NULL) ! 1326: { ! 1327: /* We found a sequence of two or more '_', ensure that we start at ! 1328: the last pair in the sequence. */ ! 1329: i = strspn (scan, "_"); ! 1330: if (i > 2) ! 1331: { ! 1332: scan += (i - 2); ! 1333: } ! 1334: } ! 1335: ! 1336: if (scan == NULL) ! 1337: { ! 1338: success = 0; ! 1339: } ! 1340: else if (work -> static_type) ! 1341: { ! 1342: if (!isdigit (scan[0]) && (scan[0] != 't')) ! 1343: { ! 1344: success = 0; ! 1345: } ! 1346: } ! 1347: else if ((scan == *mangled) && ! 1348: (isdigit (scan[2]) || (scan[2] == 'Q') || (scan[2] == 't'))) ! 1349: { ! 1350: /* The ARM says nothing about the mangling of local variables. ! 1351: But cfront mangles local variables by prepending __<nesting_level> ! 1352: to them. As an extension to ARM demangling we handle this case. */ ! 1353: if ((LUCID_DEMANGLING || ARM_DEMANGLING) && isdigit (scan[2])) ! 1354: { ! 1355: *mangled = scan + 2; ! 1356: consume_count (mangled); ! 1357: string_append (declp, *mangled); ! 1358: *mangled += strlen (*mangled); ! 1359: success = 1; ! 1360: } ! 1361: else ! 1362: { ! 1363: /* A GNU style constructor starts with __[0-9Qt]. But cfront uses ! 1364: names like __Q2_3foo3bar for nested type names. So don't accept ! 1365: this style of constructor for cfront demangling. */ ! 1366: if (!(LUCID_DEMANGLING || ARM_DEMANGLING)) ! 1367: work -> constructor += 1; ! 1368: *mangled = scan + 2; ! 1369: } ! 1370: } ! 1371: else if ((scan == *mangled) && !isdigit (scan[2]) && (scan[2] != 't')) ! 1372: { ! 1373: /* Mangled name starts with "__". Skip over any leading '_' characters, ! 1374: then find the next "__" that separates the prefix from the signature. ! 1375: */ ! 1376: if (!(ARM_DEMANGLING || LUCID_DEMANGLING) ! 1377: || (arm_special (work, mangled, declp) == 0)) ! 1378: { ! 1379: while (*scan == '_') ! 1380: { ! 1381: scan++; ! 1382: } ! 1383: if ((scan = mystrstr (scan, "__")) == NULL || (*(scan + 2) == '\0')) ! 1384: { ! 1385: /* No separator (I.E. "__not_mangled"), or empty signature ! 1386: (I.E. "__not_mangled_either__") */ ! 1387: success = 0; ! 1388: } ! 1389: else ! 1390: { ! 1391: demangle_function_name (work, mangled, declp, scan); ! 1392: } ! 1393: } ! 1394: } ! 1395: else if (ARM_DEMANGLING && scan[2] == 'p' && scan[3] == 't') ! 1396: { ! 1397: /* Cfront-style parameterized type. Handled later as a signature. */ ! 1398: success = 1; ! 1399: ! 1400: /* ARM template? */ ! 1401: demangle_arm_pt (work, mangled, strlen (*mangled), declp); ! 1402: } ! 1403: else if (*(scan + 2) != '\0') ! 1404: { ! 1405: /* Mangled name does not start with "__" but does have one somewhere ! 1406: in there with non empty stuff after it. Looks like a global ! 1407: function name. */ ! 1408: demangle_function_name (work, mangled, declp, scan); ! 1409: } ! 1410: else ! 1411: { ! 1412: /* Doesn't look like a mangled name */ ! 1413: success = 0; ! 1414: } ! 1415: ! 1416: if (!success && (work->constructor == 2 || work->destructor == 2)) ! 1417: { ! 1418: string_append (declp, *mangled); ! 1419: *mangled += strlen (*mangled); ! 1420: success = 1; ! 1421: } ! 1422: return (success); ! 1423: } ! 1424: ! 1425: /* ! 1426: ! 1427: LOCAL FUNCTION ! 1428: ! 1429: gnu_special -- special handling of gnu mangled strings ! 1430: ! 1431: SYNOPSIS ! 1432: ! 1433: static int ! 1434: gnu_special (struct work_stuff *work, const char **mangled, ! 1435: string *declp); ! 1436: ! 1437: ! 1438: DESCRIPTION ! 1439: ! 1440: Process some special GNU style mangling forms that don't fit ! 1441: the normal pattern. For example: ! 1442: ! 1443: _$_3foo (destructor for class foo) ! 1444: _vt$foo (foo virtual table) ! 1445: _vt$foo$bar (foo::bar virtual table) ! 1446: __vt_foo (foo virtual table, new style with thunks) ! 1447: _3foo$varname (static data member) ! 1448: _Q22rs2tu$vw (static data member) ! 1449: __t6vector1Zii (constructor with template) ! 1450: __thunk_4__$_7ostream (virtual function thunk) ! 1451: */ ! 1452: ! 1453: static int ! 1454: gnu_special (work, mangled, declp) ! 1455: struct work_stuff *work; ! 1456: const char **mangled; ! 1457: string *declp; ! 1458: { ! 1459: int n; ! 1460: int success = 1; ! 1461: const char *p; ! 1462: ! 1463: if ((*mangled)[0] == '_' ! 1464: && strchr (cplus_markers, (*mangled)[1]) != NULL ! 1465: && (*mangled)[2] == '_') ! 1466: { ! 1467: /* Found a GNU style destructor, get past "_<CPLUS_MARKER>_" */ ! 1468: (*mangled) += 3; ! 1469: work -> destructor += 1; ! 1470: } ! 1471: else if ((*mangled)[0] == '_' ! 1472: && (((*mangled)[1] == '_' ! 1473: && (*mangled)[2] == 'v' ! 1474: && (*mangled)[3] == 't' ! 1475: && (*mangled)[4] == '_') ! 1476: || ((*mangled)[1] == 'v' ! 1477: && (*mangled)[2] == 't' ! 1478: && strchr (cplus_markers, (*mangled)[3]) != NULL))) ! 1479: { ! 1480: /* Found a GNU style virtual table, get past "_vt<CPLUS_MARKER>" ! 1481: and create the decl. Note that we consume the entire mangled ! 1482: input string, which means that demangle_signature has no work ! 1483: to do. */ ! 1484: if ((*mangled)[2] == 'v') ! 1485: (*mangled) += 5; /* New style, with thunks: "__vt_" */ ! 1486: else ! 1487: (*mangled) += 4; /* Old style, no thunks: "_vt<CPLUS_MARKER>" */ ! 1488: while (**mangled != '\0') ! 1489: { ! 1490: p = strpbrk (*mangled, cplus_markers); ! 1491: switch (**mangled) ! 1492: { ! 1493: case 'Q': ! 1494: success = demangle_qualified (work, mangled, declp, 0, 1); ! 1495: break; ! 1496: case 't': ! 1497: success = demangle_template (work, mangled, declp, 0); ! 1498: break; ! 1499: default: ! 1500: if (isdigit(*mangled[0])) ! 1501: { ! 1502: n = consume_count(mangled); ! 1503: } ! 1504: else ! 1505: { ! 1506: n = strcspn (*mangled, cplus_markers); ! 1507: } ! 1508: string_appendn (declp, *mangled, n); ! 1509: (*mangled) += n; ! 1510: } ! 1511: ! 1512: if (success && ((p == NULL) || (p == *mangled))) ! 1513: { ! 1514: if (p != NULL) ! 1515: { ! 1516: string_append (declp, "::"); ! 1517: (*mangled)++; ! 1518: } ! 1519: } ! 1520: else ! 1521: { ! 1522: success = 0; ! 1523: break; ! 1524: } ! 1525: } ! 1526: if (success) ! 1527: string_append (declp, " virtual table"); ! 1528: } ! 1529: else if ((*mangled)[0] == '_' ! 1530: && (strchr("0123456789Qt", (*mangled)[1]) != NULL) ! 1531: && (p = strpbrk (*mangled, cplus_markers)) != NULL) ! 1532: { ! 1533: /* static data member, "_3foo$varname" for example */ ! 1534: (*mangled)++; ! 1535: switch (**mangled) ! 1536: { ! 1537: case 'Q': ! 1538: success = demangle_qualified (work, mangled, declp, 0, 1); ! 1539: break; ! 1540: case 't': ! 1541: success = demangle_template (work, mangled, declp, 0); ! 1542: break; ! 1543: default: ! 1544: n = consume_count (mangled); ! 1545: string_appendn (declp, *mangled, n); ! 1546: (*mangled) += n; ! 1547: } ! 1548: if (success && (p == *mangled)) ! 1549: { ! 1550: /* Consumed everything up to the cplus_marker, append the ! 1551: variable name. */ ! 1552: (*mangled)++; ! 1553: string_append (declp, "::"); ! 1554: n = strlen (*mangled); ! 1555: string_appendn (declp, *mangled, n); ! 1556: (*mangled) += n; ! 1557: } ! 1558: else ! 1559: { ! 1560: success = 0; ! 1561: } ! 1562: } ! 1563: else if (strncmp (*mangled, "__thunk_", 8) == 0) ! 1564: { ! 1565: int delta = ((*mangled) += 8, consume_count (mangled)); ! 1566: char *method = cplus_demangle (++*mangled, work->options); ! 1567: if (method) ! 1568: { ! 1569: char buf[50]; ! 1570: sprintf (buf, "virtual function thunk (delta:%d) for ", -delta); ! 1571: string_append (declp, buf); ! 1572: string_append (declp, method); ! 1573: free (method); ! 1574: n = strlen (*mangled); ! 1575: (*mangled) += n; ! 1576: } ! 1577: else ! 1578: { ! 1579: success = 0; ! 1580: } ! 1581: } ! 1582: else ! 1583: { ! 1584: success = 0; ! 1585: } ! 1586: return (success); ! 1587: } ! 1588: ! 1589: /* ! 1590: ! 1591: LOCAL FUNCTION ! 1592: ! 1593: arm_special -- special handling of ARM/lucid mangled strings ! 1594: ! 1595: SYNOPSIS ! 1596: ! 1597: static int ! 1598: arm_special (struct work_stuff *work, const char **mangled, ! 1599: string *declp); ! 1600: ! 1601: ! 1602: DESCRIPTION ! 1603: ! 1604: Process some special ARM style mangling forms that don't fit ! 1605: the normal pattern. For example: ! 1606: ! 1607: __vtbl__3foo (foo virtual table) ! 1608: __vtbl__3foo__3bar (bar::foo virtual table) ! 1609: ! 1610: */ ! 1611: ! 1612: static int ! 1613: arm_special (work, mangled, declp) ! 1614: struct work_stuff *work; ! 1615: const char **mangled; ! 1616: string *declp; ! 1617: { ! 1618: int n; ! 1619: int success = 1; ! 1620: const char *scan; ! 1621: ! 1622: if (strncmp (*mangled, ARM_VTABLE_STRING, ARM_VTABLE_STRLEN) == 0) ! 1623: { ! 1624: /* Found a ARM style virtual table, get past ARM_VTABLE_STRING ! 1625: and create the decl. Note that we consume the entire mangled ! 1626: input string, which means that demangle_signature has no work ! 1627: to do. */ ! 1628: scan = *mangled + ARM_VTABLE_STRLEN; ! 1629: while (*scan != '\0') /* first check it can be demangled */ ! 1630: { ! 1631: n = consume_count (&scan); ! 1632: if (n==0) ! 1633: { ! 1634: return (0); /* no good */ ! 1635: } ! 1636: scan += n; ! 1637: if (scan[0] == '_' && scan[1] == '_') ! 1638: { ! 1639: scan += 2; ! 1640: } ! 1641: } ! 1642: (*mangled) += ARM_VTABLE_STRLEN; ! 1643: while (**mangled != '\0') ! 1644: { ! 1645: n = consume_count (mangled); ! 1646: string_prependn (declp, *mangled, n); ! 1647: (*mangled) += n; ! 1648: if ((*mangled)[0] == '_' && (*mangled)[1] == '_') ! 1649: { ! 1650: string_prepend (declp, "::"); ! 1651: (*mangled) += 2; ! 1652: } ! 1653: } ! 1654: string_append (declp, " virtual table"); ! 1655: } ! 1656: else ! 1657: { ! 1658: success = 0; ! 1659: } ! 1660: return (success); ! 1661: } ! 1662: ! 1663: /* ! 1664: ! 1665: LOCAL FUNCTION ! 1666: ! 1667: demangle_qualified -- demangle 'Q' qualified name strings ! 1668: ! 1669: SYNOPSIS ! 1670: ! 1671: static int ! 1672: demangle_qualified (struct work_stuff *, const char *mangled, ! 1673: string *result, int isfuncname, int append); ! 1674: ! 1675: DESCRIPTION ! 1676: ! 1677: Demangle a qualified name, such as "Q25Outer5Inner" which is ! 1678: the mangled form of "Outer::Inner". The demangled output is ! 1679: prepended or appended to the result string according to the ! 1680: state of the append flag. ! 1681: ! 1682: If isfuncname is nonzero, then the qualified name we are building ! 1683: is going to be used as a member function name, so if it is a ! 1684: constructor or destructor function, append an appropriate ! 1685: constructor or destructor name. I.E. for the above example, ! 1686: the result for use as a constructor is "Outer::Inner::Inner" ! 1687: and the result for use as a destructor is "Outer::Inner::~Inner". ! 1688: ! 1689: BUGS ! 1690: ! 1691: Numeric conversion is ASCII dependent (FIXME). ! 1692: ! 1693: */ ! 1694: ! 1695: static int ! 1696: demangle_qualified (work, mangled, result, isfuncname, append) ! 1697: struct work_stuff *work; ! 1698: const char **mangled; ! 1699: string *result; ! 1700: int isfuncname; ! 1701: int append; ! 1702: { ! 1703: int qualifiers; ! 1704: int namelength; ! 1705: int success = 1; ! 1706: const char *p; ! 1707: char num[2]; ! 1708: string temp; ! 1709: ! 1710: string_init (&temp); ! 1711: switch ((*mangled)[1]) ! 1712: { ! 1713: case '_': ! 1714: /* GNU mangled name with more than 9 classes. The count is preceded ! 1715: by an underscore (to distinguish it from the <= 9 case) and followed ! 1716: by an underscore. */ ! 1717: p = *mangled + 2; ! 1718: qualifiers = atoi (p); ! 1719: if (!isdigit (*p) || *p == '0') ! 1720: success = 0; ! 1721: ! 1722: /* Skip the digits. */ ! 1723: while (isdigit (*p)) ! 1724: ++p; ! 1725: ! 1726: if (*p != '_') ! 1727: success = 0; ! 1728: ! 1729: *mangled = p + 1; ! 1730: break; ! 1731: ! 1732: case '1': ! 1733: case '2': ! 1734: case '3': ! 1735: case '4': ! 1736: case '5': ! 1737: case '6': ! 1738: case '7': ! 1739: case '8': ! 1740: case '9': ! 1741: /* The count is in a single digit. */ ! 1742: num[0] = (*mangled)[1]; ! 1743: num[1] = '\0'; ! 1744: qualifiers = atoi (num); ! 1745: ! 1746: /* If there is an underscore after the digit, skip it. This is ! 1747: said to be for ARM-qualified names, but the ARM makes no ! 1748: mention of such an underscore. Perhaps cfront uses one. */ ! 1749: if ((*mangled)[2] == '_') ! 1750: { ! 1751: (*mangled)++; ! 1752: } ! 1753: (*mangled) += 2; ! 1754: break; ! 1755: ! 1756: case '0': ! 1757: default: ! 1758: success = 0; ! 1759: } ! 1760: ! 1761: if (!success) ! 1762: return success; ! 1763: ! 1764: /* Pick off the names and collect them in the temp buffer in the order ! 1765: in which they are found, separated by '::'. */ ! 1766: ! 1767: while (qualifiers-- > 0) ! 1768: { ! 1769: if (*mangled[0] == '_') ! 1770: *mangled = *mangled + 1; ! 1771: if (*mangled[0] == 't') ! 1772: { ! 1773: success = demangle_template(work, mangled, &temp, 0); ! 1774: if (!success) break; ! 1775: } ! 1776: else ! 1777: { ! 1778: namelength = consume_count (mangled); ! 1779: if (strlen (*mangled) < namelength) ! 1780: { ! 1781: /* Simple sanity check failed */ ! 1782: success = 0; ! 1783: break; ! 1784: } ! 1785: string_appendn (&temp, *mangled, namelength); ! 1786: *mangled += namelength; ! 1787: } ! 1788: if (qualifiers > 0) ! 1789: { ! 1790: string_appendn (&temp, "::", 2); ! 1791: } ! 1792: } ! 1793: ! 1794: /* If we are using the result as a function name, we need to append ! 1795: the appropriate '::' separated constructor or destructor name. ! 1796: We do this here because this is the most convenient place, where ! 1797: we already have a pointer to the name and the length of the name. */ ! 1798: ! 1799: if (isfuncname && (work->constructor & 1 || work->destructor & 1)) ! 1800: { ! 1801: string_appendn (&temp, "::", 2); ! 1802: if (work -> destructor & 1) ! 1803: { ! 1804: string_append (&temp, "~"); ! 1805: } ! 1806: string_appendn (&temp, (*mangled) - namelength, namelength); ! 1807: } ! 1808: ! 1809: /* Now either prepend the temp buffer to the result, or append it, ! 1810: depending upon the state of the append flag. */ ! 1811: ! 1812: if (append) ! 1813: { ! 1814: string_appends (result, &temp); ! 1815: } ! 1816: else ! 1817: { ! 1818: if (!STRING_EMPTY (result)) ! 1819: { ! 1820: string_appendn (&temp, "::", 2); ! 1821: } ! 1822: string_prepends (result, &temp); ! 1823: } ! 1824: ! 1825: string_delete (&temp); ! 1826: return (success); ! 1827: } ! 1828: ! 1829: /* ! 1830: ! 1831: LOCAL FUNCTION ! 1832: ! 1833: get_count -- convert an ascii count to integer, consuming tokens ! 1834: ! 1835: SYNOPSIS ! 1836: ! 1837: static int ! 1838: get_count (const char **type, int *count) ! 1839: ! 1840: DESCRIPTION ! 1841: ! 1842: Return 0 if no conversion is performed, 1 if a string is converted. ! 1843: */ ! 1844: ! 1845: static int ! 1846: get_count (type, count) ! 1847: const char **type; ! 1848: int *count; ! 1849: { ! 1850: const char *p; ! 1851: int n; ! 1852: ! 1853: if (!isdigit (**type)) ! 1854: { ! 1855: return (0); ! 1856: } ! 1857: else ! 1858: { ! 1859: *count = **type - '0'; ! 1860: (*type)++; ! 1861: if (isdigit (**type)) ! 1862: { ! 1863: p = *type; ! 1864: n = *count; ! 1865: do ! 1866: { ! 1867: n *= 10; ! 1868: n += *p - '0'; ! 1869: p++; ! 1870: } ! 1871: while (isdigit (*p)); ! 1872: if (*p == '_') ! 1873: { ! 1874: *type = p + 1; ! 1875: *count = n; ! 1876: } ! 1877: } ! 1878: } ! 1879: return (1); ! 1880: } ! 1881: ! 1882: /* result will be initialised here; it will be freed on failure */ ! 1883: ! 1884: static int ! 1885: do_type (work, mangled, result) ! 1886: struct work_stuff *work; ! 1887: const char **mangled; ! 1888: string *result; ! 1889: { ! 1890: int n; ! 1891: int done; ! 1892: int success; ! 1893: string decl; ! 1894: const char *remembered_type; ! 1895: int constp; ! 1896: int volatilep; ! 1897: ! 1898: string_init (&decl); ! 1899: string_init (result); ! 1900: ! 1901: done = 0; ! 1902: success = 1; ! 1903: while (success && !done) ! 1904: { ! 1905: int member; ! 1906: switch (**mangled) ! 1907: { ! 1908: ! 1909: /* A pointer type */ ! 1910: case 'P': ! 1911: case 'p': ! 1912: (*mangled)++; ! 1913: string_prepend (&decl, "*"); ! 1914: break; ! 1915: ! 1916: /* A reference type */ ! 1917: case 'R': ! 1918: (*mangled)++; ! 1919: string_prepend (&decl, "&"); ! 1920: break; ! 1921: ! 1922: /* An array */ ! 1923: case 'A': ! 1924: { ! 1925: const char *p = ++(*mangled); ! 1926: ! 1927: string_prepend (&decl, "("); ! 1928: string_append (&decl, ")["); ! 1929: /* Copy anything up until the next underscore (the size of the ! 1930: array). */ ! 1931: while (**mangled && **mangled != '_') ! 1932: ++(*mangled); ! 1933: if (**mangled == '_') ! 1934: { ! 1935: string_appendn (&decl, p, *mangled - p); ! 1936: string_append (&decl, "]"); ! 1937: *mangled += 1; ! 1938: } ! 1939: else ! 1940: success = 0; ! 1941: break; ! 1942: } ! 1943: ! 1944: /* A back reference to a previously seen type */ ! 1945: case 'T': ! 1946: (*mangled)++; ! 1947: if (!get_count (mangled, &n) || n >= work -> ntypes) ! 1948: { ! 1949: success = 0; ! 1950: } ! 1951: else ! 1952: { ! 1953: remembered_type = work -> typevec[n]; ! 1954: mangled = &remembered_type; ! 1955: } ! 1956: break; ! 1957: ! 1958: /* A function */ ! 1959: case 'F': ! 1960: (*mangled)++; ! 1961: if (!STRING_EMPTY (&decl) && decl.b[0] == '*') ! 1962: { ! 1963: string_prepend (&decl, "("); ! 1964: string_append (&decl, ")"); ! 1965: } ! 1966: /* After picking off the function args, we expect to either find the ! 1967: function return type (preceded by an '_') or the end of the ! 1968: string. */ ! 1969: if (!demangle_args (work, mangled, &decl) ! 1970: || (**mangled != '_' && **mangled != '\0')) ! 1971: { ! 1972: success = 0; ! 1973: } ! 1974: if (success && (**mangled == '_')) ! 1975: { ! 1976: (*mangled)++; ! 1977: } ! 1978: break; ! 1979: ! 1980: case 'M': ! 1981: case 'O': ! 1982: { ! 1983: constp = 0; ! 1984: volatilep = 0; ! 1985: ! 1986: member = **mangled == 'M'; ! 1987: (*mangled)++; ! 1988: if (!isdigit (**mangled)) ! 1989: { ! 1990: success = 0; ! 1991: break; ! 1992: } ! 1993: n = consume_count (mangled); ! 1994: if (strlen (*mangled) < n) ! 1995: { ! 1996: success = 0; ! 1997: break; ! 1998: } ! 1999: string_append (&decl, ")"); ! 2000: string_prepend (&decl, "::"); ! 2001: string_prependn (&decl, *mangled, n); ! 2002: string_prepend (&decl, "("); ! 2003: *mangled += n; ! 2004: if (member) ! 2005: { ! 2006: if (**mangled == 'C') ! 2007: { ! 2008: (*mangled)++; ! 2009: constp = 1; ! 2010: } ! 2011: if (**mangled == 'V') ! 2012: { ! 2013: (*mangled)++; ! 2014: volatilep = 1; ! 2015: } ! 2016: if (*(*mangled)++ != 'F') ! 2017: { ! 2018: success = 0; ! 2019: break; ! 2020: } ! 2021: } ! 2022: if ((member && !demangle_args (work, mangled, &decl)) ! 2023: || **mangled != '_') ! 2024: { ! 2025: success = 0; ! 2026: break; ! 2027: } ! 2028: (*mangled)++; ! 2029: if (! PRINT_ANSI_QUALIFIERS) ! 2030: { ! 2031: break; ! 2032: } ! 2033: if (constp) ! 2034: { ! 2035: APPEND_BLANK (&decl); ! 2036: string_append (&decl, "const"); ! 2037: } ! 2038: if (volatilep) ! 2039: { ! 2040: APPEND_BLANK (&decl); ! 2041: string_append (&decl, "volatile"); ! 2042: } ! 2043: break; ! 2044: } ! 2045: case 'G': ! 2046: (*mangled)++; ! 2047: break; ! 2048: ! 2049: case 'C': ! 2050: (*mangled)++; ! 2051: /* ! 2052: if ((*mangled)[1] == 'P') ! 2053: { ! 2054: */ ! 2055: if (PRINT_ANSI_QUALIFIERS) ! 2056: { ! 2057: if (!STRING_EMPTY (&decl)) ! 2058: { ! 2059: string_prepend (&decl, " "); ! 2060: } ! 2061: string_prepend (&decl, "const"); ! 2062: } ! 2063: break; ! 2064: /* ! 2065: } ! 2066: */ ! 2067: ! 2068: /* fall through */ ! 2069: default: ! 2070: done = 1; ! 2071: break; ! 2072: } ! 2073: } ! 2074: ! 2075: switch (**mangled) ! 2076: { ! 2077: /* A qualified name, such as "Outer::Inner". */ ! 2078: case 'Q': ! 2079: success = demangle_qualified (work, mangled, result, 0, 1); ! 2080: break; ! 2081: ! 2082: default: ! 2083: success = demangle_fund_type (work, mangled, result); ! 2084: break; ! 2085: } ! 2086: ! 2087: if (success) ! 2088: { ! 2089: if (!STRING_EMPTY (&decl)) ! 2090: { ! 2091: string_append (result, " "); ! 2092: string_appends (result, &decl); ! 2093: } ! 2094: } ! 2095: else ! 2096: { ! 2097: string_delete (result); ! 2098: } ! 2099: string_delete (&decl); ! 2100: return (success); ! 2101: } ! 2102: ! 2103: /* Given a pointer to a type string that represents a fundamental type ! 2104: argument (int, long, unsigned int, etc) in TYPE, a pointer to the ! 2105: string in which the demangled output is being built in RESULT, and ! 2106: the WORK structure, decode the types and add them to the result. ! 2107: ! 2108: For example: ! 2109: ! 2110: "Ci" => "const int" ! 2111: "Sl" => "signed long" ! 2112: "CUs" => "const unsigned short" ! 2113: ! 2114: */ ! 2115: ! 2116: static int ! 2117: demangle_fund_type (work, mangled, result) ! 2118: struct work_stuff *work; ! 2119: const char **mangled; ! 2120: string *result; ! 2121: { ! 2122: int done = 0; ! 2123: int success = 1; ! 2124: ! 2125: /* First pick off any type qualifiers. There can be more than one. */ ! 2126: ! 2127: while (!done) ! 2128: { ! 2129: switch (**mangled) ! 2130: { ! 2131: case 'C': ! 2132: (*mangled)++; ! 2133: if (PRINT_ANSI_QUALIFIERS) ! 2134: { ! 2135: APPEND_BLANK (result); ! 2136: string_append (result, "const"); ! 2137: } ! 2138: break; ! 2139: case 'U': ! 2140: (*mangled)++; ! 2141: APPEND_BLANK (result); ! 2142: string_append (result, "unsigned"); ! 2143: break; ! 2144: case 'S': /* signed char only */ ! 2145: (*mangled)++; ! 2146: APPEND_BLANK (result); ! 2147: string_append (result, "signed"); ! 2148: break; ! 2149: case 'V': ! 2150: (*mangled)++; ! 2151: if (PRINT_ANSI_QUALIFIERS) ! 2152: { ! 2153: APPEND_BLANK (result); ! 2154: string_append (result, "volatile"); ! 2155: } ! 2156: break; ! 2157: default: ! 2158: done = 1; ! 2159: break; ! 2160: } ! 2161: } ! 2162: ! 2163: /* Now pick off the fundamental type. There can be only one. */ ! 2164: ! 2165: switch (**mangled) ! 2166: { ! 2167: case '\0': ! 2168: case '_': ! 2169: break; ! 2170: case 'v': ! 2171: (*mangled)++; ! 2172: APPEND_BLANK (result); ! 2173: string_append (result, "void"); ! 2174: break; ! 2175: case 'x': ! 2176: (*mangled)++; ! 2177: APPEND_BLANK (result); ! 2178: string_append (result, "long long"); ! 2179: break; ! 2180: case 'l': ! 2181: (*mangled)++; ! 2182: APPEND_BLANK (result); ! 2183: string_append (result, "long"); ! 2184: break; ! 2185: case 'i': ! 2186: (*mangled)++; ! 2187: APPEND_BLANK (result); ! 2188: string_append (result, "int"); ! 2189: break; ! 2190: case 's': ! 2191: (*mangled)++; ! 2192: APPEND_BLANK (result); ! 2193: string_append (result, "short"); ! 2194: break; ! 2195: case 'b': ! 2196: (*mangled)++; ! 2197: APPEND_BLANK (result); ! 2198: string_append (result, "bool"); ! 2199: break; ! 2200: case 'c': ! 2201: (*mangled)++; ! 2202: APPEND_BLANK (result); ! 2203: string_append (result, "char"); ! 2204: break; ! 2205: case 'w': ! 2206: (*mangled)++; ! 2207: APPEND_BLANK (result); ! 2208: string_append (result, "wchar_t"); ! 2209: break; ! 2210: case 'r': ! 2211: (*mangled)++; ! 2212: APPEND_BLANK (result); ! 2213: string_append (result, "long double"); ! 2214: break; ! 2215: case 'd': ! 2216: (*mangled)++; ! 2217: APPEND_BLANK (result); ! 2218: string_append (result, "double"); ! 2219: break; ! 2220: case 'f': ! 2221: (*mangled)++; ! 2222: APPEND_BLANK (result); ! 2223: string_append (result, "float"); ! 2224: break; ! 2225: case 'G': ! 2226: (*mangled)++; ! 2227: if (!isdigit (**mangled)) ! 2228: { ! 2229: success = 0; ! 2230: break; ! 2231: } ! 2232: /* fall through */ ! 2233: /* An explicit type, such as "6mytype" or "7integer" */ ! 2234: case '0': ! 2235: case '1': ! 2236: case '2': ! 2237: case '3': ! 2238: case '4': ! 2239: case '5': ! 2240: case '6': ! 2241: case '7': ! 2242: case '8': ! 2243: case '9': ! 2244: APPEND_BLANK (result); ! 2245: if (!demangle_class_name (work, mangled, result)) { ! 2246: --result->p; ! 2247: success = 0; ! 2248: } ! 2249: break; ! 2250: case 't': ! 2251: success = demangle_template(work,mangled, result, 0); ! 2252: break; ! 2253: default: ! 2254: success = 0; ! 2255: break; ! 2256: } ! 2257: ! 2258: return (success); ! 2259: } ! 2260: ! 2261: /* `result' will be initialized in do_type; it will be freed on failure */ ! 2262: ! 2263: static int ! 2264: do_arg (work, mangled, result) ! 2265: struct work_stuff *work; ! 2266: const char **mangled; ! 2267: string *result; ! 2268: { ! 2269: const char *start = *mangled; ! 2270: ! 2271: if (!do_type (work, mangled, result)) ! 2272: { ! 2273: return (0); ! 2274: } ! 2275: else ! 2276: { ! 2277: remember_type (work, start, *mangled - start); ! 2278: return (1); ! 2279: } ! 2280: } ! 2281: ! 2282: static void ! 2283: remember_type (work, start, len) ! 2284: struct work_stuff *work; ! 2285: const char *start; ! 2286: int len; ! 2287: { ! 2288: char *tem; ! 2289: ! 2290: if (work -> ntypes >= work -> typevec_size) ! 2291: { ! 2292: if (work -> typevec_size == 0) ! 2293: { ! 2294: work -> typevec_size = 3; ! 2295: work -> typevec = ! 2296: (char **) xmalloc (sizeof (char *) * work -> typevec_size); ! 2297: } ! 2298: else ! 2299: { ! 2300: work -> typevec_size *= 2; ! 2301: work -> typevec = ! 2302: (char **) xrealloc ((char *)work -> typevec, ! 2303: sizeof (char *) * work -> typevec_size); ! 2304: } ! 2305: } ! 2306: tem = xmalloc (len + 1); ! 2307: memcpy (tem, start, len); ! 2308: tem[len] = '\0'; ! 2309: work -> typevec[work -> ntypes++] = tem; ! 2310: } ! 2311: ! 2312: /* Forget the remembered types, but not the type vector itself. */ ! 2313: ! 2314: static void ! 2315: forget_types (work) ! 2316: struct work_stuff *work; ! 2317: { ! 2318: int i; ! 2319: ! 2320: while (work -> ntypes > 0) ! 2321: { ! 2322: i = --(work -> ntypes); ! 2323: if (work -> typevec[i] != NULL) ! 2324: { ! 2325: free (work -> typevec[i]); ! 2326: work -> typevec[i] = NULL; ! 2327: } ! 2328: } ! 2329: } ! 2330: ! 2331: /* Process the argument list part of the signature, after any class spec ! 2332: has been consumed, as well as the first 'F' character (if any). For ! 2333: example: ! 2334: ! 2335: "__als__3fooRT0" => process "RT0" ! 2336: "complexfunc5__FPFPc_PFl_i" => process "PFPc_PFl_i" ! 2337: ! 2338: DECLP must be already initialised, usually non-empty. It won't be freed ! 2339: on failure. ! 2340: ! 2341: Note that g++ differs significantly from ARM and lucid style mangling ! 2342: with regards to references to previously seen types. For example, given ! 2343: the source fragment: ! 2344: ! 2345: class foo { ! 2346: public: ! 2347: foo::foo (int, foo &ia, int, foo &ib, int, foo &ic); ! 2348: }; ! 2349: ! 2350: foo::foo (int, foo &ia, int, foo &ib, int, foo &ic) { ia = ib = ic; } ! 2351: void foo (int, foo &ia, int, foo &ib, int, foo &ic) { ia = ib = ic; } ! 2352: ! 2353: g++ produces the names: ! 2354: ! 2355: __3fooiRT0iT2iT2 ! 2356: foo__FiR3fooiT1iT1 ! 2357: ! 2358: while lcc (and presumably other ARM style compilers as well) produces: ! 2359: ! 2360: foo__FiR3fooT1T2T1T2 ! 2361: __ct__3fooFiR3fooT1T2T1T2 ! 2362: ! 2363: Note that g++ bases it's type numbers starting at zero and counts all ! 2364: previously seen types, while lucid/ARM bases it's type numbers starting ! 2365: at one and only considers types after it has seen the 'F' character ! 2366: indicating the start of the function args. For lucid/ARM style, we ! 2367: account for this difference by discarding any previously seen types when ! 2368: we see the 'F' character, and subtracting one from the type number ! 2369: reference. ! 2370: ! 2371: */ ! 2372: ! 2373: static int ! 2374: demangle_args (work, mangled, declp) ! 2375: struct work_stuff *work; ! 2376: const char **mangled; ! 2377: string *declp; ! 2378: { ! 2379: string arg; ! 2380: int need_comma = 0; ! 2381: int r; ! 2382: int t; ! 2383: const char *tem; ! 2384: char temptype; ! 2385: ! 2386: if (PRINT_ARG_TYPES) ! 2387: { ! 2388: string_append (declp, "("); ! 2389: if (**mangled == '\0') ! 2390: { ! 2391: string_append (declp, "void"); ! 2392: } ! 2393: } ! 2394: ! 2395: while (**mangled != '_' && **mangled != '\0' && **mangled != 'e') ! 2396: { ! 2397: if ((**mangled == 'N') || (**mangled == 'T')) ! 2398: { ! 2399: temptype = *(*mangled)++; ! 2400: ! 2401: if (temptype == 'N') ! 2402: { ! 2403: if (!get_count (mangled, &r)) ! 2404: { ! 2405: return (0); ! 2406: } ! 2407: } ! 2408: else ! 2409: { ! 2410: r = 1; ! 2411: } ! 2412: if (ARM_DEMANGLING && work -> ntypes >= 10) ! 2413: { ! 2414: /* If we have 10 or more types we might have more than a 1 digit ! 2415: index so we'll have to consume the whole count here. This ! 2416: will lose if the next thing is a type name preceded by a ! 2417: count but it's impossible to demangle that case properly ! 2418: anyway. Eg if we already have 12 types is T12Pc "(..., type1, ! 2419: Pc, ...)" or "(..., type12, char *, ...)" */ ! 2420: if ((t = consume_count(mangled)) == 0) ! 2421: { ! 2422: return (0); ! 2423: } ! 2424: } ! 2425: else ! 2426: { ! 2427: if (!get_count (mangled, &t)) ! 2428: { ! 2429: return (0); ! 2430: } ! 2431: } ! 2432: if (LUCID_DEMANGLING || ARM_DEMANGLING) ! 2433: { ! 2434: t--; ! 2435: } ! 2436: /* Validate the type index. Protect against illegal indices from ! 2437: malformed type strings. */ ! 2438: if ((t < 0) || (t >= work -> ntypes)) ! 2439: { ! 2440: return (0); ! 2441: } ! 2442: while (--r >= 0) ! 2443: { ! 2444: tem = work -> typevec[t]; ! 2445: if (need_comma && PRINT_ARG_TYPES) ! 2446: { ! 2447: string_append (declp, ", "); ! 2448: } ! 2449: if (!do_arg (work, &tem, &arg)) ! 2450: { ! 2451: return (0); ! 2452: } ! 2453: if (PRINT_ARG_TYPES) ! 2454: { ! 2455: string_appends (declp, &arg); ! 2456: } ! 2457: string_delete (&arg); ! 2458: need_comma = 1; ! 2459: } ! 2460: } ! 2461: else ! 2462: { ! 2463: if (need_comma & PRINT_ARG_TYPES) ! 2464: { ! 2465: string_append (declp, ", "); ! 2466: } ! 2467: if (!do_arg (work, mangled, &arg)) ! 2468: { ! 2469: return (0); ! 2470: } ! 2471: if (PRINT_ARG_TYPES) ! 2472: { ! 2473: string_appends (declp, &arg); ! 2474: } ! 2475: string_delete (&arg); ! 2476: need_comma = 1; ! 2477: } ! 2478: } ! 2479: ! 2480: if (**mangled == 'e') ! 2481: { ! 2482: (*mangled)++; ! 2483: if (PRINT_ARG_TYPES) ! 2484: { ! 2485: if (need_comma) ! 2486: { ! 2487: string_append (declp, ","); ! 2488: } ! 2489: string_append (declp, "..."); ! 2490: } ! 2491: } ! 2492: ! 2493: if (PRINT_ARG_TYPES) ! 2494: { ! 2495: string_append (declp, ")"); ! 2496: } ! 2497: return (1); ! 2498: } ! 2499: ! 2500: static void ! 2501: demangle_function_name (work, mangled, declp, scan) ! 2502: struct work_stuff *work; ! 2503: const char **mangled; ! 2504: string *declp; ! 2505: const char *scan; ! 2506: { ! 2507: int i; ! 2508: int len; ! 2509: string type; ! 2510: const char *tem; ! 2511: ! 2512: string_appendn (declp, (*mangled), scan - (*mangled)); ! 2513: string_need (declp, 1); ! 2514: *(declp -> p) = '\0'; ! 2515: ! 2516: /* Consume the function name, including the "__" separating the name ! 2517: from the signature. We are guaranteed that SCAN points to the ! 2518: separator. */ ! 2519: ! 2520: (*mangled) = scan + 2; ! 2521: ! 2522: if (LUCID_DEMANGLING || ARM_DEMANGLING) ! 2523: { ! 2524: ! 2525: /* See if we have an ARM style constructor or destructor operator. ! 2526: If so, then just record it, clear the decl, and return. ! 2527: We can't build the actual constructor/destructor decl until later, ! 2528: when we recover the class name from the signature. */ ! 2529: ! 2530: if (strcmp (declp -> b, "__ct") == 0) ! 2531: { ! 2532: work -> constructor += 1; ! 2533: string_clear (declp); ! 2534: return; ! 2535: } ! 2536: else if (strcmp (declp -> b, "__dt") == 0) ! 2537: { ! 2538: work -> destructor += 1; ! 2539: string_clear (declp); ! 2540: return; ! 2541: } ! 2542: } ! 2543: ! 2544: if (declp->p - declp->b >= 3 ! 2545: && declp->b[0] == 'o' ! 2546: && declp->b[1] == 'p' ! 2547: && strchr (cplus_markers, declp->b[2]) != NULL) ! 2548: { ! 2549: /* see if it's an assignment expression */ ! 2550: if (declp->p - declp->b >= 10 /* op$assign_ */ ! 2551: && memcmp (declp->b + 3, "assign_", 7) == 0) ! 2552: { ! 2553: for (i = 0; i < sizeof (optable) / sizeof (optable[0]); i++) ! 2554: { ! 2555: len = declp->p - declp->b - 10; ! 2556: if (strlen (optable[i].in) == len ! 2557: && memcmp (optable[i].in, declp->b + 10, len) == 0) ! 2558: { ! 2559: string_clear (declp); ! 2560: string_append (declp, "operator"); ! 2561: string_append (declp, optable[i].out); ! 2562: string_append (declp, "="); ! 2563: break; ! 2564: } ! 2565: } ! 2566: } ! 2567: else ! 2568: { ! 2569: for (i = 0; i < sizeof (optable) / sizeof (optable[0]); i++) ! 2570: { ! 2571: int len = declp->p - declp->b - 3; ! 2572: if (strlen (optable[i].in) == len ! 2573: && memcmp (optable[i].in, declp->b + 3, len) == 0) ! 2574: { ! 2575: string_clear (declp); ! 2576: string_append (declp, "operator"); ! 2577: string_append (declp, optable[i].out); ! 2578: break; ! 2579: } ! 2580: } ! 2581: } ! 2582: } ! 2583: else if (declp->p - declp->b >= 5 && memcmp (declp->b, "type", 4) == 0 ! 2584: && strchr (cplus_markers, declp->b[4]) != NULL) ! 2585: { ! 2586: /* type conversion operator */ ! 2587: tem = declp->b + 5; ! 2588: if (do_type (work, &tem, &type)) ! 2589: { ! 2590: string_clear (declp); ! 2591: string_append (declp, "operator "); ! 2592: string_appends (declp, &type); ! 2593: string_delete (&type); ! 2594: } ! 2595: } ! 2596: else if (declp->b[0] == '_' && declp->b[1] == '_' ! 2597: && declp->b[2] == 'o' && declp->b[3] == 'p') ! 2598: { ! 2599: /* ANSI. */ ! 2600: /* type conversion operator. */ ! 2601: tem = declp->b + 4; ! 2602: if (do_type (work, &tem, &type)) ! 2603: { ! 2604: string_clear (declp); ! 2605: string_append (declp, "operator "); ! 2606: string_appends (declp, &type); ! 2607: string_delete (&type); ! 2608: } ! 2609: } ! 2610: else if (declp->b[0] == '_' && declp->b[1] == '_' ! 2611: && declp->b[2] >= 'a' && declp->b[2] <= 'z' ! 2612: && declp->b[3] >= 'a' && declp->b[3] <= 'z') ! 2613: { ! 2614: if (declp->b[4] == '\0') ! 2615: { ! 2616: /* Operator. */ ! 2617: for (i = 0; i < sizeof (optable) / sizeof (optable[0]); i++) ! 2618: { ! 2619: if (strlen (optable[i].in) == 2 ! 2620: && memcmp (optable[i].in, declp->b + 2, 2) == 0) ! 2621: { ! 2622: string_clear (declp); ! 2623: string_append (declp, "operator"); ! 2624: string_append (declp, optable[i].out); ! 2625: break; ! 2626: } ! 2627: } ! 2628: } ! 2629: else ! 2630: { ! 2631: if (declp->b[2] == 'a' && declp->b[5] == '\0') ! 2632: { ! 2633: /* Assignment. */ ! 2634: for (i = 0; i < sizeof (optable) / sizeof (optable[0]); i++) ! 2635: { ! 2636: if (strlen (optable[i].in) == 3 ! 2637: && memcmp (optable[i].in, declp->b + 2, 3) == 0) ! 2638: { ! 2639: string_clear (declp); ! 2640: string_append (declp, "operator"); ! 2641: string_append (declp, optable[i].out); ! 2642: break; ! 2643: } ! 2644: } ! 2645: } ! 2646: } ! 2647: } ! 2648: } ! 2649: ! 2650: /* a mini string-handling package */ ! 2651: ! 2652: static void ! 2653: string_need (s, n) ! 2654: string *s; ! 2655: int n; ! 2656: { ! 2657: int tem; ! 2658: ! 2659: if (s->b == NULL) ! 2660: { ! 2661: if (n < 32) ! 2662: { ! 2663: n = 32; ! 2664: } ! 2665: s->p = s->b = xmalloc (n); ! 2666: s->e = s->b + n; ! 2667: } ! 2668: else if (s->e - s->p < n) ! 2669: { ! 2670: tem = s->p - s->b; ! 2671: n += tem; ! 2672: n *= 2; ! 2673: s->b = xrealloc (s->b, n); ! 2674: s->p = s->b + tem; ! 2675: s->e = s->b + n; ! 2676: } ! 2677: } ! 2678: ! 2679: static void ! 2680: string_delete (s) ! 2681: string *s; ! 2682: { ! 2683: if (s->b != NULL) ! 2684: { ! 2685: free (s->b); ! 2686: s->b = s->e = s->p = NULL; ! 2687: } ! 2688: } ! 2689: ! 2690: static void ! 2691: string_init (s) ! 2692: string *s; ! 2693: { ! 2694: s->b = s->p = s->e = NULL; ! 2695: } ! 2696: ! 2697: static void ! 2698: string_clear (s) ! 2699: string *s; ! 2700: { ! 2701: s->p = s->b; ! 2702: } ! 2703: ! 2704: #if 0 ! 2705: ! 2706: static int ! 2707: string_empty (s) ! 2708: string *s; ! 2709: { ! 2710: return (s->b == s->p); ! 2711: } ! 2712: ! 2713: #endif ! 2714: ! 2715: static void ! 2716: string_append (p, s) ! 2717: string *p; ! 2718: const char *s; ! 2719: { ! 2720: int n; ! 2721: if (s == NULL || *s == '\0') ! 2722: return; ! 2723: n = strlen (s); ! 2724: string_need (p, n); ! 2725: memcpy (p->p, s, n); ! 2726: p->p += n; ! 2727: } ! 2728: ! 2729: static void ! 2730: string_appends (p, s) ! 2731: string *p, *s; ! 2732: { ! 2733: int n; ! 2734: ! 2735: if (s->b != s->p) ! 2736: { ! 2737: n = s->p - s->b; ! 2738: string_need (p, n); ! 2739: memcpy (p->p, s->b, n); ! 2740: p->p += n; ! 2741: } ! 2742: } ! 2743: ! 2744: static void ! 2745: string_appendn (p, s, n) ! 2746: string *p; ! 2747: const char *s; ! 2748: int n; ! 2749: { ! 2750: if (n != 0) ! 2751: { ! 2752: string_need (p, n); ! 2753: memcpy (p->p, s, n); ! 2754: p->p += n; ! 2755: } ! 2756: } ! 2757: ! 2758: static void ! 2759: string_prepend (p, s) ! 2760: string *p; ! 2761: const char *s; ! 2762: { ! 2763: if (s != NULL && *s != '\0') ! 2764: { ! 2765: string_prependn (p, s, strlen (s)); ! 2766: } ! 2767: } ! 2768: ! 2769: static void ! 2770: string_prepends (p, s) ! 2771: string *p, *s; ! 2772: { ! 2773: if (s->b != s->p) ! 2774: { ! 2775: string_prependn (p, s->b, s->p - s->b); ! 2776: } ! 2777: } ! 2778: ! 2779: static void ! 2780: string_prependn (p, s, n) ! 2781: string *p; ! 2782: const char *s; ! 2783: int n; ! 2784: { ! 2785: char *q; ! 2786: ! 2787: if (n != 0) ! 2788: { ! 2789: string_need (p, n); ! 2790: for (q = p->p - 1; q >= p->b; q--) ! 2791: { ! 2792: q[n] = q[0]; ! 2793: } ! 2794: memcpy (p->b, s, n); ! 2795: p->p += n; ! 2796: } ! 2797: } ! 2798: ! 2799: /* To generate a standalone demangler program for testing purposes, ! 2800: just compile and link this file with -DMAIN and libiberty.a. When ! 2801: run, it demangles each command line arg, or each stdin string, and ! 2802: prints the result on stdout. */ ! 2803: ! 2804: #ifdef MAIN ! 2805: ! 2806: static void ! 2807: demangle_it (mangled_name) ! 2808: char *mangled_name; ! 2809: { ! 2810: char *result; ! 2811: ! 2812: result = cplus_demangle (mangled_name, DMGL_PARAMS | DMGL_ANSI); ! 2813: if (result == NULL) ! 2814: { ! 2815: printf ("%s\n", mangled_name); ! 2816: } ! 2817: else ! 2818: { ! 2819: printf ("%s\n", result); ! 2820: free (result); ! 2821: } ! 2822: } ! 2823: ! 2824: #include "getopt.h" ! 2825: ! 2826: static char *program_name; ! 2827: static char *program_version = VERSION; ! 2828: ! 2829: static void ! 2830: usage (stream, status) ! 2831: FILE *stream; ! 2832: int status; ! 2833: { ! 2834: fprintf (stream, "\ ! 2835: Usage: %s [-_] [-n] [-s {gnu,lucid,arm}] [--strip-underscores]\n\ ! 2836: [--no-strip-underscores] [--format={gnu,lucid,arm}]\n\ ! 2837: [--help] [--version] [arg...]\n", ! 2838: program_name); ! 2839: exit (status); ! 2840: } ! 2841: ! 2842: #define MBUF_SIZE 512 ! 2843: char mbuffer[MBUF_SIZE]; ! 2844: ! 2845: /* Defined in the automatically-generated underscore.c. */ ! 2846: extern int prepends_underscore; ! 2847: ! 2848: int strip_underscore = 0; ! 2849: ! 2850: static struct option long_options[] = { ! 2851: {"strip-underscores", no_argument, 0, '_'}, ! 2852: {"format", required_argument, 0, 's'}, ! 2853: {"help", no_argument, 0, 'h'}, ! 2854: {"no-strip-underscores", no_argument, 0, 'n'}, ! 2855: {"version", no_argument, 0, 'v'}, ! 2856: {0, no_argument, 0, 0} ! 2857: }; ! 2858: ! 2859: int ! 2860: main (argc, argv) ! 2861: int argc; ! 2862: char **argv; ! 2863: { ! 2864: char *result; ! 2865: int c; ! 2866: ! 2867: program_name = argv[0]; ! 2868: ! 2869: strip_underscore = prepends_underscore; ! 2870: ! 2871: while ((c = getopt_long (argc, argv, "_ns:", long_options, (int *) 0)) != EOF) ! 2872: { ! 2873: switch (c) ! 2874: { ! 2875: case '?': ! 2876: usage (stderr, 1); ! 2877: break; ! 2878: case 'h': ! 2879: usage (stdout, 0); ! 2880: case 'n': ! 2881: strip_underscore = 0; ! 2882: break; ! 2883: case 'v': ! 2884: printf ("GNU %s version %s\n", program_name, program_version); ! 2885: exit (0); ! 2886: case '_': ! 2887: strip_underscore = 1; ! 2888: break; ! 2889: case 's': ! 2890: if (strcmp (optarg, "gnu") == 0) ! 2891: { ! 2892: current_demangling_style = gnu_demangling; ! 2893: } ! 2894: else if (strcmp (optarg, "lucid") == 0) ! 2895: { ! 2896: current_demangling_style = lucid_demangling; ! 2897: } ! 2898: else if (strcmp (optarg, "arm") == 0) ! 2899: { ! 2900: current_demangling_style = arm_demangling; ! 2901: } ! 2902: else ! 2903: { ! 2904: fprintf (stderr, "%s: unknown demangling style `%s'\n", ! 2905: program_name, optarg); ! 2906: exit (1); ! 2907: } ! 2908: break; ! 2909: } ! 2910: } ! 2911: ! 2912: if (optind < argc) ! 2913: { ! 2914: for ( ; optind < argc; optind++) ! 2915: { ! 2916: demangle_it (argv[optind]); ! 2917: } ! 2918: } ! 2919: else ! 2920: { ! 2921: for (;;) ! 2922: { ! 2923: int i = 0; ! 2924: c = getchar (); ! 2925: /* Try to read a label. */ ! 2926: while (c != EOF && (isalnum(c) || c == '_' || c == '$' || c == '.')) ! 2927: { ! 2928: if (i >= MBUF_SIZE-1) ! 2929: break; ! 2930: mbuffer[i++] = c; ! 2931: c = getchar (); ! 2932: } ! 2933: if (i > 0) ! 2934: { ! 2935: int skip_first = 0; ! 2936: ! 2937: if (mbuffer[0] == '.') ! 2938: ++skip_first; ! 2939: if (strip_underscore && mbuffer[skip_first] == '_') ! 2940: ++skip_first; ! 2941: ! 2942: if (skip_first > i) ! 2943: skip_first = i; ! 2944: ! 2945: mbuffer[i] = 0; ! 2946: ! 2947: result = cplus_demangle (mbuffer + skip_first, ! 2948: DMGL_PARAMS | DMGL_ANSI); ! 2949: if (result) ! 2950: { ! 2951: if (mbuffer[0] == '.') ! 2952: putc ('.', stdout); ! 2953: fputs (result, stdout); ! 2954: free (result); ! 2955: } ! 2956: else ! 2957: fputs (mbuffer, stdout); ! 2958: ! 2959: fflush (stdout); ! 2960: } ! 2961: if (c == EOF) ! 2962: break; ! 2963: putchar (c); ! 2964: } ! 2965: } ! 2966: ! 2967: exit (0); ! 2968: } ! 2969: ! 2970: static void ! 2971: fatal (str) ! 2972: char *str; ! 2973: { ! 2974: fprintf (stderr, "%s: %s\n", program_name, str); ! 2975: exit (1); ! 2976: } ! 2977: ! 2978: char * malloc (); ! 2979: char * realloc (); ! 2980: ! 2981: char * ! 2982: xmalloc (size) ! 2983: unsigned size; ! 2984: { ! 2985: register char *value = (char *) malloc (size); ! 2986: if (value == 0) ! 2987: fatal ("virtual memory exhausted"); ! 2988: return value; ! 2989: } ! 2990: ! 2991: char * ! 2992: xrealloc (ptr, size) ! 2993: char *ptr; ! 2994: unsigned size; ! 2995: { ! 2996: register char *value = (char *) realloc (ptr, size); ! 2997: if (value == 0) ! 2998: fatal ("virtual memory exhausted"); ! 2999: return value; ! 3000: } ! 3001: #endif /* main */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.