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