Example #1
0
 /*-----------------------------------------------------------*/
 /*--- Constructor(s) ----------------------------------------*/
 /*-----------------------------------------------------------*/
 /// <summary>Full constructor. 
 /// </summary>
 /// <param name="prod">the production for the item.
 /// </param>
 /// <param name="pos"> the position of the "dot" within the production.
 /// </param>
 /// <param name="look">the set of lookahead symbols.
 /// 
 /// </param>
 public lalr_item(production prod, int pos, terminal_set look)
     : base(prod, pos)
 {
     _lookahead = look;
     _propagate_items = new CUP.runtime.SymbolStack();
     needs_propagation = true;
 }
Example #2
0
 /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
 /// <summary>Constructor with default position (dot at start). 
 /// </summary>
 /// <param name="prod">the production for the item.
 /// </param>
 /// <param name="look">the set of lookahead symbols.
 /// 
 /// </param>
 public lalr_item(production prod, terminal_set look)
     : this(prod, 0, look)
 {
 }
Example #3
0
        /*-----------------------------------------------------------*/
        /*--- General Methods ---------------------------------------*/
        /*-----------------------------------------------------------*/
        /// <summary>Propagate incoming lookaheads through this item to others need to 
        /// be changed.
        /// </summary>
        /// <param name="incoming">symbols to potentially be added to lookahead of this item.
        /// 
        /// </param>
        public virtual void propagate_lookaheads(terminal_set incoming)
        {
            bool change = false;

            /* if we don't need to propagate, then bail out now */
            if (!needs_propagation && (incoming == null || incoming.empty()))
                return ;

            /* if we have null incoming, treat as an empty set */
            if (incoming != null)
            {
                /* add the incoming to the lookahead of this item */
                change = lookahead().add(incoming);
            }

            /* if we changed or need it anyway, propagate across our links */
            if (change || needs_propagation)
            {
                /* don't need to propagate again */
                needs_propagation = false;

                /* propagate our lookahead into each item we are linked to */
                 for (int i = 0; i < propagate_items().Count; i++)
                    ((lalr_item) (propagate_items().Peek(propagate_items().Count - (i + 1)))).propagate_lookaheads(lookahead());
            }
        }
Example #4
0
 private void InitBlock()
 {
     _productions = new System.Collections.Hashtable(11);
     _first_set = new terminal_set();
 }
Example #5
0
        /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
        /// <summary>Calculate lookahead representing symbols that could appear after the
        /// symbol that the dot is currently in front of.  Note: this routine must
        /// not be invoked before first sets and nullability has been calculated
        /// for all non terminals. 
        /// </summary>
        public virtual terminal_set calc_lookahead(terminal_set lookahead_after)
        {
            terminal_set result;
            int pos;
            production_part part;
            symbol sym;

            /* sanity check */
            if (dot_at_end())
                throw new internal_error("Attempt to calculate a lookahead set with a completed item");

            /* start with an empty result */
            result = new terminal_set();

            /* consider all nullable symbols after the one to the right of the dot */
             for (pos = dot_pos() + 1; pos < the_production().rhs_length(); pos++)
            {
                part = the_production().rhs(pos);

                /* consider what kind of production part it is -- skip actions */
                if (!part.is_action())
                {
                    sym = ((symbol_part) part).the_symbol();

                    /* if its a terminal add it in and we are done */
                    if (!sym.is_non_term())
                    {
                        result.add((terminal) sym);
                        return result;
                    }
                    else
                    {
                        /* otherwise add in first set of the non terminal */
                        result.add(((non_terminal) sym).first_set());

                        /* if its nullable we continue adding, if not, we are done */
                        if (!((non_terminal) sym).nullable())
                            return result;
                    }
                }
            }

            /* if we get here everything past the dot was nullable
            we add in the lookahead for after the production and we are done */
            result.add(lookahead_after);
            return result;
        }
