示例#1
0
        public int Add(LRStateBuild Item)
        {
            LRState item = Item;

            Item = (LRStateBuild)item;
            return(base.Add(item));
        }
示例#2
0
        internal SymbolList GetExpectedSymbols(short CurrentLALR)
        {
            LRState       state           = m_LRStates[CurrentLALR];
            List <Symbol> expectedSymbols = new List <Symbol>();

            state.ForEach(action =>
            {
                switch (action.Symbol.Type)
                {
                case SymbolType.Content:
                case SymbolType.End:
                case SymbolType.GroupStart:
                case SymbolType.GroupEnd:
                    expectedSymbols.Add(action.Symbol);
                    break;
                }
            });
            return(new SymbolList(expectedSymbols));
        }
示例#3
0
        internal EGT(BinaryReader Reader)
        {
            EGTReader EGT     = new EGTReader(Reader);
            EGTRecord RecType = default(EGTRecord);

            try
            {
                while (!EGT.EndOfFile())
                {
                    EGT.GetNextRecord();

                    RecType = (EGTRecord)EGT.RetrieveByte();

                    switch (RecType)
                    {
                    case EGTRecord.Property:
                    {
                        //Index, Name, Value
                        int    Index = 0;
                        string Name  = null;

                        Index = EGT.RetrieveInt16();
                        Name  = EGT.RetrieveString();
                        //Just discard
                        m_Grammar.SetValue(Index, EGT.RetrieveString());
                    }
                    break;

                    case EGTRecord.TableCounts:
                        //Symbol, CharacterSet, Rule, DFA, LALR
                        m_SymbolTable     = new SymbolList(EGT.RetrieveInt16());
                        m_CharSetTable    = new CharacterSetList(EGT.RetrieveInt16());
                        m_ProductionTable = new ProductionList(EGT.RetrieveInt16());
                        m_DFA             = new FAStateList(EGT.RetrieveInt16());
                        m_LRStates        = new LRStateList(EGT.RetrieveInt16());
                        m_GroupTable      = new GroupList(EGT.RetrieveInt16());

                        break;

                    case EGTRecord.InitialStates:
                        //DFA, LALR
                        m_DFA.InitialState      = EGT.RetrieveInt16();
                        m_LRStates.InitialState = EGT.RetrieveInt16();

                        break;

                    case EGTRecord.Symbol:
                    {
                        //#, Name, Kind
                        short      Index = 0;
                        string     Name  = null;
                        SymbolType Type  = default(SymbolType);

                        Index = EGT.RetrieveInt16();
                        Name  = EGT.RetrieveString();
                        Type  = (SymbolType)EGT.RetrieveInt16();

                        m_SymbolTable[Index] = new Symbol(Name, Type, Index);
                    }
                    break;

                    case EGTRecord.Group:
                        //#, Name, Container#, Start#, End#, Tokenized, Open Ended, Reserved, Count, (Nested Group #...)
                    {
                        Group G = new Group();

                        G.TableIndex = EGT.RetrieveInt16();
                        //#

                        G.Name      = EGT.RetrieveString();
                        G.Container = m_SymbolTable[EGT.RetrieveInt16()];
                        G.Start     = m_SymbolTable[EGT.RetrieveInt16()];
                        G.End       = m_SymbolTable[EGT.RetrieveInt16()];

                        G.Advance = (Group.AdvanceMode)EGT.RetrieveInt16();
                        G.Ending  = (Group.EndingMode)EGT.RetrieveInt16();
                        EGT.RetrieveEntry();
                        //Reserved

                        int Count = EGT.RetrieveInt16();
                        for (int n = 1; n <= Count; n++)
                        {
                            G.Nesting.Add(EGT.RetrieveInt16());
                        }

                        //=== Link back
                        m_GroupStart.Add(G.Start, G);
                        m_GroupTable[G.TableIndex] = G;
                    }
                    break;

                    case EGTRecord.CharRanges:
                        //#, Total Sets, RESERVED, (Start#, End#  ...)
                    {
                        int Index = 0;
                        int Total = 0;

                        Index = EGT.RetrieveInt16();
                        EGT.RetrieveInt16();
                        //Codepage
                        Total = EGT.RetrieveInt16();
                        EGT.RetrieveEntry();
                        //Reserved

                        m_CharSetTable[Index] = new CharacterSet();
                        while (!(EGT.RecordComplete()))
                        {
                            m_CharSetTable[Index].Add(new CharacterRange(EGT.RetrieveUInt16(), EGT.RetrieveUInt16()));
                        }
                    }
                    break;

                    case EGTRecord.Production:
                        //#, ID#, Reserved, (Symbol#,  ...)
                    {
                        short Index     = 0;
                        int   HeadIndex = 0;
                        int   SymIndex  = 0;

                        Index     = EGT.RetrieveInt16();
                        HeadIndex = EGT.RetrieveInt16();
                        EGT.RetrieveEntry();
                        //Reserved

                        List <Symbol> symbols = new List <Symbol>();
                        while (!(EGT.RecordComplete()))
                        {
                            SymIndex = EGT.RetrieveInt16();
                            //m_ProductionTable[Index].Handle().Add(m_SymbolTable[SymIndex]);
                            symbols.Add(m_SymbolTable[SymIndex]);
                        }
                        SymbolList symbolList = new SymbolList(symbols);
                        m_ProductionTable[Index] = new Production(m_SymbolTable[HeadIndex], Index, symbolList);
                    }
                    break;

                    case EGTRecord.DFAState:
                        //#, Accept?, Accept#, Reserved (CharSet#, Target#, Reserved)...
                    {
                        int   Index       = 0;
                        bool  Accept      = false;
                        int   AcceptIndex = 0;
                        int   SetIndex    = 0;
                        short Target      = 0;

                        Index       = EGT.RetrieveInt16();
                        Accept      = EGT.RetrieveBoolean();
                        AcceptIndex = EGT.RetrieveInt16();
                        EGT.RetrieveEntry();
                        //Reserved

                        if (Accept)
                        {
                            m_DFA[Index] = new FAState(m_SymbolTable[AcceptIndex]);
                        }
                        else
                        {
                            m_DFA[Index] = new FAState();
                        }

                        //(Edge chars, Target#, Reserved)...
                        while (!(EGT.RecordComplete()))
                        {
                            SetIndex = EGT.RetrieveInt16();
                            //Char table index
                            Target = EGT.RetrieveInt16();
                            //Target
                            EGT.RetrieveEntry();
                            //Reserved

                            m_DFA[Index].Edges.Add(new FAEdge(m_CharSetTable[SetIndex], Target));
                        }
                    }
                    break;

                    case EGTRecord.LRState:
                        //#, Reserved (Symbol#, Action, Target#, Reserved)...
                    {
                        int          Index    = 0;
                        int          SymIndex = 0;
                        LRActionType Action   = 0;
                        short        Target   = 0;

                        Index = EGT.RetrieveInt16();
                        EGT.RetrieveEntry();
                        //Reserved

                        m_LRStates[Index] = new LRState();

                        //(Symbol#, Action, Target#, Reserved)...
                        while (!EGT.RecordComplete())
                        {
                            SymIndex = EGT.RetrieveInt16();
                            Action   = (LRActionType)EGT.RetrieveInt16();
                            Target   = EGT.RetrieveInt16();
                            EGT.RetrieveEntry();
                            //Reserved

                            m_LRStates[Index].Add(new LRAction(m_SymbolTable[SymIndex], Action, Target));
                        }
                    }
                    break;

                    default:
                        //RecordIDComment
                        throw new ParserException("File Error. A record of type '" + (char)RecType + "' was read. This is not a valid code.");
                    }
                }
            }
            catch (Exception ex)
            {
                throw new ParserException(ex.Message, ex, "LoadTables");
            }
        }
