Inheritance: Antlr.Runtime.ParserRuleReturnScope
Beispiel #1
0
    // $ANTLR start "expr"
    // H:\\Interp_CSharp\\Interp_CSharp\\Interp_CSharp\\Interp.g:53:1: expr returns [Element ret] : ( assignment | print );
    public InterpParser.expr_return expr() // throws RecognitionException [1]
    {   
        InterpParser.expr_return retval = new InterpParser.expr_return();
        retval.Start = input.LT(1);

        object root_0 = null;

        InterpParser.assignment_return assignment2 = null;

        InterpParser.print_return print3 = null;



        try {
        	dbg.EnterRule(GrammarFileName, "expr");
        	if ( RuleLevel==0 ) {dbg.Commence();}
        	IncRuleLevel();
        	dbg.Location(53, 1);

        try 
    	{
            // H:\\Interp_CSharp\\Interp_CSharp\\Interp_CSharp\\Interp.g:56:3: ( assignment | print )
            int alt2 = 2;
            try { dbg.EnterDecision(2);

            int LA2_0 = input.LA(1);

            if ( (LA2_0 == VARIABLE) )
            {
                alt2 = 1;
            }
            else if ( (LA2_0 == 11) )
            {
                alt2 = 2;
            }
            else 
            {
                NoViableAltException nvae_d2s0 =
                    new NoViableAltException("", 2, 0, input);

                dbg.RecognitionException(nvae_d2s0);
                throw nvae_d2s0;
            }
            } finally { dbg.ExitDecision(2); }

            switch (alt2) 
            {
                case 1 :
                    dbg.EnterAlt(1);

                    // H:\\Interp_CSharp\\Interp_CSharp\\Interp_CSharp\\Interp.g:56:5: assignment
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	dbg.Location(56,5);
                    	PushFollow(FOLLOW_assignment_in_expr115);
                    	assignment2 = assignment();
                    	state.followingStackPointer--;

                    	adaptor.AddChild(root_0, assignment2.Tree);
                    	dbg.Location(56,16);
                    	retval.ret = ((assignment2 != null) ? assignment2.ret : null);

                    }
                    break;
                case 2 :
                    dbg.EnterAlt(2);

                    // H:\\Interp_CSharp\\Interp_CSharp\\Interp_CSharp\\Interp.g:57:5: print
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	dbg.Location(57,5);
                    	PushFollow(FOLLOW_print_in_expr123);
                    	print3 = print();
                    	state.followingStackPointer--;

                    	adaptor.AddChild(root_0, print3.Tree);
                    	dbg.Location(57,11);
                    	 retval.ret = ((print3 != null) ? print3.ret : null); 

                    }
                    break;

            }
            retval.Stop = input.LT(-1);

            	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
        }
        dbg.Location(57, 39);

        }
        finally {
            dbg.ExitRule(GrammarFileName, "expr");
            DecRuleLevel();
            if ( RuleLevel==0 ) {dbg.Terminate();}
        }

        return retval;
    }
