public static void Closure(LRConfigSet ConfigSet)
{
LRConfigSet setB = new LRConfigSet();
short num3 = (short)(ConfigSet.Count() - 1);
for (short i = 0; i <= num3; i = (short)(i + 1))
{
LRConfig config2 = ConfigSet[i];
LookaheadSymbolSet set = TotalLookahead(config2);
SymbolBuild build = config2.NextSymbol(0);
if ((build != null) && (build.Type == SymbolType.Nonterminal))
{
LRConfigSet partialClosure = build.PartialClosure;
short num4 = (short)(partialClosure.Count() - 1);
for (short j = 0; j <= num4; j = (short)(j + 1))
{
LRConfig config = partialClosure[j];
LRConfig item = new LRConfig(config.Parent, 0, config.LookaheadSet);
if (config.InheritLookahead)
{
item.LookaheadSet.UnionWith(set);
}
setB.Add(item);
}
}
}
ConfigSet.UnionWith(setB);
}
private static LookaheadSymbolSet TotalLookahead(LRConfig Config)
{
bool flag;
LookaheadSymbolSet set = new LookaheadSymbolSet();
for (int i = 0; (i < Config.CheckaheadCount()) & !flag; i++)
{
short offset = (short)i;
i = offset;
SymbolBuild build = Config.Checkahead(offset);
ConfigTrackSource source = (ConfigTrackSource)Conversions.ToInteger(Interaction.IIf(build.Type == SymbolType.Nonterminal, ConfigTrackSource.First, ConfigTrackSource.Config));
int num4 = build.First.Count() - 1;
for (int j = 0; j <= num4; j++)
{
LookaheadSymbol item = new LookaheadSymbol(build.First[j]);
if (item.Parent.Type != SymbolType.Nonterminal)
{
item.Configs.Add(new ConfigTrack(Config, source));
set.Add(item);
}
}
flag = !build.Nullable;
}
if (!flag)
{
set.UnionWith(Config.LookaheadSet);
}
return(set);
}
private static void ComputeLRState(LRStateBuild State)
{
short num2;
SymbolBuild build2;
short num3 = (short)(BuilderApp.BuildTables.Symbol.Count() - 1);
for (num2 = 0; num2 <= num3; num2 = (short)(num2 + 1))
{
GotoList[num2] = null;
}
short num4 = (short)(State.ConfigSet.Count() - 1);
for (num2 = 0; num2 <= num4; num2 = (short)(num2 + 1))
{
LRConfig config = State.ConfigSet[num2];
build2 = config.NextSymbol(0);
if (build2 != null)
{
short tableIndex = build2.TableIndex;
if (GotoList[tableIndex] == null)
{
GotoList[tableIndex] = new LRConfigSet();
}
LRConfig item = new LRConfig(config.Parent, config.Position + 1, config.LookaheadSet);
GotoList[tableIndex].Add(item);
}
}
short num5 = (short)(BuilderApp.BuildTables.Symbol.Count() - 1);
for (num2 = 0; num2 <= num5; num2 = (short)(num2 + 1))
{
if (GotoList[num2] == null)
{
continue;
}
build2 = BuilderApp.BuildTables.Symbol[num2];
Closure(GotoList[num2]);
LRStateBuild state = new LRStateBuild
{
ConfigSet = GotoList[num2]
};
switch (build2.Type)
{
case SymbolType.Nonterminal:
{
State.Add(new LRAction(build2, LRActionType.Goto, CreateLRState(state)));
Notify.Analyzed++;
continue;
}
case SymbolType.End:
{
State.Add(new LRAction(build2, LRActionType.Accept));
continue;
}
}
State.Add(new LRAction(build2, LRActionType.Shift, CreateLRState(state)));
Notify.Analyzed++;
}
}
public bool IsLessThan(LRConfig ConfigB)
{
if (this.Position != ConfigB.Position)
{
return(this.Position > ConfigB.Position);
}
return((this.Parent.TableIndex != ConfigB.TableIndex()) && (this.Parent.TableIndex < ConfigB.TableIndex()));
}
public LRConfig(LRConfig Config)
{
this.LookaheadSet = new LookaheadSymbolSet();
this.Parent = Config.Parent;
this.Position = Config.Position;
this.LookaheadSet = new LookaheadSymbolSet();
this.Modified = Config.Modified;
this.InheritLookahead = Config.InheritLookahead;
this.LookaheadSet.Copy(Config.LookaheadSet);
}
private static bool PopulateLookahead(LRConfig Config)
{
if (Config.InheritLookahead)
{
bool flag = false;
for (short i = 0; (i < Config.CheckaheadCount()) & !flag; i = (short)(i + 1))
{
flag = !Config.Checkahead(i).Nullable;
}
return(!flag);
}
return(false);
}
public int CompareTo(object obj)
{
LRConfig config = (LRConfig)obj;
if (this.IsEqualTo(config))
{
return(0);
}
if (this.IsLessThan(config))
{
return(-1);
}
return(1);
}
public DictionarySet.MemberResult Union(DictionarySet.IMember NewObject)
{
bool flag;
LRConfig config = (LRConfig)NewObject;
LRConfig newObject = new LRConfig(this);
if (newObject.LookaheadSet.UnionWith(config.LookaheadSet))
{
flag = true;
newObject.Modified = true;
}
else
{
newObject.Modified = this.Modified | config.Modified;
flag = false;
}
newObject.InheritLookahead = this.InheritLookahead | config.InheritLookahead;
return(new DictionarySet.MemberResult(newObject, flag));
}
public LRConfigCompare CompareCore(LRConfig ConfigB)
{
if ((this.Parent.TableIndex == ConfigB.TableIndex()) & (this.Position == ConfigB.Position))
{
LRConfigCompare compare2;
switch (this.LookaheadSet.CompareTo(ConfigB.LookaheadSet))
{
case DictionarySet.Compare.Equal:
return(LRConfigCompare.EqualFull);
case DictionarySet.Compare.UnEqual:
return(LRConfigCompare.EqualCore);
case DictionarySet.Compare.Subset:
return(LRConfigCompare.ProperSubset);
}
return(compare2);
}
return(LRConfigCompare.UnEqual);
}
private static LRStateBuild CreateInitialState(Symbol StartSymbol)
{
ProductionBuild rule = new ProductionBuild();
SymbolBuild nonTerminal = new SymbolBuild
{
Type = SymbolType.Nonterminal,
Name = "S'"
};
rule.SetHead(nonTerminal);
rule.Handle().Add((SymbolBuild)StartSymbol);
rule.Handle().Add((SymbolBuild)BuilderApp.BuildTables.Symbol.GetFirstOfType(SymbolType.End));
LRConfig item = new LRConfig(rule);
LRStateBuild build3 = new LRStateBuild();
build3.ConfigSet.Add(item);
build3.Expanded = false;
Closure(build3.ConfigSet);
return(build3);
}
private static LRStateBuild GotoSymbol(LRStateBuild State, SymbolBuild TheSymbol)
{
LRStateBuild build2 = new LRStateBuild();
short num2 = (short)(State.ConfigSet.Count() - 1);
for (short i = 0; i <= num2; i = (short)(i + 1))
{
LRConfig config = State.ConfigSet[i];
Symbol symbol = config.NextSymbol(0);
if ((symbol != null) && symbol.IsEqualTo(TheSymbol))
{
LRConfig item = new LRConfig(config.Parent, config.Position + 1, config.LookaheadSet);
build2.ConfigSet.Add(item);
}
}
if (build2.ConfigSet.Count() >= 1)
{
Closure(build2.ConfigSet);
}
return(build2);
}
public ConfigTrack(LRConfig Config, ConfigTrackSource Source)
{
this.Parent = Config;
this.FromConfig = Source == ConfigTrackSource.Config;
this.FromFirst = Source == ConfigTrackSource.First;
}
private static LRConfigSet GetClosureConfigSet(SymbolBuild Sym)
{
bool flag;
LRConfig config;
short num2;
SymbolBuild build;
LRConfig config2;
ProductionBuild build2;
LRConfigSet setB = new LRConfigSet();
LRConfigSet set = new LRConfigSet();
short num3 = (short)(BuilderApp.BuildTables.Production.Count() - 1);
short num = 0;
while (num <= num3)
{
build2 = BuilderApp.BuildTables.Production[num];
if (build2.Head.IsEqualTo(Sym))
{
config2 = new LRConfig
{
Position = 0,
Modified = true,
LookaheadSet = new LookaheadSymbolSet(),
Parent = build2,
InheritLookahead = true
};
set.Add(config2);
}
num = (short)(num + 1);
}
do
{
setB.Clear();
flag = false;
short num4 = (short)(set.Count() - 1);
num2 = 0;
while (num2 <= num4)
{
config = set[num2];
if (!config.IsComplete() & config.Modified)
{
build = config.NextSymbol(0);
if (build.Type == SymbolType.Nonterminal)
{
short num5 = (short)(BuilderApp.BuildTables.Production.Count() - 1);
num = 0;
while (num <= num5)
{
build2 = BuilderApp.BuildTables.Production[num];
if (build2.Head.IsEqualTo(build))
{
config2 = new LRConfig(build2, 0, TotalLookahead(config));
setB.Add(config2);
}
num = (short)(num + 1);
}
}
set[num2].Modified = false;
}
num2 = (short)(num2 + 1);
}
}while (set.UnionWith(setB));
do
{
flag = false;
short num6 = (short)(set.Count() - 1);
for (num2 = 0; num2 <= num6; num2 = (short)(num2 + 1))
{
config = set[num2];
build = config.NextSymbol(0);
if ((build != null) && ((config.InheritLookahead & PopulateLookahead(config)) & (build.Type == SymbolType.Nonterminal)))
{
short num7 = (short)(set.Count() - 1);
for (num = 0; num <= num7; num = (short)(num + 1))
{
config = set[num];
if (((config.Position == 0) & config.Parent.Head.IsEqualTo(build)) & !config.InheritLookahead)
{
config.InheritLookahead = true;
flag = true;
}
}
}
}
}while (flag);
return(set);
}
public bool IsGreaterThan(LRConfig ConfigB)
{
LRConfig configB = this;
return(ConfigB.IsLessThan(configB));
}
public bool IsEqualTo(LRConfig Config)
{
return((this.Parent.TableIndex == Config.TableIndex()) & (this.Position == Config.Position));
}
public bool HasEqualCore(LRConfig Config)
{
return(this.IsEqualTo(Config));
}
private static void ComputeReductions()
{
LRConflictItem[] itemArray = new LRConflictItem[BuilderApp.BuildTables.Symbol.Count() + 1];
short num4 = (short)(BuilderApp.BuildTables.LALR.Count - 1);
for (short i = 0; i <= num4; i = (short)(i + 1))
{
LRConflict shiftReduce;
LRStateBuild build = BuilderApp.BuildTables.LALR[i];
short num5 = (short)(BuilderApp.BuildTables.Symbol.Count() - 1);
short index = 0;
while (index <= num5)
{
itemArray[index] = new LRConflictItem(BuilderApp.BuildTables.Symbol[index]);
index = (short)(index + 1);
}
short num6 = (short)(build.ConfigSet.Count() - 1);
short num2 = 0;
while (num2 <= num6)
{
short num7;
LRConfig item = build.ConfigSet[num2];
switch (((int)item.NextAction()))
{
case 1:
itemArray[item.NextSymbol(0).TableIndex].Shifts.Add(item);
goto Label_0137;
case 2:
num7 = (short)(item.LookaheadSet.Count() - 1);
index = 0;
goto Label_012D;
default:
goto Label_0137;
}
Label_0100:
itemArray[item.LookaheadSet[index].Parent.TableIndex].Reduces.Add(item);
index = (short)(index + 1);
Label_012D:
if (index <= num7)
{
goto Label_0100;
}
Label_0137:
num2 = (short)(num2 + 1);
}
short num8 = (short)(BuilderApp.BuildTables.Symbol.Count() - 1);
index = 0;
while (index <= num8)
{
if ((itemArray[index].Shifts.Count() >= 1) & (itemArray[index].Reduces.Count() >= 1))
{
short num9 = (short)(itemArray[index].Shifts.Count() - 1);
num2 = 0;
while (num2 <= num9)
{
itemArray[index].Shifts[num2].Status = LRStatus.Warning;
num2 = (short)(num2 + 1);
}
short num10 = (short)(itemArray[index].Reduces.Count() - 1);
num2 = 0;
while (num2 <= num10)
{
itemArray[index].Reduces[num2].Status = LRStatus.Warning;
num2 = (short)(num2 + 1);
}
build.Status = LRStatus.Warning;
build.Note = "Shift-Reduce Conflict";
build.ConflictList.Add(new LRConflictItem(itemArray[index], LRConflict.ShiftReduce));
shiftReduce = LRConflict.ShiftReduce;
BuilderApp.Log.Add(SysLogSection.LALR, SysLogAlert.Warning, "A Shift-Reduce Conflict was fixed", BuilderApp.BuildTables.Symbol[index].Text(false) + " can follow a completed rule and also be shifted." + GetConflictResolvedDesc(shiftReduce), Conversions.ToString((int)i));
}
index = (short)(index + 1);
}
short num11 = (short)(BuilderApp.BuildTables.Symbol.Count() - 1);
for (index = 0; index <= num11; index = (short)(index + 1))
{
if ((itemArray[index].Reduces.Count() == 1) & (itemArray[index].Shifts.Count() == 0))
{
SymbolBuild theSymbol = BuilderApp.BuildTables.Symbol[index];
build.Add(new LRAction(theSymbol, LRActionType.Reduce, itemArray[index].Reduces[0].Parent.TableIndex));
}
else if (itemArray[index].Reduces.Count() > 1)
{
short num12 = (short)(itemArray[index].Reduces.Count() - 1);
for (num2 = 0; num2 <= num12; num2 = (short)(num2 + 1))
{
itemArray[index].Reduces[num2].Status = LRStatus.Critical;
}
build.Status = LRStatus.Critical;
build.Note = "Reduce-Reduce Conflict";
build.ConflictList.Add(new LRConflictItem(itemArray[index], LRConflict.ReduceReduce));
shiftReduce = LRConflict.ReduceReduce;
BuilderApp.Log.Add(SysLogSection.LALR, SysLogAlert.Critical, "Reduce-Reduce Conflict", BuilderApp.BuildTables.Symbol[index].Text(false) + " can follow more than one completed rule. " + GetConflictDesc(shiftReduce), Conversions.ToString((int)i));
}
}
}
}
// Methods
public ConfigTrack(ConfigTrack Track)
{
this.Parent = Track.Parent;
this.FromConfig = Track.FromConfig;
this.FromFirst = Track.FromFirst;
}
