![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to lpass2.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / usr.bin / lint|
Return to lpass2.c CVS log | Up to [CSRG BSD Unix] / 43BSD / usr.bin / lint |
1.1 ! root 1: #ifndef lint ! 2: static char sccsid[] = "@(#)lpass2.c 1.6 (Berkeley) 2/21/86"; ! 3: #endif lint ! 4: ! 5: # include "macdefs.h" ! 6: # include "manifest.h" ! 7: # include "lmanifest.h" ! 8: ! 9: # define USED 01 ! 10: # define VUSED 02 ! 11: # define EUSED 04 ! 12: # define RVAL 010 ! 13: # define VARARGS 0100 ! 14: ! 15: # define NSZ 4096 ! 16: # define TYSZ 3500 ! 17: # define FSZ 500 ! 18: # define NTY 50 ! 19: ! 20: typedef struct sty STYPE; ! 21: struct sty { ATYPE t; STYPE *next; }; ! 22: ! 23: typedef struct sym { ! 24: #ifndef FLEXNAMES ! 25: char name[LCHNM]; ! 26: #else ! 27: char *name; ! 28: #endif ! 29: short nargs; ! 30: int decflag; ! 31: int fline; ! 32: STYPE symty; ! 33: int fno; ! 34: int use; ! 35: } STAB; ! 36: ! 37: STAB stab[NSZ]; ! 38: STAB *find(); ! 39: ! 40: STYPE tary[TYSZ]; ! 41: STYPE *tget(); ! 42: ! 43: #ifndef FLEXNAMES ! 44: char fnm[FSZ][LFNM]; ! 45: #else ! 46: char *fnm[FSZ]; ! 47: #endif ! 48: ! 49: #ifdef FLEXNAMES ! 50: char *getstr(); ! 51: #endif ! 52: ! 53: int tfree; /* used to allocate types */ ! 54: int ffree; /* used to save filenames */ ! 55: ! 56: struct ty atyp[NTY]; ! 57: /* r is where all the input ends up */ ! 58: union rec r; ! 59: ! 60: int hflag = 0; ! 61: int pflag = 0; ! 62: int xflag = 0; ! 63: int uflag = 1; ! 64: int ddddd = 0; ! 65: int zflag = 0; ! 66: int Pflag = 0; ! 67: ! 68: int cfno; /* current file number */ ! 69: ! 70: main( argc, argv ) char *argv[]; { ! 71: register char *p; ! 72: ! 73: /* first argument is intermediate file */ ! 74: /* second argument is - options */ ! 75: ! 76: for( ; argc>2 && argv[argc-1][0] == '-' ; --argc ){ ! 77: for( p=argv[argc-1]; *p; ++p ){ ! 78: switch( *p ){ ! 79: ! 80: case 'h': ! 81: hflag = 1; ! 82: break; ! 83: ! 84: case 'p': ! 85: pflag = 1; ! 86: break; ! 87: ! 88: case 'x': ! 89: xflag = 1; ! 90: break; ! 91: ! 92: case 'X': ! 93: ddddd = 1; ! 94: break; ! 95: ! 96: case 'u': ! 97: uflag = 0; ! 98: break; ! 99: ! 100: case 'z': ! 101: zflag = 1; ! 102: break; ! 103: ! 104: case 'P': ! 105: Pflag = 1; ! 106: break; ! 107: ! 108: } ! 109: } ! 110: } ! 111: ! 112: if( argc < 2 || !freopen( argv[1], "r", stdin ) ){ ! 113: error( "cannot open intermediate file" ); ! 114: exit( 1 ); ! 115: } ! 116: if( Pflag ){ ! 117: pfile(); ! 118: return( 0 ); ! 119: } ! 120: mloop( LDI|LIB|LST ); ! 121: rewind( stdin ); ! 122: mloop( LDC|LDX ); ! 123: rewind( stdin ); ! 124: mloop( LRV|LUV|LUE|LUM ); ! 125: cleanup(); ! 126: return(0); ! 127: } ! 128: ! 129: mloop( m ){ ! 130: /* do the main loop */ ! 131: register STAB *q; ! 132: ! 133: while( lread(m) ){ ! 134: q = find(); ! 135: if( q->decflag ) chkcompat(q); ! 136: else setuse(q); ! 137: } ! 138: } ! 139: ! 140: lread(m){ /* read a line into r.l */ ! 141: ! 142: register n; ! 143: ! 144: for(;;) { ! 145: if( fread( (char *)&r, sizeof(r), 1, stdin ) <= 0 ) return(0); ! 146: if( r.l.decflag & LFN ){ ! 147: /* new filename */ ! 148: #ifdef FLEXNAMES ! 149: r.f.fn = getstr(); ! 150: #endif ! 151: if( Pflag ) return( 1 ); ! 152: setfno( r.f.fn ); ! 153: continue; ! 154: } ! 155: #ifdef FLEXNAMES ! 156: r.l.name = getstr(); ! 157: #endif ! 158: n = r.l.nargs; ! 159: if( n<0 ) n = -n; ! 160: if( n>=NTY ) error( "more than %d args?", n ); ! 161: fread( (char *)atyp, sizeof(ATYPE), n, stdin ); ! 162: if( ( r.l.decflag & m ) ) return( 1 ); ! 163: } ! 164: } ! 165: ! 166: setfno( s ) char *s; { ! 167: /* look up current file names */ ! 168: /* first, strip backwards to the beginning or to the first / */ ! 169: int i; ! 170: ! 171: /* now look up s */ ! 172: for( i=0; i<ffree; ++i ){ ! 173: #ifndef FLEXNAMES ! 174: if( !strncmp( s, fnm[i], LFNM ) ) ! 175: #else ! 176: if (fnm[i] == s) ! 177: #endif ! 178: { ! 179: cfno = i; ! 180: return; ! 181: } ! 182: } ! 183: /* make a new entry */ ! 184: if( ffree >= FSZ ) error( "more than %d files", FSZ ); ! 185: #ifndef FLEXNAMES ! 186: strncpy( fnm[ffree], s, LFNM ); ! 187: #else ! 188: fnm[ffree] = s; ! 189: #endif ! 190: cfno = ffree++; ! 191: } ! 192: ! 193: /* VARARGS */ ! 194: error( s, a ) char *s; { ! 195: ! 196: #ifndef FLEXNAMES ! 197: fprintf( stderr, "pass 2 error:(file %.*s) ", LFNM, fnm[cfno] ); ! 198: #else ! 199: fprintf( stderr, "pass 2 error:(file %s) ", fnm[cfno] ); ! 200: #endif ! 201: fprintf( stderr, s, a ); ! 202: fprintf( stderr, "\n" ); ! 203: exit(1); ! 204: } ! 205: ! 206: STAB * ! 207: find(){ ! 208: register h=0; ! 209: #ifndef FLEXNAMES ! 210: h = hashstr(r.l.name, LCHNM) % NSZ; ! 211: #else ! 212: h = (int)r.l.name % NSZ; ! 213: #endif ! 214: { register STAB *p, *q; ! 215: for( p=q= &stab[h]; q->decflag; ){ ! 216: #ifndef FLEXNAMES ! 217: if( !strncmp( r.l.name, q->name, LCHNM)) ! 218: #else ! 219: if (r.l.name == q->name) ! 220: #endif ! 221: if( ((q->decflag|r.l.decflag)&LST)==0 || q->fno==cfno ) ! 222: return(q); ! 223: if( ++q >= &stab[NSZ] ) q = stab; ! 224: if( q == p ) error( "too many names defined" ); ! 225: } ! 226: #ifndef FLEXNAMES ! 227: strncpy( q->name, r.l.name, LCHNM ); ! 228: #else ! 229: q->name = r.l.name; ! 230: #endif ! 231: return( q ); ! 232: } ! 233: } ! 234: ! 235: STYPE * ! 236: tget(){ ! 237: if( tfree >= TYSZ ){ ! 238: error( "too many types needed" ); ! 239: } ! 240: return( &tary[tfree++] ); ! 241: } ! 242: ! 243: chkcompat(q) STAB *q; { ! 244: /* are the types, etc. in r.l and q compatible */ ! 245: register int i; ! 246: STYPE *qq; ! 247: ! 248: setuse(q); ! 249: ! 250: /* argument check */ ! 251: ! 252: if( q->decflag & (LDI|LIB|LUV|LUE|LST) ){ ! 253: if( r.l.decflag & (LUV|LIB|LUE) ){ ! 254: if( q->nargs != r.l.nargs ){ ! 255: if( !(q->use&VARARGS) ){ ! 256: #ifndef FLEXNAMES ! 257: printf( "%.8s: variable # of args.", q->name ); ! 258: #else ! 259: printf( "%s: variable # of args.", q->name ); ! 260: #endif ! 261: viceversa(q); ! 262: } ! 263: if( r.l.nargs > q->nargs ) r.l.nargs = q->nargs; ! 264: if( !(q->decflag & (LDI|LIB|LST) ) ) { ! 265: q->nargs = r.l.nargs; ! 266: q->use |= VARARGS; ! 267: } ! 268: } ! 269: for( i=0,qq=q->symty.next; i<r.l.nargs; ++i,qq=qq->next){ ! 270: if( chktype( &qq->t, &atyp[i] ) ){ ! 271: #ifndef FLEXNAMES ! 272: printf( "%.8s, arg. %d used inconsistently", ! 273: #else ! 274: printf( "%s, arg. %d used inconsistently", ! 275: #endif ! 276: q->name, i+1 ); ! 277: viceversa(q); ! 278: } ! 279: } ! 280: } ! 281: } ! 282: ! 283: if( (q->decflag&(LDI|LIB|LUV|LST)) && r.l.decflag==LUV ){ ! 284: if( chktype( &r.l.type, &q->symty.t ) ){ ! 285: #ifndef FLEXNAMES ! 286: printf( "%.8s value used inconsistently", q->name ); ! 287: #else ! 288: printf( "%s value used inconsistently", q->name ); ! 289: #endif ! 290: viceversa(q); ! 291: } ! 292: } ! 293: ! 294: /* check for multiple declaration */ ! 295: ! 296: if( (q->decflag&(LDI|LST)) && (r.l.decflag&(LDI|LIB|LST)) ){ ! 297: #ifndef FLEXNAMES ! 298: printf( "%.8s multiply declared", q->name ); ! 299: #else ! 300: printf( "%s multiply declared", q->name ); ! 301: #endif ! 302: viceversa(q); ! 303: } ! 304: ! 305: /* do a bit of checking of definitions and uses... */ ! 306: ! 307: if( (q->decflag & (LDI|LIB|LDX|LDC|LUM|LST)) && (r.l.decflag & (LDX|LDC|LUM)) && q->symty.t.aty != r.l.type.aty ){ ! 308: #ifndef FLEXNAMES ! 309: printf( "%.8s value declared inconsistently", q->name ); ! 310: #else ! 311: printf( "%s value declared inconsistently", q->name ); ! 312: #endif ! 313: viceversa(q); ! 314: } ! 315: ! 316: /* better not call functions which are declared to be structure or union returning */ ! 317: ! 318: if( (q->decflag & (LDI|LIB|LDX|LDC|LST)) && (r.l.decflag & LUE) && q->symty.t.aty != r.l.type.aty ){ ! 319: /* only matters if the function returns union or structure */ ! 320: TWORD ty; ! 321: ty = q->symty.t.aty; ! 322: if( ISFTN(ty) && ((ty = DECREF(ty))==STRTY || ty==UNIONTY ) ){ ! 323: #ifndef FLEXNAMES ! 324: printf( "%.8s function value type must be declared before use", q->name ); ! 325: #else ! 326: printf( "%s function value type must be declared before use", q->name ); ! 327: #endif ! 328: viceversa(q); ! 329: } ! 330: } ! 331: ! 332: if( pflag && q->decflag==LDX && r.l.decflag == LUM && !ISFTN(q->symty.t.aty) ){ ! 333: /* make the external declaration go away */ ! 334: /* in effect, it was used without being defined */ ! 335: } ! 336: } ! 337: ! 338: viceversa(q) STAB *q; { ! 339: /* print out file comparison */ ! 340: #ifndef FLEXNAMES ! 341: printf( " %.*s(%d) :: %.*s(%d)\n", ! 342: LFNM, fnm[q->fno], q->fline, ! 343: LFNM, fnm[cfno], r.l.fline ); ! 344: #else ! 345: printf( " %s(%d) :: %s(%d)\n", ! 346: fnm[q->fno], q->fline, ! 347: fnm[cfno], r.l.fline ); ! 348: #endif ! 349: } ! 350: ! 351: /* messages for defintion/use */ ! 352: char * ! 353: mess[2][2] ={ ! 354: "", ! 355: #ifndef FLEXNAMES ! 356: "%.8s used( %.*s(%d) ), but not defined\n", ! 357: "%.8s defined( %.*s(%d) ), but never used\n", ! 358: "%.8s declared( %.*s(%d) ), but never used or defined\n" ! 359: #else ! 360: "%s used( %s(%d) ), but not defined\n", ! 361: "%s defined( %s(%d) ), but never used\n", ! 362: "%s declared( %s(%d) ), but never used or defined\n" ! 363: #endif ! 364: }; ! 365: ! 366: lastone(q) STAB *q; { ! 367: ! 368: register nu, nd, uses; ! 369: ! 370: if( ddddd ) pst(q); ! 371: ! 372: nu = nd = 0; ! 373: uses = q->use; ! 374: ! 375: if( !(uses&USED) && q->decflag != LIB ) { ! 376: #ifndef FLEXNAMES ! 377: if( strncmp(q->name,"main",7) ) ! 378: #else ! 379: if (strcmp(q->name, "main")) ! 380: #endif ! 381: nu = 1; ! 382: } ! 383: ! 384: if( !ISFTN(q->symty.t.aty) ){ ! 385: switch( q->decflag ){ ! 386: ! 387: case LIB: ! 388: nu = nd = 0; /* don't complain about uses on libraries */ ! 389: break; ! 390: case LDX: ! 391: if( !xflag ) break; ! 392: case LUV: ! 393: case LUE: ! 394: /* 01/04/80 */ case LUV | LUE: ! 395: case LUM: ! 396: nd = 1; ! 397: } ! 398: } ! 399: if( uflag && ( nu || nd ) ) ! 400: #ifndef FLEXNAMES ! 401: printf( mess[nu][nd], q->name, LFNM, fnm[q->fno], q->fline ); ! 402: #else ! 403: printf( mess[nu][nd], q->name, fnm[q->fno], q->fline ); ! 404: #endif ! 405: ! 406: if( (uses&(RVAL+EUSED)) == (RVAL+EUSED) ){ ! 407: /* if functions is static, then print the file name too */ ! 408: if( q->decflag & LST ) ! 409: #ifndef FLEXNAMES ! 410: printf( "%.*s(%d):", LFNM, fnm[q->fno], q->fline ); ! 411: #else ! 412: printf( "%s(%d):", fnm[q->fno], q->fline ); ! 413: #endif ! 414: #ifndef FLEXNAMES ! 415: printf( "%.*s returns value which is %s ignored\n", ! 416: LCHNM, q->name, uses&VUSED ? "sometimes" : "always" ); ! 417: #else ! 418: printf( "%s returns value which is %s ignored\n", ! 419: q->name, uses&VUSED ? "sometimes" : "always" ); ! 420: #endif ! 421: } ! 422: ! 423: if( (uses&(RVAL+VUSED)) == (VUSED) && (q->decflag&(LDI|LIB|LST)) ){ ! 424: if( q->decflag & LST ) ! 425: #ifndef FLEXNAMES ! 426: printf( "%.*s(%d):", LFNM, fnm[q->fno], q->fline ); ! 427: #else ! 428: printf( "%s(%d):", fnm[q->fno], q->fline ); ! 429: #endif ! 430: #ifndef FLEXNAMES ! 431: printf( "%.*s value is used, but none returned\n", ! 432: LCHNM, q->name); ! 433: #else ! 434: printf( "%s value is used, but none returned\n", q->name); ! 435: #endif ! 436: } ! 437: } ! 438: ! 439: cleanup(){ /* call lastone and die gracefully */ ! 440: STAB *q; ! 441: for( q=stab; q< &stab[NSZ]; ++q ){ ! 442: if( q->decflag ) lastone(q); ! 443: } ! 444: exit(0); ! 445: } ! 446: ! 447: setuse(q) STAB *q; { /* check new type to ensure that it is used */ ! 448: ! 449: if( !q->decflag ){ /* new one */ ! 450: q->decflag = r.l.decflag; ! 451: q->symty.t = r.l.type; ! 452: if( r.l.nargs < 0 ){ ! 453: q->nargs = -r.l.nargs; ! 454: q->use = VARARGS; ! 455: } ! 456: else { ! 457: q->nargs = r.l.nargs; ! 458: q->use = 0; ! 459: } ! 460: q->fline = r.l.fline; ! 461: q->fno = cfno; ! 462: if( q->nargs ){ ! 463: int i; ! 464: STYPE *qq; ! 465: for( i=0,qq= &q->symty; i<q->nargs; ++i,qq=qq->next ){ ! 466: qq->next = tget(); ! 467: qq->next->t = atyp[i]; ! 468: } ! 469: } ! 470: } ! 471: ! 472: switch( r.l.decflag ){ ! 473: ! 474: case LRV: ! 475: q->use |= RVAL; ! 476: return; ! 477: case LUV: ! 478: q->use |= VUSED+USED; ! 479: return; ! 480: case LUE: ! 481: q->use |= EUSED+USED; ! 482: return; ! 483: /* 01/04/80 */ case LUV | LUE: ! 484: case LUM: ! 485: q->use |= USED; ! 486: return; ! 487: ! 488: } ! 489: } ! 490: ! 491: chktype( pt1, pt2 ) register ATYPE *pt1, *pt2; { ! 492: TWORD t; ! 493: ! 494: /* check the two type words to see if they are compatible */ ! 495: /* for the moment, enums are turned into ints, and should be checked as such */ ! 496: if( pt1->aty == ENUMTY ) pt1->aty = INT; ! 497: if( pt2->aty == ENUMTY ) pt2->aty = INT; ! 498: ! 499: if( (t=BTYPE(pt1->aty)==STRTY) || t==UNIONTY ){ ! 500: if( pt1->aty != pt2->aty || pt1->extra1 != pt2->extra1 ) ! 501: return 1; ! 502: /* if -z then don't worry about undefined structures, ! 503: as long as the names match */ ! 504: if( zflag && (pt1->extra == 0 || pt2->extra == 0) ) return 0; ! 505: return pt1->extra != pt2->extra; ! 506: } ! 507: ! 508: if( pt2->extra ){ /* constant passed in */ ! 509: if( pt1->aty == UNSIGNED && pt2->aty == INT ) return( 0 ); ! 510: else if( pt1->aty == ULONG && pt2->aty == LONG ) return( 0 ); ! 511: } ! 512: else if( pt1->extra ){ /* for symmetry */ ! 513: if( pt2->aty == UNSIGNED && pt1->aty == INT ) return( 0 ); ! 514: else if( pt2->aty == ULONG && pt1->aty == LONG ) return( 0 ); ! 515: } ! 516: ! 517: return( pt1->aty != pt2->aty ); ! 518: } ! 519: ! 520: struct tb { int m; char * nm }; ! 521: ! 522: struct tb dfs[] = { ! 523: LDI, "LDI", ! 524: LIB, "LIB", ! 525: LDC, "LDC", ! 526: LDX, "LDX", ! 527: LRV, "LRV", ! 528: LUV, "LUV", ! 529: LUE, "LUE", ! 530: LUM, "LUM", ! 531: LST, "LST", ! 532: LFN, "LFN", ! 533: 0, "" }; ! 534: ! 535: struct tb us[] = { ! 536: USED, "USED", ! 537: VUSED, "VUSED", ! 538: EUSED, "EUSED", ! 539: RVAL, "RVAL", ! 540: VARARGS, "VARARGS", ! 541: 0, "" }; ! 542: ! 543: ptb( v, tp ) struct tb *tp; { ! 544: /* print a value from the table */ ! 545: int flag; ! 546: flag = 0; ! 547: for( ; tp->m; ++tp ){ ! 548: if( v&tp->m ){ ! 549: if( flag++ ) putchar( '|' ); ! 550: printf( "%s", tp->nm ); ! 551: } ! 552: } ! 553: } ! 554: ! 555: pst( q ) STAB *q; { ! 556: /* give a debugging output for q */ ! 557: ! 558: #ifndef FLEXNAMES ! 559: printf( "%.8s (", q->name ); ! 560: #else ! 561: printf( "%s (", q->name ); ! 562: #endif ! 563: ptb( q->decflag, dfs ); ! 564: printf( "), use= " ); ! 565: ptb( q->use, us ); ! 566: printf( ", line %d, nargs=%d\n", q->fline, q->nargs ); ! 567: } ! 568: ! 569: pfile() { ! 570: /* print the input file in readable form */ ! 571: while( lread( LDI|LIB|LDC|LDX|LRV|LUV|LUE|LUM|LST|LFN ) ) ! 572: prc(); ! 573: } ! 574: ! 575: prc() { ! 576: /* print out 'r' for debugging */ ! 577: register i, j, k; ! 578: ! 579: printf( "decflag\t" ); ! 580: ptb( r.l.decflag, dfs ); ! 581: putchar( '\n' ); ! 582: if( r.l.decflag & LFN ){ ! 583: #ifdef FLEXNAMES ! 584: printf( "fn\t\t%s\n", r.f.fn ); ! 585: #else ! 586: printf( "fn\t%\t.*s\n", LFNM, r.f.fn ); ! 587: #endif ! 588: } ! 589: else { ! 590: #ifdef FLEXNAMES ! 591: printf( "name\t%s\n", r.l.name ); ! 592: #else ! 593: printf( "name\t%.*s\n", LCHNM, r.l.name ); ! 594: #endif ! 595: printf( "nargs\t%d\n", r.l.nargs ); ! 596: printf( "fline\t%d\n", r.l.fline ); ! 597: printf( "type.aty\t0%o (", r.l.type.aty ); ! 598: pty( r.l.type.aty, r.l.name ); ! 599: printf( ")\ntype.extra\t%d\n", r.l.type.extra ); ! 600: j = r.l.type.extra1; ! 601: printf( "type.extra1\t0x%x (%d,%d)\n", ! 602: j, j & X_NONAME ? 1 : 0, j & ~X_NONAME ); ! 603: k = r.l.nargs; ! 604: if( k < 0 ) k = -k; ! 605: for( i = 0; i < k; i++ ){ ! 606: printf( "atyp[%d].aty\t0%o (", i, atyp[i].aty ); ! 607: pty( atyp[i].aty, "" ); ! 608: printf( ")\natyp[%d].extra\t%d\n", i, atyp[i].extra); ! 609: j = atyp[i].extra1; ! 610: printf( "atyp[%d].extra1\t0x%x (%d,%d)\n", ! 611: i, j, j & X_NONAME ? 1 : 0, j & ~X_NONAME ); ! 612: } ! 613: } ! 614: putchar( '\n' ); ! 615: } ! 616: ! 617: pty( t, name ) TWORD t; { ! 618: static char * tnames[] = { ! 619: "void", "farg", "char", "short", ! 620: "int", "long", "float", "double", ! 621: "struct xxx", "union %s", "enum", "moety", ! 622: "unsigned char", "unsigned short", "unsigned", "unsigned long", ! 623: "?", "?" ! 624: }; ! 625: ! 626: printf( "%s ", tnames[BTYPE(t)] ); ! 627: pty1( t, name, (8 * sizeof (int) - BTSHIFT) / TSHIFT ); ! 628: } ! 629: ! 630: pty1( t, name, level ) TWORD t; { ! 631: register TWORD u; ! 632: ! 633: if( level < 0 ){ ! 634: printf( "%s", name ); ! 635: return; ! 636: } ! 637: u = t >> level * TSHIFT; ! 638: if( ISPTR(u) ){ ! 639: printf( "*" ); ! 640: pty1( t, name, level-1 ); ! 641: } ! 642: else if( ISFTN(u) ){ ! 643: if( level > 0 && ISPTR(u << TSHIFT) ){ ! 644: printf( "(" ); ! 645: pty1( t, name, level-1 ); ! 646: printf( ")()" ); ! 647: } ! 648: else { ! 649: pty1( t, name, level-1 ); ! 650: printf( "()" ); ! 651: } ! 652: } ! 653: else if( ISARY(u) ){ ! 654: if( level > 0 && ISPTR(u << TSHIFT) ){ ! 655: printf( "(" ); ! 656: pty1( t, name, level-1 ); ! 657: printf( ")[]" ); ! 658: } ! 659: else { ! 660: pty1( t, name, level-1 ); ! 661: printf( "[]" ); ! 662: } ! 663: } ! 664: else { ! 665: pty1( t, name, level-1 ); ! 666: } ! 667: } ! 668: ! 669: #ifdef FLEXNAMES ! 670: char * ! 671: getstr() ! 672: { ! 673: char buf[BUFSIZ]; ! 674: register char *cp = buf; ! 675: register int c; ! 676: ! 677: if (feof(stdin) || ferror(stdin)) ! 678: return(""); ! 679: while ((c = getchar()) > 0) ! 680: *cp++ = c; ! 681: if (c < 0) { ! 682: error("intermediate file format error (getstr)"); ! 683: exit(1); ! 684: } ! 685: *cp++ = 0; ! 686: return (hash(buf)); ! 687: } ! 688: ! 689: #define NSAVETAB 4096 ! 690: char *savetab; ! 691: int saveleft; ! 692: ! 693: char * ! 694: savestr(cp) ! 695: register char *cp; ! 696: { ! 697: register int len; ! 698: ! 699: len = strlen(cp) + 1; ! 700: if (len > saveleft) { ! 701: saveleft = NSAVETAB; ! 702: if (len > saveleft) ! 703: saveleft = len; ! 704: savetab = (char *)malloc(saveleft); ! 705: if (savetab == 0) { ! 706: error("ran out of memory (savestr)"); ! 707: exit(1); ! 708: } ! 709: } ! 710: strncpy(savetab, cp, len); ! 711: cp = savetab; ! 712: savetab += len; ! 713: saveleft -= len; ! 714: return (cp); ! 715: } ! 716: ! 717: /* ! 718: * The definition for the segmented hash tables. ! 719: */ ! 720: #define MAXHASH 20 ! 721: #define HASHINC 1013 ! 722: struct ht { ! 723: char **ht_low; ! 724: char **ht_high; ! 725: int ht_used; ! 726: } htab[MAXHASH]; ! 727: ! 728: char * ! 729: hash(s) ! 730: char *s; ! 731: { ! 732: register char **h; ! 733: register i; ! 734: register char *cp; ! 735: struct ht *htp; ! 736: int sh; ! 737: ! 738: sh = hashstr(s) % HASHINC; ! 739: cp = s; ! 740: /* ! 741: * There are as many as MAXHASH active ! 742: * hash tables at any given point in time. ! 743: * The search starts with the first table ! 744: * and continues through the active tables ! 745: * as necessary. ! 746: */ ! 747: for (htp = htab; htp < &htab[MAXHASH]; htp++) { ! 748: if (htp->ht_low == 0) { ! 749: register char **hp = ! 750: (char **) calloc(sizeof (char **), HASHINC); ! 751: if (hp == 0) { ! 752: error("ran out of memory (hash)"); ! 753: exit(1); ! 754: } ! 755: htp->ht_low = hp; ! 756: htp->ht_high = htp->ht_low + HASHINC; ! 757: } ! 758: h = htp->ht_low + sh; ! 759: /* ! 760: * quadratic rehash increment ! 761: * starts at 1 and incremented ! 762: * by two each rehash. ! 763: */ ! 764: i = 1; ! 765: do { ! 766: if (*h == 0) { ! 767: if (htp->ht_used > (HASHINC * 3)/4) ! 768: break; ! 769: htp->ht_used++; ! 770: *h = savestr(cp); ! 771: return (*h); ! 772: } ! 773: if (**h == *cp && strcmp(*h, cp) == 0) ! 774: return (*h); ! 775: h += i; ! 776: i += 2; ! 777: if (h >= htp->ht_high) ! 778: h -= HASHINC; ! 779: } while (i < HASHINC); ! 780: } ! 781: error("ran out of hash tables"); ! 782: exit(1); ! 783: } ! 784: char *tstrbuf[1]; ! 785: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.