![[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] / 3BSD / cmd / lint|
Return to lint.c CVS log | Up to [CSRG BSD Unix] / 3BSD / cmd / lint |
1.1 root 1: # include "mfile1"
2:
3: # include "lmanifest"
4:
5: # include <ctype.h>
6:
7: # define VAL 0
8: # define EFF 1
9:
10: /* these are appropriate for the -p flag */
11: int SZCHAR = 8;
12: int SZINT = 16;
13: int SZFLOAT = 32;
14: int SZDOUBLE = 64;
15: int SZLONG = 32;
16: int SZSHORT = 16;
17: int SZPOINT = 16;
18: int ALCHAR = 8;
19: int ALINT = 16;
20: int ALFLOAT = 32;
21: int ALDOUBLE = 64;
22: int ALLONG = 32;
23: int ALSHORT = 16;
24: int ALPOINT = 16;
25: int ALSTRUCT = 16;
26:
27: int vflag = 1; /* tell about unused argments */
28: int xflag = 0; /* tell about unused externals */
29: int argflag = 0; /* used to turn off complaints about arguments */
30: int libflag = 0; /* used to generate library descriptions */
31: int vaflag = -1; /* used to signal functions with a variable number of args */
32: int aflag = 0; /* used th check precision of assignments */
33:
34: char *flabel = "xxx";
35:
36: # define LNAMES 100
37:
38: struct lnm {
39: short lid, flgs;
40: } lnames[LNAMES], *lnp;
41:
42: contx( p, down, pl, pr ) register NODE *p; register *pl, *pr; {
43:
44: *pl = *pr = VAL;
45: switch( p->op ){
46:
47: case ANDAND:
48: case OROR:
49: case QUEST:
50: *pr = down;
51: break;
52:
53: case SCONV:
54: case PCONV:
55: case COLON:
56: *pr = *pl = down;
57: break;
58:
59: case COMOP:
60: *pl = EFF;
61: *pr = down;
62:
63: case FORCE:
64: case INIT:
65: case UNARY CALL:
66: case STCALL:
67: case UNARY STCALL:
68: case CALL:
69: case UNARY FORTCALL:
70: case FORTCALL:
71: case CBRANCH:
72: break;
73:
74: default:
75: if( asgop(p->op) ) break;
76: if( p->op == UNARY MUL && ( p->type == STRTY || p->type == UNIONTY) ) {
77: break; /* the compiler does this... */
78: }
79: if( down == EFF && hflag ) werror( "null effect" );
80:
81: }
82: }
83:
84: ecode( p ) NODE *p; {
85: /* compile code for p */
86:
87: fwalk( p, contx, EFF );
88: lnp = lnames;
89: lprt( p, EFF, 0 );
90: }
91:
92: ejobcode( flag ){
93: /* called after processing each job */
94: /* flag is nonzero if errors were detected */
95: register k;
96: register struct symtab *p;
97:
98: for( p=stab; p< &stab[SYMTSZ]; ++p ){
99:
100: if( p->stype != TNULL ) {
101:
102: if( p->stype == STRTY || p->stype == UNIONTY ){
103: if( dimtab[p->sizoff+1] < 0 ){ /* never defined */
104: if( hflag ) werror( "struct/union %.7s never defined", p->sname );
105: }
106: }
107:
108: switch( p->sclass ){
109:
110: case STATIC:
111: if( p->suse > 0 ){
112: k = lineno;
113: lineno = p->suse;
114: uerror( "static variable %s unused",
115: p->sname );
116: lineno = k;
117: break;
118: }
119:
120: case EXTERN:
121: case USTATIC:
122: /* with the xflag, worry about externs not used */
123: /* the filename may be wrong here... */
124: if( xflag && p->suse >= 0 && !libflag ){
125: printf( "%.7s\t%03d\t%o\t%d\t", p->sname, LDX, p->stype, 0 );
126: /* we don't really know the file number; we know only the line
127: number, so we put only that out */
128: printf( "\"???\"\t%d\t%s\n", p->suse, flabel );
129: }
130:
131: case EXTDEF:
132: if( p->suse < 0 ){ /* used */
133: printf( "%.7s\t%03d\t%o\t%d\t", exname(p->sname), LUM, p->stype, 0 );
134: fident( -p->suse );
135: }
136: break;
137: }
138:
139: }
140:
141: }
142: exit( 0 );
143: }
144:
145: fident( line ){ /* like ident, but lineno = line */
146: register temp;
147: temp = lineno;
148: lineno = line;
149: ident();
150: lineno = temp;
151: }
152:
153: ident(){ /* write out file and line identification */
154: printf( "%s\t%d\t%s\n", ftitle, lineno, flabel );
155: }
156:
157: bfcode( a, n ) int a[]; {
158: /* code for the beginning of a function; a is an array of
159: indices in stab for the arguments; n is the number */
160: /* this must also set retlab */
161: register i;
162: register struct symtab *cfp;
163: register unsigned t;
164:
165: retlab = 1;
166: cfp = &stab[curftn];
167:
168: /* if variable number of arguments, only print the ones which will be checked */
169: if( vaflag > 0 ){
170: if( n < vaflag ) werror( "declare the VARARGS arguments you want checked!" );
171: else n = vaflag;
172: }
173: printf( "%.7s\t%03d\t%o\t%d\t", exname(cfp->sname), libflag?LIB:LDI,
174: cfp->stype, vaflag>=0?-n:n );
175: vaflag = -1;
176:
177: for( i=0; i<n; ++i ) {
178: switch( t = stab[a[i]].stype ){
179:
180: case ULONG:
181: break;
182:
183: case CHAR:
184: case SHORT:
185: t = INT;
186: break;
187:
188: case UCHAR:
189: case USHORT:
190: case UNSIGNED:
191: t = UNSIGNED;
192: break;
193:
194: }
195:
196: printf( "%o\t", t );
197: }
198: ident();
199: }
200:
201: ctargs( p ) NODE *p; {
202: /* count arguments; p points to at least one */
203: /* the arguemnts are a tower of commasto the left */
204: register c;
205: c = 1; /* count the rhs */
206: while( p->op == CM ){
207: ++c;
208: p = p->left;
209: }
210: return( c );
211: }
212:
213: lpta( p ) NODE *p; {
214: TWORD t;
215:
216: if( p->op == CM ){
217: lpta( p->left );
218: p = p->right;
219: }
220: switch( t = p->type ){
221:
222: case CHAR:
223: case SHORT:
224: t = INT;
225: case LONG:
226: case ULONG:
227: case INT:
228: case UNSIGNED:
229: break;
230:
231: case UCHAR:
232: case USHORT:
233: t = UNSIGNED;
234: break;
235:
236: case FLOAT:
237: printf( "%o\t", DOUBLE );
238: return;
239:
240: default:
241: printf( "%o\t", p->type );
242: return;
243: }
244:
245: if( p->op == ICON ) printf( "%o<1\t", t );
246: else printf( "%o\t", t );
247: }
248:
249: # define VALSET 1
250: # define VALUSED 2
251: # define VALASGOP 4
252: # define VALADDR 8
253:
254: lprt( p, down, uses ) register NODE *p; {
255: register struct symtab *q;
256: register id;
257: register acount;
258: register down1, down2;
259: register use1, use2;
260: register struct lnm *np1, *np2;
261:
262: /* first, set variables which are set... */
263:
264: use1 = use2 = VALUSED;
265: if( p->op == ASSIGN ) use1 = VALSET;
266: else if( p->op == UNARY AND ) use1 = VALADDR;
267: else if( asgop( p->op ) ){ /* =ops */
268: use1 = VALUSED|VALSET;
269: if( down == EFF ) use1 |= VALASGOP;
270: }
271:
272:
273: /* print the lines for lint */
274:
275: down2 = down1 = VAL;
276: acount = 0;
277:
278: switch( p->op ){
279:
280: case EQ:
281: case NE:
282: case GT:
283: case GE:
284: case LT:
285: case LE:
286: if( p->left->type == CHAR && p->right->op==ICON && p->right->lval < 0 ){
287: werror( "nonportable character comparison" );
288: }
289: if( (p->op==EQ || p->op==NE ) && ISUNSIGNED(p->left->type) && p->right->op == ICON ){
290: if( p->right->lval < 0 && p->right->rval == NONAME && !ISUNSIGNED(p->right->type) ){
291: werror( "comparison of unsigned with negative constant" );
292: }
293: }
294: break;
295:
296: case UGE:
297: case ULT:
298: if( p->right->op == ICON && p->right->lval == 0 && p->right->rval == NONAME ){
299: werror( "unsigned comparison with 0?" );
300: break;
301: }
302: case UGT:
303: case ULE:
304: if( p->right->op == ICON && p->right->lval <= 0 && !ISUNSIGNED(p->right->type) && p->right->rval == NONAME ){
305: werror( "degenerate unsigned comparison" );
306: }
307: break;
308:
309: case COMOP:
310: down1 = EFF;
311:
312: case ANDAND:
313: case OROR:
314: case QUEST:
315: down2 = down;
316: /* go recursively left, then right */
317: np1 = lnp;
318: lprt( p->left, down1, use1 );
319: np2 = lnp;
320: lprt( p->right, down2, use2 );
321: lmerge( np1, np2, 0 );
322: return;
323:
324: case SCONV:
325: case PCONV:
326: case COLON:
327: down1 = down2 = down;
328: break;
329:
330: case CALL:
331: case STCALL:
332: case FORTCALL:
333: acount = ctargs( p->right );
334: case UNARY CALL:
335: case UNARY STCALL:
336: case UNARY FORTCALL:
337: if( p->left->op == ICON && (id=p->left->rval) != NONAME ){ /* used to be &name */
338: printf( "%.7s\t%03d\t%o\t%d\t",
339: exname(stab[id].sname),
340: down==EFF ? LUE : LUV,
341: DECREF(p->left->type), acount );
342: if( acount ) lpta( p->right );
343: ident();
344: }
345: break;
346:
347: case ICON:
348: /* look for &name case */
349: if( (id = p->rval) >= 0 && id != NONAME ){
350: q = &stab[id];
351: q->sflags |= (SREF|SSET);
352: }
353: return;
354:
355: case NAME:
356: if( (id = p->rval) >= 0 && id != NONAME ){
357: q = &stab[id];
358: if( (uses&VALUSED) && !(q->sflags&SSET) ){
359: if( q->sclass == AUTO || q->sclass == REGISTER ){
360: if( !ISARY(q->stype ) && !ISFTN(q->stype) && q->stype!=STRTY ){
361: werror( "%.7s may be used before set", q->sname );
362: q->sflags |= SSET;
363: }
364: }
365: }
366: if( uses & VALASGOP ) break; /* not a real use */
367: if( uses & VALSET ) q->sflags |= SSET;
368: if( uses & VALUSED ) q->sflags |= SREF;
369: if( uses & VALADDR ) q->sflags |= (SREF|SSET);
370: if( p->lval == 0 ){
371: lnp->lid = id;
372: lnp->flgs = (uses&VALADDR)?0:((uses&VALSET)?VALSET:VALUSED);
373: if( ++lnp >= &lnames[LNAMES] ) --lnp;
374: }
375: }
376: return;
377:
378: }
379:
380: /* recurse, going down the right side first if we can */
381:
382: switch( optype(p->op) ){
383:
384: case BITYPE:
385: np1 = lnp;
386: lprt( p->right, down2, use2 );
387: case UTYPE:
388: np2 = lnp;
389: lprt( p->left, down1, use1 );
390: }
391:
392: if( optype(p->op) == BITYPE ){
393: if( p->op == ASSIGN && p->left->op == NAME ){ /* special case for a = .. a .. */
394: lmerge( np1, np2, 0 );
395: }
396: else lmerge( np1, np2, p->op != COLON );
397: /* look for assignments to fields, and complain */
398: if( p->op == ASSIGN && p->left->op == FLD && p->right->op == ICON ) fldcon( p );
399: }
400:
401: }
402:
403: lmerge( np1, np2, flag ) struct lnm *np1, *np2; {
404: /* np1 and np2 point to lists of lnm members, for the two sides
405: * of a binary operator
406: * flag is 1 if commutation is possible, 0 otherwise
407: * lmerge returns a merged list, starting at np1, resetting lnp
408: * it also complains, if appropriate, about side effects
409: */
410:
411: register struct lnm *npx, *npy;
412:
413: for( npx = np2; npx < lnp; ++npx ){
414:
415: /* is it already there? */
416: for( npy = np1; npy < np2; ++npy ){
417: if( npx->lid == npy->lid ){ /* yes */
418: if( npx->flgs == 0 || npx->flgs == (VALSET|VALUSED) )
419: ; /* do nothing */
420: else if( (npx->flgs|npy->flgs)== (VALSET|VALUSED) ||
421: (npx->flgs&npy->flgs&VALSET) ){
422: if( flag ) werror( "%.8s evaluation order undefined", stab[npy->lid].sname );
423: }
424: if( npy->flgs == 0 ) npx->flgs = 0;
425: else npy->flgs |= npx->flgs;
426: goto foundit;
427: }
428: }
429:
430: /* not there: update entry */
431: np2->lid = npx->lid;
432: np2->flgs = npx->flgs;
433: ++np2;
434:
435: foundit: ;
436: }
437:
438: /* all finished: merged list is at np1 */
439: lnp = np2;
440: }
441:
442: efcode(){
443: /* code for the end of a function */
444: register struct symtab *cfp;
445:
446: cfp = &stab[curftn];
447: if( retstat & RETVAL ){
448: printf( "%.7s\t%03d\t%o\t%d\t", exname(cfp->sname),
449: LRV, DECREF( cfp->stype), 0 );
450: ident();
451: }
452: if( !vflag ){
453: vflag = argflag;
454: argflag = 0;
455: }
456: if( retstat == RETVAL+NRETVAL )
457: werror( "function %.8s has return(e); and return;", cfp->sname);
458: }
459:
460: aocode(p) struct symtab *p; {
461: /* called when automatic p removed from stab */
462: register struct symtab *cfs;
463: cfs = &stab[curftn];
464: if(p->suse>0 && !(p->sflags&SMOS) ){
465: if( p->sclass == PARAM ){
466: if( vflag ) werror( "argument %.7s unused in function %.7s",
467: p->sname,
468: cfs->sname );
469: }
470: else {
471: if( p->sclass != TYPEDEF ) werror( "%.7s unused in function %.7s",
472: p->sname, cfs->sname );
473: }
474: }
475:
476: if( p->suse < 0 && (p->sflags & (SSET|SREF|SMOS)) == SSET &&
477: !ISARY(p->stype) && !ISFTN(p->stype) ){
478:
479: werror( "%.7s set but not used in function %.7s", p->sname, cfs->sname );
480: }
481:
482: if( p->stype == STRTY || p->stype == UNIONTY || p->stype == ENUMTY ){
483: if( dimtab[p->sizoff+1] < 0 ) werror( "structure %.7s never defined", p->sname );
484: }
485:
486: }
487:
488: defnam( p ) register struct symtab *p; {
489: /* define the current location as the name p->sname */
490:
491: if( p->sclass == STATIC && p->slevel>1 ) return;
492:
493: if( !ISFTN( p->stype ) ){
494: printf( "%.7s\t%03d\t%o\t%d\t",
495: exname(p->sname), libflag?LIB:LDI, p->stype, 0 );
496: ident();
497: }
498: }
499:
500: zecode( n ){
501: /* n integer words of zeros */
502: OFFSZ temp;
503: temp = n;
504: inoff += temp*SZINT;
505: ;
506: }
507:
508: andable( p ) NODE *p; { /* p is a NAME node; can it accept & ? */
509: register r;
510:
511: if( p->op != NAME ) cerror( "andable error" );
512:
513: if( (r = p->rval) < 0 ) return(1); /* labels are andable */
514:
515: if( stab[r].sclass == AUTO || stab[r].sclass == PARAM ) return(0);
516: return(1);
517: }
518:
519: NODE *
520: clocal(p) NODE *p; {
521:
522: /* this is called to do local transformations on
523: an expression tree preparitory to its being
524: written out in intermediate code.
525: */
526:
527: /* the major essential job is rewriting the
528: automatic variables and arguments in terms of
529: REG and OREG nodes */
530: /* conversion ops which are not necessary are also clobbered here */
531: /* in addition, any special features (such as rewriting
532: exclusive or) are easily handled here as well */
533:
534: register o;
535: register unsigned t, tl;
536:
537: switch( o = p->op ){
538:
539: case SCONV:
540: case PCONV:
541: if( p->left->type==ENUMTY ){
542: p->left = pconvert( p->left );
543: }
544: /* assume conversion takes place; type is inherited */
545: t = p->type;
546: tl = p->left->type;
547: if( aflag && (tl==LONG||tl==ULONG) && (t!=LONG&&t!=ULONG) ){
548: werror( "long assignment may lose accuracy" );
549: }
550: if( ISPTR(tl) && ISPTR(t) ){
551: tl = DECREF(tl);
552: t = DECREF(t);
553: switch( ISFTN(t) + ISFTN(tl) ){
554:
555: case 0: /* neither is a function pointer */
556: if( talign(t,p->csiz) > talign(tl,p->left->csiz) ){
557: if( hflag||pflag ) werror( "possible pointer alignment problem" );
558: }
559: break;
560:
561: case 1:
562: werror( "questionable conversion of function pointer" );
563:
564: case 2:
565: ;
566: }
567: }
568: p->left->type = p->type;
569: p->left->cdim = p->cdim;
570: p->left->csiz = p->csiz;
571: p->op = FREE;
572: return( p->left );
573:
574: case PVCONV:
575: case PMCONV:
576: if( p->right->op != ICON ) cerror( "bad conversion");
577: p->op = FREE;
578: return( buildtree( o==PMCONV?MUL:DIV, p->left, p->right ) );
579:
580: }
581:
582: return(p);
583: }
584:
585: NODE *
586: offcon( off, t, d, s ) OFFSZ off; TWORD t;{ /* make a structure offset node */
587: register NODE *p;
588: p = bcon(0);
589: p->lval = off/SZCHAR;
590: return(p);
591: }
592:
593: noinit(){
594: /* storage class for such as "int a;" */
595: return( pflag ? EXTDEF : EXTERN );
596: }
597:
598:
599: cinit( p, sz ) NODE *p; { /* initialize p into size sz */
600: inoff += sz;
601: if( p->op == INIT ){
602: if( p->left->op == ICON ) return;
603: if( p->left->op == NAME && p->left->type == MOE ) return;
604: }
605: uerror( "illegal initialization" );
606: }
607:
608: char *
609: exname( p ) char *p; {
610: /* make a name look like an external name in the local machine */
611: static char aa[8];
612: register int i;
613:
614: if( !pflag ) return(p);
615: for( i=0; i<6; ++i ){
616: if( isupper(*p ) ) aa[i] = tolower( *p );
617: else aa[i] = *p;
618: if( *p ) ++p;
619: }
620: aa[6] = '\0';
621: return( aa );
622: }
623:
624: where(f){ /* print true location of error */
625: if( f == 'u' && nerrors>1 ) --nerrors; /* don't get "too many errors" */
626: fprintf( stderr, "%s, line %d: ", ftitle, lineno );
627: }
628:
629: /* a number of dummy routines, unneeded by lint */
630:
631: branch(n){;}
632: defalign(n){;}
633: deflab(n){;}
634: bycode(t,i){;}
635: cisreg(t){return(1);} /* everyting is a register variable! */
636:
637: fldty(p) struct symtab *p; {
638: ; /* all types are OK here... */
639: }
640:
641: fldal(t) unsigned t; { /* field alignment... */
642: if( t == ENUMTY ) return( ALCHAR ); /* this should be thought through better... */
643: if( ISPTR(t) ){ /* really for the benefit of honeywell (and someday IBM) */
644: if( pflag ) uerror( "nonportable field type" );
645: }
646: else uerror( "illegal field type" );
647: return(ALINT);
648: }
649:
650: main( argc, argv ) char *argv[]; {
651: char *p;
652:
653: /* handle options */
654:
655: for( p=argv[1]; *p; ++p ){
656:
657: switch( *p ){
658:
659: case '-':
660: continue;
661:
662: case 'L': /* produced by driver program */
663: flabel = p;
664: goto break2;
665:
666: case '\0':
667: break;
668:
669: case 'b':
670: brkflag = 1;
671: continue;
672:
673: case 'p':
674: pflag = 1;
675: continue;
676:
677: case 'c':
678: cflag = 1;
679: continue;
680:
681: case 's':
682: /* for the moment, -s triggers -h */
683:
684: case 'h':
685: hflag = 1;
686: continue;
687:
688: case 'v':
689: vflag = 0;
690: continue;
691:
692: case 'x':
693: xflag = 1;
694: continue;
695:
696: case 'a':
697: aflag = 1;
698: case 'u': /* done in second pass */
699: case 'n': /* done in shell script */
700: continue;
701:
702: case 't':
703: werror( "option %c now default: see `man 6 lint'", *p );
704: continue;
705:
706: default:
707: uerror( "illegal option: %c", *p );
708: continue;
709:
710: }
711: }
712:
713: break2:
714: if( !pflag ){ /* set sizes to sizes of target machine */
715: # ifdef gcos
716: SZCHAR = ALCHAR = 9;
717: # else
718: SZCHAR = ALCHAR = 8;
719: # endif
720: SZINT = ALINT = sizeof(int)*SZCHAR;
721: SZFLOAT = ALFLOAT = sizeof(float)*SZCHAR;
722: SZDOUBLE = ALDOUBLE = sizeof(double)*SZCHAR;
723: SZLONG = ALLONG = sizeof(long)*SZCHAR;
724: SZSHORT = ALSHORT = sizeof(short)*SZCHAR;
725: SZPOINT = ALPOINT = sizeof(int *)*SZCHAR;
726: ALSTRUCT = ALINT;
727: /* now, fix some things up for various machines (I wish we had "alignof") */
728:
729: # ifdef pdp11
730: ALLONG = ALDOUBLE = ALFLOAT = ALINT;
731: #endif
732: # ifdef ibm
733: ALSTRUCT = ALCHAR;
734: #endif
735: }
736:
737: return( mainp1( argc, argv ) );
738: }
739:
740: ctype( type ) unsigned type; { /* are there any funny types? */
741: return( type );
742: }
743:
744: commdec( i ){
745: /* put out a common declaration */
746: register struct symtab *p;
747: p = &stab[i];
748: printf( "%.7s\t%03d\t%o\t%d\t", exname(p->sname), libflag?LIB:LDC, p->stype, 0 );
749: ident();
750: }
751:
752: isitfloat ( s ) char *s; {
753: /* s is a character string;
754: if floating point is implemented, set dcon to the value of s */
755: /* lint version
756: */
757: dcon = atof( s );
758: return( FCON );
759: }
760:
761: fldcon( p ) register NODE *p; {
762: /* p is an assignment of a constant to a field */
763: /* check to see if the assignment is going to overflow, or otherwise cause trouble */
764: register s;
765: CONSZ v;
766:
767: if( !hflag & !pflag ) return;
768:
769: s = UPKFSZ(p->left->rval);
770: v = p->right->lval;
771:
772: switch( p->left->type ){
773:
774: case CHAR:
775: case INT:
776: case SHORT:
777: case LONG:
778: case ENUMTY:
779: if( v>=0 && (v>>(s-1))==0 ) return;
780: werror( "precision lost in assignment to (possibly sign-extended) field" );
781: default:
782: return;
783:
784: case UNSIGNED:
785: case UCHAR:
786: case USHORT:
787: case ULONG:
788: if( v<0 || (v>>s)!=0 ) werror( "precision lost in field assignment" );
789:
790: return;
791: }
792:
793: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.