![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to lint.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 lint.c CVS log | Up to [CSRG BSD Unix] / 43BSD / usr.bin / lint |
1.1 ! root 1: #ifndef lint ! 2: static char sccsid[] = "@(#)lint.c 1.10 (Berkeley) 3/20/86"; ! 3: #endif lint ! 4: ! 5: # include "pass1.h" ! 6: ! 7: # include "lmanifest.h" ! 8: ! 9: # include <ctype.h> ! 10: ! 11: # define VAL 0 ! 12: # define EFF 1 ! 13: ! 14: /* these are appropriate for the -p flag */ ! 15: int SZCHAR = 8; ! 16: int SZINT = 16; ! 17: int SZFLOAT = 32; ! 18: int SZDOUBLE = 64; ! 19: int SZLONG = 32; ! 20: int SZSHORT = 16; ! 21: int SZPOINT = 16; ! 22: int ALCHAR = 8; ! 23: int ALINT = 16; ! 24: int ALFLOAT = 32; ! 25: int ALDOUBLE = 64; ! 26: int ALLONG = 32; ! 27: int ALSHORT = 16; ! 28: int ALPOINT = 16; ! 29: int ALSTRUCT = 16; ! 30: ! 31: int vflag = 1; /* tell about unused argments */ ! 32: int xflag = 0; /* tell about unused externals */ ! 33: int argflag = 0; /* used to turn off complaints about arguments */ ! 34: int libflag = 0; /* used to generate library descriptions */ ! 35: int vaflag = -1; /* used to signal functions with a variable number of args */ ! 36: int aflag = 0; /* used to check precision of assignments */ ! 37: int zflag = 0; /* no 'structure never defined' error */ ! 38: int Cflag = 0; /* filter out certain output, for generating libraries */ ! 39: char *libname = 0; /* name of the library we're generating */ ! 40: ! 41: /* flags for the "outdef" function */ ! 42: # define USUAL (-101) ! 43: # define DECTY (-102) ! 44: # define NOFILE (-103) ! 45: # define SVLINE (-104) ! 46: ! 47: # define LNAMES 250 ! 48: ! 49: struct lnm { ! 50: short lid, flgs; ! 51: } lnames[LNAMES], *lnp; ! 52: ! 53: contx( p, down, pl, pr ) register NODE *p; register *pl, *pr; { ! 54: ! 55: *pl = *pr = VAL; ! 56: switch( p->in.op ){ ! 57: ! 58: case ANDAND: ! 59: case OROR: ! 60: case QUEST: ! 61: *pr = down; ! 62: break; ! 63: ! 64: case SCONV: ! 65: case PCONV: ! 66: case COLON: ! 67: *pr = *pl = down; ! 68: break; ! 69: ! 70: case COMOP: ! 71: *pl = EFF; ! 72: *pr = down; ! 73: ! 74: case FORCE: ! 75: case INIT: ! 76: case UNARY CALL: ! 77: case STCALL: ! 78: case UNARY STCALL: ! 79: case CALL: ! 80: case UNARY FORTCALL: ! 81: case FORTCALL: ! 82: case CBRANCH: ! 83: break; ! 84: ! 85: default: ! 86: if( asgop(p->in.op) ) break; ! 87: if( p->in.op == UNARY MUL && ( p->in.type == STRTY || p->in.type == UNIONTY || p->in.type == UNDEF) ) { ! 88: /* struct x f( ); main( ) { (void) f( ); } ! 89: * the the cast call appears as U* UNDEF ! 90: */ ! 91: break; /* the compiler does this... */ ! 92: } ! 93: if( down == EFF && hflag ) werror( "null effect" ); ! 94: ! 95: } ! 96: } ! 97: ! 98: ecode( p ) NODE *p; { ! 99: /* compile code for p */ ! 100: ! 101: fwalk( p, contx, EFF ); ! 102: lnp = lnames; ! 103: lprt( p, EFF, 0 ); ! 104: } ! 105: ! 106: ejobcode( flag ){ ! 107: /* called after processing each job */ ! 108: /* flag is nonzero if errors were detected */ ! 109: register k; ! 110: register struct symtab *p; ! 111: ! 112: for( p=stab; p< &stab[SYMTSZ]; ++p ){ ! 113: ! 114: if( p->stype != TNULL ) { ! 115: ! 116: if( p->stype == STRTY || p->stype == UNIONTY ){ ! 117: if( !zflag && dimtab[p->sizoff+1] < 0 ){ ! 118: /* never defined */ ! 119: #ifndef FLEXNAMES ! 120: if( hflag ) werror( "struct/union %.8s never defined", p->sname ); ! 121: #else ! 122: if( hflag ) werror( "struct/union %s never defined", p->sname ); ! 123: #endif ! 124: } ! 125: } ! 126: ! 127: switch( p->sclass ){ ! 128: ! 129: case STATIC: ! 130: if( p->suse > 0 ){ ! 131: k = lineno; ! 132: lineno = p->suse; ! 133: #ifndef FLEXNAMES ! 134: uerror( "static variable %.8s unused", ! 135: #else ! 136: uerror( "static variable %s unused", ! 137: #endif ! 138: p->sname ); ! 139: lineno = k; ! 140: break; ! 141: } ! 142: /* no statics in libraries */ ! 143: if( Cflag ) break; ! 144: ! 145: case EXTERN: ! 146: case USTATIC: ! 147: /* with the xflag, worry about externs not used */ ! 148: /* the filename may be wrong here... */ ! 149: if( xflag && p->suse >= 0 && !libflag ){ ! 150: outdef( p, LDX, NOFILE ); ! 151: } ! 152: ! 153: case EXTDEF: ! 154: if( p->suse < 0 ){ /* used */ ! 155: outdef( p, LUM, SVLINE ); ! 156: } ! 157: break; ! 158: } ! 159: ! 160: } ! 161: ! 162: } ! 163: exit( 0 ); ! 164: } ! 165: ! 166: astype( t, i ) ATYPE *t; { ! 167: TWORD tt; ! 168: int j, k=0, l=0; ! 169: ! 170: if( (tt=BTYPE(t->aty))==STRTY || tt==UNIONTY ){ ! 171: if( i<0 || i>= DIMTABSZ-3 ){ ! 172: werror( "lint's little mind is blown" ); ! 173: } ! 174: else { ! 175: j = dimtab[i+3]; ! 176: if( j<0 || j>SYMTSZ ){ ! 177: k = dimtab[i]; ! 178: l = X_NONAME | stab[j].suse; ! 179: } ! 180: else { ! 181: if( stab[j].suse <= 0 ) { ! 182: #ifndef FLEXNAMES ! 183: werror( "no line number for %.8s", ! 184: #else ! 185: werror( "no line number for %s", ! 186: #endif ! 187: stab[j].sname ); ! 188: } ! 189: else { ! 190: k = dimtab[i]; ! 191: #ifdef FLEXNAMES ! 192: l = hashstr(stab[j].sname); ! 193: #else ! 194: l = hashstr(stab[j].sname, LCHNM); ! 195: #endif ! 196: } ! 197: } ! 198: } ! 199: ! 200: t->extra = k; ! 201: t->extra1 = l; ! 202: return( 1 ); ! 203: } ! 204: else return( 0 ); ! 205: } ! 206: ! 207: bfcode( a, n ) int a[]; { ! 208: /* code for the beginning of a function; a is an array of ! 209: indices in stab for the arguments; n is the number */ ! 210: /* this must also set retlab */ ! 211: register i; ! 212: register struct symtab *cfp; ! 213: static ATYPE t; ! 214: ! 215: retlab = 1; ! 216: ! 217: cfp = &stab[curftn]; ! 218: ! 219: /* if creating library, don't do static functions */ ! 220: if( Cflag && cfp->sclass == STATIC ) return; ! 221: ! 222: /* if variable number of arguments, only print the ones which will be checked */ ! 223: if( vaflag > 0 ){ ! 224: if( n < vaflag ) werror( "declare the VARARGS arguments you want checked!" ); ! 225: else n = vaflag; ! 226: } ! 227: fsave( ftitle ); ! 228: if( cfp->sclass == STATIC ) outdef( cfp, LST, vaflag>=0?-n:n ); ! 229: else outdef( cfp, libflag?LIB:LDI, vaflag>=0?-n:n ); ! 230: vaflag = -1; ! 231: ! 232: /* output the arguments */ ! 233: if( n ){ ! 234: for( i=0; i<n; ++i ) { ! 235: t.aty = stab[a[i]].stype; ! 236: t.extra = 0; ! 237: t.extra1 = 0; ! 238: if( !astype( &t, stab[a[i]].sizoff ) ) { ! 239: switch( t.aty ){ ! 240: ! 241: case ULONG: ! 242: break; ! 243: ! 244: case CHAR: ! 245: case SHORT: ! 246: t.aty = INT; ! 247: break; ! 248: ! 249: case UCHAR: ! 250: case USHORT: ! 251: case UNSIGNED: ! 252: t.aty = UNSIGNED; ! 253: break; ! 254: ! 255: } ! 256: } ! 257: fwrite( (char *)&t, sizeof(ATYPE), 1, stdout ); ! 258: } ! 259: } ! 260: } ! 261: ! 262: ctargs( p ) NODE *p; { ! 263: /* count arguments; p points to at least one */ ! 264: /* the arguemnts are a tower of commas to the left */ ! 265: register c; ! 266: c = 1; /* count the rhs */ ! 267: while( p->in.op == CM ){ ! 268: ++c; ! 269: p = p->in.left; ! 270: } ! 271: return( c ); ! 272: } ! 273: ! 274: lpta( p ) NODE *p; { ! 275: static ATYPE t; ! 276: ! 277: if( p->in.op == CM ){ ! 278: lpta( p->in.left ); ! 279: p = p->in.right; ! 280: } ! 281: ! 282: t.aty = p->in.type; ! 283: t.extra = (p->in.op==ICON); ! 284: t.extra1 = 0; ! 285: ! 286: if( !astype( &t, p->fn.csiz ) ) { ! 287: switch( t.aty ){ ! 288: ! 289: case CHAR: ! 290: case SHORT: ! 291: t.aty = INT; ! 292: case LONG: ! 293: case ULONG: ! 294: case INT: ! 295: case UNSIGNED: ! 296: break; ! 297: ! 298: case UCHAR: ! 299: case USHORT: ! 300: t.aty = UNSIGNED; ! 301: break; ! 302: ! 303: case FLOAT: ! 304: t.aty = DOUBLE; ! 305: t.extra = 0; ! 306: break; ! 307: ! 308: default: ! 309: t.extra = 0; ! 310: break; ! 311: } ! 312: } ! 313: fwrite( (char *)&t, sizeof(ATYPE), 1, stdout ); ! 314: } ! 315: ! 316: # define VALSET 1 ! 317: # define VALUSED 2 ! 318: # define VALASGOP 4 ! 319: # define VALADDR 8 ! 320: ! 321: lprt( p, down, uses ) register NODE *p; { ! 322: register struct symtab *q; ! 323: register id; ! 324: register acount; ! 325: register down1, down2; ! 326: register use1, use2; ! 327: register struct lnm *np1, *np2; ! 328: ! 329: /* first, set variables which are set... */ ! 330: ! 331: use1 = use2 = VALUSED; ! 332: if( p->in.op == ASSIGN ) use1 = VALSET; ! 333: else if( p->in.op == UNARY AND ) use1 = VALADDR; ! 334: else if( asgop( p->in.op ) ){ /* =ops */ ! 335: use1 = VALUSED|VALSET; ! 336: if( down == EFF ) use1 |= VALASGOP; ! 337: } ! 338: ! 339: ! 340: /* print the lines for lint */ ! 341: ! 342: down2 = down1 = VAL; ! 343: acount = 0; ! 344: ! 345: switch( p->in.op ){ ! 346: ! 347: case EQ: ! 348: case NE: ! 349: case GT: ! 350: case GE: ! 351: case LT: ! 352: case LE: ! 353: if( p->in.left->in.type == CHAR && p->in.right->in.op==ICON && p->in.right->tn.lval < 0 ){ ! 354: werror( "nonportable character comparison" ); ! 355: } ! 356: if( (p->in.op==EQ || p->in.op==NE ) && ISUNSIGNED(p->in.left->in.type) && p->in.right->in.op == ICON ){ ! 357: if( p->in.right->tn.lval < 0 && p->in.right->tn.rval == NONAME && !ISUNSIGNED(p->in.right->in.type) ){ ! 358: werror( "comparison of unsigned with negative constant" ); ! 359: } ! 360: } ! 361: break; ! 362: ! 363: case UGE: ! 364: case ULT: ! 365: if( p->in.right->in.op == ICON && p->in.right->tn.lval == 0 && p->in.right->tn.rval == NONAME ){ ! 366: werror( "unsigned comparison with 0?" ); ! 367: break; ! 368: } ! 369: case UGT: ! 370: case ULE: ! 371: if( p->in.right->in.op == ICON && p->in.right->tn.lval <= 0 && !ISUNSIGNED(p->in.right->in.type) && p->in.right->tn.rval == NONAME ){ ! 372: werror( "degenerate unsigned comparison" ); ! 373: } ! 374: break; ! 375: ! 376: case COMOP: ! 377: down1 = EFF; ! 378: ! 379: case ANDAND: ! 380: case OROR: ! 381: case QUEST: ! 382: down2 = down; ! 383: /* go recursively left, then right */ ! 384: np1 = lnp; ! 385: lprt( p->in.left, down1, use1 ); ! 386: np2 = lnp; ! 387: lprt( p->in.right, down2, use2 ); ! 388: lmerge( np1, np2, 0 ); ! 389: return; ! 390: ! 391: case SCONV: ! 392: case PCONV: ! 393: case COLON: ! 394: down1 = down2 = down; ! 395: break; ! 396: ! 397: case CALL: ! 398: case STCALL: ! 399: case FORTCALL: ! 400: acount = ctargs( p->in.right ); ! 401: case UNARY CALL: ! 402: case UNARY STCALL: ! 403: case UNARY FORTCALL: ! 404: if( p->in.left->in.op == ICON && (id=p->in.left->tn.rval) != NONAME ){ /* used to be &name */ ! 405: struct symtab *sp = &stab[id]; ! 406: int lty; ! 407: ! 408: fsave( ftitle ); ! 409: /* ! 410: * if we're generating a library -C then ! 411: * we don't want to output references to functions ! 412: */ ! 413: if( Cflag ) break; ! 414: /* if a function used in an effects context is ! 415: * cast to type void then consider its value ! 416: * to have been disposed of properly ! 417: * thus a call of type undef in an effects ! 418: * context is construed to be used in a value ! 419: * context ! 420: */ ! 421: if ((down == EFF) && (p->in.type != UNDEF)) { ! 422: lty = LUE; ! 423: } else if (down == EFF) { ! 424: lty = LUV | LUE; ! 425: } else { ! 426: lty = LUV; ! 427: } ! 428: outdef( sp, lty, acount ); ! 429: if( acount ) { ! 430: lpta( p->in.right ); ! 431: } ! 432: } ! 433: break; ! 434: ! 435: case ICON: ! 436: /* look for &name case */ ! 437: if( (id = p->tn.rval) >= 0 && id != NONAME ){ ! 438: q = &stab[id]; ! 439: q->sflags |= (SREF|SSET); ! 440: q->suse = -lineno; ! 441: } ! 442: return; ! 443: ! 444: case NAME: ! 445: if( (id = p->tn.rval) >= 0 && id != NONAME ){ ! 446: q = &stab[id]; ! 447: if( (uses&VALUSED) && !(q->sflags&SSET) ){ ! 448: if( q->sclass == AUTO || q->sclass == REGISTER ){ ! 449: if( !ISARY(q->stype ) && !ISFTN(q->stype) && q->stype!=STRTY && q->stype!=UNIONTY ){ ! 450: #ifndef FLEXNAMES ! 451: werror( "%.8s may be used before set", q->sname ); ! 452: #else ! 453: werror( "%s may be used before set", q->sname ); ! 454: #endif ! 455: q->sflags |= SSET; ! 456: } ! 457: } ! 458: } ! 459: if( uses & VALASGOP ) break; /* not a real use */ ! 460: if( uses & VALSET ) q->sflags |= SSET; ! 461: if( uses & VALUSED ) q->sflags |= SREF; ! 462: if( uses & VALADDR ) q->sflags |= (SREF|SSET); ! 463: if( p->tn.lval == 0 ){ ! 464: lnp->lid = id; ! 465: lnp->flgs = (uses&VALADDR)?0:((uses&VALSET)?VALSET:VALUSED); ! 466: if( ++lnp >= &lnames[LNAMES] ) --lnp; ! 467: } ! 468: } ! 469: return; ! 470: ! 471: } ! 472: ! 473: /* recurse, going down the right side first if we can */ ! 474: ! 475: switch( optype(p->in.op) ){ ! 476: ! 477: case BITYPE: ! 478: np1 = lnp; ! 479: lprt( p->in.right, down2, use2 ); ! 480: case UTYPE: ! 481: np2 = lnp; ! 482: lprt( p->in.left, down1, use1 ); ! 483: } ! 484: ! 485: if( optype(p->in.op) == BITYPE ){ ! 486: if( p->in.op == ASSIGN && p->in.left->in.op == NAME ){ /* special case for a = .. a .. */ ! 487: lmerge( np1, np2, 0 ); ! 488: } ! 489: else lmerge( np1, np2, p->in.op != COLON ); ! 490: /* look for assignments to fields, and complain */ ! 491: if( p->in.op == ASSIGN && p->in.left->in.op == FLD && p->in.right->in.op == ICON ) fldcon( p ); ! 492: } ! 493: ! 494: } ! 495: ! 496: lmerge( np1, np2, flag ) struct lnm *np1, *np2; { ! 497: /* np1 and np2 point to lists of lnm members, for the two sides ! 498: * of a binary operator ! 499: * flag is 1 if commutation is possible, 0 otherwise ! 500: * lmerge returns a merged list, starting at np1, resetting lnp ! 501: * it also complains, if appropriate, about side effects ! 502: */ ! 503: ! 504: register struct lnm *npx, *npy; ! 505: ! 506: for( npx = np2; npx < lnp; ++npx ){ ! 507: ! 508: /* is it already there? */ ! 509: for( npy = np1; npy < np2; ++npy ){ ! 510: if( npx->lid == npy->lid ){ /* yes */ ! 511: if( npx->flgs == 0 || npx->flgs == (VALSET|VALUSED) ) ! 512: ; /* do nothing */ ! 513: else if( (npx->flgs|npy->flgs)== (VALSET|VALUSED) || ! 514: (npx->flgs&npy->flgs&VALSET) ){ ! 515: #ifndef FLEXNAMES ! 516: if( flag ) werror( "%.8s evaluation order undefined", stab[npy->lid].sname ); ! 517: #else ! 518: if( flag ) werror( "%s evaluation order undefined", stab[npy->lid].sname ); ! 519: #endif ! 520: } ! 521: if( npy->flgs == 0 ) npx->flgs = 0; ! 522: else npy->flgs |= npx->flgs; ! 523: goto foundit; ! 524: } ! 525: } ! 526: ! 527: /* not there: update entry */ ! 528: np2->lid = npx->lid; ! 529: np2->flgs = npx->flgs; ! 530: ++np2; ! 531: ! 532: foundit: ; ! 533: } ! 534: ! 535: /* all finished: merged list is at np1 */ ! 536: lnp = np2; ! 537: } ! 538: ! 539: efcode(){ ! 540: /* code for the end of a function */ ! 541: register struct symtab *cfp; ! 542: ! 543: cfp = &stab[curftn]; ! 544: if( retstat & RETVAL && !(Cflag && cfp->sclass==STATIC) ) ! 545: outdef( cfp, LRV, DECTY ); ! 546: if( !vflag ){ ! 547: vflag = argflag; ! 548: argflag = 0; ! 549: } ! 550: if( retstat == RETVAL+NRETVAL ) ! 551: #ifndef FLEXNAMES ! 552: werror( "function %.8s has return(e); and return;", cfp->sname); ! 553: #else ! 554: werror( "function %s has return(e); and return;", cfp->sname); ! 555: #endif ! 556: } ! 557: ! 558: aocode(p) struct symtab *p; { ! 559: /* called when automatic p removed from stab */ ! 560: register struct symtab *cfs; ! 561: cfs = &stab[curftn]; ! 562: if(p->suse>0 && !(p->sflags&(SMOS|STAG)) ){ ! 563: if( p->sclass == PARAM ){ ! 564: #ifndef FLEXNAMES ! 565: if( vflag ) werror( "argument %.8s unused in function %.8s", ! 566: #else ! 567: if( vflag ) werror( "argument %s unused in function %s", ! 568: #endif ! 569: p->sname, ! 570: cfs->sname ); ! 571: } ! 572: else { ! 573: #ifndef FLEXNAMES ! 574: if( p->sclass != TYPEDEF ) werror( "%.8s unused in function %.8s", ! 575: #else ! 576: if( p->sclass != TYPEDEF ) werror( "%s unused in function %s", ! 577: #endif ! 578: p->sname, cfs->sname ); ! 579: } ! 580: } ! 581: ! 582: if( p->suse < 0 && (p->sflags & (SSET|SREF|SMOS)) == SSET && ! 583: !ISARY(p->stype) && !ISFTN(p->stype) ){ ! 584: ! 585: #ifndef FLEXNAMES ! 586: werror( "%.8s set but not used in function %.8s", p->sname, cfs->sname ); ! 587: #else ! 588: werror( "%s set but not used in function %s", p->sname, cfs->sname ); ! 589: #endif ! 590: } ! 591: ! 592: if( p->stype == STRTY || p->stype == UNIONTY || p->stype == ENUMTY ){ ! 593: if( !zflag && dimtab[p->sizoff+1] < 0 ) ! 594: #ifndef FLEXNAMES ! 595: werror( "structure %.8s never defined", p->sname ); ! 596: #else ! 597: werror( "structure %s never defined", p->sname ); ! 598: #endif ! 599: } ! 600: ! 601: } ! 602: ! 603: defnam( p ) register struct symtab *p; { ! 604: /* define the current location as the name p->sname */ ! 605: ! 606: if( p->sclass == STATIC && (p->slevel>1 || Cflag) ) return; ! 607: ! 608: if( !ISFTN( p->stype ) ) ! 609: if( p->sclass == STATIC ) outdef( p, LST, USUAL ); ! 610: else outdef( p, libflag?LIB:LDI, USUAL ); ! 611: } ! 612: ! 613: zecode( n ){ ! 614: /* n integer words of zeros */ ! 615: OFFSZ temp; ! 616: temp = n; ! 617: inoff += temp*SZINT; ! 618: ; ! 619: } ! 620: ! 621: andable( p ) NODE *p; { /* p is a NAME node; can it accept & ? */ ! 622: register r; ! 623: ! 624: if( p->in.op != NAME ) cerror( "andable error" ); ! 625: ! 626: if( (r = p->tn.rval) < 0 ) return(1); /* labels are andable */ ! 627: ! 628: if( stab[r].sclass == AUTO || stab[r].sclass == PARAM ) return(0); ! 629: #ifndef FLEXNAMES ! 630: if( stab[r].sclass == REGISTER ) uerror( "can't take & of %.8s", stab[r].sname ); ! 631: #else ! 632: if( stab[r].sclass == REGISTER ) uerror( "can't take & of %s", stab[r].sname ); ! 633: #endif ! 634: return(1); ! 635: } ! 636: ! 637: NODE * ! 638: clocal(p) NODE *p; { ! 639: ! 640: /* this is called to do local transformations on ! 641: an expression tree preparitory to its being ! 642: written out in intermediate code. ! 643: */ ! 644: ! 645: /* the major essential job is rewriting the ! 646: automatic variables and arguments in terms of ! 647: REG and OREG nodes */ ! 648: /* conversion ops which are not necessary are also clobbered here */ ! 649: /* in addition, any special features (such as rewriting ! 650: exclusive or) are easily handled here as well */ ! 651: ! 652: register o; ! 653: register unsigned t, tl; ! 654: int s; ! 655: ! 656: switch( o = p->in.op ){ ! 657: ! 658: case SCONV: ! 659: case PCONV: ! 660: if( p->in.left->in.type==ENUMTY ){ ! 661: p->in.left = pconvert( p->in.left ); ! 662: } ! 663: /* assume conversion takes place; type is inherited */ ! 664: t = p->in.type; ! 665: tl = p->in.left->in.type; ! 666: if( aflag && (tl==LONG||tl==ULONG) && (t!=LONG&&t!=ULONG&&t!=UNDEF) ){ ! 667: werror( "long assignment may lose accuracy" ); ! 668: } ! 669: if( aflag>=2 && (tl!=LONG&&tl!=ULONG) && (t==LONG||t==ULONG) && p->in.left->in.op != ICON ){ ! 670: werror( "assignment to long may sign-extend incorrectly" ); ! 671: } ! 672: if( ISPTR(tl) && ISPTR(t) ){ ! 673: tl = DECREF(tl); ! 674: t = DECREF(t); ! 675: switch( ISFTN(t) + ISFTN(tl) ){ ! 676: ! 677: case 0: /* neither is a function pointer */ ! 678: if( talign(t,p->fn.csiz) > talign(tl,p->in.left->fn.csiz) ){ ! 679: if( hflag||pflag ) werror( "possible pointer alignment problem" ); ! 680: } ! 681: break; ! 682: ! 683: case 1: ! 684: werror( "questionable conversion of function pointer" ); ! 685: ! 686: case 2: ! 687: ; ! 688: } ! 689: } ! 690: p->in.left->in.type = p->in.type; ! 691: p->in.left->fn.cdim = p->fn.cdim; ! 692: p->in.left->fn.csiz = p->fn.csiz; ! 693: p->in.op = FREE; ! 694: return( p->in.left ); ! 695: ! 696: case PVCONV: ! 697: case PMCONV: ! 698: if( p->in.right->in.op != ICON ) cerror( "bad conversion"); ! 699: p->in.op = FREE; ! 700: return( buildtree( o==PMCONV?MUL:DIV, p->in.left, p->in.right ) ); ! 701: ! 702: case RS: ! 703: case LS: ! 704: case ASG RS: ! 705: case ASG LS: ! 706: if( p->in.right->in.op != ICON ) ! 707: break; ! 708: s = p->in.right->tn.lval; ! 709: if( s < 0 ) ! 710: werror( "negative shift" ); ! 711: else ! 712: if( s >= dimtab[ p->fn.csiz ] ) ! 713: werror( "shift greater than size of object" ); ! 714: break; ! 715: ! 716: } ! 717: ! 718: return(p); ! 719: } ! 720: ! 721: NODE * ! 722: offcon( off, t, d, s ) OFFSZ off; TWORD t;{ /* make a structure offset node */ ! 723: register NODE *p; ! 724: p = bcon(0); ! 725: p->tn.lval = off/SZCHAR; ! 726: return(p); ! 727: } ! 728: ! 729: noinit(){ ! 730: /* storage class for such as "int a;" */ ! 731: return( pflag ? EXTDEF : EXTERN ); ! 732: } ! 733: ! 734: ! 735: cinit( p, sz ) NODE *p; { /* initialize p into size sz */ ! 736: inoff += sz; ! 737: if( p->in.op == INIT ){ ! 738: if( p->in.left->in.op == ICON ) return; ! 739: if( p->in.left->in.op == NAME && p->in.left->in.type == MOE ) return; ! 740: } ! 741: uerror( "illegal initialization" ); ! 742: } ! 743: ! 744: char * ! 745: exname( p ) char *p; { ! 746: /* make a name look like an external name in the local machine */ ! 747: static char aa[8]; ! 748: register int i; ! 749: ! 750: if( !pflag ) return(p); ! 751: for( i=0; i<6; ++i ){ ! 752: if( isupper(*p ) ) aa[i] = tolower( *p ); ! 753: else aa[i] = *p; ! 754: if( *p ) ++p; ! 755: } ! 756: aa[6] = '\0'; ! 757: return( aa ); ! 758: } ! 759: ! 760: char * ! 761: strip(s) char *s; { ! 762: #ifndef FLEXNAMES ! 763: static char x[LFNM+1]; ! 764: #else ! 765: static char x[BUFSIZ]; ! 766: #endif ! 767: register char *p; ! 768: static int stripping = 0; ! 769: ! 770: if (stripping) ! 771: return(s); ! 772: stripping++; ! 773: for( p=x; *s; ++s ){ ! 774: if( *s != '"' ){ ! 775: #ifndef FLEXNAMES ! 776: /* PATCHED by ROBERT HENRY on 8Jul80 to fix 14 character file name bug */ ! 777: if( p >= &x[LFNM] ) ! 778: #else ! 779: if( p >= &x[BUFSIZ] ) ! 780: #endif ! 781: cerror( "filename too long" ); ! 782: *p++ = *s; ! 783: } ! 784: } ! 785: stripping = 0; ! 786: *p = '\0'; ! 787: #ifndef FLEXNAMES ! 788: return( x ); ! 789: #else ! 790: return( hash(x) ); ! 791: #endif ! 792: } ! 793: ! 794: fsave( s ) char *s; { ! 795: static union rec fsname; ! 796: s = strip( s ); ! 797: #ifndef FLEXNAMES ! 798: if( strncmp( s, fsname.f.fn, LFNM ) ) ! 799: #else ! 800: if (fsname.f.fn == NULL || strcmp(s, fsname.f.fn)) ! 801: #endif ! 802: { ! 803: /* new one */ ! 804: #ifndef FLEXNAMES ! 805: strncpy( fsname.f.fn, s, LFNM ); ! 806: #else ! 807: fsname.f.fn = s; ! 808: #endif ! 809: fsname.f.decflag = LFN; ! 810: fwrite( (char *)&fsname, sizeof(fsname), 1, stdout ); ! 811: #ifdef FLEXNAMES ! 812: /* if generating a library, prefix with the library name */ ! 813: /* only do this for flexnames */ ! 814: if( libname ){ ! 815: fwrite( libname, strlen(libname), 1, stdout ); ! 816: putchar( ':' ); ! 817: } ! 818: fwrite( fsname.f.fn, strlen(fsname.f.fn)+1, 1, stdout ); ! 819: #endif ! 820: } ! 821: } ! 822: ! 823: where(f){ /* print true location of error */ ! 824: if( f == 'u' && nerrors > 1 ) ! 825: --nerrors; /* don't get "too many errors" */ ! 826: fprintf( stderr, "%s(%d): ", strip(ftitle), lineno); ! 827: } ! 828: ! 829: /* a number of dummy routines, unneeded by lint */ ! 830: ! 831: branch(n){;} ! 832: defalign(n){;} ! 833: deflab(n){;} ! 834: bycode(t,i){;} ! 835: cisreg(t) TWORD t; {return(1);} /* everyting is a register variable! */ ! 836: ! 837: fldty(p) struct symtab *p; { ! 838: ; /* all types are OK here... */ ! 839: } ! 840: ! 841: fldal(t) unsigned t; { /* field alignment... */ ! 842: if( t == ENUMTY ) return( ALCHAR ); /* this should be thought through better... */ ! 843: if( ISPTR(t) ){ /* really for the benefit of honeywell (and someday IBM) */ ! 844: if( pflag ) uerror( "nonportable field type" ); ! 845: } ! 846: else uerror( "illegal field type" ); ! 847: return(ALINT); ! 848: } ! 849: ! 850: main( argc, argv ) char *argv[]; { ! 851: char *p; ! 852: int i; ! 853: ! 854: /* handle options */ ! 855: ! 856: for( i = 1; i < argc; i++ ) ! 857: for( p=argv[i]; *p; ++p ){ ! 858: ! 859: switch( *p ){ ! 860: ! 861: case '-': ! 862: continue; ! 863: ! 864: case '\0': ! 865: break; ! 866: ! 867: case 'b': ! 868: brkflag = 1; ! 869: continue; ! 870: ! 871: case 'p': ! 872: pflag = 1; ! 873: continue; ! 874: ! 875: case 'c': ! 876: cflag = 1; ! 877: continue; ! 878: ! 879: case 's': ! 880: /* for the moment, -s triggers -h */ ! 881: ! 882: case 'h': ! 883: hflag = 1; ! 884: continue; ! 885: ! 886: case 'L': ! 887: libflag = 1; ! 888: case 'v': ! 889: vflag = 0; ! 890: continue; ! 891: ! 892: case 'x': ! 893: xflag = 1; ! 894: continue; ! 895: ! 896: case 'a': ! 897: ++aflag; ! 898: case 'u': /* done in second pass */ ! 899: case 'n': /* done in shell script */ ! 900: continue; ! 901: ! 902: case 'z': ! 903: zflag = 1; ! 904: continue; ! 905: ! 906: case 't': ! 907: werror( "option %c now default: see `man 6 lint'", *p ); ! 908: continue; ! 909: ! 910: case 'P': /* debugging, done in second pass */ ! 911: continue; ! 912: ! 913: case 'C': ! 914: Cflag = 1; ! 915: if( p[1] ) libname = p + 1; ! 916: while( p[1] ) p++; ! 917: continue; ! 918: ! 919: default: ! 920: uerror( "illegal option: %c", *p ); ! 921: continue; ! 922: ! 923: } ! 924: } ! 925: ! 926: if( !pflag ){ /* set sizes to sizes of target machine */ ! 927: # ifdef gcos ! 928: SZCHAR = ALCHAR = 9; ! 929: # else ! 930: SZCHAR = ALCHAR = 8; ! 931: # endif ! 932: SZINT = ALINT = sizeof(int)*SZCHAR; ! 933: SZFLOAT = ALFLOAT = sizeof(float)*SZCHAR; ! 934: SZDOUBLE = ALDOUBLE = sizeof(double)*SZCHAR; ! 935: SZLONG = ALLONG = sizeof(long)*SZCHAR; ! 936: SZSHORT = ALSHORT = sizeof(short)*SZCHAR; ! 937: SZPOINT = ALPOINT = sizeof(int *)*SZCHAR; ! 938: ALSTRUCT = ALINT; ! 939: /* now, fix some things up for various machines (I wish we had "alignof") */ ! 940: ! 941: # ifdef pdp11 ! 942: ALLONG = ALDOUBLE = ALFLOAT = ALINT; ! 943: #endif ! 944: # ifdef ibm ! 945: ALSTRUCT = ALCHAR; ! 946: #endif ! 947: } ! 948: ! 949: return( mainp1( argc, argv ) ); ! 950: } ! 951: ! 952: ctype( type ) unsigned type; { /* are there any funny types? */ ! 953: return( type ); ! 954: } ! 955: ! 956: commdec( i ){ ! 957: /* put out a common declaration */ ! 958: if( stab[i].sclass == STATIC ) outdef( &stab[i], LST, USUAL ); ! 959: else outdef( &stab[i], libflag?LIB:LDC, USUAL ); ! 960: } ! 961: ! 962: isitfloat ( s ) char *s; { ! 963: /* s is a character string; ! 964: if floating point is implemented, set dcon to the value of s */ ! 965: /* lint version ! 966: */ ! 967: dcon = atof( s ); ! 968: return( DCON ); ! 969: } ! 970: ! 971: fldcon( p ) register NODE *p; { ! 972: /* p is an assignment of a constant to a field */ ! 973: /* check to see if the assignment is going to overflow, or otherwise cause trouble */ ! 974: register s; ! 975: CONSZ v; ! 976: ! 977: if( !hflag & !pflag ) return; ! 978: ! 979: s = UPKFSZ(p->in.left->tn.rval); ! 980: v = p->in.right->tn.lval; ! 981: ! 982: switch( p->in.left->in.type ){ ! 983: ! 984: case CHAR: ! 985: case INT: ! 986: case SHORT: ! 987: case LONG: ! 988: case ENUMTY: ! 989: if( v>=0 && (v>>(s-1))==0 ) return; ! 990: werror( "precision lost in assignment to (possibly sign-extended) field" ); ! 991: default: ! 992: return; ! 993: ! 994: case UNSIGNED: ! 995: case UCHAR: ! 996: case USHORT: ! 997: case ULONG: ! 998: if( v<0 || (v>>s)!=0 ) werror( "precision lost in field assignment" ); ! 999: ! 1000: return; ! 1001: } ! 1002: ! 1003: } ! 1004: ! 1005: outdef( p, lty, mode ) struct symtab *p; { ! 1006: /* output a definition for the second pass */ ! 1007: /* if mode is > USUAL, it is the number of args */ ! 1008: char *fname; ! 1009: TWORD t; ! 1010: int line; ! 1011: static union rec rc; ! 1012: ! 1013: if( mode == NOFILE ){ ! 1014: fname = "???"; ! 1015: line = p->suse; ! 1016: } ! 1017: else if( mode == SVLINE ){ ! 1018: fname = ftitle; ! 1019: line = -p->suse; ! 1020: } ! 1021: else { ! 1022: fname = ftitle; ! 1023: line = lineno; ! 1024: } ! 1025: fsave( fname ); ! 1026: #ifndef FLEXNAMES ! 1027: strncpy( rc.l.name, exname(p->sname), LCHNM ); ! 1028: #endif ! 1029: rc.l.decflag = lty; ! 1030: t = p->stype; ! 1031: if( mode == DECTY ) t = DECREF(t); ! 1032: rc.l.type.aty = t; ! 1033: rc.l.type.extra = 0; ! 1034: rc.l.type.extra1 = 0; ! 1035: astype( &rc.l.type, p->sizoff ); ! 1036: rc.l.nargs = (mode>USUAL) ? mode : 0; ! 1037: rc.l.fline = line; ! 1038: fwrite( (char *)&rc, sizeof(rc), 1, stdout ); ! 1039: #ifdef FLEXNAMES ! 1040: rc.l.name = exname(p->sname); ! 1041: fwrite( rc.l.name, strlen(rc.l.name)+1, 1, stdout ); ! 1042: #endif ! 1043: } ! 1044: int proflg; ! 1045: int gdebug;
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.