![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to stabstring.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / pgrm / dbx|
Return to stabstring.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / pgrm / dbx |
1.1 ! root 1: /* ! 2: * Copyright (c) 1983 The Regents of the University of California. ! 3: * All rights reserved. ! 4: * ! 5: * Redistribution and use in source and binary forms are permitted ! 6: * provided that: (1) source distributions retain this entire copyright ! 7: * notice and comment, and (2) distributions including binaries display ! 8: * the following acknowledgement: ``This product includes software ! 9: * developed by the University of California, Berkeley and its contributors'' ! 10: * in the documentation or other materials provided with the distribution ! 11: * and in all advertising materials mentioning features or use of this ! 12: * software. Neither the name of the University nor the names of its ! 13: * contributors may be used to endorse or promote products derived ! 14: * from this software without specific prior written permission. ! 15: * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ! 16: * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ! 17: * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. ! 18: */ ! 19: ! 20: #ifndef lint ! 21: static char sccsid[] = "@(#)stabstring.c 5.5 (Berkeley) 6/1/90"; ! 22: #endif /* not lint */ ! 23: ! 24: /* ! 25: * String information interpretation ! 26: * ! 27: * The string part of a stab entry is broken up into name and type information. ! 28: */ ! 29: ! 30: #include "defs.h" ! 31: #include "stabstring.h" ! 32: #include "object.h" ! 33: #include "main.h" ! 34: #include "symbols.h" ! 35: #include "names.h" ! 36: #include "languages.h" ! 37: #include "tree.h" ! 38: #include <a.out.h> ! 39: #include <ctype.h> ! 40: ! 41: #ifndef public ! 42: #endif ! 43: ! 44: /* ! 45: * Special characters in symbol table information. ! 46: */ ! 47: ! 48: #define CONSTNAME 'c' ! 49: #define TYPENAME 't' ! 50: #define TAGNAME 'T' ! 51: #define MODULEBEGIN 'm' ! 52: #define EXTPROCEDURE 'P' ! 53: #define PRIVPROCEDURE 'Q' ! 54: #define INTPROCEDURE 'I' ! 55: #define EXTFUNCTION 'F' ! 56: #define PRIVFUNCTION 'f' ! 57: #define INTFUNCTION 'J' ! 58: #define EXTVAR 'G' ! 59: #define MODULEVAR 'S' ! 60: #define OWNVAR 'V' ! 61: #define REGVAR 'r' ! 62: #define VALUEPARAM 'p' ! 63: #define VARIABLEPARAM 'v' ! 64: #define LOCALVAR /* default */ ! 65: ! 66: /* ! 67: * Type information special characters. ! 68: */ ! 69: ! 70: #define T_SUBRANGE 'r' ! 71: #define T_ARRAY 'a' ! 72: #define T_OLDOPENARRAY 'A' ! 73: #define T_OPENARRAY 'O' ! 74: #define T_DYNARRAY 'D' ! 75: #define T_SUBARRAY 'E' ! 76: #define T_RECORD 's' ! 77: #define T_UNION 'u' ! 78: #define T_ENUM 'e' ! 79: #define T_PTR '*' ! 80: #define T_FUNCVAR 'f' ! 81: #define T_PROCVAR 'p' ! 82: #define T_IMPORTED 'i' ! 83: #define T_SET 'S' ! 84: #define T_OPAQUE 'o' ! 85: #define T_FILE 'd' ! 86: ! 87: /* ! 88: * Table of types indexed by per-file unique identification number. ! 89: */ ! 90: ! 91: #define NTYPES 1000 ! 92: ! 93: private Symbol typetable[NTYPES]; ! 94: ! 95: public initTypeTable () ! 96: { ! 97: bzero(typetable, sizeof(typetable)); ! 98: (*language_op(curlang, L_MODINIT))(typetable); ! 99: } ! 100: ! 101: /* ! 102: * Put an nlist entry into the symbol table. ! 103: * If it's already there just add the associated information. ! 104: * ! 105: * Type information is encoded in the name following a ":". ! 106: */ ! 107: ! 108: private Symbol constype(); ! 109: private Char *curchar; ! 110: ! 111: #define skipchar(ptr, ch) \ ! 112: { \ ! 113: if (*ptr != ch) { \ ! 114: panic("expected char '%c', found '%s'", ch, ptr); \ ! 115: } \ ! 116: ++ptr; \ ! 117: } ! 118: ! 119: #define optchar(ptr, ch) \ ! 120: { \ ! 121: if (*ptr == ch) { \ ! 122: ++ptr; \ ! 123: } \ ! 124: } ! 125: ! 126: #ifdef sun ! 127: # define chkcont(ptr) \ ! 128: { \ ! 129: if (*ptr == '\\' or *ptr == '?') { \ ! 130: ptr = getcont(); \ ! 131: } \ ! 132: } ! 133: #else if notsun ! 134: # define chkcont(ptr) \ ! 135: { \ ! 136: if (*ptr == '?') { \ ! 137: ptr = getcont(); \ ! 138: } \ ! 139: } ! 140: #endif ! 141: ! 142: #define newSym(s, n) \ ! 143: { \ ! 144: s = insert(n); \ ! 145: s->level = curblock->level + 1; \ ! 146: s->language = curlang; \ ! 147: s->block = curblock; \ ! 148: } ! 149: ! 150: #define makeVariable(s, n, off) \ ! 151: { \ ! 152: newSym(s, n); \ ! 153: s->class = VAR; \ ! 154: s->symvalue.offset = off; \ ! 155: getType(s); \ ! 156: } ! 157: ! 158: #define makeParameter(s, n, cl, off) \ ! 159: { \ ! 160: if ((s = lookup(n)) == nil or s->block != curblock) { \ ! 161: newSym(s, n); \ ! 162: s->storage = STK; \ ! 163: s->class = cl; \ ! 164: s->symvalue.offset = off; \ ! 165: getType(s); \ ! 166: } \ ! 167: curparam->chain = s; \ ! 168: curparam = s; \ ! 169: } ! 170: ! 171: public entersym (name, np) ! 172: String name; ! 173: struct nlist *np; ! 174: { ! 175: Symbol s; ! 176: register char *p, *q, *r; ! 177: register Name n; ! 178: char c; ! 179: ! 180: p = index(name, ':'); ! 181: *p = '\0'; ! 182: c = *(p+1); ! 183: if (autostrip and streq(language_name(curlang), "c++")) { ! 184: /* ! 185: * Strip off redundant prefixes from C++ names. ! 186: * Static variables are prefixed with _static_. ! 187: * Formal arguments of functions are prefixed with _au0_. ! 188: * Automatic variables are prefixed with _au[1-9][0-9]*_. ! 189: * Class members are prefixed with _T_, where T is a class tag. ! 190: */ ! 191: if (strncmp("_static_", name, 8) == 0 and name[8] != '\0') { ! 192: name += 8; ! 193: } ! 194: q = name; ! 195: if (*q++ == '_' and *q++ == 'a' and *q++ == 'u' and isdigit(*q++)) { ! 196: while (isdigit(*q)) ! 197: ++q; ! 198: if (*q++ == '_' and *q != '\0') ! 199: name = q; ! 200: } ! 201: q = name; ! 202: if (*q++ == '_' and c == EXTFUNCTION) { ! 203: /* ! 204: * Punt on static class members, for speed. ! 205: */ ! 206: for (r = q; (r = index(r, '_')) != nil; ++r) { ! 207: if (r == q) { ! 208: continue; ! 209: } ! 210: *r = '\0'; ! 211: s = lookup(identname(q, true)); ! 212: if (s != nil and s->class == TYPE) { ! 213: char *newname = r + 1; ! 214: if (*newname != '\0') { ! 215: name = newname; ! 216: break; ! 217: } ! 218: } ! 219: *r = '_'; ! 220: } ! 221: } ! 222: } ! 223: n = identname(name, true); ! 224: chkUnnamedBlock(); ! 225: curchar = p + 2; ! 226: switch (c) { ! 227: case CONSTNAME: ! 228: newSym(s, n); ! 229: constName(s); ! 230: break; ! 231: ! 232: case TYPENAME: ! 233: newSym(s, n); ! 234: typeName(s); ! 235: break; ! 236: ! 237: case TAGNAME: ! 238: s = symbol_alloc(); ! 239: s->name = n; ! 240: s->level = curblock->level + 1; ! 241: s->language = curlang; ! 242: s->block = curblock; ! 243: tagName(s); ! 244: break; ! 245: ! 246: case MODULEBEGIN: ! 247: publicRoutine(&s, n, MODULE, np->n_value, false); ! 248: curmodule = s; ! 249: break; ! 250: ! 251: case EXTPROCEDURE: ! 252: publicRoutine(&s, n, PROC, np->n_value, false); ! 253: break; ! 254: ! 255: case PRIVPROCEDURE: ! 256: privateRoutine(&s, n, PROC, np->n_value); ! 257: break; ! 258: ! 259: case INTPROCEDURE: ! 260: publicRoutine(&s, n, PROC, np->n_value, true); ! 261: break; ! 262: ! 263: case EXTFUNCTION: ! 264: publicRoutine(&s, n, FUNC, np->n_value, false); ! 265: break; ! 266: ! 267: case PRIVFUNCTION: ! 268: privateRoutine(&s, n, FUNC, np->n_value); ! 269: break; ! 270: ! 271: case INTFUNCTION: ! 272: publicRoutine(&s, n, FUNC, np->n_value, true); ! 273: break; ! 274: ! 275: case EXTVAR: ! 276: extVar(&s, n, np->n_value); ! 277: break; ! 278: ! 279: case MODULEVAR: ! 280: if (curblock->class != MODULE) { ! 281: exitblock(); ! 282: } ! 283: makeVariable(s, n, np->n_value); ! 284: s->storage = EXT; ! 285: s->level = program->level; ! 286: s->block = curmodule; ! 287: getExtRef(s); ! 288: break; ! 289: ! 290: case OWNVAR: ! 291: makeVariable(s, n, np->n_value); ! 292: ownVariable(s, np->n_value); ! 293: getExtRef(s); ! 294: break; ! 295: ! 296: case REGVAR: ! 297: makeVariable(s, n, np->n_value); ! 298: s->storage = INREG; ! 299: break; ! 300: ! 301: case VALUEPARAM: ! 302: makeParameter(s, n, VAR, np->n_value); ! 303: # ifdef IRIS ! 304: /* ! 305: * Bug in SGI C compiler -- generates stab offset ! 306: * for parameters with size added in. ! 307: */ ! 308: if (s->storage == STK and curlang == findlanguage(".c")) { ! 309: s->symvalue.offset -= size(s); ! 310: } ! 311: # endif ! 312: break; ! 313: ! 314: case VARIABLEPARAM: ! 315: makeParameter(s, n, REF, np->n_value); ! 316: break; ! 317: ! 318: default: /* local variable */ ! 319: --curchar; ! 320: makeVariable(s, n, np->n_value); ! 321: s->storage = STK; ! 322: break; ! 323: } ! 324: if (tracesyms) { ! 325: printdecl(s); ! 326: fflush(stdout); ! 327: } ! 328: } ! 329: ! 330: /* ! 331: * Enter a named constant. ! 332: */ ! 333: ! 334: private constName (s) ! 335: Symbol s; ! 336: { ! 337: integer i; ! 338: double d; ! 339: char *p, buf[1000]; ! 340: ! 341: s->class = CONST; ! 342: skipchar(curchar, '='); ! 343: p = curchar; ! 344: ++curchar; ! 345: switch (*p) { ! 346: case 'b': ! 347: s->type = t_boolean; ! 348: s->symvalue.constval = build(O_LCON, getint()); ! 349: break; ! 350: ! 351: case 'c': ! 352: s->type = t_char; ! 353: s->symvalue.constval = build(O_LCON, getint()); ! 354: break; ! 355: ! 356: case 'i': ! 357: s->type = t_int; ! 358: s->symvalue.constval = build(O_LCON, getint()); ! 359: break; ! 360: ! 361: case 'r': ! 362: sscanf(curchar, "%lf", &d); ! 363: while (*curchar != '\0' and *curchar != ';') { ! 364: ++curchar; ! 365: } ! 366: --curchar; ! 367: s->type = t_real; ! 368: s->symvalue.constval = build(O_FCON, d); ! 369: break; ! 370: ! 371: case 's': ! 372: p = &buf[0]; ! 373: skipchar(curchar, '\''); ! 374: while (*curchar != '\'') { ! 375: *p = *curchar; ! 376: ++p; ! 377: ++curchar; ! 378: } ! 379: *p = '\0'; ! 380: s->symvalue.constval = build(O_SCON, strdup(buf)); ! 381: s->type = s->symvalue.constval->nodetype; ! 382: break; ! 383: ! 384: case 'e': ! 385: getType(s); ! 386: skipchar(curchar, ','); ! 387: s->symvalue.constval = build(O_LCON, getint()); ! 388: break; ! 389: ! 390: case 'S': ! 391: getType(s); ! 392: skipchar(curchar, ','); ! 393: i = getint(); /* set size */ ! 394: skipchar(curchar, ','); ! 395: i = getint(); /* number of bits in constant */ ! 396: s->symvalue.constval = build(O_LCON, 0); ! 397: break; ! 398: ! 399: default: ! 400: s->type = t_int; ! 401: s->symvalue.constval = build(O_LCON, 0); ! 402: printf("[internal error: unknown constant type '%c']", *p); ! 403: break; ! 404: } ! 405: s->symvalue.constval->nodetype = s->type; ! 406: } ! 407: ! 408: /* ! 409: * Enter a type name. ! 410: */ ! 411: ! 412: private typeName (s) ! 413: Symbol s; ! 414: { ! 415: register integer i; ! 416: ! 417: s->class = TYPE; ! 418: s->language = curlang; ! 419: s->block = curblock; ! 420: s->level = curblock->level + 1; ! 421: i = getint(); ! 422: if (i == 0) { ! 423: panic("bad input on type \"%s\" at \"%s\"", symname(s), curchar); ! 424: } else if (i >= NTYPES) { ! 425: panic("too many types in file \"%s\"", curfilename()); ! 426: } ! 427: /* ! 428: * A hack for C typedefs that don't create new types, ! 429: * e.g. typedef unsigned int Hashvalue; ! 430: * or typedef struct blah BLAH; ! 431: */ ! 432: if (*curchar != '=') { ! 433: s->type = typetable[i]; ! 434: if (s->type == nil) { ! 435: s->type = symbol_alloc(); ! 436: typetable[i] = s->type; ! 437: } ! 438: } else { ! 439: if (typetable[i] != nil) { ! 440: typetable[i]->language = curlang; ! 441: typetable[i]->class = TYPE; ! 442: typetable[i]->type = s; ! 443: } else { ! 444: typetable[i] = s; ! 445: } ! 446: skipchar(curchar, '='); ! 447: getType(s); ! 448: } ! 449: } ! 450: ! 451: /* ! 452: * Enter a tag name. ! 453: */ ! 454: ! 455: private tagName (s) ! 456: Symbol s; ! 457: { ! 458: register integer i; ! 459: ! 460: s->class = TAG; ! 461: i = getint(); ! 462: if (i == 0) { ! 463: panic("bad input on tag \"%s\" at \"%s\"", symname(s), curchar); ! 464: } else if (i >= NTYPES) { ! 465: panic("too many types in file \"%s\"", curfilename()); ! 466: } ! 467: if (typetable[i] != nil) { ! 468: typetable[i]->language = curlang; ! 469: typetable[i]->class = TYPE; ! 470: typetable[i]->type = s; ! 471: } else { ! 472: typetable[i] = s; ! 473: } ! 474: skipchar(curchar, '='); ! 475: getType(s); ! 476: } ! 477: ! 478: /* ! 479: * Setup a symbol entry for a public procedure or function. ! 480: * ! 481: * If it contains nested procedures, then it may already be defined ! 482: * in the current block as a MODULE. ! 483: */ ! 484: ! 485: private publicRoutine (s, n, class, addr, isinternal) ! 486: Symbol *s; ! 487: Name n; ! 488: Symclass class; ! 489: Address addr; ! 490: boolean isinternal; ! 491: { ! 492: Symbol nt, t; ! 493: ! 494: newSym(nt, n); ! 495: if (isinternal) { ! 496: markInternal(nt); ! 497: } ! 498: enterRoutine(nt, class); ! 499: find(t, n) where ! 500: t != nt and t->class == MODULE and t->block == nt->block ! 501: endfind(t); ! 502: if (t == nil) { ! 503: t = nt; ! 504: } else { ! 505: t->language = nt->language; ! 506: t->class = nt->class; ! 507: t->type = nt->type; ! 508: t->chain = nt->chain; ! 509: t->symvalue = nt->symvalue; ! 510: nt->class = EXTREF; ! 511: nt->symvalue.extref = t; ! 512: delete(nt); ! 513: curparam = t; ! 514: changeBlock(t); ! 515: } ! 516: if (t->block == program) { ! 517: t->level = program->level; ! 518: } else if (t->class == MODULE) { ! 519: t->level = t->block->level; ! 520: } else if (t->block->class == MODULE) { ! 521: t->level = t->block->block->level; ! 522: } else { ! 523: t->level = t->block->level + 1; ! 524: } ! 525: *s = t; ! 526: } ! 527: ! 528: /* ! 529: * Setup a symbol entry for a private procedure or function. ! 530: */ ! 531: ! 532: private privateRoutine (s, n, class, addr) ! 533: Symbol *s; ! 534: Name n; ! 535: Symclass class; ! 536: Address addr; ! 537: { ! 538: Symbol t; ! 539: boolean isnew; ! 540: ! 541: find(t, n) where ! 542: t->level == curmodule->level and t->class == class ! 543: endfind(t); ! 544: if (t == nil) { ! 545: isnew = true; ! 546: t = insert(n); ! 547: } else { ! 548: isnew = false; ! 549: } ! 550: t->language = curlang; ! 551: enterRoutine(t, class); ! 552: if (isnew) { ! 553: t->symvalue.funcv.src = false; ! 554: t->symvalue.funcv.inline = false; ! 555: t->symvalue.funcv.beginaddr = addr; ! 556: newfunc(t, codeloc(t)); ! 557: findbeginning(t); ! 558: } ! 559: *s = t; ! 560: } ! 561: ! 562: /* ! 563: * Set up for beginning a new procedure, function, or module. ! 564: * If it's a function, then read the type. ! 565: * ! 566: * If the next character is a ",", then read the name of the enclosing block. ! 567: * Otherwise assume the previous function, if any, is over, and the current ! 568: * routine is at the same level. ! 569: */ ! 570: ! 571: private enterRoutine (s, class) ! 572: Symbol s; ! 573: Symclass class; ! 574: { ! 575: s->class = class; ! 576: if (class == FUNC) { ! 577: getType(s); ! 578: } ! 579: if (s->class != MODULE) { ! 580: getExtRef(s); ! 581: } else if (*curchar == ',') { ! 582: ++curchar; ! 583: } ! 584: if (*curchar != '\0') { ! 585: exitblock(); ! 586: enterNestedBlock(s); ! 587: } else { ! 588: if (curblock->class == FUNC or curblock->class == PROC) { ! 589: exitblock(); ! 590: } ! 591: if (class == MODULE) { ! 592: exitblock(); ! 593: } ! 594: enterblock(s); ! 595: } ! 596: curparam = s; ! 597: } ! 598: ! 599: /* ! 600: * Handling an external variable is tricky, since we might already ! 601: * know it but need to define it's type for other type information ! 602: * in the file. So just in case we read the type information anyway. ! 603: */ ! 604: ! 605: private extVar (symp, n, off) ! 606: Symbol *symp; ! 607: Name n; ! 608: integer off; ! 609: { ! 610: Symbol s, t; ! 611: ! 612: find(s, n) where ! 613: s->level == program->level and s->class == VAR ! 614: endfind(s); ! 615: if (s == nil) { ! 616: makeVariable(s, n, off); ! 617: s->storage = EXT; ! 618: s->level = program->level; ! 619: s->block = curmodule; ! 620: getExtRef(s); ! 621: } else { ! 622: t = constype(nil); ! 623: } ! 624: *symp = s; ! 625: } ! 626: ! 627: /* ! 628: * Check to see if the stab string contains the name of the external ! 629: * reference. If so, we create a symbol with that name and class EXTREF, and ! 630: * connect it to the given symbol. This link is created so that when ! 631: * we see the linker symbol we can resolve it to the given symbol. ! 632: */ ! 633: ! 634: private getExtRef (s) ! 635: Symbol s; ! 636: { ! 637: char *p; ! 638: Name n; ! 639: Symbol t; ! 640: ! 641: if (*curchar == ',' and *(curchar + 1) != '\0') { ! 642: p = index(curchar + 1, ','); ! 643: *curchar = '\0'; ! 644: if (p != nil) { ! 645: *p = '\0'; ! 646: n = identname(curchar + 1, false); ! 647: curchar = p + 1; ! 648: } else { ! 649: n = identname(curchar + 1, true); ! 650: } ! 651: t = insert(n); ! 652: t->language = s->language; ! 653: t->class = EXTREF; ! 654: t->block = program; ! 655: t->level = program->level; ! 656: t->symvalue.extref = s; ! 657: } ! 658: } ! 659: ! 660: /* ! 661: * Find a block with the given identifier in the given outer block. ! 662: * If not there, then create it. ! 663: */ ! 664: ! 665: private Symbol findBlock (id, m) ! 666: String id; ! 667: Symbol m; ! 668: { ! 669: Name n; ! 670: Symbol s; ! 671: ! 672: n = identname(id, true); ! 673: find(s, n) where s->block == m and isblock(s) endfind(s); ! 674: if (s == nil) { ! 675: s = insert(n); ! 676: s->block = m; ! 677: s->language = curlang; ! 678: s->class = MODULE; ! 679: s->level = m->level + 1; ! 680: } ! 681: return s; ! 682: } ! 683: ! 684: /* ! 685: * Enter a nested block. ! 686: * The block within which it is nested is described ! 687: * by "module{:module}[:proc]". ! 688: */ ! 689: ! 690: private enterNestedBlock (b) ! 691: Symbol b; ! 692: { ! 693: register char *p, *q; ! 694: Symbol m, s; ! 695: Name n; ! 696: ! 697: q = curchar; ! 698: p = index(q, ':'); ! 699: m = program; ! 700: while (p != nil) { ! 701: *p = '\0'; ! 702: m = findBlock(q, m); ! 703: q = p + 1; ! 704: p = index(q, ':'); ! 705: } ! 706: if (*q != '\0') { ! 707: m = findBlock(q, m); ! 708: } ! 709: b->level = m->level + 1; ! 710: b->block = m; ! 711: pushBlock(b); ! 712: } ! 713: ! 714: /* ! 715: * Enter a statically-allocated variable defined within a routine. ! 716: * ! 717: * Global BSS variables are chained together so we can resolve them ! 718: * when the start of common is determined. The list is kept in order ! 719: * so that f77 can display all vars in a COMMON. ! 720: */ ! 721: ! 722: private ownVariable (s, addr) ! 723: Symbol s; ! 724: Address addr; ! 725: { ! 726: s->storage = EXT; ! 727: /* s->level = 1; */ ! 728: if (curcomm) { ! 729: if (commchain != nil) { ! 730: commchain->symvalue.common.chain = s; ! 731: } else { ! 732: curcomm->symvalue.common.offset = (integer) s; ! 733: } ! 734: commchain = s; ! 735: s->symvalue.common.offset = addr; ! 736: s->symvalue.common.chain = nil; ! 737: } ! 738: } ! 739: ! 740: /* ! 741: * Get a type from the current stab string for the given symbol. ! 742: */ ! 743: ! 744: private getType (s) ! 745: Symbol s; ! 746: { ! 747: Symbol t, addtag(); ! 748: ! 749: if (s->class == TAG) { ! 750: t = addtag(s); ! 751: t->type = constype(nil); ! 752: s->type = t->type; ! 753: } else { ! 754: s->type = constype(nil); ! 755: } ! 756: } ! 757: ! 758: /* ! 759: * Construct a type out of a string encoding. ! 760: */ ! 761: ! 762: private Rangetype getRangeBoundType(); ! 763: ! 764: private Symbol constype (type) ! 765: Symbol type; ! 766: { ! 767: register Symbol t; ! 768: register integer n; ! 769: char class; ! 770: char *p; ! 771: ! 772: while (*curchar == '@') { ! 773: p = index(curchar, ';'); ! 774: if (p == nil) { ! 775: fflush(stdout); ! 776: fprintf(stderr, "missing ';' after type attributes"); ! 777: } else { ! 778: curchar = p + 1; ! 779: } ! 780: } ! 781: if (isdigit(*curchar)) { ! 782: n = getint(); ! 783: if (n >= NTYPES) { ! 784: panic("too many types in file \"%s\"", curfilename()); ! 785: } ! 786: if (*curchar == '=') { ! 787: if (typetable[n] != nil) { ! 788: t = typetable[n]; ! 789: } else { ! 790: t = symbol_alloc(); ! 791: typetable[n] = t; ! 792: } ! 793: ++curchar; ! 794: constype(t); ! 795: } else { ! 796: t = typetable[n]; ! 797: if (t == nil) { ! 798: t = symbol_alloc(); ! 799: typetable[n] = t; ! 800: } ! 801: } ! 802: } else { ! 803: if (type == nil) { ! 804: t = symbol_alloc(); ! 805: } else { ! 806: t = type; ! 807: } ! 808: t->language = curlang; ! 809: t->level = curblock->level + 1; ! 810: t->block = curblock; ! 811: class = *curchar++; ! 812: switch (class) { ! 813: case T_SUBRANGE: ! 814: consSubrange(t); ! 815: break; ! 816: ! 817: case T_ARRAY: ! 818: t->class = ARRAY; ! 819: t->chain = constype(nil); ! 820: skipchar(curchar, ';'); ! 821: chkcont(curchar); ! 822: t->type = constype(nil); ! 823: break; ! 824: ! 825: case T_OLDOPENARRAY: ! 826: t->class = DYNARRAY; ! 827: t->symvalue.ndims = 1; ! 828: t->type = constype(nil); ! 829: t->chain = t_int; ! 830: break; ! 831: ! 832: case T_OPENARRAY: ! 833: consDynarray(t, OPENARRAY); ! 834: break; ! 835: ! 836: case T_DYNARRAY: ! 837: consDynarray(t, DYNARRAY); ! 838: break; ! 839: ! 840: case T_SUBARRAY: ! 841: t->class = SUBARRAY; ! 842: t->symvalue.ndims = getint(); ! 843: skipchar(curchar, ','); ! 844: t->type = constype(nil); ! 845: t->chain = t_int; ! 846: break; ! 847: ! 848: case T_RECORD: ! 849: consRecord(t, RECORD); ! 850: break; ! 851: ! 852: case T_UNION: ! 853: consRecord(t, VARNT); ! 854: break; ! 855: ! 856: case T_ENUM: ! 857: consEnum(t); ! 858: break; ! 859: ! 860: case T_PTR: ! 861: t->class = PTR; ! 862: t->type = constype(nil); ! 863: break; ! 864: ! 865: /* ! 866: * C function variables are different from Modula-2's. ! 867: */ ! 868: case T_FUNCVAR: ! 869: t->class = FFUNC; ! 870: t->type = constype(nil); ! 871: if (streq(language_name(curlang), "modula-2")) { ! 872: skipchar(curchar, ','); ! 873: consParamlist(t); ! 874: } ! 875: break; ! 876: ! 877: case T_PROCVAR: ! 878: t->class = FPROC; ! 879: consParamlist(t); ! 880: break; ! 881: ! 882: case T_IMPORTED: ! 883: consImpType(t); ! 884: break; ! 885: ! 886: case T_SET: ! 887: t->class = SET; ! 888: t->type = constype(nil); ! 889: break; ! 890: ! 891: case T_OPAQUE: ! 892: consOpaqType(t); ! 893: break; ! 894: ! 895: case T_FILE: ! 896: t->class = FILET; ! 897: t->type = constype(nil); ! 898: break; ! 899: ! 900: default: ! 901: badcaseval(class); ! 902: } ! 903: } ! 904: return t; ! 905: } ! 906: ! 907: /* ! 908: * Construct a subrange type. ! 909: */ ! 910: ! 911: private consSubrange (t) ! 912: Symbol t; ! 913: { ! 914: t->class = RANGE; ! 915: t->type = constype(nil); ! 916: skipchar(curchar, ';'); ! 917: chkcont(curchar); ! 918: t->symvalue.rangev.lowertype = getRangeBoundType(); ! 919: t->symvalue.rangev.lower = getint(); ! 920: skipchar(curchar, ';'); ! 921: chkcont(curchar); ! 922: t->symvalue.rangev.uppertype = getRangeBoundType(); ! 923: t->symvalue.rangev.upper = getint(); ! 924: } ! 925: ! 926: /* ! 927: * Figure out the bound type of a range. ! 928: * ! 929: * Some letters indicate a dynamic bound, ie what follows ! 930: * is the offset from the fp which contains the bound; this will ! 931: * need a different encoding when pc a['A'..'Z'] is ! 932: * added; J is a special flag to handle fortran a(*) bounds ! 933: */ ! 934: ! 935: private Rangetype getRangeBoundType () ! 936: { ! 937: Rangetype r; ! 938: ! 939: switch (*curchar) { ! 940: case 'A': ! 941: r = R_ARG; ! 942: curchar++; ! 943: break; ! 944: ! 945: case 'T': ! 946: r = R_TEMP; ! 947: curchar++; ! 948: break; ! 949: ! 950: case 'J': ! 951: r = R_ADJUST; ! 952: curchar++; ! 953: break; ! 954: ! 955: default: ! 956: r = R_CONST; ! 957: break; ! 958: } ! 959: return r; ! 960: } ! 961: ! 962: /* ! 963: * Construct a dynamic array descriptor. ! 964: */ ! 965: ! 966: private consDynarray (t, c) ! 967: register Symbol t; ! 968: Symclass c; ! 969: { ! 970: t->class = c; ! 971: t->symvalue.ndims = getint(); ! 972: skipchar(curchar, ','); ! 973: t->type = constype(nil); ! 974: t->chain = t_int; ! 975: } ! 976: ! 977: /* ! 978: * Construct a record or union type. ! 979: */ ! 980: ! 981: private consRecord (t, class) ! 982: Symbol t; ! 983: Symclass class; ! 984: { ! 985: register Symbol u; ! 986: register char *cur, *p; ! 987: Name name; ! 988: integer d; ! 989: ! 990: t->class = class; ! 991: t->symvalue.offset = getint(); ! 992: d = curblock->level + 1; ! 993: u = t; ! 994: chkcont(curchar); ! 995: cur = curchar; ! 996: while (*cur != ';' and *cur != '\0') { ! 997: p = index(cur, ':'); ! 998: if (p == nil) { ! 999: panic("index(\"%s\", ':') failed", curchar); ! 1000: } ! 1001: *p = '\0'; ! 1002: if ( ! 1003: autostrip and ! 1004: *cur == '_' and ! 1005: streq(language_name(curlang), "c++") ! 1006: ) { ! 1007: /* ! 1008: * Strip off redundant prefixes from C++ names. ! 1009: * Class members are prefixed with _T_, where T is a class tag. ! 1010: */ ! 1011: register char *q, *r; ! 1012: Symbol s; ! 1013: ! 1014: /* ! 1015: * The slow way... Check for members defined in the base class. ! 1016: */ ! 1017: for (q = cur + 1, r = q; (r = index(r, '_')) != nil; ++r) { ! 1018: if (r == q) { ! 1019: continue; ! 1020: } ! 1021: *r = '\0'; ! 1022: s = lookup(identname(q, true)); ! 1023: if (s != nil and s->class == TYPE) { ! 1024: char *newcur = r + 1; ! 1025: if (*newcur != '\0') { ! 1026: cur = newcur; ! 1027: break; ! 1028: } ! 1029: } ! 1030: *r = '_'; ! 1031: } ! 1032: } ! 1033: name = identname(cur, true); ! 1034: u->chain = newSymbol(name, d, FIELD, nil, nil); ! 1035: cur = p + 1; ! 1036: u = u->chain; ! 1037: u->language = curlang; ! 1038: curchar = cur; ! 1039: u->type = constype(nil); ! 1040: skipchar(curchar, ','); ! 1041: u->symvalue.field.offset = getint(); ! 1042: skipchar(curchar, ','); ! 1043: u->symvalue.field.length = getint(); ! 1044: skipchar(curchar, ';'); ! 1045: chkcont(curchar); ! 1046: cur = curchar; ! 1047: } ! 1048: if (*cur == ';') { ! 1049: ++cur; ! 1050: } ! 1051: curchar = cur; ! 1052: } ! 1053: ! 1054: /* ! 1055: * Construct an enumeration type. ! 1056: */ ! 1057: ! 1058: private consEnum (t) ! 1059: Symbol t; ! 1060: { ! 1061: register Symbol u; ! 1062: register char *p; ! 1063: register integer count; ! 1064: ! 1065: t->class = SCAL; ! 1066: count = 0; ! 1067: u = t; ! 1068: while (*curchar != ';' and *curchar != '\0' and *curchar != ',') { ! 1069: p = index(curchar, ':'); ! 1070: assert(p != nil); ! 1071: *p = '\0'; ! 1072: u->chain = insert(identname(curchar, true)); ! 1073: curchar = p + 1; ! 1074: u = u->chain; ! 1075: u->language = curlang; ! 1076: u->class = CONST; ! 1077: u->level = curblock->level + 1; ! 1078: u->block = curblock; ! 1079: u->type = t; ! 1080: u->symvalue.constval = build(O_LCON, (long) getint()); ! 1081: ++count; ! 1082: skipchar(curchar, ','); ! 1083: chkcont(curchar); ! 1084: } ! 1085: if (*curchar == ';') { ! 1086: ++curchar; ! 1087: } ! 1088: t->symvalue.iconval = count; ! 1089: } ! 1090: ! 1091: /* ! 1092: * Construct a parameter list for a function or procedure variable. ! 1093: */ ! 1094: ! 1095: private consParamlist (t) ! 1096: Symbol t; ! 1097: { ! 1098: Symbol p; ! 1099: integer i, d, n, paramclass; ! 1100: ! 1101: n = getint(); ! 1102: skipchar(curchar, ';'); ! 1103: p = t; ! 1104: d = curblock->level + 1; ! 1105: for (i = 0; i < n; i++) { ! 1106: p->chain = newSymbol(nil, d, VAR, nil, nil); ! 1107: p = p->chain; ! 1108: p->type = constype(nil); ! 1109: skipchar(curchar, ','); ! 1110: paramclass = getint(); ! 1111: if (paramclass == 0) { ! 1112: p->class = REF; ! 1113: } ! 1114: skipchar(curchar, ';'); ! 1115: chkcont(curchar); ! 1116: } ! 1117: } ! 1118: ! 1119: /* ! 1120: * Construct an imported type. ! 1121: * Add it to a list of symbols to get fixed up. ! 1122: */ ! 1123: ! 1124: private consImpType (t) ! 1125: Symbol t; ! 1126: { ! 1127: register char *p; ! 1128: Symbol tmp; ! 1129: ! 1130: p = curchar; ! 1131: while (*p != ',' and *p != ';' and *p != '\0') { ! 1132: ++p; ! 1133: } ! 1134: if (*p == '\0') { ! 1135: panic("bad import symbol entry '%s'", curchar); ! 1136: } ! 1137: t->class = TYPEREF; ! 1138: t->symvalue.typeref = curchar; ! 1139: if (*p == ',') { ! 1140: curchar = p + 1; ! 1141: tmp = constype(nil); ! 1142: } else { ! 1143: curchar = p; ! 1144: } ! 1145: skipchar(curchar, ';'); ! 1146: *p = '\0'; ! 1147: } ! 1148: ! 1149: /* ! 1150: * Construct an opaque type entry. ! 1151: */ ! 1152: ! 1153: private consOpaqType (t) ! 1154: Symbol t; ! 1155: { ! 1156: register char *p; ! 1157: register Symbol s; ! 1158: register Name n; ! 1159: boolean def; ! 1160: ! 1161: p = curchar; ! 1162: while (*p != ';' and *p != ',') { ! 1163: if (*p == '\0') { ! 1164: panic("bad opaque symbol entry '%s'", curchar); ! 1165: } ! 1166: ++p; ! 1167: } ! 1168: def = (Boolean) (*p == ','); ! 1169: *p = '\0'; ! 1170: n = identname(curchar, true); ! 1171: find(s, n) where s->class == TYPEREF endfind(s); ! 1172: if (s == nil) { ! 1173: s = insert(n); ! 1174: s->class = TYPEREF; ! 1175: s->type = nil; ! 1176: } ! 1177: curchar = p + 1; ! 1178: if (def) { ! 1179: s->type = constype(nil); ! 1180: skipchar(curchar, ';'); ! 1181: } ! 1182: t->class = TYPE; ! 1183: t->type = s; ! 1184: } ! 1185: ! 1186: /* ! 1187: * Read an integer from the current position in the type string. ! 1188: */ ! 1189: ! 1190: private integer getint () ! 1191: { ! 1192: register integer n; ! 1193: register char *p; ! 1194: register Boolean isneg; ! 1195: ! 1196: n = 0; ! 1197: p = curchar; ! 1198: if (*p == '-') { ! 1199: isneg = true; ! 1200: ++p; ! 1201: } else { ! 1202: isneg = false; ! 1203: } ! 1204: while (isdigit(*p)) { ! 1205: n = 10*n + (*p - '0'); ! 1206: ++p; ! 1207: } ! 1208: curchar = p; ! 1209: return isneg ? (-n) : n; ! 1210: } ! 1211: ! 1212: /* ! 1213: * Add a tag name. This is a kludge to be able to refer ! 1214: * to tags that have the same name as some other symbol ! 1215: * in the same block. ! 1216: */ ! 1217: ! 1218: private Symbol addtag (s) ! 1219: register Symbol s; ! 1220: { ! 1221: register Symbol t; ! 1222: char buf[100]; ! 1223: ! 1224: if (streq(language_name(curlang), "c++")) { ! 1225: t = insert(s->name); ! 1226: t->class = TYPE; ! 1227: } else { ! 1228: sprintf(buf, "$$%.90s", ident(s->name)); ! 1229: t = insert(identname(buf, false)); ! 1230: t->class = TAG; ! 1231: } ! 1232: t->language = s->language; ! 1233: t->block = s->block; ! 1234: return t; ! 1235: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.