op public repos

Blob

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