public NumberSet Difference(NumberSet setB)
{
NumberSet set2 = new NumberSet();
int index = 0;
int num2 = 0;
while ((index < m_count) | (num2 < setB.Count()))
{
if (index >= m_count)
{
num2++;
}
else if (num2 >= setB.Count())
{
set2.Add(m_list[index]);
index++;
}
else if (m_list[index] == setB[num2])
{
index++;
num2++;
}
else if (m_list[index] < setB[num2])
{
set2.Add(m_list[index]);
index++;
}
else
{
num2++;
}
}
return(set2);
}
public bool UnionWith(NumberSet setB)
{
int index = 0;
int num2 = 0;
bool flag = false;
int num4 = 0;
int[] numArray = new int[(m_count + setB.Count()) + 1];
while ((index < m_count) | (num2 < setB.Count()))
{
int num3;
if (index >= m_count)
{
num3 = setB[num2];
num2++;
flag = true;
}
else if (num2 >= setB.Count())
{
num3 = m_list[index];
index++;
}
else if (m_list[index] == setB[num2])
{
num3 = m_list[index];
index++;
num2++;
}
else if (m_list[index] < setB[num2])
{
num3 = m_list[index];
index++;
}
else
{
num3 = setB[num2];
num2++;
flag = true;
}
num4++;
numArray[num4 - 1] = num3;
}
if (flag)
{
m_count = num4;
m_list = new int[(m_count - 1) + 1];
int num5 = m_count - 1;
for (index = 0; index <= num5; index++)
{
m_list[index] = numArray[index];
}
}
return(flag);
}
public NumberSet(NumberSet numbers)
{
m_blockSize = 0x20;
m_count = numbers.Count();
m_blockSize = 0x10;
ResizeArray(m_count);
int num2 = numbers.Count() - 1;
for (int i = 0; i <= num2; i++)
{
m_list[i] = numbers[i];
}
}
public void Copy(NumberSet list)
{
Clear();
if (list.Count() > 0)
{
m_count = list.Count();
ResizeArray(m_count);
int num2 = list.Count() - 1;
for (int i = 0; i <= num2; i++)
{
m_list[i] = list[i];
}
}
}
public NumberSet Intersection(NumberSet setB)
{
NumberSet set2 = new NumberSet();
int index = 0;
int num2 = 0;
while ((index < m_count) & (num2 < setB.Count()))
{
if (m_list[index] == setB[num2])
{
set2.Add(m_list[index]);
index++;
num2++;
}
else if (m_list[index] < setB[num2])
{
index++;
}
else
{
num2++;
}
}
return(set2);
}
public bool DifferenceWith(NumberSet setB)
{
int index = 0;
int num2 = 0;
int num3 = 0;
while ((index < m_count) | (num2 < setB.Count()))
{
if (index >= m_count)
{
num2++;
}
else if (num2 >= setB.Count())
{
m_list[num3] = m_list[index];
num3++;
index++;
}
else if (m_list[index] == setB[num2])
{
index++;
num2++;
}
else if (m_list[index] < setB[num2])
{
m_list[num3] = m_list[index];
num3++;
index++;
}
else
{
num2++;
}
}
bool flag = m_count != num3;
m_count = num3;
ResizeArray(m_count);
return(flag);
}
public NumberSet Union(NumberSet setB)
{
NumberSet set = new NumberSet();
int index = 0;
int num2 = 0;
while ((index < m_count) | (num2 < setB.Count()))
{
int num3;
if (index >= m_count)
{
num3 = setB[num2];
num2++;
}
else if (num2 >= setB.Count())
{
num3 = m_list[index];
index++;
}
else if (m_list[index] == setB[num2])
{
num3 = m_list[index];
index++;
num2++;
}
else if (m_list[index] < setB[num2])
{
num3 = m_list[index];
index++;
}
else
{
num3 = setB[num2];
num2++;
}
set.Add(num3);
}
return(set);
}
public Compare CompareTo(NumberSet setB)
{
int num;
int count = m_count;
int num4 = setB.Count();
if (count == num4)
{
bool flag = false;
num = 0;
while ((num < count) & !flag)
{
if (m_list[num] != setB[num])
{
flag = true;
}
else
{
num++;
}
}
if (flag)
{
return(Compare.UnEqual);
}
return(Compare.Equal);
}
if (count < num4)
{
num = 0;
int num2 = 0;
while ((num < count) & (num2 < num4))
{
if (m_list[num] == setB[num2])
{
num++;
num2++;
}
else
{
num2++;
}
}
if (num > (count - 1))
{
return(Compare.Subset);
}
return(Compare.UnEqual);
}
return(Compare.UnEqual);
}
private static void ClosureNFA(NumberSet Reachable)
{
short num5 = (short)(Reachable.Count() - 1);
for (short i = 0; i <= num5; i = (short)(i + 1))
{
short num = (short)Reachable[i];
short num6 = (short)(NFA[num].Edges().Count() - 1);
for (short j = 0; j <= num6; j = (short)(j + 1))
{
int target = NFA[num].Edges()[j].Target;
if ((NFA[num].Edges()[j].Characters.Count() == 0) & !Reachable.Contains(target))
{
Reachable.Add(new int[] { target });
ClosureNFA(Reachable);
}
}
}
}
public bool IsEqualSet(NumberSet setB)
{
if (m_count != setB.Count())
{
return(false);
}
int index = 0;
bool flag2 = false;
while ((index <= (Count() - 1)) & !flag2)
{
if (m_list[index] != setB[index])
{
flag2 = true;
}
index++;
}
return(!flag2);
}
public bool IsProperSubsetOf(NumberSet setB)
{
int index = 0;
int num2 = 0;
while ((index < m_count) & (num2 < setB.Count()))
{
if (m_list[index] == setB[num2])
{
index++;
num2++;
}
else
{
num2++;
}
}
if (index < m_count)
{
return(false);
}
return(true);
}
public static void Build()
{
short num3;
NumberSet nFAList = new NumberSet(new int[0]);
NumberSet set2 = new NumberSet(new int[0]);
Notify.Started("Computing DFA States");
SetupForNFA();
BuilderApp.Mode = BuilderApp.ProgramMode.BuildingNFA;
short num5 = (short)(BuilderApp.BuildTables.Symbol.Count() - 1);
for (num3 = 0; num3 <= num5; num3 = (short)(num3 + 1))
{
SymbolBuild sym = BuilderApp.BuildTables.Symbol[num3];
if (sym.UsesDFA)
{
Notify.Text = sym.Name;
CreateNFAStates(sym);
}
}
BuilderApp.Mode = BuilderApp.ProgramMode.NFAClosure;
short num6 = (short)(NFA.Count - 1);
for (num3 = 0; num3 <= num6; num3 = (short)(num3 + 1))
{
NumberSet reachable = new NumberSet(new int[0]);
reachable.Add(new int[] { num3 });
ClosureNFA(reachable);
NFA[num3].NFAClosure = reachable;
}
BuilderApp.BuildTables.CharSet.Clear();
if (NFA.Count <= 1)
{
BuilderApp.Log.Add(SysLogSection.DFA, SysLogAlert.Critical, "There are no terminals in the grammar");
}
else
{
short num2;
BuilderApp.Log.Add(SysLogSection.DFA, SysLogAlert.Detail, "The initial Nondeterministic Finite Automata has " + Conversions.ToString(NFA.Count) + " states");
BuilderApp.BuildTables.DFA.Clear();
BuilderApp.Mode = BuilderApp.ProgramMode.NFACase;
SetupMapCaseCharTables(BuilderApp.BuildTables.Properties["Case Sensitive"].Value.ToUpper() == "TRUE", BuilderApp.GetParamCharMapping());
BuilderApp.Mode = BuilderApp.ProgramMode.BuildingDFA;
nFAList.Add(new int[] { Root });
StartState = BuildDFAState(nFAList);
short num7 = (short)(BuilderApp.BuildTables.DFA.Count - 1);
for (num3 = 0; num3 <= num7; num3 = (short)(num3 + 1))
{
short num8 = (short)(BuilderApp.BuildTables.DFA[num3].Edges().Count() - 1);
num2 = 0;
while (num2 <= num8)
{
FAEdgeBuild build3 = BuilderApp.BuildTables.DFA[num3].Edges()[num2];
CharacterSetBuild characters = build3.Characters;
build3.Characters = characters;
short num4 = BuilderApp.AddCharacterSet(characters);
BuilderApp.BuildTables.DFA[num3].Edges()[num2].Characters = BuilderApp.BuildTables.CharSet[num4];
num2 = (short)(num2 + 1);
}
}
short num9 = (short)(BuilderApp.BuildTables.DFA.Count - 1);
for (num3 = 0; num3 <= num9; num3 = (short)(num3 + 1))
{
FAStateBuild build = BuilderApp.BuildTables.DFA[num3];
if (build.AcceptList.Count() == 0)
{
build.Accept = null;
}
else if (build.AcceptList.Count() == 1)
{
build.Accept = BuilderApp.BuildTables.Symbol[build.AcceptList[0].SymbolIndex];
}
else
{
FAAccept accept = build.AcceptList[0];
set2.Clear();
set2.Add(new int[] { accept.SymbolIndex });
short priority = accept.Priority;
short num10 = (short)(build.AcceptList.Count() - 1);
num2 = 1;
while (num2 <= num10)
{
accept = build.AcceptList[num2];
if (accept.Priority == priority)
{
set2.Add(new int[] { accept.SymbolIndex });
}
else if (accept.Priority < priority)
{
set2.Clear();
set2.Add(new int[] { accept.SymbolIndex });
priority = accept.Priority;
}
num2 = (short)(num2 + 1);
}
build.AcceptList.Clear();
short num11 = (short)(set2.Count() - 1);
for (num2 = 0; num2 <= num11; num2 = (short)(num2 + 1))
{
build.AcceptList.Add((short)set2[num2], priority);
}
if (set2.Count() == 1)
{
build.Accept = BuilderApp.BuildTables.Symbol[set2[0]];
}
}
}
CheckErrorsDFA();
Notify.Completed("DFA States Completed");
}
}
private static short BuildDFAState(NumberSet NFAList)
{
int num4;
NumberSet nFAList = new NumberSet(new int[0]);
FAStateBuild state = new FAStateBuild();
int num8 = NFAList.Count() - 1;
for (num4 = 0; num4 <= num8; num4++)
{
state.NFAStates.UnionWith(NFA[NFAList[num4]].NFAClosure);
}
short num6 = DFAStateNumber(state);
if (num6 == -1)
{
int num3;
FAStateBuild build4;
Notify.Counter++;
num6 = AddDFAState(state);
int num9 = state.NFAStates.Count() - 1;
for (num4 = 0; num4 <= num9; num4++)
{
build4 = NFA[state.NFAStates[num4]];
int num10 = build4.AcceptList.Count() - 1;
num3 = 0;
while (num3 <= num10)
{
FAAccept item = build4.AcceptList[num3];
state.AcceptList.Add(item);
num3++;
}
}
NumberSet set2 = new NumberSet(new int[0]);
FAEdgeList list = new FAEdgeList();
int num11 = state.NFAStates.Count() - 1;
for (num4 = 0; num4 <= num11; num4++)
{
build4 = NFA[state.NFAStates[num4]];
int num12 = build4.Edges().Count() - 1;
num3 = 0;
while (num3 <= num12)
{
if (build4.Edges()[num3].Characters.Count() >= 1)
{
list.Add(build4.Edges()[num3]);
set2.Add(new int[] { build4.Edges()[num3].Target });
}
num3++;
}
}
if (set2.Count() >= 1)
{
CharacterSetBuild build;
FAEdgeBuild build3;
CharacterSetBuild[] buildArray = new CharacterSetBuild[(set2.Count() - 1) + 1];
int num13 = set2.Count() - 1;
for (num4 = 0; num4 <= num13; num4++)
{
Notify.Analyzed++;
build = new CharacterSetBuild();
short num7 = (short)set2[num4];
int num14 = list.Count() - 1;
num3 = 0;
while (num3 <= num14)
{
build3 = (FAEdgeBuild)list[num3];
if (build3.Target == num7)
{
build.UnionWith(build3.Characters);
}
num3++;
}
int num15 = list.Count() - 1;
for (num3 = 0; num3 <= num15; num3++)
{
build3 = (FAEdgeBuild)list[num3];
if (build3.Target != num7)
{
build.DifferenceWith(build3.Characters);
}
}
buildArray[num4] = build;
}
CharacterSetBuild build5 = new CharacterSetBuild();
int num16 = list.Count() - 1;
num3 = 0;
while (num3 <= num16)
{
build5.UnionWith(list[num3].Characters);
num3++;
}
int num17 = set2.Count() - 1;
for (num4 = 0; num4 <= num17; num4++)
{
build5.DifferenceWith(buildArray[num4]);
}
int num18 = set2.Count() - 1;
for (num4 = 0; num4 <= num18; num4++)
{
if (buildArray[num4].Count() >= 1)
{
nFAList = new NumberSet(new int[0]);
nFAList.Add(new int[] { set2[num4] });
Notify.Analyzed++;
state.AddEdge(buildArray[num4], BuildDFAState(nFAList));
}
}
int num19 = build5.Count() - 1;
for (num4 = 0; num4 <= num19; num4++)
{
nFAList = new NumberSet(new int[0]);
int number = build5[num4];
int num20 = list.Count() - 1;
for (num3 = 0; num3 <= num20; num3++)
{
build3 = (FAEdgeBuild)list[num3];
if (build3.Characters.Contains(number))
{
nFAList.Add(new int[] { build3.Target });
}
}
if (nFAList.Count() >= 1)
{
build = new CharacterSetBuild();
build.Add(new int[] { number });
Notify.Analyzed++;
state.AddEdge(build, BuildDFAState(nFAList));
}
}
}
return(num6);
}
return(num6);
}
