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;
}
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;
}
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;
}
private AstParserRuleReturnScope<CommonTree, IToken> ifStatement()
{
EnterRule_ifStatement();
EnterRule("ifStatement", 44);
TraceIn("ifStatement", 44);
AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>();
retval.Start = (IToken)input.LT(1);
CommonTree root_0 = default(CommonTree);
IToken IF148 = default(IToken);
AstParserRuleReturnScope<CommonTree, IToken> condition149 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> statement150 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> elseClause151 = default(AstParserRuleReturnScope<CommonTree, IToken>);
CommonTree IF148_tree = default(CommonTree);
RewriteRuleITokenStream stream_IF=new RewriteRuleITokenStream(adaptor,"token IF");
RewriteRuleSubtreeStream stream_condition=new RewriteRuleSubtreeStream(adaptor,"rule condition");
RewriteRuleSubtreeStream stream_statement=new RewriteRuleSubtreeStream(adaptor,"rule statement");
RewriteRuleSubtreeStream stream_elseClause=new RewriteRuleSubtreeStream(adaptor,"rule elseClause");
try { DebugEnterRule(GrammarFileName, "ifStatement");
DebugLocation(417, 1);
try
{
// AS3.g:418:2: ( IF condition statement ( ( ELSE )=> elseClause )? -> ^( IF_STMT IF condition statement ( elseClause )? ) )
DebugEnterAlt(1);
// AS3.g:418:4: IF condition statement ( ( ELSE )=> elseClause )?
{
DebugLocation(418, 4);
IF148=(IToken)Match(input,IF,Follow._IF_in_ifStatement2217); if (state.failed) return retval;
if (state.backtracking == 0) stream_IF.Add(IF148);
DebugLocation(418, 7);
PushFollow(Follow._condition_in_ifStatement2219);
condition149=condition();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_condition.Add(condition149.Tree);
DebugLocation(418, 17);
PushFollow(Follow._statement_in_ifStatement2221);
statement150=statement();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_statement.Add(statement150.Tree);
DebugLocation(419, 3);
// AS3.g:419:3: ( ( ELSE )=> elseClause )?
int alt35=2;
try { DebugEnterSubRule(35);
try { DebugEnterDecision(35, false);
int LA35_1 = input.LA(1);
if ((LA35_1==ELSE))
{
int LA35_2 = input.LA(2);
if ((EvaluatePredicate(synpred14_AS3_fragment)))
{
alt35 = 1;
}
}
} finally { DebugExitDecision(35); }
switch (alt35)
{
case 1:
DebugEnterAlt(1);
// AS3.g:419:4: ( ELSE )=> elseClause
{
DebugLocation(419, 12);
PushFollow(Follow._elseClause_in_ifStatement2230);
elseClause151=elseClause();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_elseClause.Add(elseClause151.Tree);
}
break;
}
} finally { DebugExitSubRule(35); }
{
// AST REWRITE
// elements: IF, condition, statement, elseClause
// 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();
// 420:9: -> ^( IF_STMT IF condition statement ( elseClause )? )
{
DebugLocation(420, 12);
// AS3.g:420:12: ^( IF_STMT IF condition statement ( elseClause )? )
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(420, 14);
root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(IF_STMT, "IF_STMT"), root_1);
DebugLocation(420, 22);
adaptor.AddChild(root_1, stream_IF.NextNode());
DebugLocation(420, 25);
adaptor.AddChild(root_1, stream_condition.NextTree());
DebugLocation(420, 35);
adaptor.AddChild(root_1, stream_statement.NextTree());
DebugLocation(420, 45);
// AS3.g:420:45: ( elseClause )?
if (stream_elseClause.HasNext)
{
DebugLocation(420, 45);
adaptor.AddChild(root_1, stream_elseClause.NextTree());
}
stream_elseClause.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("ifStatement", 44);
LeaveRule("ifStatement", 44);
LeaveRule_ifStatement();
}
DebugLocation(421, 1);
} finally { DebugExitRule(GrammarFileName, "ifStatement"); }
return retval;
}
private AstParserRuleReturnScope<CommonTree, IToken> throwStatement()
{
EnterRule_throwStatement();
EnterRule("throwStatement", 46);
TraceIn("throwStatement", 46);
AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>();
retval.Start = (IToken)input.LT(1);
CommonTree root_0 = default(CommonTree);
IToken string_literal154 = default(IToken);
AstParserRuleReturnScope<CommonTree, IToken> s = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> expression155 = default(AstParserRuleReturnScope<CommonTree, IToken>);
CommonTree string_literal154_tree = default(CommonTree);
RewriteRuleITokenStream stream_253=new RewriteRuleITokenStream(adaptor,"token 253");
RewriteRuleSubtreeStream stream_expression=new RewriteRuleSubtreeStream(adaptor,"rule expression");
RewriteRuleSubtreeStream stream_semi=new RewriteRuleSubtreeStream(adaptor,"rule semi");
try { DebugEnterRule(GrammarFileName, "throwStatement");
DebugLocation(428, 1);
try
{
// AS3.g:429:2: ( 'throw' expression s= semi -> ^( THROW_STATEMENT 'throw' expression ) )
DebugEnterAlt(1);
// AS3.g:429:4: 'throw' expression s= semi
{
DebugLocation(429, 4);
string_literal154=(IToken)Match(input,253,Follow._253_in_throwStatement2298); if (state.failed) return retval;
if (state.backtracking == 0) stream_253.Add(string_literal154);
DebugLocation(429, 12);
PushFollow(Follow._expression_in_throwStatement2300);
expression155=expression();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_expression.Add(expression155.Tree);
DebugLocation(429, 24);
PushFollow(Follow._semi_in_throwStatement2304);
s=semi();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_semi.Add(s.Tree);
{
// AST REWRITE
// elements: 253, 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();
// 430:9: -> ^( THROW_STATEMENT 'throw' expression )
{
DebugLocation(430, 12);
// AS3.g:430:12: ^( THROW_STATEMENT 'throw' expression )
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(430, 14);
root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(THROW_STATEMENT, "THROW_STATEMENT"), root_1);
DebugLocation(430, 30);
adaptor.AddChild(root_1, stream_253.NextNode());
DebugLocation(430, 38);
adaptor.AddChild(root_1, stream_expression.NextTree());
DebugLocation(430, 49);
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("throwStatement", 46);
LeaveRule("throwStatement", 46);
LeaveRule_throwStatement();
}
DebugLocation(431, 1);
} finally { DebugExitRule(GrammarFileName, "throwStatement"); }
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<CommonTree, IToken> parameterRestDeclaration()
{
EnterRule_parameterRestDeclaration();
EnterRule("parameterRestDeclaration", 37);
TraceIn("parameterRestDeclaration", 37);
AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>();
retval.Start = (IToken)input.LT(1);
CommonTree root_0 = default(CommonTree);
IToken REST120 = default(IToken);
AstParserRuleReturnScope<CommonTree, IToken> ident121 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> typeExpression122 = default(AstParserRuleReturnScope<CommonTree, IToken>);
CommonTree REST120_tree = default(CommonTree);
RewriteRuleITokenStream stream_REST=new RewriteRuleITokenStream(adaptor,"token REST");
RewriteRuleSubtreeStream stream_ident=new RewriteRuleSubtreeStream(adaptor,"rule ident");
RewriteRuleSubtreeStream stream_typeExpression=new RewriteRuleSubtreeStream(adaptor,"rule typeExpression");
try { DebugEnterRule(GrammarFileName, "parameterRestDeclaration");
DebugLocation(353, 1);
try
{
// AS3.g:354:2: ( REST ( ident )? ( typeExpression )? -> ^( PARAM REST ( ident )? ( typeExpression )? ) )
DebugEnterAlt(1);
// AS3.g:354:4: REST ( ident )? ( typeExpression )?
{
DebugLocation(354, 4);
REST120=(IToken)Match(input,REST,Follow._REST_in_parameterRestDeclaration1932); if (state.failed) return retval;
if (state.backtracking == 0) stream_REST.Add(REST120);
DebugLocation(354, 9);
// AS3.g:354:9: ( ident )?
int alt31=2;
try { DebugEnterSubRule(31);
try { DebugEnterDecision(31, false);
int LA31_1 = input.LA(1);
if ((LA31_1==AS||LA31_1==DYNAMIC||LA31_1==GET||LA31_1==IDENT||LA31_1==IS||LA31_1==NAMESPACE||LA31_1==SET||LA31_1==SUPER||LA31_1==USE||LA31_1==XML))
{
alt31 = 1;
}
} finally { DebugExitDecision(31); }
switch (alt31)
{
case 1:
DebugEnterAlt(1);
// AS3.g:354:9: ident
{
DebugLocation(354, 9);
PushFollow(Follow._ident_in_parameterRestDeclaration1934);
ident121=ident();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_ident.Add(ident121.Tree);
}
break;
}
} finally { DebugExitSubRule(31); }
DebugLocation(354, 16);
// AS3.g:354:16: ( typeExpression )?
int alt32=2;
try { DebugEnterSubRule(32);
try { DebugEnterDecision(32, false);
int LA32_1 = input.LA(1);
if ((LA32_1==COLON))
{
alt32 = 1;
}
} finally { DebugExitDecision(32); }
switch (alt32)
{
case 1:
DebugEnterAlt(1);
// AS3.g:354:16: typeExpression
{
DebugLocation(354, 16);
PushFollow(Follow._typeExpression_in_parameterRestDeclaration1937);
typeExpression122=typeExpression();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_typeExpression.Add(typeExpression122.Tree);
}
break;
}
} finally { DebugExitSubRule(32); }
{
// AST REWRITE
// elements: REST, ident, typeExpression
// 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();
// 355:3: -> ^( PARAM REST ( ident )? ( typeExpression )? )
{
DebugLocation(355, 6);
// AS3.g:355:6: ^( PARAM REST ( ident )? ( typeExpression )? )
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(355, 8);
root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(PARAM, "PARAM"), root_1);
DebugLocation(355, 14);
adaptor.AddChild(root_1, stream_REST.NextNode());
DebugLocation(355, 19);
// AS3.g:355:19: ( ident )?
if (stream_ident.HasNext)
{
DebugLocation(355, 19);
adaptor.AddChild(root_1, stream_ident.NextTree());
}
stream_ident.Reset();
DebugLocation(355, 26);
// AS3.g:355:26: ( typeExpression )?
if (stream_typeExpression.HasNext)
{
DebugLocation(355, 26);
adaptor.AddChild(root_1, stream_typeExpression.NextTree());
}
stream_typeExpression.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("parameterRestDeclaration", 37);
LeaveRule("parameterRestDeclaration", 37);
LeaveRule_parameterRestDeclaration();
}
DebugLocation(356, 1);
} finally { DebugExitRule(GrammarFileName, "parameterRestDeclaration"); }
return retval;
}
private AstParserRuleReturnScope<CommonTree, IToken> stringLiteralSingle()
{
EnterRule_stringLiteralSingle();
EnterRule("stringLiteralSingle", 128);
TraceIn("stringLiteralSingle", 128);
AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>();
retval.Start = (IToken)input.LT(1);
CommonTree root_0 = default(CommonTree);
IToken STRING_LITERAL_SINGLE426 = default(IToken);
CommonTree STRING_LITERAL_SINGLE426_tree = default(CommonTree);
RewriteRuleITokenStream stream_STRING_LITERAL_SINGLE=new RewriteRuleITokenStream(adaptor,"token STRING_LITERAL_SINGLE");
try { DebugEnterRule(GrammarFileName, "stringLiteralSingle");
DebugLocation(978, 4);
try
{
// AS3.g:979:5: ( STRING_LITERAL_SINGLE -> ^( LITERAL_SINGLE_STRING STRING_LITERAL_SINGLE ) )
DebugEnterAlt(1);
// AS3.g:979:7: STRING_LITERAL_SINGLE
{
DebugLocation(979, 7);
STRING_LITERAL_SINGLE426=(IToken)Match(input,STRING_LITERAL_SINGLE,Follow._STRING_LITERAL_SINGLE_in_stringLiteralSingle5208); if (state.failed) return retval;
if (state.backtracking == 0) stream_STRING_LITERAL_SINGLE.Add(STRING_LITERAL_SINGLE426);
{
// AST REWRITE
// elements: STRING_LITERAL_SINGLE
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
if (state.backtracking == 0) {
retval.Tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.Tree:null);
root_0 = (CommonTree)adaptor.Nil();
// 979:29: -> ^( LITERAL_SINGLE_STRING STRING_LITERAL_SINGLE )
{
DebugLocation(979, 32);
// AS3.g:979:32: ^( LITERAL_SINGLE_STRING STRING_LITERAL_SINGLE )
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(979, 34);
root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(LITERAL_SINGLE_STRING, "LITERAL_SINGLE_STRING"), root_1);
DebugLocation(979, 56);
adaptor.AddChild(root_1, stream_STRING_LITERAL_SINGLE.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("stringLiteralSingle", 128);
LeaveRule("stringLiteralSingle", 128);
LeaveRule_stringLiteralSingle();
}
DebugLocation(980, 4);
} finally { DebugExitRule(GrammarFileName, "stringLiteralSingle"); }
return retval;
}
private AstParserRuleReturnScope<CommonTree, IToken> regexpLiteral()
{
EnterRule_regexpLiteral();
EnterRule("regexpLiteral", 131);
TraceIn("regexpLiteral", 131);
AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>();
retval.Start = (IToken)input.LT(1);
CommonTree root_0 = default(CommonTree);
IToken REGEX_LITERAL429 = default(IToken);
CommonTree REGEX_LITERAL429_tree = default(CommonTree);
RewriteRuleITokenStream stream_REGEX_LITERAL=new RewriteRuleITokenStream(adaptor,"token REGEX_LITERAL");
try { DebugEnterRule(GrammarFileName, "regexpLiteral");
DebugLocation(997, 1);
try
{
// AS3.g:998:2: ( REGEX_LITERAL -> ^( LITERAL_REGEX REGEX_LITERAL ) )
DebugEnterAlt(1);
// AS3.g:998:4: REGEX_LITERAL
{
DebugLocation(998, 4);
REGEX_LITERAL429=(IToken)Match(input,REGEX_LITERAL,Follow._REGEX_LITERAL_in_regexpLiteral5299); if (state.failed) return retval;
if (state.backtracking == 0) stream_REGEX_LITERAL.Add(REGEX_LITERAL429);
{
// AST REWRITE
// elements: REGEX_LITERAL
// 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();
// 999:3: -> ^( LITERAL_REGEX REGEX_LITERAL )
{
DebugLocation(999, 6);
// AS3.g:999:6: ^( LITERAL_REGEX REGEX_LITERAL )
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(999, 8);
root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(LITERAL_REGEX, "LITERAL_REGEX"), root_1);
DebugLocation(999, 22);
adaptor.AddChild(root_1, stream_REGEX_LITERAL.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("regexpLiteral", 131);
LeaveRule("regexpLiteral", 131);
LeaveRule_regexpLiteral();
}
DebugLocation(1000, 1);
} finally { DebugExitRule(GrammarFileName, "regexpLiteral"); }
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> postfixExpression()
{
EnterRule_postfixExpression();
EnterRule("postfixExpression", 119);
TraceIn("postfixExpression", 119);
AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>();
retval.Start = (IToken)input.LT(1);
CommonTree root_0 = default(CommonTree);
IToken DOT383 = default(IToken);
IToken E4X_DESC385 = default(IToken);
IToken LBRACK387 = default(IToken);
IToken RBRACK389 = default(IToken);
IToken INC391 = default(IToken);
IToken DEC392 = default(IToken);
AstParserRuleReturnScope<CommonTree, IToken> primaryExpression381 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> propOrIdent382 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> e4xExpression384 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> e4xExpression386 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> expression388 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> arguments390 = default(AstParserRuleReturnScope<CommonTree, IToken>);
CommonTree DOT383_tree = default(CommonTree);
CommonTree E4X_DESC385_tree = default(CommonTree);
CommonTree LBRACK387_tree = default(CommonTree);
CommonTree RBRACK389_tree = default(CommonTree);
CommonTree INC391_tree = default(CommonTree);
CommonTree DEC392_tree = default(CommonTree);
RewriteRuleITokenStream stream_DOT=new RewriteRuleITokenStream(adaptor,"token DOT");
RewriteRuleITokenStream stream_E4X_DESC=new RewriteRuleITokenStream(adaptor,"token E4X_DESC");
RewriteRuleITokenStream stream_LBRACK=new RewriteRuleITokenStream(adaptor,"token LBRACK");
RewriteRuleITokenStream stream_RBRACK=new RewriteRuleITokenStream(adaptor,"token RBRACK");
RewriteRuleITokenStream stream_INC=new RewriteRuleITokenStream(adaptor,"token INC");
RewriteRuleITokenStream stream_DEC=new RewriteRuleITokenStream(adaptor,"token DEC");
RewriteRuleSubtreeStream stream_primaryExpression=new RewriteRuleSubtreeStream(adaptor,"rule primaryExpression");
RewriteRuleSubtreeStream stream_propOrIdent=new RewriteRuleSubtreeStream(adaptor,"rule propOrIdent");
RewriteRuleSubtreeStream stream_e4xExpression=new RewriteRuleSubtreeStream(adaptor,"rule e4xExpression");
RewriteRuleSubtreeStream stream_expression=new RewriteRuleSubtreeStream(adaptor,"rule expression");
RewriteRuleSubtreeStream stream_arguments=new RewriteRuleSubtreeStream(adaptor,"rule arguments");
try { DebugEnterRule(GrammarFileName, "postfixExpression");
DebugLocation(885, 2);
try
{
// AS3.g:886:2: ( ( primaryExpression -> primaryExpression ) ( propOrIdent -> ^( PROP_ACCESS $postfixExpression propOrIdent ) | DOT e4xExpression -> ^( E4X_EXPRESSION $postfixExpression e4xExpression ) | E4X_DESC e4xExpression -> ^( E4X_EXPRESSION $postfixExpression E4X_DESC e4xExpression ) | LBRACK expression RBRACK -> ^( ARRAY_ACCESS $postfixExpression ^( ARRAY_SUBSCRIPT LBRACK expression RBRACK ) ) | arguments -> ^( FUNCTION_CALL $postfixExpression arguments ) )* ( INC -> ^( POST_INC $postfixExpression INC ) | DEC -> ^( POST_DEC $postfixExpression DEC ) )? )
DebugEnterAlt(1);
// AS3.g:886:4: ( primaryExpression -> primaryExpression ) ( propOrIdent -> ^( PROP_ACCESS $postfixExpression propOrIdent ) | DOT e4xExpression -> ^( E4X_EXPRESSION $postfixExpression e4xExpression ) | E4X_DESC e4xExpression -> ^( E4X_EXPRESSION $postfixExpression E4X_DESC e4xExpression ) | LBRACK expression RBRACK -> ^( ARRAY_ACCESS $postfixExpression ^( ARRAY_SUBSCRIPT LBRACK expression RBRACK ) ) | arguments -> ^( FUNCTION_CALL $postfixExpression arguments ) )* ( INC -> ^( POST_INC $postfixExpression INC ) | DEC -> ^( POST_DEC $postfixExpression DEC ) )?
{
DebugLocation(886, 4);
// AS3.g:886:4: ( primaryExpression -> primaryExpression )
DebugEnterAlt(1);
// AS3.g:886:5: primaryExpression
{
DebugLocation(886, 5);
PushFollow(Follow._primaryExpression_in_postfixExpression4595);
primaryExpression381=primaryExpression();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_primaryExpression.Add(primaryExpression381.Tree);
{
// AST REWRITE
// elements: primaryExpression
// 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();
// 886:23: -> primaryExpression
{
DebugLocation(886, 26);
adaptor.AddChild(root_0, stream_primaryExpression.NextTree());
}
retval.Tree = root_0;
}
}
}
DebugLocation(887, 3);
// AS3.g:887:3: ( propOrIdent -> ^( PROP_ACCESS $postfixExpression propOrIdent ) | DOT e4xExpression -> ^( E4X_EXPRESSION $postfixExpression e4xExpression ) | E4X_DESC e4xExpression -> ^( E4X_EXPRESSION $postfixExpression E4X_DESC e4xExpression ) | LBRACK expression RBRACK -> ^( ARRAY_ACCESS $postfixExpression ^( ARRAY_SUBSCRIPT LBRACK expression RBRACK ) ) | arguments -> ^( FUNCTION_CALL $postfixExpression arguments ) )*
try { DebugEnterSubRule(87);
while (true)
{
int alt87=6;
try { DebugEnterDecision(87, false);
switch (input.LA(1))
{
case DOT:
{
int LA87_2 = input.LA(2);
if ((LA87_2==AS||LA87_2==DYNAMIC||LA87_2==GET||LA87_2==IDENT||(LA87_2>=INTERNAL && LA87_2<=IS)||LA87_2==NAMESPACE||LA87_2==PRIVATE||(LA87_2>=PROTECTED && LA87_2<=PUBLIC)||LA87_2==SET||LA87_2==SUPER||LA87_2==USE||LA87_2==XML))
{
alt87 = 1;
}
else if ((LA87_2==E4X_ATTRI||LA87_2==LPAREN||LA87_2==STAR))
{
alt87 = 2;
}
}
break;
case E4X_DESC:
{
alt87 = 3;
}
break;
case LBRACK:
{
alt87 = 4;
}
break;
case LPAREN:
{
alt87 = 5;
}
break;
}
} finally { DebugExitDecision(87); }
switch ( alt87 )
{
case 1:
DebugEnterAlt(1);
// AS3.g:888:13: propOrIdent
{
DebugLocation(888, 13);
PushFollow(Follow._propOrIdent_in_postfixExpression4619);
propOrIdent382=propOrIdent();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_propOrIdent.Add(propOrIdent382.Tree);
{
// AST REWRITE
// elements: postfixExpression, propOrIdent
// 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();
// 889:13: -> ^( PROP_ACCESS $postfixExpression propOrIdent )
{
DebugLocation(889, 16);
// AS3.g:889:16: ^( PROP_ACCESS $postfixExpression propOrIdent )
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(889, 18);
root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(PROP_ACCESS, "PROP_ACCESS"), root_1);
DebugLocation(889, 31);
adaptor.AddChild(root_1, stream_retval.NextTree());
DebugLocation(889, 49);
adaptor.AddChild(root_1, stream_propOrIdent.NextTree());
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;
}
}
}
break;
case 2:
DebugEnterAlt(2);
// AS3.g:892:13: DOT e4xExpression
{
DebugLocation(892, 13);
DOT383=(IToken)Match(input,DOT,Follow._DOT_in_postfixExpression4674); if (state.failed) return retval;
if (state.backtracking == 0) stream_DOT.Add(DOT383);
DebugLocation(892, 17);
PushFollow(Follow._e4xExpression_in_postfixExpression4676);
e4xExpression384=e4xExpression();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_e4xExpression.Add(e4xExpression384.Tree);
{
// AST REWRITE
// elements: postfixExpression, e4xExpression
// 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();
// 893:13: -> ^( E4X_EXPRESSION $postfixExpression e4xExpression )
{
DebugLocation(893, 16);
// AS3.g:893:16: ^( E4X_EXPRESSION $postfixExpression e4xExpression )
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(893, 18);
root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(E4X_EXPRESSION, "E4X_EXPRESSION"), root_1);
DebugLocation(893, 34);
adaptor.AddChild(root_1, stream_retval.NextTree());
DebugLocation(893, 52);
adaptor.AddChild(root_1, stream_e4xExpression.NextTree());
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;
}
}
}
break;
case 3:
DebugEnterAlt(3);
// AS3.g:896:13: E4X_DESC e4xExpression
{
DebugLocation(896, 13);
E4X_DESC385=(IToken)Match(input,E4X_DESC,Follow._E4X_DESC_in_postfixExpression4719); if (state.failed) return retval;
if (state.backtracking == 0) stream_E4X_DESC.Add(E4X_DESC385);
DebugLocation(896, 22);
PushFollow(Follow._e4xExpression_in_postfixExpression4721);
e4xExpression386=e4xExpression();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_e4xExpression.Add(e4xExpression386.Tree);
{
// AST REWRITE
// elements: postfixExpression, E4X_DESC, e4xExpression
// 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();
// 897:13: -> ^( E4X_EXPRESSION $postfixExpression E4X_DESC e4xExpression )
{
DebugLocation(897, 16);
// AS3.g:897:16: ^( E4X_EXPRESSION $postfixExpression E4X_DESC e4xExpression )
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(897, 18);
root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(E4X_EXPRESSION, "E4X_EXPRESSION"), root_1);
DebugLocation(897, 34);
adaptor.AddChild(root_1, stream_retval.NextTree());
DebugLocation(897, 52);
adaptor.AddChild(root_1, stream_E4X_DESC.NextNode());
DebugLocation(897, 61);
adaptor.AddChild(root_1, stream_e4xExpression.NextTree());
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;
}
}
}
break;
case 4:
DebugEnterAlt(4);
// AS3.g:900:13: LBRACK expression RBRACK
{
DebugLocation(900, 13);
LBRACK387=(IToken)Match(input,LBRACK,Follow._LBRACK_in_postfixExpression4778); if (state.failed) return retval;
if (state.backtracking == 0) stream_LBRACK.Add(LBRACK387);
DebugLocation(900, 20);
PushFollow(Follow._expression_in_postfixExpression4780);
expression388=expression();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_expression.Add(expression388.Tree);
DebugLocation(900, 31);
RBRACK389=(IToken)Match(input,RBRACK,Follow._RBRACK_in_postfixExpression4782); if (state.failed) return retval;
if (state.backtracking == 0) stream_RBRACK.Add(RBRACK389);
{
// AST REWRITE
// elements: postfixExpression, LBRACK, expression, RBRACK
// 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();
// 901:13: -> ^( ARRAY_ACCESS $postfixExpression ^( ARRAY_SUBSCRIPT LBRACK expression RBRACK ) )
{
DebugLocation(901, 16);
// AS3.g:901:16: ^( ARRAY_ACCESS $postfixExpression ^( ARRAY_SUBSCRIPT LBRACK expression RBRACK ) )
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(901, 18);
root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(ARRAY_ACCESS, "ARRAY_ACCESS"), root_1);
DebugLocation(901, 32);
adaptor.AddChild(root_1, stream_retval.NextTree());
DebugLocation(901, 50);
// AS3.g:901:50: ^( ARRAY_SUBSCRIPT LBRACK expression RBRACK )
{
CommonTree root_2 = (CommonTree)adaptor.Nil();
DebugLocation(901, 52);
root_2 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(ARRAY_SUBSCRIPT, "ARRAY_SUBSCRIPT"), root_2);
DebugLocation(901, 68);
adaptor.AddChild(root_2, stream_LBRACK.NextNode());
DebugLocation(901, 75);
adaptor.AddChild(root_2, stream_expression.NextTree());
DebugLocation(901, 86);
adaptor.AddChild(root_2, stream_RBRACK.NextNode());
adaptor.AddChild(root_1, root_2);
}
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;
}
}
}
break;
case 5:
DebugEnterAlt(5);
// AS3.g:904:13: arguments
{
DebugLocation(904, 13);
PushFollow(Follow._arguments_in_postfixExpression4833);
arguments390=arguments();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_arguments.Add(arguments390.Tree);
{
// AST REWRITE
// elements: postfixExpression, arguments
// 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();
// 905:13: -> ^( FUNCTION_CALL $postfixExpression arguments )
{
DebugLocation(905, 16);
// AS3.g:905:16: ^( FUNCTION_CALL $postfixExpression arguments )
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(905, 18);
root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(FUNCTION_CALL, "FUNCTION_CALL"), root_1);
DebugLocation(905, 33);
adaptor.AddChild(root_1, stream_retval.NextTree());
DebugLocation(905, 51);
adaptor.AddChild(root_1, stream_arguments.NextTree());
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;
}
}
}
break;
default:
goto loop87;
}
}
loop87:
;
} finally { DebugExitSubRule(87); }
DebugLocation(908, 3);
// AS3.g:908:3: ( INC -> ^( POST_INC $postfixExpression INC ) | DEC -> ^( POST_DEC $postfixExpression DEC ) )?
int alt88=3;
try { DebugEnterSubRule(88);
try { DebugEnterDecision(88, false);
int LA88_1 = input.LA(1);
if ((LA88_1==INC))
{
alt88 = 1;
}
else if ((LA88_1==DEC))
{
alt88 = 2;
}
} finally { DebugExitDecision(88); }
switch (alt88)
{
case 1:
DebugEnterAlt(1);
// AS3.g:908:6: INC
{
DebugLocation(908, 6);
INC391=(IToken)Match(input,INC,Follow._INC_in_postfixExpression4877); if (state.failed) return retval;
if (state.backtracking == 0) stream_INC.Add(INC391);
{
// AST REWRITE
// elements: postfixExpression, INC
// 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();
// 908:10: -> ^( POST_INC $postfixExpression INC )
{
DebugLocation(908, 13);
// AS3.g:908:13: ^( POST_INC $postfixExpression INC )
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(908, 15);
root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(POST_INC, "POST_INC"), root_1);
DebugLocation(908, 25);
adaptor.AddChild(root_1, stream_retval.NextTree());
DebugLocation(908, 43);
adaptor.AddChild(root_1, stream_INC.NextNode());
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;
}
}
}
break;
case 2:
DebugEnterAlt(2);
// AS3.g:909:6: DEC
{
DebugLocation(909, 6);
DEC392=(IToken)Match(input,DEC,Follow._DEC_in_postfixExpression4895); if (state.failed) return retval;
if (state.backtracking == 0) stream_DEC.Add(DEC392);
{
// AST REWRITE
// elements: postfixExpression, DEC
// 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();
// 909:10: -> ^( POST_DEC $postfixExpression DEC )
{
DebugLocation(909, 13);
// AS3.g:909:13: ^( POST_DEC $postfixExpression DEC )
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(909, 15);
root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(POST_DEC, "POST_DEC"), root_1);
DebugLocation(909, 25);
adaptor.AddChild(root_1, stream_retval.NextTree());
DebugLocation(909, 43);
adaptor.AddChild(root_1, stream_DEC.NextNode());
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;
}
}
}
break;
}
} finally { DebugExitSubRule(88); }
}
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("postfixExpression", 119);
LeaveRule("postfixExpression", 119);
LeaveRule_postfixExpression();
}
DebugLocation(912, 2);
} finally { DebugExitRule(GrammarFileName, "postfixExpression"); }
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);
}
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 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 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;
}
private AstParserRuleReturnScope<CommonTree, IToken> newExpression()
{
EnterRule_newExpression();
EnterRule("newExpression", 132);
TraceIn("newExpression", 132);
AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>();
retval.Start = (IToken)input.LT(1);
CommonTree root_0 = default(CommonTree);
IToken NEW430 = default(IToken);
AstParserRuleReturnScope<CommonTree, IToken> fullNewSubexpression431 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> arguments432 = default(AstParserRuleReturnScope<CommonTree, IToken>);
CommonTree NEW430_tree = default(CommonTree);
RewriteRuleITokenStream stream_NEW=new RewriteRuleITokenStream(adaptor,"token NEW");
RewriteRuleSubtreeStream stream_fullNewSubexpression=new RewriteRuleSubtreeStream(adaptor,"rule fullNewSubexpression");
RewriteRuleSubtreeStream stream_arguments=new RewriteRuleSubtreeStream(adaptor,"rule arguments");
try { DebugEnterRule(GrammarFileName, "newExpression");
DebugLocation(1002, 1);
try
{
// AS3.g:1003:2: ( NEW fullNewSubexpression arguments -> ^( NEW_EXPRESSION NEW fullNewSubexpression arguments ) )
DebugEnterAlt(1);
// AS3.g:1003:4: NEW fullNewSubexpression arguments
{
DebugLocation(1003, 4);
NEW430=(IToken)Match(input,NEW,Follow._NEW_in_newExpression5320); if (state.failed) return retval;
if (state.backtracking == 0) stream_NEW.Add(NEW430);
DebugLocation(1003, 8);
PushFollow(Follow._fullNewSubexpression_in_newExpression5322);
fullNewSubexpression431=fullNewSubexpression();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_fullNewSubexpression.Add(fullNewSubexpression431.Tree);
DebugLocation(1003, 29);
PushFollow(Follow._arguments_in_newExpression5324);
arguments432=arguments();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_arguments.Add(arguments432.Tree);
{
// AST REWRITE
// elements: NEW, fullNewSubexpression, arguments
// 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();
// 1003:39: -> ^( NEW_EXPRESSION NEW fullNewSubexpression arguments )
{
DebugLocation(1003, 42);
// AS3.g:1003:42: ^( NEW_EXPRESSION NEW fullNewSubexpression arguments )
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(1003, 44);
root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(NEW_EXPRESSION, "NEW_EXPRESSION"), root_1);
DebugLocation(1003, 59);
adaptor.AddChild(root_1, stream_NEW.NextNode());
DebugLocation(1003, 63);
adaptor.AddChild(root_1, stream_fullNewSubexpression.NextTree());
DebugLocation(1003, 84);
adaptor.AddChild(root_1, stream_arguments.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("newExpression", 132);
LeaveRule("newExpression", 132);
LeaveRule_newExpression();
}
DebugLocation(1004, 1);
} finally { DebugExitRule(GrammarFileName, "newExpression"); }
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<CommonTree, IToken> interfaceDefinition()
{
EnterRule_interfaceDefinition();
EnterRule("interfaceDefinition", 12);
TraceIn("interfaceDefinition", 12);
AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>();
retval.Start = (IToken)input.LT(1);
CommonTree root_0 = default(CommonTree);
IToken INTERFACE43 = default(IToken);
AstParserRuleReturnScope<CommonTree, IToken> modifiers42 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> ident44 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> interfaceExtendsClause45 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> typeBlock46 = default(AstParserRuleReturnScope<CommonTree, IToken>);
CommonTree INTERFACE43_tree = default(CommonTree);
RewriteRuleITokenStream stream_INTERFACE=new RewriteRuleITokenStream(adaptor,"token INTERFACE");
RewriteRuleSubtreeStream stream_modifiers=new RewriteRuleSubtreeStream(adaptor,"rule modifiers");
RewriteRuleSubtreeStream stream_ident=new RewriteRuleSubtreeStream(adaptor,"rule ident");
RewriteRuleSubtreeStream stream_interfaceExtendsClause=new RewriteRuleSubtreeStream(adaptor,"rule interfaceExtendsClause");
RewriteRuleSubtreeStream stream_typeBlock=new RewriteRuleSubtreeStream(adaptor,"rule typeBlock");
try { DebugEnterRule(GrammarFileName, "interfaceDefinition");
DebugLocation(194, 1);
try
{
// AS3.g:195:2: ( modifiers INTERFACE ident ( interfaceExtendsClause )? typeBlock -> ^( INTERFACE_DEF modifiers INTERFACE ident ( interfaceExtendsClause )? typeBlock ) )
DebugEnterAlt(1);
// AS3.g:195:4: modifiers INTERFACE ident ( interfaceExtendsClause )? typeBlock
{
DebugLocation(195, 4);
PushFollow(Follow._modifiers_in_interfaceDefinition981);
modifiers42=modifiers();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_modifiers.Add(modifiers42.Tree);
DebugLocation(196, 3);
INTERFACE43=(IToken)Match(input,INTERFACE,Follow._INTERFACE_in_interfaceDefinition985); if (state.failed) return retval;
if (state.backtracking == 0) stream_INTERFACE.Add(INTERFACE43);
DebugLocation(196, 13);
PushFollow(Follow._ident_in_interfaceDefinition987);
ident44=ident();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_ident.Add(ident44.Tree);
DebugLocation(197, 3);
// AS3.g:197:3: ( interfaceExtendsClause )?
int alt12=2;
try { DebugEnterSubRule(12);
try { DebugEnterDecision(12, false);
int LA12_1 = input.LA(1);
if ((LA12_1==EXTENDS))
{
alt12 = 1;
}
} finally { DebugExitDecision(12); }
switch (alt12)
{
case 1:
DebugEnterAlt(1);
// AS3.g:197:3: interfaceExtendsClause
{
DebugLocation(197, 3);
PushFollow(Follow._interfaceExtendsClause_in_interfaceDefinition991);
interfaceExtendsClause45=interfaceExtendsClause();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_interfaceExtendsClause.Add(interfaceExtendsClause45.Tree);
}
break;
}
} finally { DebugExitSubRule(12); }
DebugLocation(198, 3);
PushFollow(Follow._typeBlock_in_interfaceDefinition996);
typeBlock46=typeBlock();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_typeBlock.Add(typeBlock46.Tree);
{
// AST REWRITE
// elements: modifiers, INTERFACE, ident, interfaceExtendsClause, typeBlock
// 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();
// 199:3: -> ^( INTERFACE_DEF modifiers INTERFACE ident ( interfaceExtendsClause )? typeBlock )
{
DebugLocation(199, 6);
// AS3.g:199:6: ^( INTERFACE_DEF modifiers INTERFACE ident ( interfaceExtendsClause )? typeBlock )
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(199, 8);
root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(INTERFACE_DEF, "INTERFACE_DEF"), root_1);
DebugLocation(199, 22);
adaptor.AddChild(root_1, stream_modifiers.NextTree());
DebugLocation(199, 32);
adaptor.AddChild(root_1, stream_INTERFACE.NextNode());
DebugLocation(199, 42);
adaptor.AddChild(root_1, stream_ident.NextTree());
DebugLocation(199, 48);
// AS3.g:199:48: ( interfaceExtendsClause )?
if (stream_interfaceExtendsClause.HasNext)
{
DebugLocation(199, 48);
adaptor.AddChild(root_1, stream_interfaceExtendsClause.NextTree());
}
stream_interfaceExtendsClause.Reset();
DebugLocation(199, 72);
adaptor.AddChild(root_1, stream_typeBlock.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("interfaceDefinition", 12);
LeaveRule("interfaceDefinition", 12);
LeaveRule_interfaceDefinition();
}
DebugLocation(200, 1);
} finally { DebugExitRule(GrammarFileName, "interfaceDefinition"); }
return retval;
}
private AstParserRuleReturnScope<CommonTree, IToken> basicParameterDeclaration()
{
EnterRule_basicParameterDeclaration();
EnterRule("basicParameterDeclaration", 35);
TraceIn("basicParameterDeclaration", 35);
AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>();
retval.Start = (IToken)input.LT(1);
CommonTree root_0 = default(CommonTree);
IToken CONST114 = default(IToken);
AstParserRuleReturnScope<CommonTree, IToken> ident115 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> typeExpression116 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> parameterDefault117 = default(AstParserRuleReturnScope<CommonTree, IToken>);
CommonTree CONST114_tree = default(CommonTree);
RewriteRuleITokenStream stream_CONST=new RewriteRuleITokenStream(adaptor,"token CONST");
RewriteRuleSubtreeStream stream_ident=new RewriteRuleSubtreeStream(adaptor,"rule ident");
RewriteRuleSubtreeStream stream_typeExpression=new RewriteRuleSubtreeStream(adaptor,"rule typeExpression");
RewriteRuleSubtreeStream stream_parameterDefault=new RewriteRuleSubtreeStream(adaptor,"rule parameterDefault");
try { DebugEnterRule(GrammarFileName, "basicParameterDeclaration");
DebugLocation(343, 1);
try
{
// AS3.g:344:2: ( ( CONST )? ident ( typeExpression )? ( parameterDefault )? -> ^( PARAM ( CONST )? ident ( typeExpression )? ( parameterDefault )? ) )
DebugEnterAlt(1);
// AS3.g:344:4: ( CONST )? ident ( typeExpression )? ( parameterDefault )?
{
DebugLocation(344, 4);
// AS3.g:344:4: ( CONST )?
int alt28=2;
try { DebugEnterSubRule(28);
try { DebugEnterDecision(28, false);
int LA28_1 = input.LA(1);
if ((LA28_1==CONST))
{
alt28 = 1;
}
} finally { DebugExitDecision(28); }
switch (alt28)
{
case 1:
DebugEnterAlt(1);
// AS3.g:344:4: CONST
{
DebugLocation(344, 4);
CONST114=(IToken)Match(input,CONST,Follow._CONST_in_basicParameterDeclaration1877); if (state.failed) return retval;
if (state.backtracking == 0) stream_CONST.Add(CONST114);
}
break;
}
} finally { DebugExitSubRule(28); }
DebugLocation(344, 11);
PushFollow(Follow._ident_in_basicParameterDeclaration1880);
ident115=ident();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_ident.Add(ident115.Tree);
DebugLocation(344, 17);
// AS3.g:344:17: ( typeExpression )?
int alt29=2;
try { DebugEnterSubRule(29);
try { DebugEnterDecision(29, false);
int LA29_1 = input.LA(1);
if ((LA29_1==COLON))
{
alt29 = 1;
}
} finally { DebugExitDecision(29); }
switch (alt29)
{
case 1:
DebugEnterAlt(1);
// AS3.g:344:17: typeExpression
{
DebugLocation(344, 17);
PushFollow(Follow._typeExpression_in_basicParameterDeclaration1882);
typeExpression116=typeExpression();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_typeExpression.Add(typeExpression116.Tree);
}
break;
}
} finally { DebugExitSubRule(29); }
DebugLocation(344, 33);
// AS3.g:344:33: ( parameterDefault )?
int alt30=2;
try { DebugEnterSubRule(30);
try { DebugEnterDecision(30, false);
int LA30_1 = input.LA(1);
if ((LA30_1==ASSIGN))
{
alt30 = 1;
}
} finally { DebugExitDecision(30); }
switch (alt30)
{
case 1:
DebugEnterAlt(1);
// AS3.g:344:33: parameterDefault
{
DebugLocation(344, 33);
PushFollow(Follow._parameterDefault_in_basicParameterDeclaration1885);
parameterDefault117=parameterDefault();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_parameterDefault.Add(parameterDefault117.Tree);
}
break;
}
} finally { DebugExitSubRule(30); }
{
// AST REWRITE
// elements: CONST, ident, typeExpression, parameterDefault
// 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();
// 345:3: -> ^( PARAM ( CONST )? ident ( typeExpression )? ( parameterDefault )? )
{
DebugLocation(345, 6);
// AS3.g:345:6: ^( PARAM ( CONST )? ident ( typeExpression )? ( parameterDefault )? )
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(345, 8);
root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(PARAM, "PARAM"), root_1);
DebugLocation(345, 14);
// AS3.g:345:14: ( CONST )?
if (stream_CONST.HasNext)
{
DebugLocation(345, 14);
adaptor.AddChild(root_1, stream_CONST.NextNode());
}
stream_CONST.Reset();
DebugLocation(345, 21);
adaptor.AddChild(root_1, stream_ident.NextTree());
DebugLocation(345, 27);
// AS3.g:345:27: ( typeExpression )?
if (stream_typeExpression.HasNext)
{
DebugLocation(345, 27);
adaptor.AddChild(root_1, stream_typeExpression.NextTree());
}
stream_typeExpression.Reset();
DebugLocation(345, 43);
// AS3.g:345:43: ( parameterDefault )?
if (stream_parameterDefault.HasNext)
{
DebugLocation(345, 43);
adaptor.AddChild(root_1, stream_parameterDefault.NextTree());
}
stream_parameterDefault.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("basicParameterDeclaration", 35);
LeaveRule("basicParameterDeclaration", 35);
LeaveRule_basicParameterDeclaration();
}
DebugLocation(346, 1);
} finally { DebugExitRule(GrammarFileName, "basicParameterDeclaration"); }
return retval;
}
private AstParserRuleReturnScope<CommonTree, IToken> classExtendsClause()
{
EnterRule_classExtendsClause();
EnterRule("classExtendsClause", 14);
TraceIn("classExtendsClause", 14);
AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>();
retval.Start = (IToken)input.LT(1);
CommonTree root_0 = default(CommonTree);
IToken EXTENDS52 = default(IToken);
AstParserRuleReturnScope<CommonTree, IToken> identifier53 = default(AstParserRuleReturnScope<CommonTree, IToken>);
CommonTree EXTENDS52_tree = default(CommonTree);
RewriteRuleITokenStream stream_EXTENDS=new RewriteRuleITokenStream(adaptor,"token EXTENDS");
RewriteRuleSubtreeStream stream_identifier=new RewriteRuleSubtreeStream(adaptor,"rule identifier");
try { DebugEnterRule(GrammarFileName, "classExtendsClause");
DebugLocation(210, 1);
try
{
// AS3.g:211:2: ( EXTENDS identifier -> ^( EXTENDS_CLAUSE EXTENDS identifier ) )
DebugEnterAlt(1);
// AS3.g:211:4: EXTENDS identifier
{
DebugLocation(211, 4);
EXTENDS52=(IToken)Match(input,EXTENDS,Follow._EXTENDS_in_classExtendsClause1069); if (state.failed) return retval;
if (state.backtracking == 0) stream_EXTENDS.Add(EXTENDS52);
DebugLocation(211, 12);
PushFollow(Follow._identifier_in_classExtendsClause1071);
identifier53=identifier();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_identifier.Add(identifier53.Tree);
{
// AST REWRITE
// elements: EXTENDS, identifier
// 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();
// 212:9: -> ^( EXTENDS_CLAUSE EXTENDS identifier )
{
DebugLocation(212, 12);
// AS3.g:212:12: ^( EXTENDS_CLAUSE EXTENDS identifier )
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(212, 14);
root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(EXTENDS_CLAUSE, "EXTENDS_CLAUSE"), root_1);
DebugLocation(212, 29);
adaptor.AddChild(root_1, stream_EXTENDS.NextNode());
DebugLocation(212, 37);
adaptor.AddChild(root_1, stream_identifier.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("classExtendsClause", 14);
LeaveRule("classExtendsClause", 14);
LeaveRule_classExtendsClause();
}
DebugLocation(213, 1);
} finally { DebugExitRule(GrammarFileName, "classExtendsClause"); }
return retval;
}
private AstParserRuleReturnScope<CommonTree, IToken> block()
{
EnterRule_block();
EnterRule("block", 38);
TraceIn("block", 38);
AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>();
retval.Start = (IToken)input.LT(1);
CommonTree root_0 = default(CommonTree);
IToken LCURLY123 = default(IToken);
IToken RCURLY125 = default(IToken);
AstParserRuleReturnScope<CommonTree, IToken> blockEntry124 = default(AstParserRuleReturnScope<CommonTree, IToken>);
CommonTree LCURLY123_tree = default(CommonTree);
CommonTree RCURLY125_tree = default(CommonTree);
RewriteRuleITokenStream stream_LCURLY=new RewriteRuleITokenStream(adaptor,"token LCURLY");
RewriteRuleITokenStream stream_RCURLY=new RewriteRuleITokenStream(adaptor,"token RCURLY");
RewriteRuleSubtreeStream stream_blockEntry=new RewriteRuleSubtreeStream(adaptor,"rule blockEntry");
try { DebugEnterRule(GrammarFileName, "block");
DebugLocation(357, 1);
try
{
// AS3.g:358:2: ( LCURLY ( blockEntry )* RCURLY -> ^( BLOCK LCURLY ( blockEntry )* RCURLY ) )
DebugEnterAlt(1);
// AS3.g:358:4: LCURLY ( blockEntry )* RCURLY
{
DebugLocation(358, 4);
LCURLY123=(IToken)Match(input,LCURLY,Follow._LCURLY_in_block1964); if (state.failed) return retval;
if (state.backtracking == 0) stream_LCURLY.Add(LCURLY123);
DebugLocation(358, 11);
// AS3.g:358:11: ( blockEntry )*
try { DebugEnterSubRule(33);
while (true)
{
int alt33=2;
try { DebugEnterDecision(33, false);
int LA33_1 = input.LA(1);
if ((LA33_1==AS||LA33_1==BNOT||LA33_1==BREAK||LA33_1==CONST||LA33_1==CONTINUE||(LA33_1>=DEC && LA33_1<=DECIMAL_LITERAL)||LA33_1==DEFAULT||LA33_1==DO||(LA33_1>=DYNAMIC && LA33_1<=E4X_ATTRI)||(LA33_1>=FALSE && LA33_1<=FOR)||LA33_1==FUNCTION||LA33_1==GET||(LA33_1>=HEX_LITERAL && LA33_1<=IDENT)||LA33_1==IF||LA33_1==INC||(LA33_1>=INTERNAL && LA33_1<=IS)||(LA33_1>=LBRACK && LA33_1<=LCURLY)||LA33_1==LNOT||LA33_1==LPAREN||LA33_1==MINUS||LA33_1==NAMESPACE||LA33_1==NEW||LA33_1==NULL||LA33_1==OCTAL_LITERAL||LA33_1==PLUS||LA33_1==PRIVATE||(LA33_1>=PROTECTED && LA33_1<=PUBLIC)||LA33_1==REGEX_LITERAL||LA33_1==RETURN||(LA33_1>=SEMI && LA33_1<=SET)||(LA33_1>=STRING_LITERAL_DOUBLE && LA33_1<=SWITCH)||LA33_1==TRUE||(LA33_1>=USE && LA33_1<=VAR)||LA33_1==WHILE||LA33_1==WITH||LA33_1==XML||LA33_1==XML_LITERAL||LA33_1==243||(LA33_1>=253 && LA33_1<=257)))
{
alt33 = 1;
}
} finally { DebugExitDecision(33); }
switch ( alt33 )
{
case 1:
DebugEnterAlt(1);
// AS3.g:358:11: blockEntry
{
DebugLocation(358, 11);
PushFollow(Follow._blockEntry_in_block1966);
blockEntry124=blockEntry();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_blockEntry.Add(blockEntry124.Tree);
}
break;
default:
goto loop33;
}
}
loop33:
;
} finally { DebugExitSubRule(33); }
DebugLocation(358, 23);
RCURLY125=(IToken)Match(input,RCURLY,Follow._RCURLY_in_block1969); if (state.failed) return retval;
if (state.backtracking == 0) stream_RCURLY.Add(RCURLY125);
{
// AST REWRITE
// elements: LCURLY, blockEntry, 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();
// 359:3: -> ^( BLOCK LCURLY ( blockEntry )* RCURLY )
{
DebugLocation(359, 6);
// AS3.g:359:6: ^( BLOCK LCURLY ( blockEntry )* RCURLY )
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(359, 8);
root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(BLOCK, "BLOCK"), root_1);
DebugLocation(359, 14);
adaptor.AddChild(root_1, stream_LCURLY.NextNode());
DebugLocation(359, 21);
// AS3.g:359:21: ( blockEntry )*
while ( stream_blockEntry.HasNext )
{
DebugLocation(359, 21);
adaptor.AddChild(root_1, stream_blockEntry.NextTree());
}
stream_blockEntry.Reset();
DebugLocation(359, 33);
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("block", 38);
LeaveRule("block", 38);
LeaveRule_block();
}
DebugLocation(360, 1);
} finally { DebugExitRule(GrammarFileName, "block"); }
return retval;
}
private AstParserRuleReturnScope<CommonTree, IToken> interfaceExtendsClause()
{
EnterRule_interfaceExtendsClause();
EnterRule("interfaceExtendsClause", 15);
TraceIn("interfaceExtendsClause", 15);
AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>();
retval.Start = (IToken)input.LT(1);
CommonTree root_0 = default(CommonTree);
IToken EXTENDS54 = default(IToken);
IToken COMMA56 = default(IToken);
AstParserRuleReturnScope<CommonTree, IToken> identifier55 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> identifier57 = default(AstParserRuleReturnScope<CommonTree, IToken>);
CommonTree EXTENDS54_tree = default(CommonTree);
CommonTree COMMA56_tree = default(CommonTree);
RewriteRuleITokenStream stream_EXTENDS=new RewriteRuleITokenStream(adaptor,"token EXTENDS");
RewriteRuleITokenStream stream_COMMA=new RewriteRuleITokenStream(adaptor,"token COMMA");
RewriteRuleSubtreeStream stream_identifier=new RewriteRuleSubtreeStream(adaptor,"rule identifier");
try { DebugEnterRule(GrammarFileName, "interfaceExtendsClause");
DebugLocation(215, 1);
try
{
// AS3.g:216:2: ( EXTENDS identifier ( COMMA identifier )* -> ^( EXTENDS_CLAUSE EXTENDS ( identifier )+ ) )
DebugEnterAlt(1);
// AS3.g:216:4: EXTENDS identifier ( COMMA identifier )*
{
DebugLocation(216, 4);
EXTENDS54=(IToken)Match(input,EXTENDS,Follow._EXTENDS_in_interfaceExtendsClause1100); if (state.failed) return retval;
if (state.backtracking == 0) stream_EXTENDS.Add(EXTENDS54);
DebugLocation(216, 12);
PushFollow(Follow._identifier_in_interfaceExtendsClause1102);
identifier55=identifier();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_identifier.Add(identifier55.Tree);
DebugLocation(216, 23);
// AS3.g:216:23: ( COMMA identifier )*
try { DebugEnterSubRule(14);
while (true)
{
int alt14=2;
try { DebugEnterDecision(14, false);
int LA14_1 = input.LA(1);
if ((LA14_1==COMMA))
{
alt14 = 1;
}
} finally { DebugExitDecision(14); }
switch ( alt14 )
{
case 1:
DebugEnterAlt(1);
// AS3.g:216:25: COMMA identifier
{
DebugLocation(216, 25);
COMMA56=(IToken)Match(input,COMMA,Follow._COMMA_in_interfaceExtendsClause1106); if (state.failed) return retval;
if (state.backtracking == 0) stream_COMMA.Add(COMMA56);
DebugLocation(216, 31);
PushFollow(Follow._identifier_in_interfaceExtendsClause1108);
identifier57=identifier();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_identifier.Add(identifier57.Tree);
}
break;
default:
goto loop14;
}
}
loop14:
;
} finally { DebugExitSubRule(14); }
{
// AST REWRITE
// elements: EXTENDS, identifier
// 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();
// 217:9: -> ^( EXTENDS_CLAUSE EXTENDS ( identifier )+ )
{
DebugLocation(217, 12);
// AS3.g:217:12: ^( EXTENDS_CLAUSE EXTENDS ( identifier )+ )
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(217, 14);
root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(EXTENDS_CLAUSE, "EXTENDS_CLAUSE"), root_1);
DebugLocation(217, 29);
adaptor.AddChild(root_1, stream_EXTENDS.NextNode());
DebugLocation(217, 37);
if (!(stream_identifier.HasNext))
{
throw new RewriteEarlyExitException();
}
while ( stream_identifier.HasNext )
{
DebugLocation(217, 37);
adaptor.AddChild(root_1, stream_identifier.NextTree());
}
stream_identifier.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("interfaceExtendsClause", 15);
LeaveRule("interfaceExtendsClause", 15);
LeaveRule_interfaceExtendsClause();
}
DebugLocation(218, 1);
} finally { DebugExitRule(GrammarFileName, "interfaceExtendsClause"); }
return retval;
}
private AstParserRuleReturnScope<CommonTree, IToken> elseClause()
{
EnterRule_elseClause();
EnterRule("elseClause", 45);
TraceIn("elseClause", 45);
AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>();
retval.Start = (IToken)input.LT(1);
CommonTree root_0 = default(CommonTree);
IToken ELSE152 = default(IToken);
AstParserRuleReturnScope<CommonTree, IToken> statement153 = default(AstParserRuleReturnScope<CommonTree, IToken>);
CommonTree ELSE152_tree = default(CommonTree);
RewriteRuleITokenStream stream_ELSE=new RewriteRuleITokenStream(adaptor,"token ELSE");
RewriteRuleSubtreeStream stream_statement=new RewriteRuleSubtreeStream(adaptor,"rule statement");
try { DebugEnterRule(GrammarFileName, "elseClause");
DebugLocation(423, 1);
try
{
// AS3.g:424:2: ( ELSE statement -> ^( ELSE_CLAUSE ELSE statement ) )
DebugEnterAlt(1);
// AS3.g:424:4: ELSE statement
{
DebugLocation(424, 4);
ELSE152=(IToken)Match(input,ELSE,Follow._ELSE_in_elseClause2266); if (state.failed) return retval;
if (state.backtracking == 0) stream_ELSE.Add(ELSE152);
DebugLocation(424, 9);
PushFollow(Follow._statement_in_elseClause2268);
statement153=statement();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_statement.Add(statement153.Tree);
{
// AST REWRITE
// elements: ELSE, 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();
// 425:9: -> ^( ELSE_CLAUSE ELSE statement )
{
DebugLocation(425, 12);
// AS3.g:425:12: ^( ELSE_CLAUSE ELSE statement )
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(425, 14);
root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(ELSE_CLAUSE, "ELSE_CLAUSE"), root_1);
DebugLocation(425, 26);
adaptor.AddChild(root_1, stream_ELSE.NextNode());
DebugLocation(425, 31);
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("elseClause", 45);
LeaveRule("elseClause", 45);
LeaveRule_elseClause();
}
DebugLocation(426, 1);
} finally { DebugExitRule(GrammarFileName, "elseClause"); }
return retval;
}
private AstParserRuleReturnScope<CommonTree, IToken> implementsClause()
{
EnterRule_implementsClause();
EnterRule("implementsClause", 16);
TraceIn("implementsClause", 16);
AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>();
retval.Start = (IToken)input.LT(1);
CommonTree root_0 = default(CommonTree);
IToken IMPLEMENTS58 = default(IToken);
IToken COMMA60 = default(IToken);
AstParserRuleReturnScope<CommonTree, IToken> identifier59 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> identifier61 = default(AstParserRuleReturnScope<CommonTree, IToken>);
CommonTree IMPLEMENTS58_tree = default(CommonTree);
CommonTree COMMA60_tree = default(CommonTree);
RewriteRuleITokenStream stream_IMPLEMENTS=new RewriteRuleITokenStream(adaptor,"token IMPLEMENTS");
RewriteRuleITokenStream stream_COMMA=new RewriteRuleITokenStream(adaptor,"token COMMA");
RewriteRuleSubtreeStream stream_identifier=new RewriteRuleSubtreeStream(adaptor,"rule identifier");
try { DebugEnterRule(GrammarFileName, "implementsClause");
DebugLocation(220, 1);
try
{
// AS3.g:221:2: ( IMPLEMENTS identifier ( COMMA identifier )* -> ^( IMPLEMENTS_CLAUSE IMPLEMENTS ( identifier )+ ) )
DebugEnterAlt(1);
// AS3.g:221:4: IMPLEMENTS identifier ( COMMA identifier )*
{
DebugLocation(221, 4);
IMPLEMENTS58=(IToken)Match(input,IMPLEMENTS,Follow._IMPLEMENTS_in_implementsClause1140); if (state.failed) return retval;
if (state.backtracking == 0) stream_IMPLEMENTS.Add(IMPLEMENTS58);
DebugLocation(221, 15);
PushFollow(Follow._identifier_in_implementsClause1142);
identifier59=identifier();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_identifier.Add(identifier59.Tree);
DebugLocation(221, 26);
// AS3.g:221:26: ( COMMA identifier )*
try { DebugEnterSubRule(15);
while (true)
{
int alt15=2;
try { DebugEnterDecision(15, false);
int LA15_1 = input.LA(1);
if ((LA15_1==COMMA))
{
alt15 = 1;
}
} finally { DebugExitDecision(15); }
switch ( alt15 )
{
case 1:
DebugEnterAlt(1);
// AS3.g:221:28: COMMA identifier
{
DebugLocation(221, 28);
COMMA60=(IToken)Match(input,COMMA,Follow._COMMA_in_implementsClause1146); if (state.failed) return retval;
if (state.backtracking == 0) stream_COMMA.Add(COMMA60);
DebugLocation(221, 34);
PushFollow(Follow._identifier_in_implementsClause1148);
identifier61=identifier();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_identifier.Add(identifier61.Tree);
}
break;
default:
goto loop15;
}
}
loop15:
;
} finally { DebugExitSubRule(15); }
{
// AST REWRITE
// elements: IMPLEMENTS, identifier
// 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();
// 222:9: -> ^( IMPLEMENTS_CLAUSE IMPLEMENTS ( identifier )+ )
{
DebugLocation(222, 12);
// AS3.g:222:12: ^( IMPLEMENTS_CLAUSE IMPLEMENTS ( identifier )+ )
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(222, 14);
root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(IMPLEMENTS_CLAUSE, "IMPLEMENTS_CLAUSE"), root_1);
DebugLocation(222, 32);
adaptor.AddChild(root_1, stream_IMPLEMENTS.NextNode());
DebugLocation(222, 43);
if (!(stream_identifier.HasNext))
{
throw new RewriteEarlyExitException();
}
while ( stream_identifier.HasNext )
{
DebugLocation(222, 43);
adaptor.AddChild(root_1, stream_identifier.NextTree());
}
stream_identifier.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("implementsClause", 16);
LeaveRule("implementsClause", 16);
LeaveRule_implementsClause();
}
DebugLocation(223, 1);
} finally { DebugExitRule(GrammarFileName, "implementsClause"); }
return retval;
}
private AstParserRuleReturnScope<CommonTree, IToken> tryStatement()
{
EnterRule_tryStatement();
EnterRule("tryStatement", 47);
TraceIn("tryStatement", 47);
AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>();
retval.Start = (IToken)input.LT(1);
CommonTree root_0 = default(CommonTree);
IToken string_literal156 = default(IToken);
AstParserRuleReturnScope<CommonTree, IToken> block157 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> catchBlock158 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> finallyBlock159 = default(AstParserRuleReturnScope<CommonTree, IToken>);
CommonTree string_literal156_tree = default(CommonTree);
RewriteRuleITokenStream stream_254=new RewriteRuleITokenStream(adaptor,"token 254");
RewriteRuleSubtreeStream stream_block=new RewriteRuleSubtreeStream(adaptor,"rule block");
RewriteRuleSubtreeStream stream_catchBlock=new RewriteRuleSubtreeStream(adaptor,"rule catchBlock");
RewriteRuleSubtreeStream stream_finallyBlock=new RewriteRuleSubtreeStream(adaptor,"rule finallyBlock");
try { DebugEnterRule(GrammarFileName, "tryStatement");
DebugLocation(433, 1);
try
{
// AS3.g:434:2: ( 'try' block ( catchBlock )* ( finallyBlock )? -> ^( TRY_STATEMENT 'try' block ( catchBlock )* ( finallyBlock )? ) )
DebugEnterAlt(1);
// AS3.g:434:4: 'try' block ( catchBlock )* ( finallyBlock )?
{
DebugLocation(434, 4);
string_literal156=(IToken)Match(input,254,Follow._254_in_tryStatement2335); if (state.failed) return retval;
if (state.backtracking == 0) stream_254.Add(string_literal156);
DebugLocation(435, 3);
PushFollow(Follow._block_in_tryStatement2339);
block157=block();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_block.Add(block157.Tree);
DebugLocation(436, 3);
// AS3.g:436:3: ( catchBlock )*
try { DebugEnterSubRule(36);
while (true)
{
int alt36=2;
try { DebugEnterDecision(36, false);
int LA36_1 = input.LA(1);
if ((LA36_1==242))
{
alt36 = 1;
}
} finally { DebugExitDecision(36); }
switch ( alt36 )
{
case 1:
DebugEnterAlt(1);
// AS3.g:436:3: catchBlock
{
DebugLocation(436, 3);
PushFollow(Follow._catchBlock_in_tryStatement2343);
catchBlock158=catchBlock();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_catchBlock.Add(catchBlock158.Tree);
}
break;
default:
goto loop36;
}
}
loop36:
;
} finally { DebugExitSubRule(36); }
DebugLocation(437, 3);
// AS3.g:437:3: ( finallyBlock )?
int alt37=2;
try { DebugEnterSubRule(37);
try { DebugEnterDecision(37, false);
int LA37_1 = input.LA(1);
if ((LA37_1==247))
{
alt37 = 1;
}
} finally { DebugExitDecision(37); }
switch (alt37)
{
case 1:
DebugEnterAlt(1);
// AS3.g:437:3: finallyBlock
{
DebugLocation(437, 3);
PushFollow(Follow._finallyBlock_in_tryStatement2348);
finallyBlock159=finallyBlock();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_finallyBlock.Add(finallyBlock159.Tree);
}
break;
}
} finally { DebugExitSubRule(37); }
{
// AST REWRITE
// elements: 254, block, catchBlock, finallyBlock
// 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();
// 438:9: -> ^( TRY_STATEMENT 'try' block ( catchBlock )* ( finallyBlock )? )
{
DebugLocation(438, 12);
// AS3.g:438:12: ^( TRY_STATEMENT 'try' block ( catchBlock )* ( finallyBlock )? )
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(438, 14);
root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(TRY_STATEMENT, "TRY_STATEMENT"), root_1);
DebugLocation(438, 28);
adaptor.AddChild(root_1, stream_254.NextNode());
DebugLocation(438, 34);
adaptor.AddChild(root_1, stream_block.NextTree());
DebugLocation(438, 40);
// AS3.g:438:40: ( catchBlock )*
while ( stream_catchBlock.HasNext )
{
DebugLocation(438, 40);
adaptor.AddChild(root_1, stream_catchBlock.NextTree());
}
stream_catchBlock.Reset();
DebugLocation(438, 52);
// AS3.g:438:52: ( finallyBlock )?
if (stream_finallyBlock.HasNext)
{
DebugLocation(438, 52);
adaptor.AddChild(root_1, stream_finallyBlock.NextTree());
}
stream_finallyBlock.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("tryStatement", 47);
LeaveRule("tryStatement", 47);
LeaveRule_tryStatement();
}
DebugLocation(439, 1);
} finally { DebugExitRule(GrammarFileName, "tryStatement"); }
return retval;
}
private AstParserRuleReturnScope<CommonTree, IToken> includeDirective()
{
EnterRule_includeDirective();
EnterRule("includeDirective", 20);
TraceIn("includeDirective", 20);
AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>();
retval.Start = (IToken)input.LT(1);
CommonTree root_0 = default(CommonTree);
IToken string_literal73 = default(IToken);
AstParserRuleReturnScope<CommonTree, IToken> s = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> stringLiteral74 = default(AstParserRuleReturnScope<CommonTree, IToken>);
CommonTree string_literal73_tree = default(CommonTree);
RewriteRuleITokenStream stream_248=new RewriteRuleITokenStream(adaptor,"token 248");
RewriteRuleSubtreeStream stream_stringLiteral=new RewriteRuleSubtreeStream(adaptor,"rule stringLiteral");
RewriteRuleSubtreeStream stream_semi=new RewriteRuleSubtreeStream(adaptor,"rule semi");
try { DebugEnterRule(GrammarFileName, "includeDirective");
DebugLocation(247, 1);
try
{
// AS3.g:248:2: ( 'include' stringLiteral s= semi -> ^( INCLUDE_DIRECTIVE 'include' stringLiteral ) )
DebugEnterAlt(1);
// AS3.g:248:4: 'include' stringLiteral s= semi
{
DebugLocation(248, 4);
string_literal73=(IToken)Match(input,248,Follow._248_in_includeDirective1329); if (state.failed) return retval;
if (state.backtracking == 0) stream_248.Add(string_literal73);
DebugLocation(248, 14);
PushFollow(Follow._stringLiteral_in_includeDirective1331);
stringLiteral74=stringLiteral();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_stringLiteral.Add(stringLiteral74.Tree);
DebugLocation(248, 29);
PushFollow(Follow._semi_in_includeDirective1335);
s=semi();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_semi.Add(s.Tree);
{
// AST REWRITE
// elements: 248, stringLiteral
// 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();
// 249:9: -> ^( INCLUDE_DIRECTIVE 'include' stringLiteral )
{
DebugLocation(249, 12);
// AS3.g:249:12: ^( INCLUDE_DIRECTIVE 'include' stringLiteral )
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(249, 14);
root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(INCLUDE_DIRECTIVE, "INCLUDE_DIRECTIVE"), root_1);
DebugLocation(249, 32);
adaptor.AddChild(root_1, stream_248.NextNode());
DebugLocation(249, 42);
adaptor.AddChild(root_1, stream_stringLiteral.NextTree());
DebugLocation(249, 56);
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("includeDirective", 20);
LeaveRule("includeDirective", 20);
LeaveRule_includeDirective();
}
DebugLocation(250, 1);
} finally { DebugExitRule(GrammarFileName, "includeDirective"); }
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;
}
private AstParserRuleReturnScope<CommonTree, IToken> methodDefinition()
{
EnterRule_methodDefinition();
EnterRule("methodDefinition", 21);
TraceIn("methodDefinition", 21);
AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>();
retval.Start = (IToken)input.LT(1);
CommonTree root_0 = default(CommonTree);
IToken FUNCTION76 = default(IToken);
AstParserRuleReturnScope<CommonTree, IToken> modifiers75 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> accessorRole77 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> methodName78 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> parameterDeclarationList79 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> typeExpression80 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> maybeBlock81 = default(AstParserRuleReturnScope<CommonTree, IToken>);
CommonTree FUNCTION76_tree = default(CommonTree);
RewriteRuleITokenStream stream_FUNCTION=new RewriteRuleITokenStream(adaptor,"token FUNCTION");
RewriteRuleSubtreeStream stream_modifiers=new RewriteRuleSubtreeStream(adaptor,"rule modifiers");
RewriteRuleSubtreeStream stream_accessorRole=new RewriteRuleSubtreeStream(adaptor,"rule accessorRole");
RewriteRuleSubtreeStream stream_methodName=new RewriteRuleSubtreeStream(adaptor,"rule methodName");
RewriteRuleSubtreeStream stream_parameterDeclarationList=new RewriteRuleSubtreeStream(adaptor,"rule parameterDeclarationList");
RewriteRuleSubtreeStream stream_typeExpression=new RewriteRuleSubtreeStream(adaptor,"rule typeExpression");
RewriteRuleSubtreeStream stream_maybeBlock=new RewriteRuleSubtreeStream(adaptor,"rule maybeBlock");
try { DebugEnterRule(GrammarFileName, "methodDefinition");
DebugLocation(253, 1);
try
{
// AS3.g:254:2: ( modifiers FUNCTION ( accessorRole )? methodName parameterDeclarationList ( typeExpression )? maybeBlock -> ^( METHOD_DEF modifiers FUNCTION ( accessorRole )? methodName parameterDeclarationList ( typeExpression )? maybeBlock ) )
DebugEnterAlt(1);
// AS3.g:255:3: modifiers FUNCTION ( accessorRole )? methodName parameterDeclarationList ( typeExpression )? maybeBlock
{
DebugLocation(255, 3);
PushFollow(Follow._modifiers_in_methodDefinition1369);
modifiers75=modifiers();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_modifiers.Add(modifiers75.Tree);
DebugLocation(256, 3);
FUNCTION76=(IToken)Match(input,FUNCTION,Follow._FUNCTION_in_methodDefinition1373); if (state.failed) return retval;
if (state.backtracking == 0) stream_FUNCTION.Add(FUNCTION76);
DebugLocation(257, 9);
// AS3.g:257:9: ( accessorRole )?
int alt18=2;
try { DebugEnterSubRule(18);
try { DebugEnterDecision(18, false);
int LA18_1 = input.LA(1);
if ((LA18_1==GET))
{
int LA18_2 = input.LA(2);
if ((LA18_2==AS||LA18_2==DYNAMIC||LA18_2==GET||LA18_2==IDENT||LA18_2==IS||LA18_2==NAMESPACE||LA18_2==SET||LA18_2==SUPER||LA18_2==USE||LA18_2==XML))
{
alt18 = 1;
}
}
else if ((LA18_1==SET))
{
int LA18_2 = input.LA(2);
if ((LA18_2==AS||LA18_2==DYNAMIC||LA18_2==GET||LA18_2==IDENT||LA18_2==IS||LA18_2==NAMESPACE||LA18_2==SET||LA18_2==SUPER||LA18_2==USE||LA18_2==XML))
{
alt18 = 1;
}
}
} finally { DebugExitDecision(18); }
switch (alt18)
{
case 1:
DebugEnterAlt(1);
// AS3.g:257:9: accessorRole
{
DebugLocation(257, 9);
PushFollow(Follow._accessorRole_in_methodDefinition1383);
accessorRole77=accessorRole();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_accessorRole.Add(accessorRole77.Tree);
}
break;
}
} finally { DebugExitSubRule(18); }
DebugLocation(258, 3);
PushFollow(Follow._methodName_in_methodDefinition1388);
methodName78=methodName();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_methodName.Add(methodName78.Tree);
DebugLocation(259, 3);
PushFollow(Follow._parameterDeclarationList_in_methodDefinition1392);
parameterDeclarationList79=parameterDeclarationList();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_parameterDeclarationList.Add(parameterDeclarationList79.Tree);
DebugLocation(260, 3);
// AS3.g:260:3: ( typeExpression )?
int alt19=2;
try { DebugEnterSubRule(19);
try { DebugEnterDecision(19, false);
int LA19_1 = input.LA(1);
if ((LA19_1==COLON))
{
alt19 = 1;
}
} finally { DebugExitDecision(19); }
switch (alt19)
{
case 1:
DebugEnterAlt(1);
// AS3.g:260:3: typeExpression
{
DebugLocation(260, 3);
PushFollow(Follow._typeExpression_in_methodDefinition1396);
typeExpression80=typeExpression();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_typeExpression.Add(typeExpression80.Tree);
}
break;
}
} finally { DebugExitSubRule(19); }
DebugLocation(261, 9);
PushFollow(Follow._maybeBlock_in_methodDefinition1407);
maybeBlock81=maybeBlock();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_maybeBlock.Add(maybeBlock81.Tree);
{
// AST REWRITE
// elements: modifiers, FUNCTION, accessorRole, methodName, parameterDeclarationList, typeExpression, maybeBlock
// 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();
// 262:3: -> ^( METHOD_DEF modifiers FUNCTION ( accessorRole )? methodName parameterDeclarationList ( typeExpression )? maybeBlock )
{
DebugLocation(262, 6);
// AS3.g:262:6: ^( METHOD_DEF modifiers FUNCTION ( accessorRole )? methodName parameterDeclarationList ( typeExpression )? maybeBlock )
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(262, 8);
root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(METHOD_DEF, "METHOD_DEF"), root_1);
DebugLocation(262, 19);
adaptor.AddChild(root_1, stream_modifiers.NextTree());
DebugLocation(262, 29);
adaptor.AddChild(root_1, stream_FUNCTION.NextNode());
DebugLocation(262, 38);
// AS3.g:262:38: ( accessorRole )?
if (stream_accessorRole.HasNext)
{
DebugLocation(262, 38);
adaptor.AddChild(root_1, stream_accessorRole.NextTree());
}
stream_accessorRole.Reset();
DebugLocation(263, 17);
adaptor.AddChild(root_1, stream_methodName.NextTree());
DebugLocation(264, 5);
adaptor.AddChild(root_1, stream_parameterDeclarationList.NextTree());
DebugLocation(265, 5);
// AS3.g:265:5: ( typeExpression )?
if (stream_typeExpression.HasNext)
{
DebugLocation(265, 5);
adaptor.AddChild(root_1, stream_typeExpression.NextTree());
}
stream_typeExpression.Reset();
DebugLocation(266, 5);
adaptor.AddChild(root_1, stream_maybeBlock.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("methodDefinition", 21);
LeaveRule("methodDefinition", 21);
LeaveRule_methodDefinition();
}
DebugLocation(268, 1);
} finally { DebugExitRule(GrammarFileName, "methodDefinition"); }
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;
}
private AstParserRuleReturnScope<CommonTree, IToken> namespaceDefinition()
{
EnterRule_namespaceDefinition();
EnterRule("namespaceDefinition", 25);
TraceIn("namespaceDefinition", 25);
AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>();
retval.Start = (IToken)input.LT(1);
CommonTree root_0 = default(CommonTree);
IToken NAMESPACE86 = default(IToken);
AstParserRuleReturnScope<CommonTree, IToken> modifiers85 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> namespaceName87 = default(AstParserRuleReturnScope<CommonTree, IToken>);
CommonTree NAMESPACE86_tree = default(CommonTree);
RewriteRuleITokenStream stream_NAMESPACE=new RewriteRuleITokenStream(adaptor,"token NAMESPACE");
RewriteRuleSubtreeStream stream_modifiers=new RewriteRuleSubtreeStream(adaptor,"rule modifiers");
RewriteRuleSubtreeStream stream_namespaceName=new RewriteRuleSubtreeStream(adaptor,"rule namespaceName");
try { DebugEnterRule(GrammarFileName, "namespaceDefinition");
DebugLocation(286, 1);
try
{
// AS3.g:287:2: ( modifiers NAMESPACE namespaceName -> ^( NAMESPACE_DEF modifiers NAMESPACE namespaceName ) )
DebugEnterAlt(1);
// AS3.g:287:4: modifiers NAMESPACE namespaceName
{
DebugLocation(287, 4);
PushFollow(Follow._modifiers_in_namespaceDefinition1573);
modifiers85=modifiers();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_modifiers.Add(modifiers85.Tree);
DebugLocation(287, 14);
NAMESPACE86=(IToken)Match(input,NAMESPACE,Follow._NAMESPACE_in_namespaceDefinition1575); if (state.failed) return retval;
if (state.backtracking == 0) stream_NAMESPACE.Add(NAMESPACE86);
DebugLocation(287, 24);
PushFollow(Follow._namespaceName_in_namespaceDefinition1577);
namespaceName87=namespaceName();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_namespaceName.Add(namespaceName87.Tree);
{
// AST REWRITE
// elements: modifiers, NAMESPACE, namespaceName
// 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();
// 288:3: -> ^( NAMESPACE_DEF modifiers NAMESPACE namespaceName )
{
DebugLocation(288, 6);
// AS3.g:288:6: ^( NAMESPACE_DEF modifiers NAMESPACE namespaceName )
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(288, 8);
root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(NAMESPACE_DEF, "NAMESPACE_DEF"), root_1);
DebugLocation(288, 22);
adaptor.AddChild(root_1, stream_modifiers.NextTree());
DebugLocation(288, 32);
adaptor.AddChild(root_1, stream_NAMESPACE.NextNode());
DebugLocation(288, 42);
adaptor.AddChild(root_1, stream_namespaceName.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("namespaceDefinition", 25);
LeaveRule("namespaceDefinition", 25);
LeaveRule_namespaceDefinition();
}
DebugLocation(289, 1);
} finally { DebugExitRule(GrammarFileName, "namespaceDefinition"); }
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;
}
private AstParserRuleReturnScope<CommonTree, IToken> variableInitializer()
{
EnterRule_variableInitializer();
EnterRule("variableInitializer", 31);
TraceIn("variableInitializer", 31);
AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>();
retval.Start = (IToken)input.LT(1);
CommonTree root_0 = default(CommonTree);
IToken ASSIGN102 = default(IToken);
AstParserRuleReturnScope<CommonTree, IToken> expression103 = default(AstParserRuleReturnScope<CommonTree, IToken>);
CommonTree ASSIGN102_tree = default(CommonTree);
RewriteRuleITokenStream stream_ASSIGN=new RewriteRuleITokenStream(adaptor,"token ASSIGN");
RewriteRuleSubtreeStream stream_expression=new RewriteRuleSubtreeStream(adaptor,"rule expression");
try { DebugEnterRule(GrammarFileName, "variableInitializer");
DebugLocation(316, 1);
try
{
// AS3.g:317:2: ( ASSIGN expression -> ^( VAR_INITIALIZER ASSIGN expression ) )
DebugEnterAlt(1);
// AS3.g:317:4: ASSIGN expression
{
DebugLocation(317, 4);
ASSIGN102=(IToken)Match(input,ASSIGN,Follow._ASSIGN_in_variableInitializer1737); if (state.failed) return retval;
if (state.backtracking == 0) stream_ASSIGN.Add(ASSIGN102);
DebugLocation(317, 11);
PushFollow(Follow._expression_in_variableInitializer1739);
expression103=expression();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_expression.Add(expression103.Tree);
{
// AST REWRITE
// elements: ASSIGN, 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();
// 318:9: -> ^( VAR_INITIALIZER ASSIGN expression )
{
DebugLocation(318, 12);
// AS3.g:318:12: ^( VAR_INITIALIZER ASSIGN expression )
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(318, 14);
root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(VAR_INITIALIZER, "VAR_INITIALIZER"), root_1);
DebugLocation(318, 30);
adaptor.AddChild(root_1, stream_ASSIGN.NextNode());
DebugLocation(318, 37);
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("variableInitializer", 31);
LeaveRule("variableInitializer", 31);
LeaveRule_variableInitializer();
}
DebugLocation(319, 1);
} finally { DebugExitRule(GrammarFileName, "variableInitializer"); }
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<CommonTree, IToken> parameterDeclarationList()
{
EnterRule_parameterDeclarationList();
EnterRule("parameterDeclarationList", 33);
TraceIn("parameterDeclarationList", 33);
AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>();
retval.Start = (IToken)input.LT(1);
CommonTree root_0 = default(CommonTree);
IToken LPAREN107 = default(IToken);
IToken COMMA109 = default(IToken);
IToken RPAREN111 = default(IToken);
AstParserRuleReturnScope<CommonTree, IToken> parameterDeclaration108 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> parameterDeclaration110 = default(AstParserRuleReturnScope<CommonTree, IToken>);
CommonTree LPAREN107_tree = default(CommonTree);
CommonTree COMMA109_tree = default(CommonTree);
CommonTree RPAREN111_tree = default(CommonTree);
RewriteRuleITokenStream stream_LPAREN=new RewriteRuleITokenStream(adaptor,"token LPAREN");
RewriteRuleITokenStream stream_COMMA=new RewriteRuleITokenStream(adaptor,"token COMMA");
RewriteRuleITokenStream stream_RPAREN=new RewriteRuleITokenStream(adaptor,"token RPAREN");
RewriteRuleSubtreeStream stream_parameterDeclaration=new RewriteRuleSubtreeStream(adaptor,"rule parameterDeclaration");
try { DebugEnterRule(GrammarFileName, "parameterDeclarationList");
DebugLocation(329, 1);
try
{
// AS3.g:330:2: ( LPAREN ( parameterDeclaration ( COMMA parameterDeclaration )* )? RPAREN -> ^( PARAMS LPAREN ( parameterDeclaration )* RPAREN ) )
DebugEnterAlt(1);
// AS3.g:330:4: LPAREN ( parameterDeclaration ( COMMA parameterDeclaration )* )? RPAREN
{
DebugLocation(330, 4);
LPAREN107=(IToken)Match(input,LPAREN,Follow._LPAREN_in_parameterDeclarationList1810); if (state.failed) return retval;
if (state.backtracking == 0) stream_LPAREN.Add(LPAREN107);
DebugLocation(331, 3);
// AS3.g:331:3: ( parameterDeclaration ( COMMA parameterDeclaration )* )?
int alt26=2;
try { DebugEnterSubRule(26);
try { DebugEnterDecision(26, false);
int LA26_1 = input.LA(1);
if ((LA26_1==AS||LA26_1==CONST||LA26_1==DYNAMIC||LA26_1==GET||LA26_1==IDENT||LA26_1==IS||LA26_1==NAMESPACE||LA26_1==REST||LA26_1==SET||LA26_1==SUPER||LA26_1==USE||LA26_1==XML))
{
alt26 = 1;
}
} finally { DebugExitDecision(26); }
switch (alt26)
{
case 1:
DebugEnterAlt(1);
// AS3.g:331:5: parameterDeclaration ( COMMA parameterDeclaration )*
{
DebugLocation(331, 5);
PushFollow(Follow._parameterDeclaration_in_parameterDeclarationList1816);
parameterDeclaration108=parameterDeclaration();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_parameterDeclaration.Add(parameterDeclaration108.Tree);
DebugLocation(332, 4);
// AS3.g:332:4: ( COMMA parameterDeclaration )*
try { DebugEnterSubRule(25);
while (true)
{
int alt25=2;
try { DebugEnterDecision(25, false);
int LA25_1 = input.LA(1);
if ((LA25_1==COMMA))
{
alt25 = 1;
}
} finally { DebugExitDecision(25); }
switch ( alt25 )
{
case 1:
DebugEnterAlt(1);
// AS3.g:332:5: COMMA parameterDeclaration
{
DebugLocation(332, 5);
COMMA109=(IToken)Match(input,COMMA,Follow._COMMA_in_parameterDeclarationList1822); if (state.failed) return retval;
if (state.backtracking == 0) stream_COMMA.Add(COMMA109);
DebugLocation(332, 11);
PushFollow(Follow._parameterDeclaration_in_parameterDeclarationList1824);
parameterDeclaration110=parameterDeclaration();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_parameterDeclaration.Add(parameterDeclaration110.Tree);
}
break;
default:
goto loop25;
}
}
loop25:
;
} finally { DebugExitSubRule(25); }
}
break;
}
} finally { DebugExitSubRule(26); }
DebugLocation(334, 3);
RPAREN111=(IToken)Match(input,RPAREN,Follow._RPAREN_in_parameterDeclarationList1835); if (state.failed) return retval;
if (state.backtracking == 0) stream_RPAREN.Add(RPAREN111);
{
// AST REWRITE
// elements: LPAREN, parameterDeclaration, RPAREN
// 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();
// 335:3: -> ^( PARAMS LPAREN ( parameterDeclaration )* RPAREN )
{
DebugLocation(335, 6);
// AS3.g:335:6: ^( PARAMS LPAREN ( parameterDeclaration )* RPAREN )
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(335, 8);
root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(PARAMS, "PARAMS"), root_1);
DebugLocation(335, 15);
adaptor.AddChild(root_1, stream_LPAREN.NextNode());
DebugLocation(335, 22);
// AS3.g:335:22: ( parameterDeclaration )*
while ( stream_parameterDeclaration.HasNext )
{
DebugLocation(335, 22);
adaptor.AddChild(root_1, stream_parameterDeclaration.NextTree());
}
stream_parameterDeclaration.Reset();
DebugLocation(335, 44);
adaptor.AddChild(root_1, stream_RPAREN.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("parameterDeclarationList", 33);
LeaveRule("parameterDeclarationList", 33);
LeaveRule_parameterDeclarationList();
}
DebugLocation(336, 1);
} finally { DebugExitRule(GrammarFileName, "parameterDeclarationList"); }
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 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);
}