implab/ImplabNet Commit - r190:1c2a16d071a7

Слияние с ref20160224

cin -

r190:1c2a16d071a7 v2

parent child

Context file:

r190:1c2a16d071a7

Expand all files

The requested changes are too big and content was truncated. Show full diff

Implab.Test/RunnableComponentTests.cs created 644 +195 0

			@@ -0,0 +1,195
		1	using System;
		2	using System.Reflection;
		3	using System.Threading;
		4	using Implab.Parallels;
		5	using Implab.Components;
		6
		7	#if MONO
		8
		9	using NUnit.Framework;
		10	using TestClassAttribute = NUnit.Framework.TestFixtureAttribute;
		11	using TestMethodAttribute = NUnit.Framework.TestAttribute;
		12	using AssertFailedException = NUnit.Framework.AssertionException;
		13	#else
		14
		15	using Microsoft.VisualStudio.TestTools.UnitTesting;
		16
		17	#endif
		18
		19	namespace Implab.Test {
		20	[TestClass]
		21	public class RunnableComponentTests {
		22
		23	static void ShouldThrow(Action action) {
		24	try {
		25	action();
		26	Assert.Fail();
		27	} catch (AssertFailedException) {
		28	throw;
		29	} catch {
		30	}
		31	}
		32
		33	class Runnable : RunnableComponent {
		34	public Runnable(bool initialized) : base(initialized) {
		35	}
		36
		37	public Action MockInit {
		38	get;
		39	set;
		40	}
		41
		42	public Func<IPromise> MockStart {
		43	get;
		44	set;
		45	}
		46
		47	public Func<IPromise> MockStop {
		48	get;
		49	set;
		50	}
		51
		52	protected override IPromise OnStart() {
		53	return MockStart != null ? MockStart() : base.OnStart();
		54	}
		55
		56	protected override IPromise OnStop() {
		57	return MockStop != null ? MockStop() : base.OnStart();
		58	}
		59
		60	protected override void OnInitialize() {
		61	if (MockInit != null)
		62	MockInit();
		63	}
		64	}
		65
		66	[TestMethod]
		67	public void NormalFlowTest() {
		68	var comp = new Runnable(false);
		69
		70	Assert.AreEqual(ExecutionState.Created, comp.State);
		71
		72	comp.Init();
		73
		74	Assert.AreEqual(ExecutionState.Ready, comp.State);
		75
		76	comp.Start().Join(1000);
		77
		78	Assert.AreEqual(ExecutionState.Running, comp.State);
		79
		80	comp.Stop().Join(1000);
		81
		82	Assert.AreEqual(ExecutionState.Disposed, comp.State);
		83
		84	}
		85
		86	[TestMethod]
		87	public void InitFailTest() {
		88	var comp = new Runnable(false) {
		89	MockInit = () => {
		90	throw new Exception("BAD");
		91	}
		92	};
		93
		94	ShouldThrow(() => comp.Start());
		95	ShouldThrow(() => comp.Stop());
		96	Assert.AreEqual(ExecutionState.Created, comp.State);
		97
		98	ShouldThrow(comp.Init);
		99
		100	Assert.AreEqual(ExecutionState.Failed, comp.State);
		101
		102	ShouldThrow(() => comp.Start());
		103	ShouldThrow(() => comp.Stop());
		104	Assert.AreEqual(ExecutionState.Failed, comp.State);
		105
		106	comp.Dispose();
		107	Assert.AreEqual(ExecutionState.Disposed, comp.State);
		108	}
		109
		110	[TestMethod]
		111	public void DisposedTest() {
		112
		113	var comp = new Runnable(false);
		114	comp.Dispose();
		115
		116	ShouldThrow(() => comp.Start());
		117	ShouldThrow(() => comp.Stop());
		118	ShouldThrow(comp.Init);
		119
		120	Assert.AreEqual(ExecutionState.Disposed, comp.State);
		121	}
		122
		123	[TestMethod]
		124	public void StartCancelTest() {
		125	var comp = new Runnable(true) {
		126	MockStart = () => PromiseHelper.Sleep(100000, 0)
		127	};
		128
		129	var p = comp.Start();
		130	Assert.AreEqual(ExecutionState.Starting, comp.State);
		131	p.Cancel();
		132	ShouldThrow(() => p.Join(1000));
		133	Assert.AreEqual(ExecutionState.Failed, comp.State);
		134
		135	Assert.IsInstanceOfType(comp.LastError, typeof(OperationCanceledException));
		136
		137	comp.Dispose();
		138	}
		139
		140	[TestMethod]
		141	public void StartStopTest() {
		142	var stop = new Signal();
		143	var comp = new Runnable(true) {
		144	MockStart = () => PromiseHelper.Sleep(100000, 0),
		145	MockStop = () => AsyncPool.RunThread(stop.Wait)
		146	};
		147
		148	var p1 = comp.Start();
		149	var p2 = comp.Stop();
		150	// should enter stopping state
		151
		152	ShouldThrow(p1.Join);
		153	Assert.IsTrue(p1.IsCancelled);
		154	Assert.AreEqual(ExecutionState.Stopping, comp.State);
		155
		156	stop.Set();
		157	p2.Join(1000);
		158	Assert.AreEqual(ExecutionState.Disposed, comp.State);
		159	}
		160
		161	[TestMethod]
		162	public void StartStopFailTest() {
		163	var comp = new Runnable(true) {
		164	MockStart = () => PromiseHelper.Sleep(100000, 0).Then(null,null,x => { throw new Exception("I'm dead"); })
		165	};
		166
		167	comp.Start();
		168	var p = comp.Stop();
		169	// if Start fails to cancel, should fail to stop
		170	ShouldThrow(() => p.Join(1000));
		171	Assert.AreEqual(ExecutionState.Failed, comp.State);
		172	Assert.IsNotNull(comp.LastError);
		173	Assert.AreEqual("I'm dead", comp.LastError.Message);
		174	}
		175
		176	[TestMethod]
		177	public void StopCancelTest() {
		178	var comp = new Runnable(true) {
		179	MockStop = () => PromiseHelper.Sleep(100000, 0)
		180	};
		181
		182	comp.Start();
		183	var p = comp.Stop();
		184	Assert.AreEqual(ExecutionState.Stopping, comp.State);
		185	p.Cancel();
		186	ShouldThrow(() => p.Join(1000));
		187	Assert.AreEqual(ExecutionState.Failed, comp.State);
		188	Assert.IsInstanceOfType(comp.LastError, typeof(OperationCanceledException));
		189
		190	comp.Dispose();
		191	}
		192
		193	}
		194	}
		195

Implab/AbstractTask.cs created 644 +45 0

			@@ -0,0 +1,45
		1	using System;
		2	using System.Threading;
		3
		4	namespace Implab {
		5	/// <summary>
		6	/// Базовый класс для реализации задачь. Задача представляет собой некторое
		7	/// действие, которое можно иницировать и обработать результат его выполнения
		8	/// в виде обещания, для этого оно реализует интерфейс <see cref="IPromise"/>.
		9	/// </summary>
		10	/// <remarks>
		11	/// Данный класс определяет стандартное поведение при обработки результатов, в частности
		12	/// обработку <see cref="System.OperationCanceledException"/> и <see cref="PromiseTransientException"/>
		13	/// </remarks>
		14	public abstract class AbstractTask : AbstractPromise {
		15	int m_cancelationLock;
		16
		17	/// <summary>
		18	/// Получает эксклюзивное право отмены задания, используется для отмены задания до начала его выполнения.
		19	/// </summary>
		20	/// <returns><c>true</c>, if cancelation was locked, <c>false</c> otherwise.</returns>
		21	protected bool LockCancelation() {
		22	return 0 == Interlocked.CompareExchange(ref m_cancelationLock, 1, 0);
		23	}
		24
		25
		26
		27	protected void SetErrorInternal(Exception error) {
		28	// unwrap
		29	while (error is PromiseTransientException && error.InnerException != null)
		30	error = error.InnerException;
		31
		32	if (error is OperationCanceledException)
		33	SetCancelled(error);
		34	else
		35	SetError(error);
		36	}
		37
		38	protected void SetCancelledInternal(Exception reason) {
		39	SetCancelled(
		40	reason == null ? new OperationCanceledException() : reason is OperationCanceledException ? reason : new OperationCanceledException(null, reason)
		41	);
		42	}
		43	}
		44	}
		45

Implab/AbstractTaskT.cs created 644 +36 0

			@@ -0,0 +1,36
		1	using System;
		2	using System.Threading;
		3
		4	namespace Implab {
		5	public abstract class AbstractTask<T> : AbstractPromise<T> {
		6	int m_cancelationLock;
		7
		8	/// <summary>
		9	/// Получает эксклюзивное право отмены задания, используется для отмены задания до начала его выполнения.
		10	/// </summary>
		11	/// <returns><c>true</c>, if cancelation was locked, <c>false</c> otherwise.</returns>
		12	protected bool LockCancelation() {
		13	return 0 == Interlocked.CompareExchange(ref m_cancelationLock, 1, 0);
		14	}
		15
		16
		17
		18	protected void SetErrorInternal(Exception error) {
		19	// unwrap
		20	while (error is PromiseTransientException && error.InnerException != null)
		21	error = error.InnerException;
		22
		23	if (error is OperationCanceledException)
		24	SetCancelled(error);
		25	else
		26	SetError(error);
		27	}
		28
		29	protected void SetCancelledInternal(Exception reason) {
		30	SetCancelled(
		31	reason == null ? new OperationCanceledException() : reason is OperationCanceledException ? reason : new OperationCanceledException(null, reason)
		32	);
		33	}
		34	}
		35	}
		36

Implab/Automaton/AutomatonConst.cs created 644 +9 0

			@@ -0,0 +1,9
		1
		2	namespace Implab.Automaton {
		3	public static class AutomatonConst {
		4	public const int UNREACHABLE_STATE = -1;
		5
		6	public const int UNCLASSIFIED_INPUT = 0;
		7	}
		8	}
		9

Implab/Automaton/AutomatonTransition.cs created 644 +33 0

			@@ -0,0 +1,33
		1	using System;
		2
		3	namespace Implab.Automaton {
		4	public struct AutomatonTransition : IEquatable<AutomatonTransition> {
		5	public readonly int s1;
		6	public readonly int s2;
		7	public readonly int edge;
		8
		9	public AutomatonTransition(int s1, int s2, int edge) {
		10	this.s1 = s1;
		11	this.s2 = s2;
		12	this.edge = edge;
		13	}
		14
		15
		16	#region IEquatable implementation
		17	public bool Equals(AutomatonTransition other) {
		18	return other.s1 == s1 && other.s2 == s2 && other.edge == edge ;
		19	}
		20	#endregion
		21
		22	public override bool Equals(object obj) {
		23	if (obj is AutomatonTransition)
		24	return Equals((AutomatonTransition)obj);
		25	return base.Equals(obj);
		26	}
		27
		28	public override int GetHashCode() {
		29	return s1 + s2 + edge;
		30	}
		31	}
		32	}
		33

Implab/Automaton/DFATable.cs created 644 +348 0

			@@ -0,0 +1,348
		1	using Implab;
		2	using System;
		3	using System.Collections.Generic;
		4	using System.Linq;
		5	using System.Diagnostics;
		6	using System.IO;
		7	using System.CodeDom.Compiler;
		8	using System.CodeDom;
		9
		10	namespace Implab.Automaton {
		11	public class DFATable : IDFATableBuilder {
		12	int m_stateCount;
		13	int m_symbolCount;
		14	int m_initialState;
		15
		16	readonly HashSet<int> m_finalStates = new HashSet<int>();
		17	readonly HashSet<AutomatonTransition> m_transitions = new HashSet<AutomatonTransition>();
		18
		19
		20	#region IDFADefinition implementation
		21
		22	public bool IsFinalState(int s) {
		23	Safe.ArgumentInRange(s, 0, m_stateCount, "s");
		24
		25	return m_finalStates.Contains(s);
		26	}
		27
		28	public IEnumerable<int> FinalStates {
		29	get {
		30	return m_finalStates;
		31	}
		32	}
		33
		34	public int StateCount {
		35	get { return m_stateCount; }
		36	}
		37
		38	public int AlphabetSize {
		39	get { return m_symbolCount; }
		40	}
		41
		42	public int InitialState {
		43	get { return m_initialState; }
		44	}
		45
		46	#endregion
		47
		48	public void SetInitialState(int s) {
		49	Safe.ArgumentAssert(s >= 0, "s");
		50	m_stateCount = Math.Max(m_stateCount, s + 1);
		51	m_initialState = s;
		52	}
		53
		54	public void MarkFinalState(int state) {
		55	m_stateCount = Math.Max(m_stateCount, state + 1);
		56	m_finalStates.Add(state);
		57	}
		58
		59	public void Add(AutomatonTransition item) {
		60	Safe.ArgumentAssert(item.s1 >= 0, "item");
		61	Safe.ArgumentAssert(item.s2 >= 0, "item");
		62	Safe.ArgumentAssert(item.edge >= 0, "item");
		63
		64	m_stateCount = Math.Max(m_stateCount, Math.Max(item.s1, item.s2) + 1);
		65	m_symbolCount = Math.Max(m_symbolCount, item.edge + 1);
		66
		67	m_transitions.Add(item);
		68	}
		69
		70	public void Clear() {
		71	m_stateCount = 0;
		72	m_symbolCount = 0;
		73	m_finalStates.Clear();
		74	m_transitions.Clear();
		75	}
		76
		77	public bool Contains(AutomatonTransition item) {
		78	return m_transitions.Contains(item);
		79	}
		80
		81	public void CopyTo(AutomatonTransition[] array, int arrayIndex) {
		82	m_transitions.CopyTo(array, arrayIndex);
		83	}
		84
		85	public bool Remove(AutomatonTransition item) {
		86	return m_transitions.Remove(item);
		87	}
		88
		89	public int Count {
		90	get {
		91	return m_transitions.Count;
		92	}
		93	}
		94
		95	public bool IsReadOnly {
		96	get {
		97	return false;
		98	}
		99	}
		100
		101	public IEnumerator<AutomatonTransition> GetEnumerator() {
		102	return m_transitions.GetEnumerator();
		103	}
		104
		105	System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() {
		106	return GetEnumerator();
		107	}
		108
		109	public void AddSymbol(int symbol) {
		110	Safe.ArgumentAssert(symbol >= 0, "symbol");
		111	m_symbolCount = Math.Max(symbol + 1, m_symbolCount);
		112	}
		113
		114	public int[,] CreateTransitionTable() {
		115	var table = new int[StateCount,AlphabetSize];
		116
		117	for (int i = 0; i < StateCount; i++)
		118	for (int j = 0; j < AlphabetSize; j++)
		119	table[i, j] = AutomatonConst.UNREACHABLE_STATE;
		120
		121	foreach (var t in this)
		122	table[t.s1,t.edge] = t.s2;
		123
		124	return table;
		125	}
		126
		127	public bool[] CreateFinalStateTable() {
		128	var table = new bool[StateCount];
		129
		130	foreach (var s in FinalStates)
		131	table[s] = true;
		132
		133	return table;
		134	}
		135
		136	/// <summary>Формирует множества конечных состояний перед началом работы алгоритма минимизации.</summary>
		137	/// <remarks>
		138	/// В процессе построения минимального автомата требуется разделить множество состояний,
		139	/// на два подмножества - конечные состояния и все остальные, после чего эти подмножества
		140	/// будут резделены на более мелкие. Иногда требуется гарантировать различия конечных сосотяний,
		141	/// для этого необходимо переопределить даннцю фукнцию, для получения множеств конечных состояний.
		142	/// </remarks>
		143	/// <returns>The final states.</returns>
		144	protected virtual IEnumerable<HashSet<int>> SplitFinalStates(IEnumerable<int> states) {
		145	return new [] { new HashSet<int>(states) };
		146	}
		147
		148	protected void Optimize(
		149	IDFATableBuilder optimalDFA,
		150	IDictionary<int,int> alphabetMap,
		151	IDictionary<int,int> stateMap
		152	) {
		153	Safe.ArgumentNotNull(optimalDFA, "dfa");
		154	Safe.ArgumentNotNull(alphabetMap, "alphabetMap");
		155	Safe.ArgumentNotNull(stateMap, "stateMap");
		156
		157
		158	var setComparer = new CustomEqualityComparer<HashSet<int>>(
		159	(x, y) => x.SetEquals(y),
		160	s => s.Sum(x => x.GetHashCode())
		161	);
		162
		163	var optimalStates = new HashSet<HashSet<int>>(setComparer);
		164	var queue = new HashSet<HashSet<int>>(setComparer);
		165
		166	optimalStates.Add(new HashSet<int>(FinalStates));
		167
		168	var state = new HashSet<int>(
		169	Enumerable
		170	.Range(0, m_stateCount)
		171	.Where(i => !m_finalStates.Contains(i))
		172	);
		173
		174	optimalStates.Add(state);
		175	queue.Add(state);
		176
		177	var rmap = m_transitions
		178	.GroupBy(t => t.s2)
		179	.ToDictionary(
		180	g => g.Key, // s2
		181	g => g.ToLookup(t => t.edge, t => t.s1)//.ToDictionary(p => p.Key)
		182	);
		183
		184	while (queue.Count > 0) {
		185	var stateA = queue.First();
		186	queue.Remove(stateA);
		187
		188	for (int c = 0; c < m_symbolCount; c++) {
		189	var stateX = new HashSet<int>();
		190	foreach(var a in stateA.Where(rmap.ContainsKey))
		191	stateX.UnionWith(rmap[a][c]); // all states from wich the symbol 'c' leads to the state 'a'
		192
		193	var tmp = optimalStates.ToArray();
		194	foreach (var stateY in tmp) {
		195	var stateR1 = new HashSet<int>(stateY);
		196	var stateR2 = new HashSet<int>(stateY);
		197
		198	stateR1.IntersectWith(stateX);
		199	stateR2.ExceptWith(stateX);
		200
		201	if (stateR1.Count > 0 && stateR2.Count > 0) {
		202
		203
		204	optimalStates.Remove(stateY);
		205	optimalStates.Add(stateR1);
		206	optimalStates.Add(stateR2);
		207
		208	if (queue.Contains(stateY)) {
		209	queue.Remove(stateY);
		210	queue.Add(stateR1);
		211	queue.Add(stateR2);
		212	} else {
		213	queue.Add(stateR1.Count <= stateR2.Count ? stateR1 : stateR2);
		214	}
		215	}
		216	}
		217	}
		218	}
		219
		220	// дополнительно разбиваем конечные состояния
		221	foreach (var final in optimalStates.Where(s => s.Overlaps(m_finalStates)).ToArray()) {
		222	optimalStates.Remove(final);
		223	foreach (var split in SplitFinalStates(final))
		224	optimalStates.Add(split);
		225	}
		226
		227
		228	// карта получения оптимального состояния по соотвествующему ему простому состоянию
		229	var nextState = 0;
		230	foreach (var item in optimalStates) {
		231	var id = nextState++;
		232	foreach (var s in item)
		233	stateMap[s] = id;
		234	}
		235
		236	// получаем минимальный алфавит
		237	// входные символы не различимы, если Move(s,a1) == Move(s,a2), для любого s
		238	// для этого используем алгоритм кластеризации, сначала
		239	// считаем, что все символы не различимы
		240
		241	var minClasses = new HashSet<HashSet<int>>(setComparer);
		242	var alphaQueue = new Queue<HashSet<int>>();
		243	alphaQueue.Enqueue(new HashSet<int>(Enumerable.Range(0,AlphabetSize)));
		244
		245	// для всех состояний, будем проверять каждый класс на различимость,
		246	// т.е. символы различимы, если они приводят к разным состояниям
		247	for (int s = 0 ; s < optimalStates.Count; s++) {
		248	var newQueue = new Queue<HashSet<int>>();
		249
		250	foreach (var A in alphaQueue) {
		251	// классы из одного символа делить бесполезно, переводим их сразу в
		252	// результирующий алфавит
		253	if (A.Count == 1) {
		254	minClasses.Add(A);
		255	continue;
		256	}
		257
		258	// различаем классы символов, которые переводят в различные оптимальные состояния
		259	// optimalState -> alphaClass
		260	var classes = new Dictionary<int, HashSet<int>>();
		261
		262	foreach (var term in A) {
		263	// ищем все переходы класса по символу term
		264	var s2 = m_transitions.Where(t => stateMap[t.s1] == s && t.edge == term).Select(t => stateMap[t.s2]).DefaultIfEmpty(-1).First();
		265
		266	HashSet<int> a2;
		267	if (!classes.TryGetValue(s2, out a2)) {
		268	a2 = new HashSet<int>();
		269	newQueue.Enqueue(a2);
		270	classes[s2] = a2;
		271	}
		272	a2.Add(term);
		273	}
		274	}
		275
		276	if (newQueue.Count == 0)
		277	break;
		278	alphaQueue = newQueue;
		279	}
		280
		281	// после окончания работы алгоритма в очереди останутся минимальные различимые классы
		282	// входных символов
		283	foreach (var A in alphaQueue)
		284	minClasses.Add(A);
		285
		286	// построение отображения алфавитов входных символов.
		287	// поскольку символ DFAConst.UNCLASSIFIED_INPUT может иметь
		288	// специальное значение, тогда сохраним минимальный класс,
		289	// содержащий этот символ на томже месте.
		290
		291	var nextCls = 0;
		292	foreach (var item in minClasses) {
		293	if (nextCls == AutomatonConst.UNCLASSIFIED_INPUT)
		294	nextCls++;
		295
		296	// сохраняем DFAConst.UNCLASSIFIED_INPUT
		297	var cls = item.Contains(AutomatonConst.UNCLASSIFIED_INPUT) ? AutomatonConst.UNCLASSIFIED_INPUT : nextCls++;
		298	optimalDFA.AddSymbol(cls);
		299
		300	foreach (var a in item)
		301	alphabetMap[a] = cls;
		302	}
		303
		304	// построение автомата
		305	optimalDFA.SetInitialState(stateMap[m_initialState]);
		306
		307	foreach (var sf in m_finalStates.Select(s => stateMap[s]).Distinct())
		308	optimalDFA.MarkFinalState(sf);
		309
		310	foreach (var t in m_transitions.Select(t => new AutomatonTransition(stateMap[t.s1],stateMap[t.s2],alphabetMap[t.edge])).Distinct())
		311	optimalDFA.Add(t);
		312	}
		313
		314	protected string PrintDFA<TInput, TState>(IAlphabet<TInput> inputAlphabet, IAlphabet<TState> stateAlphabet) {
		315	Safe.ArgumentNotNull(inputAlphabet, "inputAlphabet");
		316	Safe.ArgumentNotNull(stateAlphabet, "stateAlphabet");
		317
		318	var data = new List<string>();
		319
		320	data.Add("digraph dfa {");
		321
		322	foreach (var final in m_finalStates)
		323	data.Add(String.Format("{0} [shape=box];",String.Join("", stateAlphabet.GetSymbols(final))));
		324
		325	foreach (var t in m_transitions)
		326	data.Add(String.Format(
		327	"{0} -> {2} [label={1}];",
		328	String.Join("", stateAlphabet.GetSymbols(t.s1)),
		329	ToLiteral(ToLiteral(String.Join("", t.edge == AutomatonConst.UNCLASSIFIED_INPUT ? new [] { "@" } : inputAlphabet.GetSymbols(t.edge).Select(x => x.ToString())))),
		330	String.Join("", stateAlphabet.GetSymbols(t.s2))
		331	));
		332	data.Add("}");
		333	return String.Join("\n", data);
		334	}
		335
		336	static string ToLiteral(string input)
		337	{
		338	using (var writer = new StringWriter())
		339	{
		340	using (var provider = CodeDomProvider.CreateProvider("CSharp"))
		341	{
		342	provider.GenerateCodeFromExpression(new CodePrimitiveExpression(input), writer, null);
		343	return writer.ToString();
		344	}
		345	}
		346	}
		347	}
		348	}

