![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to lint2.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 lint2.c CVS log | Up to [Research Unix] / researchv10no / cmd / lint |
1.1 root 1: # include "manifest"
2: # include "lint.h"
3:
4: # define USED 01
5: # define VUSED 02
6: # define EUSED 04
7: # define RVAL 010
8: # define VARARGS 0100
9:
10: # define NSZ 2048
11: # define TYSZ 3500
12: # define FSZ 250
13: # define NTY 50
14:
15: typedef struct sty STYPE;
16: struct sty { ATYPE t; STYPE *next; };
17:
18: typedef struct sym {
19: #ifndef FLEXNAMES
20: char name[LCHNM];
21: #else
22: char *name;
23: #endif
24: short nargs;
25: int decflag;
26: int fline;
27: STYPE symty;
28: int fno;
29: int use;
30: } STAB;
31:
32: STAB stab[NSZ];
33: STAB *find();
34:
35: STYPE tary[TYSZ];
36: STYPE *tget();
37:
38: #ifndef FLEXNAMES
39: char fnm[FSZ][LFNM];
40: #else
41: char *fnm[FSZ];
42: #endif
43:
44: #ifdef FLEXNAMES
45: char *getstr();
46: #endif
47:
48: int tfree; /* used to allocate types */
49: int ffree; /* used to save filenames */
50:
51: struct ty atyp[NTY];
52: /* r is where all the input ends up */
53: union rec r;
54:
55: int hflag = 0;
56: int pflag = 0;
57: int xflag = 0;
58: int uflag = 1;
59: int ddddd = 0;
60:
61: int cfno; /* current file number */
62:
63: #ifdef FMTARGS
64: FILE *stmpfile; /* string tmp file pointer */
65: char *stmpname; /* string tmp file name */
66: #endif
67:
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: #ifdef FMTARGS
76: fmtinit();
77: #endif
78: for( ; argc>2 && argv[argc-1][0] == '-' ; --argc ){
79: for( p=argv[argc-1]; *p; ++p ){
80: switch( *p ){
81:
82: case 'h':
83: hflag = 1;
84: break;
85:
86: case 'p':
87: pflag = 1;
88: break;
89:
90: case 'x':
91: xflag = 1;
92: break;
93:
94: case 'X':
95: ddddd = 1;
96: break;
97:
98: case 'u':
99: uflag = 0;
100: break;
101:
102: #ifdef FMTARGS
103: case 'S':
104: for (stmpname = p + 1; p[1]; p++);
105: if (!(stmpfile = fopen (stmpname, "r"))) {
106: error ("%s: can't open", stmpname);
107: exit (1);
108: }
109: break;
110: #endif
111: }
112: }
113: }
114:
115: if( argc < 2 || !freopen( argv[1], "r", stdin ) ){
116: error( "cannot open intermediate file" );
117: exit( 1 );
118: }
119:
120: mloop( LDI|LIB );
121: rewind( stdin );
122: mloop( LDC|LDX );
123: rewind( stdin );
124: mloop( LRV|LUV|LUE|LUM );
125: cleanup();
126: return(0);
127: }
128:
129: mloop( m ){
130: /* do the main loop */
131: register STAB *q;
132:
133: while( lread(m) ){
134: q = find();
135: if( q->decflag ) chkcompat(q);
136: else setuse(q);
137: }
138: }
139:
140: lread(m){ /* read a line into r.l */
141:
142: register n;
143:
144: for(;;) {
145: if( fread( (char *)&r, sizeof(r), 1, stdin ) <= 0 ) return(0);
146: if( r.l.decflag & LFN ){
147: /* new filename */
148: #ifdef FLEXNAMES
149: r.f.fn = getstr();
150: #endif
151: setfno( r.f.fn );
152: continue;
153: }
154: #ifdef FLEXNAMES
155: r.l.name = getstr();
156: #endif
157:
158: n = r.l.nargs;
159: if( n<0 ) n = -n;
160: if( n ){
161: if( n>=NTY ) error( "more than %d args?", n );
162: fread( (char *)atyp, sizeof(ATYPE), n, stdin );
163: }
164: if( ( r.l.decflag & m ) ) return( 1 );
165: }
166: }
167:
168: setfno( s ) char *s; {
169: /* look up current file names */
170: /* first, strip backwards to the beginning or to the first / */
171: int i;
172:
173: /* now look up s */
174: for( i=0; i<ffree; ++i ){
175: #ifndef FLEXNAMES
176: if( !strncmp( s, fnm[i], LFNM ) ){
177: #else
178: if (fnm[i] == s){
179: #endif
180: cfno = i;
181: return;
182: }
183: }
184: /* make a new entry */
185: if( ffree >= FSZ ) error( "more than %d files", FSZ );
186: #ifndef FLEXNAMES
187: strncpy( fnm[ffree], s, LFNM );
188: #else
189: fnm[ffree] = s;
190: #endif
191: cfno = ffree++;
192: }
193:
194: /* VARARGS */
195: error( s, a ) char *s; {
196:
197: #ifndef FLEXNAMES
198: fprintf( stderr, "pass 2 error:(file %.*s) ", LFNM, fnm[cfno] );
199: #else
200: fprintf( stderr, "pass 2 error:(file %s) ", fnm[cfno] );
201: #endif
202: fprintf( stderr, s, a );
203: fprintf( stderr, "\n" );
204: exit(1);
205: }
206:
207: STAB *
208: find(){
209: /* for this to work, NSZ should be a power of 2 */
210: register h=0;
211: #ifndef FLEXNAMES
212: { register char *p, *q;
213: for( h=0,p=r.l.name,q=p+LCHNM; *p&&p<q; ++p) {
214: h = (h<<1)+ *p;
215: if( h>=NSZ ){
216: h = (h+1)&(NSZ-1);
217: }
218: }
219: }
220: #else
221: h = ((int)r.l.name)%NSZ;
222: #endif
223: { register STAB *p, *q;
224: for( p=q= &stab[h]; q->decflag; ){
225: /* this call to strncmp should be taken out... */
226: #ifndef FLEXNAMES
227: if( !strncmp( r.l.name, q->name, LCHNM)) return(q);
228: #else
229: if (r.l.name == q->name) return (q);
230: #endif
231: if( ++q >= &stab[NSZ] ) q = stab;
232: if( q == p ) error( "too many names defined" );
233: }
234: #ifndef FLEXNAMES
235: strncpy( q->name, r.l.name, LCHNM );
236: #else
237: q->name = r.l.name;
238: #endif
239: return( q );
240: }
241: }
242:
243: STYPE *
244: tget(){
245: if( tfree >= TYSZ ){
246: error( "too many types needed" );
247: }
248: return( &tary[tfree++] );
249: }
250:
251: chkcompat(q) STAB *q; {
252: /* are the types, etc. in r.l and q compatible */
253: register int i;
254: STYPE *qq;
255:
256: setuse(q);
257:
258: /* argument check */
259:
260: if( q->decflag & (LDI|LIB|LUV|LUE) ){
261: if( r.l.decflag & (LUV|LIB|LUE) ){
262: #ifdef FMTARGS
263: if (q->decflag & (LPF|LSF)) {
264: fmtcheck (q);
265: if(r.l.nargs > q->nargs)
266: r.l.nargs = q->nargs;
267: q->use |= VARARGS;
268: }
269: #endif
270: if( q->nargs != r.l.nargs ){
271: if( !(q->use&VARARGS) ){
272: #ifndef FLEXNAMES
273: printf( "%.8s: variable # of args.", q->name );
274: #else
275: printf( "%s: variable # of args.", q->name );
276: #endif
277: viceversa(q);
278: }
279: if( r.l.nargs > q->nargs ) r.l.nargs = q->nargs;
280: if( !(q->decflag & (LDI|LIB) ) ) {
281: q->nargs = r.l.nargs;
282: q->use |= VARARGS;
283: }
284: }
285: for( i=0,qq=q->symty.next; i<r.l.nargs; ++i,qq=qq->next){
286: if( chktype( &qq->t, &atyp[i] ) ){
287: #ifndef FLEXNAMES
288: printf( "%.8s, arg. %d used inconsistently",
289: #else
290: printf( "%s, arg. %d used inconsistently",
291: #endif
292: q->name, i+1 );
293: viceversa(q);
294: }
295: }
296: }
297: }
298:
299: if( (q->decflag&(LDI|LIB|LUV)) && r.l.decflag==LUV ){
300: if( chktype( &r.l.type, &q->symty.t ) ){
301: #ifndef FLEXNAMES
302: printf( "%.8s value used inconsistently", q->name );
303: #else
304: printf( "%s value used inconsistently", q->name );
305: #endif
306: viceversa(q);
307: }
308: }
309:
310: /* check for multiple declaration */
311:
312: if( (q->decflag&LDI) && (r.l.decflag&(LDI|LIB)) ){
313: #ifndef FLEXNAMES
314: printf( "%.8s multiply declared", q->name );
315: #else
316: printf( "%s multiply declared", q->name );
317: #endif
318: viceversa(q);
319: }
320:
321: /* do a bit of checking of definitions and uses... */
322:
323: if( (q->decflag & (LDI|LIB|LDX|LDC|LUM)) && (r.l.decflag & (LDX|LDC|LUM)) && q->symty.t.aty != r.l.type.aty ){
324: #ifndef FLEXNAMES
325: printf( "%.8s value declared inconsistently", q->name );
326: #else
327: printf( "%s value declared inconsistently", q->name );
328: #endif
329: viceversa(q);
330: }
331:
332: /* better not call functions which are declared to be structure or union returning */
333:
334: if( (q->decflag & (LDI|LIB|LDX|LDC)) && (r.l.decflag & LUE) && q->symty.t.aty != r.l.type.aty ){
335: /* only matters if the function returns union or structure */
336: TWORD ty;
337: ty = q->symty.t.aty;
338: if( ISFTN(ty) && ((ty = DECREF(ty))==STRTY || ty==UNIONTY ) ){
339: #ifndef FLEXNAMES
340: printf( "%.8s function value type must be declared before use", q->name );
341: #else
342: printf( "%s function value type must be declared before use", q->name );
343: #endif
344: viceversa(q);
345: }
346: }
347:
348: if( pflag && q->decflag==LDX && r.l.decflag == LUM && !ISFTN(q->symty.t.aty) ){
349: /* make the external declaration go away */
350: /* in effect, it was used without being defined */
351: }
352: }
353:
354: viceversa(q) STAB *q; {
355: /* print out file comparison */
356: #ifndef FLEXNAMES
357: printf( " %.*s(%d) :: %.*s(%d)\n",
358: LFNM, fnm[q->fno], q->fline,
359: LFNM, fnm[cfno], r.l.fline );
360: #else
361: printf( " %s(%d) :: %s(%d)\n",
362: fnm[q->fno], q->fline,
363: fnm[cfno], r.l.fline );
364: #endif
365: }
366:
367: /* messages for defintion/use */
368: char *
369: mess[2][2] ={
370: "",
371: #ifndef FLEXNAMES
372: "%.8s used( %.*s(%d) ), but not defined\n",
373: "%.8s defined( %.*s(%d) ), but never used\n",
374: "%.8s declared( %.*s(%d) ), but never used or defined\n"
375: #else
376: "%s used( %s(%d) ), but not defined\n",
377: "%s defined( %s(%d) ), but never used\n",
378: "%s declared( %s(%d) ), but never used or defined\n"
379: #endif
380: };
381:
382: lastone(q) STAB *q; {
383:
384: register nu, nd, uses;
385:
386: if( ddddd ) pst(q);
387:
388: nu = nd = 0;
389: uses = q->use;
390:
391: #ifdef FMTARGS
392: /* not needed anymore, right? */
393: q->decflag &= ~(LPF|LSF);
394: #endif
395:
396: if( !(uses&USED) && q->decflag != LIB ) {
397: #ifndef FLEXNAMES
398: if( strncmp(q->name,"main",7) )
399: #else
400: if (strcmp(q->name, "main"))
401: #endif
402: nu = 1;
403: }
404:
405: if( !ISFTN(q->symty.t.aty) ){
406: switch( q->decflag ){
407:
408: case LIB:
409: nu = nd = 0; /* don't complain about uses on libraries */
410: break;
411: case LDX:
412: if( !xflag ) break;
413: case LUV:
414: case LUE:
415: /* 01/04/80 */ case LUV | LUE:
416: case LUM:
417: nd = 1;
418: }
419: }
420: if( uflag && ( nu || nd ) ) printf( mess[nu][nd],
421: #ifndef FLEXNAMES
422: q->name, LFNM, fnm[q->fno], q->fline );
423: #else
424: q->name, fnm[q->fno], q->fline );
425: #endif
426:
427: if( (uses&(RVAL+EUSED)) == (RVAL+EUSED) ){
428: #ifndef FLEXNAMES
429: printf( "%.8s returns value which is %s ignored\n", q->name,
430: #else
431: printf( "%s returns value which is %s ignored\n", q->name,
432: #endif
433: uses&VUSED ? "sometimes" : "always" );
434: }
435:
436: if( (uses&(RVAL+VUSED)) == (VUSED) && (q->decflag&(LDI|LIB)) ){
437: #ifndef FLEXNAMES
438: printf( "%.8s value is used, but none returned\n", q->name );
439: #else
440: printf( "%s value is used, but none returned\n", q->name );
441: #endif
442: }
443: }
444:
445: cleanup(){ /* call lastone and die gracefully */
446: STAB *q;
447: for( q=stab; q< &stab[NSZ]; ++q ){
448: if( q->decflag ) lastone(q);
449: }
450: exit(0);
451: }
452:
453: setuse(q) STAB *q; { /* check new type to ensure that it is used */
454:
455: if( !q->decflag ){ /* new one */
456: q->decflag = r.l.decflag;
457: q->symty.t = r.l.type;
458: if( r.l.nargs < 0 ){
459: q->nargs = -r.l.nargs;
460: q->use = VARARGS;
461: }
462: else {
463: q->nargs = r.l.nargs;
464: q->use = 0;
465: }
466: q->fline = r.l.fline;
467: q->fno = cfno;
468: if( q->nargs ){
469: int i;
470: STYPE *qq;
471: for( i=0,qq= &q->symty; i<q->nargs; ++i,qq=qq->next ){
472: qq->next = tget();
473: qq->next->t = atyp[i];
474: }
475: }
476: }
477:
478: switch( r.l.decflag ){
479:
480: case LRV:
481: q->use |= RVAL;
482: return;
483: case LUV:
484: q->use |= VUSED+USED;
485: return;
486: case LUE:
487: q->use |= EUSED+USED;
488: return;
489: /* 01/04/80 */ case LUV | LUE:
490: case LUM:
491: q->use |= USED;
492: return;
493:
494: }
495: }
496:
497: chktype( pt1, pt2 ) register ATYPE *pt1, *pt2; {
498: TWORD t;
499:
500: /* check the two type words to see if they are compatible */
501: /* for the moment, enums are turned into ints, and should be checked as such */
502: if( pt1->aty == ENUMTY ) pt1->aty = INT;
503: if( pt2->aty == ENUMTY ) pt2->aty = INT;
504:
505: if( (t=BTYPE(pt1->aty)==STRTY) || t==UNIONTY ){
506: return( pt1->aty!=pt2->aty || (
507: pt1->extra!=pt2->extra ) );
508: }
509:
510: if( pt2->extra ){ /* constant passed in */
511: if( pt1->aty == UNSIGNED && pt2->aty == INT ) return( 0 );
512: else if( pt1->aty == ULONG && pt2->aty == LONG ) return( 0 );
513: }
514: else if( pt1->extra ){ /* for symmetry */
515: if( pt2->aty == UNSIGNED && pt1->aty == INT ) return( 0 );
516: else if( pt2->aty == ULONG && pt1->aty == LONG ) return( 0 );
517: }
518:
519: return( pt1->aty != pt2->aty );
520: }
521:
522: struct tb { int m; char * nm };
523: ptb( v, tp ) struct tb *tp; {
524: /* print a value from the table */
525: int flag;
526: flag = 0;
527: for( ; tp->m; ++tp ){
528: if( v&tp->m ){
529: if( flag++ ) putchar( '|' );
530: printf( "%s", tp->nm );
531: }
532: }
533: }
534:
535: pst( q ) STAB *q; {
536: /* give a debugging output for q */
537: static struct tb dfs[] = {
538: LDI, "LDI",
539: LIB, "LIB",
540: LDC, "LDC",
541: LDX, "LDX",
542: LRV, "LRV",
543: LUV, "LUV",
544: LUE, "LUE",
545: LUM, "LUM",
546: #ifdef FMTARGS
547: LPF, "printf-like",
548: LSF, "scanf-like",
549: #endif
550: 0, "" };
551:
552: static struct tb us[] = {
553: USED, "USED",
554: VUSED, "VUSED",
555: EUSED, "EUSED",
556: RVAL, "RVAL",
557: VARARGS, "VARARGS",
558: 0, 0,
559: };
560:
561: #ifndef FLEXNAMES
562: printf( "%.8s (", q->name );
563: #else
564: printf( "%s (", q->name );
565: #endif
566: ptb( q->decflag, dfs );
567: printf( "), use= " );
568: ptb( q->use, us );
569: printf( ", line %d, nargs=%d\n", q->fline, q->nargs );
570: }
571:
572: #ifdef FLEXNAMES
573:
574: pty( t, name ) TWORD t; {
575: static char * tnames[] = {
576: "void", "farg", "char", "short",
577: "int", "long", "float", "double",
578: "struct xxx", "union %s", "enum", "moety",
579: "unsigned char", "unsigned short", "unsigned", "unsigned long",
580: "?", "?"
581: };
582:
583: printf( "%s ", tnames[BTYPE(t)] );
584: pty1( t, name, (8 * sizeof (int) - BTSHIFT) / TSHIFT );
585: }
586:
587: pty1( t, name, level ) TWORD t; {
588: register TWORD u;
589:
590: if( level < 0 ){
591: printf( "%s", name );
592: return;
593: }
594: u = t >> level * TSHIFT;
595: if( ISPTR(u) ){
596: printf( "*" );
597: pty1( t, name, level-1 );
598: }
599: else if( ISFTN(u) ){
600: if( level > 0 && ISPTR(u << TSHIFT) ){
601: printf( "(" );
602: pty1( t, name, level-1 );
603: printf( ")()" );
604: }
605: else {
606: pty1( t, name, level-1 );
607: printf( "()" );
608: }
609: }
610: else if( ISARY(u) ){
611: if( level > 0 && ISPTR(u << TSHIFT) ){
612: printf( "(" );
613: pty1( t, name, level-1 );
614: printf( ")[]" );
615: }
616: else {
617: pty1( t, name, level-1 );
618: printf( "[]" );
619: }
620: }
621: else {
622: pty1( t, name, level-1 );
623: }
624: }
625:
626: char *
627: getstr()
628: {
629: char buf[BUFSIZ];
630: register char *cp = buf;
631: register int c;
632:
633: if (feof(stdin) || ferror(stdin))
634: return("");
635: while ((c = getchar()) > 0)
636: *cp++ = c;
637: if (c < 0) {
638: fprintf(stderr, "pass 2 error: intermediate file format error (getstr)");
639: exit(1);
640: }
641: *cp++ = 0;
642: return (hash(buf));
643: }
644:
645: #define NSAVETAB 4096
646: char *savetab;
647: int saveleft;
648:
649: char *
650: savestr(cp)
651: register char *cp;
652: {
653: register int len;
654:
655: len = strlen(cp) + 1;
656: if (len > saveleft) {
657: saveleft = NSAVETAB;
658: if (len > saveleft)
659: saveleft = len;
660: savetab = (char *)malloc(saveleft);
661: if (savetab == 0) {
662: fprintf(stderr, "pass 2 error: ran out of memory (savestr)");
663: exit(1);
664: }
665: }
666: strncpy(savetab, cp, len);
667: cp = savetab;
668: savetab += len;
669: saveleft -= len;
670: return (cp);
671: }
672:
673: /*
674: * The definition for the segmented hash tables.
675: */
676: #define MAXHASH 20
677: #define HASHINC 1013
678: struct ht {
679: char **ht_low;
680: char **ht_high;
681: int ht_used;
682: } htab[MAXHASH];
683:
684: char *
685: hash(s)
686: char *s;
687: {
688: register char **h;
689: register i;
690: register char *cp;
691: struct ht *htp;
692: int sh;
693:
694: /*
695: * The hash function is a modular hash of
696: * the sum of the characters with the sum
697: * doubled before each successive character
698: * is added.
699: */
700: cp = s;
701: i = 0;
702: while (*cp)
703: i = i*2 + *cp++;
704: sh = (i&077777) % HASHINC;
705: cp = s;
706: /*
707: * There are as many as MAXHASH active
708: * hash tables at any given point in time.
709: * The search starts with the first table
710: * and continues through the active tables
711: * as necessary.
712: */
713: for (htp = htab; htp < &htab[MAXHASH]; htp++) {
714: if (htp->ht_low == 0) {
715: register char **hp =
716: (char **) calloc(sizeof (char **), HASHINC);
717: if (hp == 0) {
718: fprintf(stderr, "pass 2 error: ran out of memory (hash)");
719: exit(1);
720: }
721: htp->ht_low = hp;
722: htp->ht_high = htp->ht_low + HASHINC;
723: }
724: h = htp->ht_low + sh;
725: /*
726: * quadratic rehash increment
727: * starts at 1 and incremented
728: * by two each rehash.
729: */
730: i = 1;
731: do {
732: if (*h == 0) {
733: if (htp->ht_used > (HASHINC * 3)/4)
734: break;
735: htp->ht_used++;
736: *h = savestr(cp);
737: return (*h);
738: }
739: if (**h == *cp && strcmp(*h, cp) == 0)
740: return (*h);
741: h += i;
742: i += 2;
743: if (h >= htp->ht_high)
744: h -= HASHINC;
745: } while (i < HASHINC);
746: }
747: fprintf(stderr, "pass 2 error: ran out of hash tables");
748: exit(1);
749: }
750: char *tstrbuf[1];
751: #endif
752:
753:
754: # ifdef FMTARGS
755:
756: #define FMTSIZE 256
757:
758: char *getfmt();
759:
760: static char pftab[256], /* printf */
761: pfltab[128], /* printf %l? */
762: sftab[256], /* scanf */
763: sfhtab[128], /* scanf %h? */
764: sfltab[128]; /* scanf %l? */
765:
766: typedef struct {
767: char *fm_s; /* format characters of interest */
768: char fm_ty; /* expected arg type for fm_c */
769: char fm_lty; /* expected type if preceded by `l' */
770: char fm_hty; /* expected type if preceded by `h' */
771: } Fmtinit;
772:
773:
774: static Fmtinit pinit[] = {
775: { "dox", INT, LONG },
776: { "efgEG", DOUBLE },
777: { "c", INT },
778: { "s", CHAR+PTR },
779: #ifdef USGFMT
780: { "uX", INT, LONG },
781: #else
782: { "DOX", LONG },
783: { "u", UNSIGNED, ULONG },
784: #endif
785: { 0 }
786: };
787:
788: static Fmtinit sinit[] = {
789: { "dox", INT+PTR, LONG+PTR, SHORT+PTR },
790: { "efg", FLOAT+PTR, DOUBLE+PTR },
791: { "cs[", CHAR+PTR },
792: #ifdef USGFMT
793: { "u", UNSIGNED+PTR, ULONG+PTR, USHORT+PTR },
794: #else
795: { "DOX", LONG+PTR },
796: { "EFG", DOUBLE+PTR },
797: #endif
798: { 0 }
799: };
800:
801:
802: chkprintf (q, arg, fmt)
803: STAB *q;
804: register int arg;
805: register char *fmt;
806: {
807: register int c, d;
808: register TWORD ty;
809:
810: while (c = *fmt++) {
811: if (c != '%' || (c = *fmt++) == '%')
812: continue;
813: for (; c=='-' || c=='+' || c=='#' || c==' '; c = *fmt++);
814: if (c == '*') {
815: fmtarg (q, arg++, INT, '*', 0);
816: c = *fmt++;
817: }
818: else for (; c >= '0' && c <= '9'; c = *fmt++);
819: if (c == '.')
820: if ((c = *fmt++) == '*') {
821: fmtarg (q, arg++, INT, '*', 0);
822: c = *fmt++;
823: }
824: else for (; c >= '0' && c <= '9'; c = *fmt++);
825: ty = pftab[c];
826: if (c == 'l' && pftab[c = *fmt++]) {
827: d = 'l';
828: ty = pfltab[c];
829: }
830: else d = 0;
831: if (ty)
832: fmtarg (q, arg++, ty, c, d);
833: else goto bad;
834: }
835:
836: if (arg < r.l.nargs)
837: fmterror (q, "too many args for format");
838: return;
839:
840: bad:
841: fmterror (q, "malformed format string");
842: return;
843: }
844:
845:
846: chkscanf (q, arg, fmt)
847: STAB *q;
848: register int arg;
849: register char *fmt;
850: {
851: register int c, d = 0, suppress;
852: TWORD ty;
853:
854: while (c = *fmt++) {
855: if (c != '%' || (c = *fmt++) == '%')
856: continue;
857: if (suppress = (c == '*'))
858: c = *fmt++;
859: for (; c >= '0' && c <= '9'; c = *fmt++);
860: ty = sftab[c];
861: if (c == '[') {
862: if ((c = *fmt++) == '^')
863: c = *fmt++;
864: if (c == ']')
865: c = *fmt++;
866: for (; c && c != ']'; c = *fmt++);
867: if (c != ']')
868: goto bad;
869: c = '[';
870: }
871: d = 0;
872: if (c == 'l' || c == 'h') {
873: d = c;
874: if (sftab[c = *fmt++])
875: ty = fmt[-2] == 'l' ? sfltab[c] : sfhtab[c];
876: }
877: if (!ty)
878: goto bad;
879: else if (!suppress)
880: fmtarg (q, arg++, ty, c, d);
881: }
882:
883: if (arg < r.l.nargs)
884: fmterror (q, "too many args for format");
885: return;
886:
887: bad:
888: fmterror (q, "malformed format string");
889: return;
890: }
891:
892:
893: fmtarg (q, arg, ty, c, d)
894: STAB *q;
895: char c, d;
896: int arg;
897: TWORD ty;
898: {
899: char buf[16];
900: TWORD ty2;
901:
902: if (arg >= r.l.nargs) {
903: if (arg == r.l.nargs)
904: fmterror (q, "too few args for format");
905: return;
906: }
907:
908: #define deunsign(x) (ISUNSIGNED(BTYPE(x))?((x)&~BTMASK|DEUNSIGN(BTYPE(x))):(x))
909:
910: ty = deunsign (ty);
911: ty2 = deunsign (atyp[arg].aty);
912:
913: if (ty == ty2) /* fat chance ... */
914: return;
915:
916: if (sizeof (int) == sizeof (long))
917: if ((ty & TMASK) == (ty2 & TMASK))
918: if (BTYPE (ty) == INT && BTYPE (ty2) == LONG ||
919: BTYPE (ty) == LONG && BTYPE (ty2) == INT)
920: return;
921:
922: prflex (q->name);
923: printf (": %%%.1s%c for ", &d, c);
924: sprintf (buf, "arg %d", arg+1);
925: pty (atyp[arg].aty, buf);
926: viceversa (q);
927: return;
928: }
929:
930:
931: fmtcheck (q)
932: STAB *q;
933: {
934: char *fmt;
935: int arg = q->nargs;
936:
937: if (r.l.nargs < arg) /* somebody else will complain */
938: return;
939: if (arg < 1) /* should've been caught in pass 1 */
940: return;
941: if (!(fmt = getfmt (atyp+arg-1)))
942: return;
943:
944: if (q->decflag & LPF)
945: chkprintf (q, arg, fmt);
946: else if (q->decflag & LSF)
947: chkscanf (q, arg, fmt);
948: return;
949: }
950:
951:
952: fmterror (q, msg)
953: STAB *q;
954: char *msg;
955: {
956: prflex (q->name);
957: printf (": %s", msg);
958: viceversa (q);
959: }
960:
961:
962: int
963: fmtinit()
964: {
965: char *s;
966: int i;
967:
968: for (i = 0; s = pinit[i].fm_s; i++)
969: for (; *s; s++) {
970: pftab[*s] = pinit[i].fm_ty;
971: pfltab[*s] = pinit[i].fm_lty;
972: }
973: for (i = 0; s = sinit[i].fm_s; i++)
974: for (; *s; s++) {
975: sftab[*s] = sinit[i].fm_ty;
976: sfhtab[*s] = sinit[i].fm_hty;
977: sfltab[*s] = sinit[i].fm_lty;
978: }
979: return;
980: }
981:
982:
983: char *
984: getfmt (a)
985: register ATYPE *a;
986: {
987: static char fmt[FMTSIZE];
988: register char *s = fmt;
989: register int c;
990:
991: if (a->straddr <= 0)
992: return (0); /* not a string constant */
993: if (fseek (stmpfile, a->straddr, 0))
994: error ("cannot fseek string file");
995:
996: while ((c = fgetc (stmpfile)) != EOF && c && s < fmt+FMTSIZE-1)
997: *s++ = c;
998:
999: *s = '\0';
1000: return (fmt);
1001: }
1002:
1003:
1004: prflex (name)
1005: char *name;
1006: {
1007: #ifdef FLEXNAMES
1008: printf ("%s", name);
1009: #else
1010: printf ("%.8s", name);
1011: #endif
1012: }
1013:
1014:
1015: # endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.