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