op public repos

Blob

Date:: Sun Dec 7 00:45:22 2008 UTC
Message:: bc: cleanup, make sure to run 9 dc
Actions:: History | Blame | Raw File
1 %{
2 	#include	<u.h>
3 	#include	<libc.h>
4 	#include	<bio.h>
5 
6 	#define	bsp_max	5000
7 
8 	Biobuf	*in;
9 	Biobuf	bstdin;
10 	Biobuf	bstdout;
11 	char	cary[1000];
12 	char*	cp = { cary };
13 	char	string[1000];
14 	char*	str = { string };
15 	int	crs = 128;
16 	int	rcrs = 128;	/* reset crs */
17 	int	bindx = 0;
18 	int	lev = 0;
19 	int	ln;
20 	char*	ttp;
21 	char*	ss = "";
22 	int	bstack[10] = { 0 };
23 	char*	numb[15] =
24 	{
25 		" 0", " 1", " 2", " 3", " 4", " 5",
26 		" 6", " 7", " 8", " 9", " 10", " 11",
27 		" 12", " 13", " 14"
28 	};
29 	char*	pre;
30 	char*	post;
31 
32 	long	peekc = -1;
33 	int	sargc;
34 	int	ifile;
35 	char**	sargv;
36 
37 	char	*funtab[] =
38 	{
39 		"<1>","<2>","<3>","<4>","<5>",
40 		"<6>","<7>","<8>","<9>","<10>",
41 		"<11>","<12>","<13>","<14>","<15>",
42 		"<16>","<17>","<18>","<19>","<20>",
43 		"<21>","<22>","<23>","<24>","<25>",
44 		"<26>"
45 	};
46 	char	*atab[] =
47 	{
48 		"<221>","<222>","<223>","<224>","<225>",
49 		"<226>","<227>","<228>","<229>","<230>",
50 		"<231>","<232>","<233>","<234>","<235>",
51 		"<236>","<237>","<238>","<239>","<240>",
52 		"<241>","<242>","<243>","<244>","<245>",
53 		"<246>"
54 	};
55 	char*	letr[26] =
56 	{
57 		"a","b","c","d","e","f","g","h","i","j",
58 		"k","l","m","n","o","p","q","r","s","t",
59 		"u","v","w","x","y","z"
60 	};
61 	char*	dot = { "." };
62 	char*	bspace[bsp_max];
63 	char**	bsp_nxt = bspace;
64 	int	bdebug = 0;
65 	int	lflag;
66 	int	cflag;
67 	int	sflag;
68 
69 	char*	bundle(int, ...);
70 	void	conout(char*, char*);
71 	int	cpeek(int, int, int);
72 	int	getch(void);
73 	char*	geta(char*);
74 	char*	getf(char*);
75 	void	getout(void);
76 	void	output(char*);
77 	void	pp(char*);
78 	void	routput(char*);
79 	void	tp(char*);
80 	void	yyerror(char*, ...);
81 	int	yyparse(void);
82 
83 	typedef	void*	pointer;
84 	#pragma	varargck	type	"lx"	pointer
85 
86 %}
87 %union
88 {
89 	char*	cptr;
90 	int	cc;
91 }
92 
93 %type	<cptr>	pstat stat stat1 def slist dlets e ase nase
94 %type	<cptr>	slist re fprefix cargs eora cons constant lora
95 %type	<cptr>	crs
96 
97 %token	<cptr>	LETTER EQOP _AUTO DOT
98 %token	<cc>	DIGIT SQRT LENGTH _IF FFF EQ
99 %token	<cc>	_PRINT _WHILE _FOR NE LE GE INCR DECR
100 %token	<cc>	_RETURN _BREAK _DEFINE BASE OBASE SCALE
101 %token	<cc>	QSTR ERROR
102 
103 %right	'=' EQOP
104 %left	'+' '-'
105 %left	'*' '/' '%'
106 %right	'^'
107 %left	UMINUS
108 
109 %%
110 start:
111 	start stuff
112 |	stuff
113 
114 stuff:
115 	pstat tail
116 	{
117 		output($1);
118 	}
119 |	def dargs ')' '{' dlist slist '}'
120 	{
121 		ttp = bundle(6, pre, $6, post , "0", numb[lev], "Q");
122 		conout(ttp, (char*)$1);
123 		rcrs = crs;
124 		output("");
125 		lev = bindx = 0;
126 	}
127 
128 dlist:
129 	tail
130 |	dlist _AUTO dlets tail
131 
132 stat:
133 	stat1
134 |	nase
135 	{
136 		if(sflag)
137 			bundle(2, $1, "s.");
138 	}
139 
140 pstat:
141 	stat1
142 	{
143 		if(sflag)
144 			bundle(2, $1, "0");
145 	}
146 |	nase
147 	{
148 		if(!sflag)
149 			bundle(2, $1, "ps.");
150 	}
151 
152 stat1:
153 	{
154 		bundle(1, "");
155 	}
156 |	ase
157 	{
158 		bundle(2, $1, "s.");
159 	}
160 |	SCALE '=' e
161 	{
162 		bundle(2, $3, "k");
163 	}
164 |	SCALE EQOP e
165 	{
166 		bundle(4, "K", $3, $2, "k");
167 	}
168 |	BASE '=' e
169 	{
170 		bundle(2, $3, "i");
171 	}
172 |	BASE EQOP e
173 	{
174 		bundle(4, "I", $3, $2, "i");
175 	}
176 |	OBASE '=' e
177 	{
178 		bundle(2, $3, "o");
179 	}
180 |	OBASE EQOP e
181 	{
182 		bundle(4, "O", $3, $2, "o");
183 	}
184 |	QSTR
185 	{
186 		bundle(3, "[", $1, "]P");
187 	}
188 |	_BREAK
189 	{
190 		bundle(2, numb[lev-bstack[bindx-1]], "Q");
191 	}
192 |	_PRINT e
193 	{
194 		bundle(2, $2, "ps.");
195 	}
196 |	_RETURN e
197 	{
198 		bundle(4, $2, post, numb[lev], "Q");
199 	}
200 |	_RETURN
201 	{
202 		bundle(4, "0", post, numb[lev], "Q");
203 	}
204 |	'{' slist '}'
205 	{
206 		$$ = $2;
207 	}
208 |	FFF
209 	{
210 		bundle(1, "fY");
211 	}
212 |	_IF crs BLEV '(' re ')' stat
213 	{
214 		conout($7, $2);
215 		bundle(3, $5, $2, " ");
216 	}
217 |	_WHILE crs '(' re ')' stat BLEV
218 	{
219 		bundle(3, $6, $4, $2);
220 		conout($$, $2);
221 		bundle(3, $4, $2, " ");
222 	}
223 |	fprefix crs re ';' e ')' stat BLEV
224 	{
225 		bundle(5, $7, $5, "s.", $3, $2);
226 		conout($$, $2);
227 		bundle(5, $1, "s.", $3, $2, " ");
228 	}
229 |	'~' LETTER '=' e
230 	{
231 		bundle(3, $4, "S", $2);
232 	}
233 
234 fprefix:
235 	_FOR '(' e ';'
236 	{
237 		$$ = $3;
238 	}
239 
240 BLEV:
241 	=
242 	{
243 		--bindx;
244 	}
245 
246 slist:
247 	stat
248 |	slist tail stat
249 	{
250 		bundle(2, $1, $3);
251 	}
252 
253 tail:
254 	'\n'
255 	{
256 		ln++;
257 	}
258 |	';'
259 
260 re:
261 	e EQ e
262 	{
263 		$$ = bundle(3, $1, $3, "=");
264 	}
265 |	e '<' e
266 	{
267 		bundle(3, $1, $3, ">");
268 	}
269 |	e '>' e
270 	{
271 		bundle(3, $1, $3, "<");
272 	}
273 |	e NE e
274 	{
275 		bundle(3, $1, $3, "!=");
276 	}
277 |	e GE e
278 	{
279 		bundle(3, $1, $3, "!>");
280 	}
281 |	e LE e
282 	{
283 		bundle(3, $1, $3, "!<");
284 	}
285 |	e
286 	{
287 		bundle(2, $1, " 0!=");
288 	}
289 
290 nase:
291 	'(' e ')'
292 	{
293 		$$ = $2;
294 	}
295 |	cons
296 	{
297 		bundle(3, " ", $1, " ");
298 	}
299 |	DOT cons
300 	{
301 		bundle(3, " .", $2, " ");
302 	}
303 |	cons DOT cons
304 	{
305 		bundle(5, " ", $1, ".", $3, " ");
306 	}
307 |	cons DOT
308 	{
309 		bundle(4, " ", $1, ".", " ");
310 	}
311 |	DOT
312 	{
313 		$<cptr>$ = "l.";
314 	}
315 |	LETTER '[' e ']'
316 	{
317 		bundle(3, $3, ";", geta($1));
318 	}
319 |	LETTER INCR
320 	{
321 		bundle(4, "l", $1, "d1+s", $1);
322 	}
323 |	INCR LETTER
324 	{
325 		bundle(4, "l", $2, "1+ds", $2);
326 	}
327 |	DECR LETTER
328 	{
329 		bundle(4, "l", $2, "1-ds", $2);
330 	}
331 |	LETTER DECR
332 	{
333 		bundle(4, "l", $1, "d1-s", $1);
334 	}
335 |	LETTER '[' e ']' INCR
336 	{
337 		bundle(7, $3, ";", geta($1), "d1+" ,$3, ":" ,geta($1));
338 	}
339 |	INCR LETTER '[' e ']'
340 	{
341 		bundle(7, $4, ";", geta($2), "1+d", $4, ":", geta($2));
342 	}
343 |	LETTER '[' e ']' DECR
344 	{
345 		bundle(7, $3, ";", geta($1), "d1-", $3, ":", geta($1));
346 	}
347 |	DECR LETTER '[' e ']'
348 	{
349 		bundle(7, $4, ";", geta($2), "1-d", $4, ":" ,geta($2));
350 	}
351 |	SCALE INCR
352 	{
353 		bundle(1, "Kd1+k");
354 	}
355 |	INCR SCALE
356 	{
357 		bundle(1, "K1+dk");
358 	}
359 |	SCALE DECR
360 	{
361 		bundle(1, "Kd1-k");
362 	}
363 |	DECR SCALE
364 	{
365 		bundle(1, "K1-dk");
366 	}
367 |	BASE INCR
368 	{
369 		bundle(1, "Id1+i");
370 	}
371 |	INCR BASE
372 	{
373 		bundle(1, "I1+di");
374 	}
375 |	BASE DECR
376 	{
377 		bundle(1, "Id1-i");
378 	}
379 |	DECR BASE
380 	{
381 		bundle(1, "I1-di");
382 	}
383 |	OBASE INCR
384 	{
385 		bundle(1, "Od1+o");
386 	}
387 |	INCR OBASE
388 	{
389 		bundle(1, "O1+do");
390 	}
391 |	OBASE DECR
392 	{
393 		bundle(1, "Od1-o");
394 	}
395 |	DECR OBASE
396 	{
397 		bundle(1, "O1-do");
398 	}
399 |	LETTER '(' cargs ')'
400 	{
401 		bundle(4, $3, "l", getf($1), "x");
402 	}
403 |	LETTER '(' ')'
404 	{
405 		bundle(3, "l", getf($1), "x");
406 	}
407 |	LETTER = {
408 		bundle(2, "l", $1);
409 	}
410 |	LENGTH '(' e ')'
411 	{
412 		bundle(2, $3, "Z");
413 	}
414 |	SCALE '(' e ')'
415 	{
416 		bundle(2, $3, "X");
417 	}
418 |	'?'
419 	{
420 		bundle(1, "?");
421 	}
422 |	SQRT '(' e ')'
423 	{
424 		bundle(2, $3, "v");
425 	}
426 |	'~' LETTER
427 	{
428 		bundle(2, "L", $2);
429 	}
430 |	SCALE
431 	{
432 		bundle(1, "K");
433 	}
434 |	BASE
435 	{
436 		bundle(1, "I");
437 	}
438 |	OBASE
439 	{
440 		bundle(1, "O");
441 	}
442 |	'-' e
443 	{
444 		bundle(3, " 0", $2, "-");
445 	}
446 |	e '+' e
447 	{
448 		bundle(3, $1, $3, "+");
449 	}
450 |	e '-' e
451 	{
452 		bundle(3, $1, $3, "-");
453 	}
454 |	e '*' e
455 	{
456 		bundle(3, $1, $3, "*");
457 	}
458 |	e '/' e
459 	{
460 		bundle(3, $1, $3, "/");
461 	}
462 |	e '%' e
463 	{
464 		bundle(3, $1, $3, "%%");
465 	}
466 |	e '^' e
467 	{
468 		bundle(3, $1, $3, "^");
469 	}
470 
471 ase:
472 	LETTER '=' e
473 	{
474 		bundle(3, $3, "ds", $1);
475 	}
476 |	LETTER '[' e ']' '=' e
477 	{
478 		bundle(5, $6, "d", $3, ":", geta($1));
479 	}
480 |	LETTER EQOP e
481 	{
482 		bundle(6, "l", $1, $3, $2, "ds", $1);
483 	}
484 |	LETTER '[' e ']' EQOP e
485 	{
486 		bundle(9, $3, ";", geta($1), $6, $5, "d", $3, ":", geta($1));
487 	}
488 
489 e:
490 	ase
491 |	nase
492 
493 cargs:
494 	eora
495 |	cargs ',' eora
496 	{
497 		bundle(2, $1, $3);
498 	}
499 
500 eora:
501 	e
502 |	LETTER '[' ']'
503 	{
504 		bundle(2, "l", geta($1));
505 	}
506 
507 cons:
508 	constant
509 	{
510 		*cp++ = 0;
511 	}
512 
513 constant:
514 	'_'
515 	{
516 		$<cptr>$ = cp;
517 		*cp++ = '_';
518 	}
519 |	DIGIT
520 	{
521 		$<cptr>$ = cp;
522 		*cp++ = $1;
523 	}
524 |	constant DIGIT
525 	{
526 		*cp++ = $2;
527 	}
528 
529 crs:
530 	=
531 	{
532 		$$ = cp;
533 		*cp++ = '<';
534 		*cp++ = crs/100+'0';
535 		*cp++ = (crs%100)/10+'0';
536 		*cp++ = crs%10+'0';
537 		*cp++ = '>';
538 		*cp++ = '\0';
539 		if(crs++ >= 220) {
540 			yyerror("program too big");
541 			getout();
542 		}
543 		bstack[bindx++] = lev++;
544 	}
545 
546 def:
547 	_DEFINE LETTER '('
548 	{
549 		$$ = getf($2);
550 		pre = (char*)"";
551 		post = (char*)"";
552 		lev = 1;
553 		bindx = 0;
554 		bstack[bindx] = 0;
555 	}
556 
557 dargs:
558 |	lora
559 	{
560 		pp((char*)$1);
561 	}
562 |	dargs ',' lora
563 	{
564 		pp((char*)$3);
565 	}
566 
567 dlets:
568 	lora
569 	{
570 		tp((char*)$1);
571 	}
572 |	dlets ',' lora
573 	{
574 		tp((char*)$3);
575 	}
576 
577 lora:
578 	LETTER
579 	{
580 		$<cptr>$=$1;
581 	}
582 |	LETTER '[' ']'
583 	{
584 		$$ = geta($1);
585 	}
586 
587 %%
588 
589 int
590 yylex(void)
591 {
592 	int c, ch;
593 
594 restart:
595 	c = getch();
596 	peekc = -1;
597 	while(c == ' ' || c == '\t')
598 		c = getch();
599 	if(c == '\\') {
600 		getch();
601 		goto restart;
602 	}
603 	if(c >= 'a' && c <= 'z') {
604 		/* look ahead to look for reserved words */
605 		peekc = getch();
606 		if(peekc >= 'a' && peekc <= 'z') { /* must be reserved word */
607 			if(c=='p' && peekc=='r') {
608 				c = _PRINT;
609 				goto skip;
610 			}
611 			if(c=='i' && peekc=='f') {
612 				c = _IF;
613 				goto skip;
614 			}
615 			if(c=='w' && peekc=='h') {
616 				c = _WHILE;
617 				goto skip;
618 			}
619 			if(c=='f' && peekc=='o') {
620 				c = _FOR;
621 				goto skip;
622 			}
623 			if(c=='s' && peekc=='q') {
624 				c = SQRT;
625 				goto skip;
626 			}
627 			if(c=='r' && peekc=='e') {
628 				c = _RETURN;
629 				goto skip;
630 			}
631 			if(c=='b' && peekc=='r') {
632 				c = _BREAK;
633 				goto skip;
634 			}
635 			if(c=='d' && peekc=='e') {
636 				c = _DEFINE;
637 				goto skip;
638 			}
639 			if(c=='s' && peekc=='c') {
640 				c = SCALE;
641 				goto skip;
642 			}
643 			if(c=='b' && peekc=='a') {
644 				c = BASE;
645 				goto skip;
646 			}
647 			if(c=='i' && peekc=='b') {
648 				c = BASE;
649 				goto skip;
650 			}
651 			if(c=='o' && peekc=='b') {
652 				c = OBASE;
653 				goto skip;
654 			}
655 			if(c=='d' && peekc=='i') {
656 				c = FFF;
657 				goto skip;
658 			}
659 			if(c=='a' && peekc=='u') {
660 				c = _AUTO;
661 				goto skip;
662 			}
663 			if(c=='l' && peekc=='e') {
664 				c = LENGTH;
665 				goto skip;
666 			}
667 			if(c=='q' && peekc=='u')
668 				getout();
669 			/* could not be found */
670 			return ERROR;
671 
672 		skip:	/* skip over rest of word */
673 			peekc = -1;
674 			for(;;) {
675 				ch = getch();
676 				if(ch < 'a' || ch > 'z')
677 					break;
678 			}
679 			peekc = ch;
680 			return c;
681 		}
682 
683 		/* usual case; just one single letter */
684 		yylval.cptr = letr[c-'a'];
685 		return LETTER;
686 	}
687 	if((c >= '0' && c <= '9') || (c >= 'A' && c <= 'F')) {
688 		yylval.cc = c;
689 		return DIGIT;
690 	}
691 	switch(c) {
692 	case '.':
693 		return DOT;
694 	case '*':
695 		yylval.cptr = "*";
696 		return cpeek('=', EQOP, c);
697 	case '%':
698 		yylval.cptr = "%%";
699 		return cpeek('=', EQOP, c);
700 	case '^':
701 		yylval.cptr = "^";
702 		return cpeek('=', EQOP, c);
703 	case '+':
704 		ch = cpeek('=', EQOP, c);
705 		if(ch == EQOP) {
706 			yylval.cptr = "+";
707 			return ch;
708 		}
709 		return cpeek('+', INCR, c);
710 	case '-':
711 		ch = cpeek('=', EQOP, c);
712 		if(ch == EQOP) {
713 			yylval.cptr = "-";
714 			return ch;
715 		}
716 		return cpeek('-', DECR, c);
717 	case '=':
718 		return cpeek('=', EQ, '=');
719 	case '<':
720 		return cpeek('=', LE, '<');
721 	case '>':
722 		return cpeek('=', GE, '>');
723 	case '!':
724 		return cpeek('=', NE, '!');
725 	case '/':
726 		ch = cpeek('=', EQOP, c);
727 		if(ch == EQOP) {
728 			yylval.cptr = "/";
729 			return ch;
730 		}
731 		if(peekc == '*') {
732 			peekc = -1;
733 			for(;;) {
734 				ch = getch();
735 				if(ch == '*') {
736 					peekc = getch();
737 					if(peekc == '/') {
738 						peekc = -1;
739 						goto restart;
740 					}
741 				}
742 			}
743 		}
744 		return c;
745 	case '"':
746 		yylval.cptr = str;
747 		while((c=getch()) != '"'){
748 			*str++ = c;
749 			if(str >= &string[999]){
750 				yyerror("string space exceeded");
751 				getout();
752 			}
753 		}
754 		*str++ = 0;
755 		return QSTR;
756 	default:
757 		return c;
758 	}
759 }
760 
761 int
762 cpeek(int c, int yes, int no)
763 {
764 
765 	peekc = getch();
766 	if(peekc == c) {
767 		peekc = -1;
768 		return yes;
769 	}
770 	return no;
771 }
772 
773 int
774 getch(void)
775 {
776 	long ch;
777 
778 loop:
779 	ch = peekc;
780 	if(ch < 0){
781 		if(in == 0)
782 			ch = -1;
783 		else
784 			ch = Bgetc(in);
785 	}
786 	peekc = -1;
787 	if(ch >= 0)
788 		return ch;
789 
790 	ifile++;
791 	if(ifile >= sargc) {
792 		if(ifile >= sargc+1)
793 			getout();
794 		in = &bstdin;
795 		Binit(in, 0, OREAD);
796 		ln = 0;
797 		goto loop;
798 	}
799 	if(in)
800 		Bterm(in);
801 	if((in = Bopen(sargv[ifile], OREAD)) != 0){
802 		ln = 0;
803 		ss = sargv[ifile];
804 		goto loop;
805 	}
806 	fprint(2, "open %s: %r\n", sargv[ifile]);
807 	yyerror("cannot open input file");
808 	return 0;		/* shut up ken */
809 }
810 
811 char*
812 bundle(int a, ...)
813 {
814 	int i;
815 	char **q;
816 	va_list arg;
817 	
818 	i = a;
819 	va_start(arg, a);
820 	q = bsp_nxt;
821 	if(bdebug)
822 		fprint(2, "bundle %d elements at %lx\n", i, q);
823 	while(i-- > 0) {
824 		if(bsp_nxt >= &bspace[bsp_max])
825 			yyerror("bundling space exceeded");
826 		*bsp_nxt++ = va_arg(arg, char*);
827 	}
828 	*bsp_nxt++ = 0;
829 	va_end(arg);
830 	yyval.cptr = (char*)q;
831 	return (char*)q;
832 }
833 
834 void
835 routput(char *p)
836 {
837 	char **pp;
838 	
839 	if(bdebug)
840 		fprint(2, "routput(%lx)\n", p);
841 	if((char**)p >= &bspace[0] && (char**)p < &bspace[bsp_max]) {
842 		/* part of a bundle */
843 		pp = (char**)p;
844 		while(*pp != 0)
845 			routput(*pp++);
846 	} else
847 		Bprint(&bstdout, p);	/* character string */
848 }
849 
850 void
851 output(char *p)
852 {
853 	routput(p);
854 	bsp_nxt = &bspace[0];
855 	Bprint(&bstdout, "\n");
856 	Bflush(&bstdout);
857 	cp = cary;
858 	crs = rcrs;
859 }
860 
861 void
862 conout(char *p, char *s)
863 {
864 	Bprint(&bstdout, "[");
865 	routput(p);
866 	Bprint(&bstdout, "]s%s\n", s);
867 	Bflush(&bstdout);
868 	lev--;
869 }
870 
871 void
872 yyerror(char *s, ...)
873 {
874 	if(ifile > sargc)
875 		ss = "teletype";
876 	Bprint(&bstdout, "c[%s:%d, %s]pc\n", s, ln+1, ss);
877 	Bflush(&bstdout);
878 	cp = cary;
879 	crs = rcrs;
880 	bindx = 0;
881 	lev = 0;
882 	bsp_nxt = &bspace[0];
883 }
884 
885 void
886 pp(char *s)
887 {
888 	/* puts the relevant stuff on pre and post for the letter s */
889 	bundle(3, "S", s, pre);
890 	pre = yyval.cptr;
891 	bundle(4, post, "L", s, "s.");
892 	post = yyval.cptr;
893 }
894 
895 void
896 tp(char *s)
897 {
898 	/* same as pp, but for temps */
899 	bundle(3, "0S", s, pre);
900 	pre = yyval.cptr;
901 	bundle(4, post, "L", s, "s.");
902 	post = yyval.cptr;
903 }
904 
905 void
906 yyinit(int argc, char **argv)
907 {
908 	Binit(&bstdout, 1, OWRITE);
909 	sargv = argv;
910 	sargc = argc;
911 	if(sargc == 0) {
912 		in = &bstdin;
913 		Binit(in, 0, OREAD);
914 	} else if((in = Bopen(sargv[0], OREAD)) == 0)
915 		yyerror("cannot open input file");
916 	ifile = 0;
917 	ln = 0;
918 	ss = sargv[0];
919 }
920 
921 void
922 getout(void)
923 {
924 	Bprint(&bstdout, "q");
925 	Bflush(&bstdout);
926 	exits(0);
927 }
928 
929 char*
930 getf(char *p)
931 {
932 	return funtab[*p - 'a'];
933 }
934 
935 char*
936 geta(char *p)
937 {
938 	return atab[*p - 'a'];
939 }
940 
941 void
942 main(int argc, char **argv)
943 {
944 	int p[2];
945 
946 	ARGBEGIN{
947 	case 'd':
948 		bdebug++;
949 		break;
950 	case 'c':
951 		cflag++;
952 		break;
953 	case 'l':
954 		lflag++;
955 		break;
956 	case 's':
957 		sflag++;
958 		break;
959 	default:
960 		fprint(2, "Usage: bc [-l] [-c] [file ...]\n");
961 		exits("usage");
962 	}ARGEND
963 	
964 	if(lflag) {
965 		argc++;
966 		argv--;
967 		*argv = unsharp("#9/lib/bclib");
968 	}
969 	if(cflag) {
970 		yyinit(argc, argv);
971 		for(;;)
972 			yyparse();
973 		exits(0);
974 	}
975 	pipe(p);
976 	if(fork() == 0) {
977 		dup(p[1], 1);
978 		close(p[0]);
979 		close(p[1]);
980 		yyinit(argc, argv);
981 		for(;;)
982 			yyparse();
983 	}
984 	dup(p[0], 0);
985 	close(p[0]);
986 	close(p[1]);
987 	execl(unsharp("#9/bin/dc"), "dc", nil);
988 }