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