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