Example #6
0
        /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
        /// <summary>Fill in the parse table entries for this state.  There are two 
        /// parse tables that encode the viable prefix recognition machine, an 
        /// action table and a reduce-goto table.  The rows in each table 
        /// correspond to states of the machine.  The columns of the action table
        /// are indexed by terminal symbols and correspond to either transitions 
        /// out of the state (shift entries) or reductions from the state to some
        /// previous state saved on the stack (reduce entries).  All entries in the
        /// action table that are not shifts or reduces, represent errors.    The
        /// reduce-goto table is indexed by non terminals and represents transitions 
        /// out of a state on that non-terminal.<p>
        /// Conflicts occur if more than one action needs to go in one entry of the
        /// action table (this cannot happen with the reduce-goto table).  Conflicts
        /// are resolved by always shifting for shift/reduce conflicts and choosing
        /// the lowest numbered production (hence the one that appeared first in
        /// the specification) in reduce/reduce conflicts.  All conflicts are 
        /// reported and if more conflicts are detected than were declared by the
        /// user, code generation is aborted.
        /// *
        /// </summary>
        /// <param name="act_table">   the action table to put entries in.
        /// </param>
        /// <param name="reduce_table">the reduce-goto table to put entries in.
        /// 
        /// </param>
        public virtual void build_table_entries(parse_action_table act_table, parse_reduce_table reduce_table)
        {
            parse_action_row our_act_row;
            parse_reduce_row our_red_row;
            lalr_item itm;
            parse_action act, other_act;
            symbol sym;
            terminal_set conflict_set = new terminal_set();

            /* pull out our rows from the tables */
            our_act_row = act_table.under_state[index()];
            our_red_row = reduce_table.under_state[index()];

            /* consider each item in our state */
            //UPGRADE_TODO: method 'java.util.Enumeration.hasMoreElements' was converted to ' ' which has a different behavior. 'ms-help://MS.VSCC/commoner/redir/redirect.htm?keyword="jlca1073_javautilEnumerationhasMoreElements"'
             for (System.Collections.IEnumerator i = items().all(); i.MoveNext(); )
            {
                //UPGRADE_TODO: method 'java.util.Enumeration.nextElement' was converted to ' ' which has a different behavior. 'ms-help://MS.VSCC/commoner/redir/redirect.htm?keyword="jlca1073_javautilEnumerationnextElement"'
                itm = (lalr_item) i.Current;

                /* if its completed (dot at end) then reduce under the lookahead */
                if (itm.dot_at_end())
                {
                    act = new reduce_action(itm.the_production());

                    /* consider each lookahead symbol */
                     for (int t = 0; t < terminal.number(); t++)
                    {
                        /* skip over the ones not in the lookahead */
                        if (!itm.lookahead().contains(t))
                            continue;

                        /* if we don't already have an action put this one in */
                        if (our_act_row.under_term[t].kind() == parse_action.ERROR)
                        {
                            our_act_row.under_term[t] = act;
                        }
                        else
                        {
                            /* we now have at least one conflict */
                            terminal term = terminal.find(t);
                            other_act = our_act_row.under_term[t];

                            /* if the other act was not a shift */
                            if ((other_act.kind() != parse_action.SHIFT) && (other_act.kind() != parse_action.NONASSOC))
                            {
                                /* if we have lower index hence priority, replace it*/
                                if (itm.the_production().index() < ((reduce_action) other_act).reduce_with().index())
                                {
                                    /* replace the action */
                                    our_act_row.under_term[t] = act;
                                }
                            }
                            else
                            {
                                /*  Check precedences,see if problem is correctable */
                                if (fix_with_precedence(itm.the_production(), t, our_act_row, act))
                                {
                                    term = null;
                                }
                            }
                            if (term != null)
                            {

                                conflict_set.add(term);
                            }
                        }
                    }
                }
            }

            /* consider each outgoing transition */
             for (lalr_transition trans = transitions(); trans != null; trans = trans.next())
            {
                /* if its on an terminal add a shift entry */
                sym = trans.on_symbol();
                if (!sym.is_non_term())
                {
                    act = new shift_action(trans.to_state());

                    /* if we don't already have an action put this one in */
                    if (our_act_row.under_term[sym.index()].kind() == parse_action.ERROR)
                    {
                        our_act_row.under_term[sym.index()] = act;
                    }
                    else
                    {
                        /* we now have at least one conflict */
                        production p = ((reduce_action) our_act_row.under_term[sym.index()]).reduce_with();

                        /* shift always wins */
                        if (!fix_with_precedence(p, sym.index(), our_act_row, act))
                        {
                            our_act_row.under_term[sym.index()] = act;
                            conflict_set.add(terminal.find(sym.index()));
                        }
                    }
                }
                else
                {
                    /* for non terminals add an entry to the reduce-goto table */
                    our_red_row.under_non_term[sym.index()] = trans.to_state();
                }
            }

            /* if we end up with conflict(s), report them */
            if (!conflict_set.empty())
                report_conflicts(conflict_set);
        }