示例#4
0
        internal LRAction FindLRAction(short CurrentLALR, Symbol symbolToFind)
        {
            LRState state = m_LRStates[CurrentLALR];

            return(state.Find(action => action.Symbol.Equals(symbolToFind)));
        }
示例#5
0
文件: EGT.cs 项目: cwellsx/GOLDEngine
        internal EGT(BinaryReader Reader)
        {
            EGTReader EGT = new EGTReader(Reader);
            EGTRecord RecType = default(EGTRecord);

            try
            {
                while (!EGT.EndOfFile())
                {
                    EGT.GetNextRecord();

                    RecType = (EGTRecord)EGT.RetrieveByte();

                    switch (RecType)
                    {
                        case EGTRecord.Property:
                            {
                                //Index, Name, Value
                                int Index = 0;
                                string Name = null;

                                Index = EGT.RetrieveInt16();
                                Name = EGT.RetrieveString();
                                //Just discard
                                m_Grammar.SetValue(Index, EGT.RetrieveString());
                            }
                            break;
                        case EGTRecord.TableCounts:
                            //Symbol, CharacterSet, Rule, DFA, LALR
                            m_SymbolTable = new SymbolList(EGT.RetrieveInt16());
                            m_CharSetTable = new CharacterSetList(EGT.RetrieveInt16());
                            m_ProductionTable = new ProductionList(EGT.RetrieveInt16());
                            m_DFA = new FAStateList(EGT.RetrieveInt16());
                            m_LRStates = new LRStateList(EGT.RetrieveInt16());
                            m_GroupTable = new GroupList(EGT.RetrieveInt16());

                            break;
                        case EGTRecord.InitialStates:
                            //DFA, LALR
                            m_DFA.InitialState = EGT.RetrieveInt16();
                            m_LRStates.InitialState = EGT.RetrieveInt16();

                            break;
                        case EGTRecord.Symbol:
                            {
                                //#, Name, Kind
                                short Index = 0;
                                string Name = null;
                                SymbolType Type = default(SymbolType);

                                Index = EGT.RetrieveInt16();
                                Name = EGT.RetrieveString();
                                Type = (SymbolType)EGT.RetrieveInt16();

                                m_SymbolTable[Index] = new Symbol(Name, Type, Index);
                            }
                            break;
                        case EGTRecord.Group:
                            //#, Name, Container#, Start#, End#, Tokenized, Open Ended, Reserved, Count, (Nested Group #...)
                            {
                                Group G = new Group();

                                G.TableIndex = EGT.RetrieveInt16();
                                //#

                                G.Name = EGT.RetrieveString();
                                G.Container = m_SymbolTable[EGT.RetrieveInt16()];
                                G.Start = m_SymbolTable[EGT.RetrieveInt16()];
                                G.End = m_SymbolTable[EGT.RetrieveInt16()];

                                G.Advance = (Group.AdvanceMode)EGT.RetrieveInt16();
                                G.Ending = (Group.EndingMode)EGT.RetrieveInt16();
                                EGT.RetrieveEntry();
                                //Reserved

                                int Count = EGT.RetrieveInt16();
                                for (int n = 1; n <= Count; n++)
                                {
                                    G.Nesting.Add(EGT.RetrieveInt16());
                                }

                                //=== Link back
                                m_GroupStart.Add(G.Start, G);
                                m_GroupTable[G.TableIndex] = G;
                            }
                            break;
                        case EGTRecord.CharRanges:
                            //#, Total Sets, RESERVED, (Start#, End#  ...)
                            {
                                int Index = 0;
                                int Total = 0;

                                Index = EGT.RetrieveInt16();
                                EGT.RetrieveInt16();
                                //Codepage
                                Total = EGT.RetrieveInt16();
                                EGT.RetrieveEntry();
                                //Reserved

                                m_CharSetTable[Index] = new CharacterSet();
                                while (!(EGT.RecordComplete()))
                                {
                                    m_CharSetTable[Index].Add(new CharacterRange(EGT.RetrieveUInt16(), EGT.RetrieveUInt16()));
                                }
                            }
                            break;
                        case EGTRecord.Production:
                            //#, ID#, Reserved, (Symbol#,  ...)
                            {
                                short Index = 0;
                                int HeadIndex = 0;
                                int SymIndex = 0;

                                Index = EGT.RetrieveInt16();
                                HeadIndex = EGT.RetrieveInt16();
                                EGT.RetrieveEntry();
                                //Reserved

                                List<Symbol> symbols = new List<Symbol>();
                                while (!(EGT.RecordComplete()))
                                {
                                    SymIndex = EGT.RetrieveInt16();
                                    //m_ProductionTable[Index].Handle().Add(m_SymbolTable[SymIndex]);
                                    symbols.Add(m_SymbolTable[SymIndex]);
                                }
                                SymbolList symbolList = new SymbolList(symbols);
                                m_ProductionTable[Index] = new Production(m_SymbolTable[HeadIndex], Index, symbolList);
                            }
                            break;
                        case EGTRecord.DFAState:
                            //#, Accept?, Accept#, Reserved (CharSet#, Target#, Reserved)...
                            {
                                int Index = 0;
                                bool Accept = false;
                                int AcceptIndex = 0;
                                int SetIndex = 0;
                                short Target = 0;

                                Index = EGT.RetrieveInt16();
                                Accept = EGT.RetrieveBoolean();
                                AcceptIndex = EGT.RetrieveInt16();
                                EGT.RetrieveEntry();
                                //Reserved

                                if (Accept)
                                {
                                    m_DFA[Index] = new FAState(m_SymbolTable[AcceptIndex]);
                                }
                                else
                                {
                                    m_DFA[Index] = new FAState();
                                }

                                //(Edge chars, Target#, Reserved)...
                                while (!(EGT.RecordComplete()))
                                {
                                    SetIndex = EGT.RetrieveInt16();
                                    //Char table index
                                    Target = EGT.RetrieveInt16();
                                    //Target
                                    EGT.RetrieveEntry();
                                    //Reserved

                                    m_DFA[Index].Edges.Add(new FAEdge(m_CharSetTable[SetIndex], Target));
                                }
                            }
                            break;
                        case EGTRecord.LRState:
                            //#, Reserved (Symbol#, Action, Target#, Reserved)...
                            {
                                int Index = 0;
                                int SymIndex = 0;
                                LRActionType Action = 0;
                                short Target = 0;

                                Index = EGT.RetrieveInt16();
                                EGT.RetrieveEntry();
                                //Reserved

                                m_LRStates[Index] = new LRState();

                                //(Symbol#, Action, Target#, Reserved)...
                                while (!EGT.RecordComplete())
                                {
                                    SymIndex = EGT.RetrieveInt16();
                                    Action = (LRActionType)EGT.RetrieveInt16();
                                    Target = EGT.RetrieveInt16();
                                    EGT.RetrieveEntry();
                                    //Reserved

                                    m_LRStates[Index].Add(new LRAction(m_SymbolTable[SymIndex], Action, Target));
                                }
                            }
                            break;
                        default:
                            //RecordIDComment
                            throw new ParserException("File Error. A record of type '" + (char)RecType + "' was read. This is not a valid code.");
                    }
                }
            }
            catch (Exception ex)
            {
                throw new ParserException(ex.Message, ex, "LoadTables");
            }
        }
