private RegularLanguageNFAState Subtract(RegularLanguageNFAState left, RegularLanguageNFAState right)
{
/* *
* Include the right-element where the left overlaps it;
* however, every other point of the right-automation
* is ignored.
* *
* Where the left and right automation are at an edge
* point, the automation does not yield an edge due to
* the exclusive nature of the operation.
* */
RegularLanguageNFAState result = new RegularLanguageNFAState();
if (left.IsEdge)
{
if (right.IsEdge)
result.ForcedNoEdge = true;
else
result.IsEdge = true;
}
foreach (var transition in left.OutTransitions.Keys)
{
IDictionary<RegularLanguageSet, IFiniteAutomataTransitionNode<RegularLanguageSet, List<RegularLanguageNFAState>>> colliders;
RegularLanguageSet remainder = right.OutTransitions.GetColliders(transition, out colliders);
if (!remainder.IsEmpty)
foreach (var target in left.OutTransitions[transition])
result.MoveTo(remainder, target);
foreach (var collision in colliders.Keys)
foreach (var leftTarget in left.OutTransitions[transition])
foreach (var rightTarget in colliders[collision].Target)
result.MoveTo(collision, Subtract(leftTarget, rightTarget));
}
return result;
}
public void BuildState(Dictionary <ITokenSource, Captures.ICaptureTokenStructuralItem> sourceReplacementLookup)
{
var thisReplacement = sourceReplacementLookup.ContainsKey(this) ? (ITokenSource)(sourceReplacementLookup[this]) : (ITokenSource)this;
RegularLanguageNFAState state = null;
foreach (var expression in this.Cast <InlinedTokenExpression>())
{
expression.BuildState(sourceReplacementLookup);
if (state == null)
{
state = expression.NFAState;
}
else
{
state.Union(expression.NFAState);
}
}
List <RegularLanguageNFAState> flatline = new List <RegularLanguageNFAState>();
RegularLanguageNFAState.FlatlineState(state, flatline);
foreach (var fState in flatline)
{
fState.SetIntermediate(thisReplacement);
}
state.SetInitial(thisReplacement);
foreach (var edge in state.ObtainEdges())
{
edge.SetFinal(thisReplacement);
}
state.HandleRepeatCycle <RegularLanguageSet, RegularLanguageNFAState, RegularLanguageDFAState, ITokenSource, RegularLanguageNFARootState, IInlinedTokenItem>(this, thisReplacement, OilexerGrammarInliningCore.TokenRootStateClonerCache, OilexerGrammarInliningCore.TokenStateClonerCache);
this.state = state;
}
public void BuildState(Dictionary <ITokenSource, Captures.ICaptureTokenStructuralItem> sourceReplacementLookup)
{
var thisReplacement = sourceReplacementLookup.ContainsKey(this) ? (ITokenSource)(sourceReplacementLookup[this]) : (ITokenSource)this;
var result = this.BuildStringState(thisReplacement, this.CaseInsensitive, this.Value);
result.HandleRepeatCycle <RegularLanguageSet, RegularLanguageNFAState, RegularLanguageDFAState, ITokenSource, RegularLanguageNFARootState, IInlinedTokenItem>(this, thisReplacement, OilexerGrammarInliningCore.TokenRootStateClonerCache, OilexerGrammarInliningCore.TokenStateClonerCache);
this.state = result;
}
public void BuildState(Dictionary <ITokenSource, Captures.ICaptureTokenStructuralItem> sourceReplacementLookup)
{
var thisReplacement = sourceReplacementLookup.ContainsKey(this) ? (ITokenSource)(sourceReplacementLookup[this]) : (ITokenSource)this;
var target = (InlinedTokenExpressionSeries)this.SearchTarget;
target.BuildState(sourceReplacementLookup);
RegularLanguageNFAState current = null;
Stack <RegularLanguageNFAState> states = new Stack <RegularLanguageNFAState>(new RegularLanguageNFAState[] { target.State });
List <RegularLanguageNFAState> covered = new List <RegularLanguageNFAState>();
states.Peek().SetInitial(thisReplacement);
//Step through the sequence until it's finished with the all states
//associated to the scan operation.
while (states.Count > 0)
{
current = states.Pop();
if (covered.Contains(current))
{
continue;
}
covered.Add(current);
RegularLanguageSet currentSet = current.OutTransitions.FullCheck;
if (!currentSet.IsEmpty)
{
foreach (var transition in current.OutTransitions.Values)
{
foreach (var transitionTarget in transition)
{
if (!covered.Contains(transitionTarget))
{
states.Push(transitionTarget);
}
}
}
currentSet = currentSet.Complement();
if (!(currentSet.IsEmpty))
{
current.MoveTo(currentSet, target.State);
}
}
}
state = target.State;
List <RegularLanguageNFAState> flatline = new List <RegularLanguageNFAState>();
RegularLanguageNFAState.FlatlineState(state, flatline);
foreach (var fState in flatline)
{
fState.SetIntermediate(thisReplacement);
}
state.SetInitial(thisReplacement);
foreach (var edge in State.ObtainEdges())
{
edge.SetFinal(thisReplacement);
}
state.HandleRepeatCycle <RegularLanguageSet, RegularLanguageNFAState, RegularLanguageDFAState, ITokenSource, RegularLanguageNFARootState, IInlinedTokenItem>(this, thisReplacement, OilexerGrammarInliningCore.TokenRootStateClonerCache, OilexerGrammarInliningCore.TokenStateClonerCache);
}
public void BuildState(Dictionary <ITokenSource, Captures.ICaptureTokenStructuralItem> sourceReplacementLookup)
{
var thisReplacement = sourceReplacementLookup.ContainsKey(this) ? (ITokenSource)(sourceReplacementLookup[this]) : (ITokenSource)this;
RegularLanguageNFAState root = new RegularLanguageNFAState();
RegularLanguageNFAState next = new RegularLanguageNFAState();
root.SetInitial(thisReplacement);
root.MoveTo(this.Range, next);
next.SetFinal(thisReplacement);
root.HandleRepeatCycle <RegularLanguageSet, RegularLanguageNFAState, RegularLanguageDFAState, ITokenSource, RegularLanguageNFARootState, IInlinedTokenItem>(this, thisReplacement, OilexerGrammarInliningCore.TokenRootStateClonerCache, OilexerGrammarInliningCore.TokenStateClonerCache);
this.state = root;
}
public void BuildState(Dictionary <ITokenSource, ICaptureTokenStructuralItem> sourceReplacementLookup)
{
RegularLanguageNFAState state = new RegularLanguageNFAState();
foreach (var item in this.Cast <IInlinedTokenItem>())
{
item.BuildState(sourceReplacementLookup);
state.Concat(item.State);
}
this.nfaState = state;
}
public void BuildNFA(IOilexerGrammarFile source)
{
if (this.Source is IOilexerGrammarTokenEofEntry)
{
return;
}
this.captureType = this.DetermineKind();
Dictionary <ITokenSource, ICaptureTokenStructuralItem> replacements = new Dictionary <ITokenSource, ICaptureTokenStructuralItem>();
if (captureType.Value != RegularCaptureType.Recognizer)
{
this.structure = TokenStructuralExtractionCore.BuildStructureFor(this, source);
replacements = TokenStructuralExtractionCore.ObtainReplacements(this.structure);
}
else
{
replacements = new Dictionary <ITokenSource, ICaptureTokenStructuralItem>();
}
this.nfaState = new RegularLanguageNFARootState(this);
bool first = true;
foreach (var expression in this.Branches.Cast <InlinedTokenExpression>())
{
expression.BuildState(replacements);
var expressionNFA = expression.NFAState;
if (first)
{
bool isEdge = expressionNFA.IsEdge;
first = false;
nfaState.Union(expression.NFAState);
if (nfaState.IsEdge && !isEdge)
{
nfaState.IsEdge = isEdge;
}
}
else
{
nfaState.Union(expression.NFAState);
}
}
if (ForcedRecognizer)
{
List <RegularLanguageNFAState> flatline = new List <RegularLanguageNFAState>();
RegularLanguageNFAState.FlatlineState(this.nfaState, flatline);
foreach (var state in flatline)
{
state.IgnoreSources = true;
}
}
}
public void BuildState(Dictionary <ITokenSource, ICaptureTokenStructuralItem> sourceReplacementLookup)
{
foreach (var expression in this.Cast <InlinedTokenExpression>())
{
expression.BuildState(sourceReplacementLookup);
if (this.state == null)
{
this.state = expression.NFAState;
}
else
{
this.state.Union(expression.NFAState);
}
}
}
private static void CreateBaseEncodedGraph(RegularLanguageNFAState targetState, RegularLanguageNFAState originalState, Dictionary <RegularLanguageNFAState, RegularLanguageNFAState> oldNewLookup, Func <int, NumericBase> baseFactory, bool caseSensitive, int numChars)
{
/* *
* If it's using a user-supplied base, '0' isn't always
* correct, but it *will* always be one character.
* */
var zero = baseFactory(0).ToString()[0];
foreach (var set in originalState.OutTransitions.Keys)
{
var targets = originalState.OutTransitions[set];
var endTargets = (from s in targets
select oldNewLookup[s]).ToArray();
List <string> characters = null;
Dictionary <char, List <string> > currentSubsets = new Dictionary <char, List <string> >();
for (int i = (int)set.Offset; i < set.Offset + set.Length; i++)
{
if (set[(uint)i])
{
var s = baseFactory(i);
string current = s.ToString();
if (numChars > current.Length)
{
/* *
* The math of the radix yields the firstSeries element within the
* set always carries a value of zero. The headache of a
* variable-length escape sequence is not worth it.
* */
current = zero.Repeat(numChars - current.Length) + current;
}
char first = current[0];
if (!currentSubsets.ContainsKey(first))
{
currentSubsets.Add(first, characters = new List <string>());
}
string substr = current.Substring(1);
if (!characters.Contains(substr))
{
characters.Add(substr);
}
}
}
Breakdown(targetState, currentSubsets, endTargets, caseSensitive);
}
}
public void BuildState(Dictionary<ITokenSource, Captures.ICaptureTokenStructuralItem> sourceReplacementLookup)
{
var left = ((InlinedTokenExpressionSeries)this.Left);
var right = ((InlinedTokenExpressionSeries)this.Right);
var thisReplacement = sourceReplacementLookup.ContainsKey(this) ? (ITokenSource)(sourceReplacementLookup[this]) : (ITokenSource)this;
left.BuildState(sourceReplacementLookup);
right.BuildState(sourceReplacementLookup);
var result = this.Subtract(left.State, right.State);
List<RegularLanguageNFAState> flatline = new List<RegularLanguageNFAState>();
RegularLanguageNFAState.FlatlineState(result, flatline);
foreach (var fState in flatline)
fState.SetIntermediate(thisReplacement);
result.SetInitial(thisReplacement);
foreach (var edge in result.ObtainEdges())
edge.SetFinal(thisReplacement);
result.HandleRepeatCycle<RegularLanguageSet, RegularLanguageNFAState, RegularLanguageDFAState, ITokenSource, RegularLanguageNFARootState, IInlinedTokenItem>(this, thisReplacement, OilexerGrammarInliningCore.TokenRootStateClonerCache, OilexerGrammarInliningCore.TokenStateClonerCache);
this.state = result;
}
private static void Breakdown(RegularLanguageNFAState targetState, Dictionary <char, List <string> > currentSubsets, RegularLanguageNFAState[] endTargets, bool caseSensitive)
{
foreach (var c in currentSubsets.Keys)
{
var currentSet = currentSubsets[c];
var transition = new RegularLanguageSet(caseSensitive, c);
List <string> characters = null;
Dictionary <char, List <string> > nextSubsets = new Dictionary <char, List <string> >();
foreach (var str in currentSet)
{
if (str == string.Empty)
{
foreach (var state in endTargets)
{
targetState.MoveTo(transition, state);
}
}
else
{
char first = str[0];
if (!nextSubsets.ContainsKey(first))
{
nextSubsets.Add(first, characters = new List <string>());
}
string substr = str.Substring(1);
if (!characters.Contains(substr))
{
characters.Add(substr);
}
}
}
if (nextSubsets.Count > 0)
{
var nextSubstate = new RegularLanguageNFAState();
targetState.MoveTo(transition, nextSubstate);
Breakdown(nextSubstate, nextSubsets, endTargets, caseSensitive);
}
}
}
public void BuildState(Dictionary <ITokenSource, Captures.ICaptureTokenStructuralItem> sourceReplacementLookup)
{
/* *
* ToDo: Analyze encodeTarget state and find the number of
* characters necessary to encode it in the target
* base.
* */
var thisReplacement = sourceReplacementLookup.ContainsKey(this) ? (ITokenSource)(sourceReplacementLookup[this]) : (ITokenSource)this;
InlinedTokenExpressionSeries encodeTarget = (InlinedTokenExpressionSeries)this.EncodeTarget;
encodeTarget.BuildState(sourceReplacementLookup);
var state = encodeTarget.State;
List <RegularLanguageNFAState> originalStates = new List <RegularLanguageNFAState>();
RegularLanguageNFAState.FlatlineState(state, originalStates);
if (!originalStates.Contains(state))
{
originalStates.Add(state);
}
var onLookup = new Dictionary <RegularLanguageNFAState, RegularLanguageNFAState>();
foreach (var originalState in originalStates)
{
onLookup.Add(originalState, new RegularLanguageNFAState());
}
Func <int, NumericBase> baseFactory = null;
bool caseSensitive = false;
if (this.NumericBase == null)
{
/* *
* User-supplied base.
* */
var ac = new AnyController(this.StringBase.GetCleanValue(), !this.StringBase.CaseInsensitive);
baseFactory = ab => new AnyBase(ac, ab);
caseSensitive = !StringBase.CaseInsensitive;
}
else
{
var cleanValue = this.NumericBase.GetCleanValue();
baseFactory = baseCreator[(EncodeBase)cleanValue];
switch (cleanValue)
{
case 8:
case 16:
case 18:
case 27:
case 36:
caseSensitive = false;
break;
case 60:
caseSensitive = true;
break;
}
}
Parallel.ForEach(originalStates, originalState =>
{
var targetState = onLookup[originalState];
targetState.SetSources(originalState.Sources.ToDictionary(k => k.Item1, v => v.Item2));
CreateBaseEncodedGraph(targetState, originalState, onLookup, baseFactory, caseSensitive, Digits.GetCleanValue());
targetState.IsEdge = originalState.IsEdge;
});
this.state = onLookup[state];
this.state.HandleRepeatCycle <RegularLanguageSet, RegularLanguageNFAState, RegularLanguageDFAState, ITokenSource, RegularLanguageNFARootState, IInlinedTokenItem>(this, thisReplacement, OilexerGrammarInliningCore.TokenRootStateClonerCache, OilexerGrammarInliningCore.TokenStateClonerCache);
}
