src/java_cup/Main.java

package java_cup;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.PrintStream;
import java.util.Enumeration;

/** This class serves as the main driver for the JavaCup system.
 *  It accepts user options and coordinates overall control flow.
 *  The main flow of control includes the following activities:
 *  <ul>
 *    <li> Parse user supplied arguments and options.
 *    <li> Open output files.
 *    <li> Parse the specification from standard input.
 *    <li> Check for unused terminals, non-terminals, and productions.
 *    <li> Build the state machine, tables, etc.
 *    <li> Output the generated code.
 *    <li> Close output files.
 *    <li> Print a summary if requested.
 *  </ul>
 *
 *  Options to the main program include: <dl>
 *   <dt> -package name
 *   <dd> specify package generated classes go in [default none]
 *   <dt> -parser name
 *   <dd> specify parser class name [default "parser"]
 *   <dt> -symbols name
 *   <dd> specify name for symbol constant class [default "sym"]
 *   <dt> -nonterms
 *   <dd> put non terminals in symbol constant class
 *   <dt> -expect #
 *   <dd> number of conflicts expected/allowed [default 0]
 *   <dt> -compact_red
 *   <dd> compact tables by defaulting to most frequent reduce
 *   <dt> -nowarn
 *   <dd> don't warn about useless productions, etc.
 *   <dt> -nosummary
 *   <dd> don't print the usual summary of parse states, etc.
 *   <dt> -progress
 *   <dd> print messages to indicate progress of the system
 *   <dt> -time
 *   <dd> print time usage summary
 *   <dt> -dump_grammar
 *   <dd> produce a dump of the symbols and grammar
 *   <dt> -dump_states
 *   <dd> produce a dump of parse state machine
 *   <dt> -dump_tables
 *   <dd> produce a dump of the parse tables
 *   <dt> -dump
 *   <dd> produce a dump of all of the above
 *   <dt> -debug
 *   <dd> turn on debugging messages within JavaCup
 *   </dl>
 *
 * @version last updated: 11/25/95
 * @author  Scott Hudson
 */

public class Main {

  /*-----------------------------------------------------------*/
  /*--- Constructor(s) ----------------------------------------*/
  /*-----------------------------------------------------------*/
  /** Only constructor is private, so we do not allocate any instances of this
      class. */
  private Main() { }

  /*-------------------------*/
  /* Options set by the user */
  /*-------------------------*/
  /** User option -- do we print progress messages. */
  protected static boolean print_progress   = false;
  /** User option -- do we produce a dump of the state machine */
  protected static boolean opt_dump_states  = false;
  /** User option -- do we produce a dump of the parse tables */
  protected static boolean opt_dump_tables  = false;
  /** User option -- do we produce a dump of the grammar */
  protected static boolean opt_dump_grammar = false;
  /** User option -- do we show timing information as a part of the summary */
  protected static boolean opt_show_timing  = false;
  /** User option -- do we run produce extra debugging messages */
  protected static boolean opt_do_debug     = false;
  /** User option -- do we compact tables by making most common reduce the
      default action */
  protected static boolean opt_compact_red  = false;
  /** User option -- should we include non terminal symbol numbers in the
      symbol constant class. */
  protected static boolean include_non_terms = false;
  /** User option -- do not print a summary. */
  protected static boolean no_summary = false;
  /** User option -- number of conflicts to expect */
  protected static int expect_conflicts = 0;

  /*----------------------------------------------------------------------*/
  /* Timing data (not all of these time intervals are mutually exclusive) */
  /*----------------------------------------------------------------------*/
  /** Timing data -- when did we start */
  protected static long start_time       = 0;
  /** Timing data -- when did we end preliminaries */
  protected static long prelim_end       = 0;
  /** Timing data -- when did we end parsing */
  protected static long parse_end        = 0;
  /** Timing data -- when did we end checking */
  protected static long check_end        = 0;
  /** Timing data -- when did we end dumping */
  protected static long dump_end         = 0;
  /** Timing data -- when did we end state and table building */
  protected static long build_end        = 0;
  /** Timing data -- when did we end nullability calculation */
  protected static long nullability_end  = 0;
  /** Timing data -- when did we end first set calculation */
  protected static long first_end        = 0;
  /** Timing data -- when did we end state machine construction */
  protected static long machine_end      = 0;
  /** Timing data -- when did we end table construction */
  protected static long table_end        = 0;
  /** Timing data -- when did we end checking for non-reduced productions */
  protected static long reduce_check_end = 0;
  /** Timing data -- when did we finish emitting code */
  protected static long emit_end         = 0;
  /** Timing data -- when were we completely done */
  protected static long final_time       = 0;

