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