public void ResolvedSinglePartToRule(ISoftReferenceProductionRuleItem item, IOilexerGrammarProductionRuleEntry primary)
{
if (item.PrimaryToken != null)
{
this.handler.ReclassifyToken(item.PrimaryToken, primary);
}
}
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);
}
}
public static void FinalLink(this IOilexerGrammarProductionRuleEntry entry, OilexerGrammarFile file, ICompilerErrorCollection errors)
{
if (entry.NeedsFinalLinking())
{
List <IProductionRule> result = new List <IProductionRule>();
foreach (IProductionRule currentItem in entry)
{
IProductionRule resultIPR = null;
if (currentItem.NeedsFinalLinking())
{
resultIPR = currentItem.FinalLink(entry, file, errors);
}
else
{
resultIPR = currentItem;
}
if (resultIPR != null)
{
result.Add(resultIPR);
}
}
OilexerGrammarProductionRuleEntry r = ((OilexerGrammarProductionRuleEntry)(entry));
r.Clear();
foreach (IProductionRule ipr in result)
{
r.Add(ipr);
}
}
}
public static void Deliteralize(this IOilexerGrammarProductionRuleEntry entry, IList <IOilexerGrammarTokenEntry> availableStock, OilexerGrammarFile file, ICompilerErrorCollection errors)
{
if (entry.NeedsDeliteralized())
{
List <IProductionRule> result = new List <IProductionRule>();
foreach (IProductionRule ipr in entry)
{
IProductionRule resultIPR = null;
if (ipr.NeedsDeliteralized())
{
resultIPR = ipr.Deliteralize(entry, availableStock, file, errors);
}
else
{
resultIPR = ipr;
}
if (resultIPR != null)
{
result.Add(resultIPR);
}
}
OilexerGrammarProductionRuleEntry r = ((OilexerGrammarProductionRuleEntry)(entry));
r.Clear();
foreach (IProductionRule ipr in result)
{
r.Add(ipr);
}
//currentEntry = null;
}
}
public static void ValidateCollapsePoint(this IOilexerGrammarProductionRuleEntry entry, ICompilerErrorCollection errors)
{
if (!entry.All(r => r.Count == 1 && r.All(k => k is IRuleReferenceProductionRuleItem || k is ITokenReferenceProductionRuleItem && k.RepeatOptions.Options == ScannableEntryItemRepeatOptions.None)))
{
errors.ModelError <IOilexerGrammarProductionRuleEntry>(OilexerGrammarCore.CompilerErrors.InvalidRuleCollapsePoint, entry, entry.Name);
}
}
private IEnumerable <PredictionTreeBranch> FollowEpsilonTransitionInternal(IOilexerGrammarProductionRuleEntry rule, IDictionary <SyntacticalDFAState, PredictionTreeLeaf> fullSeries)
{
var collidingNodeKeys = (from t in this.CurrentNode.Veins.DFAOriginState.OutTransitions.Keys
from s in t.GetSymbols()
let rS = s as IGrammarRuleSymbol
where rS != null && rS.Source == rule
let targetOfTransition = this.CurrentNode.Veins.DFAOriginState.OutTransitions[t]
select new { FullTransitionKey = t, Target = fullSeries[targetOfTransition] }).ToArray();
if (collidingNodeKeys.Length > 0)
{
foreach (var key in collidingNodeKeys)
{
var currentPathSet = key.Target;
var transitionedElements = (from pathKey in currentPathSet.Veins.Keys
from path in currentPathSet.Veins[pathKey].UnalteredOriginals
let newPath = GetEpsilonTransitionPath(path)// { MinDepth = this.Depth }
select newPath).ToArray();
foreach (var element in transitionedElements)
{
yield return(element);
}
}
}
}
internal static bool NeedsExpansion(this IProductionRule series, IOilexerGrammarProductionRuleEntry entry)
{
foreach (IProductionRuleItem item in series)
{
if (item is ITemplateReferenceProductionRuleItem)
{
return(true);
}
else if (item is ITemplateParamReferenceProductionRuleItem)
{
return(true);
}
else if (item is IProductionRuleGroupItem)
{
var gItem = (IProductionRuleGroupItem)item;
if (gItem.Count == 0)
{
return(true);
}
else if (gItem.Name.IsEmptyOrNull() && gItem.Count == 1 && gItem[0].Count == 1 && gItem.RepeatOptions == ScannableEntryItemRepeatInfo.None)
{
return(true);
}
if (gItem.NeedsExpansion(entry))
{
return(true);
}
}
}
return(false);
}
public SyntacticalDFARootState this[IOilexerGrammarProductionRuleEntry rule]
{
get
{
return(this.lookup[rule]);
}
}
internal IIntermediateClassMethodMember GetEntryInternalParseMethod(IOilexerGrammarProductionRuleEntry entry)
{
IIntermediateClassMethodMember result;
var adapter = this.Compiler.RuleAdapters[entry];
this.parseInternalMethods.TryGetValue(adapter, out result);
return(result);
}
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);
}
}
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);
}
}
public static string GetDocComment(this IOilexerGrammarProductionRuleEntry entry)
{
StringBuilder s = new StringBuilder();
if (entry == null ||
entry.PreexpansionText == null)
{
return(string.Empty);
}
s.Append(entry.PreexpansionText.Replace('\x20', '\xA0'));
return(s.ToString());
}
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 SyntacticalDFAState this[IOilexerGrammarProductionRuleEntry entry]
{
get
{
lock (this.state.lookup)
foreach (GrammarVocabulary transition in this.Keys)
{
if (transition.Contains(entry))
{
return(this[transition]);
}
}
throw new ArgumentException("entry");
}
}
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));
}
}
}
public bool Contains(IOilexerGrammarProductionRuleEntry entry)
{
IGrammarRuleSymbol rSymbol = (IGrammarRuleSymbol)this.symbols[entry];
if (rSymbol == null)
{
return(false);
}
int index = symbols.IndexOf(rSymbol);
if (this.Offset <= index && Offset + this.Length > index)
{
return(this[(uint)index]);
}
else
{
return(false);
}
}
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 object Evaluate(this IPreprocessorCPrimary expression, IOilexerGrammarProductionRuleEntry currentEntry, IList <IOilexerGrammarTokenEntry> availableStock, ProductionRuleTemplateArgumentSeries argumentLookup, IOilexerGrammarProductionRuleTemplateEntry entry, OilexerGrammarFile file, ICompilerErrorCollection errors)
{
switch (expression.Rule)
{
case 1:
return(expression.String);
case 2:
return(expression.Char);
case 3:
return(expression.PreCLogicalOrExp.Evaluate(currentEntry, availableStock, argumentLookup, entry, file, errors));
case 4:
return(expression.Identifier.Name);
case 5:
return(expression.Number);
}
return(null);
}
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);
}
}
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);
}
protected override void DefineRuleIdentifier(OilexerGrammarTokens.IdentifierToken ruleIdentifier, IOilexerGrammarProductionRuleEntry ruleEntry)
{
this.Handler.ReclassifyToken(ruleIdentifier, ruleEntry);
}
public static bool DependsOn(this SyntacticalDFARootState target, IOilexerGrammarProductionRuleEntry entry)
{
return(target.DependsOn(entry, new List <SyntacticalDFAState>()));
}
private static bool DependsOn(this SyntacticalDFAState target, IOilexerGrammarProductionRuleEntry entry, List <SyntacticalDFAState> followed)
{
//Ensure that cyclic models don't recurse infinitely
if (followed.Contains(target))
{
return(target.ContainsRule(entry));
}
//Add the current element to the followed elements
followed.Add(target);
var stateTransitionUnion = target.OutTransitions.FullCheck;
var breakdown = stateTransitionUnion.Breakdown;
//Step through the rules within the state.
var helper = new DependsOnPredicatedHelper();
foreach (var rule in from rule in breakdown.Rules
select rule.Source)
{
helper.rule = rule;
SyntacticalDFARootState state = null;
//Exit with true when found.
if (rule == entry)
{
return(true);
}
//otherwise, if the root-state of the rule depends upon it...
else if ((state = target[rule]).DependsOn(entry, followed))
{
return(true);
}
/* *
* ... in the event that the initial state of the rule is
* an edge state, continue checking the state after that rule
* is called for, to ensure that the dependencies after that
* rule's reference point are considered. i.e. a hidden
* dependency.
* */
else if (state.CanBeEmpty &&
target.OutTransitions[target.OutTransitions.Keys.First(helper.rulePredicate)].DependsOn(entry, followed))
{
return(true);
}
}
/* *
* Same thing as the above, but only on the tokens
* instead of the rules.
* */
foreach (var token in breakdown.Tokens)
{
helper.token = token as InlinedTokenEntry;
if ((helper.token == null) ||
(helper.token.DFAState == null))
{
continue;
}
if (helper.token.DFAState.IsEdge &&
target.OutTransitions[target.OutTransitions.Keys.First(helper.tokenPredicate)].DependsOn(entry, followed))
{
return(true);
}
}
helper.token = null;
helper.rule = null;
return(false);
}
public Tuple <IOilexerGrammarProductionRuleEntry, SyntacticalDFARootState, SyntacticalDFAState> GetNode(IOilexerGrammarProductionRuleEntry rule)
{
lock (this.state.lookup)
foreach (var key in this.Keys)
{
if (key.Contains(rule))
{
return(new Tuple <IOilexerGrammarProductionRuleEntry, SyntacticalDFARootState, SyntacticalDFAState>(rule, this.state.lookup[rule], this[key]));
}
}
throw new ArgumentException("rule");
}
public SyntacticalDFARootState(IOilexerGrammarProductionRuleEntry entry, ControlledDictionary <IOilexerGrammarProductionRuleEntry, SyntacticalDFARootState> lookup, GrammarSymbolSet symbols)
: base(lookup, symbols)
{
this.entry = entry;
}
/// <summary>Creates a new <see cref="PredictionTreeLeafVeins"/> instance with the <paramref name="parent"/> provided.</summary>
/// <param name="parent">The <see cref="PredictionTreeLeaf"/> from which the <see cref="PredictionTreeLeafVeins"/> is derived.</param>
public PredictionTreeLeafVeins(PredictionTreeLeaf leaf, SyntacticalDFAState originalState, IOilexerGrammarProductionRuleEntry rule)
{
this.Leaf = leaf;
this.DFAOriginState = originalState;
this.Rule = rule;
}
public ProductionRuleCaptureGeneralStructuralItem(IProductionRuleSource[] references, IOilexerGrammarProductionRuleEntry rule, ResultedDataType defaultResultType)
: base(references, rule, defaultResultType)
{
}
internal void ReclassifyToken(OilexerGrammarTokens.IdentifierToken identifierToken, IOilexerGrammarProductionRuleEntry primary)
{
if (reclassifications.ContainsKey(identifierToken))
{
return;
}
reclassifications.Add(identifierToken, OilexerGrammarTokenType.RuleReference);
}
internal ProductionRuleTokenReferenceStructuralItem(ITokenReferenceProductionRuleItem[] references, IOilexerGrammarProductionRuleEntry rule)
: base(references, rule, ResultedDataType.ImportType)
{
}
