/// <summary>
/// Creates node in context of given grammar, from completeEdge
/// </summary>
/// <param name="grammar">Grammar which rules created current node</param>
/// <param name="completeEdge">Edge that will be represented by created node</param>
internal Node(GrammarBase grammar, CompleteEdge completeEdge)
{
Edge = completeEdge;
Grammar = grammar;
if (TerminalEdge == null)
{
Name = completeEdge.CompleteLabel.Parent.Name;
}
else
{
Name = TerminalEdge.Parent.Name;
}
addChild(completeEdge.ExtendingEdge);
var current = completeEdge.ExtendedEdge;
while (current != null)
{
addChild(current.ExtendingEdge);
current = current.ExtendedEdge;
}
ChildNodes.Reverse();
skipTransientChildren();
removePunctuation();
}
internal ActiveEdge(ActiveEdge extendedEdge, CompleteEdge extendingEdge)
: base(extendedEdge.StartContext, extendingEdge.EndContext)
{
ExtendingEdge = extendingEdge;
ExtendedEdge = extendedEdge;
Label = ExtendedEdge.Label.NextInChain;
}
internal CompleteEdge(ActiveEdge extendedEdge, CompleteEdge extendingEdge)
: base(extendedEdge.StartContext, extendingEdge.EndContext)
{
CompleteLabel = extendedEdge.Label.CompleteLabel;
Parent = CompleteLabel.Parent;
ExtendedEdge = extendedEdge;
ExtendingEdge = extendingEdge;
}
internal bool Connect(CompleteEdge edge)
{
if (!_completeEdges.Add(edge))
{
return(false);
}
return(true);
}
private Node buildOutput(CompleteEdge result)
{
if (result == null)
{
return(null);
}
var root = new Node(_grammar, result);
return(root);
}
internal IEnumerable <ActiveEdge> ExtensibleWith(CompleteEdge edge)
{
HashSet <ActiveEdge> extensible;
var term = edge.Parent;
if (_extensibleEdges.TryGetValue(term, out extensible))
{
return(extensible);
}
return(new ActiveEdge[0]);
}
/// <summary>
/// Add child node representing given edge
/// </summary>
/// <param name="edge">Edge that will be represented by added child</param>
private void addChild(CompleteEdge edge)
{
if (edge == null)
{
return;
}
var child = new Node(Grammar, edge);
ChildNodes.Add(child);
}
private static void predict(CompleteEdge constituent, ActiveEdge edge)
{
//TODO check if new possible interpretation of input is added
var newEdge = edge.ExtendBy(constituent);
var endContext = newEdge.EndContext;
if (endContext.Connect(newEdge))
{
foreach (var transition in newEdge.Label.Transitions)
{
var transitionEdge = new ActiveEdge(transition, newEdge);
endContext.Connect(transitionEdge);
}
}
}
private void print(CompleteEdge edge)
{
if (edge == null)
{
return;
}
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine(edge);
print(edge.ExtendingEdge);
var current = edge.ExtendedEdge;
while (current != null)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine(current);
print(edge.ExtendingEdge);
current = current.ExtendedEdge;
}
}
private void complete(CompleteEdge constituent, ActiveEdge edge)
{
//new constituent will be created
var newConstituent = edge.CompleteBy(constituent);
var endContext = newConstituent.EndContext;
if (endContext.Connect(newConstituent))
{
//constituent doesn't exists in the graph yet
_agenda.Enqueue(newConstituent);
}
if (newConstituent.IsFinal && newConstituent.EndContext.EOF && newConstituent.StartContext.BOF)
{
_result = newConstituent;
//prevent further processing
_agenda.Clear();
}
}
/// <summary>
/// Run parsing according to parser grammar on given text
/// TODO: Error reporting
/// </summary>
/// <param name="text">Text input for parsing</param>
/// <returns>Parse source data</returns>
public SourceData Parse(string text)
{
var w = Stopwatch.StartNew();
//initialize
_agenda.Clear();
_interpretations.Clear();
_nextWordContexts.Clear();
_result = null;
var inputTokens = _grammar.OutlineTokens(new[] { Token.Text(text, 0) });
var tokenStream = new TokenStream(inputTokens);
var sourceData = new SourceData(text, tokenStream);
var startContext = sourceData.StartContext;
startContext.AddSelfEdgesFrom(_rootTransitions);
_nextWordContexts.Add(startContext);
while (_result == null)
{
if (!scan())
{
break;
}
processAgenda();
}
w.Stop();
Console.WriteLine("{0}ms", w.ElapsedMilliseconds);
var root = buildOutput(_result);
sourceData.Root = root;
return(sourceData);
}
internal ActiveEdge ExtendBy(CompleteEdge constituent)
{
// return new ActiveEdge(Label.NextInChain, OriginContext, StartContext, constituent.EndContext);
return(new ActiveEdge(this, constituent));
}
internal CompleteEdge CompleteBy(CompleteEdge constituent)
{
// return new CompleteEdge(Label.CompleteLabel, OriginContext, constituent.EndContext);
return(new CompleteEdge(this, constituent));
}
