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);
}
