implab/ImplabNet Commit - r165:e227e78d72e4

DFA refactoring

cin -

r165:e227e78d72e4 ref20160224

parent child

Context file:

r165:e227e78d72e4

Expand all files

Implab/Automaton/IDFATable.cs created 644 +59 0

@@ -0,0 +1,59
	1	using System.Collections.Generic;
	2
	3
	4	namespace Implab.Automaton {
	5	/// <summary>
	6	/// Полностью описывает DFA автомат, его поведение, состояние и входные символы.
	7	/// </summary>
	8	/// <example>
	9	/// class MyAutomaton {
	10	/// int m_current;
	11	/// readonly DFAStateDescriptor<string>[] m_automaton;
	12	/// readonly IAlphabet<MyCommands> m_commands;
	13	///
	14	/// public MyAutomaton(IDFADefinition<MyCommands,MyStates,string> definition) {
	15	/// m_current = definition.StateAlphabet.Translate(MyStates.Initial);
	16	/// m_automaton = definition.GetTransitionTable();
	17	/// m_commands = definition.InputAlphabet;
	18	/// }
	19	///
	20	/// // defined a method which will move the automaton to the next state
	21	/// public void Move(MyCommands cmd) {
	22	/// // use transition map to determine the next state
	23	/// var next = m_automaton[m_current].transitions[m_commands.Translate(cmd)];
	24	///
	25	/// // validate that we aren't in the unreachable state
	26	/// if (next == DFAConst.UNREACHABLE_STATE)
	27	/// throw new InvalidOperationException("The specified command is invalid");
	28	///
	29	/// // if everything is ok
	30	/// m_current = next;
	31	/// }
	32	/// }
	33	/// </example>
	34	public interface IDFATable {
	35	/// <summary>
	36	/// Таблица переходов состояний автомата
	37	/// </summary>
	38	/// <returns>The transition table.</returns>
	39	DFAStateDescriptior[] GetTransitionTable();
	40
	41	int StateCount {
	42	get;
	43	}
	44
	45	int AlphabetSize {
	46	get;
	47	}
	48
	49	int InitialState {
	50	get;
	51	}
	52
	53	bool IsFinalState(int s);
	54
	55	IEnumerable<int> FinalStates {
	56	get;
	57	}
	58	}
	59	}

Implab/Automaton/IDFATableBuilder.cs created 644 +24 0

@@ -0,0 +1,24
	1	using System;
	2
	3	namespace Implab.Automaton {
	4	public interface IDFATableBuilder : IDFATable {
	5	/// <summary>
	6	/// Marks the state as final.
	7	/// </summary>
	8	/// <param name="state">State.</param>
	9	void MarkFinalState(int state);
	10
	11	/// <summary>
	12	/// Defines the transition from <paramref name="s1"/> to
	13	/// <paramref name="s2"/> with input <paramref name="symbol"/>.
	14	/// </summary>
	15	/// <param name="s1">S1.</param>
	16	/// <param name="s2">S2.</param>
	17	/// <param name="symbol">Symbol.</param>
	18	void DefineTransition(int s1, int s2, int symbol);
	19
	20	void SetInitialState(int s);
	21
	22	}
	23	}
	24

Implab/Formats/RegularCharDFADefinition.cs created 644 +17 0

@@ -0,0 +1,17
	1	using System;
	2	using Implab.Automaton.RegularExpressions;
	3
	4	namespace Implab.Formats {
	5	public class RegularCharDFADefinition<TTag> : RegularDFADefinition<char,TTag> {
	6	readonly CharAlphabet m_alphabet;
	7
	8	public RegularCharDFADefinition(CharAlphabet alphabet) : base(alphabet) {
	9	m_alphabet = alphabet;
	10	}
	11
	12	public new CharAlphabet InputAlphabet {
	13	get { return m_alphabet; }
	14	}
	15	}
	16	}
	17

Implab/Automaton/DFAStateDescriptor.cs +12 -4

@@ -1,7 +1,15
1	namespace Implab.Automaton {	1	namespace Implab.Automaton {
2	public struct DFAStateDescriptior<~~TTag~~> {	2	public struct DFAStateDescriptior {
3	public bool final;	3	public readonly bool final;
4	public ~~TTag~~[] tag;	4	public readonly int[] transitions;
5	public int[] transitions;	5
		6
		7	public DFAStateDescriptior(int[] transitions, bool final) {
		8	this.transitions = transitions;
		9	this.final = final;
		10	}
		11
		12	public DFAStateDescriptior(int[] transitions) : this(transitions, false) {
		13	}
6	}	14	}
7	}	15	}

