private AstParserRuleReturnScope<CommonTree, IToken> lvalue()
{
EnterRule_lvalue();
EnterRule("lvalue", 101);
TraceIn("lvalue", 101);
AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>();
retval.Start = (IToken)input.LT(1);
CommonTree root_0 = default(CommonTree);
IToken char_literal958 = default(IToken);
IToken WS959 = default(IToken);
IToken WS961 = default(IToken);
IToken char_literal962 = default(IToken);
IToken WS963 = default(IToken);
IToken WS965 = default(IToken);
IToken char_literal966 = default(IToken);
AstParserRuleReturnScope<CommonTree, IToken> lvalue_item960 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> lvalue_item964 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> lvalue_item967 = default(AstParserRuleReturnScope<CommonTree, IToken>);
CommonTree char_literal958_tree = default(CommonTree);
CommonTree WS959_tree = default(CommonTree);
CommonTree WS961_tree = default(CommonTree);
CommonTree char_literal962_tree = default(CommonTree);
CommonTree WS963_tree = default(CommonTree);
CommonTree WS965_tree = default(CommonTree);
CommonTree char_literal966_tree = default(CommonTree);
RewriteRuleITokenStream stream_94=new RewriteRuleITokenStream(adaptor,"token 94");
RewriteRuleITokenStream stream_WS=new RewriteRuleITokenStream(adaptor,"token WS");
RewriteRuleITokenStream stream_93=new RewriteRuleITokenStream(adaptor,"token 93");
RewriteRuleITokenStream stream_100=new RewriteRuleITokenStream(adaptor,"token 100");
RewriteRuleSubtreeStream stream_lvalue_item=new RewriteRuleSubtreeStream(adaptor,"rule lvalue_item");
try { DebugEnterRule(GrammarFileName, "lvalue");
DebugLocation(759, 1);
try
{
// SugarCpp.g:760:2: ( '(' ( WS )* lvalue_item ( ( WS )* ',' ( WS )* lvalue_item )+ ( WS )* ')' -> ^( Match_Tuple ( lvalue_item )* ) | lvalue_item )
int alt624=2;
try { DebugEnterDecision(624, false);
int LA624_0 = input.LA(1);
if ((LA624_0==93))
{
alt624 = 1;
}
else if ((LA624_0==IDENT||LA624_0==86||LA624_0==91||LA624_0==95||(LA624_0>=97 && LA624_0<=98)||(LA624_0>=101 && LA624_0<=102)||LA624_0==131||LA624_0==161||LA624_0==186))
{
alt624 = 2;
}
else
{
if (state.backtracking>0) {state.failed=true; return retval;}
NoViableAltException nvae = new NoViableAltException("", 624, 0, input);
DebugRecognitionException(nvae);
throw nvae;
}
} finally { DebugExitDecision(624); }
switch (alt624)
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:760:4: '(' ( WS )* lvalue_item ( ( WS )* ',' ( WS )* lvalue_item )+ ( WS )* ')'
{
DebugLocation(760, 4);
char_literal958=(IToken)Match(input,93,Follow._93_in_lvalue9181); if (state.failed) return retval;
if (state.backtracking == 0) stream_93.Add(char_literal958);
DebugLocation(760, 8);
// SugarCpp.g:760:8: ( WS )*
try { DebugEnterSubRule(619);
while (true)
{
int alt619=2;
try { DebugEnterDecision(619, false);
int LA619_0 = input.LA(1);
if ((LA619_0==WS))
{
alt619 = 1;
}
} finally { DebugExitDecision(619); }
switch ( alt619 )
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:760:8: WS
{
DebugLocation(760, 8);
WS959=(IToken)Match(input,WS,Follow._WS_in_lvalue9183); if (state.failed) return retval;
if (state.backtracking == 0) stream_WS.Add(WS959);
}
break;
default:
goto loop619;
}
}
loop619:
;
} finally { DebugExitSubRule(619); }
DebugLocation(760, 12);
PushFollow(Follow._lvalue_item_in_lvalue9186);
lvalue_item960=lvalue_item();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_lvalue_item.Add(lvalue_item960.Tree);
DebugLocation(760, 24);
// SugarCpp.g:760:24: ( ( WS )* ',' ( WS )* lvalue_item )+
int cnt622=0;
try { DebugEnterSubRule(622);
while (true)
{
int alt622=2;
try { DebugEnterDecision(622, false);
try
{
alt622 = dfa622.Predict(input);
}
catch (NoViableAltException nvae)
{
DebugRecognitionException(nvae);
throw;
}
} finally { DebugExitDecision(622); }
switch (alt622)
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:760:25: ( WS )* ',' ( WS )* lvalue_item
{
DebugLocation(760, 25);
// SugarCpp.g:760:25: ( WS )*
try { DebugEnterSubRule(620);
while (true)
{
int alt620=2;
try { DebugEnterDecision(620, false);
int LA620_0 = input.LA(1);
if ((LA620_0==WS))
{
alt620 = 1;
}
} finally { DebugExitDecision(620); }
switch ( alt620 )
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:760:25: WS
{
DebugLocation(760, 25);
WS961=(IToken)Match(input,WS,Follow._WS_in_lvalue9189); if (state.failed) return retval;
if (state.backtracking == 0) stream_WS.Add(WS961);
}
break;
default:
goto loop620;
}
}
loop620:
;
} finally { DebugExitSubRule(620); }
DebugLocation(760, 29);
char_literal962=(IToken)Match(input,100,Follow._100_in_lvalue9192); if (state.failed) return retval;
if (state.backtracking == 0) stream_100.Add(char_literal962);
DebugLocation(760, 33);
// SugarCpp.g:760:33: ( WS )*
try { DebugEnterSubRule(621);
while (true)
{
int alt621=2;
try { DebugEnterDecision(621, false);
int LA621_0 = input.LA(1);
if ((LA621_0==WS))
{
alt621 = 1;
}
} finally { DebugExitDecision(621); }
switch ( alt621 )
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:760:33: WS
{
DebugLocation(760, 33);
WS963=(IToken)Match(input,WS,Follow._WS_in_lvalue9194); if (state.failed) return retval;
if (state.backtracking == 0) stream_WS.Add(WS963);
}
break;
default:
goto loop621;
}
}
loop621:
;
} finally { DebugExitSubRule(621); }
DebugLocation(760, 37);
PushFollow(Follow._lvalue_item_in_lvalue9197);
lvalue_item964=lvalue_item();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_lvalue_item.Add(lvalue_item964.Tree);
}
break;
default:
if (cnt622 >= 1)
goto loop622;
if (state.backtracking>0) {state.failed=true; return retval;}
EarlyExitException eee622 = new EarlyExitException( 622, input );
DebugRecognitionException(eee622);
throw eee622;
}
cnt622++;
}
loop622:
;
} finally { DebugExitSubRule(622); }
DebugLocation(760, 51);
// SugarCpp.g:760:51: ( WS )*
try { DebugEnterSubRule(623);
while (true)
{
int alt623=2;
try { DebugEnterDecision(623, false);
int LA623_0 = input.LA(1);
if ((LA623_0==WS))
{
alt623 = 1;
}
} finally { DebugExitDecision(623); }
switch ( alt623 )
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:760:51: WS
{
DebugLocation(760, 51);
WS965=(IToken)Match(input,WS,Follow._WS_in_lvalue9201); if (state.failed) return retval;
if (state.backtracking == 0) stream_WS.Add(WS965);
}
break;
default:
goto loop623;
}
}
loop623:
;
} finally { DebugExitSubRule(623); }
DebugLocation(760, 55);
char_literal966=(IToken)Match(input,94,Follow._94_in_lvalue9204); if (state.failed) return retval;
if (state.backtracking == 0) stream_94.Add(char_literal966);
{
// AST REWRITE
// elements: lvalue_item
// 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();
// 760:59: -> ^( Match_Tuple ( lvalue_item )* )
{
DebugLocation(760, 62);
// SugarCpp.g:760:62: ^( Match_Tuple ( lvalue_item )* )
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(760, 64);
root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(Match_Tuple, "Match_Tuple"), root_1);
DebugLocation(760, 76);
// SugarCpp.g:760:76: ( lvalue_item )*
while ( stream_lvalue_item.HasNext )
{
DebugLocation(760, 76);
adaptor.AddChild(root_1, stream_lvalue_item.NextTree());
}
stream_lvalue_item.Reset();
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;
}
}
}
break;
case 2:
DebugEnterAlt(2);
// SugarCpp.g:761:4: lvalue_item
{
root_0 = (CommonTree)adaptor.Nil();
DebugLocation(761, 4);
PushFollow(Follow._lvalue_item_in_lvalue9218);
lvalue_item967=lvalue_item();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) adaptor.AddChild(root_0, lvalue_item967.Tree);
}
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("lvalue", 101);
LeaveRule("lvalue", 101);
LeaveRule_lvalue();
}
DebugLocation(762, 1);
} finally { DebugExitRule(GrammarFileName, "lvalue"); }
return retval;
}
// $ANTLR start "functionCall"
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:255:1: functionCall : x= ID '(' ( expression ( ',' expression )* )? ')' -> ^( FUNCTION[$x] ( expression )* ) ;
public functionCall_return functionCall() // throws RecognitionException [1]
{
var retval = new functionCall_return();
retval.Start = input.LT( 1 );
CommonTree root_0 = null;
IToken x = null;
IToken char_literal87 = null;
IToken char_literal89 = null;
IToken char_literal91 = null;
expression_return expression88 = default( expression_return );
expression_return expression90 = default( expression_return );
CommonTree x_tree = null;
CommonTree char_literal87_tree = null;
CommonTree char_literal89_tree = null;
CommonTree char_literal91_tree = null;
var stream_69 = new RewriteRuleTokenStream( adaptor, "token 69" );
var stream_94 = new RewriteRuleTokenStream( adaptor, "token 94" );
var stream_ID = new RewriteRuleTokenStream( adaptor, "token ID" );
var stream_70 = new RewriteRuleTokenStream( adaptor, "token 70" );
var stream_expression = new RewriteRuleSubtreeStream( adaptor, "rule expression" );
try
{
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:256:2: (x= ID '(' ( expression ( ',' expression )* )? ')' -> ^( FUNCTION[$x] ( expression )* ) )
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:256:4: x= ID '(' ( expression ( ',' expression )* )? ')'
{
x = (IToken)Match( input, ID, FOLLOW_ID_in_functionCall1352 );
stream_ID.Add( x );
char_literal87 = (IToken)Match( input, 69, FOLLOW_69_in_functionCall1354 );
stream_69.Add( char_literal87 );
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:256:13: ( expression ( ',' expression )* )?
int alt33 = 2;
int LA33_0 = input.LA( 1 );
if ( ( ( LA33_0 >= ID && LA33_0 <= FLOAT ) || LA33_0 == 69 || ( LA33_0 >= 71 && LA33_0 <= 72 ) || LA33_0 == 87 || LA33_0 == 91 || ( LA33_0 >= 95 && LA33_0 <= 96 ) ) )
alt33 = 1;
switch ( alt33 )
{
case 1:
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:256:15: expression ( ',' expression )*
{
PushFollow( FOLLOW_expression_in_functionCall1358 );
expression88 = expression();
state.followingStackPointer--;
stream_expression.Add( expression88.Tree );
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:256:26: ( ',' expression )*
do
{
int alt32 = 2;
int LA32_0 = input.LA( 1 );
if ( ( LA32_0 == 94 ) )
alt32 = 1;
switch ( alt32 )
{
case 1:
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:256:28: ',' expression
{
char_literal89 = (IToken)Match( input, 94, FOLLOW_94_in_functionCall1362 );
stream_94.Add( char_literal89 );
PushFollow( FOLLOW_expression_in_functionCall1364 );
expression90 = expression();
state.followingStackPointer--;
stream_expression.Add( expression90.Tree );
}
break;
default:
goto loop32;
}
} while ( true );
loop32:
; // Stops C# compiler whining that label 'loop32' has no statements
}
break;
}
char_literal91 = (IToken)Match( input, 70, FOLLOW_70_in_functionCall1372 );
stream_70.Add( char_literal91 );
// AST REWRITE
// elements: 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();
// 256:53: -> ^( FUNCTION[$x] ( expression )* )
{
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:256:56: ^( FUNCTION[$x] ( expression )* )
{
var root_1 = (CommonTree)adaptor.GetNilNode();
root_1 = (CommonTree)adaptor.BecomeRoot( adaptor.Create( FUNCTION, x ), root_1 );
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:256:72: ( expression )*
while ( stream_expression.HasNext() )
adaptor.AddChild( root_1, stream_expression.NextTree() );
stream_expression.Reset();
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 "classStatementBlock"
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:85:1: classStatementBlock : '{' ( classLevelStatement )* '}' -> ^( STATEMENT_BLOCK ( classLevelStatement )* ) ;
public classStatementBlock_return classStatementBlock() // throws RecognitionException [1]
{
var retval = new classStatementBlock_return();
retval.Start = input.LT( 1 );
CommonTree root_0 = null;
IToken char_literal12 = null;
IToken char_literal14 = null;
classLevelStatement_return classLevelStatement13 = default( classLevelStatement_return );
CommonTree char_literal12_tree = null;
CommonTree char_literal14_tree = null;
var stream_60 = new RewriteRuleTokenStream( adaptor, "token 60" );
var stream_61 = new RewriteRuleTokenStream( adaptor, "token 61" );
var stream_classLevelStatement = new RewriteRuleSubtreeStream( adaptor, "rule classLevelStatement" );
try
{
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:86:2: ( '{' ( classLevelStatement )* '}' -> ^( STATEMENT_BLOCK ( classLevelStatement )* ) )
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:86:4: '{' ( classLevelStatement )* '}'
{
char_literal12 = (IToken)Match( input, 60, FOLLOW_60_in_classStatementBlock328 );
stream_60.Add( char_literal12 );
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:86:8: ( classLevelStatement )*
do
{
int alt4 = 2;
int LA4_0 = input.LA( 1 );
if ( ( LA4_0 == 62 || LA4_0 == 67 ) )
alt4 = 1;
switch ( alt4 )
{
case 1:
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:86:8: classLevelStatement
{
PushFollow( FOLLOW_classLevelStatement_in_classStatementBlock330 );
classLevelStatement13 = classLevelStatement();
state.followingStackPointer--;
stream_classLevelStatement.Add( classLevelStatement13.Tree );
}
break;
default:
goto loop4;
}
} while ( true );
loop4:
; // Stops C# compiler whining that label 'loop4' has no statements
char_literal14 = (IToken)Match( input, 61, FOLLOW_61_in_classStatementBlock333 );
stream_61.Add( char_literal14 );
// AST REWRITE
// elements: classLevelStatement
// 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();
// 86:33: -> ^( STATEMENT_BLOCK ( classLevelStatement )* )
{
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:86:36: ^( STATEMENT_BLOCK ( classLevelStatement )* )
{
var root_1 = (CommonTree)adaptor.GetNilNode();
root_1 = (CommonTree)adaptor.BecomeRoot( adaptor.Create( STATEMENT_BLOCK, "STATEMENT_BLOCK" ), root_1 );
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:86:55: ( classLevelStatement )*
while ( stream_classLevelStatement.HasNext() )
adaptor.AddChild( root_1, stream_classLevelStatement.NextTree() );
stream_classLevelStatement.Reset();
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 "relationshipJoinDeclaration"
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:116:1: relationshipJoinDeclaration : name 'where' expression -> ^( JOIN ^( TARGET name ) ^( CRITERIA expression ) ) ;
public relationshipJoinDeclaration_return relationshipJoinDeclaration() // throws RecognitionException [1]
{
var retval = new relationshipJoinDeclaration_return();
retval.Start = input.LT( 1 );
CommonTree root_0 = null;
IToken string_literal31 = null;
name_return name30 = default( name_return );
expression_return expression32 = default( expression_return );
CommonTree string_literal31_tree = null;
var stream_59 = new RewriteRuleTokenStream( adaptor, "token 59" );
var stream_expression = new RewriteRuleSubtreeStream( adaptor, "rule expression" );
var stream_name = new RewriteRuleSubtreeStream( adaptor, "rule name" );
try
{
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:117:2: ( name 'where' expression -> ^( JOIN ^( TARGET name ) ^( CRITERIA expression ) ) )
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:117:4: name 'where' expression
{
PushFollow( FOLLOW_name_in_relationshipJoinDeclaration514 );
name30 = name();
state.followingStackPointer--;
stream_name.Add( name30.Tree );
string_literal31 = (IToken)Match( input, 59, FOLLOW_59_in_relationshipJoinDeclaration516 );
stream_59.Add( string_literal31 );
PushFollow( FOLLOW_expression_in_relationshipJoinDeclaration518 );
expression32 = expression();
state.followingStackPointer--;
stream_expression.Add( expression32.Tree );
// AST REWRITE
// elements: name, 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();
// 117:28: -> ^( JOIN ^( TARGET name ) ^( CRITERIA expression ) )
{
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:117:31: ^( JOIN ^( TARGET name ) ^( CRITERIA expression ) )
{
var root_1 = (CommonTree)adaptor.GetNilNode();
root_1 = (CommonTree)adaptor.BecomeRoot( adaptor.Create( JOIN, "JOIN" ), root_1 );
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:117:39: ^( TARGET name )
{
var root_2 = (CommonTree)adaptor.GetNilNode();
root_2 = (CommonTree)adaptor.BecomeRoot( adaptor.Create( TARGET, "TARGET" ), root_2 );
adaptor.AddChild( root_2, stream_name.NextTree() );
adaptor.AddChild( root_1, root_2 );
}
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:117:56: ^( CRITERIA expression )
{
var root_2 = (CommonTree)adaptor.GetNilNode();
root_2 = (CommonTree)adaptor.BecomeRoot( adaptor.Create( CRITERIA, "CRITERIA" ), root_2 );
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 "classDeclaration"
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:79:1: classDeclaration : 'class' name ( baseClassDeclaration )? classStatementBlock -> ^( CLASS name ( baseClassDeclaration )? classStatementBlock ) ;
public classDeclaration_return classDeclaration() // throws RecognitionException [1]
{
var retval = new classDeclaration_return();
retval.Start = input.LT( 1 );
CommonTree root_0 = null;
IToken string_literal4 = null;
name_return name5 = default( name_return );
baseClassDeclaration_return baseClassDeclaration6 = default( baseClassDeclaration_return );
classStatementBlock_return classStatementBlock7 = default( classStatementBlock_return );
CommonTree string_literal4_tree = null;
var stream_57 = new RewriteRuleTokenStream( adaptor, "token 57" );
var stream_classStatementBlock = new RewriteRuleSubtreeStream( adaptor, "rule classStatementBlock" );
var stream_name = new RewriteRuleSubtreeStream( adaptor, "rule name" );
var stream_baseClassDeclaration = new RewriteRuleSubtreeStream( adaptor, "rule baseClassDeclaration" );
try
{
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:80:2: ( 'class' name ( baseClassDeclaration )? classStatementBlock -> ^( CLASS name ( baseClassDeclaration )? classStatementBlock ) )
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:80:4: 'class' name ( baseClassDeclaration )? classStatementBlock
{
string_literal4 = (IToken)Match( input, 57, FOLLOW_57_in_classDeclaration262 );
stream_57.Add( string_literal4 );
PushFollow( FOLLOW_name_in_classDeclaration264 );
name5 = name();
state.followingStackPointer--;
stream_name.Add( name5.Tree );
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:80:17: ( baseClassDeclaration )?
int alt3 = 2;
int LA3_0 = input.LA( 1 );
if ( ( LA3_0 == 58 ) )
alt3 = 1;
switch ( alt3 )
{
case 1:
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:80:17: baseClassDeclaration
{
PushFollow( FOLLOW_baseClassDeclaration_in_classDeclaration266 );
baseClassDeclaration6 = baseClassDeclaration();
state.followingStackPointer--;
stream_baseClassDeclaration.Add( baseClassDeclaration6.Tree );
}
break;
}
PushFollow( FOLLOW_classStatementBlock_in_classDeclaration269 );
classStatementBlock7 = classStatementBlock();
state.followingStackPointer--;
stream_classStatementBlock.Add( classStatementBlock7.Tree );
// AST REWRITE
// elements: name, classStatementBlock, baseClassDeclaration
// 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();
// 80:59: -> ^( CLASS name ( baseClassDeclaration )? classStatementBlock )
{
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:80:62: ^( CLASS name ( baseClassDeclaration )? classStatementBlock )
{
var root_1 = (CommonTree)adaptor.GetNilNode();
root_1 = (CommonTree)adaptor.BecomeRoot( adaptor.Create( CLASS, "CLASS" ), root_1 );
adaptor.AddChild( root_1, stream_name.NextTree() );
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:80:76: ( baseClassDeclaration )?
if ( stream_baseClassDeclaration.HasNext() )
adaptor.AddChild( root_1, stream_baseClassDeclaration.NextTree() );
stream_baseClassDeclaration.Reset();
adaptor.AddChild( root_1, stream_classStatementBlock.NextTree() );
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;
}
private AstParserRuleReturnScope<object, IToken> or_expression()
{
EnterRule_or_expression();
EnterRule("or_expression", 5);
TraceIn("or_expression", 5);
AstParserRuleReturnScope<object, IToken> retval = new AstParserRuleReturnScope<object, IToken>();
retval.Start = (IToken)input.LT(1);
object root_0 = default(object);
IToken string_literal11 = default(IToken);
IToken string_literal12 = default(IToken);
AstParserRuleReturnScope<object, IToken> and_expression10 = default(AstParserRuleReturnScope<object, IToken>);
AstParserRuleReturnScope<object, IToken> and_expression13 = default(AstParserRuleReturnScope<object, IToken>);
object string_literal11_tree = default(object);
object string_literal12_tree = default(object);
RewriteRuleITokenStream stream_75=new RewriteRuleITokenStream(adaptor,"token 75");
RewriteRuleITokenStream stream_77=new RewriteRuleITokenStream(adaptor,"token 77");
RewriteRuleSubtreeStream stream_and_expression=new RewriteRuleSubtreeStream(adaptor,"rule and_expression");
try { DebugEnterRule(GrammarFileName, "or_expression");
DebugLocation(93, 1);
try
{
// Queries\\PomonaQuery.g:94:2: ( and_expression ( ( 'or' | '||' ) and_expression )* -> ^( OR_OP ( and_expression )+ ) )
DebugEnterAlt(1);
// Queries\\PomonaQuery.g:94:4: and_expression ( ( 'or' | '||' ) and_expression )*
{
DebugLocation(94, 4);
PushFollow(Follow._and_expression_in_or_expression588);
and_expression10=and_expression();
PopFollow();
stream_and_expression.Add(and_expression10.Tree);
DebugLocation(94, 19);
// Queries\\PomonaQuery.g:94:19: ( ( 'or' | '||' ) and_expression )*
try { DebugEnterSubRule(4);
while (true)
{
int alt4=2;
try { DebugEnterDecision(4, false);
int LA4_1 = input.LA(1);
if ((LA4_1==75||LA4_1==77))
{
alt4 = 1;
}
} finally { DebugExitDecision(4); }
switch ( alt4 )
{
case 1:
DebugEnterAlt(1);
// Queries\\PomonaQuery.g:94:21: ( 'or' | '||' ) and_expression
{
DebugLocation(94, 21);
// Queries\\PomonaQuery.g:94:21: ( 'or' | '||' )
int alt3=2;
try { DebugEnterSubRule(3);
try { DebugEnterDecision(3, false);
int LA3_1 = input.LA(1);
if ((LA3_1==75))
{
alt3 = 1;
}
else if ((LA3_1==77))
{
alt3 = 2;
}
else
{
NoViableAltException nvae = new NoViableAltException("", 3, 0, input, 1);
DebugRecognitionException(nvae);
throw nvae;
}
} finally { DebugExitDecision(3); }
switch (alt3)
{
case 1:
DebugEnterAlt(1);
// Queries\\PomonaQuery.g:94:22: 'or'
{
DebugLocation(94, 22);
string_literal11=(IToken)Match(input,75,Follow._75_in_or_expression593);
stream_75.Add(string_literal11);
}
break;
case 2:
DebugEnterAlt(2);
// Queries\\PomonaQuery.g:94:27: '||'
{
DebugLocation(94, 27);
string_literal12=(IToken)Match(input,77,Follow._77_in_or_expression595);
stream_77.Add(string_literal12);
}
break;
}
} finally { DebugExitSubRule(3); }
DebugLocation(94, 33);
PushFollow(Follow._and_expression_in_or_expression598);
and_expression13=and_expression();
PopFollow();
stream_and_expression.Add(and_expression13.Tree);
}
break;
default:
goto loop4;
}
}
loop4:
;
} finally { DebugExitSubRule(4); }
{
// AST REWRITE
// elements: and_expression
// 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();
// 94:51: -> ^( OR_OP ( and_expression )+ )
{
DebugLocation(94, 54);
// Queries\\PomonaQuery.g:94:54: ^( OR_OP ( and_expression )+ )
{
object root_1 = (object)adaptor.Nil();
DebugLocation(94, 56);
root_1 = (object)adaptor.BecomeRoot((object)adaptor.Create(OR_OP, "OR_OP"), root_1);
DebugLocation(94, 62);
if (!(stream_and_expression.HasNext))
{
throw new RewriteEarlyExitException();
}
while ( stream_and_expression.HasNext )
{
DebugLocation(94, 62);
adaptor.AddChild(root_1, stream_and_expression.NextTree());
}
stream_and_expression.Reset();
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;
}
}
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("or_expression", 5);
LeaveRule("or_expression", 5);
LeaveRule_or_expression();
}
DebugLocation(95, 1);
} finally { DebugExitRule(GrammarFileName, "or_expression"); }
return retval;
}
// $ANTLR start "propertyModifiers"
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:100:1: propertyModifiers : ( exclusivePropertyModifier -> ^( MODIFIERS exclusivePropertyModifier ) | ( propertyModifier )+ -> ^( MODIFIERS ( propertyModifier )+ ) );
public propertyModifiers_return propertyModifiers() // throws RecognitionException [1]
{
var retval = new propertyModifiers_return();
retval.Start = input.LT( 1 );
CommonTree root_0 = null;
exclusivePropertyModifier_return exclusivePropertyModifier21 = default( exclusivePropertyModifier_return );
propertyModifier_return propertyModifier22 = default( propertyModifier_return );
var stream_propertyModifier = new RewriteRuleSubtreeStream( adaptor, "rule propertyModifier" );
var stream_exclusivePropertyModifier = new RewriteRuleSubtreeStream( adaptor, "rule exclusivePropertyModifier" );
try
{
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:101:2: ( exclusivePropertyModifier -> ^( MODIFIERS exclusivePropertyModifier ) | ( propertyModifier )+ -> ^( MODIFIERS ( propertyModifier )+ ) )
int alt8 = 2;
int LA8_0 = input.LA( 1 );
if ( ( LA8_0 == 64 ) )
alt8 = 1;
else if ( ( ( LA8_0 >= 65 && LA8_0 <= 66 ) ) )
alt8 = 2;
else
{
var nvae_d8s0 =
new NoViableAltException( "", 8, 0, input );
throw nvae_d8s0;
}
switch ( alt8 )
{
case 1:
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:101:4: exclusivePropertyModifier
{
PushFollow( FOLLOW_exclusivePropertyModifier_in_propertyModifiers419 );
exclusivePropertyModifier21 = exclusivePropertyModifier();
state.followingStackPointer--;
stream_exclusivePropertyModifier.Add( exclusivePropertyModifier21.Tree );
// AST REWRITE
// elements: exclusivePropertyModifier
// 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();
// 101:30: -> ^( MODIFIERS exclusivePropertyModifier )
{
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:101:33: ^( MODIFIERS exclusivePropertyModifier )
{
var root_1 = (CommonTree)adaptor.GetNilNode();
root_1 = (CommonTree)adaptor.BecomeRoot( adaptor.Create( MODIFIERS, "MODIFIERS" ), root_1 );
adaptor.AddChild( root_1, stream_exclusivePropertyModifier.NextTree() );
adaptor.AddChild( root_0, root_1 );
}
}
retval.Tree = root_0;
retval.Tree = root_0;
}
break;
case 2:
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:102:4: ( propertyModifier )+
{
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:102:4: ( propertyModifier )+
int cnt7 = 0;
do
{
int alt7 = 2;
int LA7_0 = input.LA( 1 );
if ( ( ( LA7_0 >= 65 && LA7_0 <= 66 ) ) )
alt7 = 1;
switch ( alt7 )
{
case 1:
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:102:4: propertyModifier
{
PushFollow( FOLLOW_propertyModifier_in_propertyModifiers434 );
propertyModifier22 = propertyModifier();
state.followingStackPointer--;
stream_propertyModifier.Add( propertyModifier22.Tree );
}
break;
default:
if ( cnt7 >= 1 ) goto loop7;
var eee7 =
new EarlyExitException( 7, input );
throw eee7;
}
cnt7++;
} while ( true );
loop7:
; // Stops C# compiler whining that label 'loop7' has no statements
// AST REWRITE
// elements: propertyModifier
// 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();
// 102:22: -> ^( MODIFIERS ( propertyModifier )+ )
{
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:102:25: ^( MODIFIERS ( propertyModifier )+ )
{
var root_1 = (CommonTree)adaptor.GetNilNode();
root_1 = (CommonTree)adaptor.BecomeRoot( adaptor.Create( MODIFIERS, "MODIFIERS" ), root_1 );
if ( !( stream_propertyModifier.HasNext() ) ) throw new RewriteEarlyExitException();
while ( stream_propertyModifier.HasNext() )
adaptor.AddChild( root_1, stream_propertyModifier.NextTree() );
stream_propertyModifier.Reset();
adaptor.AddChild( root_0, root_1 );
}
}
retval.Tree = root_0;
retval.Tree = root_0;
}
break;
}
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;
}
private AstParserRuleReturnScope<CommonTree, IToken> type_name()
{
EnterRule_type_name();
EnterRule("type_name", 17);
TraceIn("type_name", 17);
AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>();
retval.Start = (IToken)input.LT(1);
CommonTree root_0 = default(CommonTree);
IToken WS178 = default(IToken);
IToken string_literal179 = default(IToken);
IToken WS180 = default(IToken);
IToken char_literal182 = default(IToken);
IToken WS183 = default(IToken);
IToken char_literal184 = default(IToken);
IToken char_literal185 = default(IToken);
IToken WS186 = default(IToken);
IToken WS188 = default(IToken);
IToken char_literal189 = default(IToken);
IToken WS190 = default(IToken);
IToken string_literal191 = default(IToken);
IToken WS192 = default(IToken);
IToken char_literal194 = default(IToken);
IToken WS195 = default(IToken);
IToken char_literal196 = default(IToken);
AstParserRuleReturnScope<CommonTree, IToken> type_single177 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> type_name181 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> type_list187 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> type_name193 = default(AstParserRuleReturnScope<CommonTree, IToken>);
CommonTree WS178_tree = default(CommonTree);
CommonTree string_literal179_tree = default(CommonTree);
CommonTree WS180_tree = default(CommonTree);
CommonTree char_literal182_tree = default(CommonTree);
CommonTree WS183_tree = default(CommonTree);
CommonTree char_literal184_tree = default(CommonTree);
CommonTree char_literal185_tree = default(CommonTree);
CommonTree WS186_tree = default(CommonTree);
CommonTree WS188_tree = default(CommonTree);
CommonTree char_literal189_tree = default(CommonTree);
CommonTree WS190_tree = default(CommonTree);
CommonTree string_literal191_tree = default(CommonTree);
CommonTree WS192_tree = default(CommonTree);
CommonTree char_literal194_tree = default(CommonTree);
CommonTree WS195_tree = default(CommonTree);
CommonTree char_literal196_tree = default(CommonTree);
RewriteRuleITokenStream stream_94=new RewriteRuleITokenStream(adaptor,"token 94");
RewriteRuleITokenStream stream_WS=new RewriteRuleITokenStream(adaptor,"token WS");
RewriteRuleITokenStream stream_93=new RewriteRuleITokenStream(adaptor,"token 93");
RewriteRuleITokenStream stream_105=new RewriteRuleITokenStream(adaptor,"token 105");
RewriteRuleSubtreeStream stream_type_name=new RewriteRuleSubtreeStream(adaptor,"rule type_name");
RewriteRuleSubtreeStream stream_type_list=new RewriteRuleSubtreeStream(adaptor,"rule type_list");
RewriteRuleSubtreeStream stream_type_single=new RewriteRuleSubtreeStream(adaptor,"rule type_single");
try { DebugEnterRule(GrammarFileName, "type_name");
DebugLocation(300, 1);
try
{
// SugarCpp.g:301:2: ( type_single ( ( WS )* '->' ( WS )* ( type_name | '(' ( WS )* ')' ) -> ^( Type_Func ^( Type_List type_single ) ( type_name )? ) | -> type_single ) | '(' ( ( WS )* type_list )? ( WS )* ')' ( WS )* '->' ( WS )* ( type_name | '(' ( WS )* ')' ) -> ^( Type_Func ( type_list )? ( type_name )? ) )
int alt128=2;
try { DebugEnterDecision(128, false);
int LA128_0 = input.LA(1);
if ((LA128_0==IDENT||LA128_0==142||LA128_0==156||(LA128_0>=166 && LA128_0<=167)||LA128_0==170))
{
alt128 = 1;
}
else if ((LA128_0==93))
{
alt128 = 2;
}
else
{
if (state.backtracking>0) {state.failed=true; return retval;}
NoViableAltException nvae = new NoViableAltException("", 128, 0, input);
DebugRecognitionException(nvae);
throw nvae;
}
} finally { DebugExitDecision(128); }
switch (alt128)
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:301:4: type_single ( ( WS )* '->' ( WS )* ( type_name | '(' ( WS )* ')' ) -> ^( Type_Func ^( Type_List type_single ) ( type_name )? ) | -> type_single )
{
DebugLocation(301, 4);
PushFollow(Follow._type_single_in_type_name1777);
type_single177=type_single();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_type_single.Add(type_single177.Tree);
DebugLocation(301, 16);
// SugarCpp.g:301:16: ( ( WS )* '->' ( WS )* ( type_name | '(' ( WS )* ')' ) -> ^( Type_Func ^( Type_List type_single ) ( type_name )? ) | -> type_single )
int alt120=2;
try { DebugEnterSubRule(120);
try { DebugEnterDecision(120, false);
try
{
alt120 = dfa120.Predict(input);
}
catch (NoViableAltException nvae)
{
DebugRecognitionException(nvae);
throw;
}
} finally { DebugExitDecision(120); }
switch (alt120)
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:301:18: ( WS )* '->' ( WS )* ( type_name | '(' ( WS )* ')' )
{
DebugLocation(301, 18);
// SugarCpp.g:301:18: ( WS )*
try { DebugEnterSubRule(116);
while (true)
{
int alt116=2;
try { DebugEnterDecision(116, false);
int LA116_0 = input.LA(1);
if ((LA116_0==WS))
{
alt116 = 1;
}
} finally { DebugExitDecision(116); }
switch ( alt116 )
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:301:18: WS
{
DebugLocation(301, 18);
WS178=(IToken)Match(input,WS,Follow._WS_in_type_name1781); if (state.failed) return retval;
if (state.backtracking == 0) stream_WS.Add(WS178);
}
break;
default:
goto loop116;
}
}
loop116:
;
} finally { DebugExitSubRule(116); }
DebugLocation(301, 22);
string_literal179=(IToken)Match(input,105,Follow._105_in_type_name1784); if (state.failed) return retval;
if (state.backtracking == 0) stream_105.Add(string_literal179);
DebugLocation(301, 27);
// SugarCpp.g:301:27: ( WS )*
try { DebugEnterSubRule(117);
while (true)
{
int alt117=2;
try { DebugEnterDecision(117, false);
int LA117_0 = input.LA(1);
if ((LA117_0==WS))
{
alt117 = 1;
}
} finally { DebugExitDecision(117); }
switch ( alt117 )
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:301:27: WS
{
DebugLocation(301, 27);
WS180=(IToken)Match(input,WS,Follow._WS_in_type_name1786); if (state.failed) return retval;
if (state.backtracking == 0) stream_WS.Add(WS180);
}
break;
default:
goto loop117;
}
}
loop117:
;
} finally { DebugExitSubRule(117); }
DebugLocation(301, 31);
// SugarCpp.g:301:31: ( type_name | '(' ( WS )* ')' )
int alt119=2;
try { DebugEnterSubRule(119);
try { DebugEnterDecision(119, false);
try
{
alt119 = dfa119.Predict(input);
}
catch (NoViableAltException nvae)
{
DebugRecognitionException(nvae);
throw;
}
} finally { DebugExitDecision(119); }
switch (alt119)
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:301:32: type_name
{
DebugLocation(301, 32);
PushFollow(Follow._type_name_in_type_name1790);
type_name181=type_name();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_type_name.Add(type_name181.Tree);
}
break;
case 2:
DebugEnterAlt(2);
// SugarCpp.g:301:44: '(' ( WS )* ')'
{
DebugLocation(301, 44);
char_literal182=(IToken)Match(input,93,Follow._93_in_type_name1794); if (state.failed) return retval;
if (state.backtracking == 0) stream_93.Add(char_literal182);
DebugLocation(301, 48);
// SugarCpp.g:301:48: ( WS )*
try { DebugEnterSubRule(118);
while (true)
{
int alt118=2;
try { DebugEnterDecision(118, false);
int LA118_0 = input.LA(1);
if ((LA118_0==WS))
{
alt118 = 1;
}
} finally { DebugExitDecision(118); }
switch ( alt118 )
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:301:48: WS
{
DebugLocation(301, 48);
WS183=(IToken)Match(input,WS,Follow._WS_in_type_name1796); if (state.failed) return retval;
if (state.backtracking == 0) stream_WS.Add(WS183);
}
break;
default:
goto loop118;
}
}
loop118:
;
} finally { DebugExitSubRule(118); }
DebugLocation(301, 52);
char_literal184=(IToken)Match(input,94,Follow._94_in_type_name1799); if (state.failed) return retval;
if (state.backtracking == 0) stream_94.Add(char_literal184);
}
break;
}
} finally { DebugExitSubRule(119); }
{
// AST REWRITE
// elements: type_name, type_single
// 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();
// 301:57: -> ^( Type_Func ^( Type_List type_single ) ( type_name )? )
{
DebugLocation(301, 60);
// SugarCpp.g:301:60: ^( Type_Func ^( Type_List type_single ) ( type_name )? )
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(301, 62);
root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(Type_Func, "Type_Func"), root_1);
DebugLocation(301, 72);
// SugarCpp.g:301:72: ^( Type_List type_single )
{
CommonTree root_2 = (CommonTree)adaptor.Nil();
DebugLocation(301, 74);
root_2 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(Type_List, "Type_List"), root_2);
DebugLocation(301, 84);
adaptor.AddChild(root_2, stream_type_single.NextTree());
adaptor.AddChild(root_1, root_2);
}
DebugLocation(301, 97);
// SugarCpp.g:301:97: ( type_name )?
if (stream_type_name.HasNext)
{
DebugLocation(301, 97);
adaptor.AddChild(root_1, stream_type_name.NextTree());
}
stream_type_name.Reset();
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;
}
}
}
break;
case 2:
DebugEnterAlt(2);
// SugarCpp.g:302:9:
{
{
// AST REWRITE
// elements: type_single
// 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();
// 302:9: -> type_single
{
DebugLocation(302, 12);
adaptor.AddChild(root_0, stream_type_single.NextTree());
}
retval.Tree = root_0;
}
}
}
break;
}
} finally { DebugExitSubRule(120); }
}
break;
case 2:
DebugEnterAlt(2);
// SugarCpp.g:304:4: '(' ( ( WS )* type_list )? ( WS )* ')' ( WS )* '->' ( WS )* ( type_name | '(' ( WS )* ')' )
{
DebugLocation(304, 4);
char_literal185=(IToken)Match(input,93,Follow._93_in_type_name1840); if (state.failed) return retval;
if (state.backtracking == 0) stream_93.Add(char_literal185);
DebugLocation(304, 8);
// SugarCpp.g:304:8: ( ( WS )* type_list )?
int alt122=2;
try { DebugEnterSubRule(122);
try { DebugEnterDecision(122, false);
try
{
alt122 = dfa122.Predict(input);
}
catch (NoViableAltException nvae)
{
DebugRecognitionException(nvae);
throw;
}
} finally { DebugExitDecision(122); }
switch (alt122)
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:304:9: ( WS )* type_list
{
DebugLocation(304, 9);
// SugarCpp.g:304:9: ( WS )*
try { DebugEnterSubRule(121);
while (true)
{
int alt121=2;
try { DebugEnterDecision(121, false);
int LA121_0 = input.LA(1);
if ((LA121_0==WS))
{
alt121 = 1;
}
} finally { DebugExitDecision(121); }
switch ( alt121 )
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:304:9: WS
{
DebugLocation(304, 9);
WS186=(IToken)Match(input,WS,Follow._WS_in_type_name1843); if (state.failed) return retval;
if (state.backtracking == 0) stream_WS.Add(WS186);
}
break;
default:
goto loop121;
}
}
loop121:
;
} finally { DebugExitSubRule(121); }
DebugLocation(304, 13);
PushFollow(Follow._type_list_in_type_name1846);
type_list187=type_list();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_type_list.Add(type_list187.Tree);
}
break;
}
} finally { DebugExitSubRule(122); }
DebugLocation(304, 25);
// SugarCpp.g:304:25: ( WS )*
try { DebugEnterSubRule(123);
while (true)
{
int alt123=2;
try { DebugEnterDecision(123, false);
int LA123_0 = input.LA(1);
if ((LA123_0==WS))
{
alt123 = 1;
}
} finally { DebugExitDecision(123); }
switch ( alt123 )
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:304:25: WS
{
DebugLocation(304, 25);
WS188=(IToken)Match(input,WS,Follow._WS_in_type_name1850); if (state.failed) return retval;
if (state.backtracking == 0) stream_WS.Add(WS188);
}
break;
default:
goto loop123;
}
}
loop123:
;
} finally { DebugExitSubRule(123); }
DebugLocation(304, 29);
char_literal189=(IToken)Match(input,94,Follow._94_in_type_name1853); if (state.failed) return retval;
if (state.backtracking == 0) stream_94.Add(char_literal189);
DebugLocation(304, 33);
// SugarCpp.g:304:33: ( WS )*
try { DebugEnterSubRule(124);
while (true)
{
int alt124=2;
try { DebugEnterDecision(124, false);
int LA124_0 = input.LA(1);
if ((LA124_0==WS))
{
alt124 = 1;
}
} finally { DebugExitDecision(124); }
switch ( alt124 )
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:304:33: WS
{
DebugLocation(304, 33);
WS190=(IToken)Match(input,WS,Follow._WS_in_type_name1855); if (state.failed) return retval;
if (state.backtracking == 0) stream_WS.Add(WS190);
}
break;
default:
goto loop124;
}
}
loop124:
;
} finally { DebugExitSubRule(124); }
DebugLocation(304, 37);
string_literal191=(IToken)Match(input,105,Follow._105_in_type_name1858); if (state.failed) return retval;
if (state.backtracking == 0) stream_105.Add(string_literal191);
DebugLocation(304, 42);
// SugarCpp.g:304:42: ( WS )*
try { DebugEnterSubRule(125);
while (true)
{
int alt125=2;
try { DebugEnterDecision(125, false);
int LA125_0 = input.LA(1);
if ((LA125_0==WS))
{
alt125 = 1;
}
} finally { DebugExitDecision(125); }
switch ( alt125 )
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:304:42: WS
{
DebugLocation(304, 42);
WS192=(IToken)Match(input,WS,Follow._WS_in_type_name1860); if (state.failed) return retval;
if (state.backtracking == 0) stream_WS.Add(WS192);
}
break;
default:
goto loop125;
}
}
loop125:
;
} finally { DebugExitSubRule(125); }
DebugLocation(304, 46);
// SugarCpp.g:304:46: ( type_name | '(' ( WS )* ')' )
int alt127=2;
try { DebugEnterSubRule(127);
try { DebugEnterDecision(127, false);
try
{
alt127 = dfa127.Predict(input);
}
catch (NoViableAltException nvae)
{
DebugRecognitionException(nvae);
throw;
}
} finally { DebugExitDecision(127); }
switch (alt127)
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:304:47: type_name
{
DebugLocation(304, 47);
PushFollow(Follow._type_name_in_type_name1864);
type_name193=type_name();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_type_name.Add(type_name193.Tree);
}
break;
case 2:
DebugEnterAlt(2);
// SugarCpp.g:304:59: '(' ( WS )* ')'
{
DebugLocation(304, 59);
char_literal194=(IToken)Match(input,93,Follow._93_in_type_name1868); if (state.failed) return retval;
if (state.backtracking == 0) stream_93.Add(char_literal194);
DebugLocation(304, 63);
// SugarCpp.g:304:63: ( WS )*
try { DebugEnterSubRule(126);
while (true)
{
int alt126=2;
try { DebugEnterDecision(126, false);
int LA126_0 = input.LA(1);
if ((LA126_0==WS))
{
alt126 = 1;
}
} finally { DebugExitDecision(126); }
switch ( alt126 )
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:304:63: WS
{
DebugLocation(304, 63);
WS195=(IToken)Match(input,WS,Follow._WS_in_type_name1870); if (state.failed) return retval;
if (state.backtracking == 0) stream_WS.Add(WS195);
}
break;
default:
goto loop126;
}
}
loop126:
;
} finally { DebugExitSubRule(126); }
DebugLocation(304, 67);
char_literal196=(IToken)Match(input,94,Follow._94_in_type_name1873); if (state.failed) return retval;
if (state.backtracking == 0) stream_94.Add(char_literal196);
}
break;
}
} finally { DebugExitSubRule(127); }
{
// AST REWRITE
// elements: type_name, type_list
// 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();
// 304:72: -> ^( Type_Func ( type_list )? ( type_name )? )
{
DebugLocation(304, 75);
// SugarCpp.g:304:75: ^( Type_Func ( type_list )? ( type_name )? )
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(304, 77);
root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(Type_Func, "Type_Func"), root_1);
DebugLocation(304, 87);
// SugarCpp.g:304:87: ( type_list )?
if (stream_type_list.HasNext)
{
DebugLocation(304, 87);
adaptor.AddChild(root_1, stream_type_list.NextTree());
}
stream_type_list.Reset();
DebugLocation(304, 98);
// SugarCpp.g:304:98: ( type_name )?
if (stream_type_name.HasNext)
{
DebugLocation(304, 98);
adaptor.AddChild(root_1, stream_type_name.NextTree());
}
stream_type_name.Reset();
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("type_name", 17);
LeaveRule("type_name", 17);
LeaveRule_type_name();
}
DebugLocation(305, 1);
} finally { DebugExitRule(GrammarFileName, "type_name"); }
return retval;
}
private AstParserRuleReturnScope<CommonTree, IToken> type_single()
{
EnterRule_type_single();
EnterRule("type_single", 18);
TraceIn("type_single", 18);
AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>();
retval.Start = (IToken)input.LT(1);
CommonTree root_0 = default(CommonTree);
IToken WS198 = default(IToken);
IToken char_literal199 = default(IToken);
IToken WS200 = default(IToken);
IToken char_literal201 = default(IToken);
IToken WS202 = default(IToken);
IToken WS204 = default(IToken);
IToken char_literal205 = default(IToken);
IToken WS206 = default(IToken);
IToken WS208 = default(IToken);
IToken char_literal209 = default(IToken);
IToken WS210 = default(IToken);
IToken char_literal211 = default(IToken);
IToken WS212 = default(IToken);
IToken char_literal213 = default(IToken);
AstParserRuleReturnScope<CommonTree, IToken> type_star197 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> expr203 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> expr207 = default(AstParserRuleReturnScope<CommonTree, IToken>);
CommonTree WS198_tree = default(CommonTree);
CommonTree char_literal199_tree = default(CommonTree);
CommonTree WS200_tree = default(CommonTree);
CommonTree char_literal201_tree = default(CommonTree);
CommonTree WS202_tree = default(CommonTree);
CommonTree WS204_tree = default(CommonTree);
CommonTree char_literal205_tree = default(CommonTree);
CommonTree WS206_tree = default(CommonTree);
CommonTree WS208_tree = default(CommonTree);
CommonTree char_literal209_tree = default(CommonTree);
CommonTree WS210_tree = default(CommonTree);
CommonTree char_literal211_tree = default(CommonTree);
CommonTree WS212_tree = default(CommonTree);
CommonTree char_literal213_tree = default(CommonTree);
RewriteRuleITokenStream stream_132=new RewriteRuleITokenStream(adaptor,"token 132");
RewriteRuleITokenStream stream_133=new RewriteRuleITokenStream(adaptor,"token 133");
RewriteRuleITokenStream stream_WS=new RewriteRuleITokenStream(adaptor,"token WS");
RewriteRuleITokenStream stream_91=new RewriteRuleITokenStream(adaptor,"token 91");
RewriteRuleITokenStream stream_100=new RewriteRuleITokenStream(adaptor,"token 100");
RewriteRuleSubtreeStream stream_expr=new RewriteRuleSubtreeStream(adaptor,"rule expr");
RewriteRuleSubtreeStream stream_type_star=new RewriteRuleSubtreeStream(adaptor,"rule type_star");
try { DebugEnterRule(GrammarFileName, "type_single");
DebugLocation(307, 1);
try
{
// SugarCpp.g:308:2: ( type_star ( ( WS )* '&' -> ^( Type_Ref type_star ) | ( WS )* '[' ( ( WS )* expr ( ( WS )* ',' ( WS )* expr )* ( WS )* ']' -> ^( Type_Array type_star ( expr )+ ) | ( ( WS )* ',' )* ( WS )* ']' -> ^( Type_Array type_star ( expr )+ ) ) | -> type_star ) )
DebugEnterAlt(1);
// SugarCpp.g:308:4: type_star ( ( WS )* '&' -> ^( Type_Ref type_star ) | ( WS )* '[' ( ( WS )* expr ( ( WS )* ',' ( WS )* expr )* ( WS )* ']' -> ^( Type_Array type_star ( expr )+ ) | ( ( WS )* ',' )* ( WS )* ']' -> ^( Type_Array type_star ( expr )+ ) ) | -> type_star )
{
DebugLocation(308, 4);
PushFollow(Follow._type_star_in_type_single1897);
type_star197=type_star();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_type_star.Add(type_star197.Tree);
DebugLocation(308, 14);
// SugarCpp.g:308:14: ( ( WS )* '&' -> ^( Type_Ref type_star ) | ( WS )* '[' ( ( WS )* expr ( ( WS )* ',' ( WS )* expr )* ( WS )* ']' -> ^( Type_Array type_star ( expr )+ ) | ( ( WS )* ',' )* ( WS )* ']' -> ^( Type_Array type_star ( expr )+ ) ) | -> type_star )
int alt140=3;
try { DebugEnterSubRule(140);
try { DebugEnterDecision(140, false);
try
{
alt140 = dfa140.Predict(input);
}
catch (NoViableAltException nvae)
{
DebugRecognitionException(nvae);
throw;
}
} finally { DebugExitDecision(140); }
switch (alt140)
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:308:16: ( WS )* '&'
{
DebugLocation(308, 16);
// SugarCpp.g:308:16: ( WS )*
try { DebugEnterSubRule(129);
while (true)
{
int alt129=2;
try { DebugEnterDecision(129, false);
int LA129_0 = input.LA(1);
if ((LA129_0==WS))
{
alt129 = 1;
}
} finally { DebugExitDecision(129); }
switch ( alt129 )
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:308:16: WS
{
DebugLocation(308, 16);
WS198=(IToken)Match(input,WS,Follow._WS_in_type_single1901); if (state.failed) return retval;
if (state.backtracking == 0) stream_WS.Add(WS198);
}
break;
default:
goto loop129;
}
}
loop129:
;
} finally { DebugExitSubRule(129); }
DebugLocation(308, 20);
char_literal199=(IToken)Match(input,91,Follow._91_in_type_single1904); if (state.failed) return retval;
if (state.backtracking == 0) stream_91.Add(char_literal199);
{
// AST REWRITE
// elements: type_star
// 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();
// 308:24: -> ^( Type_Ref type_star )
{
DebugLocation(308, 27);
// SugarCpp.g:308:27: ^( Type_Ref type_star )
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(308, 29);
root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(Type_Ref, "Type_Ref"), root_1);
DebugLocation(308, 38);
adaptor.AddChild(root_1, stream_type_star.NextTree());
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;
}
}
}
break;
case 2:
DebugEnterAlt(2);
// SugarCpp.g:309:7: ( WS )* '[' ( ( WS )* expr ( ( WS )* ',' ( WS )* expr )* ( WS )* ']' -> ^( Type_Array type_star ( expr )+ ) | ( ( WS )* ',' )* ( WS )* ']' -> ^( Type_Array type_star ( expr )+ ) )
{
DebugLocation(309, 7);
// SugarCpp.g:309:7: ( WS )*
try { DebugEnterSubRule(130);
while (true)
{
int alt130=2;
try { DebugEnterDecision(130, false);
int LA130_0 = input.LA(1);
if ((LA130_0==WS))
{
alt130 = 1;
}
} finally { DebugExitDecision(130); }
switch ( alt130 )
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:309:7: WS
{
DebugLocation(309, 7);
WS200=(IToken)Match(input,WS,Follow._WS_in_type_single1920); if (state.failed) return retval;
if (state.backtracking == 0) stream_WS.Add(WS200);
}
break;
default:
goto loop130;
}
}
loop130:
;
} finally { DebugExitSubRule(130); }
DebugLocation(309, 11);
char_literal201=(IToken)Match(input,132,Follow._132_in_type_single1923); if (state.failed) return retval;
if (state.backtracking == 0) stream_132.Add(char_literal201);
DebugLocation(309, 15);
// SugarCpp.g:309:15: ( ( WS )* expr ( ( WS )* ',' ( WS )* expr )* ( WS )* ']' -> ^( Type_Array type_star ( expr )+ ) | ( ( WS )* ',' )* ( WS )* ']' -> ^( Type_Array type_star ( expr )+ ) )
int alt139=2;
try { DebugEnterSubRule(139);
try { DebugEnterDecision(139, false);
try
{
alt139 = dfa139.Predict(input);
}
catch (NoViableAltException nvae)
{
DebugRecognitionException(nvae);
throw;
}
} finally { DebugExitDecision(139); }
switch (alt139)
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:309:17: ( WS )* expr ( ( WS )* ',' ( WS )* expr )* ( WS )* ']'
{
DebugLocation(309, 17);
// SugarCpp.g:309:17: ( WS )*
try { DebugEnterSubRule(131);
while (true)
{
int alt131=2;
try { DebugEnterDecision(131, false);
int LA131_0 = input.LA(1);
if ((LA131_0==WS))
{
alt131 = 1;
}
} finally { DebugExitDecision(131); }
switch ( alt131 )
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:309:17: WS
{
DebugLocation(309, 17);
WS202=(IToken)Match(input,WS,Follow._WS_in_type_single1927); if (state.failed) return retval;
if (state.backtracking == 0) stream_WS.Add(WS202);
}
break;
default:
goto loop131;
}
}
loop131:
;
} finally { DebugExitSubRule(131); }
DebugLocation(309, 21);
PushFollow(Follow._expr_in_type_single1930);
expr203=expr();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_expr.Add(expr203.Tree);
DebugLocation(309, 26);
// SugarCpp.g:309:26: ( ( WS )* ',' ( WS )* expr )*
try { DebugEnterSubRule(134);
while (true)
{
int alt134=2;
try { DebugEnterDecision(134, false);
try
{
alt134 = dfa134.Predict(input);
}
catch (NoViableAltException nvae)
{
DebugRecognitionException(nvae);
throw;
}
} finally { DebugExitDecision(134); }
switch ( alt134 )
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:309:27: ( WS )* ',' ( WS )* expr
{
DebugLocation(309, 27);
// SugarCpp.g:309:27: ( WS )*
try { DebugEnterSubRule(132);
while (true)
{
int alt132=2;
try { DebugEnterDecision(132, false);
int LA132_0 = input.LA(1);
if ((LA132_0==WS))
{
alt132 = 1;
}
} finally { DebugExitDecision(132); }
switch ( alt132 )
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:309:27: WS
{
DebugLocation(309, 27);
WS204=(IToken)Match(input,WS,Follow._WS_in_type_single1933); if (state.failed) return retval;
if (state.backtracking == 0) stream_WS.Add(WS204);
}
break;
default:
goto loop132;
}
}
loop132:
;
} finally { DebugExitSubRule(132); }
DebugLocation(309, 31);
char_literal205=(IToken)Match(input,100,Follow._100_in_type_single1936); if (state.failed) return retval;
if (state.backtracking == 0) stream_100.Add(char_literal205);
DebugLocation(309, 35);
// SugarCpp.g:309:35: ( WS )*
try { DebugEnterSubRule(133);
while (true)
{
int alt133=2;
try { DebugEnterDecision(133, false);
int LA133_0 = input.LA(1);
if ((LA133_0==WS))
{
alt133 = 1;
}
} finally { DebugExitDecision(133); }
switch ( alt133 )
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:309:35: WS
{
DebugLocation(309, 35);
WS206=(IToken)Match(input,WS,Follow._WS_in_type_single1938); if (state.failed) return retval;
if (state.backtracking == 0) stream_WS.Add(WS206);
}
break;
default:
goto loop133;
}
}
loop133:
;
} finally { DebugExitSubRule(133); }
DebugLocation(309, 39);
PushFollow(Follow._expr_in_type_single1941);
expr207=expr();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_expr.Add(expr207.Tree);
}
break;
default:
goto loop134;
}
}
loop134:
;
} finally { DebugExitSubRule(134); }
DebugLocation(309, 46);
// SugarCpp.g:309:46: ( WS )*
try { DebugEnterSubRule(135);
while (true)
{
int alt135=2;
try { DebugEnterDecision(135, false);
int LA135_0 = input.LA(1);
if ((LA135_0==WS))
{
alt135 = 1;
}
} finally { DebugExitDecision(135); }
switch ( alt135 )
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:309:46: WS
{
DebugLocation(309, 46);
WS208=(IToken)Match(input,WS,Follow._WS_in_type_single1945); if (state.failed) return retval;
if (state.backtracking == 0) stream_WS.Add(WS208);
}
break;
default:
goto loop135;
}
}
loop135:
;
} finally { DebugExitSubRule(135); }
DebugLocation(309, 50);
char_literal209=(IToken)Match(input,133,Follow._133_in_type_single1948); if (state.failed) return retval;
if (state.backtracking == 0) stream_133.Add(char_literal209);
{
// AST REWRITE
// elements: type_star, 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();
// 309:54: -> ^( Type_Array type_star ( expr )+ )
{
DebugLocation(309, 57);
// SugarCpp.g:309:57: ^( Type_Array type_star ( expr )+ )
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(309, 59);
root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(Type_Array, "Type_Array"), root_1);
DebugLocation(309, 70);
adaptor.AddChild(root_1, stream_type_star.NextTree());
DebugLocation(309, 80);
if (!(stream_expr.HasNext))
{
throw new RewriteEarlyExitException();
}
while ( stream_expr.HasNext )
{
DebugLocation(309, 80);
adaptor.AddChild(root_1, stream_expr.NextTree());
}
stream_expr.Reset();
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;
}
}
}
break;
case 2:
DebugEnterAlt(2);
// SugarCpp.g:310:17: ( ( WS )* ',' )* ( WS )* ']'
{
DebugLocation(310, 17);
// SugarCpp.g:310:17: ( ( WS )* ',' )*
try { DebugEnterSubRule(137);
while (true)
{
int alt137=2;
try { DebugEnterDecision(137, false);
try
{
alt137 = dfa137.Predict(input);
}
catch (NoViableAltException nvae)
{
DebugRecognitionException(nvae);
throw;
}
} finally { DebugExitDecision(137); }
switch ( alt137 )
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:310:18: ( WS )* ','
{
DebugLocation(310, 18);
// SugarCpp.g:310:18: ( WS )*
try { DebugEnterSubRule(136);
while (true)
{
int alt136=2;
try { DebugEnterDecision(136, false);
int LA136_0 = input.LA(1);
if ((LA136_0==WS))
{
alt136 = 1;
}
} finally { DebugExitDecision(136); }
switch ( alt136 )
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:310:18: WS
{
DebugLocation(310, 18);
WS210=(IToken)Match(input,WS,Follow._WS_in_type_single1978); if (state.failed) return retval;
if (state.backtracking == 0) stream_WS.Add(WS210);
}
break;
default:
goto loop136;
}
}
loop136:
;
} finally { DebugExitSubRule(136); }
DebugLocation(310, 22);
char_literal211=(IToken)Match(input,100,Follow._100_in_type_single1981); if (state.failed) return retval;
if (state.backtracking == 0) stream_100.Add(char_literal211);
}
break;
default:
goto loop137;
}
}
loop137:
;
} finally { DebugExitSubRule(137); }
DebugLocation(310, 28);
// SugarCpp.g:310:28: ( WS )*
try { DebugEnterSubRule(138);
while (true)
{
int alt138=2;
try { DebugEnterDecision(138, false);
int LA138_0 = input.LA(1);
if ((LA138_0==WS))
{
alt138 = 1;
}
} finally { DebugExitDecision(138); }
switch ( alt138 )
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:310:28: WS
{
DebugLocation(310, 28);
WS212=(IToken)Match(input,WS,Follow._WS_in_type_single1985); if (state.failed) return retval;
if (state.backtracking == 0) stream_WS.Add(WS212);
}
break;
default:
goto loop138;
}
}
loop138:
;
} finally { DebugExitSubRule(138); }
DebugLocation(310, 32);
char_literal213=(IToken)Match(input,133,Follow._133_in_type_single1988); if (state.failed) return retval;
if (state.backtracking == 0) stream_133.Add(char_literal213);
{
// AST REWRITE
// elements: type_star, 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();
// 310:36: -> ^( Type_Array type_star ( expr )+ )
{
DebugLocation(310, 39);
// SugarCpp.g:310:39: ^( Type_Array type_star ( expr )+ )
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(310, 41);
root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(Type_Array, "Type_Array"), root_1);
DebugLocation(310, 52);
adaptor.AddChild(root_1, stream_type_star.NextTree());
DebugLocation(310, 62);
if (!(stream_expr.HasNext))
{
throw new RewriteEarlyExitException();
}
while ( stream_expr.HasNext )
{
DebugLocation(310, 62);
adaptor.AddChild(root_1, stream_expr.NextTree());
}
stream_expr.Reset();
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;
}
}
}
break;
}
} finally { DebugExitSubRule(139); }
}
break;
case 3:
DebugEnterAlt(3);
// SugarCpp.g:312:7:
{
{
// AST REWRITE
// elements: type_star
// 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();
// 312:7: -> type_star
{
DebugLocation(312, 10);
adaptor.AddChild(root_0, stream_type_star.NextTree());
}
retval.Tree = root_0;
}
}
}
break;
}
} finally { DebugExitSubRule(140); }
}
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("type_single", 18);
LeaveRule("type_single", 18);
LeaveRule_type_single();
}
DebugLocation(314, 1);
} finally { DebugExitRule(GrammarFileName, "type_single"); }
return retval;
}
private AstParserRuleReturnScope<CommonTree, IToken> class_def()
{
EnterRule_class_def();
EnterRule("class_def", 15);
TraceIn("class_def", 15);
AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>();
retval.Start = (IToken)input.LT(1);
CommonTree root_0 = default(CommonTree);
IToken string_literal130 = default(IToken);
IToken WS131 = default(IToken);
IToken string_literal132 = default(IToken);
IToken WS133 = default(IToken);
IToken WS136 = default(IToken);
IToken char_literal137 = default(IToken);
IToken WS138 = default(IToken);
IToken WS140 = default(IToken);
IToken char_literal141 = default(IToken);
IToken WS142 = default(IToken);
IToken WS144 = default(IToken);
IToken NEWLINE145 = default(IToken);
IToken INDENT146 = default(IToken);
IToken NEWLINE147 = default(IToken);
IToken DEDENT149 = default(IToken);
IToken string_literal150 = default(IToken);
IToken WS151 = default(IToken);
IToken string_literal152 = default(IToken);
IToken WS153 = default(IToken);
IToken WS156 = default(IToken);
IToken WS158 = default(IToken);
IToken char_literal159 = default(IToken);
IToken WS160 = default(IToken);
IToken WS162 = default(IToken);
IToken char_literal163 = default(IToken);
IToken WS164 = default(IToken);
IToken WS166 = default(IToken);
IToken NEWLINE167 = default(IToken);
IToken INDENT168 = default(IToken);
IToken NEWLINE169 = default(IToken);
IToken DEDENT171 = default(IToken);
AstParserRuleReturnScope<CommonTree, IToken> attribute129 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> ident134 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> generic_parameter135 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> ident139 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> ident143 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> global_block148 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> ident154 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> generic_parameter155 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> class_args157 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> ident161 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> ident165 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> global_block170 = default(AstParserRuleReturnScope<CommonTree, IToken>);
CommonTree string_literal130_tree = default(CommonTree);
CommonTree WS131_tree = default(CommonTree);
CommonTree string_literal132_tree = default(CommonTree);
CommonTree WS133_tree = default(CommonTree);
CommonTree WS136_tree = default(CommonTree);
CommonTree char_literal137_tree = default(CommonTree);
CommonTree WS138_tree = default(CommonTree);
CommonTree WS140_tree = default(CommonTree);
CommonTree char_literal141_tree = default(CommonTree);
CommonTree WS142_tree = default(CommonTree);
CommonTree WS144_tree = default(CommonTree);
CommonTree NEWLINE145_tree = default(CommonTree);
CommonTree INDENT146_tree = default(CommonTree);
CommonTree NEWLINE147_tree = default(CommonTree);
CommonTree DEDENT149_tree = default(CommonTree);
CommonTree string_literal150_tree = default(CommonTree);
CommonTree WS151_tree = default(CommonTree);
CommonTree string_literal152_tree = default(CommonTree);
CommonTree WS153_tree = default(CommonTree);
CommonTree WS156_tree = default(CommonTree);
CommonTree WS158_tree = default(CommonTree);
CommonTree char_literal159_tree = default(CommonTree);
CommonTree WS160_tree = default(CommonTree);
CommonTree WS162_tree = default(CommonTree);
CommonTree char_literal163_tree = default(CommonTree);
CommonTree WS164_tree = default(CommonTree);
CommonTree WS166_tree = default(CommonTree);
CommonTree NEWLINE167_tree = default(CommonTree);
CommonTree INDENT168_tree = default(CommonTree);
CommonTree NEWLINE169_tree = default(CommonTree);
CommonTree DEDENT171_tree = default(CommonTree);
RewriteRuleITokenStream stream_163=new RewriteRuleITokenStream(adaptor,"token 163");
RewriteRuleITokenStream stream_WS=new RewriteRuleITokenStream(adaptor,"token WS");
RewriteRuleITokenStream stream_DEDENT=new RewriteRuleITokenStream(adaptor,"token DEDENT");
RewriteRuleITokenStream stream_139=new RewriteRuleITokenStream(adaptor,"token 139");
RewriteRuleITokenStream stream_NEWLINE=new RewriteRuleITokenStream(adaptor,"token NEWLINE");
RewriteRuleITokenStream stream_111=new RewriteRuleITokenStream(adaptor,"token 111");
RewriteRuleITokenStream stream_INDENT=new RewriteRuleITokenStream(adaptor,"token INDENT");
RewriteRuleITokenStream stream_100=new RewriteRuleITokenStream(adaptor,"token 100");
RewriteRuleITokenStream stream_141=new RewriteRuleITokenStream(adaptor,"token 141");
RewriteRuleSubtreeStream stream_class_args=new RewriteRuleSubtreeStream(adaptor,"rule class_args");
RewriteRuleSubtreeStream stream_ident=new RewriteRuleSubtreeStream(adaptor,"rule ident");
RewriteRuleSubtreeStream stream_attribute=new RewriteRuleSubtreeStream(adaptor,"rule attribute");
RewriteRuleSubtreeStream stream_global_block=new RewriteRuleSubtreeStream(adaptor,"rule global_block");
RewriteRuleSubtreeStream stream_generic_parameter=new RewriteRuleSubtreeStream(adaptor,"rule generic_parameter");
try { DebugEnterRule(GrammarFileName, "class_def");
DebugLocation(290, 1);
try
{
// SugarCpp.g:291:2: ( ( attribute )? ( 'public' ( WS )* )? ( 'class' ( WS )* ident ( generic_parameter )? ( ( WS )* ':' ( WS )* ident ( ( WS )* ',' ( WS )* ident )* )? ( ( WS )* ( NEWLINE )+ INDENT ( NEWLINE )* global_block DEDENT )? -> ^( Class ( 'public' )? ( attribute )? ident ( generic_parameter )? ( class_args )? ( ^( Ident_List ( ident )* ) )? ( global_block )? ) | 'case' ( WS )* 'class' ( WS )* ident ( generic_parameter )? ( ( WS )* class_args )? ( ( WS )* ':' ( WS )* ident ( ( WS )* ',' ( WS )* ident )* )? ( ( WS )* ( NEWLINE )+ INDENT ( NEWLINE )* global_block DEDENT )? -> ^( Class 'case' ( 'public' )? ( attribute )? ident ( generic_parameter )? ( class_args )? ( ^( Ident_List ( ident )* ) )? ( global_block )? ) ) )
DebugEnterAlt(1);
// SugarCpp.g:291:5: ( attribute )? ( 'public' ( WS )* )? ( 'class' ( WS )* ident ( generic_parameter )? ( ( WS )* ':' ( WS )* ident ( ( WS )* ',' ( WS )* ident )* )? ( ( WS )* ( NEWLINE )+ INDENT ( NEWLINE )* global_block DEDENT )? -> ^( Class ( 'public' )? ( attribute )? ident ( generic_parameter )? ( class_args )? ( ^( Ident_List ( ident )* ) )? ( global_block )? ) | 'case' ( WS )* 'class' ( WS )* ident ( generic_parameter )? ( ( WS )* class_args )? ( ( WS )* ':' ( WS )* ident ( ( WS )* ',' ( WS )* ident )* )? ( ( WS )* ( NEWLINE )+ INDENT ( NEWLINE )* global_block DEDENT )? -> ^( Class 'case' ( 'public' )? ( attribute )? ident ( generic_parameter )? ( class_args )? ( ^( Ident_List ( ident )* ) )? ( global_block )? ) )
{
DebugLocation(291, 5);
// SugarCpp.g:291:5: ( attribute )?
int alt82=2;
try { DebugEnterSubRule(82);
try { DebugEnterDecision(82, false);
int LA82_0 = input.LA(1);
if ((LA82_0==132))
{
alt82 = 1;
}
} finally { DebugExitDecision(82); }
switch (alt82)
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:291:5: attribute
{
DebugLocation(291, 5);
PushFollow(Follow._attribute_in_class_def1504);
attribute129=attribute();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_attribute.Add(attribute129.Tree);
}
break;
}
} finally { DebugExitSubRule(82); }
DebugLocation(291, 16);
// SugarCpp.g:291:16: ( 'public' ( WS )* )?
int alt84=2;
try { DebugEnterSubRule(84);
try { DebugEnterDecision(84, false);
int LA84_0 = input.LA(1);
if ((LA84_0==163))
{
alt84 = 1;
}
} finally { DebugExitDecision(84); }
switch (alt84)
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:291:17: 'public' ( WS )*
{
DebugLocation(291, 17);
string_literal130=(IToken)Match(input,163,Follow._163_in_class_def1508); if (state.failed) return retval;
if (state.backtracking == 0) stream_163.Add(string_literal130);
DebugLocation(291, 26);
// SugarCpp.g:291:26: ( WS )*
try { DebugEnterSubRule(83);
while (true)
{
int alt83=2;
try { DebugEnterDecision(83, false);
int LA83_0 = input.LA(1);
if ((LA83_0==WS))
{
alt83 = 1;
}
} finally { DebugExitDecision(83); }
switch ( alt83 )
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:291:26: WS
{
DebugLocation(291, 26);
WS131=(IToken)Match(input,WS,Follow._WS_in_class_def1510); if (state.failed) return retval;
if (state.backtracking == 0) stream_WS.Add(WS131);
}
break;
default:
goto loop83;
}
}
loop83:
;
} finally { DebugExitSubRule(83); }
}
break;
}
} finally { DebugExitSubRule(84); }
DebugLocation(291, 32);
// SugarCpp.g:291:32: ( 'class' ( WS )* ident ( generic_parameter )? ( ( WS )* ':' ( WS )* ident ( ( WS )* ',' ( WS )* ident )* )? ( ( WS )* ( NEWLINE )+ INDENT ( NEWLINE )* global_block DEDENT )? -> ^( Class ( 'public' )? ( attribute )? ident ( generic_parameter )? ( class_args )? ( ^( Ident_List ( ident )* ) )? ( global_block )? ) | 'case' ( WS )* 'class' ( WS )* ident ( generic_parameter )? ( ( WS )* class_args )? ( ( WS )* ':' ( WS )* ident ( ( WS )* ',' ( WS )* ident )* )? ( ( WS )* ( NEWLINE )+ INDENT ( NEWLINE )* global_block DEDENT )? -> ^( Class 'case' ( 'public' )? ( attribute )? ident ( generic_parameter )? ( class_args )? ( ^( Ident_List ( ident )* ) )? ( global_block )? ) )
int alt112=2;
try { DebugEnterSubRule(112);
try { DebugEnterDecision(112, false);
int LA112_0 = input.LA(1);
if ((LA112_0==141))
{
alt112 = 1;
}
else if ((LA112_0==139))
{
alt112 = 2;
}
else
{
if (state.backtracking>0) {state.failed=true; return retval;}
NoViableAltException nvae = new NoViableAltException("", 112, 0, input);
DebugRecognitionException(nvae);
throw nvae;
}
} finally { DebugExitDecision(112); }
switch (alt112)
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:291:34: 'class' ( WS )* ident ( generic_parameter )? ( ( WS )* ':' ( WS )* ident ( ( WS )* ',' ( WS )* ident )* )? ( ( WS )* ( NEWLINE )+ INDENT ( NEWLINE )* global_block DEDENT )?
{
DebugLocation(291, 34);
string_literal132=(IToken)Match(input,141,Follow._141_in_class_def1517); if (state.failed) return retval;
if (state.backtracking == 0) stream_141.Add(string_literal132);
DebugLocation(291, 42);
// SugarCpp.g:291:42: ( WS )*
try { DebugEnterSubRule(85);
while (true)
{
int alt85=2;
try { DebugEnterDecision(85, false);
int LA85_0 = input.LA(1);
if ((LA85_0==WS))
{
alt85 = 1;
}
} finally { DebugExitDecision(85); }
switch ( alt85 )
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:291:42: WS
{
DebugLocation(291, 42);
WS133=(IToken)Match(input,WS,Follow._WS_in_class_def1519); if (state.failed) return retval;
if (state.backtracking == 0) stream_WS.Add(WS133);
}
break;
default:
goto loop85;
}
}
loop85:
;
} finally { DebugExitSubRule(85); }
DebugLocation(291, 46);
PushFollow(Follow._ident_in_class_def1522);
ident134=ident();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_ident.Add(ident134.Tree);
DebugLocation(291, 52);
// SugarCpp.g:291:52: ( generic_parameter )?
int alt86=2;
try { DebugEnterSubRule(86);
try { DebugEnterDecision(86, false);
int LA86_0 = input.LA(1);
if ((LA86_0==115))
{
alt86 = 1;
}
} finally { DebugExitDecision(86); }
switch (alt86)
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:291:53: generic_parameter
{
DebugLocation(291, 53);
PushFollow(Follow._generic_parameter_in_class_def1525);
generic_parameter135=generic_parameter();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_generic_parameter.Add(generic_parameter135.Tree);
}
break;
}
} finally { DebugExitSubRule(86); }
DebugLocation(291, 73);
// SugarCpp.g:291:73: ( ( WS )* ':' ( WS )* ident ( ( WS )* ',' ( WS )* ident )* )?
int alt92=2;
try { DebugEnterSubRule(92);
try { DebugEnterDecision(92, false);
try
{
alt92 = dfa92.Predict(input);
}
catch (NoViableAltException nvae)
{
DebugRecognitionException(nvae);
throw;
}
} finally { DebugExitDecision(92); }
switch (alt92)
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:291:74: ( WS )* ':' ( WS )* ident ( ( WS )* ',' ( WS )* ident )*
{
DebugLocation(291, 74);
// SugarCpp.g:291:74: ( WS )*
try { DebugEnterSubRule(87);
while (true)
{
int alt87=2;
try { DebugEnterDecision(87, false);
int LA87_0 = input.LA(1);
if ((LA87_0==WS))
{
alt87 = 1;
}
} finally { DebugExitDecision(87); }
switch ( alt87 )
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:291:74: WS
{
DebugLocation(291, 74);
WS136=(IToken)Match(input,WS,Follow._WS_in_class_def1530); if (state.failed) return retval;
if (state.backtracking == 0) stream_WS.Add(WS136);
}
break;
default:
goto loop87;
}
}
loop87:
;
} finally { DebugExitSubRule(87); }
DebugLocation(291, 78);
char_literal137=(IToken)Match(input,111,Follow._111_in_class_def1533); if (state.failed) return retval;
if (state.backtracking == 0) stream_111.Add(char_literal137);
DebugLocation(291, 82);
// SugarCpp.g:291:82: ( WS )*
try { DebugEnterSubRule(88);
while (true)
{
int alt88=2;
try { DebugEnterDecision(88, false);
int LA88_0 = input.LA(1);
if ((LA88_0==WS))
{
alt88 = 1;
}
} finally { DebugExitDecision(88); }
switch ( alt88 )
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:291:82: WS
{
DebugLocation(291, 82);
WS138=(IToken)Match(input,WS,Follow._WS_in_class_def1535); if (state.failed) return retval;
if (state.backtracking == 0) stream_WS.Add(WS138);
}
break;
default:
goto loop88;
}
}
loop88:
;
} finally { DebugExitSubRule(88); }
DebugLocation(291, 86);
PushFollow(Follow._ident_in_class_def1538);
ident139=ident();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_ident.Add(ident139.Tree);
DebugLocation(291, 92);
// SugarCpp.g:291:92: ( ( WS )* ',' ( WS )* ident )*
try { DebugEnterSubRule(91);
while (true)
{
int alt91=2;
try { DebugEnterDecision(91, false);
try
{
alt91 = dfa91.Predict(input);
}
catch (NoViableAltException nvae)
{
DebugRecognitionException(nvae);
throw;
}
} finally { DebugExitDecision(91); }
switch ( alt91 )
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:291:93: ( WS )* ',' ( WS )* ident
{
DebugLocation(291, 93);
// SugarCpp.g:291:93: ( WS )*
try { DebugEnterSubRule(89);
while (true)
{
int alt89=2;
try { DebugEnterDecision(89, false);
int LA89_0 = input.LA(1);
if ((LA89_0==WS))
{
alt89 = 1;
}
} finally { DebugExitDecision(89); }
switch ( alt89 )
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:291:93: WS
{
DebugLocation(291, 93);
WS140=(IToken)Match(input,WS,Follow._WS_in_class_def1541); if (state.failed) return retval;
if (state.backtracking == 0) stream_WS.Add(WS140);
}
break;
default:
goto loop89;
}
}
loop89:
;
} finally { DebugExitSubRule(89); }
DebugLocation(291, 97);
char_literal141=(IToken)Match(input,100,Follow._100_in_class_def1544); if (state.failed) return retval;
if (state.backtracking == 0) stream_100.Add(char_literal141);
DebugLocation(291, 101);
// SugarCpp.g:291:101: ( WS )*
try { DebugEnterSubRule(90);
while (true)
{
int alt90=2;
try { DebugEnterDecision(90, false);
int LA90_0 = input.LA(1);
if ((LA90_0==WS))
{
alt90 = 1;
}
} finally { DebugExitDecision(90); }
switch ( alt90 )
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:291:101: WS
{
DebugLocation(291, 101);
WS142=(IToken)Match(input,WS,Follow._WS_in_class_def1546); if (state.failed) return retval;
if (state.backtracking == 0) stream_WS.Add(WS142);
}
break;
default:
goto loop90;
}
}
loop90:
;
} finally { DebugExitSubRule(90); }
DebugLocation(291, 105);
PushFollow(Follow._ident_in_class_def1549);
ident143=ident();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_ident.Add(ident143.Tree);
}
break;
default:
goto loop91;
}
}
loop91:
;
} finally { DebugExitSubRule(91); }
}
break;
}
} finally { DebugExitSubRule(92); }
DebugLocation(291, 115);
// SugarCpp.g:291:115: ( ( WS )* ( NEWLINE )+ INDENT ( NEWLINE )* global_block DEDENT )?
int alt96=2;
try { DebugEnterSubRule(96);
try { DebugEnterDecision(96, false);
try
{
alt96 = dfa96.Predict(input);
}
catch (NoViableAltException nvae)
{
DebugRecognitionException(nvae);
throw;
}
} finally { DebugExitDecision(96); }
switch (alt96)
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:291:116: ( WS )* ( NEWLINE )+ INDENT ( NEWLINE )* global_block DEDENT
{
DebugLocation(291, 116);
// SugarCpp.g:291:116: ( WS )*
try { DebugEnterSubRule(93);
while (true)
{
int alt93=2;
try { DebugEnterDecision(93, false);
int LA93_0 = input.LA(1);
if ((LA93_0==WS))
{
alt93 = 1;
}
} finally { DebugExitDecision(93); }
switch ( alt93 )
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:291:116: WS
{
DebugLocation(291, 116);
WS144=(IToken)Match(input,WS,Follow._WS_in_class_def1556); if (state.failed) return retval;
if (state.backtracking == 0) stream_WS.Add(WS144);
}
break;
default:
goto loop93;
}
}
loop93:
;
} finally { DebugExitSubRule(93); }
DebugLocation(291, 120);
// SugarCpp.g:291:120: ( NEWLINE )+
int cnt94=0;
try { DebugEnterSubRule(94);
while (true)
{
int alt94=2;
try { DebugEnterDecision(94, false);
int LA94_0 = input.LA(1);
if ((LA94_0==NEWLINE))
{
alt94 = 1;
}
} finally { DebugExitDecision(94); }
switch (alt94)
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:291:120: NEWLINE
{
DebugLocation(291, 120);
NEWLINE145=(IToken)Match(input,NEWLINE,Follow._NEWLINE_in_class_def1559); if (state.failed) return retval;
if (state.backtracking == 0) stream_NEWLINE.Add(NEWLINE145);
}
break;
default:
if (cnt94 >= 1)
goto loop94;
if (state.backtracking>0) {state.failed=true; return retval;}
EarlyExitException eee94 = new EarlyExitException( 94, input );
DebugRecognitionException(eee94);
throw eee94;
}
cnt94++;
}
loop94:
;
} finally { DebugExitSubRule(94); }
DebugLocation(291, 129);
INDENT146=(IToken)Match(input,INDENT,Follow._INDENT_in_class_def1562); if (state.failed) return retval;
if (state.backtracking == 0) stream_INDENT.Add(INDENT146);
DebugLocation(291, 136);
// SugarCpp.g:291:136: ( NEWLINE )*
try { DebugEnterSubRule(95);
while (true)
{
int alt95=2;
try { DebugEnterDecision(95, false);
int LA95_0 = input.LA(1);
if ((LA95_0==NEWLINE))
{
alt95 = 1;
}
} finally { DebugExitDecision(95); }
switch ( alt95 )
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:291:136: NEWLINE
{
DebugLocation(291, 136);
NEWLINE147=(IToken)Match(input,NEWLINE,Follow._NEWLINE_in_class_def1564); if (state.failed) return retval;
if (state.backtracking == 0) stream_NEWLINE.Add(NEWLINE147);
}
break;
default:
goto loop95;
}
}
loop95:
;
} finally { DebugExitSubRule(95); }
DebugLocation(291, 145);
PushFollow(Follow._global_block_in_class_def1567);
global_block148=global_block();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_global_block.Add(global_block148.Tree);
DebugLocation(291, 158);
DEDENT149=(IToken)Match(input,DEDENT,Follow._DEDENT_in_class_def1569); if (state.failed) return retval;
if (state.backtracking == 0) stream_DEDENT.Add(DEDENT149);
}
break;
}
} finally { DebugExitSubRule(96); }
{
// AST REWRITE
// elements: class_args, generic_parameter, ident, 163, attribute, global_block, 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();
// 291:167: -> ^( Class ( 'public' )? ( attribute )? ident ( generic_parameter )? ( class_args )? ( ^( Ident_List ( ident )* ) )? ( global_block )? )
{
DebugLocation(291, 170);
// SugarCpp.g:291:170: ^( Class ( 'public' )? ( attribute )? ident ( generic_parameter )? ( class_args )? ( ^( Ident_List ( ident )* ) )? ( global_block )? )
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(291, 172);
root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(Class, "Class"), root_1);
DebugLocation(291, 178);
// SugarCpp.g:291:178: ( 'public' )?
if (stream_163.HasNext)
{
DebugLocation(291, 178);
adaptor.AddChild(root_1, stream_163.NextNode());
}
stream_163.Reset();
DebugLocation(291, 188);
// SugarCpp.g:291:188: ( attribute )?
if (stream_attribute.HasNext)
{
DebugLocation(291, 188);
adaptor.AddChild(root_1, stream_attribute.NextTree());
}
stream_attribute.Reset();
DebugLocation(291, 199);
adaptor.AddChild(root_1, stream_ident.NextTree());
DebugLocation(291, 205);
// SugarCpp.g:291:205: ( generic_parameter )?
if (stream_generic_parameter.HasNext)
{
DebugLocation(291, 205);
adaptor.AddChild(root_1, stream_generic_parameter.NextTree());
}
stream_generic_parameter.Reset();
DebugLocation(291, 224);
// SugarCpp.g:291:224: ( class_args )?
if (stream_class_args.HasNext)
{
DebugLocation(291, 224);
adaptor.AddChild(root_1, stream_class_args.NextTree());
}
stream_class_args.Reset();
DebugLocation(291, 236);
// SugarCpp.g:291:236: ( ^( Ident_List ( ident )* ) )?
if (stream_ident.HasNext)
{
DebugLocation(291, 237);
// SugarCpp.g:291:237: ^( Ident_List ( ident )* )
{
CommonTree root_2 = (CommonTree)adaptor.Nil();
DebugLocation(291, 239);
root_2 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(Ident_List, "Ident_List"), root_2);
DebugLocation(291, 250);
// SugarCpp.g:291:250: ( ident )*
while ( stream_ident.HasNext )
{
DebugLocation(291, 250);
adaptor.AddChild(root_2, stream_ident.NextTree());
}
stream_ident.Reset();
adaptor.AddChild(root_1, root_2);
}
}
stream_ident.Reset();
DebugLocation(291, 260);
// SugarCpp.g:291:260: ( global_block )?
if (stream_global_block.HasNext)
{
DebugLocation(291, 260);
adaptor.AddChild(root_1, stream_global_block.NextTree());
}
stream_global_block.Reset();
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;
}
}
}
break;
case 2:
DebugEnterAlt(2);
// SugarCpp.g:292:13: 'case' ( WS )* 'class' ( WS )* ident ( generic_parameter )? ( ( WS )* class_args )? ( ( WS )* ':' ( WS )* ident ( ( WS )* ',' ( WS )* ident )* )? ( ( WS )* ( NEWLINE )+ INDENT ( NEWLINE )* global_block DEDENT )?
{
DebugLocation(292, 13);
string_literal150=(IToken)Match(input,139,Follow._139_in_class_def1618); if (state.failed) return retval;
if (state.backtracking == 0) stream_139.Add(string_literal150);
DebugLocation(292, 20);
// SugarCpp.g:292:20: ( WS )*
try { DebugEnterSubRule(97);
while (true)
{
int alt97=2;
try { DebugEnterDecision(97, false);
int LA97_0 = input.LA(1);
if ((LA97_0==WS))
{
alt97 = 1;
}
} finally { DebugExitDecision(97); }
switch ( alt97 )
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:292:20: WS
{
DebugLocation(292, 20);
WS151=(IToken)Match(input,WS,Follow._WS_in_class_def1620); if (state.failed) return retval;
if (state.backtracking == 0) stream_WS.Add(WS151);
}
break;
default:
goto loop97;
}
}
loop97:
;
} finally { DebugExitSubRule(97); }
DebugLocation(292, 24);
string_literal152=(IToken)Match(input,141,Follow._141_in_class_def1623); if (state.failed) return retval;
if (state.backtracking == 0) stream_141.Add(string_literal152);
DebugLocation(292, 32);
// SugarCpp.g:292:32: ( WS )*
try { DebugEnterSubRule(98);
while (true)
{
int alt98=2;
try { DebugEnterDecision(98, false);
int LA98_0 = input.LA(1);
if ((LA98_0==WS))
{
alt98 = 1;
}
} finally { DebugExitDecision(98); }
switch ( alt98 )
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:292:32: WS
{
DebugLocation(292, 32);
WS153=(IToken)Match(input,WS,Follow._WS_in_class_def1625); if (state.failed) return retval;
if (state.backtracking == 0) stream_WS.Add(WS153);
}
break;
default:
goto loop98;
}
}
loop98:
;
} finally { DebugExitSubRule(98); }
DebugLocation(292, 36);
PushFollow(Follow._ident_in_class_def1628);
ident154=ident();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_ident.Add(ident154.Tree);
DebugLocation(292, 42);
// SugarCpp.g:292:42: ( generic_parameter )?
int alt99=2;
try { DebugEnterSubRule(99);
try { DebugEnterDecision(99, false);
int LA99_0 = input.LA(1);
if ((LA99_0==115))
{
alt99 = 1;
}
} finally { DebugExitDecision(99); }
switch (alt99)
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:292:43: generic_parameter
{
DebugLocation(292, 43);
PushFollow(Follow._generic_parameter_in_class_def1631);
generic_parameter155=generic_parameter();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_generic_parameter.Add(generic_parameter155.Tree);
}
break;
}
} finally { DebugExitSubRule(99); }
DebugLocation(292, 63);
// SugarCpp.g:292:63: ( ( WS )* class_args )?
int alt101=2;
try { DebugEnterSubRule(101);
try { DebugEnterDecision(101, false);
try
{
alt101 = dfa101.Predict(input);
}
catch (NoViableAltException nvae)
{
DebugRecognitionException(nvae);
throw;
}
} finally { DebugExitDecision(101); }
switch (alt101)
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:292:64: ( WS )* class_args
{
DebugLocation(292, 64);
// SugarCpp.g:292:64: ( WS )*
try { DebugEnterSubRule(100);
while (true)
{
int alt100=2;
try { DebugEnterDecision(100, false);
int LA100_0 = input.LA(1);
if ((LA100_0==WS))
{
alt100 = 1;
}
} finally { DebugExitDecision(100); }
switch ( alt100 )
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:292:64: WS
{
DebugLocation(292, 64);
WS156=(IToken)Match(input,WS,Follow._WS_in_class_def1636); if (state.failed) return retval;
if (state.backtracking == 0) stream_WS.Add(WS156);
}
break;
default:
goto loop100;
}
}
loop100:
;
} finally { DebugExitSubRule(100); }
DebugLocation(292, 68);
PushFollow(Follow._class_args_in_class_def1639);
class_args157=class_args();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_class_args.Add(class_args157.Tree);
}
break;
}
} finally { DebugExitSubRule(101); }
DebugLocation(292, 81);
// SugarCpp.g:292:81: ( ( WS )* ':' ( WS )* ident ( ( WS )* ',' ( WS )* ident )* )?
int alt107=2;
try { DebugEnterSubRule(107);
try { DebugEnterDecision(107, false);
try
{
alt107 = dfa107.Predict(input);
}
catch (NoViableAltException nvae)
{
DebugRecognitionException(nvae);
throw;
}
} finally { DebugExitDecision(107); }
switch (alt107)
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:292:82: ( WS )* ':' ( WS )* ident ( ( WS )* ',' ( WS )* ident )*
{
DebugLocation(292, 82);
// SugarCpp.g:292:82: ( WS )*
try { DebugEnterSubRule(102);
while (true)
{
int alt102=2;
try { DebugEnterDecision(102, false);
int LA102_0 = input.LA(1);
if ((LA102_0==WS))
{
alt102 = 1;
}
} finally { DebugExitDecision(102); }
switch ( alt102 )
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:292:82: WS
{
DebugLocation(292, 82);
WS158=(IToken)Match(input,WS,Follow._WS_in_class_def1644); if (state.failed) return retval;
if (state.backtracking == 0) stream_WS.Add(WS158);
}
break;
default:
goto loop102;
}
}
loop102:
;
} finally { DebugExitSubRule(102); }
DebugLocation(292, 86);
char_literal159=(IToken)Match(input,111,Follow._111_in_class_def1647); if (state.failed) return retval;
if (state.backtracking == 0) stream_111.Add(char_literal159);
DebugLocation(292, 90);
// SugarCpp.g:292:90: ( WS )*
try { DebugEnterSubRule(103);
while (true)
{
int alt103=2;
try { DebugEnterDecision(103, false);
int LA103_0 = input.LA(1);
if ((LA103_0==WS))
{
alt103 = 1;
}
} finally { DebugExitDecision(103); }
switch ( alt103 )
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:292:90: WS
{
DebugLocation(292, 90);
WS160=(IToken)Match(input,WS,Follow._WS_in_class_def1649); if (state.failed) return retval;
if (state.backtracking == 0) stream_WS.Add(WS160);
}
break;
default:
goto loop103;
}
}
loop103:
;
} finally { DebugExitSubRule(103); }
DebugLocation(292, 94);
PushFollow(Follow._ident_in_class_def1652);
ident161=ident();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_ident.Add(ident161.Tree);
DebugLocation(292, 100);
// SugarCpp.g:292:100: ( ( WS )* ',' ( WS )* ident )*
try { DebugEnterSubRule(106);
while (true)
{
int alt106=2;
try { DebugEnterDecision(106, false);
try
{
alt106 = dfa106.Predict(input);
}
catch (NoViableAltException nvae)
{
DebugRecognitionException(nvae);
throw;
}
} finally { DebugExitDecision(106); }
switch ( alt106 )
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:292:101: ( WS )* ',' ( WS )* ident
{
DebugLocation(292, 101);
// SugarCpp.g:292:101: ( WS )*
try { DebugEnterSubRule(104);
while (true)
{
int alt104=2;
try { DebugEnterDecision(104, false);
int LA104_0 = input.LA(1);
if ((LA104_0==WS))
{
alt104 = 1;
}
} finally { DebugExitDecision(104); }
switch ( alt104 )
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:292:101: WS
{
DebugLocation(292, 101);
WS162=(IToken)Match(input,WS,Follow._WS_in_class_def1655); if (state.failed) return retval;
if (state.backtracking == 0) stream_WS.Add(WS162);
}
break;
default:
goto loop104;
}
}
loop104:
;
} finally { DebugExitSubRule(104); }
DebugLocation(292, 105);
char_literal163=(IToken)Match(input,100,Follow._100_in_class_def1658); if (state.failed) return retval;
if (state.backtracking == 0) stream_100.Add(char_literal163);
DebugLocation(292, 109);
// SugarCpp.g:292:109: ( WS )*
try { DebugEnterSubRule(105);
while (true)
{
int alt105=2;
try { DebugEnterDecision(105, false);
int LA105_0 = input.LA(1);
if ((LA105_0==WS))
{
alt105 = 1;
}
} finally { DebugExitDecision(105); }
switch ( alt105 )
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:292:109: WS
{
DebugLocation(292, 109);
WS164=(IToken)Match(input,WS,Follow._WS_in_class_def1660); if (state.failed) return retval;
if (state.backtracking == 0) stream_WS.Add(WS164);
}
break;
default:
goto loop105;
}
}
loop105:
;
} finally { DebugExitSubRule(105); }
DebugLocation(292, 113);
PushFollow(Follow._ident_in_class_def1663);
ident165=ident();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_ident.Add(ident165.Tree);
}
break;
default:
goto loop106;
}
}
loop106:
;
} finally { DebugExitSubRule(106); }
}
break;
}
} finally { DebugExitSubRule(107); }
DebugLocation(292, 123);
// SugarCpp.g:292:123: ( ( WS )* ( NEWLINE )+ INDENT ( NEWLINE )* global_block DEDENT )?
int alt111=2;
try { DebugEnterSubRule(111);
try { DebugEnterDecision(111, false);
try
{
alt111 = dfa111.Predict(input);
}
catch (NoViableAltException nvae)
{
DebugRecognitionException(nvae);
throw;
}
} finally { DebugExitDecision(111); }
switch (alt111)
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:292:124: ( WS )* ( NEWLINE )+ INDENT ( NEWLINE )* global_block DEDENT
{
DebugLocation(292, 124);
// SugarCpp.g:292:124: ( WS )*
try { DebugEnterSubRule(108);
while (true)
{
int alt108=2;
try { DebugEnterDecision(108, false);
int LA108_0 = input.LA(1);
if ((LA108_0==WS))
{
alt108 = 1;
}
} finally { DebugExitDecision(108); }
switch ( alt108 )
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:292:124: WS
{
DebugLocation(292, 124);
WS166=(IToken)Match(input,WS,Follow._WS_in_class_def1670); if (state.failed) return retval;
if (state.backtracking == 0) stream_WS.Add(WS166);
}
break;
default:
goto loop108;
}
}
loop108:
;
} finally { DebugExitSubRule(108); }
DebugLocation(292, 128);
// SugarCpp.g:292:128: ( NEWLINE )+
int cnt109=0;
try { DebugEnterSubRule(109);
while (true)
{
int alt109=2;
try { DebugEnterDecision(109, false);
int LA109_0 = input.LA(1);
if ((LA109_0==NEWLINE))
{
alt109 = 1;
}
} finally { DebugExitDecision(109); }
switch (alt109)
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:292:128: NEWLINE
{
DebugLocation(292, 128);
NEWLINE167=(IToken)Match(input,NEWLINE,Follow._NEWLINE_in_class_def1673); if (state.failed) return retval;
if (state.backtracking == 0) stream_NEWLINE.Add(NEWLINE167);
}
break;
default:
if (cnt109 >= 1)
goto loop109;
if (state.backtracking>0) {state.failed=true; return retval;}
EarlyExitException eee109 = new EarlyExitException( 109, input );
DebugRecognitionException(eee109);
throw eee109;
}
cnt109++;
}
loop109:
;
} finally { DebugExitSubRule(109); }
DebugLocation(292, 137);
INDENT168=(IToken)Match(input,INDENT,Follow._INDENT_in_class_def1676); if (state.failed) return retval;
if (state.backtracking == 0) stream_INDENT.Add(INDENT168);
DebugLocation(292, 144);
// SugarCpp.g:292:144: ( NEWLINE )*
try { DebugEnterSubRule(110);
while (true)
{
int alt110=2;
try { DebugEnterDecision(110, false);
int LA110_0 = input.LA(1);
if ((LA110_0==NEWLINE))
{
alt110 = 1;
}
} finally { DebugExitDecision(110); }
switch ( alt110 )
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:292:144: NEWLINE
{
DebugLocation(292, 144);
NEWLINE169=(IToken)Match(input,NEWLINE,Follow._NEWLINE_in_class_def1678); if (state.failed) return retval;
if (state.backtracking == 0) stream_NEWLINE.Add(NEWLINE169);
}
break;
default:
goto loop110;
}
}
loop110:
;
} finally { DebugExitSubRule(110); }
DebugLocation(292, 153);
PushFollow(Follow._global_block_in_class_def1681);
global_block170=global_block();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_global_block.Add(global_block170.Tree);
DebugLocation(292, 166);
DEDENT171=(IToken)Match(input,DEDENT,Follow._DEDENT_in_class_def1683); if (state.failed) return retval;
if (state.backtracking == 0) stream_DEDENT.Add(DEDENT171);
}
break;
}
} finally { DebugExitSubRule(111); }
{
// AST REWRITE
// elements: ident, attribute, generic_parameter, 163, global_block, 139, class_args, 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();
// 292:175: -> ^( Class 'case' ( 'public' )? ( attribute )? ident ( generic_parameter )? ( class_args )? ( ^( Ident_List ( ident )* ) )? ( global_block )? )
{
DebugLocation(292, 178);
// SugarCpp.g:292:178: ^( Class 'case' ( 'public' )? ( attribute )? ident ( generic_parameter )? ( class_args )? ( ^( Ident_List ( ident )* ) )? ( global_block )? )
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(292, 180);
root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(Class, "Class"), root_1);
DebugLocation(292, 186);
adaptor.AddChild(root_1, stream_139.NextNode());
DebugLocation(292, 193);
// SugarCpp.g:292:193: ( 'public' )?
if (stream_163.HasNext)
{
DebugLocation(292, 193);
adaptor.AddChild(root_1, stream_163.NextNode());
}
stream_163.Reset();
DebugLocation(292, 203);
// SugarCpp.g:292:203: ( attribute )?
if (stream_attribute.HasNext)
{
DebugLocation(292, 203);
adaptor.AddChild(root_1, stream_attribute.NextTree());
}
stream_attribute.Reset();
DebugLocation(292, 214);
adaptor.AddChild(root_1, stream_ident.NextTree());
DebugLocation(292, 220);
// SugarCpp.g:292:220: ( generic_parameter )?
if (stream_generic_parameter.HasNext)
{
DebugLocation(292, 220);
adaptor.AddChild(root_1, stream_generic_parameter.NextTree());
}
stream_generic_parameter.Reset();
DebugLocation(292, 239);
// SugarCpp.g:292:239: ( class_args )?
if (stream_class_args.HasNext)
{
DebugLocation(292, 239);
adaptor.AddChild(root_1, stream_class_args.NextTree());
}
stream_class_args.Reset();
DebugLocation(292, 251);
// SugarCpp.g:292:251: ( ^( Ident_List ( ident )* ) )?
if (stream_ident.HasNext)
{
DebugLocation(292, 252);
// SugarCpp.g:292:252: ^( Ident_List ( ident )* )
{
CommonTree root_2 = (CommonTree)adaptor.Nil();
DebugLocation(292, 254);
root_2 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(Ident_List, "Ident_List"), root_2);
DebugLocation(292, 265);
// SugarCpp.g:292:265: ( ident )*
while ( stream_ident.HasNext )
{
DebugLocation(292, 265);
adaptor.AddChild(root_2, stream_ident.NextTree());
}
stream_ident.Reset();
adaptor.AddChild(root_1, root_2);
}
}
stream_ident.Reset();
DebugLocation(292, 275);
// SugarCpp.g:292:275: ( global_block )?
if (stream_global_block.HasNext)
{
DebugLocation(292, 275);
adaptor.AddChild(root_1, stream_global_block.NextTree());
}
stream_global_block.Reset();
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;
}
}
}
break;
}
} finally { DebugExitSubRule(112); }
}
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("class_def", 15);
LeaveRule("class_def", 15);
LeaveRule_class_def();
}
DebugLocation(294, 1);
} finally { DebugExitRule(GrammarFileName, "class_def"); }
return retval;
}
private AstParserRuleReturnScope<CommonTree, IToken> type_list()
{
EnterRule_type_list();
EnterRule("type_list", 16);
TraceIn("type_list", 16);
AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>();
retval.Start = (IToken)input.LT(1);
CommonTree root_0 = default(CommonTree);
IToken WS173 = default(IToken);
IToken char_literal174 = default(IToken);
IToken WS175 = default(IToken);
AstParserRuleReturnScope<CommonTree, IToken> type_name172 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> type_name176 = default(AstParserRuleReturnScope<CommonTree, IToken>);
CommonTree WS173_tree = default(CommonTree);
CommonTree char_literal174_tree = default(CommonTree);
CommonTree WS175_tree = default(CommonTree);
RewriteRuleITokenStream stream_WS=new RewriteRuleITokenStream(adaptor,"token WS");
RewriteRuleITokenStream stream_100=new RewriteRuleITokenStream(adaptor,"token 100");
RewriteRuleSubtreeStream stream_type_name=new RewriteRuleSubtreeStream(adaptor,"rule type_name");
try { DebugEnterRule(GrammarFileName, "type_list");
DebugLocation(296, 1);
try
{
// SugarCpp.g:297:2: ( type_name ( ( WS )* ',' ( WS )* type_name )* -> ^( Type_List ( type_name )* ) )
DebugEnterAlt(1);
// SugarCpp.g:297:4: type_name ( ( WS )* ',' ( WS )* type_name )*
{
DebugLocation(297, 4);
PushFollow(Follow._type_name_in_type_list1743);
type_name172=type_name();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_type_name.Add(type_name172.Tree);
DebugLocation(297, 14);
// SugarCpp.g:297:14: ( ( WS )* ',' ( WS )* type_name )*
try { DebugEnterSubRule(115);
while (true)
{
int alt115=2;
try { DebugEnterDecision(115, false);
try
{
alt115 = dfa115.Predict(input);
}
catch (NoViableAltException nvae)
{
DebugRecognitionException(nvae);
throw;
}
} finally { DebugExitDecision(115); }
switch ( alt115 )
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:297:15: ( WS )* ',' ( WS )* type_name
{
DebugLocation(297, 15);
// SugarCpp.g:297:15: ( WS )*
try { DebugEnterSubRule(113);
while (true)
{
int alt113=2;
try { DebugEnterDecision(113, false);
int LA113_0 = input.LA(1);
if ((LA113_0==WS))
{
alt113 = 1;
}
} finally { DebugExitDecision(113); }
switch ( alt113 )
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:297:15: WS
{
DebugLocation(297, 15);
WS173=(IToken)Match(input,WS,Follow._WS_in_type_list1746); if (state.failed) return retval;
if (state.backtracking == 0) stream_WS.Add(WS173);
}
break;
default:
goto loop113;
}
}
loop113:
;
} finally { DebugExitSubRule(113); }
DebugLocation(297, 19);
char_literal174=(IToken)Match(input,100,Follow._100_in_type_list1749); if (state.failed) return retval;
if (state.backtracking == 0) stream_100.Add(char_literal174);
DebugLocation(297, 24);
// SugarCpp.g:297:24: ( WS )*
try { DebugEnterSubRule(114);
while (true)
{
int alt114=2;
try { DebugEnterDecision(114, false);
int LA114_0 = input.LA(1);
if ((LA114_0==WS))
{
alt114 = 1;
}
} finally { DebugExitDecision(114); }
switch ( alt114 )
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:297:24: WS
{
DebugLocation(297, 24);
WS175=(IToken)Match(input,WS,Follow._WS_in_type_list1752); if (state.failed) return retval;
if (state.backtracking == 0) stream_WS.Add(WS175);
}
break;
default:
goto loop114;
}
}
loop114:
;
} finally { DebugExitSubRule(114); }
DebugLocation(297, 28);
PushFollow(Follow._type_name_in_type_list1755);
type_name176=type_name();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_type_name.Add(type_name176.Tree);
}
break;
default:
goto loop115;
}
}
loop115:
;
} finally { DebugExitSubRule(115); }
{
// AST REWRITE
// elements: type_name
// 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();
// 297:40: -> ^( Type_List ( type_name )* )
{
DebugLocation(297, 43);
// SugarCpp.g:297:43: ^( Type_List ( type_name )* )
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(297, 45);
root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(Type_List, "Type_List"), root_1);
DebugLocation(297, 55);
// SugarCpp.g:297:55: ( type_name )*
while ( stream_type_name.HasNext )
{
DebugLocation(297, 55);
adaptor.AddChild(root_1, stream_type_name.NextTree());
}
stream_type_name.Reset();
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;
}
}
}
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("type_list", 16);
LeaveRule("type_list", 16);
LeaveRule_type_list();
}
DebugLocation(298, 1);
} finally { DebugExitRule(GrammarFileName, "type_list"); }
return retval;
}
private AstParserRuleReturnScope<CommonTree, IToken> class_args()
{
EnterRule_class_args();
EnterRule("class_args", 14);
TraceIn("class_args", 14);
AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>();
retval.Start = (IToken)input.LT(1);
CommonTree root_0 = default(CommonTree);
IToken char_literal122 = default(IToken);
IToken WS123 = default(IToken);
IToken WS125 = default(IToken);
IToken char_literal126 = default(IToken);
IToken WS127 = default(IToken);
IToken char_literal128 = default(IToken);
AstParserRuleReturnScope<CommonTree, IToken> func_args124 = default(AstParserRuleReturnScope<CommonTree, IToken>);
CommonTree char_literal122_tree = default(CommonTree);
CommonTree WS123_tree = default(CommonTree);
CommonTree WS125_tree = default(CommonTree);
CommonTree char_literal126_tree = default(CommonTree);
CommonTree WS127_tree = default(CommonTree);
CommonTree char_literal128_tree = default(CommonTree);
RewriteRuleITokenStream stream_94=new RewriteRuleITokenStream(adaptor,"token 94");
RewriteRuleITokenStream stream_WS=new RewriteRuleITokenStream(adaptor,"token WS");
RewriteRuleITokenStream stream_93=new RewriteRuleITokenStream(adaptor,"token 93");
RewriteRuleSubtreeStream stream_func_args=new RewriteRuleSubtreeStream(adaptor,"rule func_args");
try { DebugEnterRule(GrammarFileName, "class_args");
DebugLocation(284, 1);
try
{
// SugarCpp.g:285:2: ( '(' ( ( WS )* func_args ( WS )* ')' -> func_args | ( WS )* ')' -> ^( Func_Args ) ) )
DebugEnterAlt(1);
// SugarCpp.g:285:4: '(' ( ( WS )* func_args ( WS )* ')' -> func_args | ( WS )* ')' -> ^( Func_Args ) )
{
DebugLocation(285, 4);
char_literal122=(IToken)Match(input,93,Follow._93_in_class_args1453); if (state.failed) return retval;
if (state.backtracking == 0) stream_93.Add(char_literal122);
DebugLocation(285, 8);
// SugarCpp.g:285:8: ( ( WS )* func_args ( WS )* ')' -> func_args | ( WS )* ')' -> ^( Func_Args ) )
int alt81=2;
try { DebugEnterSubRule(81);
try { DebugEnterDecision(81, false);
try
{
alt81 = dfa81.Predict(input);
}
catch (NoViableAltException nvae)
{
DebugRecognitionException(nvae);
throw;
}
} finally { DebugExitDecision(81); }
switch (alt81)
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:285:10: ( WS )* func_args ( WS )* ')'
{
DebugLocation(285, 10);
// SugarCpp.g:285:10: ( WS )*
try { DebugEnterSubRule(78);
while (true)
{
int alt78=2;
try { DebugEnterDecision(78, false);
int LA78_0 = input.LA(1);
if ((LA78_0==WS))
{
alt78 = 1;
}
} finally { DebugExitDecision(78); }
switch ( alt78 )
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:285:10: WS
{
DebugLocation(285, 10);
WS123=(IToken)Match(input,WS,Follow._WS_in_class_args1457); if (state.failed) return retval;
if (state.backtracking == 0) stream_WS.Add(WS123);
}
break;
default:
goto loop78;
}
}
loop78:
;
} finally { DebugExitSubRule(78); }
DebugLocation(285, 14);
PushFollow(Follow._func_args_in_class_args1460);
func_args124=func_args();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_func_args.Add(func_args124.Tree);
DebugLocation(285, 24);
// SugarCpp.g:285:24: ( WS )*
try { DebugEnterSubRule(79);
while (true)
{
int alt79=2;
try { DebugEnterDecision(79, false);
int LA79_0 = input.LA(1);
if ((LA79_0==WS))
{
alt79 = 1;
}
} finally { DebugExitDecision(79); }
switch ( alt79 )
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:285:24: WS
{
DebugLocation(285, 24);
WS125=(IToken)Match(input,WS,Follow._WS_in_class_args1462); if (state.failed) return retval;
if (state.backtracking == 0) stream_WS.Add(WS125);
}
break;
default:
goto loop79;
}
}
loop79:
;
} finally { DebugExitSubRule(79); }
DebugLocation(285, 28);
char_literal126=(IToken)Match(input,94,Follow._94_in_class_args1465); if (state.failed) return retval;
if (state.backtracking == 0) stream_94.Add(char_literal126);
{
// AST REWRITE
// elements: func_args
// 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();
// 285:32: -> func_args
{
DebugLocation(285, 35);
adaptor.AddChild(root_0, stream_func_args.NextTree());
}
retval.Tree = root_0;
}
}
}
break;
case 2:
DebugEnterAlt(2);
// SugarCpp.g:286:7: ( WS )* ')'
{
DebugLocation(286, 7);
// SugarCpp.g:286:7: ( WS )*
try { DebugEnterSubRule(80);
while (true)
{
int alt80=2;
try { DebugEnterDecision(80, false);
int LA80_0 = input.LA(1);
if ((LA80_0==WS))
{
alt80 = 1;
}
} finally { DebugExitDecision(80); }
switch ( alt80 )
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:286:7: WS
{
DebugLocation(286, 7);
WS127=(IToken)Match(input,WS,Follow._WS_in_class_args1477); if (state.failed) return retval;
if (state.backtracking == 0) stream_WS.Add(WS127);
}
break;
default:
goto loop80;
}
}
loop80:
;
} finally { DebugExitSubRule(80); }
DebugLocation(286, 11);
char_literal128=(IToken)Match(input,94,Follow._94_in_class_args1480); if (state.failed) return retval;
if (state.backtracking == 0) stream_94.Add(char_literal128);
{
// AST REWRITE
// elements:
// 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();
// 286:15: -> ^( Func_Args )
{
DebugLocation(286, 18);
// SugarCpp.g:286:18: ^( Func_Args )
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(286, 20);
root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(Func_Args, "Func_Args"), root_1);
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;
}
}
}
break;
}
} finally { DebugExitSubRule(81); }
}
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("class_args", 14);
LeaveRule("class_args", 14);
LeaveRule_class_args();
}
DebugLocation(288, 1);
} finally { DebugExitRule(GrammarFileName, "class_args"); }
return retval;
}
private AstParserRuleReturnScope<CommonTree, IToken> namespace_def()
{
EnterRule_namespace_def();
EnterRule("namespace_def", 13);
TraceIn("namespace_def", 13);
AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>();
retval.Start = (IToken)input.LT(1);
CommonTree root_0 = default(CommonTree);
IToken string_literal113 = default(IToken);
IToken WS114 = default(IToken);
IToken WS116 = default(IToken);
IToken NEWLINE117 = default(IToken);
IToken INDENT118 = default(IToken);
IToken NEWLINE119 = default(IToken);
IToken DEDENT121 = default(IToken);
AstParserRuleReturnScope<CommonTree, IToken> attribute112 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> ident115 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> global_block120 = default(AstParserRuleReturnScope<CommonTree, IToken>);
CommonTree string_literal113_tree = default(CommonTree);
CommonTree WS114_tree = default(CommonTree);
CommonTree WS116_tree = default(CommonTree);
CommonTree NEWLINE117_tree = default(CommonTree);
CommonTree INDENT118_tree = default(CommonTree);
CommonTree NEWLINE119_tree = default(CommonTree);
CommonTree DEDENT121_tree = default(CommonTree);
RewriteRuleITokenStream stream_WS=new RewriteRuleITokenStream(adaptor,"token WS");
RewriteRuleITokenStream stream_DEDENT=new RewriteRuleITokenStream(adaptor,"token DEDENT");
RewriteRuleITokenStream stream_NEWLINE=new RewriteRuleITokenStream(adaptor,"token NEWLINE");
RewriteRuleITokenStream stream_159=new RewriteRuleITokenStream(adaptor,"token 159");
RewriteRuleITokenStream stream_INDENT=new RewriteRuleITokenStream(adaptor,"token INDENT");
RewriteRuleSubtreeStream stream_ident=new RewriteRuleSubtreeStream(adaptor,"rule ident");
RewriteRuleSubtreeStream stream_attribute=new RewriteRuleSubtreeStream(adaptor,"rule attribute");
RewriteRuleSubtreeStream stream_global_block=new RewriteRuleSubtreeStream(adaptor,"rule global_block");
try { DebugEnterRule(GrammarFileName, "namespace_def");
DebugLocation(280, 1);
try
{
// SugarCpp.g:281:2: ( ( attribute )? 'namespace' ( WS )* ident ( ( WS )* ( NEWLINE )+ INDENT ( NEWLINE )* global_block DEDENT )? -> ^( Namespace ( attribute )? ident ( global_block )? ) )
DebugEnterAlt(1);
// SugarCpp.g:281:4: ( attribute )? 'namespace' ( WS )* ident ( ( WS )* ( NEWLINE )+ INDENT ( NEWLINE )* global_block DEDENT )?
{
DebugLocation(281, 4);
// SugarCpp.g:281:4: ( attribute )?
int alt72=2;
try { DebugEnterSubRule(72);
try { DebugEnterDecision(72, false);
int LA72_0 = input.LA(1);
if ((LA72_0==132))
{
alt72 = 1;
}
} finally { DebugExitDecision(72); }
switch (alt72)
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:281:4: attribute
{
DebugLocation(281, 4);
PushFollow(Follow._attribute_in_namespace_def1402);
attribute112=attribute();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_attribute.Add(attribute112.Tree);
}
break;
}
} finally { DebugExitSubRule(72); }
DebugLocation(281, 15);
string_literal113=(IToken)Match(input,159,Follow._159_in_namespace_def1405); if (state.failed) return retval;
if (state.backtracking == 0) stream_159.Add(string_literal113);
DebugLocation(281, 27);
// SugarCpp.g:281:27: ( WS )*
try { DebugEnterSubRule(73);
while (true)
{
int alt73=2;
try { DebugEnterDecision(73, false);
int LA73_0 = input.LA(1);
if ((LA73_0==WS))
{
alt73 = 1;
}
} finally { DebugExitDecision(73); }
switch ( alt73 )
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:281:27: WS
{
DebugLocation(281, 27);
WS114=(IToken)Match(input,WS,Follow._WS_in_namespace_def1407); if (state.failed) return retval;
if (state.backtracking == 0) stream_WS.Add(WS114);
}
break;
default:
goto loop73;
}
}
loop73:
;
} finally { DebugExitSubRule(73); }
DebugLocation(281, 31);
PushFollow(Follow._ident_in_namespace_def1410);
ident115=ident();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_ident.Add(ident115.Tree);
DebugLocation(281, 37);
// SugarCpp.g:281:37: ( ( WS )* ( NEWLINE )+ INDENT ( NEWLINE )* global_block DEDENT )?
int alt77=2;
try { DebugEnterSubRule(77);
try { DebugEnterDecision(77, false);
try
{
alt77 = dfa77.Predict(input);
}
catch (NoViableAltException nvae)
{
DebugRecognitionException(nvae);
throw;
}
} finally { DebugExitDecision(77); }
switch (alt77)
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:281:38: ( WS )* ( NEWLINE )+ INDENT ( NEWLINE )* global_block DEDENT
{
DebugLocation(281, 38);
// SugarCpp.g:281:38: ( WS )*
try { DebugEnterSubRule(74);
while (true)
{
int alt74=2;
try { DebugEnterDecision(74, false);
int LA74_0 = input.LA(1);
if ((LA74_0==WS))
{
alt74 = 1;
}
} finally { DebugExitDecision(74); }
switch ( alt74 )
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:281:38: WS
{
DebugLocation(281, 38);
WS116=(IToken)Match(input,WS,Follow._WS_in_namespace_def1413); if (state.failed) return retval;
if (state.backtracking == 0) stream_WS.Add(WS116);
}
break;
default:
goto loop74;
}
}
loop74:
;
} finally { DebugExitSubRule(74); }
DebugLocation(281, 42);
// SugarCpp.g:281:42: ( NEWLINE )+
int cnt75=0;
try { DebugEnterSubRule(75);
while (true)
{
int alt75=2;
try { DebugEnterDecision(75, false);
int LA75_0 = input.LA(1);
if ((LA75_0==NEWLINE))
{
alt75 = 1;
}
} finally { DebugExitDecision(75); }
switch (alt75)
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:281:42: NEWLINE
{
DebugLocation(281, 42);
NEWLINE117=(IToken)Match(input,NEWLINE,Follow._NEWLINE_in_namespace_def1416); if (state.failed) return retval;
if (state.backtracking == 0) stream_NEWLINE.Add(NEWLINE117);
}
break;
default:
if (cnt75 >= 1)
goto loop75;
if (state.backtracking>0) {state.failed=true; return retval;}
EarlyExitException eee75 = new EarlyExitException( 75, input );
DebugRecognitionException(eee75);
throw eee75;
}
cnt75++;
}
loop75:
;
} finally { DebugExitSubRule(75); }
DebugLocation(281, 51);
INDENT118=(IToken)Match(input,INDENT,Follow._INDENT_in_namespace_def1419); if (state.failed) return retval;
if (state.backtracking == 0) stream_INDENT.Add(INDENT118);
DebugLocation(281, 58);
// SugarCpp.g:281:58: ( NEWLINE )*
try { DebugEnterSubRule(76);
while (true)
{
int alt76=2;
try { DebugEnterDecision(76, false);
int LA76_0 = input.LA(1);
if ((LA76_0==NEWLINE))
{
alt76 = 1;
}
} finally { DebugExitDecision(76); }
switch ( alt76 )
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:281:58: NEWLINE
{
DebugLocation(281, 58);
NEWLINE119=(IToken)Match(input,NEWLINE,Follow._NEWLINE_in_namespace_def1421); if (state.failed) return retval;
if (state.backtracking == 0) stream_NEWLINE.Add(NEWLINE119);
}
break;
default:
goto loop76;
}
}
loop76:
;
} finally { DebugExitSubRule(76); }
DebugLocation(281, 67);
PushFollow(Follow._global_block_in_namespace_def1424);
global_block120=global_block();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_global_block.Add(global_block120.Tree);
DebugLocation(281, 80);
DEDENT121=(IToken)Match(input,DEDENT,Follow._DEDENT_in_namespace_def1426); if (state.failed) return retval;
if (state.backtracking == 0) stream_DEDENT.Add(DEDENT121);
}
break;
}
} finally { DebugExitSubRule(77); }
{
// AST REWRITE
// elements: ident, attribute, global_block
// 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();
// 281:89: -> ^( Namespace ( attribute )? ident ( global_block )? )
{
DebugLocation(281, 92);
// SugarCpp.g:281:92: ^( Namespace ( attribute )? ident ( global_block )? )
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(281, 94);
root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(Namespace, "Namespace"), root_1);
DebugLocation(281, 104);
// SugarCpp.g:281:104: ( attribute )?
if (stream_attribute.HasNext)
{
DebugLocation(281, 104);
adaptor.AddChild(root_1, stream_attribute.NextTree());
}
stream_attribute.Reset();
DebugLocation(281, 115);
adaptor.AddChild(root_1, stream_ident.NextTree());
DebugLocation(281, 121);
// SugarCpp.g:281:121: ( global_block )?
if (stream_global_block.HasNext)
{
DebugLocation(281, 121);
adaptor.AddChild(root_1, stream_global_block.NextTree());
}
stream_global_block.Reset();
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;
}
}
}
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("namespace_def", 13);
LeaveRule("namespace_def", 13);
LeaveRule_namespace_def();
}
DebugLocation(282, 1);
} finally { DebugExitRule(GrammarFileName, "namespace_def"); }
return retval;
}
private AstParserRuleReturnScope<CommonTree, IToken> enum_def()
{
EnterRule_enum_def();
EnterRule("enum_def", 12);
TraceIn("enum_def", 12);
AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>();
retval.Start = (IToken)input.LT(1);
CommonTree root_0 = default(CommonTree);
IToken string_literal101 = default(IToken);
IToken WS102 = default(IToken);
IToken WS104 = default(IToken);
IToken char_literal105 = default(IToken);
IToken WS106 = default(IToken);
IToken WS108 = default(IToken);
IToken char_literal109 = default(IToken);
IToken WS110 = default(IToken);
AstParserRuleReturnScope<CommonTree, IToken> attribute100 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> ident103 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> ident107 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> ident111 = default(AstParserRuleReturnScope<CommonTree, IToken>);
CommonTree string_literal101_tree = default(CommonTree);
CommonTree WS102_tree = default(CommonTree);
CommonTree WS104_tree = default(CommonTree);
CommonTree char_literal105_tree = default(CommonTree);
CommonTree WS106_tree = default(CommonTree);
CommonTree WS108_tree = default(CommonTree);
CommonTree char_literal109_tree = default(CommonTree);
CommonTree WS110_tree = default(CommonTree);
RewriteRuleITokenStream stream_182=new RewriteRuleITokenStream(adaptor,"token 182");
RewriteRuleITokenStream stream_146=new RewriteRuleITokenStream(adaptor,"token 146");
RewriteRuleITokenStream stream_WS=new RewriteRuleITokenStream(adaptor,"token WS");
RewriteRuleITokenStream stream_121=new RewriteRuleITokenStream(adaptor,"token 121");
RewriteRuleSubtreeStream stream_ident=new RewriteRuleSubtreeStream(adaptor,"rule ident");
RewriteRuleSubtreeStream stream_attribute=new RewriteRuleSubtreeStream(adaptor,"rule attribute");
try { DebugEnterRule(GrammarFileName, "enum_def");
DebugLocation(276, 1);
try
{
// SugarCpp.g:277:2: ( ( attribute )? 'enum' ( WS )* ident ( WS )* '=' ( ( WS )* ident ( ( WS )* '|' ( WS )* ident )* )? -> ^( Enum ( attribute )? ident ^( Ident_List ( ident )* ) ) )
DebugEnterAlt(1);
// SugarCpp.g:277:4: ( attribute )? 'enum' ( WS )* ident ( WS )* '=' ( ( WS )* ident ( ( WS )* '|' ( WS )* ident )* )?
{
DebugLocation(277, 4);
// SugarCpp.g:277:4: ( attribute )?
int alt64=2;
try { DebugEnterSubRule(64);
try { DebugEnterDecision(64, false);
int LA64_0 = input.LA(1);
if ((LA64_0==132))
{
alt64 = 1;
}
} finally { DebugExitDecision(64); }
switch (alt64)
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:277:4: attribute
{
DebugLocation(277, 4);
PushFollow(Follow._attribute_in_enum_def1339);
attribute100=attribute();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_attribute.Add(attribute100.Tree);
}
break;
}
} finally { DebugExitSubRule(64); }
DebugLocation(277, 15);
string_literal101=(IToken)Match(input,146,Follow._146_in_enum_def1342); if (state.failed) return retval;
if (state.backtracking == 0) stream_146.Add(string_literal101);
DebugLocation(277, 22);
// SugarCpp.g:277:22: ( WS )*
try { DebugEnterSubRule(65);
while (true)
{
int alt65=2;
try { DebugEnterDecision(65, false);
int LA65_0 = input.LA(1);
if ((LA65_0==WS))
{
alt65 = 1;
}
} finally { DebugExitDecision(65); }
switch ( alt65 )
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:277:22: WS
{
DebugLocation(277, 22);
WS102=(IToken)Match(input,WS,Follow._WS_in_enum_def1344); if (state.failed) return retval;
if (state.backtracking == 0) stream_WS.Add(WS102);
}
break;
default:
goto loop65;
}
}
loop65:
;
} finally { DebugExitSubRule(65); }
DebugLocation(277, 26);
PushFollow(Follow._ident_in_enum_def1347);
ident103=ident();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_ident.Add(ident103.Tree);
DebugLocation(277, 32);
// SugarCpp.g:277:32: ( WS )*
try { DebugEnterSubRule(66);
while (true)
{
int alt66=2;
try { DebugEnterDecision(66, false);
int LA66_0 = input.LA(1);
if ((LA66_0==WS))
{
alt66 = 1;
}
} finally { DebugExitDecision(66); }
switch ( alt66 )
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:277:32: WS
{
DebugLocation(277, 32);
WS104=(IToken)Match(input,WS,Follow._WS_in_enum_def1349); if (state.failed) return retval;
if (state.backtracking == 0) stream_WS.Add(WS104);
}
break;
default:
goto loop66;
}
}
loop66:
;
} finally { DebugExitSubRule(66); }
DebugLocation(277, 36);
char_literal105=(IToken)Match(input,121,Follow._121_in_enum_def1352); if (state.failed) return retval;
if (state.backtracking == 0) stream_121.Add(char_literal105);
DebugLocation(277, 40);
// SugarCpp.g:277:40: ( ( WS )* ident ( ( WS )* '|' ( WS )* ident )* )?
int alt71=2;
try { DebugEnterSubRule(71);
try { DebugEnterDecision(71, false);
try
{
alt71 = dfa71.Predict(input);
}
catch (NoViableAltException nvae)
{
DebugRecognitionException(nvae);
throw;
}
} finally { DebugExitDecision(71); }
switch (alt71)
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:277:41: ( WS )* ident ( ( WS )* '|' ( WS )* ident )*
{
DebugLocation(277, 41);
// SugarCpp.g:277:41: ( WS )*
try { DebugEnterSubRule(67);
while (true)
{
int alt67=2;
try { DebugEnterDecision(67, false);
int LA67_0 = input.LA(1);
if ((LA67_0==WS))
{
alt67 = 1;
}
} finally { DebugExitDecision(67); }
switch ( alt67 )
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:277:41: WS
{
DebugLocation(277, 41);
WS106=(IToken)Match(input,WS,Follow._WS_in_enum_def1355); if (state.failed) return retval;
if (state.backtracking == 0) stream_WS.Add(WS106);
}
break;
default:
goto loop67;
}
}
loop67:
;
} finally { DebugExitSubRule(67); }
DebugLocation(277, 45);
PushFollow(Follow._ident_in_enum_def1358);
ident107=ident();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_ident.Add(ident107.Tree);
DebugLocation(277, 51);
// SugarCpp.g:277:51: ( ( WS )* '|' ( WS )* ident )*
try { DebugEnterSubRule(70);
while (true)
{
int alt70=2;
try { DebugEnterDecision(70, false);
try
{
alt70 = dfa70.Predict(input);
}
catch (NoViableAltException nvae)
{
DebugRecognitionException(nvae);
throw;
}
} finally { DebugExitDecision(70); }
switch ( alt70 )
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:277:52: ( WS )* '|' ( WS )* ident
{
DebugLocation(277, 52);
// SugarCpp.g:277:52: ( WS )*
try { DebugEnterSubRule(68);
while (true)
{
int alt68=2;
try { DebugEnterDecision(68, false);
int LA68_0 = input.LA(1);
if ((LA68_0==WS))
{
alt68 = 1;
}
} finally { DebugExitDecision(68); }
switch ( alt68 )
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:277:52: WS
{
DebugLocation(277, 52);
WS108=(IToken)Match(input,WS,Follow._WS_in_enum_def1361); if (state.failed) return retval;
if (state.backtracking == 0) stream_WS.Add(WS108);
}
break;
default:
goto loop68;
}
}
loop68:
;
} finally { DebugExitSubRule(68); }
DebugLocation(277, 56);
char_literal109=(IToken)Match(input,182,Follow._182_in_enum_def1364); if (state.failed) return retval;
if (state.backtracking == 0) stream_182.Add(char_literal109);
DebugLocation(277, 60);
// SugarCpp.g:277:60: ( WS )*
try { DebugEnterSubRule(69);
while (true)
{
int alt69=2;
try { DebugEnterDecision(69, false);
int LA69_0 = input.LA(1);
if ((LA69_0==WS))
{
alt69 = 1;
}
} finally { DebugExitDecision(69); }
switch ( alt69 )
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:277:60: WS
{
DebugLocation(277, 60);
WS110=(IToken)Match(input,WS,Follow._WS_in_enum_def1366); if (state.failed) return retval;
if (state.backtracking == 0) stream_WS.Add(WS110);
}
break;
default:
goto loop69;
}
}
loop69:
;
} finally { DebugExitSubRule(69); }
DebugLocation(277, 64);
PushFollow(Follow._ident_in_enum_def1369);
ident111=ident();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_ident.Add(ident111.Tree);
}
break;
default:
goto loop70;
}
}
loop70:
;
} finally { DebugExitSubRule(70); }
}
break;
}
} finally { DebugExitSubRule(71); }
{
// AST REWRITE
// elements: ident, ident, attribute
// 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();
// 277:74: -> ^( Enum ( attribute )? ident ^( Ident_List ( ident )* ) )
{
DebugLocation(277, 77);
// SugarCpp.g:277:77: ^( Enum ( attribute )? ident ^( Ident_List ( ident )* ) )
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(277, 79);
root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(Enum, "Enum"), root_1);
DebugLocation(277, 84);
// SugarCpp.g:277:84: ( attribute )?
if (stream_attribute.HasNext)
{
DebugLocation(277, 84);
adaptor.AddChild(root_1, stream_attribute.NextTree());
}
stream_attribute.Reset();
DebugLocation(277, 95);
adaptor.AddChild(root_1, stream_ident.NextTree());
DebugLocation(277, 101);
// SugarCpp.g:277:101: ^( Ident_List ( ident )* )
{
CommonTree root_2 = (CommonTree)adaptor.Nil();
DebugLocation(277, 103);
root_2 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(Ident_List, "Ident_List"), root_2);
DebugLocation(277, 114);
// SugarCpp.g:277:114: ( ident )*
while ( stream_ident.HasNext )
{
DebugLocation(277, 114);
adaptor.AddChild(root_2, stream_ident.NextTree());
}
stream_ident.Reset();
adaptor.AddChild(root_1, root_2);
}
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;
}
}
}
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("enum_def", 12);
LeaveRule("enum_def", 12);
LeaveRule_enum_def();
}
DebugLocation(278, 1);
} finally { DebugExitRule(GrammarFileName, "enum_def"); }
return retval;
}
private AstParserRuleReturnScope<object, IToken> orderby_expr()
{
EnterRule_orderby_expr();
EnterRule("orderby_expr", 20);
TraceIn("orderby_expr", 20);
AstParserRuleReturnScope<object, IToken> retval = new AstParserRuleReturnScope<object, IToken>();
retval.Start = (IToken)input.LT(1);
object root_0 = default(object);
AstParserRuleReturnScope<object, IToken> exp84 = default(AstParserRuleReturnScope<object, IToken>);
AstParserRuleReturnScope<object, IToken> sortorder_operator85 = default(AstParserRuleReturnScope<object, IToken>);
RewriteRuleSubtreeStream stream_exp=new RewriteRuleSubtreeStream(adaptor,"rule exp");
RewriteRuleSubtreeStream stream_sortorder_operator=new RewriteRuleSubtreeStream(adaptor,"rule sortorder_operator");
try { DebugEnterRule(GrammarFileName, "orderby_expr");
DebugLocation(184, 1);
try
{
// Queries\\PomonaQuery.g:185:2: ( exp ( sortorder_operator )? -> ^( ORDERBY_ASC exp ( sortorder_operator )? ) )
DebugEnterAlt(1);
// Queries\\PomonaQuery.g:185:4: exp ( sortorder_operator )?
{
DebugLocation(185, 4);
PushFollow(Follow._exp_in_orderby_expr1167);
exp84=exp();
PopFollow();
stream_exp.Add(exp84.Tree);
DebugLocation(185, 8);
// Queries\\PomonaQuery.g:185:8: ( sortorder_operator )?
int alt27=2;
try { DebugEnterSubRule(27);
try { DebugEnterDecision(27, false);
int LA27_1 = input.LA(1);
if (((LA27_1>=62 && LA27_1<=63)))
{
alt27 = 1;
}
} finally { DebugExitDecision(27); }
switch (alt27)
{
case 1:
DebugEnterAlt(1);
// Queries\\PomonaQuery.g:185:9: sortorder_operator
{
DebugLocation(185, 9);
PushFollow(Follow._sortorder_operator_in_orderby_expr1170);
sortorder_operator85=sortorder_operator();
PopFollow();
stream_sortorder_operator.Add(sortorder_operator85.Tree);
}
break;
}
} finally { DebugExitSubRule(27); }
{
// AST REWRITE
// elements: exp, sortorder_operator
// 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();
// 185:30: -> ^( ORDERBY_ASC exp ( sortorder_operator )? )
{
DebugLocation(185, 33);
// Queries\\PomonaQuery.g:185:33: ^( ORDERBY_ASC exp ( sortorder_operator )? )
{
object root_1 = (object)adaptor.Nil();
DebugLocation(185, 35);
root_1 = (object)adaptor.BecomeRoot((object)adaptor.Create(ORDERBY_ASC, "ORDERBY_ASC"), root_1);
DebugLocation(185, 47);
adaptor.AddChild(root_1, stream_exp.NextTree());
DebugLocation(185, 51);
// Queries\\PomonaQuery.g:185:51: ( sortorder_operator )?
if (stream_sortorder_operator.HasNext)
{
DebugLocation(185, 51);
adaptor.AddChild(root_1, stream_sortorder_operator.NextTree());
}
stream_sortorder_operator.Reset();
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;
}
}
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("orderby_expr", 20);
LeaveRule("orderby_expr", 20);
LeaveRule_orderby_expr();
}
DebugLocation(186, 1);
} finally { DebugExitRule(GrammarFileName, "orderby_expr"); }
return retval;
}
private AstParserRuleReturnScope<CommonTree, IToken> type_no_array()
{
EnterRule_type_no_array();
EnterRule("type_no_array", 19);
TraceIn("type_no_array", 19);
AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>();
retval.Start = (IToken)input.LT(1);
CommonTree root_0 = default(CommonTree);
IToken WS215 = default(IToken);
IToken char_literal216 = default(IToken);
AstParserRuleReturnScope<CommonTree, IToken> type_star214 = default(AstParserRuleReturnScope<CommonTree, IToken>);
CommonTree WS215_tree = default(CommonTree);
CommonTree char_literal216_tree = default(CommonTree);
RewriteRuleITokenStream stream_WS=new RewriteRuleITokenStream(adaptor,"token WS");
RewriteRuleITokenStream stream_91=new RewriteRuleITokenStream(adaptor,"token 91");
RewriteRuleSubtreeStream stream_type_star=new RewriteRuleSubtreeStream(adaptor,"rule type_star");
try { DebugEnterRule(GrammarFileName, "type_no_array");
DebugLocation(316, 1);
try
{
// SugarCpp.g:317:2: ( type_star ( ( WS )* '&' -> ^( Type_Ref type_star ) | -> type_star ) )
DebugEnterAlt(1);
// SugarCpp.g:317:4: type_star ( ( WS )* '&' -> ^( Type_Ref type_star ) | -> type_star )
{
DebugLocation(317, 4);
PushFollow(Follow._type_star_in_type_no_array2039);
type_star214=type_star();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_type_star.Add(type_star214.Tree);
DebugLocation(317, 14);
// SugarCpp.g:317:14: ( ( WS )* '&' -> ^( Type_Ref type_star ) | -> type_star )
int alt142=2;
try { DebugEnterSubRule(142);
try { DebugEnterDecision(142, false);
try
{
alt142 = dfa142.Predict(input);
}
catch (NoViableAltException nvae)
{
DebugRecognitionException(nvae);
throw;
}
} finally { DebugExitDecision(142); }
switch (alt142)
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:317:16: ( WS )* '&'
{
DebugLocation(317, 16);
// SugarCpp.g:317:16: ( WS )*
try { DebugEnterSubRule(141);
while (true)
{
int alt141=2;
try { DebugEnterDecision(141, false);
int LA141_0 = input.LA(1);
if ((LA141_0==WS))
{
alt141 = 1;
}
} finally { DebugExitDecision(141); }
switch ( alt141 )
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:317:16: WS
{
DebugLocation(317, 16);
WS215=(IToken)Match(input,WS,Follow._WS_in_type_no_array2043); if (state.failed) return retval;
if (state.backtracking == 0) stream_WS.Add(WS215);
}
break;
default:
goto loop141;
}
}
loop141:
;
} finally { DebugExitSubRule(141); }
DebugLocation(317, 20);
char_literal216=(IToken)Match(input,91,Follow._91_in_type_no_array2046); if (state.failed) return retval;
if (state.backtracking == 0) stream_91.Add(char_literal216);
{
// AST REWRITE
// elements: type_star
// 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();
// 317:24: -> ^( Type_Ref type_star )
{
DebugLocation(317, 27);
// SugarCpp.g:317:27: ^( Type_Ref type_star )
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(317, 29);
root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(Type_Ref, "Type_Ref"), root_1);
DebugLocation(317, 38);
adaptor.AddChild(root_1, stream_type_star.NextTree());
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;
}
}
}
break;
case 2:
DebugEnterAlt(2);
// SugarCpp.g:318:7:
{
{
// AST REWRITE
// elements: type_star
// 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();
// 318:7: -> type_star
{
DebugLocation(318, 10);
adaptor.AddChild(root_0, stream_type_star.NextTree());
}
retval.Tree = root_0;
}
}
}
break;
}
} finally { DebugExitSubRule(142); }
}
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("type_no_array", 19);
LeaveRule("type_no_array", 19);
LeaveRule_type_no_array();
}
DebugLocation(320, 1);
} finally { DebugExitRule(GrammarFileName, "type_no_array"); }
return retval;
}
private AstParserRuleReturnScope<object, IToken> lambda_expression()
{
EnterRule_lambda_expression();
EnterRule("lambda_expression", 4);
TraceIn("lambda_expression", 4);
AstParserRuleReturnScope<object, IToken> retval = new AstParserRuleReturnScope<object, IToken>();
retval.Start = (IToken)input.LT(1);
object root_0 = default(object);
IToken char_literal8 = default(IToken);
AstParserRuleReturnScope<object, IToken> or_expression7 = default(AstParserRuleReturnScope<object, IToken>);
AstParserRuleReturnScope<object, IToken> or_expression9 = default(AstParserRuleReturnScope<object, IToken>);
object char_literal8_tree = default(object);
RewriteRuleITokenStream stream_51=new RewriteRuleITokenStream(adaptor,"token 51");
RewriteRuleSubtreeStream stream_or_expression=new RewriteRuleSubtreeStream(adaptor,"rule or_expression");
try { DebugEnterRule(GrammarFileName, "lambda_expression");
DebugLocation(89, 1);
try
{
// Queries\\PomonaQuery.g:90:2: ( or_expression ( ':' or_expression )? -> ^( LAMBDA_OP ( or_expression )+ ) )
DebugEnterAlt(1);
// Queries\\PomonaQuery.g:90:4: or_expression ( ':' or_expression )?
{
DebugLocation(90, 4);
PushFollow(Follow._or_expression_in_lambda_expression559);
or_expression7=or_expression();
PopFollow();
stream_or_expression.Add(or_expression7.Tree);
DebugLocation(90, 18);
// Queries\\PomonaQuery.g:90:18: ( ':' or_expression )?
int alt2=2;
try { DebugEnterSubRule(2);
try { DebugEnterDecision(2, false);
int LA2_1 = input.LA(1);
if ((LA2_1==51))
{
alt2 = 1;
}
} finally { DebugExitDecision(2); }
switch (alt2)
{
case 1:
DebugEnterAlt(1);
// Queries\\PomonaQuery.g:90:20: ':' or_expression
{
DebugLocation(90, 20);
char_literal8=(IToken)Match(input,51,Follow._51_in_lambda_expression563);
stream_51.Add(char_literal8);
DebugLocation(90, 24);
PushFollow(Follow._or_expression_in_lambda_expression565);
or_expression9=or_expression();
PopFollow();
stream_or_expression.Add(or_expression9.Tree);
}
break;
}
} finally { DebugExitSubRule(2); }
{
// AST REWRITE
// elements: or_expression
// 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();
// 90:41: -> ^( LAMBDA_OP ( or_expression )+ )
{
DebugLocation(90, 44);
// Queries\\PomonaQuery.g:90:44: ^( LAMBDA_OP ( or_expression )+ )
{
object root_1 = (object)adaptor.Nil();
DebugLocation(90, 46);
root_1 = (object)adaptor.BecomeRoot((object)adaptor.Create(LAMBDA_OP, "LAMBDA_OP"), root_1);
DebugLocation(90, 56);
if (!(stream_or_expression.HasNext))
{
throw new RewriteEarlyExitException();
}
while ( stream_or_expression.HasNext )
{
DebugLocation(90, 56);
adaptor.AddChild(root_1, stream_or_expression.NextTree());
}
stream_or_expression.Reset();
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;
}
}
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("lambda_expression", 4);
LeaveRule("lambda_expression", 4);
LeaveRule_lambda_expression();
}
DebugLocation(91, 1);
} finally { DebugExitRule(GrammarFileName, "lambda_expression"); }
return retval;
}
private AstParserRuleReturnScope<CommonTree, IToken> type_star()
{
EnterRule_type_star();
EnterRule("type_star", 20);
TraceIn("type_star", 20);
AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>();
retval.Start = (IToken)input.LT(1);
CommonTree root_0 = default(CommonTree);
IToken WS218 = default(IToken);
IToken char_literal219 = default(IToken);
AstParserRuleReturnScope<CommonTree, IToken> type_template_type217 = default(AstParserRuleReturnScope<CommonTree, IToken>);
CommonTree WS218_tree = default(CommonTree);
CommonTree char_literal219_tree = default(CommonTree);
RewriteRuleITokenStream stream_95=new RewriteRuleITokenStream(adaptor,"token 95");
RewriteRuleITokenStream stream_WS=new RewriteRuleITokenStream(adaptor,"token WS");
RewriteRuleSubtreeStream stream_type_template_type=new RewriteRuleSubtreeStream(adaptor,"rule type_template_type");
try { DebugEnterRule(GrammarFileName, "type_star");
DebugLocation(322, 1);
try
{
// SugarCpp.g:323:2: ( type_template_type ( ( ( WS )* '*' )+ -> ^( Type_Star type_template_type ( '*' )+ ) | -> type_template_type ) )
DebugEnterAlt(1);
// SugarCpp.g:323:4: type_template_type ( ( ( WS )* '*' )+ -> ^( Type_Star type_template_type ( '*' )+ ) | -> type_template_type )
{
DebugLocation(323, 4);
PushFollow(Follow._type_template_type_in_type_star2081);
type_template_type217=type_template_type();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_type_template_type.Add(type_template_type217.Tree);
DebugLocation(323, 23);
// SugarCpp.g:323:23: ( ( ( WS )* '*' )+ -> ^( Type_Star type_template_type ( '*' )+ ) | -> type_template_type )
int alt145=2;
try { DebugEnterSubRule(145);
try { DebugEnterDecision(145, false);
try
{
alt145 = dfa145.Predict(input);
}
catch (NoViableAltException nvae)
{
DebugRecognitionException(nvae);
throw;
}
} finally { DebugExitDecision(145); }
switch (alt145)
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:323:25: ( ( WS )* '*' )+
{
DebugLocation(323, 25);
// SugarCpp.g:323:25: ( ( WS )* '*' )+
int cnt144=0;
try { DebugEnterSubRule(144);
while (true)
{
int alt144=2;
try { DebugEnterDecision(144, false);
try
{
alt144 = dfa144.Predict(input);
}
catch (NoViableAltException nvae)
{
DebugRecognitionException(nvae);
throw;
}
} finally { DebugExitDecision(144); }
switch (alt144)
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:323:26: ( WS )* '*'
{
DebugLocation(323, 26);
// SugarCpp.g:323:26: ( WS )*
try { DebugEnterSubRule(143);
while (true)
{
int alt143=2;
try { DebugEnterDecision(143, false);
int LA143_0 = input.LA(1);
if ((LA143_0==WS))
{
alt143 = 1;
}
} finally { DebugExitDecision(143); }
switch ( alt143 )
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:323:26: WS
{
DebugLocation(323, 26);
WS218=(IToken)Match(input,WS,Follow._WS_in_type_star2086); if (state.failed) return retval;
if (state.backtracking == 0) stream_WS.Add(WS218);
}
break;
default:
goto loop143;
}
}
loop143:
;
} finally { DebugExitSubRule(143); }
DebugLocation(323, 30);
char_literal219=(IToken)Match(input,95,Follow._95_in_type_star2089); if (state.failed) return retval;
if (state.backtracking == 0) stream_95.Add(char_literal219);
}
break;
default:
if (cnt144 >= 1)
goto loop144;
if (state.backtracking>0) {state.failed=true; return retval;}
EarlyExitException eee144 = new EarlyExitException( 144, input );
DebugRecognitionException(eee144);
throw eee144;
}
cnt144++;
}
loop144:
;
} finally { DebugExitSubRule(144); }
{
// AST REWRITE
// elements: type_template_type, 95
// 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();
// 323:36: -> ^( Type_Star type_template_type ( '*' )+ )
{
DebugLocation(323, 39);
// SugarCpp.g:323:39: ^( Type_Star type_template_type ( '*' )+ )
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(323, 41);
root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(Type_Star, "Type_Star"), root_1);
DebugLocation(323, 51);
adaptor.AddChild(root_1, stream_type_template_type.NextTree());
DebugLocation(323, 70);
if (!(stream_95.HasNext))
{
throw new RewriteEarlyExitException();
}
while ( stream_95.HasNext )
{
DebugLocation(323, 70);
adaptor.AddChild(root_1, stream_95.NextNode());
}
stream_95.Reset();
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;
}
}
}
break;
case 2:
DebugEnterAlt(2);
// SugarCpp.g:324:10:
{
{
// AST REWRITE
// elements: type_template_type
// 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();
// 324:10: -> type_template_type
{
DebugLocation(324, 13);
adaptor.AddChild(root_0, stream_type_template_type.NextTree());
}
retval.Tree = root_0;
}
}
}
break;
}
} finally { DebugExitSubRule(145); }
}
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("type_star", 20);
LeaveRule("type_star", 20);
LeaveRule_type_star();
}
DebugLocation(326, 1);
} finally { DebugExitRule(GrammarFileName, "type_star"); }
return retval;
}
private AstParserRuleReturnScope<object, IToken> and_expression()
{
EnterRule_and_expression();
EnterRule("and_expression", 7);
TraceIn("and_expression", 7);
AstParserRuleReturnScope<object, IToken> retval = new AstParserRuleReturnScope<object, IToken>();
retval.Start = (IToken)input.LT(1);
object root_0 = default(object);
AstParserRuleReturnScope<object, IToken> relational_expr15 = default(AstParserRuleReturnScope<object, IToken>);
AstParserRuleReturnScope<object, IToken> and_operator16 = default(AstParserRuleReturnScope<object, IToken>);
AstParserRuleReturnScope<object, IToken> relational_expr17 = default(AstParserRuleReturnScope<object, IToken>);
RewriteRuleSubtreeStream stream_relational_expr=new RewriteRuleSubtreeStream(adaptor,"rule relational_expr");
RewriteRuleSubtreeStream stream_and_operator=new RewriteRuleSubtreeStream(adaptor,"rule and_operator");
try { DebugEnterRule(GrammarFileName, "and_expression");
DebugLocation(101, 1);
try
{
// Queries\\PomonaQuery.g:102:2: ( relational_expr ( and_operator relational_expr )* -> ^( AND_OP ( relational_expr )+ ) )
DebugEnterAlt(1);
// Queries\\PomonaQuery.g:102:4: relational_expr ( and_operator relational_expr )*
{
DebugLocation(102, 4);
PushFollow(Follow._relational_expr_in_and_expression637);
relational_expr15=relational_expr();
PopFollow();
stream_relational_expr.Add(relational_expr15.Tree);
DebugLocation(102, 20);
// Queries\\PomonaQuery.g:102:20: ( and_operator relational_expr )*
try { DebugEnterSubRule(5);
while (true)
{
int alt5=2;
try { DebugEnterDecision(5, false);
int LA5_1 = input.LA(1);
if ((LA5_1==42||LA5_1==60))
{
alt5 = 1;
}
} finally { DebugExitDecision(5); }
switch ( alt5 )
{
case 1:
DebugEnterAlt(1);
// Queries\\PomonaQuery.g:102:22: and_operator relational_expr
{
DebugLocation(102, 22);
PushFollow(Follow._and_operator_in_and_expression641);
and_operator16=and_operator();
PopFollow();
stream_and_operator.Add(and_operator16.Tree);
DebugLocation(102, 35);
PushFollow(Follow._relational_expr_in_and_expression643);
relational_expr17=relational_expr();
PopFollow();
stream_relational_expr.Add(relational_expr17.Tree);
}
break;
default:
goto loop5;
}
}
loop5:
;
} finally { DebugExitSubRule(5); }
{
// AST REWRITE
// elements: relational_expr
// 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();
// 102:54: -> ^( AND_OP ( relational_expr )+ )
{
DebugLocation(102, 57);
// Queries\\PomonaQuery.g:102:57: ^( AND_OP ( relational_expr )+ )
{
object root_1 = (object)adaptor.Nil();
DebugLocation(102, 59);
root_1 = (object)adaptor.BecomeRoot((object)adaptor.Create(AND_OP, "AND_OP"), root_1);
DebugLocation(102, 66);
if (!(stream_relational_expr.HasNext))
{
throw new RewriteEarlyExitException();
}
while ( stream_relational_expr.HasNext )
{
DebugLocation(102, 66);
adaptor.AddChild(root_1, stream_relational_expr.NextTree());
}
stream_relational_expr.Reset();
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;
}
}
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("and_expression", 7);
LeaveRule("and_expression", 7);
LeaveRule_and_expression();
}
DebugLocation(103, 1);
} finally { DebugExitRule(GrammarFileName, "and_expression"); }
return retval;
}
private AstParserRuleReturnScope<CommonTree, IToken> type_template_type()
{
EnterRule_type_template_type();
EnterRule("type_template_type", 21);
TraceIn("type_template_type", 21);
AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>();
retval.Start = (IToken)input.LT(1);
CommonTree root_0 = default(CommonTree);
IToken char_literal221 = default(IToken);
IToken WS222 = default(IToken);
IToken WS224 = default(IToken);
IToken char_literal225 = default(IToken);
IToken WS226 = default(IToken);
IToken WS228 = default(IToken);
IToken char_literal229 = default(IToken);
AstParserRuleReturnScope<CommonTree, IToken> type_ident220 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> type_name223 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> type_name227 = default(AstParserRuleReturnScope<CommonTree, IToken>);
CommonTree char_literal221_tree = default(CommonTree);
CommonTree WS222_tree = default(CommonTree);
CommonTree WS224_tree = default(CommonTree);
CommonTree char_literal225_tree = default(CommonTree);
CommonTree WS226_tree = default(CommonTree);
CommonTree WS228_tree = default(CommonTree);
CommonTree char_literal229_tree = default(CommonTree);
RewriteRuleITokenStream stream_125=new RewriteRuleITokenStream(adaptor,"token 125");
RewriteRuleITokenStream stream_115=new RewriteRuleITokenStream(adaptor,"token 115");
RewriteRuleITokenStream stream_WS=new RewriteRuleITokenStream(adaptor,"token WS");
RewriteRuleITokenStream stream_100=new RewriteRuleITokenStream(adaptor,"token 100");
RewriteRuleSubtreeStream stream_type_name=new RewriteRuleSubtreeStream(adaptor,"rule type_name");
RewriteRuleSubtreeStream stream_type_ident=new RewriteRuleSubtreeStream(adaptor,"rule type_ident");
try { DebugEnterRule(GrammarFileName, "type_template_type");
DebugLocation(328, 1);
try
{
// SugarCpp.g:329:2: ( type_ident ( '<' ( ( WS )* type_name ( ( WS )* ',' ( WS )* type_name )* )? ( WS )* '>' -> ^( Type_Template type_ident ( type_name )* ) | -> type_ident ) )
DebugEnterAlt(1);
// SugarCpp.g:329:4: type_ident ( '<' ( ( WS )* type_name ( ( WS )* ',' ( WS )* type_name )* )? ( WS )* '>' -> ^( Type_Template type_ident ( type_name )* ) | -> type_ident )
{
DebugLocation(329, 4);
PushFollow(Follow._type_ident_in_type_template_type2135);
type_ident220=type_ident();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_type_ident.Add(type_ident220.Tree);
DebugLocation(329, 15);
// SugarCpp.g:329:15: ( '<' ( ( WS )* type_name ( ( WS )* ',' ( WS )* type_name )* )? ( WS )* '>' -> ^( Type_Template type_ident ( type_name )* ) | -> type_ident )
int alt152=2;
try { DebugEnterSubRule(152);
try { DebugEnterDecision(152, false);
int LA152_0 = input.LA(1);
if ((LA152_0==115))
{
alt152 = 1;
}
else if ((LA152_0==DEDENT||(LA152_0>=IDENT && LA152_0<=INDENT)||LA152_0==NEWLINE||LA152_0==WS||LA152_0==91||(LA152_0>=93 && LA152_0<=95)||LA152_0==100||LA152_0==105||(LA152_0>=113 && LA152_0<=114)||LA152_0==121||(LA152_0>=124 && LA152_0<=125)||(LA152_0>=132 && LA152_0<=133)||LA152_0==138||LA152_0==144||(LA152_0>=149 && LA152_0<=150)||LA152_0==152||LA152_0==165||LA152_0==169||(LA152_0>=171 && LA152_0<=172)||(LA152_0>=175 && LA152_0<=176)||(LA152_0>=180 && LA152_0<=181)||LA152_0==186))
{
alt152 = 2;
}
else
{
if (state.backtracking>0) {state.failed=true; return retval;}
NoViableAltException nvae = new NoViableAltException("", 152, 0, input);
DebugRecognitionException(nvae);
throw nvae;
}
} finally { DebugExitDecision(152); }
switch (alt152)
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:329:17: '<' ( ( WS )* type_name ( ( WS )* ',' ( WS )* type_name )* )? ( WS )* '>'
{
DebugLocation(329, 17);
char_literal221=(IToken)Match(input,115,Follow._115_in_type_template_type2139); if (state.failed) return retval;
if (state.backtracking == 0) stream_115.Add(char_literal221);
DebugLocation(329, 21);
// SugarCpp.g:329:21: ( ( WS )* type_name ( ( WS )* ',' ( WS )* type_name )* )?
int alt150=2;
try { DebugEnterSubRule(150);
try { DebugEnterDecision(150, false);
try
{
alt150 = dfa150.Predict(input);
}
catch (NoViableAltException nvae)
{
DebugRecognitionException(nvae);
throw;
}
} finally { DebugExitDecision(150); }
switch (alt150)
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:329:22: ( WS )* type_name ( ( WS )* ',' ( WS )* type_name )*
{
DebugLocation(329, 22);
// SugarCpp.g:329:22: ( WS )*
try { DebugEnterSubRule(146);
while (true)
{
int alt146=2;
try { DebugEnterDecision(146, false);
int LA146_0 = input.LA(1);
if ((LA146_0==WS))
{
alt146 = 1;
}
} finally { DebugExitDecision(146); }
switch ( alt146 )
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:329:22: WS
{
DebugLocation(329, 22);
WS222=(IToken)Match(input,WS,Follow._WS_in_type_template_type2142); if (state.failed) return retval;
if (state.backtracking == 0) stream_WS.Add(WS222);
}
break;
default:
goto loop146;
}
}
loop146:
;
} finally { DebugExitSubRule(146); }
DebugLocation(329, 26);
PushFollow(Follow._type_name_in_type_template_type2145);
type_name223=type_name();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_type_name.Add(type_name223.Tree);
DebugLocation(329, 36);
// SugarCpp.g:329:36: ( ( WS )* ',' ( WS )* type_name )*
try { DebugEnterSubRule(149);
while (true)
{
int alt149=2;
try { DebugEnterDecision(149, false);
try
{
alt149 = dfa149.Predict(input);
}
catch (NoViableAltException nvae)
{
DebugRecognitionException(nvae);
throw;
}
} finally { DebugExitDecision(149); }
switch ( alt149 )
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:329:37: ( WS )* ',' ( WS )* type_name
{
DebugLocation(329, 37);
// SugarCpp.g:329:37: ( WS )*
try { DebugEnterSubRule(147);
while (true)
{
int alt147=2;
try { DebugEnterDecision(147, false);
int LA147_0 = input.LA(1);
if ((LA147_0==WS))
{
alt147 = 1;
}
} finally { DebugExitDecision(147); }
switch ( alt147 )
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:329:37: WS
{
DebugLocation(329, 37);
WS224=(IToken)Match(input,WS,Follow._WS_in_type_template_type2148); if (state.failed) return retval;
if (state.backtracking == 0) stream_WS.Add(WS224);
}
break;
default:
goto loop147;
}
}
loop147:
;
} finally { DebugExitSubRule(147); }
DebugLocation(329, 41);
char_literal225=(IToken)Match(input,100,Follow._100_in_type_template_type2151); if (state.failed) return retval;
if (state.backtracking == 0) stream_100.Add(char_literal225);
DebugLocation(329, 45);
// SugarCpp.g:329:45: ( WS )*
try { DebugEnterSubRule(148);
while (true)
{
int alt148=2;
try { DebugEnterDecision(148, false);
int LA148_0 = input.LA(1);
if ((LA148_0==WS))
{
alt148 = 1;
}
} finally { DebugExitDecision(148); }
switch ( alt148 )
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:329:45: WS
{
DebugLocation(329, 45);
WS226=(IToken)Match(input,WS,Follow._WS_in_type_template_type2153); if (state.failed) return retval;
if (state.backtracking == 0) stream_WS.Add(WS226);
}
break;
default:
goto loop148;
}
}
loop148:
;
} finally { DebugExitSubRule(148); }
DebugLocation(329, 49);
PushFollow(Follow._type_name_in_type_template_type2156);
type_name227=type_name();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_type_name.Add(type_name227.Tree);
}
break;
default:
goto loop149;
}
}
loop149:
;
} finally { DebugExitSubRule(149); }
}
break;
}
} finally { DebugExitSubRule(150); }
DebugLocation(329, 63);
// SugarCpp.g:329:63: ( WS )*
try { DebugEnterSubRule(151);
while (true)
{
int alt151=2;
try { DebugEnterDecision(151, false);
int LA151_0 = input.LA(1);
if ((LA151_0==WS))
{
alt151 = 1;
}
} finally { DebugExitDecision(151); }
switch ( alt151 )
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:329:63: WS
{
DebugLocation(329, 63);
WS228=(IToken)Match(input,WS,Follow._WS_in_type_template_type2162); if (state.failed) return retval;
if (state.backtracking == 0) stream_WS.Add(WS228);
}
break;
default:
goto loop151;
}
}
loop151:
;
} finally { DebugExitSubRule(151); }
DebugLocation(329, 67);
char_literal229=(IToken)Match(input,125,Follow._125_in_type_template_type2165); if (state.failed) return retval;
if (state.backtracking == 0) stream_125.Add(char_literal229);
{
// AST REWRITE
// elements: type_ident, type_name
// 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();
// 329:71: -> ^( Type_Template type_ident ( type_name )* )
{
DebugLocation(329, 74);
// SugarCpp.g:329:74: ^( Type_Template type_ident ( type_name )* )
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(329, 76);
root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(Type_Template, "Type_Template"), root_1);
DebugLocation(329, 90);
adaptor.AddChild(root_1, stream_type_ident.NextTree());
DebugLocation(329, 101);
// SugarCpp.g:329:101: ( type_name )*
while ( stream_type_name.HasNext )
{
DebugLocation(329, 101);
adaptor.AddChild(root_1, stream_type_name.NextTree());
}
stream_type_name.Reset();
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;
}
}
}
break;
case 2:
DebugEnterAlt(2);
// SugarCpp.g:330:8:
{
{
// AST REWRITE
// elements: type_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();
// 330:8: -> type_ident
{
DebugLocation(330, 11);
adaptor.AddChild(root_0, stream_type_ident.NextTree());
}
retval.Tree = root_0;
}
}
}
break;
}
} finally { DebugExitSubRule(152); }
}
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("type_template_type", 21);
LeaveRule("type_template_type", 21);
LeaveRule_type_template_type();
}
DebugLocation(332, 1);
} finally { DebugExitRule(GrammarFileName, "type_template_type"); }
return retval;
}
// $ANTLR start "relationshipDeclaration"
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:113:1: relationshipDeclaration : 'relationship' name '=' relationshipJoinDeclaration ';' -> ^( RELATIONSHIP name relationshipJoinDeclaration ) ;
public relationshipDeclaration_return relationshipDeclaration() // throws RecognitionException [1]
{
var retval = new relationshipDeclaration_return();
retval.Start = input.LT( 1 );
CommonTree root_0 = null;
IToken string_literal25 = null;
IToken char_literal27 = null;
IToken char_literal29 = null;
name_return name26 = default( name_return );
relationshipJoinDeclaration_return relationshipJoinDeclaration28 = default( relationshipJoinDeclaration_return );
CommonTree string_literal25_tree = null;
CommonTree char_literal27_tree = null;
CommonTree char_literal29_tree = null;
var stream_67 = new RewriteRuleTokenStream( adaptor, "token 67" );
var stream_68 = new RewriteRuleTokenStream( adaptor, "token 68" );
var stream_63 = new RewriteRuleTokenStream( adaptor, "token 63" );
var stream_name = new RewriteRuleSubtreeStream( adaptor, "rule name" );
var stream_relationshipJoinDeclaration = new RewriteRuleSubtreeStream( adaptor, "rule relationshipJoinDeclaration" );
try
{
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:114:2: ( 'relationship' name '=' relationshipJoinDeclaration ';' -> ^( RELATIONSHIP name relationshipJoinDeclaration ) )
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:114:4: 'relationship' name '=' relationshipJoinDeclaration ';'
{
string_literal25 = (IToken)Match( input, 67, FOLLOW_67_in_relationshipDeclaration484 );
stream_67.Add( string_literal25 );
PushFollow( FOLLOW_name_in_relationshipDeclaration486 );
name26 = name();
state.followingStackPointer--;
stream_name.Add( name26.Tree );
char_literal27 = (IToken)Match( input, 68, FOLLOW_68_in_relationshipDeclaration488 );
stream_68.Add( char_literal27 );
PushFollow( FOLLOW_relationshipJoinDeclaration_in_relationshipDeclaration490 );
relationshipJoinDeclaration28 = relationshipJoinDeclaration();
state.followingStackPointer--;
stream_relationshipJoinDeclaration.Add( relationshipJoinDeclaration28.Tree );
char_literal29 = (IToken)Match( input, 63, FOLLOW_63_in_relationshipDeclaration492 );
stream_63.Add( char_literal29 );
// AST REWRITE
// elements: name, relationshipJoinDeclaration
// 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();
// 114:60: -> ^( RELATIONSHIP name relationshipJoinDeclaration )
{
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:114:63: ^( RELATIONSHIP name relationshipJoinDeclaration )
{
var root_1 = (CommonTree)adaptor.GetNilNode();
root_1 = (CommonTree)adaptor.BecomeRoot( adaptor.Create( RELATIONSHIP, "RELATIONSHIP" ), root_1 );
adaptor.AddChild( root_1, stream_name.NextTree() );
adaptor.AddChild( root_1, stream_relationshipJoinDeclaration.NextTree() );
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;
}
private AstParserRuleReturnScope<CommonTree, IToken> attribute_args_list()
{
EnterRule_attribute_args_list();
EnterRule("attribute_args_list", 5);
TraceIn("attribute_args_list", 5);
AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>();
retval.Start = (IToken)input.LT(1);
CommonTree root_0 = default(CommonTree);
IToken char_literal18 = default(IToken);
IToken WS19 = default(IToken);
IToken WS21 = default(IToken);
IToken char_literal22 = default(IToken);
IToken WS23 = default(IToken);
IToken WS25 = default(IToken);
IToken char_literal26 = default(IToken);
AstParserRuleReturnScope<CommonTree, IToken> attribute_args20 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> attribute_args24 = default(AstParserRuleReturnScope<CommonTree, IToken>);
CommonTree char_literal18_tree = default(CommonTree);
CommonTree WS19_tree = default(CommonTree);
CommonTree WS21_tree = default(CommonTree);
CommonTree char_literal22_tree = default(CommonTree);
CommonTree WS23_tree = default(CommonTree);
CommonTree WS25_tree = default(CommonTree);
CommonTree char_literal26_tree = default(CommonTree);
RewriteRuleITokenStream stream_94=new RewriteRuleITokenStream(adaptor,"token 94");
RewriteRuleITokenStream stream_WS=new RewriteRuleITokenStream(adaptor,"token WS");
RewriteRuleITokenStream stream_93=new RewriteRuleITokenStream(adaptor,"token 93");
RewriteRuleITokenStream stream_100=new RewriteRuleITokenStream(adaptor,"token 100");
RewriteRuleSubtreeStream stream_attribute_args=new RewriteRuleSubtreeStream(adaptor,"rule attribute_args");
try { DebugEnterRule(GrammarFileName, "attribute_args_list");
DebugLocation(239, 1);
try
{
// SugarCpp.g:240:2: ( '(' ( WS )* attribute_args ( ( WS )* ',' ( WS )* attribute_args )* ( WS )* ')' -> ( attribute_args )+ )
DebugEnterAlt(1);
// SugarCpp.g:240:4: '(' ( WS )* attribute_args ( ( WS )* ',' ( WS )* attribute_args )* ( WS )* ')'
{
DebugLocation(240, 4);
char_literal18=(IToken)Match(input,93,Follow._93_in_attribute_args_list692); if (state.failed) return retval;
if (state.backtracking == 0) stream_93.Add(char_literal18);
DebugLocation(240, 8);
// SugarCpp.g:240:8: ( WS )*
try { DebugEnterSubRule(7);
while (true)
{
int alt7=2;
try { DebugEnterDecision(7, false);
int LA7_0 = input.LA(1);
if ((LA7_0==WS))
{
alt7 = 1;
}
} finally { DebugExitDecision(7); }
switch ( alt7 )
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:240:8: WS
{
DebugLocation(240, 8);
WS19=(IToken)Match(input,WS,Follow._WS_in_attribute_args_list694); if (state.failed) return retval;
if (state.backtracking == 0) stream_WS.Add(WS19);
}
break;
default:
goto loop7;
}
}
loop7:
;
} finally { DebugExitSubRule(7); }
DebugLocation(240, 12);
PushFollow(Follow._attribute_args_in_attribute_args_list697);
attribute_args20=attribute_args();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_attribute_args.Add(attribute_args20.Tree);
DebugLocation(240, 27);
// SugarCpp.g:240:27: ( ( WS )* ',' ( WS )* attribute_args )*
try { DebugEnterSubRule(10);
while (true)
{
int alt10=2;
try { DebugEnterDecision(10, false);
try
{
alt10 = dfa10.Predict(input);
}
catch (NoViableAltException nvae)
{
DebugRecognitionException(nvae);
throw;
}
} finally { DebugExitDecision(10); }
switch ( alt10 )
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:240:28: ( WS )* ',' ( WS )* attribute_args
{
DebugLocation(240, 28);
// SugarCpp.g:240:28: ( WS )*
try { DebugEnterSubRule(8);
while (true)
{
int alt8=2;
try { DebugEnterDecision(8, false);
int LA8_0 = input.LA(1);
if ((LA8_0==WS))
{
alt8 = 1;
}
} finally { DebugExitDecision(8); }
switch ( alt8 )
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:240:28: WS
{
DebugLocation(240, 28);
WS21=(IToken)Match(input,WS,Follow._WS_in_attribute_args_list700); if (state.failed) return retval;
if (state.backtracking == 0) stream_WS.Add(WS21);
}
break;
default:
goto loop8;
}
}
loop8:
;
} finally { DebugExitSubRule(8); }
DebugLocation(240, 32);
char_literal22=(IToken)Match(input,100,Follow._100_in_attribute_args_list703); if (state.failed) return retval;
if (state.backtracking == 0) stream_100.Add(char_literal22);
DebugLocation(240, 36);
// SugarCpp.g:240:36: ( WS )*
try { DebugEnterSubRule(9);
while (true)
{
int alt9=2;
try { DebugEnterDecision(9, false);
int LA9_0 = input.LA(1);
if ((LA9_0==WS))
{
alt9 = 1;
}
} finally { DebugExitDecision(9); }
switch ( alt9 )
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:240:36: WS
{
DebugLocation(240, 36);
WS23=(IToken)Match(input,WS,Follow._WS_in_attribute_args_list705); if (state.failed) return retval;
if (state.backtracking == 0) stream_WS.Add(WS23);
}
break;
default:
goto loop9;
}
}
loop9:
;
} finally { DebugExitSubRule(9); }
DebugLocation(240, 40);
PushFollow(Follow._attribute_args_in_attribute_args_list708);
attribute_args24=attribute_args();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_attribute_args.Add(attribute_args24.Tree);
}
break;
default:
goto loop10;
}
}
loop10:
;
} finally { DebugExitSubRule(10); }
DebugLocation(240, 57);
// SugarCpp.g:240:57: ( WS )*
try { DebugEnterSubRule(11);
while (true)
{
int alt11=2;
try { DebugEnterDecision(11, false);
int LA11_0 = input.LA(1);
if ((LA11_0==WS))
{
alt11 = 1;
}
} finally { DebugExitDecision(11); }
switch ( alt11 )
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:240:57: WS
{
DebugLocation(240, 57);
WS25=(IToken)Match(input,WS,Follow._WS_in_attribute_args_list712); if (state.failed) return retval;
if (state.backtracking == 0) stream_WS.Add(WS25);
}
break;
default:
goto loop11;
}
}
loop11:
;
} finally { DebugExitSubRule(11); }
DebugLocation(240, 61);
char_literal26=(IToken)Match(input,94,Follow._94_in_attribute_args_list715); if (state.failed) return retval;
if (state.backtracking == 0) stream_94.Add(char_literal26);
{
// AST REWRITE
// elements: attribute_args
// 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();
// 240:65: -> ( attribute_args )+
{
DebugLocation(240, 68);
if (!(stream_attribute_args.HasNext))
{
throw new RewriteEarlyExitException();
}
while ( stream_attribute_args.HasNext )
{
DebugLocation(240, 68);
adaptor.AddChild(root_0, stream_attribute_args.NextTree());
}
stream_attribute_args.Reset();
}
retval.Tree = root_0;
}
}
}
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("attribute_args_list", 5);
LeaveRule("attribute_args_list", 5);
LeaveRule_attribute_args_list();
}
DebugLocation(241, 1);
} finally { DebugExitRule(GrammarFileName, "attribute_args_list"); }
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;
}
public AstParserRuleReturnScope<object, IToken> parse()
{
EnterRule_parse();
EnterRule("parse", 1);
TraceIn("parse", 1);
AstParserRuleReturnScope<object, IToken> retval = new AstParserRuleReturnScope<object, IToken>();
retval.Start = (IToken)input.LT(1);
object root_0 = default(object);
IToken EOF2 = default(IToken);
AstParserRuleReturnScope<object, IToken> arglist_expr1 = default(AstParserRuleReturnScope<object, IToken>);
object EOF2_tree = default(object);
RewriteRuleITokenStream stream_EOF=new RewriteRuleITokenStream(adaptor,"token EOF");
RewriteRuleSubtreeStream stream_arglist_expr=new RewriteRuleSubtreeStream(adaptor,"rule arglist_expr");
try { DebugEnterRule(GrammarFileName, "parse");
DebugLocation(77, 1);
try
{
// Queries\\PomonaQuery.g:78:2: ( arglist_expr EOF -> ^( ROOT arglist_expr ) )
DebugEnterAlt(1);
// Queries\\PomonaQuery.g:78:4: arglist_expr EOF
{
DebugLocation(78, 4);
PushFollow(Follow._arglist_expr_in_parse498);
arglist_expr1=arglist_expr();
PopFollow();
stream_arglist_expr.Add(arglist_expr1.Tree);
DebugLocation(78, 17);
EOF2=(IToken)Match(input,EOF,Follow._EOF_in_parse500);
stream_EOF.Add(EOF2);
{
// AST REWRITE
// elements: arglist_expr
// 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();
// 78:21: -> ^( ROOT arglist_expr )
{
DebugLocation(78, 24);
// Queries\\PomonaQuery.g:78:24: ^( ROOT arglist_expr )
{
object root_1 = (object)adaptor.Nil();
DebugLocation(78, 26);
root_1 = (object)adaptor.BecomeRoot((object)adaptor.Create(ROOT, "ROOT"), root_1);
DebugLocation(78, 31);
adaptor.AddChild(root_1, stream_arglist_expr.NextTree());
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;
}
}
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("parse", 1);
LeaveRule("parse", 1);
LeaveRule_parse();
}
DebugLocation(79, 1);
} finally { DebugExitRule(GrammarFileName, "parse"); }
return retval;
}
// $ANTLR start "criteria"
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:248:1: criteria : '[' expression ']' -> ^( CRITERIA expression ) ;
public criteria_return criteria() // throws RecognitionException [1]
{
var retval = new criteria_return();
retval.Start = input.LT( 1 );
CommonTree root_0 = null;
IToken char_literal84 = null;
IToken char_literal86 = null;
expression_return expression85 = default( expression_return );
CommonTree char_literal84_tree = null;
CommonTree char_literal86_tree = null;
var stream_93 = new RewriteRuleTokenStream( adaptor, "token 93" );
var stream_92 = new RewriteRuleTokenStream( adaptor, "token 92" );
var stream_expression = new RewriteRuleSubtreeStream( adaptor, "rule expression" );
try
{
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:249:2: ( '[' expression ']' -> ^( CRITERIA expression ) )
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:249:4: '[' expression ']'
{
char_literal84 = (IToken)Match( input, 92, FOLLOW_92_in_criteria1320 );
stream_92.Add( char_literal84 );
PushFollow( FOLLOW_expression_in_criteria1322 );
expression85 = expression();
state.followingStackPointer--;
stream_expression.Add( expression85.Tree );
char_literal86 = (IToken)Match( input, 93, FOLLOW_93_in_criteria1324 );
stream_93.Add( char_literal86 );
// AST REWRITE
// elements: 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();
// 249:23: -> ^( CRITERIA expression )
{
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:249:26: ^( CRITERIA expression )
{
var root_1 = (CommonTree)adaptor.GetNilNode();
root_1 = (CommonTree)adaptor.BecomeRoot( adaptor.Create( CRITERIA, "CRITERIA" ), root_1 );
adaptor.AddChild( root_1, stream_expression.NextTree() );
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;
}
private AstParserRuleReturnScope<object, IToken> postfix_expr()
{
EnterRule_postfix_expr();
EnterRule("postfix_expr", 18);
TraceIn("postfix_expr", 18);
AstParserRuleReturnScope<object, IToken> retval = new AstParserRuleReturnScope<object, IToken>();
retval.Start = (IToken)input.LT(1);
object root_0 = default(object);
IToken ID59 = default(IToken);
IToken char_literal60 = default(IToken);
IToken char_literal62 = default(IToken);
IToken ID63 = default(IToken);
IToken char_literal64 = default(IToken);
IToken char_literal65 = default(IToken);
IToken ID66 = default(IToken);
IToken char_literal67 = default(IToken);
IToken char_literal69 = default(IToken);
IToken ID70 = default(IToken);
IToken char_literal71 = default(IToken);
IToken char_literal72 = default(IToken);
IToken ID73 = default(IToken);
IToken STRING74 = default(IToken);
IToken INT75 = default(IToken);
IToken char_literal76 = default(IToken);
IToken char_literal78 = default(IToken);
IToken char_literal79 = default(IToken);
IToken char_literal81 = default(IToken);
IToken PREFIXED_STRING82 = default(IToken);
AstParserRuleReturnScope<object, IToken> arglist_expr61 = default(AstParserRuleReturnScope<object, IToken>);
AstParserRuleReturnScope<object, IToken> arglist_expr68 = default(AstParserRuleReturnScope<object, IToken>);
AstParserRuleReturnScope<object, IToken> orderby_expr77 = default(AstParserRuleReturnScope<object, IToken>);
AstParserRuleReturnScope<object, IToken> arglist_expr80 = default(AstParserRuleReturnScope<object, IToken>);
object ID59_tree = default(object);
object char_literal60_tree = default(object);
object char_literal62_tree = default(object);
object ID63_tree = default(object);
object char_literal64_tree = default(object);
object char_literal65_tree = default(object);
object ID66_tree = default(object);
object char_literal67_tree = default(object);
object char_literal69_tree = default(object);
object ID70_tree = default(object);
object char_literal71_tree = default(object);
object char_literal72_tree = default(object);
object ID73_tree = default(object);
object STRING74_tree = default(object);
object INT75_tree = default(object);
object char_literal76_tree = default(object);
object char_literal78_tree = default(object);
object char_literal79_tree = default(object);
object char_literal81_tree = default(object);
object PREFIXED_STRING82_tree = default(object);
RewriteRuleITokenStream stream_ID=new RewriteRuleITokenStream(adaptor,"token ID");
RewriteRuleITokenStream stream_43=new RewriteRuleITokenStream(adaptor,"token 43");
RewriteRuleITokenStream stream_44=new RewriteRuleITokenStream(adaptor,"token 44");
RewriteRuleITokenStream stream_57=new RewriteRuleITokenStream(adaptor,"token 57");
RewriteRuleITokenStream stream_58=new RewriteRuleITokenStream(adaptor,"token 58");
RewriteRuleSubtreeStream stream_arglist_expr=new RewriteRuleSubtreeStream(adaptor,"rule arglist_expr");
try { DebugEnterRule(GrammarFileName, "postfix_expr");
DebugLocation(166, 1);
try
{
// Queries\\PomonaQuery.g:167:2: ( ID ( '(' arglist_expr ')' ) -> ^( METHOD_CALL ID arglist_expr ) | ID ( '(' ')' ) -> ^( METHOD_CALL ID ) | ID ( '[' arglist_expr ']' ) -> ^( INDEXER_ACCESS ID arglist_expr ) | ID ( '[' ']' ) -> ^( INDEXER_ACCESS ID ) | ID | STRING | INT | '(' ! orderby_expr ')' !| '[' arglist_expr ']' -> ^( ARRAY_LITERAL arglist_expr ) | PREFIXED_STRING )
int alt26=10;
try { DebugEnterDecision(26, false);
switch (input.LA(1))
{
case ID:
{
switch (input.LA(2))
{
case 43:
{
int LA26_3 = input.LA(3);
if ((LA26_3==44))
{
alt26 = 2;
}
else if ((LA26_3==ID||LA26_3==INT||LA26_3==PREFIXED_STRING||LA26_3==STRING||LA26_3==39||LA26_3==43||LA26_3==57||LA26_3==74))
{
alt26 = 1;
}
else
{
NoViableAltException nvae = new NoViableAltException("", 26, 7, input, 3);
DebugRecognitionException(nvae);
throw nvae;
}
}
break;
case 57:
{
int LA26_3 = input.LA(3);
if ((LA26_3==58))
{
alt26 = 4;
}
else if ((LA26_3==ID||LA26_3==INT||LA26_3==PREFIXED_STRING||LA26_3==STRING||LA26_3==39||LA26_3==43||LA26_3==57||LA26_3==74))
{
alt26 = 3;
}
else
{
NoViableAltException nvae = new NoViableAltException("", 26, 8, input, 3);
DebugRecognitionException(nvae);
throw nvae;
}
}
break;
case EOF:
case 40:
case 41:
case 42:
case 44:
case 45:
case 46:
case 47:
case 48:
case 49:
case 50:
case 51:
case 52:
case 53:
case 54:
case 55:
case 56:
case 58:
case 59:
case 60:
case 61:
case 62:
case 63:
case 64:
case 65:
case 66:
case 67:
case 68:
case 69:
case 70:
case 71:
case 72:
case 73:
case 75:
case 76:
case 77:
{
alt26 = 5;
}
break;
default:
{
NoViableAltException nvae = new NoViableAltException("", 26, 1, input, 2);
DebugRecognitionException(nvae);
throw nvae;
}
}
}
break;
case STRING:
{
alt26 = 6;
}
break;
case INT:
{
alt26 = 7;
}
break;
case 43:
{
alt26 = 8;
}
break;
case 57:
{
alt26 = 9;
}
break;
case PREFIXED_STRING:
{
alt26 = 10;
}
break;
default:
{
NoViableAltException nvae = new NoViableAltException("", 26, 0, input, 1);
DebugRecognitionException(nvae);
throw nvae;
}
}
} finally { DebugExitDecision(26); }
switch (alt26)
{
case 1:
DebugEnterAlt(1);
// Queries\\PomonaQuery.g:167:4: ID ( '(' arglist_expr ')' )
{
DebugLocation(167, 4);
ID59=(IToken)Match(input,ID,Follow._ID_in_postfix_expr1005);
stream_ID.Add(ID59);
DebugLocation(167, 7);
// Queries\\PomonaQuery.g:167:7: ( '(' arglist_expr ')' )
DebugEnterAlt(1);
// Queries\\PomonaQuery.g:167:9: '(' arglist_expr ')'
{
DebugLocation(167, 9);
char_literal60=(IToken)Match(input,43,Follow._43_in_postfix_expr1009);
stream_43.Add(char_literal60);
DebugLocation(167, 13);
PushFollow(Follow._arglist_expr_in_postfix_expr1011);
arglist_expr61=arglist_expr();
PopFollow();
stream_arglist_expr.Add(arglist_expr61.Tree);
DebugLocation(167, 26);
char_literal62=(IToken)Match(input,44,Follow._44_in_postfix_expr1013);
stream_44.Add(char_literal62);
}
{
// AST REWRITE
// elements: ID, arglist_expr
// 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();
// 167:32: -> ^( METHOD_CALL ID arglist_expr )
{
DebugLocation(167, 35);
// Queries\\PomonaQuery.g:167:35: ^( METHOD_CALL ID arglist_expr )
{
object root_1 = (object)adaptor.Nil();
DebugLocation(167, 37);
root_1 = (object)adaptor.BecomeRoot((object)adaptor.Create(METHOD_CALL, "METHOD_CALL"), root_1);
DebugLocation(167, 49);
adaptor.AddChild(root_1, stream_ID.NextNode());
DebugLocation(167, 52);
adaptor.AddChild(root_1, stream_arglist_expr.NextTree());
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;
}
}
break;
case 2:
DebugEnterAlt(2);
// Queries\\PomonaQuery.g:168:4: ID ( '(' ')' )
{
DebugLocation(168, 4);
ID63=(IToken)Match(input,ID,Follow._ID_in_postfix_expr1030);
stream_ID.Add(ID63);
DebugLocation(168, 7);
// Queries\\PomonaQuery.g:168:7: ( '(' ')' )
DebugEnterAlt(1);
// Queries\\PomonaQuery.g:168:9: '(' ')'
{
DebugLocation(168, 9);
char_literal64=(IToken)Match(input,43,Follow._43_in_postfix_expr1034);
stream_43.Add(char_literal64);
DebugLocation(168, 13);
char_literal65=(IToken)Match(input,44,Follow._44_in_postfix_expr1036);
stream_44.Add(char_literal65);
}
{
// AST REWRITE
// elements: ID
// 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();
// 168:19: -> ^( METHOD_CALL ID )
{
DebugLocation(168, 22);
// Queries\\PomonaQuery.g:168:22: ^( METHOD_CALL ID )
{
object root_1 = (object)adaptor.Nil();
DebugLocation(168, 24);
root_1 = (object)adaptor.BecomeRoot((object)adaptor.Create(METHOD_CALL, "METHOD_CALL"), root_1);
DebugLocation(168, 36);
adaptor.AddChild(root_1, stream_ID.NextNode());
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;
}
}
break;
case 3:
DebugEnterAlt(3);
// Queries\\PomonaQuery.g:169:4: ID ( '[' arglist_expr ']' )
{
DebugLocation(169, 4);
ID66=(IToken)Match(input,ID,Follow._ID_in_postfix_expr1051);
stream_ID.Add(ID66);
DebugLocation(169, 7);
// Queries\\PomonaQuery.g:169:7: ( '[' arglist_expr ']' )
DebugEnterAlt(1);
// Queries\\PomonaQuery.g:169:9: '[' arglist_expr ']'
{
DebugLocation(169, 9);
char_literal67=(IToken)Match(input,57,Follow._57_in_postfix_expr1055);
stream_57.Add(char_literal67);
DebugLocation(169, 13);
PushFollow(Follow._arglist_expr_in_postfix_expr1057);
arglist_expr68=arglist_expr();
PopFollow();
stream_arglist_expr.Add(arglist_expr68.Tree);
DebugLocation(169, 26);
char_literal69=(IToken)Match(input,58,Follow._58_in_postfix_expr1059);
stream_58.Add(char_literal69);
}
{
// AST REWRITE
// elements: ID, arglist_expr
// 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();
// 169:32: -> ^( INDEXER_ACCESS ID arglist_expr )
{
DebugLocation(169, 35);
// Queries\\PomonaQuery.g:169:35: ^( INDEXER_ACCESS ID arglist_expr )
{
object root_1 = (object)adaptor.Nil();
DebugLocation(169, 37);
root_1 = (object)adaptor.BecomeRoot((object)adaptor.Create(INDEXER_ACCESS, "INDEXER_ACCESS"), root_1);
DebugLocation(169, 52);
adaptor.AddChild(root_1, stream_ID.NextNode());
DebugLocation(169, 55);
adaptor.AddChild(root_1, stream_arglist_expr.NextTree());
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;
}
}
break;
case 4:
DebugEnterAlt(4);
// Queries\\PomonaQuery.g:170:4: ID ( '[' ']' )
{
DebugLocation(170, 4);
ID70=(IToken)Match(input,ID,Follow._ID_in_postfix_expr1076);
stream_ID.Add(ID70);
DebugLocation(170, 7);
// Queries\\PomonaQuery.g:170:7: ( '[' ']' )
DebugEnterAlt(1);
// Queries\\PomonaQuery.g:170:9: '[' ']'
{
DebugLocation(170, 9);
char_literal71=(IToken)Match(input,57,Follow._57_in_postfix_expr1080);
stream_57.Add(char_literal71);
DebugLocation(170, 13);
char_literal72=(IToken)Match(input,58,Follow._58_in_postfix_expr1082);
stream_58.Add(char_literal72);
}
{
// AST REWRITE
// elements: ID
// 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();
// 170:19: -> ^( INDEXER_ACCESS ID )
{
DebugLocation(170, 22);
// Queries\\PomonaQuery.g:170:22: ^( INDEXER_ACCESS ID )
{
object root_1 = (object)adaptor.Nil();
DebugLocation(170, 24);
root_1 = (object)adaptor.BecomeRoot((object)adaptor.Create(INDEXER_ACCESS, "INDEXER_ACCESS"), root_1);
DebugLocation(170, 39);
adaptor.AddChild(root_1, stream_ID.NextNode());
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;
}
}
break;
case 5:
DebugEnterAlt(5);
// Queries\\PomonaQuery.g:171:4: ID
{
root_0 = (object)adaptor.Nil();
DebugLocation(171, 4);
ID73=(IToken)Match(input,ID,Follow._ID_in_postfix_expr1097);
ID73_tree = (object)adaptor.Create(ID73);
adaptor.AddChild(root_0, ID73_tree);
}
break;
case 6:
DebugEnterAlt(6);
// Queries\\PomonaQuery.g:172:4: STRING
{
root_0 = (object)adaptor.Nil();
DebugLocation(172, 4);
STRING74=(IToken)Match(input,STRING,Follow._STRING_in_postfix_expr1102);
STRING74_tree = (object)adaptor.Create(STRING74);
adaptor.AddChild(root_0, STRING74_tree);
}
break;
case 7:
DebugEnterAlt(7);
// Queries\\PomonaQuery.g:173:4: INT
{
root_0 = (object)adaptor.Nil();
DebugLocation(173, 4);
INT75=(IToken)Match(input,INT,Follow._INT_in_postfix_expr1107);
INT75_tree = (object)adaptor.Create(INT75);
adaptor.AddChild(root_0, INT75_tree);
}
break;
case 8:
DebugEnterAlt(8);
// Queries\\PomonaQuery.g:174:4: '(' ! orderby_expr ')' !
{
root_0 = (object)adaptor.Nil();
DebugLocation(174, 7);
char_literal76=(IToken)Match(input,43,Follow._43_in_postfix_expr1112);
DebugLocation(174, 9);
PushFollow(Follow._orderby_expr_in_postfix_expr1115);
orderby_expr77=orderby_expr();
PopFollow();
adaptor.AddChild(root_0, orderby_expr77.Tree);
DebugLocation(174, 25);
char_literal78=(IToken)Match(input,44,Follow._44_in_postfix_expr1117);
}
break;
case 9:
DebugEnterAlt(9);
// Queries\\PomonaQuery.g:175:4: '[' arglist_expr ']'
{
DebugLocation(175, 4);
char_literal79=(IToken)Match(input,57,Follow._57_in_postfix_expr1123);
stream_57.Add(char_literal79);
DebugLocation(175, 8);
PushFollow(Follow._arglist_expr_in_postfix_expr1125);
arglist_expr80=arglist_expr();
PopFollow();
stream_arglist_expr.Add(arglist_expr80.Tree);
DebugLocation(175, 21);
char_literal81=(IToken)Match(input,58,Follow._58_in_postfix_expr1127);
stream_58.Add(char_literal81);
{
// AST REWRITE
// elements: arglist_expr
// 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();
// 175:25: -> ^( ARRAY_LITERAL arglist_expr )
{
DebugLocation(175, 28);
// Queries\\PomonaQuery.g:175:28: ^( ARRAY_LITERAL arglist_expr )
{
object root_1 = (object)adaptor.Nil();
DebugLocation(175, 30);
root_1 = (object)adaptor.BecomeRoot((object)adaptor.Create(ARRAY_LITERAL, "ARRAY_LITERAL"), root_1);
DebugLocation(175, 44);
adaptor.AddChild(root_1, stream_arglist_expr.NextTree());
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;
}
}
break;
case 10:
DebugEnterAlt(10);
// Queries\\PomonaQuery.g:176:4: PREFIXED_STRING
{
root_0 = (object)adaptor.Nil();
DebugLocation(176, 4);
PREFIXED_STRING82=(IToken)Match(input,PREFIXED_STRING,Follow._PREFIXED_STRING_in_postfix_expr1140);
PREFIXED_STRING82_tree = (object)adaptor.Create(PREFIXED_STRING82);
adaptor.AddChild(root_0, PREFIXED_STRING82_tree);
}
break;
}
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("postfix_expr", 18);
LeaveRule("postfix_expr", 18);
LeaveRule_postfix_expr();
}
DebugLocation(177, 1);
} finally { DebugExitRule(GrammarFileName, "postfix_expr"); }
return retval;
}
// $ANTLR start "baseClassDeclaration"
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:82:1: baseClassDeclaration : ':' name 'where' expression -> ^( BASE_CLASS name ^( DISCRIMINATOR expression ) ) ;
public baseClassDeclaration_return baseClassDeclaration() // throws RecognitionException [1]
{
var retval = new baseClassDeclaration_return();
retval.Start = input.LT( 1 );
CommonTree root_0 = null;
IToken char_literal8 = null;
IToken string_literal10 = null;
name_return name9 = default( name_return );
expression_return expression11 = default( expression_return );
CommonTree char_literal8_tree = null;
CommonTree string_literal10_tree = null;
var stream_59 = new RewriteRuleTokenStream( adaptor, "token 59" );
var stream_58 = new RewriteRuleTokenStream( adaptor, "token 58" );
var stream_expression = new RewriteRuleSubtreeStream( adaptor, "rule expression" );
var stream_name = new RewriteRuleSubtreeStream( adaptor, "rule name" );
try
{
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:83:2: ( ':' name 'where' expression -> ^( BASE_CLASS name ^( DISCRIMINATOR expression ) ) )
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:83:4: ':' name 'where' expression
{
char_literal8 = (IToken)Match( input, 58, FOLLOW_58_in_baseClassDeclaration294 );
stream_58.Add( char_literal8 );
PushFollow( FOLLOW_name_in_baseClassDeclaration296 );
name9 = name();
state.followingStackPointer--;
stream_name.Add( name9.Tree );
string_literal10 = (IToken)Match( input, 59, FOLLOW_59_in_baseClassDeclaration298 );
stream_59.Add( string_literal10 );
PushFollow( FOLLOW_expression_in_baseClassDeclaration300 );
expression11 = expression();
state.followingStackPointer--;
stream_expression.Add( expression11.Tree );
// AST REWRITE
// elements: name, 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();
// 83:32: -> ^( BASE_CLASS name ^( DISCRIMINATOR expression ) )
{
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:83:35: ^( BASE_CLASS name ^( DISCRIMINATOR expression ) )
{
var root_1 = (CommonTree)adaptor.GetNilNode();
root_1 = (CommonTree)adaptor.BecomeRoot( adaptor.Create( BASE_CLASS, "BASE_CLASS" ), root_1 );
adaptor.AddChild( root_1, stream_name.NextTree() );
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:83:54: ^( DISCRIMINATOR expression )
{
var root_2 = (CommonTree)adaptor.GetNilNode();
root_2 = (CommonTree)adaptor.BecomeRoot( adaptor.Create( DISCRIMINATOR, "DISCRIMINATOR" ), root_2 );
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;
}
private AstParserRuleReturnScope<object, IToken> as_expression()
{
EnterRule_as_expression();
EnterRule("as_expression", 3);
TraceIn("as_expression", 3);
AstParserRuleReturnScope<object, IToken> retval = new AstParserRuleReturnScope<object, IToken>();
retval.Start = (IToken)input.LT(1);
object root_0 = default(object);
IToken string_literal5 = default(IToken);
AstParserRuleReturnScope<object, IToken> lambda_expression4 = default(AstParserRuleReturnScope<object, IToken>);
AstParserRuleReturnScope<object, IToken> lambda_expression6 = default(AstParserRuleReturnScope<object, IToken>);
object string_literal5_tree = default(object);
RewriteRuleITokenStream stream_61=new RewriteRuleITokenStream(adaptor,"token 61");
RewriteRuleSubtreeStream stream_lambda_expression=new RewriteRuleSubtreeStream(adaptor,"rule lambda_expression");
try { DebugEnterRule(GrammarFileName, "as_expression");
DebugLocation(85, 1);
try
{
// Queries\\PomonaQuery.g:86:2: ( lambda_expression ( 'as' lambda_expression )? -> ^( AS_OP ( lambda_expression )+ ) )
DebugEnterAlt(1);
// Queries\\PomonaQuery.g:86:4: lambda_expression ( 'as' lambda_expression )?
{
DebugLocation(86, 4);
PushFollow(Follow._lambda_expression_in_as_expression530);
lambda_expression4=lambda_expression();
PopFollow();
stream_lambda_expression.Add(lambda_expression4.Tree);
DebugLocation(86, 22);
// Queries\\PomonaQuery.g:86:22: ( 'as' lambda_expression )?
int alt1=2;
try { DebugEnterSubRule(1);
try { DebugEnterDecision(1, false);
int LA1_1 = input.LA(1);
if ((LA1_1==61))
{
alt1 = 1;
}
} finally { DebugExitDecision(1); }
switch (alt1)
{
case 1:
DebugEnterAlt(1);
// Queries\\PomonaQuery.g:86:24: 'as' lambda_expression
{
DebugLocation(86, 24);
string_literal5=(IToken)Match(input,61,Follow._61_in_as_expression534);
stream_61.Add(string_literal5);
DebugLocation(86, 29);
PushFollow(Follow._lambda_expression_in_as_expression536);
lambda_expression6=lambda_expression();
PopFollow();
stream_lambda_expression.Add(lambda_expression6.Tree);
}
break;
}
} finally { DebugExitSubRule(1); }
{
// AST REWRITE
// elements: lambda_expression
// 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();
// 86:50: -> ^( AS_OP ( lambda_expression )+ )
{
DebugLocation(86, 53);
// Queries\\PomonaQuery.g:86:53: ^( AS_OP ( lambda_expression )+ )
{
object root_1 = (object)adaptor.Nil();
DebugLocation(86, 55);
root_1 = (object)adaptor.BecomeRoot((object)adaptor.Create(AS_OP, "AS_OP"), root_1);
DebugLocation(86, 61);
if (!(stream_lambda_expression.HasNext))
{
throw new RewriteEarlyExitException();
}
while ( stream_lambda_expression.HasNext )
{
DebugLocation(86, 61);
adaptor.AddChild(root_1, stream_lambda_expression.NextTree());
}
stream_lambda_expression.Reset();
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;
}
}
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("as_expression", 3);
LeaveRule("as_expression", 3);
LeaveRule_as_expression();
}
DebugLocation(87, 1);
} finally { DebugExitRule(GrammarFileName, "as_expression"); }
return retval;
}
// $ANTLR start "propertyDeclaration"
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:97:1: propertyDeclaration : 'property' name ( propertyModifiers )? ';' -> ^( PROPERTY name ( propertyModifiers )? ) ;
public propertyDeclaration_return propertyDeclaration() // throws RecognitionException [1]
{
var retval = new propertyDeclaration_return();
retval.Start = input.LT( 1 );
CommonTree root_0 = null;
IToken string_literal17 = null;
IToken char_literal20 = null;
name_return name18 = default( name_return );
propertyModifiers_return propertyModifiers19 = default( propertyModifiers_return );
CommonTree string_literal17_tree = null;
CommonTree char_literal20_tree = null;
var stream_62 = new RewriteRuleTokenStream( adaptor, "token 62" );
var stream_63 = new RewriteRuleTokenStream( adaptor, "token 63" );
var stream_propertyModifiers = new RewriteRuleSubtreeStream( adaptor, "rule propertyModifiers" );
var stream_name = new RewriteRuleSubtreeStream( adaptor, "rule name" );
try
{
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:98:2: ( 'property' name ( propertyModifiers )? ';' -> ^( PROPERTY name ( propertyModifiers )? ) )
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:98:4: 'property' name ( propertyModifiers )? ';'
{
string_literal17 = (IToken)Match( input, 62, FOLLOW_62_in_propertyDeclaration389 );
stream_62.Add( string_literal17 );
PushFollow( FOLLOW_name_in_propertyDeclaration391 );
name18 = name();
state.followingStackPointer--;
stream_name.Add( name18.Tree );
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:98:20: ( propertyModifiers )?
int alt6 = 2;
int LA6_0 = input.LA( 1 );
if ( ( ( LA6_0 >= 64 && LA6_0 <= 66 ) ) )
alt6 = 1;
switch ( alt6 )
{
case 1:
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:98:20: propertyModifiers
{
PushFollow( FOLLOW_propertyModifiers_in_propertyDeclaration393 );
propertyModifiers19 = propertyModifiers();
state.followingStackPointer--;
stream_propertyModifiers.Add( propertyModifiers19.Tree );
}
break;
}
char_literal20 = (IToken)Match( input, 63, FOLLOW_63_in_propertyDeclaration396 );
stream_63.Add( char_literal20 );
// AST REWRITE
// elements: name, propertyModifiers
// 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();
// 98:43: -> ^( PROPERTY name ( propertyModifiers )? )
{
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:98:46: ^( PROPERTY name ( propertyModifiers )? )
{
var root_1 = (CommonTree)adaptor.GetNilNode();
root_1 = (CommonTree)adaptor.BecomeRoot( adaptor.Create( PROPERTY, "PROPERTY" ), root_1 );
adaptor.AddChild( root_1, stream_name.NextTree() );
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:98:63: ( propertyModifiers )?
if ( stream_propertyModifiers.HasNext() )
adaptor.AddChild( root_1, stream_propertyModifiers.NextTree() );
stream_propertyModifiers.Reset();
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;
}
private AstParserRuleReturnScope<CommonTree, IToken> lvalue_atom()
{
EnterRule_lvalue_atom();
EnterRule("lvalue_atom", 100);
TraceIn("lvalue_atom", 100);
AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>();
retval.Start = (IToken)input.LT(1);
CommonTree root_0 = default(CommonTree);
IToken char_literal955 = default(IToken);
IToken WS956 = default(IToken);
AstParserRuleReturnScope<CommonTree, IToken> ident954 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> ident957 = default(AstParserRuleReturnScope<CommonTree, IToken>);
CommonTree char_literal955_tree = default(CommonTree);
CommonTree WS956_tree = default(CommonTree);
RewriteRuleITokenStream stream_WS=new RewriteRuleITokenStream(adaptor,"token WS");
RewriteRuleITokenStream stream_131=new RewriteRuleITokenStream(adaptor,"token 131");
RewriteRuleSubtreeStream stream_ident=new RewriteRuleSubtreeStream(adaptor,"rule ident");
try { DebugEnterRule(GrammarFileName, "lvalue_atom");
DebugLocation(754, 1);
try
{
// SugarCpp.g:755:2: ( ident | '@' ( WS )* ident -> ^( '@' ident ) )
int alt618=2;
try { DebugEnterDecision(618, false);
int LA618_0 = input.LA(1);
if ((LA618_0==IDENT))
{
alt618 = 1;
}
else if ((LA618_0==131))
{
alt618 = 2;
}
else
{
if (state.backtracking>0) {state.failed=true; return retval;}
NoViableAltException nvae = new NoViableAltException("", 618, 0, input);
DebugRecognitionException(nvae);
throw nvae;
}
} finally { DebugExitDecision(618); }
switch (alt618)
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:755:4: ident
{
root_0 = (CommonTree)adaptor.Nil();
DebugLocation(755, 4);
PushFollow(Follow._ident_in_lvalue_atom9152);
ident954=ident();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) adaptor.AddChild(root_0, ident954.Tree);
}
break;
case 2:
DebugEnterAlt(2);
// SugarCpp.g:756:4: '@' ( WS )* ident
{
DebugLocation(756, 4);
char_literal955=(IToken)Match(input,131,Follow._131_in_lvalue_atom9157); if (state.failed) return retval;
if (state.backtracking == 0) stream_131.Add(char_literal955);
DebugLocation(756, 8);
// SugarCpp.g:756:8: ( WS )*
try { DebugEnterSubRule(617);
while (true)
{
int alt617=2;
try { DebugEnterDecision(617, false);
int LA617_0 = input.LA(1);
if ((LA617_0==WS))
{
alt617 = 1;
}
} finally { DebugExitDecision(617); }
switch ( alt617 )
{
case 1:
DebugEnterAlt(1);
// SugarCpp.g:756:8: WS
{
DebugLocation(756, 8);
WS956=(IToken)Match(input,WS,Follow._WS_in_lvalue_atom9159); if (state.failed) return retval;
if (state.backtracking == 0) stream_WS.Add(WS956);
}
break;
default:
goto loop617;
}
}
loop617:
;
} finally { DebugExitSubRule(617); }
DebugLocation(756, 12);
PushFollow(Follow._ident_in_lvalue_atom9162);
ident957=ident();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_ident.Add(ident957.Tree);
{
// AST REWRITE
// elements: ident, 131
// 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();
// 756:18: -> ^( '@' ident )
{
DebugLocation(756, 21);
// SugarCpp.g:756:21: ^( '@' ident )
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(756, 23);
root_1 = (CommonTree)adaptor.BecomeRoot(stream_131.NextNode(), root_1);
DebugLocation(756, 27);
adaptor.AddChild(root_1, stream_ident.NextTree());
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("lvalue_atom", 100);
LeaveRule("lvalue_atom", 100);
LeaveRule_lvalue_atom();
}
DebugLocation(757, 1);
} finally { DebugExitRule(GrammarFileName, "lvalue_atom"); }
return retval;
}