public IEnumerable <INfaState> Closure() { // the working queue used to process states var queue = new ProcessOnceQueue <INfaState>(); // initialize by adding the curren state (this) queue.Enqueue(this); // loop over items in the queue, adding newly discovered // items after null transitions while (queue.Count != 0) { var state = queue.Dequeue(); for (var t = 0; t < state.Transitions.Count; t++) { var transition = state.Transitions[t]; if (transition.TransitionType == NfaTransitionType.Null) { queue.Enqueue(transition.Target); } } } return(queue.Visited); }
public void ProcessOnceQueueShouldOnlyProcessItemOnce() { var processOnceQueue = new ProcessOnceQueue<int>(); processOnceQueue.Enqueue(1); processOnceQueue.Enqueue(1); processOnceQueue.Enqueue(2); Assert.AreEqual(2, processOnceQueue.Count); }
public override DfaState Transform(Nfa nfa) { var processOnceQueue = new ProcessOnceQueue <NfaClosure>(); var set = ObjectPoolExtensions.Allocate(SharedPools.Default <HashSet <NfaState> >()); foreach (var state in nfa.Start.Closure()) { set.Add(state); } var start = new NfaClosure(set, nfa.Start.Equals(nfa.End)); processOnceQueue.Enqueue(start); while (processOnceQueue.Count > 0) { var nfaClosure = processOnceQueue.Dequeue(); var transitions = ObjectPoolExtensions.Allocate(SharedPools.Default <Dictionary <AtomTerminal, HashSet <NfaState> > >()); foreach (var state in nfaClosure.Set) { foreach (var transition in state.Transitions) { if (transition is TerminalNfaTransition terminalTransition) { var terminal = terminalTransition.Terminal; if (!transitions.ContainsKey(terminal)) { transitions[terminal] = ObjectPoolExtensions.Allocate(SharedPools.Default <HashSet <NfaState> >()); } transitions[terminal].Add(transition.Target); } } } foreach (var terminal in transitions.Keys) { var targetStates = transitions[terminal]; var closure = Closure(targetStates, nfa.End); closure = processOnceQueue.EnqueueOrGetExisting(closure); nfaClosure.State.AddTransition(terminal, closure.State); SharedPools.Default <HashSet <NfaState> >().ClearAndFree(targetStates); } SharedPools .Default <HashSet <NfaState> >() .ClearAndFree(nfaClosure.Set); SharedPools .Default <Dictionary <AtomTerminal, HashSet <NfaState> > >() .ClearAndFree(transitions); } return(start.State); }
public IDfaState Transform(INfa nfa) { var processOnceQueue = new ProcessOnceQueue<NfaClosure>(); var set = SharedPools.Default<HashSet<INfaState>>().AllocateAndClear(); foreach (var state in nfa.Start.Closure()) set.Add(state); var start = new NfaClosure(set, nfa.Start.Equals(nfa.End)); processOnceQueue.Enqueue(start); while (processOnceQueue.Count > 0) { var nfaClosure = processOnceQueue.Dequeue(); var transitions = SharedPools .Default<Dictionary<ITerminal, HashSet<INfaState>>>() .AllocateAndClear(); foreach (var state in nfaClosure.Closure) { for (var t = 0; t < state.Transitions.Count; t++) { var transition = state.Transitions[t]; switch (transition.TransitionType) { case NfaTransitionType.Terminal: var terminalTransition = transition as TerminalNfaTransition; var terminal = terminalTransition.Terminal; if (!transitions.ContainsKey(terminalTransition.Terminal)) transitions[terminal] = SharedPools.Default<HashSet<INfaState>>().AllocateAndClear(); transitions[terminal].Add(transition.Target); break; } } } foreach (var terminal in transitions.Keys) { var targetStates = transitions[terminal]; var closure = Closure(targetStates, nfa.End); closure = processOnceQueue.EnqueueOrGetExisting(closure); nfaClosure.State.AddTransition( new DfaTransition(terminal, closure.State)); SharedPools.Default<HashSet<INfaState>>().Free(targetStates); } SharedPools .Default<HashSet<INfaState>>() .Free(nfaClosure.Closure); SharedPools .Default<Dictionary<ITerminal, HashSet<INfaState>>>() .ClearAndFree(transitions); } return start.State; }
public void ProcessOnceQueueShouldOnlyProcessItemOnce() { var processOnceQueue = new ProcessOnceQueue <int>(); processOnceQueue.Enqueue(1); processOnceQueue.Enqueue(1); processOnceQueue.Enqueue(2); Assert.AreEqual(2, processOnceQueue.Count); }
public PreComputedGrammar(IGrammar grammar) { _dottedRuleSetQueue = new ProcessOnceQueue <DottedRuleSet>(); _dottedRuleSets = new Dictionary <DottedRuleSet, DottedRuleSet>(); Grammar = grammar; var startStates = Initialize(Grammar); Start = AddNewOrGetExistingDottedRuleSet(startStates); ProcessDottedRuleSetQueue(); }
public Closure( int source, Dictionary <int, UniqueList <int> > nullTransitions, HashSet <int> finalStates) { _set = new SortedSet <int>(); var queue = new ProcessOnceQueue <int>(); queue.Enqueue(source); CreateClosure(nullTransitions, finalStates, queue); _hashCode = ComputeHashCode(States); }
public Closure( SortedSet <int> sources, Dictionary <int, UniqueList <int> > nullTransitions, HashSet <int> finalStates) { _set = sources; var queue = new ProcessOnceQueue <int>(); foreach (var item in sources) { queue.Enqueue(item); } CreateClosure(nullTransitions, finalStates, queue); _hashCode = ComputeHashCode(States); }
public PreComputedGrammar(IGrammar grammar) { _frameQueue = new ProcessOnceQueue <Frame>(); _frames = new Dictionary <Frame, Frame>(); Grammar = grammar; Dictionary <ISymbol, UniqueList <ISymbol> > symbolPaths = null; CreateStatesSymbolsAndSymbolPaths(grammar, out _states, out symbolPaths); var startStates = Initialize(Grammar); Start = AddNewFrameOrGetExistingFrame(startStates); ProcessFrameQueue(); _rightRecursiveSymbols = CreateRightRecursiveLookup(Grammar, _states, symbolPaths); }
public IEnumerable <NfaState> Closure() { // the working queue used to process states var queue = new ProcessOnceQueue <NfaState>(); // initialize by adding the current state (this) queue.Enqueue(this); // loop over items in the queue, adding newly discovered // items after null transitions while (queue.Count > 0) { var state = queue.Dequeue(); foreach (var transition in state.Transitions.OfType <EpsilonNfaTransition>()) { queue.Enqueue(transition.Target); } } return(queue.Visited); }
public IEnumerable<INfaState> Closure() { // the working queue used to process states var queue = new ProcessOnceQueue<INfaState>(); // initialize by adding the curren state (this) queue.Enqueue(this); // loop over items in the queue, adding newly discovered // items after null transitions while (queue.Count != 0) { var state = queue.Dequeue(); for (var t = 0; t < state.Transitions.Count; t++) { var transition = state.Transitions[t]; if (transition.TransitionType == NfaTransitionType.Null) queue.Enqueue(transition.Target); } } return queue.Visited; }
private void CreateClosure(Dictionary <int, UniqueList <int> > nullTransitions, HashSet <int> finalStates, ProcessOnceQueue <int> queue) { while (queue.Count > 0) { var state = queue.Dequeue(); _set.Add(state); if (finalStates.Contains(state)) { IsFinal = true; } UniqueList <int> targetStates = null; if (!nullTransitions.TryGetValue(state, out targetStates)) { continue; } for (int i = 0; i < targetStates.Count; i++) { queue.Enqueue(targetStates[i]); } } States = _set.ToArray(); }
public IDfaState Transform(INfa nfa) { var processOnceQueue = new ProcessOnceQueue <NfaClosure>(); var set = SharedPools.Default <SortedSet <INfaState> >().AllocateAndClear(); foreach (var state in nfa.Start.Closure()) { set.Add(state); } var start = new NfaClosure(set, nfa.Start.Equals(nfa.End)); processOnceQueue.Enqueue(start); while (processOnceQueue.Count > 0) { var nfaClosure = processOnceQueue.Dequeue(); var transitions = SharedPools .Default <Dictionary <ITerminal, SortedSet <INfaState> > >() .AllocateAndClear(); for (int i = 0; i < nfaClosure.Closure.Length; i++) { var state = nfaClosure.Closure[i]; for (var t = 0; t < state.Transitions.Count; t++) { var transition = state.Transitions[t]; switch (transition.TransitionType) { case NfaTransitionType.Edge: var terminalTransition = transition as TerminalNfaTransition; var terminal = terminalTransition.Terminal; if (!transitions.ContainsKey(terminalTransition.Terminal)) { transitions[terminal] = SharedPools.Default <SortedSet <INfaState> >().AllocateAndClear(); } transitions[terminal].Add(transition.Target); break; } } } foreach (var terminal in transitions.Keys) { var targetStates = transitions[terminal]; var closure = Closure(targetStates, nfa.End); closure = processOnceQueue.EnqueueOrGetExisting(closure); nfaClosure.State.AddTransition( new DfaTransition(terminal, closure.State)); SharedPools.Default <SortedSet <INfaState> >().ClearAndFree(targetStates); } SharedPools .Default <SortedSet <INfaState> >() .ClearAndFree(nfaClosure.Set); SharedPools .Default <Dictionary <ITerminal, SortedSet <INfaState> > >() .ClearAndFree(transitions); } return(start.State); }