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