Implab/Automaton/EnumAlphabet.cs created 644 +66 0

			@@ -0,0 +1,66
		1	using System;
		2	using System.Collections.Generic;
		3	using System.Diagnostics;
		4	using System.Globalization;
		5	using System.Linq;
		6	using System.Diagnostics.CodeAnalysis;
		7
		8	namespace Implab.Automaton {
		9	/// <summary>
		10	/// Алфавит символами которого являются элементы перечислений.
		11	/// </summary>
		12	/// <typeparam name="T">Тип перечислений</typeparam>
		13	public class EnumAlphabet<T> : IndexedAlphabetBase<T> where T : struct, IConvertible {
		14	[SuppressMessage("Microsoft.Design", "CA1000:DoNotDeclareStaticMembersOnGenericTypes")]
		15	static readonly Lazy<T[]> _symbols = new Lazy<T[]>(GetSymbols);
		16
		17	[SuppressMessage("Microsoft.Design", "CA1000:DoNotDeclareStaticMembersOnGenericTypes")]
		18	static readonly Lazy<EnumAlphabet<T>> _fullAlphabet = new Lazy<EnumAlphabet<T>>(CreateEnumAlphabet);
		19
		20	static EnumAlphabet<T> CreateEnumAlphabet() {
		21	var symbols = _symbols.Value;
		22
		23	if (
		24	symbols[symbols.Length - 1].ToInt32(CultureInfo.InvariantCulture) >= symbols.Length
		25	\|\| symbols[0].ToInt32(CultureInfo.InvariantCulture) != 0
		26	)
		27	throw new InvalidOperationException("The specified enumeration must be zero-based and continuously numbered");
		28
		29	return new EnumAlphabet<T>(symbols.Select(x => x.ToInt32(CultureInfo.InvariantCulture)).ToArray());
		30	}
		31
		32	static T[] GetSymbols() {
		33	if (!typeof(T).IsEnum)
		34	throw new InvalidOperationException("Invalid generic parameter, enumeration is required");
		35
		36	if (Enum.GetUnderlyingType(typeof(T)) != typeof(Int32))
		37	throw new InvalidOperationException("Only enums based on Int32 are supported");
		38
		39	return ((T[])Enum.GetValues(typeof(T)))
		40	.OrderBy(x => x.ToInt32(CultureInfo.InvariantCulture))
		41	.ToArray();
		42	}
		43
		44	public static EnumAlphabet<T> FullAlphabet {
		45	get {
		46	return _fullAlphabet.Value;
		47	}
		48	}
		49
		50
		51	public EnumAlphabet()
		52	: base(_symbols.Value.Length) {
		53	}
		54
		55	public EnumAlphabet(int[] map)
		56	: base(map) {
		57	Debug.Assert(map.Length == _symbols.Value.Length);
		58	}
		59
		60
		61	public override int GetSymbolIndex(T symbol) {
		62	return symbol.ToInt32(CultureInfo.InvariantCulture);
		63	}
		64
		65	}
		66	}

Implab/Automaton/IAlphabet.cs created 644 +34 0

			@@ -0,0 +1,34
		1	using System;
		2	using System.Collections.Generic;
		3	using System.Linq;
		4	using System.Text;
		5	using System.Threading.Tasks;
		6
		7	namespace Implab.Automaton {
		8	/// <summary>
		9	/// Алфавит. Множество символов, которые разбиты на классы, при этом классы имеют непрерывную нумерацию,
		10	/// что позволяет использовать их в качестве индексов массивов.
		11	/// </summary>
		12	/// <remarks>
		13	/// <para>Алфавит является сюрьективным отображением множества символов в множество индексов, это позволяет сократить размер таблицы переходов автомата
		14	/// для входных символов, которые для него не различимы.</para>
		15	/// </remarks>
		16	/// <typeparam name="TSymbol">Тип символов.</typeparam>
		17	public interface IAlphabet<TSymbol> {
		18	/// <summary>
		19	/// Количество классов символов в алфавите.
		20	/// </summary>
		21	int Count { get; }
		22
		23	/// <summary>
		24	/// Преобразует входной символ в индекс символа из алфавита.
		25	/// </summary>
		26	/// <param name="symobl">Исходный символ</param>
		27	/// <returns>Индекс в алфавите</returns>
		28	int Translate(TSymbol symobl);
		29
		30	bool Contains(TSymbol symbol);
		31
		32	IEnumerable<TSymbol> GetSymbols(int cls);
		33	}
		34	}

Implab/Automaton/IAlphabetBuilder.cs created 644 +26 0

			@@ -0,0 +1,26
		1
		2	using System.Collections.Generic;
		3
		4	namespace Implab.Automaton {
		5	public interface IAlphabetBuilder<TSymbol> : IAlphabet<TSymbol> {
		6	/// <summary>
		7	/// Добавляет новый символ в алфавит, если символ уже был добавлен, то
		8	/// возвращается ранее сопоставленный с символом класс.
		9	/// </summary>
		10	/// <param name="symbol">Символ для добавления.</param>
		11	/// <returns>Индекс класса, который попоставлен с символом.</returns>
		12	int DefineSymbol(TSymbol symbol);
		13
		14	int DefineSymbol(TSymbol symbol, int cls);
		15	/// <summary>
		16	/// Доабвляем класс символов. Множеству указанных исходных символов
		17	/// будет сопоставлен символ в алфавите.
		18	/// </summary>
		19	/// <param name="symbols">Множестов исходных символов</param>
		20	/// <returns>Идентификатор символа алфавита.</returns>
		21	int DefineClass(IEnumerable<TSymbol> symbols);
		22
		23	int DefineClass(IEnumerable<TSymbol> symbols, int cls);
		24	}
		25	}
		26

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

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

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

			@@ -0,0 +1,26
		1	using System;
		2	using System.Collections.Generic;
		3
		4	namespace Implab.Automaton {
		5	public interface IDFATableBuilder : IDFATable, ICollection<AutomatonTransition> {
		6	/// <summary>
		7	/// Marks the state as final.
		8	/// </summary>
		9	/// <param name="state">State.</param>
		10	void MarkFinalState(int state);
		11
		12	void SetInitialState(int s);
		13
		14	/// <summary>
		15	/// Increases if needed the input alphabet size to hold the specified symbol.
		16	/// </summary>
		17	/// <remarks>
		18	/// <code>
		19	/// AlphabetSize = Math.Max(AlphabetSize, symbol + 1)
		20	/// </code>
		21	/// </remarks>
		22	/// <param name="symbol">Symbol.</param>
		23	void AddSymbol(int symbol);
		24	}
		25	}
		26

Implab/Automaton/IndexedAlphabetBase.cs created 644 +50 0

			@@ -0,0 +1,50
		1	using Implab;
		2	using System;
		3	using System.Collections.Generic;
		4	using System.Diagnostics;
		5	using System.Linq;
		6
		7	namespace Implab.Automaton {
		8	/// <summary>
		9	/// Indexed alphabet is the finite set of symbols where each symbol has a zero-based unique index.
		10	/// </summary>
		11	/// <remarks>
		12	/// Indexed alphabets are usefull in bulting efficient translations from source alphabet
		13	/// to the input alphabet of the automaton. It's assumed that the index to the symbol match
		14	/// is well known and documented.
		15	/// </remarks>
		16	public abstract class IndexedAlphabetBase<T> : MapAlphabet<T> {
		17
		18	protected IndexedAlphabetBase() :base(true, null) {
		19	}
		20
		21	public abstract int GetSymbolIndex(T symbol);
		22
		23	/// <summary>
		24	/// Gets the translation map from the index of the symbol to it's class this is usefull for the optimized input symbols transtaion.
		25	/// </summary>
		26	/// <remarks>
		27	/// The map is continous and start from the symbol with zero code. The last symbol
		28	/// in the map is the last classified symbol in the alphabet, i.e. the map can be
		29	/// shorter then the whole alphabet.
		30	/// </remarks>
		31	/// <returns>The translation map.</returns>
		32	public int[] GetTranslationMap() {
		33	var map = new Dictionary<int, int>();
		34
		35	int max = 0;
		36	foreach (var p in Mappings) {
		37	var index = GetSymbolIndex(p.Key);
		38	max = Math.Max(max, index);
		39	map[index] = p.Value;
		40	}
		41
		42	var result = new int[max + 1];
		43
		44	for (int i = 0; i < result.Length; i++)
		45	map.TryGetValue(i, out result[i]);
		46
		47	return result;
		48	}
		49	}
		50	}

Implab/Automaton/MapAlphabet.cs created 644 +84 0

			@@ -0,0 +1,84
		1	using System;
		2	using System.Collections.Generic;
		3	using System.Linq;
		4
		5	namespace Implab.Automaton {
		6	public class MapAlphabet<T> : IAlphabetBuilder<T> {
		7	readonly Dictionary<T,int> m_map;
		8	int m_nextCls;
		9	readonly bool m_supportUnclassified;
		10
		11	public MapAlphabet(bool supportUnclassified, IEqualityComparer<T> comparer) {
		12	m_map = comparer != null ? new Dictionary<T, int>(comparer) : new Dictionary<T,int>();
		13	m_supportUnclassified = supportUnclassified;
		14	m_nextCls = supportUnclassified ? 1 : 0;
		15	}
		16
		17	#region IAlphabetBuilder implementation
		18
		19	public int DefineSymbol(T symbol) {
		20	int cls;
		21	return m_map.TryGetValue(symbol, out cls) ? cls : DefineSymbol(symbol, m_nextCls);
		22	}
		23
		24	public int DefineSymbol(T symbol, int cls) {
		25	Safe.ArgumentAssert(cls >= 0, "cls");
		26
		27	m_nextCls = Math.Max(cls + 1, m_nextCls);
		28	m_map.Add(symbol, cls);
		29	return cls;
		30	}
		31
		32	public int DefineClass(IEnumerable<T> symbols) {
		33	return DefineClass(symbols, m_nextCls);
		34	}
		35
		36	public int DefineClass(IEnumerable<T> symbols, int cls) {
		37	Safe.ArgumentAssert(cls >= 0, "cls");
		38	Safe.ArgumentNotNull(symbols, "symbols");
		39
		40	m_nextCls = Math.Max(cls + 1, m_nextCls);
		41
		42	foreach (var symbol in symbols)
		43	m_map[symbol] = cls;
		44	return cls;
		45	}
		46
		47	#endregion
		48
		49	#region IAlphabet implementation
		50
		51	public int Translate(T symbol) {
		52	int cls;
		53	if (m_map.TryGetValue(symbol, out cls))
		54	return cls;
		55	if (!m_supportUnclassified)
		56	throw new ArgumentOutOfRangeException("symbol", "The specified symbol isn't in the alphabet");
		57	return AutomatonConst.UNCLASSIFIED_INPUT;
		58	}
		59
		60	public int Count {
		61	get {
		62	return m_nextCls;
		63	}
		64	}
		65
		66	public bool Contains(T symbol) {
		67	return m_supportUnclassified \|\| m_map.ContainsKey(symbol);
		68	}
		69
		70
		71	public IEnumerable<T> GetSymbols(int cls) {
		72	Safe.ArgumentAssert(!m_supportUnclassified \|\| cls > 0, "cls");
		73	return m_map.Where(p => p.Value == cls).Select(p => p.Key);
		74	}
		75	#endregion
		76
		77	public IEnumerable<KeyValuePair<T,int>> Mappings {
		78	get {
		79	return m_map;
		80	}
		81	}
		82	}
		83	}
		84

Implab/Automaton/ParserException.cs created 644 +17 0

			@@ -0,0 +1,17
		1	using System;
		2	using System.Collections.Generic;
		3	using System.Linq;
		4	using System.Text;
		5
		6	namespace Implab.Automaton {
		7	[Serializable]
		8	public class ParserException : Exception {
		9	public ParserException() { }
		10	public ParserException(string message) : base(message) { }
		11	public ParserException(string message, Exception inner) : base(message, inner) { }
		12	protected ParserException(
		13	System.Runtime.Serialization.SerializationInfo info,
		14	System.Runtime.Serialization.StreamingContext context)
		15	: base(info, context) { }
		16	}
		17	}

Implab/Automaton/RegularExpressions/AltToken.cs created 644 +17 0

			@@ -0,0 +1,17
		1	using System;
		2
		3	namespace Implab.Automaton.RegularExpressions {
		4	public class AltToken: BinaryToken {
		5	public AltToken(Token left, Token right)
		6	: base(left, right) {
		7	}
		8
		9	public override void Accept(IVisitor visitor) {
		10	Safe.ArgumentNotNull(visitor, "visitor");
		11	visitor.Visit(this);
		12	}
		13	public override string ToString() {
		14	return String.Format(Right is BinaryToken ? "{0}\|({1})" : "{0}\|{1}", Left, Right);
		15	}
		16	}
		17	}

Implab/Automaton/RegularExpressions/BinaryToken.cs created 644 +21 0

			@@ -0,0 +1,21
		1	using Implab;
		2
		3	namespace Implab.Automaton.RegularExpressions {
		4	public abstract class BinaryToken: Token {
		5	readonly Token m_left;
		6	readonly Token m_right;
		7
		8	public Token Left {
		9	get { return m_left; }
		10	}
		11
		12	public Token Right {
		13	get { return m_right; }
		14	}
		15
		16	protected BinaryToken(Token left, Token right) {
		17	Safe.ArgumentNotNull(m_left = left, "left");
		18	Safe.ArgumentNotNull(m_right = right, "right");
		19	}
		20	}
		21	}

Implab/Automaton/RegularExpressions/CatToken.cs created 644 +22 0

			@@ -0,0 +1,22
		1	using System;
		2
		3	namespace Implab.Automaton.RegularExpressions {
		4	public class CatToken : BinaryToken {
		5	public CatToken(Token left, Token right)
		6	: base(left, right) {
		7	}
		8
		9	public override void Accept(IVisitor visitor) {
		10	Safe.ArgumentNotNull(visitor, "visitor");
		11	visitor.Visit(this);
		12	}
		13
		14	public override string ToString() {
		15	return String.Format("{0}{1}", FormatToken(Left), FormatToken(Right));
		16	}
		17
		18	static string FormatToken(Token token) {
		19	return String.Format(token is AltToken ? "({0})" : "{0}", token);
		20	}
		21	}
		22	}

Implab/Automaton/RegularExpressions/EmptyToken.cs created 644 +13 0

			@@ -0,0 +1,13
		1	using Implab;
		2
		3	namespace Implab.Automaton.RegularExpressions {
		4	public class EmptyToken: Token {
		5	public override void Accept(IVisitor visitor) {
		6	Safe.ArgumentNotNull(visitor, "visitor");
		7	visitor.Visit(this);
		8	}
		9	public override string ToString() {
		10	return "$";
		11	}
		12	}
		13	}

Implab/Automaton/RegularExpressions/EndToken.cs created 644 +18 0

			@@ -0,0 +1,18
		1	using Implab;
		2
		3	namespace Implab.Automaton.RegularExpressions {
		4	/// <summary>
		5	/// Конечный символ расширенного регулярного выражения, при построении ДКА
		6	/// используется для определения конечных состояний.
		7	/// </summary>
		8	public class EndToken: Token {
		9
		10	public override void Accept(IVisitor visitor) {
		11	Safe.ArgumentNotNull(visitor, "visitor");
		12	visitor.Visit(this);
		13	}
		14	public override string ToString() {
		15	return "#";
		16	}
		17	}
		18	}

Implab/Automaton/RegularExpressions/EndTokenT.cs created 644 +23 0

			@@ -0,0 +1,23
		1	namespace Implab.Automaton.RegularExpressions {
		2	/// <summary>
		3	/// Конечный символ расширенного регулярного выражения, при построении ДКА
		4	/// используется для определения конечных состояний.
		5	/// </summary>
		6	public class EndToken<TTag>: EndToken {
		7
		8	readonly TTag m_tag;
		9
		10	public EndToken(TTag tag) {
		11	m_tag = tag;
		12	}
		13
		14	public EndToken()
		15	: this(default(TTag)) {
		16	}
		17
		18	public TTag Tag {
		19	get { return m_tag; }
		20	}
		21
		22	}
		23	}

Implab/Automaton/RegularExpressions/ITaggedDFABuilder.cs created 644 +7 0

			@@ -0,0 +1,7
		1
		2	namespace Implab.Automaton.RegularExpressions {
		3	public interface ITaggedDFABuilder<TTag> : IDFATableBuilder {
		4	void SetStateTag(int s, TTag[] tags);
		5	}
		6	}
		7

Implab/Automaton/RegularExpressions/IVisitor.cs created 644 +13 0

			@@ -0,0 +1,13
		1	namespace Implab.Automaton.RegularExpressions {
		2	/// <summary>
		3	/// Интерфейс обходчика синтаксического дерева регулярного выражения
		4	/// </summary>
		5	public interface IVisitor {
		6	void Visit(AltToken token);
		7	void Visit(StarToken token);
		8	void Visit(CatToken token);
		9	void Visit(EmptyToken token);
		10	void Visit(EndToken token);
		11	void Visit(SymbolToken token);
		12	}
		13	}

Implab/Automaton/RegularExpressions/RegularDFA.cs created 644 +91 0

			@@ -0,0 +1,91
		1	using System.Collections.Generic;
		2	using System.Linq;
		3
		4	namespace Implab.Automaton.RegularExpressions {
		5	public class RegularDFA<TInput, TTag> : DFATable, ITaggedDFABuilder<TTag> {
		6
		7	readonly Dictionary<int,TTag[]> m_tags = new Dictionary<int, TTag[]>();
		8	readonly IAlphabet<TInput> m_alphabet;
		9
		10	public RegularDFA(IAlphabet<TInput> alphabet) {
		11	Safe.ArgumentNotNull(alphabet, "aplhabet");
		12
		13	m_alphabet = alphabet;
		14	}
		15
		16
		17	public IAlphabet<TInput> InputAlphabet {
		18	get {
		19	return m_alphabet;
		20	}
		21	}
		22
		23	public void MarkFinalState(int s, TTag[] tags) {
		24	MarkFinalState(s);
		25	SetStateTag(s, tags);
		26	}
		27
		28	public void SetStateTag(int s, TTag[] tags) {
		29	Safe.ArgumentNotNull(tags, "tags");
		30	m_tags[s] = tags;
		31	}
		32
		33	public TTag[] GetStateTag(int s) {
		34	TTag[] tags;
		35	return m_tags.TryGetValue(s, out tags) ? tags : new TTag[0];
		36	}
		37
		38	public TTag[][] CreateTagTable() {
		39	var table = new TTag[StateCount][];
		40
		41	foreach (var pair in m_tags)
		42	table[pair.Key] = pair.Value;
		43
		44	return table;
		45	}
		46
		47	/// <summary>
		48	/// Optimize the specified alphabet.
		49	/// </summary>
		50	/// <param name="alphabet">Пустой алфавит, который будет зполнен в процессе оптимизации.</param>
		51	public RegularDFA<TInput,TTag> Optimize(IAlphabetBuilder<TInput> alphabet) {
		52	Safe.ArgumentNotNull(alphabet, "alphabet");
		53
		54	var dfa = new RegularDFA<TInput, TTag>(alphabet);
		55
		56	var alphaMap = new Dictionary<int,int>();
		57	var stateMap = new Dictionary<int,int>();
		58
		59	Optimize(dfa, alphaMap, stateMap);
		60
		61	// mark tags in the new DFA
		62	foreach (var g in m_tags.Where(x => x.Key < StateCount).GroupBy(x => stateMap[x.Key], x => x.Value ))
		63	dfa.SetStateTag(g.Key, g.SelectMany(x => x).ToArray());
		64
		65	// make the alphabet for the new DFA
		66	// skip all unclassified symbols
		67	foreach (var pair in alphaMap.Where(x => x.Value != 0))
		68	alphabet.DefineClass(m_alphabet.GetSymbols(pair.Key), pair.Value);
		69	return dfa;
		70	}
		71
		72	protected override IEnumerable<HashSet<int>> SplitFinalStates(IEnumerable<int> states) {
		73	var arrayComparer = new CustomEqualityComparer<TTag[]>(
		74	(x,y) => x.Length == y.Length && x.All(it => y.Contains(it)),
		75	x => x.Sum(it => x.GetHashCode())
		76	);
		77	return states.GroupBy(x => m_tags[x] ?? new TTag[0], arrayComparer).Select(g => new HashSet<int>(g));
		78	}
		79
		80	public override string ToString() {
		81	var states = new MapAlphabet<string>(false, null);
		82
		83	for (int i = 0; i < StateCount; i++)
		84	states.DefineSymbol(string.Format("s{0}", i), i);
		85
		86	return string.Format("//[RegularDFA {1} x {2}]\n{0}", PrintDFA(InputAlphabet, states),StateCount, AlphabetSize);
		87	}
		88
		89	}
		90	}
		91

Implab/Automaton/RegularExpressions/RegularExpressionVisitor.cs created 644 +212 0

			@@ -0,0 +1,212
		1	using Implab;
		2	using System;
		3	using System.Collections.Generic;
		4	using System.Diagnostics;
		5	using System.Linq;
		6
		7	namespace Implab.Automaton.RegularExpressions {
		8	/// <summary>
		9	/// Используется для построения ДКА по регулярному выражению, сначала обходит
		10	/// регулярное выражение и вычисляет followpos, затем используется метод
		11	/// <see cref="BuildDFA(IDFADefinition)"/> для построения автомата.
		12	/// </summary>
		13	public class RegularExpressionVisitor : IVisitor {
		14	int m_idx;
		15	Token m_root;
		16	HashSet<int> m_firstpos;
		17	HashSet<int> m_lastpos;
		18
		19	readonly Dictionary<int, HashSet<int>> m_followpos = new Dictionary<int, HashSet<int>>();
		20	readonly Dictionary<int, int> m_indexes = new Dictionary<int, int>();
		21	readonly HashSet<int> m_ends = new HashSet<int>();
		22
		23	readonly IDFATableBuilder m_builder;
		24	readonly IAlphabetBuilder<HashSet<int>> m_states = new MapAlphabet<HashSet<int>>(
		25	false,
		26	new CustomEqualityComparer<HashSet<int>>(
		27	(x, y) => x.SetEquals(y),
		28	x => x.Sum(n => n.GetHashCode())
		29	)
		30	);
		31
		32	public RegularExpressionVisitor(IDFATableBuilder builder) {
		33	Safe.ArgumentNotNull(builder, "builder");
		34
		35	m_builder = builder;
		36	}
		37
		38	HashSet<int> Followpos(int pos) {
		39	HashSet<int> set;
		40	return m_followpos.TryGetValue(pos, out set) ? set : m_followpos[pos] = new HashSet<int>();
		41	}
		42
		43	bool Nullable(object n) {
		44	if (n is EmptyToken \|\| n is StarToken)
		45	return true;
		46	var altToken = n as AltToken;
		47	if (altToken != null)
		48	return Nullable(altToken.Left) \|\| Nullable(altToken.Right);
		49	var catToken = n as CatToken;
		50	if (catToken != null)
		51	return Nullable(catToken.Left) && Nullable(catToken.Right);
		52	return false;
		53	}
		54
		55	protected int Index {
		56	get { return m_idx; }
		57	}
		58
		59	public void Visit(AltToken token) {
		60	if (m_root == null)
		61	m_root = token;
		62	var firtspos = new HashSet<int>();
		63	var lastpos = new HashSet<int>();
		64
		65	token.Left.Accept(this);
		66	firtspos.UnionWith(m_firstpos);
		67	lastpos.UnionWith(m_lastpos);
		68
		69	token.Right.Accept(this);
		70	firtspos.UnionWith(m_firstpos);
		71	lastpos.UnionWith(m_lastpos);
		72
		73	m_firstpos = firtspos;
		74	m_lastpos = lastpos;
		75	}
		76
		77	public void Visit(StarToken token) {
		78	if (m_root == null)
		79	m_root = token;
		80	token.Token.Accept(this);
		81
		82	foreach (var i in m_lastpos)
		83	Followpos(i).UnionWith(m_firstpos);
		84	}
		85
		86	public void Visit(CatToken token) {
		87	if (m_root == null)
		88	m_root = token;
		89
		90	var firtspos = new HashSet<int>();
		91	var lastpos = new HashSet<int>();
		92	token.Left.Accept(this);
		93	firtspos.UnionWith(m_firstpos);
		94	var leftLastpos = m_lastpos;
		95
		96	token.Right.Accept(this);
		97	lastpos.UnionWith(m_lastpos);
		98	var rightFirstpos = m_firstpos;
		99
		100	if (Nullable(token.Left))
		101	firtspos.UnionWith(rightFirstpos);
		102
		103	if (Nullable(token.Right))
		104	lastpos.UnionWith(leftLastpos);
		105
		106	m_firstpos = firtspos;
		107	m_lastpos = lastpos;
		108
		109	foreach (var i in leftLastpos)
		110	Followpos(i).UnionWith(rightFirstpos);
		111
		112	}
		113
		114	public void Visit(EmptyToken token) {
		115	if (m_root == null)
		116	m_root = token;
		117	}
		118
		119	public void Visit(SymbolToken token) {
		120	if (m_root == null)
		121	m_root = token;
		122	m_idx++;
		123	m_indexes[m_idx] = token.Value;
		124	m_firstpos = new HashSet<int>(new[] { m_idx });
		125	m_lastpos = new HashSet<int>(new[] { m_idx });
		126	}
		127
		128	public virtual void Visit(EndToken token) {
		129	if (m_root == null)
		130	m_root = token;
		131	m_idx++;
		132	m_indexes[m_idx] = AutomatonConst.UNCLASSIFIED_INPUT;
		133	m_firstpos = new HashSet<int>(new[] { m_idx });
		134	m_lastpos = new HashSet<int>(new[] { m_idx });
		135	Followpos(m_idx);
		136	m_ends.Add(m_idx);
		137	}
		138
		139	public void BuildDFA() {
		140	AddState(m_firstpos);
		141	SetInitialState(m_firstpos);
		142
		143	if(IsFinal(m_firstpos))
		144	MarkFinalState(m_firstpos);
		145
		146	var inputMax = m_indexes.Values.Max();
		147	var queue = new Queue<HashSet<int>>();
		148
		149	queue.Enqueue(m_firstpos);
		150
		151	while (queue.Count > 0) {
		152	var s1 = queue.Dequeue();
		153
		154	for (int a = 0; a <= inputMax; a++) {
		155	var s2 = new HashSet<int>();
		156	foreach (var p in s1) {
		157	if (m_indexes[p] == a) {
		158	s2.UnionWith(Followpos(p));
		159	}
		160	}
		161	if (s2.Count > 0) {
		162	if (!HasState(s2)) {
		163	AddState(s2);
		164	if (IsFinal(s2))
		165	MarkFinalState(s2);
		166
		167	queue.Enqueue(s2);
		168	}
		169
		170	DefineTransition(s1, s2, a);
		171	}
		172
		173	}
		174	}
		175	}
		176
		177	protected bool HasState(HashSet<int> state) {
		178	return m_states.Contains(state);
		179	}
		180
		181	protected void AddState(HashSet<int> state) {
		182	Debug.Assert(!HasState(state));
		183
		184	m_states.DefineSymbol(state);
		185	}
		186
		187	protected int Translate(HashSet<int> state) {
		188	Debug.Assert(HasState(state));
		189
		190	return m_states.Translate(state);
		191	}
		192
		193	protected virtual void SetInitialState(HashSet<int> state) {
		194	m_builder.SetInitialState(Translate(state));
		195	}
		196
		197	protected virtual void MarkFinalState(HashSet<int> state) {
		198	m_builder.MarkFinalState(Translate(state));
		199	}
		200
		201	protected virtual void DefineTransition(HashSet<int> s1, HashSet<int> s2, int ch) {
		202
		203	m_builder.Add(new AutomatonTransition(Translate(s1), Translate(s2), ch));
		204	}
		205
		206	bool IsFinal(IEnumerable<int> state) {
		207	Debug.Assert(state != null);
		208	return state.Any(m_ends.Contains);
		209	}
		210
		211	}
		212	}

