implab/ImplabNet Commit - r180:c32688129f14

refactoring complete, JSONParser rewritten

cin -

r180:c32688129f14 ref20160224

parent child

Context file:

r180:c32688129f14

Collapse all files

.hgignore +2 0

             syntax: glob
             Implab.Test/bin/
             *.user
             Implab.Test/obj/
             *.userprefs
             Implab/bin/
             Implab/obj/
             TestResults/
             Implab.Fx/obj/
             Implab.Fx/bin/
             Implab.Fx.Test/bin/
             Implab.Fx.Test/obj/
             _ReSharper.Implab/
             Implab.Diagnostics.Interactive/bin/
             Implab.Diagnostics.Interactive/obj/
             MonoPlay/bin/
             MonoPlay/obj/
+            Implab.Test/Implab.Format.Test/bin/
+            Implab.Test/Implab.Format.Test/obj/

Implab/Automaton/DFATable.cs +4 -4

             using Implab;
             using System;
             using System.Collections.Generic;
             using System.Linq;
             namespace Implab.Automaton {
                 public class DFATable : IDFATableBuilder {
                     int m_stateCount;
                     int m_symbolCount;
                     int m_initialState;
                     readonly HashSet<int> m_finalStates = new HashSet<int>();
                     readonly HashSet<AutomatonTransition> m_transitions = new HashSet<AutomatonTransition>();
                     #region IDFADefinition implementation
                     public bool IsFinalState(int s) {
                         Safe.ArgumentInRange(s, 0, m_stateCount, "s");
                         return m_finalStates.Contains(s);
                     }
                     public IEnumerable<int> 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
                     public void SetInitialState(int s) {
                         Safe.ArgumentAssert(s >= 0, "s");
                         m_initialState = s;
                     }
                     public void MarkFinalState(int state) {
                         m_finalStates.Add(state);
                     }
                     public void Add(AutomatonTransition item) {
                         Safe.ArgumentAssert(item.s1 >= 0, "item");
                         Safe.ArgumentAssert(item.s2 >= 0, "item");
                         Safe.ArgumentAssert(item.edge >= 0, "item");
                         m_stateCount = Math.Max(m_stateCount, Math.Max(item.s1, item.s2) + 1);
                         m_symbolCount = Math.Max(m_symbolCount, item.edge);
                         m_transitions.Add(item);
                     }
                     public void Clear() {
                         m_stateCount = 0;
                         m_symbolCount = 0;
                         m_finalStates.Clear();
                         m_transitions.Clear();
                     }
                     public bool Contains(AutomatonTransition item) {
                         return m_transitions.Contains(item);
                     }
                     public void CopyTo(AutomatonTransition[] array, int arrayIndex) {
                         m_transitions.CopyTo(array, arrayIndex);
                     }
                     public bool Remove(AutomatonTransition item) {
-                        m_transitions.Remove(item);
+                        return m_transitions.Remove(item);
                     }
                     public int Count {
                         get {
                             return m_transitions.Count;
                         }
                     }
                     public bool IsReadOnly {
                         get {
                             return false;
                         }
                     }
                     public IEnumerator<AutomatonTransition> GetEnumerator() {
                         return m_transitions.GetEnumerator();
                     }
                     System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() {
                         return GetEnumerator();
                     }
                     public int[,] CreateTransitionTable() {
                         var table = new int[StateCount,AlphabetSize];
                         for (int i = 0; i < StateCount; i++)
                             for (int j = 0; i < AlphabetSize; j++)
                                 table[i, j] = AutomatonConst.UNREACHABLE_STATE;
                         foreach (var t in this)
                             table[t.s1,t.edge] = t.s2;
                         return table;
                     }
                     public bool[] CreateFinalStateTable() {
                         var table = new bool[StateCount];
                         foreach (var s in FinalStates)
                             table[s] = true;
                         return table;
                     }
                     /// <summary>Формирует множества конечных состояний перед началом работы алгоритма минимизации.</summary>
                     /// <remarks>
                     /// В процессе построения минимального автомата требуется разделить множество состояний,
                     /// на два подмножества - конечные состояния и все остальные, после чего эти подмножества
                     /// будут резделены на более мелкие. Иногда требуется гарантировать различия конечных сосотяний,
                     /// для этого необходимо переопределить даннцю фукнцию, для получения множеств конечных состояний.
                     /// </remarks>
                     /// <returns>The final states.</returns>
                     protected virtual IEnumerable<HashSet<int>> GroupFinalStates() {
                         return new HashSet<int>[] { m_finalStates };
                     }
                     protected void Optimize(
                         IDFATableBuilder optimalDFA,
                         IDictionary<int,int> alphabetMap,
                         IDictionary<int,int> stateMap
                     ) {
                         Safe.ArgumentNotNull(optimalDFA, "dfa");
                         Safe.ArgumentNotNull(alphabetMap, "alphabetMap");
                         Safe.ArgumentNotNull(stateMap, "stateMap");
                         var setComparer = new CustomEqualityComparer<HashSet<int>>(
                             (x, y) => x.SetEquals(y),
                             s => s.Sum(x => x.GetHashCode())
                         );
                         var optimalStates = new HashSet<HashSet<int>>(setComparer);
                         var queue = new HashSet<HashSet<int>>(setComparer);
                         // получаем конечные состояния, сгруппированные по маркерам
                         optimalStates.UnionWith(
                             GroupFinalStates()
                         );
                         var state = new HashSet<int>(
                             Enumerable
                             .Range(0, m_stateCount - 1)
                             .Where(i => !m_finalStates.Contains(i))
                         );
                         optimalStates.Add(state);
                         queue.Add(state);
                         var rmap = m_transitions
                             .GroupBy(t => t.s2)
-                            .ToLookup(
+                            .ToDictionary(
                                 g => g.Key, // s2
-                                g => g.ToLookup(t => t.edge, t => t.s1)
+                                g => g.GroupBy(t => t.edge, t => t.s1).ToDictionary(p => p.Key)
                             );
                         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'
+                                    stateX.UnionWith(rmap[a][c]); // all states from wich the symbol 'c' leads to the state '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 nextState = 0;
                         foreach (var item in optimalStates) {
                             var id = nextState++;
                             foreach (var s in item)
                                 stateMap[s] = id;
                         }
                         // получаем минимальный алфавит
                         // входные символы не различимы, если Move(s,a1) == Move(s,a2), для любого s
                         // для этого используем алгоритм кластеризации, сначала
                         // считаем, что все символы не различимы
                         var minClasses = new HashSet<HashSet<int>>(setComparer);
                         var alphaQueue = new Queue<HashSet<int>>();
                         alphaQueue.Enqueue(new HashSet<int>(Enumerable.Range(0,AlphabetSize)));
                         // для всех состояний, будем проверять каждый класс на различимость,
                         // т.е. символы различимы, если они приводят к разным состояниям
                         for (int s = 0 ; s < optimalStates.Count; s++) {
                             var newQueue = new Queue<HashSet<int>>();
                             foreach (var A in alphaQueue) {
                                 // классы из одного символа делить бесполезно, переводим их сразу в
                                 // результирующий алфавит
                                 if (A.Count == 1) {
                                     minClasses.Add(A);
                                     continue;
                                 }
                                 // различаем классы символов, которые переводят в различные оптимальные состояния
                                 // optimalState -> alphaClass
                                 var classes = new Dictionary<int, HashSet<int>>();
                                 foreach (var term in A) {
                                     // ищем все переходы класса по символу term
                                     var res = m_transitions.Where(t => stateMap[t.s1] == s && t.edge == term).Select(t => stateMap[t.s2]).ToArray();
                                     var s2 = res.Length > 0 ? res[0] : -1;
                                     HashSet<int> a2;
                                     if (!classes.TryGetValue(s2, out a2)) {
                                         a2 = new HashSet<int>();
                                         newQueue.Enqueue(a2);
                                         classes[s2] = a2;
                                     }
                                     a2.Add(term);
                                 }
                             }
                             if (newQueue.Count == 0)
                                 break;
                             alphaQueue = newQueue;
                         }
                         // после окончания работы алгоритма в очереди останутся минимальные различимые классы
                         // входных символов
                         foreach (var A in alphaQueue)
                             minClasses.Add(A);
                         // построение отображения алфавитов входных символов.
                         // поскольку символ DFAConst.UNCLASSIFIED_INPUT может иметь
                         // специальное значение, тогда сохраним минимальный класс,
                         // содержащий этот символ на томже месте.
                         var nextCls = 0;
                         foreach (var item in minClasses) {
                             if (nextCls == AutomatonConst.UNCLASSIFIED_INPUT)
                                 nextCls++;
                             // сохраняем DFAConst.UNCLASSIFIED_INPUT
                             var cls = item.Contains(AutomatonConst.UNCLASSIFIED_INPUT) ? AutomatonConst.UNCLASSIFIED_INPUT : nextCls;
                             foreach (var a in item)
                                 alphabetMap[a] = cls;
                             nextCls++;
                         }
                         // построение автомата
                         optimalDFA.SetInitialState(stateMap[m_initialState]);
                         foreach (var sf in m_finalStates.Select(s => stateMap[s]).Distinct())
                             optimalDFA.MarkFinalState(sf);
                         foreach (var t in m_transitions.Select(t => new AutomatonTransition(stateMap[t.s1],stateMap[t.s2],alphabetMap[t.edge])).Distinct())
                             optimalDFA.Add(t);
                     }
                     protected void PrintDFA<TInput, TState>(IAlphabet<TInput> inputAlphabet, IAlphabet<TState> stateAlphabet) {
                         Safe.ArgumentNotNull(inputAlphabet, "inputAlphabet");
                         Safe.ArgumentNotNull(stateAlphabet, "stateAlphabet");
                         foreach(var t in m_transitions)
                             Console.WriteLine(
                                 "[{0}] -{{{1}}}-> [{2}]{3}",
                                 String.Join(",", stateAlphabet.GetSymbols(t.s1)),
                                 String.Join("", inputAlphabet.GetSymbols(t.edge)),
                                 String.Join(",", stateAlphabet.GetSymbols(t.s2)),
                                 m_finalStates.Contains(t.s2) ? "$" : ""
                             );
                     }
                 }
             }

Implab/Automaton/EnumAlphabet.cs 0 -4

             using System;
             using System.Collections.Generic;
             using System.Diagnostics;
             using System.Globalization;
             using System.Linq;
             using System.Diagnostics.CodeAnalysis;
             namespace Implab.Automaton {
                 /// <summary>
                 /// Алфавит символами которого являются элементы перечислений.
                 /// </summary>
                 /// <typeparam name="T">Тип перечислений</typeparam>
                 public class EnumAlphabet<T> : IndexedAlphabetBase<T> where T : struct, IConvertible {
                     [SuppressMessage("Microsoft.Design", "CA1000:DoNotDeclareStaticMembersOnGenericTypes")]
                     static readonly Lazy<T[]> _symbols = new Lazy<T[]>(GetSymbols);
                     [SuppressMessage("Microsoft.Design", "CA1000:DoNotDeclareStaticMembersOnGenericTypes")]
                     static readonly Lazy<EnumAlphabet<T>> _fullAlphabet = new Lazy<EnumAlphabet<T>>(CreateEnumAlphabet);
                     static EnumAlphabet<T> CreateEnumAlphabet() {
                         var symbols = _symbols.Value;
                         if (
                             symbols[symbols.Length - 1].ToInt32(CultureInfo.InvariantCulture) >= symbols.Length
                             || symbols[0].ToInt32(CultureInfo.InvariantCulture) != 0
                         )
                             throw new InvalidOperationException("The specified enumeration must be zero-based and continuously numbered");
                         return new EnumAlphabet<T>(symbols.Select(x => x.ToInt32(CultureInfo.InvariantCulture)).ToArray());
                     }
                     static T[] GetSymbols() {
                         if (!typeof(T).IsEnum)
                             throw new InvalidOperationException("Invalid generic parameter, enumeration is required");
                         if (Enum.GetUnderlyingType(typeof(T)) != typeof(Int32))
                             throw new InvalidOperationException("Only enums based on Int32 are supported");
                         return ((T[])Enum.GetValues(typeof(T)))
                             .OrderBy(x => x.ToInt32(CultureInfo.InvariantCulture))
                             .ToArray();
                     }
                     public static EnumAlphabet<T> FullAlphabet {
                         get {
                             return _fullAlphabet.Value;
                         }
                     }
                     public EnumAlphabet()
                         : base(_symbols.Value.Length) {
                     }
                     public EnumAlphabet(int[] map)
                         : base(map) {
                         Debug.Assert(map.Length == _symbols.Value.Length);
                     }
                     public override int GetSymbolIndex(T symbol) {
                         return symbol.ToInt32(CultureInfo.InvariantCulture);
                     }
-                    public override IEnumerable<T> InputSymbols {
-                        get { return _symbols.Value; }
                 }
             }

Implab/Automaton/IndexedAlphabetBase.cs +2 -2

             using Implab;
             using System;
             using System.Collections.Generic;
             using System.Diagnostics;
             using System.Linq;
             namespace Implab.Automaton {
                 /// <summary>
                 /// Indexed alphabet is the finite set of symbols where each symbol has a zero-based unique index.
                 /// </summary>
                 /// <remarks>
                 /// Indexed alphabets are usefull in bulting efficient translations from source alphabet
                 /// to the input alphabet of the automaton. It's assumed that the index to the symbol match
                 /// is well known and documented.
                 /// </remarks>
                 public abstract class IndexedAlphabetBase<T> : MapAlphabet<T> {
                     protected IndexedAlphabetBase() :base(true, null) {
                     }
                     public abstract int GetSymbolIndex(T symbol);
                     /// <summary>
                     /// Gets the translation map from the index of the symbol to it's class this is usefull for the optimized input symbols transtaion.
                     /// </summary>
                     /// <remarks>
                     /// The map is continous and start from the symbol with zero code. The last symbol
                     /// in the map is the last classified symbol in the alphabet, i.e. the map can be
                     /// shorter then the whole alphabet.
                     /// </remarks>
                     /// <returns>The translation map.</returns>
                     public int[] GetTranslationMap() {
-                        Dictionary<int,int> map = new Dictionary<int, int>();
+                        var map = new Dictionary<int, int>();
-                        int max;
+                        int max = 0;
                         foreach (var p in Mappings) {
                             var index = GetSymbolIndex(p.Key);
                             max = Math.Max(max, index);
                             map[index] = p.Value;
                         }
                         var result = new int[max + 1];
                         for (int i = 0; i < result.Length; i++)
                             map.TryGetValue(i, out result[i]);
                         return result;
                     }
                 }
             }

Implab/Automaton/RegularExpressions/RegularDFA.cs 0 -1

             using System.Collections.Generic;
             using System.Linq;
             namespace Implab.Automaton.RegularExpressions {
                 public class RegularDFA<TInput, TTag> : DFATable, ITaggedDFABuilder<TTag> {
                     readonly Dictionary<int,TTag[]> m_tags = new Dictionary<int, TTag[]>();
                     readonly IAlphabet<TInput> m_alphabet;
                     public RegularDFA(IAlphabet<TInput> alphabet) {
                         Safe.ArgumentNotNull(alphabet, "aplhabet");
                         m_alphabet = alphabet;
                     }
                     public IAlphabet<TInput> InputAlphabet {
                         get {
                             return m_alphabet;
                         }
                     }
                     public void MarkFinalState(int s, TTag[] tags) {
                         MarkFinalState(s);
                         SetStateTag(s, tags);
                     }
                     public void SetStateTag(int s, TTag[] tags) {
                         Safe.ArgumentNotNull(tags, "tags");
                         m_tags[s] = tags;
                     }
                     public TTag[] GetStateTag(int s) {
                         TTag[] tags;
                         return m_tags.TryGetValue(s, out tags) ? tags : new TTag[0];
                     }
                     public TTag[][] CreateTagTable() {
                         var table = new TTag[StateCount][];
                         foreach (var pair in m_tags)
                             table[pair.Key] = pair.Value;
                         return table;
                     }
                     /// <summary>
                     /// Optimize the specified alphabet.
                     /// </summary>
                     /// <param name="alphabet">Пустой алфавит, который будет зполнен в процессе оптимизации.</param>
                     public RegularDFA<TInput,TTag> Optimize(IAlphabetBuilder<TInput> alphabet) {
                         Safe.ArgumentNotNull(alphabet, "alphabet");
                         var dfa = new RegularDFA<TInput, TTag>(alphabet);
-                        var states = new DummyAlphabet(StateCount);
                         var alphaMap = new Dictionary<int,int>();
                         var stateMap = new Dictionary<int,int>();
                         Optimize(dfa, alphaMap, stateMap);
                         // mark tags in the new DFA
                         foreach (var g in m_tags.Where(x => x.Key < StateCount).GroupBy(x => stateMap[x.Key], x => x.Value ))
                             dfa.SetStateTag(g.Key, g.SelectMany(x => x).ToArray());
                         // make the alphabet for the new DFA
                         foreach (var pair in alphaMap)
                             alphabet.DefineClass(m_alphabet.GetSymbols(pair.Key), pair.Value);
                         return dfa;
                     }
                     protected override IEnumerable<HashSet<int>> GroupFinalStates() {
                         var arrayComparer = new CustomEqualityComparer<TTag[]>(
                             (x,y) => x.Length == y.Length && x.All(it => y.Contains(it)),
                             x => x.Sum(it => x.GetHashCode())
                         );
                         return FinalStates.GroupBy(x => m_tags[x], arrayComparer).Select(g => new HashSet<int>(g));
                     }
                 }
             }

Implab/Components/LazyAndWeak.cs +19 0

             using System;
             using System.Threading;
             namespace Implab.Components {
+                /// <summary>
+                /// Creates an instace on-demand and allows it to be garbage collected.
+                /// </summary>
+                /// <remarks>
+                /// Usefull when dealing with memory-intensive objects which are frequently used.
+                /// This class is similar to <see cref="ObjectPool{T}"/> except is a singleton.
+                /// </remarks>
                 public class LazyAndWeak<T> where T : class {
                     readonly Func<T> m_factory;
                     readonly object m_lock;
                     WeakReference m_reference;
                     public LazyAndWeak(Func<T> factory, bool useLock) {
                         Safe.ArgumentNotNull(factory, "factory");
                         m_factory = factory;
                         m_lock = useLock ? new object() : null;
                     }
                     public LazyAndWeak(Func<T> factory) : this(factory, false) {
                     }
                     public T Value {
                         get {
                             while (true) {
                                 var weak = m_reference;
                                 T value;
                                 if (weak != null) {
                                     value = weak.Target as T;
                                     if (value != null)
                                         return value;
                                 }
                                 if (m_lock == null) {
                                     value = m_factory();
                                     if (Interlocked.CompareExchange(ref m_reference, new WeakReference(value), weak) == weak)
                                         return value;
                                 } else {
+                                    lock (m_lock) {
+                                        // double check
+                                        if (weak != null) {
+                                            value = weak.Target as T;
+                                            if (value != null)
+                                                return value;
+                                        }
+                                        // we are safe to write
+                                        value = m_factory();
+                                        m_reference = new WeakReference(value);
+                                        return value;
+                                    }
                                 }
                             }
                         }
                     }
                 }
             }

Implab/Components/RunnableComponent.cs +1 -1

             using System;
-            using Implab.Parsing;
+            using Implab.Formats;
             namespace Implab.Components {
                 public class RunnableComponent : Disposable, IRunnable, IInitializable {
                     IPromise m_pending;
                     Exception m_lastError;
                     protected RunnableComponent(bool initialized) {
                     }
                     #region IInitializable implementation
                     public void Init() {
                     }
                     #endregion
                     #region IRunnable implementation
                     public IPromise Start() {
                         throw new NotImplementedException();
                     }
                     protected virtual IPromise OnStart() {
                         return Promise.SUCCESS;
                     }
                     protected virtual void Run() {
                     }
                     public IPromise Stop() {
                         throw new NotImplementedException();
                     }
                     public ExecutionState State {
                         get {
                             throw new NotImplementedException();
                         }
                     }
                     public Exception LastError {
                         get {
                             throw new NotImplementedException();
                         }
                     }
                     #endregion
                 }
             }

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

             namespace Implab.Formats.JSON {
                 /// <summary>
                 /// internal
                 /// </summary>
                 enum JSONElementContext {
                     None,
                     Object,
-                    Array
+                    Array,
+                    Closed
                 }
             }

Implab/Formats/JSON/JSONGrammar.cs +10 -2

             using System.Linq;
             using Implab.Automaton.RegularExpressions;
             using System;
             using Implab.Automaton;
+            using Implab.Components;
             namespace Implab.Formats.JSON {
                 class JSONGrammar : Grammar<char> {
                     public enum TokenType {
                         None,
                         BeginObject,
                         EndObject,
                         BeginArray,
                         EndArray,
                         String,
                         Number,
                         Literal,
                         NameSeparator,
                         ValueSeparator,
                         StringBound,
                         EscapedChar,
                         UnescapedChar,
                         EscapedUnicode
                     }
-                    static Lazy<JSONGrammar> _instance = new Lazy<JSONGrammar>();
+                    static LazyAndWeak<JSONGrammar> _instance = new LazyAndWeak<JSONGrammar>(() => new JSONGrammar());
                     public static JSONGrammar Instance {
                         get { return _instance.Value; }
                     }
                     readonly ScannerContext<TokenType> m_jsonExpression;
                     readonly ScannerContext<TokenType> m_stringExpression;
+                    readonly CharAlphabet m_defaultAlphabet = new CharAlphabet();
                     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_jsonExpression = BuildScannerContext<TokenType>(jsonExpression);
                         m_stringExpression = BuildScannerContext<TokenType>(jsonStringExpression);
                     }
+                    protected override IAlphabetBuilder<char> AlphabetBuilder {
+                        get {
+                            return m_defaultAlphabet;
+                        }
+                    }
                     public ScannerContext<TokenType> JsonExpression {
                         get {
                             return m_jsonExpression;
                         }
                     }
                     public ScannerContext<TokenType> JsonStringExpression {
                         get {
                             return m_stringExpression;
                         }
                     }
                     Token SymbolRangeToken(char start, char stop) {
                         return SymbolToken(Enumerable.Range(start,stop - start).Cast<char>());
                     }
-                    protected override IAlphabetBuilder<char> CreateAlphabet() {
+                    protected override IndexedAlphabetBase<char> CreateAlphabet() {
                         return new CharAlphabet();
                     }
                 }
             }

Implab/Formats/JSON/JSONParser.cs +60 -62

             using System;
             using System.Diagnostics;
             using System.IO;
             using Implab.Automaton;
             using Implab.Automaton.RegularExpressions;
             using System.Linq;
             using Implab.Components;
+            using System.Collections.Generic;
             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 : Disposable {
                     enum MemberContext {
                         MemberName,
                         MemberValue
                     }
                     #region Parser rules
                     struct ParserContext {
                         readonly int[,] m_dfa;
                         int m_state;
                         readonly JSONElementContext m_elementContext;
                         public ParserContext(int[,] dfa, int state, JSONElementContext context) {
                             m_dfa = dfa;
                             m_state = state;
                             m_elementContext = context;
                         }
                         public bool Move(JsonTokenType token) {
-                            var next = m_dfa[m_state, token];
+                            var next = m_dfa[m_state, (int)token];
                             if (next == AutomatonConst.UNREACHABLE_STATE)
                                 return false;
                             m_state = next;
+                            return true;
                         }
                         public JSONElementContext ElementContext {
                             get { return m_elementContext; }
                         }
                     }
+                    static readonly ParserContext _jsonContext;
+                    static readonly ParserContext _objectContext;
+                    static readonly ParserContext _arrayContext;
                     static JSONParser() {
+                        var valueExpression = MakeToken(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 = MakeToken(JsonTokenType.String).Cat(MakeToken(JsonTokenType.NameSeparator)).Cat(valueExpression);
-                        var memberExpression = Token(JsonTokenType.String).Cat(Token(JsonTokenType.NameSeparator)).Cat(valueExpression);
                         var objectExpression = memberExpression
                             .Cat(
-                                Token(JsonTokenType.ValueSeparator)
+                                MakeToken(JsonTokenType.ValueSeparator)
                                 .Cat(memberExpression)
                                 .EClosure()
                             )
                             .Optional()
-                            .Cat(Token(JsonTokenType.EndObject))
+                            .Cat(MakeToken(JsonTokenType.EndObject))
                             .End();
                         var arrayExpression = valueExpression
                             .Cat(
-                                Token(JsonTokenType.ValueSeparator)
+                                MakeToken(JsonTokenType.ValueSeparator)
                                 .Cat(valueExpression)
                                 .EClosure()
                             )
                             .Optional()
-                            .Cat(Token(JsonTokenType.EndArray))
+                            .Cat(MakeToken(JsonTokenType.EndArray))
                             .End();
                         var jsonExpression = valueExpression.End();
-                        _jsonDFA = CreateParserContext(jsonExpression, JSONElementContext.None);
+                        _jsonContext = CreateParserContext(jsonExpression, JSONElementContext.None);
-                        _objectDFA = CreateParserContext(objectExpression, JSONElementContext.Object);
+                        _objectContext = CreateParserContext(objectExpression, JSONElementContext.Object);
-                        _arrayDFA = CreateParserContext(arrayExpression, JSONElementContext.Array);
+                        _arrayContext = CreateParserContext(arrayExpression, JSONElementContext.Array);
                     }
-                    static Token Token(params JsonTokenType[] input) {
+                    static Token MakeToken(params JsonTokenType[] input) {
                         return Token.New( input.Select(t => (int)t).ToArray() );
                     }
                     static ParserContext CreateParserContext(Token expr, JSONElementContext context) {
                         var dfa = new DFATable();
                         var builder = new RegularExpressionVisitor(dfa);
                         expr.Accept(builder);
                         builder.BuildDFA();
                         return new ParserContext(dfa.CreateTransitionTable(), dfa.InitialState, context);
                     }
                     #endregion
-                    JSONScanner m_scanner;
+                    readonly JSONScanner m_scanner;
                     MemberContext m_memberContext;
                     JSONElementType m_elementType;
                     object m_elementValue;
+                    string m_memberName = String.Empty;
+                    Stack<ParserContext> m_stack = new Stack<ParserContext>();
+                    ParserContext m_context = _jsonContext;
                     /// <summary>
                     /// Создает новый парсер на основе строки, содержащей JSON
                     /// </summary>
                     /// <param name="text"></param>
-                    public JSONParser(string text)
+                    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 = new JSONScanner(text);
-                        m_scanner.Feed(text.ToCharArray());
                     }
                     /// <summary>
                     /// Создает новый экземпляр парсера, на основе текстового потока.
                     /// </summary>
                     /// <param name="reader">Текстовый поток.</param>
-                    public JSONParser(TextReader reader)
+                    public JSONParser(TextReader reader) {
-                        : base(_jsonDFA, INITIAL_STATE, new JSONParserContext { elementContext = JSONElementContext.None, memberName = String.Empty }) {
                         Safe.ArgumentNotNull(reader, "reader");
-                        m_scanner = new JSONScanner();
+                        m_scanner = new JSONScanner(reader);
-                        m_scanner.Feed(reader, dispose);
+                    public int Level {
+                        get { return m_stack.Count; }
                     }
                     /// <summary>
                     /// Тип текущего элемента на котором стоит парсер.
                     /// </summary>
                     public JSONElementType ElementType {
                         get { return m_elementType; }
                     }
                     /// <summary>
                     /// Имя элемента - имя свойства родительского контейнера. Для элементов массивов и корневого всегда
                     /// пустая строка.
                     /// </summary>
                     public string ElementName {
-                        get { return m_context.info.memberName; }
+                        get { return m_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;
+                        m_memberName = String.Empty;
                         while (m_scanner.ReadToken(out tokenValue, out tokenType)) {
-                            Move((int)tokenType);
+                            if(!m_context.Move(tokenType))
-                            if (m_context.current == UNREACHEBLE_STATE)
                                 UnexpectedToken(tokenValue, tokenType);
                             switch (tokenType) {
                                 case JsonTokenType.BeginObject:
-                                    Switch(
+                                    m_stack.Push(m_context);
-                                        _objectDFA,
+                                    m_context = _objectContext;
-                                        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();
+                                    if (m_stack.Count == 0)
+                                        UnexpectedToken(tokenValue, tokenType);
+                                    m_context = m_stack.Pop();
                                     m_elementValue = null;
                                     m_elementType = JSONElementType.EndObject;
                                     return true;
                                 case JsonTokenType.BeginArray:
-                                    Switch(
+                                    m_stack.Push(m_context);
-                                        _arrayDFA,
+                                    m_context = _arrayContext;
-                                        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();
+                                    if (m_stack.Count == 0)
+                                        UnexpectedToken(tokenValue, tokenType);
+                                    m_context = m_stack.Pop();
                                     m_elementValue = null;
                                     m_elementType = JSONElementType.EndArray;
                                     return true;
                                 case JsonTokenType.String:
                                     if (m_memberContext == MemberContext.MemberName) {
-                                        m_context.info.memberName = (string)tokenValue;
+                                        m_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;
+                                    m_memberContext = m_context.ElementContext == JSONElementContext.Object ? MemberContext.MemberName : MemberContext.MemberValue;
                                     break;
                                 default:
                                     UnexpectedToken(tokenValue, tokenType);
                                     break;
                             }
                         }
-                        if (m_context.info.elementContext != JSONElementContext.None)
+                        if (m_context.ElementContext != JSONElementContext.None)
                             throw new ParserException("Unexpedted end of data");
+                        EOF = true;
                         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 {
+                        get;
-                            return m_scanner.EOF;
+                        private set;
                     }
                     protected override void Dispose(bool disposing) {
-                        if (disposing) {
+                        if (disposing)
-                            m_scanner.Dispose();
+                            Safe.Dispose(m_scanner);
                     }
                     /// <summary>
                     /// Переходит в конец текущего объекта.
                     /// </summary>
                     public void SeekElementEnd() {
                         var level = Level - 1;
                         Debug.Assert(level >= 0);
                         while (Level != level)
                             Read();
                     }
                 }
             }

Implab/Formats/JSON/JSONScanner.cs +3 0

             using System;
             using System.Globalization;
             using Implab.Automaton;
             using System.Text;
             using Implab.Components;
             using System.IO;
             namespace Implab.Formats.JSON {
                 /// <summary>
                 /// Сканнер (лексер), разбивающий поток символов на токены JSON.
                 /// </summary>
                 public class JSONScanner : Disposable {
                     readonly StringBuilder m_builder = new StringBuilder();
                     readonly ScannerContext<JSONGrammar.TokenType> m_jsonContext = JSONGrammar.Instance.JsonExpression;
                     readonly ScannerContext<JSONGrammar.TokenType> m_stringContext = JSONGrammar.Instance.JsonStringExpression;
                     readonly TextScanner m_scanner;
                     /// <summary>
                     /// Создает новый экземпляр сканнера
                     /// </summary>
                     public JSONScanner(string text) {
                         Safe.ArgumentNotEmpty(text, "text");
                         m_scanner = new StringScanner(text);
                     }
                     public JSONScanner(TextReader reader, int bufferMax, int chunkSize) {
                         Safe.ArgumentNotNull(reader, "reader");
                         m_scanner = new ReaderScanner(reader, bufferMax, chunkSize);
                     }
+                    public JSONScanner(TextReader reader) : this(reader, 1024*1024, 1024){
+                    }
                     /// <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) {
                         JSONGrammar.TokenType[] tag;
                         if (m_jsonContext.Execute(m_scanner, out tag)) {
                             switch (tag[0]) {
                                 case JSONGrammar.TokenType.StringBound:
                                     tokenValue = ReadString();
                                     tokenType = JsonTokenType.String;
                                     break;
                                 case JSONGrammar.TokenType.Number:
                                     tokenValue = Double.Parse(m_scanner.GetTokenValue(), CultureInfo.InvariantCulture);
                                     tokenType = JsonTokenType.Number;
                                     break;
                                 default:
                                     tokenType = (JsonTokenType)tag[0];
                                     tokenValue = m_scanner.GetTokenValue();
                                     break;
                             }
                             return true;
                         }
                         tokenValue = null;
                         tokenType = JsonTokenType.None;
                         return false;
                     }
                     string ReadString() {
                         int pos = 0;
                         var buf = new char[6]; // the buffer for unescaping chars
                         JSONGrammar.TokenType[] tag;
                         m_builder.Clear();
                         while (m_stringContext.Execute(m_scanner, out tag)) {
                             switch (tag[0]) {
                                 case JSONGrammar.TokenType.StringBound:
                                     return m_builder.ToString();
                                 case JSONGrammar.TokenType.UnescapedChar:
                                     m_scanner.CopyTokenTo(m_builder);
                                     break;
                                 case JSONGrammar.TokenType.EscapedUnicode: // \xXXXX - unicode escape sequence
                                     m_scanner.CopyTokenTo(buf, 0);
                                     m_builder.Append(StringTranslator.TranslateHexUnicode(buf, 2));
                                     pos++;
                                     break;
                                 case JSONGrammar.TokenType.EscapedChar:  // \t - escape sequence
                                     m_scanner.CopyTokenTo(buf, 0);
                                     m_builder.Append(StringTranslator.TranslateEscapedChar(buf[1]));
                                     break;
                             }
                         }
                         throw new ParserException("Unexpected end of data");
                     }
                     protected override void Dispose(bool disposing) {
                         if (disposing)
                             Safe.Dispose(m_scanner);
                         base.Dispose(disposing);
                     }
                 }
             }

Implab/Formats/JSON/JSONWriter.cs +1 -1

             using System;
             using System.Collections.Generic;
             using System.IO;
             using System.Globalization;
             using System.Diagnostics;
-            namespace Implab.JSON {
+            namespace Implab.Formats.JSON {
                 public class JSONWriter {
                     struct Context {
                         public bool needComma;
                         public JSONElementContext element;
                     }
                     Stack<Context> m_contextStack = new Stack<Context>();
                     Context m_context;
                     const int BUFFER_SIZE = 64;
                     TextWriter m_writer;
                     readonly bool m_indent = true;
                     readonly int m_indentSize = 4;
                     readonly char[] m_buffer = new char[BUFFER_SIZE];
                     int m_bufferPos;
                     static readonly char [] _hex = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };
                     static readonly char [] _escapeBKS,
                         _escapeFWD,
                         _escapeCR,
                         _escapeNL,
                         _escapeTAB,
                         _escapeBSLASH,
                         _escapeQ;
                     static JSONWriter() {
                         _escapeBKS = "\\b".ToCharArray();
                         _escapeFWD = "\\f".ToCharArray();
                         _escapeCR = "\\r".ToCharArray();
                         _escapeNL = "\\n".ToCharArray();
                         _escapeTAB = "\\t".ToCharArray();
                         _escapeBSLASH = "\\\\".ToCharArray();
                         _escapeQ = "\\\"".ToCharArray();
                     }
                     public JSONWriter(TextWriter writer) {
                         Safe.ArgumentNotNull(writer, "writer");
                         m_writer = writer;
                     }
                     public JSONWriter(TextWriter writer, bool indent) {
                         Safe.ArgumentNotNull(writer, "writer");
                         m_writer = writer;
                         m_indent = indent;
                     }
                     void WriteIndent() {
                         if (m_indent) {
                             var indent = new char[m_contextStack.Count * m_indentSize + 1];
                             indent[0] = '\n';
                             for (int i = 1; i < indent.Length; i++)
                                 indent[i] = ' ';
                             m_writer.Write(new String(indent));
                         } else {
                             m_writer.Write(' ');
                         }
                     }
                     void WriteMemberName(string name) {
                         Safe.ArgumentNotEmpty(name, "name");
                         if (m_context.element != JSONElementContext.Object)
                             OperationNotApplicable("WriteMember");
                         if (m_context.needComma)
                             m_writer.Write(",");
                         WriteIndent();
                         m_context.needComma = true;
                         Write(name);
                         m_writer.Write(" : ");
                     }
                     public void WriteValue(string name, string value) {
                         WriteMemberName(name);
                         Write(value);
                     }
                     public void WriteValue(string name, bool value) {
                         WriteMemberName(name);
                         Write(value);
                     }
                     public void WriteValue(string name, double value) {
                         WriteMemberName(name);
                         Write(value);
                     }
                     public void WriteValue(string value) {
                         if (m_context.element == JSONElementContext.Array) {
                             if (m_context.needComma)
                                 m_writer.Write(",");
                             WriteIndent();
                             m_context.needComma = true;
                             Write(value);
                         } else if (m_context.element == JSONElementContext.None) {
                             Write(value);
                             m_context.element = JSONElementContext.Closed;
                         } else {
                             OperationNotApplicable("WriteValue");
                         }
                     }
                     public void WriteValue(bool value) {
                         if (m_context.element == JSONElementContext.Array) {
                             if (m_context.needComma)
                                 m_writer.Write(",");
                             WriteIndent();
                             m_context.needComma = true;
                             Write(value);
                         } else if (m_context.element == JSONElementContext.None) {
                             Write(value);
                             m_context.element = JSONElementContext.Closed;
                         } else {
                             OperationNotApplicable("WriteValue");
                         }
                     }
                     public void WriteValue(double value) {
                         if (m_context.element == JSONElementContext.Array) {
                             if (m_context.needComma)
                                 m_writer.Write(",");
                             WriteIndent();
                             m_context.needComma = true;
                             Write(value);
                         } else if (m_context.element == JSONElementContext.None) {
                             Write(value);
                             m_context.element = JSONElementContext.Closed;
                         } else {
                             OperationNotApplicable("WriteValue");
                         }
                     }
                     public void BeginObject() {
                         if (m_context.element != JSONElementContext.None && m_context.element != JSONElementContext.Array)
                             OperationNotApplicable("BeginObject");
                         if (m_context.needComma)
                             m_writer.Write(",");
                         WriteIndent();
                         m_context.needComma = true;
                         m_contextStack.Push(m_context);
                         m_context = new Context { element = JSONElementContext.Object, needComma = false };
                         m_writer.Write("{");
                     }
                     public void BeginObject(string name) {
                         WriteMemberName(name);
                         m_contextStack.Push(m_context);
                         m_context = new Context { element = JSONElementContext.Object, needComma = false };
                         m_writer.Write("{");
                     }
                     public void EndObject() {
                         if (m_context.element != JSONElementContext.Object)
                             OperationNotApplicable("EndObject");
                         m_context = m_contextStack.Pop();
                         if (m_contextStack.Count == 0)
                             m_context.element = JSONElementContext.Closed;
                         WriteIndent();
                         m_writer.Write("}");
                     }
                     public void BeginArray() {
                         if (m_context.element != JSONElementContext.None && m_context.element != JSONElementContext.Array)
                             throw new InvalidOperationException();
                         if (m_context.needComma) {
                             m_writer.Write(",");
                         }
                         m_context.needComma = true;
                         WriteIndent();
                         m_contextStack.Push(m_context);
                         m_context = new Context { element = JSONElementContext.Array, needComma = false };
                         m_writer.Write("[");
                     }
                     public void BeginArray(string name) {
                         WriteMemberName(name);
                         m_contextStack.Push(m_context);
                         m_context = new Context { element = JSONElementContext.Array, needComma = false };
                         m_writer.Write("[");
                     }
                     public void EndArray() {
                         if (m_context.element != JSONElementContext.Array)
                             OperationNotApplicable("EndArray");
                         m_context = m_contextStack.Pop();
                         if (m_contextStack.Count == 0)
                             m_context.element = JSONElementContext.Closed;
                         WriteIndent();
                         m_writer.Write("]");
                     }
                     void Write(bool value) {
                         m_writer.Write(value ? "true" : "false");
                     }
                     void FlushBuffer() {
                         if (m_bufferPos > 0) {
                             m_writer.Write(m_buffer, 0, m_bufferPos);
                             m_bufferPos = 0;
                         }
                     }
                     void Write(string value) {
                         if (value == null) {
                             m_writer.Write("null");
                             return;
                         }
                         Debug.Assert(m_bufferPos == 0);
                         var chars = value.ToCharArray();
                         m_buffer[m_bufferPos++] = '"';
                         // Analysis disable once ForCanBeConvertedToForeach
                         for (int i = 0; i < chars.Length; i++) {
                             var ch = chars[i];
                             char[] escapeSeq;
                             switch (ch) {
                                 case '\b':
                                     escapeSeq = _escapeBKS;
                                     break;
                                 case '\f':
                                     escapeSeq = _escapeFWD;
                                     break;
                                 case '\r':
                                     escapeSeq = _escapeCR;
                                     break;
                                 case '\n':
                                     escapeSeq = _escapeNL;
                                     break;
                                 case '\t':
                                     escapeSeq = _escapeTAB;
                                     break;
                                 case '\\':
                                     escapeSeq = _escapeBSLASH;
                                     break;
                                 case '"':
                                     escapeSeq = _escapeQ;
                                     break;
                                 default:
                                     if (ch < 0x20) {
                                         if (m_bufferPos + 6 > BUFFER_SIZE)
                                             FlushBuffer();
                                         m_buffer[m_bufferPos++] = '\\';
                                         m_buffer[m_bufferPos++] = 'u';
                                         m_buffer[m_bufferPos++] = '0';
                                         m_buffer[m_bufferPos++] = '0';
                                         m_buffer[m_bufferPos++] = _hex[ch >> 4 & 0xf];
                                         m_buffer[m_bufferPos++] = _hex[ch & 0xf];
                                     } else {
                                         if (m_bufferPos >= BUFFER_SIZE)
                                             FlushBuffer();
                                         m_buffer[m_bufferPos++] = ch;
                                     }
                                     continue;
                             }
                             if (m_bufferPos + escapeSeq.Length > BUFFER_SIZE)
                                 FlushBuffer();
                             Array.Copy(escapeSeq, 0, m_buffer, m_bufferPos, escapeSeq.Length);
                             m_bufferPos += escapeSeq.Length;
                         }
                         if (m_bufferPos >= BUFFER_SIZE)
                             FlushBuffer();
                         m_buffer[m_bufferPos++] = '"';
                         FlushBuffer();
                     }
                     void Write(double value) {
                         if (double.IsNaN(value))
                             Write("NaN");
                         else if (double.IsNegativeInfinity(value))
                             Write("-Infinity");
                         else if (double.IsPositiveInfinity(value))
                             Write("Infinity");
                         else
                             m_writer.Write(value.ToString(CultureInfo.InvariantCulture));
                     }
                     void OperationNotApplicable(string opName) {
                         throw new InvalidOperationException(String.Format("The operation '{0}' isn't applicable in the context of '{1}'", opName, m_context.element ));
                     }
                 }
             }

Implab/Formats/JSON/JSONXmlReader.cs +9 -17

             using Implab;
-            using Implab.Parsing;
             using System;
             using System.Collections.Generic;
             using System.Globalization;
             using System.IO;
-            using System.Linq;
-            using System.Text;
-            using System.Threading.Tasks;
             using System.Xml;
-            namespace Implab.JSON {
+            namespace Implab.Formats.JSON {
                 public class JSONXmlReader : XmlReader {
                     enum ValueContext {
                         Undefined,
                         ElementStart,
                         ElementValue,
                         ElementEnd,
                         ElementEmpty
                     }
                     struct LocalNameContext {
                         public string localName;
                         public bool isArray;
                     }
                     JSONParser m_parser;
                     ValueContext m_valueContext;
                     ReadState m_state = ReadState.Initial;
                     Stack<LocalNameContext> m_localNameStack = new Stack<LocalNameContext>();
                     LocalNameContext m_localName;
-                    int m_depthCorrection = 0;
+                    int m_depthCorrection;
                     readonly string m_rootName;
                     readonly string m_prefix;
                     readonly string m_namespaceUri;
                     readonly bool m_flattenArrays;
                     readonly string m_arrayItemName;
                     readonly XmlNameTable m_nameTable;
                     JSONXmlReader(JSONParser parser, JSONXmlReaderOptions options) {
                         m_parser = parser;
                         if (options != null) {
                             m_prefix = options.NodesPrefix ?? String.Empty;
                             m_namespaceUri = options.NamespaceURI ?? String.Empty;
                             m_rootName = options.RootName ?? "json";
                             m_flattenArrays = options.FlattenArrays;
                             m_arrayItemName = options.ArrayItemName ?? "item";
                             m_nameTable = options.NameTable ?? new NameTable();
                         } else {
                             m_prefix = String.Empty;
                             m_namespaceUri = String.Empty;
                             m_rootName = "json";
                             m_flattenArrays = false;
                             m_arrayItemName = "item";
                             m_nameTable = new NameTable();
                         }
                     }
                     /// <summary>
                     /// Always 0, JSON doesn't support attributes
                     /// </summary>
                     public override int AttributeCount {
                         get { return 0; }
                     }
                     public override string BaseURI {
                         get { return String.Empty; }
                     }
                     public override int Depth {
                         get {
                             return m_localNameStack.Count + m_depthCorrection;
                         }
                     }
                     public override bool EOF {
                         get { return m_parser.EOF; }
                     }
                     /// <summary>
                     /// Always throws an exception
                     /// </summary>
                     /// <param name="i"></param>
                     /// <returns></returns>
                     public override string GetAttribute(int i) {
                         throw new ArgumentOutOfRangeException();
                     }
                     /// <summary>
                     /// Always returns empty string
                     /// </summary>
                     /// <param name="name"></param>
                     /// <param name="namespaceURI"></param>
                     /// <returns></returns>
                     public override string GetAttribute(string name, string namespaceURI) {
                         return String.Empty;
                     }
                     /// <summary>
                     /// Always returns empty string
                     /// </summary>
                     /// <param name="name"></param>
                     /// <returns></returns>
                     public override string GetAttribute(string name) {
                         return String.Empty;
                     }
                     public override bool IsEmptyElement {
                         get { return m_parser.ElementType == JSONElementType.Value && m_valueContext == ValueContext.ElementEmpty; }
                     }
                     public override string LocalName {
                         get { return m_localName.localName; }
                     }
                     public override string LookupNamespace(string prefix) {
                         if (String.IsNullOrEmpty(prefix) || prefix == m_prefix)
                             return m_namespaceUri;
-                        else
                         return String.Empty;
                     }
                     public override bool MoveToAttribute(string name, string ns) {
                         return false;
                     }
                     public override bool MoveToAttribute(string name) {
                         return false;
                     }
                     public override bool MoveToElement() {
                         return false;
                     }
                     public override bool MoveToFirstAttribute() {
                         return false;
                     }
                     public override bool MoveToNextAttribute() {
                         return false;
                     }
                     public override XmlNameTable NameTable {
                         get { return m_nameTable; }
                     }
                     public override string NamespaceURI {
                         get { return m_namespaceUri; }
                     }
                     public override XmlNodeType NodeType {
                         get {
                             switch (m_parser.ElementType) {
                                 case JSONElementType.BeginObject:
                                 case JSONElementType.BeginArray:
                                     return XmlNodeType.Element;
                                 case JSONElementType.EndObject:
                                 case JSONElementType.EndArray:
                                     return XmlNodeType.EndElement;
                                 case JSONElementType.Value:
                                     switch (m_valueContext) {
                                         case ValueContext.ElementStart:
                                         case ValueContext.ElementEmpty:
                                             return XmlNodeType.Element;
                                         case ValueContext.ElementValue:
                                             return XmlNodeType.Text;
                                         case ValueContext.ElementEnd:
                                             return XmlNodeType.EndElement;
                                         default:
                                             throw new InvalidOperationException();
                                     }
                                 default:
                                     throw new InvalidOperationException();
                             }
                         }
                     }
                     public override string Prefix {
                         get { return m_prefix; }
                     }
                     public override bool Read() {
-                        if (m_state != System.Xml.ReadState.Interactive && m_state != System.Xml.ReadState.Initial)
+                        if (m_state != ReadState.Interactive && m_state != ReadState.Initial)
                             return false;
                         if (m_state == ReadState.Initial)
-                            m_state = System.Xml.ReadState.Interactive;
+                            m_state = ReadState.Interactive;
                         try {
                             switch (m_parser.ElementType) {
                                 case JSONElementType.Value:
                                     switch (m_valueContext) {
                                         case ValueContext.ElementStart:
                                             SetLocalName(String.Empty);
                                             m_valueContext = ValueContext.ElementValue;
                                             return true;
                                         case ValueContext.ElementValue:
                                             RestoreLocalName();
                                             m_valueContext = ValueContext.ElementEnd;
                                             return true;
                                         case ValueContext.ElementEmpty:
                                         case ValueContext.ElementEnd:
                                             RestoreLocalName();
                                             break;
                                     }
                                     break;
                                 case JSONElementType.EndArray:
                                 case JSONElementType.EndObject:
                                     RestoreLocalName();
                                     break;
                             }
                             string itemName = m_parser.ElementType == JSONElementType.None ? m_rootName : m_flattenArrays ? m_localName.localName : m_arrayItemName;
                             while (m_parser.Read()) {
                                 if (!String.IsNullOrEmpty(m_parser.ElementName))
                                     itemName = m_parser.ElementName;
                                 switch (m_parser.ElementType) {
                                     case JSONElementType.BeginArray:
                                         if (m_flattenArrays && !m_localName.isArray) {
                                             m_depthCorrection--;
                                             SetLocalName(itemName, true);
                                             continue;
-                                        } else {
                                         SetLocalName(itemName, true);
                                         break;
                                     case JSONElementType.BeginObject:
                                         SetLocalName(itemName);
                                         break;
                                     case JSONElementType.EndArray:
                                         if (m_flattenArrays && !m_localNameStack.Peek().isArray) {
                                             RestoreLocalName();
                                             m_depthCorrection++;
                                             continue;
                                         }
                                         break;
                                     case JSONElementType.EndObject:
                                         break;
                                     case JSONElementType.Value:
                                         SetLocalName(itemName);
                                         m_valueContext = m_parser.ElementValue == null ? ValueContext.ElementEmpty : ValueContext.ElementStart;
                                         break;
-                                    default:
-                                        break;
                                 }
                                 return true;
                             }
-                            m_state = System.Xml.ReadState.EndOfFile;
+                            m_state = ReadState.EndOfFile;
                             return false;
                         } catch {
-                            m_state = System.Xml.ReadState.Error;
+                            m_state = ReadState.Error;
                             throw;
                         }
                     }
                     public override bool ReadAttributeValue() {
                         return false;
                     }
                     public override ReadState ReadState {
                         get { return m_state; }
                     }
                     public override void ResolveEntity() {
                         // do nothing
                     }
                     public override string Value {
                         get {
                             if (m_parser.ElementValue == null)
                                 return String.Empty;
                             if (Convert.GetTypeCode(m_parser.ElementValue) == TypeCode.Double)
                                 return ((double)m_parser.ElementValue).ToString(CultureInfo.InvariantCulture);
-                            else
                             return m_parser.ElementValue.ToString();
                         }
                     }
                     void SetLocalName(string name) {
                         m_localNameStack.Push(m_localName);
                         m_localName.localName = name;
                         m_localName.isArray = false;
                     }
                     void SetLocalName(string name, bool isArray) {
                         m_localNameStack.Push(m_localName);
                         m_localName.localName = name;
                         m_localName.isArray = isArray;
                     }
                     void RestoreLocalName() {
                         m_localName = m_localNameStack.Pop();
                     }
                     public override void Close() {
                     }
                     protected override void Dispose(bool disposing) {
                         #if MONO
                         disposing = true;
                         #endif
                         if (disposing) {
                             m_parser.Dispose();
                         }
                         base.Dispose(disposing);
                     }
                     public static JSONXmlReader Create(string file, JSONXmlReaderOptions options) {
                         return Create(File.OpenText(file), options);
                     }
                     /// <summary>
                     /// Creates the XmlReader for the specified text stream with JSON data.
                     /// </summary>
                     /// <param name="reader">Text reader.</param>
                     /// <param name="options">Options.</param>
                     /// <remarks>
                     /// The reader will be disposed when the XmlReader is disposed.
                     /// </remarks>
                     public static JSONXmlReader Create(TextReader reader,  JSONXmlReaderOptions options) {
-                        return new JSONXmlReader(new JSONParser(reader, true), options);
+                        return new JSONXmlReader(new JSONParser(reader), options);
                     }
                     /// <summary>
                     /// Creates the XmlReader for the specified stream with JSON data.
                     /// </summary>
                     /// <param name="stream">Stream.</param>
                     /// <param name="options">Options.</param>
                     /// <remarks>
                     /// The stream will be disposed when the XmlReader is disposed.
                     /// </remarks>
                     public static JSONXmlReader Create(Stream stream,  JSONXmlReaderOptions options) {
                         Safe.ArgumentNotNull(stream, "stream");
                         // HACK don't dispose StreaReader to keep stream opened
                         return Create(new StreamReader(stream), options);
                     }
                 }
             }

Implab/Formats/JSON/JSONXmlReaderOptions.cs +2 -5

-            using System;
-            using System.Collections.Generic;
-            using System.Linq;
-            using System.Text;
             using System.Xml;
-            namespace Implab.JSON {
+            namespace Implab.Formats.JSON {
                 /// <summary>
                 /// Набор необязательных параметров для <see cref="JSONXmlReader"/>, позволяющий управлять процессом
                 /// интерпретации <c>JSON</c> документа.
                 /// </summary>
                 public class JSONXmlReaderOptions {
                     /// <summary>
                     /// Пространство имен в котором будут располагаться читаемые элементы документа
                     /// </summary>
                     public string NamespaceURI {
                         get;
                         set;
                     }
                     /// <summary>
                     /// Интерпретировать массивы как множественные элементы (убирает один уровень вложенности), иначе массив
                     /// представляется в виде узла, дочерними элементами которого являются элементы массива, имена дочерних элементов
                     /// определяются свойством <see cref="ArrayItemName"/>. По умолчанию <c>false</c>.
                     /// </summary>
                     public bool FlattenArrays {
                         get;
                         set;
                     }
                     /// <summary>
                     /// Префикс, для узлов документа
                     /// </summary>
                     public string NodesPrefix {
                         get;
                         set;
                     }
                     /// <summary>
                     /// Имя корневого элемента в xml документе
                     /// </summary>
                     public string RootName {
                         get;
                         set;
                     }
                     /// <summary>
                     /// Имя элемента для массивов, если не включена опция <see cref="FlattenArrays"/>.
                     /// По умолчанию <c>item</c>.
                     /// </summary>
                     public string ArrayItemName {
                         get;
                         set;
                     }
                     /// <summary>
                     /// Таблица атомизированных строк для построения документа.
                     /// </summary>
                     public XmlNameTable NameTable {
                         get;
                         set;
                     }
                 }
             }

Implab/Formats/JSON/StringTranslator.cs +1 -44

             using Implab;
             using Implab.Formats;
             using System;
             using System.Collections.Generic;
             using System.Diagnostics;
             using System.Linq;
             using System.Text;
             using System.Threading.Tasks;
             namespace Implab.Formats.JSON {
                 /// <summary>
                 /// Класс для преобразования экранированной строки JSON
                 /// </summary>
-                public class StringTranslator : TextScanner<JSONGrammar.TokenType> {
+                static class StringTranslator {
                     static readonly char[] _escMap;
                     static readonly int[] _hexMap;
                     static StringTranslator() {
                         var chars = new char[] { 'b', 'f', 't', 'r', 'n', '\\', '/' };
                         var vals = new char[] { '\b', '\f', '\t', '\r', '\n', '\\', '/' };
                         _escMap = new char[chars.Max() + 1];
                         for (int i = 0; i < chars.Length; i++)
                             _escMap[chars[i]] = vals[i];
                         var hexs = new char[] { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f', 'A', 'B', 'C', 'D', 'E', 'F' };
                         var ints = new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 10, 11, 12, 13, 14, 15 };
                         _hexMap = new int[hexs.Max() + 1];
                         for (int i = 0; i < hexs.Length; i++)
                             _hexMap[hexs[i]] = ints[i];
                     }
-                    public StringTranslator() {
-                    public string Translate(string data) {
-                        Safe.ArgumentNotNull(data, "data");
-                        return Translate(data.ToCharArray());
-                    public string Translate(char[] data) {
-                        Safe.ArgumentNotNull(data, "data");
-                        return Translate(data, data.Length);
-                    public string Translate(char[] data, int length) {
-                        Safe.ArgumentNotNull(data, "data");
-                        Safe.ArgumentInRange(length, 0, data.Length, "length");
-                        var translated = new char[length];
-                        Feed(data,length);
-                        int pos = 0;
-                        while (ReadTokenInternal()) {
-                            switch ((JSONGrammar.TokenType)Tags[0]) {
-                                case JSONGrammar.TokenType.UnescapedChar:
-                                    Array.Copy(m_buffer,m_tokenOffset,translated,pos,m_tokenLen);
-                                    pos += m_tokenLen;
-                                    break;
-                                case JSONGrammar.TokenType.EscapedChar:
-                                    translated[pos] = _escMap[m_buffer[m_tokenOffset + 1]];
-                                    pos++;
-                                    break;
-                                case JSONGrammar.TokenType.EscapedUnicode:
-                                    translated[pos] = TranslateHexUnicode(m_buffer,m_tokenOffset + 2);
-                                    pos++;
-                                    break;
-                        return new String(translated, 0, pos);
                     internal static char TranslateEscapedChar(char symbol) {
                         return _escMap[symbol];
                     }
                     internal static char TranslateHexUnicode(char[] symbols, int offset) {
                         Debug.Assert(symbols != null);
                         Debug.Assert(symbols.Length - offset >= 4);
                         int value = (_hexMap[symbols[offset]] << 12)
                             | (_hexMap[symbols[offset + 1]] << 8)
                             | (_hexMap[symbols[offset + 2]] << 4)
                             | (_hexMap[symbols[offset + 3]]);
                         return (char)value;
                     }
                 }
             }

Implab/Formats/TextScanner.cs +7 -1

             using System;
             using Implab.Components;
             using System.Diagnostics;
             using Implab.Automaton;
             using System.Text;
             namespace Implab.Formats {
                 public abstract class TextScanner : Disposable {
                     readonly int m_bufferMax;
                     readonly int m_chunkSize;
                     char[] m_buffer;
                     int m_bufferOffset;
                     int m_bufferSize;
                     int m_tokenOffset;
                     int m_tokenLength;
                     /// <summary>
                     /// Initializes a new instance of the <see cref="Implab.Formats.TextScanner"/> class.
                     /// </summary>
                     /// <param name="bufferMax">Buffer max.</param>
                     /// <param name="chunkSize">Chunk size.</param>
                     protected TextScanner(int bufferMax, int chunkSize) {
                         Debug.Assert(m_chunkSize <= m_bufferMax);
                         m_bufferMax = bufferMax;
                         m_chunkSize = chunkSize;
                     }
                     /// <summary>
                     /// Initializes a new instance of the <see cref="Implab.Formats.TextScanner"/> class.
                     /// </summary>
                     /// <param name="buffer">Buffer.</param>
                     protected TextScanner(char[] buffer) {
                         if (buffer != null) {
                             m_buffer = buffer;
                             m_bufferSize = buffer.Length;
                         }
                     }
                     /// <summary>
                     /// (hungry) Reads the next token.
                     /// </summary>
                     /// <returns><c>true</c>, if token internal was read, <c>false</c> if there is no more tokens in the stream.</returns>
                     /// <param name="dfa">The transition map for the automaton</param>
                     /// <param name="final">Final states of the automaton.</param>
                     /// <param name="tags">Tags.</param>
                     /// <param name="state">The initial state for the automaton.</param>
                     /// <param name="alphabet"></param>
                     /// <param name = "tag"></param>
                     internal bool ReadToken<TTag>(int[,] dfa, bool[] final, TTag[][] tags, int state, int[] alphabet, out TTag[] tag) {
-                        Safe.ArgumentNotNull();
                         m_tokenLength = 0;
+                        tag = null;
                         var maxSymbol = alphabet.Length - 1;
                         do {
                             // after the next chunk is read the offset in the buffer may change
                             int pos = m_bufferOffset + m_tokenLength;
                             while (pos < m_bufferSize) {
                                 var ch = m_buffer[pos];
                                 state = dfa[state, ch > maxSymbol ? AutomatonConst.UNCLASSIFIED_INPUT : alphabet[ch]];
                                 if (state == AutomatonConst.UNREACHABLE_STATE)
                                     break;
                                 pos++;
                             }
                             m_tokenLength = pos - m_bufferOffset;
                         } while (state != AutomatonConst.UNREACHABLE_STATE && Feed());
                         m_tokenOffset = m_bufferOffset;
                         m_bufferOffset += m_tokenLength;
                         if (final[state]) {
                             tag = tags[state];
                             return true;
                         }
                         if (m_bufferOffset == m_bufferSize) {
                             if (m_tokenLength == 0) //EOF
                                     return false;
                             throw new ParserException();
                         }
                         throw new ParserException(String.Format("Unexpected symbol '{0}'", m_buffer[m_bufferOffset]));
                     }
                     protected void Feed(char[] buffer, int offset, int length) {
                         m_buffer = buffer;
                         m_bufferOffset = offset;
                         m_bufferSize = offset + length;
                     }
                     protected bool Feed() {
                         if (m_chunkSize <= 0)
                             return false;
                         if (m_buffer != null) {
                             var free = m_buffer.Length - m_bufferSize;
                             if (free < m_chunkSize) {
                                 free += m_chunkSize;
                                 var used = m_bufferSize - m_bufferOffset;
                                 var size = used + free;
                                 if (size > m_bufferMax)
                                     throw new ParserException(String.Format("The buffer limit ({0} Kb) is reached", m_bufferMax / 1024));
                                 var temp = new char[size];
                                 var read = Read(temp, used, m_chunkSize);
                                 if (read == 0)
                                     return false;
                                 Array.Copy(m_buffer, m_bufferOffset, temp, 0, used);
                                 m_bufferOffset = 0;
                                 m_bufferSize = used + read;
                                 m_buffer = temp;
+                            } else {
+                                var read = Read(m_buffer, m_bufferSize, m_chunkSize);
+                                if (read == 0)
+                                    return false;
+                                m_bufferSize += m_chunkSize;
                             }
+                            return true;
                         } else {
                             Debug.Assert(m_bufferOffset == 0);
                             m_buffer = new char[m_chunkSize];
                             m_bufferSize = Read(m_buffer, 0, m_chunkSize);
                             return (m_bufferSize != 0);
                         }
                     }
                     protected abstract int Read(char[] buffer, int offset, int size);
                     public string GetTokenValue() {
                         return new String(m_buffer, m_tokenOffset, m_tokenLength);
                     }
                     public void CopyTokenTo(char[] buffer, int offset) {
                         m_buffer.CopyTo(buffer, offset);
                     }
                     public void CopyTokenTo(StringBuilder sb) {
                         sb.Append(m_buffer, m_tokenOffset, m_tokenLength);
                     }
                 }
             }

Implab/Implab.csproj 0 -2

             <?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\EnumAlphabet.cs" />
                 <Compile Include="Automaton\IAlphabet.cs" />
                 <Compile Include="Automaton\ParserException.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\RegularExpressions\StarToken.cs" />
                 <Compile Include="Automaton\RegularExpressions\SymbolToken.cs" />
                 <Compile Include="Automaton\RegularExpressions\EmptyToken.cs" />
                 <Compile Include="Automaton\RegularExpressions\Token.cs" />
                 <Compile Include="Automaton\RegularExpressions\IVisitor.cs" />
                 <Compile Include="Automaton\AutomatonTransition.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="Formats\CharAlphabet.cs" />
                 <Compile Include="Formats\ByteAlphabet.cs" />
                 <Compile Include="Automaton\IDFATable.cs" />
                 <Compile Include="Automaton\IDFATableBuilder.cs" />
                 <Compile Include="Automaton\DFATable.cs" />
                 <Compile Include="Automaton\RegularExpressions\RegularExpressionVisitor.cs" />
                 <Compile Include="Automaton\RegularExpressions\ITaggedDFABuilder.cs" />
                 <Compile Include="Formats\TextScanner.cs" />
                 <Compile Include="Formats\StringScanner.cs" />
                 <Compile Include="Formats\ReaderScanner.cs" />
                 <Compile Include="Formats\ScannerContext.cs" />
                 <Compile Include="Formats\Grammar.cs" />
                 <Compile Include="Automaton\RegularExpressions\EndTokenT.cs" />
                 <Compile Include="Automaton\RegularExpressions\EndToken.cs" />
                 <Compile Include="Automaton\RegularExpressions\RegularExpressionVisitorT.cs" />
                 <Compile Include="Automaton\AutomatonConst.cs" />
                 <Compile Include="Automaton\RegularExpressions\RegularDFA.cs" />
                 <Compile Include="Components\LazyAndWeak.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/DummyAlphabet.cs removed 0 -46

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