public ConfigurableLrTable(ILrDfa dfa, RuntimeOptions flags)
        {
            this.grammar = dfa.GrammarAnalysis;

            this.data = new MutableTable<int>(dfa.States.Length, grammar.Symbols.Count);

            Configure(dfa, flags, out underlyingTable);
        }
        public CanonicalLrDfaTable(ILrDfa dfa, IMutableTable<int> actionTable)
        {
            var flag = LrTableOptimizations.EliminateLr0ReduceStates;
            this.canOptimizeReduceStates = (dfa.Optimizations & flag) == flag;

            this.grammar = dfa.GrammarAnalysis;
            this.actionTable = actionTable ?? new MutableTable<int>(dfa.States.Length, grammar.Symbols.Count);
            FillDfaTable(dfa.States);
            BuildConflictTable();
        }
        public ReductionModifiedLrDfaTable(ILrDfa dfa, IMutableTable<int> actionTable = null)
        {
            var flag = LrTableOptimizations.EliminateLr0ReduceStates;
            this.canOptimizeReduceStates = (dfa.Optimizations & flag) == flag;

            this.grammar = dfa.GrammarAnalysis;
            var states = dfa.States;
            this.actionTable = actionTable ?? new MutableTable<int>(states.Length, dfa.GrammarAnalysis.Symbols.Count);
            FillDfaTable(states);
            BuildConflictActionTable();
        }
Пример #4
0
        public Lalr1Dfa(GrammarAnalysis grammar, LrTableOptimizations optimizations)
        {
            this.grammar       = grammar;
            this.Optimizations = optimizations;
            this.TokenSet      = grammar.TokenSet;

            BuildLalr1States();

            if ((Optimizations & LrTableOptimizations.EliminateLr0ReduceStates) != 0)
            {
                EliminateLr0ReduceStates();
            }
        }
Пример #5
0
        // TODO: Performance
        private static void CollectClosureLookaheads(IDotItemSet result, GrammarAnalysis grammar)
        {
            int count = result.Count;
            if (count == 0)
            {
                return;
            }

            bool modified;

            // Debug.WriteLine("closured lookeads: item count = {0}", result.Count);

            do
            {
                modified = false;

                for (int i = 0; i != count; ++i)
                {
                    var fromItem = result[i];
                    if (!fromItem.IsReduce)
                    {
                        for (int j = 0; j != count; ++j)
                        {
                            var toItem = result[j];

                            if (fromItem.NextToken == toItem.Outcome)
                            {
                                int countBefore = 0;
                                if (!modified)
                                {
                                    countBefore = toItem.LA.Count;
                                }

                                grammar.AddFirst(fromItem.CreateNextItem(), toItem.LA);

                                if (!modified)
                                {
                                    modified = toItem.LA.Count != countBefore;
                                }
                            }
                        }
                    }
                }

                if (modified)
                {
                    // Debug.WriteLine("closured lookaheads: extra pass");
                }
            }
            while (modified);
        }