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			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			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>

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

@@ -1,12 +1,88
1	using NUnit.Framework;	1	using NUnit.Framework;
2	using System;	2	using System;
		3	using Implab.Formats.JSON;
		4	using Implab.Automaton;
3		5
4	namespace Implab.Format.Test {	6	namespace Implab.Format.Test {
5	[TestFixture()]	7	[TestFixture]
6	public class JsonTests {	8	public class JsonTests {
7	[Test()]	9	[Test]
8	public void Test~~Case~~() {	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>

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>

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>

Implab/AbstractEvent.cs +4 -8

             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;
-                                m_error = error.InnerException;
-                                CompleteTransit(CANCELLED_STATE);
-                            } else {
-                                m_error = error is PromiseTransientException ? error.InnerException : 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 +1 -1

             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();
+                        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 +19 -15

             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) {
+                    protected void HandleCancelInternal(Exception reason) {
-                        if (LockCancelation()) {
                         if (m_cancel != null) {
                             try {
-                                    m_cancel(reason).On(SetResult, SetError, SetCancelled);
+                                // вызываем обработчик отмены
+                                var p = m_cancel(reason);
+                                p.On(SetResult, HandleErrorInternal, SetCancelledInternal);
+                                // сообщаем асинхронной операции, что клиент уже не хочет получать результат
+                                // т.е. если он инициировал отмену, задача отменилась, вызвался обрабочик отмены
+                                // отбработчику сообщили, что результат уже не нужен и уже сам обработчик решает
+                                // отдавать ли результат или подтвердить отмену (или вернуть ошибку).
+                                CancellationRequested(p.Cancel);
                             } catch (Exception err) {
                                 HandleErrorInternal(err);
                             }
                         } else {
-                                SetCancelled(reason);
+                            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 +12 -16

             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) {
+                    protected void HandleCancelInternal(Exception error) {
-                        if (LockCancelation()) {
                         if (m_cancel != null) {
                             try {
-                                    m_cancel(reason);
+                                m_cancel(error);
                                 SetResult();
                             } catch(Exception err) {
                                 HandleErrorInternal(err);
                             }
                         } else {
-                                SetCancelled(reason);
+                            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,
+                    Undefined = 0,
-                    Uninitialized,
+                    Created,
+                    Initializing,
                     Ready,
                     Starting,
                     Running,
                     Stopping,
-                    Stopped,
+                    Failed,
                     Disposed,
-                    Failed
+                    Last = Disposed
                 }
             }

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 +207 -8

@@ -1,58 +1,257
1	using System;	1	using System;
2	using Implab.Parsing;
3		2
4	namespace Implab.Components {	3	namespace Implab.Components {
5	public class RunnableComponent : Disposable, IRunnable, IInitializable {	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;
6		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);
9		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	}
		48
		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	}
10		66
11	IPromise m_pending;	67	IPromise m_pending;
12	Exception m_lastError;	68	Exception m_lastError;
13		69
		70	readonly StateMachine m_stateMachine;
		71
14	protected RunnableComponent(bool initialized) {	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);
		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	}
		110	}
15		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;
16	}	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
17		154
18	#region IInitializable implementation	155	#region IInitializable implementation
19		156
20	public void Init() {	157	public void Init() {
		158	Invoke(Commands.Init, OnInitialize);
		159	}
21		160
		161	protected virtual void OnInitialize() {
22	}	162	}
23		163
24	#endregion	164	#endregion
25		165
26	#region IRunnable implementation	166	#region IRunnable implementation
27		167
28	public IPromise Start() {	168	public IPromise Start() {
29	throw new NotImplementedException();	169	return InvokeAsync(Commands.Start, OnStart, null);
30	}	170	}
31		171
32	protected virtual IPromise OnStart() {	172	protected virtual IPromise OnStart() {
33	return Promise.SUCCESS;	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() {	184	/// <summary>
40	throw new NotImplementedException();	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	public ExecutionState State {	204	public ExecutionState State {
44	get {	205	get {
45	throw new NotImplementedException();	206	return m_stateMachine.State;
46	}	207	}
47	}	208	}
48		209
49	public Exception LastError {	210	public Exception LastError {
50	get {	211	get {
51	throw new NotImplementedException();	212	return m_lastError;
52	}	213	}
53	}	214	}
54		215
55	#endregion	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);
56	}	242	}
57	}	243	}
58		244
		245	~RunnableComponent() {
		246	Dispose(false, null);
		247	}
		248
		249	#endregion
		250
		251	protected virtual void Dispose(bool disposing, Exception lastError) {
		252
		253	}
		254
		255	}
		256	}
		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);
                             }
                         }
                     }
                 }
             }

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 (LockCancelation())
-                            if (m_cancel != null) {
+                            HandleCancelInternal(reason);
-                                try {
-                                    m_cancel(reason).On(SetResult, HandleErrorInternal, SetCancelled);
-                                } catch (Exception err) {
-                                    HandleErrorInternal(err);
-                            } else {
-                                SetCancelled(reason);
                     }
                     protected void HandleErrorInternal(Exception error) {
                         if (m_error != null) {
                             try {
-                                var operation = m_error(error);
+                                var p = m_error(error);
+                                p.On(SetResult, SetErrorInternal, SetCancelledInternal);
-                                operation.On(SetResult, SetError, SetCancelled);
+                                CancellationRequested(p.Cancel);
-                                CancellationRequested(operation.Cancel);
                             } catch(Exception err) {
-                                SetError(err);
+                                SetErrorInternal(err);
                             }
                         } else {
-                            SetError(error);
+                            SetErrorInternal(error);
                         }
                     }
-                    protected bool LockCancelation() {
+                    protected void HandleCancelInternal(Exception reason) {
-                        return 0 == Interlocked.CompareExchange(ref m_cancelationLock, 1, 0);
+                        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);
                             }
                         }
                     }
                 }
             }

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 +9 -12

             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 (LockCancelation())
