Ptidej-v5.2-master/PADL Creator AOL/src/padl/creator/aolfile/javacup/runtime/lr_parser.java
package padl.creator.aolfile.javacup.runtime;

import java.util.Stack;

/** This class implements a skeleton table driven LR parser.  In general,
 *  LR parsers are a form of bottom up shift-reduce parsers.  Shift-reduce
 *  parsers act by shifting input onto a parse stack until the Symbols 
 *  matching the right hand side of a production appear on the top of the 
 *  stack.  Once this occurs, a reduce is performed.  This involves removing
 *  the Symbols corresponding to the right hand side of the production
 *  (the so called "handle") and replacing them with the non-terminal from
 *  the left hand side of the production.  <p>
 *
 *  To control the decision of whether to shift or reduce at any given point, 
 *  the parser uses a state machine (the "viable prefix recognition machine" 
 *  built by the parser generator).  The current state of the machine is placed
 *  on top of the parse stack (stored as part of a Symbol object representing
 *  a terminal or non terminal).  The parse action table is consulted 
 *  (using the current state and the current lookahead Symbol as indexes) to 
 *  determine whether to shift or to reduce.  When the parser shifts, it 
 *  changes to a new state by pushing a new Symbol (containing a new state) 
 *  onto the stack.  When the parser reduces, it pops the handle (right hand 
 *  side of a production) off the stack.  This leaves the parser in the state 
 *  it was in before any of those Symbols were matched.  Next the reduce-goto 
 *  table is consulted (using the new state and current lookahead Symbol as 
 *  indexes) to determine a new state to go to.  The parser then shifts to 
 *  this goto state by pushing the left hand side Symbol of the production 
 *  (also containing the new state) onto the stack.<p>
 *
 *  This class actually provides four LR parsers.  The methods parse() and 
 *  debug_parse() provide two versions of the main parser (the only difference 
 *  being that debug_parse() emits debugging trace messages as it parses).  
 *  In addition to these main parsers, the error recovery mechanism uses two 
 *  more.  One of these is used to simulate "parsing ahead" in the input 
 *  without carrying out actions (to verify that a potential error recovery 
 *  has worked), and the other is used to parse through buffered "parse ahead" 
 *  input in order to execute all actions and re-synchronize the actual parser 
 *  configuration.<p>
 *
 *  This is an abstract class which is normally filled out by a subclass
 *  generated by the JavaCup parser generator.  In addition to supplying
 *  the actual parse tables, generated code also supplies methods which 
 *  invoke various pieces of user supplied code, provide access to certain
 *  special Symbols (e.g., EOF and error), etc.  Specifically, the following
 *  abstract methods are normally supplied by generated code:
 *  <dl compact>
 *  <dt> short[][] production_table()
 *  <dd> Provides a reference to the production table (indicating the index of
 *       the left hand side non terminal and the length of the right hand side
 *       for each production in the grammar).
 *  <dt> short[][] action_table()
 *  <dd> Provides a reference to the parse action table.
 *  <dt> short[][] reduce_table()
 *  <dd> Provides a reference to the reduce-goto table.
 *  <dt> int start_state()      
 *  <dd> Indicates the index of the start state.
 *  <dt> int start_production() 
 *  <dd> Indicates the index of the starting production.
 *  <dt> int EOF_sym() 
 *  <dd> Indicates the index of the EOF Symbol.
 *  <dt> int error_sym() 
 *  <dd> Indicates the index of the error Symbol.
 *  <dt> Symbol do_action() 
 *  <dd> Executes a piece of user supplied action code.  This always comes at 
 *       the point of a reduce in the parse, so this code also allocates and 
 *       fills in the left hand side non terminal Symbol object that is to be 
 *       pushed onto the stack for the reduce.
 *  <dt> void init_actions()
 *  <dd> Code to initialize a special object that encapsulates user supplied
 *       actions (this object is used by do_action() to actually carry out the 
 *       actions).
 *  </dl>
 *  
 *  In addition to these routines that <i>must</i> be supplied by the 
 *  generated subclass there are also a series of routines that <i>may</i> 
 *  be supplied.  These include:
 *  <dl>
 *  <dt> Symbol scan()
 *  <dd> Used to get the next input Symbol from the scanner.
 *  <dt> Scanner getScanner()
 *  <dd> Used to provide a scanner for the default implementation of
 *       scan().
 *  <dt> int error_sync_size()
 *  <dd> This determines how many Symbols past the point of an error 
 *       must be parsed without error in order to consider a recovery to 
 *       be valid.  This defaults to 3.  Values less than 2 are not 
 *       recommended.
 *  <dt> void report_error(String message, Object info)
 *  <dd> This method is called to report an error.  The default implementation
 *       simply prints a message to System.err and where the error occurred.
 *       This method is often replaced in order to provide a more sophisticated
 *       error reporting mechanism.
 *  <dt> void report_fatal_error(String message, Object info)
 *  <dd> This method is called when a fatal error that cannot be recovered from
 *       is encountered.  In the default implementation, it calls 
 *       report_error() to emit a message, then throws an exception.
 *  <dt> void syntax_error(Symbol cur_token)
 *  <dd> This method is called as soon as syntax error is detected (but
 *       before recovery is attempted).  In the default implementation it 
 *       invokes: report_error("Syntax error", null);
 *  <dt> void unrecovered_syntax_error(Symbol cur_token)
 *  <dd> This method is called if syntax error recovery fails.  In the default
 *       implementation it invokes:<br> 
 *         report_fatal_error("Couldn't repair and continue parse", null);
 *  </dl>
 *
 * @see     java_cup.runtime.Symbol
 * @see     java_cup.runtime.Symbol
 * @see     java_cup.runtime.virtual_parse_stack
 * @version last updated: 7/3/96
 * @author  Frank Flannery
 */

