//private static IOilexerGrammarProductionRuleEntry currentEntry = null; public static void FinalLink(this OilexerGrammarFile file, ICompilerErrorCollection errors) { //currentEntry = null; IList <IOilexerGrammarProductionRuleEntry> original = ruleEntries.ToList(); //When '__EXTRACTED' is added, ruleEntries invalidates. var availableStock = file.GetTokens().Cast <IOilexerGrammarTokenEntry>().ToList(); foreach (IOilexerGrammarProductionRuleEntry rule in original) { GC.Collect(); GC.WaitForPendingFinalizers(); rule.Deliteralize(availableStock, file, errors); } file.ExpungeUnusedTokens(); foreach (IOilexerGrammarProductionRuleEntry rule in ruleEntries) { rule.FinalLink(file, errors); } var namedEntries = from s in file where s is IOilexerGrammarNamedEntry select(IOilexerGrammarNamedEntry) s; var namedDuplicates = (from s in namedEntries let duplicates = (from s2 in namedEntries where s != s2 where s.Name == s2.Name select s2).ToArray() where duplicates.Length > 0 select new { Entry = s, Duplicates = duplicates }); var passedDuplicates = new List <IOilexerGrammarNamedEntry>(); foreach (var duplLookup in namedDuplicates) { if (passedDuplicates.Contains(duplLookup.Entry)) { continue; } passedDuplicates.Add(duplLookup.Entry); var mainError = errors.SourceModelError(OilexerGrammarCore.CompilerErrors.DuplicateEntryError, new LineColumnPair(duplLookup.Entry.Line, duplLookup.Entry.Column), new LineColumnPair(duplLookup.Entry.Line, duplLookup.Entry.Column + duplLookup.Entry.Name.Length), new Uri(duplLookup.Entry.FileName, UriKind.RelativeOrAbsolute), duplLookup.Entry, new string[] { duplLookup.Entry.Name }); foreach (var duplicate in duplLookup.Duplicates) { passedDuplicates.Add(duplicate); errors.SourceModelError(OilexerGrammarCore.CompilerErrors.DuplicateEntryReference, new LineColumnPair(duplicate.Line, duplicate.Column), new LineColumnPair(duplicate.Line, duplicate.Column + duplicate.Name.Length), new Uri(duplicate.FileName, UriKind.RelativeOrAbsolute), duplicate, mainError, new string[] { duplicate.Name }); } } file.ExpungeComments(); foreach (var rule in ruleEntries) { if (rule.IsRuleCollapsePoint) { rule.ValidateCollapsePoint(errors); } } }
private static ITokenItem ResolveSoftReference(this ISoftReferenceTokenItem item, IOilexerGrammarTokenEntry entry, OilexerGrammarFile file, ICompilerErrorCollection errors) { IOilexerGrammarTokenEntry tokenE = tokenEntries.OilexerGrammarFindScannableEntry(item.PrimaryName); if (tokenE != null) { if (item.SecondaryName != null) { ITokenItem iti = tokenE.FindTokenItem(item.SecondaryName); if (iti != null) { if (iti is ILiteralCharTokenItem) { LiteralCharReferenceTokenItem result = new LiteralCharReferenceTokenItem(tokenE, ((ILiteralCharTokenItem)(iti)), item.Column, item.Line, item.Position); if (!(string.IsNullOrEmpty(item.Name))) result.Name = item.Name; if (resolutionAid != null) resolutionAid.ResolvedDualPartToTokenItem(item, tokenE, iti); return result; } else if (iti is ILiteralStringTokenItem) { LiteralStringReferenceTokenItem result = new LiteralStringReferenceTokenItem(tokenE, ((ILiteralStringTokenItem)(iti)), item.Column, item.Line, item.Position); if (!(string.IsNullOrEmpty(item.Name))) result.Name = item.Name; if (resolutionAid != null) resolutionAid.ResolvedDualPartToTokenItem(item, tokenE, iti); return result; } else { errors.SourceModelError<ISoftReferenceTokenItem>(OilexerGrammarCore.CompilerErrors.UndefinedTokenReference, new LineColumnPair(item.Line, item.Column), new LineColumnPair(item.Line, item.Column + item.PrimaryName.Length), new Uri(entry.FileName, UriKind.RelativeOrAbsolute), item, string.Format(" '{0}'", item.PrimaryName)); } } } else { TokenReferenceTokenItem result = new TokenReferenceTokenItem(tokenE, item.Column, item.Line, item.Position); ((SoftReferenceTokenItem)(item)).CloneData(result); if (resolutionAid != null) resolutionAid.ResolvedSinglePartToToken(item, tokenE); return result; } } else if (item.SecondaryName == null) errors.SourceModelError<ISoftReferenceTokenItem>(OilexerGrammarCore.CompilerErrors.UndefinedTokenReference, new LineColumnPair(item.Line, item.Column), new LineColumnPair(item.Line, item.Column + item.PrimaryName.Length), new Uri(entry.FileName, UriKind.RelativeOrAbsolute), item, string.Format(" '{0}'", item.PrimaryName)); else errors.SourceModelError<ISoftReferenceTokenItem>(OilexerGrammarCore.CompilerErrors.UndefinedTokenReference, new LineColumnPair(item.Line, item.Column), new LineColumnPair(item.SecondaryToken.Line, item.SecondaryToken.Column + item.SecondaryToken.Length), new Uri(entry.FileName, UriKind.RelativeOrAbsolute), item, string.Format(" '{0}'", item.PrimaryName)); return item; }
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; } } }
private static void ResolveToken(this IOilexerGrammarTokenEntry entry, OilexerGrammarFile file, ICompilerErrorCollection errors) { List<IOilexerGrammarTokenEntry> lowerTokens = new List<IOilexerGrammarTokenEntry>(); if (entry.LowerPrecedenceTokens == null) { foreach (var s in entry.LowerPrecedenceNames) { var match = (from generalEntry in tokenEntries let tokenEntry = generalEntry as IOilexerGrammarTokenEntry where tokenEntry != null && tokenEntry.Name == s.Name select tokenEntry).FirstOrDefault(); if (match == null) { errors.SourceModelError<IOilexerGrammarTokenEntry>(OilexerGrammarCore.CompilerErrors.UndefinedTokenReference, new LineColumnPair(s.Line, s.Column), new LineColumnPair(s.Line, s.Column + s.Name.Length), new Uri(entry.FileName, UriKind.RelativeOrAbsolute), entry, string.Format(@", lower precedence: '{0}'", s.Name)); break; } lowerTokens.Add(match); } ((OilexerGrammarTokenEntry)entry).LowerPrecedenceTokens = lowerTokens.ToArray(); } entry.Branches.ResolveTokenExpressionSeries(entry, file, errors); }
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)); } }