parse_action_table.java

package java_cup;


import java.util.Enumeration;


/**
 * This class represents the complete "action" table of the parser. It has one
 * row for each state in the parse machine, and a column for each terminal
 * symbol. Each entry in the table represents a shift, reduce, or an error.
 * 
 * @see java_cup.parse_action
 * @see java_cup.parse_action_row
 * @version last updated: 11/25/95
 * @author Scott Hudson
 */
@SuppressWarnings (
{ "all" } )
public class parse_action_table
{

  /*-----------------------------------------------------------*/
  /*--- Constructor(s) ----------------------------------------*/
  /*-----------------------------------------------------------*/
  /**
   * Simple constructor. All terminals, non-terminals, and productions must
   * already have been entered, and the viable prefix recognizer should have
   * been constructed before this is called.
   */
  public parse_action_table ()
  {
    /* determine how many states we are working with */
    _num_states = lalr_state.number ();
    /* allocate the array and fill it in with empty rows */
    under_state = new parse_action_row [ _num_states ];
    for ( int i = 0 ; i < _num_states ; i++ )
      under_state [ i ] = new parse_action_row ();
  }


  /*-----------------------------------------------------------*/
  /*--- (Access to) Instance Variables ------------------------*/
  /*-----------------------------------------------------------*/
  /** How many rows/states are in the machine/table. */
  protected int _num_states;


  /** How many rows/states are in the machine/table. */
  public int num_states ()
  {
    return _num_states;
  }


  /* . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . */
  /** Actual array of rows, one per state. */
  public parse_action_row [] under_state;


  /*-----------------------------------------------------------*/
  /*--- General Methods ---------------------------------------*/
  /*-----------------------------------------------------------*/
  /**
   * Check the table to ensure that all productions have been reduced. Issue a
   * warning message (to System.err) for each production that is never reduced.
   */
  public void check_reductions () throws internal_error
  {
    parse_action act;
    production prod;
    /* tabulate reductions -- look at every table entry */
    for ( int row = 0 ; row < num_states () ; row++ )
    {
      for ( int col = 0 ; col < parse_action_row.size () ; col++ )
      {
        /* look at the action entry to see if its a reduce */
        act = under_state [ row ].under_term [ col ];
        if ( act != null && act.kind () == parse_action.REDUCE )
        {
          /* tell production that we used it */
          ( ( reduce_action ) act ).reduce_with ().note_reduction_use ();
        }
      }
    }
    /* now go across every production and make sure we hit it */
    for ( Enumeration p = production.all () ; p.hasMoreElements () ; )
    {
      prod = ( production ) p.nextElement ();
      /* if we didn't hit it give a warning */
      if ( prod.num_reductions () == 0 )
      {
        /***********************************************************************
         * count it emit.not_reduced++; /* give a warning if they haven't been
         * turned off
         */
        if ( !emit.nowarn )
        {
          ErrorManager.getManager ().emit_warning (
              "*** Production \"" + prod.to_simple_string ()
                  + "\" never reduced" );
        }
      }
    }
  }


  /*****************************************************************************
   * . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . /** Convert to
   * a string.
   */
  public String toString ()
  {
    String result;
    int cnt;
    result = "-------- ACTION_TABLE --------\n";
    for ( int row = 0 ; row < num_states () ; row++ )
    {
      result += "From state #" + row + "\n";
      cnt = 0;
      for ( int col = 0 ; col < parse_action_row.size () ; col++ )
      {
        /* if the action is not an error print it */
        if ( under_state [ row ].under_term [ col ].kind () != parse_action.ERROR )
        {
          result += " [term " + col + ":"
              + under_state [ row ].under_term [ col ] + "]";
          /* end the line after the 2nd one */
          cnt++ ;
          if ( cnt == 2 )
          {
            result += "\n";
            cnt = 0;
          }
        }
      }
      /* finish the line if we haven't just done that */
      if ( cnt != 0 )
        result += "\n";
    }
    result += "------------------------------";
    return result;
  }
  /*-----------------------------------------------------------*/
}