xref: /dragonfly/usr.bin/bc/bc.y (revision 20c2db9a) 
1 %{
2 /*
3  * $OpenBSD: bc.y,v 1.32 2006/05/18 05:49:53 otto Exp $
4  */
5 
6 /*
7  * Copyright (c) 2003, Otto Moerbeek <otto@drijf.net>
8  *
9  * Permission to use, copy, modify, and distribute this software for any
10  * purpose with or without fee is hereby granted, provided that the above
11  * copyright notice and this permission notice appear in all copies.
12  *
13  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
14  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
15  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
16  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
17  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
18  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
19  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
20  */
21 
22 /*
23  * This implementation of bc(1) uses concepts from the original 4.4
24  * BSD bc(1). The code itself is a complete rewrite, based on the
25  * Posix defined bc(1) grammar. Other differences include type safe
26  * usage of pointers to build the tree of emitted code, typed yacc
27  * rule values, dynamic allocation of all data structures and a
28  * completely rewritten lexical analyzer using lex(1).
29  *
30  * Some effort has been made to make sure that the generated code is
31  * the same as the code generated by the older version, to provide
32  * easy regression testing.
33  */
34 
35 #include <sys/types.h>
36 #include <sys/wait.h>
37 
38 #include <ctype.h>
39 #include <err.h>
40 #include <errno.h>
41 #include <histedit.h>
42 #include <limits.h>
43 #include <search.h>
44 #include <signal.h>
45 #include <stdarg.h>
46 #include <stdbool.h>
47 #include <stdlib.h>
48 #include <string.h>
49 #include <unistd.h>
50 
51 #include "extern.h"
52 #include "pathnames.h"
53 
54 #define END_NODE	((ssize_t) -1)
55 #define CONST_STRING	((ssize_t) -2)
56 #define ALLOC_STRING	((ssize_t) -3)
57 
58 struct tree {
59 	ssize_t			index;
60 	union {
61 		char		*astr;
62 		const char	*cstr;
63 	} u;
64 };
65 
66 int			yyparse(void);
67 int			yywrap(void);
68 
69 int			fileindex;
70 int			sargc;
71 char			**sargv;
72 char			*filename;
73 char			*cmdexpr;
74 
75 static void		grow(void);
76 static ssize_t		cs(const char *);
77 static ssize_t		as(const char *);
78 static ssize_t		node(ssize_t, ...);
79 static void		emit(ssize_t);
80 static void		emit_macro(int, ssize_t);
81 static void		free_tree(void);
82 static ssize_t		numnode(int);
83 static ssize_t		lookup(char *, size_t, char);
84 static ssize_t		letter_node(char *);
85 static ssize_t		array_node(char *);
86 static ssize_t		function_node(char *);
87 
88 static void		add_par(ssize_t);
89 static void		add_local(ssize_t);
90 static void		warning(const char *);
91 static void		init(void);
92 static __dead2 void    	usage(void);
93 static char		*escape(const char *);
94 
95 static ssize_t		instr_sz = 0;
96 static struct tree	*instructions = NULL;
97 static ssize_t		current = 0;
98 static int		macro_char = '0';
99 static int		reset_macro_char = '0';
100 static int		nesting = 0;
101 static int		breakstack[16];
102 static int		breaksp = 0;
103 static ssize_t		prologue;
104 static ssize_t		epilogue;
105 static bool		st_has_continue;
106 static char		str_table[UCHAR_MAX][2];
107 static bool		do_fork = true;
108 static u_short		var_count;
109 static pid_t		dc;
110 
111 extern char *__progname;
112 
113 #define BREAKSTACK_SZ	(sizeof(breakstack)/sizeof(breakstack[0]))
114 
115 /* These values are 4.4BSD bc compatible */
116 #define FUNC_CHAR	0x01
117 #define ARRAY_CHAR	0xa1
118 
119 /* Skip '\0', [, \ and ] */
120 #define ENCODE(c)	((c) < '[' ? (c) : (c) + 3);
121 #define VAR_BASE	(256-4)
122 #define MAX_VARIABLES	(VAR_BASE * VAR_BASE)
123 
124 %}
125 
126 %start program
127 
128 %union {
129 	ssize_t		node;
130 	struct lvalue	lvalue;
131 	const char	*str;
132 	char		*astr;
133 }
134 
135 %token COMMA SEMICOLON LPAR RPAR LBRACE RBRACE LBRACKET RBRACKET DOT
136 %token NEWLINE
137 %token <astr> LETTER
138 %token <str> NUMBER STRING
139 %token DEFINE BREAK QUIT LENGTH
140 %token RETURN FOR IF WHILE SQRT
141 %token SCALE IBASE OBASE AUTO
142 %token CONTINUE ELSE PRINT
143 
144 %left BOOL_OR
145 %left BOOL_AND
146 %nonassoc BOOL_NOT
147 %nonassoc EQUALS LESS_EQ GREATER_EQ UNEQUALS LESS GREATER
148 %right <str> ASSIGN_OP
149 %left PLUS MINUS
150 %left MULTIPLY DIVIDE REMAINDER
151 %right EXPONENT
152 %nonassoc UMINUS
153 %nonassoc INCR DECR
154 
155 %type <lvalue>	named_expression
156 %type <node>	argument_list
157 %type <node>	alloc_macro
158 %type <node>	expression
159 %type <node>	function
160 %type <node>	function_header
161 %type <node>	input_item
162 %type <node>	opt_argument_list
163 %type <node>	opt_expression
164 %type <node>	opt_relational_expression
165 %type <node>	opt_statement
166 %type <node>	print_expression
167 %type <node>	print_expression_list
168 %type <node>	relational_expression
169 %type <node>	return_expression
170 %type <node>	semicolon_list
171 %type <node>	statement
172 %type <node>	statement_list
173 
174 %%
175 
176 program		: /* empty */
177 		| program input_item
178 		;
179 
180 input_item	: semicolon_list NEWLINE
181 			{
182 				emit($1);
183 				macro_char = reset_macro_char;
184 				putchar('\n');
185 				free_tree();
186 				st_has_continue = false;
187 			}
188 		| function
189 			{
190 				putchar('\n');
191 				free_tree();
192 				st_has_continue = false;
193 			}
194 		| error NEWLINE
195 			{
196 				yyerrok;
197 			}
198 		| error QUIT
199 			{
200 				yyerrok;
201 			}
202 		;
203 
204 semicolon_list	: /* empty */
205 			{
206 				$$ = cs("");
207 			}
208 		| statement
209 		| semicolon_list SEMICOLON statement
210 			{
211 				$$ = node($1, $3, END_NODE);
212 			}
213 		| semicolon_list SEMICOLON
214 		;
215 
216 statement_list	: /* empty */
217 			{
218 				$$ = cs("");
219 			}
220 		| statement
221 		| statement_list NEWLINE
222 		| statement_list NEWLINE statement
223 			{
224 				$$ = node($1, $3, END_NODE);
225 			}
226 		| statement_list SEMICOLON
227 		| statement_list SEMICOLON statement
228 			{
229 				$$ = node($1, $3, END_NODE);
230 			}
231 		;
232 
233 
234 opt_statement	: /* empty */
235 			{
236 				$$ = cs("");
237 			}
238 		| statement
239 		;
240 
241 statement	: expression
242 			{
243 				$$ = node($1, cs("ps."), END_NODE);
244 			}
245 		| named_expression ASSIGN_OP expression
246 			{
247 				if ($2[0] == '\0')
248 					$$ = node($3, cs($2), $1.store,
249 					    END_NODE);
250 				else
251 					$$ = node($1.load, $3, cs($2), $1.store,
252 					    END_NODE);
253 			}
254 		| STRING
255 			{
256 				$$ = node(cs("["), as($1),
257 				    cs("]P"), END_NODE);
258 			}
259 		| BREAK
260 			{
261 				if (breaksp == 0) {
262 					warning("break not in for or while");
263 					YYERROR;
264 				} else {
265 					$$ = node(
266 					    numnode(nesting -
267 						breakstack[breaksp-1]),
268 					    cs("Q"), END_NODE);
269 				}
270 			}
271 		| CONTINUE
272 			{
273 				if (breaksp == 0) {
274 					warning("continue not in for or while");
275 					YYERROR;
276 				} else {
277 					st_has_continue = true;
278 					$$ = node(numnode(nesting -
279 					    breakstack[breaksp-1] - 1),
280 					    cs("J"), END_NODE);
281 				}
282 			}
283 		| QUIT
284 			{
285 				sigset_t mask;
286 
287 				putchar('q');
288 				fflush(stdout);
289 				if (dc) {
290 					sigprocmask(SIG_BLOCK, NULL, &mask);
291 					sigsuspend(&mask);
292 				} else
293 					exit(0);
294 			}
295 		| RETURN return_expression
296 			{
297 				if (nesting == 0) {
298 					warning("return must be in a function");
299 					YYERROR;
300 				}
301 				$$ = $2;
302 			}
303 		| FOR LPAR alloc_macro opt_expression SEMICOLON
304 		     opt_relational_expression SEMICOLON
305 		     opt_expression RPAR opt_statement pop_nesting
306 			{
307 				ssize_t n;
308 
309 				if (st_has_continue)
310 					n = node($10, cs("M"), $8, cs("s."),
311 					    $6, $3, END_NODE);
312 				else
313 					n = node($10, $8, cs("s."), $6, $3,
314 					    END_NODE);
315 
316 				emit_macro($3, n);
317 				$$ = node($4, cs("s."), $6, $3, cs(" "),
318 				    END_NODE);
319 			}
320 		| IF LPAR alloc_macro pop_nesting relational_expression RPAR
321 		      opt_statement
322 			{
323 				emit_macro($3, $7);
324 				$$ = node($5, $3, cs(" "), END_NODE);
325 			}
326 		| IF LPAR alloc_macro pop_nesting relational_expression RPAR
327 		      opt_statement ELSE alloc_macro pop_nesting opt_statement
328 			{
329 				emit_macro($3, $7);
330 				emit_macro($9, $11);
331 				$$ = node($5, $3, cs("e"), $9, cs(" "),
332 				    END_NODE);
333 			}
334 		| WHILE LPAR alloc_macro relational_expression RPAR
335 		      opt_statement pop_nesting
336 			{
337 				ssize_t n;
338 
339 				if (st_has_continue)
340 					n = node($6, cs("M"), $4, $3, END_NODE);
341 				else
342 					n = node($6, $4, $3, END_NODE);
343 				emit_macro($3, n);
344 				$$ = node($4, $3, cs(" "), END_NODE);
345 			}
346 		| LBRACE statement_list RBRACE
347 			{
348 				$$ = $2;
349 			}
350 		| PRINT print_expression_list
351 			{
352 				$$ = $2;
353 			}
354 		;
355 
356 alloc_macro	: /* empty */
357 			{
358 				$$ = cs(str_table[macro_char]);
359 				macro_char++;
360 				/* Do not use [, \ and ] */
361 				if (macro_char == '[')
362 					macro_char += 3;
363 				/* skip letters */
364 				else if (macro_char == 'a')
365 					macro_char = '{';
366 				else if (macro_char == ARRAY_CHAR)
367 					macro_char += 26;
368 				else if (macro_char == 255)
369 					fatal("program too big");
370 				if (breaksp == BREAKSTACK_SZ)
371 					fatal("nesting too deep");
372 				breakstack[breaksp++] = nesting++;
373 			}
374 		;
375 
376 pop_nesting	: /* empty */
377 			{
378 				breaksp--;
379 			}
380 		;
381 
382 function	: function_header opt_parameter_list RPAR opt_newline
383 		  LBRACE NEWLINE opt_auto_define_list
384 		  statement_list RBRACE
385 			{
386 				int n = node(prologue, $8, epilogue,
387 				    cs("0"), numnode(nesting),
388 				    cs("Q"), END_NODE);
389 				emit_macro($1, n);
390 				reset_macro_char = macro_char;
391 				nesting = 0;
392 				breaksp = 0;
393 			}
394 		;
395 
396 function_header : DEFINE LETTER LPAR
397 			{
398 				$$ = function_node($2);
399 				free($2);
400 				prologue = cs("");
401 				epilogue = cs("");
402 				nesting = 1;
403 				breaksp = 0;
404 				breakstack[breaksp] = 0;
405 			}
406 		;
407 
408 opt_newline	: /* empty */
409 		| NEWLINE
410 		;
411 
412 opt_parameter_list
413 		: /* empty */
414 		| parameter_list
415 		;
416 
417 
418 parameter_list	: LETTER
419 			{
420 				add_par(letter_node($1));
421 				free($1);
422 			}
423 		| LETTER LBRACKET RBRACKET
424 			{
425 				add_par(array_node($1));
426 				free($1);
427 			}
428 		| parameter_list COMMA LETTER
429 			{
430 				add_par(letter_node($3));
431 				free($3);
432 			}
433 		| parameter_list COMMA LETTER LBRACKET RBRACKET
434 			{
435 				add_par(array_node($3));
436 				free($3);
437 			}
438 		;
439 
440 
441 
442 opt_auto_define_list
443 		: /* empty */
444 		| AUTO define_list NEWLINE
445 		| AUTO define_list SEMICOLON
446 		;
447 
448 
449 define_list	: LETTER
450 			{
451 				add_local(letter_node($1));
452 				free($1);
453 			}
454 		| LETTER LBRACKET RBRACKET
455 			{
456 				add_local(array_node($1));
457 				free($1);
458 			}
459 		| define_list COMMA LETTER
460 			{
461 				add_local(letter_node($3));
462 				free($3);
463 			}
464 		| define_list COMMA LETTER LBRACKET RBRACKET
465 			{
466 				add_local(array_node($3));
467 				free($3);
468 			}
469 		;
470 
471 
472 opt_argument_list
473 		: /* empty */
474 			{
475 				$$ = cs("");
476 			}
477 		| argument_list
478 		;
479 
480 
481 argument_list	: expression
482 		| argument_list COMMA expression
483 			{
484 				$$ = node($1, $3, END_NODE);
485 			}
486 		| argument_list COMMA LETTER LBRACKET RBRACKET
487 			{
488 				$$ = node($1, cs("l"), array_node($3),
489 				    END_NODE);
490 				free($3);
491 			}
492 		;
493 
494 opt_relational_expression
495 		: /* empty */
496 			{
497 				$$ = cs(" 0 0=");
498 			}
499 		| relational_expression
500 		;
501 
502 relational_expression
503 		: expression EQUALS expression
504 			{
505 				$$ = node($1, $3, cs("="), END_NODE);
506 			}
507 		| expression UNEQUALS expression
508 			{
509 				$$ = node($1, $3, cs("!="), END_NODE);
510 			}
511 		| expression LESS expression
512 			{
513 				$$ = node($1, $3, cs(">"), END_NODE);
514 			}
515 		| expression LESS_EQ expression
516 			{
517 				$$ = node($1, $3, cs("!<"), END_NODE);
518 			}
519 		| expression GREATER expression
520 			{
521 				$$ = node($1, $3, cs("<"), END_NODE);
522 			}
523 		| expression GREATER_EQ expression
524 			{
525 				$$ = node($1, $3, cs("!>"), END_NODE);
526 			}
527 		| expression
528 			{
529 				$$ = node($1, cs(" 0!="), END_NODE);
530 			}
531 		;
532 
533 
534 return_expression
535 		: /* empty */
536 			{
537 				$$ = node(cs("0"), epilogue,
538 				    numnode(nesting), cs("Q"), END_NODE);
539 			}
540 		| expression
541 			{
542 				$$ = node($1, epilogue,
543 				    numnode(nesting), cs("Q"), END_NODE);
544 			}
545 		| LPAR RPAR
546 			{
547 				$$ = node(cs("0"), epilogue,
548 				    numnode(nesting), cs("Q"), END_NODE);
549 			}
550 		;
551 
552 
553 opt_expression : /* empty */
554 			{
555 				$$ = cs(" 0");
556 			}
557 		| expression
558 		;
559 
560 expression	: named_expression
561 			{
562 				$$ = node($1.load, END_NODE);
563 			}
564 		| DOT	{
565 				$$ = node(cs("l."), END_NODE);
566 			}
567 		| NUMBER
568 			{
569 				$$ = node(cs(" "), as($1), END_NODE);
570 			}
571 		| LPAR expression RPAR
572 			{
573 				$$ = $2;
574 			}
575 		| LETTER LPAR opt_argument_list RPAR
576 			{
577 				$$ = node($3, cs("l"),
578 				    function_node($1), cs("x"),
579 				    END_NODE);
580 				free($1);
581 			}
582 		| MINUS expression %prec UMINUS
583 			{
584 				$$ = node(cs(" 0"), $2, cs("-"),
585 				    END_NODE);
586 			}
587 		| expression PLUS expression
588 			{
589 				$$ = node($1, $3, cs("+"), END_NODE);
590 			}
591 		| expression MINUS expression
592 			{
593 				$$ = node($1, $3, cs("-"), END_NODE);
594 			}
595 		| expression MULTIPLY expression
596 			{
597 				$$ = node($1, $3, cs("*"), END_NODE);
598 			}
599 		| expression DIVIDE expression
600 			{
601 				$$ = node($1, $3, cs("/"), END_NODE);
602 			}
603 		| expression REMAINDER expression
604 			{
605 				$$ = node($1, $3, cs("%"), END_NODE);
606 			}
607 		| expression EXPONENT expression
608 			{
609 				$$ = node($1, $3, cs("^"), END_NODE);
610 			}
611 		| INCR named_expression
612 			{
613 				$$ = node($2.load, cs("1+d"), $2.store,
614 				    END_NODE);
615 			}
616 		| DECR named_expression
617 			{
618 				$$ = node($2.load, cs("1-d"),
619 				    $2.store, END_NODE);
620 			}
621 		| named_expression INCR
622 			{
623 				$$ = node($1.load, cs("d1+"),
624 				    $1.store, END_NODE);
625 			}
626 		| named_expression DECR
627 			{
628 				$$ = node($1.load, cs("d1-"),
629 				    $1.store, END_NODE);
630 			}
631 		| named_expression ASSIGN_OP expression
632 			{
633 				if ($2[0] == '\0')
634 					$$ = node($3, cs($2), cs("d"), $1.store,
635 					    END_NODE);
636 				else
637 					$$ = node($1.load, $3, cs($2), cs("d"),
638 					    $1.store, END_NODE);
639 			}
640 		| LENGTH LPAR expression RPAR
641 			{
642 				$$ = node($3, cs("Z"), END_NODE);
643 			}
644 		| SQRT LPAR expression RPAR
645 			{
646 				$$ = node($3, cs("v"), END_NODE);
647 			}
648 		| SCALE LPAR expression RPAR
649 			{
650 				$$ = node($3, cs("X"), END_NODE);
651 			}
652 		| BOOL_NOT expression
653 			{
654 				$$ = node($2, cs("N"), END_NODE);
655 			}
656 		| expression BOOL_AND alloc_macro pop_nesting expression
657 			{
658 				ssize_t n = node(cs("R"), $5, END_NODE);
659 				emit_macro($3, n);
660 				$$ = node($1, cs("d0!="), $3, END_NODE);
661 			}
662 		| expression BOOL_OR alloc_macro pop_nesting expression
663 			{
664 				ssize_t n = node(cs("R"), $5, END_NODE);
665 				emit_macro($3, n);
666 				$$ = node($1, cs("d0="), $3, END_NODE);
667 			}
668 		| expression EQUALS expression
669 			{
670 				$$ = node($1, $3, cs("G"), END_NODE);
671 			}
672 		| expression UNEQUALS expression
673 			{
674 				$$ = node($1, $3, cs("GN"), END_NODE);
675 			}
676 		| expression LESS expression
677 			{
678 				$$ = node($3, $1, cs("("), END_NODE);
679 			}
680 		| expression LESS_EQ expression
681 			{
682 				$$ = node($3, $1, cs("{"), END_NODE);
683 			}
684 		| expression GREATER expression
685 			{
686 				$$ = node($1, $3, cs("("), END_NODE);
687 			}
688 		| expression GREATER_EQ expression
689 			{
690 				$$ = node($1, $3, cs("{"), END_NODE);
691 			}
692 		;
693 
694 named_expression
695 		: LETTER
696 			{
697 				$$.load = node(cs("l"), letter_node($1),
698 				    END_NODE);
699 				$$.store = node(cs("s"), letter_node($1),
700 				    END_NODE);
701 				free($1);
702 			}
703 		| LETTER LBRACKET expression RBRACKET
704 			{
705 				$$.load = node($3, cs(";"),
706 				    array_node($1), END_NODE);
707 				$$.store = node($3, cs(":"),
708 				    array_node($1), END_NODE);
709 				free($1);
710 			}
711 		| SCALE
712 			{
713 				$$.load = cs("K");
714 				$$.store = cs("k");
715 			}
716 		| IBASE
717 			{
718 				$$.load = cs("I");
719 				$$.store = cs("i");
720 			}
721 		| OBASE
722 			{
723 				$$.load = cs("O");
724 				$$.store = cs("o");
725 			}
726 		;
727 
728 print_expression_list
729 		: print_expression
730 		| print_expression_list COMMA print_expression
731 			{
732 				$$ = node($1, $3, END_NODE);
733 			}
734 
735 print_expression
736 		: expression
737 			{
738 				$$ = node($1, cs("ds.n"), END_NODE);
739 			}
740 		| STRING
741 			{
742 				char *p = escape($1);
743 				$$ = node(cs("["), as(p), cs("]n"), END_NODE);
744 				free(p);
745 			}
746 %%
747 
748 
749 static void
750 grow(void)
751 {
752 	struct tree	*p;
753 	size_t		newsize;
754 
755 	if (current == instr_sz) {
756 		newsize = instr_sz * 2 + 1;
757 		p = realloc(instructions, newsize * sizeof(*p));
758 		if (p == NULL) {
759 			free(instructions);
760 			err(1, NULL);
761 		}
762 		instructions = p;
763 		instr_sz = newsize;
764 	}
765 }
766 
767 static ssize_t
768 cs(const char *str)
769 {
770 	grow();
771 	instructions[current].index = CONST_STRING;
772 	instructions[current].u.cstr = str;
773 	return current++;
774 }
775 
776 static ssize_t
777 as(const char *str)
778 {
779 	grow();
780 	instructions[current].index = ALLOC_STRING;
781 	instructions[current].u.astr = strdup(str);
782 	if (instructions[current].u.astr == NULL)
783 		err(1, NULL);
784 	return current++;
785 }
786 
787 static ssize_t
788 node(ssize_t arg, ...)
789 {
790 	va_list		ap;
791 	ssize_t		ret;
792 
793 	va_start(ap, arg);
794 
795 	ret = current;
796 	grow();
797 	instructions[current++].index = arg;
798 
799 	do {
800 		arg = va_arg(ap, ssize_t);
801 		grow();
802 		instructions[current++].index = arg;
803 	} while (arg != END_NODE);
804 
805 	va_end(ap);
806 	return ret;
807 }
808 
809 static void
810 emit(ssize_t i)
811 {
812 	if (instructions[i].index >= 0)
813 		while (instructions[i].index != END_NODE)
814 			emit(instructions[i++].index);
815 	else
816 		fputs(instructions[i].u.cstr, stdout);
817 }
818 
819 static void
820 emit_macro(int node, ssize_t code)
821 {
822 	putchar('[');
823 	emit(code);
824 	printf("]s%s\n", instructions[node].u.cstr);
825 	nesting--;
826 }
827 
828 static void
829 free_tree(void)
830 {
831 	ssize_t i;
832 
833 	for (i = 0; i < current; i++)
834 		if (instructions[i].index == ALLOC_STRING)
835 			free(instructions[i].u.astr);
836 	current = 0;
837 }
838 
839 static ssize_t
840 numnode(int num)
841 {
842 	const char *p;
843 
844 	if (num < 10)
845 		p = str_table['0' + num];
846 	else if (num < 16)
847 		p = str_table['A' - 10 + num];
848 	else
849 		errx(1, "internal error: break num > 15");
850 	return node(cs(" "), cs(p), END_NODE);
851 }
852 
853 
854 static ssize_t
855 lookup(char * str, size_t len, char type)
856 {
857 	ENTRY	entry, *found;
858 	u_short	num;
859 	u_char	*p;
860 
861 	/* The scanner allocated an extra byte already */
862 	if (str[len-1] != type) {
863 		str[len] = type;
864 		str[len+1] = '\0';
865 	}
866 	entry.key = str;
867 	found = hsearch(entry, FIND);
868 	if (found == NULL) {
869 		if (var_count == MAX_VARIABLES)
870 			errx(1, "too many variables");
871 		p = malloc(4);
872 		if (p == NULL)
873 			err(1, NULL);
874 		num = var_count++;
875 		p[0] = 255;
876 		p[1] = ENCODE(num / VAR_BASE + 1);
877 		p[2] = ENCODE(num % VAR_BASE + 1);
878 		p[3] = '\0';
879 
880 		entry.data = (char *)p;
881 		entry.key = strdup(str);
882 		if (entry.key == NULL)
883 			err(1, NULL);
884 		found = hsearch(entry, ENTER);
885 		if (found == NULL)
886 			err(1, NULL);
887 	}
888 	return cs(found->data);
889 }
890 
891 static ssize_t
892 letter_node(char *str)
893 {
894 	size_t len;
895 
896 	len = strlen(str);
897 	if (len == 1 && str[0] != '_')
898 		return cs(str_table[(int)str[0]]);
899 	else
900 		return lookup(str, len, 'L');
901 }
902 
903 static ssize_t
904 array_node(char *str)
905 {
906 	size_t len;
907 
908 	len = strlen(str);
909 	if (len == 1 && str[0] != '_')
910 		return cs(str_table[(int)str[0] - 'a' + ARRAY_CHAR]);
911 	else
912 		return lookup(str, len, 'A');
913 }
914 
915 static ssize_t
916 function_node(char *str)
917 {
918 	size_t len;
919 
920 	len = strlen(str);
921 	if (len == 1 && str[0] != '_')
922 		return cs(str_table[(int)str[0] - 'a' + FUNC_CHAR]);
923 	else
924 		return lookup(str, len, 'F');
925 }
926 
927 static void
928 add_par(ssize_t n)
929 {
930 	prologue = node(cs("S"), n, prologue, END_NODE);
931 	epilogue = node(epilogue, cs("L"), n, cs("s."), END_NODE);
932 }
933 
934 static void
935 add_local(ssize_t n)
936 {
937 	prologue = node(cs("0S"), n, prologue, END_NODE);
938 	epilogue = node(epilogue, cs("L"), n, cs("s."), END_NODE);
939 }
940 
941 void
942 yyerror(char *s)
943 {
944 	char	*str, *p;
945 	int	n;
946 
947 	if (yyin != NULL && feof(yyin))
948 		n = asprintf(&str, "%s: %s:%d: %s: unexpected EOF",
949 		    __progname, filename, lineno, s);
950 	else if (isspace(yytext[0]) || !isprint(yytext[0]))
951 		n = asprintf(&str,
952 		    "%s: %s:%d: %s: ascii char 0x%02x unexpected",
953 		    __progname, filename, lineno, s, yytext[0]);
954 	else
955 		n = asprintf(&str, "%s: %s:%d: %s: %s unexpected",
956 		    __progname, filename, lineno, s, yytext);
957 	if (n == -1)
958 		err(1, NULL);
959 
960 	fputs("c[", stdout);
961 	for (p = str; *p != '\0'; p++) {
962 		if (*p == '[' || *p == ']' || *p =='\\')
963 			putchar('\\');
964 		putchar(*p);
965 	}
966 	fputs("]pc\n", stdout);
967 	free(str);
968 }
969 
970 void
971 fatal(const char *s)
972 {
973 	errx(1, "%s:%d: %s", filename, lineno, s);
974 }
975 
976 static void
977 warning(const char *s)
978 {
979 	warnx("%s:%d: %s", filename, lineno, s);
980 }
981 
982 static void
983 init(void)
984 {
985 	int i;
986 
987 	for (i = 0; i < UCHAR_MAX; i++) {
988 		str_table[i][0] = i;
989 		str_table[i][1] = '\0';
990 	}
991 	if (hcreate(1 << 16) == 0)
992 		err(1, NULL);
993 }
994 
995 
996 static __dead2 void
997 usage(void)
998 {
999 	fprintf(stderr, "usage: %s [-cl] [-e expression] [file ...]\n",
1000 	    __progname);
1001 	exit(1);
1002 }
1003 
1004 static char *
1005 escape(const char *str)
1006 {
1007 	char *ret, *p;
1008 
1009 	ret = malloc(strlen(str) + 1);
1010 	if (ret == NULL)
1011 		err(1, NULL);
1012 
1013 	p = ret;
1014 	while (*str != '\0') {
1015 		/*
1016 		 * We get _escaped_ strings here. Single backslashes are
1017 		 * already converted to double backslashes
1018 		 */
1019 		if (*str == '\\') {
1020 			if (*++str == '\\') {
1021 				switch (*++str) {
1022 				case 'a':
1023 					*p++ = '\a';
1024 					break;
1025 				case 'b':
1026 					*p++ = '\b';
1027 					break;
1028 				case 'f':
1029 					*p++ = '\f';
1030 					break;
1031 				case 'n':
1032 					*p++ = '\n';
1033 					break;
1034 				case 'q':
1035 					*p++ = '"';
1036 					break;
1037 				case 'r':
1038 					*p++ = '\r';
1039 					break;
1040 				case 't':
1041 					*p++ = '\t';
1042 					break;
1043 				case '\\':
1044 					*p++ = '\\';
1045 					break;
1046 				}
1047 				str++;
1048 			} else {
1049 				*p++ = '\\';
1050 				*p++ = *str++;
1051 			}
1052 		} else
1053 			*p++ = *str++;
1054 	}
1055 	*p = '\0';
1056 	return ret;
1057 }
1058 
1059 /* ARGSUSED */
1060 static void
1061 sigchld(int signo)
1062 {
1063 	pid_t pid;
1064 	int status;
1065 
1066 	for (;;) {
1067 		pid = waitpid(dc, &status, WCONTINUED);
1068 		if (pid == -1) {
1069 			if (errno == EINTR)
1070 				continue;
1071 			_exit(0);
1072 		}
1073 		if (WIFEXITED(status) || WIFSIGNALED(status))
1074 			_exit(0);
1075 		else
1076 			break;
1077 	}
1078 }
1079 
1080 static const char *
1081 dummy_prompt(void)
1082 {
1083 	return ("");
1084 }
1085 
1086 int
1087 main(int argc, char *argv[])
1088 {
1089 	int	i, ch;
1090 	int	p[2];
1091 	char	*q;
1092 
1093 	init();
1094 	setlinebuf(stdout);
1095 
1096 	sargv = malloc(argc * sizeof(char *));
1097 	if (sargv == NULL)
1098 		err(1, NULL);
1099 
1100 	if ((cmdexpr = strdup("")) == NULL)
1101 		err(1, NULL);
1102 	/* The d debug option is 4.4 BSD bc(1) compatible */
1103 	while ((ch = getopt(argc, argv, "cde:l")) != -1) {
1104 		switch (ch) {
1105 		case 'c':
1106 		case 'd':
1107 			do_fork = false;
1108 			break;
1109 		case 'e':
1110 			q = cmdexpr;
1111 			if (asprintf(&cmdexpr, "%s%s\n", cmdexpr, optarg) == -1)
1112 				err(1, NULL);
1113 			free(q);
1114 			break;
1115 		case 'l':
1116 			sargv[sargc++] = _PATH_LIBB;
1117 			break;
1118 		default:
1119 			usage();
1120 		}
1121 	}
1122 
1123 	argc -= optind;
1124 	argv += optind;
1125 
1126 	interactive = isatty(STDIN_FILENO);
1127 	for (i = 0; i < argc; i++)
1128 		sargv[sargc++] = argv[i];
1129 
1130 	if (do_fork) {
1131 		if (pipe(p) == -1)
1132 			err(1, "cannot create pipe");
1133 		dc = fork();
1134 		if (dc == -1)
1135 			err(1, "cannot fork");
1136 		else if (dc != 0) {
1137 			signal(SIGCHLD, sigchld);
1138 			close(STDOUT_FILENO);
1139 			dup(p[1]);
1140 			close(p[0]);
1141 			close(p[1]);
1142 		} else {
1143 			close(STDIN_FILENO);
1144 			dup(p[0]);
1145 			close(p[0]);
1146 			close(p[1]);
1147 			execl(_PATH_DC, "dc", "-x", NULL);
1148 			err(1, "cannot find dc");
1149 		}
1150 	}
1151 	if (interactive) {
1152 		el = el_init("bc", stdin, stderr, stderr);
1153 		hist = history_init();
1154 		history(hist, &he, H_SETSIZE, 100);
1155 		el_set(el, EL_HIST, history, hist);
1156 		el_set(el, EL_EDITOR, "emacs");
1157 		el_set(el, EL_SIGNAL, 1);
1158 		el_set(el, EL_PROMPT, dummy_prompt);
1159 		el_source(el, NULL);
1160 	}
1161 	yywrap();
1162 	return yyparse();
1163 }
1164