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