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: * * * Options to the main program include:
*
-package name *
specify package generated classes go in [default none] *
-parser name *
specify parser class name [default "parser"] *
-symbols name *
specify name for symbol constant class [default "sym"] *
-nonterms *
put non terminals in symbol constant class *
-expect # *
number of conflicts expected/allowed [default 0] *
-compact_red *
compact tables by defaulting to most frequent reduce *
-nowarn *
don't warn about useless productions, etc. *
-nosummary *
don't print the usual summary of parse states, etc. *
-progress *
print messages to indicate progress of the system *
-time *
print time usage summary *
-dump_grammar *
produce a dump of the symbols and grammar *
-dump_states *
produce a dump of parse state machine *
-dump_tables *
produce a dump of the parse tables *
-dump *
produce a dump of all of the above *
-debug *
turn on debugging messages within JavaCup *
* * @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 || 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: */ 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