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