Implab/Automaton/RegularExpressions/RegularExpressionVisitorT.cs created 644 +37 0

			@@ -0,0 +1,37
		1	using Implab;
		2	using System;
		3	using System.Collections.Generic;
		4	using System.Diagnostics;
		5	using System.Linq;
		6
		7	namespace Implab.Automaton.RegularExpressions {
		8	/// <summary>
		9	/// </summary>
		10	public class RegularExpressionVisitor<TTag> : RegularExpressionVisitor {
		11	readonly Dictionary<int, TTag> m_tags = new Dictionary<int, TTag>();
		12
		13	readonly ITaggedDFABuilder<TTag> m_builder;
		14
		15	public RegularExpressionVisitor(ITaggedDFABuilder<TTag> builder) : base(builder) {
		16	m_builder = builder;
		17	}
		18
		19	public override void Visit(EndToken token) {
		20	base.Visit(token);
		21	var tagged = token as EndToken<TTag>;
		22	if (tagged != null)
		23	m_tags.Add(Index, tagged.Tag);
		24	}
		25
		26	protected override void MarkFinalState(HashSet<int> state) {
		27	base.MarkFinalState(state);
		28	m_builder.SetStateTag(Translate(state), GetStateTags(state));
		29	}
		30
		31	TTag[] GetStateTags(IEnumerable<int> state) {
		32	Debug.Assert(state != null);
		33	return state.Where(m_tags.ContainsKey).Select(pos => m_tags[pos]).ToArray();
		34	}
		35
		36	}
		37	}

Implab/Automaton/RegularExpressions/StarToken.cs created 644 +31 0

			@@ -0,0 +1,31
		1	using Implab;
		2	using System;
		3
		4
		5	namespace Implab.Automaton.RegularExpressions {
		6	/// <summary>
		7	/// Замыкание выражения с 0 и более повторов.
		8	/// </summary>
		9	public class StarToken: Token {
		10
		11	Token m_token;
		12
		13	public Token Token {
		14	get { return m_token; }
		15	}
		16
		17	public StarToken(Token token) {
		18	Safe.ArgumentNotNull(token, "token");
		19	m_token = token;
		20	}
		21
		22	public override void Accept(IVisitor visitor) {
		23	Safe.ArgumentNotNull(visitor, "visitor");
		24	visitor.Visit(this);
		25	}
		26
		27	public override string ToString() {
		28	return String.Format("({0})*", Token);
		29	}
		30	}
		31	}

Implab/Automaton/RegularExpressions/SymbolToken.cs created 644 +27 0

			@@ -0,0 +1,27
		1	using Implab;
		2
		3	namespace Implab.Automaton.RegularExpressions {
		4	/// <summary>
		5	/// Выражение, соответсвующее одному символу.
		6	/// </summary>
		7	public class SymbolToken: Token {
		8	int m_value;
		9
		10	public int Value {
		11	get { return m_value; }
		12	}
		13
		14	public SymbolToken(int value) {
		15	m_value = value;
		16	}
		17	public override void Accept(IVisitor visitor) {
		18	Safe.ArgumentNotNull(visitor, "visitor");
		19
		20	visitor.Visit(this);
		21	}
		22
		23	public override string ToString() {
		24	return Value.ToString();
		25	}
		26	}
		27	}

Implab/Automaton/RegularExpressions/Token.cs created 644 +63 0

			@@ -0,0 +1,63
		1	using Implab;
		2	using System;
		3	using System.Linq;
		4
		5	namespace Implab.Automaton.RegularExpressions {
		6	public abstract class Token {
		7	public abstract void Accept(IVisitor visitor);
		8
		9	public Token End() {
		10	return Cat(new EndToken());
		11	}
		12
		13	public Token Tag<TTag>(TTag tag) {
		14	return Cat(new EndToken<TTag>(tag));
		15	}
		16
		17	public Token Cat(Token right) {
		18	return new CatToken(this, right);
		19	}
		20
		21	public Token Or(Token right) {
		22	return new AltToken(this, right);
		23	}
		24
		25	public Token Optional() {
		26	return Or(new EmptyToken());
		27	}
		28
		29	public Token EClosure() {
		30	return new StarToken(this);
		31	}
		32
		33	public Token Closure() {
		34	return Cat(new StarToken(this));
		35	}
		36
		37	public Token Repeat(int count) {
		38	Token token = null;
		39
		40	for (int i = 0; i < count; i++)
		41	token = token != null ? token.Cat(this) : this;
		42	return token ?? new EmptyToken();
		43	}
		44
		45	public Token Repeat(int min, int max) {
		46	if (min > max \|\| min < 1)
		47	throw new ArgumentOutOfRangeException();
		48	var token = Repeat(min);
		49
		50	for (int i = min; i < max; i++)
		51	token = token.Cat( Optional() );
		52	return token;
		53	}
		54
		55	public static Token New(params int[] set) {
		56	Safe.ArgumentNotNull(set, "set");
		57	Token token = null;
		58	foreach(var c in set.Distinct())
		59	token = token == null ? new SymbolToken(c) : token.Or(new SymbolToken(c));
		60	return token;
		61	}
		62	}
		63	}

Implab/Components/LazyAndWeak.cs created 644 +64 0

			@@ -0,0 +1,64
		1	using System;
		2	using System.Threading;
		3
		4	namespace Implab.Components {
		5	/// <summary>
		6	/// Creates an instace on-demand and allows it to be garbage collected.
		7	/// </summary>
		8	/// <remarks>
		9	/// Usefull when dealing with memory-intensive objects which are frequently used.
		10	/// This class is similar to <see cref="ObjectPool{T}"/> except it is a singleton.
		11	/// </remarks>
		12	public class LazyAndWeak<T> where T : class {
		13
		14	readonly Func<T> m_factory;
		15	readonly object m_lock;
		16	WeakReference m_reference;
		17
		18
		19	public LazyAndWeak(Func<T> factory, bool useLock) {
		20	Safe.ArgumentNotNull(factory, "factory");
		21	m_factory = factory;
		22	m_lock = useLock ? new object() : null;
		23	}
		24
		25	public LazyAndWeak(Func<T> factory) : this(factory, false) {
		26	}
		27
		28	public T Value {
		29	get {
		30	while (true) {
		31	var weak = m_reference;
		32	T value;
		33	if (weak != null) {
		34	value = weak.Target as T;
		35	if (value != null)
		36	return value;
		37	}
		38
		39	if (m_lock == null) {
		40	value = m_factory();
		41
		42	if (Interlocked.CompareExchange(ref m_reference, new WeakReference(value), weak) == weak)
		43	return value;
		44	} else {
		45	lock (m_lock) {
		46	// double check
		47	weak = m_reference;
		48	if (weak != null) {
		49	value = weak.Target as T;
		50	if (value != null)
		51	return value;
		52	}
		53	// we are safe to write
		54	value = m_factory();
		55	m_reference = new WeakReference(value);
		56	return value;
		57	}
		58	}
		59	}
		60	}
		61	}
		62	}
		63	}
		64

Implab/Formats/ByteAlphabet.cs created 644 +23 0

			@@ -0,0 +1,23
		1	using System.Collections.Generic;
		2	using System.Linq;
		3	using Implab.Automaton;
		4
		5	namespace Implab.Formats {
		6	public class ByteAlphabet : IndexedAlphabetBase<byte> {
		7
		8	#region implemented abstract members of IndexedAlphabetBase
		9
		10	public override int GetSymbolIndex(byte symbol) {
		11	return (int)symbol;
		12	}
		13
		14	public IEnumerable<byte> InputSymbols {
		15	get {
		16	return Enumerable.Range(byte.MinValue, byte.MaxValue).Cast<byte>();
		17	}
		18	}
		19
		20	#endregion
		21	}
		22	}
		23

Implab/Formats/CharAlphabet.cs created 644 +16 0

			@@ -0,0 +1,16
		1	using System.Collections.Generic;
		2	using System.Linq;
		3	using Implab.Automaton;
		4
		5	namespace Implab.Formats {
		6	public class CharAlphabet: IndexedAlphabetBase<char> {
		7
		8	public override int GetSymbolIndex(char symbol) {
		9	return symbol;
		10	}
		11
		12	public IEnumerable<char> InputSymbols {
		13	get { return Enumerable.Range(char.MinValue, char.MaxValue).Cast<char>(); }
		14	}
		15	}
		16	}

Implab/Formats/Grammar.cs created 644 +99 0

			@@ -0,0 +1,99
		1	using Implab;
		2	using System;
		3	using System.Collections.Generic;
		4	using System.Linq;
		5	using Implab.Automaton;
		6	using Implab.Automaton.RegularExpressions;
		7
		8	namespace Implab.Formats {
		9	/// <summary>
		10	/// Базовый абстрактный класс. Грамматика, позволяет формулировать выражения над алфавитом типа <c>char</c>.
		11	/// </summary>
		12	public abstract class Grammar<TSymbol> {
		13
		14	protected abstract IAlphabetBuilder<TSymbol> AlphabetBuilder {
		15	get;
		16	}
		17
		18	protected SymbolToken UnclassifiedToken() {
		19	return new SymbolToken(AutomatonConst.UNCLASSIFIED_INPUT);
		20	}
		21
		22	protected void DefineAlphabet(IEnumerable<TSymbol> alphabet) {
		23	Safe.ArgumentNotNull(alphabet, "alphabet");
		24
		25	foreach (var ch in alphabet)
		26	AlphabetBuilder.DefineSymbol(ch);
		27	}
		28
		29	protected Token SymbolToken(TSymbol symbol) {
		30	return Token.New(TranslateOrAdd(symbol));
		31	}
		32
		33	protected Token SymbolToken(IEnumerable<TSymbol> symbols) {
		34	Safe.ArgumentNotNull(symbols, "symbols");
		35
		36	return Token.New(TranslateOrAdd(symbols).ToArray());
		37	}
		38
		39	protected Token SymbolSetToken(params TSymbol[] set) {
		40	return SymbolToken(set);
		41	}
		42
		43	int TranslateOrAdd(TSymbol ch) {
		44	var t = AlphabetBuilder.Translate(ch);
		45	if (t == AutomatonConst.UNCLASSIFIED_INPUT)
		46	t = AlphabetBuilder.DefineSymbol(ch);
		47	return t;
		48	}
		49
		50	IEnumerable<int> TranslateOrAdd(IEnumerable<TSymbol> symbols) {
		51	return symbols.Distinct().Select(TranslateOrAdd);
		52	}
		53
		54	int TranslateOrDie(TSymbol ch) {
		55	var t = AlphabetBuilder.Translate(ch);
		56	if (t == AutomatonConst.UNCLASSIFIED_INPUT)
		57	throw new ApplicationException(String.Format("Symbol '{0}' is UNCLASSIFIED", ch));
		58	return t;
		59	}
		60
		61	IEnumerable<int> TranslateOrDie(IEnumerable<TSymbol> symbols) {
		62	return symbols.Distinct().Select(TranslateOrDie);
		63	}
		64
		65	protected Token SymbolTokenExcept(IEnumerable<TSymbol> symbols) {
		66	Safe.ArgumentNotNull(symbols, "symbols");
		67
		68	return Token.New( Enumerable.Range(0, AlphabetBuilder.Count).Except(TranslateOrDie(symbols)).ToArray() );
		69	}
		70
		71	protected abstract IndexedAlphabetBase<TSymbol> CreateAlphabet();
		72
		73	protected ScannerContext<TTag> BuildScannerContext<TTag>(Token regexp) {
		74
		75	var dfa = new RegularDFA<TSymbol, TTag>(AlphabetBuilder);
		76
		77	var visitor = new RegularExpressionVisitor<TTag>(dfa);
		78	regexp.Accept(visitor);
		79	visitor.BuildDFA();
		80
		81	if (dfa.IsFinalState(dfa.InitialState))
		82	throw new ApplicationException("The specified language contains empty token");
		83
		84	var ab = CreateAlphabet();
		85	var optimal = dfa.Optimize(ab);
		86
		87	return new ScannerContext<TTag>(
		88	optimal.CreateTransitionTable(),
		89	optimal.CreateFinalStateTable(),
		90	optimal.CreateTagTable(),
		91	optimal.InitialState,
		92	ab.GetTranslationMap()
		93	);
		94	}
		95
		96	}
		97
		98
		99	}

Implab/Formats/JSON/JSONElementContext.cs created 644 +11 0

			@@ -0,0 +1,11
		1	namespace Implab.Formats.JSON {
		2	/// <summary>
		3	/// internal
		4	/// </summary>
		5	enum JSONElementContext {
		6	None,
		7	Object,
		8	Array,
		9	Closed
		10	}
		11	}

Implab/Formats/JSON/JSONElementType.cs created 644 +28 0

			@@ -0,0 +1,28
		1	namespace Implab.Formats.JSON {
		2	/// <summary>
		3	/// Тип элемента на котором находится парсер
		4	/// </summary>
		5	public enum JSONElementType {
		6	None,
		7	/// <summary>
		8	/// Начало объекта
		9	/// </summary>
		10	BeginObject,
		11	/// <summary>
		12	/// Конец объекта
		13	/// </summary>
		14	EndObject,
		15	/// <summary>
		16	/// Начало массива
		17	/// </summary>
		18	BeginArray,
		19	/// <summary>
		20	/// Конец массива
		21	/// </summary>
		22	EndArray,
		23	/// <summary>
		24	/// Простое значение
		25	/// </summary>
		26	Value
		27	}
		28	}

Implab/Formats/JSON/JSONGrammar.cs created 644 +121 0

			@@ -0,0 +1,121
		1	using System.Linq;
		2	using Implab.Automaton.RegularExpressions;
		3	using System;
		4	using Implab.Automaton;
		5	using Implab.Components;
		6
		7	namespace Implab.Formats.JSON {
		8	class JSONGrammar : Grammar<char> {
		9	public enum TokenType {
		10	None,
		11	BeginObject,
		12	EndObject,
		13	BeginArray,
		14	EndArray,
		15	String,
		16	Number,
		17	Literal,
		18	NameSeparator,
		19	ValueSeparator,
		20	Whitespace,
		21
		22	StringBound,
		23	EscapedChar,
		24	UnescapedChar,
		25	EscapedUnicode
		26	}
		27
		28	static LazyAndWeak<JSONGrammar> _instance = new LazyAndWeak<JSONGrammar>(() => new JSONGrammar());
		29
		30	public static JSONGrammar Instance {
		31	get { return _instance.Value; }
		32	}
		33
		34	readonly ScannerContext<TokenType> m_jsonExpression;
		35	readonly ScannerContext<TokenType> m_stringExpression;
		36	readonly CharAlphabet m_defaultAlphabet = new CharAlphabet();
		37
		38	public JSONGrammar() {
		39	DefineAlphabet(Enumerable.Range(0, 0x20).Select(x => (char)x));
		40	var hexDigit = SymbolRangeToken('a','f').Or(SymbolRangeToken('A','F')).Or(SymbolRangeToken('0','9'));
		41	var digit9 = SymbolRangeToken('1', '9');
		42	var zero = SymbolToken('0');
		43	var digit = zero.Or(digit9);
		44	var dot = SymbolToken('.');
		45	var minus = SymbolToken('-');
		46	var sign = SymbolSetToken('-', '+');
		47	var expSign = SymbolSetToken('e', 'E');
		48	var letters = SymbolRangeToken('a', 'z');
		49	var integer = zero.Or(digit9.Cat(digit.EClosure()));
		50	var frac = dot.Cat(digit.Closure());
		51	var exp = expSign.Cat(sign.Optional()).Cat(digit.Closure());
		52	var quote = SymbolToken('"');
		53	var backSlash = SymbolToken('\\');
		54	var specialEscapeChars = SymbolSetToken('\\', '"', '/', 'b', 'f', 't', 'n', 'r');
		55	var unicodeEspace = SymbolToken('u').Cat(hexDigit.Repeat(4));
		56	var whitespace = SymbolSetToken('\n', '\r', '\t', ' ').EClosure();
		57	var beginObject = whitespace.Cat(SymbolToken('{')).Cat(whitespace);
		58	var endObject = whitespace.Cat(SymbolToken('}')).Cat(whitespace);
		59	var beginArray = whitespace.Cat(SymbolToken('[')).Cat(whitespace);
		60	var endArray = whitespace.Cat(SymbolToken(']')).Cat(whitespace);
		61	var nameSep = whitespace.Cat(SymbolToken(':')).Cat(whitespace);
		62	var valueSep = whitespace.Cat(SymbolToken(',')).Cat(whitespace);
		63
		64	var number = minus.Optional().Cat(integer).Cat(frac.Optional()).Cat(exp.Optional());
		65	var literal = letters.Closure();
		66	var unescaped = SymbolTokenExcept(Enumerable.Range(0, 0x20).Union(new int[] { '\\', '"' }).Select(x => (char)x));
		67
		68	var jsonExpression =
		69	number.Tag(TokenType.Number)
		70	.Or(literal.Tag(TokenType.Literal))
		71	.Or(quote.Tag(TokenType.StringBound))
		72	.Or(beginObject.Tag(TokenType.BeginObject))
		73	.Or(endObject.Tag(TokenType.EndObject))
		74	.Or(beginArray.Tag(TokenType.BeginArray))
		75	.Or(endArray.Tag(TokenType.EndArray))
		76	.Or(nameSep.Tag(TokenType.NameSeparator))
		77	.Or(valueSep.Tag(TokenType.ValueSeparator))
		78	.Or(SymbolSetToken('\n', '\r', '\t', ' ').Closure().Tag(TokenType.Whitespace));
		79
		80
		81	var jsonStringExpression =
		82	quote.Tag(TokenType.StringBound)
		83	.Or(backSlash.Cat(specialEscapeChars).Tag(TokenType.EscapedChar))
		84	.Or(backSlash.Cat(unicodeEspace).Tag(TokenType.EscapedUnicode))
		85	.Or(unescaped.Closure().Tag(TokenType.UnescapedChar));
		86
		87
		88	m_jsonExpression = BuildScannerContext<TokenType>(jsonExpression);
		89	m_stringExpression = BuildScannerContext<TokenType>(jsonStringExpression);
		90
		91
		92	}
		93
		94	protected override IAlphabetBuilder<char> AlphabetBuilder {
		95	get {
		96	return m_defaultAlphabet;
		97	}
		98	}
		99
		100	public ScannerContext<TokenType> JsonExpression {
		101	get {
		102	return m_jsonExpression;
		103	}
		104	}
		105
		106	public ScannerContext<TokenType> JsonStringExpression {
		107	get {
		108	return m_stringExpression;
		109	}
		110	}
		111
		112	Token SymbolRangeToken(char start, char stop) {
		113	return SymbolToken(Enumerable.Range(start, stop - start + 1).Select(x => (char)x));
		114	}
		115
		116	protected override IndexedAlphabetBase<char> CreateAlphabet() {
		117	return new CharAlphabet();
		118	}
		119
		120	}
		121	}

