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 IRuleReferenceProductionRuleItem FinalLink(this ISoftReferenceProductionRuleItem softReference, IOilexerGrammarProductionRuleEntry currentEntry, OilexerGrammarFile file, ICompilerErrorCollection errors)
{
IOilexerGrammarProductionRuleEntry ipre = ruleEntries.OilexerGrammarFindScannableEntry(softReference.PrimaryName);
if (ipre == null)
{
errors.SourceError(OilexerGrammarCore.CompilerErrors.UndefinedTokenReference, new LineColumnPair(softReference.Line, softReference.Column), LineColumnPair.Zero, new Uri(currentEntry.FileName, UriKind.RelativeOrAbsolute), string.Format(" '{0}'", softReference.PrimaryName));
}
else
{
IRuleReferenceProductionRuleItem ipri = new RuleReferenceProductionRuleItem(ipre, softReference.Column, softReference.Line, softReference.Position);;
((ScannableEntryItem)(softReference)).CloneData(ipri);
return(ipri);
}
return(null);
}
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 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);
}
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 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);
}
}
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));
}
}