示例#6
0
        public void GenerateTable(List <LRState> LRstates)
        {
            var states          = LRstates.ToList();
            var groupedStates   = new List <LRState>();
            var statesNumbers   = new List <int>();
            var nextStateNumber = 0;

            foreach (var variable in states)
            {
                if (!statesNumbers.Exists(w => w.Equals(variable.Number)))
                {
                    var similarStates = new List <LRState>();
                    similarStates.Add(variable);
                    if (variable.Number == 6)
                    {
                    }
                    foreach (var state in LRstates.ToList().Where(e => e.Number != variable.Number))
                    {
                        bool equalFlag = true;
                        if (state.Productions.Count() == variable.Productions.Count())
                        {
                            for (int i = 0; i < variable.Productions.Count; i++)
                            {
                                if (variable.Productions[i].Production.Equals(state.Productions[i].Production) &&
                                    variable.Productions[i].Marked.Index == state.Productions[i].Marked.Index)
                                {
                                }
                                else
                                {
                                    equalFlag = false;
                                }
                            }
                        }
                        else
                        {
                            equalFlag = false;
                        }
                        if (equalFlag)
                        {
                            similarStates.Add(state);
                        }
                    }

                    LRState newState = similarStates.ToList().First();


                    foreach (var oldState in similarStates)
                    {
                        foreach (var s in states.Where(w =>
                                                       w.Productions.Exists(q => q.Action == ActionType.State && q.ActionNumber == oldState.Number)))
                        {
                            foreach (var p in s.Productions.Where(q => q.Action == ActionType.State && q.ActionNumber == oldState.Number))
                            {
                                p.ActionNumber = nextStateNumber;
                            }
                        }
                    }

                    foreach (var oldState in similarStates.Where(y => y.Number != newState.Number))
                    {
                        statesNumbers.Add(oldState.Number);

                        //Atualizar o Follow Local
                        var localFollowSize = oldState.Productions.Count;
                        for (int j = 0; j < localFollowSize; j++)
                        {
                            foreach (var lf in oldState.Productions[j].LocalFolow)
                            {
                                if (!newState.Productions[j].LocalFolow.Exists(r => r.Value == lf.Value))
                                {
                                    newState.Productions[j].LocalFolow.Add(lf);
                                }
                            }
                        }
                    }
                    newState.Number = nextStateNumber;
                    statesNumbers.Add(newState.Number);
                    nextStateNumber++;
                    groupedStates.Add(newState);
                }
            }
            Generated = true;
            CreateTableMatches(groupedStates);
        }