Implab/Formats/JSON/JSONParser.cs created 644 +293 0

			@@ -0,0 +1,293
		1	using System;
		2	using System.Diagnostics;
		3	using System.IO;
		4	using Implab.Automaton;
		5	using Implab.Automaton.RegularExpressions;
		6	using System.Linq;
		7	using Implab.Components;
		8	using System.Collections.Generic;
		9
		10	namespace Implab.Formats.JSON {
		11	/// <summary>
		12	/// Pull парсер JSON данных.
		13	/// </summary>
		14	/// <remarks>
		15	/// Следует отметить отдельную интерпретацию свойства <see cref="Level"/>,
		16	/// оно означает текущий уровень вложенности объектов, однако закрывающий
		17	/// элемент объекта и массива имеет уровень меньше, чем сам объект.
		18	/// <code>
		19	/// { // Level = 1
		20	/// "name" : "Peter", // Level = 1
		21	/// "address" : { // Level = 2
		22	/// city : "Stern" // Level = 2
		23	/// } // Level = 1
		24	/// } // Level = 0
		25	/// </code>
		26	/// </remarks>
		27	public class JSONParser : Disposable {
		28
		29	enum MemberContext {
		30	MemberName,
		31	MemberValue
		32	}
		33
		34	#region Parser rules
		35	struct ParserContext {
		36	readonly int[,] m_dfa;
		37	int m_state;
		38
		39	readonly JSONElementContext m_elementContext;
		40
		41	public ParserContext(int[,] dfa, int state, JSONElementContext context) {
		42	m_dfa = dfa;
		43	m_state = state;
		44	m_elementContext = context;
		45	}
		46
		47	public bool Move(JsonTokenType token) {
		48	var next = m_dfa[m_state, (int)token];
		49	if (next == AutomatonConst.UNREACHABLE_STATE)
		50	return false;
		51	m_state = next;
		52	return true;
		53	}
		54
		55	public JSONElementContext ElementContext {
		56	get { return m_elementContext; }
		57	}
		58	}
		59
		60	static readonly ParserContext _jsonContext;
		61	static readonly ParserContext _objectContext;
		62	static readonly ParserContext _arrayContext;
		63
		64	static JSONParser() {
		65
		66	var valueExpression = MakeToken(JsonTokenType.BeginArray, JsonTokenType.BeginObject, JsonTokenType.Literal, JsonTokenType.Number, JsonTokenType.String);
		67	var memberExpression = MakeToken(JsonTokenType.String).Cat(MakeToken(JsonTokenType.NameSeparator)).Cat(valueExpression);
		68
		69	var objectExpression = memberExpression
		70	.Cat(
		71	MakeToken(JsonTokenType.ValueSeparator)
		72	.Cat(memberExpression)
		73	.EClosure()
		74	)
		75	.Optional()
		76	.Cat(MakeToken(JsonTokenType.EndObject))
		77	.End();
		78
		79	var arrayExpression = valueExpression
		80	.Cat(
		81	MakeToken(JsonTokenType.ValueSeparator)
		82	.Cat(valueExpression)
		83	.EClosure()
		84	)
		85	.Optional()
		86	.Cat(MakeToken(JsonTokenType.EndArray))
		87	.End();
		88
		89	var jsonExpression = valueExpression.End();
		90
		91	_jsonContext = CreateParserContext(jsonExpression, JSONElementContext.None);
		92	_objectContext = CreateParserContext(objectExpression, JSONElementContext.Object);
		93	_arrayContext = CreateParserContext(arrayExpression, JSONElementContext.Array);
		94	}
		95
		96	static Token MakeToken(params JsonTokenType[] input) {
		97	return Token.New( input.Select(t => (int)t).ToArray() );
		98	}
		99
		100	static ParserContext CreateParserContext(Token expr, JSONElementContext context) {
		101
		102	var dfa = new DFATable();
		103	var builder = new RegularExpressionVisitor(dfa);
		104	expr.Accept(builder);
		105	builder.BuildDFA();
		106
		107	return new ParserContext(dfa.CreateTransitionTable(), dfa.InitialState, context);
		108	}
		109
		110	#endregion
		111
		112	readonly JSONScanner m_scanner;
		113	MemberContext m_memberContext;
		114
		115	JSONElementType m_elementType;
		116	object m_elementValue;
		117	string m_memberName = String.Empty;
		118
		119	Stack<ParserContext> m_stack = new Stack<ParserContext>();
		120	ParserContext m_context = _jsonContext;
		121
		122	/// <summary>
		123	/// Создает новый парсер на основе строки, содержащей JSON
		124	/// </summary>
		125	/// <param name="text"></param>
		126	public JSONParser(string text) {
		127	Safe.ArgumentNotEmpty(text, "text");
		128	m_scanner = new JSONScanner(text);
		129	}
		130
		131	/// <summary>
		132	/// Создает новый экземпляр парсера, на основе текстового потока.
		133	/// </summary>
		134	/// <param name="reader">Текстовый поток.</param>
		135	public JSONParser(TextReader reader) {
		136	Safe.ArgumentNotNull(reader, "reader");
		137	m_scanner = new JSONScanner(reader);
		138	}
		139
		140	public int Level {
		141	get { return m_stack.Count; }
		142	}
		143
		144	/// <summary>
		145	/// Тип текущего элемента на котором стоит парсер.
		146	/// </summary>
		147	public JSONElementType ElementType {
		148	get { return m_elementType; }
		149	}
		150
		151	/// <summary>
		152	/// Имя элемента - имя свойства родительского контейнера. Для элементов массивов и корневого всегда
		153	/// пустая строка.
		154	/// </summary>
		155	public string ElementName {
		156	get { return m_memberName; }
		157	}
		158
		159	/// <summary>
		160	/// Значение элемента. Только для элементов типа <see cref="JSONElementType.Value"/>, для остальных <c>null</c>
		161	/// </summary>
		162	public object ElementValue {
		163	get { return m_elementValue; }
		164	}
		165
		166	/// <summary>
		167	/// Читает слеюудущий объект из потока
		168	/// </summary>
		169	/// <returns><c>true</c> - операция чтения прошла успешно, <c>false</c> - конец данных</returns>
		170	public bool Read() {
		171	object tokenValue;
		172	JsonTokenType tokenType;
		173
		174	m_memberName = String.Empty;
		175
		176	while (m_scanner.ReadToken(out tokenValue, out tokenType)) {
		177	if(!m_context.Move(tokenType))
		178	UnexpectedToken(tokenValue, tokenType);
		179
		180	switch (tokenType) {
		181	case JsonTokenType.BeginObject:
		182	m_stack.Push(m_context);
		183	m_context = _objectContext;
		184
		185	m_elementValue = null;
		186	m_memberContext = MemberContext.MemberName;
		187	m_elementType = JSONElementType.BeginObject;
		188	return true;
		189	case JsonTokenType.EndObject:
		190	if (m_stack.Count == 0)
		191	UnexpectedToken(tokenValue, tokenType);
		192	m_context = m_stack.Pop();
		193
		194	m_elementValue = null;
		195	m_elementType = JSONElementType.EndObject;
		196	return true;
		197	case JsonTokenType.BeginArray:
		198	m_stack.Push(m_context);
		199	m_context = _arrayContext;
		200
		201	m_elementValue = null;
		202	m_memberContext = MemberContext.MemberValue;
		203	m_elementType = JSONElementType.BeginArray;
		204	return true;
		205	case JsonTokenType.EndArray:
		206	if (m_stack.Count == 0)
		207	UnexpectedToken(tokenValue, tokenType);
		208	m_context = m_stack.Pop();
		209
		210	m_elementValue = null;
		211	m_elementType = JSONElementType.EndArray;
		212	return true;
		213	case JsonTokenType.String:
		214	if (m_memberContext == MemberContext.MemberName) {
		215	m_memberName = (string)tokenValue;
		216	break;
		217	}
		218	m_elementType = JSONElementType.Value;
		219	m_elementValue = tokenValue;
		220	return true;
		221	case JsonTokenType.Number:
		222	m_elementType = JSONElementType.Value;
		223	m_elementValue = tokenValue;
		224	return true;
		225	case JsonTokenType.Literal:
		226	m_elementType = JSONElementType.Value;
		227	m_elementValue = ParseLiteral((string)tokenValue);
		228	return true;
		229	case JsonTokenType.NameSeparator:
		230	m_memberContext = MemberContext.MemberValue;
		231	break;
		232	case JsonTokenType.ValueSeparator:
		233	m_memberContext = m_context.ElementContext == JSONElementContext.Object ? MemberContext.MemberName : MemberContext.MemberValue;
		234	break;
		235	default:
		236	UnexpectedToken(tokenValue, tokenType);
		237	break;
		238	}
		239	}
		240	if (m_context.ElementContext != JSONElementContext.None)
		241	throw new ParserException("Unexpedted end of data");
		242
		243	EOF = true;
		244
		245	return false;
		246	}
		247
		248	object ParseLiteral(string literal) {
		249	switch (literal) {
		250	case "null":
		251	return null;
		252	case "false":
		253	return false;
		254	case "true":
		255	return true;
		256	default:
		257	UnexpectedToken(literal, JsonTokenType.Literal);
		258	return null; // avoid compliler error
		259	}
		260	}
		261
		262	void UnexpectedToken(object value, JsonTokenType tokenType) {
		263	throw new ParserException(String.Format("Unexpected token {0}: '{1}'", tokenType, value));
		264	}
		265
		266
		267	/// <summary>
		268	/// Признак конца потока
		269	/// </summary>
		270	public bool EOF {
		271	get;
		272	private set;
		273	}
		274
		275	protected override void Dispose(bool disposing) {
		276	if (disposing)
		277	Safe.Dispose(m_scanner);
		278	}
		279
		280	/// <summary>
		281	/// Переходит в конец текущего объекта.
		282	/// </summary>
		283	public void SeekElementEnd() {
		284	var level = Level - 1;
		285
		286	Debug.Assert(level >= 0);
		287
		288	while (Level != level)
		289	Read();
		290	}
		291	}
		292
		293	}

Implab/Formats/JSON/JSONScanner.cs created 644 +109 0

			@@ -0,0 +1,109
		1	using System;
		2	using System.Globalization;
		3	using Implab.Automaton;
		4	using System.Text;
		5	using Implab.Components;
		6	using System.IO;
		7
		8	namespace Implab.Formats.JSON {
		9	/// <summary>
		10	/// Сканнер (лексер), разбивающий поток символов на токены JSON.
		11	/// </summary>
		12	public class JSONScanner : Disposable {
		13	readonly StringBuilder m_builder = new StringBuilder();
		14
		15	readonly ScannerContext<JSONGrammar.TokenType> m_jsonContext = JSONGrammar.Instance.JsonExpression;
		16	readonly ScannerContext<JSONGrammar.TokenType> m_stringContext = JSONGrammar.Instance.JsonStringExpression;
		17
		18
		19	readonly TextScanner m_scanner;
		20
		21	/// <summary>
		22	/// Создает новый экземпляр сканнера
		23	/// </summary>
		24	public JSONScanner(string text) {
		25	Safe.ArgumentNotEmpty(text, "text");
		26
		27	m_scanner = new StringScanner(text);
		28	}
		29
		30	public JSONScanner(TextReader reader, int bufferMax, int chunkSize) {
		31	Safe.ArgumentNotNull(reader, "reader");
		32
		33	m_scanner = new ReaderScanner(reader, bufferMax, chunkSize);
		34	}
		35
		36	public JSONScanner(TextReader reader) : this(reader, 1024*1024, 1024){
		37	}
		38
		39	/// <summary>
		40	/// Читает следующий лексический элемент из входных данных.
		41	/// </summary>
		42	/// <param name="tokenValue">Возвращает значение прочитанного токена.</param>
		43	/// <param name="tokenType">Возвращает тип прочитанного токена.</param>
		44	/// <returns><c>true</c> - чтение произведено успешно. <c>false</c> - достигнут конец входных данных</returns>
		45	/// <remarks>В случе если токен не распознается, возникает исключение. Значения токенов обрабатываются, т.е.
		46	/// в строках обрабатываются экранированные символы, числа становтся типа double.</remarks>
		47	public bool ReadToken(out object tokenValue, out JsonTokenType tokenType) {
		48	JSONGrammar.TokenType[] tag;
		49	while (m_jsonContext.Execute(m_scanner, out tag)) {
		50	switch (tag[0]) {
		51	case JSONGrammar.TokenType.StringBound:
		52	tokenValue = ReadString();
		53	tokenType = JsonTokenType.String;
		54	break;
		55	case JSONGrammar.TokenType.Number:
		56	tokenValue = Double.Parse(m_scanner.GetTokenValue(), CultureInfo.InvariantCulture);
		57	tokenType = JsonTokenType.Number;
		58	break;
		59	case JSONGrammar.TokenType.Whitespace:
		60	continue;
		61	default:
		62	tokenType = (JsonTokenType)tag[0];
		63	tokenValue = m_scanner.GetTokenValue();
		64	break;
		65	}
		66	return true;
		67	}
		68	tokenValue = null;
		69	tokenType = JsonTokenType.None;
		70	return false;
		71	}
		72
		73	string ReadString() {
		74	int pos = 0;
		75	var buf = new char[6]; // the buffer for unescaping chars
		76
		77	JSONGrammar.TokenType[] tag;
		78	m_builder.Clear();
		79
		80	while (m_stringContext.Execute(m_scanner, out tag)) {
		81	switch (tag[0]) {
		82	case JSONGrammar.TokenType.StringBound:
		83	return m_builder.ToString();
		84	case JSONGrammar.TokenType.UnescapedChar:
		85	m_scanner.CopyTokenTo(m_builder);
		86	break;
		87	case JSONGrammar.TokenType.EscapedUnicode: // \xXXXX - unicode escape sequence
		88	m_scanner.CopyTokenTo(buf, 0);
		89	m_builder.Append(StringTranslator.TranslateHexUnicode(buf, 2));
		90	pos++;
		91	break;
		92	case JSONGrammar.TokenType.EscapedChar: // \t - escape sequence
		93	m_scanner.CopyTokenTo(buf, 0);
		94	m_builder.Append(StringTranslator.TranslateEscapedChar(buf[1]));
		95	break;
		96	}
		97
		98	}
		99
		100	throw new ParserException("Unexpected end of data");
		101	}
		102
		103	protected override void Dispose(bool disposing) {
		104	if (disposing)
		105	Safe.Dispose(m_scanner);
		106	base.Dispose(disposing);
		107	}
		108	}
		109	}

Implab/Formats/JSON/JSONWriter.cs created 644 +319 0

			@@ -0,0 +1,319
		1	using System;
		2	using System.Collections.Generic;
		3	using System.IO;
		4	using System.Globalization;
		5	using System.Diagnostics;
		6
		7	namespace Implab.Formats.JSON {
		8	public class JSONWriter {
		9	struct Context {
		10	public bool needComma;
		11	public JSONElementContext element;
		12	}
		13	Stack<Context> m_contextStack = new Stack<Context>();
		14	Context m_context;
		15
		16	const int BUFFER_SIZE = 64;
		17
		18	TextWriter m_writer;
		19	readonly bool m_indent = true;
		20	readonly int m_indentSize = 4;
		21	readonly char[] m_buffer = new char[BUFFER_SIZE];
		22	int m_bufferPos;
		23
		24	static readonly char [] _hex = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };
		25	static readonly char [] _escapeBKS,
		26	_escapeFWD,
		27	_escapeCR,
		28	_escapeNL,
		29	_escapeTAB,
		30	_escapeBSLASH,
		31	_escapeQ;
		32
		33	static JSONWriter() {
		34	_escapeBKS = "\\b".ToCharArray();
		35	_escapeFWD = "\\f".ToCharArray();
		36	_escapeCR = "\\r".ToCharArray();
		37	_escapeNL = "\\n".ToCharArray();
		38	_escapeTAB = "\\t".ToCharArray();
		39	_escapeBSLASH = "\\\\".ToCharArray();
		40	_escapeQ = "\\\"".ToCharArray();
		41	}
		42
		43	public JSONWriter(TextWriter writer) {
		44	Safe.ArgumentNotNull(writer, "writer");
		45	m_writer = writer;
		46	}
		47
		48	public JSONWriter(TextWriter writer, bool indent) {
		49	Safe.ArgumentNotNull(writer, "writer");
		50
		51	m_writer = writer;
		52	m_indent = indent;
		53	}
		54
		55	void WriteIndent() {
		56	if (m_indent) {
		57	var indent = new char[m_contextStack.Count * m_indentSize + 1];
		58	indent[0] = '\n';
		59	for (int i = 1; i < indent.Length; i++)
		60	indent[i] = ' ';
		61	m_writer.Write(new String(indent));
		62	} else {
		63	m_writer.Write(' ');
		64	}
		65	}
		66
		67	void WriteMemberName(string name) {
		68	Safe.ArgumentNotEmpty(name, "name");
		69	if (m_context.element != JSONElementContext.Object)
		70	OperationNotApplicable("WriteMember");
		71	if (m_context.needComma)
		72	m_writer.Write(",");
		73
		74	WriteIndent();
		75	m_context.needComma = true;
		76	Write(name);
		77	m_writer.Write(" : ");
		78	}
		79
		80	public void WriteValue(string name, string value) {
		81	WriteMemberName(name);
		82	Write(value);
		83	}
		84
		85	public void WriteValue(string name, bool value) {
		86	WriteMemberName(name);
		87	Write(value);
		88	}
		89
		90	public void WriteValue(string name, double value) {
		91	WriteMemberName(name);
		92	Write(value);
		93	}
		94
		95	public void WriteValue(string value) {
		96	if (m_context.element == JSONElementContext.Array) {
		97
		98	if (m_context.needComma)
		99	m_writer.Write(",");
		100	WriteIndent();
		101	m_context.needComma = true;
		102
		103	Write(value);
		104	} else if (m_context.element == JSONElementContext.None) {
		105	Write(value);
		106	m_context.element = JSONElementContext.Closed;
		107	} else {
		108	OperationNotApplicable("WriteValue");
		109	}
		110	}
		111
		112	public void WriteValue(bool value) {
		113	if (m_context.element == JSONElementContext.Array) {
		114
		115	if (m_context.needComma)
		116	m_writer.Write(",");
		117	WriteIndent();
		118	m_context.needComma = true;
		119
		120	Write(value);
		121	} else if (m_context.element == JSONElementContext.None) {
		122	Write(value);
		123	m_context.element = JSONElementContext.Closed;
		124	} else {
		125	OperationNotApplicable("WriteValue");
		126	}
		127	}
		128
		129	public void WriteValue(double value) {
		130	if (m_context.element == JSONElementContext.Array) {
		131
		132	if (m_context.needComma)
		133	m_writer.Write(",");
		134	WriteIndent();
		135	m_context.needComma = true;
		136
		137	Write(value);
		138	} else if (m_context.element == JSONElementContext.None) {
		139	Write(value);
		140	m_context.element = JSONElementContext.Closed;
		141	} else {
		142	OperationNotApplicable("WriteValue");
		143	}
		144	}
		145
		146	public void BeginObject() {
		147	if (m_context.element != JSONElementContext.None && m_context.element != JSONElementContext.Array)
		148	OperationNotApplicable("BeginObject");
		149	if (m_context.needComma)
		150	m_writer.Write(",");
		151
		152	WriteIndent();
		153
		154	m_context.needComma = true;
		155
		156	m_contextStack.Push(m_context);
		157
		158	m_context = new Context { element = JSONElementContext.Object, needComma = false };
		159	m_writer.Write("{");
		160	}
		161
		162	public void BeginObject(string name) {
		163	WriteMemberName(name);
		164
		165	m_contextStack.Push(m_context);
		166
		167	m_context = new Context { element = JSONElementContext.Object, needComma = false };
		168	m_writer.Write("{");
		169	}
		170
		171	public void EndObject() {
		172	if (m_context.element != JSONElementContext.Object)
		173	OperationNotApplicable("EndObject");
		174
		175	m_context = m_contextStack.Pop();
		176	if (m_contextStack.Count == 0)
		177	m_context.element = JSONElementContext.Closed;
		178	WriteIndent();
		179	m_writer.Write("}");
		180	}
		181
		182	public void BeginArray() {
		183	if (m_context.element != JSONElementContext.None && m_context.element != JSONElementContext.Array)
		184	throw new InvalidOperationException();
		185	if (m_context.needComma) {
		186	m_writer.Write(",");
		187
		188	}
		189	m_context.needComma = true;
		190
		191	WriteIndent();
		192	m_contextStack.Push(m_context);
		193	m_context = new Context { element = JSONElementContext.Array, needComma = false };
		194	m_writer.Write("[");
		195	}
		196
		197	public void BeginArray(string name) {
		198	WriteMemberName(name);
		199
		200	m_contextStack.Push(m_context);
		201
		202	m_context = new Context { element = JSONElementContext.Array, needComma = false };
		203	m_writer.Write("[");
		204	}
		205
		206	public void EndArray() {
		207	if (m_context.element != JSONElementContext.Array)
		208	OperationNotApplicable("EndArray");
		209
		210	m_context = m_contextStack.Pop();
		211	if (m_contextStack.Count == 0)
		212	m_context.element = JSONElementContext.Closed;
		213	WriteIndent();
		214	m_writer.Write("]");
		215	}
		216
		217	void Write(bool value) {
		218	m_writer.Write(value ? "true" : "false");
		219	}
		220
		221	void FlushBuffer() {
		222	if (m_bufferPos > 0) {
		223	m_writer.Write(m_buffer, 0, m_bufferPos);
		224	m_bufferPos = 0;
		225	}
		226	}
		227
		228	void Write(string value) {
		229	if (value == null) {
		230	m_writer.Write("null");
		231	return;
		232	}
		233
		234	Debug.Assert(m_bufferPos == 0);
		235
		236	var chars = value.ToCharArray();
		237	m_buffer[m_bufferPos++] = '"';
		238
		239	// Analysis disable once ForCanBeConvertedToForeach
		240	for (int i = 0; i < chars.Length; i++) {
		241	var ch = chars[i];
		242
		243	char[] escapeSeq;
		244
		245	switch (ch) {
		246	case '\b':
		247	escapeSeq = _escapeBKS;
		248	break;
		249	case '\f':
		250	escapeSeq = _escapeFWD;
		251	break;
		252	case '\r':
		253	escapeSeq = _escapeCR;
		254	break;
		255	case '\n':
		256	escapeSeq = _escapeNL;
		257	break;
		258	case '\t':
		259	escapeSeq = _escapeTAB;
		260	break;
		261	case '\\':
		262	escapeSeq = _escapeBSLASH;
		263	break;
		264	case '"':
		265	escapeSeq = _escapeQ;
		266	break;
		267	default:
		268	if (ch < 0x20) {
		269	if (m_bufferPos + 6 > BUFFER_SIZE)
		270	FlushBuffer();
		271
		272	m_buffer[m_bufferPos++] = '\\';
		273	m_buffer[m_bufferPos++] = 'u';
		274	m_buffer[m_bufferPos++] = '0';
		275	m_buffer[m_bufferPos++] = '0';
		276	m_buffer[m_bufferPos++] = _hex[ch >> 4 & 0xf];
		277	m_buffer[m_bufferPos++] = _hex[ch & 0xf];
		278
		279	} else {
		280	if (m_bufferPos >= BUFFER_SIZE)
		281	FlushBuffer();
		282	m_buffer[m_bufferPos++] = ch;
		283	}
		284	continue;
		285	}
		286
		287	if (m_bufferPos + escapeSeq.Length > BUFFER_SIZE)
		288	FlushBuffer();
		289
		290	Array.Copy(escapeSeq, 0, m_buffer, m_bufferPos, escapeSeq.Length);
		291	m_bufferPos += escapeSeq.Length;
		292
		293	}
		294
		295	if (m_bufferPos >= BUFFER_SIZE)
		296	FlushBuffer();
		297
		298	m_buffer[m_bufferPos++] = '"';
		299
		300	FlushBuffer();
		301	}
		302
		303	void Write(double value) {
		304	if (double.IsNaN(value))
		305	Write("NaN");
		306	else if (double.IsNegativeInfinity(value))
		307	Write("-Infinity");
		308	else if (double.IsPositiveInfinity(value))
		309	Write("Infinity");
		310	else
		311	m_writer.Write(value.ToString(CultureInfo.InvariantCulture));
		312	}
		313
		314	void OperationNotApplicable(string opName) {
		315	throw new InvalidOperationException(String.Format("The operation '{0}' isn't applicable in the context of '{1}'", opName, m_context.element ));
		316	}
		317
		318	}
		319	}

