Inheritance: Antlr.Runtime.ParserRuleReturnScope
Beispiel #1
0
    // $ANTLR start "var_or_int_literal"
    // Interp.g:53:1: var_or_int_literal returns [Element ret] : ( variable | int_literal ) ;
    public InterpParser.var_or_int_literal_return var_or_int_literal() // throws RecognitionException [1]
    {   
        InterpParser.var_or_int_literal_return retval = new InterpParser.var_or_int_literal_return();
        retval.Start = input.LT(1);

        object root_0 = null;

        InterpParser.variable_return variable14 = null;

        InterpParser.int_literal_return int_literal15 = null;



        try 
    	{
            // Interp.g:54:3: ( ( variable | int_literal ) )
            // Interp.g:54:6: ( variable | int_literal )
            {
            	root_0 = (object)adaptor.GetNilNode();

            	// Interp.g:54:6: ( variable | int_literal )
            	int alt5 = 2;
            	int LA5_0 = input.LA(1);

            	if ( (LA5_0 == VARIABLE) )
            	{
            	    alt5 = 1;
            	}
            	else if ( (LA5_0 == INT_LITERAL) )
            	{
            	    alt5 = 2;
            	}
            	else 
            	{
            	    NoViableAltException nvae_d5s0 =
            	        new NoViableAltException("", 5, 0, input);

            	    throw nvae_d5s0;
            	}
            	switch (alt5) 
            	{
            	    case 1 :
            	        // Interp.g:54:7: variable
            	        {
            	        	PushFollow(FOLLOW_variable_in_var_or_int_literal218);
            	        	variable14 = variable();
            	        	state.followingStackPointer--;

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

            	        }
            	        break;
            	    case 2 :
            	        // Interp.g:55:7: int_literal
            	        {
            	        	PushFollow(FOLLOW_int_literal_in_var_or_int_literal229);
            	        	int_literal15 = int_literal();
            	        	state.followingStackPointer--;

            	        	adaptor.AddChild(root_0, int_literal15.Tree);
            	        	retval.ret = ((int_literal15 != null) ? int_literal15.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 #2
0
    // throws RecognitionException [1]
    // $ANTLR start "var_or_int_literal"
    // Interp.g:74:1: var_or_int_literal returns [Element ret] : ( variable | int_literal ) ;
    public InterpParser.var_or_int_literal_return var_or_int_literal()
    {
        InterpParser.var_or_int_literal_return retval = new InterpParser.var_or_int_literal_return();
        retval.Start = input.LT(1);

        object root_0 = null;

        InterpParser.variable_return variable12 = null;

        InterpParser.int_literal_return int_literal13 = null;

        try
        {
            // Interp.g:75:3: ( ( variable | int_literal ) )
            // Interp.g:75:6: ( variable | int_literal )
            {
                root_0 = (object)adaptor.GetNilNode();

                // Interp.g:75:6: ( variable | int_literal )
                int alt4 = 2;
                int LA4_0 = input.LA(1);

                if ( (LA4_0 == VARIABLE) )
                {
                    alt4 = 1;
                }
                else if ( (LA4_0 == INT_LITERAL) )
                {
                    alt4 = 2;
                }
                else
                {
                    NoViableAltException nvae_d4s0 =
                        new NoViableAltException("", 4, 0, input);

                    throw nvae_d4s0;
                }
                switch (alt4)
                {
                    case 1 :
                        // Interp.g:75:7: variable
                        {
                            PushFollow(FOLLOW_variable_in_var_or_int_literal220);
                            variable12 = variable();
                            state.followingStackPointer--;

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

                        }
                        break;
                    case 2 :
                        // Interp.g:76:7: int_literal
                        {
                            PushFollow(FOLLOW_int_literal_in_var_or_int_literal231);
                            int_literal13 = int_literal();
                            state.followingStackPointer--;

                            adaptor.AddChild(root_0, int_literal13.Tree);
                            retval.ret = ((int_literal13 != null) ? int_literal13.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 #3
0
    // $ANTLR start "var_or_int_literal"
    // H:\\Interp_CSharp\\Interp_CSharp\\Interp_CSharp\\Interp.g:83:1: var_or_int_literal returns [Element ret] : ( variable | int_literal ) ;
    public InterpParser.var_or_int_literal_return var_or_int_literal() // throws RecognitionException [1]
    {   
        InterpParser.var_or_int_literal_return retval = new InterpParser.var_or_int_literal_return();
        retval.Start = input.LT(1);

        object root_0 = null;

        InterpParser.variable_return variable9 = null;

        InterpParser.int_literal_return int_literal10 = null;



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

        try 
    	{
            // H:\\Interp_CSharp\\Interp_CSharp\\Interp_CSharp\\Interp.g:85:3: ( ( variable | int_literal ) )
            dbg.EnterAlt(1);

            // H:\\Interp_CSharp\\Interp_CSharp\\Interp_CSharp\\Interp.g:85:6: ( variable | int_literal )
            {
            	root_0 = (object)adaptor.GetNilNode();

            	dbg.Location(85,6);
            	// H:\\Interp_CSharp\\Interp_CSharp\\Interp_CSharp\\Interp.g:85:6: ( variable | int_literal )
            	int alt4 = 2;
            	try { dbg.EnterSubRule(4);
            	try { dbg.EnterDecision(4);

            	int LA4_0 = input.LA(1);

            	if ( (LA4_0 == VARIABLE) )
            	{
            	    alt4 = 1;
            	}
            	else if ( (LA4_0 == INT_LITERAL) )
            	{
            	    alt4 = 2;
            	}
            	else 
            	{
            	    NoViableAltException nvae_d4s0 =
            	        new NoViableAltException("", 4, 0, input);

            	    dbg.RecognitionException(nvae_d4s0);
            	    throw nvae_d4s0;
            	}
            	} finally { dbg.ExitDecision(4); }

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

            	        // H:\\Interp_CSharp\\Interp_CSharp\\Interp_CSharp\\Interp.g:85:7: variable
            	        {
            	        	dbg.Location(85,7);
            	        	PushFollow(FOLLOW_variable_in_var_or_int_literal214);
            	        	variable9 = variable();
            	        	state.followingStackPointer--;

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

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

            	        // H:\\Interp_CSharp\\Interp_CSharp\\Interp_CSharp\\Interp.g:87:4: int_literal
            	        {
            	        	dbg.Location(87,4);
            	        	PushFollow(FOLLOW_int_literal_in_var_or_int_literal227);
            	        	int_literal10 = int_literal();
            	        	state.followingStackPointer--;

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

            	        }
            	        break;

            	}
            	} finally { dbg.ExitSubRule(4); }


            }

            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(87, 51);

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

        return retval;
    }
Beispiel #4
0
    // $ANTLR start "var_or_int_literal"
    // C:\\Documents and Settings\\Administrator\\Desktop\\SPINA\\Interp_CSharp\\Interp_CSharp\\Interp.g:53:1: var_or_int_literal returns [Element ret] : ( variable | int_literal ) ;
    public InterpParser.var_or_int_literal_return var_or_int_literal() // throws RecognitionException [1]
    {   
        InterpParser.var_or_int_literal_return retval = new InterpParser.var_or_int_literal_return();
        retval.Start = input.LT(1);

        object root_0 = null;

        InterpParser.variable_return variable14 = null;

        InterpParser.int_literal_return int_literal15 = null;



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

        try 
    	{
            // C:\\Documents and Settings\\Administrator\\Desktop\\SPINA\\Interp_CSharp\\Interp_CSharp\\Interp.g:54:3: ( ( variable | int_literal ) )
            dbg.EnterAlt(1);

            // C:\\Documents and Settings\\Administrator\\Desktop\\SPINA\\Interp_CSharp\\Interp_CSharp\\Interp.g:54:6: ( variable | int_literal )
            {
            	root_0 = (object)adaptor.GetNilNode();

            	dbg.Location(54,6);
            	// C:\\Documents and Settings\\Administrator\\Desktop\\SPINA\\Interp_CSharp\\Interp_CSharp\\Interp.g:54:6: ( variable | int_literal )
            	int alt5 = 2;
            	try { dbg.EnterSubRule(5);
            	try { dbg.EnterDecision(5);

            	int LA5_0 = input.LA(1);

            	if ( (LA5_0 == VARIABLE) )
            	{
            	    alt5 = 1;
            	}
            	else if ( (LA5_0 == INT_LITERAL) )
            	{
            	    alt5 = 2;
            	}
            	else 
            	{
            	    NoViableAltException nvae_d5s0 =
            	        new NoViableAltException("", 5, 0, input);

            	    dbg.RecognitionException(nvae_d5s0);
            	    throw nvae_d5s0;
            	}
            	} finally { dbg.ExitDecision(5); }

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

            	        // C:\\Documents and Settings\\Administrator\\Desktop\\SPINA\\Interp_CSharp\\Interp_CSharp\\Interp.g:54:7: variable
            	        {
            	        	dbg.Location(54,7);
            	        	PushFollow(FOLLOW_variable_in_var_or_int_literal218);
            	        	variable14 = variable();
            	        	state.followingStackPointer--;

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

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

            	        // C:\\Documents and Settings\\Administrator\\Desktop\\SPINA\\Interp_CSharp\\Interp_CSharp\\Interp.g:55:7: int_literal
            	        {
            	        	dbg.Location(55,7);
            	        	PushFollow(FOLLOW_int_literal_in_var_or_int_literal229);
            	        	int_literal15 = int_literal();
            	        	state.followingStackPointer--;

            	        	adaptor.AddChild(root_0, int_literal15.Tree);
            	        	dbg.Location(55,19);
            	        	retval.ret = ((int_literal15 != null) ? int_literal15.ret : null); 

            	        }
            	        break;

            	}
            	} finally { dbg.ExitSubRule(5); }


            }

            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(55, 53);

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

        return retval;
    }