Example #7
0
        /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
        /// <summary>Produce warning messages for all conflicts found in this state.  
        /// </summary>
        protected internal virtual void report_conflicts(terminal_set conflict_set)
        {
            lalr_item itm, compare;
            //symbol shift_sym;

            bool after_itm;

            /* consider each element */
            //UPGRADE_TODO: method 'java.util.Enumeration.hasMoreElements' was converted to ' ' which has a different behavior. 'ms-help://MS.VSCC/commoner/redir/redirect.htm?keyword="jlca1073_javautilEnumerationhasMoreElements"'
             for (System.Collections.IEnumerator itms = items().all(); itms.MoveNext(); )
            {
                //UPGRADE_TODO: method 'java.util.Enumeration.nextElement' was converted to ' ' which has a different behavior. 'ms-help://MS.VSCC/commoner/redir/redirect.htm?keyword="jlca1073_javautilEnumerationnextElement"'
                itm = (lalr_item) itms.Current;

                /* clear the S/R conflict set for this item */

                /* if it results in a reduce, it could be a conflict */
                if (itm.dot_at_end())
                {
                    /* not yet after itm */
                    after_itm = false;

                    /* compare this item against all others looking for conflicts */
                    //UPGRADE_TODO: method 'java.util.Enumeration.hasMoreElements' was converted to ' ' which has a different behavior. 'ms-help://MS.VSCC/commoner/redir/redirect.htm?keyword="jlca1073_javautilEnumerationhasMoreElements"'
                     for (System.Collections.IEnumerator comps = items().all(); comps.MoveNext(); )
                    {
                        //UPGRADE_TODO: method 'java.util.Enumeration.nextElement' was converted to ' ' which has a different behavior. 'ms-help://MS.VSCC/commoner/redir/redirect.htm?keyword="jlca1073_javautilEnumerationnextElement"'
                        compare = (lalr_item) comps.Current;

                        /* if this is the item, next one is after it */
                        if (itm == compare)
                            after_itm = true;

                        /* only look at it if its not the same item */
                        if (itm != compare)
                        {
                            /* is it a reduce */
                            if (compare.dot_at_end())
                            {
                                /* only look at reduces after itm */
                                if (after_itm)
                                    if (compare.lookahead().intersects(itm.lookahead()))
                                        report_reduce_reduce(itm, compare);
                            }
                        }
                    }
                    /* report S/R conflicts under all the symbols we conflict under */
                     for (int t = 0; t < terminal.number(); t++)
                        if (conflict_set.contains(t))
                            report_shift_reduce(itm, t);
                }
            }
        }
