![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to bsdsymtab.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / jtools / src / pi|
Return to bsdsymtab.c CVS log | Up to [Research Unix] / researchv9 / jtools / src / pi |
1.1 ! root 1: #include <a.out.h> ! 2: #include "symtab.pri" ! 3: #include "dtype.pri" ! 4: #include "symbol.h" ! 5: #include "stab.h" ! 6: #include "core.pub" ! 7: SRCFILE("bsdsymtab.c") ! 8: ! 9: char *strchr(char *, int); ! 10: char *memset(char *, int, int); ! 11: char *memcpy(char *, char *, int); ! 12: int nccdemangle(char **, char *); ! 13: void SymbolStats(); ! 14: ! 15: BsdSymTab::BsdSymTab(Core* c, int fd, SymTab *i, long r):(c, fd, i, r) ! 16: { ! 17: hdr = new exec; ! 18: bsdshare = 0; ! 19: } ! 20: ! 21: BsdSymTab::~BsdSymTab() ! 22: { ! 23: delete hdr; ! 24: if (bsdshare) ! 25: delete bsdshare; ! 26: } ! 27: ! 28: char *BsdSymTab::gethdr() ! 29: { ! 30: if( lseek( fd, 0L, 0 ) == -1 || !ReadOK(fd, (char*)hdr, sizeof *hdr) ) ! 31: return SysErr( "symbol table: " ); ! 32: _magic = hdr->a_magic; ! 33: // if( N_BADMAG(*hdr) || hdr->a_trsize || hdr->a_drsize ) ! 34: if( N_BADMAG(*hdr) ) ! 35: return "symbol table: not executable text"; ! 36: entries = hdr->a_syms/sizeof(nlist); ! 37: return 0; ! 38: } ! 39: ! 40: int BsdSymTab::endtext() ! 41: { ! 42: exec h = *hdr; ! 43: return N_DATADDR(h); ! 44: } ! 45: ! 46: Block *BsdSymTab::gatherfunc(Func *func) ! 47: { ! 48: register struct nlist *f, *n; ! 49: register Block *ablk, *lblk; ! 50: Var *arg = 0, *lcl = 0; ! 51: register Stmt *stmt = 0; ! 52: long bfun = func->begin, size = func->size, i; ! 53: char *so = func->source()->_text; ! 54: BsdType *bsd = func->source()->bsdp; ! 55: char *subtype; ! 56: ! 57: ++FunctionGathered; ! 58: SymbolStats(); ! 59: IF_LIVE( bfun < 0 || bfun+size > entries ) return 0; ! 60: if (size == 0) ! 61: return fakeblk(); ! 62: if( !(n = f = nlistvector(bfun,size+1)) ) return 0; ! 63: IF_LIVE( n->n_type != N_FUN ) return 0; ! 64: ablk = new Block( this, 0, 0, sf("%s().arg_blk",n->n_un.n_name) ); ! 65: lblk = new Block( this, ablk, 0, sf("%s().lcl_blk",n->n_un.n_name) ); ! 66: ablk->child = lblk; ! 67: for( i = 0; i < size; ++i, ++n ){ ! 68: switch( n->n_type ){ ! 69: case N_PSYM: ! 70: gathervar( n, &arg, ablk, U_ARG, bsd ); ! 71: break; ! 72: case N_LSYM: ! 73: subtype = strchr(n->n_un.n_name, ':'); ! 74: if (!subtype || *++subtype != '(') ! 75: break; ! 76: gathervar( n, &lcl, lblk, U_AUT, bsd ); ! 77: break; ! 78: case N_STSYM: ! 79: case N_LCSYM: ! 80: subtype = strchr(n->n_un.n_name, ':'); ! 81: if (!subtype || *++subtype != 'V') ! 82: break; ! 83: n->n_value += relocation; ! 84: gathervar( n, &lcl, lblk, U_STA, bsd ); ! 85: break; ! 86: case N_RSYM: ! 87: gathervar( n, &lcl, lblk, U_REG, bsd ); ! 88: break; ! 89: case N_FUN: ! 90: case N_SLINE: ! 91: n->n_value += relocation; ! 92: if( stmt ) { ! 93: if ( n->n_desc > stmt->lineno ) ! 94: func->lines.hi = n->n_desc; ! 95: stmt->range.hi = n->n_value; ! 96: } ! 97: stmt = new Stmt(this,lblk,stmt); ! 98: if( !ablk->stmt ) ablk->stmt = stmt; ! 99: stmt->lineno = n->n_desc; ! 100: stmt->range.lo = n->n_value; ! 101: if( !ablk->range.lo ) ! 102: ablk->range.lo = n->n_value; ! 103: ablk->range.hi = n->n_value; ! 104: break; ! 105: } ! 106: } ! 107: if( stmt ) ! 108: stmt->range.hi = n->n_value + relocation; ! 109: delete f; ! 110: uncfront( ablk->var, (char *)0 ); ! 111: uncfront( lblk->var, (char *)0 ); ! 112: return ablk; ! 113: } ! 114: ! 115: void BsdSymTab::gathervar( nlist *n, Var **v, Block *b, UDisc d, BsdType *bt ) ! 116: { ! 117: IF_LIVE( !v ) return; ! 118: if( *n->n_un.n_name == ' ') ! 119: return; ! 120: char *marker = strchr( n->n_un.n_name, ':'); ! 121: if (!marker) ! 122: marker = n->n_un.n_name + strlen(n->n_un.n_name); ! 123: else if (marker[1] == ':') { //Special Ncc symbol ! 124: marker = strchr( &marker[2], ':'); ! 125: if (!marker) { ! 126: marker = n->n_un.n_name + strlen(n->n_un.n_name); ! 127: while (*++marker == 0) ! 128: ; ! 129: marker--; ! 130: } ! 131: } ! 132: *marker++ = 0; ! 133: *v = new Var( this, b, *v, d, n->n_un.n_name ); ! 134: if( b && !b->var ) b->var = *v; ! 135: (*v)->range.lo = n->n_value; ! 136: (*v)->type = bt->gettype(marker); ! 137: } ! 138: ! 139: void BsdSymTab::gathervar( nlist *n, Var **v, Block *b, UDisc d) ! 140: { ! 141: DType dt; ! 142: ! 143: IF_LIVE( !v ) return; ! 144: *v = new Var( this, b, *v, d, n->n_un.n_name ); ! 145: if( b && !b->var ) b->var = *v; ! 146: (*v)->range.lo = n->n_value; ! 147: (*v)->type = dt; ! 148: (*v)->type.pcc = n->n_desc; ! 149: } ! 150: ! 151: char *BsdSymTab::gettbl() ! 152: { ! 153: base = new nlist[entries]; ! 154: symoff = (nlist*)N_SYMOFF(*hdr); ! 155: if( lseek(fd, (long)symoff, 0) == 1 ! 156: || !ReadOK(fd, (char*)base, hdr->a_syms) ! 157: || !ReadOK(fd, (char*)&strsize, 4) ){ ! 158: delete base; base = 0; ! 159: return SysErr( "symbol table: " ); ! 160: } ! 161: strings = new char[strsize]; ! 162: if( lseek( fd, -4, 1 ) == -1 || !ReadOK(fd, strings, strsize) ){ ! 163: delete strings; strings = 0; ! 164: delete base; base = 0; ! 165: return SysErr( "strings table: " ); ! 166: } ! 167: strcpy( strings, "???" ); /* zero string index */ ! 168: return 0; ! 169: } ! 170: ! 171: Source *BsdSymTab::tree() ! 172: { ! 173: register nlist *n, *base_entries; ! 174: Source *src = 0; ! 175: Func *func = 0; ! 176: Block *fake = fakeblk(); ! 177: Var *glb = 0, *fst = 0, *resolve; ! 178: // UType *u; ! 179: register long regstrings, inafunc = 0, inasrc = 0; ! 180: long lastline, funcstart = 0, lgfound = 0; ! 181: char *equal, *subtype; ! 182: BsdType *bsd = 0; ! 183: DType *t; ! 184: ! 185: if( _warn = gettbl() ) return 0; ! 186: base_entries = base+entries; ! 187: regstrings = (long) strings; ! 188: glb = globregs(_blk, _core->nregs() ); ! 189: bsdshare = new BsdTShare; ! 190: for( n = base; n < base_entries; ++n ){ ! 191: n->n_un.n_strx += (long) regstrings; ! 192: if( inasrc && n->n_un.n_name && (equal = strchr(n->n_un.n_name, '='))) ! 193: bsd->parsetype(equal, n->n_un.n_name); ! 194: switch( n->n_type ){ ! 195: case N_ABS|N_EXT: ! 196: if( n->n_un.n_name[0] != '_' ) break; /* ? */ ! 197: case N_BSS|N_EXT: ! 198: case N_DATA|N_EXT: ! 199: if( *n->n_un.n_name == '_' ) ++n->n_un.n_name; ! 200: nccdemangle(&n->n_un.n_name, (char *)0); ! 201: resolve = (Var*)idtosym(U_GLB, n->n_un.n_name, 0); ! 202: n->n_value += relocation; ! 203: if( resolve ){ ! 204: if( !resolve->range.lo ) ! 205: resolve->range.lo = n->n_value; ! 206: } else { ! 207: n->n_desc = LONG; ! 208: gathervar( n, &glb, _blk, U_GLB ); ! 209: break; ! 210: } ! 211: break; ! 212: case N_GSYM: ! 213: if( !inasrc ) break; ! 214: subtype = strchr(n->n_un.n_name, ':'); ! 215: if (!subtype) ! 216: break; ! 217: *subtype = 0; ! 218: nccdemangle(&n->n_un.n_name, (char *)0); ! 219: if( !idtosym(U_GLB, n->n_un.n_name, 0) ) ! 220: gathervar( n, &glb, _blk, U_GLB, bsd ); ! 221: break; ! 222: case N_LCSYM: ! 223: case N_STSYM: ! 224: if( !inasrc || !src || !src->blk ) break; ! 225: subtype = strchr(n->n_un.n_name, ':') + 1; ! 226: if (*subtype != 'S') ! 227: break; ! 228: n->n_value += relocation; ! 229: gathervar( n, &fst, src->blk, U_FST, bsd ); ! 230: break; ! 231: case N_SLINE: ! 232: lastline = n->n_desc; ! 233: if (funcstart) { ! 234: funcstart = 0; ! 235: func->lines.lo = lastline; ! 236: } ! 237: break; ! 238: case N_BINCL: // Include files for type indexing ! 239: bsd->addinclude(n->n_un.n_name, 1); ! 240: break; ! 241: case N_EXCL: ! 242: bsd->addinclude(n->n_un.n_name, 0); ! 243: break; ! 244: case N_SO: ! 245: if (inafunc) { ! 246: inafunc = 0; ! 247: func->lines.hi = lastline; ! 248: func->size = n-base - func->begin; ! 249: } ! 250: // Directory entry in 4.0? ! 251: if (n->n_un.n_name[strlen(n->n_un.n_name)-1] == '/') { ! 252: inasrc = 0; ! 253: break; ! 254: } ! 255: if (!strcmp(n->n_un.n_name, "libg.s")) { ! 256: lgfound = 1; ! 257: inasrc = 0; ! 258: break; ! 259: } ! 260: inasrc = 1; ! 261: src = new Source(this,src,n->n_un.n_name,0); ! 262: bsd = src->bsdp = new BsdType(src, bsdshare); ! 263: func = 0; ! 264: inafunc = 0; ! 265: fst = 0; ! 266: n += 12; // Through away type info ! 267: break; ! 268: case N_TEXT|N_EXT: ! 269: if( *n->n_un.n_name == '_' ) ++n->n_un.n_name; ! 270: nccdemangle(&n->n_un.n_name, (char *)0); ! 271: if( idtosym(U_FUNC, n->n_un.n_name, 0) ) break; ! 272: func = new Func(this,0,0,0,n->n_un.n_name); ! 273: func->range.lo = n->n_value + relocation; ! 274: func->_blk = fake; ! 275: t = new DType; ! 276: t->pcc = LONG; ! 277: func->type = t->incref(); ! 278: func->type.pcc = FTN; ! 279: break; ! 280: case N_FUN: ! 281: if (inafunc) { ! 282: inafunc = 0; ! 283: func->lines.hi = lastline; ! 284: func->size = n-base - func->begin; ! 285: } ! 286: if( !inasrc || !src ) break; ! 287: inafunc = 1; ! 288: ++FunctionStubs; ! 289: subtype = strchr(n->n_un.n_name, ':'); ! 290: *subtype++ = 0; ! 291: nccdemangle(&n->n_un.n_name, (char *)0); ! 292: func = new Func(this,src,func,n-base,n->n_un.n_name); ! 293: if( !src->child ) src->child = src->linefunc = func; ! 294: funcstart = 1; ! 295: func->range.lo = n->n_value + relocation; ! 296: t = new DType; ! 297: *t = bsd->gettype(subtype); ! 298: func->type = t->incref(); ! 299: func->type.pcc = FTN; ! 300: break; ! 301: } ! 302: } ! 303: while( src && src->lsib ) src = (Source*) src->lsib; ! 304: if( base ) { delete base; base = 0; } ! 305: if (!lgfound) ! 306: _warn = "should be linked with ld -g"; ! 307: return src; ! 308: } ! 309: ! 310: Var *BsdSymTab::gatherutype(UType *u) ! 311: { ! 312: Var *first = 0, *v = 0; ! 313: char *memname, *cp; ! 314: int file, offset; ! 315: int bitsize, bitoffset; ! 316: int isenum = (u->type.pcc == ENUMTY); ! 317: ! 318: memname = u->encode; ! 319: if (!memname) ! 320: return first; ! 321: ++UTypeGathered; ! 322: SymbolStats(); ! 323: while (*memname != ';') { ! 324: cp = strchr(memname, ':'); ! 325: *cp++ = 0; ! 326: if (isenum) { ! 327: v = new Var( this, 0, v, U_MOT, memname ); ! 328: v->range.lo = u->bsdp->toint(cp); ! 329: v->type.pcc = MOETY; ! 330: if( !first ) first = v; ! 331: memname = strchr(cp, ',') + 1; ! 332: continue; ! 333: } ! 334: u->bsdp->toindices(cp, file, offset); ! 335: cp = strchr(cp, ')') + 2; ! 336: bitoffset = u->bsdp->toint(cp); ! 337: cp = strchr(cp, ',') + 1; ! 338: bitsize = u->bsdp->toint(cp); ! 339: v = new Var( this, 0, v, U_MOT, memname ); ! 340: v->type = u->bsdp->gettype(file, offset); ! 341: if ((bitsize & 0x7) || (bitoffset & 0x7)) { ! 342: v->range.lo = ((bitoffset >> 5) << 5) + ! 343: 32 - bitsize - (bitoffset & 0x1f); ! 344: v->type.pcc = UBITS; ! 345: v->type.dim = bitsize; ! 346: } else ! 347: v->range.lo = bitoffset >> 3; ! 348: if( !first ) first = v; ! 349: memname = strchr(cp, ';') + 1; ! 350: } ! 351: uncfront(first, u->_text); ! 352: return first; ! 353: } ! 354: ! 355: nlist *BsdSymTab::nlistvector(long start, long size ) ! 356: { ! 357: struct nlist *n; ! 358: int i; ! 359: ! 360: lseek(fd, (long) (symoff + start), 0); ! 361: n = new nlist[size]; ! 362: IF_LIVE( !ReadOK(fd, (char*) n, size * sizeof *n) ){ ! 363: delete n; ! 364: return 0; ! 365: } ! 366: for( i = 0; i < size; ++i ) ! 367: n[i].n_un.n_strx += (long) strings; ! 368: return n; ! 369: } ! 370: ! 371: BsdTShare::BsdTShare() ! 372: { ! 373: } ! 374: ! 375: BsdTShare::~BsdTShare() ! 376: { ! 377: for(BsdTFile *f = file; f < &file[used]; f++) { ! 378: for (int i = 0; i < f->ntypes; i++) ! 379: delete f->type[i]; ! 380: delete f->type; ! 381: } ! 382: delete file; ! 383: } ! 384: ! 385: int BsdTShare::addfile(char *fname, int flag) ! 386: { ! 387: BsdTFile *f; ! 388: int i; ! 389: ! 390: if (used == nfiles) { // Grow the number of files ! 391: nfiles += 10; ! 392: f = new BsdTFile[nfiles]; ! 393: for (i = 0; i < used; i++) ! 394: f[i] = file[i]; ! 395: delete file; ! 396: file = f; ! 397: } ! 398: f = &file[used]; ! 399: f->fname = fname; // Initialize ! 400: f->ntypes = 20; ! 401: f->type = new DTypep[20]; ! 402: if (flag) { // add builtins ! 403: static int typeindex[] = { ! 404: 0, INT, CHAR, LONG, SHORT, UCHAR, USHORT, ! 405: ULONG, UNSIGNED, FLOAT, DOUBLE, INT, UNDEF ! 406: }; ! 407: for(i = 1; i < sizeof(typeindex)/sizeof(int); i++) { ! 408: f->type[i] = new DType; ! 409: f->type[i]->pcc = typeindex[i]; ! 410: } ! 411: } ! 412: return used++; ! 413: } ! 414: ! 415: int BsdTShare::findfile(char *fname) ! 416: { ! 417: for(BsdTFile *f = &file[used-1]; f >= file; f--) ! 418: if (!strcmp(f->fname, fname)) ! 419: return f - file; ! 420: return -1; ! 421: } ! 422: ! 423: DType *BsdTShare::findtype(int fnum, int offset) ! 424: { ! 425: if (offset >= file[fnum].ntypes) ! 426: return 0; ! 427: return file[fnum].type[offset]; ! 428: } ! 429: ! 430: char *BsdTShare::filename(int fnum) ! 431: { ! 432: return file[fnum].fname; ! 433: } ! 434: ! 435: void BsdTShare::entertype(int fnum, int offset, DTypep dp) ! 436: { ! 437: BsdTFile *f = &file[fnum]; ! 438: if (offset >= f->ntypes) { ! 439: int n = offset + 5; // Room to spare ! 440: DTypepar nda = new DTypep[n]; ! 441: for(int i = 0; i < f->ntypes; i++) ! 442: nda[i] = f->type[i]; ! 443: delete f->type; ! 444: f->type = nda; ! 445: f->ntypes = n; ! 446: } ! 447: f->type[offset] = dp; ! 448: } ! 449: ! 450: BsdType::BsdType(Source *sp, BsdTShare *sh) ! 451: { ! 452: share = sh; ! 453: src = sp; ! 454: utypeindex = 0; ! 455: nfiles = 10; ! 456: filemap = new int[nfiles]; ! 457: filemap[0] = share->addfile(src->text(), 1); ! 458: used = 1; ! 459: } ! 460: ! 461: BsdType::~BsdType() ! 462: { ! 463: delete filemap; ! 464: } ! 465: ! 466: void BsdType::addinclude(char *fname, int flg) ! 467: { ! 468: if (used == nfiles) { // More mapping space needed ! 469: nfiles += 10; ! 470: int *map = new int[nfiles]; ! 471: for(int i = 0; i < used; i++) ! 472: map[i] = filemap[i]; ! 473: delete filemap; ! 474: filemap = map; ! 475: } ! 476: if (flg) ! 477: filemap[used] = share->addfile(fname); ! 478: else ! 479: filemap[used] = share->findfile(fname); ! 480: used++; ! 481: } ! 482: ! 483: /* ! 484: * Parse the yucky '=' symbol table information ! 485: * Possiblities: ! 486: * (a,b)=(x,y) usually typedefs ! 487: * (a,b)=*(x,y) pointers ! 488: * (a,b)=f(x,y) functions ! 489: * (a,b)=ar(0,1);lo;hi;(x,y) arrays ! 490: * (a,b)=r(x,y);lo;hi; range - who cares! ! 491: * (a,b)=eN:size,...; enum encoding ! 492: * (a,b)=sSN:(x,y),off,size;...;; structure encoding ! 493: * (a,b)=uSN:(x,y),off,size;...;; union encoding ! 494: * (a,b)=x{esu}name: ptr to undefined utype ! 495: */ ! 496: void BsdType::parsetype(char *equalptr, char *name) ! 497: { ! 498: int file, offset; ! 499: int pfile, poffset; ! 500: struct DType *dp, *dp1; ! 501: int ssize; ! 502: char stype; ! 503: char sname[100], *utypename; ! 504: ! 505: char *nextequal = strchr(equalptr+1, '='); ! 506: if (nextequal) ! 507: parsetype (nextequal, name); ! 508: register char *tp = equalptr; ! 509: while (*--tp != '(') ! 510: ; ! 511: toindices(tp, file, offset); ! 512: register char *cp = equalptr + 1; ! 513: switch ( *cp ) { ! 514: case '(': ! 515: toindices(cp, pfile, poffset); ! 516: dp1 = share->findtype(pfile,poffset); ! 517: dp = new DType; ! 518: dp->pcc = dp1->pcc; ! 519: dp->dim = dp1->dim; ! 520: dp->univ = dp1->univ; ! 521: share->entertype(file, offset, dp); ! 522: cp = strchr(cp, ')') + 1; ! 523: break; ! 524: case '*': ! 525: toindices(++cp, pfile, poffset); ! 526: cp = strchr(cp, ')') + 1; ! 527: dp = new DType; ! 528: dp->univ = share->findtype(pfile,poffset); ! 529: if (!dp->univ) ! 530: dp->over = (pfile << 16) | poffset; ! 531: dp->pcc = PTR; ! 532: share->entertype(file, offset, dp); ! 533: break; ! 534: case 'f': ! 535: toindices(++cp, pfile, poffset); ! 536: cp = strchr(cp, ')') + 1; ! 537: dp = new DType; ! 538: dp->univ = share->findtype(pfile,poffset); ! 539: if (!dp->univ) ! 540: dp->over = (pfile << 16) | poffset; ! 541: dp->pcc = FTN; ! 542: share->entertype(file, offset, dp); ! 543: break; ! 544: case 'a': ! 545: cp = strchr(cp, ';') + 1; ! 546: cp = strchr(cp, ';') + 1; ! 547: dp = new DType; ! 548: dp->dim = toint(cp) + 1; ! 549: dp->pcc = ARY; ! 550: cp = strchr(cp, ';') + 1; ! 551: toindices(cp, pfile, poffset); ! 552: cp = strchr(cp, ')') + 1; ! 553: dp->univ = share->findtype(pfile,poffset); ! 554: if (!dp->univ) ! 555: dp->over = (pfile << 16) | poffset; ! 556: share->entertype(file, offset, dp); ! 557: break; ! 558: case 'r': ! 559: cp = strchr(cp, ';') + 1; ! 560: cp = strchr(cp, ';') + 1; ! 561: cp = strchr(cp, ';') + 1; ! 562: break; ! 563: case 'x': ! 564: stype = *++cp; ! 565: ssize = 0; ! 566: cp++; ! 567: for(char *to = utypename = sname; *cp != ':'; ) ! 568: *to++ = *cp++; ! 569: *to = 0; ! 570: cp++; ! 571: goto xentry; ! 572: case 's': ! 573: case 'u': ! 574: case 'e': ! 575: if (*--tp == 'T' || *tp == 't') { ! 576: *strchr(name, ':') = 0; ! 577: utypename = name; ! 578: } else { ! 579: sprintf(sname, "%s.%d", ! 580: basename(share->filename(file)), ! 581: offset); ! 582: utypename = sname; ! 583: } ! 584: stype = *cp++; ! 585: ssize = toint(cp); ! 586: if (stype == 'e') ! 587: ssize = 1; ! 588: xentry: ! 589: UType *u = (UType*) src->symtab->idtosym( ! 590: U_UTYPE, utypename, 0); ! 591: if( u ){ ! 592: if( u->range.lo < ssize ){ ! 593: if( u->encode ) ! 594: delete u->encode; ! 595: u->encode = toutypestr(cp, stype); ! 596: u->range.lo = ssize; ! 597: u->bsdp = this; ! 598: } else if (ssize) ! 599: delete toutypestr(cp, stype); ! 600: } else { ! 601: ++UTypeStubs; ! 602: if (utypename == sname) ! 603: utypename = sf("%s", sname); ! 604: u = new UType(src->symtab, ! 605: ssize ? toutypestr(cp, stype) : (char *)0, ! 606: utypename, this); ! 607: u->range.lo = ssize; ! 608: switch(stype) { ! 609: case 'e': ! 610: u->type.pcc = ENUMTY; ! 611: break; ! 612: case 's': ! 613: u->type.pcc = STRTY; ! 614: break; ! 615: case 'u': ! 616: u->type.pcc = UNIONTY; ! 617: break; ! 618: } ! 619: u->type.univ = u; ! 620: u->rsib = src->symtab->utype; ! 621: src->symtab->utype = u; ! 622: } ! 623: if (!share->findtype(file, offset)) { ! 624: dp = new DType; ! 625: dp->univ = u; ! 626: dp->pcc = u->type.pcc; ! 627: share->entertype(file, offset, dp); ! 628: } ! 629: break; ! 630: default: ! 631: break; ! 632: } ! 633: memset(equalptr, ' ', cp - equalptr); ! 634: } ! 635: ! 636: DType BsdType::gettype(char *string) ! 637: { ! 638: int file, offset; ! 639: string = strchr(string, '('); ! 640: toindices(string, file, offset); ! 641: return gettype(file, offset); ! 642: } ! 643: ! 644: DType BsdType::gettype(int fnum, int offset) ! 645: { ! 646: return chain(share->findtype(fnum, offset)); ! 647: } ! 648: ! 649: DType BsdType::chain(DType *dp) ! 650: { ! 651: DType d; ! 652: ! 653: if (!dp) { // Shouldn't happen - fix this if ever figure ! 654: d.pcc = INT; // out how the include file references are ! 655: return d; // shared. I give up .... ! 656: } ! 657: d.pcc = dp->pcc; ! 658: d.dim = dp->dim; ! 659: d.univ = dp->univ; ! 660: if( d.pcc & TMASK ){ ! 661: if (!dp->univ) ! 662: dp->univ = share->findtype(dp->over>>16, ! 663: dp->over&0xffff); ! 664: d.univ = new DType; ! 665: *(d.ref()) = chain(dp->ref()); ! 666: } ! 667: return d; ! 668: } ! 669: ! 670: void BsdType::toindices(char *cp, int &fnum, int &offset) ! 671: { ! 672: while (*cp++ != '(') ! 673: ; ! 674: fnum = filemap[toint(cp)]; ! 675: while (*cp++ != ',') ! 676: ; ! 677: offset = toint(cp); ! 678: } ! 679: ! 680: int BsdType::toint(char *cp) ! 681: { ! 682: int cnt = 0; ! 683: int sign = 1; ! 684: ! 685: if (*cp == '-') { ! 686: sign = -1; ! 687: cp++; ! 688: } ! 689: while (*cp >= '0' && *cp <= '9') ! 690: cnt = cnt * 10 + *cp++ - '0'; ! 691: return cnt * sign; ! 692: } ! 693: ! 694: char *BsdType::toutypestr(char *cp, int c) ! 695: { ! 696: char *bp; ! 697: int size; ! 698: char *cstart; ! 699: register char *to, *from; ! 700: ! 701: if (c == 'e') { ! 702: cstart = cp; ! 703: for(size = 0; ; cp++) { ! 704: if (*cp == '\\') { ! 705: *cp++ = ' '; ! 706: *cp = ' '; ! 707: } ! 708: if (*cp != ' ') ! 709: size++; ! 710: if (*cp == ';') /* Enum delimiter */ ! 711: break; ! 712: } ! 713: } else { ! 714: while (*cp >= '0' && *cp <= '9') ! 715: *cp++ = ' '; ! 716: cstart = cp; ! 717: for(size = 0; ; cp++) { ! 718: if (*cp == '\\') { ! 719: *cp++ = ' '; ! 720: *cp = ' '; ! 721: char *nextequal = strchr(cp+1, '='); ! 722: if (nextequal) ! 723: parsetype (nextequal, nextequal); ! 724: } ! 725: if (*cp != ' ') ! 726: size++; ! 727: if (*cp == ';' && *(cp-1) == ';') ! 728: break; ! 729: } ! 730: } ! 731: to = bp = new char[size + 1]; ! 732: from = cstart; ! 733: for (register i = size; size--; ) { ! 734: while (*from == ' ') ! 735: from++; ! 736: *to++ = *from; ! 737: *from++ = ' '; ! 738: } ! 739: *to = 0; ! 740: return bp; ! 741: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.