Implab/Automaton/DFATransitionTable.cs +4 -4

             using Implab;
             using System;
             using System.Collections.Generic;
             using System.Linq;
             namespace Implab.Automaton {
-                public class DFATransitionTable<TTag> : IDFATransitionTableBuilder<TTag> {
+                public class DFATransitionTable<TTag> : IDFATableBuilder {
-                    DFAStateDescriptior<TTag>[] m_dfaTable;
+                    DFAStateDescriptior[] m_dfaTable;
                     int m_stateCount;
                     int m_symbolCount;
                     int m_initialState;
                     readonly Dictionary<int, TTag[]> m_finalStates = new Dictionary<int, TTag[]>();
                     readonly HashSet<AutomatonTransition> m_transitions = new HashSet<AutomatonTransition>();
                     #region IDFADefinition implementation
-                    public DFAStateDescriptior<TTag>[] GetTransitionTable() {
+                    public DFAStateDescriptior[] GetTransitionTable() {
                         if (m_dfaTable == null) {
                             if (m_stateCount <= 0)
                                 throw new InvalidOperationException("Invalid automaton definition: states count = {0}", m_stateCount);
                             if (m_symbolCount <= 0)
                                 throw new InvalidOperationException("Invalid automaton definition: symbols count = {0}", m_symbolCount);
                             m_dfaTable = ConstructTransitionTable();
                         }
                         return m_dfaTable;
                     }
                     public bool IsFinalState(int s) {
                         Safe.ArgumentInRange(s, 0, m_stateCount, "s");
                         return m_finalStates.ContainsKey(s);
                     }
                     public IEnumerable<KeyValuePair<int,TTag[]>> FinalStates {
                         get {
                             return m_finalStates;
                         }
                     }
                     public int StateCount {
                         get { return m_stateCount; }
                     }
                     public int AlphabetSize {
                         get { return m_symbolCount; }
                     }
                     public int InitialState {
                         get { return m_initialState; }
                     }
                     #endregion
                     protected virtual DFAStateDescriptior<TTag>[] ConstructTransitionTable() {
                         var dfaTable = new DFAStateDescriptior<TTag>[m_stateCount];
                         foreach (var pair in m_finalStates) {
                             var idx = pair.Key;
                             dfaTable[idx].final = true;
                             dfaTable[idx].tag = pair.Value;
                         }
                         foreach (var t in m_transitions) {
                             if (dfaTable[t.s1].transitions == null) {
                                 dfaTable[t.s1].transitions = new int[m_symbolCount];
                                 for (int i = 0; i < dfaTable[t.s1].transitions.Length; i++)
                                     dfaTable[t.s1].transitions[i] = DFAConst.UNREACHABLE_STATE;
                             }
                             dfaTable[t.s1].transitions[t.edge] = t.s2;
                         }
                     }
                     #region IDFADefinitionBuilder
                     public void DefineTransition(int s1, int s2, int symbol) {
                         if (m_dfaTable != null)
                             throw new InvalidOperationException("The transition table is already built");
                         Safe.ArgumentAssert(s1 > 0, "s1");
                         Safe.ArgumentAssert(s2 > 0, "s2");
                         Safe.ArgumentAssert(symbol >= 0, "symbol");
                         m_stateCount = Math.Max(Math.Max(m_stateCount, s1 + 1), s2 + 1);
                         m_symbolCount = Math.Max(m_symbolCount, symbol + 1);
                         m_transitions.Add(new AutomatonTransition(s1, s2, symbol));
                     }
                     public void MarkFinalState(int state, params TTag[] tags) {
                         if (m_dfaTable != null)
                             throw new InvalidOperationException("The transition table is already built");
                         m_finalStates[state] = tags;
                     }
                     public void SetInitialState(int s) {
                         Safe.ArgumentAssert(s >= 0, "s");
                         m_initialState = s;
                     }
                     #endregion
                     protected void Optimize<TInput, TState>(
-                        IDFATransitionTableBuilder<TTag> optimalDFA,
+                        IDFATableBuilder<TTag> optimalDFA,
                         IAlphabet<TInput> inputAlphabet,
                         IAlphabetBuilder<TInput> optimalInputAlphabet,
                         IAlphabet<TState> stateAlphabet,
                         IAlphabetBuilder<TState> optimalStateAlphabet
                     ) {
                         Safe.ArgumentNotNull(optimalDFA, "dfa");
                         Safe.ArgumentNotNull(optimalInputAlphabet, "optimalInputAlphabet");
                         Safe.ArgumentNotNull(optimalStateAlphabet, "optimalStateAlphabet");
                         Safe.ArgumentNotNull(inputAlphabet, "inputAlphabet");
                         Safe.ArgumentNotNull(stateAlphabet, "stateAlphabet");
                         if (inputAlphabet.Count != m_symbolCount)
                             throw new InvalidOperationException("The input symbols aphabet mismatch");
                         if (stateAlphabet.Count != m_stateCount)
                             throw new InvalidOperationException("The states alphabet mismatch");
                         var setComparer = new CustomEqualityComparer<HashSet<int>>(
                             (x, y) => x.SetEquals(y),
                             s => s.Sum(x => x.GetHashCode())
                         );
                         var arrayComparer = new CustomEqualityComparer<TTag[]>(
                             (x,y) => (new HashSet<int>(x)).SetEquals(new HashSet<int>(y)),
                             a => a.Sum(x => x.GetHashCode())
                         );
                         var optimalStates = new HashSet<HashSet<int>>(setComparer);
                         var queue = new HashSet<HashSet<int>>(setComparer);
                         // получаем конечные состояния, сгруппированные по маркерам
                         optimalStates.UnionWith(
                             m_finalStates
                             .GroupBy(pair => pair.Value, arrayComparer)
                             .Select(
                                 g => new HashSet<int>(
                                     g.Select( pair => pair.Key)
                                 )
                             )
                         );
                         var state = new HashSet<int>(
                             Enumerable
                             .Range(0, m_stateCount - 1)
                             .Where(i => !m_finalStates.ContainsKey(i))
                         );
                         optimalStates.Add(state);
                         queue.Add(state);
                         var rmap = m_transitions
                             .GroupBy(t => t.s2)
                             .ToLookup(
                                 g => g.Key, // s2
                                 g => g.ToLookup(t => t.edge, t => t.s1)
                             );
                         while (queue.Count > 0) {
                             var stateA = queue.First();
                             queue.Remove(stateA);
                             for (int c = 0; c < m_symbolCount; c++) {
                                 var stateX = new HashSet<int>();
                                 foreach(var a in stateA)
                                     stateX.UnionWith(rmap[a][c]); // all states from wich 'c' leads to 'a'
                                 foreach (var stateY in optimalStates.ToArray()) {
                                     if (stateX.Overlaps(stateY) && !stateY.IsSubsetOf(stateX)) {
                                         var stateR1 = new HashSet<int>(stateY);
                                         var stateR2 = new HashSet<int>(stateY);
                                         stateR1.IntersectWith(stateX);
                                         stateR2.ExceptWith(stateX);
                                         optimalStates.Remove(stateY);
                                         optimalStates.Add(stateR1);
                                         optimalStates.Add(stateR2);
                                         if (queue.Contains(stateY)) {
                                             queue.Remove(stateY);
                                             queue.Add(stateR1);
                                             queue.Add(stateR2);
                                         } else {
                                             queue.Add(stateR1.Count <= stateR2.Count ? stateR1 : stateR2);
                                         }
                                     }
                                 }
                             }
                         }
                         // карта получения оптимального состояния по соотвествующему ему простому состоянию
                         var statesMap = stateAlphabet.Reclassify(optimalStateAlphabet, optimalStates);
                         // получаем минимальный алфавит
                         // входные символы не различимы, если Move(s,a1) == Move(s,a2)
                         var optimalAlphabet = m_transitions
                             .GroupBy(t => Tuple.Create(statesMap[t.s1], statesMap[t.s2]), t => t.edge);
                         var alphabetMap = inputAlphabet.Reclassify(optimalInputAlphabet, optimalAlphabet);
                         var optimalTags = m_finalStates
                             .GroupBy(pair => statesMap[pair.Key])
                             .ToDictionary(
                                 g => g.Key,
                                 g => g.SelectMany(pair => pair.Value).ToArray()
                             );
                         // построение автомата
                         optimalDFA.SetInitialState(statesMap[m_initialState]);
                         foreach (var pair in optimalTags)
                             optimalDFA.MarkFinalState(pair.Key, pair.Value);
                         foreach (var t in m_transitions.Select(t => new AutomatonTransition(statesMap[t.s1],statesMap[t.s2],alphabetMap[t.edge])).Distinct())
                             optimalDFA.DefineTransition(t.s1, t.s2, t.edge);
                     }
                     protected void PrintDFA<TInput, TState>(IAlphabet<TInput> inputAlphabet, IAlphabet<TState> stateAlphabet) {
                         Safe.ArgumentNotNull(inputAlphabet, "inputAlphabet");
                         Safe.ArgumentNotNull(stateAlphabet, "stateAlphabet");
                         var inputMap = inputAlphabet.CreateReverseMap();
                         var stateMap = stateAlphabet.CreateReverseMap();
                         for (int i = 0; i < inputMap.Length; i++)
                             Console.WriteLine("C{0}: {1}", i, String.Join(",", inputMap[i]));
                         foreach(var t in m_transitions)
                             Console.WriteLine(
                                 "[{0}] -{{{1}}}-> [{2}]{3}",
                                 stateMap[t.s1],
                                 String.Join(",", inputMap[t.edge]),
                                 stateMap[t.s2],
                                 m_finalStates.ContainsKey(t.s2) ? "$" : ""
                             );
                     }
                 }
             }

Implab/Automaton/RegularExpressions/Grammar.cs +21 -25

             using Implab;
             using System;
             using System.Collections.Generic;
             using System.Linq;
-            using System.Text;
-            using System.Threading.Tasks;
             namespace Implab.Automaton.RegularExpressions {
                 /// <summary>
                 /// Базовый абстрактный класс. Грамматика, позволяет формулировать выражения над алфавитом типа <c>char</c>.
                 /// </summary>
-                    public abstract class Grammar<TSymbol, TTag> {
+                public abstract class Grammar<TSymbol, TTag> {
-                    public abstract IAlphabetBuilder<TSymbol> Alphabet {
+                    protected abstract IAlphabetBuilder<TSymbol> AlphabetBuilder {
                         get;
                     }
-                    public SymbolToken<TTag> UnclassifiedToken() {
+                    protected SymbolToken<TTag> UnclassifiedToken() {
                         return new SymbolToken<TTag>(DFAConst.UNCLASSIFIED_INPUT);
                     }
-                    public void DefineAlphabet(IEnumerable<TSymbol> alphabet) {
+                    protected void DefineAlphabet(IEnumerable<TSymbol> alphabet) {
                         Safe.ArgumentNotNull(alphabet, "alphabet");
                         foreach (var ch in alphabet)
-                            Alphabet.DefineSymbol(ch);
+                            AlphabetBuilder.DefineSymbol(ch);
                     }
-                    public Token<TTag> SymbolToken(TSymbol symbol) {
+                    protected Token<TTag> SymbolToken(TSymbol symbol) {
                         return Token<TTag>.New(TranslateOrAdd(symbol));
                     }
-                    public Token<TTag> SymbolToken(IEnumerable<TSymbol> symbols) {
+                    protected Token<TTag> SymbolToken(IEnumerable<TSymbol> symbols) {
                         Safe.ArgumentNotNull(symbols, "symbols");
                         return Token<TTag>.New(TranslateOrAdd(symbols).ToArray());
                     }
-                    public Token<TTag> SymbolSetToken(params TSymbol[] set) {
+                    protected Token<TTag> SymbolSetToken(params TSymbol[] set) {
                         return SymbolToken(set);
                     }
                     int TranslateOrAdd(TSymbol ch) {
-                        var t = Alphabet.Translate(ch);
+                        var t = AlphabetBuilder.Translate(ch);
                         if (t == DFAConst.UNCLASSIFIED_INPUT)
-                            t = Alphabet.DefineSymbol(ch);
+                            t = AlphabetBuilder.DefineSymbol(ch);
                         return t;
                     }
                     IEnumerable<int> TranslateOrAdd(IEnumerable<TSymbol> symbols) {
                         return symbols.Distinct().Select(TranslateOrAdd);
                     }
                     int TranslateOrDie(TSymbol ch) {
-                        var t = Alphabet.Translate(ch);
+                        var t = AlphabetBuilder.Translate(ch);
                         if (t == DFAConst.UNCLASSIFIED_INPUT)
                                 throw new ApplicationException(String.Format("Symbol '{0}' is UNCLASSIFIED", ch));
                         return t;
                     }
                     IEnumerable<int> TranslateOrDie(IEnumerable<TSymbol> symbols) {
                         return symbols.Distinct().Select(TranslateOrDie);
                     }
-                    public Token<TTag> SymbolTokenExcept(IEnumerable<TSymbol> symbols) {
+                    protected Token<TTag> SymbolTokenExcept(IEnumerable<TSymbol> symbols) {
                         Safe.ArgumentNotNull(symbols, "symbols");
-                        return Token<TTag>.New( Enumerable.Range(0, Alphabet.Count).Except(TranslateOrDie(symbols)).ToArray() );
+                        return Token<TTag>.New( Enumerable.Range(0, AlphabetBuilder.Count).Except(TranslateOrDie(symbols)).ToArray() );
                     }
-                    protected CDFADefinition BuildDFA(Token<TTag> lang) {
+                    protected void BuildDFA(Token<TTag> lang, IDFATableBuilder<TTag> dfaTable, IAlphabetBuilder<TSymbol> dfaAlphabet) {
                         Safe.ArgumentNotNull(lang, "lang");
+                        Safe.ArgumentNotNull(dfaAlphabet, "dfaAlphabet");
-                        var dfa = new RegularDFADefinition<TSymbol, TTag>(Alphabet, 0);
+                        var dfa = new RegularDFADefinition<TSymbol, TTag>(AlphabetBuilder);
-                        var table = new DFATransitionTable<TTag>();
                         var builder = new RegularDFABuilder<TTag>();
                         lang.Accept( builder );
-                        var initialState = builder.BuildDFA(table);
+                        builder.BuildDFA(dfa);
-                        if (table.IsFinalState(initialState))
+                        if (dfa.IsFinalState(dfa.InitialState))
                             throw new ApplicationException("The specified language contains empty token");
-                        return dfa.Optimize();
+                        dfa.Optimize(dfaTable, dfaAlphabet);
                     }
-                    //protected abstract TGrammar CreateInstance();
                 }
             }

Implab/Automaton/RegularExpressions/RegularDFABuilder.cs +9 -9

             using Implab;
             using System;
             using System.Collections.Generic;
             using System.Diagnostics;
             using System.Linq;
             namespace Implab.Automaton.RegularExpressions {
                 /// <summary>
                 /// Используется для построения ДКА по регулярному выражению, сначала обходит
                 /// регулярное выражение и вычисляет followpos, затем используется метод
                 /// <see cref="BuildDFA(IDFADefinition)"/> для построения автомата.
                 /// </summary>
                 public class RegularDFABuilder<TTag> : IVisitor<TTag> {
-                    int m_idx = 0;
+                    int m_idx;
                     Token<TTag> m_root;
                     HashSet<int> m_firstpos;
                     HashSet<int> m_lastpos;
                     readonly Dictionary<int, HashSet<int>> m_followpos = new Dictionary<int, HashSet<int>>();
                     readonly Dictionary<int, int> m_indexes = new Dictionary<int, int>();
                     readonly Dictionary<int, TTag> m_ends = new Dictionary<int, TTag>();
                     public Dictionary<int, HashSet<int>> FollowposMap {
                         get { return m_followpos; }
                     }
                     public HashSet<int> Followpos(int pos) {
                         HashSet<int> set;
-                        if (m_followpos.TryGetValue(pos, out set))
+                        return m_followpos.TryGetValue(pos, out set) ? set : m_followpos[pos] = new HashSet<int>();
-                            return set;
-                        return m_followpos[pos] = new HashSet<int>();
                     }
                     bool Nullable(object n) {
                         if (n is EmptyToken<TTag> || n is StarToken<TTag>)
                             return true;
-                        if (n is AltToken<TTag>)
+                        var altToken = n as AltToken<TTag>;
-                            return Nullable(((AltToken<TTag>)n).Left) || Nullable(((AltToken<TTag>)n).Right);
+                        if (altToken != null)
-                        if (n is CatToken<TTag>)
+                            return Nullable(altToken.Left) || Nullable(altToken.Right);
-                            return Nullable(((CatToken<TTag>)n).Left) && Nullable(((CatToken<TTag>)n).Right);
+                        var catToken = n as CatToken<TTag>;
+                        if (catToken != null)
+                            return Nullable(catToken.Left) && Nullable(catToken.Right);
                         return false;
                     }
                     public void Visit(AltToken<TTag> token) {
                         if (m_root == null)
                             m_root = token;
                         var firtspos = new HashSet<int>();
                         var lastpos = new HashSet<int>();
                         token.Left.Accept(this);
                         firtspos.UnionWith(m_firstpos);
                         lastpos.UnionWith(m_lastpos);
                         token.Right.Accept(this);
                         firtspos.UnionWith(m_firstpos);
                         lastpos.UnionWith(m_lastpos);
                         m_firstpos = firtspos;
                         m_lastpos = lastpos;
                     }
                     public void Visit(StarToken<TTag> token) {
                         if (m_root == null)
                             m_root = token;
                         token.Token.Accept(this);
                         foreach (var i in m_lastpos)
                             Followpos(i).UnionWith(m_firstpos);
                     }
                     public void Visit(CatToken<TTag> token) {
                         if (m_root == null)
                             m_root = token;
                         var firtspos = new HashSet<int>();
                         var lastpos = new HashSet<int>();
                         token.Left.Accept(this);
                         firtspos.UnionWith(m_firstpos);
                         var leftLastpos = m_lastpos;
                         token.Right.Accept(this);
                         lastpos.UnionWith(m_lastpos);
                         var rightFirstpos = m_firstpos;
                         if (Nullable(token.Left))
                             firtspos.UnionWith(rightFirstpos);
                         if (Nullable(token.Right))
                             lastpos.UnionWith(leftLastpos);
                         m_firstpos = firtspos;
                         m_lastpos = lastpos;
                         foreach (var i in leftLastpos)
                             Followpos(i).UnionWith(rightFirstpos);
                     }
                     public void Visit(EmptyToken<TTag> token) {
                         if (m_root == null)
                             m_root = token;
                     }
                     public void Visit(SymbolToken<TTag> token) {
                         if (m_root == null)
                             m_root = token;
                         m_idx++;
                         m_indexes[m_idx] = token.Value;
                         m_firstpos = new HashSet<int>(new[] { m_idx });
                         m_lastpos = new HashSet<int>(new[] { m_idx });
                     }
                     public void Visit(EndToken<TTag> token) {
                         if (m_root == null)
                             m_root = token;
                         m_idx++;
                         m_indexes[m_idx] = DFAConst.UNCLASSIFIED_INPUT;
                         m_firstpos = new HashSet<int>(new[] { m_idx });
                         m_lastpos = new HashSet<int>(new[] { m_idx });
                         Followpos(m_idx);
                         m_ends.Add(m_idx, token.Tag);
                     }
-                    public void BuildDFA(IDFATransitionTableBuilder<TTag> dfa) {
+                    public void BuildDFA(IDFATableBuilder<TTag> dfa) {
                         Safe.ArgumentNotNull(dfa,"dfa");
                         var states = new MapAlphabet<HashSet<int>>(new CustomEqualityComparer<HashSet<int>>(
                                          (x, y) => x.SetEquals(y),
                                          x => x.Sum(n => n.GetHashCode())
                                      ));
                         var initialState = states.DefineSymbol(m_firstpos);
                         dfa.SetInitialState(initialState);
                         var tags = GetStateTags(m_firstpos);
                         if (tags != null && tags.Length > 0)
                             dfa.MarkFinalState(initialState, tags);
                         var inputMax = m_indexes.Values.Max();
                         var queue = new Queue<HashSet<int>>();
                         queue.Enqueue(m_firstpos);
                         while (queue.Count > 0) {
                             var state = queue.Dequeue();
                             var s1 = states.Translate(state);
                             Debug.Assert(s1 != DFAConst.UNCLASSIFIED_INPUT);
                             for (int a = 0; a <= inputMax; a++) {
                                 var next = new HashSet<int>();
                                 foreach (var p in state) {
                                     if (m_indexes[p] == a) {
                                         next.UnionWith(Followpos(p));
                                     }
                                 }
                                 if (next.Count > 0) {
                                     int s2 = states.Translate(next);
                                     if (s2 == DFAConst.UNCLASSIFIED_INPUT) {
                                         s2 = states.DefineSymbol(next);
                                         tags = GetStateTags(next);
                                         if (tags != null && tags.Length > 0)
                                             dfa.MarkFinalState(s2, tags);
                                         queue.Enqueue(next);
                                     }
                                     dfa.DefineTransition(s1, s2, a);
                                 }
                             }
                         }
                     }
                     TTag[] GetStateTags(IEnumerable<int> state) {
                         Debug.Assert(state != null);
                         return state.Where(m_ends.ContainsKey).Select(pos => m_ends[pos]).ToArray();
                     }
                 }
             }

Implab/Automaton/RegularExpressions/RegularDFADefinition.cs +5 -8

             using System;
             namespace Implab.Automaton.RegularExpressions {
                 public class RegularDFADefinition<TInput, TTag> : DFATransitionTable<TTag>, IDFATransitionTable<TTag> {
                     readonly IAlphabet<TInput> m_alphabet;
-                    readonly int m_initialState;
-                    public RegularDFADefinition(IAlphabet<TInput> alphabet, int initialState) {
+                    public RegularDFADefinition(IAlphabet<TInput> alphabet) {
                         Safe.ArgumentNotNull(alphabet, "aplhabet");
                         m_alphabet = alphabet;
-                        m_initialState = initialState;
                     }
                     public IAlphabet<TInput> InputAlphabet {
                         get {
                             return m_alphabet;
                         }
                     }
                     protected override DFAStateDescriptior<TTag>[] ConstructTransitionTable() {
                         if (InputAlphabet.Count != m_alphabet.Count)
                             throw new InvalidOperationException("The alphabet doesn't match the transition table");
                         return base.ConstructTransitionTable();
                     }
                     /// <summary>
                     /// Optimize the specified alphabet.
                     /// </summary>
+                    /// <param name = "dfaTable"></param>
                     /// <param name="alphabet">Пустой алфавит, который будет зполнен в процессе оптимизации.</param>
-                    public  RegularDFADefinition<TInput, TTag> Optimize(IAlphabetBuilder<TInput> alphabet) {
+                    public void Optimize(IDFATableBuilder<TTag> dfaTable, IAlphabetBuilder<TInput> alphabet) {
                         Safe.ArgumentNotNull(alphabet, "alphabet");
+                        Safe.ArgumentNotNull(dfaTable, "dfaTable");
-                        var optimalDFA = new RegularDFADefinition<TInput,TTag>(alphabet, m_initialState);
+                        Optimize(dfaTable, InputAlphabet, alphabet, new DummyAlphabet(StateCount), new MapAlphabet<int>());
-                        Optimize(optimalDFA, InputAlphabet, alphabet, new DummyAlphabet(StateCount), new MapAlphabet<int>());
                     }
                 }
             }

Implab/Automaton/RegularExpressions/Token.cs +3 -3

             using Implab;
             using System;
             using System.Linq;
             namespace Implab.Automaton.RegularExpressions {
                 public abstract class Token<TTag> {
                     public abstract void Accept(IVisitor<TTag> visitor);
                     public Token<TTag> Extend() {
                         return Cat(new EndToken<TTag>());
                     }
-                    public Token<TTag> Tag<T>(T tag) where T : IConvertible {
+                    public Token<TTag> Tag(TTag tag) {
                         return Cat(new EndToken<TTag>(tag));
                     }
                     public Token<TTag> Cat(Token<TTag> right) {
                         return new CatToken<TTag>(this, right);
                     }
                     public Token<TTag> Or(Token<TTag> right) {
                         return new AltToken<TTag>(this, right);
                     }
                     public Token<TTag> Optional() {
                         return Or(new EmptyToken<TTag>());
                     }
                     public Token<TTag> EClosure() {
                         return new StarToken<TTag>(this);
                     }
                     public Token<TTag> Closure() {
                         return Cat(new StarToken<TTag>(this));
                     }
                     public Token<TTag> Repeat(int count) {
                         Token<TTag> token = null;
                         for (int i = 0; i < count; i++)
                             token = token != null ? token.Cat(this) : this;
                         return token ?? new EmptyToken<TTag>();
                     }
                     public Token<TTag> Repeat(int min, int max) {
                         if (min > max || min < 1)
                             throw new ArgumentOutOfRangeException();
                         var token = Repeat(min);
                         for (int i = min; i < max; i++)
-                            token = token.Cat( this.Optional() );
+                            token = token.Cat( Optional() );
                         return token;
                     }
-                    public static Token<TTag> New<T>(params T[] set) where T : struct, IConvertible {
+                    public static Token<TTag> New(params int[] set) {
                         Safe.ArgumentNotNull(set, "set");
                         Token<TTag> token = null;
                         foreach(var c in set.Distinct())
                             token = token == null ? new SymbolToken<TTag>(c) : token.Or(new SymbolToken<TTag>(c));
                         return token;
                     }
                 }
             }

Implab/Automaton/Scanner.cs +12 -12

             using Implab;
             using System;
             using System.Collections.Generic;
             using System.IO;
             using Implab.Components;
             namespace Implab.Automaton {
                 /// <summary>
                 /// Базовый класс для разбора потока входных символов на токены.
                 /// </summary>
                 /// <remarks>
                 /// Сканнер имеет внутри буффер с симолами входного текста, по которому перемещаются два
                 /// указателя, начала и конца токена, при перемещении искользуется ДКА для определения
                 /// конца токена и допустимости текущего символа.
                 /// </remarks>
                 public abstract class Scanner<TTag> : Disposable {
                     struct ScannerConfig {
                         public DFAStateDescriptior<TTag>[] states;
                         public int[] alphabetMap;
                         public int initialState;
                     }
                     Stack<ScannerConfig> m_defs = new Stack<ScannerConfig>();
                     DFAStateDescriptior<TTag>[] m_states;
                     int[] m_alphabetMap;
                     int m_initialState;
                     protected DFAStateDescriptior<TTag> m_currentState;
                     int m_previewCode;
-                    protected int m_tokenLen = 0;
+                    protected int m_tokenLen;
                     protected int m_tokenOffset;
                     protected char[] m_buffer;
                     protected int m_bufferSize;
                     protected int m_pointer;
                     TextReader m_reader;
                     bool m_disposeReader;
                     int m_chunkSize = 1024; // 1k
                     int m_limit = 10 * 1024 * 1024; // 10Mb
                     protected Scanner(DFAStateDescriptior<TTag>[] states, int[] alphabet, int initialState) {
                         Safe.ArgumentNotEmpty(states, "states");
                         Safe.ArgumentNotNull(alphabet, "alphabet");
                         m_states = states;
                         m_alphabetMap = alphabet;
                         m_initialState = initialState;
                         Feed(new char[0]);
                     }
                     /// <summary>
                     /// Заполняет входными данными буффер.
                     /// </summary>
                     /// <param name="data">Данные для обработки.</param>
                     /// <remarks>Копирование данных не происходит, переданный массив используется в
                     /// качестве входного буффера.</remarks>
                     public void Feed(char[] data) {
                         Safe.ArgumentNotNull(data, "data");
                         Feed(data, data.Length);
                     }
                     /// <summary>
                     /// Заполняет буффур чтения входными данными.
                     /// </summary>
                     /// <param name="data">Данные для обработки.</param>
                     /// <param name="length">Длина данных для обработки.</param>
                     /// <remarks>Копирование данных не происходит, переданный массив используется в
                     /// качестве входного буффера.</remarks>
                     public void Feed(char[] data, int length) {
                         Safe.ArgumentNotNull(data, "data");
                         Safe.ArgumentInRange(length, 0, data.Length, "length");
                         AssertNotDisposed();
                         m_pointer = -1;
                         m_buffer = data;
                         m_bufferSize = length;
                         Shift();
                     }
                     public void Feed(TextReader reader, bool dispose) {
                         Safe.ArgumentNotNull(reader, "reader");
                         AssertNotDisposed();
                         if (m_reader != null && m_disposeReader)
                             m_reader.Dispose();
                         m_reader = reader;
                         m_disposeReader = dispose;
                         m_pointer = -1;
                         m_buffer = new char[m_chunkSize];
                         m_bufferSize = 0;
                         Shift();
                     }
                     /// <summary>
                     /// Получает текущий токен в виде строки.
                     /// </summary>
                     /// <returns></returns>
                     protected string GetTokenValue() {
                         return new String(m_buffer, m_tokenOffset, m_tokenLen);
                     }
                     /// <summary>
                     /// Метки текущего токена, которые были назначены в регулярном выражении.
                     /// </summary>
                     protected TTag[] TokenTags {
                         get {
                             return m_currentState.tag;
                         }
                     }
                     /// <summary>
                     /// Признак конца данных
                     /// </summary>
                     public bool EOF {
                         get {
                             return m_pointer >= m_bufferSize;
                         }
                     }
                     /// <summary>
                     /// Читает следующий токен, при этом <see cref="m_tokenOffset"/> указывает на начало токена,
                     /// <see cref="m_tokenLen"/> на длину токена, <see cref="m_buffer"/> - массив символов, в
                     /// котором находится токен.
                     /// </summary>
                     /// <returns><c>false</c> - достигнут конец данных, токен не прочитан.</returns>
                     protected bool ReadTokenInternal() {
                         if (m_pointer >= m_bufferSize)
                             return false;
                         m_currentState = m_states[m_initialState];
                         m_tokenLen = 0;
                         m_tokenOffset = m_pointer;
                         int nextState;
                         do {
                             nextState = m_currentState.transitions[m_previewCode];
                             if (nextState == DFAConst.UNREACHABLE_STATE) {
                                 if (m_currentState.final)
                                     return true;
-                                else
-                                    throw new ParserException(
+                                throw new ParserException(
-                                        String.Format(
+                                    String.Format(
-                                            "Unexpected symbol '{0}', at pos {1}",
+                                        "Unexpected symbol '{0}', at pos {1}",
-                                            m_buffer[m_pointer],
+                                        m_buffer[m_pointer],
-                                            Position
+                                        Position
+                                    )
-                                    );
+                                );
-                            } else {
-                                m_currentState = m_states[nextState];
-                                m_tokenLen++;
                             }
+                            m_currentState = m_states[nextState];
+                            m_tokenLen++;
                         } while (Shift());
                         // END OF DATA
                         if (!m_currentState.final)
                             throw new ParserException("Unexpected end of data");
                         return true;
                     }
                     bool Shift() {
                         m_pointer++;
                         if (m_pointer >= m_bufferSize) {
                             if (!ReadNextChunk())
                                 return false;
                         }
                         m_previewCode = m_alphabetMap[m_buffer[m_pointer]];
                         return true;
                     }
                     bool ReadNextChunk() {
                         if (m_reader == null)
                             return false;
                         //  extend buffer if nesessary
                         if (m_pointer + m_chunkSize > m_buffer.Length) {
                             // trim unused buffer head
                             var size = m_tokenLen + m_chunkSize;
                             if (size >= m_limit)
                                 throw new ParserException(String.Format("Input buffer {0} bytes limit exceeded", m_limit));
                             var temp = new char[size];
                             Array.Copy(m_buffer, m_tokenOffset, temp, 0, m_tokenLen);
                             m_pointer -= m_tokenOffset;
                             m_bufferSize -= m_tokenOffset;
                             m_tokenOffset = 0;
                             m_buffer = temp;
                         }
                         var read = m_reader.Read(m_buffer, m_tokenLen, m_chunkSize);
                         if (read == 0)
                             return false;
                         m_bufferSize += read;
                         return true;
                     }
                     /// <summary>
                     /// Позиция сканнера во входном буфере
                     /// </summary>
                     public int Position {
                         get {
                             return m_pointer + 1;
                         }
                     }
                     /// <summary>
                     /// Преключает внутренний ДКА на указанный, позволяет реализовать подобие захватывающей
                     /// группировки.
                     /// </summary>
                     /// <param name="states">Таблица состояний нового ДКА</param>
                     /// <param name="alphabet">Таблица входных символов для нового ДКА</param>
+                    /// <param name = "initialState"></param>
                     protected void Switch(DFAStateDescriptior<TTag>[] states, int[] alphabet, int initialState) {
                         Safe.ArgumentNotNull(states, "dfa");
                         m_defs.Push(new ScannerConfig {
                             states = m_states,
                             alphabetMap = m_alphabetMap,
                             initialState = m_initialState
                         });
                         m_states = states;
                         m_alphabetMap = alphabet;
                         m_initialState = initialState;
                         m_previewCode = m_alphabetMap[m_buffer[m_pointer]];
                     }
                     /// <summary>
                     /// Восстанавливает предыдущей ДКА сканнера.
                     /// </summary>
                     protected void Restore() {
                         if (m_defs.Count == 0)
                             throw new InvalidOperationException();
                         var prev = m_defs.Pop();
                         m_states = prev.states;
                         m_alphabetMap = prev.alphabetMap;
                         m_initialState = prev.initialState;
                         m_previewCode = m_alphabetMap[m_buffer[m_pointer]];
                     }
                     protected override void Dispose(bool disposing) {
                         if (disposing) {
                             if (m_reader != null && m_disposeReader)
                                 m_reader.Dispose();
                             m_buffer = null;
                             m_bufferSize = 0;
                             m_pointer = 0;
                             m_tokenLen = 0;
                             m_tokenOffset = 0;
                         }
                         base.Dispose(disposing);
                     }
                 }
             }

Implab/Formats/ByteAlphabet.cs +3 -3

-            using System;
+            using System.Collections.Generic;
-            using System.Collections.Generic;
             using System.Linq;
+            using Implab.Automaton;
-            namespace Implab.Automaton {
+            namespace Implab.Formats {
                 public class ByteAlphabet : IndexedAlphabetBase<byte> {
                     public ByteAlphabet() : base(byte.MaxValue + 1){
                     }
                     #region implemented abstract members of IndexedAlphabetBase
                     public override int GetSymbolIndex(byte symbol) {
                         return (int)symbol;
                     }
                     public IEnumerable<byte> InputSymbols {
                         get {
                             return Enumerable.Range(byte.MinValue, byte.MaxValue).Cast<byte>();
                         }
                     }
                     #endregion
                 }
             }

Implab/Formats/CharAlphabet.cs +3 -6

-            using Implab;
+            using System.Collections.Generic;
-            using System;
-            using System.Collections.Generic;
             using System.Linq;
-            using System.Text;
+            using Implab.Automaton;
-            using System.Threading.Tasks;
-            namespace Implab.Automaton {
+            namespace Implab.Formats {
                 public class CharAlphabet: IndexedAlphabetBase<char> {
                     public CharAlphabet()
                         : base(char.MaxValue + 1) {
                     }
                     public override int GetSymbolIndex(char symbol) {
                         return symbol;
                     }
                     public override IEnumerable<char> InputSymbols {
                         get { return Enumerable.Range(char.MinValue, char.MaxValue).Cast<char>(); }
                     }
                 }
             }

Implab/Formats/JSON/JSONElementContext.cs +2 -8

-            using System;
+            namespace Implab.Formats.JSON {
-            using System.Collections.Generic;
-            using System.Linq;
-            using System.Text;
-            using System.Threading.Tasks;
-            namespace Implab.JSON {
                 /// <summary>
                 /// internal
                 /// </summary>
-                public enum JSONElementContext {
+                enum JSONElementContext {
                     None,
                     Object,
                     Array,
                     Closed
                 }
             }

Implab/Formats/JSON/JSONElementType.cs +1 -7

-            using System;
+            namespace Implab.Formats.JSON {
-            using System.Collections.Generic;
-            using System.Linq;
-            using System.Text;
-            using System.Threading.Tasks;
-            namespace Implab.JSON {
                 /// <summary>
                 /// Тип элемента на котором находится парсер
                 /// </summary>
                 public enum JSONElementType {
                     None,
                     /// <summary>
                     /// Начало объекта
                     /// </summary>
                     BeginObject,
                     /// <summary>
                     /// Конец объекта
                     /// </summary>
                     EndObject,
                     /// <summary>
                     /// Начало массива
                     /// </summary>
                     BeginArray,
                     /// <summary>
                     /// Конец массива
                     /// </summary>
                     EndArray,
                     /// <summary>
                     /// Простое значение
                     /// </summary>
                     Value
                 }
             }

Implab/Formats/JSON/JSONGrammar.cs +23 -7

             using System.Linq;
             using Implab.Automaton.RegularExpressions;
+            using System;
             namespace Implab.Formats.JSON {
-                class JSONGrammar : Grammar<JSONGrammar> {
+                class JSONGrammar : Grammar<char,JSONGrammar.TokenType> {
                     public enum TokenType {
                         None,
                         BeginObject,
                         EndObject,
                         BeginArray,
                         EndArray,
                         String,
                         Number,
                         Literal,
                         NameSeparator,
                         ValueSeparator,
                         StringBound,
                         EscapedChar,
                         UnescapedChar,
                         EscapedUnicode,
                         Minus,
                         Plus,
                         Sign,
                         Integer,
                         Dot,
                         Exp
                     }
-                    readonly CDFADefinition m_jsonDFA;
+                    static Lazy<JSONGrammar> _instance = new Lazy<JSONGrammar>();
-                    readonly CDFADefinition m_stringDFA;
+                    public static JSONGrammar Instance {
+                        get { return _instance.Value; }
+                    }
+                    readonly RegularCharDFADefinition<TokenType> m_jsonDFA;
+                    readonly RegularCharDFADefinition<TokenType> m_stringDFA;
                     public JSONGrammar() {
                         DefineAlphabet(Enumerable.Range(0, 0x20).Select(x => (char)x));
                         var hexDigit = SymbolRangeToken('a','f').Or(SymbolRangeToken('A','F')).Or(SymbolRangeToken('0','9'));
                         var digit9 = SymbolRangeToken('1', '9');
                         var zero = SymbolToken('0');
                         var digit = zero.Or(digit9);
                         var dot = SymbolToken('.');
                         var minus = SymbolToken('-');
                         var sign = SymbolSetToken('-', '+');
                         var expSign = SymbolSetToken('e', 'E');
                         var letters = SymbolRangeToken('a', 'z');
                         var integer = zero.Or(digit9.Cat(digit.EClosure()));
                         var frac = dot.Cat(digit.Closure());
                         var exp = expSign.Cat(sign.Optional()).Cat(digit.Closure());
                         var quote = SymbolToken('"');
                         var backSlash = SymbolToken('\\');
                         var specialEscapeChars = SymbolSetToken('\\', '"', '/', 'b', 'f', 't', 'n', 'r');
                         var unicodeEspace = SymbolToken('u').Cat(hexDigit.Repeat(4));
                         var whitespace = SymbolSetToken('\n', '\r', '\t', ' ').EClosure();
                         var beginObject = whitespace.Cat(SymbolToken('{')).Cat(whitespace);
                         var endObject = whitespace.Cat(SymbolToken('}')).Cat(whitespace);
                         var beginArray = whitespace.Cat(SymbolToken('[')).Cat(whitespace);
                         var endArray = whitespace.Cat(SymbolToken(']')).Cat(whitespace);
                         var nameSep = whitespace.Cat(SymbolToken(':')).Cat(whitespace);
                         var valueSep = whitespace.Cat(SymbolToken(',')).Cat(whitespace);
                         var number = minus.Optional().Cat(integer).Cat(frac.Optional()).Cat(exp.Optional());
                         var literal = letters.Closure();
                         var unescaped = SymbolTokenExcept(Enumerable.Range(0, 0x20).Union(new int[] { '\\', '"' }).Select(x => (char)x));
                         var jsonExpression =
                             number.Tag(TokenType.Number)
                             .Or(literal.Tag(TokenType.Literal))
                             .Or(quote.Tag(TokenType.StringBound))
                             .Or(beginObject.Tag(TokenType.BeginObject))
                             .Or(endObject.Tag(TokenType.EndObject))
                             .Or(beginArray.Tag(TokenType.BeginArray))
                             .Or(endArray.Tag(TokenType.EndArray))
                             .Or(nameSep.Tag(TokenType.NameSeparator))
                             .Or(valueSep.Tag(TokenType.ValueSeparator));
                         var jsonStringExpression =
                             quote.Tag(TokenType.StringBound)
                             .Or(backSlash.Cat(specialEscapeChars).Tag(TokenType.EscapedChar))
                             .Or(backSlash.Cat(unicodeEspace).Tag(TokenType.EscapedUnicode))
                             .Or(unescaped.Closure().Tag(TokenType.UnescapedChar));
-                        m_jsonDFA = BuildDFA(jsonExpression);
+                        m_jsonDFA = new RegularCharDFADefinition<TokenType>(new CharAlphabet());
-                        m_stringDFA = BuildDFA(jsonStringExpression);
+                        BuildDFA(jsonExpression, m_jsonDFA, m_jsonDFA.InputAlphabet);
+                        m_stringDFA = new RegularCharDFADefinition<TokenType>(new CharAlphabet());
+                        BuildDFA(jsonStringExpression, m_jsonDFA, m_jsonDFA.InputAlphabet);
                     }
-                    public CDFADefinition JsonDFA {
+                    public RegularCharDFADefinition<TokenType> JsonDFA {
                         get {
                             return m_jsonDFA;
                         }
                     }
-                    public CDFADefinition JsonStringDFA {
+                    public RegularDFADefinition<char,TokenType> JsonStringDFA {
                         get {
                             return m_stringDFA;
                         }
                     }
+                    Token<TokenType> SymbolRangeToken(char start, char stop) {
+                        return SymbolToken(Enumerable.Range(start,stop - start).Cast<char>());
+                    }
                 }
             }

Implab/Formats/JSON/JSONParser.cs +38 -35

-            using Implab.Parsing;
+            using System;
-            using System;
             using System.Diagnostics;
             using System.IO;
+            using Implab.Automaton;
+            using Implab.Automaton.RegularExpressions;
+            using System.Linq;
+            using Implab.Components;
-            namespace Implab.JSON {
+            namespace Implab.Formats.JSON {
                 /// <summary>
                 /// internal
                 /// </summary>
                 public struct JSONParserContext {
                     public string memberName;
                     public JSONElementContext elementContext;
                 }
                 /// <summary>
                 /// Pull парсер JSON данных.
                 /// </summary>
                 /// <remarks>
                 /// Следует отметить отдельную интерпретацию свойства <see cref="Level"/>,
                 /// оно означает текущий уровень вложенности объектов, однако закрывающий
                 /// элемент объекта и массива имеет уровень меньше, чем сам объект.
                 /// <code>
                 /// { // Level = 1
                 ///     "name" : "Peter", // Level = 1
                 ///     "address" : { // Level = 2
                 ///         city : "Stern" // Level = 2
                 ///     } // Level = 1
                 /// } // Level = 0
                 /// </code>
                 /// </remarks>
-                public class JSONParser : DFAutomaton<JSONParserContext>, IDisposable {
+                public class JSONParser : Disposable {
                     enum MemberContext {
                         MemberName,
                         MemberValue
                     }
+                    struct ParserContext {
+                        DFAStateDescriptior<object>
+                    }
                     static readonly EnumAlphabet<JsonTokenType> _alphabet = EnumAlphabet<JsonTokenType>.FullAlphabet;
-                    static readonly DFAStateDescriptior[] _jsonDFA;
+                    static readonly DFAStateDescriptior<object>[] _jsonDFA;
-                    static readonly DFAStateDescriptior[] _objectDFA;
+                    static readonly int _jsonDFAInitialState;
-                    static readonly DFAStateDescriptior[] _arrayDFA;
+                    static readonly DFAStateDescriptior<object>[] _objectDFA;
+                    static readonly int _objectDFAInitialState;
+                    static readonly DFAStateDescriptior<object>[] _arrayDFA;
+                    static readonly int _arrayDFAInitialState;
                     static JSONParser() {
-                        var valueExpression = Token.New(JsonTokenType.BeginArray, JsonTokenType.BeginObject, JsonTokenType.Literal, JsonTokenType.Number, JsonTokenType.String);
+                        var valueExpression = Token(JsonTokenType.BeginArray, JsonTokenType.BeginObject, JsonTokenType.Literal, JsonTokenType.Number, JsonTokenType.String);
-                        var memberExpression = Token.New(JsonTokenType.String).Cat(Token.New(JsonTokenType.NameSeparator)).Cat(valueExpression);
+                        var memberExpression = Token(JsonTokenType.String).Cat(Token(JsonTokenType.NameSeparator)).Cat(valueExpression);
                         var objectExpression = memberExpression
                             .Cat(
-                                Token.New(JsonTokenType.ValueSeparator)
+                                Token(JsonTokenType.ValueSeparator)
                                 .Cat(memberExpression)
                                 .EClosure()
                             )
                             .Optional()
-                            .Cat(Token.New(JsonTokenType.EndObject))
+                            .Cat(Token(JsonTokenType.EndObject))
-                            .Tag(0);
+                            .Tag(null);
                         var arrayExpression = valueExpression
                             .Cat(
-                                Token.New(JsonTokenType.ValueSeparator)
+                                Token(JsonTokenType.ValueSeparator)
                                 .Cat(valueExpression)
                                 .EClosure()
                             )
                             .Optional()
-                            .Cat(Token.New(JsonTokenType.EndArray))
+                            .Cat(Token(JsonTokenType.EndArray))
-                            .Tag(0);
+                            .Tag(null);
-                        var jsonExpression = valueExpression.Tag(0);
+                        var jsonExpression = valueExpression.Tag(null);
-                        _jsonDFA = BuildDFA(jsonExpression).States;
+                        _jsonDFA = CreateDFA(jsonExpression).GetTransitionTable();
-                        _objectDFA = BuildDFA(objectExpression).States;
+                        _objectDFA = CreateDFA(objectExpression).GetTransitionTable();
-                        _arrayDFA = BuildDFA(arrayExpression).States;
+                        _arrayDFA = CreateDFA(arrayExpression).GetTransitionTable();
                     }
-                    static EDFADefinition<JsonTokenType> BuildDFA(Token expr) {
+                    static Token<object> Token(params JsonTokenType[] input) {
-                        var builder = new DFABuilder();
+                        return Token<object>.New(input.Select(t => _alphabet.Translate(t)).ToArray());
-                        var dfa = new EDFADefinition<JsonTokenType>(_alphabet);
+                    static RegularDFADefinition<JsonTokenType,object> CreateDFA(Token<object> expr) {
+                        var builder = new RegularDFABuilder<object>();
+                        var dfa = new RegularDFADefinition<JsonTokenType,object>(_alphabet);
                         expr.Accept(builder);
                         builder.BuildDFA(dfa);
                         return dfa;
                     }
                     JSONScanner m_scanner;
                     MemberContext m_memberContext;
                     JSONElementType m_elementType;
                     object m_elementValue;
                     /// <summary>
                     /// Создает новый парсер на основе строки, содержащей JSON
                     /// </summary>
                     /// <param name="text"></param>
                     public JSONParser(string text)
                         : base(_jsonDFA, INITIAL_STATE, new JSONParserContext { elementContext = JSONElementContext.None, memberName = String.Empty }) {
                         Safe.ArgumentNotEmpty(text, "text");
                         m_scanner = new JSONScanner();
                         m_scanner.Feed(text.ToCharArray());
                     }
                     /// <summary>
                     /// Создает новый экземпляр парсера, на основе текстового потока.
                     /// </summary>
                     /// <param name="reader">Текстовый поток.</param>
                     /// <param name="dispose">Признак того, что парсер должен конролировать время жизни входного потока.</param>
                     public JSONParser(TextReader reader, bool dispose)
                         : base(_jsonDFA, INITIAL_STATE, new JSONParserContext { elementContext = JSONElementContext.None, memberName = String.Empty }) {
                         Safe.ArgumentNotNull(reader, "reader");
                         m_scanner = new JSONScanner();
                         m_scanner.Feed(reader, dispose);
                     }
                     /// <summary>
                     /// Тип текущего элемента на котором стоит парсер.
                     /// </summary>
                     public JSONElementType ElementType {
                         get { return m_elementType; }
                     }
                     /// <summary>
                     /// Имя элемента - имя свойства родительского контейнера. Для элементов массивов и корневого всегда
                     /// пустая строка.
                     /// </summary>
                     public string ElementName {
                         get { return m_context.info.memberName; }
                     }
                     /// <summary>
                     /// Значение элемента. Только для элементов типа <see cref="JSONElementType.Value"/>, для остальных <c>null</c>
                     /// </summary>
                     public object ElementValue {
                         get { return m_elementValue; }
                     }
                     /// <summary>
                     /// Читает слеюудущий объект из потока
                     /// </summary>
                     /// <returns><c>true</c> - операция чтения прошла успешно, <c>false</c> - конец данных</returns>
                     public bool Read() {
                         if (m_context.current == UNREACHEBLE_STATE)
                             throw new InvalidOperationException("The parser is in invalid state");
                         object tokenValue;
                         JsonTokenType tokenType;
                         m_context.info.memberName = String.Empty;
                         while (m_scanner.ReadToken(out tokenValue, out tokenType)) {
                             Move((int)tokenType);
                             if (m_context.current == UNREACHEBLE_STATE)
                                 UnexpectedToken(tokenValue, tokenType);
                             switch (tokenType) {
                                 case JsonTokenType.BeginObject:
                                     Switch(
                                         _objectDFA,
                                         INITIAL_STATE,
                                         new JSONParserContext {
                                             memberName = m_context.info.memberName,
                                             elementContext = JSONElementContext.Object
                                         }
                                     );
                                     m_elementValue = null;
                                     m_memberContext = MemberContext.MemberName;
                                     m_elementType = JSONElementType.BeginObject;
                                     return true;
                                 case JsonTokenType.EndObject:
                                     Restore();
                                     m_elementValue = null;
                                     m_elementType = JSONElementType.EndObject;
                                     return true;
                                 case JsonTokenType.BeginArray:
                                     Switch(
                                         _arrayDFA,
                                         INITIAL_STATE,
                                         new JSONParserContext {
                                             memberName = m_context.info.memberName,
                                             elementContext = JSONElementContext.Array
                                         }
                                     );
                                     m_elementValue = null;
                                     m_memberContext = MemberContext.MemberValue;
                                     m_elementType = JSONElementType.BeginArray;
                                     return true;
                                 case JsonTokenType.EndArray:
                                     Restore();
                                     m_elementValue = null;
                                     m_elementType = JSONElementType.EndArray;
                                     return true;
                                 case JsonTokenType.String:
                                     if (m_memberContext == MemberContext.MemberName) {
                                         m_context.info.memberName = (string)tokenValue;
                                         break;
                                     }
                                     m_elementType = JSONElementType.Value;
                                     m_elementValue = tokenValue;
                                     return true;
                                 case JsonTokenType.Number:
                                     m_elementType = JSONElementType.Value;
                                     m_elementValue = tokenValue;
                                     return true;
                                 case JsonTokenType.Literal:
                                     m_elementType = JSONElementType.Value;
                                     m_elementValue = ParseLiteral((string)tokenValue);
                                     return true;
                                 case JsonTokenType.NameSeparator:
                                     m_memberContext = MemberContext.MemberValue;
                                     break;
                                 case JsonTokenType.ValueSeparator:
                                     m_memberContext = m_context.info.elementContext == JSONElementContext.Object ? MemberContext.MemberName : MemberContext.MemberValue;
                                     break;
                                 default:
                                     UnexpectedToken(tokenValue, tokenType);
                                     break;
                             }
                         }
                         if (m_context.info.elementContext != JSONElementContext.None)
                             throw new ParserException("Unexpedted end of data");
                         return false;
                     }
                     object ParseLiteral(string literal) {
                         switch (literal) {
                             case "null":
                                 return null;
                             case "false":
                                 return false;
                             case "true":
                                 return true;
                             default:
                                 UnexpectedToken(literal, JsonTokenType.Literal);
                                 return null; // avoid compliler error
                         }
                     }
                     void UnexpectedToken(object value, JsonTokenType tokenType) {
                         throw new ParserException(String.Format("Unexpected token {0}: '{1}'", tokenType, value));
                     }
                     /// <summary>
                     /// Признак конца потока
                     /// </summary>
                     public bool EOF {
                         get {
                             return m_scanner.EOF;
                         }
                     }
-                    protected virtual void Dispose(bool disposing) {
+                    protected override void Dispose(bool disposing) {
                         if (disposing) {
                             m_scanner.Dispose();
                         }
                     }
                     /// <summary>
-                    /// Освобождает парсер и связанный с ним сканнер.
-                    /// </summary>
-                    public void Dispose() {
-                        Dispose(true);
-                        GC.SuppressFinalize(this);
-                    ~JSONParser() {
-                        Dispose(false);
-                    /// <summary>
                     /// Переходит в конец текущего объекта.
                     /// </summary>
                     public void SeekElementEnd() {
                         var level = Level - 1;
                         Debug.Assert(level >= 0);
                         while (Level != level)
                             Read();
                     }
                 }
             }

Implab/Formats/JSON/JSONScanner.cs +6 -10

-            using Implab.Parsing;
+            using System;
-            using System;
-            using System.Collections.Generic;
             using System.Globalization;
-            using System.Linq;
+            using Implab.Automaton;
-            using System.Text;
-            using System.Threading.Tasks;
-            namespace Implab.JSON {
+            namespace Implab.Formats.JSON {
                 /// <summary>
                 /// Сканнер (лексер), разбивающий поток символов на токены JSON.
                 /// </summary>
-                public class JSONScanner : Scanner {
+                public class JSONScanner : Scanner<object> {
                     char[] m_stringBuffer;
-                    DFAStateDescriptior[] m_stringDFA;
+                    DFAStateDescriptior<>[] m_stringDFA;
                     int[] m_stringAlphabet;
                     /// <summary>
                     /// Создает новый экземпляр сканнера
                     /// </summary>
                     public JSONScanner()
-                        : base(JSONGrammar.Instance.JsonDFA.States, JSONGrammar.Instance.JsonDFA.Alphabet.GetTranslationMap()) {
+                        : base(JSONGrammar.Instance.JsonDFA.GetTransitionTable(), JSONGrammar.Instance.JsonDFA.Alphabet.GetTranslationMap()) {
                         m_stringBuffer = new char[1024];
                         var dfa = JSONGrammar.Instance.JsonStringDFA;
                         m_stringAlphabet = dfa.Alphabet.GetTranslationMap();
                         m_stringDFA = dfa.States;
                     }
                     /// <summary>
                     /// Читает следующий лексический элемент из входных данных.
                     /// </summary>
                     /// <param name="tokenValue">Возвращает значение прочитанного токена.</param>
                     /// <param name="tokenType">Возвращает тип прочитанного токена.</param>
                     /// <returns><c>true</c> - чтение произведено успешно. <c>false</c> - достигнут конец входных данных</returns>
                     /// <remarks>В случе если токен не распознается, возникает исключение. Значения токенов обрабатываются, т.е.
                     /// в строках обрабатываются экранированные символы, числа становтся типа double.</remarks>
                     public bool ReadToken(out object tokenValue, out JsonTokenType tokenType) {
                         if (ReadTokenInternal()) {
                             switch ((JSONGrammar.TokenType)m_currentState.tag[0]) {
                                 case JSONGrammar.TokenType.StringBound:
                                     tokenValue = ReadString();
                                     tokenType = JsonTokenType.String;
                                     break;
                                 case JSONGrammar.TokenType.Number:
                                     tokenValue = Double.Parse(new String(m_buffer, m_tokenOffset, m_tokenLen), CultureInfo.InvariantCulture);
                                     tokenType = JsonTokenType.Number;
                                     break;
                                 default:
                                     tokenType = (JsonTokenType)m_currentState.tag[0];
                                     tokenValue = new String(m_buffer, m_tokenOffset, m_tokenLen);
                                     break;
                             }
                             return true;
                         }
                         tokenValue = null;
                         tokenType = JsonTokenType.None;
                         return false;
                     }
                     string ReadString() {
                         int pos = 0;
                         Switch(m_stringDFA, m_stringAlphabet);
                         while (ReadTokenInternal()) {
                             switch ((JSONGrammar.TokenType)m_currentState.tag[0]) {
                                 case JSONGrammar.TokenType.StringBound:
                                     Restore();
                                     return new String(m_stringBuffer, 0, pos);
                                 case JSONGrammar.TokenType.UnescapedChar:
                                     EnsureStringBufferSize(pos + m_tokenLen);
                                     Array.Copy(m_buffer, m_tokenOffset, m_stringBuffer, pos, m_tokenLen);
                                     pos += m_tokenLen;
                                     break;
                                 case JSONGrammar.TokenType.EscapedUnicode:
                                     EnsureStringBufferSize(pos + 1);
                                     m_stringBuffer[pos] = StringTranslator.TranslateHexUnicode(m_buffer, m_tokenOffset + 2);
                                     pos++;
                                     break;
                                 case JSONGrammar.TokenType.EscapedChar:
                                     EnsureStringBufferSize(pos + 1);
                                     m_stringBuffer[pos] = StringTranslator.TranslateEscapedChar(m_buffer[m_tokenOffset + 1]);
                                     pos++;
                                     break;
                                 default:
                                     break;
                             }
                         }
                         throw new ParserException("Unexpected end of data");
                     }
                     void EnsureStringBufferSize(int size) {
                         if (size > m_stringBuffer.Length) {
                             var newBuffer = new char[size];
                             m_stringBuffer.CopyTo(newBuffer, 0);
                             m_stringBuffer = newBuffer;
                         }
                     }
                 }
             }

Implab/Formats/JSON/JsonTokenType.cs +1 -7

-            using System;
+            namespace Implab.Formats.JSON {
-            using System.Collections.Generic;
-            using System.Linq;
-            using System.Text;
-            using System.Threading.Tasks;
-            namespace Implab.JSON {
                 /// <summary>
                 /// Тип токенов, возвращаемых <see cref="JSONScanner"/>.
                 /// </summary>
                 public enum JsonTokenType : int {
                     None = 0,
                     /// <summary>
                     /// Начало объекта
                     /// </summary>
                     BeginObject,
                     /// <summary>
                     /// Конец объекта
                     /// </summary>
                     EndObject,
                     /// <summary>
                     /// Начало массива
                     /// </summary>
                     BeginArray,
                     /// <summary>
                     /// Конец массива
                     /// </summary>
                     EndArray,
                     /// <summary>
                     /// Строка
                     /// </summary>
                     String,
                     /// <summary>
                     /// Число
                     /// </summary>
                     Number,
                     /// <summary>
                     /// Литерал
                     /// </summary>
                     Literal,
                     /// <summary>
                     /// Разделитель имени <c>:</c>
                     /// </summary>
                     NameSeparator,
                     /// <summary>
                     /// Разделитель имени <c>,</c>
                     /// </summary>
                     ValueSeparator
                 }
             }

Implab/Implab.csproj +3 -3

             <?xml version="1.0" encoding="utf-8"?>
             <Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
               <PropertyGroup>
                 <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
                 <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
                 <ProjectGuid>{F550F1F8-8746-4AD0-9614-855F4C4B7F05}</ProjectGuid>
                 <OutputType>Library</OutputType>
                 <RootNamespace>Implab</RootNamespace>
                 <AssemblyName>Implab</AssemblyName>
                 <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
                 <ReleaseVersion>0.2</ReleaseVersion>
                 <ProductVersion>8.0.30703</ProductVersion>
                 <SchemaVersion>2.0</SchemaVersion>
               </PropertyGroup>
               <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
                 <DebugSymbols>true</DebugSymbols>
                 <DebugType>full</DebugType>
                 <Optimize>false</Optimize>
                 <OutputPath>bin\Debug</OutputPath>
                 <DefineConstants>TRACE;DEBUG;</DefineConstants>
                 <ErrorReport>prompt</ErrorReport>
                 <WarningLevel>4</WarningLevel>
                 <ConsolePause>false</ConsolePause>
                 <RunCodeAnalysis>true</RunCodeAnalysis>
               </PropertyGroup>
               <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
                 <DebugType>full</DebugType>
                 <Optimize>true</Optimize>
                 <OutputPath>bin\Release</OutputPath>
                 <ErrorReport>prompt</ErrorReport>
                 <WarningLevel>4</WarningLevel>
                 <ConsolePause>false</ConsolePause>
               </PropertyGroup>
               <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug 4.5|AnyCPU' ">
                 <DebugSymbols>true</DebugSymbols>
                 <DebugType>full</DebugType>
                 <Optimize>false</Optimize>
                 <OutputPath>bin\Debug</OutputPath>
                 <DefineConstants>TRACE;DEBUG;NET_4_5</DefineConstants>
                 <ErrorReport>prompt</ErrorReport>
                 <WarningLevel>4</WarningLevel>
                 <RunCodeAnalysis>true</RunCodeAnalysis>
                 <ConsolePause>false</ConsolePause>
               </PropertyGroup>
               <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release 4.5|AnyCPU' ">
                 <Optimize>true</Optimize>
                 <OutputPath>bin\Release</OutputPath>
                 <ErrorReport>prompt</ErrorReport>
                 <WarningLevel>4</WarningLevel>
                 <ConsolePause>false</ConsolePause>
                 <DefineConstants>NET_4_5</DefineConstants>
               </PropertyGroup>
               <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'DebugMono|AnyCPU' ">
                 <DebugSymbols>true</DebugSymbols>
                 <DebugType>full</DebugType>
                 <Optimize>false</Optimize>
                 <OutputPath>bin\Debug</OutputPath>
                 <DefineConstants>TRACE;DEBUG;NET_4_5;MONO</DefineConstants>
                 <ErrorReport>prompt</ErrorReport>
                 <WarningLevel>4</WarningLevel>
                 <RunCodeAnalysis>true</RunCodeAnalysis>
                 <ConsolePause>false</ConsolePause>
               </PropertyGroup>
               <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'ReleaseMono|AnyCPU' ">
                 <Optimize>true</Optimize>
                 <OutputPath>bin\Release</OutputPath>
                 <DefineConstants>NET_4_5;MONO;</DefineConstants>
                 <ErrorReport>prompt</ErrorReport>
                 <WarningLevel>4</WarningLevel>
                 <ConsolePause>false</ConsolePause>
               </PropertyGroup>
               <ItemGroup>
                 <Reference Include="System" />
                 <Reference Include="System.Xml" />
                 <Reference Include="mscorlib" />
               </ItemGroup>
               <ItemGroup>
                 <Compile Include="CustomEqualityComparer.cs" />
                 <Compile Include="Diagnostics\ConsoleTraceListener.cs" />
                 <Compile Include="Diagnostics\EventText.cs" />
                 <Compile Include="Diagnostics\LogChannel.cs" />
                 <Compile Include="Diagnostics\LogicalOperation.cs" />
                 <Compile Include="Diagnostics\TextFileListener.cs" />
                 <Compile Include="Diagnostics\TraceLog.cs" />
                 <Compile Include="Diagnostics\TraceEvent.cs" />
                 <Compile Include="Diagnostics\TraceEventType.cs" />
                 <Compile Include="ICancellable.cs" />
                 <Compile Include="IProgressHandler.cs" />
                 <Compile Include="IProgressNotifier.cs" />
                 <Compile Include="IPromiseT.cs" />
                 <Compile Include="IPromise.cs" />
                 <Compile Include="IServiceLocator.cs" />
                 <Compile Include="ITaskController.cs" />
                 <Compile Include="Parallels\DispatchPool.cs" />
                 <Compile Include="Parallels\ArrayTraits.cs" />
                 <Compile Include="Parallels\MTQueue.cs" />
                 <Compile Include="Parallels\WorkerPool.cs" />
                 <Compile Include="ProgressInitEventArgs.cs" />
                 <Compile Include="Properties\AssemblyInfo.cs" />
                 <Compile Include="Parallels\AsyncPool.cs" />
                 <Compile Include="Safe.cs" />
                 <Compile Include="ValueEventArgs.cs" />
                 <Compile Include="PromiseExtensions.cs" />
                 <Compile Include="SyncContextPromise.cs" />
                 <Compile Include="Diagnostics\OperationContext.cs" />
                 <Compile Include="Diagnostics\TraceContext.cs" />
                 <Compile Include="Diagnostics\LogEventArgs.cs" />
                 <Compile Include="Diagnostics\LogEventArgsT.cs" />
                 <Compile Include="Diagnostics\Extensions.cs" />
                 <Compile Include="PromiseEventType.cs" />
                 <Compile Include="Parallels\AsyncQueue.cs" />
                 <Compile Include="PromiseT.cs" />
                 <Compile Include="IDeferred.cs" />
                 <Compile Include="IDeferredT.cs" />
                 <Compile Include="Promise.cs" />
                 <Compile Include="PromiseTransientException.cs" />
                 <Compile Include="Parallels\Signal.cs" />
                 <Compile Include="Parallels\SharedLock.cs" />
                 <Compile Include="Diagnostics\ILogWriter.cs" />
                 <Compile Include="Diagnostics\ListenerBase.cs" />
                 <Compile Include="Parallels\BlockingQueue.cs" />
                 <Compile Include="AbstractEvent.cs" />
                 <Compile Include="AbstractPromise.cs" />
                 <Compile Include="AbstractPromiseT.cs" />
                 <Compile Include="FuncTask.cs" />
                 <Compile Include="FuncTaskBase.cs" />
                 <Compile Include="FuncTaskT.cs" />
                 <Compile Include="ActionChainTaskBase.cs" />
                 <Compile Include="ActionChainTask.cs" />
                 <Compile Include="ActionChainTaskT.cs" />
                 <Compile Include="FuncChainTaskBase.cs" />
                 <Compile Include="FuncChainTask.cs" />
                 <Compile Include="FuncChainTaskT.cs" />
                 <Compile Include="ActionTaskBase.cs" />
                 <Compile Include="ActionTask.cs" />
                 <Compile Include="ActionTaskT.cs" />
                 <Compile Include="ICancellationToken.cs" />
                 <Compile Include="SuccessPromise.cs" />
                 <Compile Include="SuccessPromiseT.cs" />
                 <Compile Include="PromiseAwaiterT.cs" />
                 <Compile Include="PromiseAwaiter.cs" />
                 <Compile Include="Components\ComponentContainer.cs" />
                 <Compile Include="Components\Disposable.cs" />
                 <Compile Include="Components\DisposablePool.cs" />
                 <Compile Include="Components\ObjectPool.cs" />
                 <Compile Include="Components\ServiceLocator.cs" />
                 <Compile Include="Components\IInitializable.cs" />
                 <Compile Include="TaskController.cs" />
                 <Compile Include="Components\App.cs" />
                 <Compile Include="Components\IRunnable.cs" />
                 <Compile Include="Components\ExecutionState.cs" />
                 <Compile Include="Components\RunnableComponent.cs" />
                 <Compile Include="Components\IFactory.cs" />
                 <Compile Include="Automaton\DFAStateDescriptor.cs" />
-                <Compile Include="Automaton\DFAutomaton.cs" />
                 <Compile Include="Automaton\EnumAlphabet.cs" />
                 <Compile Include="Automaton\IAlphabet.cs" />
                 <Compile Include="Automaton\ParserException.cs" />
                 <Compile Include="Automaton\Scanner.cs" />
                 <Compile Include="Automaton\IndexedAlphabetBase.cs" />
                 <Compile Include="Automaton\IAlphabetBuilder.cs" />
                 <Compile Include="Automaton\RegularExpressions\AltToken.cs" />
                 <Compile Include="Automaton\RegularExpressions\BinaryToken.cs" />
                 <Compile Include="Automaton\RegularExpressions\CatToken.cs" />
                 <Compile Include="Automaton\DFAConst.cs" />
                 <Compile Include="Automaton\RegularExpressions\Grammar.cs" />
                 <Compile Include="Automaton\RegularExpressions\StarToken.cs" />
                 <Compile Include="Automaton\RegularExpressions\SymbolToken.cs" />
                 <Compile Include="Automaton\RegularExpressions\EmptyToken.cs" />
                 <Compile Include="Automaton\RegularExpressions\EndToken.cs" />
                 <Compile Include="Automaton\RegularExpressions\Token.cs" />
                 <Compile Include="Automaton\RegularExpressions\IVisitor.cs" />
                 <Compile Include="Automaton\AutomatonTransition.cs" />
                 <Compile Include="Automaton\RegularExpressions\RegularDFABuilder.cs" />
                 <Compile Include="Formats\JSON\JSONElementContext.cs" />
                 <Compile Include="Formats\JSON\JSONElementType.cs" />
                 <Compile Include="Formats\JSON\JSONGrammar.cs" />
                 <Compile Include="Formats\JSON\JSONParser.cs" />
                 <Compile Include="Formats\JSON\JSONScanner.cs" />
                 <Compile Include="Formats\JSON\JsonTokenType.cs" />
                 <Compile Include="Formats\JSON\JSONWriter.cs" />
                 <Compile Include="Formats\JSON\JSONXmlReader.cs" />
                 <Compile Include="Formats\JSON\JSONXmlReaderOptions.cs" />
                 <Compile Include="Formats\JSON\StringTranslator.cs" />
                 <Compile Include="Automaton\MapAlphabet.cs" />
                 <Compile Include="Automaton\DummyAlphabet.cs" />
                 <Compile Include="Automaton\DFATransitionTable.cs" />
-                <Compile Include="Automaton\IDFATransitionTableBuilder.cs" />
-                <Compile Include="Automaton\IDFATransitionTable.cs" />
                 <Compile Include="Automaton\RegularExpressions\RegularDFADefinition.cs" />
                 <Compile Include="Formats\CharAlphabet.cs" />
                 <Compile Include="Formats\ByteAlphabet.cs" />
+                <Compile Include="Formats\RegularCharDFADefinition.cs" />
+                <Compile Include="Automaton\IDFATable.cs" />
+                <Compile Include="Automaton\IDFATableBuilder.cs" />
               </ItemGroup>
               <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
               <ItemGroup />
               <ProjectExtensions>
                 <MonoDevelop>
                   <Properties>
                     <Policies>
                       <CSharpFormattingPolicy IndentSwitchBody="True" NamespaceBraceStyle="EndOfLine" ClassBraceStyle="EndOfLine" InterfaceBraceStyle="EndOfLine" StructBraceStyle="EndOfLine" EnumBraceStyle="EndOfLine" MethodBraceStyle="EndOfLine" ConstructorBraceStyle="EndOfLine" DestructorBraceStyle="EndOfLine" BeforeMethodDeclarationParentheses="False" BeforeMethodCallParentheses="False" BeforeConstructorDeclarationParentheses="False" NewLineBeforeConstructorInitializerColon="NewLine" NewLineAfterConstructorInitializerColon="SameLine" BeforeIndexerDeclarationBracket="False" BeforeDelegateDeclarationParentheses="False" NewParentheses="False" SpacesBeforeBrackets="False" inheritsSet="Mono" inheritsScope="text/x-csharp" scope="text/x-csharp" />
                       <TextStylePolicy FileWidth="120" EolMarker="Unix" inheritsSet="VisualStudio" inheritsScope="text/plain" scope="text/x-csharp" />
                       <DotNetNamingPolicy DirectoryNamespaceAssociation="PrefixedHierarchical" ResourceNamePolicy="MSBuild" />
                       <TextStylePolicy FileWidth="120" TabsToSpaces="False" inheritsSet="VisualStudio" inheritsScope="text/plain" scope="application/xml" />
                       <XmlFormattingPolicy inheritsSet="Mono" inheritsScope="application/xml" scope="application/xml" />
                       <TextStylePolicy FileWidth="120" TabsToSpaces="False" inheritsSet="VisualStudio" inheritsScope="text/plain" scope="text/plain" />
                       <NameConventionPolicy>
                         <Rules>
                           <NamingRule Name="Namespaces" AffectedEntity="Namespace" VisibilityMask="VisibilityMask" NamingStyle="PascalCase" IncludeInstanceMembers="True" IncludeStaticEntities="True" />
                           <NamingRule Name="Types" AffectedEntity="Class, Struct, Enum, Delegate" VisibilityMask="VisibilityMask" NamingStyle="PascalCase" IncludeInstanceMembers="True" IncludeStaticEntities="True" />
                           <NamingRule Name="Interfaces" AffectedEntity="Interface" VisibilityMask="VisibilityMask" NamingStyle="PascalCase" IncludeInstanceMembers="True" IncludeStaticEntities="True">
                             <RequiredPrefixes>
                               <String>I</String>
                             </RequiredPrefixes>
                           </NamingRule>
                           <NamingRule Name="Attributes" AffectedEntity="CustomAttributes" VisibilityMask="VisibilityMask" NamingStyle="PascalCase" IncludeInstanceMembers="True" IncludeStaticEntities="True">
                             <RequiredSuffixes>
                               <String>Attribute</String>
                             </RequiredSuffixes>
                           </NamingRule>
                           <NamingRule Name="Event Arguments" AffectedEntity="CustomEventArgs" VisibilityMask="VisibilityMask" NamingStyle="PascalCase" IncludeInstanceMembers="True" IncludeStaticEntities="True">
                             <RequiredSuffixes>
                               <String>EventArgs</String>
                             </RequiredSuffixes>
                           </NamingRule>
                           <NamingRule Name="Exceptions" AffectedEntity="CustomExceptions" VisibilityMask="VisibilityMask" NamingStyle="PascalCase" IncludeInstanceMembers="True" IncludeStaticEntities="True">
                             <RequiredSuffixes>
                               <String>Exception</String>
                             </RequiredSuffixes>
                           </NamingRule>
                           <NamingRule Name="Methods" AffectedEntity="Methods" VisibilityMask="VisibilityMask" NamingStyle="PascalCase" IncludeInstanceMembers="True" IncludeStaticEntities="True" />
                           <NamingRule Name="Static Readonly Fields" AffectedEntity="ReadonlyField" VisibilityMask="Internal, Protected, Public" NamingStyle="CamelCase" IncludeInstanceMembers="False" IncludeStaticEntities="True" />
                           <NamingRule Name="Fields (Non Private)" AffectedEntity="Field" VisibilityMask="Internal, Public" NamingStyle="CamelCase" IncludeInstanceMembers="True" IncludeStaticEntities="True" />
                           <NamingRule Name="ReadOnly Fields (Non Private)" AffectedEntity="ReadonlyField" VisibilityMask="Internal, Public" NamingStyle="CamelCase" IncludeInstanceMembers="True" IncludeStaticEntities="False" />
                           <NamingRule Name="Fields (Private)" AffectedEntity="Field, ReadonlyField" VisibilityMask="Private, Protected" NamingStyle="CamelCase" IncludeInstanceMembers="True" IncludeStaticEntities="False">
                             <RequiredPrefixes>
                               <String>m_</String>
                             </RequiredPrefixes>
                           </NamingRule>
                           <NamingRule Name="Static Fields (Private)" AffectedEntity="Field" VisibilityMask="Private" NamingStyle="CamelCase" IncludeInstanceMembers="False" IncludeStaticEntities="True">
                             <RequiredPrefixes>
                               <String>_</String>
                             </RequiredPrefixes>
                           </NamingRule>
                           <NamingRule Name="ReadOnly Fields (Private)" AffectedEntity="ReadonlyField" VisibilityMask="Private, Protected" NamingStyle="CamelCase" IncludeInstanceMembers="True" IncludeStaticEntities="False">
                             <RequiredPrefixes>
                               <String>m_</String>
                             </RequiredPrefixes>
                           </NamingRule>
                           <NamingRule Name="Constant Fields" AffectedEntity="ConstantField" VisibilityMask="VisibilityMask" NamingStyle="AllUpper" IncludeInstanceMembers="True" IncludeStaticEntities="True" />
                           <NamingRule Name="Properties" AffectedEntity="Property" VisibilityMask="VisibilityMask" NamingStyle="PascalCase" IncludeInstanceMembers="True" IncludeStaticEntities="True" />
                           <NamingRule Name="Events" AffectedEntity="Event" VisibilityMask="VisibilityMask" NamingStyle="PascalCase" IncludeInstanceMembers="True" IncludeStaticEntities="True" />
                           <NamingRule Name="Enum Members" AffectedEntity="EnumMember" VisibilityMask="VisibilityMask" NamingStyle="PascalCase" IncludeInstanceMembers="True" IncludeStaticEntities="True" />
                           <NamingRule Name="Parameters" AffectedEntity="Parameter, LocalVariable" VisibilityMask="VisibilityMask" NamingStyle="CamelCase" IncludeInstanceMembers="True" IncludeStaticEntities="True" />
                           <NamingRule Name="Type Parameters" AffectedEntity="TypeParameter" VisibilityMask="VisibilityMask" NamingStyle="PascalCase" IncludeInstanceMembers="True" IncludeStaticEntities="True">
                             <RequiredPrefixes>
                               <String>T</String>
                             </RequiredPrefixes>
                           </NamingRule>
                         </Rules>
                       </NameConventionPolicy>
                     </Policies>
                   </Properties>
                 </MonoDevelop>
               </ProjectExtensions>
               <ItemGroup>
                 <Folder Include="Components\" />
                 <Folder Include="Automaton\RegularExpressions\" />
                 <Folder Include="Formats\" />
                 <Folder Include="Formats\JSON\" />
               </ItemGroup>
             </Project>

Implab/Automaton/DFAutomaton.cs removed 0 -61

NO CONTENT: file was removed

Implab/Automaton/IDFATransitionTable.cs removed 0 -59

NO CONTENT: file was removed

Implab/Automaton/IDFATransitionTableBuilder.cs removed 0 -25

NO CONTENT: file was removed

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages