private TemplateParserRuleReturnScope<StringTemplate, IToken> doWhileStatement() { EnterRule_doWhileStatement(); EnterRule("doWhileStatement", 69); TraceIn("doWhileStatement", 69); TemplateParserRuleReturnScope<StringTemplate, IToken> retval = new TemplateParserRuleReturnScope<StringTemplate, IToken>(); retval.Start = (IToken)input.LT(1); try { DebugEnterRule(GrammarFileName, "doWhileStatement"); DebugLocation(816, 1); try { // AS3T.g:817:2: ( DO statement WHILE condition semi ) DebugEnterAlt(1); // AS3T.g:817:4: DO statement WHILE condition semi { DebugLocation(817, 4); Match(input,DO,Follow._DO_in_doWhileStatement2790); if (state.failed) return retval; DebugLocation(817, 7); PushFollow(Follow._statement_in_doWhileStatement2792); statement(); PopFollow(); if (state.failed) return retval; DebugLocation(817, 17); Match(input,WHILE,Follow._WHILE_in_doWhileStatement2794); if (state.failed) return retval; DebugLocation(817, 23); PushFollow(Follow._condition_in_doWhileStatement2796); condition(); PopFollow(); if (state.failed) return retval; DebugLocation(817, 33); PushFollow(Follow._semi_in_doWhileStatement2798); semi(); PopFollow(); if (state.failed) return retval; } retval.Stop = (IToken)input.LT(-1); } catch (RecognitionException re) { ReportError(re); Recover(input,re); } finally { TraceOut("doWhileStatement", 69); LeaveRule("doWhileStatement", 69); LeaveRule_doWhileStatement(); } DebugLocation(819, 1); } finally { DebugExitRule(GrammarFileName, "doWhileStatement"); } return retval; }
private TemplateParserRuleReturnScope<StringTemplate, IToken> objectLiteral() { EnterRule_objectLiteral(); EnterRule("objectLiteral", 91); TraceIn("objectLiteral", 91); TemplateParserRuleReturnScope<StringTemplate, IToken> retval = new TemplateParserRuleReturnScope<StringTemplate, IToken>(); retval.Start = (IToken)input.LT(1); try { DebugEnterRule(GrammarFileName, "objectLiteral"); DebugLocation(960, 1); try { // AS3T.g:961:2: ( LCURLY ( fieldList )? RCURLY ) DebugEnterAlt(1); // AS3T.g:961:4: LCURLY ( fieldList )? RCURLY { DebugLocation(961, 4); Match(input,LCURLY,Follow._LCURLY_in_objectLiteral3517); if (state.failed) return retval; DebugLocation(961, 11); // AS3T.g:961:11: ( fieldList )? int alt71=2; try { DebugEnterSubRule(71); try { DebugEnterDecision(71, false); int LA71_1 = input.LA(1); if ((LA71_1==AS||LA71_1==DECIMAL_LITERAL||LA71_1==DYNAMIC||LA71_1==FLOAT_LITERAL||LA71_1==GET||(LA71_1>=HEX_LITERAL && LA71_1<=IDENT)||LA71_1==IS||LA71_1==NAMESPACE||LA71_1==OCTAL_LITERAL||LA71_1==SET||LA71_1==SUPER||LA71_1==TRACE||LA71_1==USE||LA71_1==XML)) { alt71 = 1; } } finally { DebugExitDecision(71); } switch (alt71) { case 1: DebugEnterAlt(1); // AS3T.g:961:11: fieldList { DebugLocation(961, 11); PushFollow(Follow._fieldList_in_objectLiteral3519); fieldList(); PopFollow(); if (state.failed) return retval; } break; } } finally { DebugExitSubRule(71); } DebugLocation(961, 22); Match(input,RCURLY,Follow._RCURLY_in_objectLiteral3522); if (state.failed) return retval; } retval.Stop = (IToken)input.LT(-1); } catch (RecognitionException re) { ReportError(re); Recover(input,re); } finally { TraceOut("objectLiteral", 91); LeaveRule("objectLiteral", 91); LeaveRule_objectLiteral(); } DebugLocation(962, 1); } finally { DebugExitRule(GrammarFileName, "objectLiteral"); } return retval; }
private TemplateParserRuleReturnScope<StringTemplate, IToken> literalField() { EnterRule_literalField(); EnterRule("literalField", 93); TraceIn("literalField", 93); TemplateParserRuleReturnScope<StringTemplate, IToken> retval = new TemplateParserRuleReturnScope<StringTemplate, IToken>(); retval.Start = (IToken)input.LT(1); try { DebugEnterRule(GrammarFileName, "literalField"); DebugLocation(968, 1); try { // AS3T.g:969:2: ( fieldName COLON element ) DebugEnterAlt(1); // AS3T.g:969:5: fieldName COLON element { DebugLocation(969, 5); PushFollow(Follow._fieldName_in_literalField3556); fieldName(); PopFollow(); if (state.failed) return retval; DebugLocation(969, 15); Match(input,COLON,Follow._COLON_in_literalField3558); if (state.failed) return retval; DebugLocation(969, 21); PushFollow(Follow._element_in_literalField3560); element(); PopFollow(); if (state.failed) return retval; } retval.Stop = (IToken)input.LT(-1); } catch (RecognitionException re) { ReportError(re); Recover(input,re); } finally { TraceOut("literalField", 93); LeaveRule("literalField", 93); LeaveRule_literalField(); } DebugLocation(970, 1); } finally { DebugExitRule(GrammarFileName, "literalField"); } return retval; }
private TemplateParserRuleReturnScope<StringTemplate, IToken> arrayLiteral() { EnterRule_arrayLiteral(); EnterRule("arrayLiteral", 87); TraceIn("arrayLiteral", 87); TemplateParserRuleReturnScope<StringTemplate, IToken> retval = new TemplateParserRuleReturnScope<StringTemplate, IToken>(); retval.Start = (IToken)input.LT(1); try { DebugEnterRule(GrammarFileName, "arrayLiteral"); DebugLocation(942, 1); try { // AS3T.g:943:2: ( LBRACK ( elementList )? RBRACK ) DebugEnterAlt(1); // AS3T.g:943:4: LBRACK ( elementList )? RBRACK { DebugLocation(943, 4); Match(input,LBRACK,Follow._LBRACK_in_arrayLiteral3453); if (state.failed) return retval; DebugLocation(943, 11); // AS3T.g:943:11: ( elementList )? int alt68=2; try { DebugEnterSubRule(68); try { DebugEnterDecision(68, false); int LA68_1 = input.LA(1); if ((LA68_1==AS||LA68_1==BNOT||LA68_1==COMMA||(LA68_1>=DEC && LA68_1<=DECIMAL_LITERAL)||(LA68_1>=DYNAMIC && LA68_1<=E4X_ATTRI)||(LA68_1>=FALSE && LA68_1<=FLOAT_LITERAL)||LA68_1==FUNCTION||LA68_1==GET||(LA68_1>=HEX_LITERAL && LA68_1<=IDENT)||LA68_1==INC||(LA68_1>=INTERNAL && LA68_1<=IS)||(LA68_1>=LBRACK && LA68_1<=LCURLY)||LA68_1==LNOT||LA68_1==LPAREN||LA68_1==MINUS||LA68_1==NAMESPACE||LA68_1==NEW||LA68_1==NULL||LA68_1==OCTAL_LITERAL||LA68_1==PLUS||LA68_1==PRIVATE||(LA68_1>=PROTECTED && LA68_1<=PUBLIC)||LA68_1==REGEX_LITERAL||LA68_1==SET||(LA68_1>=STRING_LITERAL_DOUBLE && LA68_1<=SUPER)||(LA68_1>=TRACE && LA68_1<=TRUE)||LA68_1==USE||LA68_1==XML||LA68_1==XML_LITERAL||LA68_1==244||(LA68_1>=256 && LA68_1<=258))) { alt68 = 1; } } finally { DebugExitDecision(68); } switch (alt68) { case 1: DebugEnterAlt(1); // AS3T.g:943:11: elementList { DebugLocation(943, 11); PushFollow(Follow._elementList_in_arrayLiteral3455); elementList(); PopFollow(); if (state.failed) return retval; } break; } } finally { DebugExitSubRule(68); } DebugLocation(943, 24); Match(input,RBRACK,Follow._RBRACK_in_arrayLiteral3458); if (state.failed) return retval; } retval.Stop = (IToken)input.LT(-1); } catch (RecognitionException re) { ReportError(re); Recover(input,re); } finally { TraceOut("arrayLiteral", 87); LeaveRule("arrayLiteral", 87); LeaveRule_arrayLiteral(); } DebugLocation(944, 1); } finally { DebugExitRule(GrammarFileName, "arrayLiteral"); } return retval; }
private TemplateParserRuleReturnScope<StringTemplate, IToken> nonemptyElementList() { EnterRule_nonemptyElementList(); EnterRule("nonemptyElementList", 89); TraceIn("nonemptyElementList", 89); TemplateParserRuleReturnScope<StringTemplate, IToken> retval = new TemplateParserRuleReturnScope<StringTemplate, IToken>(); retval.Start = (IToken)input.LT(1); try { DebugEnterRule(GrammarFileName, "nonemptyElementList"); DebugLocation(951, 1); try { // AS3T.g:952:2: ( assignmentExpression ( COMMA assignmentExpression )* ) DebugEnterAlt(1); // AS3T.g:952:4: assignmentExpression ( COMMA assignmentExpression )* { DebugLocation(952, 4); PushFollow(Follow._assignmentExpression_in_nonemptyElementList3487); assignmentExpression(); PopFollow(); if (state.failed) return retval; DebugLocation(952, 25); // AS3T.g:952:25: ( COMMA assignmentExpression )* try { DebugEnterSubRule(70); while (true) { int alt70=2; try { DebugEnterDecision(70, false); int LA70_1 = input.LA(1); if ((LA70_1==COMMA)) { alt70 = 1; } } finally { DebugExitDecision(70); } switch ( alt70 ) { case 1: DebugEnterAlt(1); // AS3T.g:952:26: COMMA assignmentExpression { DebugLocation(952, 26); Match(input,COMMA,Follow._COMMA_in_nonemptyElementList3490); if (state.failed) return retval; DebugLocation(952, 32); PushFollow(Follow._assignmentExpression_in_nonemptyElementList3492); assignmentExpression(); PopFollow(); if (state.failed) return retval; } break; default: goto loop70; } } loop70: ; } finally { DebugExitSubRule(70); } } retval.Stop = (IToken)input.LT(-1); } catch (RecognitionException re) { ReportError(re); Recover(input,re); } finally { TraceOut("nonemptyElementList", 89); LeaveRule("nonemptyElementList", 89); LeaveRule_nonemptyElementList(); } DebugLocation(953, 1); } finally { DebugExitRule(GrammarFileName, "nonemptyElementList"); } return retval; }
private TemplateParserRuleReturnScope<StringTemplate, IToken> modifiers() { EnterRule_modifiers(); EnterRule("modifiers", 84); TraceIn("modifiers", 84); TemplateParserRuleReturnScope<StringTemplate, IToken> retval = new TemplateParserRuleReturnScope<StringTemplate, IToken>(); retval.Start = (IToken)input.LT(1); try { DebugEnterRule(GrammarFileName, "modifiers"); DebugLocation(918, 1); try { // AS3T.g:920:2: ( ( modifier ( modifier )* )? ) DebugEnterAlt(1); // AS3T.g:920:4: ( modifier ( modifier )* )? { DebugLocation(920, 4); // AS3T.g:920:4: ( modifier ( modifier )* )? int alt65=2; try { DebugEnterSubRule(65); try { DebugEnterDecision(65, false); int LA65_1 = input.LA(1); if ((LA65_1==DYNAMIC||LA65_1==IDENT||LA65_1==INTERNAL||LA65_1==PRIVATE||(LA65_1>=PROTECTED && LA65_1<=PUBLIC)||LA65_1==STATIC||(LA65_1>=245 && LA65_1<=247)||LA65_1==251||LA65_1==253)) { alt65 = 1; } } finally { DebugExitDecision(65); } switch (alt65) { case 1: DebugEnterAlt(1); // AS3T.g:920:6: modifier ( modifier )* { DebugLocation(920, 6); PushFollow(Follow._modifier_in_modifiers3347); modifier(); PopFollow(); if (state.failed) return retval; DebugLocation(920, 15); // AS3T.g:920:15: ( modifier )* try { DebugEnterSubRule(64); while (true) { int alt64=2; try { DebugEnterDecision(64, false); int LA64_1 = input.LA(1); if ((LA64_1==DYNAMIC||LA64_1==IDENT||LA64_1==INTERNAL||LA64_1==PRIVATE||(LA64_1>=PROTECTED && LA64_1<=PUBLIC)||LA64_1==STATIC||(LA64_1>=245 && LA64_1<=247)||LA64_1==251||LA64_1==253)) { alt64 = 1; } } finally { DebugExitDecision(64); } switch ( alt64 ) { case 1: DebugEnterAlt(1); // AS3T.g:920:16: modifier { DebugLocation(920, 16); PushFollow(Follow._modifier_in_modifiers3350); modifier(); PopFollow(); if (state.failed) return retval; } break; default: goto loop64; } } loop64: ; } finally { DebugExitSubRule(64); } } break; } } finally { DebugExitSubRule(65); } } retval.Stop = (IToken)input.LT(-1); if (state.backtracking == 0) { retval.Template = new StringTemplate(TemplateGroup,input.ToString(retval.Start,input.LT(-1))); } } catch (RecognitionException re) { ReportError(re); Recover(input,re); } finally { TraceOut("modifiers", 84); LeaveRule("modifiers", 84); LeaveRule_modifiers(); } DebugLocation(921, 1); } finally { DebugExitRule(GrammarFileName, "modifiers"); } return retval; }
private TemplateParserRuleReturnScope<StringTemplate, IToken> modifier() { EnterRule_modifier(); EnterRule("modifier", 85); TraceIn("modifier", 85); TemplateParserRuleReturnScope<StringTemplate, IToken> retval = new TemplateParserRuleReturnScope<StringTemplate, IToken>(); retval.Start = (IToken)input.LT(1); try { DebugEnterRule(GrammarFileName, "modifier"); DebugLocation(923, 1); try { // AS3T.g:925:2: ( namespaceName | STATIC -> ignore(| 'final' | 'enumerable' | 'explicit' | 'override' | DYNAMIC | 'intrinsic' ) int alt66=8; try { DebugEnterDecision(66, false); switch (input.LA(1)) { case IDENT: case INTERNAL: case PRIVATE: case PROTECTED: case PUBLIC: { alt66 = 1; } break; case STATIC: { alt66 = 2; } break; case 247: { alt66 = 3; } break; case 245: { alt66 = 4; } break; case 246: { alt66 = 5; } break; case 253: { alt66 = 6; } break; case DYNAMIC: { alt66 = 7; } break; case 251: { alt66 = 8; } break; default: { if (state.backtracking>0) {state.failed=true; return retval;} NoViableAltException nvae = new NoViableAltException("", 66, 0, input, 1); DebugRecognitionException(nvae); throw nvae; } } } finally { DebugExitDecision(66); } switch (alt66) { case 1: DebugEnterAlt(1); // AS3T.g:925:4: namespaceName { DebugLocation(925, 4); PushFollow(Follow._namespaceName_in_modifier3371); namespaceName(); PopFollow(); if (state.failed) return retval; } break; case 2: DebugEnterAlt(2); // AS3T.g:926:4: STATIC { DebugLocation(926, 4); Match(input,STATIC,Follow._STATIC_in_modifier3376); if (state.failed) return retval; DebugLocation(926, 11); if (state.backtracking == 0) { _storage = Symbol.STATIC; } // TEMPLATE REWRITE if (state.backtracking == 0) { // 926:41: -> ignore( { retval.Template = TemplateGroup.GetInstanceOf("ignore"); } ((TokenRewriteStream)input).Replace( retval.Start.TokenIndex, input.LT(-1).TokenIndex, retval.Template); } } break; case 3: DebugEnterAlt(3); // AS3T.g:927:4: 'final' { DebugLocation(927, 4); Match(input,247,Follow._247_in_modifier3389); if (state.failed) return retval; } break; case 4: DebugEnterAlt(4); // AS3T.g:928:4: 'enumerable' { DebugLocation(928, 4); Match(input,245,Follow._245_in_modifier3394); if (state.failed) return retval; } break; case 5: DebugEnterAlt(5); // AS3T.g:929:4: 'explicit' { DebugLocation(929, 4); Match(input,246,Follow._246_in_modifier3399); if (state.failed) return retval; } break; case 6: DebugEnterAlt(6); // AS3T.g:930:4: 'override' { DebugLocation(930, 4); Match(input,253,Follow._253_in_modifier3404); if (state.failed) return retval; } break; case 7: DebugEnterAlt(7); // AS3T.g:931:4: DYNAMIC { DebugLocation(931, 4); Match(input,DYNAMIC,Follow._DYNAMIC_in_modifier3409); if (state.failed) return retval; } break; case 8: DebugEnterAlt(8); // AS3T.g:932:4: 'intrinsic' { DebugLocation(932, 4); Match(input,251,Follow._251_in_modifier3414); if (state.failed) return retval; } break; } retval.Stop = (IToken)input.LT(-1); if (state.backtracking == 0) { retval.Template = new StringTemplate(TemplateGroup,input.ToString(retval.Start,input.LT(-1))); } } catch (RecognitionException re) { ReportError(re); Recover(input,re); } finally { TraceOut("modifier", 85); LeaveRule("modifier", 85); LeaveRule_modifier(); } DebugLocation(933, 1); } finally { DebugExitRule(GrammarFileName, "modifier"); } return retval; }
private TemplateParserRuleReturnScope<StringTemplate, IToken> identifier() { EnterRule_identifier(); EnterRule("identifier", 74); TraceIn("identifier", 74); TemplateParserRuleReturnScope<StringTemplate, IToken> retval = new TemplateParserRuleReturnScope<StringTemplate, IToken>(); retval.Start = (IToken)input.LT(1); try { DebugEnterRule(GrammarFileName, "identifier"); DebugLocation(842, 1); try { // AS3T.g:844:2: ( ( qualifiedIdent ) ( propOrIdent )* ) DebugEnterAlt(1); // AS3T.g:844:4: ( qualifiedIdent ) ( propOrIdent )* { DebugLocation(844, 4); // AS3T.g:844:4: ( qualifiedIdent ) DebugEnterAlt(1); // AS3T.g:844:5: qualifiedIdent { DebugLocation(844, 5); PushFollow(Follow._qualifiedIdent_in_identifier2944); qualifiedIdent(); PopFollow(); if (state.failed) return retval; } DebugLocation(844, 21); // AS3T.g:844:21: ( propOrIdent )* try { DebugEnterSubRule(53); while (true) { int alt53=2; try { DebugEnterDecision(53, false); int LA53_1 = input.LA(1); if ((LA53_1==DOT)) { alt53 = 1; } } finally { DebugExitDecision(53); } switch ( alt53 ) { case 1: DebugEnterAlt(1); // AS3T.g:844:22: propOrIdent { DebugLocation(844, 22); PushFollow(Follow._propOrIdent_in_identifier2948); propOrIdent(); PopFollow(); if (state.failed) return retval; } break; default: goto loop53; } } loop53: ; } finally { DebugExitSubRule(53); } } retval.Stop = (IToken)input.LT(-1); if (state.backtracking == 0) { retval.Template = new StringTemplate(TemplateGroup,input.ToString(retval.Start,input.LT(-1))); } } catch (RecognitionException re) { ReportError(re); Recover(input,re); } finally { TraceOut("identifier", 74); LeaveRule("identifier", 74); LeaveRule_identifier(); } DebugLocation(845, 1); } finally { DebugExitRule(GrammarFileName, "identifier"); } return retval; }
private TemplateParserRuleReturnScope<StringTemplate, IToken> qualifiedIdent() { EnterRule_qualifiedIdent(); EnterRule("qualifiedIdent", 75); TraceIn("qualifiedIdent", 75); TemplateParserRuleReturnScope<StringTemplate, IToken> retval = new TemplateParserRuleReturnScope<StringTemplate, IToken>(); retval.Start = (IToken)input.LT(1); try { DebugEnterRule(GrammarFileName, "qualifiedIdent"); DebugLocation(847, 4); try { // AS3T.g:850:5: ( ( namespaceName DBL_COLON )=> namespaceName DBL_COLON ident | ident ) int alt54=2; try { DebugEnterDecision(54, false); int LA54_1 = input.LA(1); if ((LA54_1==IDENT)) { int LA54_2 = input.LA(2); if ((EvaluatePredicate(synpred15_AS3T_fragment))) { alt54 = 1; } else if ((true)) { alt54 = 2; } else { if (state.backtracking>0) {state.failed=true; return retval;} NoViableAltException nvae = new NoViableAltException("", 54, 1, input, 2); DebugRecognitionException(nvae); throw nvae; } } else if ((LA54_1==PUBLIC) && (EvaluatePredicate(synpred15_AS3T_fragment))) { alt54 = 1; } else if ((LA54_1==PRIVATE) && (EvaluatePredicate(synpred15_AS3T_fragment))) { alt54 = 1; } else if ((LA54_1==PROTECTED) && (EvaluatePredicate(synpred15_AS3T_fragment))) { alt54 = 1; } else if ((LA54_1==INTERNAL) && (EvaluatePredicate(synpred15_AS3T_fragment))) { alt54 = 1; } else if ((LA54_1==AS||LA54_1==DYNAMIC||LA54_1==GET||LA54_1==IS||LA54_1==NAMESPACE||LA54_1==SET||LA54_1==SUPER||LA54_1==TRACE||LA54_1==USE||LA54_1==XML)) { alt54 = 2; } else { if (state.backtracking>0) {state.failed=true; return retval;} NoViableAltException nvae = new NoViableAltException("", 54, 0, input, 1); DebugRecognitionException(nvae); throw nvae; } } finally { DebugExitDecision(54); } switch (alt54) { case 1: DebugEnterAlt(1); // AS3T.g:850:7: ( namespaceName DBL_COLON )=> namespaceName DBL_COLON ident { DebugLocation(850, 36); PushFollow(Follow._namespaceName_in_qualifiedIdent2985); namespaceName(); PopFollow(); if (state.failed) return retval; DebugLocation(850, 50); Match(input,DBL_COLON,Follow._DBL_COLON_in_qualifiedIdent2987); if (state.failed) return retval; DebugLocation(850, 60); PushFollow(Follow._ident_in_qualifiedIdent2989); ident(); PopFollow(); if (state.failed) return retval; } break; case 2: DebugEnterAlt(2); // AS3T.g:851:7: ident { DebugLocation(851, 7); PushFollow(Follow._ident_in_qualifiedIdent2997); ident(); PopFollow(); if (state.failed) return retval; } break; } retval.Stop = (IToken)input.LT(-1); if (state.backtracking == 0) { retval.Template = new StringTemplate(TemplateGroup,input.ToString(retval.Start,input.LT(-1))); } } catch (RecognitionException re) { ReportError(re); Recover(input,re); } finally { TraceOut("qualifiedIdent", 75); LeaveRule("qualifiedIdent", 75); LeaveRule_qualifiedIdent(); } DebugLocation(852, 4); } finally { DebugExitRule(GrammarFileName, "qualifiedIdent"); } return retval; }
private TemplateParserRuleReturnScope<StringTemplate, IToken> typeExpression() { EnterRule_typeExpression(); EnterRule("typeExpression", 72); TraceIn("typeExpression", 72); TemplateParserRuleReturnScope<StringTemplate, IToken> retval = new TemplateParserRuleReturnScope<StringTemplate, IToken>(); retval.Start = (IToken)input.LT(1); TemplateParserRuleReturnScope<StringTemplate, IToken> typeIdentifier22 = default(TemplateParserRuleReturnScope<StringTemplate, IToken>); try { DebugEnterRule(GrammarFileName, "typeExpression"); DebugLocation(830, 4); try { // AS3T.g:832:2: ( COLON typeIdentifier -> type(t=$typeIdentifier.text)| 'void' -> type(t=\"void\")| STAR -> type(t=\"void*\")) int alt51=3; try { DebugEnterDecision(51, false); switch (input.LA(1)) { case COLON: { alt51 = 1; } break; case 258: { alt51 = 2; } break; case STAR: { alt51 = 3; } break; default: { if (state.backtracking>0) {state.failed=true; return retval;} NoViableAltException nvae = new NoViableAltException("", 51, 0, input, 1); DebugRecognitionException(nvae); throw nvae; } } } finally { DebugExitDecision(51); } switch (alt51) { case 1: DebugEnterAlt(1); // AS3T.g:832:4: COLON typeIdentifier { DebugLocation(832, 4); Match(input,COLON,Follow._COLON_in_typeExpression2856); if (state.failed) return retval; DebugLocation(832, 10); PushFollow(Follow._typeIdentifier_in_typeExpression2858); typeIdentifier22=typeIdentifier(); PopFollow(); if (state.failed) return retval; // TEMPLATE REWRITE if (state.backtracking == 0) { // 832:25: -> type(t=$typeIdentifier.text) { retval.Template = TemplateGroup.GetInstanceOf("type", new Dictionary<string, object>() { {"t", (typeIdentifier22!=null?input.ToString(typeIdentifier22.Start,typeIdentifier22.Stop):null)} } ); } ((TokenRewriteStream)input).Replace( retval.Start.TokenIndex, input.LT(-1).TokenIndex, retval.Template); } } break; case 2: DebugEnterAlt(2); // AS3T.g:833:4: 'void' { DebugLocation(833, 4); Match(input,258,Follow._258_in_typeExpression2872); if (state.failed) return retval; // TEMPLATE REWRITE if (state.backtracking == 0) { // 833:12: -> type(t=\"void\") { retval.Template = TemplateGroup.GetInstanceOf("type", new Dictionary<string, object>() { {"t", "void"} } ); } ((TokenRewriteStream)input).Replace( retval.Start.TokenIndex, input.LT(-1).TokenIndex, retval.Template); } } break; case 3: DebugEnterAlt(3); // AS3T.g:834:4: STAR { DebugLocation(834, 4); Match(input,STAR,Follow._STAR_in_typeExpression2887); if (state.failed) return retval; // TEMPLATE REWRITE if (state.backtracking == 0) { // 834:9: -> type(t=\"void*\") { retval.Template = TemplateGroup.GetInstanceOf("type", new Dictionary<string, object>() { {"t", "void*"} } ); } ((TokenRewriteStream)input).Replace( retval.Start.TokenIndex, input.LT(-1).TokenIndex, retval.Template); } } break; } retval.Stop = (IToken)input.LT(-1); if (state.backtracking == 0) { retval.Template = new StringTemplate(TemplateGroup,input.ToString(retval.Start,input.LT(-1))); } } catch (RecognitionException re) { ReportError(re); Recover(input,re); } finally { TraceOut("typeExpression", 72); LeaveRule("typeExpression", 72); LeaveRule_typeExpression(); } DebugLocation(835, 4); } finally { DebugExitRule(GrammarFileName, "typeExpression"); } return retval; }
private TemplateParserRuleReturnScope<StringTemplate, IToken> typeIdentifier() { EnterRule_typeIdentifier(); EnterRule("typeIdentifier", 73); TraceIn("typeIdentifier", 73); TemplateParserRuleReturnScope<StringTemplate, IToken> retval = new TemplateParserRuleReturnScope<StringTemplate, IToken>(); retval.Start = (IToken)input.LT(1); try { DebugEnterRule(GrammarFileName, "typeIdentifier"); DebugLocation(837, 4); try { // AS3T.g:839:5: ( ident ( propOrIdent )* ) DebugEnterAlt(1); // AS3T.g:839:7: ident ( propOrIdent )* { DebugLocation(839, 7); PushFollow(Follow._ident_in_typeIdentifier2918); ident(); PopFollow(); if (state.failed) return retval; DebugLocation(839, 13); // AS3T.g:839:13: ( propOrIdent )* try { DebugEnterSubRule(52); while (true) { int alt52=2; try { DebugEnterDecision(52, false); int LA52_1 = input.LA(1); if ((LA52_1==DOT)) { alt52 = 1; } } finally { DebugExitDecision(52); } switch ( alt52 ) { case 1: DebugEnterAlt(1); // AS3T.g:839:14: propOrIdent { DebugLocation(839, 14); PushFollow(Follow._propOrIdent_in_typeIdentifier2921); propOrIdent(); PopFollow(); if (state.failed) return retval; } break; default: goto loop52; } } loop52: ; } finally { DebugExitSubRule(52); } } retval.Stop = (IToken)input.LT(-1); if (state.backtracking == 0) { retval.Template = new StringTemplate(TemplateGroup,input.ToString(retval.Start,input.LT(-1))); } } catch (RecognitionException re) { ReportError(re); Recover(input,re); } finally { TraceOut("typeIdentifier", 73); LeaveRule("typeIdentifier", 73); LeaveRule_typeIdentifier(); } DebugLocation(840, 4); } finally { DebugExitRule(GrammarFileName, "typeIdentifier"); } return retval; }
private TemplateParserRuleReturnScope<StringTemplate, IToken> defaultXMLNamespaceStatement() { EnterRule_defaultXMLNamespaceStatement(); EnterRule("defaultXMLNamespaceStatement", 71); TraceIn("defaultXMLNamespaceStatement", 71); TemplateParserRuleReturnScope<StringTemplate, IToken> retval = new TemplateParserRuleReturnScope<StringTemplate, IToken>(); retval.Start = (IToken)input.LT(1); try { DebugEnterRule(GrammarFileName, "defaultXMLNamespaceStatement"); DebugLocation(825, 1); try { // AS3T.g:826:2: ( DEFAULT XML NAMESPACE ASSIGN expression semi ) DebugEnterAlt(1); // AS3T.g:826:4: DEFAULT XML NAMESPACE ASSIGN expression semi { DebugLocation(826, 4); Match(input,DEFAULT,Follow._DEFAULT_in_defaultXMLNamespaceStatement2827); if (state.failed) return retval; DebugLocation(826, 12); Match(input,XML,Follow._XML_in_defaultXMLNamespaceStatement2829); if (state.failed) return retval; DebugLocation(826, 16); Match(input,NAMESPACE,Follow._NAMESPACE_in_defaultXMLNamespaceStatement2831); if (state.failed) return retval; DebugLocation(826, 26); Match(input,ASSIGN,Follow._ASSIGN_in_defaultXMLNamespaceStatement2833); if (state.failed) return retval; DebugLocation(826, 33); PushFollow(Follow._expression_in_defaultXMLNamespaceStatement2835); expression(); PopFollow(); if (state.failed) return retval; DebugLocation(826, 44); PushFollow(Follow._semi_in_defaultXMLNamespaceStatement2837); semi(); PopFollow(); if (state.failed) return retval; } retval.Stop = (IToken)input.LT(-1); } catch (RecognitionException re) { ReportError(re); Recover(input,re); } finally { TraceOut("defaultXMLNamespaceStatement", 71); LeaveRule("defaultXMLNamespaceStatement", 71); LeaveRule_defaultXMLNamespaceStatement(); } DebugLocation(828, 1); } finally { DebugExitRule(GrammarFileName, "defaultXMLNamespaceStatement"); } return retval; }
private TemplateParserRuleReturnScope<StringTemplate, IToken> as2CompilationUnit() { EnterRule_as2CompilationUnit(); EnterRule("as2CompilationUnit", 3); TraceIn("as2CompilationUnit", 3); TemplateParserRuleReturnScope<StringTemplate, IToken> retval = new TemplateParserRuleReturnScope<StringTemplate, IToken>(); retval.Start = (IToken)input.LT(1); try { DebugEnterRule(GrammarFileName, "as2CompilationUnit"); DebugLocation(339, 1); try { // AS3T.g:341:2: ( ( importDefinition )* as2Type ) DebugEnterAlt(1); // AS3T.g:341:4: ( importDefinition )* as2Type { DebugLocation(341, 4); // AS3T.g:341:4: ( importDefinition )* try { DebugEnterSubRule(2); while (true) { int alt2=2; try { DebugEnterDecision(2, false); int LA2_1 = input.LA(1); if ((LA2_1==IMPORT)) { alt2 = 1; } } finally { DebugExitDecision(2); } switch ( alt2 ) { case 1: DebugEnterAlt(1); // AS3T.g:341:4: importDefinition { DebugLocation(341, 4); PushFollow(Follow._importDefinition_in_as2CompilationUnit510); importDefinition(); PopFollow(); if (state.failed) return retval; } break; default: goto loop2; } } loop2: ; } finally { DebugExitSubRule(2); } DebugLocation(342, 3); PushFollow(Follow._as2Type_in_as2CompilationUnit515); as2Type(); PopFollow(); if (state.failed) return retval; } retval.Stop = (IToken)input.LT(-1); if (state.backtracking == 0) { retval.Template = new StringTemplate(TemplateGroup,input.ToString(retval.Start,input.LT(-1))); } } catch (RecognitionException re) { ReportError(re); Recover(input,re); } finally { TraceOut("as2CompilationUnit", 3); LeaveRule("as2CompilationUnit", 3); LeaveRule_as2CompilationUnit(); } DebugLocation(343, 1); } finally { DebugExitRule(GrammarFileName, "as2CompilationUnit"); } return retval; }
private TemplateParserRuleReturnScope<StringTemplate, IToken> withStatement() { EnterRule_withStatement(); EnterRule("withStatement", 70); TraceIn("withStatement", 70); TemplateParserRuleReturnScope<StringTemplate, IToken> retval = new TemplateParserRuleReturnScope<StringTemplate, IToken>(); retval.Start = (IToken)input.LT(1); try { DebugEnterRule(GrammarFileName, "withStatement"); DebugLocation(821, 1); try { // AS3T.g:822:2: ( WITH condition statement ) DebugEnterAlt(1); // AS3T.g:822:4: WITH condition statement { DebugLocation(822, 4); Match(input,WITH,Follow._WITH_in_withStatement2812); if (state.failed) return retval; DebugLocation(822, 9); PushFollow(Follow._condition_in_withStatement2814); condition(); PopFollow(); if (state.failed) return retval; DebugLocation(822, 19); PushFollow(Follow._statement_in_withStatement2816); statement(); PopFollow(); if (state.failed) return retval; } retval.Stop = (IToken)input.LT(-1); } catch (RecognitionException re) { ReportError(re); Recover(input,re); } finally { TraceOut("withStatement", 70); LeaveRule("withStatement", 70); LeaveRule_withStatement(); } DebugLocation(823, 1); } finally { DebugExitRule(GrammarFileName, "withStatement"); } return retval; }
private TemplateParserRuleReturnScope<StringTemplate, IToken> annotationParamList() { EnterRule_annotationParamList(); EnterRule("annotationParamList", 82); TraceIn("annotationParamList", 82); TemplateParserRuleReturnScope<StringTemplate, IToken> retval = new TemplateParserRuleReturnScope<StringTemplate, IToken>(); retval.Start = (IToken)input.LT(1); try { DebugEnterRule(GrammarFileName, "annotationParamList"); DebugLocation(902, 1); try { // AS3T.g:903:2: ( LPAREN ( annotationParam ( COMMA annotationParam )* )? RPAREN ) DebugEnterAlt(1); // AS3T.g:904:3: LPAREN ( annotationParam ( COMMA annotationParam )* )? RPAREN { DebugLocation(904, 3); Match(input,LPAREN,Follow._LPAREN_in_annotationParamList3273); if (state.failed) return retval; DebugLocation(905, 3); // AS3T.g:905:3: ( annotationParam ( COMMA annotationParam )* )? int alt62=2; try { DebugEnterSubRule(62); try { DebugEnterDecision(62, false); int LA62_1 = input.LA(1); if ((LA62_1==AS||LA62_1==DECIMAL_LITERAL||LA62_1==DYNAMIC||(LA62_1>=FALSE && LA62_1<=FLOAT_LITERAL)||LA62_1==GET||(LA62_1>=HEX_LITERAL && LA62_1<=IDENT)||LA62_1==IS||LA62_1==NAMESPACE||LA62_1==NULL||LA62_1==OCTAL_LITERAL||LA62_1==REGEX_LITERAL||LA62_1==SET||(LA62_1>=STRING_LITERAL_DOUBLE && LA62_1<=SUPER)||(LA62_1>=TRACE && LA62_1<=TRUE)||LA62_1==USE||LA62_1==XML||LA62_1==XML_LITERAL)) { alt62 = 1; } } finally { DebugExitDecision(62); } switch (alt62) { case 1: DebugEnterAlt(1); // AS3T.g:905:5: annotationParam ( COMMA annotationParam )* { DebugLocation(905, 5); PushFollow(Follow._annotationParam_in_annotationParamList3279); annotationParam(); PopFollow(); if (state.failed) return retval; DebugLocation(906, 4); // AS3T.g:906:4: ( COMMA annotationParam )* try { DebugEnterSubRule(61); while (true) { int alt61=2; try { DebugEnterDecision(61, false); int LA61_1 = input.LA(1); if ((LA61_1==COMMA)) { alt61 = 1; } } finally { DebugExitDecision(61); } switch ( alt61 ) { case 1: DebugEnterAlt(1); // AS3T.g:906:5: COMMA annotationParam { DebugLocation(906, 5); Match(input,COMMA,Follow._COMMA_in_annotationParamList3285); if (state.failed) return retval; DebugLocation(906, 11); PushFollow(Follow._annotationParam_in_annotationParamList3287); annotationParam(); PopFollow(); if (state.failed) return retval; } break; default: goto loop61; } } loop61: ; } finally { DebugExitSubRule(61); } } break; } } finally { DebugExitSubRule(62); } DebugLocation(908, 3); Match(input,RPAREN,Follow._RPAREN_in_annotationParamList3298); if (state.failed) return retval; } retval.Stop = (IToken)input.LT(-1); } catch (RecognitionException re) { ReportError(re); Recover(input,re); } finally { TraceOut("annotationParamList", 82); LeaveRule("annotationParamList", 82); LeaveRule_annotationParamList(); } DebugLocation(910, 1); } finally { DebugExitRule(GrammarFileName, "annotationParamList"); } return retval; }
private TemplateParserRuleReturnScope<StringTemplate, IToken> namespaceName() { EnterRule_namespaceName(); EnterRule("namespaceName", 76); TraceIn("namespaceName", 76); TemplateParserRuleReturnScope<StringTemplate, IToken> retval = new TemplateParserRuleReturnScope<StringTemplate, IToken>(); retval.Start = (IToken)input.LT(1); try { DebugEnterRule(GrammarFileName, "namespaceName"); DebugLocation(854, 1); try { // AS3T.g:856:2: ( IDENT | reservedNamespace ) int alt55=2; try { DebugEnterDecision(55, false); int LA55_1 = input.LA(1); if ((LA55_1==IDENT)) { alt55 = 1; } else if ((LA55_1==INTERNAL||LA55_1==PRIVATE||(LA55_1>=PROTECTED && LA55_1<=PUBLIC))) { alt55 = 2; } else { if (state.backtracking>0) {state.failed=true; return retval;} NoViableAltException nvae = new NoViableAltException("", 55, 0, input, 1); DebugRecognitionException(nvae); throw nvae; } } finally { DebugExitDecision(55); } switch (alt55) { case 1: DebugEnterAlt(1); // AS3T.g:856:4: IDENT { DebugLocation(856, 4); Match(input,IDENT,Follow._IDENT_in_namespaceName3016); if (state.failed) return retval; } break; case 2: DebugEnterAlt(2); // AS3T.g:856:12: reservedNamespace { DebugLocation(856, 12); PushFollow(Follow._reservedNamespace_in_namespaceName3020); reservedNamespace(); PopFollow(); if (state.failed) return retval; } break; } retval.Stop = (IToken)input.LT(-1); if (state.backtracking == 0) { retval.Template = new StringTemplate(TemplateGroup,input.ToString(retval.Start,input.LT(-1))); } } catch (RecognitionException re) { ReportError(re); Recover(input,re); } finally { TraceOut("namespaceName", 76); LeaveRule("namespaceName", 76); LeaveRule_namespaceName(); } DebugLocation(857, 1); } finally { DebugExitRule(GrammarFileName, "namespaceName"); } return retval; }
private TemplateParserRuleReturnScope<StringTemplate, IToken> annotationParam() { EnterRule_annotationParam(); EnterRule("annotationParam", 83); TraceIn("annotationParam", 83); TemplateParserRuleReturnScope<StringTemplate, IToken> retval = new TemplateParserRuleReturnScope<StringTemplate, IToken>(); retval.Start = (IToken)input.LT(1); try { DebugEnterRule(GrammarFileName, "annotationParam"); DebugLocation(912, 1); try { // AS3T.g:913:2: ( ident ASSIGN constant | constant | ident ) int alt63=3; try { DebugEnterDecision(63, false); switch (input.LA(1)) { case IDENT: { int LA63_2 = input.LA(2); if ((LA63_2==ASSIGN)) { alt63 = 1; } else if ((LA63_2==COMMA||LA63_2==RPAREN)) { alt63 = 3; } else { if (state.backtracking>0) {state.failed=true; return retval;} NoViableAltException nvae = new NoViableAltException("", 63, 1, input, 2); DebugRecognitionException(nvae); throw nvae; } } break; case USE: { int LA63_2 = input.LA(2); if ((LA63_2==ASSIGN)) { alt63 = 1; } else if ((LA63_2==COMMA||LA63_2==RPAREN)) { alt63 = 3; } else { if (state.backtracking>0) {state.failed=true; return retval;} NoViableAltException nvae = new NoViableAltException("", 63, 2, input, 2); DebugRecognitionException(nvae); throw nvae; } } break; case XML: { int LA63_2 = input.LA(2); if ((LA63_2==ASSIGN)) { alt63 = 1; } else if ((LA63_2==COMMA||LA63_2==RPAREN)) { alt63 = 3; } else { if (state.backtracking>0) {state.failed=true; return retval;} NoViableAltException nvae = new NoViableAltException("", 63, 3, input, 2); DebugRecognitionException(nvae); throw nvae; } } break; case TRACE: { int LA63_2 = input.LA(2); if ((LA63_2==ASSIGN)) { alt63 = 1; } else if ((LA63_2==COMMA||LA63_2==RPAREN)) { alt63 = 3; } else { if (state.backtracking>0) {state.failed=true; return retval;} NoViableAltException nvae = new NoViableAltException("", 63, 4, input, 2); DebugRecognitionException(nvae); throw nvae; } } break; case DYNAMIC: { int LA63_2 = input.LA(2); if ((LA63_2==ASSIGN)) { alt63 = 1; } else if ((LA63_2==COMMA||LA63_2==RPAREN)) { alt63 = 3; } else { if (state.backtracking>0) {state.failed=true; return retval;} NoViableAltException nvae = new NoViableAltException("", 63, 5, input, 2); DebugRecognitionException(nvae); throw nvae; } } break; case NAMESPACE: { int LA63_2 = input.LA(2); if ((LA63_2==ASSIGN)) { alt63 = 1; } else if ((LA63_2==COMMA||LA63_2==RPAREN)) { alt63 = 3; } else { if (state.backtracking>0) {state.failed=true; return retval;} NoViableAltException nvae = new NoViableAltException("", 63, 6, input, 2); DebugRecognitionException(nvae); throw nvae; } } break; case IS: { int LA63_2 = input.LA(2); if ((LA63_2==ASSIGN)) { alt63 = 1; } else if ((LA63_2==COMMA||LA63_2==RPAREN)) { alt63 = 3; } else { if (state.backtracking>0) {state.failed=true; return retval;} NoViableAltException nvae = new NoViableAltException("", 63, 7, input, 2); DebugRecognitionException(nvae); throw nvae; } } break; case AS: { int LA63_2 = input.LA(2); if ((LA63_2==ASSIGN)) { alt63 = 1; } else if ((LA63_2==COMMA||LA63_2==RPAREN)) { alt63 = 3; } else { if (state.backtracking>0) {state.failed=true; return retval;} NoViableAltException nvae = new NoViableAltException("", 63, 8, input, 2); DebugRecognitionException(nvae); throw nvae; } } break; case GET: { int LA63_2 = input.LA(2); if ((LA63_2==ASSIGN)) { alt63 = 1; } else if ((LA63_2==COMMA||LA63_2==RPAREN)) { alt63 = 3; } else { if (state.backtracking>0) {state.failed=true; return retval;} NoViableAltException nvae = new NoViableAltException("", 63, 9, input, 2); DebugRecognitionException(nvae); throw nvae; } } break; case SET: { int LA63_2 = input.LA(2); if ((LA63_2==ASSIGN)) { alt63 = 1; } else if ((LA63_2==COMMA||LA63_2==RPAREN)) { alt63 = 3; } else { if (state.backtracking>0) {state.failed=true; return retval;} NoViableAltException nvae = new NoViableAltException("", 63, 10, input, 2); DebugRecognitionException(nvae); throw nvae; } } break; case SUPER: { int LA63_2 = input.LA(2); if ((LA63_2==ASSIGN)) { alt63 = 1; } else if ((LA63_2==COMMA||LA63_2==RPAREN)) { alt63 = 3; } else { if (state.backtracking>0) {state.failed=true; return retval;} NoViableAltException nvae = new NoViableAltException("", 63, 11, input, 2); DebugRecognitionException(nvae); throw nvae; } } break; case DECIMAL_LITERAL: case FALSE: case FLOAT_LITERAL: case HEX_LITERAL: case NULL: case OCTAL_LITERAL: case REGEX_LITERAL: case STRING_LITERAL_DOUBLE: case STRING_LITERAL_SINGLE: case TRUE: case XML_LITERAL: { alt63 = 2; } break; default: { if (state.backtracking>0) {state.failed=true; return retval;} NoViableAltException nvae = new NoViableAltException("", 63, 0, input, 1); DebugRecognitionException(nvae); throw nvae; } } } finally { DebugExitDecision(63); } switch (alt63) { case 1: DebugEnterAlt(1); // AS3T.g:913:4: ident ASSIGN constant { DebugLocation(913, 4); PushFollow(Follow._ident_in_annotationParam3312); ident(); PopFollow(); if (state.failed) return retval; DebugLocation(913, 10); Match(input,ASSIGN,Follow._ASSIGN_in_annotationParam3314); if (state.failed) return retval; DebugLocation(913, 17); PushFollow(Follow._constant_in_annotationParam3316); constant(); PopFollow(); if (state.failed) return retval; } break; case 2: DebugEnterAlt(2); // AS3T.g:914:4: constant { DebugLocation(914, 4); PushFollow(Follow._constant_in_annotationParam3322); constant(); PopFollow(); if (state.failed) return retval; } break; case 3: DebugEnterAlt(3); // AS3T.g:915:4: ident { DebugLocation(915, 4); PushFollow(Follow._ident_in_annotationParam3328); ident(); PopFollow(); if (state.failed) return retval; } break; } retval.Stop = (IToken)input.LT(-1); } catch (RecognitionException re) { ReportError(re); Recover(input,re); } finally { TraceOut("annotationParam", 83); LeaveRule("annotationParam", 83); LeaveRule_annotationParam(); } DebugLocation(916, 1); } finally { DebugExitRule(GrammarFileName, "annotationParam"); } return retval; }
private TemplateParserRuleReturnScope<StringTemplate, IToken> reservedNamespace() { EnterRule_reservedNamespace(); EnterRule("reservedNamespace", 77); TraceIn("reservedNamespace", 77); TemplateParserRuleReturnScope<StringTemplate, IToken> retval = new TemplateParserRuleReturnScope<StringTemplate, IToken>(); retval.Start = (IToken)input.LT(1); try { DebugEnterRule(GrammarFileName, "reservedNamespace"); DebugLocation(859, 1); try { // AS3T.g:861:2: ( PUBLIC -> ignore(| PRIVATE -> ignore(| PROTECTED -> ignore(| INTERNAL -> ignore() int alt56=4; try { DebugEnterDecision(56, false); switch (input.LA(1)) { case PUBLIC: { alt56 = 1; } break; case PRIVATE: { alt56 = 2; } break; case PROTECTED: { alt56 = 3; } break; case INTERNAL: { alt56 = 4; } break; default: { if (state.backtracking>0) {state.failed=true; return retval;} NoViableAltException nvae = new NoViableAltException("", 56, 0, input, 1); DebugRecognitionException(nvae); throw nvae; } } } finally { DebugExitDecision(56); } switch (alt56) { case 1: DebugEnterAlt(1); // AS3T.g:861:4: PUBLIC { DebugLocation(861, 4); Match(input,PUBLIC,Follow._PUBLIC_in_reservedNamespace3036); if (state.failed) return retval; DebugLocation(861, 11); if (state.backtracking == 0) { _scope = Symbol.PUBLIC; } // TEMPLATE REWRITE if (state.backtracking == 0) { // 861:39: -> ignore( { retval.Template = TemplateGroup.GetInstanceOf("ignore"); } ((TokenRewriteStream)input).Replace( retval.Start.TokenIndex, input.LT(-1).TokenIndex, retval.Template); } } break; case 2: DebugEnterAlt(2); // AS3T.g:862:4: PRIVATE { DebugLocation(862, 4); Match(input,PRIVATE,Follow._PRIVATE_in_reservedNamespace3049); if (state.failed) return retval; DebugLocation(862, 12); if (state.backtracking == 0) { _scope = Symbol.PRIVATE; } // TEMPLATE REWRITE if (state.backtracking == 0) { // 862:41: -> ignore( { retval.Template = TemplateGroup.GetInstanceOf("ignore"); } ((TokenRewriteStream)input).Replace( retval.Start.TokenIndex, input.LT(-1).TokenIndex, retval.Template); } } break; case 3: DebugEnterAlt(3); // AS3T.g:863:4: PROTECTED { DebugLocation(863, 4); Match(input,PROTECTED,Follow._PROTECTED_in_reservedNamespace3062); if (state.failed) return retval; DebugLocation(863, 14); if (state.backtracking == 0) { _scope = Symbol.PROTECTED; } // TEMPLATE REWRITE if (state.backtracking == 0) { // 863:45: -> ignore( { retval.Template = TemplateGroup.GetInstanceOf("ignore"); } ((TokenRewriteStream)input).Replace( retval.Start.TokenIndex, input.LT(-1).TokenIndex, retval.Template); } } break; case 4: DebugEnterAlt(4); // AS3T.g:864:4: INTERNAL { DebugLocation(864, 4); Match(input,INTERNAL,Follow._INTERNAL_in_reservedNamespace3075); if (state.failed) return retval; DebugLocation(864, 13); if (state.backtracking == 0) { _scope = Symbol.INTERNAL; } // TEMPLATE REWRITE if (state.backtracking == 0) { // 864:43: -> ignore( { retval.Template = TemplateGroup.GetInstanceOf("ignore"); } ((TokenRewriteStream)input).Replace( retval.Start.TokenIndex, input.LT(-1).TokenIndex, retval.Template); } } break; } retval.Stop = (IToken)input.LT(-1); if (state.backtracking == 0) { retval.Template = new StringTemplate(TemplateGroup,input.ToString(retval.Start,input.LT(-1))); } } catch (RecognitionException re) { ReportError(re); Recover(input,re); } finally { TraceOut("reservedNamespace", 77); LeaveRule("reservedNamespace", 77); LeaveRule_reservedNamespace(); } DebugLocation(865, 1); } finally { DebugExitRule(GrammarFileName, "reservedNamespace"); } return retval; }
private TemplateParserRuleReturnScope<StringTemplate, IToken> as3CompilationUnit() { EnterRule_as3CompilationUnit(); EnterRule("as3CompilationUnit", 5); TraceIn("as3CompilationUnit", 5); TemplateParserRuleReturnScope<StringTemplate, IToken> retval = new TemplateParserRuleReturnScope<StringTemplate, IToken>(); retval.Start = (IToken)input.LT(1); try { DebugEnterRule(GrammarFileName, "as3CompilationUnit"); DebugLocation(353, 1); try { // AS3T.g:355:2: ( packageDecl ( packageBlockEntry )* EOF ) DebugEnterAlt(1); // AS3T.g:355:4: packageDecl ( packageBlockEntry )* EOF { DebugLocation(355, 4); PushFollow(Follow._packageDecl_in_as3CompilationUnit575); packageDecl(); PopFollow(); if (state.failed) return retval; DebugLocation(356, 3); // AS3T.g:356:3: ( packageBlockEntry )* try { DebugEnterSubRule(4); while (true) { int alt4=2; try { DebugEnterDecision(4, false); int LA4_1 = input.LA(1); if ((LA4_1==AS||LA4_1==BNOT||LA4_1==BREAK||LA4_1==CLASS||LA4_1==CONST||LA4_1==CONTINUE||(LA4_1>=DEC && LA4_1<=DECIMAL_LITERAL)||LA4_1==DEFAULT||LA4_1==DO||(LA4_1>=DYNAMIC && LA4_1<=E4X_ATTRI)||(LA4_1>=FALSE && LA4_1<=FOR)||LA4_1==FUNCTION||LA4_1==GET||(LA4_1>=HEX_LITERAL && LA4_1<=IDENT)||LA4_1==IF||LA4_1==IMPORT||LA4_1==INC||LA4_1==INTERFACE||(LA4_1>=INTERNAL && LA4_1<=IS)||(LA4_1>=LBRACK && LA4_1<=LCURLY)||LA4_1==LNOT||LA4_1==LPAREN||LA4_1==MINUS||LA4_1==NAMESPACE||LA4_1==NEW||LA4_1==NULL||LA4_1==OCTAL_LITERAL||LA4_1==PLUS||LA4_1==PRIVATE||(LA4_1>=PROTECTED && LA4_1<=PUBLIC)||LA4_1==REGEX_LITERAL||LA4_1==RETURN||(LA4_1>=SEMI && LA4_1<=SET)||LA4_1==STATIC||(LA4_1>=STRING_LITERAL_DOUBLE && LA4_1<=SWITCH)||(LA4_1>=TRACE && LA4_1<=TRUE)||(LA4_1>=USE && LA4_1<=VAR)||LA4_1==WHILE||LA4_1==WITH||LA4_1==XML||LA4_1==XML_LITERAL||(LA4_1>=244 && LA4_1<=247)||LA4_1==249||LA4_1==251||(LA4_1>=253 && LA4_1<=258))) { alt4 = 1; } } finally { DebugExitDecision(4); } switch ( alt4 ) { case 1: DebugEnterAlt(1); // AS3T.g:356:3: packageBlockEntry { DebugLocation(356, 3); PushFollow(Follow._packageBlockEntry_in_as3CompilationUnit579); packageBlockEntry(); PopFollow(); if (state.failed) return retval; } break; default: goto loop4; } } loop4: ; } finally { DebugExitSubRule(4); } DebugLocation(357, 3); Match(input,EOF,Follow._EOF_in_as3CompilationUnit584); if (state.failed) return retval; } retval.Stop = (IToken)input.LT(-1); if (state.backtracking == 0) { retval.Template = new StringTemplate(TemplateGroup,input.ToString(retval.Start,input.LT(-1))); } } catch (RecognitionException re) { ReportError(re); Recover(input,re); } finally { TraceOut("as3CompilationUnit", 5); LeaveRule("as3CompilationUnit", 5); LeaveRule_as3CompilationUnit(); } DebugLocation(358, 1); } finally { DebugExitRule(GrammarFileName, "as3CompilationUnit"); } return retval; }
private TemplateParserRuleReturnScope<StringTemplate, IToken> identifierStar() { EnterRule_identifierStar(); EnterRule("identifierStar", 78); TraceIn("identifierStar", 78); TemplateParserRuleReturnScope<StringTemplate, IToken> retval = new TemplateParserRuleReturnScope<StringTemplate, IToken>(); retval.Start = (IToken)input.LT(1); try { DebugEnterRule(GrammarFileName, "identifierStar"); DebugLocation(867, 1); try { // AS3T.g:869:2: ( ident ( dotIdent )* ( DOT STAR )? ) DebugEnterAlt(1); // AS3T.g:869:4: ident ( dotIdent )* ( DOT STAR )? { DebugLocation(869, 4); PushFollow(Follow._ident_in_identifierStar3099); ident(); PopFollow(); if (state.failed) return retval; DebugLocation(870, 3); // AS3T.g:870:3: ( dotIdent )* try { DebugEnterSubRule(57); while (true) { int alt57=2; try { DebugEnterDecision(57, false); int LA57_1 = input.LA(1); if ((LA57_1==DOT)) { int LA57_2 = input.LA(2); if ((LA57_2==AS||LA57_2==DYNAMIC||LA57_2==GET||LA57_2==IDENT||LA57_2==IS||LA57_2==NAMESPACE||LA57_2==SET||LA57_2==SUPER||LA57_2==TRACE||LA57_2==USE||LA57_2==XML)) { alt57 = 1; } } } finally { DebugExitDecision(57); } switch ( alt57 ) { case 1: DebugEnterAlt(1); // AS3T.g:870:3: dotIdent { DebugLocation(870, 3); PushFollow(Follow._dotIdent_in_identifierStar3103); dotIdent(); PopFollow(); if (state.failed) return retval; } break; default: goto loop57; } } loop57: ; } finally { DebugExitSubRule(57); } DebugLocation(871, 3); // AS3T.g:871:3: ( DOT STAR )? int alt58=2; try { DebugEnterSubRule(58); try { DebugEnterDecision(58, false); int LA58_1 = input.LA(1); if ((LA58_1==DOT)) { alt58 = 1; } } finally { DebugExitDecision(58); } switch (alt58) { case 1: DebugEnterAlt(1); // AS3T.g:871:4: DOT STAR { DebugLocation(871, 4); Match(input,DOT,Follow._DOT_in_identifierStar3109); if (state.failed) return retval; DebugLocation(871, 8); Match(input,STAR,Follow._STAR_in_identifierStar3111); if (state.failed) return retval; } break; } } finally { DebugExitSubRule(58); } } retval.Stop = (IToken)input.LT(-1); if (state.backtracking == 0) { retval.Template = new StringTemplate(TemplateGroup,input.ToString(retval.Start,input.LT(-1))); } } catch (RecognitionException re) { ReportError(re); Recover(input,re); } finally { TraceOut("identifierStar", 78); LeaveRule("identifierStar", 78); LeaveRule_identifierStar(); } DebugLocation(872, 1); } finally { DebugExitRule(GrammarFileName, "identifierStar"); } return retval; }
private TemplateParserRuleReturnScope<StringTemplate, IToken> arguments() { EnterRule_arguments(); EnterRule("arguments", 86); TraceIn("arguments", 86); TemplateParserRuleReturnScope<StringTemplate, IToken> retval = new TemplateParserRuleReturnScope<StringTemplate, IToken>(); retval.Start = (IToken)input.LT(1); try { DebugEnterRule(GrammarFileName, "arguments"); DebugLocation(935, 1); try { // AS3T.g:937:2: ( LPAREN expressionList RPAREN | LPAREN RPAREN ) int alt67=2; try { DebugEnterDecision(67, false); int LA67_1 = input.LA(1); if ((LA67_1==LPAREN)) { int LA67_2 = input.LA(2); if ((LA67_2==RPAREN)) { alt67 = 2; } else if ((LA67_2==AS||LA67_2==BNOT||(LA67_2>=DEC && LA67_2<=DECIMAL_LITERAL)||(LA67_2>=DYNAMIC && LA67_2<=E4X_ATTRI)||(LA67_2>=FALSE && LA67_2<=FLOAT_LITERAL)||LA67_2==FUNCTION||LA67_2==GET||(LA67_2>=HEX_LITERAL && LA67_2<=IDENT)||LA67_2==INC||(LA67_2>=INTERNAL && LA67_2<=IS)||(LA67_2>=LBRACK && LA67_2<=LCURLY)||LA67_2==LNOT||LA67_2==LPAREN||LA67_2==MINUS||LA67_2==NAMESPACE||LA67_2==NEW||LA67_2==NULL||LA67_2==OCTAL_LITERAL||LA67_2==PLUS||LA67_2==PRIVATE||(LA67_2>=PROTECTED && LA67_2<=PUBLIC)||LA67_2==REGEX_LITERAL||LA67_2==SET||(LA67_2>=STRING_LITERAL_DOUBLE && LA67_2<=SUPER)||(LA67_2>=TRACE && LA67_2<=TRUE)||LA67_2==USE||LA67_2==XML||LA67_2==XML_LITERAL||LA67_2==244||(LA67_2>=256 && LA67_2<=258))) { alt67 = 1; } else { if (state.backtracking>0) {state.failed=true; return retval;} NoViableAltException nvae = new NoViableAltException("", 67, 1, input, 2); DebugRecognitionException(nvae); throw nvae; } } else { if (state.backtracking>0) {state.failed=true; return retval;} NoViableAltException nvae = new NoViableAltException("", 67, 0, input, 1); DebugRecognitionException(nvae); throw nvae; } } finally { DebugExitDecision(67); } switch (alt67) { case 1: DebugEnterAlt(1); // AS3T.g:937:4: LPAREN expressionList RPAREN { DebugLocation(937, 4); Match(input,LPAREN,Follow._LPAREN_in_arguments3430); if (state.failed) return retval; DebugLocation(937, 11); PushFollow(Follow._expressionList_in_arguments3432); expressionList(); PopFollow(); if (state.failed) return retval; DebugLocation(937, 26); Match(input,RPAREN,Follow._RPAREN_in_arguments3434); if (state.failed) return retval; } break; case 2: DebugEnterAlt(2); // AS3T.g:938:4: LPAREN RPAREN { DebugLocation(938, 4); Match(input,LPAREN,Follow._LPAREN_in_arguments3439); if (state.failed) return retval; DebugLocation(938, 11); Match(input,RPAREN,Follow._RPAREN_in_arguments3441); if (state.failed) return retval; } break; } retval.Stop = (IToken)input.LT(-1); if (state.backtracking == 0) { retval.Template = new StringTemplate(TemplateGroup,input.ToString(retval.Start,input.LT(-1))); } } catch (RecognitionException re) { ReportError(re); Recover(input,re); } finally { TraceOut("arguments", 86); LeaveRule("arguments", 86); LeaveRule_arguments(); } DebugLocation(939, 1); } finally { DebugExitRule(GrammarFileName, "arguments"); } return retval; }
private TemplateParserRuleReturnScope<StringTemplate, IToken> as2Type() { EnterRule_as2Type(); EnterRule("as2Type", 4); TraceIn("as2Type", 4); TemplateParserRuleReturnScope<StringTemplate, IToken> retval = new TemplateParserRuleReturnScope<StringTemplate, IToken>(); retval.Start = (IToken)input.LT(1); try { DebugEnterRule(GrammarFileName, "as2Type"); DebugLocation(345, 1); try { // AS3T.g:346:2: ( ( as2IncludeDirective | ( modifiers CLASS )=> as2ClassDefinition | ( modifiers INTERFACE )=> as2InterfaceDefinition ) ) DebugEnterAlt(1); // AS3T.g:347:2: ( as2IncludeDirective | ( modifiers CLASS )=> as2ClassDefinition | ( modifiers INTERFACE )=> as2InterfaceDefinition ) { DebugLocation(347, 2); // AS3T.g:347:2: ( as2IncludeDirective | ( modifiers CLASS )=> as2ClassDefinition | ( modifiers INTERFACE )=> as2InterfaceDefinition ) int alt3=3; try { DebugEnterSubRule(3); try { DebugEnterDecision(3, false); try { alt3 = dfa3.Predict(input); } catch (NoViableAltException nvae) { DebugRecognitionException(nvae); throw; } } finally { DebugExitDecision(3); } switch (alt3) { case 1: DebugEnterAlt(1); // AS3T.g:347:4: as2IncludeDirective { DebugLocation(347, 4); PushFollow(Follow._as2IncludeDirective_in_as2Type530); as2IncludeDirective(); PopFollow(); if (state.failed) return retval; } break; case 2: DebugEnterAlt(2); // AS3T.g:348:4: ( modifiers CLASS )=> as2ClassDefinition { DebugLocation(348, 25); PushFollow(Follow._as2ClassDefinition_in_as2Type543); as2ClassDefinition(); PopFollow(); if (state.failed) return retval; } break; case 3: DebugEnterAlt(3); // AS3T.g:349:4: ( modifiers INTERFACE )=> as2InterfaceDefinition { DebugLocation(349, 29); PushFollow(Follow._as2InterfaceDefinition_in_as2Type556); as2InterfaceDefinition(); PopFollow(); if (state.failed) return retval; } break; } } finally { DebugExitSubRule(3); } } retval.Stop = (IToken)input.LT(-1); } catch (RecognitionException re) { ReportError(re); Recover(input,re); } finally { TraceOut("as2Type", 4); LeaveRule("as2Type", 4); LeaveRule_as2Type(); } DebugLocation(351, 1); } finally { DebugExitRule(GrammarFileName, "as2Type"); } return retval; }
private TemplateParserRuleReturnScope<StringTemplate, IToken> elementList() { EnterRule_elementList(); EnterRule("elementList", 88); TraceIn("elementList", 88); TemplateParserRuleReturnScope<StringTemplate, IToken> retval = new TemplateParserRuleReturnScope<StringTemplate, IToken>(); retval.Start = (IToken)input.LT(1); try { DebugEnterRule(GrammarFileName, "elementList"); DebugLocation(946, 1); try { // AS3T.g:947:2: ( COMMA | nonemptyElementList ) int alt69=2; try { DebugEnterDecision(69, false); int LA69_1 = input.LA(1); if ((LA69_1==COMMA)) { alt69 = 1; } else if ((LA69_1==AS||LA69_1==BNOT||(LA69_1>=DEC && LA69_1<=DECIMAL_LITERAL)||(LA69_1>=DYNAMIC && LA69_1<=E4X_ATTRI)||(LA69_1>=FALSE && LA69_1<=FLOAT_LITERAL)||LA69_1==FUNCTION||LA69_1==GET||(LA69_1>=HEX_LITERAL && LA69_1<=IDENT)||LA69_1==INC||(LA69_1>=INTERNAL && LA69_1<=IS)||(LA69_1>=LBRACK && LA69_1<=LCURLY)||LA69_1==LNOT||LA69_1==LPAREN||LA69_1==MINUS||LA69_1==NAMESPACE||LA69_1==NEW||LA69_1==NULL||LA69_1==OCTAL_LITERAL||LA69_1==PLUS||LA69_1==PRIVATE||(LA69_1>=PROTECTED && LA69_1<=PUBLIC)||LA69_1==REGEX_LITERAL||LA69_1==SET||(LA69_1>=STRING_LITERAL_DOUBLE && LA69_1<=SUPER)||(LA69_1>=TRACE && LA69_1<=TRUE)||LA69_1==USE||LA69_1==XML||LA69_1==XML_LITERAL||LA69_1==244||(LA69_1>=256 && LA69_1<=258))) { alt69 = 2; } else { if (state.backtracking>0) {state.failed=true; return retval;} NoViableAltException nvae = new NoViableAltException("", 69, 0, input, 1); DebugRecognitionException(nvae); throw nvae; } } finally { DebugExitDecision(69); } switch (alt69) { case 1: DebugEnterAlt(1); // AS3T.g:947:4: COMMA { DebugLocation(947, 4); Match(input,COMMA,Follow._COMMA_in_elementList3471); if (state.failed) return retval; } break; case 2: DebugEnterAlt(2); // AS3T.g:948:4: nonemptyElementList { DebugLocation(948, 4); PushFollow(Follow._nonemptyElementList_in_elementList3476); nonemptyElementList(); PopFollow(); if (state.failed) return retval; } break; } retval.Stop = (IToken)input.LT(-1); } catch (RecognitionException re) { ReportError(re); Recover(input,re); } finally { TraceOut("elementList", 88); LeaveRule("elementList", 88); LeaveRule_elementList(); } DebugLocation(949, 1); } finally { DebugExitRule(GrammarFileName, "elementList"); } return retval; }
private TemplateParserRuleReturnScope<StringTemplate, IToken> dotIdent() { EnterRule_dotIdent(); EnterRule("dotIdent", 79); TraceIn("dotIdent", 79); TemplateParserRuleReturnScope<StringTemplate, IToken> retval = new TemplateParserRuleReturnScope<StringTemplate, IToken>(); retval.Start = (IToken)input.LT(1); TemplateParserRuleReturnScope<StringTemplate, IToken> ident23 = default(TemplateParserRuleReturnScope<StringTemplate, IToken>); try { DebugEnterRule(GrammarFileName, "dotIdent"); DebugLocation(874, 4); try { // AS3T.g:875:5: ( DOT ident -> path(p=$ident.text)) DebugEnterAlt(1); // AS3T.g:875:7: DOT ident { DebugLocation(875, 7); Match(input,DOT,Follow._DOT_in_dotIdent3127); if (state.failed) return retval; DebugLocation(875, 11); PushFollow(Follow._ident_in_dotIdent3129); ident23=ident(); PopFollow(); if (state.failed) return retval; // TEMPLATE REWRITE if (state.backtracking == 0) { // 875:17: -> path(p=$ident.text) { retval.Template = TemplateGroup.GetInstanceOf("path", new Dictionary<string, object>() { {"p", (ident23!=null?input.ToString(ident23.Start,ident23.Stop):null)} } ); } ((TokenRewriteStream)input).Replace( retval.Start.TokenIndex, input.LT(-1).TokenIndex, retval.Template); } } retval.Stop = (IToken)input.LT(-1); } catch (RecognitionException re) { ReportError(re); Recover(input,re); } finally { TraceOut("dotIdent", 79); LeaveRule("dotIdent", 79); LeaveRule_dotIdent(); } DebugLocation(876, 4); } finally { DebugExitRule(GrammarFileName, "dotIdent"); } return retval; }
private TemplateParserRuleReturnScope<StringTemplate, IToken> element() { EnterRule_element(); EnterRule("element", 90); TraceIn("element", 90); TemplateParserRuleReturnScope<StringTemplate, IToken> retval = new TemplateParserRuleReturnScope<StringTemplate, IToken>(); retval.Start = (IToken)input.LT(1); try { DebugEnterRule(GrammarFileName, "element"); DebugLocation(955, 1); try { // AS3T.g:956:2: ( assignmentExpression ) DebugEnterAlt(1); // AS3T.g:956:4: assignmentExpression { DebugLocation(956, 4); PushFollow(Follow._assignmentExpression_in_element3505); assignmentExpression(); PopFollow(); if (state.failed) return retval; } retval.Stop = (IToken)input.LT(-1); } catch (RecognitionException re) { ReportError(re); Recover(input,re); } finally { TraceOut("element", 90); LeaveRule("element", 90); LeaveRule_element(); } DebugLocation(957, 1); } finally { DebugExitRule(GrammarFileName, "element"); } return retval; }
private TemplateParserRuleReturnScope<StringTemplate, IToken> ident() { EnterRule_ident(); EnterRule("ident", 80); TraceIn("ident", 80); TemplateParserRuleReturnScope<StringTemplate, IToken> retval = new TemplateParserRuleReturnScope<StringTemplate, IToken>(); retval.Start = (IToken)input.LT(1); IToken z = default(IToken); try { DebugEnterRule(GrammarFileName, "ident"); DebugLocation(878, 1); try { // AS3T.g:880:2: ( IDENT | USE | XML | TRACE | DYNAMIC | NAMESPACE | IS | AS | GET | SET |z= SUPER -> comment(s=$z.text)) int alt59=11; try { DebugEnterDecision(59, false); switch (input.LA(1)) { case IDENT: { alt59 = 1; } break; case USE: { alt59 = 2; } break; case XML: { alt59 = 3; } break; case TRACE: { alt59 = 4; } break; case DYNAMIC: { alt59 = 5; } break; case NAMESPACE: { alt59 = 6; } break; case IS: { alt59 = 7; } break; case AS: { alt59 = 8; } break; case GET: { alt59 = 9; } break; case SET: { alt59 = 10; } break; case SUPER: { alt59 = 11; } break; default: { if (state.backtracking>0) {state.failed=true; return retval;} NoViableAltException nvae = new NoViableAltException("", 59, 0, input, 1); DebugRecognitionException(nvae); throw nvae; } } } finally { DebugExitDecision(59); } switch (alt59) { case 1: DebugEnterAlt(1); // AS3T.g:880:4: IDENT { DebugLocation(880, 4); Match(input,IDENT,Follow._IDENT_in_ident3157); if (state.failed) return retval; } break; case 2: DebugEnterAlt(2); // AS3T.g:881:4: USE { DebugLocation(881, 4); Match(input,USE,Follow._USE_in_ident3163); if (state.failed) return retval; } break; case 3: DebugEnterAlt(3); // AS3T.g:882:4: XML { DebugLocation(882, 4); Match(input,XML,Follow._XML_in_ident3168); if (state.failed) return retval; } break; case 4: DebugEnterAlt(4); // AS3T.g:883:4: TRACE { DebugLocation(883, 4); Match(input,TRACE,Follow._TRACE_in_ident3173); if (state.failed) return retval; } break; case 5: DebugEnterAlt(5); // AS3T.g:884:4: DYNAMIC { DebugLocation(884, 4); Match(input,DYNAMIC,Follow._DYNAMIC_in_ident3178); if (state.failed) return retval; } break; case 6: DebugEnterAlt(6); // AS3T.g:885:4: NAMESPACE { DebugLocation(885, 4); Match(input,NAMESPACE,Follow._NAMESPACE_in_ident3183); if (state.failed) return retval; } break; case 7: DebugEnterAlt(7); // AS3T.g:886:4: IS { DebugLocation(886, 4); Match(input,IS,Follow._IS_in_ident3188); if (state.failed) return retval; } break; case 8: DebugEnterAlt(8); // AS3T.g:887:4: AS { DebugLocation(887, 4); Match(input,AS,Follow._AS_in_ident3193); if (state.failed) return retval; } break; case 9: DebugEnterAlt(9); // AS3T.g:888:4: GET { DebugLocation(888, 4); Match(input,GET,Follow._GET_in_ident3198); if (state.failed) return retval; } break; case 10: DebugEnterAlt(10); // AS3T.g:889:4: SET { DebugLocation(889, 4); Match(input,SET,Follow._SET_in_ident3203); if (state.failed) return retval; } break; case 11: DebugEnterAlt(11); // AS3T.g:890:4: z= SUPER { DebugLocation(890, 5); z=(IToken)Match(input,SUPER,Follow._SUPER_in_ident3210); if (state.failed) return retval; // TEMPLATE REWRITE if (state.backtracking == 0) { // 890:12: -> comment(s=$z.text) { retval.Template = TemplateGroup.GetInstanceOf("comment", new Dictionary<string, object>() { {"s", (z!=null?z.Text:null)} } ); } ((TokenRewriteStream)input).Replace( retval.Start.TokenIndex, input.LT(-1).TokenIndex, retval.Template); } } break; } retval.Stop = (IToken)input.LT(-1); if (state.backtracking == 0) { retval.Template = new StringTemplate(TemplateGroup,input.ToString(retval.Start,input.LT(-1))); } } catch (RecognitionException re) { ReportError(re); Recover(input,re); } finally { TraceOut("ident", 80); LeaveRule("ident", 80); LeaveRule_ident(); } DebugLocation(891, 1); } finally { DebugExitRule(GrammarFileName, "ident"); } return retval; }
private TemplateParserRuleReturnScope<StringTemplate, IToken> fieldList() { EnterRule_fieldList(); EnterRule("fieldList", 92); TraceIn("fieldList", 92); TemplateParserRuleReturnScope<StringTemplate, IToken> retval = new TemplateParserRuleReturnScope<StringTemplate, IToken>(); retval.Start = (IToken)input.LT(1); try { DebugEnterRule(GrammarFileName, "fieldList"); DebugLocation(964, 1); try { // AS3T.g:965:2: ( literalField ( COMMA ( literalField )? )* ) DebugEnterAlt(1); // AS3T.g:965:4: literalField ( COMMA ( literalField )? )* { DebugLocation(965, 4); PushFollow(Follow._literalField_in_fieldList3534); literalField(); PopFollow(); if (state.failed) return retval; DebugLocation(965, 17); // AS3T.g:965:17: ( COMMA ( literalField )? )* try { DebugEnterSubRule(73); while (true) { int alt73=2; try { DebugEnterDecision(73, false); int LA73_1 = input.LA(1); if ((LA73_1==COMMA)) { alt73 = 1; } } finally { DebugExitDecision(73); } switch ( alt73 ) { case 1: DebugEnterAlt(1); // AS3T.g:965:18: COMMA ( literalField )? { DebugLocation(965, 18); Match(input,COMMA,Follow._COMMA_in_fieldList3537); if (state.failed) return retval; DebugLocation(965, 24); // AS3T.g:965:24: ( literalField )? int alt72=2; try { DebugEnterSubRule(72); try { DebugEnterDecision(72, false); int LA72_1 = input.LA(1); if ((LA72_1==AS||LA72_1==DECIMAL_LITERAL||LA72_1==DYNAMIC||LA72_1==FLOAT_LITERAL||LA72_1==GET||(LA72_1>=HEX_LITERAL && LA72_1<=IDENT)||LA72_1==IS||LA72_1==NAMESPACE||LA72_1==OCTAL_LITERAL||LA72_1==SET||LA72_1==SUPER||LA72_1==TRACE||LA72_1==USE||LA72_1==XML)) { alt72 = 1; } } finally { DebugExitDecision(72); } switch (alt72) { case 1: DebugEnterAlt(1); // AS3T.g:965:24: literalField { DebugLocation(965, 24); PushFollow(Follow._literalField_in_fieldList3539); literalField(); PopFollow(); if (state.failed) return retval; } break; } } finally { DebugExitSubRule(72); } } break; default: goto loop73; } } loop73: ; } finally { DebugExitSubRule(73); } } retval.Stop = (IToken)input.LT(-1); } catch (RecognitionException re) { ReportError(re); Recover(input,re); } finally { TraceOut("fieldList", 92); LeaveRule("fieldList", 92); LeaveRule_fieldList(); } DebugLocation(966, 1); } finally { DebugExitRule(GrammarFileName, "fieldList"); } return retval; }
private TemplateParserRuleReturnScope<StringTemplate, IToken> annotation() { EnterRule_annotation(); EnterRule("annotation", 81); TraceIn("annotation", 81); TemplateParserRuleReturnScope<StringTemplate, IToken> retval = new TemplateParserRuleReturnScope<StringTemplate, IToken>(); retval.Start = (IToken)input.LT(1); try { DebugEnterRule(GrammarFileName, "annotation"); DebugLocation(893, 1); try { // AS3T.g:895:2: ( LBRACK ident ( annotationParamList )? RBRACK -> notsupported(s=$text)) DebugEnterAlt(1); // AS3T.g:895:4: LBRACK ident ( annotationParamList )? RBRACK { DebugLocation(895, 4); Match(input,LBRACK,Follow._LBRACK_in_annotation3235); if (state.failed) return retval; DebugLocation(896, 3); PushFollow(Follow._ident_in_annotation3239); ident(); PopFollow(); if (state.failed) return retval; DebugLocation(897, 3); // AS3T.g:897:3: ( annotationParamList )? int alt60=2; try { DebugEnterSubRule(60); try { DebugEnterDecision(60, false); int LA60_1 = input.LA(1); if ((LA60_1==LPAREN)) { alt60 = 1; } } finally { DebugExitDecision(60); } switch (alt60) { case 1: DebugEnterAlt(1); // AS3T.g:897:3: annotationParamList { DebugLocation(897, 3); PushFollow(Follow._annotationParamList_in_annotation3243); annotationParamList(); PopFollow(); if (state.failed) return retval; } break; } } finally { DebugExitSubRule(60); } DebugLocation(898, 3); Match(input,RBRACK,Follow._RBRACK_in_annotation3248); if (state.failed) return retval; // TEMPLATE REWRITE if (state.backtracking == 0) { // 898:10: -> notsupported(s=$text) { retval.Template = TemplateGroup.GetInstanceOf("notsupported", new Dictionary<string, object>() { {"s", input.ToString(retval.Start,input.LT(-1))} } ); } ((TokenRewriteStream)input).Replace( retval.Start.TokenIndex, input.LT(-1).TokenIndex, retval.Template); } } retval.Stop = (IToken)input.LT(-1); if (state.backtracking == 0) { retval.Template = new StringTemplate(TemplateGroup,input.ToString(retval.Start,input.LT(-1))); } } catch (RecognitionException re) { ReportError(re); Recover(input,re); } finally { TraceOut("annotation", 81); LeaveRule("annotation", 81); LeaveRule_annotation(); } DebugLocation(900, 1); } finally { DebugExitRule(GrammarFileName, "annotation"); } return retval; }
private TemplateParserRuleReturnScope<StringTemplate, IToken> fieldName() { EnterRule_fieldName(); EnterRule("fieldName", 94); TraceIn("fieldName", 94); TemplateParserRuleReturnScope<StringTemplate, IToken> retval = new TemplateParserRuleReturnScope<StringTemplate, IToken>(); retval.Start = (IToken)input.LT(1); try { DebugEnterRule(GrammarFileName, "fieldName"); DebugLocation(972, 1); try { // AS3T.g:973:2: ( ident | number ) int alt74=2; try { DebugEnterDecision(74, false); int LA74_1 = input.LA(1); if ((LA74_1==AS||LA74_1==DYNAMIC||LA74_1==GET||LA74_1==IDENT||LA74_1==IS||LA74_1==NAMESPACE||LA74_1==SET||LA74_1==SUPER||LA74_1==TRACE||LA74_1==USE||LA74_1==XML)) { alt74 = 1; } else if ((LA74_1==DECIMAL_LITERAL||LA74_1==FLOAT_LITERAL||LA74_1==HEX_LITERAL||LA74_1==OCTAL_LITERAL)) { alt74 = 2; } else { if (state.backtracking>0) {state.failed=true; return retval;} NoViableAltException nvae = new NoViableAltException("", 74, 0, input, 1); DebugRecognitionException(nvae); throw nvae; } } finally { DebugExitDecision(74); } switch (alt74) { case 1: DebugEnterAlt(1); // AS3T.g:973:4: ident { DebugLocation(973, 4); PushFollow(Follow._ident_in_fieldName3572); ident(); PopFollow(); if (state.failed) return retval; } break; case 2: DebugEnterAlt(2); // AS3T.g:974:4: number { DebugLocation(974, 4); PushFollow(Follow._number_in_fieldName3577); number(); PopFollow(); if (state.failed) return retval; } break; } retval.Stop = (IToken)input.LT(-1); } catch (RecognitionException re) { ReportError(re); Recover(input,re); } finally { TraceOut("fieldName", 94); LeaveRule("fieldName", 94); LeaveRule_fieldName(); } DebugLocation(975, 1); } finally { DebugExitRule(GrammarFileName, "fieldName"); } return retval; }
private TemplateParserRuleReturnScope<StringTemplate, IToken> forIter() { EnterRule_forIter(); EnterRule("forIter", 67); TraceIn("forIter", 67); TemplateParserRuleReturnScope<StringTemplate, IToken> retval = new TemplateParserRuleReturnScope<StringTemplate, IToken>(); retval.Start = (IToken)input.LT(1); try { DebugEnterRule(GrammarFileName, "forIter"); DebugLocation(806, 1); try { // AS3T.g:808:2: ( ( expressionList )? ) DebugEnterAlt(1); // AS3T.g:808:4: ( expressionList )? { DebugLocation(808, 4); // AS3T.g:808:4: ( expressionList )? int alt50=2; try { DebugEnterSubRule(50); try { DebugEnterDecision(50, false); int LA50_1 = input.LA(1); if ((LA50_1==AS||LA50_1==BNOT||(LA50_1>=DEC && LA50_1<=DECIMAL_LITERAL)||(LA50_1>=DYNAMIC && LA50_1<=E4X_ATTRI)||(LA50_1>=FALSE && LA50_1<=FLOAT_LITERAL)||LA50_1==FUNCTION||LA50_1==GET||(LA50_1>=HEX_LITERAL && LA50_1<=IDENT)||LA50_1==INC||(LA50_1>=INTERNAL && LA50_1<=IS)||(LA50_1>=LBRACK && LA50_1<=LCURLY)||LA50_1==LNOT||LA50_1==LPAREN||LA50_1==MINUS||LA50_1==NAMESPACE||LA50_1==NEW||LA50_1==NULL||LA50_1==OCTAL_LITERAL||LA50_1==PLUS||LA50_1==PRIVATE||(LA50_1>=PROTECTED && LA50_1<=PUBLIC)||LA50_1==REGEX_LITERAL||LA50_1==SET||(LA50_1>=STRING_LITERAL_DOUBLE && LA50_1<=SUPER)||(LA50_1>=TRACE && LA50_1<=TRUE)||LA50_1==USE||LA50_1==XML||LA50_1==XML_LITERAL||LA50_1==244||(LA50_1>=256 && LA50_1<=258))) { alt50 = 1; } } finally { DebugExitDecision(50); } switch (alt50) { case 1: DebugEnterAlt(1); // AS3T.g:808:4: expressionList { DebugLocation(808, 4); PushFollow(Follow._expressionList_in_forIter2760); expressionList(); PopFollow(); if (state.failed) return retval; } break; } } finally { DebugExitSubRule(50); } } retval.Stop = (IToken)input.LT(-1); if (state.backtracking == 0) { retval.Template = new StringTemplate(TemplateGroup,input.ToString(retval.Start,input.LT(-1))); } } catch (RecognitionException re) { ReportError(re); Recover(input,re); } finally { TraceOut("forIter", 67); LeaveRule("forIter", 67); LeaveRule_forIter(); } DebugLocation(809, 1); } finally { DebugExitRule(GrammarFileName, "forIter"); } return retval; }