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