public abstract class lr_parser {

	/*-----------------------------------------------------------*/
	/*--- Constructor(s) ----------------------------------------*/
	/*-----------------------------------------------------------*/

	/** The default number of Symbols after an error we much match to consider 
	 *  it recovered from. 
	 */
	protected final static int _error_sync_size = 3;

	/** Utility function: unpacks parse tables from strings */
	protected static short[][] unpackFromStrings(final String[] sa) {
		// Concatanate initialization strings.
		final StringBuffer sb = new StringBuffer(sa[0]);
		for (int i = 1; i < sa.length; i++) {
			sb.append(sa[i]);
		}
		int n = 0; // location in initialization string
		final int size1 = sb.charAt(n) << 16 | sb.charAt(n + 1);
		n += 2;
		final short[][] result = new short[size1][];
		for (int i = 0; i < size1; i++) {
			final int size2 = sb.charAt(n) << 16 | sb.charAt(n + 1);
			n += 2;
			result[i] = new short[size2];
			for (int j = 0; j < size2; j++) {
				result[i][j] = (short) (sb.charAt(n++) - 2);
			}
		}
		return result;
	}

	/*-----------------------------------------------------------*/
	/*--- (Access to) Static (Class) Variables ------------------*/
	/*-----------------------------------------------------------*/

	/** Internal flag to indicate when parser should quit. */
	protected boolean _done_parsing = false;

	/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/

	/** Indication of the index for top of stack (for use by actions). */
	protected int tos;

	/*-----------------------------------------------------------*/
	/*--- (Access to) Instance Variables ------------------------*/
	/*-----------------------------------------------------------*/

	/** The current lookahead Symbol. */
	protected Symbol cur_token;

	/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/

	/** The parse stack itself. */
	protected Stack stack = new Stack();

	/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/

	/** Direct reference to the production table. */
	protected short[][] production_tab;

	/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/

	/** Direct reference to the action table. */
	protected short[][] action_tab;

	/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/

	/** Direct reference to the reduce-goto table. */
	protected short[][] reduce_tab;

	/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/

	/** This is the scanner object used by the default implementation
	 *  of scan() to get Symbols.  To avoid name conflicts with existing
	 *  code, this field is private. [CSA/davidm] */
	private Scanner _scanner;

	/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/

	/** Lookahead Symbols used for attempting error recovery "parse aheads". */
	protected Symbol lookahead[];

	/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/

	/** Position in lookahead input buffer used for "parse ahead". */
	protected int lookahead_pos;

	/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/

	/** Simple constructor. */
	public lr_parser() {
		/* nothing to do here */
	}

	/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
	/* Global parse state shared by parse(), error recovery, and 
	 * debugging routines */
	/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/

	/** Constructor that sets the default scanner. [CSA/davidm] */
	public lr_parser(final Scanner s) {
		this(); /* in case default constructor someday does something */
		this.setScanner(s);
	}

	/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/

	/** The action table (supplied by generated subclass).  This table is
	 *  indexed by state and terminal number indicating what action is to
	 *  be taken when the parser is in the given state (i.e., the given state 
	 *  is on top of the stack) and the given terminal is next on the input.  
	 *  States are indexed using the first dimension, however, the entries for 
	 *  a given state are compacted and stored in adjacent index, value pairs 
	 *  which are searched for rather than accessed directly (see get_action()).  
	 *  The actions stored in the table will be either shifts, reduces, or 
	 *  errors.  Shifts are encoded as positive values (one greater than the 
	 *  state shifted to).  Reduces are encoded as negative values (one less 
	 *  than the production reduced by).  Error entries are denoted by zero. 
	 * 
	 * @see java_cup.runtime.lr_parser#get_action
	 */
	public abstract short[][] action_table();

	/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/

	/** Advance to next "parse ahead" input Symbol. Return true if we have 
	 *  input to advance to, false otherwise. 
	 */
	protected boolean advance_lookahead() {
		/* advance the input location */
		this.lookahead_pos++;

		/* return true if we didn't go off the end */
		return this.lookahead_pos < this.error_sync_size();
	}

	/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/

	/** Return the current lookahead in our error "parse ahead" buffer. */
	protected Symbol cur_err_token() {
		return this.lookahead[this.lookahead_pos];
	}

	/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/

