src/main.c

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