private bool IsNext(ProductionPattern pattern)
{
var set = pattern.LookAhead;
var flag = set == null;
return(!flag && set.IsNext(this));
}
private Node ParsePattern(ProductionPattern pattern)
{
var defaultAlt = pattern.DefaultAlternative;
var num = pattern.Count - 1;
Node parsePattern;
for (var i = 0; i <= num; i++)
{
var alt = pattern[i];
// ReSharper disable once PossibleUnintendedReferenceComparison
var flag = defaultAlt != alt && this.IsNext(alt);
if (flag)
{
parsePattern = this.ParseAlternative(alt);
return(parsePattern);
}
}
var flag2 = defaultAlt == null || !this.IsNext(defaultAlt);
if (flag2)
{
this.ThrowParseException(this.FindUnion(pattern));
}
parsePattern = this.ParseAlternative(defaultAlt);
return(parsePattern);
}
private void CheckPattern(ProductionPattern pattern)
{
var num = pattern.Count - 1;
for (var i = 0; i <= num; i++)
{
this.CheckAlternative(pattern.Name, pattern[i]);
}
}
private string ToString(ProductionPattern prod)
{
var buffer = new StringBuilder();
var indent = new StringBuilder();
buffer.Append(prod.Name);
buffer.Append(" (");
buffer.Append(prod.Id);
buffer.Append(") ");
var num = buffer.Length - 1;
for (var i = 0; i <= num; i++)
{
indent.Append(" ");
}
buffer.Append("= ");
indent.Append("| ");
var num2 = prod.Count - 1;
for (var i = 0; i <= num2; i++)
{
var flag = i > 0;
if (flag)
{
buffer.Append(indent);
}
buffer.Append(this.ToString(prod[i]));
buffer.Append("\n");
}
var num3 = prod.Count - 1;
for (var i = 0; i <= num3; i++)
{
var set = prod[i].LookAheadSet;
var flag2 = set.GetMaxLength() > 1;
if (flag2)
{
buffer.Append("Using ");
buffer.Append(set.GetMaxLength());
buffer.Append(" token look-ahead for alternative ");
buffer.Append(i + 1);
buffer.Append(": ");
buffer.Append(set.ToString(this.Tokenizer));
buffer.Append("\n");
}
}
return(buffer.ToString());
}
public override void AddPattern(ProductionPattern pattern)
{
var flag = pattern.IsMatchingEmpty();
if (flag)
{
throw new ParserCreationException(ParserCreationException.ErrorType.INVALID_PRODUCTION, pattern.Name,
"zero elements can be matched (minimum is one)");
}
var flag2 = pattern.IsLeftRecursive();
if (flag2)
{
throw new ParserCreationException(ParserCreationException.ErrorType.INVALID_PRODUCTION, pattern.Name,
"left recursive patterns are not allowed");
}
base.AddPattern(pattern);
}
private LookAheadSet FindLookAhead(ProductionPattern pattern, int length, CallStack stack, LookAheadSet filter)
{
var flag = stack.Contains(pattern.Name, length);
if (flag)
{
throw new ParserCreationException(ParserCreationException.ErrorType.INFINITE_LOOP, pattern.Name, null);
}
stack.Push(pattern.Name, length);
var result = new LookAheadSet(length);
var num = pattern.Count - 1;
for (var i = 0; i <= num; i++)
{
var temp = this.FindLookAhead(pattern[i], length, 0, stack, filter);
result.AddAll(temp);
}
stack.Pop();
return(result);
}
public virtual void AddPattern(ProductionPattern pattern)
{
var flag = pattern.Count <= 0;
if (flag)
{
throw new ParserCreationException(ParserCreationException.ErrorType.INVALID_PRODUCTION, pattern.Name,
"no production alternatives are present (must have at least one)");
}
var flag2 = this.patternIds.ContainsKey(pattern.Id);
if (flag2)
{
throw new ParserCreationException(ParserCreationException.ErrorType.INVALID_PRODUCTION, pattern.Name,
Conversions.ToString(Conversions.ToDouble("another pattern with the same id (")
+ pattern.Id + Conversions.ToDouble(") has already been added")));
}
this.patterns.Add(pattern);
this.patternIds.Add(pattern.Id, pattern);
this.SetInitialized(false);
}
private LookAheadSet FindConflicts(ProductionPattern pattern, int maxLength)
{
var result = new LookAheadSet(maxLength);
var num = pattern.Count - 1;
for (var i = 0; i <= num; i++)
{
var set = pattern[i].LookAheadSet;
var num2 = i - 1;
for (var j = 0; j <= num2; j++)
{
var set2 = pattern[j].LookAheadSet;
result.AddAll(set.CreateIntersection(set2));
}
}
var flag = result.IsRepetitive();
if (flag)
{
this.ThrowAmbiguityException(pattern.Name, null, result);
}
return(result);
}
private LookAheadSet FindUnion(ProductionPattern pattern)
{
var length = 0;
var num = pattern.Count - 1;
LookAheadSet result;
for (var i = 0; i <= num; i++)
{
result = pattern[i].LookAheadSet;
var flag = result.GetMaxLength() > length;
if (flag)
{
length = result.GetMaxLength();
}
}
result = new LookAheadSet(length);
var num2 = pattern.Count - 1;
for (var i = 0; i <= num2; i++)
{
result.AddAll(pattern[i].LookAheadSet);
}
return(result);
}
private void CalculateLookAhead(ProductionPattern pattern)
{
var previous = new LookAheadSet(0);
var length = 1;
var stack = new CallStack();
stack.Push(pattern.Name, 1);
var result = new LookAheadSet(1);
var alternatives = new LookAheadSet[pattern.Count - 1 + 1];
var num = pattern.Count - 1;
for (var i = 0; i <= num; i++)
{
var alt = pattern[i];
alternatives[i] = this.FindLookAhead(alt, 1, 0, stack, null);
alt.LookAheadSet = alternatives[i];
result.AddAll(alternatives[i]);
}
var flag = pattern.LookAhead == null;
if (flag)
{
pattern.LookAhead = result;
}
var conflicts = this.FindConflicts(pattern, 1);
while (conflicts.Size() > 0)
{
length++;
stack.Clear();
stack.Push(pattern.Name, length);
conflicts.AddAll(previous);
var num2 = pattern.Count - 1;
for (var i = 0; i <= num2; i++)
{
var alt = pattern[i];
var flag2 = alternatives[i].Intersects(conflicts);
if (flag2)
{
alternatives[i] = this.FindLookAhead(alt, length, 0, stack, conflicts);
alt.LookAheadSet = alternatives[i];
}
var flag3 = alternatives[i].Intersects(conflicts);
if (flag3)
{
var flag4 = pattern.DefaultAlternative == null;
if (flag4)
{
pattern.DefaultAlternative = alt;
}
else
{
// ReSharper disable once PossibleUnintendedReferenceComparison
var flag5 = pattern.DefaultAlternative != alt;
if (flag5)
{
result = alternatives[i].CreateIntersection(conflicts);
this.ThrowAmbiguityException(pattern.Name, null, result);
}
}
}
}
previous = conflicts;
conflicts = this.FindConflicts(pattern, length);
}
var num3 = pattern.Count - 1;
for (var i = 0; i <= num3; i++)
{
this.CalculateLookAhead(pattern[i], 0);
}
}
public Production(ProductionPattern pattern)
{
this.Pattern = pattern;
this.children = new ArrayList();
}
internal void SetPattern(ProductionPattern pattern)
{
this.Pattern = pattern;
}
