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)); }