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, 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 static void
 149 fatal_banner (void)
 150 {
 151   if (infile == 0)
 152     fprintf(stderr, _("%s: fatal error: "), program_name);
 153   else
 154     fprintf(stderr, _("%s:%d: fatal error: "), infile, lineno);
 155 }
 156
 157 /* Print the message S for a fatal error.  */
 158
 159 void
 160 fatal (char *s)
 161 {
 162   fatal_banner ();
 163   fputs (s, stderr);
 164   fputc ('\n', stderr);
 165   done (1);
 166 }
 167
 168
 169 /* Print a message for a fatal error.  Use FMT to construct the message
 170    and incorporate string X1.  */
 171
 172 void
 173 fatals (char *fmt, char *x1)
 174 {
 175   fatal_banner ();
 176   fprintf (stderr, fmt, x1);
 177   fputc ('\n', stderr);
 178   done (1);
 179 }
 180
 181 static void
 182 warn_banner (void)
 183 {
 184   if (infile == 0)
 185     fprintf(stderr, _("%s: "), program_name);
 186   else
 187     fprintf(stderr, _("%s:%d: "), infile, lineno);
 188   failure = 1;
 189 }
 190
 191 /* Print a warning message S.  */
 192
 193 void
 194 warn (char *s)
 195 {
 196   warn_banner ();
 197   fputs (s, stderr);
 198   fputc ('\n', stderr);
 199 }
 200
 201 /* Print a warning message containing the string for the integer X1.
 202    The message is given by the format FMT.  */
 203
 204 void
 205 warni (char *fmt, int x1)
 206 {
 207   warn_banner ();
 208   fprintf (stderr, fmt, x1);
 209   fputc ('\n', stderr);
 210 }
 211
 212 /* Print a warning message containing the string X1.
 213    The message is given by the format FMT.  */
 214
 215 void
 216 warns (char *fmt, char *x1)
 217 {
 218   warn_banner ();
 219   fprintf (stderr, fmt, x1);
 220   fputc ('\n', stderr);
 221 }
 222
 223 /* Print a warning message containing the two strings X1 and X2.
 224         The message is given by the format FMT.  */
 225
 226 void
 227 warnss (char *fmt, char *x1, char *x2)
 228 {
 229   warn_banner ();
 230   fprintf (stderr, fmt, x1, x2);
 231   fputc ('\n', stderr);
 232 }
 233
 234 /* Print a warning message containing the 3 strings X1, X2, X3.
 235    The message is given by the format FMT.  */
 236
 237 void
 238 warnsss (char *fmt, char *x1, char *x2, char *x3)
 239 {
 240   warn_banner ();
 241   fprintf (stderr, fmt, x1, x2, x3);
 242   fputc ('\n', stderr);
 243 }
 244
 245 /* Print a message for the fatal occurence of more than MAXSHORT
 246    instances of whatever is denoted by the string S.  */
 247
 248 void
 249 toomany (char *s)
 250 {
 251   fatal_banner ();
 252   fprintf (stderr, _("too many %s (max %d)"), s, MAXSHORT);
 253   fputc ('\n', stderr);
 254   done (1);
 255 }
 256
 257 /* Abort for an internal error denoted by string S.  */
 258
 259 void
 260 berror (char *s)
 261 {
 262   fprintf(stderr, _("%s: internal error: %s\n"), program_name, s);
 263   abort();
 264 }