// $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;
}
private AstParserRuleReturnScope<CommonTree, IToken> defaultXMLNamespaceStatement()
{
EnterRule_defaultXMLNamespaceStatement();
EnterRule("defaultXMLNamespaceStatement", 70);
TraceIn("defaultXMLNamespaceStatement", 70);
AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>();
retval.Start = (IToken)input.LT(1);
CommonTree root_0 = default(CommonTree);
IToken DEFAULT226 = default(IToken);
IToken XML227 = default(IToken);
IToken NAMESPACE228 = default(IToken);
IToken ASSIGN229 = default(IToken);
AstParserRuleReturnScope<CommonTree, IToken> expression230 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> semi231 = default(AstParserRuleReturnScope<CommonTree, IToken>);
CommonTree DEFAULT226_tree = default(CommonTree);
CommonTree XML227_tree = default(CommonTree);
CommonTree NAMESPACE228_tree = default(CommonTree);
CommonTree ASSIGN229_tree = default(CommonTree);
RewriteRuleITokenStream stream_DEFAULT=new RewriteRuleITokenStream(adaptor,"token DEFAULT");
RewriteRuleITokenStream stream_XML=new RewriteRuleITokenStream(adaptor,"token XML");
RewriteRuleITokenStream stream_NAMESPACE=new RewriteRuleITokenStream(adaptor,"token NAMESPACE");
RewriteRuleITokenStream stream_ASSIGN=new RewriteRuleITokenStream(adaptor,"token ASSIGN");
RewriteRuleSubtreeStream stream_expression=new RewriteRuleSubtreeStream(adaptor,"rule expression");
RewriteRuleSubtreeStream stream_semi=new RewriteRuleSubtreeStream(adaptor,"rule semi");
try { DebugEnterRule(GrammarFileName, "defaultXMLNamespaceStatement");
DebugLocation(562, 1);
try
{
// AS3.g:563:2: ( DEFAULT XML NAMESPACE ASSIGN expression semi -> ^( DEFAULT_XML_NAMESPACE expression ) )
DebugEnterAlt(1);
// AS3.g:563:4: DEFAULT XML NAMESPACE ASSIGN expression semi
{
DebugLocation(563, 4);
DEFAULT226=(IToken)Match(input,DEFAULT,Follow._DEFAULT_in_defaultXMLNamespaceStatement3040); if (state.failed) return retval;
if (state.backtracking == 0) stream_DEFAULT.Add(DEFAULT226);
DebugLocation(563, 12);
XML227=(IToken)Match(input,XML,Follow._XML_in_defaultXMLNamespaceStatement3042); if (state.failed) return retval;
if (state.backtracking == 0) stream_XML.Add(XML227);
DebugLocation(563, 16);
NAMESPACE228=(IToken)Match(input,NAMESPACE,Follow._NAMESPACE_in_defaultXMLNamespaceStatement3044); if (state.failed) return retval;
if (state.backtracking == 0) stream_NAMESPACE.Add(NAMESPACE228);
DebugLocation(563, 26);
ASSIGN229=(IToken)Match(input,ASSIGN,Follow._ASSIGN_in_defaultXMLNamespaceStatement3046); if (state.failed) return retval;
if (state.backtracking == 0) stream_ASSIGN.Add(ASSIGN229);
DebugLocation(563, 33);
PushFollow(Follow._expression_in_defaultXMLNamespaceStatement3048);
expression230=expression();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_expression.Add(expression230.Tree);
DebugLocation(563, 44);
PushFollow(Follow._semi_in_defaultXMLNamespaceStatement3050);
semi231=semi();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_semi.Add(semi231.Tree);
{
// AST REWRITE
// elements: expression
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
if (state.backtracking == 0) {
retval.Tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.Tree:null);
root_0 = (CommonTree)adaptor.Nil();
// 564:3: -> ^( DEFAULT_XML_NAMESPACE expression )
{
DebugLocation(564, 6);
// AS3.g:564:6: ^( DEFAULT_XML_NAMESPACE expression )
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(564, 8);
root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(DEFAULT_XML_NAMESPACE, "DEFAULT_XML_NAMESPACE"), root_1);
DebugLocation(564, 30);
adaptor.AddChild(root_1, stream_expression.NextTree());
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;
}
}
}
retval.Stop = (IToken)input.LT(-1);
if (state.backtracking == 0) {
retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
}
}
catch (RecognitionException re)
{
ReportError(re);
Recover(input,re);
retval.Tree = (CommonTree)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);
}
finally
{
TraceOut("defaultXMLNamespaceStatement", 70);
LeaveRule("defaultXMLNamespaceStatement", 70);
LeaveRule_defaultXMLNamespaceStatement();
}
DebugLocation(565, 1);
} finally { DebugExitRule(GrammarFileName, "defaultXMLNamespaceStatement"); }
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 "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;
}
private AstParserRuleReturnScope<CommonTree, IToken> whileStatement()
{
EnterRule_whileStatement();
EnterRule("whileStatement", 67);
TraceIn("whileStatement", 67);
AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>();
retval.Start = (IToken)input.LT(1);
CommonTree root_0 = default(CommonTree);
IToken WHILE215 = default(IToken);
AstParserRuleReturnScope<CommonTree, IToken> condition216 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> statement217 = default(AstParserRuleReturnScope<CommonTree, IToken>);
CommonTree WHILE215_tree = default(CommonTree);
RewriteRuleITokenStream stream_WHILE=new RewriteRuleITokenStream(adaptor,"token WHILE");
RewriteRuleSubtreeStream stream_condition=new RewriteRuleSubtreeStream(adaptor,"rule condition");
RewriteRuleSubtreeStream stream_statement=new RewriteRuleSubtreeStream(adaptor,"rule statement");
try { DebugEnterRule(GrammarFileName, "whileStatement");
DebugLocation(548, 1);
try
{
// AS3.g:549:2: ( WHILE condition statement -> ^( WHILE_LOOP condition statement ) )
DebugEnterAlt(1);
// AS3.g:549:4: WHILE condition statement
{
DebugLocation(549, 4);
WHILE215=(IToken)Match(input,WHILE,Follow._WHILE_in_whileStatement2962); if (state.failed) return retval;
if (state.backtracking == 0) stream_WHILE.Add(WHILE215);
DebugLocation(549, 10);
PushFollow(Follow._condition_in_whileStatement2964);
condition216=condition();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_condition.Add(condition216.Tree);
DebugLocation(549, 20);
PushFollow(Follow._statement_in_whileStatement2966);
statement217=statement();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_statement.Add(statement217.Tree);
{
// AST REWRITE
// elements: condition, statement
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
if (state.backtracking == 0) {
retval.Tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.Tree:null);
root_0 = (CommonTree)adaptor.Nil();
// 550:3: -> ^( WHILE_LOOP condition statement )
{
DebugLocation(550, 6);
// AS3.g:550:6: ^( WHILE_LOOP condition statement )
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(550, 8);
root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(WHILE_LOOP, "WHILE_LOOP"), root_1);
DebugLocation(550, 19);
adaptor.AddChild(root_1, stream_condition.NextTree());
DebugLocation(550, 29);
adaptor.AddChild(root_1, stream_statement.NextTree());
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;
}
}
}
retval.Stop = (IToken)input.LT(-1);
if (state.backtracking == 0) {
retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
}
}
catch (RecognitionException re)
{
ReportError(re);
Recover(input,re);
retval.Tree = (CommonTree)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);
}
finally
{
TraceOut("whileStatement", 67);
LeaveRule("whileStatement", 67);
LeaveRule_whileStatement();
}
DebugLocation(551, 1);
} finally { DebugExitRule(GrammarFileName, "whileStatement"); }
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 "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;
}
private PointcutParser.criteria_return criteria()
{
Enter_criteria();
EnterRule("criteria", 5);
TraceIn("criteria", 5);
PointcutParser.criteria_return retval = new PointcutParser.criteria_return();
retval.Start = (IToken)input.LT(1);
object root_0 = default(object);
IToken Identifier12 = null;
IToken char_literal13 = null;
PointcutParser.atom_return atom11 = default(PointcutParser.atom_return);
PointcutParser.array_return array14 = default(PointcutParser.array_return);
object Identifier12_tree = default(object);
object char_literal13_tree = default(object);
RewriteRuleITokenStream stream_15 = new RewriteRuleITokenStream(adaptor, "token 15");
RewriteRuleITokenStream stream_Identifier = new RewriteRuleITokenStream(adaptor, "token Identifier");
RewriteRuleSubtreeStream stream_array = new RewriteRuleSubtreeStream(adaptor, "rule array");
try { DebugEnterRule(GrammarFileName, "criteria");
DebugLocation(30, 60);
try
{
// D:\\Dev\\Codeplex\\SheepAop\\SheepAspect\\Saql\\Ast\\Pointcut.g:30:10: ( atom | ( Identifier ( ':' array )? ) -> ^( CRITERIA Identifier ( array )? ) )
int alt7 = 2;
try { DebugEnterDecision(7, decisionCanBacktrack[7]);
int LA7_0 = input.LA(1);
if ((LA7_0 == Value || (LA7_0 >= 16 && LA7_0 <= 17)))
{
alt7 = 1;
}
else if ((LA7_0 == Identifier))
{
alt7 = 2;
}
else
{
NoViableAltException nvae = new NoViableAltException("", 7, 0, input);
DebugRecognitionException(nvae);
throw nvae;
} } finally { DebugExitDecision(7); }
switch (alt7)
{
case 1:
DebugEnterAlt(1);
// D:\\Dev\\Codeplex\\SheepAop\\SheepAspect\\Saql\\Ast\\Pointcut.g:30:12: atom
{
root_0 = (object)adaptor.Nil();
DebugLocation(30, 12);
PushFollow(Follow._atom_in_criteria157);
atom11 = atom();
PopFollow();
adaptor.AddChild(root_0, atom11.Tree);
}
break;
case 2:
DebugEnterAlt(2);
// D:\\Dev\\Codeplex\\SheepAop\\SheepAspect\\Saql\\Ast\\Pointcut.g:31:4: ( Identifier ( ':' array )? )
{
DebugLocation(31, 4);
// D:\\Dev\\Codeplex\\SheepAop\\SheepAspect\\Saql\\Ast\\Pointcut.g:31:4: ( Identifier ( ':' array )? )
DebugEnterAlt(1);
// D:\\Dev\\Codeplex\\SheepAop\\SheepAspect\\Saql\\Ast\\Pointcut.g:31:5: Identifier ( ':' array )?
{
DebugLocation(31, 5);
Identifier12 = (IToken)Match(input, Identifier, Follow._Identifier_in_criteria163);
stream_Identifier.Add(Identifier12);
DebugLocation(31, 16);
// D:\\Dev\\Codeplex\\SheepAop\\SheepAspect\\Saql\\Ast\\Pointcut.g:31:16: ( ':' array )?
int alt6 = 2;
try { DebugEnterSubRule(6);
try { DebugEnterDecision(6, decisionCanBacktrack[6]);
int LA6_0 = input.LA(1);
if ((LA6_0 == 15))
{
alt6 = 1;
}
} finally { DebugExitDecision(6); }
switch (alt6)
{
case 1:
DebugEnterAlt(1);
// D:\\Dev\\Codeplex\\SheepAop\\SheepAspect\\Saql\\Ast\\Pointcut.g:31:17: ':' array
{
DebugLocation(31, 17);
char_literal13 = (IToken)Match(input, 15, Follow._15_in_criteria166);
stream_15.Add(char_literal13);
DebugLocation(31, 21);
PushFollow(Follow._array_in_criteria168);
array14 = array();
PopFollow();
stream_array.Add(array14.Tree);
}
break;
}
} finally { DebugExitSubRule(6); }
}
{
// AST REWRITE
// elements: array, Identifier
// 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();
// 31:29: -> ^( CRITERIA Identifier ( array )? )
{
DebugLocation(31, 32);
// D:\\Dev\\Codeplex\\SheepAop\\SheepAspect\\Saql\\Ast\\Pointcut.g:31:32: ^( CRITERIA Identifier ( array )? )
{
object root_1 = (object)adaptor.Nil();
DebugLocation(31, 34);
root_1 = (object)adaptor.BecomeRoot((object)adaptor.Create(CRITERIA, "CRITERIA"), root_1);
DebugLocation(31, 43);
adaptor.AddChild(root_1, stream_Identifier.NextNode());
DebugLocation(31, 54);
// D:\\Dev\\Codeplex\\SheepAop\\SheepAspect\\Saql\\Ast\\Pointcut.g:31:54: ( array )?
if (stream_array.HasNext)
{
DebugLocation(31, 54);
adaptor.AddChild(root_1, stream_array.NextTree());
}
stream_array.Reset();
adaptor.AddChild(root_0, root_1);
}
}
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("criteria", 5);
LeaveRule("criteria", 5);
Leave_criteria();
}
DebugLocation(31, 60); } finally { DebugExitRule(GrammarFileName, "criteria"); }
return(retval);
}
private PointcutParser.atom_return atom()
{
Enter_atom();
EnterRule("atom", 6);
TraceIn("atom", 6);
PointcutParser.atom_return retval = new PointcutParser.atom_return();
retval.Start = (IToken)input.LT(1);
object root_0 = default(object);
IToken char_literal15 = null;
IToken Identifier16 = null;
IToken Value17 = null;
IToken char_literal18 = null;
IToken char_literal20 = null;
PointcutParser.compound_return compound19 = default(PointcutParser.compound_return);
object char_literal15_tree = default(object);
object Identifier16_tree = default(object);
object Value17_tree = default(object);
object char_literal18_tree = default(object);
object char_literal20_tree = default(object);
RewriteRuleITokenStream stream_16 = new RewriteRuleITokenStream(adaptor, "token 16");
RewriteRuleITokenStream stream_Identifier = new RewriteRuleITokenStream(adaptor, "token Identifier");
try { DebugEnterRule(GrammarFileName, "atom");
DebugLocation(33, 22);
try
{
// D:\\Dev\\Codeplex\\SheepAop\\SheepAspect\\Saql\\Ast\\Pointcut.g:33:6: ( '@' Identifier -> ^( POINTCUTREF Identifier ) | Value | '(' compound ')' )
int alt8 = 3;
try { DebugEnterDecision(8, decisionCanBacktrack[8]);
switch (input.LA(1))
{
case 16:
{
alt8 = 1;
}
break;
case Value:
{
alt8 = 2;
}
break;
case 17:
{
alt8 = 3;
}
break;
default:
{
NoViableAltException nvae = new NoViableAltException("", 8, 0, input);
DebugRecognitionException(nvae);
throw nvae;
}
}
} finally { DebugExitDecision(8); }
switch (alt8)
{
case 1:
DebugEnterAlt(1);
// D:\\Dev\\Codeplex\\SheepAop\\SheepAspect\\Saql\\Ast\\Pointcut.g:33:8: '@' Identifier
{
DebugLocation(33, 8);
char_literal15 = (IToken)Match(input, 16, Follow._16_in_atom190);
stream_16.Add(char_literal15);
DebugLocation(33, 12);
Identifier16 = (IToken)Match(input, Identifier, Follow._Identifier_in_atom192);
stream_Identifier.Add(Identifier16);
{
// AST REWRITE
// elements: Identifier
// 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();
// 33:23: -> ^( POINTCUTREF Identifier )
{
DebugLocation(33, 26);
// D:\\Dev\\Codeplex\\SheepAop\\SheepAspect\\Saql\\Ast\\Pointcut.g:33:26: ^( POINTCUTREF Identifier )
{
object root_1 = (object)adaptor.Nil();
DebugLocation(33, 28);
root_1 = (object)adaptor.BecomeRoot((object)adaptor.Create(POINTCUTREF, "POINTCUTREF"), root_1);
DebugLocation(33, 40);
adaptor.AddChild(root_1, stream_Identifier.NextNode());
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;
}
}
break;
case 2:
DebugEnterAlt(2);
// D:\\Dev\\Codeplex\\SheepAop\\SheepAspect\\Saql\\Ast\\Pointcut.g:34:5: Value
{
root_0 = (object)adaptor.Nil();
DebugLocation(34, 5);
Value17 = (IToken)Match(input, Value, Follow._Value_in_atom206);
Value17_tree = (object)adaptor.Create(Value17);
adaptor.AddChild(root_0, Value17_tree);
}
break;
case 3:
DebugEnterAlt(3);
// D:\\Dev\\Codeplex\\SheepAop\\SheepAspect\\Saql\\Ast\\Pointcut.g:35:5: '(' compound ')'
{
root_0 = (object)adaptor.Nil();
DebugLocation(35, 8);
char_literal18 = (IToken)Match(input, 17, Follow._17_in_atom213);
DebugLocation(35, 10);
PushFollow(Follow._compound_in_atom216);
compound19 = compound();
PopFollow();
adaptor.AddChild(root_0, compound19.Tree);
DebugLocation(35, 22);
char_literal20 = (IToken)Match(input, 18, Follow._18_in_atom218);
}
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("atom", 6);
LeaveRule("atom", 6);
Leave_atom();
}
DebugLocation(35, 22); } finally { DebugExitRule(GrammarFileName, "atom"); }
return(retval);
}
private AstParserRuleReturnScope <object, IToken> identifier()
{
EnterRule_identifier();
EnterRule("identifier", 5);
TraceIn("identifier", 5);
AstParserRuleReturnScope <object, IToken> retval = new AstParserRuleReturnScope <object, IToken>();
retval.Start = (IToken)input.LT(1);
object root_0 = default(object);
IToken ASTERISK12 = default(IToken);
AstParserRuleReturnScope <object, IToken> prefixedName11 = default(AstParserRuleReturnScope <object, IToken>);
object ASTERISK12_tree = default(object);
RewriteRuleITokenStream stream_ASTERISK = new RewriteRuleITokenStream(adaptor, "token ASTERISK");
RewriteRuleSubtreeStream stream_prefixedName = new RewriteRuleSubtreeStream(adaptor, "rule prefixedName");
try { DebugEnterRule(GrammarFileName, "identifier");
DebugLocation(56, 1);
try
{
// ../Grammars/OslcSelect.g:56:12: ( prefixedName -> ^( 'prefixed_name' prefixedName ) | ASTERISK -> ^( 'wildcard' ) )
int alt3 = 2;
try { DebugEnterDecision(3, false);
int LA3_1 = input.LA(1);
if (((LA3_1 >= PNAME_LN && LA3_1 <= PNAME_NS)))
{
alt3 = 1;
}
else if ((LA3_1 == ASTERISK))
{
alt3 = 2;
}
else
{
NoViableAltException nvae = new NoViableAltException("", 3, 0, input, 1);
DebugRecognitionException(nvae);
throw nvae;
} } finally { DebugExitDecision(3); }
switch (alt3)
{
case 1:
DebugEnterAlt(1);
// ../Grammars/OslcSelect.g:56:14: prefixedName
{
DebugLocation(56, 14);
PushFollow(Follow._prefixedName_in_identifier173);
prefixedName11 = prefixedName();
PopFollow();
stream_prefixedName.Add(prefixedName11.Tree);
{
// AST REWRITE
// elements: prefixedName, PREFIXED_NAME
// 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();
// 56:27: -> ^( 'prefixed_name' prefixedName )
{
DebugLocation(56, 30);
// ../Grammars/OslcSelect.g:56:30: ^( 'prefixed_name' prefixedName )
{
object root_1 = (object)adaptor.Nil();
DebugLocation(56, 33);
root_1 = (object)adaptor.BecomeRoot((object)adaptor.Create(PREFIXED_NAME, "PREFIXED_NAME"), root_1);
DebugLocation(56, 49);
adaptor.AddChild(root_1, stream_prefixedName.NextTree());
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;
}
}
break;
case 2:
DebugEnterAlt(2);
// ../Grammars/OslcSelect.g:57:7: ASTERISK
{
DebugLocation(57, 7);
ASTERISK12 = (IToken)Match(input, ASTERISK, Follow._ASTERISK_in_identifier191);
stream_ASTERISK.Add(ASTERISK12);
{
// AST REWRITE
// elements: WILDCARD
// 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();
// 57:16: -> ^( 'wildcard' )
{
DebugLocation(57, 19);
// ../Grammars/OslcSelect.g:57:19: ^( 'wildcard' )
{
object root_1 = (object)adaptor.Nil();
DebugLocation(57, 22);
root_1 = (object)adaptor.BecomeRoot((object)adaptor.Create(WILDCARD, "WILDCARD"), root_1);
adaptor.AddChild(root_0, root_1);
}
}
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("identifier", 5);
LeaveRule("identifier", 5);
LeaveRule_identifier();
}
DebugLocation(58, 1); } finally { DebugExitRule(GrammarFileName, "identifier"); }
return(retval);
}
private PointcutParser.array_return array()
{
Enter_array();
EnterRule("array", 3);
TraceIn("array", 3);
PointcutParser.array_return retval = new PointcutParser.array_return();
retval.Start = (IToken)input.LT(1);
object root_0 = default(object);
IToken char_literal7 = null;
PointcutParser.negation_return negation6 = default(PointcutParser.negation_return);
PointcutParser.negation_return negation8 = default(PointcutParser.negation_return);
object char_literal7_tree = default(object);
RewriteRuleITokenStream stream_14 = new RewriteRuleITokenStream(adaptor, "token 14");
RewriteRuleSubtreeStream stream_negation = new RewriteRuleSubtreeStream(adaptor, "rule negation");
try { DebugEnterRule(GrammarFileName, "array");
DebugLocation(23, 3);
try
{
// D:\\Dev\\Codeplex\\SheepAop\\SheepAspect\\Saql\\Ast\\Pointcut.g:23:7: ( negation ( ( ',' negation )+ -> ^( ARRAY ( negation )* ) | -> negation ) )
DebugEnterAlt(1);
// D:\\Dev\\Codeplex\\SheepAop\\SheepAspect\\Saql\\Ast\\Pointcut.g:23:9: negation ( ( ',' negation )+ -> ^( ARRAY ( negation )* ) | -> negation )
{
DebugLocation(23, 9);
PushFollow(Follow._negation_in_array100);
negation6 = negation();
PopFollow();
stream_negation.Add(negation6.Tree);
DebugLocation(23, 18);
// D:\\Dev\\Codeplex\\SheepAop\\SheepAspect\\Saql\\Ast\\Pointcut.g:23:18: ( ( ',' negation )+ -> ^( ARRAY ( negation )* ) | -> negation )
int alt4 = 2;
try { DebugEnterSubRule(4);
try { DebugEnterDecision(4, decisionCanBacktrack[4]);
int LA4_0 = input.LA(1);
if ((LA4_0 == 14))
{
alt4 = 1;
}
else if ((LA4_0 == EOF || (LA4_0 >= And && LA4_0 <= Or) || LA4_0 == 18))
{
alt4 = 2;
}
else
{
NoViableAltException nvae = new NoViableAltException("", 4, 0, input);
DebugRecognitionException(nvae);
throw nvae;
} } finally { DebugExitDecision(4); }
switch (alt4)
{
case 1:
DebugEnterAlt(1);
// D:\\Dev\\Codeplex\\SheepAop\\SheepAspect\\Saql\\Ast\\Pointcut.g:24:4: ( ',' negation )+
{
DebugLocation(24, 4);
// D:\\Dev\\Codeplex\\SheepAop\\SheepAspect\\Saql\\Ast\\Pointcut.g:24:4: ( ',' negation )+
int cnt3 = 0;
try { DebugEnterSubRule(3);
while (true)
{
int alt3 = 2;
try { DebugEnterDecision(3, decisionCanBacktrack[3]);
int LA3_0 = input.LA(1);
if ((LA3_0 == 14))
{
alt3 = 1;
}
} finally { DebugExitDecision(3); }
switch (alt3)
{
case 1:
DebugEnterAlt(1);
// D:\\Dev\\Codeplex\\SheepAop\\SheepAspect\\Saql\\Ast\\Pointcut.g:24:5: ',' negation
{
DebugLocation(24, 5);
char_literal7 = (IToken)Match(input, 14, Follow._14_in_array108);
stream_14.Add(char_literal7);
DebugLocation(24, 9);
PushFollow(Follow._negation_in_array110);
negation8 = negation();
PopFollow();
stream_negation.Add(negation8.Tree);
}
break;
default:
if (cnt3 >= 1)
{
goto loop3;
}
EarlyExitException eee3 = new EarlyExitException(3, input);
DebugRecognitionException(eee3);
throw eee3;
}
cnt3++;
}
loop3:
; } finally { DebugExitSubRule(3); }
{
// AST REWRITE
// elements: negation
// 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();
// 24:20: -> ^( ARRAY ( negation )* )
{
DebugLocation(24, 23);
// D:\\Dev\\Codeplex\\SheepAop\\SheepAspect\\Saql\\Ast\\Pointcut.g:24:23: ^( ARRAY ( negation )* )
{
object root_1 = (object)adaptor.Nil();
DebugLocation(24, 25);
root_1 = (object)adaptor.BecomeRoot((object)adaptor.Create(ARRAY, "ARRAY"), root_1);
DebugLocation(24, 31);
// D:\\Dev\\Codeplex\\SheepAop\\SheepAspect\\Saql\\Ast\\Pointcut.g:24:31: ( negation )*
while (stream_negation.HasNext)
{
DebugLocation(24, 31);
adaptor.AddChild(root_1, stream_negation.NextTree());
}
stream_negation.Reset();
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;
}
}
break;
case 2:
DebugEnterAlt(2);
// D:\\Dev\\Codeplex\\SheepAop\\SheepAspect\\Saql\\Ast\\Pointcut.g:25:7:
{
{
// AST REWRITE
// elements: negation
// 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();
// 25:7: -> negation
{
DebugLocation(25, 10);
adaptor.AddChild(root_0, stream_negation.NextTree());
}
retval.Tree = root_0;
}
}
break;
}
} finally { DebugExitSubRule(4); }
}
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("array", 3);
LeaveRule("array", 3);
Leave_array();
}
DebugLocation(26, 3); } finally { DebugExitRule(GrammarFileName, "array"); }
return(retval);
}
private AstParserRuleReturnScope <object, IToken> nested_property()
{
EnterRule_nested_property();
EnterRule("nested_property", 4);
TraceIn("nested_property", 4);
AstParserRuleReturnScope <object, IToken> retval = new AstParserRuleReturnScope <object, IToken>();
retval.Start = (IToken)input.LT(1);
object root_0 = default(object);
IToken OPEN_CURLY_BRACE8 = default(IToken);
IToken CLOSE_CURLY_BRACE10 = default(IToken);
AstParserRuleReturnScope <object, IToken> identifier7 = default(AstParserRuleReturnScope <object, IToken>);
AstParserRuleReturnScope <object, IToken> properties9 = default(AstParserRuleReturnScope <object, IToken>);
object OPEN_CURLY_BRACE8_tree = default(object);
object CLOSE_CURLY_BRACE10_tree = default(object);
RewriteRuleITokenStream stream_CLOSE_CURLY_BRACE = new RewriteRuleITokenStream(adaptor, "token CLOSE_CURLY_BRACE");
RewriteRuleITokenStream stream_OPEN_CURLY_BRACE = new RewriteRuleITokenStream(adaptor, "token OPEN_CURLY_BRACE");
RewriteRuleSubtreeStream stream_properties = new RewriteRuleSubtreeStream(adaptor, "rule properties");
RewriteRuleSubtreeStream stream_identifier = new RewriteRuleSubtreeStream(adaptor, "rule identifier");
try { DebugEnterRule(GrammarFileName, "nested_property");
DebugLocation(53, 1);
try
{
// ../Grammars/OslcSelect.g:53:17: ( identifier OPEN_CURLY_BRACE properties CLOSE_CURLY_BRACE -> ^( 'nested_property' identifier properties ) )
DebugEnterAlt(1);
// ../Grammars/OslcSelect.g:53:19: identifier OPEN_CURLY_BRACE properties CLOSE_CURLY_BRACE
{
DebugLocation(53, 19);
PushFollow(Follow._identifier_in_nested_property145);
identifier7 = identifier();
PopFollow();
stream_identifier.Add(identifier7.Tree);
DebugLocation(53, 30);
OPEN_CURLY_BRACE8 = (IToken)Match(input, OPEN_CURLY_BRACE, Follow._OPEN_CURLY_BRACE_in_nested_property147);
stream_OPEN_CURLY_BRACE.Add(OPEN_CURLY_BRACE8);
DebugLocation(53, 47);
PushFollow(Follow._properties_in_nested_property149);
properties9 = properties();
PopFollow();
stream_properties.Add(properties9.Tree);
DebugLocation(53, 58);
CLOSE_CURLY_BRACE10 = (IToken)Match(input, CLOSE_CURLY_BRACE, Follow._CLOSE_CURLY_BRACE_in_nested_property151);
stream_CLOSE_CURLY_BRACE.Add(CLOSE_CURLY_BRACE10);
{
// AST REWRITE
// elements: properties, NESTED_PROPERTIES, identifier
// 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();
// 53:76: -> ^( 'nested_property' identifier properties )
{
DebugLocation(53, 79);
// ../Grammars/OslcSelect.g:53:79: ^( 'nested_property' identifier properties )
{
object root_1 = (object)adaptor.Nil();
DebugLocation(53, 82);
root_1 = (object)adaptor.BecomeRoot((object)adaptor.Create(NESTED_PROPERTIES, "NESTED_PROPERTIES"), root_1);
DebugLocation(53, 100);
adaptor.AddChild(root_1, stream_identifier.NextTree());
DebugLocation(53, 111);
adaptor.AddChild(root_1, stream_properties.NextTree());
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;
}
}
retval.Stop = (IToken)input.LT(-1);
retval.Tree = (object)adaptor.RulePostProcessing(root_0);
adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
}
catch (RecognitionException re)
{
ReportError(re);
Recover(input, re);
retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);
}
finally
{
TraceOut("nested_property", 4);
LeaveRule("nested_property", 4);
LeaveRule_nested_property();
}
DebugLocation(54, 1); } finally { DebugExitRule(GrammarFileName, "nested_property"); }
return(retval);
}
private AstParserRuleReturnScope <object, IToken> properties()
{
EnterRule_properties();
EnterRule("properties", 2);
TraceIn("properties", 2);
AstParserRuleReturnScope <object, IToken> retval = new AstParserRuleReturnScope <object, IToken>();
retval.Start = (IToken)input.LT(1);
object root_0 = default(object);
IToken char_literal3 = default(IToken);
AstParserRuleReturnScope <object, IToken> property2 = default(AstParserRuleReturnScope <object, IToken>);
AstParserRuleReturnScope <object, IToken> property4 = default(AstParserRuleReturnScope <object, IToken>);
object char_literal3_tree = default(object);
RewriteRuleITokenStream stream_COMMA = new RewriteRuleITokenStream(adaptor, "token COMMA");
RewriteRuleSubtreeStream stream_property = new RewriteRuleSubtreeStream(adaptor, "rule property");
try { DebugEnterRule(GrammarFileName, "properties");
DebugLocation(47, 1);
try
{
// ../Grammars/OslcSelect.g:47:12: ( property ( ',' property )* -> ^( 'properties' property ( property )* ) )
DebugEnterAlt(1);
// ../Grammars/OslcSelect.g:47:14: property ( ',' property )*
{
DebugLocation(47, 14);
PushFollow(Follow._property_in_properties88);
property2 = property();
PopFollow();
stream_property.Add(property2.Tree);
DebugLocation(47, 24);
// ../Grammars/OslcSelect.g:47:24: ( ',' property )*
try { DebugEnterSubRule(1);
while (true)
{
int alt1 = 2;
try { DebugEnterDecision(1, false);
int LA1_1 = input.LA(1);
if ((LA1_1 == COMMA))
{
alt1 = 1;
}
} finally { DebugExitDecision(1); }
switch (alt1)
{
case 1:
DebugEnterAlt(1);
// ../Grammars/OslcSelect.g:47:26: ',' property
{
DebugLocation(47, 26);
char_literal3 = (IToken)Match(input, COMMA, Follow._COMMA_in_properties93);
stream_COMMA.Add(char_literal3);
DebugLocation(47, 30);
PushFollow(Follow._property_in_properties95);
property4 = property();
PopFollow();
stream_property.Add(property4.Tree);
}
break;
default:
goto loop1;
}
}
loop1:
; } finally { DebugExitSubRule(1); }
{
// AST REWRITE
// elements: PROPERTIES, property, property
// 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();
// 47:43: -> ^( 'properties' property ( property )* )
{
DebugLocation(47, 46);
// ../Grammars/OslcSelect.g:47:46: ^( 'properties' property ( property )* )
{
object root_1 = (object)adaptor.Nil();
DebugLocation(47, 49);
root_1 = (object)adaptor.BecomeRoot((object)adaptor.Create(PROPERTIES, "PROPERTIES"), root_1);
DebugLocation(47, 62);
adaptor.AddChild(root_1, stream_property.NextTree());
DebugLocation(47, 71);
// ../Grammars/OslcSelect.g:47:71: ( property )*
while (stream_property.HasNext)
{
DebugLocation(47, 72);
adaptor.AddChild(root_1, stream_property.NextTree());
}
stream_property.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("properties", 2);
LeaveRule("properties", 2);
LeaveRule_properties();
}
DebugLocation(48, 1); } finally { DebugExitRule(GrammarFileName, "properties"); }
return(retval);
}
private AstParserRuleReturnScope <object, IToken> oslc_search_terms()
{
EnterRule_oslc_search_terms();
EnterRule("oslc_search_terms", 1);
TraceIn("oslc_search_terms", 1);
AstParserRuleReturnScope <object, IToken> retval = new AstParserRuleReturnScope <object, IToken>();
retval.Start = (IToken)input.LT(1);
object root_0 = default(object);
IToken char_literal2 = default(IToken);
AstParserRuleReturnScope <object, IToken> string_esc1 = default(AstParserRuleReturnScope <object, IToken>);
AstParserRuleReturnScope <object, IToken> string_esc3 = default(AstParserRuleReturnScope <object, IToken>);
object char_literal2_tree = default(object);
RewriteRuleITokenStream stream_COMMA = new RewriteRuleITokenStream(adaptor, "token COMMA");
RewriteRuleSubtreeStream stream_string_esc = new RewriteRuleSubtreeStream(adaptor, "rule string_esc");
try { DebugEnterRule(GrammarFileName, "oslc_search_terms");
DebugLocation(41, 1);
try
{
// ../Grammars/OslcSearchTerms.g:41:22: ( string_esc ( ',' string_esc )* -> ^( 'string_list' string_esc ( string_esc )* ) )
DebugEnterAlt(1);
// ../Grammars/OslcSearchTerms.g:41:24: string_esc ( ',' string_esc )*
{
DebugLocation(41, 24);
PushFollow(Follow._string_esc_in_oslc_search_terms60);
string_esc1 = string_esc();
PopFollow();
stream_string_esc.Add(string_esc1.Tree);
DebugLocation(41, 35);
// ../Grammars/OslcSearchTerms.g:41:35: ( ',' string_esc )*
try { DebugEnterSubRule(1);
while (true)
{
int alt1 = 2;
try { DebugEnterDecision(1, false);
int LA1_1 = input.LA(1);
if ((LA1_1 == COMMA))
{
alt1 = 1;
}
} finally { DebugExitDecision(1); }
switch (alt1)
{
case 1:
DebugEnterAlt(1);
// ../Grammars/OslcSearchTerms.g:41:37: ',' string_esc
{
DebugLocation(41, 37);
char_literal2 = (IToken)Match(input, COMMA, Follow._COMMA_in_oslc_search_terms64);
stream_COMMA.Add(char_literal2);
DebugLocation(41, 41);
PushFollow(Follow._string_esc_in_oslc_search_terms66);
string_esc3 = string_esc();
PopFollow();
stream_string_esc.Add(string_esc3.Tree);
}
break;
default:
goto loop1;
}
}
loop1:
; } finally { DebugExitSubRule(1); }
{
// AST REWRITE
// elements: string_esc, STRING_LIST, string_esc
// 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();
// 41:55: -> ^( 'string_list' string_esc ( string_esc )* )
{
DebugLocation(41, 58);
// ../Grammars/OslcSearchTerms.g:41:58: ^( 'string_list' string_esc ( string_esc )* )
{
object root_1 = (object)adaptor.Nil();
DebugLocation(41, 60);
root_1 = (object)adaptor.BecomeRoot((object)adaptor.Create(STRING_LIST, "STRING_LIST"), root_1);
DebugLocation(41, 74);
adaptor.AddChild(root_1, stream_string_esc.NextTree());
DebugLocation(41, 85);
// ../Grammars/OslcSearchTerms.g:41:85: ( string_esc )*
while (stream_string_esc.HasNext)
{
DebugLocation(41, 86);
adaptor.AddChild(root_1, stream_string_esc.NextTree());
}
stream_string_esc.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("oslc_search_terms", 1);
LeaveRule("oslc_search_terms", 1);
LeaveRule_oslc_search_terms();
}
DebugLocation(42, 1); } finally { DebugExitRule(GrammarFileName, "oslc_search_terms"); }
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;
}
private AstParserRuleReturnScope <object, IToken> oslc_prefixes()
{
EnterRule_oslc_prefixes();
EnterRule("oslc_prefixes", 1);
TraceIn("oslc_prefixes", 1);
AstParserRuleReturnScope <object, IToken> retval = new AstParserRuleReturnScope <object, IToken>();
retval.Start = (IToken)input.LT(1);
object root_0 = default(object);
IToken char_literal2 = default(IToken);
AstParserRuleReturnScope <object, IToken> prefix_binding1 = default(AstParserRuleReturnScope <object, IToken>);
AstParserRuleReturnScope <object, IToken> prefix_binding3 = default(AstParserRuleReturnScope <object, IToken>);
object char_literal2_tree = default(object);
RewriteRuleITokenStream stream_COMMA = new RewriteRuleITokenStream(adaptor, "token COMMA");
RewriteRuleSubtreeStream stream_prefix_binding = new RewriteRuleSubtreeStream(adaptor, "rule prefix_binding");
try { DebugEnterRule(GrammarFileName, "oslc_prefixes");
DebugLocation(43, 1);
try
{
// ../Grammars/OslcPrefix.g:43:18: ( prefix_binding ( ',' prefix_binding )* -> ^( 'prefix_list' prefix_binding ( prefix_binding )* ) )
DebugEnterAlt(1);
// ../Grammars/OslcPrefix.g:43:20: prefix_binding ( ',' prefix_binding )*
{
DebugLocation(43, 20);
PushFollow(Follow._prefix_binding_in_oslc_prefixes69);
prefix_binding1 = prefix_binding();
PopFollow();
stream_prefix_binding.Add(prefix_binding1.Tree);
DebugLocation(43, 35);
// ../Grammars/OslcPrefix.g:43:35: ( ',' prefix_binding )*
try { DebugEnterSubRule(1);
while (true)
{
int alt1 = 2;
try { DebugEnterDecision(1, false);
int LA1_1 = input.LA(1);
if ((LA1_1 == COMMA))
{
alt1 = 1;
}
} finally { DebugExitDecision(1); }
switch (alt1)
{
case 1:
DebugEnterAlt(1);
// ../Grammars/OslcPrefix.g:43:37: ',' prefix_binding
{
DebugLocation(43, 37);
char_literal2 = (IToken)Match(input, COMMA, Follow._COMMA_in_oslc_prefixes73);
stream_COMMA.Add(char_literal2);
DebugLocation(43, 41);
PushFollow(Follow._prefix_binding_in_oslc_prefixes75);
prefix_binding3 = prefix_binding();
PopFollow();
stream_prefix_binding.Add(prefix_binding3.Tree);
}
break;
default:
goto loop1;
}
}
loop1:
; } finally { DebugExitSubRule(1); }
{
// AST REWRITE
// elements: prefix_binding, PREFIX_LIST, prefix_binding
// 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();
// 43:59: -> ^( 'prefix_list' prefix_binding ( prefix_binding )* )
{
DebugLocation(43, 62);
// ../Grammars/OslcPrefix.g:43:62: ^( 'prefix_list' prefix_binding ( prefix_binding )* )
{
object root_1 = (object)adaptor.Nil();
DebugLocation(43, 65);
root_1 = (object)adaptor.BecomeRoot((object)adaptor.Create(PREFIX_LIST, "PREFIX_LIST"), root_1);
DebugLocation(43, 79);
adaptor.AddChild(root_1, stream_prefix_binding.NextTree());
DebugLocation(43, 94);
// ../Grammars/OslcPrefix.g:43:94: ( prefix_binding )*
while (stream_prefix_binding.HasNext)
{
DebugLocation(43, 95);
adaptor.AddChild(root_1, stream_prefix_binding.NextTree());
}
stream_prefix_binding.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("oslc_prefixes", 1);
LeaveRule("oslc_prefixes", 1);
LeaveRule_oslc_prefixes();
}
DebugLocation(44, 1); } finally { DebugExitRule(GrammarFileName, "oslc_prefixes"); }
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> prefix_binding()
{
EnterRule_prefix_binding();
EnterRule("prefix_binding", 2);
TraceIn("prefix_binding", 2);
AstParserRuleReturnScope <object, IToken> retval = new AstParserRuleReturnScope <object, IToken>();
retval.Start = (IToken)input.LT(1);
object root_0 = default(object);
IToken PN_PREFIX4 = default(IToken);
IToken char_literal5 = default(IToken);
IToken IRI_REF6 = default(IToken);
object PN_PREFIX4_tree = default(object);
object char_literal5_tree = default(object);
object IRI_REF6_tree = default(object);
RewriteRuleITokenStream stream_PN_PREFIX = new RewriteRuleITokenStream(adaptor, "token PN_PREFIX");
RewriteRuleITokenStream stream_IRI_REF = new RewriteRuleITokenStream(adaptor, "token IRI_REF");
RewriteRuleITokenStream stream_21 = new RewriteRuleITokenStream(adaptor, "token 21");
try { DebugEnterRule(GrammarFileName, "prefix_binding");
DebugLocation(46, 4);
try
{
// ../Grammars/OslcPrefix.g:46:16: ( PN_PREFIX '=' IRI_REF -> ^( 'prefix' PN_PREFIX IRI_REF ) )
DebugEnterAlt(1);
// ../Grammars/OslcPrefix.g:46:18: PN_PREFIX '=' IRI_REF
{
DebugLocation(46, 18);
PN_PREFIX4 = (IToken)Match(input, PN_PREFIX, Follow._PN_PREFIX_in_prefix_binding105);
stream_PN_PREFIX.Add(PN_PREFIX4);
DebugLocation(46, 28);
char_literal5 = (IToken)Match(input, 21, Follow._21_in_prefix_binding107);
stream_21.Add(char_literal5);
DebugLocation(46, 32);
IRI_REF6 = (IToken)Match(input, IRI_REF, Follow._IRI_REF_in_prefix_binding109);
stream_IRI_REF.Add(IRI_REF6);
{
// AST REWRITE
// elements: IRI_REF, PREFIX, PN_PREFIX
// 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();
// 46:40: -> ^( 'prefix' PN_PREFIX IRI_REF )
{
DebugLocation(46, 43);
// ../Grammars/OslcPrefix.g:46:43: ^( 'prefix' PN_PREFIX IRI_REF )
{
object root_1 = (object)adaptor.Nil();
DebugLocation(46, 46);
root_1 = (object)adaptor.BecomeRoot((object)adaptor.Create(PREFIX, "PREFIX"), root_1);
DebugLocation(46, 55);
adaptor.AddChild(root_1, stream_PN_PREFIX.NextNode());
DebugLocation(46, 65);
adaptor.AddChild(root_1, stream_IRI_REF.NextNode());
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("prefix_binding", 2);
LeaveRule("prefix_binding", 2);
LeaveRule_prefix_binding();
}
DebugLocation(47, 4); } finally { DebugExitRule(GrammarFileName, "prefix_binding"); }
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 "funcwithparams"
// abevformula.g:24:0: funcwithparams : '[' func ',' paramlist ']' -> ^( FUNC func paramlist ) ;
private abevformulaParser.funcwithparams_return funcwithparams( )
{
abevformulaParser.funcwithparams_return retval = new abevformulaParser.funcwithparams_return();
retval.start = input.LT(1);
int funcwithparams_StartIndex = input.Index;
CommonTree root_0 = null;
IToken char_literal2 = null;
IToken char_literal4 = null;
IToken char_literal6 = null;
abevformulaParser.func_return func3 = default(abevformulaParser.func_return);
abevformulaParser.paramlist_return paramlist5 = default(abevformulaParser.paramlist_return);
CommonTree char_literal2_tree = null;
CommonTree char_literal4_tree = null;
CommonTree char_literal6_tree = null;
RewriteRuleITokenStream stream_9 = new RewriteRuleITokenStream(adaptor, "token 9");
RewriteRuleITokenStream stream_8 = new RewriteRuleITokenStream(adaptor, "token 8");
RewriteRuleITokenStream stream_10 = new RewriteRuleITokenStream(adaptor, "token 10");
RewriteRuleSubtreeStream stream_func = new RewriteRuleSubtreeStream(adaptor, "rule func");
RewriteRuleSubtreeStream stream_paramlist = new RewriteRuleSubtreeStream(adaptor, "rule paramlist");
try
{
if (state.backtracking > 0 && AlreadyParsedRule(input, 2))
{
return(retval);
}
// abevformula.g:24:18: ( '[' func ',' paramlist ']' -> ^( FUNC func paramlist ) )
// abevformula.g:24:18: '[' func ',' paramlist ']'
{
char_literal2 = (IToken)Match(input, 9, Follow._9_in_funcwithparams109); if (state.failed)
{
return(retval);
}
if (state.backtracking == 0)
{
stream_9.Add(char_literal2);
}
PushFollow(Follow._func_in_funcwithparams111);
func3 = func();
state._fsp--;
if (state.failed)
{
return(retval);
}
if (state.backtracking == 0)
{
stream_func.Add(func3.Tree);
}
char_literal4 = (IToken)Match(input, 8, Follow._8_in_funcwithparams113); if (state.failed)
{
return(retval);
}
if (state.backtracking == 0)
{
stream_8.Add(char_literal4);
}
PushFollow(Follow._paramlist_in_funcwithparams115);
paramlist5 = paramlist();
state._fsp--;
if (state.failed)
{
return(retval);
}
if (state.backtracking == 0)
{
stream_paramlist.Add(paramlist5.Tree);
}
char_literal6 = (IToken)Match(input, 10, Follow._10_in_funcwithparams117); if (state.failed)
{
return(retval);
}
if (state.backtracking == 0)
{
stream_10.Add(char_literal6);
}
{
// AST REWRITE
// elements: func, paramlist
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
if (state.backtracking == 0)
{
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null?retval.tree:null);
root_0 = (CommonTree)adaptor.Nil();
// 24:45: -> ^( FUNC func paramlist )
{
// abevformula.g:24:48: ^( FUNC func paramlist )
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(FUNC, "FUNC"), root_1);
adaptor.AddChild(root_1, stream_func.NextTree());
adaptor.AddChild(root_1, stream_paramlist.NextTree());
adaptor.AddChild(root_0, root_1);
}
}
retval.tree = root_0;
}
}
}
retval.stop = input.LT(-1);
if (state.backtracking == 0)
{
retval.tree = (CommonTree)adaptor.RulePostProcessing(root_0);
adaptor.SetTokenBoundaries(retval.tree, retval.start, retval.stop);
}
}
catch (RecognitionException re)
{
ReportError(re);
Recover(input, re);
retval.tree = (CommonTree)adaptor.ErrorNode(input, retval.start, input.LT(-1), re);
}
finally
{
if (state.backtracking > 0)
{
Memoize(input, 2, funcwithparams_StartIndex);
}
}
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 "paramlist"
// abevformula.g:26:0: paramlist : param ( ',' param )* -> ( param )+ ;
private abevformulaParser.paramlist_return paramlist( )
{
abevformulaParser.paramlist_return retval = new abevformulaParser.paramlist_return();
retval.start = input.LT(1);
int paramlist_StartIndex = input.Index;
CommonTree root_0 = null;
IToken char_literal9 = null;
abevformulaParser.param_return param8 = default(abevformulaParser.param_return);
abevformulaParser.param_return param10 = default(abevformulaParser.param_return);
CommonTree char_literal9_tree = null;
RewriteRuleITokenStream stream_8 = new RewriteRuleITokenStream(adaptor, "token 8");
RewriteRuleSubtreeStream stream_param = new RewriteRuleSubtreeStream(adaptor, "rule param");
try
{
if (state.backtracking > 0 && AlreadyParsedRule(input, 4))
{
return(retval);
}
// abevformula.g:26:13: ( param ( ',' param )* -> ( param )+ )
// abevformula.g:26:13: param ( ',' param )*
{
PushFollow(Follow._param_in_paramlist143);
param8 = param();
state._fsp--;
if (state.failed)
{
return(retval);
}
if (state.backtracking == 0)
{
stream_param.Add(param8.Tree);
}
// abevformula.g:26:19: ( ',' param )*
for ( ; ;)
{
int alt1 = 2;
int LA1_0 = input.LA(1);
if ((LA1_0 == 8))
{
alt1 = 1;
}
switch (alt1)
{
case 1:
// abevformula.g:26:20: ',' param
{
char_literal9 = (IToken)Match(input, 8, Follow._8_in_paramlist146); if (state.failed)
{
return(retval);
}
if (state.backtracking == 0)
{
stream_8.Add(char_literal9);
}
PushFollow(Follow._param_in_paramlist148);
param10 = param();
state._fsp--;
if (state.failed)
{
return(retval);
}
if (state.backtracking == 0)
{
stream_param.Add(param10.Tree);
}
}
break;
default:
goto loop1;
}
}
loop1:
;
{
// AST REWRITE
// elements: param
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
if (state.backtracking == 0)
{
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null?retval.tree:null);
root_0 = (CommonTree)adaptor.Nil();
// 26:32: -> ( param )+
{
if (!(stream_param.HasNext))
{
throw new RewriteEarlyExitException();
}
while (stream_param.HasNext)
{
adaptor.AddChild(root_0, stream_param.NextTree());
}
stream_param.Reset();
}
retval.tree = root_0;
}
}
}
retval.stop = input.LT(-1);
if (state.backtracking == 0)
{
retval.tree = (CommonTree)adaptor.RulePostProcessing(root_0);
adaptor.SetTokenBoundaries(retval.tree, retval.start, retval.stop);
}
}
catch (RecognitionException re)
{
ReportError(re);
Recover(input, re);
retval.tree = (CommonTree)adaptor.ErrorNode(input, retval.start, input.LT(-1), re);
}
finally
{
if (state.backtracking > 0)
{
Memoize(input, 4, paramlist_StartIndex);
}
}
return(retval);
}
private AstParserRuleReturnScope <object, IToken> plain_elem()
{
EnterRule_plain_elem();
EnterRule("plain_elem", 5);
TraceIn("plain_elem", 5);
AstParserRuleReturnScope <object, IToken> retval = new AstParserRuleReturnScope <object, IToken>();
retval.Start = (IToken)input.LT(1);
object root_0 = default(object);
IToken i1 = default(IToken);
IToken i2 = default(IToken);
IToken al = default(IToken);
IToken ID12 = default(IToken);
IToken FROM13 = default(IToken);
IToken TO14 = default(IToken);
IToken ID15 = default(IToken);
IToken LENGTH16 = default(IToken);
object i1_tree = default(object);
object i2_tree = default(object);
object al_tree = default(object);
object ID12_tree = default(object);
object FROM13_tree = default(object);
object TO14_tree = default(object);
object ID15_tree = default(object);
object LENGTH16_tree = default(object);
RewriteRuleITokenStream stream_INT = new RewriteRuleITokenStream(adaptor, "token INT");
RewriteRuleITokenStream stream_ALIGN_RIGHT = new RewriteRuleITokenStream(adaptor, "token ALIGN_RIGHT");
RewriteRuleITokenStream stream_ID = new RewriteRuleITokenStream(adaptor, "token ID");
RewriteRuleITokenStream stream_FROM = new RewriteRuleITokenStream(adaptor, "token FROM");
RewriteRuleITokenStream stream_TO = new RewriteRuleITokenStream(adaptor, "token TO");
RewriteRuleITokenStream stream_ALIGN_LEFT = new RewriteRuleITokenStream(adaptor, "token ALIGN_LEFT");
RewriteRuleITokenStream stream_LENGTH = new RewriteRuleITokenStream(adaptor, "token LENGTH");
try { DebugEnterRule(GrammarFileName, "plain_elem");
DebugLocation(47, 2);
try
{
// C:\\Users\\franz\\SkyDrive\\Dokumente\\workspace\\TextTable\\src\\eu\\reitmayer\\texttable\\lang\\TextTable.g:47:11: ( ID FROM i1= INT TO i2= INT (al= ALIGN_LEFT |al= ALIGN_RIGHT )? -> ^( ID $i1 $i2 ( $al)? ) | ID LENGTH i1= INT (al= ALIGN_LEFT |al= ALIGN_RIGHT )? -> ^( ID $i1 ( $al)? ) )
int alt5 = 2;
try { DebugEnterDecision(5, false);
int LA5_0 = input.LA(1);
if ((LA5_0 == ID))
{
int LA5_1 = input.LA(2);
if ((LA5_1 == FROM))
{
alt5 = 1;
}
else if ((LA5_1 == LENGTH))
{
alt5 = 2;
}
else
{
NoViableAltException nvae = new NoViableAltException("", 5, 1, input);
DebugRecognitionException(nvae);
throw nvae;
}
}
else
{
NoViableAltException nvae = new NoViableAltException("", 5, 0, input);
DebugRecognitionException(nvae);
throw nvae;
} } finally { DebugExitDecision(5); }
switch (alt5)
{
case 1:
DebugEnterAlt(1);
// C:\\Users\\franz\\SkyDrive\\Dokumente\\workspace\\TextTable\\src\\eu\\reitmayer\\texttable\\lang\\TextTable.g:48:3: ID FROM i1= INT TO i2= INT (al= ALIGN_LEFT |al= ALIGN_RIGHT )?
{
DebugLocation(48, 3);
ID12 = (IToken)Match(input, ID, Follow._ID_in_plain_elem181);
stream_ID.Add(ID12);
DebugLocation(48, 6);
FROM13 = (IToken)Match(input, FROM, Follow._FROM_in_plain_elem183);
stream_FROM.Add(FROM13);
DebugLocation(48, 13);
i1 = (IToken)Match(input, INT, Follow._INT_in_plain_elem187);
stream_INT.Add(i1);
DebugLocation(48, 18);
TO14 = (IToken)Match(input, TO, Follow._TO_in_plain_elem189);
stream_TO.Add(TO14);
DebugLocation(48, 23);
i2 = (IToken)Match(input, INT, Follow._INT_in_plain_elem193);
stream_INT.Add(i2);
DebugLocation(48, 28);
// C:\\Users\\franz\\SkyDrive\\Dokumente\\workspace\\TextTable\\src\\eu\\reitmayer\\texttable\\lang\\TextTable.g:48:28: (al= ALIGN_LEFT |al= ALIGN_RIGHT )?
int alt3 = 3;
try { DebugEnterSubRule(3);
try { DebugEnterDecision(3, false);
int LA3_0 = input.LA(1);
if ((LA3_0 == ALIGN_LEFT))
{
alt3 = 1;
}
else if ((LA3_0 == ALIGN_RIGHT))
{
alt3 = 2;
}
} finally { DebugExitDecision(3); }
switch (alt3)
{
case 1:
DebugEnterAlt(1);
// C:\\Users\\franz\\SkyDrive\\Dokumente\\workspace\\TextTable\\src\\eu\\reitmayer\\texttable\\lang\\TextTable.g:48:29: al= ALIGN_LEFT
{
DebugLocation(48, 31);
al = (IToken)Match(input, ALIGN_LEFT, Follow._ALIGN_LEFT_in_plain_elem198);
stream_ALIGN_LEFT.Add(al);
}
break;
case 2:
DebugEnterAlt(2);
// C:\\Users\\franz\\SkyDrive\\Dokumente\\workspace\\TextTable\\src\\eu\\reitmayer\\texttable\\lang\\TextTable.g:48:45: al= ALIGN_RIGHT
{
DebugLocation(48, 47);
al = (IToken)Match(input, ALIGN_RIGHT, Follow._ALIGN_RIGHT_in_plain_elem204);
stream_ALIGN_RIGHT.Add(al);
}
break;
}
} finally { DebugExitSubRule(3); }
{
// AST REWRITE
// elements: i2, ID, al, i1
// token labels: al, i2, i1
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.Tree = root_0;
RewriteRuleITokenStream stream_al = new RewriteRuleITokenStream(adaptor, "token al", al);
RewriteRuleITokenStream stream_i2 = new RewriteRuleITokenStream(adaptor, "token i2", i2);
RewriteRuleITokenStream stream_i1 = new RewriteRuleITokenStream(adaptor, "token i1", i1);
RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null?retval.Tree:null);
root_0 = (object)adaptor.Nil();
// 48:62: -> ^( ID $i1 $i2 ( $al)? )
{
DebugLocation(48, 65);
// C:\\Users\\franz\\SkyDrive\\Dokumente\\workspace\\TextTable\\src\\eu\\reitmayer\\texttable\\lang\\TextTable.g:48:65: ^( ID $i1 $i2 ( $al)? )
{
object root_1 = (object)adaptor.Nil();
DebugLocation(48, 67);
root_1 = (object)adaptor.BecomeRoot(stream_ID.NextNode(), root_1);
DebugLocation(48, 71);
adaptor.AddChild(root_1, stream_i1.NextNode());
DebugLocation(48, 75);
adaptor.AddChild(root_1, stream_i2.NextNode());
DebugLocation(48, 79);
// C:\\Users\\franz\\SkyDrive\\Dokumente\\workspace\\TextTable\\src\\eu\\reitmayer\\texttable\\lang\\TextTable.g:48:79: ( $al)?
if (stream_al.HasNext)
{
DebugLocation(48, 79);
adaptor.AddChild(root_1, stream_al.NextNode());
}
stream_al.Reset();
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;
}
}
break;
case 2:
DebugEnterAlt(2);
// C:\\Users\\franz\\SkyDrive\\Dokumente\\workspace\\TextTable\\src\\eu\\reitmayer\\texttable\\lang\\TextTable.g:50:3: ID LENGTH i1= INT (al= ALIGN_LEFT |al= ALIGN_RIGHT )?
{
DebugLocation(50, 3);
ID15 = (IToken)Match(input, ID, Follow._ID_in_plain_elem230);
stream_ID.Add(ID15);
DebugLocation(50, 6);
LENGTH16 = (IToken)Match(input, LENGTH, Follow._LENGTH_in_plain_elem232);
stream_LENGTH.Add(LENGTH16);
DebugLocation(50, 15);
i1 = (IToken)Match(input, INT, Follow._INT_in_plain_elem236);
stream_INT.Add(i1);
DebugLocation(50, 20);
// C:\\Users\\franz\\SkyDrive\\Dokumente\\workspace\\TextTable\\src\\eu\\reitmayer\\texttable\\lang\\TextTable.g:50:20: (al= ALIGN_LEFT |al= ALIGN_RIGHT )?
int alt4 = 3;
try { DebugEnterSubRule(4);
try { DebugEnterDecision(4, false);
int LA4_0 = input.LA(1);
if ((LA4_0 == ALIGN_LEFT))
{
alt4 = 1;
}
else if ((LA4_0 == ALIGN_RIGHT))
{
alt4 = 2;
}
} finally { DebugExitDecision(4); }
switch (alt4)
{
case 1:
DebugEnterAlt(1);
// C:\\Users\\franz\\SkyDrive\\Dokumente\\workspace\\TextTable\\src\\eu\\reitmayer\\texttable\\lang\\TextTable.g:50:21: al= ALIGN_LEFT
{
DebugLocation(50, 23);
al = (IToken)Match(input, ALIGN_LEFT, Follow._ALIGN_LEFT_in_plain_elem241);
stream_ALIGN_LEFT.Add(al);
}
break;
case 2:
DebugEnterAlt(2);
// C:\\Users\\franz\\SkyDrive\\Dokumente\\workspace\\TextTable\\src\\eu\\reitmayer\\texttable\\lang\\TextTable.g:50:37: al= ALIGN_RIGHT
{
DebugLocation(50, 39);
al = (IToken)Match(input, ALIGN_RIGHT, Follow._ALIGN_RIGHT_in_plain_elem247);
stream_ALIGN_RIGHT.Add(al);
}
break;
}
} finally { DebugExitSubRule(4); }
{
// AST REWRITE
// elements: i1, al, ID
// token labels: al, i1
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.Tree = root_0;
RewriteRuleITokenStream stream_al = new RewriteRuleITokenStream(adaptor, "token al", al);
RewriteRuleITokenStream stream_i1 = new RewriteRuleITokenStream(adaptor, "token i1", i1);
RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null?retval.Tree:null);
root_0 = (object)adaptor.Nil();
// 50:54: -> ^( ID $i1 ( $al)? )
{
DebugLocation(50, 57);
// C:\\Users\\franz\\SkyDrive\\Dokumente\\workspace\\TextTable\\src\\eu\\reitmayer\\texttable\\lang\\TextTable.g:50:57: ^( ID $i1 ( $al)? )
{
object root_1 = (object)adaptor.Nil();
DebugLocation(50, 59);
root_1 = (object)adaptor.BecomeRoot(stream_ID.NextNode(), root_1);
DebugLocation(50, 63);
adaptor.AddChild(root_1, stream_i1.NextNode());
DebugLocation(50, 67);
// C:\\Users\\franz\\SkyDrive\\Dokumente\\workspace\\TextTable\\src\\eu\\reitmayer\\texttable\\lang\\TextTable.g:50:67: ( $al)?
if (stream_al.HasNext)
{
DebugLocation(50, 67);
adaptor.AddChild(root_1, stream_al.NextNode());
}
stream_al.Reset();
adaptor.AddChild(root_0, root_1);
}
}
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("plain_elem", 5);
LeaveRule("plain_elem", 5);
LeaveRule_plain_elem();
}
DebugLocation(51, 2); } finally { DebugExitRule(GrammarFileName, "plain_elem"); }
return(retval);
}
private AstParserRuleReturnScope <object, IToken> sort_terms()
{
EnterRule_sort_terms();
EnterRule("sort_terms", 2);
TraceIn("sort_terms", 2);
AstParserRuleReturnScope <object, IToken> retval = new AstParserRuleReturnScope <object, IToken>();
retval.Start = (IToken)input.LT(1);
object root_0 = default(object);
IToken char_literal3 = default(IToken);
AstParserRuleReturnScope <object, IToken> sort_term2 = default(AstParserRuleReturnScope <object, IToken>);
AstParserRuleReturnScope <object, IToken> sort_term4 = default(AstParserRuleReturnScope <object, IToken>);
object char_literal3_tree = default(object);
RewriteRuleITokenStream stream_COMMA = new RewriteRuleITokenStream(adaptor, "token COMMA");
RewriteRuleSubtreeStream stream_sort_term = new RewriteRuleSubtreeStream(adaptor, "rule sort_term");
try
{
DebugEnterRule(GrammarFileName, "sort_terms");
DebugLocation(46, 1);
try
{
// ../Grammars/OslcOrderBy.g:46:13: ( sort_term ( ',' sort_term )* -> ^( 'terms' sort_term ( sort_term )* ) )
DebugEnterAlt(1);
// ../Grammars/OslcOrderBy.g:46:15: sort_term ( ',' sort_term )*
{
DebugLocation(46, 15);
PushFollow(Follow._sort_term_in_sort_terms82);
sort_term2 = sort_term();
PopFollow();
stream_sort_term.Add(sort_term2.Tree);
DebugLocation(46, 25);
// ../Grammars/OslcOrderBy.g:46:25: ( ',' sort_term )*
try
{
DebugEnterSubRule(1);
while (true)
{
int alt1 = 2;
try
{
DebugEnterDecision(1, false);
int LA1_1 = input.LA(1);
if ((LA1_1 == COMMA))
{
alt1 = 1;
}
}
finally { DebugExitDecision(1); }
switch (alt1)
{
case 1:
DebugEnterAlt(1);
// ../Grammars/OslcOrderBy.g:46:27: ',' sort_term
{
DebugLocation(46, 27);
char_literal3 = (IToken)Match(input, COMMA, Follow._COMMA_in_sort_terms86);
stream_COMMA.Add(char_literal3);
DebugLocation(46, 31);
PushFollow(Follow._sort_term_in_sort_terms88);
sort_term4 = sort_term();
PopFollow();
stream_sort_term.Add(sort_term4.Tree);
}
break;
default:
goto loop1;
}
}
loop1:
;
}
finally { DebugExitSubRule(1); }
{
// AST REWRITE
// elements: sort_term, sort_term, TERMS
// 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();
// 46:45: -> ^( 'terms' sort_term ( sort_term )* )
{
DebugLocation(46, 48);
// ../Grammars/OslcOrderBy.g:46:48: ^( 'terms' sort_term ( sort_term )* )
{
object root_1 = (object)adaptor.Nil();
DebugLocation(46, 51);
root_1 = (object)adaptor.BecomeRoot((object)adaptor.Create(TERMS, "TERMS"), root_1);
DebugLocation(46, 59);
adaptor.AddChild(root_1, stream_sort_term.NextTree());
DebugLocation(46, 69);
// ../Grammars/OslcOrderBy.g:46:69: ( sort_term )*
while (stream_sort_term.HasNext)
{
DebugLocation(46, 70);
adaptor.AddChild(root_1, stream_sort_term.NextTree());
}
stream_sort_term.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("sort_terms", 2);
LeaveRule("sort_terms", 2);
LeaveRule_sort_terms();
}
DebugLocation(47, 1);
}
finally { DebugExitRule(GrammarFileName, "sort_terms"); }
return(retval);
}
private AstParserRuleReturnScope<CommonTree, IToken> doWhileStatement()
{
EnterRule_doWhileStatement();
EnterRule("doWhileStatement", 68);
TraceIn("doWhileStatement", 68);
AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>();
retval.Start = (IToken)input.LT(1);
CommonTree root_0 = default(CommonTree);
IToken DO218 = default(IToken);
IToken WHILE220 = default(IToken);
AstParserRuleReturnScope<CommonTree, IToken> statement219 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> condition221 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> semi222 = default(AstParserRuleReturnScope<CommonTree, IToken>);
CommonTree DO218_tree = default(CommonTree);
CommonTree WHILE220_tree = default(CommonTree);
RewriteRuleITokenStream stream_DO=new RewriteRuleITokenStream(adaptor,"token DO");
RewriteRuleITokenStream stream_WHILE=new RewriteRuleITokenStream(adaptor,"token WHILE");
RewriteRuleSubtreeStream stream_statement=new RewriteRuleSubtreeStream(adaptor,"rule statement");
RewriteRuleSubtreeStream stream_condition=new RewriteRuleSubtreeStream(adaptor,"rule condition");
RewriteRuleSubtreeStream stream_semi=new RewriteRuleSubtreeStream(adaptor,"rule semi");
try { DebugEnterRule(GrammarFileName, "doWhileStatement");
DebugLocation(553, 1);
try
{
// AS3.g:554:2: ( DO statement WHILE condition semi -> ^( DO_WHILE_LOOP DO statement WHILE condition ) )
DebugEnterAlt(1);
// AS3.g:554:4: DO statement WHILE condition semi
{
DebugLocation(554, 4);
DO218=(IToken)Match(input,DO,Follow._DO_in_doWhileStatement2989); if (state.failed) return retval;
if (state.backtracking == 0) stream_DO.Add(DO218);
DebugLocation(554, 7);
PushFollow(Follow._statement_in_doWhileStatement2991);
statement219=statement();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_statement.Add(statement219.Tree);
DebugLocation(554, 17);
WHILE220=(IToken)Match(input,WHILE,Follow._WHILE_in_doWhileStatement2993); if (state.failed) return retval;
if (state.backtracking == 0) stream_WHILE.Add(WHILE220);
DebugLocation(554, 23);
PushFollow(Follow._condition_in_doWhileStatement2995);
condition221=condition();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_condition.Add(condition221.Tree);
DebugLocation(554, 33);
PushFollow(Follow._semi_in_doWhileStatement2997);
semi222=semi();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_semi.Add(semi222.Tree);
{
// AST REWRITE
// elements: DO, statement, WHILE, condition
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
if (state.backtracking == 0) {
retval.Tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.Tree:null);
root_0 = (CommonTree)adaptor.Nil();
// 555:3: -> ^( DO_WHILE_LOOP DO statement WHILE condition )
{
DebugLocation(555, 6);
// AS3.g:555:6: ^( DO_WHILE_LOOP DO statement WHILE condition )
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(555, 8);
root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(DO_WHILE_LOOP, "DO_WHILE_LOOP"), root_1);
DebugLocation(555, 22);
adaptor.AddChild(root_1, stream_DO.NextNode());
DebugLocation(555, 25);
adaptor.AddChild(root_1, stream_statement.NextTree());
DebugLocation(555, 35);
adaptor.AddChild(root_1, stream_WHILE.NextNode());
DebugLocation(555, 41);
adaptor.AddChild(root_1, stream_condition.NextTree());
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;
}
}
}
retval.Stop = (IToken)input.LT(-1);
if (state.backtracking == 0) {
retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
}
}
catch (RecognitionException re)
{
ReportError(re);
Recover(input,re);
retval.Tree = (CommonTree)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);
}
finally
{
TraceOut("doWhileStatement", 68);
LeaveRule("doWhileStatement", 68);
LeaveRule_doWhileStatement();
}
DebugLocation(556, 1);
} finally { DebugExitRule(GrammarFileName, "doWhileStatement"); }
return retval;
}
private AstParserRuleReturnScope <object, IToken> sort_term()
{
EnterRule_sort_term();
EnterRule("sort_term", 3);
TraceIn("sort_term", 3);
AstParserRuleReturnScope <object, IToken> retval = new AstParserRuleReturnScope <object, IToken>();
retval.Start = (IToken)input.LT(1);
object root_0 = default(object);
IToken DIRECTION6 = default(IToken);
AstParserRuleReturnScope <object, IToken> scoped_sort_term5 = default(AstParserRuleReturnScope <object, IToken>);
AstParserRuleReturnScope <object, IToken> identifier7 = default(AstParserRuleReturnScope <object, IToken>);
object DIRECTION6_tree = default(object);
RewriteRuleITokenStream stream_DIRECTION = new RewriteRuleITokenStream(adaptor, "token DIRECTION");
RewriteRuleSubtreeStream stream_identifier = new RewriteRuleSubtreeStream(adaptor, "rule identifier");
try
{
DebugEnterRule(GrammarFileName, "sort_term");
DebugLocation(49, 1);
try
{
// ../Grammars/OslcOrderBy.g:49:13: ( scoped_sort_term | DIRECTION identifier -> ^( 'simple_term' identifier DIRECTION ) )
int alt2 = 2;
try
{
DebugEnterDecision(2, false);
int LA2_1 = input.LA(1);
if (((LA2_1 >= PNAME_LN && LA2_1 <= PNAME_NS)))
{
alt2 = 1;
}
else if ((LA2_1 == DIRECTION))
{
alt2 = 2;
}
else
{
NoViableAltException nvae = new NoViableAltException("", 2, 0, input, 1);
DebugRecognitionException(nvae);
throw nvae;
}
}
finally { DebugExitDecision(2); }
switch (alt2)
{
case 1:
DebugEnterAlt(1);
// ../Grammars/OslcOrderBy.g:49:15: scoped_sort_term
{
root_0 = (object)adaptor.Nil();
DebugLocation(49, 15);
PushFollow(Follow._scoped_sort_term_in_sort_term120);
scoped_sort_term5 = scoped_sort_term();
PopFollow();
adaptor.AddChild(root_0, scoped_sort_term5.Tree);
}
break;
case 2:
DebugEnterAlt(2);
// ../Grammars/OslcOrderBy.g:49:34: DIRECTION identifier
{
DebugLocation(49, 34);
DIRECTION6 = (IToken)Match(input, DIRECTION, Follow._DIRECTION_in_sort_term124);
stream_DIRECTION.Add(DIRECTION6);
DebugLocation(49, 44);
PushFollow(Follow._identifier_in_sort_term126);
identifier7 = identifier();
PopFollow();
stream_identifier.Add(identifier7.Tree);
{
// AST REWRITE
// elements: identifier, DIRECTION, SIMPLE_TERM
// 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();
// 49:55: -> ^( 'simple_term' identifier DIRECTION )
{
DebugLocation(49, 58);
// ../Grammars/OslcOrderBy.g:49:58: ^( 'simple_term' identifier DIRECTION )
{
object root_1 = (object)adaptor.Nil();
DebugLocation(49, 61);
root_1 = (object)adaptor.BecomeRoot((object)adaptor.Create(SIMPLE_TERM, "SIMPLE_TERM"), root_1);
DebugLocation(49, 75);
adaptor.AddChild(root_1, stream_identifier.NextTree());
DebugLocation(49, 86);
adaptor.AddChild(root_1, stream_DIRECTION.NextNode());
adaptor.AddChild(root_0, root_1);
}
}
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("sort_term", 3);
LeaveRule("sort_term", 3);
LeaveRule_sort_term();
}
DebugLocation(50, 1);
}
finally { DebugExitRule(GrammarFileName, "sort_term"); }
return(retval);
}
private AstParserRuleReturnScope<CommonTree, IToken> typeExpression()
{
EnterRule_typeExpression();
EnterRule("typeExpression", 71);
TraceIn("typeExpression", 71);
AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>();
retval.Start = (IToken)input.LT(1);
CommonTree root_0 = default(CommonTree);
IToken COLON232 = default(IToken);
IToken string_literal234 = default(IToken);
IToken STAR235 = default(IToken);
AstParserRuleReturnScope<CommonTree, IToken> typeIdentifier233 = default(AstParserRuleReturnScope<CommonTree, IToken>);
CommonTree COLON232_tree = default(CommonTree);
CommonTree string_literal234_tree = default(CommonTree);
CommonTree STAR235_tree = default(CommonTree);
RewriteRuleITokenStream stream_COLON=new RewriteRuleITokenStream(adaptor,"token COLON");
RewriteRuleITokenStream stream_257=new RewriteRuleITokenStream(adaptor,"token 257");
RewriteRuleITokenStream stream_STAR=new RewriteRuleITokenStream(adaptor,"token STAR");
RewriteRuleSubtreeStream stream_typeIdentifier=new RewriteRuleSubtreeStream(adaptor,"rule typeIdentifier");
try { DebugEnterRule(GrammarFileName, "typeExpression");
DebugLocation(567, 4);
try
{
// AS3.g:568:2: ( COLON ( typeIdentifier | 'void' | STAR ) -> ^( TYPE_SPEC COLON ( typeIdentifier )? ( 'void' )? ( STAR )? ) )
DebugEnterAlt(1);
// AS3.g:569:3: COLON ( typeIdentifier | 'void' | STAR )
{
DebugLocation(569, 3);
COLON232=(IToken)Match(input,COLON,Follow._COLON_in_typeExpression3075); if (state.failed) return retval;
if (state.backtracking == 0) stream_COLON.Add(COLON232);
DebugLocation(569, 9);
// AS3.g:569:9: ( typeIdentifier | 'void' | STAR )
int alt49=3;
try { DebugEnterSubRule(49);
try { DebugEnterDecision(49, false);
switch (input.LA(1))
{
case AS:
case DYNAMIC:
case GET:
case IDENT:
case IS:
case NAMESPACE:
case SET:
case SUPER:
case USE:
case XML:
{
alt49 = 1;
}
break;
case 257:
{
alt49 = 2;
}
break;
case STAR:
{
alt49 = 3;
}
break;
default:
{
if (state.backtracking>0) {state.failed=true; return retval;}
NoViableAltException nvae = new NoViableAltException("", 49, 0, input, 1);
DebugRecognitionException(nvae);
throw nvae;
}
}
} finally { DebugExitDecision(49); }
switch (alt49)
{
case 1:
DebugEnterAlt(1);
// AS3.g:569:10: typeIdentifier
{
DebugLocation(569, 10);
PushFollow(Follow._typeIdentifier_in_typeExpression3078);
typeIdentifier233=typeIdentifier();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_typeIdentifier.Add(typeIdentifier233.Tree);
}
break;
case 2:
DebugEnterAlt(2);
// AS3.g:569:27: 'void'
{
DebugLocation(569, 27);
string_literal234=(IToken)Match(input,257,Follow._257_in_typeExpression3082); if (state.failed) return retval;
if (state.backtracking == 0) stream_257.Add(string_literal234);
}
break;
case 3:
DebugEnterAlt(3);
// AS3.g:569:36: STAR
{
DebugLocation(569, 36);
STAR235=(IToken)Match(input,STAR,Follow._STAR_in_typeExpression3086); if (state.failed) return retval;
if (state.backtracking == 0) stream_STAR.Add(STAR235);
}
break;
}
} finally { DebugExitSubRule(49); }
{
// AST REWRITE
// elements: COLON, typeIdentifier, 257, STAR
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
if (state.backtracking == 0) {
retval.Tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.Tree:null);
root_0 = (CommonTree)adaptor.Nil();
// 570:3: -> ^( TYPE_SPEC COLON ( typeIdentifier )? ( 'void' )? ( STAR )? )
{
DebugLocation(570, 6);
// AS3.g:570:6: ^( TYPE_SPEC COLON ( typeIdentifier )? ( 'void' )? ( STAR )? )
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(570, 8);
root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(TYPE_SPEC, "TYPE_SPEC"), root_1);
DebugLocation(570, 18);
adaptor.AddChild(root_1, stream_COLON.NextNode());
DebugLocation(570, 24);
// AS3.g:570:24: ( typeIdentifier )?
if (stream_typeIdentifier.HasNext)
{
DebugLocation(570, 24);
adaptor.AddChild(root_1, stream_typeIdentifier.NextTree());
}
stream_typeIdentifier.Reset();
DebugLocation(570, 40);
// AS3.g:570:40: ( 'void' )?
if (stream_257.HasNext)
{
DebugLocation(570, 40);
adaptor.AddChild(root_1, stream_257.NextNode());
}
stream_257.Reset();
DebugLocation(570, 48);
// AS3.g:570:48: ( STAR )?
if (stream_STAR.HasNext)
{
DebugLocation(570, 48);
adaptor.AddChild(root_1, stream_STAR.NextNode());
}
stream_STAR.Reset();
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;
}
}
}
retval.Stop = (IToken)input.LT(-1);
if (state.backtracking == 0) {
retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
}
}
catch (RecognitionException re)
{
ReportError(re);
Recover(input,re);
retval.Tree = (CommonTree)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);
}
finally
{
TraceOut("typeExpression", 71);
LeaveRule("typeExpression", 71);
LeaveRule_typeExpression();
}
DebugLocation(571, 4);
} finally { DebugExitRule(GrammarFileName, "typeExpression"); }
return retval;
}
private AstParserRuleReturnScope <object, IToken> scoped_sort_term()
{
EnterRule_scoped_sort_term();
EnterRule("scoped_sort_term", 4);
TraceIn("scoped_sort_term", 4);
AstParserRuleReturnScope <object, IToken> retval = new AstParserRuleReturnScope <object, IToken>();
retval.Start = (IToken)input.LT(1);
object root_0 = default(object);
IToken char_literal9 = default(IToken);
IToken char_literal11 = default(IToken);
AstParserRuleReturnScope <object, IToken> identifier8 = default(AstParserRuleReturnScope <object, IToken>);
AstParserRuleReturnScope <object, IToken> sort_terms10 = default(AstParserRuleReturnScope <object, IToken>);
object char_literal9_tree = default(object);
object char_literal11_tree = default(object);
RewriteRuleITokenStream stream_CLOSE_CURLY_BRACE = new RewriteRuleITokenStream(adaptor, "token CLOSE_CURLY_BRACE");
RewriteRuleITokenStream stream_OPEN_CURLY_BRACE = new RewriteRuleITokenStream(adaptor, "token OPEN_CURLY_BRACE");
RewriteRuleSubtreeStream stream_sort_terms = new RewriteRuleSubtreeStream(adaptor, "rule sort_terms");
RewriteRuleSubtreeStream stream_identifier = new RewriteRuleSubtreeStream(adaptor, "rule identifier");
try
{
DebugEnterRule(GrammarFileName, "scoped_sort_term");
DebugLocation(52, 4);
try
{
// ../Grammars/OslcOrderBy.g:52:18: ( identifier '{' sort_terms '}' -> ^( 'scoped_term' identifier sort_terms ) )
DebugEnterAlt(1);
// ../Grammars/OslcOrderBy.g:52:20: identifier '{' sort_terms '}'
{
DebugLocation(52, 20);
PushFollow(Follow._identifier_in_scoped_sort_term148);
identifier8 = identifier();
PopFollow();
stream_identifier.Add(identifier8.Tree);
DebugLocation(52, 31);
char_literal9 = (IToken)Match(input, OPEN_CURLY_BRACE, Follow._OPEN_CURLY_BRACE_in_scoped_sort_term150);
stream_OPEN_CURLY_BRACE.Add(char_literal9);
DebugLocation(52, 35);
PushFollow(Follow._sort_terms_in_scoped_sort_term152);
sort_terms10 = sort_terms();
PopFollow();
stream_sort_terms.Add(sort_terms10.Tree);
DebugLocation(52, 46);
char_literal11 = (IToken)Match(input, CLOSE_CURLY_BRACE, Follow._CLOSE_CURLY_BRACE_in_scoped_sort_term154);
stream_CLOSE_CURLY_BRACE.Add(char_literal11);
{
// AST REWRITE
// elements: SCOPED_TERM, identifier, sort_terms
// 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();
// 52:50: -> ^( 'scoped_term' identifier sort_terms )
{
DebugLocation(52, 53);
// ../Grammars/OslcOrderBy.g:52:53: ^( 'scoped_term' identifier sort_terms )
{
object root_1 = (object)adaptor.Nil();
DebugLocation(52, 56);
root_1 = (object)adaptor.BecomeRoot((object)adaptor.Create(SCOPED_TERM, "SCOPED_TERM"), root_1);
DebugLocation(52, 70);
adaptor.AddChild(root_1, stream_identifier.NextTree());
DebugLocation(52, 81);
adaptor.AddChild(root_1, stream_sort_terms.NextTree());
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;
}
}
retval.Stop = (IToken)input.LT(-1);
retval.Tree = (object)adaptor.RulePostProcessing(root_0);
adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
}
catch (RecognitionException re)
{
ReportError(re);
Recover(input, re);
retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);
}
finally
{
TraceOut("scoped_sort_term", 4);
LeaveRule("scoped_sort_term", 4);
LeaveRule_scoped_sort_term();
}
DebugLocation(53, 4);
}
finally { DebugExitRule(GrammarFileName, "scoped_sort_term"); }
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;
}
private AstParserRuleReturnScope<CommonTree, IToken> returnStatement()
{
EnterRule_returnStatement();
EnterRule("returnStatement", 50);
TraceIn("returnStatement", 50);
AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>();
retval.Start = (IToken)input.LT(1);
CommonTree root_0 = default(CommonTree);
IToken RETURN168 = default(IToken);
AstParserRuleReturnScope<CommonTree, IToken> s = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> expression169 = default(AstParserRuleReturnScope<CommonTree, IToken>);
CommonTree RETURN168_tree = default(CommonTree);
RewriteRuleITokenStream stream_RETURN=new RewriteRuleITokenStream(adaptor,"token RETURN");
RewriteRuleSubtreeStream stream_expression=new RewriteRuleSubtreeStream(adaptor,"rule expression");
RewriteRuleSubtreeStream stream_semi=new RewriteRuleSubtreeStream(adaptor,"rule semi");
try { DebugEnterRule(GrammarFileName, "returnStatement");
DebugLocation(450, 1);
try
{
// AS3.g:451:2: ( RETURN ( expression )? s= semi -> ^( RETURN_STATEMENT RETURN ( expression )? ) )
DebugEnterAlt(1);
// AS3.g:451:4: RETURN ( expression )? s= semi
{
DebugLocation(451, 4);
RETURN168=(IToken)Match(input,RETURN,Follow._RETURN_in_returnStatement2421); if (state.failed) return retval;
if (state.backtracking == 0) stream_RETURN.Add(RETURN168);
DebugLocation(451, 11);
// AS3.g:451:11: ( expression )?
int alt39=2;
try { DebugEnterSubRule(39);
try { DebugEnterDecision(39, false);
int LA39_1 = input.LA(1);
if ((LA39_1==AS||LA39_1==BNOT||(LA39_1>=DEC && LA39_1<=DECIMAL_LITERAL)||(LA39_1>=DYNAMIC && LA39_1<=E4X_ATTRI)||(LA39_1>=FALSE && LA39_1<=FLOAT_LITERAL)||LA39_1==FUNCTION||LA39_1==GET||(LA39_1>=HEX_LITERAL && LA39_1<=IDENT)||LA39_1==INC||(LA39_1>=INTERNAL && LA39_1<=IS)||(LA39_1>=LBRACK && LA39_1<=LCURLY)||LA39_1==LNOT||LA39_1==LPAREN||LA39_1==MINUS||LA39_1==NAMESPACE||LA39_1==NEW||LA39_1==NULL||LA39_1==OCTAL_LITERAL||LA39_1==PLUS||LA39_1==PRIVATE||(LA39_1>=PROTECTED && LA39_1<=PUBLIC)||LA39_1==REGEX_LITERAL||LA39_1==SET||(LA39_1>=STRING_LITERAL_DOUBLE && LA39_1<=SUPER)||LA39_1==TRUE||LA39_1==USE||LA39_1==XML||LA39_1==XML_LITERAL||LA39_1==243||(LA39_1>=255 && LA39_1<=257)))
{
alt39 = 1;
}
} finally { DebugExitDecision(39); }
switch (alt39)
{
case 1:
DebugEnterAlt(1);
// AS3.g:451:11: expression
{
DebugLocation(451, 11);
PushFollow(Follow._expression_in_returnStatement2423);
expression169=expression();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_expression.Add(expression169.Tree);
}
break;
}
} finally { DebugExitSubRule(39); }
DebugLocation(451, 24);
PushFollow(Follow._semi_in_returnStatement2428);
s=semi();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_semi.Add(s.Tree);
{
// AST REWRITE
// elements: RETURN, expression
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
if (state.backtracking == 0) {
retval.Tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.Tree:null);
root_0 = (CommonTree)adaptor.Nil();
// 452:9: -> ^( RETURN_STATEMENT RETURN ( expression )? )
{
DebugLocation(452, 12);
// AS3.g:452:12: ^( RETURN_STATEMENT RETURN ( expression )? )
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(452, 14);
root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(RETURN_STATEMENT, "RETURN_STATEMENT"), root_1);
DebugLocation(452, 31);
adaptor.AddChild(root_1, stream_RETURN.NextNode());
DebugLocation(452, 38);
// AS3.g:452:38: ( expression )?
if (stream_expression.HasNext)
{
DebugLocation(452, 38);
adaptor.AddChild(root_1, stream_expression.NextTree());
}
stream_expression.Reset();
DebugLocation(452, 50);
adaptor.AddChild(root_1, maybeSemi(s));
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;
}
}
}
retval.Stop = (IToken)input.LT(-1);
if (state.backtracking == 0) {
retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
}
}
catch (RecognitionException re)
{
ReportError(re);
Recover(input,re);
retval.Tree = (CommonTree)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);
}
finally
{
TraceOut("returnStatement", 50);
LeaveRule("returnStatement", 50);
LeaveRule_returnStatement();
}
DebugLocation(453, 1);
} finally { DebugExitRule(GrammarFileName, "returnStatement"); }
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;
}
private AstParserRuleReturnScope<CommonTree, IToken> continueStatement()
{
EnterRule_continueStatement();
EnterRule("continueStatement", 51);
TraceIn("continueStatement", 51);
AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>();
retval.Start = (IToken)input.LT(1);
CommonTree root_0 = default(CommonTree);
IToken CONTINUE170 = default(IToken);
AstParserRuleReturnScope<CommonTree, IToken> s = default(AstParserRuleReturnScope<CommonTree, IToken>);
CommonTree CONTINUE170_tree = default(CommonTree);
RewriteRuleITokenStream stream_CONTINUE=new RewriteRuleITokenStream(adaptor,"token CONTINUE");
RewriteRuleSubtreeStream stream_semi=new RewriteRuleSubtreeStream(adaptor,"rule semi");
try { DebugEnterRule(GrammarFileName, "continueStatement");
DebugLocation(455, 1);
try
{
// AS3.g:456:2: ( CONTINUE s= semi -> ^( CONTINUE_STATEMENT CONTINUE ) )
DebugEnterAlt(1);
// AS3.g:456:4: CONTINUE s= semi
{
DebugLocation(456, 4);
CONTINUE170=(IToken)Match(input,CONTINUE,Follow._CONTINUE_in_continueStatement2462); if (state.failed) return retval;
if (state.backtracking == 0) stream_CONTINUE.Add(CONTINUE170);
DebugLocation(456, 14);
PushFollow(Follow._semi_in_continueStatement2466);
s=semi();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_semi.Add(s.Tree);
{
// AST REWRITE
// elements: CONTINUE
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
if (state.backtracking == 0) {
retval.Tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.Tree:null);
root_0 = (CommonTree)adaptor.Nil();
// 457:9: -> ^( CONTINUE_STATEMENT CONTINUE )
{
DebugLocation(457, 12);
// AS3.g:457:12: ^( CONTINUE_STATEMENT CONTINUE )
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(457, 14);
root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(CONTINUE_STATEMENT, "CONTINUE_STATEMENT"), root_1);
DebugLocation(457, 33);
adaptor.AddChild(root_1, stream_CONTINUE.NextNode());
DebugLocation(457, 42);
adaptor.AddChild(root_1, maybeSemi(s));
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;
}
}
}
retval.Stop = (IToken)input.LT(-1);
if (state.backtracking == 0) {
retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
}
}
catch (RecognitionException re)
{
ReportError(re);
Recover(input,re);
retval.Tree = (CommonTree)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);
}
finally
{
TraceOut("continueStatement", 51);
LeaveRule("continueStatement", 51);
LeaveRule_continueStatement();
}
DebugLocation(458, 1);
} finally { DebugExitRule(GrammarFileName, "continueStatement"); }
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<CommonTree, IToken> breakStatement()
{
EnterRule_breakStatement();
EnterRule("breakStatement", 52);
TraceIn("breakStatement", 52);
AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>();
retval.Start = (IToken)input.LT(1);
CommonTree root_0 = default(CommonTree);
IToken BREAK171 = default(IToken);
AstParserRuleReturnScope<CommonTree, IToken> s = default(AstParserRuleReturnScope<CommonTree, IToken>);
CommonTree BREAK171_tree = default(CommonTree);
RewriteRuleITokenStream stream_BREAK=new RewriteRuleITokenStream(adaptor,"token BREAK");
RewriteRuleSubtreeStream stream_semi=new RewriteRuleSubtreeStream(adaptor,"rule semi");
try { DebugEnterRule(GrammarFileName, "breakStatement");
DebugLocation(460, 1);
try
{
// AS3.g:461:2: ( BREAK s= semi -> ^( BREAK_STATEMENT BREAK ) )
DebugEnterAlt(1);
// AS3.g:461:4: BREAK s= semi
{
DebugLocation(461, 4);
BREAK171=(IToken)Match(input,BREAK,Follow._BREAK_in_breakStatement2495); if (state.failed) return retval;
if (state.backtracking == 0) stream_BREAK.Add(BREAK171);
DebugLocation(461, 11);
PushFollow(Follow._semi_in_breakStatement2499);
s=semi();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_semi.Add(s.Tree);
{
// AST REWRITE
// elements: BREAK
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
if (state.backtracking == 0) {
retval.Tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.Tree:null);
root_0 = (CommonTree)adaptor.Nil();
// 462:9: -> ^( BREAK_STATEMENT BREAK )
{
DebugLocation(462, 12);
// AS3.g:462:12: ^( BREAK_STATEMENT BREAK )
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(462, 14);
root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(BREAK_STATEMENT, "BREAK_STATEMENT"), root_1);
DebugLocation(462, 30);
adaptor.AddChild(root_1, stream_BREAK.NextNode());
DebugLocation(462, 36);
adaptor.AddChild(root_1, maybeSemi(s));
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;
}
}
}
retval.Stop = (IToken)input.LT(-1);
if (state.backtracking == 0) {
retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
}
}
catch (RecognitionException re)
{
ReportError(re);
Recover(input,re);
retval.Tree = (CommonTree)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);
}
finally
{
TraceOut("breakStatement", 52);
LeaveRule("breakStatement", 52);
LeaveRule_breakStatement();
}
DebugLocation(463, 1);
} finally { DebugExitRule(GrammarFileName, "breakStatement"); }
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<CommonTree, IToken> switchStatement()
{
EnterRule_switchStatement();
EnterRule("switchStatement", 53);
TraceIn("switchStatement", 53);
AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>();
retval.Start = (IToken)input.LT(1);
CommonTree root_0 = default(CommonTree);
IToken SWITCH172 = default(IToken);
AstParserRuleReturnScope<CommonTree, IToken> condition173 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> switchBlock174 = default(AstParserRuleReturnScope<CommonTree, IToken>);
CommonTree SWITCH172_tree = default(CommonTree);
RewriteRuleITokenStream stream_SWITCH=new RewriteRuleITokenStream(adaptor,"token SWITCH");
RewriteRuleSubtreeStream stream_condition=new RewriteRuleSubtreeStream(adaptor,"rule condition");
RewriteRuleSubtreeStream stream_switchBlock=new RewriteRuleSubtreeStream(adaptor,"rule switchBlock");
try { DebugEnterRule(GrammarFileName, "switchStatement");
DebugLocation(465, 1);
try
{
// AS3.g:466:2: ( SWITCH condition switchBlock -> ^( SWITCH_STATEMENT SWITCH condition switchBlock ) )
DebugEnterAlt(1);
// AS3.g:466:4: SWITCH condition switchBlock
{
DebugLocation(466, 4);
SWITCH172=(IToken)Match(input,SWITCH,Follow._SWITCH_in_switchStatement2528); if (state.failed) return retval;
if (state.backtracking == 0) stream_SWITCH.Add(SWITCH172);
DebugLocation(466, 11);
PushFollow(Follow._condition_in_switchStatement2530);
condition173=condition();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_condition.Add(condition173.Tree);
DebugLocation(467, 3);
PushFollow(Follow._switchBlock_in_switchStatement2534);
switchBlock174=switchBlock();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_switchBlock.Add(switchBlock174.Tree);
{
// AST REWRITE
// elements: SWITCH, condition, switchBlock
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
if (state.backtracking == 0) {
retval.Tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.Tree:null);
root_0 = (CommonTree)adaptor.Nil();
// 468:9: -> ^( SWITCH_STATEMENT SWITCH condition switchBlock )
{
DebugLocation(468, 12);
// AS3.g:468:12: ^( SWITCH_STATEMENT SWITCH condition switchBlock )
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(468, 14);
root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(SWITCH_STATEMENT, "SWITCH_STATEMENT"), root_1);
DebugLocation(468, 31);
adaptor.AddChild(root_1, stream_SWITCH.NextNode());
DebugLocation(468, 38);
adaptor.AddChild(root_1, stream_condition.NextTree());
DebugLocation(468, 48);
adaptor.AddChild(root_1, stream_switchBlock.NextTree());
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;
}
}
}
retval.Stop = (IToken)input.LT(-1);
if (state.backtracking == 0) {
retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
}
}
catch (RecognitionException re)
{
ReportError(re);
Recover(input,re);
retval.Tree = (CommonTree)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);
}
finally
{
TraceOut("switchStatement", 53);
LeaveRule("switchStatement", 53);
LeaveRule_switchStatement();
}
DebugLocation(469, 1);
} finally { DebugExitRule(GrammarFileName, "switchStatement"); }
return retval;
}
// $ANTLR start "classDeclaration"
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:79:1: classDeclaration : 'class' name ( baseClassDeclaration )? classStatementBlock -> ^( CLASS name ( baseClassDeclaration )? classStatementBlock ) ;
public classDeclaration_return classDeclaration() // throws RecognitionException [1]
{
var retval = new classDeclaration_return();
retval.Start = input.LT( 1 );
CommonTree root_0 = null;
IToken string_literal4 = null;
name_return name5 = default( name_return );
baseClassDeclaration_return baseClassDeclaration6 = default( baseClassDeclaration_return );
classStatementBlock_return classStatementBlock7 = default( classStatementBlock_return );
CommonTree string_literal4_tree = null;
var stream_57 = new RewriteRuleTokenStream( adaptor, "token 57" );
var stream_classStatementBlock = new RewriteRuleSubtreeStream( adaptor, "rule classStatementBlock" );
var stream_name = new RewriteRuleSubtreeStream( adaptor, "rule name" );
var stream_baseClassDeclaration = new RewriteRuleSubtreeStream( adaptor, "rule baseClassDeclaration" );
try
{
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:80:2: ( 'class' name ( baseClassDeclaration )? classStatementBlock -> ^( CLASS name ( baseClassDeclaration )? classStatementBlock ) )
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:80:4: 'class' name ( baseClassDeclaration )? classStatementBlock
{
string_literal4 = (IToken)Match( input, 57, FOLLOW_57_in_classDeclaration262 );
stream_57.Add( string_literal4 );
PushFollow( FOLLOW_name_in_classDeclaration264 );
name5 = name();
state.followingStackPointer--;
stream_name.Add( name5.Tree );
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:80:17: ( baseClassDeclaration )?
int alt3 = 2;
int LA3_0 = input.LA( 1 );
if ( ( LA3_0 == 58 ) )
alt3 = 1;
switch ( alt3 )
{
case 1:
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:80:17: baseClassDeclaration
{
PushFollow( FOLLOW_baseClassDeclaration_in_classDeclaration266 );
baseClassDeclaration6 = baseClassDeclaration();
state.followingStackPointer--;
stream_baseClassDeclaration.Add( baseClassDeclaration6.Tree );
}
break;
}
PushFollow( FOLLOW_classStatementBlock_in_classDeclaration269 );
classStatementBlock7 = classStatementBlock();
state.followingStackPointer--;
stream_classStatementBlock.Add( classStatementBlock7.Tree );
// AST REWRITE
// elements: name, classStatementBlock, baseClassDeclaration
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.Tree = root_0;
var stream_retval = new RewriteRuleSubtreeStream( adaptor, "rule retval", retval != null ? retval.Tree : null );
root_0 = (CommonTree)adaptor.GetNilNode();
// 80:59: -> ^( CLASS name ( baseClassDeclaration )? classStatementBlock )
{
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:80:62: ^( CLASS name ( baseClassDeclaration )? classStatementBlock )
{
var root_1 = (CommonTree)adaptor.GetNilNode();
root_1 = (CommonTree)adaptor.BecomeRoot( adaptor.Create( CLASS, "CLASS" ), root_1 );
adaptor.AddChild( root_1, stream_name.NextTree() );
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:80:76: ( baseClassDeclaration )?
if ( stream_baseClassDeclaration.HasNext() )
adaptor.AddChild( root_1, stream_baseClassDeclaration.NextTree() );
stream_baseClassDeclaration.Reset();
adaptor.AddChild( root_1, stream_classStatementBlock.NextTree() );
adaptor.AddChild( root_0, root_1 );
}
}
retval.Tree = root_0;
retval.Tree = root_0;
}
retval.Stop = input.LT( -1 );
retval.Tree = adaptor.RulePostProcessing( root_0 );
adaptor.SetTokenBoundaries( retval.Tree, (IToken)retval.Start, (IToken)retval.Stop );
}
catch ( RecognitionException re )
{
ReportError( re );
Recover( input, re );
// Conversion of the second argument necessary, but harmless
retval.Tree = adaptor.ErrorNode( input, (IToken)retval.Start, input.LT( -1 ), re );
}
finally {}
return retval;
}
private AstParserRuleReturnScope<CommonTree, IToken> switchBlock()
{
EnterRule_switchBlock();
EnterRule("switchBlock", 54);
TraceIn("switchBlock", 54);
AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>();
retval.Start = (IToken)input.LT(1);
CommonTree root_0 = default(CommonTree);
IToken LCURLY175 = default(IToken);
IToken RCURLY178 = default(IToken);
AstParserRuleReturnScope<CommonTree, IToken> caseStatement176 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> defaultStatement177 = default(AstParserRuleReturnScope<CommonTree, IToken>);
CommonTree LCURLY175_tree = default(CommonTree);
CommonTree RCURLY178_tree = default(CommonTree);
RewriteRuleITokenStream stream_LCURLY=new RewriteRuleITokenStream(adaptor,"token LCURLY");
RewriteRuleITokenStream stream_RCURLY=new RewriteRuleITokenStream(adaptor,"token RCURLY");
RewriteRuleSubtreeStream stream_caseStatement=new RewriteRuleSubtreeStream(adaptor,"rule caseStatement");
RewriteRuleSubtreeStream stream_defaultStatement=new RewriteRuleSubtreeStream(adaptor,"rule defaultStatement");
try { DebugEnterRule(GrammarFileName, "switchBlock");
DebugLocation(471, 1);
try
{
// AS3.g:472:2: ( LCURLY ( caseStatement )* ( defaultStatement )? RCURLY -> ^( BLOCK ( caseStatement )* ( defaultStatement )? ) )
DebugEnterAlt(1);
// AS3.g:472:4: LCURLY ( caseStatement )* ( defaultStatement )? RCURLY
{
DebugLocation(472, 4);
LCURLY175=(IToken)Match(input,LCURLY,Follow._LCURLY_in_switchBlock2565); if (state.failed) return retval;
if (state.backtracking == 0) stream_LCURLY.Add(LCURLY175);
DebugLocation(473, 3);
// AS3.g:473:3: ( caseStatement )*
try { DebugEnterSubRule(40);
while (true)
{
int alt40=2;
try { DebugEnterDecision(40, false);
int LA40_1 = input.LA(1);
if ((LA40_1==CASE))
{
alt40 = 1;
}
} finally { DebugExitDecision(40); }
switch ( alt40 )
{
case 1:
DebugEnterAlt(1);
// AS3.g:473:4: caseStatement
{
DebugLocation(473, 4);
PushFollow(Follow._caseStatement_in_switchBlock2570);
caseStatement176=caseStatement();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_caseStatement.Add(caseStatement176.Tree);
}
break;
default:
goto loop40;
}
}
loop40:
;
} finally { DebugExitSubRule(40); }
DebugLocation(474, 3);
// AS3.g:474:3: ( defaultStatement )?
int alt41=2;
try { DebugEnterSubRule(41);
try { DebugEnterDecision(41, false);
int LA41_1 = input.LA(1);
if ((LA41_1==DEFAULT))
{
alt41 = 1;
}
} finally { DebugExitDecision(41); }
switch (alt41)
{
case 1:
DebugEnterAlt(1);
// AS3.g:474:4: defaultStatement
{
DebugLocation(474, 4);
PushFollow(Follow._defaultStatement_in_switchBlock2577);
defaultStatement177=defaultStatement();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_defaultStatement.Add(defaultStatement177.Tree);
}
break;
}
} finally { DebugExitSubRule(41); }
DebugLocation(475, 3);
RCURLY178=(IToken)Match(input,RCURLY,Follow._RCURLY_in_switchBlock2583); if (state.failed) return retval;
if (state.backtracking == 0) stream_RCURLY.Add(RCURLY178);
{
// AST REWRITE
// elements: caseStatement, defaultStatement
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
if (state.backtracking == 0) {
retval.Tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.Tree:null);
root_0 = (CommonTree)adaptor.Nil();
// 476:3: -> ^( BLOCK ( caseStatement )* ( defaultStatement )? )
{
DebugLocation(476, 6);
// AS3.g:476:6: ^( BLOCK ( caseStatement )* ( defaultStatement )? )
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(476, 8);
root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(BLOCK, "BLOCK"), root_1);
DebugLocation(476, 14);
// AS3.g:476:14: ( caseStatement )*
while ( stream_caseStatement.HasNext )
{
DebugLocation(476, 14);
adaptor.AddChild(root_1, stream_caseStatement.NextTree());
}
stream_caseStatement.Reset();
DebugLocation(476, 29);
// AS3.g:476:29: ( defaultStatement )?
if (stream_defaultStatement.HasNext)
{
DebugLocation(476, 29);
adaptor.AddChild(root_1, stream_defaultStatement.NextTree());
}
stream_defaultStatement.Reset();
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;
}
}
}
retval.Stop = (IToken)input.LT(-1);
if (state.backtracking == 0) {
retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
}
}
catch (RecognitionException re)
{
ReportError(re);
Recover(input,re);
retval.Tree = (CommonTree)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);
}
finally
{
TraceOut("switchBlock", 54);
LeaveRule("switchBlock", 54);
LeaveRule_switchBlock();
}
DebugLocation(477, 1);
} finally { DebugExitRule(GrammarFileName, "switchBlock"); }
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;
}
private AstParserRuleReturnScope<CommonTree, IToken> forEachStatement()
{
EnterRule_forEachStatement();
EnterRule("forEachStatement", 58);
TraceIn("forEachStatement", 58);
AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>();
retval.Start = (IToken)input.LT(1);
CommonTree root_0 = default(CommonTree);
IToken f = default(IToken);
IToken EACH185 = default(IToken);
IToken LPAREN186 = default(IToken);
IToken RPAREN188 = default(IToken);
AstParserRuleReturnScope<CommonTree, IToken> forInClause187 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> statement189 = default(AstParserRuleReturnScope<CommonTree, IToken>);
CommonTree f_tree = default(CommonTree);
CommonTree EACH185_tree = default(CommonTree);
CommonTree LPAREN186_tree = default(CommonTree);
CommonTree RPAREN188_tree = default(CommonTree);
RewriteRuleITokenStream stream_FOR=new RewriteRuleITokenStream(adaptor,"token FOR");
RewriteRuleITokenStream stream_EACH=new RewriteRuleITokenStream(adaptor,"token EACH");
RewriteRuleITokenStream stream_LPAREN=new RewriteRuleITokenStream(adaptor,"token LPAREN");
RewriteRuleITokenStream stream_RPAREN=new RewriteRuleITokenStream(adaptor,"token RPAREN");
RewriteRuleSubtreeStream stream_forInClause=new RewriteRuleSubtreeStream(adaptor,"rule forInClause");
RewriteRuleSubtreeStream stream_statement=new RewriteRuleSubtreeStream(adaptor,"rule statement");
try { DebugEnterRule(GrammarFileName, "forEachStatement");
DebugLocation(491, 1);
try
{
// AS3.g:492:2: (f= FOR EACH LPAREN forInClause RPAREN statement -> ^( FOR_EACH_LOOP $f forInClause statement ) )
DebugEnterAlt(1);
// AS3.g:492:4: f= FOR EACH LPAREN forInClause RPAREN statement
{
DebugLocation(492, 5);
f=(IToken)Match(input,FOR,Follow._FOR_in_forEachStatement2672); if (state.failed) return retval;
if (state.backtracking == 0) stream_FOR.Add(f);
DebugLocation(492, 10);
EACH185=(IToken)Match(input,EACH,Follow._EACH_in_forEachStatement2674); if (state.failed) return retval;
if (state.backtracking == 0) stream_EACH.Add(EACH185);
DebugLocation(493, 3);
LPAREN186=(IToken)Match(input,LPAREN,Follow._LPAREN_in_forEachStatement2678); if (state.failed) return retval;
if (state.backtracking == 0) stream_LPAREN.Add(LPAREN186);
DebugLocation(494, 3);
PushFollow(Follow._forInClause_in_forEachStatement2682);
forInClause187=forInClause();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_forInClause.Add(forInClause187.Tree);
DebugLocation(495, 3);
RPAREN188=(IToken)Match(input,RPAREN,Follow._RPAREN_in_forEachStatement2686); if (state.failed) return retval;
if (state.backtracking == 0) stream_RPAREN.Add(RPAREN188);
DebugLocation(496, 3);
PushFollow(Follow._statement_in_forEachStatement2690);
statement189=statement();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_statement.Add(statement189.Tree);
{
// AST REWRITE
// elements: f, forInClause, statement
// token labels: f
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
if (state.backtracking == 0) {
retval.Tree = root_0;
RewriteRuleITokenStream stream_f=new RewriteRuleITokenStream(adaptor,"token f",f);
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.Tree:null);
root_0 = (CommonTree)adaptor.Nil();
// 497:3: -> ^( FOR_EACH_LOOP $f forInClause statement )
{
DebugLocation(497, 6);
// AS3.g:497:6: ^( FOR_EACH_LOOP $f forInClause statement )
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(497, 8);
root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(FOR_EACH_LOOP, "FOR_EACH_LOOP"), root_1);
DebugLocation(497, 23);
adaptor.AddChild(root_1, stream_f.NextNode());
DebugLocation(497, 25);
adaptor.AddChild(root_1, stream_forInClause.NextTree());
DebugLocation(497, 37);
adaptor.AddChild(root_1, stream_statement.NextTree());
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;
}
}
}
retval.Stop = (IToken)input.LT(-1);
if (state.backtracking == 0) {
retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
}
}
catch (RecognitionException re)
{
ReportError(re);
Recover(input,re);
retval.Tree = (CommonTree)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);
}
finally
{
TraceOut("forEachStatement", 58);
LeaveRule("forEachStatement", 58);
LeaveRule_forEachStatement();
}
DebugLocation(498, 1);
} finally { DebugExitRule(GrammarFileName, "forEachStatement"); }
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;
}
private AstParserRuleReturnScope<CommonTree, IToken> forStatement()
{
EnterRule_forStatement();
EnterRule("forStatement", 59);
TraceIn("forStatement", 59);
AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>();
retval.Start = (IToken)input.LT(1);
CommonTree root_0 = default(CommonTree);
IToken FOR190 = default(IToken);
IToken LPAREN191 = default(IToken);
IToken RPAREN193 = default(IToken);
IToken RPAREN196 = default(IToken);
AstParserRuleReturnScope<CommonTree, IToken> forInClause192 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> statement194 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> traditionalForClause195 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> statement197 = default(AstParserRuleReturnScope<CommonTree, IToken>);
CommonTree FOR190_tree = default(CommonTree);
CommonTree LPAREN191_tree = default(CommonTree);
CommonTree RPAREN193_tree = default(CommonTree);
CommonTree RPAREN196_tree = default(CommonTree);
RewriteRuleITokenStream stream_FOR=new RewriteRuleITokenStream(adaptor,"token FOR");
RewriteRuleITokenStream stream_LPAREN=new RewriteRuleITokenStream(adaptor,"token LPAREN");
RewriteRuleITokenStream stream_RPAREN=new RewriteRuleITokenStream(adaptor,"token RPAREN");
RewriteRuleSubtreeStream stream_forInClause=new RewriteRuleSubtreeStream(adaptor,"rule forInClause");
RewriteRuleSubtreeStream stream_statement=new RewriteRuleSubtreeStream(adaptor,"rule statement");
RewriteRuleSubtreeStream stream_traditionalForClause=new RewriteRuleSubtreeStream(adaptor,"rule traditionalForClause");
try { DebugEnterRule(GrammarFileName, "forStatement");
DebugLocation(500, 1);
try
{
// AS3.g:502:2: ( FOR LPAREN ( forInClause RPAREN statement -> ^( FOR_IN_LOOP FOR LPAREN forInClause RPAREN statement ) | traditionalForClause RPAREN statement -> ^( FOR_LOOP FOR LPAREN traditionalForClause RPAREN statement ) ) )
DebugEnterAlt(1);
// AS3.g:502:4: FOR LPAREN ( forInClause RPAREN statement -> ^( FOR_IN_LOOP FOR LPAREN forInClause RPAREN statement ) | traditionalForClause RPAREN statement -> ^( FOR_LOOP FOR LPAREN traditionalForClause RPAREN statement ) )
{
DebugLocation(502, 4);
FOR190=(IToken)Match(input,FOR,Follow._FOR_in_forStatement2717); if (state.failed) return retval;
if (state.backtracking == 0) stream_FOR.Add(FOR190);
DebugLocation(503, 3);
LPAREN191=(IToken)Match(input,LPAREN,Follow._LPAREN_in_forStatement2721); if (state.failed) return retval;
if (state.backtracking == 0) stream_LPAREN.Add(LPAREN191);
DebugLocation(504, 3);
// AS3.g:504:3: ( forInClause RPAREN statement -> ^( FOR_IN_LOOP FOR LPAREN forInClause RPAREN statement ) | traditionalForClause RPAREN statement -> ^( FOR_LOOP FOR LPAREN traditionalForClause RPAREN statement ) )
int alt43=2;
try { DebugEnterSubRule(43);
try { DebugEnterDecision(43, false);
try
{
alt43 = dfa43.Predict(input);
}
catch (NoViableAltException nvae)
{
DebugRecognitionException(nvae);
throw;
}
} finally { DebugExitDecision(43); }
switch (alt43)
{
case 1:
DebugEnterAlt(1);
// AS3.g:504:5: forInClause RPAREN statement
{
DebugLocation(504, 5);
PushFollow(Follow._forInClause_in_forStatement2727);
forInClause192=forInClause();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_forInClause.Add(forInClause192.Tree);
DebugLocation(504, 17);
RPAREN193=(IToken)Match(input,RPAREN,Follow._RPAREN_in_forStatement2729); if (state.failed) return retval;
if (state.backtracking == 0) stream_RPAREN.Add(RPAREN193);
DebugLocation(504, 24);
PushFollow(Follow._statement_in_forStatement2731);
statement194=statement();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_statement.Add(statement194.Tree);
{
// AST REWRITE
// elements: FOR, LPAREN, forInClause, RPAREN, statement
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
if (state.backtracking == 0) {
retval.Tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.Tree:null);
root_0 = (CommonTree)adaptor.Nil();
// 505:4: -> ^( FOR_IN_LOOP FOR LPAREN forInClause RPAREN statement )
{
DebugLocation(505, 7);
// AS3.g:505:7: ^( FOR_IN_LOOP FOR LPAREN forInClause RPAREN statement )
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(505, 9);
root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(FOR_IN_LOOP, "FOR_IN_LOOP"), root_1);
DebugLocation(505, 21);
adaptor.AddChild(root_1, stream_FOR.NextNode());
DebugLocation(505, 25);
adaptor.AddChild(root_1, stream_LPAREN.NextNode());
DebugLocation(505, 32);
adaptor.AddChild(root_1, stream_forInClause.NextTree());
DebugLocation(505, 44);
adaptor.AddChild(root_1, stream_RPAREN.NextNode());
DebugLocation(505, 51);
adaptor.AddChild(root_1, stream_statement.NextTree());
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;
}
}
}
break;
case 2:
DebugEnterAlt(2);
// AS3.g:507:5: traditionalForClause RPAREN statement
{
DebugLocation(507, 5);
PushFollow(Follow._traditionalForClause_in_forStatement2757);
traditionalForClause195=traditionalForClause();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_traditionalForClause.Add(traditionalForClause195.Tree);
DebugLocation(507, 26);
RPAREN196=(IToken)Match(input,RPAREN,Follow._RPAREN_in_forStatement2759); if (state.failed) return retval;
if (state.backtracking == 0) stream_RPAREN.Add(RPAREN196);
DebugLocation(507, 33);
PushFollow(Follow._statement_in_forStatement2761);
statement197=statement();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_statement.Add(statement197.Tree);
{
// AST REWRITE
// elements: FOR, LPAREN, traditionalForClause, RPAREN, statement
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
if (state.backtracking == 0) {
retval.Tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.Tree:null);
root_0 = (CommonTree)adaptor.Nil();
// 508:4: -> ^( FOR_LOOP FOR LPAREN traditionalForClause RPAREN statement )
{
DebugLocation(508, 7);
// AS3.g:508:7: ^( FOR_LOOP FOR LPAREN traditionalForClause RPAREN statement )
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(508, 9);
root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(FOR_LOOP, "FOR_LOOP"), root_1);
DebugLocation(508, 18);
adaptor.AddChild(root_1, stream_FOR.NextNode());
DebugLocation(508, 22);
adaptor.AddChild(root_1, stream_LPAREN.NextNode());
DebugLocation(508, 29);
adaptor.AddChild(root_1, stream_traditionalForClause.NextTree());
DebugLocation(508, 50);
adaptor.AddChild(root_1, stream_RPAREN.NextNode());
DebugLocation(508, 57);
adaptor.AddChild(root_1, stream_statement.NextTree());
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;
}
}
}
break;
}
} finally { DebugExitSubRule(43); }
}
retval.Stop = (IToken)input.LT(-1);
if (state.backtracking == 0) {
retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
}
}
catch (RecognitionException re)
{
ReportError(re);
Recover(input,re);
retval.Tree = (CommonTree)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);
}
finally
{
TraceOut("forStatement", 59);
LeaveRule("forStatement", 59);
LeaveRule_forStatement();
}
DebugLocation(510, 1);
} finally { DebugExitRule(GrammarFileName, "forStatement"); }
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;
}
private AstParserRuleReturnScope<CommonTree, IToken> packageDecl()
{
EnterRule_packageDecl();
EnterRule("packageDecl", 5);
TraceIn("packageDecl", 5);
AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>();
retval.Start = (IToken)input.LT(1);
CommonTree root_0 = default(CommonTree);
IToken PACKAGE11 = default(IToken);
IToken LCURLY13 = default(IToken);
IToken RCURLY15 = default(IToken);
AstParserRuleReturnScope<CommonTree, IToken> identifierStar12 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> packageBlockEntry14 = default(AstParserRuleReturnScope<CommonTree, IToken>);
CommonTree PACKAGE11_tree = default(CommonTree);
CommonTree LCURLY13_tree = default(CommonTree);
CommonTree RCURLY15_tree = default(CommonTree);
RewriteRuleITokenStream stream_PACKAGE=new RewriteRuleITokenStream(adaptor,"token PACKAGE");
RewriteRuleITokenStream stream_LCURLY=new RewriteRuleITokenStream(adaptor,"token LCURLY");
RewriteRuleITokenStream stream_RCURLY=new RewriteRuleITokenStream(adaptor,"token RCURLY");
RewriteRuleSubtreeStream stream_identifierStar=new RewriteRuleSubtreeStream(adaptor,"rule identifierStar");
RewriteRuleSubtreeStream stream_packageBlockEntry=new RewriteRuleSubtreeStream(adaptor,"rule packageBlockEntry");
try { DebugEnterRule(GrammarFileName, "packageDecl");
DebugLocation(139, 1);
try
{
// AS3.g:140:2: ( PACKAGE ( identifierStar )? LCURLY ( packageBlockEntry )* RCURLY -> ^( PACKAGE_DECL PACKAGE ( identifierStar )? LCURLY ( packageBlockEntry )* RCURLY ) )
DebugEnterAlt(1);
// AS3.g:140:4: PACKAGE ( identifierStar )? LCURLY ( packageBlockEntry )* RCURLY
{
DebugLocation(140, 4);
PACKAGE11=(IToken)Match(input,PACKAGE,Follow._PACKAGE_in_packageDecl590); if (state.failed) return retval;
if (state.backtracking == 0) stream_PACKAGE.Add(PACKAGE11);
DebugLocation(140, 12);
// AS3.g:140:12: ( identifierStar )?
int alt5=2;
try { DebugEnterSubRule(5);
try { DebugEnterDecision(5, false);
int LA5_1 = input.LA(1);
if ((LA5_1==AS||LA5_1==DYNAMIC||LA5_1==GET||LA5_1==IDENT||LA5_1==IS||LA5_1==NAMESPACE||LA5_1==SET||LA5_1==SUPER||LA5_1==USE||LA5_1==XML))
{
alt5 = 1;
}
} finally { DebugExitDecision(5); }
switch (alt5)
{
case 1:
DebugEnterAlt(1);
// AS3.g:140:12: identifierStar
{
DebugLocation(140, 12);
PushFollow(Follow._identifierStar_in_packageDecl592);
identifierStar12=identifierStar();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_identifierStar.Add(identifierStar12.Tree);
}
break;
}
} finally { DebugExitSubRule(5); }
DebugLocation(141, 3);
LCURLY13=(IToken)Match(input,LCURLY,Follow._LCURLY_in_packageDecl597); if (state.failed) return retval;
if (state.backtracking == 0) stream_LCURLY.Add(LCURLY13);
DebugLocation(142, 9);
// AS3.g:142:9: ( packageBlockEntry )*
try { DebugEnterSubRule(6);
while (true)
{
int alt6=2;
try { DebugEnterDecision(6, false);
int LA6_1 = input.LA(1);
if ((LA6_1==AS||LA6_1==BNOT||LA6_1==BREAK||LA6_1==CLASS||LA6_1==CONST||LA6_1==CONTINUE||(LA6_1>=DEC && LA6_1<=DECIMAL_LITERAL)||LA6_1==DEFAULT||LA6_1==DO||(LA6_1>=DYNAMIC && LA6_1<=E4X_ATTRI)||(LA6_1>=FALSE && LA6_1<=FOR)||LA6_1==FUNCTION||LA6_1==GET||(LA6_1>=HEX_LITERAL && LA6_1<=IDENT)||LA6_1==IF||LA6_1==IMPORT||LA6_1==INC||LA6_1==INTERFACE||(LA6_1>=INTERNAL && LA6_1<=IS)||(LA6_1>=LBRACK && LA6_1<=LCURLY)||LA6_1==LNOT||LA6_1==LPAREN||LA6_1==MINUS||LA6_1==NAMESPACE||LA6_1==NEW||LA6_1==NULL||LA6_1==OCTAL_LITERAL||LA6_1==PLUS||LA6_1==PRIVATE||(LA6_1>=PROTECTED && LA6_1<=PUBLIC)||LA6_1==REGEX_LITERAL||LA6_1==RETURN||(LA6_1>=SEMI && LA6_1<=SET)||LA6_1==STATIC||(LA6_1>=STRING_LITERAL_DOUBLE && LA6_1<=SWITCH)||LA6_1==TRUE||(LA6_1>=USE && LA6_1<=VAR)||LA6_1==WHILE||LA6_1==WITH||LA6_1==XML||LA6_1==XML_LITERAL||(LA6_1>=243 && LA6_1<=246)||LA6_1==248||LA6_1==250||(LA6_1>=252 && LA6_1<=257)))
{
alt6 = 1;
}
} finally { DebugExitDecision(6); }
switch ( alt6 )
{
case 1:
DebugEnterAlt(1);
// AS3.g:142:9: packageBlockEntry
{
DebugLocation(142, 9);
PushFollow(Follow._packageBlockEntry_in_packageDecl608);
packageBlockEntry14=packageBlockEntry();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_packageBlockEntry.Add(packageBlockEntry14.Tree);
}
break;
default:
goto loop6;
}
}
loop6:
;
} finally { DebugExitSubRule(6); }
DebugLocation(143, 3);
RCURLY15=(IToken)Match(input,RCURLY,Follow._RCURLY_in_packageDecl613); if (state.failed) return retval;
if (state.backtracking == 0) stream_RCURLY.Add(RCURLY15);
{
// AST REWRITE
// elements: PACKAGE, identifierStar, LCURLY, packageBlockEntry, RCURLY
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
if (state.backtracking == 0) {
retval.Tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.Tree:null);
root_0 = (CommonTree)adaptor.Nil();
// 144:3: -> ^( PACKAGE_DECL PACKAGE ( identifierStar )? LCURLY ( packageBlockEntry )* RCURLY )
{
DebugLocation(144, 6);
// AS3.g:144:6: ^( PACKAGE_DECL PACKAGE ( identifierStar )? LCURLY ( packageBlockEntry )* RCURLY )
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(144, 8);
root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(PACKAGE_DECL, "PACKAGE_DECL"), root_1);
DebugLocation(144, 21);
adaptor.AddChild(root_1, stream_PACKAGE.NextNode());
DebugLocation(144, 29);
// AS3.g:144:29: ( identifierStar )?
if (stream_identifierStar.HasNext)
{
DebugLocation(144, 29);
adaptor.AddChild(root_1, stream_identifierStar.NextTree());
}
stream_identifierStar.Reset();
DebugLocation(144, 45);
adaptor.AddChild(root_1, stream_LCURLY.NextNode());
DebugLocation(144, 52);
// AS3.g:144:52: ( packageBlockEntry )*
while ( stream_packageBlockEntry.HasNext )
{
DebugLocation(144, 52);
adaptor.AddChild(root_1, stream_packageBlockEntry.NextTree());
}
stream_packageBlockEntry.Reset();
DebugLocation(144, 71);
adaptor.AddChild(root_1, stream_RCURLY.NextNode());
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;
}
}
}
retval.Stop = (IToken)input.LT(-1);
if (state.backtracking == 0) {
retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
}
}
catch (RecognitionException re)
{
ReportError(re);
Recover(input,re);
retval.Tree = (CommonTree)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);
}
finally
{
TraceOut("packageDecl", 5);
LeaveRule("packageDecl", 5);
LeaveRule_packageDecl();
}
DebugLocation(145, 1);
} finally { DebugExitRule(GrammarFileName, "packageDecl"); }
return retval;
}
// $ANTLR start "propertyDeclaration"
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:97:1: propertyDeclaration : 'property' name ( propertyModifiers )? ';' -> ^( PROPERTY name ( propertyModifiers )? ) ;
public propertyDeclaration_return propertyDeclaration() // throws RecognitionException [1]
{
var retval = new propertyDeclaration_return();
retval.Start = input.LT( 1 );
CommonTree root_0 = null;
IToken string_literal17 = null;
IToken char_literal20 = null;
name_return name18 = default( name_return );
propertyModifiers_return propertyModifiers19 = default( propertyModifiers_return );
CommonTree string_literal17_tree = null;
CommonTree char_literal20_tree = null;
var stream_62 = new RewriteRuleTokenStream( adaptor, "token 62" );
var stream_63 = new RewriteRuleTokenStream( adaptor, "token 63" );
var stream_propertyModifiers = new RewriteRuleSubtreeStream( adaptor, "rule propertyModifiers" );
var stream_name = new RewriteRuleSubtreeStream( adaptor, "rule name" );
try
{
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:98:2: ( 'property' name ( propertyModifiers )? ';' -> ^( PROPERTY name ( propertyModifiers )? ) )
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:98:4: 'property' name ( propertyModifiers )? ';'
{
string_literal17 = (IToken)Match( input, 62, FOLLOW_62_in_propertyDeclaration389 );
stream_62.Add( string_literal17 );
PushFollow( FOLLOW_name_in_propertyDeclaration391 );
name18 = name();
state.followingStackPointer--;
stream_name.Add( name18.Tree );
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:98:20: ( propertyModifiers )?
int alt6 = 2;
int LA6_0 = input.LA( 1 );
if ( ( ( LA6_0 >= 64 && LA6_0 <= 66 ) ) )
alt6 = 1;
switch ( alt6 )
{
case 1:
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:98:20: propertyModifiers
{
PushFollow( FOLLOW_propertyModifiers_in_propertyDeclaration393 );
propertyModifiers19 = propertyModifiers();
state.followingStackPointer--;
stream_propertyModifiers.Add( propertyModifiers19.Tree );
}
break;
}
char_literal20 = (IToken)Match( input, 63, FOLLOW_63_in_propertyDeclaration396 );
stream_63.Add( char_literal20 );
// AST REWRITE
// elements: name, propertyModifiers
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.Tree = root_0;
var stream_retval = new RewriteRuleSubtreeStream( adaptor, "rule retval", retval != null ? retval.Tree : null );
root_0 = (CommonTree)adaptor.GetNilNode();
// 98:43: -> ^( PROPERTY name ( propertyModifiers )? )
{
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:98:46: ^( PROPERTY name ( propertyModifiers )? )
{
var root_1 = (CommonTree)adaptor.GetNilNode();
root_1 = (CommonTree)adaptor.BecomeRoot( adaptor.Create( PROPERTY, "PROPERTY" ), root_1 );
adaptor.AddChild( root_1, stream_name.NextTree() );
// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:98:63: ( propertyModifiers )?
if ( stream_propertyModifiers.HasNext() )
adaptor.AddChild( root_1, stream_propertyModifiers.NextTree() );
stream_propertyModifiers.Reset();
adaptor.AddChild( root_0, root_1 );
}
}
retval.Tree = root_0;
retval.Tree = root_0;
}
retval.Stop = input.LT( -1 );
retval.Tree = adaptor.RulePostProcessing( root_0 );
adaptor.SetTokenBoundaries( retval.Tree, (IToken)retval.Start, (IToken)retval.Stop );
}
catch ( RecognitionException re )
{
ReportError( re );
Recover( input, re );
// Conversion of the second argument necessary, but harmless
retval.Tree = adaptor.ErrorNode( input, (IToken)retval.Start, input.LT( -1 ), re );
}
finally {}
return retval;
}
private AstParserRuleReturnScope <object, IToken> plain_descr()
{
EnterRule_plain_descr();
EnterRule("plain_descr", 2);
TraceIn("plain_descr", 2);
AstParserRuleReturnScope <object, IToken> retval = new AstParserRuleReturnScope <object, IToken>();
retval.Start = (IToken)input.LT(1);
object root_0 = default(object);
IToken PLAIN3 = default(IToken);
IToken ID4 = default(IToken);
IToken BEGIN5 = default(IToken);
IToken END6 = default(IToken);
IToken char_literal7 = default(IToken);
AstParserRuleReturnScope <object, IToken> pl = default(AstParserRuleReturnScope <object, IToken>);
object PLAIN3_tree = default(object);
object ID4_tree = default(object);
object BEGIN5_tree = default(object);
object END6_tree = default(object);
object char_literal7_tree = default(object);
RewriteRuleITokenStream stream_ID = new RewriteRuleITokenStream(adaptor, "token ID");
RewriteRuleITokenStream stream_END = new RewriteRuleITokenStream(adaptor, "token END");
RewriteRuleITokenStream stream_PLAIN = new RewriteRuleITokenStream(adaptor, "token PLAIN");
RewriteRuleITokenStream stream_24 = new RewriteRuleITokenStream(adaptor, "token 24");
RewriteRuleITokenStream stream_BEGIN = new RewriteRuleITokenStream(adaptor, "token BEGIN");
RewriteRuleSubtreeStream stream_plain_elem_list = new RewriteRuleSubtreeStream(adaptor, "rule plain_elem_list");
try { DebugEnterRule(GrammarFileName, "plain_descr");
DebugLocation(30, 1);
try
{
// C:\\Users\\franz\\SkyDrive\\Dokumente\\workspace\\TextTable\\src\\eu\\reitmayer\\texttable\\lang\\TextTable.g:30:12: ( PLAIN ID BEGIN pl= plain_elem_list END ';' -> ^( PLAIN_FILE ID $pl) )
DebugEnterAlt(1);
// C:\\Users\\franz\\SkyDrive\\Dokumente\\workspace\\TextTable\\src\\eu\\reitmayer\\texttable\\lang\\TextTable.g:31:2: PLAIN ID BEGIN pl= plain_elem_list END ';'
{
DebugLocation(31, 2);
PLAIN3 = (IToken)Match(input, PLAIN, Follow._PLAIN_in_plain_descr99);
stream_PLAIN.Add(PLAIN3);
DebugLocation(31, 8);
ID4 = (IToken)Match(input, ID, Follow._ID_in_plain_descr101);
stream_ID.Add(ID4);
DebugLocation(32, 2);
BEGIN5 = (IToken)Match(input, BEGIN, Follow._BEGIN_in_plain_descr104);
stream_BEGIN.Add(BEGIN5);
DebugLocation(33, 6);
PushFollow(Follow._plain_elem_list_in_plain_descr111);
pl = plain_elem_list();
PopFollow();
stream_plain_elem_list.Add(pl.Tree);
DebugLocation(34, 2);
END6 = (IToken)Match(input, END, Follow._END_in_plain_descr114);
stream_END.Add(END6);
DebugLocation(34, 6);
char_literal7 = (IToken)Match(input, 24, Follow._24_in_plain_descr116);
stream_24.Add(char_literal7);
{
// AST REWRITE
// elements: pl, ID
// token labels:
// rule labels: retval, pl
// token list labels:
// rule list labels:
// wildcard labels:
retval.Tree = root_0;
RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null?retval.Tree:null);
RewriteRuleSubtreeStream stream_pl = new RewriteRuleSubtreeStream(adaptor, "rule pl", pl != null?pl.Tree:null);
root_0 = (object)adaptor.Nil();
// 34:10: -> ^( PLAIN_FILE ID $pl)
{
DebugLocation(34, 13);
// C:\\Users\\franz\\SkyDrive\\Dokumente\\workspace\\TextTable\\src\\eu\\reitmayer\\texttable\\lang\\TextTable.g:34:13: ^( PLAIN_FILE ID $pl)
{
object root_1 = (object)adaptor.Nil();
DebugLocation(34, 15);
root_1 = (object)adaptor.BecomeRoot((object)adaptor.Create(PLAIN_FILE, "PLAIN_FILE"), root_1);
DebugLocation(34, 26);
adaptor.AddChild(root_1, stream_ID.NextNode());
DebugLocation(34, 30);
adaptor.AddChild(root_1, stream_pl.NextTree());
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;
}
}
retval.Stop = (IToken)input.LT(-1);
retval.Tree = (object)adaptor.RulePostProcessing(root_0);
adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
}
catch (RecognitionException re)
{
ReportError(re);
Recover(input, re);
retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);
}
finally
{
TraceOut("plain_descr", 2);
LeaveRule("plain_descr", 2);
LeaveRule_plain_descr();
}
DebugLocation(35, 1); } finally { DebugExitRule(GrammarFileName, "plain_descr"); }
return(retval);
}