Esempio n. 1
0
        /*-----------------------------------------------------------*/
        /*--- General Methods ---------------------------------------*/
        /*-----------------------------------------------------------*/

        /// <summary>Add a transition out of this state to another.
        /// </summary>
        /// <param name="on_sym">the symbol the transition is under.
        /// </param>
        /// <param name="to_st"> the state the transition goes to.
        ///
        /// </param>
        public virtual void  add_transition(symbol on_sym, lalr_state to_st)
        {
            lalr_transition trans;

            /* create a new transition object and put it in our list */
            trans        = new lalr_transition(on_sym, to_st, _transitions);
            _transitions = trans;
        }
Esempio n. 2
0
        /*-----------------------------------------------------------*/
        /*--- Constructor(s) ----------------------------------------*/
        /*-----------------------------------------------------------*/
        /// <summary>Full constructor.
        /// </summary>
        /// <param name="on_sym"> symbol we are transitioning on.
        /// </param>
        /// <param name="to_st">  state we transition to.
        /// </param>
        /// <param name="nxt">    next transition in linked list.
        /// 
        /// </param>
        public lalr_transition(symbol on_sym, lalr_state to_st, lalr_transition nxt)
        {
            /* sanity checks */
            if (on_sym == null)
                throw new internal_error("Attempt to create transition on null symbol");
            if (to_st == null)
                throw new internal_error("Attempt to create transition to null state");

            /* initialize */
            _on_symbol = on_sym;
            _to_state = to_st;
            _next = nxt;
        }
Esempio n. 3
0
        /*-----------------------------------------------------------*/
        /*--- Constructor(s) ----------------------------------------*/
        /*-----------------------------------------------------------*/

        /// <summary>Full constructor.
        /// </summary>
        /// <param name="on_sym"> symbol we are transitioning on.
        /// </param>
        /// <param name="to_st">  state we transition to.
        /// </param>
        /// <param name="nxt">    next transition in linked list.
        ///
        /// </param>
        public lalr_transition(symbol on_sym, lalr_state to_st, lalr_transition nxt)
        {
            /* sanity checks */
            if (on_sym == null)
            {
                throw new internal_error("Attempt to create transition on null symbol");
            }
            if (to_st == null)
            {
                throw new internal_error("Attempt to create transition to null state");
            }

            /* initialize */
            _on_symbol = on_sym;
            _to_state  = to_st;
            _next      = nxt;
        }
Esempio n. 4
0
        /*-----------------------------------------------------------*/
        /*--- General Methods ---------------------------------------*/
        /*-----------------------------------------------------------*/
        /// <summary>Add a transition out of this state to another.
        /// </summary>
        /// <param name="on_sym">the symbol the transition is under.
        /// </param>
        /// <param name="to_st"> the state the transition goes to.
        /// 
        /// </param>
        public virtual void add_transition(symbol on_sym, lalr_state to_st)
        {
            lalr_transition trans;

            /* create a new transition object and put it in our list */
            trans = new lalr_transition(on_sym, to_st, _transitions);
            _transitions = trans;
        }
Esempio n. 5
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);
            }
        }