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