Beispiel #2
0
    // $ANTLR start "expr"
    // Interp.g:34:1: expr returns [Element ret] : ( assignment | structdec | structobjdec | print );
    public InterpParser.expr_return expr() // throws RecognitionException [1]
    {   
        InterpParser.expr_return retval = new InterpParser.expr_return();
        retval.Start = input.LT(1);

        object root_0 = null;

        InterpParser.assignment_return assignment2 = null;

        InterpParser.structdec_return structdec3 = null;

        InterpParser.structobjdec_return structobjdec4 = null;

        InterpParser.print_return print5 = null;



        try 
    	{
            // Interp.g:35:3: ( assignment | structdec | structobjdec | print )
            int alt2 = 4;
            switch ( input.LA(1) ) 
            {
            case VARIABLE:
            	{
                int LA2_1 = input.LA(2);

                if ( (LA2_1 == ASSIGNMENT || LA2_1 == 19) )
                {
                    alt2 = 1;
                }
                else if ( (LA2_1 == VARIABLE) )
                {
                    alt2 = 3;
                }
                else 
                {
                    NoViableAltException nvae_d2s1 =
                        new NoViableAltException("", 2, 1, input);

                    throw nvae_d2s1;
                }
                }
                break;
            case 16:
            	{
                alt2 = 2;
                }
                break;
            case 20:
            	{
                alt2 = 4;
                }
                break;
            	default:
            	    NoViableAltException nvae_d2s0 =
            	        new NoViableAltException("", 2, 0, input);

            	    throw nvae_d2s0;
            }

            switch (alt2) 
            {
                case 1 :
                    // Interp.g:35:5: assignment
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_assignment_in_expr92);
                    	assignment2 = assignment();
                    	state.followingStackPointer--;

                    	adaptor.AddChild(root_0, assignment2.Tree);
                    	retval.ret = ((assignment2 != null) ? assignment2.ret : null);

                    }
                    break;
                case 2 :
                    // Interp.g:36:5: structdec
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_structdec_in_expr100);
                    	structdec3 = structdec();
                    	state.followingStackPointer--;

                    	adaptor.AddChild(root_0, structdec3.Tree);
                    	retval.ret = ((structdec3 != null) ? structdec3.ret : null);

                    }
                    break;
                case 3 :
                    // Interp.g:37:5: structobjdec
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_structobjdec_in_expr108);
                    	structobjdec4 = structobjdec();
                    	state.followingStackPointer--;

                    	adaptor.AddChild(root_0, structobjdec4.Tree);
                    	 retval.ret = ((structobjdec4 != null) ? structobjdec4.ret : null);

                    }
                    break;
                case 4 :
                    // Interp.g:38:5: print
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_print_in_expr116);
                    	print5 = print();
                    	state.followingStackPointer--;

                    	adaptor.AddChild(root_0, print5.Tree);
                    	 retval.ret = ((print5 != null) ? print5.ret : null); 

                    }
                    break;

            }
            retval.Stop = input.LT(-1);

            	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
        }
        return retval;
    }
Beispiel #3
0
    // throws RecognitionException [1]
    // $ANTLR start "expr"
    // Interp.g:54:1: expr returns [Element ret] : ( assignment | print | parallel_for );
    public InterpParser.expr_return expr()
    {
        InterpParser.expr_return retval = new InterpParser.expr_return();
        retval.Start = input.LT(1);

        object root_0 = null;

        InterpParser.assignment_return assignment2 = null;

        InterpParser.print_return print3 = null;

        InterpParser.parallel_for_return parallel_for4 = null;

        try
        {
            // Interp.g:55:3: ( assignment | print | parallel_for )
            int alt2 = 3;
            switch ( input.LA(1) )
            {
            case VARIABLE:
                {
                alt2 = 1;
                }
                break;
            case 19:
                {
                alt2 = 2;
                }
                break;
            case 20:
                {
                alt2 = 3;
                }
                break;
                default:
                    NoViableAltException nvae_d2s0 =
                        new NoViableAltException("", 2, 0, input);

                    throw nvae_d2s0;
            }

            switch (alt2)
            {
                case 1 :
                    // Interp.g:55:5: assignment
                    {
                        root_0 = (object)adaptor.GetNilNode();

                        PushFollow(FOLLOW_assignment_in_expr105);
                        assignment2 = assignment();
                        state.followingStackPointer--;

                        adaptor.AddChild(root_0, assignment2.Tree);
                        retval.ret = ((assignment2 != null) ? assignment2.ret : null);

                    }
                    break;
                case 2 :
                    // Interp.g:56:5: print
                    {
                        root_0 = (object)adaptor.GetNilNode();

                        PushFollow(FOLLOW_print_in_expr113);
                        print3 = print();
                        state.followingStackPointer--;

                        adaptor.AddChild(root_0, print3.Tree);
                         retval.ret = ((print3 != null) ? print3.ret : null);

                    }
                    break;
                case 3 :
                    // Interp.g:57:5: parallel_for
                    {
                        root_0 = (object)adaptor.GetNilNode();

                        PushFollow(FOLLOW_parallel_for_in_expr121);
                        parallel_for4 = parallel_for();
                        state.followingStackPointer--;

                        adaptor.AddChild(root_0, parallel_for4.Tree);
                         retval.ret = ((parallel_for4 != null) ? parallel_for4.ret : null);

                    }
                    break;

            }
            retval.Stop = input.LT(-1);

                retval.Tree = (object)adaptor.RulePostProcessing(root_0);
                adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }

            catch (RecognitionException e) {
                throw e;
            }
        finally
        {
        }
        return retval;
    }
