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