private void ProcessSymbolTransitions(DottedRuleSet frame)
{
var pool = SharedPools.Default <Dictionary <ISymbol, SortedSet <IDottedRule> > >();
var transitions = pool.AllocateAndClear();
for (int i = 0; i < frame.Data.Count; i++)
{
var nfaState = frame.Data[i];
if (IsComplete(nfaState))
{
continue;
}
var postDotSymbol = GetPostDotSymbol(nfaState);
var targetStates = transitions.AddOrGetExisting(postDotSymbol);
var nextRule = GetPreComputedState(nfaState.Production, nfaState.Position + 1);
targetStates.Add(nextRule);
}
foreach (var symbol in transitions.Keys)
{
var confirmedStates = GetConfirmedStates(transitions[symbol]);
var valueDottedRuleSet = AddNewOrGetExistingDottedRuleSet(confirmedStates);
frame.AddTransistion(symbol, valueDottedRuleSet);
}
pool.ClearAndFree(transitions);
}
public PreComputedGrammar(IGrammar grammar)
{
_dottedRuleSetQueue = new ProcessOnceQueue <DottedRuleSet>();
_dottedRuleSets = new Dictionary <DottedRuleSet, DottedRuleSet>();
Grammar = grammar;
var startStates = Initialize(Grammar);
Start = AddNewOrGetExistingDottedRuleSet(startStates);
ProcessDottedRuleSetQueue();
}
private bool TryGetOrCreateDottedRuleSet(SortedSet <IDottedRule> states, out DottedRuleSet outDottedRuleSet)
{
var dottedRuleSet = new DottedRuleSet(states);
if (_dottedRuleSets.TryGetValue(dottedRuleSet, out outDottedRuleSet))
{
return(true);
}
outDottedRuleSet = dottedRuleSet;
_dottedRuleSets[dottedRuleSet] = outDottedRuleSet;
_dottedRuleSetQueue.Enqueue(outDottedRuleSet);
return(false);
}
private DottedRuleSet AddNewOrGetExistingDottedRuleSet(SortedSet <IDottedRule> states)
{
var dottedRuleSet = new DottedRuleSet(states);
DottedRuleSet outDottedRuleSet;
if (_dottedRuleSets.TryGetValue(dottedRuleSet, out outDottedRuleSet))
{
return(outDottedRuleSet);
}
outDottedRuleSet = dottedRuleSet;
_dottedRuleSets[dottedRuleSet] = outDottedRuleSet;
_dottedRuleSetQueue.Enqueue(outDottedRuleSet);
return(outDottedRuleSet);
}
public void AddTransistion(ISymbol symbol, DottedRuleSet target)
{
if (symbol.SymbolType == SymbolType.NonTerminal)
{
if (!Reductions.ContainsKey(symbol))
{
_reductions.Add(symbol, target);
}
}
else if (symbol.SymbolType == SymbolType.LexerRule)
{
var lexerRule = symbol as ILexerRule;
if (!Scans.ContainsKey(lexerRule))
{
_tokenTransitions.Add(lexerRule.TokenType, target);
_scans.Add(lexerRule, target);
_scanKeys.Add(lexerRule);
}
}
}
private SortedSet <IDottedRule> GetPredictedStates(DottedRuleSet frame)
{
var pool = SharedPools.Default <Queue <IDottedRule> >();
var queue = pool.AllocateAndClear();
var closure = new SortedSet <IDottedRule>();
for (int i = 0; i < frame.Data.Count; i++)
{
var state = frame.Data[i];
if (!IsComplete(state))
{
queue.Enqueue(state);
}
}
while (queue.Count > 0)
{
var state = queue.Dequeue();
if (IsComplete(state))
{
continue;
}
var postDotSymbol = GetPostDotSymbol(state);
if (postDotSymbol.SymbolType != SymbolType.NonTerminal)
{
continue;
}
var nonTerminalPostDotSymbol = postDotSymbol as INonTerminal;
if (Grammar.IsTransativeNullable(nonTerminalPostDotSymbol))
{
var preComputedState = GetPreComputedState(state.Production, state.Position + 1);
if (!frame.Contains(preComputedState))
{
if (closure.Add(preComputedState))
{
if (!IsComplete(preComputedState))
{
queue.Enqueue(preComputedState);
}
}
}
}
var predictions = Grammar.RulesFor(nonTerminalPostDotSymbol);
for (var p = 0; p < predictions.Count; p++)
{
var prediction = predictions[p];
var preComputedState = GetPreComputedState(prediction, 0);
if (frame.Contains(preComputedState))
{
continue;
}
if (!closure.Add(preComputedState))
{
continue;
}
if (!IsComplete(preComputedState))
{
queue.Enqueue(preComputedState);
}
}
}
pool.ClearAndFree(queue);
return(closure);
}
