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