src/main.c

   1 /* Top level entry point of bison,
   2    Copyright (C) 1984, 1986, 1989, 1992, 1995 Free Software Foundation, Inc.
   3
   4 This file is part of Bison, the GNU Compiler Compiler.
   5
   6 Bison is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 Bison is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with Bison; see the file COPYING.  If not, write to
  18 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19
  20
  21 #include <stdio.h>
  22 #include "system.h"
  23 #include "machine.h"    /* for MAXSHORT */
  24
  25 extern  int lineno;
  26 extern  int verboseflag;
  27 extern  char *infile;
  28
  29 /* Nonzero means failure has been detected; don't write a parser file.  */
  30 int failure;
  31
  32 /* The name this program was run with, for messages.  */
  33 char *program_name;
  34
  35 char *printable_version PARAMS((int));
  36 char *int_to_string PARAMS((int));
  37 void fatal PARAMS((char *));
  38 void fatals PARAMS((char *, char *));
  39 void warn PARAMS((char *));
  40 void warni PARAMS((char *, int));
  41 void warns PARAMS((char *, char *));
  42 void warnss PARAMS((char *, char *, char *));
  43 void warnsss PARAMS((char *, char *, char *, char *));
  44 void toomany PARAMS((char *));
  45 void berror PARAMS((char *));
  46
  47 extern void getargs PARAMS((int, char *[]));
  48 extern void openfiles PARAMS((void));
  49 extern void reader PARAMS((void));
  50 extern void reduce_grammar PARAMS((void));
  51 extern void set_derives PARAMS((void));
  52 extern void set_nullable PARAMS((void));
  53 extern void generate_states PARAMS((void));
  54 extern void lalr PARAMS((void));
  55 extern void initialize_conflicts PARAMS((void));
  56 extern void verbose PARAMS((void));
  57 extern void terse PARAMS((void));
  58 extern void output PARAMS((void));
  59 extern void done PARAMS((int));
  60
  61
  62 /* VMS complained about using `int'.  */
  63
  64 int
  65 main (int argc, char *argv[])
  66 {
  67   program_name = argv[0];
  68   setlocale (LC_ALL, "");
  69   bindtextdomain (PACKAGE, LOCALEDIR);
  70   textdomain (PACKAGE);
  71
  72   failure = 0;
  73   lineno = 0;
  74   getargs(argc, argv);
  75   openfiles();
  76
  77   /* read the input.  Copy some parts of it to fguard, faction, ftable and fattrs.
  78      In file reader.c.
  79      The other parts are recorded in the grammar; see gram.h.  */
  80   reader();
  81   if (failure)
  82         done(failure);
  83
  84   /* find useless nonterminals and productions and reduce the grammar.  In
  85      file reduce.c */
  86   reduce_grammar();
  87
  88   /* record other info about the grammar.  In files derives and nullable.  */
  89   set_derives();
  90   set_nullable();
  91
  92   /* convert to nondeterministic finite state machine.  In file LR0.
  93      See state.h for more info.  */
  94   generate_states();
  95
  96   /* make it deterministic.  In file lalr.  */
  97   lalr();
  98
  99   /* Find and record any conflicts: places where one token of lookahead is not
 100      enough to disambiguate the parsing.  In file conflicts.
 101      Also resolve s/r conflicts based on precedence declarations.  */
 102   initialize_conflicts();
 103
 104   /* print information about results, if requested.  In file print. */
 105   if (verboseflag)
 106     verbose();
 107   else
 108     terse();
 109
 110   /* output the tables and the parser to ftable.  In file output. */
 111   output();
 112   done(failure);
 113   return failure;
 114 }
 115 \f
 116 /* functions to report errors which prevent a parser from being generated */
 117
 118
 119 /* Return a string containing a printable version of C:
 120    either C itself, or the corresponding \DDD code.  */
 121
 122 char *
 123 printable_version (int c)
 124 {
 125   static char buf[10];
 126   if (c < ' ' || c >= '\177')
 127     sprintf(buf, "\\%o", c);
 128   else
 129     {
 130       buf[0] = c;
 131       buf[1] = '\0';
 132     }
 133   return buf;
 134 }
 135
 136 /* Generate a string from the integer I.
 137    Return a ptr to internal memory containing the string.  */
 138
 139 char *
 140 int_to_string (int i)
 141 {
 142   static char buf[20];
 143   sprintf(buf, "%d", i);
 144   return buf;
 145 }
 146
 147 static void
 148 fatal_banner (void)
 149 {
 150   if (infile == 0)
 151     fprintf(stderr, _("%s: fatal error: "), program_name);
 152   else
 153     fprintf(stderr, _("%s:%d: fatal error: "), infile, lineno);
 154 }
 155
 156 /* Print the message S for a fatal error.  */
 157
 158 void
 159 fatal (char *s)
 160 {
 161   fatal_banner ();
 162   fputs (s, stderr);
 163   fputc ('\n', stderr);
 164   done (1);
 165 }
 166
 167
 168 /* Print a message for a fatal error.  Use FMT to construct the message
 169    and incorporate string X1.  */
 170
 171 void
 172 fatals (char *fmt, char *x1)
 173 {
 174   fatal_banner ();
 175   fprintf (stderr, fmt, x1);
 176   fputc ('\n', stderr);
 177   done (1);
 178 }
 179
 180 static void
 181 warn_banner (void)
 182 {
 183   if (infile == 0)
 184     fprintf(stderr, _("%s: "), program_name);
 185   else
 186     fprintf(stderr, _("%s:%d: "), infile, lineno);
 187   failure = 1;
 188 }
 189
 190 /* Print a warning message S.  */
 191
 192 void
 193 warn (char *s)
 194 {
 195   warn_banner ();
 196   fputs (s, stderr);
 197   fputc ('\n', stderr);
 198 }
 199
 200 /* Print a warning message containing the string for the integer X1.
 201    The message is given by the format FMT.  */
 202
 203 void
 204 warni (char *fmt, int x1)
 205 {
 206   warn_banner ();
 207   fprintf (stderr, fmt, x1);
 208   fputc ('\n', stderr);
 209 }
 210
 211 /* Print a warning message containing the string X1.
 212    The message is given by the format FMT.  */
 213
 214 void
 215 warns (char *fmt, char *x1)
 216 {
 217   warn_banner ();
 218   fprintf (stderr, fmt, x1);
 219   fputc ('\n', stderr);
 220 }
 221
 222 /* Print a warning message containing the two strings X1 and X2.
 223         The message is given by the format FMT.  */
 224
 225 void
 226 warnss (char *fmt, char *x1, char *x2)
 227 {
 228   warn_banner ();
 229   fprintf (stderr, fmt, x1, x2);
 230   fputc ('\n', stderr);
 231 }
 232
 233 /* Print a warning message containing the 3 strings X1, X2, X3.
 234    The message is given by the format FMT.  */
 235
 236 void
 237 warnsss (char *fmt, char *x1, char *x2, char *x3)
 238 {
 239   warn_banner ();
 240   fprintf (stderr, fmt, x1, x2, x3);
 241   fputc ('\n', stderr);
 242 }
 243
 244 /* Print a message for the fatal occurence of more than MAXSHORT
 245    instances of whatever is denoted by the string S.  */
 246
 247 void
 248 toomany (char *s)
 249 {
 250   fatal_banner ();
 251   fprintf (stderr, _("too many %s (max %d)"), s, MAXSHORT);
 252   fputc ('\n', stderr);
 253   done (1);
 254 }
 255
 256 /* Abort for an internal error denoted by string S.  */
 257
 258 void
 259 berror (char *s)
 260 {
 261   fprintf(stderr, _("%s: internal error: %s\n"), program_name, s);
 262   abort();
 263 }