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