0001 /* Generated By:JJTree&JavaCC: Do not edit this line. JSParser.java */
0002 package org.descripter.js.parse;
0003 
0004 public class JSParser/*@bgen(jjtree)*/implements JSParserTreeConstants, JSParserConstants {/*@bgen(jjtree)*/
0005   protected JJTJSParserState jjtree = new JJTJSParserState();void jjtreeOpenNodeScope(Node n) {
0006                 ((AbstractNode)n).firstToken = getToken(1);
0007         }
0008 
0009         void jjtreeCloseNodeScope(Node n) {
0010                 ((AbstractNode)n).lastToken = getToken(0);
0011         }
0012 
0013 /* ECMA-262 5.1 Edition / June 2011 - Section 7.8: Literals */
0014   final public void Literal() throws ParseException {
0015  /*@bgen(jjtree) Literal */
0016         ECMALiteral jjtn000 = new ECMALiteral(this, JJTLITERAL);
0017         boolean jjtc000 = true;
0018         jjtree.openNodeScope(jjtn000);
0019         jjtreeOpenNodeScope(jjtn000);Token t;
0020     try {
0021       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
0022       case DECIMAL_LITERAL:
0023         t = jj_consume_token(DECIMAL_LITERAL);
0024         break;
0025       case HEX_INTEGER_LITERAL:
0026         t = jj_consume_token(HEX_INTEGER_LITERAL);
0027         break;
0028       case STRING_LITERAL:
0029         t = jj_consume_token(STRING_LITERAL);
0030         break;
0031       case BOOLEAN_LITERAL:
0032         t = jj_consume_token(BOOLEAN_LITERAL);
0033         break;
0034       case NULL_LITERAL:
0035         t = jj_consume_token(NULL_LITERAL);
0036         break;
0037       case REGULAR_EXPRESSION_LITERAL:
0038         t = jj_consume_token(REGULAR_EXPRESSION_LITERAL);
0039         break;
0040       default:
0041         jj_la1[0] = jj_gen;
0042         jj_consume_token(-1);
0043         throw new ParseException();
0044       }
0045           jjtree.closeNodeScope(jjtn000, true);
0046           jjtc000 = false;
0047           jjtreeCloseNodeScope(jjtn000);
0048                 jjtn000.jjtSetValue(t.image);
0049     } finally {
0050   if (jjtc000) {
0051     jjtree.closeNodeScope(jjtn000, true);
0052     jjtreeCloseNodeScope(jjtn000);
0053   }
0054     }
0055   }
0056 
0057 /* ECMA-262 5.1 Edition / June 2011 - Section 11.1: Primary Expressions */
0058   final public void PrimaryExpression() throws ParseException {
0059     if (jj_2_1(2147483647)) {
0060                             ECMAThisReference jjtn001 = new ECMAThisReference(this, JJTTHISREFERENCE);
0061                             boolean jjtc001 = true;
0062                             jjtree.openNodeScope(jjtn001);
0063                             jjtreeOpenNodeScope(jjtn001);
0064       try {
0065         jj_consume_token(THIS);
0066       } finally {
0067                             if (jjtc001) {
0068                               jjtree.closeNodeScope(jjtn001, true);
0069                               jjtreeCloseNodeScope(jjtn001);
0070                             }
0071       }
0072     } else if (jj_2_2(2147483647)) {
0073       ObjectLiteral();
0074     } else if (jj_2_3(2147483647)) {
0075                          ECMAGroup jjtn002 = new ECMAGroup(this, JJTGROUP);
0076                          boolean jjtc002 = true;
0077                          jjtree.openNodeScope(jjtn002);
0078                          jjtreeOpenNodeScope(jjtn002);
0079       try {
0080         jj_consume_token(LPAREN);
0081         Expression();
0082         jj_consume_token(RPAREN);
0083       } catch (Throwable jjte002) {
0084                          if (jjtc002) {
0085                            jjtree.clearNodeScope(jjtn002);
0086                            jjtc002 = false;
0087                          } else {
0088                            jjtree.popNode();
0089                          }
0090                          if (jjte002 instanceof RuntimeException) {
0091                            {if (true) throw (RuntimeException)jjte002;}
0092                          }
0093                          if (jjte002 instanceof ParseException) {
0094                            {if (true) throw (ParseException)jjte002;}
0095                          }
0096                          {if (true) throw (Error)jjte002;}
0097       } finally {
0098                          if (jjtc002) {
0099                            jjtree.closeNodeScope(jjtn002, true);
0100                            jjtreeCloseNodeScope(jjtn002);
0101                          }
0102       }
0103     } else if (jj_2_4(2147483647)) {
0104       Identifier();
0105     } else if (jj_2_5(2147483647)) {
0106       ArrayLiteral();
0107     } else if (jj_2_6(2)) {
0108       Literal();
0109     } else {
0110       jj_consume_token(-1);
0111       throw new ParseException();
0112     }
0113   }
0114 
0115 /* ECMA-262 5.1 Edition / June 2011 - Section 11.1.4: Array Initialiser */
0116   final public void ArrayLiteral() throws ParseException {
0117  /*@bgen(jjtree) ArrayLiteral */
0118   ECMAArrayLiteral jjtn000 = new ECMAArrayLiteral(this, JJTARRAYLITERAL);
0119   boolean jjtc000 = true;
0120   jjtree.openNodeScope(jjtn000);
0121   jjtreeOpenNodeScope(jjtn000);
0122     try {
0123       jj_consume_token(LBRACKET);
0124       if (jj_2_7(2)) {
0125         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
0126         case COMMA:
0127           Elision();
0128           break;
0129         default:
0130           jj_la1[1] = jj_gen;
0131           ;
0132         }
0133         jj_consume_token(RBRACKET);
0134       } else if (jj_2_8(2147483647)) {
0135         ElementList();
0136         Elision();
0137         jj_consume_token(RBRACKET);
0138       } else {
0139         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
0140         case TYPEOF:
0141         case NEW:
0142         case VOID:
0143         case FUNCTION:
0144         case THIS:
0145         case DELETE:
0146         case LBRACE:
0147         case LPAREN:
0148         case LBRACKET:
0149         case RBRACKET:
0150         case COMMA:
0151         case PLUS:
0152         case MINUS:
0153         case INC:
0154         case DEC:
0155         case BNOT:
0156         case NOT:
0157         case NULL_LITERAL:
0158         case BOOLEAN_LITERAL:
0159         case DECIMAL_LITERAL:
0160         case HEX_INTEGER_LITERAL:
0161         case STRING_LITERAL:
0162         case IDENTIFIER_NAME:
0163         case REGULAR_EXPRESSION_LITERAL:
0164           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
0165           case TYPEOF:
0166           case NEW:
0167           case VOID:
0168           case FUNCTION:
0169           case THIS:
0170           case DELETE:
0171           case LBRACE:
0172           case LPAREN:
0173           case LBRACKET:
0174           case COMMA:
0175           case PLUS:
0176           case MINUS:
0177           case INC:
0178           case DEC:
0179           case BNOT:
0180           case NOT:
0181           case NULL_LITERAL:
0182           case BOOLEAN_LITERAL:
0183           case DECIMAL_LITERAL:
0184           case HEX_INTEGER_LITERAL:
0185           case STRING_LITERAL:
0186           case IDENTIFIER_NAME:
0187           case REGULAR_EXPRESSION_LITERAL:
0188             ElementList();
0189             break;
0190           default:
0191             jj_la1[2] = jj_gen;
0192             ;
0193           }
0194           jj_consume_token(RBRACKET);
0195           break;
0196         default:
0197           jj_la1[3] = jj_gen;
0198           jj_consume_token(-1);
0199           throw new ParseException();
0200         }
0201       }
0202     } catch (Throwable jjte000) {
0203           if (jjtc000) {
0204             jjtree.clearNodeScope(jjtn000);
0205             jjtc000 = false;
0206           } else {
0207             jjtree.popNode();
0208           }
0209           if (jjte000 instanceof RuntimeException) {
0210             {if (true) throw (RuntimeException)jjte000;}
0211           }
0212           if (jjte000 instanceof ParseException) {
0213             {if (true) throw (ParseException)jjte000;}
0214           }
0215           {if (true) throw (Error)jjte000;}
0216     } finally {
0217           if (jjtc000) {
0218             jjtree.closeNodeScope(jjtn000, true);
0219             jjtreeCloseNodeScope(jjtn000);
0220           }
0221     }
0222   }
0223 
0224   final public void ElementList() throws ParseException {
0225     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
0226     case COMMA:
0227       Elision();
0228       break;
0229     default:
0230       jj_la1[4] = jj_gen;
0231       ;
0232     }
0233     AssignmentExpression();
0234     label_1:
0235     while (true) {
0236       if (jj_2_9(2147483647)) {
0237         ;
0238       } else {
0239         break label_1;
0240       }
0241       Elision();
0242       AssignmentExpression();
0243     }
0244   }
0245 
0246   final public void Elision() throws ParseException {
0247     label_2:
0248     while (true) {
0249       jj_consume_token(COMMA);
0250       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
0251       case COMMA:
0252         ;
0253         break;
0254       default:
0255         jj_la1[5] = jj_gen;
0256         break label_2;
0257       }
0258     }
0259   }
0260 
0261 /* ECMA-262 5.1 Edition / June 2011 - Section 11.1.5: Object Initialiser */
0262   final public void ObjectLiteral() throws ParseException {
0263  /*@bgen(jjtree) ObjectLiteral */
0264   ECMAObjectLiteral jjtn000 = new ECMAObjectLiteral(this, JJTOBJECTLITERAL);
0265   boolean jjtc000 = true;
0266   jjtree.openNodeScope(jjtn000);
0267   jjtreeOpenNodeScope(jjtn000);
0268     try {
0269       jj_consume_token(LBRACE);
0270       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
0271       case DECIMAL_LITERAL:
0272       case STRING_LITERAL:
0273       case IDENTIFIER_NAME:
0274         PropertyNameAndValueList();
0275         break;
0276       default:
0277         jj_la1[6] = jj_gen;
0278         ;
0279       }
0280       jj_consume_token(RBRACE);
0281     } catch (Throwable jjte000) {
0282           if (jjtc000) {
0283             jjtree.clearNodeScope(jjtn000);
0284             jjtc000 = false;
0285           } else {
0286             jjtree.popNode();
0287           }
0288           if (jjte000 instanceof RuntimeException) {
0289             {if (true) throw (RuntimeException)jjte000;}
0290           }
0291           if (jjte000 instanceof ParseException) {
0292             {if (true) throw (ParseException)jjte000;}
0293           }
0294           {if (true) throw (Error)jjte000;}
0295     } finally {
0296           if (jjtc000) {
0297             jjtree.closeNodeScope(jjtn000, true);
0298             jjtreeCloseNodeScope(jjtn000);
0299           }
0300     }
0301   }
0302 
0303   final public void PropertyNameAndValueList() throws ParseException {
0304     PropertyAssignment();
0305     label_3:
0306     while (true) {
0307       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
0308       case COMMA:
0309         ;
0310         break;
0311       default:
0312         jj_la1[7] = jj_gen;
0313         break label_3;
0314       }
0315       if (jj_2_10(2147483647)) {
0316         jj_consume_token(COMMA);
0317         PropertyAssignment();
0318       } else {
0319         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
0320         case COMMA:
0321           jj_consume_token(COMMA);
0322           break;
0323         default:
0324           jj_la1[8] = jj_gen;
0325           jj_consume_token(-1);
0326           throw new ParseException();
0327         }
0328       }
0329     }
0330   }
0331 
0332   final public void PropertyAssignment() throws ParseException {
0333  /*@bgen(jjtree) PropertyAssignment */
0334   ECMAPropertyAssignment jjtn000 = new ECMAPropertyAssignment(this, JJTPROPERTYASSIGNMENT);
0335   boolean jjtc000 = true;
0336   jjtree.openNodeScope(jjtn000);
0337   jjtreeOpenNodeScope(jjtn000);
0338     try {
0339       PropertyName();
0340       jj_consume_token(COLON);
0341       AssignmentExpression();
0342     } catch (Throwable jjte000) {
0343           if (jjtc000) {
0344             jjtree.clearNodeScope(jjtn000);
0345             jjtc000 = false;
0346           } else {
0347             jjtree.popNode();
0348           }
0349           if (jjte000 instanceof RuntimeException) {
0350             {if (true) throw (RuntimeException)jjte000;}
0351           }
0352           if (jjte000 instanceof ParseException) {
0353             {if (true) throw (ParseException)jjte000;}
0354           }
0355           {if (true) throw (Error)jjte000;}
0356     } finally {
0357           if (jjtc000) {
0358             jjtree.closeNodeScope(jjtn000, true);
0359             jjtreeCloseNodeScope(jjtn000);
0360           }
0361     }
0362   }
0363 
0364   final public void PropertyName() throws ParseException {
0365     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
0366     case IDENTIFIER_NAME:
0367       Identifier();
0368       break;
0369     case STRING_LITERAL:
0370           ECMALiteral jjtn001 = new ECMALiteral(this, JJTLITERAL);
0371           boolean jjtc001 = true;
0372           jjtree.openNodeScope(jjtn001);
0373           jjtreeOpenNodeScope(jjtn001);
0374       try {
0375         jj_consume_token(STRING_LITERAL);
0376       } finally {
0377           if (jjtc001) {
0378             jjtree.closeNodeScope(jjtn001, true);
0379             jjtreeCloseNodeScope(jjtn001);
0380           }
0381       }
0382       break;
0383     case DECIMAL_LITERAL:
0384           ECMALiteral jjtn002 = new ECMALiteral(this, JJTLITERAL);
0385           boolean jjtc002 = true;
0386           jjtree.openNodeScope(jjtn002);
0387           jjtreeOpenNodeScope(jjtn002);
0388       try {
0389         jj_consume_token(DECIMAL_LITERAL);
0390       } finally {
0391           if (jjtc002) {
0392             jjtree.closeNodeScope(jjtn002, true);
0393             jjtreeCloseNodeScope(jjtn002);
0394           }
0395       }
0396       break;
0397     default:
0398       jj_la1[9] = jj_gen;
0399       jj_consume_token(-1);
0400       throw new ParseException();
0401     }
0402   }
0403 
0404 /* ECMA-262 5.1 Edition / June 2011 - Section 11.2: Left-Hand-Side Expressions */
0405   final public void MemberExpression() throws ParseException {
0406           ECMAAccess jjtn002 = new ECMAAccess(this, JJTACCESS);
0407           boolean jjtc002 = true;
0408           jjtree.openNodeScope(jjtn002);
0409           jjtreeOpenNodeScope(jjtn002);
0410     try {
0411       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
0412       case THIS:
0413       case LBRACE:
0414       case LPAREN:
0415       case LBRACKET:
0416       case NULL_LITERAL:
0417       case BOOLEAN_LITERAL:
0418       case DECIMAL_LITERAL:
0419       case HEX_INTEGER_LITERAL:
0420       case STRING_LITERAL:
0421       case IDENTIFIER_NAME:
0422       case REGULAR_EXPRESSION_LITERAL:
0423         PrimaryExpression();
0424         break;
0425       case FUNCTION:
0426         FunctionExpression();
0427         break;
0428       case NEW:
0429                           ECMANewOperation jjtn001 = new ECMANewOperation(this, JJTNEWOPERATION);
0430                           boolean jjtc001 = true;
0431                           jjtree.openNodeScope(jjtn001);
0432                           jjtreeOpenNodeScope(jjtn001);
0433         try {
0434           jj_consume_token(NEW);
0435           MemberExpression();
0436           Arguments();
0437         } catch (Throwable jjte001) {
0438                           if (jjtc001) {
0439                             jjtree.clearNodeScope(jjtn001);
0440                             jjtc001 = false;
0441                           } else {
0442                             jjtree.popNode();
0443                           }
0444                           if (jjte001 instanceof RuntimeException) {
0445                             {if (true) throw (RuntimeException)jjte001;}
0446                           }
0447                           if (jjte001 instanceof ParseException) {
0448                             {if (true) throw (ParseException)jjte001;}
0449                           }
0450                           {if (true) throw (Error)jjte001;}
0451         } finally {
0452                           if (jjtc001) {
0453                             jjtree.closeNodeScope(jjtn001, true);
0454                             jjtreeCloseNodeScope(jjtn001);
0455                           }
0456         }
0457         break;
0458       default:
0459         jj_la1[10] = jj_gen;
0460         jj_consume_token(-1);
0461         throw new ParseException();
0462       }
0463       label_4:
0464       while (true) {
0465         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
0466         case LBRACKET:
0467         case DOT:
0468           ;
0469           break;
0470         default:
0471           jj_la1[11] = jj_gen;
0472           break label_4;
0473         }
0474         PropertyAccessor();
0475       }
0476     } catch (Throwable jjte002) {
0477           if (jjtc002) {
0478             jjtree.clearNodeScope(jjtn002);
0479             jjtc002 = false;
0480           } else {
0481             jjtree.popNode();
0482           }
0483           if (jjte002 instanceof RuntimeException) {
0484             {if (true) throw (RuntimeException)jjte002;}
0485           }
0486           if (jjte002 instanceof ParseException) {
0487             {if (true) throw (ParseException)jjte002;}
0488           }
0489           {if (true) throw (Error)jjte002;}
0490     } finally {
0491           if (jjtc002) {
0492             jjtree.closeNodeScope(jjtn002, jjtree.nodeArity() > 1);
0493             jjtreeCloseNodeScope(jjtn002);
0494           }
0495     }
0496   }
0497 
0498   final public void NewExpression() throws ParseException {
0499     if (jj_2_11(2147483647)) {
0500       MemberExpression();
0501     } else {
0502       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
0503       case NEW:
0504           ECMAAllocation jjtn001 = new ECMAAllocation(this, JJTALLOCATION);
0505           boolean jjtc001 = true;
0506           jjtree.openNodeScope(jjtn001);
0507           jjtreeOpenNodeScope(jjtn001);
0508         try {
0509           jj_consume_token(NEW);
0510           NewExpression();
0511         } catch (Throwable jjte001) {
0512           if (jjtc001) {
0513             jjtree.clearNodeScope(jjtn001);
0514             jjtc001 = false;
0515           } else {
0516             jjtree.popNode();
0517           }
0518           if (jjte001 instanceof RuntimeException) {
0519             {if (true) throw (RuntimeException)jjte001;}
0520           }
0521           if (jjte001 instanceof ParseException) {
0522             {if (true) throw (ParseException)jjte001;}
0523           }
0524           {if (true) throw (Error)jjte001;}
0525         } finally {
0526           if (jjtc001) {
0527             jjtree.closeNodeScope(jjtn001, true);
0528             jjtreeCloseNodeScope(jjtn001);
0529           }
0530         }
0531         break;
0532       default:
0533         jj_la1[12] = jj_gen;
0534         jj_consume_token(-1);
0535         throw new ParseException();
0536       }
0537     }
0538   }
0539 
0540   final public void PropertyAccessor() throws ParseException {
0541     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
0542     case LBRACKET:
0543           ECMAArrayAccessor jjtn001 = new ECMAArrayAccessor(this, JJTARRAYACCESSOR);
0544           boolean jjtc001 = true;
0545           jjtree.openNodeScope(jjtn001);
0546           jjtreeOpenNodeScope(jjtn001);
0547       try {
0548         jj_consume_token(LBRACKET);
0549         Expression();
0550         jj_consume_token(RBRACKET);
0551       } catch (Throwable jjte001) {
0552           if (jjtc001) {
0553             jjtree.clearNodeScope(jjtn001);
0554             jjtc001 = false;
0555           } else {
0556             jjtree.popNode();
0557           }
0558           if (jjte001 instanceof RuntimeException) {
0559             {if (true) throw (RuntimeException)jjte001;}
0560           }
0561           if (jjte001 instanceof ParseException) {
0562             {if (true) throw (ParseException)jjte001;}
0563           }
0564           {if (true) throw (Error)jjte001;}
0565       } finally {
0566           if (jjtc001) {
0567             jjtree.closeNodeScope(jjtn001, true);
0568             jjtreeCloseNodeScope(jjtn001);
0569           }
0570       }
0571       break;
0572     case DOT:
0573           ECMAMemberAccessor jjtn002 = new ECMAMemberAccessor(this, JJTMEMBERACCESSOR);
0574           boolean jjtc002 = true;
0575           jjtree.openNodeScope(jjtn002);
0576           jjtreeOpenNodeScope(jjtn002);
0577       try {
0578         jj_consume_token(DOT);
0579         Identifier();
0580       } catch (Throwable jjte002) {
0581           if (jjtc002) {
0582             jjtree.clearNodeScope(jjtn002);
0583             jjtc002 = false;
0584           } else {
0585             jjtree.popNode();
0586           }
0587           if (jjte002 instanceof RuntimeException) {
0588             {if (true) throw (RuntimeException)jjte002;}
0589           }
0590           if (jjte002 instanceof ParseException) {
0591             {if (true) throw (ParseException)jjte002;}
0592           }
0593           {if (true) throw (Error)jjte002;}
0594       } finally {
0595           if (jjtc002) {
0596             jjtree.closeNodeScope(jjtn002, true);
0597             jjtreeCloseNodeScope(jjtn002);
0598           }
0599       }
0600       break;
0601     default:
0602       jj_la1[13] = jj_gen;
0603       jj_consume_token(-1);
0604       throw new ParseException();
0605     }
0606   }
0607 
0608   final public void CallExpression() throws ParseException {
0609  /*@bgen(jjtree) #Access(> 1) */
0610   ECMAAccess jjtn000 = new ECMAAccess(this, JJTACCESS);
0611   boolean jjtc000 = true;
0612   jjtree.openNodeScope(jjtn000);
0613   jjtreeOpenNodeScope(jjtn000);
0614     try {
0615       MemberExpression();
0616       Arguments();
0617       label_5:
0618       while (true) {
0619         if (jj_2_12(2)) {
0620           ;
0621         } else {
0622           break label_5;
0623         }
0624         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
0625         case LPAREN:
0626           Arguments();
0627           break;
0628         case LBRACKET:
0629         case DOT:
0630           PropertyAccessor();
0631           break;
0632         default:
0633           jj_la1[14] = jj_gen;
0634           jj_consume_token(-1);
0635           throw new ParseException();
0636         }
0637       }
0638     } catch (Throwable jjte000) {
0639           if (jjtc000) {
0640             jjtree.clearNodeScope(jjtn000);
0641             jjtc000 = false;
0642           } else {
0643             jjtree.popNode();
0644           }
0645           if (jjte000 instanceof RuntimeException) {
0646             {if (true) throw (RuntimeException)jjte000;}
0647           }
0648           if (jjte000 instanceof ParseException) {
0649             {if (true) throw (ParseException)jjte000;}
0650           }
0651           {if (true) throw (Error)jjte000;}
0652     } finally {
0653           if (jjtc000) {
0654             jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
0655             jjtreeCloseNodeScope(jjtn000);
0656           }
0657     }
0658   }
0659 
0660   final public void Arguments() throws ParseException {
0661  /*@bgen(jjtree) Arguments */
0662   ECMAArguments jjtn000 = new ECMAArguments(this, JJTARGUMENTS);
0663   boolean jjtc000 = true;
0664   jjtree.openNodeScope(jjtn000);
0665   jjtreeOpenNodeScope(jjtn000);
0666     try {
0667       jj_consume_token(LPAREN);
0668       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
0669       case TYPEOF:
0670       case NEW:
0671       case VOID:
0672       case FUNCTION:
0673       case THIS:
0674       case DELETE:
0675       case LBRACE:
0676       case LPAREN:
0677       case LBRACKET:
0678       case PLUS:
0679       case MINUS:
0680       case INC:
0681       case DEC:
0682       case BNOT:
0683       case NOT:
0684       case NULL_LITERAL:
0685       case BOOLEAN_LITERAL:
0686       case DECIMAL_LITERAL:
0687       case HEX_INTEGER_LITERAL:
0688       case STRING_LITERAL:
0689       case IDENTIFIER_NAME:
0690       case REGULAR_EXPRESSION_LITERAL:
0691         ArgumentList();
0692         break;
0693       default:
0694         jj_la1[15] = jj_gen;
0695         ;
0696       }
0697       jj_consume_token(RPAREN);
0698     } catch (Throwable jjte000) {
0699           if (jjtc000) {
0700             jjtree.clearNodeScope(jjtn000);
0701             jjtc000 = false;
0702           } else {
0703             jjtree.popNode();
0704           }
0705           if (jjte000 instanceof RuntimeException) {
0706             {if (true) throw (RuntimeException)jjte000;}
0707           }
0708           if (jjte000 instanceof ParseException) {
0709             {if (true) throw (ParseException)jjte000;}
0710           }
0711           {if (true) throw (Error)jjte000;}
0712     } finally {
0713           if (jjtc000) {
0714             jjtree.closeNodeScope(jjtn000, true);
0715             jjtreeCloseNodeScope(jjtn000);
0716           }
0717     }
0718   }
0719 
0720   final public void ArgumentList() throws ParseException {
0721     AssignmentExpression();
0722     label_6:
0723     while (true) {
0724       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
0725       case COMMA:
0726         ;
0727         break;
0728       default:
0729         jj_la1[16] = jj_gen;
0730         break label_6;
0731       }
0732       jj_consume_token(COMMA);
0733       AssignmentExpression();
0734     }
0735   }
0736 
0737   final public void LeftHandSideExpression() throws ParseException {
0738     if (jj_2_13(2147483647)) {
0739       CallExpression();
0740     } else {
0741       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
0742       case NEW:
0743       case FUNCTION:
0744       case THIS:
0745       case LBRACE:
0746       case LPAREN:
0747       case LBRACKET:
0748       case NULL_LITERAL:
0749       case BOOLEAN_LITERAL:
0750       case DECIMAL_LITERAL:
0751       case HEX_INTEGER_LITERAL:
0752       case STRING_LITERAL:
0753       case IDENTIFIER_NAME:
0754       case REGULAR_EXPRESSION_LITERAL:
0755         NewExpression();
0756         break;
0757       default:
0758         jj_la1[17] = jj_gen;
0759         jj_consume_token(-1);
0760         throw new ParseException();
0761       }
0762     }
0763   }
0764 
0765 /* ECMA-262 5.1 Edition / June 2011 - Section 11.3 Postfix Expressions */
0766   final public void PostfixExpression() throws ParseException {
0767  /*@bgen(jjtree) #PostfixExpression(> 1) */
0768   ECMAPostfixExpression jjtn000 = new ECMAPostfixExpression(this, JJTPOSTFIXEXPRESSION);
0769   boolean jjtc000 = true;
0770   jjtree.openNodeScope(jjtn000);
0771   jjtreeOpenNodeScope(jjtn000);
0772     try {
0773       LeftHandSideExpression();
0774       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
0775       case INC:
0776       case DEC:
0777                                                   ECMAOperator jjtn001 = new ECMAOperator(this, JJTOPERATOR);
0778                                                   boolean jjtc001 = true;
0779                                                   jjtree.openNodeScope(jjtn001);
0780                                                   jjtreeOpenNodeScope(jjtn001);
0781         try {
0782           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
0783           case INC:
0784             jj_consume_token(INC);
0785             break;
0786           case DEC:
0787             jj_consume_token(DEC);
0788             break;
0789           default:
0790             jj_la1[18] = jj_gen;
0791             jj_consume_token(-1);
0792             throw new ParseException();
0793           }
0794         } finally {
0795                                                   if (jjtc001) {
0796                                                     jjtree.closeNodeScope(jjtn001, true);
0797                                                     jjtreeCloseNodeScope(jjtn001);
0798                                                   }
0799         }
0800         break;
0801       default:
0802         jj_la1[19] = jj_gen;
0803         ;
0804       }
0805     } catch (Throwable jjte000) {
0806           if (jjtc000) {
0807             jjtree.clearNodeScope(jjtn000);
0808             jjtc000 = false;
0809           } else {
0810             jjtree.popNode();
0811           }
0812           if (jjte000 instanceof RuntimeException) {
0813             {if (true) throw (RuntimeException)jjte000;}
0814           }
0815           if (jjte000 instanceof ParseException) {
0816             {if (true) throw (ParseException)jjte000;}
0817           }
0818           {if (true) throw (Error)jjte000;}
0819     } finally {
0820           if (jjtc000) {
0821             jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
0822             jjtreeCloseNodeScope(jjtn000);
0823           }
0824     }
0825   }
0826 
0827 /* ECMA-262 5.1 Edition / June 2011 - Section 11.4 Unary Operators */
0828   final public void UnaryExpression() throws ParseException {
0829  /*@bgen(jjtree) #UnaryExpression(> 1) */
0830   ECMAUnaryExpression jjtn000 = new ECMAUnaryExpression(this, JJTUNARYEXPRESSION);
0831   boolean jjtc000 = true;
0832   jjtree.openNodeScope(jjtn000);
0833   jjtreeOpenNodeScope(jjtn000);
0834     try {
0835       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
0836       case NEW:
0837       case FUNCTION:
0838       case THIS:
0839       case LBRACE:
0840       case LPAREN:
0841       case LBRACKET:
0842       case NULL_LITERAL:
0843       case BOOLEAN_LITERAL:
0844       case DECIMAL_LITERAL:
0845       case HEX_INTEGER_LITERAL:
0846       case STRING_LITERAL:
0847       case IDENTIFIER_NAME:
0848       case REGULAR_EXPRESSION_LITERAL:
0849         PostfixExpression();
0850         break;
0851       case TYPEOF:
0852       case VOID:
0853       case DELETE:
0854       case PLUS:
0855       case MINUS:
0856       case INC:
0857       case DEC:
0858       case BNOT:
0859       case NOT:
0860                   ECMAOperator jjtn001 = new ECMAOperator(this, JJTOPERATOR);
0861                   boolean jjtc001 = true;
0862                   jjtree.openNodeScope(jjtn001);
0863                   jjtreeOpenNodeScope(jjtn001);
0864         try {
0865           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
0866           case DELETE:
0867             jj_consume_token(DELETE);
0868             break;
0869           case VOID:
0870             jj_consume_token(VOID);
0871             break;
0872           case TYPEOF:
0873             jj_consume_token(TYPEOF);
0874             break;
0875           case INC:
0876             jj_consume_token(INC);
0877             break;
0878           case DEC:
0879             jj_consume_token(DEC);
0880             break;
0881           case PLUS:
0882             jj_consume_token(PLUS);
0883             break;
0884           case MINUS:
0885             jj_consume_token(MINUS);
0886             break;
0887           case NOT:
0888             jj_consume_token(NOT);
0889             break;
0890           case BNOT:
0891             jj_consume_token(BNOT);
0892             break;
0893           default:
0894             jj_la1[20] = jj_gen;
0895             jj_consume_token(-1);
0896             throw new ParseException();
0897           }
0898         } finally {
0899                   if (jjtc001) {
0900                     jjtree.closeNodeScope(jjtn001, true);
0901                     jjtreeCloseNodeScope(jjtn001);
0902                   }
0903         }
0904         UnaryExpression();
0905         break;
0906       default:
0907         jj_la1[21] = jj_gen;
0908         jj_consume_token(-1);
0909         throw new ParseException();
0910       }
0911     } catch (Throwable jjte000) {
0912           if (jjtc000) {
0913             jjtree.clearNodeScope(jjtn000);
0914             jjtc000 = false;
0915           } else {
0916             jjtree.popNode();
0917           }
0918           if (jjte000 instanceof RuntimeException) {
0919             {if (true) throw (RuntimeException)jjte000;}
0920           }
0921           if (jjte000 instanceof ParseException) {
0922             {if (true) throw (ParseException)jjte000;}
0923           }
0924           {if (true) throw (Error)jjte000;}
0925     } finally {
0926           if (jjtc000) {
0927             jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
0928             jjtreeCloseNodeScope(jjtn000);
0929           }
0930     }
0931   }
0932 
0933 /* ECMA-262 5.1 Edition / June 2011 - Section 11.5: Multiplicative Operators */
0934   final public void MultiplicativeExpression() throws ParseException {
0935  /*@bgen(jjtree) #BinaryOperation(> 1) */
0936   ECMABinaryOperation jjtn000 = new ECMABinaryOperation(this, JJTBINARYOPERATION);
0937   boolean jjtc000 = true;
0938   jjtree.openNodeScope(jjtn000);
0939   jjtreeOpenNodeScope(jjtn000);
0940     try {
0941       UnaryExpression();
0942       label_7:
0943       while (true) {
0944         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
0945         case MUL:
0946         case MOD:
0947         case DIV:
0948           ;
0949           break;
0950         default:
0951           jj_la1[22] = jj_gen;
0952           break label_7;
0953         }
0954                               ECMAOperator jjtn001 = new ECMAOperator(this, JJTOPERATOR);
0955                               boolean jjtc001 = true;
0956                               jjtree.openNodeScope(jjtn001);
0957                               jjtreeOpenNodeScope(jjtn001);
0958         try {
0959           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
0960           case MUL:
0961             jj_consume_token(MUL);
0962             break;
0963           case DIV:
0964             jj_consume_token(DIV);
0965             break;
0966           case MOD:
0967             jj_consume_token(MOD);
0968             break;
0969           default:
0970             jj_la1[23] = jj_gen;
0971             jj_consume_token(-1);
0972             throw new ParseException();
0973           }
0974         } finally {
0975                               if (jjtc001) {
0976                                 jjtree.closeNodeScope(jjtn001, true);
0977                                 jjtreeCloseNodeScope(jjtn001);
0978                               }
0979         }
0980         UnaryExpression();
0981       }
0982     } catch (Throwable jjte000) {
0983           if (jjtc000) {
0984             jjtree.clearNodeScope(jjtn000);
0985             jjtc000 = false;
0986           } else {
0987             jjtree.popNode();
0988           }
0989           if (jjte000 instanceof RuntimeException) {
0990             {if (true) throw (RuntimeException)jjte000;}
0991           }
0992           if (jjte000 instanceof ParseException) {
0993             {if (true) throw (ParseException)jjte000;}
0994           }
0995           {if (true) throw (Error)jjte000;}
0996     } finally {
0997           if (jjtc000) {
0998             jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
0999             jjtreeCloseNodeScope(jjtn000);
1000           }
1001     }
1002   }
1003 
1004 /* ECMA-262 5.1 Edition / June 2011 - Section 11.6: Additive Operators */
1005   final public void AdditiveExpression() throws ParseException {
1006  /*@bgen(jjtree) #BinaryOperation(> 1) */
1007   ECMABinaryOperation jjtn000 = new ECMABinaryOperation(this, JJTBINARYOPERATION);
1008   boolean jjtc000 = true;
1009   jjtree.openNodeScope(jjtn000);
1010   jjtreeOpenNodeScope(jjtn000);
1011     try {
1012       MultiplicativeExpression();
1013       label_8:
1014       while (true) {
1015         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1016         case PLUS:
1017         case MINUS:
1018           ;
1019           break;
1020         default:
1021           jj_la1[24] = jj_gen;
1022           break label_8;
1023         }
1024                                                     ECMAOperator jjtn001 = new ECMAOperator(this, JJTOPERATOR);
1025                                                     boolean jjtc001 = true;
1026                                                     jjtree.openNodeScope(jjtn001);
1027                                                     jjtreeOpenNodeScope(jjtn001);
1028         try {
1029           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1030           case PLUS:
1031             jj_consume_token(PLUS);
1032             break;
1033           case MINUS:
1034             jj_consume_token(MINUS);
1035             break;
1036           default:
1037             jj_la1[25] = jj_gen;
1038             jj_consume_token(-1);
1039             throw new ParseException();
1040           }
1041         } finally {
1042                                                     if (jjtc001) {
1043                                                       jjtree.closeNodeScope(jjtn001, true);
1044                                                       jjtreeCloseNodeScope(jjtn001);
1045                                                     }
1046         }
1047         MultiplicativeExpression();
1048       }
1049     } catch (Throwable jjte000) {
1050           if (jjtc000) {
1051             jjtree.clearNodeScope(jjtn000);
1052             jjtc000 = false;
1053           } else {
1054             jjtree.popNode();
1055           }
1056           if (jjte000 instanceof RuntimeException) {
1057             {if (true) throw (RuntimeException)jjte000;}
1058           }
1059           if (jjte000 instanceof ParseException) {
1060             {if (true) throw (ParseException)jjte000;}
1061           }
1062           {if (true) throw (Error)jjte000;}
1063     } finally {
1064           if (jjtc000) {
1065             jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
1066             jjtreeCloseNodeScope(jjtn000);
1067           }
1068     }
1069   }
1070 
1071 /* ECMA-262 5.1 Edition / June 2011 - Section 11.7: Bitwise Shift Operators */
1072   final public void ShiftExpression() throws ParseException {
1073  /*@bgen(jjtree) #BinaryOperation(> 1) */
1074   ECMABinaryOperation jjtn000 = new ECMABinaryOperation(this, JJTBINARYOPERATION);
1075   boolean jjtc000 = true;
1076   jjtree.openNodeScope(jjtn000);
1077   jjtreeOpenNodeScope(jjtn000);
1078     try {
1079       AdditiveExpression();
1080       label_9:
1081       while (true) {
1082         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1083         case SHL:
1084         case SHR:
1085         case SHRU:
1086           ;
1087           break;
1088         default:
1089           jj_la1[26] = jj_gen;
1090           break label_9;
1091         }
1092                                  ECMAOperator jjtn001 = new ECMAOperator(this, JJTOPERATOR);
1093                                  boolean jjtc001 = true;
1094                                  jjtree.openNodeScope(jjtn001);
1095                                  jjtreeOpenNodeScope(jjtn001);
1096         try {
1097           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1098           case SHL:
1099             jj_consume_token(SHL);
1100             break;
1101           case SHR:
1102             jj_consume_token(SHR);
1103             break;
1104           case SHRU:
1105             jj_consume_token(SHRU);
1106             break;
1107           default:
1108             jj_la1[27] = jj_gen;
1109             jj_consume_token(-1);
1110             throw new ParseException();
1111           }
1112         } finally {
1113                                  if (jjtc001) {
1114                                    jjtree.closeNodeScope(jjtn001, true);
1115                                    jjtreeCloseNodeScope(jjtn001);
1116                                  }
1117         }
1118         AdditiveExpression();
1119       }
1120     } catch (Throwable jjte000) {
1121           if (jjtc000) {
1122             jjtree.clearNodeScope(jjtn000);
1123             jjtc000 = false;
1124           } else {
1125             jjtree.popNode();
1126           }
1127           if (jjte000 instanceof RuntimeException) {
1128             {if (true) throw (RuntimeException)jjte000;}
1129           }
1130           if (jjte000 instanceof ParseException) {
1131             {if (true) throw (ParseException)jjte000;}
1132           }
1133           {if (true) throw (Error)jjte000;}
1134     } finally {
1135           if (jjtc000) {
1136             jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
1137             jjtreeCloseNodeScope(jjtn000);
1138           }
1139     }
1140   }
1141 
1142 /* ECMA-262 5.1 Edition / June 2011 - Section 11.8: Relational Operators */
1143   final public void RelationalExpression() throws ParseException {
1144  /*@bgen(jjtree) #BinaryOperation(> 1) */
1145   ECMABinaryOperation jjtn000 = new ECMABinaryOperation(this, JJTBINARYOPERATION);
1146   boolean jjtc000 = true;
1147   jjtree.openNodeScope(jjtn000);
1148   jjtreeOpenNodeScope(jjtn000);
1149     try {
1150       ShiftExpression();
1151       label_10:
1152       while (true) {
1153         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1154         case INSTANCEOF:
1155         case IN:
1156         case LT:
1157         case GT:
1158         case LTE:
1159         case GTE:
1160           ;
1161           break;
1162         default:
1163           jj_la1[28] = jj_gen;
1164           break label_10;
1165         }
1166                               ECMAOperator jjtn001 = new ECMAOperator(this, JJTOPERATOR);
1167                               boolean jjtc001 = true;
1168                               jjtree.openNodeScope(jjtn001);
1169                               jjtreeOpenNodeScope(jjtn001);
1170         try {
1171           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1172           case INSTANCEOF:
1173           case LT:
1174           case GT:
1175           case LTE:
1176           case GTE:
1177             RelationalOperatorNoIn();
1178             break;
1179           case IN:
1180             jj_consume_token(IN);
1181             break;
1182           default:
1183             jj_la1[29] = jj_gen;
1184             jj_consume_token(-1);
1185             throw new ParseException();
1186           }
1187         } catch (Throwable jjte001) {
1188                               if (jjtc001) {
1189                                 jjtree.clearNodeScope(jjtn001);
1190                                 jjtc001 = false;
1191                               } else {
1192                                 jjtree.popNode();
1193                               }
1194                               if (jjte001 instanceof RuntimeException) {
1195                                 {if (true) throw (RuntimeException)jjte001;}
1196                               }
1197                               if (jjte001 instanceof ParseException) {
1198                                 {if (true) throw (ParseException)jjte001;}
1199                               }
1200                               {if (true) throw (Error)jjte001;}
1201         } finally {
1202                               if (jjtc001) {
1203                                 jjtree.closeNodeScope(jjtn001, true);
1204                                 jjtreeCloseNodeScope(jjtn001);
1205                               }
1206         }
1207         ShiftExpression();
1208       }
1209     } catch (Throwable jjte000) {
1210           if (jjtc000) {
1211             jjtree.clearNodeScope(jjtn000);
1212             jjtc000 = false;
1213           } else {
1214             jjtree.popNode();
1215           }
1216           if (jjte000 instanceof RuntimeException) {
1217             {if (true) throw (RuntimeException)jjte000;}
1218           }
1219           if (jjte000 instanceof ParseException) {
1220             {if (true) throw (ParseException)jjte000;}
1221           }
1222           {if (true) throw (Error)jjte000;}
1223     } finally {
1224           if (jjtc000) {
1225             jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
1226             jjtreeCloseNodeScope(jjtn000);
1227           }
1228     }
1229   }
1230 
1231   final public void RelationalExpressionNoIn() throws ParseException {
1232  /*@bgen(jjtree) #BinaryOperation(> 1) */
1233   ECMABinaryOperation jjtn000 = new ECMABinaryOperation(this, JJTBINARYOPERATION);
1234   boolean jjtc000 = true;
1235   jjtree.openNodeScope(jjtn000);
1236   jjtreeOpenNodeScope(jjtn000);
1237     try {
1238       ShiftExpression();
1239       label_11:
1240       while (true) {
1241         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1242         case INSTANCEOF:
1243         case LT:
1244         case GT:
1245         case LTE:
1246         case GTE:
1247           ;
1248           break;
1249         default:
1250           jj_la1[30] = jj_gen;
1251           break label_11;
1252         }
1253                               ECMAOperator jjtn001 = new ECMAOperator(this, JJTOPERATOR);
1254                               boolean jjtc001 = true;
1255                               jjtree.openNodeScope(jjtn001);
1256                               jjtreeOpenNodeScope(jjtn001);
1257         try {
1258           RelationalOperatorNoIn();
1259         } catch (Throwable jjte001) {
1260                               if (jjtc001) {
1261                                 jjtree.clearNodeScope(jjtn001);
1262                                 jjtc001 = false;
1263                               } else {
1264                                 jjtree.popNode();
1265                               }
1266                               if (jjte001 instanceof RuntimeException) {
1267                                 {if (true) throw (RuntimeException)jjte001;}
1268                               }
1269                               if (jjte001 instanceof ParseException) {
1270                                 {if (true) throw (ParseException)jjte001;}
1271                               }
1272                               {if (true) throw (Error)jjte001;}
1273         } finally {
1274                               if (jjtc001) {
1275                                 jjtree.closeNodeScope(jjtn001, true);
1276                                 jjtreeCloseNodeScope(jjtn001);
1277                               }
1278         }
1279         ShiftExpression();
1280       }
1281     } catch (Throwable jjte000) {
1282           if (jjtc000) {
1283             jjtree.clearNodeScope(jjtn000);
1284             jjtc000 = false;
1285           } else {
1286             jjtree.popNode();
1287           }
1288           if (jjte000 instanceof RuntimeException) {
1289             {if (true) throw (RuntimeException)jjte000;}
1290           }
1291           if (jjte000 instanceof ParseException) {
1292             {if (true) throw (ParseException)jjte000;}
1293           }
1294           {if (true) throw (Error)jjte000;}
1295     } finally {
1296           if (jjtc000) {
1297             jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
1298             jjtreeCloseNodeScope(jjtn000);
1299           }
1300     }
1301   }
1302 
1303   final public void RelationalOperatorNoIn() throws ParseException {
1304     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1305     case LT:
1306       jj_consume_token(LT);
1307       break;
1308     case GT:
1309       jj_consume_token(GT);
1310       break;
1311     case LTE:
1312       jj_consume_token(LTE);
1313       break;
1314     case GTE:
1315       jj_consume_token(GTE);
1316       break;
1317     case INSTANCEOF:
1318       jj_consume_token(INSTANCEOF);
1319       break;
1320     default:
1321       jj_la1[31] = jj_gen;
1322       jj_consume_token(-1);
1323       throw new ParseException();
1324     }
1325   }
1326 
1327 /* ECMA-262 5.1 Edition / June 2011 - Section 11.9: Equality Operators */
1328   final public void EqualityExpression() throws ParseException {
1329  /*@bgen(jjtree) #BinaryOperation(> 1) */
1330   ECMABinaryOperation jjtn000 = new ECMABinaryOperation(this, JJTBINARYOPERATION);
1331   boolean jjtc000 = true;
1332   jjtree.openNodeScope(jjtn000);
1333   jjtreeOpenNodeScope(jjtn000);
1334     try {
1335       RelationalExpression();
1336       label_12:
1337       while (true) {
1338         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1339         case EQ:
1340         case NE:
1341         case EQS:
1342         case NEQS:
1343           ;
1344           break;
1345         default:
1346           jj_la1[32] = jj_gen;
1347           break label_12;
1348         }
1349         EqualityOperator();
1350         RelationalExpression();
1351       }
1352     } catch (Throwable jjte000) {
1353           if (jjtc000) {
1354             jjtree.clearNodeScope(jjtn000);
1355             jjtc000 = false;
1356           } else {
1357             jjtree.popNode();
1358           }
1359           if (jjte000 instanceof RuntimeException) {
1360             {if (true) throw (RuntimeException)jjte000;}
1361           }
1362           if (jjte000 instanceof ParseException) {
1363             {if (true) throw (ParseException)jjte000;}
1364           }
1365           {if (true) throw (Error)jjte000;}
1366     } finally {
1367           if (jjtc000) {
1368             jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
1369             jjtreeCloseNodeScope(jjtn000);
1370           }
1371     }
1372   }
1373 
1374   final public void EqualityExpressionNoIn() throws ParseException {
1375  /*@bgen(jjtree) #BinaryOperation(> 1) */
1376   ECMABinaryOperation jjtn000 = new ECMABinaryOperation(this, JJTBINARYOPERATION);
1377   boolean jjtc000 = true;
1378   jjtree.openNodeScope(jjtn000);
1379   jjtreeOpenNodeScope(jjtn000);
1380     try {
1381       RelationalExpressionNoIn();
1382       label_13:
1383       while (true) {
1384         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1385         case EQ:
1386         case NE:
1387         case EQS:
1388         case NEQS:
1389           ;
1390           break;
1391         default:
1392           jj_la1[33] = jj_gen;
1393           break label_13;
1394         }
1395         EqualityOperator();
1396         RelationalExpressionNoIn();
1397       }
1398     } catch (Throwable jjte000) {
1399           if (jjtc000) {
1400             jjtree.clearNodeScope(jjtn000);
1401             jjtc000 = false;
1402           } else {
1403             jjtree.popNode();
1404           }
1405           if (jjte000 instanceof RuntimeException) {
1406             {if (true) throw (RuntimeException)jjte000;}
1407           }
1408           if (jjte000 instanceof ParseException) {
1409             {if (true) throw (ParseException)jjte000;}
1410           }
1411           {if (true) throw (Error)jjte000;}
1412     } finally {
1413           if (jjtc000) {
1414             jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
1415             jjtreeCloseNodeScope(jjtn000);
1416           }
1417     }
1418   }
1419 
1420   final public void EqualityOperator() throws ParseException {
1421  /*@bgen(jjtree) Operator */
1422   ECMAOperator jjtn000 = new ECMAOperator(this, JJTOPERATOR);
1423   boolean jjtc000 = true;
1424   jjtree.openNodeScope(jjtn000);
1425   jjtreeOpenNodeScope(jjtn000);
1426     try {
1427       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1428       case EQ:
1429         jj_consume_token(EQ);
1430         break;
1431       case NE:
1432         jj_consume_token(NE);
1433         break;
1434       case EQS:
1435         jj_consume_token(EQS);
1436         break;
1437       case NEQS:
1438         jj_consume_token(NEQS);
1439         break;
1440       default:
1441         jj_la1[34] = jj_gen;
1442         jj_consume_token(-1);
1443         throw new ParseException();
1444       }
1445     } finally {
1446           if (jjtc000) {
1447             jjtree.closeNodeScope(jjtn000, true);
1448             jjtreeCloseNodeScope(jjtn000);
1449           }
1450     }
1451   }
1452 
1453 /* ECMA-262 5.1 Edition / June 2011 - Section 11.10: Binary Bitwise Operators */
1454   final public void BitwiseANDExpression() throws ParseException {
1455  /*@bgen(jjtree) #BinaryOperation(> 1) */
1456   ECMABinaryOperation jjtn000 = new ECMABinaryOperation(this, JJTBINARYOPERATION);
1457   boolean jjtc000 = true;
1458   jjtree.openNodeScope(jjtn000);
1459   jjtreeOpenNodeScope(jjtn000);
1460     try {
1461       EqualityExpression();
1462       label_14:
1463       while (true) {
1464         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1465         case AND:
1466           ;
1467           break;
1468         default:
1469           jj_la1[35] = jj_gen;
1470           break label_14;
1471         }
1472         BitwiseANDOperator();
1473         EqualityExpression();
1474       }
1475     } catch (Throwable jjte000) {
1476           if (jjtc000) {
1477             jjtree.clearNodeScope(jjtn000);
1478             jjtc000 = false;
1479           } else {
1480             jjtree.popNode();
1481           }
1482           if (jjte000 instanceof RuntimeException) {
1483             {if (true) throw (RuntimeException)jjte000;}
1484           }
1485           if (jjte000 instanceof ParseException) {
1486             {if (true) throw (ParseException)jjte000;}
1487           }
1488           {if (true) throw (Error)jjte000;}
1489     } finally {
1490           if (jjtc000) {
1491             jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
1492             jjtreeCloseNodeScope(jjtn000);
1493           }
1494     }
1495   }
1496 
1497   final public void BitwiseANDExpressionNoIn() throws ParseException {
1498  /*@bgen(jjtree) #BinaryOperation(> 1) */
1499   ECMABinaryOperation jjtn000 = new ECMABinaryOperation(this, JJTBINARYOPERATION);
1500   boolean jjtc000 = true;
1501   jjtree.openNodeScope(jjtn000);
1502   jjtreeOpenNodeScope(jjtn000);
1503     try {
1504       EqualityExpressionNoIn();
1505       label_15:
1506       while (true) {
1507         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1508         case AND:
1509           ;
1510           break;
1511         default:
1512           jj_la1[36] = jj_gen;
1513           break label_15;
1514         }
1515         BitwiseANDOperator();
1516         EqualityExpressionNoIn();
1517       }
1518     } catch (Throwable jjte000) {
1519           if (jjtc000) {
1520             jjtree.clearNodeScope(jjtn000);
1521             jjtc000 = false;
1522           } else {
1523             jjtree.popNode();
1524           }
1525           if (jjte000 instanceof RuntimeException) {
1526             {if (true) throw (RuntimeException)jjte000;}
1527           }
1528           if (jjte000 instanceof ParseException) {
1529             {if (true) throw (ParseException)jjte000;}
1530           }
1531           {if (true) throw (Error)jjte000;}
1532     } finally {
1533           if (jjtc000) {
1534             jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
1535             jjtreeCloseNodeScope(jjtn000);
1536           }
1537     }
1538   }
1539 
1540   final public void BitwiseANDOperator() throws ParseException {
1541  /*@bgen(jjtree) Operator */
1542   ECMAOperator jjtn000 = new ECMAOperator(this, JJTOPERATOR);
1543   boolean jjtc000 = true;
1544   jjtree.openNodeScope(jjtn000);
1545   jjtreeOpenNodeScope(jjtn000);
1546     try {
1547       jj_consume_token(AND);
1548     } finally {
1549           if (jjtc000) {
1550             jjtree.closeNodeScope(jjtn000, true);
1551             jjtreeCloseNodeScope(jjtn000);
1552           }
1553     }
1554   }
1555 
1556   final public void BitwiseXORExpression() throws ParseException {
1557  /*@bgen(jjtree) #BinaryOperation(> 1) */
1558   ECMABinaryOperation jjtn000 = new ECMABinaryOperation(this, JJTBINARYOPERATION);
1559   boolean jjtc000 = true;
1560   jjtree.openNodeScope(jjtn000);
1561   jjtreeOpenNodeScope(jjtn000);
1562     try {
1563       BitwiseANDExpression();
1564       label_16:
1565       while (true) {
1566         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1567         case XOR:
1568           ;
1569           break;
1570         default:
1571           jj_la1[37] = jj_gen;
1572           break label_16;
1573         }
1574         BitwiseXOROperator();
1575         BitwiseANDExpression();
1576       }
1577     } catch (Throwable jjte000) {
1578           if (jjtc000) {
1579             jjtree.clearNodeScope(jjtn000);
1580             jjtc000 = false;
1581           } else {
1582             jjtree.popNode();
1583           }
1584           if (jjte000 instanceof RuntimeException) {
1585             {if (true) throw (RuntimeException)jjte000;}
1586           }
1587           if (jjte000 instanceof ParseException) {
1588             {if (true) throw (ParseException)jjte000;}
1589           }
1590           {if (true) throw (Error)jjte000;}
1591     } finally {
1592           if (jjtc000) {
1593             jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
1594             jjtreeCloseNodeScope(jjtn000);
1595           }
1596     }
1597   }
1598 
1599   final public void BitwiseXORExpressionNoIn() throws ParseException {
1600  /*@bgen(jjtree) #BinaryOperation(> 1) */
1601   ECMABinaryOperation jjtn000 = new ECMABinaryOperation(this, JJTBINARYOPERATION);
1602   boolean jjtc000 = true;
1603   jjtree.openNodeScope(jjtn000);
1604   jjtreeOpenNodeScope(jjtn000);
1605     try {
1606       BitwiseANDExpressionNoIn();
1607       label_17:
1608       while (true) {
1609         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1610         case XOR:
1611           ;
1612           break;
1613         default:
1614           jj_la1[38] = jj_gen;
1615           break label_17;
1616         }
1617         BitwiseXOROperator();
1618         BitwiseANDExpressionNoIn();
1619       }
1620     } catch (Throwable jjte000) {
1621           if (jjtc000) {
1622             jjtree.clearNodeScope(jjtn000);
1623             jjtc000 = false;
1624           } else {
1625             jjtree.popNode();
1626           }
1627           if (jjte000 instanceof RuntimeException) {
1628             {if (true) throw (RuntimeException)jjte000;}
1629           }
1630           if (jjte000 instanceof ParseException) {
1631             {if (true) throw (ParseException)jjte000;}
1632           }
1633           {if (true) throw (Error)jjte000;}
1634     } finally {
1635           if (jjtc000) {
1636             jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
1637             jjtreeCloseNodeScope(jjtn000);
1638           }
1639     }
1640   }
1641 
1642   final public void BitwiseXOROperator() throws ParseException {
1643  /*@bgen(jjtree) Operator */
1644   ECMAOperator jjtn000 = new ECMAOperator(this, JJTOPERATOR);
1645   boolean jjtc000 = true;
1646   jjtree.openNodeScope(jjtn000);
1647   jjtreeOpenNodeScope(jjtn000);
1648     try {
1649       jj_consume_token(XOR);
1650     } finally {
1651           if (jjtc000) {
1652             jjtree.closeNodeScope(jjtn000, true);
1653             jjtreeCloseNodeScope(jjtn000);
1654           }
1655     }
1656   }
1657 
1658   final public void BitwiseORExpression() throws ParseException {
1659  /*@bgen(jjtree) #BinaryOperation(> 1) */
1660   ECMABinaryOperation jjtn000 = new ECMABinaryOperation(this, JJTBINARYOPERATION);
1661   boolean jjtc000 = true;
1662   jjtree.openNodeScope(jjtn000);
1663   jjtreeOpenNodeScope(jjtn000);
1664     try {
1665       BitwiseXORExpression();
1666       label_18:
1667       while (true) {
1668         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1669         case OR:
1670           ;
1671           break;
1672         default:
1673           jj_la1[39] = jj_gen;
1674           break label_18;
1675         }
1676         BitwiseOROperator();
1677         BitwiseXORExpression();
1678       }
1679     } catch (Throwable jjte000) {
1680           if (jjtc000) {
1681             jjtree.clearNodeScope(jjtn000);
1682             jjtc000 = false;
1683           } else {
1684             jjtree.popNode();
1685           }
1686           if (jjte000 instanceof RuntimeException) {
1687             {if (true) throw (RuntimeException)jjte000;}
1688           }
1689           if (jjte000 instanceof ParseException) {
1690             {if (true) throw (ParseException)jjte000;}
1691           }
1692           {if (true) throw (Error)jjte000;}
1693     } finally {
1694           if (jjtc000) {
1695             jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
1696             jjtreeCloseNodeScope(jjtn000);
1697           }
1698     }
1699   }
1700 
1701   final public void BitwiseORExpressionNoIn() throws ParseException {
1702  /*@bgen(jjtree) #BinaryOperation(> 1) */
1703   ECMABinaryOperation jjtn000 = new ECMABinaryOperation(this, JJTBINARYOPERATION);
1704   boolean jjtc000 = true;
1705   jjtree.openNodeScope(jjtn000);
1706   jjtreeOpenNodeScope(jjtn000);
1707     try {
1708       BitwiseXORExpressionNoIn();
1709       label_19:
1710       while (true) {
1711         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1712         case OR:
1713           ;
1714           break;
1715         default:
1716           jj_la1[40] = jj_gen;
1717           break label_19;
1718         }
1719         BitwiseOROperator();
1720         BitwiseXORExpressionNoIn();
1721       }
1722     } catch (Throwable jjte000) {
1723           if (jjtc000) {
1724             jjtree.clearNodeScope(jjtn000);
1725             jjtc000 = false;
1726           } else {
1727             jjtree.popNode();
1728           }
1729           if (jjte000 instanceof RuntimeException) {
1730             {if (true) throw (RuntimeException)jjte000;}
1731           }
1732           if (jjte000 instanceof ParseException) {
1733             {if (true) throw (ParseException)jjte000;}
1734           }
1735           {if (true) throw (Error)jjte000;}
1736     } finally {
1737           if (jjtc000) {
1738             jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
1739             jjtreeCloseNodeScope(jjtn000);
1740           }
1741     }
1742   }
1743 
1744   final public void BitwiseOROperator() throws ParseException {
1745  /*@bgen(jjtree) Operator */
1746   ECMAOperator jjtn000 = new ECMAOperator(this, JJTOPERATOR);
1747   boolean jjtc000 = true;
1748   jjtree.openNodeScope(jjtn000);
1749   jjtreeOpenNodeScope(jjtn000);
1750     try {
1751       jj_consume_token(OR);
1752     } finally {
1753           if (jjtc000) {
1754             jjtree.closeNodeScope(jjtn000, true);
1755             jjtreeCloseNodeScope(jjtn000);
1756           }
1757     }
1758   }
1759 
1760 /* ECMA-262 5.1 Edition / June 2011 - Section 11.11: Binary Logical Operators */
1761   final public void LogicalANDExpression() throws ParseException {
1762  /*@bgen(jjtree) #AndOperation(> 1) */
1763   ECMAAndOperation jjtn000 = new ECMAAndOperation(this, JJTANDOPERATION);
1764   boolean jjtc000 = true;
1765   jjtree.openNodeScope(jjtn000);
1766   jjtreeOpenNodeScope(jjtn000);
1767     try {
1768       BitwiseORExpression();
1769       label_20:
1770       while (true) {
1771         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1772         case BAND:
1773           ;
1774           break;
1775         default:
1776           jj_la1[41] = jj_gen;
1777           break label_20;
1778         }
1779         LogicalANDOperator();
1780         BitwiseORExpression();
1781       }
1782     } catch (Throwable jjte000) {
1783           if (jjtc000) {
1784             jjtree.clearNodeScope(jjtn000);
1785             jjtc000 = false;
1786           } else {
1787             jjtree.popNode();
1788           }
1789           if (jjte000 instanceof RuntimeException) {
1790             {if (true) throw (RuntimeException)jjte000;}
1791           }
1792           if (jjte000 instanceof ParseException) {
1793             {if (true) throw (ParseException)jjte000;}
1794           }
1795           {if (true) throw (Error)jjte000;}
1796     } finally {
1797           if (jjtc000) {
1798             jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
1799             jjtreeCloseNodeScope(jjtn000);
1800           }
1801     }
1802   }
1803 
1804   final public void LogicalANDExpressionNoIn() throws ParseException {
1805  /*@bgen(jjtree) #AndOperation(> 1) */
1806   ECMAAndOperation jjtn000 = new ECMAAndOperation(this, JJTANDOPERATION);
1807   boolean jjtc000 = true;
1808   jjtree.openNodeScope(jjtn000);
1809   jjtreeOpenNodeScope(jjtn000);
1810     try {
1811       BitwiseORExpressionNoIn();
1812       label_21:
1813       while (true) {
1814         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1815         case BAND:
1816           ;
1817           break;
1818         default:
1819           jj_la1[42] = jj_gen;
1820           break label_21;
1821         }
1822         LogicalANDOperator();
1823         BitwiseORExpressionNoIn();
1824       }
1825     } catch (Throwable jjte000) {
1826           if (jjtc000) {
1827             jjtree.clearNodeScope(jjtn000);
1828             jjtc000 = false;
1829           } else {
1830             jjtree.popNode();
1831           }
1832           if (jjte000 instanceof RuntimeException) {
1833             {if (true) throw (RuntimeException)jjte000;}
1834           }
1835           if (jjte000 instanceof ParseException) {
1836             {if (true) throw (ParseException)jjte000;}
1837           }
1838           {if (true) throw (Error)jjte000;}
1839     } finally {
1840           if (jjtc000) {
1841             jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
1842             jjtreeCloseNodeScope(jjtn000);
1843           }
1844     }
1845   }
1846 
1847   final public void LogicalANDOperator() throws ParseException {
1848  /*@bgen(jjtree) Operator */
1849   ECMAOperator jjtn000 = new ECMAOperator(this, JJTOPERATOR);
1850   boolean jjtc000 = true;
1851   jjtree.openNodeScope(jjtn000);
1852   jjtreeOpenNodeScope(jjtn000);
1853     try {
1854       jj_consume_token(BAND);
1855     } finally {
1856           if (jjtc000) {
1857             jjtree.closeNodeScope(jjtn000, true);
1858             jjtreeCloseNodeScope(jjtn000);
1859           }
1860     }
1861   }
1862 
1863   final public void LogicalORExpression() throws ParseException {
1864  /*@bgen(jjtree) #OrOperation(> 1) */
1865   ECMAOrOperation jjtn000 = new ECMAOrOperation(this, JJTOROPERATION);
1866   boolean jjtc000 = true;
1867   jjtree.openNodeScope(jjtn000);
1868   jjtreeOpenNodeScope(jjtn000);
1869     try {
1870       LogicalANDExpression();
1871       label_22:
1872       while (true) {
1873         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1874         case BOR:
1875           ;
1876           break;
1877         default:
1878           jj_la1[43] = jj_gen;
1879           break label_22;
1880         }
1881         LogicalOROperator();
1882         LogicalANDExpression();
1883       }
1884     } catch (Throwable jjte000) {
1885           if (jjtc000) {
1886             jjtree.clearNodeScope(jjtn000);
1887             jjtc000 = false;
1888           } else {
1889             jjtree.popNode();
1890           }
1891           if (jjte000 instanceof RuntimeException) {
1892             {if (true) throw (RuntimeException)jjte000;}
1893           }
1894           if (jjte000 instanceof ParseException) {
1895             {if (true) throw (ParseException)jjte000;}
1896           }
1897           {if (true) throw (Error)jjte000;}
1898     } finally {
1899           if (jjtc000) {
1900             jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
1901             jjtreeCloseNodeScope(jjtn000);
1902           }
1903     }
1904   }
1905 
1906   final public void LogicalORExpressionNoIn() throws ParseException {
1907  /*@bgen(jjtree) #OrOperation(> 1) */
1908   ECMAOrOperation jjtn000 = new ECMAOrOperation(this, JJTOROPERATION);
1909   boolean jjtc000 = true;
1910   jjtree.openNodeScope(jjtn000);
1911   jjtreeOpenNodeScope(jjtn000);
1912     try {
1913       LogicalANDExpressionNoIn();
1914       label_23:
1915       while (true) {
1916         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1917         case BOR:
1918           ;
1919           break;
1920         default:
1921           jj_la1[44] = jj_gen;
1922           break label_23;
1923         }
1924         LogicalOROperator();
1925         LogicalANDExpressionNoIn();
1926       }
1927     } catch (Throwable jjte000) {
1928           if (jjtc000) {
1929             jjtree.clearNodeScope(jjtn000);
1930             jjtc000 = false;
1931           } else {
1932             jjtree.popNode();
1933           }
1934           if (jjte000 instanceof RuntimeException) {
1935             {if (true) throw (RuntimeException)jjte000;}
1936           }
1937           if (jjte000 instanceof ParseException) {
1938             {if (true) throw (ParseException)jjte000;}
1939           }
1940           {if (true) throw (Error)jjte000;}
1941     } finally {
1942           if (jjtc000) {
1943             jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
1944             jjtreeCloseNodeScope(jjtn000);
1945           }
1946     }
1947   }
1948 
1949   final public void LogicalOROperator() throws ParseException {
1950  /*@bgen(jjtree) Operator */
1951   ECMAOperator jjtn000 = new ECMAOperator(this, JJTOPERATOR);
1952   boolean jjtc000 = true;
1953   jjtree.openNodeScope(jjtn000);
1954   jjtreeOpenNodeScope(jjtn000);
1955     try {
1956       jj_consume_token(BOR);
1957     } finally {
1958           if (jjtc000) {
1959             jjtree.closeNodeScope(jjtn000, true);
1960             jjtreeCloseNodeScope(jjtn000);
1961           }
1962     }
1963   }
1964 
1965 /* ECMA-262 5.1 Edition / June 2011 - Section 11.12: Conditional Operator */
1966   final public void ConditionalExpression() throws ParseException {
1967  /*@bgen(jjtree) #ConditionalExpression(> 1) */
1968   ECMAConditionalExpression jjtn000 = new ECMAConditionalExpression(this, JJTCONDITIONALEXPRESSION);
1969   boolean jjtc000 = true;
1970   jjtree.openNodeScope(jjtn000);
1971   jjtreeOpenNodeScope(jjtn000);
1972     try {
1973       LogicalORExpression();
1974       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1975       case QUEST:
1976         jj_consume_token(QUEST);
1977         AssignmentExpression();
1978         jj_consume_token(COLON);
1979         AssignmentExpression();
1980         break;
1981       default:
1982         jj_la1[45] = jj_gen;
1983         ;
1984       }
1985     } catch (Throwable jjte000) {
1986           if (jjtc000) {
1987             jjtree.clearNodeScope(jjtn000);
1988             jjtc000 = false;
1989           } else {
1990             jjtree.popNode();
1991           }
1992           if (jjte000 instanceof RuntimeException) {
1993             {if (true) throw (RuntimeException)jjte000;}
1994           }
1995           if (jjte000 instanceof ParseException) {
1996             {if (true) throw (ParseException)jjte000;}
1997           }
1998           {if (true) throw (Error)jjte000;}
1999     } finally {
2000           if (jjtc000) {
2001             jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
2002             jjtreeCloseNodeScope(jjtn000);
2003           }
2004     }
2005   }
2006 
2007   final public void ConditionalExpressionNoIn() throws ParseException {
2008  /*@bgen(jjtree) #ConditionalExpression(> 1) */
2009   ECMAConditionalExpression jjtn000 = new ECMAConditionalExpression(this, JJTCONDITIONALEXPRESSION);
2010   boolean jjtc000 = true;
2011   jjtree.openNodeScope(jjtn000);
2012   jjtreeOpenNodeScope(jjtn000);
2013     try {
2014       LogicalORExpressionNoIn();
2015       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2016       case QUEST:
2017         jj_consume_token(QUEST);
2018         AssignmentExpression();
2019         jj_consume_token(COLON);
2020         AssignmentExpressionNoIn();
2021         break;
2022       default:
2023         jj_la1[46] = jj_gen;
2024         ;
2025       }
2026     } catch (Throwable jjte000) {
2027           if (jjtc000) {
2028             jjtree.clearNodeScope(jjtn000);
2029             jjtc000 = false;
2030           } else {
2031             jjtree.popNode();
2032           }
2033           if (jjte000 instanceof RuntimeException) {
2034             {if (true) throw (RuntimeException)jjte000;}
2035           }
2036           if (jjte000 instanceof ParseException) {
2037             {if (true) throw (ParseException)jjte000;}
2038           }
2039           {if (true) throw (Error)jjte000;}
2040     } finally {
2041           if (jjtc000) {
2042             jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
2043             jjtreeCloseNodeScope(jjtn000);
2044           }
2045     }
2046   }
2047 
2048 /* ECMA-262 5.1 Edition / June 2011 - Section 11.13: Assignment Operators */
2049   final public void AssignmentExpression() throws ParseException {
2050  /*@bgen(jjtree) #AssignmentExpression(> 1) */
2051   ECMAAssignmentExpression jjtn000 = new ECMAAssignmentExpression(this, JJTASSIGNMENTEXPRESSION);
2052   boolean jjtc000 = true;
2053   jjtree.openNodeScope(jjtn000);
2054   jjtreeOpenNodeScope(jjtn000);
2055     try {
2056       if (jj_2_14(2147483647)) {
2057         LeftHandSideExpression();
2058         AssignmentOperator();
2059         AssignmentExpression();
2060       } else {
2061         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2062         case TYPEOF:
2063         case NEW:
2064         case VOID:
2065         case FUNCTION:
2066         case THIS:
2067         case DELETE:
2068         case LBRACE:
2069         case LPAREN:
2070         case LBRACKET:
2071         case PLUS:
2072         case MINUS:
2073         case INC:
2074         case DEC:
2075         case BNOT:
2076         case NOT:
2077         case NULL_LITERAL:
2078         case BOOLEAN_LITERAL:
2079         case DECIMAL_LITERAL:
2080         case HEX_INTEGER_LITERAL:
2081         case STRING_LITERAL:
2082         case IDENTIFIER_NAME:
2083         case REGULAR_EXPRESSION_LITERAL:
2084           ConditionalExpression();
2085           break;
2086         default:
2087           jj_la1[47] = jj_gen;
2088           jj_consume_token(-1);
2089           throw new ParseException();
2090         }
2091       }
2092     } catch (Throwable jjte000) {
2093           if (jjtc000) {
2094             jjtree.clearNodeScope(jjtn000);
2095             jjtc000 = false;
2096           } else {
2097             jjtree.popNode();
2098           }
2099           if (jjte000 instanceof RuntimeException) {
2100             {if (true) throw (RuntimeException)jjte000;}
2101           }
2102           if (jjte000 instanceof ParseException) {
2103             {if (true) throw (ParseException)jjte000;}
2104           }
2105           {if (true) throw (Error)jjte000;}
2106     } finally {
2107           if (jjtc000) {
2108             jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
2109             jjtreeCloseNodeScope(jjtn000);
2110           }
2111     }
2112   }
2113 
2114   final public void AssignmentExpressionNoIn() throws ParseException {
2115  /*@bgen(jjtree) #AssignmentExpression(> 1) */
2116   ECMAAssignmentExpression jjtn000 = new ECMAAssignmentExpression(this, JJTASSIGNMENTEXPRESSION);
2117   boolean jjtc000 = true;
2118   jjtree.openNodeScope(jjtn000);
2119   jjtreeOpenNodeScope(jjtn000);
2120     try {
2121       if (jj_2_15(2147483647)) {
2122         LeftHandSideExpression();
2123         AssignmentOperator();
2124         AssignmentExpressionNoIn();
2125       } else {
2126         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2127         case TYPEOF:
2128         case NEW:
2129         case VOID:
2130         case FUNCTION:
2131         case THIS:
2132         case DELETE:
2133         case LBRACE:
2134         case LPAREN:
2135         case LBRACKET:
2136         case PLUS:
2137         case MINUS:
2138         case INC:
2139         case DEC:
2140         case BNOT:
2141         case NOT:
2142         case NULL_LITERAL:
2143         case BOOLEAN_LITERAL:
2144         case DECIMAL_LITERAL:
2145         case HEX_INTEGER_LITERAL:
2146         case STRING_LITERAL:
2147         case IDENTIFIER_NAME:
2148         case REGULAR_EXPRESSION_LITERAL:
2149           ConditionalExpressionNoIn();
2150           break;
2151         default:
2152           jj_la1[48] = jj_gen;
2153           jj_consume_token(-1);
2154           throw new ParseException();
2155         }
2156       }
2157     } catch (Throwable jjte000) {
2158           if (jjtc000) {
2159             jjtree.clearNodeScope(jjtn000);
2160             jjtc000 = false;
2161           } else {
2162             jjtree.popNode();
2163           }
2164           if (jjte000 instanceof RuntimeException) {
2165             {if (true) throw (RuntimeException)jjte000;}
2166           }
2167           if (jjte000 instanceof ParseException) {
2168             {if (true) throw (ParseException)jjte000;}
2169           }
2170           {if (true) throw (Error)jjte000;}
2171     } finally {
2172           if (jjtc000) {
2173             jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
2174             jjtreeCloseNodeScope(jjtn000);
2175           }
2176     }
2177   }
2178 
2179   final public void AssignmentOperator() throws ParseException {
2180  /*@bgen(jjtree) Operator */
2181   ECMAOperator jjtn000 = new ECMAOperator(this, JJTOPERATOR);
2182   boolean jjtc000 = true;
2183   jjtree.openNodeScope(jjtn000);
2184   jjtreeOpenNodeScope(jjtn000);
2185     try {
2186       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2187       case ASSIGN:
2188         jj_consume_token(ASSIGN);
2189         break;
2190       case AMUL:
2191         jj_consume_token(AMUL);
2192         break;
2193       case ADIV:
2194         jj_consume_token(ADIV);
2195         break;
2196       case AMOD:
2197         jj_consume_token(AMOD);
2198         break;
2199       case AADD:
2200         jj_consume_token(AADD);
2201         break;
2202       case ASUB:
2203         jj_consume_token(ASUB);
2204         break;
2205       case ASHL:
2206         jj_consume_token(ASHL);
2207         break;
2208       case ASHR:
2209         jj_consume_token(ASHR);
2210         break;
2211       case ASHRU:
2212         jj_consume_token(ASHRU);
2213         break;
2214       case AAND:
2215         jj_consume_token(AAND);
2216         break;
2217       case AXOR:
2218         jj_consume_token(AXOR);
2219         break;
2220       case AOR:
2221         jj_consume_token(AOR);
2222         break;
2223       default:
2224         jj_la1[49] = jj_gen;
2225         jj_consume_token(-1);
2226         throw new ParseException();
2227       }
2228     } finally {
2229           if (jjtc000) {
2230             jjtree.closeNodeScope(jjtn000, true);
2231             jjtreeCloseNodeScope(jjtn000);
2232           }
2233     }
2234   }
2235 
2236 /* ECMA-262 5.1 Edition / June 2011 - Section 11.14: Comma Operator */
2237   final public void Expression() throws ParseException {
2238  /*@bgen(jjtree) #CommaExpression(> 1) */
2239   ECMACommaExpression jjtn000 = new ECMACommaExpression(this, JJTCOMMAEXPRESSION);
2240   boolean jjtc000 = true;
2241   jjtree.openNodeScope(jjtn000);
2242   jjtreeOpenNodeScope(jjtn000);
2243     try {
2244       AssignmentExpression();
2245       label_24:
2246       while (true) {
2247         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2248         case COMMA:
2249           ;
2250           break;
2251         default:
2252           jj_la1[50] = jj_gen;
2253           break label_24;
2254         }
2255         jj_consume_token(COMMA);
2256         AssignmentExpression();
2257       }
2258     } catch (Throwable jjte000) {
2259           if (jjtc000) {
2260             jjtree.clearNodeScope(jjtn000);
2261             jjtc000 = false;
2262           } else {
2263             jjtree.popNode();
2264           }
2265           if (jjte000 instanceof RuntimeException) {
2266             {if (true) throw (RuntimeException)jjte000;}
2267           }
2268           if (jjte000 instanceof ParseException) {
2269             {if (true) throw (ParseException)jjte000;}
2270           }
2271           {if (true) throw (Error)jjte000;}
2272     } finally {
2273           if (jjtc000) {
2274             jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
2275             jjtreeCloseNodeScope(jjtn000);
2276           }
2277     }
2278   }
2279 
2280   final public void ExpressionNoIn() throws ParseException {
2281  /*@bgen(jjtree) #CommaExpression(> 1) */
2282   ECMACommaExpression jjtn000 = new ECMACommaExpression(this, JJTCOMMAEXPRESSION);
2283   boolean jjtc000 = true;
2284   jjtree.openNodeScope(jjtn000);
2285   jjtreeOpenNodeScope(jjtn000);
2286     try {
2287       AssignmentExpressionNoIn();
2288       label_25:
2289       while (true) {
2290         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2291         case COMMA:
2292           ;
2293           break;
2294         default:
2295           jj_la1[51] = jj_gen;
2296           break label_25;
2297         }
2298         jj_consume_token(COMMA);
2299         AssignmentExpressionNoIn();
2300       }
2301     } catch (Throwable jjte000) {
2302           if (jjtc000) {
2303             jjtree.clearNodeScope(jjtn000);
2304             jjtc000 = false;
2305           } else {
2306             jjtree.popNode();
2307           }
2308           if (jjte000 instanceof RuntimeException) {
2309             {if (true) throw (RuntimeException)jjte000;}
2310           }
2311           if (jjte000 instanceof ParseException) {
2312             {if (true) throw (ParseException)jjte000;}
2313           }
2314           {if (true) throw (Error)jjte000;}
2315     } finally {
2316           if (jjtc000) {
2317             jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
2318             jjtreeCloseNodeScope(jjtn000);
2319           }
2320     }
2321   }
2322 
2323 /* ECMA-262 5.1 Edition / June 2011 - Section 12: STATEMENTS */
2324   final public void Statement() throws ParseException {
2325     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2326     case JAVA_STATEMENT:
2327           ECMAJavaStatement jjtn001 = new ECMAJavaStatement(this, JJTJAVASTATEMENT);
2328           boolean jjtc001 = true;
2329           jjtree.openNodeScope(jjtn001);
2330           jjtreeOpenNodeScope(jjtn001);
2331       try {
2332         jj_consume_token(JAVA_STATEMENT);
2333       } finally {
2334           if (jjtc001) {
2335             jjtree.closeNodeScope(jjtn001, true);
2336             jjtreeCloseNodeScope(jjtn001);
2337           }
2338       }
2339       break;
2340     default:
2341       jj_la1[52] = jj_gen;
2342       if (jj_2_16(2147483647)) {
2343         Block();
2344       } else if (jj_2_17(2147483647)) {
2345         VariableStatement();
2346       } else {
2347         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2348         case DEBUGGER:
2349           DebuggerStatement();
2350           break;
2351         case SEMICOLON:
2352           EmptyStatement();
2353           break;
2354         default:
2355           jj_la1[53] = jj_gen;
2356           if (jj_2_18(2147483647)) {
2357             LabelledStatement();
2358           } else if (jj_2_19(2147483647)) {
2359             ExpressionStatement();
2360           } else if (jj_2_20(2147483647)) {
2361             IfStatement();
2362           } else {
2363             switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2364             case DO:
2365             case FOR:
2366             case WHILE:
2367               IterationStatement();
2368               break;
2369             default:
2370               jj_la1[54] = jj_gen;
2371               if (jj_2_21(2147483647)) {
2372                 ContinueStatement();
2373               } else if (jj_2_22(2147483647)) {
2374                 BreakStatement();
2375               } else {
2376                 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2377                 case RETURN:
2378                   ReturnStatement();
2379                   break;
2380                 case WITH:
2381                   WithStatement();
2382                   break;
2383                 case SWITCH:
2384                   SwitchStatement();
2385                   break;
2386                 case THROW:
2387                   ThrowStatement();
2388                   break;
2389                 case TRY:
2390                   TryStatement();
2391                   break;
2392                 default:
2393                   jj_la1[55] = jj_gen;
2394                   jj_consume_token(-1);
2395                   throw new ParseException();
2396                 }
2397               }
2398             }
2399           }
2400         }
2401       }
2402     }
2403   }
2404 
2405 /* ECMA-262 5.1 Edition / June 2011 - Section 12.1 Block Statement */
2406   final public void Block() throws ParseException {
2407  /*@bgen(jjtree) Block */
2408   ECMABlock jjtn000 = new ECMABlock(this, JJTBLOCK);
2409   boolean jjtc000 = true;
2410   jjtree.openNodeScope(jjtn000);
2411   jjtreeOpenNodeScope(jjtn000);
2412     try {
2413       jj_consume_token(LBRACE);
2414       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2415       case BREAK:
2416       case DO:
2417       case TYPEOF:
2418       case NEW:
2419       case VAR:
2420       case RETURN:
2421       case VOID:
2422       case CONTINUE:
2423       case FOR:
2424       case SWITCH:
2425       case WHILE:
2426       case DEBUGGER:
2427       case FUNCTION:
2428       case THIS:
2429       case WITH:
2430       case IF:
2431       case THROW:
2432       case DELETE:
2433       case TRY:
2434       case LBRACE:
2435       case LPAREN:
2436       case LBRACKET:
2437       case SEMICOLON:
2438       case PLUS:
2439       case MINUS:
2440       case INC:
2441       case DEC:
2442       case BNOT:
2443       case NOT:
2444       case NULL_LITERAL:
2445       case BOOLEAN_LITERAL:
2446       case DECIMAL_LITERAL:
2447       case HEX_INTEGER_LITERAL:
2448       case STRING_LITERAL:
2449       case IDENTIFIER_NAME:
2450       case REGULAR_EXPRESSION_LITERAL:
2451       case JAVA_STATEMENT:
2452         StatementList();
2453         break;
2454       default:
2455         jj_la1[56] = jj_gen;
2456         ;
2457       }
2458       jj_consume_token(RBRACE);
2459     } catch (Throwable jjte000) {
2460           if (jjtc000) {
2461             jjtree.clearNodeScope(jjtn000);
2462             jjtc000 = false;
2463           } else {
2464             jjtree.popNode();
2465           }
2466           if (jjte000 instanceof RuntimeException) {
2467             {if (true) throw (RuntimeException)jjte000;}
2468           }
2469           if (jjte000 instanceof ParseException) {
2470             {if (true) throw (ParseException)jjte000;}
2471           }
2472           {if (true) throw (Error)jjte000;}
2473     } finally {
2474           if (jjtc000) {
2475             jjtree.closeNodeScope(jjtn000, true);
2476             jjtreeCloseNodeScope(jjtn000);
2477           }
2478     }
2479   }
2480 
2481   final public void StatementList() throws ParseException {
2482  /*@bgen(jjtree) #StatementList(> 1) */
2483   ECMAStatementList jjtn000 = new ECMAStatementList(this, JJTSTATEMENTLIST);
2484   boolean jjtc000 = true;
2485   jjtree.openNodeScope(jjtn000);
2486   jjtreeOpenNodeScope(jjtn000);
2487     try {
2488       label_26:
2489       while (true) {
2490         Statement();
2491         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2492         case BREAK:
2493         case DO:
2494         case TYPEOF:
2495         case NEW:
2496         case VAR:
2497         case RETURN:
2498         case VOID:
2499         case CONTINUE:
2500         case FOR:
2501         case SWITCH:
2502         case WHILE:
2503         case DEBUGGER:
2504         case FUNCTION:
2505         case THIS:
2506         case WITH:
2507         case IF:
2508         case THROW:
2509         case DELETE:
2510         case TRY:
2511         case LBRACE:
2512         case LPAREN:
2513         case LBRACKET:
2514         case SEMICOLON:
2515         case PLUS:
2516         case MINUS:
2517         case INC:
2518         case DEC:
2519         case BNOT:
2520         case NOT:
2521         case NULL_LITERAL:
2522         case BOOLEAN_LITERAL:
2523         case DECIMAL_LITERAL:
2524         case HEX_INTEGER_LITERAL:
2525         case STRING_LITERAL:
2526         case IDENTIFIER_NAME:
2527         case REGULAR_EXPRESSION_LITERAL:
2528         case JAVA_STATEMENT:
2529           ;
2530           break;
2531         default:
2532           jj_la1[57] = jj_gen;
2533           break label_26;
2534         }
2535       }
2536     } catch (Throwable jjte000) {
2537           if (jjtc000) {
2538             jjtree.clearNodeScope(jjtn000);
2539             jjtc000 = false;
2540           } else {
2541             jjtree.popNode();
2542           }
2543           if (jjte000 instanceof RuntimeException) {
2544             {if (true) throw (RuntimeException)jjte000;}
2545           }
2546           if (jjte000 instanceof ParseException) {
2547             {if (true) throw (ParseException)jjte000;}
2548           }
2549           {if (true) throw (Error)jjte000;}
2550     } finally {
2551           if (jjtc000) {
2552             jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
2553             jjtreeCloseNodeScope(jjtn000);
2554           }
2555     }
2556   }
2557 
2558 /* ECMA-262 5.1 Edition / June 2011 - Section 12.2: Variable statement */
2559   final public void VariableStatement() throws ParseException {
2560  /*@bgen(jjtree) VariableStatement */
2561   ECMAVariableStatement jjtn000 = new ECMAVariableStatement(this, JJTVARIABLESTATEMENT);
2562   boolean jjtc000 = true;
2563   jjtree.openNodeScope(jjtn000);
2564   jjtreeOpenNodeScope(jjtn000);
2565     try {
2566       jj_consume_token(VAR);
2567       VariableDeclarationList();
2568       if (jj_2_23(2)) {
2569         jj_consume_token(SEMICOLON);
2570       } else {
2571         ;
2572       }
2573     } catch (Throwable jjte000) {
2574           if (jjtc000) {
2575             jjtree.clearNodeScope(jjtn000);
2576             jjtc000 = false;
2577           } else {
2578             jjtree.popNode();
2579           }
2580           if (jjte000 instanceof RuntimeException) {
2581             {if (true) throw (RuntimeException)jjte000;}
2582           }
2583           if (jjte000 instanceof ParseException) {
2584             {if (true) throw (ParseException)jjte000;}
2585           }
2586           {if (true) throw (Error)jjte000;}
2587     } finally {
2588           if (jjtc000) {
2589             jjtree.closeNodeScope(jjtn000, true);
2590             jjtreeCloseNodeScope(jjtn000);
2591           }
2592     }
2593   }
2594 
2595   final public void VariableDeclarationList() throws ParseException {
2596  /*@bgen(jjtree) #VariableDeclarationList(> 1) */
2597   ECMAVariableDeclarationList jjtn000 = new ECMAVariableDeclarationList(this, JJTVARIABLEDECLARATIONLIST);
2598   boolean jjtc000 = true;
2599   jjtree.openNodeScope(jjtn000);
2600   jjtreeOpenNodeScope(jjtn000);
2601     try {
2602       VariableDeclaration();
2603       label_27:
2604       while (true) {
2605         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2606         case COMMA:
2607           ;
2608           break;
2609         default:
2610           jj_la1[58] = jj_gen;
2611           break label_27;
2612         }
2613         jj_consume_token(COMMA);
2614         VariableDeclaration();
2615       }
2616     } catch (Throwable jjte000) {
2617           if (jjtc000) {
2618             jjtree.clearNodeScope(jjtn000);
2619             jjtc000 = false;
2620           } else {
2621             jjtree.popNode();
2622           }
2623           if (jjte000 instanceof RuntimeException) {
2624             {if (true) throw (RuntimeException)jjte000;}
2625           }
2626           if (jjte000 instanceof ParseException) {
2627             {if (true) throw (ParseException)jjte000;}
2628           }
2629           {if (true) throw (Error)jjte000;}
2630     } finally {
2631           if (jjtc000) {
2632             jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
2633             jjtreeCloseNodeScope(jjtn000);
2634           }
2635     }
2636   }
2637 
2638   final public void VariableDeclarationListNoIn() throws ParseException {
2639  /*@bgen(jjtree) #VariableDeclarationList(> 1) */
2640   ECMAVariableDeclarationList jjtn000 = new ECMAVariableDeclarationList(this, JJTVARIABLEDECLARATIONLIST);
2641   boolean jjtc000 = true;
2642   jjtree.openNodeScope(jjtn000);
2643   jjtreeOpenNodeScope(jjtn000);
2644     try {
2645       VariableDeclarationNoIn();
2646       label_28:
2647       while (true) {
2648         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2649         case COMMA:
2650           ;
2651           break;
2652         default:
2653           jj_la1[59] = jj_gen;
2654           break label_28;
2655         }
2656         jj_consume_token(COMMA);
2657         VariableDeclarationNoIn();
2658       }
2659     } catch (Throwable jjte000) {
2660           if (jjtc000) {
2661             jjtree.clearNodeScope(jjtn000);
2662             jjtc000 = false;
2663           } else {
2664             jjtree.popNode();
2665           }
2666           if (jjte000 instanceof RuntimeException) {
2667             {if (true) throw (RuntimeException)jjte000;}
2668           }
2669           if (jjte000 instanceof ParseException) {
2670             {if (true) throw (ParseException)jjte000;}
2671           }
2672           {if (true) throw (Error)jjte000;}
2673     } finally {
2674           if (jjtc000) {
2675             jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
2676             jjtreeCloseNodeScope(jjtn000);
2677           }
2678     }
2679   }
2680 
2681   final public void VariableDeclaration() throws ParseException {
2682  /*@bgen(jjtree) VariableDeclaration */
2683   ECMAVariableDeclaration jjtn000 = new ECMAVariableDeclaration(this, JJTVARIABLEDECLARATION);
2684   boolean jjtc000 = true;
2685   jjtree.openNodeScope(jjtn000);
2686   jjtreeOpenNodeScope(jjtn000);
2687     try {
2688       Identifier();
2689       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2690       case ASSIGN:
2691         Initialiser();
2692         break;
2693       default:
2694         jj_la1[60] = jj_gen;
2695         ;
2696       }
2697     } catch (Throwable jjte000) {
2698           if (jjtc000) {
2699             jjtree.clearNodeScope(jjtn000);
2700             jjtc000 = false;
2701           } else {
2702             jjtree.popNode();
2703           }
2704           if (jjte000 instanceof RuntimeException) {
2705             {if (true) throw (RuntimeException)jjte000;}
2706           }
2707           if (jjte000 instanceof ParseException) {
2708             {if (true) throw (ParseException)jjte000;}
2709           }
2710           {if (true) throw (Error)jjte000;}
2711     } finally {
2712           if (jjtc000) {
2713             jjtree.closeNodeScope(jjtn000, true);
2714             jjtreeCloseNodeScope(jjtn000);
2715           }
2716     }
2717   }
2718 
2719   final public void VariableDeclarationNoIn() throws ParseException {
2720  /*@bgen(jjtree) VariableDeclaration */
2721   ECMAVariableDeclaration jjtn000 = new ECMAVariableDeclaration(this, JJTVARIABLEDECLARATION);
2722   boolean jjtc000 = true;
2723   jjtree.openNodeScope(jjtn000);
2724   jjtreeOpenNodeScope(jjtn000);
2725     try {
2726       Identifier();
2727                        ECMAEmptyExpression jjtn001 = new ECMAEmptyExpression(this, JJTEMPTYEXPRESSION);
2728                        boolean jjtc001 = true;
2729                        jjtree.openNodeScope(jjtn001);
2730                        jjtreeOpenNodeScope(jjtn001);
2731       try {
2732         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2733         case ASSIGN:
2734           InitialiserNoIn();
2735           break;
2736         default:
2737           jj_la1[61] = jj_gen;
2738           ;
2739         }
2740       } catch (Throwable jjte001) {
2741                        if (jjtc001) {
2742                          jjtree.clearNodeScope(jjtn001);
2743                          jjtc001 = false;
2744                        } else {
2745                          jjtree.popNode();
2746                        }
2747                        if (jjte001 instanceof RuntimeException) {
2748                          {if (true) throw (RuntimeException)jjte001;}
2749                        }
2750                        if (jjte001 instanceof ParseException) {
2751                          {if (true) throw (ParseException)jjte001;}
2752                        }
2753                        {if (true) throw (Error)jjte001;}
2754       } finally {
2755                        if (jjtc001) {
2756                          jjtree.closeNodeScope(jjtn001,  jjtree . nodeArity ( ) == 0);
2757                          jjtreeCloseNodeScope(jjtn001);
2758                        }
2759       }
2760     } catch (Throwable jjte000) {
2761           if (jjtc000) {
2762             jjtree.clearNodeScope(jjtn000);
2763             jjtc000 = false;
2764           } else {
2765             jjtree.popNode();
2766           }
2767           if (jjte000 instanceof RuntimeException) {
2768             {if (true) throw (RuntimeException)jjte000;}
2769           }
2770           if (jjte000 instanceof ParseException) {
2771             {if (true) throw (ParseException)jjte000;}
2772           }
2773           {if (true) throw (Error)jjte000;}
2774     } finally {
2775           if (jjtc000) {
2776             jjtree.closeNodeScope(jjtn000, true);
2777             jjtreeCloseNodeScope(jjtn000);
2778           }
2779     }
2780   }
2781 
2782   final public void Initialiser() throws ParseException {
2783     jj_consume_token(ASSIGN);
2784     AssignmentExpression();
2785   }
2786 
2787   final public void InitialiserNoIn() throws ParseException {
2788     jj_consume_token(ASSIGN);
2789     AssignmentExpressionNoIn();
2790   }
2791 
2792 /* ECMA-262 5.1 Edition / June 2011 - Section 12.3: Empty Statement */
2793   final public void EmptyStatement() throws ParseException {
2794     jj_consume_token(SEMICOLON);
2795   }
2796 
2797 /* ECMA-262 5.1 Edition / June 2011 - Section 12.4: Expression Statement */
2798   final public void ExpressionStatement() throws ParseException {
2799  /*@bgen(jjtree) ExpressionStatement */
2800   ECMAExpressionStatement jjtn000 = new ECMAExpressionStatement(this, JJTEXPRESSIONSTATEMENT);
2801   boolean jjtc000 = true;
2802   jjtree.openNodeScope(jjtn000);
2803   jjtreeOpenNodeScope(jjtn000);
2804     try {
2805       Expression();
2806       if (jj_2_24(2)) {
2807         jj_consume_token(SEMICOLON);
2808       } else {
2809         ;
2810       }
2811     } catch (Throwable jjte000) {
2812           if (jjtc000) {
2813             jjtree.clearNodeScope(jjtn000);
2814             jjtc000 = false;
2815           } else {
2816             jjtree.popNode();
2817           }
2818           if (jjte000 instanceof RuntimeException) {
2819             {if (true) throw (RuntimeException)jjte000;}
2820           }
2821           if (jjte000 instanceof ParseException) {
2822             {if (true) throw (ParseException)jjte000;}
2823           }
2824           {if (true) throw (Error)jjte000;}
2825     } finally {
2826           if (jjtc000) {
2827             jjtree.closeNodeScope(jjtn000, true);
2828             jjtreeCloseNodeScope(jjtn000);
2829           }
2830     }
2831   }
2832 
2833 /* ECMA-262 5.1 Edition / June 2011 - Section 12.5: The if Statement */
2834   final public void IfStatement() throws ParseException {
2835  /*@bgen(jjtree) IfStatement */
2836   ECMAIfStatement jjtn000 = new ECMAIfStatement(this, JJTIFSTATEMENT);
2837   boolean jjtc000 = true;
2838   jjtree.openNodeScope(jjtn000);
2839   jjtreeOpenNodeScope(jjtn000);
2840     try {
2841       jj_consume_token(IF);
2842       jj_consume_token(LPAREN);
2843       Expression();
2844       jj_consume_token(RPAREN);
2845       Statement();
2846       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2847       case ELSE:
2848         jj_consume_token(ELSE);
2849         Statement();
2850         break;
2851       default:
2852         jj_la1[62] = jj_gen;
2853         ;
2854       }
2855     } catch (Throwable jjte000) {
2856           if (jjtc000) {
2857             jjtree.clearNodeScope(jjtn000);
2858             jjtc000 = false;
2859           } else {
2860             jjtree.popNode();
2861           }
2862           if (jjte000 instanceof RuntimeException) {
2863             {if (true) throw (RuntimeException)jjte000;}
2864           }
2865           if (jjte000 instanceof ParseException) {
2866             {if (true) throw (ParseException)jjte000;}
2867           }
2868           {if (true) throw (Error)jjte000;}
2869     } finally {
2870           if (jjtc000) {
2871             jjtree.closeNodeScope(jjtn000, true);
2872             jjtreeCloseNodeScope(jjtn000);
2873           }
2874     }
2875   }
2876 
2877 /* ECMA-262 5.1 Edition / June 2011 - Section 12.6: Iteration Statements */
2878   final public void IterationStatement() throws ParseException {
2879     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2880     case DO:
2881           ECMADoWhileStatement jjtn001 = new ECMADoWhileStatement(this, JJTDOWHILESTATEMENT);
2882           boolean jjtc001 = true;
2883           jjtree.openNodeScope(jjtn001);
2884           jjtreeOpenNodeScope(jjtn001);
2885       try {
2886         jj_consume_token(DO);
2887         Statement();
2888         jj_consume_token(WHILE);
2889         jj_consume_token(LPAREN);
2890         Expression();
2891         jj_consume_token(RPAREN);
2892         if (jj_2_25(2)) {
2893           jj_consume_token(SEMICOLON);
2894         } else {
2895           ;
2896         }
2897       } catch (Throwable jjte001) {
2898           if (jjtc001) {
2899             jjtree.clearNodeScope(jjtn001);
2900             jjtc001 = false;
2901           } else {
2902             jjtree.popNode();
2903           }
2904           if (jjte001 instanceof RuntimeException) {
2905             {if (true) throw (RuntimeException)jjte001;}
2906           }
2907           if (jjte001 instanceof ParseException) {
2908             {if (true) throw (ParseException)jjte001;}
2909           }
2910           {if (true) throw (Error)jjte001;}
2911       } finally {
2912           if (jjtc001) {
2913             jjtree.closeNodeScope(jjtn001, true);
2914             jjtreeCloseNodeScope(jjtn001);
2915           }
2916       }
2917       break;
2918     case WHILE:
2919           ECMAWhileStatement jjtn002 = new ECMAWhileStatement(this, JJTWHILESTATEMENT);
2920           boolean jjtc002 = true;
2921           jjtree.openNodeScope(jjtn002);
2922           jjtreeOpenNodeScope(jjtn002);
2923       try {
2924         jj_consume_token(WHILE);
2925         jj_consume_token(LPAREN);
2926         Expression();
2927         jj_consume_token(RPAREN);
2928         Statement();
2929       } catch (Throwable jjte002) {
2930           if (jjtc002) {
2931             jjtree.clearNodeScope(jjtn002);
2932             jjtc002 = false;
2933           } else {
2934             jjtree.popNode();
2935           }
2936           if (jjte002 instanceof RuntimeException) {
2937             {if (true) throw (RuntimeException)jjte002;}
2938           }
2939           if (jjte002 instanceof ParseException) {
2940             {if (true) throw (ParseException)jjte002;}
2941           }
2942           {if (true) throw (Error)jjte002;}
2943       } finally {
2944           if (jjtc002) {
2945             jjtree.closeNodeScope(jjtn002, true);
2946             jjtreeCloseNodeScope(jjtn002);
2947           }
2948       }
2949       break;
2950     default:
2951       jj_la1[68] = jj_gen;
2952       if (jj_2_26(2147483647)) {
2953                                                        ECMAForStatement jjtn006 = new ECMAForStatement(this, JJTFORSTATEMENT);
2954                                                        boolean jjtc006 = true;
2955                                                        jjtree.openNodeScope(jjtn006);
2956                                                        jjtreeOpenNodeScope(jjtn006);
2957         try {
2958           jj_consume_token(FOR);
2959           jj_consume_token(LPAREN);
2960                                                                    ECMAEmptyExpression jjtn003 = new ECMAEmptyExpression(this, JJTEMPTYEXPRESSION);
2961                                                                    boolean jjtc003 = true;
2962                                                                    jjtree.openNodeScope(jjtn003);
2963                                                                    jjtreeOpenNodeScope(jjtn003);
2964           try {
2965             switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2966             case TYPEOF:
2967             case NEW:
2968             case VOID:
2969             case FUNCTION:
2970             case THIS:
2971             case DELETE:
2972             case LBRACE:
2973             case LPAREN:
2974             case LBRACKET:
2975             case PLUS:
2976             case MINUS:
2977             case INC:
2978             case DEC:
2979             case BNOT:
2980             case NOT:
2981             case NULL_LITERAL:
2982             case BOOLEAN_LITERAL:
2983             case DECIMAL_LITERAL:
2984             case HEX_INTEGER_LITERAL:
2985             case STRING_LITERAL:
2986             case IDENTIFIER_NAME:
2987             case REGULAR_EXPRESSION_LITERAL:
2988               ExpressionNoIn();
2989               break;
2990             default:
2991               jj_la1[63] = jj_gen;
2992               ;
2993             }
2994           } catch (Throwable jjte003) {
2995                                                                    if (jjtc003) {
2996                                                                      jjtree.clearNodeScope(jjtn003);
2997                                                                      jjtc003 = false;
2998                                                                    } else {
2999                                                                      jjtree.popNode();
3000                                                                    }
3001                                                                    if (jjte003 instanceof RuntimeException) {
3002                                                                      {if (true) throw (RuntimeException)jjte003;}
3003                                                                    }
3004                                                                    if (jjte003 instanceof ParseException) {
3005                                                                      {if (true) throw (ParseException)jjte003;}
3006                                                                    }
3007                                                                    {if (true) throw (Error)jjte003;}
3008           } finally {
3009                                                                    if (jjtc003) {
3010                                                                      jjtree.closeNodeScope(jjtn003,  jjtree . nodeArity ( ) == 0);
3011                                                                      jjtreeCloseNodeScope(jjtn003);
3012                                                                    }
3013           }
3014           jj_consume_token(SEMICOLON);
3015                                                                                                                                      ECMAEmptyExpression jjtn004 = new ECMAEmptyExpression(this, JJTEMPTYEXPRESSION);
3016                                                                                                                                      boolean jjtc004 = true;
3017                                                                                                                                      jjtree.openNodeScope(jjtn004);
3018                                                                                                                                      jjtreeOpenNodeScope(jjtn004);
3019           try {
3020             switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3021             case TYPEOF:
3022             case NEW:
3023             case VOID:
3024             case FUNCTION:
3025             case THIS:
3026             case DELETE:
3027             case LBRACE:
3028             case LPAREN:
3029             case LBRACKET:
3030             case PLUS:
3031             case MINUS:
3032             case INC:
3033             case DEC:
3034             case BNOT:
3035             case NOT:
3036             case NULL_LITERAL:
3037             case BOOLEAN_LITERAL:
3038             case DECIMAL_LITERAL:
3039             case HEX_INTEGER_LITERAL:
3040             case STRING_LITERAL:
3041             case IDENTIFIER_NAME:
3042             case REGULAR_EXPRESSION_LITERAL:
3043               Expression();
3044               break;
3045             default:
3046               jj_la1[64] = jj_gen;
3047               ;
3048             }
3049           } catch (Throwable jjte004) {
3050                                                                                                                                      if (jjtc004) {
3051                                                                                                                                        jjtree.clearNodeScope(jjtn004);
3052                                                                                                                                        jjtc004 = false;
3053                                                                                                                                      } else {
3054                                                                                                                                        jjtree.popNode();
3055                                                                                                                                      }
3056                                                                                                                                      if (jjte004 instanceof RuntimeException) {
3057                                                                                                                                        {if (true) throw (RuntimeException)jjte004;}
3058                                                                                                                                      }
3059                                                                                                                                      if (jjte004 instanceof ParseException) {
3060                                                                                                                                        {if (true) throw (ParseException)jjte004;}
3061                                                                                                                                      }
3062                                                                                                                                      {if (true) throw (Error)jjte004;}
3063           } finally {
3064                                                                                                                                      if (jjtc004) {
3065                                                                                                                                        jjtree.closeNodeScope(jjtn004,  jjtree . nodeArity ( ) == 0);
3066                                                                                                                                        jjtreeCloseNodeScope(jjtn004);
3067                                                                                                                                      }
3068           }
3069           jj_consume_token(SEMICOLON);
3070                                                                                                                                                                                                    ECMAEmptyExpression jjtn005 = new ECMAEmptyExpression(this, JJTEMPTYEXPRESSION);
3071                                                                                                                                                                                                    boolean jjtc005 = true;
3072                                                                                                                                                                                                    jjtree.openNodeScope(jjtn005);
3073                                                                                                                                                                                                    jjtreeOpenNodeScope(jjtn005);
3074           try {
3075             switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3076             case TYPEOF:
3077             case NEW:
3078             case VOID:
3079             case FUNCTION:
3080             case THIS:
3081             case DELETE:
3082             case LBRACE:
3083             case LPAREN:
3084             case LBRACKET:
3085             case PLUS:
3086             case MINUS:
3087             case INC:
3088             case DEC:
3089             case BNOT:
3090             case NOT:
3091             case NULL_LITERAL:
3092             case BOOLEAN_LITERAL:
3093             case DECIMAL_LITERAL:
3094             case HEX_INTEGER_LITERAL:
3095             case STRING_LITERAL:
3096             case IDENTIFIER_NAME:
3097             case REGULAR_EXPRESSION_LITERAL:
3098               Expression();
3099               break;
3100             default:
3101               jj_la1[65] = jj_gen;
3102               ;
3103             }
3104           } catch (Throwable jjte005) {
3105                                                                                                                                                                                                    if (jjtc005) {
3106                                                                                                                                                                                                      jjtree.clearNodeScope(jjtn005);
3107                                                                                                                                                                                                      jjtc005 = false;
3108                                                                                                                                                                                                    } else {
3109                                                                                                                                                                                                      jjtree.popNode();
3110                                                                                                                                                                                                    }
3111                                                                                                                                                                                                    if (jjte005 instanceof RuntimeException) {
3112                                                                                                                                                                                                      {if (true) throw (RuntimeException)jjte005;}
3113                                                                                                                                                                                                    }
3114                                                                                                                                                                                                    if (jjte005 instanceof ParseException) {
3115                                                                                                                                                                                                      {if (true) throw (ParseException)jjte005;}
3116                                                                                                                                                                                                    }
3117                                                                                                                                                                                                    {if (true) throw (Error)jjte005;}
3118           } finally {
3119                                                                                                                                                                                                    if (jjtc005) {
3120                                                                                                                                                                                                      jjtree.closeNodeScope(jjtn005,  jjtree . nodeArity ( ) == 0);
3121                                                                                                                                                                                                      jjtreeCloseNodeScope(jjtn005);
3122                                                                                                                                                                                                    }
3123           }
3124           jj_consume_token(RPAREN);
3125           Statement();
3126         } catch (Throwable jjte006) {
3127                                                        if (jjtc006) {
3128                                                          jjtree.clearNodeScope(jjtn006);
3129                                                          jjtc006 = false;
3130                                                        } else {
3131                                                          jjtree.popNode();
3132                                                        }
3133                                                        if (jjte006 instanceof RuntimeException) {
3134                                                          {if (true) throw (RuntimeException)jjte006;}
3135                                                        }
3136                                                        if (jjte006 instanceof ParseException) {
3137                                                          {if (true) throw (ParseException)jjte006;}
3138                                                        }
3139                                                        {if (true) throw (Error)jjte006;}
3140         } finally {
3141                                                        if (jjtc006) {
3142                                                          jjtree.closeNodeScope(jjtn006, true);
3143                                                          jjtreeCloseNodeScope(jjtn006);
3144                                                        }
3145         }
3146       } else if (jj_2_27(2147483647)) {
3147                                                                    ECMAForVarStatement jjtn009 = new ECMAForVarStatement(this, JJTFORVARSTATEMENT);
3148                                                                    boolean jjtc009 = true;
3149                                                                    jjtree.openNodeScope(jjtn009);
3150                                                                    jjtreeOpenNodeScope(jjtn009);
3151         try {
3152           jj_consume_token(FOR);
3153           jj_consume_token(LPAREN);
3154           jj_consume_token(VAR);
3155           VariableDeclarationList();
3156           jj_consume_token(SEMICOLON);
3157                                                                                                                    ECMAEmptyExpression jjtn007 = new ECMAEmptyExpression(this, JJTEMPTYEXPRESSION);
3158                                                                                                                    boolean jjtc007 = true;
3159                                                                                                                    jjtree.openNodeScope(jjtn007);
3160                                                                                                                    jjtreeOpenNodeScope(jjtn007);
3161           try {
3162             switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3163             case TYPEOF:
3164             case NEW:
3165             case VOID:
3166             case FUNCTION:
3167             case THIS:
3168             case DELETE:
3169             case LBRACE:
3170             case LPAREN:
3171             case LBRACKET:
3172             case PLUS:
3173             case MINUS:
3174             case INC:
3175             case DEC:
3176             case BNOT:
3177             case NOT:
3178             case NULL_LITERAL:
3179             case BOOLEAN_LITERAL:
3180             case DECIMAL_LITERAL:
3181             case HEX_INTEGER_LITERAL:
3182             case STRING_LITERAL:
3183             case IDENTIFIER_NAME:
3184             case REGULAR_EXPRESSION_LITERAL:
3185               Expression();
3186               break;
3187             default:
3188               jj_la1[66] = jj_gen;
3189               ;
3190             }
3191           } catch (Throwable jjte007) {
3192                                                                                                                    if (jjtc007) {
3193                                                                                                                      jjtree.clearNodeScope(jjtn007);
3194                                                                                                                      jjtc007 = false;
3195                                                                                                                    } else {
3196                                                                                                                      jjtree.popNode();
3197                                                                                                                    }
3198                                                                                                                    if (jjte007 instanceof RuntimeException) {
3199                                                                                                                      {if (true) throw (RuntimeException)jjte007;}
3200                                                                                                                    }
3201                                                                                                                    if (jjte007 instanceof ParseException) {
3202                                                                                                                      {if (true) throw (ParseException)jjte007;}
3203                                                                                                                    }
3204                                                                                                                    {if (true) throw (Error)jjte007;}
3205           } finally {
3206                                                                                                                    if (jjtc007) {
3207                                                                                                                      jjtree.closeNodeScope(jjtn007,  jjtree . nodeArity ( ) == 0);
3208                                                                                                                      jjtreeCloseNodeScope(jjtn007);
3209                                                                                                                    }
3210           }
3211           jj_consume_token(SEMICOLON);
3212                                                                                                                                                                                  ECMAEmptyExpression jjtn008 = new ECMAEmptyExpression(this, JJTEMPTYEXPRESSION);
3213                                                                                                                                                                                  boolean jjtc008 = true;
3214                                                                                                                                                                                  jjtree.openNodeScope(jjtn008);
3215                                                                                                                                                                                  jjtreeOpenNodeScope(jjtn008);
3216           try {
3217             switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3218             case TYPEOF:
3219             case NEW:
3220             case VOID:
3221             case FUNCTION:
3222             case THIS:
3223             case DELETE:
3224             case LBRACE:
3225             case LPAREN:
3226             case LBRACKET:
3227             case PLUS:
3228             case MINUS:
3229             case INC:
3230             case DEC:
3231             case BNOT:
3232             case NOT:
3233             case NULL_LITERAL:
3234             case BOOLEAN_LITERAL:
3235             case DECIMAL_LITERAL:
3236             case HEX_INTEGER_LITERAL:
3237             case STRING_LITERAL:
3238             case IDENTIFIER_NAME:
3239             case REGULAR_EXPRESSION_LITERAL:
3240               Expression();
3241               break;
3242             default:
3243               jj_la1[67] = jj_gen;
3244               ;
3245             }
3246           } catch (Throwable jjte008) {
3247                                                                                                                                                                                  if (jjtc008) {
3248                                                                                                                                                                                    jjtree.clearNodeScope(jjtn008);
3249                                                                                                                                                                                    jjtc008 = false;
3250                                                                                                                                                                                  } else {
3251                                                                                                                                                                                    jjtree.popNode();
3252                                                                                                                                                                                  }
3253                                                                                                                                                                                  if (jjte008 instanceof RuntimeException) {
3254                                                                                                                                                                                    {if (true) throw (RuntimeException)jjte008;}
3255                                                                                                                                                                                  }
3256                                                                                                                                                                                  if (jjte008 instanceof ParseException) {
3257                                                                                                                                                                                    {if (true) throw (ParseException)jjte008;}
3258                                                                                                                                                                                  }
3259                                                                                                                                                                                  {if (true) throw (Error)jjte008;}
3260           } finally {
3261                                                                                                                                                                                  if (jjtc008) {
3262                                                                                                                                                                                    jjtree.closeNodeScope(jjtn008,  jjtree . nodeArity ( ) == 0);
3263                                                                                                                                                                                    jjtreeCloseNodeScope(jjtn008);
3264                                                                                                                                                                                  }
3265           }
3266           jj_consume_token(RPAREN);
3267           Statement();
3268         } catch (Throwable jjte009) {
3269                                                                    if (jjtc009) {
3270                                                                      jjtree.clearNodeScope(jjtn009);
3271                                                                      jjtc009 = false;
3272                                                                    } else {
3273                                                                      jjtree.popNode();
3274                                                                    }
3275                                                                    if (jjte009 instanceof RuntimeException) {
3276                                                                      {if (true) throw (RuntimeException)jjte009;}
3277                                                                    }
3278                                                                    if (jjte009 instanceof ParseException) {
3279                                                                      {if (true) throw (ParseException)jjte009;}
3280                                                                    }
3281                                                                    {if (true) throw (Error)jjte009;}
3282         } finally {
3283                                                                    if (jjtc009) {
3284                                                                      jjtree.closeNodeScope(jjtn009, true);
3285                                                                      jjtreeCloseNodeScope(jjtn009);
3286                                                                    }
3287         }
3288       } else if (jj_2_28(2147483647)) {
3289                                                                     ECMAForVarInStatement jjtn010 = new ECMAForVarInStatement(this, JJTFORVARINSTATEMENT);
3290                                                                     boolean jjtc010 = true;
3291                                                                     jjtree.openNodeScope(jjtn010);
3292                                                                     jjtreeOpenNodeScope(jjtn010);
3293         try {
3294           jj_consume_token(FOR);
3295           jj_consume_token(LPAREN);
3296           jj_consume_token(VAR);
3297           VariableDeclarationNoIn();
3298           jj_consume_token(IN);
3299           Expression();
3300           jj_consume_token(RPAREN);
3301           Statement();
3302         } catch (Throwable jjte010) {
3303                                                                     if (jjtc010) {
3304                                                                       jjtree.clearNodeScope(jjtn010);
3305                                                                       jjtc010 = false;
3306                                                                     } else {
3307                                                                       jjtree.popNode();
3308                                                                     }
3309                                                                     if (jjte010 instanceof RuntimeException) {
3310                                                                       {if (true) throw (RuntimeException)jjte010;}
3311                                                                     }
3312                                                                     if (jjte010 instanceof ParseException) {
3313                                                                       {if (true) throw (ParseException)jjte010;}
3314                                                                     }
3315                                                                     {if (true) throw (Error)jjte010;}
3316         } finally {
3317                                                                     if (jjtc010) {
3318                                                                       jjtree.closeNodeScope(jjtn010, true);
3319                                                                       jjtreeCloseNodeScope(jjtn010);
3320                                                                     }
3321         }
3322       } else {
3323         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3324         case FOR:
3325           ECMAForInStatement jjtn011 = new ECMAForInStatement(this, JJTFORINSTATEMENT);
3326           boolean jjtc011 = true;
3327           jjtree.openNodeScope(jjtn011);
3328           jjtreeOpenNodeScope(jjtn011);
3329           try {
3330             jj_consume_token(FOR);
3331             jj_consume_token(LPAREN);
3332             LeftHandSideExpression();
3333             jj_consume_token(IN);
3334             Expression();
3335             jj_consume_token(RPAREN);
3336             Statement();
3337           } catch (Throwable jjte011) {
3338           if (jjtc011) {
3339             jjtree.clearNodeScope(jjtn011);
3340             jjtc011 = false;
3341           } else {
3342             jjtree.popNode();
3343           }
3344           if (jjte011 instanceof RuntimeException) {
3345             {if (true) throw (RuntimeException)jjte011;}
3346           }
3347           if (jjte011 instanceof ParseException) {
3348             {if (true) throw (ParseException)jjte011;}
3349           }
3350           {if (true) throw (Error)jjte011;}
3351           } finally {
3352           if (jjtc011) {
3353             jjtree.closeNodeScope(jjtn011, true);
3354             jjtreeCloseNodeScope(jjtn011);
3355           }
3356           }
3357           break;
3358         default:
3359           jj_la1[69] = jj_gen;
3360           jj_consume_token(-1);
3361           throw new ParseException();
3362         }
3363       }
3364     }
3365   }
3366 
3367 /* ECMA-262 5.1 Edition / June 2011 - Section 12.7: The continue Statement */
3368   final public void ContinueStatement() throws ParseException {
3369  /*@bgen(jjtree) ContinueStatement */
3370   ECMAContinueStatement jjtn000 = new ECMAContinueStatement(this, JJTCONTINUESTATEMENT);
3371   boolean jjtc000 = true;
3372   jjtree.openNodeScope(jjtn000);
3373   jjtreeOpenNodeScope(jjtn000);
3374     try {
3375       jj_consume_token(CONTINUE);
3376       if (jj_2_29(2147483647)) {
3377         Identifier();
3378       } else {
3379         ;
3380       }
3381       if (jj_2_30(2147483647)) {
3382         jj_consume_token(SEMICOLON);
3383       } else {
3384         ;
3385       }
3386     } catch (Throwable jjte000) {
3387           if (jjtc000) {
3388             jjtree.clearNodeScope(jjtn000);
3389             jjtc000 = false;
3390           } else {
3391             jjtree.popNode();
3392           }
3393           if (jjte000 instanceof RuntimeException) {
3394             {if (true) throw (RuntimeException)jjte000;}
3395           }
3396           if (jjte000 instanceof ParseException) {
3397             {if (true) throw (ParseException)jjte000;}
3398           }
3399           {if (true) throw (Error)jjte000;}
3400     } finally {
3401           if (jjtc000) {
3402             jjtree.closeNodeScope(jjtn000, true);
3403             jjtreeCloseNodeScope(jjtn000);
3404           }
3405     }
3406   }
3407 
3408 /* ECMA-262 5.1 Edition / June 2011 - Section 12.8: The break Statement */
3409   final public void BreakStatement() throws ParseException {
3410  /*@bgen(jjtree) BreakStatement */
3411   ECMABreakStatement jjtn000 = new ECMABreakStatement(this, JJTBREAKSTATEMENT);
3412   boolean jjtc000 = true;
3413   jjtree.openNodeScope(jjtn000);
3414   jjtreeOpenNodeScope(jjtn000);
3415     try {
3416       jj_consume_token(BREAK);
3417       if (jj_2_31(2147483647)) {
3418         Identifier();
3419       } else {
3420         ;
3421       }
3422       if (jj_2_32(2147483647)) {
3423         jj_consume_token(SEMICOLON);
3424       } else {
3425         ;
3426       }
3427     } catch (Throwable jjte000) {
3428           if (jjtc000) {
3429             jjtree.clearNodeScope(jjtn000);
3430             jjtc000 = false;
3431           } else {
3432             jjtree.popNode();
3433           }
3434           if (jjte000 instanceof RuntimeException) {
3435             {if (true) throw (RuntimeException)jjte000;}
3436           }
3437           if (jjte000 instanceof ParseException) {
3438             {if (true) throw (ParseException)jjte000;}
3439           }
3440           {if (true) throw (Error)jjte000;}
3441     } finally {
3442           if (jjtc000) {
3443             jjtree.closeNodeScope(jjtn000, true);
3444             jjtreeCloseNodeScope(jjtn000);
3445           }
3446     }
3447   }
3448 
3449 /* ECMA-262 5.1 Edition / June 2011 - Section 12.9 The return Statement */
3450   final public void ReturnStatement() throws ParseException {
3451  /*@bgen(jjtree) ReturnStatement */
3452   ECMAReturnStatement jjtn000 = new ECMAReturnStatement(this, JJTRETURNSTATEMENT);
3453   boolean jjtc000 = true;
3454   jjtree.openNodeScope(jjtn000);
3455   jjtreeOpenNodeScope(jjtn000);
3456     try {
3457       jj_consume_token(RETURN);
3458       if (jj_2_33(2147483647)) {
3459         Expression();
3460       } else {
3461         ;
3462       }
3463       if (jj_2_34(2147483647)) {
3464         jj_consume_token(SEMICOLON);
3465       } else {
3466         ;
3467       }
3468     } catch (Throwable jjte000) {
3469           if (jjtc000) {
3470             jjtree.clearNodeScope(jjtn000);
3471             jjtc000 = false;
3472           } else {
3473             jjtree.popNode();
3474           }
3475           if (jjte000 instanceof RuntimeException) {
3476             {if (true) throw (RuntimeException)jjte000;}
3477           }
3478           if (jjte000 instanceof ParseException) {
3479             {if (true) throw (ParseException)jjte000;}
3480           }
3481           {if (true) throw (Error)jjte000;}
3482     } finally {
3483           if (jjtc000) {
3484             jjtree.closeNodeScope(jjtn000, true);
3485             jjtreeCloseNodeScope(jjtn000);
3486           }
3487     }
3488   }
3489 
3490 /* ECMA-262 5.1 Edition / June 2011 - Section 12.10: The with Statement */
3491   final public void WithStatement() throws ParseException {
3492  /*@bgen(jjtree) WithStatement */
3493   ECMAWithStatement jjtn000 = new ECMAWithStatement(this, JJTWITHSTATEMENT);
3494   boolean jjtc000 = true;
3495   jjtree.openNodeScope(jjtn000);
3496   jjtreeOpenNodeScope(jjtn000);
3497     try {
3498       jj_consume_token(WITH);
3499       jj_consume_token(LPAREN);
3500       Expression();
3501       jj_consume_token(RPAREN);
3502       Statement();
3503     } catch (Throwable jjte000) {
3504           if (jjtc000) {
3505             jjtree.clearNodeScope(jjtn000);
3506             jjtc000 = false;
3507           } else {
3508             jjtree.popNode();
3509           }
3510           if (jjte000 instanceof RuntimeException) {
3511             {if (true) throw (RuntimeException)jjte000;}
3512           }
3513           if (jjte000 instanceof ParseException) {
3514             {if (true) throw (ParseException)jjte000;}
3515           }
3516           {if (true) throw (Error)jjte000;}
3517     } finally {
3518           if (jjtc000) {
3519             jjtree.closeNodeScope(jjtn000, true);
3520             jjtreeCloseNodeScope(jjtn000);
3521           }
3522     }
3523   }
3524 
3525 /* ECMA-262 5.1 Edition / June 2011 - 12.11 The switch Statement */
3526   final public void SwitchStatement() throws ParseException {
3527  /*@bgen(jjtree) SwitchStatement */
3528   ECMASwitchStatement jjtn000 = new ECMASwitchStatement(this, JJTSWITCHSTATEMENT);
3529   boolean jjtc000 = true;
3530   jjtree.openNodeScope(jjtn000);
3531   jjtreeOpenNodeScope(jjtn000);
3532     try {
3533       jj_consume_token(SWITCH);
3534       jj_consume_token(LPAREN);
3535       Expression();
3536       jj_consume_token(RPAREN);
3537       CaseBlock();
3538     } catch (Throwable jjte000) {
3539           if (jjtc000) {
3540             jjtree.clearNodeScope(jjtn000);
3541             jjtc000 = false;
3542           } else {
3543             jjtree.popNode();
3544           }
3545           if (jjte000 instanceof RuntimeException) {
3546             {if (true) throw (RuntimeException)jjte000;}
3547           }
3548           if (jjte000 instanceof ParseException) {
3549             {if (true) throw (ParseException)jjte000;}
3550           }
3551           {if (true) throw (Error)jjte000;}
3552     } finally {
3553           if (jjtc000) {
3554             jjtree.closeNodeScope(jjtn000, true);
3555             jjtreeCloseNodeScope(jjtn000);
3556           }
3557     }
3558   }
3559 
3560   final public void CaseBlock() throws ParseException {
3561  /*@bgen(jjtree) CaseBlock */
3562   ECMACaseBlock jjtn000 = new ECMACaseBlock(this, JJTCASEBLOCK);
3563   boolean jjtc000 = true;
3564   jjtree.openNodeScope(jjtn000);
3565   jjtreeOpenNodeScope(jjtn000);
3566     try {
3567       jj_consume_token(LBRACE);
3568       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3569       case CASE:
3570         CaseClauses();
3571         break;
3572       default:
3573         jj_la1[70] = jj_gen;
3574         ;
3575       }
3576       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3577       case RBRACE:
3578         jj_consume_token(RBRACE);
3579         break;
3580       case DEFAULT_:
3581         DefaultClause();
3582         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3583         case CASE:
3584           CaseClauses();
3585           break;
3586         default:
3587           jj_la1[71] = jj_gen;
3588           ;
3589         }
3590         jj_consume_token(RBRACE);
3591         break;
3592       default:
3593         jj_la1[72] = jj_gen;
3594         jj_consume_token(-1);
3595         throw new ParseException();
3596       }
3597     } catch (Throwable jjte000) {
3598           if (jjtc000) {
3599             jjtree.clearNodeScope(jjtn000);
3600             jjtc000 = false;
3601           } else {
3602             jjtree.popNode();
3603           }
3604           if (jjte000 instanceof RuntimeException) {
3605             {if (true) throw (RuntimeException)jjte000;}
3606           }
3607           if (jjte000 instanceof ParseException) {
3608             {if (true) throw (ParseException)jjte000;}
3609           }
3610           {if (true) throw (Error)jjte000;}
3611     } finally {
3612           if (jjtc000) {
3613             jjtree.closeNodeScope(jjtn000, true);
3614             jjtreeCloseNodeScope(jjtn000);
3615           }
3616     }
3617   }
3618 
3619   final public void CaseClauses() throws ParseException {
3620     label_29:
3621     while (true) {
3622       CaseClause();
3623       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3624       case CASE:
3625         ;
3626         break;
3627       default:
3628         jj_la1[73] = jj_gen;
3629         break label_29;
3630       }
3631     }
3632   }
3633 
3634   final public void CaseClause() throws ParseException {
3635  /*@bgen(jjtree) CaseClause */
3636   ECMACaseClause jjtn000 = new ECMACaseClause(this, JJTCASECLAUSE);
3637   boolean jjtc000 = true;
3638   jjtree.openNodeScope(jjtn000);
3639   jjtreeOpenNodeScope(jjtn000);
3640     try {
3641             ECMACase jjtn001 = new ECMACase(this, JJTCASE);
3642             boolean jjtc001 = true;
3643             jjtree.openNodeScope(jjtn001);
3644             jjtreeOpenNodeScope(jjtn001);
3645       try {
3646         jj_consume_token(CASE);
3647         Expression();
3648         jj_consume_token(COLON);
3649       } catch (Throwable jjte001) {
3650             if (jjtc001) {
3651               jjtree.clearNodeScope(jjtn001);
3652               jjtc001 = false;
3653             } else {
3654               jjtree.popNode();
3655             }
3656             if (jjte001 instanceof RuntimeException) {
3657               {if (true) throw (RuntimeException)jjte001;}
3658             }
3659             if (jjte001 instanceof ParseException) {
3660               {if (true) throw (ParseException)jjte001;}
3661             }
3662             {if (true) throw (Error)jjte001;}
3663       } finally {
3664             if (jjtc001) {
3665               jjtree.closeNodeScope(jjtn001, true);
3666               jjtreeCloseNodeScope(jjtn001);
3667             }
3668       }
3669       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3670       case BREAK:
3671       case DO:
3672       case TYPEOF:
3673       case NEW:
3674       case VAR:
3675       case RETURN:
3676       case VOID:
3677       case CONTINUE:
3678       case FOR:
3679       case SWITCH:
3680       case WHILE:
3681       case DEBUGGER:
3682       case FUNCTION:
3683       case THIS:
3684       case WITH:
3685       case IF:
3686       case THROW:
3687       case DELETE:
3688       case TRY:
3689       case LBRACE:
3690       case LPAREN:
3691       case LBRACKET:
3692       case SEMICOLON:
3693       case PLUS:
3694       case MINUS:
3695       case INC:
3696       case DEC:
3697       case BNOT:
3698       case NOT:
3699       case NULL_LITERAL:
3700       case BOOLEAN_LITERAL:
3701       case DECIMAL_LITERAL:
3702       case HEX_INTEGER_LITERAL:
3703       case STRING_LITERAL:
3704       case IDENTIFIER_NAME:
3705       case REGULAR_EXPRESSION_LITERAL:
3706       case JAVA_STATEMENT:
3707         StatementList();
3708         break;
3709       default:
3710         jj_la1[74] = jj_gen;
3711         ;
3712       }
3713     } catch (Throwable jjte000) {
3714           if (jjtc000) {
3715             jjtree.clearNodeScope(jjtn000);
3716             jjtc000 = false;
3717           } else {
3718             jjtree.popNode();
3719           }
3720           if (jjte000 instanceof RuntimeException) {
3721             {if (true) throw (RuntimeException)jjte000;}
3722           }
3723           if (jjte000 instanceof ParseException) {
3724             {if (true) throw (ParseException)jjte000;}
3725           }
3726           {if (true) throw (Error)jjte000;}
3727     } finally {
3728           if (jjtc000) {
3729             jjtree.closeNodeScope(jjtn000, true);
3730             jjtreeCloseNodeScope(jjtn000);
3731           }
3732     }
3733   }
3734 
3735   final public void DefaultClause() throws ParseException {
3736  /*@bgen(jjtree) CaseClause */
3737   ECMACaseClause jjtn000 = new ECMACaseClause(this, JJTCASECLAUSE);
3738   boolean jjtc000 = true;
3739   jjtree.openNodeScope(jjtn000);
3740   jjtreeOpenNodeScope(jjtn000);
3741     try {
3742             ECMACase jjtn001 = new ECMACase(this, JJTCASE);
3743             boolean jjtc001 = true;
3744             jjtree.openNodeScope(jjtn001);
3745             jjtreeOpenNodeScope(jjtn001);
3746       try {
3747         jj_consume_token(DEFAULT_);
3748         jj_consume_token(COLON);
3749       } finally {
3750             if (jjtc001) {
3751               jjtree.closeNodeScope(jjtn001, true);
3752               jjtreeCloseNodeScope(jjtn001);
3753             }
3754       }
3755       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3756       case BREAK:
3757       case DO:
3758       case TYPEOF:
3759       case NEW:
3760       case VAR:
3761       case RETURN:
3762       case VOID:
3763       case CONTINUE:
3764       case FOR:
3765       case SWITCH:
3766       case WHILE:
3767       case DEBUGGER:
3768       case FUNCTION:
3769       case THIS:
3770       case WITH:
3771       case IF:
3772       case THROW:
3773       case DELETE:
3774       case TRY:
3775       case LBRACE:
3776       case LPAREN:
3777       case LBRACKET:
3778       case SEMICOLON:
3779       case PLUS:
3780       case MINUS:
3781       case INC:
3782       case DEC:
3783       case BNOT:
3784       case NOT:
3785       case NULL_LITERAL:
3786       case BOOLEAN_LITERAL:
3787       case DECIMAL_LITERAL:
3788       case HEX_INTEGER_LITERAL:
3789       case STRING_LITERAL:
3790       case IDENTIFIER_NAME:
3791       case REGULAR_EXPRESSION_LITERAL:
3792       case JAVA_STATEMENT:
3793         StatementList();
3794         break;
3795       default:
3796         jj_la1[75] = jj_gen;
3797         ;
3798       }
3799     } catch (Throwable jjte000) {
3800           if (jjtc000) {
3801             jjtree.clearNodeScope(jjtn000);
3802             jjtc000 = false;
3803           } else {
3804             jjtree.popNode();
3805           }
3806           if (jjte000 instanceof RuntimeException) {
3807             {if (true) throw (RuntimeException)jjte000;}
3808           }
3809           if (jjte000 instanceof ParseException) {
3810             {if (true) throw (ParseException)jjte000;}
3811           }
3812           {if (true) throw (Error)jjte000;}
3813     } finally {
3814           if (jjtc000) {
3815             jjtree.closeNodeScope(jjtn000, true);
3816             jjtreeCloseNodeScope(jjtn000);
3817           }
3818     }
3819   }
3820 
3821 /* ECMA-262 5.1 Edition / June 2011 - Section 12.12: Labelled Statements */
3822   final public void LabelledStatement() throws ParseException {
3823  /*@bgen(jjtree) LabelledStatement */
3824   ECMALabelledStatement jjtn000 = new ECMALabelledStatement(this, JJTLABELLEDSTATEMENT);
3825   boolean jjtc000 = true;
3826   jjtree.openNodeScope(jjtn000);
3827   jjtreeOpenNodeScope(jjtn000);
3828     try {
3829       Identifier();
3830       jj_consume_token(COLON);
3831       Statement();
3832     } catch (Throwable jjte000) {
3833           if (jjtc000) {
3834             jjtree.clearNodeScope(jjtn000);
3835             jjtc000 = false;
3836           } else {
3837             jjtree.popNode();
3838           }
3839           if (jjte000 instanceof RuntimeException) {
3840             {if (true) throw (RuntimeException)jjte000;}
3841           }
3842           if (jjte000 instanceof ParseException) {
3843             {if (true) throw (ParseException)jjte000;}
3844           }
3845           {if (true) throw (Error)jjte000;}
3846     } finally {
3847           if (jjtc000) {
3848             jjtree.closeNodeScope(jjtn000, true);
3849             jjtreeCloseNodeScope(jjtn000);
3850           }
3851     }
3852   }
3853 
3854   final public void ThrowStatement() throws ParseException {
3855  /*@bgen(jjtree) ThrowStatement */
3856   ECMAThrowStatement jjtn000 = new ECMAThrowStatement(this, JJTTHROWSTATEMENT);
3857   boolean jjtc000 = true;
3858   jjtree.openNodeScope(jjtn000);
3859   jjtreeOpenNodeScope(jjtn000);
3860     try {
3861       jj_consume_token(THROW);
3862       Expression();
3863       if (jj_2_35(2147483647)) {
3864         jj_consume_token(SEMICOLON);
3865       } else {
3866         ;
3867       }
3868     } catch (Throwable jjte000) {
3869           if (jjtc000) {
3870             jjtree.clearNodeScope(jjtn000);
3871             jjtc000 = false;
3872           } else {
3873             jjtree.popNode();
3874           }
3875           if (jjte000 instanceof RuntimeException) {
3876             {if (true) throw (RuntimeException)jjte000;}
3877           }
3878           if (jjte000 instanceof ParseException) {
3879             {if (true) throw (ParseException)jjte000;}
3880           }
3881           {if (true) throw (Error)jjte000;}
3882     } finally {
3883           if (jjtc000) {
3884             jjtree.closeNodeScope(jjtn000, true);
3885             jjtreeCloseNodeScope(jjtn000);
3886           }
3887     }
3888   }
3889 
3890   final public void TryStatement() throws ParseException {
3891  /*@bgen(jjtree) TryStatement */
3892   ECMATryStatement jjtn000 = new ECMATryStatement(this, JJTTRYSTATEMENT);
3893   boolean jjtc000 = true;
3894   jjtree.openNodeScope(jjtn000);
3895   jjtreeOpenNodeScope(jjtn000);
3896     try {
3897       jj_consume_token(TRY);
3898       Block();
3899       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3900       case FINALLY:
3901         Finally();
3902         break;
3903       case CATCH:
3904         Catch();
3905         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3906         case FINALLY:
3907           Finally();
3908           break;
3909         default:
3910           jj_la1[76] = jj_gen;
3911           ;
3912         }
3913         break;
3914       default:
3915         jj_la1[77] = jj_gen;
3916         jj_consume_token(-1);
3917         throw new ParseException();
3918       }
3919     } catch (Throwable jjte000) {
3920           if (jjtc000) {
3921             jjtree.clearNodeScope(jjtn000);
3922             jjtc000 = false;
3923           } else {
3924             jjtree.popNode();
3925           }
3926           if (jjte000 instanceof RuntimeException) {
3927             {if (true) throw (RuntimeException)jjte000;}
3928           }
3929           if (jjte000 instanceof ParseException) {
3930             {if (true) throw (ParseException)jjte000;}
3931           }
3932           {if (true) throw (Error)jjte000;}
3933     } finally {
3934           if (jjtc000) {
3935             jjtree.closeNodeScope(jjtn000, true);
3936             jjtreeCloseNodeScope(jjtn000);
3937           }
3938     }
3939   }
3940 
3941   final public void Catch() throws ParseException {
3942  /*@bgen(jjtree) Catch */
3943   ECMACatch jjtn000 = new ECMACatch(this, JJTCATCH);
3944   boolean jjtc000 = true;
3945   jjtree.openNodeScope(jjtn000);
3946   jjtreeOpenNodeScope(jjtn000);
3947     try {
3948       jj_consume_token(CATCH);
3949       jj_consume_token(LPAREN);
3950       Identifier();
3951       jj_consume_token(RPAREN);
3952       Block();
3953     } catch (Throwable jjte000) {
3954           if (jjtc000) {
3955             jjtree.clearNodeScope(jjtn000);
3956             jjtc000 = false;
3957           } else {
3958             jjtree.popNode();
3959           }
3960           if (jjte000 instanceof RuntimeException) {
3961             {if (true) throw (RuntimeException)jjte000;}
3962           }
3963           if (jjte000 instanceof ParseException) {
3964             {if (true) throw (ParseException)jjte000;}
3965           }
3966           {if (true) throw (Error)jjte000;}
3967     } finally {
3968           if (jjtc000) {
3969             jjtree.closeNodeScope(jjtn000, true);
3970             jjtreeCloseNodeScope(jjtn000);
3971           }
3972     }
3973   }
3974 
3975   final public void Finally() throws ParseException {
3976  /*@bgen(jjtree) Finally */
3977   ECMAFinally jjtn000 = new ECMAFinally(this, JJTFINALLY);
3978   boolean jjtc000 = true;
3979   jjtree.openNodeScope(jjtn000);
3980   jjtreeOpenNodeScope(jjtn000);
3981     try {
3982       jj_consume_token(FINALLY);
3983       Block();
3984     } catch (Throwable jjte000) {
3985           if (jjtc000) {
3986             jjtree.clearNodeScope(jjtn000);
3987             jjtc000 = false;
3988           } else {
3989             jjtree.popNode();
3990           }
3991           if (jjte000 instanceof RuntimeException) {
3992             {if (true) throw (RuntimeException)jjte000;}
3993           }
3994           if (jjte000 instanceof ParseException) {
3995             {if (true) throw (ParseException)jjte000;}
3996           }
3997           {if (true) throw (Error)jjte000;}
3998     } finally {
3999           if (jjtc000) {
4000             jjtree.closeNodeScope(jjtn000, true);
4001             jjtreeCloseNodeScope(jjtn000);
4002           }
4003     }
4004   }
4005 
4006 /* ECMA-262 5.1 Edition / June 2011 - Section 12.15 The debugger Statement */
4007   final public void DebuggerStatement() throws ParseException {
4008  /*@bgen(jjtree) DebuggerStatement */
4009   ECMADebuggerStatement jjtn000 = new ECMADebuggerStatement(this, JJTDEBUGGERSTATEMENT);
4010   boolean jjtc000 = true;
4011   jjtree.openNodeScope(jjtn000);
4012   jjtreeOpenNodeScope(jjtn000);
4013     try {
4014       jj_consume_token(DEBUGGER);
4015       if (jj_2_36(2147483647)) {
4016         jj_consume_token(SEMICOLON);
4017       } else {
4018         ;
4019       }
4020     } finally {
4021           if (jjtc000) {
4022             jjtree.closeNodeScope(jjtn000, true);
4023             jjtreeCloseNodeScope(jjtn000);
4024           }
4025     }
4026   }
4027 
4028 /* ECMA-262 5.1 Edition / June 2011 - Section 13: Function Definition */
4029   final public void FunctionDeclaration() throws ParseException {
4030  /*@bgen(jjtree) FunctionDeclaration */
4031   ECMAFunctionDeclaration jjtn000 = new ECMAFunctionDeclaration(this, JJTFUNCTIONDECLARATION);
4032   boolean jjtc000 = true;
4033   jjtree.openNodeScope(jjtn000);
4034   jjtreeOpenNodeScope(jjtn000);
4035     try {
4036       jj_consume_token(FUNCTION);
4037       Identifier();
4038                                   ECMAFormalParameterList jjtn001 = new ECMAFormalParameterList(this, JJTFORMALPARAMETERLIST);
4039                                   boolean jjtc001 = true;
4040                                   jjtree.openNodeScope(jjtn001);
4041                                   jjtreeOpenNodeScope(jjtn001);
4042       try {
4043         jj_consume_token(LPAREN);
4044         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4045         case IDENTIFIER_NAME:
4046           FormalParameterList();
4047           break;
4048         default:
4049           jj_la1[78] = jj_gen;
4050           ;
4051         }
4052         jj_consume_token(RPAREN);
4053       } catch (Throwable jjte001) {
4054                                   if (jjtc001) {
4055                                     jjtree.clearNodeScope(jjtn001);
4056                                     jjtc001 = false;
4057                                   } else {
4058                                     jjtree.popNode();
4059                                   }
4060                                   if (jjte001 instanceof RuntimeException) {
4061                                     {if (true) throw (RuntimeException)jjte001;}
4062                                   }
4063                                   if (jjte001 instanceof ParseException) {
4064                                     {if (true) throw (ParseException)jjte001;}
4065                                   }
4066                                   {if (true) throw (Error)jjte001;}
4067       } finally {
4068                                   if (jjtc001) {
4069                                     jjtree.closeNodeScope(jjtn001, true);
4070                                     jjtreeCloseNodeScope(jjtn001);
4071                                   }
4072       }
4073       FunctionBody();
4074     } catch (Throwable jjte000) {
4075           if (jjtc000) {
4076             jjtree.clearNodeScope(jjtn000);
4077             jjtc000 = false;
4078           } else {
4079             jjtree.popNode();
4080           }
4081           if (jjte000 instanceof RuntimeException) {
4082             {if (true) throw (RuntimeException)jjte000;}
4083           }
4084           if (jjte000 instanceof ParseException) {
4085             {if (true) throw (ParseException)jjte000;}
4086           }
4087           {if (true) throw (Error)jjte000;}
4088     } finally {
4089           if (jjtc000) {
4090             jjtree.closeNodeScope(jjtn000, true);
4091             jjtreeCloseNodeScope(jjtn000);
4092           }
4093     }
4094   }
4095 
4096   final public void FunctionExpression() throws ParseException {
4097  /*@bgen(jjtree) FunctionExpression */
4098   ECMAFunctionExpression jjtn000 = new ECMAFunctionExpression(this, JJTFUNCTIONEXPRESSION);
4099   boolean jjtc000 = true;
4100   jjtree.openNodeScope(jjtn000);
4101   jjtreeOpenNodeScope(jjtn000);
4102     try {
4103       jj_consume_token(FUNCTION);
4104       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4105       case IDENTIFIER_NAME:
4106         Identifier();
4107         break;
4108       default:
4109         jj_la1[79] = jj_gen;
4110         ;
4111       }
4112                                        ECMAFormalParameterList jjtn001 = new ECMAFormalParameterList(this, JJTFORMALPARAMETERLIST);
4113                                        boolean jjtc001 = true;
4114                                        jjtree.openNodeScope(jjtn001);
4115                                        jjtreeOpenNodeScope(jjtn001);
4116       try {
4117         jj_consume_token(LPAREN);
4118         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4119         case IDENTIFIER_NAME:
4120           FormalParameterList();
4121           break;
4122         default:
4123           jj_la1[80] = jj_gen;
4124           ;
4125         }
4126         jj_consume_token(RPAREN);
4127       } catch (Throwable jjte001) {
4128                                        if (jjtc001) {
4129                                          jjtree.clearNodeScope(jjtn001);
4130                                          jjtc001 = false;
4131                                        } else {
4132                                          jjtree.popNode();
4133                                        }
4134                                        if (jjte001 instanceof RuntimeException) {
4135                                          {if (true) throw (RuntimeException)jjte001;}
4136                                        }
4137                                        if (jjte001 instanceof ParseException) {
4138                                          {if (true) throw (ParseException)jjte001;}
4139                                        }
4140                                        {if (true) throw (Error)jjte001;}
4141       } finally {
4142                                        if (jjtc001) {
4143                                          jjtree.closeNodeScope(jjtn001, true);
4144                                          jjtreeCloseNodeScope(jjtn001);
4145                                        }
4146       }
4147       FunctionBody();
4148     } catch (Throwable jjte000) {
4149           if (jjtc000) {
4150             jjtree.clearNodeScope(jjtn000);
4151             jjtc000 = false;
4152           } else {
4153             jjtree.popNode();
4154           }
4155           if (jjte000 instanceof RuntimeException) {
4156             {if (true) throw (RuntimeException)jjte000;}
4157           }
4158           if (jjte000 instanceof ParseException) {
4159             {if (true) throw (ParseException)jjte000;}
4160           }
4161           {if (true) throw (Error)jjte000;}
4162     } finally {
4163           if (jjtc000) {
4164             jjtree.closeNodeScope(jjtn000, true);
4165             jjtreeCloseNodeScope(jjtn000);
4166           }
4167     }
4168   }
4169 
4170   final public void FormalParameterList() throws ParseException {
4171     Identifier();
4172     label_30:
4173     while (true) {
4174       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4175       case COMMA:
4176         ;
4177         break;
4178       default:
4179         jj_la1[81] = jj_gen;
4180         break label_30;
4181       }
4182       jj_consume_token(COMMA);
4183       Identifier();
4184     }
4185   }
4186 
4187   final public void FunctionBody() throws ParseException {
4188  /*@bgen(jjtree) Block */
4189   ECMABlock jjtn000 = new ECMABlock(this, JJTBLOCK);
4190   boolean jjtc000 = true;
4191   jjtree.openNodeScope(jjtn000);
4192   jjtreeOpenNodeScope(jjtn000);
4193     try {
4194       jj_consume_token(LBRACE);
4195       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4196       case BREAK:
4197       case DO:
4198       case TYPEOF:
4199       case NEW:
4200       case VAR:
4201       case RETURN:
4202       case VOID:
4203       case CONTINUE:
4204       case FOR:
4205       case SWITCH:
4206       case WHILE:
4207       case DEBUGGER:
4208       case FUNCTION:
4209       case THIS:
4210       case WITH:
4211       case IF:
4212       case THROW:
4213       case DELETE:
4214       case TRY:
4215       case LBRACE:
4216       case LPAREN:
4217       case LBRACKET:
4218       case SEMICOLON:
4219       case PLUS:
4220       case MINUS:
4221       case INC:
4222       case DEC:
4223       case BNOT:
4224       case NOT:
4225       case NULL_LITERAL:
4226       case BOOLEAN_LITERAL:
4227       case DECIMAL_LITERAL:
4228       case HEX_INTEGER_LITERAL:
4229       case STRING_LITERAL:
4230       case IDENTIFIER_NAME:
4231       case REGULAR_EXPRESSION_LITERAL:
4232       case JAVA_STATEMENT:
4233         SourceElements();
4234         break;
4235       default:
4236         jj_la1[82] = jj_gen;
4237         ;
4238       }
4239       jj_consume_token(RBRACE);
4240     } catch (Throwable jjte000) {
4241           if (jjtc000) {
4242             jjtree.clearNodeScope(jjtn000);
4243             jjtc000 = false;
4244           } else {
4245             jjtree.popNode();
4246           }
4247           if (jjte000 instanceof RuntimeException) {
4248             {if (true) throw (RuntimeException)jjte000;}
4249           }
4250           if (jjte000 instanceof ParseException) {
4251             {if (true) throw (ParseException)jjte000;}
4252           }
4253           {if (true) throw (Error)jjte000;}
4254     } finally {
4255           if (jjtc000) {
4256             jjtree.closeNodeScope(jjtn000, true);
4257             jjtreeCloseNodeScope(jjtn000);
4258           }
4259     }
4260   }
4261 
4262 /* ECMA-262 5.1 Edition / June 2011 - Section 14: Script */
4263   final public ECMAProgram Program() throws ParseException {
4264  /*@bgen(jjtree) Program */
4265   ECMAProgram jjtn000 = new ECMAProgram(this, JJTPROGRAM);
4266   boolean jjtc000 = true;
4267   jjtree.openNodeScope(jjtn000);
4268   jjtreeOpenNodeScope(jjtn000);
4269     try {
4270       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4271       case BREAK:
4272       case DO:
4273       case TYPEOF:
4274       case NEW:
4275       case VAR:
4276       case RETURN:
4277       case VOID:
4278       case CONTINUE:
4279       case FOR:
4280       case SWITCH:
4281       case WHILE:
4282       case DEBUGGER:
4283       case FUNCTION:
4284       case THIS:
4285       case WITH:
4286       case IF:
4287       case THROW:
4288       case DELETE:
4289       case TRY:
4290       case LBRACE:
4291       case LPAREN:
4292       case LBRACKET:
4293       case SEMICOLON:
4294       case PLUS:
4295       case MINUS:
4296       case INC:
4297       case DEC:
4298       case BNOT:
4299       case NOT:
4300       case NULL_LITERAL:
4301       case BOOLEAN_LITERAL:
4302       case DECIMAL_LITERAL:
4303       case HEX_INTEGER_LITERAL:
4304       case STRING_LITERAL:
4305       case IDENTIFIER_NAME:
4306       case REGULAR_EXPRESSION_LITERAL:
4307       case JAVA_STATEMENT:
4308         SourceElements();
4309         break;
4310       default:
4311         jj_la1[83] = jj_gen;
4312         ;
4313       }
4314       jj_consume_token(0);
4315           jjtree.closeNodeScope(jjtn000, true);
4316           jjtc000 = false;
4317           jjtreeCloseNodeScope(jjtn000);
4318                 {if (true) return jjtn000;}
4319     } catch (Throwable jjte000) {
4320           if (jjtc000) {
4321             jjtree.clearNodeScope(jjtn000);
4322             jjtc000 = false;
4323           } else {
4324             jjtree.popNode();
4325           }
4326           if (jjte000 instanceof RuntimeException) {
4327             {if (true) throw (RuntimeException)jjte000;}
4328           }
4329           if (jjte000 instanceof ParseException) {
4330             {if (true) throw (ParseException)jjte000;}
4331           }
4332           {if (true) throw (Error)jjte000;}
4333     } finally {
4334           if (jjtc000) {
4335             jjtree.closeNodeScope(jjtn000, true);
4336             jjtreeCloseNodeScope(jjtn000);
4337           }
4338     }
4339     throw new Error("Missing return statement in function");
4340   }
4341 
4342   final public void SourceElements() throws ParseException {
4343     label_31:
4344     while (true) {
4345       SourceElement();
4346       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4347       case BREAK:
4348       case DO:
4349       case TYPEOF:
4350       case NEW:
4351       case VAR:
4352       case RETURN:
4353       case VOID:
4354       case CONTINUE:
4355       case FOR:
4356       case SWITCH:
4357       case WHILE:
4358       case DEBUGGER:
4359       case FUNCTION:
4360       case THIS:
4361       case WITH:
4362       case IF:
4363       case THROW:
4364       case DELETE:
4365       case TRY:
4366       case LBRACE:
4367       case LPAREN:
4368       case LBRACKET:
4369       case SEMICOLON:
4370       case PLUS:
4371       case MINUS:
4372       case INC:
4373       case DEC:
4374       case BNOT:
4375       case NOT:
4376       case NULL_LITERAL:
4377       case BOOLEAN_LITERAL:
4378       case DECIMAL_LITERAL:
4379       case HEX_INTEGER_LITERAL:
4380       case STRING_LITERAL:
4381       case IDENTIFIER_NAME:
4382       case REGULAR_EXPRESSION_LITERAL:
4383       case JAVA_STATEMENT:
4384         ;
4385         break;
4386       default:
4387         jj_la1[84] = jj_gen;
4388         break label_31;
4389       }
4390     }
4391   }
4392 
4393   final public void SourceElement() throws ParseException {
4394     if (jj_2_37(2147483647)) {
4395       FunctionDeclaration();
4396     } else {
4397       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4398       case BREAK:
4399       case DO:
4400       case TYPEOF:
4401       case NEW:
4402       case VAR:
4403       case RETURN:
4404       case VOID:
4405       case CONTINUE:
4406       case FOR:
4407       case SWITCH:
4408       case WHILE:
4409       case DEBUGGER:
4410       case FUNCTION:
4411       case THIS:
4412       case WITH:
4413       case IF:
4414       case THROW:
4415       case DELETE:
4416       case TRY:
4417       case LBRACE:
4418       case LPAREN:
4419       case LBRACKET:
4420       case SEMICOLON:
4421       case PLUS:
4422       case MINUS:
4423       case INC:
4424       case DEC:
4425       case BNOT:
4426       case NOT:
4427       case NULL_LITERAL:
4428       case BOOLEAN_LITERAL:
4429       case DECIMAL_LITERAL:
4430       case HEX_INTEGER_LITERAL:
4431       case STRING_LITERAL:
4432       case IDENTIFIER_NAME:
4433       case REGULAR_EXPRESSION_LITERAL:
4434       case JAVA_STATEMENT:
4435         Statement();
4436         break;
4437       default:
4438         jj_la1[85] = jj_gen;
4439         jj_consume_token(-1);
4440         throw new ParseException();
4441       }
4442     }
4443   }
4444 
4445 /* ECMA-262 5.1 Edition / June 2011 - Section 7.6: Identifiers */
4446   final public void Identifier() throws ParseException {
4447  /*@bgen(jjtree) Identifier */
4448         ECMAIdentifier jjtn000 = new ECMAIdentifier(this, JJTIDENTIFIER);
4449         boolean jjtc000 = true;
4450         jjtree.openNodeScope(jjtn000);
4451         jjtreeOpenNodeScope(jjtn000);Token t;
4452     try {
4453       t = jj_consume_token(IDENTIFIER_NAME);
4454           jjtree.closeNodeScope(jjtn000, true);
4455           jjtc000 = false;
4456           jjtreeCloseNodeScope(jjtn000);
4457                 jjtn000.jjtSetValue(t.image);
4458     } finally {
4459           if (jjtc000) {
4460             jjtree.closeNodeScope(jjtn000, true);
4461             jjtreeCloseNodeScope(jjtn000);
4462           }
4463     }
4464   }
4465 
4466   private boolean jj_2_1(int xla) {
4467     jj_la = xla; jj_lastpos = jj_scanpos = token;
4468     try { return !jj_3_1(); }
4469     catch(LookaheadSuccess ls) { return true; }
4470     finally { jj_save(0, xla); }
4471   }
4472 
4473   private boolean jj_2_2(int xla) {
4474     jj_la = xla; jj_lastpos = jj_scanpos = token;
4475     try { return !jj_3_2(); }
4476     catch(LookaheadSuccess ls) { return true; }
4477     finally { jj_save(1, xla); }
4478   }
4479 
4480   private boolean jj_2_3(int xla) {
4481     jj_la = xla; jj_lastpos = jj_scanpos = token;
4482     try { return !jj_3_3(); }
4483     catch(LookaheadSuccess ls) { return true; }
4484     finally { jj_save(2, xla); }
4485   }
4486 
4487   private boolean jj_2_4(int xla) {
4488     jj_la = xla; jj_lastpos = jj_scanpos = token;
4489     try { return !jj_3_4(); }
4490     catch(LookaheadSuccess ls) { return true; }
4491     finally { jj_save(3, xla); }
4492   }
4493 
4494   private boolean jj_2_5(int xla) {
4495     jj_la = xla; jj_lastpos = jj_scanpos = token;
4496     try { return !jj_3_5(); }
4497     catch(LookaheadSuccess ls) { return true; }
4498     finally { jj_save(4, xla); }
4499   }
4500 
4501   private boolean jj_2_6(int xla) {
4502     jj_la = xla; jj_lastpos = jj_scanpos = token;
4503     try { return !jj_3_6(); }
4504     catch(LookaheadSuccess ls) { return true; }
4505     finally { jj_save(5, xla); }
4506   }
4507 
4508   private boolean jj_2_7(int xla) {
4509     jj_la = xla; jj_lastpos = jj_scanpos = token;
4510     try { return !jj_3_7(); }
4511     catch(LookaheadSuccess ls) { return true; }
4512     finally { jj_save(6, xla); }
4513   }
4514 
4515   private boolean jj_2_8(int xla) {
4516     jj_la = xla; jj_lastpos = jj_scanpos = token;
4517     try { return !jj_3_8(); }
4518     catch(LookaheadSuccess ls) { return true; }
4519     finally { jj_save(7, xla); }
4520   }
4521 
4522   private boolean jj_2_9(int xla) {
4523     jj_la = xla; jj_lastpos = jj_scanpos = token;
4524     try { return !jj_3_9(); }
4525     catch(LookaheadSuccess ls) { return true; }
4526     finally { jj_save(8, xla); }
4527   }
4528 
4529   private boolean jj_2_10(int xla) {
4530     jj_la = xla; jj_lastpos = jj_scanpos = token;
4531     try { return !jj_3_10(); }
4532     catch(LookaheadSuccess ls) { return true; }
4533     finally { jj_save(9, xla); }
4534   }
4535 
4536   private boolean jj_2_11(int xla) {
4537     jj_la = xla; jj_lastpos = jj_scanpos = token;
4538     try { return !jj_3_11(); }
4539     catch(LookaheadSuccess ls) { return true; }
4540     finally { jj_save(10, xla); }
4541   }
4542 
4543   private boolean jj_2_12(int xla) {
4544     jj_la = xla; jj_lastpos = jj_scanpos = token;
4545     try { return !jj_3_12(); }
4546     catch(LookaheadSuccess ls) { return true; }
4547     finally { jj_save(11, xla); }
4548   }
4549 
4550   private boolean jj_2_13(int xla) {
4551     jj_la = xla; jj_lastpos = jj_scanpos = token;
4552     try { return !jj_3_13(); }
4553     catch(LookaheadSuccess ls) { return true; }
4554     finally { jj_save(12, xla); }
4555   }
4556 
4557   private boolean jj_2_14(int xla) {
4558     jj_la = xla; jj_lastpos = jj_scanpos = token;
4559     try { return !jj_3_14(); }
4560     catch(LookaheadSuccess ls) { return true; }
4561     finally { jj_save(13, xla); }
4562   }
4563 
4564   private boolean jj_2_15(int xla) {
4565     jj_la = xla; jj_lastpos = jj_scanpos = token;
4566     try { return !jj_3_15(); }
4567     catch(LookaheadSuccess ls) { return true; }
4568     finally { jj_save(14, xla); }
4569   }
4570 
4571   private boolean jj_2_16(int xla) {
4572     jj_la = xla; jj_lastpos = jj_scanpos = token;
4573     try { return !jj_3_16(); }
4574     catch(LookaheadSuccess ls) { return true; }
4575     finally { jj_save(15, xla); }
4576   }
4577 
4578   private boolean jj_2_17(int xla) {
4579     jj_la = xla; jj_lastpos = jj_scanpos = token;
4580     try { return !jj_3_17(); }
4581     catch(LookaheadSuccess ls) { return true; }
4582     finally { jj_save(16, xla); }
4583   }
4584 
4585   private boolean jj_2_18(int xla) {
4586     jj_la = xla; jj_lastpos = jj_scanpos = token;
4587     try { return !jj_3_18(); }
4588     catch(LookaheadSuccess ls) { return true; }
4589     finally { jj_save(17, xla); }
4590   }