/*-----------------------------------------------------------*/
/*--- General Methods ---------------------------------------*/
/*-----------------------------------------------------------*/
/// <summary>Add a transition out of this state to another.
/// </summary>
/// <param name="on_sym">the symbol the transition is under.
/// </param>
/// <param name="to_st"> the state the transition goes to.
///
/// </param>
public virtual void add_transition(symbol on_sym, lalr_state to_st)
{
lalr_transition trans;
/* create a new transition object and put it in our list */
trans = new lalr_transition(on_sym, to_st, _transitions);
_transitions = trans;
}
/*-----------------------------------------------------------*/
/*--- Constructor(s) ----------------------------------------*/
/*-----------------------------------------------------------*/
/// <summary>Full constructor.
/// </summary>
/// <param name="on_sym"> symbol we are transitioning on.
/// </param>
/// <param name="to_st"> state we transition to.
/// </param>
/// <param name="nxt"> next transition in linked list.
///
/// </param>
public lalr_transition(symbol on_sym, lalr_state to_st, lalr_transition nxt)
{
/* sanity checks */
if (on_sym == null)
throw new internal_error("Attempt to create transition on null symbol");
if (to_st == null)
throw new internal_error("Attempt to create transition to null state");
/* initialize */
_on_symbol = on_sym;
_to_state = to_st;
_next = nxt;
}
/*-----------------------------------------------------------*/
/*--- Constructor(s) ----------------------------------------*/
/*-----------------------------------------------------------*/
/// <summary>Full constructor.
/// </summary>
/// <param name="on_sym"> symbol we are transitioning on.
/// </param>
/// <param name="to_st"> state we transition to.
/// </param>
/// <param name="nxt"> next transition in linked list.
///
/// </param>
public lalr_transition(symbol on_sym, lalr_state to_st, lalr_transition nxt)
{
/* sanity checks */
if (on_sym == null)
{
throw new internal_error("Attempt to create transition on null symbol");
}
if (to_st == null)
{
throw new internal_error("Attempt to create transition to null state");
}
/* initialize */
_on_symbol = on_sym;
_to_state = to_st;
_next = nxt;
}
/*-----------------------------------------------------------*/
/*--- General Methods ---------------------------------------*/
/*-----------------------------------------------------------*/
/// <summary>Add a transition out of this state to another.
/// </summary>
/// <param name="on_sym">the symbol the transition is under.
/// </param>
/// <param name="to_st"> the state the transition goes to.
///
/// </param>
public virtual void add_transition(symbol on_sym, lalr_state to_st)
{
lalr_transition trans;
/* create a new transition object and put it in our list */
trans = new lalr_transition(on_sym, to_st, _transitions);
_transitions = trans;
}
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/// <summary>Fill in the parse table entries for this state. There are two
/// parse tables that encode the viable prefix recognition machine, an
/// action table and a reduce-goto table. The rows in each table
/// correspond to states of the machine. The columns of the action table
/// are indexed by terminal symbols and correspond to either transitions
/// out of the state (shift entries) or reductions from the state to some
/// previous state saved on the stack (reduce entries). All entries in the
/// action table that are not shifts or reduces, represent errors. The
/// reduce-goto table is indexed by non terminals and represents transitions
/// out of a state on that non-terminal.<p>
/// Conflicts occur if more than one action needs to go in one entry of the
/// action table (this cannot happen with the reduce-goto table). Conflicts
/// are resolved by always shifting for shift/reduce conflicts and choosing
/// the lowest numbered production (hence the one that appeared first in
/// the specification) in reduce/reduce conflicts. All conflicts are
/// reported and if more conflicts are detected than were declared by the
/// user, code generation is aborted.
/// *
/// </summary>
/// <param name="act_table"> the action table to put entries in.
/// </param>
/// <param name="reduce_table">the reduce-goto table to put entries in.
///
/// </param>
public virtual void build_table_entries(parse_action_table act_table, parse_reduce_table reduce_table)
{
parse_action_row our_act_row;
parse_reduce_row our_red_row;
lalr_item itm;
parse_action act, other_act;
symbol sym;
terminal_set conflict_set = new terminal_set();
/* pull out our rows from the tables */
our_act_row = act_table.under_state[index()];
our_red_row = reduce_table.under_state[index()];
/* consider each item in our state */
//UPGRADE_TODO: method 'java.util.Enumeration.hasMoreElements' was converted to ' ' which has a different behavior. 'ms-help://MS.VSCC/commoner/redir/redirect.htm?keyword="jlca1073_javautilEnumerationhasMoreElements"'
for (System.Collections.IEnumerator i = items().all(); i.MoveNext();)
{
//UPGRADE_TODO: method 'java.util.Enumeration.nextElement' was converted to ' ' which has a different behavior. 'ms-help://MS.VSCC/commoner/redir/redirect.htm?keyword="jlca1073_javautilEnumerationnextElement"'
itm = (lalr_item)i.Current;
/* if its completed (dot at end) then reduce under the lookahead */
if (itm.dot_at_end())
{
act = new reduce_action(itm.the_production());
/* consider each lookahead symbol */
for (int t = 0; t < terminal.number(); t++)
{
/* skip over the ones not in the lookahead */
if (!itm.lookahead().contains(t))
{
continue;
}
/* if we don't already have an action put this one in */
if (our_act_row.under_term[t].kind() == parse_action.ERROR)
{
our_act_row.under_term[t] = act;
}
else
{
/* we now have at least one conflict */
terminal term = terminal.find(t);
other_act = our_act_row.under_term[t];
/* if the other act was not a shift */
if ((other_act.kind() != parse_action.SHIFT) && (other_act.kind() != parse_action.NONASSOC))
{
/* if we have lower index hence priority, replace it*/
if (itm.the_production().index() < ((reduce_action)other_act).reduce_with().index())
{
/* replace the action */
our_act_row.under_term[t] = act;
}
}
else
{
/* Check precedences,see if problem is correctable */
if (fix_with_precedence(itm.the_production(), t, our_act_row, act))
{
term = null;
}
}
if (term != null)
{
conflict_set.add(term);
}
}
}
}
}
/* consider each outgoing transition */
for (lalr_transition trans = transitions(); trans != null; trans = trans.next())
{
/* if its on an terminal add a shift entry */
sym = trans.on_symbol();
if (!sym.is_non_term())
{
act = new shift_action(trans.to_state());
/* if we don't already have an action put this one in */
if (our_act_row.under_term[sym.index()].kind() == parse_action.ERROR)
{
our_act_row.under_term[sym.index()] = act;
}
else
{
/* we now have at least one conflict */
production p = ((reduce_action)our_act_row.under_term[sym.index()]).reduce_with();
/* shift always wins */
if (!fix_with_precedence(p, sym.index(), our_act_row, act))
{
our_act_row.under_term[sym.index()] = act;
conflict_set.add(terminal.find(sym.index()));
}
}
}
else
{
/* for non terminals add an entry to the reduce-goto table */
our_red_row.under_non_term[sym.index()] = trans.to_state();
}
}
/* if we end up with conflict(s), report them */
if (!conflict_set.empty())
{
report_conflicts(conflict_set);
}
}