private ProductionRuleTemplatePart(string name, TemplatePartExpectedSpecial specialExpectancy, IProductionRuleItem reference, int line, int column, long position) : base(column, line, position) { this.Name = name; this.specialExpectancy = specialExpectancy; this.expectedSpecific = reference; }
public static IProductionRule Deliteralize(this IProductionRule rule, IOilexerGrammarProductionRuleEntry currentEntry, IList <IOilexerGrammarTokenEntry> availableStock, OilexerGrammarFile file, ICompilerErrorCollection errors) { if (rule.NeedsDeliteralized()) { List <IProductionRuleItem> result = new List <IProductionRuleItem>(); foreach (IProductionRuleItem ruleItem in rule) { IProductionRuleItem resultItem = null; if (ruleItem.NeedsDeliteralized()) { resultItem = ruleItem.Deliteralize(currentEntry, availableStock, file, errors); } else { resultItem = ruleItem; } if (resultItem != null) { result.Add(resultItem); } } if (result.Count == 0) { return(null); } return(new ProductionRule(result, rule.FileName, rule.Column, rule.Line, rule.Position)); } else { return(rule); } }
private static void Deform(IProductionRuleItem item, IProductionRuleCaptureStructuralItem structuralItem, IProductionRule owner) { /* * * Items reduced to their max are for recognizer sections.. * */ if (!(item is IProductionRuleGroupItem)) { if ((item.RepeatOptions.Options & ScannableEntryItemRepeatOptions.MaxReduce) == ScannableEntryItemRepeatOptions.MaxReduce && string.IsNullOrEmpty(item.Name)) { return; } switch (item.RepeatOptions.Options & (ScannableEntryItemRepeatOptions.OneOrMore | ScannableEntryItemRepeatOptions.ZeroOrMore | ScannableEntryItemRepeatOptions.ZeroOrOne)) { case ScannableEntryItemRepeatOptions.ZeroOrOne: structuralItem.Optional = true; break; case ScannableEntryItemRepeatOptions.ZeroOrMore: case ScannableEntryItemRepeatOptions.OneOrMore: switch (structuralItem.ResultType) { case ResultedDataType.ImportType: structuralItem.ResultType = ResultedDataType.ImportTypeList; break; } structuralItem.Optional = true; break; } } else { IProductionRuleCaptureStructure structure = (IProductionRuleCaptureStructure)structuralItem; var groupItem = (IProductionRuleGroupItem)item; switch (item.RepeatOptions.Options & (ScannableEntryItemRepeatOptions.OneOrMore | ScannableEntryItemRepeatOptions.ZeroOrMore | ScannableEntryItemRepeatOptions.ZeroOrOne)) { case ScannableEntryItemRepeatOptions.ZeroOrOne: structuralItem.Optional = true; break; case ScannableEntryItemRepeatOptions.ZeroOrMore: case ScannableEntryItemRepeatOptions.OneOrMore: foreach (var subItem in structure.Values) { switch (subItem.ResultType) { case ResultedDataType.ImportType: subItem.ResultType = ResultedDataType.ImportTypeList; break; } } structuralItem.Optional = true; break; } } }
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 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); } }
private static bool AllAreUnnamedEquivalents(IProductionRule rule, ref IProductionRuleItem rootItem) { foreach (var item in rule) { if (!AllAreUnnamedEquivalents(item, ref rootItem)) { return(false); } } return(true); }
public ProductionRuleTemplatePart(string name, bool inSeries, string expectedTargetName, int line, int column, long position) : base(column, line, position) { this.Name = name; this.repeatSeries = inSeries; if (expectedTargetName != null) { this.expectedSpecific = new SoftReferenceProductionRuleItem(expectedTargetName, null, line, column, position, false, false); } this.RepeatOptions = repeatSeries ? ScannableEntryItemRepeatInfo.OneOrMore : ScannableEntryItemRepeatInfo.None; }
public static bool ContainsReferences(IOilexerGrammarFile source, IProductionRuleItem target, IDictionary <IProductionRuleItem, IProductionRuleItem> elementToElementList) { if (elementToElementList.ContainsKey(target)) { return(true); } if (target is IProductionRuleGroupItem) { return(ContainsReferences(source, ((IProductionRuleSeries)(target)), elementToElementList)); } 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); }
public static SyntacticalNFAState BuildNFA(this IProductionRuleItem item, IGrammarSymbolSet symbols, ControlledDictionary <IOilexerGrammarProductionRuleEntry, SyntacticalDFARootState> lookup, Dictionary <IProductionRuleSource, IProductionRuleCaptureStructuralItem> replacements) { SyntacticalNFAState result = null; if (item is IProductionRuleGroupItem) { result = ((IProductionRuleSeries)item).BuildNFA(symbols, lookup, replacements); } else if (item is ILiteralCharReferenceProductionRuleItem) { result = ((ILiteralCharReferenceProductionRuleItem)(item)).BuildNFA(symbols, lookup, replacements); } else if (item is ILiteralStringReferenceProductionRuleItem) { result = ((ILiteralStringReferenceProductionRuleItem)(item)).BuildNFA(symbols, lookup, replacements); } else if (item is ITokenReferenceProductionRuleItem) { result = ((ITokenReferenceProductionRuleItem)(item)).BuildNFA(symbols, lookup, replacements); } else if (item is IRuleReferenceProductionRuleItem) { result = ((IRuleReferenceProductionRuleItem)(item)).BuildNFA(symbols, lookup, replacements); } else { throw new ArgumentException("series"); } if (result == null) { return(null); } var source = replacements.ContainsKey(item) ? (IProductionRuleSource)replacements[item] : (IProductionRuleSource)item; result.HandleRepeatCycle <GrammarVocabulary, SyntacticalNFAState, SyntacticalDFAState, IProductionRuleSource, SyntacticalNFARootState, IProductionRuleItem>(item, item, OilexerGrammarInliningCore.ProductionRuleRootStateClonerCache, () => new SyntacticalNFAState(lookup, (GrammarSymbolSet)symbols)); List <SyntacticalNFAState> flatForm = new List <SyntacticalNFAState>(); SyntacticalNFAState.FlatlineState(result, flatForm); result.SetInitial(source); foreach (var fState in flatForm) { fState.SetIntermediate(source); } foreach (var edge in result.ObtainEdges()) { edge.SetFinal(source); } return(result); }
public static bool NeedsFinalLinking(this IProductionRuleItem ruleItem) { if (ruleItem is IProductionRuleGroupItem) { if (((IProductionRuleSeries)(ruleItem)).NeedsFinalLinking()) { return(true); } } else if (ruleItem is ISoftReferenceProductionRuleItem) { return(true); } return(false); }
public static bool NeedsDeliteralized(this IProductionRuleItem ruleItem) { if (ruleItem is IProductionRuleGroupItem) { if (((IProductionRuleSeries)(ruleItem)).NeedsDeliteralized()) { return(true); } } else if (ruleItem is ILiteralProductionRuleItem) { return(true); } return(false); }
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 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); } } }
internal static bool HasExpansion(this IProductionRuleItem rule) { if (rule is IProductionRulePreprocessorDirective) { return(true); } else if (rule is ITemplateParamReferenceProductionRuleItem) { return(true); } else if (rule is ITemplateReferenceProductionRuleItem) { return(true); } else if (rule is IProductionRuleGroupItem) { return(((IProductionRuleSeries)(rule)).HasExpansion()); } return(false); }
private static IProductionRuleItem ResolveProductionRuleItem<T>(this IProductionRuleItem item, T entry, OilexerGrammarFile file, ICompilerErrorCollection errors) where T : IOilexerGrammarProductionRuleEntry { if (item is IProductionRuleGroupItem) { ((IProductionRuleGroupItem)(item)).ResolveProductionRuleSeries(entry, file, errors); return item; } else if (item is ILiteralProductionRuleItem) return item; else if (item is IProductionRulePreprocessorDirective) return ((IProductionRulePreprocessorDirective)item).ResolveProductionRuleItem(entry, file, errors); else if (item is ISoftTemplateReferenceProductionRuleItem) return ((ISoftTemplateReferenceProductionRuleItem)(item)).ResolveTemplateSoftReference(entry, file, errors); else if (item is ISoftReferenceProductionRuleItem) return ((ISoftReferenceProductionRuleItem)(item)).ResolveSoftReference(entry, file, errors); else return item; }
private static void ReplaceTokenReference(IProductionRuleItem target, IOilexerGrammarTokenEntry sourceElement, InlinedTokenEntry destination) { if (target is IProductionRuleGroupItem) { ReplaceTokenReference((IProductionRuleSeries)target, sourceElement, destination); } else if (target is ITokenReferenceProductionRuleItem) { var tTarget = target as TokenReferenceProductionRuleItem; if (tTarget.Reference != sourceElement) { return; } tTarget.Reference = destination; } else if (target is ILiteralStringReferenceProductionRuleItem) { var tTarget = target as LiteralStringReferenceProductionRuleItem; if (tTarget.Source != sourceElement) { return; } tTarget.Source = destination; /* * * The inlined token provides a lookup to assist * reference replacement. * */ tTarget.Literal = (ILiteralStringTokenItem)destination.OldNewLookup[tTarget.Literal]; } else if (target is ILiteralCharReferenceProductionRuleItem) { var tTarget = target as LiteralCharReferenceProductionRuleItem; if (tTarget.Source != sourceElement) { return; } tTarget.Source = destination; tTarget.Literal = (ILiteralCharTokenItem)destination.OldNewLookup[tTarget.Literal]; } }
public static IProductionRule FinalLink(this IProductionRule rule, IOilexerGrammarProductionRuleEntry currentEntry, OilexerGrammarFile file, ICompilerErrorCollection errors) { if (rule.NeedsFinalLinking()) { List <IProductionRuleItem> result = new List <IProductionRuleItem>(); foreach (IProductionRuleItem currentItem in rule) { IProductionRuleItem resultItem = null; if (currentItem.NeedsFinalLinking()) { resultItem = currentItem.FinalLink(currentEntry, file, errors); } else { resultItem = currentItem; } if (resultItem != null) { result.Add(resultItem); } } /* * * If the only element remaining after template expansion * was an empty group, the current expression is * unnecessary. * */ if (result.Count == 0) { return(null); } return(new ProductionRule(result, rule.FileName, rule.Column, rule.Line, rule.Position)); } else { return(rule); } }
public static IProductionRuleItem Deliteralize(this IProductionRuleItem ruleItem, IOilexerGrammarProductionRuleEntry currentEntry, IList <IOilexerGrammarTokenEntry> availableStock, OilexerGrammarFile file, ICompilerErrorCollection errors) { if (ruleItem.NeedsDeliteralized()) { if (ruleItem is IProductionRuleGroupItem) { return(((IProductionRuleGroupItem)(ruleItem)).Deliteralize(currentEntry, availableStock, file, errors)); } else if (ruleItem is ILiteralProductionRuleItem) { return(((ILiteralProductionRuleItem)(ruleItem)).Deliteralize(currentEntry, availableStock, file, errors)); } else { errors.SourceError(OilexerGrammarCore.CompilerErrors.UnexpectedLiteralEntry, new LineColumnPair(ruleItem.Line, ruleItem.Column), LineColumnPair.Zero, new Uri(currentEntry.FileName, UriKind.RelativeOrAbsolute), ruleItem.GetType().Name); return(null); } } else { return(ruleItem); } }
private static bool AllAreUnnamedEquivalents(IProductionRuleItem item, ref IProductionRuleItem rootItem) { if (item is IProductionRuleGroupItem) { return(AllAreUnnamedEquivalents((IProductionRuleSeries)item, ref rootItem)); } else { if (rootItem == null) { rootItem = item; return(rootItem.Name.IsEmptyOrNull()); } else if (item is ILiteralCharReferenceProductionRuleItem || item is ILiteralStringReferenceProductionRuleItem) { return(item.Name.IsEmptyOrNull() && rootItem is ILiteralCharReferenceProductionRuleItem || rootItem is ILiteralStringReferenceProductionRuleItem); } return(item.GetType() == rootItem.GetType() && item.Name.IsEmptyOrNull()); } }
public static IProductionRuleItem FinalLink(this IProductionRuleItem ruleItem, IOilexerGrammarProductionRuleEntry currentEntry, OilexerGrammarFile file, ICompilerErrorCollection errors) { if (ruleItem.NeedsFinalLinking()) { if (ruleItem is IProductionRuleGroupItem) { return(((IProductionRuleGroupItem)(ruleItem)).FinalLink(currentEntry, file, errors)); } else if (ruleItem is ISoftReferenceProductionRuleItem) { return(((ISoftReferenceProductionRuleItem)(ruleItem)).FinalLink(currentEntry, file, errors)); } else { errors.SourceError(OilexerGrammarCore.CompilerErrors.UnexpectedUndefinedEntry, new LineColumnPair(ruleItem.Line, ruleItem.Column), LineColumnPair.Zero, new Uri(currentEntry.FileName, UriKind.RelativeOrAbsolute), ruleItem.GetType().Name); return(null); } } else { return(ruleItem); } }
public static void GetTokenReferences(this IProductionRuleItem ruleItem, IList <IOilexerGrammarTokenEntry> list) { if (ruleItem is IProductionRuleGroupItem) { ((IProductionRuleSeries)(ruleItem)).GetTokenReferences(list); } else { if (ruleItem is ITokenReferenceProductionRuleItem) { if (!list.Contains(((ITokenReferenceProductionRuleItem)(ruleItem)).Reference)) { list.Add(((ITokenReferenceProductionRuleItem)(ruleItem)).Reference); } } else if (ruleItem is ILiteralReferenceProductionRuleItem) { if (!(list.Contains(((ILiteralReferenceProductionRuleItem)(ruleItem)).Source))) { list.Add(((ILiteralReferenceProductionRuleItem)(ruleItem)).Source); } } } }
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 bool AllAreUnnamedEquivalents(IProductionRuleSeries ruleSeries, ref IProductionRuleItem rootItem) { foreach (var exp in ruleSeries) { if (!AllAreUnnamedEquivalents(exp, ref rootItem)) { return(false); } } return(true); }
private static bool AllAreUnnamedEquivalents(IProductionRuleGroupItem ruleGroup) { IProductionRuleItem rootItem = null; return(AllAreUnnamedEquivalents((IProductionRuleSeries)ruleGroup, ref rootItem)); }
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 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); }