1 /* $Id: main.c,v 1.73 2021/08/08 20:39:34 tom Exp $ */ 2 3 #include <signal.h> 4 #if !defined(_WIN32) || defined(__MINGW32__) 5 #include <unistd.h> /* for _exit() */ 6 #else 7 #include <stdlib.h> /* for _exit() */ 8 #endif 9 10 #include "defs.h" 11 12 #ifdef HAVE_MKSTEMP 13 # define USE_MKSTEMP 1 14 #elif defined(HAVE_FCNTL_H) 15 # define USE_MKSTEMP 1 16 # include <fcntl.h> /* for open(), O_EXCL, etc. */ 17 #else 18 # define USE_MKSTEMP 0 19 #endif 20 21 #if USE_MKSTEMP 22 #include <sys/types.h> 23 #include <sys/stat.h> 24 25 typedef struct _my_tmpfiles 26 { 27 struct _my_tmpfiles *next; 28 char *name; 29 } 30 MY_TMPFILES; 31 32 static MY_TMPFILES *my_tmpfiles; 33 #endif /* USE_MKSTEMP */ 34 35 char dflag; 36 char dflag2; 37 char gflag; 38 char iflag; 39 char lflag; 40 static char oflag; 41 char rflag; 42 char sflag; 43 char tflag; 44 char vflag; 45 46 const char *symbol_prefix; 47 const char *myname = "yacc"; 48 49 int lineno; 50 int outline; 51 52 static char default_file_prefix[] = "y"; 53 54 static char *file_prefix = default_file_prefix; 55 56 char *code_file_name; 57 char *input_file_name; 58 size_t input_file_name_len = 0; 59 char *defines_file_name; 60 char *externs_file_name; 61 62 static char *graph_file_name; 63 static char *output_file_name; 64 static char *verbose_file_name; 65 66 FILE *action_file; /* a temp file, used to save actions associated */ 67 /* with rules until the parser is written */ 68 FILE *code_file; /* y.code.c (used when the -r option is specified) */ 69 FILE *defines_file; /* y.tab.h */ 70 FILE *externs_file; /* y.tab.i */ 71 FILE *input_file; /* the input file */ 72 FILE *output_file; /* y.tab.c */ 73 FILE *text_file; /* a temp file, used to save text until all */ 74 /* symbols have been defined */ 75 FILE *union_file; /* a temp file, used to save the union */ 76 /* definition until all symbol have been */ 77 /* defined */ 78 FILE *verbose_file; /* y.output */ 79 FILE *graph_file; /* y.dot */ 80 81 Value_t nitems; 82 Value_t nrules; 83 Value_t nsyms; 84 Value_t ntokens; 85 Value_t nvars; 86 87 Value_t start_symbol; 88 char **symbol_name; 89 char **symbol_pname; 90 Value_t *symbol_value; 91 Value_t *symbol_prec; 92 char *symbol_assoc; 93 94 int pure_parser; 95 int token_table; 96 int error_verbose; 97 98 #if defined(YYBTYACC) 99 Value_t *symbol_pval; 100 char **symbol_destructor; 101 char **symbol_type_tag; 102 int locations = 0; /* default to no position processing */ 103 int backtrack = 0; /* default is no backtracking */ 104 char *initial_action = NULL; 105 #endif 106 107 int exit_code; 108 109 Value_t *ritem; 110 Value_t *rlhs; 111 Value_t *rrhs; 112 Value_t *rprec; 113 Assoc_t *rassoc; 114 Value_t **derives; 115 char *nullable; 116 117 /* 118 * Since fclose() is called via the signal handler, it might die. Don't loop 119 * if there is a problem closing a file. 120 */ 121 #define DO_CLOSE(fp) \ 122 if (fp != 0) { \ 123 FILE *use = fp; \ 124 fp = 0; \ 125 fclose(use); \ 126 } 127 128 static int got_intr = 0; 129 130 void 131 done(int k) 132 { 133 DO_CLOSE(input_file); 134 DO_CLOSE(output_file); 135 if (iflag) 136 DO_CLOSE(externs_file); 137 if (rflag) 138 DO_CLOSE(code_file); 139 140 DO_CLOSE(action_file); 141 DO_CLOSE(defines_file); 142 DO_CLOSE(graph_file); 143 DO_CLOSE(text_file); 144 DO_CLOSE(union_file); 145 DO_CLOSE(verbose_file); 146 147 if (got_intr) 148 _exit(EXIT_FAILURE); 149 150 #ifdef NO_LEAKS 151 DO_FREE(input_file_name); 152 153 if (rflag) 154 DO_FREE(code_file_name); 155 156 if (dflag && !dflag2) 157 DO_FREE(defines_file_name); 158 159 if (iflag) 160 DO_FREE(externs_file_name); 161 162 if (oflag) 163 DO_FREE(output_file_name); 164 165 if (vflag) 166 DO_FREE(verbose_file_name); 167 168 if (gflag) 169 DO_FREE(graph_file_name); 170 171 lr0_leaks(); 172 lalr_leaks(); 173 mkpar_leaks(); 174 mstring_leaks(); 175 output_leaks(); 176 reader_leaks(); 177 #endif 178 179 exit(k); 180 } 181 182 static void 183 onintr(int sig GCC_UNUSED) 184 { 185 got_intr = 1; 186 done(EXIT_FAILURE); 187 } 188 189 static void 190 set_signals(void) 191 { 192 #ifdef SIGINT 193 if (signal(SIGINT, SIG_IGN) != SIG_IGN) 194 signal(SIGINT, onintr); 195 #endif 196 #ifdef SIGTERM 197 if (signal(SIGTERM, SIG_IGN) != SIG_IGN) 198 signal(SIGTERM, onintr); 199 #endif 200 #ifdef SIGHUP 201 if (signal(SIGHUP, SIG_IGN) != SIG_IGN) 202 signal(SIGHUP, onintr); 203 #endif 204 } 205 206 #define SIZEOF(v) (sizeof(v) / sizeof((v)[0])) 207 208 /* 209 * Long options are provided only as a compatibility aid for scripters. 210 */ 211 /* *INDENT-OFF* */ 212 static const struct { 213 const char long_opt[16]; 214 const char yacc_arg; 215 const char yacc_opt; 216 } long_opts[] = { 217 { "defines", 1, 'H' }, 218 { "file-prefix", 1, 'b' }, 219 { "graph", 0, 'g' }, 220 { "help", 0, 'h' }, 221 { "name-prefix", 1, 'p' }, 222 { "no-lines", 0, 'l' }, 223 { "output", 1, 'o' }, 224 { "version", 0, 'V' } 225 }; 226 /* *INDENT-ON* */ 227 228 /* 229 * Usage-message is designed for 80 columns, with some unknowns. Account for 230 * those in the maximum width so that the usage message uses no relocatable 231 * pointers. 232 */ 233 #define USAGE_COLS (80 + sizeof(DEFINES_SUFFIX) + sizeof(OUTPUT_SUFFIX)) 234 235 static void 236 usage(void) 237 { 238 /* *INDENT-OFF* */ 239 static const char msg[][USAGE_COLS] = 240 { 241 { " -b file_prefix set filename prefix (default \"y.\")" }, 242 { " -B create a backtracking parser" }, 243 { " -d write definitions (" DEFINES_SUFFIX ")" }, 244 { " -h print this help-message" }, 245 { " -H defines_file write definitions to defines_file" }, 246 { " -i write interface (y.tab.i)" }, 247 { " -g write a graphical description" }, 248 { " -l suppress #line directives" }, 249 { " -L enable position processing, e.g., \"%locations\"" }, 250 { " -o output_file (default \"" OUTPUT_SUFFIX "\")" }, 251 { " -p symbol_prefix set symbol prefix (default \"yy\")" }, 252 { " -P create a reentrant parser, e.g., \"%pure-parser\"" }, 253 { " -r produce separate code and table files (y.code.c)" }, 254 { " -s suppress #define's for quoted names in %token lines" }, 255 { " -t add debugging support" }, 256 { " -v write description (y.output)" }, 257 { " -V show version information and exit" }, 258 }; 259 /* *INDENT-ON* */ 260 unsigned n; 261 262 fflush(stdout); 263 fprintf(stderr, "Usage: %s [options] filename\n", myname); 264 265 fprintf(stderr, "\nOptions:\n"); 266 for (n = 0; n < SIZEOF(msg); ++n) 267 { 268 fprintf(stderr, "%s\n", msg[n]); 269 } 270 271 fprintf(stderr, "\nLong options:\n"); 272 for (n = 0; n < SIZEOF(long_opts); ++n) 273 { 274 fprintf(stderr, " --%-20s-%c\n", 275 long_opts[n].long_opt, 276 long_opts[n].yacc_opt); 277 } 278 279 exit(EXIT_FAILURE); 280 } 281 282 static void 283 invalid_option(const char *option) 284 { 285 fprintf(stderr, "invalid option: %s\n", option); 286 usage(); 287 } 288 289 static void 290 setflag(int ch) 291 { 292 switch (ch) 293 { 294 case 'B': 295 #if defined(YYBTYACC) 296 backtrack = 1; 297 #else 298 unsupported_flag_warning("-B", "reconfigure with --enable-btyacc"); 299 #endif 300 break; 301 302 case 'd': 303 dflag = 1; 304 dflag2 = 0; 305 break; 306 307 case 'g': 308 gflag = 1; 309 break; 310 311 case 'i': 312 iflag = 1; 313 break; 314 315 case 'l': 316 lflag = 1; 317 break; 318 319 case 'L': 320 #if defined(YYBTYACC) 321 locations = 1; 322 #else 323 unsupported_flag_warning("-L", "reconfigure with --enable-btyacc"); 324 #endif 325 break; 326 327 case 'P': 328 pure_parser = 1; 329 break; 330 331 case 'r': 332 rflag = 1; 333 break; 334 335 case 's': 336 sflag = 1; 337 break; 338 339 case 't': 340 tflag = 1; 341 break; 342 343 case 'v': 344 vflag = 1; 345 break; 346 347 case 'V': 348 printf("%s - %s\n", myname, VERSION); 349 exit(EXIT_SUCCESS); 350 351 case 'y': 352 /* noop for bison compatibility. byacc is already designed to be posix 353 * yacc compatible. */ 354 break; 355 356 default: 357 usage(); 358 } 359 } 360 361 static void 362 getargs(int argc, char *argv[]) 363 { 364 int i; 365 #ifdef HAVE_GETOPT 366 int ch; 367 #endif 368 369 /* 370 * Map bison's long-options into yacc short options. 371 */ 372 for (i = 1; i < argc; ++i) 373 { 374 char *a = argv[i]; 375 376 if (!strncmp(a, "--", 2)) 377 { 378 char *eqls; 379 size_t lc; 380 size_t len; 381 382 if ((len = strlen(a)) == 2) 383 break; 384 385 if ((eqls = strchr(a, '=')) != NULL) 386 { 387 len = (size_t)(eqls - a); 388 if (len == 0 || eqls[1] == '\0') 389 invalid_option(a); 390 } 391 392 for (lc = 0; lc < SIZEOF(long_opts); ++lc) 393 { 394 if (!strncmp(long_opts[lc].long_opt, a + 2, len - 2)) 395 { 396 if (eqls != NULL && !long_opts[lc].yacc_arg) 397 invalid_option(a); 398 *a++ = '-'; 399 *a++ = long_opts[lc].yacc_opt; 400 *a = '\0'; 401 if (eqls) 402 { 403 while ((*a++ = *++eqls) != '\0') /* empty */ ; 404 } 405 break; 406 } 407 } 408 if (!strncmp(a, "--", 2)) 409 invalid_option(a); 410 } 411 } 412 413 #ifdef HAVE_GETOPT 414 if (argc > 0) 415 myname = argv[0]; 416 417 while ((ch = getopt(argc, argv, "Bb:dghH:ilLo:Pp:rstVvy")) != -1) 418 { 419 switch (ch) 420 { 421 case 'b': 422 file_prefix = optarg; 423 break; 424 case 'h': 425 usage(); 426 break; 427 case 'H': 428 dflag = dflag2 = 1; 429 defines_file_name = optarg; 430 break; 431 case 'o': 432 output_file_name = optarg; 433 break; 434 case 'p': 435 symbol_prefix = optarg; 436 break; 437 default: 438 setflag(ch); 439 break; 440 } 441 } 442 if ((i = optind) < argc) 443 { 444 /* getopt handles "--" specially, while we handle "-" specially */ 445 if (!strcmp(argv[i], "-")) 446 { 447 if ((i + 1) < argc) 448 usage(); 449 input_file = stdin; 450 return; 451 } 452 } 453 #else 454 char *s; 455 int ch; 456 457 if (argc > 0) 458 myname = argv[0]; 459 460 for (i = 1; i < argc; ++i) 461 { 462 s = argv[i]; 463 if (*s != '-') 464 break; 465 switch (ch = *++s) 466 { 467 case '\0': 468 input_file = stdin; 469 if (i + 1 < argc) 470 usage(); 471 return; 472 473 case '-': 474 ++i; 475 goto no_more_options; 476 477 case 'b': 478 if (*++s) 479 file_prefix = s; 480 else if (++i < argc) 481 file_prefix = argv[i]; 482 else 483 usage(); 484 continue; 485 486 case 'H': 487 dflag = dflag2 = 1; 488 if (*++s) 489 defines_file_name = s; 490 else if (++i < argc) 491 defines_file_name = argv[i]; 492 else 493 usage(); 494 continue; 495 496 case 'o': 497 if (*++s) 498 output_file_name = s; 499 else if (++i < argc) 500 output_file_name = argv[i]; 501 else 502 usage(); 503 continue; 504 505 case 'p': 506 if (*++s) 507 symbol_prefix = s; 508 else if (++i < argc) 509 symbol_prefix = argv[i]; 510 else 511 usage(); 512 continue; 513 514 default: 515 setflag(ch); 516 break; 517 } 518 519 for (;;) 520 { 521 switch (ch = *++s) 522 { 523 case '\0': 524 goto end_of_option; 525 526 default: 527 setflag(ch); 528 break; 529 } 530 } 531 end_of_option:; 532 } 533 534 no_more_options: 535 536 #endif /* HAVE_GETOPT */ 537 if (i + 1 != argc) 538 usage(); 539 input_file_name_len = strlen(argv[i]); 540 input_file_name = TMALLOC(char, input_file_name_len + 1); 541 NO_SPACE(input_file_name); 542 strcpy(input_file_name, argv[i]); 543 } 544 545 void * 546 allocate(size_t n) 547 { 548 void *p; 549 550 p = NULL; 551 if (n) 552 { 553 p = CALLOC(1, n); 554 NO_SPACE(p); 555 } 556 return (p); 557 } 558 559 #define CREATE_FILE_NAME(dest, suffix) \ 560 dest = alloc_file_name(len, suffix) 561 562 static char * 563 alloc_file_name(size_t len, const char *suffix) 564 { 565 char *result = TMALLOC(char, len + strlen(suffix) + 1); 566 if (result == 0) 567 no_space(); 568 strcpy(result, file_prefix); 569 strcpy(result + len, suffix); 570 return result; 571 } 572 573 static char * 574 find_suffix(char *name, const char *suffix) 575 { 576 size_t len = strlen(name); 577 size_t slen = strlen(suffix); 578 if (len >= slen) 579 { 580 name += len - slen; 581 if (strcmp(name, suffix) == 0) 582 return name; 583 } 584 return NULL; 585 } 586 587 static void 588 create_file_names(void) 589 { 590 size_t len; 591 const char *defines_suffix; 592 const char *externs_suffix; 593 char *suffix; 594 595 suffix = NULL; 596 defines_suffix = DEFINES_SUFFIX; 597 externs_suffix = EXTERNS_SUFFIX; 598 599 /* compute the file_prefix from the user provided output_file_name */ 600 if (output_file_name != 0) 601 { 602 if (!(suffix = find_suffix(output_file_name, OUTPUT_SUFFIX)) 603 && (suffix = find_suffix(output_file_name, ".c"))) 604 { 605 defines_suffix = ".h"; 606 externs_suffix = ".i"; 607 } 608 } 609 610 if (suffix != NULL) 611 { 612 len = (size_t)(suffix - output_file_name); 613 file_prefix = TMALLOC(char, len + 1); 614 NO_SPACE(file_prefix); 615 strncpy(file_prefix, output_file_name, len)[len] = 0; 616 } 617 else 618 len = strlen(file_prefix); 619 620 /* if "-o filename" was not given */ 621 if (output_file_name == 0) 622 { 623 oflag = 1; 624 CREATE_FILE_NAME(output_file_name, OUTPUT_SUFFIX); 625 } 626 627 if (rflag) 628 { 629 CREATE_FILE_NAME(code_file_name, CODE_SUFFIX); 630 } 631 else 632 code_file_name = output_file_name; 633 634 if (dflag && !dflag2) 635 { 636 CREATE_FILE_NAME(defines_file_name, defines_suffix); 637 } 638 639 if (iflag) 640 { 641 CREATE_FILE_NAME(externs_file_name, externs_suffix); 642 } 643 644 if (vflag) 645 { 646 CREATE_FILE_NAME(verbose_file_name, VERBOSE_SUFFIX); 647 } 648 649 if (gflag) 650 { 651 CREATE_FILE_NAME(graph_file_name, GRAPH_SUFFIX); 652 } 653 654 if (suffix != NULL) 655 { 656 FREE(file_prefix); 657 } 658 } 659 660 #if USE_MKSTEMP 661 static void 662 close_tmpfiles(void) 663 { 664 while (my_tmpfiles != 0) 665 { 666 MY_TMPFILES *next = my_tmpfiles->next; 667 668 (void)chmod(my_tmpfiles->name, 0644); 669 (void)unlink(my_tmpfiles->name); 670 671 free(my_tmpfiles->name); 672 free(my_tmpfiles); 673 674 my_tmpfiles = next; 675 } 676 } 677 678 #ifndef HAVE_MKSTEMP 679 static int 680 my_mkstemp(char *temp) 681 { 682 int fd; 683 char *dname; 684 char *fname; 685 char *name; 686 687 /* 688 * Split-up to use tempnam, rather than tmpnam; the latter (like 689 * mkstemp) is unusable on Windows. 690 */ 691 if ((fname = strrchr(temp, '/')) != 0) 692 { 693 dname = strdup(temp); 694 dname[++fname - temp] = '\0'; 695 } 696 else 697 { 698 dname = 0; 699 fname = temp; 700 } 701 if ((name = tempnam(dname, fname)) != 0) 702 { 703 fd = open(name, O_CREAT | O_EXCL | O_RDWR); 704 strcpy(temp, name); 705 } 706 else 707 { 708 fd = -1; 709 } 710 711 if (dname != 0) 712 free(dname); 713 714 return fd; 715 } 716 #define mkstemp(s) my_mkstemp(s) 717 #endif 718 719 #endif 720 721 /* 722 * tmpfile() should be adequate, except that it may require special privileges 723 * to use, e.g., MinGW and Windows 7 where it tries to use the root directory. 724 */ 725 static FILE * 726 open_tmpfile(const char *label) 727 { 728 #define MY_FMT "%s/%.*sXXXXXX" 729 FILE *result; 730 #if USE_MKSTEMP 731 const char *tmpdir; 732 char *name; 733 734 if (((tmpdir = getenv("TMPDIR")) == 0 || access(tmpdir, W_OK) != 0) || 735 ((tmpdir = getenv("TEMP")) == 0 || access(tmpdir, W_OK) != 0)) 736 { 737 #ifdef P_tmpdir 738 tmpdir = P_tmpdir; 739 #else 740 tmpdir = "/tmp"; 741 #endif 742 if (access(tmpdir, W_OK) != 0) 743 tmpdir = "."; 744 } 745 746 /* The size of the format is guaranteed to be longer than the result from 747 * printing empty strings with it; this calculation accounts for the 748 * string-lengths as well. 749 */ 750 name = malloc(strlen(tmpdir) + sizeof(MY_FMT) + strlen(label)); 751 752 result = 0; 753 if (name != 0) 754 { 755 int fd; 756 const char *mark; 757 758 mode_t save_umask = umask(0177); 759 760 if ((mark = strrchr(label, '_')) == 0) 761 mark = label + strlen(label); 762 763 sprintf(name, MY_FMT, tmpdir, (int)(mark - label), label); 764 fd = mkstemp(name); 765 if (fd >= 0 766 && (result = fdopen(fd, "w+")) != 0) 767 { 768 MY_TMPFILES *item; 769 770 if (my_tmpfiles == 0) 771 { 772 atexit(close_tmpfiles); 773 } 774 775 item = NEW(MY_TMPFILES); 776 NO_SPACE(item); 777 778 item->name = name; 779 NO_SPACE(item->name); 780 781 item->next = my_tmpfiles; 782 my_tmpfiles = item; 783 } 784 else 785 { 786 FREE(name); 787 } 788 (void)umask(save_umask); 789 } 790 #else 791 result = tmpfile(); 792 #endif 793 794 if (result == 0) 795 open_error(label); 796 return result; 797 #undef MY_FMT 798 } 799 800 static void 801 open_files(void) 802 { 803 create_file_names(); 804 805 if (input_file == 0) 806 { 807 input_file = fopen(input_file_name, "r"); 808 if (input_file == 0) 809 open_error(input_file_name); 810 } 811 812 action_file = open_tmpfile("action_file"); 813 text_file = open_tmpfile("text_file"); 814 815 if (vflag) 816 { 817 verbose_file = fopen(verbose_file_name, "w"); 818 if (verbose_file == 0) 819 open_error(verbose_file_name); 820 } 821 822 if (gflag) 823 { 824 graph_file = fopen(graph_file_name, "w"); 825 if (graph_file == 0) 826 open_error(graph_file_name); 827 fprintf(graph_file, "digraph %s {\n", file_prefix); 828 fprintf(graph_file, "\tedge [fontsize=10];\n"); 829 fprintf(graph_file, "\tnode [shape=box,fontsize=10];\n"); 830 fprintf(graph_file, "\torientation=landscape;\n"); 831 fprintf(graph_file, "\trankdir=LR;\n"); 832 fprintf(graph_file, "\t/*\n"); 833 fprintf(graph_file, "\tmargin=0.2;\n"); 834 fprintf(graph_file, "\tpage=\"8.27,11.69\"; // for A4 printing\n"); 835 fprintf(graph_file, "\tratio=auto;\n"); 836 fprintf(graph_file, "\t*/\n"); 837 } 838 839 if (dflag || dflag2) 840 { 841 defines_file = fopen(defines_file_name, "w"); 842 if (defines_file == 0) 843 open_error(defines_file_name); 844 union_file = open_tmpfile("union_file"); 845 } 846 847 if (iflag) 848 { 849 externs_file = fopen(externs_file_name, "w"); 850 if (externs_file == 0) 851 open_error(externs_file_name); 852 } 853 854 output_file = fopen(output_file_name, "w"); 855 if (output_file == 0) 856 open_error(output_file_name); 857 858 if (rflag) 859 { 860 code_file = fopen(code_file_name, "w"); 861 if (code_file == 0) 862 open_error(code_file_name); 863 } 864 else 865 code_file = output_file; 866 } 867 868 int 869 main(int argc, char *argv[]) 870 { 871 SRexpect = -1; 872 RRexpect = -1; 873 exit_code = EXIT_SUCCESS; 874 875 set_signals(); 876 getargs(argc, argv); 877 open_files(); 878 reader(); 879 lr0(); 880 lalr(); 881 make_parser(); 882 graph(); 883 finalize_closure(); 884 verbose(); 885 output(); 886 done(exit_code); 887 /*NOTREACHED */ 888 } 889