java_cup.parse_action_row Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of javacup Show documentation
A fork of the Java Cup parser generator with some bug fixes and enhancements. (Forked at version 11b)
The newest version!
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;
    }

  /*-----------------------------------------------------------*/

}