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
done(int k)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
onintr(int sig GCC_UNUSED)183 onintr(int sig GCC_UNUSED)
184 {
185 got_intr = 1;
186 done(EXIT_FAILURE);
187 }
188
189 static void
set_signals(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
usage(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
invalid_option(const char * option)283 invalid_option(const char *option)
284 {
285 fprintf(stderr, "invalid option: %s\n", option);
286 usage();
287 }
288
289 static void
setflag(int ch)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
getargs(int argc,char * argv[])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 *
allocate(size_t n)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 *
alloc_file_name(size_t len,const char * suffix)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 *
find_suffix(char * name,const char * suffix)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
create_file_names(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
close_tmpfiles(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
my_mkstemp(char * temp)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 *
open_tmpfile(const char * label)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
open_files(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
main(int argc,char * argv[])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