Beispiel #4
0
    // $ANTLR start "expr"
    // C:\\Documents and Settings\\Administrator\\Desktop\\SPINA\\Interp_CSharp\\Interp_CSharp\\Interp.g:34:1: expr returns [Element ret] : ( assignment | structdec | structobjdec | print );
    public InterpParser.expr_return expr() // throws RecognitionException [1]
    {   
        InterpParser.expr_return retval = new InterpParser.expr_return();
        retval.Start = input.LT(1);

        object root_0 = null;

        InterpParser.assignment_return assignment2 = null;

        InterpParser.structdec_return structdec3 = null;

        InterpParser.structobjdec_return structobjdec4 = null;

        InterpParser.print_return print5 = null;



        try {
        	dbg.EnterRule(GrammarFileName, "expr");
        	if ( RuleLevel==0 ) {dbg.Commence();}
        	IncRuleLevel();
        	dbg.Location(34, 1);

        try 
    	{
            // C:\\Documents and Settings\\Administrator\\Desktop\\SPINA\\Interp_CSharp\\Interp_CSharp\\Interp.g:35:3: ( assignment | structdec | structobjdec | print )
            int alt2 = 4;
            try { dbg.EnterDecision(2);

            switch ( input.LA(1) ) 
            {
            case VARIABLE:
            	{
                int LA2_1 = input.LA(2);

                if ( (LA2_1 == ASSIGNMENT || LA2_1 == 19) )
                {
                    alt2 = 1;
                }
                else if ( (LA2_1 == VARIABLE) )
                {
                    alt2 = 3;
                }
                else 
                {
                    NoViableAltException nvae_d2s1 =
                        new NoViableAltException("", 2, 1, input);

                    dbg.RecognitionException(nvae_d2s1);
                    throw nvae_d2s1;
                }
                }
                break;
            case 16:
            	{
                alt2 = 2;
                }
                break;
            case 20:
            	{
                alt2 = 4;
                }
                break;
            	default:
            	    NoViableAltException nvae_d2s0 =
            	        new NoViableAltException("", 2, 0, input);

            	    dbg.RecognitionException(nvae_d2s0);
            	    throw nvae_d2s0;
            }

            } finally { dbg.ExitDecision(2); }

            switch (alt2) 
            {
                case 1 :
                    dbg.EnterAlt(1);

                    // C:\\Documents and Settings\\Administrator\\Desktop\\SPINA\\Interp_CSharp\\Interp_CSharp\\Interp.g:35:5: assignment
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	dbg.Location(35,5);
                    	PushFollow(FOLLOW_assignment_in_expr92);
                    	assignment2 = assignment();
                    	state.followingStackPointer--;

                    	adaptor.AddChild(root_0, assignment2.Tree);
                    	dbg.Location(35,16);
                    	retval.ret = ((assignment2 != null) ? assignment2.ret : null);

                    }
                    break;
                case 2 :
                    dbg.EnterAlt(2);

                    // C:\\Documents and Settings\\Administrator\\Desktop\\SPINA\\Interp_CSharp\\Interp_CSharp\\Interp.g:36:5: structdec
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	dbg.Location(36,5);
                    	PushFollow(FOLLOW_structdec_in_expr100);
                    	structdec3 = structdec();
                    	state.followingStackPointer--;

                    	adaptor.AddChild(root_0, structdec3.Tree);
                    	dbg.Location(36,15);
                    	retval.ret = ((structdec3 != null) ? structdec3.ret : null);

                    }
                    break;
                case 3 :
                    dbg.EnterAlt(3);

                    // C:\\Documents and Settings\\Administrator\\Desktop\\SPINA\\Interp_CSharp\\Interp_CSharp\\Interp.g:37:5: structobjdec
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	dbg.Location(37,5);
                    	PushFollow(FOLLOW_structobjdec_in_expr108);
                    	structobjdec4 = structobjdec();
                    	state.followingStackPointer--;

                    	adaptor.AddChild(root_0, structobjdec4.Tree);
                    	dbg.Location(37,18);
                    	 retval.ret = ((structobjdec4 != null) ? structobjdec4.ret : null);

                    }
                    break;
                case 4 :
                    dbg.EnterAlt(4);

                    // C:\\Documents and Settings\\Administrator\\Desktop\\SPINA\\Interp_CSharp\\Interp_CSharp\\Interp.g:38:5: print
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	dbg.Location(38,5);
                    	PushFollow(FOLLOW_print_in_expr116);
                    	print5 = print();
                    	state.followingStackPointer--;

                    	adaptor.AddChild(root_0, print5.Tree);
                    	dbg.Location(38,11);
                    	 retval.ret = ((print5 != null) ? print5.ret : null); 

                    }
                    break;

            }
            retval.Stop = input.LT(-1);

            	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
        }
        dbg.Location(38, 39);

        }
        finally {
            dbg.ExitRule(GrammarFileName, "expr");
            DecRuleLevel();
            if ( RuleLevel==0 ) {dbg.Terminate();}
        }

        return retval;
    }
