public void CharacterClassInvertedTest(string input, bool expected) { string pattern = "^[^c-e]$"; var target = NFA.CharacterClass('c', 'e', included: false); Test(input, expected, target, pattern); }
public void JustAB(string input, bool expected) { string pattern = "^b$"; var target = NFA.Character('b'); Test(input, expected, target, pattern); }
public void CharacterClassTest(string input, bool expected) { string pattern = "^[a-z]$"; var target = NFA.CharacterClass('a', 'z'); Test(input, expected, target, pattern); }
public void CharacterClassRepeatedTest(string input, bool expected) { string pattern = "^[a-b]+$"; var target = NFA.OneOrMany(NFA.CharacterClass('a', 'b')); Test(input, expected, target, pattern); }
public void JustAnAWithoutEnforcinfItBeTheEntireString(string input, bool expected) { string pattern = "^a$"; var target = NFA.Character('a'); Test(input, expected, target, pattern); }
public void AnyCharSequenceRepeatedTest(string input, bool expected) { string pattern = "^A.+C$"; var target = NFA.Sequence(NFA.Character('A'), NFA.OneOrMany(NFA.AnyCharacter()), NFA.Character('C')); Test(input, expected, target, pattern); }
public void NFATests() { var a = new NFA<char>(); // "a" automaton a.AddTransition(a.Start, new State { Final = true }, 'a'); a.Initial(); a.Trigger('a'); Assert.That(a.Current.Contains(a.LastAdded), Is.True); a.Initial(); Assert.That(() => a.Trigger('b'), Throws.TypeOf<StateNotFoundException>()); // "abcd" automaton a = new NFA<char>(); a.AddTransition(a.Start, new State(), 'a'); a.AddTransition(a.LastAdded, new State(), 'b'); a.AddTransition(a.LastAdded, new State(), 'c'); a.AddTransition(a.LastAdded, new State { Final = true }, 'd'); a.Initial(); foreach (char c in "abcd") { Assert.That(a.Current.Contains(a.LastAdded), Is.False); a.Trigger(c); } Assert.That(a.Current.Contains(a.LastAdded), Is.True); Assert.That(() => a.Trigger('b'), Throws.TypeOf<StateNotFoundException>()); }
public void AOneOrMoreRepeated(string input, bool expected) { string pattern = "^a+$"; var target = NFA.OneOrMany(NFA.Character('a')); Test(input, expected, target, pattern); }
public void GetDFAFinalStatesTest() { var finalStates = new HashSet <int>() { 1, 3 }; var dfaTestStates = new List <HashSet <int> >() { new HashSet <int>() { 1, 2, 3 }, new HashSet <int>() { 2, 0 }, new HashSet <int>() { 3 }, new HashSet <int>() { 1, 2 }, new HashSet <int>() { 0 } }; Assert.IsTrue(NFA.GetDFAFinalStates(dfaTestStates, finalStates).SetEquals(new HashSet <int>() { 0, 2, 3 })); }
static void outputResults(NFA nfa, List <string> newStates, Dictionary <string, List <int> > newRules) { Console.WriteLine("Initial state: {{ {0} }}", nfa.StartState); Console.WriteLine("Favorable states:"); foreach (string state in newStates) { foreach (int Si in getStateElements(state)) { if (nfa.IsFavorable[Si]) { Console.Write(state + " "); break; } } } Console.WriteLine("\nRules:"); foreach (KeyValuePair <string, List <int> > rule in newRules) { Console.Write(rule.Key + " -> { "); foreach (int state in rule.Value) { Console.Write(state + " "); } Console.WriteLine("}"); } }
/// <summary> /// Concatenates two NFAs /// </summary> /// <param name="nfa1">The first NFA</param> /// <param name="nfa2">The second NFA</param> /// <returns></returns> public static NFA ConcatNFAs(NFA nfa1, NFA nfa2) { if (nfa1 == null && nfa2 == null) { return(null); } else if (nfa1 == null) { return(nfa2); } else if (nfa2 == null) { return(nfa1); } NFA result = new NFA(); result.nodeConnections = new List <List <Connection> >(); result.nodeConnections.AddRange(nfa1.nodeConnections); result.nodeConnections.AddRange(nfa2.nodeConnections); //bridge nfa1 and nfa2 by an epsilon connection: Connection bridge = new Connection(); bridge.Epsilon = true; bridge.Node = nfa2.nodeConnections[nfa2.startIndex]; result.nodeConnections[nfa1.endIndices[0]].Add(bridge); result.startIndex = nfa1.startIndex; result.endIndices.Add(nfa1.nodeConnections.Count + nfa2.endIndices[0]); return(result); }
public TreeToNFAConverter(Grammar g, NFA nfa, NFAFactory factory, ITreeNodeStream input) : this( input ) { this.grammar = g; this.nfa = nfa; this.factory = factory; }
public void TestOneOrMore() { NFA nfa = NFACreate("a+"); Assert.AreEqual(3, nfa.States.Count()); Assert.AreEqual(3, nfa.Transitions.Count()); }
public void TestOneOrOnce() { NFA nfa = NFACreate("a?"); Assert.AreEqual(2, nfa.States.Count()); Assert.AreEqual(2, nfa.Transitions.Count()); }
public void CanGoWithLambdaTest() { string path = @"..\..\..\TestData\1.txt"; var nfa = new NFA(path); Assert.IsTrue(nfa.CanGoWithLambda(1).SetEquals(new HashSet <int>() { })); Assert.IsTrue(nfa.CanGoWithLambda(2).SetEquals(new HashSet <int>() { 3 })); Assert.IsTrue(nfa.CanGoWithLambda(3).SetEquals(new HashSet <int>() { })); path = @"..\..\..\TestData\2.txt"; nfa = new NFA(path); Assert.IsTrue(nfa.CanGoWithLambda(0).SetEquals(new HashSet <int>() { 2, 3, 1 })); Assert.IsTrue(nfa.CanGoWithLambda(1).SetEquals(new HashSet <int>() { })); Assert.IsTrue(nfa.CanGoWithLambda(2).SetEquals(new HashSet <int>() { 2, 3 })); Assert.IsTrue(nfa.CanGoWithLambda(3).SetEquals(new HashSet <int>() { 3, 2 })); }
public void TestRepeat() { NFA nfa = NFACreate("a*"); Assert.AreEqual(4, nfa.States.Count()); Assert.AreEqual(4, nfa.Transitions.Count()); }
public NFA Evaluate() { if (Op == RegOperation.String) { return(NFA.GenerateFromString(Content, Alphabet)); } if (Op == RegOperation.Set) { return(NFA.GenerateFromSet(Content, Alphabet)); } else if (Op == RegOperation.Union) { return(NFA.Union(Left.Evaluate(), Right.Evaluate())); } else if (Op == RegOperation.Concat) { return(NFA.Concat(Left.Evaluate(), Right.Evaluate())); } else if (Op == RegOperation.Star) { return(NFA.KleeneStar(Left.Evaluate())); } else if (Op == RegOperation.Plus) { return(NFA.Plus(Left.Evaluate())); } else if (Op == RegOperation.Group || Op == RegOperation.NonGroup) { return(Left.Evaluate()); } else { return(null); } }
public NFA ToNfa() { Expression tree = Parse(pattern); NFA nfa = Construct(tree); return(nfa); }
public void emptyMatchesNothing() { NFA test = new NFA(""); Assert.IsTrue(test.recognizes("")); Assert.IsFalse(test.recognizes("a")); }
public void emptyComplementMatchesAnythingExceptNothing() { NFA test = new NFA("").complement(); Assert.IsFalse(test.recognizes("")); Assert.IsTrue(test.recognizes("a")); }
public static NFA CreateAutomaton(string a) { var result = new NFA(); var start = 0; var next = 1; result.AddState(start, false); for (int i = 0; i < a.Length; ++i) { if (a[i] == '*') { result.AddTransition(next - 1, next - 1, NFA.Any); } else { result.AddState(next, false); result.AddTransition(next - 1, next, (a[i] != '?' ? CharRange.SingleChar(a[i]) : NFA.Any)); ++next; } } result.AddState(next, true); result.AddTransition(next - 1, next, NFA.Epsilon); return(result); }
public void Visit(KleenStarRepetition target) { target.child.Accept(this); var f = stack.Pop(); stack.Push(NFA.ZeroOrMany(f)); }
public void Visit(QuestionRepetition target) { target.child.Accept(this); var f = stack.Pop(); stack.Push(NFA.ZeroOrOne(f)); }
public void Run() { var regs = new List <string[]> { new[] { "((A*B|AC)D)", "AAAABD" }, new[] { "((A*B|AC)D)", "AAAAC" }, new[] { "((a|(bc)*d)*)", "abcbcd" }, new[] { "((a|(bc)*d)*)", "abcbcbcdaaaabcbcdaaaddd" } }; foreach (var reg in regs) { var regexp = reg[0]; var txt = reg[1]; if (txt.Contains("|")) { throw new ArgumentException("| character in text is not supported"); } var nfa = new NFA(regexp); Console.WriteLine($"{regexp} : {txt}"); Console.WriteLine(nfa.Recognizes(txt)); Console.WriteLine("---------------------------------------------"); } Console.ReadLine(); }
public void TestComplex() { NFA nfa = NFACreate("a|b*a&b&a*&*ab|&ab|&"); Assert.AreEqual(30, nfa.States.Count()); Assert.AreEqual(35, nfa.Transitions.Count()); }
public bool IsMatch(string input) { NFA nfa = ToNfa(); DFA dfa = nfa.ToDfa(); return(dfa.IsMatch(input)); }
public void TestConstructWithDigit() { NFA nfa = NFACreate("\\d+"); Assert.AreEqual(3, nfa.States.Count()); Assert.AreEqual(3, nfa.Transitions.Count()); }
public NfaLexer(NFA nfa, IEnumerable <NFA> nfas, List <Tuple <string, Func <string, T> > > tokens, int endOfInputTokenNumber) : base(endOfInputTokenNumber) { this.nfa = nfa; actions = nfas.Select((n, i) => new Tuple <NFA.State, Tuple <int, Func <string, T> > >(n.States.Single(f => f.AcceptState), new Tuple <int, Func <string, T> >(i, i < tokens.Count ? tokens[i].Item2 : null))).ToArray(); }
public void TestConcatenate() { NFA nfa = NFACreate("abc"); Assert.AreEqual(4, nfa.States.Count()); Assert.AreEqual(3, nfa.Transitions.Count()); }
public void Visit(PlusRepetition target) { target.child.Accept(this); var f = stack.Pop(); stack.Push(NFA.OneOrMany(f)); }
public void AddExpression(string name, string regex) { using (var stream = new StringReader(InfixToPostfix.Convert(regex))) { while (stream.Peek() != -1) { var c = (char)stream.Read(); switch (c) { case '.': _stack.Concatenate(); break; case '|': _stack.Unite(); break; case '*': _stack.Iterate(); break; case '+': _stack.AtLeast(); break; case '?': _stack.Maybe(); break; default: var a = new NFA <char>(); a.AddTransition(a.Start, new State(), c == '\\' ? Escape((char)stream.Read()) : c); _stack.Push(a); break; } } var top = _stack.Peek(); top.LastAdded.Final = true; top.SetName(top.LastAdded, name); } }
public void AddExpression(string name, string regex) { using (var stream = new StringReader(InfixToPostfix.Convert(regex))) { while (stream.Peek() != -1) { var c = (char) stream.Read(); switch (c) { case '.': _stack.Concatenate(); break; case '|': _stack.Unite(); break; case '*': _stack.Iterate(); break; case '+': _stack.AtLeast(); break; case '?': _stack.Maybe(); break; default: var a = new NFA<char>(); a.AddTransition(a.Start, new State(), c == '\\' ? Escape((char) stream.Read()) : c); _stack.Push(a); break; } } var top = _stack.Peek(); top.LastAdded.Final = true; top.SetName(top.LastAdded, name); } }
public void AddStates(IDictionary<Mode, State> modeMap, CodePointEquivalenceClasses equivalenceClasses, NFA<LexerAction> nfa, int priority, Channel defaultChannel) { var states = Expression.AddTo(nfa, equivalenceClasses); foreach(var mode in Modes) nfa.AddEpsilonTransition(modeMap[mode], states.Start); nfa.SetFinal(states.End); // Set Action nfa.SetData(states.End, new LexerAction(priority, GetValueAction(), GetModeActions(), GetEmitAction(defaultChannel), GetCodeAction())); }
public LTLMonitor(ITLFormula formula) { var tpositiveNFA = translator.GetBuchiAutomaton (formula).ToNFA(); var tnegativeNFA = translator.GetBuchiAutomaton (formula.Negate ()).ToNFA(); positiveNFA = tpositiveNFA.Determinize (); negativeNFA = tnegativeNFA.Determinize (); currentNegative = negativeNFA.InitialNode; currentPositive = positiveNFA.InitialNode; UpdateStatus (); }
private static NFA RepeatOnceOrMore(NFA nfa) { // Add an epsilon transition from the accept state back to the start state NFA.State oldAcceptState = nfa.States.First(f => f.AcceptState); nfa.Transitions.Add(new Transition<NFA.State>(oldAcceptState, nfa.StartState)); // Add a new accept state, since we cannot have edges exiting the accept state var newAcceptState = new NFA.State { AcceptState = true }; nfa.Transitions.Add(new Transition<NFA.State>(oldAcceptState, newAcceptState)); nfa.States.Add(newAcceptState); // Clear the accept flag of the old accept state oldAcceptState.AcceptState = false; return nfa; }
private static NFA Accept(CharSet acceptCharacters) { // Generate a NFA with a simple path with one state transitioning into an accept state. var nfa = new NFA(); var state = new NFA.State(); nfa.States.Add(state); var acceptState = new NFA.State { AcceptState = true }; nfa.States.Add(acceptState); nfa.Transitions.Add(new Transition<NFA.State>(state, acceptState, acceptCharacters)); nfa.StartState = state; return nfa; }
public void AddExpression(string name, string regex) { var stream = new StringReader(InfixToPostfix.Convert(regex)); while (stream.Peek() != -1) { var c = (char) stream.Read(); NFA<char> a; switch (c) { case '.': _stack.Concatenate(); break; case '|': _stack.Unite(); break; case '*': _stack.Iterate(); break; case '+': _stack.AtLeast(); break; case '?': _stack.Maybe(); break; case '\\': char n = (char) stream.Read(); a = new NFA<char>(); a.AddTransition(a.Start, new State(), Escape(n)); _stack.Push(a); break; default: a = new NFA<char>(); a.AddTransition(a.Start, new State(), c); _stack.Push(a); break; } } var automaton = _stack.Peek(); automaton.LastAdded.Final = true; automaton.SetName(automaton.LastAdded, name); }
public static NFA Or(NFA a, NFA b) { var nfa = new NFA(); // Composite NFA contains all the and all edges in both NFAs nfa.AddAll(a); nfa.AddAll(b); // Add a start state, link to both NFAs old start state with // epsilon links nfa.StartState = new NFA.State(); nfa.States.Add(nfa.StartState); nfa.Transitions.Add(new Transition<NFA.State>(nfa.StartState, a.StartState)); nfa.Transitions.Add(new Transition<NFA.State>(nfa.StartState, b.StartState)); // Add a new accept state, link all old accept states to the new accept // state with an epsilon link and remove the accept flag var newAcceptState = new NFA.State { AcceptState = true }; foreach (var oldAcceptState in nfa.States.Where(f => f.AcceptState)) { oldAcceptState.AcceptState = false; nfa.Transitions.Add(new Transition<NFA.State>(oldAcceptState, newAcceptState)); } nfa.States.Add(newAcceptState); return nfa; }
public static NFA RepeatZeroOrMore(NFA input) { var nfa = new NFA(); // Add everything from the input nfa.AddAll(input); // Create a new starting state, link it to the old accept state with Epsilon nfa.StartState = new NFA.State(); nfa.States.Add(nfa.StartState); NFA.State oldAcceptState = input.States.First(f => f.AcceptState); nfa.Transitions.Add(new Transition<NFA.State>(nfa.StartState, oldAcceptState)); // Add epsilon link from old accept state of input to start, to allow for repetition nfa.Transitions.Add(new Transition<NFA.State>(oldAcceptState, input.StartState)); // Create new accept state, link old accept state to new accept state with epsilon var acceptState = new NFA.State { AcceptState = true }; nfa.States.Add(acceptState); oldAcceptState.AcceptState = false; nfa.Transitions.Add(new Transition<NFA.State>(oldAcceptState, acceptState)); return nfa; }
public abstract LAD Reify(NFA pad);
public Frame list_common(bool eval, Frame th, Variable var) { VarDeque iter = Builtins.start_iter(var); List<object> toks = new List<object>(); List<LAD> lads = new List<LAD>(); NFA pad = new NFA(); pad.cursor_class = st.ns.klass; while (Kernel.IterHasFlat(iter, true)) { Variable svar = iter.Shift(); P6any sobj = svar.Fetch(); retry: if (sobj.Isa(Kernel.RegexMO)) { toks.Add(sobj); pad.outer_stack.Add(Kernel.GetOuter(sobj)); pad.info_stack.Add(Kernel.GetInfo(sobj)); lads.Add(pad.info_stack[0].ltm.Reify(pad)); pad.outer_stack.Clear(); pad.info_stack.Clear(); } else if (eval) { sobj = Builtins.compile_bind_regex(th, sobj.mo.mro_raw_Str.Get(svar)); svar = Kernel.NewROScalar(sobj); goto retry; } else { string str = sobj.mo.mro_raw_Str.Get(svar); toks.Add(str); lads.Add(new LADStr(str)); } } int[] cases = (new Lexer(pad, "array_var", lads.ToArray())). Run(global.orig_s, st.pos); Frame nth = th.MakeChild(null, ArrayHelperSI, Kernel.AnyP); nth.lex0 = MakeCursor(); nth.lex1 = toks; nth.lex2 = cases; return nth; }
public static NFA And(NFA first, NFA second) { // Create a new NFA and use the first NFAs start state as the starting point var nfa = new NFA { StartState = first.StartState }; // Change all links in to first acceptstate to go to seconds // start state foreach (var edge in first.Transitions.Where(f => f.To.AcceptState)) { edge.To = second.StartState; } // Remove acceptstate from first first.States.Remove(first.States.First(f => f.AcceptState)); // Add all states and edges in both NFAs // Second NFA already has an accept state, there is no need to create another one nfa.AddAll(first); nfa.AddAll(second); return nfa; }
public static Lexer GetDispatchLexer(STable kl, SubInfo disp) { LexerCache lc = kl.GetLexerCache(); Lexer ret; if (lc.dispatch_nfas.TryGetValue(disp, out ret)) return ret; if (lc.parent != null && lc.parent.mo.name != "Cursor" && lc.parent.mo.name != "Any") { ret = GetDispatchLexer(lc.parent.mo, disp); foreach (string u in ret.pad.used_methods) { if (lc.repl_methods.Contains(u)) goto anew; } if (LtmTrace) Console.WriteLine("Reused {0} dispatch lexer for {1} in {2}", disp.name, lc.parent.mo.name, kl.name); return lc.dispatch_nfas[disp] = ret; } anew: if (LtmTrace) { Console.WriteLine("Need new dispatch lexer for {0} in {1}", disp.name, kl.name); } NFA pad = new NFA(); pad.cursor_class = kl; P6any[] cands = (P6any[])disp.param[0]; LAD[] lads_p = new LAD[cands.Length]; for (int i = 0; i < lads_p.Length; i++) { pad.outer_stack.Add(Kernel.GetOuter(cands[i])); pad.info_stack.Add(Kernel.GetInfo(cands[i])); lads_p[i] = pad.info_stack[0].ltm.Reify(pad); pad.outer_stack.RemoveAt(pad.outer_stack.Count - 1); pad.info_stack.RemoveAt(pad.info_stack.Count - 1); } ret = new Lexer(pad, disp.name, lads_p); lc.dispatch_nfas[disp] = ret; return ret; }
public override void ToNFA(NFA pad, int from, int to) { int knot = pad.AddNode(); pad.nodes_l[knot].final = true; pad.AddEdge(from, knot, null); }
public void CollectFates(NFA nf, Lexer l) { for (int i = nf.nodes.Length - 1; i >= 0; i--) { if ((nstates[i >> 5] & (1 << (i & 31))) != 0) { NFA.Node n = nf.nodes[i]; if (n.final) { if (Lexer.LtmTrace) Console.WriteLine("+ Adding fate {0}", n.fate); l.NoteFate(n.fate); } } } }
public override LAD Reify(NFA pad) { Frame of = pad.outer_stack[pad.outer_stack.Count - 1]; SubInfo si = pad.info_stack[pad.info_stack.Count - 1]; while ((si == null || si.param == null) && of != null) { si = of.info; of = of.outer; } if (si == null || si.param == null || !(si.param[0] is P6any[])) throw new NieczaException("Cannot resolve dispatch operator"); P6any[] cands = si.param[0] as P6any[]; LAD[] opts = new LAD[cands.Length]; for (int i = 0; i < opts.Length; i++) { pad.outer_stack.Add(Kernel.GetOuter(cands[i])); pad.info_stack.Add(Kernel.GetInfo(cands[i])); opts[i] = Kernel.GetInfo(cands[i]).ltm.Reify(pad); pad.outer_stack.RemoveAt(pad.outer_stack.Count - 1); pad.info_stack.RemoveAt(pad.info_stack.Count - 1); } return new LADAny(opts); }
public override void ToNFA(NFA pad, int from, int to) { pad.AddEdge(from, to, CC.All); }
public override void ToNFA(NFA pad, int from, int to) { foreach (LAD k in zyg) k.ToNFA(pad, from, to); }
public override LAD Reify(NFA pad) { LAD[] nc = new LAD[zyg.Length]; for (int i = 0; i < zyg.Length; i++) nc[i] = zyg[i].Reify(pad); return new LADAny(nc); }
public abstract void ToNFA(NFA pad, int from, int to);
private static NFA RepeatZeroOrOnce(NFA nfa) { // Easy enough, add an epsilon transition from the start state // to the end state. Done nfa.Transitions.Add(new Transition<NFA.State>(nfa.StartState, nfa.States.First(f => f.AcceptState))); return nfa; }
public override void QueryLiteral(NFA pad, out int len, out bool cont) { throw new InvalidOperationException(); }
private static NFA NumberedRepeat(NFA nfa, int minRepetitions, int maxRepetitions) { // To create a suitable expression, the special case of infinite max repetitions // must be separately handled. bool infiniteMax = false; if (maxRepetitions == int.MaxValue) { infiniteMax = true; maxRepetitions = minRepetitions; } else if (maxRepetitions < minRepetitions) { maxRepetitions = minRepetitions; } // Copy the NFA max repetitions times, link them together. NFA output = nfa.Copy(); var epsilonLinkStates = new Stack<NFA.State>(); for (int i = 1; i < maxRepetitions; ++i) { NFA newNfa = nfa.Copy(); if (i >= minRepetitions || (infiniteMax && i == maxRepetitions - 1 )) { epsilonLinkStates.Push(newNfa.StartState); } output = And(output, newNfa); } if (infiniteMax) { // Use Single to force an exception if this has gone astray var finalState = epsilonLinkStates.Single(); // Make a little epsilon loop from the final accept state to the start state of the final state output.Transitions.Add(new Transition<NFA.State>(output.States.Single(f => f.AcceptState), finalState)); } else { // Add epsilon transitions from accept to beginning states of NFAs in the chain var acceptState = output.States.Single(f => f.AcceptState); while (epsilonLinkStates.Any()) { output.Transitions.Add(new Transition<NFA.State>(epsilonLinkStates.Pop(), acceptState)); } } return output; }
public override LAD Reify(NFA pad) { if (Lexer.LtmTrace) Console.WriteLine("+ Processing subrule {0}", name); if (name == "ws") return new LADImp(); pad.used_methods.Add(name); if (pad.name_stack.Contains(name)) { // NFAs cannot be recursive, so treat this as the end of the // declarative prefix. if (Lexer.LtmTrace) Console.WriteLine("+ Pruning to avoid recursion"); return new LADImp(); } DispatchEnt de; if (!pad.cursor_class.mro_methods.TryGetValue(name, out de) || de.info.ltm == null) return new LADImp(); pad.name_stack.Add(name); pad.outer_stack.Add(de.outer); pad.info_stack.Add(de.info); LAD ret = de.info.ltm.Reify(pad); pad.name_stack.Remove(name); pad.outer_stack.RemoveAt(pad.outer_stack.Count - 1); pad.info_stack.RemoveAt(pad.info_stack.Count - 1); return ret; }
public LexerState(NFA nf) { this.nstates = new int[(nf.nodes.Length + 31) >> 5]; }
public override void ToNFA(NFA pad, int from, int to) { throw new InvalidOperationException(); }
public static Lexer GetLexer(Frame fromf, STable kl, LAD[] lads, string title) { LexerCache lc = kl.GetLexerCache(); Lexer ret; if (lc.nfas.TryGetValue(lads, out ret)) return ret; if (lc.parent != null && lc.parent.mo.name != "Cursor" && lc.parent.mo.name != "Any") { ret = GetLexer(fromf, lc.parent.mo, lads, title); foreach (string u in ret.pad.used_methods) { if (lc.repl_methods.Contains(u)) goto anew; } if (LtmTrace) Console.WriteLine("Reused {0} alternation lexer for {1} in {2}", title, lc.parent.mo.name, kl.name); return lc.nfas[lads] = ret; } anew: if (LtmTrace) { Console.WriteLine("Need new alternation lexer for {0} in {1}", title, kl.name); } NFA pad = new NFA(); pad.cursor_class = kl; LAD[] lads_p = new LAD[lads.Length]; pad.outer_stack.Add(fromf); pad.info_stack.Add(fromf.info); for (int i = 0; i < lads_p.Length; i++) lads_p[i] = lads[i].Reify(pad); ret = new Lexer(pad, title, lads_p); lc.nfas[lads] = ret; return ret; }
public override LAD Reify(NFA pad) { return this; }
public LexerState Next(NFA nf, int ch) { LexerState l; if (dfc.TryGetValue(ch, out l)) return l; l = new LexerState(nf); for (int i = 0; i < nstates.Length; i++) { int bm = nstates[i]; for (int j = 0; j < 32; j++) { if ((bm & (1 << j)) == 0) continue; foreach (NFA.Edge e in nf.nodes[32*i + j].edges) { if (e.when != null && e.when.Accepts(ch)) l.Add(e.to); } } } nf.Close(l); LexerState cl; if (!nf.dfashare.TryGetValue(l, out cl)) { nf.dfashare[l] = cl = l; } dfc[ch] = cl; return cl; }
public virtual void QueryLiteral(NFA pad, out int len, out bool cont) { len = 0; cont = false; }