	/** Write a debugging message to System.err for the debugging version 
	 *  of the parser. 
	 *
	 * @param mess the text of the debugging message.
	 */
	public void debug_message(final String mess) {
		System.err.println(mess);
	}

	/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/

	/** Perform a parse with debugging output.  This does exactly the
	 *  same things as parse(), except that it calls debug_shift() and
	 *  debug_reduce() when shift and reduce moves are taken by the parser
	 *  and produces various other debugging messages.  
	 */
	public Symbol debug_parse() throws java.lang.Exception {
		/* the current action code */
		int act;

		/* the Symbol/stack element returned by a reduce */
		Symbol lhs_sym = null;

		/* information about production being reduced with */
		short handle_size, lhs_sym_num;

		/* set up direct reference to tables to drive the parser */
		this.production_tab = this.production_table();
		this.action_tab = this.action_table();
		this.reduce_tab = this.reduce_table();

		this.debug_message("# Initializing parser");

		/* initialize the action encapsulation object */
		this.init_actions();

		/* do user initialization */
		this.user_init();

		/* the current Symbol */
		this.cur_token = this.scan();

		this.debug_message("# Current Symbol is #" + this.cur_token.sym);

		/* push dummy Symbol with start state to get us underway */
		this.stack.removeAllElements();
		this.stack.push(new Symbol(0, this.start_state()));
		this.tos = 0;

		/* continue until we are told to stop */
		for (this._done_parsing = false; !this._done_parsing;) {
			/* Check current token for freshness. */
			if (this.cur_token.used_by_parser) {
				throw new Error("Symbol recycling detected (fix your scanner).");
			}

			/* current state is always on the top of the stack */
			//debug_stack();

			/* look up action out of the current state with the current input */
			act =
				this.get_action(
					((Symbol) this.stack.peek()).parse_state,
					this.cur_token.sym);

			/* decode the action -- > 0 encodes shift */
			if (act > 0) {
				/* shift to the encoded state by pushing it on the stack */
				this.cur_token.parse_state = act - 1;
				this.cur_token.used_by_parser = true;
				this.debug_shift(this.cur_token);
				this.stack.push(this.cur_token);
				this.tos++;

				/* advance to the next Symbol */
				this.cur_token = this.scan();
				this.debug_message("# Current token is " + this.cur_token);
			}
			/* if its less than zero, then it encodes a reduce action */
			else if (act < 0) {
				/* perform the action for the reduce */
				lhs_sym = this.do_action(-act - 1, this, this.stack, this.tos);

				/* look up information about the production */
				lhs_sym_num = this.production_tab[-act - 1][0];
				handle_size = this.production_tab[-act - 1][1];

				this.debug_reduce(-act - 1, lhs_sym_num, handle_size);

				/* pop the handle off the stack */
				for (int i = 0; i < handle_size; i++) {
					this.stack.pop();
					this.tos--;
				}

				/* look up the state to go to from the one popped back to */
				act =
					this.get_reduce(
						((Symbol) this.stack.peek()).parse_state,
						lhs_sym_num);
				this.debug_message("# Reduce rule: top state "
						+ ((Symbol) this.stack.peek()).parse_state
						+ ", lhs sym " + lhs_sym_num + " -> state " + act);

				/* shift to that state */
				lhs_sym.parse_state = act;
				lhs_sym.used_by_parser = true;
				this.stack.push(lhs_sym);
				this.tos++;

				this.debug_message("# Goto state #" + act);
			}
			/* finally if the entry is zero, we have an error */
			else if (act == 0) {
				/* call user syntax error reporting routine */
				this.syntax_error(this.cur_token);

				/* try to error recover */
				if (!this.error_recovery(true)) {
					/* if that fails give up with a fatal syntax error */
					this.unrecovered_syntax_error(this.cur_token);

					/* just in case that wasn't fatal enough, end parse */
					this.done_parsing();
				}
				else {
					lhs_sym = (Symbol) this.stack.peek();
				}
			}
		}
		return lhs_sym;
	}

	/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/

	/** Do debug output for a reduce. 
	 *
	 * @param prod_num  the production we are reducing with.
	 * @param nt_num    the index of the LHS non terminal.
	 * @param rhs_size  the size of the RHS.
	 */
	public void debug_reduce(
		final int prod_num,
		final int nt_num,
		final int rhs_size) {
		this.debug_message("# Reduce with prod #" + prod_num + " [NT=" + nt_num
				+ ", " + "SZ=" + rhs_size + "]");
	}

	/** Do debug output for shift. 
	 *
	 * @param shift_tkn the Symbol being shifted onto the stack.
	 */
	public void debug_shift(final Symbol shift_tkn) {
		this.debug_message("# Shift under term #" + shift_tkn.sym
				+ " to state #" + shift_tkn.parse_state);
	}

	/** Do debug output for stack state. [CSA]
	 */
	public void debug_stack() {
		StringBuffer sb = new StringBuffer("## STACK:");
		for (int i = 0; i < this.stack.size(); i++) {
			final Symbol s = (Symbol) this.stack.elementAt(i);
			sb.append(" <state " + s.parse_state + ", sym " + s.sym + ">");
			if (i % 3 == 2 || i == this.stack.size() - 1) {
				this.debug_message(sb.toString());
				sb = new StringBuffer("         ");
			}
		}
	}

	/*-----------------------------------------------------------*/
	/*--- General Methods ---------------------------------------*/
	/*-----------------------------------------------------------*/

	/** Perform a bit of user supplied action code (supplied by generated 
	 *  subclass).  Actions are indexed by an internal action number assigned
	 *  at parser generation time.
	 *
	 * @param act_num   the internal index of the action to be performed.
	 * @param parser    the parser object we are acting for.
	 * @param stack     the parse stack of that object.
	 * @param top       the index of the top element of the parse stack.
	 */
	public abstract Symbol do_action(
		int act_num,
		lr_parser parser,
		Stack stack,
		int top) throws java.lang.Exception;

	/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/

	/** This method is called to indicate that the parser should quit.  This is 
	 *  normally called by an accept action, but can be used to cancel parsing 
	 *  early in other circumstances if desired. 
	 */
	public void done_parsing() {
		this._done_parsing = true;
	}

	/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/

	/** Dump the parse stack for debugging purposes. */
	public void dump_stack() {
		if (this.stack == null) {
			this.debug_message("# Stack dump requested, but stack is null");
			return;
		}

		this.debug_message("============ Parse Stack Dump ============");

		/* dump the stack */
		for (int i = 0; i < this.stack.size(); i++) {
			this.debug_message("Symbol: "
					+ ((Symbol) this.stack.elementAt(i)).sym + " State: "
					+ ((Symbol) this.stack.elementAt(i)).parse_state);
		}
		this.debug_message("==========================================");
	}

	/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/

	/** The index of the end of file terminal Symbol (supplied by generated 
	 *  subclass). 
	 */
	public abstract int EOF_sym();

	/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/

	/** Attempt to recover from a syntax error.  This returns false if recovery 
	 *  fails, true if it succeeds.  Recovery happens in 4 steps.  First we
	 *  pop the parse stack down to a point at which we have a shift out
	 *  of the top-most state on the error Symbol.  This represents the
	 *  initial error recovery configuration.  If no such configuration is
	 *  found, then we fail.  Next a small number of "lookahead" or "parse
	 *  ahead" Symbols are read into a buffer.  The size of this buffer is 
	 *  determined by error_sync_size() and determines how many Symbols beyond
	 *  the error must be matched to consider the recovery a success.  Next, 
	 *  we begin to discard Symbols in attempt to get past the point of error
	 *  to a point where we can continue parsing.  After each Symbol, we attempt 
	 *  to "parse ahead" though the buffered lookahead Symbols.  The "parse ahead"
	 *  process simulates that actual parse, but does not modify the real 
	 *  parser's configuration, nor execute any actions. If we can  parse all 
	 *  the stored Symbols without error, then the recovery is considered a 
	 *  success.  Once a successful recovery point is determined, we do an
	 *  actual parse over the stored input -- modifying the real parse 
	 *  configuration and executing all actions.  Finally, we return the the 
	 *  normal parser to continue with the overall parse.
	 *
	 * @param debug should we produce debugging messages as we parse.
	 */
	protected boolean error_recovery(final boolean debug)
			throws java.lang.Exception {
		if (debug) {
			this.debug_message("# Attempting error recovery");
		}

		/* first pop the stack back into a state that can shift on error and 
		do that shift (if that fails, we fail) */
		if (!this.find_recovery_config(debug)) {
			if (debug) {
				this.debug_message("# Error recovery fails");
			}
			return false;
		}

		/* read ahead to create lookahead we can parse multiple times */
		this.read_lookahead();

		/* repeatedly try to parse forward until we make it the required dist */
		for (;;) {
			/* try to parse forward, if it makes it, bail out of loop */
			if (debug) {
				this.debug_message("# Trying to parse ahead");
			}
			if (this.try_parse_ahead(debug)) {
				break;
			}

			/* if we are now at EOF, we have failed */
			if (this.lookahead[0].sym == this.EOF_sym()) {
				if (debug) {
					this.debug_message("# Error recovery fails at EOF");
				}
				return false;
			}

			/* otherwise, we consume another Symbol and try again */
			// BUG FIX by Bruce Hutton
			// Computer Science Department, University of Auckland,
			// Auckland, New Zealand.
			// It is the first token that is being consumed, not the one 
			// we were up to parsing
			if (debug) {
				this.debug_message("# Consuming Symbol #"
						+ this.lookahead[0].sym);
			}
			this.restart_lookahead();
		}

		/* we have consumed to a point where we can parse forward */
		if (debug) {
			this.debug_message("# Parse-ahead ok, going back to normal parse");
		}

		/* do the real parse (including actions) across the lookahead */
		this.parse_lookahead(debug);

		/* we have success */
		return true;
	}

	/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/

	/** The index of the special error Symbol (supplied by generated subclass). */
	public abstract int error_sym();

	/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/

	/** The number of Symbols after an error we much match to consider it 
	 *  recovered from. 
	 */
	protected int error_sync_size() {
		return lr_parser._error_sync_size;
	}

