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);
        }
Пример #2
0
        public void testSingleNode()
        {
            CommonTree t = new CommonTree(new CommonToken(101));

            Assert.IsNull(t.parent);
            Assert.AreEqual(-1, t.childIndex);
        }
Пример #3
0
 // 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);
 }
Пример #4
0
        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);
        }
Пример #5
0
        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);
        }
Пример #6
0
 // 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);
        }
Пример #10
0
        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);
        }
Пример #11
0
        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);
        }
Пример #12
0
        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);
        }
Пример #13
0
        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);
        }
Пример #14
0
        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);
        }
Пример #15
0
        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);
        }
Пример #16
0
        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);
        }
Пример #17
0
 /**
  * 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);
     }
 }
Пример #18
0
        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
        }
Пример #19
0
        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);
        }
Пример #20
0
        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);
        }
Пример #21
0
        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);
        }
Пример #22
0
        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);
        }
Пример #23
0
        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);
        }
Пример #24
0
        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);
        }
Пример #25
0
        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);
        }
Пример #26
0
        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);
        }
Пример #27
0
        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);
        }
Пример #28
0
        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());
        }
Пример #29
0
        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);
        }
Пример #30
0
        /// <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;
                }
                }
            }
        }
Пример #31
0
        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());
        }
Пример #32
0
        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);
        }
Пример #33
0
		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);
		}
Пример #34
0
		/// <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);
		}
Пример #35
0
		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);
		}
Пример #36
0
		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);
		}
Пример #37
0
		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);
		}
Пример #38
0
        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 );
            } );
        }
Пример #39
0
        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();
        }
Пример #40
0
		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);
		}
Пример #41
0
 public void testSingleNode()
 {
     CommonTree t = new CommonTree(new CommonToken(101));
     Assert.IsNull(t.parent);
     Assert.AreEqual(-1, t.childIndex);
 }
Пример #42
0
        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();
        }
Пример #43
0
 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);
 }
Пример #44
0
        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();
        }
Пример #45
0
        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();
        }
Пример #46
0
        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();
        }
Пример #47
0
        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);
        }
Пример #48
0
		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);
		}
Пример #49
0
		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);
		}
Пример #50
0
		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());
		}
Пример #51
0
		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);
		}
Пример #52
0
        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();
        }
Пример #53
0
		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);
		}
Пример #54
0
		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);
		}
Пример #55
0
		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);
			}
		}
Пример #56
0
		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);
		}
Пример #57
0
		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);
		}
Пример #58
0
		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);
		}
Пример #59
0
        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;
            }
        }
Пример #60
0
 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 );
         }
     }
 }