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