public void CheckRRNodeStreamBehaviourWhileEmpty2()
        {
            RewriteRuleNodeStream nodeTest = new RewriteRuleNodeStream(CreateTreeAdaptor(),
                                                                       "RewriteRuleNodeStream test");

            nodeTest.NextTree();
        }
        public void CheckRRNodeStreamBehaviourWithElements()
        {
            RewriteRuleNodeStream nodeTest = new RewriteRuleNodeStream(CreateTreeAdaptor(),
                                                                       "RewriteRuleNodeStream test");

            IToken token1 = CreateToken(1, "test token without any real context");
            ITree  tree1  = CreateTree(token1);

            // Test Add()
            nodeTest.Add(tree1);
            Assert.AreEqual(1, nodeTest.Size(), "nodeTest should have the size 1 (1).");
            Assert.IsTrue(nodeTest.HasNext(), "HasNext() should be true here (1).");

            // Test NextNode()
            CommonTree returnedTree = (CommonTree)nodeTest.NextNode();

            Assert.AreEqual(tree1.Type, returnedTree.Type,
                            "The returned tree should be equal to the given tree (1).");
            Assert.AreEqual(1, nodeTest.Size(), "nodeTest should have the size 1 (2).");
            Assert.IsFalse(nodeTest.HasNext(), "HasNext() should be false here (1).");
            nodeTest.Reset();
            Assert.AreEqual(1, nodeTest.Size(), "nodeTest should have the size 1 (3).");
            Assert.IsTrue(nodeTest.HasNext(), "HasNext() should be true here (2).");

            // Test NextTree()
            returnedTree = (CommonTree)nodeTest.NextTree();
            Assert.AreEqual(token1, returnedTree.Token,
                            "The returned token should be equal to the given token (3).");
            Assert.AreEqual(1, nodeTest.Size(), "nodeTest should have the size 1 (4).");
            Assert.IsFalse(nodeTest.HasNext(), "HasNext() should be false here (2).");
            nodeTest.Reset();
            Assert.AreEqual(1, nodeTest.Size(), "nodeTest should have the size 1 (5).");
            Assert.IsTrue(nodeTest.HasNext(), "HasNext() should be true here (3).");

            // Test, what happens with two elements
            IToken token2 = CreateToken(2, "test token without any real context");
            ITree  tree2  = CreateTree(token2);

            nodeTest.Add(tree2);
            Assert.AreEqual(2, nodeTest.Size(), "nodeTest should have the size 2 (1).");
            Assert.IsTrue(nodeTest.HasNext(), "HasNext() should be true here (4).");
            returnedTree = (CommonTree)nodeTest.NextTree();
            Assert.AreEqual(token1, returnedTree.Token,
                            "The returned token should be equal to the given token (4).");
            Assert.AreEqual(2, nodeTest.Size(), "nodeTest should have the size 2 (2).");
            Assert.IsTrue(nodeTest.HasNext(), "HasNext() should be true here (5).");
            returnedTree = (CommonTree)nodeTest.NextTree();
            Assert.AreEqual(token2, returnedTree.Token,
                            "The returned token should be equal to the given token (5).");
            Assert.IsFalse(nodeTest.HasNext(), "HasNext() should be false here (3).");

            // Test exception
            nodeTest.NextTree();
        }
        public void CheckRewriteRuleNodeStreamConstructors()
        {
            RewriteRuleNodeStream nodeTest1 = new RewriteRuleNodeStream(CreateTreeAdaptor(),
                                                                        "RewriteRuleNodeStream test1");

            RewriteRuleNodeStream nodeTest2 = new RewriteRuleNodeStream(CreateTreeAdaptor(),
                                                                        "RewriteRuleNodeStream test2", CreateToken(1,
                                                                                                                   "test token without any real context"));

            RewriteRuleNodeStream nodeTest3 = new RewriteRuleNodeStream(CreateTreeAdaptor(),
                                                                        "RewriteRuleNodeStream test3", CreateTokenList(4));
        }
        public void CheckRRNodeStreamBehaviourWhileEmpty1()
        {
            string description             = "RewriteRuleNodeStream test";
            RewriteRuleNodeStream nodeTest =
                new RewriteRuleNodeStream(CreateTreeAdaptor(), description);

            Assert.IsFalse(nodeTest.HasNext(), "HasNext() has to give back false here.");
            Assert.AreEqual(description.ToString(), nodeTest.Description,
                            "Description strings should be equal.");
            Assert.AreEqual(0, nodeTest.Size(), "The number of elements should be zero.");
            nodeTest.Reset();
            Assert.IsTrue(true, "Reset() shouldn't make any problems here.");
            Assert.AreEqual(0, nodeTest.Size(),
                            "The number of elements should be still zero.");
            nodeTest.NextNode();
        }
