public void testSeek() { // ^(101 ^(102 103 ^(106 107) ) 104 105) // stream has 7 real + 6 nav nodes // Sequence of types: 101 DN 102 DN 103 106 DN 107 Up Up 104 105 Up EndOfFile ITree r0 = new CommonTree(new CommonToken(101)); ITree r1 = new CommonTree(new CommonToken(102)); r0.AddChild(r1); r1.AddChild(new CommonTree(new CommonToken(103))); ITree r2 = new CommonTree(new CommonToken(106)); r2.AddChild(new CommonTree(new CommonToken(107))); r1.AddChild(r2); r0.AddChild(new CommonTree(new CommonToken(104))); r0.AddChild(new CommonTree(new CommonToken(105))); BufferedTreeNodeStream stream = new BufferedTreeNodeStream(r0); stream.Consume(); // consume 101 stream.Consume(); // consume DN stream.Consume(); // consume 102 stream.Seek(7); // seek to 107 Assert.AreEqual(107, ((ITree)stream.LT(1)).Type); stream.Consume(); // consume 107 stream.Consume(); // consume Up stream.Consume(); // consume Up Assert.AreEqual(104, ((ITree)stream.LT(1)).Type); }
public void testSingleNode() { CommonTree t = new CommonTree(new CommonToken(101)); Assert.IsNull(t.parent); Assert.AreEqual(-1, t.childIndex); }
// TODO: move to basetree when i settle on how runtime works // TODO: don't include this node!! // TODO: reuse other method public virtual CommonTree GetFirstDescendantWithType(int type) { if (Type == type) { return(this); } if (Children == null) { return(null); } foreach (object c in Children) { GrammarAST t = (GrammarAST)c; if (t.Type == type) { return(t); } CommonTree d = t.GetFirstDescendantWithType(type); if (d != null) { return(d); } } return(null); }
public void testAddListToExistChildren() { // Add child ^(nil 101 102 103) to root ^(5 6) // should add 101 102 103 to end of 5's child list CommonTree root = new CommonTree(new CommonToken(5)); root.AddChild(new CommonTree(new CommonToken(6))); // child tree CommonTree r0 = new CommonTree((IToken)null); CommonTree c0, c1, c2; r0.AddChild(c0 = new CommonTree(new CommonToken(101))); r0.AddChild(c1 = new CommonTree(new CommonToken(102))); r0.AddChild(c2 = new CommonTree(new CommonToken(103))); root.AddChild(r0); Assert.IsNull(root.parent); Assert.AreEqual(-1, root.childIndex); // check children of root all point at root Assert.AreEqual(root, c0.parent); Assert.AreEqual(1, c0.childIndex); Assert.AreEqual(root, c0.parent); Assert.AreEqual(2, c1.childIndex); Assert.AreEqual(root, c0.parent); Assert.AreEqual(3, c2.childIndex); }
// TODO: don't include this node!! public virtual CommonTree GetFirstDescendantWithType(Antlr.Runtime.BitSet types) { if (types.Member(Type)) { return(this); } if (Children == null) { return(null); } foreach (object c in Children) { GrammarAST t = (GrammarAST)c; if (types.Member(t.Type)) { return(t); } CommonTree d = t.GetFirstDescendantWithType(types); if (d != null) { return(d); } } return(null); }
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 void testSeekFromStart() { // ^(101 ^(102 103 ^(106 107) ) 104 105) // stream has 7 real + 6 nav nodes // Sequence of types: 101 DN 102 DN 103 106 DN 107 UP UP 104 105 UP EOF ITree r0 = new CommonTree(new CommonToken(101)); ITree r1 = new CommonTree(new CommonToken(102)); r0.AddChild(r1); r1.AddChild(new CommonTree(new CommonToken(103))); ITree r2 = new CommonTree(new CommonToken(106)); r2.AddChild(new CommonTree(new CommonToken(107))); r1.AddChild(r2); r0.AddChild(new CommonTree(new CommonToken(104))); r0.AddChild(new CommonTree(new CommonToken(105))); CommonTreeNodeStream stream = new CommonTreeNodeStream(r0); stream.Seek(7); // seek to 107 Assert.AreEqual(107, ((ITree)stream.LT(1)).Type); stream.Consume(); // consume 107 stream.Consume(); // consume UP stream.Consume(); // consume UP Assert.AreEqual(104, ((ITree)stream.LT(1)).Type); }
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 void testList() { ITree root = new CommonTree((IToken)null); 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))); ITree u = new CommonTree(new CommonToken(105)); root.AddChild(t); root.AddChild(u); CommonTreeNodeStream stream = new CommonTreeNodeStream(root); string expected = " 101 102 103 104 105"; string actual = GetStringOfEntireStreamContentsWithNodeTypesOnly(stream); Assert.AreEqual(expected, actual); expected = " 101 2 102 2 103 3 104 3 105"; actual = stream.ToString(); Assert.AreEqual(expected, actual); }
public void testList2() { // Add child ^(nil 101 102 103) to root 5 // should pull 101 102 103 directly to become 5's child list CommonTree root = new CommonTree(new CommonToken(5)); // child tree CommonTree r0 = new CommonTree((IToken)null); CommonTree c0, c1, c2; r0.AddChild(c0 = new CommonTree(new CommonToken(101))); r0.AddChild(c1 = new CommonTree(new CommonToken(102))); r0.AddChild(c2 = new CommonTree(new CommonToken(103))); root.AddChild(r0); Assert.IsNull(root.Parent); Assert.AreEqual(-1, root.ChildIndex); // check children of root all point at root Assert.AreEqual(root, c0.Parent); Assert.AreEqual(0, c0.ChildIndex); Assert.AreEqual(root, c0.Parent); Assert.AreEqual(1, c1.ChildIndex); Assert.AreEqual(root, c0.Parent); Assert.AreEqual(2, c2.ChildIndex); }
public virtual void ParseAndRewrite() { ProcessArgs(args); ICharStream input = null; if (filename != null) { input = new ANTLRFileStream(filename); } else { input = new ANTLRReaderStream(Console.In, ANTLRReaderStream.InitialBufferSize, ANTLRReaderStream.ReadBufferSize); } // BUILD AST ANTLRLexer lex = new ANTLRLexer(input); tokens = new TokenRewriteStream(lex); ANTLRParser g = new ANTLRParser(tokens); Grammar grammar = new Grammar(); var r = g.grammar_(grammar); CommonTree t = (CommonTree)r.Tree; if (tree_option) { Console.Out.WriteLine(t.ToStringTree()); } Rewrite(g.TreeAdaptor, t, g.TokenNames); }
public void testInvalidListTree() { ITreeAdaptor adaptor = new CommonTreeAdaptor(); TreeWizard wiz = new TreeWizard(adaptor, tokens); CommonTree t = (CommonTree)wiz.Create("A B C"); Assert.IsTrue(t == null); }
public void testPushPopFromEOF() { // ^(101 ^(102 103) ^(104 105) ^(106 107) 108 109) // stream has 9 real + 8 nav nodes // Sequence of types: 101 DN 102 DN 103 UP 104 DN 105 UP 106 DN 107 UP 108 109 UP ITree r0 = new CommonTree(new CommonToken(101)); ITree r1 = new CommonTree(new CommonToken(102)); r1.AddChild(new CommonTree(new CommonToken(103))); r0.AddChild(r1); ITree r2 = new CommonTree(new CommonToken(104)); r2.AddChild(new CommonTree(new CommonToken(105))); r0.AddChild(r2); ITree r3 = new CommonTree(new CommonToken(106)); r3.AddChild(new CommonTree(new CommonToken(107))); r0.AddChild(r3); r0.AddChild(new CommonTree(new CommonToken(108))); r0.AddChild(new CommonTree(new CommonToken(109))); CommonTreeNodeStream stream = new CommonTreeNodeStream(r0); while (stream.LA(1) != Token.EOF) { stream.Consume(); } int indexOf102 = 2; int indexOf104 = 6; Assert.AreEqual(Token.EOF, ((ITree)stream.LT(1)).Type); // CALL 102 stream.Push(indexOf102); Assert.AreEqual(102, ((ITree)stream.LT(1)).Type); stream.Consume(); // consume 102 Assert.AreEqual(Token.DOWN, ((ITree)stream.LT(1)).Type); stream.Consume(); // consume DN Assert.AreEqual(103, ((ITree)stream.LT(1)).Type); stream.Consume(); // consume 103 Assert.AreEqual(Token.UP, ((ITree)stream.LT(1)).Type); // RETURN (to empty stack) stream.Pop(); Assert.AreEqual(Token.EOF, ((ITree)stream.LT(1)).Type); // CALL 104 stream.Push(indexOf104); Assert.AreEqual(104, ((ITree)stream.LT(1)).Type); stream.Consume(); // consume 102 Assert.AreEqual(Token.DOWN, ((ITree)stream.LT(1)).Type); stream.Consume(); // consume DN Assert.AreEqual(105, ((ITree)stream.LT(1)).Type); stream.Consume(); // consume 103 Assert.AreEqual(Token.UP, ((ITree)stream.LT(1)).Type); // RETURN (to empty stack) stream.Pop(); Assert.AreEqual(Token.EOF, ((ITree)stream.LT(1)).Type); }
public void testWildcard() { ITreeAdaptor adaptor = new CommonTreeAdaptor(); TreeWizard wiz = new TreeWizard(adaptor, tokens); CommonTree t = (CommonTree)wiz.Create("(A B C)"); bool valid = wiz.Parse(t, "(A . .)"); Assert.IsTrue(valid); }
public void testParseSingleNode() { ITreeAdaptor adaptor = new CommonTreeAdaptor(); TreeWizard wiz = new TreeWizard(adaptor, tokens); CommonTree t = (CommonTree)wiz.Create("A"); bool valid = wiz.Parse(t, "A"); Assert.IsTrue(valid); }
/** * Finish instantiating class objects --- needs to be called after subclass constructors (and is called by them accordingly) */ protected void finishConstruction() { if (this.InitialString != null) { Antlr.Runtime.Tree.CommonTree tmptree = passel.controller.parsing.math.Expression.Parse(this.InitialString); //passel.controller.parsing.math.Expression.FixTypes(ref tmptree); this.Initially = passel.controller.parsing.math.ast.LogicalExpression.CreateTerm(tmptree); } }
public void testParseWithTextFails() { ITreeAdaptor adaptor = new CommonTreeAdaptor(); TreeWizard wiz = new TreeWizard(adaptor, tokens); CommonTree t = (CommonTree)wiz.Create("(A B C)"); bool valid = wiz.Parse(t, "(A[foo] B C)"); Assert.IsTrue(!valid); // fails }
public void testSingleNodeWithArg() { ITreeAdaptor adaptor = new CommonTreeAdaptor(); TreeWizard wiz = new TreeWizard(adaptor, tokens); CommonTree t = (CommonTree)wiz.Create("ID[foo]"); string actual = t.ToStringTree(); string expected = "foo"; Assert.AreEqual(expected, actual); }
public void testDoubleLevelTree() { ITreeAdaptor adaptor = new CommonTreeAdaptor(); TreeWizard wiz = new TreeWizard(adaptor, tokens); CommonTree t = (CommonTree)wiz.Create("(A (B C) (B D) E)"); string actual = t.ToStringTree(); string expected = "(A (B C) (B D) E)"; Assert.AreEqual(expected, actual); }
public void testListTree() { ITreeAdaptor adaptor = new CommonTreeAdaptor(); TreeWizard wiz = new TreeWizard(adaptor, tokens); CommonTree t = (CommonTree)wiz.Create("(nil A B C)"); string actual = t.ToStringTree(); string expected = "A B C"; Assert.AreEqual(expected, actual); }
public void testEqualsWithMismatchedText() { ITreeAdaptor adaptor = new CommonTreeAdaptor(); TreeWizard wiz = new TreeWizard(adaptor, tokens); CommonTree t1 = (CommonTree)wiz.Create("(A B[foo] C)"); CommonTree t2 = (CommonTree)wiz.Create("(A B C)"); bool same = TreeWizard.Equals(t1, t2, adaptor); Assert.IsTrue(!same); }
public void testSingleNodeIndex() { ITreeAdaptor adaptor = new CommonTreeAdaptor(); TreeWizard wiz = new TreeWizard(adaptor, tokens); CommonTree t = (CommonTree)wiz.Create("ID"); IDictionary m = wiz.Index(t); string actual = CollectionUtils.DictionaryToString(m); string expected = "{10=[ID]}"; Assert.AreEqual(expected, actual); }
public void testParseWithText() { ITreeAdaptor adaptor = new CommonTreeAdaptor(); TreeWizard wiz = new TreeWizard(adaptor, tokens); CommonTree t = (CommonTree)wiz.Create("(A B[foo] C[bar])"); // C pattern has no text arg so despite [bar] in t, no need // to match text--check structure only. bool valid = wiz.Parse(t, "(A B[foo] C)"); Assert.IsTrue(valid); }
public void test4Nodes() { // ^(101 ^(102 103) 104) CommonTree r0 = new CommonTree(new CommonToken(101)); r0.AddChild(new CommonTree(new CommonToken(102))); r0.GetChild(0).AddChild(new CommonTree(new CommonToken(103))); r0.AddChild(new CommonTree(new CommonToken(104))); Assert.IsNull(r0.parent); Assert.AreEqual(-1, r0.childIndex); }
public void testRepeatsIndex() { ITreeAdaptor adaptor = new CommonTreeAdaptor(); TreeWizard wiz = new TreeWizard(adaptor, tokens); CommonTree t = (CommonTree)wiz.Create("(A B (A C B) B D D)"); IDictionary m = wiz.Index(t); string actual = CollectionUtils.DictionaryToString(m); //string expected = "{8=[D, D], 6=[B, B, B], 7=[C], 5=[A, A]}"; string expected = "{8=[D, D], 7=[C], 6=[B, B, B], 5=[A, A]}"; Assert.AreEqual(expected, actual); }
public void testParseWithWildcardLabels() { ITreeAdaptor adaptor = new CommonTreeAdaptor(); TreeWizard wiz = new TreeWizard(adaptor, tokens); CommonTree t = (CommonTree)wiz.Create("(A B C)"); IDictionary labels = new Hashtable(); bool valid = wiz.Parse(t, "(A %b:. %c:.)", labels); Assert.IsTrue(valid); Assert.AreEqual("B", labels["b"].ToString()); Assert.AreEqual("C", labels["c"].ToString()); }
public void testFindPattern() { ITreeAdaptor adaptor = new CommonTreeAdaptor(); TreeWizard wiz = new TreeWizard(adaptor, tokens); CommonTree t = (CommonTree)wiz.Create("(A B C (A[foo] B[bar]) (D (A[big] B[dog])))"); IList subtrees = wiz.Find(t, "(A B)"); IList elements = subtrees; string actual = CollectionUtils.ListToString(elements); string expected = "[foo, big]"; Assert.AreEqual(expected, actual); }
/// <summary> /// Parse a user supplied assumption: also asserts it into Z3 /// </summary> /// <param name="reader"></param> public static void ParseAssumption(XmlTextReader reader) { String assump = reader.GetAttribute(AssumptionAttributes.equn.ToString()); String type = reader.GetAttribute(AssumptionAttributes.type.ToString()); AssumptionTypes atype; if (type != null) { atype = (AssumptionTypes)Enum.Parse(typeof(AssumptionTypes), type, true); } else { atype = AssumptionTypes.none; } if (assump.Length > 0) { Antlr.Runtime.Tree.CommonTree tmptree = math.Expression.Parse(assump); Expr assumpTerm = LogicalExpression.CreateTerm(tmptree); switch (atype) { case AssumptionTypes.safety: case AssumptionTypes.inductive_invariant: { // assert the assumption Expr assumpTermPrime = assumpTerm; Controller.Instance.Z3.primeAllVariables(ref assumpTermPrime); Expr assumpTermImplies = Controller.Instance.Z3.MkImplies((BoolExpr)assumpTerm, (BoolExpr)assumpTermPrime); // inductive part Controller.Instance.Z3.Assumptions.Add((BoolExpr)assumpTerm); // invariant part Controller.Instance.Z3.Assumptions.Add((BoolExpr)assumpTermPrime); //Controller.Instance.Z3.AssertCnstr(assumpTerm & assumpTermPrime); //Controller.Instance.Z3.AssertCnstr(assumpTermImplies); break; } case AssumptionTypes.invariant: case AssumptionTypes.none: default: { // assert the assumption Controller.Instance.Z3.Assumptions.Add((BoolExpr)assumpTerm); break; } } } }
public void testParseLabelsAndTestText() { ITreeAdaptor adaptor = new CommonTreeAdaptor(); TreeWizard wiz = new TreeWizard(adaptor, tokens); CommonTree t = (CommonTree)wiz.Create("(A B[foo] C)"); IDictionary labels = new Hashtable(); bool valid = wiz.Parse(t, "(%a:A %b:B[foo] %c:C)", labels); Assert.IsTrue(valid); Assert.AreEqual("A", labels["a"].ToString()); Assert.AreEqual("foo", labels["b"].ToString()); Assert.AreEqual("C", labels["c"].ToString()); }
public void testVisitPatternMultipleWithLabels() { ITreeAdaptor adaptor = new CommonTreeAdaptor(); TreeWizard wiz = new TreeWizard(adaptor, tokens); CommonTree t = (CommonTree)wiz.Create("(A B C (A[foo] B[bar]) (D (A[big] B[dog])))"); IList elements = new ArrayList(); wiz.Visit(t, "(%a:A %b:B)", new Test2ContextVisitor(adaptor, elements)); string actual = CollectionUtils.ListToString(elements); string expected = "[foo@A[2]foo&bar, big@D[0]big&dog]"; Assert.AreEqual(expected, actual); }
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); }
/// <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 testList() { // ^(nil 101 102 103) CommonTree r0 = new CommonTree((IToken)null); CommonTree c0, c1, c2; r0.AddChild(c0 = new CommonTree(new CommonToken(101))); r0.AddChild(c1 = new CommonTree(new CommonToken(102))); r0.AddChild(c2 = new CommonTree(new CommonToken(103))); Assert.IsNull(r0.Parent); Assert.AreEqual(-1, r0.ChildIndex); Assert.AreEqual(r0, c0.Parent); Assert.AreEqual(0, c0.ChildIndex); Assert.AreEqual(r0, c1.Parent); Assert.AreEqual(1, c1.ChildIndex); Assert.AreEqual(r0, c2.Parent); Assert.AreEqual(2, c2.ChildIndex); }
public void testMarkRewindNested() { // ^(101 ^(102 103 ^(106 107) ) 104 105) // stream has 7 real + 6 nav nodes // Sequence of types: 101 DN 102 DN 103 106 DN 107 UP UP 104 105 UP EOF ITree r0 = new CommonTree(new CommonToken(101)); ITree r1 = new CommonTree(new CommonToken(102)); r0.AddChild(r1); r1.AddChild(new CommonTree(new CommonToken(103))); ITree r2 = new CommonTree(new CommonToken(106)); r2.AddChild(new CommonTree(new CommonToken(107))); r1.AddChild(r2); r0.AddChild(new CommonTree(new CommonToken(104))); r0.AddChild(new CommonTree(new CommonToken(105))); CommonTreeNodeStream stream = new CommonTreeNodeStream(r0); int m = stream.Mark(); // MARK at start stream.Consume(); // consume 101 stream.Consume(); // consume DN int m2 = stream.Mark(); // MARK on 102 stream.Consume(); // consume 102 stream.Consume(); // consume DN stream.Consume(); // consume 103 stream.Consume(); // consume 106 stream.Rewind(m2); // REWIND to 102 Assert.AreEqual(102, ((ITree)stream.LT(1)).Type); stream.Consume(); Assert.AreEqual(Token.DOWN, ((ITree)stream.LT(1)).Type); stream.Consume(); // stop at 103 and rewind to start stream.Rewind(m); // REWIND to 101 Assert.AreEqual(101, ((ITree)stream.LT(1)).Type); stream.Consume(); Assert.AreEqual(Token.DOWN, ((ITree)stream.LT(1)).Type); stream.Consume(); Assert.AreEqual(102, ((ITree)stream.LT(1)).Type); stream.Consume(); Assert.AreEqual(Token.DOWN, ((ITree)stream.LT(1)).Type); }
public void testMarkRewindInMiddle() { // ^(101 ^(102 103 ^(106 107) ) 104 105) // stream has 7 real + 6 nav nodes // Sequence of types: 101 DN 102 DN 103 106 DN 107 UP UP 104 105 UP EOF ITree r0 = new CommonTree(new CommonToken(101)); ITree r1 = new CommonTree(new CommonToken(102)); r0.AddChild(r1); r1.AddChild(new CommonTree(new CommonToken(103))); ITree r2 = new CommonTree(new CommonToken(106)); r2.AddChild(new CommonTree(new CommonToken(107))); r1.AddChild(r2); r0.AddChild(new CommonTree(new CommonToken(104))); r0.AddChild(new CommonTree(new CommonToken(105))); CommonTreeNodeStream stream = new CommonTreeNodeStream(r0); for (int k = 1; k <= 7; k++) { // consume til middle //System.out.println(((ITree)stream.LT(1)).Type); stream.Consume(); } Assert.AreEqual(107, ((ITree)stream.LT(1)).Type); int m = stream.Mark(); // MARK stream.Consume(); // consume 107 stream.Consume(); // consume UP stream.Consume(); // consume UP stream.Consume(); // consume 104 stream.Rewind(m); // REWIND Assert.AreEqual(107, ((ITree)stream.LT(1)).Type); stream.Consume(); Assert.AreEqual(Token.UP, ((ITree)stream.LT(1)).Type); stream.Consume(); Assert.AreEqual(Token.UP, ((ITree)stream.LT(1)).Type); stream.Consume(); Assert.AreEqual(104, ((ITree)stream.LT(1)).Type); stream.Consume(); // now we're past rewind position Assert.AreEqual(105, ((ITree)stream.LT(1)).Type); stream.Consume(); Assert.AreEqual(Token.UP, ((ITree)stream.LT(1)).Type); stream.Consume(); Assert.AreEqual(Token.EOF, ((ITree)stream.LT(1)).Type); Assert.AreEqual(Token.UP, ((ITree)stream.LT(-1)).Type); }
public virtual void Rewrite( ITreeAdaptor adaptor, CommonTree t, string[] tokenNames ) { TreeWizard wiz = new TreeWizard( adaptor, tokenNames ); // ACTIONS STUFF wiz.Visit( t, ANTLRParser.ACTION, ( tree ) => { ACTION( tokens, (CommonTree)tree ); } ); // ^('@' id ACTION) rule actions wiz.Visit( t, ANTLRParser.AMPERSAND, ( tree ) => { CommonTree a = (CommonTree)t; CommonTree action = null; if (a.ChildCount == 2) { action = (CommonTree)a.GetChild(1); } else if (a.ChildCount == 3) { action = (CommonTree)a.GetChild(2); } if ( action.Type == ANTLRParser.ACTION ) { tokens.Delete( a.TokenStartIndex, a.TokenStopIndex ); KillTrailingNewline( tokens, action.TokenStopIndex ); } } ); wiz.Visit( t, ANTLRParser.ACTION, ( tree ) => { } ); // wipe rule arguments wiz.Visit( t, ANTLRParser.ARG, ( tree ) => { CommonTree a = (CommonTree)t; a = (CommonTree)a.GetChild( 0 ); tokens.Delete( a.Token.TokenIndex ); KillTrailingNewline( tokens, a.Token.TokenIndex ); } ); // wipe rule return declarations wiz.Visit( t, ANTLRParser.RET, ( tree ) => { CommonTree a = (CommonTree)t; CommonTree ret = (CommonTree)a.GetChild( 0 ); tokens.Delete( a.Token.TokenIndex, ret.Token.TokenIndex ); } ); // comment out semantic predicates wiz.Visit( t, ANTLRParser.SEMPRED, ( tree ) => { CommonTree a = (CommonTree)t; tokens.Replace( a.Token.TokenIndex, "/*" + a.Text + "*/" ); } ); // comment out semantic predicates wiz.Visit( t, ANTLRParser.GATED_SEMPRED, ( tree ) => { CommonTree a = (CommonTree)t; string text = tokens.ToString( a.TokenStartIndex, a.TokenStopIndex ); tokens.Replace( a.TokenStartIndex, a.TokenStopIndex, "/*" + text + "*/" ); } ); // comment scope specs wiz.Visit( t, ANTLRParser.SCOPE, ( tree ) => { CommonTree a = (CommonTree)t; tokens.Delete( a.TokenStartIndex, a.TokenStopIndex ); KillTrailingNewline( tokens, a.TokenStopIndex ); } ); // args r[x,y] -> ^(r [x,y]) wiz.Visit( t, ANTLRParser.ARG_ACTION, ( tree ) => { CommonTree a = (CommonTree)t; if ( a.Parent.Type == ANTLRParser.RULE_REF ) tokens.Delete( a.TokenStartIndex, a.TokenStopIndex ); } ); #if false // what is this token type in the C# ported version of the V3 grammar? // ^('=' id ^(RULE_REF [arg])), ... wiz.Visit( t, ANTLRParser.LABEL_ASSIGN, ( tree ) => { CommonTree a = (CommonTree)t; if ( !a.HasAncestor( ANTLRParser.OPTIONS ) ) { // avoid options CommonTree child = (CommonTree)a.GetChild( 0 ); // kill "id=" tokens.Delete( a.token.TokenIndex ); tokens.Delete( child.token.TokenIndex ); } } ); #endif #if false // what is this token type in the C# ported version of the V3 grammar? // ^('+=' id ^(RULE_REF [arg])), ... wiz.Visit( t, ANTLRParser.LIST_LABEL_ASSIGN, ( tree ) => { CommonTree a = (CommonTree)t; CommonTree child = (CommonTree)a.GetChild( 0 ); // kill "id+=" tokens.Delete( a.token.TokenIndex ); tokens.Delete( child.token.TokenIndex ); } ); #endif // AST STUFF wiz.Visit( t, ANTLRParser.REWRITE, ( tree ) => { CommonTree a = (CommonTree)t; CommonTree child = (CommonTree)a.GetChild( 0 ); int stop = child.TokenStopIndex; if ( child.Type == ANTLRParser.SEMPRED ) { CommonTree rew = (CommonTree)a.GetChild( 1 ); stop = rew.TokenStopIndex; } tokens.Delete( a.Token.TokenIndex, stop ); KillTrailingNewline( tokens, stop ); } ); wiz.Visit( t, ANTLRParser.ROOT, ( tree ) => { tokens.Delete( ( (CommonTree)t ).Token.TokenIndex ); } ); wiz.Visit( t, ANTLRParser.BANG, ( tree ) => { tokens.Delete( ( (CommonTree)t ).Token.TokenIndex ); } ); }
public void testDupTree() { // ^(101 ^(102 103 ^(106 107) ) 104 105) CommonTree r0 = new CommonTree(new CommonToken(101)); CommonTree r1 = new CommonTree(new CommonToken(102)); r0.AddChild(r1); r1.AddChild(new CommonTree(new CommonToken(103))); ITree r2 = new CommonTree(new CommonToken(106)); r2.AddChild(new CommonTree(new CommonToken(107))); r1.AddChild(r2); r0.AddChild(new CommonTree(new CommonToken(104))); r0.AddChild(new CommonTree(new CommonToken(105))); CommonTree dup = (CommonTree)(new CommonTreeAdaptor()).DupTree(r0); Assert.IsNull(dup.parent); Assert.AreEqual(-1, dup.childIndex); dup.SanityCheckParentAndChildIndexes(); }
public void testNestedPushPop() { // ^(101 ^(102 103) ^(104 105) ^(106 107) 108 109) // stream has 9 real + 8 nav nodes // Sequence of types: 101 DN 102 DN 103 UP 104 DN 105 UP 106 DN 107 UP 108 109 UP ITree r0 = new CommonTree(new CommonToken(101)); ITree r1 = new CommonTree(new CommonToken(102)); r1.AddChild(new CommonTree(new CommonToken(103))); r0.AddChild(r1); ITree r2 = new CommonTree(new CommonToken(104)); r2.AddChild(new CommonTree(new CommonToken(105))); r0.AddChild(r2); ITree r3 = new CommonTree(new CommonToken(106)); r3.AddChild(new CommonTree(new CommonToken(107))); r0.AddChild(r3); r0.AddChild(new CommonTree(new CommonToken(108))); r0.AddChild(new CommonTree(new CommonToken(109))); CommonTreeNodeStream stream = new CommonTreeNodeStream(r0); // Assume we want to hit node 107 and then "call 102", which // calls 104, then return int indexOf102 = 2; int indexOf107 = 12; for (int k = 1; k <= indexOf107; k++) { // consume til 107 node stream.Consume(); } Assert.AreEqual(107, ((ITree)stream.LT(1)).Type); // CALL 102 stream.Push(indexOf102); Assert.AreEqual(102, ((ITree)stream.LT(1)).Type); stream.Consume(); // consume 102 Assert.AreEqual(Token.DOWN, ((ITree)stream.LT(1)).Type); stream.Consume(); // consume DN Assert.AreEqual(103, ((ITree)stream.LT(1)).Type); stream.Consume(); // consume 103 // CALL 104 int indexOf104 = 6; stream.Push(indexOf104); Assert.AreEqual(104, ((ITree)stream.LT(1)).Type); stream.Consume(); // consume 102 Assert.AreEqual(Token.DOWN, ((ITree)stream.LT(1)).Type); stream.Consume(); // consume DN Assert.AreEqual(105, ((ITree)stream.LT(1)).Type); stream.Consume(); // consume 103 Assert.AreEqual(Token.UP, ((ITree)stream.LT(1)).Type); // RETURN (to UP node in 102 subtree) stream.Pop(); Assert.AreEqual(Token.UP, ((ITree)stream.LT(1)).Type); // RETURN (to empty stack) stream.Pop(); Assert.AreEqual(107, ((ITree)stream.LT(1)).Type); }
public void testReplaceWithOneChildren() { // assume token type 99 and use text CommonTree t = new CommonTree(new CommonToken(99, "a")); CommonTree c0 = new CommonTree(new CommonToken(99, "b")); t.AddChild(c0); CommonTree newChild = new CommonTree(new CommonToken(99, "c")); t.ReplaceChildren(0, 0, newChild); String expected = "(a c)"; Assert.AreEqual(expected, t.ToStringTree()); t.SanityCheckParentAndChildIndexes(); }
public void testReplaceWithNoChildren() { CommonTree t = new CommonTree(new CommonToken(101)); CommonTree newChild = new CommonTree(new CommonToken(5)); bool error = false; try { t.ReplaceChildren(0, 0, newChild); } catch (Exception) { error = true; } Assert.IsTrue(error); }
public void testReplaceTwoWithOneAtRight() { CommonTree t = new CommonTree(new CommonToken(99, "a")); t.AddChild(new CommonTree(new CommonToken(99, "b"))); t.AddChild(new CommonTree(new CommonToken(99, "c"))); t.AddChild(new CommonTree(new CommonToken(99, "d"))); CommonTree newChild = new CommonTree(new CommonToken(99, "x")); t.ReplaceChildren(1, 2, newChild); String expected = "(a b x)"; Assert.AreEqual(expected, t.ToStringTree()); t.SanityCheckParentAndChildIndexes(); }
public void testReplaceOneWithTwoInMiddle() { ITreeAdaptor adaptor = new CommonTreeAdaptor(); CommonTree t = new CommonTree(new CommonToken(99, "a")); t.AddChild(new CommonTree(new CommonToken(99, "b"))); t.AddChild(new CommonTree(new CommonToken(99, "c"))); t.AddChild(new CommonTree(new CommonToken(99, "d"))); CommonTree newChildren = (CommonTree)adaptor.GetNilNode(); newChildren.AddChild(new CommonTree(new CommonToken(99, "x"))); newChildren.AddChild(new CommonTree(new CommonToken(99, "y"))); t.ReplaceChildren(1, 1, newChildren); String expected = "(a b x y d)"; Assert.AreEqual(expected, t.ToStringTree()); t.SanityCheckParentAndChildIndexes(); }
public void testReplaceInMiddle() { CommonTree t = new CommonTree(new CommonToken(99, "a")); t.AddChild(new CommonTree(new CommonToken(99, "b"))); t.AddChild(new CommonTree(new CommonToken(99, "c"))); // index 1 t.AddChild(new CommonTree(new CommonToken(99, "d"))); CommonTree newChild = new CommonTree(new CommonToken(99, "x")); t.ReplaceChildren(1, 1, newChild); String expected = "(a b x d)"; Assert.AreEqual(expected, t.ToStringTree()); t.SanityCheckParentAndChildIndexes(); }
public void testList2() { // Add child ^(nil 101 102 103) to root 5 // should pull 101 102 103 directly to become 5's child list CommonTree root = new CommonTree(new CommonToken(5)); // child tree CommonTree r0 = new CommonTree((IToken)null); CommonTree c0, c1, c2; r0.AddChild(c0 = new CommonTree(new CommonToken(101))); r0.AddChild(c1 = new CommonTree(new CommonToken(102))); r0.AddChild(c2 = new CommonTree(new CommonToken(103))); root.AddChild(r0); Assert.IsNull(root.parent); Assert.AreEqual(-1, root.childIndex); // check children of root all point at root Assert.AreEqual(root, c0.parent); Assert.AreEqual(0, c0.childIndex); Assert.AreEqual(root, c0.parent); Assert.AreEqual(1, c1.childIndex); Assert.AreEqual(root, c0.parent); Assert.AreEqual(2, c2.childIndex); }
public void testPushPop() { // ^(101 ^(102 103) ^(104 105) ^(106 107) 108 109) // stream has 9 real + 8 nav nodes // Sequence of types: 101 DN 102 DN 103 UP 104 DN 105 UP 106 DN 107 UP 108 109 UP ITree r0 = new CommonTree(new CommonToken(101)); ITree r1 = new CommonTree(new CommonToken(102)); r1.AddChild(new CommonTree(new CommonToken(103))); r0.AddChild(r1); ITree r2 = new CommonTree(new CommonToken(104)); r2.AddChild(new CommonTree(new CommonToken(105))); r0.AddChild(r2); ITree r3 = new CommonTree(new CommonToken(106)); r3.AddChild(new CommonTree(new CommonToken(107))); r0.AddChild(r3); r0.AddChild(new CommonTree(new CommonToken(108))); r0.AddChild(new CommonTree(new CommonToken(109))); CommonTreeNodeStream stream = new CommonTreeNodeStream(r0); String expecting = " 101 2 102 2 103 3 104 2 105 3 106 2 107 3 108 109 3"; String found = stream.ToString(); Assert.AreEqual(expecting, found); // Assume we want to hit node 107 and then "call 102" then return int indexOf102 = 2; int indexOf107 = 12; for (int k = 1; k <= indexOf107; k++) { // consume til 107 node stream.Consume(); } // CALL 102 Assert.AreEqual(107, ((ITree)stream.LT(1)).Type); stream.Push(indexOf102); Assert.AreEqual(102, ((ITree)stream.LT(1)).Type); stream.Consume(); // consume 102 Assert.AreEqual(Token.DOWN, ((ITree)stream.LT(1)).Type); stream.Consume(); // consume DN Assert.AreEqual(103, ((ITree)stream.LT(1)).Type); stream.Consume(); // consume 103 Assert.AreEqual(Token.UP, ((ITree)stream.LT(1)).Type); // RETURN stream.Pop(); Assert.AreEqual(107, ((ITree)stream.LT(1)).Type); }
public void testStackStretch() { // make more than INITIAL_CALL_STACK_SIZE pushes ITree r0 = new CommonTree(new CommonToken(101)); CommonTreeNodeStream stream = new CommonTreeNodeStream(r0); // go 1 over initial size for (int i = 1; i <= CommonTreeNodeStream.INITIAL_CALL_STACK_SIZE + 1; i++) { stream.Push(i); } Assert.AreEqual(10, stream.Pop()); Assert.AreEqual(9, stream.Pop()); }
public void testBecomeRoot5() { // ^(nil 5) becomes new root of ^(101 102 103) CommonTree newRoot = new CommonTree((IToken)null); newRoot.AddChild(new CommonTree(new CommonToken(5))); CommonTree oldRoot = new CommonTree(new CommonToken(101)); oldRoot.AddChild(new CommonTree(new CommonToken(102))); oldRoot.AddChild(new CommonTree(new CommonToken(103))); ITreeAdaptor adaptor = new CommonTreeAdaptor(); adaptor.BecomeRoot(newRoot, oldRoot); newRoot.SanityCheckParentAndChildIndexes(); }
public void testListWithOneNode() { ITree root = new CommonTree((IToken)null); root.AddChild(new CommonTree(new CommonToken(101))); CommonTreeNodeStream stream = new CommonTreeNodeStream(root); string expected = " 101"; string actual = GetStringOfEntireStreamContentsWithNodeTypesOnly(stream); Assert.AreEqual(expected, actual); expected = " 101"; 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); }
public void testMarkRewindEntire() { // ^(101 ^(102 103 ^(106 107) ) 104 105) // stream has 7 real + 6 nav nodes // Sequence of types: 101 DN 102 DN 103 106 DN 107 UP UP 104 105 UP EOF ITree r0 = new CommonTree(new CommonToken(101)); ITree r1 = new CommonTree(new CommonToken(102)); r0.AddChild(r1); r1.AddChild(new CommonTree(new CommonToken(103))); ITree r2 = new CommonTree(new CommonToken(106)); r2.AddChild(new CommonTree(new CommonToken(107))); r1.AddChild(r2); r0.AddChild(new CommonTree(new CommonToken(104))); r0.AddChild(new CommonTree(new CommonToken(105))); CommonTreeNodeStream stream = new CommonTreeNodeStream(r0); int m = stream.Mark(); // MARK for (int k = 1; k <= 13; k++) { // consume til end stream.LT(1); stream.Consume(); } Assert.AreEqual(Token.EOF, ((ITree)stream.LT(1)).Type); Assert.AreEqual(Token.UP, ((ITree)stream.LT(-1)).Type); stream.Rewind(m); // REWIND // consume til end again :) for (int k = 1; k <= 13; k++) { // consume til end stream.LT(1); stream.Consume(); } Assert.AreEqual(Token.EOF, ((ITree)stream.LT(1)).Type); Assert.AreEqual(Token.UP, ((ITree)stream.LT(-1)).Type); }
public static DataType Check(AstNode node, Context context) { switch (node.Type) { case MathExprLexer.PROGRAM: { if (context == null) context = new Context(context); CheckBlock(node, context); return DataType.Void; } case MathExprLexer.BLOCK: { context = new Context(context); CheckBlock(node, context); return DataType.Void; } case MathExprLexer.VAR: { List<AstNode> nodes = new List<AstNode>(); DataType dataType = strToDataType(node.GetChild(0).Text); for (int i = 0; i < node.GetChild(0).ChildCount; i++) { AstNode temp = (AstNode) node.GetChild(0).GetChild(i); if (temp.Token.Type == MathExprLexer.ASSIGN) { Ident ident = context.InThisContext(temp.GetChild(0).Text); if (ident != null) throw new ApplicationException(string.Format("Identifier {0} already exists", temp.GetChild(0).Text)); AstNode var = new AstNode(new Antlr.Runtime.CommonToken(MathExprLexer.VAR, "VAR")); var.AddChild(new AstNode(new Antlr.Runtime.CommonToken(MathExprLexer.IDENT, dataTypeToStr(dataType)))); var.GetChild(0).AddChild(new AstNode(new Antlr.Runtime.CommonToken(MathExprLexer.IDENT, temp.GetChild(0).Text))); nodes.Add(var); nodes.Add(temp); } else { Ident ident = context.InThisContext(temp.Text); if (ident != null) throw new ApplicationException(string.Format("Identifier {0} already exists", temp.Text)); AstNode var = new AstNode(new Antlr.Runtime.CommonToken(MathExprLexer.VAR, "VAR")); var.AddChild(new AstNode(new Antlr.Runtime.CommonToken(MathExprLexer.IDENT, dataTypeToStr(dataType)))); var.GetChild(0).AddChild(temp); nodes.Add(var); } string name = nodes[0].GetChild(0).GetChild(0).Text; context[name] = new Ident(name, context.ParentContext == null ? IdentType.GlobalVar : IdentType.LocalVar, dataType, nodes[0]); Antlr.Runtime.Tree.CommonTree tree = new Antlr.Runtime.Tree.CommonTree(); foreach (AstNode n in nodes) tree.AddChild(n); node.Parent.ReplaceChildren(node.ChildIndex, node.ChildIndex, tree); } return DataType.Void; ; } case MathExprLexer.FUNCTION: { DataType dataType = strToDataType(node.GetChild(0).Text); string name = node.GetChild(1).Text; Ident ident = context[name]; if (ident != null) throw new ApplicationException(string.Format("Identifier {0} already exists", name)); Ident func = new Ident(name, IdentType.Function, dataType, node); context[name] = func; context = new Context(context); AstNode _params = (AstNode) node.GetChild(2); for (int i = 0; i < _params.ChildCount; i++) { DataType paramDataType = strToDataType(_params.GetChild(i).Text); string paramName = _params.GetChild(i).GetChild(0).Text; if (paramDataType == DataType.Void) throw new ApplicationException(string.Format("In function {0} void param {1}", name, paramName)); context[paramName] = new Ident(paramName, IdentType.Param, paramDataType, (AstNode) _params.GetChild(i)); } context.Function = func; Check((AstNode) node.GetChild(3), context); return DataType.Void; } case MathExprLexer.CALL: { Ident ident = context[node.GetChild(0).Text]; if (ident == null) throw new ApplicationException(string.Format("Unknown identifier {0}", node.GetChild(0).Text)); if (ident.IdentType != IdentType.Function) throw new ApplicationException(string.Format("Identifier {0} is not function", node.GetChild(0).Text)); if (node.GetChild(1).ChildCount != ident.Node.GetChild(2).ChildCount) throw new ApplicationException(string.Format("Not equals params count in function {0}", node.GetChild(0).Text)); for (int i = 0; i < ident.Node.GetChild(2).ChildCount; i++) { DataType formalDataType = strToDataType(ident.Node.GetChild(2).GetChild(i).Text); DataType factDataType = Check((AstNode)node.GetChild(1).GetChild(i), context); if (formalDataType != factDataType) { if (formalDataType == DataType.Double && factDataType == DataType.Int) convert((AstNode)node.GetChild(1).GetChild(i), DataType.Double); else throw new ApplicationException(string.Format("In function {0} param {1} incopotible types {2} {3}", node.GetChild(0).Text, i, dataTypeToStr(formalDataType), dataTypeToStr(factDataType))); } } return strToDataType(ident.Node.GetChild(0).Text); } case MathExprLexer.IDENT: { Ident ident = context[node.Text]; if (ident == null) throw new ApplicationException(string.Format("Unknown identifier {0}", node.Text)); if (ident.IdentType == IdentType.Function) { if (ident.DataType == DataType.Void) throw new ApplicationException(string.Format("Function {0} returns void", ident.Name)); if (ident.Node.GetChild(1).ChildCount > 0) throw new ApplicationException(string.Format("No params for function {0} call", ident.Name)); AstNode call = new AstNode(new Antlr.Runtime.CommonToken(MathExprLexer.CALL)); call.AddChild(node); call.AddChild(new AstNode(new Antlr.Runtime.CommonToken(MathExprLexer.PARAMS))); node.Parent.SetChild(node.ChildIndex, call); node.DataType = ident.DataType; return node.DataType; } else { node.DataType = ident.DataType; return node.DataType; } } case MathExprLexer.NUMBER: { node.DataType = node.Text.Contains(".") ? DataType.Double : DataType.Int; return node.DataType; } case MathExprLexer.TRUE: case MathExprLexer.FALSE: { node.DataType = DataType.Bool; return node.DataType; } case MathExprLexer.ASSIGN: { Ident ident = context[node.GetChild(0).Text]; if (ident == null) throw new ApplicationException(string.Format("Unknown identifier {0}", node.GetChild(0).Text)); if (ident.IdentType == IdentType.Function) throw new ApplicationException(string.Format("Assign to function {0}", node.GetChild(0).Text)); DataType rightDataType = Check((AstNode) node.GetChild(1), context); if (ident.DataType != rightDataType) { if (ident.DataType == DataType.Double && rightDataType == DataType.Int) convert((AstNode) node.GetChild(1), DataType.Double); else throw new ApplicationException(string.Format("Assign incopotible types {0} {1}", dataTypeToStr(ident.DataType), dataTypeToStr(rightDataType))); } return DataType.Void; } case MathExprLexer.RETURN: { if (context.Function == null) throw new ApplicationException(string.Format("Return not in function in line {0}", node.Line)); DataType returnDataType = Check((AstNode) node.GetChild(0), context); if (context.Function.DataType != returnDataType) { if (context.Function.DataType == DataType.Double && returnDataType == DataType.Int) convert((AstNode) node.GetChild(0), DataType.Double); else throw new ApplicationException(string.Format("Return incopotible types {0} {1}", dataTypeToStr(context.Function.DataType), dataTypeToStr(returnDataType))); } return DataType.Void; } case MathExprLexer.ADD: case MathExprLexer.SUB: case MathExprLexer.MUL: case MathExprLexer.DIV: case MathExprLexer.GE: case MathExprLexer.LE: case MathExprLexer.NEQUALS: case MathExprLexer.EQUALS: case MathExprLexer.GT: case MathExprLexer.LT: { bool compareOperation = true; switch (node.Type) { case MathExprLexer.ADD: case MathExprLexer.SUB: case MathExprLexer.MUL: case MathExprLexer.DIV: compareOperation = false; break; } DataType leftDataType = Check((AstNode) node.GetChild(0), context); DataType rightDataType = Check((AstNode) node.GetChild(1), context); if (leftDataType != DataType.Double && leftDataType != DataType.Int) throw new ApplicationException(string.Format("Left operand invalid type for operation {0}, line = {1}, pos = {2}", node.Text, node.Line, node.TokenStartIndex)); if (rightDataType != DataType.Double && rightDataType != DataType.Int) throw new ApplicationException(string.Format("Right operand invalid type for operation {0}, line = {1}, pos = {2}", node.Text, node.Line, node.TokenStartIndex)); if (leftDataType == DataType.Double) { if (rightDataType == DataType.Int) convert((AstNode)node.GetChild(1), DataType.Double); node.DataType = compareOperation ? DataType.Bool : DataType.Double; return node.DataType; } if (rightDataType == DataType.Double) { if (leftDataType == DataType.Int) convert((AstNode)node.GetChild(0), DataType.Double); node.DataType = compareOperation ? DataType.Bool : DataType.Double; return node.DataType; } node.DataType = compareOperation ? DataType.Bool : DataType.Int; return node.DataType; } case MathExprLexer.NOT: { DataType dataType = Check((AstNode) node.GetChild(0), context); if (dataType != DataType.Bool) throw new ApplicationException(string.Format("Not operator with type {0}", dataTypeToStr(dataType))); node.DataType = DataType.Bool; return node.DataType; } case MathExprLexer.AND: case MathExprLexer.OR: case MathExprLexer.XOR: { DataType leftDataType = Check((AstNode) node.GetChild(0), context); DataType rightDataType = Check((AstNode) node.GetChild(1), context); if (leftDataType != DataType.Bool && rightDataType != DataType.Bool) throw new ApplicationException(string.Format("{0} operator with type {1}, {2}", node.Text, dataTypeToStr(leftDataType), dataTypeToStr(rightDataType))); node.DataType = DataType.Bool; return node.DataType; } case MathExprLexer.WHILE: { DataType condDataType = Check((AstNode)node.GetChild(0), context); if (condDataType != DataType.Bool) throw new ApplicationException(string.Format("In while condition type is {0}", dataTypeToStr(condDataType))); // context = new Context(context); Check((AstNode)node.GetChild(1), context); return DataType.Void; } case MathExprLexer.IF: { DataType condDataType = Check((AstNode)node.GetChild(0), context); if (condDataType != DataType.Bool) throw new ApplicationException(string.Format("In if condition type is {0}", dataTypeToStr(condDataType))); // context = new Context(context); Check((AstNode)node.GetChild(1), context); if (node.ChildCount == 3) Check((AstNode)node.GetChild(2), context); return DataType.Void; } case MathExprLexer.FOR: { context = new Context(context); CheckBlock((AstNode) node.GetChild(0), context); DataType condDataType = Check((AstNode)node.GetChild(1), context); if (condDataType != DataType.Bool) throw new ApplicationException(string.Format("In while condition type is {0}", dataTypeToStr(condDataType))); CheckBlock((AstNode)node.GetChild(2), context); Check((AstNode)node.GetChild(3), context); return DataType.Void; } default: { throw new ApplicationException("Unknown token type"); } break; } }
public static void ACTION( TokenRewriteStream tokens, CommonTree t ) { CommonTree parent = (CommonTree)t.Parent; int ptype = parent.Type; if ( ptype == ANTLRParser.SCOPE || // we have special rules for these ptype == ANTLRParser.AMPERSAND ) { return; } //Console.Out.WriteLine( "ACTION: " + t.Text ); CommonTree root = (CommonTree)t.GetAncestor( ANTLRParser.RULE ); if ( root != null ) { CommonTree rule = (CommonTree)root.GetChild( 0 ); //Console.Out.WriteLine( "rule: " + rule ); if ( Rule.GetRuleType( rule.Text ) == RuleType.Parser ) { tokens.Delete( t.TokenStartIndex, t.TokenStopIndex ); KillTrailingNewline( tokens, t.Token.TokenIndex ); } } }