| |
| package java_cup; |
| |
| import java.io.PrintStream; |
| import java.util.Date; |
| import java.util.Enumeration; |
| import java.util.Stack; |
| |
| /** |
| * This class handles emitting generated code for the resulting parser. |
| * The various parse tables must be constructed, etc. before calling any |
| * routines in this class.<p> |
| * |
| * Three classes are produced by this code: |
| * <dl> |
| * <dt> symbol constant class |
| * <dd> this contains constant declarations for each terminal (and |
| * optionally each non-terminal). |
| * <dt> action class |
| * <dd> this non-public class contains code to invoke all the user actions |
| * that were embedded in the parser specification. |
| * <dt> parser class |
| * <dd> the specialized parser class consisting primarily of some user |
| * supplied general and initialization code, and the parse tables. |
| * </dl><p> |
| * |
| * Three parse tables are created as part of the parser class: |
| * <dl> |
| * <dt> production table |
| * <dd> lists the LHS non terminal number, and the length of the RHS of |
| * each production. |
| * <dt> action table |
| * <dd> for each state of the parse machine, gives the action to be taken |
| * (shift, reduce, or error) under each lookahead symbol.<br> |
| * <dt> reduce-goto table |
| * <dd> when a reduce on a given production is taken, the parse stack is |
| * popped back a number of elements corresponding to the RHS of the |
| * production. This reveals a prior state, which we transition out |
| * of under the LHS non terminal symbol for the production (as if we |
| * had seen the LHS symbol rather than all the symbols matching the |
| * RHS). This table is indexed by non terminal numbers and indicates |
| * how to make these transitions. |
| * </dl><p> |
| * |
| * In addition to the method interface, this class maintains a series of |
| * public global variables and flags indicating how misc. parts of the code |
| * and other output is to be produced, and counting things such as number of |
| * conflicts detected (see the source code and public variables below for |
| * more details).<p> |
| * |
| * This class is "static" (contains only static data and methods).<p> |
| * |
| * @see java_cup.main |
| * @version last update: 11/25/95 |
| * @author Scott Hudson |
| */ |
| |
| /* Major externally callable routines here include: |
| symbols - emit the symbol constant class |
| parser - emit the parser class |
| |
| In addition the following major internal routines are provided: |
| emit_package - emit a package declaration |
| emit_action_code - emit the class containing the user's actions |
| emit_production_table - emit declaration and init for the production table |
| do_action_table - emit declaration and init for the action table |
| do_reduce_table - emit declaration and init for the reduce-goto table |
| |
| Finally, this class uses a number of public instance variables to communicate |
| optional parameters and flags used to control how code is generated, |
| as well as to report counts of various things (such as number of conflicts |
| detected). These include: |
| |
| prefix - a prefix string used to prefix names that would |
| otherwise "pollute" someone else's name space. |
| package_name - name of the package emitted code is placed in |
| (or null for an unnamed package. |
| symbol_const_class_name - name of the class containing symbol constants. |
| parser_class_name - name of the class for the resulting parser. |
| action_code - user supplied declarations and other code to be |
| placed in action class. |
| parser_code - user supplied declarations and other code to be |
| placed in parser class. |
| init_code - user supplied code to be executed as the parser |
| is being initialized. |
| scan_code - user supplied code to get the next token. |
| start_production - the start production for the grammar. |
| import_list - list of imports for use with action class. |
| num_conflicts - number of conflicts detected. |
| nowarn - true if we are not to issue warning messages. |
| not_reduced - count of number of productions that never reduce. |
| unused_term - count of unused terminal symbols. |
| unused_non_term - count of unused non terminal symbols. |
| *_time - a series of symbols indicating how long various |
| sub-parts of code generation took (used to produce |
| optional time reports in main). |
| */ |
| |
| public class emit { |
| |
| /*-----------------------------------------------------------*/ |
| /*--- Constructor(s) ----------------------------------------*/ |
| /*-----------------------------------------------------------*/ |
| |
| /** Only constructor is private so no instances can be created. */ |
| private emit() { } |
| |
| /*-----------------------------------------------------------*/ |
| /*--- Static (Class) Variables ------------------------------*/ |
| /*-----------------------------------------------------------*/ |
| |
| public static String input_file_name; |
| |
| /** The prefix placed on names that pollute someone else's name space. */ |
| public static String prefix = "CUP$"; |
| |
| /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/ |
| |
| /** Package that the resulting code goes into (null is used for unnamed). */ |
| public static String package_name = null; |
| |
| /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/ |
| |
| /** Name of the generated class for symbol constants. */ |
| public static String symbol_const_class_name = "sym"; |
| |
| |
| /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/ |
| |
| /** Name of the generated parser class. */ |
| public static String parser_class_name = "parser"; |
| |
| /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/ |
| |
| /** User declarations for direct inclusion in user action class. */ |
| public static String action_code = null; |
| |
| /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/ |
| |
| /** User declarations for direct inclusion in parser class. */ |
| public static String parser_code = null; |
| |
| /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/ |
| |
| /** User code for user_init() which is called during parser initialization. */ |
| public static String init_code = null; |
| |
| /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/ |
| |
| /** User code for scan() which is called to get the next token. */ |
| public static String scan_code = null; |
| |
| /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/ |
| |
| /** The start production of the grammar. */ |
| public static production start_production = null; |
| |
| /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/ |
| |
| /** List of imports (Strings containing class names) to go with actions. */ |
| public static Stack import_list = new Stack(); |
| |
| /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/ |
| |
| /** Number of conflict found while building tables. */ |
| public static int num_conflicts = 0; |
| |
| /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/ |
| |
| /** Do we skip warnings? */ |
| public static boolean nowarn = false; |
| |
| /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/ |
| |
| /** Count of the number on non-reduced productions found. */ |
| public static int not_reduced = 0; |
| |
| /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/ |
| |
| /** Count of unused terminals. */ |
| public static int unused_term = 0; |
| |
| /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/ |
| |
| /** Count of unused non terminals. */ |
| public static int unused_non_term = 0; |
| |
| /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/ |
| |
| /* Timing values used to produce timing report in main.*/ |
| |
| /** Time to produce symbol constant class. */ |
| public static long symbols_time = 0; |
| |
| /** Time to produce parser class. */ |
| public static long parser_time = 0; |
| |
| /** Time to produce action code class. */ |
| public static long action_code_time = 0; |
| |
| /** Time to produce the production table. */ |
| public static long production_table_time = 0; |
| |
| /** Time to produce the action table. */ |
| public static long action_table_time = 0; |
| |
| /** Time to produce the reduce-goto table. */ |
| public static long goto_table_time = 0; |
| |
| /** Do we produce calls debug_gammar in generated parser? */ |
| public static String debug_grammar = null; |
| |
| /*-----------------------------------------------------------*/ |
| /*--- General Methods ---------------------------------------*/ |
| /*-----------------------------------------------------------*/ |
| |
| /** Build a string with the standard prefix. |
| * @param str string to prefix. |
| */ |
| protected static String pre(String str) {return prefix + str;} |
| |
| /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/ |
| |
| /** Emit a package spec if the user wants one. |
| * @param out stream to produce output on. |
| */ |
| protected static void emit_package(PrintStream out) |
| { |
| /* generate a package spec if we have a name for one */ |
| if (package_name != null) |
| out.println("package " + package_name + ";\n"); |
| |
| } |
| |
| /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/ |
| |
| /** Emit code for the symbol constant class, optionally including non terms, |
| * if they have been requested. |
| * @param out stream to produce output on. |
| * @param emit_non_terms do we emit constants for non terminals? |
| */ |
| public static void symbols(PrintStream out, boolean emit_non_terms) |
| { |
| terminal term; |
| non_terminal nt; |
| |
| long start_time = System.currentTimeMillis(); |
| |
| /* top of file */ |
| out.println(); |
| out.println("//----------------------------------------------------"); |
| out.println("// The following code was generated by " + |
| version.title_str); |
| out.println("// " + new Date()); |
| out.println("//----------------------------------------------------"); |
| out.println(); |
| emit_package(out); |
| |
| /* class header */ |
| out.println( |
| "/** JavaCup generated class containing symbol constants. */"); |
| out.println("public class " + symbol_const_class_name + " {"); |
| |
| out.println(" /* terminals */"); |
| |
| /* walk over the terminals */ /* later might sort these */ |
| for (Enumeration e = terminal.all(); e.hasMoreElements(); ) |
| { |
| term = (terminal)e.nextElement(); |
| |
| /* output a constant decl for the terminal */ |
| out.println(" static final int " + term.name() + " = " + |
| term.index() + ";"); |
| } |
| |
| /* do the non terminals if they want them (parser doesn't need them) */ |
| if (emit_non_terms) |
| { |
| out.println("\n /* non terminals */"); |
| |
| /* walk over the non terminals */ /* later might sort these */ |
| for (Enumeration e = non_terminal.all(); e.hasMoreElements(); ) |
| { |
| nt = (non_terminal)e.nextElement(); |
| |
| /* output a constant decl for the terminal */ |
| out.println(" static final int " + nt.name() + " = " + |
| nt.index() + ";"); |
| } |
| } |
| |
| /* end of class */ |
| out.println("};\n"); |
| |
| symbols_time = System.currentTimeMillis() - start_time; |
| } |
| |
| /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/ |
| |
| /** Emit code for the non-public class holding the actual action code. |
| * @param out stream to produce output on. |
| * @param start_prod the start production of the grammar. |
| */ |
| protected static void emit_action_code(PrintStream out, production start_prod) |
| throws internal_error |
| { |
| production prod; |
| |
| long start_time = System.currentTimeMillis(); |
| |
| /* class header */ |
| out.println(); |
| out.println( |
| "/** JavaCup generated class to encapsulate user supplied action code.*/" |
| ); |
| out.println("class " + pre("actions") + " {"); |
| |
| /* user supplied code */ |
| if (action_code != null) |
| { |
| out.println(); |
| out.println(action_code); |
| } |
| |
| /* constructor */ |
| out.println(); |
| out.println(" /** Constructor */"); |
| out.println(" " + pre("actions") + "() { }"); |
| |
| /* action method head */ |
| out.println(); |
| out.println(" /** Method with the actual generated action code. */"); |
| out.println(" public final java_cup.runtime.symbol " + |
| pre("do_action") + "("); |
| out.println(" int " + pre("act_num,")); |
| out.println(" java_cup.runtime.lr_parser " + pre("parser,")); |
| out.println(" java.util.Stack " + pre("stack,")); |
| out.println(" int " + pre("top)")); |
| out.println(" throws java.lang.Exception"); |
| out.println(" {"); |
| |
| /* declaration of result symbol */ |
| out.println(" /* object for return from actions */"); |
| out.println(" java_cup.runtime.symbol " + pre("result") + ";"); |
| out.println(); |
| |
| /* switch top */ |
| out.println(" /* select the action based on the action number */"); |
| out.println(" switch (" + pre("act_num") + ")"); |
| out.println(" {"); |
| |
| /* emit action code for each production as a separate case */ |
| for (Enumeration p = production.all(); p.hasMoreElements(); ) |
| { |
| prod = (production)p.nextElement(); |
| |
| /* case label */ |
| out.println(" /*. . . . . . . . . . . . . . . . . . . .*/"); |
| out.println(" case " + prod.index() + ": // " + |
| prod.to_simple_string()); |
| |
| /* give them their own block to work in */ |
| out.println(" {"); |
| |
| /* user supplied code for debug_grammar() */ |
| if (debug_grammar != null) |
| out.println(" " +debug_grammar+ "(\"" + |
| prod.to_simple_string() + "\");"); |
| |
| /* create the result symbol */ |
| out.println(" " + pre("result") + " = new " + |
| prod.lhs().the_symbol().stack_type() + "(/*" + |
| prod.lhs().the_symbol().name() + "*/" + |
| prod.lhs().the_symbol().index() + ");"); |
| |
| /* if there is an action string, emit it */ |
| if (prod.action() != null && prod.action().code_string() != null && |
| !prod.action().equals("")) |
| out.println(" " + prod.action().code_string()); |
| |
| /* end of their block */ |
| out.println(" }"); |
| |
| /* if this was the start production, do action for accept */ |
| if (prod == start_prod) |
| { |
| out.println(" /* ACCEPT */"); |
| out.println(" " + pre("parser") + ".done_parsing();"); |
| } |
| |
| /* code to return lhs symbol */ |
| out.println(" return " + pre("result") + ";"); |
| out.println(); |
| } |
| |
| /* end of switch */ |
| out.println(" /* . . . . . .*/"); |
| out.println(" default:"); |
| out.println(" throw new Exception("); |
| out.println(" \"Invalid action number found in " + |
| "internal parse table\");"); |
| out.println(); |
| out.println(" }"); |
| |
| /* end of method */ |
| out.println(" }"); |
| |
| /* end of class */ |
| out.println("};\n"); |
| |
| action_code_time = System.currentTimeMillis() - start_time; |
| } |
| |
| /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/ |
| |
| /** Emit the production table. |
| * @param out stream to produce output on. |
| */ |
| protected static void emit_production_table(PrintStream out) |
| { |
| production all_prods[]; |
| production prod; |
| |
| long start_time = System.currentTimeMillis(); |
| |
| /* do the top of the table */ |
| out.println(); |
| out.println(" /** production table */"); |
| out.println(" protected static final short _production_table[][] = {"); |
| |
| /* collect up the productions in order */ |
| all_prods = new production[production.number()]; |
| for (Enumeration p = production.all(); p.hasMoreElements(); ) |
| { |
| prod = (production)p.nextElement(); |
| all_prods[prod.index()] = prod; |
| } |
| |
| /* do one entry per production */ |
| out.print(" "); |
| for (int i = 0; i<production.number(); i++) |
| { |
| prod = all_prods[i]; |
| |
| /* make the table entry */ |
| out.print(" {"); |
| out.print(/* lhs symbol # */ prod.lhs().the_symbol().index() + ", "); |
| out.print(/* rhs size */ prod.rhs_length() + "}"); |
| |
| /* put in a comma if we aren't at the end */ |
| if (i < production.number()-1) out.print(", "); |
| |
| /* 5 entries per line */ |
| if ((i+1) % 5 == 0) |
| { |
| out.println(); |
| out.print(" "); |
| } |
| } |
| |
| /* finish off the table initializer */ |
| out.println(" };"); |
| |
| /* do the public accessor method */ |
| out.println(); |
| out.println(" /** access to production table */"); |
| out.println(" public short[][] production_table() " + |
| "{return _production_table;}"); |
| |
| production_table_time = System.currentTimeMillis() - start_time; |
| } |
| |
| /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/ |
| |
| /** Emit the action table. |
| * @param out stream to produce output on. |
| * @param act_tab the internal representation of the action table. |
| * @param compact_reduces do we use the most frequent reduce as default? |
| */ |
| protected static void do_action_table( |
| PrintStream out, |
| parse_action_table act_tab, |
| boolean compact_reduces) |
| throws internal_error |
| { |
| parse_action_row row; |
| parse_action act; |
| int red; |
| |
| long start_time = System.currentTimeMillis(); |
| |
| out.println(); |
| out.println(" /** parse action table */"); |
| out.println(" protected static final short[][] _action_table = {"); |
| |
| /* do each state (row) of the action table */ |
| for (int i = 0; i < act_tab.num_states(); i++) |
| { |
| /* get the row */ |
| row = act_tab.under_state[i]; |
| |
| /* determine the default for the row */ |
| if (compact_reduces) |
| row.compute_default(); |
| else |
| row.default_reduce = -1; |
| |
| out.print(" /*" + i + "*/{"); |
| |
| /* do each column */ |
| for (int j = 0; j < row.size(); j++) |
| { |
| /* extract the action from the table */ |
| act = row.under_term[j]; |
| |
| /* skip error entries these are all defaulted out */ |
| if (act.kind() != parse_action.ERROR) |
| { |
| /* first put in the symbol index, then the actual entry */ |
| |
| /* shifts get positive entries of state number + 1 */ |
| if (act.kind() == parse_action.SHIFT) |
| { |
| out.print(j + "," + |
| (((shift_action)act).shift_to().index() + 1) + ","); |
| } |
| |
| /* reduce actions get negated entries of production# + 1 */ |
| else if (act.kind() == parse_action.REDUCE) |
| { |
| /* if its the default entry let it get defaulted out */ |
| red = ((reduce_action)act).reduce_with().index(); |
| if (red != row.default_reduce) |
| out.print(j + "," + (-(red+1)) + ","); |
| } |
| |
| /* shouldn't be anything else */ |
| else |
| throw new internal_error("Unrecognized action code " + |
| act.kind() + " found in parse table"); |
| } |
| } |
| |
| /* finish off the row with a default entry */ |
| if (row.default_reduce != -1) |
| out.println("-1," + (-(row.default_reduce+1)) + "},"); |
| else |
| out.println("-1,0},"); |
| } |
| |
| /* finish off the init of the table */ |
| out.println(" };"); |
| |
| /* do the public accessor method */ |
| out.println(); |
| out.println(" /** access to parse action table */"); |
| out.println(" public short[][] action_table() {return _action_table;}"); |
| |
| action_table_time = System.currentTimeMillis() - start_time; |
| } |
| |
| /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/ |
| |
| /** Emit the reduce-goto table. |
| * @param out stream to produce output on. |
| * @param red_tab the internal representation of the reduce-goto table. |
| */ |
| protected static void do_reduce_table( |
| PrintStream out, |
| parse_reduce_table red_tab) |
| { |
| lalr_state goto_st; |
| parse_action act; |
| |
| long start_time = System.currentTimeMillis(); |
| |
| out.println(); |
| out.println(" /** reduce_goto table */"); |
| out.println(" protected static final short[][] _reduce_table = {"); |
| |
| /* do each row of the reduce-goto table */ |
| for (int i=0; i<red_tab.num_states(); i++) |
| { |
| out.print(" /*" + i + "*/{"); |
| |
| /* do each entry in the row */ |
| for (int j=0; j<red_tab.under_state[i].size(); j++) |
| { |
| /* get the entry */ |
| goto_st = red_tab.under_state[i].under_non_term[j]; |
| |
| /* if we have none, skip it */ |
| if (goto_st != null) |
| { |
| /* make entries for the index and the value */ |
| out.print(j + "," + goto_st.index() + ","); |
| } |
| } |
| |
| /* end row with default value */ |
| out.println("-1,-1},"); |
| } |
| |
| /* finish off the init of the table */ |
| out.println(" };"); |
| |
| /* do the public accessor method */ |
| out.println(); |
| out.println(" /** access to reduce_goto table */"); |
| out.println(" public short[][] reduce_table() {return _reduce_table;}"); |
| out.println(); |
| |
| goto_table_time = System.currentTimeMillis() - start_time; |
| } |
| |
| /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/ |
| |
| /** Emit the parser subclass with embedded tables. |
| * @param out stream to produce output on. |
| * @param action_table internal representation of the action table. |
| * @param reduce_table internal representation of the reduce-goto table. |
| * @param start_st start state of the parse machine. |
| * @param start_prod start production of the grammar. |
| * @param compact_reduces do we use most frequent reduce as default? |
| */ |
| public static void parser( |
| PrintStream out, |
| parse_action_table action_table, |
| parse_reduce_table reduce_table, |
| int start_st, |
| production start_prod, |
| boolean compact_reduces) |
| throws internal_error |
| { |
| long start_time = System.currentTimeMillis(); |
| |
| /* top of file */ |
| out.println(); |
| out.println("//----------------------------------------------------"); |
| out.println("// The following code was generated by " + |
| version.title_str); |
| out.println("// " + new Date()); |
| out.println("//----------------------------------------------------"); |
| out.println(); |
| emit_package(out); |
| |
| /* user supplied imports */ |
| for (int i = 0; i < import_list.size(); i++) |
| out.println("import " + import_list.elementAt(i) + ";"); |
| |
| /* class header */ |
| out.println(); |
| out.println("public class " + parser_class_name + |
| " extends java_cup.runtime.lr_parser {"); |
| |
| /* constructor */ |
| out.println(); |
| out.println(" /** constructor */"); |
| out.println(" public " + parser_class_name + "() {super();}"); |
| |
| /* emit the various tables */ |
| emit_production_table(out); |
| do_action_table(out, action_table, compact_reduces); |
| do_reduce_table(out, reduce_table); |
| |
| /* instance of the action encapsulation class */ |
| out.println(" /** instance of action encapsulation class */"); |
| out.println(" protected " + pre("actions") + " action_obj;"); |
| out.println(); |
| |
| /* action object initializer */ |
| out.println(" /** action encapsulation object initializer */"); |
| out.println(" protected void init_actions()"); |
| out.println(" {"); |
| out.println(" action_obj = new " + pre("actions") + "();"); |
| out.println(" }"); |
| out.println(); |
| |
| /* access to action code */ |
| out.println(" /** invoke a user supplied parse action */"); |
| out.println(" public java_cup.runtime.symbol do_action("); |
| out.println(" int act_num,"); |
| out.println(" java_cup.runtime.lr_parser parser,"); |
| out.println(" java.util.Stack stack,"); |
| out.println(" int top)"); |
| out.println(" throws java.lang.Exception"); |
| out.println(" {"); |
| out.println(" /* call code in generated class */"); |
| out.println(" return action_obj." + pre("do_action(") + |
| "act_num, parser, stack, top);"); |
| out.println(" }"); |
| out.println(""); |
| |
| |
| /* method to tell the parser about the start state */ |
| out.println(" /** start state */"); |
| out.println(" public int start_state() {return " + start_st + ";}"); |
| |
| /* method to indicate start production */ |
| out.println(" /** start production */"); |
| out.println(" public int start_production() {return " + |
| start_production.index() + ";}"); |
| out.println(); |
| |
| /* methods to indicate EOF and error symbol indexes */ |
| out.println(" /** EOF symbol index */"); |
| out.println(" public int EOF_sym() {return " + terminal.EOF.index() + |
| ";}"); |
| out.println(); |
| out.println(" /** error symbol index */"); |
| out.println(" public int error_sym() {return " + terminal.error.index() + |
| ";}"); |
| out.println(); |
| |
| /* user supplied code for user_init() */ |
| if (init_code != null) |
| { |
| out.println(); |
| out.println(" /** user initialization */"); |
| out.println(" public void user_init() throws java.lang.Exception"); |
| out.println(" {"); |
| out.println(init_code); |
| out.println(" }"); |
| } |
| |
| /* user supplied code for scan */ |
| if (scan_code != null) |
| { |
| out.println(); |
| out.println(" /** scan to get the next token */"); |
| out.println(" public java_cup.runtime.token scan()"); |
| out.println(" throws java.lang.Exception"); |
| out.println(" {"); |
| out.println(scan_code); |
| out.println(" }"); |
| } |
| |
| /* user supplied code */ |
| if (parser_code != null) |
| { |
| out.println(); |
| out.println(parser_code); |
| } |
| |
| /* end of class */ |
| out.println("};"); |
| |
| /* put out the action code class */ |
| emit_action_code(out, start_prod); |
| |
| parser_time = System.currentTimeMillis() - start_time; |
| } |
| |
| /*-----------------------------------------------------------*/ |
| }; |
