public void ResolvedSinglePartToTemplateParameter(IOilexerGrammarProductionRuleTemplateEntry entry, IProductionRuleTemplatePart iprtp, ISoftReferenceProductionRuleItem item) { if (item.PrimaryToken != null) { this.handler.ReclassifyToken(item.PrimaryToken, iprtp); } }
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); } }
/// <summary> /// Creates a new <see cref="TemplateReferenceProductionRuleItem"/> with the <paramref name="reference"/>, /// <paramref name="parts"/>, <paramref name="column"/>, <paramref name="line"/>, and /// <paramref name="position"/> provided. /// </summary> /// <param name="reference">The <see cref="IOilexerGrammarProductionRuleTemplateEntry"/> which /// is referenced by the <see cref="TemplateReferenceProductionRuleItem"/>.</param> /// <param name="parts">The <see cref="IProductionRuleSeries"/> collection which denotes the /// parameters passed to the template expansion request.</param> /// <param name="column">The column on <paramref name="line"/> at which the <see cref="TemplateReferenceProductionRuleItem"/> was /// defined.</param> /// <param name="line">The line at which the <see cref="TemplateReferenceProductionRuleItem"/> was defined.</param> /// <param name="position">The byte in the file at which the <see cref="TemplateReferenceProductionRuleItem"/> was declared.</param> public TemplateReferenceProductionRuleItem(IOilexerGrammarProductionRuleTemplateEntry reference, IList <IProductionRuleSeries> parts, int column, int line, long position) : base(parts) { this.column = column; this.line = line; this.position = position; this.reference = reference; }
public TemplateReferenceProductionRuleItem(Dictionary <string, string> constraints, IOilexerGrammarProductionRuleTemplateEntry reference, ICollection <IProductionRuleSeries> parts, int column, int line, long position) { this.ConditionalConstraints = new ControlledDictionary <string, string>(constraints); foreach (IProductionRuleSeries iprs in parts) { baseList.Add(iprs); } this.column = column; this.line = line; this.position = position; this.reference = reference; }
private static void ResolveProductionRuleTemplate(this IOilexerGrammarProductionRuleTemplateEntry entry, OilexerGrammarFile file, ICompilerErrorCollection errors) { foreach (ProductionRuleTemplatePart part in entry.Parts) { IOilexerGrammarTokenEntry reference = null; if (part.SpecialExpectancy == TemplatePartExpectedSpecial.None && part.ExpectedSpecific != null && part.ExpectedSpecific is ISoftReferenceProductionRuleItem) { var softExpect = part.ExpectedSpecific as ISoftReferenceProductionRuleItem; if ((reference = tokenEntries.OilexerGrammarFindScannableEntry(softExpect.PrimaryName)) != null) { part.ExpectedSpecific = new TokenReferenceProductionRuleItem(reference, part.Column, part.Line, part.Position); if (resolutionAid != null) resolutionAid.ResolvedSinglePartToToken(softExpect, reference); } else errors.SourceModelError<ISoftReferenceProductionRuleItem>(OilexerGrammarCore.CompilerErrors.UndefinedTokenReference, new LineColumnPair(part.ExpectedSpecific.Column, part.ExpectedSpecific.Line), LineColumnPair.Zero, new Uri(entry.FileName, UriKind.RelativeOrAbsolute), softExpect, string.Format(" '{0}'", softExpect.PrimaryName)); return; } } }
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 bool IsDefined(this IPreprocessorCLogicalOrConditionExp expression, IOilexerGrammarProductionRuleEntry currentEntry, IList <IOilexerGrammarTokenEntry> availableStock, ProductionRuleTemplateArgumentSeries argumentLookup, IOilexerGrammarProductionRuleTemplateEntry entry, OilexerGrammarFile file, ICompilerErrorCollection errors) { if (expression.Left == null && expression.Right.Left == null && expression.Right.Right.Rule == 3 && expression.Right.Right.PreCPrimary.Rule == 4) { string name = expression.Right.Right.PreCPrimary.Identifier.Name; if (argumentLookup.ContainsParameter(name)) { IProductionRuleTemplatePart iprtp = argumentLookup.GetParameter(name); if (iprtp.SpecialExpectancy == TemplatePartExpectedSpecial.Rule) { IProductionRuleSeries iprs = argumentLookup[name]; if (iprs.Count == 1 && iprs[0].Count == 1) { IProductionRuleItem ipri = iprs[0][0]; if (ipri != null) { if (ipri is IRuleReferenceProductionRuleItem) { name = ((IRuleReferenceProductionRuleItem)(ipri)).Reference.Name; } else if (ipri is ISoftReferenceProductionRuleItem) { //No guarantee that just being a soft-reference guarantees //lack of definition. //Reason: if another template defines this later, //it exists, but hasn't been resolved. -- It will be later in the expansion/resolution phase. name = ((ISoftReferenceProductionRuleItem)(ipri)).PrimaryName; } } } } else { errors.SourceError(OilexerGrammarCore.CompilerErrors.IsDefinedTemplateParameterMustExpectRule, new LineColumnPair(expression.Line, expression.Column), LineColumnPair.Zero, new Uri(entry.FileName, UriKind.RelativeOrAbsolute), name); } } foreach (IOilexerGrammarEntry ientry in file.ToArray()) { if (ientry is IOilexerGrammarProductionRuleEntry && (!(ientry is IOilexerGrammarProductionRuleTemplateEntry))) { if (((IOilexerGrammarProductionRuleEntry)ientry).Name == name) { return(true); } } } return(false); } errors.SourceError(OilexerGrammarCore.CompilerErrors.InvalidDefinedTarget, new LineColumnPair(expression.Line, expression.Column), LineColumnPair.Zero, new Uri(entry.FileName, UriKind.RelativeOrAbsolute), expression.ToString()); return(false); }
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 IProductionRule Expand(this IProductionRule rule, IOilexerGrammarProductionRuleEntry currentEntry, IList <IOilexerGrammarTokenEntry> availableStock, ProductionRuleTemplateArgumentSeries argumentLookup, IOilexerGrammarProductionRuleTemplateEntry entry, OilexerGrammarFile file, ICompilerErrorCollection errors) { if (rule.HasExpansion()) { List <IProductionRuleItem> result = new List <IProductionRuleItem>(); foreach (IProductionRuleItem item in rule) { IProductionRuleItem ipri = null; if (item.HasExpansion()) { ipri = item.Expand(currentEntry, availableStock, argumentLookup, entry, file, errors); } else { ipri = item.Clone(); } if (ipri == null) { continue; } result.Add(ipri); } rebuildResult: List <IProductionRuleItem> rebuiltResult = new List <IProductionRuleItem>(); foreach (IProductionRuleItem ipri in result) { if (ipri is IProductionRuleGroupItem && ((IProductionRuleGroupItem)(ipri)).Count == 1 && (ipri.Name == null || ipri.Name == string.Empty) && ipri.RepeatOptions == ScannableEntryItemRepeatInfo.None) { foreach (IProductionRuleItem iprii in ((IProductionRuleGroupItem)(ipri))[0]) { rebuiltResult.Add(iprii); } } else { rebuiltResult.Add(ipri); } } if (rebuiltResult.Count != result.Count) { result = rebuiltResult; goto rebuildResult; } if (result.Count == 0) { return(null); } return(new ProductionRule(result, rule.FileName, rule.Column, rule.Line, rule.Position)); } else { return(rule); } }
internal static void Expand(this IPreprocessorDefineRuleDirective directive, IOilexerGrammarProductionRuleEntry currentEntry, IList <IOilexerGrammarTokenEntry> availableStock, ProductionRuleTemplateArgumentSeries argumentLookup, IOilexerGrammarProductionRuleTemplateEntry entry, OilexerGrammarFile file, ICompilerErrorCollection errors) { string search = directive.DeclareTarget; if (search != null && search != string.Empty) { if (argumentLookup.ContainsParameter(search)) { IProductionRuleTemplatePart part = argumentLookup.GetParameter(search); IProductionRuleSeries iprs = argumentLookup[part]; if (iprs.Count == 1 && iprs[0].Count == 1) { IProductionRuleItem ipri = iprs[0][0]; if (ipri is ISoftReferenceProductionRuleItem) { ISoftReferenceProductionRuleItem n = (ISoftReferenceProductionRuleItem)ipri; search = n.PrimaryName; } } } /* ToDo: Evaluate the depth necessary to institute a lock associated to the base list on the oilexer grammar file type. */ IOilexerGrammarEntry[] fileElements; lock (file) fileElements = file.ToArray(); foreach (IOilexerGrammarEntry ie in fileElements) { if (ie is IOilexerGrammarNamedEntry && ((IOilexerGrammarNamedEntry)ie).Name == search) { errors.SourceError(OilexerGrammarCore.CompilerErrors.DuplicateTermDefined, new LineColumnPair(directive.Line, directive.Column), LineColumnPair.Zero, new Uri(entry.FileName, UriKind.RelativeOrAbsolute), search); return; } } OilexerGrammarProductionRuleEntry insertedItem = new OilexerGrammarProductionRuleEntry(search, entry.ScanMode, entry.FileName, directive.Column, directive.Line, directive.Position); lock (file) file.Add(insertedItem); foreach (IProductionRule ipr in directive.DefinedRules) { IProductionRule expanded = ipr.Expand(currentEntry, availableStock, argumentLookup, entry, file, errors); insertedItem.Add(expanded); } } }
/// <summary> /// Creates a new <see cref="TemplateParamReferenceProductionRuleItem"/> with the /// <paramref name="column"/>, <paramref name="line"/>, and <paramref name="position"/>. /// </summary> /// <param name="column">The column on <paramref name="line"/> at which the <see cref="TemplateParamReferenceProductionRuleItem"/> was /// defined.</param> /// <param name="line">The line at which the <see cref="TemplateParamReferenceProductionRuleItem"/> was defined.</param> /// <param name="position">The byte in the file at which the <see cref="TemplateParamReferenceProductionRuleItem"/> was declared.</param> public TemplateParamReferenceProductionRuleItem(IOilexerGrammarProductionRuleTemplateEntry source, IProductionRuleTemplatePart reference, int column, int line, long position) : base(column, line, position) { this.source = source; this.reference = reference; }
internal static IProductionRuleSeries Expand(this IProductionRuleSeries series, IOilexerGrammarProductionRuleEntry currentEntry, IList <IOilexerGrammarTokenEntry> availableStock, ProductionRuleTemplateArgumentSeries argumentLookup, IOilexerGrammarProductionRuleTemplateEntry entry, OilexerGrammarFile file, ICompilerErrorCollection errors) { List <IProductionRule> result = new List <IProductionRule>(); foreach (IProductionRule ipr in series) { IProductionRule resultedItem = null; if (ipr.HasExpansion()) { resultedItem = ipr.Expand(currentEntry, availableStock, argumentLookup, entry, file, errors); } else { resultedItem = ipr; } if (resultedItem == null) { continue; } result.Add(resultedItem); } if (result.Count == 0) { return(null); } return(new ProductionRuleSeries(result)); }
internal static void Expand(this IPreprocessorAddRuleDirective directive, IOilexerGrammarProductionRuleEntry currentEntry, IList <IOilexerGrammarTokenEntry> availableStock, ProductionRuleTemplateArgumentSeries argumentLookup, IOilexerGrammarProductionRuleTemplateEntry entry, OilexerGrammarFile file, ICompilerErrorCollection errors) { string search = directive.InsertTarget; if (search != null && search != string.Empty) { OilexerGrammarProductionRuleEntry foundItem = null; if (argumentLookup.ContainsParameter(search)) { IProductionRuleTemplatePart part = argumentLookup.GetParameter(search); IProductionRuleSeries iprs = argumentLookup[part]; if (iprs.Count == 1 && iprs[0].Count == 1) { IProductionRuleItem ipri = iprs[0][0]; if (ipri is ISoftReferenceProductionRuleItem) { ISoftReferenceProductionRuleItem n = (ISoftReferenceProductionRuleItem)ipri; search = n.PrimaryName; } else if (ipri is IRuleReferenceProductionRuleItem) { foundItem = (OilexerGrammarProductionRuleEntry)((IRuleReferenceProductionRuleItem)(ipri)).Reference; } } } if (foundItem == null) { foreach (IOilexerGrammarEntry ie in file) { if (ie is OilexerGrammarProductionRuleEntry && ((OilexerGrammarProductionRuleEntry)ie).Name == search) { foundItem = ie as OilexerGrammarProductionRuleEntry; break; } } } if (foundItem == null) { errors.SourceError(OilexerGrammarCore.CompilerErrors.UndefinedAddRuleTarget, new LineColumnPair(directive.Line, directive.Column), LineColumnPair.Zero, new Uri(entry.FileName, UriKind.RelativeOrAbsolute), string.Join <IProductionRule>(" | ", directive.Rules), search); return; } foreach (IProductionRule ipr in directive.Rules) { foundItem.Add(ipr.Expand(currentEntry, availableStock, argumentLookup, entry, file, errors)); } } }
internal void ReclassifyToken(OilexerGrammarTokens.IdentifierToken identifierToken, IOilexerGrammarProductionRuleTemplateEntry primary) { if (reclassifications.ContainsKey(identifierToken)) { return; } reclassifications.Add(identifierToken, OilexerGrammarTokenType.RuleTemplateReference); }
internal static IProductionRuleItem Expand(this IProductionRulePreprocessorDirective directive, IOilexerGrammarProductionRuleEntry currentEntry, IList <IOilexerGrammarTokenEntry> availableStock, ProductionRuleTemplateArgumentSeries argumentLookup, IOilexerGrammarProductionRuleTemplateEntry entry, OilexerGrammarFile file, ICompilerErrorCollection errors) { return(directive.Directive.Expand(currentEntry, availableStock, argumentLookup, entry, file, errors)); }
internal static IProductionRuleItem Expand(this IPreprocessorIfDirective directive, IOilexerGrammarProductionRuleEntry currentEntry, IList <IOilexerGrammarTokenEntry> availableStock, ProductionRuleTemplateArgumentSeries argumentLookup, IOilexerGrammarProductionRuleTemplateEntry entry, OilexerGrammarFile file, ICompilerErrorCollection errors) { bool process = true; if (directive.Type != EntryPreprocessorType.Else) { switch (directive.Type) { case EntryPreprocessorType.If: case EntryPreprocessorType.ElseIf: process = directive.Condition.Evaluate(currentEntry, availableStock, argumentLookup, entry, file, errors); break; case EntryPreprocessorType.IfNotDefined: process = !directive.Condition.IsDefined(currentEntry, availableStock, argumentLookup, entry, file, errors); break; case EntryPreprocessorType.ElseIfDefined: case EntryPreprocessorType.IfDefined: process = directive.Condition.IsDefined(currentEntry, availableStock, argumentLookup, entry, file, errors); break; default: break; } } if (process) { List <IProductionRuleItem> result = new List <IProductionRuleItem>(); foreach (IPreprocessorDirective ipd in directive.Body) { IProductionRuleItem ipri = ipd.Expand(currentEntry, availableStock, argumentLookup, entry, file, errors); if (ipri != null) { result.Add(ipri); } } if (result.Count > 1) { return(new ProductionRuleGroupItem(new IProductionRule[] { new ProductionRule(result, entry.FileName, entry.Column, entry.Line, entry.Position) }, directive.Column, directive.Line, directive.Position)); } else if (result.Count > 0) { return(result[0]); } else { return(null); } } else if (directive.Next != null) { return(directive.Next.Expand(currentEntry, availableStock, argumentLookup, entry, file, errors)); } return(null); }
internal static object Evaluate(this IPreprocessorCPrimary expression, IOilexerGrammarProductionRuleEntry currentEntry, IList <IOilexerGrammarTokenEntry> availableStock, ProductionRuleTemplateArgumentSeries argumentLookup, IOilexerGrammarProductionRuleTemplateEntry entry, OilexerGrammarFile file, ICompilerErrorCollection errors) { switch (expression.Rule) { case 1: return(expression.String); case 2: return(expression.Char); case 3: return(expression.PreCLogicalOrExp.Evaluate(currentEntry, availableStock, argumentLookup, entry, file, errors)); case 4: return(expression.Identifier.Name); case 5: return(expression.Number); } return(null); }
internal static object Evaluate(this IPreprocessorCEqualityExp expression, IOilexerGrammarProductionRuleEntry currentEntry, IList <IOilexerGrammarTokenEntry> availableStock, ProductionRuleTemplateArgumentSeries argumentLookup, IOilexerGrammarProductionRuleTemplateEntry entry, OilexerGrammarFile file, ICompilerErrorCollection errors) { IOilexerGrammarTokenEntry lookup; ILiteralTokenItem reference = null; //Hack #1. if (expression.Rule == 1 || expression.Rule == 2) { string name = null; //If the left side is a parameter reference and the right side //is an identifier... if (expression.PreCEqualityExp.Rule == 3 && expression.PreCPrimary.Rule == 4 && expression.PreCEqualityExp.PreCPrimary.Rule == 4 && argumentLookup.ContainsParameter(name = expression.PreCEqualityExp.PreCPrimary.Identifier.Name)) { //Obtain the parameter IProductionRuleTemplatePart part = argumentLookup.GetParameter(name); if (part.SpecialExpectancy == TemplatePartExpectedSpecial.None && part.ExpectedSpecific != null) { //If the specific expectency is a production rule reference... if (part.ExpectedSpecific is ITokenReferenceProductionRuleItem) { //Lookup the expectency. ILiteralTokenItem secondHalf = null; lookup = ((ITokenReferenceProductionRuleItem)(part.ExpectedSpecific)).Reference; //Lookup the right-hand requirement for the condition. ITokenItem sRef = lookup.FindTokenItem(expression.PreCPrimary.Identifier.Name); if (sRef is ILiteralTokenItem) { reference = ((ILiteralTokenItem)(sRef)); } else { goto notValidReference; } //Obtain the expression series for the left-hand side. IProductionRuleSeries series = argumentLookup[part]; //If it's a single unit. if (series.Count == 1 && series[0].Count == 1) { //If it's a soft-reference item... IProductionRuleItem e = series[0][0]; if (e is ISoftReferenceProductionRuleItem) { ISoftReferenceProductionRuleItem sre = ((ISoftReferenceProductionRuleItem)e); if (((sre.SecondaryName == null || sre.SecondaryName == string.Empty)) && sre.PrimaryName != null) { secondHalf = (ILiteralTokenItem)lookup.FindTokenItemByValue(sre.PrimaryName, file, true); } } //If they used the fully qualified name... else if (e is ILiteralReferenceProductionRuleItem) { ILiteralReferenceProductionRuleItem lr = ((ILiteralReferenceProductionRuleItem)e); //So much easier... secondHalf = lr.Literal; } if (expression.Rule == 1) { return(secondHalf == reference); } else if (expression.Rule == 2) { return(secondHalf != reference); } } } } } else if (expression.PreCEqualityExp.Rule == 3 && expression.PreCPrimary.Rule == 5 && expression.PreCEqualityExp.PreCPrimary.Rule == 4 && expression.PreCEqualityExp.PreCPrimary.Identifier.Name.ToLower() == "index") { if (expression.Rule == 1) { return(expression.PreCPrimary.Number.GetCleanValue() == argumentLookup.Index); } else if (expression.Rule == 2) { return(expression.PreCPrimary.Number.GetCleanValue() != argumentLookup.Index); } } } notValidReference: switch (expression.Rule) { case 1: //PreprocessorCEqualityExp "==" PreprocessorCPrimary return(expression.PreCEqualityExp.Evaluate(currentEntry, availableStock, argumentLookup, entry, file, errors) == expression.PreCPrimary.Evaluate(currentEntry, availableStock, argumentLookup, entry, file, errors)); case 2: //PreprocessorCEqualityExp "!=" PreprocessorCPrimary return(expression.PreCEqualityExp.Evaluate(currentEntry, availableStock, argumentLookup, entry, file, errors) != expression.PreCPrimary.Evaluate(currentEntry, availableStock, argumentLookup, entry, file, errors)); case 3: //PreprocessorCPrimary return(expression.PreCPrimary.Evaluate(currentEntry, availableStock, argumentLookup, entry, file, errors)); } return(false); }
internal static bool Evaluate(this IPreprocessorCLogicalAndConditionExp expression, IOilexerGrammarProductionRuleEntry currentEntry, IList <IOilexerGrammarTokenEntry> availableStock, ProductionRuleTemplateArgumentSeries argumentLookup, IOilexerGrammarProductionRuleTemplateEntry entry, OilexerGrammarFile file, ICompilerErrorCollection errors) { //rule 2. if (expression.Left == null) { try { return((bool)expression.Right.Evaluate(currentEntry, availableStock, argumentLookup, entry, file, errors)); } catch { errors.SourceError(OilexerGrammarCore.CompilerErrors.InvalidPreprocessorCondition, new LineColumnPair(expression.Line, expression.Column), LineColumnPair.Zero, new Uri(entry.FileName, UriKind.RelativeOrAbsolute), expression.ToString()); } } //rule 1. else { return((bool)expression.Left.Evaluate(currentEntry, availableStock, argumentLookup, entry, file, errors) && (bool)expression.Right.Evaluate(currentEntry, availableStock, argumentLookup, entry, file, errors)); } return(false); }
internal static bool Evaluate(this IPreprocessorCLogicalOrConditionExp expression, IOilexerGrammarProductionRuleEntry currentEntry, IList <IOilexerGrammarTokenEntry> availableStock, ProductionRuleTemplateArgumentSeries argumentLookup, IOilexerGrammarProductionRuleTemplateEntry entry, OilexerGrammarFile file, ICompilerErrorCollection errors) { //rule 2. if (expression.Left == null) { return(expression.Right.Evaluate(currentEntry, availableStock, argumentLookup, entry, file, errors)); } //rule 1. else { return(expression.Left.Evaluate(currentEntry, availableStock, argumentLookup, entry, file, errors) || expression.Right.Evaluate(currentEntry, availableStock, argumentLookup, entry, file, errors)); } }
public void ResolvedSinglePartToRuleTemplate(ISoftTemplateReferenceProductionRuleItem item, IOilexerGrammarProductionRuleTemplateEntry primary) { if (item.PrimaryToken != null) { this.handler.ReclassifyToken(item.PrimaryToken, primary); } }
internal static IProductionRuleItem Expand(this IPreprocessorDirective directive, IOilexerGrammarProductionRuleEntry currentEntry, IList <IOilexerGrammarTokenEntry> availableStock, ProductionRuleTemplateArgumentSeries argumentLookup, IOilexerGrammarProductionRuleTemplateEntry entry, OilexerGrammarFile file, ICompilerErrorCollection errors) { switch (directive.Type) { case EntryPreprocessorType.If: case EntryPreprocessorType.IfNotDefined: case EntryPreprocessorType.IfDefined: case EntryPreprocessorType.ElseIf: case EntryPreprocessorType.ElseIfDefined: case EntryPreprocessorType.Else: return(((IPreprocessorIfDirective)directive).Expand(currentEntry, availableStock, argumentLookup, entry, file, errors)); case EntryPreprocessorType.DefineRule: ((IPreprocessorDefineRuleDirective)(directive)).Expand(currentEntry, availableStock, argumentLookup, entry, file, errors); break; case EntryPreprocessorType.AddRule: ((IPreprocessorAddRuleDirective)(directive)).Expand(currentEntry, availableStock, argumentLookup, entry, file, errors); break; case EntryPreprocessorType.Throw: ((IPreprocessorThrowDirective)(directive)).Expand(currentEntry, availableStock, argumentLookup, entry, file, errors); break; case EntryPreprocessorType.Return: return(((IPreprocessorConditionalReturnDirective)(directive)).Expand(currentEntry, availableStock, argumentLookup, entry, file, errors)); } return(null); }
protected override void DefineRuleTemplateIdentifier(OilexerGrammarTokens.IdentifierToken ruleTemplateIdentifier, IOilexerGrammarProductionRuleTemplateEntry ruleTemplateEntry) { this.Handler.ReclassifyToken(ruleTemplateIdentifier, ruleTemplateEntry); }
internal static void Expand(this IPreprocessorThrowDirective directive, IOilexerGrammarProductionRuleEntry currentEntry, IList <IOilexerGrammarTokenEntry> availableStock, ProductionRuleTemplateArgumentSeries argumentLookup, IOilexerGrammarProductionRuleTemplateEntry entry, OilexerGrammarFile file, ICompilerErrorCollection errors) { string[] errorData = new string[directive.Arguments.Length]; int index = 0; //List<Tuple<string, int, int>> errorLocations = new List<Tuple<string, int, int>>(); List <Tuple <IProductionRule, ISoftReferenceProductionRuleItem> > errorLocations = new List <Tuple <IProductionRule, ISoftReferenceProductionRuleItem> >(); foreach (var item in directive.Arguments) { if (item.TokenType == OilexerGrammarTokenType.Identifier) { var idItem = item as OilexerGrammarTokens.IdentifierToken; if (!argumentLookup.ContainsParameter(idItem.Name)) { errorData[index++] = idItem.Name; continue; } else { var parameter = argumentLookup.GetParameter(idItem.Name); var parameterDataSeries = argumentLookup[parameter]; if (parameterDataSeries.Count == 1 && parameterDataSeries[0].Count == 1) { var pd0 = parameterDataSeries[0]; var parameterData = pd0[0]; if (parameterData is ISoftReferenceProductionRuleItem) { var specificData = (ISoftReferenceProductionRuleItem)parameterData; if (specificData.SecondaryToken == null) { errorData[index] = specificData.PrimaryName; } else { errorData[index] = string.Format("{0}.{1}", specificData.PrimaryName, specificData.SecondaryName); } errorLocations.Add(Tuple.Create(pd0, specificData)); } } } } else if (item.TokenType == OilexerGrammarTokenType.CharacterLiteral) { errorData[index] = ((OilexerGrammarTokens.CharLiteralToken)(item)).GetCleanValue().ToString(); } else if (item.TokenType == OilexerGrammarTokenType.StringLiteral) { errorData[index] = ((OilexerGrammarTokens.StringLiteralToken)(item)).GetCleanValue(); } index++; } if (errorLocations.Count > 0) { foreach (var errorLocation in errorLocations) { errors.SourceModelError(OilexerGrammarCore.CompilerErrors.LanguageDefinedError, new LineColumnPair(errorLocation.Item2.Line, errorLocation.Item2.Column), new LineColumnPair(errorLocation.Item2.Line, errorLocation.Item2.Column + (errorLocation.Item2.SecondaryToken == null ? errorLocation.Item2.PrimaryName.Length : errorLocation.Item2.PrimaryName.Length + errorLocation.Item2.SecondaryName.Length)), new Uri(errorLocation.Item1.FileName, UriKind.RelativeOrAbsolute), directive, errorLocation.Item1, errorLocation.Item2, new string[] { directive.Reference.Number.ToString(), string.Format(directive.Reference.Message, errorData) }); } } else { errors.SourceError(OilexerGrammarCore.CompilerErrors.LanguageDefinedError, new LineColumnPair(directive.Line, directive.Column), LineColumnPair.Zero, new Uri(entry.FileName, UriKind.RelativeOrAbsolute), directive.Reference.Number.ToString(), string.Format(directive.Reference.Message, errorData)); } }
public static IProductionRuleItem ResolveTemplateSoftReference<T>(this ISoftTemplateReferenceProductionRuleItem item, T entry, OilexerGrammarFile file, ICompilerErrorCollection errors) where T : IOilexerGrammarProductionRuleEntry { IOilexerGrammarProductionRuleTemplateEntry iprte = null; var closeMatches = GetList(new { Entry = (IOilexerGrammarProductionRuleTemplateEntry)null, ArgumentInformation = default(TemplateArgumentInformation) }); foreach (IOilexerGrammarProductionRuleTemplateEntry template in ruleTemplEntries) { if (template.Name == item.PrimaryName) { TemplateArgumentInformation tai = template.GetArgumentInformation(); if (item.Parts.Count >= tai.FixedArguments) { closeMatches.Add(new { Entry = template, ArgumentInformation = tai }); if (tai.DynamicArguments > 0) { if ((item.Parts.Count - tai.FixedArguments) % tai.DynamicArguments == 0) { if (tai.InvalidArguments == 0) { iprte = template; break; } } } else if (tai.InvalidArguments == 0) { if (item.Parts.Count == tai.FixedArguments) { iprte = template; break; } } } else { closeMatches.Add(new { Entry = template, ArgumentInformation = tai }); continue; } } } if (iprte != null) { foreach (IProductionRuleSeries iprs in item.Parts) iprs.ResolveProductionRuleSeries(entry, file, errors); TemplateReferenceProductionRuleItem rResult = new TemplateReferenceProductionRuleItem(iprte, new List<IProductionRuleSeries>(item.Parts.ToArray()), item.Column, item.Line, item.Position); if (resolutionAid != null) resolutionAid.ResolvedSinglePartToRuleTemplate(item, iprte); if (item.RepeatOptions != ScannableEntryItemRepeatInfo.None) rResult.RepeatOptions = item.RepeatOptions; if (item.Name != null && item.Name != string.Empty) rResult.Name = item.Name; return rResult; } else if (closeMatches.Count > 0) { var fixedMatch = (from templateArguments in closeMatches let arguments = templateArguments.ArgumentInformation where arguments.FixedArguments > 0 orderby arguments.FixedArguments descending select templateArguments.Entry); IOilexerGrammarProductionRuleTemplateEntry closestMismatch = null; foreach (var mismatch in fixedMatch) { if (item.Parts.Count > mismatch.Parts.Count) { closestMismatch = mismatch; break; } } /**/ if (closestMismatch == null) closestMismatch = fixedMatch.Last(); if (fixedMatch != null) errors.SourceModelError<ISoftTemplateReferenceProductionRuleItem, IOilexerGrammarProductionRuleTemplateEntry>(OilexerGrammarCore.CompilerErrors.FixedArgumentMismatch, new LineColumnPair(item.Line, item.Column), LineColumnPair.Zero, new Uri(entry.FileName, UriKind.RelativeOrAbsolute), item, closestMismatch, new string[] { closestMismatch.Name, closestMismatch.Parts.Count.ToString(), item.Parts.Count.ToString() }); else { var dynamicMatch = (from templateArguments in closeMatches let arguments = templateArguments.ArgumentInformation where arguments.DynamicArguments > 0 select templateArguments.Entry).FirstOrDefault(); if (dynamicMatch != null) errors.SourceModelError<IOilexerGrammarProductionRuleTemplateEntry>(OilexerGrammarCore.CompilerErrors.DynamicArgumentCountError, new LineColumnPair(item.Line, item.Column), LineColumnPair.Zero, new Uri(entry.FileName, UriKind.RelativeOrAbsolute), dynamicMatch); else { var invalidMatch = (from templateArguments in closeMatches let arguments = templateArguments.ArgumentInformation where arguments.InvalidArguments > 0 select templateArguments.Entry).FirstOrDefault(); if (invalidMatch != null) errors.SourceModelError<IOilexerGrammarProductionRuleTemplateEntry>(OilexerGrammarCore.CompilerErrors.InvalidRepeatOptions, new LineColumnPair(item.Line, item.Column), LineColumnPair.Zero, new Uri(entry.FileName, UriKind.RelativeOrAbsolute), invalidMatch); else if (ruleEntries.OilexerGrammarFindScannableEntry(item.PrimaryName) != null) errors.SourceModelError<ISoftTemplateReferenceProductionRuleItem>(OilexerGrammarCore.CompilerErrors.RuleNotTemplate, new LineColumnPair(item.Line, item.Column), LineColumnPair.Zero, new Uri(entry.FileName, UriKind.RelativeOrAbsolute), item, item.PrimaryName); } } //errors.Add(OilexerGrammarCore.GetParserError(entry.FileName, item.Line, item.Column, OilexerGrammarParserErrors.DynamicArgumentCountError)); } else if (ruleEntries.OilexerGrammarFindScannableEntry(item.PrimaryName) != null) errors.SourceModelError<ISoftTemplateReferenceProductionRuleItem>(OilexerGrammarCore.CompilerErrors.RuleNotTemplate, new LineColumnPair(item.Line, item.Column), LineColumnPair.Zero, new Uri(entry.FileName, UriKind.RelativeOrAbsolute), item, item.PrimaryName); else { var matches = (from template in ruleTemplEntries where template.Name == item.PrimaryName select template).Count(); if (matches > 0) errors.SourceError(OilexerGrammarCore.CompilerErrors.FixedArgumentMismatch, new LineColumnPair(item.Line, item.Column), LineColumnPair.Zero, new Uri(entry.FileName, UriKind.RelativeOrAbsolute), item.PrimaryName); else errors.SourceError(OilexerGrammarCore.CompilerErrors.UndefinedRuleReference, new LineColumnPair(item.Line, item.Column), LineColumnPair.Zero, new Uri(entry.FileName, UriKind.RelativeOrAbsolute), item.PrimaryName); } return item; } public static IProductionRuleItem ResolveSoftReference<T>(this ISoftReferenceProductionRuleItem item, T entry, OilexerGrammarFile file, ICompilerErrorCollection errors) where T : IOilexerGrammarProductionRuleEntry { if (entry is IOilexerGrammarProductionRuleTemplateEntry) { var templateEntry = entry as IOilexerGrammarProductionRuleTemplateEntry; if (string.IsNullOrEmpty(item.SecondaryName)) foreach (IProductionRuleTemplatePart iprtp in templateEntry.Parts) if (iprtp.Name == item.PrimaryName) { TemplateParamReferenceProductionRuleItem result = new TemplateParamReferenceProductionRuleItem(templateEntry, iprtp, item.Column, item.Line, item.Position); if (resolutionAid != null) resolutionAid.ResolvedSinglePartToTemplateParameter(templateEntry, iprtp, item); if (item.RepeatOptions != ScannableEntryItemRepeatInfo.None) result.RepeatOptions = item.RepeatOptions; if (item.Name != null && result.Name == null) result.Name = item.Name; return result; } } IOilexerGrammarProductionRuleEntry ipre = ruleEntries.OilexerGrammarFindScannableEntry(item.PrimaryName); if (ipre != null) { RuleReferenceProductionRuleItem rrpri = new RuleReferenceProductionRuleItem(ipre, item.Column, item.Line, item.Position); if (resolutionAid != null) resolutionAid.ResolvedSinglePartToRule(item, ipre); ((ProductionRuleItem)(item)).CloneData(rrpri); return rrpri; } else if (ruleTemplEntries.OilexerGrammarFindScannableEntry(item.PrimaryName) != null) errors.SourceModelError<ISoftReferenceProductionRuleItem>(OilexerGrammarCore.CompilerErrors.RuleIsTemplate, new LineColumnPair(item.Line, item.Column), LineColumnPair.Zero, new Uri(entry.FileName, UriKind.RelativeOrAbsolute), item, item.PrimaryName); else { IOilexerGrammarTokenEntry tokenE = tokenEntries.OilexerGrammarFindScannableEntry(item.PrimaryName); if (tokenE != null) if (item.SecondaryName != null) { ITokenItem iti = tokenE.FindTokenItem(item.SecondaryName); if (iti != null) { IProductionRuleItem result = null; if (iti is ILiteralCharTokenItem) { if (resolutionAid != null) resolutionAid.ResolvedDualPartToTokenItem(item, tokenE, iti); result = new LiteralCharReferenceProductionRuleItem(((ILiteralCharTokenItem)(iti)), tokenE, item.Column, item.Line, item.Position, item.IsFlag, item.Counter); } else if (iti is ILiteralStringTokenItem) { if (resolutionAid != null) resolutionAid.ResolvedDualPartToTokenItem(item, tokenE, iti); result = new LiteralStringReferenceProductionRuleItem(((ILiteralStringTokenItem)(iti)), tokenE, item.Column, item.Line, item.Position, item.IsFlag, item.Counter); } else { /* * * ToDo: Throw an error here for referencing the wrong type of token * */ } if (result != null) { result.Name = item.Name; result.RepeatOptions = item.RepeatOptions; 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); }