	/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/

	/** Put the (real) parse stack into error recovery configuration by 
	 *  popping the stack down to a state that can shift on the special 
	 *  error Symbol, then doing the shift.  If no suitable state exists on 
	 *  the stack we return false 
	 *
	 * @param debug should we produce debugging messages as we parse.
	 */
	protected boolean find_recovery_config(final boolean debug) {
		Symbol error_token;
		int act;

		if (debug) {
			this.debug_message("# Finding recovery state on stack");
		}

		/* Remember the right-position of the top symbol on the stack */
		final int right_pos = ((Symbol) this.stack.peek()).right;
		int left_pos = ((Symbol) this.stack.peek()).left;

		/* pop down until we can shift under error Symbol */
		while (!this.shift_under_error()) {
			/* pop the stack */
			if (debug) {
				this.debug_message("# Pop stack by one, state was # "
						+ ((Symbol) this.stack.peek()).parse_state);
			}
			left_pos = ((Symbol) this.stack.pop()).left;
			this.tos--;

			/* if we have hit bottom, we fail */
			if (this.stack.empty()) {
				if (debug) {
					this.debug_message("# No recovery state found on stack");
				}
				return false;
			}
		}

		/* state on top of the stack can shift under error, find the shift */
		act =
			this.get_action(((Symbol) this.stack.peek()).parse_state, this
				.error_sym());
		if (debug) {
			this.debug_message("# Recover state found (#"
					+ ((Symbol) this.stack.peek()).parse_state + ")");
			this.debug_message("# Shifting on error to state #" + (act - 1));
		}

		/* build and shift a special error Symbol */
		error_token = new Symbol(this.error_sym(), left_pos, right_pos);
		error_token.parse_state = act - 1;
		error_token.used_by_parser = true;
		this.stack.push(error_token);
		this.tos++;

		return true;
	}

	/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/

	/** Fetch an action from the action table.  The table is broken up into
	 *  rows, one per state (rows are indexed directly by state number).  
	 *  Within each row, a list of index, value pairs are given (as sequential
	 *  entries in the table), and the list is terminated by a default entry 
	 *  (denoted with a Symbol index of -1).  To find the proper entry in a row 
	 *  we do a linear or binary search (depending on the size of the row).  
	 *
	 * @param state the state index of the action being accessed.
	 * @param sym   the Symbol index of the action being accessed.
	 */
	protected final short get_action(final int state, final int sym) {
		short tag;
		int first, last, probe;
		final short[] row = this.action_tab[state];

		/* linear search if we are < 10 entries */
		if (row.length < 20) {
			for (probe = 0; probe < row.length; probe++) {
				/* is this entry labeled with our Symbol or the default? */
				tag = row[probe++];
				if (tag == sym || tag == -1) {
					/* return the next entry */
					return row[probe];
				}
			}
			/* otherwise binary search */
		}
		else {
			first = 0;
			last = (row.length - 1) / 2 - 1; /* leave out trailing default entry */
			while (first <= last) {
				probe = (first + last) / 2;
				if (sym == row[probe * 2]) {
					return row[probe * 2 + 1];
				}
				else if (sym > row[probe * 2]) {
					first = probe + 1;
				}
				else {
					last = probe - 1;
				}
			}

			/* not found, use the default at the end */
			return row[row.length - 1];
		}

		/* shouldn't happened, but if we run off the end we return the 
		default (error == 0) */
		return 0;
	}

	/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/

	/** Fetch a state from the reduce-goto table.  The table is broken up into
	 *  rows, one per state (rows are indexed directly by state number).  
	 *  Within each row, a list of index, value pairs are given (as sequential
	 *  entries in the table), and the list is terminated by a default entry 
	 *  (denoted with a Symbol index of -1).  To find the proper entry in a row 
	 *  we do a linear search.  
	 *
	 * @param state the state index of the entry being accessed.
	 * @param sym   the Symbol index of the entry being accessed.
	 */
	protected final short get_reduce(final int state, final int sym) {
		short tag;
		final short[] row = this.reduce_tab[state];

		/* if we have a null row we go with the default */
		if (row == null) {
			return -1;
		}

		for (int probe = 0; probe < row.length; probe++) {
			/* is this entry labeled with our Symbol or the default? */
			tag = row[probe++];
			if (tag == sym || tag == -1) {
				/* return the next entry */
				return row[probe];
			}
		}
		/* if we run off the end we return the default (error == -1) */
		return -1;
	}

	/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/

	/**
	 * Simple accessor method to get the default scanner.
	 */
	public Scanner getScanner() {
		return this._scanner;
	}

	/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/

	/** Initialize the action object.  This is called before the parser does
	 *  any parse actions. This is filled in by generated code to create
	 *  an object that encapsulates all action code. 
	 */
	protected abstract void init_actions() throws java.lang.Exception;

	/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/

	/** This method provides the main parsing routine.  It returns only when 
	 *  done_parsing() has been called (typically because the parser has 
	 *  accepted, or a fatal error has been reported).  See the header 
	 *  documentation for the class regarding how shift/reduce parsers operate
	 *  and how the various tables are used.
	 */
	public Symbol parse() throws java.lang.Exception {
		/* the current action code */
		int act;

		/* the Symbol/stack element returned by a reduce */
		Symbol lhs_sym = null;

		/* information about production being reduced with */
		short handle_size, lhs_sym_num;

		/* set up direct reference to tables to drive the parser */

		this.production_tab = this.production_table();
		this.action_tab = this.action_table();
		this.reduce_tab = this.reduce_table();

		/* initialize the action encapsulation object */
		this.init_actions();

		/* do user initialization */
		this.user_init();

		/* get the first token */
		this.cur_token = this.scan();

		/* push dummy Symbol with start state to get us underway */
		this.stack.removeAllElements();
		this.stack.push(new Symbol(0, this.start_state()));
		this.tos = 0;

		/* continue until we are told to stop */
		for (this._done_parsing = false; !this._done_parsing;) {
			/* Check current token for freshness. */
			if (this.cur_token.used_by_parser) {
				throw new Error("Symbol recycling detected (fix your scanner).");
			}

			/* current state is always on the top of the stack */

			/* look up action out of the current state with the current input */
			act =
				this.get_action(
					((Symbol) this.stack.peek()).parse_state,
					this.cur_token.sym);

			/* decode the action -- > 0 encodes shift */
			if (act > 0) {
				/* shift to the encoded state by pushing it on the stack */
				this.cur_token.parse_state = act - 1;
				this.cur_token.used_by_parser = true;
				this.stack.push(this.cur_token);
				this.tos++;

				/* advance to the next Symbol */
				this.cur_token = this.scan();
			}
			/* if its less than zero, then it encodes a reduce action */
			else if (act < 0) {
				/* perform the action for the reduce */
				lhs_sym = this.do_action(-act - 1, this, this.stack, this.tos);

				/* look up information about the production */
				lhs_sym_num = this.production_tab[-act - 1][0];
				handle_size = this.production_tab[-act - 1][1];

				/* pop the handle off the stack */
				for (int i = 0; i < handle_size; i++) {
					this.stack.pop();
					this.tos--;
				}

				/* look up the state to go to from the one popped back to */
				act =
					this.get_reduce(
						((Symbol) this.stack.peek()).parse_state,
						lhs_sym_num);

				/* shift to that state */
				lhs_sym.parse_state = act;
				lhs_sym.used_by_parser = true;
				this.stack.push(lhs_sym);
				this.tos++;
			}
			/* finally if the entry is zero, we have an error */
			else if (act == 0) {
				/* call user syntax error reporting routine */
				this.syntax_error(this.cur_token);

				/* try to error recover */
				if (!this.error_recovery(false)) {
					/* if that fails give up with a fatal syntax error */
					this.unrecovered_syntax_error(this.cur_token);

					/* just in case that wasn't fatal enough, end parse */
					this.done_parsing();
				}
				else {
					lhs_sym = (Symbol) this.stack.peek();
				}
			}
		}
		return lhs_sym;
	}

	/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/

	/** Parse forward using stored lookahead Symbols.  In this case we have
	 *  already verified that parsing will make it through the stored lookahead
	 *  Symbols and we are now getting back to the point at which we can hand
	 *  control back to the normal parser.  Consequently, this version of the
	 *  parser performs all actions and modifies the real parse configuration.  
	 *  This returns once we have consumed all the stored input or we accept.
	 *
	 * @param debug should we produce debugging messages as we parse.
	 */
	protected void parse_lookahead(final boolean debug)
			throws java.lang.Exception {
		/* the current action code */
		int act;

		/* the Symbol/stack element returned by a reduce */
		Symbol lhs_sym = null;

		/* information about production being reduced with */
		short handle_size, lhs_sym_num;

		/* restart the saved input at the beginning */
		this.lookahead_pos = 0;

		if (debug) {
			this.debug_message("# Reparsing saved input with actions");
			this.debug_message("# Current Symbol is #"
					+ this.cur_err_token().sym);
			this.debug_message("# Current state is #"
					+ ((Symbol) this.stack.peek()).parse_state);
		}

		/* continue until we accept or have read all lookahead input */
		while (!this._done_parsing) {
			/* current state is always on the top of the stack */

			/* look up action out of the current state with the current input */
			act =
				this.get_action(((Symbol) this.stack.peek()).parse_state, this
					.cur_err_token().sym);

			/* decode the action -- > 0 encodes shift */
			if (act > 0) {
				/* shift to the encoded state by pushing it on the stack */
				this.cur_err_token().parse_state = act - 1;
				this.cur_err_token().used_by_parser = true;
				if (debug) {
					this.debug_shift(this.cur_err_token());
				}
				this.stack.push(this.cur_err_token());
				this.tos++;

				/* advance to the next Symbol, if there is none, we are done */
				if (!this.advance_lookahead()) {
					if (debug) {
						this.debug_message("# Completed reparse");
					}

					/* scan next Symbol so we can continue parse */
					// BUGFIX by Chris Harris <ckharris@ucsd.edu>:
					//   correct a one-off error by commenting out
					//   this next line.
					/*cur_token = scan();*/

					/* go back to normal parser */
					return;
				}

				if (debug) {
					this.debug_message("# Current Symbol is #"
							+ this.cur_err_token().sym);
				}
			}
			/* if its less than zero, then it encodes a reduce action */
			else if (act < 0) {
				/* perform the action for the reduce */
				lhs_sym = this.do_action(-act - 1, this, this.stack, this.tos);

				/* look up information about the production */
				lhs_sym_num = this.production_tab[-act - 1][0];
				handle_size = this.production_tab[-act - 1][1];

				if (debug) {
					this.debug_reduce(-act - 1, lhs_sym_num, handle_size);
				}

				/* pop the handle off the stack */
				for (int i = 0; i < handle_size; i++) {
					this.stack.pop();
					this.tos--;
				}

				/* look up the state to go to from the one popped back to */
				act =
					this.get_reduce(
						((Symbol) this.stack.peek()).parse_state,
						lhs_sym_num);

				/* shift to that state */
				lhs_sym.parse_state = act;
				lhs_sym.used_by_parser = true;
				this.stack.push(lhs_sym);
				this.tos++;

				if (debug) {
					this.debug_message("# Goto state #" + act);
				}

			}
			/* finally if the entry is zero, we have an error 
			   (shouldn't happen here, but...)*/
			else if (act == 0) {
				this.report_fatal_error("Syntax error", lhs_sym);
				return;
			}
		}

	}

