// $ANTLR start "caseExpression" // Hql.g:517:1: caseExpression : ( CASE ( whenClause )+ ( elseClause )? END -> ^( CASE ( whenClause )+ ( elseClause )? ) | CASE unaryExpression ( altWhenClause )+ ( elseClause )? END -> ^( CASE2 unaryExpression ( altWhenClause )+ ( elseClause )? ) ); public HqlParser.caseExpression_return caseExpression() // throws RecognitionException [1] { HqlParser.caseExpression_return retval = new HqlParser.caseExpression_return(); retval.Start = input.LT(1); IASTNode root_0 = null; IToken CASE207 = null; IToken END210 = null; IToken CASE211 = null; IToken END215 = null; HqlParser.whenClause_return whenClause208 = default(HqlParser.whenClause_return); HqlParser.elseClause_return elseClause209 = default(HqlParser.elseClause_return); HqlParser.unaryExpression_return unaryExpression212 = default(HqlParser.unaryExpression_return); HqlParser.altWhenClause_return altWhenClause213 = default(HqlParser.altWhenClause_return); HqlParser.elseClause_return elseClause214 = default(HqlParser.elseClause_return); IASTNode CASE207_tree=null; IASTNode END210_tree=null; IASTNode CASE211_tree=null; IASTNode END215_tree=null; RewriteRuleTokenStream stream_END = new RewriteRuleTokenStream(adaptor,"token END"); RewriteRuleTokenStream stream_CASE = new RewriteRuleTokenStream(adaptor,"token CASE"); RewriteRuleSubtreeStream stream_whenClause = new RewriteRuleSubtreeStream(adaptor,"rule whenClause"); RewriteRuleSubtreeStream stream_unaryExpression = new RewriteRuleSubtreeStream(adaptor,"rule unaryExpression"); RewriteRuleSubtreeStream stream_altWhenClause = new RewriteRuleSubtreeStream(adaptor,"rule altWhenClause"); RewriteRuleSubtreeStream stream_elseClause = new RewriteRuleSubtreeStream(adaptor,"rule elseClause"); try { // Hql.g:518:2: ( CASE ( whenClause )+ ( elseClause )? END -> ^( CASE ( whenClause )+ ( elseClause )? ) | CASE unaryExpression ( altWhenClause )+ ( elseClause )? END -> ^( CASE2 unaryExpression ( altWhenClause )+ ( elseClause )? ) ) int alt79 = 2; int LA79_0 = input.LA(1); if ( (LA79_0 == CASE) ) { int LA79_1 = input.LA(2); if ( ((LA79_1 >= ALL && LA79_1 <= ANY) || LA79_1 == AVG || LA79_1 == COUNT || LA79_1 == ELEMENTS || (LA79_1 >= EXISTS && LA79_1 <= FALSE) || LA79_1 == INDICES || (LA79_1 >= MAX && LA79_1 <= MIN) || LA79_1 == NULL || (LA79_1 >= SOME && LA79_1 <= SUM) || LA79_1 == TRUE || LA79_1 == CASE || LA79_1 == EMPTY || (LA79_1 >= NUM_INT && LA79_1 <= NUM_LONG) || LA79_1 == OPEN || (LA79_1 >= COLON && LA79_1 <= PARAM) || (LA79_1 >= PLUS && LA79_1 <= MINUS) || (LA79_1 >= QUOTED_String && LA79_1 <= IDENT)) ) { alt79 = 2; } else if ( (LA79_1 == WHEN) ) { alt79 = 1; } else { NoViableAltException nvae_d79s1 = new NoViableAltException("", 79, 1, input); throw nvae_d79s1; } } else { NoViableAltException nvae_d79s0 = new NoViableAltException("", 79, 0, input); throw nvae_d79s0; } switch (alt79) { case 1 : // Hql.g:518:4: CASE ( whenClause )+ ( elseClause )? END { CASE207=(IToken)Match(input,CASE,FOLLOW_CASE_in_caseExpression2588); stream_CASE.Add(CASE207); // Hql.g:518:9: ( whenClause )+ int cnt75 = 0; do { int alt75 = 2; int LA75_0 = input.LA(1); if ( (LA75_0 == WHEN) ) { alt75 = 1; } switch (alt75) { case 1 : // Hql.g:518:10: whenClause { PushFollow(FOLLOW_whenClause_in_caseExpression2591); whenClause208 = whenClause(); state.followingStackPointer--; stream_whenClause.Add(whenClause208.Tree); } break; default: if ( cnt75 >= 1 ) goto loop75; EarlyExitException eee75 = new EarlyExitException(75, input); throw eee75; } cnt75++; } while (true); loop75: ; // Stops C# compiler whining that label 'loop75' has no statements // Hql.g:518:23: ( elseClause )? int alt76 = 2; int LA76_0 = input.LA(1); if ( (LA76_0 == ELSE) ) { alt76 = 1; } switch (alt76) { case 1 : // Hql.g:518:24: elseClause { PushFollow(FOLLOW_elseClause_in_caseExpression2596); elseClause209 = elseClause(); state.followingStackPointer--; stream_elseClause.Add(elseClause209.Tree); } break; } END210=(IToken)Match(input,END,FOLLOW_END_in_caseExpression2600); stream_END.Add(END210); // AST REWRITE // elements: whenClause, CASE, elseClause // 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(); // 519:3: -> ^( CASE ( whenClause )+ ( elseClause )? ) { // Hql.g:519:6: ^( CASE ( whenClause )+ ( elseClause )? ) { IASTNode root_1 = (IASTNode)adaptor.GetNilNode(); root_1 = (IASTNode)adaptor.BecomeRoot(stream_CASE.NextNode(), root_1); if ( !(stream_whenClause.HasNext()) ) { throw new RewriteEarlyExitException(); } while ( stream_whenClause.HasNext() ) { adaptor.AddChild(root_1, stream_whenClause.NextTree()); } stream_whenClause.Reset(); // Hql.g:519:25: ( elseClause )? if ( stream_elseClause.HasNext() ) { adaptor.AddChild(root_1, stream_elseClause.NextTree()); } stream_elseClause.Reset(); adaptor.AddChild(root_0, root_1); } } retval.Tree = root_0;retval.Tree = root_0; } break; case 2 : // Hql.g:520:4: CASE unaryExpression ( altWhenClause )+ ( elseClause )? END { CASE211=(IToken)Match(input,CASE,FOLLOW_CASE_in_caseExpression2620); stream_CASE.Add(CASE211); PushFollow(FOLLOW_unaryExpression_in_caseExpression2622); unaryExpression212 = unaryExpression(); state.followingStackPointer--; stream_unaryExpression.Add(unaryExpression212.Tree); // Hql.g:520:25: ( altWhenClause )+ int cnt77 = 0; do { int alt77 = 2; int LA77_0 = input.LA(1); if ( (LA77_0 == WHEN) ) { alt77 = 1; } switch (alt77) { case 1 : // Hql.g:520:26: altWhenClause { PushFollow(FOLLOW_altWhenClause_in_caseExpression2625); altWhenClause213 = altWhenClause(); state.followingStackPointer--; stream_altWhenClause.Add(altWhenClause213.Tree); } break; default: if ( cnt77 >= 1 ) goto loop77; EarlyExitException eee77 = new EarlyExitException(77, input); throw eee77; } cnt77++; } while (true); loop77: ; // Stops C# compiler whining that label 'loop77' has no statements // Hql.g:520:42: ( elseClause )? int alt78 = 2; int LA78_0 = input.LA(1); if ( (LA78_0 == ELSE) ) { alt78 = 1; } switch (alt78) { case 1 : // Hql.g:520:43: elseClause { PushFollow(FOLLOW_elseClause_in_caseExpression2630); elseClause214 = elseClause(); state.followingStackPointer--; stream_elseClause.Add(elseClause214.Tree); } break; } END215=(IToken)Match(input,END,FOLLOW_END_in_caseExpression2634); stream_END.Add(END215); // AST REWRITE // elements: elseClause, altWhenClause, unaryExpression // 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(); // 521:3: -> ^( CASE2 unaryExpression ( altWhenClause )+ ( elseClause )? ) { // Hql.g:521:6: ^( CASE2 unaryExpression ( altWhenClause )+ ( elseClause )? ) { IASTNode root_1 = (IASTNode)adaptor.GetNilNode(); root_1 = (IASTNode)adaptor.BecomeRoot((IASTNode)adaptor.Create(CASE2, "CASE2"), root_1); adaptor.AddChild(root_1, stream_unaryExpression.NextTree()); if ( !(stream_altWhenClause.HasNext()) ) { throw new RewriteEarlyExitException(); } while ( stream_altWhenClause.HasNext() ) { adaptor.AddChild(root_1, stream_altWhenClause.NextTree()); } stream_altWhenClause.Reset(); // Hql.g:521:45: ( elseClause )? if ( stream_elseClause.HasNext() ) { adaptor.AddChild(root_1, stream_elseClause.NextTree()); } stream_elseClause.Reset(); 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 "caseExpression" // /Users/Steve/Projects/NHibernate/Branches/2.1.x/nhibernate/src/NHibernate/Hql/Ast/ANTLR/Hql.g:499:1: caseExpression : ( CASE ( whenClause )+ ( elseClause )? END -> ^( CASE whenClause ( elseClause )? ) | CASE unaryExpression ( altWhenClause )+ ( elseClause )? END -> ^( CASE2 unaryExpression ( altWhenClause )+ ( elseClause )? ) ); public HqlParser.caseExpression_return caseExpression() // throws RecognitionException [1] { HqlParser.caseExpression_return retval = new HqlParser.caseExpression_return(); retval.Start = input.LT(1); IASTNode root_0 = null; IToken CASE194 = null; IToken END197 = null; IToken CASE198 = null; IToken END202 = null; HqlParser.whenClause_return whenClause195 = default(HqlParser.whenClause_return); HqlParser.elseClause_return elseClause196 = default(HqlParser.elseClause_return); HqlParser.unaryExpression_return unaryExpression199 = default(HqlParser.unaryExpression_return); HqlParser.altWhenClause_return altWhenClause200 = default(HqlParser.altWhenClause_return); HqlParser.elseClause_return elseClause201 = default(HqlParser.elseClause_return); IASTNode CASE194_tree=null; IASTNode END197_tree=null; IASTNode CASE198_tree=null; IASTNode END202_tree=null; RewriteRuleTokenStream stream_CASE = new RewriteRuleTokenStream(adaptor,"token CASE"); RewriteRuleTokenStream stream_END = new RewriteRuleTokenStream(adaptor,"token END"); RewriteRuleSubtreeStream stream_unaryExpression = new RewriteRuleSubtreeStream(adaptor,"rule unaryExpression"); RewriteRuleSubtreeStream stream_whenClause = new RewriteRuleSubtreeStream(adaptor,"rule whenClause"); RewriteRuleSubtreeStream stream_elseClause = new RewriteRuleSubtreeStream(adaptor,"rule elseClause"); RewriteRuleSubtreeStream stream_altWhenClause = new RewriteRuleSubtreeStream(adaptor,"rule altWhenClause"); try { // /Users/Steve/Projects/NHibernate/Branches/2.1.x/nhibernate/src/NHibernate/Hql/Ast/ANTLR/Hql.g:500:2: ( CASE ( whenClause )+ ( elseClause )? END -> ^( CASE whenClause ( elseClause )? ) | CASE unaryExpression ( altWhenClause )+ ( elseClause )? END -> ^( CASE2 unaryExpression ( altWhenClause )+ ( elseClause )? ) ) int alt73 = 2; int LA73_0 = input.LA(1); if ( (LA73_0 == CASE) ) { int LA73_1 = input.LA(2); if ( (LA73_1 == WHEN) ) { alt73 = 1; } else if ( ((LA73_1 >= ALL && LA73_1 <= ANY) || LA73_1 == AVG || LA73_1 == COUNT || LA73_1 == ELEMENTS || (LA73_1 >= EXISTS && LA73_1 <= FALSE) || LA73_1 == INDICES || (LA73_1 >= MAX && LA73_1 <= MIN) || LA73_1 == NULL || (LA73_1 >= SOME && LA73_1 <= TRUE) || LA73_1 == CASE || LA73_1 == EMPTY || (LA73_1 >= NUM_INT && LA73_1 <= NUM_LONG) || LA73_1 == OPEN || (LA73_1 >= PLUS && LA73_1 <= MINUS) || (LA73_1 >= COLON && LA73_1 <= IDENT)) ) { alt73 = 2; } else { NoViableAltException nvae_d73s1 = new NoViableAltException("", 73, 1, input); throw nvae_d73s1; } } else { NoViableAltException nvae_d73s0 = new NoViableAltException("", 73, 0, input); throw nvae_d73s0; } switch (alt73) { case 1 : // /Users/Steve/Projects/NHibernate/Branches/2.1.x/nhibernate/src/NHibernate/Hql/Ast/ANTLR/Hql.g:500:4: CASE ( whenClause )+ ( elseClause )? END { CASE194=(IToken)Match(input,CASE,FOLLOW_CASE_in_caseExpression2490); stream_CASE.Add(CASE194); // /Users/Steve/Projects/NHibernate/Branches/2.1.x/nhibernate/src/NHibernate/Hql/Ast/ANTLR/Hql.g:500:9: ( whenClause )+ int cnt69 = 0; do { int alt69 = 2; int LA69_0 = input.LA(1); if ( (LA69_0 == WHEN) ) { alt69 = 1; } switch (alt69) { case 1 : // /Users/Steve/Projects/NHibernate/Branches/2.1.x/nhibernate/src/NHibernate/Hql/Ast/ANTLR/Hql.g:500:10: whenClause { PushFollow(FOLLOW_whenClause_in_caseExpression2493); whenClause195 = whenClause(); state.followingStackPointer--; stream_whenClause.Add(whenClause195.Tree); } break; default: if ( cnt69 >= 1 ) goto loop69; EarlyExitException eee69 = new EarlyExitException(69, input); throw eee69; } cnt69++; } while (true); loop69: ; // Stops C# compiler whinging that label 'loop69' has no statements // /Users/Steve/Projects/NHibernate/Branches/2.1.x/nhibernate/src/NHibernate/Hql/Ast/ANTLR/Hql.g:500:23: ( elseClause )? int alt70 = 2; int LA70_0 = input.LA(1); if ( (LA70_0 == ELSE) ) { alt70 = 1; } switch (alt70) { case 1 : // /Users/Steve/Projects/NHibernate/Branches/2.1.x/nhibernate/src/NHibernate/Hql/Ast/ANTLR/Hql.g:500:24: elseClause { PushFollow(FOLLOW_elseClause_in_caseExpression2498); elseClause196 = elseClause(); state.followingStackPointer--; stream_elseClause.Add(elseClause196.Tree); } break; } END197=(IToken)Match(input,END,FOLLOW_END_in_caseExpression2502); stream_END.Add(END197); // AST REWRITE // elements: whenClause, elseClause, CASE // 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(); // 501:3: -> ^( CASE whenClause ( elseClause )? ) { // /Users/Steve/Projects/NHibernate/Branches/2.1.x/nhibernate/src/NHibernate/Hql/Ast/ANTLR/Hql.g:501:6: ^( CASE whenClause ( elseClause )? ) { IASTNode root_1 = (IASTNode)adaptor.GetNilNode(); root_1 = (IASTNode)adaptor.BecomeRoot(stream_CASE.NextNode(), root_1); adaptor.AddChild(root_1, stream_whenClause.NextTree()); // /Users/Steve/Projects/NHibernate/Branches/2.1.x/nhibernate/src/NHibernate/Hql/Ast/ANTLR/Hql.g:501:24: ( elseClause )? if ( stream_elseClause.HasNext() ) { adaptor.AddChild(root_1, stream_elseClause.NextTree()); } stream_elseClause.Reset(); 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:502:4: CASE unaryExpression ( altWhenClause )+ ( elseClause )? END { CASE198=(IToken)Match(input,CASE,FOLLOW_CASE_in_caseExpression2521); stream_CASE.Add(CASE198); PushFollow(FOLLOW_unaryExpression_in_caseExpression2523); unaryExpression199 = unaryExpression(); state.followingStackPointer--; stream_unaryExpression.Add(unaryExpression199.Tree); // /Users/Steve/Projects/NHibernate/Branches/2.1.x/nhibernate/src/NHibernate/Hql/Ast/ANTLR/Hql.g:502:25: ( altWhenClause )+ int cnt71 = 0; do { int alt71 = 2; int LA71_0 = input.LA(1); if ( (LA71_0 == WHEN) ) { alt71 = 1; } switch (alt71) { case 1 : // /Users/Steve/Projects/NHibernate/Branches/2.1.x/nhibernate/src/NHibernate/Hql/Ast/ANTLR/Hql.g:502:26: altWhenClause { PushFollow(FOLLOW_altWhenClause_in_caseExpression2526); altWhenClause200 = altWhenClause(); state.followingStackPointer--; stream_altWhenClause.Add(altWhenClause200.Tree); } break; default: if ( cnt71 >= 1 ) goto loop71; EarlyExitException eee71 = new EarlyExitException(71, input); throw eee71; } cnt71++; } while (true); loop71: ; // Stops C# compiler whinging that label 'loop71' has no statements // /Users/Steve/Projects/NHibernate/Branches/2.1.x/nhibernate/src/NHibernate/Hql/Ast/ANTLR/Hql.g:502:42: ( elseClause )? int alt72 = 2; int LA72_0 = input.LA(1); if ( (LA72_0 == ELSE) ) { alt72 = 1; } switch (alt72) { case 1 : // /Users/Steve/Projects/NHibernate/Branches/2.1.x/nhibernate/src/NHibernate/Hql/Ast/ANTLR/Hql.g:502:43: elseClause { PushFollow(FOLLOW_elseClause_in_caseExpression2531); elseClause201 = elseClause(); state.followingStackPointer--; stream_elseClause.Add(elseClause201.Tree); } break; } END202=(IToken)Match(input,END,FOLLOW_END_in_caseExpression2535); stream_END.Add(END202); // AST REWRITE // elements: altWhenClause, elseClause, unaryExpression // 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(); // 503:3: -> ^( CASE2 unaryExpression ( altWhenClause )+ ( elseClause )? ) { // /Users/Steve/Projects/NHibernate/Branches/2.1.x/nhibernate/src/NHibernate/Hql/Ast/ANTLR/Hql.g:503:6: ^( CASE2 unaryExpression ( altWhenClause )+ ( elseClause )? ) { IASTNode root_1 = (IASTNode)adaptor.GetNilNode(); root_1 = (IASTNode)adaptor.BecomeRoot((IASTNode)adaptor.Create(CASE2, "CASE2"), root_1); adaptor.AddChild(root_1, stream_unaryExpression.NextTree()); if ( !(stream_altWhenClause.HasNext()) ) { throw new RewriteEarlyExitException(); } while ( stream_altWhenClause.HasNext() ) { adaptor.AddChild(root_1, stream_altWhenClause.NextTree()); } stream_altWhenClause.Reset(); // /Users/Steve/Projects/NHibernate/Branches/2.1.x/nhibernate/src/NHibernate/Hql/Ast/ANTLR/Hql.g:503:45: ( elseClause )? if ( stream_elseClause.HasNext() ) { adaptor.AddChild(root_1, stream_elseClause.NextTree()); } stream_elseClause.Reset(); 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 "caseExpression" // Hql.g:512:1: caseExpression : ( CASE ( whenClause )+ ( elseClause )? END -> ^( CASE ( whenClause )+ ( elseClause )? ) | CASE unaryExpression ( altWhenClause )+ ( elseClause )? END -> ^( CASE2 unaryExpression ( altWhenClause )+ ( elseClause )? ) ); public HqlParser.caseExpression_return caseExpression() // throws RecognitionException [1] { HqlParser.caseExpression_return retval = new HqlParser.caseExpression_return(); retval.Start = input.LT(1); IASTNode root_0 = null; IToken CASE201 = null; IToken END204 = null; IToken CASE205 = null; IToken END209 = null; HqlParser.whenClause_return whenClause202 = default(HqlParser.whenClause_return); HqlParser.elseClause_return elseClause203 = default(HqlParser.elseClause_return); HqlParser.unaryExpression_return unaryExpression206 = default(HqlParser.unaryExpression_return); HqlParser.altWhenClause_return altWhenClause207 = default(HqlParser.altWhenClause_return); HqlParser.elseClause_return elseClause208 = default(HqlParser.elseClause_return); IASTNode CASE201_tree=null; IASTNode END204_tree=null; IASTNode CASE205_tree=null; IASTNode END209_tree=null; RewriteRuleTokenStream stream_END = new RewriteRuleTokenStream(adaptor,"token END"); RewriteRuleTokenStream stream_CASE = new RewriteRuleTokenStream(adaptor,"token CASE"); RewriteRuleSubtreeStream stream_whenClause = new RewriteRuleSubtreeStream(adaptor,"rule whenClause"); RewriteRuleSubtreeStream stream_unaryExpression = new RewriteRuleSubtreeStream(adaptor,"rule unaryExpression"); RewriteRuleSubtreeStream stream_altWhenClause = new RewriteRuleSubtreeStream(adaptor,"rule altWhenClause"); RewriteRuleSubtreeStream stream_elseClause = new RewriteRuleSubtreeStream(adaptor,"rule elseClause"); try { // Hql.g:513:2: ( CASE ( whenClause )+ ( elseClause )? END -> ^( CASE ( whenClause )+ ( elseClause )? ) | CASE unaryExpression ( altWhenClause )+ ( elseClause )? END -> ^( CASE2 unaryExpression ( altWhenClause )+ ( elseClause )? ) ) int alt75 = 2; int LA75_0 = input.LA(1); if ( (LA75_0 == CASE) ) { int LA75_1 = input.LA(2); if ( ((LA75_1 >= ALL && LA75_1 <= ANY) || LA75_1 == AVG || LA75_1 == COUNT || LA75_1 == ELEMENTS || (LA75_1 >= EXISTS && LA75_1 <= FALSE) || LA75_1 == INDICES || (LA75_1 >= MAX && LA75_1 <= MIN) || LA75_1 == NULL || (LA75_1 >= SOME && LA75_1 <= SUM) || LA75_1 == TRUE || LA75_1 == CASE || LA75_1 == EMPTY || (LA75_1 >= NUM_INT && LA75_1 <= NUM_LONG) || LA75_1 == OPEN || (LA75_1 >= PLUS && LA75_1 <= MINUS) || (LA75_1 >= COLON && LA75_1 <= IDENT)) ) { alt75 = 2; } else if ( (LA75_1 == WHEN) ) { alt75 = 1; } else { NoViableAltException nvae_d75s1 = new NoViableAltException("", 75, 1, input); throw nvae_d75s1; } } else { NoViableAltException nvae_d75s0 = new NoViableAltException("", 75, 0, input); throw nvae_d75s0; } switch (alt75) { case 1 : // Hql.g:513:4: CASE ( whenClause )+ ( elseClause )? END { CASE201=(IToken)Match(input,CASE,FOLLOW_CASE_in_caseExpression2551); stream_CASE.Add(CASE201); // Hql.g:513:9: ( whenClause )+ int cnt71 = 0; do { int alt71 = 2; int LA71_0 = input.LA(1); if ( (LA71_0 == WHEN) ) { alt71 = 1; } switch (alt71) { case 1 : // Hql.g:513:10: whenClause { PushFollow(FOLLOW_whenClause_in_caseExpression2554); whenClause202 = whenClause(); state.followingStackPointer--; stream_whenClause.Add(whenClause202.Tree); } break; default: if ( cnt71 >= 1 ) goto loop71; EarlyExitException eee71 = new EarlyExitException(71, input); throw eee71; } cnt71++; } while (true); loop71: ; // Stops C# compiler whining that label 'loop71' has no statements // Hql.g:513:23: ( elseClause )? int alt72 = 2; int LA72_0 = input.LA(1); if ( (LA72_0 == ELSE) ) { alt72 = 1; } switch (alt72) { case 1 : // Hql.g:513:24: elseClause { PushFollow(FOLLOW_elseClause_in_caseExpression2559); elseClause203 = elseClause(); state.followingStackPointer--; stream_elseClause.Add(elseClause203.Tree); } break; } END204=(IToken)Match(input,END,FOLLOW_END_in_caseExpression2563); stream_END.Add(END204); // AST REWRITE // elements: whenClause, elseClause, CASE // 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(); // 514:3: -> ^( CASE ( whenClause )+ ( elseClause )? ) { // Hql.g:514:6: ^( CASE ( whenClause )+ ( elseClause )? ) { IASTNode root_1 = (IASTNode)adaptor.GetNilNode(); root_1 = (IASTNode)adaptor.BecomeRoot(stream_CASE.NextNode(), root_1); if ( !(stream_whenClause.HasNext()) ) { throw new RewriteEarlyExitException(); } while ( stream_whenClause.HasNext() ) { adaptor.AddChild(root_1, stream_whenClause.NextTree()); } stream_whenClause.Reset(); // Hql.g:514:25: ( elseClause )? if ( stream_elseClause.HasNext() ) { adaptor.AddChild(root_1, stream_elseClause.NextTree()); } stream_elseClause.Reset(); adaptor.AddChild(root_0, root_1); } } retval.Tree = root_0;retval.Tree = root_0; } break; case 2 : // Hql.g:515:4: CASE unaryExpression ( altWhenClause )+ ( elseClause )? END { CASE205=(IToken)Match(input,CASE,FOLLOW_CASE_in_caseExpression2583); stream_CASE.Add(CASE205); PushFollow(FOLLOW_unaryExpression_in_caseExpression2585); unaryExpression206 = unaryExpression(); state.followingStackPointer--; stream_unaryExpression.Add(unaryExpression206.Tree); // Hql.g:515:25: ( altWhenClause )+ int cnt73 = 0; do { int alt73 = 2; int LA73_0 = input.LA(1); if ( (LA73_0 == WHEN) ) { alt73 = 1; } switch (alt73) { case 1 : // Hql.g:515:26: altWhenClause { PushFollow(FOLLOW_altWhenClause_in_caseExpression2588); altWhenClause207 = altWhenClause(); state.followingStackPointer--; stream_altWhenClause.Add(altWhenClause207.Tree); } break; default: if ( cnt73 >= 1 ) goto loop73; EarlyExitException eee73 = new EarlyExitException(73, input); throw eee73; } cnt73++; } while (true); loop73: ; // Stops C# compiler whining that label 'loop73' has no statements // Hql.g:515:42: ( elseClause )? int alt74 = 2; int LA74_0 = input.LA(1); if ( (LA74_0 == ELSE) ) { alt74 = 1; } switch (alt74) { case 1 : // Hql.g:515:43: elseClause { PushFollow(FOLLOW_elseClause_in_caseExpression2593); elseClause208 = elseClause(); state.followingStackPointer--; stream_elseClause.Add(elseClause208.Tree); } break; } END209=(IToken)Match(input,END,FOLLOW_END_in_caseExpression2597); stream_END.Add(END209); // AST REWRITE // elements: altWhenClause, unaryExpression, elseClause // 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(); // 516:3: -> ^( CASE2 unaryExpression ( altWhenClause )+ ( elseClause )? ) { // Hql.g:516:6: ^( CASE2 unaryExpression ( altWhenClause )+ ( elseClause )? ) { IASTNode root_1 = (IASTNode)adaptor.GetNilNode(); root_1 = (IASTNode)adaptor.BecomeRoot((IASTNode)adaptor.Create(CASE2, "CASE2"), root_1); adaptor.AddChild(root_1, stream_unaryExpression.NextTree()); if ( !(stream_altWhenClause.HasNext()) ) { throw new RewriteEarlyExitException(); } while ( stream_altWhenClause.HasNext() ) { adaptor.AddChild(root_1, stream_altWhenClause.NextTree()); } stream_altWhenClause.Reset(); // Hql.g:516:45: ( elseClause )? if ( stream_elseClause.HasNext() ) { adaptor.AddChild(root_1, stream_elseClause.NextTree()); } stream_elseClause.Reset(); 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; }