public void CheckRewriteRuleSubtreeStreamConstructors() {
RewriteRuleSubtreeStream subtreeTest1 =
new RewriteRuleSubtreeStream(CreateTreeAdaptor(),
"RewriteRuleSubtreeStream test1");
RewriteRuleSubtreeStream subtreeTest2 =
new RewriteRuleSubtreeStream(CreateTreeAdaptor(),
"RewriteRuleSubtreeStream test2", CreateToken(1,
"test token without any real context"));
RewriteRuleSubtreeStream subtreeTest3 =
new RewriteRuleSubtreeStream(CreateTreeAdaptor(),
"RewriteRuleSubtreeStream test3", CreateTokenList(4));
}
private AstParserRuleReturnScope<object, IToken> additive_operator()
{
EnterRule_additive_operator();
EnterRule("additive_operator", 10);
TraceIn("additive_operator", 10);
AstParserRuleReturnScope<object, IToken> retval = new AstParserRuleReturnScope<object, IToken>();
retval.Start = (IToken)input.LT(1);
object root_0 = default(object);
IToken string_literal34 = default(IToken);
IToken char_literal35 = default(IToken);
IToken string_literal36 = default(IToken);
IToken char_literal37 = default(IToken);
object string_literal34_tree = default(object);
object char_literal35_tree = default(object);
object string_literal36_tree = default(object);
object char_literal37_tree = default(object);
RewriteRuleITokenStream stream_59=new RewriteRuleITokenStream(adaptor,"token 59");
RewriteRuleITokenStream stream_46=new RewriteRuleITokenStream(adaptor,"token 46");
RewriteRuleITokenStream stream_76=new RewriteRuleITokenStream(adaptor,"token 76");
RewriteRuleITokenStream stream_48=new RewriteRuleITokenStream(adaptor,"token 48");
try { DebugEnterRule(GrammarFileName, "additive_operator");
DebugLocation(129, 4);
try
{
// Queries\\PomonaQuery.g:130:5: ( ( 'add' | '+' ) -> ADD_OP | ( 'sub' | '-' ) -> SUB_OP )
int alt16=2;
try { DebugEnterDecision(16, false);
int LA16_1 = input.LA(1);
if ((LA16_1==46||LA16_1==59))
{
alt16 = 1;
}
else if ((LA16_1==48||LA16_1==76))
{
alt16 = 2;
}
else
{
NoViableAltException nvae = new NoViableAltException("", 16, 0, input, 1);
DebugRecognitionException(nvae);
throw nvae;
}
} finally { DebugExitDecision(16); }
switch (alt16)
{
case 1:
DebugEnterAlt(1);
// Queries\\PomonaQuery.g:130:7: ( 'add' | '+' )
{
DebugLocation(130, 7);
// Queries\\PomonaQuery.g:130:7: ( 'add' | '+' )
int alt14=2;
try { DebugEnterSubRule(14);
try { DebugEnterDecision(14, false);
int LA14_1 = input.LA(1);
if ((LA14_1==59))
{
alt14 = 1;
}
else if ((LA14_1==46))
{
alt14 = 2;
}
else
{
NoViableAltException nvae = new NoViableAltException("", 14, 0, input, 1);
DebugRecognitionException(nvae);
throw nvae;
}
} finally { DebugExitDecision(14); }
switch (alt14)
{
case 1:
DebugEnterAlt(1);
// Queries\\PomonaQuery.g:130:8: 'add'
{
DebugLocation(130, 8);
string_literal34=(IToken)Match(input,59,Follow._59_in_additive_operator787);
stream_59.Add(string_literal34);
}
break;
case 2:
DebugEnterAlt(2);
// Queries\\PomonaQuery.g:130:14: '+'
{
DebugLocation(130, 14);
char_literal35=(IToken)Match(input,46,Follow._46_in_additive_operator789);
stream_46.Add(char_literal35);
}
break;
}
} finally { DebugExitSubRule(14); }
{
// AST REWRITE
// elements:
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.Tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.Tree:null);
root_0 = (object)adaptor.Nil();
// 130:19: -> ADD_OP
{
DebugLocation(130, 22);
adaptor.AddChild(root_0, (object)adaptor.Create(ADD_OP, "ADD_OP"));
}
retval.Tree = root_0;
}
}
break;
case 2:
DebugEnterAlt(2);
// Queries\\PomonaQuery.g:131:7: ( 'sub' | '-' )
{
DebugLocation(131, 7);
// Queries\\PomonaQuery.g:131:7: ( 'sub' | '-' )
int alt15=2;
try { DebugEnterSubRule(15);
try { DebugEnterDecision(15, false);
int LA15_1 = input.LA(1);
if ((LA15_1==76))
{
alt15 = 1;
}
else if ((LA15_1==48))
{
alt15 = 2;
}
else
{
NoViableAltException nvae = new NoViableAltException("", 15, 0, input, 1);
DebugRecognitionException(nvae);
throw nvae;
}
} finally { DebugExitDecision(15); }
switch (alt15)
{
case 1:
DebugEnterAlt(1);
// Queries\\PomonaQuery.g:131:8: 'sub'
{
DebugLocation(131, 8);
string_literal36=(IToken)Match(input,76,Follow._76_in_additive_operator803);
stream_76.Add(string_literal36);
}
break;
case 2:
DebugEnterAlt(2);
// Queries\\PomonaQuery.g:131:14: '-'
{
DebugLocation(131, 14);
char_literal37=(IToken)Match(input,48,Follow._48_in_additive_operator805);
stream_48.Add(char_literal37);
}
break;
}
} finally { DebugExitSubRule(15); }
{
// AST REWRITE
// elements:
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.Tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.Tree:null);
root_0 = (object)adaptor.Nil();
// 131:19: -> SUB_OP
{
DebugLocation(131, 22);
adaptor.AddChild(root_0, (object)adaptor.Create(SUB_OP, "SUB_OP"));
}
retval.Tree = root_0;
}
}
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("additive_operator", 10);
LeaveRule("additive_operator", 10);
LeaveRule_additive_operator();
}
DebugLocation(132, 4);
} finally { DebugExitRule(GrammarFileName, "additive_operator"); }
return retval;
}
// $ANTLR start "name"
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:92:1: name : x= ID -> NAME[$x] ;
public name_return name() // throws RecognitionException [1]
{
var retval = new name_return();
retval.Start = input.LT( 1 );
CommonTree root_0 = null;
IToken x = null;
CommonTree x_tree = null;
var stream_ID = new RewriteRuleTokenStream( adaptor, "token ID" );
try
{
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:93:2: (x= ID -> NAME[$x] )
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:93:4: x= ID
{
x = (IToken)Match( input, ID, FOLLOW_ID_in_name371 );
stream_ID.Add( x );
// AST REWRITE
// elements:
// 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();
// 93:9: -> NAME[$x]
{
adaptor.AddChild( root_0, adaptor.Create( NAME, x ) );
}
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 "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;
}
// $ANTLR start "identifier"
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:262:1: identifier : ID -> ^( IDENTIFIER ID ) ;
public identifier_return identifier() // throws RecognitionException [1]
{
var retval = new identifier_return();
retval.Start = input.LT( 1 );
CommonTree root_0 = null;
IToken ID92 = null;
CommonTree ID92_tree = null;
var stream_ID = new RewriteRuleTokenStream( adaptor, "token ID" );
try
{
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:263:2: ( ID -> ^( IDENTIFIER ID ) )
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:263:4: ID
{
ID92 = (IToken)Match( input, ID, FOLLOW_ID_in_identifier1399 );
stream_ID.Add( ID92 );
// AST REWRITE
// elements: ID
// 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();
// 263:7: -> ^( IDENTIFIER ID )
{
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:263:10: ^( IDENTIFIER ID )
{
var root_1 = (CommonTree)adaptor.GetNilNode();
root_1 = (CommonTree)adaptor.BecomeRoot( adaptor.Create( IDENTIFIER, "IDENTIFIER" ), root_1 );
adaptor.AddChild( root_1, stream_ID.NextNode() );
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 "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;
}
// $ANTLR start "assignmentOp"
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:224:1: assignmentOp : x= '=' -> OP_ASSIGN[$x] ;
public assignmentOp_return assignmentOp() // throws RecognitionException [1]
{
var retval = new assignmentOp_return();
retval.Start = input.LT( 1 );
CommonTree root_0 = null;
IToken x = null;
CommonTree x_tree = null;
var stream_68 = new RewriteRuleTokenStream( adaptor, "token 68" );
try
{
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:225:2: (x= '=' -> OP_ASSIGN[$x] )
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:225:4: x= '='
{
x = (IToken)Match( input, 68, FOLLOW_68_in_assignmentOp1201 );
stream_68.Add( x );
// AST REWRITE
// elements:
// 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();
// 225:10: -> OP_ASSIGN[$x]
{
adaptor.AddChild( root_0, adaptor.Create( OP_ASSIGN, x ) );
}
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 "equalsOp"
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:189:1: equalsOp : (x= '==' -> OP_EQ[$x] | x= '=' -> OP_EQ[$x] );
public equalsOp_return equalsOp() // throws RecognitionException [1]
{
var retval = new equalsOp_return();
retval.Start = input.LT( 1 );
CommonTree root_0 = null;
IToken x = null;
CommonTree x_tree = null;
var stream_79 = new RewriteRuleTokenStream( adaptor, "token 79" );
var stream_68 = new RewriteRuleTokenStream( adaptor, "token 68" );
try
{
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:190:2: (x= '==' -> OP_EQ[$x] | x= '=' -> OP_EQ[$x] )
int alt26 = 2;
int LA26_0 = input.LA( 1 );
if ( ( LA26_0 == 79 ) )
alt26 = 1;
else if ( ( LA26_0 == 68 ) )
alt26 = 2;
else
{
var nvae_d26s0 =
new NoViableAltException( "", 26, 0, input );
throw nvae_d26s0;
}
switch ( alt26 )
{
case 1:
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:190:4: x= '=='
{
x = (IToken)Match( input, 79, FOLLOW_79_in_equalsOp988 );
stream_79.Add( x );
// AST REWRITE
// elements:
// 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();
// 190:11: -> OP_EQ[$x]
{
adaptor.AddChild( root_0, adaptor.Create( OP_EQ, x ) );
}
retval.Tree = root_0;
retval.Tree = root_0;
}
break;
case 2:
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:191:4: x= '='
{
x = (IToken)Match( input, 68, FOLLOW_68_in_equalsOp1001 );
stream_68.Add( x );
// AST REWRITE
// elements:
// 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();
// 191:11: -> OP_EQ[$x]
{
adaptor.AddChild( root_0, adaptor.Create( OP_EQ, x ) );
}
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<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<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<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;
}
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;
}
private AstParserRuleReturnScope<object, IToken> dot_operator()
{
EnterRule_dot_operator();
EnterRule("dot_operator", 15);
TraceIn("dot_operator", 15);
AstParserRuleReturnScope<object, IToken> retval = new AstParserRuleReturnScope<object, IToken>();
retval.Start = (IToken)input.LT(1);
object root_0 = default(object);
IToken char_literal52 = default(IToken);
object char_literal52_tree = default(object);
RewriteRuleITokenStream stream_49=new RewriteRuleITokenStream(adaptor,"token 49");
try { DebugEnterRule(GrammarFileName, "dot_operator");
DebugLocation(152, 1);
try
{
// Queries\\PomonaQuery.g:153:2: ( '.' -> DOT_OP )
DebugEnterAlt(1);
// Queries\\PomonaQuery.g:153:4: '.'
{
DebugLocation(153, 4);
char_literal52=(IToken)Match(input,49,Follow._49_in_dot_operator948);
stream_49.Add(char_literal52);
{
// AST REWRITE
// elements:
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.Tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.Tree:null);
root_0 = (object)adaptor.Nil();
// 153:8: -> DOT_OP
{
DebugLocation(153, 11);
adaptor.AddChild(root_0, (object)adaptor.Create(DOT_OP, "DOT_OP"));
}
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("dot_operator", 15);
LeaveRule("dot_operator", 15);
LeaveRule_dot_operator();
}
DebugLocation(154, 1);
} finally { DebugExitRule(GrammarFileName, "dot_operator"); }
return retval;
}
private AstParserRuleReturnScope<object, IToken> unary_operator()
{
EnterRule_unary_operator();
EnterRule("unary_operator", 14);
TraceIn("unary_operator", 14);
AstParserRuleReturnScope<object, IToken> retval = new AstParserRuleReturnScope<object, IToken>();
retval.Start = (IToken)input.LT(1);
object root_0 = default(object);
IToken string_literal50 = default(IToken);
IToken char_literal51 = default(IToken);
object string_literal50_tree = default(object);
object char_literal51_tree = default(object);
RewriteRuleITokenStream stream_74=new RewriteRuleITokenStream(adaptor,"token 74");
RewriteRuleITokenStream stream_39=new RewriteRuleITokenStream(adaptor,"token 39");
try { DebugEnterRule(GrammarFileName, "unary_operator");
DebugLocation(148, 1);
try
{
// Queries\\PomonaQuery.g:149:2: ( ( 'not' | '!' ) -> NOT_OP )
DebugEnterAlt(1);
// Queries\\PomonaQuery.g:149:4: ( 'not' | '!' )
{
DebugLocation(149, 4);
// Queries\\PomonaQuery.g:149:4: ( 'not' | '!' )
int alt23=2;
try { DebugEnterSubRule(23);
try { DebugEnterDecision(23, false);
int LA23_1 = input.LA(1);
if ((LA23_1==74))
{
alt23 = 1;
}
else if ((LA23_1==39))
{
alt23 = 2;
}
else
{
NoViableAltException nvae = new NoViableAltException("", 23, 0, input, 1);
DebugRecognitionException(nvae);
throw nvae;
}
} finally { DebugExitDecision(23); }
switch (alt23)
{
case 1:
DebugEnterAlt(1);
// Queries\\PomonaQuery.g:149:5: 'not'
{
DebugLocation(149, 5);
string_literal50=(IToken)Match(input,74,Follow._74_in_unary_operator930);
stream_74.Add(string_literal50);
}
break;
case 2:
DebugEnterAlt(2);
// Queries\\PomonaQuery.g:149:11: '!'
{
DebugLocation(149, 11);
char_literal51=(IToken)Match(input,39,Follow._39_in_unary_operator932);
stream_39.Add(char_literal51);
}
break;
}
} finally { DebugExitSubRule(23); }
{
// AST REWRITE
// elements:
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.Tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.Tree:null);
root_0 = (object)adaptor.Nil();
// 149:16: -> NOT_OP
{
DebugLocation(149, 19);
adaptor.AddChild(root_0, (object)adaptor.Create(NOT_OP, "NOT_OP"));
}
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("unary_operator", 14);
LeaveRule("unary_operator", 14);
LeaveRule_unary_operator();
}
DebugLocation(150, 1);
} finally { DebugExitRule(GrammarFileName, "unary_operator"); }
return retval;
}
private AstParserRuleReturnScope<object, IToken> multiplicative_operator()
{
EnterRule_multiplicative_operator();
EnterRule("multiplicative_operator", 12);
TraceIn("multiplicative_operator", 12);
AstParserRuleReturnScope<object, IToken> retval = new AstParserRuleReturnScope<object, IToken>();
retval.Start = (IToken)input.LT(1);
object root_0 = default(object);
IToken string_literal41 = default(IToken);
IToken char_literal42 = default(IToken);
IToken string_literal43 = default(IToken);
IToken char_literal44 = default(IToken);
IToken string_literal45 = default(IToken);
IToken char_literal46 = default(IToken);
object string_literal41_tree = default(object);
object char_literal42_tree = default(object);
object string_literal43_tree = default(object);
object char_literal44_tree = default(object);
object string_literal45_tree = default(object);
object char_literal46_tree = default(object);
RewriteRuleITokenStream stream_72=new RewriteRuleITokenStream(adaptor,"token 72");
RewriteRuleITokenStream stream_45=new RewriteRuleITokenStream(adaptor,"token 45");
RewriteRuleITokenStream stream_64=new RewriteRuleITokenStream(adaptor,"token 64");
RewriteRuleITokenStream stream_50=new RewriteRuleITokenStream(adaptor,"token 50");
RewriteRuleITokenStream stream_71=new RewriteRuleITokenStream(adaptor,"token 71");
RewriteRuleITokenStream stream_41=new RewriteRuleITokenStream(adaptor,"token 41");
try { DebugEnterRule(GrammarFileName, "multiplicative_operator");
DebugLocation(138, 4);
try
{
// Queries\\PomonaQuery.g:139:5: ( ( 'mul' | '*' ) -> MUL_OP | ( 'div' | '/' ) -> DIV_OP | ( 'mod' | '%' ) -> MOD_OP )
int alt21=3;
try { DebugEnterDecision(21, false);
switch (input.LA(1))
{
case 45:
case 72:
{
alt21 = 1;
}
break;
case 50:
case 64:
{
alt21 = 2;
}
break;
case 41:
case 71:
{
alt21 = 3;
}
break;
default:
{
NoViableAltException nvae = new NoViableAltException("", 21, 0, input, 1);
DebugRecognitionException(nvae);
throw nvae;
}
}
} finally { DebugExitDecision(21); }
switch (alt21)
{
case 1:
DebugEnterAlt(1);
// Queries\\PomonaQuery.g:139:9: ( 'mul' | '*' )
{
DebugLocation(139, 9);
// Queries\\PomonaQuery.g:139:9: ( 'mul' | '*' )
int alt18=2;
try { DebugEnterSubRule(18);
try { DebugEnterDecision(18, false);
int LA18_1 = input.LA(1);
if ((LA18_1==72))
{
alt18 = 1;
}
else if ((LA18_1==45))
{
alt18 = 2;
}
else
{
NoViableAltException nvae = new NoViableAltException("", 18, 0, input, 1);
DebugRecognitionException(nvae);
throw nvae;
}
} finally { DebugExitDecision(18); }
switch (alt18)
{
case 1:
DebugEnterAlt(1);
// Queries\\PomonaQuery.g:139:10: 'mul'
{
DebugLocation(139, 10);
string_literal41=(IToken)Match(input,72,Follow._72_in_multiplicative_operator852);
stream_72.Add(string_literal41);
}
break;
case 2:
DebugEnterAlt(2);
// Queries\\PomonaQuery.g:139:16: '*'
{
DebugLocation(139, 16);
char_literal42=(IToken)Match(input,45,Follow._45_in_multiplicative_operator854);
stream_45.Add(char_literal42);
}
break;
}
} finally { DebugExitSubRule(18); }
{
// AST REWRITE
// elements:
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.Tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.Tree:null);
root_0 = (object)adaptor.Nil();
// 139:21: -> MUL_OP
{
DebugLocation(139, 24);
adaptor.AddChild(root_0, (object)adaptor.Create(MUL_OP, "MUL_OP"));
}
retval.Tree = root_0;
}
}
break;
case 2:
DebugEnterAlt(2);
// Queries\\PomonaQuery.g:140:9: ( 'div' | '/' )
{
DebugLocation(140, 9);
// Queries\\PomonaQuery.g:140:9: ( 'div' | '/' )
int alt19=2;
try { DebugEnterSubRule(19);
try { DebugEnterDecision(19, false);
int LA19_1 = input.LA(1);
if ((LA19_1==64))
{
alt19 = 1;
}
else if ((LA19_1==50))
{
alt19 = 2;
}
else
{
NoViableAltException nvae = new NoViableAltException("", 19, 0, input, 1);
DebugRecognitionException(nvae);
throw nvae;
}
} finally { DebugExitDecision(19); }
switch (alt19)
{
case 1:
DebugEnterAlt(1);
// Queries\\PomonaQuery.g:140:10: 'div'
{
DebugLocation(140, 10);
string_literal43=(IToken)Match(input,64,Follow._64_in_multiplicative_operator870);
stream_64.Add(string_literal43);
}
break;
case 2:
DebugEnterAlt(2);
// Queries\\PomonaQuery.g:140:16: '/'
{
DebugLocation(140, 16);
char_literal44=(IToken)Match(input,50,Follow._50_in_multiplicative_operator872);
stream_50.Add(char_literal44);
}
break;
}
} finally { DebugExitSubRule(19); }
{
// AST REWRITE
// elements:
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.Tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.Tree:null);
root_0 = (object)adaptor.Nil();
// 140:21: -> DIV_OP
{
DebugLocation(140, 24);
adaptor.AddChild(root_0, (object)adaptor.Create(DIV_OP, "DIV_OP"));
}
retval.Tree = root_0;
}
}
break;
case 3:
DebugEnterAlt(3);
// Queries\\PomonaQuery.g:141:6: ( 'mod' | '%' )
{
DebugLocation(141, 6);
// Queries\\PomonaQuery.g:141:6: ( 'mod' | '%' )
int alt20=2;
try { DebugEnterSubRule(20);
try { DebugEnterDecision(20, false);
int LA20_1 = input.LA(1);
if ((LA20_1==71))
{
alt20 = 1;
}
else if ((LA20_1==41))
{
alt20 = 2;
}
else
{
NoViableAltException nvae = new NoViableAltException("", 20, 0, input, 1);
DebugRecognitionException(nvae);
throw nvae;
}
} finally { DebugExitDecision(20); }
switch (alt20)
{
case 1:
DebugEnterAlt(1);
// Queries\\PomonaQuery.g:141:7: 'mod'
{
DebugLocation(141, 7);
string_literal45=(IToken)Match(input,71,Follow._71_in_multiplicative_operator885);
stream_71.Add(string_literal45);
}
break;
case 2:
DebugEnterAlt(2);
// Queries\\PomonaQuery.g:141:13: '%'
{
DebugLocation(141, 13);
char_literal46=(IToken)Match(input,41,Follow._41_in_multiplicative_operator887);
stream_41.Add(char_literal46);
}
break;
}
} finally { DebugExitSubRule(20); }
{
// AST REWRITE
// elements:
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.Tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.Tree:null);
root_0 = (object)adaptor.Nil();
// 141:18: -> MOD_OP
{
DebugLocation(141, 21);
adaptor.AddChild(root_0, (object)adaptor.Create(MOD_OP, "MOD_OP"));
}
retval.Tree = root_0;
}
}
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("multiplicative_operator", 12);
LeaveRule("multiplicative_operator", 12);
LeaveRule_multiplicative_operator();
}
DebugLocation(142, 4);
} finally { DebugExitRule(GrammarFileName, "multiplicative_operator"); }
return retval;
}
// $ANTLR start "andOp"
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:181:1: andOp : (x= 'and' -> OP_AND[$x] | x= '&&' -> OP_AND[$x] );
public andOp_return andOp() // throws RecognitionException [1]
{
var retval = new andOp_return();
retval.Start = input.LT( 1 );
CommonTree root_0 = null;
IToken x = null;
CommonTree x_tree = null;
var stream_75 = new RewriteRuleTokenStream( adaptor, "token 75" );
var stream_76 = new RewriteRuleTokenStream( adaptor, "token 76" );
try
{
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:182:2: (x= 'and' -> OP_AND[$x] | x= '&&' -> OP_AND[$x] )
int alt24 = 2;
int LA24_0 = input.LA( 1 );
if ( ( LA24_0 == 75 ) )
alt24 = 1;
else if ( ( LA24_0 == 76 ) )
alt24 = 2;
else
{
var nvae_d24s0 =
new NoViableAltException( "", 24, 0, input );
throw nvae_d24s0;
}
switch ( alt24 )
{
case 1:
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:182:4: x= 'and'
{
x = (IToken)Match( input, 75, FOLLOW_75_in_andOp927 );
stream_75.Add( x );
// AST REWRITE
// elements:
// 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();
// 182:12: -> OP_AND[$x]
{
adaptor.AddChild( root_0, adaptor.Create( OP_AND, x ) );
}
retval.Tree = root_0;
retval.Tree = root_0;
}
break;
case 2:
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:183:4: x= '&&'
{
x = (IToken)Match( input, 76, FOLLOW_76_in_andOp939 );
stream_76.Add( x );
// AST REWRITE
// elements:
// 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();
// 183:12: -> OP_AND[$x]
{
adaptor.AddChild( root_0, adaptor.Create( OP_AND, x ) );
}
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;
}
// $ANTLR start "modulusOp"
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:185:1: modulusOp : (x= 'mod' -> OP_MODULUS[$x] | x= '%' -> OP_MODULUS[$x] );
public modulusOp_return modulusOp() // throws RecognitionException [1]
{
var retval = new modulusOp_return();
retval.Start = input.LT( 1 );
CommonTree root_0 = null;
IToken x = null;
CommonTree x_tree = null;
var stream_78 = new RewriteRuleTokenStream( adaptor, "token 78" );
var stream_77 = new RewriteRuleTokenStream( adaptor, "token 77" );
try
{
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:186:2: (x= 'mod' -> OP_MODULUS[$x] | x= '%' -> OP_MODULUS[$x] )
int alt25 = 2;
int LA25_0 = input.LA( 1 );
if ( ( LA25_0 == 77 ) )
alt25 = 1;
else if ( ( LA25_0 == 78 ) )
alt25 = 2;
else
{
var nvae_d25s0 =
new NoViableAltException( "", 25, 0, input );
throw nvae_d25s0;
}
switch ( alt25 )
{
case 1:
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:186:4: x= 'mod'
{
x = (IToken)Match( input, 77, FOLLOW_77_in_modulusOp957 );
stream_77.Add( x );
// AST REWRITE
// elements:
// 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();
// 186:12: -> OP_MODULUS[$x]
{
adaptor.AddChild( root_0, adaptor.Create( OP_MODULUS, x ) );
}
retval.Tree = root_0;
retval.Tree = root_0;
}
break;
case 2:
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:187:4: x= '%'
{
x = (IToken)Match( input, 78, FOLLOW_78_in_modulusOp969 );
stream_78.Add( x );
// AST REWRITE
// elements:
// 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();
// 187:12: -> OP_MODULUS[$x]
{
adaptor.AddChild( root_0, adaptor.Create( OP_MODULUS, x ) );
}
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<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 "notEqualsOp"
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:193:1: notEqualsOp : (x= '!=' -> OP_NE[$x] | x= '<>' -> OP_NE[$x] );
public notEqualsOp_return notEqualsOp() // throws RecognitionException [1]
{
var retval = new notEqualsOp_return();
retval.Start = input.LT( 1 );
CommonTree root_0 = null;
IToken x = null;
CommonTree x_tree = null;
var stream_80 = new RewriteRuleTokenStream( adaptor, "token 80" );
var stream_81 = new RewriteRuleTokenStream( adaptor, "token 81" );
try
{
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:194:2: (x= '!=' -> OP_NE[$x] | x= '<>' -> OP_NE[$x] )
int alt27 = 2;
int LA27_0 = input.LA( 1 );
if ( ( LA27_0 == 80 ) )
alt27 = 1;
else if ( ( LA27_0 == 81 ) )
alt27 = 2;
else
{
var nvae_d27s0 =
new NoViableAltException( "", 27, 0, input );
throw nvae_d27s0;
}
switch ( alt27 )
{
case 1:
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:194:4: x= '!='
{
x = (IToken)Match( input, 80, FOLLOW_80_in_notEqualsOp1019 );
stream_80.Add( x );
// AST REWRITE
// elements:
// 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();
// 194:11: -> OP_NE[$x]
{
adaptor.AddChild( root_0, adaptor.Create( OP_NE, x ) );
}
retval.Tree = root_0;
retval.Tree = root_0;
}
break;
case 2:
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:195:4: x= '<>'
{
x = (IToken)Match( input, 81, FOLLOW_81_in_notEqualsOp1031 );
stream_81.Add( x );
// AST REWRITE
// elements:
// 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();
// 195:11: -> OP_NE[$x]
{
adaptor.AddChild( root_0, adaptor.Create( OP_NE, x ) );
}
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<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;
}
// $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;
}
// $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;
}
// $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 "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;
}
// $ANTLR start "booleanValue"
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:269:1: booleanValue : (x= 'true' -> TRUE[$x] | x= 'false' -> FALSE[$x] );
public booleanValue_return booleanValue() // throws RecognitionException [1]
{
var retval = new booleanValue_return();
retval.Start = input.LT( 1 );
CommonTree root_0 = null;
IToken x = null;
CommonTree x_tree = null;
var stream_96 = new RewriteRuleTokenStream( adaptor, "token 96" );
var stream_95 = new RewriteRuleTokenStream( adaptor, "token 95" );
try
{
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:270:2: (x= 'true' -> TRUE[$x] | x= 'false' -> FALSE[$x] )
int alt34 = 2;
int LA34_0 = input.LA( 1 );
if ( ( LA34_0 == 95 ) )
alt34 = 1;
else if ( ( LA34_0 == 96 ) )
alt34 = 2;
else
{
var nvae_d34s0 =
new NoViableAltException( "", 34, 0, input );
throw nvae_d34s0;
}
switch ( alt34 )
{
case 1:
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:270:4: x= 'true'
{
x = (IToken)Match( input, 95, FOLLOW_95_in_booleanValue1440 );
stream_95.Add( x );
// AST REWRITE
// elements:
// 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();
// 270:13: -> TRUE[$x]
{
adaptor.AddChild( root_0, adaptor.Create( TRUE, x ) );
}
retval.Tree = root_0;
retval.Tree = root_0;
}
break;
case 2:
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:271:4: x= 'false'
{
x = (IToken)Match( input, 96, FOLLOW_96_in_booleanValue1452 );
stream_96.Add( x );
// AST REWRITE
// elements:
// 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();
// 271:14: -> FALSE[$x]
{
adaptor.AddChild( root_0, adaptor.Create( FALSE, x ) );
}
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;
}
// $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 "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 "formulaDeclaration"
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:125:1: formulaDeclaration : entityChainNoFilter assignmentOp expression ';' -> ^( FORMULA ^( assignmentOp entityChainNoFilter expression ) ) ;
public formulaDeclaration_return formulaDeclaration() // throws RecognitionException [1]
{
var retval = new formulaDeclaration_return();
retval.Start = input.LT( 1 );
CommonTree root_0 = null;
IToken char_literal36 = null;
entityChainNoFilter_return entityChainNoFilter33 = default( entityChainNoFilter_return );
assignmentOp_return assignmentOp34 = default( assignmentOp_return );
expression_return expression35 = default( expression_return );
CommonTree char_literal36_tree = null;
var stream_63 = new RewriteRuleTokenStream( adaptor, "token 63" );
var stream_entityChainNoFilter = new RewriteRuleSubtreeStream( adaptor, "rule entityChainNoFilter" );
var stream_expression = new RewriteRuleSubtreeStream( adaptor, "rule expression" );
var stream_assignmentOp = new RewriteRuleSubtreeStream( adaptor, "rule assignmentOp" );
try
{
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:126:2: ( entityChainNoFilter assignmentOp expression ';' -> ^( FORMULA ^( assignmentOp entityChainNoFilter expression ) ) )
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:126:4: entityChainNoFilter assignmentOp expression ';'
{
PushFollow( FOLLOW_entityChainNoFilter_in_formulaDeclaration558 );
entityChainNoFilter33 = entityChainNoFilter();
state.followingStackPointer--;
stream_entityChainNoFilter.Add( entityChainNoFilter33.Tree );
PushFollow( FOLLOW_assignmentOp_in_formulaDeclaration560 );
assignmentOp34 = assignmentOp();
state.followingStackPointer--;
stream_assignmentOp.Add( assignmentOp34.Tree );
PushFollow( FOLLOW_expression_in_formulaDeclaration562 );
expression35 = expression();
state.followingStackPointer--;
stream_expression.Add( expression35.Tree );
char_literal36 = (IToken)Match( input, 63, FOLLOW_63_in_formulaDeclaration564 );
stream_63.Add( char_literal36 );
// AST REWRITE
// elements: assignmentOp, entityChainNoFilter, expression
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.Tree = root_0;
var stream_retval = new RewriteRuleSubtreeStream( adaptor, "rule retval", retval != null ? retval.Tree : null );
root_0 = (CommonTree)adaptor.GetNilNode();
// 126:52: -> ^( FORMULA ^( assignmentOp entityChainNoFilter expression ) )
{
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:126:55: ^( FORMULA ^( assignmentOp entityChainNoFilter expression ) )
{
var root_1 = (CommonTree)adaptor.GetNilNode();
root_1 = (CommonTree)adaptor.BecomeRoot( adaptor.Create( FORMULA, "FORMULA" ), root_1 );
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:126:66: ^( assignmentOp entityChainNoFilter expression )
{
var root_2 = (CommonTree)adaptor.GetNilNode();
root_2 = (CommonTree)adaptor.BecomeRoot( stream_assignmentOp.NextNode(), root_2 );
adaptor.AddChild( root_2, stream_entityChainNoFilter.NextTree() );
adaptor.AddChild( root_2, stream_expression.NextTree() );
adaptor.AddChild( root_1, root_2 );
}
adaptor.AddChild( root_0, root_1 );
}
}
retval.Tree = root_0;
retval.Tree = root_0;
}
retval.Stop = input.LT( -1 );
retval.Tree = adaptor.RulePostProcessing( root_0 );
adaptor.SetTokenBoundaries( retval.Tree, (IToken)retval.Start, (IToken)retval.Stop );
}
catch ( RecognitionException re )
{
ReportError( re );
Recover( input, re );
// Conversion of the second argument necessary, but harmless
retval.Tree = adaptor.ErrorNode( input, (IToken)retval.Start, input.LT( -1 ), re );
}
finally {}
return retval;
}
// $ANTLR start "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;
}
// $ANTLR start "orOp"
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:177:1: orOp : (x= 'or' -> OP_OR[$x] | x= '||' -> OP_OR[$x] );
public orOp_return orOp() // throws RecognitionException [1]
{
var retval = new orOp_return();
retval.Start = input.LT( 1 );
CommonTree root_0 = null;
IToken x = null;
CommonTree x_tree = null;
var stream_73 = new RewriteRuleTokenStream( adaptor, "token 73" );
var stream_74 = new RewriteRuleTokenStream( adaptor, "token 74" );
try
{
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:178:2: (x= 'or' -> OP_OR[$x] | x= '||' -> OP_OR[$x] )
int alt23 = 2;
int LA23_0 = input.LA( 1 );
if ( ( LA23_0 == 73 ) )
alt23 = 1;
else if ( ( LA23_0 == 74 ) )
alt23 = 2;
else
{
var nvae_d23s0 =
new NoViableAltException( "", 23, 0, input );
throw nvae_d23s0;
}
switch ( alt23 )
{
case 1:
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:178:4: x= 'or'
{
x = (IToken)Match( input, 73, FOLLOW_73_in_orOp898 );
stream_73.Add( x );
// AST REWRITE
// elements:
// 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();
// 178:11: -> OP_OR[$x]
{
adaptor.AddChild( root_0, adaptor.Create( OP_OR, x ) );
}
retval.Tree = root_0;
retval.Tree = root_0;
}
break;
case 2:
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:179:4: x= '||'
{
x = (IToken)Match( input, 74, FOLLOW_74_in_orOp910 );
stream_74.Add( x );
// AST REWRITE
// elements:
// 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();
// 179:11: -> OP_OR[$x]
{
adaptor.AddChild( root_0, adaptor.Create( OP_OR, x ) );
}
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;
}