	/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/

	/** Table of production information (supplied by generated subclass).
	 *  This table contains one entry per production and is indexed by 
	 *  the negative-encoded values (reduce actions) in the action_table.  
	 *  Each entry has two parts, the index of the non-terminal on the 
	 *  left hand side of the production, and the number of Symbols 
	 *  on the right hand side. 
	 */
	public abstract short[][] production_table();

	/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/

	/** Read from input to establish our buffer of "parse ahead" lookahead 
	 *  Symbols. 
	 */
	protected void read_lookahead() throws java.lang.Exception {
		/* create the lookahead array */
		this.lookahead = new Symbol[this.error_sync_size()];

		/* fill in the array */
		for (int i = 0; i < this.error_sync_size(); i++) {
			this.lookahead[i] = this.cur_token;
			this.cur_token = this.scan();
		}

		/* start at the beginning */
		this.lookahead_pos = 0;
	}

	/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/

	/** The reduce-goto table (supplied by generated subclass).  This
	 *  table is indexed by state and non-terminal number and contains
	 *  state numbers.  States are indexed using the first dimension, however,
	 *  the entries for a given state are compacted and stored in adjacent
	 *  index, value pairs which are searched for rather than accessed 
	 *  directly (see get_reduce()).  When a reduce occurs, the handle 
	 *  (corresponding to the RHS of the matched production) is popped off 
	 *  the stack.  The new top of stack indicates a state.  This table is 
	 *  then indexed by that state and the LHS of the reducing production to 
	 *  indicate where to "shift" to. 
	 *
	 * @see java_cup.runtime.lr_parser#get_reduce
	 */
	public abstract short[][] reduce_table();

	/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
	/* Error recovery code */
	/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/

	/** Report a non fatal error (or warning).  This method takes a message 
	 *  string and an additional object (to be used by specializations 
	 *  implemented in subclasses).  Here in the base class a very simple 
	 *  implementation is provided which simply prints the message to 
	 *  System.err. 
	 *
	 * @param message an error message.
	 * @param info    an extra object reserved for use by specialized subclasses.
	 */
	public void report_error(final String message, final Object info) {
		System.err.print(message);
		if (info instanceof Symbol) {
			if (((Symbol) info).left != -1) {
				System.err.println(" at character " + ((Symbol) info).left
						+ " of input");
			}
			else {
				System.err.println("");
			}
		}
		else {
			System.err.println("");
		}
	}

	/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/

	/** Report a fatal error.  This method takes a  message string and an 
	 *  additional object (to be used by specializations implemented in 
	 *  subclasses).  Here in the base class a very simple implementation 
	 *  is provided which reports the error then throws an exception. 
	 *
	 * @param message an error message.
	 * @param info    an extra object reserved for use by specialized subclasses.
	 */
	public void report_fatal_error(final String message, final Object info)
			throws java.lang.Exception {
		/* stop parsing (not really necessary since we throw an exception, but) */
		this.done_parsing();

		/* use the normal error message reporting to put out the message */
		this.report_error(message, info);

		/* throw an exception */
		throw new Exception("Can't recover from previous error(s)");
	}

	/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/

	/** Reset the parse ahead input to one Symbol past where we started error 
	 *  recovery (this consumes one new Symbol from the real input). 
	 */
	protected void restart_lookahead() throws java.lang.Exception {
		/* move all the existing input over */
		for (int i = 1; i < this.error_sync_size(); i++) {
			this.lookahead[i - 1] = this.lookahead[i];
		}

		/* read a new Symbol into the last spot */
		// BUG Fix by Bruce Hutton
		// Computer Science Department, University of Auckland,
		// Auckland, New Zealand. [applied 5-sep-1999 by csa]
		// The following two lines were out of order!!
		this.lookahead[this.error_sync_size() - 1] = this.cur_token;
		this.cur_token = this.scan();

		/* reset our internal position marker */
		this.lookahead_pos = 0;
	}

