public void CheckRRSubtreeStreamBehaviourWithElements()
{
RewriteRuleSubtreeStream subtreeTest =
new RewriteRuleSubtreeStream(CreateTreeAdaptor(),
"RewriteRuleSubtreeStream test");
IToken token1 = CreateToken(1, "test token without any real context");
ITree tree1 = CreateTree(token1);
// Test Add()
subtreeTest.Add(tree1);
Assert.AreEqual(1, subtreeTest.Size(), "subtreeTest should have the size 1 (1).");
Assert.IsTrue(subtreeTest.HasNext(), "HasNext() should be true here (1).");
// Test NextNode()
Assert.AreEqual(tree1, (ITree)subtreeTest.NextNode(),
"The returned tree should be equal to the given tree (1).");
Assert.AreEqual(1, subtreeTest.Size(), "subtreeTest should have the size 1 (2).");
Assert.IsFalse(subtreeTest.HasNext(), "HasNext() should be false here (1).");
subtreeTest.Reset();
Assert.AreEqual(1, subtreeTest.Size(), "subtreeTest should have the size 1 (3).");
Assert.IsTrue(subtreeTest.HasNext(), "HasNext() should be true here (2).");
// Test NextTree()
CommonTree returnedTree = (CommonTree)subtreeTest.NextTree();
Assert.AreEqual(token1, returnedTree.Token,
"The returned token should be equal to the given token (3).");
Assert.AreEqual(1, subtreeTest.Size(), "subtreeTest should have the size 1 (4).");
Assert.IsFalse(subtreeTest.HasNext(), "HasNext() should be false here (2).");
subtreeTest.Reset();
Assert.AreEqual(1, subtreeTest.Size(), "subtreeTest should have the size 1 (5).");
Assert.IsTrue(subtreeTest.HasNext(), "HasNext() should be true here (3).");
// Test, what happens with two elements
IToken token2 = CreateToken(2, "test token without any real context");
ITree tree2 = CreateTree(token2);
subtreeTest.Add(tree2);
Assert.AreEqual(2, subtreeTest.Size(), "subtreeTest should have the size 2 (1).");
Assert.IsTrue(subtreeTest.HasNext(), "HasNext() should be true here (4).");
returnedTree = (CommonTree)subtreeTest.NextTree();
Assert.AreEqual(token1, returnedTree.Token,
"The returned token should be equal to the given token (4).");
Assert.AreEqual(2, subtreeTest.Size(), "subtreeTest should have the size 2 (2).");
Assert.IsTrue(subtreeTest.HasNext(), "HasNext() should be true here (5).");
returnedTree = (CommonTree)subtreeTest.NextTree();
Assert.AreEqual(token2, returnedTree.Token,
"The returned token should be equal to the given token (5).");
Assert.IsFalse(subtreeTest.HasNext(), "HasNext() should be false here (3).");
// Test exception
subtreeTest.NextTree();
}
public void CheckRRSubtreeStreamBehaviourWhileEmpty1()
{
string description = "RewriteRuleSubtreeStream test";
RewriteRuleSubtreeStream subtreeTest =
new RewriteRuleSubtreeStream(CreateTreeAdaptor(), description);
Assert.IsFalse(subtreeTest.HasNext(), "HasNext() has to give back false here.");
Assert.AreEqual(description.ToString(), subtreeTest.Description,
"Description strings should be equal.");
Assert.AreEqual(0, subtreeTest.Size(), "The number of elements should be zero.");
subtreeTest.Reset();
Assert.IsTrue(true, "Reset() shouldn't make any problems here.");
Assert.AreEqual(0, subtreeTest.Size(),
"The number of elements should be still zero.");
subtreeTest.NextNode();
}
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> 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;
}
private AstParserRuleReturnScope<CommonTree, IToken> variableDefinition()
{
EnterRule_variableDefinition();
EnterRule("variableDefinition", 27);
TraceIn("variableDefinition", 27);
AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>();
retval.Start = (IToken)input.LT(1);
CommonTree root_0 = default(CommonTree);
IToken COMMA94 = default(IToken);
AstParserRuleReturnScope<CommonTree, IToken> decl = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> s = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> modifiers92 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> variableDeclarator93 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> variableDeclarator95 = default(AstParserRuleReturnScope<CommonTree, IToken>);
CommonTree COMMA94_tree = default(CommonTree);
RewriteRuleITokenStream stream_COMMA=new RewriteRuleITokenStream(adaptor,"token COMMA");
RewriteRuleSubtreeStream stream_modifiers=new RewriteRuleSubtreeStream(adaptor,"rule modifiers");
RewriteRuleSubtreeStream stream_varOrConst=new RewriteRuleSubtreeStream(adaptor,"rule varOrConst");
RewriteRuleSubtreeStream stream_variableDeclarator=new RewriteRuleSubtreeStream(adaptor,"rule variableDeclarator");
RewriteRuleSubtreeStream stream_semi=new RewriteRuleSubtreeStream(adaptor,"rule semi");
try { DebugEnterRule(GrammarFileName, "variableDefinition");
DebugLocation(295, 1);
try
{
// AS3.g:296:2: ( modifiers decl= varOrConst variableDeclarator ( COMMA variableDeclarator )* s= semi -> ^( VARIABLE_DEF modifiers $decl ( variableDeclarator )+ ) )
DebugEnterAlt(1);
// AS3.g:296:4: modifiers decl= varOrConst variableDeclarator ( COMMA variableDeclarator )* s= semi
{
DebugLocation(296, 4);
PushFollow(Follow._modifiers_in_variableDefinition1619);
modifiers92=modifiers();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_modifiers.Add(modifiers92.Tree);
DebugLocation(297, 7);
PushFollow(Follow._varOrConst_in_variableDefinition1625);
decl=varOrConst();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_varOrConst.Add(decl.Tree);
DebugLocation(297, 19);
PushFollow(Follow._variableDeclarator_in_variableDefinition1627);
variableDeclarator93=variableDeclarator();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_variableDeclarator.Add(variableDeclarator93.Tree);
DebugLocation(298, 3);
// AS3.g:298:3: ( COMMA variableDeclarator )*
try { DebugEnterSubRule(21);
while (true)
{
int alt21=2;
try { DebugEnterDecision(21, false);
int LA21_1 = input.LA(1);
if ((LA21_1==COMMA))
{
alt21 = 1;
}
} finally { DebugExitDecision(21); }
switch ( alt21 )
{
case 1:
DebugEnterAlt(1);
// AS3.g:298:4: COMMA variableDeclarator
{
DebugLocation(298, 4);
COMMA94=(IToken)Match(input,COMMA,Follow._COMMA_in_variableDefinition1632); if (state.failed) return retval;
if (state.backtracking == 0) stream_COMMA.Add(COMMA94);
DebugLocation(298, 10);
PushFollow(Follow._variableDeclarator_in_variableDefinition1634);
variableDeclarator95=variableDeclarator();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_variableDeclarator.Add(variableDeclarator95.Tree);
}
break;
default:
goto loop21;
}
}
loop21:
;
} finally { DebugExitSubRule(21); }
DebugLocation(299, 4);
PushFollow(Follow._semi_in_variableDefinition1642);
s=semi();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_semi.Add(s.Tree);
{
// AST REWRITE
// elements: modifiers, decl, variableDeclarator
// token labels:
// rule labels: decl, retval
// token list labels:
// rule list labels:
// wildcard labels:
if (state.backtracking == 0) {
retval.Tree = root_0;
RewriteRuleSubtreeStream stream_decl=new RewriteRuleSubtreeStream(adaptor,"rule decl",decl!=null?decl.Tree:null);
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.Tree:null);
root_0 = (CommonTree)adaptor.Nil();
// 300:3: -> ^( VARIABLE_DEF modifiers $decl ( variableDeclarator )+ )
{
DebugLocation(300, 6);
// AS3.g:300:6: ^( VARIABLE_DEF modifiers $decl ( variableDeclarator )+ )
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(300, 8);
root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(VARIABLE_DEF, "VARIABLE_DEF"), root_1);
DebugLocation(300, 21);
adaptor.AddChild(root_1, stream_modifiers.NextTree());
DebugLocation(300, 32);
adaptor.AddChild(root_1, stream_decl.NextTree());
DebugLocation(300, 37);
if (!(stream_variableDeclarator.HasNext))
{
throw new RewriteEarlyExitException();
}
while ( stream_variableDeclarator.HasNext )
{
DebugLocation(300, 37);
adaptor.AddChild(root_1, stream_variableDeclarator.NextTree());
}
stream_variableDeclarator.Reset();
DebugLocation(300, 57);
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("variableDefinition", 27);
LeaveRule("variableDefinition", 27);
LeaveRule_variableDefinition();
}
DebugLocation(301, 1);
} finally { DebugExitRule(GrammarFileName, "variableDefinition"); }
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> 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 <object, IToken> oslc_search_terms()
{
EnterRule_oslc_search_terms();
EnterRule("oslc_search_terms", 1);
TraceIn("oslc_search_terms", 1);
AstParserRuleReturnScope <object, IToken> retval = new AstParserRuleReturnScope <object, IToken>();
retval.Start = (IToken)input.LT(1);
object root_0 = default(object);
IToken char_literal2 = default(IToken);
AstParserRuleReturnScope <object, IToken> string_esc1 = default(AstParserRuleReturnScope <object, IToken>);
AstParserRuleReturnScope <object, IToken> string_esc3 = default(AstParserRuleReturnScope <object, IToken>);
object char_literal2_tree = default(object);
RewriteRuleITokenStream stream_COMMA = new RewriteRuleITokenStream(adaptor, "token COMMA");
RewriteRuleSubtreeStream stream_string_esc = new RewriteRuleSubtreeStream(adaptor, "rule string_esc");
try { DebugEnterRule(GrammarFileName, "oslc_search_terms");
DebugLocation(41, 1);
try
{
// ../Grammars/OslcSearchTerms.g:41:22: ( string_esc ( ',' string_esc )* -> ^( 'string_list' string_esc ( string_esc )* ) )
DebugEnterAlt(1);
// ../Grammars/OslcSearchTerms.g:41:24: string_esc ( ',' string_esc )*
{
DebugLocation(41, 24);
PushFollow(Follow._string_esc_in_oslc_search_terms60);
string_esc1 = string_esc();
PopFollow();
stream_string_esc.Add(string_esc1.Tree);
DebugLocation(41, 35);
// ../Grammars/OslcSearchTerms.g:41:35: ( ',' string_esc )*
try { DebugEnterSubRule(1);
while (true)
{
int alt1 = 2;
try { DebugEnterDecision(1, false);
int LA1_1 = input.LA(1);
if ((LA1_1 == COMMA))
{
alt1 = 1;
}
} finally { DebugExitDecision(1); }
switch (alt1)
{
case 1:
DebugEnterAlt(1);
// ../Grammars/OslcSearchTerms.g:41:37: ',' string_esc
{
DebugLocation(41, 37);
char_literal2 = (IToken)Match(input, COMMA, Follow._COMMA_in_oslc_search_terms64);
stream_COMMA.Add(char_literal2);
DebugLocation(41, 41);
PushFollow(Follow._string_esc_in_oslc_search_terms66);
string_esc3 = string_esc();
PopFollow();
stream_string_esc.Add(string_esc3.Tree);
}
break;
default:
goto loop1;
}
}
loop1:
; } finally { DebugExitSubRule(1); }
{
// AST REWRITE
// elements: string_esc, STRING_LIST, string_esc
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.Tree = root_0;
RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null?retval.Tree:null);
root_0 = (object)adaptor.Nil();
// 41:55: -> ^( 'string_list' string_esc ( string_esc )* )
{
DebugLocation(41, 58);
// ../Grammars/OslcSearchTerms.g:41:58: ^( 'string_list' string_esc ( string_esc )* )
{
object root_1 = (object)adaptor.Nil();
DebugLocation(41, 60);
root_1 = (object)adaptor.BecomeRoot((object)adaptor.Create(STRING_LIST, "STRING_LIST"), root_1);
DebugLocation(41, 74);
adaptor.AddChild(root_1, stream_string_esc.NextTree());
DebugLocation(41, 85);
// ../Grammars/OslcSearchTerms.g:41:85: ( string_esc )*
while (stream_string_esc.HasNext)
{
DebugLocation(41, 86);
adaptor.AddChild(root_1, stream_string_esc.NextTree());
}
stream_string_esc.Reset();
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;
}
}
retval.Stop = (IToken)input.LT(-1);
retval.Tree = (object)adaptor.RulePostProcessing(root_0);
adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
}
catch (RecognitionException re)
{
ReportError(re);
Recover(input, re);
retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);
}
finally
{
TraceOut("oslc_search_terms", 1);
LeaveRule("oslc_search_terms", 1);
LeaveRule_oslc_search_terms();
}
DebugLocation(42, 1); } finally { DebugExitRule(GrammarFileName, "oslc_search_terms"); }
return(retval);
}
private AstParserRuleReturnScope<CommonTree, IToken> switchStatementList()
{
EnterRule_switchStatementList();
EnterRule("switchStatementList", 57);
TraceIn("switchStatementList", 57);
AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>();
retval.Start = (IToken)input.LT(1);
CommonTree root_0 = default(CommonTree);
AstParserRuleReturnScope<CommonTree, IToken> statement184 = default(AstParserRuleReturnScope<CommonTree, IToken>);
RewriteRuleSubtreeStream stream_statement=new RewriteRuleSubtreeStream(adaptor,"rule statement");
try { DebugEnterRule(GrammarFileName, "switchStatementList");
DebugLocation(487, 1);
try
{
// AS3.g:488:2: ( ( statement )* -> ^( SWITCH_STATEMENT_LIST ( statement )* ) )
DebugEnterAlt(1);
// AS3.g:488:4: ( statement )*
{
DebugLocation(488, 4);
// AS3.g:488:4: ( statement )*
try { DebugEnterSubRule(42);
while (true)
{
int alt42=2;
try { DebugEnterDecision(42, false);
int LA42_1 = input.LA(1);
if ((LA42_1==DEFAULT))
{
int LA42_2 = input.LA(2);
if ((LA42_2==XML))
{
alt42 = 1;
}
}
else if ((LA42_1==AS||LA42_1==BNOT||LA42_1==BREAK||LA42_1==CONST||LA42_1==CONTINUE||(LA42_1>=DEC && LA42_1<=DECIMAL_LITERAL)||LA42_1==DO||(LA42_1>=DYNAMIC && LA42_1<=E4X_ATTRI)||(LA42_1>=FALSE && LA42_1<=FOR)||LA42_1==FUNCTION||LA42_1==GET||(LA42_1>=HEX_LITERAL && LA42_1<=IDENT)||LA42_1==IF||LA42_1==INC||(LA42_1>=INTERNAL && LA42_1<=IS)||(LA42_1>=LBRACK && LA42_1<=LCURLY)||LA42_1==LNOT||LA42_1==LPAREN||LA42_1==MINUS||LA42_1==NAMESPACE||LA42_1==NEW||LA42_1==NULL||LA42_1==OCTAL_LITERAL||LA42_1==PLUS||LA42_1==PRIVATE||(LA42_1>=PROTECTED && LA42_1<=PUBLIC)||LA42_1==REGEX_LITERAL||LA42_1==RETURN||(LA42_1>=SEMI && LA42_1<=SET)||(LA42_1>=STRING_LITERAL_DOUBLE && LA42_1<=SWITCH)||LA42_1==TRUE||(LA42_1>=USE && LA42_1<=VAR)||LA42_1==WHILE||LA42_1==WITH||LA42_1==XML||LA42_1==XML_LITERAL||LA42_1==243||(LA42_1>=253 && LA42_1<=257)))
{
alt42 = 1;
}
} finally { DebugExitDecision(42); }
switch ( alt42 )
{
case 1:
DebugEnterAlt(1);
// AS3.g:488:4: statement
{
DebugLocation(488, 4);
PushFollow(Follow._statement_in_switchStatementList2649);
statement184=statement();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_statement.Add(statement184.Tree);
}
break;
default:
goto loop42;
}
}
loop42:
;
} finally { DebugExitSubRule(42); }
{
// AST REWRITE
// elements: 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();
// 488:15: -> ^( SWITCH_STATEMENT_LIST ( statement )* )
{
DebugLocation(488, 18);
// AS3.g:488:18: ^( SWITCH_STATEMENT_LIST ( statement )* )
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(488, 20);
root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(SWITCH_STATEMENT_LIST, "SWITCH_STATEMENT_LIST"), root_1);
DebugLocation(488, 42);
// AS3.g:488:42: ( statement )*
while ( stream_statement.HasNext )
{
DebugLocation(488, 42);
adaptor.AddChild(root_1, stream_statement.NextTree());
}
stream_statement.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("switchStatementList", 57);
LeaveRule("switchStatementList", 57);
LeaveRule_switchStatementList();
}
DebugLocation(489, 1);
} finally { DebugExitRule(GrammarFileName, "switchStatementList"); }
return retval;
}
// $ANTLR start "paramlist"
// abevformula.g:26:0: paramlist : param ( ',' param )* -> ( param )+ ;
private abevformulaParser.paramlist_return paramlist( )
{
abevformulaParser.paramlist_return retval = new abevformulaParser.paramlist_return();
retval.start = input.LT(1);
int paramlist_StartIndex = input.Index;
CommonTree root_0 = null;
IToken char_literal9 = null;
abevformulaParser.param_return param8 = default(abevformulaParser.param_return);
abevformulaParser.param_return param10 = default(abevformulaParser.param_return);
CommonTree char_literal9_tree = null;
RewriteRuleITokenStream stream_8 = new RewriteRuleITokenStream(adaptor, "token 8");
RewriteRuleSubtreeStream stream_param = new RewriteRuleSubtreeStream(adaptor, "rule param");
try
{
if (state.backtracking > 0 && AlreadyParsedRule(input, 4))
{
return(retval);
}
// abevformula.g:26:13: ( param ( ',' param )* -> ( param )+ )
// abevformula.g:26:13: param ( ',' param )*
{
PushFollow(Follow._param_in_paramlist143);
param8 = param();
state._fsp--;
if (state.failed)
{
return(retval);
}
if (state.backtracking == 0)
{
stream_param.Add(param8.Tree);
}
// abevformula.g:26:19: ( ',' param )*
for ( ; ;)
{
int alt1 = 2;
int LA1_0 = input.LA(1);
if ((LA1_0 == 8))
{
alt1 = 1;
}
switch (alt1)
{
case 1:
// abevformula.g:26:20: ',' param
{
char_literal9 = (IToken)Match(input, 8, Follow._8_in_paramlist146); if (state.failed)
{
return(retval);
}
if (state.backtracking == 0)
{
stream_8.Add(char_literal9);
}
PushFollow(Follow._param_in_paramlist148);
param10 = param();
state._fsp--;
if (state.failed)
{
return(retval);
}
if (state.backtracking == 0)
{
stream_param.Add(param10.Tree);
}
}
break;
default:
goto loop1;
}
}
loop1:
;
{
// AST REWRITE
// elements: param
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
if (state.backtracking == 0)
{
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null?retval.tree:null);
root_0 = (CommonTree)adaptor.Nil();
// 26:32: -> ( param )+
{
if (!(stream_param.HasNext))
{
throw new RewriteEarlyExitException();
}
while (stream_param.HasNext)
{
adaptor.AddChild(root_0, stream_param.NextTree());
}
stream_param.Reset();
}
retval.tree = root_0;
}
}
}
retval.stop = input.LT(-1);
if (state.backtracking == 0)
{
retval.tree = (CommonTree)adaptor.RulePostProcessing(root_0);
adaptor.SetTokenBoundaries(retval.tree, retval.start, retval.stop);
}
}
catch (RecognitionException re)
{
ReportError(re);
Recover(input, re);
retval.tree = (CommonTree)adaptor.ErrorNode(input, retval.start, input.LT(-1), re);
}
finally
{
if (state.backtracking > 0)
{
Memoize(input, 4, paramlist_StartIndex);
}
}
return(retval);
}
private AstParserRuleReturnScope <object, IToken> oslc_prefixes()
{
EnterRule_oslc_prefixes();
EnterRule("oslc_prefixes", 1);
TraceIn("oslc_prefixes", 1);
AstParserRuleReturnScope <object, IToken> retval = new AstParserRuleReturnScope <object, IToken>();
retval.Start = (IToken)input.LT(1);
object root_0 = default(object);
IToken char_literal2 = default(IToken);
AstParserRuleReturnScope <object, IToken> prefix_binding1 = default(AstParserRuleReturnScope <object, IToken>);
AstParserRuleReturnScope <object, IToken> prefix_binding3 = default(AstParserRuleReturnScope <object, IToken>);
object char_literal2_tree = default(object);
RewriteRuleITokenStream stream_COMMA = new RewriteRuleITokenStream(adaptor, "token COMMA");
RewriteRuleSubtreeStream stream_prefix_binding = new RewriteRuleSubtreeStream(adaptor, "rule prefix_binding");
try { DebugEnterRule(GrammarFileName, "oslc_prefixes");
DebugLocation(43, 1);
try
{
// ../Grammars/OslcPrefix.g:43:18: ( prefix_binding ( ',' prefix_binding )* -> ^( 'prefix_list' prefix_binding ( prefix_binding )* ) )
DebugEnterAlt(1);
// ../Grammars/OslcPrefix.g:43:20: prefix_binding ( ',' prefix_binding )*
{
DebugLocation(43, 20);
PushFollow(Follow._prefix_binding_in_oslc_prefixes69);
prefix_binding1 = prefix_binding();
PopFollow();
stream_prefix_binding.Add(prefix_binding1.Tree);
DebugLocation(43, 35);
// ../Grammars/OslcPrefix.g:43:35: ( ',' prefix_binding )*
try { DebugEnterSubRule(1);
while (true)
{
int alt1 = 2;
try { DebugEnterDecision(1, false);
int LA1_1 = input.LA(1);
if ((LA1_1 == COMMA))
{
alt1 = 1;
}
} finally { DebugExitDecision(1); }
switch (alt1)
{
case 1:
DebugEnterAlt(1);
// ../Grammars/OslcPrefix.g:43:37: ',' prefix_binding
{
DebugLocation(43, 37);
char_literal2 = (IToken)Match(input, COMMA, Follow._COMMA_in_oslc_prefixes73);
stream_COMMA.Add(char_literal2);
DebugLocation(43, 41);
PushFollow(Follow._prefix_binding_in_oslc_prefixes75);
prefix_binding3 = prefix_binding();
PopFollow();
stream_prefix_binding.Add(prefix_binding3.Tree);
}
break;
default:
goto loop1;
}
}
loop1:
; } finally { DebugExitSubRule(1); }
{
// AST REWRITE
// elements: prefix_binding, PREFIX_LIST, prefix_binding
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.Tree = root_0;
RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null?retval.Tree:null);
root_0 = (object)adaptor.Nil();
// 43:59: -> ^( 'prefix_list' prefix_binding ( prefix_binding )* )
{
DebugLocation(43, 62);
// ../Grammars/OslcPrefix.g:43:62: ^( 'prefix_list' prefix_binding ( prefix_binding )* )
{
object root_1 = (object)adaptor.Nil();
DebugLocation(43, 65);
root_1 = (object)adaptor.BecomeRoot((object)adaptor.Create(PREFIX_LIST, "PREFIX_LIST"), root_1);
DebugLocation(43, 79);
adaptor.AddChild(root_1, stream_prefix_binding.NextTree());
DebugLocation(43, 94);
// ../Grammars/OslcPrefix.g:43:94: ( prefix_binding )*
while (stream_prefix_binding.HasNext)
{
DebugLocation(43, 95);
adaptor.AddChild(root_1, stream_prefix_binding.NextTree());
}
stream_prefix_binding.Reset();
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;
}
}
retval.Stop = (IToken)input.LT(-1);
retval.Tree = (object)adaptor.RulePostProcessing(root_0);
adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
}
catch (RecognitionException re)
{
ReportError(re);
Recover(input, re);
retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);
}
finally
{
TraceOut("oslc_prefixes", 1);
LeaveRule("oslc_prefixes", 1);
LeaveRule_oslc_prefixes();
}
DebugLocation(44, 1); } finally { DebugExitRule(GrammarFileName, "oslc_prefixes"); }
return(retval);
}
private PointcutParser.criteria_return criteria()
{
Enter_criteria();
EnterRule("criteria", 5);
TraceIn("criteria", 5);
PointcutParser.criteria_return retval = new PointcutParser.criteria_return();
retval.Start = (IToken)input.LT(1);
object root_0 = default(object);
IToken Identifier12 = null;
IToken char_literal13 = null;
PointcutParser.atom_return atom11 = default(PointcutParser.atom_return);
PointcutParser.array_return array14 = default(PointcutParser.array_return);
object Identifier12_tree = default(object);
object char_literal13_tree = default(object);
RewriteRuleITokenStream stream_15 = new RewriteRuleITokenStream(adaptor, "token 15");
RewriteRuleITokenStream stream_Identifier = new RewriteRuleITokenStream(adaptor, "token Identifier");
RewriteRuleSubtreeStream stream_array = new RewriteRuleSubtreeStream(adaptor, "rule array");
try { DebugEnterRule(GrammarFileName, "criteria");
DebugLocation(30, 60);
try
{
// D:\\Dev\\Codeplex\\SheepAop\\SheepAspect\\Saql\\Ast\\Pointcut.g:30:10: ( atom | ( Identifier ( ':' array )? ) -> ^( CRITERIA Identifier ( array )? ) )
int alt7 = 2;
try { DebugEnterDecision(7, decisionCanBacktrack[7]);
int LA7_0 = input.LA(1);
if ((LA7_0 == Value || (LA7_0 >= 16 && LA7_0 <= 17)))
{
alt7 = 1;
}
else if ((LA7_0 == Identifier))
{
alt7 = 2;
}
else
{
NoViableAltException nvae = new NoViableAltException("", 7, 0, input);
DebugRecognitionException(nvae);
throw nvae;
} } finally { DebugExitDecision(7); }
switch (alt7)
{
case 1:
DebugEnterAlt(1);
// D:\\Dev\\Codeplex\\SheepAop\\SheepAspect\\Saql\\Ast\\Pointcut.g:30:12: atom
{
root_0 = (object)adaptor.Nil();
DebugLocation(30, 12);
PushFollow(Follow._atom_in_criteria157);
atom11 = atom();
PopFollow();
adaptor.AddChild(root_0, atom11.Tree);
}
break;
case 2:
DebugEnterAlt(2);
// D:\\Dev\\Codeplex\\SheepAop\\SheepAspect\\Saql\\Ast\\Pointcut.g:31:4: ( Identifier ( ':' array )? )
{
DebugLocation(31, 4);
// D:\\Dev\\Codeplex\\SheepAop\\SheepAspect\\Saql\\Ast\\Pointcut.g:31:4: ( Identifier ( ':' array )? )
DebugEnterAlt(1);
// D:\\Dev\\Codeplex\\SheepAop\\SheepAspect\\Saql\\Ast\\Pointcut.g:31:5: Identifier ( ':' array )?
{
DebugLocation(31, 5);
Identifier12 = (IToken)Match(input, Identifier, Follow._Identifier_in_criteria163);
stream_Identifier.Add(Identifier12);
DebugLocation(31, 16);
// D:\\Dev\\Codeplex\\SheepAop\\SheepAspect\\Saql\\Ast\\Pointcut.g:31:16: ( ':' array )?
int alt6 = 2;
try { DebugEnterSubRule(6);
try { DebugEnterDecision(6, decisionCanBacktrack[6]);
int LA6_0 = input.LA(1);
if ((LA6_0 == 15))
{
alt6 = 1;
}
} finally { DebugExitDecision(6); }
switch (alt6)
{
case 1:
DebugEnterAlt(1);
// D:\\Dev\\Codeplex\\SheepAop\\SheepAspect\\Saql\\Ast\\Pointcut.g:31:17: ':' array
{
DebugLocation(31, 17);
char_literal13 = (IToken)Match(input, 15, Follow._15_in_criteria166);
stream_15.Add(char_literal13);
DebugLocation(31, 21);
PushFollow(Follow._array_in_criteria168);
array14 = array();
PopFollow();
stream_array.Add(array14.Tree);
}
break;
}
} finally { DebugExitSubRule(6); }
}
{
// AST REWRITE
// elements: array, Identifier
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.Tree = root_0;
RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null?retval.Tree:null);
root_0 = (object)adaptor.Nil();
// 31:29: -> ^( CRITERIA Identifier ( array )? )
{
DebugLocation(31, 32);
// D:\\Dev\\Codeplex\\SheepAop\\SheepAspect\\Saql\\Ast\\Pointcut.g:31:32: ^( CRITERIA Identifier ( array )? )
{
object root_1 = (object)adaptor.Nil();
DebugLocation(31, 34);
root_1 = (object)adaptor.BecomeRoot((object)adaptor.Create(CRITERIA, "CRITERIA"), root_1);
DebugLocation(31, 43);
adaptor.AddChild(root_1, stream_Identifier.NextNode());
DebugLocation(31, 54);
// D:\\Dev\\Codeplex\\SheepAop\\SheepAspect\\Saql\\Ast\\Pointcut.g:31:54: ( array )?
if (stream_array.HasNext)
{
DebugLocation(31, 54);
adaptor.AddChild(root_1, stream_array.NextTree());
}
stream_array.Reset();
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;
}
}
break;
}
retval.Stop = (IToken)input.LT(-1);
retval.Tree = (object)adaptor.RulePostProcessing(root_0);
adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
}
catch (RecognitionException re)
{
ReportError(re);
Recover(input, re);
retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);
}
finally
{
TraceOut("criteria", 5);
LeaveRule("criteria", 5);
Leave_criteria();
}
DebugLocation(31, 60); } finally { DebugExitRule(GrammarFileName, "criteria"); }
return(retval);
}
private PointcutParser.array_return array()
{
Enter_array();
EnterRule("array", 3);
TraceIn("array", 3);
PointcutParser.array_return retval = new PointcutParser.array_return();
retval.Start = (IToken)input.LT(1);
object root_0 = default(object);
IToken char_literal7 = null;
PointcutParser.negation_return negation6 = default(PointcutParser.negation_return);
PointcutParser.negation_return negation8 = default(PointcutParser.negation_return);
object char_literal7_tree = default(object);
RewriteRuleITokenStream stream_14 = new RewriteRuleITokenStream(adaptor, "token 14");
RewriteRuleSubtreeStream stream_negation = new RewriteRuleSubtreeStream(adaptor, "rule negation");
try { DebugEnterRule(GrammarFileName, "array");
DebugLocation(23, 3);
try
{
// D:\\Dev\\Codeplex\\SheepAop\\SheepAspect\\Saql\\Ast\\Pointcut.g:23:7: ( negation ( ( ',' negation )+ -> ^( ARRAY ( negation )* ) | -> negation ) )
DebugEnterAlt(1);
// D:\\Dev\\Codeplex\\SheepAop\\SheepAspect\\Saql\\Ast\\Pointcut.g:23:9: negation ( ( ',' negation )+ -> ^( ARRAY ( negation )* ) | -> negation )
{
DebugLocation(23, 9);
PushFollow(Follow._negation_in_array100);
negation6 = negation();
PopFollow();
stream_negation.Add(negation6.Tree);
DebugLocation(23, 18);
// D:\\Dev\\Codeplex\\SheepAop\\SheepAspect\\Saql\\Ast\\Pointcut.g:23:18: ( ( ',' negation )+ -> ^( ARRAY ( negation )* ) | -> negation )
int alt4 = 2;
try { DebugEnterSubRule(4);
try { DebugEnterDecision(4, decisionCanBacktrack[4]);
int LA4_0 = input.LA(1);
if ((LA4_0 == 14))
{
alt4 = 1;
}
else if ((LA4_0 == EOF || (LA4_0 >= And && LA4_0 <= Or) || LA4_0 == 18))
{
alt4 = 2;
}
else
{
NoViableAltException nvae = new NoViableAltException("", 4, 0, input);
DebugRecognitionException(nvae);
throw nvae;
} } finally { DebugExitDecision(4); }
switch (alt4)
{
case 1:
DebugEnterAlt(1);
// D:\\Dev\\Codeplex\\SheepAop\\SheepAspect\\Saql\\Ast\\Pointcut.g:24:4: ( ',' negation )+
{
DebugLocation(24, 4);
// D:\\Dev\\Codeplex\\SheepAop\\SheepAspect\\Saql\\Ast\\Pointcut.g:24:4: ( ',' negation )+
int cnt3 = 0;
try { DebugEnterSubRule(3);
while (true)
{
int alt3 = 2;
try { DebugEnterDecision(3, decisionCanBacktrack[3]);
int LA3_0 = input.LA(1);
if ((LA3_0 == 14))
{
alt3 = 1;
}
} finally { DebugExitDecision(3); }
switch (alt3)
{
case 1:
DebugEnterAlt(1);
// D:\\Dev\\Codeplex\\SheepAop\\SheepAspect\\Saql\\Ast\\Pointcut.g:24:5: ',' negation
{
DebugLocation(24, 5);
char_literal7 = (IToken)Match(input, 14, Follow._14_in_array108);
stream_14.Add(char_literal7);
DebugLocation(24, 9);
PushFollow(Follow._negation_in_array110);
negation8 = negation();
PopFollow();
stream_negation.Add(negation8.Tree);
}
break;
default:
if (cnt3 >= 1)
{
goto loop3;
}
EarlyExitException eee3 = new EarlyExitException(3, input);
DebugRecognitionException(eee3);
throw eee3;
}
cnt3++;
}
loop3:
; } finally { DebugExitSubRule(3); }
{
// AST REWRITE
// elements: negation
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.Tree = root_0;
RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null?retval.Tree:null);
root_0 = (object)adaptor.Nil();
// 24:20: -> ^( ARRAY ( negation )* )
{
DebugLocation(24, 23);
// D:\\Dev\\Codeplex\\SheepAop\\SheepAspect\\Saql\\Ast\\Pointcut.g:24:23: ^( ARRAY ( negation )* )
{
object root_1 = (object)adaptor.Nil();
DebugLocation(24, 25);
root_1 = (object)adaptor.BecomeRoot((object)adaptor.Create(ARRAY, "ARRAY"), root_1);
DebugLocation(24, 31);
// D:\\Dev\\Codeplex\\SheepAop\\SheepAspect\\Saql\\Ast\\Pointcut.g:24:31: ( negation )*
while (stream_negation.HasNext)
{
DebugLocation(24, 31);
adaptor.AddChild(root_1, stream_negation.NextTree());
}
stream_negation.Reset();
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;
}
}
break;
case 2:
DebugEnterAlt(2);
// D:\\Dev\\Codeplex\\SheepAop\\SheepAspect\\Saql\\Ast\\Pointcut.g:25:7:
{
{
// AST REWRITE
// elements: negation
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.Tree = root_0;
RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null?retval.Tree:null);
root_0 = (object)adaptor.Nil();
// 25:7: -> negation
{
DebugLocation(25, 10);
adaptor.AddChild(root_0, stream_negation.NextTree());
}
retval.Tree = root_0;
}
}
break;
}
} finally { DebugExitSubRule(4); }
}
retval.Stop = (IToken)input.LT(-1);
retval.Tree = (object)adaptor.RulePostProcessing(root_0);
adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
}
catch (RecognitionException re)
{
ReportError(re);
Recover(input, re);
retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);
}
finally
{
TraceOut("array", 3);
LeaveRule("array", 3);
Leave_array();
}
DebugLocation(26, 3); } finally { DebugExitRule(GrammarFileName, "array"); }
return(retval);
}
private AstParserRuleReturnScope <object, IToken> properties()
{
EnterRule_properties();
EnterRule("properties", 2);
TraceIn("properties", 2);
AstParserRuleReturnScope <object, IToken> retval = new AstParserRuleReturnScope <object, IToken>();
retval.Start = (IToken)input.LT(1);
object root_0 = default(object);
IToken char_literal3 = default(IToken);
AstParserRuleReturnScope <object, IToken> property2 = default(AstParserRuleReturnScope <object, IToken>);
AstParserRuleReturnScope <object, IToken> property4 = default(AstParserRuleReturnScope <object, IToken>);
object char_literal3_tree = default(object);
RewriteRuleITokenStream stream_COMMA = new RewriteRuleITokenStream(adaptor, "token COMMA");
RewriteRuleSubtreeStream stream_property = new RewriteRuleSubtreeStream(adaptor, "rule property");
try { DebugEnterRule(GrammarFileName, "properties");
DebugLocation(47, 1);
try
{
// ../Grammars/OslcSelect.g:47:12: ( property ( ',' property )* -> ^( 'properties' property ( property )* ) )
DebugEnterAlt(1);
// ../Grammars/OslcSelect.g:47:14: property ( ',' property )*
{
DebugLocation(47, 14);
PushFollow(Follow._property_in_properties88);
property2 = property();
PopFollow();
stream_property.Add(property2.Tree);
DebugLocation(47, 24);
// ../Grammars/OslcSelect.g:47:24: ( ',' property )*
try { DebugEnterSubRule(1);
while (true)
{
int alt1 = 2;
try { DebugEnterDecision(1, false);
int LA1_1 = input.LA(1);
if ((LA1_1 == COMMA))
{
alt1 = 1;
}
} finally { DebugExitDecision(1); }
switch (alt1)
{
case 1:
DebugEnterAlt(1);
// ../Grammars/OslcSelect.g:47:26: ',' property
{
DebugLocation(47, 26);
char_literal3 = (IToken)Match(input, COMMA, Follow._COMMA_in_properties93);
stream_COMMA.Add(char_literal3);
DebugLocation(47, 30);
PushFollow(Follow._property_in_properties95);
property4 = property();
PopFollow();
stream_property.Add(property4.Tree);
}
break;
default:
goto loop1;
}
}
loop1:
; } finally { DebugExitSubRule(1); }
{
// AST REWRITE
// elements: PROPERTIES, property, property
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.Tree = root_0;
RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null?retval.Tree:null);
root_0 = (object)adaptor.Nil();
// 47:43: -> ^( 'properties' property ( property )* )
{
DebugLocation(47, 46);
// ../Grammars/OslcSelect.g:47:46: ^( 'properties' property ( property )* )
{
object root_1 = (object)adaptor.Nil();
DebugLocation(47, 49);
root_1 = (object)adaptor.BecomeRoot((object)adaptor.Create(PROPERTIES, "PROPERTIES"), root_1);
DebugLocation(47, 62);
adaptor.AddChild(root_1, stream_property.NextTree());
DebugLocation(47, 71);
// ../Grammars/OslcSelect.g:47:71: ( property )*
while (stream_property.HasNext)
{
DebugLocation(47, 72);
adaptor.AddChild(root_1, stream_property.NextTree());
}
stream_property.Reset();
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;
}
}
retval.Stop = (IToken)input.LT(-1);
retval.Tree = (object)adaptor.RulePostProcessing(root_0);
adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
}
catch (RecognitionException re)
{
ReportError(re);
Recover(input, re);
retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);
}
finally
{
TraceOut("properties", 2);
LeaveRule("properties", 2);
LeaveRule_properties();
}
DebugLocation(48, 1); } finally { DebugExitRule(GrammarFileName, "properties"); }
return(retval);
}
private AstParserRuleReturnScope<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 <object, IToken> sort_terms()
{
EnterRule_sort_terms();
EnterRule("sort_terms", 2);
TraceIn("sort_terms", 2);
AstParserRuleReturnScope <object, IToken> retval = new AstParserRuleReturnScope <object, IToken>();
retval.Start = (IToken)input.LT(1);
object root_0 = default(object);
IToken char_literal3 = default(IToken);
AstParserRuleReturnScope <object, IToken> sort_term2 = default(AstParserRuleReturnScope <object, IToken>);
AstParserRuleReturnScope <object, IToken> sort_term4 = default(AstParserRuleReturnScope <object, IToken>);
object char_literal3_tree = default(object);
RewriteRuleITokenStream stream_COMMA = new RewriteRuleITokenStream(adaptor, "token COMMA");
RewriteRuleSubtreeStream stream_sort_term = new RewriteRuleSubtreeStream(adaptor, "rule sort_term");
try
{
DebugEnterRule(GrammarFileName, "sort_terms");
DebugLocation(46, 1);
try
{
// ../Grammars/OslcOrderBy.g:46:13: ( sort_term ( ',' sort_term )* -> ^( 'terms' sort_term ( sort_term )* ) )
DebugEnterAlt(1);
// ../Grammars/OslcOrderBy.g:46:15: sort_term ( ',' sort_term )*
{
DebugLocation(46, 15);
PushFollow(Follow._sort_term_in_sort_terms82);
sort_term2 = sort_term();
PopFollow();
stream_sort_term.Add(sort_term2.Tree);
DebugLocation(46, 25);
// ../Grammars/OslcOrderBy.g:46:25: ( ',' sort_term )*
try
{
DebugEnterSubRule(1);
while (true)
{
int alt1 = 2;
try
{
DebugEnterDecision(1, false);
int LA1_1 = input.LA(1);
if ((LA1_1 == COMMA))
{
alt1 = 1;
}
}
finally { DebugExitDecision(1); }
switch (alt1)
{
case 1:
DebugEnterAlt(1);
// ../Grammars/OslcOrderBy.g:46:27: ',' sort_term
{
DebugLocation(46, 27);
char_literal3 = (IToken)Match(input, COMMA, Follow._COMMA_in_sort_terms86);
stream_COMMA.Add(char_literal3);
DebugLocation(46, 31);
PushFollow(Follow._sort_term_in_sort_terms88);
sort_term4 = sort_term();
PopFollow();
stream_sort_term.Add(sort_term4.Tree);
}
break;
default:
goto loop1;
}
}
loop1:
;
}
finally { DebugExitSubRule(1); }
{
// AST REWRITE
// elements: sort_term, sort_term, TERMS
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.Tree = root_0;
RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.Tree : null);
root_0 = (object)adaptor.Nil();
// 46:45: -> ^( 'terms' sort_term ( sort_term )* )
{
DebugLocation(46, 48);
// ../Grammars/OslcOrderBy.g:46:48: ^( 'terms' sort_term ( sort_term )* )
{
object root_1 = (object)adaptor.Nil();
DebugLocation(46, 51);
root_1 = (object)adaptor.BecomeRoot((object)adaptor.Create(TERMS, "TERMS"), root_1);
DebugLocation(46, 59);
adaptor.AddChild(root_1, stream_sort_term.NextTree());
DebugLocation(46, 69);
// ../Grammars/OslcOrderBy.g:46:69: ( sort_term )*
while (stream_sort_term.HasNext)
{
DebugLocation(46, 70);
adaptor.AddChild(root_1, stream_sort_term.NextTree());
}
stream_sort_term.Reset();
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;
}
}
retval.Stop = (IToken)input.LT(-1);
retval.Tree = (object)adaptor.RulePostProcessing(root_0);
adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
}
catch (RecognitionException re)
{
ReportError(re);
Recover(input, re);
retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);
}
finally
{
TraceOut("sort_terms", 2);
LeaveRule("sort_terms", 2);
LeaveRule_sort_terms();
}
DebugLocation(47, 1);
}
finally { DebugExitRule(GrammarFileName, "sort_terms"); }
return(retval);
}
private AstParserRuleReturnScope<CommonTree, IToken> 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> identifierStar()
{
EnterRule_identifierStar();
EnterRule("identifierStar", 77);
TraceIn("identifierStar", 77);
AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>();
retval.Start = (IToken)input.LT(1);
CommonTree root_0 = default(CommonTree);
IToken DOT249 = default(IToken);
IToken STAR250 = default(IToken);
AstParserRuleReturnScope<CommonTree, IToken> ident247 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> dotIdent248 = default(AstParserRuleReturnScope<CommonTree, IToken>);
CommonTree DOT249_tree = default(CommonTree);
CommonTree STAR250_tree = default(CommonTree);
RewriteRuleITokenStream stream_DOT=new RewriteRuleITokenStream(adaptor,"token DOT");
RewriteRuleITokenStream stream_STAR=new RewriteRuleITokenStream(adaptor,"token STAR");
RewriteRuleSubtreeStream stream_ident=new RewriteRuleSubtreeStream(adaptor,"rule ident");
RewriteRuleSubtreeStream stream_dotIdent=new RewriteRuleSubtreeStream(adaptor,"rule dotIdent");
try { DebugEnterRule(GrammarFileName, "identifierStar");
DebugLocation(600, 1);
try
{
// AS3.g:601:2: ( ident ( dotIdent )* ( DOT STAR )? -> ^( IDENTIFIER_STAR ident ( dotIdent )* ( DOT )? ( STAR )? ) )
DebugEnterAlt(1);
// AS3.g:601:4: ident ( dotIdent )* ( DOT STAR )?
{
DebugLocation(601, 4);
PushFollow(Follow._ident_in_identifierStar3287);
ident247=ident();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_ident.Add(ident247.Tree);
DebugLocation(602, 3);
// AS3.g:602:3: ( dotIdent )*
try { DebugEnterSubRule(54);
while (true)
{
int alt54=2;
try { DebugEnterDecision(54, false);
int LA54_1 = input.LA(1);
if ((LA54_1==DOT))
{
int LA54_2 = input.LA(2);
if ((LA54_2==AS||LA54_2==DYNAMIC||LA54_2==GET||LA54_2==IDENT||LA54_2==IS||LA54_2==NAMESPACE||LA54_2==SET||LA54_2==SUPER||LA54_2==USE||LA54_2==XML))
{
alt54 = 1;
}
}
} finally { DebugExitDecision(54); }
switch ( alt54 )
{
case 1:
DebugEnterAlt(1);
// AS3.g:602:3: dotIdent
{
DebugLocation(602, 3);
PushFollow(Follow._dotIdent_in_identifierStar3291);
dotIdent248=dotIdent();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_dotIdent.Add(dotIdent248.Tree);
}
break;
default:
goto loop54;
}
}
loop54:
;
} finally { DebugExitSubRule(54); }
DebugLocation(603, 3);
// AS3.g:603:3: ( DOT STAR )?
int alt55=2;
try { DebugEnterSubRule(55);
try { DebugEnterDecision(55, false);
int LA55_1 = input.LA(1);
if ((LA55_1==DOT))
{
alt55 = 1;
}
} finally { DebugExitDecision(55); }
switch (alt55)
{
case 1:
DebugEnterAlt(1);
// AS3.g:603:4: DOT STAR
{
DebugLocation(603, 4);
DOT249=(IToken)Match(input,DOT,Follow._DOT_in_identifierStar3297); if (state.failed) return retval;
if (state.backtracking == 0) stream_DOT.Add(DOT249);
DebugLocation(603, 8);
STAR250=(IToken)Match(input,STAR,Follow._STAR_in_identifierStar3299); if (state.failed) return retval;
if (state.backtracking == 0) stream_STAR.Add(STAR250);
}
break;
}
} finally { DebugExitSubRule(55); }
{
// AST REWRITE
// elements: ident, dotIdent, DOT, 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();
// 604:3: -> ^( IDENTIFIER_STAR ident ( dotIdent )* ( DOT )? ( STAR )? )
{
DebugLocation(604, 6);
// AS3.g:604:6: ^( IDENTIFIER_STAR ident ( dotIdent )* ( DOT )? ( STAR )? )
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(604, 8);
root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(IDENTIFIER_STAR, "IDENTIFIER_STAR"), root_1);
DebugLocation(604, 24);
adaptor.AddChild(root_1, stream_ident.NextTree());
DebugLocation(604, 30);
// AS3.g:604:30: ( dotIdent )*
while ( stream_dotIdent.HasNext )
{
DebugLocation(604, 30);
adaptor.AddChild(root_1, stream_dotIdent.NextTree());
}
stream_dotIdent.Reset();
DebugLocation(604, 40);
// AS3.g:604:40: ( DOT )?
if (stream_DOT.HasNext)
{
DebugLocation(604, 40);
adaptor.AddChild(root_1, stream_DOT.NextNode());
}
stream_DOT.Reset();
DebugLocation(604, 45);
// AS3.g:604:45: ( STAR )?
if (stream_STAR.HasNext)
{
DebugLocation(604, 45);
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("identifierStar", 77);
LeaveRule("identifierStar", 77);
LeaveRule_identifierStar();
}
DebugLocation(605, 1);
} finally { DebugExitRule(GrammarFileName, "identifierStar"); }
return retval;
}
private AstParserRuleReturnScope<CommonTree, IToken> forIter()
{
EnterRule_forIter();
EnterRule("forIter", 66);
TraceIn("forIter", 66);
AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>();
retval.Start = (IToken)input.LT(1);
CommonTree root_0 = default(CommonTree);
AstParserRuleReturnScope<CommonTree, IToken> expressionList214 = default(AstParserRuleReturnScope<CommonTree, IToken>);
RewriteRuleSubtreeStream stream_expressionList=new RewriteRuleSubtreeStream(adaptor,"rule expressionList");
try { DebugEnterRule(GrammarFileName, "forIter");
DebugLocation(543, 1);
try
{
// AS3.g:544:2: ( ( expressionList )? -> ^( FOR_ITERATOR ( expressionList )? ) )
DebugEnterAlt(1);
// AS3.g:544:4: ( expressionList )?
{
DebugLocation(544, 4);
// AS3.g:544:4: ( expressionList )?
int alt48=2;
try { DebugEnterSubRule(48);
try { DebugEnterDecision(48, false);
int LA48_1 = input.LA(1);
if ((LA48_1==AS||LA48_1==BNOT||(LA48_1>=DEC && LA48_1<=DECIMAL_LITERAL)||(LA48_1>=DYNAMIC && LA48_1<=E4X_ATTRI)||(LA48_1>=FALSE && LA48_1<=FLOAT_LITERAL)||LA48_1==FUNCTION||LA48_1==GET||(LA48_1>=HEX_LITERAL && LA48_1<=IDENT)||LA48_1==INC||(LA48_1>=INTERNAL && LA48_1<=IS)||(LA48_1>=LBRACK && LA48_1<=LCURLY)||LA48_1==LNOT||LA48_1==LPAREN||LA48_1==MINUS||LA48_1==NAMESPACE||LA48_1==NEW||LA48_1==NULL||LA48_1==OCTAL_LITERAL||LA48_1==PLUS||LA48_1==PRIVATE||(LA48_1>=PROTECTED && LA48_1<=PUBLIC)||LA48_1==REGEX_LITERAL||LA48_1==SET||(LA48_1>=STRING_LITERAL_DOUBLE && LA48_1<=SUPER)||LA48_1==TRUE||LA48_1==USE||LA48_1==XML||LA48_1==XML_LITERAL||LA48_1==243||(LA48_1>=255 && LA48_1<=257)))
{
alt48 = 1;
}
} finally { DebugExitDecision(48); }
switch (alt48)
{
case 1:
DebugEnterAlt(1);
// AS3.g:544:4: expressionList
{
DebugLocation(544, 4);
PushFollow(Follow._expressionList_in_forIter2939);
expressionList214=expressionList();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_expressionList.Add(expressionList214.Tree);
}
break;
}
} finally { DebugExitSubRule(48); }
{
// AST REWRITE
// elements: expressionList
// 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();
// 545:3: -> ^( FOR_ITERATOR ( expressionList )? )
{
DebugLocation(545, 6);
// AS3.g:545:6: ^( FOR_ITERATOR ( expressionList )? )
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(545, 8);
root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(FOR_ITERATOR, "FOR_ITERATOR"), root_1);
DebugLocation(545, 21);
// AS3.g:545:21: ( expressionList )?
if (stream_expressionList.HasNext)
{
DebugLocation(545, 21);
adaptor.AddChild(root_1, stream_expressionList.NextTree());
}
stream_expressionList.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("forIter", 66);
LeaveRule("forIter", 66);
LeaveRule_forIter();
}
DebugLocation(546, 1);
} finally { DebugExitRule(GrammarFileName, "forIter"); }
return retval;
}
private AstParserRuleReturnScope<CommonTree, IToken> annotation()
{
EnterRule_annotation();
EnterRule("annotation", 80);
TraceIn("annotation", 80);
AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>();
retval.Start = (IToken)input.LT(1);
CommonTree root_0 = default(CommonTree);
IToken LBRACK263 = default(IToken);
IToken RBRACK266 = default(IToken);
AstParserRuleReturnScope<CommonTree, IToken> ident264 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> annotationParamList265 = default(AstParserRuleReturnScope<CommonTree, IToken>);
CommonTree LBRACK263_tree = default(CommonTree);
CommonTree RBRACK266_tree = default(CommonTree);
RewriteRuleITokenStream stream_LBRACK=new RewriteRuleITokenStream(adaptor,"token LBRACK");
RewriteRuleITokenStream stream_RBRACK=new RewriteRuleITokenStream(adaptor,"token RBRACK");
RewriteRuleSubtreeStream stream_ident=new RewriteRuleSubtreeStream(adaptor,"rule ident");
RewriteRuleSubtreeStream stream_annotationParamList=new RewriteRuleSubtreeStream(adaptor,"rule annotationParamList");
try { DebugEnterRule(GrammarFileName, "annotation");
DebugLocation(627, 1);
try
{
// AS3.g:628:2: ( LBRACK ident ( annotationParamList )? RBRACK -> ^( ANNOTATION ident ( annotationParamList )? ) )
DebugEnterAlt(1);
// AS3.g:628:4: LBRACK ident ( annotationParamList )? RBRACK
{
DebugLocation(628, 4);
LBRACK263=(IToken)Match(input,LBRACK,Follow._LBRACK_in_annotation3420); if (state.failed) return retval;
if (state.backtracking == 0) stream_LBRACK.Add(LBRACK263);
DebugLocation(629, 3);
PushFollow(Follow._ident_in_annotation3424);
ident264=ident();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_ident.Add(ident264.Tree);
DebugLocation(630, 3);
// AS3.g:630:3: ( annotationParamList )?
int alt57=2;
try { DebugEnterSubRule(57);
try { DebugEnterDecision(57, false);
int LA57_1 = input.LA(1);
if ((LA57_1==LPAREN))
{
alt57 = 1;
}
} finally { DebugExitDecision(57); }
switch (alt57)
{
case 1:
DebugEnterAlt(1);
// AS3.g:630:3: annotationParamList
{
DebugLocation(630, 3);
PushFollow(Follow._annotationParamList_in_annotation3428);
annotationParamList265=annotationParamList();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_annotationParamList.Add(annotationParamList265.Tree);
}
break;
}
} finally { DebugExitSubRule(57); }
DebugLocation(631, 3);
RBRACK266=(IToken)Match(input,RBRACK,Follow._RBRACK_in_annotation3433); if (state.failed) return retval;
if (state.backtracking == 0) stream_RBRACK.Add(RBRACK266);
{
// AST REWRITE
// elements: ident, annotationParamList
// 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();
// 632:3: -> ^( ANNOTATION ident ( annotationParamList )? )
{
DebugLocation(632, 6);
// AS3.g:632:6: ^( ANNOTATION ident ( annotationParamList )? )
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(632, 8);
root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(ANNOTATION, "ANNOTATION"), root_1);
DebugLocation(632, 19);
adaptor.AddChild(root_1, stream_ident.NextTree());
DebugLocation(632, 25);
// AS3.g:632:25: ( annotationParamList )?
if (stream_annotationParamList.HasNext)
{
DebugLocation(632, 25);
adaptor.AddChild(root_1, stream_annotationParamList.NextTree());
}
stream_annotationParamList.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("annotation", 80);
LeaveRule("annotation", 80);
LeaveRule_annotation();
}
DebugLocation(633, 1);
} finally { DebugExitRule(GrammarFileName, "annotation"); }
return retval;
}
private AstParserRuleReturnScope<CommonTree, IToken> as2InterfaceDefinition()
{
EnterRule_as2InterfaceDefinition();
EnterRule("as2InterfaceDefinition", 13);
TraceIn("as2InterfaceDefinition", 13);
AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>();
retval.Start = (IToken)input.LT(1);
CommonTree root_0 = default(CommonTree);
IToken INTERFACE48 = default(IToken);
AstParserRuleReturnScope<CommonTree, IToken> modifiers47 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> identifier49 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> interfaceExtendsClause50 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> typeBlock51 = default(AstParserRuleReturnScope<CommonTree, IToken>);
CommonTree INTERFACE48_tree = default(CommonTree);
RewriteRuleITokenStream stream_INTERFACE=new RewriteRuleITokenStream(adaptor,"token INTERFACE");
RewriteRuleSubtreeStream stream_modifiers=new RewriteRuleSubtreeStream(adaptor,"rule modifiers");
RewriteRuleSubtreeStream stream_identifier=new RewriteRuleSubtreeStream(adaptor,"rule identifier");
RewriteRuleSubtreeStream stream_interfaceExtendsClause=new RewriteRuleSubtreeStream(adaptor,"rule interfaceExtendsClause");
RewriteRuleSubtreeStream stream_typeBlock=new RewriteRuleSubtreeStream(adaptor,"rule typeBlock");
try { DebugEnterRule(GrammarFileName, "as2InterfaceDefinition");
DebugLocation(202, 1);
try
{
// AS3.g:203:2: ( modifiers INTERFACE identifier ( interfaceExtendsClause )? typeBlock -> ^( INTERFACE_DEF modifiers identifier ( interfaceExtendsClause )? typeBlock ) )
DebugEnterAlt(1);
// AS3.g:203:4: modifiers INTERFACE identifier ( interfaceExtendsClause )? typeBlock
{
DebugLocation(203, 4);
PushFollow(Follow._modifiers_in_as2InterfaceDefinition1026);
modifiers47=modifiers();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_modifiers.Add(modifiers47.Tree);
DebugLocation(204, 3);
INTERFACE48=(IToken)Match(input,INTERFACE,Follow._INTERFACE_in_as2InterfaceDefinition1030); if (state.failed) return retval;
if (state.backtracking == 0) stream_INTERFACE.Add(INTERFACE48);
DebugLocation(204, 13);
PushFollow(Follow._identifier_in_as2InterfaceDefinition1032);
identifier49=identifier();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_identifier.Add(identifier49.Tree);
DebugLocation(205, 3);
// AS3.g:205:3: ( interfaceExtendsClause )?
int alt13=2;
try { DebugEnterSubRule(13);
try { DebugEnterDecision(13, false);
int LA13_1 = input.LA(1);
if ((LA13_1==EXTENDS))
{
alt13 = 1;
}
} finally { DebugExitDecision(13); }
switch (alt13)
{
case 1:
DebugEnterAlt(1);
// AS3.g:205:3: interfaceExtendsClause
{
DebugLocation(205, 3);
PushFollow(Follow._interfaceExtendsClause_in_as2InterfaceDefinition1036);
interfaceExtendsClause50=interfaceExtendsClause();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_interfaceExtendsClause.Add(interfaceExtendsClause50.Tree);
}
break;
}
} finally { DebugExitSubRule(13); }
DebugLocation(206, 3);
PushFollow(Follow._typeBlock_in_as2InterfaceDefinition1041);
typeBlock51=typeBlock();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_typeBlock.Add(typeBlock51.Tree);
{
// AST REWRITE
// elements: modifiers, identifier, 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();
// 207:3: -> ^( INTERFACE_DEF modifiers identifier ( interfaceExtendsClause )? typeBlock )
{
DebugLocation(207, 6);
// AS3.g:207:6: ^( INTERFACE_DEF modifiers identifier ( interfaceExtendsClause )? typeBlock )
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(207, 8);
root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(INTERFACE_DEF, "INTERFACE_DEF"), root_1);
DebugLocation(207, 22);
adaptor.AddChild(root_1, stream_modifiers.NextTree());
DebugLocation(207, 32);
adaptor.AddChild(root_1, stream_identifier.NextTree());
DebugLocation(207, 43);
// AS3.g:207:43: ( interfaceExtendsClause )?
if (stream_interfaceExtendsClause.HasNext)
{
DebugLocation(207, 43);
adaptor.AddChild(root_1, stream_interfaceExtendsClause.NextTree());
}
stream_interfaceExtendsClause.Reset();
DebugLocation(207, 67);
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("as2InterfaceDefinition", 13);
LeaveRule("as2InterfaceDefinition", 13);
LeaveRule_as2InterfaceDefinition();
}
DebugLocation(208, 1);
} finally { DebugExitRule(GrammarFileName, "as2InterfaceDefinition"); }
return retval;
}
private AstParserRuleReturnScope<CommonTree, IToken> annotationParamList()
{
EnterRule_annotationParamList();
EnterRule("annotationParamList", 81);
TraceIn("annotationParamList", 81);
AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>();
retval.Start = (IToken)input.LT(1);
CommonTree root_0 = default(CommonTree);
IToken LPAREN267 = default(IToken);
IToken COMMA269 = default(IToken);
IToken RPAREN271 = default(IToken);
AstParserRuleReturnScope<CommonTree, IToken> annotationParam268 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> annotationParam270 = default(AstParserRuleReturnScope<CommonTree, IToken>);
CommonTree LPAREN267_tree = default(CommonTree);
CommonTree COMMA269_tree = default(CommonTree);
CommonTree RPAREN271_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_annotationParam=new RewriteRuleSubtreeStream(adaptor,"rule annotationParam");
try { DebugEnterRule(GrammarFileName, "annotationParamList");
DebugLocation(635, 1);
try
{
// AS3.g:636:2: ( LPAREN ( annotationParam ( COMMA annotationParam )* )? RPAREN -> ^( ANNOTATION_PARAMS ( annotationParam )* ) )
DebugEnterAlt(1);
// AS3.g:637:3: LPAREN ( annotationParam ( COMMA annotationParam )* )? RPAREN
{
DebugLocation(637, 3);
LPAREN267=(IToken)Match(input,LPAREN,Follow._LPAREN_in_annotationParamList3459); if (state.failed) return retval;
if (state.backtracking == 0) stream_LPAREN.Add(LPAREN267);
DebugLocation(638, 3);
// AS3.g:638:3: ( annotationParam ( COMMA annotationParam )* )?
int alt59=2;
try { DebugEnterSubRule(59);
try { DebugEnterDecision(59, false);
int LA59_1 = input.LA(1);
if ((LA59_1==AS||LA59_1==DECIMAL_LITERAL||LA59_1==DYNAMIC||(LA59_1>=FALSE && LA59_1<=FLOAT_LITERAL)||LA59_1==GET||(LA59_1>=HEX_LITERAL && LA59_1<=IDENT)||LA59_1==IS||LA59_1==NAMESPACE||LA59_1==NULL||LA59_1==OCTAL_LITERAL||LA59_1==REGEX_LITERAL||LA59_1==SET||(LA59_1>=STRING_LITERAL_DOUBLE && LA59_1<=SUPER)||LA59_1==TRUE||LA59_1==USE||LA59_1==XML||LA59_1==XML_LITERAL))
{
alt59 = 1;
}
} finally { DebugExitDecision(59); }
switch (alt59)
{
case 1:
DebugEnterAlt(1);
// AS3.g:638:5: annotationParam ( COMMA annotationParam )*
{
DebugLocation(638, 5);
PushFollow(Follow._annotationParam_in_annotationParamList3465);
annotationParam268=annotationParam();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_annotationParam.Add(annotationParam268.Tree);
DebugLocation(639, 4);
// AS3.g:639:4: ( COMMA annotationParam )*
try { DebugEnterSubRule(58);
while (true)
{
int alt58=2;
try { DebugEnterDecision(58, false);
int LA58_1 = input.LA(1);
if ((LA58_1==COMMA))
{
alt58 = 1;
}
} finally { DebugExitDecision(58); }
switch ( alt58 )
{
case 1:
DebugEnterAlt(1);
// AS3.g:639:5: COMMA annotationParam
{
DebugLocation(639, 5);
COMMA269=(IToken)Match(input,COMMA,Follow._COMMA_in_annotationParamList3471); if (state.failed) return retval;
if (state.backtracking == 0) stream_COMMA.Add(COMMA269);
DebugLocation(639, 11);
PushFollow(Follow._annotationParam_in_annotationParamList3473);
annotationParam270=annotationParam();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_annotationParam.Add(annotationParam270.Tree);
}
break;
default:
goto loop58;
}
}
loop58:
;
} finally { DebugExitSubRule(58); }
}
break;
}
} finally { DebugExitSubRule(59); }
DebugLocation(641, 3);
RPAREN271=(IToken)Match(input,RPAREN,Follow._RPAREN_in_annotationParamList3484); if (state.failed) return retval;
if (state.backtracking == 0) stream_RPAREN.Add(RPAREN271);
{
// AST REWRITE
// elements: annotationParam
// 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();
// 642:3: -> ^( ANNOTATION_PARAMS ( annotationParam )* )
{
DebugLocation(642, 6);
// AS3.g:642:6: ^( ANNOTATION_PARAMS ( annotationParam )* )
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(642, 8);
root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(ANNOTATION_PARAMS, "ANNOTATION_PARAMS"), root_1);
DebugLocation(642, 26);
// AS3.g:642:26: ( annotationParam )*
while ( stream_annotationParam.HasNext )
{
DebugLocation(642, 26);
adaptor.AddChild(root_1, stream_annotationParam.NextTree());
}
stream_annotationParam.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("annotationParamList", 81);
LeaveRule("annotationParamList", 81);
LeaveRule_annotationParamList();
}
DebugLocation(643, 1);
} finally { DebugExitRule(GrammarFileName, "annotationParamList"); }
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> modifiers()
{
EnterRule_modifiers();
EnterRule("modifiers", 83);
TraceIn("modifiers", 83);
AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>();
retval.Start = (IToken)input.LT(1);
CommonTree root_0 = default(CommonTree);
AstParserRuleReturnScope<CommonTree, IToken> modifier277 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> modifier278 = default(AstParserRuleReturnScope<CommonTree, IToken>);
RewriteRuleSubtreeStream stream_modifier=new RewriteRuleSubtreeStream(adaptor,"rule modifier");
try { DebugEnterRule(GrammarFileName, "modifiers");
DebugLocation(664, 1);
try
{
// AS3.g:665:2: ( ( modifier ( modifier )* )? -> ^( MODIFIER_LIST ( modifier )* ) )
DebugEnterAlt(1);
// AS3.g:665:4: ( modifier ( modifier )* )?
{
DebugLocation(665, 4);
// AS3.g:665:4: ( modifier ( modifier )* )?
int alt62=2;
try { DebugEnterSubRule(62);
try { DebugEnterDecision(62, false);
int LA62_1 = input.LA(1);
if ((LA62_1==DYNAMIC||LA62_1==IDENT||LA62_1==INTERNAL||LA62_1==PRIVATE||(LA62_1>=PROTECTED && LA62_1<=PUBLIC)||LA62_1==STATIC||(LA62_1>=244 && LA62_1<=246)||LA62_1==250||LA62_1==252))
{
alt62 = 1;
}
} finally { DebugExitDecision(62); }
switch (alt62)
{
case 1:
DebugEnterAlt(1);
// AS3.g:665:6: modifier ( modifier )*
{
DebugLocation(665, 6);
PushFollow(Follow._modifier_in_modifiers3557);
modifier277=modifier();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_modifier.Add(modifier277.Tree);
DebugLocation(665, 15);
// AS3.g:665:15: ( modifier )*
try { DebugEnterSubRule(61);
while (true)
{
int alt61=2;
try { DebugEnterDecision(61, false);
int LA61_1 = input.LA(1);
if ((LA61_1==DYNAMIC||LA61_1==IDENT||LA61_1==INTERNAL||LA61_1==PRIVATE||(LA61_1>=PROTECTED && LA61_1<=PUBLIC)||LA61_1==STATIC||(LA61_1>=244 && LA61_1<=246)||LA61_1==250||LA61_1==252))
{
alt61 = 1;
}
} finally { DebugExitDecision(61); }
switch ( alt61 )
{
case 1:
DebugEnterAlt(1);
// AS3.g:665:16: modifier
{
DebugLocation(665, 16);
PushFollow(Follow._modifier_in_modifiers3560);
modifier278=modifier();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_modifier.Add(modifier278.Tree);
}
break;
default:
goto loop61;
}
}
loop61:
;
} finally { DebugExitSubRule(61); }
}
break;
}
} finally { DebugExitSubRule(62); }
{
// AST REWRITE
// elements: modifier
// 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();
// 666:2: -> ^( MODIFIER_LIST ( modifier )* )
{
DebugLocation(666, 5);
// AS3.g:666:5: ^( MODIFIER_LIST ( modifier )* )
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(666, 7);
root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(MODIFIER_LIST, "MODIFIER_LIST"), root_1);
DebugLocation(666, 21);
// AS3.g:666:21: ( modifier )*
while ( stream_modifier.HasNext )
{
DebugLocation(666, 21);
adaptor.AddChild(root_1, stream_modifier.NextTree());
}
stream_modifier.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("modifiers", 83);
LeaveRule("modifiers", 83);
LeaveRule_modifiers();
}
DebugLocation(667, 1);
} finally { DebugExitRule(GrammarFileName, "modifiers"); }
return retval;
}
public AstParserRuleReturnScope<CommonTree, IToken> compilationUnit()
{
EnterRule_compilationUnit();
EnterRule("compilationUnit", 1);
TraceIn("compilationUnit", 1);
AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>();
retval.Start = (IToken)input.LT(1);
CommonTree root_0 = default(CommonTree);
AstParserRuleReturnScope<CommonTree, IToken> as2CompilationUnit1 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> as3CompilationUnit2 = default(AstParserRuleReturnScope<CommonTree, IToken>);
RewriteRuleSubtreeStream stream_as2CompilationUnit=new RewriteRuleSubtreeStream(adaptor,"rule as2CompilationUnit");
RewriteRuleSubtreeStream stream_as3CompilationUnit=new RewriteRuleSubtreeStream(adaptor,"rule as3CompilationUnit");
try { DebugEnterRule(GrammarFileName, "compilationUnit");
DebugLocation(114, 1);
try
{
// AS3.g:115:2: ( ( as2CompilationUnit | as3CompilationUnit ) -> ^( COMPILATION_UNIT ( as2CompilationUnit )? ( as3CompilationUnit )? ) )
DebugEnterAlt(1);
// AS3.g:115:4: ( as2CompilationUnit | as3CompilationUnit )
{
DebugLocation(115, 4);
// AS3.g:115:4: ( as2CompilationUnit | as3CompilationUnit )
int alt1=2;
try { DebugEnterSubRule(1);
try { DebugEnterDecision(1, false);
int LA1_1 = input.LA(1);
if ((LA1_1==CLASS||LA1_1==DYNAMIC||LA1_1==IDENT||LA1_1==IMPORT||(LA1_1>=INCLUDE_DIRECTIVE && LA1_1<=INTERFACE)||LA1_1==INTERNAL||LA1_1==PRIVATE||(LA1_1>=PROTECTED && LA1_1<=PUBLIC)||LA1_1==STATIC||(LA1_1>=244 && LA1_1<=246)||LA1_1==250||LA1_1==252))
{
alt1 = 1;
}
else if ((LA1_1==PACKAGE))
{
alt1 = 2;
}
else
{
if (state.backtracking>0) {state.failed=true; return retval;}
NoViableAltException nvae = new NoViableAltException("", 1, 0, input, 1);
DebugRecognitionException(nvae);
throw nvae;
}
} finally { DebugExitDecision(1); }
switch (alt1)
{
case 1:
DebugEnterAlt(1);
// AS3.g:115:6: as2CompilationUnit
{
DebugLocation(115, 6);
PushFollow(Follow._as2CompilationUnit_in_compilationUnit476);
as2CompilationUnit1=as2CompilationUnit();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_as2CompilationUnit.Add(as2CompilationUnit1.Tree);
}
break;
case 2:
DebugEnterAlt(2);
// AS3.g:116:5: as3CompilationUnit
{
DebugLocation(116, 5);
PushFollow(Follow._as3CompilationUnit_in_compilationUnit482);
as3CompilationUnit2=as3CompilationUnit();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_as3CompilationUnit.Add(as3CompilationUnit2.Tree);
}
break;
}
} finally { DebugExitSubRule(1); }
{
// AST REWRITE
// elements: as2CompilationUnit, as3CompilationUnit
// 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();
// 117:5: -> ^( COMPILATION_UNIT ( as2CompilationUnit )? ( as3CompilationUnit )? )
{
DebugLocation(117, 8);
// AS3.g:117:8: ^( COMPILATION_UNIT ( as2CompilationUnit )? ( as3CompilationUnit )? )
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(117, 10);
root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(COMPILATION_UNIT, "COMPILATION_UNIT"), root_1);
DebugLocation(117, 27);
// AS3.g:117:27: ( as2CompilationUnit )?
if (stream_as2CompilationUnit.HasNext)
{
DebugLocation(117, 27);
adaptor.AddChild(root_1, stream_as2CompilationUnit.NextTree());
}
stream_as2CompilationUnit.Reset();
DebugLocation(117, 47);
// AS3.g:117:47: ( as3CompilationUnit )?
if (stream_as3CompilationUnit.HasNext)
{
DebugLocation(117, 47);
adaptor.AddChild(root_1, stream_as3CompilationUnit.NextTree());
}
stream_as3CompilationUnit.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("compilationUnit", 1);
LeaveRule("compilationUnit", 1);
LeaveRule_compilationUnit();
}
DebugLocation(118, 1);
} finally { DebugExitRule(GrammarFileName, "compilationUnit"); }
return retval;
}
private AstParserRuleReturnScope<CommonTree, IToken> arrayLiteral()
{
EnterRule_arrayLiteral();
EnterRule("arrayLiteral", 86);
TraceIn("arrayLiteral", 86);
AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>();
retval.Start = (IToken)input.LT(1);
CommonTree root_0 = default(CommonTree);
IToken LBRACK292 = default(IToken);
IToken RBRACK294 = default(IToken);
AstParserRuleReturnScope<CommonTree, IToken> elementList293 = default(AstParserRuleReturnScope<CommonTree, IToken>);
CommonTree LBRACK292_tree = default(CommonTree);
CommonTree RBRACK294_tree = default(CommonTree);
RewriteRuleITokenStream stream_LBRACK=new RewriteRuleITokenStream(adaptor,"token LBRACK");
RewriteRuleITokenStream stream_RBRACK=new RewriteRuleITokenStream(adaptor,"token RBRACK");
RewriteRuleSubtreeStream stream_elementList=new RewriteRuleSubtreeStream(adaptor,"rule elementList");
try { DebugEnterRule(GrammarFileName, "arrayLiteral");
DebugLocation(688, 1);
try
{
// AS3.g:689:2: ( LBRACK ( elementList )? RBRACK -> ^( ARRAY_LITERAL LBRACK ( elementList )? RBRACK ) )
DebugEnterAlt(1);
// AS3.g:689:4: LBRACK ( elementList )? RBRACK
{
DebugLocation(689, 4);
LBRACK292=(IToken)Match(input,LBRACK,Follow._LBRACK_in_arrayLiteral3681); if (state.failed) return retval;
if (state.backtracking == 0) stream_LBRACK.Add(LBRACK292);
DebugLocation(689, 11);
// AS3.g:689:11: ( elementList )?
int alt65=2;
try { DebugEnterSubRule(65);
try { DebugEnterDecision(65, false);
int LA65_1 = input.LA(1);
if ((LA65_1==AS||LA65_1==BNOT||LA65_1==COMMA||(LA65_1>=DEC && LA65_1<=DECIMAL_LITERAL)||(LA65_1>=DYNAMIC && LA65_1<=E4X_ATTRI)||(LA65_1>=FALSE && LA65_1<=FLOAT_LITERAL)||LA65_1==FUNCTION||LA65_1==GET||(LA65_1>=HEX_LITERAL && LA65_1<=IDENT)||LA65_1==INC||(LA65_1>=INTERNAL && LA65_1<=IS)||(LA65_1>=LBRACK && LA65_1<=LCURLY)||LA65_1==LNOT||LA65_1==LPAREN||LA65_1==MINUS||LA65_1==NAMESPACE||LA65_1==NEW||LA65_1==NULL||LA65_1==OCTAL_LITERAL||LA65_1==PLUS||LA65_1==PRIVATE||(LA65_1>=PROTECTED && LA65_1<=PUBLIC)||LA65_1==REGEX_LITERAL||LA65_1==SET||(LA65_1>=STRING_LITERAL_DOUBLE && LA65_1<=SUPER)||LA65_1==TRUE||LA65_1==USE||LA65_1==XML||LA65_1==XML_LITERAL||LA65_1==243||(LA65_1>=255 && LA65_1<=257)))
{
alt65 = 1;
}
} finally { DebugExitDecision(65); }
switch (alt65)
{
case 1:
DebugEnterAlt(1);
// AS3.g:689:11: elementList
{
DebugLocation(689, 11);
PushFollow(Follow._elementList_in_arrayLiteral3683);
elementList293=elementList();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_elementList.Add(elementList293.Tree);
}
break;
}
} finally { DebugExitSubRule(65); }
DebugLocation(689, 24);
RBRACK294=(IToken)Match(input,RBRACK,Follow._RBRACK_in_arrayLiteral3686); if (state.failed) return retval;
if (state.backtracking == 0) stream_RBRACK.Add(RBRACK294);
{
// AST REWRITE
// elements: LBRACK, elementList, 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();
// 690:3: -> ^( ARRAY_LITERAL LBRACK ( elementList )? RBRACK )
{
DebugLocation(690, 6);
// AS3.g:690:6: ^( ARRAY_LITERAL LBRACK ( elementList )? RBRACK )
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(690, 8);
root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(ARRAY_LITERAL, "ARRAY_LITERAL"), root_1);
DebugLocation(690, 22);
adaptor.AddChild(root_1, stream_LBRACK.NextNode());
DebugLocation(690, 29);
// AS3.g:690:29: ( elementList )?
if (stream_elementList.HasNext)
{
DebugLocation(690, 29);
adaptor.AddChild(root_1, stream_elementList.NextTree());
}
stream_elementList.Reset();
DebugLocation(690, 42);
adaptor.AddChild(root_1, stream_RBRACK.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("arrayLiteral", 86);
LeaveRule("arrayLiteral", 86);
LeaveRule_arrayLiteral();
}
DebugLocation(691, 1);
} finally { DebugExitRule(GrammarFileName, "arrayLiteral"); }
return retval;
}
private AstParserRuleReturnScope<CommonTree, IToken> variableDeclarator()
{
EnterRule_variableDeclarator();
EnterRule("variableDeclarator", 32);
TraceIn("variableDeclarator", 32);
AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>();
retval.Start = (IToken)input.LT(1);
CommonTree root_0 = default(CommonTree);
AstParserRuleReturnScope<CommonTree, IToken> ident104 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> typeExpression105 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> variableInitializer106 = default(AstParserRuleReturnScope<CommonTree, IToken>);
RewriteRuleSubtreeStream stream_ident=new RewriteRuleSubtreeStream(adaptor,"rule ident");
RewriteRuleSubtreeStream stream_typeExpression=new RewriteRuleSubtreeStream(adaptor,"rule typeExpression");
RewriteRuleSubtreeStream stream_variableInitializer=new RewriteRuleSubtreeStream(adaptor,"rule variableInitializer");
try { DebugEnterRule(GrammarFileName, "variableDeclarator");
DebugLocation(321, 1);
try
{
// AS3.g:322:2: ( ident ( typeExpression )? ( variableInitializer )? -> ^( VAR_DECLARATION ident ( typeExpression )? ( variableInitializer )? ) )
DebugEnterAlt(1);
// AS3.g:322:4: ident ( typeExpression )? ( variableInitializer )?
{
DebugLocation(322, 4);
PushFollow(Follow._ident_in_variableDeclarator1768);
ident104=ident();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_ident.Add(ident104.Tree);
DebugLocation(322, 10);
// AS3.g:322:10: ( typeExpression )?
int alt23=2;
try { DebugEnterSubRule(23);
try { DebugEnterDecision(23, false);
int LA23_1 = input.LA(1);
if ((LA23_1==COLON))
{
alt23 = 1;
}
} finally { DebugExitDecision(23); }
switch (alt23)
{
case 1:
DebugEnterAlt(1);
// AS3.g:322:10: typeExpression
{
DebugLocation(322, 10);
PushFollow(Follow._typeExpression_in_variableDeclarator1770);
typeExpression105=typeExpression();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_typeExpression.Add(typeExpression105.Tree);
}
break;
}
} finally { DebugExitSubRule(23); }
DebugLocation(322, 26);
// AS3.g:322:26: ( variableInitializer )?
int alt24=2;
try { DebugEnterSubRule(24);
try { DebugEnterDecision(24, false);
int LA24_1 = input.LA(1);
if ((LA24_1==ASSIGN))
{
alt24 = 1;
}
} finally { DebugExitDecision(24); }
switch (alt24)
{
case 1:
DebugEnterAlt(1);
// AS3.g:322:26: variableInitializer
{
DebugLocation(322, 26);
PushFollow(Follow._variableInitializer_in_variableDeclarator1773);
variableInitializer106=variableInitializer();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_variableInitializer.Add(variableInitializer106.Tree);
}
break;
}
} finally { DebugExitSubRule(24); }
{
// AST REWRITE
// elements: ident, typeExpression, variableInitializer
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
if (state.backtracking == 0) {
retval.Tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.Tree:null);
root_0 = (CommonTree)adaptor.Nil();
// 323:9: -> ^( VAR_DECLARATION ident ( typeExpression )? ( variableInitializer )? )
{
DebugLocation(323, 12);
// AS3.g:323:12: ^( VAR_DECLARATION ident ( typeExpression )? ( variableInitializer )? )
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(323, 14);
root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(VAR_DECLARATION, "VAR_DECLARATION"), root_1);
DebugLocation(323, 30);
adaptor.AddChild(root_1, stream_ident.NextTree());
DebugLocation(323, 36);
// AS3.g:323:36: ( typeExpression )?
if (stream_typeExpression.HasNext)
{
DebugLocation(323, 36);
adaptor.AddChild(root_1, stream_typeExpression.NextTree());
}
stream_typeExpression.Reset();
DebugLocation(323, 52);
// AS3.g:323:52: ( variableInitializer )?
if (stream_variableInitializer.HasNext)
{
DebugLocation(323, 52);
adaptor.AddChild(root_1, stream_variableInitializer.NextTree());
}
stream_variableInitializer.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("variableDeclarator", 32);
LeaveRule("variableDeclarator", 32);
LeaveRule_variableDeclarator();
}
DebugLocation(324, 1);
} finally { DebugExitRule(GrammarFileName, "variableDeclarator"); }
return retval;
}
private AstParserRuleReturnScope<CommonTree, IToken> objectLiteral()
{
EnterRule_objectLiteral();
EnterRule("objectLiteral", 90);
TraceIn("objectLiteral", 90);
AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>();
retval.Start = (IToken)input.LT(1);
CommonTree root_0 = default(CommonTree);
IToken LCURLY301 = default(IToken);
IToken RCURLY303 = default(IToken);
AstParserRuleReturnScope<CommonTree, IToken> fieldList302 = default(AstParserRuleReturnScope<CommonTree, IToken>);
CommonTree LCURLY301_tree = default(CommonTree);
CommonTree RCURLY303_tree = default(CommonTree);
RewriteRuleITokenStream stream_LCURLY=new RewriteRuleITokenStream(adaptor,"token LCURLY");
RewriteRuleITokenStream stream_RCURLY=new RewriteRuleITokenStream(adaptor,"token RCURLY");
RewriteRuleSubtreeStream stream_fieldList=new RewriteRuleSubtreeStream(adaptor,"rule fieldList");
try { DebugEnterRule(GrammarFileName, "objectLiteral");
DebugLocation(707, 1);
try
{
// AS3.g:708:2: ( LCURLY ( fieldList )? RCURLY -> ^( OBJECT_LITERAL ( fieldList )? ) )
DebugEnterAlt(1);
// AS3.g:708:4: LCURLY ( fieldList )? RCURLY
{
DebugLocation(708, 4);
LCURLY301=(IToken)Match(input,LCURLY,Follow._LCURLY_in_objectLiteral3771); if (state.failed) return retval;
if (state.backtracking == 0) stream_LCURLY.Add(LCURLY301);
DebugLocation(708, 11);
// AS3.g:708:11: ( fieldList )?
int alt68=2;
try { DebugEnterSubRule(68);
try { DebugEnterDecision(68, false);
int LA68_1 = input.LA(1);
if ((LA68_1==AS||LA68_1==DECIMAL_LITERAL||LA68_1==DYNAMIC||LA68_1==FLOAT_LITERAL||LA68_1==GET||(LA68_1>=HEX_LITERAL && LA68_1<=IDENT)||LA68_1==IS||LA68_1==NAMESPACE||LA68_1==OCTAL_LITERAL||LA68_1==SET||LA68_1==SUPER||LA68_1==USE||LA68_1==XML))
{
alt68 = 1;
}
} finally { DebugExitDecision(68); }
switch (alt68)
{
case 1:
DebugEnterAlt(1);
// AS3.g:708:11: fieldList
{
DebugLocation(708, 11);
PushFollow(Follow._fieldList_in_objectLiteral3773);
fieldList302=fieldList();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_fieldList.Add(fieldList302.Tree);
}
break;
}
} finally { DebugExitSubRule(68); }
DebugLocation(708, 22);
RCURLY303=(IToken)Match(input,RCURLY,Follow._RCURLY_in_objectLiteral3776); if (state.failed) return retval;
if (state.backtracking == 0) stream_RCURLY.Add(RCURLY303);
{
// AST REWRITE
// elements: fieldList
// 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();
// 709:3: -> ^( OBJECT_LITERAL ( fieldList )? )
{
DebugLocation(709, 6);
// AS3.g:709:6: ^( OBJECT_LITERAL ( fieldList )? )
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(709, 8);
root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(OBJECT_LITERAL, "OBJECT_LITERAL"), root_1);
DebugLocation(709, 23);
// AS3.g:709:23: ( fieldList )?
if (stream_fieldList.HasNext)
{
DebugLocation(709, 23);
adaptor.AddChild(root_1, stream_fieldList.NextTree());
}
stream_fieldList.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("objectLiteral", 90);
LeaveRule("objectLiteral", 90);
LeaveRule_objectLiteral();
}
DebugLocation(710, 1);
} finally { DebugExitRule(GrammarFileName, "objectLiteral"); }
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> expressionList()
{
EnterRule_expressionList();
EnterRule("expressionList", 95);
TraceIn("expressionList", 95);
AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>();
retval.Start = (IToken)input.LT(1);
CommonTree root_0 = default(CommonTree);
IToken COMMA314 = default(IToken);
AstParserRuleReturnScope<CommonTree, IToken> assignmentExpression313 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> assignmentExpression315 = default(AstParserRuleReturnScope<CommonTree, IToken>);
CommonTree COMMA314_tree = default(CommonTree);
RewriteRuleITokenStream stream_COMMA=new RewriteRuleITokenStream(adaptor,"token COMMA");
RewriteRuleSubtreeStream stream_assignmentExpression=new RewriteRuleSubtreeStream(adaptor,"rule assignmentExpression");
try { DebugEnterRule(GrammarFileName, "expressionList");
DebugLocation(733, 1);
try
{
// AS3.g:734:2: ( assignmentExpression ( COMMA assignmentExpression )* -> ^( EXPR_LIST ( assignmentExpression )+ ) )
DebugEnterAlt(1);
// AS3.g:734:4: assignmentExpression ( COMMA assignmentExpression )*
{
DebugLocation(734, 4);
PushFollow(Follow._assignmentExpression_in_expressionList3895);
assignmentExpression313=assignmentExpression();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_assignmentExpression.Add(assignmentExpression313.Tree);
DebugLocation(734, 25);
// AS3.g:734:25: ( COMMA assignmentExpression )*
try { DebugEnterSubRule(72);
while (true)
{
int alt72=2;
try { DebugEnterDecision(72, false);
int LA72_1 = input.LA(1);
if ((LA72_1==COMMA))
{
alt72 = 1;
}
} finally { DebugExitDecision(72); }
switch ( alt72 )
{
case 1:
DebugEnterAlt(1);
// AS3.g:734:26: COMMA assignmentExpression
{
DebugLocation(734, 26);
COMMA314=(IToken)Match(input,COMMA,Follow._COMMA_in_expressionList3898); if (state.failed) return retval;
if (state.backtracking == 0) stream_COMMA.Add(COMMA314);
DebugLocation(734, 32);
PushFollow(Follow._assignmentExpression_in_expressionList3900);
assignmentExpression315=assignmentExpression();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_assignmentExpression.Add(assignmentExpression315.Tree);
}
break;
default:
goto loop72;
}
}
loop72:
;
} finally { DebugExitSubRule(72); }
{
// AST REWRITE
// elements: assignmentExpression
// 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();
// 735:9: -> ^( EXPR_LIST ( assignmentExpression )+ )
{
DebugLocation(735, 12);
// AS3.g:735:12: ^( EXPR_LIST ( assignmentExpression )+ )
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(735, 14);
root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(EXPR_LIST, "EXPR_LIST"), root_1);
DebugLocation(735, 24);
if (!(stream_assignmentExpression.HasNext))
{
throw new RewriteEarlyExitException();
}
while ( stream_assignmentExpression.HasNext )
{
DebugLocation(735, 24);
adaptor.AddChild(root_1, stream_assignmentExpression.NextTree());
}
stream_assignmentExpression.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("expressionList", 95);
LeaveRule("expressionList", 95);
LeaveRule_expressionList();
}
DebugLocation(736, 1);
} finally { DebugExitRule(GrammarFileName, "expressionList"); }
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> classDefinition()
{
EnterRule_classDefinition();
EnterRule("classDefinition", 10);
TraceIn("classDefinition", 10);
AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>();
retval.Start = (IToken)input.LT(1);
CommonTree root_0 = default(CommonTree);
IToken CLASS31 = default(IToken);
AstParserRuleReturnScope<CommonTree, IToken> modifiers30 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> ident32 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> classExtendsClause33 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> implementsClause34 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> typeBlock35 = default(AstParserRuleReturnScope<CommonTree, IToken>);
CommonTree CLASS31_tree = default(CommonTree);
RewriteRuleITokenStream stream_CLASS=new RewriteRuleITokenStream(adaptor,"token CLASS");
RewriteRuleSubtreeStream stream_modifiers=new RewriteRuleSubtreeStream(adaptor,"rule modifiers");
RewriteRuleSubtreeStream stream_ident=new RewriteRuleSubtreeStream(adaptor,"rule ident");
RewriteRuleSubtreeStream stream_classExtendsClause=new RewriteRuleSubtreeStream(adaptor,"rule classExtendsClause");
RewriteRuleSubtreeStream stream_implementsClause=new RewriteRuleSubtreeStream(adaptor,"rule implementsClause");
RewriteRuleSubtreeStream stream_typeBlock=new RewriteRuleSubtreeStream(adaptor,"rule typeBlock");
try { DebugEnterRule(GrammarFileName, "classDefinition");
DebugLocation(175, 1);
try
{
// AS3.g:176:2: ( modifiers CLASS ident ( classExtendsClause )? ( implementsClause )? typeBlock -> ^( CLASS_DEF modifiers CLASS ^( CLASS_NAME ident ) ( classExtendsClause )? ( implementsClause )? typeBlock ) )
DebugEnterAlt(1);
// AS3.g:176:4: modifiers CLASS ident ( classExtendsClause )? ( implementsClause )? typeBlock
{
DebugLocation(176, 4);
PushFollow(Follow._modifiers_in_classDefinition864);
modifiers30=modifiers();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_modifiers.Add(modifiers30.Tree);
DebugLocation(177, 3);
CLASS31=(IToken)Match(input,CLASS,Follow._CLASS_in_classDefinition868); if (state.failed) return retval;
if (state.backtracking == 0) stream_CLASS.Add(CLASS31);
DebugLocation(178, 9);
PushFollow(Follow._ident_in_classDefinition879);
ident32=ident();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_ident.Add(ident32.Tree);
DebugLocation(179, 3);
// AS3.g:179:3: ( classExtendsClause )?
int alt8=2;
try { DebugEnterSubRule(8);
try { DebugEnterDecision(8, false);
int LA8_1 = input.LA(1);
if ((LA8_1==EXTENDS))
{
alt8 = 1;
}
} finally { DebugExitDecision(8); }
switch (alt8)
{
case 1:
DebugEnterAlt(1);
// AS3.g:179:3: classExtendsClause
{
DebugLocation(179, 3);
PushFollow(Follow._classExtendsClause_in_classDefinition883);
classExtendsClause33=classExtendsClause();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_classExtendsClause.Add(classExtendsClause33.Tree);
}
break;
}
} finally { DebugExitSubRule(8); }
DebugLocation(180, 3);
// AS3.g:180:3: ( implementsClause )?
int alt9=2;
try { DebugEnterSubRule(9);
try { DebugEnterDecision(9, false);
int LA9_1 = input.LA(1);
if ((LA9_1==IMPLEMENTS))
{
alt9 = 1;
}
} finally { DebugExitDecision(9); }
switch (alt9)
{
case 1:
DebugEnterAlt(1);
// AS3.g:180:3: implementsClause
{
DebugLocation(180, 3);
PushFollow(Follow._implementsClause_in_classDefinition888);
implementsClause34=implementsClause();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_implementsClause.Add(implementsClause34.Tree);
}
break;
}
} finally { DebugExitSubRule(9); }
DebugLocation(181, 3);
PushFollow(Follow._typeBlock_in_classDefinition893);
typeBlock35=typeBlock();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_typeBlock.Add(typeBlock35.Tree);
{
// AST REWRITE
// elements: modifiers, CLASS, ident, classExtendsClause, implementsClause, 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();
// 182:3: -> ^( CLASS_DEF modifiers CLASS ^( CLASS_NAME ident ) ( classExtendsClause )? ( implementsClause )? typeBlock )
{
DebugLocation(182, 6);
// AS3.g:182:6: ^( CLASS_DEF modifiers CLASS ^( CLASS_NAME ident ) ( classExtendsClause )? ( implementsClause )? typeBlock )
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(182, 8);
root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(CLASS_DEF, "CLASS_DEF"), root_1);
DebugLocation(182, 18);
adaptor.AddChild(root_1, stream_modifiers.NextTree());
DebugLocation(182, 28);
adaptor.AddChild(root_1, stream_CLASS.NextNode());
DebugLocation(182, 34);
// AS3.g:182:34: ^( CLASS_NAME ident )
{
CommonTree root_2 = (CommonTree)adaptor.Nil();
DebugLocation(182, 36);
root_2 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(CLASS_NAME, "CLASS_NAME"), root_2);
DebugLocation(182, 47);
adaptor.AddChild(root_2, stream_ident.NextTree());
adaptor.AddChild(root_1, root_2);
}
DebugLocation(182, 54);
// AS3.g:182:54: ( classExtendsClause )?
if (stream_classExtendsClause.HasNext)
{
DebugLocation(182, 54);
adaptor.AddChild(root_1, stream_classExtendsClause.NextTree());
}
stream_classExtendsClause.Reset();
DebugLocation(182, 74);
// AS3.g:182:74: ( implementsClause )?
if (stream_implementsClause.HasNext)
{
DebugLocation(182, 74);
adaptor.AddChild(root_1, stream_implementsClause.NextTree());
}
stream_implementsClause.Reset();
DebugLocation(182, 92);
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("classDefinition", 10);
LeaveRule("classDefinition", 10);
LeaveRule_classDefinition();
}
DebugLocation(183, 1);
} finally { DebugExitRule(GrammarFileName, "classDefinition"); }
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> as2ClassDefinition()
{
EnterRule_as2ClassDefinition();
EnterRule("as2ClassDefinition", 11);
TraceIn("as2ClassDefinition", 11);
AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>();
retval.Start = (IToken)input.LT(1);
CommonTree root_0 = default(CommonTree);
IToken CLASS37 = default(IToken);
AstParserRuleReturnScope<CommonTree, IToken> modifiers36 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> identifier38 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> classExtendsClause39 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> implementsClause40 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> typeBlock41 = default(AstParserRuleReturnScope<CommonTree, IToken>);
CommonTree CLASS37_tree = default(CommonTree);
RewriteRuleITokenStream stream_CLASS=new RewriteRuleITokenStream(adaptor,"token CLASS");
RewriteRuleSubtreeStream stream_modifiers=new RewriteRuleSubtreeStream(adaptor,"rule modifiers");
RewriteRuleSubtreeStream stream_identifier=new RewriteRuleSubtreeStream(adaptor,"rule identifier");
RewriteRuleSubtreeStream stream_classExtendsClause=new RewriteRuleSubtreeStream(adaptor,"rule classExtendsClause");
RewriteRuleSubtreeStream stream_implementsClause=new RewriteRuleSubtreeStream(adaptor,"rule implementsClause");
RewriteRuleSubtreeStream stream_typeBlock=new RewriteRuleSubtreeStream(adaptor,"rule typeBlock");
try { DebugEnterRule(GrammarFileName, "as2ClassDefinition");
DebugLocation(185, 1);
try
{
// AS3.g:186:2: ( modifiers CLASS identifier ( classExtendsClause )? ( implementsClause )? typeBlock -> ^( CLASS_DEF modifiers identifier ( classExtendsClause )? ( implementsClause )? typeBlock ) )
DebugEnterAlt(1);
// AS3.g:186:4: modifiers CLASS identifier ( classExtendsClause )? ( implementsClause )? typeBlock
{
DebugLocation(186, 4);
PushFollow(Follow._modifiers_in_as2ClassDefinition930);
modifiers36=modifiers();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_modifiers.Add(modifiers36.Tree);
DebugLocation(187, 3);
CLASS37=(IToken)Match(input,CLASS,Follow._CLASS_in_as2ClassDefinition934); if (state.failed) return retval;
if (state.backtracking == 0) stream_CLASS.Add(CLASS37);
DebugLocation(187, 9);
PushFollow(Follow._identifier_in_as2ClassDefinition936);
identifier38=identifier();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_identifier.Add(identifier38.Tree);
DebugLocation(188, 3);
// AS3.g:188:3: ( classExtendsClause )?
int alt10=2;
try { DebugEnterSubRule(10);
try { DebugEnterDecision(10, false);
int LA10_1 = input.LA(1);
if ((LA10_1==EXTENDS))
{
alt10 = 1;
}
} finally { DebugExitDecision(10); }
switch (alt10)
{
case 1:
DebugEnterAlt(1);
// AS3.g:188:3: classExtendsClause
{
DebugLocation(188, 3);
PushFollow(Follow._classExtendsClause_in_as2ClassDefinition940);
classExtendsClause39=classExtendsClause();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_classExtendsClause.Add(classExtendsClause39.Tree);
}
break;
}
} finally { DebugExitSubRule(10); }
DebugLocation(189, 3);
// AS3.g:189:3: ( implementsClause )?
int alt11=2;
try { DebugEnterSubRule(11);
try { DebugEnterDecision(11, false);
int LA11_1 = input.LA(1);
if ((LA11_1==IMPLEMENTS))
{
alt11 = 1;
}
} finally { DebugExitDecision(11); }
switch (alt11)
{
case 1:
DebugEnterAlt(1);
// AS3.g:189:3: implementsClause
{
DebugLocation(189, 3);
PushFollow(Follow._implementsClause_in_as2ClassDefinition945);
implementsClause40=implementsClause();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_implementsClause.Add(implementsClause40.Tree);
}
break;
}
} finally { DebugExitSubRule(11); }
DebugLocation(190, 3);
PushFollow(Follow._typeBlock_in_as2ClassDefinition950);
typeBlock41=typeBlock();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_typeBlock.Add(typeBlock41.Tree);
{
// AST REWRITE
// elements: modifiers, identifier, classExtendsClause, implementsClause, 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();
// 191:3: -> ^( CLASS_DEF modifiers identifier ( classExtendsClause )? ( implementsClause )? typeBlock )
{
DebugLocation(191, 6);
// AS3.g:191:6: ^( CLASS_DEF modifiers identifier ( classExtendsClause )? ( implementsClause )? typeBlock )
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(191, 8);
root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(CLASS_DEF, "CLASS_DEF"), root_1);
DebugLocation(191, 18);
adaptor.AddChild(root_1, stream_modifiers.NextTree());
DebugLocation(191, 28);
adaptor.AddChild(root_1, stream_identifier.NextTree());
DebugLocation(191, 39);
// AS3.g:191:39: ( classExtendsClause )?
if (stream_classExtendsClause.HasNext)
{
DebugLocation(191, 39);
adaptor.AddChild(root_1, stream_classExtendsClause.NextTree());
}
stream_classExtendsClause.Reset();
DebugLocation(191, 59);
// AS3.g:191:59: ( implementsClause )?
if (stream_implementsClause.HasNext)
{
DebugLocation(191, 59);
adaptor.AddChild(root_1, stream_implementsClause.NextTree());
}
stream_implementsClause.Reset();
DebugLocation(191, 77);
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("as2ClassDefinition", 11);
LeaveRule("as2ClassDefinition", 11);
LeaveRule_as2ClassDefinition();
}
DebugLocation(192, 1);
} finally { DebugExitRule(GrammarFileName, "as2ClassDefinition"); }
return retval;
}
private AstParserRuleReturnScope<CommonTree, IToken> switchBlock()
{
EnterRule_switchBlock();
EnterRule("switchBlock", 54);
TraceIn("switchBlock", 54);
AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>();
retval.Start = (IToken)input.LT(1);
CommonTree root_0 = default(CommonTree);
IToken LCURLY175 = default(IToken);
IToken RCURLY178 = default(IToken);
AstParserRuleReturnScope<CommonTree, IToken> caseStatement176 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> defaultStatement177 = default(AstParserRuleReturnScope<CommonTree, IToken>);
CommonTree LCURLY175_tree = default(CommonTree);
CommonTree RCURLY178_tree = default(CommonTree);
RewriteRuleITokenStream stream_LCURLY=new RewriteRuleITokenStream(adaptor,"token LCURLY");
RewriteRuleITokenStream stream_RCURLY=new RewriteRuleITokenStream(adaptor,"token RCURLY");
RewriteRuleSubtreeStream stream_caseStatement=new RewriteRuleSubtreeStream(adaptor,"rule caseStatement");
RewriteRuleSubtreeStream stream_defaultStatement=new RewriteRuleSubtreeStream(adaptor,"rule defaultStatement");
try { DebugEnterRule(GrammarFileName, "switchBlock");
DebugLocation(471, 1);
try
{
// AS3.g:472:2: ( LCURLY ( caseStatement )* ( defaultStatement )? RCURLY -> ^( BLOCK ( caseStatement )* ( defaultStatement )? ) )
DebugEnterAlt(1);
// AS3.g:472:4: LCURLY ( caseStatement )* ( defaultStatement )? RCURLY
{
DebugLocation(472, 4);
LCURLY175=(IToken)Match(input,LCURLY,Follow._LCURLY_in_switchBlock2565); if (state.failed) return retval;
if (state.backtracking == 0) stream_LCURLY.Add(LCURLY175);
DebugLocation(473, 3);
// AS3.g:473:3: ( caseStatement )*
try { DebugEnterSubRule(40);
while (true)
{
int alt40=2;
try { DebugEnterDecision(40, false);
int LA40_1 = input.LA(1);
if ((LA40_1==CASE))
{
alt40 = 1;
}
} finally { DebugExitDecision(40); }
switch ( alt40 )
{
case 1:
DebugEnterAlt(1);
// AS3.g:473:4: caseStatement
{
DebugLocation(473, 4);
PushFollow(Follow._caseStatement_in_switchBlock2570);
caseStatement176=caseStatement();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_caseStatement.Add(caseStatement176.Tree);
}
break;
default:
goto loop40;
}
}
loop40:
;
} finally { DebugExitSubRule(40); }
DebugLocation(474, 3);
// AS3.g:474:3: ( defaultStatement )?
int alt41=2;
try { DebugEnterSubRule(41);
try { DebugEnterDecision(41, false);
int LA41_1 = input.LA(1);
if ((LA41_1==DEFAULT))
{
alt41 = 1;
}
} finally { DebugExitDecision(41); }
switch (alt41)
{
case 1:
DebugEnterAlt(1);
// AS3.g:474:4: defaultStatement
{
DebugLocation(474, 4);
PushFollow(Follow._defaultStatement_in_switchBlock2577);
defaultStatement177=defaultStatement();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_defaultStatement.Add(defaultStatement177.Tree);
}
break;
}
} finally { DebugExitSubRule(41); }
DebugLocation(475, 3);
RCURLY178=(IToken)Match(input,RCURLY,Follow._RCURLY_in_switchBlock2583); if (state.failed) return retval;
if (state.backtracking == 0) stream_RCURLY.Add(RCURLY178);
{
// AST REWRITE
// elements: caseStatement, defaultStatement
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
if (state.backtracking == 0) {
retval.Tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.Tree:null);
root_0 = (CommonTree)adaptor.Nil();
// 476:3: -> ^( BLOCK ( caseStatement )* ( defaultStatement )? )
{
DebugLocation(476, 6);
// AS3.g:476:6: ^( BLOCK ( caseStatement )* ( defaultStatement )? )
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(476, 8);
root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(BLOCK, "BLOCK"), root_1);
DebugLocation(476, 14);
// AS3.g:476:14: ( caseStatement )*
while ( stream_caseStatement.HasNext )
{
DebugLocation(476, 14);
adaptor.AddChild(root_1, stream_caseStatement.NextTree());
}
stream_caseStatement.Reset();
DebugLocation(476, 29);
// AS3.g:476:29: ( defaultStatement )?
if (stream_defaultStatement.HasNext)
{
DebugLocation(476, 29);
adaptor.AddChild(root_1, stream_defaultStatement.NextTree());
}
stream_defaultStatement.Reset();
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;
}
}
}
retval.Stop = (IToken)input.LT(-1);
if (state.backtracking == 0) {
retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
}
}
catch (RecognitionException re)
{
ReportError(re);
Recover(input,re);
retval.Tree = (CommonTree)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);
}
finally
{
TraceOut("switchBlock", 54);
LeaveRule("switchBlock", 54);
LeaveRule_switchBlock();
}
DebugLocation(477, 1);
} finally { DebugExitRule(GrammarFileName, "switchBlock"); }
return retval;
}
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> 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> functionDefinition()
{
EnterRule_functionDefinition();
EnterRule("functionDefinition", 137);
TraceIn("functionDefinition", 137);
AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>();
retval.Start = (IToken)input.LT(1);
CommonTree root_0 = default(CommonTree);
IToken FUNCTION445 = default(IToken);
AstParserRuleReturnScope<CommonTree, IToken> parameterDeclarationList446 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> typeExpression447 = default(AstParserRuleReturnScope<CommonTree, IToken>);
AstParserRuleReturnScope<CommonTree, IToken> block448 = default(AstParserRuleReturnScope<CommonTree, IToken>);
CommonTree FUNCTION445_tree = default(CommonTree);
RewriteRuleITokenStream stream_FUNCTION=new RewriteRuleITokenStream(adaptor,"token FUNCTION");
RewriteRuleSubtreeStream stream_parameterDeclarationList=new RewriteRuleSubtreeStream(adaptor,"rule parameterDeclarationList");
RewriteRuleSubtreeStream stream_typeExpression=new RewriteRuleSubtreeStream(adaptor,"rule typeExpression");
RewriteRuleSubtreeStream stream_block=new RewriteRuleSubtreeStream(adaptor,"rule block");
try { DebugEnterRule(GrammarFileName, "functionDefinition");
DebugLocation(1031, 1);
try
{
// AS3.g:1032:2: ( FUNCTION parameterDeclarationList ( typeExpression )? block -> ^( FUNC_DEF parameterDeclarationList ( typeExpression )? block ) )
DebugEnterAlt(1);
// AS3.g:1032:4: FUNCTION parameterDeclarationList ( typeExpression )? block
{
DebugLocation(1032, 4);
FUNCTION445=(IToken)Match(input,FUNCTION,Follow._FUNCTION_in_functionDefinition5472); if (state.failed) return retval;
if (state.backtracking == 0) stream_FUNCTION.Add(FUNCTION445);
DebugLocation(1032, 13);
PushFollow(Follow._parameterDeclarationList_in_functionDefinition5474);
parameterDeclarationList446=parameterDeclarationList();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_parameterDeclarationList.Add(parameterDeclarationList446.Tree);
DebugLocation(1032, 38);
// AS3.g:1032:38: ( typeExpression )?
int alt96=2;
try { DebugEnterSubRule(96);
try { DebugEnterDecision(96, false);
int LA96_1 = input.LA(1);
if ((LA96_1==COLON))
{
alt96 = 1;
}
} finally { DebugExitDecision(96); }
switch (alt96)
{
case 1:
DebugEnterAlt(1);
// AS3.g:1032:38: typeExpression
{
DebugLocation(1032, 38);
PushFollow(Follow._typeExpression_in_functionDefinition5476);
typeExpression447=typeExpression();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_typeExpression.Add(typeExpression447.Tree);
}
break;
}
} finally { DebugExitSubRule(96); }
DebugLocation(1032, 54);
PushFollow(Follow._block_in_functionDefinition5479);
block448=block();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_block.Add(block448.Tree);
{
// AST REWRITE
// elements: parameterDeclarationList, typeExpression, block
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
if (state.backtracking == 0) {
retval.Tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.Tree:null);
root_0 = (CommonTree)adaptor.Nil();
// 1033:3: -> ^( FUNC_DEF parameterDeclarationList ( typeExpression )? block )
{
DebugLocation(1033, 6);
// AS3.g:1033:6: ^( FUNC_DEF parameterDeclarationList ( typeExpression )? block )
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(1033, 8);
root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(FUNC_DEF, "FUNC_DEF"), root_1);
DebugLocation(1033, 17);
adaptor.AddChild(root_1, stream_parameterDeclarationList.NextTree());
DebugLocation(1033, 42);
// AS3.g:1033:42: ( typeExpression )?
if (stream_typeExpression.HasNext)
{
DebugLocation(1033, 42);
adaptor.AddChild(root_1, stream_typeExpression.NextTree());
}
stream_typeExpression.Reset();
DebugLocation(1033, 58);
adaptor.AddChild(root_1, stream_block.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("functionDefinition", 137);
LeaveRule("functionDefinition", 137);
LeaveRule_functionDefinition();
}
DebugLocation(1034, 1);
} finally { DebugExitRule(GrammarFileName, "functionDefinition"); }
return retval;
}
private AstParserRuleReturnScope<CommonTree, IToken> typeExpression()
{
EnterRule_typeExpression();
EnterRule("typeExpression", 71);
TraceIn("typeExpression", 71);
AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>();
retval.Start = (IToken)input.LT(1);
CommonTree root_0 = default(CommonTree);
IToken COLON232 = default(IToken);
IToken string_literal234 = default(IToken);
IToken STAR235 = default(IToken);
AstParserRuleReturnScope<CommonTree, IToken> typeIdentifier233 = default(AstParserRuleReturnScope<CommonTree, IToken>);
CommonTree COLON232_tree = default(CommonTree);
CommonTree string_literal234_tree = default(CommonTree);
CommonTree STAR235_tree = default(CommonTree);
RewriteRuleITokenStream stream_COLON=new RewriteRuleITokenStream(adaptor,"token COLON");
RewriteRuleITokenStream stream_257=new RewriteRuleITokenStream(adaptor,"token 257");
RewriteRuleITokenStream stream_STAR=new RewriteRuleITokenStream(adaptor,"token STAR");
RewriteRuleSubtreeStream stream_typeIdentifier=new RewriteRuleSubtreeStream(adaptor,"rule typeIdentifier");
try { DebugEnterRule(GrammarFileName, "typeExpression");
DebugLocation(567, 4);
try
{
// AS3.g:568:2: ( COLON ( typeIdentifier | 'void' | STAR ) -> ^( TYPE_SPEC COLON ( typeIdentifier )? ( 'void' )? ( STAR )? ) )
DebugEnterAlt(1);
// AS3.g:569:3: COLON ( typeIdentifier | 'void' | STAR )
{
DebugLocation(569, 3);
COLON232=(IToken)Match(input,COLON,Follow._COLON_in_typeExpression3075); if (state.failed) return retval;
if (state.backtracking == 0) stream_COLON.Add(COLON232);
DebugLocation(569, 9);
// AS3.g:569:9: ( typeIdentifier | 'void' | STAR )
int alt49=3;
try { DebugEnterSubRule(49);
try { DebugEnterDecision(49, false);
switch (input.LA(1))
{
case AS:
case DYNAMIC:
case GET:
case IDENT:
case IS:
case NAMESPACE:
case SET:
case SUPER:
case USE:
case XML:
{
alt49 = 1;
}
break;
case 257:
{
alt49 = 2;
}
break;
case STAR:
{
alt49 = 3;
}
break;
default:
{
if (state.backtracking>0) {state.failed=true; return retval;}
NoViableAltException nvae = new NoViableAltException("", 49, 0, input, 1);
DebugRecognitionException(nvae);
throw nvae;
}
}
} finally { DebugExitDecision(49); }
switch (alt49)
{
case 1:
DebugEnterAlt(1);
// AS3.g:569:10: typeIdentifier
{
DebugLocation(569, 10);
PushFollow(Follow._typeIdentifier_in_typeExpression3078);
typeIdentifier233=typeIdentifier();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) stream_typeIdentifier.Add(typeIdentifier233.Tree);
}
break;
case 2:
DebugEnterAlt(2);
// AS3.g:569:27: 'void'
{
DebugLocation(569, 27);
string_literal234=(IToken)Match(input,257,Follow._257_in_typeExpression3082); if (state.failed) return retval;
if (state.backtracking == 0) stream_257.Add(string_literal234);
}
break;
case 3:
DebugEnterAlt(3);
// AS3.g:569:36: STAR
{
DebugLocation(569, 36);
STAR235=(IToken)Match(input,STAR,Follow._STAR_in_typeExpression3086); if (state.failed) return retval;
if (state.backtracking == 0) stream_STAR.Add(STAR235);
}
break;
}
} finally { DebugExitSubRule(49); }
{
// AST REWRITE
// elements: COLON, typeIdentifier, 257, STAR
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
if (state.backtracking == 0) {
retval.Tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.Tree:null);
root_0 = (CommonTree)adaptor.Nil();
// 570:3: -> ^( TYPE_SPEC COLON ( typeIdentifier )? ( 'void' )? ( STAR )? )
{
DebugLocation(570, 6);
// AS3.g:570:6: ^( TYPE_SPEC COLON ( typeIdentifier )? ( 'void' )? ( STAR )? )
{
CommonTree root_1 = (CommonTree)adaptor.Nil();
DebugLocation(570, 8);
root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(TYPE_SPEC, "TYPE_SPEC"), root_1);
DebugLocation(570, 18);
adaptor.AddChild(root_1, stream_COLON.NextNode());
DebugLocation(570, 24);
// AS3.g:570:24: ( typeIdentifier )?
if (stream_typeIdentifier.HasNext)
{
DebugLocation(570, 24);
adaptor.AddChild(root_1, stream_typeIdentifier.NextTree());
}
stream_typeIdentifier.Reset();
DebugLocation(570, 40);
// AS3.g:570:40: ( 'void' )?
if (stream_257.HasNext)
{
DebugLocation(570, 40);
adaptor.AddChild(root_1, stream_257.NextNode());
}
stream_257.Reset();
DebugLocation(570, 48);
// AS3.g:570:48: ( STAR )?
if (stream_STAR.HasNext)
{
DebugLocation(570, 48);
adaptor.AddChild(root_1, stream_STAR.NextNode());
}
stream_STAR.Reset();
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;
}
}
}
retval.Stop = (IToken)input.LT(-1);
if (state.backtracking == 0) {
retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
}
}
catch (RecognitionException re)
{
ReportError(re);
Recover(input,re);
retval.Tree = (CommonTree)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);
}
finally
{
TraceOut("typeExpression", 71);
LeaveRule("typeExpression", 71);
LeaveRule_typeExpression();
}
DebugLocation(571, 4);
} finally { DebugExitRule(GrammarFileName, "typeExpression"); }
return retval;
}
private AstParserRuleReturnScope <object, IToken> plain_elem_list()
{
EnterRule_plain_elem_list();
EnterRule("plain_elem_list", 4);
TraceIn("plain_elem_list", 4);
AstParserRuleReturnScope <object, IToken> retval = new AstParserRuleReturnScope <object, IToken>();
retval.Start = (IToken)input.LT(1);
object root_0 = default(object);
List <object> list_p = null;
AstParserRuleReturnScope <object, IToken> p = default(AstParserRuleReturnScope <object, IToken>);
RewriteRuleSubtreeStream stream_plain_elem = new RewriteRuleSubtreeStream(adaptor, "rule plain_elem");
try { DebugEnterRule(GrammarFileName, "plain_elem_list");
DebugLocation(43, 1);
try
{
// C:\\Users\\franz\\SkyDrive\\Dokumente\\workspace\\TextTable\\src\\eu\\reitmayer\\texttable\\lang\\TextTable.g:43:16: ( (p+= plain_elem )+ -> ^( PLAIN_ELEM_LIST ( $p)+ ) )
DebugEnterAlt(1);
// C:\\Users\\franz\\SkyDrive\\Dokumente\\workspace\\TextTable\\src\\eu\\reitmayer\\texttable\\lang\\TextTable.g:44:2: (p+= plain_elem )+
{
DebugLocation(44, 3);
// C:\\Users\\franz\\SkyDrive\\Dokumente\\workspace\\TextTable\\src\\eu\\reitmayer\\texttable\\lang\\TextTable.g:44:3: (p+= plain_elem )+
int cnt2 = 0;
try { DebugEnterSubRule(2);
while (true)
{
int alt2 = 2;
try { DebugEnterDecision(2, false);
int LA2_0 = input.LA(1);
if ((LA2_0 == ID))
{
alt2 = 1;
}
} finally { DebugExitDecision(2); }
switch (alt2)
{
case 1:
DebugEnterAlt(1);
// C:\\Users\\franz\\SkyDrive\\Dokumente\\workspace\\TextTable\\src\\eu\\reitmayer\\texttable\\lang\\TextTable.g:44:3: p+= plain_elem
{
DebugLocation(44, 3);
PushFollow(Follow._plain_elem_in_plain_elem_list157);
p = plain_elem();
PopFollow();
stream_plain_elem.Add(p.Tree);
if (list_p == null)
{
list_p = new List <object>();
}
list_p.Add(p.Tree);
}
break;
default:
if (cnt2 >= 1)
{
goto loop2;
}
EarlyExitException eee2 = new EarlyExitException(2, input);
DebugRecognitionException(eee2);
throw eee2;
}
cnt2++;
}
loop2:
; } finally { DebugExitSubRule(2); }
{
// AST REWRITE
// elements: p
// token labels:
// rule labels: retval
// token list labels:
// rule list labels: p
// wildcard labels:
retval.Tree = root_0;
RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null?retval.Tree:null);
RewriteRuleSubtreeStream stream_p = new RewriteRuleSubtreeStream(adaptor, "token p", list_p);
root_0 = (object)adaptor.Nil();
// 44:17: -> ^( PLAIN_ELEM_LIST ( $p)+ )
{
DebugLocation(44, 20);
// C:\\Users\\franz\\SkyDrive\\Dokumente\\workspace\\TextTable\\src\\eu\\reitmayer\\texttable\\lang\\TextTable.g:44:20: ^( PLAIN_ELEM_LIST ( $p)+ )
{
object root_1 = (object)adaptor.Nil();
DebugLocation(44, 22);
root_1 = (object)adaptor.BecomeRoot((object)adaptor.Create(PLAIN_ELEM_LIST, "PLAIN_ELEM_LIST"), root_1);
DebugLocation(44, 39);
if (!(stream_p.HasNext))
{
throw new RewriteEarlyExitException();
}
while (stream_p.HasNext)
{
DebugLocation(44, 39);
adaptor.AddChild(root_1, stream_p.NextTree());
}
stream_p.Reset();
adaptor.AddChild(root_0, root_1);
}
}
retval.Tree = root_0;
}
}
retval.Stop = (IToken)input.LT(-1);
retval.Tree = (object)adaptor.RulePostProcessing(root_0);
adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
}
catch (RecognitionException re)
{
ReportError(re);
Recover(input, re);
retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);
}
finally
{
TraceOut("plain_elem_list", 4);
LeaveRule("plain_elem_list", 4);
LeaveRule_plain_elem_list();
}
DebugLocation(45, 1); } finally { DebugExitRule(GrammarFileName, "plain_elem_list"); }
return(retval);
}
