org.apache.myfaces.trinidadbuild.plugin.javascript.javascript20parser.js2.0.jj Maven / Gradle / Ivy
The newest version!
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
/*@bgen(jjtree) Generated By:JJTree: Do not edit this line. .\js2.0.jj */
/*@egen*/options {
STATIC=false;
DEBUG_TOKEN_MANAGER=false;
DEBUG_PARSER=false;
}
PARSER_BEGIN(JSParser20)
package org.apache.myfaces.trinidadbuild.plugin.javascript.javascript20parser;
import java.io.IOException;
public class JSParser20/*@bgen(jjtree)*/implements JSParser20TreeConstants/*@egen*/
{/*@bgen(jjtree)*/
protected JJTJSParser20State jjtree = new JJTJSParser20State();
/*@egen*/
//
// This is the root node for the parse tree (root DOM node, tree of SimpleNode(s))
//
protected ASTProgram _jjtRoot;
public ASTProgram getRootNode()
{
return _jjtRoot;
}
}
PARSER_END(JSParser20)
/////////////////////////////////////////////////////
// LEXICAL RULES Section
/////////////////////////////////////////////////////
TOKEN_MGR_DECLS :
{
private boolean isRegValid = true;
public void setRegInvalid()
{
isRegValid = false;
}
public void setRegValid()
{
isRegValid = true;
}
}
/////////////////////////////////////////////////////
// WHITE SPACE
/////////////////////////////////////////////////////
SPECIAL_TOKEN :
{
|
}
/////////////////////////////////////////////////////
// COMMENTS
/////////////////////////////////////////////////////
MORE :
{
"//" : IN_SINGLE_LINE_COMMENT
| "/*" : IN_MULTI_LINE_COMMENT
}
SPECIAL_TOKEN :
{
< SINGLE_LINE_COMMENT: (~["\n","\r"])* ("\n"|"\r"|"\r\n")? > : DEFAULT
}
SPECIAL_TOKEN :
{
: DEFAULT
}
MORE :
{
< ~[] >
}
/////////////////////////////////////////////////////
// RESERVED WORDS AND LITERALS
/////////////////////////////////////////////////////
TOKEN :
{
< AS: "as" >
| < BREAK: "break" >
| < CASE: "case" >
| < CATCH: "catch" >
| < CLASS: "class" >
| < CONST: "const" >
| < CONTINUE: "continue" >
| < _DEFAULT: "default" >
| < DELETE: "delete" >
| < DO: "do" >
| < ELSE: "else" >
| < EXTENDS: "extends" >
| < FALSE: "false" >
| < FINALLY: "finally" >
| < FOR: "for" >
| < FUNCTION: "function" >
| < FUNCTION_: "Function" >
| < GET: "get" >
| < IF: "if" >
| < IN: "in" >
| < INCLUDE: "include" >
| < INSTANCEOF: "instanceof" >
| < IS: "is" >
| < NAMESPACE: "namespace" >
| < NEW: "new" >
| < NULL: "null" >
| < PACKAGE: "package" >
| < PRIVATE: "private" >
| < PUBLIC: "public" >
| < RETURN: "return" >
| < SET: "set" >
| < SUPER: "super" >
| < SWITCH: "switch" >
| < THIS: "this" >
| < THROW: "throw" >
| < TRUE: "true" >
| < TRY: "try" >
| < TYPEOF: "typeof" >
| < USE: "use" >
| < VAR: "var" >
| < VOID: "void" >
| < WHILE: "while" >
| < WITH: "with" >
}
/////////////////////////////////////////////////////
// FUTURE RESERVED WORDS
/////////////////////////////////////////////////////
TOKEN :
{
< ABSTRACT: "abstract" >
| < DEBUGGER: "debugger" >
| < ENUM: "enum" >
| < EXPORT: "export" >
| < GOTO: "goto" >
| < IMPLEMENTS: "implements" >
| < INTERFACE: "interface" >
| < NATIVE: "native" >
| < PROTECTED: "protected" >
| < SYNCHRONIZED: "synchronized" >
| < THROWS: "throws" >
| < TRANSIENT: "transient" >
| < VOLATILE: "volatile" >
| < IMPORT: "import" >
}
/////////////////////////////////////////////////////
// LITERALS
/////////////////////////////////////////////////////
TOKEN :
{
< DECIMAL_LITERAL: ["1"-"9"] (["0"-"9"])* >
| < HEX_LITERAL: "0" ["x","X"] (["0"-"9","a"-"f","A"-"F"])+ >
| < OCTAL_LITERAL: "0" (["0"-"7"])* >
| < FLOATING_POINT_LITERAL: (["0"-"9"])+ "." (["0"-"9"])* ()?
| "." (["0"-"9"])+ ()?
| (["0"-"9"])+ ()?
>
| < #EXPONENT: ["e","E"] (["+","-"])? (["0"-"9"])+ >
| < STRING_LITERAL: "\""
( (~["\"","\\","\n","\r"]) | )*
"\""
| "\""
( (~["\"","\\"]) | "\\" ("\n" | "\r" | "\r\n") | )*
"\""
| "'"
( (~["'","\\","\n","\r"]) | )*
"'"
>
| < #ESCAPE_SEQUENCE:
"\\"
( ["n","t","b","r","f","\\","'","\"","[","]"]
| ["0"-"7"] ( ["0"-"7"] )?
| ["0"-"3"] ["0"-"7"] ["0"-"7"]
| ["x"] ["0"-"9","a"-"f","A"-"F"] ["0"-"9","a"-"f","A"-"F"]
| ["u"] ["0"-"9","a"-"f","A"-"F"] ["0"-"9","a"-"f","A"-"F"]
["0"-"9","a"-"f","A"-"F"] ["0"-"9","a"-"f","A"-"F"]
)
>
| < UNTERMINATED_STRING_LITERAL:
"\"" ( (~["\"","\\","\n","\r"]) | )* ( ["\n","\r"] )?
| "'" ( (~["'","\\","\n","\r"]) | )* ( ["\n","\r"] )?
>
}
/////////////////////////////////////////////////////
// REGULAR EXPRESSIONS
/////////////////////////////////////////////////////
TOKEN :
{
< #REGX_START_CHAR : ~["\r","\n","/","=","*"] | "\\/">
| < #REGX_BODY_CHAR_EXCLUSION : ~["\r","\n","/"] >
| < #REGX_BODY_CHAR : ( | "\\/" ) >
| < #REGEX_END_CHAR : "i"
| "g"
| "m"
| "ig"
| "im"
| "gi"
| "gm"
| "mi"
| "mg"
| "igm"
| "img"
| "gmi"
| "gim"
| "mig"
| "mgi"
>
}
TOKEN :
{
()* "/" ()? >
{
try {
// Peek at the next character.
char nextCh = input_stream.readChar();
input_stream.backup(1);
if (isRegValid == false || nextCh == '/' || nextCh == '*') {
//
// Lexecal analyser thinks it is a RE
// operator such as /...../
// Put the everything to the first "/" back on the input stream
//
input_stream.backup(lengthOfMatch-1);
//
// And remove it from the token
//
matchedToken.image = matchedToken.image.substring(0, 1);
image.delete(0, image.length() - 1);
image.append('/');
matchedToken.kind=SLASH;
}
} catch (IOException e) {
throw new Error(e.toString());
}
}
}
/////////////////////////////////////////////////////
// IDENTIFIERS
/////////////////////////////////////////////////////
TOKEN :
{
< IDENTIFIER: (|)* >
| < #LETTER: ["a"-"z","A"-"Z","$","_"] >
| < #DIGIT: ["0"-"9"]>
}
/////////////////////////////////////////////////////
// SEPARATORS
/////////////////////////////////////////////////////
TOKEN :
{
< LPAREN: "(" >
| < RPAREN: ")" >
| < LBRACE: "{" >
| < RBRACE: "}" >
| < LBRACKET: "[" >
| < RBRACKET: "]" >
| < SEMICOLON: ";" >
| < COMMA: "," >
| < DOT: "." >
| < QUALIFIER: "::" >
| < ELIPSE: "..." >
}
/////////////////////////////////////////////////////
// OPERATORS
/////////////////////////////////////////////////////
TOKEN :
{
< ASSIGN: "=" >
| < GT: ">" >
| < LT: "<" >
| < BANG: "!" >
| < TILDE: "~" >
| < HOOK: "?" >
| < COLON: ":" >
| < EQ: "==" >
| < LE: "<=" >
| < GE: ">=" >
| < NE: "!=" >
| < SC_OR: "||" >
| < SC_AND: "&&" >
| < SC_XOR: "^^" >
| < INCR: "++" >
| < DECR: "--" >
| < PLUS: "+" >
| < MINUS: "-" >
| < STAR: "*" >
| < SLASH: "/" >
| < BIT_AND: "&" >
| < BIT_OR: "|" >
| < XOR: "^" >
| < REM: "%" >
| < LSHIFT: "<<" >
| < RSIGNEDSHIFT: ">>" >
| < RUNSIGNEDSHIFT: ">>>" >
| < PLUSASSIGN: "+=" >
| < MINUSASSIGN: "-=" >
| < STARASSIGN: "*=" >
| < SLASHASSIGN: "/=" >
| < ANDASSIGN: "&=" >
| < ORASSIGN: "|=" >
| < XORASSIGN: "^=" >
| < REMASSIGN: "%=" >
| < LSHIFTASSIGN: "<<=" >
| < RSIGNEDSHIFTASSIGN: ">>=" >
| < RUNSIGNEDSHIFTASSIGN: ">>>=" >
| < SC_ORASSIGN: "||=" >
| < SC_ANDASSIGN: "&&=" >
| < SC_XORASSIGN: "^^=" >
| < IDENTITYOPER: "===" >
| < NOTIDENTITYOPER: "!==" >
}
///////////////////////////////////////////////////////////////////
// GRAMMAR Section
///////////////////////////////////////////////////////////////////
Token Program():
{/*@bgen(jjtree) Program */
ASTProgram jjtn000 = new ASTProgram(this, JJTPROGRAM);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/
Token retval = getToken(1);
}
{/*@bgen(jjtree) Program */
try {
/*@egen*/
(PackageDefinition())* [Directives()] /*@bgen(jjtree)*/
{
jjtree.closeNodeScope(jjtn000, true);
jjtc000 = false;
}
/*@egen*/
{
_jjtRoot = jjtn000;
return retval;
}/*@bgen(jjtree)*/
} catch (Throwable jjte000) {
if (jjtc000) {
jjtree.clearNodeScope(jjtn000);
jjtc000 = false;
} else {
jjtree.popNode();
}
if (jjte000 instanceof RuntimeException) {
throw (RuntimeException)jjte000;
}
if (jjte000 instanceof ParseException) {
throw (ParseException)jjte000;
}
throw (Error)jjte000;
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
/////////////////////////////////////////////////////
// Expressions
/////////////////////////////////////////////////////
/////////////////////////////////////////////////////
// Identifier
/////////////////////////////////////////////////////
void Identifier():
{/*@bgen(jjtree) Identifier */
ASTIdentifier jjtn000 = new ASTIdentifier(this, JJTIDENTIFIER);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) Identifier */
try {
/*@egen*/
|
|
| /*@bgen(jjtree)*/
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
// |
}
/////////////////////////////////////////////////////
// Qualified Identifier
/////////////////////////////////////////////////////
void SimpleQualifiedIdentifier():
{/*@bgen(jjtree) SimpleQualifiedIdentifier */
ASTSimpleQualifiedIdentifier jjtn000 = new ASTSimpleQualifiedIdentifier(this, JJTSIMPLEQUALIFIEDIDENTIFIER);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) SimpleQualifiedIdentifier */
try {
/*@egen*/
Identifier() [ Identifier()]
| ReservedNamespace() [ Identifier()]/*@bgen(jjtree)*/
} catch (Throwable jjte000) {
if (jjtc000) {
jjtree.clearNodeScope(jjtn000);
jjtc000 = false;
} else {
jjtree.popNode();
}
if (jjte000 instanceof RuntimeException) {
throw (RuntimeException)jjte000;
}
if (jjte000 instanceof ParseException) {
throw (ParseException)jjte000;
}
throw (Error)jjte000;
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
void ExpressionQualifiedIdentifier():
{/*@bgen(jjtree) ExpressionQualifiedIdentifier */
ASTExpressionQualifiedIdentifier jjtn000 = new ASTExpressionQualifiedIdentifier(this, JJTEXPRESSIONQUALIFIEDIDENTIFIER);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) ExpressionQualifiedIdentifier */
try {
/*@egen*/
AssignmentExpression() Identifier()/*@bgen(jjtree)*/
} catch (Throwable jjte000) {
if (jjtc000) {
jjtree.clearNodeScope(jjtn000);
jjtc000 = false;
} else {
jjtree.popNode();
}
if (jjte000 instanceof RuntimeException) {
throw (RuntimeException)jjte000;
}
if (jjte000 instanceof ParseException) {
throw (ParseException)jjte000;
}
throw (Error)jjte000;
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
void QualifiedIdentifier():
{/*@bgen(jjtree) QualifiedIdentifier */
ASTQualifiedIdentifier jjtn000 = new ASTQualifiedIdentifier(this, JJTQUALIFIEDIDENTIFIER);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) QualifiedIdentifier */
try {
/*@egen*/
SimpleQualifiedIdentifier()
| ExpressionQualifiedIdentifier()/*@bgen(jjtree)*/
} catch (Throwable jjte000) {
if (jjtc000) {
jjtree.clearNodeScope(jjtn000);
jjtc000 = false;
} else {
jjtree.popNode();
}
if (jjte000 instanceof RuntimeException) {
throw (RuntimeException)jjte000;
}
if (jjte000 instanceof ParseException) {
throw (ParseException)jjte000;
}
throw (Error)jjte000;
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
/////////////////////////////////////////////////////
// Primary Expressions
/////////////////////////////////////////////////////
void PrimaryExpression ():
{/*@bgen(jjtree) PrimaryExpression */
ASTPrimaryExpression jjtn000 = new ASTPrimaryExpression(this, JJTPRIMARYEXPRESSION);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) PrimaryExpression */
try {
/*@egen*/
(
|
|
|
|
|
|
|
|
|
| ListExpression()
| ArrayLiteral()
| ObjectLiteral()
| FunctionExpression()
)/*@bgen(jjtree)*/
{
jjtree.closeNodeScope(jjtn000, true);
jjtc000 = false;
}
/*@egen*/
{
token_source.setRegValid();
}/*@bgen(jjtree)*/
} catch (Throwable jjte000) {
if (jjtc000) {
jjtree.clearNodeScope(jjtn000);
jjtc000 = false;
} else {
jjtree.popNode();
}
if (jjte000 instanceof RuntimeException) {
throw (RuntimeException)jjte000;
}
if (jjte000 instanceof ParseException) {
throw (ParseException)jjte000;
}
throw (Error)jjte000;
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
void ReservedNamespace ():
{/*@bgen(jjtree) ReservedNamespace */
ASTReservedNamespace jjtn000 = new ASTReservedNamespace(this, JJTRESERVEDNAMESPACE);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) ReservedNamespace */
try {
/*@egen*/
|
| /*@bgen(jjtree)*/
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
/////////////////////////////////////////////////////
// Function Expression
/////////////////////////////////////////////////////
void FunctionExpression ():
{/*@bgen(jjtree) FunctionExpression */
ASTFunctionExpression jjtn000 = new ASTFunctionExpression(this, JJTFUNCTIONEXPRESSION);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) FunctionExpression */
try {
/*@egen*/
LOOKAHEAD(2) FunctionCommon()
| Identifier() FunctionCommon()/*@bgen(jjtree)*/
} catch (Throwable jjte000) {
if (jjtc000) {
jjtree.clearNodeScope(jjtn000);
jjtc000 = false;
} else {
jjtree.popNode();
}
if (jjte000 instanceof RuntimeException) {
throw (RuntimeException)jjte000;
}
if (jjte000 instanceof ParseException) {
throw (ParseException)jjte000;
}
throw (Error)jjte000;
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
/////////////////////////////////////////////////////
// Object Literals
/////////////////////////////////////////////////////
void ObjectLiteral ():
{/*@bgen(jjtree) ObjectLiteral */
ASTObjectLiteral jjtn000 = new ASTObjectLiteral(this, JJTOBJECTLITERAL);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) ObjectLiteral */
try {
/*@egen*/
[FieldList()] /*@bgen(jjtree)*/
} catch (Throwable jjte000) {
if (jjtc000) {
jjtree.clearNodeScope(jjtn000);
jjtc000 = false;
} else {
jjtree.popNode();
}
if (jjte000 instanceof RuntimeException) {
throw (RuntimeException)jjte000;
}
if (jjte000 instanceof ParseException) {
throw (ParseException)jjte000;
}
throw (Error)jjte000;
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
void FieldList():
{/*@bgen(jjtree) FieldList */
ASTFieldList jjtn000 = new ASTFieldList(this, JJTFIELDLIST);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) FieldList */
try {
/*@egen*/
LiteralField() ( LiteralField())*/*@bgen(jjtree)*/
} catch (Throwable jjte000) {
if (jjtc000) {
jjtree.clearNodeScope(jjtn000);
jjtc000 = false;
} else {
jjtree.popNode();
}
if (jjte000 instanceof RuntimeException) {
throw (RuntimeException)jjte000;
}
if (jjte000 instanceof ParseException) {
throw (ParseException)jjte000;
}
throw (Error)jjte000;
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
void LiteralField ():
{/*@bgen(jjtree) LiteralField */
ASTLiteralField jjtn000 = new ASTLiteralField(this, JJTLITERALFIELD);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) LiteralField */
try {
/*@egen*/
FieldName() AssignmentExpression()/*@bgen(jjtree)*/
} catch (Throwable jjte000) {
if (jjtc000) {
jjtree.clearNodeScope(jjtn000);
jjtc000 = false;
} else {
jjtree.popNode();
}
if (jjte000 instanceof RuntimeException) {
throw (RuntimeException)jjte000;
}
if (jjte000 instanceof ParseException) {
throw (ParseException)jjte000;
}
throw (Error)jjte000;
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
void FieldName ():
{/*@bgen(jjtree) FieldName */
ASTFieldName jjtn000 = new ASTFieldName(this, JJTFIELDNAME);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) FieldName */
try {
/*@egen*/
|
| SimpleQualifiedIdentifier()
| AssignmentExpression() [ Identifier()]/*@bgen(jjtree)*/
} catch (Throwable jjte000) {
if (jjtc000) {
jjtree.clearNodeScope(jjtn000);
jjtc000 = false;
} else {
jjtree.popNode();
}
if (jjte000 instanceof RuntimeException) {
throw (RuntimeException)jjte000;
}
if (jjte000 instanceof ParseException) {
throw (ParseException)jjte000;
}
throw (Error)jjte000;
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
/////////////////////////////////////////////////////
// Array Literal
/////////////////////////////////////////////////////
void ArrayLiteral():
{/*@bgen(jjtree) ArrayLiteral */
ASTArrayLiteral jjtn000 = new ASTArrayLiteral(this, JJTARRAYLITERAL);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) ArrayLiteral */
try {
/*@egen*/
[ElementList()] /*@bgen(jjtree)*/
} catch (Throwable jjte000) {
if (jjtc000) {
jjtree.clearNodeScope(jjtn000);
jjtc000 = false;
} else {
jjtree.popNode();
}
if (jjte000 instanceof RuntimeException) {
throw (RuntimeException)jjte000;
}
if (jjte000 instanceof ParseException) {
throw (ParseException)jjte000;
}
throw (Error)jjte000;
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
void ElementList():
{/*@bgen(jjtree) ElementList */
ASTElementList jjtn000 = new ASTElementList(this, JJTELEMENTLIST);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) ElementList */
try {
/*@egen*/
LiteralElement() ( LiteralElement())*/*@bgen(jjtree)*/
} catch (Throwable jjte000) {
if (jjtc000) {
jjtree.clearNodeScope(jjtn000);
jjtc000 = false;
} else {
jjtree.popNode();
}
if (jjte000 instanceof RuntimeException) {
throw (RuntimeException)jjte000;
}
if (jjte000 instanceof ParseException) {
throw (ParseException)jjte000;
}
throw (Error)jjte000;
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
void LiteralElement():
{/*@bgen(jjtree) LiteralElement */
ASTLiteralElement jjtn000 = new ASTLiteralElement(this, JJTLITERALELEMENT);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) LiteralElement */
try {
/*@egen*/
AssignmentExpression()/*@bgen(jjtree)*/
} catch (Throwable jjte000) {
if (jjtc000) {
jjtree.clearNodeScope(jjtn000);
jjtc000 = false;
} else {
jjtree.popNode();
}
if (jjte000 instanceof RuntimeException) {
throw (RuntimeException)jjte000;
}
if (jjte000 instanceof ParseException) {
throw (ParseException)jjte000;
}
throw (Error)jjte000;
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
/////////////////////////////////////////////////////
// Super Expression
/////////////////////////////////////////////////////
void SuperExpression ():
{/*@bgen(jjtree) SuperExpression */
ASTSuperExpression jjtn000 = new ASTSuperExpression(this, JJTSUPEREXPRESSION);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) SuperExpression */
try {
/*@egen*/
[LOOKAHEAD(2) AssignmentExpression() ]/*@bgen(jjtree)*/
} catch (Throwable jjte000) {
if (jjtc000) {
jjtree.clearNodeScope(jjtn000);
jjtc000 = false;
} else {
jjtree.popNode();
}
if (jjte000 instanceof RuntimeException) {
throw (RuntimeException)jjte000;
}
if (jjte000 instanceof ParseException) {
throw (ParseException)jjte000;
}
throw (Error)jjte000;
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
/////////////////////////////////////////////////////
// Postfix Expression
/////////////////////////////////////////////////////
void PostfixExpression ():
{/*@bgen(jjtree) PostfixExpression */
ASTPostfixExpression jjtn000 = new ASTPostfixExpression(this, JJTPOSTFIXEXPRESSION);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) PostfixExpression */
try {
/*@egen*/
AttributeExpression () [PostfixOp()]
| {token_source.setRegInvalid();}
FullPostfixExpression () (PropertyOrArguments())* [PostfixOp()]
| SuperExpression() PropertyOperator()/*@bgen(jjtree)*/
} catch (Throwable jjte000) {
if (jjtc000) {
jjtree.clearNodeScope(jjtn000);
jjtc000 = false;
} else {
jjtree.popNode();
}
if (jjte000 instanceof RuntimeException) {
throw (RuntimeException)jjte000;
}
if (jjte000 instanceof ParseException) {
throw (ParseException)jjte000;
}
throw (Error)jjte000;
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
void AttributeExpression ():
{/*@bgen(jjtree) AttributeExpression */
ASTAttributeExpression jjtn000 = new ASTAttributeExpression(this, JJTATTRIBUTEEXPRESSION);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) AttributeExpression */
try {
/*@egen*/
SimpleQualifiedIdentifier() (PropertyOrArguments())*/*@bgen(jjtree)*/
} catch (Throwable jjte000) {
if (jjtc000) {
jjtree.clearNodeScope(jjtn000);
jjtc000 = false;
} else {
jjtree.popNode();
}
if (jjte000 instanceof RuntimeException) {
throw (RuntimeException)jjte000;
}
if (jjte000 instanceof ParseException) {
throw (ParseException)jjte000;
}
throw (Error)jjte000;
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
void FullPostfixExpression ():
{/*@bgen(jjtree) FullPostfixExpression */
ASTFullPostfixExpression jjtn000 = new ASTFullPostfixExpression(this, JJTFULLPOSTFIXEXPRESSION);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) FullPostfixExpression */
try {
/*@egen*/
LOOKAHEAD( AssignmentExpression() )
ExpressionQualifiedIdentifier()
| PrimaryExpression()
| FullNewExpression()/*@bgen(jjtree)*/
} catch (Throwable jjte000) {
if (jjtc000) {
jjtree.clearNodeScope(jjtn000);
jjtc000 = false;
} else {
jjtree.popNode();
}
if (jjte000 instanceof RuntimeException) {
throw (RuntimeException)jjte000;
}
if (jjte000 instanceof ParseException) {
throw (ParseException)jjte000;
}
throw (Error)jjte000;
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
void FullNewExpression ():
{/*@bgen(jjtree) FullNewExpression */
ASTFullNewExpression jjtn000 = new ASTFullNewExpression(this, JJTFULLNEWEXPRESSION);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) FullNewExpression */
try {
/*@egen*/
FullNewSubexpression() (LOOKAHEAD(2) PropertyOperator())* [LOOKAHEAD(2) Arguments()]/*@bgen(jjtree)*/
} catch (Throwable jjte000) {
if (jjtc000) {
jjtree.clearNodeScope(jjtn000);
jjtc000 = false;
} else {
jjtree.popNode();
}
if (jjte000 instanceof RuntimeException) {
throw (RuntimeException)jjte000;
}
if (jjte000 instanceof ParseException) {
throw (ParseException)jjte000;
}
throw (Error)jjte000;
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
void FunctionConstructor():
{/*@bgen(jjtree) FunctionConstructor */
ASTFunctionConstructor jjtn000 = new ASTFunctionConstructor(this, JJTFUNCTIONCONSTRUCTOR);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) FunctionConstructor */
try {
/*@egen*/
Arguments()/*@bgen(jjtree)*/
} catch (Throwable jjte000) {
if (jjtc000) {
jjtree.clearNodeScope(jjtn000);
jjtc000 = false;
} else {
jjtree.popNode();
}
if (jjte000 instanceof RuntimeException) {
throw (RuntimeException)jjte000;
}
if (jjte000 instanceof ParseException) {
throw (ParseException)jjte000;
}
throw (Error)jjte000;
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
void FullNewSubexpression ():
{/*@bgen(jjtree) FullNewSubexpression */
ASTFullNewSubexpression jjtn000 = new ASTFullNewSubexpression(this, JJTFULLNEWSUBEXPRESSION);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) FullNewSubexpression */
try {
/*@egen*/
LOOKAHEAD( AssignmentExpression() )
ExpressionQualifiedIdentifier()
| PrimaryExpression()
| SimpleQualifiedIdentifier()
| SuperExpression()
| FullNewExpression()
| FunctionConstructor()/*@bgen(jjtree)*/
} catch (Throwable jjte000) {
if (jjtc000) {
jjtree.clearNodeScope(jjtn000);
jjtc000 = false;
} else {
jjtree.popNode();
}
if (jjte000 instanceof RuntimeException) {
throw (RuntimeException)jjte000;
}
if (jjte000 instanceof ParseException) {
throw (ParseException)jjte000;
}
throw (Error)jjte000;
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
void PostfixOp():
{/*@bgen(jjtree) PostfixOp */
ASTPostfixOp jjtn000 = new ASTPostfixOp(this, JJTPOSTFIXOP);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) PostfixOp */
try {
/*@egen*/
| /*@bgen(jjtree)*/
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
void PropertyOrArguments ():
{/*@bgen(jjtree) PropertyOrArguments */
ASTPropertyOrArguments jjtn000 = new ASTPropertyOrArguments(this, JJTPROPERTYORARGUMENTS);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) PropertyOrArguments */
try {
/*@egen*/
Arguments()
| PropertyOperator()/*@bgen(jjtree)*/
} catch (Throwable jjte000) {
if (jjtc000) {
jjtree.clearNodeScope(jjtn000);
jjtc000 = false;
} else {
jjtree.popNode();
}
if (jjte000 instanceof RuntimeException) {
throw (RuntimeException)jjte000;
}
if (jjte000 instanceof ParseException) {
throw (ParseException)jjte000;
}
throw (Error)jjte000;
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
/////////////////////////////////////////////////////
// Property Operators
/////////////////////////////////////////////////////
void PropertyOperator ():
{/*@bgen(jjtree) PropertyOperator */
ASTPropertyOperator jjtn000 = new ASTPropertyOperator(this, JJTPROPERTYOPERATOR);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) PropertyOperator */
try {
/*@egen*/
QualifiedIdentifier()
| LOOKAHEAD(2)
| LOOKAHEAD(2) AssignmentExpression()
| ListExpression() [ AssignmentExpression()] /*@bgen(jjtree)*/
} catch (Throwable jjte000) {
if (jjtc000) {
jjtree.clearNodeScope(jjtn000);
jjtc000 = false;
} else {
jjtree.popNode();
}
if (jjte000 instanceof RuntimeException) {
throw (RuntimeException)jjte000;
}
if (jjte000 instanceof ParseException) {
throw (ParseException)jjte000;
}
throw (Error)jjte000;
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
void Arguments ():
{/*@bgen(jjtree) Arguments */
ASTArguments jjtn000 = new ASTArguments(this, JJTARGUMENTS);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/{token_source.setRegValid();}}
{/*@bgen(jjtree) Arguments */
try {
/*@egen*/
LOOKAHEAD(2)
| LOOKAHEAD(2) AssignmentExpression()
| ListExpression() [ AssignmentExpression()] /*@bgen(jjtree)*/
} catch (Throwable jjte000) {
if (jjtc000) {
jjtree.clearNodeScope(jjtn000);
jjtc000 = false;
} else {
jjtree.popNode();
}
if (jjte000 instanceof RuntimeException) {
throw (RuntimeException)jjte000;
}
if (jjte000 instanceof ParseException) {
throw (ParseException)jjte000;
}
throw (Error)jjte000;
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
/////////////////////////////////////////////////////
// Unary Operators
/////////////////////////////////////////////////////
void UnaryExpression ():
{/*@bgen(jjtree) UnaryExpression */
ASTUnaryExpression jjtn000 = new ASTUnaryExpression(this, JJTUNARYEXPRESSION);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) UnaryExpression */
try {
/*@egen*/
PostfixExpression()
| PostfixExpression()
| UnaryExpression()
| UnaryExpression()
| PostfixExpression()
| PostfixExpression()
| UnaryExpression()
| UnaryExpression()
| UnaryExpression()
| UnaryExpression()/*@bgen(jjtree)*/
} catch (Throwable jjte000) {
if (jjtc000) {
jjtree.clearNodeScope(jjtn000);
jjtc000 = false;
} else {
jjtree.popNode();
}
if (jjte000 instanceof RuntimeException) {
throw (RuntimeException)jjte000;
}
if (jjte000 instanceof ParseException) {
throw (ParseException)jjte000;
}
throw (Error)jjte000;
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
/////////////////////////////////////////////////////
// Multiplicative Operators
/////////////////////////////////////////////////////
void MulOp():
{/*@bgen(jjtree) MulOp */
ASTMulOp jjtn000 = new ASTMulOp(this, JJTMULOP);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) MulOp */
try {
/*@egen*/
|
| /*@bgen(jjtree)*/
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
void MultiplicativeExpression():
{/*@bgen(jjtree) MultiplicativeExpression */
ASTMultiplicativeExpression jjtn000 = new ASTMultiplicativeExpression(this, JJTMULTIPLICATIVEEXPRESSION);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) MultiplicativeExpression */
try {
/*@egen*/
UnaryExpression() (MulOp() UnaryExpression())*/*@bgen(jjtree)*/
} catch (Throwable jjte000) {
if (jjtc000) {
jjtree.clearNodeScope(jjtn000);
jjtc000 = false;
} else {
jjtree.popNode();
}
if (jjte000 instanceof RuntimeException) {
throw (RuntimeException)jjte000;
}
if (jjte000 instanceof ParseException) {
throw (ParseException)jjte000;
}
throw (Error)jjte000;
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
/////////////////////////////////////////////////////
// Additive Operators
/////////////////////////////////////////////////////
void AddOp():
{/*@bgen(jjtree) AddOp */
ASTAddOp jjtn000 = new ASTAddOp(this, JJTADDOP);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) AddOp */
try {
/*@egen*/
| /*@bgen(jjtree)*/
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
void AdditiveExpression():
{/*@bgen(jjtree) AdditiveExpression */
ASTAdditiveExpression jjtn000 = new ASTAdditiveExpression(this, JJTADDITIVEEXPRESSION);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) AdditiveExpression */
try {
/*@egen*/
MultiplicativeExpression() (AddOp() MultiplicativeExpression())*/*@bgen(jjtree)*/
} catch (Throwable jjte000) {
if (jjtc000) {
jjtree.clearNodeScope(jjtn000);
jjtc000 = false;
} else {
jjtree.popNode();
}
if (jjte000 instanceof RuntimeException) {
throw (RuntimeException)jjte000;
}
if (jjte000 instanceof ParseException) {
throw (ParseException)jjte000;
}
throw (Error)jjte000;
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
/////////////////////////////////////////////////////
// Bitwise Shift Operators
/////////////////////////////////////////////////////
void ShiftOp():
{/*@bgen(jjtree) ShiftOp */
ASTShiftOp jjtn000 = new ASTShiftOp(this, JJTSHIFTOP);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) ShiftOp */
try {
/*@egen*/
|
| /*@bgen(jjtree)*/
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
void ShiftExpression():
{/*@bgen(jjtree) ShiftExpression */
ASTShiftExpression jjtn000 = new ASTShiftExpression(this, JJTSHIFTEXPRESSION);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) ShiftExpression */
try {
/*@egen*/
AdditiveExpression() (ShiftOp() AdditiveExpression())*/*@bgen(jjtree)*/
} catch (Throwable jjte000) {
if (jjtc000) {
jjtree.clearNodeScope(jjtn000);
jjtc000 = false;
} else {
jjtree.popNode();
}
if (jjte000 instanceof RuntimeException) {
throw (RuntimeException)jjte000;
}
if (jjte000 instanceof ParseException) {
throw (ParseException)jjte000;
}
throw (Error)jjte000;
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
/////////////////////////////////////////////////////
// Relational Operators
/////////////////////////////////////////////////////
void RelOp():
{/*@bgen(jjtree) RelOp */
ASTRelOp jjtn000 = new ASTRelOp(this, JJTRELOP);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) RelOp */
try {
/*@egen*/
|
|
|
|
| /*@bgen(jjtree)*/
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
void RelationalExpression():
{/*@bgen(jjtree) RelationalExpression */
ASTRelationalExpression jjtn000 = new ASTRelationalExpression(this, JJTRELATIONALEXPRESSION);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) RelationalExpression */
try {
/*@egen*/
ShiftExpression()
(LOOKAHEAD(3)(RelOp() | | ) ShiftExpression())*/*@bgen(jjtree)*/
} catch (Throwable jjte000) {
if (jjtc000) {
jjtree.clearNodeScope(jjtn000);
jjtc000 = false;
} else {
jjtree.popNode();
}
if (jjte000 instanceof RuntimeException) {
throw (RuntimeException)jjte000;
}
if (jjte000 instanceof ParseException) {
throw (ParseException)jjte000;
}
throw (Error)jjte000;
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
void RelationalExpressionNoIN():
{/*@bgen(jjtree) RelationalExpressionNoIN */
ASTRelationalExpressionNoIN jjtn000 = new ASTRelationalExpressionNoIN(this, JJTRELATIONALEXPRESSIONNOIN);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) RelationalExpressionNoIN */
try {
/*@egen*/
ShiftExpression()
((RelOp() | ) ShiftExpression())*/*@bgen(jjtree)*/
} catch (Throwable jjte000) {
if (jjtc000) {
jjtree.clearNodeScope(jjtn000);
jjtc000 = false;
} else {
jjtree.popNode();
}
if (jjte000 instanceof RuntimeException) {
throw (RuntimeException)jjte000;
}
if (jjte000 instanceof ParseException) {
throw (ParseException)jjte000;
}
throw (Error)jjte000;
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
/////////////////////////////////////////////////////
// Equality Operators
/////////////////////////////////////////////////////
void EqualOp():
{/*@bgen(jjtree) EqualOp */
ASTEqualOp jjtn000 = new ASTEqualOp(this, JJTEQUALOP);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) EqualOp */
try {
/*@egen*/
|
|
| /*@bgen(jjtree)*/
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
void EqualityExpression():
{/*@bgen(jjtree) EqualityExpression */
ASTEqualityExpression jjtn000 = new ASTEqualityExpression(this, JJTEQUALITYEXPRESSION);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) EqualityExpression */
try {
/*@egen*/
RelationalExpression() (EqualOp() RelationalExpression())*/*@bgen(jjtree)*/
} catch (Throwable jjte000) {
if (jjtc000) {
jjtree.clearNodeScope(jjtn000);
jjtc000 = false;
} else {
jjtree.popNode();
}
if (jjte000 instanceof RuntimeException) {
throw (RuntimeException)jjte000;
}
if (jjte000 instanceof ParseException) {
throw (ParseException)jjte000;
}
throw (Error)jjte000;
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
void EqualityExpressionNoIN():
{/*@bgen(jjtree) EqualityExpressionNoIN */
ASTEqualityExpressionNoIN jjtn000 = new ASTEqualityExpressionNoIN(this, JJTEQUALITYEXPRESSIONNOIN);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) EqualityExpressionNoIN */
try {
/*@egen*/
RelationalExpressionNoIN() (EqualOp() RelationalExpressionNoIN())*/*@bgen(jjtree)*/
} catch (Throwable jjte000) {
if (jjtc000) {
jjtree.clearNodeScope(jjtn000);
jjtc000 = false;
} else {
jjtree.popNode();
}
if (jjte000 instanceof RuntimeException) {
throw (RuntimeException)jjte000;
}
if (jjte000 instanceof ParseException) {
throw (ParseException)jjte000;
}
throw (Error)jjte000;
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
/////////////////////////////////////////////////////
// Binary Bitwise Operators
/////////////////////////////////////////////////////
void BitwiseANDOp():
{/*@bgen(jjtree) BitwiseANDOp */
ASTBitwiseANDOp jjtn000 = new ASTBitwiseANDOp(this, JJTBITWISEANDOP);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) BitwiseANDOp */
try {
/*@egen*/
/*@bgen(jjtree)*/
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
void BitwiseANDExpression():
{/*@bgen(jjtree) BitwiseANDExpression */
ASTBitwiseANDExpression jjtn000 = new ASTBitwiseANDExpression(this, JJTBITWISEANDEXPRESSION);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) BitwiseANDExpression */
try {
/*@egen*/
EqualityExpression() (BitwiseANDOp() EqualityExpression())*/*@bgen(jjtree)*/
} catch (Throwable jjte000) {
if (jjtc000) {
jjtree.clearNodeScope(jjtn000);
jjtc000 = false;
} else {
jjtree.popNode();
}
if (jjte000 instanceof RuntimeException) {
throw (RuntimeException)jjte000;
}
if (jjte000 instanceof ParseException) {
throw (ParseException)jjte000;
}
throw (Error)jjte000;
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
void BitwiseANDExpressionNoIN():
{/*@bgen(jjtree) BitwiseANDExpressionNoIN */
ASTBitwiseANDExpressionNoIN jjtn000 = new ASTBitwiseANDExpressionNoIN(this, JJTBITWISEANDEXPRESSIONNOIN);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) BitwiseANDExpressionNoIN */
try {
/*@egen*/
EqualityExpressionNoIN() (BitwiseANDOp() EqualityExpressionNoIN())*/*@bgen(jjtree)*/
} catch (Throwable jjte000) {
if (jjtc000) {
jjtree.clearNodeScope(jjtn000);
jjtc000 = false;
} else {
jjtree.popNode();
}
if (jjte000 instanceof RuntimeException) {
throw (RuntimeException)jjte000;
}
if (jjte000 instanceof ParseException) {
throw (ParseException)jjte000;
}
throw (Error)jjte000;
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
void BitwiseXOROp():
{/*@bgen(jjtree) BitwiseXOROp */
ASTBitwiseXOROp jjtn000 = new ASTBitwiseXOROp(this, JJTBITWISEXOROP);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) BitwiseXOROp */
try {
/*@egen*/
/*@bgen(jjtree)*/
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
void BitwiseXORExpression():
{/*@bgen(jjtree) BitwiseXORExpression */
ASTBitwiseXORExpression jjtn000 = new ASTBitwiseXORExpression(this, JJTBITWISEXOREXPRESSION);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) BitwiseXORExpression */
try {
/*@egen*/
BitwiseANDExpression() (BitwiseXOROp() BitwiseANDExpression())*/*@bgen(jjtree)*/
} catch (Throwable jjte000) {
if (jjtc000) {
jjtree.clearNodeScope(jjtn000);
jjtc000 = false;
} else {
jjtree.popNode();
}
if (jjte000 instanceof RuntimeException) {
throw (RuntimeException)jjte000;
}
if (jjte000 instanceof ParseException) {
throw (ParseException)jjte000;
}
throw (Error)jjte000;
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
void BitwiseXORExpressionNoIN():
{/*@bgen(jjtree) BitwiseXORExpressionNoIN */
ASTBitwiseXORExpressionNoIN jjtn000 = new ASTBitwiseXORExpressionNoIN(this, JJTBITWISEXOREXPRESSIONNOIN);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) BitwiseXORExpressionNoIN */
try {
/*@egen*/
BitwiseANDExpressionNoIN() (BitwiseXOROp() BitwiseANDExpressionNoIN())*/*@bgen(jjtree)*/
} catch (Throwable jjte000) {
if (jjtc000) {
jjtree.clearNodeScope(jjtn000);
jjtc000 = false;
} else {
jjtree.popNode();
}
if (jjte000 instanceof RuntimeException) {
throw (RuntimeException)jjte000;
}
if (jjte000 instanceof ParseException) {
throw (ParseException)jjte000;
}
throw (Error)jjte000;
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
void BitwiseOROp():
{/*@bgen(jjtree) BitwiseOROp */
ASTBitwiseOROp jjtn000 = new ASTBitwiseOROp(this, JJTBITWISEOROP);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) BitwiseOROp */
try {
/*@egen*/
/*@bgen(jjtree)*/
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
void BitwiseORExpression():
{/*@bgen(jjtree) BitwiseORExpression */
ASTBitwiseORExpression jjtn000 = new ASTBitwiseORExpression(this, JJTBITWISEOREXPRESSION);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) BitwiseORExpression */
try {
/*@egen*/
BitwiseXORExpression() (BitwiseOROp() BitwiseXORExpression())*/*@bgen(jjtree)*/
} catch (Throwable jjte000) {
if (jjtc000) {
jjtree.clearNodeScope(jjtn000);
jjtc000 = false;
} else {
jjtree.popNode();
}
if (jjte000 instanceof RuntimeException) {
throw (RuntimeException)jjte000;
}
if (jjte000 instanceof ParseException) {
throw (ParseException)jjte000;
}
throw (Error)jjte000;
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
void BitwiseORExpressionNoIN():
{/*@bgen(jjtree) BitwiseORExpressionNoIN */
ASTBitwiseORExpressionNoIN jjtn000 = new ASTBitwiseORExpressionNoIN(this, JJTBITWISEOREXPRESSIONNOIN);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) BitwiseORExpressionNoIN */
try {
/*@egen*/
BitwiseXORExpressionNoIN() (BitwiseOROp() BitwiseXORExpressionNoIN())*/*@bgen(jjtree)*/
} catch (Throwable jjte000) {
if (jjtc000) {
jjtree.clearNodeScope(jjtn000);
jjtc000 = false;
} else {
jjtree.popNode();
}
if (jjte000 instanceof RuntimeException) {
throw (RuntimeException)jjte000;
}
if (jjte000 instanceof ParseException) {
throw (ParseException)jjte000;
}
throw (Error)jjte000;
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
/////////////////////////////////////////////////////
// Binary Logical Operators
/////////////////////////////////////////////////////
void LogicalANDExpression():
{/*@bgen(jjtree) LogicalANDExpression */
ASTLogicalANDExpression jjtn000 = new ASTLogicalANDExpression(this, JJTLOGICALANDEXPRESSION);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) LogicalANDExpression */
try {
/*@egen*/
BitwiseORExpression() ( BitwiseORExpression())*/*@bgen(jjtree)*/
} catch (Throwable jjte000) {
if (jjtc000) {
jjtree.clearNodeScope(jjtn000);
jjtc000 = false;
} else {
jjtree.popNode();
}
if (jjte000 instanceof RuntimeException) {
throw (RuntimeException)jjte000;
}
if (jjte000 instanceof ParseException) {
throw (ParseException)jjte000;
}
throw (Error)jjte000;
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
void LogicalANDExpressionNoIN():
{/*@bgen(jjtree) LogicalANDExpressionNoIN */
ASTLogicalANDExpressionNoIN jjtn000 = new ASTLogicalANDExpressionNoIN(this, JJTLOGICALANDEXPRESSIONNOIN);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) LogicalANDExpressionNoIN */
try {
/*@egen*/
BitwiseORExpressionNoIN() ( BitwiseORExpressionNoIN())*/*@bgen(jjtree)*/
} catch (Throwable jjte000) {
if (jjtc000) {
jjtree.clearNodeScope(jjtn000);
jjtc000 = false;
} else {
jjtree.popNode();
}
if (jjte000 instanceof RuntimeException) {
throw (RuntimeException)jjte000;
}
if (jjte000 instanceof ParseException) {
throw (ParseException)jjte000;
}
throw (Error)jjte000;
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
void LogicalORExpression():
{/*@bgen(jjtree) LogicalORExpression */
ASTLogicalORExpression jjtn000 = new ASTLogicalORExpression(this, JJTLOGICALOREXPRESSION);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) LogicalORExpression */
try {
/*@egen*/
LogicalANDExpression() ( LogicalANDExpression())*/*@bgen(jjtree)*/
} catch (Throwable jjte000) {
if (jjtc000) {
jjtree.clearNodeScope(jjtn000);
jjtc000 = false;
} else {
jjtree.popNode();
}
if (jjte000 instanceof RuntimeException) {
throw (RuntimeException)jjte000;
}
if (jjte000 instanceof ParseException) {
throw (ParseException)jjte000;
}
throw (Error)jjte000;
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
void LogicalORExpressionNoIN():
{/*@bgen(jjtree) LogicalORExpressionNoIN */
ASTLogicalORExpressionNoIN jjtn000 = new ASTLogicalORExpressionNoIN(this, JJTLOGICALOREXPRESSIONNOIN);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) LogicalORExpressionNoIN */
try {
/*@egen*/
LogicalANDExpressionNoIN() ( LogicalANDExpressionNoIN())*/*@bgen(jjtree)*/
} catch (Throwable jjte000) {
if (jjtc000) {
jjtree.clearNodeScope(jjtn000);
jjtc000 = false;
} else {
jjtree.popNode();
}
if (jjte000 instanceof RuntimeException) {
throw (RuntimeException)jjte000;
}
if (jjte000 instanceof ParseException) {
throw (ParseException)jjte000;
}
throw (Error)jjte000;
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
/////////////////////////////////////////////////////
// Conditional Operators
/////////////////////////////////////////////////////
void ConditionalExpression():
{/*@bgen(jjtree) ConditionalExpression */
ASTConditionalExpression jjtn000 = new ASTConditionalExpression(this, JJTCONDITIONALEXPRESSION);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) ConditionalExpression */
try {
/*@egen*/
LogicalORExpression() [ AssignmentExpression()
AssignmentExpression()]/*@bgen(jjtree)*/
} catch (Throwable jjte000) {
if (jjtc000) {
jjtree.clearNodeScope(jjtn000);
jjtc000 = false;
} else {
jjtree.popNode();
}
if (jjte000 instanceof RuntimeException) {
throw (RuntimeException)jjte000;
}
if (jjte000 instanceof ParseException) {
throw (ParseException)jjte000;
}
throw (Error)jjte000;
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
void ConditionalExpressionNoIN():
{/*@bgen(jjtree) ConditionalExpressionNoIN */
ASTConditionalExpressionNoIN jjtn000 = new ASTConditionalExpressionNoIN(this, JJTCONDITIONALEXPRESSIONNOIN);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) ConditionalExpressionNoIN */
try {
/*@egen*/
LogicalORExpressionNoIN() [ AssignmentExpressionNoIN()
AssignmentExpressionNoIN()]/*@bgen(jjtree)*/
} catch (Throwable jjte000) {
if (jjtc000) {
jjtree.clearNodeScope(jjtn000);
jjtc000 = false;
} else {
jjtree.popNode();
}
if (jjte000 instanceof RuntimeException) {
throw (RuntimeException)jjte000;
}
if (jjte000 instanceof ParseException) {
throw (ParseException)jjte000;
}
throw (Error)jjte000;
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
void NonAssignmentExpression():
{/*@bgen(jjtree) NonAssignmentExpression */
ASTNonAssignmentExpression jjtn000 = new ASTNonAssignmentExpression(this, JJTNONASSIGNMENTEXPRESSION);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) NonAssignmentExpression */
try {
/*@egen*/
LogicalORExpression() [ NonAssignmentExpression()
NonAssignmentExpression()]/*@bgen(jjtree)*/
} catch (Throwable jjte000) {
if (jjtc000) {
jjtree.clearNodeScope(jjtn000);
jjtc000 = false;
} else {
jjtree.popNode();
}
if (jjte000 instanceof RuntimeException) {
throw (RuntimeException)jjte000;
}
if (jjte000 instanceof ParseException) {
throw (ParseException)jjte000;
}
throw (Error)jjte000;
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
void NonAssignmentExpressionNoIN():
{/*@bgen(jjtree) NonAssignmentExpressionNoIN */
ASTNonAssignmentExpressionNoIN jjtn000 = new ASTNonAssignmentExpressionNoIN(this, JJTNONASSIGNMENTEXPRESSIONNOIN);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) NonAssignmentExpressionNoIN */
try {
/*@egen*/
LogicalORExpressionNoIN() [ NonAssignmentExpressionNoIN()
NonAssignmentExpressionNoIN()]/*@bgen(jjtree)*/
} catch (Throwable jjte000) {
if (jjtc000) {
jjtree.clearNodeScope(jjtn000);
jjtc000 = false;
} else {
jjtree.popNode();
}
if (jjte000 instanceof RuntimeException) {
throw (RuntimeException)jjte000;
}
if (jjte000 instanceof ParseException) {
throw (ParseException)jjte000;
}
throw (Error)jjte000;
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
/////////////////////////////////////////////////////
// Assignment Operators
/////////////////////////////////////////////////////
void AssignementOperator():
{/*@bgen(jjtree) AssignementOperator */
ASTAssignementOperator jjtn000 = new ASTAssignementOperator(this, JJTASSIGNEMENTOPERATOR);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) AssignementOperator */
try {
/*@egen*/
|
|
|
|
|
|
|
|
|
|
|
|
|
| /*@bgen(jjtree)*/
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
void AssignmentExpression():
{/*@bgen(jjtree) AssignmentExpression */
ASTAssignmentExpression jjtn000 = new ASTAssignmentExpression(this, JJTASSIGNMENTEXPRESSION);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) AssignmentExpression */
try {
/*@egen*/
ConditionalExpression() [LOOKAHEAD(2) AssignementOperator() AssignmentExpression()]/*@bgen(jjtree)*/
} catch (Throwable jjte000) {
if (jjtc000) {
jjtree.clearNodeScope(jjtn000);
jjtc000 = false;
} else {
jjtree.popNode();
}
if (jjte000 instanceof RuntimeException) {
throw (RuntimeException)jjte000;
}
if (jjte000 instanceof ParseException) {
throw (ParseException)jjte000;
}
throw (Error)jjte000;
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
void AssignmentExpressionNoIN():
{/*@bgen(jjtree) AssignmentExpressionNoIN */
ASTAssignmentExpressionNoIN jjtn000 = new ASTAssignmentExpressionNoIN(this, JJTASSIGNMENTEXPRESSIONNOIN);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) AssignmentExpressionNoIN */
try {
/*@egen*/
ConditionalExpressionNoIN() [LOOKAHEAD(2) AssignementOperator() AssignmentExpressionNoIN()]/*@bgen(jjtree)*/
} catch (Throwable jjte000) {
if (jjtc000) {
jjtree.clearNodeScope(jjtn000);
jjtc000 = false;
} else {
jjtree.popNode();
}
if (jjte000 instanceof RuntimeException) {
throw (RuntimeException)jjte000;
}
if (jjte000 instanceof ParseException) {
throw (ParseException)jjte000;
}
throw (Error)jjte000;
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
/////////////////////////////////////////////////////
// Comma Expressions
/////////////////////////////////////////////////////
void ListExpression ():
{/*@bgen(jjtree) ListExpression */
ASTListExpression jjtn000 = new ASTListExpression(this, JJTLISTEXPRESSION);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) ListExpression */
try {
/*@egen*/
AssignmentExpression() ( AssignmentExpression())*/*@bgen(jjtree)*/
} catch (Throwable jjte000) {
if (jjtc000) {
jjtree.clearNodeScope(jjtn000);
jjtc000 = false;
} else {
jjtree.popNode();
}
if (jjte000 instanceof RuntimeException) {
throw (RuntimeException)jjte000;
}
if (jjte000 instanceof ParseException) {
throw (ParseException)jjte000;
}
throw (Error)jjte000;
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
void ListExpressionNoIN ():
{/*@bgen(jjtree) ListExpressionNoIN */
ASTListExpressionNoIN jjtn000 = new ASTListExpressionNoIN(this, JJTLISTEXPRESSIONNOIN);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) ListExpressionNoIN */
try {
/*@egen*/
AssignmentExpressionNoIN() ( AssignmentExpressionNoIN())*/*@bgen(jjtree)*/
} catch (Throwable jjte000) {
if (jjtc000) {
jjtree.clearNodeScope(jjtn000);
jjtc000 = false;
} else {
jjtree.popNode();
}
if (jjte000 instanceof RuntimeException) {
throw (RuntimeException)jjte000;
}
if (jjte000 instanceof ParseException) {
throw (ParseException)jjte000;
}
throw (Error)jjte000;
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
/////////////////////////////////////////////////////
// Type Expressions
/////////////////////////////////////////////////////
void TypeExpression ():
{/*@bgen(jjtree) TypeExpression */
ASTTypeExpression jjtn000 = new ASTTypeExpression(this, JJTTYPEEXPRESSION);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) TypeExpression */
try {
/*@egen*/
NonAssignmentExpression()/*@bgen(jjtree)*/
} catch (Throwable jjte000) {
if (jjtc000) {
jjtree.clearNodeScope(jjtn000);
jjtc000 = false;
} else {
jjtree.popNode();
}
if (jjte000 instanceof RuntimeException) {
throw (RuntimeException)jjte000;
}
if (jjte000 instanceof ParseException) {
throw (ParseException)jjte000;
}
throw (Error)jjte000;
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
void TypeExpressionNoIN ():
{/*@bgen(jjtree) TypeExpressionNoIN */
ASTTypeExpressionNoIN jjtn000 = new ASTTypeExpressionNoIN(this, JJTTYPEEXPRESSIONNOIN);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) TypeExpressionNoIN */
try {
/*@egen*/
NonAssignmentExpressionNoIN()/*@bgen(jjtree)*/
} catch (Throwable jjte000) {
if (jjtc000) {
jjtree.clearNodeScope(jjtn000);
jjtc000 = false;
} else {
jjtree.popNode();
}
if (jjte000 instanceof RuntimeException) {
throw (RuntimeException)jjte000;
}
if (jjte000 instanceof ParseException) {
throw (ParseException)jjte000;
}
throw (Error)jjte000;
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
void TypeExpressionList ():
{/*@bgen(jjtree) TypeExpressionList */
ASTTypeExpressionList jjtn000 = new ASTTypeExpressionList(this, JJTTYPEEXPRESSIONLIST);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) TypeExpressionList */
try {
/*@egen*/
NonAssignmentExpression() ( NonAssignmentExpression())*/*@bgen(jjtree)*/
} catch (Throwable jjte000) {
if (jjtc000) {
jjtree.clearNodeScope(jjtn000);
jjtc000 = false;
} else {
jjtree.popNode();
}
if (jjte000 instanceof RuntimeException) {
throw (RuntimeException)jjte000;
}
if (jjte000 instanceof ParseException) {
throw (ParseException)jjte000;
}
throw (Error)jjte000;
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
/////////////////////////////////////////////////////
// Staements (abbrev, noShortIf, full)
/////////////////////////////////////////////////////
void Statement ():
{/*@bgen(jjtree) Statement */
ASTStatement jjtn000 = new ASTStatement(this, JJTSTATEMENT);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) Statement */
try {
/*@egen*/
LOOKAHEAD(3) ExpressionStatement() Sc()
| SuperStatement() Sc()
| Block()
| LabeledStatement()
| IfStatement()
| SwitchStatement()
| DoStatement() Sc()
| WhileStatement()
| ForStatement()
| WithStatement()
| ContinueStatement() Sc()
| BreakStatement() Sc()
| ReturnStatement() Sc()
| ThrowStatement() Sc()
| TryStatement()/*@bgen(jjtree)*/
} catch (Throwable jjte000) {
if (jjtc000) {
jjtree.clearNodeScope(jjtn000);
jjtc000 = false;
} else {
jjtree.popNode();
}
if (jjte000 instanceof RuntimeException) {
throw (RuntimeException)jjte000;
}
if (jjte000 instanceof ParseException) {
throw (ParseException)jjte000;
}
throw (Error)jjte000;
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
void Substatement ():
{/*@bgen(jjtree) Substatement */
ASTSubstatement jjtn000 = new ASTSubstatement(this, JJTSUBSTATEMENT);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) Substatement */
try {
/*@egen*/
EmptyStatement()
| LOOKAHEAD(2) Statement()
| SimpleVariableDefinition() Sc()
| Attributes() Substatements() /*@bgen(jjtree)*/
} catch (Throwable jjte000) {
if (jjtc000) {
jjtree.clearNodeScope(jjtn000);
jjtc000 = false;
} else {
jjtree.popNode();
}
if (jjte000 instanceof RuntimeException) {
throw (RuntimeException)jjte000;
}
if (jjte000 instanceof ParseException) {
throw (ParseException)jjte000;
}
throw (Error)jjte000;
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
void Substatements ():
{/*@bgen(jjtree) Substatements */
ASTSubstatements jjtn000 = new ASTSubstatements(this, JJTSUBSTATEMENTS);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) Substatements */
try {
/*@egen*/
(Substatement())+/*@bgen(jjtree)*/
} catch (Throwable jjte000) {
if (jjtc000) {
jjtree.clearNodeScope(jjtn000);
jjtc000 = false;
} else {
jjtree.popNode();
}
if (jjte000 instanceof RuntimeException) {
throw (RuntimeException)jjte000;
}
if (jjte000 instanceof ParseException) {
throw (ParseException)jjte000;
}
throw (Error)jjte000;
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
JAVACODE
void Sc() {/*@bgen(jjtree) Sc */
ASTSc jjtn000 = new ASTSc(this, JJTSC);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
try {
/*@egen*/
Token tok = getToken(1);
if (tok.kind == SEMICOLON) {
tok = getNextToken();
} else if (tok.specialToken != null) {
if (!EolCommentSkipWs(tok.specialToken) && (tok.kind != EOF)) {
throw generateParseException();
}
} else if ((tok.kind != EOF) && (tok.kind!=RBRACE)) {
throw generateParseException();
}/*@bgen(jjtree)*/
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
JAVACODE
boolean EolCommentSkipWs(Token t) {/*@bgen(jjtree) EolCommentSkipWs */
ASTEolCommentSkipWs jjtn000 = new ASTEolCommentSkipWs(this, JJTEOLCOMMENTSKIPWS);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
try {
/*@egen*/
boolean retVal = false;
Token specialToken = t;
while(specialToken != null) {
if(specialToken.kind == WS) {
specialToken = specialToken.specialToken;
continue;
}
else if(specialToken.kind == EOL ||
specialToken.kind == SINGLE_LINE_COMMENT) {
retVal = true;
break;
}
else {
break;
}
}
return retVal;/*@bgen(jjtree)*/
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
/////////////////////////////////////////////////////
// Empty Statement
/////////////////////////////////////////////////////
void EmptyStatement():
{/*@bgen(jjtree) EmptyStatement */
ASTEmptyStatement jjtn000 = new ASTEmptyStatement(this, JJTEMPTYSTATEMENT);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) EmptyStatement */
try {
/*@egen*/
/*@bgen(jjtree)*/
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
/////////////////////////////////////////////////////
// Expresion Statement
/////////////////////////////////////////////////////
void ExpressionStatement():
{/*@bgen(jjtree) ExpressionStatement */
ASTExpressionStatement jjtn000 = new ASTExpressionStatement(this, JJTEXPRESSIONSTATEMENT);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) ExpressionStatement */
try {
/*@egen*/
ListExpression()/*@bgen(jjtree)*/
} catch (Throwable jjte000) {
if (jjtc000) {
jjtree.clearNodeScope(jjtn000);
jjtc000 = false;
} else {
jjtree.popNode();
}
if (jjte000 instanceof RuntimeException) {
throw (RuntimeException)jjte000;
}
if (jjte000 instanceof ParseException) {
throw (ParseException)jjte000;
}
throw (Error)jjte000;
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
/////////////////////////////////////////////////////
// Super Statement
/////////////////////////////////////////////////////
void SuperStatement ():
{/*@bgen(jjtree) SuperStatement */
ASTSuperStatement jjtn000 = new ASTSuperStatement(this, JJTSUPERSTATEMENT);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) SuperStatement */
try {
/*@egen*/
Arguments()/*@bgen(jjtree)*/
} catch (Throwable jjte000) {
if (jjtc000) {
jjtree.clearNodeScope(jjtn000);
jjtc000 = false;
} else {
jjtree.popNode();
}
if (jjte000 instanceof RuntimeException) {
throw (RuntimeException)jjte000;
}
if (jjte000 instanceof ParseException) {
throw (ParseException)jjte000;
}
throw (Error)jjte000;
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
/////////////////////////////////////////////////////
// Block Statement
/////////////////////////////////////////////////////
void Block ():
{/*@bgen(jjtree) Block */
ASTBlock jjtn000 = new ASTBlock(this, JJTBLOCK);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) Block */
try {
/*@egen*/
[Directives()] /*@bgen(jjtree)*/
} catch (Throwable jjte000) {
if (jjtc000) {
jjtree.clearNodeScope(jjtn000);
jjtc000 = false;
} else {
jjtree.popNode();
}
if (jjte000 instanceof RuntimeException) {
throw (RuntimeException)jjte000;
}
if (jjte000 instanceof ParseException) {
throw (ParseException)jjte000;
}
throw (Error)jjte000;
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
/////////////////////////////////////////////////////
// Labeled Statement (maps to literal field)
/////////////////////////////////////////////////////
void LabeledStatement ():
{/*@bgen(jjtree) LabeledStatement */
ASTLabeledStatement jjtn000 = new ASTLabeledStatement(this, JJTLABELEDSTATEMENT);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) LabeledStatement */
try {
/*@egen*/
Identifier() Substatement()/*@bgen(jjtree)*/
} catch (Throwable jjte000) {
if (jjtc000) {
jjtree.clearNodeScope(jjtn000);
jjtc000 = false;
} else {
jjtree.popNode();
}
if (jjte000 instanceof RuntimeException) {
throw (RuntimeException)jjte000;
}
if (jjte000 instanceof ParseException) {
throw (ParseException)jjte000;
}
throw (Error)jjte000;
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
/////////////////////////////////////////////////////
// If Statement
/////////////////////////////////////////////////////
void IfStatement():
{/*@bgen(jjtree) IfStatement */
ASTIfStatement jjtn000 = new ASTIfStatement(this, JJTIFSTATEMENT);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) IfStatement */
try {
/*@egen*/
ListExpression()
Substatement()
[LOOKAHEAD(1) Substatement()]/*@bgen(jjtree)*/
} catch (Throwable jjte000) {
if (jjtc000) {
jjtree.clearNodeScope(jjtn000);
jjtc000 = false;
} else {
jjtree.popNode();
}
if (jjte000 instanceof RuntimeException) {
throw (RuntimeException)jjte000;
}
if (jjte000 instanceof ParseException) {
throw (ParseException)jjte000;
}
throw (Error)jjte000;
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
/////////////////////////////////////////////////////
// Switch Statement
/////////////////////////////////////////////////////
void SwitchStatement ():
{/*@bgen(jjtree) SwitchStatement */
ASTSwitchStatement jjtn000 = new ASTSwitchStatement(this, JJTSWITCHSTATEMENT);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) SwitchStatement */
try {
/*@egen*/
ListExpression()
[CaseElements()] /*@bgen(jjtree)*/
} catch (Throwable jjte000) {
if (jjtc000) {
jjtree.clearNodeScope(jjtn000);
jjtc000 = false;
} else {
jjtree.popNode();
}
if (jjte000 instanceof RuntimeException) {
throw (RuntimeException)jjte000;
}
if (jjte000 instanceof ParseException) {
throw (ParseException)jjte000;
}
throw (Error)jjte000;
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
void CaseElements ():
{/*@bgen(jjtree) CaseElements */
ASTCaseElements jjtn000 = new ASTCaseElements(this, JJTCASEELEMENTS);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) CaseElements */
try {
/*@egen*/
CaseLabel() (CaseElement())*/*@bgen(jjtree)*/
} catch (Throwable jjte000) {
if (jjtc000) {
jjtree.clearNodeScope(jjtn000);
jjtc000 = false;
} else {
jjtree.popNode();
}
if (jjte000 instanceof RuntimeException) {
throw (RuntimeException)jjte000;
}
if (jjte000 instanceof ParseException) {
throw (ParseException)jjte000;
}
throw (Error)jjte000;
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
void CaseElement ():
{/*@bgen(jjtree) CaseElement */
ASTCaseElement jjtn000 = new ASTCaseElement(this, JJTCASEELEMENT);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) CaseElement */
try {
/*@egen*/
Directive()
| CaseLabel()/*@bgen(jjtree)*/
} catch (Throwable jjte000) {
if (jjtc000) {
jjtree.clearNodeScope(jjtn000);
jjtc000 = false;
} else {
jjtree.popNode();
}
if (jjte000 instanceof RuntimeException) {
throw (RuntimeException)jjte000;
}
if (jjte000 instanceof ParseException) {
throw (ParseException)jjte000;
}
throw (Error)jjte000;
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
void CaseLabel ():
{/*@bgen(jjtree) CaseLabel */
ASTCaseLabel jjtn000 = new ASTCaseLabel(this, JJTCASELABEL);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) CaseLabel */
try {
/*@egen*/
ListExpression()
| <_DEFAULT> /*@bgen(jjtree)*/
} catch (Throwable jjte000) {
if (jjtc000) {
jjtree.clearNodeScope(jjtn000);
jjtc000 = false;
} else {
jjtree.popNode();
}
if (jjte000 instanceof RuntimeException) {
throw (RuntimeException)jjte000;
}
if (jjte000 instanceof ParseException) {
throw (ParseException)jjte000;
}
throw (Error)jjte000;
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
/////////////////////////////////////////////////////
// Do-While Statement
/////////////////////////////////////////////////////
void DoStatement():
{/*@bgen(jjtree) DoStatement */
ASTDoStatement jjtn000 = new ASTDoStatement(this, JJTDOSTATEMENT);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) DoStatement */
try {
/*@egen*/
Substatement() ListExpression() /*@bgen(jjtree)*/
} catch (Throwable jjte000) {
if (jjtc000) {
jjtree.clearNodeScope(jjtn000);
jjtc000 = false;
} else {
jjtree.popNode();
}
if (jjte000 instanceof RuntimeException) {
throw (RuntimeException)jjte000;
}
if (jjte000 instanceof ParseException) {
throw (ParseException)jjte000;
}
throw (Error)jjte000;
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
/////////////////////////////////////////////////////
// While Statement
/////////////////////////////////////////////////////
void WhileStatement ():
{/*@bgen(jjtree) WhileStatement */
ASTWhileStatement jjtn000 = new ASTWhileStatement(this, JJTWHILESTATEMENT);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) WhileStatement */
try {
/*@egen*/
ListExpression()
Substatement()/*@bgen(jjtree)*/
} catch (Throwable jjte000) {
if (jjtc000) {
jjtree.clearNodeScope(jjtn000);
jjtc000 = false;
} else {
jjtree.popNode();
}
if (jjte000 instanceof RuntimeException) {
throw (RuntimeException)jjte000;
}
if (jjte000 instanceof ParseException) {
throw (ParseException)jjte000;
}
throw (Error)jjte000;
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
/////////////////////////////////////////////////////
// For Statements
/////////////////////////////////////////////////////
void ForStatement ():
{/*@bgen(jjtree) ForStatement */
ASTForStatement jjtn000 = new ASTForStatement(this, JJTFORSTATEMENT);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) ForStatement */
try {
/*@egen*/
LOOKAHEAD( ForInBinding() )
ForInBinding() ListExpression()
Substatement()
| [ForInitializer()]
[ListExpression()]
[ListExpression()]
Substatement()/*@bgen(jjtree)*/
} catch (Throwable jjte000) {
if (jjtc000) {
jjtree.clearNodeScope(jjtn000);
jjtc000 = false;
} else {
jjtree.popNode();
}
if (jjte000 instanceof RuntimeException) {
throw (RuntimeException)jjte000;
}
if (jjte000 instanceof ParseException) {
throw (ParseException)jjte000;
}
throw (Error)jjte000;
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
void ForInitializer ():
{/*@bgen(jjtree) ForInitializer */
ASTForInitializer jjtn000 = new ASTForInitializer(this, JJTFORINITIALIZER);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) ForInitializer */
try {
/*@egen*/
LOOKAHEAD(3) ListExpressionNoIN()
| VariableDefinitionNoIN()
| Attributes() VariableDefinitionNoIN()/*@bgen(jjtree)*/
} catch (Throwable jjte000) {
if (jjtc000) {
jjtree.clearNodeScope(jjtn000);
jjtc000 = false;
} else {
jjtree.popNode();
}
if (jjte000 instanceof RuntimeException) {
throw (RuntimeException)jjte000;
}
if (jjte000 instanceof ParseException) {
throw (ParseException)jjte000;
}
throw (Error)jjte000;
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
void ForInBinding ():
{/*@bgen(jjtree) ForInBinding */
ASTForInBinding jjtn000 = new ASTForInBinding(this, JJTFORINBINDING);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) ForInBinding */
try {
/*@egen*/
LOOKAHEAD(3) PostfixExpression()
| VariableDefinitionKind() VariableBindingNoIN()
| Attributes() VariableDefinitionKind() VariableBindingNoIN()/*@bgen(jjtree)*/
} catch (Throwable jjte000) {
if (jjtc000) {
jjtree.clearNodeScope(jjtn000);
jjtc000 = false;
} else {
jjtree.popNode();
}
if (jjte000 instanceof RuntimeException) {
throw (RuntimeException)jjte000;
}
if (jjte000 instanceof ParseException) {
throw (ParseException)jjte000;
}
throw (Error)jjte000;
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
/////////////////////////////////////////////////////
// With Statement
/////////////////////////////////////////////////////
void WithStatement():
{/*@bgen(jjtree) WithStatement */
ASTWithStatement jjtn000 = new ASTWithStatement(this, JJTWITHSTATEMENT);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) WithStatement */
try {
/*@egen*/
ExpressionStatement()
Substatement()/*@bgen(jjtree)*/
} catch (Throwable jjte000) {
if (jjtc000) {
jjtree.clearNodeScope(jjtn000);
jjtc000 = false;
} else {
jjtree.popNode();
}
if (jjte000 instanceof RuntimeException) {
throw (RuntimeException)jjte000;
}
if (jjte000 instanceof ParseException) {
throw (ParseException)jjte000;
}
throw (Error)jjte000;
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
/////////////////////////////////////////////////////
// Continue and Break Statement
/////////////////////////////////////////////////////
void ContinueStatement():
{/*@bgen(jjtree) ContinueStatement */
ASTContinueStatement jjtn000 = new ASTContinueStatement(this, JJTCONTINUESTATEMENT);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) ContinueStatement */
try {
/*@egen*/
[Identifier()]/*@bgen(jjtree)*/
} catch (Throwable jjte000) {
if (jjtc000) {
jjtree.clearNodeScope(jjtn000);
jjtc000 = false;
} else {
jjtree.popNode();
}
if (jjte000 instanceof RuntimeException) {
throw (RuntimeException)jjte000;
}
if (jjte000 instanceof ParseException) {
throw (ParseException)jjte000;
}
throw (Error)jjte000;
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
void BreakStatement():
{/*@bgen(jjtree) BreakStatement */
ASTBreakStatement jjtn000 = new ASTBreakStatement(this, JJTBREAKSTATEMENT);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) BreakStatement */
try {
/*@egen*/
[Identifier()]/*@bgen(jjtree)*/
} catch (Throwable jjte000) {
if (jjtc000) {
jjtree.clearNodeScope(jjtn000);
jjtc000 = false;
} else {
jjtree.popNode();
}
if (jjte000 instanceof RuntimeException) {
throw (RuntimeException)jjte000;
}
if (jjte000 instanceof ParseException) {
throw (ParseException)jjte000;
}
throw (Error)jjte000;
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
/////////////////////////////////////////////////////
// Return Statement
/////////////////////////////////////////////////////
void ReturnStatement():
{/*@bgen(jjtree) ReturnStatement */
ASTReturnStatement jjtn000 = new ASTReturnStatement(this, JJTRETURNSTATEMENT);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) ReturnStatement */
try {
/*@egen*/
[ListExpression()]/*@bgen(jjtree)*/
} catch (Throwable jjte000) {
if (jjtc000) {
jjtree.clearNodeScope(jjtn000);
jjtc000 = false;
} else {
jjtree.popNode();
}
if (jjte000 instanceof RuntimeException) {
throw (RuntimeException)jjte000;
}
if (jjte000 instanceof ParseException) {
throw (ParseException)jjte000;
}
throw (Error)jjte000;
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
/////////////////////////////////////////////////////
// Throw Statement
/////////////////////////////////////////////////////
void ThrowStatement():
{/*@bgen(jjtree) ThrowStatement */
ASTThrowStatement jjtn000 = new ASTThrowStatement(this, JJTTHROWSTATEMENT);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) ThrowStatement */
try {
/*@egen*/
ListExpression()/*@bgen(jjtree)*/
} catch (Throwable jjte000) {
if (jjtc000) {
jjtree.clearNodeScope(jjtn000);
jjtc000 = false;
} else {
jjtree.popNode();
}
if (jjte000 instanceof RuntimeException) {
throw (RuntimeException)jjte000;
}
if (jjte000 instanceof ParseException) {
throw (ParseException)jjte000;
}
throw (Error)jjte000;
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
/////////////////////////////////////////////////////
// Try Statement
/////////////////////////////////////////////////////
void TryStatement():
{/*@bgen(jjtree) TryStatement */
ASTTryStatement jjtn000 = new ASTTryStatement(this, JJTTRYSTATEMENT);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) TryStatement */
try {
/*@egen*/
Block()
( Identifier() Block())*
[ Block()]/*@bgen(jjtree)*/
} catch (Throwable jjte000) {
if (jjtc000) {
jjtree.clearNodeScope(jjtn000);
jjtc000 = false;
} else {
jjtree.popNode();
}
if (jjte000 instanceof RuntimeException) {
throw (RuntimeException)jjte000;
}
if (jjte000 instanceof ParseException) {
throw (ParseException)jjte000;
}
throw (Error)jjte000;
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
/////////////////////////////////////////////////////
// Directives
/////////////////////////////////////////////////////
void Directives ():
{/*@bgen(jjtree) Directives */
ASTDirectives jjtn000 = new ASTDirectives(this, JJTDIRECTIVES);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) Directives */
try {
/*@egen*/
(Directive())+/*@bgen(jjtree)*/
} catch (Throwable jjte000) {
if (jjtc000) {
jjtree.clearNodeScope(jjtn000);
jjtc000 = false;
} else {
jjtree.popNode();
}
if (jjte000 instanceof RuntimeException) {
throw (RuntimeException)jjte000;
}
if (jjte000 instanceof ParseException) {
throw (ParseException)jjte000;
}
throw (Error)jjte000;
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
void Directive ():
{/*@bgen(jjtree) Directive */
ASTDirective jjtn000 = new ASTDirective(this, JJTDIRECTIVE);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) Directive */
try {
/*@egen*/
EmptyStatement()
| LOOKAHEAD(3) Statement()
| LOOKAHEAD(2) AnnotatableDirective()
| LOOKAHEAD(2) Attributes() Directives()
| LOOKAHEAD(2) Attributes() AnnotatableDirective()
| IncludeDirective() Sc()
| Pragma() Sc()/*@bgen(jjtree)*/
} catch (Throwable jjte000) {
if (jjtc000) {
jjtree.clearNodeScope(jjtn000);
jjtc000 = false;
} else {
jjtree.popNode();
}
if (jjte000 instanceof RuntimeException) {
throw (RuntimeException)jjte000;
}
if (jjte000 instanceof ParseException) {
throw (ParseException)jjte000;
}
throw (Error)jjte000;
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
void AnnotatableDirective ():
{/*@bgen(jjtree) AnnotatableDirective */
ASTAnnotatableDirective jjtn000 = new ASTAnnotatableDirective(this, JJTANNOTATABLEDIRECTIVE);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) AnnotatableDirective */
try {
/*@egen*/
VariableDefinition() Sc()
| FunctionDefinition()
| ClassDefinition()
| InterfaceDefinition()
| NamespaceDefinition() Sc()
| ImportDirective() Sc()
| ExportDefinition() Sc()
| UseDirective() Sc()/*@bgen(jjtree)*/
} catch (Throwable jjte000) {
if (jjtc000) {
jjtree.clearNodeScope(jjtn000);
jjtc000 = false;
} else {
jjtree.popNode();
}
if (jjte000 instanceof RuntimeException) {
throw (RuntimeException)jjte000;
}
if (jjte000 instanceof ParseException) {
throw (ParseException)jjte000;
}
throw (Error)jjte000;
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
/////////////////////////////////////////////////////
// Attributes
/////////////////////////////////////////////////////
void Attributes ():
{/*@bgen(jjtree) Attributes */
ASTAttributes jjtn000 = new ASTAttributes(this, JJTATTRIBUTES);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) Attributes */
try {
/*@egen*/
(Attribute ())+/*@bgen(jjtree)*/
} catch (Throwable jjte000) {
if (jjtc000) {
jjtree.clearNodeScope(jjtn000);
jjtc000 = false;
} else {
jjtree.popNode();
}
if (jjte000 instanceof RuntimeException) {
throw (RuntimeException)jjte000;
}
if (jjte000 instanceof ParseException) {
throw (ParseException)jjte000;
}
throw (Error)jjte000;
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
void Attribute ():
{/*@bgen(jjtree) Attribute */
ASTAttribute jjtn000 = new ASTAttribute(this, JJTATTRIBUTE);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) Attribute */
try {
/*@egen*/
AttributeExpression()
|
| /*@bgen(jjtree)*/
} catch (Throwable jjte000) {
if (jjtc000) {
jjtree.clearNodeScope(jjtn000);
jjtc000 = false;
} else {
jjtree.popNode();
}
if (jjte000 instanceof RuntimeException) {
throw (RuntimeException)jjte000;
}
if (jjte000 instanceof ParseException) {
throw (ParseException)jjte000;
}
throw (Error)jjte000;
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
}
}
/*@egen*/
}
/////////////////////////////////////////////////////
// Use Directive
/////////////////////////////////////////////////////
void UseDirective ():
{/*@bgen(jjtree) UseDirective */
ASTUseDirective jjtn000 = new ASTUseDirective(this, JJTUSEDIRECTIVE);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) UseDirective */
try {
/*@egen*/