Implab/Formats/JSON/JSONXmlReader.cs created 644 +335 0

			@@ -0,0 +1,335
		1	using Implab;
		2	using System;
		3	using System.Collections.Generic;
		4	using System.Globalization;
		5	using System.IO;
		6	using System.Xml;
		7
		8	namespace Implab.Formats.JSON {
		9	public class JSONXmlReader : XmlReader {
		10
		11	enum ValueContext {
		12	Undefined,
		13	ElementStart,
		14	ElementValue,
		15	ElementEnd,
		16	ElementEmpty
		17	}
		18
		19	struct LocalNameContext {
		20	public string localName;
		21	public bool isArray;
		22	}
		23
		24	JSONParser m_parser;
		25	ValueContext m_valueContext;
		26	ReadState m_state = ReadState.Initial;
		27	Stack<LocalNameContext> m_localNameStack = new Stack<LocalNameContext>();
		28	LocalNameContext m_localName;
		29	int m_depthCorrection;
		30
		31	readonly string m_rootName;
		32	readonly string m_prefix;
		33	readonly string m_namespaceUri;
		34	readonly bool m_flattenArrays;
		35	readonly string m_arrayItemName;
		36	readonly XmlNameTable m_nameTable;
		37
		38	JSONXmlReader(JSONParser parser, JSONXmlReaderOptions options) {
		39	m_parser = parser;
		40
		41	if (options != null) {
		42	m_prefix = options.NodesPrefix ?? String.Empty;
		43	m_namespaceUri = options.NamespaceURI ?? String.Empty;
		44	m_rootName = options.RootName ?? "json";
		45	m_flattenArrays = options.FlattenArrays;
		46	m_arrayItemName = options.ArrayItemName ?? "item";
		47	m_nameTable = options.NameTable ?? new NameTable();
		48	} else {
		49	m_prefix = String.Empty;
		50	m_namespaceUri = String.Empty;
		51	m_rootName = "json";
		52	m_flattenArrays = false;
		53	m_arrayItemName = "item";
		54	m_nameTable = new NameTable();
		55	}
		56	}
		57
		58	/// <summary>
		59	/// Always 0, JSON doesn't support attributes
		60	/// </summary>
		61	public override int AttributeCount {
		62	get { return 0; }
		63	}
		64
		65	public override string BaseURI {
		66	get { return String.Empty; }
		67	}
		68
		69	public override int Depth {
		70	get {
		71	return m_localNameStack.Count + m_depthCorrection;
		72	}
		73	}
		74
		75	public override bool EOF {
		76	get { return m_parser.EOF; }
		77	}
		78
		79	/// <summary>
		80	/// Always throws an exception
		81	/// </summary>
		82	/// <param name="i"></param>
		83	/// <returns></returns>
		84	public override string GetAttribute(int i) {
		85	throw new ArgumentOutOfRangeException();
		86	}
		87
		88	/// <summary>
		89	/// Always returns empty string
		90	/// </summary>
		91	/// <param name="name"></param>
		92	/// <param name="namespaceURI"></param>
		93	/// <returns></returns>
		94	public override string GetAttribute(string name, string namespaceURI) {
		95	return String.Empty;
		96	}
		97
		98	/// <summary>
		99	/// Always returns empty string
		100	/// </summary>
		101	/// <param name="name"></param>
		102	/// <returns></returns>
		103	public override string GetAttribute(string name) {
		104	return String.Empty;
		105	}
		106
		107	public override bool IsEmptyElement {
		108	get { return m_parser.ElementType == JSONElementType.Value && m_valueContext == ValueContext.ElementEmpty; }
		109	}
		110
		111	public override string LocalName {
		112	get { return m_localName.localName; }
		113	}
		114
		115	public override string LookupNamespace(string prefix) {
		116	if (String.IsNullOrEmpty(prefix) \|\| prefix == m_prefix)
		117	return m_namespaceUri;
		118
		119	return String.Empty;
		120	}
		121
		122	public override bool MoveToAttribute(string name, string ns) {
		123	return false;
		124	}
		125
		126	public override bool MoveToAttribute(string name) {
		127	return false;
		128	}
		129
		130	public override bool MoveToElement() {
		131	return false;
		132	}
		133
		134	public override bool MoveToFirstAttribute() {
		135	return false;
		136	}
		137
		138	public override bool MoveToNextAttribute() {
		139	return false;
		140	}
		141
		142	public override XmlNameTable NameTable {
		143	get { return m_nameTable; }
		144	}
		145
		146	public override string NamespaceURI {
		147	get { return m_namespaceUri; }
		148	}
		149
		150	public override XmlNodeType NodeType {
		151	get {
		152	switch (m_parser.ElementType) {
		153	case JSONElementType.BeginObject:
		154	case JSONElementType.BeginArray:
		155	return XmlNodeType.Element;
		156	case JSONElementType.EndObject:
		157	case JSONElementType.EndArray:
		158	return XmlNodeType.EndElement;
		159	case JSONElementType.Value:
		160	switch (m_valueContext) {
		161	case ValueContext.ElementStart:
		162	case ValueContext.ElementEmpty:
		163	return XmlNodeType.Element;
		164	case ValueContext.ElementValue:
		165	return XmlNodeType.Text;
		166	case ValueContext.ElementEnd:
		167	return XmlNodeType.EndElement;
		168	default:
		169	throw new InvalidOperationException();
		170	}
		171	default:
		172	throw new InvalidOperationException();
		173	}
		174	}
		175	}
		176
		177	public override string Prefix {
		178	get { return m_prefix; }
		179	}
		180
		181	public override bool Read() {
		182	if (m_state != ReadState.Interactive && m_state != ReadState.Initial)
		183	return false;
		184
		185	if (m_state == ReadState.Initial)
		186	m_state = ReadState.Interactive;
		187
		188	try {
		189	switch (m_parser.ElementType) {
		190	case JSONElementType.Value:
		191	switch (m_valueContext) {
		192	case ValueContext.ElementStart:
		193	SetLocalName(String.Empty);
		194	m_valueContext = ValueContext.ElementValue;
		195	return true;
		196	case ValueContext.ElementValue:
		197	RestoreLocalName();
		198	m_valueContext = ValueContext.ElementEnd;
		199	return true;
		200	case ValueContext.ElementEmpty:
		201	case ValueContext.ElementEnd:
		202	RestoreLocalName();
		203	break;
		204	}
		205	break;
		206	case JSONElementType.EndArray:
		207	case JSONElementType.EndObject:
		208	RestoreLocalName();
		209	break;
		210	}
		211	string itemName = m_parser.ElementType == JSONElementType.None ? m_rootName : m_flattenArrays ? m_localName.localName : m_arrayItemName;
		212	while (m_parser.Read()) {
		213	if (!String.IsNullOrEmpty(m_parser.ElementName))
		214	itemName = m_parser.ElementName;
		215
		216	switch (m_parser.ElementType) {
		217	case JSONElementType.BeginArray:
		218	if (m_flattenArrays && !m_localName.isArray) {
		219	m_depthCorrection--;
		220	SetLocalName(itemName, true);
		221	continue;
		222	}
		223	SetLocalName(itemName, true);
		224	break;
		225	case JSONElementType.BeginObject:
		226	SetLocalName(itemName);
		227	break;
		228	case JSONElementType.EndArray:
		229	if (m_flattenArrays && !m_localNameStack.Peek().isArray) {
		230	RestoreLocalName();
		231	m_depthCorrection++;
		232	continue;
		233	}
		234	break;
		235	case JSONElementType.EndObject:
		236	break;
		237	case JSONElementType.Value:
		238	SetLocalName(itemName);
		239	m_valueContext = m_parser.ElementValue == null ? ValueContext.ElementEmpty : ValueContext.ElementStart;
		240	break;
		241	}
		242	return true;
		243	}
		244
		245	m_state = ReadState.EndOfFile;
		246	return false;
		247	} catch {
		248	m_state = ReadState.Error;
		249	throw;
		250	}
		251	}
		252
		253	public override bool ReadAttributeValue() {
		254	return false;
		255	}
		256
		257	public override ReadState ReadState {
		258	get { return m_state; }
		259	}
		260
		261	public override void ResolveEntity() {
		262	// do nothing
		263	}
		264
		265	public override string Value {
		266	get {
		267	if (m_parser.ElementValue == null)
		268	return String.Empty;
		269	if (Convert.GetTypeCode(m_parser.ElementValue) == TypeCode.Double)
		270	return ((double)m_parser.ElementValue).ToString(CultureInfo.InvariantCulture);
		271	return m_parser.ElementValue.ToString();
		272	}
		273	}
		274
		275	void SetLocalName(string name) {
		276	m_localNameStack.Push(m_localName);
		277	m_localName.localName = name;
		278	m_localName.isArray = false;
		279	}
		280
		281	void SetLocalName(string name, bool isArray) {
		282	m_localNameStack.Push(m_localName);
		283	m_localName.localName = name;
		284	m_localName.isArray = isArray;
		285	}
		286
		287	void RestoreLocalName() {
		288	m_localName = m_localNameStack.Pop();
		289	}
		290
		291	public override void Close() {
		292
		293	}
		294
		295	protected override void Dispose(bool disposing) {
		296	#if MONO
		297	disposing = true;
		298	#endif
		299	if (disposing) {
		300	m_parser.Dispose();
		301	}
		302	base.Dispose(disposing);
		303	}
		304
		305	public static JSONXmlReader Create(string file, JSONXmlReaderOptions options) {
		306	return Create(File.OpenText(file), options);
		307	}
		308
		309	/// <summary>
		310	/// Creates the XmlReader for the specified text stream with JSON data.
		311	/// </summary>
		312	/// <param name="reader">Text reader.</param>
		313	/// <param name="options">Options.</param>
		314	/// <remarks>
		315	/// The reader will be disposed when the XmlReader is disposed.
		316	/// </remarks>
		317	public static JSONXmlReader Create(TextReader reader, JSONXmlReaderOptions options) {
		318	return new JSONXmlReader(new JSONParser(reader), options);
		319	}
		320
		321	/// <summary>
		322	/// Creates the XmlReader for the specified stream with JSON data.
		323	/// </summary>
		324	/// <param name="stream">Stream.</param>
		325	/// <param name="options">Options.</param>
		326	/// <remarks>
		327	/// The stream will be disposed when the XmlReader is disposed.
		328	/// </remarks>
		329	public static JSONXmlReader Create(Stream stream, JSONXmlReaderOptions options) {
		330	Safe.ArgumentNotNull(stream, "stream");
		331	// HACK don't dispose StreaReader to keep stream opened
		332	return Create(new StreamReader(stream), options);
		333	}
		334	}
		335	}

Implab/Formats/JSON/JSONXmlReaderOptions.cs created 644 +62 0

			@@ -0,0 +1,62
		1
		2	using System.Xml;
		3
		4	namespace Implab.Formats.JSON {
		5	/// <summary>
		6	/// Набор необязательных параметров для <see cref="JSONXmlReader"/>, позволяющий управлять процессом
		7	/// интерпретации <c>JSON</c> документа.
		8	/// </summary>
		9	public class JSONXmlReaderOptions {
		10	/// <summary>
		11	/// Пространство имен в котором будут располагаться читаемые элементы документа
		12	/// </summary>
		13	public string NamespaceURI {
		14	get;
		15	set;
		16	}
		17
		18	/// <summary>
		19	/// Интерпретировать массивы как множественные элементы (убирает один уровень вложенности), иначе массив
		20	/// представляется в виде узла, дочерними элементами которого являются элементы массива, имена дочерних элементов
		21	/// определяются свойством <see cref="ArrayItemName"/>. По умолчанию <c>false</c>.
		22	/// </summary>
		23	public bool FlattenArrays {
		24	get;
		25	set;
		26	}
		27
		28	/// <summary>
		29	/// Префикс, для узлов документа
		30	/// </summary>
		31	public string NodesPrefix {
		32	get;
		33	set;
		34	}
		35
		36	/// <summary>
		37	/// Имя корневого элемента в xml документе
		38	/// </summary>
		39	public string RootName {
		40	get;
		41	set;
		42	}
		43
		44	/// <summary>
		45	/// Имя элемента для массивов, если не включена опция <see cref="FlattenArrays"/>.
		46	/// По умолчанию <c>item</c>.
		47	/// </summary>
		48	public string ArrayItemName {
		49	get;
		50	set;
		51	}
		52
		53	/// <summary>
		54	/// Таблица атомизированных строк для построения документа.
		55	/// </summary>
		56	public XmlNameTable NameTable {
		57	get;
		58	set;
		59	}
		60
		61	}
		62	}

Implab/Formats/JSON/JsonTokenType.cs created 644 +44 0

			@@ -0,0 +1,44
		1	namespace Implab.Formats.JSON {
		2	/// <summary>
		3	/// Тип токенов, возвращаемых <see cref="JSONScanner"/>.
		4	/// </summary>
		5	public enum JsonTokenType : int {
		6	None = 0,
		7	/// <summary>
		8	/// Начало объекта
		9	/// </summary>
		10	BeginObject,
		11	/// <summary>
		12	/// Конец объекта
		13	/// </summary>
		14	EndObject,
		15	/// <summary>
		16	/// Начало массива
		17	/// </summary>
		18	BeginArray,
		19	/// <summary>
		20	/// Конец массива
		21	/// </summary>
		22	EndArray,
		23	/// <summary>
		24	/// Строка
		25	/// </summary>
		26	String,
		27	/// <summary>
		28	/// Число
		29	/// </summary>
		30	Number,
		31	/// <summary>
		32	/// Литерал
		33	/// </summary>
		34	Literal,
		35	/// <summary>
		36	/// Разделитель имени <c>:</c>
		37	/// </summary>
		38	NameSeparator,
		39	/// <summary>
		40	/// Разделитель имени <c>,</c>
		41	/// </summary>
		42	ValueSeparator
		43	}
		44	}

Implab/Formats/JSON/StringTranslator.cs created 644 +52 0

			@@ -0,0 +1,52
		1	using Implab;
		2	using Implab.Formats;
		3	using System;
		4	using System.Collections.Generic;
		5	using System.Diagnostics;
		6	using System.Linq;
		7	using System.Text;
		8	using System.Threading.Tasks;
		9
		10	namespace Implab.Formats.JSON {
		11	/// <summary>
		12	/// Класс для преобразования экранированной строки JSON
		13	/// </summary>
		14	static class StringTranslator {
		15	static readonly char[] _escMap;
		16	static readonly int[] _hexMap;
		17
		18	static StringTranslator() {
		19	var chars = new char[] { 'b', 'f', 't', 'r', 'n', '\\', '/' };
		20	var vals = new char[] { '\b', '\f', '\t', '\r', '\n', '\\', '/' };
		21
		22	_escMap = new char[chars.Max() + 1];
		23
		24	for (int i = 0; i < chars.Length; i++)
		25	_escMap[chars[i]] = vals[i];
		26
		27	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' };
		28	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 };
		29
		30	_hexMap = new int[hexs.Max() + 1];
		31
		32	for (int i = 0; i < hexs.Length; i++)
		33	_hexMap[hexs[i]] = ints[i];
		34
		35	}
		36
		37	internal static char TranslateEscapedChar(char symbol) {
		38	return _escMap[symbol];
		39	}
		40
		41	internal static char TranslateHexUnicode(char[] symbols, int offset) {
		42	Debug.Assert(symbols != null);
		43	Debug.Assert(symbols.Length - offset >= 4);
		44
		45	int value = (_hexMap[symbols[offset]] << 12)
		46	\| (_hexMap[symbols[offset + 1]] << 8)
		47	\| (_hexMap[symbols[offset + 2]] << 4)
		48	\| (_hexMap[symbols[offset + 3]]);
		49	return (char)value;
		50	}
		51	}
		52	}

Implab/Formats/ReaderScanner.cs created 644 +30 0

			@@ -0,0 +1,30
		1	using System;
		2	using System.IO;
		3
		4	namespace Implab.Formats {
		5	public class ReaderScanner: TextScanner {
		6	const int CHUNK_SIZE = 1024*4;
		7	const int BUFFER_MAX = CHUNK_SIZE*1024;
		8
		9	readonly TextReader m_reader;
		10
		11	public ReaderScanner(TextReader reader, int limit, int chunk) : base(limit, chunk) {
		12	Safe.ArgumentNotNull(reader, "reader");
		13	m_reader = reader;
		14	}
		15
		16	public ReaderScanner(TextReader reader) : this(reader, BUFFER_MAX, CHUNK_SIZE) {
		17	}
		18
		19	protected override int Read(char[] buffer, int offset, int size) {
		20	return m_reader.Read(buffer, offset, size);
		21	}
		22
		23	protected override void Dispose(bool disposing) {
		24	if (disposing)
		25	Safe.Dispose(m_reader);
		26	base.Dispose(disposing);
		27	}
		28	}
		29	}
		30

Implab/Formats/ScannerContext.cs created 644 +30 0

			@@ -0,0 +1,30
		1	namespace Implab.Formats {
		2	/// <summary>
		3	/// Represents a scanner configuration usefull to recongnize token, based on the DFA.
		4	/// </summary>
		5	public class ScannerContext<TTag> {
		6
		7	public int[,] Dfa { get; private set; }
		8
		9	public bool[] Final { get; private set; }
		10
		11	public TTag[][] Tags { get; private set; }
		12
		13	public int State { get; private set; }
		14
		15	public int[] Alphabet { get; private set; }
		16
		17	public ScannerContext(int[,] dfa, bool[] final, TTag[][] tags, int state, int[] alphabet) {
		18	Dfa = dfa;
		19	Final = final;
		20	Tags = tags;
		21	State = state;
		22	Alphabet = alphabet;
		23	}
		24
		25	public bool Execute(TextScanner scanner, out TTag[] tag) {
		26	return scanner.ReadToken(Dfa, Final, Tags, State, Alphabet, out tag);
		27	}
		28	}
		29	}
		30

Implab/Formats/StringScanner.cs created 644 +18 0

			@@ -0,0 +1,18
		1	using System;
		2
		3	namespace Implab.Formats {
		4	public class StringScanner: TextScanner {
		5	const int CHUNK_SIZE = 1024;
		6
		7	public StringScanner(string text) : base(null) {
		8	Safe.ArgumentNotNull(text, "text");
		9	var data = text.ToCharArray();
		10	Feed(data, 0, data.Length);
		11	}
		12
		13	protected override int Read(char[] buffer, int offset, int size) {
		14	return 0;
		15	}
		16	}
		17	}
		18

Implab/Formats/TextScanner.cs created 644 +157 0

			@@ -0,0 +1,157
		1	using System;
		2	using Implab.Components;
		3	using System.Diagnostics;
		4	using Implab.Automaton;
		5	using System.Text;
		6
		7	namespace Implab.Formats {
		8	public abstract class TextScanner : Disposable {
		9	readonly int m_bufferMax;
		10	readonly int m_chunkSize;
		11
		12	char[] m_buffer;
		13	int m_bufferOffset;
		14	int m_bufferSize;
		15	int m_tokenOffset;
		16	int m_tokenLength;
		17
		18	/// <summary>
		19	/// Initializes a new instance of the <see cref="Implab.Formats.TextScanner"/> class.
		20	/// </summary>
		21	/// <param name="bufferMax">Buffer max.</param>
		22	/// <param name="chunkSize">Chunk size.</param>
		23	protected TextScanner(int bufferMax, int chunkSize) {
		24	Debug.Assert(m_chunkSize <= m_bufferMax);
		25
		26	m_bufferMax = bufferMax;
		27	m_chunkSize = chunkSize;
		28	}
		29
		30	/// <summary>
		31	/// Initializes a new instance of the <see cref="Implab.Formats.TextScanner"/> class.
		32	/// </summary>
		33	/// <param name="buffer">Buffer.</param>
		34	protected TextScanner(char[] buffer) {
		35	if (buffer != null) {
		36	m_buffer = buffer;
		37	m_bufferSize = buffer.Length;
		38	}
		39	}
		40
		41	/// <summary>
		42	/// (hungry) Reads the next token.
		43	/// </summary>
		44	/// <returns><c>true</c>, if token internal was read, <c>false</c> if there is no more tokens in the stream.</returns>
		45	/// <param name="dfa">The transition map for the automaton</param>
		46	/// <param name="final">Final states of the automaton.</param>
		47	/// <param name="tags">Tags.</param>
		48	/// <param name="state">The initial state for the automaton.</param>
		49	/// <param name="alphabet"></param>
		50	/// <param name = "tag"></param>
		51	internal bool ReadToken<TTag>(int[,] dfa, bool[] final, TTag[][] tags, int state, int[] alphabet, out TTag[] tag) {
		52	m_tokenLength = 0;
		53	tag = null;
		54
		55	var maxSymbol = alphabet.Length - 1;
		56	int next;
		57	do {
		58	// after the next chunk is read the offset in the buffer may change
		59	int pos = m_bufferOffset + m_tokenLength;
		60	next = state;
		61	while (pos < m_bufferSize) {
		62	var ch = m_buffer[pos];
		63
		64	next = dfa[next, ch > maxSymbol ? AutomatonConst.UNCLASSIFIED_INPUT : alphabet[ch]];
		65
		66	if (next == AutomatonConst.UNREACHABLE_STATE)
		67	break;
		68
		69	state = next;
		70	pos++;
		71	}
		72	m_tokenLength = pos - m_bufferOffset;
		73	} while (next != AutomatonConst.UNREACHABLE_STATE && Feed());
		74
		75	m_tokenOffset = m_bufferOffset;
		76	m_bufferOffset += m_tokenLength;
		77
		78	if (final[state]) {
		79	tag = tags[state];
		80	return true;
		81	}
		82
		83	if (m_bufferOffset == m_bufferSize) {
		84	if (m_tokenLength == 0) //EOF
		85	return false;
		86
		87	throw new ParserException();
		88	}
		89
		90	throw new ParserException(String.Format("Unexpected symbol '{0}'", m_buffer[m_bufferOffset]));
		91
		92	}
		93
		94	protected void Feed(char[] buffer, int offset, int length) {
		95	m_buffer = buffer;
		96	m_bufferOffset = offset;
		97	m_bufferSize = offset + length;
		98	}
		99
		100	protected bool Feed() {
		101	if (m_chunkSize <= 0)
		102	return false;
		103
		104	if (m_buffer != null) {
		105	var free = m_buffer.Length - m_bufferSize;
		106
		107	if (free < m_chunkSize) {
		108	free += m_chunkSize;
		109	var used = m_bufferSize - m_bufferOffset;
		110	var size = used + free;
		111
		112	if (size > m_bufferMax)
		113	throw new ParserException(String.Format("The buffer limit ({0} Kb) is reached", m_bufferMax / 1024));
		114
		115	var temp = new char[size];
		116
		117	var read = Read(temp, used, m_chunkSize);
		118	if (read == 0)
		119	return false;
		120
		121	Array.Copy(m_buffer, m_bufferOffset, temp, 0, used);
		122
		123	m_bufferOffset = 0;
		124	m_bufferSize = used + read;
		125	m_buffer = temp;
		126	} else {
		127	var read = Read(m_buffer, m_bufferSize, m_chunkSize);
		128	if (read == 0)
		129	return false;
		130	m_bufferSize += m_chunkSize;
		131	}
		132	return true;
		133	} else {
		134	Debug.Assert(m_bufferOffset == 0);
		135	m_buffer = new char[m_chunkSize];
		136	m_bufferSize = Read(m_buffer, 0, m_chunkSize);
		137	return (m_bufferSize != 0);
		138	}
		139	}
		140
		141	protected abstract int Read(char[] buffer, int offset, int size);
		142
		143	public string GetTokenValue() {
		144	return new String(m_buffer, m_tokenOffset, m_tokenLength);
		145	}
		146
		147	public void CopyTokenTo(char[] buffer, int offset) {
		148	Array.Copy(m_buffer, m_tokenOffset,buffer, offset, m_tokenLength);
		149	}
		150
		151	public void CopyTokenTo(StringBuilder sb) {
		152	sb.Append(m_buffer, m_tokenOffset, m_tokenLength);
		153	}
		154
		155	}
		156	}
		157

MonoPlay/packages.config created 644 +4 0

			@@ -0,0 +1,4
		1	<?xml version="1.0" encoding="utf-8"?>
		2	<packages>
		3	<package id="System.Text.Json" version="2.0.0.11" targetFramework="net45" />
		4	</packages> No newline at end of file

packages/NUnit.2.6.4/NUnit.2.6.4.nupkg created 644 binary 0 0

NO CONTENT: new file 100644, binary diff hidden

packages/NUnit.2.6.4/lib/nunit.framework.dll created 644 binary 0 0

NO CONTENT: new file 100644, binary diff hidden

packages/NUnit.2.6.4/lib/nunit.framework.xml created 644 0 0

	1		NO CONTENT: new file 100644
The requested commit or file is too big and content was truncated. Show full diff

packages/NUnit.2.6.4/license.txt created 644 0 0

	1		NO CONTENT: new file 100644
The requested commit or file is too big and content was truncated. Show full diff

packages/System.Text.Json.2.0.0.11/System.Text.Json.2.0.0.11.nupkg created 644 binary 0 0

NO CONTENT: new file 100644, binary diff hidden

packages/System.Text.Json.2.0.0.11/lib/net40/System.Text.Json.dll created 644 binary 0 0

NO CONTENT: new file 100644, binary diff hidden

.hgignore +3 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/
+             *.suo

Implab.Test/Implab.Format.Test/Implab.Format.Test.csproj +8 -1

              <?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>
                  <ProductVersion>8.0.30703</ProductVersion>
                  <SchemaVersion>2.0</SchemaVersion>
                  <ProjectGuid>{4D364996-7ECD-4193-8F90-F223FFEA49DA}</ProjectGuid>
                  <OutputType>Library</OutputType>
                  <RootNamespace>Implab.Format.Test</RootNamespace>
                  <AssemblyName>Implab.Format.Test</AssemblyName>
                  <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
+                 <ReleaseVersion>0.2</ReleaseVersion>
                </PropertyGroup>
                <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
                  <DebugSymbols>true</DebugSymbols>
                  <DebugType>full</DebugType>
                  <Optimize>false</Optimize>
                  <OutputPath>bin\Debug</OutputPath>
                  <DefineConstants>DEBUG;</DefineConstants>
                  <ErrorReport>prompt</ErrorReport>
                  <WarningLevel>4</WarningLevel>
                  <ConsolePause>false</ConsolePause>
                </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>
                <ItemGroup>
                  <Reference Include="System" />
                  <Reference Include="nunit.framework">
-                   <HintPath>..\..\packages\NUnit.3.0.1\lib\net45\nunit.framework.dll</HintPath>
+                   <HintPath>..\..\packages\NUnit.2.6.4\lib\nunit.framework.dll</HintPath>
                  </Reference>
                </ItemGroup>
                <ItemGroup>
                  <Compile Include="JsonTests.cs" />
                </ItemGroup>
                <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
                <ItemGroup>
+                 <ProjectReference Include="..\..\Implab\Implab.csproj">
+                   <Project>{F550F1F8-8746-4AD0-9614-855F4C4B7F05}</Project>
+                   <Name>Implab</Name>
+                 </ProjectReference>
+               </ItemGroup>
+               <ItemGroup>
                  <None Include="packages.config" />
                </ItemGroup>
              </Project>
  No newline at end of file

Implab.Test/Implab.Format.Test/JsonTests.cs +79 -3

		@@ -1,12 +1,88
1	1	using NUnit.Framework;
2	2	using System;
	3	using Implab.Formats.JSON;
	4	using Implab.Automaton;
