implab/ImplabNet Commit - r169:54270c2f29f2

DFA refactoring

cin -

r169:54270c2f29f2 ref20160224

parent child

Context file:

r169:54270c2f29f2

Collapse all files

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

@@ -0,0 +1,280
	1	using Implab;
	2	using System;
	3	using System.Collections.Generic;
	4	using System.Linq;
	5
	6	namespace Implab.Automaton {
	7	public class DFATable : IDFATableBuilder {
	8	DFAStateDescriptior[] m_dfaTable;
	9
	10	int m_stateCount;
	11	int m_symbolCount;
	12	int m_initialState;
	13
	14	readonly HashSet<int> m_finalStates = new HashSet<int>();
	15	readonly HashSet<AutomatonTransition> m_transitions = new HashSet<AutomatonTransition>();
	16
	17	void AssertNotReadOnly() {
	18	if (m_dfaTable != null)
	19	throw new InvalidOperationException("The object is readonly");
	20	}
	21
	22
	23	#region IDFADefinition implementation
	24
	25	public DFAStateDescriptior[] GetTransitionTable() {
	26	if (m_dfaTable == null) {
	27	if (m_stateCount <= 0)
	28	throw new InvalidOperationException("Invalid automaton definition: states count = {0}", m_stateCount);
	29	if (m_symbolCount <= 0)
	30	throw new InvalidOperationException("Invalid automaton definition: symbols count = {0}", m_symbolCount);
	31
	32	m_dfaTable = ConstructTransitionTable();
	33	}
	34	return m_dfaTable;
	35	}
	36
	37	public bool IsFinalState(int s) {
	38	Safe.ArgumentInRange(s, 0, m_stateCount, "s");
	39
	40	return m_dfaTable != null ? m_dfaTable[s].final : m_finalStates.Contains(s);
	41	}
	42
	43	public IEnumerable<int> FinalStates {
	44	get {
	45	return m_finalStates;
	46	}
	47	}
	48
	49	public int StateCount {
	50	get { return m_stateCount; }
	51	}
	52
	53	public int AlphabetSize {
	54	get { return m_symbolCount; }
	55	}
	56
	57	public int InitialState {
	58	get { return m_initialState; }
	59	}
	60
	61	#endregion
	62
	63	protected virtual DFAStateDescriptior[] ConstructTransitionTable() {
	64	var dfaTable = new DFAStateDescriptior[m_stateCount];
	65
	66
	67	foreach (var t in m_transitions) {
	68	if (dfaTable[t.s1].transitions == null)
	69	dfaTable[t.s1] = new DFAStateDescriptior(m_symbolCount, m_finalStates.Contains(t.s1));
	70
	71	dfaTable[t.s1].transitions[t.edge] = t.s2;
	72	}
	73
	74	foreach (var s in m_finalStates)
	75	if (!dfaTable[s].final)
	76	m_dfaTable[s] = new DFAStateDescriptior(m_symbolCount, true);
	77
	78	}
	79
	80	public void SetInitialState(int s) {
	81	Safe.ArgumentAssert(s >= 0, "s");
	82	m_initialState = s;
	83	}
	84
	85	public void MarkFinalState(int state) {
	86	AssertNotReadOnly();
	87	m_finalStates.Add(state);
	88	}
	89
	90	public void Add(AutomatonTransition item) {
	91	AssertNotReadOnly();
	92	Safe.ArgumentAssert(item.s1 >= 0, "item");
	93	Safe.ArgumentAssert(item.s2 >= 0, "item");
	94	Safe.ArgumentAssert(item.edge >= 0, "item");
	95
	96	m_stateCount = Math.Max(m_stateCount, Math.Max(item.s1, item.s2) + 1);
	97	m_symbolCount = Math.Max(m_symbolCount, item.edge);
	98
	99	m_transitions.Add(item);
	100	}
	101
	102	public void Clear() {
	103	AssertNotReadOnly();
	104
	105	m_stateCount = 0;
	106	m_symbolCount = 0;
	107	m_finalStates.Clear();
	108	m_transitions.Clear();
	109	}
	110
	111	public bool Contains(AutomatonTransition item) {
	112	return m_transitions.Contains(item);
	113	}
	114
	115	public void CopyTo(AutomatonTransition[] array, int arrayIndex) {
	116	m_transitions.CopyTo(array, arrayIndex);
	117	}
	118
	119	public bool Remove(AutomatonTransition item) {
	120	AssertNotReadOnly();
	121	m_transitions.Remove(item);
	122	}
	123
	124	public int Count {
	125	get {
	126	return m_transitions.Count;
	127	}
	128	}
	129
	130	public bool IsReadOnly {
	131	get {
	132	return m_dfaTable != null;
	133	}
	134	}
	135
	136	public IEnumerator<AutomatonTransition> GetEnumerator() {
	137	return m_transitions.GetEnumerator();
	138	}
	139
	140	System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() {
	141	return GetEnumerator();
	142	}
	143
	144	/// <summary>Формирует множества конечных состояний перед началом работы алгоритма минимизации.</summary>
	145	/// <remarks>
	146	/// В процессе построения минимального автомата требуется разделить множество состояний,
	147	/// на два подмножества - конечные состояния и все остальные, после чего эти подмножества
	148	/// будут резделены на более мелкие. Иногда требуется гарантировать различия конечных сосотяний,
	149	/// для этого необходимо переопределить даннцю фукнцию, для получения множеств конечных состояний.
	150	/// </remarks>
	151	/// <returns>The final states.</returns>
	152	protected virtual IEnumerable<HashSet<int>> GroupFinalStates() {
	153	return new HashSet<int>[] { m_finalStates };
	154	}
	155
	156	protected void Optimize<TInput, TState>(
	157	IDFATableBuilder optimalDFA,
	158	IAlphabet<TInput> inputAlphabet,
	159	IAlphabetBuilder<TInput> optimalInputAlphabet,
	160	IAlphabet<TState> stateAlphabet,
	161	IAlphabetBuilder<TState> optimalStateAlphabet
	162	) {
	163	Safe.ArgumentNotNull(optimalDFA, "dfa");
	164	Safe.ArgumentNotNull(optimalInputAlphabet, "optimalInputAlphabet");
	165	Safe.ArgumentNotNull(optimalStateAlphabet, "optimalStateAlphabet");
	166	Safe.ArgumentNotNull(inputAlphabet, "inputAlphabet");
	167	Safe.ArgumentNotNull(stateAlphabet, "stateAlphabet");
	168
	169	if (inputAlphabet.Count != m_symbolCount)
	170	throw new InvalidOperationException("The input symbols aphabet mismatch");
	171	if (stateAlphabet.Count != m_stateCount)
	172	throw new InvalidOperationException("The states alphabet mismatch");
	173
	174	var setComparer = new CustomEqualityComparer<HashSet<int>>(
	175	(x, y) => x.SetEquals(y),
	176	s => s.Sum(x => x.GetHashCode())
	177	);
	178
	179	var optimalStates = new HashSet<HashSet<int>>(setComparer);
	180	var queue = new HashSet<HashSet<int>>(setComparer);
	181
	182	// получаем конечные состояния, сгруппированные по маркерам
	183	optimalStates.UnionWith(
	184	GroupFinalStates()
	185	);
	186
	187	var state = new HashSet<int>(
	188	Enumerable
	189	.Range(0, m_stateCount - 1)
	190	.Where(i => !m_finalStates.Contains(i))
	191	);
	192
	193	optimalStates.Add(state);
	194	queue.Add(state);
	195
	196	var rmap = m_transitions
	197	.GroupBy(t => t.s2)
	198	.ToLookup(
	199	g => g.Key, // s2
	200	g => g.ToLookup(t => t.edge, t => t.s1)
	201	);
	202
	203	while (queue.Count > 0) {
	204	var stateA = queue.First();
	205	queue.Remove(stateA);
	206
	207	for (int c = 0; c < m_symbolCount; c++) {
	208	var stateX = new HashSet<int>();
	209	foreach(var a in stateA)
	210	stateX.UnionWith(rmap[a][c]); // all states from wich 'c' leads to 'a'
	211
	212	foreach (var stateY in optimalStates.ToArray()) {
	213	if (stateX.Overlaps(stateY) && !stateY.IsSubsetOf(stateX)) {
	214	var stateR1 = new HashSet<int>(stateY);
	215	var stateR2 = new HashSet<int>(stateY);
	216
	217	stateR1.IntersectWith(stateX);
	218	stateR2.ExceptWith(stateX);
	219
	220	optimalStates.Remove(stateY);
	221	optimalStates.Add(stateR1);
	222	optimalStates.Add(stateR2);
	223
	224	if (queue.Contains(stateY)) {
	225	queue.Remove(stateY);
	226	queue.Add(stateR1);
	227	queue.Add(stateR2);
	228	} else {
	229	queue.Add(stateR1.Count <= stateR2.Count ? stateR1 : stateR2);
	230	}
	231	}
	232	}
	233	}
	234	}
	235
	236	// карта получения оптимального состояния по соотвествующему ему простому состоянию
	237	var statesMap = stateAlphabet.Reclassify(optimalStateAlphabet, optimalStates);
	238
	239	// получаем минимальный алфавит
	240	// входные символы не различимы, если Move(s,a1) == Move(s,a2)
	241	var optimalAlphabet = m_transitions
	242	.GroupBy(t => Tuple.Create(statesMap[t.s1], statesMap[t.s2]), t => t.edge);
	243
	244	var alphabetMap = inputAlphabet.Reclassify(optimalInputAlphabet, optimalAlphabet);
	245
	246	// построение автомата
	247	optimalDFA.SetInitialState(statesMap[m_initialState]);
	248
	249	foreach (var sf in m_finalStates.GroupBy(s => statesMap[s]))
	250	optimalDFA.MarkFinalState(sf.Key);
	251
	252	foreach (var t in m_transitions.Select(t => new AutomatonTransition(statesMap[t.s1],statesMap[t.s2],alphabetMap[t.edge])).Distinct())
	253	optimalDFA.Add(t);
	254
	255	}
	256
	257	protected void PrintDFA<TInput, TState>(IAlphabet<TInput> inputAlphabet, IAlphabet<TState> stateAlphabet) {
	258	Safe.ArgumentNotNull(inputAlphabet, "inputAlphabet");
	259	Safe.ArgumentNotNull(stateAlphabet, "stateAlphabet");
	260
	261	var inputMap = inputAlphabet.CreateReverseMap();
	262	var stateMap = stateAlphabet.CreateReverseMap();
	263
	264	for (int i = 0; i < inputMap.Length; i++)
	265	Console.WriteLine("C{0}: {1}", i, String.Join(",", inputMap[i]));
	266
	267
	268	foreach(var t in m_transitions)
	269	Console.WriteLine(
	270	"[{0}] -{{{1}}}-> [{2}]{3}",
	271	stateMap[t.s1],
	272	String.Join(",", inputMap[t.edge]),
	273	stateMap[t.s2],
	274	m_finalStates.Contains(t.s2) ? "$" : ""
	275	);
	276
	277	}
	278
	279	}
	280	}

