//------------------------------------------------------------------------------ // // This code was generated by a tool. // ANTLR Version: 3.4 // // Changes to this file may cause incorrect behavior and will be lost if // the code is regenerated. // //------------------------------------------------------------------------------ // $ANTLR 3.4 D:\\~Compilador\\!yatc\\Grammar\\tiger.g 2014-03-10 18:42:49 // The variable 'variable' is assigned but its value is never used. #pragma warning disable 219 // Unreachable code detected. #pragma warning disable 162 // Missing XML comment for publicly visible type or member 'Type_or_Member' #pragma warning disable 1591 // CLS compliance checking will not be performed on 'type' because it is not visible from outside this assembly. #pragma warning disable 3019 using System; using System.Collections.Generic; using Antlr.Runtime; using Antlr.Runtime.Misc; using Antlr.Runtime.Tree; using RewriteRuleITokenStream = Antlr.Runtime.Tree.RewriteRuleTokenStream; namespace YATC.Grammar { [System.CodeDom.Compiler.GeneratedCode("ANTLR", "3.4")] [System.CLSCompliant(false)] public partial class tigerParser : Antlr.Runtime.Parser { internal static readonly string[] tokenNames = new string[] { "", "", "", "", "ALIAS_DECL", "AND", "ARGS_FIELDS", "ARRAYKEY", "ARRAY_ACCESS", "ARRAY_DECL", "ARRAY_INST", "ASCII_ESC", "ASSIGN", "BEGIN_COMMENT", "BREAK", "BREAKKEY", "COLON", "COMMA", "COMMENTARY", "DECL_BLOCK", "DIGIT", "DIV", "DOKEY", "DOT", "ELSEKEY", "ENDKEY", "END_COMMENT", "EQ", "ESC_SEQ", "EXPR_SEQ", "FIELDS_INST", "FIELD_ACCESS", "FIELD_ACCESS_TERMINAL", "FIELD_INST", "FILL_IN_TYPE", "FOR", "FORKEY", "FUNCTIONKEY", "FUN_CALL", "FUN_DECL", "FUN_DECL_SEQ", "FUN_TYPE_WRAPPER", "GT", "GTEQ", "ID", "IF", "IFKEY", "INKEY", "INT", "INTKEY", "LBRACKET", "LET", "LETKEY", "LETTER", "LKEY", "LPAREN", "LT", "LTEQ", "MINUS", "MULT", "NEG", "NIL", "NILKEY", "NOTEQ", "OFKEY", "OR", "PARAM_DECL", "PLUS", "PRINTABLE_CHARACTER", "PROGRAM", "QUOTE", "RBRACKET", "RECORD_DECL", "RECORD_INST", "RKEY", "RPAREN", "SEMI", "STRING", "STRINGKEY", "THENKEY", "TOKEY", "TYPE", "TYPEKEY", "TYPE_DECL", "TYPE_DECL_SEQ", "TYPE_FIELD", "VARKEY", "VAR_ACCESS", "VAR_DECL", "WHILE", "WHILEKEY", "WS" }; public const int EOF=-1; public const int ALIAS_DECL=4; public const int AND=5; public const int ARGS_FIELDS=6; public const int ARRAYKEY=7; public const int ARRAY_ACCESS=8; public const int ARRAY_DECL=9; public const int ARRAY_INST=10; public const int ASCII_ESC=11; public const int ASSIGN=12; public const int BEGIN_COMMENT=13; public const int BREAK=14; public const int BREAKKEY=15; public const int COLON=16; public const int COMMA=17; public const int COMMENTARY=18; public const int DECL_BLOCK=19; public const int DIGIT=20; public const int DIV=21; public const int DOKEY=22; public const int DOT=23; public const int ELSEKEY=24; public const int ENDKEY=25; public const int END_COMMENT=26; public const int EQ=27; public const int ESC_SEQ=28; public const int EXPR_SEQ=29; public const int FIELDS_INST=30; public const int FIELD_ACCESS=31; public const int FIELD_ACCESS_TERMINAL=32; public const int FIELD_INST=33; public const int FILL_IN_TYPE=34; public const int FOR=35; public const int FORKEY=36; public const int FUNCTIONKEY=37; public const int FUN_CALL=38; public const int FUN_DECL=39; public const int FUN_DECL_SEQ=40; public const int FUN_TYPE_WRAPPER=41; public const int GT=42; public const int GTEQ=43; public const int ID=44; public const int IF=45; public const int IFKEY=46; public const int INKEY=47; public const int INT=48; public const int INTKEY=49; public const int LBRACKET=50; public const int LET=51; public const int LETKEY=52; public const int LETTER=53; public const int LKEY=54; public const int LPAREN=55; public const int LT=56; public const int LTEQ=57; public const int MINUS=58; public const int MULT=59; public const int NEG=60; public const int NIL=61; public const int NILKEY=62; public const int NOTEQ=63; public const int OFKEY=64; public const int OR=65; public const int PARAM_DECL=66; public const int PLUS=67; public const int PRINTABLE_CHARACTER=68; public const int PROGRAM=69; public const int QUOTE=70; public const int RBRACKET=71; public const int RECORD_DECL=72; public const int RECORD_INST=73; public const int RKEY=74; public const int RPAREN=75; public const int SEMI=76; public const int STRING=77; public const int STRINGKEY=78; public const int THENKEY=79; public const int TOKEY=80; public const int TYPE=81; public const int TYPEKEY=82; public const int TYPE_DECL=83; public const int TYPE_DECL_SEQ=84; public const int TYPE_FIELD=85; public const int VARKEY=86; public const int VAR_ACCESS=87; public const int VAR_DECL=88; public const int WHILE=89; public const int WHILEKEY=90; public const int WS=91; public tigerParser(ITokenStream input) : this(input, new RecognizerSharedState()) { } public tigerParser(ITokenStream input, RecognizerSharedState state) : base(input, state) { ITreeAdaptor treeAdaptor = default(ITreeAdaptor); CreateTreeAdaptor(ref treeAdaptor); TreeAdaptor = treeAdaptor ?? new CommonTreeAdaptor(); OnCreated(); } // Implement this function in your helper file to use a custom tree adaptor partial void CreateTreeAdaptor(ref ITreeAdaptor adaptor); private ITreeAdaptor adaptor; public ITreeAdaptor TreeAdaptor { get { return adaptor; } set { this.adaptor = value; } } public override string[] TokenNames { get { return tigerParser.tokenNames; } } public override string GrammarFileName { get { return "D:\\~Compilador\\!yatc\\Grammar\\tiger.g"; } } public override void ReportError(RecognitionException exc) { /* Abort on first error. */ throw new ParsingException(GetErrorMessage(exc, TokenNames), exc); } partial void OnCreated(); partial void EnterRule(string ruleName, int ruleIndex); partial void LeaveRule(string ruleName, int ruleIndex); #region Rules partial void EnterRule_a_program(); partial void LeaveRule_a_program(); // $ANTLR start "a_program" // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:218:8: public a_program : ( expr )? EOF -> ^( PROGRAM ( expr )? ) ; [GrammarRule("a_program")] public AstParserRuleReturnScope a_program() { EnterRule_a_program(); EnterRule("a_program", 1); TraceIn("a_program", 1); AstParserRuleReturnScope retval = new AstParserRuleReturnScope(); retval.Start = (IToken)input.LT(1); object root_0 = default(object); IToken EOF2 = default(IToken); AstParserRuleReturnScope expr1 = default(AstParserRuleReturnScope); object EOF2_tree = default(object); RewriteRuleITokenStream stream_EOF=new RewriteRuleITokenStream(adaptor,"token EOF"); RewriteRuleSubtreeStream stream_expr=new RewriteRuleSubtreeStream(adaptor,"rule expr"); try { DebugEnterRule(GrammarFileName, "a_program"); DebugLocation(218, 23); try { // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:219:2: ( ( expr )? EOF -> ^( PROGRAM ( expr )? ) ) DebugEnterAlt(1); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:219:4: ( expr )? EOF { DebugLocation(219, 4); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:219:4: ( expr )? int alt1=2; try { DebugEnterSubRule(1); try { DebugEnterDecision(1, false); int LA1_0 = input.LA(1); if ((LA1_0==BREAKKEY||LA1_0==FORKEY||LA1_0==ID||LA1_0==IFKEY||(LA1_0>=INT && LA1_0<=INTKEY)||LA1_0==LETKEY||LA1_0==LPAREN||LA1_0==MINUS||LA1_0==NILKEY||(LA1_0>=STRING && LA1_0<=STRINGKEY)||LA1_0==WHILEKEY)) { alt1 = 1; } } finally { DebugExitDecision(1); } switch (alt1) { case 1: DebugEnterAlt(1); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:219:4: expr { DebugLocation(219, 4); PushFollow(Follow._expr_in_a_program1145); expr1=expr(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) stream_expr.Add(expr1.Tree); } break; } } finally { DebugExitSubRule(1); } DebugLocation(219, 11); EOF2=(IToken)Match(input,EOF,Follow._EOF_in_a_program1149); if (state.failed) return retval; if (state.backtracking == 0) stream_EOF.Add(EOF2); { // AST REWRITE // elements: expr // 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 = (object)adaptor.Nil(); // 220:3: -> ^( PROGRAM ( expr )? ) { DebugLocation(220, 6); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:220:6: ^( PROGRAM ( expr )? ) { object root_1 = (object)adaptor.Nil(); DebugLocation(220, 8); root_1 = (object)adaptor.BecomeRoot((object)adaptor.Create(PROGRAM, "PROGRAM"), root_1); DebugLocation(220, 16); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:220:16: ( expr )? if (stream_expr.HasNext) { DebugLocation(220, 16); adaptor.AddChild(root_1, stream_expr.NextTree()); } stream_expr.Reset(); adaptor.AddChild(root_0, root_1); } } retval.Tree = root_0; } } } retval.Stop = (IToken)input.LT(-1); if (state.backtracking == 0) { 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("a_program", 1); LeaveRule("a_program", 1); LeaveRule_a_program(); } DebugLocation(220, 23); } finally { DebugExitRule(GrammarFileName, "a_program"); } return retval; } // $ANTLR end "a_program" partial void EnterRule_expr(); partial void LeaveRule_expr(); // $ANTLR start "expr" // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:222:1: expr : ( ( ID LBRACKET disjunction_expr RBRACKET OFKEY )=> array_inst | ( lvalue ASSIGN )=> assignment | disjunction_expr | record_inst | while_stat | BREAKKEY -> BREAK ); [GrammarRule("expr")] private AstParserRuleReturnScope expr() { EnterRule_expr(); EnterRule("expr", 2); TraceIn("expr", 2); AstParserRuleReturnScope retval = new AstParserRuleReturnScope(); retval.Start = (IToken)input.LT(1); object root_0 = default(object); IToken BREAKKEY8 = default(IToken); AstParserRuleReturnScope array_inst3 = default(AstParserRuleReturnScope); AstParserRuleReturnScope assignment4 = default(AstParserRuleReturnScope); AstParserRuleReturnScope disjunction_expr5 = default(AstParserRuleReturnScope); AstParserRuleReturnScope record_inst6 = default(AstParserRuleReturnScope); AstParserRuleReturnScope while_stat7 = default(AstParserRuleReturnScope); object BREAKKEY8_tree = default(object); RewriteRuleITokenStream stream_BREAKKEY=new RewriteRuleITokenStream(adaptor,"token BREAKKEY"); try { DebugEnterRule(GrammarFileName, "expr"); DebugLocation(222, 1); try { // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:223:2: ( ( ID LBRACKET disjunction_expr RBRACKET OFKEY )=> array_inst | ( lvalue ASSIGN )=> assignment | disjunction_expr | record_inst | while_stat | BREAKKEY -> BREAK ) int alt2=6; try { DebugEnterDecision(2, false); try { alt2 = dfa2.Predict(input); } catch (NoViableAltException nvae) { DebugRecognitionException(nvae); throw; } } finally { DebugExitDecision(2); } switch (alt2) { case 1: DebugEnterAlt(1); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:223:4: ( ID LBRACKET disjunction_expr RBRACKET OFKEY )=> array_inst { root_0 = (object)adaptor.Nil(); DebugLocation(223, 53); PushFollow(Follow._array_inst_in_expr1185); array_inst3=array_inst(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) adaptor.AddChild(root_0, array_inst3.Tree); } break; case 2: DebugEnterAlt(2); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:224:4: ( lvalue ASSIGN )=> assignment { root_0 = (object)adaptor.Nil(); DebugLocation(224, 23); PushFollow(Follow._assignment_in_expr1198); assignment4=assignment(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) adaptor.AddChild(root_0, assignment4.Tree); } break; case 3: DebugEnterAlt(3); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:225:4: disjunction_expr { root_0 = (object)adaptor.Nil(); DebugLocation(225, 4); PushFollow(Follow._disjunction_expr_in_expr1203); disjunction_expr5=disjunction_expr(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) adaptor.AddChild(root_0, disjunction_expr5.Tree); } break; case 4: DebugEnterAlt(4); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:226:4: record_inst { root_0 = (object)adaptor.Nil(); DebugLocation(226, 4); PushFollow(Follow._record_inst_in_expr1209); record_inst6=record_inst(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) adaptor.AddChild(root_0, record_inst6.Tree); } break; case 5: DebugEnterAlt(5); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:227:4: while_stat { root_0 = (object)adaptor.Nil(); DebugLocation(227, 4); PushFollow(Follow._while_stat_in_expr1214); while_stat7=while_stat(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) adaptor.AddChild(root_0, while_stat7.Tree); } break; case 6: DebugEnterAlt(6); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:228:4: BREAKKEY { DebugLocation(228, 4); BREAKKEY8=(IToken)Match(input,BREAKKEY,Follow._BREAKKEY_in_expr1219); if (state.failed) return retval; if (state.backtracking == 0) stream_BREAKKEY.Add(BREAKKEY8); { // AST REWRITE // elements: // 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 = (object)adaptor.Nil(); // 229:13: -> BREAK { DebugLocation(229, 16); adaptor.AddChild(root_0, (object)adaptor.Create(BREAK, "BREAK")); } retval.Tree = root_0; } } } break; } retval.Stop = (IToken)input.LT(-1); if (state.backtracking == 0) { 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("expr", 2); LeaveRule("expr", 2); LeaveRule_expr(); } DebugLocation(230, 1); } finally { DebugExitRule(GrammarFileName, "expr"); } return retval; } // $ANTLR end "expr" partial void EnterRule_disjunction_expr(); partial void LeaveRule_disjunction_expr(); // $ANTLR start "disjunction_expr" // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:232:1: disjunction_expr : conjunction_expr ( OR ^ conjunction_expr )* ; [GrammarRule("disjunction_expr")] private AstParserRuleReturnScope disjunction_expr() { EnterRule_disjunction_expr(); EnterRule("disjunction_expr", 3); TraceIn("disjunction_expr", 3); AstParserRuleReturnScope retval = new AstParserRuleReturnScope(); retval.Start = (IToken)input.LT(1); object root_0 = default(object); IToken OR10 = default(IToken); AstParserRuleReturnScope conjunction_expr9 = default(AstParserRuleReturnScope); AstParserRuleReturnScope conjunction_expr11 = default(AstParserRuleReturnScope); object OR10_tree = default(object); try { DebugEnterRule(GrammarFileName, "disjunction_expr"); DebugLocation(232, 1); try { // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:233:2: ( conjunction_expr ( OR ^ conjunction_expr )* ) DebugEnterAlt(1); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:233:4: conjunction_expr ( OR ^ conjunction_expr )* { root_0 = (object)adaptor.Nil(); DebugLocation(233, 4); PushFollow(Follow._conjunction_expr_in_disjunction_expr1248); conjunction_expr9=conjunction_expr(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) adaptor.AddChild(root_0, conjunction_expr9.Tree); DebugLocation(233, 21); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:233:21: ( OR ^ conjunction_expr )* try { DebugEnterSubRule(3); while (true) { int alt3=2; try { DebugEnterDecision(3, false); int LA3_0 = input.LA(1); if ((LA3_0==OR)) { alt3 = 1; } } finally { DebugExitDecision(3); } switch ( alt3 ) { case 1: DebugEnterAlt(1); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:233:22: OR ^ conjunction_expr { DebugLocation(233, 24); OR10=(IToken)Match(input,OR,Follow._OR_in_disjunction_expr1251); if (state.failed) return retval; if (state.backtracking == 0) { OR10_tree = (object)adaptor.Create(OR10); root_0 = (object)adaptor.BecomeRoot(OR10_tree, root_0); } DebugLocation(233, 26); PushFollow(Follow._conjunction_expr_in_disjunction_expr1254); conjunction_expr11=conjunction_expr(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) adaptor.AddChild(root_0, conjunction_expr11.Tree); } break; default: goto loop3; } } loop3: ; } finally { DebugExitSubRule(3); } } retval.Stop = (IToken)input.LT(-1); if (state.backtracking == 0) { 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("disjunction_expr", 3); LeaveRule("disjunction_expr", 3); LeaveRule_disjunction_expr(); } DebugLocation(234, 1); } finally { DebugExitRule(GrammarFileName, "disjunction_expr"); } return retval; } // $ANTLR end "disjunction_expr" partial void EnterRule_assignment(); partial void LeaveRule_assignment(); // $ANTLR start "assignment" // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:236:1: assignment : lvalue ASSIGN ^ ( ( ID LBRACKET disjunction_expr RBRACKET OFKEY )=> array_inst | disjunction_expr | record_inst ) ; [GrammarRule("assignment")] private AstParserRuleReturnScope assignment() { EnterRule_assignment(); EnterRule("assignment", 4); TraceIn("assignment", 4); AstParserRuleReturnScope retval = new AstParserRuleReturnScope(); retval.Start = (IToken)input.LT(1); object root_0 = default(object); IToken ASSIGN13 = default(IToken); AstParserRuleReturnScope lvalue12 = default(AstParserRuleReturnScope); AstParserRuleReturnScope array_inst14 = default(AstParserRuleReturnScope); AstParserRuleReturnScope disjunction_expr15 = default(AstParserRuleReturnScope); AstParserRuleReturnScope record_inst16 = default(AstParserRuleReturnScope); object ASSIGN13_tree = default(object); try { DebugEnterRule(GrammarFileName, "assignment"); DebugLocation(236, 1); try { // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:237:2: ( lvalue ASSIGN ^ ( ( ID LBRACKET disjunction_expr RBRACKET OFKEY )=> array_inst | disjunction_expr | record_inst ) ) DebugEnterAlt(1); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:237:4: lvalue ASSIGN ^ ( ( ID LBRACKET disjunction_expr RBRACKET OFKEY )=> array_inst | disjunction_expr | record_inst ) { root_0 = (object)adaptor.Nil(); DebugLocation(237, 4); PushFollow(Follow._lvalue_in_assignment1267); lvalue12=lvalue(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) adaptor.AddChild(root_0, lvalue12.Tree); DebugLocation(237, 17); ASSIGN13=(IToken)Match(input,ASSIGN,Follow._ASSIGN_in_assignment1269); if (state.failed) return retval; if (state.backtracking == 0) { ASSIGN13_tree = (object)adaptor.Create(ASSIGN13); root_0 = (object)adaptor.BecomeRoot(ASSIGN13_tree, root_0); } DebugLocation(238, 4); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:238:4: ( ( ID LBRACKET disjunction_expr RBRACKET OFKEY )=> array_inst | disjunction_expr | record_inst ) int alt4=3; try { DebugEnterSubRule(4); try { DebugEnterDecision(4, false); int LA4_0 = input.LA(1); if ((LA4_0==ID)) { switch (input.LA(2)) { case LBRACKET: { switch (input.LA(3)) { case MINUS: { int LA4_33 = input.LA(4); if ((EvaluatePredicate(synpred3_tiger_fragment))) { alt4 = 1; } else if ((true)) { alt4 = 2; } else { if (state.backtracking>0) {state.failed=true; return retval;} NoViableAltException nvae = new NoViableAltException("", 4, 33, input); DebugRecognitionException(nvae); throw nvae; } } break; case INT: case NILKEY: case STRING: { int LA4_34 = input.LA(4); if ((EvaluatePredicate(synpred3_tiger_fragment))) { alt4 = 1; } else if ((true)) { alt4 = 2; } else { if (state.backtracking>0) {state.failed=true; return retval;} NoViableAltException nvae = new NoViableAltException("", 4, 34, input); DebugRecognitionException(nvae); throw nvae; } } break; case ID: case INTKEY: case STRINGKEY: { int LA4_35 = input.LA(4); if ((EvaluatePredicate(synpred3_tiger_fragment))) { alt4 = 1; } else if ((true)) { alt4 = 2; } else { if (state.backtracking>0) {state.failed=true; return retval;} NoViableAltException nvae = new NoViableAltException("", 4, 35, input); DebugRecognitionException(nvae); throw nvae; } } break; case IFKEY: { int LA4_36 = input.LA(4); if ((EvaluatePredicate(synpred3_tiger_fragment))) { alt4 = 1; } else if ((true)) { alt4 = 2; } else { if (state.backtracking>0) {state.failed=true; return retval;} NoViableAltException nvae = new NoViableAltException("", 4, 36, input); DebugRecognitionException(nvae); throw nvae; } } break; case FORKEY: { int LA4_37 = input.LA(4); if ((EvaluatePredicate(synpred3_tiger_fragment))) { alt4 = 1; } else if ((true)) { alt4 = 2; } else { if (state.backtracking>0) {state.failed=true; return retval;} NoViableAltException nvae = new NoViableAltException("", 4, 37, input); DebugRecognitionException(nvae); throw nvae; } } break; case LETKEY: { int LA4_38 = input.LA(4); if ((EvaluatePredicate(synpred3_tiger_fragment))) { alt4 = 1; } else if ((true)) { alt4 = 2; } else { if (state.backtracking>0) {state.failed=true; return retval;} NoViableAltException nvae = new NoViableAltException("", 4, 38, input); DebugRecognitionException(nvae); throw nvae; } } break; case LPAREN: { int LA4_39 = input.LA(4); if ((EvaluatePredicate(synpred3_tiger_fragment))) { alt4 = 1; } else if ((true)) { alt4 = 2; } else { if (state.backtracking>0) {state.failed=true; return retval;} NoViableAltException nvae = new NoViableAltException("", 4, 39, input); DebugRecognitionException(nvae); throw nvae; } } break; default: { if (state.backtracking>0) {state.failed=true; return retval;} NoViableAltException nvae = new NoViableAltException("", 4, 9, input); DebugRecognitionException(nvae); throw nvae; } } } break; case LKEY: { alt4 = 3; } break; case EOF: case AND: case COMMA: case DIV: case DOKEY: case DOT: case ELSEKEY: case ENDKEY: case EQ: case FUNCTIONKEY: case GT: case GTEQ: case INKEY: case LPAREN: case LT: case LTEQ: case MINUS: case MULT: case NOTEQ: case OR: case PLUS: case RBRACKET: case RKEY: case RPAREN: case SEMI: case THENKEY: case TOKEY: case TYPEKEY: case VARKEY: { alt4 = 2; } break; default: { if (state.backtracking>0) {state.failed=true; return retval;} NoViableAltException nvae = new NoViableAltException("", 4, 1, input); DebugRecognitionException(nvae); throw nvae; } } } else if ((LA4_0==FORKEY||LA4_0==IFKEY||(LA4_0>=INT && LA4_0<=INTKEY)||LA4_0==LETKEY||LA4_0==LPAREN||LA4_0==MINUS||LA4_0==NILKEY||(LA4_0>=STRING && LA4_0<=STRINGKEY))) { alt4 = 2; } else { if (state.backtracking>0) {state.failed=true; return retval;} NoViableAltException nvae = new NoViableAltException("", 4, 0, input); DebugRecognitionException(nvae); throw nvae; } } finally { DebugExitDecision(4); } switch (alt4) { case 1: DebugEnterAlt(1); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:238:6: ( ID LBRACKET disjunction_expr RBRACKET OFKEY )=> array_inst { DebugLocation(238, 55); PushFollow(Follow._array_inst_in_assignment1292); array_inst14=array_inst(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) adaptor.AddChild(root_0, array_inst14.Tree); } break; case 2: DebugEnterAlt(2); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:239:6: disjunction_expr { DebugLocation(239, 6); PushFollow(Follow._disjunction_expr_in_assignment1300); disjunction_expr15=disjunction_expr(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) adaptor.AddChild(root_0, disjunction_expr15.Tree); } break; case 3: DebugEnterAlt(3); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:240:6: record_inst { DebugLocation(240, 6); PushFollow(Follow._record_inst_in_assignment1308); record_inst16=record_inst(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) adaptor.AddChild(root_0, record_inst16.Tree); } break; } } finally { DebugExitSubRule(4); } } retval.Stop = (IToken)input.LT(-1); if (state.backtracking == 0) { 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("assignment", 4); LeaveRule("assignment", 4); LeaveRule_assignment(); } DebugLocation(242, 1); } finally { DebugExitRule(GrammarFileName, "assignment"); } return retval; } // $ANTLR end "assignment" partial void EnterRule_record_inst(); partial void LeaveRule_record_inst(); // $ANTLR start "record_inst" // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:244:1: record_inst : ID LKEY ( field_inst_list )? RKEY -> ^( RECORD_INST ID ( field_inst_list )? ) ; [GrammarRule("record_inst")] private AstParserRuleReturnScope record_inst() { EnterRule_record_inst(); EnterRule("record_inst", 5); TraceIn("record_inst", 5); AstParserRuleReturnScope retval = new AstParserRuleReturnScope(); retval.Start = (IToken)input.LT(1); object root_0 = default(object); IToken ID17 = default(IToken); IToken LKEY18 = default(IToken); IToken RKEY20 = default(IToken); AstParserRuleReturnScope field_inst_list19 = default(AstParserRuleReturnScope); object ID17_tree = default(object); object LKEY18_tree = default(object); object RKEY20_tree = default(object); RewriteRuleITokenStream stream_LKEY=new RewriteRuleITokenStream(adaptor,"token LKEY"); RewriteRuleITokenStream stream_ID=new RewriteRuleITokenStream(adaptor,"token ID"); RewriteRuleITokenStream stream_RKEY=new RewriteRuleITokenStream(adaptor,"token RKEY"); RewriteRuleSubtreeStream stream_field_inst_list=new RewriteRuleSubtreeStream(adaptor,"rule field_inst_list"); try { DebugEnterRule(GrammarFileName, "record_inst"); DebugLocation(244, 1); try { // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:245:2: ( ID LKEY ( field_inst_list )? RKEY -> ^( RECORD_INST ID ( field_inst_list )? ) ) DebugEnterAlt(1); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:245:4: ID LKEY ( field_inst_list )? RKEY { DebugLocation(245, 4); ID17=(IToken)Match(input,ID,Follow._ID_in_record_inst1325); if (state.failed) return retval; if (state.backtracking == 0) stream_ID.Add(ID17); DebugLocation(245, 7); LKEY18=(IToken)Match(input,LKEY,Follow._LKEY_in_record_inst1327); if (state.failed) return retval; if (state.backtracking == 0) stream_LKEY.Add(LKEY18); DebugLocation(245, 12); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:245:12: ( field_inst_list )? int alt5=2; try { DebugEnterSubRule(5); try { DebugEnterDecision(5, false); int LA5_0 = input.LA(1); if ((LA5_0==ID)) { alt5 = 1; } } finally { DebugExitDecision(5); } switch (alt5) { case 1: DebugEnterAlt(1); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:245:12: field_inst_list { DebugLocation(245, 12); PushFollow(Follow._field_inst_list_in_record_inst1329); field_inst_list19=field_inst_list(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) stream_field_inst_list.Add(field_inst_list19.Tree); } break; } } finally { DebugExitSubRule(5); } DebugLocation(245, 29); RKEY20=(IToken)Match(input,RKEY,Follow._RKEY_in_record_inst1332); if (state.failed) return retval; if (state.backtracking == 0) stream_RKEY.Add(RKEY20); { // AST REWRITE // elements: ID, field_inst_list // 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 = (object)adaptor.Nil(); // 246:4: -> ^( RECORD_INST ID ( field_inst_list )? ) { DebugLocation(246, 7); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:246:7: ^( RECORD_INST ID ( field_inst_list )? ) { object root_1 = (object)adaptor.Nil(); DebugLocation(246, 9); root_1 = (object)adaptor.BecomeRoot((object)adaptor.Create(RECORD_INST, "RECORD_INST"), root_1); DebugLocation(246, 21); adaptor.AddChild(root_1, stream_ID.NextNode()); DebugLocation(246, 24); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:246:24: ( field_inst_list )? if (stream_field_inst_list.HasNext) { DebugLocation(246, 24); adaptor.AddChild(root_1, stream_field_inst_list.NextTree()); } stream_field_inst_list.Reset(); adaptor.AddChild(root_0, root_1); } } retval.Tree = root_0; } } } retval.Stop = (IToken)input.LT(-1); if (state.backtracking == 0) { 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("record_inst", 5); LeaveRule("record_inst", 5); LeaveRule_record_inst(); } DebugLocation(247, 1); } finally { DebugExitRule(GrammarFileName, "record_inst"); } return retval; } // $ANTLR end "record_inst" partial void EnterRule_for_expr(); partial void LeaveRule_for_expr(); // $ANTLR start "for_expr" // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:254:1: for_expr : FORKEY type_id ASSIGN disjunction_expr TOKEY disjunction_expr DOKEY expr -> ^( FOR type_id disjunction_expr disjunction_expr expr ) ; [GrammarRule("for_expr")] private AstParserRuleReturnScope for_expr() { EnterRule_for_expr(); EnterRule("for_expr", 6); TraceIn("for_expr", 6); AstParserRuleReturnScope retval = new AstParserRuleReturnScope(); retval.Start = (IToken)input.LT(1); object root_0 = default(object); IToken FORKEY21 = default(IToken); IToken ASSIGN23 = default(IToken); IToken TOKEY25 = default(IToken); IToken DOKEY27 = default(IToken); AstParserRuleReturnScope type_id22 = default(AstParserRuleReturnScope); AstParserRuleReturnScope disjunction_expr24 = default(AstParserRuleReturnScope); AstParserRuleReturnScope disjunction_expr26 = default(AstParserRuleReturnScope); AstParserRuleReturnScope expr28 = default(AstParserRuleReturnScope); object FORKEY21_tree = default(object); object ASSIGN23_tree = default(object); object TOKEY25_tree = default(object); object DOKEY27_tree = default(object); RewriteRuleITokenStream stream_TOKEY=new RewriteRuleITokenStream(adaptor,"token TOKEY"); RewriteRuleITokenStream stream_FORKEY=new RewriteRuleITokenStream(adaptor,"token FORKEY"); RewriteRuleITokenStream stream_DOKEY=new RewriteRuleITokenStream(adaptor,"token DOKEY"); RewriteRuleITokenStream stream_ASSIGN=new RewriteRuleITokenStream(adaptor,"token ASSIGN"); RewriteRuleSubtreeStream stream_type_id=new RewriteRuleSubtreeStream(adaptor,"rule type_id"); RewriteRuleSubtreeStream stream_disjunction_expr=new RewriteRuleSubtreeStream(adaptor,"rule disjunction_expr"); RewriteRuleSubtreeStream stream_expr=new RewriteRuleSubtreeStream(adaptor,"rule expr"); try { DebugEnterRule(GrammarFileName, "for_expr"); DebugLocation(254, 1); try { // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:255:2: ( FORKEY type_id ASSIGN disjunction_expr TOKEY disjunction_expr DOKEY expr -> ^( FOR type_id disjunction_expr disjunction_expr expr ) ) DebugEnterAlt(1); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:255:4: FORKEY type_id ASSIGN disjunction_expr TOKEY disjunction_expr DOKEY expr { DebugLocation(255, 4); FORKEY21=(IToken)Match(input,FORKEY,Follow._FORKEY_in_for_expr1359); if (state.failed) return retval; if (state.backtracking == 0) stream_FORKEY.Add(FORKEY21); DebugLocation(255, 11); PushFollow(Follow._type_id_in_for_expr1361); type_id22=type_id(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) stream_type_id.Add(type_id22.Tree); DebugLocation(255, 19); ASSIGN23=(IToken)Match(input,ASSIGN,Follow._ASSIGN_in_for_expr1363); if (state.failed) return retval; if (state.backtracking == 0) stream_ASSIGN.Add(ASSIGN23); DebugLocation(255, 26); PushFollow(Follow._disjunction_expr_in_for_expr1365); disjunction_expr24=disjunction_expr(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) stream_disjunction_expr.Add(disjunction_expr24.Tree); DebugLocation(255, 43); TOKEY25=(IToken)Match(input,TOKEY,Follow._TOKEY_in_for_expr1367); if (state.failed) return retval; if (state.backtracking == 0) stream_TOKEY.Add(TOKEY25); DebugLocation(255, 49); PushFollow(Follow._disjunction_expr_in_for_expr1369); disjunction_expr26=disjunction_expr(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) stream_disjunction_expr.Add(disjunction_expr26.Tree); DebugLocation(255, 66); DOKEY27=(IToken)Match(input,DOKEY,Follow._DOKEY_in_for_expr1371); if (state.failed) return retval; if (state.backtracking == 0) stream_DOKEY.Add(DOKEY27); DebugLocation(255, 72); PushFollow(Follow._expr_in_for_expr1373); expr28=expr(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) stream_expr.Add(expr28.Tree); { // AST REWRITE // elements: type_id, expr, disjunction_expr, disjunction_expr // 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 = (object)adaptor.Nil(); // 256:4: -> ^( FOR type_id disjunction_expr disjunction_expr expr ) { DebugLocation(256, 7); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:256:7: ^( FOR type_id disjunction_expr disjunction_expr expr ) { object root_1 = (object)adaptor.Nil(); DebugLocation(256, 9); root_1 = (object)adaptor.BecomeRoot((object)adaptor.Create(FOR, "FOR"), root_1); DebugLocation(256, 13); adaptor.AddChild(root_1, stream_type_id.NextTree()); DebugLocation(256, 21); adaptor.AddChild(root_1, stream_disjunction_expr.NextTree()); DebugLocation(256, 38); adaptor.AddChild(root_1, stream_disjunction_expr.NextTree()); DebugLocation(256, 55); adaptor.AddChild(root_1, stream_expr.NextTree()); adaptor.AddChild(root_0, root_1); } } retval.Tree = root_0; } } } retval.Stop = (IToken)input.LT(-1); if (state.backtracking == 0) { 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("for_expr", 6); LeaveRule("for_expr", 6); LeaveRule_for_expr(); } DebugLocation(257, 1); } finally { DebugExitRule(GrammarFileName, "for_expr"); } return retval; } // $ANTLR end "for_expr" partial void EnterRule_array_inst(); partial void LeaveRule_array_inst(); // $ANTLR start "array_inst" // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:259:1: array_inst : ID LBRACKET disjunction_expr RBRACKET OFKEY expr -> ^( ARRAY_INST ID disjunction_expr expr ) ; [GrammarRule("array_inst")] private AstParserRuleReturnScope array_inst() { EnterRule_array_inst(); EnterRule("array_inst", 7); TraceIn("array_inst", 7); AstParserRuleReturnScope retval = new AstParserRuleReturnScope(); retval.Start = (IToken)input.LT(1); object root_0 = default(object); IToken ID29 = default(IToken); IToken LBRACKET30 = default(IToken); IToken RBRACKET32 = default(IToken); IToken OFKEY33 = default(IToken); AstParserRuleReturnScope disjunction_expr31 = default(AstParserRuleReturnScope); AstParserRuleReturnScope expr34 = default(AstParserRuleReturnScope); object ID29_tree = default(object); object LBRACKET30_tree = default(object); object RBRACKET32_tree = default(object); object OFKEY33_tree = default(object); RewriteRuleITokenStream stream_OFKEY=new RewriteRuleITokenStream(adaptor,"token OFKEY"); RewriteRuleITokenStream stream_LBRACKET=new RewriteRuleITokenStream(adaptor,"token LBRACKET"); RewriteRuleITokenStream stream_RBRACKET=new RewriteRuleITokenStream(adaptor,"token RBRACKET"); RewriteRuleITokenStream stream_ID=new RewriteRuleITokenStream(adaptor,"token ID"); RewriteRuleSubtreeStream stream_disjunction_expr=new RewriteRuleSubtreeStream(adaptor,"rule disjunction_expr"); RewriteRuleSubtreeStream stream_expr=new RewriteRuleSubtreeStream(adaptor,"rule expr"); try { DebugEnterRule(GrammarFileName, "array_inst"); DebugLocation(259, 1); try { // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:260:2: ( ID LBRACKET disjunction_expr RBRACKET OFKEY expr -> ^( ARRAY_INST ID disjunction_expr expr ) ) DebugEnterAlt(1); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:260:4: ID LBRACKET disjunction_expr RBRACKET OFKEY expr { DebugLocation(260, 4); ID29=(IToken)Match(input,ID,Follow._ID_in_array_inst1401); if (state.failed) return retval; if (state.backtracking == 0) stream_ID.Add(ID29); DebugLocation(260, 7); LBRACKET30=(IToken)Match(input,LBRACKET,Follow._LBRACKET_in_array_inst1403); if (state.failed) return retval; if (state.backtracking == 0) stream_LBRACKET.Add(LBRACKET30); DebugLocation(260, 16); PushFollow(Follow._disjunction_expr_in_array_inst1405); disjunction_expr31=disjunction_expr(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) stream_disjunction_expr.Add(disjunction_expr31.Tree); DebugLocation(260, 33); RBRACKET32=(IToken)Match(input,RBRACKET,Follow._RBRACKET_in_array_inst1407); if (state.failed) return retval; if (state.backtracking == 0) stream_RBRACKET.Add(RBRACKET32); DebugLocation(260, 42); OFKEY33=(IToken)Match(input,OFKEY,Follow._OFKEY_in_array_inst1409); if (state.failed) return retval; if (state.backtracking == 0) stream_OFKEY.Add(OFKEY33); DebugLocation(260, 48); PushFollow(Follow._expr_in_array_inst1411); expr34=expr(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) stream_expr.Add(expr34.Tree); { // AST REWRITE // elements: ID, expr, disjunction_expr // 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 = (object)adaptor.Nil(); // 261:4: -> ^( ARRAY_INST ID disjunction_expr expr ) { DebugLocation(261, 7); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:261:7: ^( ARRAY_INST ID disjunction_expr expr ) { object root_1 = (object)adaptor.Nil(); DebugLocation(261, 9); root_1 = (object)adaptor.BecomeRoot((object)adaptor.Create(ARRAY_INST, "ARRAY_INST"), root_1); DebugLocation(261, 20); adaptor.AddChild(root_1, stream_ID.NextNode()); DebugLocation(261, 23); adaptor.AddChild(root_1, stream_disjunction_expr.NextTree()); DebugLocation(261, 40); adaptor.AddChild(root_1, stream_expr.NextTree()); adaptor.AddChild(root_0, root_1); } } retval.Tree = root_0; } } } retval.Stop = (IToken)input.LT(-1); if (state.backtracking == 0) { retval.Tree = (object)adaptor.RulePostProcessing(root_0); adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop); } } catch (RecognitionException re) { ReportError(re); Recover(input,re); retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re); } finally { TraceOut("array_inst", 7); LeaveRule("array_inst", 7); LeaveRule_array_inst(); } DebugLocation(262, 1); } finally { DebugExitRule(GrammarFileName, "array_inst"); } return retval; } // $ANTLR end "array_inst" partial void EnterRule_conjunction_expr(); partial void LeaveRule_conjunction_expr(); // $ANTLR start "conjunction_expr" // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:264:1: conjunction_expr : relational_expr ( AND ^ relational_expr )* ; [GrammarRule("conjunction_expr")] private AstParserRuleReturnScope conjunction_expr() { EnterRule_conjunction_expr(); EnterRule("conjunction_expr", 8); TraceIn("conjunction_expr", 8); AstParserRuleReturnScope retval = new AstParserRuleReturnScope(); retval.Start = (IToken)input.LT(1); object root_0 = default(object); IToken AND36 = default(IToken); AstParserRuleReturnScope relational_expr35 = default(AstParserRuleReturnScope); AstParserRuleReturnScope relational_expr37 = default(AstParserRuleReturnScope); object AND36_tree = default(object); try { DebugEnterRule(GrammarFileName, "conjunction_expr"); DebugLocation(264, 1); try { // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:265:2: ( relational_expr ( AND ^ relational_expr )* ) DebugEnterAlt(1); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:265:4: relational_expr ( AND ^ relational_expr )* { root_0 = (object)adaptor.Nil(); DebugLocation(265, 4); PushFollow(Follow._relational_expr_in_conjunction_expr1437); relational_expr35=relational_expr(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) adaptor.AddChild(root_0, relational_expr35.Tree); DebugLocation(265, 20); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:265:20: ( AND ^ relational_expr )* try { DebugEnterSubRule(6); while (true) { int alt6=2; try { DebugEnterDecision(6, false); int LA6_0 = input.LA(1); if ((LA6_0==AND)) { alt6 = 1; } } finally { DebugExitDecision(6); } switch ( alt6 ) { case 1: DebugEnterAlt(1); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:265:21: AND ^ relational_expr { DebugLocation(265, 24); AND36=(IToken)Match(input,AND,Follow._AND_in_conjunction_expr1440); if (state.failed) return retval; if (state.backtracking == 0) { AND36_tree = (object)adaptor.Create(AND36); root_0 = (object)adaptor.BecomeRoot(AND36_tree, root_0); } DebugLocation(265, 26); PushFollow(Follow._relational_expr_in_conjunction_expr1443); relational_expr37=relational_expr(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) adaptor.AddChild(root_0, relational_expr37.Tree); } break; default: goto loop6; } } loop6: ; } finally { DebugExitSubRule(6); } } retval.Stop = (IToken)input.LT(-1); if (state.backtracking == 0) { 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("conjunction_expr", 8); LeaveRule("conjunction_expr", 8); LeaveRule_conjunction_expr(); } DebugLocation(266, 1); } finally { DebugExitRule(GrammarFileName, "conjunction_expr"); } return retval; } // $ANTLR end "conjunction_expr" partial void EnterRule_relational_expr(); partial void LeaveRule_relational_expr(); // $ANTLR start "relational_expr" // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:273:1: relational_expr : arith_expr ( ( EQ | NOTEQ | GT | LT | GTEQ | LTEQ ) ^ arith_expr )? ; [GrammarRule("relational_expr")] private AstParserRuleReturnScope relational_expr() { EnterRule_relational_expr(); EnterRule("relational_expr", 9); TraceIn("relational_expr", 9); AstParserRuleReturnScope retval = new AstParserRuleReturnScope(); retval.Start = (IToken)input.LT(1); object root_0 = default(object); IToken set39 = default(IToken); AstParserRuleReturnScope arith_expr38 = default(AstParserRuleReturnScope); AstParserRuleReturnScope arith_expr40 = default(AstParserRuleReturnScope); object set39_tree = default(object); try { DebugEnterRule(GrammarFileName, "relational_expr"); DebugLocation(273, 1); try { // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:274:2: ( arith_expr ( ( EQ | NOTEQ | GT | LT | GTEQ | LTEQ ) ^ arith_expr )? ) DebugEnterAlt(1); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:274:4: arith_expr ( ( EQ | NOTEQ | GT | LT | GTEQ | LTEQ ) ^ arith_expr )? { root_0 = (object)adaptor.Nil(); DebugLocation(274, 4); PushFollow(Follow._arith_expr_in_relational_expr1459); arith_expr38=arith_expr(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) adaptor.AddChild(root_0, arith_expr38.Tree); DebugLocation(274, 15); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:274:15: ( ( EQ | NOTEQ | GT | LT | GTEQ | LTEQ ) ^ arith_expr )? int alt7=2; try { DebugEnterSubRule(7); try { DebugEnterDecision(7, false); int LA7_0 = input.LA(1); if ((LA7_0==EQ||(LA7_0>=GT && LA7_0<=GTEQ)||(LA7_0>=LT && LA7_0<=LTEQ)||LA7_0==NOTEQ)) { alt7 = 1; } } finally { DebugExitDecision(7); } switch (alt7) { case 1: DebugEnterAlt(1); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:274:16: ( EQ | NOTEQ | GT | LT | GTEQ | LTEQ ) ^ arith_expr { DebugLocation(274, 53); set39=(IToken)input.LT(1); set39=(IToken)input.LT(1); if (input.LA(1)==EQ||(input.LA(1)>=GT && input.LA(1)<=GTEQ)||(input.LA(1)>=LT && input.LA(1)<=LTEQ)||input.LA(1)==NOTEQ) { input.Consume(); if (state.backtracking == 0) root_0 = (object)adaptor.BecomeRoot((object)adaptor.Create(set39), root_0); state.errorRecovery=false;state.failed=false; } else { if (state.backtracking>0) {state.failed=true; return retval;} MismatchedSetException mse = new MismatchedSetException(null,input); DebugRecognitionException(mse); throw mse; } DebugLocation(274, 55); PushFollow(Follow._arith_expr_in_relational_expr1488); arith_expr40=arith_expr(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) adaptor.AddChild(root_0, arith_expr40.Tree); } break; } } finally { DebugExitSubRule(7); } } retval.Stop = (IToken)input.LT(-1); if (state.backtracking == 0) { 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("relational_expr", 9); LeaveRule("relational_expr", 9); LeaveRule_relational_expr(); } DebugLocation(275, 1); } finally { DebugExitRule(GrammarFileName, "relational_expr"); } return retval; } // $ANTLR end "relational_expr" partial void EnterRule_arith_expr(); partial void LeaveRule_arith_expr(); // $ANTLR start "arith_expr" // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:277:1: arith_expr : term_expr ( ( PLUS | MINUS ) ^ term_expr )* ; [GrammarRule("arith_expr")] private AstParserRuleReturnScope arith_expr() { EnterRule_arith_expr(); EnterRule("arith_expr", 10); TraceIn("arith_expr", 10); AstParserRuleReturnScope retval = new AstParserRuleReturnScope(); retval.Start = (IToken)input.LT(1); object root_0 = default(object); IToken set42 = default(IToken); AstParserRuleReturnScope term_expr41 = default(AstParserRuleReturnScope); AstParserRuleReturnScope term_expr43 = default(AstParserRuleReturnScope); object set42_tree = default(object); try { DebugEnterRule(GrammarFileName, "arith_expr"); DebugLocation(277, 1); try { // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:278:2: ( term_expr ( ( PLUS | MINUS ) ^ term_expr )* ) DebugEnterAlt(1); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:278:4: term_expr ( ( PLUS | MINUS ) ^ term_expr )* { root_0 = (object)adaptor.Nil(); DebugLocation(278, 4); PushFollow(Follow._term_expr_in_arith_expr1502); term_expr41=term_expr(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) adaptor.AddChild(root_0, term_expr41.Tree); DebugLocation(278, 14); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:278:14: ( ( PLUS | MINUS ) ^ term_expr )* try { DebugEnterSubRule(8); while (true) { int alt8=2; try { DebugEnterDecision(8, false); int LA8_0 = input.LA(1); if ((LA8_0==MINUS||LA8_0==PLUS)) { alt8 = 1; } } finally { DebugExitDecision(8); } switch ( alt8 ) { case 1: DebugEnterAlt(1); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:278:15: ( PLUS | MINUS ) ^ term_expr { DebugLocation(278, 29); set42=(IToken)input.LT(1); set42=(IToken)input.LT(1); if (input.LA(1)==MINUS||input.LA(1)==PLUS) { input.Consume(); if (state.backtracking == 0) root_0 = (object)adaptor.BecomeRoot((object)adaptor.Create(set42), root_0); state.errorRecovery=false;state.failed=false; } else { if (state.backtracking>0) {state.failed=true; return retval;} MismatchedSetException mse = new MismatchedSetException(null,input); DebugRecognitionException(mse); throw mse; } DebugLocation(278, 31); PushFollow(Follow._term_expr_in_arith_expr1514); term_expr43=term_expr(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) adaptor.AddChild(root_0, term_expr43.Tree); } break; default: goto loop8; } } loop8: ; } finally { DebugExitSubRule(8); } } retval.Stop = (IToken)input.LT(-1); if (state.backtracking == 0) { 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("arith_expr", 10); LeaveRule("arith_expr", 10); LeaveRule_arith_expr(); } DebugLocation(279, 1); } finally { DebugExitRule(GrammarFileName, "arith_expr"); } return retval; } // $ANTLR end "arith_expr" partial void EnterRule_term_expr(); partial void LeaveRule_term_expr(); // $ANTLR start "term_expr" // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:281:1: term_expr : atom ( ( MULT | DIV ) ^ atom )* ; [GrammarRule("term_expr")] private AstParserRuleReturnScope term_expr() { EnterRule_term_expr(); EnterRule("term_expr", 11); TraceIn("term_expr", 11); AstParserRuleReturnScope retval = new AstParserRuleReturnScope(); retval.Start = (IToken)input.LT(1); object root_0 = default(object); IToken set45 = default(IToken); AstParserRuleReturnScope atom44 = default(AstParserRuleReturnScope); AstParserRuleReturnScope atom46 = default(AstParserRuleReturnScope); object set45_tree = default(object); try { DebugEnterRule(GrammarFileName, "term_expr"); DebugLocation(281, 1); try { // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:282:2: ( atom ( ( MULT | DIV ) ^ atom )* ) DebugEnterAlt(1); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:282:4: atom ( ( MULT | DIV ) ^ atom )* { root_0 = (object)adaptor.Nil(); DebugLocation(282, 4); PushFollow(Follow._atom_in_term_expr1527); atom44=atom(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) adaptor.AddChild(root_0, atom44.Tree); DebugLocation(282, 9); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:282:9: ( ( MULT | DIV ) ^ atom )* try { DebugEnterSubRule(9); while (true) { int alt9=2; try { DebugEnterDecision(9, false); int LA9_0 = input.LA(1); if ((LA9_0==DIV||LA9_0==MULT)) { alt9 = 1; } } finally { DebugExitDecision(9); } switch ( alt9 ) { case 1: DebugEnterAlt(1); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:282:10: ( MULT | DIV ) ^ atom { DebugLocation(282, 22); set45=(IToken)input.LT(1); set45=(IToken)input.LT(1); if (input.LA(1)==DIV||input.LA(1)==MULT) { input.Consume(); if (state.backtracking == 0) root_0 = (object)adaptor.BecomeRoot((object)adaptor.Create(set45), root_0); state.errorRecovery=false;state.failed=false; } else { if (state.backtracking>0) {state.failed=true; return retval;} MismatchedSetException mse = new MismatchedSetException(null,input); DebugRecognitionException(mse); throw mse; } DebugLocation(282, 24); PushFollow(Follow._atom_in_term_expr1539); atom46=atom(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) adaptor.AddChild(root_0, atom46.Tree); } break; default: goto loop9; } } loop9: ; } finally { DebugExitSubRule(9); } } retval.Stop = (IToken)input.LT(-1); if (state.backtracking == 0) { 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("term_expr", 11); LeaveRule("term_expr", 11); LeaveRule_term_expr(); } DebugLocation(283, 1); } finally { DebugExitRule(GrammarFileName, "term_expr"); } return retval; } // $ANTLR end "term_expr" partial void EnterRule_field_inst_list(); partial void LeaveRule_field_inst_list(); // $ANTLR start "field_inst_list" // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:285:1: field_inst_list : record_field_inst ( COMMA record_field_inst )* -> ^( FIELDS_INST ( record_field_inst )+ ) ; [GrammarRule("field_inst_list")] private AstParserRuleReturnScope field_inst_list() { EnterRule_field_inst_list(); EnterRule("field_inst_list", 12); TraceIn("field_inst_list", 12); AstParserRuleReturnScope retval = new AstParserRuleReturnScope(); retval.Start = (IToken)input.LT(1); object root_0 = default(object); IToken COMMA48 = default(IToken); AstParserRuleReturnScope record_field_inst47 = default(AstParserRuleReturnScope); AstParserRuleReturnScope record_field_inst49 = default(AstParserRuleReturnScope); object COMMA48_tree = default(object); RewriteRuleITokenStream stream_COMMA=new RewriteRuleITokenStream(adaptor,"token COMMA"); RewriteRuleSubtreeStream stream_record_field_inst=new RewriteRuleSubtreeStream(adaptor,"rule record_field_inst"); try { DebugEnterRule(GrammarFileName, "field_inst_list"); DebugLocation(285, 1); try { // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:286:2: ( record_field_inst ( COMMA record_field_inst )* -> ^( FIELDS_INST ( record_field_inst )+ ) ) DebugEnterAlt(1); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:286:5: record_field_inst ( COMMA record_field_inst )* { DebugLocation(286, 5); PushFollow(Follow._record_field_inst_in_field_inst_list1553); record_field_inst47=record_field_inst(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) stream_record_field_inst.Add(record_field_inst47.Tree); DebugLocation(286, 23); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:286:23: ( COMMA record_field_inst )* try { DebugEnterSubRule(10); while (true) { int alt10=2; try { DebugEnterDecision(10, false); int LA10_0 = input.LA(1); if ((LA10_0==COMMA)) { alt10 = 1; } } finally { DebugExitDecision(10); } switch ( alt10 ) { case 1: DebugEnterAlt(1); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:286:25: COMMA record_field_inst { DebugLocation(286, 25); COMMA48=(IToken)Match(input,COMMA,Follow._COMMA_in_field_inst_list1557); if (state.failed) return retval; if (state.backtracking == 0) stream_COMMA.Add(COMMA48); DebugLocation(286, 31); PushFollow(Follow._record_field_inst_in_field_inst_list1559); record_field_inst49=record_field_inst(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) stream_record_field_inst.Add(record_field_inst49.Tree); } break; default: goto loop10; } } loop10: ; } finally { DebugExitSubRule(10); } { // AST REWRITE // elements: record_field_inst // 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 = (object)adaptor.Nil(); // 287:4: -> ^( FIELDS_INST ( record_field_inst )+ ) { DebugLocation(287, 7); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:287:7: ^( FIELDS_INST ( record_field_inst )+ ) { object root_1 = (object)adaptor.Nil(); DebugLocation(287, 9); root_1 = (object)adaptor.BecomeRoot((object)adaptor.Create(FIELDS_INST, "FIELDS_INST"), root_1); DebugLocation(287, 21); if (!(stream_record_field_inst.HasNext)) { throw new RewriteEarlyExitException(); } while ( stream_record_field_inst.HasNext ) { DebugLocation(287, 21); adaptor.AddChild(root_1, stream_record_field_inst.NextTree()); } stream_record_field_inst.Reset(); adaptor.AddChild(root_0, root_1); } } retval.Tree = root_0; } } } retval.Stop = (IToken)input.LT(-1); if (state.backtracking == 0) { 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("field_inst_list", 12); LeaveRule("field_inst_list", 12); LeaveRule_field_inst_list(); } DebugLocation(288, 1); } finally { DebugExitRule(GrammarFileName, "field_inst_list"); } return retval; } // $ANTLR end "field_inst_list" partial void EnterRule_record_field_inst(); partial void LeaveRule_record_field_inst(); // $ANTLR start "record_field_inst" // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:290:1: record_field_inst : ID EQ expr -> ^( FIELD_INST ID expr ) ; [GrammarRule("record_field_inst")] private AstParserRuleReturnScope record_field_inst() { EnterRule_record_field_inst(); EnterRule("record_field_inst", 13); TraceIn("record_field_inst", 13); AstParserRuleReturnScope retval = new AstParserRuleReturnScope(); retval.Start = (IToken)input.LT(1); object root_0 = default(object); IToken ID50 = default(IToken); IToken EQ51 = default(IToken); AstParserRuleReturnScope expr52 = default(AstParserRuleReturnScope); object ID50_tree = default(object); object EQ51_tree = default(object); RewriteRuleITokenStream stream_ID=new RewriteRuleITokenStream(adaptor,"token ID"); RewriteRuleITokenStream stream_EQ=new RewriteRuleITokenStream(adaptor,"token EQ"); RewriteRuleSubtreeStream stream_expr=new RewriteRuleSubtreeStream(adaptor,"rule expr"); try { DebugEnterRule(GrammarFileName, "record_field_inst"); DebugLocation(290, 1); try { // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:291:2: ( ID EQ expr -> ^( FIELD_INST ID expr ) ) DebugEnterAlt(1); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:291:5: ID EQ expr { DebugLocation(291, 5); ID50=(IToken)Match(input,ID,Follow._ID_in_record_field_inst1586); if (state.failed) return retval; if (state.backtracking == 0) stream_ID.Add(ID50); DebugLocation(291, 8); EQ51=(IToken)Match(input,EQ,Follow._EQ_in_record_field_inst1588); if (state.failed) return retval; if (state.backtracking == 0) stream_EQ.Add(EQ51); DebugLocation(291, 11); PushFollow(Follow._expr_in_record_field_inst1590); expr52=expr(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) stream_expr.Add(expr52.Tree); { // AST REWRITE // elements: ID, expr // 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 = (object)adaptor.Nil(); // 292:4: -> ^( FIELD_INST ID expr ) { DebugLocation(292, 7); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:292:7: ^( FIELD_INST ID expr ) { object root_1 = (object)adaptor.Nil(); DebugLocation(292, 9); root_1 = (object)adaptor.BecomeRoot((object)adaptor.Create(FIELD_INST, "FIELD_INST"), root_1); DebugLocation(292, 20); adaptor.AddChild(root_1, stream_ID.NextNode()); DebugLocation(292, 23); adaptor.AddChild(root_1, stream_expr.NextTree()); adaptor.AddChild(root_0, root_1); } } retval.Tree = root_0; } } } retval.Stop = (IToken)input.LT(-1); if (state.backtracking == 0) { 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("record_field_inst", 13); LeaveRule("record_field_inst", 13); LeaveRule_record_field_inst(); } DebugLocation(293, 1); } finally { DebugExitRule(GrammarFileName, "record_field_inst"); } return retval; } // $ANTLR end "record_field_inst" partial void EnterRule_decl(); partial void LeaveRule_decl(); // $ANTLR start "decl" // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:295:1: decl : ( ( type_decl )+ -> ^( TYPE_DECL_SEQ ( type_decl )+ ) | var_decl | ( fun_decl )+ -> ^( FUN_DECL_SEQ ( fun_decl )+ ) ); [GrammarRule("decl")] private AstParserRuleReturnScope decl() { EnterRule_decl(); EnterRule("decl", 14); TraceIn("decl", 14); AstParserRuleReturnScope retval = new AstParserRuleReturnScope(); retval.Start = (IToken)input.LT(1); object root_0 = default(object); AstParserRuleReturnScope type_decl53 = default(AstParserRuleReturnScope); AstParserRuleReturnScope var_decl54 = default(AstParserRuleReturnScope); AstParserRuleReturnScope fun_decl55 = default(AstParserRuleReturnScope); RewriteRuleSubtreeStream stream_type_decl=new RewriteRuleSubtreeStream(adaptor,"rule type_decl"); RewriteRuleSubtreeStream stream_fun_decl=new RewriteRuleSubtreeStream(adaptor,"rule fun_decl"); try { DebugEnterRule(GrammarFileName, "decl"); DebugLocation(295, 1); try { // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:296:2: ( ( type_decl )+ -> ^( TYPE_DECL_SEQ ( type_decl )+ ) | var_decl | ( fun_decl )+ -> ^( FUN_DECL_SEQ ( fun_decl )+ ) ) int alt13=3; try { DebugEnterDecision(13, false); switch (input.LA(1)) { case TYPEKEY: { alt13 = 1; } break; case VARKEY: { alt13 = 2; } break; case FUNCTIONKEY: { alt13 = 3; } break; default: { if (state.backtracking>0) {state.failed=true; return retval;} NoViableAltException nvae = new NoViableAltException("", 13, 0, input); DebugRecognitionException(nvae); throw nvae; } } } finally { DebugExitDecision(13); } switch (alt13) { case 1: DebugEnterAlt(1); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:296:4: ( type_decl )+ { DebugLocation(296, 4); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:296:4: ( type_decl )+ int cnt11=0; try { DebugEnterSubRule(11); while (true) { int alt11=2; try { DebugEnterDecision(11, false); int LA11_0 = input.LA(1); if ((LA11_0==TYPEKEY)) { alt11 = 1; } } finally { DebugExitDecision(11); } switch (alt11) { case 1: DebugEnterAlt(1); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:296:4: type_decl { DebugLocation(296, 4); PushFollow(Follow._type_decl_in_decl1615); type_decl53=type_decl(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) stream_type_decl.Add(type_decl53.Tree); } break; default: if (cnt11 >= 1) goto loop11; if (state.backtracking>0) {state.failed=true; return retval;} EarlyExitException eee11 = new EarlyExitException( 11, input ); DebugRecognitionException(eee11); throw eee11; } cnt11++; } loop11: ; } finally { DebugExitSubRule(11); } { // AST REWRITE // elements: type_decl // 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 = (object)adaptor.Nil(); // 297:4: -> ^( TYPE_DECL_SEQ ( type_decl )+ ) { DebugLocation(297, 7); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:297:7: ^( TYPE_DECL_SEQ ( type_decl )+ ) { object root_1 = (object)adaptor.Nil(); DebugLocation(297, 9); root_1 = (object)adaptor.BecomeRoot((object)adaptor.Create(TYPE_DECL_SEQ, "TYPE_DECL_SEQ"), root_1); DebugLocation(297, 23); if (!(stream_type_decl.HasNext)) { throw new RewriteEarlyExitException(); } while ( stream_type_decl.HasNext ) { DebugLocation(297, 23); adaptor.AddChild(root_1, stream_type_decl.NextTree()); } stream_type_decl.Reset(); adaptor.AddChild(root_0, root_1); } } retval.Tree = root_0; } } } break; case 2: DebugEnterAlt(2); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:298:4: var_decl { root_0 = (object)adaptor.Nil(); DebugLocation(298, 4); PushFollow(Follow._var_decl_in_decl1633); var_decl54=var_decl(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) adaptor.AddChild(root_0, var_decl54.Tree); } break; case 3: DebugEnterAlt(3); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:299:4: ( fun_decl )+ { DebugLocation(299, 4); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:299:4: ( fun_decl )+ int cnt12=0; try { DebugEnterSubRule(12); while (true) { int alt12=2; try { DebugEnterDecision(12, false); int LA12_0 = input.LA(1); if ((LA12_0==FUNCTIONKEY)) { alt12 = 1; } } finally { DebugExitDecision(12); } switch (alt12) { case 1: DebugEnterAlt(1); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:299:4: fun_decl { DebugLocation(299, 4); PushFollow(Follow._fun_decl_in_decl1638); fun_decl55=fun_decl(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) stream_fun_decl.Add(fun_decl55.Tree); } break; default: if (cnt12 >= 1) goto loop12; if (state.backtracking>0) {state.failed=true; return retval;} EarlyExitException eee12 = new EarlyExitException( 12, input ); DebugRecognitionException(eee12); throw eee12; } cnt12++; } loop12: ; } finally { DebugExitSubRule(12); } { // AST REWRITE // elements: fun_decl // 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 = (object)adaptor.Nil(); // 300:4: -> ^( FUN_DECL_SEQ ( fun_decl )+ ) { DebugLocation(300, 7); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:300:7: ^( FUN_DECL_SEQ ( fun_decl )+ ) { object root_1 = (object)adaptor.Nil(); DebugLocation(300, 9); root_1 = (object)adaptor.BecomeRoot((object)adaptor.Create(FUN_DECL_SEQ, "FUN_DECL_SEQ"), root_1); DebugLocation(300, 22); if (!(stream_fun_decl.HasNext)) { throw new RewriteEarlyExitException(); } while ( stream_fun_decl.HasNext ) { DebugLocation(300, 22); adaptor.AddChild(root_1, stream_fun_decl.NextTree()); } stream_fun_decl.Reset(); adaptor.AddChild(root_0, root_1); } } retval.Tree = root_0; } } } break; } retval.Stop = (IToken)input.LT(-1); if (state.backtracking == 0) { 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("decl", 14); LeaveRule("decl", 14); LeaveRule_decl(); } DebugLocation(301, 1); } finally { DebugExitRule(GrammarFileName, "decl"); } return retval; } // $ANTLR end "decl" partial void EnterRule_type_decl(); partial void LeaveRule_type_decl(); // $ANTLR start "type_decl" // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:303:1: type_decl : TYPEKEY ID EQ type -> ^( TYPE_DECL ID type ) ; [GrammarRule("type_decl")] private AstParserRuleReturnScope type_decl() { EnterRule_type_decl(); EnterRule("type_decl", 15); TraceIn("type_decl", 15); AstParserRuleReturnScope retval = new AstParserRuleReturnScope(); retval.Start = (IToken)input.LT(1); object root_0 = default(object); IToken TYPEKEY56 = default(IToken); IToken ID57 = default(IToken); IToken EQ58 = default(IToken); AstParserRuleReturnScope type59 = default(AstParserRuleReturnScope); object TYPEKEY56_tree = default(object); object ID57_tree = default(object); object EQ58_tree = default(object); RewriteRuleITokenStream stream_TYPEKEY=new RewriteRuleITokenStream(adaptor,"token TYPEKEY"); RewriteRuleITokenStream stream_ID=new RewriteRuleITokenStream(adaptor,"token ID"); RewriteRuleITokenStream stream_EQ=new RewriteRuleITokenStream(adaptor,"token EQ"); RewriteRuleSubtreeStream stream_type=new RewriteRuleSubtreeStream(adaptor,"rule type"); try { DebugEnterRule(GrammarFileName, "type_decl"); DebugLocation(303, 1); try { // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:304:2: ( TYPEKEY ID EQ type -> ^( TYPE_DECL ID type ) ) DebugEnterAlt(1); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:304:4: TYPEKEY ID EQ type { DebugLocation(304, 4); TYPEKEY56=(IToken)Match(input,TYPEKEY,Follow._TYPEKEY_in_type_decl1662); if (state.failed) return retval; if (state.backtracking == 0) stream_TYPEKEY.Add(TYPEKEY56); DebugLocation(304, 12); ID57=(IToken)Match(input,ID,Follow._ID_in_type_decl1664); if (state.failed) return retval; if (state.backtracking == 0) stream_ID.Add(ID57); DebugLocation(304, 15); EQ58=(IToken)Match(input,EQ,Follow._EQ_in_type_decl1666); if (state.failed) return retval; if (state.backtracking == 0) stream_EQ.Add(EQ58); DebugLocation(304, 18); PushFollow(Follow._type_in_type_decl1668); type59=type(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) stream_type.Add(type59.Tree); { // AST REWRITE // elements: type, ID // 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 = (object)adaptor.Nil(); // 305:4: -> ^( TYPE_DECL ID type ) { DebugLocation(305, 7); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:305:7: ^( TYPE_DECL ID type ) { object root_1 = (object)adaptor.Nil(); DebugLocation(305, 9); root_1 = (object)adaptor.BecomeRoot((object)adaptor.Create(TYPE_DECL, "TYPE_DECL"), root_1); DebugLocation(305, 19); adaptor.AddChild(root_1, stream_ID.NextNode()); DebugLocation(305, 22); adaptor.AddChild(root_1, stream_type.NextTree()); adaptor.AddChild(root_0, root_1); } } retval.Tree = root_0; } } } retval.Stop = (IToken)input.LT(-1); if (state.backtracking == 0) { 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("type_decl", 15); LeaveRule("type_decl", 15); LeaveRule_type_decl(); } DebugLocation(306, 1); } finally { DebugExitRule(GrammarFileName, "type_decl"); } return retval; } // $ANTLR end "type_decl" partial void EnterRule_var_decl(); partial void LeaveRule_var_decl(); // $ANTLR start "var_decl" // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:308:1: var_decl : ( VARKEY type_id COLON type_id ASSIGN expr -> ^( VAR_DECL type_id type_id expr ) | VARKEY type_id ASSIGN expr -> ^( VAR_DECL type_id FILL_IN_TYPE expr ) ); [GrammarRule("var_decl")] private AstParserRuleReturnScope var_decl() { EnterRule_var_decl(); EnterRule("var_decl", 16); TraceIn("var_decl", 16); AstParserRuleReturnScope retval = new AstParserRuleReturnScope(); retval.Start = (IToken)input.LT(1); object root_0 = default(object); IToken VARKEY60 = default(IToken); IToken COLON62 = default(IToken); IToken ASSIGN64 = default(IToken); IToken VARKEY66 = default(IToken); IToken ASSIGN68 = default(IToken); AstParserRuleReturnScope type_id61 = default(AstParserRuleReturnScope); AstParserRuleReturnScope type_id63 = default(AstParserRuleReturnScope); AstParserRuleReturnScope expr65 = default(AstParserRuleReturnScope); AstParserRuleReturnScope type_id67 = default(AstParserRuleReturnScope); AstParserRuleReturnScope expr69 = default(AstParserRuleReturnScope); object VARKEY60_tree = default(object); object COLON62_tree = default(object); object ASSIGN64_tree = default(object); object VARKEY66_tree = default(object); object ASSIGN68_tree = default(object); RewriteRuleITokenStream stream_VARKEY=new RewriteRuleITokenStream(adaptor,"token VARKEY"); RewriteRuleITokenStream stream_COLON=new RewriteRuleITokenStream(adaptor,"token COLON"); RewriteRuleITokenStream stream_ASSIGN=new RewriteRuleITokenStream(adaptor,"token ASSIGN"); RewriteRuleSubtreeStream stream_type_id=new RewriteRuleSubtreeStream(adaptor,"rule type_id"); RewriteRuleSubtreeStream stream_expr=new RewriteRuleSubtreeStream(adaptor,"rule expr"); try { DebugEnterRule(GrammarFileName, "var_decl"); DebugLocation(308, 1); try { // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:309:2: ( VARKEY type_id COLON type_id ASSIGN expr -> ^( VAR_DECL type_id type_id expr ) | VARKEY type_id ASSIGN expr -> ^( VAR_DECL type_id FILL_IN_TYPE expr ) ) int alt14=2; try { DebugEnterDecision(14, false); int LA14_0 = input.LA(1); if ((LA14_0==VARKEY)) { int LA14_1 = input.LA(2); if ((LA14_1==ID||LA14_1==INTKEY||LA14_1==STRINGKEY)) { int LA14_2 = input.LA(3); if ((LA14_2==COLON)) { alt14 = 1; } else if ((LA14_2==ASSIGN)) { alt14 = 2; } else { if (state.backtracking>0) {state.failed=true; return retval;} NoViableAltException nvae = new NoViableAltException("", 14, 2, input); DebugRecognitionException(nvae); throw nvae; } } else { if (state.backtracking>0) {state.failed=true; return retval;} NoViableAltException nvae = new NoViableAltException("", 14, 1, input); DebugRecognitionException(nvae); throw nvae; } } else { if (state.backtracking>0) {state.failed=true; return retval;} NoViableAltException nvae = new NoViableAltException("", 14, 0, input); DebugRecognitionException(nvae); throw nvae; } } finally { DebugExitDecision(14); } switch (alt14) { case 1: DebugEnterAlt(1); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:309:4: VARKEY type_id COLON type_id ASSIGN expr { DebugLocation(309, 4); VARKEY60=(IToken)Match(input,VARKEY,Follow._VARKEY_in_var_decl1692); if (state.failed) return retval; if (state.backtracking == 0) stream_VARKEY.Add(VARKEY60); DebugLocation(309, 11); PushFollow(Follow._type_id_in_var_decl1694); type_id61=type_id(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) stream_type_id.Add(type_id61.Tree); DebugLocation(309, 19); COLON62=(IToken)Match(input,COLON,Follow._COLON_in_var_decl1696); if (state.failed) return retval; if (state.backtracking == 0) stream_COLON.Add(COLON62); DebugLocation(309, 25); PushFollow(Follow._type_id_in_var_decl1698); type_id63=type_id(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) stream_type_id.Add(type_id63.Tree); DebugLocation(309, 33); ASSIGN64=(IToken)Match(input,ASSIGN,Follow._ASSIGN_in_var_decl1700); if (state.failed) return retval; if (state.backtracking == 0) stream_ASSIGN.Add(ASSIGN64); DebugLocation(309, 40); PushFollow(Follow._expr_in_var_decl1702); expr65=expr(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) stream_expr.Add(expr65.Tree); { // AST REWRITE // elements: type_id, expr, type_id // 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 = (object)adaptor.Nil(); // 310:4: -> ^( VAR_DECL type_id type_id expr ) { DebugLocation(310, 7); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:310:7: ^( VAR_DECL type_id type_id expr ) { object root_1 = (object)adaptor.Nil(); DebugLocation(310, 9); root_1 = (object)adaptor.BecomeRoot((object)adaptor.Create(VAR_DECL, "VAR_DECL"), root_1); DebugLocation(310, 18); adaptor.AddChild(root_1, stream_type_id.NextTree()); DebugLocation(310, 26); adaptor.AddChild(root_1, stream_type_id.NextTree()); DebugLocation(310, 34); adaptor.AddChild(root_1, stream_expr.NextTree()); adaptor.AddChild(root_0, root_1); } } retval.Tree = root_0; } } } break; case 2: DebugEnterAlt(2); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:311:4: VARKEY type_id ASSIGN expr { DebugLocation(311, 4); VARKEY66=(IToken)Match(input,VARKEY,Follow._VARKEY_in_var_decl1723); if (state.failed) return retval; if (state.backtracking == 0) stream_VARKEY.Add(VARKEY66); DebugLocation(311, 11); PushFollow(Follow._type_id_in_var_decl1725); type_id67=type_id(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) stream_type_id.Add(type_id67.Tree); DebugLocation(311, 19); ASSIGN68=(IToken)Match(input,ASSIGN,Follow._ASSIGN_in_var_decl1727); if (state.failed) return retval; if (state.backtracking == 0) stream_ASSIGN.Add(ASSIGN68); DebugLocation(311, 26); PushFollow(Follow._expr_in_var_decl1729); expr69=expr(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) stream_expr.Add(expr69.Tree); { // AST REWRITE // elements: expr, type_id // 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 = (object)adaptor.Nil(); // 312:4: -> ^( VAR_DECL type_id FILL_IN_TYPE expr ) { DebugLocation(312, 7); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:312:7: ^( VAR_DECL type_id FILL_IN_TYPE expr ) { object root_1 = (object)adaptor.Nil(); DebugLocation(312, 9); root_1 = (object)adaptor.BecomeRoot((object)adaptor.Create(VAR_DECL, "VAR_DECL"), root_1); DebugLocation(312, 18); adaptor.AddChild(root_1, stream_type_id.NextTree()); DebugLocation(312, 26); adaptor.AddChild(root_1, (object)adaptor.Create(FILL_IN_TYPE, "FILL_IN_TYPE")); DebugLocation(312, 39); adaptor.AddChild(root_1, stream_expr.NextTree()); adaptor.AddChild(root_0, root_1); } } retval.Tree = root_0; } } } break; } retval.Stop = (IToken)input.LT(-1); if (state.backtracking == 0) { 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("var_decl", 16); LeaveRule("var_decl", 16); LeaveRule_var_decl(); } DebugLocation(313, 1); } finally { DebugExitRule(GrammarFileName, "var_decl"); } return retval; } // $ANTLR end "var_decl" partial void EnterRule_fun_decl(); partial void LeaveRule_fun_decl(); // $ANTLR start "fun_decl" // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:315:1: fun_decl : FUNCTIONKEY type_id LPAREN ( type_fields )? RPAREN ( COLON type_id )? EQ expr -> ^( FUN_DECL type_id ^( PARAM_DECL ( type_fields )? ) ^( FUN_TYPE_WRAPPER ( type_id )? ) expr ) ; [GrammarRule("fun_decl")] private AstParserRuleReturnScope fun_decl() { EnterRule_fun_decl(); EnterRule("fun_decl", 17); TraceIn("fun_decl", 17); AstParserRuleReturnScope retval = new AstParserRuleReturnScope(); retval.Start = (IToken)input.LT(1); object root_0 = default(object); IToken FUNCTIONKEY70 = default(IToken); IToken LPAREN72 = default(IToken); IToken RPAREN74 = default(IToken); IToken COLON75 = default(IToken); IToken EQ77 = default(IToken); AstParserRuleReturnScope type_id71 = default(AstParserRuleReturnScope); AstParserRuleReturnScope type_fields73 = default(AstParserRuleReturnScope); AstParserRuleReturnScope type_id76 = default(AstParserRuleReturnScope); AstParserRuleReturnScope expr78 = default(AstParserRuleReturnScope); object FUNCTIONKEY70_tree = default(object); object LPAREN72_tree = default(object); object RPAREN74_tree = default(object); object COLON75_tree = default(object); object EQ77_tree = default(object); RewriteRuleITokenStream stream_FUNCTIONKEY=new RewriteRuleITokenStream(adaptor,"token FUNCTIONKEY"); RewriteRuleITokenStream stream_LPAREN=new RewriteRuleITokenStream(adaptor,"token LPAREN"); RewriteRuleITokenStream stream_COLON=new RewriteRuleITokenStream(adaptor,"token COLON"); RewriteRuleITokenStream stream_RPAREN=new RewriteRuleITokenStream(adaptor,"token RPAREN"); RewriteRuleITokenStream stream_EQ=new RewriteRuleITokenStream(adaptor,"token EQ"); RewriteRuleSubtreeStream stream_type_id=new RewriteRuleSubtreeStream(adaptor,"rule type_id"); RewriteRuleSubtreeStream stream_type_fields=new RewriteRuleSubtreeStream(adaptor,"rule type_fields"); RewriteRuleSubtreeStream stream_expr=new RewriteRuleSubtreeStream(adaptor,"rule expr"); try { DebugEnterRule(GrammarFileName, "fun_decl"); DebugLocation(315, 1); try { // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:316:2: ( FUNCTIONKEY type_id LPAREN ( type_fields )? RPAREN ( COLON type_id )? EQ expr -> ^( FUN_DECL type_id ^( PARAM_DECL ( type_fields )? ) ^( FUN_TYPE_WRAPPER ( type_id )? ) expr ) ) DebugEnterAlt(1); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:316:4: FUNCTIONKEY type_id LPAREN ( type_fields )? RPAREN ( COLON type_id )? EQ expr { DebugLocation(316, 4); FUNCTIONKEY70=(IToken)Match(input,FUNCTIONKEY,Follow._FUNCTIONKEY_in_fun_decl1755); if (state.failed) return retval; if (state.backtracking == 0) stream_FUNCTIONKEY.Add(FUNCTIONKEY70); DebugLocation(316, 16); PushFollow(Follow._type_id_in_fun_decl1757); type_id71=type_id(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) stream_type_id.Add(type_id71.Tree); DebugLocation(316, 24); LPAREN72=(IToken)Match(input,LPAREN,Follow._LPAREN_in_fun_decl1759); if (state.failed) return retval; if (state.backtracking == 0) stream_LPAREN.Add(LPAREN72); DebugLocation(316, 31); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:316:31: ( type_fields )? int alt15=2; try { DebugEnterSubRule(15); try { DebugEnterDecision(15, false); int LA15_0 = input.LA(1); if ((LA15_0==ID||LA15_0==INTKEY||LA15_0==STRINGKEY)) { alt15 = 1; } } finally { DebugExitDecision(15); } switch (alt15) { case 1: DebugEnterAlt(1); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:316:31: type_fields { DebugLocation(316, 31); PushFollow(Follow._type_fields_in_fun_decl1761); type_fields73=type_fields(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) stream_type_fields.Add(type_fields73.Tree); } break; } } finally { DebugExitSubRule(15); } DebugLocation(316, 44); RPAREN74=(IToken)Match(input,RPAREN,Follow._RPAREN_in_fun_decl1764); if (state.failed) return retval; if (state.backtracking == 0) stream_RPAREN.Add(RPAREN74); DebugLocation(316, 51); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:316:51: ( COLON type_id )? int alt16=2; try { DebugEnterSubRule(16); try { DebugEnterDecision(16, false); int LA16_0 = input.LA(1); if ((LA16_0==COLON)) { alt16 = 1; } } finally { DebugExitDecision(16); } switch (alt16) { case 1: DebugEnterAlt(1); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:316:52: COLON type_id { DebugLocation(316, 52); COLON75=(IToken)Match(input,COLON,Follow._COLON_in_fun_decl1767); if (state.failed) return retval; if (state.backtracking == 0) stream_COLON.Add(COLON75); DebugLocation(316, 58); PushFollow(Follow._type_id_in_fun_decl1769); type_id76=type_id(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) stream_type_id.Add(type_id76.Tree); } break; } } finally { DebugExitSubRule(16); } DebugLocation(316, 68); EQ77=(IToken)Match(input,EQ,Follow._EQ_in_fun_decl1773); if (state.failed) return retval; if (state.backtracking == 0) stream_EQ.Add(EQ77); DebugLocation(316, 71); PushFollow(Follow._expr_in_fun_decl1775); expr78=expr(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) stream_expr.Add(expr78.Tree); { // AST REWRITE // elements: type_id, expr, type_id, type_fields // 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 = (object)adaptor.Nil(); // 317:4: -> ^( FUN_DECL type_id ^( PARAM_DECL ( type_fields )? ) ^( FUN_TYPE_WRAPPER ( type_id )? ) expr ) { DebugLocation(317, 7); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:317:7: ^( FUN_DECL type_id ^( PARAM_DECL ( type_fields )? ) ^( FUN_TYPE_WRAPPER ( type_id )? ) expr ) { object root_1 = (object)adaptor.Nil(); DebugLocation(317, 9); root_1 = (object)adaptor.BecomeRoot((object)adaptor.Create(FUN_DECL, "FUN_DECL"), root_1); DebugLocation(317, 18); adaptor.AddChild(root_1, stream_type_id.NextTree()); DebugLocation(317, 26); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:317:26: ^( PARAM_DECL ( type_fields )? ) { object root_2 = (object)adaptor.Nil(); DebugLocation(317, 28); root_2 = (object)adaptor.BecomeRoot((object)adaptor.Create(PARAM_DECL, "PARAM_DECL"), root_2); DebugLocation(317, 39); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:317:39: ( type_fields )? if (stream_type_fields.HasNext) { DebugLocation(317, 39); adaptor.AddChild(root_2, stream_type_fields.NextTree()); } stream_type_fields.Reset(); adaptor.AddChild(root_1, root_2); } DebugLocation(317, 53); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:317:53: ^( FUN_TYPE_WRAPPER ( type_id )? ) { object root_2 = (object)adaptor.Nil(); DebugLocation(317, 55); root_2 = (object)adaptor.BecomeRoot((object)adaptor.Create(FUN_TYPE_WRAPPER, "FUN_TYPE_WRAPPER"), root_2); DebugLocation(317, 72); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:317:72: ( type_id )? if (stream_type_id.HasNext) { DebugLocation(317, 72); adaptor.AddChild(root_2, stream_type_id.NextTree()); } stream_type_id.Reset(); adaptor.AddChild(root_1, root_2); } DebugLocation(317, 82); adaptor.AddChild(root_1, stream_expr.NextTree()); adaptor.AddChild(root_0, root_1); } } retval.Tree = root_0; } } } retval.Stop = (IToken)input.LT(-1); if (state.backtracking == 0) { 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("fun_decl", 17); LeaveRule("fun_decl", 17); LeaveRule_fun_decl(); } DebugLocation(318, 1); } finally { DebugExitRule(GrammarFileName, "fun_decl"); } return retval; } // $ANTLR end "fun_decl" partial void EnterRule_type_id(); partial void LeaveRule_type_id(); // $ANTLR start "type_id" // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:320:1: type_id : ( STRINGKEY | INTKEY | ID ); [GrammarRule("type_id")] private AstParserRuleReturnScope type_id() { EnterRule_type_id(); EnterRule("type_id", 18); TraceIn("type_id", 18); AstParserRuleReturnScope retval = new AstParserRuleReturnScope(); retval.Start = (IToken)input.LT(1); object root_0 = default(object); IToken set79 = default(IToken); object set79_tree = default(object); try { DebugEnterRule(GrammarFileName, "type_id"); DebugLocation(320, 1); try { // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:321:2: ( STRINGKEY | INTKEY | ID ) DebugEnterAlt(1); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g: { root_0 = (object)adaptor.Nil(); DebugLocation(321, 2); set79=(IToken)input.LT(1); if (input.LA(1)==ID||input.LA(1)==INTKEY||input.LA(1)==STRINGKEY) { input.Consume(); if (state.backtracking == 0) adaptor.AddChild(root_0, (object)adaptor.Create(set79)); state.errorRecovery=false;state.failed=false; } else { if (state.backtracking>0) {state.failed=true; return retval;} MismatchedSetException mse = new MismatchedSetException(null,input); DebugRecognitionException(mse); throw mse; } } retval.Stop = (IToken)input.LT(-1); if (state.backtracking == 0) { 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("type_id", 18); LeaveRule("type_id", 18); LeaveRule_type_id(); } DebugLocation(324, 1); } finally { DebugExitRule(GrammarFileName, "type_id"); } return retval; } // $ANTLR end "type_id" partial void EnterRule_type(); partial void LeaveRule_type(); // $ANTLR start "type" // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:326:1: type : ( type_id -> ^( ALIAS_DECL type_id ) | array_decl | record_decl ); [GrammarRule("type")] private AstParserRuleReturnScope type() { EnterRule_type(); EnterRule("type", 19); TraceIn("type", 19); AstParserRuleReturnScope retval = new AstParserRuleReturnScope(); retval.Start = (IToken)input.LT(1); object root_0 = default(object); AstParserRuleReturnScope type_id80 = default(AstParserRuleReturnScope); AstParserRuleReturnScope array_decl81 = default(AstParserRuleReturnScope); AstParserRuleReturnScope record_decl82 = default(AstParserRuleReturnScope); RewriteRuleSubtreeStream stream_type_id=new RewriteRuleSubtreeStream(adaptor,"rule type_id"); try { DebugEnterRule(GrammarFileName, "type"); DebugLocation(326, 1); try { // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:327:2: ( type_id -> ^( ALIAS_DECL type_id ) | array_decl | record_decl ) int alt17=3; try { DebugEnterDecision(17, false); switch (input.LA(1)) { case ID: case INTKEY: case STRINGKEY: { alt17 = 1; } break; case ARRAYKEY: { alt17 = 2; } break; case LKEY: { alt17 = 3; } break; default: { if (state.backtracking>0) {state.failed=true; return retval;} NoViableAltException nvae = new NoViableAltException("", 17, 0, input); DebugRecognitionException(nvae); throw nvae; } } } finally { DebugExitDecision(17); } switch (alt17) { case 1: DebugEnterAlt(1); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:327:4: type_id { DebugLocation(327, 4); PushFollow(Follow._type_id_in_type1834); type_id80=type_id(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) stream_type_id.Add(type_id80.Tree); { // AST REWRITE // elements: type_id // 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 = (object)adaptor.Nil(); // 328:13: -> ^( ALIAS_DECL type_id ) { DebugLocation(328, 16); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:328:16: ^( ALIAS_DECL type_id ) { object root_1 = (object)adaptor.Nil(); DebugLocation(328, 18); root_1 = (object)adaptor.BecomeRoot((object)adaptor.Create(ALIAS_DECL, "ALIAS_DECL"), root_1); DebugLocation(328, 29); adaptor.AddChild(root_1, stream_type_id.NextTree()); adaptor.AddChild(root_0, root_1); } } retval.Tree = root_0; } } } break; case 2: DebugEnterAlt(2); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:329:4: array_decl { root_0 = (object)adaptor.Nil(); DebugLocation(329, 4); PushFollow(Follow._array_decl_in_type1859); array_decl81=array_decl(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) adaptor.AddChild(root_0, array_decl81.Tree); } break; case 3: DebugEnterAlt(3); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:330:4: record_decl { root_0 = (object)adaptor.Nil(); DebugLocation(330, 4); PushFollow(Follow._record_decl_in_type1865); record_decl82=record_decl(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) adaptor.AddChild(root_0, record_decl82.Tree); } break; } retval.Stop = (IToken)input.LT(-1); if (state.backtracking == 0) { 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("type", 19); LeaveRule("type", 19); LeaveRule_type(); } DebugLocation(331, 1); } finally { DebugExitRule(GrammarFileName, "type"); } return retval; } // $ANTLR end "type" partial void EnterRule_record_decl(); partial void LeaveRule_record_decl(); // $ANTLR start "record_decl" // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:333:1: record_decl : LKEY ( type_fields )? RKEY -> ^( RECORD_DECL ( type_fields )? ) ; [GrammarRule("record_decl")] private AstParserRuleReturnScope record_decl() { EnterRule_record_decl(); EnterRule("record_decl", 20); TraceIn("record_decl", 20); AstParserRuleReturnScope retval = new AstParserRuleReturnScope(); retval.Start = (IToken)input.LT(1); object root_0 = default(object); IToken LKEY83 = default(IToken); IToken RKEY85 = default(IToken); AstParserRuleReturnScope type_fields84 = default(AstParserRuleReturnScope); object LKEY83_tree = default(object); object RKEY85_tree = default(object); RewriteRuleITokenStream stream_LKEY=new RewriteRuleITokenStream(adaptor,"token LKEY"); RewriteRuleITokenStream stream_RKEY=new RewriteRuleITokenStream(adaptor,"token RKEY"); RewriteRuleSubtreeStream stream_type_fields=new RewriteRuleSubtreeStream(adaptor,"rule type_fields"); try { DebugEnterRule(GrammarFileName, "record_decl"); DebugLocation(333, 1); try { // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:334:2: ( LKEY ( type_fields )? RKEY -> ^( RECORD_DECL ( type_fields )? ) ) DebugEnterAlt(1); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:334:4: LKEY ( type_fields )? RKEY { DebugLocation(334, 4); LKEY83=(IToken)Match(input,LKEY,Follow._LKEY_in_record_decl1876); if (state.failed) return retval; if (state.backtracking == 0) stream_LKEY.Add(LKEY83); DebugLocation(334, 9); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:334:9: ( type_fields )? int alt18=2; try { DebugEnterSubRule(18); try { DebugEnterDecision(18, false); int LA18_0 = input.LA(1); if ((LA18_0==ID||LA18_0==INTKEY||LA18_0==STRINGKEY)) { alt18 = 1; } } finally { DebugExitDecision(18); } switch (alt18) { case 1: DebugEnterAlt(1); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:334:9: type_fields { DebugLocation(334, 9); PushFollow(Follow._type_fields_in_record_decl1878); type_fields84=type_fields(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) stream_type_fields.Add(type_fields84.Tree); } break; } } finally { DebugExitSubRule(18); } DebugLocation(334, 22); RKEY85=(IToken)Match(input,RKEY,Follow._RKEY_in_record_decl1881); if (state.failed) return retval; if (state.backtracking == 0) stream_RKEY.Add(RKEY85); { // AST REWRITE // elements: type_fields // 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 = (object)adaptor.Nil(); // 335:4: -> ^( RECORD_DECL ( type_fields )? ) { DebugLocation(335, 7); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:335:7: ^( RECORD_DECL ( type_fields )? ) { object root_1 = (object)adaptor.Nil(); DebugLocation(335, 9); root_1 = (object)adaptor.BecomeRoot((object)adaptor.Create(RECORD_DECL, "RECORD_DECL"), root_1); DebugLocation(335, 21); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:335:21: ( type_fields )? if (stream_type_fields.HasNext) { DebugLocation(335, 21); adaptor.AddChild(root_1, stream_type_fields.NextTree()); } stream_type_fields.Reset(); adaptor.AddChild(root_0, root_1); } } retval.Tree = root_0; } } } retval.Stop = (IToken)input.LT(-1); if (state.backtracking == 0) { 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("record_decl", 20); LeaveRule("record_decl", 20); LeaveRule_record_decl(); } DebugLocation(336, 1); } finally { DebugExitRule(GrammarFileName, "record_decl"); } return retval; } // $ANTLR end "record_decl" partial void EnterRule_array_decl(); partial void LeaveRule_array_decl(); // $ANTLR start "array_decl" // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:338:1: array_decl : ARRAYKEY OFKEY type_id -> ^( ARRAY_DECL type_id ) ; [GrammarRule("array_decl")] private AstParserRuleReturnScope array_decl() { EnterRule_array_decl(); EnterRule("array_decl", 21); TraceIn("array_decl", 21); AstParserRuleReturnScope retval = new AstParserRuleReturnScope(); retval.Start = (IToken)input.LT(1); object root_0 = default(object); IToken ARRAYKEY86 = default(IToken); IToken OFKEY87 = default(IToken); AstParserRuleReturnScope type_id88 = default(AstParserRuleReturnScope); object ARRAYKEY86_tree = default(object); object OFKEY87_tree = default(object); RewriteRuleITokenStream stream_ARRAYKEY=new RewriteRuleITokenStream(adaptor,"token ARRAYKEY"); RewriteRuleITokenStream stream_OFKEY=new RewriteRuleITokenStream(adaptor,"token OFKEY"); RewriteRuleSubtreeStream stream_type_id=new RewriteRuleSubtreeStream(adaptor,"rule type_id"); try { DebugEnterRule(GrammarFileName, "array_decl"); DebugLocation(338, 1); try { // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:339:2: ( ARRAYKEY OFKEY type_id -> ^( ARRAY_DECL type_id ) ) DebugEnterAlt(1); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:339:4: ARRAYKEY OFKEY type_id { DebugLocation(339, 4); ARRAYKEY86=(IToken)Match(input,ARRAYKEY,Follow._ARRAYKEY_in_array_decl1904); if (state.failed) return retval; if (state.backtracking == 0) stream_ARRAYKEY.Add(ARRAYKEY86); DebugLocation(339, 13); OFKEY87=(IToken)Match(input,OFKEY,Follow._OFKEY_in_array_decl1906); if (state.failed) return retval; if (state.backtracking == 0) stream_OFKEY.Add(OFKEY87); DebugLocation(339, 19); PushFollow(Follow._type_id_in_array_decl1908); type_id88=type_id(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) stream_type_id.Add(type_id88.Tree); { // AST REWRITE // elements: type_id // 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 = (object)adaptor.Nil(); // 340:4: -> ^( ARRAY_DECL type_id ) { DebugLocation(340, 7); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:340:7: ^( ARRAY_DECL type_id ) { object root_1 = (object)adaptor.Nil(); DebugLocation(340, 9); root_1 = (object)adaptor.BecomeRoot((object)adaptor.Create(ARRAY_DECL, "ARRAY_DECL"), root_1); DebugLocation(340, 20); adaptor.AddChild(root_1, stream_type_id.NextTree()); adaptor.AddChild(root_0, root_1); } } retval.Tree = root_0; } } } retval.Stop = (IToken)input.LT(-1); if (state.backtracking == 0) { retval.Tree = (object)adaptor.RulePostProcessing(root_0); adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop); } } catch (RecognitionException re) { ReportError(re); Recover(input,re); retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re); } finally { TraceOut("array_decl", 21); LeaveRule("array_decl", 21); LeaveRule_array_decl(); } DebugLocation(341, 1); } finally { DebugExitRule(GrammarFileName, "array_decl"); } return retval; } // $ANTLR end "array_decl" partial void EnterRule_type_fields(); partial void LeaveRule_type_fields(); // $ANTLR start "type_fields" // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:343:1: type_fields : type_field ( COMMA type_field )* -> ( type_field )+ ; [GrammarRule("type_fields")] private AstParserRuleReturnScope type_fields() { EnterRule_type_fields(); EnterRule("type_fields", 22); TraceIn("type_fields", 22); AstParserRuleReturnScope retval = new AstParserRuleReturnScope(); retval.Start = (IToken)input.LT(1); object root_0 = default(object); IToken COMMA90 = default(IToken); AstParserRuleReturnScope type_field89 = default(AstParserRuleReturnScope); AstParserRuleReturnScope type_field91 = default(AstParserRuleReturnScope); object COMMA90_tree = default(object); RewriteRuleITokenStream stream_COMMA=new RewriteRuleITokenStream(adaptor,"token COMMA"); RewriteRuleSubtreeStream stream_type_field=new RewriteRuleSubtreeStream(adaptor,"rule type_field"); try { DebugEnterRule(GrammarFileName, "type_fields"); DebugLocation(343, 1); try { // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:344:2: ( type_field ( COMMA type_field )* -> ( type_field )+ ) DebugEnterAlt(1); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:344:4: type_field ( COMMA type_field )* { DebugLocation(344, 4); PushFollow(Follow._type_field_in_type_fields1931); type_field89=type_field(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) stream_type_field.Add(type_field89.Tree); DebugLocation(344, 15); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:344:15: ( COMMA type_field )* try { DebugEnterSubRule(19); while (true) { int alt19=2; try { DebugEnterDecision(19, false); int LA19_0 = input.LA(1); if ((LA19_0==COMMA)) { alt19 = 1; } } finally { DebugExitDecision(19); } switch ( alt19 ) { case 1: DebugEnterAlt(1); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:344:16: COMMA type_field { DebugLocation(344, 16); COMMA90=(IToken)Match(input,COMMA,Follow._COMMA_in_type_fields1934); if (state.failed) return retval; if (state.backtracking == 0) stream_COMMA.Add(COMMA90); DebugLocation(344, 22); PushFollow(Follow._type_field_in_type_fields1936); type_field91=type_field(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) stream_type_field.Add(type_field91.Tree); } break; default: goto loop19; } } loop19: ; } finally { DebugExitSubRule(19); } { // AST REWRITE // elements: type_field // 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 = (object)adaptor.Nil(); // 345:4: -> ( type_field )+ { DebugLocation(345, 7); if (!(stream_type_field.HasNext)) { throw new RewriteEarlyExitException(); } while ( stream_type_field.HasNext ) { DebugLocation(345, 7); adaptor.AddChild(root_0, stream_type_field.NextTree()); } stream_type_field.Reset(); } retval.Tree = root_0; } } } retval.Stop = (IToken)input.LT(-1); if (state.backtracking == 0) { 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("type_fields", 22); LeaveRule("type_fields", 22); LeaveRule_type_fields(); } DebugLocation(346, 1); } finally { DebugExitRule(GrammarFileName, "type_fields"); } return retval; } // $ANTLR end "type_fields" partial void EnterRule_type_field(); partial void LeaveRule_type_field(); // $ANTLR start "type_field" // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:348:1: type_field : type_id COLON type_id -> ^( TYPE_FIELD type_id type_id ) ; [GrammarRule("type_field")] private AstParserRuleReturnScope type_field() { EnterRule_type_field(); EnterRule("type_field", 23); TraceIn("type_field", 23); AstParserRuleReturnScope retval = new AstParserRuleReturnScope(); retval.Start = (IToken)input.LT(1); object root_0 = default(object); IToken COLON93 = default(IToken); AstParserRuleReturnScope type_id92 = default(AstParserRuleReturnScope); AstParserRuleReturnScope type_id94 = default(AstParserRuleReturnScope); object COLON93_tree = default(object); RewriteRuleITokenStream stream_COLON=new RewriteRuleITokenStream(adaptor,"token COLON"); RewriteRuleSubtreeStream stream_type_id=new RewriteRuleSubtreeStream(adaptor,"rule type_id"); try { DebugEnterRule(GrammarFileName, "type_field"); DebugLocation(348, 1); try { // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:349:2: ( type_id COLON type_id -> ^( TYPE_FIELD type_id type_id ) ) DebugEnterAlt(1); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:349:4: type_id COLON type_id { DebugLocation(349, 4); PushFollow(Follow._type_id_in_type_field1957); type_id92=type_id(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) stream_type_id.Add(type_id92.Tree); DebugLocation(349, 12); COLON93=(IToken)Match(input,COLON,Follow._COLON_in_type_field1959); if (state.failed) return retval; if (state.backtracking == 0) stream_COLON.Add(COLON93); DebugLocation(349, 18); PushFollow(Follow._type_id_in_type_field1961); type_id94=type_id(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) stream_type_id.Add(type_id94.Tree); { // AST REWRITE // elements: type_id, type_id // 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 = (object)adaptor.Nil(); // 350:4: -> ^( TYPE_FIELD type_id type_id ) { DebugLocation(350, 7); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:350:7: ^( TYPE_FIELD type_id type_id ) { object root_1 = (object)adaptor.Nil(); DebugLocation(350, 9); root_1 = (object)adaptor.BecomeRoot((object)adaptor.Create(TYPE_FIELD, "TYPE_FIELD"), root_1); DebugLocation(350, 20); adaptor.AddChild(root_1, stream_type_id.NextTree()); DebugLocation(350, 28); adaptor.AddChild(root_1, stream_type_id.NextTree()); adaptor.AddChild(root_0, root_1); } } retval.Tree = root_0; } } } retval.Stop = (IToken)input.LT(-1); if (state.backtracking == 0) { 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("type_field", 23); LeaveRule("type_field", 23); LeaveRule_type_field(); } DebugLocation(351, 1); } finally { DebugExitRule(GrammarFileName, "type_field"); } return retval; } // $ANTLR end "type_field" partial void EnterRule_atom(); partial void LeaveRule_atom(); // $ANTLR start "atom" // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:353:1: atom : ( MINUS atom -> ^( NEG atom ) | constant_value | lvalue | funcall | if_then_expr | for_expr | let_expr | LPAREN expr_seq RPAREN -> expr_seq ); [GrammarRule("atom")] private AstParserRuleReturnScope atom() { EnterRule_atom(); EnterRule("atom", 24); TraceIn("atom", 24); AstParserRuleReturnScope retval = new AstParserRuleReturnScope(); retval.Start = (IToken)input.LT(1); object root_0 = default(object); IToken MINUS95 = default(IToken); IToken LPAREN103 = default(IToken); IToken RPAREN105 = default(IToken); AstParserRuleReturnScope atom96 = default(AstParserRuleReturnScope); AstParserRuleReturnScope constant_value97 = default(AstParserRuleReturnScope); AstParserRuleReturnScope lvalue98 = default(AstParserRuleReturnScope); AstParserRuleReturnScope funcall99 = default(AstParserRuleReturnScope); AstParserRuleReturnScope if_then_expr100 = default(AstParserRuleReturnScope); AstParserRuleReturnScope for_expr101 = default(AstParserRuleReturnScope); AstParserRuleReturnScope let_expr102 = default(AstParserRuleReturnScope); AstParserRuleReturnScope expr_seq104 = default(AstParserRuleReturnScope); object MINUS95_tree = default(object); object LPAREN103_tree = default(object); object RPAREN105_tree = default(object); RewriteRuleITokenStream stream_LPAREN=new RewriteRuleITokenStream(adaptor,"token LPAREN"); RewriteRuleITokenStream stream_RPAREN=new RewriteRuleITokenStream(adaptor,"token RPAREN"); RewriteRuleITokenStream stream_MINUS=new RewriteRuleITokenStream(adaptor,"token MINUS"); RewriteRuleSubtreeStream stream_expr_seq=new RewriteRuleSubtreeStream(adaptor,"rule expr_seq"); RewriteRuleSubtreeStream stream_atom=new RewriteRuleSubtreeStream(adaptor,"rule atom"); try { DebugEnterRule(GrammarFileName, "atom"); DebugLocation(353, 1); try { // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:354:2: ( MINUS atom -> ^( NEG atom ) | constant_value | lvalue | funcall | if_then_expr | for_expr | let_expr | LPAREN expr_seq RPAREN -> expr_seq ) int alt20=8; try { DebugEnterDecision(20, false); switch (input.LA(1)) { case MINUS: { alt20 = 1; } break; case INT: case NILKEY: case STRING: { alt20 = 2; } break; case ID: case INTKEY: case STRINGKEY: { int LA20_3 = input.LA(2); if ((LA20_3==EOF||LA20_3==AND||LA20_3==COMMA||(LA20_3>=DIV && LA20_3<=ENDKEY)||LA20_3==EQ||LA20_3==FUNCTIONKEY||(LA20_3>=GT && LA20_3<=GTEQ)||LA20_3==INKEY||LA20_3==LBRACKET||(LA20_3>=LT && LA20_3<=MULT)||LA20_3==NOTEQ||LA20_3==OR||LA20_3==PLUS||LA20_3==RBRACKET||(LA20_3>=RKEY && LA20_3<=SEMI)||(LA20_3>=THENKEY && LA20_3<=TOKEY)||LA20_3==TYPEKEY||LA20_3==VARKEY)) { alt20 = 3; } else if ((LA20_3==LPAREN)) { alt20 = 4; } else { if (state.backtracking>0) {state.failed=true; return retval;} NoViableAltException nvae = new NoViableAltException("", 20, 3, input); DebugRecognitionException(nvae); throw nvae; } } break; case IFKEY: { alt20 = 5; } break; case FORKEY: { alt20 = 6; } break; case LETKEY: { alt20 = 7; } break; case LPAREN: { alt20 = 8; } break; default: { if (state.backtracking>0) {state.failed=true; return retval;} NoViableAltException nvae = new NoViableAltException("", 20, 0, input); DebugRecognitionException(nvae); throw nvae; } } } finally { DebugExitDecision(20); } switch (alt20) { case 1: DebugEnterAlt(1); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:354:4: MINUS atom { DebugLocation(354, 4); MINUS95=(IToken)Match(input,MINUS,Follow._MINUS_in_atom1986); if (state.failed) return retval; if (state.backtracking == 0) stream_MINUS.Add(MINUS95); DebugLocation(354, 10); PushFollow(Follow._atom_in_atom1988); atom96=atom(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) stream_atom.Add(atom96.Tree); { // AST REWRITE // elements: atom // 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 = (object)adaptor.Nil(); // 355:13: -> ^( NEG atom ) { DebugLocation(355, 16); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:355:16: ^( NEG atom ) { object root_1 = (object)adaptor.Nil(); DebugLocation(355, 18); root_1 = (object)adaptor.BecomeRoot((object)adaptor.Create(NEG, "NEG"), root_1); DebugLocation(355, 22); adaptor.AddChild(root_1, stream_atom.NextTree()); adaptor.AddChild(root_0, root_1); } } retval.Tree = root_0; } } } break; case 2: DebugEnterAlt(2); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:356:4: constant_value { root_0 = (object)adaptor.Nil(); DebugLocation(356, 4); PushFollow(Follow._constant_value_in_atom2013); constant_value97=constant_value(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) adaptor.AddChild(root_0, constant_value97.Tree); } break; case 3: DebugEnterAlt(3); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:357:4: lvalue { root_0 = (object)adaptor.Nil(); DebugLocation(357, 4); PushFollow(Follow._lvalue_in_atom2018); lvalue98=lvalue(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) adaptor.AddChild(root_0, lvalue98.Tree); } break; case 4: DebugEnterAlt(4); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:358:4: funcall { root_0 = (object)adaptor.Nil(); DebugLocation(358, 4); PushFollow(Follow._funcall_in_atom2023); funcall99=funcall(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) adaptor.AddChild(root_0, funcall99.Tree); } break; case 5: DebugEnterAlt(5); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:359:4: if_then_expr { root_0 = (object)adaptor.Nil(); DebugLocation(359, 4); PushFollow(Follow._if_then_expr_in_atom2028); if_then_expr100=if_then_expr(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) adaptor.AddChild(root_0, if_then_expr100.Tree); } break; case 6: DebugEnterAlt(6); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:360:4: for_expr { root_0 = (object)adaptor.Nil(); DebugLocation(360, 4); PushFollow(Follow._for_expr_in_atom2033); for_expr101=for_expr(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) adaptor.AddChild(root_0, for_expr101.Tree); } break; case 7: DebugEnterAlt(7); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:361:4: let_expr { root_0 = (object)adaptor.Nil(); DebugLocation(361, 4); PushFollow(Follow._let_expr_in_atom2038); let_expr102=let_expr(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) adaptor.AddChild(root_0, let_expr102.Tree); } break; case 8: DebugEnterAlt(8); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:362:4: LPAREN expr_seq RPAREN { DebugLocation(362, 4); LPAREN103=(IToken)Match(input,LPAREN,Follow._LPAREN_in_atom2043); if (state.failed) return retval; if (state.backtracking == 0) stream_LPAREN.Add(LPAREN103); DebugLocation(362, 11); PushFollow(Follow._expr_seq_in_atom2045); expr_seq104=expr_seq(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) stream_expr_seq.Add(expr_seq104.Tree); DebugLocation(362, 20); RPAREN105=(IToken)Match(input,RPAREN,Follow._RPAREN_in_atom2047); if (state.failed) return retval; if (state.backtracking == 0) stream_RPAREN.Add(RPAREN105); { // AST REWRITE // elements: expr_seq // 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 = (object)adaptor.Nil(); // 363:4: -> expr_seq { DebugLocation(363, 7); adaptor.AddChild(root_0, stream_expr_seq.NextTree()); } retval.Tree = root_0; } } } break; } retval.Stop = (IToken)input.LT(-1); if (state.backtracking == 0) { retval.Tree = (object)adaptor.RulePostProcessing(root_0); adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop); } } catch (RecognitionException re) { ReportError(re); Recover(input,re); retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re); } finally { TraceOut("atom", 24); LeaveRule("atom", 24); LeaveRule_atom(); } DebugLocation(364, 1); } finally { DebugExitRule(GrammarFileName, "atom"); } return retval; } // $ANTLR end "atom" partial void EnterRule_constant_value(); partial void LeaveRule_constant_value(); // $ANTLR start "constant_value" // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:366:1: constant_value : ( STRING | INT | NILKEY ); [GrammarRule("constant_value")] private AstParserRuleReturnScope constant_value() { EnterRule_constant_value(); EnterRule("constant_value", 25); TraceIn("constant_value", 25); AstParserRuleReturnScope retval = new AstParserRuleReturnScope(); retval.Start = (IToken)input.LT(1); object root_0 = default(object); IToken set106 = default(IToken); object set106_tree = default(object); try { DebugEnterRule(GrammarFileName, "constant_value"); DebugLocation(366, 1); try { // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:367:2: ( STRING | INT | NILKEY ) DebugEnterAlt(1); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g: { root_0 = (object)adaptor.Nil(); DebugLocation(367, 2); set106=(IToken)input.LT(1); if (input.LA(1)==INT||input.LA(1)==NILKEY||input.LA(1)==STRING) { input.Consume(); if (state.backtracking == 0) adaptor.AddChild(root_0, (object)adaptor.Create(set106)); state.errorRecovery=false;state.failed=false; } else { if (state.backtracking>0) {state.failed=true; return retval;} MismatchedSetException mse = new MismatchedSetException(null,input); DebugRecognitionException(mse); throw mse; } } retval.Stop = (IToken)input.LT(-1); if (state.backtracking == 0) { 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("constant_value", 25); LeaveRule("constant_value", 25); LeaveRule_constant_value(); } DebugLocation(370, 1); } finally { DebugExitRule(GrammarFileName, "constant_value"); } return retval; } // $ANTLR end "constant_value" partial void EnterRule_if_then_expr(); partial void LeaveRule_if_then_expr(); // $ANTLR start "if_then_expr" // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:372:1: if_then_expr : IFKEY conditional= disjunction_expr THENKEY then_expr= expr ( ELSEKEY else_expr= expr )? -> ^( IF $conditional $then_expr ( $else_expr)? ) ; [GrammarRule("if_then_expr")] private AstParserRuleReturnScope if_then_expr() { EnterRule_if_then_expr(); EnterRule("if_then_expr", 26); TraceIn("if_then_expr", 26); AstParserRuleReturnScope retval = new AstParserRuleReturnScope(); retval.Start = (IToken)input.LT(1); object root_0 = default(object); IToken IFKEY107 = default(IToken); IToken THENKEY108 = default(IToken); IToken ELSEKEY109 = default(IToken); AstParserRuleReturnScope conditional = default(AstParserRuleReturnScope); AstParserRuleReturnScope then_expr = default(AstParserRuleReturnScope); AstParserRuleReturnScope else_expr = default(AstParserRuleReturnScope); object IFKEY107_tree = default(object); object THENKEY108_tree = default(object); object ELSEKEY109_tree = default(object); RewriteRuleITokenStream stream_ELSEKEY=new RewriteRuleITokenStream(adaptor,"token ELSEKEY"); RewriteRuleITokenStream stream_IFKEY=new RewriteRuleITokenStream(adaptor,"token IFKEY"); RewriteRuleITokenStream stream_THENKEY=new RewriteRuleITokenStream(adaptor,"token THENKEY"); RewriteRuleSubtreeStream stream_disjunction_expr=new RewriteRuleSubtreeStream(adaptor,"rule disjunction_expr"); RewriteRuleSubtreeStream stream_expr=new RewriteRuleSubtreeStream(adaptor,"rule expr"); try { DebugEnterRule(GrammarFileName, "if_then_expr"); DebugLocation(372, 1); try { // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:373:2: ( IFKEY conditional= disjunction_expr THENKEY then_expr= expr ( ELSEKEY else_expr= expr )? -> ^( IF $conditional $then_expr ( $else_expr)? ) ) DebugEnterAlt(1); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:373:4: IFKEY conditional= disjunction_expr THENKEY then_expr= expr ( ELSEKEY else_expr= expr )? { DebugLocation(373, 4); IFKEY107=(IToken)Match(input,IFKEY,Follow._IFKEY_in_if_then_expr2086); if (state.failed) return retval; if (state.backtracking == 0) stream_IFKEY.Add(IFKEY107); DebugLocation(373, 21); PushFollow(Follow._disjunction_expr_in_if_then_expr2090); conditional=disjunction_expr(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) stream_disjunction_expr.Add(conditional.Tree); DebugLocation(373, 39); THENKEY108=(IToken)Match(input,THENKEY,Follow._THENKEY_in_if_then_expr2092); if (state.failed) return retval; if (state.backtracking == 0) stream_THENKEY.Add(THENKEY108); DebugLocation(373, 56); PushFollow(Follow._expr_in_if_then_expr2096); then_expr=expr(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) stream_expr.Add(then_expr.Tree); DebugLocation(373, 62); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:373:62: ( ELSEKEY else_expr= expr )? int alt21=2; try { DebugEnterSubRule(21); try { DebugEnterDecision(21, false); int LA21_0 = input.LA(1); if ((LA21_0==ELSEKEY)) { alt21 = 1; } } finally { DebugExitDecision(21); } switch (alt21) { case 1: DebugEnterAlt(1); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:373:63: ELSEKEY else_expr= expr { DebugLocation(373, 63); ELSEKEY109=(IToken)Match(input,ELSEKEY,Follow._ELSEKEY_in_if_then_expr2099); if (state.failed) return retval; if (state.backtracking == 0) stream_ELSEKEY.Add(ELSEKEY109); DebugLocation(373, 80); PushFollow(Follow._expr_in_if_then_expr2103); else_expr=expr(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) stream_expr.Add(else_expr.Tree); } break; } } finally { DebugExitSubRule(21); } { // AST REWRITE // elements: else_expr, conditional, then_expr // token labels: // rule labels: else_expr, conditional, then_expr, retval // token list labels: // rule list labels: // wildcard labels: if (state.backtracking == 0) { retval.Tree = root_0; RewriteRuleSubtreeStream stream_else_expr=new RewriteRuleSubtreeStream(adaptor,"rule else_expr",else_expr!=null?else_expr.Tree:null); RewriteRuleSubtreeStream stream_conditional=new RewriteRuleSubtreeStream(adaptor,"rule conditional",conditional!=null?conditional.Tree:null); RewriteRuleSubtreeStream stream_then_expr=new RewriteRuleSubtreeStream(adaptor,"rule then_expr",then_expr!=null?then_expr.Tree:null); RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.Tree:null); root_0 = (object)adaptor.Nil(); // 374:4: -> ^( IF $conditional $then_expr ( $else_expr)? ) { DebugLocation(374, 7); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:374:7: ^( IF $conditional $then_expr ( $else_expr)? ) { object root_1 = (object)adaptor.Nil(); DebugLocation(374, 9); root_1 = (object)adaptor.BecomeRoot((object)adaptor.Create(IF, "IF"), root_1); DebugLocation(374, 13); adaptor.AddChild(root_1, stream_conditional.NextTree()); DebugLocation(374, 26); adaptor.AddChild(root_1, stream_then_expr.NextTree()); DebugLocation(374, 37); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:374:37: ( $else_expr)? if (stream_else_expr.HasNext) { DebugLocation(374, 37); adaptor.AddChild(root_1, stream_else_expr.NextTree()); } stream_else_expr.Reset(); adaptor.AddChild(root_0, root_1); } } retval.Tree = root_0; } } } retval.Stop = (IToken)input.LT(-1); if (state.backtracking == 0) { 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("if_then_expr", 26); LeaveRule("if_then_expr", 26); LeaveRule_if_then_expr(); } DebugLocation(375, 1); } finally { DebugExitRule(GrammarFileName, "if_then_expr"); } return retval; } // $ANTLR end "if_then_expr" partial void EnterRule_while_stat(); partial void LeaveRule_while_stat(); // $ANTLR start "while_stat" // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:377:1: while_stat : WHILEKEY cond= disjunction_expr DOKEY do_expr= expr -> ^( WHILE $cond $do_expr) ; [GrammarRule("while_stat")] private AstParserRuleReturnScope while_stat() { EnterRule_while_stat(); EnterRule("while_stat", 27); TraceIn("while_stat", 27); AstParserRuleReturnScope retval = new AstParserRuleReturnScope(); retval.Start = (IToken)input.LT(1); object root_0 = default(object); IToken WHILEKEY110 = default(IToken); IToken DOKEY111 = default(IToken); AstParserRuleReturnScope cond = default(AstParserRuleReturnScope); AstParserRuleReturnScope do_expr = default(AstParserRuleReturnScope); object WHILEKEY110_tree = default(object); object DOKEY111_tree = default(object); RewriteRuleITokenStream stream_WHILEKEY=new RewriteRuleITokenStream(adaptor,"token WHILEKEY"); RewriteRuleITokenStream stream_DOKEY=new RewriteRuleITokenStream(adaptor,"token DOKEY"); RewriteRuleSubtreeStream stream_disjunction_expr=new RewriteRuleSubtreeStream(adaptor,"rule disjunction_expr"); RewriteRuleSubtreeStream stream_expr=new RewriteRuleSubtreeStream(adaptor,"rule expr"); try { DebugEnterRule(GrammarFileName, "while_stat"); DebugLocation(377, 1); try { // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:378:2: ( WHILEKEY cond= disjunction_expr DOKEY do_expr= expr -> ^( WHILE $cond $do_expr) ) DebugEnterAlt(1); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:378:4: WHILEKEY cond= disjunction_expr DOKEY do_expr= expr { DebugLocation(378, 4); WHILEKEY110=(IToken)Match(input,WHILEKEY,Follow._WHILEKEY_in_while_stat2136); if (state.failed) return retval; if (state.backtracking == 0) stream_WHILEKEY.Add(WHILEKEY110); DebugLocation(378, 17); PushFollow(Follow._disjunction_expr_in_while_stat2140); cond=disjunction_expr(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) stream_disjunction_expr.Add(cond.Tree); DebugLocation(378, 35); DOKEY111=(IToken)Match(input,DOKEY,Follow._DOKEY_in_while_stat2142); if (state.failed) return retval; if (state.backtracking == 0) stream_DOKEY.Add(DOKEY111); DebugLocation(378, 48); PushFollow(Follow._expr_in_while_stat2146); do_expr=expr(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) stream_expr.Add(do_expr.Tree); { // AST REWRITE // elements: cond, do_expr // token labels: // rule labels: do_expr, cond, retval // token list labels: // rule list labels: // wildcard labels: if (state.backtracking == 0) { retval.Tree = root_0; RewriteRuleSubtreeStream stream_do_expr=new RewriteRuleSubtreeStream(adaptor,"rule do_expr",do_expr!=null?do_expr.Tree:null); RewriteRuleSubtreeStream stream_cond=new RewriteRuleSubtreeStream(adaptor,"rule cond",cond!=null?cond.Tree:null); RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.Tree:null); root_0 = (object)adaptor.Nil(); // 379:4: -> ^( WHILE $cond $do_expr) { DebugLocation(379, 7); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:379:7: ^( WHILE $cond $do_expr) { object root_1 = (object)adaptor.Nil(); DebugLocation(379, 9); root_1 = (object)adaptor.BecomeRoot((object)adaptor.Create(WHILE, "WHILE"), root_1); DebugLocation(379, 16); adaptor.AddChild(root_1, stream_cond.NextTree()); DebugLocation(379, 22); adaptor.AddChild(root_1, stream_do_expr.NextTree()); adaptor.AddChild(root_0, root_1); } } retval.Tree = root_0; } } } retval.Stop = (IToken)input.LT(-1); if (state.backtracking == 0) { 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("while_stat", 27); LeaveRule("while_stat", 27); LeaveRule_while_stat(); } DebugLocation(380, 1); } finally { DebugExitRule(GrammarFileName, "while_stat"); } return retval; } // $ANTLR end "while_stat" partial void EnterRule_let_expr(); partial void LeaveRule_let_expr(); // $ANTLR start "let_expr" // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:382:1: let_expr : LETKEY ( decl )+ INKEY expr_seq ENDKEY -> ^( LET ^( DECL_BLOCK ( decl )+ ) expr_seq ) ; [GrammarRule("let_expr")] private AstParserRuleReturnScope let_expr() { EnterRule_let_expr(); EnterRule("let_expr", 28); TraceIn("let_expr", 28); AstParserRuleReturnScope retval = new AstParserRuleReturnScope(); retval.Start = (IToken)input.LT(1); object root_0 = default(object); IToken LETKEY112 = default(IToken); IToken INKEY114 = default(IToken); IToken ENDKEY116 = default(IToken); AstParserRuleReturnScope decl113 = default(AstParserRuleReturnScope); AstParserRuleReturnScope expr_seq115 = default(AstParserRuleReturnScope); object LETKEY112_tree = default(object); object INKEY114_tree = default(object); object ENDKEY116_tree = default(object); RewriteRuleITokenStream stream_INKEY=new RewriteRuleITokenStream(adaptor,"token INKEY"); RewriteRuleITokenStream stream_LETKEY=new RewriteRuleITokenStream(adaptor,"token LETKEY"); RewriteRuleITokenStream stream_ENDKEY=new RewriteRuleITokenStream(adaptor,"token ENDKEY"); RewriteRuleSubtreeStream stream_expr_seq=new RewriteRuleSubtreeStream(adaptor,"rule expr_seq"); RewriteRuleSubtreeStream stream_decl=new RewriteRuleSubtreeStream(adaptor,"rule decl"); try { DebugEnterRule(GrammarFileName, "let_expr"); DebugLocation(382, 1); try { // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:383:2: ( LETKEY ( decl )+ INKEY expr_seq ENDKEY -> ^( LET ^( DECL_BLOCK ( decl )+ ) expr_seq ) ) DebugEnterAlt(1); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:383:4: LETKEY ( decl )+ INKEY expr_seq ENDKEY { DebugLocation(383, 4); LETKEY112=(IToken)Match(input,LETKEY,Follow._LETKEY_in_let_expr2172); if (state.failed) return retval; if (state.backtracking == 0) stream_LETKEY.Add(LETKEY112); DebugLocation(383, 11); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:383:11: ( decl )+ int cnt22=0; try { DebugEnterSubRule(22); while (true) { int alt22=2; try { DebugEnterDecision(22, false); int LA22_0 = input.LA(1); if ((LA22_0==FUNCTIONKEY||LA22_0==TYPEKEY||LA22_0==VARKEY)) { alt22 = 1; } } finally { DebugExitDecision(22); } switch (alt22) { case 1: DebugEnterAlt(1); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:383:11: decl { DebugLocation(383, 11); PushFollow(Follow._decl_in_let_expr2174); decl113=decl(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) stream_decl.Add(decl113.Tree); } break; default: if (cnt22 >= 1) goto loop22; if (state.backtracking>0) {state.failed=true; return retval;} EarlyExitException eee22 = new EarlyExitException( 22, input ); DebugRecognitionException(eee22); throw eee22; } cnt22++; } loop22: ; } finally { DebugExitSubRule(22); } DebugLocation(383, 17); INKEY114=(IToken)Match(input,INKEY,Follow._INKEY_in_let_expr2177); if (state.failed) return retval; if (state.backtracking == 0) stream_INKEY.Add(INKEY114); DebugLocation(383, 23); PushFollow(Follow._expr_seq_in_let_expr2179); expr_seq115=expr_seq(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) stream_expr_seq.Add(expr_seq115.Tree); DebugLocation(383, 32); ENDKEY116=(IToken)Match(input,ENDKEY,Follow._ENDKEY_in_let_expr2181); if (state.failed) return retval; if (state.backtracking == 0) stream_ENDKEY.Add(ENDKEY116); { // AST REWRITE // elements: expr_seq, decl // 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 = (object)adaptor.Nil(); // 384:4: -> ^( LET ^( DECL_BLOCK ( decl )+ ) expr_seq ) { DebugLocation(384, 7); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:384:7: ^( LET ^( DECL_BLOCK ( decl )+ ) expr_seq ) { object root_1 = (object)adaptor.Nil(); DebugLocation(384, 9); root_1 = (object)adaptor.BecomeRoot((object)adaptor.Create(LET, "LET"), root_1); DebugLocation(384, 13); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:384:13: ^( DECL_BLOCK ( decl )+ ) { object root_2 = (object)adaptor.Nil(); DebugLocation(384, 15); root_2 = (object)adaptor.BecomeRoot((object)adaptor.Create(DECL_BLOCK, "DECL_BLOCK"), root_2); DebugLocation(384, 26); if (!(stream_decl.HasNext)) { throw new RewriteEarlyExitException(); } while ( stream_decl.HasNext ) { DebugLocation(384, 26); adaptor.AddChild(root_2, stream_decl.NextTree()); } stream_decl.Reset(); adaptor.AddChild(root_1, root_2); } DebugLocation(384, 33); adaptor.AddChild(root_1, stream_expr_seq.NextTree()); adaptor.AddChild(root_0, root_1); } } retval.Tree = root_0; } } } retval.Stop = (IToken)input.LT(-1); if (state.backtracking == 0) { 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("let_expr", 28); LeaveRule("let_expr", 28); LeaveRule_let_expr(); } DebugLocation(385, 1); } finally { DebugExitRule(GrammarFileName, "let_expr"); } return retval; } // $ANTLR end "let_expr" partial void EnterRule_lvalue(); partial void LeaveRule_lvalue(); // $ANTLR start "lvalue" // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:387:1: lvalue : type_id ( lvalue_access )? -> ^( VAR_ACCESS type_id ( lvalue_access )? ) ; [GrammarRule("lvalue")] private AstParserRuleReturnScope lvalue() { EnterRule_lvalue(); EnterRule("lvalue", 29); TraceIn("lvalue", 29); AstParserRuleReturnScope retval = new AstParserRuleReturnScope(); retval.Start = (IToken)input.LT(1); object root_0 = default(object); AstParserRuleReturnScope type_id117 = default(AstParserRuleReturnScope); AstParserRuleReturnScope lvalue_access118 = default(AstParserRuleReturnScope); RewriteRuleSubtreeStream stream_type_id=new RewriteRuleSubtreeStream(adaptor,"rule type_id"); RewriteRuleSubtreeStream stream_lvalue_access=new RewriteRuleSubtreeStream(adaptor,"rule lvalue_access"); try { DebugEnterRule(GrammarFileName, "lvalue"); DebugLocation(387, 1); try { // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:388:2: ( type_id ( lvalue_access )? -> ^( VAR_ACCESS type_id ( lvalue_access )? ) ) DebugEnterAlt(1); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:388:4: type_id ( lvalue_access )? { DebugLocation(388, 4); PushFollow(Follow._type_id_in_lvalue2211); type_id117=type_id(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) stream_type_id.Add(type_id117.Tree); DebugLocation(388, 12); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:388:12: ( lvalue_access )? int alt23=2; try { DebugEnterSubRule(23); try { DebugEnterDecision(23, false); int LA23_0 = input.LA(1); if ((LA23_0==DOT||LA23_0==LBRACKET)) { alt23 = 1; } } finally { DebugExitDecision(23); } switch (alt23) { case 1: DebugEnterAlt(1); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:388:12: lvalue_access { DebugLocation(388, 12); PushFollow(Follow._lvalue_access_in_lvalue2213); lvalue_access118=lvalue_access(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) stream_lvalue_access.Add(lvalue_access118.Tree); } break; } } finally { DebugExitSubRule(23); } { // AST REWRITE // elements: lvalue_access, type_id // 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 = (object)adaptor.Nil(); // 388:27: -> ^( VAR_ACCESS type_id ( lvalue_access )? ) { DebugLocation(388, 30); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:388:30: ^( VAR_ACCESS type_id ( lvalue_access )? ) { object root_1 = (object)adaptor.Nil(); DebugLocation(388, 32); root_1 = (object)adaptor.BecomeRoot((object)adaptor.Create(VAR_ACCESS, "VAR_ACCESS"), root_1); DebugLocation(388, 43); adaptor.AddChild(root_1, stream_type_id.NextTree()); DebugLocation(388, 51); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:388:51: ( lvalue_access )? if (stream_lvalue_access.HasNext) { DebugLocation(388, 51); adaptor.AddChild(root_1, stream_lvalue_access.NextTree()); } stream_lvalue_access.Reset(); adaptor.AddChild(root_0, root_1); } } retval.Tree = root_0; } } } retval.Stop = (IToken)input.LT(-1); if (state.backtracking == 0) { 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("lvalue", 29); LeaveRule("lvalue", 29); LeaveRule_lvalue(); } DebugLocation(389, 1); } finally { DebugExitRule(GrammarFileName, "lvalue"); } return retval; } // $ANTLR end "lvalue" partial void EnterRule_lvalue_access(); partial void LeaveRule_lvalue_access(); // $ANTLR start "lvalue_access" // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:391:1: lvalue_access : ( DOT type_id ( lvalue_access )? -> ^( FIELD_ACCESS type_id ( lvalue_access )? ) | LBRACKET disjunction_expr RBRACKET ( lvalue_access )? -> ^( ARRAY_ACCESS disjunction_expr ( lvalue_access )? ) ); [GrammarRule("lvalue_access")] private AstParserRuleReturnScope lvalue_access() { EnterRule_lvalue_access(); EnterRule("lvalue_access", 30); TraceIn("lvalue_access", 30); AstParserRuleReturnScope retval = new AstParserRuleReturnScope(); retval.Start = (IToken)input.LT(1); object root_0 = default(object); IToken DOT119 = default(IToken); IToken LBRACKET122 = default(IToken); IToken RBRACKET124 = default(IToken); AstParserRuleReturnScope type_id120 = default(AstParserRuleReturnScope); AstParserRuleReturnScope lvalue_access121 = default(AstParserRuleReturnScope); AstParserRuleReturnScope disjunction_expr123 = default(AstParserRuleReturnScope); AstParserRuleReturnScope lvalue_access125 = default(AstParserRuleReturnScope); object DOT119_tree = default(object); object LBRACKET122_tree = default(object); object RBRACKET124_tree = default(object); RewriteRuleITokenStream stream_DOT=new RewriteRuleITokenStream(adaptor,"token DOT"); RewriteRuleITokenStream stream_LBRACKET=new RewriteRuleITokenStream(adaptor,"token LBRACKET"); RewriteRuleITokenStream stream_RBRACKET=new RewriteRuleITokenStream(adaptor,"token RBRACKET"); RewriteRuleSubtreeStream stream_type_id=new RewriteRuleSubtreeStream(adaptor,"rule type_id"); RewriteRuleSubtreeStream stream_disjunction_expr=new RewriteRuleSubtreeStream(adaptor,"rule disjunction_expr"); RewriteRuleSubtreeStream stream_lvalue_access=new RewriteRuleSubtreeStream(adaptor,"rule lvalue_access"); try { DebugEnterRule(GrammarFileName, "lvalue_access"); DebugLocation(391, 1); try { // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:392:2: ( DOT type_id ( lvalue_access )? -> ^( FIELD_ACCESS type_id ( lvalue_access )? ) | LBRACKET disjunction_expr RBRACKET ( lvalue_access )? -> ^( ARRAY_ACCESS disjunction_expr ( lvalue_access )? ) ) int alt26=2; try { DebugEnterDecision(26, false); int LA26_0 = input.LA(1); if ((LA26_0==DOT)) { alt26 = 1; } else if ((LA26_0==LBRACKET)) { alt26 = 2; } else { if (state.backtracking>0) {state.failed=true; return retval;} NoViableAltException nvae = new NoViableAltException("", 26, 0, input); DebugRecognitionException(nvae); throw nvae; } } finally { DebugExitDecision(26); } switch (alt26) { case 1: DebugEnterAlt(1); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:392:4: DOT type_id ( lvalue_access )? { DebugLocation(392, 4); DOT119=(IToken)Match(input,DOT,Follow._DOT_in_lvalue_access2236); if (state.failed) return retval; if (state.backtracking == 0) stream_DOT.Add(DOT119); DebugLocation(392, 8); PushFollow(Follow._type_id_in_lvalue_access2238); type_id120=type_id(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) stream_type_id.Add(type_id120.Tree); DebugLocation(392, 16); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:392:16: ( lvalue_access )? int alt24=2; try { DebugEnterSubRule(24); try { DebugEnterDecision(24, false); int LA24_0 = input.LA(1); if ((LA24_0==DOT||LA24_0==LBRACKET)) { alt24 = 1; } } finally { DebugExitDecision(24); } switch (alt24) { case 1: DebugEnterAlt(1); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:392:16: lvalue_access { DebugLocation(392, 16); PushFollow(Follow._lvalue_access_in_lvalue_access2240); lvalue_access121=lvalue_access(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) stream_lvalue_access.Add(lvalue_access121.Tree); } break; } } finally { DebugExitSubRule(24); } { // AST REWRITE // elements: lvalue_access, type_id // 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 = (object)adaptor.Nil(); // 393:13: -> ^( FIELD_ACCESS type_id ( lvalue_access )? ) { DebugLocation(393, 16); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:393:16: ^( FIELD_ACCESS type_id ( lvalue_access )? ) { object root_1 = (object)adaptor.Nil(); DebugLocation(393, 18); root_1 = (object)adaptor.BecomeRoot((object)adaptor.Create(FIELD_ACCESS, "FIELD_ACCESS"), root_1); DebugLocation(393, 31); adaptor.AddChild(root_1, stream_type_id.NextTree()); DebugLocation(393, 39); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:393:39: ( lvalue_access )? if (stream_lvalue_access.HasNext) { DebugLocation(393, 39); adaptor.AddChild(root_1, stream_lvalue_access.NextTree()); } stream_lvalue_access.Reset(); adaptor.AddChild(root_0, root_1); } } retval.Tree = root_0; } } } break; case 2: DebugEnterAlt(2); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:394:4: LBRACKET disjunction_expr RBRACKET ( lvalue_access )? { DebugLocation(394, 4); LBRACKET122=(IToken)Match(input,LBRACKET,Follow._LBRACKET_in_lvalue_access2269); if (state.failed) return retval; if (state.backtracking == 0) stream_LBRACKET.Add(LBRACKET122); DebugLocation(394, 13); PushFollow(Follow._disjunction_expr_in_lvalue_access2271); disjunction_expr123=disjunction_expr(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) stream_disjunction_expr.Add(disjunction_expr123.Tree); DebugLocation(394, 30); RBRACKET124=(IToken)Match(input,RBRACKET,Follow._RBRACKET_in_lvalue_access2273); if (state.failed) return retval; if (state.backtracking == 0) stream_RBRACKET.Add(RBRACKET124); DebugLocation(394, 39); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:394:39: ( lvalue_access )? int alt25=2; try { DebugEnterSubRule(25); try { DebugEnterDecision(25, false); int LA25_0 = input.LA(1); if ((LA25_0==DOT||LA25_0==LBRACKET)) { alt25 = 1; } } finally { DebugExitDecision(25); } switch (alt25) { case 1: DebugEnterAlt(1); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:394:39: lvalue_access { DebugLocation(394, 39); PushFollow(Follow._lvalue_access_in_lvalue_access2275); lvalue_access125=lvalue_access(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) stream_lvalue_access.Add(lvalue_access125.Tree); } break; } } finally { DebugExitSubRule(25); } { // AST REWRITE // elements: lvalue_access, disjunction_expr // 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 = (object)adaptor.Nil(); // 395:4: -> ^( ARRAY_ACCESS disjunction_expr ( lvalue_access )? ) { DebugLocation(395, 7); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:395:7: ^( ARRAY_ACCESS disjunction_expr ( lvalue_access )? ) { object root_1 = (object)adaptor.Nil(); DebugLocation(395, 9); root_1 = (object)adaptor.BecomeRoot((object)adaptor.Create(ARRAY_ACCESS, "ARRAY_ACCESS"), root_1); DebugLocation(395, 22); adaptor.AddChild(root_1, stream_disjunction_expr.NextTree()); DebugLocation(395, 39); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:395:39: ( lvalue_access )? if (stream_lvalue_access.HasNext) { DebugLocation(395, 39); adaptor.AddChild(root_1, stream_lvalue_access.NextTree()); } stream_lvalue_access.Reset(); adaptor.AddChild(root_0, root_1); } } retval.Tree = root_0; } } } break; } retval.Stop = (IToken)input.LT(-1); if (state.backtracking == 0) { 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("lvalue_access", 30); LeaveRule("lvalue_access", 30); LeaveRule_lvalue_access(); } DebugLocation(396, 1); } finally { DebugExitRule(GrammarFileName, "lvalue_access"); } return retval; } // $ANTLR end "lvalue_access" partial void EnterRule_funcall(); partial void LeaveRule_funcall(); // $ANTLR start "funcall" // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:398:1: funcall : type_id LPAREN ( arg_list )? RPAREN -> ^( FUN_CALL type_id ( arg_list )? ) ; [GrammarRule("funcall")] private AstParserRuleReturnScope funcall() { EnterRule_funcall(); EnterRule("funcall", 31); TraceIn("funcall", 31); AstParserRuleReturnScope retval = new AstParserRuleReturnScope(); retval.Start = (IToken)input.LT(1); object root_0 = default(object); IToken LPAREN127 = default(IToken); IToken RPAREN129 = default(IToken); AstParserRuleReturnScope type_id126 = default(AstParserRuleReturnScope); AstParserRuleReturnScope arg_list128 = default(AstParserRuleReturnScope); object LPAREN127_tree = default(object); object RPAREN129_tree = default(object); RewriteRuleITokenStream stream_LPAREN=new RewriteRuleITokenStream(adaptor,"token LPAREN"); RewriteRuleITokenStream stream_RPAREN=new RewriteRuleITokenStream(adaptor,"token RPAREN"); RewriteRuleSubtreeStream stream_type_id=new RewriteRuleSubtreeStream(adaptor,"rule type_id"); RewriteRuleSubtreeStream stream_arg_list=new RewriteRuleSubtreeStream(adaptor,"rule arg_list"); try { DebugEnterRule(GrammarFileName, "funcall"); DebugLocation(398, 1); try { // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:399:2: ( type_id LPAREN ( arg_list )? RPAREN -> ^( FUN_CALL type_id ( arg_list )? ) ) DebugEnterAlt(1); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:399:4: type_id LPAREN ( arg_list )? RPAREN { DebugLocation(399, 4); PushFollow(Follow._type_id_in_funcall2301); type_id126=type_id(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) stream_type_id.Add(type_id126.Tree); DebugLocation(399, 12); LPAREN127=(IToken)Match(input,LPAREN,Follow._LPAREN_in_funcall2303); if (state.failed) return retval; if (state.backtracking == 0) stream_LPAREN.Add(LPAREN127); DebugLocation(399, 19); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:399:19: ( arg_list )? int alt27=2; try { DebugEnterSubRule(27); try { DebugEnterDecision(27, false); int LA27_0 = input.LA(1); if ((LA27_0==BREAKKEY||LA27_0==FORKEY||LA27_0==ID||LA27_0==IFKEY||(LA27_0>=INT && LA27_0<=INTKEY)||LA27_0==LETKEY||LA27_0==LPAREN||LA27_0==MINUS||LA27_0==NILKEY||(LA27_0>=STRING && LA27_0<=STRINGKEY)||LA27_0==WHILEKEY)) { alt27 = 1; } } finally { DebugExitDecision(27); } switch (alt27) { case 1: DebugEnterAlt(1); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:399:19: arg_list { DebugLocation(399, 19); PushFollow(Follow._arg_list_in_funcall2305); arg_list128=arg_list(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) stream_arg_list.Add(arg_list128.Tree); } break; } } finally { DebugExitSubRule(27); } DebugLocation(399, 29); RPAREN129=(IToken)Match(input,RPAREN,Follow._RPAREN_in_funcall2308); if (state.failed) return retval; if (state.backtracking == 0) stream_RPAREN.Add(RPAREN129); { // AST REWRITE // elements: arg_list, type_id // 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 = (object)adaptor.Nil(); // 400:4: -> ^( FUN_CALL type_id ( arg_list )? ) { DebugLocation(400, 7); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:400:7: ^( FUN_CALL type_id ( arg_list )? ) { object root_1 = (object)adaptor.Nil(); DebugLocation(400, 9); root_1 = (object)adaptor.BecomeRoot((object)adaptor.Create(FUN_CALL, "FUN_CALL"), root_1); DebugLocation(400, 18); adaptor.AddChild(root_1, stream_type_id.NextTree()); DebugLocation(400, 26); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:400:26: ( arg_list )? if (stream_arg_list.HasNext) { DebugLocation(400, 26); adaptor.AddChild(root_1, stream_arg_list.NextTree()); } stream_arg_list.Reset(); adaptor.AddChild(root_0, root_1); } } retval.Tree = root_0; } } } retval.Stop = (IToken)input.LT(-1); if (state.backtracking == 0) { 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("funcall", 31); LeaveRule("funcall", 31); LeaveRule_funcall(); } DebugLocation(401, 1); } finally { DebugExitRule(GrammarFileName, "funcall"); } return retval; } // $ANTLR end "funcall" partial void EnterRule_expr_seq(); partial void LeaveRule_expr_seq(); // $ANTLR start "expr_seq" // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:403:1: expr_seq : ( expr ( SEMI expr )* -> ^( EXPR_SEQ ( expr )+ ) | -> ^( EXPR_SEQ ) ); [GrammarRule("expr_seq")] private AstParserRuleReturnScope expr_seq() { EnterRule_expr_seq(); EnterRule("expr_seq", 32); TraceIn("expr_seq", 32); AstParserRuleReturnScope retval = new AstParserRuleReturnScope(); retval.Start = (IToken)input.LT(1); object root_0 = default(object); IToken SEMI131 = default(IToken); AstParserRuleReturnScope expr130 = default(AstParserRuleReturnScope); AstParserRuleReturnScope expr132 = default(AstParserRuleReturnScope); object SEMI131_tree = default(object); RewriteRuleITokenStream stream_SEMI=new RewriteRuleITokenStream(adaptor,"token SEMI"); RewriteRuleSubtreeStream stream_expr=new RewriteRuleSubtreeStream(adaptor,"rule expr"); try { DebugEnterRule(GrammarFileName, "expr_seq"); DebugLocation(403, 1); try { // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:404:2: ( expr ( SEMI expr )* -> ^( EXPR_SEQ ( expr )+ ) | -> ^( EXPR_SEQ ) ) int alt29=2; try { DebugEnterDecision(29, false); int LA29_0 = input.LA(1); if ((LA29_0==BREAKKEY||LA29_0==FORKEY||LA29_0==ID||LA29_0==IFKEY||(LA29_0>=INT && LA29_0<=INTKEY)||LA29_0==LETKEY||LA29_0==LPAREN||LA29_0==MINUS||LA29_0==NILKEY||(LA29_0>=STRING && LA29_0<=STRINGKEY)||LA29_0==WHILEKEY)) { alt29 = 1; } else if ((LA29_0==ENDKEY||LA29_0==RPAREN)) { alt29 = 2; } else { if (state.backtracking>0) {state.failed=true; return retval;} NoViableAltException nvae = new NoViableAltException("", 29, 0, input); DebugRecognitionException(nvae); throw nvae; } } finally { DebugExitDecision(29); } switch (alt29) { case 1: DebugEnterAlt(1); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:404:4: expr ( SEMI expr )* { DebugLocation(404, 4); PushFollow(Follow._expr_in_expr_seq2334); expr130=expr(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) stream_expr.Add(expr130.Tree); DebugLocation(404, 9); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:404:9: ( SEMI expr )* try { DebugEnterSubRule(28); while (true) { int alt28=2; try { DebugEnterDecision(28, false); int LA28_0 = input.LA(1); if ((LA28_0==SEMI)) { alt28 = 1; } } finally { DebugExitDecision(28); } switch ( alt28 ) { case 1: DebugEnterAlt(1); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:404:10: SEMI expr { DebugLocation(404, 10); SEMI131=(IToken)Match(input,SEMI,Follow._SEMI_in_expr_seq2337); if (state.failed) return retval; if (state.backtracking == 0) stream_SEMI.Add(SEMI131); DebugLocation(404, 15); PushFollow(Follow._expr_in_expr_seq2339); expr132=expr(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) stream_expr.Add(expr132.Tree); } break; default: goto loop28; } } loop28: ; } finally { DebugExitSubRule(28); } { // AST REWRITE // elements: expr // 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 = (object)adaptor.Nil(); // 405:4: -> ^( EXPR_SEQ ( expr )+ ) { DebugLocation(405, 7); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:405:7: ^( EXPR_SEQ ( expr )+ ) { object root_1 = (object)adaptor.Nil(); DebugLocation(405, 9); root_1 = (object)adaptor.BecomeRoot((object)adaptor.Create(EXPR_SEQ, "EXPR_SEQ"), root_1); DebugLocation(405, 18); if (!(stream_expr.HasNext)) { throw new RewriteEarlyExitException(); } while ( stream_expr.HasNext ) { DebugLocation(405, 18); adaptor.AddChild(root_1, stream_expr.NextTree()); } stream_expr.Reset(); adaptor.AddChild(root_0, root_1); } } retval.Tree = root_0; } } } break; case 2: DebugEnterAlt(2); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:406:9: { { // AST REWRITE // elements: // 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 = (object)adaptor.Nil(); // 406:9: -> ^( EXPR_SEQ ) { DebugLocation(406, 12); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:406:12: ^( EXPR_SEQ ) { object root_1 = (object)adaptor.Nil(); DebugLocation(406, 14); root_1 = (object)adaptor.BecomeRoot((object)adaptor.Create(EXPR_SEQ, "EXPR_SEQ"), root_1); adaptor.AddChild(root_0, root_1); } } retval.Tree = root_0; } } } break; } retval.Stop = (IToken)input.LT(-1); if (state.backtracking == 0) { 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("expr_seq", 32); LeaveRule("expr_seq", 32); LeaveRule_expr_seq(); } DebugLocation(407, 1); } finally { DebugExitRule(GrammarFileName, "expr_seq"); } return retval; } // $ANTLR end "expr_seq" partial void EnterRule_arg_list(); partial void LeaveRule_arg_list(); // $ANTLR start "arg_list" // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:409:1: arg_list : expr ( COMMA expr )* -> ^( ARGS_FIELDS ( expr )+ ) ; [GrammarRule("arg_list")] private AstParserRuleReturnScope arg_list() { EnterRule_arg_list(); EnterRule("arg_list", 33); TraceIn("arg_list", 33); AstParserRuleReturnScope retval = new AstParserRuleReturnScope(); retval.Start = (IToken)input.LT(1); object root_0 = default(object); IToken COMMA134 = default(IToken); AstParserRuleReturnScope expr133 = default(AstParserRuleReturnScope); AstParserRuleReturnScope expr135 = default(AstParserRuleReturnScope); object COMMA134_tree = default(object); RewriteRuleITokenStream stream_COMMA=new RewriteRuleITokenStream(adaptor,"token COMMA"); RewriteRuleSubtreeStream stream_expr=new RewriteRuleSubtreeStream(adaptor,"rule expr"); try { DebugEnterRule(GrammarFileName, "arg_list"); DebugLocation(409, 1); try { // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:410:2: ( expr ( COMMA expr )* -> ^( ARGS_FIELDS ( expr )+ ) ) DebugEnterAlt(1); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:410:4: expr ( COMMA expr )* { DebugLocation(410, 4); PushFollow(Follow._expr_in_arg_list2381); expr133=expr(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) stream_expr.Add(expr133.Tree); DebugLocation(410, 9); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:410:9: ( COMMA expr )* try { DebugEnterSubRule(30); while (true) { int alt30=2; try { DebugEnterDecision(30, false); int LA30_0 = input.LA(1); if ((LA30_0==COMMA)) { alt30 = 1; } } finally { DebugExitDecision(30); } switch ( alt30 ) { case 1: DebugEnterAlt(1); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:410:10: COMMA expr { DebugLocation(410, 10); COMMA134=(IToken)Match(input,COMMA,Follow._COMMA_in_arg_list2384); if (state.failed) return retval; if (state.backtracking == 0) stream_COMMA.Add(COMMA134); DebugLocation(410, 16); PushFollow(Follow._expr_in_arg_list2386); expr135=expr(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) stream_expr.Add(expr135.Tree); } break; default: goto loop30; } } loop30: ; } finally { DebugExitSubRule(30); } { // AST REWRITE // elements: expr // 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 = (object)adaptor.Nil(); // 411:4: -> ^( ARGS_FIELDS ( expr )+ ) { DebugLocation(411, 7); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:411:7: ^( ARGS_FIELDS ( expr )+ ) { object root_1 = (object)adaptor.Nil(); DebugLocation(411, 9); root_1 = (object)adaptor.BecomeRoot((object)adaptor.Create(ARGS_FIELDS, "ARGS_FIELDS"), root_1); DebugLocation(411, 21); if (!(stream_expr.HasNext)) { throw new RewriteEarlyExitException(); } while ( stream_expr.HasNext ) { DebugLocation(411, 21); adaptor.AddChild(root_1, stream_expr.NextTree()); } stream_expr.Reset(); adaptor.AddChild(root_0, root_1); } } retval.Tree = root_0; } } } retval.Stop = (IToken)input.LT(-1); if (state.backtracking == 0) { 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("arg_list", 33); LeaveRule("arg_list", 33); LeaveRule_arg_list(); } DebugLocation(412, 1); } finally { DebugExitRule(GrammarFileName, "arg_list"); } return retval; } // $ANTLR end "arg_list" partial void EnterRule_synpred1_tiger_fragment(); partial void LeaveRule_synpred1_tiger_fragment(); // $ANTLR start synpred1_tiger public void synpred1_tiger_fragment() { EnterRule_synpred1_tiger_fragment(); EnterRule("synpred1_tiger_fragment", 34); TraceIn("synpred1_tiger_fragment", 34); try { // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:223:4: ( ID LBRACKET disjunction_expr RBRACKET OFKEY ) DebugEnterAlt(1); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:223:5: ID LBRACKET disjunction_expr RBRACKET OFKEY { DebugLocation(223, 5); Match(input,ID,Follow._ID_in_synpred1_tiger1172); if (state.failed) return; DebugLocation(223, 8); Match(input,LBRACKET,Follow._LBRACKET_in_synpred1_tiger1174); if (state.failed) return; DebugLocation(223, 17); PushFollow(Follow._disjunction_expr_in_synpred1_tiger1176); disjunction_expr(); PopFollow(); if (state.failed) return; DebugLocation(223, 34); Match(input,RBRACKET,Follow._RBRACKET_in_synpred1_tiger1178); if (state.failed) return; DebugLocation(223, 43); Match(input,OFKEY,Follow._OFKEY_in_synpred1_tiger1180); if (state.failed) return; } } finally { TraceOut("synpred1_tiger_fragment", 34); LeaveRule("synpred1_tiger_fragment", 34); LeaveRule_synpred1_tiger_fragment(); } } // $ANTLR end synpred1_tiger partial void EnterRule_synpred2_tiger_fragment(); partial void LeaveRule_synpred2_tiger_fragment(); // $ANTLR start synpred2_tiger public void synpred2_tiger_fragment() { EnterRule_synpred2_tiger_fragment(); EnterRule("synpred2_tiger_fragment", 35); TraceIn("synpred2_tiger_fragment", 35); try { // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:224:4: ( lvalue ASSIGN ) DebugEnterAlt(1); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:224:5: lvalue ASSIGN { DebugLocation(224, 5); PushFollow(Follow._lvalue_in_synpred2_tiger1191); lvalue(); PopFollow(); if (state.failed) return; DebugLocation(224, 12); Match(input,ASSIGN,Follow._ASSIGN_in_synpred2_tiger1193); if (state.failed) return; } } finally { TraceOut("synpred2_tiger_fragment", 35); LeaveRule("synpred2_tiger_fragment", 35); LeaveRule_synpred2_tiger_fragment(); } } // $ANTLR end synpred2_tiger partial void EnterRule_synpred3_tiger_fragment(); partial void LeaveRule_synpred3_tiger_fragment(); // $ANTLR start synpred3_tiger public void synpred3_tiger_fragment() { EnterRule_synpred3_tiger_fragment(); EnterRule("synpred3_tiger_fragment", 36); TraceIn("synpred3_tiger_fragment", 36); try { // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:238:6: ( ID LBRACKET disjunction_expr RBRACKET OFKEY ) DebugEnterAlt(1); // D:\\~Compilador\\!yatc\\Grammar\\tiger.g:238:7: ID LBRACKET disjunction_expr RBRACKET OFKEY { DebugLocation(238, 7); Match(input,ID,Follow._ID_in_synpred3_tiger1279); if (state.failed) return; DebugLocation(238, 10); Match(input,LBRACKET,Follow._LBRACKET_in_synpred3_tiger1281); if (state.failed) return; DebugLocation(238, 19); PushFollow(Follow._disjunction_expr_in_synpred3_tiger1283); disjunction_expr(); PopFollow(); if (state.failed) return; DebugLocation(238, 36); Match(input,RBRACKET,Follow._RBRACKET_in_synpred3_tiger1285); if (state.failed) return; DebugLocation(238, 45); Match(input,OFKEY,Follow._OFKEY_in_synpred3_tiger1287); if (state.failed) return; } } finally { TraceOut("synpred3_tiger_fragment", 36); LeaveRule("synpred3_tiger_fragment", 36); LeaveRule_synpred3_tiger_fragment(); } } // $ANTLR end synpred3_tiger #endregion Rules #region Synpreds private bool EvaluatePredicate(System.Action fragment) { bool success = false; state.backtracking++; try { DebugBeginBacktrack(state.backtracking); int start = input.Mark(); try { fragment(); } catch ( RecognitionException re ) { System.Console.Error.WriteLine("impossible: "+re); } success = !state.failed; input.Rewind(start); } finally { DebugEndBacktrack(state.backtracking, success); } state.backtracking--; state.failed=false; return success; } #endregion Synpreds #region DFA private DFA2 dfa2; protected override void InitDFAs() { base.InitDFAs(); dfa2 = new DFA2( this, SpecialStateTransition2 ); } private class DFA2 : DFA { private const string DFA2_eotS = "\x4D\xFFFF"; private const string DFA2_eofS = "\x1\xFFFF\x2\x3\x4A\xFFFF"; private const string DFA2_minS = "\x1\xF\x2\x5\x8\xFFFF\x1\x24\x1\xFFFF\x1\x2C\x16\xFFFF\x1\x2C\x1\x24"+ "\x16\xFFFF\x10\x0\x1\xFFFF"; private const string DFA2_maxS = "\x1\x5A\x2\x56\x8\xFFFF\x1\x4E\x1\xFFFF\x1\x4E\x16\xFFFF\x2\x4E\x16\xFFFF"+ "\x10\x0\x1\xFFFF"; private const string DFA2_acceptS = "\x3\xFFFF\x1\x3\x5\xFFFF\x1\x5\x1\x6\x1\xFFFF\x1\x4\x1\xFFFF\x1\x2\x17"+ "\xFFFF\x1\x2\x25\xFFFF\x1\x1"; private const string DFA2_specialS = "\x1\xFFFF\x1\x0\x1\x1\x39\xFFFF\x1\x2\x1\x3\x1\x4\x1\x5\x1\x6\x1\x7\x1"+ "\x8\x1\x9\x1\xA\x1\xB\x1\xC\x1\xD\x1\xE\x1\xF\x1\x10\x1\x11\x1\xFFFF}>"; private static readonly string[] DFA2_transitionS = { "\x1\xA\x14\xFFFF\x1\x3\x7\xFFFF\x1\x1\x1\xFFFF\x1\x3\x1\xFFFF\x1\x3"+ "\x1\x2\x2\xFFFF\x1\x3\x2\xFFFF\x1\x3\x2\xFFFF\x1\x3\x3\xFFFF\x1\x3\xE"+ "\xFFFF\x1\x3\x1\x2\xB\xFFFF\x1\x9", "\x1\x3\x6\xFFFF\x1\xE\x4\xFFFF\x1\x3\x3\xFFFF\x2\x3\x1\xD\x2\x3\x1"+ "\xFFFF\x1\x3\x9\xFFFF\x1\x3\x4\xFFFF\x2\x3\x3\xFFFF\x1\x3\x2\xFFFF\x1"+ "\xB\x3\xFFFF\x1\xC\x5\x3\x3\xFFFF\x1\x3\x1\xFFFF\x1\x3\x1\xFFFF\x1\x3"+ "\x3\xFFFF\x1\x3\x2\xFFFF\x3\x3\x2\xFFFF\x2\x3\x1\xFFFF\x1\x3\x3\xFFFF"+ "\x1\x3", "\x1\x3\x6\xFFFF\x1\x26\x4\xFFFF\x1\x3\x3\xFFFF\x2\x3\x1\x24\x2\x3\x1"+ "\xFFFF\x1\x3\x9\xFFFF\x1\x3\x4\xFFFF\x2\x3\x3\xFFFF\x1\x3\x2\xFFFF\x1"+ "\x25\x4\xFFFF\x5\x3\x3\xFFFF\x1\x3\x1\xFFFF\x1\x3\x1\xFFFF\x1\x3\x3"+ "\xFFFF\x1\x3\x2\xFFFF\x3\x3\x2\xFFFF\x2\x3\x1\xFFFF\x1\x3\x3\xFFFF\x1"+ "\x3", "", "", "", "", "", "", "", "", "\x1\x40\x7\xFFFF\x1\x3E\x1\xFFFF\x1\x3F\x1\xFFFF\x1\x3D\x1\x3E\x2\xFFFF"+ "\x1\x41\x2\xFFFF\x1\x42\x2\xFFFF\x1\x3C\x3\xFFFF\x1\x3D\xE\xFFFF\x1"+ "\x3D\x1\x3E", "", "\x1\x43\x4\xFFFF\x1\x43\x1C\xFFFF\x1\x43", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "\x1\x44\x4\xFFFF\x1\x44\x1C\xFFFF\x1\x44", "\x1\x49\x7\xFFFF\x1\x47\x1\xFFFF\x1\x48\x1\xFFFF\x1\x46\x1\x47\x2\xFFFF"+ "\x1\x4A\x2\xFFFF\x1\x4B\x2\xFFFF\x1\x45\x3\xFFFF\x1\x46\xE\xFFFF\x1"+ "\x46\x1\x47", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "\x1\xFFFF", "\x1\xFFFF", "\x1\xFFFF", "\x1\xFFFF", "\x1\xFFFF", "\x1\xFFFF", "\x1\xFFFF", "\x1\xFFFF", "\x1\xFFFF", "\x1\xFFFF", "\x1\xFFFF", "\x1\xFFFF", "\x1\xFFFF", "\x1\xFFFF", "\x1\xFFFF", "\x1\xFFFF", "" }; private static readonly short[] DFA2_eot = DFA.UnpackEncodedString(DFA2_eotS); private static readonly short[] DFA2_eof = DFA.UnpackEncodedString(DFA2_eofS); private static readonly char[] DFA2_min = DFA.UnpackEncodedStringToUnsignedChars(DFA2_minS); private static readonly char[] DFA2_max = DFA.UnpackEncodedStringToUnsignedChars(DFA2_maxS); private static readonly short[] DFA2_accept = DFA.UnpackEncodedString(DFA2_acceptS); private static readonly short[] DFA2_special = DFA.UnpackEncodedString(DFA2_specialS); private static readonly short[][] DFA2_transition; static DFA2() { int numStates = DFA2_transitionS.Length; DFA2_transition = new short[numStates][]; for ( int i=0; i < numStates; i++ ) { DFA2_transition[i] = DFA.UnpackEncodedString(DFA2_transitionS[i]); } } public DFA2( BaseRecognizer recognizer, SpecialStateTransitionHandler specialStateTransition ) : base(specialStateTransition) { this.recognizer = recognizer; this.decisionNumber = 2; this.eot = DFA2_eot; this.eof = DFA2_eof; this.min = DFA2_min; this.max = DFA2_max; this.accept = DFA2_accept; this.special = DFA2_special; this.transition = DFA2_transition; } public override string Description { get { return "222:1: expr : ( ( ID LBRACKET disjunction_expr RBRACKET OFKEY )=> array_inst | ( lvalue ASSIGN )=> assignment | disjunction_expr | record_inst | while_stat | BREAKKEY -> BREAK );"; } } public override void Error(NoViableAltException nvae) { DebugRecognitionException(nvae); } } private int SpecialStateTransition2(DFA dfa, int s, IIntStream _input) { ITokenStream input = (ITokenStream)_input; int _s = s; switch (s) { case 0: int LA2_1 = input.LA(1); int index2_1 = input.Index; input.Rewind(); s = -1; if ((LA2_1==LBRACKET)) {s = 11;} else if ((LA2_1==LKEY)) {s = 12;} else if ((LA2_1==DOT)) {s = 13;} else if ((LA2_1==ASSIGN) && (EvaluatePredicate(synpred2_tiger_fragment))) {s = 14;} else if ((LA2_1==EOF||LA2_1==AND||LA2_1==COMMA||(LA2_1>=DIV && LA2_1<=DOKEY)||(LA2_1>=ELSEKEY && LA2_1<=ENDKEY)||LA2_1==EQ||LA2_1==FUNCTIONKEY||(LA2_1>=GT && LA2_1<=GTEQ)||LA2_1==INKEY||(LA2_1>=LPAREN && LA2_1<=MULT)||LA2_1==NOTEQ||LA2_1==OR||LA2_1==PLUS||LA2_1==RBRACKET||(LA2_1>=RKEY && LA2_1<=SEMI)||(LA2_1>=THENKEY && LA2_1<=TOKEY)||LA2_1==TYPEKEY||LA2_1==VARKEY)) {s = 3;} input.Seek(index2_1); if (s >= 0) return s; break; case 1: int LA2_2 = input.LA(1); int index2_2 = input.Index; input.Rewind(); s = -1; if ((LA2_2==DOT)) {s = 36;} else if ((LA2_2==LBRACKET)) {s = 37;} else if ((LA2_2==ASSIGN) && (EvaluatePredicate(synpred2_tiger_fragment))) {s = 38;} else if ((LA2_2==EOF||LA2_2==AND||LA2_2==COMMA||(LA2_2>=DIV && LA2_2<=DOKEY)||(LA2_2>=ELSEKEY && LA2_2<=ENDKEY)||LA2_2==EQ||LA2_2==FUNCTIONKEY||(LA2_2>=GT && LA2_2<=GTEQ)||LA2_2==INKEY||(LA2_2>=LPAREN && LA2_2<=MULT)||LA2_2==NOTEQ||LA2_2==OR||LA2_2==PLUS||LA2_2==RBRACKET||(LA2_2>=RKEY && LA2_2<=SEMI)||(LA2_2>=THENKEY && LA2_2<=TOKEY)||LA2_2==TYPEKEY||LA2_2==VARKEY)) {s = 3;} input.Seek(index2_2); if (s >= 0) return s; break; case 2: int LA2_60 = input.LA(1); int index2_60 = input.Index; input.Rewind(); s = -1; if ((EvaluatePredicate(synpred1_tiger_fragment))) {s = 76;} else if ((EvaluatePredicate(synpred2_tiger_fragment))) {s = 38;} else if ((true)) {s = 3;} input.Seek(index2_60); if (s >= 0) return s; break; case 3: int LA2_61 = input.LA(1); int index2_61 = input.Index; input.Rewind(); s = -1; if ((EvaluatePredicate(synpred1_tiger_fragment))) {s = 76;} else if ((EvaluatePredicate(synpred2_tiger_fragment))) {s = 38;} else if ((true)) {s = 3;} input.Seek(index2_61); if (s >= 0) return s; break; case 4: int LA2_62 = input.LA(1); int index2_62 = input.Index; input.Rewind(); s = -1; if ((EvaluatePredicate(synpred1_tiger_fragment))) {s = 76;} else if ((EvaluatePredicate(synpred2_tiger_fragment))) {s = 38;} else if ((true)) {s = 3;} input.Seek(index2_62); if (s >= 0) return s; break; case 5: int LA2_63 = input.LA(1); int index2_63 = input.Index; input.Rewind(); s = -1; if ((EvaluatePredicate(synpred1_tiger_fragment))) {s = 76;} else if ((EvaluatePredicate(synpred2_tiger_fragment))) {s = 38;} else if ((true)) {s = 3;} input.Seek(index2_63); if (s >= 0) return s; break; case 6: int LA2_64 = input.LA(1); int index2_64 = input.Index; input.Rewind(); s = -1; if ((EvaluatePredicate(synpred1_tiger_fragment))) {s = 76;} else if ((EvaluatePredicate(synpred2_tiger_fragment))) {s = 38;} else if ((true)) {s = 3;} input.Seek(index2_64); if (s >= 0) return s; break; case 7: int LA2_65 = input.LA(1); int index2_65 = input.Index; input.Rewind(); s = -1; if ((EvaluatePredicate(synpred1_tiger_fragment))) {s = 76;} else if ((EvaluatePredicate(synpred2_tiger_fragment))) {s = 38;} else if ((true)) {s = 3;} input.Seek(index2_65); if (s >= 0) return s; break; case 8: int LA2_66 = input.LA(1); int index2_66 = input.Index; input.Rewind(); s = -1; if ((EvaluatePredicate(synpred1_tiger_fragment))) {s = 76;} else if ((EvaluatePredicate(synpred2_tiger_fragment))) {s = 38;} else if ((true)) {s = 3;} input.Seek(index2_66); if (s >= 0) return s; break; case 9: int LA2_67 = input.LA(1); int index2_67 = input.Index; input.Rewind(); s = -1; if ((EvaluatePredicate(synpred2_tiger_fragment))) {s = 38;} else if ((true)) {s = 3;} input.Seek(index2_67); if (s >= 0) return s; break; case 10: int LA2_68 = input.LA(1); int index2_68 = input.Index; input.Rewind(); s = -1; if ((EvaluatePredicate(synpred2_tiger_fragment))) {s = 38;} else if ((true)) {s = 3;} input.Seek(index2_68); if (s >= 0) return s; break; case 11: int LA2_69 = input.LA(1); int index2_69 = input.Index; input.Rewind(); s = -1; if ((EvaluatePredicate(synpred2_tiger_fragment))) {s = 38;} else if ((true)) {s = 3;} input.Seek(index2_69); if (s >= 0) return s; break; case 12: int LA2_70 = input.LA(1); int index2_70 = input.Index; input.Rewind(); s = -1; if ((EvaluatePredicate(synpred2_tiger_fragment))) {s = 38;} else if ((true)) {s = 3;} input.Seek(index2_70); if (s >= 0) return s; break; case 13: int LA2_71 = input.LA(1); int index2_71 = input.Index; input.Rewind(); s = -1; if ((EvaluatePredicate(synpred2_tiger_fragment))) {s = 38;} else if ((true)) {s = 3;} input.Seek(index2_71); if (s >= 0) return s; break; case 14: int LA2_72 = input.LA(1); int index2_72 = input.Index; input.Rewind(); s = -1; if ((EvaluatePredicate(synpred2_tiger_fragment))) {s = 38;} else if ((true)) {s = 3;} input.Seek(index2_72); if (s >= 0) return s; break; case 15: int LA2_73 = input.LA(1); int index2_73 = input.Index; input.Rewind(); s = -1; if ((EvaluatePredicate(synpred2_tiger_fragment))) {s = 38;} else if ((true)) {s = 3;} input.Seek(index2_73); if (s >= 0) return s; break; case 16: int LA2_74 = input.LA(1); int index2_74 = input.Index; input.Rewind(); s = -1; if ((EvaluatePredicate(synpred2_tiger_fragment))) {s = 38;} else if ((true)) {s = 3;} input.Seek(index2_74); if (s >= 0) return s; break; case 17: int LA2_75 = input.LA(1); int index2_75 = input.Index; input.Rewind(); s = -1; if ((EvaluatePredicate(synpred2_tiger_fragment))) {s = 38;} else if ((true)) {s = 3;} input.Seek(index2_75); if (s >= 0) return s; break; } if (state.backtracking > 0) {state.failed=true; return -1;} NoViableAltException nvae = new NoViableAltException(dfa.Description, 2, _s, input); dfa.Error(nvae); throw nvae; } #endregion DFA #region Follow sets private static class Follow { public static readonly BitSet _expr_in_a_program1145 = new BitSet(new ulong[]{0x0UL}); public static readonly BitSet _EOF_in_a_program1149 = new BitSet(new ulong[]{0x2UL}); public static readonly BitSet _array_inst_in_expr1185 = new BitSet(new ulong[]{0x2UL}); public static readonly BitSet _assignment_in_expr1198 = new BitSet(new ulong[]{0x2UL}); public static readonly BitSet _disjunction_expr_in_expr1203 = new BitSet(new ulong[]{0x2UL}); public static readonly BitSet _record_inst_in_expr1209 = new BitSet(new ulong[]{0x2UL}); public static readonly BitSet _while_stat_in_expr1214 = new BitSet(new ulong[]{0x2UL}); public static readonly BitSet _BREAKKEY_in_expr1219 = new BitSet(new ulong[]{0x2UL}); public static readonly BitSet _conjunction_expr_in_disjunction_expr1248 = new BitSet(new ulong[]{0x2UL,0x2UL}); public static readonly BitSet _OR_in_disjunction_expr1251 = new BitSet(new ulong[]{0x4493501000000000UL,0x6000UL}); public static readonly BitSet _conjunction_expr_in_disjunction_expr1254 = new BitSet(new ulong[]{0x2UL,0x2UL}); public static readonly BitSet _lvalue_in_assignment1267 = new BitSet(new ulong[]{0x1000UL}); public static readonly BitSet _ASSIGN_in_assignment1269 = new BitSet(new ulong[]{0x4493501000000000UL,0x6000UL}); public static readonly BitSet _array_inst_in_assignment1292 = new BitSet(new ulong[]{0x2UL}); public static readonly BitSet _disjunction_expr_in_assignment1300 = new BitSet(new ulong[]{0x2UL}); public static readonly BitSet _record_inst_in_assignment1308 = new BitSet(new ulong[]{0x2UL}); public static readonly BitSet _ID_in_record_inst1325 = new BitSet(new ulong[]{0x40000000000000UL}); public static readonly BitSet _LKEY_in_record_inst1327 = new BitSet(new ulong[]{0x100000000000UL,0x400UL}); public static readonly BitSet _field_inst_list_in_record_inst1329 = new BitSet(new ulong[]{0x0UL,0x400UL}); public static readonly BitSet _RKEY_in_record_inst1332 = new BitSet(new ulong[]{0x2UL}); public static readonly BitSet _FORKEY_in_for_expr1359 = new BitSet(new ulong[]{0x2100000000000UL,0x4000UL}); public static readonly BitSet _type_id_in_for_expr1361 = new BitSet(new ulong[]{0x1000UL}); public static readonly BitSet _ASSIGN_in_for_expr1363 = new BitSet(new ulong[]{0x4493501000000000UL,0x6000UL}); public static readonly BitSet _disjunction_expr_in_for_expr1365 = new BitSet(new ulong[]{0x0UL,0x10000UL}); public static readonly BitSet _TOKEY_in_for_expr1367 = new BitSet(new ulong[]{0x4493501000000000UL,0x6000UL}); public static readonly BitSet _disjunction_expr_in_for_expr1369 = new BitSet(new ulong[]{0x400000UL}); public static readonly BitSet _DOKEY_in_for_expr1371 = new BitSet(new ulong[]{0x4493501000008000UL,0x4006000UL}); public static readonly BitSet _expr_in_for_expr1373 = new BitSet(new ulong[]{0x2UL}); public static readonly BitSet _ID_in_array_inst1401 = new BitSet(new ulong[]{0x4000000000000UL}); public static readonly BitSet _LBRACKET_in_array_inst1403 = new BitSet(new ulong[]{0x4493501000000000UL,0x6000UL}); public static readonly BitSet _disjunction_expr_in_array_inst1405 = new BitSet(new ulong[]{0x0UL,0x80UL}); public static readonly BitSet _RBRACKET_in_array_inst1407 = new BitSet(new ulong[]{0x0UL,0x1UL}); public static readonly BitSet _OFKEY_in_array_inst1409 = new BitSet(new ulong[]{0x4493501000008000UL,0x4006000UL}); public static readonly BitSet _expr_in_array_inst1411 = new BitSet(new ulong[]{0x2UL}); public static readonly BitSet _relational_expr_in_conjunction_expr1437 = new BitSet(new ulong[]{0x22UL}); public static readonly BitSet _AND_in_conjunction_expr1440 = new BitSet(new ulong[]{0x4493501000000000UL,0x6000UL}); public static readonly BitSet _relational_expr_in_conjunction_expr1443 = new BitSet(new ulong[]{0x22UL}); public static readonly BitSet _arith_expr_in_relational_expr1459 = new BitSet(new ulong[]{0x83000C0008000002UL}); public static readonly BitSet _set_in_relational_expr1462 = new BitSet(new ulong[]{0x4493501000000000UL,0x6000UL}); public static readonly BitSet _arith_expr_in_relational_expr1488 = new BitSet(new ulong[]{0x2UL}); public static readonly BitSet _term_expr_in_arith_expr1502 = new BitSet(new ulong[]{0x400000000000002UL,0x8UL}); public static readonly BitSet _set_in_arith_expr1505 = new BitSet(new ulong[]{0x4493501000000000UL,0x6000UL}); public static readonly BitSet _term_expr_in_arith_expr1514 = new BitSet(new ulong[]{0x400000000000002UL,0x8UL}); public static readonly BitSet _atom_in_term_expr1527 = new BitSet(new ulong[]{0x800000000200002UL}); public static readonly BitSet _set_in_term_expr1530 = new BitSet(new ulong[]{0x4493501000000000UL,0x6000UL}); public static readonly BitSet _atom_in_term_expr1539 = new BitSet(new ulong[]{0x800000000200002UL}); public static readonly BitSet _record_field_inst_in_field_inst_list1553 = new BitSet(new ulong[]{0x20002UL}); public static readonly BitSet _COMMA_in_field_inst_list1557 = new BitSet(new ulong[]{0x100000000000UL}); public static readonly BitSet _record_field_inst_in_field_inst_list1559 = new BitSet(new ulong[]{0x20002UL}); public static readonly BitSet _ID_in_record_field_inst1586 = new BitSet(new ulong[]{0x8000000UL}); public static readonly BitSet _EQ_in_record_field_inst1588 = new BitSet(new ulong[]{0x4493501000008000UL,0x4006000UL}); public static readonly BitSet _expr_in_record_field_inst1590 = new BitSet(new ulong[]{0x2UL}); public static readonly BitSet _type_decl_in_decl1615 = new BitSet(new ulong[]{0x2UL,0x40000UL}); public static readonly BitSet _var_decl_in_decl1633 = new BitSet(new ulong[]{0x2UL}); public static readonly BitSet _fun_decl_in_decl1638 = new BitSet(new ulong[]{0x2000000002UL}); public static readonly BitSet _TYPEKEY_in_type_decl1662 = new BitSet(new ulong[]{0x100000000000UL}); public static readonly BitSet _ID_in_type_decl1664 = new BitSet(new ulong[]{0x8000000UL}); public static readonly BitSet _EQ_in_type_decl1666 = new BitSet(new ulong[]{0x42100000000080UL,0x4000UL}); public static readonly BitSet _type_in_type_decl1668 = new BitSet(new ulong[]{0x2UL}); public static readonly BitSet _VARKEY_in_var_decl1692 = new BitSet(new ulong[]{0x2100000000000UL,0x4000UL}); public static readonly BitSet _type_id_in_var_decl1694 = new BitSet(new ulong[]{0x10000UL}); public static readonly BitSet _COLON_in_var_decl1696 = new BitSet(new ulong[]{0x2100000000000UL,0x4000UL}); public static readonly BitSet _type_id_in_var_decl1698 = new BitSet(new ulong[]{0x1000UL}); public static readonly BitSet _ASSIGN_in_var_decl1700 = new BitSet(new ulong[]{0x4493501000008000UL,0x4006000UL}); public static readonly BitSet _expr_in_var_decl1702 = new BitSet(new ulong[]{0x2UL}); public static readonly BitSet _VARKEY_in_var_decl1723 = new BitSet(new ulong[]{0x2100000000000UL,0x4000UL}); public static readonly BitSet _type_id_in_var_decl1725 = new BitSet(new ulong[]{0x1000UL}); public static readonly BitSet _ASSIGN_in_var_decl1727 = new BitSet(new ulong[]{0x4493501000008000UL,0x4006000UL}); public static readonly BitSet _expr_in_var_decl1729 = new BitSet(new ulong[]{0x2UL}); public static readonly BitSet _FUNCTIONKEY_in_fun_decl1755 = new BitSet(new ulong[]{0x2100000000000UL,0x4000UL}); public static readonly BitSet _type_id_in_fun_decl1757 = new BitSet(new ulong[]{0x80000000000000UL}); public static readonly BitSet _LPAREN_in_fun_decl1759 = new BitSet(new ulong[]{0x2100000000000UL,0x4800UL}); public static readonly BitSet _type_fields_in_fun_decl1761 = new BitSet(new ulong[]{0x0UL,0x800UL}); public static readonly BitSet _RPAREN_in_fun_decl1764 = new BitSet(new ulong[]{0x8010000UL}); public static readonly BitSet _COLON_in_fun_decl1767 = new BitSet(new ulong[]{0x2100000000000UL,0x4000UL}); public static readonly BitSet _type_id_in_fun_decl1769 = new BitSet(new ulong[]{0x8000000UL}); public static readonly BitSet _EQ_in_fun_decl1773 = new BitSet(new ulong[]{0x4493501000008000UL,0x4006000UL}); public static readonly BitSet _expr_in_fun_decl1775 = new BitSet(new ulong[]{0x2UL}); public static readonly BitSet _type_id_in_type1834 = new BitSet(new ulong[]{0x2UL}); public static readonly BitSet _array_decl_in_type1859 = new BitSet(new ulong[]{0x2UL}); public static readonly BitSet _record_decl_in_type1865 = new BitSet(new ulong[]{0x2UL}); public static readonly BitSet _LKEY_in_record_decl1876 = new BitSet(new ulong[]{0x2100000000000UL,0x4400UL}); public static readonly BitSet _type_fields_in_record_decl1878 = new BitSet(new ulong[]{0x0UL,0x400UL}); public static readonly BitSet _RKEY_in_record_decl1881 = new BitSet(new ulong[]{0x2UL}); public static readonly BitSet _ARRAYKEY_in_array_decl1904 = new BitSet(new ulong[]{0x0UL,0x1UL}); public static readonly BitSet _OFKEY_in_array_decl1906 = new BitSet(new ulong[]{0x2100000000000UL,0x4000UL}); public static readonly BitSet _type_id_in_array_decl1908 = new BitSet(new ulong[]{0x2UL}); public static readonly BitSet _type_field_in_type_fields1931 = new BitSet(new ulong[]{0x20002UL}); public static readonly BitSet _COMMA_in_type_fields1934 = new BitSet(new ulong[]{0x2100000000000UL,0x4000UL}); public static readonly BitSet _type_field_in_type_fields1936 = new BitSet(new ulong[]{0x20002UL}); public static readonly BitSet _type_id_in_type_field1957 = new BitSet(new ulong[]{0x10000UL}); public static readonly BitSet _COLON_in_type_field1959 = new BitSet(new ulong[]{0x2100000000000UL,0x4000UL}); public static readonly BitSet _type_id_in_type_field1961 = new BitSet(new ulong[]{0x2UL}); public static readonly BitSet _MINUS_in_atom1986 = new BitSet(new ulong[]{0x4493501000000000UL,0x6000UL}); public static readonly BitSet _atom_in_atom1988 = new BitSet(new ulong[]{0x2UL}); public static readonly BitSet _constant_value_in_atom2013 = new BitSet(new ulong[]{0x2UL}); public static readonly BitSet _lvalue_in_atom2018 = new BitSet(new ulong[]{0x2UL}); public static readonly BitSet _funcall_in_atom2023 = new BitSet(new ulong[]{0x2UL}); public static readonly BitSet _if_then_expr_in_atom2028 = new BitSet(new ulong[]{0x2UL}); public static readonly BitSet _for_expr_in_atom2033 = new BitSet(new ulong[]{0x2UL}); public static readonly BitSet _let_expr_in_atom2038 = new BitSet(new ulong[]{0x2UL}); public static readonly BitSet _LPAREN_in_atom2043 = new BitSet(new ulong[]{0x4493501000008000UL,0x4006800UL}); public static readonly BitSet _expr_seq_in_atom2045 = new BitSet(new ulong[]{0x0UL,0x800UL}); public static readonly BitSet _RPAREN_in_atom2047 = new BitSet(new ulong[]{0x2UL}); public static readonly BitSet _IFKEY_in_if_then_expr2086 = new BitSet(new ulong[]{0x4493501000000000UL,0x6000UL}); public static readonly BitSet _disjunction_expr_in_if_then_expr2090 = new BitSet(new ulong[]{0x0UL,0x8000UL}); public static readonly BitSet _THENKEY_in_if_then_expr2092 = new BitSet(new ulong[]{0x4493501000008000UL,0x4006000UL}); public static readonly BitSet _expr_in_if_then_expr2096 = new BitSet(new ulong[]{0x1000002UL}); public static readonly BitSet _ELSEKEY_in_if_then_expr2099 = new BitSet(new ulong[]{0x4493501000008000UL,0x4006000UL}); public static readonly BitSet _expr_in_if_then_expr2103 = new BitSet(new ulong[]{0x2UL}); public static readonly BitSet _WHILEKEY_in_while_stat2136 = new BitSet(new ulong[]{0x4493501000000000UL,0x6000UL}); public static readonly BitSet _disjunction_expr_in_while_stat2140 = new BitSet(new ulong[]{0x400000UL}); public static readonly BitSet _DOKEY_in_while_stat2142 = new BitSet(new ulong[]{0x4493501000008000UL,0x4006000UL}); public static readonly BitSet _expr_in_while_stat2146 = new BitSet(new ulong[]{0x2UL}); public static readonly BitSet _LETKEY_in_let_expr2172 = new BitSet(new ulong[]{0x2000000000UL,0x440000UL}); public static readonly BitSet _decl_in_let_expr2174 = new BitSet(new ulong[]{0x802000000000UL,0x440000UL}); public static readonly BitSet _INKEY_in_let_expr2177 = new BitSet(new ulong[]{0x4493501002008000UL,0x4006000UL}); public static readonly BitSet _expr_seq_in_let_expr2179 = new BitSet(new ulong[]{0x2000000UL}); public static readonly BitSet _ENDKEY_in_let_expr2181 = new BitSet(new ulong[]{0x2UL}); public static readonly BitSet _type_id_in_lvalue2211 = new BitSet(new ulong[]{0x4000000800002UL}); public static readonly BitSet _lvalue_access_in_lvalue2213 = new BitSet(new ulong[]{0x2UL}); public static readonly BitSet _DOT_in_lvalue_access2236 = new BitSet(new ulong[]{0x2100000000000UL,0x4000UL}); public static readonly BitSet _type_id_in_lvalue_access2238 = new BitSet(new ulong[]{0x4000000800002UL}); public static readonly BitSet _lvalue_access_in_lvalue_access2240 = new BitSet(new ulong[]{0x2UL}); public static readonly BitSet _LBRACKET_in_lvalue_access2269 = new BitSet(new ulong[]{0x4493501000000000UL,0x6000UL}); public static readonly BitSet _disjunction_expr_in_lvalue_access2271 = new BitSet(new ulong[]{0x0UL,0x80UL}); public static readonly BitSet _RBRACKET_in_lvalue_access2273 = new BitSet(new ulong[]{0x4000000800002UL}); public static readonly BitSet _lvalue_access_in_lvalue_access2275 = new BitSet(new ulong[]{0x2UL}); public static readonly BitSet _type_id_in_funcall2301 = new BitSet(new ulong[]{0x80000000000000UL}); public static readonly BitSet _LPAREN_in_funcall2303 = new BitSet(new ulong[]{0x4493501000008000UL,0x4006800UL}); public static readonly BitSet _arg_list_in_funcall2305 = new BitSet(new ulong[]{0x0UL,0x800UL}); public static readonly BitSet _RPAREN_in_funcall2308 = new BitSet(new ulong[]{0x2UL}); public static readonly BitSet _expr_in_expr_seq2334 = new BitSet(new ulong[]{0x2UL,0x1000UL}); public static readonly BitSet _SEMI_in_expr_seq2337 = new BitSet(new ulong[]{0x4493501000008000UL,0x4006000UL}); public static readonly BitSet _expr_in_expr_seq2339 = new BitSet(new ulong[]{0x2UL,0x1000UL}); public static readonly BitSet _expr_in_arg_list2381 = new BitSet(new ulong[]{0x20002UL}); public static readonly BitSet _COMMA_in_arg_list2384 = new BitSet(new ulong[]{0x4493501000008000UL,0x4006000UL}); public static readonly BitSet _expr_in_arg_list2386 = new BitSet(new ulong[]{0x20002UL}); public static readonly BitSet _ID_in_synpred1_tiger1172 = new BitSet(new ulong[]{0x4000000000000UL}); public static readonly BitSet _LBRACKET_in_synpred1_tiger1174 = new BitSet(new ulong[]{0x4493501000000000UL,0x6000UL}); public static readonly BitSet _disjunction_expr_in_synpred1_tiger1176 = new BitSet(new ulong[]{0x0UL,0x80UL}); public static readonly BitSet _RBRACKET_in_synpred1_tiger1178 = new BitSet(new ulong[]{0x0UL,0x1UL}); public static readonly BitSet _OFKEY_in_synpred1_tiger1180 = new BitSet(new ulong[]{0x2UL}); public static readonly BitSet _lvalue_in_synpred2_tiger1191 = new BitSet(new ulong[]{0x1000UL}); public static readonly BitSet _ASSIGN_in_synpred2_tiger1193 = new BitSet(new ulong[]{0x2UL}); public static readonly BitSet _ID_in_synpred3_tiger1279 = new BitSet(new ulong[]{0x4000000000000UL}); public static readonly BitSet _LBRACKET_in_synpred3_tiger1281 = new BitSet(new ulong[]{0x4493501000000000UL,0x6000UL}); public static readonly BitSet _disjunction_expr_in_synpred3_tiger1283 = new BitSet(new ulong[]{0x0UL,0x80UL}); public static readonly BitSet _RBRACKET_in_synpred3_tiger1285 = new BitSet(new ulong[]{0x0UL,0x1UL}); public static readonly BitSet _OFKEY_in_synpred3_tiger1287 = new BitSet(new ulong[]{0x2UL}); } #endregion Follow sets } } // namespace YATC.Grammar