示例#7
0
        public void GenerateTable(DataGridView gridView)
        {
            int            NextStateNumber = 0;                                 //Número do próximo estado
            List <LRState> states          = new List <LRState>();              //Estados
            var            productions     = _syntactic.GetSingleProductions(); //Pega todas as produções
            var            firstProduction = productions.First();

            //Inicio com o primeiro estado (0)
            var firstState = new LRState();

            firstState.Number = NextStateNumber;
            NextStateNumber++;

            //Adiciona a primeira produção (Slinha)
            var firstStateProduction = new LRStateProduction();

            firstStateProduction.LocalFolow.Add(new Symbol()
            {
                Type = SymbolType.EndOfFile, Value = "$"
            });
            firstStateProduction.Production = firstProduction;

            firstState.Productions.Add(firstStateProduction);
            states.Add(firstState);

            while (states.Exists(e => e.Done == false))
            {
                var actualState = states.First(w => w.Done == false);
                while (actualState.Productions.Exists(u => u.Checked == false))
                {
                    var p = actualState.Productions.First(i => i.Checked == false);
                    if (!p.Checked)
                    {
                        Closure(p, ref actualState, productions);
                    }
                }
                if (!actualState.Productions.Exists(g => g.Checked == false))
                {
                    actualState.Done = true;
                    //TERMINOU O FECHO, CRIA OS PRÓXIMOS ESTADOS
                }

                var grouped = actualState.Productions.Where(e => e.Action == ActionType.State).GroupBy(item => item.Marked.Symbol.Value);

                foreach (var item in grouped)
                {
                    bool similarTransitionFound = false;
                    //VERIFICA SE JÁ EXISTE ALGUMA TRANSIÇÃO SIMILAR
                    // item = transições para o mesmo estado, agrupadas
                    foreach (var VARIABLE in states.Where(e => !e.Equals(actualState)))
                    {
                        var stateGroupedProductions = VARIABLE.Productions.GroupBy(x => new { x.ActionNumber });
                        foreach (var gp in stateGroupedProductions)
                        {
                            if (gp.ToList().Count == item.ToList().Count() && gp.All(a => a.Action == ActionType.State))
                            {
                                bool flag = true;
                                //SÃO DO MESMO TAMANHO, POSSO VERIFICAR SE SÃO IGUAIS
                                for (int i = 0; i < gp.ToList().Count; i++)
                                {
                                    if (!(gp.ToList()[i].Production.Equals(item.ToList()[i].Production)) || !(gp.ToList()[i].Marked.Index == item.ToList()[i].Marked.Index))
                                    {
                                        flag = false;
                                    }
                                    else
                                    {
                                        if (gp.ToList()[i].LocalFolow.ToList().Count == item.ToList()[i].LocalFolow.Count())
                                        {
                                            //SÃO DO MESMO TAMANHO, POSSO VERIFICAR SE SÃO IGUAIS
                                            for (int j = 0; j < gp.ToList()[i].LocalFolow.Count; j++)
                                            {
                                                if (!(gp.ToList()[i].LocalFolow[j].Value.Equals(item.ToList()[i].LocalFolow[j].Value)))
                                                {
                                                    flag = false;
                                                }
                                            }
                                        }
                                        else
                                        {
                                            flag = false;
                                        }
                                    }
                                }
                                if (flag)
                                {
                                    similarTransitionFound = true;
                                    foreach (var va in item)
                                    {
                                        va.ActionNumber = gp.First().ActionNumber;
                                    }
                                    break;
                                }
                            }
                        }
                        if (similarTransitionFound)
                        {
                            break;
                        }
                    }
                    if (!similarTransitionFound)
                    {
                        var newState = new LRState();
                        newState.Number = NextStateNumber;

                        foreach (var VARIABLE in item)
                        {
                            var nextStateNewProduction = new LRStateProduction()
                            {
                                Production = VARIABLE.Production,
                                Marked     = new MarkedSymbol()
                                {
                                    Index  = VARIABLE.Marked.Index,
                                    Symbol = new Symbol()
                                    {
                                        Type = VARIABLE.Marked.Symbol.Type, Value = VARIABLE.Marked.Symbol.Value
                                    }
                                },
                                Checked = false
                            };
                            nextStateNewProduction.LocalFolow.AddRange(VARIABLE.LocalFolow);
                            newState.Productions.Add(nextStateNewProduction);
                        }
                        foreach (var pro in newState.Productions)
                        {
                            pro.Checked = false;
                        }
                        states.Add(newState);
                        foreach (var VARIABLE in item)
                        {
                            actualState.Productions.Find(w => w.Equals(VARIABLE)).ActionNumber = NextStateNumber;
                        }
                        NextStateNumber++;
                    }
                }
            }

            CreateTableMatches(states);
            Generated = true;
            this.LRstates.AddRange(states.ToList());
        }
