+++ /dev/null
-package java_cup;
-
-import java.io.PrintWriter;
-import java.util.Stack;
-import java.util.Enumeration;
-import java.util.Date;
-
-/**
- * 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 Symbol.
- 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 ------------------------------*/
- /*-----------------------------------------------------------*/
-
- /** 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 Symbol. */
- 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;
-
- /* frankf 6/18/96 */
- protected static boolean _lr_values;
-
- /** whether or not to emit code for left and right values */
- public static boolean lr_values() {return _lr_values;}
- protected static void set_lr_values(boolean b) { _lr_values = b;}
-
- /*-----------------------------------------------------------*/
- /*--- General Methods ---------------------------------------*/
- /*-----------------------------------------------------------*/
-
- /** Build a string with the standard prefix.
- * @param str string to prefix.
- */
- protected static String pre(String str) {
- return prefix + parser_class_name + "$" + str;
- }
-
- /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
-
- /** Emit a package spec if the user wants one.
- * @param out stream to produce output on.
- */
- protected static void emit_package(PrintWriter out)
- {
- /* generate a package spec if we have a name for one */
- if (package_name != null) {
- out.println("package " + package_name + ";"); out.println();
- }
- }
-
- /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
-
- /** 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?
- * @param sym_interface should we emit an interface, rather than a class?
- */
- public static void symbols(PrintWriter out,
- boolean emit_non_terms, boolean sym_interface)
- {
- terminal term;
- non_terminal nt;
- String class_or_interface = (sym_interface)?"interface":"class";
-
- 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("/** CUP generated " + class_or_interface +
- " containing symbol constants. */");
- out.println("public " + class_or_interface + " " +
- 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(" public 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();
- out.println(" /* 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("}");
- out.println();
-
- 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(PrintWriter out, production start_prod)
- throws internal_error
- {
- production prod;
-
- long start_time = System.currentTimeMillis();
-
- /* class header */
- out.println();
- out.println(
- "/** Cup 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);
- }
-
- /* field for parser object */
- out.println(" private final "+parser_class_name+" parser;");
-
- /* constructor */
- out.println();
- out.println(" /** Constructor */");
- out.println(" " + pre("actions") + "("+parser_class_name+" parser) {");
- out.println(" this.parser = parser;");
- out.println(" }");
-
- /* 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 */
- /* New declaration!! now return Symbol
- 6/13/96 frankf */
- out.println(" /* Symbol 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(" {");
-
- /* create the result symbol */
- /*make the variable RESULT which will point to the new Symbol (see below)
- and be changed by action code
- 6/13/96 frankf */
- out.println(" " + prod.lhs().the_symbol().stack_type() +
- " RESULT = null;");
-
- /* Add code to propagate RESULT assignments that occur in
- * action code embedded in a production (ie, non-rightmost
- * action code). 24-Mar-1998 CSA
- */
- for (int i=0; i<prod.rhs_length(); i++) {
- // only interested in non-terminal symbols.
- if (!(prod.rhs(i) instanceof symbol_part)) continue;
- symbol s = ((symbol_part)prod.rhs(i)).the_symbol();
- if (!(s instanceof non_terminal)) continue;
- // skip this non-terminal unless it corresponds to
- // an embedded action production.
- if (((non_terminal)s).is_embedded_action == false) continue;
- // OK, it fits. Make a conditional assignment to RESULT.
- int index = prod.rhs_length() - i - 1; // last rhs is on top.
- out.println(" " + "// propagate RESULT from " +
- s.name());
- out.println(" " + "if ( " +
- "((java_cup.runtime.Symbol) " + emit.pre("stack") + ".elementAt("
- + emit.pre("top") + "-" + index + ")).value != null )");
- out.println(" " + "RESULT = " +
- "(" + prod.lhs().the_symbol().stack_type() + ") " +
- "((java_cup.runtime.Symbol) " + emit.pre("stack") + ".elementAt("
- + emit.pre("top") + "-" + index + ")).value;");
- }
-
- /* 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());
-
- /* here we have the left and right values being propagated.
- must make this a command line option.
- frankf 6/18/96 */
-
- /* Create the code that assigns the left and right values of
- the new Symbol that the production is reducing to */
- if (emit.lr_values()) {
- int loffset;
- String leftstring, rightstring;
- int roffset = 0;
- rightstring = "((java_cup.runtime.Symbol)" + emit.pre("stack") + ".elementAt(" +
- emit.pre("top") + "-" + roffset + ")).right";
- if (prod.rhs_length() == 0)
- leftstring = rightstring;
- else {
- loffset = prod.rhs_length() - 1;
- leftstring = "((java_cup.runtime.Symbol)" + emit.pre("stack") + ".elementAt(" +
- emit.pre("top") + "-" + loffset + ")).left";
- }
- out.println(" " + pre("result") + " = new java_cup.runtime.Symbol(" +
- prod.lhs().the_symbol().index() + "/*" +
- prod.lhs().the_symbol().name() + "*/" +
- ", " + leftstring + ", " + rightstring + ", RESULT);");
- } else {
- out.println(" " + pre("result") + " = new java_cup.runtime.Symbol(" +
- prod.lhs().the_symbol().index() + "/*" +
- prod.lhs().the_symbol().name() + "*/" +
- ", RESULT);");
- }
-
- /* 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("}");
- out.println();
-
- action_code_time = System.currentTimeMillis() - start_time;
- }
-
- /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
-
- /** Emit the production table.
- * @param out stream to produce output on.
- */
- protected static void emit_production_table(PrintWriter out)
- {
- production all_prods[];
- production prod;
-
- long start_time = System.currentTimeMillis();
-
- /* 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;
- }
-
- // make short[][]
- short[][] prod_table = new short[production.number()][2];
- for (int i = 0; i<production.number(); i++)
- {
- prod = all_prods[i];
- // { lhs symbol , rhs size }
- prod_table[i][0] = (short) prod.lhs().the_symbol().index();
- prod_table[i][1] = (short) prod.rhs_length();
- }
- /* do the top of the table */
- out.println();
- out.println(" /** Production table. */");
- out.println(" protected static final short _production_table[][] = ");
- out.print (" unpackFromStrings(");
- do_table_as_string(out, prod_table);
- 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(
- PrintWriter 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();
-
- /* collect values for the action table */
- short[][] action_table = new short[act_tab.num_states()][];
- /* 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;
-
- /* make temporary table for the row. */
- short[] temp_table = new short[2*row.size()];
- int nentries = 0;
-
- /* 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)
- {
- /* make entry */
- temp_table[nentries++] = (short) j;
- temp_table[nentries++] = (short)
- (((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) {
- /* make entry */
- temp_table[nentries++] = (short) j;
- temp_table[nentries++] = (short) (-(red+1));
- }
- } else if (act.kind() == parse_action.NONASSOC)
- {
- /* do nothing, since we just want a syntax error */
- }
- /* shouldn't be anything else */
- else
- throw new internal_error("Unrecognized action code " +
- act.kind() + " found in parse table");
- }
- }
-
- /* now we know how big to make the row */
- action_table[i] = new short[nentries + 2];
- System.arraycopy(temp_table, 0, action_table[i], 0, nentries);
-
- /* finish off the row with a default entry */
- action_table[i][nentries++] = -1;
- if (row.default_reduce != -1)
- action_table[i][nentries++] = (short) (-(row.default_reduce+1));
- else
- action_table[i][nentries++] = 0;
- }
-
- /* finish off the init of the table */
- out.println();
- out.println(" /** Parse-action table. */");
- out.println(" protected static final short[][] _action_table = ");
- out.print (" unpackFromStrings(");
- do_table_as_string(out, action_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(
- PrintWriter out,
- parse_reduce_table red_tab)
- {
- lalr_state goto_st;
- parse_action act;
-
- long start_time = System.currentTimeMillis();
-
- /* collect values for reduce-goto table */
- short[][] reduce_goto_table = new short[red_tab.num_states()][];
- /* do each row of the reduce-goto table */
- for (int i=0; i<red_tab.num_states(); i++)
- {
- /* make temporary table for the row. */
- short[] temp_table = new short[2*red_tab.under_state[i].size()];
- int nentries = 0;
- /* 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 */
- temp_table[nentries++] = (short) j;
- temp_table[nentries++] = (short) goto_st.index();
- }
- }
- /* now we know how big to make the row. */
- reduce_goto_table[i] = new short[nentries+2];
- System.arraycopy(temp_table, 0, reduce_goto_table[i], 0, nentries);
-
- /* end row with default value */
- reduce_goto_table[i][nentries++] = -1;
- reduce_goto_table[i][nentries++] = -1;
- }
-
- /* emit the table. */
- out.println();
- out.println(" /** <code>reduce_goto</code> table. */");
- out.println(" protected static final short[][] _reduce_table = ");
- out.print (" unpackFromStrings(");
- do_table_as_string(out, reduce_goto_table);
- out.println(");");
-
- /* do the public accessor method */
- out.println();
- out.println(" /** Access to <code>reduce_goto</code> table. */");
- out.println(" public short[][] reduce_table() {return _reduce_table;}");
- out.println();
-
- goto_table_time = System.currentTimeMillis() - start_time;
- }
-
- // print a string array encoding the given short[][] array.
- protected static void do_table_as_string(PrintWriter out, short[][] sa) {
- out.println("new String[] {");
- out.print(" \"");
- int nchar=0, nbytes=0;
- nbytes+=do_escaped(out, (char)(sa.length>>16));
- nchar =do_newline(out, nchar, nbytes);
- nbytes+=do_escaped(out, (char)(sa.length&0xFFFF));
- nchar =do_newline(out, nchar, nbytes);
- for (int i=0; i<sa.length; i++) {
- nbytes+=do_escaped(out, (char)(sa[i].length>>16));
- nchar =do_newline(out, nchar, nbytes);
- nbytes+=do_escaped(out, (char)(sa[i].length&0xFFFF));
- nchar =do_newline(out, nchar, nbytes);
- for (int j=0; j<sa[i].length; j++) {
- // contents of string are (value+2) to allow for common -1, 0 cases
- // (UTF-8 encoding is most efficient for 0<c<0x80)
- nbytes+=do_escaped(out, (char)(2+sa[i][j]));
- nchar =do_newline(out, nchar, nbytes);
- }
- }
- out.print("\" }");
- }
- // split string if it is very long; start new line occasionally for neatness
- protected static int do_newline(PrintWriter out, int nchar, int nbytes) {
- if (nbytes > 65500) { out.println("\", "); out.print(" \""); }
- else if (nchar > 11) { out.println("\" +"); out.print(" \""); }
- else return nchar+1;
- return 0;
- }
- // output an escape sequence for the given character code.
- protected static int do_escaped(PrintWriter out, char c) {
- StringBuffer escape = new StringBuffer();
- if (c <= 0xFF) {
- escape.append(Integer.toOctalString(c));
- while(escape.length() < 3) escape.insert(0, '0');
- } else {
- escape.append(Integer.toHexString(c));
- while(escape.length() < 4) escape.insert(0, '0');
- escape.insert(0, 'u');
- }
- escape.insert(0, '\\');
- out.print(escape.toString());
-
- // return number of bytes this takes up in UTF-8 encoding.
- if (c == 0) return 2;
- if (c >= 0x01 && c <= 0x7F) return 1;
- if (c >= 0x80 && c <= 0x7FF) return 2;
- return 3;
- }
-
- /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
-
- /** 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?
- * @param suppress_scanner should scanner be suppressed for compatibility?
- */
- public static void parser(
- PrintWriter out,
- parse_action_table action_table,
- parse_reduce_table reduce_table,
- int start_st,
- production start_prod,
- boolean compact_reduces,
- boolean suppress_scanner)
- 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("/** "+version.title_str+" generated parser.");
- out.println(" * @version " + new Date());
- out.println(" */");
- out.println("public class " + parser_class_name +
- " extends java_cup.runtime.lr_parser {");
-
- /* constructors [CSA/davidm, 24-jul-99] */
- out.println();
- out.println(" /** Default constructor. */");
- out.println(" public " + parser_class_name + "() {super();}");
- if (!suppress_scanner) {
- out.println();
- out.println(" /** Constructor which sets the default scanner. */");
- out.println(" public " + parser_class_name +
- "(java_cup.runtime.Scanner s) {super(s);}");
- }
-
- /* 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") + "(this);");
- 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(" /** Indicates start state. */");
- out.println(" public int start_state() {return " + start_st + ";}");
-
- /* method to indicate start production */
- out.println(" /** Indicates start production. */");
- out.println(" public int start_production() {return " +
- start_production.index() + ";}");
- out.println();
-
- /* methods to indicate EOF and error symbol indexes */
- out.println(" /** <code>EOF</code> Symbol index. */");
- out.println(" public int EOF_sym() {return " + terminal.EOF.index() +
- ";}");
- out.println();
- out.println(" /** <code>error</code> 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 code. */");
- 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 Symbol. */");
- out.println(" public java_cup.runtime.Symbol 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;
- }
-
- /*-----------------------------------------------------------*/
-}
projects / IRC.git / blobdiff