1 /* $Id: main.c,v 1.70 2020/09/10 17:32:55 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 if (rflag) 152 DO_FREE(code_file_name); 153 154 if (dflag && !dflag2) 155 DO_FREE(defines_file_name); 156 157 if (iflag) 158 DO_FREE(externs_file_name); 159 160 if (oflag) 161 DO_FREE(output_file_name); 162 163 if (vflag) 164 DO_FREE(verbose_file_name); 165 166 if (gflag) 167 DO_FREE(graph_file_name); 168 169 lr0_leaks(); 170 lalr_leaks(); 171 mkpar_leaks(); 172 mstring_leaks(); 173 output_leaks(); 174 reader_leaks(); 175 #endif 176 177 exit(k); 178 } 179 180 static void 181 onintr(int sig GCC_UNUSED) 182 { 183 got_intr = 1; 184 done(EXIT_FAILURE); 185 } 186 187 static void 188 set_signals(void) 189 { 190 #ifdef SIGINT 191 if (signal(SIGINT, SIG_IGN) != SIG_IGN) 192 signal(SIGINT, onintr); 193 #endif 194 #ifdef SIGTERM 195 if (signal(SIGTERM, SIG_IGN) != SIG_IGN) 196 signal(SIGTERM, onintr); 197 #endif 198 #ifdef SIGHUP 199 if (signal(SIGHUP, SIG_IGN) != SIG_IGN) 200 signal(SIGHUP, onintr); 201 #endif 202 } 203 204 static void 205 usage(void) 206 { 207 static const char *msg[] = 208 { 209 "" 210 ,"Options:" 211 ," -b file_prefix set filename prefix (default \"y.\")" 212 ," -B create a backtracking parser" 213 ," -d write definitions (" DEFINES_SUFFIX ")" 214 ," -H defines_file write definitions to defines_file" 215 ," -i write interface (y.tab.i)" 216 ," -g write a graphical description" 217 ," -l suppress #line directives" 218 ," -L enable position processing, e.g., \"%locations\"" 219 ," -o output_file (default \"" OUTPUT_SUFFIX "\")" 220 ," -p symbol_prefix set symbol prefix (default \"yy\")" 221 ," -P create a reentrant parser, e.g., \"%pure-parser\"" 222 ," -r produce separate code and table files (y.code.c)" 223 ," -s suppress #define's for quoted names in %token lines" 224 ," -t add debugging support" 225 ," -v write description (y.output)" 226 ," -V show version information and exit" 227 }; 228 unsigned n; 229 230 fflush(stdout); 231 fprintf(stderr, "Usage: %s [options] filename\n", myname); 232 for (n = 0; n < sizeof(msg) / sizeof(msg[0]); ++n) 233 fprintf(stderr, "%s\n", msg[n]); 234 235 exit(EXIT_FAILURE); 236 } 237 238 static void 239 setflag(int ch) 240 { 241 switch (ch) 242 { 243 case 'B': 244 #if defined(YYBTYACC) 245 backtrack = 1; 246 #else 247 unsupported_flag_warning("-B", "reconfigure with --enable-btyacc"); 248 #endif 249 break; 250 251 case 'd': 252 dflag = 1; 253 dflag2 = 0; 254 break; 255 256 case 'g': 257 gflag = 1; 258 break; 259 260 case 'i': 261 iflag = 1; 262 break; 263 264 case 'l': 265 lflag = 1; 266 break; 267 268 case 'L': 269 #if defined(YYBTYACC) 270 locations = 1; 271 #else 272 unsupported_flag_warning("-L", "reconfigure with --enable-btyacc"); 273 #endif 274 break; 275 276 case 'P': 277 pure_parser = 1; 278 break; 279 280 case 'r': 281 rflag = 1; 282 break; 283 284 case 's': 285 sflag = 1; 286 break; 287 288 case 't': 289 tflag = 1; 290 break; 291 292 case 'v': 293 vflag = 1; 294 break; 295 296 case 'V': 297 printf("%s - %s\n", myname, VERSION); 298 exit(EXIT_SUCCESS); 299 300 case 'y': 301 /* noop for bison compatibility. byacc is already designed to be posix 302 * yacc compatible. */ 303 break; 304 305 default: 306 usage(); 307 } 308 } 309 310 static void 311 getargs(int argc, char *argv[]) 312 { 313 int i; 314 #ifdef HAVE_GETOPT 315 int ch; 316 317 if (argc > 0) 318 myname = argv[0]; 319 320 while ((ch = getopt(argc, argv, "Bb:dgH:ilLo:Pp:rstVvy")) != -1) 321 { 322 switch (ch) 323 { 324 case 'b': 325 file_prefix = optarg; 326 break; 327 case 'H': 328 dflag = dflag2 = 1; 329 defines_file_name = optarg; 330 break; 331 case 'o': 332 output_file_name = optarg; 333 break; 334 case 'p': 335 symbol_prefix = optarg; 336 break; 337 default: 338 setflag(ch); 339 break; 340 } 341 } 342 if ((i = optind) < argc) 343 { 344 /* getopt handles "--" specially, while we handle "-" specially */ 345 if (!strcmp(argv[i], "-")) 346 { 347 if ((i + 1) < argc) 348 usage(); 349 input_file = stdin; 350 return; 351 } 352 } 353 #else 354 char *s; 355 int ch; 356 357 if (argc > 0) 358 myname = argv[0]; 359 360 for (i = 1; i < argc; ++i) 361 { 362 s = argv[i]; 363 if (*s != '-') 364 break; 365 switch (ch = *++s) 366 { 367 case '\0': 368 input_file = stdin; 369 if (i + 1 < argc) 370 usage(); 371 return; 372 373 case '-': 374 ++i; 375 goto no_more_options; 376 377 case 'b': 378 if (*++s) 379 file_prefix = s; 380 else if (++i < argc) 381 file_prefix = argv[i]; 382 else 383 usage(); 384 continue; 385 386 case 'H': 387 dflag = dflag2 = 1; 388 if (*++s) 389 defines_file_name = s; 390 else if (++i < argc) 391 defines_file_name = argv[i]; 392 else 393 usage(); 394 continue; 395 396 case 'o': 397 if (*++s) 398 output_file_name = s; 399 else if (++i < argc) 400 output_file_name = argv[i]; 401 else 402 usage(); 403 continue; 404 405 case 'p': 406 if (*++s) 407 symbol_prefix = s; 408 else if (++i < argc) 409 symbol_prefix = argv[i]; 410 else 411 usage(); 412 continue; 413 414 default: 415 setflag(ch); 416 break; 417 } 418 419 for (;;) 420 { 421 switch (ch = *++s) 422 { 423 case '\0': 424 goto end_of_option; 425 426 default: 427 setflag(ch); 428 break; 429 } 430 } 431 end_of_option:; 432 } 433 434 no_more_options: 435 436 #endif /* HAVE_GETOPT */ 437 if (i + 1 != argc) 438 usage(); 439 input_file_name_len = strlen(argv[i]); 440 input_file_name = TMALLOC(char, input_file_name_len + 1); 441 NO_SPACE(input_file_name); 442 strcpy(input_file_name, argv[i]); 443 } 444 445 void * 446 allocate(size_t n) 447 { 448 void *p; 449 450 p = NULL; 451 if (n) 452 { 453 p = CALLOC(1, n); 454 NO_SPACE(p); 455 } 456 return (p); 457 } 458 459 #define CREATE_FILE_NAME(dest, suffix) \ 460 dest = alloc_file_name(len, suffix) 461 462 static char * 463 alloc_file_name(size_t len, const char *suffix) 464 { 465 char *result = TMALLOC(char, len + strlen(suffix) + 1); 466 if (result == 0) 467 no_space(); 468 strcpy(result, file_prefix); 469 strcpy(result + len, suffix); 470 return result; 471 } 472 473 static char * 474 find_suffix(char *name, const char *suffix) 475 { 476 size_t len = strlen(name); 477 size_t slen = strlen(suffix); 478 if (len >= slen) 479 { 480 name += len - slen; 481 if (strcmp(name, suffix) == 0) 482 return name; 483 } 484 return NULL; 485 } 486 487 static void 488 create_file_names(void) 489 { 490 size_t len; 491 const char *defines_suffix; 492 const char *externs_suffix; 493 char *suffix; 494 495 suffix = NULL; 496 defines_suffix = DEFINES_SUFFIX; 497 externs_suffix = EXTERNS_SUFFIX; 498 499 /* compute the file_prefix from the user provided output_file_name */ 500 if (output_file_name != 0) 501 { 502 if (!(suffix = find_suffix(output_file_name, OUTPUT_SUFFIX)) 503 && (suffix = find_suffix(output_file_name, ".c"))) 504 { 505 defines_suffix = ".h"; 506 externs_suffix = ".i"; 507 } 508 } 509 510 if (suffix != NULL) 511 { 512 len = (size_t) (suffix - output_file_name); 513 file_prefix = TMALLOC(char, len + 1); 514 NO_SPACE(file_prefix); 515 strncpy(file_prefix, output_file_name, len)[len] = 0; 516 } 517 else 518 len = strlen(file_prefix); 519 520 /* if "-o filename" was not given */ 521 if (output_file_name == 0) 522 { 523 oflag = 1; 524 CREATE_FILE_NAME(output_file_name, OUTPUT_SUFFIX); 525 } 526 527 if (rflag) 528 { 529 CREATE_FILE_NAME(code_file_name, CODE_SUFFIX); 530 } 531 else 532 code_file_name = output_file_name; 533 534 if (dflag && !dflag2) 535 { 536 CREATE_FILE_NAME(defines_file_name, defines_suffix); 537 } 538 539 if (iflag) 540 { 541 CREATE_FILE_NAME(externs_file_name, externs_suffix); 542 } 543 544 if (vflag) 545 { 546 CREATE_FILE_NAME(verbose_file_name, VERBOSE_SUFFIX); 547 } 548 549 if (gflag) 550 { 551 CREATE_FILE_NAME(graph_file_name, GRAPH_SUFFIX); 552 } 553 554 if (suffix != NULL) 555 { 556 FREE(file_prefix); 557 } 558 } 559 560 #if USE_MKSTEMP 561 static void 562 close_tmpfiles(void) 563 { 564 while (my_tmpfiles != 0) 565 { 566 MY_TMPFILES *next = my_tmpfiles->next; 567 568 (void)chmod(my_tmpfiles->name, 0644); 569 (void)unlink(my_tmpfiles->name); 570 571 free(my_tmpfiles->name); 572 free(my_tmpfiles); 573 574 my_tmpfiles = next; 575 } 576 } 577 578 #ifndef HAVE_MKSTEMP 579 static int 580 my_mkstemp(char *temp) 581 { 582 int fd; 583 char *dname; 584 char *fname; 585 char *name; 586 587 /* 588 * Split-up to use tempnam, rather than tmpnam; the latter (like 589 * mkstemp) is unusable on Windows. 590 */ 591 if ((fname = strrchr(temp, '/')) != 0) 592 { 593 dname = strdup(temp); 594 dname[++fname - temp] = '\0'; 595 } 596 else 597 { 598 dname = 0; 599 fname = temp; 600 } 601 if ((name = tempnam(dname, fname)) != 0) 602 { 603 fd = open(name, O_CREAT | O_EXCL | O_RDWR); 604 strcpy(temp, name); 605 } 606 else 607 { 608 fd = -1; 609 } 610 611 if (dname != 0) 612 free(dname); 613 614 return fd; 615 } 616 #define mkstemp(s) my_mkstemp(s) 617 #endif 618 619 #endif 620 621 /* 622 * tmpfile() should be adequate, except that it may require special privileges 623 * to use, e.g., MinGW and Windows 7 where it tries to use the root directory. 624 */ 625 static FILE * 626 open_tmpfile(const char *label) 627 { 628 #define MY_FMT "%s/%.*sXXXXXX" 629 FILE *result; 630 #if USE_MKSTEMP 631 const char *tmpdir; 632 char *name; 633 634 if (((tmpdir = getenv("TMPDIR")) == 0 || access(tmpdir, W_OK) != 0) || 635 ((tmpdir = getenv("TEMP")) == 0 || access(tmpdir, W_OK) != 0)) 636 { 637 #ifdef P_tmpdir 638 tmpdir = P_tmpdir; 639 #else 640 tmpdir = "/tmp"; 641 #endif 642 if (access(tmpdir, W_OK) != 0) 643 tmpdir = "."; 644 } 645 646 /* The size of the format is guaranteed to be longer than the result from 647 * printing empty strings with it; this calculation accounts for the 648 * string-lengths as well. 649 */ 650 name = malloc(strlen(tmpdir) + sizeof(MY_FMT) + strlen(label)); 651 652 result = 0; 653 if (name != 0) 654 { 655 int fd; 656 const char *mark; 657 658 mode_t save_umask = umask(0177); 659 660 if ((mark = strrchr(label, '_')) == 0) 661 mark = label + strlen(label); 662 663 sprintf(name, MY_FMT, tmpdir, (int)(mark - label), label); 664 fd = mkstemp(name); 665 if (fd >= 0 666 && (result = fdopen(fd, "w+")) != 0) 667 { 668 MY_TMPFILES *item; 669 670 if (my_tmpfiles == 0) 671 { 672 atexit(close_tmpfiles); 673 } 674 675 item = NEW(MY_TMPFILES); 676 NO_SPACE(item); 677 678 item->name = name; 679 NO_SPACE(item->name); 680 681 item->next = my_tmpfiles; 682 my_tmpfiles = item; 683 } 684 else 685 { 686 FREE(name); 687 } 688 (void)umask(save_umask); 689 } 690 #else 691 result = tmpfile(); 692 #endif 693 694 if (result == 0) 695 open_error(label); 696 return result; 697 #undef MY_FMT 698 } 699 700 static void 701 open_files(void) 702 { 703 create_file_names(); 704 705 if (input_file == 0) 706 { 707 input_file = fopen(input_file_name, "r"); 708 if (input_file == 0) 709 open_error(input_file_name); 710 } 711 712 action_file = open_tmpfile("action_file"); 713 text_file = open_tmpfile("text_file"); 714 715 if (vflag) 716 { 717 verbose_file = fopen(verbose_file_name, "w"); 718 if (verbose_file == 0) 719 open_error(verbose_file_name); 720 } 721 722 if (gflag) 723 { 724 graph_file = fopen(graph_file_name, "w"); 725 if (graph_file == 0) 726 open_error(graph_file_name); 727 fprintf(graph_file, "digraph %s {\n", file_prefix); 728 fprintf(graph_file, "\tedge [fontsize=10];\n"); 729 fprintf(graph_file, "\tnode [shape=box,fontsize=10];\n"); 730 fprintf(graph_file, "\torientation=landscape;\n"); 731 fprintf(graph_file, "\trankdir=LR;\n"); 732 fprintf(graph_file, "\t/*\n"); 733 fprintf(graph_file, "\tmargin=0.2;\n"); 734 fprintf(graph_file, "\tpage=\"8.27,11.69\"; // for A4 printing\n"); 735 fprintf(graph_file, "\tratio=auto;\n"); 736 fprintf(graph_file, "\t*/\n"); 737 } 738 739 if (dflag || dflag2) 740 { 741 defines_file = fopen(defines_file_name, "w"); 742 if (defines_file == 0) 743 open_error(defines_file_name); 744 union_file = open_tmpfile("union_file"); 745 } 746 747 if (iflag) 748 { 749 externs_file = fopen(externs_file_name, "w"); 750 if (externs_file == 0) 751 open_error(externs_file_name); 752 } 753 754 output_file = fopen(output_file_name, "w"); 755 if (output_file == 0) 756 open_error(output_file_name); 757 758 if (rflag) 759 { 760 code_file = fopen(code_file_name, "w"); 761 if (code_file == 0) 762 open_error(code_file_name); 763 } 764 else 765 code_file = output_file; 766 } 767 768 int 769 main(int argc, char *argv[]) 770 { 771 SRexpect = -1; 772 RRexpect = -1; 773 exit_code = EXIT_SUCCESS; 774 775 set_signals(); 776 getargs(argc, argv); 777 open_files(); 778 reader(); 779 lr0(); 780 lalr(); 781 make_parser(); 782 graph(); 783 finalize_closure(); 784 verbose(); 785 output(); 786 done(exit_code); 787 /*NOTREACHED */ 788 } 789