public TreeToNFAConverter(Grammar g, NFA nfa, NFAFactory factory, ITreeNodeStream input)
: this( input )
{
this.grammar = g;
this.nfa = nfa;
this.factory = factory;
}
public void testBufferWrap()
{
int N = 10;
// make tree with types: 1 2 ... INITIAL_LOOKAHEAD_BUFFER_SIZE+N
ITree t = new CommonTree((IToken)null);
for (int i = 0; i < UnBufferedTreeNodeStream.INITIAL_LOOKAHEAD_BUFFER_SIZE + N; i++)
{
t.AddChild(new CommonTree(new CommonToken(i + 1)));
}
// move head to index N
ITreeNodeStream stream = CreateUnBufferedTreeNodeStream(t);
for (int i = 1; i <= N; i++)
{ // consume N
ITree node = (ITree)stream.LT(1);
Assert.AreEqual(i, node.Type);
stream.Consume();
}
// now use LT to lookahead past end of buffer
int remaining = UnBufferedTreeNodeStream.INITIAL_LOOKAHEAD_BUFFER_SIZE - N;
int wrapBy = 4; // wrap around by 4 nodes
Assert.IsTrue(wrapBy < N, "bad test code; wrapBy must be less than N");
for (int i = 1; i <= remaining + wrapBy; i++)
{ // wrap past end of buffer
ITree node = (ITree)stream.LT(i); // look ahead to ith token
Assert.AreEqual(N + i, node.Type);
}
}
public TreeToNFAConverter( Grammar g, NFA nfa, NFAFactory factory, ITreeNodeStream input )
: this(input)
{
this.grammar = g;
this.nfa = nfa;
this.factory = factory;
}
public void testBufferOverflow()
{
StringBuilder buf = new StringBuilder();
StringBuilder buf2 = new StringBuilder();
// make ^(101 102 ... n)
ITree t = new CommonTree(new CommonToken(101));
buf.Append(" 101");
buf2.Append(" 101");
buf2.Append(" ");
buf2.Append(Token.DOWN);
for (int i = 0; i <= UnBufferedTreeNodeStream.INITIAL_LOOKAHEAD_BUFFER_SIZE + 10; i++)
{
t.AddChild(new CommonTree(new CommonToken(102 + i)));
buf.Append(" ");
buf.Append(102 + i);
buf2.Append(" ");
buf2.Append(102 + i);
}
buf2.Append(" ");
buf2.Append(Token.UP);
ITreeNodeStream stream = CreateUnBufferedTreeNodeStream(t);
String expecting = buf.ToString();
String found = GetStringOfEntireStreamContentsWithNodeTypesOnly(stream);
Assert.AreEqual(expecting, found);
expecting = buf2.ToString();
found = stream.ToString();
Assert.AreEqual(expecting, found);
}
public DebugTreeNodeStream(ITreeNodeStream input, IDebugEventListener dbg)
{
this.input = input;
this.adaptor = input.TreeAdaptor;
this.input.HasUniqueNavigationNodes = true;
SetDebugListener(dbg);
}
public DebugTreeNodeStream(ITreeNodeStream input, IDebugEventListener dbg)
{
this.input = input;
this.adaptor = input.TreeAdaptor;
this.input.HasUniqueNavigationNodes = true;
SetDebugListener(dbg);
}
public ElementFrequenciesVisitor(Grammar grammar, ITreeNodeStream input)
: base(input)
{
this.grammar = grammar;
frequencies = new Stack <FrequencySet <string> >();
frequencies.Push(new FrequencySet <string>());
minFrequencies = new Stack <FrequencySet <string> >();
minFrequencies.Push(SENTINEL);
}
public ElementFrequenciesVisitor(Grammar grammar, ITreeNodeStream input)
: base(input)
{
this.grammar = grammar;
frequencies = new Stack<FrequencySet<string>>();
frequencies.Push(new FrequencySet<string>());
minFrequencies = new Stack<FrequencySet<string>>();
minFrequencies.Push(SENTINEL);
}
protected void ExtractInformationFromTreeNodeStream(IIntStream input)
{
ITreeNodeStream nodes = (ITreeNodeStream)input;
this.node = nodes.LT(1);
ITreeAdaptor adaptor = nodes.TreeAdaptor;
IToken payload = adaptor.GetToken(node);
if (payload != null)
{
this.token = payload;
if (payload.Line <= 0)
{
// imaginary node; no line/pos info; scan backwards
int i = -1;
object priorNode = nodes.LT(i);
while (priorNode != null)
{
IToken priorPayload = adaptor.GetToken(priorNode);
if ((priorPayload != null) && (priorPayload.Line > 0))
{
// we found the most recent real line / pos info
this.line = priorPayload.Line;
this.charPositionInLine = priorPayload.CharPositionInLine;
this.approximateLineInfo = true;
break;
}
--i;
priorNode = nodes.LT(i);
}
}
else
{
// node created from real token
this.line = payload.Line;
this.charPositionInLine = payload.CharPositionInLine;
}
}
else if (this.node is ITree)
{
this.line = ((ITree)this.node).Line;
this.charPositionInLine = ((ITree)this.node).CharPositionInLine;
if (this.node is CommonTree)
{
this.token = ((CommonTree)this.node).Token;
}
}
else
{
int type = adaptor.GetNodeType(this.node);
string text = adaptor.GetNodeText(this.node);
this.token = new CommonToken(type, text);
}
}
public void testSingleNode()
{
ITree t = new CommonTree(new CommonToken(101));
ITreeNodeStream stream = CreateCommonTreeNodeStream(t);
string expected = " 101";
string actual = GetStringOfEntireStreamContentsWithNodeTypesOnly(stream);
Assert.AreEqual(expected, actual);
expected = " 101";
actual = stream.ToString();
Assert.AreEqual(expected, actual);
}
public string GetStringOfEntireStreamContentsWithNodeTypesOnly(ITreeNodeStream nodes)
{
StringBuilder buf = new StringBuilder();
for (int i = 0; i < nodes.Size(); i++)
{
object t = nodes.LT(i + 1);
int type = nodes.TreeAdaptor.GetNodeType(t);
if (!((type == Token.DOWN) || (type == Token.UP)))
{
buf.Append(" ");
buf.Append(type);
}
}
return buf.ToString();
}
public string GetStringOfEntireStreamContentsWithNodeTypesOnly(ITreeNodeStream nodes)
{
StringBuilder buf = new StringBuilder();
for (int i = 0; i < nodes.Size(); i++)
{
object t = nodes.LT(i + 1);
int type = nodes.TreeAdaptor.GetNodeType(t);
if (!((type == Token.DOWN) || (type == Token.UP)))
{
buf.Append(" ");
buf.Append(type);
}
}
return(buf.ToString());
}
public void testAoverB()
{
ITree t = new CommonTree(new CommonToken(101));
t.AddChild(new CommonTree(new CommonToken(102)));
ITreeNodeStream stream = CreateBufferedTreeNodeStream(t);
string expected = " 101 102";
string actual = GetStringOfEntireStreamContentsWithNodeTypesOnly(stream);
Assert.AreEqual(expected, actual);
expected = " 101 2 102 3";
actual = stream.ToString();
Assert.AreEqual(expected, actual);
}
/// <summary>
/// Test a tree with four nodes - ^(101 ^(102 103) 104)
/// </summary>
public void test4Nodes()
{
ITree t = new CommonTree(new CommonToken(101));
t.AddChild(new CommonTree(new CommonToken(102)));
t.GetChild(0).AddChild(new CommonTree(new CommonToken(103)));
t.AddChild(new CommonTree(new CommonToken(104)));
ITreeNodeStream stream = CreateCommonTreeNodeStream(t);
string expected = " 101 102 103 104";
string actual = GetStringOfEntireStreamContentsWithNodeTypesOnly(stream);
Assert.AreEqual(expected, actual);
expected = " 101 2 102 2 103 3 104 3";
actual = stream.ToString();
Assert.AreEqual(expected, actual);
}
public void testLT()
{
// ^(101 ^(102 103) 104)
ITree t = new CommonTree(new CommonToken(101));
t.AddChild(new CommonTree(new CommonToken(102)));
t.GetChild(0).AddChild(new CommonTree(new CommonToken(103)));
t.AddChild(new CommonTree(new CommonToken(104)));
ITreeNodeStream stream = CreateCommonTreeNodeStream(t);
Assert.AreEqual(101, ((ITree)stream.LT(1)).Type);
Assert.AreEqual(Token.DOWN, ((ITree)stream.LT(2)).Type);
Assert.AreEqual(102, ((ITree)stream.LT(3)).Type);
Assert.AreEqual(Token.DOWN, ((ITree)stream.LT(4)).Type);
Assert.AreEqual(103, ((ITree)stream.LT(5)).Type);
Assert.AreEqual(Token.UP, ((ITree)stream.LT(6)).Type);
Assert.AreEqual(104, ((ITree)stream.LT(7)).Type);
Assert.AreEqual(Token.UP, ((ITree)stream.LT(8)).Type);
Assert.AreEqual(Token.EOF, ((ITree)stream.LT(9)).Type);
// check way ahead
Assert.AreEqual(Token.EOF, ((ITree)stream.LT(100)).Type);
}
/** <summary>
* Create a normal parser except wrap the token stream in a debug
* proxy that fires consume events.
* </summary>
*/
public DebugTreeParser(ITreeNodeStream input, IDebugEventListener dbg, RecognizerSharedState state)
: base(input is DebugTreeNodeStream ? input : new DebugTreeNodeStream(input, dbg), state)
{
SetDebugListener(dbg);
}
public MismatchedTreeNodeException(string message, int expecting, ITreeNodeStream input, Exception innerException)
: base(message, input, innerException)
{
this._expecting = expecting;
}
public MismatchedTreeNodeException(int expecting, ITreeNodeStream input)
: base(input)
{
this._expecting = expecting;
}
public DebugTreeParser( ITreeNodeStream input, IDebugEventListener dbg )
: this(input is DebugTreeNodeStream ? input : new DebugTreeNodeStream( input, dbg ), dbg, null)
{
}
public DebugTreeParser( ITreeNodeStream input, RecognizerSharedState state )
: base(input is DebugTreeNodeStream ? input : new DebugTreeNodeStream( input, null ), state)
{
}
/** <summary>
* Create a normal parser except wrap the token stream in a debug
* proxy that fires consume events.
* </summary>
*/
public DebugTreeParser( ITreeNodeStream input, IDebugEventListener dbg, RecognizerSharedState state )
: base(input is DebugTreeNodeStream ? input : new DebugTreeNodeStream( input, dbg ), state)
{
SetDebugListener(dbg);
}
public DebugTreeParser(ITreeNodeStream input, RecognizerSharedState state)
: base(input is DebugTreeNodeStream ? input : new DebugTreeNodeStream(input, null), state)
{
}
public MismatchedTreeNodeException(string message, int expecting, ITreeNodeStream input, Exception innerException)
: base(message, input, innerException)
{
this._expecting = expecting;
}
public DebugTreeParser(ITreeNodeStream input, IDebugEventListener dbg)
: this(input is DebugTreeNodeStream ? input : new DebugTreeNodeStream(input, dbg), dbg, null)
{
}
public MismatchedTreeNodeException( int expecting, ITreeNodeStream input )
: base(input)
{
this._expecting = expecting;
}
