Logo Search packages:      
Sourcecode: jasmin-sable version File versions  Download package

void java_cup::lalr_state::build_table_entries ( parse_action_table  act_table,
parse_reduce_table  reduce_table 
) throws internal_error [inline]

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.

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.

Parameters:
act_table the action table to put entries in.
reduce_table the reduce-goto table to put entries in.

Definition at line 451 of file lalr_state.java.

References java_cup::terminal_set::add(), all(), java_cup::terminal_set::contains(), java_cup::lr_item_core::dot_at_end(), java_cup::terminal_set::empty(), fix_with_precedence(), java_cup::symbol::index(), java_cup::production::index(), index(), java_cup::symbol::is_non_term(), items(), java_cup::parse_action::kind(), java_cup::lalr_item::lookahead(), java_cup::lalr_transition::next(), report_conflicts(), java_cup::lr_item_core::the_production(), transitions(), java_cup::parse_reduce_row::under_non_term, and java_cup::parse_action_row::under_term.

Referenced by java_cup::Main::build_parser().

    {
      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 */
      for (Enumeration i = items().all(); i.hasMoreElements(); )
      {
        itm = (lalr_item)i.nextElement();
       

        /* 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);
    }


Generated by  Doxygen 1.6.0   Back to index