  /* Additional timing information is also collected in emit */

  /** Path to create output files */
  private static String out_path = null;

  /*-----------------------------------------------------------*/
  /*--- Main Program ------------------------------------------*/
  /*-----------------------------------------------------------*/

  /** The main driver for the system.
   * @param argv an array of strings containing command line arguments.
   */
  public static void main(String argv[])
    throws internal_error, java.io.IOException, java.lang.Exception
    {
      boolean did_output = false;

      start_time = System.currentTimeMillis();

      /* process user options and arguments */
      parse_args(argv);

      /* open output files */
      if (print_progress) System.err.println("Opening files...");
      open_files();

      prelim_end = System.currentTimeMillis();

      /* parse spec into internal data structures */
      if (print_progress)
    System.err.println("Parsing specification from standard input...");
      parse_grammar_spec();

      parse_end = System.currentTimeMillis();

      /* don't proceed unless we are error free */
      if (lexer.error_count == 0)
    {
      /* check for unused bits */
          if (print_progress) System.err.println("Checking specification...");
          check_unused();

          check_end = System.currentTimeMillis();

      /* build the state machine and parse tables */
          if (print_progress) System.err.println("Building parse tables...");
          build_parser();

          build_end = System.currentTimeMillis();

      /* output the generated code */
          if (print_progress) System.err.println("Writing parser...");
          emit_parser();
      did_output = true;

          emit_end = System.currentTimeMillis();
    }
      else
    {
      /* fix up the times to make the summary easier */
      emit_end = parse_end;
    }

      /* do requested dumps */
      if (opt_dump_grammar) dump_grammar();
      if (opt_dump_states)  dump_machine();
      if (opt_dump_tables)  dump_tables();

      dump_end = System.currentTimeMillis();

      /* close output files */
      if (print_progress) System.err.println("Closing files...");
      close_files();

      /* produce a summary if desired */
      if (!no_summary) emit_summary(did_output);
    }

  /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/

  /** Print a "usage message" that described possible command line options,
   *  then exit.
   * @param message a specific error message to preface the usage message by.
   */
  protected static void usage(String message)
    {
      System.err.println();
      System.err.println(message);
      System.err.println();
      System.err.println(
"Usage: " + version.program_name + " [options]\n" +
"  and expects a specification file on standard input.\n" +
"  Legal options include:\n" +
"    -out path      specify the output files path [default current directory]\n" +
"    -package name  specify package generated classes go in [default none]\n" +
"    -parser name   specify parser class name [default \"parser\"]\n" +
"    -symbols name  specify name for symbol constant class [default \"sym\"]\n"+
"    -nonterms      put non terminals in symbol constant class\n" +
"    -expect #      number of conflicts expected/allowed [default 0]\n" +
"    -compact_red   compact tables by defaulting to most frequent reduce\n" +
"    -nowarn        don't warn about useless productions, etc.\n" +
"    -nosummary     don't print the usual summary of parse states, etc.\n" +
"    -progress      print messages to indicate progress of the system\n" +
"    -time          print time usage summary\n" +
"    -dump_grammar  produce a human readable dump of the symbols and grammar\n"+
"    -dump_states   produce a dump of parse state machine\n"+
"    -dump_tables   produce a dump of the parse tables\n"+
"    -dump          produce a dump of all of the above\n"
      );
      System.exit(1);
    }

  /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/

