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);
}
