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