Beispiel #1
0
        /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/

        /// <summary>Remove (set subtract) a complete set.
        /// </summary>
        /// <param name="other">the set we are removing.
        ///
        /// </param>
        public virtual void  remove(symbol_set other)
        {
            not_null(other);

            /* walk down the other set and do the removes individually */
            //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 e = other.all(); e.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"'
                remove((symbol)e.Current);
            }
        }
Beispiel #2
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(symbol_set other)
        {
            not_null(other);

            /* walk down our set and make sure every element is in the other */
            //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 e = all(); e.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"'
                if (!other.contains((symbol)e.Current))
                {
                    return(false);
                }
            }

            /* they were all there */
            return(true);
        }
Beispiel #3
0
        /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/

        /// <summary>Equality comparison.
        /// </summary>
        public virtual bool equals(symbol_set other)
        {
            if (other == null || other.size() != size())
            {
                return(false);
            }

            /* once we know they are the same size, then improper subset does test */
            try
            {
                return(is_subset_of(other));
            }
            catch (internal_error e)
            {
                /* can't throw the error (because super class doesn't), so we crash */
                e.crash();
                return(false);
            }
        }
Beispiel #4
0
 /// <summary>Constructor for cloning from another set.
 /// </summary>
 /// <param name="other">the set we are cloning from.
 ///
 /// </param>
 public symbol_set(symbol_set other)
 {
     InitBlock();
     not_null(other);
     _all = (System.Collections.Hashtable)other._all.Clone();
 }
Beispiel #5
0
        /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/

        /// <summary>Determine if this set is an (improper) superset of another.
        /// </summary>
        /// <param name="other">the set we are are testing against.
        ///
        /// </param>
        public virtual bool is_superset_of(symbol_set other)
        {
            not_null(other);
            return(other.is_subset_of(this));
        }
Beispiel #6
0
 /// <summary>Constructor for cloning from another set. 
 /// </summary>
 /// <param name="other">the set we are cloning from.
 /// 
 /// </param>
 public symbol_set(symbol_set other)
 {
     InitBlock();
     not_null(other);
     _all = (System.Collections.Hashtable) other._all.Clone();
 }
Beispiel #7
0
        /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
        /// <summary>Add (union) in a complete set.  
        /// </summary>
        /// <param name="other">the set we are adding in.
        /// </param>
        /// <returns>true if this changes the set. 
        /// 
        /// </returns>
        public virtual bool add(symbol_set other)
        {
            bool result = false;

            not_null(other);

            /* walk down the other set and do the adds individually */
            //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 e = other.all(); e.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"'
                result = add((symbol) e.Current) || result;
            }

            return result;
        }
Beispiel #8
0
 /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
 /// <summary>Determine if this set is an (improper) superset of another. 
 /// </summary>
 /// <param name="other">the set we are are testing against.
 /// 
 /// </param>
 public virtual bool is_superset_of(symbol_set other)
 {
     not_null(other);
     return other.is_subset_of(this);
 }
Beispiel #9
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(symbol_set other)
        {
            not_null(other);

            /* walk down our set and make sure every element is in the other */
            //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 e = all(); e.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"'
                if (!other.contains((symbol) e.Current))
                    return false;
            }

            /* they were all there */
            return true;
        }
Beispiel #10
0
        /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
        /// <summary>Equality comparison. 
        /// </summary>
        public virtual bool equals(symbol_set other)
        {
            if (other == null || other.size() != size())
                return false;

            /* once we know they are the same size, then improper subset does test */
            try
            {
                return is_subset_of(other);
            }
            catch (internal_error e)
            {
                /* can't throw the error (because super class doesn't), so we crash */
                e.crash();
                return false;
            }
        }
