|
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);
|
}
|
|
/*-----------------------------------------------------------*/
|
|
};
|
