parse_action_row.java

package java_cup;


/**
 * This class represents one row (corresponding to one machine state) of the
 * parse action table.
 */
@SuppressWarnings (
{ "all" } )
public class parse_action_row
{

  /*-----------------------------------------------------------*/
  /*--- Constructor(s) ----------------------------------------*/
  /*-----------------------------------------------------------*/
  /**
   * Simple constructor. Note: this should not be used until the number of
   * terminals in the grammar has been established.
   */
  public parse_action_row ()
  {
    /* make sure the size is set */
    if ( _size <= 0 )
      _size = terminal.number ();
    /* allocate the array */
    under_term = new parse_action [ size () ];
    /* set each element to an error action */
    for ( int i = 0 ; i < _size ; i++ )
      under_term [ i ] = new parse_action ();
  }


  /*-----------------------------------------------------------*/
  /*--- (Access to) Static (Class) Variables ------------------*/
  /*-----------------------------------------------------------*/
  /** Number of columns (terminals) in every row. */
  protected static int _size = 0;


  /** Number of columns (terminals) in every row. */
  public static int size ()
  {
    return _size;
  }


  // Hm Added clear to clear all static fields
  public static void clear ()
  {
    _size = 0;
    reduction_count = null;
  }


  /* . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . */
  /** Table of reduction counts (reused by compute_default()). */
  protected static int reduction_count[] = null;


  /*-----------------------------------------------------------*/
  /*--- (Access to) Instance Variables ------------------------*/
  /*-----------------------------------------------------------*/
  /** Actual action entries for the row. */
  public parse_action under_term[];


  /* . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . */
  /**
   * Default (reduce) action for this row. -1 will represent default of error.
   */
  public int default_reduce;


  /*-----------------------------------------------------------*/
  /*--- General Methods ---------------------------------------*/
  /*-----------------------------------------------------------*/
  /**
   * Compute the default (reduce) action for this row and store it in
   * default_reduce. In the case of non-zero default we will have the effect of
   * replacing all errors by that reduction. This may cause us to do erroneous
   * reduces, but will never cause us to shift past the point of the error and
   * never cause an incorrect parse. -1 will be used to encode the fact that no
   * reduction can be used as a default (in which case error will be used).
   */
  public void compute_default ()
  {
    int i, prod, max_prod, max_red;
    /* if we haven't allocated the count table, do so now */
    if ( reduction_count == null )
      reduction_count = new int [ production.number () ];
    /* clear the reduction count table and maximums */
    for ( i = 0 ; i < production.number () ; i++ )
      reduction_count [ i ] = 0;
    max_prod = -1;
    max_red = 0;
    /* walk down the row and look at the reduces */
    for ( i = 0 ; i < size () ; i++ )
      if ( under_term [ i ].kind () == parse_action.REDUCE )
      {
        /*
         * count the reduce in the proper production slot and keep the max up to
         * date
         */
        prod = ( ( reduce_action ) under_term [ i ] ).reduce_with ().index ();
        reduction_count [ prod ]++ ;
        if ( reduction_count [ prod ] > max_red )
        {
          max_red = reduction_count [ prod ];
          max_prod = prod;
        }
      }
    /* record the max as the default (or -1 for not found) */
    default_reduce = max_prod;
  }
  /*-----------------------------------------------------------*/
}