Package java_cup

Class production

  • Direct Known Subclasses:
    action_production

    public class production
    extends java.lang.Object
    This class represents a production in the grammar. It contains a LHS non terminal, and an array of RHS symbols. As various transformations are done on the RHS of the production, it may shrink. As a result a separate length is always maintained to indicate how much of the RHS array is still valid.

    I addition to construction and manipulation operations, productions provide methods for factoring out actions (see remove_embedded_actions()), for computing the nullability of the production (i.e., can it derive the empty string, see check_nullable()), and operations for computing its first set (i.e., the set of terminals that could appear at the beginning of some string derived from the production, see check_first_set()).

    Version:
    last updated: 7/3/96
    Author:
    Frank Flannery
    See Also:
    production_part, symbol_part, action_part
    • Field Summary

      Fields 
      Modifier and Type Field Description
      protected action_part _action
      An action_part containing code for the action to be performed when we reduce with this production.
      protected static java.util.Hashtable _all
      Table of all productions.
      protected terminal_set _first_set
      First set of the production.
      protected int _index
      Index number of the production.
      protected symbol_part _lhs
      The left hand side non-terminal.
      protected boolean _nullable
      Nullability of the production (can it derive the empty string).
      protected boolean _nullable_known
      Is the nullability of the production known or unknown?
      protected int _num_reductions
      Count of number of reductions using this production.
      protected production_part[] _rhs
      A collection of parts for the right hand side.
      protected int _rhs_assoc  
      protected int _rhs_length
      How much of the right hand side array we are presently using.
      protected int _rhs_prec
      The precedence of the rule
      protected static int next_index
      Static counter for assigning unique index numbers.
    • Method Summary

      All Methods Static Methods Instance Methods Concrete Methods 
      Modifier and Type Method Description
      action_part action()
      An action_part containing code for the action to be performed when we reduce with this production.
      static java.util.Enumeration all()
      Access to all productions.
      terminal_set check_first_set()
      Update (and return) the first set based on current NT firsts.
      boolean check_nullable()
      Check to see if the production (now) appears to be nullable.
      static void clear()  
      protected java.lang.String declare_labels​(production_part[] rhs, int rhs_len, java.lang.String final_action)
      Declare label names as valid variables within the action string
      boolean equals​(production other)
      Equality comparison.
      boolean equals​(java.lang.Object other)
      Generic equality comparison.
      static production find​(int indx)
      Lookup a production by index.
      terminal_set first_set()
      First set of the production.
      int hashCode()
      Produce a hash code.
      int index()
      Index number of the production.
      protected static boolean is_id_char​(char c)
      Determine if a character can be in a label id.
      protected static boolean is_id_start​(char c)
      Determine if a given character can be a label id starter.
      symbol_part lhs()
      The left hand side non-terminal.
      protected java.lang.String make_declaration​(java.lang.String labelname, java.lang.String stack_type, int offset)
      Return label declaration code
      protected int merge_adjacent_actions​(production_part[] rhs_parts, int len)
      Helper routine to merge adjacent actions in a set of RHS parts
      void note_reduction_use()
      Increment the count of reductions with this non-terminal
      boolean nullable()
      Nullability of the production (can it derive the empty string).
      boolean nullable_known()
      Is the nullability of the production known or unknown?
      int num_reductions()
      Count of number of reductions using this production.
      static int number()
      Total number of productions.
      int precedence_num()
      Access to the precedence of the rule
      int precedence_side()  
      protected void remove_embedded_actions()
      Remove all embedded actions from a production by factoring them out into individual action production using new non terminals.
      production_part rhs​(int indx)
      Access to the collection of parts for the right hand side.
      int rhs_length()
      How much of the right hand side array we are presently using.
      void set_precedence_num​(int prec_num)
      Setting the precedence of a rule
      void set_precedence_side​(int prec_side)  
      protected action_part strip_trailing_action​(production_part[] rhs_parts, int len)
      Helper routine to strip a trailing action off rhs and return it
      java.lang.String to_simple_string()
      Convert to a simpler string.
      java.lang.String toString()
      Convert to a string.
      • Methods inherited from class java.lang.Object

        clone, finalize, getClass, notify, notifyAll, wait, wait, wait
    • Field Detail

      • _all

        protected static java.util.Hashtable _all
        Table of all productions. Elements are stored using their index as the key.
      • next_index

        protected static int next_index
        Static counter for assigning unique index numbers.
      • _lhs

        protected symbol_part _lhs
        The left hand side non-terminal.
      • _rhs_prec

        protected int _rhs_prec
        The precedence of the rule
      • _rhs_assoc

        protected int _rhs_assoc
      • _rhs

        protected production_part[] _rhs
        A collection of parts for the right hand side.
      • _rhs_length

        protected int _rhs_length
        How much of the right hand side array we are presently using.
      • _action

        protected action_part _action
        An action_part containing code for the action to be performed when we reduce with this production.
      • _index

        protected int _index
        Index number of the production.
      • _num_reductions

        protected int _num_reductions
        Count of number of reductions using this production.
      • _nullable_known

        protected boolean _nullable_known
        Is the nullability of the production known or unknown?
      • _nullable

        protected boolean _nullable
        Nullability of the production (can it derive the empty string).
      • _first_set

        protected terminal_set _first_set
        First set of the production. This is the set of terminals that could appear at the front of some string derived from this production.
    • Constructor Detail

      • production

        public production​(non_terminal lhs_sym,
                          production_part[] rhs_parts,
                          int rhs_l,
                          java.lang.String action_str)
                   throws internal_error
        Full constructor. This constructor accepts a LHS non terminal, an array of RHS parts (including terminals, non terminals, and actions), and a string for a final reduce action. It does several manipulations in the process of creating a production object. After some validity checking it translates labels that appear in actions into code for accessing objects on the runtime parse stack. It them merges adjacent actions if they appear and moves any trailing action into the final reduce actions string. Next it removes any embedded actions by factoring them out with new action productions. Finally it assigns a unique index to the production.

        Factoring out of actions is accomplished by creating new "hidden" non terminals. For example if the production was originally:

            A ::= B {action} C D
          
        then it is factored into two productions:
            A ::= B X C D
            X ::= {action}
          
        (where X is a unique new non terminal). This has the effect of placing all actions at the end where they can be handled as part of a reduce by the parser.
        Throws:
        internal_error
    • Method Detail

      • all

        public static java.util.Enumeration all()
        Access to all productions.
      • find

        public static production find​(int indx)
        Lookup a production by index.
      • clear

        public static void clear()
      • number

        public static int number()
        Total number of productions.
      • lhs

        public symbol_part lhs()
        The left hand side non-terminal.
      • precedence_num

        public int precedence_num()
        Access to the precedence of the rule
      • precedence_side

        public int precedence_side()
      • set_precedence_num

        public void set_precedence_num​(int prec_num)
        Setting the precedence of a rule
      • set_precedence_side

        public void set_precedence_side​(int prec_side)
      • rhs_length

        public int rhs_length()
        How much of the right hand side array we are presently using.
      • action

        public action_part action()
        An action_part containing code for the action to be performed when we reduce with this production.
      • index

        public int index()
        Index number of the production.
      • num_reductions

        public int num_reductions()
        Count of number of reductions using this production.
      • note_reduction_use

        public void note_reduction_use()
        Increment the count of reductions with this non-terminal
      • nullable_known

        public boolean nullable_known()
        Is the nullability of the production known or unknown?
      • nullable

        public boolean nullable()
        Nullability of the production (can it derive the empty string).
      • first_set

        public terminal_set first_set()
        First set of the production. This is the set of terminals that could appear at the front of some string derived from this production.
      • is_id_start

        protected static boolean is_id_start​(char c)
        Determine if a given character can be a label id starter.
        Parameters:
        c - the character in question.
      • is_id_char

        protected static boolean is_id_char​(char c)
        Determine if a character can be in a label id.
        Parameters:
        c - the character in question.
      • make_declaration

        protected java.lang.String make_declaration​(java.lang.String labelname,
                                                    java.lang.String stack_type,
                                                    int offset)
        Return label declaration code
        Parameters:
        labelname - the label name
        stack_type - the stack type of label?
      • declare_labels

        protected java.lang.String declare_labels​(production_part[] rhs,
                                                  int rhs_len,
                                                  java.lang.String final_action)
        Declare label names as valid variables within the action string
        Parameters:
        rhs - array of RHS parts.
        rhs_len - how much of rhs to consider valid.
        final_action - the final action string of the production.
        lhs_type - the object type associated with the LHS symbol.
      • merge_adjacent_actions

        protected int merge_adjacent_actions​(production_part[] rhs_parts,
                                             int len)
        Helper routine to merge adjacent actions in a set of RHS parts
        Parameters:
        rhs_parts - array of RHS parts.
        len - amount of that array that is valid.
        Returns:
        remaining valid length.
      • strip_trailing_action

        protected action_part strip_trailing_action​(production_part[] rhs_parts,
                                                    int len)
        Helper routine to strip a trailing action off rhs and return it
        Parameters:
        rhs_parts - array of RHS parts.
        len - how many of those are valid.
        Returns:
        the removed action part.
      • remove_embedded_actions

        protected void remove_embedded_actions()
                                        throws internal_error
        Remove all embedded actions from a production by factoring them out into individual action production using new non terminals. if the original production was:
            A ::= B {action1} C {action2} D 
          
        then it will be factored into:
            A ::= B NT$1 C NT$2 D
            NT$1 ::= {action1}
            NT$2 ::= {action2}
          
        where NT$1 and NT$2 are new system created non terminals.
        Throws:
        internal_error
      • check_nullable

        public boolean check_nullable()
                               throws internal_error
        Check to see if the production (now) appears to be nullable. A production is nullable if its RHS could derive the empty string. This results when the RHS is empty or contains only non terminals which themselves are nullable.
        Throws:
        internal_error
      • check_first_set

        public terminal_set check_first_set()
                                     throws internal_error
        Update (and return) the first set based on current NT firsts. This assumes that nullability has already been computed for all non terminals and productions.
        Throws:
        internal_error
      • equals

        public boolean equals​(production other)
        Equality comparison.
      • equals

        public boolean equals​(java.lang.Object other)
        Generic equality comparison.
        Overrides:
        equals in class java.lang.Object
      • hashCode

        public int hashCode()
        Produce a hash code.
        Overrides:
        hashCode in class java.lang.Object
      • toString

        public java.lang.String toString()
        Convert to a string.
        Overrides:
        toString in class java.lang.Object