Example #5
0
    // $ANTLR start "assignments"
    // C:\\nadir\\nadir\\Nadir\\Parsing\\NadirASTOptimizer.g:100:1: assignments : ( ^(l= PlusEquals var= . value= . ) -> ^( Assignment[$l.Token] $var ^( Add[$l.Token] $var $value) ) | ^(l= MinusEquals var= . value= . ) -> ^( Assignment[$l.Token] $var ^( Subtract[$l.Token] $var $value) ) | ^(l= TimesEquals var= . value= . ) -> ^( Assignment[$l.Token] $var ^( Multiply[$l.Token] $var $value) ) | ^(l= DivideEquals var= . value= . ) -> ^( Assignment[$l.Token] $var ^( Divide[$l.Token] $var $value) ) | ^(l= ModEquals var= . value= . ) -> ^( Assignment[$l.Token] $var ^( Modulus[$l.Token] $var $value) ) );
    public NadirASTOptimizer.assignments_return assignments() // throws RecognitionException [1]
    {   
        NadirASTOptimizer.assignments_return retval = new NadirASTOptimizer.assignments_return();
        retval.Start = input.LT(1);

        NadirAST root_0 = null;

        NadirAST _first_0 = null;
        NadirAST _last = null;

        NadirAST l = null;
        NadirAST var = null;
        NadirAST value = null;

        NadirAST l_tree=null;
        NadirAST var_tree=null;
        NadirAST value_tree=null;
        RewriteRuleNodeStream stream_DivideEquals = new RewriteRuleNodeStream(adaptor,"token DivideEquals");
        RewriteRuleNodeStream stream_PlusEquals = new RewriteRuleNodeStream(adaptor,"token PlusEquals");
        RewriteRuleNodeStream stream_TimesEquals = new RewriteRuleNodeStream(adaptor,"token TimesEquals");
        RewriteRuleNodeStream stream_ModEquals = new RewriteRuleNodeStream(adaptor,"token ModEquals");
        RewriteRuleNodeStream stream_MinusEquals = new RewriteRuleNodeStream(adaptor,"token MinusEquals");

        try 
    	{
            // C:\\nadir\\nadir\\Nadir\\Parsing\\NadirASTOptimizer.g:101:3: ( ^(l= PlusEquals var= . value= . ) -> ^( Assignment[$l.Token] $var ^( Add[$l.Token] $var $value) ) | ^(l= MinusEquals var= . value= . ) -> ^( Assignment[$l.Token] $var ^( Subtract[$l.Token] $var $value) ) | ^(l= TimesEquals var= . value= . ) -> ^( Assignment[$l.Token] $var ^( Multiply[$l.Token] $var $value) ) | ^(l= DivideEquals var= . value= . ) -> ^( Assignment[$l.Token] $var ^( Divide[$l.Token] $var $value) ) | ^(l= ModEquals var= . value= . ) -> ^( Assignment[$l.Token] $var ^( Modulus[$l.Token] $var $value) ) )
            int alt16 = 5;
            switch ( input.LA(1) ) 
            {
            case PlusEquals:
            	{
                alt16 = 1;
                }
                break;
            case MinusEquals:
            	{
                alt16 = 2;
                }
                break;
            case TimesEquals:
            	{
                alt16 = 3;
                }
                break;
            case DivideEquals:
            	{
                alt16 = 4;
                }
                break;
            case ModEquals:
            	{
                alt16 = 5;
                }
                break;
            	default:
            	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            	    NoViableAltException nvae_d16s0 =
            	        new NoViableAltException("", 16, 0, input);

            	    throw nvae_d16s0;
            }

            switch (alt16) 
            {
                case 1 :
                    // C:\\nadir\\nadir\\Nadir\\Parsing\\NadirASTOptimizer.g:101:6: ^(l= PlusEquals var= . value= . )
                    {
                    	_last = (NadirAST)input.LT(1);
                    	{
                    	NadirAST _save_last_1 = _last;
                    	NadirAST _first_1 = null;
                    	_last = (NadirAST)input.LT(1);
                    	l=(NadirAST)Match(input,PlusEquals,FOLLOW_PlusEquals_in_assignments1549); if (state.failed) return retval; 
                    	if ( (state.backtracking == 1) ) stream_PlusEquals.Add(l);


                    	if ( (state.backtracking == 1) )
                    	if ( _first_0==null ) _first_0 = l;
                    	Match(input, Token.DOWN, null); if (state.failed) return retval;
                    	_last = (NadirAST)input.LT(1);
                    	var = (NadirAST)input.LT(1);
                    	MatchAny(input); if (state.failed) return retval;
                    	 
                    	if ( (state.backtracking == 1) )
                    	if ( _first_1==null ) _first_1 = var;
                    	_last = (NadirAST)input.LT(1);
                    	value = (NadirAST)input.LT(1);
                    	MatchAny(input); if (state.failed) return retval;
                    	 
                    	if ( (state.backtracking == 1) )
                    	if ( _first_1==null ) _first_1 = value;

                    	Match(input, Token.UP, null); if (state.failed) return retval;_last = _save_last_1;
                    	}



                    	// AST REWRITE
                    	// elements:          var, var, value
                    	// token labels:      
                    	// rule labels:       retval
                    	// token list labels: 
                    	// rule list labels:  
                    	// wildcard labels: var, value
                    	if ( (state.backtracking == 1) ) {
                    	retval.Tree = root_0;
                    	RewriteRuleSubtreeStream stream_var = new RewriteRuleSubtreeStream(adaptor,"wildcard var",var);
                    	RewriteRuleSubtreeStream stream_value = new RewriteRuleSubtreeStream(adaptor,"wildcard value",value);
                    	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

                    	root_0 = (NadirAST)adaptor.GetNilNode();
                    	// 101:37: -> ^( Assignment[$l.Token] $var ^( Add[$l.Token] $var $value) )
                    	{
                    	    // C:\\nadir\\nadir\\Nadir\\Parsing\\NadirASTOptimizer.g:101:40: ^( Assignment[$l.Token] $var ^( Add[$l.Token] $var $value) )
                    	    {
                    	    NadirAST root_1 = (NadirAST)adaptor.GetNilNode();
                    	    root_1 = (NadirAST)adaptor.BecomeRoot((NadirAST)adaptor.Create(Assignment, l.Token), root_1);

                    	    adaptor.AddChild(root_1, stream_var.NextTree());
                    	    // C:\\nadir\\nadir\\Nadir\\Parsing\\NadirASTOptimizer.g:101:68: ^( Add[$l.Token] $var $value)
                    	    {
                    	    NadirAST root_2 = (NadirAST)adaptor.GetNilNode();
                    	    root_2 = (NadirAST)adaptor.BecomeRoot((NadirAST)adaptor.Create(Add, l.Token), root_2);

                    	    adaptor.AddChild(root_2, stream_var.NextTree());
                    	    adaptor.AddChild(root_2, stream_value.NextTree());

                    	    adaptor.AddChild(root_1, root_2);
                    	    }

                    	    adaptor.AddChild(root_0, root_1);
                    	    }

                    	}

                    	retval.Tree = (NadirAST)adaptor.RulePostProcessing(root_0);
                    	input.ReplaceChildren(adaptor.GetParent(retval.Start),
                    	                      adaptor.GetChildIndex(retval.Start),
                    	                      adaptor.GetChildIndex(_last),
                    	                      retval.Tree);}
                    }
                    break;
                case 2 :
                    // C:\\nadir\\nadir\\Nadir\\Parsing\\NadirASTOptimizer.g:102:6: ^(l= MinusEquals var= . value= . )
                    {
                    	_last = (NadirAST)input.LT(1);
                    	{
                    	NadirAST _save_last_1 = _last;
                    	NadirAST _first_1 = null;
                    	_last = (NadirAST)input.LT(1);
                    	l=(NadirAST)Match(input,MinusEquals,FOLLOW_MinusEquals_in_assignments1590); if (state.failed) return retval; 
                    	if ( (state.backtracking == 1) ) stream_MinusEquals.Add(l);


                    	if ( (state.backtracking == 1) )
                    	if ( _first_0==null ) _first_0 = l;
                    	Match(input, Token.DOWN, null); if (state.failed) return retval;
                    	_last = (NadirAST)input.LT(1);
                    	var = (NadirAST)input.LT(1);
                    	MatchAny(input); if (state.failed) return retval;
                    	 
                    	if ( (state.backtracking == 1) )
                    	if ( _first_1==null ) _first_1 = var;
                    	_last = (NadirAST)input.LT(1);
                    	value = (NadirAST)input.LT(1);
                    	MatchAny(input); if (state.failed) return retval;
                    	 
                    	if ( (state.backtracking == 1) )
                    	if ( _first_1==null ) _first_1 = value;

                    	Match(input, Token.UP, null); if (state.failed) return retval;_last = _save_last_1;
                    	}



                    	// AST REWRITE
                    	// elements:          var, var, value
                    	// token labels:      
                    	// rule labels:       retval
                    	// token list labels: 
                    	// rule list labels:  
                    	// wildcard labels: var, value
                    	if ( (state.backtracking == 1) ) {
                    	retval.Tree = root_0;
                    	RewriteRuleSubtreeStream stream_var = new RewriteRuleSubtreeStream(adaptor,"wildcard var",var);
                    	RewriteRuleSubtreeStream stream_value = new RewriteRuleSubtreeStream(adaptor,"wildcard value",value);
                    	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

                    	root_0 = (NadirAST)adaptor.GetNilNode();
                    	// 102:38: -> ^( Assignment[$l.Token] $var ^( Subtract[$l.Token] $var $value) )
                    	{
                    	    // C:\\nadir\\nadir\\Nadir\\Parsing\\NadirASTOptimizer.g:102:41: ^( Assignment[$l.Token] $var ^( Subtract[$l.Token] $var $value) )
                    	    {
                    	    NadirAST root_1 = (NadirAST)adaptor.GetNilNode();
                    	    root_1 = (NadirAST)adaptor.BecomeRoot((NadirAST)adaptor.Create(Assignment, l.Token), root_1);

                    	    adaptor.AddChild(root_1, stream_var.NextTree());
                    	    // C:\\nadir\\nadir\\Nadir\\Parsing\\NadirASTOptimizer.g:102:69: ^( Subtract[$l.Token] $var $value)
                    	    {
                    	    NadirAST root_2 = (NadirAST)adaptor.GetNilNode();
                    	    root_2 = (NadirAST)adaptor.BecomeRoot((NadirAST)adaptor.Create(Subtract, l.Token), root_2);

                    	    adaptor.AddChild(root_2, stream_var.NextTree());
                    	    adaptor.AddChild(root_2, stream_value.NextTree());

                    	    adaptor.AddChild(root_1, root_2);
                    	    }

                    	    adaptor.AddChild(root_0, root_1);
                    	    }

                    	}

                    	retval.Tree = (NadirAST)adaptor.RulePostProcessing(root_0);
                    	input.ReplaceChildren(adaptor.GetParent(retval.Start),
                    	                      adaptor.GetChildIndex(retval.Start),
                    	                      adaptor.GetChildIndex(_last),
                    	                      retval.Tree);}
                    }
                    break;
                case 3 :
                    // C:\\nadir\\nadir\\Nadir\\Parsing\\NadirASTOptimizer.g:103:6: ^(l= TimesEquals var= . value= . )
                    {
                    	_last = (NadirAST)input.LT(1);
                    	{
                    	NadirAST _save_last_1 = _last;
                    	NadirAST _first_1 = null;
                    	_last = (NadirAST)input.LT(1);
                    	l=(NadirAST)Match(input,TimesEquals,FOLLOW_TimesEquals_in_assignments1631); if (state.failed) return retval; 
                    	if ( (state.backtracking == 1) ) stream_TimesEquals.Add(l);


                    	if ( (state.backtracking == 1) )
                    	if ( _first_0==null ) _first_0 = l;
                    	Match(input, Token.DOWN, null); if (state.failed) return retval;
                    	_last = (NadirAST)input.LT(1);
                    	var = (NadirAST)input.LT(1);
                    	MatchAny(input); if (state.failed) return retval;
                    	 
                    	if ( (state.backtracking == 1) )
                    	if ( _first_1==null ) _first_1 = var;
                    	_last = (NadirAST)input.LT(1);
                    	value = (NadirAST)input.LT(1);
                    	MatchAny(input); if (state.failed) return retval;
                    	 
                    	if ( (state.backtracking == 1) )
                    	if ( _first_1==null ) _first_1 = value;

                    	Match(input, Token.UP, null); if (state.failed) return retval;_last = _save_last_1;
                    	}



                    	// AST REWRITE
                    	// elements:          var, value, var
                    	// token labels:      
                    	// rule labels:       retval
                    	// token list labels: 
                    	// rule list labels:  
                    	// wildcard labels: var, value
                    	if ( (state.backtracking == 1) ) {
                    	retval.Tree = root_0;
                    	RewriteRuleSubtreeStream stream_var = new RewriteRuleSubtreeStream(adaptor,"wildcard var",var);
                    	RewriteRuleSubtreeStream stream_value = new RewriteRuleSubtreeStream(adaptor,"wildcard value",value);
                    	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

                    	root_0 = (NadirAST)adaptor.GetNilNode();
                    	// 103:38: -> ^( Assignment[$l.Token] $var ^( Multiply[$l.Token] $var $value) )
                    	{
                    	    // C:\\nadir\\nadir\\Nadir\\Parsing\\NadirASTOptimizer.g:103:41: ^( Assignment[$l.Token] $var ^( Multiply[$l.Token] $var $value) )
                    	    {
                    	    NadirAST root_1 = (NadirAST)adaptor.GetNilNode();
                    	    root_1 = (NadirAST)adaptor.BecomeRoot((NadirAST)adaptor.Create(Assignment, l.Token), root_1);

                    	    adaptor.AddChild(root_1, stream_var.NextTree());
                    	    // C:\\nadir\\nadir\\Nadir\\Parsing\\NadirASTOptimizer.g:103:69: ^( Multiply[$l.Token] $var $value)
                    	    {
                    	    NadirAST root_2 = (NadirAST)adaptor.GetNilNode();
                    	    root_2 = (NadirAST)adaptor.BecomeRoot((NadirAST)adaptor.Create(Multiply, l.Token), root_2);

                    	    adaptor.AddChild(root_2, stream_var.NextTree());
                    	    adaptor.AddChild(root_2, stream_value.NextTree());

                    	    adaptor.AddChild(root_1, root_2);
                    	    }

                    	    adaptor.AddChild(root_0, root_1);
                    	    }

                    	}

                    	retval.Tree = (NadirAST)adaptor.RulePostProcessing(root_0);
                    	input.ReplaceChildren(adaptor.GetParent(retval.Start),
                    	                      adaptor.GetChildIndex(retval.Start),
                    	                      adaptor.GetChildIndex(_last),
                    	                      retval.Tree);}
                    }
                    break;
                case 4 :
                    // C:\\nadir\\nadir\\Nadir\\Parsing\\NadirASTOptimizer.g:104:6: ^(l= DivideEquals var= . value= . )
                    {
                    	_last = (NadirAST)input.LT(1);
                    	{
                    	NadirAST _save_last_1 = _last;
                    	NadirAST _first_1 = null;
                    	_last = (NadirAST)input.LT(1);
                    	l=(NadirAST)Match(input,DivideEquals,FOLLOW_DivideEquals_in_assignments1672); if (state.failed) return retval; 
                    	if ( (state.backtracking == 1) ) stream_DivideEquals.Add(l);


                    	if ( (state.backtracking == 1) )
                    	if ( _first_0==null ) _first_0 = l;
                    	Match(input, Token.DOWN, null); if (state.failed) return retval;
                    	_last = (NadirAST)input.LT(1);
                    	var = (NadirAST)input.LT(1);
                    	MatchAny(input); if (state.failed) return retval;
                    	 
                    	if ( (state.backtracking == 1) )
                    	if ( _first_1==null ) _first_1 = var;
                    	_last = (NadirAST)input.LT(1);
                    	value = (NadirAST)input.LT(1);
                    	MatchAny(input); if (state.failed) return retval;
                    	 
                    	if ( (state.backtracking == 1) )
                    	if ( _first_1==null ) _first_1 = value;

                    	Match(input, Token.UP, null); if (state.failed) return retval;_last = _save_last_1;
                    	}



                    	// AST REWRITE
                    	// elements:          var, var, value
                    	// token labels:      
                    	// rule labels:       retval
                    	// token list labels: 
                    	// rule list labels:  
                    	// wildcard labels: var, value
                    	if ( (state.backtracking == 1) ) {
                    	retval.Tree = root_0;
                    	RewriteRuleSubtreeStream stream_var = new RewriteRuleSubtreeStream(adaptor,"wildcard var",var);
                    	RewriteRuleSubtreeStream stream_value = new RewriteRuleSubtreeStream(adaptor,"wildcard value",value);
                    	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

                    	root_0 = (NadirAST)adaptor.GetNilNode();
                    	// 104:39: -> ^( Assignment[$l.Token] $var ^( Divide[$l.Token] $var $value) )
                    	{
                    	    // C:\\nadir\\nadir\\Nadir\\Parsing\\NadirASTOptimizer.g:104:42: ^( Assignment[$l.Token] $var ^( Divide[$l.Token] $var $value) )
                    	    {
                    	    NadirAST root_1 = (NadirAST)adaptor.GetNilNode();
                    	    root_1 = (NadirAST)adaptor.BecomeRoot((NadirAST)adaptor.Create(Assignment, l.Token), root_1);

                    	    adaptor.AddChild(root_1, stream_var.NextTree());
                    	    // C:\\nadir\\nadir\\Nadir\\Parsing\\NadirASTOptimizer.g:104:70: ^( Divide[$l.Token] $var $value)
                    	    {
                    	    NadirAST root_2 = (NadirAST)adaptor.GetNilNode();
                    	    root_2 = (NadirAST)adaptor.BecomeRoot((NadirAST)adaptor.Create(Divide, l.Token), root_2);

                    	    adaptor.AddChild(root_2, stream_var.NextTree());
                    	    adaptor.AddChild(root_2, stream_value.NextTree());

                    	    adaptor.AddChild(root_1, root_2);
                    	    }

                    	    adaptor.AddChild(root_0, root_1);
                    	    }

                    	}

                    	retval.Tree = (NadirAST)adaptor.RulePostProcessing(root_0);
                    	input.ReplaceChildren(adaptor.GetParent(retval.Start),
                    	                      adaptor.GetChildIndex(retval.Start),
                    	                      adaptor.GetChildIndex(_last),
                    	                      retval.Tree);}
                    }
                    break;
                case 5 :
                    // C:\\nadir\\nadir\\Nadir\\Parsing\\NadirASTOptimizer.g:105:6: ^(l= ModEquals var= . value= . )
                    {
                    	_last = (NadirAST)input.LT(1);
                    	{
                    	NadirAST _save_last_1 = _last;
                    	NadirAST _first_1 = null;
                    	_last = (NadirAST)input.LT(1);
                    	l=(NadirAST)Match(input,ModEquals,FOLLOW_ModEquals_in_assignments1713); if (state.failed) return retval; 
                    	if ( (state.backtracking == 1) ) stream_ModEquals.Add(l);


                    	if ( (state.backtracking == 1) )
                    	if ( _first_0==null ) _first_0 = l;
                    	Match(input, Token.DOWN, null); if (state.failed) return retval;
                    	_last = (NadirAST)input.LT(1);
                    	var = (NadirAST)input.LT(1);
                    	MatchAny(input); if (state.failed) return retval;
                    	 
                    	if ( (state.backtracking == 1) )
                    	if ( _first_1==null ) _first_1 = var;
                    	_last = (NadirAST)input.LT(1);
                    	value = (NadirAST)input.LT(1);
                    	MatchAny(input); if (state.failed) return retval;
                    	 
                    	if ( (state.backtracking == 1) )
                    	if ( _first_1==null ) _first_1 = value;

                    	Match(input, Token.UP, null); if (state.failed) return retval;_last = _save_last_1;
                    	}



                    	// AST REWRITE
                    	// elements:          var, value, var
                    	// token labels:      
                    	// rule labels:       retval
                    	// token list labels: 
                    	// rule list labels:  
                    	// wildcard labels: var, value
                    	if ( (state.backtracking == 1) ) {
                    	retval.Tree = root_0;
                    	RewriteRuleSubtreeStream stream_var = new RewriteRuleSubtreeStream(adaptor,"wildcard var",var);
                    	RewriteRuleSubtreeStream stream_value = new RewriteRuleSubtreeStream(adaptor,"wildcard value",value);
                    	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

                    	root_0 = (NadirAST)adaptor.GetNilNode();
                    	// 105:36: -> ^( Assignment[$l.Token] $var ^( Modulus[$l.Token] $var $value) )
                    	{
                    	    // C:\\nadir\\nadir\\Nadir\\Parsing\\NadirASTOptimizer.g:105:39: ^( Assignment[$l.Token] $var ^( Modulus[$l.Token] $var $value) )
                    	    {
                    	    NadirAST root_1 = (NadirAST)adaptor.GetNilNode();
                    	    root_1 = (NadirAST)adaptor.BecomeRoot((NadirAST)adaptor.Create(Assignment, l.Token), root_1);

                    	    adaptor.AddChild(root_1, stream_var.NextTree());
                    	    // C:\\nadir\\nadir\\Nadir\\Parsing\\NadirASTOptimizer.g:105:67: ^( Modulus[$l.Token] $var $value)
                    	    {
                    	    NadirAST root_2 = (NadirAST)adaptor.GetNilNode();
                    	    root_2 = (NadirAST)adaptor.BecomeRoot((NadirAST)adaptor.Create(Modulus, l.Token), root_2);

                    	    adaptor.AddChild(root_2, stream_var.NextTree());
                    	    adaptor.AddChild(root_2, stream_value.NextTree());

                    	    adaptor.AddChild(root_1, root_2);
                    	    }

                    	    adaptor.AddChild(root_0, root_1);
                    	    }

                    	}

                    	retval.Tree = (NadirAST)adaptor.RulePostProcessing(root_0);
                    	input.ReplaceChildren(adaptor.GetParent(retval.Start),
                    	                      adaptor.GetChildIndex(retval.Start),
                    	                      adaptor.GetChildIndex(_last),
                    	                      retval.Tree);}
                    }
                    break;

            }
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return retval;
    }
Example #6
0
    // $ANTLR start "require"
    // C:\\nadir\\nadir\\Nadir\\Parsing\\NadirASTOptimizer.g:93:1: require : ( ^( Require ^( FunctionCall ^( Name ID {...}?) s= STRING ) ) -> ^( NoMatchClause $s) | ^( Require ^( FunctionCall ^( Name ID {...}?) s= STRING ) ) -> ^( MatchClause $s) | ^( Require ^( NoMatchClause (e= . )* ) ) -> ^( NoMatchClause ( $e)* ) | ^( Require ^( MatchClause (e= . )* ) ) -> ^( MatchClause ( $e)* ) );
    public NadirASTOptimizer.require_return require() // throws RecognitionException [1]
    {   
        NadirASTOptimizer.require_return retval = new NadirASTOptimizer.require_return();
        retval.Start = input.LT(1);

        NadirAST root_0 = null;

        NadirAST _first_0 = null;
        NadirAST _last = null;

        NadirAST s = null;
        NadirAST Require23 = null;
        NadirAST FunctionCall24 = null;
        NadirAST Name25 = null;
        NadirAST ID26 = null;
        NadirAST Require27 = null;
        NadirAST FunctionCall28 = null;
        NadirAST Name29 = null;
        NadirAST ID30 = null;
        NadirAST Require31 = null;
        NadirAST NoMatchClause32 = null;
        NadirAST Require33 = null;
        NadirAST MatchClause34 = null;
        NadirAST e = null;

        NadirAST s_tree=null;
        NadirAST Require23_tree=null;
        NadirAST FunctionCall24_tree=null;
        NadirAST Name25_tree=null;
        NadirAST ID26_tree=null;
        NadirAST Require27_tree=null;
        NadirAST FunctionCall28_tree=null;
        NadirAST Name29_tree=null;
        NadirAST ID30_tree=null;
        NadirAST Require31_tree=null;
        NadirAST NoMatchClause32_tree=null;
        NadirAST Require33_tree=null;
        NadirAST MatchClause34_tree=null;
        NadirAST e_tree=null;
        RewriteRuleNodeStream stream_Name = new RewriteRuleNodeStream(adaptor,"token Name");
        RewriteRuleNodeStream stream_NoMatchClause = new RewriteRuleNodeStream(adaptor,"token NoMatchClause");
        RewriteRuleNodeStream stream_Require = new RewriteRuleNodeStream(adaptor,"token Require");
        RewriteRuleNodeStream stream_ID = new RewriteRuleNodeStream(adaptor,"token ID");
        RewriteRuleNodeStream stream_MatchClause = new RewriteRuleNodeStream(adaptor,"token MatchClause");
        RewriteRuleNodeStream stream_FunctionCall = new RewriteRuleNodeStream(adaptor,"token FunctionCall");
        RewriteRuleNodeStream stream_STRING = new RewriteRuleNodeStream(adaptor,"token STRING");

        try 
    	{
            // C:\\nadir\\nadir\\Nadir\\Parsing\\NadirASTOptimizer.g:94:9: ( ^( Require ^( FunctionCall ^( Name ID {...}?) s= STRING ) ) -> ^( NoMatchClause $s) | ^( Require ^( FunctionCall ^( Name ID {...}?) s= STRING ) ) -> ^( MatchClause $s) | ^( Require ^( NoMatchClause (e= . )* ) ) -> ^( NoMatchClause ( $e)* ) | ^( Require ^( MatchClause (e= . )* ) ) -> ^( MatchClause ( $e)* ) )
            int alt15 = 4;
            alt15 = dfa15.Predict(input);
            switch (alt15) 
            {
                case 1 :
                    // C:\\nadir\\nadir\\Nadir\\Parsing\\NadirASTOptimizer.g:94:17: ^( Require ^( FunctionCall ^( Name ID {...}?) s= STRING ) )
                    {
                    	_last = (NadirAST)input.LT(1);
                    	{
                    	NadirAST _save_last_1 = _last;
                    	NadirAST _first_1 = null;
                    	_last = (NadirAST)input.LT(1);
                    	Require23=(NadirAST)Match(input,Require,FOLLOW_Require_in_require1263); if (state.failed) return retval; 
                    	if ( (state.backtracking == 1) ) stream_Require.Add(Require23);


                    	if ( (state.backtracking == 1) )
                    	if ( _first_0==null ) _first_0 = Require23;
                    	Match(input, Token.DOWN, null); if (state.failed) return retval;
                    	_last = (NadirAST)input.LT(1);
                    	{
                    	NadirAST _save_last_2 = _last;
                    	NadirAST _first_2 = null;
                    	_last = (NadirAST)input.LT(1);
                    	FunctionCall24=(NadirAST)Match(input,FunctionCall,FOLLOW_FunctionCall_in_require1266); if (state.failed) return retval; 
                    	if ( (state.backtracking == 1) ) stream_FunctionCall.Add(FunctionCall24);


                    	if ( (state.backtracking == 1) )
                    	if ( _first_1==null ) _first_1 = FunctionCall24;
                    	Match(input, Token.DOWN, null); if (state.failed) return retval;
                    	_last = (NadirAST)input.LT(1);
                    	{
                    	NadirAST _save_last_3 = _last;
                    	NadirAST _first_3 = null;
                    	_last = (NadirAST)input.LT(1);
                    	Name25=(NadirAST)Match(input,Name,FOLLOW_Name_in_require1269); if (state.failed) return retval; 
                    	if ( (state.backtracking == 1) ) stream_Name.Add(Name25);


                    	if ( (state.backtracking == 1) )
                    	if ( _first_2==null ) _first_2 = Name25;
                    	Match(input, Token.DOWN, null); if (state.failed) return retval;
                    	_last = (NadirAST)input.LT(1);
                    	ID26=(NadirAST)Match(input,ID,FOLLOW_ID_in_require1271); if (state.failed) return retval; 
                    	if ( (state.backtracking == 1) ) stream_ID.Add(ID26);

                    	if ( !((ID26.Text=="nomatchregex")) ) 
                    	{
                    	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
                    	    throw new FailedPredicateException(input, "require", "$ID.Text==\"nomatchregex\"");
                    	}

                    	Match(input, Token.UP, null); if (state.failed) return retval;_last = _save_last_3;
                    	}

                    	_last = (NadirAST)input.LT(1);
                    	s=(NadirAST)Match(input,STRING,FOLLOW_STRING_in_require1278); if (state.failed) return retval; 
                    	if ( (state.backtracking == 1) ) stream_STRING.Add(s);


                    	Match(input, Token.UP, null); if (state.failed) return retval;_last = _save_last_2;
                    	}


                    	Match(input, Token.UP, null); if (state.failed) return retval;_last = _save_last_1;
                    	}



                    	// AST REWRITE
                    	// elements:          s
                    	// token labels:      s
                    	// rule labels:       retval
                    	// token list labels: 
                    	// rule list labels:  
                    	// wildcard labels: 
                    	if ( (state.backtracking == 1) ) {
                    	retval.Tree = root_0;
                    	RewriteRuleNodeStream stream_s = new RewriteRuleNodeStream(adaptor, "token s", s);
                    	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

                    	root_0 = (NadirAST)adaptor.GetNilNode();
                    	// 94:97: -> ^( NoMatchClause $s)
                    	{
                    	    // C:\\nadir\\nadir\\Nadir\\Parsing\\NadirASTOptimizer.g:94:100: ^( NoMatchClause $s)
                    	    {
                    	    NadirAST root_1 = (NadirAST)adaptor.GetNilNode();
                    	    root_1 = (NadirAST)adaptor.BecomeRoot((NadirAST)adaptor.Create(NoMatchClause, "NoMatchClause"), root_1);

                    	    adaptor.AddChild(root_1, stream_s.NextNode());

                    	    adaptor.AddChild(root_0, root_1);
                    	    }

                    	}

                    	retval.Tree = (NadirAST)adaptor.RulePostProcessing(root_0);
                    	input.ReplaceChildren(adaptor.GetParent(retval.Start),
                    	                      adaptor.GetChildIndex(retval.Start),
                    	                      adaptor.GetChildIndex(_last),
                    	                      retval.Tree);}
                    }
                    break;
                case 2 :
                    // C:\\nadir\\nadir\\Nadir\\Parsing\\NadirASTOptimizer.g:95:17: ^( Require ^( FunctionCall ^( Name ID {...}?) s= STRING ) )
                    {
                    	_last = (NadirAST)input.LT(1);
                    	{
                    	NadirAST _save_last_1 = _last;
                    	NadirAST _first_1 = null;
                    	_last = (NadirAST)input.LT(1);
                    	Require27=(NadirAST)Match(input,Require,FOLLOW_Require_in_require1313); if (state.failed) return retval; 
                    	if ( (state.backtracking == 1) ) stream_Require.Add(Require27);


                    	if ( (state.backtracking == 1) )
                    	if ( _first_0==null ) _first_0 = Require27;
                    	Match(input, Token.DOWN, null); if (state.failed) return retval;
                    	_last = (NadirAST)input.LT(1);
                    	{
                    	NadirAST _save_last_2 = _last;
                    	NadirAST _first_2 = null;
                    	_last = (NadirAST)input.LT(1);
                    	FunctionCall28=(NadirAST)Match(input,FunctionCall,FOLLOW_FunctionCall_in_require1316); if (state.failed) return retval; 
                    	if ( (state.backtracking == 1) ) stream_FunctionCall.Add(FunctionCall28);


                    	if ( (state.backtracking == 1) )
                    	if ( _first_1==null ) _first_1 = FunctionCall28;
                    	Match(input, Token.DOWN, null); if (state.failed) return retval;
                    	_last = (NadirAST)input.LT(1);
                    	{
                    	NadirAST _save_last_3 = _last;
                    	NadirAST _first_3 = null;
                    	_last = (NadirAST)input.LT(1);
                    	Name29=(NadirAST)Match(input,Name,FOLLOW_Name_in_require1319); if (state.failed) return retval; 
                    	if ( (state.backtracking == 1) ) stream_Name.Add(Name29);


                    	if ( (state.backtracking == 1) )
                    	if ( _first_2==null ) _first_2 = Name29;
                    	Match(input, Token.DOWN, null); if (state.failed) return retval;
                    	_last = (NadirAST)input.LT(1);
                    	ID30=(NadirAST)Match(input,ID,FOLLOW_ID_in_require1321); if (state.failed) return retval; 
                    	if ( (state.backtracking == 1) ) stream_ID.Add(ID30);

                    	if ( !((ID30.Text=="matchregex")) ) 
                    	{
                    	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
                    	    throw new FailedPredicateException(input, "require", "$ID.Text==\"matchregex\"");
                    	}

                    	Match(input, Token.UP, null); if (state.failed) return retval;_last = _save_last_3;
                    	}

                    	_last = (NadirAST)input.LT(1);
                    	s=(NadirAST)Match(input,STRING,FOLLOW_STRING_in_require1330); if (state.failed) return retval; 
                    	if ( (state.backtracking == 1) ) stream_STRING.Add(s);


                    	Match(input, Token.UP, null); if (state.failed) return retval;_last = _save_last_2;
                    	}


                    	Match(input, Token.UP, null); if (state.failed) return retval;_last = _save_last_1;
                    	}



                    	// AST REWRITE
                    	// elements:          s
                    	// token labels:      s
                    	// rule labels:       retval
                    	// token list labels: 
                    	// rule list labels:  
                    	// wildcard labels: 
                    	if ( (state.backtracking == 1) ) {
                    	retval.Tree = root_0;
                    	RewriteRuleNodeStream stream_s = new RewriteRuleNodeStream(adaptor, "token s", s);
                    	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

                    	root_0 = (NadirAST)adaptor.GetNilNode();
                    	// 95:97: -> ^( MatchClause $s)
                    	{
                    	    // C:\\nadir\\nadir\\Nadir\\Parsing\\NadirASTOptimizer.g:95:100: ^( MatchClause $s)
                    	    {
                    	    NadirAST root_1 = (NadirAST)adaptor.GetNilNode();
                    	    root_1 = (NadirAST)adaptor.BecomeRoot((NadirAST)adaptor.Create(MatchClause, "MatchClause"), root_1);

                    	    adaptor.AddChild(root_1, stream_s.NextNode());

                    	    adaptor.AddChild(root_0, root_1);
                    	    }

                    	}

                    	retval.Tree = (NadirAST)adaptor.RulePostProcessing(root_0);
                    	input.ReplaceChildren(adaptor.GetParent(retval.Start),
                    	                      adaptor.GetChildIndex(retval.Start),
                    	                      adaptor.GetChildIndex(_last),
                    	                      retval.Tree);}
                    }
                    break;
                case 3 :
                    // C:\\nadir\\nadir\\Nadir\\Parsing\\NadirASTOptimizer.g:96:17: ^( Require ^( NoMatchClause (e= . )* ) )
                    {
                    	_last = (NadirAST)input.LT(1);
                    	{
                    	NadirAST _save_last_1 = _last;
                    	NadirAST _first_1 = null;
                    	_last = (NadirAST)input.LT(1);
                    	Require31=(NadirAST)Match(input,Require,FOLLOW_Require_in_require1369); if (state.failed) return retval; 
                    	if ( (state.backtracking == 1) ) stream_Require.Add(Require31);


                    	if ( (state.backtracking == 1) )
                    	if ( _first_0==null ) _first_0 = Require31;
                    	Match(input, Token.DOWN, null); if (state.failed) return retval;
                    	_last = (NadirAST)input.LT(1);
                    	{
                    	NadirAST _save_last_2 = _last;
                    	NadirAST _first_2 = null;
                    	_last = (NadirAST)input.LT(1);
                    	NoMatchClause32=(NadirAST)Match(input,NoMatchClause,FOLLOW_NoMatchClause_in_require1372); if (state.failed) return retval; 
                    	if ( (state.backtracking == 1) ) stream_NoMatchClause.Add(NoMatchClause32);


                    	if ( (state.backtracking == 1) )
                    	if ( _first_1==null ) _first_1 = NoMatchClause32;
                    	if ( input.LA(1) == Token.DOWN )
                    	{
                    	    Match(input, Token.DOWN, null); if (state.failed) return retval;
                    	    // C:\\nadir\\nadir\\Nadir\\Parsing\\NadirASTOptimizer.g:96:44: (e= . )*
                    	    do 
                    	    {
                    	        int alt13 = 2;
                    	        int LA13_0 = input.LA(1);

                    	        if ( ((LA13_0 >= TokenFirst && LA13_0 <= 250)) )
                    	        {
                    	            alt13 = 1;
                    	        }


                    	        switch (alt13) 
                    	    	{
                    	    		case 1 :
                    	    		    // C:\\nadir\\nadir\\Nadir\\Parsing\\NadirASTOptimizer.g:0:0: e= .
                    	    		    {
                    	    		    	_last = (NadirAST)input.LT(1);
                    	    		    	e = (NadirAST)input.LT(1);
                    	    		    	MatchAny(input); if (state.failed) return retval;
                    	    		    	 
                    	    		    	if ( (state.backtracking == 1) )
                    	    		    	if ( _first_2==null ) _first_2 = e;

                    	    		    	if ( (state.backtracking == 1) ) {
                    	    		    	retval.Tree = (NadirAST)_first_0;
                    	    		    	if ( adaptor.GetParent(retval.Tree)!=null && adaptor.IsNil( adaptor.GetParent(retval.Tree) ) )
                    	    		    	    retval.Tree = (NadirAST)adaptor.GetParent(retval.Tree);}
                    	    		    }
                    	    		    break;

                    	    		default:
                    	    		    goto loop13;
                    	        }
                    	    } while (true);

                    	    loop13:
                    	    	;	// Stops C# compiler whining that label 'loop13' has no statements


                    	    Match(input, Token.UP, null); if (state.failed) return retval;
                    	}_last = _save_last_2;
                    	}


                    	Match(input, Token.UP, null); if (state.failed) return retval;_last = _save_last_1;
                    	}



                    	// AST REWRITE
                    	// elements:          NoMatchClause, e
                    	// token labels:      
                    	// rule labels:       retval
                    	// token list labels: 
                    	// rule list labels:  
                    	// wildcard labels: e
                    	if ( (state.backtracking == 1) ) {
                    	retval.Tree = root_0;
                    	RewriteRuleSubtreeStream stream_e = new RewriteRuleSubtreeStream(adaptor,"wildcard e",e);
                    	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

                    	root_0 = (NadirAST)adaptor.GetNilNode();
                    	// 96:97: -> ^( NoMatchClause ( $e)* )
                    	{
                    	    // C:\\nadir\\nadir\\Nadir\\Parsing\\NadirASTOptimizer.g:96:100: ^( NoMatchClause ( $e)* )
                    	    {
                    	    NadirAST root_1 = (NadirAST)adaptor.GetNilNode();
                    	    root_1 = (NadirAST)adaptor.BecomeRoot(stream_NoMatchClause.NextNode(), root_1);

                    	    // C:\\nadir\\nadir\\Nadir\\Parsing\\NadirASTOptimizer.g:96:116: ( $e)*
                    	    while ( stream_e.HasNext() )
                    	    {
                    	        adaptor.AddChild(root_1, stream_e.NextTree());

                    	    }
                    	    stream_e.Reset();

                    	    adaptor.AddChild(root_0, root_1);
                    	    }

                    	}

                    	retval.Tree = (NadirAST)adaptor.RulePostProcessing(root_0);
                    	input.ReplaceChildren(adaptor.GetParent(retval.Start),
                    	                      adaptor.GetChildIndex(retval.Start),
                    	                      adaptor.GetChildIndex(_last),
                    	                      retval.Tree);}
                    }
                    break;
                case 4 :
                    // C:\\nadir\\nadir\\Nadir\\Parsing\\NadirASTOptimizer.g:97:17: ^( Require ^( MatchClause (e= . )* ) )
                    {
                    	_last = (NadirAST)input.LT(1);
                    	{
                    	NadirAST _save_last_1 = _last;
                    	NadirAST _first_1 = null;
                    	_last = (NadirAST)input.LT(1);
                    	Require33=(NadirAST)Match(input,Require,FOLLOW_Require_in_require1455); if (state.failed) return retval; 
                    	if ( (state.backtracking == 1) ) stream_Require.Add(Require33);


                    	if ( (state.backtracking == 1) )
                    	if ( _first_0==null ) _first_0 = Require33;
                    	Match(input, Token.DOWN, null); if (state.failed) return retval;
                    	_last = (NadirAST)input.LT(1);
                    	{
                    	NadirAST _save_last_2 = _last;
                    	NadirAST _first_2 = null;
                    	_last = (NadirAST)input.LT(1);
                    	MatchClause34=(NadirAST)Match(input,MatchClause,FOLLOW_MatchClause_in_require1458); if (state.failed) return retval; 
                    	if ( (state.backtracking == 1) ) stream_MatchClause.Add(MatchClause34);


                    	if ( (state.backtracking == 1) )
                    	if ( _first_1==null ) _first_1 = MatchClause34;
                    	if ( input.LA(1) == Token.DOWN )
                    	{
                    	    Match(input, Token.DOWN, null); if (state.failed) return retval;
                    	    // C:\\nadir\\nadir\\Nadir\\Parsing\\NadirASTOptimizer.g:97:42: (e= . )*
                    	    do 
                    	    {
                    	        int alt14 = 2;
                    	        int LA14_0 = input.LA(1);

                    	        if ( ((LA14_0 >= TokenFirst && LA14_0 <= 250)) )
                    	        {
                    	            alt14 = 1;
                    	        }


                    	        switch (alt14) 
                    	    	{
                    	    		case 1 :
                    	    		    // C:\\nadir\\nadir\\Nadir\\Parsing\\NadirASTOptimizer.g:0:0: e= .
                    	    		    {
                    	    		    	_last = (NadirAST)input.LT(1);
                    	    		    	e = (NadirAST)input.LT(1);
                    	    		    	MatchAny(input); if (state.failed) return retval;
                    	    		    	 
                    	    		    	if ( (state.backtracking == 1) )
                    	    		    	if ( _first_2==null ) _first_2 = e;

                    	    		    	if ( (state.backtracking == 1) ) {
                    	    		    	retval.Tree = (NadirAST)_first_0;
                    	    		    	if ( adaptor.GetParent(retval.Tree)!=null && adaptor.IsNil( adaptor.GetParent(retval.Tree) ) )
                    	    		    	    retval.Tree = (NadirAST)adaptor.GetParent(retval.Tree);}
                    	    		    }
                    	    		    break;

                    	    		default:
                    	    		    goto loop14;
                    	        }
                    	    } while (true);

                    	    loop14:
                    	    	;	// Stops C# compiler whining that label 'loop14' has no statements


                    	    Match(input, Token.UP, null); if (state.failed) return retval;
                    	}_last = _save_last_2;
                    	}


                    	Match(input, Token.UP, null); if (state.failed) return retval;_last = _save_last_1;
                    	}



                    	// AST REWRITE
                    	// elements:          e, MatchClause
                    	// token labels:      
                    	// rule labels:       retval
                    	// token list labels: 
                    	// rule list labels:  
                    	// wildcard labels: e
                    	if ( (state.backtracking == 1) ) {
                    	retval.Tree = root_0;
                    	RewriteRuleSubtreeStream stream_e = new RewriteRuleSubtreeStream(adaptor,"wildcard e",e);
                    	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

                    	root_0 = (NadirAST)adaptor.GetNilNode();
                    	// 97:97: -> ^( MatchClause ( $e)* )
                    	{
                    	    // C:\\nadir\\nadir\\Nadir\\Parsing\\NadirASTOptimizer.g:97:100: ^( MatchClause ( $e)* )
                    	    {
                    	    NadirAST root_1 = (NadirAST)adaptor.GetNilNode();
                    	    root_1 = (NadirAST)adaptor.BecomeRoot(stream_MatchClause.NextNode(), root_1);

                    	    // C:\\nadir\\nadir\\Nadir\\Parsing\\NadirASTOptimizer.g:97:116: ( $e)*
                    	    while ( stream_e.HasNext() )
                    	    {
                    	        adaptor.AddChild(root_1, stream_e.NextTree());

                    	    }
                    	    stream_e.Reset();

                    	    adaptor.AddChild(root_0, root_1);
                    	    }

                    	}

                    	retval.Tree = (NadirAST)adaptor.RulePostProcessing(root_0);
                    	input.ReplaceChildren(adaptor.GetParent(retval.Start),
                    	                      adaptor.GetChildIndex(retval.Start),
                    	                      adaptor.GetChildIndex(_last),
                    	                      retval.Tree);}
                    }
                    break;

            }
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return retval;
    }
Example #7
0
    // $ANTLR start "expandMatch"
    // C:\\nadir\\nadir\\Nadir\\Parsing\\NadirASTOptimizer.g:87:1: expandMatch : ( ^( FunctionCall ^( Name id= ID {...}?) s= STRING ) -> ^( FunctionCall ^( Name ID[$id.Token, \"nomatchregex\"] ) ) | ^( FunctionCall ^( Name id= ID {...}?) s= STRING ) -> ^( FunctionCall ^( Name ID[$id.Token, \"matchregex\"] ) ) | ^( FunctionCall ^( Name id= ID {...}?) s= STRING ) -> ^( FunctionCall ^( Name ID[$id.Token, \"matchcountregex\"] ) ) );
    public NadirASTOptimizer.expandMatch_return expandMatch() // throws RecognitionException [1]
    {   
        NadirASTOptimizer.expandMatch_return retval = new NadirASTOptimizer.expandMatch_return();
        retval.Start = input.LT(1);

        NadirAST root_0 = null;

        NadirAST _first_0 = null;
        NadirAST _last = null;

        NadirAST id = null;
        NadirAST s = null;
        NadirAST FunctionCall17 = null;
        NadirAST Name18 = null;
        NadirAST FunctionCall19 = null;
        NadirAST Name20 = null;
        NadirAST FunctionCall21 = null;
        NadirAST Name22 = null;

        NadirAST id_tree=null;
        NadirAST s_tree=null;
        NadirAST FunctionCall17_tree=null;
        NadirAST Name18_tree=null;
        NadirAST FunctionCall19_tree=null;
        NadirAST Name20_tree=null;
        NadirAST FunctionCall21_tree=null;
        NadirAST Name22_tree=null;
        RewriteRuleNodeStream stream_Name = new RewriteRuleNodeStream(adaptor,"token Name");
        RewriteRuleNodeStream stream_ID = new RewriteRuleNodeStream(adaptor,"token ID");
        RewriteRuleNodeStream stream_FunctionCall = new RewriteRuleNodeStream(adaptor,"token FunctionCall");
        RewriteRuleNodeStream stream_STRING = new RewriteRuleNodeStream(adaptor,"token STRING");

        try 
    	{
            // C:\\nadir\\nadir\\Nadir\\Parsing\\NadirASTOptimizer.g:88:9: ( ^( FunctionCall ^( Name id= ID {...}?) s= STRING ) -> ^( FunctionCall ^( Name ID[$id.Token, \"nomatchregex\"] ) ) | ^( FunctionCall ^( Name id= ID {...}?) s= STRING ) -> ^( FunctionCall ^( Name ID[$id.Token, \"matchregex\"] ) ) | ^( FunctionCall ^( Name id= ID {...}?) s= STRING ) -> ^( FunctionCall ^( Name ID[$id.Token, \"matchcountregex\"] ) ) )
            int alt12 = 3;
            alt12 = dfa12.Predict(input);
            switch (alt12) 
            {
                case 1 :
                    // C:\\nadir\\nadir\\Nadir\\Parsing\\NadirASTOptimizer.g:88:17: ^( FunctionCall ^( Name id= ID {...}?) s= STRING )
                    {
                    	_last = (NadirAST)input.LT(1);
                    	{
                    	NadirAST _save_last_1 = _last;
                    	NadirAST _first_1 = null;
                    	_last = (NadirAST)input.LT(1);
                    	FunctionCall17=(NadirAST)Match(input,FunctionCall,FOLLOW_FunctionCall_in_expandMatch1081); if (state.failed) return retval; 
                    	if ( (state.backtracking == 1) ) stream_FunctionCall.Add(FunctionCall17);


                    	if ( (state.backtracking == 1) )
                    	if ( _first_0==null ) _first_0 = FunctionCall17;
                    	Match(input, Token.DOWN, null); if (state.failed) return retval;
                    	_last = (NadirAST)input.LT(1);
                    	{
                    	NadirAST _save_last_2 = _last;
                    	NadirAST _first_2 = null;
                    	_last = (NadirAST)input.LT(1);
                    	Name18=(NadirAST)Match(input,Name,FOLLOW_Name_in_expandMatch1084); if (state.failed) return retval; 
                    	if ( (state.backtracking == 1) ) stream_Name.Add(Name18);


                    	if ( (state.backtracking == 1) )
                    	if ( _first_1==null ) _first_1 = Name18;
                    	Match(input, Token.DOWN, null); if (state.failed) return retval;
                    	_last = (NadirAST)input.LT(1);
                    	id=(NadirAST)Match(input,ID,FOLLOW_ID_in_expandMatch1088); if (state.failed) return retval; 
                    	if ( (state.backtracking == 1) ) stream_ID.Add(id);

                    	if ( !((id.Text=="nomatch")) ) 
                    	{
                    	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
                    	    throw new FailedPredicateException(input, "expandMatch", "$ID.Text==\"nomatch\"");
                    	}

                    	Match(input, Token.UP, null); if (state.failed) return retval;_last = _save_last_2;
                    	}

                    	_last = (NadirAST)input.LT(1);
                    	s=(NadirAST)Match(input,STRING,FOLLOW_STRING_in_expandMatch1099); if (state.failed) return retval; 
                    	if ( (state.backtracking == 1) ) stream_STRING.Add(s);


                    	Match(input, Token.UP, null); if (state.failed) return retval;_last = _save_last_1;
                    	}



                    	// AST REWRITE
                    	// elements:          FunctionCall, ID, Name
                    	// token labels:      
                    	// rule labels:       retval
                    	// token list labels: 
                    	// rule list labels:  
                    	// wildcard labels: 
                    	if ( (state.backtracking == 1) ) {
                    	retval.Tree = root_0;
                    	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

                    	root_0 = (NadirAST)adaptor.GetNilNode();
                    	// 88:83: -> ^( FunctionCall ^( Name ID[$id.Token, \"nomatchregex\"] ) )
                    	{
                    	    // C:\\nadir\\nadir\\Nadir\\Parsing\\NadirASTOptimizer.g:88:86: ^( FunctionCall ^( Name ID[$id.Token, \"nomatchregex\"] ) )
                    	    {
                    	    NadirAST root_1 = (NadirAST)adaptor.GetNilNode();
                    	    root_1 = (NadirAST)adaptor.BecomeRoot(stream_FunctionCall.NextNode(), root_1);

                    	    // C:\\nadir\\nadir\\Nadir\\Parsing\\NadirASTOptimizer.g:88:101: ^( Name ID[$id.Token, \"nomatchregex\"] )
                    	    {
                    	    NadirAST root_2 = (NadirAST)adaptor.GetNilNode();
                    	    root_2 = (NadirAST)adaptor.BecomeRoot(stream_Name.NextNode(), root_2);

                    	    adaptor.AddChild(root_2, (NadirAST)adaptor.Create(ID, id.Token, "nomatchregex"));

                    	    adaptor.AddChild(root_1, root_2);
                    	    }
                    	    adaptor.AddChild(root_1, ExpandNucleotidePatternsInRegEx(s));

                    	    adaptor.AddChild(root_0, root_1);
                    	    }

                    	}

                    	retval.Tree = (NadirAST)adaptor.RulePostProcessing(root_0);
                    	input.ReplaceChildren(adaptor.GetParent(retval.Start),
                    	                      adaptor.GetChildIndex(retval.Start),
                    	                      adaptor.GetChildIndex(_last),
                    	                      retval.Tree);}
                    }
                    break;
                case 2 :
                    // C:\\nadir\\nadir\\Nadir\\Parsing\\NadirASTOptimizer.g:89:17: ^( FunctionCall ^( Name id= ID {...}?) s= STRING )
                    {
                    	_last = (NadirAST)input.LT(1);
                    	{
                    	NadirAST _save_last_1 = _last;
                    	NadirAST _first_1 = null;
                    	_last = (NadirAST)input.LT(1);
                    	FunctionCall19=(NadirAST)Match(input,FunctionCall,FOLLOW_FunctionCall_in_expandMatch1138); if (state.failed) return retval; 
                    	if ( (state.backtracking == 1) ) stream_FunctionCall.Add(FunctionCall19);


                    	if ( (state.backtracking == 1) )
                    	if ( _first_0==null ) _first_0 = FunctionCall19;
                    	Match(input, Token.DOWN, null); if (state.failed) return retval;
                    	_last = (NadirAST)input.LT(1);
                    	{
                    	NadirAST _save_last_2 = _last;
                    	NadirAST _first_2 = null;
                    	_last = (NadirAST)input.LT(1);
                    	Name20=(NadirAST)Match(input,Name,FOLLOW_Name_in_expandMatch1141); if (state.failed) return retval; 
                    	if ( (state.backtracking == 1) ) stream_Name.Add(Name20);


                    	if ( (state.backtracking == 1) )
                    	if ( _first_1==null ) _first_1 = Name20;
                    	Match(input, Token.DOWN, null); if (state.failed) return retval;
                    	_last = (NadirAST)input.LT(1);
                    	id=(NadirAST)Match(input,ID,FOLLOW_ID_in_expandMatch1145); if (state.failed) return retval; 
                    	if ( (state.backtracking == 1) ) stream_ID.Add(id);

                    	if ( !((id.Text=="match")) ) 
                    	{
                    	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
                    	    throw new FailedPredicateException(input, "expandMatch", "$ID.Text==\"match\"");
                    	}

                    	Match(input, Token.UP, null); if (state.failed) return retval;_last = _save_last_2;
                    	}

                    	_last = (NadirAST)input.LT(1);
                    	s=(NadirAST)Match(input,STRING,FOLLOW_STRING_in_expandMatch1158); if (state.failed) return retval; 
                    	if ( (state.backtracking == 1) ) stream_STRING.Add(s);


                    	Match(input, Token.UP, null); if (state.failed) return retval;_last = _save_last_1;
                    	}



                    	// AST REWRITE
                    	// elements:          FunctionCall, ID, Name
                    	// token labels:      
                    	// rule labels:       retval
                    	// token list labels: 
                    	// rule list labels:  
                    	// wildcard labels: 
                    	if ( (state.backtracking == 1) ) {
                    	retval.Tree = root_0;
                    	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

                    	root_0 = (NadirAST)adaptor.GetNilNode();
                    	// 89:83: -> ^( FunctionCall ^( Name ID[$id.Token, \"matchregex\"] ) )
                    	{
                    	    // C:\\nadir\\nadir\\Nadir\\Parsing\\NadirASTOptimizer.g:89:86: ^( FunctionCall ^( Name ID[$id.Token, \"matchregex\"] ) )
                    	    {
                    	    NadirAST root_1 = (NadirAST)adaptor.GetNilNode();
                    	    root_1 = (NadirAST)adaptor.BecomeRoot(stream_FunctionCall.NextNode(), root_1);

                    	    // C:\\nadir\\nadir\\Nadir\\Parsing\\NadirASTOptimizer.g:89:101: ^( Name ID[$id.Token, \"matchregex\"] )
                    	    {
                    	    NadirAST root_2 = (NadirAST)adaptor.GetNilNode();
                    	    root_2 = (NadirAST)adaptor.BecomeRoot(stream_Name.NextNode(), root_2);

                    	    adaptor.AddChild(root_2, (NadirAST)adaptor.Create(ID, id.Token, "matchregex"));

                    	    adaptor.AddChild(root_1, root_2);
                    	    }
                    	    adaptor.AddChild(root_1, ExpandNucleotidePatternsInRegEx(s));

                    	    adaptor.AddChild(root_0, root_1);
                    	    }

                    	}

                    	retval.Tree = (NadirAST)adaptor.RulePostProcessing(root_0);
                    	input.ReplaceChildren(adaptor.GetParent(retval.Start),
                    	                      adaptor.GetChildIndex(retval.Start),
                    	                      adaptor.GetChildIndex(_last),
                    	                      retval.Tree);}
                    }
                    break;
                case 3 :
                    // C:\\nadir\\nadir\\Nadir\\Parsing\\NadirASTOptimizer.g:90:17: ^( FunctionCall ^( Name id= ID {...}?) s= STRING )
                    {
                    	_last = (NadirAST)input.LT(1);
                    	{
                    	NadirAST _save_last_1 = _last;
                    	NadirAST _first_1 = null;
                    	_last = (NadirAST)input.LT(1);
                    	FunctionCall21=(NadirAST)Match(input,FunctionCall,FOLLOW_FunctionCall_in_expandMatch1199); if (state.failed) return retval; 
                    	if ( (state.backtracking == 1) ) stream_FunctionCall.Add(FunctionCall21);


                    	if ( (state.backtracking == 1) )
                    	if ( _first_0==null ) _first_0 = FunctionCall21;
                    	Match(input, Token.DOWN, null); if (state.failed) return retval;
                    	_last = (NadirAST)input.LT(1);
                    	{
                    	NadirAST _save_last_2 = _last;
                    	NadirAST _first_2 = null;
                    	_last = (NadirAST)input.LT(1);
                    	Name22=(NadirAST)Match(input,Name,FOLLOW_Name_in_expandMatch1202); if (state.failed) return retval; 
                    	if ( (state.backtracking == 1) ) stream_Name.Add(Name22);


                    	if ( (state.backtracking == 1) )
                    	if ( _first_1==null ) _first_1 = Name22;
                    	Match(input, Token.DOWN, null); if (state.failed) return retval;
                    	_last = (NadirAST)input.LT(1);
                    	id=(NadirAST)Match(input,ID,FOLLOW_ID_in_expandMatch1206); if (state.failed) return retval; 
                    	if ( (state.backtracking == 1) ) stream_ID.Add(id);

                    	if ( !((id.Text=="matchcount")) ) 
                    	{
                    	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
                    	    throw new FailedPredicateException(input, "expandMatch", "$ID.Text==\"matchcount\"");
                    	}

                    	Match(input, Token.UP, null); if (state.failed) return retval;_last = _save_last_2;
                    	}

                    	_last = (NadirAST)input.LT(1);
                    	s=(NadirAST)Match(input,STRING,FOLLOW_STRING_in_expandMatch1214); if (state.failed) return retval; 
                    	if ( (state.backtracking == 1) ) stream_STRING.Add(s);


                    	Match(input, Token.UP, null); if (state.failed) return retval;_last = _save_last_1;
                    	}



                    	// AST REWRITE
                    	// elements:          Name, ID, FunctionCall
                    	// token labels:      
                    	// rule labels:       retval
                    	// token list labels: 
                    	// rule list labels:  
                    	// wildcard labels: 
                    	if ( (state.backtracking == 1) ) {
                    	retval.Tree = root_0;
                    	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

                    	root_0 = (NadirAST)adaptor.GetNilNode();
                    	// 90:83: -> ^( FunctionCall ^( Name ID[$id.Token, \"matchcountregex\"] ) )
                    	{
                    	    // C:\\nadir\\nadir\\Nadir\\Parsing\\NadirASTOptimizer.g:90:86: ^( FunctionCall ^( Name ID[$id.Token, \"matchcountregex\"] ) )
                    	    {
                    	    NadirAST root_1 = (NadirAST)adaptor.GetNilNode();
                    	    root_1 = (NadirAST)adaptor.BecomeRoot(stream_FunctionCall.NextNode(), root_1);

                    	    // C:\\nadir\\nadir\\Nadir\\Parsing\\NadirASTOptimizer.g:90:101: ^( Name ID[$id.Token, \"matchcountregex\"] )
                    	    {
                    	    NadirAST root_2 = (NadirAST)adaptor.GetNilNode();
                    	    root_2 = (NadirAST)adaptor.BecomeRoot(stream_Name.NextNode(), root_2);

                    	    adaptor.AddChild(root_2, (NadirAST)adaptor.Create(ID, id.Token, "matchcountregex"));

                    	    adaptor.AddChild(root_1, root_2);
                    	    }
                    	    adaptor.AddChild(root_1, ExpandNucleotidePatternsInRegEx(s));

                    	    adaptor.AddChild(root_0, root_1);
                    	    }

                    	}

                    	retval.Tree = (NadirAST)adaptor.RulePostProcessing(root_0);
                    	input.ReplaceChildren(adaptor.GetParent(retval.Start),
                    	                      adaptor.GetChildIndex(retval.Start),
                    	                      adaptor.GetChildIndex(_last),
                    	                      retval.Tree);}
                    }
                    break;

            }
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return retval;
    }
Example #8
0
    // $ANTLR start "concat"
    // C:\\nadir\\nadir\\Nadir\\Parsing\\NadirASTOptimizer.g:83:1: concat : ^(head= Concat {...}? (e+= . )* ) -> ( $e)* ;
    public NadirASTOptimizer.concat_return concat() // throws RecognitionException [1]
    {   
        NadirASTOptimizer.concat_return retval = new NadirASTOptimizer.concat_return();
        retval.Start = input.LT(1);

        NadirAST root_0 = null;

        NadirAST _first_0 = null;
        NadirAST _last = null;

        NadirAST head = null;
        NadirAST e = null;
        IList list_e = null;

        NadirAST head_tree=null;
        NadirAST e_tree=null;
        RewriteRuleNodeStream stream_Concat = new RewriteRuleNodeStream(adaptor,"token Concat");

        try 
    	{
            // C:\\nadir\\nadir\\Nadir\\Parsing\\NadirASTOptimizer.g:84:9: ( ^(head= Concat {...}? (e+= . )* ) -> ( $e)* )
            // C:\\nadir\\nadir\\Nadir\\Parsing\\NadirASTOptimizer.g:84:17: ^(head= Concat {...}? (e+= . )* )
            {
            	_last = (NadirAST)input.LT(1);
            	{
            	NadirAST _save_last_1 = _last;
            	NadirAST _first_1 = null;
            	_last = (NadirAST)input.LT(1);
            	head=(NadirAST)Match(input,Concat,FOLLOW_Concat_in_concat1001); if (state.failed) return retval; 
            	if ( (state.backtracking == 1) ) stream_Concat.Add(head);


            	if ( (state.backtracking == 1) )
            	if ( _first_0==null ) _first_0 = head;
            	if ( input.LA(1) == Token.DOWN )
            	{
            	    Match(input, Token.DOWN, null); if (state.failed) return retval;
            	    if ( !(( ParentIsOfType(head, Concat) || DegenerateNumberOfChildren(head) )) ) 
            	    {
            	        if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            	        throw new FailedPredicateException(input, "concat", " ParentIsOfType($head, Concat) || DegenerateNumberOfChildren($head) ");
            	    }
            	    // C:\\nadir\\nadir\\Nadir\\Parsing\\NadirASTOptimizer.g:84:122: (e+= . )*
            	    do 
            	    {
            	        int alt11 = 2;
            	        int LA11_0 = input.LA(1);

            	        if ( ((LA11_0 >= TokenFirst && LA11_0 <= 250)) )
            	        {
            	            alt11 = 1;
            	        }


            	        switch (alt11) 
            	    	{
            	    		case 1 :
            	    		    // C:\\nadir\\nadir\\Nadir\\Parsing\\NadirASTOptimizer.g:0:0: e+= .
            	    		    {
            	    		    	_last = (NadirAST)input.LT(1);
            	    		    	e = (NadirAST)input.LT(1);
            	    		    	MatchAny(input); if (state.failed) return retval;
            	    		    	 
            	    		    	if ( (state.backtracking == 1) )
            	    		    	if ( _first_1==null ) _first_1 = e;
            	    		    	if (list_e == null) list_e = new ArrayList();
            	    		    	list_e.Add(e);


            	    		    	if ( (state.backtracking == 1) ) {
            	    		    	retval.Tree = (NadirAST)_first_0;
            	    		    	if ( adaptor.GetParent(retval.Tree)!=null && adaptor.IsNil( adaptor.GetParent(retval.Tree) ) )
            	    		    	    retval.Tree = (NadirAST)adaptor.GetParent(retval.Tree);}
            	    		    }
            	    		    break;

            	    		default:
            	    		    goto loop11;
            	        }
            	    } while (true);

            	    loop11:
            	    	;	// Stops C# compiler whining that label 'loop11' has no statements


            	    Match(input, Token.UP, null); if (state.failed) return retval;
            	}_last = _save_last_1;
            	}



            	// AST REWRITE
            	// elements:          e
            	// token labels:      
            	// rule labels:       retval
            	// token list labels: 
            	// rule list labels:  
            	// wildcard labels: e
            	if ( (state.backtracking == 1) ) {
            	retval.Tree = root_0;
            	RewriteRuleSubtreeStream stream_e = new RewriteRuleSubtreeStream(adaptor,"wildcard e",list_e);
            	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

            	root_0 = (NadirAST)adaptor.GetNilNode();
            	// 84:129: -> ( $e)*
            	{
            	    // C:\\nadir\\nadir\\Nadir\\Parsing\\NadirASTOptimizer.g:84:132: ( $e)*
            	    while ( stream_e.HasNext() )
            	    {
            	        adaptor.AddChild(root_0, stream_e.NextTree());

            	    }
            	    stream_e.Reset();

            	}

            	retval.Tree = (NadirAST)adaptor.RulePostProcessing(root_0);
            	input.ReplaceChildren(adaptor.GetParent(retval.Start),
            	                      adaptor.GetChildIndex(retval.Start),
            	                      adaptor.GetChildIndex(_last),
            	                      retval.Tree);}
            }

        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return retval;
    }
Example #9
0
    // $ANTLR start "doubleComplement"
    // C:\\nadir\\nadir\\Nadir\\Parsing\\NadirASTOptimizer.g:52:1: doubleComplement : ^( Complement ^( Complement e= . ) ) -> $e;
    public NadirASTOptimizer.doubleComplement_return doubleComplement() // throws RecognitionException [1]
    {   
        NadirASTOptimizer.doubleComplement_return retval = new NadirASTOptimizer.doubleComplement_return();
        retval.Start = input.LT(1);

        NadirAST root_0 = null;

        NadirAST _first_0 = null;
        NadirAST _last = null;

        NadirAST Complement15 = null;
        NadirAST Complement16 = null;
        NadirAST e = null;

        NadirAST Complement15_tree=null;
        NadirAST Complement16_tree=null;
        NadirAST e_tree=null;
        RewriteRuleNodeStream stream_Complement = new RewriteRuleNodeStream(adaptor,"token Complement");

        try 
    	{
            // C:\\nadir\\nadir\\Nadir\\Parsing\\NadirASTOptimizer.g:53:9: ( ^( Complement ^( Complement e= . ) ) -> $e)
            // C:\\nadir\\nadir\\Nadir\\Parsing\\NadirASTOptimizer.g:53:17: ^( Complement ^( Complement e= . ) )
            {
            	_last = (NadirAST)input.LT(1);
            	{
            	NadirAST _save_last_1 = _last;
            	NadirAST _first_1 = null;
            	_last = (NadirAST)input.LT(1);
            	Complement15=(NadirAST)Match(input,Complement,FOLLOW_Complement_in_doubleComplement305); if (state.failed) return retval; 
            	if ( (state.backtracking == 1) ) stream_Complement.Add(Complement15);


            	if ( (state.backtracking == 1) )
            	if ( _first_0==null ) _first_0 = Complement15;
            	Match(input, Token.DOWN, null); if (state.failed) return retval;
            	_last = (NadirAST)input.LT(1);
            	{
            	NadirAST _save_last_2 = _last;
            	NadirAST _first_2 = null;
            	_last = (NadirAST)input.LT(1);
            	Complement16=(NadirAST)Match(input,Complement,FOLLOW_Complement_in_doubleComplement308); if (state.failed) return retval; 
            	if ( (state.backtracking == 1) ) stream_Complement.Add(Complement16);


            	if ( (state.backtracking == 1) )
            	if ( _first_1==null ) _first_1 = Complement16;
            	Match(input, Token.DOWN, null); if (state.failed) return retval;
            	_last = (NadirAST)input.LT(1);
            	e = (NadirAST)input.LT(1);
            	MatchAny(input); if (state.failed) return retval;
            	 
            	if ( (state.backtracking == 1) )
            	if ( _first_2==null ) _first_2 = e;

            	Match(input, Token.UP, null); if (state.failed) return retval;_last = _save_last_2;
            	}


            	Match(input, Token.UP, null); if (state.failed) return retval;_last = _save_last_1;
            	}



            	// AST REWRITE
            	// elements:          e
            	// token labels:      
            	// rule labels:       retval
            	// token list labels: 
            	// rule list labels:  
            	// wildcard labels: e
            	if ( (state.backtracking == 1) ) {
            	retval.Tree = root_0;
            	RewriteRuleSubtreeStream stream_e = new RewriteRuleSubtreeStream(adaptor,"wildcard e",e);
            	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

            	root_0 = (NadirAST)adaptor.GetNilNode();
            	// 53:121: -> $e
            	{
            	    adaptor.AddChild(root_0, stream_e.NextTree());

            	}

            	retval.Tree = (NadirAST)adaptor.RulePostProcessing(root_0);
            	input.ReplaceChildren(adaptor.GetParent(retval.Start),
            	                      adaptor.GetChildIndex(retval.Start),
            	                      adaptor.GetChildIndex(_last),
            	                      retval.Tree);}
            }

        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return retval;
    }