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)); }
private static void ResolveProductionRuleSeries<T>(this IProductionRuleSeries series, T entry, OilexerGrammarFile file, ICompilerErrorCollection errors) where T : IOilexerGrammarProductionRuleEntry { foreach (IProductionRule ite in series) ite.ResolveProductionRule(entry, file, errors); }
private static void ReplaceTokenReference(IProductionRuleSeries target, IOilexerGrammarTokenEntry sourceElement, InlinedTokenEntry destination) { foreach (var expression in target) { ReplaceTokenReference(expression, sourceElement, destination); } }
public static void GetTokenReferences(this IProductionRuleSeries series, IList <IOilexerGrammarTokenEntry> list) { foreach (IProductionRule rule in series) { rule.GetTokenReferences(list); } }
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 IProductionRuleSeries ExpandTemplates(this IProductionRuleSeries series, IList <IOilexerGrammarTokenEntry> availableStock, IOilexerGrammarProductionRuleEntry entry, OilexerGrammarFile file, ICompilerErrorCollection errors) { List <IProductionRule> result = new List <IProductionRule>(); foreach (IProductionRule rule in series.ToArray()) { if (!series.NeedsExpansion(entry)) { result.Add(rule); } else { result.Add(rule.ExpandTemplates(availableStock, entry, file, errors)); } } if (EachSubitemIsNamelessGroup(result)) { List <IProductionRule> minimizedResult = new List <IProductionRule>(); foreach (var rule in result) { foreach (IProductionRuleGroupItem item in rule) { foreach (var subRule in item) { minimizedResult.Add(subRule); } } } result = minimizedResult; } return(new ProductionRuleSeries(result)); }
public static IProductionRuleSeries Deliteralize(this IProductionRuleSeries series, IOilexerGrammarProductionRuleEntry currentEntry, IList <IOilexerGrammarTokenEntry> availableStock, OilexerGrammarFile file, ICompilerErrorCollection errors) { if (series.NeedsDeliteralized()) { List <IProductionRule> result = new List <IProductionRule>(); foreach (IProductionRule ipr in series) { IProductionRule resultIPR = null; if (ipr.NeedsDeliteralized()) { resultIPR = ipr.Deliteralize(currentEntry, availableStock, file, errors); } else { resultIPR = ipr; } if (resultIPR != null) { result.Add(resultIPR); } } if (result.Count == 0) { return(null); } return(new ProductionRuleSeries(result)); } return(series); }
internal static bool HasExpansion(this IProductionRuleSeries series) { foreach (IProductionRule rule in series) { if (rule.HasExpansion()) { return(true); } } return(false); }
public static void ReplaceReferences(IOilexerGrammarFile source, IOilexerGrammarProductionRuleEntry target, IDictionary <IProductionRuleItem, IProductionRuleItem> elementToElementList) { OilexerGrammarProductionRuleEntry r = (OilexerGrammarProductionRuleEntry)(target); IProductionRuleSeries resultSeries = ReplaceReferences(source, ((IProductionRuleSeries)(r)).ToArray(), elementToElementList); r.Clear(); foreach (var rule in resultSeries) { r.Add(rule); } }
private static bool AllAreUnnamedEquivalents(IProductionRuleSeries ruleSeries, ref IProductionRuleItem rootItem) { foreach (var exp in ruleSeries) { if (!AllAreUnnamedEquivalents(exp, ref rootItem)) { return(false); } } return(true); }
public static bool NeedsFinalLinking(this IProductionRuleSeries series) { foreach (IProductionRule rule in series) { if (rule.NeedsFinalLinking()) { return(true); } } return(false); }
public static bool NeedsDeliteralized(this IProductionRuleSeries series) { foreach (IProductionRule rule in series) { if (rule.NeedsDeliteralized()) { return(true); } } return(false); }
public static bool ContainsReferences(IOilexerGrammarFile source, IProductionRuleSeries target, IDictionary <IProductionRuleItem, IProductionRuleItem> elementToElementList) { foreach (var item in target) { if (ContainsReferences(source, item, elementToElementList)) { return(true); } } return(false); }
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 void ExpandTemplates(this IOilexerGrammarProductionRuleEntry entry, IList <IOilexerGrammarTokenEntry> availableStock, OilexerGrammarFile file, ICompilerErrorCollection errors) { while (entry.NeedsExpansion()) { OilexerGrammarProductionRuleEntry e = ((OilexerGrammarProductionRuleEntry)(entry)); IProductionRuleSeries iprs = entry.ExpandTemplates(availableStock, entry, file, errors); e.Clear(); foreach (IProductionRule ipr in iprs) { e.Add(ipr); } } }
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 SyntacticalNFAState BuildNFA(this IProductionRuleSeries series, SyntacticalNFAState root, IGrammarSymbolSet symbols, ControlledDictionary <IOilexerGrammarProductionRuleEntry, SyntacticalDFARootState> lookup, Dictionary <IProductionRuleSource, IProductionRuleCaptureStructuralItem> replacements) { SyntacticalNFAState state = root; bool first = true; foreach (var expression in series) { if (state == null) { state = expression.BuildNFA(symbols, lookup, replacements); first = false; } else { var expressionNFA = expression.BuildNFA(symbols, lookup, replacements); if (first) { bool isEdge = expressionNFA.IsEdge; first = false; state.Union(expressionNFA); if (state.IsEdge && !isEdge) { state.IsEdge = isEdge; } } else { state.Union(expressionNFA); } } } if (!(series is IProductionRuleGroupItem)) { List <SyntacticalNFAState> flatForm = new List <SyntacticalNFAState>(); SyntacticalNFAState.FlatlineState(state, flatForm); var source = (replacements.ContainsKey(series) ? (IProductionRuleSource)replacements[series] : (IProductionRuleSource)series); state.SetInitial(source); foreach (var fState in flatForm) { fState.SetIntermediate(source); } foreach (var edge in state.ObtainEdges()) { edge.SetFinal(source); } } return(state); }
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)); } } }
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 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); } } }
private static List <IProductionRuleCaptureStructuralItem> PollGroup(IProductionRuleSeries series, IProductionRuleCaptureStructure structure) { List <IProductionRuleCaptureStructuralItem> result = new List <IProductionRuleCaptureStructuralItem>(); foreach (var expression in series) { foreach (var item in expression) { var firstOrDef = structure.Values.FirstOrDefault(k => k.Sources.Contains(item)); if (firstOrDef != null) { result.Add(firstOrDef); } else if (item is IProductionRuleGroupItem) { result.AddRange(PollGroup((IProductionRuleGroupItem)item, structure)); } } } return(result); }
private static void CleanupRule(IProductionRuleSeries series) { List <IProductionRule> terminalList = new List <IProductionRule>(); foreach (var expression in series) { //Only dispose rules that were null post-cleanup. if (expression.Count == 0) { continue; } CleanupRule(expression); if (expression.Count == 0) { terminalList.Add(expression); } } foreach (var expression in terminalList) { ((ControlledCollection <IProductionRule>)series).baseList.Remove(expression); } }
internal static bool NeedsExpansion(this IProductionRuleSeries series, IOilexerGrammarProductionRuleEntry entry) { if (series.Count == 0) { return(true); } if (series is IProductionRuleGroupItem) { var gSeries = (IProductionRuleGroupItem)series; if (gSeries.Count == 1 && gSeries[0].Count == 1 && gSeries.Name.IsEmptyOrNull() && gSeries.RepeatOptions == ScannableEntryItemRepeatInfo.None) { return(true); } } foreach (IProductionRule rule in series) { if (rule.NeedsExpansion(entry)) { return(true); } } return(false); }
public static IProductionRuleSeries FinalLink(this IProductionRuleSeries series, IOilexerGrammarProductionRuleEntry currentEntry, OilexerGrammarFile file, ICompilerErrorCollection errors) { if (series.NeedsFinalLinking()) { List <IProductionRule> result = new List <IProductionRule>(); foreach (IProductionRule current in series) { IProductionRule resultIPR = null; if (current.NeedsFinalLinking()) { resultIPR = current.FinalLink(currentEntry, file, errors); } else { resultIPR = current; } /* * * It can be null because methods like this for * production rule series return null when the * set was empty. * * * A good example is groups. * */ if (resultIPR != null) { result.Add(resultIPR); } } if (result.Count == 0) { return(null); } return(new ProductionRuleSeries(result)); } return(series); }
internal ArgumentData(IProductionRuleTemplatePart relative, IProductionRuleSeries replacement) { this.Relative = relative; this.Replacement = replacement; }
private static IProductionRuleCaptureStructuralItem BuildStructureFor(OilexerGrammarProductionRuleEntry entry, IProductionRuleSeries expressionSeries, IProductionRule expression, IProductionRuleItem item, IOilexerGrammarFile source) { IProductionRuleCaptureStructuralItem result = null; if (item is IProductionRuleGroupItem) { var ruleGroup = ((IProductionRuleGroupItem)(item)); if (!ruleGroup.Name.IsEmptyOrNull() && AllAreUnnamedEquivalents(ruleGroup)) { SetAllNames(ruleGroup, ruleGroup.Name); } result = BuildStructureFor(entry, ruleGroup, source); if (result.ResultType == ResultedDataType.None && !item.Name.IsEmptyOrNull()) { if (ruleGroup.Count == 1 && ruleGroup[0].Count == 1) { var singleItem = ruleGroup[0][0]; if (singleItem is ILiteralCharReferenceProductionRuleItem) { if (singleItem.RepeatOptions == ScannableEntryItemRepeatInfo.None && ruleGroup.RepeatOptions == ScannableEntryItemRepeatInfo.None) { result.ResultType = ResultedDataType.Character; } else { result.ResultType = ResultedDataType.String; } } else { result.ResultType = ResultedDataType.String; } } else { result.ResultType = ResultedDataType.String; } } else if (item.Name.IsEmptyOrNull()) { result.ResultType = ResultedDataType.PassThrough; } ((ControlledCollection <IProductionRuleSource>)(result.Sources)).baseList.Add(item); } else if (item is ILiteralReferenceProductionRuleItem) { var literalRefItem = (ILiteralReferenceProductionRuleItem)item; var inlinedRef = ((InlinedTokenEntry)(literalRefItem.Source)); result = new ProductionRuleLiteralTokenItemReferenceStructuralItem(literalRefItem.Source, literalRefItem, entry); if (inlinedRef.CaptureKind == RegularCaptureType.Transducer) { result.ResultType = ResultedDataType.EnumerationItem; } else if (inlinedRef.CaptureKind == RegularCaptureType.ContextfulTransducer) { result.ResultType = ResultedDataType.FlagEnumerationItem; } } else if (item is ITokenReferenceProductionRuleItem) { var tokenRefItem = ((ITokenReferenceProductionRuleItem)(item)); var inlinedRef = ((InlinedTokenEntry)(tokenRefItem.Reference)); result = new ProductionRuleTokenReferenceStructuralItem((ITokenReferenceProductionRuleItem)item, entry); if (inlinedRef.CaptureKind == RegularCaptureType.Transducer) { result.ResultType = ResultedDataType.Enumeration; } else { result.ResultType = ResultedDataType.ImportType; } } else if (item is IRuleReferenceProductionRuleItem) { var ruleItem = (IRuleReferenceProductionRuleItem)item; result = new ProductionRuleCaptureReferenceStructuralItem(ruleItem, entry); } Deform(item, result, expression); return(result); }
private static IProductionRuleCaptureStructure BuildStructureFor(OilexerGrammarProductionRuleEntry entry, IProductionRuleSeries expressionSeries, IProductionRule expression, IOilexerGrammarFile source) { IProductionRuleCaptureStructure result = new ProductionRuleCaptureStructure(entry); foreach (var item in expression) { var current = BuildStructureFor(entry, expressionSeries, expression, item, source); result = result.Concat(current); } return(result); }
private static Dictionary <IProductionRuleGroupItem, List <IProductionRuleCaptureStructuralItem> > PickOptionalGroups(IProductionRuleSeries series, IProductionRuleCaptureStructure structure) { Dictionary <IProductionRuleGroupItem, List <IProductionRuleCaptureStructuralItem> > result = new Dictionary <IProductionRuleGroupItem, List <IProductionRuleCaptureStructuralItem> >(); foreach (var expression in series) { foreach (var item in expression) { if (item is IProductionRuleGroupItem) { var groupItem = (IProductionRuleGroupItem)item; if ((item.RepeatOptions.Options & ScannableEntryItemRepeatOptions.ZeroOrMore) == ScannableEntryItemRepeatOptions.ZeroOrMore || (item.RepeatOptions.Options & ScannableEntryItemRepeatOptions.ZeroOrOne) == ScannableEntryItemRepeatOptions.ZeroOrOne || (item.RepeatOptions.Options & ScannableEntryItemRepeatOptions.Specific) == ScannableEntryItemRepeatOptions.Specific && (!item.RepeatOptions.Min.HasValue || item.RepeatOptions.Min.Value == 0)) { /* * * Found an optional token group, now to search * within to see what we have inside. * */ var firstOrDef = structure.Values.FirstOrDefault(k => k.Sources.Contains(item)); if (firstOrDef != null) { result.Add(groupItem, new List <IProductionRuleCaptureStructuralItem>() { firstOrDef }); } else { var currentSet = PollGroup(groupItem, structure); if (currentSet.Count > 0) { result.Add(groupItem, currentSet); } } } else { var subResult = PickOptionalGroups(groupItem, structure); foreach (var element in subResult.Keys) { if (result.ContainsKey(element)) { result[element].AddRange(subResult[element]); } } } } } } return(result); }
private static IProductionRuleCaptureStructure BuildStructureFor(OilexerGrammarProductionRuleEntry entry, IProductionRuleSeries expressionSeries, IOilexerGrammarFile source) { IProductionRuleCaptureStructure result = null; HashList <HashList <string> > currentResultVariants = new HashList <HashList <string> >(); foreach (var expression in expressionSeries) { var current = BuildStructureFor(entry, expressionSeries, expression, source); if (result == null) { result = current; } else { result = result.Union(current); } var dataSet = new HashList <string>(current.Keys); if (!currentResultVariants.Any(k => k.SequenceEqual(dataSet))) { currentResultVariants.Add(dataSet); } } foreach (var variant in currentResultVariants) { result.Structures.Add(variant); } if (expressionSeries == entry) { ((ControlledCollection <IProductionRuleSource>)result.Sources).baseList.Add(entry); } result.ResultedTypeName = string.Format("{0}{1}{2}", source.Options.RulePrefix, entry.Name, source.Options.RuleSuffix); return(result); }
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); }