Beispiel #11
0
        /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
        /// <summary>Build an LALR viable prefix recognition machine given a start 
        /// production.  This method operates by first building a start state
        /// from the start production (based on a single item with the dot at
        /// the beginning and EOF as expected lookahead).  Then for each state
        /// it attempts to extend the machine by creating transitions out of
        /// the state to new or existing states.  When considering extension
        /// from a state we make a transition on each symbol that appears before
        /// the dot in some item.  For example, if we have the items: <pre>
        /// [A ::= a b * X c, {d,e}]
        /// [B ::= a b * X d, {a,b}]
        /// </pre>
        /// in some state, then we would be making a transition under X to a new
        /// state.  This new state would be formed by a "kernel" of items 
        /// corresponding to moving the dot past the X.  In this case: <pre>
        /// [A ::= a b X * c, {d,e}]
        /// [B ::= a b X * Y, {a,b}]
        /// </pre>
        /// The full state would then be formed by "closing" this kernel set of 
        /// items so that it included items that represented productions of things
        /// the parser was now looking for.  In this case we would items 
        /// corresponding to productions of Y, since various forms of Y are expected
        /// next when in this state (see lalr_item_set.compute_closure() for details 
        /// on closure). <p>
        /// *
        /// The process of building the viable prefix recognizer terminates when no
        /// new states can be added.  However, in order to build a smaller number of
        /// states (i.e., corresponding to LALR rather than canonical LR) the state 
        /// building process does not maintain full loookaheads in all items.  
        /// Consequently, after the machine is built, we go back and propagate 
        /// lookaheads through the constructed machine using a call to 
        /// propagate_all_lookaheads().  This makes use of propagation links 
        /// constructed during the closure and transition process.
        /// *
        /// </summary>
        /// <param name="start_prod">the start production of the grammar
        /// </param>
        /// <seealso cref="   CUP.lalr_item_set#compute_closure
        /// "/>
        /// <seealso cref="   CUP.lalr_state#propagate_all_lookaheads
        /// 
        /// "/>
        public static lalr_state build_machine(production start_prod)
        {
            lalr_state start_state;
            lalr_item_set start_items;
            lalr_item_set new_items;
            lalr_item_set linked_items;
            lalr_item_set kernel;
            CUP.runtime.SymbolStack work_stack = new CUP.runtime.SymbolStack();
            lalr_state st, new_st;
            symbol_set outgoing;
            lalr_item itm, new_itm, existing, fix_itm;
            symbol sym, sym2;
            System.Collections.IEnumerator i, s, fix;

            /* sanity check */
            if (start_prod == null)
                throw new internal_error("Attempt to build viable prefix recognizer using a null production");

            /* build item with dot at front of start production and EOF lookahead */
            start_items = new lalr_item_set();

            itm = new lalr_item(start_prod);
            itm.lookahead().add(terminal.EOF);

            start_items.add(itm);

            /* create copy the item set to form the kernel */
            kernel = new lalr_item_set(start_items);

            /* create the closure from that item set */
            start_items.compute_closure();

            /* build a state out of that item set and put it in our work set */
            start_state = new lalr_state(start_items);
            System.Object temp_object;
            temp_object = start_state;
            System.Object generatedAux = temp_object;
            work_stack.Push(temp_object);

            /* enter the state using the kernel as the key */
            SupportClass.PutElement(_all_kernels, kernel, start_state);

            /* continue looking at new states until we have no more work to do */
            while (!(work_stack.Count == 0))
            {
                /* remove a state from the work set */
                st = (lalr_state) work_stack.Pop();

                /* gather up all the symbols that appear before dots */
                outgoing = new symbol_set();
                //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 (i = st.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;

                    /* add the symbol before the dot (if any) to our collection */
                    sym = itm.symbol_after_dot();
                    if (sym != null)
                        outgoing.add(sym);
                }

                /* now create a transition out for each individual symbol */
                //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 (s = outgoing.all(); s.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"'
                    sym = (symbol) s.Current;

                    /* will be keeping the set of items with propagate links */
                    linked_items = new lalr_item_set();

                    /* gather up shifted versions of all the items that have this
                    symbol before the dot */
                    new_items = new lalr_item_set();
                    //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 (i = st.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 this is the symbol we are working on now, add to set */
                        sym2 = itm.symbol_after_dot();
                        if (sym.Equals(sym2))
                        {
                            /* add to the kernel of the new state */
                            new_items.add(itm.shift());

                            /* remember that itm has propagate link to it */
                            linked_items.add(itm);
                        }
                    }

                    /* use new items as state kernel */
                    kernel = new lalr_item_set(new_items);

                    /* have we seen this one already? */
                    new_st = (lalr_state) _all_kernels[kernel];

                    /* if we haven't, build a new state out of the item set */
                    if (new_st == null)
                    {
                        /* compute closure of the kernel for the full item set */
                        new_items.compute_closure();

                        /* build the new state */
                        new_st = new lalr_state(new_items);

                        /* add the new state to our work set */
                        System.Object temp_object2;
                        temp_object2 = new_st;
                        System.Object generatedAux2 = temp_object2;
                        work_stack.Push(temp_object2);

                        /* put it in our kernel table */
                        SupportClass.PutElement(_all_kernels, kernel, new_st);
                    }
                    else
                    {
                        /* walk through the items that have links to the new 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 (fix = linked_items.all(); fix.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"'
                            fix_itm = (lalr_item) fix.Current;

                            /* look at each propagate link out of that item */
                             for (int l = 0; l < fix_itm.propagate_items().Count; l++)
                            {
                                /* pull out item linked to in the new state */
                                new_itm = (lalr_item) (fix_itm.propagate_items().Peek(fix_itm.propagate_items().Count - (l + 1)));

                                /* find corresponding item in the existing state */
                                existing = new_st.items().find(new_itm);

                                /* fix up the item so it points to the existing set */
                                if (existing != null)
                                    fix_itm.propagate_items()[l] = existing;
                            }
                        }
                    }

                    /* add a transition from current state to that state */
                    st.add_transition(sym, new_st);
                }
            }

            /* all done building states */

            /* propagate complete lookahead sets throughout the states */
            propagate_all_lookaheads();

            return start_state;
        }
