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