  /** Parse command line options and arguments to set various user-option
   *  flags and variables.
   * @param argv the command line arguments to be parsed.
   */
  protected static void parse_args(String argv[])
    {
      int len = argv.length;
      int i;

      /* parse the options */
      for (i=0; i<len; i++)
    {
      /* try to get the various options */
      if (argv[i].equals("-package"))
        {
          /* must have an arg */
          if (++i >= len || argv[i].startsWith("-") ||
                argv[i].endsWith(".cup"))
        usage("-package must have a name argument");

          /* record the name */
          emit.package_name = argv[i];
        }
      else if (argv[i].equals("-parser"))
        {
          /* must have an arg */
          if (++i >= len || argv[i].startsWith("-") ||
                argv[i].endsWith(".cup"))
        usage("-parser must have a name argument");

          /* record the name */
          emit.parser_class_name = argv[i];
        }
      else if (argv[i].equals("-input")) {
          /* must have an arg */
          if (++i >= len || argv[i].startsWith("-") ||
              argv[i].endsWith(".cup"))
              usage("-input must have a name argument");

          /* record the name */
          emit.input_file_name = argv[i];
      }
      else if (argv[i].equals("-symbols"))
        {
          /* must have an arg */
          if (++i >= len || argv[i].startsWith("-") ||
                argv[i].endsWith(".cup"))
        usage("-symbols must have a name argument");

          /* record the name */
          emit.symbol_const_class_name = argv[i];
        }
      else if (argv[i].equals("-nonterms"))
        {
          include_non_terms = true;
        }
      else if (argv[i].equals("-expect"))
        {
          /* must have an arg */
          if (++i >= len || argv[i].startsWith("-") ||
                argv[i].endsWith(".cup"))
        usage("-expect must have a name argument");

          /* record the number */
          try {
            expect_conflicts = Integer.parseInt(argv[i]);
          } catch (NumberFormatException e) {
        usage("-expect must be followed by a decimal integer");
          }
        }
          else if (argv[i].equals("-out"))
        {
          /* must have an arg */
              if (++i >= len || argv[i].startsWith("-"))
                usage("-out must have a path argument");

              /* validate path */
              if (argv[i].length() != 0) {
                out_path = argv[i] + File.separator;
                File f = new File(out_path);
                if (!f.exists() || !f.isDirectory())
                  out_path = null;
          }
              if (out_path == null)
                usage("-out argument must be a valid existing path");
        }
      else if (argv[i].equals("-compact_red"))  opt_compact_red = true;
      else if (argv[i].equals("-nosummary"))    no_summary = true;
      else if (argv[i].equals("-nowarn"))       emit.nowarn = true;
      else if (argv[i].equals("-dump_states"))  opt_dump_states = true;
      else if (argv[i].equals("-dump_tables"))  opt_dump_tables = true;
      else if (argv[i].equals("-progress"))     print_progress = true;
      else if (argv[i].equals("-dump_grammar")) opt_dump_grammar = true;
      else if (argv[i].equals("-dump"))
            opt_dump_states = opt_dump_tables = opt_dump_grammar = true;
      else if (argv[i].equals("-time"))         opt_show_timing = true;
      else if (argv[i].equals("-debug"))        opt_do_debug = true;
      else
        {
          usage("Unrecognized option \"" + argv[i] + "\"");
        }
    }
    }

  /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/

  /*-------*/
  /* Files */
  /*-------*/

  /** Input file.  This is a buffered version of System.in. */
  protected static BufferedInputStream input_file;

  /** Output file for the parser class. */
  protected static PrintStream parser_class_file;

  /** Output file for the symbol constant class. */
  protected static PrintStream symbol_class_file;

  /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/

  /** Open various files used by the system. */
  protected static void open_files()
    {
      File fil;
      String out_name;

      /* use a buffered version of standard input */
        if (emit.input_file_name != null)
            try {
                input_file = new BufferedInputStream(new FileInputStream(emit.input_file_name));
            } catch (Exception ex) {
                ex.printStackTrace();
                System.exit(3);
            }
        else
            input_file = new BufferedInputStream(System.in);

      /* open each of the output files */
      if (out_path == null)
        out_path = "";

      /* parser class */
      out_name = out_path + emit.parser_class_name + ".java";
      fil = new File(out_name);
      try {
        parser_class_file = new PrintStream(
         new BufferedOutputStream(new FileOutputStream(fil), 4096));
      } catch(Exception e) {
    System.err.println("Can't open \"" + out_name + "\" for output");
    System.exit(3);
      }

      /* symbol constants class */
      out_name = out_path + emit.symbol_const_class_name + ".java";
      fil = new File(out_name);
      try {
        symbol_class_file = new PrintStream(
         new BufferedOutputStream(new FileOutputStream(fil), 4096));
      } catch(Exception e) {
    System.err.println("Can't open \"" + out_name + "\" for output");
    System.exit(4);
      }
    }

  /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/

  /** Close various files used by the system. */
  protected static void close_files() throws java.io.IOException
    {
      if (input_file != null) input_file.close();
      if (parser_class_file != null) parser_class_file.close();
      if (symbol_class_file != null) symbol_class_file.close();
    }

  /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/

