|
| |
|
| java.lang.Object
 java_cup.Main
| Main | | public class Main (Code) | | 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:
- Parse user supplied arguments and options.
- Open output files.
- Parse the specification from standard input.
- Check for unused terminals, non-terminals, and productions.
- Build the state machine, tables, etc.
- Output the generated code.
- Close output files.
- Print a summary if requested.
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"]
- -interface
- emit symbol constant interface, rather than class
- -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
- -nopositions
- don't generate the positions code
- -noscanner
- don't refer to java_cup.runtime.Scanner in the parser
(for compatibility with old runtimes)
- -version
- print version information for JavaCUP and halt.
version:
last updated: 7/3/96
author:
Frank Flannery |
| Method Summary | |
| protected static void | build_parser()
Build the (internal) parser from the previously parsed specification. | | protected static void | check_unused()
Check for unused symbols. | | protected static void | close_files()
Close various files used by the system. | | public static void | dump_grammar()
Produce a human readable dump of the grammar. | | public static void | dump_machine()
Produce a (semi-) human readable dump of the complete viable prefix
recognition state machine. | | public static void | dump_tables()
| | protected static void | emit_parser()
Call the emit routines necessary to write out the generated parser. | | protected static void | emit_summary(boolean output_produced)
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. | | public static void | main(String argv)
The main driver for the system. | | protected static void | open_files()
Open various files used by the system. | | protected static void | parse_args(String argv)
Parse command line options and arguments to set various user-option
flags and variables. | | protected static void | parse_grammar_spec()
Parse the grammar specification from standard input. | | protected static String | plural(int val)
Helper routine to optionally return a plural or non-plural ending. | | protected static void | show_times()
Produce the optional timing summary as part of an overall summary. | | protected static String | timestr(long time_val, long total_time)
Helper routine to format a decimal based display of seconds and
percentage of total time given counts of milliseconds. | | protected static void | usage(String message)
Print a "usage message" that described possible command line options,
then exit. |
| build_end | | protected static long build_end(Code) | | Timing data -- when did we end state and table building
|
| check_end | | protected static long check_end(Code) | | Timing data -- when did we end checking
|
| dest_dir | | protected static File dest_dir(Code) | | Output directory.
|
| dump_end | | protected static long dump_end(Code) | | Timing data -- when did we end dumping
|
| emit_end | | protected static long emit_end(Code) | | Timing data -- when did we finish emitting code
|
| expect_conflicts | | protected static int expect_conflicts(Code) | | User option -- number of conflicts to expect
|
| final_time | | protected static long final_time(Code) | | Timing data -- when were we completely done
|
| first_end | | protected static long first_end(Code) | | Timing data -- when did we end first set calculation
|
| include_non_terms | | protected static boolean include_non_terms(Code) | | User option -- should we include non terminal symbol numbers in the
symbol constant class.
|
| lr_values | | protected static boolean lr_values(Code) | | User option -- should generator generate code for left/right values?
|
| machine_end | | protected static long machine_end(Code) | | Timing data -- when did we end state machine construction
|
| no_summary | | protected static boolean no_summary(Code) | | User option -- do not print a summary.
|
| nullability_end | | protected static long nullability_end(Code) | | Timing data -- when did we end nullability calculation
|
| opt_compact_red | | protected static boolean opt_compact_red(Code) | | User option -- do we compact tables by making most common reduce the
default action
|
| opt_do_debug | | protected static boolean opt_do_debug(Code) | | User option -- do we run produce extra debugging messages
|
| opt_dump_grammar | | protected static boolean opt_dump_grammar(Code) | | User option -- do we produce a dump of the grammar
|
| opt_dump_states | | protected static boolean opt_dump_states(Code) | | User option -- do we produce a dump of the state machine
|
| opt_dump_tables | | protected static boolean opt_dump_tables(Code) | | User option -- do we produce a dump of the parse tables
|
| opt_show_timing | | protected static boolean opt_show_timing(Code) | | User option -- do we show timing information as a part of the summary
|
| parse_end | | protected static long parse_end(Code) | | Timing data -- when did we end parsing
|
| parser_class_file | | protected static PrintWriter parser_class_file(Code) | | Output file for the parser class.
|
| prelim_end | | protected static long prelim_end(Code) | | Timing data -- when did we end preliminaries
|
| print_progress | | protected static boolean print_progress(Code) | | User option -- do we print progress messages.
|
| reduce_check_end | | protected static long reduce_check_end(Code) | | Timing data -- when did we end checking for non-reduced productions
|
| start_state | | protected static lalr_state start_state(Code) | | Start state in the overall state machine.
|
| start_time | | protected static long start_time(Code) | | Timing data -- when did we start
|
| suppress_scanner | | protected static boolean suppress_scanner(Code) | | User option -- should generator suppress references to
java_cup.runtime.Scanner for compatibility with old runtimes?
|
| sym_interface | | protected static boolean sym_interface(Code) | | User option -- should symbols be put in a class or an interface? [CSA]
|
| symbol_class_file | | protected static PrintWriter symbol_class_file(Code) | | Output file for the symbol constant class.
|
| table_end | | protected static long table_end(Code) | | Timing data -- when did we end table construction
|
| build_parser | | protected static void build_parser() throws internal_error(Code) | | Build the (internal) parser from the previously parsed specification.
This includes:
- Computing nullability of non-terminals.
- Computing first sets of non-terminals and productions.
- Building the viable prefix recognizer machine.
- Filling in the (internal) parse tables.
- Checking for unreduced productions.
|
| check_unused | | protected static void check_unused()(Code) | | Check for unused symbols. Unreduced productions get checked when
tables are created.
|
| dump_grammar | | public static void dump_grammar() throws internal_error(Code) | | Produce a human readable dump of the grammar.
|
| dump_machine | | public static void dump_machine()(Code) | | Produce a (semi-) human readable dump of the complete viable prefix
recognition state machine.
|
| dump_tables | | public static void dump_tables()(Code) | | Produce a (semi-) human readable dumps of the parse tables
|
| emit_parser | | protected static void emit_parser() throws internal_error(Code) | | Call the emit routines necessary to write out the generated parser.
|
| emit_summary | | protected static void emit_summary(boolean output_produced)(Code) | | 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.
Parameters:
output_produced - did the system get far enough to generate code. |
| open_files | | protected static void open_files()(Code) | | Open various files used by the system.
|
| parse_args | | protected static void parse_args(String argv)(Code) | | Parse command line options and arguments to set various user-option
flags and variables.
Parameters:
argv - the command line arguments to be parsed. |
| parse_grammar_spec | | protected static void parse_grammar_spec() throws java.lang.Exception(Code) | | 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.
|
| plural | | protected static String plural(int val)(Code) | | Helper routine to optionally return a plural or non-plural ending.
Parameters:
val - the numerical value determining plurality. |
| show_times | | protected static void show_times()(Code) | | Produce the optional timing summary as part of an overall summary.
|
| timestr | | protected static String timestr(long time_val, long total_time)(Code) | | 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).
Parameters:
time_val - the value being formatted (in ms).
Parameters:
total_time - total time percentages are calculated against (in ms). |
| usage | | protected static void usage(String message)(Code) | | Print a "usage message" that described possible command line options,
then exit.
Parameters:
message - a specific error message to preface the usage message by. |
|
|
|