![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cb.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / cb|
Return to cb.c CVS log | Up to [Research Unix] / researchv10no / cmd / cb |
1.1 root 1: #include <stddef.h>
2: #include <libc.h>
3: #include <stdio.h>
4: #include "cb.h"
5: #include "cbtype.c"
6:
7: main(int argc, char *argv[])
8: {
9: while (--argc > 0 && (*++argv)[0] == '-'){
10: switch ((*argv)[1]){
11: case 's':
12: strict = 1;
13: continue;
14: case 'j':
15: join = 1;
16: continue;
17: case 'l':
18: if((*argv)[2] != '\0'){
19: maxleng = atoi( &((*argv)[2]) );
20: }
21: else{
22: maxleng = atoi(*++argv);
23: argc--;
24: }
25: maxtabs = maxleng/TABLENG - 2;
26: maxleng -= (maxleng + 5)/10;
27: continue;
28: default:
29: fprintf(stderr, "cb: illegal option %c\n", *argv[1]);
30: exit(1);
31: }
32: }
33: if (argc <= 0)work();
34: else {
35: while (argc-- > 0){
36: if ((input = fopen( *argv, "r")) == NULL){
37: fprintf(stderr, "cb: cannot open input file %s\n", *argv);
38: exit(1);
39: }
40: work();
41: argv++;
42: }
43: }
44: return(0);
45: }
46: void
47: work(void){
48: register int c;
49: register struct keyw *lptr;
50: char *pt;
51: char cc;
52: int ct;
53:
54: while ((c = getch()) != EOF){
55: switch (c){
56: case '{':
57: if ((lptr = lookup(lastlook,p)) != 0){
58: if (lptr->type == ELSE)gotelse();
59: else if(lptr->type == DO)gotdo();
60: else if(lptr->type == STRUCT)structlev++;
61: }
62: if(++clev >= &ind[CLEVEL-1]){
63: fprintf(stderr,"too many levels of curly brackets\n");
64: clev = &ind[CLEVEL-1];
65: }
66: clev->pdepth = 0;
67: clev->tabs = (clev-1)->tabs;
68: clearif(clev);
69: if(strict && clev->tabs > 0)
70: putspace(' ',NO);
71: putch(c,NO);
72: getnl();
73: if(keyflag == DATADEF){
74: OUT;
75: }
76: else {
77: OUTK;
78: }
79: clev->tabs++;
80: pt = getnext(0); /* to handle initialized structures */
81: if(*pt == '{'){ /* hide one level of {} */
82: while((c=getch()) != '{')
83: if(c == EOF)error("{");
84: putch(c,NO);
85: if(strict){
86: putch(' ',NO);
87: eatspace();
88: }
89: keyflag = SINIT;
90: }
91: continue;
92: case '}':
93: pt = getnext(0); /* to handle initialized structures */
94: if(*pt == ','){
95: if(strict){
96: putspace(' ',NO);
97: eatspace();
98: }
99: putch(c,NO);
100: putch(*pt,NO);
101: *pt = '\0';
102: ct = getnl();
103: pt = getnext(0);
104: if(*pt == '{'){
105: OUT;
106: while((cc = getch()) != '{')
107: if(cc == EOF)error("}");
108: putch(cc,NO);
109: if(strict){
110: putch(' ',NO);
111: eatspace();
112: }
113: pt = getnext(0);
114: continue;
115: }
116: else if(strict || ct){
117: OUT;
118: }
119: continue;
120: }
121: else if(keyflag == SINIT && *pt == '}'){
122: if(strict)
123: putspace(' ',NO);
124: putch(c,NO);
125: getnl();
126: OUT;
127: keyflag = DATADEF;
128: *pt = '\0';
129: pt = getnext(0);
130: }
131: outs(clev->tabs);
132: if(--clev < ind)clev = ind;
133: ptabs(clev->tabs);
134: putch(c,NO);
135: lbegin = 0;
136: lptr=lookup(pt,lastplace+1);
137: c = *pt;
138: if(*pt == ';' || *pt == ','){
139: putch(*pt,NO);
140: *pt = '\0';
141: lastplace=pt;
142: }
143: ct = getnl();
144: if((dolevel && clev->tabs <= dotabs[dolevel]) || (structlev )
145: || (lptr != 0 &&lptr->type == ELSE&& clev->pdepth == 0)){
146: if(c == ';'){
147: OUTK;
148: }
149: else if(strict || (lptr != 0 && lptr->type == ELSE && ct == 0)){
150: putspace(' ',NO);
151: eatspace();
152: }
153: else if(lptr != 0 && lptr->type == ELSE){
154: OUTK;
155: }
156: if(structlev){
157: structlev--;
158: keyflag = DATADEF;
159: }
160: }
161: else {
162: OUTK;
163: if(strict && clev->tabs == 0){
164: if((c=getch()) != '\n'){
165: putchar('\n');
166: putchar('\n');
167: unget(c);
168: }
169: else {
170: lineno++;
171: putchar('\n');
172: if((c=getch()) != '\n')unget(c);
173: else lineno++;
174: putchar('\n');
175: }
176: }
177: }
178: if(lptr != 0 && lptr->type == ELSE && clev->pdepth != 0){
179: UNBUMP;
180: }
181: if(lptr == 0 || lptr->type != ELSE){
182: clev->iflev = 0;
183: if(dolevel && docurly[dolevel] == NO && clev->tabs == dotabs[dolevel]+1)
184: clev->tabs--;
185: else if(clev->pdepth != 0){
186: UNBUMP;
187: }
188: }
189: continue;
190: case '(':
191: paren++;
192: if ((lptr = lookup(lastlook,p)) != 0){
193: if(!(lptr->type == TYPE || lptr->type == STRUCT))keyflag=KEYWORD;
194: if (strict){
195: putspace(lptr->punc,NO);
196: opflag = 1;
197: }
198: putch(c,NO);
199: if (lptr->type == IF)gotif();
200: }
201: else {
202: putch(c,NO);
203: lastlook = p;
204: opflag = 1;
205: }
206: continue;
207: case ')':
208: if(--paren < 0)paren = 0;
209: putch(c,NO);
210: if((lptr = lookup(lastlook,p)) != 0){
211: if(lptr->type == TYPE || lptr->type == STRUCT)
212: opflag = 1;
213: }
214: else if(keyflag == DATADEF)opflag = 1;
215: else opflag = 0;
216: outs(clev->tabs);
217: pt = getnext(1);
218: if ((ct = getnl()) == 1 && !strict){
219: if(dolevel && clev->tabs <= dotabs[dolevel])
220: resetdo();
221: if(clev->tabs > 0 && (paren != 0 || keyflag == 0)){
222: if(join){
223: eatspace();
224: putch(' ',YES);
225: continue;
226: } else {
227: OUT;
228: split = 1;
229: continue;
230: }
231: }
232: else if(clev->tabs > 0 && *pt != '{'){
233: BUMP;
234: }
235: OUTK;
236: }
237: else if(strict){
238: if(clev->tabs == 0){
239: if(*pt != ';' && *pt != ',' && *pt != '(' && *pt != '['){
240: OUTK;
241: }
242: }
243: else {
244: if(keyflag == KEYWORD && paren == 0){
245: if(dolevel && clev->tabs <= dotabs[dolevel]){
246: resetdo();
247: eatspace();
248: continue;
249: }
250: if(*pt != '{'){
251: BUMP;
252: OUTK;
253: }
254: else {
255: *pt='\0';
256: eatspace();
257: unget('{');
258: }
259: }
260: else if(ct){
261: if(paren){
262: if(join){
263: eatspace();
264: } else {
265: split = 1;
266: OUT;
267: }
268: }
269: else {
270: OUTK;
271: }
272: }
273: }
274: }
275: else if(dolevel && clev->tabs <= dotabs[dolevel])
276: resetdo();
277: continue;
278: case ' ':
279: case '\t':
280: if ((lptr = lookup(lastlook,p)) != 0){
281: if(!(lptr->type==TYPE||lptr->type==STRUCT))
282: keyflag = KEYWORD;
283: else if(paren == 0)keyflag = DATADEF;
284: if(strict){
285: if(lptr->type != ELSE){
286: if(lptr->type == TYPE){
287: if(paren != 0)putch(' ',YES);
288: }
289: else
290: putch(lptr->punc,NO);
291: eatspace();
292: }
293: }
294: else putch(c,YES);
295: switch(lptr->type){
296: case CASE:
297: outs(clev->tabs-1);
298: continue;
299: case ELSE:
300: pt = getnext(1);
301: eatspace();
302: if((cc = getch()) == '\n' && !strict){
303: unget(cc);
304: }
305: else {
306: unget(cc);
307: if(checkif(pt))continue;
308: }
309: gotelse();
310: if(strict) unget(c);
311: if(getnl() == 1 && !strict){
312: OUTK;
313: if(*pt != '{'){
314: BUMP;
315: }
316: }
317: else if(strict){
318: if(*pt != '{'){
319: OUTK;
320: BUMP;
321: }
322: }
323: continue;
324: case IF:
325: gotif();
326: continue;
327: case DO:
328: gotdo();
329: pt = getnext(1);
330: if(*pt != '{'){
331: eatallsp();
332: OUTK;
333: docurly[dolevel] = NO;
334: dopdepth[dolevel] = clev->pdepth;
335: clev->pdepth = 0;
336: clev->tabs++;
337: }
338: continue;
339: case TYPE:
340: if(paren)continue;
341: if(!strict)continue;
342: gottype(lptr);
343: continue;
344: case STRUCT:
345: gotstruct();
346: continue;
347: }
348: }
349: else if (lbegin == 0 || p > string)
350: if(strict)
351: putch(c,NO);
352: else putch(c,YES);
353: continue;
354: case ';':
355: putch(c,NO);
356: if(paren != 0){
357: if(strict){
358: putch(' ',YES);
359: eatspace();
360: }
361: opflag = 1;
362: continue;
363: }
364: outs(clev->tabs);
365: pt = getnext(0);
366: lptr=lookup(pt,lastplace+1);
367: if(lptr == 0 || lptr->type != ELSE){
368: clev->iflev = 0;
369: if(clev->pdepth != 0){
370: UNBUMP;
371: }
372: if(dolevel && docurly[dolevel] == NO && clev->tabs <= dotabs[dolevel]+1)
373: clev->tabs--;
374: /*
375: else if(clev->pdepth != 0){
376: UNBUMP;
377: }
378: */
379: }
380: getnl();
381: OUTK;
382: continue;
383: case '\n':
384: if ((lptr = lookup(lastlook,p)) != 0){
385: pt = getnext(1);
386: if (lptr->type == ELSE){
387: if(strict)
388: if(checkif(pt))continue;
389: gotelse();
390: OUTK;
391: if(*pt != '{'){
392: BUMP;
393: }
394: }
395: else if(lptr->type == DO){
396: OUTK;
397: gotdo();
398: if(*pt != '{'){
399: docurly[dolevel] = NO;
400: dopdepth[dolevel] = clev->pdepth;
401: clev->pdepth = 0;
402: clev->tabs++;
403: }
404: }
405: else {
406: OUTK;
407: if(lptr->type == STRUCT)gotstruct();
408: }
409: }
410: else if(p == string)putchar('\n');
411: else {
412: if(clev->tabs > 0 &&(paren != 0 || keyflag == 0)){
413: if(join){
414: putch(' ',YES);
415: eatspace();
416: continue;
417: } else {
418: OUT;
419: split = 1;
420: continue;
421: }
422: }
423: else if(keyflag == KEYWORD){
424: OUTK;
425: continue;
426: }
427: OUT;
428: }
429: continue;
430: case '"':
431: case '\'':
432: putch(c,NO);
433: while ((cc = getch()) != c){
434: if(cc == EOF)
435: error("\" or '");
436: putch(cc,NO);
437: if (cc == '\\'){
438: putch(getch(),NO);
439: }
440: if (cc == '\n'){
441: outs(clev->tabs);
442: lbegin = 1;
443: count = 0;
444: }
445: }
446: putch(cc,NO);
447: opflag=0;
448: if (getnl() == 1){
449: unget('\n');
450: }
451: continue;
452: case '\\':
453: putch(c,NO);
454: putch(getch(),NO);
455: continue;
456: case '?':
457: question = 1;
458: gotop(c);
459: continue;
460: case ':':
461: if (question == 1){
462: question = 0;
463: gotop(c);
464: continue;
465: }
466: putch(c,NO);
467: if(structlev)continue;
468: if ((lptr = lookup(lastlook,p)) != 0){
469: if (lptr->type == CASE)outs(clev->tabs - 1);
470: }
471: else {
472: lbegin = 0;
473: outs(clev->tabs);
474: }
475: getnl();
476: OUTK;
477: continue;
478: case '/':
479: if ((cc = getch()) != '*'){
480: unget(cc);
481: gotop(c);
482: continue;
483: }
484: putch(c,NO);
485: putch(cc,NO);
486: cc = comment(YES);
487: if(getnl() == 1){
488: if(cc == 0){
489: OUT;
490: }
491: else {
492: outs(0);
493: putchar('\n');
494: lbegin = 1;
495: count = 0;
496: }
497: lastlook = 0;
498: }
499: continue;
500: case '[':
501: putch(c,NO);
502: ct = 0;
503: while((c = getch()) != ']' || ct > 0){
504: if(c == EOF)error("]");
505: putch(c,NO);
506: if(c == '[')ct++;
507: if(c == ']')ct--;
508: }
509: putch(c,NO);
510: continue;
511: case '#':
512: putch(c,NO);
513: while ((cc = getch()) != '\n'){
514: if(cc == EOF)error("newline");
515: if (cc == '\\'){
516: putch(cc,NO);
517: cc = getch();
518: }
519: putch(cc,NO);
520: }
521: putch(cc,NO);
522: lbegin = 0;
523: outs(clev->tabs);
524: lbegin = 1;
525: count = 0;
526: continue;
527: default:
528: if (c == ','){
529: opflag = 1;
530: putch(c,YES);
531: if (strict){
532: if ((cc = getch()) != ' ')unget(cc);
533: if(cc != '\n')putch(' ',YES);
534: }
535: }
536: else if(isop(c))gotop(c);
537: else {
538: if(isalnum(c) && lastlook == 0)lastlook = p;
539: if(isdigit(c)){
540: putch(c,NO);
541: while(isdigit(c=getc(input))||c == '.')putch(c,NO);
542: if(c == 'e'){
543: putch(c,NO);
544: c = getc(input);
545: putch(c, NO);
546: while(isdigit(c=getc(input)))putch(c,NO);
547: }
548: ungetc(c,input);
549: }
550: else putch(c,NO);
551: if(keyflag != DATADEF)opflag = 0;
552: }
553: }
554: }
555: }
556: void
557: gotif(void){
558: outs(clev->tabs);
559: if(++clev->iflev >= IFLEVEL-1){
560: fprintf(stderr,"too many levels of if %d\n",clev->iflev );
561: clev->iflev = IFLEVEL-1;
562: }
563: clev->ifc[clev->iflev] = clev->tabs;
564: clev->spdepth[clev->iflev] = clev->pdepth;
565: }
566: void
567: gotelse(void){
568: clev->tabs = clev->ifc[clev->iflev];
569: clev->pdepth = clev->spdepth[clev->iflev];
570: if(--(clev->iflev) < 0)clev->iflev = 0;
571: }
572: int
573: checkif(char *pt)
574: {
575: register struct keyw *lptr;
576: int cc;
577: if((lptr=lookup(pt,lastplace+1))!= 0){
578: if(lptr->type == IF){
579: if(strict)putch(' ',YES);
580: copy(lptr->name);
581: *pt='\0';
582: lastplace = pt;
583: if(strict){
584: putch(lptr->punc,NO);
585: eatallsp();
586: }
587: clev->tabs = clev->ifc[clev->iflev];
588: clev->pdepth = clev->spdepth[clev->iflev];
589: keyflag = KEYWORD;
590: return(1);
591: }
592: }
593: return(0);
594: }
595: void
596: gotdo(void){
597: if(++dolevel >= DOLEVEL-1){
598: fprintf(stderr,"too many levels of do %d\n",dolevel);
599: dolevel = DOLEVEL-1;
600: }
601: dotabs[dolevel] = clev->tabs;
602: docurly[dolevel] = YES;
603: }
604: void
605: resetdo(void){
606: if(docurly[dolevel] == NO)
607: clev->pdepth = dopdepth[dolevel];
608: if(--dolevel < 0)dolevel = 0;
609: }
610: void
611: gottype(struct keyw *lptr)
612: {
613: char *pt;
614: struct keyw *tlptr;
615: int c;
616: while(1){
617: pt = getnext(1);
618: if((tlptr=lookup(pt,lastplace+1))!=0){
619: putch(' ',YES);
620: copy(tlptr->name);
621: *pt='\0';
622: lastplace = pt;
623: if(tlptr->type == STRUCT){
624: putch(tlptr->punc,YES);
625: gotstruct();
626: break;
627: }
628: lptr=tlptr;
629: continue;
630: }
631: else{
632: putch(lptr->punc,NO);
633: while((c=getch())== ' ' || c == '\t');
634: unget(c);
635: break;
636: }
637: }
638: }
639: void
640: gotstruct(void){
641: int c;
642: int cc;
643: char *pt;
644: while((c=getch()) == ' ' || c == '\t')
645: if(!strict)putch(c,NO);
646: if(c == '{'){
647: structlev++;
648: unget(c);
649: return;
650: }
651: if(isalpha(c)){
652: putch(c,NO);
653: while(isalnum(c=getch()))putch(c,NO);
654: }
655: unget(c);
656: pt = getnext(1);
657: if(*pt == '{')structlev++;
658: if(strict){
659: eatallsp();
660: putch(' ',NO);
661: }
662: }
663: void
664: gotop(int c)
665: {
666: char optmp[OPLENGTH];
667: char *op_ptr;
668: struct op *s_op;
669: char *a, *b;
670: op_ptr = optmp;
671: *op_ptr++ = c;
672: while (isop(( *op_ptr = getch())))op_ptr++;
673: if(!strict)unget(*op_ptr);
674: else if (*op_ptr != ' ')unget( *op_ptr);
675: *op_ptr = '\0';
676: s_op = op;
677: b = optmp;
678: while ((a = s_op->name) != 0){
679: op_ptr = b;
680: while ((*op_ptr == *a) && (*op_ptr != '\0')){
681: a++;
682: op_ptr++;
683: }
684: if (*a == '\0'){
685: keep(s_op);
686: opflag = s_op->setop;
687: if (*op_ptr != '\0'){
688: b = op_ptr;
689: s_op = op;
690: continue;
691: }
692: else break;
693: }
694: else s_op++;
695: }
696: }
697: void
698: keep(struct op *o)
699: {
700: char *s;
701: int ok;
702: if(o->blanks == NEVER)ok = NO;
703: else ok = YES;
704: if (strict && ((o->blanks & ALWAYS)
705: || ((opflag == 0 && o->blanks & SOMETIMES) && clev->tabs != 0)))
706: putspace(' ',YES);
707: for(s=o->name; *s != '\0'; s++){
708: if(*(s+1) == '\0')putch(*s,ok);
709: else
710: putch(*s,NO);
711: }
712: if (strict && ((o->blanks & ALWAYS)
713: || ((opflag == 0 && o->blanks & SOMETIMES) && clev->tabs != 0))) putch(' ',YES);
714: }
715: int
716: getnl(void){
717: register int ch;
718: char *savp;
719: int gotcmt;
720: gotcmt = 0;
721: savp = p;
722: while ((ch = getch()) == '\t' || ch == ' ')putch(ch,NO);
723: if (ch == '/'){
724: if ((ch = getch()) == '*'){
725: putch('/',NO);
726: putch('*',NO);
727: comment(NO);
728: ch = getch();
729: gotcmt=1;
730: }
731: else {
732: if(inswitch)*(++lastplace) = ch;
733: else {
734: inswitch = 1;
735: *lastplace = ch;
736: }
737: unget('/');
738: return(0);
739: }
740: }
741: if(ch == '\n'){
742: if(gotcmt == 0)p=savp;
743: return(1);
744: }
745: unget(ch);
746: return(0);
747: }
748: void
749: ptabs(int n){
750: int i;
751: int num;
752: if(n > maxtabs){
753: if(!folded){
754: printf("/* code folded from here */\n");
755: folded = 1;
756: }
757: num = n-maxtabs;
758: }
759: else {
760: num = n;
761: if(folded){
762: folded = 0;
763: printf("/* unfolding */\n");
764: }
765: }
766: for (i = 0; i < num; i++)putchar('\t');
767: }
768: void
769: outs(int n){
770: if (p > string){
771: if (lbegin){
772: ptabs(n);
773: lbegin = 0;
774: if (split == 1){
775: split = 0;
776: if (clev->tabs > 0)printf(" ");
777: }
778: }
779: *p = '\0';
780: printf("%s", string);
781: lastlook = p = string;
782: }
783: else {
784: if (lbegin != 0){
785: lbegin = 0;
786: split = 0;
787: }
788: }
789: }
790: void
791: putch(char c,int ok)
792: {
793: register int cc;
794: if(p < &string[LINE-1]){
795: if(count+TABLENG*clev->tabs >= maxleng && ok && !folded){
796: if(c != ' ')*p++ = c;
797: OUT;
798: split = 1;
799: if((cc=getch()) != '\n')unget(cc);
800: }
801: else {
802: *p++ = c;
803: count++;
804: }
805: }
806: else {
807: outs(clev->tabs);
808: *p++ = c;
809: count = 0;
810: }
811: }
812: struct keyw *
813: lookup(char *first, char *last)
814: {
815: struct keyw *ptr;
816: char *cptr, *ckey, *k;
817:
818: if(first == last || first == 0)return(0);
819: cptr = first;
820: while (*cptr == ' ' || *cptr == '\t')cptr++;
821: if(cptr >= last)return(0);
822: ptr = key;
823: while ((ckey = ptr->name) != 0){
824: for (k = cptr; (*ckey == *k && *ckey != '\0'); k++, ckey++);
825: if(*ckey=='\0' && (k==last|| (k<last && !isalnum(*k)))){
826: opflag = 1;
827: lastlook = 0;
828: return(ptr);
829: }
830: ptr++;
831: }
832: return(0);
833: }
834: int
835: comment(int ok)
836: {
837: register int ch;
838: int hitnl;
839:
840: hitnl = 0;
841: while ((ch = getch()) != EOF){
842: putch(ch, NO);
843: if (ch == '*'){
844: gotstar:
845: if ((ch = getch()) == '/'){
846: putch(ch,NO);
847: return(hitnl);
848: }
849: putch(ch,NO);
850: if (ch == '*')goto gotstar;
851: }
852: if (ch == '\n'){
853: if(ok && !hitnl){
854: outs(clev->tabs);
855: }
856: else {
857: outs(0);
858: }
859: lbegin = 1;
860: count = 0;
861: hitnl = 1;
862: }
863: }
864: return(hitnl);
865: }
866: void
867: putspace(char ch, int ok)
868: {
869: if(p == string)putch(ch,ok);
870: else if (*(p - 1) != ch) putch(ch,ok);
871: }
872: char
873: getch(void){
874: register char c;
875: if(inswitch){
876: if(next != '\0'){
877: c=next;
878: next = '\0';
879: return(c);
880: }
881: if(tptr <= lastplace){
882: if(*tptr != '\0')return(*tptr++);
883: else if(++tptr <= lastplace)return(*tptr++);
884: }
885: inswitch=0;
886: lastplace = tptr = temp;
887: }
888: return(getc(input));
889: }
890: void
891: unget(char c)
892: {
893: if(inswitch){
894: if(tptr != temp)
895: *(--tptr) = c;
896: else next = c;
897: }
898: else ungetc(c,input);
899: }
900: char *
901: getnext(int must){
902: int c;
903: char *beg;
904: int prect,nlct;
905: prect = nlct = 0;
906: if(tptr > lastplace){
907: tptr = lastplace = temp;
908: err = 0;
909: inswitch = 0;
910: }
911: tp = beg = lastplace;
912: if(inswitch && tptr <= lastplace)
913: if (isalnum(*lastplace)||ispunct(*lastplace)||isop(*lastplace))return(lastplace);
914: space:
915: while(isspace(c=getc(input)))puttmp(c,1);
916: beg = tp;
917: puttmp(c,1);
918: if(c == '/'){
919: if(puttmp((c=getc(input)),1) == '*'){
920: cont:
921: while((c=getc(input)) != '*'){
922: puttmp(c,0);
923: if(must == 0 && c == '\n')
924: if(nlct++ > 2)goto done;
925: }
926: puttmp(c,1);
927: star:
928: if(puttmp((c=getc(input)),1) == '/'){
929: beg = tp;
930: puttmp((c=getc(input)),1);
931: }
932: else if(c == '*')goto star;
933: else goto cont;
934: }
935: else goto done;
936: }
937: if(isspace(c))goto space;
938: if(c == '#' && tp > temp+1 && *(tp-2) == '\n'){
939: if(prect++ > 2)goto done;
940: while(puttmp((c=getc(input)),1) != '\n')
941: if(c == '\\')puttmp(getc(input),1);
942: goto space;
943: }
944: if(isalnum(c)){
945: while(isalnum(c = getc(input)))puttmp(c,1);
946: ungetc(c,input);
947: }
948: done:
949: puttmp('\0',1);
950: lastplace = tp-1;
951: inswitch = 1;
952: return(beg);
953: }
954: void
955: copy(char *s)
956: {
957: while(*s != '\0')putch(*s++,NO);
958: }
959: void
960: clearif(struct indent *cl)
961: {
962: int i;
963: for(i=0;i<IFLEVEL-1;i++)cl->ifc[i] = 0;
964: }
965: char
966: puttmp(char c, int keep)
967: {
968: if(tp < &temp[TEMP-120])
969: *tp++ = c;
970: else {
971: if(keep){
972: if(tp >= &temp[TEMP-1]){
973: fprintf(stderr,"can't look past huge comment - quiting\n");
974: exit(1);
975: }
976: *tp++ = c;
977: }
978: else if(err == 0){
979: err++;
980: fprintf(stderr,"truncating long comment\n");
981: }
982: }
983: return(c);
984: }
985: void
986: error(char *s)
987: {
988: fprintf(stderr,"saw EOF while looking for %s\n",s);
989: exit(1);
990: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.