// $ANTLR start "expr" // MathExpr.g:124:1: expr : ( expr0 ';' | IF '(' term ')' expr ( ELSE expr )? | WHILE '(' term ')' expr | FOR '(' exprList2 ';' termOrTrue ';' exprList2 ')' expr | REPEAT expr UNTIL term | RETURN term ';' | call ';' | blockExpr ); 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 char_literal54 = null; IToken IF55 = null; IToken char_literal56 = null; IToken char_literal58 = null; IToken ELSE60 = null; IToken WHILE62 = null; IToken char_literal63 = null; IToken char_literal65 = null; IToken FOR67 = null; IToken char_literal68 = null; IToken char_literal70 = null; IToken char_literal72 = null; IToken char_literal74 = null; IToken REPEAT76 = null; IToken UNTIL78 = null; IToken RETURN80 = null; IToken char_literal82 = null; IToken char_literal84 = null; MathExprParser.expr0_return expr053 = default(MathExprParser.expr0_return); MathExprParser.term_return term57 = default(MathExprParser.term_return); MathExprParser.expr_return expr59 = default(MathExprParser.expr_return); MathExprParser.expr_return expr61 = default(MathExprParser.expr_return); MathExprParser.term_return term64 = default(MathExprParser.term_return); MathExprParser.expr_return expr66 = default(MathExprParser.expr_return); MathExprParser.exprList2_return exprList269 = default(MathExprParser.exprList2_return); MathExprParser.termOrTrue_return termOrTrue71 = default(MathExprParser.termOrTrue_return); MathExprParser.exprList2_return exprList273 = default(MathExprParser.exprList2_return); MathExprParser.expr_return expr75 = default(MathExprParser.expr_return); MathExprParser.expr_return expr77 = default(MathExprParser.expr_return); MathExprParser.term_return term79 = default(MathExprParser.term_return); MathExprParser.term_return term81 = default(MathExprParser.term_return); MathExprParser.call_return call83 = default(MathExprParser.call_return); MathExprParser.blockExpr_return blockExpr85 = default(MathExprParser.blockExpr_return); AstNode char_literal54_tree=null; AstNode IF55_tree=null; AstNode char_literal56_tree=null; AstNode char_literal58_tree=null; AstNode ELSE60_tree=null; AstNode WHILE62_tree=null; AstNode char_literal63_tree=null; AstNode char_literal65_tree=null; AstNode FOR67_tree=null; AstNode char_literal68_tree=null; AstNode char_literal70_tree=null; AstNode char_literal72_tree=null; AstNode char_literal74_tree=null; AstNode REPEAT76_tree=null; AstNode UNTIL78_tree=null; AstNode RETURN80_tree=null; AstNode char_literal82_tree=null; AstNode char_literal84_tree=null; try { if ( (state.backtracking > 0) && AlreadyParsedRule(input, 17) ) { return retval; } // MathExpr.g:124:5: ( expr0 ';' | IF '(' term ')' expr ( ELSE expr )? | WHILE '(' term ')' expr | FOR '(' exprList2 ';' termOrTrue ';' exprList2 ')' expr | REPEAT expr UNTIL term | RETURN term ';' | call ';' | blockExpr ) int alt15 = 8; alt15 = dfa15.Predict(input); switch (alt15) { case 1 : // MathExpr.g:125:3: expr0 ';' { root_0 = (AstNode)adaptor.GetNilNode(); PushFollow(FOLLOW_expr0_in_expr1288); expr053 = expr0(); state.followingStackPointer--; if (state.failed) return retval; if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expr053.Tree); char_literal54=(IToken)Match(input,55,FOLLOW_55_in_expr1290); if (state.failed) return retval; } break; case 2 : // MathExpr.g:126:3: IF '(' term ')' expr ( ELSE expr )? { root_0 = (AstNode)adaptor.GetNilNode(); IF55=(IToken)Match(input,IF,FOLLOW_IF_in_expr1295); if (state.failed) return retval; if ( state.backtracking == 0 ) {IF55_tree = (AstNode)adaptor.Create(IF55); root_0 = (AstNode)adaptor.BecomeRoot(IF55_tree, root_0); } char_literal56=(IToken)Match(input,51,FOLLOW_51_in_expr1298); if (state.failed) return retval; PushFollow(FOLLOW_term_in_expr1301); term57 = term(); state.followingStackPointer--; if (state.failed) return retval; if ( state.backtracking == 0 ) adaptor.AddChild(root_0, term57.Tree); char_literal58=(IToken)Match(input,52,FOLLOW_52_in_expr1303); if (state.failed) return retval; PushFollow(FOLLOW_expr_in_expr1306); expr59 = expr(); state.followingStackPointer--; if (state.failed) return retval; if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expr59.Tree); // MathExpr.g:126:27: ( ELSE expr )? int alt14 = 2; int LA14_0 = input.LA(1); if ( (LA14_0 == ELSE) ) { int LA14_1 = input.LA(2); if ( (synpred32_MathExpr()) ) { alt14 = 1; } } switch (alt14) { case 1 : // MathExpr.g:126:28: ELSE expr { ELSE60=(IToken)Match(input,ELSE,FOLLOW_ELSE_in_expr1309); if (state.failed) return retval; PushFollow(FOLLOW_expr_in_expr1312); expr61 = expr(); state.followingStackPointer--; if (state.failed) return retval; if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expr61.Tree); } break; } } break; case 3 : // MathExpr.g:127:3: WHILE '(' term ')' expr { root_0 = (AstNode)adaptor.GetNilNode(); WHILE62=(IToken)Match(input,WHILE,FOLLOW_WHILE_in_expr1318); if (state.failed) return retval; if ( state.backtracking == 0 ) {WHILE62_tree = (AstNode)adaptor.Create(WHILE62); root_0 = (AstNode)adaptor.BecomeRoot(WHILE62_tree, root_0); } char_literal63=(IToken)Match(input,51,FOLLOW_51_in_expr1321); if (state.failed) return retval; PushFollow(FOLLOW_term_in_expr1324); term64 = term(); state.followingStackPointer--; if (state.failed) return retval; if ( state.backtracking == 0 ) adaptor.AddChild(root_0, term64.Tree); char_literal65=(IToken)Match(input,52,FOLLOW_52_in_expr1326); if (state.failed) return retval; PushFollow(FOLLOW_expr_in_expr1329); expr66 = expr(); state.followingStackPointer--; if (state.failed) return retval; if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expr66.Tree); } break; case 4 : // MathExpr.g:128:3: FOR '(' exprList2 ';' termOrTrue ';' exprList2 ')' expr { root_0 = (AstNode)adaptor.GetNilNode(); FOR67=(IToken)Match(input,FOR,FOLLOW_FOR_in_expr1333); if (state.failed) return retval; if ( state.backtracking == 0 ) {FOR67_tree = (AstNode)adaptor.Create(FOR67); root_0 = (AstNode)adaptor.BecomeRoot(FOR67_tree, root_0); } char_literal68=(IToken)Match(input,51,FOLLOW_51_in_expr1336); if (state.failed) return retval; PushFollow(FOLLOW_exprList2_in_expr1339); exprList269 = exprList2(); state.followingStackPointer--; if (state.failed) return retval; if ( state.backtracking == 0 ) adaptor.AddChild(root_0, exprList269.Tree); char_literal70=(IToken)Match(input,55,FOLLOW_55_in_expr1341); if (state.failed) return retval; PushFollow(FOLLOW_termOrTrue_in_expr1344); termOrTrue71 = termOrTrue(); state.followingStackPointer--; if (state.failed) return retval; if ( state.backtracking == 0 ) adaptor.AddChild(root_0, termOrTrue71.Tree); char_literal72=(IToken)Match(input,55,FOLLOW_55_in_expr1346); if (state.failed) return retval; PushFollow(FOLLOW_exprList2_in_expr1349); exprList273 = exprList2(); state.followingStackPointer--; if (state.failed) return retval; if ( state.backtracking == 0 ) adaptor.AddChild(root_0, exprList273.Tree); char_literal74=(IToken)Match(input,52,FOLLOW_52_in_expr1351); if (state.failed) return retval; PushFollow(FOLLOW_expr_in_expr1354); expr75 = expr(); state.followingStackPointer--; if (state.failed) return retval; if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expr75.Tree); } break; case 5 : // MathExpr.g:129:3: REPEAT expr UNTIL term { root_0 = (AstNode)adaptor.GetNilNode(); REPEAT76=(IToken)Match(input,REPEAT,FOLLOW_REPEAT_in_expr1358); if (state.failed) return retval; if ( state.backtracking == 0 ) {REPEAT76_tree = (AstNode)adaptor.Create(REPEAT76); root_0 = (AstNode)adaptor.BecomeRoot(REPEAT76_tree, root_0); } PushFollow(FOLLOW_expr_in_expr1361); expr77 = expr(); state.followingStackPointer--; if (state.failed) return retval; if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expr77.Tree); UNTIL78=(IToken)Match(input,UNTIL,FOLLOW_UNTIL_in_expr1363); if (state.failed) return retval; PushFollow(FOLLOW_term_in_expr1366); term79 = term(); state.followingStackPointer--; if (state.failed) return retval; if ( state.backtracking == 0 ) adaptor.AddChild(root_0, term79.Tree); } break; case 6 : // MathExpr.g:130:3: RETURN term ';' { root_0 = (AstNode)adaptor.GetNilNode(); RETURN80=(IToken)Match(input,RETURN,FOLLOW_RETURN_in_expr1370); if (state.failed) return retval; if ( state.backtracking == 0 ) {RETURN80_tree = (AstNode)adaptor.Create(RETURN80); root_0 = (AstNode)adaptor.BecomeRoot(RETURN80_tree, root_0); } PushFollow(FOLLOW_term_in_expr1373); term81 = term(); state.followingStackPointer--; if (state.failed) return retval; if ( state.backtracking == 0 ) adaptor.AddChild(root_0, term81.Tree); char_literal82=(IToken)Match(input,55,FOLLOW_55_in_expr1375); if (state.failed) return retval; } break; case 7 : // MathExpr.g:131:3: call ';' { root_0 = (AstNode)adaptor.GetNilNode(); PushFollow(FOLLOW_call_in_expr1380); call83 = call(); state.followingStackPointer--; if (state.failed) return retval; if ( state.backtracking == 0 ) adaptor.AddChild(root_0, call83.Tree); char_literal84=(IToken)Match(input,55,FOLLOW_55_in_expr1382); if (state.failed) return retval; } break; case 8 : // MathExpr.g:132:3: blockExpr { root_0 = (AstNode)adaptor.GetNilNode(); PushFollow(FOLLOW_blockExpr_in_expr1388); blockExpr85 = blockExpr(); state.followingStackPointer--; if (state.failed) return retval; if ( state.backtracking == 0 ) adaptor.AddChild(root_0, blockExpr85.Tree); } 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, 17, expr_StartIndex); } } return retval; }
// $ANTLR start "expr" // antlr_temp_dir\\MathExpr.g:86:1: expr : ( PRINT term | ident ASSIGN term ); public MathExprParser.expr_return expr() // throws RecognitionException [1] { MathExprParser.expr_return retval = new MathExprParser.expr_return(); retval.Start = input.LT(1); object root_0 = null; IToken PRINT13 = null; IToken ASSIGN16 = null; MathExprParser.term_return term14 = default(MathExprParser.term_return); MathExprParser.ident_return ident15 = default(MathExprParser.ident_return); MathExprParser.term_return term17 = default(MathExprParser.term_return); object PRINT13_tree=null; object ASSIGN16_tree=null; try { // antlr_temp_dir\\MathExpr.g:86:5: ( PRINT term | ident ASSIGN term ) int alt4 = 2; int LA4_0 = input.LA(1); if ( (LA4_0 == PRINT) ) { alt4 = 1; } else if ( (LA4_0 == IDENT) ) { alt4 = 2; } else { NoViableAltException nvae_d4s0 = new NoViableAltException("", 4, 0, input); throw nvae_d4s0; } switch (alt4) { case 1 : // antlr_temp_dir\\MathExpr.g:87:3: PRINT term { root_0 = (object)adaptor.GetNilNode(); PRINT13=(IToken)Match(input,PRINT,FOLLOW_PRINT_in_expr463); PRINT13_tree = (object)adaptor.Create(PRINT13); root_0 = (object)adaptor.BecomeRoot(PRINT13_tree, root_0); PushFollow(FOLLOW_term_in_expr466); term14 = term(); state.followingStackPointer--; adaptor.AddChild(root_0, term14.Tree); } break; case 2 : // antlr_temp_dir\\MathExpr.g:88:3: ident ASSIGN term { root_0 = (object)adaptor.GetNilNode(); PushFollow(FOLLOW_ident_in_expr470); ident15 = ident(); state.followingStackPointer--; adaptor.AddChild(root_0, ident15.Tree); ASSIGN16=(IToken)Match(input,ASSIGN,FOLLOW_ASSIGN_in_expr472); ASSIGN16_tree = (object)adaptor.Create(ASSIGN16); root_0 = (object)adaptor.BecomeRoot(ASSIGN16_tree, root_0); PushFollow(FOLLOW_term_in_expr475); term17 = term(); state.followingStackPointer--; adaptor.AddChild(root_0, term17.Tree); } break; } retval.Stop = input.LT(-1); retval.Tree = (object)adaptor.RulePostProcessing(root_0); adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop); } catch (RecognitionException re) { ReportError(re); Recover(input,re); // Conversion of the second argument necessary, but harmless retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re); } finally { } return retval; }
// $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; }