?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
kernel: Fix buildkernel without INVARIANTS.
[dragonfly.git] / usr.bin / bc / bc.y
blob57b771afa0577d9b1f3e48bf0c3d92eb6d78430f
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 }
DragonFly BSD