Beispiel #12
0
        /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/

        /// <summary>Build an LALR viable prefix recognition machine given a start
        /// production.  This method operates by first building a start state
        /// from the start production (based on a single item with the dot at
        /// the beginning and EOF as expected lookahead).  Then for each state
        /// it attempts to extend the machine by creating transitions out of
        /// the state to new or existing states.  When considering extension
        /// from a state we make a transition on each symbol that appears before
        /// the dot in some item.  For example, if we have the items: <pre>
        /// [A ::= a b * X c, {d,e}]
        /// [B ::= a b * X d, {a,b}]
        /// </pre>
        /// in some state, then we would be making a transition under X to a new
        /// state.  This new state would be formed by a "kernel" of items
        /// corresponding to moving the dot past the X.  In this case: <pre>
        /// [A ::= a b X * c, {d,e}]
        /// [B ::= a b X * Y, {a,b}]
        /// </pre>
        /// The full state would then be formed by "closing" this kernel set of
        /// items so that it included items that represented productions of things
        /// the parser was now looking for.  In this case we would items
        /// corresponding to productions of Y, since various forms of Y are expected
        /// next when in this state (see lalr_item_set.compute_closure() for details
        /// on closure). <p>
        /// *
        /// The process of building the viable prefix recognizer terminates when no
        /// new states can be added.  However, in order to build a smaller number of
        /// states (i.e., corresponding to LALR rather than canonical LR) the state
        /// building process does not maintain full loookaheads in all items.
        /// Consequently, after the machine is built, we go back and propagate
        /// lookaheads through the constructed machine using a call to
        /// propagate_all_lookaheads().  This makes use of propagation links
        /// constructed during the closure and transition process.
        /// *
        /// </summary>
        /// <param name="start_prod">the start production of the grammar
        /// </param>
        /// <seealso cref="   CUP.lalr_item_set#compute_closure
        /// "/>
        /// <seealso cref="   CUP.lalr_state#propagate_all_lookaheads
        ///
        /// "/>

        public static lalr_state build_machine(production start_prod)
        {
            lalr_state    start_state;
            lalr_item_set start_items;
            lalr_item_set new_items;
            lalr_item_set linked_items;
            lalr_item_set kernel;

            CUP.runtime.SymbolStack work_stack = new CUP.runtime.SymbolStack();
            lalr_state st, new_st;
            symbol_set outgoing;
            lalr_item  itm, new_itm, existing, fix_itm;
            symbol     sym, sym2;

            System.Collections.IEnumerator i, s, fix;

            /* sanity check */
            if (start_prod == null)
            {
                throw new internal_error("Attempt to build viable prefix recognizer using a null production");
            }

            /* build item with dot at front of start production and EOF lookahead */
            start_items = new lalr_item_set();

            itm = new lalr_item(start_prod);
            itm.lookahead().add(terminal.EOF);

            start_items.add(itm);

            /* create copy the item set to form the kernel */
            kernel = new lalr_item_set(start_items);

            /* create the closure from that item set */
            start_items.compute_closure();

            /* build a state out of that item set and put it in our work set */
            start_state = new lalr_state(start_items);
            System.Object temp_object;
            temp_object = start_state;
            System.Object generatedAux = temp_object;
            work_stack.Push(temp_object);

            /* enter the state using the kernel as the key */
            SupportClass.PutElement(_all_kernels, kernel, start_state);

            /* continue looking at new states until we have no more work to do */
            while (!(work_stack.Count == 0))
            {
                /* remove a state from the work set */
                st = (lalr_state)work_stack.Pop();

                /* gather up all the symbols that appear before dots */
                outgoing = new symbol_set();
                //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 (i = st.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;

                    /* add the symbol before the dot (if any) to our collection */
                    sym = itm.symbol_after_dot();
                    if (sym != null)
                    {
                        outgoing.add(sym);
                    }
                }

                /* now create a transition out for each individual symbol */
                //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 (s = outgoing.all(); s.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"'
                    sym = (symbol)s.Current;

                    /* will be keeping the set of items with propagate links */
                    linked_items = new lalr_item_set();

                    /* gather up shifted versions of all the items that have this
                     * symbol before the dot */
                    new_items = new lalr_item_set();
                    //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 (i = st.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 this is the symbol we are working on now, add to set */
                        sym2 = itm.symbol_after_dot();
                        if (sym.Equals(sym2))
                        {
                            /* add to the kernel of the new state */
                            new_items.add(itm.shift());

                            /* remember that itm has propagate link to it */
                            linked_items.add(itm);
                        }
                    }

                    /* use new items as state kernel */
                    kernel = new lalr_item_set(new_items);

                    /* have we seen this one already? */
                    new_st = (lalr_state)_all_kernels[kernel];

                    /* if we haven't, build a new state out of the item set */
                    if (new_st == null)
                    {
                        /* compute closure of the kernel for the full item set */
                        new_items.compute_closure();

                        /* build the new state */
                        new_st = new lalr_state(new_items);

                        /* add the new state to our work set */
                        System.Object temp_object2;
                        temp_object2 = new_st;
                        System.Object generatedAux2 = temp_object2;
                        work_stack.Push(temp_object2);

                        /* put it in our kernel table */
                        SupportClass.PutElement(_all_kernels, kernel, new_st);
                    }
                    else
                    {
                        /* walk through the items that have links to the new 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 (fix = linked_items.all(); fix.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"'
                            fix_itm = (lalr_item)fix.Current;

                            /* look at each propagate link out of that item */
                            for (int l = 0; l < fix_itm.propagate_items().Count; l++)
                            {
                                /* pull out item linked to in the new state */
                                new_itm = (lalr_item)(fix_itm.propagate_items().Peek(fix_itm.propagate_items().Count - (l + 1)));

                                /* find corresponding item in the existing state */
                                existing = new_st.items().find(new_itm);

                                /* fix up the item so it points to the existing set */
                                if (existing != null)
                                {
                                    fix_itm.propagate_items()[l] = existing;
                                }
                            }
                        }
                    }

                    /* add a transition from current state to that state */
                    st.add_transition(sym, new_st);
                }
            }

            /* all done building states */

            /* propagate complete lookahead sets throughout the states */
            propagate_all_lookaheads();

            return(start_state);
        }