![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cp-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 cp-dem.c CVS log | Up to [GCC 2.x] / gcc |
1.1 ! root 1: /* Demangler for GNU C++ ! 2: Copyright (C) 1989, 1992 Free Software Foundation, Inc. ! 3: written by James Clark ([email protected]) ! 4: ! 5: This program is free software; you can redistribute it and/or modify ! 6: it under the terms of the GNU General Public License as published by ! 7: the Free Software Foundation; either version 2, or (at your option) ! 8: any later version. ! 9: ! 10: This program is distributed in the hope that it will be useful, ! 11: but WITHOUT ANY WARRANTY; without even the implied warranty of ! 12: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ! 13: GNU General Public License for more details. ! 14: ! 15: You should have received a copy of the GNU General Public License ! 16: along with this program; if not, write to the Free Software ! 17: Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ ! 18: ! 19: /* This is for g++ 1.36.1 (November 6 version). It will probably ! 20: require changes for any other version. ! 21: ! 22: Modified for g++ 1.36.2 (November 18 version). ! 23: ! 24: Modified for g++ 1.90.06 (December 31 version). ! 25: ! 26: Modified for g++ 1.95.03 (November 13 verison). */ ! 27: ! 28: /* This file exports one function ! 29: ! 30: char *cplus_demangle (const char *name) ! 31: ! 32: If NAME is a mangled function name produced by GNU C++, then ! 33: a pointer to a malloced string giving a C++ representation ! 34: of the name will be returned; otherwise NULL will be returned. ! 35: It is the caller's responsibility to free the string which ! 36: is returned. ! 37: ! 38: For example, ! 39: ! 40: cplus_demangle ("_foo__1Ai") ! 41: ! 42: returns ! 43: ! 44: "A::foo(int)" ! 45: ! 46: This file imports xmalloc and xrealloc, which are like malloc and ! 47: realloc except that they generate a fatal error if there is no ! 48: available memory. */ ! 49: ! 50: /* #define nounderscore 1 /* define this is names don't start with _ */ ! 51: ! 52: #include <stdio.h> ! 53: #include <ctype.h> ! 54: ! 55: #ifdef USG ! 56: #include <memory.h> ! 57: #include <string.h> ! 58: #else ! 59: #include <strings.h> ! 60: #define memcpy(s1, s2, n) bcopy ((s2), (s1), (n)) ! 61: #define memcmp(s1, s2, n) bcmp ((s2), (s1), (n)) ! 62: #define strchr index ! 63: #define strrchr rindex ! 64: #endif ! 65: ! 66: /* This is '$' on systems where the assembler can deal with that. ! 67: Where the assembler can't, it's '.' (but on many systems '.' is ! 68: used for other things). */ ! 69: #if !defined (CPLUS_MARKER) ! 70: #define CPLUS_MARKER '$' ! 71: #endif ! 72: ! 73: #ifndef __STDC__ ! 74: #define const ! 75: #endif ! 76: ! 77: #ifdef __STDC__ ! 78: extern char *cplus_demangle (const char *type); ! 79: #else ! 80: extern char *cplus_demangle (); ! 81: #endif ! 82: ! 83: #ifdef __STDC__ ! 84: extern char *xmalloc (int); ! 85: extern char *xrealloc (char *, int); ! 86: extern void free (char *); ! 87: #else ! 88: extern char *xmalloc (); ! 89: extern char *xrealloc (); ! 90: extern void free (); ! 91: #endif ! 92: ! 93: static char **typevec = 0; ! 94: static int ntypes = 0; ! 95: static int typevec_size = 0; ! 96: ! 97: static struct { ! 98: const char *in; ! 99: const char *out; ! 100: } optable[] = { ! 101: "nw", " new", /* new (1.92, ansi) */ ! 102: "dl", " delete", /* new (1.92, ansi) */ ! 103: "new", " new", /* old (1.91) */ ! 104: "delete", " delete", /* old (1.91) */ ! 105: "ne", "!=", /* old, ansi */ ! 106: "eq", "==", /* old, ansi */ ! 107: "ge", ">=", /* old, ansi */ ! 108: "gt", ">", /* old, ansi */ ! 109: "le", "<=", /* old, ansi */ ! 110: "lt", "<", /* old, ansi */ ! 111: "plus", "+", /* old */ ! 112: "pl", "+", /* ansi */ ! 113: "apl", "+=", /* ansi */ ! 114: "minus", "-", /* old */ ! 115: "mi", "-", /* ansi */ ! 116: "ami", "-=", /* ansi */ ! 117: "mult", "*", /* old */ ! 118: "ml", "*", /* ansi */ ! 119: "aml", "*=", /* ansi */ ! 120: "convert", "+", /* old (unary +) */ ! 121: "negate", "-", /* old (unary -) */ ! 122: "trunc_mod", "%", /* old */ ! 123: "md", "%", /* ansi */ ! 124: "amd", "%=", /* ansi */ ! 125: "trunc_div", "/", /* old */ ! 126: "dv", "/", /* ansi */ ! 127: "adv", "/=", /* ansi */ ! 128: "truth_andif", "&&", /* old */ ! 129: "aa", "&&", /* ansi */ ! 130: "truth_orif", "||", /* old */ ! 131: "oo", "||", /* ansi */ ! 132: "truth_not", "!", /* old */ ! 133: "nt", "!", /* ansi */ ! 134: "postincrement", "++", /* old */ ! 135: "pp", "++", /* ansi */ ! 136: "postdecrement", "--", /* old */ ! 137: "mm", "--", /* ansi */ ! 138: "bit_ior", "|", /* old */ ! 139: "or", "|", /* ansi */ ! 140: "aor", "|=", /* ansi */ ! 141: "bit_xor", "^", /* old */ ! 142: "er", "^", /* ansi */ ! 143: "aer", "^=", /* ansi */ ! 144: "bit_and", "&", /* old */ ! 145: "ad", "&", /* ansi */ ! 146: "aad", "&=", /* ansi */ ! 147: "bit_not", "~", /* old */ ! 148: "co", "~", /* ansi */ ! 149: "call", "()", /* old */ ! 150: "cl", "()", /* ansi */ ! 151: "cond", "?:", /* old */ ! 152: "alshift", "<<", /* old */ ! 153: "ls", "<<", /* ansi */ ! 154: "als", "<<=", /* ansi */ ! 155: "arshift", ">>", /* old */ ! 156: "rs", ">>", /* ansi */ ! 157: "ars", ">>=", /* ansi */ ! 158: "component", "->", /* old */ ! 159: "rf", "->", /* ansi */ ! 160: "indirect", "*", /* old */ ! 161: "method_call", "->()", /* old */ ! 162: "addr", "&", /* old (unary &) */ ! 163: "array", "[]", /* old */ ! 164: "vc", "[]", /* ansi */ ! 165: "compound", ",", /* old */ ! 166: "cm", ",", /* ansi */ ! 167: "nop", "", /* old (for operator=) */ ! 168: }; ! 169: ! 170: /* Beware: these aren't '\0' terminated. */ ! 171: ! 172: typedef struct { ! 173: char *b; /* pointer to start of string */ ! 174: char *p; /* pointer after last character */ ! 175: char *e; /* pointer after end of allocated space */ ! 176: } string; ! 177: ! 178: #ifdef __STDC__ ! 179: static void string_need (string *s, int n); ! 180: static void string_delete (string *s); ! 181: static void string_init (string *s); ! 182: static void string_clear (string *s); ! 183: static int string_empty (string *s); ! 184: static void string_append (string *p, const char *s); ! 185: static void string_appends (string *p, string *s); ! 186: static void string_appendn (string *p, const char *s, int n); ! 187: static void string_prepend (string *p, const char *s); ! 188: #if 0 ! 189: static void string_prepends (string *p, string *s); ! 190: #endif ! 191: static void string_prependn (string *p, const char *s, int n); ! 192: static int get_count (const char **type, int *count); ! 193: static int do_args (const char **type, string *decl); ! 194: static int do_type (const char **type, string *result); ! 195: static int do_arg (const char **type, string *result); ! 196: static int do_args (const char **type, string *decl); ! 197: static void munge_function_name (string *name); ! 198: static void remember_type (const char *type, int len); ! 199: #else ! 200: static void string_need (); ! 201: static void string_delete (); ! 202: static void string_init (); ! 203: static void string_clear (); ! 204: static int string_empty (); ! 205: static void string_append (); ! 206: static void string_appends (); ! 207: static void string_appendn (); ! 208: static void string_prepend (); ! 209: static void string_prepends (); ! 210: static void string_prependn (); ! 211: static int get_count (); ! 212: static int do_args (); ! 213: static int do_type (); ! 214: static int do_arg (); ! 215: static int do_args (); ! 216: static void munge_function_name (); ! 217: static void remember_type (); ! 218: #endif ! 219: ! 220: int ! 221: get_simple_count (type, res) ! 222: char **type; ! 223: int *res; ! 224: { ! 225: int n = 0, success = 1;; ! 226: ! 227: do ! 228: { ! 229: n *= 10; ! 230: n += **type - '0'; ! 231: *type += 1; ! 232: } ! 233: while (isdigit (**type)); ! 234: if (strlen (*type) < n) ! 235: { ! 236: success = 0; ! 237: } ! 238: ! 239: *res = n; ! 240: return success; ! 241: } ! 242: ! 243: char * ! 244: cplus_demangle (type) ! 245: const char *type; ! 246: { ! 247: string decl; ! 248: int n; ! 249: int success = 0; ! 250: int constructor = 0; ! 251: int destructor = 0; ! 252: int static_type = 0; ! 253: int const_flag = 0; ! 254: int i; ! 255: const char *p; ! 256: #ifndef LONGERNAMES ! 257: const char *premangle; ! 258: #endif ! 259: ! 260: if (type == NULL || *type == '\0') ! 261: return NULL; ! 262: #ifndef nounderscore ! 263: if (*type++ != '_') ! 264: return NULL; ! 265: #endif ! 266: p = type; ! 267: while (*p != '\0' && !(*p == '_' && p[1] == '_')) ! 268: p++; ! 269: if (*p == '\0') ! 270: { ! 271: /* destructor */ ! 272: if (type[0] == '_' && type[1] == CPLUS_MARKER && type[2] == '_') ! 273: { ! 274: destructor = 1; ! 275: p = type; ! 276: } ! 277: /* static data member */ ! 278: else if (*type != '_' && (strchr (type, CPLUS_MARKER) != NULL)) ! 279: { ! 280: static_type = 1; ! 281: p = type; ! 282: } ! 283: /* virtual table "_vt$" */ ! 284: else if (type[0] == '_' && type[1] == 'v' && type[2] == 't' && type[3] == CPLUS_MARKER) ! 285: { ! 286: int n = strlen (type + 4) + 14 + 1; ! 287: char *tem = (char *) xmalloc (n); ! 288: strcpy (tem, type + 4); ! 289: strcat (tem, " virtual table"); ! 290: return tem; ! 291: } ! 292: else return NULL; ! 293: } ! 294: ! 295: string_init (&decl); ! 296: ! 297: if (static_type) ! 298: { ! 299: if (!isdigit (p[0]) && ('t' != p[0])) ! 300: { ! 301: string_delete (&decl); ! 302: return NULL; ! 303: } ! 304: } ! 305: else if (destructor) ! 306: { ! 307: if (!isdigit (p[3])&& ('t' != p[3])) ! 308: { ! 309: string_delete (&decl); ! 310: return NULL; ! 311: } ! 312: p += 3; ! 313: } ! 314: else if (p == type) ! 315: { ! 316: if (!isdigit (p[2]) && ('t' != p[2])) ! 317: { ! 318: p += 1; ! 319: while (*p != '\0' && !(*p == '_' && p[1] == '_')) ! 320: p++; ! 321: string_appendn (&decl, type, p - type); ! 322: string_appendn (&decl, "", 1); ! 323: munge_function_name (&decl); ! 324: if (decl.b[0] == '_') ! 325: { ! 326: string_delete (&decl); ! 327: return NULL; ! 328: } ! 329: else ! 330: p += 2; ! 331: } ! 332: else ! 333: { ! 334: constructor = 1; ! 335: p += 2; ! 336: } ! 337: } ! 338: else ! 339: { ! 340: string_appendn (&decl, type, p - type); ! 341: decl.p[0] = '0'; ! 342: munge_function_name (&decl); ! 343: p += 2; ! 344: } ! 345: ! 346: #ifndef LONGERNAMES ! 347: premangle = p; ! 348: #endif ! 349: switch (*p) ! 350: { ! 351: case 'C': ! 352: /* a const member function */ ! 353: if (!isdigit (p[1])) ! 354: { ! 355: string_delete (&decl); ! 356: return NULL; ! 357: } ! 358: p += 1; ! 359: const_flag = 1; ! 360: /* fall through */ ! 361: case '0': ! 362: case '1': ! 363: case '2': ! 364: case '3': ! 365: case '4': ! 366: case '5': ! 367: case '6': ! 368: case '7': ! 369: case '8': ! 370: case '9': ! 371: n = 0; ! 372: do ! 373: { ! 374: n *= 10; ! 375: n += *p - '0'; ! 376: p += 1; ! 377: } ! 378: while (isdigit (*p)); ! 379: if (strlen (p) < n) ! 380: { ! 381: string_delete (&decl); ! 382: return NULL; ! 383: } ! 384: if (constructor || destructor) ! 385: { ! 386: string_appendn (&decl, p, n); ! 387: string_append (&decl, "::"); ! 388: if (destructor) ! 389: string_append(&decl, "~"); ! 390: string_appendn (&decl, p, n); ! 391: } ! 392: else ! 393: { ! 394: string_prepend (&decl, "::"); ! 395: string_prependn (&decl, p, n); ! 396: } ! 397: p += n; ! 398: #ifndef LONGERNAMES ! 399: remember_type (premangle, p - premangle); ! 400: #endif ! 401: if (static_type) ! 402: { ! 403: string_append(&decl, p+1); ! 404: p += strlen(p); ! 405: success = 1; ! 406: } ! 407: else ! 408: success = do_args (&p, &decl); ! 409: if (const_flag) ! 410: string_append (&decl, " const"); ! 411: break; ! 412: case 'F': ! 413: p += 1; ! 414: success = do_args (&p, &decl); ! 415: break; ! 416: /* template additions */ ! 417: case 't': ! 418: p += 1; ! 419: { ! 420: int r, i; ! 421: int non_empty = 0; ! 422: string tname; ! 423: string trawname; ! 424: ! 425: string temp; ! 426: int need_comma = 0; ! 427: ! 428: string_init(&tname); ! 429: string_init(&trawname); ! 430: ! 431: /* get template name */ ! 432: if (!get_simple_count (&p, &r)) ! 433: { ! 434: string_delete (&decl); ! 435: return 0; ! 436: } ! 437: string_appendn (&tname, p, r); ! 438: string_appendn (&trawname, p, r); ! 439: string_appendn (&trawname, "", 1); ! 440: p += r; ! 441: string_append (&tname, "<"); ! 442: /* get size of template parameter list */ ! 443: if (!get_count (&p, &r)) ! 444: return 0; ! 445: for (i = 0; i < r; i++) ! 446: { ! 447: if (need_comma) ! 448: string_append (&tname, ", "); ! 449: /* Z for type parameters */ ! 450: if (*p == 'Z') ! 451: { ! 452: p += 1; ! 453: ! 454: success = do_type (&p, &temp); ! 455: string_appendn (&temp, "", 1); ! 456: if (success) ! 457: string_append (&tname, temp.b); ! 458: string_delete(&temp); ! 459: if (!success) ! 460: break; ! 461: } ! 462: /* otherwise, value parameter */ ! 463: else ! 464: { ! 465: const char *old_p = p; ! 466: int is_pointer = 0; ! 467: int is_real = 0; ! 468: int is_integral = 0; ! 469: int done = 0; ! 470: ! 471: success = do_type (&p, &temp); ! 472: string_appendn (&temp, "", 1); ! 473: if (success) ! 474: string_append (&tname, temp.b); ! 475: string_delete(&temp); ! 476: if (!success) ! 477: break; ! 478: string_append (&tname, "="); ! 479: while (*old_p && !done) ! 480: { ! 481: switch (*old_p) ! 482: { ! 483: case 'P': ! 484: case 'R': ! 485: done = is_pointer = 1; ! 486: break; ! 487: case 'C': /* const */ ! 488: case 'U': /* unsigned */ ! 489: case 'V': /* volatile */ ! 490: case 'F': /* function */ ! 491: case 'M': /* member function */ ! 492: case 'O': /* ??? */ ! 493: old_p++; ! 494: continue; ! 495: case 'Q': /* repetition of following */ ! 496: case 'T': /* remembered type */ ! 497: abort(); ! 498: break; ! 499: case 'v': /* void */ ! 500: abort(); ! 501: break; ! 502: case 'x': /* long long */ ! 503: case 'l': /* long */ ! 504: case 'i': /* int */ ! 505: case 's': /* short */ ! 506: case 'c': /* char */ ! 507: done = is_integral = 1; ! 508: break; ! 509: case 'r': /* long double */ ! 510: case 'd': /* double */ ! 511: case 'f': /* float */ ! 512: done = is_real = 1; ! 513: break; ! 514: default: ! 515: abort(); ! 516: } ! 517: } ! 518: if (is_integral) ! 519: { ! 520: if (*p == 'm') ! 521: { ! 522: string_appendn (&tname, "-", 1); ! 523: p++; ! 524: } ! 525: while (isdigit (*p)) ! 526: { ! 527: string_appendn (&tname, p, 1); ! 528: p++; ! 529: } ! 530: } ! 531: else if (is_real) ! 532: { ! 533: if (*p == 'm') ! 534: { ! 535: string_appendn (&tname, "-", 1); ! 536: p++; ! 537: } ! 538: while (isdigit (*p)) ! 539: { ! 540: string_appendn (&tname, p, 1); ! 541: p++; ! 542: } ! 543: if (*p == '.') /* fraction */ ! 544: { ! 545: string_appendn (&tname, ".", 1); ! 546: p++; ! 547: while (isdigit (*p)) ! 548: { ! 549: string_appendn (&tname, p, 1); ! 550: p++; ! 551: } ! 552: } ! 553: if (*p == 'e') /* exponent */ ! 554: { ! 555: string_appendn (&tname, "e", 1); ! 556: p++; ! 557: while (isdigit (*p)) ! 558: { ! 559: string_appendn (&tname, p, 1); ! 560: p++; ! 561: } ! 562: } ! 563: } ! 564: else if (is_pointer) ! 565: { ! 566: int symbol_len; ! 567: ! 568: if (!get_count (&p, &symbol_len)) ! 569: { ! 570: success = 0; ! 571: break; ! 572: } ! 573: string_appendn (&tname, p, symbol_len); ! 574: p += symbol_len; ! 575: } ! 576: } ! 577: need_comma = 1; ! 578: } ! 579: string_append (&tname, ">::"); ! 580: if (destructor) ! 581: string_append(&tname, "~"); ! 582: if (constructor || destructor) { ! 583: string_appendn (&trawname, "", 1); ! 584: string_append (&tname, trawname.b); ! 585: } ! 586: string_delete(&trawname); ! 587: ! 588: if (!success) { ! 589: string_delete(&tname); ! 590: return 0; ! 591: } ! 592: string_appendn (&tname, "", 1); ! 593: string_prepend (&decl, tname.b); ! 594: string_delete (&tname); ! 595: ! 596: if (static_type) ! 597: { ! 598: string_append (&decl, p+1); ! 599: p += strlen (p); ! 600: success = 1; ! 601: } ! 602: else ! 603: success = do_args (&p, &decl); ! 604: break; ! 605: } ! 606: } ! 607: ! 608: for (i = 0; i < ntypes; i++) ! 609: if (typevec[i] != NULL) ! 610: free (typevec[i]); ! 611: ntypes = 0; ! 612: if (typevec != NULL) ! 613: { ! 614: free ((char *)typevec); ! 615: typevec = NULL; ! 616: typevec_size = 0; ! 617: } ! 618: ! 619: if (success) ! 620: { ! 621: string_appendn (&decl, "", 1); ! 622: return decl.b; ! 623: } ! 624: else ! 625: { ! 626: string_delete (&decl); ! 627: return NULL; ! 628: } ! 629: } ! 630: ! 631: static int ! 632: get_count (type, count) ! 633: const char **type; ! 634: int *count; ! 635: { ! 636: if (!isdigit (**type)) ! 637: return 0; ! 638: *count = **type - '0'; ! 639: *type += 1; ! 640: /* see flush_repeats in cp-method.c */ ! 641: if (isdigit (**type)) ! 642: { ! 643: const char *p = *type; ! 644: int n = *count; ! 645: do ! 646: { ! 647: n *= 10; ! 648: n += *p - '0'; ! 649: p += 1; ! 650: } ! 651: while (isdigit (*p)); ! 652: if (*p == '_') ! 653: { ! 654: *type = p + 1; ! 655: *count = n; ! 656: } ! 657: } ! 658: return 1; ! 659: } ! 660: ! 661: /* result will be initialised here; it will be freed on failure */ ! 662: ! 663: static int ! 664: do_type (type, result) ! 665: const char **type; ! 666: string *result; ! 667: { ! 668: int n; ! 669: int done; ! 670: int non_empty = 0; ! 671: int success; ! 672: string decl; ! 673: const char *remembered_type; ! 674: ! 675: string_init (&decl); ! 676: string_init (result); ! 677: ! 678: done = 0; ! 679: success = 1; ! 680: while (success && !done) ! 681: { ! 682: int member; ! 683: switch (**type) ! 684: { ! 685: case 'Q': ! 686: n = (*type)[1] - '0'; ! 687: if (n < 0 || n > 9) ! 688: success = 0; ! 689: *type += 2; ! 690: while (n-- > 0) ! 691: do_type (type, result); ! 692: break; ! 693: ! 694: case 'P': ! 695: *type += 1; ! 696: string_prepend (&decl, "*"); ! 697: break; ! 698: ! 699: case 'R': ! 700: *type += 1; ! 701: string_prepend (&decl, "&"); ! 702: break; ! 703: ! 704: case 'T': ! 705: *type += 1; ! 706: if (!get_count (type, &n) || n >= ntypes) ! 707: success = 0; ! 708: else ! 709: { ! 710: remembered_type = typevec[n]; ! 711: type = &remembered_type; ! 712: } ! 713: break; ! 714: ! 715: case 'F': ! 716: *type += 1; ! 717: if (!string_empty (&decl) && decl.b[0] == '*') ! 718: { ! 719: string_prepend (&decl, "("); ! 720: string_append (&decl, ")"); ! 721: } ! 722: if (!do_args (type, &decl) || **type != '_') ! 723: success = 0; ! 724: else ! 725: *type += 1; ! 726: break; ! 727: ! 728: case 'M': ! 729: case 'O': ! 730: { ! 731: int constp = 0; ! 732: int volatilep = 0; ! 733: ! 734: member = **type == 'M'; ! 735: *type += 1; ! 736: if (!isdigit (**type)) ! 737: { ! 738: success = 0; ! 739: break; ! 740: } ! 741: n = 0; ! 742: do ! 743: { ! 744: n *= 10; ! 745: n += **type - '0'; ! 746: *type += 1; ! 747: } ! 748: while (isdigit (**type)); ! 749: if (strlen (*type) < n) ! 750: { ! 751: success = 0; ! 752: break; ! 753: } ! 754: string_append (&decl, ")"); ! 755: string_prepend (&decl, "::"); ! 756: string_prependn (&decl, *type, n); ! 757: string_prepend (&decl, "("); ! 758: *type += n; ! 759: if (member) ! 760: { ! 761: if (**type == 'C') ! 762: { ! 763: *type += 1; ! 764: constp = 1; ! 765: } ! 766: if (**type == 'V') ! 767: { ! 768: *type += 1; ! 769: volatilep = 1; ! 770: } ! 771: if (*(*type)++ != 'F') ! 772: { ! 773: success = 0; ! 774: break; ! 775: } ! 776: } ! 777: if ((member && !do_args (type, &decl)) || **type != '_') ! 778: { ! 779: success = 0; ! 780: break; ! 781: } ! 782: *type += 1; ! 783: if (constp) ! 784: { ! 785: if (non_empty) ! 786: string_append (&decl, " "); ! 787: else ! 788: non_empty = 1; ! 789: string_append (&decl, "const"); ! 790: } ! 791: if (volatilep) ! 792: { ! 793: if (non_empty) ! 794: string_append (&decl, " "); ! 795: else ! 796: non_empty = 1; ! 797: string_append (&decl, "volatile"); ! 798: } ! 799: break; ! 800: } ! 801: ! 802: case 'C': ! 803: if ((*type)[1] == 'P') ! 804: { ! 805: *type += 1; ! 806: if (!string_empty (&decl)) ! 807: string_prepend (&decl, " "); ! 808: string_prepend (&decl, "const"); ! 809: break; ! 810: } ! 811: ! 812: /* fall through */ ! 813: default: ! 814: done = 1; ! 815: break; ! 816: } ! 817: } ! 818: ! 819: non_empty = 0; ! 820: if (success) ! 821: success = do_cuv_prefix (type, result, &non_empty); ! 822: ! 823: if (success) ! 824: success = do_builtin_type(type, result, &non_empty); ! 825: ! 826: if (success) ! 827: { ! 828: if (!string_empty (&decl)) ! 829: { ! 830: string_append (result, " "); ! 831: string_appends (result, &decl); ! 832: } ! 833: string_delete (&decl); ! 834: return 1; ! 835: } ! 836: else ! 837: { ! 838: string_delete (&decl); ! 839: string_delete (result); ! 840: return 0; ! 841: } ! 842: } ! 843: ! 844: int ! 845: do_cuv_prefix (type, result, non_empty) ! 846: char **type; ! 847: string* result; ! 848: int* non_empty; ! 849: { ! 850: int success = 1; ! 851: int done = 0; ! 852: ! 853: while (success && !done) ! 854: { ! 855: switch (**type) ! 856: { ! 857: case 'C': ! 858: *type += 1; ! 859: if (*non_empty) ! 860: string_append (result, " "); ! 861: else ! 862: *non_empty = 1; ! 863: string_append (result, "const"); ! 864: break; ! 865: case 'U': ! 866: *type += 1; ! 867: if (*non_empty) ! 868: string_append (result, " "); ! 869: else ! 870: *non_empty = 1; ! 871: string_append (result, "unsigned"); ! 872: break; ! 873: case 'V': ! 874: *type += 1; ! 875: if (*non_empty) ! 876: string_append (result, " "); ! 877: else ! 878: *non_empty = 1; ! 879: string_append (result, "volatile"); ! 880: break; ! 881: default: ! 882: done = 1; ! 883: break; ! 884: } ! 885: } ! 886: return success; ! 887: } ! 888: ! 889: int ! 890: do_builtin_type (type, result, non_empty) ! 891: char **type; ! 892: string* result; ! 893: int *non_empty; ! 894: { ! 895: int success = 1; ! 896: int n; ! 897: ! 898: switch (**type) ! 899: { ! 900: case '\0': ! 901: case '_': ! 902: break; ! 903: case 'v': ! 904: *type += 1; ! 905: if (*non_empty) ! 906: string_append (result, " "); ! 907: string_append (result, "void"); ! 908: break; ! 909: case 'x': ! 910: *type += 1; ! 911: if (*non_empty) ! 912: string_append (result, " "); ! 913: string_append (result, "long long"); ! 914: break; ! 915: case 'l': ! 916: *type += 1; ! 917: if (*non_empty) ! 918: string_append (result, " "); ! 919: string_append (result, "long"); ! 920: break; ! 921: case 'i': ! 922: *type += 1; ! 923: if (*non_empty) ! 924: string_append (result, " "); ! 925: string_append (result, "int"); ! 926: break; ! 927: case 's': ! 928: *type += 1; ! 929: if (*non_empty) ! 930: string_append (result, " "); ! 931: string_append (result, "short"); ! 932: break; ! 933: case 'c': ! 934: *type += 1; ! 935: if (*non_empty) ! 936: string_append (result, " "); ! 937: string_append (result, "char"); ! 938: break; ! 939: case 'r': ! 940: *type += 1; ! 941: if (*non_empty) ! 942: string_append (result, " "); ! 943: string_append (result, "long double"); ! 944: break; ! 945: case 'd': ! 946: *type += 1; ! 947: if (*non_empty) ! 948: string_append (result, " "); ! 949: string_append (result, "double"); ! 950: break; ! 951: case 'f': ! 952: *type += 1; ! 953: if (*non_empty) ! 954: string_append (result, " "); ! 955: string_append (result, "float"); ! 956: break; ! 957: case 'G': ! 958: *type += 1; ! 959: if (!isdigit (**type)) ! 960: { ! 961: success = 0; ! 962: break; ! 963: } ! 964: /* fall through */ ! 965: case '0': ! 966: case '1': ! 967: case '2': ! 968: case '3': ! 969: case '4': ! 970: case '5': ! 971: case '6': ! 972: case '7': ! 973: case '8': ! 974: case '9': ! 975: n = 0; ! 976: do ! 977: { ! 978: n *= 10; ! 979: n += **type - '0'; ! 980: *type += 1; ! 981: } ! 982: while (isdigit (**type)); ! 983: if (strlen (*type) < n) ! 984: { ! 985: success = 0; ! 986: break; ! 987: } ! 988: if (*non_empty) ! 989: string_append (result, " "); ! 990: string_appendn (result, *type, n); ! 991: *type += n; ! 992: break; ! 993: default: ! 994: success = 0; ! 995: break; ! 996: } ! 997: return success; ! 998: } ! 999: ! 1000: /* `result' will be initialised in do_type; it will be freed on failure */ ! 1001: ! 1002: static int ! 1003: do_arg (type, result) ! 1004: const char **type; ! 1005: string *result; ! 1006: { ! 1007: const char *start = *type; ! 1008: ! 1009: if (!do_type (type, result)) ! 1010: return 0; ! 1011: remember_type (start, *type - start); ! 1012: return 1; ! 1013: } ! 1014: ! 1015: static void ! 1016: remember_type (start, len) ! 1017: const char *start; ! 1018: int len; ! 1019: { ! 1020: char *tem; ! 1021: ! 1022: if (ntypes >= typevec_size) ! 1023: { ! 1024: if (typevec_size == 0) ! 1025: { ! 1026: typevec_size = 3; ! 1027: typevec = (char **) xmalloc (sizeof (char*)*typevec_size); ! 1028: } ! 1029: else ! 1030: { ! 1031: typevec_size *= 2; ! 1032: typevec = (char **) xrealloc ((char *)typevec, sizeof (char*)*typevec_size); ! 1033: } ! 1034: } ! 1035: tem = (char *) xmalloc (len + 1); ! 1036: memcpy (tem, start, len); ! 1037: tem[len] = '\0'; ! 1038: typevec[ntypes++] = tem; ! 1039: } ! 1040: ! 1041: /* `decl' must be already initialised, usually non-empty; ! 1042: it won't be freed on failure */ ! 1043: ! 1044: static int ! 1045: do_args (type, decl) ! 1046: const char **type; ! 1047: string *decl; ! 1048: { ! 1049: string arg; ! 1050: int need_comma = 0; ! 1051: ! 1052: string_append (decl, "("); ! 1053: ! 1054: while (**type != '_' && **type != '\0' && **type != 'e' && **type != 'v') ! 1055: { ! 1056: if (**type == 'N') ! 1057: { ! 1058: int r; ! 1059: int t; ! 1060: *type += 1; ! 1061: if (!get_count (type, &r) || !get_count (type, &t) || t >= ntypes) ! 1062: return 0; ! 1063: while (--r >= 0) ! 1064: { ! 1065: const char *tem = typevec[t]; ! 1066: if (need_comma) ! 1067: string_append (decl, ", "); ! 1068: if (!do_arg (&tem, &arg)) ! 1069: return 0; ! 1070: string_appends (decl, &arg); ! 1071: string_delete (&arg); ! 1072: need_comma = 1; ! 1073: } ! 1074: } ! 1075: else ! 1076: { ! 1077: if (need_comma) ! 1078: string_append (decl, ", "); ! 1079: if (!do_arg (type, &arg)) ! 1080: return 0; ! 1081: string_appends (decl, &arg); ! 1082: string_delete (&arg); ! 1083: need_comma = 1; ! 1084: } ! 1085: } ! 1086: ! 1087: if (**type == 'v') ! 1088: *type += 1; ! 1089: else if (**type == 'e') ! 1090: { ! 1091: *type += 1; ! 1092: if (need_comma) ! 1093: string_append (decl, ","); ! 1094: string_append (decl, "..."); ! 1095: } ! 1096: ! 1097: string_append (decl, ")"); ! 1098: return 1; ! 1099: } ! 1100: ! 1101: static void ! 1102: munge_function_name (name) ! 1103: string *name; ! 1104: { ! 1105: if (string_empty (name)) ! 1106: return; ! 1107: ! 1108: if (name->p - name->b >= 3 ! 1109: && name->b[0] == 'o' && name->b[1] == 'p' && name->b[2] == CPLUS_MARKER) ! 1110: { ! 1111: int i; ! 1112: /* see if it's an assignment expression */ ! 1113: if (name->p - name->b >= 10 /* op$assign_ */ ! 1114: && memcmp (name->b + 3, "assign_", 7) == 0) ! 1115: { ! 1116: for (i = 0; i < sizeof (optable)/sizeof (optable[0]); i++) ! 1117: { ! 1118: int len = name->p - name->b - 10; ! 1119: if (strlen (optable[i].in) == len ! 1120: && memcmp (optable[i].in, name->b + 10, len) == 0) ! 1121: { ! 1122: string_clear (name); ! 1123: string_append (name, "operator"); ! 1124: string_append (name, optable[i].out); ! 1125: string_append (name, "="); ! 1126: return; ! 1127: } ! 1128: } ! 1129: } ! 1130: else ! 1131: { ! 1132: for (i = 0; i < sizeof (optable)/sizeof (optable[0]); i++) ! 1133: { ! 1134: int len = name->p - name->b - 3; ! 1135: if (strlen (optable[i].in) == len ! 1136: && memcmp (optable[i].in, name->b + 3, len) == 0) ! 1137: { ! 1138: string_clear (name); ! 1139: string_append (name, "operator"); ! 1140: string_append (name, optable[i].out); ! 1141: return; ! 1142: } ! 1143: } ! 1144: } ! 1145: return; ! 1146: } ! 1147: else if (name->p - name->b >= 5 && memcmp (name->b, "type$", 5) == 0) ! 1148: { ! 1149: /* type conversion operator */ ! 1150: string type; ! 1151: const char *tem = name->b + 5; ! 1152: if (do_type (&tem, &type)) ! 1153: { ! 1154: string_clear (name); ! 1155: string_append (name, "operator "); ! 1156: string_appends (name, &type); ! 1157: string_delete (&type); ! 1158: return; ! 1159: } ! 1160: } ! 1161: /* ANSI. */ ! 1162: else if (name->b[2] == 'o' && name->b[3] == 'p') ! 1163: { ! 1164: /* type conversion operator. */ ! 1165: string type; ! 1166: const char *tem = name->b + 4; ! 1167: if (do_type (&tem, &type)) ! 1168: { ! 1169: string_clear (name); ! 1170: string_append (name, "operator "); ! 1171: string_appends (name, &type); ! 1172: string_delete (&type); ! 1173: return; ! 1174: } ! 1175: } ! 1176: else if (name->b[2] >= 'a' && name->b[2] <= 'z' ! 1177: && name->b[3] >= 'a' && name->b[3] <= 'z') ! 1178: { ! 1179: int i; ! 1180: ! 1181: if (name->b[4] == '\0') ! 1182: { ! 1183: /* Operator. */ ! 1184: for (i = 0; i < sizeof (optable)/sizeof (optable[0]); i++) ! 1185: { ! 1186: if (strlen (optable[i].in) == 2 ! 1187: && memcmp (optable[i].in, name->b + 2, 2) == 0) ! 1188: { ! 1189: string_clear (name); ! 1190: string_append (name, "operator"); ! 1191: string_append (name, optable[i].out); ! 1192: return; ! 1193: } ! 1194: } ! 1195: } ! 1196: else ! 1197: { ! 1198: if (name->b[2] != 'a' || name->b[5] != '\0') ! 1199: return; ! 1200: /* Assignment. */ ! 1201: for (i = 0; i < sizeof (optable)/sizeof (optable[0]); i++) ! 1202: { ! 1203: if (strlen (optable[i].in) == 3 ! 1204: && memcmp (optable[i].in, name->b + 2, 3) == 0) ! 1205: { ! 1206: string_clear (name); ! 1207: string_append (name, "operator"); ! 1208: string_append (name, optable[i].out); ! 1209: return; ! 1210: } ! 1211: } ! 1212: } ! 1213: } ! 1214: } ! 1215: ! 1216: /* a mini string-handling package */ ! 1217: ! 1218: static void ! 1219: string_need (s, n) ! 1220: string *s; ! 1221: int n; ! 1222: { ! 1223: if (s->b == NULL) ! 1224: { ! 1225: if (n < 32) ! 1226: n = 32; ! 1227: s->p = s->b = (char *) xmalloc (n); ! 1228: s->e = s->b + n; ! 1229: } ! 1230: else if (s->e - s->p < n) ! 1231: { ! 1232: int tem = s->p - s->b; ! 1233: n += tem; ! 1234: n *= 2; ! 1235: s->b = (char *) xrealloc (s->b, n); ! 1236: s->p = s->b + tem; ! 1237: s->e = s->b + n; ! 1238: } ! 1239: } ! 1240: ! 1241: static void ! 1242: string_delete (s) ! 1243: string *s; ! 1244: { ! 1245: if (s->b != NULL) ! 1246: { ! 1247: free (s->b); ! 1248: s->b = s->e = s->p = NULL; ! 1249: } ! 1250: } ! 1251: ! 1252: static void ! 1253: string_init (s) ! 1254: string *s; ! 1255: { ! 1256: s->b = s->p = s->e = NULL; ! 1257: } ! 1258: ! 1259: static void ! 1260: string_clear (s) ! 1261: string *s; ! 1262: { ! 1263: s->p = s->b; ! 1264: } ! 1265: ! 1266: static int ! 1267: string_empty (s) ! 1268: string *s; ! 1269: { ! 1270: return s->b == s->p; ! 1271: } ! 1272: ! 1273: static void ! 1274: string_append (p, s) ! 1275: string *p; ! 1276: const char *s; ! 1277: { ! 1278: int n; ! 1279: if (s == NULL || *s == '\0') ! 1280: return; ! 1281: n = strlen (s); ! 1282: string_need (p, n); ! 1283: memcpy (p->p, s, n); ! 1284: p->p += n; ! 1285: } ! 1286: ! 1287: static void ! 1288: string_appends (p, s) ! 1289: string *p, *s; ! 1290: { ! 1291: int n; ! 1292: if (s->b == s->p) ! 1293: return; ! 1294: n = s->p - s->b; ! 1295: string_need (p, n); ! 1296: memcpy (p->p, s->b, n); ! 1297: p->p += n; ! 1298: } ! 1299: ! 1300: static void ! 1301: string_appendn (p, s, n) ! 1302: string *p; ! 1303: const char *s; ! 1304: int n; ! 1305: { ! 1306: if (n == 0) ! 1307: return; ! 1308: string_need (p, n); ! 1309: memcpy (p->p, s, n); ! 1310: p->p += n; ! 1311: } ! 1312: ! 1313: static void ! 1314: string_prepend (p, s) ! 1315: string *p; ! 1316: const char *s; ! 1317: { ! 1318: if (s == NULL || *s == '\0') ! 1319: return; ! 1320: string_prependn (p, s, strlen (s)); ! 1321: } ! 1322: ! 1323: #if 0 ! 1324: static void ! 1325: string_prepends (p, s) ! 1326: string *p, *s; ! 1327: { ! 1328: if (s->b == s->p) ! 1329: return; ! 1330: string_prependn (p, s->b, s->p - s->b); ! 1331: } ! 1332: #endif ! 1333: ! 1334: static void ! 1335: string_prependn (p, s, n) ! 1336: string *p; ! 1337: const char *s; ! 1338: int n; ! 1339: { ! 1340: char *q; ! 1341: ! 1342: if (n == 0) ! 1343: return; ! 1344: string_need (p, n); ! 1345: for (q = p->p - 1; q >= p->b; q--) ! 1346: q[n] = q[0]; ! 1347: memcpy (p->b, s, n); ! 1348: p->p += n; ! 1349: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.