private AstParserRuleReturnScope<CommonTree, IToken> stmt_modify()
{
EnterRule_stmt_modify();
EnterRule("stmt_modify", 57);
TraceIn("stmt_modify", 57);
AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>();
retval.Start = (IToken)input.LT(1);
CommonTree root_0 = default(CommonTree);
IToken WS554 = default(IToken);
IToken WS556 = default(IToken);
IToken WS558 = default(IToken);
IToken string_literal559 = default(IToken);
IToken WS560 = default(IToken);
IToken WS562 = default(IToken);
IToken string_literal563 = default(IToken);
IToken WS564 = default(IToken);
IToken WS566 = default(IToken);
IToken string_literal567 = default(IToken);
IToken WS568 = default(IToken);
AstParserRuleReturnScope<CommonTree, IToken> lvalue553 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> modify_expr_op555 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> where_expr557 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> where_expr561 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> where_expr565 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> where_expr569 = default(AstParserRuleReturnScope<CommonTree, IToken>);
CommonTree WS554_tree = default(CommonTree);
CommonTree WS556_tree = default(CommonTree);
CommonTree WS558_tree = default(CommonTree);
CommonTree string_literal559_tree = default(CommonTree);
CommonTree WS560_tree = default(CommonTree);
CommonTree WS562_tree = default(CommonTree);
CommonTree string_literal563_tree = default(CommonTree);
CommonTree WS564_tree = default(CommonTree);
CommonTree WS566_tree = default(CommonTree);
CommonTree string_literal567_tree = default(CommonTree);
CommonTree WS568_tree = default(CommonTree);
RewriteRuleITokenStream stream_117=new RewriteRuleITokenStream(adaptor,"token 117");
RewriteRuleITokenStream stream_127=new RewriteRuleITokenStream(adaptor,"token 127");
RewriteRuleITokenStream stream_WS=new RewriteRuleITokenStream(adaptor,"token WS");
RewriteRuleITokenStream stream_130=new RewriteRuleITokenStream(adaptor,"token 130");
RewriteRuleSubtreeStream stream_lvalue=new RewriteRuleSubtreeStream(adaptor,"rule lvalue");
RewriteRuleSubtreeStream stream_modify_expr_op=new RewriteRuleSubtreeStream(adaptor,"rule modify_expr_op");
RewriteRuleSubtreeStream stream_where_expr=new RewriteRuleSubtreeStream(adaptor,"rule where_expr");
try { DebugEnterRule(GrammarFileName, "stmt_modify");
DebugLocation(523, 1);
try
{
// SugarCpp.g:524:2: ( lvalue ( ( WS )* modify_expr_op ( WS )* where_expr -> ^( modify_expr_op lvalue where_expr ) | ( WS )* '?=' ( WS )* where_expr -> ^( '?=' lvalue where_expr ) | ( WS )* '<<' ( WS )* where_expr -> ^( Expr_Bin '<<' lvalue where_expr ) | ( WS )* '>>' ( WS )* where_expr -> ^( Expr_Bin '>>' lvalue where_expr ) | -> lvalue ) )
DebugEnterAlt(1);
// SugarCpp.g:524:4: lvalue ( ( WS )* modify_expr_op ( WS )* where_expr -> ^( modify_expr_op lvalue where_expr ) | ( WS )* '?=' ( WS )* where_expr -> ^( '?=' lvalue where_expr ) | ( WS )* '<<' ( WS )* where_expr -> ^( Expr_Bin '<<' lvalue where_expr ) | ( WS )* '>>' ( WS )* where_expr -> ^( Expr_Bin '>>' lvalue where_expr ) | -> lvalue )
{
DebugLocation(524, 4);
PushFollow(Follow._lvalue_in_stmt_modify5162);
lvalue553=lvalue();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_lvalue.Add(lvalue553.Tree);
DebugLocation(524, 11);
// SugarCpp.g:524:11: ( ( WS )* modify_expr_op ( WS )* where_expr -> ^( modify_expr_op lvalue where_expr ) | ( WS )* '?=' ( WS )* where_expr -> ^( '?=' lvalue where_expr ) | ( WS )* '<<' ( WS )* where_expr -> ^( Expr_Bin '<<' lvalue where_expr ) | ( WS )* '>>' ( WS )* where_expr -> ^( Expr_Bin '>>' lvalue where_expr ) | -> lvalue )
int alt365=5;
try { DebugEnterSubRule(365);
try { DebugEnterDecision(365, false);
try
{
alt365 = dfa365.Predict(input);
}
catch (NoViableAltException nvae)
{
DebugRecognitionException(nvae);
throw;
}
} finally { DebugExitDecision(365); }
switch (alt365)
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:524:13: ( WS )* modify_expr_op ( WS )* where_expr
{
DebugLocation(524, 13);
// SugarCpp.g:524:13: ( WS )*
try { DebugEnterSubRule(357);
while (true)
{
int alt357=2;
try { DebugEnterDecision(357, false);
int LA357_0 = input.LA(1);
if ((LA357_0==WS))
{
alt357 = 1;
}
} finally { DebugExitDecision(357); }
switch ( alt357 )
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:524:13: WS
{
DebugLocation(524, 13);
WS554=(IToken)Match(input,WS,Follow._WS_in_stmt_modify5166); if (state.failed) return retval;
if (state.backtracking == 0) stream_WS.Add(WS554);
}
break;
default:
goto loop357;
}
}
loop357:
;
} finally { DebugExitSubRule(357); }
DebugLocation(524, 17);
PushFollow(Follow._modify_expr_op_in_stmt_modify5169);
modify_expr_op555=modify_expr_op();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_modify_expr_op.Add(modify_expr_op555.Tree);
DebugLocation(524, 32);
// SugarCpp.g:524:32: ( WS )*
try { DebugEnterSubRule(358);
while (true)
{
int alt358=2;
try { DebugEnterDecision(358, false);
int LA358_0 = input.LA(1);
if ((LA358_0==WS))
{
alt358 = 1;
}
} finally { DebugExitDecision(358); }
switch ( alt358 )
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:524:32: WS
{
DebugLocation(524, 32);
WS556=(IToken)Match(input,WS,Follow._WS_in_stmt_modify5171); if (state.failed) return retval;
if (state.backtracking == 0) stream_WS.Add(WS556);
}
break;
default:
goto loop358;
}
}
loop358:
;
} finally { DebugExitSubRule(358); }
DebugLocation(524, 36);
PushFollow(Follow._where_expr_in_stmt_modify5174);
where_expr557=where_expr();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_where_expr.Add(where_expr557.Tree);
{
// AST REWRITE
// elements: lvalue, where_expr, modify_expr_op
// 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 = (CommonTree)adaptor.Nil();
// 524:47: -> ^( modify_expr_op lvalue where_expr )
{
DebugLocation(524, 50);
// SugarCpp.g:524:50: ^( modify_expr_op lvalue where_expr )
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(524, 52);
root_1 = (CommonTree)adaptor.BecomeRoot(stream_modify_expr_op.NextNode(), root_1);
DebugLocation(524, 67);
adaptor.AddChild(root_1, stream_lvalue.NextTree());
DebugLocation(524, 74);
adaptor.AddChild(root_1, stream_where_expr.NextTree());
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;
}
}
}
break;
case 2:
DebugEnterAlt(2);
// SugarCpp.g:525:13: ( WS )* '?=' ( WS )* where_expr
{
DebugLocation(525, 13);
// SugarCpp.g:525:13: ( WS )*
try { DebugEnterSubRule(359);
while (true)
{
int alt359=2;
try { DebugEnterDecision(359, false);
int LA359_0 = input.LA(1);
if ((LA359_0==WS))
{
alt359 = 1;
}
} finally { DebugExitDecision(359); }
switch ( alt359 )
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:525:13: WS
{
DebugLocation(525, 13);
WS558=(IToken)Match(input,WS,Follow._WS_in_stmt_modify5198); if (state.failed) return retval;
if (state.backtracking == 0) stream_WS.Add(WS558);
}
break;
default:
goto loop359;
}
}
loop359:
;
} finally { DebugExitSubRule(359); }
DebugLocation(525, 17);
string_literal559=(IToken)Match(input,130,Follow._130_in_stmt_modify5201); if (state.failed) return retval;
if (state.backtracking == 0) stream_130.Add(string_literal559);
DebugLocation(525, 22);
// SugarCpp.g:525:22: ( WS )*
try { DebugEnterSubRule(360);
while (true)
{
int alt360=2;
try { DebugEnterDecision(360, false);
int LA360_0 = input.LA(1);
if ((LA360_0==WS))
{
alt360 = 1;
}
} finally { DebugExitDecision(360); }
switch ( alt360 )
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:525:22: WS
{
DebugLocation(525, 22);
WS560=(IToken)Match(input,WS,Follow._WS_in_stmt_modify5203); if (state.failed) return retval;
if (state.backtracking == 0) stream_WS.Add(WS560);
}
break;
default:
goto loop360;
}
}
loop360:
;
} finally { DebugExitSubRule(360); }
DebugLocation(525, 26);
PushFollow(Follow._where_expr_in_stmt_modify5206);
where_expr561=where_expr();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_where_expr.Add(where_expr561.Tree);
{
// AST REWRITE
// elements: where_expr, lvalue, 130
// 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 = (CommonTree)adaptor.Nil();
// 525:37: -> ^( '?=' lvalue where_expr )
{
DebugLocation(525, 40);
// SugarCpp.g:525:40: ^( '?=' lvalue where_expr )
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(525, 42);
root_1 = (CommonTree)adaptor.BecomeRoot(stream_130.NextNode(), root_1);
DebugLocation(525, 47);
adaptor.AddChild(root_1, stream_lvalue.NextTree());
DebugLocation(525, 54);
adaptor.AddChild(root_1, stream_where_expr.NextTree());
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;
}
}
}
break;
case 3:
DebugEnterAlt(3);
// SugarCpp.g:526:16: ( WS )* '<<' ( WS )* where_expr
{
DebugLocation(526, 16);
// SugarCpp.g:526:16: ( WS )*
try { DebugEnterSubRule(361);
while (true)
{
int alt361=2;
try { DebugEnterDecision(361, false);
int LA361_0 = input.LA(1);
if ((LA361_0==WS))
{
alt361 = 1;
}
} finally { DebugExitDecision(361); }
switch ( alt361 )
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:526:16: WS
{
DebugLocation(526, 16);
WS562=(IToken)Match(input,WS,Follow._WS_in_stmt_modify5233); if (state.failed) return retval;
if (state.backtracking == 0) stream_WS.Add(WS562);
}
break;
default:
goto loop361;
}
}
loop361:
;
} finally { DebugExitSubRule(361); }
DebugLocation(526, 20);
string_literal563=(IToken)Match(input,117,Follow._117_in_stmt_modify5236); if (state.failed) return retval;
if (state.backtracking == 0) stream_117.Add(string_literal563);
DebugLocation(526, 25);
// SugarCpp.g:526:25: ( WS )*
try { DebugEnterSubRule(362);
while (true)
{
int alt362=2;
try { DebugEnterDecision(362, false);
int LA362_0 = input.LA(1);
if ((LA362_0==WS))
{
alt362 = 1;
}
} finally { DebugExitDecision(362); }
switch ( alt362 )
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:526:25: WS
{
DebugLocation(526, 25);
WS564=(IToken)Match(input,WS,Follow._WS_in_stmt_modify5238); if (state.failed) return retval;
if (state.backtracking == 0) stream_WS.Add(WS564);
}
break;
default:
goto loop362;
}
}
loop362:
;
} finally { DebugExitSubRule(362); }
DebugLocation(526, 29);
PushFollow(Follow._where_expr_in_stmt_modify5241);
where_expr565=where_expr();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_where_expr.Add(where_expr565.Tree);
{
// AST REWRITE
// elements: 117, lvalue, where_expr
// 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 = (CommonTree)adaptor.Nil();
// 526:40: -> ^( Expr_Bin '<<' lvalue where_expr )
{
DebugLocation(526, 43);
// SugarCpp.g:526:43: ^( Expr_Bin '<<' lvalue where_expr )
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(526, 45);
root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(Expr_Bin, "Expr_Bin"), root_1);
DebugLocation(526, 54);
adaptor.AddChild(root_1, stream_117.NextNode());
DebugLocation(526, 59);
adaptor.AddChild(root_1, stream_lvalue.NextTree());
DebugLocation(526, 66);
adaptor.AddChild(root_1, stream_where_expr.NextTree());
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;
}
}
}
break;
case 4:
DebugEnterAlt(4);
// SugarCpp.g:527:16: ( WS )* '>>' ( WS )* where_expr
{
DebugLocation(527, 16);
// SugarCpp.g:527:16: ( WS )*
try { DebugEnterSubRule(363);
while (true)
{
int alt363=2;
try { DebugEnterDecision(363, false);
int LA363_0 = input.LA(1);
if ((LA363_0==WS))
{
alt363 = 1;
}
} finally { DebugExitDecision(363); }
switch ( alt363 )
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:527:16: WS
{
DebugLocation(527, 16);
WS566=(IToken)Match(input,WS,Follow._WS_in_stmt_modify5270); if (state.failed) return retval;
if (state.backtracking == 0) stream_WS.Add(WS566);
}
break;
default:
goto loop363;
}
}
loop363:
;
} finally { DebugExitSubRule(363); }
DebugLocation(527, 20);
string_literal567=(IToken)Match(input,127,Follow._127_in_stmt_modify5273); if (state.failed) return retval;
if (state.backtracking == 0) stream_127.Add(string_literal567);
DebugLocation(527, 25);
// SugarCpp.g:527:25: ( WS )*
try { DebugEnterSubRule(364);
while (true)
{
int alt364=2;
try { DebugEnterDecision(364, false);
int LA364_0 = input.LA(1);
if ((LA364_0==WS))
{
alt364 = 1;
}
} finally { DebugExitDecision(364); }
switch ( alt364 )
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:527:25: WS
{
DebugLocation(527, 25);
WS568=(IToken)Match(input,WS,Follow._WS_in_stmt_modify5275); if (state.failed) return retval;
if (state.backtracking == 0) stream_WS.Add(WS568);
}
break;
default:
goto loop364;
}
}
loop364:
;
} finally { DebugExitSubRule(364); }
DebugLocation(527, 29);
PushFollow(Follow._where_expr_in_stmt_modify5278);
where_expr569=where_expr();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_where_expr.Add(where_expr569.Tree);
{
// AST REWRITE
// elements: 127, where_expr, lvalue
// 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 = (CommonTree)adaptor.Nil();
// 527:40: -> ^( Expr_Bin '>>' lvalue where_expr )
{
DebugLocation(527, 43);
// SugarCpp.g:527:43: ^( Expr_Bin '>>' lvalue where_expr )
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(527, 45);
root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(Expr_Bin, "Expr_Bin"), root_1);
DebugLocation(527, 54);
adaptor.AddChild(root_1, stream_127.NextNode());
DebugLocation(527, 59);
adaptor.AddChild(root_1, stream_lvalue.NextTree());
DebugLocation(527, 66);
adaptor.AddChild(root_1, stream_where_expr.NextTree());
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;
}
}
}
break;
case 5:
DebugEnterAlt(5);
// SugarCpp.g:528:7:
{
{
// AST REWRITE
// elements: lvalue
// 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 = (CommonTree)adaptor.Nil();
// 528:7: -> lvalue
{
DebugLocation(528, 10);
adaptor.AddChild(root_0, stream_lvalue.NextTree());
}
retval.Tree = root_0;
}
}
}
break;
}
} finally { DebugExitSubRule(365); }
}
retval.Stop = (IToken)input.LT(-1);
if (state.backtracking == 0) {
retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
}
}
catch (RecognitionException re)
{
ReportError(re);
Recover(input,re);
retval.Tree = (CommonTree)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);
}
finally
{
TraceOut("stmt_modify", 57);
LeaveRule("stmt_modify", 57);
LeaveRule_stmt_modify();
}
DebugLocation(529, 1);
} finally { DebugExitRule(GrammarFileName, "stmt_modify"); }
return retval;
}
// $ANTLR start "formulaDeclaration"
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:125:1: formulaDeclaration : entityChainNoFilter assignmentOp expression ';' -> ^( FORMULA ^( assignmentOp entityChainNoFilter expression ) ) ;
public formulaDeclaration_return formulaDeclaration() // throws RecognitionException [1]
{
var retval = new formulaDeclaration_return();
retval.Start = input.LT( 1 );
CommonTree root_0 = null;
IToken char_literal36 = null;
entityChainNoFilter_return entityChainNoFilter33 = default( entityChainNoFilter_return );
assignmentOp_return assignmentOp34 = default( assignmentOp_return );
expression_return expression35 = default( expression_return );
CommonTree char_literal36_tree = null;
var stream_63 = new RewriteRuleTokenStream( adaptor, "token 63" );
var stream_entityChainNoFilter = new RewriteRuleSubtreeStream( adaptor, "rule entityChainNoFilter" );
var stream_expression = new RewriteRuleSubtreeStream( adaptor, "rule expression" );
var stream_assignmentOp = new RewriteRuleSubtreeStream( adaptor, "rule assignmentOp" );
try
{
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:126:2: ( entityChainNoFilter assignmentOp expression ';' -> ^( FORMULA ^( assignmentOp entityChainNoFilter expression ) ) )
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:126:4: entityChainNoFilter assignmentOp expression ';'
{
PushFollow( FOLLOW_entityChainNoFilter_in_formulaDeclaration558 );
entityChainNoFilter33 = entityChainNoFilter();
state.followingStackPointer--;
stream_entityChainNoFilter.Add( entityChainNoFilter33.Tree );
PushFollow( FOLLOW_assignmentOp_in_formulaDeclaration560 );
assignmentOp34 = assignmentOp();
state.followingStackPointer--;
stream_assignmentOp.Add( assignmentOp34.Tree );
PushFollow( FOLLOW_expression_in_formulaDeclaration562 );
expression35 = expression();
state.followingStackPointer--;
stream_expression.Add( expression35.Tree );
char_literal36 = (IToken)Match( input, 63, FOLLOW_63_in_formulaDeclaration564 );
stream_63.Add( char_literal36 );
// AST REWRITE
// elements: assignmentOp, entityChainNoFilter, expression
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.Tree = root_0;
var stream_retval = new RewriteRuleSubtreeStream( adaptor, "rule retval", retval != null ? retval.Tree : null );
root_0 = (CommonTree)adaptor.GetNilNode();
// 126:52: -> ^( FORMULA ^( assignmentOp entityChainNoFilter expression ) )
{
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:126:55: ^( FORMULA ^( assignmentOp entityChainNoFilter expression ) )
{
var root_1 = (CommonTree)adaptor.GetNilNode();
root_1 = (CommonTree)adaptor.BecomeRoot( adaptor.Create( FORMULA, "FORMULA" ), root_1 );
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:126:66: ^( assignmentOp entityChainNoFilter expression )
{
var root_2 = (CommonTree)adaptor.GetNilNode();
root_2 = (CommonTree)adaptor.BecomeRoot( stream_assignmentOp.NextNode(), root_2 );
adaptor.AddChild( root_2, stream_entityChainNoFilter.NextTree() );
adaptor.AddChild( root_2, stream_expression.NextTree() );
adaptor.AddChild( root_1, root_2 );
}
adaptor.AddChild( root_0, root_1 );
}
}
retval.Tree = root_0;
retval.Tree = root_0;
}
retval.Stop = input.LT( -1 );
retval.Tree = 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 = adaptor.ErrorNode( input, (IToken)retval.Start, input.LT( -1 ), re );
}
finally {}
return retval;
}
// $ANTLR start "unaryExpression"
// /Users/Steve/Projects/NHibernate/Branches/2.1.x/nhibernate/src/NHibernate/Hql/Ast/ANTLR/Hql.g:491:1: unaryExpression : (m= MINUS mu= unaryExpression -> ^( UNARY_MINUS[$m] $mu) | p= PLUS pu= unaryExpression -> ^( UNARY_PLUS[$p] $pu) | c= caseExpression -> ^( $c) | q= quantifiedExpression -> ^( $q) | a= atom -> ^( $a) );
public HqlParser.unaryExpression_return unaryExpression() // throws RecognitionException [1]
{
HqlParser.unaryExpression_return retval = new HqlParser.unaryExpression_return();
retval.Start = input.LT(1);
IASTNode root_0 = null;
IToken m = null;
IToken p = null;
HqlParser.unaryExpression_return mu = default(HqlParser.unaryExpression_return);
HqlParser.unaryExpression_return pu = default(HqlParser.unaryExpression_return);
HqlParser.caseExpression_return c = default(HqlParser.caseExpression_return);
HqlParser.quantifiedExpression_return q = default(HqlParser.quantifiedExpression_return);
HqlParser.atom_return a = default(HqlParser.atom_return);
IASTNode m_tree=null;
IASTNode p_tree=null;
RewriteRuleTokenStream stream_MINUS = new RewriteRuleTokenStream(adaptor,"token MINUS");
RewriteRuleTokenStream stream_PLUS = new RewriteRuleTokenStream(adaptor,"token PLUS");
RewriteRuleSubtreeStream stream_unaryExpression = new RewriteRuleSubtreeStream(adaptor,"rule unaryExpression");
RewriteRuleSubtreeStream stream_atom = new RewriteRuleSubtreeStream(adaptor,"rule atom");
RewriteRuleSubtreeStream stream_quantifiedExpression = new RewriteRuleSubtreeStream(adaptor,"rule quantifiedExpression");
RewriteRuleSubtreeStream stream_caseExpression = new RewriteRuleSubtreeStream(adaptor,"rule caseExpression");
try
{
// /Users/Steve/Projects/NHibernate/Branches/2.1.x/nhibernate/src/NHibernate/Hql/Ast/ANTLR/Hql.g:492:2: (m= MINUS mu= unaryExpression -> ^( UNARY_MINUS[$m] $mu) | p= PLUS pu= unaryExpression -> ^( UNARY_PLUS[$p] $pu) | c= caseExpression -> ^( $c) | q= quantifiedExpression -> ^( $q) | a= atom -> ^( $a) )
int alt68 = 5;
switch ( input.LA(1) )
{
case MINUS:
{
alt68 = 1;
}
break;
case PLUS:
{
alt68 = 2;
}
break;
case CASE:
{
alt68 = 3;
}
break;
case ALL:
case ANY:
case EXISTS:
case SOME:
{
alt68 = 4;
}
break;
case AVG:
case COUNT:
case ELEMENTS:
case FALSE:
case INDICES:
case MAX:
case MIN:
case NULL:
case SUM:
case TRUE:
case EMPTY:
case NUM_INT:
case NUM_DOUBLE:
case NUM_FLOAT:
case NUM_LONG:
case OPEN:
case COLON:
case PARAM:
case QUOTED_String:
case IDENT:
{
alt68 = 5;
}
break;
default:
NoViableAltException nvae_d68s0 =
new NoViableAltException("", 68, 0, input);
throw nvae_d68s0;
}
switch (alt68)
{
case 1 :
// /Users/Steve/Projects/NHibernate/Branches/2.1.x/nhibernate/src/NHibernate/Hql/Ast/ANTLR/Hql.g:492:4: m= MINUS mu= unaryExpression
{
m=(IToken)Match(input,MINUS,FOLLOW_MINUS_in_unaryExpression2400);
stream_MINUS.Add(m);
PushFollow(FOLLOW_unaryExpression_in_unaryExpression2404);
mu = unaryExpression();
state.followingStackPointer--;
stream_unaryExpression.Add(mu.Tree);
// AST REWRITE
// elements: mu
// token labels:
// rule labels: mu, retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.Tree = root_0;
RewriteRuleSubtreeStream stream_mu = new RewriteRuleSubtreeStream(adaptor, "rule mu", mu!=null ? mu.Tree : null);
RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);
root_0 = (IASTNode)adaptor.GetNilNode();
// 492:31: -> ^( UNARY_MINUS[$m] $mu)
{
// /Users/Steve/Projects/NHibernate/Branches/2.1.x/nhibernate/src/NHibernate/Hql/Ast/ANTLR/Hql.g:492:34: ^( UNARY_MINUS[$m] $mu)
{
IASTNode root_1 = (IASTNode)adaptor.GetNilNode();
root_1 = (IASTNode)adaptor.BecomeRoot((IASTNode)adaptor.Create(UNARY_MINUS, m), root_1);
adaptor.AddChild(root_1, stream_mu.NextTree());
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;retval.Tree = root_0;
}
break;
case 2 :
// /Users/Steve/Projects/NHibernate/Branches/2.1.x/nhibernate/src/NHibernate/Hql/Ast/ANTLR/Hql.g:493:4: p= PLUS pu= unaryExpression
{
p=(IToken)Match(input,PLUS,FOLLOW_PLUS_in_unaryExpression2421);
stream_PLUS.Add(p);
PushFollow(FOLLOW_unaryExpression_in_unaryExpression2425);
pu = unaryExpression();
state.followingStackPointer--;
stream_unaryExpression.Add(pu.Tree);
// AST REWRITE
// elements: pu
// token labels:
// rule labels: pu, retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.Tree = root_0;
RewriteRuleSubtreeStream stream_pu = new RewriteRuleSubtreeStream(adaptor, "rule pu", pu!=null ? pu.Tree : null);
RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);
root_0 = (IASTNode)adaptor.GetNilNode();
// 493:30: -> ^( UNARY_PLUS[$p] $pu)
{
// /Users/Steve/Projects/NHibernate/Branches/2.1.x/nhibernate/src/NHibernate/Hql/Ast/ANTLR/Hql.g:493:33: ^( UNARY_PLUS[$p] $pu)
{
IASTNode root_1 = (IASTNode)adaptor.GetNilNode();
root_1 = (IASTNode)adaptor.BecomeRoot((IASTNode)adaptor.Create(UNARY_PLUS, p), root_1);
adaptor.AddChild(root_1, stream_pu.NextTree());
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;retval.Tree = root_0;
}
break;
case 3 :
// /Users/Steve/Projects/NHibernate/Branches/2.1.x/nhibernate/src/NHibernate/Hql/Ast/ANTLR/Hql.g:494:4: c= caseExpression
{
PushFollow(FOLLOW_caseExpression_in_unaryExpression2442);
c = caseExpression();
state.followingStackPointer--;
stream_caseExpression.Add(c.Tree);
// AST REWRITE
// elements: c
// token labels:
// rule labels: c, retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.Tree = root_0;
RewriteRuleSubtreeStream stream_c = new RewriteRuleSubtreeStream(adaptor, "rule c", c!=null ? c.Tree : null);
RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);
root_0 = (IASTNode)adaptor.GetNilNode();
// 494:21: -> ^( $c)
{
// /Users/Steve/Projects/NHibernate/Branches/2.1.x/nhibernate/src/NHibernate/Hql/Ast/ANTLR/Hql.g:494:24: ^( $c)
{
IASTNode root_1 = (IASTNode)adaptor.GetNilNode();
root_1 = (IASTNode)adaptor.BecomeRoot(stream_c.NextNode(), root_1);
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;retval.Tree = root_0;
}
break;
case 4 :
// /Users/Steve/Projects/NHibernate/Branches/2.1.x/nhibernate/src/NHibernate/Hql/Ast/ANTLR/Hql.g:495:4: q= quantifiedExpression
{
PushFollow(FOLLOW_quantifiedExpression_in_unaryExpression2456);
q = quantifiedExpression();
state.followingStackPointer--;
stream_quantifiedExpression.Add(q.Tree);
// AST REWRITE
// elements: q
// token labels:
// rule labels: retval, q
// token list labels:
// rule list labels:
// wildcard labels:
retval.Tree = root_0;
RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);
RewriteRuleSubtreeStream stream_q = new RewriteRuleSubtreeStream(adaptor, "rule q", q!=null ? q.Tree : null);
root_0 = (IASTNode)adaptor.GetNilNode();
// 495:27: -> ^( $q)
{
// /Users/Steve/Projects/NHibernate/Branches/2.1.x/nhibernate/src/NHibernate/Hql/Ast/ANTLR/Hql.g:495:30: ^( $q)
{
IASTNode root_1 = (IASTNode)adaptor.GetNilNode();
root_1 = (IASTNode)adaptor.BecomeRoot(stream_q.NextNode(), root_1);
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;retval.Tree = root_0;
}
break;
case 5 :
// /Users/Steve/Projects/NHibernate/Branches/2.1.x/nhibernate/src/NHibernate/Hql/Ast/ANTLR/Hql.g:496:4: a= atom
{
PushFollow(FOLLOW_atom_in_unaryExpression2471);
a = atom();
state.followingStackPointer--;
stream_atom.Add(a.Tree);
// AST REWRITE
// elements: a
// token labels:
// rule labels: a, retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.Tree = root_0;
RewriteRuleSubtreeStream stream_a = new RewriteRuleSubtreeStream(adaptor, "rule a", a!=null ? a.Tree : null);
RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);
root_0 = (IASTNode)adaptor.GetNilNode();
// 496:11: -> ^( $a)
{
// /Users/Steve/Projects/NHibernate/Branches/2.1.x/nhibernate/src/NHibernate/Hql/Ast/ANTLR/Hql.g:496:14: ^( $a)
{
IASTNode root_1 = (IASTNode)adaptor.GetNilNode();
root_1 = (IASTNode)adaptor.BecomeRoot(stream_a.NextNode(), root_1);
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;retval.Tree = root_0;
}
break;
}
retval.Stop = input.LT(-1);
retval.Tree = (IASTNode)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 = (IASTNode)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);
}
finally
{
}
return retval;
}
// $ANTLR start "expressionOrVector"
// /Users/Steve/Projects/NHibernate/Branches/2.1.x/nhibernate/src/NHibernate/Hql/Ast/ANTLR/Hql.g:548:1: expressionOrVector : e= expression (v= vectorExpr )? -> {v != null}? ^( VECTOR_EXPR[\"{vector}\"] $e $v) -> ^( $e) ;
public HqlParser.expressionOrVector_return expressionOrVector() // throws RecognitionException [1]
{
HqlParser.expressionOrVector_return retval = new HqlParser.expressionOrVector_return();
retval.Start = input.LT(1);
IASTNode root_0 = null;
HqlParser.expression_return e = default(HqlParser.expression_return);
HqlParser.vectorExpr_return v = default(HqlParser.vectorExpr_return);
RewriteRuleSubtreeStream stream_vectorExpr = new RewriteRuleSubtreeStream(adaptor,"rule vectorExpr");
RewriteRuleSubtreeStream stream_expression = new RewriteRuleSubtreeStream(adaptor,"rule expression");
try
{
// /Users/Steve/Projects/NHibernate/Branches/2.1.x/nhibernate/src/NHibernate/Hql/Ast/ANTLR/Hql.g:549:2: (e= expression (v= vectorExpr )? -> {v != null}? ^( VECTOR_EXPR[\"{vector}\"] $e $v) -> ^( $e) )
// /Users/Steve/Projects/NHibernate/Branches/2.1.x/nhibernate/src/NHibernate/Hql/Ast/ANTLR/Hql.g:549:4: e= expression (v= vectorExpr )?
{
PushFollow(FOLLOW_expression_in_expressionOrVector2861);
e = expression();
state.followingStackPointer--;
stream_expression.Add(e.Tree);
// /Users/Steve/Projects/NHibernate/Branches/2.1.x/nhibernate/src/NHibernate/Hql/Ast/ANTLR/Hql.g:549:17: (v= vectorExpr )?
int alt82 = 2;
int LA82_0 = input.LA(1);
if ( (LA82_0 == COMMA) )
{
alt82 = 1;
}
switch (alt82)
{
case 1 :
// /Users/Steve/Projects/NHibernate/Branches/2.1.x/nhibernate/src/NHibernate/Hql/Ast/ANTLR/Hql.g:549:19: v= vectorExpr
{
PushFollow(FOLLOW_vectorExpr_in_expressionOrVector2867);
v = vectorExpr();
state.followingStackPointer--;
stream_vectorExpr.Add(v.Tree);
}
break;
}
// AST REWRITE
// elements: e, v, e
// token labels:
// rule labels: retval, v, e
// token list labels:
// rule list labels:
// wildcard labels:
retval.Tree = root_0;
RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);
RewriteRuleSubtreeStream stream_v = new RewriteRuleSubtreeStream(adaptor, "rule v", v!=null ? v.Tree : null);
RewriteRuleSubtreeStream stream_e = new RewriteRuleSubtreeStream(adaptor, "rule e", e!=null ? e.Tree : null);
root_0 = (IASTNode)adaptor.GetNilNode();
// 550:2: -> {v != null}? ^( VECTOR_EXPR[\"{vector}\"] $e $v)
if (v != null)
{
// /Users/Steve/Projects/NHibernate/Branches/2.1.x/nhibernate/src/NHibernate/Hql/Ast/ANTLR/Hql.g:550:18: ^( VECTOR_EXPR[\"{vector}\"] $e $v)
{
IASTNode root_1 = (IASTNode)adaptor.GetNilNode();
root_1 = (IASTNode)adaptor.BecomeRoot((IASTNode)adaptor.Create(VECTOR_EXPR, "{vector}"), root_1);
adaptor.AddChild(root_1, stream_e.NextTree());
adaptor.AddChild(root_1, stream_v.NextTree());
adaptor.AddChild(root_0, root_1);
}
}
else // 551:2: -> ^( $e)
{
// /Users/Steve/Projects/NHibernate/Branches/2.1.x/nhibernate/src/NHibernate/Hql/Ast/ANTLR/Hql.g:551:5: ^( $e)
{
IASTNode root_1 = (IASTNode)adaptor.GetNilNode();
root_1 = (IASTNode)adaptor.BecomeRoot(stream_e.NextNode(), root_1);
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;retval.Tree = root_0;
}
retval.Stop = input.LT(-1);
retval.Tree = (IASTNode)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 = (IASTNode)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);
}
finally
{
}
return retval;
}
private AstParserRuleReturnScope<object, IToken> propertyname(bool subquery)
{
EnterRule_propertyname();
EnterRule("propertyname", 22);
TraceIn("propertyname", 22);
AstParserRuleReturnScope<object, IToken> retval = new AstParserRuleReturnScope<object, IToken>();
retval.Start = (IToken)input.LT(1);
object root_0 = default(object);
IToken char_literal90 = default(IToken);
AstParserRuleReturnScope<object, IToken> next = default(AstParserRuleReturnScope<object, IToken>);
AstParserRuleReturnScope<object, IToken> identifierpart89 = default(AstParserRuleReturnScope<object, IToken>);
object char_literal90_tree = default(object);
RewriteRuleITokenStream stream_74=new RewriteRuleITokenStream(adaptor,"token 74");
RewriteRuleSubtreeStream stream_identifierpart=new RewriteRuleSubtreeStream(adaptor,"rule identifierpart");
RewriteRuleSubtreeStream stream_subpropertyname=new RewriteRuleSubtreeStream(adaptor,"rule subpropertyname");
try { DebugEnterRule(GrammarFileName, "propertyname");
DebugLocation(110, 108);
try
{
// C:\\projects\\LinqToQuerystring\\LinqToQuerystring\\LinqToQuerystring.g:111:2: ( ( identifierpart[subquery] -> identifierpart ) ( '/' next= subpropertyname[false] -> ^( $propertyname $next) )? )
DebugEnterAlt(1);
// C:\\projects\\LinqToQuerystring\\LinqToQuerystring\\LinqToQuerystring.g:111:4: ( identifierpart[subquery] -> identifierpart ) ( '/' next= subpropertyname[false] -> ^( $propertyname $next) )?
{
DebugLocation(111, 4);
// C:\\projects\\LinqToQuerystring\\LinqToQuerystring\\LinqToQuerystring.g:111:4: ( identifierpart[subquery] -> identifierpart )
DebugEnterAlt(1);
// C:\\projects\\LinqToQuerystring\\LinqToQuerystring\\LinqToQuerystring.g:111:5: identifierpart[subquery]
{
DebugLocation(111, 5);
PushFollow(Follow._identifierpart_in_propertyname870);
identifierpart89=identifierpart(subquery);
PopFollow();
stream_identifierpart.Add(identifierpart89.Tree);
{
// AST REWRITE
// elements: identifierpart
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.Tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.Tree:null);
root_0 = (object)adaptor.Nil();
// 111:30: -> identifierpart
{
DebugLocation(111, 33);
adaptor.AddChild(root_0, stream_identifierpart.NextTree());
}
retval.Tree = root_0;
}
}
DebugLocation(111, 49);
// C:\\projects\\LinqToQuerystring\\LinqToQuerystring\\LinqToQuerystring.g:111:49: ( '/' next= subpropertyname[false] -> ^( $propertyname $next) )?
int alt25=2;
try { DebugEnterSubRule(25);
try { DebugEnterDecision(25, false);
int LA25_1 = input.LA(1);
if ((LA25_1==74))
{
int LA25_2 = input.LA(2);
if ((LA25_2==DYNAMICIDENTIFIER||LA25_2==IDENTIFIER))
{
alt25 = 1;
}
}
} finally { DebugExitDecision(25); }
switch (alt25)
{
case 1:
DebugEnterAlt(1);
// C:\\projects\\LinqToQuerystring\\LinqToQuerystring\\LinqToQuerystring.g:111:50: '/' next= subpropertyname[false]
{
DebugLocation(111, 50);
char_literal90=(IToken)Match(input,74,Follow._74_in_propertyname879);
stream_74.Add(char_literal90);
DebugLocation(111, 58);
PushFollow(Follow._subpropertyname_in_propertyname883);
next=subpropertyname(false);
PopFollow();
stream_subpropertyname.Add(next.Tree);
{
// AST REWRITE
// elements: propertyname, next
// token labels:
// rule labels: next, retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.Tree = root_0;
RewriteRuleSubtreeStream stream_next=new RewriteRuleSubtreeStream(adaptor,"rule next",next!=null?next.Tree:null);
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.Tree:null);
root_0 = (object)adaptor.Nil();
// 111:82: -> ^( $propertyname $next)
{
DebugLocation(111, 85);
// C:\\projects\\LinqToQuerystring\\LinqToQuerystring\\LinqToQuerystring.g:111:85: ^( $propertyname $next)
{
object root_1 = (object)adaptor.Nil();
DebugLocation(111, 88);
root_1 = (object)adaptor.BecomeRoot(stream_retval.NextNode(), root_1);
DebugLocation(111, 102);
adaptor.AddChild(root_1, stream_next.NextTree());
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;
}
}
break;
}
} finally { DebugExitSubRule(25); }
}
retval.Stop = (IToken)input.LT(-1);
retval.Tree = (object)adaptor.RulePostProcessing(root_0);
adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
}
catch (RecognitionException re)
{
ReportError(re);
Recover(input,re);
retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);
}
finally
{
TraceOut("propertyname", 22);
LeaveRule("propertyname", 22);
LeaveRule_propertyname();
}
DebugLocation(111, 108);
} finally { DebugExitRule(GrammarFileName, "propertyname"); }
return retval;
}
// $ANTLR start "negatedExpression"
// /Users/Steve/Projects/NHibernate/Branches/2.1.x/nhibernate/src/NHibernate/Hql/Ast/ANTLR/Hql.g:373:1: negatedExpression : ( NOT x= negatedExpression -> ^() | equalityExpression -> ^( equalityExpression ) );
public HqlParser.negatedExpression_return negatedExpression() // throws RecognitionException [1]
{
HqlParser.negatedExpression_return retval = new HqlParser.negatedExpression_return();
retval.Start = input.LT(1);
IASTNode root_0 = null;
IToken NOT148 = null;
HqlParser.negatedExpression_return x = default(HqlParser.negatedExpression_return);
HqlParser.equalityExpression_return equalityExpression149 = default(HqlParser.equalityExpression_return);
IASTNode NOT148_tree=null;
RewriteRuleTokenStream stream_NOT = new RewriteRuleTokenStream(adaptor,"token NOT");
RewriteRuleSubtreeStream stream_negatedExpression = new RewriteRuleSubtreeStream(adaptor,"rule negatedExpression");
RewriteRuleSubtreeStream stream_equalityExpression = new RewriteRuleSubtreeStream(adaptor,"rule equalityExpression");
WeakKeywords();
try
{
// /Users/Steve/Projects/NHibernate/Branches/2.1.x/nhibernate/src/NHibernate/Hql/Ast/ANTLR/Hql.g:375:2: ( NOT x= negatedExpression -> ^() | equalityExpression -> ^( equalityExpression ) )
int alt47 = 2;
int LA47_0 = input.LA(1);
if ( (LA47_0 == NOT) )
{
alt47 = 1;
}
else if ( ((LA47_0 >= ALL && LA47_0 <= ANY) || LA47_0 == AVG || LA47_0 == COUNT || LA47_0 == ELEMENTS || (LA47_0 >= EXISTS && LA47_0 <= FALSE) || LA47_0 == INDICES || (LA47_0 >= MAX && LA47_0 <= MIN) || LA47_0 == NULL || (LA47_0 >= SOME && LA47_0 <= TRUE) || LA47_0 == CASE || LA47_0 == EMPTY || (LA47_0 >= NUM_INT && LA47_0 <= NUM_LONG) || LA47_0 == OPEN || LA47_0 == BNOT || (LA47_0 >= PLUS && LA47_0 <= MINUS) || (LA47_0 >= COLON && LA47_0 <= IDENT)) )
{
alt47 = 2;
}
else
{
NoViableAltException nvae_d47s0 =
new NoViableAltException("", 47, 0, input);
throw nvae_d47s0;
}
switch (alt47)
{
case 1 :
// /Users/Steve/Projects/NHibernate/Branches/2.1.x/nhibernate/src/NHibernate/Hql/Ast/ANTLR/Hql.g:375:4: NOT x= negatedExpression
{
NOT148=(IToken)Match(input,NOT,FOLLOW_NOT_in_negatedExpression1854);
stream_NOT.Add(NOT148);
PushFollow(FOLLOW_negatedExpression_in_negatedExpression1858);
x = negatedExpression();
state.followingStackPointer--;
stream_negatedExpression.Add(x.Tree);
// AST REWRITE
// elements:
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.Tree = root_0;
RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);
root_0 = (IASTNode)adaptor.GetNilNode();
// 376:3: -> ^()
{
// /Users/Steve/Projects/NHibernate/Branches/2.1.x/nhibernate/src/NHibernate/Hql/Ast/ANTLR/Hql.g:376:6: ^()
{
IASTNode root_1 = (IASTNode)adaptor.GetNilNode();
root_1 = (IASTNode)adaptor.BecomeRoot(NegateNode(((x != null) ? ((IASTNode)x.Tree) : null)), root_1);
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;retval.Tree = root_0;
}
break;
case 2 :
// /Users/Steve/Projects/NHibernate/Branches/2.1.x/nhibernate/src/NHibernate/Hql/Ast/ANTLR/Hql.g:377:4: equalityExpression
{
PushFollow(FOLLOW_equalityExpression_in_negatedExpression1871);
equalityExpression149 = equalityExpression();
state.followingStackPointer--;
stream_equalityExpression.Add(equalityExpression149.Tree);
// AST REWRITE
// elements: equalityExpression
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.Tree = root_0;
RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);
root_0 = (IASTNode)adaptor.GetNilNode();
// 378:3: -> ^( equalityExpression )
{
// /Users/Steve/Projects/NHibernate/Branches/2.1.x/nhibernate/src/NHibernate/Hql/Ast/ANTLR/Hql.g:378:6: ^( equalityExpression )
{
IASTNode root_1 = (IASTNode)adaptor.GetNilNode();
root_1 = (IASTNode)adaptor.BecomeRoot(stream_equalityExpression.NextNode(), root_1);
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;retval.Tree = root_0;
}
break;
}
retval.Stop = input.LT(-1);
retval.Tree = (IASTNode)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 = (IASTNode)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);
}
finally
{
}
return retval;
}
public void CheckRRSubtreeStreamBehaviourWhileEmpty1() {
string description = "RewriteRuleSubtreeStream test";
RewriteRuleSubtreeStream subtreeTest =
new RewriteRuleSubtreeStream(CreateTreeAdaptor(), description);
Assert.IsFalse(subtreeTest.HasNext(), "HasNext() has to give back false here.");
Assert.AreEqual(description.ToString(), subtreeTest.Description,
"Description strings should be equal.");
Assert.AreEqual(0, subtreeTest.Size(), "The number of elements should be zero.");
subtreeTest.Reset();
Assert.IsTrue(true, "Reset() shouldn't make any problems here.");
Assert.AreEqual(0, subtreeTest.Size(),
"The number of elements should be still zero.");
subtreeTest.NextNode();
}
public void CheckRRSubtreeStreamBehaviourWithElements() {
RewriteRuleSubtreeStream subtreeTest =
new RewriteRuleSubtreeStream(CreateTreeAdaptor(),
"RewriteRuleSubtreeStream test");
IToken token1 = CreateToken(1, "test token without any real context");
ITree tree1 = CreateTree(token1);
// Test Add()
subtreeTest.Add(tree1);
Assert.AreEqual(1, subtreeTest.Size(), "subtreeTest should have the size 1 (1).");
Assert.IsTrue(subtreeTest.HasNext(), "HasNext() should be true here (1).");
// Test NextNode()
Assert.AreEqual(tree1, (ITree) subtreeTest.NextNode(),
"The returned tree should be equal to the given tree (1).");
Assert.AreEqual(1, subtreeTest.Size(), "subtreeTest should have the size 1 (2).");
Assert.IsFalse(subtreeTest.HasNext(), "HasNext() should be false here (1).");
subtreeTest.Reset();
Assert.AreEqual(1, subtreeTest.Size(), "subtreeTest should have the size 1 (3).");
Assert.IsTrue(subtreeTest.HasNext(), "HasNext() should be true here (2).");
// Test NextTree()
CommonTree returnedTree = (CommonTree) subtreeTest.NextTree();
Assert.AreEqual(token1, returnedTree.Token,
"The returned token should be equal to the given token (3).");
Assert.AreEqual(1, subtreeTest.Size(), "subtreeTest should have the size 1 (4).");
Assert.IsFalse(subtreeTest.HasNext(), "HasNext() should be false here (2).");
subtreeTest.Reset();
Assert.AreEqual(1, subtreeTest.Size(), "subtreeTest should have the size 1 (5).");
Assert.IsTrue(subtreeTest.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);
subtreeTest.Add(tree2);
Assert.AreEqual(2, subtreeTest.Size(), "subtreeTest should have the size 2 (1).");
Assert.IsTrue(subtreeTest.HasNext(), "HasNext() should be true here (4).");
returnedTree = (CommonTree) subtreeTest.NextTree();
Assert.AreEqual(token1, returnedTree.Token,
"The returned token should be equal to the given token (4).");
Assert.AreEqual(2, subtreeTest.Size(), "subtreeTest should have the size 2 (2).");
Assert.IsTrue(subtreeTest.HasNext(), "HasNext() should be true here (5).");
returnedTree = (CommonTree) subtreeTest.NextTree();
Assert.AreEqual(token2, returnedTree.Token,
"The returned token should be equal to the given token (5).");
Assert.IsFalse(subtreeTest.HasNext(), "HasNext() should be false here (3).");
// Test exception
subtreeTest.NextTree();
}
// $ANTLR start "varsDecl"
// MathExpr.g:109:1: varsDecl : ident varDecl ( ',' varDecl )* -> ^( VAR ^( ident ( varDecl )+ ) ) ;
public MathExprParser.varsDecl_return varsDecl() // throws RecognitionException [1]
{
MathExprParser.varsDecl_return retval = new MathExprParser.varsDecl_return();
retval.Start = input.LT(1);
int varsDecl_StartIndex = input.Index();
AstNode root_0 = null;
IToken char_literal41 = null;
MathExprParser.ident_return ident39 = default(MathExprParser.ident_return);
MathExprParser.varDecl_return varDecl40 = default(MathExprParser.varDecl_return);
MathExprParser.varDecl_return varDecl42 = default(MathExprParser.varDecl_return);
AstNode char_literal41_tree=null;
RewriteRuleTokenStream stream_50 = new RewriteRuleTokenStream(adaptor,"token 50");
RewriteRuleSubtreeStream stream_ident = new RewriteRuleSubtreeStream(adaptor,"rule ident");
RewriteRuleSubtreeStream stream_varDecl = new RewriteRuleSubtreeStream(adaptor,"rule varDecl");
try
{
if ( (state.backtracking > 0) && AlreadyParsedRule(input, 13) )
{
return retval;
}
// MathExpr.g:109:9: ( ident varDecl ( ',' varDecl )* -> ^( VAR ^( ident ( varDecl )+ ) ) )
// MathExpr.g:109:11: ident varDecl ( ',' varDecl )*
{
PushFollow(FOLLOW_ident_in_varsDecl1183);
ident39 = ident();
state.followingStackPointer--;
if (state.failed) return retval;
if ( (state.backtracking==0) ) stream_ident.Add(ident39.Tree);
PushFollow(FOLLOW_varDecl_in_varsDecl1185);
varDecl40 = varDecl();
state.followingStackPointer--;
if (state.failed) return retval;
if ( (state.backtracking==0) ) stream_varDecl.Add(varDecl40.Tree);
// MathExpr.g:109:25: ( ',' varDecl )*
do
{
int alt11 = 2;
int LA11_0 = input.LA(1);
if ( (LA11_0 == 50) )
{
int LA11_2 = input.LA(2);
if ( (LA11_2 == IDENT) )
{
int LA11_3 = input.LA(3);
if ( (synpred26_MathExpr()) )
{
alt11 = 1;
}
}
}
switch (alt11)
{
case 1 :
// MathExpr.g:109:27: ',' varDecl
{
char_literal41=(IToken)Match(input,50,FOLLOW_50_in_varsDecl1189); if (state.failed) return retval;
if ( (state.backtracking==0) ) stream_50.Add(char_literal41);
PushFollow(FOLLOW_varDecl_in_varsDecl1191);
varDecl42 = varDecl();
state.followingStackPointer--;
if (state.failed) return retval;
if ( (state.backtracking==0) ) stream_varDecl.Add(varDecl42.Tree);
}
break;
default:
goto loop11;
}
} while (true);
loop11:
; // Stops C# compiler whining that label 'loop11' has no statements
// AST REWRITE
// elements: ident, varDecl
// 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();
// 109:42: -> ^( VAR ^( ident ( varDecl )+ ) )
{
// MathExpr.g:109:45: ^( VAR ^( ident ( varDecl )+ ) )
{
AstNode root_1 = (AstNode)adaptor.GetNilNode();
root_1 = (AstNode)adaptor.BecomeRoot((AstNode)adaptor.Create(VAR, "VAR"), root_1);
// MathExpr.g:109:51: ^( ident ( varDecl )+ )
{
AstNode root_2 = (AstNode)adaptor.GetNilNode();
root_2 = (AstNode)adaptor.BecomeRoot(stream_ident.NextNode(), root_2);
if ( !(stream_varDecl.HasNext()) ) {
throw new RewriteEarlyExitException();
}
while ( stream_varDecl.HasNext() )
{
adaptor.AddChild(root_2, stream_varDecl.NextTree());
}
stream_varDecl.Reset();
adaptor.AddChild(root_1, root_2);
}
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, 13, varsDecl_StartIndex);
}
}
return retval;
}
private AstParserRuleReturnScope<CommonTree, IToken> qualifiedIdentExpression()
{
EnterRule_qualifiedIdentExpression();
EnterRule("qualifiedIdentExpression", 106);
TraceIn("qualifiedIdentExpression", 106);
AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>();
retval.Start = (IToken)input.LT(1);
int qualifiedIdentExpression_StartIndex = input.Index;
CommonTree root_0 = default(CommonTree);
IToken outerDot = default(IToken);
IToken Super = default(IToken);
IToken innerDot = default(IToken);
IToken DOT493 = default(IToken);
IToken CLASS494 = default(IToken);
IToken CLASS496 = default(IToken);
IToken SUPER499 = default(IToken);
IToken IDENT500 = default(IToken);
IToken IDENT502 = default(IToken);
IToken THIS504 = default(IToken);
AstParserRuleReturnScope<CommonTree, IToken> qualifiedIdentifier491 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> arrayDeclarator492 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> arguments495 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> genericTypeArgumentListSimplified497 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> arguments498 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> arguments501 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> arguments503 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> arguments505 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> innerNewExpression506 = default(AstParserRuleReturnScope<CommonTree, IToken>);
CommonTree outerDot_tree = default(CommonTree);
CommonTree Super_tree = default(CommonTree);
CommonTree innerDot_tree = default(CommonTree);
CommonTree DOT493_tree = default(CommonTree);
CommonTree CLASS494_tree = default(CommonTree);
CommonTree CLASS496_tree = default(CommonTree);
CommonTree SUPER499_tree = default(CommonTree);
CommonTree IDENT500_tree = default(CommonTree);
CommonTree IDENT502_tree = default(CommonTree);
CommonTree THIS504_tree = default(CommonTree);
RewriteRuleITokenStream stream_DOT=new RewriteRuleITokenStream(adaptor,"token DOT");
RewriteRuleITokenStream stream_CLASS=new RewriteRuleITokenStream(adaptor,"token CLASS");
RewriteRuleITokenStream stream_SUPER=new RewriteRuleITokenStream(adaptor,"token SUPER");
RewriteRuleITokenStream stream_IDENT=new RewriteRuleITokenStream(adaptor,"token IDENT");
RewriteRuleITokenStream stream_THIS=new RewriteRuleITokenStream(adaptor,"token THIS");
RewriteRuleSubtreeStream stream_qualifiedIdentifier=new RewriteRuleSubtreeStream(adaptor,"rule qualifiedIdentifier");
RewriteRuleSubtreeStream stream_arrayDeclarator=new RewriteRuleSubtreeStream(adaptor,"rule arrayDeclarator");
RewriteRuleSubtreeStream stream_arguments=new RewriteRuleSubtreeStream(adaptor,"rule arguments");
RewriteRuleSubtreeStream stream_genericTypeArgumentListSimplified=new RewriteRuleSubtreeStream(adaptor,"rule genericTypeArgumentListSimplified");
RewriteRuleSubtreeStream stream_innerNewExpression=new RewriteRuleSubtreeStream(adaptor,"rule innerNewExpression");
try { DebugEnterRule(GrammarFileName, "qualifiedIdentExpression");
DebugLocation(940, 4);
try
{
if (state.backtracking > 0 && AlreadyParsedRule(input, 106)) { return retval; }
// Java.g:942:5: ( ( qualifiedIdentifier -> qualifiedIdentifier ) ( ( arrayDeclarator -> ^( arrayDeclarator $qualifiedIdentExpression) )+ ( DOT CLASS -> ^( DOT $qualifiedIdentExpression CLASS ) ) | arguments -> ^( METHOD_CALL qualifiedIdentifier arguments ) |outerDot= DOT ( CLASS -> ^( DOT qualifiedIdentifier CLASS ) | genericTypeArgumentListSimplified (Super= SUPER arguments -> ^( SUPER_CONSTRUCTOR_CALL[$Super, \"SUPER_CONSTRUCTOR_CALL\"] qualifiedIdentifier genericTypeArgumentListSimplified arguments ) | SUPER innerDot= DOT IDENT arguments -> ^( METHOD_CALL ^( $innerDot ^( $outerDot qualifiedIdentifier SUPER ) IDENT ) genericTypeArgumentListSimplified arguments ) | IDENT arguments -> ^( METHOD_CALL ^( DOT qualifiedIdentifier IDENT ) genericTypeArgumentListSimplified arguments ) ) | THIS -> ^( DOT qualifiedIdentifier THIS ) |Super= SUPER arguments -> ^( SUPER_CONSTRUCTOR_CALL[$Super, \"SUPER_CONSTRUCTOR_CALL\"] qualifiedIdentifier arguments ) | innerNewExpression -> ^( DOT qualifiedIdentifier innerNewExpression ) ) )? )
DebugEnterAlt(1);
// Java.g:942:9: ( qualifiedIdentifier -> qualifiedIdentifier ) ( ( arrayDeclarator -> ^( arrayDeclarator $qualifiedIdentExpression) )+ ( DOT CLASS -> ^( DOT $qualifiedIdentExpression CLASS ) ) | arguments -> ^( METHOD_CALL qualifiedIdentifier arguments ) |outerDot= DOT ( CLASS -> ^( DOT qualifiedIdentifier CLASS ) | genericTypeArgumentListSimplified (Super= SUPER arguments -> ^( SUPER_CONSTRUCTOR_CALL[$Super, \"SUPER_CONSTRUCTOR_CALL\"] qualifiedIdentifier genericTypeArgumentListSimplified arguments ) | SUPER innerDot= DOT IDENT arguments -> ^( METHOD_CALL ^( $innerDot ^( $outerDot qualifiedIdentifier SUPER ) IDENT ) genericTypeArgumentListSimplified arguments ) | IDENT arguments -> ^( METHOD_CALL ^( DOT qualifiedIdentifier IDENT ) genericTypeArgumentListSimplified arguments ) ) | THIS -> ^( DOT qualifiedIdentifier THIS ) |Super= SUPER arguments -> ^( SUPER_CONSTRUCTOR_CALL[$Super, \"SUPER_CONSTRUCTOR_CALL\"] qualifiedIdentifier arguments ) | innerNewExpression -> ^( DOT qualifiedIdentifier innerNewExpression ) ) )?
{
DebugLocation(942, 9);
// Java.g:942:9: ( qualifiedIdentifier -> qualifiedIdentifier )
DebugEnterAlt(1);
// Java.g:942:13: qualifiedIdentifier
{
DebugLocation(942, 13);
PushFollow(Follow._qualifiedIdentifier_in_qualifiedIdentExpression13626);
qualifiedIdentifier491=qualifiedIdentifier();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_qualifiedIdentifier.Add(qualifiedIdentifier491.Tree);
{
// AST REWRITE
// elements: qualifiedIdentifier
// 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 = (CommonTree)adaptor.Nil();
// 942:61: -> qualifiedIdentifier
{
DebugLocation(942, 65);
adaptor.AddChild(root_0, stream_qualifiedIdentifier.NextTree());
}
retval.Tree = root_0;
}
}
}
DebugLocation(945, 9);
// Java.g:945:9: ( ( arrayDeclarator -> ^( arrayDeclarator $qualifiedIdentExpression) )+ ( DOT CLASS -> ^( DOT $qualifiedIdentExpression CLASS ) ) | arguments -> ^( METHOD_CALL qualifiedIdentifier arguments ) |outerDot= DOT ( CLASS -> ^( DOT qualifiedIdentifier CLASS ) | genericTypeArgumentListSimplified (Super= SUPER arguments -> ^( SUPER_CONSTRUCTOR_CALL[$Super, \"SUPER_CONSTRUCTOR_CALL\"] qualifiedIdentifier genericTypeArgumentListSimplified arguments ) | SUPER innerDot= DOT IDENT arguments -> ^( METHOD_CALL ^( $innerDot ^( $outerDot qualifiedIdentifier SUPER ) IDENT ) genericTypeArgumentListSimplified arguments ) | IDENT arguments -> ^( METHOD_CALL ^( DOT qualifiedIdentifier IDENT ) genericTypeArgumentListSimplified arguments ) ) | THIS -> ^( DOT qualifiedIdentifier THIS ) |Super= SUPER arguments -> ^( SUPER_CONSTRUCTOR_CALL[$Super, \"SUPER_CONSTRUCTOR_CALL\"] qualifiedIdentifier arguments ) | innerNewExpression -> ^( DOT qualifiedIdentifier innerNewExpression ) ) )?
int alt143=4;
try { DebugEnterSubRule(143);
try { DebugEnterDecision(143, false);
switch (input.LA(1))
{
case LBRACK:
{
int LA143_2 = input.LA(2);
if ((EvaluatePredicate(synpred218_Java_fragment)))
{
alt143 = 1;
}
}
break;
case LPAREN:
{
alt143 = 2;
}
break;
case DOT:
{
int LA143_2 = input.LA(2);
if ((EvaluatePredicate(synpred226_Java_fragment)))
{
alt143 = 3;
}
}
break;
}
} finally { DebugExitDecision(143); }
switch (alt143)
{
case 1:
DebugEnterAlt(1);
// Java.g:945:13: ( arrayDeclarator -> ^( arrayDeclarator $qualifiedIdentExpression) )+ ( DOT CLASS -> ^( DOT $qualifiedIdentExpression CLASS ) )
{
DebugLocation(945, 13);
// Java.g:945:13: ( arrayDeclarator -> ^( arrayDeclarator $qualifiedIdentExpression) )+
int cnt140=0;
try { DebugEnterSubRule(140);
while (true)
{
int alt140=2;
try { DebugEnterDecision(140, false);
int LA140_1 = input.LA(1);
if ((LA140_1==LBRACK))
{
alt140 = 1;
}
} finally { DebugExitDecision(140); }
switch (alt140)
{
case 1:
DebugEnterAlt(1);
// Java.g:945:17: arrayDeclarator
{
DebugLocation(945, 17);
PushFollow(Follow._arrayDeclarator_in_qualifiedIdentExpression13696);
arrayDeclarator492=arrayDeclarator();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_arrayDeclarator.Add(arrayDeclarator492.Tree);
{
// AST REWRITE
// elements: arrayDeclarator, qualifiedIdentExpression
// 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 = (CommonTree)adaptor.Nil();
// 945:57: -> ^( arrayDeclarator $qualifiedIdentExpression)
{
DebugLocation(945, 61);
// Java.g:945:61: ^( arrayDeclarator $qualifiedIdentExpression)
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(945, 63);
root_1 = (CommonTree)adaptor.BecomeRoot(stream_arrayDeclarator.NextNode(), root_1);
DebugLocation(945, 80);
adaptor.AddChild(root_1, stream_retval.NextTree());
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;
}
}
}
break;
default:
if (cnt140 >= 1)
goto loop140;
if (state.backtracking>0) {state.failed=true; return retval;}
EarlyExitException eee140 = new EarlyExitException( 140, input );
DebugRecognitionException(eee140);
throw eee140;
}
cnt140++;
}
loop140:
;
} finally { DebugExitSubRule(140); }
DebugLocation(947, 13);
// Java.g:947:13: ( DOT CLASS -> ^( DOT $qualifiedIdentExpression CLASS ) )
DebugEnterAlt(1);
// Java.g:947:17: DOT CLASS
{
DebugLocation(947, 17);
DOT493=(IToken)Match(input,DOT,Follow._DOT_in_qualifiedIdentExpression13764); if (state.failed) return retval;
if (state.backtracking == 0) stream_DOT.Add(DOT493);
DebugLocation(947, 21);
CLASS494=(IToken)Match(input,CLASS,Follow._CLASS_in_qualifiedIdentExpression13766); if (state.failed) return retval;
if (state.backtracking == 0) stream_CLASS.Add(CLASS494);
{
// AST REWRITE
// elements: DOT, qualifiedIdentExpression, CLASS
// 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 = (CommonTree)adaptor.Nil();
// 947:57: -> ^( DOT $qualifiedIdentExpression CLASS )
{
DebugLocation(947, 61);
// Java.g:947:61: ^( DOT $qualifiedIdentExpression CLASS )
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(947, 63);
root_1 = (CommonTree)adaptor.BecomeRoot(stream_DOT.NextNode(), root_1);
DebugLocation(947, 68);
adaptor.AddChild(root_1, stream_retval.NextTree());
DebugLocation(947, 93);
adaptor.AddChild(root_1, stream_CLASS.NextNode());
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;
}
}
}
}
break;
case 2:
DebugEnterAlt(2);
// Java.g:949:13: arguments
{
DebugLocation(949, 13);
PushFollow(Follow._arguments_in_qualifiedIdentExpression13836);
arguments495=arguments();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_arguments.Add(arguments495.Tree);
{
// AST REWRITE
// elements: qualifiedIdentifier, arguments
// 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 = (CommonTree)adaptor.Nil();
// 949:57: -> ^( METHOD_CALL qualifiedIdentifier arguments )
{
DebugLocation(949, 61);
// Java.g:949:61: ^( METHOD_CALL qualifiedIdentifier arguments )
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(949, 63);
root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(METHOD_CALL, "METHOD_CALL"), root_1);
DebugLocation(949, 75);
adaptor.AddChild(root_1, stream_qualifiedIdentifier.NextTree());
DebugLocation(949, 95);
adaptor.AddChild(root_1, stream_arguments.NextTree());
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;
}
}
}
break;
case 3:
DebugEnterAlt(3);
// Java.g:950:13: outerDot= DOT ( CLASS -> ^( DOT qualifiedIdentifier CLASS ) | genericTypeArgumentListSimplified (Super= SUPER arguments -> ^( SUPER_CONSTRUCTOR_CALL[$Super, \"SUPER_CONSTRUCTOR_CALL\"] qualifiedIdentifier genericTypeArgumentListSimplified arguments ) | SUPER innerDot= DOT IDENT arguments -> ^( METHOD_CALL ^( $innerDot ^( $outerDot qualifiedIdentifier SUPER ) IDENT ) genericTypeArgumentListSimplified arguments ) | IDENT arguments -> ^( METHOD_CALL ^( DOT qualifiedIdentifier IDENT ) genericTypeArgumentListSimplified arguments ) ) | THIS -> ^( DOT qualifiedIdentifier THIS ) |Super= SUPER arguments -> ^( SUPER_CONSTRUCTOR_CALL[$Super, \"SUPER_CONSTRUCTOR_CALL\"] qualifiedIdentifier arguments ) | innerNewExpression -> ^( DOT qualifiedIdentifier innerNewExpression ) )
{
DebugLocation(950, 21);
outerDot=(IToken)Match(input,DOT,Follow._DOT_in_qualifiedIdentExpression13897); if (state.failed) return retval;
if (state.backtracking == 0) stream_DOT.Add(outerDot);
DebugLocation(951, 13);
// Java.g:951:13: ( CLASS -> ^( DOT qualifiedIdentifier CLASS ) | genericTypeArgumentListSimplified (Super= SUPER arguments -> ^( SUPER_CONSTRUCTOR_CALL[$Super, \"SUPER_CONSTRUCTOR_CALL\"] qualifiedIdentifier genericTypeArgumentListSimplified arguments ) | SUPER innerDot= DOT IDENT arguments -> ^( METHOD_CALL ^( $innerDot ^( $outerDot qualifiedIdentifier SUPER ) IDENT ) genericTypeArgumentListSimplified arguments ) | IDENT arguments -> ^( METHOD_CALL ^( DOT qualifiedIdentifier IDENT ) genericTypeArgumentListSimplified arguments ) ) | THIS -> ^( DOT qualifiedIdentifier THIS ) |Super= SUPER arguments -> ^( SUPER_CONSTRUCTOR_CALL[$Super, \"SUPER_CONSTRUCTOR_CALL\"] qualifiedIdentifier arguments ) | innerNewExpression -> ^( DOT qualifiedIdentifier innerNewExpression ) )
int alt142=5;
try { DebugEnterSubRule(142);
try { DebugEnterDecision(142, false);
switch (input.LA(1))
{
case CLASS:
{
alt142 = 1;
}
break;
case LESS_THAN:
{
alt142 = 2;
}
break;
case THIS:
{
alt142 = 3;
}
break;
case SUPER:
{
alt142 = 4;
}
break;
case NEW:
{
alt142 = 5;
}
break;
default:
{
if (state.backtracking>0) {state.failed=true; return retval;}
NoViableAltException nvae = new NoViableAltException("", 142, 0, input, 1);
DebugRecognitionException(nvae);
throw nvae;
}
}
} finally { DebugExitDecision(142); }
switch (alt142)
{
case 1:
DebugEnterAlt(1);
// Java.g:951:17: CLASS
{
DebugLocation(951, 17);
CLASS496=(IToken)Match(input,CLASS,Follow._CLASS_in_qualifiedIdentExpression13915); if (state.failed) return retval;
if (state.backtracking == 0) stream_CLASS.Add(CLASS496);
{
// AST REWRITE
// elements: DOT, qualifiedIdentifier, CLASS
// 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 = (CommonTree)adaptor.Nil();
// 951:57: -> ^( DOT qualifiedIdentifier CLASS )
{
DebugLocation(951, 61);
// Java.g:951:61: ^( DOT qualifiedIdentifier CLASS )
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(951, 63);
root_1 = (CommonTree)adaptor.BecomeRoot(stream_DOT.NextNode(), root_1);
DebugLocation(951, 67);
adaptor.AddChild(root_1, stream_qualifiedIdentifier.NextTree());
DebugLocation(951, 87);
adaptor.AddChild(root_1, stream_CLASS.NextNode());
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;
}
}
}
break;
case 2:
DebugEnterAlt(2);
// Java.g:952:17: genericTypeArgumentListSimplified (Super= SUPER arguments -> ^( SUPER_CONSTRUCTOR_CALL[$Super, \"SUPER_CONSTRUCTOR_CALL\"] qualifiedIdentifier genericTypeArgumentListSimplified arguments ) | SUPER innerDot= DOT IDENT arguments -> ^( METHOD_CALL ^( $innerDot ^( $outerDot qualifiedIdentifier SUPER ) IDENT ) genericTypeArgumentListSimplified arguments ) | IDENT arguments -> ^( METHOD_CALL ^( DOT qualifiedIdentifier IDENT ) genericTypeArgumentListSimplified arguments ) )
{
DebugLocation(952, 17);
PushFollow(Follow._genericTypeArgumentListSimplified_in_qualifiedIdentExpression13978);
genericTypeArgumentListSimplified497=genericTypeArgumentListSimplified();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_genericTypeArgumentListSimplified.Add(genericTypeArgumentListSimplified497.Tree);
DebugLocation(953, 17);
// Java.g:953:17: (Super= SUPER arguments -> ^( SUPER_CONSTRUCTOR_CALL[$Super, \"SUPER_CONSTRUCTOR_CALL\"] qualifiedIdentifier genericTypeArgumentListSimplified arguments ) | SUPER innerDot= DOT IDENT arguments -> ^( METHOD_CALL ^( $innerDot ^( $outerDot qualifiedIdentifier SUPER ) IDENT ) genericTypeArgumentListSimplified arguments ) | IDENT arguments -> ^( METHOD_CALL ^( DOT qualifiedIdentifier IDENT ) genericTypeArgumentListSimplified arguments ) )
int alt141=3;
try { DebugEnterSubRule(141);
try { DebugEnterDecision(141, false);
int LA141_1 = input.LA(1);
if ((LA141_1==SUPER))
{
int LA141_2 = input.LA(2);
if ((LA141_2==DOT))
{
alt141 = 2;
}
else if ((LA141_2==LPAREN))
{
alt141 = 1;
}
else
{
if (state.backtracking>0) {state.failed=true; return retval;}
NoViableAltException nvae = new NoViableAltException("", 141, 1, input, 2);
DebugRecognitionException(nvae);
throw nvae;
}
}
else if ((LA141_1==IDENT))
{
alt141 = 3;
}
else
{
if (state.backtracking>0) {state.failed=true; return retval;}
NoViableAltException nvae = new NoViableAltException("", 141, 0, input, 1);
DebugRecognitionException(nvae);
throw nvae;
}
} finally { DebugExitDecision(141); }
switch (alt141)
{
case 1:
DebugEnterAlt(1);
// Java.g:953:21: Super= SUPER arguments
{
DebugLocation(953, 26);
Super=(IToken)Match(input,SUPER,Follow._SUPER_in_qualifiedIdentExpression14003); if (state.failed) return retval;
if (state.backtracking == 0) stream_SUPER.Add(Super);
DebugLocation(953, 33);
PushFollow(Follow._arguments_in_qualifiedIdentExpression14005);
arguments498=arguments();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_arguments.Add(arguments498.Tree);
{
// AST REWRITE
// elements: qualifiedIdentifier, genericTypeArgumentListSimplified, arguments
// 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 = (CommonTree)adaptor.Nil();
// 953:57: -> ^( SUPER_CONSTRUCTOR_CALL[$Super, \"SUPER_CONSTRUCTOR_CALL\"] qualifiedIdentifier genericTypeArgumentListSimplified arguments )
{
DebugLocation(953, 61);
// Java.g:953:61: ^( SUPER_CONSTRUCTOR_CALL[$Super, \"SUPER_CONSTRUCTOR_CALL\"] qualifiedIdentifier genericTypeArgumentListSimplified arguments )
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(953, 63);
root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(SUPER_CONSTRUCTOR_CALL, Super, "SUPER_CONSTRUCTOR_CALL"), root_1);
DebugLocation(953, 120);
adaptor.AddChild(root_1, stream_qualifiedIdentifier.NextTree());
DebugLocation(953, 140);
adaptor.AddChild(root_1, stream_genericTypeArgumentListSimplified.NextTree());
DebugLocation(953, 174);
adaptor.AddChild(root_1, stream_arguments.NextTree());
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;
}
}
}
break;
case 2:
DebugEnterAlt(2);
// Java.g:954:21: SUPER innerDot= DOT IDENT arguments
{
DebugLocation(954, 21);
SUPER499=(IToken)Match(input,SUPER,Follow._SUPER_in_qualifiedIdentExpression14055); if (state.failed) return retval;
if (state.backtracking == 0) stream_SUPER.Add(SUPER499);
DebugLocation(954, 35);
innerDot=(IToken)Match(input,DOT,Follow._DOT_in_qualifiedIdentExpression14059); if (state.failed) return retval;
if (state.backtracking == 0) stream_DOT.Add(innerDot);
DebugLocation(954, 40);
IDENT500=(IToken)Match(input,IDENT,Follow._IDENT_in_qualifiedIdentExpression14061); if (state.failed) return retval;
if (state.backtracking == 0) stream_IDENT.Add(IDENT500);
DebugLocation(954, 46);
PushFollow(Follow._arguments_in_qualifiedIdentExpression14063);
arguments501=arguments();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_arguments.Add(arguments501.Tree);
{
// AST REWRITE
// elements: innerDot, outerDot, qualifiedIdentifier, SUPER, IDENT, genericTypeArgumentListSimplified, arguments
// token labels: innerDot, outerDot
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
if (state.backtracking == 0) {
retval.Tree = root_0;
RewriteRuleITokenStream stream_innerDot=new RewriteRuleITokenStream(adaptor,"token innerDot",innerDot);
RewriteRuleITokenStream stream_outerDot=new RewriteRuleITokenStream(adaptor,"token outerDot",outerDot);
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.Tree:null);
root_0 = (CommonTree)adaptor.Nil();
// 954:57: -> ^( METHOD_CALL ^( $innerDot ^( $outerDot qualifiedIdentifier SUPER ) IDENT ) genericTypeArgumentListSimplified arguments )
{
DebugLocation(954, 61);
// Java.g:954:61: ^( METHOD_CALL ^( $innerDot ^( $outerDot qualifiedIdentifier SUPER ) IDENT ) genericTypeArgumentListSimplified arguments )
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(954, 63);
root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(METHOD_CALL, "METHOD_CALL"), root_1);
DebugLocation(954, 75);
// Java.g:954:75: ^( $innerDot ^( $outerDot qualifiedIdentifier SUPER ) IDENT )
{
CommonTree root_2 = (CommonTree)adaptor.Nil();
DebugLocation(954, 78);
root_2 = (CommonTree)adaptor.BecomeRoot(stream_innerDot.NextNode(), root_2);
DebugLocation(954, 87);
// Java.g:954:87: ^( $outerDot qualifiedIdentifier SUPER )
{
CommonTree root_3 = (CommonTree)adaptor.Nil();
DebugLocation(954, 90);
root_3 = (CommonTree)adaptor.BecomeRoot(stream_outerDot.NextNode(), root_3);
DebugLocation(954, 99);
adaptor.AddChild(root_3, stream_qualifiedIdentifier.NextTree());
DebugLocation(954, 119);
adaptor.AddChild(root_3, stream_SUPER.NextNode());
adaptor.AddChild(root_2, root_3);
}
DebugLocation(954, 126);
adaptor.AddChild(root_2, stream_IDENT.NextNode());
adaptor.AddChild(root_1, root_2);
}
DebugLocation(954, 133);
adaptor.AddChild(root_1, stream_genericTypeArgumentListSimplified.NextTree());
DebugLocation(954, 167);
adaptor.AddChild(root_1, stream_arguments.NextTree());
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;
}
}
}
break;
case 3:
DebugEnterAlt(3);
// Java.g:955:21: IDENT arguments
{
DebugLocation(955, 21);
IDENT502=(IToken)Match(input,IDENT,Follow._IDENT_in_qualifiedIdentExpression14113); if (state.failed) return retval;
if (state.backtracking == 0) stream_IDENT.Add(IDENT502);
DebugLocation(955, 27);
PushFollow(Follow._arguments_in_qualifiedIdentExpression14115);
arguments503=arguments();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_arguments.Add(arguments503.Tree);
{
// AST REWRITE
// elements: DOT, qualifiedIdentifier, IDENT, genericTypeArgumentListSimplified, arguments
// 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 = (CommonTree)adaptor.Nil();
// 955:57: -> ^( METHOD_CALL ^( DOT qualifiedIdentifier IDENT ) genericTypeArgumentListSimplified arguments )
{
DebugLocation(955, 61);
// Java.g:955:61: ^( METHOD_CALL ^( DOT qualifiedIdentifier IDENT ) genericTypeArgumentListSimplified arguments )
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(955, 63);
root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(METHOD_CALL, "METHOD_CALL"), root_1);
DebugLocation(955, 75);
// Java.g:955:75: ^( DOT qualifiedIdentifier IDENT )
{
CommonTree root_2 = (CommonTree)adaptor.Nil();
DebugLocation(955, 77);
root_2 = (CommonTree)adaptor.BecomeRoot(stream_DOT.NextNode(), root_2);
DebugLocation(955, 81);
adaptor.AddChild(root_2, stream_qualifiedIdentifier.NextTree());
DebugLocation(955, 101);
adaptor.AddChild(root_2, stream_IDENT.NextNode());
adaptor.AddChild(root_1, root_2);
}
DebugLocation(955, 108);
adaptor.AddChild(root_1, stream_genericTypeArgumentListSimplified.NextTree());
DebugLocation(955, 142);
adaptor.AddChild(root_1, stream_arguments.NextTree());
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;
}
}
}
break;
}
} finally { DebugExitSubRule(141); }
}
break;
case 3:
DebugEnterAlt(3);
// Java.g:957:17: THIS
{
DebugLocation(957, 17);
THIS504=(IToken)Match(input,THIS,Follow._THIS_in_qualifiedIdentExpression14190); if (state.failed) return retval;
if (state.backtracking == 0) stream_THIS.Add(THIS504);
{
// AST REWRITE
// elements: DOT, qualifiedIdentifier, THIS
// 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 = (CommonTree)adaptor.Nil();
// 957:57: -> ^( DOT qualifiedIdentifier THIS )
{
DebugLocation(957, 61);
// Java.g:957:61: ^( DOT qualifiedIdentifier THIS )
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(957, 63);
root_1 = (CommonTree)adaptor.BecomeRoot(stream_DOT.NextNode(), root_1);
DebugLocation(957, 67);
adaptor.AddChild(root_1, stream_qualifiedIdentifier.NextTree());
DebugLocation(957, 87);
adaptor.AddChild(root_1, stream_THIS.NextNode());
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;
}
}
}
break;
case 4:
DebugEnterAlt(4);
// Java.g:958:17: Super= SUPER arguments
{
DebugLocation(958, 22);
Super=(IToken)Match(input,SUPER,Follow._SUPER_in_qualifiedIdentExpression14256); if (state.failed) return retval;
if (state.backtracking == 0) stream_SUPER.Add(Super);
DebugLocation(958, 29);
PushFollow(Follow._arguments_in_qualifiedIdentExpression14258);
arguments505=arguments();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_arguments.Add(arguments505.Tree);
{
// AST REWRITE
// elements: qualifiedIdentifier, arguments
// 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 = (CommonTree)adaptor.Nil();
// 958:57: -> ^( SUPER_CONSTRUCTOR_CALL[$Super, \"SUPER_CONSTRUCTOR_CALL\"] qualifiedIdentifier arguments )
{
DebugLocation(958, 61);
// Java.g:958:61: ^( SUPER_CONSTRUCTOR_CALL[$Super, \"SUPER_CONSTRUCTOR_CALL\"] qualifiedIdentifier arguments )
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(958, 63);
root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(SUPER_CONSTRUCTOR_CALL, Super, "SUPER_CONSTRUCTOR_CALL"), root_1);
DebugLocation(958, 120);
adaptor.AddChild(root_1, stream_qualifiedIdentifier.NextTree());
DebugLocation(958, 140);
adaptor.AddChild(root_1, stream_arguments.NextTree());
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;
}
}
}
break;
case 5:
DebugEnterAlt(5);
// Java.g:959:17: innerNewExpression
{
DebugLocation(959, 17);
PushFollow(Follow._innerNewExpression_in_qualifiedIdentExpression14306);
innerNewExpression506=innerNewExpression();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_innerNewExpression.Add(innerNewExpression506.Tree);
{
// AST REWRITE
// elements: DOT, qualifiedIdentifier, innerNewExpression
// 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 = (CommonTree)adaptor.Nil();
// 959:57: -> ^( DOT qualifiedIdentifier innerNewExpression )
{
DebugLocation(959, 61);
// Java.g:959:61: ^( DOT qualifiedIdentifier innerNewExpression )
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(959, 63);
root_1 = (CommonTree)adaptor.BecomeRoot(stream_DOT.NextNode(), root_1);
DebugLocation(959, 67);
adaptor.AddChild(root_1, stream_qualifiedIdentifier.NextTree());
DebugLocation(959, 87);
adaptor.AddChild(root_1, stream_innerNewExpression.NextTree());
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;
}
}
}
break;
}
} finally { DebugExitSubRule(142); }
}
break;
}
} finally { DebugExitSubRule(143); }
}
retval.Stop = (IToken)input.LT(-1);
if (state.backtracking == 0) {
retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
}
}
catch (RecognitionException re)
{
ReportError(re);
Recover(input,re);
retval.Tree = (CommonTree)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);
}
finally
{
TraceOut("qualifiedIdentExpression", 106);
LeaveRule("qualifiedIdentExpression", 106);
LeaveRule_qualifiedIdentExpression();
if (state.backtracking > 0) { Memoize(input, 106, qualifiedIdentExpression_StartIndex); }
}
DebugLocation(962, 4);
} finally { DebugExitRule(GrammarFileName, "qualifiedIdentExpression"); }
return retval;
}
private AstParserRuleReturnScope<CommonTree, IToken> primaryExpression()
{
EnterRule_primaryExpression();
EnterRule("primaryExpression", 105);
TraceIn("primaryExpression", 105);
AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>();
retval.Start = (IToken)input.LT(1);
int primaryExpression_StartIndex = input.Index;
CommonTree root_0 = default(CommonTree);
IToken SUPER467 = default(IToken);
IToken DOT469 = default(IToken);
IToken IDENT470 = default(IToken);
IToken IDENT472 = default(IToken);
IToken THIS474 = default(IToken);
IToken THIS476 = default(IToken);
IToken SUPER478 = default(IToken);
IToken SUPER480 = default(IToken);
IToken DOT481 = default(IToken);
IToken IDENT482 = default(IToken);
IToken DOT486 = default(IToken);
IToken CLASS487 = default(IToken);
IToken VOID488 = default(IToken);
IToken DOT489 = default(IToken);
IToken CLASS490 = default(IToken);
AstParserRuleReturnScope<CommonTree, IToken> parenthesizedExpression462 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> literal463 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> newExpression464 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> qualifiedIdentExpression465 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> genericTypeArgumentListSimplified466 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> arguments468 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> arguments471 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> arguments473 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> arguments475 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> arguments477 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> arguments479 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> arguments483 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> primitiveType484 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> arrayDeclarator485 = default(AstParserRuleReturnScope<CommonTree, IToken>);
CommonTree SUPER467_tree = default(CommonTree);
CommonTree DOT469_tree = default(CommonTree);
CommonTree IDENT470_tree = default(CommonTree);
CommonTree IDENT472_tree = default(CommonTree);
CommonTree THIS474_tree = default(CommonTree);
CommonTree THIS476_tree = default(CommonTree);
CommonTree SUPER478_tree = default(CommonTree);
CommonTree SUPER480_tree = default(CommonTree);
CommonTree DOT481_tree = default(CommonTree);
CommonTree IDENT482_tree = default(CommonTree);
CommonTree DOT486_tree = default(CommonTree);
CommonTree CLASS487_tree = default(CommonTree);
CommonTree VOID488_tree = default(CommonTree);
CommonTree DOT489_tree = default(CommonTree);
CommonTree CLASS490_tree = default(CommonTree);
RewriteRuleITokenStream stream_SUPER=new RewriteRuleITokenStream(adaptor,"token SUPER");
RewriteRuleITokenStream stream_DOT=new RewriteRuleITokenStream(adaptor,"token DOT");
RewriteRuleITokenStream stream_IDENT=new RewriteRuleITokenStream(adaptor,"token IDENT");
RewriteRuleITokenStream stream_THIS=new RewriteRuleITokenStream(adaptor,"token THIS");
RewriteRuleITokenStream stream_CLASS=new RewriteRuleITokenStream(adaptor,"token CLASS");
RewriteRuleITokenStream stream_VOID=new RewriteRuleITokenStream(adaptor,"token VOID");
RewriteRuleSubtreeStream stream_genericTypeArgumentListSimplified=new RewriteRuleSubtreeStream(adaptor,"rule genericTypeArgumentListSimplified");
RewriteRuleSubtreeStream stream_arguments=new RewriteRuleSubtreeStream(adaptor,"rule arguments");
RewriteRuleSubtreeStream stream_primitiveType=new RewriteRuleSubtreeStream(adaptor,"rule primitiveType");
RewriteRuleSubtreeStream stream_arrayDeclarator=new RewriteRuleSubtreeStream(adaptor,"rule arrayDeclarator");
try { DebugEnterRule(GrammarFileName, "primaryExpression");
DebugLocation(909, 4);
try
{
if (state.backtracking > 0 && AlreadyParsedRule(input, 105)) { return retval; }
// Java.g:910:5: ( parenthesizedExpression | literal | newExpression | qualifiedIdentExpression | genericTypeArgumentListSimplified ( SUPER ( arguments -> ^( SUPER_CONSTRUCTOR_CALL[$SUPER, \"SUPER_CONSTRUCTOR_CALL\"] genericTypeArgumentListSimplified arguments ) | DOT IDENT arguments -> ^( METHOD_CALL ^( DOT SUPER IDENT ) genericTypeArgumentListSimplified arguments ) ) | IDENT arguments -> ^( METHOD_CALL IDENT genericTypeArgumentListSimplified arguments ) | THIS arguments -> ^( THIS_CONSTRUCTOR_CALL[$THIS, \"THIS_CONSTRUCTOR_CALL\"] genericTypeArgumentListSimplified arguments ) ) | ( THIS -> THIS ) ( arguments -> ^( THIS_CONSTRUCTOR_CALL[$THIS, \"THIS_CONSTRUCTOR_CALL\"] arguments ) )? | SUPER arguments -> ^( SUPER_CONSTRUCTOR_CALL[$SUPER, \"SUPER_CONSTRUCTOR_CALL\"] arguments ) | ( SUPER DOT IDENT ) ( arguments -> ^( METHOD_CALL ^( DOT SUPER IDENT ) arguments ) | -> ^( DOT SUPER IDENT ) ) | ( primitiveType -> primitiveType ) ( arrayDeclarator -> ^( arrayDeclarator $primaryExpression) )* DOT CLASS -> ^( DOT $primaryExpression CLASS ) | VOID DOT CLASS -> ^( DOT VOID CLASS ) )
int alt139=10;
try { DebugEnterDecision(139, false);
switch (input.LA(1))
{
case LPAREN:
{
alt139 = 1;
}
break;
case CHARACTER_LITERAL:
case DECIMAL_LITERAL:
case FALSE:
case FLOATING_POINT_LITERAL:
case HEX_LITERAL:
case NULL:
case OCTAL_LITERAL:
case STRING_LITERAL:
case TRUE:
{
alt139 = 2;
}
break;
case NEW:
{
alt139 = 3;
}
break;
case IDENT:
{
alt139 = 4;
}
break;
case LESS_THAN:
{
alt139 = 5;
}
break;
case THIS:
{
alt139 = 6;
}
break;
case SUPER:
{
int LA139_2 = input.LA(2);
if ((LA139_2==DOT))
{
alt139 = 8;
}
else if ((LA139_2==LPAREN))
{
alt139 = 7;
}
else
{
if (state.backtracking>0) {state.failed=true; return retval;}
NoViableAltException nvae = new NoViableAltException("", 139, 7, input, 2);
DebugRecognitionException(nvae);
throw nvae;
}
}
break;
case BOOLEAN:
case BYTE:
case CHAR:
case DOUBLE:
case FLOAT:
case INT:
case LONG:
case SHORT:
{
alt139 = 9;
}
break;
case VOID:
{
alt139 = 10;
}
break;
default:
{
if (state.backtracking>0) {state.failed=true; return retval;}
NoViableAltException nvae = new NoViableAltException("", 139, 0, input, 1);
DebugRecognitionException(nvae);
throw nvae;
}
}
} finally { DebugExitDecision(139); }
switch (alt139)
{
case 1:
DebugEnterAlt(1);
// Java.g:910:9: parenthesizedExpression
{
root_0 = (CommonTree)adaptor.Nil();
DebugLocation(910, 9);
PushFollow(Follow._parenthesizedExpression_in_primaryExpression12669);
parenthesizedExpression462=parenthesizedExpression();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) adaptor.AddChild(root_0, parenthesizedExpression462.Tree);
}
break;
case 2:
DebugEnterAlt(2);
// Java.g:911:9: literal
{
root_0 = (CommonTree)adaptor.Nil();
DebugLocation(911, 9);
PushFollow(Follow._literal_in_primaryExpression12679);
literal463=literal();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) adaptor.AddChild(root_0, literal463.Tree);
}
break;
case 3:
DebugEnterAlt(3);
// Java.g:912:9: newExpression
{
root_0 = (CommonTree)adaptor.Nil();
DebugLocation(912, 9);
PushFollow(Follow._newExpression_in_primaryExpression12689);
newExpression464=newExpression();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) adaptor.AddChild(root_0, newExpression464.Tree);
}
break;
case 4:
DebugEnterAlt(4);
// Java.g:913:9: qualifiedIdentExpression
{
root_0 = (CommonTree)adaptor.Nil();
DebugLocation(913, 9);
PushFollow(Follow._qualifiedIdentExpression_in_primaryExpression12699);
qualifiedIdentExpression465=qualifiedIdentExpression();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) adaptor.AddChild(root_0, qualifiedIdentExpression465.Tree);
}
break;
case 5:
DebugEnterAlt(5);
// Java.g:914:9: genericTypeArgumentListSimplified ( SUPER ( arguments -> ^( SUPER_CONSTRUCTOR_CALL[$SUPER, \"SUPER_CONSTRUCTOR_CALL\"] genericTypeArgumentListSimplified arguments ) | DOT IDENT arguments -> ^( METHOD_CALL ^( DOT SUPER IDENT ) genericTypeArgumentListSimplified arguments ) ) | IDENT arguments -> ^( METHOD_CALL IDENT genericTypeArgumentListSimplified arguments ) | THIS arguments -> ^( THIS_CONSTRUCTOR_CALL[$THIS, \"THIS_CONSTRUCTOR_CALL\"] genericTypeArgumentListSimplified arguments ) )
{
DebugLocation(914, 9);
PushFollow(Follow._genericTypeArgumentListSimplified_in_primaryExpression12709);
genericTypeArgumentListSimplified466=genericTypeArgumentListSimplified();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_genericTypeArgumentListSimplified.Add(genericTypeArgumentListSimplified466.Tree);
DebugLocation(915, 9);
// Java.g:915:9: ( SUPER ( arguments -> ^( SUPER_CONSTRUCTOR_CALL[$SUPER, \"SUPER_CONSTRUCTOR_CALL\"] genericTypeArgumentListSimplified arguments ) | DOT IDENT arguments -> ^( METHOD_CALL ^( DOT SUPER IDENT ) genericTypeArgumentListSimplified arguments ) ) | IDENT arguments -> ^( METHOD_CALL IDENT genericTypeArgumentListSimplified arguments ) | THIS arguments -> ^( THIS_CONSTRUCTOR_CALL[$THIS, \"THIS_CONSTRUCTOR_CALL\"] genericTypeArgumentListSimplified arguments ) )
int alt135=3;
try { DebugEnterSubRule(135);
try { DebugEnterDecision(135, false);
switch (input.LA(1))
{
case SUPER:
{
alt135 = 1;
}
break;
case IDENT:
{
alt135 = 2;
}
break;
case THIS:
{
alt135 = 3;
}
break;
default:
{
if (state.backtracking>0) {state.failed=true; return retval;}
NoViableAltException nvae = new NoViableAltException("", 135, 0, input, 1);
DebugRecognitionException(nvae);
throw nvae;
}
}
} finally { DebugExitDecision(135); }
switch (alt135)
{
case 1:
DebugEnterAlt(1);
// Java.g:915:13: SUPER ( arguments -> ^( SUPER_CONSTRUCTOR_CALL[$SUPER, \"SUPER_CONSTRUCTOR_CALL\"] genericTypeArgumentListSimplified arguments ) | DOT IDENT arguments -> ^( METHOD_CALL ^( DOT SUPER IDENT ) genericTypeArgumentListSimplified arguments ) )
{
DebugLocation(915, 13);
SUPER467=(IToken)Match(input,SUPER,Follow._SUPER_in_primaryExpression12724); if (state.failed) return retval;
if (state.backtracking == 0) stream_SUPER.Add(SUPER467);
DebugLocation(916, 13);
// Java.g:916:13: ( arguments -> ^( SUPER_CONSTRUCTOR_CALL[$SUPER, \"SUPER_CONSTRUCTOR_CALL\"] genericTypeArgumentListSimplified arguments ) | DOT IDENT arguments -> ^( METHOD_CALL ^( DOT SUPER IDENT ) genericTypeArgumentListSimplified arguments ) )
int alt134=2;
try { DebugEnterSubRule(134);
try { DebugEnterDecision(134, false);
int LA134_1 = input.LA(1);
if ((LA134_1==LPAREN))
{
alt134 = 1;
}
else if ((LA134_1==DOT))
{
alt134 = 2;
}
else
{
if (state.backtracking>0) {state.failed=true; return retval;}
NoViableAltException nvae = new NoViableAltException("", 134, 0, input, 1);
DebugRecognitionException(nvae);
throw nvae;
}
} finally { DebugExitDecision(134); }
switch (alt134)
{
case 1:
DebugEnterAlt(1);
// Java.g:916:17: arguments
{
DebugLocation(916, 17);
PushFollow(Follow._arguments_in_primaryExpression12742);
arguments468=arguments();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_arguments.Add(arguments468.Tree);
{
// AST REWRITE
// elements: genericTypeArgumentListSimplified, arguments
// 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 = (CommonTree)adaptor.Nil();
// 916:57: -> ^( SUPER_CONSTRUCTOR_CALL[$SUPER, \"SUPER_CONSTRUCTOR_CALL\"] genericTypeArgumentListSimplified arguments )
{
DebugLocation(916, 61);
// Java.g:916:61: ^( SUPER_CONSTRUCTOR_CALL[$SUPER, \"SUPER_CONSTRUCTOR_CALL\"] genericTypeArgumentListSimplified arguments )
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(916, 63);
root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(SUPER_CONSTRUCTOR_CALL, SUPER467, "SUPER_CONSTRUCTOR_CALL"), root_1);
DebugLocation(916, 120);
adaptor.AddChild(root_1, stream_genericTypeArgumentListSimplified.NextTree());
DebugLocation(916, 154);
adaptor.AddChild(root_1, stream_arguments.NextTree());
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;
}
}
}
break;
case 2:
DebugEnterAlt(2);
// Java.g:917:17: DOT IDENT arguments
{
DebugLocation(917, 17);
DOT469=(IToken)Match(input,DOT,Follow._DOT_in_primaryExpression12802); if (state.failed) return retval;
if (state.backtracking == 0) stream_DOT.Add(DOT469);
DebugLocation(917, 21);
IDENT470=(IToken)Match(input,IDENT,Follow._IDENT_in_primaryExpression12804); if (state.failed) return retval;
if (state.backtracking == 0) stream_IDENT.Add(IDENT470);
DebugLocation(917, 27);
PushFollow(Follow._arguments_in_primaryExpression12806);
arguments471=arguments();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_arguments.Add(arguments471.Tree);
{
// AST REWRITE
// elements: DOT, SUPER, IDENT, genericTypeArgumentListSimplified, arguments
// 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 = (CommonTree)adaptor.Nil();
// 917:57: -> ^( METHOD_CALL ^( DOT SUPER IDENT ) genericTypeArgumentListSimplified arguments )
{
DebugLocation(917, 61);
// Java.g:917:61: ^( METHOD_CALL ^( DOT SUPER IDENT ) genericTypeArgumentListSimplified arguments )
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(917, 63);
root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(METHOD_CALL, "METHOD_CALL"), root_1);
DebugLocation(917, 75);
// Java.g:917:75: ^( DOT SUPER IDENT )
{
CommonTree root_2 = (CommonTree)adaptor.Nil();
DebugLocation(917, 77);
root_2 = (CommonTree)adaptor.BecomeRoot(stream_DOT.NextNode(), root_2);
DebugLocation(917, 81);
adaptor.AddChild(root_2, stream_SUPER.NextNode());
DebugLocation(917, 87);
adaptor.AddChild(root_2, stream_IDENT.NextNode());
adaptor.AddChild(root_1, root_2);
}
DebugLocation(917, 94);
adaptor.AddChild(root_1, stream_genericTypeArgumentListSimplified.NextTree());
DebugLocation(917, 128);
adaptor.AddChild(root_1, stream_arguments.NextTree());
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;
}
}
}
break;
}
} finally { DebugExitSubRule(134); }
}
break;
case 2:
DebugEnterAlt(2);
// Java.g:919:13: IDENT arguments
{
DebugLocation(919, 13);
IDENT472=(IToken)Match(input,IDENT,Follow._IDENT_in_primaryExpression12873); if (state.failed) return retval;
if (state.backtracking == 0) stream_IDENT.Add(IDENT472);
DebugLocation(919, 19);
PushFollow(Follow._arguments_in_primaryExpression12875);
arguments473=arguments();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_arguments.Add(arguments473.Tree);
{
// AST REWRITE
// elements: IDENT, genericTypeArgumentListSimplified, arguments
// 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 = (CommonTree)adaptor.Nil();
// 919:57: -> ^( METHOD_CALL IDENT genericTypeArgumentListSimplified arguments )
{
DebugLocation(919, 61);
// Java.g:919:61: ^( METHOD_CALL IDENT genericTypeArgumentListSimplified arguments )
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(919, 63);
root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(METHOD_CALL, "METHOD_CALL"), root_1);
DebugLocation(919, 75);
adaptor.AddChild(root_1, stream_IDENT.NextNode());
DebugLocation(919, 81);
adaptor.AddChild(root_1, stream_genericTypeArgumentListSimplified.NextTree());
DebugLocation(919, 115);
adaptor.AddChild(root_1, stream_arguments.NextTree());
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;
}
}
}
break;
case 3:
DebugEnterAlt(3);
// Java.g:920:13: THIS arguments
{
DebugLocation(920, 13);
THIS474=(IToken)Match(input,THIS,Follow._THIS_in_primaryExpression12930); if (state.failed) return retval;
if (state.backtracking == 0) stream_THIS.Add(THIS474);
DebugLocation(920, 18);
PushFollow(Follow._arguments_in_primaryExpression12932);
arguments475=arguments();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_arguments.Add(arguments475.Tree);
{
// AST REWRITE
// elements: genericTypeArgumentListSimplified, arguments
// 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 = (CommonTree)adaptor.Nil();
// 920:57: -> ^( THIS_CONSTRUCTOR_CALL[$THIS, \"THIS_CONSTRUCTOR_CALL\"] genericTypeArgumentListSimplified arguments )
{
DebugLocation(920, 61);
// Java.g:920:61: ^( THIS_CONSTRUCTOR_CALL[$THIS, \"THIS_CONSTRUCTOR_CALL\"] genericTypeArgumentListSimplified arguments )
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(920, 63);
root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(THIS_CONSTRUCTOR_CALL, THIS474, "THIS_CONSTRUCTOR_CALL"), root_1);
DebugLocation(920, 117);
adaptor.AddChild(root_1, stream_genericTypeArgumentListSimplified.NextTree());
DebugLocation(920, 151);
adaptor.AddChild(root_1, stream_arguments.NextTree());
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;
}
}
}
break;
}
} finally { DebugExitSubRule(135); }
}
break;
case 6:
DebugEnterAlt(6);
// Java.g:922:9: ( THIS -> THIS ) ( arguments -> ^( THIS_CONSTRUCTOR_CALL[$THIS, \"THIS_CONSTRUCTOR_CALL\"] arguments ) )?
{
DebugLocation(922, 9);
// Java.g:922:9: ( THIS -> THIS )
DebugEnterAlt(1);
// Java.g:922:13: THIS
{
DebugLocation(922, 13);
THIS476=(IToken)Match(input,THIS,Follow._THIS_in_primaryExpression12997); if (state.failed) return retval;
if (state.backtracking == 0) stream_THIS.Add(THIS476);
{
// AST REWRITE
// elements: THIS
// 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 = (CommonTree)adaptor.Nil();
// 922:57: -> THIS
{
DebugLocation(922, 61);
adaptor.AddChild(root_0, stream_THIS.NextNode());
}
retval.Tree = root_0;
}
}
}
DebugLocation(924, 9);
// Java.g:924:9: ( arguments -> ^( THIS_CONSTRUCTOR_CALL[$THIS, \"THIS_CONSTRUCTOR_CALL\"] arguments ) )?
int alt136=2;
try { DebugEnterSubRule(136);
try { DebugEnterDecision(136, false);
int LA136_1 = input.LA(1);
if ((LA136_1==LPAREN))
{
alt136 = 1;
}
} finally { DebugExitDecision(136); }
switch (alt136)
{
case 1:
DebugEnterAlt(1);
// Java.g:924:13: arguments
{
DebugLocation(924, 13);
PushFollow(Follow._arguments_in_primaryExpression13065);
arguments477=arguments();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_arguments.Add(arguments477.Tree);
{
// AST REWRITE
// elements: arguments
// 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 = (CommonTree)adaptor.Nil();
// 924:57: -> ^( THIS_CONSTRUCTOR_CALL[$THIS, \"THIS_CONSTRUCTOR_CALL\"] arguments )
{
DebugLocation(924, 61);
// Java.g:924:61: ^( THIS_CONSTRUCTOR_CALL[$THIS, \"THIS_CONSTRUCTOR_CALL\"] arguments )
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(924, 63);
root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(THIS_CONSTRUCTOR_CALL, THIS476, "THIS_CONSTRUCTOR_CALL"), root_1);
DebugLocation(924, 117);
adaptor.AddChild(root_1, stream_arguments.NextTree());
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;
}
}
}
break;
}
} finally { DebugExitSubRule(136); }
}
break;
case 7:
DebugEnterAlt(7);
// Java.g:926:9: SUPER arguments
{
DebugLocation(926, 9);
SUPER478=(IToken)Match(input,SUPER,Follow._SUPER_in_primaryExpression13130); if (state.failed) return retval;
if (state.backtracking == 0) stream_SUPER.Add(SUPER478);
DebugLocation(926, 15);
PushFollow(Follow._arguments_in_primaryExpression13132);
arguments479=arguments();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_arguments.Add(arguments479.Tree);
{
// AST REWRITE
// elements: arguments
// 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 = (CommonTree)adaptor.Nil();
// 926:57: -> ^( SUPER_CONSTRUCTOR_CALL[$SUPER, \"SUPER_CONSTRUCTOR_CALL\"] arguments )
{
DebugLocation(926, 61);
// Java.g:926:61: ^( SUPER_CONSTRUCTOR_CALL[$SUPER, \"SUPER_CONSTRUCTOR_CALL\"] arguments )
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(926, 63);
root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(SUPER_CONSTRUCTOR_CALL, SUPER478, "SUPER_CONSTRUCTOR_CALL"), root_1);
DebugLocation(926, 120);
adaptor.AddChild(root_1, stream_arguments.NextTree());
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;
}
}
}
break;
case 8:
DebugEnterAlt(8);
// Java.g:927:9: ( SUPER DOT IDENT ) ( arguments -> ^( METHOD_CALL ^( DOT SUPER IDENT ) arguments ) | -> ^( DOT SUPER IDENT ) )
{
DebugLocation(927, 9);
// Java.g:927:9: ( SUPER DOT IDENT )
DebugEnterAlt(1);
// Java.g:927:13: SUPER DOT IDENT
{
DebugLocation(927, 13);
SUPER480=(IToken)Match(input,SUPER,Follow._SUPER_in_primaryExpression13188); if (state.failed) return retval;
if (state.backtracking == 0) stream_SUPER.Add(SUPER480);
DebugLocation(927, 19);
DOT481=(IToken)Match(input,DOT,Follow._DOT_in_primaryExpression13190); if (state.failed) return retval;
if (state.backtracking == 0) stream_DOT.Add(DOT481);
DebugLocation(927, 23);
IDENT482=(IToken)Match(input,IDENT,Follow._IDENT_in_primaryExpression13192); if (state.failed) return retval;
if (state.backtracking == 0) stream_IDENT.Add(IDENT482);
}
DebugLocation(929, 9);
// Java.g:929:9: ( arguments -> ^( METHOD_CALL ^( DOT SUPER IDENT ) arguments ) | -> ^( DOT SUPER IDENT ) )
int alt137=2;
try { DebugEnterSubRule(137);
try { DebugEnterDecision(137, false);
int LA137_1 = input.LA(1);
if ((LA137_1==LPAREN))
{
alt137 = 1;
}
else if ((LA137_1==EOF||(LA137_1>=AND && LA137_1<=AND_ASSIGN)||LA137_1==ASSIGN||(LA137_1>=BIT_SHIFT_RIGHT && LA137_1<=BIT_SHIFT_RIGHT_ASSIGN)||(LA137_1>=COLON && LA137_1<=COMMA)||LA137_1==DEC||(LA137_1>=DIV && LA137_1<=DIV_ASSIGN)||LA137_1==DOT||LA137_1==EQUAL||(LA137_1>=GREATER_OR_EQUAL && LA137_1<=GREATER_THAN)||(LA137_1>=INC && LA137_1<=INSTANCEOF)||LA137_1==LBRACK||(LA137_1>=LESS_OR_EQUAL && LA137_1<=LESS_THAN)||LA137_1==LOGICAL_AND||LA137_1==LOGICAL_OR||(LA137_1>=MINUS && LA137_1<=MOD)||LA137_1==MOD_ASSIGN||LA137_1==NOT_EQUAL||(LA137_1>=OR && LA137_1<=OR_ASSIGN)||(LA137_1>=PLUS && LA137_1<=PLUS_ASSIGN)||(LA137_1>=QUESTION && LA137_1<=RCURLY)||(LA137_1>=RPAREN && LA137_1<=SHIFT_RIGHT_ASSIGN)||(LA137_1>=STAR && LA137_1<=STAR_ASSIGN)||(LA137_1>=XOR && LA137_1<=XOR_ASSIGN)))
{
alt137 = 2;
}
else
{
if (state.backtracking>0) {state.failed=true; return retval;}
NoViableAltException nvae = new NoViableAltException("", 137, 0, input, 1);
DebugRecognitionException(nvae);
throw nvae;
}
} finally { DebugExitDecision(137); }
switch (alt137)
{
case 1:
DebugEnterAlt(1);
// Java.g:929:13: arguments
{
DebugLocation(929, 13);
PushFollow(Follow._arguments_in_primaryExpression13216);
arguments483=arguments();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_arguments.Add(arguments483.Tree);
{
// AST REWRITE
// elements: DOT, SUPER, IDENT, arguments
// 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 = (CommonTree)adaptor.Nil();
// 929:57: -> ^( METHOD_CALL ^( DOT SUPER IDENT ) arguments )
{
DebugLocation(929, 61);
// Java.g:929:61: ^( METHOD_CALL ^( DOT SUPER IDENT ) arguments )
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(929, 63);
root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(METHOD_CALL, "METHOD_CALL"), root_1);
DebugLocation(929, 75);
// Java.g:929:75: ^( DOT SUPER IDENT )
{
CommonTree root_2 = (CommonTree)adaptor.Nil();
DebugLocation(929, 77);
root_2 = (CommonTree)adaptor.BecomeRoot(stream_DOT.NextNode(), root_2);
DebugLocation(929, 81);
adaptor.AddChild(root_2, stream_SUPER.NextNode());
DebugLocation(929, 87);
adaptor.AddChild(root_2, stream_IDENT.NextNode());
adaptor.AddChild(root_1, root_2);
}
DebugLocation(929, 94);
adaptor.AddChild(root_1, stream_arguments.NextTree());
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;
}
}
}
break;
case 2:
DebugEnterAlt(2);
// Java.g:930:57:
{
{
// AST REWRITE
// elements: DOT, SUPER, IDENT
// 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 = (CommonTree)adaptor.Nil();
// 930:57: -> ^( DOT SUPER IDENT )
{
DebugLocation(930, 61);
// Java.g:930:61: ^( DOT SUPER IDENT )
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(930, 63);
root_1 = (CommonTree)adaptor.BecomeRoot(stream_DOT.NextNode(), root_1);
DebugLocation(930, 67);
adaptor.AddChild(root_1, stream_SUPER.NextNode());
DebugLocation(930, 73);
adaptor.AddChild(root_1, stream_IDENT.NextNode());
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;
}
}
}
break;
}
} finally { DebugExitSubRule(137); }
}
break;
case 9:
DebugEnterAlt(9);
// Java.g:932:9: ( primitiveType -> primitiveType ) ( arrayDeclarator -> ^( arrayDeclarator $primaryExpression) )* DOT CLASS
{
DebugLocation(932, 9);
// Java.g:932:9: ( primitiveType -> primitiveType )
DebugEnterAlt(1);
// Java.g:932:13: primitiveType
{
DebugLocation(932, 13);
PushFollow(Follow._primitiveType_in_primaryExpression13358);
primitiveType484=primitiveType();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_primitiveType.Add(primitiveType484.Tree);
{
// AST REWRITE
// elements: primitiveType
// 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 = (CommonTree)adaptor.Nil();
// 932:57: -> primitiveType
{
DebugLocation(932, 61);
adaptor.AddChild(root_0, stream_primitiveType.NextTree());
}
retval.Tree = root_0;
}
}
}
DebugLocation(934, 9);
// Java.g:934:9: ( arrayDeclarator -> ^( arrayDeclarator $primaryExpression) )*
try { DebugEnterSubRule(138);
while (true)
{
int alt138=2;
try { DebugEnterDecision(138, false);
int LA138_1 = input.LA(1);
if ((LA138_1==LBRACK))
{
alt138 = 1;
}
} finally { DebugExitDecision(138); }
switch ( alt138 )
{
case 1:
DebugEnterAlt(1);
// Java.g:934:13: arrayDeclarator
{
DebugLocation(934, 13);
PushFollow(Follow._arrayDeclarator_in_primaryExpression13417);
arrayDeclarator485=arrayDeclarator();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_arrayDeclarator.Add(arrayDeclarator485.Tree);
{
// AST REWRITE
// elements: arrayDeclarator, primaryExpression
// 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 = (CommonTree)adaptor.Nil();
// 934:57: -> ^( arrayDeclarator $primaryExpression)
{
DebugLocation(934, 61);
// Java.g:934:61: ^( arrayDeclarator $primaryExpression)
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(934, 63);
root_1 = (CommonTree)adaptor.BecomeRoot(stream_arrayDeclarator.NextNode(), root_1);
DebugLocation(934, 80);
adaptor.AddChild(root_1, stream_retval.NextTree());
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;
}
}
}
break;
default:
goto loop138;
}
}
loop138:
;
} finally { DebugExitSubRule(138); }
DebugLocation(936, 9);
DOT486=(IToken)Match(input,DOT,Follow._DOT_in_primaryExpression13480); if (state.failed) return retval;
if (state.backtracking == 0) stream_DOT.Add(DOT486);
DebugLocation(936, 13);
CLASS487=(IToken)Match(input,CLASS,Follow._CLASS_in_primaryExpression13482); if (state.failed) return retval;
if (state.backtracking == 0) stream_CLASS.Add(CLASS487);
{
// AST REWRITE
// elements: DOT, primaryExpression, CLASS
// 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 = (CommonTree)adaptor.Nil();
// 936:57: -> ^( DOT $primaryExpression CLASS )
{
DebugLocation(936, 61);
// Java.g:936:61: ^( DOT $primaryExpression CLASS )
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(936, 63);
root_1 = (CommonTree)adaptor.BecomeRoot(stream_DOT.NextNode(), root_1);
DebugLocation(936, 68);
adaptor.AddChild(root_1, stream_retval.NextTree());
DebugLocation(936, 86);
adaptor.AddChild(root_1, stream_CLASS.NextNode());
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;
}
}
}
break;
case 10:
DebugEnterAlt(10);
// Java.g:937:9: VOID DOT CLASS
{
DebugLocation(937, 9);
VOID488=(IToken)Match(input,VOID,Follow._VOID_in_primaryExpression13542); if (state.failed) return retval;
if (state.backtracking == 0) stream_VOID.Add(VOID488);
DebugLocation(937, 14);
DOT489=(IToken)Match(input,DOT,Follow._DOT_in_primaryExpression13544); if (state.failed) return retval;
if (state.backtracking == 0) stream_DOT.Add(DOT489);
DebugLocation(937, 18);
CLASS490=(IToken)Match(input,CLASS,Follow._CLASS_in_primaryExpression13546); if (state.failed) return retval;
if (state.backtracking == 0) stream_CLASS.Add(CLASS490);
{
// AST REWRITE
// elements: DOT, VOID, CLASS
// 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 = (CommonTree)adaptor.Nil();
// 937:57: -> ^( DOT VOID CLASS )
{
DebugLocation(937, 61);
// Java.g:937:61: ^( DOT VOID CLASS )
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(937, 63);
root_1 = (CommonTree)adaptor.BecomeRoot(stream_DOT.NextNode(), root_1);
DebugLocation(937, 67);
adaptor.AddChild(root_1, stream_VOID.NextNode());
DebugLocation(937, 72);
adaptor.AddChild(root_1, stream_CLASS.NextNode());
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;
}
}
}
break;
}
retval.Stop = (IToken)input.LT(-1);
if (state.backtracking == 0) {
retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
}
}
catch (RecognitionException re)
{
ReportError(re);
Recover(input,re);
retval.Tree = (CommonTree)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);
}
finally
{
TraceOut("primaryExpression", 105);
LeaveRule("primaryExpression", 105);
LeaveRule_primaryExpression();
if (state.backtracking > 0) { Memoize(input, 105, primaryExpression_StartIndex); }
}
DebugLocation(938, 4);
} finally { DebugExitRule(GrammarFileName, "primaryExpression"); }
return retval;
}
// $ANTLR start "expr"
// MathExpr.g:188:1: expr : ( BEGIN exprList END -> ^( BLOCK ( exprList )? ) | idar allassign term | IF term expr ( ELSE expr )? | WHILE term expr | FOR ( VAR IDENT ASSIGN term )? ';' ( compare )? ';' ( groupExpr )? expr -> ^( FOR ( ^( VAR ^( IDENT TYPE ^( ASSIGN term ) ) ) )? ( compare )? ( groupExpr )? expr ) | LET idar ( ':' type )? ( ASSIGN returnValue )? ( ',' idar ( ':' type )? ( ASSIGN returnValue )? )* -> ^( LET ( ^( idar ^( TYPE ( type )? ) ( ^( ASSIGN returnValue ) )? ) )* ) | VAR var_element ( ',' var_element )* -> ^( VAR ( var_element )* ) | FOR ( VAR )? IDENT IN term '...' term expr | PRINT '(' ( STRINGVAL | idar ) ')' | groupExpr | REPEATE expr WHILE term -> ^( REPEATE term expr ) | FUNC IDENT '(' ( func_params )? ')' ( '->' type )? expr -> ^( FUNC IDENT ^( FUNC_PARAM ( func_params )? ) ^( TYPE ( type )? ) expr ) | RETURN ( returnValue | arrayValue ) -> ^( RETURN ( returnValue )? ( ^( ARRAY arrayValue ) )? ) | SWITCH IDENT '{' ( swcase )* ( DEFAULT ':' expr )? '}' -> ^( SWITCH IDENT ( swcase )* ( DEFAULT expr )? ) );
public MathExprParser.expr_return expr() // throws RecognitionException [1]
{
MathExprParser.expr_return retval = new MathExprParser.expr_return();
retval.Start = input.LT(1);
int expr_StartIndex = input.Index();
AstNode root_0 = null;
IToken BEGIN97 = null;
IToken END99 = null;
IToken IF103 = null;
IToken ELSE106 = null;
IToken WHILE108 = null;
IToken FOR111 = null;
IToken VAR112 = null;
IToken IDENT113 = null;
IToken ASSIGN114 = null;
IToken char_literal116 = null;
IToken char_literal118 = null;
IToken LET121 = null;
IToken char_literal123 = null;
IToken ASSIGN125 = null;
IToken char_literal127 = null;
IToken char_literal129 = null;
IToken ASSIGN131 = null;
IToken VAR133 = null;
IToken char_literal135 = null;
IToken FOR137 = null;
IToken VAR138 = null;
IToken IDENT139 = null;
IToken IN140 = null;
IToken string_literal142 = null;
IToken PRINT145 = null;
IToken char_literal146 = null;
IToken STRINGVAL147 = null;
IToken char_literal149 = null;
IToken REPEATE151 = null;
IToken WHILE153 = null;
IToken FUNC155 = null;
IToken IDENT156 = null;
IToken char_literal157 = null;
IToken char_literal159 = null;
IToken string_literal160 = null;
IToken RETURN163 = null;
IToken SWITCH166 = null;
IToken IDENT167 = null;
IToken char_literal168 = null;
IToken DEFAULT170 = null;
IToken char_literal171 = null;
IToken char_literal173 = null;
MathExprParser.exprList_return exprList98 = default(MathExprParser.exprList_return);
MathExprParser.idar_return idar100 = default(MathExprParser.idar_return);
MathExprParser.allassign_return allassign101 = default(MathExprParser.allassign_return);
MathExprParser.term_return term102 = default(MathExprParser.term_return);
MathExprParser.term_return term104 = default(MathExprParser.term_return);
MathExprParser.expr_return expr105 = default(MathExprParser.expr_return);
MathExprParser.expr_return expr107 = default(MathExprParser.expr_return);
MathExprParser.term_return term109 = default(MathExprParser.term_return);
MathExprParser.expr_return expr110 = default(MathExprParser.expr_return);
MathExprParser.term_return term115 = default(MathExprParser.term_return);
MathExprParser.compare_return compare117 = default(MathExprParser.compare_return);
MathExprParser.groupExpr_return groupExpr119 = default(MathExprParser.groupExpr_return);
MathExprParser.expr_return expr120 = default(MathExprParser.expr_return);
MathExprParser.idar_return idar122 = default(MathExprParser.idar_return);
MathExprParser.type_return type124 = default(MathExprParser.type_return);
MathExprParser.returnValue_return returnValue126 = default(MathExprParser.returnValue_return);
MathExprParser.idar_return idar128 = default(MathExprParser.idar_return);
MathExprParser.type_return type130 = default(MathExprParser.type_return);
MathExprParser.returnValue_return returnValue132 = default(MathExprParser.returnValue_return);
MathExprParser.var_element_return var_element134 = default(MathExprParser.var_element_return);
MathExprParser.var_element_return var_element136 = default(MathExprParser.var_element_return);
MathExprParser.term_return term141 = default(MathExprParser.term_return);
MathExprParser.term_return term143 = default(MathExprParser.term_return);
MathExprParser.expr_return expr144 = default(MathExprParser.expr_return);
MathExprParser.idar_return idar148 = default(MathExprParser.idar_return);
MathExprParser.groupExpr_return groupExpr150 = default(MathExprParser.groupExpr_return);
MathExprParser.expr_return expr152 = default(MathExprParser.expr_return);
MathExprParser.term_return term154 = default(MathExprParser.term_return);
MathExprParser.func_params_return func_params158 = default(MathExprParser.func_params_return);
MathExprParser.type_return type161 = default(MathExprParser.type_return);
MathExprParser.expr_return expr162 = default(MathExprParser.expr_return);
MathExprParser.returnValue_return returnValue164 = default(MathExprParser.returnValue_return);
MathExprParser.arrayValue_return arrayValue165 = default(MathExprParser.arrayValue_return);
MathExprParser.swcase_return swcase169 = default(MathExprParser.swcase_return);
MathExprParser.expr_return expr172 = default(MathExprParser.expr_return);
AstNode BEGIN97_tree=null;
AstNode END99_tree=null;
AstNode IF103_tree=null;
AstNode ELSE106_tree=null;
AstNode WHILE108_tree=null;
AstNode FOR111_tree=null;
AstNode VAR112_tree=null;
AstNode IDENT113_tree=null;
AstNode ASSIGN114_tree=null;
AstNode char_literal116_tree=null;
AstNode char_literal118_tree=null;
AstNode LET121_tree=null;
AstNode char_literal123_tree=null;
AstNode ASSIGN125_tree=null;
AstNode char_literal127_tree=null;
AstNode char_literal129_tree=null;
AstNode ASSIGN131_tree=null;
AstNode VAR133_tree=null;
AstNode char_literal135_tree=null;
AstNode FOR137_tree=null;
AstNode VAR138_tree=null;
AstNode IDENT139_tree=null;
AstNode IN140_tree=null;
AstNode string_literal142_tree=null;
AstNode PRINT145_tree=null;
AstNode char_literal146_tree=null;
AstNode STRINGVAL147_tree=null;
AstNode char_literal149_tree=null;
AstNode REPEATE151_tree=null;
AstNode WHILE153_tree=null;
AstNode FUNC155_tree=null;
AstNode IDENT156_tree=null;
AstNode char_literal157_tree=null;
AstNode char_literal159_tree=null;
AstNode string_literal160_tree=null;
AstNode RETURN163_tree=null;
AstNode SWITCH166_tree=null;
AstNode IDENT167_tree=null;
AstNode char_literal168_tree=null;
AstNode DEFAULT170_tree=null;
AstNode char_literal171_tree=null;
AstNode char_literal173_tree=null;
RewriteRuleTokenStream stream_77 = new RewriteRuleTokenStream(adaptor,"token 77");
RewriteRuleTokenStream stream_79 = new RewriteRuleTokenStream(adaptor,"token 79");
RewriteRuleTokenStream stream_FUNC = new RewriteRuleTokenStream(adaptor,"token FUNC");
RewriteRuleTokenStream stream_VAR = new RewriteRuleTokenStream(adaptor,"token VAR");
RewriteRuleTokenStream stream_FOR = new RewriteRuleTokenStream(adaptor,"token FOR");
RewriteRuleTokenStream stream_BEGIN = new RewriteRuleTokenStream(adaptor,"token BEGIN");
RewriteRuleTokenStream stream_ASSIGN = new RewriteRuleTokenStream(adaptor,"token ASSIGN");
RewriteRuleTokenStream stream_REPEATE = new RewriteRuleTokenStream(adaptor,"token REPEATE");
RewriteRuleTokenStream stream_RETURN = new RewriteRuleTokenStream(adaptor,"token RETURN");
RewriteRuleTokenStream stream_IDENT = new RewriteRuleTokenStream(adaptor,"token IDENT");
RewriteRuleTokenStream stream_END = new RewriteRuleTokenStream(adaptor,"token END");
RewriteRuleTokenStream stream_LET = new RewriteRuleTokenStream(adaptor,"token LET");
RewriteRuleTokenStream stream_WHILE = new RewriteRuleTokenStream(adaptor,"token WHILE");
RewriteRuleTokenStream stream_SWITCH = new RewriteRuleTokenStream(adaptor,"token SWITCH");
RewriteRuleTokenStream stream_72 = new RewriteRuleTokenStream(adaptor,"token 72");
RewriteRuleTokenStream stream_73 = new RewriteRuleTokenStream(adaptor,"token 73");
RewriteRuleTokenStream stream_74 = new RewriteRuleTokenStream(adaptor,"token 74");
RewriteRuleTokenStream stream_75 = new RewriteRuleTokenStream(adaptor,"token 75");
RewriteRuleTokenStream stream_DEFAULT = new RewriteRuleTokenStream(adaptor,"token DEFAULT");
RewriteRuleSubtreeStream stream_groupExpr = new RewriteRuleSubtreeStream(adaptor,"rule groupExpr");
RewriteRuleSubtreeStream stream_compare = new RewriteRuleSubtreeStream(adaptor,"rule compare");
RewriteRuleSubtreeStream stream_returnValue = new RewriteRuleSubtreeStream(adaptor,"rule returnValue");
RewriteRuleSubtreeStream stream_func_params = new RewriteRuleSubtreeStream(adaptor,"rule func_params");
RewriteRuleSubtreeStream stream_exprList = new RewriteRuleSubtreeStream(adaptor,"rule exprList");
RewriteRuleSubtreeStream stream_term = new RewriteRuleSubtreeStream(adaptor,"rule term");
RewriteRuleSubtreeStream stream_expr = new RewriteRuleSubtreeStream(adaptor,"rule expr");
RewriteRuleSubtreeStream stream_arrayValue = new RewriteRuleSubtreeStream(adaptor,"rule arrayValue");
RewriteRuleSubtreeStream stream_type = new RewriteRuleSubtreeStream(adaptor,"rule type");
RewriteRuleSubtreeStream stream_swcase = new RewriteRuleSubtreeStream(adaptor,"rule swcase");
RewriteRuleSubtreeStream stream_idar = new RewriteRuleSubtreeStream(adaptor,"rule idar");
RewriteRuleSubtreeStream stream_var_element = new RewriteRuleSubtreeStream(adaptor,"rule var_element");
try
{
if ( (state.backtracking > 0) && AlreadyParsedRule(input, 24) )
{
return retval;
}
// MathExpr.g:188:5: ( BEGIN exprList END -> ^( BLOCK ( exprList )? ) | idar allassign term | IF term expr ( ELSE expr )? | WHILE term expr | FOR ( VAR IDENT ASSIGN term )? ';' ( compare )? ';' ( groupExpr )? expr -> ^( FOR ( ^( VAR ^( IDENT TYPE ^( ASSIGN term ) ) ) )? ( compare )? ( groupExpr )? expr ) | LET idar ( ':' type )? ( ASSIGN returnValue )? ( ',' idar ( ':' type )? ( ASSIGN returnValue )? )* -> ^( LET ( ^( idar ^( TYPE ( type )? ) ( ^( ASSIGN returnValue ) )? ) )* ) | VAR var_element ( ',' var_element )* -> ^( VAR ( var_element )* ) | FOR ( VAR )? IDENT IN term '...' term expr | PRINT '(' ( STRINGVAL | idar ) ')' | groupExpr | REPEATE expr WHILE term -> ^( REPEATE term expr ) | FUNC IDENT '(' ( func_params )? ')' ( '->' type )? expr -> ^( FUNC IDENT ^( FUNC_PARAM ( func_params )? ) ^( TYPE ( type )? ) expr ) | RETURN ( returnValue | arrayValue ) -> ^( RETURN ( returnValue )? ( ^( ARRAY arrayValue ) )? ) | SWITCH IDENT '{' ( swcase )* ( DEFAULT ':' expr )? '}' -> ^( SWITCH IDENT ( swcase )* ( DEFAULT expr )? ) )
int alt42 = 14;
alt42 = dfa42.Predict(input);
switch (alt42)
{
case 1 :
// MathExpr.g:189:3: BEGIN exprList END
{
BEGIN97=(IToken)Match(input,BEGIN,FOLLOW_BEGIN_in_expr1663); if (state.failed) return retval;
if ( (state.backtracking==0) ) stream_BEGIN.Add(BEGIN97);
PushFollow(FOLLOW_exprList_in_expr1665);
exprList98 = exprList();
state.followingStackPointer--;
if (state.failed) return retval;
if ( (state.backtracking==0) ) stream_exprList.Add(exprList98.Tree);
END99=(IToken)Match(input,END,FOLLOW_END_in_expr1667); if (state.failed) return retval;
if ( (state.backtracking==0) ) stream_END.Add(END99);
// AST REWRITE
// elements: exprList
// 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();
// 189:22: -> ^( BLOCK ( exprList )? )
{
// MathExpr.g:189:25: ^( BLOCK ( exprList )? )
{
AstNode root_1 = (AstNode)adaptor.GetNilNode();
root_1 = (AstNode)adaptor.BecomeRoot((AstNode)adaptor.Create(BLOCK, "BLOCK"), root_1);
// MathExpr.g:189:33: ( exprList )?
if ( stream_exprList.HasNext() )
{
adaptor.AddChild(root_1, stream_exprList.NextTree());
}
stream_exprList.Reset();
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;retval.Tree = root_0;}
}
break;
case 2 :
// MathExpr.g:190:3: idar allassign term
{
root_0 = (AstNode)adaptor.GetNilNode();
PushFollow(FOLLOW_idar_in_expr1680);
idar100 = idar();
state.followingStackPointer--;
if (state.failed) return retval;
if ( state.backtracking == 0 ) adaptor.AddChild(root_0, idar100.Tree);
PushFollow(FOLLOW_allassign_in_expr1682);
allassign101 = allassign();
state.followingStackPointer--;
if (state.failed) return retval;
if ( state.backtracking == 0 ) root_0 = (AstNode)adaptor.BecomeRoot(allassign101.Tree, root_0);
PushFollow(FOLLOW_term_in_expr1685);
term102 = term();
state.followingStackPointer--;
if (state.failed) return retval;
if ( state.backtracking == 0 ) adaptor.AddChild(root_0, term102.Tree);
}
break;
case 3 :
// MathExpr.g:191:3: IF term expr ( ELSE expr )?
{
root_0 = (AstNode)adaptor.GetNilNode();
IF103=(IToken)Match(input,IF,FOLLOW_IF_in_expr1689); if (state.failed) return retval;
if ( state.backtracking == 0 )
{IF103_tree = (AstNode)adaptor.Create(IF103);
root_0 = (AstNode)adaptor.BecomeRoot(IF103_tree, root_0);
}
PushFollow(FOLLOW_term_in_expr1692);
term104 = term();
state.followingStackPointer--;
if (state.failed) return retval;
if ( state.backtracking == 0 ) adaptor.AddChild(root_0, term104.Tree);
PushFollow(FOLLOW_expr_in_expr1694);
expr105 = expr();
state.followingStackPointer--;
if (state.failed) return retval;
if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expr105.Tree);
// MathExpr.g:191:17: ( ELSE expr )?
int alt25 = 2;
int LA25_0 = input.LA(1);
if ( (LA25_0 == ELSE) )
{
int LA25_1 = input.LA(2);
if ( (synpred50_MathExpr()) )
{
alt25 = 1;
}
}
switch (alt25)
{
case 1 :
// MathExpr.g:191:18: ELSE expr
{
ELSE106=(IToken)Match(input,ELSE,FOLLOW_ELSE_in_expr1697); if (state.failed) return retval;
PushFollow(FOLLOW_expr_in_expr1700);
expr107 = expr();
state.followingStackPointer--;
if (state.failed) return retval;
if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expr107.Tree);
}
break;
}
}
break;
case 4 :
// MathExpr.g:192:3: WHILE term expr
{
root_0 = (AstNode)adaptor.GetNilNode();
WHILE108=(IToken)Match(input,WHILE,FOLLOW_WHILE_in_expr1706); if (state.failed) return retval;
if ( state.backtracking == 0 )
{WHILE108_tree = (AstNode)adaptor.Create(WHILE108);
root_0 = (AstNode)adaptor.BecomeRoot(WHILE108_tree, root_0);
}
PushFollow(FOLLOW_term_in_expr1709);
term109 = term();
state.followingStackPointer--;
if (state.failed) return retval;
if ( state.backtracking == 0 ) adaptor.AddChild(root_0, term109.Tree);
PushFollow(FOLLOW_expr_in_expr1712);
expr110 = expr();
state.followingStackPointer--;
if (state.failed) return retval;
if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expr110.Tree);
}
break;
case 5 :
// MathExpr.g:193:3: FOR ( VAR IDENT ASSIGN term )? ';' ( compare )? ';' ( groupExpr )? expr
{
FOR111=(IToken)Match(input,FOR,FOLLOW_FOR_in_expr1716); if (state.failed) return retval;
if ( (state.backtracking==0) ) stream_FOR.Add(FOR111);
// MathExpr.g:193:7: ( VAR IDENT ASSIGN term )?
int alt26 = 2;
int LA26_0 = input.LA(1);
if ( (LA26_0 == VAR) )
{
alt26 = 1;
}
switch (alt26)
{
case 1 :
// MathExpr.g:193:8: VAR IDENT ASSIGN term
{
VAR112=(IToken)Match(input,VAR,FOLLOW_VAR_in_expr1719); if (state.failed) return retval;
if ( (state.backtracking==0) ) stream_VAR.Add(VAR112);
IDENT113=(IToken)Match(input,IDENT,FOLLOW_IDENT_in_expr1721); if (state.failed) return retval;
if ( (state.backtracking==0) ) stream_IDENT.Add(IDENT113);
ASSIGN114=(IToken)Match(input,ASSIGN,FOLLOW_ASSIGN_in_expr1723); if (state.failed) return retval;
if ( (state.backtracking==0) ) stream_ASSIGN.Add(ASSIGN114);
PushFollow(FOLLOW_term_in_expr1725);
term115 = term();
state.followingStackPointer--;
if (state.failed) return retval;
if ( (state.backtracking==0) ) stream_term.Add(term115.Tree);
}
break;
}
char_literal116=(IToken)Match(input,77,FOLLOW_77_in_expr1730); if (state.failed) return retval;
if ( (state.backtracking==0) ) stream_77.Add(char_literal116);
// MathExpr.g:193:37: ( compare )?
int alt27 = 2;
int LA27_0 = input.LA(1);
if ( (LA27_0 == NOT || (LA27_0 >= TRUE && LA27_0 <= FALSE) || (LA27_0 >= NUMBER && LA27_0 <= IDENT) || (LA27_0 >= INCR && LA27_0 <= DECR) || LA27_0 == 74) )
{
alt27 = 1;
}
switch (alt27)
{
case 1 :
// MathExpr.g:0:0: compare
{
PushFollow(FOLLOW_compare_in_expr1732);
compare117 = compare();
state.followingStackPointer--;
if (state.failed) return retval;
if ( (state.backtracking==0) ) stream_compare.Add(compare117.Tree);
}
break;
}
char_literal118=(IToken)Match(input,77,FOLLOW_77_in_expr1735); if (state.failed) return retval;
if ( (state.backtracking==0) ) stream_77.Add(char_literal118);
// MathExpr.g:193:50: ( groupExpr )?
int alt28 = 2;
alt28 = dfa28.Predict(input);
switch (alt28)
{
case 1 :
// MathExpr.g:193:52: groupExpr
{
PushFollow(FOLLOW_groupExpr_in_expr1739);
groupExpr119 = groupExpr();
state.followingStackPointer--;
if (state.failed) return retval;
if ( (state.backtracking==0) ) stream_groupExpr.Add(groupExpr119.Tree);
}
break;
}
PushFollow(FOLLOW_expr_in_expr1743);
expr120 = expr();
state.followingStackPointer--;
if (state.failed) return retval;
if ( (state.backtracking==0) ) stream_expr.Add(expr120.Tree);
// AST REWRITE
// elements: term, FOR, IDENT, groupExpr, ASSIGN, VAR, compare, expr
// 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();
// 193:69: -> ^( FOR ( ^( VAR ^( IDENT TYPE ^( ASSIGN term ) ) ) )? ( compare )? ( groupExpr )? expr )
{
// MathExpr.g:193:72: ^( FOR ( ^( VAR ^( IDENT TYPE ^( ASSIGN term ) ) ) )? ( compare )? ( groupExpr )? expr )
{
AstNode root_1 = (AstNode)adaptor.GetNilNode();
root_1 = (AstNode)adaptor.BecomeRoot(stream_FOR.NextNode(), root_1);
// MathExpr.g:193:78: ( ^( VAR ^( IDENT TYPE ^( ASSIGN term ) ) ) )?
if ( stream_term.HasNext() || stream_IDENT.HasNext() || stream_ASSIGN.HasNext() || stream_VAR.HasNext() )
{
// MathExpr.g:193:78: ^( VAR ^( IDENT TYPE ^( ASSIGN term ) ) )
{
AstNode root_2 = (AstNode)adaptor.GetNilNode();
root_2 = (AstNode)adaptor.BecomeRoot(stream_VAR.NextNode(), root_2);
// MathExpr.g:193:84: ^( IDENT TYPE ^( ASSIGN term ) )
{
AstNode root_3 = (AstNode)adaptor.GetNilNode();
root_3 = (AstNode)adaptor.BecomeRoot(stream_IDENT.NextNode(), root_3);
adaptor.AddChild(root_3, (AstNode)adaptor.Create(TYPE, "TYPE"));
// MathExpr.g:193:97: ^( ASSIGN term )
{
AstNode root_4 = (AstNode)adaptor.GetNilNode();
root_4 = (AstNode)adaptor.BecomeRoot(stream_ASSIGN.NextNode(), root_4);
adaptor.AddChild(root_4, stream_term.NextTree());
adaptor.AddChild(root_3, root_4);
}
adaptor.AddChild(root_2, root_3);
}
adaptor.AddChild(root_1, root_2);
}
}
stream_term.Reset();
stream_IDENT.Reset();
stream_ASSIGN.Reset();
stream_VAR.Reset();
// MathExpr.g:193:115: ( compare )?
if ( stream_compare.HasNext() )
{
adaptor.AddChild(root_1, stream_compare.NextTree());
}
stream_compare.Reset();
// MathExpr.g:193:124: ( groupExpr )?
if ( stream_groupExpr.HasNext() )
{
adaptor.AddChild(root_1, stream_groupExpr.NextTree());
}
stream_groupExpr.Reset();
adaptor.AddChild(root_1, stream_expr.NextTree());
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;retval.Tree = root_0;}
}
break;
case 6 :
// MathExpr.g:194:3: LET idar ( ':' type )? ( ASSIGN returnValue )? ( ',' idar ( ':' type )? ( ASSIGN returnValue )? )*
{
LET121=(IToken)Match(input,LET,FOLLOW_LET_in_expr1778); if (state.failed) return retval;
if ( (state.backtracking==0) ) stream_LET.Add(LET121);
PushFollow(FOLLOW_idar_in_expr1780);
idar122 = idar();
state.followingStackPointer--;
if (state.failed) return retval;
if ( (state.backtracking==0) ) stream_idar.Add(idar122.Tree);
// MathExpr.g:194:12: ( ':' type )?
int alt29 = 2;
int LA29_0 = input.LA(1);
if ( (LA29_0 == 73) )
{
alt29 = 1;
}
switch (alt29)
{
case 1 :
// MathExpr.g:194:13: ':' type
{
char_literal123=(IToken)Match(input,73,FOLLOW_73_in_expr1783); if (state.failed) return retval;
if ( (state.backtracking==0) ) stream_73.Add(char_literal123);
PushFollow(FOLLOW_type_in_expr1785);
type124 = type();
state.followingStackPointer--;
if (state.failed) return retval;
if ( (state.backtracking==0) ) stream_type.Add(type124.Tree);
}
break;
}
// MathExpr.g:194:24: ( ASSIGN returnValue )?
int alt30 = 2;
int LA30_0 = input.LA(1);
if ( (LA30_0 == ASSIGN) )
{
alt30 = 1;
}
switch (alt30)
{
case 1 :
// MathExpr.g:194:25: ASSIGN returnValue
{
ASSIGN125=(IToken)Match(input,ASSIGN,FOLLOW_ASSIGN_in_expr1790); if (state.failed) return retval;
if ( (state.backtracking==0) ) stream_ASSIGN.Add(ASSIGN125);
PushFollow(FOLLOW_returnValue_in_expr1792);
returnValue126 = returnValue();
state.followingStackPointer--;
if (state.failed) return retval;
if ( (state.backtracking==0) ) stream_returnValue.Add(returnValue126.Tree);
}
break;
}
// MathExpr.g:194:46: ( ',' idar ( ':' type )? ( ASSIGN returnValue )? )*
do
{
int alt33 = 2;
int LA33_0 = input.LA(1);
if ( (LA33_0 == 72) )
{
alt33 = 1;
}
switch (alt33)
{
case 1 :
// MathExpr.g:194:47: ',' idar ( ':' type )? ( ASSIGN returnValue )?
{
char_literal127=(IToken)Match(input,72,FOLLOW_72_in_expr1797); if (state.failed) return retval;
if ( (state.backtracking==0) ) stream_72.Add(char_literal127);
PushFollow(FOLLOW_idar_in_expr1799);
idar128 = idar();
state.followingStackPointer--;
if (state.failed) return retval;
if ( (state.backtracking==0) ) stream_idar.Add(idar128.Tree);
// MathExpr.g:194:56: ( ':' type )?
int alt31 = 2;
int LA31_0 = input.LA(1);
if ( (LA31_0 == 73) )
{
alt31 = 1;
}
switch (alt31)
{
case 1 :
// MathExpr.g:194:57: ':' type
{
char_literal129=(IToken)Match(input,73,FOLLOW_73_in_expr1802); if (state.failed) return retval;
if ( (state.backtracking==0) ) stream_73.Add(char_literal129);
PushFollow(FOLLOW_type_in_expr1804);
type130 = type();
state.followingStackPointer--;
if (state.failed) return retval;
if ( (state.backtracking==0) ) stream_type.Add(type130.Tree);
}
break;
}
// MathExpr.g:194:68: ( ASSIGN returnValue )?
int alt32 = 2;
int LA32_0 = input.LA(1);
if ( (LA32_0 == ASSIGN) )
{
alt32 = 1;
}
switch (alt32)
{
case 1 :
// MathExpr.g:194:69: ASSIGN returnValue
{
ASSIGN131=(IToken)Match(input,ASSIGN,FOLLOW_ASSIGN_in_expr1809); if (state.failed) return retval;
if ( (state.backtracking==0) ) stream_ASSIGN.Add(ASSIGN131);
PushFollow(FOLLOW_returnValue_in_expr1811);
returnValue132 = returnValue();
state.followingStackPointer--;
if (state.failed) return retval;
if ( (state.backtracking==0) ) stream_returnValue.Add(returnValue132.Tree);
}
break;
}
}
break;
default:
goto loop33;
}
} while (true);
loop33:
; // Stops C# compiler whining that label 'loop33' has no statements
// AST REWRITE
// elements: idar, LET, returnValue, type, ASSIGN
// 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();
// 194:93: -> ^( LET ( ^( idar ^( TYPE ( type )? ) ( ^( ASSIGN returnValue ) )? ) )* )
{
// MathExpr.g:194:96: ^( LET ( ^( idar ^( TYPE ( type )? ) ( ^( ASSIGN returnValue ) )? ) )* )
{
AstNode root_1 = (AstNode)adaptor.GetNilNode();
root_1 = (AstNode)adaptor.BecomeRoot(stream_LET.NextNode(), root_1);
// MathExpr.g:194:102: ( ^( idar ^( TYPE ( type )? ) ( ^( ASSIGN returnValue ) )? ) )*
while ( stream_idar.HasNext() )
{
// MathExpr.g:194:102: ^( idar ^( TYPE ( type )? ) ( ^( ASSIGN returnValue ) )? )
{
AstNode root_2 = (AstNode)adaptor.GetNilNode();
root_2 = (AstNode)adaptor.BecomeRoot(stream_idar.NextNode(), root_2);
// MathExpr.g:194:109: ^( TYPE ( type )? )
{
AstNode root_3 = (AstNode)adaptor.GetNilNode();
root_3 = (AstNode)adaptor.BecomeRoot((AstNode)adaptor.Create(TYPE, "TYPE"), root_3);
// MathExpr.g:194:116: ( type )?
if ( stream_type.HasNext() )
{
adaptor.AddChild(root_3, stream_type.NextTree());
}
stream_type.Reset();
adaptor.AddChild(root_2, root_3);
}
// MathExpr.g:194:123: ( ^( ASSIGN returnValue ) )?
if ( stream_returnValue.HasNext() || stream_ASSIGN.HasNext() )
{
// MathExpr.g:194:123: ^( ASSIGN returnValue )
{
AstNode root_3 = (AstNode)adaptor.GetNilNode();
root_3 = (AstNode)adaptor.BecomeRoot(stream_ASSIGN.NextNode(), root_3);
adaptor.AddChild(root_3, stream_returnValue.NextTree());
adaptor.AddChild(root_2, root_3);
}
}
stream_returnValue.Reset();
stream_ASSIGN.Reset();
adaptor.AddChild(root_1, root_2);
}
}
stream_idar.Reset();
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;retval.Tree = root_0;}
}
break;
case 7 :
// MathExpr.g:195:3: VAR var_element ( ',' var_element )*
{
VAR133=(IToken)Match(input,VAR,FOLLOW_VAR_in_expr1846); if (state.failed) return retval;
if ( (state.backtracking==0) ) stream_VAR.Add(VAR133);
PushFollow(FOLLOW_var_element_in_expr1848);
var_element134 = var_element();
state.followingStackPointer--;
if (state.failed) return retval;
if ( (state.backtracking==0) ) stream_var_element.Add(var_element134.Tree);
// MathExpr.g:195:19: ( ',' var_element )*
do
{
int alt34 = 2;
int LA34_0 = input.LA(1);
if ( (LA34_0 == 72) )
{
alt34 = 1;
}
switch (alt34)
{
case 1 :
// MathExpr.g:195:20: ',' var_element
{
char_literal135=(IToken)Match(input,72,FOLLOW_72_in_expr1851); if (state.failed) return retval;
if ( (state.backtracking==0) ) stream_72.Add(char_literal135);
PushFollow(FOLLOW_var_element_in_expr1853);
var_element136 = var_element();
state.followingStackPointer--;
if (state.failed) return retval;
if ( (state.backtracking==0) ) stream_var_element.Add(var_element136.Tree);
}
break;
default:
goto loop34;
}
} while (true);
loop34:
; // Stops C# compiler whining that label 'loop34' has no statements
// AST REWRITE
// elements: VAR, var_element
// 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();
// 195:38: -> ^( VAR ( var_element )* )
{
// MathExpr.g:195:41: ^( VAR ( var_element )* )
{
AstNode root_1 = (AstNode)adaptor.GetNilNode();
root_1 = (AstNode)adaptor.BecomeRoot(stream_VAR.NextNode(), root_1);
// MathExpr.g:195:47: ( var_element )*
while ( stream_var_element.HasNext() )
{
adaptor.AddChild(root_1, stream_var_element.NextTree());
}
stream_var_element.Reset();
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;retval.Tree = root_0;}
}
break;
case 8 :
// MathExpr.g:196:3: FOR ( VAR )? IDENT IN term '...' term expr
{
root_0 = (AstNode)adaptor.GetNilNode();
FOR137=(IToken)Match(input,FOR,FOLLOW_FOR_in_expr1868); if (state.failed) return retval;
if ( state.backtracking == 0 )
{FOR137_tree = (AstNode)adaptor.Create(FOR137);
root_0 = (AstNode)adaptor.BecomeRoot(FOR137_tree, root_0);
}
// MathExpr.g:196:11: ( VAR )?
int alt35 = 2;
int LA35_0 = input.LA(1);
if ( (LA35_0 == VAR) )
{
alt35 = 1;
}
switch (alt35)
{
case 1 :
// MathExpr.g:0:0: VAR
{
VAR138=(IToken)Match(input,VAR,FOLLOW_VAR_in_expr1871); if (state.failed) return retval;
}
break;
}
IDENT139=(IToken)Match(input,IDENT,FOLLOW_IDENT_in_expr1875); if (state.failed) return retval;
if ( state.backtracking == 0 )
{IDENT139_tree = (AstNode)adaptor.Create(IDENT139);
adaptor.AddChild(root_0, IDENT139_tree);
}
IN140=(IToken)Match(input,IN,FOLLOW_IN_in_expr1877); if (state.failed) return retval;
PushFollow(FOLLOW_term_in_expr1880);
term141 = term();
state.followingStackPointer--;
if (state.failed) return retval;
if ( state.backtracking == 0 ) adaptor.AddChild(root_0, term141.Tree);
string_literal142=(IToken)Match(input,78,FOLLOW_78_in_expr1882); if (state.failed) return retval;
PushFollow(FOLLOW_term_in_expr1885);
term143 = term();
state.followingStackPointer--;
if (state.failed) return retval;
if ( state.backtracking == 0 ) adaptor.AddChild(root_0, term143.Tree);
PushFollow(FOLLOW_expr_in_expr1887);
expr144 = expr();
state.followingStackPointer--;
if (state.failed) return retval;
if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expr144.Tree);
}
break;
case 9 :
// MathExpr.g:197:3: PRINT '(' ( STRINGVAL | idar ) ')'
{
root_0 = (AstNode)adaptor.GetNilNode();
PRINT145=(IToken)Match(input,PRINT,FOLLOW_PRINT_in_expr1891); if (state.failed) return retval;
if ( state.backtracking == 0 )
{PRINT145_tree = (AstNode)adaptor.Create(PRINT145);
root_0 = (AstNode)adaptor.BecomeRoot(PRINT145_tree, root_0);
}
char_literal146=(IToken)Match(input,74,FOLLOW_74_in_expr1894); if (state.failed) return retval;
// MathExpr.g:197:15: ( STRINGVAL | idar )
int alt36 = 2;
int LA36_0 = input.LA(1);
if ( (LA36_0 == STRINGVAL) )
{
alt36 = 1;
}
else if ( (LA36_0 == IDENT) )
{
alt36 = 2;
}
else
{
if ( state.backtracking > 0 ) {state.failed = true; return retval;}
NoViableAltException nvae_d36s0 =
new NoViableAltException("", 36, 0, input);
throw nvae_d36s0;
}
switch (alt36)
{
case 1 :
// MathExpr.g:197:17: STRINGVAL
{
STRINGVAL147=(IToken)Match(input,STRINGVAL,FOLLOW_STRINGVAL_in_expr1899); if (state.failed) return retval;
if ( state.backtracking == 0 )
{STRINGVAL147_tree = (AstNode)adaptor.Create(STRINGVAL147);
adaptor.AddChild(root_0, STRINGVAL147_tree);
}
}
break;
case 2 :
// MathExpr.g:197:29: idar
{
PushFollow(FOLLOW_idar_in_expr1903);
idar148 = idar();
state.followingStackPointer--;
if (state.failed) return retval;
if ( state.backtracking == 0 ) adaptor.AddChild(root_0, idar148.Tree);
}
break;
}
char_literal149=(IToken)Match(input,75,FOLLOW_75_in_expr1907); if (state.failed) return retval;
}
break;
case 10 :
// MathExpr.g:198:3: groupExpr
{
root_0 = (AstNode)adaptor.GetNilNode();
PushFollow(FOLLOW_groupExpr_in_expr1912);
groupExpr150 = groupExpr();
state.followingStackPointer--;
if (state.failed) return retval;
if ( state.backtracking == 0 ) adaptor.AddChild(root_0, groupExpr150.Tree);
}
break;
case 11 :
// MathExpr.g:199:3: REPEATE expr WHILE term
{
REPEATE151=(IToken)Match(input,REPEATE,FOLLOW_REPEATE_in_expr1916); if (state.failed) return retval;
if ( (state.backtracking==0) ) stream_REPEATE.Add(REPEATE151);
PushFollow(FOLLOW_expr_in_expr1918);
expr152 = expr();
state.followingStackPointer--;
if (state.failed) return retval;
if ( (state.backtracking==0) ) stream_expr.Add(expr152.Tree);
WHILE153=(IToken)Match(input,WHILE,FOLLOW_WHILE_in_expr1920); if (state.failed) return retval;
if ( (state.backtracking==0) ) stream_WHILE.Add(WHILE153);
PushFollow(FOLLOW_term_in_expr1922);
term154 = term();
state.followingStackPointer--;
if (state.failed) return retval;
if ( (state.backtracking==0) ) stream_term.Add(term154.Tree);
// AST REWRITE
// elements: expr, REPEATE, term
// 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();
// 199:27: -> ^( REPEATE term expr )
{
// MathExpr.g:199:30: ^( REPEATE term expr )
{
AstNode root_1 = (AstNode)adaptor.GetNilNode();
root_1 = (AstNode)adaptor.BecomeRoot(stream_REPEATE.NextNode(), root_1);
adaptor.AddChild(root_1, stream_term.NextTree());
adaptor.AddChild(root_1, stream_expr.NextTree());
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;retval.Tree = root_0;}
}
break;
case 12 :
// MathExpr.g:200:3: FUNC IDENT '(' ( func_params )? ')' ( '->' type )? expr
{
FUNC155=(IToken)Match(input,FUNC,FOLLOW_FUNC_in_expr1936); if (state.failed) return retval;
if ( (state.backtracking==0) ) stream_FUNC.Add(FUNC155);
IDENT156=(IToken)Match(input,IDENT,FOLLOW_IDENT_in_expr1938); if (state.failed) return retval;
if ( (state.backtracking==0) ) stream_IDENT.Add(IDENT156);
char_literal157=(IToken)Match(input,74,FOLLOW_74_in_expr1940); if (state.failed) return retval;
if ( (state.backtracking==0) ) stream_74.Add(char_literal157);
// MathExpr.g:200:18: ( func_params )?
int alt37 = 2;
int LA37_0 = input.LA(1);
if ( (LA37_0 == IDENT) )
{
alt37 = 1;
}
switch (alt37)
{
case 1 :
// MathExpr.g:0:0: func_params
{
PushFollow(FOLLOW_func_params_in_expr1942);
func_params158 = func_params();
state.followingStackPointer--;
if (state.failed) return retval;
if ( (state.backtracking==0) ) stream_func_params.Add(func_params158.Tree);
}
break;
}
char_literal159=(IToken)Match(input,75,FOLLOW_75_in_expr1945); if (state.failed) return retval;
if ( (state.backtracking==0) ) stream_75.Add(char_literal159);
// MathExpr.g:200:35: ( '->' type )?
int alt38 = 2;
int LA38_0 = input.LA(1);
if ( (LA38_0 == 79) )
{
alt38 = 1;
}
switch (alt38)
{
case 1 :
// MathExpr.g:200:36: '->' type
{
string_literal160=(IToken)Match(input,79,FOLLOW_79_in_expr1948); if (state.failed) return retval;
if ( (state.backtracking==0) ) stream_79.Add(string_literal160);
PushFollow(FOLLOW_type_in_expr1950);
type161 = type();
state.followingStackPointer--;
if (state.failed) return retval;
if ( (state.backtracking==0) ) stream_type.Add(type161.Tree);
}
break;
}
PushFollow(FOLLOW_expr_in_expr1954);
expr162 = expr();
state.followingStackPointer--;
if (state.failed) return retval;
if ( (state.backtracking==0) ) stream_expr.Add(expr162.Tree);
// AST REWRITE
// elements: func_params, IDENT, type, FUNC, expr
// 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();
// 200:53: -> ^( FUNC IDENT ^( FUNC_PARAM ( func_params )? ) ^( TYPE ( type )? ) expr )
{
// MathExpr.g:200:56: ^( FUNC IDENT ^( FUNC_PARAM ( func_params )? ) ^( TYPE ( type )? ) expr )
{
AstNode root_1 = (AstNode)adaptor.GetNilNode();
root_1 = (AstNode)adaptor.BecomeRoot(stream_FUNC.NextNode(), root_1);
adaptor.AddChild(root_1, stream_IDENT.NextNode());
// MathExpr.g:200:69: ^( FUNC_PARAM ( func_params )? )
{
AstNode root_2 = (AstNode)adaptor.GetNilNode();
root_2 = (AstNode)adaptor.BecomeRoot((AstNode)adaptor.Create(FUNC_PARAM, "FUNC_PARAM"), root_2);
// MathExpr.g:200:83: ( func_params )?
if ( stream_func_params.HasNext() )
{
adaptor.AddChild(root_2, stream_func_params.NextTree());
}
stream_func_params.Reset();
adaptor.AddChild(root_1, root_2);
}
// MathExpr.g:200:97: ^( TYPE ( type )? )
{
AstNode root_2 = (AstNode)adaptor.GetNilNode();
root_2 = (AstNode)adaptor.BecomeRoot((AstNode)adaptor.Create(TYPE, "TYPE"), root_2);
// MathExpr.g:200:104: ( type )?
if ( stream_type.HasNext() )
{
adaptor.AddChild(root_2, stream_type.NextTree());
}
stream_type.Reset();
adaptor.AddChild(root_1, root_2);
}
adaptor.AddChild(root_1, stream_expr.NextTree());
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;retval.Tree = root_0;}
}
break;
case 13 :
// MathExpr.g:201:3: RETURN ( returnValue | arrayValue )
{
RETURN163=(IToken)Match(input,RETURN,FOLLOW_RETURN_in_expr1983); if (state.failed) return retval;
if ( (state.backtracking==0) ) stream_RETURN.Add(RETURN163);
// MathExpr.g:201:10: ( returnValue | arrayValue )
int alt39 = 2;
int LA39_0 = input.LA(1);
if ( (LA39_0 == NOT || (LA39_0 >= TRUE && LA39_0 <= FALSE) || (LA39_0 >= NUMBER && LA39_0 <= IDENT) || (LA39_0 >= INCR && LA39_0 <= DECR) || LA39_0 == 74) )
{
alt39 = 1;
}
else if ( (LA39_0 == 70) )
{
alt39 = 2;
}
else
{
if ( state.backtracking > 0 ) {state.failed = true; return retval;}
NoViableAltException nvae_d39s0 =
new NoViableAltException("", 39, 0, input);
throw nvae_d39s0;
}
switch (alt39)
{
case 1 :
// MathExpr.g:201:11: returnValue
{
PushFollow(FOLLOW_returnValue_in_expr1986);
returnValue164 = returnValue();
state.followingStackPointer--;
if (state.failed) return retval;
if ( (state.backtracking==0) ) stream_returnValue.Add(returnValue164.Tree);
}
break;
case 2 :
// MathExpr.g:201:26: arrayValue
{
PushFollow(FOLLOW_arrayValue_in_expr1991);
arrayValue165 = arrayValue();
state.followingStackPointer--;
if (state.failed) return retval;
if ( (state.backtracking==0) ) stream_arrayValue.Add(arrayValue165.Tree);
}
break;
}
// AST REWRITE
// elements: returnValue, arrayValue, RETURN
// 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();
// 201:38: -> ^( RETURN ( returnValue )? ( ^( ARRAY arrayValue ) )? )
{
// MathExpr.g:201:41: ^( RETURN ( returnValue )? ( ^( ARRAY arrayValue ) )? )
{
AstNode root_1 = (AstNode)adaptor.GetNilNode();
root_1 = (AstNode)adaptor.BecomeRoot(stream_RETURN.NextNode(), root_1);
// MathExpr.g:201:50: ( returnValue )?
if ( stream_returnValue.HasNext() )
{
adaptor.AddChild(root_1, stream_returnValue.NextTree());
}
stream_returnValue.Reset();
// MathExpr.g:201:63: ( ^( ARRAY arrayValue ) )?
if ( stream_arrayValue.HasNext() )
{
// MathExpr.g:201:63: ^( ARRAY arrayValue )
{
AstNode root_2 = (AstNode)adaptor.GetNilNode();
root_2 = (AstNode)adaptor.BecomeRoot((AstNode)adaptor.Create(ARRAY, "ARRAY"), root_2);
adaptor.AddChild(root_2, stream_arrayValue.NextTree());
adaptor.AddChild(root_1, root_2);
}
}
stream_arrayValue.Reset();
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;retval.Tree = root_0;}
}
break;
case 14 :
// MathExpr.g:202:3: SWITCH IDENT '{' ( swcase )* ( DEFAULT ':' expr )? '}'
{
SWITCH166=(IToken)Match(input,SWITCH,FOLLOW_SWITCH_in_expr2012); if (state.failed) return retval;
if ( (state.backtracking==0) ) stream_SWITCH.Add(SWITCH166);
IDENT167=(IToken)Match(input,IDENT,FOLLOW_IDENT_in_expr2014); if (state.failed) return retval;
if ( (state.backtracking==0) ) stream_IDENT.Add(IDENT167);
char_literal168=(IToken)Match(input,BEGIN,FOLLOW_BEGIN_in_expr2016); if (state.failed) return retval;
if ( (state.backtracking==0) ) stream_BEGIN.Add(char_literal168);
// MathExpr.g:202:20: ( swcase )*
do
{
int alt40 = 2;
int LA40_0 = input.LA(1);
if ( (LA40_0 == CASE) )
{
alt40 = 1;
}
switch (alt40)
{
case 1 :
// MathExpr.g:202:21: swcase
{
PushFollow(FOLLOW_swcase_in_expr2019);
swcase169 = swcase();
state.followingStackPointer--;
if (state.failed) return retval;
if ( (state.backtracking==0) ) stream_swcase.Add(swcase169.Tree);
}
break;
default:
goto loop40;
}
} while (true);
loop40:
; // Stops C# compiler whining that label 'loop40' has no statements
// MathExpr.g:202:30: ( DEFAULT ':' expr )?
int alt41 = 2;
int LA41_0 = input.LA(1);
if ( (LA41_0 == DEFAULT) )
{
alt41 = 1;
}
switch (alt41)
{
case 1 :
// MathExpr.g:202:31: DEFAULT ':' expr
{
DEFAULT170=(IToken)Match(input,DEFAULT,FOLLOW_DEFAULT_in_expr2024); if (state.failed) return retval;
if ( (state.backtracking==0) ) stream_DEFAULT.Add(DEFAULT170);
char_literal171=(IToken)Match(input,73,FOLLOW_73_in_expr2026); if (state.failed) return retval;
if ( (state.backtracking==0) ) stream_73.Add(char_literal171);
PushFollow(FOLLOW_expr_in_expr2028);
expr172 = expr();
state.followingStackPointer--;
if (state.failed) return retval;
if ( (state.backtracking==0) ) stream_expr.Add(expr172.Tree);
}
break;
}
char_literal173=(IToken)Match(input,END,FOLLOW_END_in_expr2032); if (state.failed) return retval;
if ( (state.backtracking==0) ) stream_END.Add(char_literal173);
// AST REWRITE
// elements: expr, SWITCH, swcase, DEFAULT, IDENT
// 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();
// 202:54: -> ^( SWITCH IDENT ( swcase )* ( DEFAULT expr )? )
{
// MathExpr.g:202:57: ^( SWITCH IDENT ( swcase )* ( DEFAULT expr )? )
{
AstNode root_1 = (AstNode)adaptor.GetNilNode();
root_1 = (AstNode)adaptor.BecomeRoot(stream_SWITCH.NextNode(), root_1);
adaptor.AddChild(root_1, stream_IDENT.NextNode());
// MathExpr.g:202:73: ( swcase )*
while ( stream_swcase.HasNext() )
{
adaptor.AddChild(root_1, stream_swcase.NextTree());
}
stream_swcase.Reset();
// MathExpr.g:202:83: ( DEFAULT expr )?
if ( stream_expr.HasNext() || stream_DEFAULT.HasNext() )
{
adaptor.AddChild(root_1, stream_DEFAULT.NextNode());
adaptor.AddChild(root_1, stream_expr.NextTree());
}
stream_expr.Reset();
stream_DEFAULT.Reset();
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;retval.Tree = root_0;}
}
break;
}
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, 24, expr_StartIndex);
}
}
return retval;
}
// $ANTLR start "var_element"
// MathExpr.g:148:1: var_element : idar ( ':' type ( '(count' ':' add ')' ) )? ( ASSIGN ( returnValue | arrayValue ) )? -> ^( idar ( ^( TYPE type add ) )? ( ^( ASSIGN ( returnValue )? ( ^( ARRAY arrayValue ) )? ) )? ) ;
public MathExprParser.var_element_return var_element() // throws RecognitionException [1]
{
MathExprParser.var_element_return retval = new MathExprParser.var_element_return();
retval.Start = input.LT(1);
int var_element_StartIndex = input.Index();
AstNode root_0 = null;
IToken char_literal59 = null;
IToken string_literal61 = null;
IToken char_literal62 = null;
IToken char_literal64 = null;
IToken ASSIGN65 = null;
MathExprParser.idar_return idar58 = default(MathExprParser.idar_return);
MathExprParser.type_return type60 = default(MathExprParser.type_return);
MathExprParser.add_return add63 = default(MathExprParser.add_return);
MathExprParser.returnValue_return returnValue66 = default(MathExprParser.returnValue_return);
MathExprParser.arrayValue_return arrayValue67 = default(MathExprParser.arrayValue_return);
AstNode char_literal59_tree=null;
AstNode string_literal61_tree=null;
AstNode char_literal62_tree=null;
AstNode char_literal64_tree=null;
AstNode ASSIGN65_tree=null;
RewriteRuleTokenStream stream_73 = new RewriteRuleTokenStream(adaptor,"token 73");
RewriteRuleTokenStream stream_ASSIGN = new RewriteRuleTokenStream(adaptor,"token ASSIGN");
RewriteRuleTokenStream stream_75 = new RewriteRuleTokenStream(adaptor,"token 75");
RewriteRuleTokenStream stream_76 = new RewriteRuleTokenStream(adaptor,"token 76");
RewriteRuleSubtreeStream stream_add = new RewriteRuleSubtreeStream(adaptor,"rule add");
RewriteRuleSubtreeStream stream_returnValue = new RewriteRuleSubtreeStream(adaptor,"rule returnValue");
RewriteRuleSubtreeStream stream_arrayValue = new RewriteRuleSubtreeStream(adaptor,"rule arrayValue");
RewriteRuleSubtreeStream stream_type = new RewriteRuleSubtreeStream(adaptor,"rule type");
RewriteRuleSubtreeStream stream_idar = new RewriteRuleSubtreeStream(adaptor,"rule idar");
try
{
if ( (state.backtracking > 0) && AlreadyParsedRule(input, 13) )
{
return retval;
}
// MathExpr.g:148:12: ( idar ( ':' type ( '(count' ':' add ')' ) )? ( ASSIGN ( returnValue | arrayValue ) )? -> ^( idar ( ^( TYPE type add ) )? ( ^( ASSIGN ( returnValue )? ( ^( ARRAY arrayValue ) )? ) )? ) )
// MathExpr.g:148:14: idar ( ':' type ( '(count' ':' add ')' ) )? ( ASSIGN ( returnValue | arrayValue ) )?
{
PushFollow(FOLLOW_idar_in_var_element1384);
idar58 = idar();
state.followingStackPointer--;
if (state.failed) return retval;
if ( (state.backtracking==0) ) stream_idar.Add(idar58.Tree);
// MathExpr.g:148:19: ( ':' type ( '(count' ':' add ')' ) )?
int alt13 = 2;
int LA13_0 = input.LA(1);
if ( (LA13_0 == 73) )
{
alt13 = 1;
}
switch (alt13)
{
case 1 :
// MathExpr.g:148:20: ':' type ( '(count' ':' add ')' )
{
char_literal59=(IToken)Match(input,73,FOLLOW_73_in_var_element1387); if (state.failed) return retval;
if ( (state.backtracking==0) ) stream_73.Add(char_literal59);
PushFollow(FOLLOW_type_in_var_element1389);
type60 = type();
state.followingStackPointer--;
if (state.failed) return retval;
if ( (state.backtracking==0) ) stream_type.Add(type60.Tree);
// MathExpr.g:148:29: ( '(count' ':' add ')' )
// MathExpr.g:148:30: '(count' ':' add ')'
{
string_literal61=(IToken)Match(input,76,FOLLOW_76_in_var_element1392); if (state.failed) return retval;
if ( (state.backtracking==0) ) stream_76.Add(string_literal61);
char_literal62=(IToken)Match(input,73,FOLLOW_73_in_var_element1394); if (state.failed) return retval;
if ( (state.backtracking==0) ) stream_73.Add(char_literal62);
PushFollow(FOLLOW_add_in_var_element1396);
add63 = add();
state.followingStackPointer--;
if (state.failed) return retval;
if ( (state.backtracking==0) ) stream_add.Add(add63.Tree);
char_literal64=(IToken)Match(input,75,FOLLOW_75_in_var_element1398); if (state.failed) return retval;
if ( (state.backtracking==0) ) stream_75.Add(char_literal64);
}
}
break;
}
// MathExpr.g:148:56: ( ASSIGN ( returnValue | arrayValue ) )?
int alt15 = 2;
int LA15_0 = input.LA(1);
if ( (LA15_0 == ASSIGN) )
{
alt15 = 1;
}
switch (alt15)
{
case 1 :
// MathExpr.g:148:57: ASSIGN ( returnValue | arrayValue )
{
ASSIGN65=(IToken)Match(input,ASSIGN,FOLLOW_ASSIGN_in_var_element1406); if (state.failed) return retval;
if ( (state.backtracking==0) ) stream_ASSIGN.Add(ASSIGN65);
// MathExpr.g:148:64: ( returnValue | arrayValue )
int alt14 = 2;
int LA14_0 = input.LA(1);
if ( (LA14_0 == NOT || (LA14_0 >= TRUE && LA14_0 <= FALSE) || (LA14_0 >= NUMBER && LA14_0 <= IDENT) || (LA14_0 >= INCR && LA14_0 <= DECR) || LA14_0 == 74) )
{
alt14 = 1;
}
else if ( (LA14_0 == 70) )
{
alt14 = 2;
}
else
{
if ( state.backtracking > 0 ) {state.failed = true; return retval;}
NoViableAltException nvae_d14s0 =
new NoViableAltException("", 14, 0, input);
throw nvae_d14s0;
}
switch (alt14)
{
case 1 :
// MathExpr.g:148:66: returnValue
{
PushFollow(FOLLOW_returnValue_in_var_element1410);
returnValue66 = returnValue();
state.followingStackPointer--;
if (state.failed) return retval;
if ( (state.backtracking==0) ) stream_returnValue.Add(returnValue66.Tree);
}
break;
case 2 :
// MathExpr.g:148:80: arrayValue
{
PushFollow(FOLLOW_arrayValue_in_var_element1414);
arrayValue67 = arrayValue();
state.followingStackPointer--;
if (state.failed) return retval;
if ( (state.backtracking==0) ) stream_arrayValue.Add(arrayValue67.Tree);
}
break;
}
}
break;
}
// AST REWRITE
// elements: returnValue, arrayValue, ASSIGN, type, add, idar
// 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();
// 148:94: -> ^( idar ( ^( TYPE type add ) )? ( ^( ASSIGN ( returnValue )? ( ^( ARRAY arrayValue ) )? ) )? )
{
// MathExpr.g:148:97: ^( idar ( ^( TYPE type add ) )? ( ^( ASSIGN ( returnValue )? ( ^( ARRAY arrayValue ) )? ) )? )
{
AstNode root_1 = (AstNode)adaptor.GetNilNode();
root_1 = (AstNode)adaptor.BecomeRoot(stream_idar.NextNode(), root_1);
// MathExpr.g:148:104: ( ^( TYPE type add ) )?
if ( stream_type.HasNext() || stream_add.HasNext() )
{
// MathExpr.g:148:104: ^( TYPE type add )
{
AstNode root_2 = (AstNode)adaptor.GetNilNode();
root_2 = (AstNode)adaptor.BecomeRoot((AstNode)adaptor.Create(TYPE, "TYPE"), root_2);
adaptor.AddChild(root_2, stream_type.NextTree());
adaptor.AddChild(root_2, stream_add.NextTree());
adaptor.AddChild(root_1, root_2);
}
}
stream_type.Reset();
stream_add.Reset();
// MathExpr.g:148:122: ( ^( ASSIGN ( returnValue )? ( ^( ARRAY arrayValue ) )? ) )?
if ( stream_returnValue.HasNext() || stream_arrayValue.HasNext() || stream_ASSIGN.HasNext() )
{
// MathExpr.g:148:122: ^( ASSIGN ( returnValue )? ( ^( ARRAY arrayValue ) )? )
{
AstNode root_2 = (AstNode)adaptor.GetNilNode();
root_2 = (AstNode)adaptor.BecomeRoot(stream_ASSIGN.NextNode(), root_2);
// MathExpr.g:148:131: ( returnValue )?
if ( stream_returnValue.HasNext() )
{
adaptor.AddChild(root_2, stream_returnValue.NextTree());
}
stream_returnValue.Reset();
// MathExpr.g:148:144: ( ^( ARRAY arrayValue ) )?
if ( stream_arrayValue.HasNext() )
{
// MathExpr.g:148:144: ^( ARRAY arrayValue )
{
AstNode root_3 = (AstNode)adaptor.GetNilNode();
root_3 = (AstNode)adaptor.BecomeRoot((AstNode)adaptor.Create(ARRAY, "ARRAY"), root_3);
adaptor.AddChild(root_3, stream_arrayValue.NextTree());
adaptor.AddChild(root_2, root_3);
}
}
stream_arrayValue.Reset();
adaptor.AddChild(root_1, root_2);
}
}
stream_returnValue.Reset();
stream_arrayValue.Reset();
stream_ASSIGN.Reset();
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, 13, var_element_StartIndex);
}
}
return retval;
}