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);
}
}
public static IProductionRule ReplaceReferences(IOilexerGrammarFile source, IProductionRule target, IDictionary <IProductionRuleItem, IProductionRuleItem> elementToElementList)
{
List <IProductionRuleItem> result = new List <IProductionRuleItem>();
foreach (var item in target)
{
if (elementToElementList.ContainsKey(item))
{
result.Add(elementToElementList[item]);
}
else
{
if (item is IProductionRuleGroupItem &&
ContainsReferences(source, item, elementToElementList))
{
var gItem = ((IProductionRuleGroupItem)(item));
var rItemElements = ReplaceReferences(source, gItem.ToArray(), elementToElementList);
ProductionRuleGroupItem rItem = new ProductionRuleGroupItem(rItemElements.ToArray(), gItem.Column, gItem.Line, gItem.Position);
rItem.Name = gItem.Name;
rItem.RepeatOptions = gItem.RepeatOptions;
result.Add(rItem);
}
else
{
result.Add(item);
}
}
}
return(new ProductionRule(result, target.FileName, target.Column, target.Line, target.Position));
}
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 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);
}
internal static IProductionRuleItem Expand(this IPreprocessorConditionalReturnDirective directive, IOilexerGrammarProductionRuleEntry currentEntry, IList <IOilexerGrammarTokenEntry> availableStock, ProductionRuleTemplateArgumentSeries argumentLookup, IOilexerGrammarProductionRuleTemplateEntry entry, OilexerGrammarFile file, ICompilerErrorCollection errors)
{
IProductionRule[] result = new IProductionRule[directive.Result.Length];
for (int i = 0; i < directive.Result.Length; i++)
{
result[i] = directive.Result[i].Expand(currentEntry, availableStock, argumentLookup, entry, file, errors);
}
var resultG = new ProductionRuleGroupItem(result, directive.Column, directive.Line, directive.Position);
return(resultG);
}
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);
}
}
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());
}
}