Implab/Automaton/RegularExpressions/IDFATable2.cs created 644 +9 0

@@ -0,0 +1,9
	1	using System;
	2
	3	namespace Implab.Automaton.RegularExpressions {
	4	public interface IDFATable2<TTag> : IDFATable {
	5	void MarkFinalState(int state, TTag[] tags);
	6
	7	}
	8	}
	9

Implab/Automaton/DFAStateDescriptor.cs +11 0

             namespace Implab.Automaton {
                 public struct DFAStateDescriptior {
                     public readonly bool final;
                     public readonly int[] transitions;
                     public DFAStateDescriptior(int[] transitions, bool final) {
                         this.transitions = transitions;
                         this.final = final;
                     }
                     public DFAStateDescriptior(int[] transitions) : this(transitions, false) {
                     }
+                    public DFAStateDescriptior(int size, bool final) {
+                        Safe.ArgumentInRange(size, 0, int.MaxValue, "size");
+                        this.final = final;
+                        transitions = new int[size];
+                        for (int i = 0; i < size; i++)
+                            transitions[i] = DFAConst.UNREACHABLE_STATE;
+                    }
                 }
             }

Implab/Automaton/RegularExpressions/RegularDFADefinition.cs +2 -2

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

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

Implab/Automaton/DFATransitionTable.cs removed 0 -293

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