Beispiel #5
0
    // throws RecognitionException [1]
    // $ANTLR start "expr"
    // Interp.g:34:1: expr returns [Element ret] : ( assignment | scalarvardec | vectorvardec | matrixvardec | deletionofvar | structdec | structobjdec | print );
    public InterpParser.expr_return expr()
    {
        InterpParser.expr_return retval = new InterpParser.expr_return();
        retval.Start = input.LT(1);

        object root_0 = null;

        InterpParser.assignment_return assignment2 = null;

        InterpParser.scalarvardec_return scalarvardec3 = null;

        InterpParser.vectorvardec_return vectorvardec4 = null;

        InterpParser.matrixvardec_return matrixvardec5 = null;

        InterpParser.deletionofvar_return deletionofvar6 = null;

        InterpParser.structdec_return structdec7 = null;

        InterpParser.structobjdec_return structobjdec8 = null;

        InterpParser.print_return print9 = null;

        try
        {
            // Interp.g:35:3: ( assignment | scalarvardec | vectorvardec | matrixvardec | deletionofvar | structdec | structobjdec | print )
            int alt2 = 8;
            alt2 = dfa2.Predict(input);
            switch (alt2)
            {
                case 1 :
                    // Interp.g:35:5: assignment
                    {
                        root_0 = (object)adaptor.GetNilNode();

                        PushFollow(FOLLOW_assignment_in_expr92);
                        assignment2 = assignment();
                        state.followingStackPointer--;

                        adaptor.AddChild(root_0, assignment2.Tree);
                        retval.ret = ((assignment2 != null) ? assignment2.ret : null);

                    }
                    break;
                case 2 :
                    // Interp.g:36:5: scalarvardec
                    {
                        root_0 = (object)adaptor.GetNilNode();

                        PushFollow(FOLLOW_scalarvardec_in_expr100);
                        scalarvardec3 = scalarvardec();
                        state.followingStackPointer--;

                        adaptor.AddChild(root_0, scalarvardec3.Tree);
                         retval.ret = ((scalarvardec3 != null) ? scalarvardec3.ret : null);

                    }
                    break;
                case 3 :
                    // Interp.g:37:5: vectorvardec
                    {
                        root_0 = (object)adaptor.GetNilNode();

                        PushFollow(FOLLOW_vectorvardec_in_expr108);
                        vectorvardec4 = vectorvardec();
                        state.followingStackPointer--;

                        adaptor.AddChild(root_0, vectorvardec4.Tree);
                         retval.ret = ((vectorvardec4 != null) ? vectorvardec4.ret : null);

                    }
                    break;
                case 4 :
                    // Interp.g:38:5: matrixvardec
                    {
                        root_0 = (object)adaptor.GetNilNode();

                        PushFollow(FOLLOW_matrixvardec_in_expr116);
                        matrixvardec5 = matrixvardec();
                        state.followingStackPointer--;

                        adaptor.AddChild(root_0, matrixvardec5.Tree);
                         retval.ret = ((matrixvardec5 != null) ? matrixvardec5.ret : null);

                    }
                    break;
                case 5 :
                    // Interp.g:39:5: deletionofvar
                    {
                        root_0 = (object)adaptor.GetNilNode();

                        PushFollow(FOLLOW_deletionofvar_in_expr124);
                        deletionofvar6 = deletionofvar();
                        state.followingStackPointer--;

                        adaptor.AddChild(root_0, deletionofvar6.Tree);
                         retval.ret = ((deletionofvar6 != null) ? deletionofvar6.ret : null);

                    }
                    break;
                case 6 :
                    // Interp.g:40:5: structdec
                    {
                        root_0 = (object)adaptor.GetNilNode();

                        PushFollow(FOLLOW_structdec_in_expr132);
                        structdec7 = structdec();
                        state.followingStackPointer--;

                        adaptor.AddChild(root_0, structdec7.Tree);
                        retval.ret = ((structdec7 != null) ? structdec7.ret : null);

                    }
                    break;
                case 7 :
                    // Interp.g:41:5: structobjdec
                    {
                        root_0 = (object)adaptor.GetNilNode();

                        PushFollow(FOLLOW_structobjdec_in_expr140);
                        structobjdec8 = structobjdec();
                        state.followingStackPointer--;

                        adaptor.AddChild(root_0, structobjdec8.Tree);
                         retval.ret = ((structobjdec8 != null) ? structobjdec8.ret : null);

                    }
                    break;
                case 8 :
                    // Interp.g:42:5: print
                    {
                        root_0 = (object)adaptor.GetNilNode();

                        PushFollow(FOLLOW_print_in_expr148);
                        print9 = print();
                        state.followingStackPointer--;

                        adaptor.AddChild(root_0, print9.Tree);
                         retval.ret = ((print9 != null) ? print9.ret : null);

                    }
                    break;

            }
            retval.Stop = input.LT(-1);

                retval.Tree = (object)adaptor.RulePostProcessing(root_0);
                adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re)
        {
            ReportError(re);
            Recover(input,re);
        // Conversion of the second argument necessary, but harmless
        retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally
        {
        }
        return retval;
    }
Beispiel #6
0
    // $ANTLR start "expr"
    // Interp.g:53:1: expr returns [Element ret] : ( assignment | print );
    public InterpParser.expr_return expr() // throws RecognitionException [1]
    {   
        InterpParser.expr_return retval = new InterpParser.expr_return();
        retval.Start = input.LT(1);

        object root_0 = null;

        InterpParser.assignment_return assignment2 = null;

        InterpParser.print_return print3 = null;



        try 
    	{
            // Interp.g:56:3: ( assignment | print )
            int alt2 = 2;
            int LA2_0 = input.LA(1);

            if ( (LA2_0 == VARIABLE) )
            {
                alt2 = 1;
            }
            else if ( (LA2_0 == 13) )
            {
                alt2 = 2;
            }
            else 
            {
                NoViableAltException nvae_d2s0 =
                    new NoViableAltException("", 2, 0, input);

                throw nvae_d2s0;
            }
            switch (alt2) 
            {
                case 1 :
                    // Interp.g:56:5: assignment
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_assignment_in_expr115);
                    	assignment2 = assignment();
                    	state.followingStackPointer--;

                    	adaptor.AddChild(root_0, assignment2.Tree);
                    	retval.ret = ((assignment2 != null) ? assignment2.ret : null);

                    }
                    break;
                case 2 :
                    // Interp.g:57:5: print
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_print_in_expr123);
                    	print3 = print();
                    	state.followingStackPointer--;

                    	adaptor.AddChild(root_0, print3.Tree);
                    	 retval.ret = ((print3 != null) ? print3.ret : null); 

                    }
                    break;

            }
            retval.Stop = input.LT(-1);

            	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
        }
        return retval;
    }
    // throws RecognitionException [1]
    // $ANTLR start "expr"
    // Interp.g:35:1: expr returns [Element ret] : ( assignment | print | matdecelement | matmul | parallel );
    public InterpParser.expr_return expr()
    {
        InterpParser.expr_return retval = new InterpParser.expr_return();
        retval.Start = input.LT(1);

        object root_0 = null;

        InterpParser.assignment_return assignment2 = null;

        InterpParser.print_return print3 = null;

        InterpParser.matdecelement_return matdecelement4 = null;

        InterpParser.matmul_return matmul5 = null;

        InterpParser.parallel_return parallel6 = null;

        try
        {
            // Interp.g:36:3: ( assignment | print | matdecelement | matmul | parallel )
            int alt2 = 5;
            switch ( input.LA(1) )
            {
            case VARIABLE:
                {
                alt2 = 1;
                }
                break;
            case 18:
                {
                alt2 = 2;
                }
                break;
            case MATVAR:
                {
                int LA2_3 = input.LA(2);

                if ( (LA2_3 == MATVAL) )
                {
                    alt2 = 3;
                }
                else if ( (LA2_3 == ASSIGNMENT) )
                {
                    alt2 = 4;
                }
                else
                {
                    NoViableAltException nvae_d2s3 =
                        new NoViableAltException("", 2, 3, input);

                    throw nvae_d2s3;
                }
                }
                break;
            case PARALLEL:
                {
                alt2 = 5;
                }
                break;
                default:
                    NoViableAltException nvae_d2s0 =
                        new NoViableAltException("", 2, 0, input);

                    throw nvae_d2s0;
            }

            switch (alt2)
            {
                case 1 :
                    // Interp.g:36:5: assignment
                    {
                        root_0 = (object)adaptor.GetNilNode();

                        PushFollow(FOLLOW_assignment_in_expr93);
                        assignment2 = assignment();
                        state.followingStackPointer--;

                        adaptor.AddChild(root_0, assignment2.Tree);
                        retval.ret = ((assignment2 != null) ? assignment2.ret : null);

                    }
                    break;
                case 2 :
                    // Interp.g:37:5: print
                    {
                        root_0 = (object)adaptor.GetNilNode();

                        PushFollow(FOLLOW_print_in_expr101);
                        print3 = print();
                        state.followingStackPointer--;

                        adaptor.AddChild(root_0, print3.Tree);
                         retval.ret = ((print3 != null) ? print3.ret : null);

                    }
                    break;
                case 3 :
                    // Interp.g:38:5: matdecelement
                    {
                        root_0 = (object)adaptor.GetNilNode();

                        PushFollow(FOLLOW_matdecelement_in_expr109);
                        matdecelement4 = matdecelement();
                        state.followingStackPointer--;

                        adaptor.AddChild(root_0, matdecelement4.Tree);
                         retval.ret = ((matdecelement4 != null) ? matdecelement4.ret : null);

                    }
                    break;
                case 4 :
                    // Interp.g:39:5: matmul
                    {
                        root_0 = (object)adaptor.GetNilNode();

                        PushFollow(FOLLOW_matmul_in_expr119);
                        matmul5 = matmul();
                        state.followingStackPointer--;

                        adaptor.AddChild(root_0, matmul5.Tree);
                         retval.ret =  ((matmul5 != null) ? matmul5.ret : null);

                    }
                    break;
                case 5 :
                    // Interp.g:40:5: parallel
                    {
                        root_0 = (object)adaptor.GetNilNode();

                        PushFollow(FOLLOW_parallel_in_expr131);
                        parallel6 = parallel();
                        state.followingStackPointer--;

                        adaptor.AddChild(root_0, parallel6.Tree);
                         retval.ret = ((parallel6 != null) ? parallel6.ret : null);

                    }
                    break;

            }
            retval.Stop = input.LT(-1);

                retval.Tree = (object)adaptor.RulePostProcessing(root_0);
                adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re)
        {
            ReportError(re);
            Recover(input,re);
        // Conversion of the second argument necessary, but harmless
        retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally
        {
        }
        return retval;
    }