示例#8
0
        public void Closure(LRStateProduction p, ref LRState actualState, List <SingleProduction> productions)
        {
            //VERIFICO SE PRECISO ANDAR COM O FECHO E INCREMENTO O INDEX
            p.Marked.Index++;
            if (p.Marked.Index < p.Production.Produced.Count)
            {
                p.Marked.Symbol = p.Production.Produced.ElementAt(p.Marked.Index);
            }
            //Verifica se existe um simbolo nesse index. Caso não, é uma redução
            if ((p.Marked.Index >= p.Production.Produced.Count) || ((p.Marked.Symbol.Type == SymbolType.Empty) && (p.Marked.Index + 1 == p.Production.Produced.Count)))
            {
                p.Action       = ActionType.Reduction;
                p.ActionNumber = p.Production.Number;
            }
            else
            {
                p.Marked.Symbol = p.Production.Produced.ElementAt(p.Marked.Index);
                p.Action        = ActionType.State;
                //ANDEI COM O FECHO, VERIFICO SE É UM NÃO TERMINAL
                var s = p.Marked.Symbol;
                if (s.Type == SymbolType.NonTerminal)
                {
                    //PEGO AS PRODUÇÕES DESSE NÃO TERMINAL
                    var nonTerminalProductions = productions.Where(t => t.Producer.Value == s.Value);
                    //DECIDO QUAL VAI SER O FOLLOW

                    var localFollow = new List <Symbol>();
                    if (p.Marked.Index + 1 < p.Production.Produced.Count)
                    {
                        //Pego o first desse simbolo
                        var nextSymbol = p.Production.Produced.ElementAt(p.Marked.Index + 1);
                        if (nextSymbol.Type == SymbolType.Terminal)
                        {
                            localFollow.Add(new Symbol()
                            {
                                Type = nextSymbol.Type, Value = nextSymbol.Value
                            });
                        }
                        if (nextSymbol.Type == SymbolType.NonTerminal)
                        {
                            localFollow.AddRange(_semantic.GetFirstList()
                                                 .Find(e => e.NonTerminal.Value == nextSymbol.Value).Terminals);
                        }
                    }
                    else
                    {
                        //Follow local é igual ao follow atual
                        localFollow.AddRange(p.LocalFolow);
                    }

                    //Já tenho o Follow local, verifico se preciso atualizar o follow de alguém
                    if (actualState.ClosureSymbols.Exists(i => i.Value == s.Value))
                    {
                        var actualStateNumber        = actualState.Number;
                        var pendingUpdateProductions =
                            actualState.Productions.Where(r =>
                                                          r.Production.Producer.Value == s.Value && r.GeneratorStateNumber == actualStateNumber);
                        foreach (var lrp in pendingUpdateProductions)
                        {
                            foreach (var followSymbol in localFollow)
                            {
                                if (!lrp.LocalFolow.Exists(e => e.Value == followSymbol.Value))
                                {
                                    lrp.LocalFolow.Add(followSymbol);
                                }
                            }
                        }
                    }
                    else
                    {
                        //CRIEI UM NOVO LRStateProduction para o estado, que é igual à production desse não terminal
                        foreach (var VARIABLE in nonTerminalProductions)
                        {
                            LRStateProduction sp = new LRStateProduction();
                            sp.Production = VARIABLE;
                            sp.LocalFolow.AddRange(localFollow);
                            sp.GeneratorStateNumber = actualState.Number;
                            actualState.Productions.Add(sp);
                        }
                        //SALVA QUE JÁ GEROU O FECHO DESSE NÃO TERMINAL
                        actualState.ClosureSymbols.Add(s);
                    }
                }
            }
            p.Checked = true;
            //MARCO QUE TERMINEI O FECHO DESSE
        }
示例#9
0
        public List <LRStateProduction> IsThereASimilarTransition(List <LRStateProduction> productions, LRState s, LRState actualState)
        {
            bool flag    = false;
            var  grouped = s.Productions.Where(e => e.Action == ActionType.State && e.ActionNumber != actualState.Number).GroupBy(item => item.ActionNumber);

            foreach (var item in grouped)
            {
                flag = true;
                if (item.ToList().Count == productions.Count)
                {
                    for (int i = 0; i < productions.Count; i++)
                    {
                        if (!productions[i].Production.Equals(item.ToList()[i].Production))
                        {
                            flag = false;
                        }
                    }
                }
                else
                {
                    flag = false;
                }
                if (flag)
                {
                    return(item.ToList());
                }
            }
            return(null);
        }