  /** Parse the grammar specification from standard input.  This produces
   *  sets of terminal, non-terminals, and productions which can be accessed
   *  via static variables of the respective classes, as well as the setting
   *  of various variables (mostly in the emit class) for small user supplied
   *  items such as the code to scan with.
   */
  protected static void parse_grammar_spec() throws java.lang.Exception
    {
      parser parser_obj;

      /* create a parser and parse with it */
      parser_obj = new parser();
      try {
    if (opt_do_debug)
          parser_obj.debug_parse();
    else
          parser_obj.parse();
      } catch (Exception e)
      {
    /* something threw an exception.  catch it and emit a message so we
       have a line number to work with, then re-throw it */
    lexer.emit_error("Internal error: Unexpected exception");
    throw e;
      }
    }

  /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/

  /** Check for unused symbols.  Unreduced productions get checked when
   *  tables are created.
   */
  protected static void check_unused()
    {
      terminal term;
      non_terminal nt;

      /* check for unused terminals */
      for (Enumeration t = terminal.all(); t.hasMoreElements(); )
    {
      term = (terminal)t.nextElement();

      /* don't issue a message for EOF */
      if (term == terminal.EOF) continue;

      /* or error */
      if (term == terminal.error) continue;

      /* is this one unused */
      if (term.use_count() == 0)
        {
          /* count it and warn if we are doing warnings */
          emit.unused_term++;
          if (!emit.nowarn)
        {
          System.err.println("Warning: Terminal \"" + term.name() +
                     "\" was declared but never used");
          lexer.warning_count++;
        }
        }
    }

      /* check for unused non terminals */
      for (Enumeration n = non_terminal.all(); n.hasMoreElements(); )
    {
      nt = (non_terminal)n.nextElement();

      /* is this one unused */
      if (nt.use_count() == 0)
        {
          /* count and warn if we are doing warnings */
          emit.unused_term++;
          if (!emit.nowarn)
        {
          System.err.println("Warning: Non terminal \"" + nt.name() +
                     "\" was declared but never used");
          lexer.warning_count++;
        }
        }
    }

    }

  /* . . . . . . . . . . . . . . . . . . . . . . . . .*/
  /* . . Internal Results of Generating the Parser . .*/
  /* . . . . . . . . . . . . . . . . . . . . . . . . .*/

  /** Start state in the overall state machine. */
  protected static lalr_state start_state;

  /** Resulting parse action table. */
  protected static parse_action_table action_table;

  /** Resulting reduce-goto table. */
  protected static parse_reduce_table reduce_table;

  /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/

  /** Build the (internal) parser from the previously parsed specification.
   *  This includes:<ul>
   *    <li> Computing nullability of non-terminals.
   *    <li> Computing first sets of non-terminals and productions.
   *    <li> Building the viable prefix recognizer machine.
   *    <li> Filling in the (internal) parse tables.
   *    <li> Checking for unreduced productions.
   *  </ul>
   */
  protected static void build_parser() throws internal_error
    {
      /* compute nullability of all non terminals */
      if (opt_do_debug || print_progress)
    System.err.println("  Computing non-terminal nullability...");
      non_terminal.compute_nullability();

      nullability_end = System.currentTimeMillis();

      /* compute first sets of all non terminals */
      if (opt_do_debug || print_progress)
    System.err.println("  Computing first sets...");
      non_terminal.compute_first_sets();

      first_end = System.currentTimeMillis();

      /* build the LR viable prefix recognition machine */
      if (opt_do_debug || print_progress)
    System.err.println("  Building state machine...");
      start_state = lalr_state.build_machine(emit.start_production);

      machine_end = System.currentTimeMillis();

      /* build the LR parser action and reduce-goto tables */
      if (opt_do_debug || print_progress)
    System.err.println("  Filling in tables...");
      action_table = new parse_action_table();
      reduce_table = new parse_reduce_table();
      for (Enumeration st = lalr_state.all(); st.hasMoreElements(); )
    {
      ((lalr_state)st.nextElement()).build_table_entries(
                                  action_table, reduce_table);
    }

      table_end = System.currentTimeMillis();

      /* check and warn for non-reduced productions */
      if (opt_do_debug || print_progress)
    System.err.println("  Checking for non-reduced productions...");
      action_table.check_reductions();

      reduce_check_end = System.currentTimeMillis();

      /* if we have more conflicts than we expected issue a message and die */
      if (emit.num_conflicts > expect_conflicts)
    {
      System.err.println("*** More conflicts encountered than expected " +
                 "-- parser generation aborted");
      lexer.error_count++;
      build_end = System.currentTimeMillis();

      /* do dumps and summary as needed */
          if (opt_dump_grammar) dump_grammar();
          if (opt_dump_states)  dump_machine();
      if (!no_summary) emit_summary(false);

      System.exit(100);
    }
    }