	/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/

	/** Get the next Symbol from the input (supplied by generated subclass).
	 *  Once end of file has been reached, all subsequent calls to scan 
	 *  should return an EOF Symbol (which is Symbol number 0).  By default
	 *  this method returns getScanner().next_token(); this implementation
	 *  can be overriden by the generated parser using the code declared in
	 *  the "scan with" clause.  Do not recycle objects; every call to
	 *  scan() should return a fresh object.
	 */
	public Symbol scan() throws java.lang.Exception {
		final Symbol sym = this.getScanner().next_token();
		return sym != null ? sym : new Symbol(this.EOF_sym());
	}

	/**
	 * Simple accessor method to set the default scanner.
	 */
	public void setScanner(final Scanner s) {
		this._scanner = s;
	}

	/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/

	/** Determine if we can shift under the special error Symbol out of the 
	 *  state currently on the top of the (real) parse stack. 
	 */
	protected boolean shift_under_error() {
		/* is there a shift under error Symbol */
		return this.get_action(((Symbol) this.stack.peek()).parse_state, this
			.error_sym()) > 0;
	}

	/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/

	/** The index of the start production (supplied by generated subclass). */
	public abstract int start_production();

	/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/

	/** The index of the start state (supplied by generated subclass). */
	public abstract int start_state();

	/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/

	/** This method is called when a syntax error has been detected and recovery 
	 *  is about to be invoked.  Here in the base class we just emit a 
	 *  "Syntax error" error message.  
	 *
	 * @param cur_token the current lookahead Symbol.
	 */
	public void syntax_error(final Symbol cur_token) {
		this.report_error("Syntax error", cur_token);
	}

	/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/

	/** Do a simulated parse forward (a "parse ahead") from the current 
	 *  stack configuration using stored lookahead input and a virtual parse
	 *  stack.  Return true if we make it all the way through the stored 
	 *  lookahead input without error. This basically simulates the action of 
	 *  parse() using only our saved "parse ahead" input, and not executing any 
	 *  actions.
	 *
	 * @param debug should we produce debugging messages as we parse.
	 */
	protected boolean try_parse_ahead(final boolean debug)
			throws java.lang.Exception {
		int act;
		short lhs, rhs_size;

		/* create a virtual stack from the real parse stack */
		final virtual_parse_stack vstack = new virtual_parse_stack(this.stack);

		/* parse until we fail or get past the lookahead input */
		for (;;) {
			/* look up the action from the current state (on top of stack) */
			act = this.get_action(vstack.top(), this.cur_err_token().sym);

			/* if its an error, we fail */
			if (act == 0) {
				return false;
			}

			/* > 0 encodes a shift */
			if (act > 0) {
				/* push the new state on the stack */
				vstack.push(act - 1);

				if (debug) {
					this.debug_message("# Parse-ahead shifts Symbol #"
							+ this.cur_err_token().sym + " into state #"
							+ (act - 1));
				}

				/* advance simulated input, if we run off the end, we are done */
				if (!this.advance_lookahead()) {
					return true;
				}
			}
			/* < 0 encodes a reduce */
			else {
				/* if this is a reduce with the start production we are done */
				if (-act - 1 == this.start_production()) {
					if (debug) {
						this.debug_message("# Parse-ahead accepts");
					}
					return true;
				}

				/* get the lhs Symbol and the rhs size */
				lhs = this.production_tab[-act - 1][0];
				rhs_size = this.production_tab[-act - 1][1];

				/* pop handle off the stack */
				for (int i = 0; i < rhs_size; i++) {
					vstack.pop();
				}

				if (debug) {
					this.debug_message("# Parse-ahead reduces: handle size = "
							+ rhs_size + " lhs = #" + lhs + " from state #"
							+ vstack.top());
				}

				/* look up goto and push it onto the stack */
				vstack.push(this.get_reduce(vstack.top(), lhs));
				if (debug) {
					this.debug_message("# Goto state #" + vstack.top());
				}
			}
		}
	}

	/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/

	/** This method is called if it is determined that syntax error recovery 
	 *  has been unsuccessful.  Here in the base class we report a fatal error. 
	 *
	 * @param cur_token the current lookahead Symbol.
	 */
	public void unrecovered_syntax_error(final Symbol cur_token)
			throws java.lang.Exception {
		this
			.report_fatal_error("Couldn't repair and continue parse", cur_token);
	}

	/*-----------------------------------------------------------*/

	/** User code for initialization inside the parser.  Typically this 
	 *  initializes the scanner.  This is called before the parser requests
	 *  the first Symbol.  Here this is just a placeholder for subclasses that 
	 *  might need this and we perform no action.   This method is normally
	 *  overridden by the generated code using this contents of the "init with"
	 *  clause as its body.
	 */
	public void user_init() throws java.lang.Exception {
	}
}