+                            HandleCancelInternal(reason);
+                    }
+                    protected void HandleCancelInternal(Exception reason) {
                         if (m_cancel != null) {
                             try {
                                 SetResult(m_cancel(reason));
                             } catch (Exception err) {
                                 HandleErrorInternal(err);
                             }
                         } else {
-                                SetCancelled(reason);
+                            HandleErrorInternal(reason ?? new OperationCanceledException());
                         }
                     }
-                    protected bool LockCancelation() {
-                        return 0 == Interlocked.CompareExchange(ref m_cancelationLock, 1, 0);
                 }
             }

Implab/FuncTaskT.cs +2 0

             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(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="Automaton\IAlphabet.cs" />
-                <Compile Include="Parsing\IndexedAlphabetBase.cs" />
+                <Compile Include="Automaton\ParserException.cs" />
-                <Compile Include="Parsing\CharAlphabet.cs" />
+                <Compile Include="Automaton\IndexedAlphabetBase.cs" />
-                <Compile Include="Parsing\IAlphabetBuilder.cs" />
+                <Compile Include="Automaton\IAlphabetBuilder.cs" />
-                <Compile Include="Parsing\IDFADefinitionBuilder.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>

Implab/PromiseExtensions.cs +7 -17

             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) {
+                    static void CancelByTimeoutCallback(object cookie) {
-                        ((ICancellable)cookie).Cancel();
+                        ((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);
                         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);
                         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);
                         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);
                         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>

MonoPlay/Program.cs +24 -16

             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");
+                        int t1, t2;
-                        var t1 = Environment.TickCount;
-                        DoWork().GetAwaiter().GetResult();
+                        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++;
+                            }
-                        var t2 = Environment.TickCount;
+                            t2 = Environment.TickCount;
-                        Console.WriteLine("done: {0} ms, {1:.00} Mb, {2} GC", t2 - t1, GC.GetTotalMemory(false) / (1024*1024), GC.CollectionCount(0) );
+                            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) {
+                        Console.WriteLine("Syste.Text.Json");
-                        //return Promise<int>.FromResult(x + 1);
+                        var paraser = new JsonParser();
-                        var p = new Promise<int>();
+                        for (int i = 0; i < 2; i++) {
-                        p.Resolve(x+1);
+                            t1 = Environment.TickCount;
-                        return p;
+                            using (var reader = File.OpenText("/home/sergey/temp/citylots.json")) {
+                                paraser.Parse(reader);
                             }
-                    static async Task<int> DoWork() {
+                            t2 = Environment.TickCount;
-                        var c = 0;
+                            Console.WriteLine("attempt {0} done: {1} ms, {2:.00} Mb, {3} GC, ",i+1, t2 - t1, GC.GetTotalMemory(false) / (1024*1024), GC.CollectionCount(0));
-                        for (int i = 0; i < 10000000; i++)
-                            c = await DoItem(c);
-                        return c;
                     }
                 }
             }

packages/repositories.config 0 0

	1	NO CONTENT: modified file			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