usr.bin/yacc/main.c

   1 /*
   2  * Copyright (c) 1989 The Regents of the University of California.
   3  * All rights reserved.
   4  *
   5  * This code is derived from software contributed to Berkeley by
   6  * Robert Paul Corbett.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  * 3. All advertising materials mentioning features or use of this software
  17  *    must display the following acknowledgement:
  18  *      This product includes software developed by the University of
  19  *      California, Berkeley and its contributors.
  20  * 4. Neither the name of the University nor the names of its contributors
  21  *    may be used to endorse or promote products derived from this software
  22  *    without specific prior written permission.
  23  *
  24  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  25  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  26  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  27  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  28  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  29  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  30  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  31  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  32  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  33  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  34  * SUCH DAMAGE.
  35  *
  36  * @(#) Copyright (c) 1989 The Regents of the University of California. All rights reserved.
  37  * @(#)main.c   5.5 (Berkeley) 5/24/93
  38  * $FreeBSD: src/usr.bin/yacc/main.c,v 1.12 2000/01/10 20:26:24 kris Exp $
  39  */
  40
  41 #include <signal.h>
  42 #include <stdlib.h>
  43 #include <string.h>
  44 #include <unistd.h>
  45 #include "defs.h"
  46
  47 char dflag;
  48 char lflag;
  49 char rflag;
  50 char tflag;
  51 char vflag;
  52
  53 const char *symbol_prefix;
  54 const char *file_prefix = "y";
  55 const char *temp_form = "yacc.XXXXXXXXXXX";
  56
  57 int lineno;
  58 int outline;
  59
  60 char *action_file_name;
  61 char *code_file_name;
  62 char *defines_file_name;
  63 const char *input_file_name = "";
  64 char *output_file_name;
  65 char *text_file_name;
  66 char *union_file_name;
  67 char *verbose_file_name;
  68
  69 FILE *action_file;      /*  a temp file, used to save actions associated    */
  70                         /*  with rules until the parser is written          */
  71 FILE *code_file;        /*  y.code.c (used when the -r option is specified) */
  72 FILE *defines_file;     /*  y.tab.h                                         */
  73 FILE *input_file;       /*  the input file                                  */
  74 FILE *output_file;      /*  y.tab.c                                         */
  75 FILE *text_file;        /*  a temp file, used to save text until all        */
  76                         /*  symbols have been defined                       */
  77 FILE *union_file;       /*  a temp file, used to save the union             */
  78                         /*  definition until all symbol have been           */
  79                         /*  defined                                         */
  80 FILE *verbose_file;     /*  y.output                                        */
  81
  82 int nitems;
  83 int nrules;
  84 int nsyms;
  85 int ntokens;
  86 int nvars;
  87
  88 int   start_symbol;
  89 char  **symbol_name;
  90 short *symbol_value;
  91 short *symbol_prec;
  92 char  *symbol_assoc;
  93
  94 short *ritem;
  95 short *rlhs;
  96 short *rrhs;
  97 short *rprec;
  98 char  *rassoc;
  99 short **derives;
 100 char *nullable;
 101
 102 static void cleanup(void);
 103 static void create_file_names(void);
 104 static void getargs(int, char **);
 105 static void onintr(int);
 106 static void open_files(void);
 107 static void set_signals(void);
 108 static void usage(void);
 109
 110
 111 static void
 112 cleanup(void)
 113 {
 114     if (action_file) { fclose(action_file); unlink(action_file_name); }
 115     if (text_file) { fclose(text_file); unlink(text_file_name); }
 116     if (union_file) { fclose(union_file); unlink(union_file_name); }
 117 }
 118
 119
 120 static void
 121 onintr(int signo __unused)
 122 {
 123     if (action_file)
 124         unlink(action_file_name);
 125     if (text_file)
 126         unlink(text_file_name);
 127     if (union_file)
 128         unlink(union_file_name);
 129     _exit(1);
 130 }
 131
 132
 133 static void
 134 set_signals(void)
 135 {
 136 #ifdef SIGINT
 137     if (signal(SIGINT, SIG_IGN) != SIG_IGN)
 138         signal(SIGINT, onintr);
 139 #endif
 140 #ifdef SIGTERM
 141     if (signal(SIGTERM, SIG_IGN) != SIG_IGN)
 142         signal(SIGTERM, onintr);
 143 #endif
 144 #ifdef SIGHUP
 145     if (signal(SIGHUP, SIG_IGN) != SIG_IGN)
 146         signal(SIGHUP, onintr);
 147 #endif
 148 }
 149
 150
 151 static void
 152 usage(void)
 153 {
 154     fprintf(stderr, "%s\n%s\n",
 155                 "usage: yacc [-dlrtv] [-b file_prefix] [-o output_filename]",
 156                 "            [-p symbol_prefix] filename");
 157     exit(1);
 158 }
 159
 160
 161 static void
 162 getargs(int argc, char **argv)
 163 {
 164     int i;
 165     char *s;
 166
 167     for (i = 1; i < argc; ++i)
 168     {
 169         s = argv[i];
 170         if (*s != '-') break;
 171         switch (*++s)
 172         {
 173         case '\0':
 174             input_file = stdin;
 175             if (i + 1 < argc) usage();
 176             return;
 177
 178         case '-':
 179             ++i;
 180             goto no_more_options;
 181
 182         case 'b':
 183             if (*++s)
 184                  file_prefix = s;
 185             else if (++i < argc)
 186                 file_prefix = argv[i];
 187             else
 188                 usage();
 189             continue;
 190
 191         case 'd':
 192             dflag = 1;
 193             break;
 194
 195         case 'l':
 196             lflag = 1;
 197             break;
 198
 199         case 'o':
 200             if (*++s)
 201                 output_file_name = s;
 202             else if (++i < argc)
 203                 output_file_name = argv[i];
 204             else
 205                 usage();
 206             continue;
 207
 208         case 'p':
 209             if (*++s)
 210                 symbol_prefix = s;
 211             else if (++i < argc)
 212                 symbol_prefix = argv[i];
 213             else
 214                 usage();
 215             continue;
 216
 217         case 'r':
 218             rflag = 1;
 219             break;
 220
 221         case 't':
 222             tflag = 1;
 223             break;
 224
 225         case 'v':
 226             vflag = 1;
 227             break;
 228
 229         default:
 230             usage();
 231         }
 232
 233         for (;;)
 234         {
 235             switch (*++s)
 236             {
 237             case '\0':
 238                 goto end_of_option;
 239
 240             case 'd':
 241                 dflag = 1;
 242                 break;
 243
 244             case 'l':
 245                 lflag = 1;
 246                 break;
 247
 248             case 'r':
 249                 rflag = 1;
 250                 break;
 251
 252             case 't':
 253                 tflag = 1;
 254                 break;
 255
 256             case 'v':
 257                 vflag = 1;
 258                 break;
 259
 260             default:
 261                 usage();
 262             }
 263         }
 264 end_of_option:;
 265     }
 266
 267 no_more_options:;
 268     if (i + 1 != argc) usage();
 269     input_file_name = argv[i];
 270 }
 271
 272
 273 char *
 274 allocate(unsigned n)
 275 {
 276     char *p;
 277
 278     p = NULL;
 279     if (n)
 280     {
 281         p = CALLOC(1, n);
 282         if (!p) no_space();
 283     }
 284     return (p);
 285 }
 286
 287
 288 static void
 289 create_file_names(void)
 290 {
 291     int i, len;
 292     const char *tmpdir;
 293
 294     tmpdir = getenv("TMPDIR");
 295     if (tmpdir == NULL) tmpdir = "/tmp";
 296
 297     len = strlen(tmpdir);
 298     i = len + 17;
 299     if (len && tmpdir[len-1] != '/')
 300         ++i;
 301
 302     action_file_name = MALLOC(i);
 303     if (action_file_name == NULL) no_space();
 304     text_file_name = MALLOC(i);
 305     if (text_file_name == NULL) no_space();
 306     union_file_name = MALLOC(i);
 307     if (union_file_name == NULL) no_space();
 308
 309     strcpy(action_file_name, tmpdir);
 310     strcpy(text_file_name, tmpdir);
 311     strcpy(union_file_name, tmpdir);
 312
 313     if (len && tmpdir[len - 1] != '/')
 314     {
 315         action_file_name[len] = '/';
 316         text_file_name[len] = '/';
 317         union_file_name[len] = '/';
 318         ++len;
 319     }
 320
 321     strcpy(action_file_name + len, temp_form);
 322     strcpy(text_file_name + len, temp_form);
 323     strcpy(union_file_name + len, temp_form);
 324
 325     action_file_name[len + 5] = 'a';
 326     text_file_name[len + 5] = 't';
 327     union_file_name[len + 5] = 'u';
 328
 329     if (output_file_name != NULL)
 330     {
 331         file_prefix = output_file_name;
 332         len = strlen(file_prefix);
 333     }
 334     else
 335     {
 336         len = strlen(file_prefix);
 337         output_file_name = MALLOC(len + 7);
 338         if (output_file_name == NULL)
 339             no_space();
 340         strcpy(output_file_name, file_prefix);
 341         strcpy(output_file_name + len, OUTPUT_SUFFIX);
 342     }
 343
 344     if (rflag)
 345     {
 346         code_file_name = MALLOC(len + 8);
 347         if (code_file_name == NULL)
 348             no_space();
 349         strcpy(code_file_name, file_prefix);
 350         if (file_prefix == output_file_name)
 351         {
 352             /*
 353              * XXX ".tab.c" here is OUTPUT_SUFFIX, but since its length is
 354              * in various magic numbers, don't bother using the macro.
 355              */
 356             if (len >= 6 && strcmp(code_file_name + len - 6, ".tab.c") == 0)
 357                 strcpy(code_file_name + len - 6, CODE_SUFFIX);
 358             else if (len >= 2 && strcmp(code_file_name + len - 2, ".c") == 0)
 359                 strcpy(code_file_name + len - 2, CODE_SUFFIX);
 360             else
 361                 strcpy(code_file_name + len, CODE_SUFFIX);
 362         }
 363         else
 364             strcpy(code_file_name + len, CODE_SUFFIX);
 365     }
 366     else
 367         code_file_name = output_file_name;
 368
 369     if (dflag)
 370     {
 371         defines_file_name = MALLOC(len + 7);
 372         if (defines_file_name == NULL)
 373             no_space();
 374         strcpy(defines_file_name, file_prefix);
 375         if (file_prefix == output_file_name)
 376         {
 377 #define BISON_DEFINES_SUFFIX  ".h"
 378             if (len >= 2 && strcmp(defines_file_name + len - 2, ".c") == 0)
 379                 strcpy(defines_file_name + len - 2, BISON_DEFINES_SUFFIX);
 380             else
 381                 strcpy(defines_file_name + len, BISON_DEFINES_SUFFIX);
 382         }
 383         else
 384             strcpy(defines_file_name + len, DEFINES_SUFFIX);
 385     }
 386
 387     if (vflag)
 388     {
 389         verbose_file_name = MALLOC(len + 8);
 390         if (verbose_file_name == NULL)
 391             no_space();
 392         strcpy(verbose_file_name, file_prefix);
 393         if (file_prefix == output_file_name)
 394         {
 395             if (len >= 6 && strcmp(verbose_file_name + len - 6, ".tab.c") == 0)
 396                 strcpy(verbose_file_name + len - 6, VERBOSE_SUFFIX);
 397             else if (len >= 2 && strcmp(verbose_file_name + len - 2, ".c") == 0)
 398                 strcpy(verbose_file_name + len - 2, VERBOSE_SUFFIX);
 399             else
 400                 strcpy(verbose_file_name + len, VERBOSE_SUFFIX);
 401         }
 402         else
 403             strcpy(verbose_file_name + len, VERBOSE_SUFFIX);
 404     }
 405 }
 406
 407
 408 static void
 409 open_files(void)
 410 {
 411     int fd;
 412
 413     create_file_names();
 414
 415     if (input_file == NULL)
 416     {
 417         input_file = fopen(input_file_name, "r");
 418         if (input_file == NULL)
 419             open_error(input_file_name);
 420     }
 421
 422     fd = mkstemp(action_file_name);
 423     if (fd < 0 || (action_file = fdopen(fd, "w")) == NULL) {
 424         if (fd >= 0)
 425             close(fd);
 426         open_error(action_file_name);
 427     }
 428     fd = mkstemp(text_file_name);
 429     if (fd < 0 || (text_file = fdopen(fd, "w")) == NULL) {
 430         if (fd >= 0)
 431             close(fd);
 432         open_error(text_file_name);
 433     }
 434     fd = mkstemp(union_file_name);
 435     if (fd < 0 || (union_file = fdopen(fd, "w")) == NULL) {
 436         if (fd >= 0)
 437             close(fd);
 438         open_error(union_file_name);
 439     }
 440
 441     text_file = fopen(text_file_name, "w");
 442     if (text_file == NULL)
 443         open_error(text_file_name);
 444
 445     if (vflag)
 446     {
 447         verbose_file = fopen(verbose_file_name, "w");
 448         if (verbose_file == NULL)
 449             open_error(verbose_file_name);
 450     }
 451
 452     if (dflag)
 453     {
 454         defines_file = fopen(defines_file_name, "w");
 455         if (defines_file == NULL)
 456             open_error(defines_file_name);
 457         union_file = fopen(union_file_name, "w");
 458         if (union_file ==  NULL)
 459             open_error(union_file_name);
 460     }
 461
 462     output_file = fopen(output_file_name, "w");
 463     if (output_file == NULL)
 464         open_error(output_file_name);
 465
 466     if (rflag)
 467     {
 468         code_file = fopen(code_file_name, "w");
 469         if (code_file == NULL)
 470             open_error(code_file_name);
 471     }
 472     else
 473         code_file = output_file;
 474 }
 475
 476
 477 int
 478 main(int argc, char **argv)
 479 {
 480     atexit(cleanup);
 481     set_signals();
 482     getargs(argc, argv);
 483     open_files();
 484     reader();
 485     lr0();
 486     lalr();
 487     make_parser();
 488     verbose();
 489     output();
 490     exit(0);
 491     /*NOTREACHED*/
 492 }