3	5
4	6	namespace Implab.Format.Test {
5		[TestFixture()]
	7	[TestFixture]
6	8	public class JsonTests {
7		[Test()]
8		public void Test~~Case~~() {
	9	[Test]
	10	public void TestScannerValidTokens() {
	11	using (var scanner = new JSONScanner(@"9123, -123, 0, 0.1, -0.2, -0.1e3, 1.3E-3, ""some \t\n\u0020 text"", literal []{}:")) {
	12
	13	Tuple<JsonTokenType,object>[] expexted = {
	14	new Tuple<JsonTokenType,object>(JsonTokenType.Number, 9123d),
	15	new Tuple<JsonTokenType,object>(JsonTokenType.ValueSeparator, ", "),
	16	new Tuple<JsonTokenType,object>(JsonTokenType.Number, -123d),
	17	new Tuple<JsonTokenType,object>(JsonTokenType.ValueSeparator, ", "),
	18	new Tuple<JsonTokenType,object>(JsonTokenType.Number, 0d),
	19	new Tuple<JsonTokenType,object>(JsonTokenType.ValueSeparator, ", "),
	20	new Tuple<JsonTokenType,object>(JsonTokenType.Number, 0.1d),
	21	new Tuple<JsonTokenType,object>(JsonTokenType.ValueSeparator, ", "),
	22	new Tuple<JsonTokenType,object>(JsonTokenType.Number, -0.2d),
	23	new Tuple<JsonTokenType,object>(JsonTokenType.ValueSeparator, ", "),
	24	new Tuple<JsonTokenType,object>(JsonTokenType.Number, -0.1e3d),
	25	new Tuple<JsonTokenType,object>(JsonTokenType.ValueSeparator, ", "),
	26	new Tuple<JsonTokenType,object>(JsonTokenType.Number, 1.3E-3d),
	27	new Tuple<JsonTokenType,object>(JsonTokenType.ValueSeparator, ", "),
	28	new Tuple<JsonTokenType,object>(JsonTokenType.String, "some \t\n text"),
	29	new Tuple<JsonTokenType,object>(JsonTokenType.ValueSeparator, ", "),
	30	new Tuple<JsonTokenType,object>(JsonTokenType.Literal, "literal"),
	31	new Tuple<JsonTokenType,object>(JsonTokenType.BeginArray, " ["),
	32	new Tuple<JsonTokenType,object>(JsonTokenType.EndArray, "]"),
	33	new Tuple<JsonTokenType,object>(JsonTokenType.BeginObject, "{"),
	34	new Tuple<JsonTokenType,object>(JsonTokenType.EndObject, "}"),
	35	new Tuple<JsonTokenType,object>(JsonTokenType.NameSeparator, ":")
	36	};
	37
	38	object value;
	39	JsonTokenType tokenType;
	40	for (var i = 0; i < expexted.Length; i++) {
	41
	42	Assert.IsTrue(scanner.ReadToken(out value, out tokenType));
	43	Assert.AreEqual(expexted[i].Item1, tokenType);
	44	Assert.AreEqual(expexted[i].Item2, value);
	45	}
	46
	47	Assert.IsFalse(scanner.ReadToken(out value, out tokenType));
	48	}
	49	}
	50
	51	[Test]
	52	public void TestScannerBadTokens() {
	53	var bad = new [] {
	54	" 1",
	55	" literal",
	56	" \"",
	57	"\"unclosed string",
	58	"1.bad",
	59	"001", // should be read as three numbers
	60	"--10",
	61	"+10",
	62	"1.0.0",
	63	"1e1.0",
	64	"l1teral0",
	65	".123",
	66	"-.123"
	67	};
	68
	69	foreach (var json in bad)
	70	using (var scanner = new JSONScanner(json)) {
	71	try {
	72	object value;
	73	JsonTokenType token;
	74	scanner.ReadToken(out value, out token);
	75	if (!Object.Equals(value,json)) {
	76	Console.WriteLine("'{0}' is read as {1}", json, value is String ? String.Format("'{0}'", value) : value );
	77	continue;
	78	}
	79	Assert.Fail("Token '{0}' shouldn't pass", json);
	80	} catch (ParserException e) {
	81	Console.WriteLine(e.Message);
	82	}
	83	}
	84
9	85	}
10	86	}
11	87	}
12	88

Implab.Test/Implab.Format.Test/packages.config +1 -1

              <?xml version="1.0" encoding="utf-8"?>
              <packages>
-               <package id="NUnit" version="3.0.1" targetFramework="net45" />
+               <package id="NUnit" version="2.6.4" targetFramework="net45" />
              </packages>
  No newline at end of file

Implab.Test/Implab.Test.csproj +2 0

              <?xml version="1.0" encoding="utf-8"?>
              <Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
                <PropertyGroup>
                  <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
                  <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
                  <ProductVersion>8.0.30703</ProductVersion>
                  <SchemaVersion>2.0</SchemaVersion>
                  <ProjectGuid>{63F92C0C-61BF-48C0-A377-8D67C3C661D0}</ProjectGuid>
                  <OutputType>Library</OutputType>
                  <AppDesignerFolder>Properties</AppDesignerFolder>
                  <RootNamespace>Implab.Test</RootNamespace>
                  <AssemblyName>Implab.Test</AssemblyName>
                  <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
                  <FileAlignment>512</FileAlignment>
                  <ProjectTypeGuids>{3AC096D0-A1C2-E12C-1390-A8335801FDAB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
                  <TargetFrameworkProfile />
                </PropertyGroup>
                <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
                  <DebugSymbols>true</DebugSymbols>
                  <DebugType>full</DebugType>
                  <Optimize>false</Optimize>
                  <OutputPath>bin\Debug\</OutputPath>
                  <DefineConstants>DEBUG;TRACE</DefineConstants>
                  <ErrorReport>prompt</ErrorReport>
                  <WarningLevel>4</WarningLevel>
                  <Prefer32Bit>false</Prefer32Bit>
                </PropertyGroup>
                <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
                  <DebugType>pdbonly</DebugType>
                  <Optimize>true</Optimize>
                  <OutputPath>bin\Release\</OutputPath>
                  <DefineConstants>TRACE</DefineConstants>
                  <ErrorReport>prompt</ErrorReport>
                  <WarningLevel>4</WarningLevel>
                  <Prefer32Bit>false</Prefer32Bit>
                </PropertyGroup>
                <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug 4.5|AnyCPU' ">
                  <DebugSymbols>true</DebugSymbols>
                  <DebugType>full</DebugType>
                  <Optimize>false</Optimize>
                  <OutputPath>bin\Debug\</OutputPath>
                  <DefineConstants>DEBUG;TRACE</DefineConstants>
                  <ErrorReport>prompt</ErrorReport>
                  <WarningLevel>4</WarningLevel>
                  <Prefer32Bit>false</Prefer32Bit>
                </PropertyGroup>
                <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release 4.5|AnyCPU' ">
                  <DebugType>pdbonly</DebugType>
                  <Optimize>true</Optimize>
                  <OutputPath>bin\Release\</OutputPath>
                  <DefineConstants>TRACE</DefineConstants>
                  <ErrorReport>prompt</ErrorReport>
                  <WarningLevel>4</WarningLevel>
                  <Prefer32Bit>false</Prefer32Bit>
                </PropertyGroup>
                <ItemGroup>
                  <Reference Include="Microsoft.VisualStudio.QualityTools.UnitTestFramework, Version=10.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL" />
                  <Reference Include="System" />
                  <Reference Include="System.Core">
                    <RequiredTargetFramework>3.5</RequiredTargetFramework>
                  </Reference>
                </ItemGroup>
                <ItemGroup>
                  <Compile Include="AsyncTests.cs" />
+                 <Compile Include="CancelationTests.cs" />
                  <Compile Include="PromiseHelper.cs" />
                  <Compile Include="Properties\AssemblyInfo.cs" />
+                 <Compile Include="RunnableComponentTests.cs" />
                </ItemGroup>
                <ItemGroup>
                  <ProjectReference Include="..\Implab\Implab.csproj">
                    <Project>{99B95D0D-9CF9-4F70-8ADF-F4D0AA5CB0D9}</Project>
                    <Name>Implab</Name>
                  </ProjectReference>
                </ItemGroup>
                <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
                <!-- To modify your build process, add your task inside one of the targets below and uncomment it.
                     Other similar extension points exist, see Microsoft.Common.targets.
                <Target Name="BeforeBuild">
                </Target>
                <Target Name="AfterBuild">
                </Target>
                -->
              </Project>
  No newline at end of file

Implab.Test/Implab.Test.mono.csproj +1 0

              <?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>
                  <ProductVersion>8.0.30703</ProductVersion>
                  <SchemaVersion>2.0</SchemaVersion>
                  <ProjectGuid>{2BD05F84-E067-4B87-9477-FDC2676A21C6}</ProjectGuid>
                  <OutputType>Library</OutputType>
                  <RootNamespace>Implab.Test</RootNamespace>
                  <AssemblyName>Implab.Test</AssemblyName>
                  <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
                  <ReleaseVersion>0.2</ReleaseVersion>
                </PropertyGroup>
                <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
                  <DebugSymbols>true</DebugSymbols>
                  <DebugType>full</DebugType>
                  <Optimize>false</Optimize>
                  <OutputPath>bin\Debug</OutputPath>
                  <DefineConstants>DEBUG;MONO</DefineConstants>
                  <ErrorReport>prompt</ErrorReport>
                  <WarningLevel>4</WarningLevel>
                  <ConsolePause>false</ConsolePause>
                </PropertyGroup>
                <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
                  <Optimize>true</Optimize>
                  <OutputPath>bin\Release</OutputPath>
                  <ErrorReport>prompt</ErrorReport>
                  <WarningLevel>4</WarningLevel>
                  <ConsolePause>false</ConsolePause>
                  <DefineConstants>MONO</DefineConstants>
                </PropertyGroup>
                <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug 4.5|AnyCPU' ">
                  <DebugSymbols>true</DebugSymbols>
                  <DebugType>full</DebugType>
                  <Optimize>false</Optimize>
                  <OutputPath>bin\Debug</OutputPath>
                  <DefineConstants>DEBUG;TRACE;NET_4_5;MONO</DefineConstants>
                  <ErrorReport>prompt</ErrorReport>
                  <WarningLevel>4</WarningLevel>
                  <ConsolePause>false</ConsolePause>
                </PropertyGroup>
                <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release 4.5|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="nunit.framework" />
                </ItemGroup>
                <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
                <ItemGroup>
                  <Compile Include="AsyncTests.cs" />
                  <Compile Include="PromiseHelper.cs" />
                  <Compile Include="Properties\AssemblyInfo.cs" />
                  <Compile Include="CancelationTests.cs" />
+                 <Compile Include="RunnableComponentTests.cs" />
                </ItemGroup>
                <ItemGroup>
                  <ProjectReference Include="..\Implab\Implab.csproj">
                    <Project>{F550F1F8-8746-4AD0-9614-855F4C4B7F05}</Project>
                    <Name>Implab</Name>
                  </ProjectReference>
                </ItemGroup>
              </Project>
  No newline at end of file

Implab/AbstractEvent.cs +5 -9

              using System;
              using Implab.Parallels;
              using System.Threading;
              using System.Reflection;
              namespace Implab {
                  public abstract class AbstractEvent<THandler> : ICancellationToken, ICancellable {
                      const int UNRESOLVED_SATE = 0;
                      const int TRANSITIONAL_STATE = 1;
                      protected const int SUCCEEDED_STATE = 2;
                      protected const int REJECTED_STATE = 3;
                      protected const int CANCELLED_STATE = 4;
                      const int CANCEL_NOT_REQUESTED = 0;
                      const int CANCEL_REQUESTING = 1;
                      const int CANCEL_REQUESTED = 2;
                      const int RESERVED_HANDLERS_COUNT = 4;
                      int m_state;
                      Exception m_error;
                      int m_handlersCount;
                      //readonly THandler[] m_handlers = new THandler[RESERVED_HANDLERS_COUNT];
                      THandler[] m_handlers;
                      MTQueue<THandler> m_extraHandlers;
                      int m_handlerPointer = -1;
                      int m_handlersCommited;
                      int m_cancelRequest;
                      Exception m_cancelationReason;
                      MTQueue<Action<Exception>> m_cancelationHandlers;
                      #region state managment
                      bool BeginTransit() {
                          return UNRESOLVED_SATE == Interlocked.CompareExchange(ref m_state, TRANSITIONAL_STATE, UNRESOLVED_SATE);
                      }
                      void CompleteTransit(int state) {
                          if (TRANSITIONAL_STATE != Interlocked.CompareExchange(ref m_state, state, TRANSITIONAL_STATE))
                              throw new InvalidOperationException("Can't complete transition when the object isn't in the transitional state");
                      }
                      void WaitTransition() {
                          while (m_state == TRANSITIONAL_STATE) {
                              Thread.MemoryBarrier();
                          }
                      }
                      protected bool BeginSetResult() {
                          if (!BeginTransit()) {
                              WaitTransition();
                              if (m_state != CANCELLED_STATE)
                                  throw new InvalidOperationException("The promise is already resolved");
                              return false;
                          }
                          return true;
                      }
                      protected void EndSetResult() {
                          CompleteTransit(SUCCEEDED_STATE);
                          Signal();
                      }
                      /// <summary>
                      /// Выполняет обещание, сообщая об ошибке
                      /// </summary>
                      /// <remarks>
                      /// Поскольку обещание должно работать в многопточной среде, при его выполнении сразу несколько потоков
                      /// могу вернуть ошибку, при этом только первая будет использована в качестве результата, остальные
                      /// будут проигнорированы.
                      /// </remarks>
                      /// <param name="error">Исключение возникшее при выполнении операции</param>
                      /// <exception cref="InvalidOperationException">Данное обещание уже выполнено</exception>
                      protected void SetError(Exception error) {
                          if (BeginTransit()) {
-                             if (error is OperationCanceledException) {
-                                 m_error = error.InnerException;
-                                 CompleteTransit(CANCELLED_STATE);
-                             } else {
-                                 m_error = error is PromiseTransientException ? error.InnerException : error;
-                                 CompleteTransit(REJECTED_STATE);
+                             }
+                             m_error = error;
+                             CompleteTransit(REJECTED_STATE);
                              Signal();
                          } else {
                              WaitTransition();
                              if (m_state == SUCCEEDED_STATE)
                                  throw new InvalidOperationException("The promise is already resolved");
                          }
                      }
                      /// <summary>
                      /// Отменяет операцию, если это возможно.
                      /// </summary>
                      /// <remarks>Для определения была ли операция отменена следует использовать свойство <see cref="IsCancelled"/>.</remarks>
                      protected void SetCancelled(Exception reason) {
                          if (BeginTransit()) {
                              m_error = reason;
                              CompleteTransit(CANCELLED_STATE);
                              Signal();
                          }
                      }
                      protected abstract void SignalHandler(THandler handler, int signal);
                      void Signal() {
                          var hp = m_handlerPointer;
                          var slot = hp +1 ;
                          while (slot < m_handlersCommited) {
                              if (Interlocked.CompareExchange(ref m_handlerPointer, slot, hp) == hp) {
                                  SignalHandler(m_handlers[slot], m_state);
                              }
                              hp = m_handlerPointer;
                              slot = hp +1 ;
                          }
                          if (m_extraHandlers != null) {
                              THandler handler;
                              while (m_extraHandlers.TryDequeue(out handler))
                                  SignalHandler(handler, m_state);
                          }
                      }
                      #endregion
                      protected abstract Signal GetResolveSignal();
                      #region synchronization traits
                      protected void WaitResult(int timeout) {
                          if (!(IsResolved || GetResolveSignal().Wait(timeout)))
                              throw new TimeoutException();
                          switch (m_state) {
                              case SUCCEEDED_STATE:
                                  return;
                              case CANCELLED_STATE:
-                                 throw new OperationCanceledException();
+                                 throw new OperationCanceledException("The operation has been cancelled", m_error);
                              case REJECTED_STATE:
                                  throw new TargetInvocationException(m_error);
                              default:
-                                 throw new ApplicationException(String.Format("Invalid promise state {0}", m_state));
+                                 throw new ApplicationException(String.Format("The promise state {0} is invalid", m_state));
                          }
                      }
                      #endregion
                      #region handlers managment
                      protected void AddHandler(THandler handler) {
                          if (m_state > 1) {
                              // the promise is in the resolved state, just invoke the handler
                              SignalHandler(handler, m_state);
                          } else {
                              var slot = Interlocked.Increment(ref m_handlersCount) - 1;
                              if (slot < RESERVED_HANDLERS_COUNT) {
                                  if (slot == 0) {
                                      m_handlers = new THandler[RESERVED_HANDLERS_COUNT];
                                  } else {
                                      while (m_handlers == null)
                                          Thread.MemoryBarrier();
                                  }
                                  m_handlers[slot] = handler;
                                  while (slot != Interlocked.CompareExchange(ref m_handlersCommited, slot + 1, slot)) {
                                  }
                                  if (m_state > 1) {
                                      do {
                                          var hp = m_handlerPointer;
                                          slot = hp + 1;
                                          if (slot < m_handlersCommited) {
                                              if (Interlocked.CompareExchange(ref m_handlerPointer, slot, hp) != hp)
                                                  continue;
                                              SignalHandler(m_handlers[slot], m_state);
                                          }
                                          break;
                                      } while(true);
                                  }
                              } else {
                                  if (slot == RESERVED_HANDLERS_COUNT) {
                                      m_extraHandlers = new MTQueue<THandler>();
                                  } else {
                                      while (m_extraHandlers == null)
                                          Thread.MemoryBarrier();
                                  }
                                  m_extraHandlers.Enqueue(handler);
                                  if (m_state > 1 && m_extraHandlers.TryDequeue(out handler))
                                  // if the promise have been resolved while we was adding the handler to the queue
                                  // we can't guarantee that someone is still processing it
                                  // therefore we need to fetch a handler from the queue and execute it
                                  // note that fetched handler may be not the one that we have added
                                  // even we can fetch no handlers at all :)
                                      SignalHandler(handler, m_state);
                              }
                          }
                      }
                      #endregion
                      #region IPromise implementation
                      public bool IsResolved {
                          get {
                              Thread.MemoryBarrier();
                              return m_state > 1;
                          }
                      }
                      public bool IsCancelled {
                          get {
                              Thread.MemoryBarrier();
                              return m_state == CANCELLED_STATE;
                          }
                      }
                      #endregion
                      public Exception Error {
                          get {
                              return m_error;
                          }
                      }
                      public bool CancelOperationIfRequested() {
                          if (IsCancellationRequested) {
                              CancelOperation(CancellationReason);
                              return true;
                          }
                          return false;
                      }
                      public virtual void CancelOperation(Exception reason) {
                          SetCancelled(reason);
                      }
                      public void CancellationRequested(Action<Exception> handler) {
                          Safe.ArgumentNotNull(handler, "handler");
                          if (IsCancellationRequested)
                              handler(CancellationReason);
                          if (m_cancelationHandlers == null)
                              Interlocked.CompareExchange(ref m_cancelationHandlers, new MTQueue<Action<Exception>>(), null);
                          m_cancelationHandlers.Enqueue(handler);
                          if (IsCancellationRequested && m_cancelationHandlers.TryDequeue(out handler))
                              // TryDeque implies MemoryBarrier()
                              handler(m_cancelationReason);
                      }
                      public bool IsCancellationRequested {
                          get {
                              do {
                                  if (m_cancelRequest == CANCEL_NOT_REQUESTED)
                                      return false;
                                  if (m_cancelRequest == CANCEL_REQUESTED)
                                      return true;
                                  Thread.MemoryBarrier();
                              } while(true);
                          }
                      }
                      public Exception CancellationReason {
                          get {
                              do {
                                  Thread.MemoryBarrier();
                              } while(m_cancelRequest == CANCEL_REQUESTING);
                              return m_cancelationReason;
                          }
                      }
                      #region ICancellable implementation
                      public void Cancel() {
                          Cancel(null);
                      }
                      public void Cancel(Exception reason) {
                          if (CANCEL_NOT_REQUESTED == Interlocked.CompareExchange(ref m_cancelRequest, CANCEL_REQUESTING, CANCEL_NOT_REQUESTED)) {
                              m_cancelationReason = reason;
                              m_cancelRequest = CANCEL_REQUESTED;
                              if (m_cancelationHandlers != null) {
                                  Action<Exception> handler;
                                  while (m_cancelationHandlers.TryDequeue(out handler))
                                      handler(m_cancelationReason);
                              }
                          }
                      }
                      #endregion
                  }
              }

Implab/AbstractPromise.cs +2 -2

              using System;
              using Implab.Parallels;
              namespace Implab {
                  public abstract class AbstractPromise : AbstractEvent<AbstractPromise.HandlerDescriptor>, IPromise {
                      public struct HandlerDescriptor {
                          readonly Action m_handler;
                          readonly Action<Exception> m_error;
                          readonly Action<Exception> m_cancel;
                          readonly PromiseEventType m_mask;
                          public HandlerDescriptor(Action success, Action<Exception> error, Action<Exception> cancel) {
                              m_handler = success;
                              m_error = error;
                              m_cancel = cancel;
                              m_mask = PromiseEventType.Success;
                          }
                          public HandlerDescriptor(Action handler, PromiseEventType mask) {
                              m_handler = handler;
                              m_error = null;
                              m_cancel = null;
                              m_mask = mask;
                          }
                          public void SignalSuccess() {
                              if ((m_mask & PromiseEventType.Success) != 0 && m_handler != null) {
                                  try {
                                      m_handler();
                                  } catch (Exception err) {
                                      // avoid calling handler twice in case of error
                                      if (m_error != null)
                                          SignalError(err);
                                  }
                              }
                          }
                          public void SignalError(Exception err) {
                              if (m_error != null) {
                                  try {
                                      m_error(err);
                                      // Analysis disable once EmptyGeneralCatchClause
                                  } catch {
                                  }
                              } else if ((m_mask & PromiseEventType.Error ) != 0 && m_handler != null) {
                                  try {
                                      m_handler();
                                      // Analysis disable once EmptyGeneralCatchClause
                                  } catch {
                                  }
                              }
                          }
                          public void SignalCancel(Exception reason) {
                              if (m_cancel != null) {
                                  try {
                                      m_cancel(reason);
                                  } catch (Exception err) {
                                      SignalError(err);
                                  }
                              } else if ( (m_mask & PromiseEventType.Cancelled) != 0 && m_handler != null) {
                                  try {
                                      m_handler();
                                      // Analysis disable once EmptyGeneralCatchClause
                                  } catch {
                                  }
                              }
                          }
                      }
                      #region implemented abstract members of AbstractPromise
                      protected override void SignalHandler(HandlerDescriptor handler, int signal) {
                          switch (signal) {
                              case SUCCEEDED_STATE:
                                  handler.SignalSuccess();
                                  break;
                              case REJECTED_STATE:
                                  handler.SignalError(Error);
                                  break;
                              case CANCELLED_STATE:
                                  handler.SignalCancel(CancellationReason);
                                  break;
                              default:
                                  throw new InvalidOperationException(String.Format("Invalid promise signal: {0}", signal));
                          }
                      }
                      protected override Signal GetResolveSignal() {
                          var signal = new Signal();
                          On(signal.Set, PromiseEventType.All);
                          return signal;
                      }
                      #endregion
                      public Type PromiseType {
                          get {
                              return typeof(void);
                          }
                      }
                      public IPromise On(Action success, Action<Exception> error, Action<Exception> cancel) {
                          AddHandler(new HandlerDescriptor(success, error, cancel));
                          return this;
                      }
                      public IPromise On(Action success, Action<Exception> error) {
                          AddHandler(new HandlerDescriptor(success, error, null));
                          return this;
                      }
                      public IPromise On(Action success) {
                          AddHandler(new HandlerDescriptor(success, null, null));
                          return this;
                      }
                      public IPromise On(Action handler, PromiseEventType events) {
                          AddHandler(new HandlerDescriptor(handler,events));
                          return this;
                      }
                      public IPromise<T> Cast<T>() {
                          throw new InvalidCastException();
                      }
                      public void Join() {
                          WaitResult(-1);
                      }
                      public void Join(int timeout) {
                          WaitResult(timeout);
                      }
                      protected void SetResult() {
-                         BeginSetResult();
-                         EndSetResult();
+                         if(BeginSetResult())
+                             EndSetResult();
                      }
                  }
              }

Implab/ActionChainTask.cs +12 -1

              using System;
              namespace Implab {
                  public class ActionChainTask : ActionChainTaskBase, IDeferred {
                      readonly Func<IPromise> m_task;
+                     /// <summary>
+                     /// Initializes a new instance of the <see cref="Implab.ActionChainTask"/> class.
+                     /// </summary>
+                     /// <param name="task">The operation which will be performed when the <see cref="Resolve()"/> is called.</param>
+                     /// <param name="error">The error handler which will invoke when the <see cref="Reject(Exception)"/> is called or when the task fails with an error.</param>
+                     /// <param name="cancel">The cancellation handler.</param>
+                     /// <param name="autoCancellable">If set to <c>true</c> will automatically accept
+                     ///  all cancel requests before the task is started with <see cref="Resolve()"/>,
+                     /// after that all requests are directed to the task.</param>
                      public ActionChainTask(Func<IPromise> task, Func<Exception, IPromise> error, Func<Exception, IPromise> cancel, bool autoCancellable) : base(error,cancel, autoCancellable) {
                          m_task = task;
                      }
                      public void Resolve() {
                          if (m_task != null && LockCancelation()) {
                              try {
                                  var p = m_task();
-                                 p.On(SetResult, HandleErrorInternal, SetCancelled);
+                                 p.On(SetResult, HandleErrorInternal, HandleCancelInternal);
                                  CancellationRequested(p.Cancel);
+                             } catch (OperationCanceledException reason){
+                                 HandleCancelInternal(reason);
                              } catch(Exception err) {
                                  HandleErrorInternal(err);
                              }
                          }
                      }
                  }
              }

Implab/ActionChainTaskBase.cs +24 -20

              using System;
              using System.Threading;
              namespace Implab {
-                 public class ActionChainTaskBase : AbstractPromise {
+                 public class ActionChainTaskBase : AbstractTask {
                      readonly Func<Exception, IPromise> m_error;
                      readonly Func<Exception, IPromise> m_cancel;
-                     int m_cancelationLock;
                      protected ActionChainTaskBase(Func<Exception, IPromise> error, Func<Exception, IPromise> cancel, bool autoCancellable) {
                          m_error = error;
                          m_cancel = cancel;
                          if (autoCancellable)
                              CancellationRequested(CancelOperation);
                      }
                      public void Reject(Exception error) {
                          if (LockCancelation())
                              HandleErrorInternal(error);
                      }
+                     public override void CancelOperation(Exception reason) {
+                         if (LockCancelation())
+                             // отмена вызвана до начала выполнения задачи
+                             HandleCancelInternal(reason);
+                     }
-                     public override void CancelOperation(Exception reason) {
-                         if (LockCancelation()) {
-                             if (m_cancel != null) {
-                                 try {
-                                     m_cancel(reason).On(SetResult, SetError, SetCancelled);
-                                 } catch (Exception err) {
-                                     HandleErrorInternal(err);
+                                 }
-                             } else {
-                                 SetCancelled(reason);
+                     protected void HandleCancelInternal(Exception reason) {
+                         if (m_cancel != null) {
+                             try {
+                                 // вызываем обработчик отмены
+                                 var p = m_cancel(reason);
+                                 p.On(SetResult, HandleErrorInternal, SetCancelledInternal);
+                                 // сообщаем асинхронной операции, что клиент уже не хочет получать результат
+                                 // т.е. если он инициировал отмену, задача отменилась, вызвался обрабочик отмены
+                                 // отбработчику сообщили, что результат уже не нужен и уже сам обработчик решает
+                                 // отдавать ли результат или подтвердить отмену (или вернуть ошибку).
+                                 CancellationRequested(p.Cancel);
+                             } catch (Exception err) {
+                                 HandleErrorInternal(err);
                              }
+                         } else {
+                             HandleErrorInternal(reason ?? new OperationCanceledException());
                          }
                      }
                      protected void HandleErrorInternal(Exception error) {
                          if (m_error != null) {
                              try {
                                  var p = m_error(error);
-                                 p.On(SetResult,SetError,SetCancelled);
+                                 p.On(SetResult, SetErrorInternal, SetCancelledInternal);
                                  CancellationRequested(p.Cancel);
                              } catch (Exception err) {
-                                 SetError(err);
+                                 SetErrorInternal(error);
                              }
                          } else {
-                             SetError(error);
+                             SetErrorInternal(error);
                          }
                      }
-                     protected bool LockCancelation() {
-                         return 0 == Interlocked.CompareExchange(ref m_cancelationLock, 1, 0);
+                     }
                  }
              }

Implab/ActionChainTaskT.cs +3 -1

              using System;
              namespace Implab {
                  public class ActionChainTask<T> : ActionChainTaskBase, IDeferred<T> {
                      readonly Func<T, IPromise> m_task;
                      public ActionChainTask(Func<T, IPromise> task, Func<Exception, IPromise> error, Func<Exception, IPromise> cancel, bool autoCancellable) : base(error,cancel, autoCancellable) {
                          m_task = task;
                      }
                      public void Resolve(T value) {
                          if (m_task != null && LockCancelation()) {
                              try {
                                  var p = m_task(value);
-                                 p.On(SetResult, HandleErrorInternal, SetCancelled);
+                                 p.On(SetResult, HandleErrorInternal, HandleCancelInternal);
                                  CancellationRequested(p.Cancel);
+                             } catch (OperationCanceledException reason) {
+                                 HandleCancelInternal(reason);
                              } catch(Exception err) {
                                  HandleErrorInternal(err);
                              }
                          }
                      }
                  }
              }

Implab/ActionTask.cs +2 0

              using System;
              namespace Implab {
                  public class ActionTask : ActionTaskBase, IDeferred {
                      readonly Action m_task;
                      public ActionTask(Action task, Action<Exception> error, Action<Exception> cancel, bool autoCancellable) : base(error,cancel, autoCancellable) {
                          m_task = task;
                      }
                      public void Resolve() {
                          if (m_task != null && LockCancelation()) {
                              try {
                                  m_task();
                                  SetResult();
+                             } catch(OperationCanceledException reason) {
+                                 HandleCancelInternal(reason);
                              } catch(Exception err) {
                                  HandleErrorInternal(err);
                              }
                          }
                      }
                  }
              }

Implab/ActionTaskBase.cs +17 -21

              using System;
-             using System.Threading;
              namespace Implab {
-                 public class ActionTaskBase : AbstractPromise {
+                 public class ActionTaskBase : AbstractTask {
                      readonly Action<Exception> m_cancel;
                      readonly Action<Exception> m_error;
-                     int m_cancelationLock;
                      protected ActionTaskBase( Action<Exception> error, Action<Exception> cancel, bool autoCancellable) {
                          m_error = error;
                          m_cancel = cancel;
                          if (autoCancellable)
                              CancellationRequested(CancelOperation);
                      }
                      public void Reject(Exception error) {
                          Safe.ArgumentNotNull(error, "error");
                          if (LockCancelation())
                              HandleErrorInternal(error);
                      }
+                     public override void CancelOperation(Exception reason) {
+                         if (LockCancelation())
+                             HandleCancelInternal(reason);
+                     }
                      protected void HandleErrorInternal(Exception error) {
                          if (m_error != null) {
                              try {
                                  m_error(error);
                                  SetResult();
                              } catch(Exception err) {
-                                 SetError(err);
+                                 SetErrorInternal(err);
                              }
                          } else {
-                             SetError(error);
+                             SetErrorInternal(error);
                          }
                      }
-                     public override void CancelOperation(Exception reason) {
-                         if (LockCancelation()) {
-                             if (m_cancel != null) {
-                                 try {
-                                     m_cancel(reason);
-                                     SetResult();
-                                 } catch (Exception err) {
-                                     HandleErrorInternal(err);
+                                 }
-                             } else {
-                                 SetCancelled(reason);
+                     protected void HandleCancelInternal(Exception error) {
+                         if (m_cancel != null) {
+                             try {
+                                 m_cancel(error);
+                                 SetResult();
+                             } catch(Exception err) {
+                                 HandleErrorInternal(err);
                              }
+                         } else {
+                             HandleErrorInternal(error ?? new OperationCanceledException());
                          }
                      }
-                     protected bool LockCancelation() {
-                         return 0 == Interlocked.CompareExchange(ref m_cancelationLock, 1, 0);
+                     }
                  }
              }

Implab/ActionTaskT.cs +2 0

              using System;
              namespace Implab {
                  public class ActionTask<T> : ActionTaskBase, IDeferred<T> {
                      readonly Action<T> m_task;
                      public ActionTask(Action<T> task, Action<Exception> error, Action<Exception> cancel, bool autoCancellable) : base(error,cancel, autoCancellable) {
                          m_task = task;
                      }
                      public void Resolve(T value) {
                          if (m_task != null && LockCancelation()) {
                              try {
                                  m_task(value);
                                  SetResult();
+                             } catch(OperationCanceledException reason) {
+                                 HandleCancelInternal(reason);
                              } catch(Exception err) {
                                  HandleErrorInternal(err);
                              }
                          }
                      }
                  }
              }

Implab/Components/ExecutionState.cs +14 -4

              namespace Implab.Components {
                  public enum ExecutionState {
-                     Reserved = 0,
-                     Uninitialized,
+                     Undefined = 0,
+                     Created,
+                     Initializing,
                      Ready,
                      Starting,
                      Running,
                      Stopping,
-                     Stopped,
+                     Failed,
                      Disposed,
-                     Failed
+                     Last = Disposed
                  }
              }
  No newline at end of file

Implab/Components/IInitializable.cs +1 -1

              using System;
              namespace Implab.Components {
                  /// <summary>
                  /// Initializable components are created and initialized in two steps, first we have create the component,
                  /// then we have to complete it's creation by calling an <see cref="Init()"/> method. All parameters needed
                  /// to complete the initialization must be passed before the calling <see cref="Init()"/>
                  /// </summary>
                  public interface IInitializable {
                      /// <summary>
                      /// Completes initialization.
                      /// </summary>
                      /// <remarks>
-                     /// Normally virtual shouldn't be called from the constructor, due to the incomplete object state, but
+                     /// Normally virtual methods shouldn't be called from the constructor, due to the incomplete object state, but
                      /// they can be called from this method. This method is also usefull when we constructing a complex grpah
                      /// of components where cyclic references may take place.
                      /// </remarks>
                      void Init();
                  }
              }

Implab/Components/RunnableComponent.cs +210 -11

		@@ -1,58 +1,257
1	1	using System;
2		using Implab.Parsing;
3	2
4	3	namespace Implab.Components {
5		public class RunnableComponent : Disposable, IRunnable, IInitializable {
6
	4	public abstract class RunnableComponent : IDisposable, IRunnable, IInitializable {
	5	enum Commands {
	6	Ok = 0,
	7	Fail,
	8	Init,
	9	Start,
	10	Stop,
	11	Dispose,
	12	Last = Dispose
	13	}
	14
	15	class StateMachine {
	16	static readonly ExecutionState[,] _transitions;
	17
	18	static StateMachine() {
	19	_transitions = new ExecutionState[(int)ExecutionState.Last + 1, (int)Commands.Last + 1];
	20
	21	Edge(ExecutionState.Created, ExecutionState.Initializing, Commands.Init);
	22	Edge(ExecutionState.Created, ExecutionState.Disposed, Commands.Dispose);
	23
	24	Edge(ExecutionState.Initializing, ExecutionState.Ready, Commands.Ok);
	25	Edge(ExecutionState.Initializing, ExecutionState.Failed, Commands.Fail);
	26
	27	Edge(ExecutionState.Ready, ExecutionState.Starting, Commands.Start);
	28	Edge(ExecutionState.Ready, ExecutionState.Disposed, Commands.Dispose);
	29
	30	Edge(ExecutionState.Starting, ExecutionState.Running, Commands.Ok);
	31	Edge(ExecutionState.Starting, ExecutionState.Failed, Commands.Fail);
	32	Edge(ExecutionState.Starting, ExecutionState.Stopping, Commands.Stop);
	33	Edge(ExecutionState.Starting, ExecutionState.Disposed, Commands.Dispose);
7	34
	35	Edge(ExecutionState.Running, ExecutionState.Failed, Commands.Fail);
	36	Edge(ExecutionState.Running, ExecutionState.Stopping, Commands.Stop);
	37	Edge(ExecutionState.Running, ExecutionState.Disposed, Commands.Dispose);
8	38
	39	Edge(ExecutionState.Stopping, ExecutionState.Failed, Commands.Fail);
	40	Edge(ExecutionState.Stopping, ExecutionState.Disposed, Commands.Ok);
	41
	42	Edge(ExecutionState.Failed, ExecutionState.Disposed, Commands.Dispose);
	43	}
	44
	45	static void Edge(ExecutionState s1, ExecutionState s2, Commands cmd) {
	46	_transitions[(int)s1, (int)cmd] = s2;
	47	}
9	48
10
	49	public ExecutionState State {
	50	get;
	51	private set;
	52	}
	53
	54	public StateMachine(ExecutionState initial) {
	55	State = initial;
	56	}
	57
	58	public bool Move(Commands cmd) {
	59	var next = _transitions[(int)State, (int)cmd];
	60	if (next == ExecutionState.Undefined)
	61	return false;
	62	State = next;
	63	return true;
	64	}
	65	}
	66
11	67	IPromise m_pending;
12	68	Exception m_lastError;
13	69
	70	readonly StateMachine m_stateMachine;
	71
14	72	protected RunnableComponent(bool initialized) {
	73	m_stateMachine = new StateMachine(initialized ? ExecutionState.Ready : ExecutionState.Created);
	74	}
	75
	76	protected virtual int DisposeTimeout {
	77	get {
	78	return 10000;
	79	}
	80	}
	81
	82	void ThrowInvalidCommand(Commands cmd) {
	83	if (m_stateMachine.State == ExecutionState.Disposed)
	84	throw new ObjectDisposedException(ToString());
	85
	86	throw new InvalidOperationException(String.Format("Commnd {0} is not allowed in the state {1}", cmd, m_stateMachine.State));
	87	}
	88
	89	void Move(Commands cmd) {
	90	if (!m_stateMachine.Move(cmd))
	91	ThrowInvalidCommand(cmd);
	92	}
	93
	94	void Invoke(Commands cmd, Action action) {
	95	lock (m_stateMachine)
	96	Move(cmd);
15	97
	98	try {
	99	action();
	100	lock(m_stateMachine)
	101	Move(Commands.Ok);
	102
	103	} catch (Exception err) {
	104	lock (m_stateMachine) {
	105	Move(Commands.Fail);
	106	m_lastError = err;
	107	}
	108	throw;
	109	}
16	110	}
17	111
	112	IPromise InvokeAsync(Commands cmd, Func<IPromise> action, Action<IPromise, IDeferred> chain) {
	113	IPromise promise = null;
	114	IPromise prev;
	115
	116	var task = new ActionChainTask(action, null, null, true);
	117
	118	lock (m_stateMachine) {
	119	Move(cmd);
	120
	121	prev = m_pending;
	122
	123	promise = task.Then(
	124	() => {
	125	lock(m_stateMachine) {
	126	if (m_pending == promise) {
	127	Move(Commands.Ok);
	128	m_pending = null;
	129	}
	130	}
	131	}, e => {
	132	lock(m_stateMachine) {
	133	if (m_pending == promise) {
	134	Move(Commands.Fail);
	135	m_pending = null;
	136	m_lastError = e;
	137	}
	138	}
	139	throw new PromiseTransientException(e);
	140	}
	141	);
	142
	143	m_pending = promise;
	144	}
	145
	146	if (prev == null)
	147	task.Resolve();
	148	else
	149	chain(prev, task);
	150
	151	return promise;
	152	}
	153
	154
18	155	#region IInitializable implementation
19	156
20	157	public void Init() {
21
	158	Invoke(Commands.Init, OnInitialize);
	159	}
	160
	161	protected virtual void OnInitialize() {
22	162	}
23	163
24	164	#endregion
25	165
26	166	#region IRunnable implementation
27	167
28	168	public IPromise Start() {
29		throw new NotImplementedException();
	169	return InvokeAsync(Commands.Start, OnStart, null);
30	170	}
31	171
32	172	protected virtual IPromise OnStart() {
33	173	return Promise.SUCCESS;
34	174	}
35	175
36		protected virtual void Run() {
	176	public IPromise Stop() {
	177	return InvokeAsync(Commands.Stop, OnStop, StopPending).Then(Dispose);
	178	}
	179
	180	protected virtual IPromise OnStop() {
	181	return Promise.SUCCESS;
37	182	}
38	183
39		public IPromise Stop() {
40		throw new NotImplementedException();
	184	/// <summary>
	185	/// Stops the current operation if one exists.
	186	/// </summary>
	187	/// <param name="current">Current.</param>
	188	/// <param name="stop">Stop.</param>
	189	protected virtual void StopPending(IPromise current, IDeferred stop) {
	190	if (current == null) {
	191	stop.Resolve();
	192	} else {
	193	// связваем текущую операцию с операцией остановки
	194	current.On(
	195	stop.Resolve, // если текущая операция заверщилась, то можно начинать остановку
	196	stop.Reject, // если текущая операция дала ошибку - то все плохо, нельзя продолжать
	197	e => stop.Resolve() // если текущая отменилась, то можно начинать остановку
	198	);
	199	// посылаем текущей операции сигнал остановки
	200	current.Cancel();
	201	}
41	202	}
42	203
43	204	public ExecutionState State {
44	205	get {
45		throw new NotImplementedException();
	206	return m_stateMachine.State;
46	207	}
47	208	}
48	209
49	210	public Exception LastError {
50	211	get {
51		throw new NotImplementedException();
	212	return m_lastError;
52	213	}
53	214	}
54	215
55	216	#endregion
	217
	218	#region IDisposable implementation
	219
	220	public void Dispose() {
	221	IPromise pending;
	222	lock (m_stateMachine) {
	223	if (m_stateMachine.State == ExecutionState.Disposed)
	224	return;
	225
	226	Move(Commands.Dispose);
	227
	228	GC.SuppressFinalize(this);
	229
	230	pending = m_pending;
	231	m_pending = null;
	232	}
	233	if (pending != null) {
	234	pending.Cancel();
	235	pending.Timeout(DisposeTimeout).On(
	236	() => Dispose(true, null),
	237	err => Dispose(true, err),
	238	reason => Dispose(true, new OperationCanceledException("The operation is cancelled", reason))
	239	);
	240	} else {
	241	Dispose(true, m_lastError);
	242	}
	243	}
	244
	245	~RunnableComponent() {
	246	Dispose(false, null);
	247	}
	248
	249	#endregion
	250
	251	protected virtual void Dispose(bool disposing, Exception lastError) {
	252
	253	}
	254
56	255	}
57	256	}
58	257

Implab/FuncChainTask.cs +3 -1

              using System;
              namespace Implab {
                  public class FuncChainTask<TResult> : FuncChainTaskBase<TResult>, IDeferred {
                      readonly Func<IPromise<TResult>> m_task;
                      public FuncChainTask(Func<IPromise<TResult>> task, Func<Exception, IPromise<TResult>> error, Func<Exception, IPromise<TResult>> cancel, bool autoCancellable)
                          : base(error, cancel, autoCancellable) {
                          m_task = task;
                      }
                      public void Resolve() {
                          if (m_task != null && LockCancelation()) {
                              try {
                                  var operation = m_task();
-                                 operation.On(SetResult, HandleErrorInternal, SetCancelled);
+                                 operation.On(SetResult, HandleErrorInternal, HandleCancelInternal);
                                  CancellationRequested(operation.Cancel);
+                             } catch (OperationCanceledException reason) {
+                                 HandleCancelInternal(reason);
                              } catch (Exception err) {
                                  HandleErrorInternal(err);
                              }
                          }
                      }
                  }
              }
  No newline at end of file

Implab/FuncChainTaskBase.cs +20 -24

              using System;
-             using System.Threading;
              namespace Implab {
-                 public class FuncChainTaskBase<TResult> : AbstractPromise<TResult> {
+                 public class FuncChainTaskBase<TResult> : AbstractTask<TResult> {
                      readonly Func<Exception, IPromise<TResult>> m_error;
                      readonly Func<Exception, IPromise<TResult>> m_cancel;
-                     int m_cancelationLock;
                      protected FuncChainTaskBase( Func<Exception, IPromise<TResult>> error, Func<Exception, IPromise<TResult>> cancel, bool autoCancellable) {
                          m_error = error;
                          m_cancel = cancel;
                          if (autoCancellable)
                              CancellationRequested(CancelOperation);
                      }
                      public void Reject(Exception error) {
                          if (LockCancelation())
                              HandleErrorInternal(error);
                      }
                      public override void CancelOperation(Exception reason) {
-                         if (LockCancelation()) {
-                             if (m_cancel != null) {
-                                 try {
-                                     m_cancel(reason).On(SetResult, HandleErrorInternal, SetCancelled);
-                                 } catch (Exception err) {
-                                     HandleErrorInternal(err);
+                                 }
-                             } else {
-                                 SetCancelled(reason);
+                             }
+                         }
+                         if (LockCancelation())
+                             HandleCancelInternal(reason);
                      }
                      protected void HandleErrorInternal(Exception error) {
                          if (m_error != null) {
                              try {
-                                 var operation = m_error(error);
-                                 operation.On(SetResult, SetError, SetCancelled);
-                                 CancellationRequested(operation.Cancel);
+                                 var p = m_error(error);
+                                 p.On(SetResult, SetErrorInternal, SetCancelledInternal);
+                                 CancellationRequested(p.Cancel);
                              } catch(Exception err) {
-                                 SetError(err);
+                                 SetErrorInternal(err);
                              }
                          } else {
-                             SetError(error);
+                             SetErrorInternal(error);
                          }
                      }
-                     protected bool LockCancelation() {
-                         return 0 == Interlocked.CompareExchange(ref m_cancelationLock, 1, 0);
+                     protected void HandleCancelInternal(Exception reason) {
+                         if (m_cancel != null) {
+                             try {
+                                 var p = m_cancel(reason);
+                                 p.On(SetResult, HandleErrorInternal, SetCancelledInternal);
+                                 CancellationRequested(p.Cancel);
+                             } catch (Exception err) {
+                                 HandleErrorInternal(err);
+                             }
+                         } else {
+                             HandleErrorInternal(reason ?? new OperationCanceledException());
+                         }
                      }
                  }
              }

Implab/FuncChainTaskT.cs +2 0

              using System;
              namespace Implab {
                  public class FuncChainTask<TArg,TResult> : FuncChainTaskBase<TResult>, IDeferred<TArg> {
                      readonly Func<TArg, IPromise<TResult>> m_task;
                      public FuncChainTask(Func<TArg, IPromise<TResult>> task, Func<Exception, IPromise<TResult>> error, Func<Exception, IPromise<TResult>> cancel, bool autoCancellable) : base(error, cancel, autoCancellable){
                          m_task = task;
                      }
                      public void Resolve(TArg value) {
                          if (m_task != null && LockCancelation()) {
                              try {
                                  var operation = m_task(value);
                                  operation.On(SetResult, HandleErrorInternal, SetCancelled);
                                  CancellationRequested(operation.Cancel);
+                             } catch (OperationCanceledException reason) {
+                                 HandleCancelInternal(reason);
                              } catch (Exception err) {
                                  HandleErrorInternal(err);
                              }
                          }
                      }
                  }
              }
  No newline at end of file

Implab/FuncTask.cs +2 0

              using System;
              using System.Threading;
              namespace Implab {
                  public class FuncTask<T> : FuncTaskBase<T>, IDeferred {
                      readonly Func<T> m_task;
                      public FuncTask(Func<T> task, Func<Exception, T> error, Func<Exception, T> cancel, bool autoCancellable) : base(error, cancel, autoCancellable) {
                          m_task = task;
                      }
                      public void Resolve() {
                          if (m_task != null && LockCancelation()) {
                              try {
                                  SetResult(m_task());
+                             } catch(OperationCanceledException reason)  {
+                                 HandleCancelInternal(reason);
                              } catch(Exception err) {
                                  HandleErrorInternal(err);
                              }
                          }
                      }
                  }
              }

Implab/FuncTaskBase.cs +15 -18

              using System;
-             using System.Threading;
              namespace Implab {
-                 public class FuncTaskBase<TResult> : AbstractPromise<TResult> {
+                 public class FuncTaskBase<TResult> : AbstractTask<TResult> {
                      readonly Func<Exception, TResult> m_cancel;
                      readonly Func<Exception, TResult> m_error;
-                     int m_cancelationLock;
                      protected FuncTaskBase( Func<Exception, TResult> error, Func<Exception, TResult> cancel, bool autoCancellable) {
                          m_error = error;
                          m_cancel = cancel;
                          if (autoCancellable)
                              CancellationRequested(CancelOperation);
                      }
                      public void Reject(Exception error) {
                          Safe.ArgumentNotNull(error, "error");
                          if (LockCancelation())
                              HandleErrorInternal(error);
                      }
                      protected void HandleErrorInternal(Exception error) {
                          if (m_error != null) {
                              try {
                                  SetResult(m_error(error));
                              } catch(Exception err) {
-                                 SetError(err);
+                                 SetErrorInternal(err);
                              }
                          } else {
-                             SetError(error);
+                             SetErrorInternal(error);
                          }
                      }
                      public override void CancelOperation(Exception reason) {
-                         if (LockCancelation()) {
-                             if (m_cancel != null) {
-                                 try {
-                                     SetResult(m_cancel(reason));
-                                 } catch (Exception err) {
-                                     HandleErrorInternal(err);
+                                 }
-                             } else {
-                                 SetCancelled(reason);
+                         if (LockCancelation())
+                             HandleCancelInternal(reason);
+                     }
+                     protected void HandleCancelInternal(Exception reason) {
+                         if (m_cancel != null) {
+                             try {
+                                 SetResult(m_cancel(reason));
+                             } catch (Exception err) {
+                                 HandleErrorInternal(err);
                              }
+                         } else {
+                             HandleErrorInternal(reason ?? new OperationCanceledException());
                          }
                      }
-                     protected bool LockCancelation() {
-                         return 0 == Interlocked.CompareExchange(ref m_cancelationLock, 1, 0);
+                     }
                  }
              }

Implab/FuncTaskT.cs +3 -1

              using System;
              namespace Implab {
                  public class FuncTask<TArg, TResult> : FuncTaskBase<TResult>, IDeferred<TArg> {
                      readonly Func<TArg, TResult> m_task;
                      public FuncTask(Func<TArg, TResult> task, Func<Exception, TResult> error,Func<Exception, TResult> cancel, bool autoCancellable) :  base(error,cancel, autoCancellable) {
                          m_task = task;
                      }
                      public void Resolve(TArg value) {
                          if (m_task != null && LockCancelation()) {
                              try {
                                  SetResult(m_task(value));
-                             } catch (Exception err) {
+                             } catch(OperationCanceledException reason)  {
+                                 HandleCancelInternal(reason);
+                             } catch(Exception err) {
                                  HandleErrorInternal(err);
                              }
                          }
                      }
                  }
              }

Implab/Implab.csproj +50 -35

              <?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="JSON\JSONElementContext.cs" />
-                 <Compile Include="JSON\JSONElementType.cs" />
-                 <Compile Include="JSON\JSONGrammar.cs" />
-                 <Compile Include="JSON\JSONParser.cs" />
-                 <Compile Include="JSON\JSONScanner.cs" />
-                 <Compile Include="JSON\JsonTokenType.cs" />
-                 <Compile Include="JSON\JSONWriter.cs" />
-                 <Compile Include="JSON\JSONXmlReader.cs" />
-                 <Compile Include="JSON\JSONXmlReaderOptions.cs" />
-                 <Compile Include="JSON\StringTranslator.cs" />
                  <Compile Include="Parallels\DispatchPool.cs" />
                  <Compile Include="Parallels\ArrayTraits.cs" />
                  <Compile Include="Parallels\MTQueue.cs" />
                  <Compile Include="Parallels\WorkerPool.cs" />
-                 <Compile Include="Parsing\AltToken.cs" />
-                 <Compile Include="Parsing\BinaryToken.cs" />
-                 <Compile Include="Parsing\CatToken.cs" />
-                 <Compile Include="Parsing\CDFADefinition.cs" />
-                 <Compile Include="Parsing\DFABuilder.cs" />
-                 <Compile Include="Parsing\DFAStateDescriptor.cs" />
-                 <Compile Include="Parsing\DFAutomaton.cs" />
-                 <Compile Include="Parsing\EDFADefinition.cs" />
-                 <Compile Include="Parsing\EmptyToken.cs" />
-                 <Compile Include="Parsing\EndToken.cs" />
-                 <Compile Include="Parsing\EnumAlphabet.cs" />
-                 <Compile Include="Parsing\Grammar.cs" />
-                 <Compile Include="Parsing\IAlphabet.cs" />
-                 <Compile Include="Parsing\IDFADefinition.cs" />
-                 <Compile Include="Parsing\IVisitor.cs" />
-                 <Compile Include="Parsing\ParserException.cs" />
-                 <Compile Include="Parsing\Scanner.cs" />
-                 <Compile Include="Parsing\StarToken.cs" />
-                 <Compile Include="Parsing\SymbolToken.cs" />
-                 <Compile Include="Parsing\Token.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="Parsing\DFADefinition.cs" />
-                 <Compile Include="Parsing\IndexedAlphabetBase.cs" />
-                 <Compile Include="Parsing\CharAlphabet.cs" />
-                 <Compile Include="Parsing\IAlphabetBuilder.cs" />
-                 <Compile Include="Parsing\IDFADefinitionBuilder.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="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" />
+                 <Compile Include="AbstractTask.cs" />
+                 <Compile Include="AbstractTaskT.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>
  No newline at end of file

Implab/PromiseExtensions.cs +11 -21

              using System.Threading;
              using System;
              using Implab.Diagnostics;
              using System.Collections.Generic;
-             #if NET_4_5
-             using System.Threading.Tasks;
-             #endif
              namespace Implab {
                  public static class PromiseExtensions {
                      public static IPromise<T> DispatchToCurrentContext<T>(this IPromise<T> that) {
                          Safe.ArgumentNotNull(that, "that");
                          var context = SynchronizationContext.Current;
                          if (context == null)
                              return that;
                          var p = new SyncContextPromise<T>(context);
-                         p.On(that.Cancel, PromiseEventType.Cancelled);
+                         p.CancellationRequested(that.Cancel);
                          that.On(
                              p.Resolve,
                              p.Reject,
-                             p.Cancel
+                             p.CancelOperation
                          );
                          return p;
                      }
                      public static IPromise<T> DispatchToContext<T>(this IPromise<T> that, SynchronizationContext context) {
                          Safe.ArgumentNotNull(that, "that");
                          Safe.ArgumentNotNull(context, "context");
                          var p = new SyncContextPromise<T>(context);
-                         p.On(that.Cancel, PromiseEventType.Cancelled);
+                         p.CancellationRequested(that.Cancel);
                          that.On(
                              p.Resolve,
                              p.Reject,
-                             p.Cancel
+                             p.CancelOperation
                          );
                          return p;
                      }
                      /// <summary>
                      /// Ensures the dispatched.
                      /// </summary>
                      /// <returns>The dispatched.</returns>
                      /// <param name="that">That.</param>
                      /// <param name="head">Head.</param>
                      /// <param name="cleanup">Cleanup.</param>
                      /// <typeparam name="TPromise">The 1st type parameter.</typeparam>
                      /// <typeparam name="T">The 2nd type parameter.</typeparam>
                      public static TPromise EnsureDispatched<TPromise,T>(this TPromise that, IPromise<T> head, Action<T> cleanup) where TPromise : IPromise{
                          Safe.ArgumentNotNull(that, "that");
                          Safe.ArgumentNotNull(head, "head");
                          that.On(() => head.On(cleanup), PromiseEventType.Cancelled);
                          return that;
                      }
                      public static AsyncCallback AsyncCallback<T>(this Promise<T> that, Func<IAsyncResult,T> callback) {
                          Safe.ArgumentNotNull(that, "that");
                          Safe.ArgumentNotNull(callback, "callback");
                          var op = TraceContext.Instance.CurrentOperation;
                          return ar => {
                              TraceContext.Instance.EnterLogicalOperation(op,false);
                              try {
                                  that.Resolve(callback(ar));
                              } catch (Exception err) {
                                  that.Reject(err);
                              } finally {
                                  TraceContext.Instance.Leave();
                              }
                          };
                      }
-                     static void CancelCallback(object cookie) {
-                         ((ICancellable)cookie).Cancel();
+                     static void CancelByTimeoutCallback(object cookie) {
+                         ((ICancellable)cookie).Cancel(new TimeoutException());
                      }
                      /// <summary>
                      /// Cancells promise after the specified timeout is elapsed.
                      /// </summary>
                      /// <param name="that">The promise to cancel on timeout.</param>
                      /// <param name="milliseconds">The timeout in milliseconds.</param>
                      /// <typeparam name="TPromise">The 1st type parameter.</typeparam>
                      public static TPromise Timeout<TPromise>(this TPromise that, int milliseconds) where TPromise : IPromise {
                          Safe.ArgumentNotNull(that, "that");
-                         var timer = new Timer(CancelCallback, that, milliseconds, -1);
+                         var timer = new Timer(CancelByTimeoutCallback, that, milliseconds, -1);
                          that.On(timer.Dispose, PromiseEventType.All);
                          return that;
                      }
                      public static IPromise Bundle(this ICollection<IPromise> that) {
                          Safe.ArgumentNotNull(that, "that");
                          int count = that.Count;
                          int errors = 0;
                          var medium = new Promise();
                          if (count == 0) {
                              medium.Resolve();
                              return medium;
                          }
                          medium.On(() => {
                              foreach(var p2 in that)
                                  p2.Cancel();
                          }, PromiseEventType.ErrorOrCancel);
                          foreach (var p in that)
                              p.On(
                                  () => {
                                      if (Interlocked.Decrement(ref count) == 0)
                                          medium.Resolve();
                                  },
                                  error => {
                                      if (Interlocked.Increment(ref errors) == 1)
                                          medium.Reject(
                                              new Exception("The dependency promise is failed", error)
                                          );
                                  },
                                  reason => {
                                      if (Interlocked.Increment(ref errors) == 1)
                                          medium.Cancel(
                                              new Exception("The dependency promise is cancelled")
                                          );
                                  }
                              );
                          return medium;
                      }
                      public static IPromise<T[]> Bundle<T>(this ICollection<IPromise<T>> that) {
                          Safe.ArgumentNotNull(that, "that");
                          int count = that.Count;
                          int errors = 0;
                          var medium = new Promise<T[]>();
                          var results = new T[that.Count];
                          medium.On(() => {
                              foreach(var p2 in that)
                                  p2.Cancel();
                          }, PromiseEventType.ErrorOrCancel);
                          int i = 0;
                          foreach (var p in that) {
                              var idx = i;
                              p.On(
                                  x => {
                                      results[idx] = x;
                                      if (Interlocked.Decrement(ref count) == 0)
                                          medium.Resolve(results);
                                  },
                                  error => {
                                      if (Interlocked.Increment(ref errors) == 1)
                                          medium.Reject(
                                              new Exception("The dependency promise is failed", error)
                                          );
                                  },
                                  reason => {
                                      if (Interlocked.Increment(ref errors) == 1)
                                          medium.Cancel(
                                              new Exception("The dependency promise is cancelled", reason)
                                          );
                                  }
                              );
                              i++;
                          }
                          return medium;
                      }
                      public static IPromise Then(this IPromise that, Action success, Action<Exception> error, Action<Exception> cancel) {
                          Safe.ArgumentNotNull(that, "that");
                          var d = new ActionTask(success, error, cancel, false);
                          that.On(d.Resolve, d.Reject, d.CancelOperation);
-                         if (success != null)
-                             d.CancellationRequested(that.Cancel);
+                         d.CancellationRequested(that.Cancel);
                          return d;
                      }
                      public static IPromise Then(this IPromise that, Action success, Action<Exception> error) {
                          return Then(that, success, error, null);
                      }
                      public static IPromise Then(this IPromise that, Action success) {
                          return Then(that, success, null, null);
                      }
                      public static IPromise<T> Then<T>(this IPromise that, Func<T> success, Func<Exception, T> error, Func<Exception, T> cancel) {
                          Safe.ArgumentNotNull(that, "that");
                          var d = new FuncTask<T>(success, error, cancel, false);
                          that.On(d.Resolve, d.Reject, d.CancelOperation);
-                         if (success != null)
-                             d.CancellationRequested(that.Cancel);
+                         d.CancellationRequested(that.Cancel);
                          return d;
                      }
                      public static IPromise<T> Then<T>(this IPromise that, Func<T> success, Func<Exception, T> error) {
                          return Then(that, success, error, null);
                      }
                      public static IPromise<T> Then<T>(this IPromise that, Func<T> success) {
                          return Then(that, success, null, null);
                      }
                      public static IPromise<T2> Then<T, T2>(this IPromise<T> that, Func<T, T2> success, Func<Exception, T2> error, Func<Exception, T2> cancel) {
                          Safe.ArgumentNotNull(that, "that");
                          var d = new FuncTask<T,T2>(success, error, cancel, false);
                          that.On(d.Resolve, d.Reject, d.CancelOperation);
-                         if (success != null)
-                             d.CancellationRequested(that.Cancel);
+                         d.CancellationRequested(that.Cancel);
                          return d;
                      }
                      public static IPromise<T2> Then<T, T2>(this IPromise<T> that, Func<T, T2> success, Func<Exception, T2> error) {
                          return Then(that, success, error, null);
                      }
                      public static IPromise<T2> Then<T, T2>(this IPromise<T> that, Func<T, T2> success) {
                          return Then(that, success, null, null);
                      }
                      #region chain traits
                      public static IPromise Chain(this IPromise that, Func<IPromise> success, Func<Exception,IPromise> error, Func<Exception,IPromise> cancel) {
                          Safe.ArgumentNotNull(that, "that");
                          var d = new ActionChainTask(success, error, cancel, false);
                          that.On(d.Resolve, d.Reject, d.CancelOperation);
-                         if (success != null)
-                             d.CancellationRequested(that.Cancel);
+                         d.CancellationRequested(that.Cancel);
                          return d;
                      }
                      public static IPromise Chain(this IPromise that, Func<IPromise> success, Func<Exception,IPromise> error) {
                          return Chain(that, success, error, null);
                      }
                      public static IPromise Chain(this IPromise that, Func<IPromise> success) {
                          return Chain(that, success, null, null);
                      }
                      public static IPromise<T> Chain<T>(this IPromise that, Func<IPromise<T>> success, Func<Exception, IPromise<T>> error, Func<Exception, IPromise<T>> cancel) {
                          Safe.ArgumentNotNull(that, "that");
                          var d = new FuncChainTask<T>(success, error, cancel, false);
                          that.On(d.Resolve, d.Reject, d.CancelOperation);
                          if (success != null)
                              d.CancellationRequested(that.Cancel);
                          return d;
                      }
                      public static IPromise<T> Chain<T>(this IPromise that, Func<IPromise<T>> success, Func<Exception, IPromise<T>> error) {
                          return Chain(that, success, error, null);
                      }
                      public static IPromise<T> Chain<T>(this IPromise that, Func<IPromise<T>> success) {
                          return Chain(that, success, null, null);
                      }
                      public static IPromise<T2> Chain<T, T2>(this IPromise<T> that, Func<T, IPromise<T2>> success, Func<Exception, IPromise<T2>> error, Func<Exception, IPromise<T2>> cancel) {
                          Safe.ArgumentNotNull(that, "that");
                          var d = new FuncChainTask<T,T2>(success, error, cancel, false);
                          that.On(d.Resolve, d.Reject, d.CancelOperation);
                          if (success != null)
                              d.CancellationRequested(that.Cancel);
                          return d;
                      }
                      public static IPromise<T2> Chain<T, T2>(this IPromise<T> that, Func<T, IPromise<T2>> success, Func<Exception, IPromise<T2>> error) {
                          return Chain(that, success, error, null);
                      }
                      public static IPromise<T2> Chain<T, T2>(this IPromise<T> that, Func<T, IPromise<T2>> success) {
                          return Chain(that, success, null, null);
                      }
                      #endregion
                      #if NET_4_5
                      public static PromiseAwaiter<T> GetAwaiter<T>(this IPromise<T> that) {
                          Safe.ArgumentNotNull(that, "that");
                          return new PromiseAwaiter<T>(that);
                      }
                      #endif
                  }
              }

Implab/Safe.cs +5 0

              using System;
              using System.Collections.Generic;
              using System.Linq;
              using System.Text;
              using System.Text.RegularExpressions;
              using System.Diagnostics;
              namespace Implab
              {
                  public static class Safe
                  {
                      public static void ArgumentAssert(bool condition, string paramName) {
                          if (!condition)
                              throw new ArgumentException("The parameter is invalid", paramName);
                      }
                      public static void ArgumentMatch(string value, string paramName, Regex rx) {
                          if (rx == null)
                              throw new ArgumentNullException("rx");
                          if (!rx.IsMatch(value))
                              throw new ArgumentException(String.Format("The prameter value must match {0}", rx), paramName);
                      }
                      public static void ArgumentNotEmpty(string value, string paramName) {
                          if (String.IsNullOrEmpty(value))
                              throw new ArgumentException("The parameter can't be empty", paramName);
                      }
                      public static void ArgumentNotEmpty<T>(T[] value, string paramName) {
                          if (value == null || value.Length == 0)
                              throw new ArgumentException("The array must be not emty", paramName);
                      }
                      public static void ArgumentNotNull(object value, string paramName) {
                          if (value == null)
                              throw new ArgumentNullException(paramName);
                      }
                      public static void ArgumentInRange(int value, int min, int max, string paramName) {
                          if (value < min || value > max)
                              throw new ArgumentOutOfRangeException(paramName);
                      }
+                     public static void ArgumentOfType(object value, Type type, string paramName) {
+                         if (!type.IsInstanceOfType(value))
+                             throw new ArgumentException(String.Format("The parameter must be of type {0}", type), paramName);
+                     }
                      public static void Dispose(params IDisposable[] objects) {
                          foreach (var d in objects)
                              if (d != null)
                                  d.Dispose();
                      }
                      public static void Dispose(params object[] objects) {
                          foreach (var obj in objects) {
                              var d = obj as IDisposable;
                              if (d != null)
                                  d.Dispose();
                          }
                      }
                      public static void Dispose(object obj) {
                          var d = obj as IDisposable;
                          if (d != null)
                              d.Dispose();
                      }
                      [DebuggerStepThrough]
                      public static IPromise<T> WrapPromise<T>(Func<T> action) {
                          ArgumentNotNull(action, "action");
                          var p = new Promise<T>();
                          try {
                              p.Resolve(action());
                          } catch (Exception err) {
                              p.Reject(err);
                          }
                          return p;
                      }
                      [DebuggerStepThrough]
                      public static IPromise WrapPromise(Action action) {
                          ArgumentNotNull(action, "action");
                          var p = new Promise();
                          try {
                              action();
                              p.Resolve();
                          } catch (Exception err) {
                              p.Reject(err);
                          }
                          return p;
                      }
                      [DebuggerStepThrough]
                      public static IPromise InvokePromise(Func<IPromise> action) {
                          ArgumentNotNull(action, "action");
                          try {
                              var p = action();
                              if (p == null) {
                                  var d = new Promise();
                                  d.Reject(new Exception("The action returned null"));
                                  p = d;
                              }
                              return p;
                          } catch (Exception err) {
                              var p = new Promise();
                              p.Reject(err);
                              return p;
                          }
                      }
                      [DebuggerStepThrough]
                      public static IPromise<T> InvokePromise<T>(Func<IPromise<T>> action) {
                          ArgumentNotNull(action, "action");
                          try {
                              return action() ?? Promise<T>.FromException(new Exception("The action returned null"));
                          } catch (Exception err) {
                              return Promise<T>.FromException(err);
                          }
                      }
                  }
              }

MonoPlay/MonoPlay.csproj +6 0

              <?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>
                  <ProductVersion>8.0.30703</ProductVersion>
                  <SchemaVersion>2.0</SchemaVersion>
                  <ProjectGuid>{15DD7123-D504-4627-8B4F-D00C7F04D033}</ProjectGuid>
                  <OutputType>Exe</OutputType>
                  <RootNamespace>MonoPlay</RootNamespace>
                  <AssemblyName>MonoPlay</AssemblyName>
                  <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
                  <ReleaseVersion>0.2</ReleaseVersion>
                </PropertyGroup>
                <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
                  <DebugSymbols>true</DebugSymbols>
                  <DebugType>full</DebugType>
                  <Optimize>false</Optimize>
                  <OutputPath>bin\Debug</OutputPath>
                  <DefineConstants>DEBUG;TRACE;</DefineConstants>
                  <ErrorReport>prompt</ErrorReport>
                  <WarningLevel>4</WarningLevel>
                  <ConsolePause>false</ConsolePause>
                </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>
                <ItemGroup>
                  <Reference Include="System" />
+                 <Reference Include="System.Text.Json">
+                   <HintPath>..\packages\System.Text.Json.2.0.0.11\lib\net40\System.Text.Json.dll</HintPath>
+                 </Reference>
                </ItemGroup>
                <ItemGroup>
                  <Compile Include="Program.cs" />
                  <Compile Include="Properties\AssemblyInfo.cs" />
                </ItemGroup>
                <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
                <ItemGroup>
                  <ProjectReference Include="..\Implab\Implab.csproj">
                    <Project>{F550F1F8-8746-4AD0-9614-855F4C4B7F05}</Project>
                    <Name>Implab</Name>
                  </ProjectReference>
                </ItemGroup>
+               <ItemGroup>
+                 <None Include="packages.config" />
+               </ItemGroup>
              </Project>
  No newline at end of file

MonoPlay/Program.cs +26 -18

              using System;
              using Implab;
              using System.Threading.Tasks;
+             using Implab.Formats.JSON;
+             using System.IO;
+             using System.Text.Json;
              namespace MonoPlay {
                  class MainClass {
                      public static void Main(string[] args) {
                          if (args == null)
                              throw new ArgumentNullException("args");
-                         var t1 = Environment.TickCount;
-                         DoWork().GetAwaiter().GetResult();
+                         int t1, t2;
-                         var t2 = Environment.TickCount;
-                         Console.WriteLine("done: {0} ms, {1:.00} Mb, {2} GC", t2 - t1, GC.GetTotalMemory(false) / (1024*1024), GC.CollectionCount(0) );
+                         for (int i = 0; i < 2; i++) {
+                             t1 = Environment.TickCount;
+                             int elements =0;
+                             using (var reader = new JSONParser(File.OpenText("/home/sergey/temp/citylots.json"))) {
+                                 while (reader.Read())
+                                     elements++;
+                             }
+                     }
+                             t2 = Environment.TickCount;
+                             Console.WriteLine("attempt {0} done: {1} ms, {2:.00} Mb, {3} GC, Elements: {4}",i+1, t2 - t1, GC.GetTotalMemory(false) / (1024*1024), GC.CollectionCount(0), elements );
+                         }
-                     static IPromise<int> DoItem(int x) {
-                         //return Promise<int>.FromResult(x + 1);
-                         var p = new Promise<int>();
-                         p.Resolve(x+1);
-                         return p;
+                     }
+                         Console.WriteLine("Syste.Text.Json");
+                         var paraser = new JsonParser();
+                         for (int i = 0; i < 2; i++) {
+                             t1 = Environment.TickCount;
+                             using (var reader = File.OpenText("/home/sergey/temp/citylots.json")) {
+                                 paraser.Parse(reader);
+                             }
-                     static async Task<int> DoWork() {
-                         var c = 0;
-                         for (int i = 0; i < 10000000; i++)
-                             c = await DoItem(c);
-                         return c;
+                             t2 = Environment.TickCount;
+                             Console.WriteLine("attempt {0} done: {1} ms, {2:.00} Mb, {3} GC, ",i+1, t2 - t1, GC.GetTotalMemory(false) / (1024*1024), GC.CollectionCount(0));
+                         }
                      }
                  }
              }

packages/repositories.config 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

Implab/JSON/JSONElementContext.cs removed 0 -17

NO CONTENT: file was removed

Implab/JSON/JSONElementType.cs removed 0 -34

NO CONTENT: file was removed

Implab/JSON/JSONGrammar.cs removed 0 -99

NO CONTENT: file was removed

Implab/JSON/JSONParser.cs removed 0 -277

NO CONTENT: file was removed

Implab/JSON/JSONScanner.cs removed 0 -100

NO CONTENT: file was removed

Implab/JSON/JSONWriter.cs removed 0 -319

NO CONTENT: file was removed

Implab/JSON/JSONXmlReader.cs removed 0 -343

NO CONTENT: file was removed

Implab/JSON/JSONXmlReaderOptions.cs removed 0 -65

NO CONTENT: file was removed

Implab/JSON/JsonTokenType.cs removed 0 -50

NO CONTENT: file was removed

Implab/JSON/StringTranslator.cs removed 0 -96

NO CONTENT: file was removed

Implab/Parsing/AltToken.cs removed 0 -17

NO CONTENT: file was removed

Implab/Parsing/BinaryToken.cs removed 0 -26

NO CONTENT: file was removed

Implab/Parsing/CDFADefinition.cs removed 0 -22

NO CONTENT: file was removed

Implab/Parsing/CatToken.cs removed 0 -22

NO CONTENT: file was removed

Implab/Parsing/CharAlphabet.cs removed 0 -23

NO CONTENT: file was removed

Implab/Parsing/DFABuilder.cs removed 0 -180

NO CONTENT: file was removed

Implab/Parsing/DFADefinition.cs removed 0 -285

NO CONTENT: file was removed

Implab/Parsing/DFAStateDescriptor.cs removed 0 -13

NO CONTENT: file was removed

Implab/Parsing/DFAutomaton.cs removed 0 -61

NO CONTENT: file was removed

Implab/Parsing/EDFADefinition.cs removed 0 -29

NO CONTENT: file was removed

Implab/Parsing/EmptyToken.cs removed 0 -18

NO CONTENT: file was removed

Implab/Parsing/EndToken.cs removed 0 -37

NO CONTENT: file was removed

Implab/Parsing/EnumAlphabet.cs removed 0 -67

NO CONTENT: file was removed

Implab/Parsing/Grammar.cs removed 0 -108

NO CONTENT: file was removed

Implab/Parsing/IAlphabet.cs removed 0 -48

NO CONTENT: file was removed

Implab/Parsing/IAlphabetBuilder.cs removed 0 -25

NO CONTENT: file was removed

Implab/Parsing/IDFADefinition.cs removed 0 -61

NO CONTENT: file was removed

Implab/Parsing/IDFADefinitionBuilder.cs removed 0 -9

NO CONTENT: file was removed

Implab/Parsing/IVisitor.cs removed 0 -19

NO CONTENT: file was removed

Implab/Parsing/IndexedAlphabetBase.cs removed 0 -107

NO CONTENT: file was removed

Implab/Parsing/ParserException.cs removed 0 -17

NO CONTENT: file was removed

Implab/Parsing/Scanner.cs removed 0 -259

NO CONTENT: file was removed

Implab/Parsing/StarToken.cs removed 0 -34

NO CONTENT: file was removed

Implab/Parsing/SymbolToken.cs removed 0 -33

NO CONTENT: file was removed

Implab/Parsing/Token.cs removed 0 -67

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