Example #8
0
 /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
 /// <summary>Constructor for cloning from another set. 
 /// </summary>
 /// <param name="other">the set we are cloning from.
 /// 
 /// </param>
 public terminal_set(terminal_set other)
 {
     not_null(other);
     _elements = (System.Collections.BitArray) other._elements.Clone();
 }
Example #9
0
        /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
        /// <summary>Add (union) in a complete set.  
        /// </summary>
        /// <param name="other">the set being added.
        /// </param>
        /// <returns>true if this changes the set.
        /// 
        /// </returns>
        public virtual bool add(terminal_set other)
        {
            not_null(other);

            /* make a copy */
            System.Collections.BitArray copy = (System.Collections.BitArray) _elements.Clone();

            /* or in the other set */
            //UPGRADE_NOTE: In .NET BitArrays must be of the same size to allow the 'System.Collections.BitArray.Or' operation. 'ms-help://MS.VSCC/commoner/redir/redirect.htm?keyword="jlca1083"'
            _elements = _elements.Or(other._elements);

            /* changed if we are not the same as the copy */
            //UPGRADE_TODO: method 'java.util.BitSet.equals' was converted to ' ' which has a different behavior. 'ms-help://MS.VSCC/commoner/redir/redirect.htm?keyword="jlca1073_javautilBitSetequals_javalangObject"'
            return !BitArraysEqual(_elements, copy);
            // _elements.Equals(copy);
        }
Example #10
0
 /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
 /// <summary>Determine if this set is an (improper) superset of another.
 /// </summary>
 /// <param name="other">the set we are testing against.
 /// 
 /// </param>
 public virtual bool is_superset_of(terminal_set other)
 {
     not_null(other);
     return other.is_subset_of(this);
 }
Example #11
0
        /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
        /// <summary>Determine if this set is an (improper) subset of another.
        /// </summary>
        /// <param name="other">the set we are testing against.
        /// 
        /// </param>
        public virtual bool is_subset_of(terminal_set other)
        {
            not_null(other);

            /* make a copy of the other set */
            System.Collections.BitArray copy_other = (System.Collections.BitArray) other._elements.Clone();

            /* and or in */
            copy_other = copy_other.Or(_elements);

            /* if it hasn't changed, we were a subset */
            return BitArraysEqual(copy_other, other._elements);
                /// copy_other.Equals(other._elements);
        }
Example #12
0
        /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
        /// <summary>Determine if this set intersects another.
        /// </summary>
        /// <param name="other">the other set in question.
        /// 
        /// </param>
        public virtual bool intersects(terminal_set other)
        {
            not_null(other);

            /* make a copy of the other set */
            System.Collections.BitArray copy = (System.Collections.BitArray) other._elements.Clone();

            /* xor out our values */
            //UPGRADE_NOTE: In .NET BitArrays must be of the same size to allow the 'System.Collections.BitArray.Xor' operation. 'ms-help://MS.VSCC/commoner/redir/redirect.htm?keyword="jlca1083"'
            copy = copy.Xor(this._elements);

            /* see if its different */
            //UPGRADE_TODO: method 'java.util.BitSet.equals' was converted to ' ' which has a different behavior. 'ms-help://MS.VSCC/commoner/redir/redirect.htm?keyword="jlca1073_javautilBitSetequals_javalangObject"'
            return !BitArraysEqual(copy, other._elements);
            // copy.Equals(other._elements);
        }
Example #13
0
 /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
 /// <summary>Equality comparison. 
 /// </summary>
 public virtual bool equals(terminal_set other)
 {
     if (other == null)
         return false;
     else
     {
         //UPGRADE_TODO: method 'java.util.BitSet.equals' was converted to ' ' which has a different behavior. 'ms-help://MS.VSCC/commoner/redir/redirect.htm?keyword="jlca1073_javautilBitSetequals_javalangObject"'
         return _elements.Equals(other._elements);
     }
 }
Example #14
0
 private void InitBlock()
 {
     _first_set = new terminal_set();
 }