incubator-adffaces-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From mat...@apache.org
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 GMT
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 ...]


Mime
View raw message