private void Scan(INormalState scan, int j, IToken token)
{
var i = scan.Origin;
var currentSymbol = scan.DottedRule.PostDotSymbol;
var lexerRule = currentSymbol as ILexerRule;
if (token.TokenType != lexerRule.TokenType)
{
return;
}
var dottedRule = _dottedRuleRegistry.GetNext(scan.DottedRule);
if (_chart.Contains(j + 1, StateType.Normal, dottedRule, i))
{
return;
}
var tokenNode = _nodeSet.AddOrGetExistingTokenNode(token);
var parseNode = CreateParseNode(
dottedRule,
scan.Origin,
scan.ParseNode,
tokenNode,
j + 1);
var nextState = StateFactory.NewState(dottedRule, scan.Origin, parseNode);
if (_chart.Enqueue(j + 1, nextState))
{
LogScan(j + 1, nextState, token);
}
}
private void Complete(INormalState completed, int k)
{
if (completed.ParseNode == null)
{
completed.ParseNode = CreateNullParseNode(completed.DottedRule.Production.LeftHandSide, k);
}
var earleySet = _chart.EarleySets[completed.Origin];
var searchSymbol = completed.DottedRule.Production.LeftHandSide;
if (Options.OptimizeRightRecursion)
{
OptimizeReductionPath(searchSymbol, completed.Origin);
}
var transitionState = earleySet.FindTransitionState(searchSymbol);
if (transitionState != null)
{
LeoComplete(transitionState, completed, k);
}
else
{
EarleyComplete(completed, k);
}
}
private void EarleyComplete(INormalState completed, int k)
{
var j = completed.Origin;
var sourceEarleySet = _chart.EarleySets[j];
for (int p = 0; p < sourceEarleySet.Predictions.Count; p++)
{
var prediction = sourceEarleySet.Predictions[p];
if (!prediction.IsSource(completed.DottedRule.Production.LeftHandSide))
{
continue;
}
var nextState = StateFactory.NextState(prediction);
var parseNode = CreateParseNode(
nextState,
prediction.ParseNode,
completed.ParseNode,
k);
nextState.ParseNode = parseNode;
if (_chart.Enqueue(k, nextState))
{
Log("Complete", k, nextState);
}
}
}
private bool AddUniquePrediction(INormalState normalState)
{
if (_predictions == null)
{
_predictions = new UniqueList <INormalState>();
}
return(_predictions.AddUnique(normalState));
}
private bool AddUniqueScan(INormalState normalState)
{
if (_scans == null)
{
_scans = new UniqueList <INormalState>();
}
return(_scans.AddUnique(normalState));
}
private bool AddUniqueCompletion(INormalState normalState)
{
if (_completions == null)
{
_completions = new UniqueList <INormalState>();
}
return(_completions.AddUnique(normalState));
}
private Unit()
{
normal = new Normal();
lockdown = new LockDown();
blind = new Blind();
emergency = new EmergencyAdapter(new Emergency());
state = normal;
}
public TransitionState(
ISymbol recognized,
IState transition,
INormalState reduction,
int index)
: base(transition.DottedRule, transition.Origin)
{
Reduction = reduction;
Recognized = recognized;
Index = index;
_hashCode = ComputeHashCode();
}
public TransitionState(
ISymbol recognized,
IState transition,
INormalState reduction,
int index)
: base(transition.Production, transition.Position, transition.Origin)
{
Reduction = reduction;
Recognized = recognized;
Index = index;
_hashCode = ComputeHashCode();
}
private bool EnqueueNormal(IState state, INormalState normalState)
{
if (!state.IsComplete)
{
var currentSymbol = state.PostDotSymbol;
if (currentSymbol.SymbolType == SymbolType.NonTerminal)
{
return(_predictions.AddUnique(normalState));
}
return(_scans.AddUnique(normalState));
}
return(_completions.AddUnique(normalState));
}
private bool EnqueueNormal(IState state, INormalState normalState)
{
var dottedRule = state.DottedRule;
if (dottedRule.IsComplete)
{
return(AddUniqueCompletion(normalState));
}
var currentSymbol = dottedRule.PostDotSymbol;
if (currentSymbol.SymbolType == SymbolType.NonTerminal)
{
return(AddUniquePrediction(normalState));
}
return(AddUniqueScan(normalState));
}
private void Predict(INormalState evidence, int j)
{
var nonTerminal = evidence.PostDotSymbol as INonTerminal;
var rulesForNonTerminal = Grammar.RulesFor(nonTerminal);
// PERF: Avoid boxing enumerable
for (int p = 0; p < rulesForNonTerminal.Count; p++)
{
var production = rulesForNonTerminal[p];
PredictProduction(j, production);
}
var isNullable = Grammar.IsNullable(evidence.PostDotSymbol as INonTerminal);
if (isNullable)
{
PredictAycockHorspool(evidence, j);
}
}
public INormalState FindSourceState(ISymbol searchSymbol)
{
var sourceItemCount = 0;
INormalState sourceItem = null;
for (int s = 0; s < Predictions.Count; s++)
{
var state = Predictions[s];
if (state.IsSource(searchSymbol))
{
var moreThanOneSourceItemExists = sourceItemCount > 0;
if (moreThanOneSourceItemExists)
{
return(null);
}
sourceItemCount++;
sourceItem = state;
}
}
return(sourceItem);
}
private void PredictAycockHorspool(INormalState evidence, int j)
{
var nullParseNode = CreateNullParseNode(evidence.DottedRule.PostDotSymbol, j);
var dottedRule = _dottedRuleRegistry.GetNext(evidence.DottedRule);
var evidenceParseNode = evidence.ParseNode as IInternalForestNode;
IForestNode parseNode = null;
if (evidenceParseNode is null)
{
parseNode = CreateParseNode(
dottedRule,
evidence.Origin,
null,
nullParseNode,
j);
}
else if (evidenceParseNode.Children.Count > 0 &&
evidenceParseNode.Children[0].Children.Count > 0)
{
parseNode = CreateParseNode(
dottedRule,
evidence.Origin,
evidenceParseNode,
nullParseNode,
j);
}
if (_chart.Contains(j, StateType.Normal, dottedRule, evidence.Origin))
{
return;
}
var aycockHorspoolState = StateFactory.NewState(dottedRule, evidence.Origin, parseNode);
if (_chart.Enqueue(j, aycockHorspoolState))
{
Log(PredictionLogName, j, aycockHorspoolState);
}
}
private void PredictAycockHorspool(INormalState evidence, int j)
{
var nullParseNode = CreateNullParseNode(evidence.PostDotSymbol, j);
var aycockHorspoolState = StateFactory.NextState(evidence);
var evidenceParseNode = evidence.ParseNode as IInternalForestNode;
if (evidenceParseNode == null)
{
aycockHorspoolState.ParseNode = CreateParseNode(aycockHorspoolState, null, nullParseNode, j);
}
else if (evidenceParseNode.Children.Count > 0 &&
evidenceParseNode.Children[0].Children.Count > 0)
{
var firstChildNode = evidenceParseNode;
var parseNode = CreateParseNode(aycockHorspoolState, firstChildNode, nullParseNode, j);
aycockHorspoolState.ParseNode = parseNode;
}
if (_chart.Enqueue(j, aycockHorspoolState))
{
Log("Predict", j, aycockHorspoolState);
}
}
private void Scan(INormalState scan, int j, IToken token)
{
var i = scan.Origin;
var currentSymbol = scan.PostDotSymbol;
var lexerRule = currentSymbol as ILexerRule;
if (token.TokenType == lexerRule.TokenType)
{
var tokenNode = _nodeSet.AddOrGetExistingTokenNode(token);
var nextState = StateFactory.NextState(scan);
var parseNode = CreateParseNode(
nextState,
scan.ParseNode,
tokenNode,
j + 1);
nextState.ParseNode = parseNode;
if (_chart.Enqueue(j + 1, nextState))
{
LogScan(j + 1, nextState, token);
}
}
}
private void EarleyComplete(INormalState completed, int k)
{
var j = completed.Origin;
var sourceEarleySet = _chart.EarleySets[j];
for (int p = 0; p < sourceEarleySet.Predictions.Count; p++)
{
var prediction = sourceEarleySet.Predictions[p];
if (!prediction.IsSource(completed.DottedRule.Production.LeftHandSide))
{
continue;
}
var dottedRule = _dottedRuleRegistry.GetNext(prediction.DottedRule);
var origin = prediction.Origin;
// this will not create a node if the state already exists
var parseNode = CreateParseNode(
dottedRule,
origin,
prediction.ParseNode,
completed.ParseNode,
k);
if (_chart.Contains(k, StateType.Normal, dottedRule, origin))
{
continue;
}
var nextState = StateFactory.NewState(dottedRule, origin, parseNode);
if (_chart.Enqueue(k, nextState))
{
Log(CompleteLogName, k, nextState);
}
}
}
private void Complete(INormalState completed, int k)
{
if (completed.ParseNode == null)
completed.ParseNode = CreateNullParseNode(completed.Production.LeftHandSide, k);
var earleySet = _chart.EarleySets[completed.Origin];
var searchSymbol = completed.Production.LeftHandSide;
if(Options.OptimizeRightRecursion)
OptimizeReductionPath(searchSymbol, completed.Origin);
var transitionState = earleySet.FindTransitionState(searchSymbol);
if (transitionState != null)
{
LeoComplete(transitionState, completed, k);
}
else
{
EarleyComplete(completed, k);
}
}
private void Scan(INormalState scan, int j, IToken token)
{
var i = scan.Origin;
var currentSymbol = scan.PostDotSymbol;
var lexerRule = currentSymbol as ILexerRule;
if (token.TokenType == lexerRule.TokenType)
{
var tokenNode = _nodeSet.AddOrGetExistingTokenNode(token);
var nextState = scan.NextState();
var parseNode = CreateParseNode(
nextState,
scan.ParseNode,
tokenNode,
j + 1);
nextState.ParseNode = parseNode;
if (_chart.Enqueue(j + 1, nextState))
LogScan(j + 1, nextState, token);
}
}
private void PredictProduction(INormalState evidence, int j, IProduction production)
{
// TODO: Pre-Compute Leo Items. If item is 1 step from being complete, add a transition item
var predictedState = new NormalState(production, 0, j);
if (_chart.Enqueue(j, predictedState))
Log("Predict", j, predictedState);
var isNullable = Grammar.IsNullable(evidence.PostDotSymbol as INonTerminal);
if (isNullable)
{
var nullParseNode = CreateNullParseNode(evidence.PostDotSymbol, j);
var aycockHorspoolState = evidence.NextState();
var evidenceParseNode = evidence.ParseNode as IInternalForestNode;
if (evidenceParseNode == null)
aycockHorspoolState.ParseNode = CreateParseNode(aycockHorspoolState, null, nullParseNode, j);
else if (evidenceParseNode.Children.Count > 0
&& evidenceParseNode.Children[0].Children.Count > 0)
{
var firstChildNode = evidenceParseNode;
var parseNode = CreateParseNode(aycockHorspoolState, firstChildNode, nullParseNode, j);
aycockHorspoolState.ParseNode = parseNode;
}
if (_chart.Enqueue(j, aycockHorspoolState))
Log("Predict", j, aycockHorspoolState);
}
}
private void Predict(INormalState evidence, int j)
{
var nonTerminal = evidence.PostDotSymbol as INonTerminal;
var rulesForNonTerminal = Grammar.RulesFor(nonTerminal);
// PERF: Avoid boxing enumerable
for (int p = 0; p < rulesForNonTerminal.Count; p++)
{
var production = rulesForNonTerminal[p];
PredictProduction(evidence, j, production);
}
}
private void EarleyComplete(INormalState completed, int k)
{
var j = completed.Origin;
var sourceEarleySet = _chart.EarleySets[j];
for (int p = 0; p < sourceEarleySet.Predictions.Count; p++)
{
var prediction = sourceEarleySet.Predictions[p];
if (!prediction.IsSource(completed.Production.LeftHandSide))
continue;
var nextState = prediction.NextState();
var parseNode = CreateParseNode(
nextState,
prediction.ParseNode,
completed.ParseNode,
k);
nextState.ParseNode = parseNode;
if (_chart.Enqueue(k, nextState))
Log("Complete", k, nextState);
}
}
private bool EnqueueNormal(IState state, INormalState normalState)
{
if (!state.IsComplete)
{
var currentSymbol = state.PostDotSymbol;
if (currentSymbol.SymbolType == SymbolType.NonTerminal)
return _predictions.Enqueue(normalState);
return _scans.Enqueue(normalState);
}
return _completions.Enqueue(normalState);
}
public void setState(INormalState state)
{
this.state = state;
}
