internal static IProductionRuleGroupItem Expand(this ITemplateReferenceProductionRuleItem ruleItem, IList <IOilexerGrammarTokenEntry> availableStock, IOilexerGrammarProductionRuleEntry entry, OilexerGrammarFile file, ICompilerErrorCollection errors)
{
IProductionRuleGroupItem result = new ProductionRuleGroupItem(ruleItem.Reference.Expand(availableStock, ruleItem, file, errors).ToArray(), ruleItem.Column, ruleItem.Line, ruleItem.Position);
result.RepeatOptions = ruleItem.RepeatOptions;
result.Name = ruleItem.Name;
return(result);
}
internal ProductionRuleTemplateArgumentSeries(IOilexerGrammarProductionRuleTemplateEntry entry, ITemplateReferenceProductionRuleItem reference)
{
TemplateArgumentInformation tai = entry.GetArgumentInformation();
if (tai.InvalidArguments > 0)
{
this.dynLookup = null;
this.fixedLookup = null;
this.Lookup = null;
this.index = int.MinValue;
return;
}
this.fixedLookup = new Dictionary <IProductionRuleTemplatePart, ArgumentData>();
if (tai.DynamicArguments > 0)
{
this.dynLookup = new IDictionary <IProductionRuleTemplatePart, ArgumentData> [(reference.Count - tai.FixedArguments) / tai.DynamicArguments];
}
else
{
this.dynLookup = new IDictionary <IProductionRuleTemplatePart, ArgumentData> [0];
}
for (int i = 0; i < tai.FixedArguments; i++)
{
fixedLookup.Add(entry.Parts[i], new ArgumentData(entry.Parts[i], reference[i]));
}
//Dynamic series index.
for (int i = 0, dSerInd = 0; i < reference.Count - tai.FixedArguments; i += tai.DynamicArguments, dSerInd++)
{
dynLookup[dSerInd] = new Dictionary <IProductionRuleTemplatePart, ArgumentData>();
for (int j = i; j < i + tai.DynamicArguments; j++)
{
dynLookup[dSerInd].Add(entry.Parts[j - i], new ArgumentData(entry.Parts[j - i], reference[j]));
}
}
this.Lookup = null;
this.index = int.MinValue;
}
internal static IProductionRuleItem Expand(this IProductionRuleItem ruleItem, IOilexerGrammarProductionRuleEntry currentEntry, IList <IOilexerGrammarTokenEntry> availableStock, ProductionRuleTemplateArgumentSeries argumentLookup, IOilexerGrammarProductionRuleTemplateEntry entry, OilexerGrammarFile file, ICompilerErrorCollection errors)
{
if (ruleItem is IProductionRulePreprocessorDirective)
{
return(((IProductionRulePreprocessorDirective)(ruleItem)).Expand(currentEntry, availableStock, argumentLookup, entry, file, errors));
}
else if (ruleItem is ITemplateParamReferenceProductionRuleItem)
{
TemplateParamReferenceProductionRuleItem trpri = (TemplateParamReferenceProductionRuleItem)ruleItem;
if (argumentLookup.Lookup.ContainsKey(trpri.Reference))
{
IProductionRuleSeries series = argumentLookup.Lookup[trpri.Reference].Replacement;
/* *
* Fix 4-29-2013
* *
* Series null check, if an error is thrown by the user's template within a replacement
* the result of the replacement is null, thus this is null.
* */
if (series == null)
{
return(null);
}
if (series.Count == 1 && series[0].Count == 1)
{
IProductionRuleItem ipri = series[0][0].Clone();
trpri.CloneData(ipri);
return(ipri);
}
else
{
ProductionRuleGroupItem result = new ProductionRuleGroupItem(series.ToArray(), trpri.Column, trpri.Line, trpri.Position);
trpri.CloneData(result);
return(result);
}
}
else
{
return(trpri.Clone());
}
}
else if (ruleItem is ITemplateReferenceProductionRuleItem)
{
ITemplateReferenceProductionRuleItem rI = ruleItem as TemplateReferenceProductionRuleItem;
List <IProductionRuleSeries> serii = new List <IProductionRuleSeries>();
foreach (IProductionRuleSeries series in rI)
{
var seriesCopy = series;
/* *
* Handle deliteralization here to expedite
* phase 3. If a template yields 5000 literals
* then deliteralizing that will waste a massive
* chunk of processor cycles.
* */
if (series.NeedsDeliteralized())
{
seriesCopy = seriesCopy.Deliteralize(currentEntry, availableStock, file, errors);
}
serii.Add(seriesCopy.Expand(currentEntry, availableStock, argumentLookup, entry, file, errors));
}
TemplateReferenceProductionRuleItem result = new TemplateReferenceProductionRuleItem(rI.Reference, serii, rI.Column, rI.Line, rI.Position);
((TemplateReferenceProductionRuleItem)ruleItem).CloneData(result);
return(result.Expand(availableStock, entry, file, errors));
}
else if (ruleItem is IProductionRuleGroupItem)
{
if (!((IProductionRuleSeries)(ruleItem)).HasExpansion())
{
return(ruleItem.Clone());
}
else
{
ProductionRuleGroupItem result = new ProductionRuleGroupItem(((IProductionRuleSeries)ruleItem).Expand(currentEntry, availableStock, argumentLookup, entry, file, errors).ToArray(), ruleItem.Column, ruleItem.Line, ruleItem.Position);
result.RepeatOptions = ruleItem.RepeatOptions;
result.Name = ruleItem.Name;
return(result);
}
}
else
{
return(ruleItem.Clone());
}
}
internal static IProductionRuleSeries Expand(this IOilexerGrammarProductionRuleTemplateEntry entry, IList <IOilexerGrammarTokenEntry> availableStock, ITemplateReferenceProductionRuleItem dataSource, OilexerGrammarFile file, ICompilerErrorCollection errors)
{
List <IProductionRuleSeries> result = new List <IProductionRuleSeries>();
foreach (ProductionRuleTemplateArgumentSeries prtas in new ProductionRuleTemplateArgumentSeries(entry, dataSource))
{
IProductionRuleSeries item = entry.Expand(entry, availableStock, prtas, entry, file, errors);
if (item == null)
{
continue;
}
if (item.Count == 1 && item[0] == null)
{
continue;
}
else if (item.Count == 1 && item[0].Count == 1 && item[0][0] == null)
{
continue;
}
result.Add(item);
}
if (dataSource.RepeatOptions == ScannableEntryItemRepeatInfo.None && (dataSource.Name == null || dataSource.Name == string.Empty))
{
return(new ProductionRuleSeries(result));
}
else
{
ProductionRuleGroupItem rResult = new ProductionRuleGroupItem(result, dataSource.Column, dataSource.Line, dataSource.Position);
rResult.RepeatOptions = dataSource.RepeatOptions;
rResult.Name = dataSource.Name;
return(rResult);
}
}
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));
}
