/// <summary> /// This method handles promotion of an EOL token to on channel in situations where the ECMA 3 specification /// states there should be a semicolon inserted because of an EOL between the current (offending) token /// and the previous token. /// So an semicolon is not actually inserted but the EOL present is switched from off to on channel. In this /// way that EOL gets the notion of an "virtual" semicolon. /// As a side effect a given rule's return scope starting point is set to the found EOL and the input stream is repositioned on it. /// A multi line comment with an EOL is also promoted. /// </summary> /// <param name="rule">The invoking rule's return scope</param> public void PromoteEol(AstParserRuleReturnScope <object, IToken> rule) { // Get current token and its type (the possibly offending token). IToken lt = input.LT(1); int la = lt.Type; // We only need to promote an EOL when the current token is offending (not a SEMIC, EOF, RBRACE or EOL). // Promoting an EOL means switching it from off channel to on channel. if (!(la == SEMIC || la == EOF || la == RBRACE || la == EOL)) { // Start on the possition before the current token and scan backwards off channel tokens until the previous on channel token. for (int ix = lt.TokenIndex - 1; ix > 0; ix--) { lt = input.Get(ix); if (lt.Channel == DefaultTokenChannel) { // On channel token found: stop scanning. break; } if (lt.Type == EOL || (lt.Type == MultiLineComment && Regex.IsMatch(lt.Text, "/.*\r\n|\r|\n"))) { // We found our EOL: promote it to on channel, position the input on it and reset the rule start. lt.Channel = DefaultTokenChannel; input.Seek(lt.TokenIndex); if (rule != null) { rule.Start = lt; } break; } } } }
public static string Compile(string input) { input = input.Replace("\r", ""); ANTLRStringStream Input = new ANTLRStringStream(input); SugarCppLexer lexer = new SugarCppLexer(Input); CommonTokenStream tokens = new CommonTokenStream(lexer); SugarCppParser parser = new SugarCppParser(tokens); AstParserRuleReturnScope <CommonTree, IToken> t = parser.root(); CommonTree ct = (CommonTree)t.Tree; if (parser.errors.Count() > 0) { StringBuilder sb = new StringBuilder(); foreach (var error in parser.errors) { sb.Append(error); sb.Append("\n"); } throw new Exception(sb.ToString()); } CommonTreeNodeStream nodes = new CommonTreeNodeStream(ct); SugarWalker walker = new SugarWalker(nodes); Root ast = walker.root(); TargetCpp target_cpp = new TargetCpp(); return(ast.Accept(target_cpp).Render()); }
public void TestMetaSettingsCSS() { // create CSS. string css = "meta { " + " title: \"Parking lanes\"; /* title shown in the menu */ " + " icon: \"images/logo.png\"; /* small icon shown in the menu next to the title */ " + "} "; // parses the MapCSS. AstParserRuleReturnScope <object, IToken> result = this.TestMapCSSParsingString(css); // Test the very minimum; no errors during parsing says a lot already! var tree = result.Tree as Antlr.Runtime.Tree.CommonTree; Assert.NotNull(tree); Assert.AreEqual(1, tree.ChildCount); // parse into domain. MapCSSFile file = MapCSSDomainParser.Parse(tree); Assert.IsNotNull(file); Assert.AreEqual(0, file.Rules.Count); Assert.AreEqual("Parking lanes", file.Title); Assert.AreEqual("images/logo.png", file.Icon); }
public void TestDomainColorNamed() { // parses the MapCSS. AstParserRuleReturnScope <object, IToken> result = this.TestMapCSSParsing( "OsmSharp.UI.Unittests.Data.MapCSS.color-named.mapcss"); // Test the very minimum; no errors during parsing says a lot already! var tree = result.Tree as Antlr.Runtime.Tree.CommonTree; Assert.NotNull(tree); Assert.AreEqual(2, tree.ChildCount); // parse into domain. MapCSSFile file = MapCSSDomainParser.Parse(tree); Assert.IsNotNull(file); Assert.AreEqual(1, file.Rules.Count); Assert.AreEqual(1, file.Rules[0].Declarations.Count); Assert.IsInstanceOf(typeof(DeclarationInt), file.Rules[0].Declarations[0]); // get color declaration. var declarationInt = file.Rules[0].Declarations[0] as DeclarationInt; Assert.IsNotNull(declarationInt); Assert.AreEqual(DeclarationIntEnum.Color, declarationInt.Qualifier); // instantiate color. var simpleColor = new SimpleColor(); simpleColor.Value = declarationInt.Eval((MapCSSObject)null); Assert.AreEqual("#FFFFFF", simpleColor.HexRgb); }
private AstParserRuleReturnScope <object, IToken> identifier() { EnterRule_identifier(); EnterRule("identifier", 5); TraceIn("identifier", 5); AstParserRuleReturnScope <object, IToken> retval = new AstParserRuleReturnScope <object, IToken>(); retval.Start = (IToken)input.LT(1); object root_0 = default(object); AstParserRuleReturnScope <object, IToken> prefixedName12 = default(AstParserRuleReturnScope <object, IToken>); try { DebugEnterRule(GrammarFileName, "identifier"); DebugLocation(55, 29); try { // ../Grammars/OslcOrderBy.g:55:15: ( prefixedName ) DebugEnterAlt(1); // ../Grammars/OslcOrderBy.g:55:17: prefixedName { root_0 = (object)adaptor.Nil(); DebugLocation(55, 17); PushFollow(Follow._prefixedName_in_identifier182); prefixedName12 = prefixedName(); PopFollow(); adaptor.AddChild(root_0, prefixedName12.Tree); } retval.Stop = (IToken)input.LT(-1); retval.Tree = (object)adaptor.RulePostProcessing(root_0); adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop); } catch (RecognitionException re) { ReportError(re); Recover(input, re); retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re); } finally { TraceOut("identifier", 5); LeaveRule("identifier", 5); LeaveRule_identifier(); } DebugLocation(55, 29); } finally { DebugExitRule(GrammarFileName, "identifier"); } return(retval); }
private AstParserRuleReturnScope <object, IToken> oslc_order_by() { EnterRule_oslc_order_by(); EnterRule("oslc_order_by", 1); TraceIn("oslc_order_by", 1); AstParserRuleReturnScope <object, IToken> retval = new AstParserRuleReturnScope <object, IToken>(); retval.Start = (IToken)input.LT(1); object root_0 = default(object); AstParserRuleReturnScope <object, IToken> sort_terms1 = default(AstParserRuleReturnScope <object, IToken>); try { DebugEnterRule(GrammarFileName, "oslc_order_by"); DebugLocation(43, 1); try { // ../Grammars/OslcOrderBy.g:43:15: ( sort_terms ) DebugEnterAlt(1); // ../Grammars/OslcOrderBy.g:43:17: sort_terms { root_0 = (object)adaptor.Nil(); DebugLocation(43, 17); PushFollow(Follow._sort_terms_in_oslc_order_by70); sort_terms1 = sort_terms(); PopFollow(); adaptor.AddChild(root_0, sort_terms1.Tree); } 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_order_by", 1); LeaveRule("oslc_order_by", 1); LeaveRule_oslc_order_by(); } DebugLocation(44, 1); } finally { DebugExitRule(GrammarFileName, "oslc_order_by"); } return(retval); }
public string Parse(string input) { Antlr.Runtime.ANTLRStringStream stream = new Antlr.Runtime.ANTLRStringStream(input); formulaLexer lexer = new formulaLexer(stream); CommonTokenStream tokens = new CommonTokenStream(lexer); formulaParser parser = new formulaParser(tokens); AstParserRuleReturnScope <CommonTree, CommonToken> result = parser.formula(); String textual = result.Tree.ToStringTree(); return(textual); }
/// <summary> /// Is a RuleReturnScope node candidate for the left-hand-side of an in expression? /// </summary> /// <param name="lhs">The RuleReturnScope node</param> /// <param name="cached">The cached result of a former call to this method</param> /// <returns>True if so, false otherwise</returns> public bool IsLeftHandSideIn(AstParserRuleReturnScope <object, IToken> lhs, ref bool?cached) { if (cached.HasValue) { return(cached.Value); } bool result = IsLeftHandSideExpression(lhs) && (input.LA(1) == IN); cached = result; return(result); }
public void TestHideNodes() { // parses the MapCSS. AstParserRuleReturnScope <object, IToken> result = this.TestMapCSSParsing( "OsmSharp.UI.Test.Unittests.Data.MapCSS.Hide_nodes.mapcss"); // Test the very minimum; no errors during parsing says a lot already! var tree = result.Tree as Antlr.Runtime.Tree.CommonTree; Assert.NotNull(tree); Assert.AreEqual(4, tree.ChildCount); }
public void Test_opencyclemap() { //TODO: this css will not parse; the meta section is a problem! // parses the MapCSS. AstParserRuleReturnScope <object, IToken> result = this.TestMapCSSParsing( "OsmSharp.UI.Test.Unittests.Data.MapCSS.opencyclemap.mapcss"); // Test the very minimum; no errors during parsing says a lot already! Antlr.Runtime.Tree.CommonTree tree = result.Tree as Antlr.Runtime.Tree.CommonTree; Assert.NotNull(tree); Assert.AreEqual(47, tree.ChildCount); }
private AstParserRuleReturnScope <object, IToken> string_esc() { EnterRule_string_esc(); EnterRule("string_esc", 2); TraceIn("string_esc", 2); AstParserRuleReturnScope <object, IToken> retval = new AstParserRuleReturnScope <object, IToken>(); retval.Start = (IToken)input.LT(1); object root_0 = default(object); IToken STRING_LITERAL4 = default(IToken); object STRING_LITERAL4_tree = default(object); try { DebugEnterRule(GrammarFileName, "string_esc"); DebugLocation(44, 31); try { // ../Grammars/OslcSearchTerms.g:44:15: ( STRING_LITERAL ) DebugEnterAlt(1); // ../Grammars/OslcSearchTerms.g:44:17: STRING_LITERAL { root_0 = (object)adaptor.Nil(); DebugLocation(44, 17); STRING_LITERAL4 = (IToken)Match(input, STRING_LITERAL, Follow._STRING_LITERAL_in_string_esc97); STRING_LITERAL4_tree = (object)adaptor.Create(STRING_LITERAL4); adaptor.AddChild(root_0, STRING_LITERAL4_tree); } 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("string_esc", 2); LeaveRule("string_esc", 2); LeaveRule_string_esc(); } DebugLocation(44, 31); } finally { DebugExitRule(GrammarFileName, "string_esc"); } return(retval); }
private AstParserRuleReturnScope <object, IToken> oslc_select() { EnterRule_oslc_select(); EnterRule("oslc_select", 1); TraceIn("oslc_select", 1); AstParserRuleReturnScope <object, IToken> retval = new AstParserRuleReturnScope <object, IToken>(); retval.Start = (IToken)input.LT(1); object root_0 = default(object); AstParserRuleReturnScope <object, IToken> properties1 = default(AstParserRuleReturnScope <object, IToken>); try { DebugEnterRule(GrammarFileName, "oslc_select"); DebugLocation(44, 1); try { // ../Grammars/OslcSelect.g:44:13: ( properties ) DebugEnterAlt(1); // ../Grammars/OslcSelect.g:44:15: properties { root_0 = (object)adaptor.Nil(); DebugLocation(44, 15); PushFollow(Follow._properties_in_oslc_select78); properties1 = properties(); PopFollow(); adaptor.AddChild(root_0, properties1.Tree); } 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_select", 1); LeaveRule("oslc_select", 1); LeaveRule_oslc_select(); } DebugLocation(45, 1); } finally { DebugExitRule(GrammarFileName, "oslc_select"); } return(retval); }
public static CommonTree GetAst(string input) { input = input.Replace("\r", ""); ANTLRStringStream Input = new ANTLRStringStream(input); SugarCppLexer lexer = new SugarCppLexer(Input); CommonTokenStream tokens = new CommonTokenStream(lexer); SugarCppParser parser = new SugarCppParser(tokens); AstParserRuleReturnScope <CommonTree, IToken> t = parser.root(); CommonTree ct = (CommonTree)t.Tree; return(ct); }
public static TargetCppResult Compile(string input, string file_name) { if (file_name.LastIndexOf("/") != -1) { file_name = file_name.Substring(file_name.LastIndexOf("/") + 1); } if (file_name.LastIndexOf("\\") != -1) { file_name = file_name.Substring(file_name.LastIndexOf("\\") + 1); } input = input.Replace("\r", ""); ANTLRStringStream Input = new ANTLRStringStream(input); SugarCppLexer lexer = new SugarCppLexer(Input); CommonTokenStream tokens = new CommonTokenStream(lexer); SugarCppParser parser = new SugarCppParser(tokens); AstParserRuleReturnScope <CommonTree, IToken> t = parser.root(); CommonTree ct = (CommonTree)t.Tree; if (parser.errors.Count() > 0) { StringBuilder sb = new StringBuilder(); foreach (var error in parser.errors) { sb.Append(error); sb.Append("\n"); } throw new Exception(sb.ToString()); } CommonTreeNodeStream nodes = new CommonTreeNodeStream(ct); SugarWalker walker = new SugarWalker(nodes); Root ast = walker.root(); TargetCppHeader header = new TargetCppHeader(); TargetCppImplementation implementation = new TargetCppImplementation(); implementation.HeaderFileName = string.Format("{0}.h", file_name); TargetCppResult result = new TargetCppResult(); result.Header = ast.Accept(header).Render(); result.Implementation = ast.Accept(implementation).Render(); return(result); }
public void TestDomainDefault() { // parses the MapCSS. AstParserRuleReturnScope <object, IToken> result = this.TestMapCSSParsing( "OsmSharp.UI.Unittests.Data.MapCSS.default.mapcss"); // Test the very minimum; no errors during parsing says a lot already! var tree = result.Tree as Antlr.Runtime.Tree.CommonTree; Assert.NotNull(tree); Assert.AreEqual(54, tree.ChildCount); // parse into domain. MapCSSFile file = MapCSSDomainParser.Parse(tree); Assert.IsNotNull(file); }
/// <summary> /// Is a RuleReturnScope node candidate for the left-hand-side of an assignment expression? /// </summary> /// <param name="lhs">The RuleReturnScope node</param> /// <param name="cached">The cached result of a former call to this method</param> /// <returns>True if so, false otherwise</returns> public bool IsLeftHandSideAssign(AstParserRuleReturnScope <object, IToken> lhs, ref bool?cached) { if (cached.HasValue) { return(cached.Value); } bool result; if (IsLeftHandSideExpression(lhs)) { switch (input.LA(1)) { case ASSIGN: case MULASS: case DIVASS: case MODASS: case ADDASS: case SUBASS: case SHLASS: case SHRASS: case SHUASS: case ANDASS: case XORASS: case ORASS: result = true; break; default: result = false; break; } } else { result = false; } cached = result; return(result); }
public static void Loop2() { bool exit = false; string input = ""; KermitParser parser = new KermitParser(null); //parser.TreeAdaptor = new KermitAdaptor(); while (!exit) { if (input == string.Empty) { Console.Write("> "); } else { Console.Write(".. "); } input += Console.ReadLine() + "\n"; ANTLRStringStream stream = new ANTLRStringStream(input); KermitLexer lexer = new KermitLexer(stream); TokenRewriteStream tokens = new TokenRewriteStream(lexer); parser.TokenStream = tokens; try { AstParserRuleReturnScope <KermitAST, CommonToken> result = parser.program(); var tree = (CommonTree)result.Tree; DotTreeGenerator gen = new DotTreeGenerator(); Console.WriteLine("{0}", gen.ToDot(tree)); input = ""; //Console.WriteLine(globalScope.ToString()); } catch (PartialStatement) { } catch (ParserException e) { } } }
/// <summary> /// Is a RuleReturnScope node candidate for the left-hand-side of an assignment expression? /// </summary> /// <param name="lhs">The RuleReturnScope node</param> /// <param name="cached">The cached result of a former call to this method</param> /// <returns>True if so, false otherwise</returns> public bool IsLeftHandSideAssign(AstParserRuleReturnScope<object, IToken> lhs, ref bool? cached) { if (cached.HasValue) { return cached.Value; } bool result; if (IsLeftHandSideExpression(lhs)) { switch (input.LA(1)) { case ASSIGN: case MULASS: case DIVASS: case MODASS: case ADDASS: case SUBASS: case SHLASS: case SHRASS: case SHUASS: case ANDASS: case XORASS: case ORASS: result = true; break; default: result = false; break; } } else { result = false; } cached = result; return result; }
/// <summary> /// Is a RuleReturnScope node candidate a left-hand-side expression? /// </summary> /// <param name="lhs">The RuleReturnScope node</param> /// <returns>True if so, false otherwise</returns> private bool IsLeftHandSideExpression(AstParserRuleReturnScope <object, IToken> lhs) { if (lhs.Tree == null) // e.g. during backtracking { return(true); } else { switch (((ITree)lhs.Tree).Type) { // primaryExpression case THIS: case Identifier: case NULL: case TRUE: case FALSE: case DecimalLiteral: case OctalIntegerLiteral: case HexIntegerLiteral: case StringLiteral: case RegularExpressionLiteral: case ARRAY: case OBJECT: case PAREXPR: // functionExpression case FUNCTION: // newExpression case NEW: // leftHandSideExpression case CALL: case BYFIELD: case BYINDEX: return(true); default: return(false); } } }
/// <summary> /// Is a RuleReturnScope node candidate a left-hand-side expression? /// </summary> /// <param name="lhs">The RuleReturnScope node</param> /// <returns>True if so, false otherwise</returns> private bool IsLeftHandSideExpression(AstParserRuleReturnScope<object, IToken> lhs) { if (lhs.Tree == null) // e.g. during backtracking { return true; } else { switch (((ITree)lhs.Tree).Type) { // primaryExpression case THIS: case Identifier: case NULL: case TRUE: case FALSE: case DecimalLiteral: case OctalIntegerLiteral: case HexIntegerLiteral: case StringLiteral: case RegularExpressionLiteral: case ARRAY: case OBJECT: case PAREXPR: // functionExpression case FUNCTION: // newExpression case NEW: // leftHandSideExpression case CALL: case BYFIELD: case BYINDEX: return true; default: return false; } } }
public void Compile(string script) { ANTLRStringStream input = new ANTLRStringStream(script); bgitestLexer tokenSource = new bgitestLexer(input); CommonTokenStream input2 = new CommonTokenStream(tokenSource); bgitestParser bgitestParser = new bgitestParser(input2); AstParserRuleReturnScope <CommonTree, IToken> astParserRuleReturnScope = bgitestParser.program(); Mstream = new MemoryStream(); Output = new BinaryWriter(Mstream); CommonTree tree = astParserRuleReturnScope.Tree; if (tree.Token != null) { ParseBlock(tree); } else { foreach (CommonTree child in tree.Children) { ParseBlock(child); } } }
/** * Parse a math expression string and return the corresponding AST */ public static CommonTree Parse(string expression) { guardLexer lexer = new guardLexer(new ANTLRStringStream(expression)); guardParser parser = new guardParser(new CommonTokenStream(lexer)); try { AstParserRuleReturnScope <CommonTree, CommonToken> rule = parser.getExpression(); if (parser.HasError) { throw new Exception(parser.ErrorMessage + " " + parser.ErrorPosition); } return(rule.Tree as CommonTree); } catch (NoViableAltException) { throw; } catch (Exception) { throw; //throw new EvaluationException(e.Message, e); } }
private AstParserRuleReturnScope<CommonTree, IToken> forInClauseDecl() { EnterRule_forInClauseDecl(); EnterRule("forInClauseDecl", 62); TraceIn("forInClauseDecl", 62); AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>(); retval.Start = (IToken)input.LT(1); CommonTree root_0 = default(CommonTree); AstParserRuleReturnScope<CommonTree, IToken> varOrConst206 = default(AstParserRuleReturnScope<CommonTree, IToken>); AstParserRuleReturnScope<CommonTree, IToken> ident207 = default(AstParserRuleReturnScope<CommonTree, IToken>); AstParserRuleReturnScope<CommonTree, IToken> typeExpression208 = default(AstParserRuleReturnScope<CommonTree, IToken>); AstParserRuleReturnScope<CommonTree, IToken> ident209 = default(AstParserRuleReturnScope<CommonTree, IToken>); try { DebugEnterRule(GrammarFileName, "forInClauseDecl"); DebugLocation(522, 1); try { // AS3.g:523:2: ( varOrConst ident ( typeExpression )? | ident ) int alt45=2; try { DebugEnterDecision(45, false); int LA45_1 = input.LA(1); if ((LA45_1==CONST||LA45_1==VAR)) { alt45 = 1; } else if ((LA45_1==AS||LA45_1==DYNAMIC||LA45_1==GET||LA45_1==IDENT||LA45_1==IS||LA45_1==NAMESPACE||LA45_1==SET||LA45_1==SUPER||LA45_1==USE||LA45_1==XML)) { alt45 = 2; } else { if (state.backtracking>0) {state.failed=true; return retval;} NoViableAltException nvae = new NoViableAltException("", 45, 0, input, 1); DebugRecognitionException(nvae); throw nvae; } } finally { DebugExitDecision(45); } switch (alt45) { case 1: DebugEnterAlt(1); // AS3.g:523:4: varOrConst ident ( typeExpression )? { root_0 = (CommonTree)adaptor.Nil(); DebugLocation(523, 4); PushFollow(Follow._varOrConst_in_forInClauseDecl2840); varOrConst206=varOrConst(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) adaptor.AddChild(root_0, varOrConst206.Tree); DebugLocation(523, 15); PushFollow(Follow._ident_in_forInClauseDecl2842); ident207=ident(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) adaptor.AddChild(root_0, ident207.Tree); DebugLocation(523, 21); // AS3.g:523:21: ( typeExpression )? int alt44=2; try { DebugEnterSubRule(44); try { DebugEnterDecision(44, false); int LA44_1 = input.LA(1); if ((LA44_1==COLON)) { alt44 = 1; } } finally { DebugExitDecision(44); } switch (alt44) { case 1: DebugEnterAlt(1); // AS3.g:523:21: typeExpression { DebugLocation(523, 21); PushFollow(Follow._typeExpression_in_forInClauseDecl2844); typeExpression208=typeExpression(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) adaptor.AddChild(root_0, typeExpression208.Tree); } break; } } finally { DebugExitSubRule(44); } } break; case 2: DebugEnterAlt(2); // AS3.g:524:11: ident { root_0 = (CommonTree)adaptor.Nil(); DebugLocation(524, 11); PushFollow(Follow._ident_in_forInClauseDecl2858); ident209=ident(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) adaptor.AddChild(root_0, ident209.Tree); } break; } 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("forInClauseDecl", 62); LeaveRule("forInClauseDecl", 62); LeaveRule_forInClauseDecl(); } DebugLocation(525, 1); } finally { DebugExitRule(GrammarFileName, "forInClauseDecl"); } return retval; }
private AstParserRuleReturnScope<CommonTree, IToken> forStatement() { EnterRule_forStatement(); EnterRule("forStatement", 59); TraceIn("forStatement", 59); AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>(); retval.Start = (IToken)input.LT(1); CommonTree root_0 = default(CommonTree); IToken FOR190 = default(IToken); IToken LPAREN191 = default(IToken); IToken RPAREN193 = default(IToken); IToken RPAREN196 = default(IToken); AstParserRuleReturnScope<CommonTree, IToken> forInClause192 = default(AstParserRuleReturnScope<CommonTree, IToken>); AstParserRuleReturnScope<CommonTree, IToken> statement194 = default(AstParserRuleReturnScope<CommonTree, IToken>); AstParserRuleReturnScope<CommonTree, IToken> traditionalForClause195 = default(AstParserRuleReturnScope<CommonTree, IToken>); AstParserRuleReturnScope<CommonTree, IToken> statement197 = default(AstParserRuleReturnScope<CommonTree, IToken>); CommonTree FOR190_tree = default(CommonTree); CommonTree LPAREN191_tree = default(CommonTree); CommonTree RPAREN193_tree = default(CommonTree); CommonTree RPAREN196_tree = default(CommonTree); RewriteRuleITokenStream stream_FOR=new RewriteRuleITokenStream(adaptor,"token FOR"); RewriteRuleITokenStream stream_LPAREN=new RewriteRuleITokenStream(adaptor,"token LPAREN"); RewriteRuleITokenStream stream_RPAREN=new RewriteRuleITokenStream(adaptor,"token RPAREN"); RewriteRuleSubtreeStream stream_forInClause=new RewriteRuleSubtreeStream(adaptor,"rule forInClause"); RewriteRuleSubtreeStream stream_statement=new RewriteRuleSubtreeStream(adaptor,"rule statement"); RewriteRuleSubtreeStream stream_traditionalForClause=new RewriteRuleSubtreeStream(adaptor,"rule traditionalForClause"); try { DebugEnterRule(GrammarFileName, "forStatement"); DebugLocation(500, 1); try { // AS3.g:502:2: ( FOR LPAREN ( forInClause RPAREN statement -> ^( FOR_IN_LOOP FOR LPAREN forInClause RPAREN statement ) | traditionalForClause RPAREN statement -> ^( FOR_LOOP FOR LPAREN traditionalForClause RPAREN statement ) ) ) DebugEnterAlt(1); // AS3.g:502:4: FOR LPAREN ( forInClause RPAREN statement -> ^( FOR_IN_LOOP FOR LPAREN forInClause RPAREN statement ) | traditionalForClause RPAREN statement -> ^( FOR_LOOP FOR LPAREN traditionalForClause RPAREN statement ) ) { DebugLocation(502, 4); FOR190=(IToken)Match(input,FOR,Follow._FOR_in_forStatement2717); if (state.failed) return retval; if (state.backtracking == 0) stream_FOR.Add(FOR190); DebugLocation(503, 3); LPAREN191=(IToken)Match(input,LPAREN,Follow._LPAREN_in_forStatement2721); if (state.failed) return retval; if (state.backtracking == 0) stream_LPAREN.Add(LPAREN191); DebugLocation(504, 3); // AS3.g:504:3: ( forInClause RPAREN statement -> ^( FOR_IN_LOOP FOR LPAREN forInClause RPAREN statement ) | traditionalForClause RPAREN statement -> ^( FOR_LOOP FOR LPAREN traditionalForClause RPAREN statement ) ) int alt43=2; try { DebugEnterSubRule(43); try { DebugEnterDecision(43, false); try { alt43 = dfa43.Predict(input); } catch (NoViableAltException nvae) { DebugRecognitionException(nvae); throw; } } finally { DebugExitDecision(43); } switch (alt43) { case 1: DebugEnterAlt(1); // AS3.g:504:5: forInClause RPAREN statement { DebugLocation(504, 5); PushFollow(Follow._forInClause_in_forStatement2727); forInClause192=forInClause(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) stream_forInClause.Add(forInClause192.Tree); DebugLocation(504, 17); RPAREN193=(IToken)Match(input,RPAREN,Follow._RPAREN_in_forStatement2729); if (state.failed) return retval; if (state.backtracking == 0) stream_RPAREN.Add(RPAREN193); DebugLocation(504, 24); PushFollow(Follow._statement_in_forStatement2731); statement194=statement(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) stream_statement.Add(statement194.Tree); { // AST REWRITE // elements: FOR, LPAREN, forInClause, RPAREN, statement // token labels: // rule labels: retval // token list labels: // rule list labels: // wildcard labels: if (state.backtracking == 0) { retval.Tree = root_0; RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.Tree:null); root_0 = (CommonTree)adaptor.Nil(); // 505:4: -> ^( FOR_IN_LOOP FOR LPAREN forInClause RPAREN statement ) { DebugLocation(505, 7); // AS3.g:505:7: ^( FOR_IN_LOOP FOR LPAREN forInClause RPAREN statement ) { CommonTree root_1 = (CommonTree)adaptor.Nil(); DebugLocation(505, 9); root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(FOR_IN_LOOP, "FOR_IN_LOOP"), root_1); DebugLocation(505, 21); adaptor.AddChild(root_1, stream_FOR.NextNode()); DebugLocation(505, 25); adaptor.AddChild(root_1, stream_LPAREN.NextNode()); DebugLocation(505, 32); adaptor.AddChild(root_1, stream_forInClause.NextTree()); DebugLocation(505, 44); adaptor.AddChild(root_1, stream_RPAREN.NextNode()); DebugLocation(505, 51); adaptor.AddChild(root_1, stream_statement.NextTree()); adaptor.AddChild(root_0, root_1); } } retval.Tree = root_0; } } } break; case 2: DebugEnterAlt(2); // AS3.g:507:5: traditionalForClause RPAREN statement { DebugLocation(507, 5); PushFollow(Follow._traditionalForClause_in_forStatement2757); traditionalForClause195=traditionalForClause(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) stream_traditionalForClause.Add(traditionalForClause195.Tree); DebugLocation(507, 26); RPAREN196=(IToken)Match(input,RPAREN,Follow._RPAREN_in_forStatement2759); if (state.failed) return retval; if (state.backtracking == 0) stream_RPAREN.Add(RPAREN196); DebugLocation(507, 33); PushFollow(Follow._statement_in_forStatement2761); statement197=statement(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) stream_statement.Add(statement197.Tree); { // AST REWRITE // elements: FOR, LPAREN, traditionalForClause, RPAREN, statement // token labels: // rule labels: retval // token list labels: // rule list labels: // wildcard labels: if (state.backtracking == 0) { retval.Tree = root_0; RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.Tree:null); root_0 = (CommonTree)adaptor.Nil(); // 508:4: -> ^( FOR_LOOP FOR LPAREN traditionalForClause RPAREN statement ) { DebugLocation(508, 7); // AS3.g:508:7: ^( FOR_LOOP FOR LPAREN traditionalForClause RPAREN statement ) { CommonTree root_1 = (CommonTree)adaptor.Nil(); DebugLocation(508, 9); root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(FOR_LOOP, "FOR_LOOP"), root_1); DebugLocation(508, 18); adaptor.AddChild(root_1, stream_FOR.NextNode()); DebugLocation(508, 22); adaptor.AddChild(root_1, stream_LPAREN.NextNode()); DebugLocation(508, 29); adaptor.AddChild(root_1, stream_traditionalForClause.NextTree()); DebugLocation(508, 50); adaptor.AddChild(root_1, stream_RPAREN.NextNode()); DebugLocation(508, 57); adaptor.AddChild(root_1, stream_statement.NextTree()); adaptor.AddChild(root_0, root_1); } } retval.Tree = root_0; } } } break; } } finally { DebugExitSubRule(43); } } retval.Stop = (IToken)input.LT(-1); if (state.backtracking == 0) { retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0); adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop); } } catch (RecognitionException re) { ReportError(re); Recover(input,re); retval.Tree = (CommonTree)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re); } finally { TraceOut("forStatement", 59); LeaveRule("forStatement", 59); LeaveRule_forStatement(); } DebugLocation(510, 1); } finally { DebugExitRule(GrammarFileName, "forStatement"); } return retval; }
private AstParserRuleReturnScope<CommonTree, IToken> traditionalForClause() { EnterRule_traditionalForClause(); EnterRule("traditionalForClause", 60); TraceIn("traditionalForClause", 60); AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>(); retval.Start = (IToken)input.LT(1); CommonTree root_0 = default(CommonTree); AstParserRuleReturnScope<CommonTree, IToken> forInit198 = default(AstParserRuleReturnScope<CommonTree, IToken>); AstParserRuleReturnScope<CommonTree, IToken> semi199 = default(AstParserRuleReturnScope<CommonTree, IToken>); AstParserRuleReturnScope<CommonTree, IToken> forCond200 = default(AstParserRuleReturnScope<CommonTree, IToken>); AstParserRuleReturnScope<CommonTree, IToken> semi201 = default(AstParserRuleReturnScope<CommonTree, IToken>); AstParserRuleReturnScope<CommonTree, IToken> forIter202 = default(AstParserRuleReturnScope<CommonTree, IToken>); try { DebugEnterRule(GrammarFileName, "traditionalForClause"); DebugLocation(512, 1); try { // AS3.g:513:2: ( forInit semi forCond semi forIter ) DebugEnterAlt(1); // AS3.g:513:4: forInit semi forCond semi forIter { root_0 = (CommonTree)adaptor.Nil(); DebugLocation(513, 4); PushFollow(Follow._forInit_in_traditionalForClause2795); forInit198=forInit(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) adaptor.AddChild(root_0, forInit198.Tree); DebugLocation(513, 13); PushFollow(Follow._semi_in_traditionalForClause2798); semi199=semi(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) adaptor.AddChild(root_0, semi199.Tree); DebugLocation(514, 3); PushFollow(Follow._forCond_in_traditionalForClause2803); forCond200=forCond(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) adaptor.AddChild(root_0, forCond200.Tree); DebugLocation(514, 12); PushFollow(Follow._semi_in_traditionalForClause2806); semi201=semi(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) adaptor.AddChild(root_0, semi201.Tree); DebugLocation(515, 3); PushFollow(Follow._forIter_in_traditionalForClause2811); forIter202=forIter(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) adaptor.AddChild(root_0, forIter202.Tree); } 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("traditionalForClause", 60); LeaveRule("traditionalForClause", 60); LeaveRule_traditionalForClause(); } DebugLocation(516, 1); } finally { DebugExitRule(GrammarFileName, "traditionalForClause"); } return retval; }
private AstParserRuleReturnScope<CommonTree, IToken> caseStatement() { EnterRule_caseStatement(); EnterRule("caseStatement", 55); TraceIn("caseStatement", 55); AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>(); retval.Start = (IToken)input.LT(1); CommonTree root_0 = default(CommonTree); IToken CASE179 = default(IToken); IToken COLON181 = default(IToken); AstParserRuleReturnScope<CommonTree, IToken> l = default(AstParserRuleReturnScope<CommonTree, IToken>); AstParserRuleReturnScope<CommonTree, IToken> expression180 = default(AstParserRuleReturnScope<CommonTree, IToken>); CommonTree CASE179_tree = default(CommonTree); CommonTree COLON181_tree = default(CommonTree); try { DebugEnterRule(GrammarFileName, "caseStatement"); DebugLocation(479, 1); try { // AS3.g:480:2: ( CASE expression COLON !l= switchStatementList ) DebugEnterAlt(1); // AS3.g:480:4: CASE expression COLON !l= switchStatementList { root_0 = (CommonTree)adaptor.Nil(); DebugLocation(480, 4); CASE179=(IToken)Match(input,CASE,Follow._CASE_in_caseStatement2608); if (state.failed) return retval; if (state.backtracking == 0) { CASE179_tree = (CommonTree)adaptor.Create(CASE179); adaptor.AddChild(root_0, CASE179_tree); } DebugLocation(480, 9); PushFollow(Follow._expression_in_caseStatement2610); expression180=expression(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) adaptor.AddChild(root_0, expression180.Tree); DebugLocation(480, 25); COLON181=(IToken)Match(input,COLON,Follow._COLON_in_caseStatement2612); if (state.failed) return retval; DebugLocation(480, 28); PushFollow(Follow._switchStatementList_in_caseStatement2617); l=switchStatementList(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) adaptor.AddChild(root_0, l.Tree); } 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("caseStatement", 55); LeaveRule("caseStatement", 55); LeaveRule_caseStatement(); } DebugLocation(481, 1); } finally { DebugExitRule(GrammarFileName, "caseStatement"); } 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; }
private AstParserRuleReturnScope<CommonTree, IToken> defaultXMLNamespaceStatement() { EnterRule_defaultXMLNamespaceStatement(); EnterRule("defaultXMLNamespaceStatement", 70); TraceIn("defaultXMLNamespaceStatement", 70); AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>(); retval.Start = (IToken)input.LT(1); CommonTree root_0 = default(CommonTree); IToken DEFAULT226 = default(IToken); IToken XML227 = default(IToken); IToken NAMESPACE228 = default(IToken); IToken ASSIGN229 = default(IToken); AstParserRuleReturnScope<CommonTree, IToken> expression230 = default(AstParserRuleReturnScope<CommonTree, IToken>); AstParserRuleReturnScope<CommonTree, IToken> semi231 = default(AstParserRuleReturnScope<CommonTree, IToken>); CommonTree DEFAULT226_tree = default(CommonTree); CommonTree XML227_tree = default(CommonTree); CommonTree NAMESPACE228_tree = default(CommonTree); CommonTree ASSIGN229_tree = default(CommonTree); RewriteRuleITokenStream stream_DEFAULT=new RewriteRuleITokenStream(adaptor,"token DEFAULT"); RewriteRuleITokenStream stream_XML=new RewriteRuleITokenStream(adaptor,"token XML"); RewriteRuleITokenStream stream_NAMESPACE=new RewriteRuleITokenStream(adaptor,"token NAMESPACE"); RewriteRuleITokenStream stream_ASSIGN=new RewriteRuleITokenStream(adaptor,"token ASSIGN"); RewriteRuleSubtreeStream stream_expression=new RewriteRuleSubtreeStream(adaptor,"rule expression"); RewriteRuleSubtreeStream stream_semi=new RewriteRuleSubtreeStream(adaptor,"rule semi"); try { DebugEnterRule(GrammarFileName, "defaultXMLNamespaceStatement"); DebugLocation(562, 1); try { // AS3.g:563:2: ( DEFAULT XML NAMESPACE ASSIGN expression semi -> ^( DEFAULT_XML_NAMESPACE expression ) ) DebugEnterAlt(1); // AS3.g:563:4: DEFAULT XML NAMESPACE ASSIGN expression semi { DebugLocation(563, 4); DEFAULT226=(IToken)Match(input,DEFAULT,Follow._DEFAULT_in_defaultXMLNamespaceStatement3040); if (state.failed) return retval; if (state.backtracking == 0) stream_DEFAULT.Add(DEFAULT226); DebugLocation(563, 12); XML227=(IToken)Match(input,XML,Follow._XML_in_defaultXMLNamespaceStatement3042); if (state.failed) return retval; if (state.backtracking == 0) stream_XML.Add(XML227); DebugLocation(563, 16); NAMESPACE228=(IToken)Match(input,NAMESPACE,Follow._NAMESPACE_in_defaultXMLNamespaceStatement3044); if (state.failed) return retval; if (state.backtracking == 0) stream_NAMESPACE.Add(NAMESPACE228); DebugLocation(563, 26); ASSIGN229=(IToken)Match(input,ASSIGN,Follow._ASSIGN_in_defaultXMLNamespaceStatement3046); if (state.failed) return retval; if (state.backtracking == 0) stream_ASSIGN.Add(ASSIGN229); DebugLocation(563, 33); PushFollow(Follow._expression_in_defaultXMLNamespaceStatement3048); expression230=expression(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) stream_expression.Add(expression230.Tree); DebugLocation(563, 44); PushFollow(Follow._semi_in_defaultXMLNamespaceStatement3050); semi231=semi(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) stream_semi.Add(semi231.Tree); { // AST REWRITE // elements: expression // token labels: // rule labels: retval // token list labels: // rule list labels: // wildcard labels: if (state.backtracking == 0) { retval.Tree = root_0; RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.Tree:null); root_0 = (CommonTree)adaptor.Nil(); // 564:3: -> ^( DEFAULT_XML_NAMESPACE expression ) { DebugLocation(564, 6); // AS3.g:564:6: ^( DEFAULT_XML_NAMESPACE expression ) { CommonTree root_1 = (CommonTree)adaptor.Nil(); DebugLocation(564, 8); root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(DEFAULT_XML_NAMESPACE, "DEFAULT_XML_NAMESPACE"), root_1); DebugLocation(564, 30); adaptor.AddChild(root_1, stream_expression.NextTree()); adaptor.AddChild(root_0, root_1); } } retval.Tree = root_0; } } } retval.Stop = (IToken)input.LT(-1); if (state.backtracking == 0) { retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0); adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop); } } catch (RecognitionException re) { ReportError(re); Recover(input,re); retval.Tree = (CommonTree)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re); } finally { TraceOut("defaultXMLNamespaceStatement", 70); LeaveRule("defaultXMLNamespaceStatement", 70); LeaveRule_defaultXMLNamespaceStatement(); } DebugLocation(565, 1); } finally { DebugExitRule(GrammarFileName, "defaultXMLNamespaceStatement"); } return retval; }
private AstParserRuleReturnScope<CommonTree, IToken> switchStatement() { EnterRule_switchStatement(); EnterRule("switchStatement", 53); TraceIn("switchStatement", 53); AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>(); retval.Start = (IToken)input.LT(1); CommonTree root_0 = default(CommonTree); IToken SWITCH172 = default(IToken); AstParserRuleReturnScope<CommonTree, IToken> condition173 = default(AstParserRuleReturnScope<CommonTree, IToken>); AstParserRuleReturnScope<CommonTree, IToken> switchBlock174 = default(AstParserRuleReturnScope<CommonTree, IToken>); CommonTree SWITCH172_tree = default(CommonTree); RewriteRuleITokenStream stream_SWITCH=new RewriteRuleITokenStream(adaptor,"token SWITCH"); RewriteRuleSubtreeStream stream_condition=new RewriteRuleSubtreeStream(adaptor,"rule condition"); RewriteRuleSubtreeStream stream_switchBlock=new RewriteRuleSubtreeStream(adaptor,"rule switchBlock"); try { DebugEnterRule(GrammarFileName, "switchStatement"); DebugLocation(465, 1); try { // AS3.g:466:2: ( SWITCH condition switchBlock -> ^( SWITCH_STATEMENT SWITCH condition switchBlock ) ) DebugEnterAlt(1); // AS3.g:466:4: SWITCH condition switchBlock { DebugLocation(466, 4); SWITCH172=(IToken)Match(input,SWITCH,Follow._SWITCH_in_switchStatement2528); if (state.failed) return retval; if (state.backtracking == 0) stream_SWITCH.Add(SWITCH172); DebugLocation(466, 11); PushFollow(Follow._condition_in_switchStatement2530); condition173=condition(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) stream_condition.Add(condition173.Tree); DebugLocation(467, 3); PushFollow(Follow._switchBlock_in_switchStatement2534); switchBlock174=switchBlock(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) stream_switchBlock.Add(switchBlock174.Tree); { // AST REWRITE // elements: SWITCH, condition, switchBlock // token labels: // rule labels: retval // token list labels: // rule list labels: // wildcard labels: if (state.backtracking == 0) { retval.Tree = root_0; RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.Tree:null); root_0 = (CommonTree)adaptor.Nil(); // 468:9: -> ^( SWITCH_STATEMENT SWITCH condition switchBlock ) { DebugLocation(468, 12); // AS3.g:468:12: ^( SWITCH_STATEMENT SWITCH condition switchBlock ) { CommonTree root_1 = (CommonTree)adaptor.Nil(); DebugLocation(468, 14); root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(SWITCH_STATEMENT, "SWITCH_STATEMENT"), root_1); DebugLocation(468, 31); adaptor.AddChild(root_1, stream_SWITCH.NextNode()); DebugLocation(468, 38); adaptor.AddChild(root_1, stream_condition.NextTree()); DebugLocation(468, 48); adaptor.AddChild(root_1, stream_switchBlock.NextTree()); adaptor.AddChild(root_0, root_1); } } retval.Tree = root_0; } } } retval.Stop = (IToken)input.LT(-1); if (state.backtracking == 0) { retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0); adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop); } } catch (RecognitionException re) { ReportError(re); Recover(input,re); retval.Tree = (CommonTree)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re); } finally { TraceOut("switchStatement", 53); LeaveRule("switchStatement", 53); LeaveRule_switchStatement(); } DebugLocation(469, 1); } finally { DebugExitRule(GrammarFileName, "switchStatement"); } return retval; }
//throw new CompilerException(nvae.Message, nvae.Line, nvae.CharPositionInLine); public void Compile(string FileName, string Source) { Tokens = new List <Token>(); Errors = new List <CompilerError>(); CoolGrammarLexer lexer = null; CoolGrammarParser parser = null; CoolCodeGenerator generator = null; try { var stream = new ANTLRStringStream(Source); lexer = new CoolGrammarLexer(stream, new RecognizerSharedState() { errorRecovery = true }); IToken token; token = lexer.NextToken(); while (token.Type != CoolGrammarLexer.EOF) { Tokens.Add( new Token { Name = CoolTokens.Dictionary[token.Type], Value = token.Text, Line = token.Line, Column = token.CharPositionInLine }); token = lexer.NextToken(); } lexer.Reset(); lexer.Line = 0; lexer.CharPositionInLine = 0; } catch (EarlyExitException exception) { Errors.Add(new EarlyExitErrorLexer(exception.Message, Errors.Count(), exception.Line, exception.CharPositionInLine)); } catch (MismatchedSetException exception) { Errors.Add(new MismatchedSetErrorLexer(exception.Message, Errors.Count(), exception.Line, exception.CharPositionInLine)); } catch (NoViableAltException exception) { Errors.Add(new NoViableAltErrorLexer(exception.Message, Errors.Count(), exception.Line, exception.CharPositionInLine)); } catch (CompilerException exception) { Errors.Add(new CommonLexerError(exception.Message, Errors.Count(), exception.Line, exception.Column)); } catch { } try { var tokenStream = new CommonTokenStream(lexer); parser = new CoolGrammarParser(tokenStream); Tree = parser.program(); } catch (EarlyExitException exception) { Errors.Add(new EarlyExitErrorParser(exception.Message, Errors.Count(), exception.Line, exception.CharPositionInLine)); } catch (MismatchedSetException exception) { Errors.Add(new MismatchedSetErrorParser(exception.Message, Errors.Count(), exception.Line, exception.CharPositionInLine)); } catch (NoViableAltException exception) { Errors.Add(new NoViableAltErrorParser(exception.Message, Errors.Count(), exception.Line, exception.CharPositionInLine)); } catch (RecognitionException exception) { Errors.Add(new RecognitionError(exception.Message, Errors.Count(), exception.Line, exception.CharPositionInLine)); } catch (RewriteEarlyExitException exception) { Errors.Add(new RewriteEarlyExitError(exception.Message, Errors.Count())); } catch (CompilerException exception) { Errors.Add(new CommonParserError(exception.Message, Errors.Count(), exception.Line, exception.Column)); } catch (Exception exception) { Errors.Add(new CommonParserError(exception.Message, Errors.Count(), null, null)); } try { generator = new CoolCodeGenerator(FileName, Tree.Tree); generator.Generate(); GeneratedProgramName = System.IO.Path.GetFileNameWithoutExtension(FileName) + ".exe"; foreach (var error in generator.CompilerErrors) { Errors.Add(error); } } catch (Exception e) { Errors.Add(new CommonError(e.Message, Errors.Count)); } if (Tree == null) { Tree = new AstParserRuleReturnScope <CommonTree, CommonToken>(); } }
private AstParserRuleReturnScope <object, IToken> identifier() { EnterRule_identifier(); EnterRule("identifier", 5); TraceIn("identifier", 5); AstParserRuleReturnScope <object, IToken> retval = new AstParserRuleReturnScope <object, IToken>(); retval.Start = (IToken)input.LT(1); object root_0 = default(object); IToken ASTERISK12 = default(IToken); AstParserRuleReturnScope <object, IToken> prefixedName11 = default(AstParserRuleReturnScope <object, IToken>); object ASTERISK12_tree = default(object); RewriteRuleITokenStream stream_ASTERISK = new RewriteRuleITokenStream(adaptor, "token ASTERISK"); RewriteRuleSubtreeStream stream_prefixedName = new RewriteRuleSubtreeStream(adaptor, "rule prefixedName"); try { DebugEnterRule(GrammarFileName, "identifier"); DebugLocation(56, 1); try { // ../Grammars/OslcSelect.g:56:12: ( prefixedName -> ^( 'prefixed_name' prefixedName ) | ASTERISK -> ^( 'wildcard' ) ) int alt3 = 2; try { DebugEnterDecision(3, false); int LA3_1 = input.LA(1); if (((LA3_1 >= PNAME_LN && LA3_1 <= PNAME_NS))) { alt3 = 1; } else if ((LA3_1 == ASTERISK)) { alt3 = 2; } else { NoViableAltException nvae = new NoViableAltException("", 3, 0, input, 1); DebugRecognitionException(nvae); throw nvae; } } finally { DebugExitDecision(3); } switch (alt3) { case 1: DebugEnterAlt(1); // ../Grammars/OslcSelect.g:56:14: prefixedName { DebugLocation(56, 14); PushFollow(Follow._prefixedName_in_identifier173); prefixedName11 = prefixedName(); PopFollow(); stream_prefixedName.Add(prefixedName11.Tree); { // AST REWRITE // elements: prefixedName, PREFIXED_NAME // token labels: // rule labels: retval // token list labels: // rule list labels: // wildcard labels: retval.Tree = root_0; RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null?retval.Tree:null); root_0 = (object)adaptor.Nil(); // 56:27: -> ^( 'prefixed_name' prefixedName ) { DebugLocation(56, 30); // ../Grammars/OslcSelect.g:56:30: ^( 'prefixed_name' prefixedName ) { object root_1 = (object)adaptor.Nil(); DebugLocation(56, 33); root_1 = (object)adaptor.BecomeRoot((object)adaptor.Create(PREFIXED_NAME, "PREFIXED_NAME"), root_1); DebugLocation(56, 49); adaptor.AddChild(root_1, stream_prefixedName.NextTree()); adaptor.AddChild(root_0, root_1); } } retval.Tree = root_0; } } break; case 2: DebugEnterAlt(2); // ../Grammars/OslcSelect.g:57:7: ASTERISK { DebugLocation(57, 7); ASTERISK12 = (IToken)Match(input, ASTERISK, Follow._ASTERISK_in_identifier191); stream_ASTERISK.Add(ASTERISK12); { // AST REWRITE // elements: WILDCARD // token labels: // rule labels: retval // token list labels: // rule list labels: // wildcard labels: retval.Tree = root_0; RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null?retval.Tree:null); root_0 = (object)adaptor.Nil(); // 57:16: -> ^( 'wildcard' ) { DebugLocation(57, 19); // ../Grammars/OslcSelect.g:57:19: ^( 'wildcard' ) { object root_1 = (object)adaptor.Nil(); DebugLocation(57, 22); root_1 = (object)adaptor.BecomeRoot((object)adaptor.Create(WILDCARD, "WILDCARD"), root_1); adaptor.AddChild(root_0, root_1); } } retval.Tree = root_0; } } break; } retval.Stop = (IToken)input.LT(-1); retval.Tree = (object)adaptor.RulePostProcessing(root_0); adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop); } catch (RecognitionException re) { ReportError(re); Recover(input, re); retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re); } finally { TraceOut("identifier", 5); LeaveRule("identifier", 5); LeaveRule_identifier(); } DebugLocation(58, 1); } finally { DebugExitRule(GrammarFileName, "identifier"); } return(retval); }
private AstParserRuleReturnScope <object, IToken> prefixedName() { EnterRule_prefixedName(); EnterRule("prefixedName", 6); TraceIn("prefixedName", 6); AstParserRuleReturnScope <object, IToken> retval = new AstParserRuleReturnScope <object, IToken>(); retval.Start = (IToken)input.LT(1); object root_0 = default(object); IToken set13 = default(IToken); object set13_tree = default(object); try { DebugEnterRule(GrammarFileName, "prefixedName"); DebugLocation(57, 4); try { // ../Grammars/OslcOrderBy.g:58:5: ( PNAME_LN | PNAME_NS ) DebugEnterAlt(1); // ../Grammars/OslcOrderBy.g: { root_0 = (object)adaptor.Nil(); DebugLocation(58, 5); set13 = (IToken)input.LT(1); if ((input.LA(1) >= PNAME_LN && input.LA(1) <= PNAME_NS)) { input.Consume(); // if (Result == null) // { // this.Result = oslc_order_by().Tree; // } if (Result is CommonTree commonTree) { if (commonTree?.Children?.Any(item => item is CommonErrorNode) ?? false) { throw new RecognitionException(); } } adaptor.AddChild(root_0, (object)adaptor.Create(set13)); state.errorRecovery = false; } else { MismatchedSetException mse = new MismatchedSetException(null, input); DebugRecognitionException(mse); throw mse; } } 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("prefixedName", 6); LeaveRule("prefixedName", 6); LeaveRule_prefixedName(); } DebugLocation(60, 4); } finally { DebugExitRule(GrammarFileName, "prefixedName"); } 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 AstParserRuleReturnScope <object, IToken> prefix_binding() { EnterRule_prefix_binding(); EnterRule("prefix_binding", 2); TraceIn("prefix_binding", 2); AstParserRuleReturnScope <object, IToken> retval = new AstParserRuleReturnScope <object, IToken>(); retval.Start = (IToken)input.LT(1); object root_0 = default(object); IToken PN_PREFIX4 = default(IToken); IToken char_literal5 = default(IToken); IToken IRI_REF6 = default(IToken); object PN_PREFIX4_tree = default(object); object char_literal5_tree = default(object); object IRI_REF6_tree = default(object); RewriteRuleITokenStream stream_PN_PREFIX = new RewriteRuleITokenStream(adaptor, "token PN_PREFIX"); RewriteRuleITokenStream stream_IRI_REF = new RewriteRuleITokenStream(adaptor, "token IRI_REF"); RewriteRuleITokenStream stream_21 = new RewriteRuleITokenStream(adaptor, "token 21"); try { DebugEnterRule(GrammarFileName, "prefix_binding"); DebugLocation(46, 4); try { // ../Grammars/OslcPrefix.g:46:16: ( PN_PREFIX '=' IRI_REF -> ^( 'prefix' PN_PREFIX IRI_REF ) ) DebugEnterAlt(1); // ../Grammars/OslcPrefix.g:46:18: PN_PREFIX '=' IRI_REF { DebugLocation(46, 18); PN_PREFIX4 = (IToken)Match(input, PN_PREFIX, Follow._PN_PREFIX_in_prefix_binding105); stream_PN_PREFIX.Add(PN_PREFIX4); DebugLocation(46, 28); char_literal5 = (IToken)Match(input, 21, Follow._21_in_prefix_binding107); stream_21.Add(char_literal5); DebugLocation(46, 32); IRI_REF6 = (IToken)Match(input, IRI_REF, Follow._IRI_REF_in_prefix_binding109); stream_IRI_REF.Add(IRI_REF6); { // AST REWRITE // elements: IRI_REF, PREFIX, PN_PREFIX // token labels: // rule labels: retval // token list labels: // rule list labels: // wildcard labels: retval.Tree = root_0; RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null?retval.Tree:null); root_0 = (object)adaptor.Nil(); // 46:40: -> ^( 'prefix' PN_PREFIX IRI_REF ) { DebugLocation(46, 43); // ../Grammars/OslcPrefix.g:46:43: ^( 'prefix' PN_PREFIX IRI_REF ) { object root_1 = (object)adaptor.Nil(); DebugLocation(46, 46); root_1 = (object)adaptor.BecomeRoot((object)adaptor.Create(PREFIX, "PREFIX"), root_1); DebugLocation(46, 55); adaptor.AddChild(root_1, stream_PN_PREFIX.NextNode()); DebugLocation(46, 65); adaptor.AddChild(root_1, stream_IRI_REF.NextNode()); adaptor.AddChild(root_0, root_1); } } retval.Tree = root_0; } } retval.Stop = (IToken)input.LT(-1); retval.Tree = (object)adaptor.RulePostProcessing(root_0); adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop); } catch (RecognitionException re) { ReportError(re); Recover(input, re); retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re); } finally { TraceOut("prefix_binding", 2); LeaveRule("prefix_binding", 2); LeaveRule_prefix_binding(); } DebugLocation(47, 4); } finally { DebugExitRule(GrammarFileName, "prefix_binding"); } return(retval); }
private AstParserRuleReturnScope <object, IToken> scoped_sort_term() { EnterRule_scoped_sort_term(); EnterRule("scoped_sort_term", 4); TraceIn("scoped_sort_term", 4); AstParserRuleReturnScope <object, IToken> retval = new AstParserRuleReturnScope <object, IToken>(); retval.Start = (IToken)input.LT(1); object root_0 = default(object); IToken char_literal9 = default(IToken); IToken char_literal11 = default(IToken); AstParserRuleReturnScope <object, IToken> identifier8 = default(AstParserRuleReturnScope <object, IToken>); AstParserRuleReturnScope <object, IToken> sort_terms10 = default(AstParserRuleReturnScope <object, IToken>); object char_literal9_tree = default(object); object char_literal11_tree = default(object); RewriteRuleITokenStream stream_CLOSE_CURLY_BRACE = new RewriteRuleITokenStream(adaptor, "token CLOSE_CURLY_BRACE"); RewriteRuleITokenStream stream_OPEN_CURLY_BRACE = new RewriteRuleITokenStream(adaptor, "token OPEN_CURLY_BRACE"); RewriteRuleSubtreeStream stream_sort_terms = new RewriteRuleSubtreeStream(adaptor, "rule sort_terms"); RewriteRuleSubtreeStream stream_identifier = new RewriteRuleSubtreeStream(adaptor, "rule identifier"); try { DebugEnterRule(GrammarFileName, "scoped_sort_term"); DebugLocation(52, 4); try { // ../Grammars/OslcOrderBy.g:52:18: ( identifier '{' sort_terms '}' -> ^( 'scoped_term' identifier sort_terms ) ) DebugEnterAlt(1); // ../Grammars/OslcOrderBy.g:52:20: identifier '{' sort_terms '}' { DebugLocation(52, 20); PushFollow(Follow._identifier_in_scoped_sort_term148); identifier8 = identifier(); PopFollow(); stream_identifier.Add(identifier8.Tree); DebugLocation(52, 31); char_literal9 = (IToken)Match(input, OPEN_CURLY_BRACE, Follow._OPEN_CURLY_BRACE_in_scoped_sort_term150); stream_OPEN_CURLY_BRACE.Add(char_literal9); DebugLocation(52, 35); PushFollow(Follow._sort_terms_in_scoped_sort_term152); sort_terms10 = sort_terms(); PopFollow(); stream_sort_terms.Add(sort_terms10.Tree); DebugLocation(52, 46); char_literal11 = (IToken)Match(input, CLOSE_CURLY_BRACE, Follow._CLOSE_CURLY_BRACE_in_scoped_sort_term154); stream_CLOSE_CURLY_BRACE.Add(char_literal11); { // AST REWRITE // elements: SCOPED_TERM, identifier, sort_terms // token labels: // rule labels: retval // token list labels: // rule list labels: // wildcard labels: retval.Tree = root_0; RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.Tree : null); root_0 = (object)adaptor.Nil(); // 52:50: -> ^( 'scoped_term' identifier sort_terms ) { DebugLocation(52, 53); // ../Grammars/OslcOrderBy.g:52:53: ^( 'scoped_term' identifier sort_terms ) { object root_1 = (object)adaptor.Nil(); DebugLocation(52, 56); root_1 = (object)adaptor.BecomeRoot((object)adaptor.Create(SCOPED_TERM, "SCOPED_TERM"), root_1); DebugLocation(52, 70); adaptor.AddChild(root_1, stream_identifier.NextTree()); DebugLocation(52, 81); adaptor.AddChild(root_1, stream_sort_terms.NextTree()); adaptor.AddChild(root_0, root_1); } } retval.Tree = root_0; } } retval.Stop = (IToken)input.LT(-1); retval.Tree = (object)adaptor.RulePostProcessing(root_0); adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop); } catch (RecognitionException re) { ReportError(re); Recover(input, re); retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re); } finally { TraceOut("scoped_sort_term", 4); LeaveRule("scoped_sort_term", 4); LeaveRule_scoped_sort_term(); } DebugLocation(53, 4); } finally { DebugExitRule(GrammarFileName, "scoped_sort_term"); } return(retval); }
private AstParserRuleReturnScope <object, IToken> sort_term() { EnterRule_sort_term(); EnterRule("sort_term", 3); TraceIn("sort_term", 3); AstParserRuleReturnScope <object, IToken> retval = new AstParserRuleReturnScope <object, IToken>(); retval.Start = (IToken)input.LT(1); object root_0 = default(object); IToken DIRECTION6 = default(IToken); AstParserRuleReturnScope <object, IToken> scoped_sort_term5 = default(AstParserRuleReturnScope <object, IToken>); AstParserRuleReturnScope <object, IToken> identifier7 = default(AstParserRuleReturnScope <object, IToken>); object DIRECTION6_tree = default(object); RewriteRuleITokenStream stream_DIRECTION = new RewriteRuleITokenStream(adaptor, "token DIRECTION"); RewriteRuleSubtreeStream stream_identifier = new RewriteRuleSubtreeStream(adaptor, "rule identifier"); try { DebugEnterRule(GrammarFileName, "sort_term"); DebugLocation(49, 1); try { // ../Grammars/OslcOrderBy.g:49:13: ( scoped_sort_term | DIRECTION identifier -> ^( 'simple_term' identifier DIRECTION ) ) int alt2 = 2; try { DebugEnterDecision(2, false); int LA2_1 = input.LA(1); if (((LA2_1 >= PNAME_LN && LA2_1 <= PNAME_NS))) { alt2 = 1; } else if ((LA2_1 == DIRECTION)) { alt2 = 2; } else { NoViableAltException nvae = new NoViableAltException("", 2, 0, input, 1); DebugRecognitionException(nvae); throw nvae; } } finally { DebugExitDecision(2); } switch (alt2) { case 1: DebugEnterAlt(1); // ../Grammars/OslcOrderBy.g:49:15: scoped_sort_term { root_0 = (object)adaptor.Nil(); DebugLocation(49, 15); PushFollow(Follow._scoped_sort_term_in_sort_term120); scoped_sort_term5 = scoped_sort_term(); PopFollow(); adaptor.AddChild(root_0, scoped_sort_term5.Tree); } break; case 2: DebugEnterAlt(2); // ../Grammars/OslcOrderBy.g:49:34: DIRECTION identifier { DebugLocation(49, 34); DIRECTION6 = (IToken)Match(input, DIRECTION, Follow._DIRECTION_in_sort_term124); stream_DIRECTION.Add(DIRECTION6); DebugLocation(49, 44); PushFollow(Follow._identifier_in_sort_term126); identifier7 = identifier(); PopFollow(); stream_identifier.Add(identifier7.Tree); { // AST REWRITE // elements: identifier, DIRECTION, SIMPLE_TERM // token labels: // rule labels: retval // token list labels: // rule list labels: // wildcard labels: retval.Tree = root_0; RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.Tree : null); root_0 = (object)adaptor.Nil(); // 49:55: -> ^( 'simple_term' identifier DIRECTION ) { DebugLocation(49, 58); // ../Grammars/OslcOrderBy.g:49:58: ^( 'simple_term' identifier DIRECTION ) { object root_1 = (object)adaptor.Nil(); DebugLocation(49, 61); root_1 = (object)adaptor.BecomeRoot((object)adaptor.Create(SIMPLE_TERM, "SIMPLE_TERM"), root_1); DebugLocation(49, 75); adaptor.AddChild(root_1, stream_identifier.NextTree()); DebugLocation(49, 86); adaptor.AddChild(root_1, stream_DIRECTION.NextNode()); adaptor.AddChild(root_0, root_1); } } retval.Tree = root_0; } } break; } retval.Stop = (IToken)input.LT(-1); retval.Tree = (object)adaptor.RulePostProcessing(root_0); adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop); } catch (RecognitionException re) { ReportError(re); Recover(input, re); retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re); } finally { TraceOut("sort_term", 3); LeaveRule("sort_term", 3); LeaveRule_sort_term(); } DebugLocation(50, 1); } finally { DebugExitRule(GrammarFileName, "sort_term"); } return(retval); }
private AstParserRuleReturnScope<CommonTree, IToken> 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 int checkGrammar(string vhod) { try { ANTLRStringStream sStream = new ANTLRStringStream(vhod); RobotLanguageLexer lexer = new RobotLanguageLexer(sStream); CommonTokenStream tStream = new CommonTokenStream(lexer); RobotLanguageParser parser = new RobotLanguageParser(tStream); AstParserRuleReturnScope <CommonTree, IToken> odgovor = parser.start(); CommonTree drevo = (CommonTree)odgovor.Tree; string izpis = String.Empty; Dictionary <string, float[]> CINDEKS = new Dictionary <string, float[]>(); for (int i = 0; i < drevo.ChildCount; i++) { ITree token = drevo.GetChild(i); switch (token.Type) { case -1: break; //EOF //case 0: richTextBox2.Text += GetTimestamp(DateTime.Now) + "Napaka!! Vrstica: " + token.Text + Environment.NewLine; return -1; case 4: break; //ATTR case 5: break; //COMM case 6: break; //DATE case 7: break; //DIN case 8: break; //DOUT case 9: break; //FRAME case 10: break; //GROUP case 11: try { string key = token.Text; i++; float[] value = new float[6]; for (int j = 0; j < 6; j++, i++) { if (drevo.GetChild(i).Type == 15) { value[j] = -1f * (float)Convert.ToDouble(drevo.GetChild(i + 1).Text.Replace(".", ",")); i++; } //negativni predznak else { value[j] = (float)Convert.ToDouble(drevo.GetChild(i).Text.Replace(".", ",")); } } CINDEKS.Add(key, value); i--; izpis += "\t" + token.Text + " (" + value[0].ToString() + " " + value[1].ToString() + " " + value[2].ToString() + " " + value[3].ToString() + " " + value[4].ToString() + " " + value[5].ToString() + ")" + Environment.NewLine; } catch { richTextBox2.Text += GetTimestamp(DateTime.Now) + "Napaka!! Token" + "(" + i.ToString() + ")" + ": " + token.Text + Environment.NewLine; return(-1); } break; //INDEKS case 12: break; //INST case 13: break; //INT case 14: break; //JOB case 15: break; //MINUS case 16: try { string usedKey = drevo.GetChild(i + 1).Text; float delay = (float)Convert.ToDouble(drevo.GetChild(i + 3).Text.Replace(".", ",")); //MOVC(CINDEKS[usedKey], delay); i += 3; izpis += "\t" + token.Text + " (" + usedKey + ", " + delay.ToString() + ")" + Environment.NewLine; } catch { richTextBox2.Text += GetTimestamp(DateTime.Now) + "Napaka!! Token" + "(" + i.ToString() + ")" + ": " + token.Text + Environment.NewLine; return(-1); } break; //MOVC case 17: try { string usedKey = drevo.GetChild(i + 1).Text; float delay = (float)Convert.ToDouble(drevo.GetChild(i + 3).Text.Replace(".", ",")); //MOVJ(CINDEKS[usedKey], delay); i += 3; izpis += "\t" + token.Text + " (" + usedKey + ", " + delay.ToString() + ")" + Environment.NewLine; } catch { richTextBox2.Text += GetTimestamp(DateTime.Now) + "Napaka!! Token" + "(" + i.ToString() + ")" + ": " + token.Text + Environment.NewLine; return(-1); } break; //MOVJ case 18: try { string usedKey = drevo.GetChild(i + 1).Text; float delay = (float)Convert.ToDouble(drevo.GetChild(i + 3).Text.Replace(".", ",")); //MOVL(CINDEKS[usedKey], delay); i += 3; izpis += "\t" + token.Text + " (" + usedKey + ", " + delay.ToString() + ")" + Environment.NewLine; } catch { richTextBox2.Text += GetTimestamp(DateTime.Now) + "Napaka!! Token" + "(" + i.ToString() + ")" + ": " + token.Text + Environment.NewLine; return(-1); } break; //MOVL case 19: try { string usedKey = drevo.GetChild(i + 1).Text; float delay = (float)Convert.ToDouble(drevo.GetChild(i + 3).Text.Replace(".", ",")); //MOVS(CINDEKS[usedKey], delay); i += 3; izpis += "\t" + token.Text + " (" + usedKey + ", " + delay.ToString() + ")" + Environment.NewLine; } catch { richTextBox2.Text += GetTimestamp(DateTime.Now) + "Napaka!! Token" + "(" + i.ToString() + ")" + ": " + token.Text + Environment.NewLine; return(-1); } break; //MOVS case 20: break; //NAME case 21: break; //NEWLINE case 22: break; //NIZ case 23: break; //NPOS case 24: break; //ONOFF case 25: break; //POS case 26: break; //POSTYPE case 27: break; //RCONF case 28: break; //REAL case 29: break; //RECTAN case 30: break; //TIME case 31: try { float timer = (float)Convert.ToDouble(drevo.GetChild(i + 1).Text.Replace(".", ",")); //izpis += "\t" + token.Text + "(" + timer.ToString() + ")" + Environment.NewLine; } catch { richTextBox2.Text += GetTimestamp(DateTime.Now) + "Napaka!! Token" + "(" + i.ToString() + ")" + ": " + token.Text + Environment.NewLine; return(-1); } break; //TIMER case 32: break; //TOOL case 33: break; //USER case 34: break; //WS } } richTextBox2.Text += GetTimestamp(DateTime.Now) + Environment.NewLine + izpis; return(0); } catch { richTextBox2.Text += GetTimestamp(DateTime.Now) + "Something went wrong..." + Environment.NewLine; return(-1); } }
private AstParserRuleReturnScope<CommonTree, IToken> doWhileStatement() { EnterRule_doWhileStatement(); EnterRule("doWhileStatement", 68); TraceIn("doWhileStatement", 68); AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>(); retval.Start = (IToken)input.LT(1); CommonTree root_0 = default(CommonTree); IToken DO218 = default(IToken); IToken WHILE220 = default(IToken); AstParserRuleReturnScope<CommonTree, IToken> statement219 = default(AstParserRuleReturnScope<CommonTree, IToken>); AstParserRuleReturnScope<CommonTree, IToken> condition221 = default(AstParserRuleReturnScope<CommonTree, IToken>); AstParserRuleReturnScope<CommonTree, IToken> semi222 = default(AstParserRuleReturnScope<CommonTree, IToken>); CommonTree DO218_tree = default(CommonTree); CommonTree WHILE220_tree = default(CommonTree); RewriteRuleITokenStream stream_DO=new RewriteRuleITokenStream(adaptor,"token DO"); RewriteRuleITokenStream stream_WHILE=new RewriteRuleITokenStream(adaptor,"token WHILE"); RewriteRuleSubtreeStream stream_statement=new RewriteRuleSubtreeStream(adaptor,"rule statement"); RewriteRuleSubtreeStream stream_condition=new RewriteRuleSubtreeStream(adaptor,"rule condition"); RewriteRuleSubtreeStream stream_semi=new RewriteRuleSubtreeStream(adaptor,"rule semi"); try { DebugEnterRule(GrammarFileName, "doWhileStatement"); DebugLocation(553, 1); try { // AS3.g:554:2: ( DO statement WHILE condition semi -> ^( DO_WHILE_LOOP DO statement WHILE condition ) ) DebugEnterAlt(1); // AS3.g:554:4: DO statement WHILE condition semi { DebugLocation(554, 4); DO218=(IToken)Match(input,DO,Follow._DO_in_doWhileStatement2989); if (state.failed) return retval; if (state.backtracking == 0) stream_DO.Add(DO218); DebugLocation(554, 7); PushFollow(Follow._statement_in_doWhileStatement2991); statement219=statement(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) stream_statement.Add(statement219.Tree); DebugLocation(554, 17); WHILE220=(IToken)Match(input,WHILE,Follow._WHILE_in_doWhileStatement2993); if (state.failed) return retval; if (state.backtracking == 0) stream_WHILE.Add(WHILE220); DebugLocation(554, 23); PushFollow(Follow._condition_in_doWhileStatement2995); condition221=condition(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) stream_condition.Add(condition221.Tree); DebugLocation(554, 33); PushFollow(Follow._semi_in_doWhileStatement2997); semi222=semi(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) stream_semi.Add(semi222.Tree); { // AST REWRITE // elements: DO, statement, WHILE, condition // token labels: // rule labels: retval // token list labels: // rule list labels: // wildcard labels: if (state.backtracking == 0) { retval.Tree = root_0; RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.Tree:null); root_0 = (CommonTree)adaptor.Nil(); // 555:3: -> ^( DO_WHILE_LOOP DO statement WHILE condition ) { DebugLocation(555, 6); // AS3.g:555:6: ^( DO_WHILE_LOOP DO statement WHILE condition ) { CommonTree root_1 = (CommonTree)adaptor.Nil(); DebugLocation(555, 8); root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(DO_WHILE_LOOP, "DO_WHILE_LOOP"), root_1); DebugLocation(555, 22); adaptor.AddChild(root_1, stream_DO.NextNode()); DebugLocation(555, 25); adaptor.AddChild(root_1, stream_statement.NextTree()); DebugLocation(555, 35); adaptor.AddChild(root_1, stream_WHILE.NextNode()); DebugLocation(555, 41); adaptor.AddChild(root_1, stream_condition.NextTree()); adaptor.AddChild(root_0, root_1); } } retval.Tree = root_0; } } } retval.Stop = (IToken)input.LT(-1); if (state.backtracking == 0) { retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0); adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop); } } catch (RecognitionException re) { ReportError(re); Recover(input,re); retval.Tree = (CommonTree)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re); } finally { TraceOut("doWhileStatement", 68); LeaveRule("doWhileStatement", 68); LeaveRule_doWhileStatement(); } DebugLocation(556, 1); } finally { DebugExitRule(GrammarFileName, "doWhileStatement"); } return retval; }
private AstParserRuleReturnScope<CommonTree, IToken> 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> elseClause() { EnterRule_elseClause(); EnterRule("elseClause", 45); TraceIn("elseClause", 45); AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>(); retval.Start = (IToken)input.LT(1); CommonTree root_0 = default(CommonTree); IToken ELSE152 = default(IToken); AstParserRuleReturnScope<CommonTree, IToken> statement153 = default(AstParserRuleReturnScope<CommonTree, IToken>); CommonTree ELSE152_tree = default(CommonTree); RewriteRuleITokenStream stream_ELSE=new RewriteRuleITokenStream(adaptor,"token ELSE"); RewriteRuleSubtreeStream stream_statement=new RewriteRuleSubtreeStream(adaptor,"rule statement"); try { DebugEnterRule(GrammarFileName, "elseClause"); DebugLocation(423, 1); try { // AS3.g:424:2: ( ELSE statement -> ^( ELSE_CLAUSE ELSE statement ) ) DebugEnterAlt(1); // AS3.g:424:4: ELSE statement { DebugLocation(424, 4); ELSE152=(IToken)Match(input,ELSE,Follow._ELSE_in_elseClause2266); if (state.failed) return retval; if (state.backtracking == 0) stream_ELSE.Add(ELSE152); DebugLocation(424, 9); PushFollow(Follow._statement_in_elseClause2268); statement153=statement(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) stream_statement.Add(statement153.Tree); { // AST REWRITE // elements: ELSE, statement // token labels: // rule labels: retval // token list labels: // rule list labels: // wildcard labels: if (state.backtracking == 0) { retval.Tree = root_0; RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.Tree:null); root_0 = (CommonTree)adaptor.Nil(); // 425:9: -> ^( ELSE_CLAUSE ELSE statement ) { DebugLocation(425, 12); // AS3.g:425:12: ^( ELSE_CLAUSE ELSE statement ) { CommonTree root_1 = (CommonTree)adaptor.Nil(); DebugLocation(425, 14); root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(ELSE_CLAUSE, "ELSE_CLAUSE"), root_1); DebugLocation(425, 26); adaptor.AddChild(root_1, stream_ELSE.NextNode()); DebugLocation(425, 31); adaptor.AddChild(root_1, stream_statement.NextTree()); adaptor.AddChild(root_0, root_1); } } retval.Tree = root_0; } } } retval.Stop = (IToken)input.LT(-1); if (state.backtracking == 0) { retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0); adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop); } } catch (RecognitionException re) { ReportError(re); Recover(input,re); retval.Tree = (CommonTree)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re); } finally { TraceOut("elseClause", 45); LeaveRule("elseClause", 45); LeaveRule_elseClause(); } DebugLocation(426, 1); } finally { DebugExitRule(GrammarFileName, "elseClause"); } return retval; }
private AstParserRuleReturnScope<CommonTree, IToken> 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> throwStatement() { EnterRule_throwStatement(); EnterRule("throwStatement", 46); TraceIn("throwStatement", 46); AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>(); retval.Start = (IToken)input.LT(1); CommonTree root_0 = default(CommonTree); IToken string_literal154 = default(IToken); AstParserRuleReturnScope<CommonTree, IToken> s = default(AstParserRuleReturnScope<CommonTree, IToken>); AstParserRuleReturnScope<CommonTree, IToken> expression155 = default(AstParserRuleReturnScope<CommonTree, IToken>); CommonTree string_literal154_tree = default(CommonTree); RewriteRuleITokenStream stream_253=new RewriteRuleITokenStream(adaptor,"token 253"); RewriteRuleSubtreeStream stream_expression=new RewriteRuleSubtreeStream(adaptor,"rule expression"); RewriteRuleSubtreeStream stream_semi=new RewriteRuleSubtreeStream(adaptor,"rule semi"); try { DebugEnterRule(GrammarFileName, "throwStatement"); DebugLocation(428, 1); try { // AS3.g:429:2: ( 'throw' expression s= semi -> ^( THROW_STATEMENT 'throw' expression ) ) DebugEnterAlt(1); // AS3.g:429:4: 'throw' expression s= semi { DebugLocation(429, 4); string_literal154=(IToken)Match(input,253,Follow._253_in_throwStatement2298); if (state.failed) return retval; if (state.backtracking == 0) stream_253.Add(string_literal154); DebugLocation(429, 12); PushFollow(Follow._expression_in_throwStatement2300); expression155=expression(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) stream_expression.Add(expression155.Tree); DebugLocation(429, 24); PushFollow(Follow._semi_in_throwStatement2304); s=semi(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) stream_semi.Add(s.Tree); { // AST REWRITE // elements: 253, expression // token labels: // rule labels: retval // token list labels: // rule list labels: // wildcard labels: if (state.backtracking == 0) { retval.Tree = root_0; RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.Tree:null); root_0 = (CommonTree)adaptor.Nil(); // 430:9: -> ^( THROW_STATEMENT 'throw' expression ) { DebugLocation(430, 12); // AS3.g:430:12: ^( THROW_STATEMENT 'throw' expression ) { CommonTree root_1 = (CommonTree)adaptor.Nil(); DebugLocation(430, 14); root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(THROW_STATEMENT, "THROW_STATEMENT"), root_1); DebugLocation(430, 30); adaptor.AddChild(root_1, stream_253.NextNode()); DebugLocation(430, 38); adaptor.AddChild(root_1, stream_expression.NextTree()); DebugLocation(430, 49); adaptor.AddChild(root_1, maybeSemi(s)); adaptor.AddChild(root_0, root_1); } } retval.Tree = root_0; } } } retval.Stop = (IToken)input.LT(-1); if (state.backtracking == 0) { retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0); adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop); } } catch (RecognitionException re) { ReportError(re); Recover(input,re); retval.Tree = (CommonTree)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re); } finally { TraceOut("throwStatement", 46); LeaveRule("throwStatement", 46); LeaveRule_throwStatement(); } DebugLocation(431, 1); } finally { DebugExitRule(GrammarFileName, "throwStatement"); } return retval; }
private AstParserRuleReturnScope<CommonTree, IToken> defaultStatement() { EnterRule_defaultStatement(); EnterRule("defaultStatement", 56); TraceIn("defaultStatement", 56); AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>(); retval.Start = (IToken)input.LT(1); CommonTree root_0 = default(CommonTree); IToken DEFAULT182 = default(IToken); IToken COLON183 = default(IToken); AstParserRuleReturnScope<CommonTree, IToken> l = default(AstParserRuleReturnScope<CommonTree, IToken>); CommonTree DEFAULT182_tree = default(CommonTree); CommonTree COLON183_tree = default(CommonTree); try { DebugEnterRule(GrammarFileName, "defaultStatement"); DebugLocation(483, 1); try { // AS3.g:484:2: ( DEFAULT COLON !l= switchStatementList ) DebugEnterAlt(1); // AS3.g:484:4: DEFAULT COLON !l= switchStatementList { root_0 = (CommonTree)adaptor.Nil(); DebugLocation(484, 4); DEFAULT182=(IToken)Match(input,DEFAULT,Follow._DEFAULT_in_defaultStatement2630); if (state.failed) return retval; if (state.backtracking == 0) { DEFAULT182_tree = (CommonTree)adaptor.Create(DEFAULT182); adaptor.AddChild(root_0, DEFAULT182_tree); } DebugLocation(484, 17); COLON183=(IToken)Match(input,COLON,Follow._COLON_in_defaultStatement2632); if (state.failed) return retval; DebugLocation(484, 20); PushFollow(Follow._switchStatementList_in_defaultStatement2637); l=switchStatementList(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) adaptor.AddChild(root_0, l.Tree); } 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("defaultStatement", 56); LeaveRule("defaultStatement", 56); LeaveRule_defaultStatement(); } DebugLocation(485, 1); } finally { DebugExitRule(GrammarFileName, "defaultStatement"); } 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> forEachStatement() { EnterRule_forEachStatement(); EnterRule("forEachStatement", 58); TraceIn("forEachStatement", 58); AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>(); retval.Start = (IToken)input.LT(1); CommonTree root_0 = default(CommonTree); IToken f = default(IToken); IToken EACH185 = default(IToken); IToken LPAREN186 = default(IToken); IToken RPAREN188 = default(IToken); AstParserRuleReturnScope<CommonTree, IToken> forInClause187 = default(AstParserRuleReturnScope<CommonTree, IToken>); AstParserRuleReturnScope<CommonTree, IToken> statement189 = default(AstParserRuleReturnScope<CommonTree, IToken>); CommonTree f_tree = default(CommonTree); CommonTree EACH185_tree = default(CommonTree); CommonTree LPAREN186_tree = default(CommonTree); CommonTree RPAREN188_tree = default(CommonTree); RewriteRuleITokenStream stream_FOR=new RewriteRuleITokenStream(adaptor,"token FOR"); RewriteRuleITokenStream stream_EACH=new RewriteRuleITokenStream(adaptor,"token EACH"); RewriteRuleITokenStream stream_LPAREN=new RewriteRuleITokenStream(adaptor,"token LPAREN"); RewriteRuleITokenStream stream_RPAREN=new RewriteRuleITokenStream(adaptor,"token RPAREN"); RewriteRuleSubtreeStream stream_forInClause=new RewriteRuleSubtreeStream(adaptor,"rule forInClause"); RewriteRuleSubtreeStream stream_statement=new RewriteRuleSubtreeStream(adaptor,"rule statement"); try { DebugEnterRule(GrammarFileName, "forEachStatement"); DebugLocation(491, 1); try { // AS3.g:492:2: (f= FOR EACH LPAREN forInClause RPAREN statement -> ^( FOR_EACH_LOOP $f forInClause statement ) ) DebugEnterAlt(1); // AS3.g:492:4: f= FOR EACH LPAREN forInClause RPAREN statement { DebugLocation(492, 5); f=(IToken)Match(input,FOR,Follow._FOR_in_forEachStatement2672); if (state.failed) return retval; if (state.backtracking == 0) stream_FOR.Add(f); DebugLocation(492, 10); EACH185=(IToken)Match(input,EACH,Follow._EACH_in_forEachStatement2674); if (state.failed) return retval; if (state.backtracking == 0) stream_EACH.Add(EACH185); DebugLocation(493, 3); LPAREN186=(IToken)Match(input,LPAREN,Follow._LPAREN_in_forEachStatement2678); if (state.failed) return retval; if (state.backtracking == 0) stream_LPAREN.Add(LPAREN186); DebugLocation(494, 3); PushFollow(Follow._forInClause_in_forEachStatement2682); forInClause187=forInClause(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) stream_forInClause.Add(forInClause187.Tree); DebugLocation(495, 3); RPAREN188=(IToken)Match(input,RPAREN,Follow._RPAREN_in_forEachStatement2686); if (state.failed) return retval; if (state.backtracking == 0) stream_RPAREN.Add(RPAREN188); DebugLocation(496, 3); PushFollow(Follow._statement_in_forEachStatement2690); statement189=statement(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) stream_statement.Add(statement189.Tree); { // AST REWRITE // elements: f, forInClause, statement // token labels: f // rule labels: retval // token list labels: // rule list labels: // wildcard labels: if (state.backtracking == 0) { retval.Tree = root_0; RewriteRuleITokenStream stream_f=new RewriteRuleITokenStream(adaptor,"token f",f); RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.Tree:null); root_0 = (CommonTree)adaptor.Nil(); // 497:3: -> ^( FOR_EACH_LOOP $f forInClause statement ) { DebugLocation(497, 6); // AS3.g:497:6: ^( FOR_EACH_LOOP $f forInClause statement ) { CommonTree root_1 = (CommonTree)adaptor.Nil(); DebugLocation(497, 8); root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(FOR_EACH_LOOP, "FOR_EACH_LOOP"), root_1); DebugLocation(497, 23); adaptor.AddChild(root_1, stream_f.NextNode()); DebugLocation(497, 25); adaptor.AddChild(root_1, stream_forInClause.NextTree()); DebugLocation(497, 37); adaptor.AddChild(root_1, stream_statement.NextTree()); adaptor.AddChild(root_0, root_1); } } retval.Tree = root_0; } } } retval.Stop = (IToken)input.LT(-1); if (state.backtracking == 0) { retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0); adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop); } } catch (RecognitionException re) { ReportError(re); Recover(input,re); retval.Tree = (CommonTree)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re); } finally { TraceOut("forEachStatement", 58); LeaveRule("forEachStatement", 58); LeaveRule_forEachStatement(); } DebugLocation(498, 1); } finally { DebugExitRule(GrammarFileName, "forEachStatement"); } return retval; }
private AstParserRuleReturnScope<CommonTree, IToken> catchBlock() { EnterRule_catchBlock(); EnterRule("catchBlock", 48); TraceIn("catchBlock", 48); AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>(); retval.Start = (IToken)input.LT(1); CommonTree root_0 = default(CommonTree); IToken string_literal160 = default(IToken); IToken LPAREN161 = default(IToken); IToken RPAREN164 = default(IToken); AstParserRuleReturnScope<CommonTree, IToken> ident162 = default(AstParserRuleReturnScope<CommonTree, IToken>); AstParserRuleReturnScope<CommonTree, IToken> typeExpression163 = default(AstParserRuleReturnScope<CommonTree, IToken>); AstParserRuleReturnScope<CommonTree, IToken> block165 = default(AstParserRuleReturnScope<CommonTree, IToken>); CommonTree string_literal160_tree = default(CommonTree); CommonTree LPAREN161_tree = default(CommonTree); CommonTree RPAREN164_tree = default(CommonTree); try { DebugEnterRule(GrammarFileName, "catchBlock"); DebugLocation(441, 1); try { // AS3.g:442:2: ( 'catch' LPAREN ident ( typeExpression )? RPAREN block ) DebugEnterAlt(1); // AS3.g:442:4: 'catch' LPAREN ident ( typeExpression )? RPAREN block { root_0 = (CommonTree)adaptor.Nil(); DebugLocation(442, 4); string_literal160=(IToken)Match(input,242,Follow._242_in_catchBlock2384); if (state.failed) return retval; if (state.backtracking == 0) { string_literal160_tree = (CommonTree)adaptor.Create(string_literal160); adaptor.AddChild(root_0, string_literal160_tree); } DebugLocation(442, 12); LPAREN161=(IToken)Match(input,LPAREN,Follow._LPAREN_in_catchBlock2386); if (state.failed) return retval; if (state.backtracking == 0) { LPAREN161_tree = (CommonTree)adaptor.Create(LPAREN161); adaptor.AddChild(root_0, LPAREN161_tree); } DebugLocation(442, 19); PushFollow(Follow._ident_in_catchBlock2388); ident162=ident(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) adaptor.AddChild(root_0, ident162.Tree); DebugLocation(442, 25); // AS3.g:442:25: ( typeExpression )? int alt38=2; try { DebugEnterSubRule(38); try { DebugEnterDecision(38, false); int LA38_1 = input.LA(1); if ((LA38_1==COLON)) { alt38 = 1; } } finally { DebugExitDecision(38); } switch (alt38) { case 1: DebugEnterAlt(1); // AS3.g:442:25: typeExpression { DebugLocation(442, 25); PushFollow(Follow._typeExpression_in_catchBlock2390); typeExpression163=typeExpression(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) adaptor.AddChild(root_0, typeExpression163.Tree); } break; } } finally { DebugExitSubRule(38); } DebugLocation(442, 41); RPAREN164=(IToken)Match(input,RPAREN,Follow._RPAREN_in_catchBlock2393); if (state.failed) return retval; if (state.backtracking == 0) { RPAREN164_tree = (CommonTree)adaptor.Create(RPAREN164); adaptor.AddChild(root_0, RPAREN164_tree); } DebugLocation(443, 3); PushFollow(Follow._block_in_catchBlock2397); block165=block(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) adaptor.AddChild(root_0, block165.Tree); } 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("catchBlock", 48); LeaveRule("catchBlock", 48); LeaveRule_catchBlock(); } DebugLocation(444, 1); } finally { DebugExitRule(GrammarFileName, "catchBlock"); } 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> finallyBlock() { EnterRule_finallyBlock(); EnterRule("finallyBlock", 49); TraceIn("finallyBlock", 49); AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>(); retval.Start = (IToken)input.LT(1); CommonTree root_0 = default(CommonTree); IToken string_literal166 = default(IToken); AstParserRuleReturnScope<CommonTree, IToken> block167 = default(AstParserRuleReturnScope<CommonTree, IToken>); CommonTree string_literal166_tree = default(CommonTree); try { DebugEnterRule(GrammarFileName, "finallyBlock"); DebugLocation(446, 1); try { // AS3.g:447:2: ( 'finally' block ) DebugEnterAlt(1); // AS3.g:447:4: 'finally' block { root_0 = (CommonTree)adaptor.Nil(); DebugLocation(447, 4); string_literal166=(IToken)Match(input,247,Follow._247_in_finallyBlock2408); if (state.failed) return retval; if (state.backtracking == 0) { string_literal166_tree = (CommonTree)adaptor.Create(string_literal166); adaptor.AddChild(root_0, string_literal166_tree); } DebugLocation(447, 14); PushFollow(Follow._block_in_finallyBlock2410); block167=block(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) adaptor.AddChild(root_0, block167.Tree); } 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("finallyBlock", 49); LeaveRule("finallyBlock", 49); LeaveRule_finallyBlock(); } DebugLocation(448, 1); } finally { DebugExitRule(GrammarFileName, "finallyBlock"); } return retval; }
private AstParserRuleReturnScope<CommonTree, IToken> forInClause() { EnterRule_forInClause(); EnterRule("forInClause", 61); TraceIn("forInClause", 61); AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>(); retval.Start = (IToken)input.LT(1); CommonTree root_0 = default(CommonTree); IToken IN204 = default(IToken); AstParserRuleReturnScope<CommonTree, IToken> forInClauseDecl203 = default(AstParserRuleReturnScope<CommonTree, IToken>); AstParserRuleReturnScope<CommonTree, IToken> forInClauseTail205 = default(AstParserRuleReturnScope<CommonTree, IToken>); CommonTree IN204_tree = default(CommonTree); try { DebugEnterRule(GrammarFileName, "forInClause"); DebugLocation(518, 1); try { // AS3.g:519:2: ( forInClauseDecl IN forInClauseTail ) DebugEnterAlt(1); // AS3.g:519:4: forInClauseDecl IN forInClauseTail { root_0 = (CommonTree)adaptor.Nil(); DebugLocation(519, 4); PushFollow(Follow._forInClauseDecl_in_forInClause2825); forInClauseDecl203=forInClauseDecl(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) adaptor.AddChild(root_0, forInClauseDecl203.Tree); DebugLocation(519, 20); IN204=(IToken)Match(input,IN,Follow._IN_in_forInClause2827); if (state.failed) return retval; if (state.backtracking == 0) { IN204_tree = (CommonTree)adaptor.Create(IN204); adaptor.AddChild(root_0, IN204_tree); } DebugLocation(519, 23); PushFollow(Follow._forInClauseTail_in_forInClause2829); forInClauseTail205=forInClauseTail(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) adaptor.AddChild(root_0, forInClauseTail205.Tree); } 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("forInClause", 61); LeaveRule("forInClause", 61); LeaveRule_forInClause(); } DebugLocation(520, 1); } finally { DebugExitRule(GrammarFileName, "forInClause"); } 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> forInClauseTail() { EnterRule_forInClauseTail(); EnterRule("forInClauseTail", 63); TraceIn("forInClauseTail", 63); AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>(); retval.Start = (IToken)input.LT(1); CommonTree root_0 = default(CommonTree); AstParserRuleReturnScope<CommonTree, IToken> expressionList210 = default(AstParserRuleReturnScope<CommonTree, IToken>); try { DebugEnterRule(GrammarFileName, "forInClauseTail"); DebugLocation(528, 1); try { // AS3.g:529:2: ( expressionList ) DebugEnterAlt(1); // AS3.g:529:4: expressionList { root_0 = (CommonTree)adaptor.Nil(); DebugLocation(529, 4); PushFollow(Follow._expressionList_in_forInClauseTail2870); expressionList210=expressionList(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) adaptor.AddChild(root_0, expressionList210.Tree); } 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("forInClauseTail", 63); LeaveRule("forInClauseTail", 63); LeaveRule_forInClauseTail(); } DebugLocation(530, 1); } finally { DebugExitRule(GrammarFileName, "forInClauseTail"); } return retval; }
private AstParserRuleReturnScope<CommonTree, IToken> as3CompilationUnit() { EnterRule_as3CompilationUnit(); EnterRule("as3CompilationUnit", 4); TraceIn("as3CompilationUnit", 4); AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>(); retval.Start = (IToken)input.LT(1); CommonTree root_0 = default(CommonTree); IToken EOF10 = default(IToken); AstParserRuleReturnScope<CommonTree, IToken> packageDecl8 = default(AstParserRuleReturnScope<CommonTree, IToken>); AstParserRuleReturnScope<CommonTree, IToken> packageBlockEntry9 = default(AstParserRuleReturnScope<CommonTree, IToken>); CommonTree EOF10_tree = default(CommonTree); try { DebugEnterRule(GrammarFileName, "as3CompilationUnit"); DebugLocation(133, 1); try { // AS3.g:134:2: ( packageDecl ( packageBlockEntry )* EOF !) DebugEnterAlt(1); // AS3.g:134:4: packageDecl ( packageBlockEntry )* EOF ! { root_0 = (CommonTree)adaptor.Nil(); DebugLocation(134, 4); PushFollow(Follow._packageDecl_in_as3CompilationUnit569); packageDecl8=packageDecl(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) adaptor.AddChild(root_0, packageDecl8.Tree); DebugLocation(135, 3); // AS3.g:135:3: ( packageBlockEntry )* try { DebugEnterSubRule(4); while (true) { int alt4=2; try { DebugEnterDecision(4, false); int LA4_1 = input.LA(1); if ((LA4_1==AS||LA4_1==BNOT||LA4_1==BREAK||LA4_1==CLASS||LA4_1==CONST||LA4_1==CONTINUE||(LA4_1>=DEC && LA4_1<=DECIMAL_LITERAL)||LA4_1==DEFAULT||LA4_1==DO||(LA4_1>=DYNAMIC && LA4_1<=E4X_ATTRI)||(LA4_1>=FALSE && LA4_1<=FOR)||LA4_1==FUNCTION||LA4_1==GET||(LA4_1>=HEX_LITERAL && LA4_1<=IDENT)||LA4_1==IF||LA4_1==IMPORT||LA4_1==INC||LA4_1==INTERFACE||(LA4_1>=INTERNAL && LA4_1<=IS)||(LA4_1>=LBRACK && LA4_1<=LCURLY)||LA4_1==LNOT||LA4_1==LPAREN||LA4_1==MINUS||LA4_1==NAMESPACE||LA4_1==NEW||LA4_1==NULL||LA4_1==OCTAL_LITERAL||LA4_1==PLUS||LA4_1==PRIVATE||(LA4_1>=PROTECTED && LA4_1<=PUBLIC)||LA4_1==REGEX_LITERAL||LA4_1==RETURN||(LA4_1>=SEMI && LA4_1<=SET)||LA4_1==STATIC||(LA4_1>=STRING_LITERAL_DOUBLE && LA4_1<=SWITCH)||LA4_1==TRUE||(LA4_1>=USE && LA4_1<=VAR)||LA4_1==WHILE||LA4_1==WITH||LA4_1==XML||LA4_1==XML_LITERAL||(LA4_1>=243 && LA4_1<=246)||LA4_1==248||LA4_1==250||(LA4_1>=252 && LA4_1<=257))) { alt4 = 1; } } finally { DebugExitDecision(4); } switch ( alt4 ) { case 1: DebugEnterAlt(1); // AS3.g:135:3: packageBlockEntry { DebugLocation(135, 3); PushFollow(Follow._packageBlockEntry_in_as3CompilationUnit573); packageBlockEntry9=packageBlockEntry(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) adaptor.AddChild(root_0, packageBlockEntry9.Tree); } break; default: goto loop4; } } loop4: ; } finally { DebugExitSubRule(4); } DebugLocation(136, 6); EOF10=(IToken)Match(input,EOF,Follow._EOF_in_as3CompilationUnit578); if (state.failed) return retval; } 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("as3CompilationUnit", 4); LeaveRule("as3CompilationUnit", 4); LeaveRule_as3CompilationUnit(); } DebugLocation(137, 1); } finally { DebugExitRule(GrammarFileName, "as3CompilationUnit"); } return retval; }
private AstParserRuleReturnScope<CommonTree, IToken> whileStatement() { EnterRule_whileStatement(); EnterRule("whileStatement", 67); TraceIn("whileStatement", 67); AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>(); retval.Start = (IToken)input.LT(1); CommonTree root_0 = default(CommonTree); IToken WHILE215 = default(IToken); AstParserRuleReturnScope<CommonTree, IToken> condition216 = default(AstParserRuleReturnScope<CommonTree, IToken>); AstParserRuleReturnScope<CommonTree, IToken> statement217 = default(AstParserRuleReturnScope<CommonTree, IToken>); CommonTree WHILE215_tree = default(CommonTree); RewriteRuleITokenStream stream_WHILE=new RewriteRuleITokenStream(adaptor,"token WHILE"); RewriteRuleSubtreeStream stream_condition=new RewriteRuleSubtreeStream(adaptor,"rule condition"); RewriteRuleSubtreeStream stream_statement=new RewriteRuleSubtreeStream(adaptor,"rule statement"); try { DebugEnterRule(GrammarFileName, "whileStatement"); DebugLocation(548, 1); try { // AS3.g:549:2: ( WHILE condition statement -> ^( WHILE_LOOP condition statement ) ) DebugEnterAlt(1); // AS3.g:549:4: WHILE condition statement { DebugLocation(549, 4); WHILE215=(IToken)Match(input,WHILE,Follow._WHILE_in_whileStatement2962); if (state.failed) return retval; if (state.backtracking == 0) stream_WHILE.Add(WHILE215); DebugLocation(549, 10); PushFollow(Follow._condition_in_whileStatement2964); condition216=condition(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) stream_condition.Add(condition216.Tree); DebugLocation(549, 20); PushFollow(Follow._statement_in_whileStatement2966); statement217=statement(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) stream_statement.Add(statement217.Tree); { // AST REWRITE // elements: condition, statement // token labels: // rule labels: retval // token list labels: // rule list labels: // wildcard labels: if (state.backtracking == 0) { retval.Tree = root_0; RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.Tree:null); root_0 = (CommonTree)adaptor.Nil(); // 550:3: -> ^( WHILE_LOOP condition statement ) { DebugLocation(550, 6); // AS3.g:550:6: ^( WHILE_LOOP condition statement ) { CommonTree root_1 = (CommonTree)adaptor.Nil(); DebugLocation(550, 8); root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(WHILE_LOOP, "WHILE_LOOP"), root_1); DebugLocation(550, 19); adaptor.AddChild(root_1, stream_condition.NextTree()); DebugLocation(550, 29); adaptor.AddChild(root_1, stream_statement.NextTree()); adaptor.AddChild(root_0, root_1); } } retval.Tree = root_0; } } } retval.Stop = (IToken)input.LT(-1); if (state.backtracking == 0) { retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0); adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop); } } catch (RecognitionException re) { ReportError(re); Recover(input,re); retval.Tree = (CommonTree)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re); } finally { TraceOut("whileStatement", 67); LeaveRule("whileStatement", 67); LeaveRule_whileStatement(); } DebugLocation(551, 1); } finally { DebugExitRule(GrammarFileName, "whileStatement"); } return retval; }
private AstParserRuleReturnScope<CommonTree, IToken> continueStatement() { EnterRule_continueStatement(); EnterRule("continueStatement", 51); TraceIn("continueStatement", 51); AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>(); retval.Start = (IToken)input.LT(1); CommonTree root_0 = default(CommonTree); IToken CONTINUE170 = default(IToken); AstParserRuleReturnScope<CommonTree, IToken> s = default(AstParserRuleReturnScope<CommonTree, IToken>); CommonTree CONTINUE170_tree = default(CommonTree); RewriteRuleITokenStream stream_CONTINUE=new RewriteRuleITokenStream(adaptor,"token CONTINUE"); RewriteRuleSubtreeStream stream_semi=new RewriteRuleSubtreeStream(adaptor,"rule semi"); try { DebugEnterRule(GrammarFileName, "continueStatement"); DebugLocation(455, 1); try { // AS3.g:456:2: ( CONTINUE s= semi -> ^( CONTINUE_STATEMENT CONTINUE ) ) DebugEnterAlt(1); // AS3.g:456:4: CONTINUE s= semi { DebugLocation(456, 4); CONTINUE170=(IToken)Match(input,CONTINUE,Follow._CONTINUE_in_continueStatement2462); if (state.failed) return retval; if (state.backtracking == 0) stream_CONTINUE.Add(CONTINUE170); DebugLocation(456, 14); PushFollow(Follow._semi_in_continueStatement2466); s=semi(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) stream_semi.Add(s.Tree); { // AST REWRITE // elements: CONTINUE // token labels: // rule labels: retval // token list labels: // rule list labels: // wildcard labels: if (state.backtracking == 0) { retval.Tree = root_0; RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.Tree:null); root_0 = (CommonTree)adaptor.Nil(); // 457:9: -> ^( CONTINUE_STATEMENT CONTINUE ) { DebugLocation(457, 12); // AS3.g:457:12: ^( CONTINUE_STATEMENT CONTINUE ) { CommonTree root_1 = (CommonTree)adaptor.Nil(); DebugLocation(457, 14); root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(CONTINUE_STATEMENT, "CONTINUE_STATEMENT"), root_1); DebugLocation(457, 33); adaptor.AddChild(root_1, stream_CONTINUE.NextNode()); DebugLocation(457, 42); adaptor.AddChild(root_1, maybeSemi(s)); adaptor.AddChild(root_0, root_1); } } retval.Tree = root_0; } } } retval.Stop = (IToken)input.LT(-1); if (state.backtracking == 0) { retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0); adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop); } } catch (RecognitionException re) { ReportError(re); Recover(input,re); retval.Tree = (CommonTree)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re); } finally { TraceOut("continueStatement", 51); LeaveRule("continueStatement", 51); LeaveRule_continueStatement(); } DebugLocation(458, 1); } finally { DebugExitRule(GrammarFileName, "continueStatement"); } return retval; }
private AstParserRuleReturnScope<CommonTree, IToken> withStatement() { EnterRule_withStatement(); EnterRule("withStatement", 69); TraceIn("withStatement", 69); AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>(); retval.Start = (IToken)input.LT(1); CommonTree root_0 = default(CommonTree); IToken WITH223 = default(IToken); AstParserRuleReturnScope<CommonTree, IToken> condition224 = default(AstParserRuleReturnScope<CommonTree, IToken>); AstParserRuleReturnScope<CommonTree, IToken> statement225 = default(AstParserRuleReturnScope<CommonTree, IToken>); CommonTree WITH223_tree = default(CommonTree); try { DebugEnterRule(GrammarFileName, "withStatement"); DebugLocation(558, 1); try { // AS3.g:559:2: ( WITH condition statement ) DebugEnterAlt(1); // AS3.g:559:4: WITH condition statement { root_0 = (CommonTree)adaptor.Nil(); DebugLocation(559, 4); WITH223=(IToken)Match(input,WITH,Follow._WITH_in_withStatement3025); if (state.failed) return retval; if (state.backtracking == 0) { WITH223_tree = (CommonTree)adaptor.Create(WITH223); adaptor.AddChild(root_0, WITH223_tree); } DebugLocation(559, 9); PushFollow(Follow._condition_in_withStatement3027); condition224=condition(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) adaptor.AddChild(root_0, condition224.Tree); DebugLocation(559, 19); PushFollow(Follow._statement_in_withStatement3029); statement225=statement(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) adaptor.AddChild(root_0, statement225.Tree); } 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("withStatement", 69); LeaveRule("withStatement", 69); LeaveRule_withStatement(); } DebugLocation(560, 1); } finally { DebugExitRule(GrammarFileName, "withStatement"); } return retval; }
private AstParserRuleReturnScope<CommonTree, IToken> breakStatement() { EnterRule_breakStatement(); EnterRule("breakStatement", 52); TraceIn("breakStatement", 52); AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>(); retval.Start = (IToken)input.LT(1); CommonTree root_0 = default(CommonTree); IToken BREAK171 = default(IToken); AstParserRuleReturnScope<CommonTree, IToken> s = default(AstParserRuleReturnScope<CommonTree, IToken>); CommonTree BREAK171_tree = default(CommonTree); RewriteRuleITokenStream stream_BREAK=new RewriteRuleITokenStream(adaptor,"token BREAK"); RewriteRuleSubtreeStream stream_semi=new RewriteRuleSubtreeStream(adaptor,"rule semi"); try { DebugEnterRule(GrammarFileName, "breakStatement"); DebugLocation(460, 1); try { // AS3.g:461:2: ( BREAK s= semi -> ^( BREAK_STATEMENT BREAK ) ) DebugEnterAlt(1); // AS3.g:461:4: BREAK s= semi { DebugLocation(461, 4); BREAK171=(IToken)Match(input,BREAK,Follow._BREAK_in_breakStatement2495); if (state.failed) return retval; if (state.backtracking == 0) stream_BREAK.Add(BREAK171); DebugLocation(461, 11); PushFollow(Follow._semi_in_breakStatement2499); s=semi(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) stream_semi.Add(s.Tree); { // AST REWRITE // elements: BREAK // token labels: // rule labels: retval // token list labels: // rule list labels: // wildcard labels: if (state.backtracking == 0) { retval.Tree = root_0; RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.Tree:null); root_0 = (CommonTree)adaptor.Nil(); // 462:9: -> ^( BREAK_STATEMENT BREAK ) { DebugLocation(462, 12); // AS3.g:462:12: ^( BREAK_STATEMENT BREAK ) { CommonTree root_1 = (CommonTree)adaptor.Nil(); DebugLocation(462, 14); root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(BREAK_STATEMENT, "BREAK_STATEMENT"), root_1); DebugLocation(462, 30); adaptor.AddChild(root_1, stream_BREAK.NextNode()); DebugLocation(462, 36); adaptor.AddChild(root_1, maybeSemi(s)); adaptor.AddChild(root_0, root_1); } } retval.Tree = root_0; } } } retval.Stop = (IToken)input.LT(-1); if (state.backtracking == 0) { retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0); adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop); } } catch (RecognitionException re) { ReportError(re); Recover(input,re); retval.Tree = (CommonTree)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re); } finally { TraceOut("breakStatement", 52); LeaveRule("breakStatement", 52); LeaveRule_breakStatement(); } DebugLocation(463, 1); } finally { DebugExitRule(GrammarFileName, "breakStatement"); } return retval; }
private AstParserRuleReturnScope<CommonTree, IToken> 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 void UpdateQuickInfoContent(IQuickInfoSession session, SnapshotPoint triggerPoint) { /* use the experimental model to locate and process the expression */ Stopwatch stopwatch = Stopwatch.StartNew(); // lex the entire document var currentSnapshot = triggerPoint.Snapshot; var input = new SnapshotCharStream(currentSnapshot, new Span(0, currentSnapshot.Length)); var unicodeInput = new JavaUnicodeStream(input); var lexer = new Java2Lexer(unicodeInput); var tokens = new CommonTokenStream(lexer); tokens.Fill(); // locate the last token before the trigger point while (true) { IToken nextToken = tokens.LT(1); if (nextToken.Type == CharStreamConstants.EndOfFile) { break; } if (nextToken.StartIndex > triggerPoint.Position) { break; } tokens.Consume(); } IToken triggerToken = tokens.LT(-1); if (triggerToken == null) { return; } switch (triggerToken.Type) { // symbol references case Java2Lexer.IDENTIFIER: case Java2Lexer.THIS: case Java2Lexer.SUPER: // primitive types case Java2Lexer.BOOLEAN: case Java2Lexer.CHAR: case Java2Lexer.BYTE: case Java2Lexer.SHORT: case Java2Lexer.INT: case Java2Lexer.LONG: case Java2Lexer.FLOAT: case Java2Lexer.DOUBLE: // literals case Java2Lexer.INTLITERAL: case Java2Lexer.LONGLITERAL: case Java2Lexer.FLOATLITERAL: case Java2Lexer.DOUBLELITERAL: case Java2Lexer.CHARLITERAL: case Java2Lexer.STRINGLITERAL: case Java2Lexer.TRUE: case Java2Lexer.FALSE: case Java2Lexer.NULL: break; default: return; } NetworkInterpreter interpreter = CreateNetworkInterpreter(tokens); while (interpreter.TryStepBackward()) { if (interpreter.Contexts.Count == 0 || interpreter.Contexts.Count > 400) { break; } if (interpreter.Contexts.All(context => context.BoundedStart)) { break; } } interpreter.Contexts.RemoveAll(i => !i.BoundedStart); interpreter.CombineBoundedStartContexts(); IOutputWindowPane pane = Provider.OutputWindowService.TryGetPane(PredefinedOutputWindowPanes.TvlIntellisense); if (pane != null) { pane.WriteLine(string.Format("Located {0} QuickInfo expression(s) in {1}ms.", interpreter.Contexts.Count, stopwatch.ElapsedMilliseconds)); } HashSet <string> intermediateResult = new HashSet <string>(); HashSet <string> finalResult = new HashSet <string>(); List <object> quickInfoContent = new List <object>(); foreach (var context in interpreter.Contexts) { Span?span = null; foreach (var transition in context.Transitions) { if (!transition.Transition.IsMatch) { continue; } IToken token = transition.Token; Span tokenSpan = new Span(token.StartIndex, token.StopIndex - token.StartIndex + 1); if (span == null) { span = tokenSpan; } else { span = Span.FromBounds(Math.Min(span.Value.Start, tokenSpan.Start), Math.Max(span.Value.End, tokenSpan.End)); } } if (span.HasValue && !span.Value.IsEmpty) { string text = currentSnapshot.GetText(span.Value); if (!intermediateResult.Add(text)) { continue; } AstParserRuleReturnScope <CommonTree, CommonToken> result = null; try { var expressionInput = new ANTLRStringStream(text); var expressionUnicodeInput = new JavaUnicodeStream(expressionInput); var expressionLexer = new Java2Lexer(expressionUnicodeInput); var expressionTokens = new CommonTokenStream(expressionLexer); var expressionParser = new Java2Parser(expressionTokens); result = expressionParser.primary(); // anchors experiment Contract.Assert(TextBuffer.CurrentSnapshot == triggerPoint.Snapshot); ClassAnchorTracker tracker = new ClassAnchorTracker(TextBuffer, null); SnapshotSpan trackedSpan = new SnapshotSpan(triggerPoint.Snapshot, 0, triggerPoint.Position); ITagSpan <ScopeAnchorTag>[] tags = tracker.GetTags(new NormalizedSnapshotSpanCollection(trackedSpan)).ToArray(); text = result.Tree.ToStringTree(); } catch (RecognitionException) { text = "Could not parse: " + text; } text = text.Replace("\n", "\\n").Replace("\r", "\\r"); finalResult.Add(text); //if (Regex.IsMatch(text, @"^[A-Za-z_]+(?:\.\w+)*$")) //{ // NameResolutionContext resolutionContext = NameResolutionContext.Global(Provider.IntelliSenseCache); // resolutionContext = resolutionContext.Filter(text, null, true); // CodeElement[] matching = resolutionContext.GetMatchingElements(); // if (matching.Length > 0) // { // foreach (var element in matching) // { // element.AugmentQuickInfoSession(quickInfoContent); // } // } // else // { // // check if this is a package // CodePhysicalFile[] files = Provider.IntelliSenseCache.GetPackageFiles(text, true); // if (files.Length > 0) // { // finalResult.Add(string.Format("package {0}", text)); // } // else // { // // check if this is a type // string typeName = text.Substring(text.LastIndexOf('.') + 1); // CodeType[] types = Provider.IntelliSenseCache.GetTypes(typeName, true); // foreach (var type in types) // { // if (type.FullName == text) // finalResult.Add(string.Format("{0}: {1}", type.GetType().Name, type.FullName)); // } // } // } //} //else //{ // finalResult.Add(text); //} } } ITrackingSpan applicableToSpan = null; foreach (var result in finalResult) { quickInfoContent.Add(result); } applicableToSpan = currentSnapshot.CreateTrackingSpan(new Span(triggerToken.StartIndex, triggerToken.StopIndex - triggerToken.StartIndex + 1), SpanTrackingMode.EdgeExclusive); //try //{ // Expression currentExpression = Provider.IntellisenseCache.ParseExpression(selection); // if (currentExpression != null) // { // SnapshotSpan? span = currentExpression.Span; // if (span.HasValue) // applicableToSpan = span.Value.Snapshot.CreateTrackingSpan(span.Value, SpanTrackingMode.EdgeExclusive); // quickInfoContent.Add(currentExpression.ToString()); // } // else // { // quickInfoContent.Add("Could not parse expression."); // } //} //catch (Exception ex) //{ // if (ErrorHandler.IsCriticalException(ex)) // throw; // quickInfoContent.Add(ex.Message); //} lock (_contentUpdateLock) { _triggerPoint = triggerPoint; _applicableToSpan = applicableToSpan; _quickInfoContent = quickInfoContent; } IWpfTextView wpfTextView = session.TextView as IWpfTextView; if (wpfTextView != null && wpfTextView.VisualElement != null) { ITrackingPoint trackingTriggerPoint = triggerPoint.Snapshot.CreateTrackingPoint(triggerPoint.Position, PointTrackingMode.Negative); wpfTextView.VisualElement.Dispatcher.BeginInvoke((Action <IQuickInfoSession, ITrackingPoint, bool>)RetriggerQuickInfo, session, trackingTriggerPoint, true); } }