  /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/

  /** Call the emit routines necessary to write out the generated parser. */
  protected static void emit_parser() throws internal_error
    {
      emit.symbols(symbol_class_file, include_non_terms);
      emit.parser(parser_class_file, action_table, reduce_table,
          start_state.index(), emit.start_production, opt_compact_red);
    }

  /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/

  /** Helper routine to optionally return a plural or non-plural ending.
   * @param val the numerical value determining plurality.
   */
  protected static String plural(int val)
    {
      if (val == 1)
    return "";
      else
    return "s";
    }

  /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/

  /** Emit a long summary message to standard error (System.err) which
   *  summarizes what was found in the specification, how many states were
   *  produced, how many conflicts were found, etc.  A detailed timing
   *  summary is also produced if it was requested by the user.
   * @param output_produced did the system get far enough to generate code.
   */
  protected static void emit_summary(boolean output_produced)
    {
      final_time = System.currentTimeMillis();

      if (no_summary) return;

      System.err.println("------- " + version.title_str +
             " Parser Generation Summary -------");

      /* error and warning count */
      System.err.println("  " + lexer.error_count + " error" +
     plural(lexer.error_count) + " and " + lexer.warning_count +
     " warning" + plural(lexer.warning_count));

      /* basic stats */
      System.err.print("  " + terminal.number() + " terminal" +
             plural(terminal.number()) + ", ");
      System.err.print(non_terminal.number() + " non terminal" +
             plural(non_terminal.number()) + ", and ");
      System.err.println(production.number() + " production" +
             plural(production.number()) + " declared, ");
      System.err.println("  producing " + lalr_state.number() +
             " unique parse states.");

      /* unused symbols */
      System.err.println("  " + emit.unused_term + " terminal" +
             plural(emit.unused_term) + " declared but not used.");
      System.err.println("  " + emit.unused_non_term + " non terminal" +
             plural(emit.unused_term) + " declared but not used.");

      /* productions that didn't reduce */
      System.err.println("  " + emit.not_reduced + " production" +
             plural(emit.not_reduced) + " never reduced.");

      /* conflicts */
      System.err.println("  " + emit.num_conflicts + " conflict" +
             plural(emit.num_conflicts) + " detected" +
                     " (" + expect_conflicts + " expected).");

      /* code location */
      if (output_produced)
    System.err.println("  Code written to \"" + emit.parser_class_name +
            ".java\", and \"" + emit.symbol_const_class_name + ".java\".");
      else
    System.err.println("  No code produced.");

      if (opt_show_timing) show_times();

      System.err.println(
    "---------------------------------------------------- (" +
     version.version_str + ")");
    }

  /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/

  /** Produce the optional timing summary as part of an overall summary. */
  protected static void show_times()
    {
      long total_time = final_time - start_time;

      System.err.println(". . . . . . . . . . . . . . . . . . . . . . . . . ");
      System.err.println("  Timing Summary");
      System.err.println("    Total time       "
        + timestr(final_time-start_time, total_time));
      System.err.println("      Startup        "
    + timestr(prelim_end-start_time, total_time));
      System.err.println("      Parse          "
    + timestr(parse_end-prelim_end, total_time) );
      if (check_end != 0)
        System.err.println("      Checking       "
        + timestr(check_end-parse_end, total_time));
      if (check_end != 0 && build_end != 0)
        System.err.println("      Parser Build   "
        + timestr(build_end-check_end, total_time));
      if (nullability_end != 0 && check_end != 0)
        System.err.println("        Nullability  "
        + timestr(nullability_end-check_end, total_time));
      if (first_end != 0 && nullability_end != 0)
        System.err.println("        First sets   "
            + timestr(first_end-nullability_end, total_time));
      if (machine_end != 0 && first_end != 0)
        System.err.println("        State build  "
        + timestr(machine_end-first_end, total_time));
      if (table_end != 0 && machine_end != 0)
        System.err.println("        Table build  "
        + timestr(table_end-machine_end, total_time));
      if (reduce_check_end != 0 && table_end != 0)
        System.err.println("        Checking     "
        + timestr(reduce_check_end-table_end, total_time));
      if (emit_end != 0 && build_end != 0)
        System.err.println("      Code Output    "
        + timestr(emit_end-build_end, total_time));
      if (emit.symbols_time != 0)
    System.err.println("        Symbols      "
        + timestr(emit.symbols_time, total_time));
      if (emit.parser_time != 0)
    System.err.println("        Parser class "
        + timestr(emit.parser_time, total_time));
      if (emit.action_code_time != 0)
    System.err.println("          Actions    "
        + timestr(emit.action_code_time, total_time));
      if (emit.production_table_time != 0)
    System.err.println("          Prod table "
        + timestr(emit.production_table_time, total_time));
      if (emit.action_table_time != 0)
    System.err.println("          Action tab "
        + timestr(emit.action_table_time, total_time));
      if (emit.goto_table_time != 0)
    System.err.println("          Reduce tab "
        + timestr(emit.goto_table_time, total_time));

      System.err.println("      Dump Output    "
    + timestr(dump_end-emit_end, total_time));
    }

