//public FiniteAutomaton(System.IO.FileInfo source) //{ // loadAutomaton(source); //} //public FiniteAutomaton(System.String filename) //{ // if (!loadAutomaton(filename)) // throw new InvalidAutomatonFormat("The source file \"" + filename + "\" does not define a valid automaton."); //} public virtual FAState createState() { FAState st = new FAState(num); num++; states.Add(st); return(st); }
private void LoadEGT(BinaryReader reader) { using (EGTReader egtReader = new EGTReader(reader)) { while (egtReader.GetNextRecord()) { switch (egtReader.ReadRecordType()) { case EGTRecord.Property: GrammarProperties.SetProperty(egtReader.ReadGrammarProperty()); break; case EGTRecord.TableCounts: GrammarTables = egtReader.ReadGrammarTables(); break; case EGTRecord.InitialStates: //DFA, LALR ushort dfaState = egtReader.ReadUInt16(); ushort lalrState = egtReader.ReadUInt16(); Debug.Assert(dfaState == 0, "The initial DFA State is not 0!"); Debug.Assert(lalrState == 0, "The initial LALR State is not 0!"); break; case EGTRecord.Symbol: Symbol sym = egtReader.ReadSymbol(); GrammarTables.Symbols[sym.TableIndex] = sym; break; case EGTRecord.Group: Group group = egtReader.ReadGroup(); GrammarTables.Groups[group.TableIndex] = group; break; case EGTRecord.CharRanges: CharacterSet charSet = egtReader.ReadCharacterSet(); GrammarTables.CharacterSets[charSet.Index] = charSet; break; case EGTRecord.Production: Production prod = egtReader.ReadProduction(); GrammarTables.Productions[prod.TableIndex] = prod; break; case EGTRecord.DFAState: FAState faState = egtReader.ReadFAState(); GrammarTables.FAStates[faState.TableIndex] = faState; break; case EGTRecord.LRState: LRActionList actionList = egtReader.ReadLRActionList(); GrammarTables.LRActionLists[actionList.Index] = actionList; break; } } } }
/** * Simplify a finite automaton by merging simulation equivalent states * @param fa: a finite automaton * @param Sim: some simulation rel_specation over states in the spec automaton * * @return an equivalent finite automaton */ private FiniteAutomaton quotient(FiniteAutomaton fa, HashSet <Pair <FAState, FAState> > rel) { FiniteAutomaton result = new FiniteAutomaton(); Dictionary <FAState, FAState> map = new Dictionary <FAState, FAState>(); Dictionary <FAState, FAState> reducedMap = new Dictionary <FAState, FAState>(); foreach (FAState state in fa.states) { map.Add(state, state); foreach (FAState state2 in fa.states) { if (rel.Contains(new Pair <FAState, FAState>(state, state2)) && rel.Contains(new Pair <FAState, FAState>(state2, state))) { map.Add(state, state2); } } } FAState init = result.createState(); reducedMap.Add(map[fa.InitialState], init); result.InitialState = init; foreach (FAState state in fa.states) { if (!reducedMap.ContainsKey(map[state])) { reducedMap.Add(map[state], result.createState()); } if (fa.F.Contains(state)) { result.F.Add(reducedMap[map[state]]); } foreach (KeyValuePair <string, HashSet <FAState> > sym_it in state.next) { String sym = sym_it.Key; foreach (FAState to in sym_it.Value) { if (!reducedMap.ContainsKey(map[to])) { reducedMap.Add(map[to], result.createState()); } result.addTransition(reducedMap[map[state]], reducedMap[map[to]], sym); } } } HashSet <Pair <FAState, FAState> > newrel_spec = new HashSet <Pair <FAState, FAState> >(); foreach (Pair <FAState, FAState> sim in rel) { newrel_spec.Add(new Pair <FAState, FAState>(reducedMap[map[sim.Left]], reducedMap[map[sim.Right]])); } rel.Clear(); rel = new HashSet <Pair <FAState, FAState> >(newrel_spec); return(result); }
private FAState GetOptimalState(FAState sourceState, IEnumerable <FATransition> filterTransition, FiniteAutomata DFA) { FAState selectedState = null; IEnumerable <FAState> finalStateFilter = filterTransition.SelectMany(x => x.ToState.Where(y => y.IsFinalState)); if (finalStateFilter.Count() == 1) { selectedState = finalStateFilter.First(); } else { bool xLoop = filterTransition.All(x => x.FromState == sourceState && x.ToState.Any(y => y.StateName == sourceState.StateName) && x.FromState.IsFinalState); if (xLoop) { string emptySName = "Empty"; FAState emptySet = new FAState(emptySName); if (!DFA.States.Any(x => x.StateName == emptySet.StateName)) { _ = DFA.AddState(emptySet); foreach (char symbol in DFA.Alphabet) { _ = DFA.AddTransition(symbol, emptySName, emptySName); } } selectedState = emptySet; return(selectedState); } IEnumerable <FAState> selfRefStates = filterTransition.Where(x => x.ToState.Any(y => y == sourceState && x.FromState == sourceState) && !x.Direction) .Select(x => x.FromState); FAState selfRefSt = selfRefStates.FirstOrDefault(); if (selfRefSt != null) { FAState updState = new FAState(selfRefSt.StateName, selfRefSt.IsInitialState); DFA.UpdateState(updState); selectedState = updState; return(selectedState); } IEnumerable <FAState> selfReferenceFilter = filterTransition.SelectMany(x => x.ToState.Where(y => y != sourceState)); if (selfReferenceFilter.Count() == 1) { selectedState = selfReferenceFilter.First(); } else { selectedState = filterTransition.First().FromState; } } return(selectedState); }
public void Should_ReturnsZero_When_CompareTo_Transition() { FAState state = new FAState("State1"); FAState state2 = new FAState("State2"); FATransition transition1 = new FATransition('a', state, state2); FATransition transition2 = new FATransition('a', state, state2); Assert.Zero(transition1.CompareTo(transition2)); }
public void Should_ReturnsNegative_When_CompareTo_Transition() { FAState state = new FAState("State1"); FAState state2 = new FAState("State2"); FATransition transition1 = new FATransition('a', state, state2); FATransition transition2 = new FATransition('b', state, state2); Assert.AreEqual(-1, transition1.CompareTo(transition2)); }
public void Should_ReturnFalse_When_AddState_WithNullFaState() { List <char> alphabet = new List <char>() { 'a' }; FiniteAutomata automata = new FiniteAutomata(FiniteAutomataType.DFA, alphabet); FAState state = null; Assert.False(automata.AddState(state)); }
public void Should_ReturnTrue_When_AddState_WithFAState() { List <char> alphabet = new List <char>() { 'a' }; FiniteAutomata automata = new FiniteAutomata(FiniteAutomataType.DFA, alphabet); FAState state = new FAState("State"); Assert.True(automata.AddState(state)); }
public void Should_Equal_When_InitalState_ComparedByInitialState() { List <char> alphabet = new List <char> { '0', '1' }; FiniteAutomata automata = new FiniteAutomata(FiniteAutomataType.NFA, alphabet); FAState state = new FAState("A", isInitialState: true); automata.AddState(state); Assert.AreEqual(state, automata.InitialState); }
public void Should_ReturnTrue_When_AddTransition_WithFATranstion() { List <char> alphabet = new List <char>() { 'a' }; FiniteAutomata automata = new FiniteAutomata(FiniteAutomataType.DFA, alphabet); FAState state1 = new FAState("q1", isInitialState: true, isFinalState: true); FATransition transition = new FATransition('a', state1, state1); Assert.True(automata.AddTransition(transition)); }
public void Should_ReturnTrue_When_UpdateState_WithFAState() { List <char> alphabet = new List <char>() { 'a' }; FiniteAutomata automata = new FiniteAutomata(FiniteAutomataType.TwoWayDFA, alphabet); FAState state = new FAState("State Name", isInitialState: true, isFinalState: true); automata.AddState(state); state = new FAState("State Name", isInitialState: true, isFinalState: false); Assert.True(automata.UpdateState(state)); }
public virtual FAState createState(System.String name) { int i = S.IndexOf(name); if (i < 0) { FAState st = new FAState(num); S.Add(name); states.Add(st); num++; return(st); } else { return(states[i]); } }
internal FAState ReadFAState() { ushort index = ReadUInt16(); bool accept = ReadBoolean(); ushort acceptIndex = ReadUInt16(); //Reserved; skip ReadEntry(); FAState faState = accept ? new FAState(index, grammarTables.Symbols[acceptIndex]) : new FAState(index); while (!IsRecordComplete()) { faState.Edges.Add(ReadFAEdge()); } return(faState); }
public void Should_Equal_When_FinalState_ComparedByFinalState() { List <char> alphabet = new List <char> { '0', '1' }; FiniteAutomata automata = new FiniteAutomata(FiniteAutomataType.NFA, alphabet); FAState state = new FAState("A", isFinalState: true); _ = automata.AddState(state); List <FAState> states = new List <FAState>() { state }; Assert.AreEqual(states, automata.FinalState); }
public virtual void addTransition(FAState state, FAState state2, System.String label) { if (state.next.ContainsKey(label)) { if (state.next[label].Contains(state2)) { return; } } trans++; if (!alphabet.Contains(label)) { alphabet.Add(label); } state.addNext(label, state2, this); state2.addPre(label, state); }
public static Automata BuildAutomata(ConfigurationBase initStep) { Dictionary <string, FAState> visited = new Dictionary <string, FAState>(); Stack <ConfigurationBase> working = new Stack <ConfigurationBase>(1024); working.Push(initStep); Automata auto = new Automata(); FAState init = auto.AddState(); auto.SetInitialState(init); visited.Add(initStep.GetID(), init); do { ConfigurationBase current = working.Pop(); FAState currentState = visited[current.GetID()]; IEnumerable <ConfigurationBase> list = current.MakeOneMove(); //for (int i = 0; i < list.Length; i++) foreach (ConfigurationBase step in list) { //ConfigurationBase step = list[i]; FAState target; string nextID = step.GetID(); if (visited.ContainsKey(nextID)) { target = visited[nextID]; } else { target = auto.AddState(); working.Push(step); visited.Add(nextID, target); } auto.AddTransition(currentState, step.Event, target); } }while (working.Count > 0); return(auto); }
public void Should_ReturnTrue_When_AddTransition_MultipleToStatesInNFA() { List <char> alphabet = new List <char>() { 'a' }; FiniteAutomata automata = new FiniteAutomata(FiniteAutomataType.NFA, alphabet); FAState state1 = new FAState("q1", isInitialState: true, isFinalState: true); FAState state2 = new FAState("q2"); List <FAState> states = new List <FAState>() { state1, state2 }; FATransition transition = new FATransition('a', state1, states); Assert.True(automata.AddTransition(transition)); }
/// <summary> /// Inserts initial state to DFA from NFA. /// </summary> /// <param name="NFA"></param> /// <param name="DFA"></param> /// <returns>Updated DFA object.</returns> private FiniteAutomata InsertInitalState(FiniteAutomata NFA, FiniteAutomata DFA) { _ = DFA.AddState(NFA.InitialState); // TR: Sadece initial state'in yaptığı geçişleri NFA dan getirilir. IEnumerable <FATransition> transitions = NFA.Transitions.Where(x => x.FromState == NFA.InitialState); foreach (FATransition transition in transitions) { if (transition.ToState.Count() == 1) { // TR: Hedef state yoksa oluşturulur. FAState toState = transition.ToState.First(); _ = DFA.AddState(toState); // TR: 1-1 geçiş olduğundan DFA'ya uyumludur. Geçişi olduğu gibi eklenir. _ = DFA.AddTransition(transition); } else if (transition.ToState.Count() > 1) // 1 den fazla to state varsa { IEnumerable <FAState> toStates = transition.ToState; // TR: Stateleri aralarına ayraç koyarak birleştir. string newStateName = string.Join(STATE_SEPARATOR, toStates); // TR: Herhangi bir state final state ise bu state final olmalıdır. bool isFinalState = toStates.Any(state => state.IsFinalState); // TR: Hedef state yoksa oluşturulur. FAState aState = new FAState(newStateName, isFinalState: isFinalState); _ = DFA.AddState(aState); _ = DFA.AddTransition(transition.TransitionSymbol, transition.FromState.StateName, aState.StateName); } else // 0 olma durumu { } } return(DFA); }
private FiniteAutomata InsertLeftDirectionStates(FiniteAutomata TWDFA, FiniteAutomata DFA) { IEnumerable <FATransition> leftTransitions = TWDFA.Transitions.Where(x => !x.Direction); Queue <FATransition> leftTransitionQueue = new Queue <FATransition>(leftTransitions); do { FATransition transition = leftTransitionQueue.Dequeue(); FAState toState = transition.ToState.First(); IEnumerable <FATransition> l0Transitions = TWDFA.Transitions.Where(x => x.FromState == toState); FAState targetState = null; if (l0Transitions.Any(x => !x.Direction)) { IEnumerable <FATransition> l1Transitions = l0Transitions.Where(x => !x.Direction); if (l1Transitions.Count() > 1) { leftTransitionQueue.Enqueue(transition); } else { FATransition l1Transition = l1Transitions.First(); FAState l1State = l1Transition.FromState; targetState = GetOptimalState(l1State, l0Transitions, DFA); } } else { targetState = GetOptimalState(toState, l0Transitions, DFA); } FATransition newTransition = new FATransition(transition.TransitionSymbol, transition.FromState, targetState); _ = DFA.AddTransition(newTransition); } while (leftTransitionQueue.Count > 0); return(DFA); }
public static bool Compare(this FAState first, FAState second) { return(first.StateName == second.StateName); }
public Terminal PeekNextTerminal() { //This function implements the DFA for th parser's lexer. //It generates a token which is used by the LALR state //machine. //=================================================== //Match DFA token //=================================================== short CurrentDFA = m_loaded.InitialDFAState; //Next byte in the input Stream short LastAcceptState = -1; //We have not yet accepted a character string int LastAcceptPosition = -1; char?Ch = Lookahead(0); //NO MORE DATA if (!Ch.HasValue) { // End of file reached, create End Token return(CreateTerminal(m_loaded.GetFirstSymbolOfType(SymbolType.End), 0)); } for (int CurrentPosition = 0; ; ++CurrentPosition) { // This code searches all the branches of the current DFA state // for the next character in the input Stream. If found the // target state is returned. Ch = Lookahead(CurrentPosition); short?Found = null; //End reached, do not match if (Ch.HasValue) { ushort charCode = m_charToShort(Ch.Value); FAState faState = m_loaded.GetFAState(CurrentDFA); foreach (FAEdge Edge in faState.Edges) { //==== Look for character in the Character Set Table if (Edge.Characters.Contains(charCode)) { Found = Edge.Target; break; } } } // This block-if statement checks whether an edge was found from the current state. If so, the state and current // position advance. Otherwise it is time to exit the main loop and report the token found (if there was one). // If the LastAcceptState is -1, then we never found a match and the Error Token is created. Otherwise, a new // token is created using the Symbol in the Accept State and all the characters that comprise it. if (Found.HasValue) { // This code checks whether the target state accepts a token. // If so, it sets the appropiate variables so when the // algorithm in done, it can return the proper token and // number of characters. short Target = Found.Value; //NOT is very important! if ((m_loaded.GetFAState(Target).Accept != null)) { LastAcceptState = Target; LastAcceptPosition = CurrentPosition; } CurrentDFA = Target; //No edge found } else { // Lexer cannot recognize symbol if (LastAcceptState == -1) { return(CreateTerminal(m_loaded.GetFirstSymbolOfType(SymbolType.Error), 1)); } else { //Created Terminal contains the total number of accept characters return(CreateTerminal(m_loaded.GetFAState(LastAcceptState).Accept, LastAcceptPosition + 1)); } } } }
private static Automata BuildAutomataWithRefusalsAndDiv(ConfigurationBase InitSpecStep) { Dictionary <string, FAState> visited = new Dictionary <string, FAState>(); Stack <ConfigurationBase> working = new Stack <ConfigurationBase>(1024); working.Push(InitSpecStep); Automata auto = new Automata(); FAState init = auto.AddState(); auto.SetInitialState(init); visited.Add(InitSpecStep.GetID(), init); do { ConfigurationBase current = working.Pop(); FAState currentState = visited[current.GetID()]; if (current.IsDivergent()) { currentState.IsDiv = true; } else { IEnumerable <ConfigurationBase> list = current.MakeOneMove(); List <string> negateRefusal = new List <string>(); bool hasTau = false; //for (int i = 0; i < list.Length; i++) foreach (ConfigurationBase step in list) { //ConfigurationBase step = list[i]; if (step.Event == Constants.TAU) { hasTau = true; } else { negateRefusal.Add(step.Event); } FAState target; string nextID = step.GetID(); if (visited.ContainsKey(nextID)) { target = visited[nextID]; } else { target = auto.AddState(); working.Push(step); visited.Add(nextID, target); } auto.AddTransition(currentState, step.Event, target); } if (hasTau) { currentState.NegatedRefusal = null; } else { currentState.NegatedRefusal = negateRefusal; } } }while (working.Count > 0); return(auto); }
internal virtual void tarjan(FAState v) { v_index.Add(v.id, index); v_lowlink.Add(v.id, index); index++; S.Push(v); foreach (KeyValuePair <string, HashSet <FAState> > pair in v.next) { //System.String next = pair.Key; foreach (FAState v_prime in pair.Value) { if (!v_index.ContainsKey(v_prime.id)) { tarjan(v_prime); v_lowlink.Add(v.id, Math.Min(v_lowlink[v.id], v_lowlink[v_prime.id])); } else if (S.Contains(v_prime)) { v_lowlink.Add(v.id, Math.Min(v_lowlink[v.id], v_index[v_prime.id])); } } } if (v_lowlink[v.id] == v_index[v.id]) { HashSet <FAState> SCC = new HashSet <FAState>(); while (S.Count > 0) { FAState t = S.Pop(); SCC.Add(t); if (t.id == v.id) { break; } } foreach (FAState st in SCC) { if (st.next.ContainsKey("1")) { HashSet <FAState> states = st.next["1"]; //states..retainAll(SCC); if (states.Overlaps(SCC)) { foreach (FAState state in SCC) { OneSCC.Add(state); } ////is 1-SCC ////UPGRADE_NOTE: There is an untranslated Statement. Please refer to original code. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1153'" //while (SCC_it2.hasNext()) //{ // OneSCC.add(SCC_it2.next()); //} break; } } } } }
private bool PreStateSimulated(HashSet <Pair <FAState, FAState> > sim, FiniteAutomaton omega, FAState p, FAState q) { foreach (KeyValuePair <string, HashSet <FAState> > keyValuePair in p.pre) { String a = keyValuePair.Key; if (keyValuePair.Value == null) { return(false); } foreach (FAState p_pre in keyValuePair.Value) { bool hasSimulatingState = false; foreach (FAState q_pre in q.pre[a]) { if (sim.Contains(new Pair <FAState, FAState>(p_pre, q_pre))) { hasSimulatingState = true; break; } } if (!hasSimulatingState) { return(false); } } } return(true); }
private bool NextStateSimulated(HashSet <Pair <FAState, FAState> > sim, FiniteAutomaton omega, FAState p, FAState q) { foreach (KeyValuePair <string, HashSet <FAState> > symbol_it in p.next) { String a = symbol_it.Key; if (symbol_it.Value == null) { return(false); } foreach (FAState p_next in symbol_it.Value) { bool hasSimulatingState = false; foreach (FAState q_next in q.next[a]) { if (sim.Contains(new Pair <FAState, FAState>(p_next, q_next))) { hasSimulatingState = true; break; } } if (!hasSimulatingState) { return(false); } } } return(true); }
/** * Compute forward simulation relation of a Buchi automaton using Henzinger, Henzinger, Kopke FOCS 1995 * @param omega: a Buchi automaton * @param FSim: maximum simulation relation * * @return simulation relation on states of the input automaton */ public HashSet <Pair <FAState, FAState> > FastFSimRelNBW2(FiniteAutomaton omega, HashSet <Pair <FAState, FAState> > FSim) { Dictionary <State_Label, HashSet <FAState> > Remove = new Dictionary <State_Label, HashSet <FAState> >(); Dictionary <String, int> symMap = new Dictionary <String, int>(); int [,,] counter = new int[omega.states.Count, omega.states.Count, omega.alphabet.Count]; for (int i = 0; i < omega.states.Count; i++) { for (int j = 0; j < omega.states.Count; j++) { for (int k = 0; k < omega.alphabet.Count; k++) { counter[i, j, k] = 0; } } } foreach (FAState v in omega.states) { HashSet <String> sym_it = omega.getAllTransitionSymbols(); int sym_index = 0; foreach (string sym in sym_it) { symMap.Add(sym, sym_index); sym_index++; HashSet <FAState> allStates = new HashSet <FAState>(omega.states); Remove.Add(new State_Label(v, sym), allStates); } } foreach (Pair <FAState, FAState> cur in FSim) { FAState v = cur.Left; FAState sim_v = cur.Right; foreach (KeyValuePair <string, HashSet <FAState> > symbol_it in sim_v.pre) { String symbol = symbol_it.Key; foreach (FAState from in symbol_it.Value) { State_Label label = new State_Label(v, symbol); if (Remove.ContainsKey(label)) { Remove[label].Remove(from); } counter[from.id, v.id, symMap[symbol]]++; } } } while (Remove.Count > 0) { Dictionary <State_Label, HashSet <FAState> > .Enumerator iterator = Remove.GetEnumerator(); State_Label key = iterator.Current.Key; HashSet <FAState> remove = iterator.Current.Value; Remove.Remove(key); FAState v = key.State; String symbol = key.Label; if (!v.pre.ContainsKey(symbol)) { continue; } foreach (FAState u in v.pre[symbol]) { foreach (FAState w in remove) { if (FSim.Contains(new Pair <FAState, FAState>(u, w))) { FSim.Remove(new Pair <FAState, FAState>(u, w)); foreach (KeyValuePair <string, HashSet <FAState> > symbol_it in w.pre) { String w_symbol = symbol_it.Key; foreach (FAState w_pre in symbol_it.Value) { counter[w_pre.id, u.id, symMap[w_symbol]]--; if (counter[w_pre.id, u.id, symMap[w_symbol]] == 0) { State_Label label = new State_Label(u, w_symbol); if (!Remove.ContainsKey(label)) { HashSet <FAState> emptyStates = new HashSet <FAState>(); Remove.Add(label, emptyStates); } Remove[label].Add(w_pre); } } } } } } } return(FSim); }
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"); } }
public State_Label(FAState st, System.String l) { this.st = st; this.l = l; }
/// <summary> /// Converts NFA transitions into the DFA transition, except initial state. /// </summary> /// <param name="NFA"></param> /// <param name="DFA"></param> /// <returns>Updated DFA object.</returns> private FiniteAutomata Convert(FiniteAutomata NFA, FiniteAutomata DFA) { Queue <FAState> statesQueue = new Queue <FAState>(); // TR: Initial state tarafından eklenen tüm stateleri bulup kuyruğa ekler. IEnumerable <FAState> states = DFA.States.Where(x => !x.IsInitialState); foreach (FAState state in states) { statesQueue.Enqueue(state); } // TR: Kuyruktaki tüm nesneler için çalışır. do { // TR: Kuyruktan sıradaki eleman getirilir. FAState fromState = statesQueue.Dequeue(); // TR: DFA olduğu için tüm geçişler kullanılmalıdır. foreach (char symbol in DFA.Alphabet) { string[] subStateNames = fromState.StateName.Split(STATE_SEPARATOR); List <string> newStateNames = new List <string>(); bool isFinalState = false; foreach (string subStateName in subStateNames) { FAState subState = NFA.States.First(x => x.StateName == subStateName); FATransition subTransition = NFA.Transitions.FirstOrDefault(x => x.FromState == subState && x.TransitionSymbol == symbol); IEnumerable <FAState> subToStates = subTransition.ToState; newStateNames.AddNotExists(subToStates.Select(x => x.StateName)); // TR: Herhangi bir state final state ise bu state final olmalıdır. if (!isFinalState) { isFinalState = subToStates.Any(state => state.IsFinalState); } } // TR: Stateleri aralarına ayraç koyarak birleştirir. string newStateName = string.Join(STATE_SEPARATOR, newStateNames.OrderBy(x => x)); // TR: Hedef state yoksa oluşturulur. FAState targetState; if (!DFA.States.Any(x => x.StateName == newStateName)) { targetState = new FAState(newStateName, isFinalState: isFinalState); _ = DFA.AddState(targetState); // TR: Olmayan item kuyruğa da eklenir. statesQueue.Enqueue(targetState); } else { targetState = DFA.States.First(x => x.StateName == newStateName); } _ = DFA.AddTransition(symbol, fromState.StateName, targetState.StateName); } } while (statesQueue.Count > 0); return(DFA); }
public virtual System.String getName(FAState s) { string name = S[s.ID]; return(name == "" ? s.ToString() : name); }