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