  /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/

  /** Helper routine to format a decimal based display of seconds and
   *  percentage of total time given counts of milliseconds.   Note: this
   *  is broken for use with some instances of negative time (since we don't
   *  use any negative time here, we let if be for now).
   * @param time_val   the value being formatted (in ms).
   * @param total_time total time percentages are calculated against (in ms).
   */
  protected static String timestr(long time_val, long total_time)
    {
      boolean neg;
      long    ms = 0;
      long    sec = 0;
      long    percent10;
      String  pad;

      /* work with positives only */
      neg = time_val < 0;
      if (neg) time_val = -time_val;

      /* pull out seconds and ms */
      ms = time_val % 1000;
      sec = time_val / 1000;

      /* construct a pad to blank fill seconds out to 4 places */
      if (sec < 10)
    pad = "   ";
      else if (sec < 100)
    pad = "  ";
      else if (sec < 1000)
    pad = " ";
      else
    pad = "";

      /* calculate 10 times the percentage of total */
      percent10 = (time_val*1000)/total_time;

      /* build and return the output string */
      return (neg ? "-" : "") + pad + sec + "." +
         ((ms%1000)/100) + ((ms%100)/10) + (ms%10) + "sec" +
         " (" + percent10/10 + "." + percent10%10 + "%)";
    }

  /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/

  /** Produce a human readable dump of the grammar. */
  public static void dump_grammar() throws internal_error
    {
      int cnt;
      Enumeration t, n, p;
      production prod;

      System.err.println("===== Terminals =====");
      for (t = terminal.all(), cnt=0; t.hasMoreElements(); cnt++)
    {
      System.err.print(((terminal)t.nextElement()).name() + " ");
      if ((cnt+1) % 5 == 0) System.err.println();
    }
      System.err.println();
      System.err.println();

      System.err.println("===== Non terminals =====");
      for (n=non_terminal.all(), cnt=0; n.hasMoreElements(); cnt++)
    {
      System.err.print(((non_terminal)n.nextElement()).name() + " ");
      if ((cnt+1) % 5 == 0) System.err.println();
    }
      System.err.println();
      System.err.println();


      System.err.println("===== Productions =====");
      for (p=production.all(); p.hasMoreElements(); )
    {
      prod = (production)p.nextElement();
      System.err.print(prod.lhs().the_symbol().name() + " ::= ");
      for (int i=0; i<prod.rhs_length(); i++)
        if (prod.rhs(i).is_action())
          System.err.print("{action} ");
        else
          System.err.print(
             ((symbol_part)prod.rhs(i)).the_symbol().name() + " ");
      System.err.println();
    }
      System.err.println();
    }

  /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/

  /** Produce a (semi-) human readable dump of the complete viable prefix
   *  recognition state machine.
   */
  public static void dump_machine()
    {
      lalr_state ordered[] = new lalr_state[lalr_state.number()];

      /* put the states in sorted order for a nicer display */
      for (Enumeration s = lalr_state.all(); s.hasMoreElements(); )
    {
      lalr_state st = (lalr_state)s.nextElement();
      ordered[st.index()] = st;
    }

      System.err.println("===== Viable Prefix Recognizer =====");
      for (int i = 0; i<lalr_state.number(); i++)
    {
      if (ordered[i] == start_state) System.err.print("START ");
          System.err.println(ordered[i]);
      System.err.println("-------------------");
    }
    }

  /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/

  /** Produce a (semi-) human readable dumps of the parse tables */
  public static void dump_tables()
    {
      System.err.println(action_table);
      System.err.println(reduce_table);
    }

  /*-----------------------------------------------------------*/

};