// $ANTLR start "execute"
// MathExpr.g:152:1: execute : result ;
public MathExprParser.execute_return execute() // throws RecognitionException [1]
{
MathExprParser.execute_return retval = new MathExprParser.execute_return();
retval.Start = input.LT(1);
int execute_StartIndex = input.Index();
AstNode root_0 = null;
MathExprParser.result_return result109 = default(MathExprParser.result_return);
try
{
if ( (state.backtracking > 0) && AlreadyParsedRule(input, 26) )
{
return retval;
}
// MathExpr.g:152:8: ( result )
// MathExpr.g:153:3: result
{
root_0 = (AstNode)adaptor.GetNilNode();
PushFollow(FOLLOW_result_in_execute1597);
result109 = result();
state.followingStackPointer--;
if (state.failed) return retval;
if ( state.backtracking == 0 ) adaptor.AddChild(root_0, result109.Tree);
}
retval.Stop = input.LT(-1);
if ( (state.backtracking==0) )
{ retval.Tree = (AstNode)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 = (AstNode)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);
}
finally
{
if ( state.backtracking > 0 )
{
Memoize(input, 26, execute_StartIndex);
}
}
return retval;
}
// $ANTLR start "execute"
// antlr_temp_dir\\MathExpr.g:95:1: execute : result ;
public MathExprParser.execute_return execute() // throws RecognitionException [1]
{
MathExprParser.execute_return retval = new MathExprParser.execute_return();
retval.Start = input.LT(1);
object root_0 = null;
MathExprParser.result_return result20 = default(MathExprParser.result_return);
try
{
// antlr_temp_dir\\MathExpr.g:95:8: ( result )
// antlr_temp_dir\\MathExpr.g:96:3: result
{
root_0 = (object)adaptor.GetNilNode();
PushFollow(FOLLOW_result_in_execute509);
result20 = result();
state.followingStackPointer--;
adaptor.AddChild(root_0, result20.Tree);
}
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;
}
// $ANTLR start "execute"
// MathExpr.g:212:8: public execute : program -> ^( PROGRAM program ) ;
public MathExprParser.execute_return execute() // throws RecognitionException [1]
{
MathExprParser.execute_return retval = new MathExprParser.execute_return();
retval.Start = input.LT(1);
int execute_StartIndex = input.Index();
AstNode root_0 = null;
MathExprParser.program_return program179 = default(MathExprParser.program_return);
RewriteRuleSubtreeStream stream_program = new RewriteRuleSubtreeStream(adaptor,"rule program");
try
{
if ( (state.backtracking > 0) && AlreadyParsedRule(input, 27) )
{
return retval;
}
// MathExpr.g:212:15: ( program -> ^( PROGRAM program ) )
// MathExpr.g:213:5: program
{
PushFollow(FOLLOW_program_in_execute2109);
program179 = program();
state.followingStackPointer--;
if (state.failed) return retval;
if ( (state.backtracking==0) ) stream_program.Add(program179.Tree);
// AST REWRITE
// elements: program
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
if ( (state.backtracking==0) ) {
retval.Tree = root_0;
RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);
root_0 = (AstNode)adaptor.GetNilNode();
// 213:13: -> ^( PROGRAM program )
{
// MathExpr.g:213:16: ^( PROGRAM program )
{
AstNode root_1 = (AstNode)adaptor.GetNilNode();
root_1 = (AstNode)adaptor.BecomeRoot((AstNode)adaptor.Create(PROGRAM, "PROGRAM"), root_1);
adaptor.AddChild(root_1, stream_program.NextTree());
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;retval.Tree = root_0;}
}
retval.Stop = input.LT(-1);
if ( (state.backtracking==0) )
{ retval.Tree = (AstNode)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 = (AstNode)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);
}
finally
{
if ( state.backtracking > 0 )
{
Memoize(input, 27, execute_StartIndex);
}
}
return retval;
}