internal static IProductionRuleGroupItem ExpandTemplates(this IProductionRuleGroupItem groupItem, IList <IOilexerGrammarTokenEntry> availableStock, IOilexerGrammarProductionRuleEntry entry, OilexerGrammarFile file, ICompilerErrorCollection errors)
{
ProductionRuleGroupItem result = new ProductionRuleGroupItem(((IProductionRuleSeries)(groupItem)).ExpandTemplates(availableStock, entry, file, errors).ToArray(), groupItem.Column, groupItem.Line, groupItem.Position);
result.RepeatOptions = groupItem.RepeatOptions;
result.Name = groupItem.Name;
return(result);
}
private static bool EachSubitemIsNamelessGroup(IEnumerable <IProductionRule> series)
{
foreach (var item in series)
{
IProductionRuleGroupItem groupItem = null;
if (!(item.Count == 1 &&
(groupItem = item[0] as IProductionRuleGroupItem) != null &&
groupItem.Name.IsEmptyOrNull() &&
groupItem.RepeatOptions == ScannableEntryItemRepeatInfo.None))
{
return(false);
}
}
return(true);
}
public static IProductionRuleGroupItem Deliteralize(this IProductionRuleGroupItem ruleGroupItem, IOilexerGrammarProductionRuleEntry currentEntry, IList <IOilexerGrammarTokenEntry> availableStock, OilexerGrammarFile file, ICompilerErrorCollection errors)
{
if (((IProductionRuleSeries)(ruleGroupItem)).NeedsDeliteralized())
{
IProductionRuleSeries series = ((IProductionRuleSeries)(ruleGroupItem)).Deliteralize(currentEntry, availableStock, file, errors);
ProductionRuleGroupItem result = new ProductionRuleGroupItem(series.ToArray(), ruleGroupItem.Column, ruleGroupItem.Line, ruleGroupItem.Position);
result.Name = ruleGroupItem.Name;
result.RepeatOptions = ruleGroupItem.RepeatOptions;
return(result);
}
else
{
return(ruleGroupItem);
}
}
public static IProductionRuleGroupItem FinalLink(this IProductionRuleGroupItem ruleGroupItem, IOilexerGrammarProductionRuleEntry currentEntry, OilexerGrammarFile file, ICompilerErrorCollection errors)
{
if (((IProductionRuleSeries)(ruleGroupItem)).NeedsFinalLinking())
{
IProductionRuleSeries series = ((IProductionRuleSeries)(ruleGroupItem)).FinalLink(currentEntry, file, errors);
if (series == null)
{
return(null);
}
ProductionRuleGroupItem result = new ProductionRuleGroupItem(series.ToArray(), ruleGroupItem.Column, ruleGroupItem.Line, ruleGroupItem.Position);
result.Name = ruleGroupItem.Name;
result.RepeatOptions = ruleGroupItem.RepeatOptions;
return(result);
}
else
{
return(ruleGroupItem);
}
}
private static void SetAllNames(IProductionRuleGroupItem ruleGroup, string p)
{
Stack <IProductionRuleSeries> seriesToSet = new Stack <IProductionRuleSeries>();
seriesToSet.Push(ruleGroup);
while (seriesToSet.Count > 0)
{
var curSeries = seriesToSet.Pop();
foreach (var rule in curSeries)
{
foreach (var item in rule)
{
if (item is IProductionRuleGroupItem)
{
seriesToSet.Push((IProductionRuleGroupItem)item);
}
else
{
item.Name = p;
}
}
}
}
}
private static bool AllAreUnnamedEquivalents(IProductionRuleGroupItem ruleGroup)
{
IProductionRuleItem rootItem = null;
return(AllAreUnnamedEquivalents((IProductionRuleSeries)ruleGroup, ref rootItem));
}
internal static IProductionRule ExpandTemplates(this IProductionRule rule, IList <IOilexerGrammarTokenEntry> availableStock, IOilexerGrammarProductionRuleEntry entry, OilexerGrammarFile file, ICompilerErrorCollection errors)
{
List <IProductionRuleItem> result = new List <IProductionRuleItem>();
foreach (IProductionRuleItem ruleItem in rule)
{
if (ruleItem is IProductionRuleGroupItem)
{
var gItem = (IProductionRuleGroupItem)ruleItem;
if (!gItem.NeedsExpansion(entry))
{
result.Add(ruleItem);
}
else if (gItem.Count == 0)
{
continue;
}
else if (gItem.Count == 1 && gItem[0].Count == 1 && gItem.Name.IsEmptyOrNull() && gItem.RepeatOptions == ScannableEntryItemRepeatInfo.None)
{
result.Add(gItem[0][0]);
}
else
{
result.Add(gItem.ExpandTemplates(availableStock, entry, file, errors));
}
}
else if (ruleItem is ITemplateReferenceProductionRuleItem)
{
ITemplateReferenceProductionRuleItem tRef = (ITemplateReferenceProductionRuleItem)ruleItem;
result.Add(tRef.Expand(availableStock, entry, file, errors));
}
else
{
result.Add(ruleItem);
}
}
rebuildResult:
List <IProductionRuleItem> rebuiltResult = new List <IProductionRuleItem>();
foreach (IProductionRuleItem ipri in result)
{
IProductionRuleGroupItem group = null;
if ((group = ipri as IProductionRuleGroupItem) != null && group.Count == 1 && group.Name.IsEmptyOrNull() && group.RepeatOptions == ScannableEntryItemRepeatInfo.None)
{
foreach (IProductionRuleItem iprii in group[0])
{
rebuiltResult.Add(iprii);
}
}
else
{
rebuiltResult.Add(ipri);
}
}
if (rebuiltResult.Count != result.Count)
{
result = rebuiltResult;
goto rebuildResult;
}
return(new ProductionRule(rebuiltResult, rule.FileName, rule.Column, rule.Line, rule.Position));
}
internal void AddRuleGroupRegion(IProductionRuleGroupItem group, long openParen, long endParen)
{
this.myRegions.Add(new OilexerGrammarProductionRuleGroupRegion(group, openParen + 1, endParen));
}
public OilexerGrammarProductionRuleGroupRegion(IProductionRuleGroupItem groupItem, long start, long end)
{
this.Start = (int)start;
this.End = (int)end;
this.groupItem = groupItem;
}
