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); }