content: 
  package java_cup;
  
  /** This class represents one row (corresponding to one machine state) of the 
   *  parse action table.
   */
  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;
      }
  
    /*-----------------------------------------------------------*/
  
  }
  
  