public FSA(string name, IEnumerable <FSATransition <TValue> > transitions, IEnumerable <int> q0, IEnumerable <int> f)
{
Name = name.ThrowIfEmpty();
Q0 = q0.ToHashSet();
F = f.ToHashSet();
#region Speedup
foreach (var t in transitions)
{
OrderedSet <FSATransition <TValue> > predics;
if (!_lookup.TryGetValue(t.BeginState, out predics))
{
predics = new OrderedSet <FSATransition <TValue> >();
_lookup[t.BeginState] = predics;
}
predics.Add(t);
if (!PredicateEdgeBase <TValue> .IsEpsilon(t.Condition))
{
_sigma.Add(t.Condition);
}
}
StateCount = Q.Count();
#endregion
}
public void GetInvertedPredicate(IEnumerable <string> names, out PredicateEdgeBase <TValue> predicate, out string invertedName)
{
names = names.Distinct().OrderByDescending(x => x);
invertedName = string.Format("#not in: {0}", string.Join(",", names));
if (!_predicateTable.Contains(invertedName))
{
var predicates = names.Select(GetPredicate).Distinct().ToArray();
Func <SequenceHandler <TValue>, int, bool> invertedPredicate = (v, i) =>
{
return(!predicates.Any(p => p.IsMatch(v, i)));
};
_predicateTable.AddPredicate(invertedName, invertedPredicate);
}
predicate = GetPredicate(invertedName);
}
/// <summary>
/// Returns a set of NFA states from which there is a transition on input symbol
/// inp from some state s in states.
/// </summary>
/// <param name="states"></param>
/// <param name="inp"></param>
/// <returns></returns>
internal Set <int> Move(Set <int> states, PredicateEdgeBase <TValue> inp)
{
var result = new Set <int>();
// For each state in the set of states
foreach (var state in states)
{
IEnumerable <FSATransition <TValue> > transitions;
if (TryGetTransitionsFrom(state, out transitions))
{
foreach (var input in transitions)
{
// If the transition is on input inp, add it to the resulting set
if (PredicateEdgeBase <TValue> .IsEqual(input.Condition, inp))
{
result.Add(input.EndState);
}
}
}
}
return(result);
}
private void AddTransition(FSATransition <TValue> trans)
{
if (trans == null)
{
throw new ArgumentNullException(nameof(trans));
}
#region Speedup
OrderedSet <FSATransition <TValue> > predics;
if (!_lookup.TryGetValue(trans.BeginState, out predics))
{
predics = new OrderedSet <FSATransition <TValue> >();
_lookup[trans.BeginState] = predics;
}
predics.Add(trans);
if (!PredicateEdgeBase <TValue> .IsEpsilon(trans.Condition))
{
_sigma.Add(trans.Condition);
}
#endregion
}
/// <summary>
/// Builds the Epsilon closure of states for the given NFA
/// </summary>
/// <param name="nfa"></param>
/// <param name="states"></param>
/// <returns></returns>
private static Set <int> EpsilonClosure(FSA <TValue> nfa, Set <int> states)
{
// Push all states onto a stack
Stack <int> uncheckedStack = new Stack <int>(states);
// Initialize EpsilonClosure(states) to states
Set <int> epsilonClosure = states;
while (uncheckedStack.Count != 0)
{
// Pop state t, the top element, off the stack
var t = uncheckedStack.Pop();
// For each state u with an edge from t to u labeled Epsilon
IEnumerable <FSATransition <TValue> > transitions;
if (nfa.TryGetTransitionsFrom(t, out transitions))
{
foreach (var input in transitions)
{
if (PredicateEdgeBase <TValue> .IsEpsilon(input.Condition))
{
int u = input.EndState;
// If u is not already in epsilonClosure, add it and push it onto stack
if (!epsilonClosure.Contains(u))
{
epsilonClosure.Add(u);
uncheckedStack.Push(u);
}
}
}
}
}
return(epsilonClosure);
}
private void EvaluateCondition(int start, int end, FSA <TValue> fsa, PredicateEdgeBase <TValue> condition)
{
fsa.AddTransition(start, condition, end);
}
public bool TryRun(SequenceHandler <TValue> values, int startIndex, OCaptureTable <TValue> table, out Range range)
{
range = default(Range);
var piStack = _piStack;
piStack.Clear();
var stack = _instanceStack;
stack.Clear();
bool hasSubCaptures = false;
FSAState state = CreateState(_startState, startIndex);
stack.Push(state);
var pi = 0;
piStack.Push(pi);
while (stack.Count > 0)
{
state = stack.Peek();
pi = piStack.Peek();
bool retrieved = false;
var transitions = _transitionMatrix[state.StateId];
if (transitions != null &&
transitions.Length > 0)
{
for (int i = pi; i < transitions.Length; i++)
{
var trans = transitions[i];
piStack.Push(piStack.Pop() + 1);
var isMatch = trans.Condition.IsMatch(values, state.CurrentIndex);
if (isMatch)
{
var isEps = PredicateEdgeBase <TValue> .IsEpsilon(trans.Condition);
hasSubCaptures |= trans.Condition.IsSystemPredicate && ((SystemPredicateEdge <TValue>)trans.Condition).IsCapture;
stack.Push(CreateState(trans.EndState, state.CurrentIndex + (isEps ? 0 : 1)));
piStack.Push(0);
retrieved = true;
break;
}
}
}
if (!retrieved)
{
if (_finalsLookup[state.StateId])
{
break;
}
stack.Pop();
piStack.Pop();
}
}
if (stack.Count != 0 && _finalsLookup[state.StateId])
{
if (hasSubCaptures && table != null)
{
ManageSubCaptures(table, values, stack, piStack);
}
range = new Range(startIndex, state.CurrentIndex - startIndex);
return(true);
}
return(false);
}
public AstAtomNode(string name, PredicateEdgeBase <TValue> condition, Range range)
: base(range)
{
Name = name.ThrowIfEmpty();
Condition = condition.ThrowIfNull();
}
public FSATransition(int beginState, PredicateEdgeBase <TValue> info, int endState)
{
BeginState = beginState;
Condition = info;
EndState = endState;
}
public void AddTransition(int from, PredicateEdgeBase <TValue> condition, int to)
{
AddTransition(new FSATransition <TValue>(from, condition, to));
}
