From adffaces-commits-return-201-apmail-incubator-adffaces-commits-archive=incubator.apache.org@incubator.apache.org Mon Jul 24 17:00:21 2006 Return-Path: Delivered-To: apmail-incubator-adffaces-commits-archive@locus.apache.org Received: (qmail 29720 invoked from network); 24 Jul 2006 17:00:21 -0000 Received: from hermes.apache.org (HELO mail.apache.org) (209.237.227.199) by minotaur.apache.org with SMTP; 24 Jul 2006 17:00:21 -0000 Received: (qmail 53525 invoked by uid 500); 24 Jul 2006 17:00:20 -0000 Delivered-To: apmail-incubator-adffaces-commits-archive@incubator.apache.org Received: (qmail 53423 invoked by uid 500); 24 Jul 2006 17:00:20 -0000 Mailing-List: contact adffaces-commits-help@incubator.apache.org; run by ezmlm Precedence: bulk List-Help: List-Unsubscribe: List-Post: List-Id: Reply-To: adffaces-dev@incubator.apache.org Delivered-To: mailing list adffaces-commits@incubator.apache.org Received: (qmail 53337 invoked by uid 99); 24 Jul 2006 17:00:19 -0000 Received: from asf.osuosl.org (HELO asf.osuosl.org) (140.211.166.49) by apache.org (qpsmtpd/0.29) with ESMTP; Mon, 24 Jul 2006 10:00:19 -0700 X-ASF-Spam-Status: No, hits=-9.4 required=10.0 tests=ALL_TRUSTED,NO_REAL_NAME X-Spam-Check-By: apache.org Received-SPF: pass (asf.osuosl.org: local policy) Received: from [140.211.166.113] (HELO eris.apache.org) (140.211.166.113) by apache.org (qpsmtpd/0.29) with ESMTP; Mon, 24 Jul 2006 10:00:11 -0700 Received: by eris.apache.org (Postfix, from userid 65534) id 4A0601A9827; Mon, 24 Jul 2006 09:59:26 -0700 (PDT) Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit Subject: svn commit: r425117 [6/14] - in /incubator/adffaces/branches/matzew-repackaging-trinidad/plugins/maven-javascript-plugin/src/main/java/org/apache/myfaces/trinidadbuild/plugin/javascript: ./ javascript20parser/ javascriptcompiler/ obfuscator/ obfuscator... Date: Mon, 24 Jul 2006 16:58:51 -0000 To: adffaces-commits@incubator.apache.org From: matzew@apache.org X-Mailer: svnmailer-1.0.8 Message-Id: <20060724165926.4A0601A9827@eris.apache.org> X-Virus-Checked: Checked by ClamAV on apache.org X-Spam-Rating: minotaur.apache.org 1.6.2 0/1000/N Added: incubator/adffaces/branches/matzew-repackaging-trinidad/plugins/maven-javascript-plugin/src/main/java/org/apache/myfaces/trinidadbuild/plugin/javascript/javascript20parser/JSParser20.java URL: http://svn.apache.org/viewvc/incubator/adffaces/branches/matzew-repackaging-trinidad/plugins/maven-javascript-plugin/src/main/java/org/apache/myfaces/trinidadbuild/plugin/javascript/javascript20parser/JSParser20.java?rev=425117&view=auto ============================================================================== --- incubator/adffaces/branches/matzew-repackaging-trinidad/plugins/maven-javascript-plugin/src/main/java/org/apache/myfaces/trinidadbuild/plugin/javascript/javascript20parser/JSParser20.java (added) +++ incubator/adffaces/branches/matzew-repackaging-trinidad/plugins/maven-javascript-plugin/src/main/java/org/apache/myfaces/trinidadbuild/plugin/javascript/javascript20parser/JSParser20.java Mon Jul 24 09:58:43 2006 @@ -0,0 +1,9407 @@ +/* +* Copyright 2006 The Apache Software Foundation. +* +* Licensed 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. +*/ +/* Generated By:JJTree&JavaCC: Do not edit this line. JSParser20.java */ +package org.apache.myfaces.trinidadbuild.plugin.javascript.javascript20parser; + +import java.io.IOException; +public class JSParser20/*@bgen(jjtree)*/implements JSParser20TreeConstants, JSParser20Constants {/*@bgen(jjtree)*/ + protected JJTJSParser20State jjtree = new JJTJSParser20State();// + // This is the root node for the parse tree (root DOM node, tree of SimpleNode(s)) + // + protected ASTProgram _jjtRoot; + + public ASTProgram getRootNode() + { + return _jjtRoot; + } + +/////////////////////////////////////////////////////////////////// +// GRAMMAR Section +/////////////////////////////////////////////////////////////////// + final public Token Program() throws ParseException { + /*@bgen(jjtree) Program */ + ASTProgram jjtn000 = new ASTProgram(this, JJTPROGRAM); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000);Token retval = getToken(1); + try { + label_1: + while (true) { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case PACKAGE: + ; + break; + default: + jj_la1[0] = jj_gen; + break label_1; + } + PackageDefinition(); + } + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case BREAK: + case CLASS: + case CONST: + case CONTINUE: + case DELETE: + case DO: + case FALSE: + case FOR: + case FUNCTION: + case GET: + case IF: + case INCLUDE: + case NAMESPACE: + case NEW: + case NULL: + case PRIVATE: + case PUBLIC: + case RETURN: + case SET: + case SUPER: + case SWITCH: + case THIS: + case THROW: + case TRUE: + case TRY: + case TYPEOF: + case USE: + case VAR: + case VOID: + case WHILE: + case WITH: + case EXPORT: + case INTERFACE: + case PROTECTED: + case IMPORT: + case DECIMAL_LITERAL: + case HEX_LITERAL: + case OCTAL_LITERAL: + case FLOATING_POINT_LITERAL: + case STRING_LITERAL: + case REGULAR_EXPRESSION: + case IDENTIFIER: + case LPAREN: + case LBRACE: + case LBRACKET: + case SEMICOLON: + case BANG: + case TILDE: + case INCR: + case DECR: + case PLUS: + case MINUS: + Directives(); + break; + default: + jj_la1[1] = jj_gen; + ; + } + jj_consume_token(0); + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + _jjtRoot = jjtn000; + {if (true) return retval;} + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + {if (true) throw (RuntimeException)jjte000;} + } + if (jjte000 instanceof ParseException) { + {if (true) throw (ParseException)jjte000;} + } + {if (true) throw (Error)jjte000;} + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } + throw new Error("Missing return statement in function"); + } + +///////////////////////////////////////////////////// +// Expressions +///////////////////////////////////////////////////// + +///////////////////////////////////////////////////// +// Identifier +///////////////////////////////////////////////////// + final public void Identifier() throws ParseException { + /*@bgen(jjtree) Identifier */ + ASTIdentifier jjtn000 = new ASTIdentifier(this, JJTIDENTIFIER); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); + try { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case IDENTIFIER: + jj_consume_token(IDENTIFIER); + break; + case GET: + jj_consume_token(GET); + break; + case SET: + jj_consume_token(SET); + break; + case INCLUDE: + jj_consume_token(INCLUDE); + break; + default: + jj_la1[2] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } + } + +///////////////////////////////////////////////////// +// Qualified Identifier +///////////////////////////////////////////////////// + final public void SimpleQualifiedIdentifier() throws ParseException { + /*@bgen(jjtree) SimpleQualifiedIdentifier */ + ASTSimpleQualifiedIdentifier jjtn000 = new ASTSimpleQualifiedIdentifier(this, JJTSIMPLEQUALIFIEDIDENTIFIER); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); + try { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case GET: + case INCLUDE: + case SET: + case IDENTIFIER: + Identifier(); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case QUALIFIER: + jj_consume_token(QUALIFIER); + Identifier(); + break; + default: + jj_la1[3] = jj_gen; + ; + } + break; + case PRIVATE: + case PUBLIC: + case PROTECTED: + ReservedNamespace(); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case QUALIFIER: + jj_consume_token(QUALIFIER); + Identifier(); + break; + default: + jj_la1[4] = jj_gen; + ; + } + break; + default: + jj_la1[5] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + {if (true) throw (RuntimeException)jjte000;} + } + if (jjte000 instanceof ParseException) { + {if (true) throw (ParseException)jjte000;} + } + {if (true) throw (Error)jjte000;} + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } + } + + final public void ExpressionQualifiedIdentifier() throws ParseException { + /*@bgen(jjtree) ExpressionQualifiedIdentifier */ + ASTExpressionQualifiedIdentifier jjtn000 = new ASTExpressionQualifiedIdentifier(this, JJTEXPRESSIONQUALIFIEDIDENTIFIER); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); + try { + jj_consume_token(LPAREN); + AssignmentExpression(); + jj_consume_token(RPAREN); + jj_consume_token(QUALIFIER); + Identifier(); + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + {if (true) throw (RuntimeException)jjte000;} + } + if (jjte000 instanceof ParseException) { + {if (true) throw (ParseException)jjte000;} + } + {if (true) throw (Error)jjte000;} + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } + } + + final public void QualifiedIdentifier() throws ParseException { + /*@bgen(jjtree) QualifiedIdentifier */ + ASTQualifiedIdentifier jjtn000 = new ASTQualifiedIdentifier(this, JJTQUALIFIEDIDENTIFIER); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); + try { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case GET: + case INCLUDE: + case PRIVATE: + case PUBLIC: + case SET: + case PROTECTED: + case IDENTIFIER: + SimpleQualifiedIdentifier(); + break; + case LPAREN: + ExpressionQualifiedIdentifier(); + break; + default: + jj_la1[6] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + {if (true) throw (RuntimeException)jjte000;} + } + if (jjte000 instanceof ParseException) { + {if (true) throw (ParseException)jjte000;} + } + {if (true) throw (Error)jjte000;} + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } + } + +///////////////////////////////////////////////////// +// Primary Expressions +///////////////////////////////////////////////////// + final public void PrimaryExpression() throws ParseException { + /*@bgen(jjtree) PrimaryExpression */ + ASTPrimaryExpression jjtn000 = new ASTPrimaryExpression(this, JJTPRIMARYEXPRESSION); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); + try { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case NULL: + jj_consume_token(NULL); + break; + case TRUE: + jj_consume_token(TRUE); + break; + case FALSE: + jj_consume_token(FALSE); + break; + case DECIMAL_LITERAL: + jj_consume_token(DECIMAL_LITERAL); + break; + case OCTAL_LITERAL: + jj_consume_token(OCTAL_LITERAL); + break; + case HEX_LITERAL: + jj_consume_token(HEX_LITERAL); + break; + case FLOATING_POINT_LITERAL: + jj_consume_token(FLOATING_POINT_LITERAL); + break; + case STRING_LITERAL: + jj_consume_token(STRING_LITERAL); + break; + case THIS: + jj_consume_token(THIS); + break; + case REGULAR_EXPRESSION: + jj_consume_token(REGULAR_EXPRESSION); + break; + case LPAREN: + jj_consume_token(LPAREN); + ListExpression(); + jj_consume_token(RPAREN); + break; + case LBRACKET: + ArrayLiteral(); + break; + case LBRACE: + ObjectLiteral(); + break; + case FUNCTION: + FunctionExpression(); + break; + default: + jj_la1[7] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + token_source.setRegValid(); + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + {if (true) throw (RuntimeException)jjte000;} + } + if (jjte000 instanceof ParseException) { + {if (true) throw (ParseException)jjte000;} + } + {if (true) throw (Error)jjte000;} + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } + } + + final public void ReservedNamespace() throws ParseException { + /*@bgen(jjtree) ReservedNamespace */ + ASTReservedNamespace jjtn000 = new ASTReservedNamespace(this, JJTRESERVEDNAMESPACE); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); + try { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case PUBLIC: + jj_consume_token(PUBLIC); + break; + case PROTECTED: + jj_consume_token(PROTECTED); + break; + case PRIVATE: + jj_consume_token(PRIVATE); + break; + default: + jj_la1[8] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } + } + +///////////////////////////////////////////////////// +// Function Expression +///////////////////////////////////////////////////// + final public void FunctionExpression() throws ParseException { + /*@bgen(jjtree) FunctionExpression */ + ASTFunctionExpression jjtn000 = new ASTFunctionExpression(this, JJTFUNCTIONEXPRESSION); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); + try { + if (jj_2_1(2)) { + jj_consume_token(FUNCTION); + FunctionCommon(); + } else { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case FUNCTION: + jj_consume_token(FUNCTION); + Identifier(); + FunctionCommon(); + break; + default: + jj_la1[9] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + } + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + {if (true) throw (RuntimeException)jjte000;} + } + if (jjte000 instanceof ParseException) { + {if (true) throw (ParseException)jjte000;} + } + {if (true) throw (Error)jjte000;} + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } + } + +///////////////////////////////////////////////////// +// Object Literals +///////////////////////////////////////////////////// + final public void ObjectLiteral() throws ParseException { + /*@bgen(jjtree) ObjectLiteral */ + ASTObjectLiteral jjtn000 = new ASTObjectLiteral(this, JJTOBJECTLITERAL); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); + try { + jj_consume_token(LBRACE); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case GET: + case INCLUDE: + case PRIVATE: + case PUBLIC: + case SET: + case PROTECTED: + case DECIMAL_LITERAL: + case STRING_LITERAL: + case IDENTIFIER: + case LPAREN: + FieldList(); + break; + default: + jj_la1[10] = jj_gen; + ; + } + jj_consume_token(RBRACE); + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + {if (true) throw (RuntimeException)jjte000;} + } + if (jjte000 instanceof ParseException) { + {if (true) throw (ParseException)jjte000;} + } + {if (true) throw (Error)jjte000;} + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } + } + + final public void FieldList() throws ParseException { + /*@bgen(jjtree) FieldList */ + ASTFieldList jjtn000 = new ASTFieldList(this, JJTFIELDLIST); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); + try { + LiteralField(); + label_2: + while (true) { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case COMMA: + ; + break; + default: + jj_la1[11] = jj_gen; + break label_2; + } + jj_consume_token(COMMA); + LiteralField(); + } + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + {if (true) throw (RuntimeException)jjte000;} + } + if (jjte000 instanceof ParseException) { + {if (true) throw (ParseException)jjte000;} + } + {if (true) throw (Error)jjte000;} + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } + } + + final public void LiteralField() throws ParseException { + /*@bgen(jjtree) LiteralField */ + ASTLiteralField jjtn000 = new ASTLiteralField(this, JJTLITERALFIELD); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); + try { + FieldName(); + jj_consume_token(COLON); + AssignmentExpression(); + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + {if (true) throw (RuntimeException)jjte000;} + } + if (jjte000 instanceof ParseException) { + {if (true) throw (ParseException)jjte000;} + } + {if (true) throw (Error)jjte000;} + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } + } + + final public void FieldName() throws ParseException { + /*@bgen(jjtree) FieldName */ + ASTFieldName jjtn000 = new ASTFieldName(this, JJTFIELDNAME); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); + try { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case STRING_LITERAL: + jj_consume_token(STRING_LITERAL); + break; + case DECIMAL_LITERAL: + jj_consume_token(DECIMAL_LITERAL); + break; + case GET: + case INCLUDE: + case PRIVATE: + case PUBLIC: + case SET: + case PROTECTED: + case IDENTIFIER: + SimpleQualifiedIdentifier(); + break; + case LPAREN: + jj_consume_token(LPAREN); + AssignmentExpression(); + jj_consume_token(RPAREN); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case QUALIFIER: + jj_consume_token(QUALIFIER); + Identifier(); + break; + default: + jj_la1[12] = jj_gen; + ; + } + break; + default: + jj_la1[13] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + {if (true) throw (RuntimeException)jjte000;} + } + if (jjte000 instanceof ParseException) { + {if (true) throw (ParseException)jjte000;} + } + {if (true) throw (Error)jjte000;} + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } + } + +///////////////////////////////////////////////////// +// Array Literal +///////////////////////////////////////////////////// + final public void ArrayLiteral() throws ParseException { + /*@bgen(jjtree) ArrayLiteral */ + ASTArrayLiteral jjtn000 = new ASTArrayLiteral(this, JJTARRAYLITERAL); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); + try { + jj_consume_token(LBRACKET); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case DELETE: + case FALSE: + case FUNCTION: + case GET: + case INCLUDE: + case NEW: + case NULL: + case PRIVATE: + case PUBLIC: + case SET: + case SUPER: + case THIS: + case TRUE: + case TYPEOF: + case VOID: + case PROTECTED: + case DECIMAL_LITERAL: + case HEX_LITERAL: + case OCTAL_LITERAL: + case FLOATING_POINT_LITERAL: + case STRING_LITERAL: + case REGULAR_EXPRESSION: + case IDENTIFIER: + case LPAREN: + case LBRACE: + case LBRACKET: + case BANG: + case TILDE: + case INCR: + case DECR: + case PLUS: + case MINUS: + ElementList(); + break; + default: + jj_la1[14] = jj_gen; + ; + } + jj_consume_token(RBRACKET); + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + {if (true) throw (RuntimeException)jjte000;} + } + if (jjte000 instanceof ParseException) { + {if (true) throw (ParseException)jjte000;} + } + {if (true) throw (Error)jjte000;} + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } + } + + final public void ElementList() throws ParseException { + /*@bgen(jjtree) ElementList */ + ASTElementList jjtn000 = new ASTElementList(this, JJTELEMENTLIST); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); + try { + LiteralElement(); + label_3: + while (true) { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case COMMA: + ; + break; + default: + jj_la1[15] = jj_gen; + break label_3; + } + jj_consume_token(COMMA); + LiteralElement(); + } + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + {if (true) throw (RuntimeException)jjte000;} + } + if (jjte000 instanceof ParseException) { + {if (true) throw (ParseException)jjte000;} + } + {if (true) throw (Error)jjte000;} + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } + } + + final public void LiteralElement() throws ParseException { + /*@bgen(jjtree) LiteralElement */ + ASTLiteralElement jjtn000 = new ASTLiteralElement(this, JJTLITERALELEMENT); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); + try { + AssignmentExpression(); + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + {if (true) throw (RuntimeException)jjte000;} + } + if (jjte000 instanceof ParseException) { + {if (true) throw (ParseException)jjte000;} + } + {if (true) throw (Error)jjte000;} + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } + } + +///////////////////////////////////////////////////// +// Super Expression +///////////////////////////////////////////////////// + final public void SuperExpression() throws ParseException { + /*@bgen(jjtree) SuperExpression */ + ASTSuperExpression jjtn000 = new ASTSuperExpression(this, JJTSUPEREXPRESSION); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); + try { + jj_consume_token(SUPER); + if (jj_2_2(2)) { + jj_consume_token(LPAREN); + AssignmentExpression(); + jj_consume_token(RPAREN); + } else { + ; + } + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + {if (true) throw (RuntimeException)jjte000;} + } + if (jjte000 instanceof ParseException) { + {if (true) throw (ParseException)jjte000;} + } + {if (true) throw (Error)jjte000;} + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } + } + +///////////////////////////////////////////////////// +// Postfix Expression +///////////////////////////////////////////////////// + final public void PostfixExpression() throws ParseException { + /*@bgen(jjtree) PostfixExpression */ + ASTPostfixExpression jjtn000 = new ASTPostfixExpression(this, JJTPOSTFIXEXPRESSION); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); + try { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case GET: + case INCLUDE: + case PRIVATE: + case PUBLIC: + case SET: + case PROTECTED: + case IDENTIFIER: + AttributeExpression(); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case INCR: + case DECR: + PostfixOp(); + break; + default: + jj_la1[16] = jj_gen; + ; + } + break; + case FALSE: + case FUNCTION: + case NEW: + case NULL: + case THIS: + case TRUE: + case DECIMAL_LITERAL: + case HEX_LITERAL: + case OCTAL_LITERAL: + case FLOATING_POINT_LITERAL: + case STRING_LITERAL: + case REGULAR_EXPRESSION: + case LPAREN: + case LBRACE: + case LBRACKET: + token_source.setRegInvalid(); + FullPostfixExpression(); + label_4: + while (true) { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case LPAREN: + case LBRACKET: + case DOT: + ; + break; + default: + jj_la1[17] = jj_gen; + break label_4; + } + PropertyOrArguments(); + } + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case INCR: + case DECR: + PostfixOp(); + break; + default: + jj_la1[18] = jj_gen; + ; + } + break; + case SUPER: + SuperExpression(); + PropertyOperator(); + break; + default: + jj_la1[19] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + {if (true) throw (RuntimeException)jjte000;} + } + if (jjte000 instanceof ParseException) { + {if (true) throw (ParseException)jjte000;} + } + {if (true) throw (Error)jjte000;} + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } + } + + final public void AttributeExpression() throws ParseException { + /*@bgen(jjtree) AttributeExpression */ + ASTAttributeExpression jjtn000 = new ASTAttributeExpression(this, JJTATTRIBUTEEXPRESSION); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); + try { + SimpleQualifiedIdentifier(); + label_5: + while (true) { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case LPAREN: + case LBRACKET: + case DOT: + ; + break; + default: + jj_la1[20] = jj_gen; + break label_5; + } + PropertyOrArguments(); + } + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + {if (true) throw (RuntimeException)jjte000;} + } + if (jjte000 instanceof ParseException) { + {if (true) throw (ParseException)jjte000;} + } + {if (true) throw (Error)jjte000;} + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } + } + + final public void FullPostfixExpression() throws ParseException { + /*@bgen(jjtree) FullPostfixExpression */ + ASTFullPostfixExpression jjtn000 = new ASTFullPostfixExpression(this, JJTFULLPOSTFIXEXPRESSION); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); + try { + if (jj_2_3(2147483647)) { + ExpressionQualifiedIdentifier(); + } else { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case FALSE: + case FUNCTION: + case NULL: + case THIS: + case TRUE: + case DECIMAL_LITERAL: + case HEX_LITERAL: + case OCTAL_LITERAL: + case FLOATING_POINT_LITERAL: + case STRING_LITERAL: + case REGULAR_EXPRESSION: + case LPAREN: + case LBRACE: + case LBRACKET: + PrimaryExpression(); + break; + case NEW: + FullNewExpression(); + break; + default: + jj_la1[21] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + } + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + {if (true) throw (RuntimeException)jjte000;} + } + if (jjte000 instanceof ParseException) { + {if (true) throw (ParseException)jjte000;} + } + {if (true) throw (Error)jjte000;} + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } + } + + final public void FullNewExpression() throws ParseException { + /*@bgen(jjtree) FullNewExpression */ + ASTFullNewExpression jjtn000 = new ASTFullNewExpression(this, JJTFULLNEWEXPRESSION); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); + try { + jj_consume_token(NEW); + FullNewSubexpression(); + label_6: + while (true) { + if (jj_2_4(2)) { + ; + } else { + break label_6; + } + PropertyOperator(); + } + if (jj_2_5(2)) { + Arguments(); + } else { + ; + } + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + {if (true) throw (RuntimeException)jjte000;} + } + if (jjte000 instanceof ParseException) { + {if (true) throw (ParseException)jjte000;} + } + {if (true) throw (Error)jjte000;} + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } + } + + final public void FunctionConstructor() throws ParseException { + /*@bgen(jjtree) FunctionConstructor */ + ASTFunctionConstructor jjtn000 = new ASTFunctionConstructor(this, JJTFUNCTIONCONSTRUCTOR); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); + try { + jj_consume_token(FUNCTION_); + Arguments(); + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + {if (true) throw (RuntimeException)jjte000;} + } + if (jjte000 instanceof ParseException) { + {if (true) throw (ParseException)jjte000;} + } + {if (true) throw (Error)jjte000;} + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } + } + + final public void FullNewSubexpression() throws ParseException { + /*@bgen(jjtree) FullNewSubexpression */ + ASTFullNewSubexpression jjtn000 = new ASTFullNewSubexpression(this, JJTFULLNEWSUBEXPRESSION); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); + try { + if (jj_2_6(2147483647)) { + ExpressionQualifiedIdentifier(); + } else { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case FALSE: + case FUNCTION: + case NULL: + case THIS: + case TRUE: + case DECIMAL_LITERAL: + case HEX_LITERAL: + case OCTAL_LITERAL: + case FLOATING_POINT_LITERAL: + case STRING_LITERAL: + case REGULAR_EXPRESSION: + case LPAREN: + case LBRACE: + case LBRACKET: + PrimaryExpression(); + break; + case GET: + case INCLUDE: + case PRIVATE: + case PUBLIC: + case SET: + case PROTECTED: + case IDENTIFIER: + SimpleQualifiedIdentifier(); + break; + case SUPER: + SuperExpression(); + break; + case NEW: + FullNewExpression(); + break; + case FUNCTION_: + FunctionConstructor(); + break; + default: + jj_la1[22] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + } + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + {if (true) throw (RuntimeException)jjte000;} + } + if (jjte000 instanceof ParseException) { + {if (true) throw (ParseException)jjte000;} + } + {if (true) throw (Error)jjte000;} + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } + } + + final public void PostfixOp() throws ParseException { + /*@bgen(jjtree) PostfixOp */ + ASTPostfixOp jjtn000 = new ASTPostfixOp(this, JJTPOSTFIXOP); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); + try { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case INCR: + jj_consume_token(INCR); + break; + case DECR: + jj_consume_token(DECR); + break; + default: + jj_la1[23] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } + } + + final public void PropertyOrArguments() throws ParseException { + /*@bgen(jjtree) PropertyOrArguments */ + ASTPropertyOrArguments jjtn000 = new ASTPropertyOrArguments(this, JJTPROPERTYORARGUMENTS); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); + try { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case LPAREN: + Arguments(); + break; + case LBRACKET: + case DOT: + PropertyOperator(); + break; + default: + jj_la1[24] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + {if (true) throw (RuntimeException)jjte000;} + } + if (jjte000 instanceof ParseException) { + {if (true) throw (ParseException)jjte000;} + } + {if (true) throw (Error)jjte000;} + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } + } + +///////////////////////////////////////////////////// +// Property Operators +///////////////////////////////////////////////////// + final public void PropertyOperator() throws ParseException { + /*@bgen(jjtree) PropertyOperator */ + ASTPropertyOperator jjtn000 = new ASTPropertyOperator(this, JJTPROPERTYOPERATOR); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); + try { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case DOT: + jj_consume_token(DOT); + QualifiedIdentifier(); + break; + default: + jj_la1[26] = jj_gen; + if (jj_2_7(2)) { + jj_consume_token(LBRACKET); + jj_consume_token(RBRACKET); + } else if (jj_2_8(2)) { + jj_consume_token(LBRACKET); + jj_consume_token(ELIPSE); + AssignmentExpression(); + jj_consume_token(RBRACKET); + } else { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case LBRACKET: + jj_consume_token(LBRACKET); + ListExpression(); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case ELIPSE: + jj_consume_token(ELIPSE); + AssignmentExpression(); + break; + default: + jj_la1[25] = jj_gen; + ; + } + jj_consume_token(RBRACKET); + break; + default: + jj_la1[27] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + } + } + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + {if (true) throw (RuntimeException)jjte000;} + } + if (jjte000 instanceof ParseException) { + {if (true) throw (ParseException)jjte000;} + } + {if (true) throw (Error)jjte000;} + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } + } + + final public void Arguments() throws ParseException { + /*@bgen(jjtree) Arguments */ + ASTArguments jjtn000 = new ASTArguments(this, JJTARGUMENTS); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000);{token_source.setRegValid();} + try { + if (jj_2_9(2)) { + jj_consume_token(LPAREN); + jj_consume_token(RPAREN); + } else if (jj_2_10(2)) { + jj_consume_token(LPAREN); + jj_consume_token(ELIPSE); + AssignmentExpression(); + jj_consume_token(RPAREN); + } else { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case LPAREN: + jj_consume_token(LPAREN); + ListExpression(); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case ELIPSE: + jj_consume_token(ELIPSE); + AssignmentExpression(); + break; + default: + jj_la1[28] = jj_gen; + ; + } + jj_consume_token(RPAREN); + break; + default: + jj_la1[29] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + } + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + {if (true) throw (RuntimeException)jjte000;} + } + if (jjte000 instanceof ParseException) { + {if (true) throw (ParseException)jjte000;} + } + {if (true) throw (Error)jjte000;} + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } + } + +///////////////////////////////////////////////////// +// Unary Operators +///////////////////////////////////////////////////// + final public void UnaryExpression() throws ParseException { + /*@bgen(jjtree) UnaryExpression */ + ASTUnaryExpression jjtn000 = new ASTUnaryExpression(this, JJTUNARYEXPRESSION); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); + try { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case FALSE: + case FUNCTION: + case GET: + case INCLUDE: + case NEW: + case NULL: + case PRIVATE: + case PUBLIC: + case SET: + case SUPER: + case THIS: + case TRUE: + case PROTECTED: + case DECIMAL_LITERAL: + case HEX_LITERAL: + case OCTAL_LITERAL: + case FLOATING_POINT_LITERAL: + case STRING_LITERAL: + case REGULAR_EXPRESSION: + case IDENTIFIER: + case LPAREN: + case LBRACE: + case LBRACKET: + PostfixExpression(); + break; + case DELETE: + jj_consume_token(DELETE); + PostfixExpression(); + break; + case VOID: + jj_consume_token(VOID); + UnaryExpression(); + break; + case TYPEOF: + jj_consume_token(TYPEOF); + UnaryExpression(); + break; + case INCR: + jj_consume_token(INCR); + PostfixExpression(); + break; + case DECR: + jj_consume_token(DECR); + PostfixExpression(); + break; + case PLUS: + jj_consume_token(PLUS); + UnaryExpression(); + break; + case MINUS: + jj_consume_token(MINUS); + UnaryExpression(); + break; + case TILDE: + jj_consume_token(TILDE); + UnaryExpression(); + break; + case BANG: + jj_consume_token(BANG); + UnaryExpression(); + break; + default: + jj_la1[30] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + {if (true) throw (RuntimeException)jjte000;} + } + if (jjte000 instanceof ParseException) { + {if (true) throw (ParseException)jjte000;} + } + {if (true) throw (Error)jjte000;} + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } + } + +///////////////////////////////////////////////////// +// Multiplicative Operators +///////////////////////////////////////////////////// + final public void MulOp() throws ParseException { + /*@bgen(jjtree) MulOp */ + ASTMulOp jjtn000 = new ASTMulOp(this, JJTMULOP); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); + try { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case STAR: + jj_consume_token(STAR); + break; + case SLASH: + jj_consume_token(SLASH); + break; + case REM: + jj_consume_token(REM); + break; + default: + jj_la1[31] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } + } + + final public void MultiplicativeExpression() throws ParseException { + /*@bgen(jjtree) MultiplicativeExpression */ + ASTMultiplicativeExpression jjtn000 = new ASTMultiplicativeExpression(this, JJTMULTIPLICATIVEEXPRESSION); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); + try { + UnaryExpression(); + label_7: + while (true) { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case STAR: + case SLASH: + case REM: + ; + break; + default: + jj_la1[32] = jj_gen; + break label_7; + } + MulOp(); + UnaryExpression(); + } + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + {if (true) throw (RuntimeException)jjte000;} + } + if (jjte000 instanceof ParseException) { + {if (true) throw (ParseException)jjte000;} + } + {if (true) throw (Error)jjte000;} + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } + } + +///////////////////////////////////////////////////// +// Additive Operators +///////////////////////////////////////////////////// + final public void AddOp() throws ParseException { + /*@bgen(jjtree) AddOp */ + ASTAddOp jjtn000 = new ASTAddOp(this, JJTADDOP); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); + try { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case PLUS: + jj_consume_token(PLUS); + break; + case MINUS: + jj_consume_token(MINUS); + break; + default: + jj_la1[33] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } + } + + final public void AdditiveExpression() throws ParseException { + /*@bgen(jjtree) AdditiveExpression */ + ASTAdditiveExpression jjtn000 = new ASTAdditiveExpression(this, JJTADDITIVEEXPRESSION); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); + try { + MultiplicativeExpression(); + label_8: + while (true) { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case PLUS: + case MINUS: + ; + break; + default: + jj_la1[34] = jj_gen; + break label_8; + } + AddOp(); + MultiplicativeExpression(); + } + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + {if (true) throw (RuntimeException)jjte000;} + } + if (jjte000 instanceof ParseException) { + {if (true) throw (ParseException)jjte000;} + } + {if (true) throw (Error)jjte000;} + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } + } + +///////////////////////////////////////////////////// +// Bitwise Shift Operators +///////////////////////////////////////////////////// + final public void ShiftOp() throws ParseException { + /*@bgen(jjtree) ShiftOp */ + ASTShiftOp jjtn000 = new ASTShiftOp(this, JJTSHIFTOP); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); + try { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case LSHIFT: + jj_consume_token(LSHIFT); + break; + case RSIGNEDSHIFT: + jj_consume_token(RSIGNEDSHIFT); + break; + case RUNSIGNEDSHIFT: + jj_consume_token(RUNSIGNEDSHIFT); + break; + default: + jj_la1[35] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } + } + + final public void ShiftExpression() throws ParseException { + /*@bgen(jjtree) ShiftExpression */ + ASTShiftExpression jjtn000 = new ASTShiftExpression(this, JJTSHIFTEXPRESSION); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); + try { + AdditiveExpression(); + label_9: + while (true) { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case LSHIFT: + case RSIGNEDSHIFT: + case RUNSIGNEDSHIFT: + ; + break; + default: + jj_la1[36] = jj_gen; + break label_9; + } + ShiftOp(); + AdditiveExpression(); + } + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + {if (true) throw (RuntimeException)jjte000;} + } + if (jjte000 instanceof ParseException) { + {if (true) throw (ParseException)jjte000;} + } + {if (true) throw (Error)jjte000;} + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } + } + +///////////////////////////////////////////////////// +// Relational Operators +///////////////////////////////////////////////////// + final public void RelOp() throws ParseException { + /*@bgen(jjtree) RelOp */ + ASTRelOp jjtn000 = new ASTRelOp(this, JJTRELOP); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); + try { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case LT: + jj_consume_token(LT); + break; + case GT: + jj_consume_token(GT); + break; + case LE: + jj_consume_token(LE); + break; + case GE: + jj_consume_token(GE); + break; + case IS: + jj_consume_token(IS); + break; + case AS: + jj_consume_token(AS); + break; + default: + jj_la1[37] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } + } + + final public void RelationalExpression() throws ParseException { + /*@bgen(jjtree) RelationalExpression */ + ASTRelationalExpression jjtn000 = new ASTRelationalExpression(this, JJTRELATIONALEXPRESSION); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); + try { + ShiftExpression(); + label_10: + while (true) { + if (jj_2_11(3)) { + ; + } else { + break label_10; + } + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case AS: + case IS: + case GT: + case LT: + case LE: + case GE: + RelOp(); + break; + case IN: + jj_consume_token(IN); + break; + case INSTANCEOF: + jj_consume_token(INSTANCEOF); + break; + default: + jj_la1[38] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + ShiftExpression(); + } + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + {if (true) throw (RuntimeException)jjte000;} + } + if (jjte000 instanceof ParseException) { + {if (true) throw (ParseException)jjte000;} + } + {if (true) throw (Error)jjte000;} + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } + } + + final public void RelationalExpressionNoIN() throws ParseException { + /*@bgen(jjtree) RelationalExpressionNoIN */ + ASTRelationalExpressionNoIN jjtn000 = new ASTRelationalExpressionNoIN(this, JJTRELATIONALEXPRESSIONNOIN); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); + try { + ShiftExpression(); + label_11: + while (true) { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case AS: + case INSTANCEOF: + case IS: + case GT: + case LT: + case LE: + case GE: + ; + break; + default: + jj_la1[39] = jj_gen; + break label_11; + } + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case AS: + case IS: + case GT: + case LT: + case LE: + case GE: + RelOp(); + break; + case INSTANCEOF: + jj_consume_token(INSTANCEOF); + break; + default: + jj_la1[40] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + ShiftExpression(); + } + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + {if (true) throw (RuntimeException)jjte000;} + } + if (jjte000 instanceof ParseException) { + {if (true) throw (ParseException)jjte000;} + } + {if (true) throw (Error)jjte000;} + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } + } + +///////////////////////////////////////////////////// +// Equality Operators +///////////////////////////////////////////////////// + final public void EqualOp() throws ParseException { + /*@bgen(jjtree) EqualOp */ + ASTEqualOp jjtn000 = new ASTEqualOp(this, JJTEQUALOP); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); + try { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case EQ: + jj_consume_token(EQ); + break; + case NE: + jj_consume_token(NE); + break; + case IDENTITYOPER: + jj_consume_token(IDENTITYOPER); + break; + case NOTIDENTITYOPER: + jj_consume_token(NOTIDENTITYOPER); + break; + default: + jj_la1[41] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } + } + + final public void EqualityExpression() throws ParseException { + /*@bgen(jjtree) EqualityExpression */ + ASTEqualityExpression jjtn000 = new ASTEqualityExpression(this, JJTEQUALITYEXPRESSION); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); + try { + RelationalExpression(); + label_12: + while (true) { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case EQ: + case NE: + case IDENTITYOPER: + case NOTIDENTITYOPER: + ; + break; + default: + jj_la1[42] = jj_gen; + break label_12; + } + EqualOp(); + RelationalExpression(); + } + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + {if (true) throw (RuntimeException)jjte000;} + } + if (jjte000 instanceof ParseException) { + {if (true) throw (ParseException)jjte000;} + } + {if (true) throw (Error)jjte000;} + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } + } + + final public void EqualityExpressionNoIN() throws ParseException { + /*@bgen(jjtree) EqualityExpressionNoIN */ + ASTEqualityExpressionNoIN jjtn000 = new ASTEqualityExpressionNoIN(this, JJTEQUALITYEXPRESSIONNOIN); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); + try { + RelationalExpressionNoIN(); + label_13: + while (true) { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case EQ: + case NE: + case IDENTITYOPER: + case NOTIDENTITYOPER: + ; + break; + default: + jj_la1[43] = jj_gen; + break label_13; + } + EqualOp(); + RelationalExpressionNoIN(); + } + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + {if (true) throw (RuntimeException)jjte000;} + } + if (jjte000 instanceof ParseException) { + {if (true) throw (ParseException)jjte000;} + } + {if (true) throw (Error)jjte000;} + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } + } + +///////////////////////////////////////////////////// +// Binary Bitwise Operators +///////////////////////////////////////////////////// + final public void BitwiseANDOp() throws ParseException { + /*@bgen(jjtree) BitwiseANDOp */ + ASTBitwiseANDOp jjtn000 = new ASTBitwiseANDOp(this, JJTBITWISEANDOP); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); + try { + jj_consume_token(BIT_AND); + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } + } + + final public void BitwiseANDExpression() throws ParseException { + /*@bgen(jjtree) BitwiseANDExpression */ + ASTBitwiseANDExpression jjtn000 = new ASTBitwiseANDExpression(this, JJTBITWISEANDEXPRESSION); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); + try { + EqualityExpression(); + label_14: + while (true) { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case BIT_AND: + ; + break; + default: + jj_la1[44] = jj_gen; + break label_14; + } + BitwiseANDOp(); + EqualityExpression(); + } + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + {if (true) throw (RuntimeException)jjte000;} + } + if (jjte000 instanceof ParseException) { + {if (true) throw (ParseException)jjte000;} + } + {if (true) throw (Error)jjte000;} + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } + } + + final public void BitwiseANDExpressionNoIN() throws ParseException { + /*@bgen(jjtree) BitwiseANDExpressionNoIN */ + ASTBitwiseANDExpressionNoIN jjtn000 = new ASTBitwiseANDExpressionNoIN(this, JJTBITWISEANDEXPRESSIONNOIN); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); + try { + EqualityExpressionNoIN(); + label_15: + while (true) { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case BIT_AND: + ; + break; + default: + jj_la1[45] = jj_gen; + break label_15; + } + BitwiseANDOp(); + EqualityExpressionNoIN(); + } + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + {if (true) throw (RuntimeException)jjte000;} + } + if (jjte000 instanceof ParseException) { + {if (true) throw (ParseException)jjte000;} + } + {if (true) throw (Error)jjte000;} + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } + } + + final public void BitwiseXOROp() throws ParseException { + /*@bgen(jjtree) BitwiseXOROp */ + ASTBitwiseXOROp jjtn000 = new ASTBitwiseXOROp(this, JJTBITWISEXOROP); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); + try { + jj_consume_token(XOR); + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } + } + + final public void BitwiseXORExpression() throws ParseException { + /*@bgen(jjtree) BitwiseXORExpression */ + ASTBitwiseXORExpression jjtn000 = new ASTBitwiseXORExpression(this, JJTBITWISEXOREXPRESSION); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); + try { + BitwiseANDExpression(); + label_16: + while (true) { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case XOR: + ; + break; + default: + jj_la1[46] = jj_gen; + break label_16; + } + BitwiseXOROp(); + BitwiseANDExpression(); + } + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + {if (true) throw (RuntimeException)jjte000;} + } + if (jjte000 instanceof ParseException) { + {if (true) throw (ParseException)jjte000;} + } + {if (true) throw (Error)jjte000;} + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } + } + + final public void BitwiseXORExpressionNoIN() throws ParseException { + /*@bgen(jjtree) BitwiseXORExpressionNoIN */ + ASTBitwiseXORExpressionNoIN jjtn000 = new ASTBitwiseXORExpressionNoIN(this, JJTBITWISEXOREXPRESSIONNOIN); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); + try { + BitwiseANDExpressionNoIN(); + label_17: + while (true) { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case XOR: + ; + break; + default: + jj_la1[47] = jj_gen; + break label_17; + } + BitwiseXOROp(); + BitwiseANDExpressionNoIN(); + } + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + {if (true) throw (RuntimeException)jjte000;} + } + if (jjte000 instanceof ParseException) { + {if (true) throw (ParseException)jjte000;} + } + {if (true) throw (Error)jjte000;} + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } + } + + final public void BitwiseOROp() throws ParseException { + /*@bgen(jjtree) BitwiseOROp */ + ASTBitwiseOROp jjtn000 = new ASTBitwiseOROp(this, JJTBITWISEOROP); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); + try { + jj_consume_token(BIT_OR); + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } + } + + final public void BitwiseORExpression() throws ParseException { + /*@bgen(jjtree) BitwiseORExpression */ + ASTBitwiseORExpression jjtn000 = new ASTBitwiseORExpression(this, JJTBITWISEOREXPRESSION); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); + try { + BitwiseXORExpression(); + label_18: + while (true) { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case BIT_OR: + ; + break; + default: + jj_la1[48] = jj_gen; + break label_18; + } + BitwiseOROp(); + BitwiseXORExpression(); + } + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + {if (true) throw (RuntimeException)jjte000;} + } + if (jjte000 instanceof ParseException) { + {if (true) throw (ParseException)jjte000;} + } + {if (true) throw (Error)jjte000;} + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } + } + + final public void BitwiseORExpressionNoIN() throws ParseException { + /*@bgen(jjtree) BitwiseORExpressionNoIN */ + ASTBitwiseORExpressionNoIN jjtn000 = new ASTBitwiseORExpressionNoIN(this, JJTBITWISEOREXPRESSIONNOIN); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); + try { + BitwiseXORExpressionNoIN(); + label_19: + while (true) { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case BIT_OR: + ; + break; + default: + jj_la1[49] = jj_gen; + break label_19; + } + BitwiseOROp(); + BitwiseXORExpressionNoIN(); + } + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + {if (true) throw (RuntimeException)jjte000;} + } + if (jjte000 instanceof ParseException) { + {if (true) throw (ParseException)jjte000;} + } + {if (true) throw (Error)jjte000;} + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } + } + +///////////////////////////////////////////////////// +// Binary Logical Operators +///////////////////////////////////////////////////// + final public void LogicalANDExpression() throws ParseException { + /*@bgen(jjtree) LogicalANDExpression */ + ASTLogicalANDExpression jjtn000 = new ASTLogicalANDExpression(this, JJTLOGICALANDEXPRESSION); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); + try { + BitwiseORExpression(); + label_20: + while (true) { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case SC_AND: + ; + break; + default: + jj_la1[50] = jj_gen; + break label_20; + } + jj_consume_token(SC_AND); + BitwiseORExpression(); + } + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + {if (true) throw (RuntimeException)jjte000;} + } + if (jjte000 instanceof ParseException) { + {if (true) throw (ParseException)jjte000;} + } + {if (true) throw (Error)jjte000;} + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } + } + + final public void LogicalANDExpressionNoIN() throws ParseException { + /*@bgen(jjtree) LogicalANDExpressionNoIN */ + ASTLogicalANDExpressionNoIN jjtn000 = new ASTLogicalANDExpressionNoIN(this, JJTLOGICALANDEXPRESSIONNOIN); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); + try { + BitwiseORExpressionNoIN(); + label_21: + while (true) { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case SC_AND: + ; + break; + default: + jj_la1[51] = jj_gen; + break label_21; + } + jj_consume_token(SC_AND); + BitwiseORExpressionNoIN(); + } + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + {if (true) throw (RuntimeException)jjte000;} + } + if (jjte000 instanceof ParseException) { + {if (true) throw (ParseException)jjte000;} + } + {if (true) throw (Error)jjte000;} + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } + } + + final public void LogicalORExpression() throws ParseException { + /*@bgen(jjtree) LogicalORExpression */ + ASTLogicalORExpression jjtn000 = new ASTLogicalORExpression(this, JJTLOGICALOREXPRESSION); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); + try { + LogicalANDExpression(); + label_22: + while (true) { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case SC_OR: + ; + break; + default: + jj_la1[52] = jj_gen; + break label_22; + } + jj_consume_token(SC_OR); + LogicalANDExpression(); + } + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + {if (true) throw (RuntimeException)jjte000;} + } + if (jjte000 instanceof ParseException) { + {if (true) throw (ParseException)jjte000;} + } + {if (true) throw (Error)jjte000;} + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } + } + + final public void LogicalORExpressionNoIN() throws ParseException { + /*@bgen(jjtree) LogicalORExpressionNoIN */ + ASTLogicalORExpressionNoIN jjtn000 = new ASTLogicalORExpressionNoIN(this, JJTLOGICALOREXPRESSIONNOIN); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); + try { + LogicalANDExpressionNoIN(); + label_23: + while (true) { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case SC_OR: + ; + break; + default: + jj_la1[53] = jj_gen; + break label_23; + } + jj_consume_token(SC_OR); + LogicalANDExpressionNoIN(); + } + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + {if (true) throw (RuntimeException)jjte000;} + } + if (jjte000 instanceof ParseException) { + {if (true) throw (ParseException)jjte000;} + } + {if (true) throw (Error)jjte000;} + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } + } + +///////////////////////////////////////////////////// +// Conditional Operators +///////////////////////////////////////////////////// + final public void ConditionalExpression() throws ParseException { + /*@bgen(jjtree) ConditionalExpression */ + ASTConditionalExpression jjtn000 = new ASTConditionalExpression(this, JJTCONDITIONALEXPRESSION); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); + try { + LogicalORExpression(); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case HOOK: + jj_consume_token(HOOK); + AssignmentExpression(); + jj_consume_token(COLON); + AssignmentExpression(); + break; + default: + jj_la1[54] = jj_gen; + ; + } + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + {if (true) throw (RuntimeException)jjte000;} + } + if (jjte000 instanceof ParseException) { + {if (true) throw (ParseException)jjte000;} + } + {if (true) throw (Error)jjte000;} + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } + } + + final public void ConditionalExpressionNoIN() throws ParseException { + /*@bgen(jjtree) ConditionalExpressionNoIN */ + ASTConditionalExpressionNoIN jjtn000 = new ASTConditionalExpressionNoIN(this, JJTCONDITIONALEXPRESSIONNOIN); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); + try { + LogicalORExpressionNoIN(); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case HOOK: + jj_consume_token(HOOK); + AssignmentExpressionNoIN(); + jj_consume_token(COLON); + AssignmentExpressionNoIN(); + break; + default: + jj_la1[55] = jj_gen; + ; + } + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + {if (true) throw (RuntimeException)jjte000;} + } + if (jjte000 instanceof ParseException) { + {if (true) throw (ParseException)jjte000;} + } + {if (true) throw (Error)jjte000;} + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } + } + + final public void NonAssignmentExpression() throws ParseException { + /*@bgen(jjtree) NonAssignmentExpression */ + ASTNonAssignmentExpression jjtn000 = new ASTNonAssignmentExpression(this, JJTNONASSIGNMENTEXPRESSION); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); + try { + LogicalORExpression(); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case HOOK: + jj_consume_token(HOOK); + NonAssignmentExpression(); + jj_consume_token(COLON); + NonAssignmentExpression(); + break; + default: + jj_la1[56] = jj_gen; + ; + } + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + {if (true) throw (RuntimeException)jjte000;} + } + if (jjte000 instanceof ParseException) { + {if (true) throw (ParseException)jjte000;} + } + {if (true) throw (Error)jjte000;} + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } + } + + final public void NonAssignmentExpressionNoIN() throws ParseException { + /*@bgen(jjtree) NonAssignmentExpressionNoIN */ + ASTNonAssignmentExpressionNoIN jjtn000 = new ASTNonAssignmentExpressionNoIN(this, JJTNONASSIGNMENTEXPRESSIONNOIN); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); + try { + LogicalORExpressionNoIN(); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case HOOK: + jj_consume_token(HOOK); + NonAssignmentExpressionNoIN(); + jj_consume_token(COLON); + NonAssignmentExpressionNoIN(); + break; + default: + jj_la1[57] = jj_gen; + ; + } + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + {if (true) throw (RuntimeException)jjte000;} + } + if (jjte000 instanceof ParseException) { + {if (true) throw (ParseException)jjte000;} + } + {if (true) throw (Error)jjte000;} + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } + } + +///////////////////////////////////////////////////// +// Assignment Operators +///////////////////////////////////////////////////// + final public void AssignementOperator() throws ParseException { + /*@bgen(jjtree) AssignementOperator */ + ASTAssignementOperator jjtn000 = new ASTAssignementOperator(this, JJTASSIGNEMENTOPERATOR); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); + try { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case ASSIGN: + jj_consume_token(ASSIGN); + break; + case STARASSIGN: + jj_consume_token(STARASSIGN); + break; + case SLASHASSIGN: + jj_consume_token(SLASHASSIGN); + break; + case REMASSIGN: + jj_consume_token(REMASSIGN); + break; + case PLUSASSIGN: + jj_consume_token(PLUSASSIGN); + break; + case MINUSASSIGN: + jj_consume_token(MINUSASSIGN); + break; + case LSHIFTASSIGN: + jj_consume_token(LSHIFTASSIGN); + break; + case RSIGNEDSHIFTASSIGN: + jj_consume_token(RSIGNEDSHIFTASSIGN); + break; + case RUNSIGNEDSHIFTASSIGN: + jj_consume_token(RUNSIGNEDSHIFTASSIGN); + break; + case ANDASSIGN: + jj_consume_token(ANDASSIGN); + break; + case XORASSIGN: + jj_consume_token(XORASSIGN); + break; + case ORASSIGN: + jj_consume_token(ORASSIGN); + break; + case SC_ANDASSIGN: + jj_consume_token(SC_ANDASSIGN); + break; + case SC_XORASSIGN: + jj_consume_token(SC_XORASSIGN); + break; + case SC_ORASSIGN: + jj_consume_token(SC_ORASSIGN); + break; + default: + jj_la1[58] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } + } + + final public void AssignmentExpression() throws ParseException { + /*@bgen(jjtree) AssignmentExpression */ + ASTAssignmentExpression jjtn000 = new ASTAssignmentExpression(this, JJTASSIGNMENTEXPRESSION); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); + try { + ConditionalExpression(); + if (jj_2_12(2)) { + AssignementOperator(); + AssignmentExpression(); + } else { + ; + } + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + {if (true) throw (RuntimeException)jjte000;} + } + if (jjte000 instanceof ParseException) { + {if (true) throw (ParseException)jjte000;} + } + {if (true) throw (Error)jjte000;} + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } + } + + final public void AssignmentExpressionNoIN() throws ParseException { + /*@bgen(jjtree) AssignmentExpressionNoIN */ + ASTAssignmentExpressionNoIN jjtn000 = new ASTAssignmentExpressionNoIN(this, JJTASSIGNMENTEXPRESSIONNOIN); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); + try { + ConditionalExpressionNoIN(); + if (jj_2_13(2)) { + AssignementOperator(); + AssignmentExpressionNoIN(); + } else { + ; + } + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + {if (true) throw (RuntimeException)jjte000;} + } + if (jjte000 instanceof ParseException) { + {if (true) throw (ParseException)jjte000;} + } + {if (true) throw (Error)jjte000;} + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } + } + +///////////////////////////////////////////////////// +// Comma Expressions +///////////////////////////////////////////////////// + final public void ListExpression() throws ParseException { + /*@bgen(jjtree) ListExpression */ + ASTListExpression jjtn000 = new ASTListExpression(this, JJTLISTEXPRESSION); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); + try { + AssignmentExpression(); + label_24: + while (true) { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case COMMA: + ; + break; + default: + jj_la1[59] = jj_gen; + break label_24; + } + jj_consume_token(COMMA); + AssignmentExpression(); + } + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + {if (true) throw (RuntimeException)jjte000;} + } + if (jjte000 instanceof ParseException) { + {if (true) throw (ParseException)jjte000;} + } + {if (true) throw (Error)jjte000;} + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } + } + + final public void ListExpressionNoIN() throws ParseException { + /*@bgen(jjtree) ListExpressionNoIN */ + ASTListExpressionNoIN jjtn000 = new ASTListExpressionNoIN(this, JJTLISTEXPRESSIONNOIN); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); + try { + AssignmentExpressionNoIN(); + label_25: + while (true) { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case COMMA: + ; + break; + default: + jj_la1[60] = jj_gen; + break label_25; + } + jj_consume_token(COMMA); + AssignmentExpressionNoIN(); + } + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + {if (true) throw (RuntimeException)jjte000;} + } + if (jjte000 instanceof ParseException) { + {if (true) throw (ParseException)jjte000;} + } + {if (true) throw (Error)jjte000;} + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } + } + +///////////////////////////////////////////////////// +// Type Expressions +///////////////////////////////////////////////////// + final public void TypeExpression() throws ParseException { + /*@bgen(jjtree) TypeExpression */ + ASTTypeExpression jjtn000 = new ASTTypeExpression(this, JJTTYPEEXPRESSION); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); + try { + NonAssignmentExpression(); + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + {if (true) throw (RuntimeException)jjte000;} + } + if (jjte000 instanceof ParseException) { + {if (true) throw (ParseException)jjte000;} + } + {if (true) throw (Error)jjte000;} + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } + } + + final public void TypeExpressionNoIN() throws ParseException { + /*@bgen(jjtree) TypeExpressionNoIN */ + ASTTypeExpressionNoIN jjtn000 = new ASTTypeExpressionNoIN(this, JJTTYPEEXPRESSIONNOIN); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); + try { + NonAssignmentExpressionNoIN(); + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + {if (true) throw (RuntimeException)jjte000;} + } + if (jjte000 instanceof ParseException) { + {if (true) throw (ParseException)jjte000;} + } + {if (true) throw (Error)jjte000;} + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } + } + + final public void TypeExpressionList() throws ParseException { + /*@bgen(jjtree) TypeExpressionList */ + ASTTypeExpressionList jjtn000 = new ASTTypeExpressionList(this, JJTTYPEEXPRESSIONLIST); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); + try { + NonAssignmentExpression(); + label_26: + while (true) { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case COMMA: + ; + break; + default: + jj_la1[61] = jj_gen; + break label_26; + } + jj_consume_token(COMMA); + NonAssignmentExpression(); + } + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + {if (true) throw (RuntimeException)jjte000;} + } + if (jjte000 instanceof ParseException) { + {if (true) throw (ParseException)jjte000;} + } + {if (true) throw (Error)jjte000;} + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } + } + +///////////////////////////////////////////////////// +// Staements (abbrev, noShortIf, full) +///////////////////////////////////////////////////// + final public void Statement() throws ParseException { + /*@bgen(jjtree) Statement */ + ASTStatement jjtn000 = new ASTStatement(this, JJTSTATEMENT); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); + try { + if (jj_2_14(3)) { + ExpressionStatement(); + Sc(); + } else { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case SUPER: + SuperStatement(); + Sc(); + break; + case LBRACE: + Block(); + break; + case GET: + case INCLUDE: + case SET: + case IDENTIFIER: + LabeledStatement(); + break; + case IF: + IfStatement(); + break; + case SWITCH: + SwitchStatement(); + break; + case DO: + DoStatement(); + Sc(); + break; + case WHILE: + WhileStatement(); + break; [... 6470 lines stripped ...]