
JavaParser.java


0001 /* Generated By:JJTree&JavaCC: Do not edit this line. JavaParser.java */

0002 package net.sourceforge.pmd.lang.java.ast;

0003 import java.util.*;

0004 import net.sourceforge.pmd.PMD;

0005 import net.sourceforge.pmd.lang.ast.CharStream;

0006 import net.sourceforge.pmd.lang.ast.TokenMgrError;

0007 public class JavaParser/*@bgen(jjtree)*/implements JavaParserTreeConstants, JavaParserConstants {/*@bgen(jjtree)*/

0008   protected JJTJavaParserState jjtree = new JJTJavaParserState();

0009   private boolean isJDK13;

0010   private boolean isJDK15;

0011 

0012   public void setJDK13() {

0013    this.isJDK13 = true;

0014   }

0015 

0016   public void setJDK15() {

0017    this.isJDK15 = true;

0018   }

0019 

0020   private void checkForBadAssertUsage(String in, String usage) {

0021     if (!isJDK13 && in.equals("assert")) {

0022       throw new ParseException("Can't use 'assert' as " + usage + " when running in JDK 1.4 mode!");

0023     }

0024   }

0025 

0026   private void checkForBadStaticImportUsage() {

0027     if (!isJDK15) {

0028       throw new ParseException("Can't use static imports when running in JDK 1.4 mode!");

0029     }

0030   }

0031 

0032   private void checkForBadAnnotationUsage() {

0033     if (!isJDK15) {

0034       throw new ParseException("Can't use annotations when running in JDK 1.4 mode!");

0035     }

0036   }

0037 

0038   private void checkForBadGenericsUsage() {

0039     if (!isJDK15) {

0040       throw new ParseException("Can't use generics unless running in JDK 1.5 mode!");

0041     }

0042   }

0043 

0044   private void checkForBadVariableArgumentsUsage() {

0045     if (!isJDK15) {

0046       throw new ParseException("Can't use variable arguments (varargs) when running in JDK 1.4 mode!");

0047     }

0048   }

0049 

0050   private void checkForBadJDK15ForLoopSyntaxArgumentsUsage() {

0051     if (!isJDK15) {

0052       throw new ParseException("Can't use JDK 1.5 for loop syntax when running in JDK 1.4 mode!");

0053     }

0054   }

0055 

0056   private void checkForBadEnumUsage(String in, String usage) {

0057     if (isJDK15 && in.equals("enum")) {

0058       throw new ParseException("Can't use 'enum' as " + usage + " when running in JDK 1.5 mode!");

0059     }

0060   }

0061 

0062   private void checkForBadHexFloatingPointLiteral() {

0063     if (!isJDK15) {

0064       throw new ParseException("ERROR: Can't use hexadecimal floating point literals in pre-JDK 1.5 target");

0065     }

0066   }

0067 

0068   // This is a semantic LOOKAHEAD to determine if we're dealing with an assert

0069   // Note that this can't be replaced with a syntactic lookahead

0070   // since "assert" isn't a string literal token

0071   private boolean isNextTokenAnAssert() {

0072     boolean res = getToken(1).image.equals("assert");

0073     if (res && isJDK13 && getToken(2).image.equals("(")) {

0074      res = false;

0075     }

0076     return res;

0077   }

0078 

0079   private boolean isPrecededByComment(Token tok) {

0080       boolean res = false;

0081       while (!res && tok.specialToken != null) {

0082           tok = tok.specialToken;

0083           res = tok.kind == SINGLE_LINE_COMMENT ||

0084                 tok.kind == FORMAL_COMMENT ||

0085                 tok.kind == MULTI_LINE_COMMENT;

0086       }

0087       return res;

0088   }

0089 

0090   public Map<Integer, String> getSuppressMap() {

0091     return token_source.getSuppressMap();

0092   }

0093 

0094   public void setSuppressMarker(String marker) {

0095     token_source.setSuppressMarker(marker);

0096   }

0097 

0098 /*****************************************

0099  * THE JAVA LANGUAGE GRAMMAR STARTS HERE *

0100  *****************************************/

0101 

0102 /*

0103  * Program structuring syntax follows.

0104  */

0105   final public ASTCompilationUnit CompilationUnit() throws ParseException {

0106  /*@bgen(jjtree) CompilationUnit */

0107   ASTCompilationUnit jjtn000 = new ASTCompilationUnit(this, JJTCOMPILATIONUNIT);

0108   boolean jjtc000 = true;

0109   jjtree.openNodeScope(jjtn000);

0110     try {

0111       if (jj_2_1(2147483647)) {

0112         PackageDeclaration();

0113       } else {

0114         ;

0115       }

0116       label_1:

0117       while (true) {

0118         switch (jj_nt.kind) {

0119         case IMPORT:

0120           ;

0121           break;

0122         default:

0123           jj_la1[0] = jj_gen;

0124           break label_1;

0125         }

0126         ImportDeclaration();

0127       }

0128       label_2:

0129       while (true) {

0130         switch (jj_nt.kind) {

0131         case ABSTRACT:

0132         case CLASS:

0133         case FINAL:

0134         case INTERFACE:

0135         case NATIVE:

0136         case PRIVATE:

0137         case PROTECTED:

0138         case PUBLIC:

0139         case STATIC:

0140         case SYNCHRONIZED:

0141         case TRANSIENT:

0142         case VOLATILE:

0143         case STRICTFP:

0144         case IDENTIFIER:

0145         case SEMICOLON:

0146         case AT:

0147           ;

0148           break;

0149         default:

0150           jj_la1[1] = jj_gen;

0151           break label_2;

0152         }

0153         TypeDeclaration();

0154       }

0155       switch (jj_nt.kind) {

0156       case 123:

0157         jj_consume_token(123);

0158         break;

0159       default:

0160         jj_la1[2] = jj_gen;

0161         ;

0162       }

0163       switch (jj_nt.kind) {

0164       case 124:

0165         jj_consume_token(124);

0166         break;

0167       default:

0168         jj_la1[3] = jj_gen;

0169         ;

0170       }

0171       jj_consume_token(0);

0172   jjtree.closeNodeScope(jjtn000, true);

0173   jjtc000 = false;

0174  jjtn000.setComments(token_source.comments);

0175  {if (true) return jjtn000;}

0176     } catch (Throwable jjte000) {

0177     if (jjtc000) {

0178       jjtree.clearNodeScope(jjtn000);

0179       jjtc000 = false;

0180     } else {

0181       jjtree.popNode();

0182     }

0183     if (jjte000 instanceof RuntimeException) {

0184       {if (true) throw (RuntimeException)jjte000;}

0185     }

0186     if (jjte000 instanceof ParseException) {

0187       {if (true) throw (ParseException)jjte000;}

0188     }

0189     {if (true) throw (Error)jjte000;}

0190     } finally {

0191     if (jjtc000) {

0192       jjtree.closeNodeScope(jjtn000, true);

0193     }

0194     }

0195     throw new RuntimeException("Missing return statement in function");

0196   }

0197 

0198   final public void PackageDeclaration() throws ParseException {

0199  /*@bgen(jjtree) PackageDeclaration */

0200   ASTPackageDeclaration jjtn000 = new ASTPackageDeclaration(this, JJTPACKAGEDECLARATION);

0201   boolean jjtc000 = true;

0202   jjtree.openNodeScope(jjtn000);

0203     try {

0204       label_3:

0205       while (true) {

0206         switch (jj_nt.kind) {

0207         case AT:

0208           ;

0209           break;

0210         default:

0211           jj_la1[4] = jj_gen;

0212           break label_3;

0213         }

0214         Annotation();

0215       }

0216       jj_consume_token(PACKAGE);

0217       Name();

0218       jj_consume_token(SEMICOLON);

0219     } catch (Throwable jjte000) {

0220     if (jjtc000) {

0221       jjtree.clearNodeScope(jjtn000);

0222       jjtc000 = false;

0223     } else {

0224       jjtree.popNode();

0225     }

0226     if (jjte000 instanceof RuntimeException) {

0227       {if (true) throw (RuntimeException)jjte000;}

0228     }

0229     if (jjte000 instanceof ParseException) {

0230       {if (true) throw (ParseException)jjte000;}

0231     }

0232     {if (true) throw (Error)jjte000;}

0233     } finally {

0234     if (jjtc000) {

0235       jjtree.closeNodeScope(jjtn000, true);

0236     }

0237     }

0238   }

0239 

0240   final public void ImportDeclaration() throws ParseException {

0241  /*@bgen(jjtree) ImportDeclaration */

0242   ASTImportDeclaration jjtn000 = new ASTImportDeclaration(this, JJTIMPORTDECLARATION);

0243   boolean jjtc000 = true;

0244   jjtree.openNodeScope(jjtn000);

0245     try {

0246       jj_consume_token(IMPORT);

0247       switch (jj_nt.kind) {

0248       case STATIC:

0249         jj_consume_token(STATIC);

0250                        checkForBadStaticImportUsage();jjtn000.setStatic();

0251         break;

0252       default:

0253         jj_la1[5] = jj_gen;

0254         ;

0255       }

0256       Name();

0257       switch (jj_nt.kind) {

0258       case DOT:

0259         jj_consume_token(DOT);

0260         jj_consume_token(STAR);

0261                                                                                                 jjtn000.setImportOnDemand();

0262         break;

0263       default:

0264         jj_la1[6] = jj_gen;

0265         ;

0266       }

0267       jj_consume_token(SEMICOLON);

0268     } catch (Throwable jjte000) {

0269     if (jjtc000) {

0270       jjtree.clearNodeScope(jjtn000);

0271       jjtc000 = false;

0272     } else {

0273       jjtree.popNode();

0274     }

0275     if (jjte000 instanceof RuntimeException) {

0276       {if (true) throw (RuntimeException)jjte000;}

0277     }

0278     if (jjte000 instanceof ParseException) {

0279       {if (true) throw (ParseException)jjte000;}

0280     }

0281     {if (true) throw (Error)jjte000;}

0282     } finally {

0283     if (jjtc000) {

0284       jjtree.closeNodeScope(jjtn000, true);

0285     }

0286     }

0287   }

0288 

0289 /*

0290  * Modifiers. We match all modifiers in a single rule to reduce the chances of

0291  * syntax errors for simple modifier mistakes. It will also enable us to give

0292  * better error messages.

0293  */

0294   final public int Modifiers() throws ParseException {

0295    int modifiers = 0;

0296     label_4:

0297     while (true) {

0298       if (jj_2_2(2)) {

0299         ;

0300       } else {

0301         break label_4;

0302       }

0303       switch (jj_nt.kind) {

0304       case PUBLIC:

0305         jj_consume_token(PUBLIC);

0306               modifiers |= AccessNode.PUBLIC;

0307         break;

0308       case STATIC:

0309         jj_consume_token(STATIC);

0310                modifiers |= AccessNode.STATIC;

0311         break;

0312       case PROTECTED:

0313         jj_consume_token(PROTECTED);

0314                   modifiers |= AccessNode.PROTECTED;

0315         break;

0316       case PRIVATE:

0317         jj_consume_token(PRIVATE);

0318                 modifiers |= AccessNode.PRIVATE;

0319         break;

0320       case FINAL:

0321         jj_consume_token(FINAL);

0322               modifiers |= AccessNode.FINAL;

0323         break;

0324       case ABSTRACT:

0325         jj_consume_token(ABSTRACT);

0326                  modifiers |= AccessNode.ABSTRACT;

0327         break;

0328       case SYNCHRONIZED:

0329         jj_consume_token(SYNCHRONIZED);

0330                      modifiers |= AccessNode.SYNCHRONIZED;

0331         break;

0332       case NATIVE:

0333         jj_consume_token(NATIVE);

0334                modifiers |= AccessNode.NATIVE;

0335         break;

0336       case TRANSIENT:

0337         jj_consume_token(TRANSIENT);

0338                   modifiers |= AccessNode.TRANSIENT;

0339         break;

0340       case VOLATILE:

0341         jj_consume_token(VOLATILE);

0342                  modifiers |= AccessNode.VOLATILE;

0343         break;

0344       case STRICTFP:

0345         jj_consume_token(STRICTFP);

0346                  modifiers |= AccessNode.STRICTFP;

0347         break;

0348       case AT:

0349         Annotation();

0350         break;

0351       default:

0352         jj_la1[7] = jj_gen;

0353         jj_consume_token(-1);

0354         throw new ParseException();

0355       }

0356     }

0357     {if (true) return modifiers;}

0358     throw new RuntimeException("Missing return statement in function");

0359   }

0360 

0361 /*

0362  * Declaration syntax follows.

0363  */

0364   final public void TypeDeclaration() throws ParseException {

0365  /*@bgen(jjtree) TypeDeclaration */

0366    ASTTypeDeclaration jjtn000 = new ASTTypeDeclaration(this, JJTTYPEDECLARATION);

0367    boolean jjtc000 = true;

0368    jjtree.openNodeScope(jjtn000);int modifiers;

0369     try {

0370       switch (jj_nt.kind) {

0371       case SEMICOLON:

0372         jj_consume_token(SEMICOLON);

0373         break;

0374       case ABSTRACT:

0375       case CLASS:

0376       case FINAL:

0377       case INTERFACE:

0378       case NATIVE:

0379       case PRIVATE:

0380       case PROTECTED:

0381       case PUBLIC:

0382       case STATIC:

0383       case SYNCHRONIZED:

0384       case TRANSIENT:

0385       case VOLATILE:

0386       case STRICTFP:

0387       case IDENTIFIER:

0388       case AT:

0389         modifiers = Modifiers();

0390         switch (jj_nt.kind) {

0391         case ABSTRACT:

0392         case CLASS:

0393         case FINAL:

0394         case INTERFACE:

0395           ClassOrInterfaceDeclaration(modifiers);

0396           break;

0397         case IDENTIFIER:

0398           EnumDeclaration(modifiers);

0399           break;

0400         case AT:

0401           AnnotationTypeDeclaration(modifiers);

0402           break;

0403         default:

0404           jj_la1[8] = jj_gen;

0405           jj_consume_token(-1);

0406           throw new ParseException();

0407         }

0408         break;

0409       default:

0410         jj_la1[9] = jj_gen;

0411         jj_consume_token(-1);

0412         throw new ParseException();

0413       }

0414     } catch (Throwable jjte000) {

0415     if (jjtc000) {

0416       jjtree.clearNodeScope(jjtn000);

0417       jjtc000 = false;

0418     } else {

0419       jjtree.popNode();

0420     }

0421     if (jjte000 instanceof RuntimeException) {

0422       {if (true) throw (RuntimeException)jjte000;}

0423     }

0424     if (jjte000 instanceof ParseException) {

0425       {if (true) throw (ParseException)jjte000;}

0426     }

0427     {if (true) throw (Error)jjte000;}

0428     } finally {

0429     if (jjtc000) {

0430       jjtree.closeNodeScope(jjtn000, true);

0431     }

0432     }

0433   }

0434 

0435   final public void ClassOrInterfaceDeclaration(int modifiers) throws ParseException {

0436  /*@bgen(jjtree) ClassOrInterfaceDeclaration */

0437 ASTClassOrInterfaceDeclaration jjtn000 = new ASTClassOrInterfaceDeclaration(this, JJTCLASSORINTERFACEDECLARATION);

0438 boolean jjtc000 = true;

0439 jjtree.openNodeScope(jjtn000);Token t = null;

0440 jjtn000.setModifiers(modifiers);

0441     try {

0442       switch (jj_nt.kind) {

0443       case ABSTRACT:

0444       case CLASS:

0445       case FINAL:

0446         switch (jj_nt.kind) {

0447         case ABSTRACT:

0448         case FINAL:

0449           switch (jj_nt.kind) {

0450           case FINAL:

0451             jj_consume_token(FINAL);

0452             break;

0453           case ABSTRACT:

0454             jj_consume_token(ABSTRACT);

0455             break;

0456           default:

0457             jj_la1[10] = jj_gen;

0458             jj_consume_token(-1);

0459             throw new ParseException();

0460           }

0461           break;

0462         default:

0463           jj_la1[11] = jj_gen;

0464           ;

0465         }

0466         jj_consume_token(CLASS);

0467         break;

0468       case INTERFACE:

0469         jj_consume_token(INTERFACE);

0470                                                                                                                      jjtn000.setInterface();

0471         break;

0472       default:

0473         jj_la1[12] = jj_gen;

0474         jj_consume_token(-1);

0475         throw new ParseException();

0476       }

0477       t = jj_consume_token(IDENTIFIER);

0478                    jjtn000.setImage(t.image);

0479       switch (jj_nt.kind) {

0480       case LT:

0481         TypeParameters();

0482         break;

0483       default:

0484         jj_la1[13] = jj_gen;

0485         ;

0486       }

0487       switch (jj_nt.kind) {

0488       case EXTENDS:

0489         ExtendsList();

0490         break;

0491       default:

0492         jj_la1[14] = jj_gen;

0493         ;

0494       }

0495       switch (jj_nt.kind) {

0496       case IMPLEMENTS:

0497         ImplementsList();

0498         break;

0499       default:

0500         jj_la1[15] = jj_gen;

0501         ;

0502       }

0503       ClassOrInterfaceBody();

0504     } catch (Throwable jjte000) {

0505     if (jjtc000) {

0506       jjtree.clearNodeScope(jjtn000);

0507       jjtc000 = false;

0508     } else {

0509       jjtree.popNode();

0510     }

0511     if (jjte000 instanceof RuntimeException) {

0512       {if (true) throw (RuntimeException)jjte000;}

0513     }

0514     if (jjte000 instanceof ParseException) {

0515       {if (true) throw (ParseException)jjte000;}

0516     }

0517     {if (true) throw (Error)jjte000;}

0518     } finally {

0519     if (jjtc000) {

0520       jjtree.closeNodeScope(jjtn000, true);

0521     }

0522     }

0523   }

0524 

0525   final public void ExtendsList() throws ParseException {

0526  /*@bgen(jjtree) ExtendsList */

0527    ASTExtendsList jjtn000 = new ASTExtendsList(this, JJTEXTENDSLIST);

0528    boolean jjtc000 = true;

0529    jjtree.openNodeScope(jjtn000);boolean extendsMoreThanOne = false;

0530     try {

0531       jj_consume_token(EXTENDS);

0532       ClassOrInterfaceType();

0533       label_5:

0534       while (true) {

0535         switch (jj_nt.kind) {

0536         case COMMA:

0537           ;

0538           break;

0539         default:

0540           jj_la1[16] = jj_gen;

0541           break label_5;

0542         }

0543         jj_consume_token(COMMA);

0544         ClassOrInterfaceType();

0545                                   extendsMoreThanOne = true;

0546       }

0547     } catch (Throwable jjte000) {

0548      if (jjtc000) {

0549        jjtree.clearNodeScope(jjtn000);

0550        jjtc000 = false;

0551      } else {

0552        jjtree.popNode();

0553      }

0554      if (jjte000 instanceof RuntimeException) {

0555        {if (true) throw (RuntimeException)jjte000;}

0556      }

0557      if (jjte000 instanceof ParseException) {

0558        {if (true) throw (ParseException)jjte000;}

0559      }

0560      {if (true) throw (Error)jjte000;}

0561     } finally {

0562      if (jjtc000) {

0563        jjtree.closeNodeScope(jjtn000, true);

0564      }

0565     }

0566   }

0567 

0568   final public void ImplementsList() throws ParseException {

0569  /*@bgen(jjtree) ImplementsList */

0570   ASTImplementsList jjtn000 = new ASTImplementsList(this, JJTIMPLEMENTSLIST);

0571   boolean jjtc000 = true;

0572   jjtree.openNodeScope(jjtn000);

0573     try {

0574       jj_consume_token(IMPLEMENTS);

0575       ClassOrInterfaceType();

0576       label_6:

0577       while (true) {

0578         switch (jj_nt.kind) {

0579         case COMMA:

0580           ;

0581           break;

0582         default:

0583           jj_la1[17] = jj_gen;

0584           break label_6;

0585         }

0586         jj_consume_token(COMMA);

0587         ClassOrInterfaceType();

0588       }

0589     } catch (Throwable jjte000) {

0590      if (jjtc000) {

0591        jjtree.clearNodeScope(jjtn000);

0592        jjtc000 = false;

0593      } else {

0594        jjtree.popNode();

0595      }

0596      if (jjte000 instanceof RuntimeException) {

0597        {if (true) throw (RuntimeException)jjte000;}

0598      }

0599      if (jjte000 instanceof ParseException) {

0600        {if (true) throw (ParseException)jjte000;}

0601      }

0602      {if (true) throw (Error)jjte000;}

0603     } finally {

0604      if (jjtc000) {

0605        jjtree.closeNodeScope(jjtn000, true);

0606      }

0607     }

0608   }

0609 

0610   final public void EnumDeclaration(int modifiers) throws ParseException {

0611  /*@bgen(jjtree) EnumDeclaration */

0612 ASTEnumDeclaration jjtn000 = new ASTEnumDeclaration(this, JJTENUMDECLARATION);

0613 boolean jjtc000 = true;

0614 jjtree.openNodeScope(jjtn000);Token t;

0615 jjtn000.setModifiers(modifiers);

0616     try {

0617       t = jj_consume_token(IDENTIFIER);

0618     if (!t.image.equals("enum")) {

0619       {if (true) throw new ParseException("ERROR: expecting enum");}

0620     }

0621     if (!this.isJDK15) {

0622       {if (true) throw new ParseException("ERROR: Can't use enum as a keyword in pre-JDK 1.5 target");}

0623     }

0624       t = jj_consume_token(IDENTIFIER);

0625                   jjtn000.setImage(t.image);

0626       switch (jj_nt.kind) {

0627       case IMPLEMENTS:

0628         ImplementsList();

0629         break;

0630       default:

0631         jj_la1[18] = jj_gen;

0632         ;

0633       }

0634       EnumBody();

0635     } catch (Throwable jjte000) {

0636     if (jjtc000) {

0637       jjtree.clearNodeScope(jjtn000);

0638       jjtc000 = false;

0639     } else {

0640       jjtree.popNode();

0641     }

0642     if (jjte000 instanceof RuntimeException) {

0643       {if (true) throw (RuntimeException)jjte000;}

0644     }

0645     if (jjte000 instanceof ParseException) {

0646       {if (true) throw (ParseException)jjte000;}

0647     }

0648     {if (true) throw (Error)jjte000;}

0649     } finally {

0650     if (jjtc000) {

0651       jjtree.closeNodeScope(jjtn000, true);

0652     }

0653     }

0654   }

0655 

0656   final public void EnumBody() throws ParseException {

0657  /*@bgen(jjtree) EnumBody */

0658   ASTEnumBody jjtn000 = new ASTEnumBody(this, JJTENUMBODY);

0659   boolean jjtc000 = true;

0660   jjtree.openNodeScope(jjtn000);

0661     try {

0662       jj_consume_token(LBRACE);

0663       switch (jj_nt.kind) {

0664       case IDENTIFIER:

0665       case AT:

0666         label_7:

0667         while (true) {

0668           switch (jj_nt.kind) {

0669           case AT:

0670             ;

0671             break;

0672           default:

0673             jj_la1[19] = jj_gen;

0674             break label_7;

0675           }

0676           Annotation();

0677         }

0678         EnumConstant();

0679         label_8:

0680         while (true) {

0681           if (jj_2_3(2)) {

0682             ;

0683           } else {

0684             break label_8;

0685           }

0686           jj_consume_token(COMMA);

0687           label_9:

0688           while (true) {

0689             switch (jj_nt.kind) {

0690             case AT:

0691               ;

0692               break;

0693             default:

0694               jj_la1[20] = jj_gen;

0695               break label_9;

0696             }

0697             Annotation();

0698           }

0699           EnumConstant();

0700         }

0701         break;

0702       default:

0703         jj_la1[21] = jj_gen;

0704         ;

0705       }

0706       switch (jj_nt.kind) {

0707       case COMMA:

0708         jj_consume_token(COMMA);

0709         break;

0710       default:

0711         jj_la1[22] = jj_gen;

0712         ;

0713       }

0714       switch (jj_nt.kind) {

0715       case SEMICOLON:

0716         jj_consume_token(SEMICOLON);

0717         label_10:

0718         while (true) {

0719           switch (jj_nt.kind) {

0720           case ABSTRACT:

0721           case BOOLEAN:

0722           case BYTE:

0723           case CHAR:

0724           case CLASS:

0725           case DOUBLE:

0726           case FINAL:

0727           case FLOAT:

0728           case INT:

0729           case INTERFACE:

0730           case LONG:

0731           case NATIVE:

0732           case PRIVATE:

0733           case PROTECTED:

0734           case PUBLIC:

0735           case SHORT:

0736           case STATIC:

0737           case SYNCHRONIZED:

0738           case TRANSIENT:

0739           case VOID:

0740           case VOLATILE:

0741           case STRICTFP:

0742           case IDENTIFIER:

0743           case LBRACE:

0744           case SEMICOLON:

0745           case AT:

0746           case LT:

0747             ;

0748             break;

0749           default:

0750             jj_la1[23] = jj_gen;

0751             break label_10;

0752           }

0753           ClassOrInterfaceBodyDeclaration();

0754         }

0755         break;

0756       default:

0757         jj_la1[24] = jj_gen;

0758         ;

0759       }

0760       jj_consume_token(RBRACE);

0761     } catch (Throwable jjte000) {

0762      if (jjtc000) {

0763        jjtree.clearNodeScope(jjtn000);

0764        jjtc000 = false;

0765      } else {

0766        jjtree.popNode();

0767      }

0768      if (jjte000 instanceof RuntimeException) {

0769        {if (true) throw (RuntimeException)jjte000;}

0770      }

0771      if (jjte000 instanceof ParseException) {

0772        {if (true) throw (ParseException)jjte000;}

0773      }

0774      {if (true) throw (Error)jjte000;}

0775     } finally {

0776      if (jjtc000) {

0777        jjtree.closeNodeScope(jjtn000, true);

0778      }

0779     }

0780   }

0781 

0782   final public void EnumConstant() throws ParseException {

0783  /*@bgen(jjtree) EnumConstant */

0784  ASTEnumConstant jjtn000 = new ASTEnumConstant(this, JJTENUMCONSTANT);

0785  boolean jjtc000 = true;

0786  jjtree.openNodeScope(jjtn000);Token t;

0787     try {

0788       t = jj_consume_token(IDENTIFIER);

0789                   jjtn000.setImage(t.image);

0790       switch (jj_nt.kind) {

0791       case LPAREN:

0792         Arguments();

0793         break;

0794       default:

0795         jj_la1[25] = jj_gen;

0796         ;

0797       }

0798       switch (jj_nt.kind) {

0799       case LBRACE:

0800         ClassOrInterfaceBody();

0801         break;

0802       default:

0803         jj_la1[26] = jj_gen;

0804         ;

0805       }

0806     } catch (Throwable jjte000) {

0807     if (jjtc000) {

0808       jjtree.clearNodeScope(jjtn000);

0809       jjtc000 = false;

0810     } else {

0811       jjtree.popNode();

0812     }

0813     if (jjte000 instanceof RuntimeException) {

0814       {if (true) throw (RuntimeException)jjte000;}

0815     }

0816     if (jjte000 instanceof ParseException) {

0817       {if (true) throw (ParseException)jjte000;}

0818     }

0819     {if (true) throw (Error)jjte000;}

0820     } finally {

0821     if (jjtc000) {

0822       jjtree.closeNodeScope(jjtn000, true);

0823     }

0824     }

0825   }

0826 

0827   final public void TypeParameters() throws ParseException {

0828  /*@bgen(jjtree) TypeParameters */

0829   ASTTypeParameters jjtn000 = new ASTTypeParameters(this, JJTTYPEPARAMETERS);

0830   boolean jjtc000 = true;

0831   jjtree.openNodeScope(jjtn000);

0832     try {

0833       jj_consume_token(LT);

0834         checkForBadGenericsUsage();

0835       TypeParameter();

0836       label_11:

0837       while (true) {

0838         switch (jj_nt.kind) {

0839         case COMMA:

0840           ;

0841           break;

0842         default:

0843           jj_la1[27] = jj_gen;

0844           break label_11;

0845         }

0846         jj_consume_token(COMMA);

0847         TypeParameter();

0848       }

0849       jj_consume_token(GT);

0850     } catch (Throwable jjte000) {

0851      if (jjtc000) {

0852        jjtree.clearNodeScope(jjtn000);

0853        jjtc000 = false;

0854      } else {

0855        jjtree.popNode();

0856      }

0857      if (jjte000 instanceof RuntimeException) {

0858        {if (true) throw (RuntimeException)jjte000;}

0859      }

0860      if (jjte000 instanceof ParseException) {

0861        {if (true) throw (ParseException)jjte000;}

0862      }

0863      {if (true) throw (Error)jjte000;}

0864     } finally {

0865      if (jjtc000) {

0866        jjtree.closeNodeScope(jjtn000, true);

0867      }

0868     }

0869   }

0870 

0871   final public void TypeParameter() throws ParseException {

0872  /*@bgen(jjtree) TypeParameter */

0873  ASTTypeParameter jjtn000 = new ASTTypeParameter(this, JJTTYPEPARAMETER);

0874  boolean jjtc000 = true;

0875  jjtree.openNodeScope(jjtn000);Token t;

0876     try {

0877       t = jj_consume_token(IDENTIFIER);

0878                    jjtn000.setImage(t.image);

0879       switch (jj_nt.kind) {

0880       case EXTENDS:

0881         TypeBound();

0882         break;

0883       default:

0884         jj_la1[28] = jj_gen;

0885         ;

0886       }

0887     } catch (Throwable jjte000) {

0888      if (jjtc000) {

0889        jjtree.clearNodeScope(jjtn000);

0890        jjtc000 = false;

0891      } else {

0892        jjtree.popNode();

0893      }

0894      if (jjte000 instanceof RuntimeException) {

0895        {if (true) throw (RuntimeException)jjte000;}

0896      }

0897      if (jjte000 instanceof ParseException) {

0898        {if (true) throw (ParseException)jjte000;}

0899      }

0900      {if (true) throw (Error)jjte000;}

0901     } finally {

0902      if (jjtc000) {

0903        jjtree.closeNodeScope(jjtn000, true);

0904      }

0905     }

0906   }

0907 

0908   final public void TypeBound() throws ParseException {

0909  /*@bgen(jjtree) TypeBound */

0910   ASTTypeBound jjtn000 = new ASTTypeBound(this, JJTTYPEBOUND);

0911   boolean jjtc000 = true;

0912   jjtree.openNodeScope(jjtn000);

0913     try {

0914       jj_consume_token(EXTENDS);

0915       ClassOrInterfaceType();

0916       label_12:

0917       while (true) {

0918         switch (jj_nt.kind) {

0919         case BIT_AND:

0920           ;

0921           break;

0922         default:

0923           jj_la1[29] = jj_gen;

0924           break label_12;

0925         }

0926         jj_consume_token(BIT_AND);

0927         ClassOrInterfaceType();

0928       }

0929     } catch (Throwable jjte000) {

0930      if (jjtc000) {

0931        jjtree.clearNodeScope(jjtn000);

0932        jjtc000 = false;

0933      } else {

0934        jjtree.popNode();

0935      }

0936      if (jjte000 instanceof RuntimeException) {

0937        {if (true) throw (RuntimeException)jjte000;}

0938      }

0939      if (jjte000 instanceof ParseException) {

0940        {if (true) throw (ParseException)jjte000;}

0941      }

0942      {if (true) throw (Error)jjte000;}

0943     } finally {

0944      if (jjtc000) {

0945        jjtree.closeNodeScope(jjtn000, true);

0946      }

0947     }

0948   }

0949 

0950   final public void ClassOrInterfaceBody() throws ParseException {

0951  /*@bgen(jjtree) ClassOrInterfaceBody */

0952   ASTClassOrInterfaceBody jjtn000 = new ASTClassOrInterfaceBody(this, JJTCLASSORINTERFACEBODY);

0953   boolean jjtc000 = true;

0954   jjtree.openNodeScope(jjtn000);

0955     try {

0956       jj_consume_token(LBRACE);

0957       label_13:

0958       while (true) {

0959         switch (jj_nt.kind) {

0960         case ABSTRACT:

0961         case BOOLEAN:

0962         case BYTE:

0963         case CHAR:

0964         case CLASS:

0965         case DOUBLE:

0966         case FINAL:

0967         case FLOAT:

0968         case INT:

0969         case INTERFACE:

0970         case LONG:

0971         case NATIVE:

0972         case PRIVATE:

0973         case PROTECTED:

0974         case PUBLIC:

0975         case SHORT:

0976         case STATIC:

0977         case SYNCHRONIZED:

0978         case TRANSIENT:

0979         case VOID:

0980         case VOLATILE:

0981         case STRICTFP:

0982         case IDENTIFIER:

0983         case LBRACE:

0984         case SEMICOLON:

0985         case AT:

0986         case LT:

0987           ;

0988           break;

0989         default:

0990           jj_la1[30] = jj_gen;

0991           break label_13;

0992         }

0993         ClassOrInterfaceBodyDeclaration();

0994       }

0995       jj_consume_token(RBRACE);

0996     } catch (Throwable jjte000) {

0997     if (jjtc000) {

0998       jjtree.clearNodeScope(jjtn000);

0999       jjtc000 = false;

1000     } else {

1001       jjtree.popNode();

1002     }

1003     if (jjte000 instanceof RuntimeException) {

1004       {if (true) throw (RuntimeException)jjte000;}

1005     }

1006     if (jjte000 instanceof ParseException) {

1007       {if (true) throw (ParseException)jjte000;}

1008     }

1009     {if (true) throw (Error)jjte000;}

1010     } finally {

1011     if (jjtc000) {

1012       jjtree.closeNodeScope(jjtn000, true);

1013     }

1014     }

1015   }

1016 

1017   final public void ClassOrInterfaceBodyDeclaration() throws ParseException {

1018  /*@bgen(jjtree) ClassOrInterfaceBodyDeclaration */

1019    ASTClassOrInterfaceBodyDeclaration jjtn000 = new ASTClassOrInterfaceBodyDeclaration(this, JJTCLASSORINTERFACEBODYDECLARATION);

1020    boolean jjtc000 = true;

1021    jjtree.openNodeScope(jjtn000);int modifiers;

1022     try {

1023       if (jj_2_8(2147483647)) {

1024         Initializer();

1025       } else {

1026         switch (jj_nt.kind) {

1027         case ABSTRACT:

1028         case BOOLEAN:

1029         case BYTE:

1030         case CHAR:

1031         case CLASS:

1032         case DOUBLE:

1033         case FINAL:

1034         case FLOAT:

1035         case INT:

1036         case INTERFACE:

1037         case LONG:

1038         case NATIVE:

1039         case PRIVATE:

1040         case PROTECTED:

1041         case PUBLIC:

1042         case SHORT:

1043         case STATIC:

1044         case SYNCHRONIZED:

1045         case TRANSIENT:

1046         case VOID:

1047         case VOLATILE:

1048         case STRICTFP:

1049         case IDENTIFIER:

1050         case AT:

1051         case LT:

1052           modifiers = Modifiers();

1053           if (jj_2_4(3)) {

1054             ClassOrInterfaceDeclaration(modifiers);

1055           } else if (jj_2_5(3)) {

1056             EnumDeclaration(modifiers);

1057           } else if (jj_2_6(2147483647)) {

1058             ConstructorDeclaration(modifiers);

1059           } else if (jj_2_7(2147483647)) {

1060             FieldDeclaration(modifiers);

1061           } else {

1062             switch (jj_nt.kind) {

1063             case BOOLEAN:

1064             case BYTE:

1065             case CHAR:

1066             case DOUBLE:

1067             case FLOAT:

1068             case INT:

1069             case LONG:

1070             case SHORT:

1071             case VOID:

1072             case IDENTIFIER:

1073             case LT:

1074               MethodDeclaration(modifiers);

1075               break;

1076             case AT:

1077               AnnotationTypeDeclaration(modifiers);

1078               break;

1079             default:

1080               jj_la1[31] = jj_gen;

1081               jj_consume_token(-1);

1082               throw new ParseException();

1083             }

1084           }

1085           break;

1086         case SEMICOLON:

1087           jj_consume_token(SEMICOLON);

1088           break;

1089         default:

1090           jj_la1[32] = jj_gen;

1091           jj_consume_token(-1);

1092           throw new ParseException();

1093         }

1094       }

1095     } catch (Throwable jjte000) {

1096     if (jjtc000) {

1097       jjtree.clearNodeScope(jjtn000);

1098       jjtc000 = false;

1099     } else {

1100       jjtree.popNode();

1101     }

1102     if (jjte000 instanceof RuntimeException) {

1103       {if (true) throw (RuntimeException)jjte000;}

1104     }

1105     if (jjte000 instanceof ParseException) {

1106       {if (true) throw (ParseException)jjte000;}

1107     }

1108     {if (true) throw (Error)jjte000;}

1109     } finally {

1110     if (jjtc000) {

1111       jjtree.closeNodeScope(jjtn000, true);

1112     }

1113     }

1114   }

1115 

1116   final public void FieldDeclaration(int modifiers) throws ParseException {

1117  /*@bgen(jjtree) FieldDeclaration */

1118  ASTFieldDeclaration jjtn000 = new ASTFieldDeclaration(this, JJTFIELDDECLARATION);

1119  boolean jjtc000 = true;

1120  jjtree.openNodeScope(jjtn000);jjtn000.setModifiers(modifiers);

1121     try {

1122       Type();

1123       VariableDeclarator();

1124       label_14:

1125       while (true) {

1126         switch (jj_nt.kind) {

1127         case COMMA:

1128           ;

1129           break;

1130         default:

1131           jj_la1[33] = jj_gen;

1132           break label_14;

1133         }

1134         jj_consume_token(COMMA);

1135         VariableDeclarator();

1136       }

1137       jj_consume_token(SEMICOLON);

1138     } catch (Throwable jjte000) {

1139     if (jjtc000) {

1140       jjtree.clearNodeScope(jjtn000);

1141       jjtc000 = false;

1142     } else {

1143       jjtree.popNode();

1144     }

1145     if (jjte000 instanceof RuntimeException) {

1146       {if (true) throw (RuntimeException)jjte000;}

1147     }

1148     if (jjte000 instanceof ParseException) {

1149       {if (true) throw (ParseException)jjte000;}

1150     }

1151     {if (true) throw (Error)jjte000;}

1152     } finally {

1153     if (jjtc000) {

1154       jjtree.closeNodeScope(jjtn000, true);

1155     }

1156     }

1157   }

1158 

1159   final public void VariableDeclarator() throws ParseException {

1160  /*@bgen(jjtree) VariableDeclarator */

1161   ASTVariableDeclarator jjtn000 = new ASTVariableDeclarator(this, JJTVARIABLEDECLARATOR);

1162   boolean jjtc000 = true;

1163   jjtree.openNodeScope(jjtn000);

1164     try {

1165       VariableDeclaratorId();

1166       switch (jj_nt.kind) {

1167       case ASSIGN:

1168         jj_consume_token(ASSIGN);

1169         VariableInitializer();

1170         break;

1171       default:

1172         jj_la1[34] = jj_gen;

1173         ;

1174       }

1175     } catch (Throwable jjte000) {

1176     if (jjtc000) {

1177       jjtree.clearNodeScope(jjtn000);

1178       jjtc000 = false;

1179     } else {

1180       jjtree.popNode();

1181     }

1182     if (jjte000 instanceof RuntimeException) {

1183       {if (true) throw (RuntimeException)jjte000;}

1184     }

1185     if (jjte000 instanceof ParseException) {

1186       {if (true) throw (ParseException)jjte000;}

1187     }

1188     {if (true) throw (Error)jjte000;}

1189     } finally {

1190     if (jjtc000) {

1191       jjtree.closeNodeScope(jjtn000, true);

1192     }

1193     }

1194   }

1195 

1196   final public void VariableDeclaratorId() throws ParseException {

1197  /*@bgen(jjtree) VariableDeclaratorId */

1198  ASTVariableDeclaratorId jjtn000 = new ASTVariableDeclaratorId(this, JJTVARIABLEDECLARATORID);

1199  boolean jjtc000 = true;

1200  jjtree.openNodeScope(jjtn000);Token t;

1201     try {

1202       t = jj_consume_token(IDENTIFIER);

1203       label_15:

1204       while (true) {

1205         switch (jj_nt.kind) {

1206         case LBRACKET:

1207           ;

1208           break;

1209         default:

1210           jj_la1[35] = jj_gen;

1211           break label_15;

1212         }

1213         jj_consume_token(LBRACKET);

1214         jj_consume_token(RBRACKET);

1215                jjtn000.bumpArrayDepth();

1216       }

1217     jjtree.closeNodeScope(jjtn000, true);

1218     jjtc000 = false;

1219     checkForBadAssertUsage(t.image, "a variable name");

1220     checkForBadEnumUsage(t.image, "a variable name");

1221     jjtn000.setImage( t.image );

1222     } finally {

1223     if (jjtc000) {

1224       jjtree.closeNodeScope(jjtn000, true);

1225     }

1226     }

1227   }

1228 

1229   final public void VariableInitializer() throws ParseException {

1230  /*@bgen(jjtree) VariableInitializer */

1231   ASTVariableInitializer jjtn000 = new ASTVariableInitializer(this, JJTVARIABLEINITIALIZER);

1232   boolean jjtc000 = true;

1233   jjtree.openNodeScope(jjtn000);

1234     try {

1235       switch (jj_nt.kind) {

1236       case LBRACE:

1237         ArrayInitializer();

1238         break;

1239       case BOOLEAN:

1240       case BYTE:

1241       case CHAR:

1242       case DOUBLE:

1243       case FALSE:

1244       case FLOAT:

1245       case INT:

1246       case LONG:

1247       case NEW:

1248       case NULL:

1249       case SHORT:

1250       case SUPER:

1251       case THIS:

1252       case TRUE:

1253       case VOID:

1254       case INTEGER_LITERAL:

1255       case FLOATING_POINT_LITERAL:

1256       case HEX_FLOATING_POINT_LITERAL:

1257       case CHARACTER_LITERAL:

1258       case STRING_LITERAL:

1259       case IDENTIFIER:

1260       case LPAREN:

1261       case BANG:

1262       case TILDE:

1263       case INCR:

1264       case DECR:

1265       case PLUS:

1266       case MINUS:

1267         Expression();

1268         break;

1269       default:

1270         jj_la1[36] = jj_gen;

1271         jj_consume_token(-1);

1272         throw new ParseException();

1273       }

1274     } catch (Throwable jjte000) {

1275     if (jjtc000) {

1276       jjtree.clearNodeScope(jjtn000);

1277       jjtc000 = false;

1278     } else {

1279       jjtree.popNode();

1280     }

1281     if (jjte000 instanceof RuntimeException) {

1282       {if (true) throw (RuntimeException)jjte000;}

1283     }

1284     if (jjte000 instanceof ParseException) {

1285       {if (true) throw (ParseException)jjte000;}

1286     }

1287     {if (true) throw (Error)jjte000;}

1288     } finally {

1289     if (jjtc000) {

1290       jjtree.closeNodeScope(jjtn000, true);

1291     }

1292     }

1293   }

1294 

1295   final public void ArrayInitializer() throws ParseException {

1296  /*@bgen(jjtree) ArrayInitializer */

1297   ASTArrayInitializer jjtn000 = new ASTArrayInitializer(this, JJTARRAYINITIALIZER);

1298   boolean jjtc000 = true;

1299   jjtree.openNodeScope(jjtn000);

1300     try {

1301       jj_consume_token(LBRACE);

1302       switch (jj_nt.kind) {

1303       case BOOLEAN:

1304       case BYTE:

1305       case CHAR:

1306       case DOUBLE:

1307       case FALSE:

1308       case FLOAT:

1309       case INT:

1310       case LONG:

1311       case NEW:

1312       case NULL:

1313       case SHORT:

1314       case SUPER:

1315       case THIS:

1316       case TRUE:

1317       case VOID:

1318       case INTEGER_LITERAL:

1319       case FLOATING_POINT_LITERAL:

1320       case HEX_FLOATING_POINT_LITERAL:

1321       case CHARACTER_LITERAL:

1322       case STRING_LITERAL:

1323       case IDENTIFIER:

1324       case LPAREN:

1325       case LBRACE:

1326       case BANG:

1327       case TILDE:

1328       case INCR:

1329       case DECR:

1330       case PLUS:

1331       case MINUS:

1332         VariableInitializer();

1333         label_16:

1334         while (true) {

1335           if (jj_2_9(2)) {

1336             ;

1337           } else {

1338             break label_16;

1339           }

1340           jj_consume_token(COMMA);

1341           VariableInitializer();

1342         }

1343         break;

1344       default:

1345         jj_la1[37] = jj_gen;

1346         ;

1347       }

1348       switch (jj_nt.kind) {

1349       case COMMA:

1350         jj_consume_token(COMMA);

1351         break;

1352       default:

1353         jj_la1[38] = jj_gen;

1354         ;

1355       }

1356       jj_consume_token(RBRACE);

1357     } catch (Throwable jjte000) {

1358     if (jjtc000) {

1359       jjtree.clearNodeScope(jjtn000);

1360       jjtc000 = false;

1361     } else {

1362       jjtree.popNode();

1363     }

1364     if (jjte000 instanceof RuntimeException) {

1365       {if (true) throw (RuntimeException)jjte000;}

1366     }

1367     if (jjte000 instanceof ParseException) {

1368       {if (true) throw (ParseException)jjte000;}

1369     }

1370     {if (true) throw (Error)jjte000;}

1371     } finally {

1372     if (jjtc000) {

1373       jjtree.closeNodeScope(jjtn000, true);

1374     }

1375     }

1376   }

1377 

1378   final public void MethodDeclaration(int modifiers) throws ParseException {

1379  /*@bgen(jjtree) MethodDeclaration */

1380  ASTMethodDeclaration jjtn000 = new ASTMethodDeclaration(this, JJTMETHODDECLARATION);

1381  boolean jjtc000 = true;

1382  jjtree.openNodeScope(jjtn000);jjtn000.setModifiers(modifiers);

1383     try {

1384       switch (jj_nt.kind) {

1385       case LT:

1386         TypeParameters();

1387         break;

1388       default:

1389         jj_la1[39] = jj_gen;

1390         ;

1391       }

1392       ResultType();

1393       MethodDeclarator();

1394       switch (jj_nt.kind) {

1395       case THROWS:

1396         jj_consume_token(THROWS);

1397         NameList();

1398         break;

1399       default:

1400         jj_la1[40] = jj_gen;

1401         ;

1402       }

1403       switch (jj_nt.kind) {

1404       case LBRACE:

1405         Block();

1406         break;

1407       case SEMICOLON:

1408         jj_consume_token(SEMICOLON);

1409         break;

1410       default:

1411         jj_la1[41] = jj_gen;

1412         jj_consume_token(-1);

1413         throw new ParseException();

1414       }

1415     } catch (Throwable jjte000) {

1416     if (jjtc000) {

1417       jjtree.clearNodeScope(jjtn000);

1418       jjtc000 = false;

1419     } else {

1420       jjtree.popNode();

1421     }

1422     if (jjte000 instanceof RuntimeException) {

1423       {if (true) throw (RuntimeException)jjte000;}

1424     }

1425     if (jjte000 instanceof ParseException) {

1426       {if (true) throw (ParseException)jjte000;}

1427     }

1428     {if (true) throw (Error)jjte000;}

1429     } finally {

1430     if (jjtc000) {

1431       jjtree.closeNodeScope(jjtn000, true);

1432     }

1433     }

1434   }

1435 

1436   final public void MethodDeclarator() throws ParseException {

1437  /*@bgen(jjtree) MethodDeclarator */

1438  ASTMethodDeclarator jjtn000 = new ASTMethodDeclarator(this, JJTMETHODDECLARATOR);

1439  boolean jjtc000 = true;

1440  jjtree.openNodeScope(jjtn000);Token t;

1441     try {

1442       t = jj_consume_token(IDENTIFIER);

1443     checkForBadAssertUsage(t.image, "a method name");

1444     checkForBadEnumUsage(t.image, "a method name");

1445     jjtn000.setImage( t.image );

1446       FormalParameters();

1447       label_17:

1448       while (true) {

1449         switch (jj_nt.kind) {

1450         case LBRACKET:

1451           ;

1452           break;

1453         default:

1454           jj_la1[42] = jj_gen;

1455           break label_17;

1456         }

1457         jj_consume_token(LBRACKET);

1458         jj_consume_token(RBRACKET);

1459       }

1460     } catch (Throwable jjte000) {

1461     if (jjtc000) {

1462       jjtree.clearNodeScope(jjtn000);

1463       jjtc000 = false;

1464     } else {

1465       jjtree.popNode();

1466     }

1467     if (jjte000 instanceof RuntimeException) {

1468       {if (true) throw (RuntimeException)jjte000;}

1469     }

1470     if (jjte000 instanceof ParseException) {

1471       {if (true) throw (ParseException)jjte000;}

1472     }

1473     {if (true) throw (Error)jjte000;}

1474     } finally {

1475     if (jjtc000) {

1476       jjtree.closeNodeScope(jjtn000, true);

1477     }

1478     }

1479   }

1480 

1481   final public void FormalParameters() throws ParseException {

1482  /*@bgen(jjtree) FormalParameters */

1483   ASTFormalParameters jjtn000 = new ASTFormalParameters(this, JJTFORMALPARAMETERS);

1484   boolean jjtc000 = true;

1485   jjtree.openNodeScope(jjtn000);

1486     try {

1487       jj_consume_token(LPAREN);

1488       switch (jj_nt.kind) {

1489       case BOOLEAN:

1490       case BYTE:

1491       case CHAR:

1492       case DOUBLE:

1493       case FINAL:

1494       case FLOAT:

1495       case INT:

1496       case LONG:

1497       case SHORT:

1498       case IDENTIFIER:

1499       case AT:

1500         FormalParameter();

1501         label_18:

1502         while (true) {

1503           switch (jj_nt.kind) {

1504           case COMMA:

1505             ;

1506             break;

1507           default:

1508             jj_la1[43] = jj_gen;

1509             break label_18;

1510           }

1511           jj_consume_token(COMMA);

1512           FormalParameter();

1513         }

1514         break;

1515       default:

1516         jj_la1[44] = jj_gen;

1517         ;

1518       }

1519       jj_consume_token(RPAREN);

1520     } catch (Throwable jjte000) {

1521     if (jjtc000) {

1522       jjtree.clearNodeScope(jjtn000);

1523       jjtc000 = false;

1524     } else {

1525       jjtree.popNode();

1526     }

1527     if (jjte000 instanceof RuntimeException) {

1528       {if (true) throw (RuntimeException)jjte000;}

1529     }

1530     if (jjte000 instanceof ParseException) {

1531       {if (true) throw (ParseException)jjte000;}

1532     }

1533     {if (true) throw (Error)jjte000;}

1534     } finally {

1535     if (jjtc000) {

1536       jjtree.closeNodeScope(jjtn000, true);

1537     }

1538     }

1539   }

1540 

1541   final public void FormalParameter() throws ParseException {

1542  /*@bgen(jjtree) FormalParameter */

1543   ASTFormalParameter jjtn000 = new ASTFormalParameter(this, JJTFORMALPARAMETER);

1544   boolean jjtc000 = true;

1545   jjtree.openNodeScope(jjtn000);

1546     try {

1547       label_19:

1548       while (true) {

1549         switch (jj_nt.kind) {

1550         case FINAL:

1551         case AT:

1552           ;

1553           break;

1554         default:

1555           jj_la1[45] = jj_gen;

1556           break label_19;

1557         }

1558         switch (jj_nt.kind) {

1559         case FINAL:

1560           jj_consume_token(FINAL);

1561               jjtn000.setFinal(true);

1562           break;

1563         case AT:

1564           Annotation();

1565           break;

1566         default:

1567           jj_la1[46] = jj_gen;

1568           jj_consume_token(-1);

1569           throw new ParseException();

1570         }

1571       }

1572       Type();

1573       switch (jj_nt.kind) {

1574       case ELLIPSIS:

1575         jj_consume_token(ELLIPSIS);

1576             checkForBadVariableArgumentsUsage();

1577                                                    jjtn000.setVarargs();

1578         break;

1579       default:

1580         jj_la1[47] = jj_gen;

1581         ;

1582       }

1583       VariableDeclaratorId();

1584     } catch (Throwable jjte000) {

1585      if (jjtc000) {

1586        jjtree.clearNodeScope(jjtn000);

1587        jjtc000 = false;

1588      } else {

1589        jjtree.popNode();

1590      }

1591      if (jjte000 instanceof RuntimeException) {

1592        {if (true) throw (RuntimeException)jjte000;}

1593      }

1594      if (jjte000 instanceof ParseException) {

1595        {if (true) throw (ParseException)jjte000;}

1596      }

1597      {if (true) throw (Error)jjte000;}

1598     } finally {

1599      if (jjtc000) {

1600        jjtree.closeNodeScope(jjtn000, true);

1601      }

1602     }

1603   }

1604 

1605   final public void ConstructorDeclaration(int modifiers) throws ParseException {

1606  /*@bgen(jjtree) ConstructorDeclaration */

1607  ASTConstructorDeclaration jjtn000 = new ASTConstructorDeclaration(this, JJTCONSTRUCTORDECLARATION);

1608  boolean jjtc000 = true;

1609  jjtree.openNodeScope(jjtn000);jjtn000.setModifiers(modifiers);

1610 Token t;

1611     try {

1612       switch (jj_nt.kind) {

1613       case LT:

1614         TypeParameters();

1615         break;

1616       default:

1617         jj_la1[48] = jj_gen;

1618         ;

1619       }

1620       jj_consume_token(IDENTIFIER);

1621       FormalParameters();

1622       switch (jj_nt.kind) {

1623       case THROWS:

1624         jj_consume_token(THROWS);

1625         NameList();

1626         break;

1627       default:

1628         jj_la1[49] = jj_gen;

1629         ;

1630       }

1631       jj_consume_token(LBRACE);

1632       if (jj_2_10(2147483647)) {

1633         ExplicitConstructorInvocation();

1634       } else {

1635         ;

1636       }

1637       label_20:

1638       while (true) {

1639         if (jj_2_11(1)) {

1640           ;

1641         } else {

1642           break label_20;

1643         }

1644         BlockStatement();

1645       }

1646       t = jj_consume_token(RBRACE);

1647             jjtree.closeNodeScope(jjtn000, true);

1648             jjtc000 = false;

1649             if (isPrecededByComment(t)) { jjtn000.setContainsComment(); }

1650     } catch (Throwable jjte000) {

1651       if (jjtc000) {

1652         jjtree.clearNodeScope(jjtn000);

1653         jjtc000 = false;

1654       } else {

1655         jjtree.popNode();

1656       }

1657       if (jjte000 instanceof RuntimeException) {

1658         {if (true) throw (RuntimeException)jjte000;}

1659       }

1660       if (jjte000 instanceof ParseException) {

1661         {if (true) throw (ParseException)jjte000;}

1662       }

1663       {if (true) throw (Error)jjte000;}

1664     } finally {

1665       if (jjtc000) {

1666         jjtree.closeNodeScope(jjtn000, true);

1667       }

1668     }

1669   }

1670 

1671   final public void ExplicitConstructorInvocation() throws ParseException {

1672  /*@bgen(jjtree) ExplicitConstructorInvocation */

1673   ASTExplicitConstructorInvocation jjtn000 = new ASTExplicitConstructorInvocation(this, JJTEXPLICITCONSTRUCTORINVOCATION);

1674   boolean jjtc000 = true;

1675   jjtree.openNodeScope(jjtn000);

1676     try {

1677       if (jj_2_13(2147483647)) {

1678         jj_consume_token(THIS);

1679                                              jjtn000.setIsThis();

1680         Arguments();

1681         jj_consume_token(SEMICOLON);

1682       } else {

1683         switch (jj_nt.kind) {

1684         case BOOLEAN:

1685         case BYTE:

1686         case CHAR:

1687         case DOUBLE:

1688         case FALSE:

1689         case FLOAT:

1690         case INT:

1691         case LONG:

1692         case NEW:

1693         case NULL:

1694         case SHORT:

1695         case SUPER:

1696         case THIS:

1697         case TRUE:

1698         case VOID:

1699         case INTEGER_LITERAL:

1700         case FLOATING_POINT_LITERAL:

1701         case HEX_FLOATING_POINT_LITERAL:

1702         case CHARACTER_LITERAL:

1703         case STRING_LITERAL:

1704         case IDENTIFIER:

1705         case LPAREN:

1706           if (jj_2_12(2)) {

1707             PrimaryExpression();

1708             jj_consume_token(DOT);

1709             jj_consume_token(SUPER);

1710             jj_consume_token(LPAREN);

1711           } else {

1712             ;

1713           }

1714           switch (jj_nt.kind) {

1715           case SUPER:

1716             jj_consume_token(SUPER);

1717             break;

1718           case THIS:

1719             jj_consume_token(THIS);

1720             break;

1721           default:

1722             jj_la1[50] = jj_gen;

1723             jj_consume_token(-1);

1724             throw new ParseException();

1725           }

1726           Arguments();

1727           jj_consume_token(SEMICOLON);

1728           break;

1729         default:

1730           jj_la1[51] = jj_gen;

1731           jj_consume_token(-1);

1732           throw new ParseException();

1733         }

1734       }

1735     } catch (Throwable jjte000) {

1736     if (jjtc000) {

1737       jjtree.clearNodeScope(jjtn000);

1738       jjtc000 = false;

1739     } else {

1740       jjtree.popNode();

1741     }

1742     if (jjte000 instanceof RuntimeException) {

1743       {if (true) throw (RuntimeException)jjte000;}

1744     }

1745     if (jjte000 instanceof ParseException) {

1746       {if (true) throw (ParseException)jjte000;}

1747     }

1748     {if (true) throw (Error)jjte000;}

1749     } finally {

1750     if (jjtc000) {

1751       jjtree.closeNodeScope(jjtn000, true);

1752     }

1753     }

1754   }

1755 

1756   final public void Initializer() throws ParseException {

1757  /*@bgen(jjtree) Initializer */

1758   ASTInitializer jjtn000 = new ASTInitializer(this, JJTINITIALIZER);

1759   boolean jjtc000 = true;

1760   jjtree.openNodeScope(jjtn000);

1761     try {

1762       switch (jj_nt.kind) {

1763       case STATIC:

1764         jj_consume_token(STATIC);

1765               jjtn000.setStatic();

1766         break;

1767       default:

1768         jj_la1[52] = jj_gen;

1769         ;

1770       }

1771       Block();

1772     } catch (Throwable jjte000) {

1773     if (jjtc000) {

1774       jjtree.clearNodeScope(jjtn000);

1775       jjtc000 = false;

1776     } else {

1777       jjtree.popNode();

1778     }

1779     if (jjte000 instanceof RuntimeException) {

1780       {if (true) throw (RuntimeException)jjte000;}

1781     }

1782     if (jjte000 instanceof ParseException) {

1783       {if (true) throw (ParseException)jjte000;}

1784     }

1785     {if (true) throw (Error)jjte000;}

1786     } finally {

1787     if (jjtc000) {

1788       jjtree.closeNodeScope(jjtn000, true);

1789     }

1790     }

1791   }

1792 

1793 /*

1794  * Type, name and expression syntax follows.

1795  */

1796   final public void Type() throws ParseException {

1797  /*@bgen(jjtree) Type */

1798   ASTType jjtn000 = new ASTType(this, JJTTYPE);

1799   boolean jjtc000 = true;

1800   jjtree.openNodeScope(jjtn000);

1801     try {

1802       if (jj_2_14(2)) {

1803         ReferenceType();

1804       } else {

1805         switch (jj_nt.kind) {

1806         case BOOLEAN:

1807         case BYTE:

1808         case CHAR:

1809         case DOUBLE:

1810         case FLOAT:

1811         case INT:

1812         case LONG:

1813         case SHORT:

1814           PrimitiveType();

1815           break;

1816         default:

1817           jj_la1[53] = jj_gen;

1818           jj_consume_token(-1);

1819           throw new ParseException();

1820         }

1821       }

1822     } catch (Throwable jjte000) {

1823      if (jjtc000) {

1824        jjtree.clearNodeScope(jjtn000);

1825        jjtc000 = false;

1826      } else {

1827        jjtree.popNode();

1828      }

1829      if (jjte000 instanceof RuntimeException) {

1830        {if (true) throw (RuntimeException)jjte000;}

1831      }

1832      if (jjte000 instanceof ParseException) {

1833        {if (true) throw (ParseException)jjte000;}

1834      }

1835      {if (true) throw (Error)jjte000;}

1836     } finally {

1837      if (jjtc000) {

1838        jjtree.closeNodeScope(jjtn000, true);

1839      }

1840     }

1841   }

1842 

1843   final public void ReferenceType() throws ParseException {

1844  /*@bgen(jjtree) ReferenceType */

1845   ASTReferenceType jjtn000 = new ASTReferenceType(this, JJTREFERENCETYPE);

1846   boolean jjtc000 = true;

1847   jjtree.openNodeScope(jjtn000);

1848     try {

1849       switch (jj_nt.kind) {

1850       case BOOLEAN:

1851       case BYTE:

1852       case CHAR:

1853       case DOUBLE:

1854       case FLOAT:

1855       case INT:

1856       case LONG:

1857       case SHORT:

1858         PrimitiveType();

1859         label_21:

1860         while (true) {

1861           jj_consume_token(LBRACKET);

1862           jj_consume_token(RBRACKET);

1863                                             jjtn000.bumpArrayDepth();

1864           if (jj_2_15(2)) {

1865             ;

1866           } else {

1867             break label_21;

1868           }

1869         }

1870         break;

1871       case IDENTIFIER:

1872         ClassOrInterfaceType();

1873         label_22:

1874         while (true) {

1875           if (jj_2_16(2)) {

1876             ;

1877           } else {

1878             break label_22;

1879           }

1880           jj_consume_token(LBRACKET);

1881           jj_consume_token(RBRACKET);

1882                                                        jjtn000.bumpArrayDepth();

1883         }

1884         break;

1885       default:

1886         jj_la1[54] = jj_gen;

1887         jj_consume_token(-1);

1888         throw new ParseException();

1889       }

1890     } catch (Throwable jjte000) {

1891      if (jjtc000) {

1892        jjtree.clearNodeScope(jjtn000);

1893        jjtc000 = false;

1894      } else {

1895        jjtree.popNode();

1896      }

1897      if (jjte000 instanceof RuntimeException) {

1898        {if (true) throw (RuntimeException)jjte000;}

1899      }

1900      if (jjte000 instanceof ParseException) {

1901        {if (true) throw (ParseException)jjte000;}

1902      }

1903      {if (true) throw (Error)jjte000;}

1904     } finally {

1905      if (jjtc000) {

1906        jjtree.closeNodeScope(jjtn000, true);

1907      }

1908     }

1909   }

1910 

1911   final public void ClassOrInterfaceType() throws ParseException {

1912  /*@bgen(jjtree) ClassOrInterfaceType */

1913   ASTClassOrInterfaceType jjtn000 = new ASTClassOrInterfaceType(this, JJTCLASSORINTERFACETYPE);

1914   boolean jjtc000 = true;

1915   jjtree.openNodeScope(jjtn000);StringBuffer s = new StringBuffer();

1916   Token t;

1917     try {

1918       t = jj_consume_token(IDENTIFIER);

1919                   s.append(t.image);

1920       if (jj_2_17(2)) {

1921         TypeArguments();

1922       } else {

1923         ;

1924       }

1925       label_23:

1926       while (true) {

1927         if (jj_2_18(2)) {

1928           ;

1929         } else {

1930           break label_23;

1931         }

1932         jj_consume_token(DOT);

1933         t = jj_consume_token(IDENTIFIER);

1934                                      s.append('.').append(t.image);

1935         if (jj_2_19(2)) {

1936           TypeArguments();

1937         } else {

1938           ;

1939         }

1940       }

1941     jjtree.closeNodeScope(jjtn000, true);

1942     jjtc000 = false;

1943    jjtn000.setImage(s.toString());

1944     } catch (Throwable jjte000) {

1945     if (jjtc000) {

1946       jjtree.clearNodeScope(jjtn000);

1947       jjtc000 = false;

1948     } else {

1949       jjtree.popNode();

1950     }

1951     if (jjte000 instanceof RuntimeException) {

1952       {if (true) throw (RuntimeException)jjte000;}

1953     }

1954     if (jjte000 instanceof ParseException) {

1955       {if (true) throw (ParseException)jjte000;}

1956     }

1957     {if (true) throw (Error)jjte000;}

1958     } finally {

1959     if (jjtc000) {

1960       jjtree.closeNodeScope(jjtn000, true);

1961     }

1962     }

1963   }

1964 

1965   final public void TypeArguments() throws ParseException {

1966  /*@bgen(jjtree) TypeArguments */

1967   ASTTypeArguments jjtn000 = new ASTTypeArguments(this, JJTTYPEARGUMENTS);

1968   boolean jjtc000 = true;

1969   jjtree.openNodeScope(jjtn000);

1970     try {

1971       jj_consume_token(LT);

1972         checkForBadGenericsUsage();

1973       TypeArgument();

1974       label_24:

1975       while (true) {

1976         switch (jj_nt.kind) {

1977         case COMMA:

1978           ;

1979           break;

1980         default:

1981           jj_la1[55] = jj_gen;

1982           break label_24;

1983         }

1984         jj_consume_token(COMMA);

1985         TypeArgument();

1986       }

1987       jj_consume_token(GT);

1988     } catch (Throwable jjte000) {

1989      if (jjtc000) {

1990        jjtree.clearNodeScope(jjtn000);

1991        jjtc000 = false;

1992      } else {

1993        jjtree.popNode();

1994      }

1995      if (jjte000 instanceof RuntimeException) {

1996        {if (true) throw (RuntimeException)jjte000;}

1997      }

1998      if (jjte000 instanceof ParseException) {

1999        {if (true) throw (ParseException)jjte000;}

2000      }

2001      {if (true) throw (Error)jjte000;}

2002     } finally {

2003      if (jjtc000) {

2004        jjtree.closeNodeScope(jjtn000, true);

2005      }

2006     }

2007   }

2008 

2009   final public void TypeArgument() throws ParseException {

2010  /*@bgen(jjtree) TypeArgument */

2011   ASTTypeArgument jjtn000 = new ASTTypeArgument(this, JJTTYPEARGUMENT);

2012   boolean jjtc000 = true;

2013   jjtree.openNodeScope(jjtn000);

2014     try {

2015       switch (jj_nt.kind) {

2016       case BOOLEAN:

2017       case BYTE:

2018       case CHAR:

2019       case DOUBLE:

2020       case FLOAT:

2021       case INT:

2022       case LONG:

2023       case SHORT:

2024       case IDENTIFIER:

2025         ReferenceType();

2026         break;

2027       case HOOK:

2028         jj_consume_token(HOOK);

2029         switch (jj_nt.kind) {

2030         case EXTENDS:

2031         case SUPER:

2032           WildcardBounds();

2033           break;

2034         default:

2035           jj_la1[56] = jj_gen;

2036           ;

2037         }

2038         break;

2039       default:

2040         jj_la1[57] = jj_gen;

2041         jj_consume_token(-1);

2042         throw new ParseException();

2043       }

2044     } catch (Throwable jjte000) {

2045      if (jjtc000) {

2046        jjtree.clearNodeScope(jjtn000);

2047        jjtc000 = false;

2048      } else {

2049        jjtree.popNode();

2050      }

2051      if (jjte000 instanceof RuntimeException) {

2052        {if (true) throw (RuntimeException)jjte000;}

2053      }

2054      if (jjte000 instanceof ParseException) {

2055        {if (true) throw (ParseException)jjte000;}

2056      }

2057      {if (true) throw (Error)jjte000;}

2058     } finally {

2059      if (jjtc000) {

2060        jjtree.closeNodeScope(jjtn000, true);

2061      }

2062     }

2063   }

2064 

2065   final public void WildcardBounds() throws ParseException {

2066  /*@bgen(jjtree) WildcardBounds */

2067   ASTWildcardBounds jjtn000 = new ASTWildcardBounds(this, JJTWILDCARDBOUNDS);

2068   boolean jjtc000 = true;

2069   jjtree.openNodeScope(jjtn000);

2070     try {

2071       switch (jj_nt.kind) {

2072       case EXTENDS:

2073         jj_consume_token(EXTENDS);

2074         ReferenceType();

2075         break;

2076       case SUPER:

2077         jj_consume_token(SUPER);

2078         ReferenceType();

2079         break;

2080       default:

2081         jj_la1[58] = jj_gen;

2082         jj_consume_token(-1);

2083         throw new ParseException();

2084       }

2085     } catch (Throwable jjte000) {

2086      if (jjtc000) {

2087        jjtree.clearNodeScope(jjtn000);

2088        jjtc000 = false;

2089      } else {

2090        jjtree.popNode();

2091      }

2092      if (jjte000 instanceof RuntimeException) {

2093        {if (true) throw (RuntimeException)jjte000;}

2094      }

2095      if (jjte000 instanceof ParseException) {

2096        {if (true) throw (ParseException)jjte000;}

2097      }

2098      {if (true) throw (Error)jjte000;}

2099     } finally {

2100      if (jjtc000) {

2101        jjtree.closeNodeScope(jjtn000, true);

2102      }

2103     }

2104   }

2105 

2106   final public void PrimitiveType() throws ParseException {

2107  /*@bgen(jjtree) PrimitiveType */

2108   ASTPrimitiveType jjtn000 = new ASTPrimitiveType(this, JJTPRIMITIVETYPE);

2109   boolean jjtc000 = true;

2110   jjtree.openNodeScope(jjtn000);

2111     try {

2112       switch (jj_nt.kind) {

2113       case BOOLEAN:

2114         jj_consume_token(BOOLEAN);

2115               jjtree.closeNodeScope(jjtn000, true);

2116               jjtc000 = false;

2117              jjtn000.setImage("boolean");

2118         break;

2119       case CHAR:

2120         jj_consume_token(CHAR);

2121            jjtree.closeNodeScope(jjtn000, true);

2122            jjtc000 = false;

2123           jjtn000.setImage("char");

2124         break;

2125       case BYTE:

2126         jj_consume_token(BYTE);

2127            jjtree.closeNodeScope(jjtn000, true);

2128            jjtc000 = false;

2129           jjtn000.setImage("byte");

2130         break;

2131       case SHORT:

2132         jj_consume_token(SHORT);

2133             jjtree.closeNodeScope(jjtn000, true);

2134             jjtc000 = false;

2135            jjtn000.setImage("short");

2136         break;

2137       case INT:

2138         jj_consume_token(INT);

2139           jjtree.closeNodeScope(jjtn000, true);

2140           jjtc000 = false;

2141          jjtn000.setImage("int");

2142         break;

2143       case LONG:

2144         jj_consume_token(LONG);

2145            jjtree.closeNodeScope(jjtn000, true);

2146            jjtc000 = false;

2147           jjtn000.setImage("long");

2148         break;

2149       case FLOAT:

2150         jj_consume_token(FLOAT);

2151             jjtree.closeNodeScope(jjtn000, true);

2152             jjtc000 = false;

2153            jjtn000.setImage("float");

2154         break;

2155       case DOUBLE:

2156         jj_consume_token(DOUBLE);

2157              jjtree.closeNodeScope(jjtn000, true);

2158              jjtc000 = false;

2159             jjtn000.setImage("double");

2160         break;

2161       default:

2162         jj_la1[59] = jj_gen;

2163         jj_consume_token(-1);

2164         throw new ParseException();

2165       }

2166     } finally {

2167     if (jjtc000) {

2168       jjtree.closeNodeScope(jjtn000, true);

2169     }

2170     }

2171   }

2172 

2173   final public void ResultType() throws ParseException {

2174  /*@bgen(jjtree) ResultType */

2175   ASTResultType jjtn000 = new ASTResultType(this, JJTRESULTTYPE);

2176   boolean jjtc000 = true;

2177   jjtree.openNodeScope(jjtn000);

2178     try {

2179       switch (jj_nt.kind) {

2180       case VOID:

2181         jj_consume_token(VOID);

2182         break;

2183       case BOOLEAN:

2184       case BYTE:

2185       case CHAR:

2186       case DOUBLE:

2187       case FLOAT:

2188       case INT:

2189       case LONG:

2190       case SHORT:

2191       case IDENTIFIER:

2192         Type();

2193         break;

2194       default:

2195         jj_la1[60] = jj_gen;

2196         jj_consume_token(-1);

2197         throw new ParseException();

2198       }

2199     } catch (Throwable jjte000) {

2200     if (jjtc000) {

2201       jjtree.clearNodeScope(jjtn000);

2202       jjtc000 = false;

2203     } else {

2204       jjtree.popNode();

2205     }

2206     if (jjte000 instanceof RuntimeException) {

2207       {if (true) throw (RuntimeException)jjte000;}

2208     }

2209     if (jjte000 instanceof ParseException) {

2210       {if (true) throw (ParseException)jjte000;}

2211     }

2212     {if (true) throw (Error)jjte000;}

2213     } finally {

2214     if (jjtc000) {

2215       jjtree.closeNodeScope(jjtn000, true);

2216     }

2217     }

2218   }

2219 

2220   final public void Name() throws ParseException {

2221  /*@bgen(jjtree) Name */

2222   ASTName jjtn000 = new ASTName(this, JJTNAME);

2223   boolean jjtc000 = true;

2224   jjtree.openNodeScope(jjtn000);StringBuffer s = new StringBuffer();

2225   Token t;

2226     try {

2227       t = jj_consume_token(IDENTIFIER);

2228     jjtn000.testingOnly__setBeginLine( t.beginLine);

2229     jjtn000.testingOnly__setBeginColumn( t.beginColumn);

2230     s.append(t.image);

2231       label_25:

2232       while (true) {

2233         if (jj_2_20(2)) {

2234           ;

2235         } else {

2236           break label_25;

2237         }

2238         jj_consume_token(DOT);

2239         t = jj_consume_token(IDENTIFIER);

2240      s.append('.').append(t.image);

2241       }

2242     jjtree.closeNodeScope(jjtn000, true);

2243     jjtc000 = false;

2244    jjtn000.setImage(s.toString());

2245     } finally {

2246     if (jjtc000) {

2247       jjtree.closeNodeScope(jjtn000, true);

2248     }

2249     }

2250   }

2251 

2252   final public void NameList() throws ParseException {

2253  /*@bgen(jjtree) NameList */

2254   ASTNameList jjtn000 = new ASTNameList(this, JJTNAMELIST);

2255   boolean jjtc000 = true;

2256   jjtree.openNodeScope(jjtn000);

2257     try {

2258       Name();

2259       label_26:

2260       while (true) {

2261         switch (jj_nt.kind) {

2262         case COMMA:

2263           ;

2264           break;

2265         default:

2266           jj_la1[61] = jj_gen;

2267           break label_26;

2268         }

2269         jj_consume_token(COMMA);

2270         Name();

2271       }

2272     } catch (Throwable jjte000) {

2273     if (jjtc000) {

2274       jjtree.clearNodeScope(jjtn000);

2275       jjtc000 = false;

2276     } else {

2277       jjtree.popNode();

2278     }

2279     if (jjte000 instanceof RuntimeException) {

2280       {if (true) throw (RuntimeException)jjte000;}

2281     }

2282     if (jjte000 instanceof ParseException) {

2283       {if (true) throw (ParseException)jjte000;}

2284     }

2285     {if (true) throw (Error)jjte000;}

2286     } finally {

2287     if (jjtc000) {

2288       jjtree.closeNodeScope(jjtn000, true);

2289     }

2290     }

2291   }

2292 

2293 /*

2294  * Expression syntax follows.

2295  */

2296   final public void Expression() throws ParseException {

2297  /*@bgen(jjtree) Expression */

2298   ASTExpression jjtn000 = new ASTExpression(this, JJTEXPRESSION);

2299   boolean jjtc000 = true;

2300   jjtree.openNodeScope(jjtn000);

2301     try {

2302       ConditionalExpression();

2303       switch (jj_nt.kind) {

2304       case ASSIGN:

2305       case PLUSASSIGN:

2306       case MINUSASSIGN:

2307       case STARASSIGN:

2308       case SLASHASSIGN:

2309       case ANDASSIGN:

2310       case ORASSIGN:

2311       case XORASSIGN:

2312       case REMASSIGN:

2313       case LSHIFTASSIGN:

2314       case RSIGNEDSHIFTASSIGN:

2315       case RUNSIGNEDSHIFTASSIGN:

2316         AssignmentOperator();

2317         Expression();

2318         break;

2319       default:

2320         jj_la1[62] = jj_gen;

2321         ;

2322       }

2323     } catch (Throwable jjte000) {

2324     if (jjtc000) {

2325       jjtree.clearNodeScope(jjtn000);

2326       jjtc000 = false;

2327     } else {

2328       jjtree.popNode();

2329     }

2330     if (jjte000 instanceof RuntimeException) {

2331       {if (true) throw (RuntimeException)jjte000;}

2332     }

2333     if (jjte000 instanceof ParseException) {

2334       {if (true) throw (ParseException)jjte000;}

2335     }

2336     {if (true) throw (Error)jjte000;}

2337     } finally {

2338     if (jjtc000) {

2339       jjtree.closeNodeScope(jjtn000, true);

2340     }

2341     }

2342   }

2343 

2344   final public void AssignmentOperator() throws ParseException {

2345  /*@bgen(jjtree) AssignmentOperator */

2346   ASTAssignmentOperator jjtn000 = new ASTAssignmentOperator(this, JJTASSIGNMENTOPERATOR);

2347   boolean jjtc000 = true;

2348   jjtree.openNodeScope(jjtn000);

2349     try {

2350       switch (jj_nt.kind) {

2351       case ASSIGN:

2352         jj_consume_token(ASSIGN);

2353                 jjtree.closeNodeScope(jjtn000, true);

2354                 jjtc000 = false;

2355                jjtn000.setImage("=");

2356         break;

2357       case STARASSIGN:

2358         jj_consume_token(STARASSIGN);

2359                 jjtree.closeNodeScope(jjtn000, true);

2360                 jjtc000 = false;

2361                jjtn000.setImage("*="); jjtn000.setCompound();

2362         break;

2363       case SLASHASSIGN:

2364         jj_consume_token(SLASHASSIGN);

2365                 jjtree.closeNodeScope(jjtn000, true);

2366                 jjtc000 = false;

2367                jjtn000.setImage("/="); jjtn000.setCompound();

2368         break;

2369       case REMASSIGN:

2370         jj_consume_token(REMASSIGN);

2371                 jjtree.closeNodeScope(jjtn000, true);

2372                 jjtc000 = false;

2373                jjtn000.setImage("%="); jjtn000.setCompound();

2374         break;

2375       case PLUSASSIGN:

2376         jj_consume_token(PLUSASSIGN);

2377                 jjtree.closeNodeScope(jjtn000, true);

2378                 jjtc000 = false;

2379                jjtn000.setImage("+="); jjtn000.setCompound();

2380         break;

2381       case MINUSASSIGN:

2382         jj_consume_token(MINUSASSIGN);

2383                 jjtree.closeNodeScope(jjtn000, true);

2384                 jjtc000 = false;

2385                jjtn000.setImage("-="); jjtn000.setCompound();

2386         break;

2387       case LSHIFTASSIGN:

2388         jj_consume_token(LSHIFTASSIGN);

2389                 jjtree.closeNodeScope(jjtn000, true);

2390                 jjtc000 = false;

2391                jjtn000.setImage("<<="); jjtn000.setCompound();

2392         break;

2393       case RSIGNEDSHIFTASSIGN:

2394         jj_consume_token(RSIGNEDSHIFTASSIGN);

2395                 jjtree.closeNodeScope(jjtn000, true);

2396                 jjtc000 = false;

2397                jjtn000.setImage(">>="); jjtn000.setCompound();

2398         break;

2399       case RUNSIGNEDSHIFTASSIGN:

2400         jj_consume_token(RUNSIGNEDSHIFTASSIGN);

2401                 jjtree.closeNodeScope(jjtn000, true);

2402                 jjtc000 = false;

2403                jjtn000.setImage(">>>="); jjtn000.setCompound();

2404         break;

2405       case ANDASSIGN:

2406         jj_consume_token(ANDASSIGN);

2407                 jjtree.closeNodeScope(jjtn000, true);

2408                 jjtc000 = false;

2409                jjtn000.setImage("&="); jjtn000.setCompound();

2410         break;

2411       case XORASSIGN:

2412         jj_consume_token(XORASSIGN);

2413                 jjtree.closeNodeScope(jjtn000, true);

2414                 jjtc000 = false;

2415                jjtn000.setImage("^="); jjtn000.setCompound();

2416         break;

2417       case ORASSIGN:

2418         jj_consume_token(ORASSIGN);

2419                 jjtree.closeNodeScope(jjtn000, true);

2420                 jjtc000 = false;

2421                jjtn000.setImage("|="); jjtn000.setCompound();

2422         break;

2423       default:

2424         jj_la1[63] = jj_gen;

2425         jj_consume_token(-1);

2426         throw new ParseException();

2427       }

2428     } finally {

2429         if (jjtc000) {

2430           jjtree.closeNodeScope(jjtn000, true);

2431         }

2432     }

2433   }

2434 

2435   final public void ConditionalExpression() throws ParseException {

2436  /*@bgen(jjtree) #ConditionalExpression(> 1) */

2437   ASTConditionalExpression jjtn000 = new ASTConditionalExpression(this, JJTCONDITIONALEXPRESSION);

2438   boolean jjtc000 = true;

2439   jjtree.openNodeScope(jjtn000);

2440     try {

2441       ConditionalOrExpression();

2442       switch (jj_nt.kind) {

2443       case HOOK:

2444         jj_consume_token(HOOK);

2445                                    jjtn000.setTernary();

2446         Expression();

2447         jj_consume_token(COLON);

2448         ConditionalExpression();

2449         break;

2450       default:

2451         jj_la1[64] = jj_gen;

2452         ;

2453       }

2454     } catch (Throwable jjte000) {

2455     if (jjtc000) {

2456       jjtree.clearNodeScope(jjtn000);

2457       jjtc000 = false;

2458     } else {

2459       jjtree.popNode();

2460     }

2461     if (jjte000 instanceof RuntimeException) {

2462       {if (true) throw (RuntimeException)jjte000;}

2463     }

2464     if (jjte000 instanceof ParseException) {

2465       {if (true) throw (ParseException)jjte000;}

2466     }

2467     {if (true) throw (Error)jjte000;}

2468     } finally {

2469     if (jjtc000) {

2470       jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);

2471     }

2472     }

2473   }

2474 

2475   final public void ConditionalOrExpression() throws ParseException {

2476  /*@bgen(jjtree) #ConditionalOrExpression(> 1) */

2477   ASTConditionalOrExpression jjtn000 = new ASTConditionalOrExpression(this, JJTCONDITIONALOREXPRESSION);

2478   boolean jjtc000 = true;

2479   jjtree.openNodeScope(jjtn000);

2480     try {

2481       ConditionalAndExpression();

2482       label_27:

2483       while (true) {

2484         switch (jj_nt.kind) {

2485         case SC_OR:

2486           ;

2487           break;

2488         default:

2489           jj_la1[65] = jj_gen;

2490           break label_27;

2491         }

2492         jj_consume_token(SC_OR);

2493         ConditionalAndExpression();

2494       }

2495     } catch (Throwable jjte000) {

2496     if (jjtc000) {

2497       jjtree.clearNodeScope(jjtn000);

2498       jjtc000 = false;

2499     } else {

2500       jjtree.popNode();

2501     }

2502     if (jjte000 instanceof RuntimeException) {

2503       {if (true) throw (RuntimeException)jjte000;}

2504     }

2505     if (jjte000 instanceof ParseException) {

2506       {if (true) throw (ParseException)jjte000;}

2507     }

2508     {if (true) throw (Error)jjte000;}

2509     } finally {

2510     if (jjtc000) {

2511       jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);

2512     }

2513     }

2514   }

2515 

2516   final public void ConditionalAndExpression() throws ParseException {

2517  /*@bgen(jjtree) #ConditionalAndExpression(> 1) */

2518   ASTConditionalAndExpression jjtn000 = new ASTConditionalAndExpression(this, JJTCONDITIONALANDEXPRESSION);

2519   boolean jjtc000 = true;

2520   jjtree.openNodeScope(jjtn000);

2521     try {

2522       InclusiveOrExpression();

2523       label_28:

2524       while (true) {

2525         switch (jj_nt.kind) {

2526         case SC_AND:

2527           ;

2528           break;

2529         default:

2530           jj_la1[66] = jj_gen;

2531           break label_28;

2532         }

2533         jj_consume_token(SC_AND);

2534         InclusiveOrExpression();

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     }

2554     }

2555   }

2556 

2557   final public void InclusiveOrExpression() throws ParseException {

2558  /*@bgen(jjtree) #InclusiveOrExpression(> 1) */

2559   ASTInclusiveOrExpression jjtn000 = new ASTInclusiveOrExpression(this, JJTINCLUSIVEOREXPRESSION);

2560   boolean jjtc000 = true;

2561   jjtree.openNodeScope(jjtn000);

2562     try {

2563       ExclusiveOrExpression();

2564       label_29:

2565       while (true) {

2566         switch (jj_nt.kind) {

2567         case BIT_OR:

2568           ;

2569           break;

2570         default:

2571           jj_la1[67] = jj_gen;

2572           break label_29;

2573         }

2574         jj_consume_token(BIT_OR);

2575         ExclusiveOrExpression();

2576       }

2577     } catch (Throwable jjte000) {

2578     if (jjtc000) {

2579       jjtree.clearNodeScope(jjtn000);

2580       jjtc000 = false;

2581     } else {

2582       jjtree.popNode();

2583     }

2584     if (jjte000 instanceof RuntimeException) {

2585       {if (true) throw (RuntimeException)jjte000;}

2586     }

2587     if (jjte000 instanceof ParseException) {

2588       {if (true) throw (ParseException)jjte000;}

2589     }

2590     {if (true) throw (Error)jjte000;}

2591     } finally {

2592     if (jjtc000) {

2593       jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);

2594     }

2595     }

2596   }

2597 

2598   final public void ExclusiveOrExpression() throws ParseException {

2599  /*@bgen(jjtree) #ExclusiveOrExpression(> 1) */

2600   ASTExclusiveOrExpression jjtn000 = new ASTExclusiveOrExpression(this, JJTEXCLUSIVEOREXPRESSION);

2601   boolean jjtc000 = true;

2602   jjtree.openNodeScope(jjtn000);

2603     try {

2604       AndExpression();

2605       label_30:

2606       while (true) {

2607         switch (jj_nt.kind) {

2608         case XOR:

2609           ;

2610           break;

2611         default:

2612           jj_la1[68] = jj_gen;

2613           break label_30;

2614         }

2615         jj_consume_token(XOR);

2616         AndExpression();

2617       }

2618     } catch (Throwable jjte000) {

2619     if (jjtc000) {

2620       jjtree.clearNodeScope(jjtn000);

2621       jjtc000 = false;

2622     } else {

2623       jjtree.popNode();

2624     }

2625     if (jjte000 instanceof RuntimeException) {

2626       {if (true) throw (RuntimeException)jjte000;}

2627     }

2628     if (jjte000 instanceof ParseException) {

2629       {if (true) throw (ParseException)jjte000;}

2630     }

2631     {if (true) throw (Error)jjte000;}

2632     } finally {

2633     if (jjtc000) {

2634       jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);

2635     }

2636     }

2637   }

2638 

2639   final public void AndExpression() throws ParseException {

2640  /*@bgen(jjtree) #AndExpression(> 1) */

2641   ASTAndExpression jjtn000 = new ASTAndExpression(this, JJTANDEXPRESSION);

2642   boolean jjtc000 = true;

2643   jjtree.openNodeScope(jjtn000);

2644     try {

2645       EqualityExpression();

2646       label_31:

2647       while (true) {

2648         switch (jj_nt.kind) {

2649         case BIT_AND:

2650           ;

2651           break;

2652         default:

2653           jj_la1[69] = jj_gen;

2654           break label_31;

2655         }

2656         jj_consume_token(BIT_AND);

2657         EqualityExpression();

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     }

2677     }

2678   }

2679 

2680   final public void EqualityExpression() throws ParseException {

2681  /*@bgen(jjtree) #EqualityExpression(> 1) */

2682   ASTEqualityExpression jjtn000 = new ASTEqualityExpression(this, JJTEQUALITYEXPRESSION);

2683   boolean jjtc000 = true;

2684   jjtree.openNodeScope(jjtn000);

2685     try {

2686       InstanceOfExpression();

2687       label_32:

2688       while (true) {

2689         switch (jj_nt.kind) {

2690         case EQ:

2691         case NE:

2692           ;

2693           break;

2694         default:

2695           jj_la1[70] = jj_gen;

2696           break label_32;

2697         }

2698         switch (jj_nt.kind) {

2699         case EQ:

2700           jj_consume_token(EQ);

2701                                     jjtn000.setImage("==");

2702           break;

2703         case NE:

2704           jj_consume_token(NE);

2705                                                                      jjtn000.setImage("!=");

2706           break;

2707         default:

2708           jj_la1[71] = jj_gen;

2709           jj_consume_token(-1);

2710           throw new ParseException();

2711         }

2712         InstanceOfExpression();

2713       }

2714     } catch (Throwable jjte000) {

2715     if (jjtc000) {

2716       jjtree.clearNodeScope(jjtn000);

2717       jjtc000 = false;

2718     } else {

2719       jjtree.popNode();

2720     }

2721     if (jjte000 instanceof RuntimeException) {

2722       {if (true) throw (RuntimeException)jjte000;}

2723     }

2724     if (jjte000 instanceof ParseException) {

2725       {if (true) throw (ParseException)jjte000;}

2726     }

2727     {if (true) throw (Error)jjte000;}

2728     } finally {

2729     if (jjtc000) {

2730       jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);

2731     }

2732     }

2733   }

2734 

2735   final public void InstanceOfExpression() throws ParseException {

2736  /*@bgen(jjtree) #InstanceOfExpression(> 1) */

2737   ASTInstanceOfExpression jjtn000 = new ASTInstanceOfExpression(this, JJTINSTANCEOFEXPRESSION);

2738   boolean jjtc000 = true;

2739   jjtree.openNodeScope(jjtn000);

2740     try {

2741       RelationalExpression();

2742       switch (jj_nt.kind) {

2743       case INSTANCEOF:

2744         jj_consume_token(INSTANCEOF);

2745         Type();

2746         break;

2747       default:

2748         jj_la1[72] = jj_gen;

2749         ;

2750       }

2751     } catch (Throwable jjte000) {

2752     if (jjtc000) {

2753       jjtree.clearNodeScope(jjtn000);

2754       jjtc000 = false;

2755     } else {

2756       jjtree.popNode();

2757     }

2758     if (jjte000 instanceof RuntimeException) {

2759       {if (true) throw (RuntimeException)jjte000;}

2760     }

2761     if (jjte000 instanceof ParseException) {

2762       {if (true) throw (ParseException)jjte000;}

2763     }

2764     {if (true) throw (Error)jjte000;}

2765     } finally {

2766     if (jjtc000) {

2767       jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);

2768     }

2769     }

2770   }

2771 

2772   final public void RelationalExpression() throws ParseException {

2773  /*@bgen(jjtree) #RelationalExpression(> 1) */

2774   ASTRelationalExpression jjtn000 = new ASTRelationalExpression(this, JJTRELATIONALEXPRESSION);

2775   boolean jjtc000 = true;

2776   jjtree.openNodeScope(jjtn000);

2777     try {

2778       ShiftExpression();

2779       label_33:

2780       while (true) {

2781         switch (jj_nt.kind) {

2782         case LT:

2783         case LE:

2784         case GE:

2785         case GT:

2786           ;

2787           break;

2788         default:

2789           jj_la1[73] = jj_gen;

2790           break label_33;

2791         }

2792         switch (jj_nt.kind) {

2793         case LT:

2794           jj_consume_token(LT);

2795            jjtn000.setImage("<");

2796           break;

2797         case GT:

2798           jj_consume_token(GT);

2799             jjtn000.setImage(">");

2800           break;

2801         case LE:

2802           jj_consume_token(LE);

2803              jjtn000.setImage("<=");

2804           break;

2805         case GE:

2806           jj_consume_token(GE);

2807              jjtn000.setImage(">=");

2808           break;

2809         default:

2810           jj_la1[74] = jj_gen;

2811           jj_consume_token(-1);

2812           throw new ParseException();

2813         }

2814         ShiftExpression();

2815       }

2816     } catch (Throwable jjte000) {

2817     if (jjtc000) {

2818       jjtree.clearNodeScope(jjtn000);

2819       jjtc000 = false;

2820     } else {

2821       jjtree.popNode();

2822     }

2823     if (jjte000 instanceof RuntimeException) {

2824       {if (true) throw (RuntimeException)jjte000;}

2825     }

2826     if (jjte000 instanceof ParseException) {

2827       {if (true) throw (ParseException)jjte000;}

2828     }

2829     {if (true) throw (Error)jjte000;}

2830     } finally {

2831     if (jjtc000) {

2832       jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);

2833     }

2834     }

2835   }

2836 

2837   final public void ShiftExpression() throws ParseException {

2838  /*@bgen(jjtree) #ShiftExpression(> 1) */

2839   ASTShiftExpression jjtn000 = new ASTShiftExpression(this, JJTSHIFTEXPRESSION);

2840   boolean jjtc000 = true;

2841   jjtree.openNodeScope(jjtn000);

2842     try {

2843       AdditiveExpression();

2844       label_34:

2845       while (true) {

2846         if (jj_2_21(1)) {

2847           ;

2848         } else {

2849           break label_34;

2850         }

2851         switch (jj_nt.kind) {

2852         case LSHIFT:

2853           jj_consume_token(LSHIFT);

2854              jjtn000.setImage("<<");

2855           break;

2856         default:

2857           jj_la1[75] = jj_gen;

2858           if (jj_2_22(1)) {

2859             RSIGNEDSHIFT();

2860           } else if (jj_2_23(1)) {

2861             RUNSIGNEDSHIFT();

2862           } else {

2863             jj_consume_token(-1);

2864             throw new ParseException();

2865           }

2866         }

2867         AdditiveExpression();

2868       }

2869     } catch (Throwable jjte000) {

2870     if (jjtc000) {

2871       jjtree.clearNodeScope(jjtn000);

2872       jjtc000 = false;

2873     } else {

2874       jjtree.popNode();

2875     }

2876     if (jjte000 instanceof RuntimeException) {

2877       {if (true) throw (RuntimeException)jjte000;}

2878     }

2879     if (jjte000 instanceof ParseException) {

2880       {if (true) throw (ParseException)jjte000;}

2881     }

2882     {if (true) throw (Error)jjte000;}

2883     } finally {

2884     if (jjtc000) {

2885       jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);

2886     }

2887     }

2888   }

2889 

2890   final public void AdditiveExpression() throws ParseException {

2891  /*@bgen(jjtree) #AdditiveExpression(> 1) */

2892   ASTAdditiveExpression jjtn000 = new ASTAdditiveExpression(this, JJTADDITIVEEXPRESSION);

2893   boolean jjtc000 = true;

2894   jjtree.openNodeScope(jjtn000);

2895     try {

2896       MultiplicativeExpression();

2897       label_35:

2898       while (true) {

2899         switch (jj_nt.kind) {

2900         case PLUS:

2901         case MINUS:

2902           ;

2903           break;

2904         default:

2905           jj_la1[76] = jj_gen;

2906           break label_35;

2907         }

2908         switch (jj_nt.kind) {

2909         case PLUS:

2910           jj_consume_token(PLUS);

2911                                       jjtn000.setImage("+");

2912           break;

2913         case MINUS:

2914           jj_consume_token(MINUS);

2915                                                                      jjtn000.setImage("-");

2916           break;

2917         default:

2918           jj_la1[77] = jj_gen;

2919           jj_consume_token(-1);

2920           throw new ParseException();

2921         }

2922         MultiplicativeExpression();

2923       }

2924     } catch (Throwable jjte000) {

2925     if (jjtc000) {

2926       jjtree.clearNodeScope(jjtn000);

2927       jjtc000 = false;

2928     } else {

2929       jjtree.popNode();

2930     }

2931     if (jjte000 instanceof RuntimeException) {

2932       {if (true) throw (RuntimeException)jjte000;}

2933     }

2934     if (jjte000 instanceof ParseException) {

2935       {if (true) throw (ParseException)jjte000;}

2936     }

2937     {if (true) throw (Error)jjte000;}

2938     } finally {

2939     if (jjtc000) {

2940       jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);

2941     }

2942     }

2943   }

2944 

2945   final public void MultiplicativeExpression() throws ParseException {

2946  /*@bgen(jjtree) #MultiplicativeExpression(> 1) */

2947   ASTMultiplicativeExpression jjtn000 = new ASTMultiplicativeExpression(this, JJTMULTIPLICATIVEEXPRESSION);

2948   boolean jjtc000 = true;

2949   jjtree.openNodeScope(jjtn000);

2950     try {

2951       UnaryExpression();

2952       label_36:

2953       while (true) {

2954         switch (jj_nt.kind) {

2955         case STAR:

2956         case SLASH:

2957         case REM:

2958           ;

2959           break;

2960         default:

2961           jj_la1[78] = jj_gen;

2962           break label_36;

2963         }

2964         switch (jj_nt.kind) {

2965         case STAR:

2966           jj_consume_token(STAR);

2967                              jjtn000.setImage("*");

2968           break;

2969         case SLASH:

2970           jj_consume_token(SLASH);

2971                                                             jjtn000.setImage("/");

2972           break;

2973         case REM:

2974           jj_consume_token(REM);

2975                                                                                            jjtn000.setImage("%");

2976           break;

2977         default:

2978           jj_la1[79] = jj_gen;

2979           jj_consume_token(-1);

2980           throw new ParseException();

2981         }

2982         UnaryExpression();

2983       }

2984     } catch (Throwable jjte000) {

2985     if (jjtc000) {

2986       jjtree.clearNodeScope(jjtn000);

2987       jjtc000 = false;

2988     } else {

2989       jjtree.popNode();

2990     }

2991     if (jjte000 instanceof RuntimeException) {

2992       {if (true) throw (RuntimeException)jjte000;}

2993     }

2994     if (jjte000 instanceof ParseException) {

2995       {if (true) throw (ParseException)jjte000;}

2996     }

2997     {if (true) throw (Error)jjte000;}

2998     } finally {

2999     if (jjtc000) {

3000       jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);

3001     }

3002     }

3003   }

3004 

3005   final public void UnaryExpression() throws ParseException {

3006  /*@bgen(jjtree) #UnaryExpression( ( jjtn000 . getImage ( ) != null )) */

3007   ASTUnaryExpression jjtn000 = new ASTUnaryExpression(this, JJTUNARYEXPRESSION);

3008   boolean jjtc000 = true;

3009   jjtree.openNodeScope(jjtn000);

3010     try {

3011       switch (jj_nt.kind) {

3012       case PLUS:

3013       case MINUS:

3014         switch (jj_nt.kind) {

3015         case PLUS:

3016           jj_consume_token(PLUS);

3017         jjtn000.setImage("+");

3018           break;

3019         case MINUS:

3020           jj_consume_token(MINUS);

3021                                        jjtn000.setImage("-");

3022           break;

3023         default:

3024           jj_la1[80] = jj_gen;

3025           jj_consume_token(-1);

3026           throw new ParseException();

3027         }

3028         UnaryExpression();

3029         break;

3030       case INCR:

3031         PreIncrementExpression();

3032         break;

3033       case DECR:

3034         PreDecrementExpression();

3035         break;

3036       case BOOLEAN:

3037       case BYTE:

3038       case CHAR:

3039       case DOUBLE:

3040       case FALSE:

3041       case FLOAT:

3042       case INT:

3043       case LONG:

3044       case NEW:

3045       case NULL:

3046       case SHORT:

3047       case SUPER:

3048       case THIS:

3049       case TRUE:

3050       case VOID:

3051       case INTEGER_LITERAL:

3052       case FLOATING_POINT_LITERAL:

3053       case HEX_FLOATING_POINT_LITERAL:

3054       case CHARACTER_LITERAL:

3055       case STRING_LITERAL:

3056       case IDENTIFIER:

3057       case LPAREN:

3058       case BANG:

3059       case TILDE:

3060         UnaryExpressionNotPlusMinus();

3061         break;

3062       default:

3063         jj_la1[81] = jj_gen;

3064         jj_consume_token(-1);

3065         throw new ParseException();

3066       }

3067     } catch (Throwable jjte000) {

3068     if (jjtc000) {

3069       jjtree.clearNodeScope(jjtn000);

3070       jjtc000 = false;

3071     } else {

3072       jjtree.popNode();

3073     }

3074     if (jjte000 instanceof RuntimeException) {

3075       {if (true) throw (RuntimeException)jjte000;}

3076     }

3077     if (jjte000 instanceof ParseException) {

3078       {if (true) throw (ParseException)jjte000;}

3079     }

3080     {if (true) throw (Error)jjte000;}

3081     } finally {

3082     if (jjtc000) {

3083       jjtree.closeNodeScope(jjtn000,  ( jjtn000 . getImage ( ) != null ));

3084     }

3085     }

3086   }

3087 

3088   final public void PreIncrementExpression() throws ParseException {

3089  /*@bgen(jjtree) PreIncrementExpression */

3090   ASTPreIncrementExpression jjtn000 = new ASTPreIncrementExpression(this, JJTPREINCREMENTEXPRESSION);

3091   boolean jjtc000 = true;

3092   jjtree.openNodeScope(jjtn000);

3093     try {

3094       jj_consume_token(INCR);

3095       PrimaryExpression();

3096     } catch (Throwable jjte000) {

3097     if (jjtc000) {

3098       jjtree.clearNodeScope(jjtn000);

3099       jjtc000 = false;

3100     } else {

3101       jjtree.popNode();

3102     }

3103     if (jjte000 instanceof RuntimeException) {

3104       {if (true) throw (RuntimeException)jjte000;}

3105     }

3106     if (jjte000 instanceof ParseException) {

3107       {if (true) throw (ParseException)jjte000;}

3108     }

3109     {if (true) throw (Error)jjte000;}

3110     } finally {

3111     if (jjtc000) {

3112       jjtree.closeNodeScope(jjtn000, true);

3113     }

3114     }

3115   }

3116 

3117   final public void PreDecrementExpression() throws ParseException {

3118  /*@bgen(jjtree) PreDecrementExpression */

3119   ASTPreDecrementExpression jjtn000 = new ASTPreDecrementExpression(this, JJTPREDECREMENTEXPRESSION);

3120   boolean jjtc000 = true;

3121   jjtree.openNodeScope(jjtn000);

3122     try {

3123       jj_consume_token(DECR);

3124       PrimaryExpression();

3125     } catch (Throwable jjte000) {

3126     if (jjtc000) {

3127       jjtree.clearNodeScope(jjtn000);

3128       jjtc000 = false;

3129     } else {

3130       jjtree.popNode();

3131     }

3132     if (jjte000 instanceof RuntimeException) {

3133       {if (true) throw (RuntimeException)jjte000;}

3134     }

3135     if (jjte000 instanceof ParseException) {

3136       {if (true) throw (ParseException)jjte000;}

3137     }

3138     {if (true) throw (Error)jjte000;}

3139     } finally {

3140     if (jjtc000) {

3141       jjtree.closeNodeScope(jjtn000, true);

3142     }

3143     }

3144   }

3145 

3146   final public void UnaryExpressionNotPlusMinus() throws ParseException {

3147  /*@bgen(jjtree) #UnaryExpressionNotPlusMinus( ( jjtn000 . getImage ( ) != null )) */

3148   ASTUnaryExpressionNotPlusMinus jjtn000 = new ASTUnaryExpressionNotPlusMinus(this, JJTUNARYEXPRESSIONNOTPLUSMINUS);

3149   boolean jjtc000 = true;

3150   jjtree.openNodeScope(jjtn000);

3151     try {

3152       switch (jj_nt.kind) {

3153       case BANG:

3154       case TILDE:

3155         switch (jj_nt.kind) {

3156         case TILDE:

3157           jj_consume_token(TILDE);

3158         jjtn000.setImage("~");

3159           break;

3160         case BANG:

3161           jj_consume_token(BANG);

3162                                        jjtn000.setImage("!");

3163           break;

3164         default:

3165           jj_la1[82] = jj_gen;

3166           jj_consume_token(-1);

3167           throw new ParseException();

3168         }

3169         UnaryExpression();

3170         break;

3171       default:

3172         jj_la1[83] = jj_gen;

3173         if (jj_2_24(2147483647)) {

3174           CastExpression();

3175         } else {

3176           switch (jj_nt.kind) {

3177           case BOOLEAN:

3178           case BYTE:

3179           case CHAR:

3180           case DOUBLE:

3181           case FALSE:

3182           case FLOAT:

3183           case INT:

3184           case LONG:

3185           case NEW:

3186           case NULL:

3187           case SHORT:

3188           case SUPER:

3189           case THIS:

3190           case TRUE:

3191           case VOID:

3192           case INTEGER_LITERAL:

3193           case FLOATING_POINT_LITERAL:

3194           case HEX_FLOATING_POINT_LITERAL:

3195           case CHARACTER_LITERAL:

3196           case STRING_LITERAL:

3197           case IDENTIFIER:

3198           case LPAREN:

3199             PostfixExpression();

3200             break;

3201           default:

3202             jj_la1[84] = jj_gen;

3203             jj_consume_token(-1);

3204             throw new ParseException();

3205           }

3206         }

3207       }

3208     } catch (Throwable jjte000) {

3209    if (jjtc000) {

3210      jjtree.clearNodeScope(jjtn000);

3211      jjtc000 = false;

3212    } else {

3213      jjtree.popNode();

3214    }

3215    if (jjte000 instanceof RuntimeException) {

3216      {if (true) throw (RuntimeException)jjte000;}

3217    }

3218    if (jjte000 instanceof ParseException) {

3219      {if (true) throw (ParseException)jjte000;}

3220    }

3221    {if (true) throw (Error)jjte000;}

3222     } finally {

3223    if (jjtc000) {

3224      jjtree.closeNodeScope(jjtn000,  ( jjtn000 . getImage ( ) != null ));

3225    }

3226     }

3227   }

3228 

3229 // This production is to determine lookahead only.  The LOOKAHEAD specifications

3230 // below are not used, but they are there just to indicate that we know about

3231 // this.

3232   final public void CastLookahead() throws ParseException {

3233     if (jj_2_25(2)) {

3234       jj_consume_token(LPAREN);

3235       PrimitiveType();

3236     } else if (jj_2_26(2147483647)) {

3237       jj_consume_token(LPAREN);

3238       Type();

3239       jj_consume_token(LBRACKET);

3240       jj_consume_token(RBRACKET);

3241     } else {

3242       switch (jj_nt.kind) {

3243       case LPAREN:

3244         jj_consume_token(LPAREN);

3245         Type();

3246         jj_consume_token(RPAREN);

3247         switch (jj_nt.kind) {

3248         case TILDE:

3249           jj_consume_token(TILDE);

3250           break;

3251         case BANG:

3252           jj_consume_token(BANG);

3253           break;

3254         case LPAREN:

3255           jj_consume_token(LPAREN);

3256           break;

3257         case IDENTIFIER:

3258           jj_consume_token(IDENTIFIER);

3259           break;

3260         case THIS:

3261           jj_consume_token(THIS);

3262           break;

3263         case SUPER:

3264           jj_consume_token(SUPER);

3265           break;

3266         case NEW:

3267           jj_consume_token(NEW);

3268           break;

3269         case FALSE:

3270         case NULL:

3271         case TRUE:

3272         case INTEGER_LITERAL:

3273         case FLOATING_POINT_LITERAL:

3274         case HEX_FLOATING_POINT_LITERAL:

3275         case CHARACTER_LITERAL:

3276         case STRING_LITERAL:

3277           Literal();

3278           break;

3279         default:

3280           jj_la1[85] = jj_gen;

3281           jj_consume_token(-1);

3282           throw new ParseException();

3283         }

3284         break;

3285       default:

3286         jj_la1[86] = jj_gen;

3287         jj_consume_token(-1);

3288         throw new ParseException();

3289       }

3290     }

3291   }

3292 

3293   final public void PostfixExpression() throws ParseException {

3294  /*@bgen(jjtree) #PostfixExpression( ( jjtn000 . getImage ( ) != null )) */

3295   ASTPostfixExpression jjtn000 = new ASTPostfixExpression(this, JJTPOSTFIXEXPRESSION);

3296   boolean jjtc000 = true;

3297   jjtree.openNodeScope(jjtn000);

3298     try {

3299       PrimaryExpression();

3300       switch (jj_nt.kind) {

3301       case INCR:

3302       case DECR:

3303         switch (jj_nt.kind) {

3304         case INCR:

3305           jj_consume_token(INCR);

3306                               jjtn000.setImage("++");

3307           break;

3308         case DECR:

3309           jj_consume_token(DECR);

3310                                                                jjtn000.setImage("--");

3311           break;

3312         default:

3313           jj_la1[87] = jj_gen;

3314           jj_consume_token(-1);

3315           throw new ParseException();

3316         }

3317         break;

3318       default:

3319         jj_la1[88] = jj_gen;

3320         ;

3321       }

3322     } catch (Throwable jjte000) {

3323     if (jjtc000) {

3324       jjtree.clearNodeScope(jjtn000);

3325       jjtc000 = false;

3326     } else {

3327       jjtree.popNode();

3328     }

3329     if (jjte000 instanceof RuntimeException) {

3330       {if (true) throw (RuntimeException)jjte000;}

3331     }

3332     if (jjte000 instanceof ParseException) {

3333       {if (true) throw (ParseException)jjte000;}

3334     }

3335     {if (true) throw (Error)jjte000;}

3336     } finally {

3337     if (jjtc000) {

3338       jjtree.closeNodeScope(jjtn000,  ( jjtn000 . getImage ( ) != null ));

3339     }

3340     }

3341   }

3342 

3343   final public void CastExpression() throws ParseException {

3344  /*@bgen(jjtree) #CastExpression(> 1) */

3345   ASTCastExpression jjtn000 = new ASTCastExpression(this, JJTCASTEXPRESSION);

3346   boolean jjtc000 = true;

3347   jjtree.openNodeScope(jjtn000);

3348     try {

3349       if (jj_2_27(2147483647)) {

3350         jj_consume_token(LPAREN);

3351         Type();

3352         jj_consume_token(RPAREN);

3353         UnaryExpression();

3354       } else {

3355         switch (jj_nt.kind) {

3356         case LPAREN:

3357           jj_consume_token(LPAREN);

3358           Type();

3359           jj_consume_token(RPAREN);

3360           UnaryExpressionNotPlusMinus();

3361           break;

3362         default:

3363           jj_la1[89] = jj_gen;

3364           jj_consume_token(-1);

3365           throw new ParseException();

3366         }

3367       }

3368     } catch (Throwable jjte000) {

3369     if (jjtc000) {

3370       jjtree.clearNodeScope(jjtn000);

3371       jjtc000 = false;

3372     } else {

3373       jjtree.popNode();

3374     }

3375     if (jjte000 instanceof RuntimeException) {

3376       {if (true) throw (RuntimeException)jjte000;}

3377     }

3378     if (jjte000 instanceof ParseException) {

3379       {if (true) throw (ParseException)jjte000;}

3380     }

3381     {if (true) throw (Error)jjte000;}

3382     } finally {

3383     if (jjtc000) {

3384       jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);

3385     }

3386     }

3387   }

3388 

3389   final public void PrimaryExpression() throws ParseException {

3390  /*@bgen(jjtree) PrimaryExpression */

3391   ASTPrimaryExpression jjtn000 = new ASTPrimaryExpression(this, JJTPRIMARYEXPRESSION);

3392   boolean jjtc000 = true;

3393   jjtree.openNodeScope(jjtn000);

3394     try {

3395       PrimaryPrefix();

3396       label_37:

3397       while (true) {

3398         if (jj_2_28(2)) {

3399           ;

3400         } else {

3401           break label_37;

3402         }

3403         PrimarySuffix();

3404       }

3405     } catch (Throwable jjte000) {

3406     if (jjtc000) {

3407       jjtree.clearNodeScope(jjtn000);

3408       jjtc000 = false;

3409     } else {

3410       jjtree.popNode();

3411     }

3412     if (jjte000 instanceof RuntimeException) {

3413       {if (true) throw (RuntimeException)jjte000;}

3414     }

3415     if (jjte000 instanceof ParseException) {

3416       {if (true) throw (ParseException)jjte000;}

3417     }

3418     {if (true) throw (Error)jjte000;}

3419     } finally {

3420     if (jjtc000) {

3421       jjtree.closeNodeScope(jjtn000, true);

3422     }

3423     }

3424   }

3425 

3426   final public void MemberSelector() throws ParseException {

3427  /*@bgen(jjtree) MemberSelector */

3428 ASTMemberSelector jjtn000 = new ASTMemberSelector(this, JJTMEMBERSELECTOR);

3429 boolean jjtc000 = true;

3430 jjtree.openNodeScope(jjtn000);Token t;

3431     try {

3432       jj_consume_token(DOT);

3433       TypeArguments();

3434       t = jj_consume_token(IDENTIFIER);

3435                                        jjtree.closeNodeScope(jjtn000, true);

3436                                        jjtc000 = false;

3437                                       jjtn000.setImage(t.image);

3438     } catch (Throwable jjte000) {

3439     if (jjtc000) {

3440       jjtree.clearNodeScope(jjtn000);

3441       jjtc000 = false;

3442     } else {

3443       jjtree.popNode();

3444     }

3445     if (jjte000 instanceof RuntimeException) {

3446       {if (true) throw (RuntimeException)jjte000;}

3447     }

3448     if (jjte000 instanceof ParseException) {

3449       {if (true) throw (ParseException)jjte000;}

3450     }

3451     {if (true) throw (Error)jjte000;}

3452     } finally {

3453     if (jjtc000) {

3454       jjtree.closeNodeScope(jjtn000, true);

3455     }

3456     }

3457   }

3458 

3459   final public void PrimaryPrefix() throws ParseException {

3460  /*@bgen(jjtree) PrimaryPrefix */

3461  ASTPrimaryPrefix jjtn000 = new ASTPrimaryPrefix(this, JJTPRIMARYPREFIX);

3462  boolean jjtc000 = true;

3463  jjtree.openNodeScope(jjtn000);Token t;

3464     try {

3465       switch (jj_nt.kind) {

3466       case FALSE:

3467       case NULL:

3468       case TRUE:

3469       case INTEGER_LITERAL:

3470       case FLOATING_POINT_LITERAL:

3471       case HEX_FLOATING_POINT_LITERAL:

3472       case CHARACTER_LITERAL:

3473       case STRING_LITERAL:

3474         Literal();

3475         break;

3476       case THIS:

3477         jj_consume_token(THIS);

3478            jjtree.closeNodeScope(jjtn000, true);

3479            jjtc000 = false;

3480           jjtn000.setUsesThisModifier();

3481         break;

3482       case SUPER:

3483         jj_consume_token(SUPER);

3484            jjtn000.setUsesSuperModifier();

3485         jj_consume_token(DOT);

3486         t = jj_consume_token(IDENTIFIER);

3487                                                                  jjtree.closeNodeScope(jjtn000, true);

3488                                                                  jjtc000 = false;

3489                                                                 jjtn000.setImage(t.image);

3490         break;

3491       case LPAREN:

3492         jj_consume_token(LPAREN);

3493         Expression();

3494         jj_consume_token(RPAREN);

3495         break;

3496       case NEW:

3497         AllocationExpression();

3498         break;

3499       default:

3500         jj_la1[90] = jj_gen;

3501         if (jj_2_29(2147483647)) {

3502           ResultType();

3503           jj_consume_token(DOT);

3504           jj_consume_token(CLASS);

3505         } else {

3506           switch (jj_nt.kind) {

3507           case IDENTIFIER:

3508             Name();

3509             break;

3510           default:

3511             jj_la1[91] = jj_gen;

3512             jj_consume_token(-1);

3513             throw new ParseException();

3514           }

3515         }

3516       }

3517     } catch (Throwable jjte000) {

3518     if (jjtc000) {

3519       jjtree.clearNodeScope(jjtn000);

3520       jjtc000 = false;

3521     } else {

3522       jjtree.popNode();

3523     }

3524     if (jjte000 instanceof RuntimeException) {

3525       {if (true) throw (RuntimeException)jjte000;}

3526     }

3527     if (jjte000 instanceof ParseException) {

3528       {if (true) throw (ParseException)jjte000;}

3529     }

3530     {if (true) throw (Error)jjte000;}

3531     } finally {

3532     if (jjtc000) {

3533       jjtree.closeNodeScope(jjtn000, true);

3534     }

3535     }

3536   }

3537 

3538   final public void PrimarySuffix() throws ParseException {

3539  /*@bgen(jjtree) PrimarySuffix */

3540  ASTPrimarySuffix jjtn000 = new ASTPrimarySuffix(this, JJTPRIMARYSUFFIX);

3541  boolean jjtc000 = true;

3542  jjtree.openNodeScope(jjtn000);Token t;

3543     try {

3544       if (jj_2_30(2)) {

3545         jj_consume_token(DOT);

3546         jj_consume_token(THIS);

3547       } else if (jj_2_31(2)) {

3548         jj_consume_token(DOT);

3549         jj_consume_token(SUPER);

3550       } else if (jj_2_32(2)) {

3551         jj_consume_token(DOT);

3552         AllocationExpression();

3553       } else if (jj_2_33(3)) {

3554         MemberSelector();

3555       } else {

3556         switch (jj_nt.kind) {

3557         case LBRACKET:

3558           jj_consume_token(LBRACKET);

3559           Expression();

3560           jj_consume_token(RBRACKET);

3561                          jjtree.closeNodeScope(jjtn000, true);

3562                          jjtc000 = false;

3563                         jjtn000.setIsArrayDereference();

3564           break;

3565         case DOT:

3566           jj_consume_token(DOT);

3567           t = jj_consume_token(IDENTIFIER);

3568                        jjtree.closeNodeScope(jjtn000, true);

3569                        jjtc000 = false;

3570                       jjtn000.setImage(t.image);

3571           break;

3572         case LPAREN:

3573           Arguments();

3574                 jjtree.closeNodeScope(jjtn000, true);

3575                 jjtc000 = false;

3576                jjtn000.setIsArguments();

3577           break;

3578         default:

3579           jj_la1[92] = jj_gen;

3580           jj_consume_token(-1);

3581           throw new ParseException();

3582         }

3583       }

3584     } catch (Throwable jjte000) {

3585     if (jjtc000) {

3586       jjtree.clearNodeScope(jjtn000);

3587       jjtc000 = false;

3588     } else {

3589       jjtree.popNode();

3590     }

3591     if (jjte000 instanceof RuntimeException) {

3592       {if (true) throw (RuntimeException)jjte000;}

3593     }

3594     if (jjte000 instanceof ParseException) {

3595       {if (true) throw (ParseException)jjte000;}

3596     }

3597     {if (true) throw (Error)jjte000;}

3598     } finally {

3599     if (jjtc000) {

3600       jjtree.closeNodeScope(jjtn000, true);

3601     }

3602     }

3603   }

3604 

3605   final public void Literal() throws ParseException {

3606  /*@bgen(jjtree) Literal */

3607   ASTLiteral jjtn000 = new ASTLiteral(this, JJTLITERAL);

3608   boolean jjtc000 = true;

3609   jjtree.openNodeScope(jjtn000);

3610     try {

3611       switch (jj_nt.kind) {

3612       case INTEGER_LITERAL:

3613   Token t;

3614         t = jj_consume_token(INTEGER_LITERAL);

3615                         jjtree.closeNodeScope(jjtn000, true);

3616                         jjtc000 = false;

3617                        jjtn000.setImage(t.image); jjtn000.setIntLiteral();

3618         break;

3619       case FLOATING_POINT_LITERAL:

3620         t = jj_consume_token(FLOATING_POINT_LITERAL);

3621                                jjtree.closeNodeScope(jjtn000, true);

3622                                jjtc000 = false;

3623                               jjtn000.setImage(t.image); jjtn000.setFloatLiteral();

3624         break;

3625       case HEX_FLOATING_POINT_LITERAL:

3626         t = jj_consume_token(HEX_FLOATING_POINT_LITERAL);

3627                                    jjtree.closeNodeScope(jjtn000, true);

3628                                    jjtc000 = false;

3629                                    checkForBadHexFloatingPointLiteral(); jjtn000.setImage(t.image); jjtn000.setFloatLiteral();

3630         break;

3631       case CHARACTER_LITERAL:

3632         t = jj_consume_token(CHARACTER_LITERAL);

3633                           jjtree.closeNodeScope(jjtn000, true);

3634                           jjtc000 = false;

3635                          jjtn000.setImage(t.image); jjtn000.setCharLiteral();

3636         break;

3637       case STRING_LITERAL:

3638         t = jj_consume_token(STRING_LITERAL);

3639                        jjtree.closeNodeScope(jjtn000, true);

3640                        jjtc000 = false;

3641                       jjtn000.setImage(t.image); jjtn000.setStringLiteral();

3642         break;

3643       case FALSE:

3644       case TRUE:

3645         BooleanLiteral();

3646         break;

3647       case NULL:

3648         NullLiteral();

3649         break;

3650       default:

3651         jj_la1[93] = jj_gen;

3652         jj_consume_token(-1);

3653         throw new ParseException();

3654       }

3655     } catch (Throwable jjte000) {

3656   if (jjtc000) {

3657     jjtree.clearNodeScope(jjtn000);

3658     jjtc000 = false;

3659   } else {

3660     jjtree.popNode();

3661   }

3662   if (jjte000 instanceof RuntimeException) {

3663     {if (true) throw (RuntimeException)jjte000;}

3664   }

3665   if (jjte000 instanceof ParseException) {

3666     {if (true) throw (ParseException)jjte000;}

3667   }

3668   {if (true) throw (Error)jjte000;}

3669     } finally {

3670   if (jjtc000) {

3671     jjtree.closeNodeScope(jjtn000, true);

3672   }

3673     }

3674   }

3675 

3676   final public void BooleanLiteral() throws ParseException {

3677  /*@bgen(jjtree) BooleanLiteral */

3678   ASTBooleanLiteral jjtn000 = new ASTBooleanLiteral(this, JJTBOOLEANLITERAL);

3679   boolean jjtc000 = true;

3680   jjtree.openNodeScope(jjtn000);

3681     try {

3682       switch (jj_nt.kind) {

3683       case TRUE:

3684         jj_consume_token(TRUE);

3685            jjtree.closeNodeScope(jjtn000, true);

3686            jjtc000 = false;

3687            jjtn000.setTrue();

3688         break;

3689       case FALSE:

3690         jj_consume_token(FALSE);

3691         break;

3692       default:

3693         jj_la1[94] = jj_gen;

3694         jj_consume_token(-1);

3695         throw new ParseException();

3696       }

3697     } finally {

3698     if (jjtc000) {

3699       jjtree.closeNodeScope(jjtn000, true);

3700     }

3701     }

3702   }

3703 

3704   final public void NullLiteral() throws ParseException {

3705  /*@bgen(jjtree) NullLiteral */

3706   ASTNullLiteral jjtn000 = new ASTNullLiteral(this, JJTNULLLITERAL);

3707   boolean jjtc000 = true;

3708   jjtree.openNodeScope(jjtn000);

3709     try {

3710       jj_consume_token(NULL);

3711     } finally {

3712     if (jjtc000) {

3713       jjtree.closeNodeScope(jjtn000, true);

3714     }

3715     }

3716   }

3717 

3718   final public void Arguments() throws ParseException {

3719  /*@bgen(jjtree) Arguments */

3720   ASTArguments jjtn000 = new ASTArguments(this, JJTARGUMENTS);

3721   boolean jjtc000 = true;

3722   jjtree.openNodeScope(jjtn000);

3723     try {

3724       jj_consume_token(LPAREN);

3725       switch (jj_nt.kind) {

3726       case BOOLEAN:

3727       case BYTE:

3728       case CHAR:

3729       case DOUBLE:

3730       case FALSE:

3731       case FLOAT:

3732       case INT:

3733       case LONG:

3734       case NEW:

3735       case NULL:

3736       case SHORT:

3737       case SUPER:

3738       case THIS:

3739       case TRUE:

3740       case VOID:

3741       case INTEGER_LITERAL:

3742       case FLOATING_POINT_LITERAL:

3743       case HEX_FLOATING_POINT_LITERAL:

3744       case CHARACTER_LITERAL:

3745       case STRING_LITERAL:

3746       case IDENTIFIER:

3747       case LPAREN:

3748       case BANG:

3749       case TILDE:

3750       case INCR:

3751       case DECR:

3752       case PLUS:

3753       case MINUS:

3754         ArgumentList();

3755         break;

3756       default:

3757         jj_la1[95] = jj_gen;

3758         ;

3759       }

3760       jj_consume_token(RPAREN);

3761     } catch (Throwable jjte000) {

3762     if (jjtc000) {

3763       jjtree.clearNodeScope(jjtn000);

3764       jjtc000 = false;

3765     } else {

3766       jjtree.popNode();

3767     }

3768     if (jjte000 instanceof RuntimeException) {

3769       {if (true) throw (RuntimeException)jjte000;}

3770     }

3771     if (jjte000 instanceof ParseException) {

3772       {if (true) throw (ParseException)jjte000;}

3773     }

3774     {if (true) throw (Error)jjte000;}

3775     } finally {

3776     if (jjtc000) {

3777       jjtree.closeNodeScope(jjtn000, true);

3778     }

3779     }

3780   }

3781 

3782   final public void ArgumentList() throws ParseException {

3783  /*@bgen(jjtree) ArgumentList */

3784   ASTArgumentList jjtn000 = new ASTArgumentList(this, JJTARGUMENTLIST);

3785   boolean jjtc000 = true;

3786   jjtree.openNodeScope(jjtn000);

3787     try {

3788       Expression();

3789       label_38:

3790       while (true) {

3791         switch (jj_nt.kind) {

3792         case COMMA:

3793           ;

3794           break;

3795         default:

3796           jj_la1[96] = jj_gen;

3797           break label_38;

3798         }

3799         jj_consume_token(COMMA);

3800         Expression();

3801       }

3802     } catch (Throwable jjte000) {

3803     if (jjtc000) {

3804       jjtree.clearNodeScope(jjtn000);

3805       jjtc000 = false;

3806     } else {

3807       jjtree.popNode();

3808     }

3809     if (jjte000 instanceof RuntimeException) {

3810       {if (true) throw (RuntimeException)jjte000;}

3811     }

3812     if (jjte000 instanceof ParseException) {

3813       {if (true) throw (ParseException)jjte000;}

3814     }

3815     {if (true) throw (Error)jjte000;}

3816     } finally {

3817     if (jjtc000) {

3818       jjtree.closeNodeScope(jjtn000, true);

3819     }

3820     }

3821   }

3822 

3823   final public void AllocationExpression() throws ParseException {

3824  /*@bgen(jjtree) AllocationExpression */

3825   ASTAllocationExpression jjtn000 = new ASTAllocationExpression(this, JJTALLOCATIONEXPRESSION);

3826   boolean jjtc000 = true;

3827   jjtree.openNodeScope(jjtn000);

3828     try {

3829       if (jj_2_34(2)) {

3830         jj_consume_token(NEW);

3831         PrimitiveType();

3832         ArrayDimsAndInits();

3833       } else {

3834         switch (jj_nt.kind) {

3835         case NEW:

3836           jj_consume_token(NEW);

3837           ClassOrInterfaceType();

3838           switch (jj_nt.kind) {

3839           case LT:

3840             TypeArguments();

3841             break;

3842           default:

3843             jj_la1[97] = jj_gen;

3844             ;

3845           }

3846           switch (jj_nt.kind) {

3847           case LBRACKET:

3848             ArrayDimsAndInits();

3849             break;

3850           case LPAREN:

3851             Arguments();

3852             switch (jj_nt.kind) {

3853             case LBRACE:

3854               ClassOrInterfaceBody();

3855               break;

3856             default:

3857               jj_la1[98] = jj_gen;

3858               ;

3859             }

3860             break;

3861           default:

3862             jj_la1[99] = jj_gen;

3863             jj_consume_token(-1);

3864             throw new ParseException();

3865           }

3866           break;

3867         default:

3868           jj_la1[100] = jj_gen;

3869           jj_consume_token(-1);

3870           throw new ParseException();

3871         }

3872       }

3873     } catch (Throwable jjte000) {

3874     if (jjtc000) {

3875       jjtree.clearNodeScope(jjtn000);

3876       jjtc000 = false;

3877     } else {

3878       jjtree.popNode();

3879     }

3880     if (jjte000 instanceof RuntimeException) {

3881       {if (true) throw (RuntimeException)jjte000;}

3882     }

3883     if (jjte000 instanceof ParseException) {

3884       {if (true) throw (ParseException)jjte000;}

3885     }

3886     {if (true) throw (Error)jjte000;}

3887     } finally {

3888     if (jjtc000) {

3889       jjtree.closeNodeScope(jjtn000, true);

3890     }

3891     }

3892   }

3893 

3894 /*

3895  * The second LOOKAHEAD specification below is to parse to PrimarySuffix

3896  * if there is an expression between the "[...]".

3897  */

3898   final public void ArrayDimsAndInits() throws ParseException {

3899  /*@bgen(jjtree) ArrayDimsAndInits */

3900   ASTArrayDimsAndInits jjtn000 = new ASTArrayDimsAndInits(this, JJTARRAYDIMSANDINITS);

3901   boolean jjtc000 = true;

3902   jjtree.openNodeScope(jjtn000);

3903     try {

3904       if (jj_2_37(2)) {

3905         label_39:

3906         while (true) {

3907           jj_consume_token(LBRACKET);

3908           Expression();

3909           jj_consume_token(RBRACKET);

3910           if (jj_2_35(2)) {

3911             ;

3912           } else {

3913             break label_39;

3914           }

3915         }

3916         label_40:

3917         while (true) {

3918           if (jj_2_36(2)) {

3919             ;

3920           } else {

3921             break label_40;

3922           }

3923           jj_consume_token(LBRACKET);

3924           jj_consume_token(RBRACKET);

3925         }

3926       } else {

3927         switch (jj_nt.kind) {

3928         case LBRACKET:

3929           label_41:

3930           while (true) {

3931             jj_consume_token(LBRACKET);

3932             jj_consume_token(RBRACKET);

3933             switch (jj_nt.kind) {

3934             case LBRACKET:

3935               ;

3936               break;

3937             default:

3938               jj_la1[101] = jj_gen;

3939               break label_41;

3940             }

3941           }

3942           ArrayInitializer();

3943           break;

3944         default:

3945           jj_la1[102] = jj_gen;

3946           jj_consume_token(-1);

3947           throw new ParseException();

3948         }

3949       }

3950     } catch (Throwable jjte000) {

3951     if (jjtc000) {

3952       jjtree.clearNodeScope(jjtn000);

3953       jjtc000 = false;

3954     } else {

3955       jjtree.popNode();

3956     }

3957     if (jjte000 instanceof RuntimeException) {

3958       {if (true) throw (RuntimeException)jjte000;}

3959     }

3960     if (jjte000 instanceof ParseException) {

3961       {if (true) throw (ParseException)jjte000;}

3962     }

3963     {if (true) throw (Error)jjte000;}

3964     } finally {

3965     if (jjtc000) {

3966       jjtree.closeNodeScope(jjtn000, true);

3967     }

3968     }

3969   }

3970 

3971 /*

3972  * Statement syntax follows.

3973  */

3974   final public void Statement() throws ParseException {

3975  /*@bgen(jjtree) Statement */

3976   ASTStatement jjtn000 = new ASTStatement(this, JJTSTATEMENT);

3977   boolean jjtc000 = true;

3978   jjtree.openNodeScope(jjtn000);

3979     try {

3980       if (isNextTokenAnAssert()) {

3981         AssertStatement();

3982       } else if (jj_2_38(2)) {

3983         LabeledStatement();

3984       } else {

3985         switch (jj_nt.kind) {

3986         case LBRACE:

3987           Block();

3988           break;

3989         case SEMICOLON:

3990           EmptyStatement();

3991           break;

3992         case BOOLEAN:

3993         case BYTE:

3994         case CHAR:

3995         case DOUBLE:

3996         case FALSE:

3997         case FLOAT:

3998         case INT:

3999         case LONG:

4000         case NEW:

4001         case NULL:

4002         case SHORT:

4003         case SUPER:

4004         case THIS:

4005         case TRUE:

4006         case VOID:

4007         case INTEGER_LITERAL:

4008         case FLOATING_POINT_LITERAL:

4009         case HEX_FLOATING_POINT_LITERAL:

4010         case CHARACTER_LITERAL:

4011         case STRING_LITERAL:

4012         case IDENTIFIER:

4013         case LPAREN:

4014         case INCR:

4015         case DECR:

4016           StatementExpression();

4017           jj_consume_token(SEMICOLON);

4018           break;

4019         case SWITCH:

4020           SwitchStatement();

4021           break;

4022         case IF:

4023           IfStatement();

4024           break;

4025         case WHILE:

4026           WhileStatement();

4027           break;

4028         case DO:

4029           DoStatement();

4030           break;

4031         case FOR:

4032           ForStatement();

4033           break;

4034         case BREAK:

4035           BreakStatement();

4036           break;

4037         case CONTINUE:

4038           ContinueStatement();

4039           break;

4040         case RETURN:

4041           ReturnStatement();

4042           break;

4043         case THROW:

4044           ThrowStatement();

4045           break;

4046         case SYNCHRONIZED:

4047           SynchronizedStatement();

4048           break;

4049         case TRY:

4050           TryStatement();

4051           break;

4052         default:

4053           jj_la1[103] = jj_gen;

4054           jj_consume_token(-1);

4055           throw new ParseException();

4056         }

4057       }

4058     } catch (Throwable jjte000) {

4059     if (jjtc000) {

4060       jjtree.clearNodeScope(jjtn000);

4061       jjtc000 = false;

4062     } else {

4063       jjtree.popNode();

4064     }

4065     if (jjte000 instanceof RuntimeException) {

4066       {if (true) throw (RuntimeException)jjte000;}

4067     }

4068     if (jjte000 instanceof ParseException) {

4069       {if (true) throw (ParseException)jjte000;}

4070     }

4071     {if (true) throw (Error)jjte000;}

4072     } finally {

4073     if (jjtc000) {

4074       jjtree.closeNodeScope(jjtn000, true);

4075     }

4076     }

4077   }

4078 

4079   final public void LabeledStatement() throws ParseException {

4080  /*@bgen(jjtree) LabeledStatement */

4081  ASTLabeledStatement jjtn000 = new ASTLabeledStatement(this, JJTLABELEDSTATEMENT);

4082  boolean jjtc000 = true;

4083  jjtree.openNodeScope(jjtn000);Token t;

4084     try {

4085       t = jj_consume_token(IDENTIFIER);

4086                   jjtn000.setImage(t.image);

4087       jj_consume_token(COLON);

4088       Statement();

4089     } catch (Throwable jjte000) {

4090     if (jjtc000) {

4091       jjtree.clearNodeScope(jjtn000);

4092       jjtc000 = false;

4093     } else {

4094       jjtree.popNode();

4095     }

4096     if (jjte000 instanceof RuntimeException) {

4097       {if (true) throw (RuntimeException)jjte000;}

4098     }

4099     if (jjte000 instanceof ParseException) {

4100       {if (true) throw (ParseException)jjte000;}

4101     }

4102     {if (true) throw (Error)jjte000;}

4103     } finally {

4104     if (jjtc000) {

4105       jjtree.closeNodeScope(jjtn000, true);

4106     }

4107     }

4108   }

4109 

4110   final public void Block() throws ParseException {

4111  /*@bgen(jjtree) Block */

4112  ASTBlock jjtn000 = new ASTBlock(this, JJTBLOCK);

4113  boolean jjtc000 = true;

4114  jjtree.openNodeScope(jjtn000);Token t;

4115     try {

4116       jj_consume_token(LBRACE);

4117       label_42:

4118       while (true) {

4119         if (jj_2_39(1)) {

4120           ;

4121         } else {

4122           break label_42;

4123         }

4124         BlockStatement();

4125       }

4126       t = jj_consume_token(RBRACE);

4127                                       jjtree.closeNodeScope(jjtn000, true);

4128                                       jjtc000 = false;

4129                                       if (isPrecededByComment(t)) { jjtn000.setContainsComment(); }

4130     } catch (Throwable jjte000) {

4131         if (jjtc000) {

4132           jjtree.clearNodeScope(jjtn000);

4133           jjtc000 = false;

4134         } else {

4135           jjtree.popNode();

4136         }

4137         if (jjte000 instanceof RuntimeException) {

4138           {if (true) throw (RuntimeException)jjte000;}

4139         }

4140         if (jjte000 instanceof ParseException) {

4141           {if (true) throw (ParseException)jjte000;}

4142         }

4143         {if (true) throw (Error)jjte000;}

4144     } finally {

4145         if (jjtc000) {

4146           jjtree.closeNodeScope(jjtn000, true);

4147         }

4148     }

4149   }

4150 

4151   final public void BlockStatement() throws ParseException {

4152  /*@bgen(jjtree) BlockStatement */

4153   ASTBlockStatement jjtn000 = new ASTBlockStatement(this, JJTBLOCKSTATEMENT);

4154   boolean jjtc000 = true;

4155   jjtree.openNodeScope(jjtn000);

4156     try {

4157       if (isNextTokenAnAssert()) {

4158         AssertStatement();

4159       } else if (jj_2_40(2147483647)) {

4160         LocalVariableDeclaration();

4161         jj_consume_token(SEMICOLON);

4162       } else if (jj_2_41(1)) {

4163         Statement();

4164       } else if (jj_2_42(2147483647)) {

4165         switch (jj_nt.kind) {

4166         case AT:

4167           Annotation();

4168           break;

4169         default:

4170           jj_la1[104] = jj_gen;

4171           ;

4172         }

4173         ClassOrInterfaceDeclaration(0);

4174       } else {

4175         jj_consume_token(-1);

4176         throw new ParseException();

4177       }

4178     } catch (Throwable jjte000) {

4179     if (jjtc000) {

4180       jjtree.clearNodeScope(jjtn000);

4181       jjtc000 = false;

4182     } else {

4183       jjtree.popNode();

4184     }

4185     if (jjte000 instanceof RuntimeException) {

4186       {if (true) throw (RuntimeException)jjte000;}

4187     }

4188     if (jjte000 instanceof ParseException) {

4189       {if (true) throw (ParseException)jjte000;}

4190     }

4191     {if (true) throw (Error)jjte000;}

4192     } finally {

4193     if (jjtc000) {

4194       jjtree.closeNodeScope(jjtn000, true);

4195     }

4196     }

4197   }

4198 

4199   final public void LocalVariableDeclaration() throws ParseException {

4200  /*@bgen(jjtree) LocalVariableDeclaration */

4201   ASTLocalVariableDeclaration jjtn000 = new ASTLocalVariableDeclaration(this, JJTLOCALVARIABLEDECLARATION);

4202   boolean jjtc000 = true;

4203   jjtree.openNodeScope(jjtn000);

4204     try {

4205       label_43:

4206       while (true) {

4207         switch (jj_nt.kind) {

4208         case FINAL:

4209         case AT:

4210           ;

4211           break;

4212         default:

4213           jj_la1[105] = jj_gen;

4214           break label_43;

4215         }

4216         switch (jj_nt.kind) {

4217         case FINAL:

4218           jj_consume_token(FINAL);

4219              jjtn000.setFinal(true);

4220           break;

4221         case AT:

4222           Annotation();

4223           break;

4224         default:

4225           jj_la1[106] = jj_gen;

4226           jj_consume_token(-1);

4227           throw new ParseException();

4228         }

4229       }

4230       Type();

4231       VariableDeclarator();

4232       label_44:

4233       while (true) {

4234         switch (jj_nt.kind) {

4235         case COMMA:

4236           ;

4237           break;

4238         default:

4239           jj_la1[107] = jj_gen;

4240           break label_44;

4241         }

4242         jj_consume_token(COMMA);

4243         VariableDeclarator();

4244       }

4245     } catch (Throwable jjte000) {

4246     if (jjtc000) {

4247       jjtree.clearNodeScope(jjtn000);

4248       jjtc000 = false;

4249     } else {

4250       jjtree.popNode();

4251     }

4252     if (jjte000 instanceof RuntimeException) {

4253       {if (true) throw (RuntimeException)jjte000;}

4254     }

4255     if (jjte000 instanceof ParseException) {

4256       {if (true) throw (ParseException)jjte000;}

4257     }

4258     {if (true) throw (Error)jjte000;}

4259     } finally {

4260     if (jjtc000) {

4261       jjtree.closeNodeScope(jjtn000, true);

4262     }

4263     }

4264   }

4265 

4266   final public void EmptyStatement() throws ParseException {

4267  /*@bgen(jjtree) EmptyStatement */

4268   ASTEmptyStatement jjtn000 = new ASTEmptyStatement(this, JJTEMPTYSTATEMENT);

4269   boolean jjtc000 = true;

4270   jjtree.openNodeScope(jjtn000);

4271     try {

4272       jj_consume_token(SEMICOLON);

4273     } finally {

4274     if (jjtc000) {

4275       jjtree.closeNodeScope(jjtn000, true);

4276     }

4277     }

4278   }

4279 

4280   final public void StatementExpression() throws ParseException {

4281  /*@bgen(jjtree) StatementExpression */

4282   ASTStatementExpression jjtn000 = new ASTStatementExpression(this, JJTSTATEMENTEXPRESSION);

4283   boolean jjtc000 = true;

4284   jjtree.openNodeScope(jjtn000);

4285     try {

4286       switch (jj_nt.kind) {

4287       case INCR:

4288         PreIncrementExpression();

4289         break;

4290       case DECR:

4291         PreDecrementExpression();

4292         break;

4293       default:

4294         jj_la1[109] = jj_gen;

4295         if (jj_2_43(2147483647)) {

4296           PostfixExpression();

4297         } else {

4298           switch (jj_nt.kind) {

4299           case BOOLEAN:

4300           case BYTE:

4301           case CHAR:

4302           case DOUBLE:

4303           case FALSE:

4304           case FLOAT:

4305           case INT:

4306           case LONG:

4307           case NEW:

4308           case NULL:

4309           case SHORT:

4310           case SUPER:

4311           case THIS:

4312           case TRUE:

4313           case VOID:

4314           case INTEGER_LITERAL:

4315           case FLOATING_POINT_LITERAL:

4316           case HEX_FLOATING_POINT_LITERAL:

4317           case CHARACTER_LITERAL:

4318           case STRING_LITERAL:

4319           case IDENTIFIER:

4320           case LPAREN:

4321             PrimaryExpression();

4322             switch (jj_nt.kind) {

4323             case ASSIGN:

4324             case PLUSASSIGN:

4325             case MINUSASSIGN:

4326             case STARASSIGN:

4327             case SLASHASSIGN:

4328             case ANDASSIGN:

4329             case ORASSIGN:

4330             case XORASSIGN:

4331             case REMASSIGN:

4332             case LSHIFTASSIGN:

4333             case RSIGNEDSHIFTASSIGN:

4334             case RUNSIGNEDSHIFTASSIGN:

4335               AssignmentOperator();

4336               Expression();

4337               break;

4338             default:

4339               jj_la1[108] = jj_gen;

4340               ;

4341             }

4342             break;

4343           default:

4344             jj_la1[110] = jj_gen;

4345             jj_consume_token(-1);

4346             throw new ParseException();

4347           }

4348         }

4349       }

4350     } catch (Throwable jjte000) {

4351     if (jjtc000) {

4352       jjtree.clearNodeScope(jjtn000);

4353       jjtc000 = false;

4354     } else {

4355       jjtree.popNode();

4356     }

4357     if (jjte000 instanceof RuntimeException) {

4358       {if (true) throw (RuntimeException)jjte000;}

4359     }

4360     if (jjte000 instanceof ParseException) {

4361       {if (true) throw (ParseException)jjte000;}

4362     }

4363     {if (true) throw (Error)jjte000;}

4364     } finally {

4365     if (jjtc000) {

4366       jjtree.closeNodeScope(jjtn000, true);

4367     }

4368     }

4369   }

4370 

4371   final public void SwitchStatement() throws ParseException {

4372  /*@bgen(jjtree) SwitchStatement */

4373   ASTSwitchStatement jjtn000 = new ASTSwitchStatement(this, JJTSWITCHSTATEMENT);

4374   boolean jjtc000 = true;

4375   jjtree.openNodeScope(jjtn000);

4376     try {

4377       jj_consume_token(SWITCH);

4378       jj_consume_token(LPAREN);

4379       Expression();

4380       jj_consume_token(RPAREN);

4381       jj_consume_token(LBRACE);

4382       label_45:

4383       while (true) {

4384         switch (jj_nt.kind) {

4385         case CASE:

4386         case _DEFAULT:

4387           ;

4388           break;

4389         default:

4390           jj_la1[111] = jj_gen;

4391           break label_45;

4392         }

4393         SwitchLabel();

4394         label_46:

4395         while (true) {

4396           if (jj_2_44(1)) {

4397             ;

4398           } else {

4399             break label_46;

4400           }

4401           BlockStatement();

4402         }

4403       }

4404       jj_consume_token(RBRACE);

4405     } catch (Throwable jjte000) {

4406     if (jjtc000) {

4407       jjtree.clearNodeScope(jjtn000);

4408       jjtc000 = false;

4409     } else {

4410       jjtree.popNode();

4411     }

4412     if (jjte000 instanceof RuntimeException) {

4413       {if (true) throw (RuntimeException)jjte000;}

4414     }

4415     if (jjte000 instanceof ParseException) {

4416       {if (true) throw (ParseException)jjte000;}

4417     }

4418     {if (true) throw (Error)jjte000;}

4419     } finally {

4420     if (jjtc000) {

4421       jjtree.closeNodeScope(jjtn000, true);

4422     }

4423     }

4424   }

4425 

4426   final public void SwitchLabel() throws ParseException {

4427  /*@bgen(jjtree) SwitchLabel */

4428   ASTSwitchLabel jjtn000 = new ASTSwitchLabel(this, JJTSWITCHLABEL);

4429   boolean jjtc000 = true;

4430   jjtree.openNodeScope(jjtn000);

4431     try {

4432       switch (jj_nt.kind) {

4433       case CASE:

4434         jj_consume_token(CASE);

4435         Expression();

4436         jj_consume_token(COLON);

4437         break;

4438       case _DEFAULT:

4439         jj_consume_token(_DEFAULT);

4440              jjtn000.setDefault();

4441         jj_consume_token(COLON);

4442         break;

4443       default:

4444         jj_la1[112] = jj_gen;

4445         jj_consume_token(-1);

4446         throw new ParseException();

4447       }

4448     } catch (Throwable jjte000) {

4449     if (jjtc000) {

4450       jjtree.clearNodeScope(jjtn000);

4451       jjtc000 = false;

4452     } else {

4453       jjtree.popNode();

4454     }

4455     if (jjte000 instanceof RuntimeException) {

4456       {if (true) throw (RuntimeException)jjte000;}

4457     }

4458     if (jjte000 instanceof ParseException) {

4459       {if (true) throw (ParseException)jjte000;}

4460     }

4461     {if (true) throw (Error)jjte000;}

4462     } finally {

4463     if (jjtc000) {

4464       jjtree.closeNodeScope(jjtn000, true);

4465     }

4466     }

4467   }

4468 

4469   final public void IfStatement() throws ParseException {

4470  /*@bgen(jjtree) IfStatement */

4471   ASTIfStatement jjtn000 = new ASTIfStatement(this, JJTIFSTATEMENT);

4472   boolean jjtc000 = true;

4473   jjtree.openNodeScope(jjtn000);

4474     try {

4475       jj_consume_token(IF);

4476       jj_consume_token(LPAREN);

4477       Expression();

4478       jj_consume_token(RPAREN);

4479       Statement();

4480       switch (jj_nt.kind) {

4481       case ELSE:

4482         jj_consume_token(ELSE);

4483                                                                jjtn000.setHasElse();

4484         Statement();

4485         break;

4486       default:

4487         jj_la1[113] = jj_gen;

4488         ;

4489       }

4490   jjtree.closeNodeScope(jjtn000, true);

4491   jjtc000 = false;

4492 

4493     } catch (Throwable jjte000) {

4494     if (jjtc000) {

4495       jjtree.clearNodeScope(jjtn000);

4496       jjtc000 = false;

4497     } else {

4498       jjtree.popNode();

4499     }

4500     if (jjte000 instanceof RuntimeException) {

4501       {if (true) throw (RuntimeException)jjte000;}

4502     }

4503     if (jjte000 instanceof ParseException) {

4504       {if (true) throw (ParseException)jjte000;}

4505     }

4506     {if (true) throw (Error)jjte000;}

4507     } finally {

4508     if (jjtc000) {

4509       jjtree.closeNodeScope(jjtn000, true);

4510     }

4511     }

4512   }

4513 

4514   final public void WhileStatement() throws ParseException {

4515  /*@bgen(jjtree) WhileStatement */

4516   ASTWhileStatement jjtn000 = new ASTWhileStatement(this, JJTWHILESTATEMENT);

4517   boolean jjtc000 = true;

4518   jjtree.openNodeScope(jjtn000);

4519     try {

4520       jj_consume_token(WHILE);

4521       jj_consume_token(LPAREN);

4522       Expression();

4523       jj_consume_token(RPAREN);

4524       Statement();

4525     } catch (Throwable jjte000) {

4526     if (jjtc000) {

4527       jjtree.clearNodeScope(jjtn000);

4528       jjtc000 = false;

4529     } else {

4530       jjtree.popNode();

4531     }

4532     if (jjte000 instanceof RuntimeException) {

4533       {if (true) throw (RuntimeException)jjte000;}

4534     }

4535     if (jjte000 instanceof ParseException) {

4536       {if (true) throw (ParseException)jjte000;}

4537     }

4538     {if (true) throw (Error)jjte000;}

4539     } finally {

4540     if (jjtc000) {

4541       jjtree.closeNodeScope(jjtn000, true);

4542     }

4543     }

4544   }

4545 

4546   final public void DoStatement() throws ParseException {

4547  /*@bgen(jjtree) DoStatement */

4548   ASTDoStatement jjtn000 = new ASTDoStatement(this, JJTDOSTATEMENT);

4549   boolean jjtc000 = true;

4550   jjtree.openNodeScope(jjtn000);

4551     try {

4552       jj_consume_token(DO);

4553       Statement();

4554       jj_consume_token(WHILE);

4555       jj_consume_token(LPAREN);

4556       Expression();

4557       jj_consume_token(RPAREN);

4558       jj_consume_token(SEMICOLON);

4559     } catch (Throwable jjte000) {

4560     if (jjtc000) {

4561       jjtree.clearNodeScope(jjtn000);

4562       jjtc000 = false;

4563     } else {

4564       jjtree.popNode();

4565     }

4566     if (jjte000 instanceof RuntimeException) {

4567       {if (true) throw (RuntimeException)jjte000;}

4568     }

4569     if (jjte000 instanceof ParseException) {

4570       {if (true) throw (ParseException)jjte000;}

4571     }

4572     {if (true) throw (Error)jjte000;}

4573     } finally {

4574     if (jjtc000) {

4575       jjtree.closeNodeScope(jjtn000, true);

4576     }

4577     }

4578   }

4579 

4580   final public void ForStatement() throws ParseException {

4581  /*@bgen(jjtree) ForStatement */

4582   ASTForStatement jjtn000 = new ASTForStatement(this, JJTFORSTATEMENT);

4583   boolean jjtc000 = true;

4584   jjtree.openNodeScope(jjtn000);

4585     try {

4586       jj_consume_token(FOR);

4587       jj_consume_token(LPAREN);

4588       if (jj_2_45(2147483647)) {

4589        checkForBadJDK15ForLoopSyntaxArgumentsUsage();

4590         Modifiers();

4591         Type();

4592         jj_consume_token(IDENTIFIER);

4593         jj_consume_token(COLON);

4594         Expression();

4595       } else {

4596         switch (jj_nt.kind) {

4597         case BOOLEAN:

4598         case BYTE:

4599         case CHAR:

4600         case DOUBLE:

4601         case FALSE:

4602         case FINAL:

4603         case FLOAT:

4604         case INT:

4605         case LONG:

4606         case NEW:

4607         case NULL:

4608         case SHORT:

4609         case SUPER:

4610         case THIS:

4611         case TRUE:

4612         case VOID:

4613         case INTEGER_LITERAL:

4614         case FLOATING_POINT_LITERAL:

4615         case HEX_FLOATING_POINT_LITERAL:

4616         case CHARACTER_LITERAL:

4617         case STRING_LITERAL:

4618         case IDENTIFIER:

4619         case LPAREN:

4620         case SEMICOLON:

4621         case AT:

4622         case INCR:

4623         case DECR:

4624           switch (jj_nt.kind) {

4625           case BOOLEAN:

4626           case BYTE:

4627           case CHAR:

4628           case DOUBLE:

4629           case FALSE:

4630           case FINAL:

4631           case FLOAT:

4632           case INT:

4633           case LONG:

4634           case NEW:

4635           case NULL:

4636           case SHORT:

4637           case SUPER:

4638           case THIS:

4639           case TRUE:

4640           case VOID:

4641           case INTEGER_LITERAL:

4642           case FLOATING_POINT_LITERAL:

4643           case HEX_FLOATING_POINT_LITERAL:

4644           case CHARACTER_LITERAL:

4645           case STRING_LITERAL:

4646           case IDENTIFIER:

4647           case LPAREN:

4648           case AT:

4649           case INCR:

4650           case DECR:

4651             ForInit();

4652             break;

4653           default:

4654             jj_la1[114] = jj_gen;

4655             ;

4656           }

4657           jj_consume_token(SEMICOLON);

4658           switch (jj_nt.kind) {

4659           case BOOLEAN:

4660           case BYTE:

4661           case CHAR:

4662           case DOUBLE:

4663           case FALSE:

4664           case FLOAT:

4665           case INT:

4666           case LONG:

4667           case NEW:

4668           case NULL:

4669           case SHORT:

4670           case SUPER:

4671           case THIS:

4672           case TRUE:

4673           case VOID:

4674           case INTEGER_LITERAL:

4675           case FLOATING_POINT_LITERAL:

4676           case HEX_FLOATING_POINT_LITERAL:

4677           case CHARACTER_LITERAL:

4678           case STRING_LITERAL:

4679           case IDENTIFIER:

4680           case LPAREN:

4681           case BANG:

4682           case TILDE:

4683           case INCR:

4684           case DECR:

4685           case PLUS:

4686           case MINUS:

4687             Expression();

4688             break;

4689           default:

4690             jj_la1[115] = jj_gen;

4691             ;

4692           }

4693           jj_consume_token(SEMICOLON);

4694           switch (jj_nt.kind) {

4695           case BOOLEAN:

4696           case BYTE:

4697           case CHAR:

4698           case DOUBLE:

4699           case FALSE:

4700           case FLOAT:

4701           case INT:

4702           case LONG:

4703           case NEW:

4704           case NULL:

4705           case SHORT:

4706           case SUPER:

4707           case THIS:

4708           case TRUE:

4709           case VOID:

4710           case INTEGER_LITERAL:

4711           case FLOATING_POINT_LITERAL:

4712           case HEX_FLOATING_POINT_LITERAL:

4713           case CHARACTER_LITERAL:

4714           case STRING_LITERAL:

4715           case IDENTIFIER:

4716           case LPAREN:

4717           case INCR:

4718           case DECR:

4719             ForUpdate();

4720             break;

4721           default:

4722             jj_la1[116] = jj_gen;

4723             ;

4724           }

4725           break;

4726         default:

4727           jj_la1[117] = jj_gen;

4728           jj_consume_token(-1);

4729           throw new ParseException();

4730         }

4731       }

4732       jj_consume_token(RPAREN);

4733       Statement();

4734     } catch (Throwable jjte000) {

4735     if (jjtc000) {

4736       jjtree.clearNodeScope(jjtn000);

4737       jjtc000 = false;

4738     } else {

4739       jjtree.popNode();

4740     }

4741     if (jjte000 instanceof RuntimeException) {

4742       {if (true) throw (RuntimeException)jjte000;}

4743     }

4744     if (jjte000 instanceof ParseException) {

4745       {if (true) throw (ParseException)jjte000;}

4746     }

4747     {if (true) throw (Error)jjte000;}

4748     } finally {

4749     if (jjtc000) {

4750       jjtree.closeNodeScope(jjtn000, true);

4751     }

4752     }

4753   }

4754 

4755   final public void ForInit() throws ParseException {

4756  /*@bgen(jjtree) ForInit */

4757   ASTForInit jjtn000 = new ASTForInit(this, JJTFORINIT);

4758   boolean jjtc000 = true;

4759   jjtree.openNodeScope(jjtn000);

4760     try {

4761       if (jj_2_46(2147483647)) {

4762         LocalVariableDeclaration();

4763       } else {

4764         switch (jj_nt.kind) {

4765         case BOOLEAN:

4766         case BYTE:

4767         case CHAR:

4768         case DOUBLE:

4769         case FALSE:

4770         case FLOAT:

4771         case INT:

4772         case LONG:

4773         case NEW:

4774         case NULL:

4775         case SHORT:

4776         case SUPER:

4777         case THIS:

4778         case TRUE:

4779         case VOID:

4780         case INTEGER_LITERAL:

4781         case FLOATING_POINT_LITERAL:

4782         case HEX_FLOATING_POINT_LITERAL:

4783         case CHARACTER_LITERAL:

4784         case STRING_LITERAL:

4785         case IDENTIFIER:

4786         case LPAREN:

4787         case INCR:

4788         case DECR:

4789           StatementExpressionList();

4790           break;

4791         default:

4792           jj_la1[118] = jj_gen;

4793           jj_consume_token(-1);

4794           throw new ParseException();

4795         }

4796       }

4797     } catch (Throwable jjte000) {

4798     if (jjtc000) {

4799       jjtree.clearNodeScope(jjtn000);

4800       jjtc000 = false;

4801     } else {

4802       jjtree.popNode();

4803     }

4804     if (jjte000 instanceof RuntimeException) {

4805       {if (true) throw (RuntimeException)jjte000;}

4806     }

4807     if (jjte000 instanceof ParseException) {

4808       {if (true) throw (ParseException)jjte000;}

4809     }

4810     {if (true) throw (Error)jjte000;}

4811     } finally {

4812     if (jjtc000) {

4813       jjtree.closeNodeScope(jjtn000, true);

4814     }

4815     }

4816   }

4817 

4818   final public void StatementExpressionList() throws ParseException {

4819  /*@bgen(jjtree) StatementExpressionList */

4820   ASTStatementExpressionList jjtn000 = new ASTStatementExpressionList(this, JJTSTATEMENTEXPRESSIONLIST);

4821   boolean jjtc000 = true;

4822   jjtree.openNodeScope(jjtn000);

4823     try {

4824       StatementExpression();

4825       label_47:

4826       while (true) {

4827         switch (jj_nt.kind) {

4828         case COMMA:

4829           ;

4830           break;

4831         default:

4832           jj_la1[119] = jj_gen;

4833           break label_47;

4834         }

4835         jj_consume_token(COMMA);

4836         StatementExpression();

4837       }

4838     } catch (Throwable jjte000) {

4839     if (jjtc000) {

4840       jjtree.clearNodeScope(jjtn000);

4841       jjtc000 = false;

4842     } else {

4843       jjtree.popNode();

4844     }

4845     if (jjte000 instanceof RuntimeException) {

4846       {if (true) throw (RuntimeException)jjte000;}

4847     }

4848     if (jjte000 instanceof ParseException) {

4849       {if (true) throw (ParseException)jjte000;}

4850     }

4851     {if (true) throw (Error)jjte000;}

4852     } finally {

4853     if (jjtc000) {

4854       jjtree.closeNodeScope(jjtn000, true);

4855     }

4856     }

4857   }

4858 

4859   final public void ForUpdate() throws ParseException {

4860  /*@bgen(jjtree) ForUpdate */

4861   ASTForUpdate jjtn000 = new ASTForUpdate(this, JJTFORUPDATE);

4862   boolean jjtc000 = true;

4863   jjtree.openNodeScope(jjtn000);

4864     try {

4865       StatementExpressionList();

4866     } catch (Throwable jjte000) {

4867     if (jjtc000) {

4868       jjtree.clearNodeScope(jjtn000);

4869       jjtc000 = false;

4870     } else {

4871       jjtree.popNode();

4872     }

4873     if (jjte000 instanceof RuntimeException) {

4874       {if (true) throw (RuntimeException)jjte000;}

4875     }

4876     if (jjte000 instanceof ParseException) {

4877       {if (true) throw (ParseException)jjte000;}

4878     }

4879     {if (true) throw (Error)jjte000;}

4880     } finally {

4881     if (jjtc000) {

4882       jjtree.closeNodeScope(jjtn000, true);

4883     }

4884     }

4885   }

4886 

4887   final public void BreakStatement() throws ParseException {

4888  /*@bgen(jjtree) BreakStatement */

4889  ASTBreakStatement jjtn000 = new ASTBreakStatement(this, JJTBREAKSTATEMENT);

4890  boolean jjtc000 = true;

4891  jjtree.openNodeScope(jjtn000);Token t;

4892     try {

4893       jj_consume_token(BREAK);

4894       switch (jj_nt.kind) {

4895       case IDENTIFIER:

4896         t = jj_consume_token(IDENTIFIER);

4897                             jjtn000.setImage(t.image);

4898         break;

4899       default:

4900         jj_la1[120] = jj_gen;

4901         ;

4902       }

4903       jj_consume_token(SEMICOLON);

4904     } finally {

4905     if (jjtc000) {

4906       jjtree.closeNodeScope(jjtn000, true);

4907     }

4908     }

4909   }

4910 

4911   final public void ContinueStatement() throws ParseException {

4912  /*@bgen(jjtree) ContinueStatement */

4913  ASTContinueStatement jjtn000 = new ASTContinueStatement(this, JJTCONTINUESTATEMENT);

4914  boolean jjtc000 = true;

4915  jjtree.openNodeScope(jjtn000);Token t;

4916     try {

4917       jj_consume_token(CONTINUE);

4918       switch (jj_nt.kind) {

4919       case IDENTIFIER:

4920         t = jj_consume_token(IDENTIFIER);

4921                                jjtn000.setImage(t.image);

4922         break;

4923       default:

4924         jj_la1[121] = jj_gen;

4925         ;

4926       }

4927       jj_consume_token(SEMICOLON);

4928     } finally {

4929     if (jjtc000) {

4930       jjtree.closeNodeScope(jjtn000, true);

4931     }

4932     }

4933   }

4934 

4935   final public void ReturnStatement() throws ParseException {

4936  /*@bgen(jjtree) ReturnStatement */

4937   ASTReturnStatement jjtn000 = new ASTReturnStatement(this, JJTRETURNSTATEMENT);

4938   boolean jjtc000 = true;

4939   jjtree.openNodeScope(jjtn000);

4940     try {

4941       jj_consume_token(RETURN);

4942       switch (jj_nt.kind) {

4943       case BOOLEAN:

4944       case BYTE:

4945       case CHAR:

4946       case DOUBLE:

4947       case FALSE:

4948       case FLOAT:

4949       case INT:

4950       case LONG:

4951       case NEW:

4952       case NULL:

4953       case SHORT:

4954       case SUPER:

4955       case THIS:

4956       case TRUE:

4957       case VOID:

4958       case INTEGER_LITERAL:

4959       case FLOATING_POINT_LITERAL:

4960       case HEX_FLOATING_POINT_LITERAL:

4961       case CHARACTER_LITERAL:

4962       case STRING_LITERAL:

4963       case IDENTIFIER:

4964       case LPAREN:

4965       case BANG:

4966       case TILDE:

4967       case INCR:

4968       case DECR:

4969       case PLUS:

4970       case MINUS:

4971         Expression();

4972         break;

4973       default:

4974         jj_la1[122] = jj_gen;

4975         ;

4976       }

4977       jj_consume_token(SEMICOLON);

4978     } catch (Throwable jjte000) {

4979     if (jjtc000) {

4980       jjtree.clearNodeScope(jjtn000);

4981       jjtc000 = false;

4982     } else {

4983       jjtree.popNode();

4984     }

4985     if (jjte000 instanceof RuntimeException) {

4986       {if (true) throw (RuntimeException)jjte000;}

4987     }

4988     if (jjte000 instanceof ParseException) {

4989       {if (true) throw (ParseException)jjte000;}

4990     }

4991     {if (true) throw (Error)jjte000;}

4992     } finally {

4993     if (jjtc000) {

4994       jjtree.closeNodeScope(jjtn000, true);

4995     }

4996     }

4997   }

4998 

4999   final public void ThrowStatement() throws ParseException {

5000  /*@bgen(jjtree) ThrowStatement */

5001   ASTThrowStatement jjtn000 = new ASTThrowStatement(this, JJTTHROWSTATEMENT);

5002   boolean jjtc000 = true;

5003   jjtree.openNodeScope(jjtn000);

5004     try {

5005       jj_consume_token(THROW);

5006       Expression();

5007       jj_consume_token(SEMICOLON);

5008     } catch (Throwable jjte000) {

5009     if (jjtc000) {

5010       jjtree.clearNodeScope(jjtn000);

5011       jjtc000 = false;

5012     } else {

5013       jjtree.popNode();

5014     }

5015     if (jjte000 instanceof RuntimeException) {

5016       {if (true) throw (RuntimeException)jjte000;}

5017     }

5018     if (jjte000 instanceof ParseException) {

5019       {if (true) throw (ParseException)jjte000;}

5020     }

5021     {if (true) throw (Error)jjte000;}

5022     } finally {

5023     if (jjtc000) {

5024       jjtree.closeNodeScope(jjtn000, true);

5025     }

5026     }

5027   }

5028 

5029   final public void SynchronizedStatement() throws ParseException {

5030  /*@bgen(jjtree) SynchronizedStatement */

5031   ASTSynchronizedStatement jjtn000 = new ASTSynchronizedStatement(this, JJTSYNCHRONIZEDSTATEMENT);

5032   boolean jjtc000 = true;

5033   jjtree.openNodeScope(jjtn000);

5034     try {

5035       jj_consume_token(SYNCHRONIZED);

5036       jj_consume_token(LPAREN);

5037       Expression();

5038       jj_consume_token(RPAREN);

5039       Block();

5040     } catch (Throwable jjte000) {

5041     if (jjtc000) {

5042       jjtree.clearNodeScope(jjtn000);

5043       jjtc000 = false;

5044     } else {

5045       jjtree.popNode();

5046     }

5047     if (jjte000 instanceof RuntimeException) {

5048       {if (true) throw (RuntimeException)jjte000;}

5049     }

5050     if (jjte000 instanceof ParseException) {

5051       {if (true) throw (ParseException)jjte000;}

5052     }

5053     {if (true) throw (Error)jjte000;}

5054     } finally {

5055     if (jjtc000) {

5056       jjtree.closeNodeScope(jjtn000, true);

5057     }

5058     }

5059   }

5060 

5061   final public void TryStatement() throws ParseException {

5062  /*@bgen(jjtree) TryStatement */

5063   ASTTryStatement jjtn000 = new ASTTryStatement(this, JJTTRYSTATEMENT);

5064   boolean jjtc000 = true;

5065   jjtree.openNodeScope(jjtn000);

5066     try {

5067       jj_consume_token(TRY);

5068       Block();

5069       label_48:

5070       while (true) {

5071         switch (jj_nt.kind) {

5072         case CATCH:

5073           ;

5074           break;

5075         default:

5076           jj_la1[123] = jj_gen;

5077           break label_48;

5078         }

5079         CatchStatement();

5080       }

5081       switch (jj_nt.kind) {

5082       case FINALLY:

5083         FinallyStatement();

5084         break;

5085       default:

5086         jj_la1[124] = jj_gen;

5087         ;

5088       }

5089     } catch (Throwable jjte000) {

5090     if (jjtc000) {

5091       jjtree.clearNodeScope(jjtn000);

5092       jjtc000 = false;

5093     } else {

5094       jjtree.popNode();

5095     }

5096     if (jjte000 instanceof RuntimeException) {

5097       {if (true) throw (RuntimeException)jjte000;}

5098     }

5099     if (jjte000 instanceof ParseException) {

5100       {if (true) throw (ParseException)jjte000;}

5101     }

5102     {if (true) throw (Error)jjte000;}

5103     } finally {

5104     if (jjtc000) {

5105       jjtree.closeNodeScope(jjtn000, true);

5106     }

5107     }

5108   }

5109 

5110   final public void CatchStatement() throws ParseException {

5111  /*@bgen(jjtree) CatchStatement */

5112   ASTCatchStatement jjtn000 = new ASTCatchStatement(this, JJTCATCHSTATEMENT);

5113   boolean jjtc000 = true;

5114   jjtree.openNodeScope(jjtn000);

5115     try {

5116       jj_consume_token(CATCH);

5117       jj_consume_token(LPAREN);

5118       FormalParameter();

5119       jj_consume_token(RPAREN);

5120       Block();

5121     } catch (Throwable jjte000) {

5122     if (jjtc000) {

5123       jjtree.clearNodeScope(jjtn000);

5124       jjtc000 = false;

5125     } else {

5126       jjtree.popNode();

5127     }

5128     if (jjte000 instanceof RuntimeException) {

5129       {if (true) throw (RuntimeException)jjte000;}

5130     }

5131     if (jjte000 instanceof ParseException) {

5132       {if (true) throw (ParseException)jjte000;}

5133     }

5134     {if (true) throw (Error)jjte000;}

5135     } finally {

5136     if (jjtc000) {

5137       jjtree.closeNodeScope(jjtn000, true);

5138     }

5139     }

5140   }

5141 

5142   final public void FinallyStatement() throws ParseException {

5143  /*@bgen(jjtree) FinallyStatement */

5144   ASTFinallyStatement jjtn000 = new ASTFinallyStatement(this, JJTFINALLYSTATEMENT);

5145   boolean jjtc000 = true;

5146   jjtree.openNodeScope(jjtn000);

5147     try {

5148       jj_consume_token(FINALLY);

5149       Block();

5150     } catch (Throwable jjte000) {

5151       if (jjtc000) {

5152         jjtree.clearNodeScope(jjtn000);

5153         jjtc000 = false;

5154       } else {

5155         jjtree.popNode();

5156       }

5157       if (jjte000 instanceof RuntimeException) {

5158         {if (true) throw (RuntimeException)jjte000;}

5159       }

5160       if (jjte000 instanceof ParseException) {

5161         {if (true) throw (ParseException)jjte000;}

5162       }

5163       {if (true) throw (Error)jjte000;}

5164     } finally {

5165       if (jjtc000) {

5166         jjtree.closeNodeScope(jjtn000, true);

5167       }

5168     }

5169   }

5170 

5171   final public void AssertStatement() throws ParseException {

5172  /*@bgen(jjtree) AssertStatement */

5173     ASTAssertStatement jjtn000 = new ASTAssertStatement(this, JJTASSERTSTATEMENT);

5174     boolean jjtc000 = true;

5175     jjtree.openNodeScope(jjtn000);if (isJDK13) {

5176         throw new ParseException("Can't use 'assert' as a keyword when running in JDK 1.3 mode!");

5177     }

5178     try {

5179       jj_consume_token(IDENTIFIER);

5180       Expression();

5181       switch (jj_nt.kind) {

5182       case COLON:

5183         jj_consume_token(COLON);

5184         Expression();

5185         break;

5186       default:

5187         jj_la1[125] = jj_gen;

5188         ;

5189       }

5190       jj_consume_token(SEMICOLON);

5191     } catch (Throwable jjte000) {

5192     if (jjtc000) {

5193       jjtree.clearNodeScope(jjtn000);

5194       jjtc000 = false;

5195     } else {

5196       jjtree.popNode();

5197     }

5198     if (jjte000 instanceof RuntimeException) {

5199       {if (true) throw (RuntimeException)jjte000;}

5200     }

5201     if (jjte000 instanceof ParseException) {

5202       {if (true) throw (ParseException)jjte000;}

5203     }

5204     {if (true) throw (Error)jjte000;}

5205     } finally {

5206     if (jjtc000) {

5207       jjtree.closeNodeScope(jjtn000, true);

5208     }

5209     }

5210   }

5211 

5212 /* We use productions to match >>>, >> and > so that we can keep the

5213  * type declaration syntax with generics clean

5214  */

5215   final public void RUNSIGNEDSHIFT() throws ParseException {

5216  /*@bgen(jjtree) RUNSIGNEDSHIFT */

5217   ASTRUNSIGNEDSHIFT jjtn000 = new ASTRUNSIGNEDSHIFT(this, JJTRUNSIGNEDSHIFT);

5218   boolean jjtc000 = true;

5219   jjtree.openNodeScope(jjtn000);

5220     try {

5221       if (getToken(1).kind == GT &&

5222                       ((Token.GTToken)getToken(1)).realKind == RUNSIGNEDSHIFT) {

5223 

5224       } else {

5225         jj_consume_token(-1);

5226         throw new ParseException();

5227       }

5228       jj_consume_token(GT);

5229       jj_consume_token(GT);

5230       jj_consume_token(GT);

5231     } finally {

5232     if (jjtc000) {

5233       jjtree.closeNodeScope(jjtn000, true);

5234     }

5235     }

5236   }

5237 

5238   final public void RSIGNEDSHIFT() throws ParseException {

5239  /*@bgen(jjtree) RSIGNEDSHIFT */

5240   ASTRSIGNEDSHIFT jjtn000 = new ASTRSIGNEDSHIFT(this, JJTRSIGNEDSHIFT);

5241   boolean jjtc000 = true;

5242   jjtree.openNodeScope(jjtn000);

5243     try {

5244       if (getToken(1).kind == GT &&

5245                       ((Token.GTToken)getToken(1)).realKind == RSIGNEDSHIFT) {

5246 

5247       } else {

5248         jj_consume_token(-1);

5249         throw new ParseException();

5250       }

5251       jj_consume_token(GT);

5252       jj_consume_token(GT);

5253     } finally {

5254     if (jjtc000) {

5255       jjtree.closeNodeScope(jjtn000, true);

5256     }

5257     }

5258   }

5259 

5260 /* Annotation syntax follows. */

5261   final public void Annotation() throws ParseException {

5262  /*@bgen(jjtree) Annotation */

5263   ASTAnnotation jjtn000 = new ASTAnnotation(this, JJTANNOTATION);

5264   boolean jjtc000 = true;

5265   jjtree.openNodeScope(jjtn000);

5266     try {

5267       if (jj_2_47(2147483647)) {

5268         NormalAnnotation();

5269       } else if (jj_2_48(2147483647)) {

5270         SingleMemberAnnotation();

5271       } else {

5272         switch (jj_nt.kind) {

5273         case AT:

5274           MarkerAnnotation();

5275           break;

5276         default:

5277           jj_la1[126] = jj_gen;

5278           jj_consume_token(-1);

5279           throw new ParseException();

5280         }

5281       }

5282     } catch (Throwable jjte000) {

5283      if (jjtc000) {

5284        jjtree.clearNodeScope(jjtn000);

5285        jjtc000 = false;

5286      } else {

5287        jjtree.popNode();

5288      }

5289      if (jjte000 instanceof RuntimeException) {

5290        {if (true) throw (RuntimeException)jjte000;}

5291      }

5292      if (jjte000 instanceof ParseException) {

5293        {if (true) throw (ParseException)jjte000;}

5294      }

5295      {if (true) throw (Error)jjte000;}

5296     } finally {

5297      if (jjtc000) {

5298        jjtree.closeNodeScope(jjtn000, true);

5299      }

5300     }

5301   }

5302 

5303   final public void NormalAnnotation() throws ParseException {

5304  /*@bgen(jjtree) NormalAnnotation */

5305   ASTNormalAnnotation jjtn000 = new ASTNormalAnnotation(this, JJTNORMALANNOTATION);

5306   boolean jjtc000 = true;

5307   jjtree.openNodeScope(jjtn000);

5308     try {

5309       jj_consume_token(AT);

5310       Name();

5311       jj_consume_token(LPAREN);

5312       switch (jj_nt.kind) {

5313       case IDENTIFIER:

5314         MemberValuePairs();

5315         break;

5316       default:

5317         jj_la1[127] = jj_gen;

5318         ;

5319       }

5320       jj_consume_token(RPAREN);

5321                                                jjtree.closeNodeScope(jjtn000, true);

5322                                                jjtc000 = false;

5323                                               checkForBadAnnotationUsage();

5324     } catch (Throwable jjte000) {

5325      if (jjtc000) {

5326        jjtree.clearNodeScope(jjtn000);

5327        jjtc000 = false;

5328      } else {

5329        jjtree.popNode();

5330      }

5331      if (jjte000 instanceof RuntimeException) {

5332        {if (true) throw (RuntimeException)jjte000;}

5333      }

5334      if (jjte000 instanceof ParseException) {

5335        {if (true) throw (ParseException)jjte000;}

5336      }

5337      {if (true) throw (Error)jjte000;}

5338     } finally {

5339      if (jjtc000) {

5340        jjtree.closeNodeScope(jjtn000, true);

5341      }

5342     }

5343   }

5344 

5345   final public void MarkerAnnotation() throws ParseException {

5346  /*@bgen(jjtree) MarkerAnnotation */

5347   ASTMarkerAnnotation jjtn000 = new ASTMarkerAnnotation(this, JJTMARKERANNOTATION);

5348   boolean jjtc000 = true;

5349   jjtree.openNodeScope(jjtn000);

5350     try {

5351       jj_consume_token(AT);

5352       Name();

5353                jjtree.closeNodeScope(jjtn000, true);

5354                jjtc000 = false;

5355               checkForBadAnnotationUsage();

5356     } catch (Throwable jjte000) {

5357     if (jjtc000) {

5358       jjtree.clearNodeScope(jjtn000);

5359       jjtc000 = false;

5360     } else {

5361       jjtree.popNode();

5362     }

5363     if (jjte000 instanceof RuntimeException) {

5364       {if (true) throw (RuntimeException)jjte000;}

5365     }

5366     if (jjte000 instanceof ParseException) {

5367       {if (true) throw (ParseException)jjte000;}

5368     }

5369     {if (true) throw (Error)jjte000;}

5370     } finally {

5371     if (jjtc000) {

5372       jjtree.closeNodeScope(jjtn000, true);

5373     }

5374     }

5375   }

5376 

5377   final public void SingleMemberAnnotation() throws ParseException {

5378  /*@bgen(jjtree) SingleMemberAnnotation */

5379   ASTSingleMemberAnnotation jjtn000 = new ASTSingleMemberAnnotation(this, JJTSINGLEMEMBERANNOTATION);

5380   boolean jjtc000 = true;

5381   jjtree.openNodeScope(jjtn000);

5382     try {

5383       jj_consume_token(AT);

5384       Name();

5385       jj_consume_token(LPAREN);

5386       MemberValue();

5387       jj_consume_token(RPAREN);

5388                                      jjtree.closeNodeScope(jjtn000, true);

5389                                      jjtc000 = false;

5390                                     checkForBadAnnotationUsage();

5391     } catch (Throwable jjte000) {

5392     if (jjtc000) {

5393       jjtree.clearNodeScope(jjtn000);

5394       jjtc000 = false;

5395     } else {

5396       jjtree.popNode();

5397     }

5398     if (jjte000 instanceof RuntimeException) {

5399       {if (true) throw (RuntimeException)jjte000;}

5400     }

5401     if (jjte000 instanceof ParseException) {

5402       {if (true) throw (ParseException)jjte000;}

5403     }

5404     {if (true) throw (Error)jjte000;}

5405     } finally {

5406     if (jjtc000) {

5407       jjtree.closeNodeScope(jjtn000, true);

5408     }

5409     }

5410   }

5411 

5412   final public void MemberValuePairs() throws ParseException {

5413  /*@bgen(jjtree) MemberValuePairs */

5414   ASTMemberValuePairs jjtn000 = new ASTMemberValuePairs(this, JJTMEMBERVALUEPAIRS);

5415   boolean jjtc000 = true;

5416   jjtree.openNodeScope(jjtn000);

5417     try {

5418       MemberValuePair();

5419       label_49:

5420       while (true) {

5421         switch (jj_nt.kind) {

5422         case COMMA:

5423           ;

5424           break;

5425         default:

5426           jj_la1[128] = jj_gen;

5427           break label_49;

5428         }

5429         jj_consume_token(COMMA);

5430         MemberValuePair();

5431       }

5432     } catch (Throwable jjte000) {

5433      if (jjtc000) {

5434        jjtree.clearNodeScope(jjtn000);

5435        jjtc000 = false;

5436      } else {

5437        jjtree.popNode();

5438      }

5439      if (jjte000 instanceof RuntimeException) {

5440        {if (true) throw (RuntimeException)jjte000;}

5441      }

5442      if (jjte000 instanceof ParseException) {

5443        {if (true) throw (ParseException)jjte000;}

5444      }

5445      {if (true) throw (Error)jjte000;}

5446     } finally {

5447      if (jjtc000) {

5448        jjtree.closeNodeScope(jjtn000, true);

5449      }

5450     }

5451   }

5452 

5453   final public void MemberValuePair() throws ParseException {

5454  /*@bgen(jjtree) MemberValuePair */

5455  ASTMemberValuePair jjtn000 = new ASTMemberValuePair(this, JJTMEMBERVALUEPAIR);

5456  boolean jjtc000 = true;

5457  jjtree.openNodeScope(jjtn000);Token t;

5458     try {

5459       t = jj_consume_token(IDENTIFIER);

5460                      jjtn000.setImage(t.image);

5461       jj_consume_token(ASSIGN);

5462       MemberValue();

5463     } catch (Throwable jjte000) {

5464       if (jjtc000) {

5465         jjtree.clearNodeScope(jjtn000);

5466         jjtc000 = false;

5467       } else {

5468         jjtree.popNode();

5469       }

5470       if (jjte000 instanceof RuntimeException) {

5471         {if (true) throw (RuntimeException)jjte000;}

5472       }

5473       if (jjte000 instanceof ParseException) {

5474         {if (true) throw (ParseException)jjte000;}

5475       }

5476       {if (true) throw (Error)jjte000;}

5477     } finally {

5478       if (jjtc000) {

5479         jjtree.closeNodeScope(jjtn000, true);

5480       }

5481     }

5482   }

5483 

5484   final public void MemberValue() throws ParseException {

5485  /*@bgen(jjtree) MemberValue */

5486   ASTMemberValue jjtn000 = new ASTMemberValue(this, JJTMEMBERVALUE);

5487   boolean jjtc000 = true;

5488   jjtree.openNodeScope(jjtn000);

5489     try {

5490       switch (jj_nt.kind) {

5491       case AT:

5492         Annotation();

5493         break;

5494       case LBRACE:

5495         MemberValueArrayInitializer();

5496         break;

5497       case BOOLEAN:

5498       case BYTE:

5499       case CHAR:

5500       case DOUBLE:

5501       case FALSE:

5502       case FLOAT:

5503       case INT:

5504       case LONG:

5505       case NEW:

5506       case NULL:

5507       case SHORT:

5508       case SUPER:

5509       case THIS:

5510       case TRUE:

5511       case VOID:

5512       case INTEGER_LITERAL:

5513       case FLOATING_POINT_LITERAL:

5514       case HEX_FLOATING_POINT_LITERAL:

5515       case CHARACTER_LITERAL:

5516       case STRING_LITERAL:

5517       case IDENTIFIER:

5518       case LPAREN:

5519       case BANG:

5520       case TILDE:

5521       case INCR:

5522       case DECR:

5523       case PLUS:

5524       case MINUS:

5525         ConditionalExpression();

5526         break;

5527       default:

5528         jj_la1[129] = jj_gen;

5529         jj_consume_token(-1);

5530         throw new ParseException();

5531       }

5532     } catch (Throwable jjte000) {

5533      if (jjtc000) {

5534        jjtree.clearNodeScope(jjtn000);

5535        jjtc000 = false;

5536      } else {

5537        jjtree.popNode();

5538      }

5539      if (jjte000 instanceof RuntimeException) {

5540        {if (true) throw (RuntimeException)jjte000;}

5541      }

5542      if (jjte000 instanceof ParseException) {

5543        {if (true) throw (ParseException)jjte000;}

5544      }

5545      {if (true) throw (Error)jjte000;}

5546     } finally {

5547      if (jjtc000) {

5548        jjtree.closeNodeScope(jjtn000, true);

5549      }

5550     }

5551   }

5552 

5553   final public void MemberValueArrayInitializer() throws ParseException {

5554  /*@bgen(jjtree) MemberValueArrayInitializer */

5555   ASTMemberValueArrayInitializer jjtn000 = new ASTMemberValueArrayInitializer(this, JJTMEMBERVALUEARRAYINITIALIZER);

5556   boolean jjtc000 = true;

5557   jjtree.openNodeScope(jjtn000);

5558     try {

5559       jj_consume_token(LBRACE);

5560       switch (jj_nt.kind) {

5561       case BOOLEAN:

5562       case BYTE:

5563       case CHAR:

5564       case DOUBLE:

5565       case FALSE:

5566       case FLOAT:

5567       case INT:

5568       case LONG:

5569       case NEW:

5570       case NULL:

5571       case SHORT:

5572       case SUPER:

5573       case THIS:

5574       case TRUE:

5575       case VOID:

5576       case INTEGER_LITERAL:

5577       case FLOATING_POINT_LITERAL:

5578       case HEX_FLOATING_POINT_LITERAL:

5579       case CHARACTER_LITERAL:

5580       case STRING_LITERAL:

5581       case IDENTIFIER:

5582       case LPAREN:

5583       case LBRACE:

5584       case AT:

5585       case BANG:

5586       case TILDE:

5587       case INCR:

5588       case DECR:

5589       case PLUS:

5590       case MINUS:

5591         MemberValue();

5592         label_50:

5593         while (true) {

5594           if (jj_2_49(2)) {

5595             ;

5596           } else {

5597             break label_50;

5598           }

5599           jj_consume_token(COMMA);

5600           MemberValue();

5601         }

5602         switch (jj_nt.kind) {

5603         case COMMA:

5604           jj_consume_token(COMMA);

5605           break;

5606         default:

5607           jj_la1[130] = jj_gen;

5608           ;

5609         }

5610         break;

5611       default:

5612         jj_la1[131] = jj_gen;

5613         ;

5614       }

5615       jj_consume_token(RBRACE);

5616     } catch (Throwable jjte000) {

5617     if (jjtc000) {

5618       jjtree.clearNodeScope(jjtn000);

5619       jjtc000 = false;

5620     } else {

5621       jjtree.popNode();

5622     }

5623     if (jjte000 instanceof RuntimeException) {

5624       {if (true) throw (RuntimeException)jjte000;}

5625     }

5626     if (jjte000 instanceof ParseException) {

5627       {if (true) throw (ParseException)jjte000;}

5628     }

5629     {if (true) throw (Error)jjte000;}

5630     } finally {

5631     if (jjtc000) {

5632       jjtree.closeNodeScope(jjtn000, true);

5633     }

5634     }

5635   }

5636 

5637 /* Annotation Types. */

5638   final public void AnnotationTypeDeclaration(int modifiers) throws ParseException {

5639  /*@bgen(jjtree) AnnotationTypeDeclaration */

5640 ASTAnnotationTypeDeclaration jjtn000 = new ASTAnnotationTypeDeclaration(this, JJTANNOTATIONTYPEDECLARATION);

5641 boolean jjtc000 = true;

5642 jjtree.openNodeScope(jjtn000);Token t;

5643 jjtn000.setModifiers(modifiers);

5644     try {

5645       jj_consume_token(AT);

5646       jj_consume_token(INTERFACE);

5647       t = jj_consume_token(IDENTIFIER);

5648                                   checkForBadAnnotationUsage();jjtn000.setImage(t.image);

5649       AnnotationTypeBody();

5650     } catch (Throwable jjte000) {

5651     if (jjtc000) {

5652       jjtree.clearNodeScope(jjtn000);

5653       jjtc000 = false;

5654     } else {

5655       jjtree.popNode();

5656     }

5657     if (jjte000 instanceof RuntimeException) {

5658       {if (true) throw (RuntimeException)jjte000;}

5659     }

5660     if (jjte000 instanceof ParseException) {

5661       {if (true) throw (ParseException)jjte000;}

5662     }

5663     {if (true) throw (Error)jjte000;}

5664     } finally {

5665     if (jjtc000) {

5666       jjtree.closeNodeScope(jjtn000, true);

5667     }

5668     }

5669   }

5670 

5671   final public void AnnotationTypeBody() throws ParseException {

5672  /*@bgen(jjtree) AnnotationTypeBody */

5673   ASTAnnotationTypeBody jjtn000 = new ASTAnnotationTypeBody(this, JJTANNOTATIONTYPEBODY);

5674   boolean jjtc000 = true;

5675   jjtree.openNodeScope(jjtn000);

5676     try {

5677       jj_consume_token(LBRACE);

5678       label_51:

5679       while (true) {

5680         switch (jj_nt.kind) {

5681         case ABSTRACT:

5682         case BOOLEAN:

5683         case BYTE:

5684         case CHAR:

5685         case CLASS:

5686         case DOUBLE:

5687         case FINAL:

5688         case FLOAT:

5689         case INT:

5690         case INTERFACE:

5691         case LONG:

5692         case NATIVE:

5693         case PRIVATE:

5694         case PROTECTED:

5695         case PUBLIC:

5696         case SHORT:

5697         case STATIC:

5698         case SYNCHRONIZED:

5699         case TRANSIENT:

5700         case VOLATILE:

5701         case STRICTFP:

5702         case IDENTIFIER:

5703         case SEMICOLON:

5704         case AT:

5705           ;

5706           break;

5707         default:

5708           jj_la1[132] = jj_gen;

5709           break label_51;

5710         }

5711         AnnotationTypeMemberDeclaration();

5712       }

5713       jj_consume_token(RBRACE);

5714     } catch (Throwable jjte000) {

5715     if (jjtc000) {

5716       jjtree.clearNodeScope(jjtn000);

5717       jjtc000 = false;

5718     } else {

5719       jjtree.popNode();

5720     }

5721     if (jjte000 instanceof RuntimeException) {

5722       {if (true) throw (RuntimeException)jjte000;}

5723     }

5724     if (jjte000 instanceof ParseException) {

5725       {if (true) throw (ParseException)jjte000;}

5726     }

5727     {if (true) throw (Error)jjte000;}

5728     } finally {

5729     if (jjtc000) {

5730       jjtree.closeNodeScope(jjtn000, true);

5731     }

5732     }

5733   }

5734 

5735   final public void AnnotationTypeMemberDeclaration() throws ParseException {

5736  /*@bgen(jjtree) AnnotationTypeMemberDeclaration */

5737    ASTAnnotationTypeMemberDeclaration jjtn000 = new ASTAnnotationTypeMemberDeclaration(this, JJTANNOTATIONTYPEMEMBERDECLARATION);

5738    boolean jjtc000 = true;

5739    jjtree.openNodeScope(jjtn000);int modifiers;

5740     try {

5741       switch (jj_nt.kind) {

5742       case ABSTRACT:

5743       case BOOLEAN:

5744       case BYTE:

5745       case CHAR:

5746       case CLASS:

5747       case DOUBLE:

5748       case FINAL:

5749       case FLOAT:

5750       case INT:

5751       case INTERFACE:

5752       case LONG:

5753       case NATIVE:

5754       case PRIVATE:

5755       case PROTECTED:

5756       case PUBLIC:

5757       case SHORT:

5758       case STATIC:

5759       case SYNCHRONIZED:

5760       case TRANSIENT:

5761       case VOLATILE:

5762       case STRICTFP:

5763       case IDENTIFIER:

5764       case AT:

5765         modifiers = Modifiers();

5766         if (jj_2_50(3)) {

5767           AnnotationMethodDeclaration(modifiers);

5768         } else {

5769           switch (jj_nt.kind) {

5770           case ABSTRACT:

5771           case CLASS:

5772           case FINAL:

5773           case INTERFACE:

5774             ClassOrInterfaceDeclaration(modifiers);

5775             break;

5776           default:

5777             jj_la1[133] = jj_gen;

5778             if (jj_2_51(3)) {

5779               EnumDeclaration(modifiers);

5780             } else {

5781               switch (jj_nt.kind) {

5782               case AT:

5783                 AnnotationTypeDeclaration(modifiers);

5784                 break;

5785               case BOOLEAN:

5786               case BYTE:

5787               case CHAR:

5788               case DOUBLE:

5789               case FLOAT:

5790               case INT:

5791               case LONG:

5792               case SHORT:

5793               case IDENTIFIER:

5794                 FieldDeclaration(modifiers);

5795                 break;

5796               default:

5797                 jj_la1[134] = jj_gen;

5798                 jj_consume_token(-1);

5799                 throw new ParseException();

5800               }

5801             }

5802           }

5803         }

5804         break;

5805       case SEMICOLON:

5806         jj_consume_token(SEMICOLON);

5807         break;

5808       default:

5809         jj_la1[135] = jj_gen;

5810         jj_consume_token(-1);

5811         throw new ParseException();

5812       }

5813     } catch (Throwable jjte000) {

5814    if (jjtc000) {

5815      jjtree.clearNodeScope(jjtn000);

5816      jjtc000 = false;

5817    } else {

5818      jjtree.popNode();

5819    }

5820    if (jjte000 instanceof RuntimeException) {

5821      {if (true) throw (RuntimeException)jjte000;}

5822    }

5823    if (jjte000 instanceof ParseException) {

5824      {if (true) throw (ParseException)jjte000;}

5825    }

5826    {if (true) throw (Error)jjte000;}

5827     } finally {

5828    if (jjtc000) {

5829      jjtree.closeNodeScope(jjtn000, true);

5830    }

5831     }

5832   }

5833 

5834   final public void AnnotationMethodDeclaration(int modifiers) throws ParseException {

5835  /*@bgen(jjtree) AnnotationMethodDeclaration */

5836   ASTAnnotationMethodDeclaration jjtn000 = new ASTAnnotationMethodDeclaration(this, JJTANNOTATIONMETHODDECLARATION);

5837   boolean jjtc000 = true;

5838   jjtree.openNodeScope(jjtn000);Token t;

5839   jjtn000.setModifiers(modifiers);

5840     try {

5841       Type();

5842       t = jj_consume_token(IDENTIFIER);

5843       jj_consume_token(LPAREN);

5844       jj_consume_token(RPAREN);

5845       switch (jj_nt.kind) {

5846       case _DEFAULT:

5847         DefaultValue();

5848         break;

5849       default:

5850         jj_la1[136] = jj_gen;

5851         ;

5852       }

5853       jj_consume_token(SEMICOLON);

5854     jjtree.closeNodeScope(jjtn000, true);

5855     jjtc000 = false;

5856     jjtn000.setImage(t.image);

5857     } catch (Throwable jjte000) {

5858     if (jjtc000) {

5859       jjtree.clearNodeScope(jjtn000);

5860       jjtc000 = false;

5861     } else {

5862       jjtree.popNode();

5863     }

5864     if (jjte000 instanceof RuntimeException) {

5865       {if (true) throw (RuntimeException)jjte000;}

5866     }

5867     if (jjte000 instanceof ParseException) {

5868       {if (true) throw (ParseException)jjte000;}

5869     }

5870     {if (true) throw (Error)jjte000;}

5871     } finally {

5872     if (jjtc000) {

5873       jjtree.closeNodeScope(jjtn000, true);

5874     }

5875     }

5876   }

5877 

5878   final public void DefaultValue() throws ParseException {

5879  /*@bgen(jjtree) DefaultValue */

5880   ASTDefaultValue jjtn000 = new ASTDefaultValue(this, JJTDEFAULTVALUE);

5881   boolean jjtc000 = true;

5882   jjtree.openNodeScope(jjtn000);

5883     try {

5884       jj_consume_token(_DEFAULT);

5885       MemberValue();

5886     } catch (Throwable jjte000) {

5887     if (jjtc000) {

5888       jjtree.clearNodeScope(jjtn000);

5889       jjtc000 = false;

5890     } else {

5891       jjtree.popNode();

5892     }

5893     if (jjte000 instanceof RuntimeException) {

5894       {if (true) throw (RuntimeException)jjte000;}

5895     }

5896     if (jjte000 instanceof ParseException) {

5897       {if (true) throw (ParseException)jjte000;}

5898     }

5899     {if (true) throw (Error)jjte000;}

5900     } finally {

5901     if (jjtc000) {

5902       jjtree.closeNodeScope(jjtn000, true);

5903     }

5904     }

5905   }

5906 

5907   private boolean jj_2_1(int xla) {

5908     jj_la = xla; jj_lastpos = jj_scanpos = token;

5909     try { return !jj_3_1(); }

5910     catch(LookaheadSuccess ls) { return true; }

5911     finally { jj_save(0, xla); }

5912   }

5913 

5914   private boolean jj_2_2(int xla) {

5915     jj_la = xla; jj_lastpos = jj_scanpos = token;

5916     try { return !jj_3_2(); }

5917     catch(LookaheadSuccess ls) { return true; }

5918     finally { jj_save(1, xla); }

5919   }

5920 

5921   private boolean jj_2_3(int xla) {

5922     jj_la = xla; jj_lastpos = jj_scanpos = token;

5923     try { return !jj_3_3(); }

5924     catch(LookaheadSuccess ls) { return true; }

5925     finally { jj_save(2, xla); }

5926   }

5927 

5928   private boolean jj_2_4(int xla) {

5929     jj_la = xla; jj_lastpos = jj_scanpos = token;

5930     try { return !jj_3_4(); }

5931     catch(LookaheadSuccess ls) { return true; }

5932     finally { jj_save(3, xla); }

5933   }

5934 

5935   private boolean jj_2_5(int xla) {

5936     jj_la = xla; jj_lastpos = jj_scanpos = token;

5937     try { return !jj_3_5(); }

5938     catch(LookaheadSuccess ls) { return true; }

5939     finally { jj_save(4, xla); }

5940   }

5941 

5942   private boolean jj_2_6(int xla) {

5943     jj_la = xla; jj_lastpos = jj_scanpos = token;

5944     try { return !jj_3_6(); }

5945     catch(LookaheadSuccess ls) { return true; }

5946     finally { jj_save(5, xla); }

5947   }

5948 

5949   private boolean jj_2_7(int xla) {

5950     jj_la = xla; jj_lastpos = jj_scanpos = token;

5951     try { return !jj_3_7(); }

5952     catch(LookaheadSuccess ls) { return true; }

5953     finally { jj_save(6, xla); }

5954   }

5955 

5956   private boolean jj_2_8(int xla) {

5957     jj_la = xla; jj_lastpos = jj_scanpos = token;

5958     try { return !jj_3_8(); }

5959     catch(LookaheadSuccess ls) { return true; }

5960     finally { jj_save(7, xla); }

5961   }

5962 

5963   private boolean jj_2_9(int xla) {

5964     jj_la = xla; jj_lastpos = jj_scanpos = token;

5965     try { return !jj_3_9(); }

5966     catch(LookaheadSuccess ls) { return true; }

5967     finally { jj_save(8, xla); }

5968   }

5969 

5970   private boolean jj_2_10(int xla) {

5971     jj_la = xla; jj_lastpos = jj_scanpos = token;

5972     try { return !jj_3_10(); }

5973     catch(LookaheadSuccess ls) { return true; }

5974     finally { jj_save(9, xla); }

5975   }

5976 

5977   private boolean jj_2_11(int xla) {

5978     jj_la = xla; jj_lastpos = jj_scanpos = token;

5979     try { return !jj_3_11(); }

5980     catch(LookaheadSuccess ls) { return true; }

5981     finally { jj_save(10, xla); }

5982   }

5983 

5984   private boolean jj_2_12(int xla) {

5985     jj_la = xla; jj_lastpos = jj_scanpos = token;

5986     try { return !jj_3_12(); }

5987     catch(LookaheadSuccess ls) { return true; }

5988     finally { jj_save(11, xla); }

5989   }

5990 

5991   private boolean jj_2_13(int xla) {

5992     jj_la = xla; jj_lastpos = jj_scanpos = token;

5993     try { return !jj_3_13(); }

5994     catch(LookaheadSuccess ls) { return true; }

5995     finally { jj_save(12, xla); }

5996   }

5997 

5998   private boolean jj_2_14(int xla) {

5999     jj_la = xla; jj_lastpos = jj_scanpos = token;

6000     try { return !jj_3_14(); }

6001     catch(LookaheadSuccess ls) { return true; }

6002     finally { jj_save(13, xla); }

6003   }

6004 

6005   private boolean jj_2_15(int xla) {

6006     jj_la = xla; jj_lastpos = jj_scanpos = token;

6007     try { return !jj_3_15(); }

6008     catch(LookaheadSuccess ls) { return true; }

6009     finally { jj_save(14, xla); }

6010   }

6011 

6012   private boolean jj_2_16(int xla) {

6013     jj_la = xla; jj_lastpos = jj_scanpos = token;

6014     try { return !jj_3_16(); }

6015     catch(LookaheadSuccess ls) { return true; }

6016     finally { jj_save(15, xla); }

6017   }

6018 

6019   private boolean jj_2_17(int xla) {

6020     jj_la = xla; jj_lastpos = jj_scanpos = token;

6021     try { return !jj_3_17(); }

6022     catch(LookaheadSuccess ls) { return true; }

6023     finally { jj_save(16, xla); }

6024   }

6025 

6026   private boolean jj_2_18(int xla) {

6027     jj_la = xla; jj_lastpos = jj_scanpos = token;

6028     try { return !jj_3_18(); }

6029     catch(LookaheadSuccess ls) { return true; }

6030     finally { jj_save(17, xla); }

6031   }

6032 

6033   private boolean jj_2_19(int xla) {

6034     jj_la = xla; jj_lastpos = jj_scanpos = token;

6035     try { return !jj_3_19(); }

6036     catch(LookaheadSuccess ls) { return true; }

6037     finally { jj_save(18, xla); }

6038   }

6039 

6040   private boolean jj_2_20(int xla) {

6041     jj_la = xla; jj_lastpos = jj_scanpos = token;

6042     try { return !jj_3_20(); }

6043     catch(LookaheadSuccess ls) { return true; }

6044     finally { jj_save(19, xla); }

6045   }

6046 

6047   private boolean jj_2_21(int xla) {

6048     jj_la = xla; jj_lastpos = jj_scanpos = token;

6049     try { return !jj_3_21(); }

6050     catch(LookaheadSuccess ls) { return true; }

6051     finally { jj_save(20, xla); }

6052   }

6053 

6054   private boolean jj_2_22(int xla) {

6055     jj_la = xla; jj_lastpos = jj_scanpos = token;

6056     try { return !jj_3_22(); }

6057     catch(LookaheadSuccess ls) { return true; }

6058     finally { jj_save(21, xla); }

6059   }

6060 

6061   private boolean jj_2_23(int xla) {

6062     jj_la = xla; jj_lastpos = jj_scanpos = token;

6063     try { return !jj_3_23(); }

6064     catch(LookaheadSuccess ls) { return true; }

6065     finally { jj_save(22, xla); }

6066   }

6067 

6068   private boolean jj_2_24(int xla) {

6069     jj_la = xla; jj_lastpos = jj_scanpos = token;

6070     try { return !jj_3_24(); }

6071     catch(LookaheadSuccess ls) { return true; }

6072     finally { jj_save(23, xla); }

6073   }

6074 

6075   private boolean jj_2_25(int xla) {

6076     jj_la = xla; jj_lastpos = jj_scanpos = token;

6077     try { return !jj_3_25(); }

6078     catch(LookaheadSuccess ls) { return true; }

6079     finally { jj_save(24, xla); }

6080   }

6081 

6082   private boolean jj_2_26(int xla) {

6083     jj_la = xla; jj_lastpos = jj_scanpos = token;

6084     try { return !jj_3_26(); }

6085     catch(LookaheadSuccess ls) { return true; }

6086     finally { jj_save(25, xla); }

6087   }

6088 

6089   private boolean jj_2_27(int xla) {

6090     jj_la = xla; jj_lastpos = jj_scanpos = token;

6091     try { return !jj_3_27(); }

6092     catch(LookaheadSuccess ls) { return true; }

6093     finally { jj_save(26, xla); }

6094   }

6095 

6096   private boolean jj_2_28(int xla) {

6097     jj_la = xla; jj_lastpos = jj_scanpos = token;

6098     try { return !jj_3_28(); }

6099     catch(LookaheadSuccess ls) { return true; }

6100     finally { jj_save(27, xla); }

6101   }

6102 

6103   private boolean jj_2_29(int xla) {

6104     jj_la = xla; jj_lastpos = jj_scanpos = token;

6105     try { return !jj_3_29(); }

6106     catch(LookaheadSuccess ls) { return true; }

6107     finally { jj_save(28, xla); }

6108   }

6109 

6110   private boolean jj_2_30(int xla) {

6111     jj_la = xla; jj_lastpos = jj_scanpos = token;

6112     try { return !jj_3_30(); }

6113     catch(LookaheadSuccess ls) { return true; }

6114     finally { jj_save(29, xla); }

6115   }

6116 

6117   private boolean jj_2_31(int xla) {

6118     jj_la = xla; jj_lastpos = jj_scanpos = token;

6119     try { return !jj_3_31(); }

6120     catch(LookaheadSuccess ls) { return true; }

6121     finally { jj_save(30, xla); }

6122   }

6123 

6124   private boolean jj_2_32(int xla) {

6125     jj_la = xla; jj_lastpos = jj_scanpos = token;

6126     try { return !jj_3_32(); }

6127     catch(LookaheadSuccess ls) { return true; }

6128     finally { jj_save(31, xla); }

6129   }

6130 

6131   private boolean jj_2_33(int xla) {

6132     jj_la = xla; jj_lastpos = jj_scanpos = token;

6133     try { return !jj_3_33(); }

6134     catch(LookaheadSuccess ls) { return true; }

6135     finally { jj_save(32, xla); }

6136   }

6137 

6138   private boolean jj_2_34(int xla) {

6139     jj_la = xla; jj_lastpos = jj_scanpos = token;

6140     try { return !jj_3_34(); }

6141     catch(LookaheadSuccess ls) { return true; }

6142     finally { jj_save(33, xla); }

6143   }

6144 

6145   private boolean jj_2_35(int xla) {

6146     jj_la = xla; jj_lastpos = jj_scanpos = token;

6147     try { return !jj_3_35(); }

6148     catch(LookaheadSuccess ls) { return true; }

6149     finally { jj_save(34, xla); }

6150   }

6151 

6152   private boolean jj_2_36(int xla) {

6153     jj_la = xla; jj_lastpos = jj_scanpos = token;

6154     try { return !jj_3_36(); }

6155     catch(LookaheadSuccess ls) { return true; }

6156     finally { jj_save(35, xla); }

6157   }

6158 

6159   private boolean jj_2_37(int xla) {

6160     jj_la = xla; jj_lastpos = jj_scanpos = token;

6161     try { return !jj_3_37(); }

6162     catch(LookaheadSuccess ls) { return true; }

6163     finally { jj_save(36, xla); }

6164   }

6165 

6166   private boolean jj_2_38(int xla) {

6167     jj_la = xla; jj_lastpos = jj_scanpos = token;

6168     try { return !jj_3_38(); }

6169     catch(LookaheadSuccess ls) { return true; }

6170     finally { jj_save(37, xla); }

6171   }

6172 

6173   private boolean jj_2_39(int xla) {

6174     jj_la = xla; jj_lastpos = jj_scanpos = token;

6175     try { return !jj_3_39(); }

6176     catch(LookaheadSuccess ls) { return true; }

6177     finally { jj_save(38, xla); }

6178   }

6179 

6180   private boolean jj_2_40(int xla) {

6181     jj_la = xla; jj_lastpos = jj_scanpos = token;

6182     try { return !jj_3_40(); }

6183     catch(LookaheadSuccess ls) { return true; }

6184     finally { jj_save(39, xla); }

6185   }

6186 

6187   private boolean jj_2_41(int xla) {

6188     jj_la = xla; jj_lastpos = jj_scanpos = token;

6189     try { return !jj_3_41(); }

6190     catch(LookaheadSuccess ls) { return true; }

6191     finally { jj_save(40, xla); }

6192   }

6193 

6194   private boolean jj_2_42(int xla) {

6195     jj_la = xla; jj_lastpos = jj_scanpos = token;

6196     try { return !jj_3_42(); }

6197     catch(LookaheadSuccess ls) { return true; }

6198     finally { jj_save(41, xla); }

6199   }

6200 

6201   private boolean jj_2_43(int xla) {

6202     jj_la = xla; jj_lastpos = jj_scanpos = token;

6203     try { return !jj_3_43(); }

6204     catch(LookaheadSuccess ls) { return true; }

6205     finally { jj_save(42, xla); }

6206   }

6207 

6208   private boolean jj_2_44(int xla) {

6209     jj_la = xla; jj_lastpos = jj_scanpos = token;

6210     try { return !jj_3_44(); }

6211     catch(LookaheadSuccess ls) { return true; }

6212     finally { jj_save(43, xla); }

6213   }

6214 

6215   private boolean jj_2_45(int xla) {

6216     jj_la = xla; jj_lastpos = jj_scanpos = token;

6217     try { return !jj_3_45(); }

6218     catch(LookaheadSuccess ls) { return true; }

6219     finally { jj_save(44, xla); }

6220   }

6221 

6222   private boolean jj_2_46(int xla) {

6223     jj_la = xla; jj_lastpos = jj_scanpos = token;

6224     try { return !jj_3_46(); }

6225     catch(LookaheadSuccess ls) { return true; }

6226     finally { jj_save(45, xla); }

6227   }

6228 

6229   private boolean jj_2_47(int xla) {

6230     jj_la = xla; jj_lastpos = jj_scanpos = token;

6231     try { return !jj_3_47(); }

6232     catch(LookaheadSuccess ls) { return true; }

6233     finally { jj_save(46, xla); }

6234   }

6235 

6236   private boolean jj_2_48(int xla) {

6237     jj_la = xla; jj_lastpos = jj_scanpos = token;

6238     try { return !jj_3_48(); }

6239     catch(LookaheadSuccess ls) { return true; }

6240     finally { jj_save(47, xla); }

6241   }

6242 

6243   private boolean jj_2_49(int xla) {

6244     jj_la = xla; jj_lastpos = jj_scanpos = token;

6245     try { return !jj_3_49(); }

6246     catch(LookaheadSuccess ls) { return true; }

6247     finally { jj_save(48, xla); }

6248   }

6249 

6250   private boolean jj_2_50(int xla) {

6251     jj_la = xla; jj_lastpos = jj_scanpos = token;

6252     try { return !jj_3_50(); }

6253     catch(LookaheadSuccess ls) { return true; }

6254     finally { jj_save(49, xla); }

6255   }

6256 

6257   private boolean jj_2_51(int xla) {

6258     jj_la = xla; jj_lastpos = jj_scanpos = token;

6259     try { return !jj_3_51(); }

6260     catch(LookaheadSuccess ls) { return true; }

6261     finally { jj_save(50, xla); }

6262   }

6263 

6264   private boolean jj_3R_231() {

6265     if (jj_scan_token(HOOK)) return true;

6266     if (jj_3R_88()) return true;

6267     if (jj_scan_token(COLON)) return true;

6268     if (jj_3R_139()) return true;

6269     return false;

6270   }

6271 

6272   private boolean jj_3R_233() {

6273     if (jj_3R_254()) return true;

6274     Token xsp;

6275     while (true) {

6276       xsp = jj_scanpos;

6277       if (jj_3R_267()) { jj_scanpos = xsp; break; }

6278     }

6279     return false;

6280   }

6281 

6282   private boolean jj_3R_223() {

6283     if (jj_3R_233()) return true;

6284     Token xsp;

6285     while (true) {

6286       xsp = jj_scanpos;

6287       if (jj_3R_262()) { jj_scanpos = xsp; break; }

6288     }

6289     return false;

6290   }

6291 

6292   private boolean jj_3R_206() {

6293     if (jj_3R_223()) return true;

6294     Token xsp;

6295     while (true) {

6296       xsp = jj_scanpos;

6297       if (jj_3R_259()) { jj_scanpos = xsp; break; }

6298     }

6299     return false;

6300   }

6301 

6302   private boolean jj_3R_183() {

6303     if (jj_3R_206()) return true;

6304     Token xsp;

6305     while (true) {

6306       xsp = jj_scanpos;

6307       if (jj_3R_241()) { jj_scanpos = xsp; break; }

6308     }

6309     return false;

6310   }

6311 

6312   private boolean jj_3R_139() {

6313     if (jj_3R_183()) return true;

6314     Token xsp;

6315     xsp = jj_scanpos;

6316     if (jj_3R_231()) jj_scanpos = xsp;

6317     return false;

6318   }

6319 

6320   private boolean jj_3R_253() {

6321     if (jj_scan_token(ORASSIGN)) return true;

6322     return false;

6323   }

6324 

6325   private boolean jj_3R_252() {

6326     if (jj_scan_token(XORASSIGN)) return true;

6327     return false;

6328   }

6329 

6330   private boolean jj_3R_251() {

6331     if (jj_scan_token(ANDASSIGN)) return true;

6332     return false;

6333   }

6334 

6335   private boolean jj_3R_250() {

6336     if (jj_scan_token(RUNSIGNEDSHIFTASSIGN)) return true;

6337     return false;

6338   }

6339 

6340   private boolean jj_3R_249() {

6341     if (jj_scan_token(RSIGNEDSHIFTASSIGN)) return true;

6342     return false;

6343   }

6344 

6345   private boolean jj_3R_248() {

6346     if (jj_scan_token(LSHIFTASSIGN)) return true;

6347     return false;

6348   }

6349 

6350   private boolean jj_3R_247() {

6351     if (jj_scan_token(MINUSASSIGN)) return true;

6352     return false;

6353   }

6354 

6355   private boolean jj_3R_246() {

6356     if (jj_scan_token(PLUSASSIGN)) return true;

6357     return false;

6358   }

6359 

6360   private boolean jj_3R_245() {

6361     if (jj_scan_token(REMASSIGN)) return true;

6362     return false;

6363   }

6364 

6365   private boolean jj_3R_244() {

6366     if (jj_scan_token(SLASHASSIGN)) return true;

6367     return false;

6368   }

6369 

6370   private boolean jj_3R_243() {

6371     if (jj_scan_token(STARASSIGN)) return true;

6372     return false;

6373   }

6374 

6375   private boolean jj_3R_232() {

6376     Token xsp;

6377     xsp = jj_scanpos;

6378     if (jj_3R_242()) {

6379     jj_scanpos = xsp;

6380     if (jj_3R_243()) {

6381     jj_scanpos = xsp;

6382     if (jj_3R_244()) {

6383     jj_scanpos = xsp;

6384     if (jj_3R_245()) {

6385     jj_scanpos = xsp;

6386     if (jj_3R_246()) {

6387     jj_scanpos = xsp;

6388     if (jj_3R_247()) {

6389     jj_scanpos = xsp;

6390     if (jj_3R_248()) {

6391     jj_scanpos = xsp;

6392     if (jj_3R_249()) {

6393     jj_scanpos = xsp;

6394     if (jj_3R_250()) {

6395     jj_scanpos = xsp;

6396     if (jj_3R_251()) {

6397     jj_scanpos = xsp;

6398     if (jj_3R_252()) {

6399     jj_scanpos = xsp;

6400     if (jj_3R_253()) return true;

6401     }

6402     }

6403     }

6404     }

6405     }

6406     }

6407     }

6408     }

6409     }

6410     }

6411     }

6412     return false;

6413   }

6414 

6415   private boolean jj_3R_242() {

6416     if (jj_scan_token(ASSIGN)) return true;

6417     return false;

6418   }

6419 

6420   private boolean jj_3R_222() {

6421     if (jj_3R_232()) return true;

6422     if (jj_3R_88()) return true;

6423     return false;

6424   }

6425 

6426   private boolean jj_3R_88() {

6427     if (jj_3R_139()) return true;

6428     Token xsp;

6429     xsp = jj_scanpos;

6430     if (jj_3R_222()) jj_scanpos = xsp;

6431     return false;

6432   }

6433 

6434   private boolean jj_3R_332() {

6435     if (jj_scan_token(COMMA)) return true;

6436     if (jj_3R_95()) return true;

6437     return false;

6438   }

6439 

6440   private boolean jj_3R_317() {

6441     if (jj_3R_95()) return true;

6442     Token xsp;

6443     while (true) {

6444       xsp = jj_scanpos;

6445       if (jj_3R_332()) { jj_scanpos = xsp; break; }

6446     }

6447     return false;

6448   }

6449 

6450   private boolean jj_3_19() {

6451     if (jj_3R_78()) return true;

6452     return false;

6453   }

6454 

6455   private boolean jj_3_20() {

6456     if (jj_scan_token(DOT)) return true;

6457     if (jj_scan_token(IDENTIFIER)) return true;

6458     return false;

6459   }

6460 

6461   private boolean jj_3R_257() {

6462     if (jj_scan_token(COMMA)) return true;

6463     if (jj_3R_121()) return true;

6464     return false;

6465   }

6466 

6467   private boolean jj_3R_95() {

6468     if (jj_scan_token(IDENTIFIER)) return true;

6469     Token xsp;

6470     while (true) {

6471       xsp = jj_scanpos;

6472       if (jj_3_20()) { jj_scanpos = xsp; break; }

6473     }

6474     return false;

6475   }

6476 

6477   private boolean jj_3R_137() {

6478     if (jj_3R_70()) return true;

6479     return false;

6480   }

6481 

6482   private boolean jj_3R_85() {

6483     Token xsp;

6484     xsp = jj_scanpos;

6485     if (jj_scan_token(59)) {

6486     jj_scanpos = xsp;

6487     if (jj_3R_137()) return true;

6488     }

6489     return false;

6490   }

6491 

6492   private boolean jj_3R_133() {

6493     if (jj_scan_token(DOUBLE)) return true;

6494     return false;

6495   }

6496 

6497   private boolean jj_3R_132() {

6498     if (jj_scan_token(FLOAT)) return true;

6499     return false;

6500   }

6501 

6502   private boolean jj_3R_131() {

6503     if (jj_scan_token(LONG)) return true;

6504     return false;

6505   }

6506 

6507   private boolean jj_3R_130() {

6508     if (jj_scan_token(INT)) return true;

6509     return false;

6510   }

6511 

6512   private boolean jj_3R_129() {

6513     if (jj_scan_token(SHORT)) return true;

6514     return false;

6515   }

6516 

6517   private boolean jj_3R_128() {

6518     if (jj_scan_token(BYTE)) return true;

6519     return false;

6520   }

6521 

6522   private boolean jj_3R_127() {

6523     if (jj_scan_token(CHAR)) return true;

6524     return false;

6525   }

6526 

6527   private boolean jj_3R_126() {

6528     if (jj_scan_token(BOOLEAN)) return true;

6529     return false;

6530   }

6531 

6532   private boolean jj_3R_83() {

6533     Token xsp;

6534     xsp = jj_scanpos;

6535     if (jj_3R_126()) {

6536     jj_scanpos = xsp;

6537     if (jj_3R_127()) {

6538     jj_scanpos = xsp;

6539     if (jj_3R_128()) {

6540     jj_scanpos = xsp;

6541     if (jj_3R_129()) {

6542     jj_scanpos = xsp;

6543     if (jj_3R_130()) {

6544     jj_scanpos = xsp;

6545     if (jj_3R_131()) {

6546     jj_scanpos = xsp;

6547     if (jj_3R_132()) {

6548     jj_scanpos = xsp;

6549     if (jj_3R_133()) return true;

6550     }

6551     }

6552     }

6553     }

6554     }

6555     }

6556     }

6557     return false;

6558   }

6559 

6560   private boolean jj_3R_276() {

6561     if (jj_scan_token(SUPER)) return true;

6562     if (jj_3R_77()) return true;

6563     return false;

6564   }

6565 

6566   private boolean jj_3R_266() {

6567     if (jj_3R_270()) return true;

6568     return false;

6569   }

6570 

6571   private boolean jj_3R_270() {

6572     Token xsp;

6573     xsp = jj_scanpos;

6574     if (jj_3R_275()) {

6575     jj_scanpos = xsp;

6576     if (jj_3R_276()) return true;

6577     }

6578     return false;

6579   }

6580 

6581   private boolean jj_3R_275() {

6582     if (jj_scan_token(EXTENDS)) return true;

6583     if (jj_3R_77()) return true;

6584     return false;

6585   }

6586 

6587   private boolean jj_3_16() {

6588     if (jj_scan_token(LBRACKET)) return true;

6589     if (jj_scan_token(RBRACKET)) return true;

6590     return false;

6591   }

6592 

6593   private boolean jj_3R_181() {

6594     if (jj_scan_token(HOOK)) return true;

6595     Token xsp;

6596     xsp = jj_scanpos;

6597     if (jj_3R_266()) jj_scanpos = xsp;

6598     return false;

6599   }

6600 

6601   private boolean jj_3R_121() {

6602     Token xsp;

6603     xsp = jj_scanpos;

6604     if (jj_3R_180()) {

6605     jj_scanpos = xsp;

6606     if (jj_3R_181()) return true;

6607     }

6608     return false;

6609   }

6610 

6611   private boolean jj_3R_180() {

6612     if (jj_3R_77()) return true;

6613     return false;

6614   }

6615 

6616   private boolean jj_3R_78() {

6617     if (jj_scan_token(LT)) return true;

6618     if (jj_3R_121()) return true;

6619     Token xsp;

6620     while (true) {

6621       xsp = jj_scanpos;

6622       if (jj_3R_257()) { jj_scanpos = xsp; break; }

6623     }

6624     if (jj_scan_token(GT)) return true;

6625     return false;

6626   }

6627 

6628   private boolean jj_3_15() {

6629     if (jj_scan_token(LBRACKET)) return true;

6630     if (jj_scan_token(RBRACKET)) return true;

6631     return false;

6632   }

6633 

6634   private boolean jj_3_18() {

6635     if (jj_scan_token(DOT)) return true;

6636     if (jj_scan_token(IDENTIFIER)) return true;

6637     Token xsp;

6638     xsp = jj_scanpos;

6639     if (jj_3_19()) jj_scanpos = xsp;

6640     return false;

6641   }

6642 

6643   private boolean jj_3_17() {

6644     if (jj_3R_78()) return true;

6645     return false;

6646   }

6647 

6648   private boolean jj_3R_179() {

6649     if (jj_scan_token(IDENTIFIER)) return true;

6650     Token xsp;

6651     xsp = jj_scanpos;

6652     if (jj_3_17()) jj_scanpos = xsp;

6653     while (true) {

6654       xsp = jj_scanpos;

6655       if (jj_3_18()) { jj_scanpos = xsp; break; }

6656     }

6657     return false;

6658   }

6659 

6660   private boolean jj_3R_120() {

6661     if (jj_3R_179()) return true;

6662     Token xsp;

6663     while (true) {

6664       xsp = jj_scanpos;

6665       if (jj_3_16()) { jj_scanpos = xsp; break; }

6666     }

6667     return false;

6668   }

6669 

6670   private boolean jj_3R_119() {

6671     if (jj_3R_83()) return true;

6672     Token xsp;

6673     if (jj_3_15()) return true;

6674     while (true) {

6675       xsp = jj_scanpos;

6676       if (jj_3_15()) { jj_scanpos = xsp; break; }

6677     }

6678     return false;

6679   }

6680 

6681   private boolean jj_3R_77() {

6682     Token xsp;

6683     xsp = jj_scanpos;

6684     if (jj_3R_119()) {

6685     jj_scanpos = xsp;

6686     if (jj_3R_120()) return true;

6687     }

6688     return false;

6689   }

6690 

6691   private boolean jj_3R_297() {

6692     if (jj_scan_token(THROWS)) return true;

6693     if (jj_3R_317()) return true;

6694     return false;

6695   }

6696 

6697   private boolean jj_3R_109() {

6698     if (jj_3R_83()) return true;

6699     return false;

6700   }

6701 

6702   private boolean jj_3_14() {

6703     if (jj_3R_77()) return true;

6704     return false;

6705   }

6706 

6707   private boolean jj_3R_70() {

6708     Token xsp;

6709     xsp = jj_scanpos;

6710     if (jj_3_14()) {

6711     jj_scanpos = xsp;

6712     if (jj_3R_109()) return true;

6713     }

6714     return false;

6715   }

6716 

6717   private boolean jj_3R_355() {

6718     if (jj_3R_99()) return true;

6719     return false;

6720   }

6721 

6722   private boolean jj_3R_370() {

6723     if (jj_3R_378()) return true;

6724     return false;

6725   }

6726 

6727   private boolean jj_3R_288() {

6728     if (jj_scan_token(STATIC)) return true;

6729     return false;

6730   }

6731 

6732   private boolean jj_3_13() {

6733     if (jj_scan_token(THIS)) return true;

6734     if (jj_3R_76()) return true;

6735     if (jj_scan_token(SEMICOLON)) return true;

6736     return false;

6737   }

6738 

6739   private boolean jj_3R_279() {

6740     Token xsp;

6741     xsp = jj_scanpos;

6742     if (jj_3R_288()) jj_scanpos = xsp;

6743     if (jj_3R_184()) return true;

6744     return false;

6745   }

6746 

6747   private boolean jj_3_10() {

6748     if (jj_3R_73()) return true;

6749     return false;

6750   }

6751 

6752   private boolean jj_3_12() {

6753     if (jj_3R_75()) return true;

6754     if (jj_scan_token(DOT)) return true;

6755     if (jj_scan_token(SUPER)) return true;

6756     if (jj_scan_token(LPAREN)) return true;

6757     return false;

6758   }

6759 

6760   private boolean jj_3R_113() {

6761     Token xsp;

6762     xsp = jj_scanpos;

6763     if (jj_3_12()) jj_scanpos = xsp;

6764     xsp = jj_scanpos;

6765     if (jj_scan_token(50)) {

6766     jj_scanpos = xsp;

6767     if (jj_scan_token(53)) return true;

6768     }

6769     if (jj_3R_76()) return true;

6770     if (jj_scan_token(SEMICOLON)) return true;

6771     return false;

6772   }

6773 

6774   private boolean jj_3R_112() {

6775     if (jj_scan_token(THIS)) return true;

6776     if (jj_3R_76()) return true;

6777     if (jj_scan_token(SEMICOLON)) return true;

6778     return false;

6779   }

6780 

6781   private boolean jj_3R_73() {

6782     Token xsp;

6783     xsp = jj_scanpos;

6784     if (jj_3R_112()) {

6785     jj_scanpos = xsp;

6786     if (jj_3R_113()) return true;

6787     }

6788     return false;

6789   }

6790 

6791   private boolean jj_3R_331() {

6792     if (jj_scan_token(COMMA)) return true;

6793     if (jj_3R_330()) return true;

6794     return false;

6795   }

6796 

6797   private boolean jj_3_11() {

6798     if (jj_3R_74()) return true;

6799     return false;

6800   }

6801 

6802   private boolean jj_3R_298() {

6803     if (jj_3R_73()) return true;

6804     return false;

6805   }

6806 

6807   private boolean jj_3R_295() {

6808     if (jj_3R_108()) return true;

6809     return false;

6810   }

6811 

6812   private boolean jj_3R_289() {

6813     Token xsp;

6814     xsp = jj_scanpos;

6815     if (jj_3R_295()) jj_scanpos = xsp;

6816     if (jj_scan_token(IDENTIFIER)) return true;

6817     if (jj_3R_296()) return true;

6818     xsp = jj_scanpos;

6819     if (jj_3R_297()) jj_scanpos = xsp;

6820     if (jj_scan_token(LBRACE)) return true;

6821     xsp = jj_scanpos;

6822     if (jj_3R_298()) jj_scanpos = xsp;

6823     while (true) {

6824       xsp = jj_scanpos;

6825       if (jj_3_11()) { jj_scanpos = xsp; break; }

6826     }

6827     if (jj_scan_token(RBRACE)) return true;

6828     return false;

6829   }

6830 

6831   private boolean jj_3R_378() {

6832     if (jj_scan_token(_DEFAULT)) return true;

6833     if (jj_3R_97()) return true;

6834     return false;

6835   }

6836 

6837   private boolean jj_3R_320() {

6838     if (jj_scan_token(LBRACKET)) return true;

6839     if (jj_scan_token(RBRACKET)) return true;

6840     return false;

6841   }

6842 

6843   private boolean jj_3R_303() {

6844     if (jj_scan_token(THROWS)) return true;

6845     if (jj_3R_317()) return true;

6846     return false;

6847   }

6848 

6849   private boolean jj_3R_344() {

6850     if (jj_scan_token(ELLIPSIS)) return true;

6851     return false;

6852   }

6853 

6854   private boolean jj_3R_354() {

6855     if (jj_scan_token(FINAL)) return true;

6856     return false;

6857   }

6858 

6859   private boolean jj_3R_343() {

6860     Token xsp;

6861     xsp = jj_scanpos;

6862     if (jj_3R_354()) {

6863     jj_scanpos = xsp;

6864     if (jj_3R_355()) return true;

6865     }

6866     return false;

6867   }

6868 

6869   private boolean jj_3R_330() {

6870     Token xsp;

6871     while (true) {

6872       xsp = jj_scanpos;

6873       if (jj_3R_343()) { jj_scanpos = xsp; break; }

6874     }

6875     if (jj_3R_70()) return true;

6876     xsp = jj_scanpos;

6877     if (jj_3R_344()) jj_scanpos = xsp;

6878     if (jj_3R_318()) return true;

6879     return false;

6880   }

6881 

6882   private boolean jj_3R_98() {

6883     if (jj_3R_70()) return true;

6884     if (jj_scan_token(IDENTIFIER)) return true;

6885     if (jj_scan_token(LPAREN)) return true;

6886     if (jj_scan_token(RPAREN)) return true;

6887     Token xsp;

6888     xsp = jj_scanpos;

6889     if (jj_3R_370()) jj_scanpos = xsp;

6890     if (jj_scan_token(SEMICOLON)) return true;

6891     return false;

6892   }

6893 

6894   private boolean jj_3R_316() {

6895     if (jj_3R_330()) return true;

6896     Token xsp;

6897     while (true) {

6898       xsp = jj_scanpos;

6899       if (jj_3R_331()) { jj_scanpos = xsp; break; }

6900     }

6901     return false;

6902   }

6903 

6904   private boolean jj_3_9() {

6905     if (jj_scan_token(COMMA)) return true;

6906     if (jj_3R_72()) return true;

6907     return false;

6908   }

6909 

6910   private boolean jj_3R_296() {

6911     if (jj_scan_token(LPAREN)) return true;

6912     Token xsp;

6913     xsp = jj_scanpos;

6914     if (jj_3R_316()) jj_scanpos = xsp;

6915     if (jj_scan_token(RPAREN)) return true;

6916     return false;

6917   }

6918 

6919   private boolean jj_3R_358() {

6920     if (jj_3R_290()) return true;

6921     return false;

6922   }

6923 

6924   private boolean jj_3R_357() {

6925     if (jj_3R_292()) return true;

6926     return false;

6927   }

6928 

6929   private boolean jj_3_51() {

6930     if (jj_3R_68()) return true;

6931     return false;

6932   }

6933 

6934   private boolean jj_3R_356() {

6935     if (jj_3R_67()) return true;

6936     return false;

6937   }

6938 

6939   private boolean jj_3_50() {

6940     if (jj_3R_98()) return true;

6941     return false;

6942   }

6943 

6944   private boolean jj_3R_302() {

6945     if (jj_scan_token(IDENTIFIER)) return true;

6946     if (jj_3R_296()) return true;

6947     Token xsp;

6948     while (true) {

6949       xsp = jj_scanpos;

6950       if (jj_3R_320()) { jj_scanpos = xsp; break; }

6951     }

6952     return false;

6953   }

6954 

6955   private boolean jj_3R_345() {

6956     if (jj_3R_94()) return true;

6957     Token xsp;

6958     xsp = jj_scanpos;

6959     if (jj_3_50()) {

6960     jj_scanpos = xsp;

6961     if (jj_3R_356()) {

6962     jj_scanpos = xsp;

6963     if (jj_3_51()) {

6964     jj_scanpos = xsp;

6965     if (jj_3R_357()) {

6966     jj_scanpos = xsp;

6967     if (jj_3R_358()) return true;

6968     }

6969     }

6970     }

6971     }

6972     return false;

6973   }

6974 

6975   private boolean jj_3R_334() {

6976     Token xsp;

6977     xsp = jj_scanpos;

6978     if (jj_3R_345()) {

6979     jj_scanpos = xsp;

6980     if (jj_scan_token(81)) return true;

6981     }

6982     return false;

6983   }

6984 

6985   private boolean jj_3R_321() {

6986     if (jj_3R_334()) return true;

6987     return false;

6988   }

6989 

6990   private boolean jj_3R_304() {

6991     if (jj_3R_184()) return true;

6992     return false;

6993   }

6994 

6995   private boolean jj_3R_301() {

6996     if (jj_3R_108()) return true;

6997     return false;

6998   }

6999 

7000   private boolean jj_3_49() {

7001     if (jj_scan_token(COMMA)) return true;

7002     if (jj_3R_97()) return true;

7003     return false;

7004   }

7005 

7006   private boolean jj_3R_291() {

7007     Token xsp;

7008     xsp = jj_scanpos;

7009     if (jj_3R_301()) jj_scanpos = xsp;

7010     if (jj_3R_85()) return true;

7011     if (jj_3R_302()) return true;

7012     xsp = jj_scanpos;

7013     if (jj_3R_303()) jj_scanpos = xsp;

7014     xsp = jj_scanpos;

7015     if (jj_3R_304()) {

7016     jj_scanpos = xsp;

7017     if (jj_scan_token(81)) return true;

7018     }

7019     return false;

7020   }

7021 

7022   private boolean jj_3R_264() {

7023     if (jj_3R_72()) return true;

7024     Token xsp;

7025     while (true) {

7026       xsp = jj_scanpos;

7027       if (jj_3_9()) { jj_scanpos = xsp; break; }

7028     }

7029     return false;

7030   }

7031 

7032   private boolean jj_3R_305() {

7033     if (jj_scan_token(LBRACE)) return true;

7034     Token xsp;

7035     while (true) {

7036       xsp = jj_scanpos;

7037       if (jj_3R_321()) { jj_scanpos = xsp; break; }

7038     }

7039     if (jj_scan_token(RBRACE)) return true;

7040     return false;

7041   }

7042 

7043   private boolean jj_3R_319() {

7044     if (jj_scan_token(ASSIGN)) return true;

7045     if (jj_3R_72()) return true;

7046     return false;

7047   }

7048 

7049   private boolean jj_3R_167() {

7050     if (jj_scan_token(LBRACE)) return true;

7051     Token xsp;

7052     xsp = jj_scanpos;

7053     if (jj_3R_264()) jj_scanpos = xsp;

7054     xsp = jj_scanpos;

7055     if (jj_scan_token(82)) jj_scanpos = xsp;

7056     if (jj_scan_token(RBRACE)) return true;

7057     return false;

7058   }

7059 

7060   private boolean jj_3R_300() {

7061     if (jj_scan_token(COMMA)) return true;

7062     if (jj_3R_299()) return true;

7063     return false;

7064   }

7065 

7066   private boolean jj_3R_292() {

7067     if (jj_scan_token(AT)) return true;

7068     if (jj_scan_token(INTERFACE)) return true;

7069     if (jj_scan_token(IDENTIFIER)) return true;

7070     if (jj_3R_305()) return true;

7071     return false;

7072   }

7073 

7074   private boolean jj_3R_71() {

7075     if (jj_scan_token(LBRACKET)) return true;

7076     if (jj_scan_token(RBRACKET)) return true;

7077     return false;

7078   }

7079 

7080   private boolean jj_3R_111() {

7081     if (jj_3R_88()) return true;

7082     return false;

7083   }

7084 

7085   private boolean jj_3R_110() {

7086     if (jj_3R_167()) return true;

7087     return false;

7088   }

7089 

7090   private boolean jj_3R_72() {

7091     Token xsp;

7092     xsp = jj_scanpos;

7093     if (jj_3R_110()) {

7094     jj_scanpos = xsp;

7095     if (jj_3R_111()) return true;

7096     }

7097     return false;

7098   }

7099 

7100   private boolean jj_3R_258() {

7101     if (jj_3R_97()) return true;

7102     Token xsp;

7103     while (true) {

7104       xsp = jj_scanpos;

7105       if (jj_3_49()) { jj_scanpos = xsp; break; }

7106     }

7107     xsp = jj_scanpos;

7108     if (jj_scan_token(82)) jj_scanpos = xsp;

7109     return false;

7110   }

7111 

7112   private boolean jj_3R_198() {

7113     if (jj_scan_token(LBRACE)) return true;

7114     Token xsp;

7115     xsp = jj_scanpos;

7116     if (jj_3R_258()) jj_scanpos = xsp;

7117     if (jj_scan_token(RBRACE)) return true;

7118     return false;

7119   }

7120 

7121   private boolean jj_3R_239() {

7122     if (jj_scan_token(COMMA)) return true;

7123     if (jj_3R_238()) return true;

7124     return false;

7125   }

7126 

7127   private boolean jj_3R_342() {

7128     if (jj_3R_105()) return true;

7129     return false;

7130   }

7131 

7132   private boolean jj_3R_333() {

7133     if (jj_scan_token(LBRACKET)) return true;

7134     if (jj_scan_token(RBRACKET)) return true;

7135     return false;

7136   }

7137 

7138   private boolean jj_3R_158() {

7139     if (jj_3R_139()) return true;

7140     return false;

7141   }

7142 

7143   private boolean jj_3R_318() {

7144     if (jj_scan_token(IDENTIFIER)) return true;

7145     Token xsp;

7146     while (true) {

7147       xsp = jj_scanpos;

7148       if (jj_3R_333()) { jj_scanpos = xsp; break; }

7149     }

7150     return false;

7151   }

7152 

7153   private boolean jj_3R_166() {

7154     if (jj_scan_token(COMMA)) return true;

7155     if (jj_3R_165()) return true;

7156     return false;

7157   }

7158 

7159   private boolean jj_3R_202() {

7160     if (jj_3R_212()) return true;

7161     return false;

7162   }

7163 

7164   private boolean jj_3R_157() {

7165     if (jj_3R_198()) return true;

7166     return false;

7167   }

7168 

7169   private boolean jj_3R_97() {

7170     Token xsp;

7171     xsp = jj_scanpos;

7172     if (jj_3R_156()) {

7173     jj_scanpos = xsp;

7174     if (jj_3R_157()) {

7175     jj_scanpos = xsp;

7176     if (jj_3R_158()) return true;

7177     }

7178     }

7179     return false;

7180   }

7181 

7182   private boolean jj_3R_156() {

7183     if (jj_3R_99()) return true;

7184     return false;

7185   }

7186 

7187   private boolean jj_3R_228() {

7188     if (jj_scan_token(BIT_AND)) return true;

7189     if (jj_3R_179()) return true;

7190     return false;

7191   }

7192 

7193   private boolean jj_3R_299() {

7194     if (jj_3R_318()) return true;

7195     Token xsp;

7196     xsp = jj_scanpos;

7197     if (jj_3R_319()) jj_scanpos = xsp;

7198     return false;

7199   }

7200 

7201   private boolean jj_3R_69() {

7202     if (jj_3R_108()) return true;

7203     return false;

7204   }

7205 

7206   private boolean jj_3_7() {

7207     if (jj_3R_70()) return true;

7208     if (jj_scan_token(IDENTIFIER)) return true;

7209     Token xsp;

7210     while (true) {

7211       xsp = jj_scanpos;

7212       if (jj_3R_71()) { jj_scanpos = xsp; break; }

7213     }

7214     xsp = jj_scanpos;

7215     if (jj_scan_token(82)) {

7216     jj_scanpos = xsp;

7217     if (jj_scan_token(85)) {

7218     jj_scanpos = xsp;

7219     if (jj_scan_token(81)) return true;

7220     }

7221     }

7222     return false;

7223   }

7224 

7225   private boolean jj_3R_238() {

7226     if (jj_scan_token(IDENTIFIER)) return true;

7227     if (jj_scan_token(ASSIGN)) return true;

7228     if (jj_3R_97()) return true;

7229     return false;

7230   }

7231 

7232   private boolean jj_3_6() {

7233     Token xsp;

7234     xsp = jj_scanpos;

7235     if (jj_3R_69()) jj_scanpos = xsp;

7236     if (jj_scan_token(IDENTIFIER)) return true;

7237     if (jj_scan_token(LPAREN)) return true;

7238     return false;

7239   }

7240 

7241   private boolean jj_3R_290() {

7242     if (jj_3R_70()) return true;

7243     if (jj_3R_299()) return true;

7244     Token xsp;

7245     while (true) {

7246       xsp = jj_scanpos;

7247       if (jj_3R_300()) { jj_scanpos = xsp; break; }

7248     }

7249     if (jj_scan_token(SEMICOLON)) return true;

7250     return false;

7251   }

7252 

7253   private boolean jj_3R_65() {

7254     if (jj_3R_99()) return true;

7255     return false;

7256   }

7257 

7258   private boolean jj_3R_341() {

7259     if (jj_3R_76()) return true;

7260     return false;

7261   }

7262 

7263   private boolean jj_3R_101() {

7264     if (jj_scan_token(INTERFACE)) return true;

7265     return false;

7266   }

7267 

7268   private boolean jj_3R_227() {

7269     if (jj_3R_238()) return true;

7270     Token xsp;

7271     while (true) {

7272       xsp = jj_scanpos;

7273       if (jj_3R_239()) { jj_scanpos = xsp; break; }

7274     }

7275     return false;

7276   }

7277 

7278   private boolean jj_3R_211() {

7279     if (jj_3R_227()) return true;

7280     return false;

7281   }

7282 

7283   private boolean jj_3R_283() {

7284     if (jj_3R_292()) return true;

7285     return false;

7286   }

7287 

7288   private boolean jj_3R_96() {

7289     if (jj_scan_token(IDENTIFIER)) return true;

7290     if (jj_scan_token(ASSIGN)) return true;

7291     return false;

7292   }

7293 

7294   private boolean jj_3_8() {

7295     Token xsp;

7296     xsp = jj_scanpos;

7297     if (jj_scan_token(49)) jj_scanpos = xsp;

7298     if (jj_scan_token(LBRACE)) return true;

7299     return false;

7300   }

7301 

7302   private boolean jj_3R_282() {

7303     if (jj_3R_291()) return true;

7304     return false;

7305   }

7306 

7307   private boolean jj_3R_281() {

7308     if (jj_3R_290()) return true;

7309     return false;

7310   }

7311 

7312   private boolean jj_3R_280() {

7313     if (jj_3R_289()) return true;

7314     return false;

7315   }

7316 

7317   private boolean jj_3_5() {

7318     if (jj_3R_68()) return true;

7319     return false;

7320   }

7321 

7322   private boolean jj_3R_200() {

7323     if (jj_scan_token(AT)) return true;

7324     if (jj_3R_95()) return true;

7325     if (jj_scan_token(LPAREN)) return true;

7326     if (jj_3R_97()) return true;

7327     if (jj_scan_token(RPAREN)) return true;

7328     return false;

7329   }

7330 

7331   private boolean jj_3_4() {

7332     if (jj_3R_67()) return true;

7333     return false;

7334   }

7335 

7336   private boolean jj_3R_274() {

7337     if (jj_3R_94()) return true;

7338     Token xsp;

7339     xsp = jj_scanpos;

7340     if (jj_3_4()) {

7341     jj_scanpos = xsp;

7342     if (jj_3_5()) {

7343     jj_scanpos = xsp;

7344     if (jj_3R_280()) {

7345     jj_scanpos = xsp;

7346     if (jj_3R_281()) {

7347     jj_scanpos = xsp;

7348     if (jj_3R_282()) {

7349     jj_scanpos = xsp;

7350     if (jj_3R_283()) return true;

7351     }

7352     }

7353     }

7354     }

7355     }

7356     return false;

7357   }

7358 

7359   private boolean jj_3R_269() {

7360     Token xsp;

7361     xsp = jj_scanpos;

7362     if (jj_3R_273()) {

7363     jj_scanpos = xsp;

7364     if (jj_3R_274()) {

7365     jj_scanpos = xsp;

7366     if (jj_scan_token(81)) return true;

7367     }

7368     }

7369     return false;

7370   }

7371 

7372   private boolean jj_3R_273() {

7373     if (jj_3R_279()) return true;

7374     return false;

7375   }

7376 

7377   private boolean jj_3R_201() {

7378     if (jj_scan_token(AT)) return true;

7379     if (jj_3R_95()) return true;

7380     return false;

7381   }

7382 

7383   private boolean jj_3R_265() {

7384     if (jj_3R_269()) return true;

7385     return false;

7386   }

7387 

7388   private boolean jj_3_3() {

7389     if (jj_scan_token(COMMA)) return true;

7390     Token xsp;

7391     while (true) {

7392       xsp = jj_scanpos;

7393       if (jj_3R_65()) { jj_scanpos = xsp; break; }

7394     }

7395     if (jj_3R_66()) return true;

7396     return false;

7397   }

7398 

7399   private boolean jj_3_48() {

7400     if (jj_scan_token(AT)) return true;

7401     if (jj_3R_95()) return true;

7402     if (jj_scan_token(LPAREN)) return true;

7403     return false;

7404   }

7405 

7406   private boolean jj_3R_199() {

7407     if (jj_scan_token(AT)) return true;

7408     if (jj_3R_95()) return true;

7409     if (jj_scan_token(LPAREN)) return true;

7410     Token xsp;

7411     xsp = jj_scanpos;

7412     if (jj_3R_211()) jj_scanpos = xsp;

7413     if (jj_scan_token(RPAREN)) return true;

7414     return false;

7415   }

7416 

7417   private boolean jj_3_47() {

7418     if (jj_scan_token(AT)) return true;

7419     if (jj_3R_95()) return true;

7420     if (jj_scan_token(LPAREN)) return true;

7421     Token xsp;

7422     xsp = jj_scanpos;

7423     if (jj_3R_96()) {

7424     jj_scanpos = xsp;

7425     if (jj_scan_token(76)) return true;

7426     }

7427     return false;

7428   }

7429 

7430   private boolean jj_3R_105() {

7431     if (jj_scan_token(LBRACE)) return true;

7432     Token xsp;

7433     while (true) {

7434       xsp = jj_scanpos;

7435       if (jj_3R_265()) { jj_scanpos = xsp; break; }

7436     }

7437     if (jj_scan_token(RBRACE)) return true;

7438     return false;

7439   }

7440 

7441   private boolean jj_3R_161() {

7442     if (jj_3R_201()) return true;

7443     return false;

7444   }

7445 

7446   private boolean jj_3R_212() {

7447     if (jj_scan_token(EXTENDS)) return true;

7448     if (jj_3R_179()) return true;

7449     Token xsp;

7450     while (true) {

7451       xsp = jj_scanpos;

7452       if (jj_3R_228()) { jj_scanpos = xsp; break; }

7453     }

7454     return false;

7455   }

7456 

7457   private boolean jj_3R_160() {

7458     if (jj_3R_200()) return true;

7459     return false;

7460   }

7461 

7462   private boolean jj_3R_162() {

7463     Token xsp;

7464     xsp = jj_scanpos;

7465     if (jj_scan_token(28)) {

7466     jj_scanpos = xsp;

7467     if (jj_scan_token(12)) return true;

7468     }

7469     return false;

7470   }

7471 

7472   private boolean jj_3R_122() {

7473     return false;

7474   }

7475 

7476   private boolean jj_3R_99() {

7477     Token xsp;

7478     xsp = jj_scanpos;

7479     if (jj_3R_159()) {

7480     jj_scanpos = xsp;

7481     if (jj_3R_160()) {

7482     jj_scanpos = xsp;

7483     if (jj_3R_161()) return true;

7484     }

7485     }

7486     return false;

7487   }

7488 

7489   private boolean jj_3R_159() {

7490     if (jj_3R_199()) return true;

7491     return false;

7492   }

7493 

7494   private boolean jj_3R_100() {

7495     Token xsp;

7496     xsp = jj_scanpos;

7497     if (jj_3R_162()) jj_scanpos = xsp;

7498     if (jj_scan_token(CLASS)) return true;

7499     return false;

7500   }

7501 

7502   private boolean jj_3R_165() {

7503     if (jj_scan_token(IDENTIFIER)) return true;

7504     Token xsp;

7505     xsp = jj_scanpos;

7506     if (jj_3R_202()) jj_scanpos = xsp;

7507     return false;

7508   }

7509 

7510   private boolean jj_3R_352() {

7511     if (jj_scan_token(COLON)) return true;

7512     if (jj_3R_88()) return true;

7513     return false;

7514   }

7515 

7516   private boolean jj_3R_108() {

7517     if (jj_scan_token(LT)) return true;

7518     if (jj_3R_165()) return true;

7519     Token xsp;

7520     while (true) {

7521       xsp = jj_scanpos;

7522       if (jj_3R_166()) { jj_scanpos = xsp; break; }

7523     }

7524     if (jj_scan_token(GT)) return true;

7525     return false;

7526   }

7527 

7528   private boolean jj_3R_123() {

7529     return false;

7530   }

7531 

7532   private boolean jj_3R_329() {

7533     if (jj_3R_269()) return true;

7534     return false;

7535   }

7536 

7537   private boolean jj_3R_80() {

7538     jj_lookingAhead = true;

7539     jj_semLA = getToken(1).kind == GT &&

7540                 ((Token.GTToken)getToken(1)).realKind == RSIGNEDSHIFT;

7541     jj_lookingAhead = false;

7542     if (!jj_semLA || jj_3R_122()) return true;

7543     if (jj_scan_token(GT)) return true;

7544     if (jj_scan_token(GT)) return true;

7545     return false;

7546   }

7547 

7548   private boolean jj_3R_66() {

7549     if (jj_scan_token(IDENTIFIER)) return true;

7550     Token xsp;

7551     xsp = jj_scanpos;

7552     if (jj_3R_341()) jj_scanpos = xsp;

7553     xsp = jj_scanpos;

7554     if (jj_3R_342()) jj_scanpos = xsp;

7555     return false;

7556   }

7557 

7558   private boolean jj_3R_315() {

7559     if (jj_scan_token(SEMICOLON)) return true;

7560     Token xsp;

7561     while (true) {

7562       xsp = jj_scanpos;

7563       if (jj_3R_329()) { jj_scanpos = xsp; break; }

7564     }

7565     return false;

7566   }

7567 

7568   private boolean jj_3R_328() {

7569     if (jj_3R_99()) return true;

7570     return false;

7571   }

7572 

7573   private boolean jj_3R_314() {

7574     Token xsp;

7575     while (true) {

7576       xsp = jj_scanpos;

7577       if (jj_3R_328()) { jj_scanpos = xsp; break; }

7578     }

7579     if (jj_3R_66()) return true;

7580     while (true) {

7581       xsp = jj_scanpos;

7582       if (jj_3_3()) { jj_scanpos = xsp; break; }

7583     }

7584     return false;

7585   }

7586 

7587   private boolean jj_3R_81() {

7588     jj_lookingAhead = true;

7589     jj_semLA = getToken(1).kind == GT &&

7590                 ((Token.GTToken)getToken(1)).realKind == RUNSIGNEDSHIFT;

7591     jj_lookingAhead = false;

7592     if (!jj_semLA || jj_3R_123()) return true;

7593     if (jj_scan_token(GT)) return true;

7594     if (jj_scan_token(GT)) return true;

7595     if (jj_scan_token(GT)) return true;

7596     return false;

7597   }

7598 

7599   private boolean jj_3R_107() {

7600     if (jj_scan_token(LBRACE)) return true;

7601     Token xsp;

7602     xsp = jj_scanpos;

7603     if (jj_3R_314()) jj_scanpos = xsp;

7604     xsp = jj_scanpos;

7605     if (jj_scan_token(82)) jj_scanpos = xsp;

7606     xsp = jj_scanpos;

7607     if (jj_3R_315()) jj_scanpos = xsp;

7608     if (jj_scan_token(RBRACE)) return true;

7609     return false;

7610   }

7611 

7612   private boolean jj_3R_106() {

7613     if (jj_3R_164()) return true;

7614     return false;

7615   }

7616 

7617   private boolean jj_3R_168() {

7618     if (jj_scan_token(IDENTIFIER)) return true;

7619     if (jj_3R_88()) return true;

7620     Token xsp;

7621     xsp = jj_scanpos;

7622     if (jj_3R_352()) jj_scanpos = xsp;

7623     if (jj_scan_token(SEMICOLON)) return true;

7624     return false;

7625   }

7626 

7627   private boolean jj_3R_377() {

7628     if (jj_scan_token(FINALLY)) return true;

7629     if (jj_3R_184()) return true;

7630     return false;

7631   }

7632 

7633   private boolean jj_3R_68() {

7634     if (jj_scan_token(IDENTIFIER)) return true;

7635     if (jj_scan_token(IDENTIFIER)) return true;

7636     Token xsp;

7637     xsp = jj_scanpos;

7638     if (jj_3R_106()) jj_scanpos = xsp;

7639     if (jj_3R_107()) return true;

7640     return false;

7641   }

7642 

7643   private boolean jj_3R_327() {

7644     if (jj_scan_token(COMMA)) return true;

7645     if (jj_3R_179()) return true;

7646     return false;

7647   }

7648 

7649   private boolean jj_3R_376() {

7650     if (jj_scan_token(CATCH)) return true;

7651     if (jj_scan_token(LPAREN)) return true;

7652     if (jj_3R_330()) return true;

7653     if (jj_scan_token(RPAREN)) return true;

7654     if (jj_3R_184()) return true;

7655     return false;

7656   }

7657 

7658   private boolean jj_3R_164() {

7659     if (jj_scan_token(IMPLEMENTS)) return true;

7660     if (jj_3R_179()) return true;

7661     Token xsp;

7662     while (true) {

7663       xsp = jj_scanpos;

7664       if (jj_3R_327()) { jj_scanpos = xsp; break; }

7665     }

7666     return false;

7667   }

7668 

7669   private boolean jj_3R_369() {

7670     if (jj_3R_377()) return true;

7671     return false;

7672   }

7673 

7674   private boolean jj_3R_368() {

7675     if (jj_3R_376()) return true;

7676     return false;

7677   }

7678 

7679   private boolean jj_3R_326() {

7680     if (jj_scan_token(COMMA)) return true;

7681     if (jj_3R_179()) return true;

7682     return false;

7683   }

7684 

7685   private boolean jj_3R_163() {

7686     if (jj_scan_token(EXTENDS)) return true;

7687     if (jj_3R_179()) return true;

7688     Token xsp;

7689     while (true) {

7690       xsp = jj_scanpos;

7691       if (jj_3R_326()) { jj_scanpos = xsp; break; }

7692     }

7693     return false;

7694   }

7695 

7696   private boolean jj_3R_197() {

7697     if (jj_scan_token(TRY)) return true;

7698     if (jj_3R_184()) return true;

7699     Token xsp;

7700     while (true) {

7701       xsp = jj_scanpos;

7702       if (jj_3R_368()) { jj_scanpos = xsp; break; }

7703     }

7704     xsp = jj_scanpos;

7705     if (jj_3R_369()) jj_scanpos = xsp;

7706     return false;

7707   }

7708 

7709   private boolean jj_3R_104() {

7710     if (jj_3R_164()) return true;

7711     return false;

7712   }

7713 

7714   private boolean jj_3R_103() {

7715     if (jj_3R_163()) return true;

7716     return false;

7717   }

7718 

7719   private boolean jj_3R_102() {

7720     if (jj_3R_108()) return true;

7721     return false;

7722   }

7723 

7724   private boolean jj_3R_196() {

7725     if (jj_scan_token(SYNCHRONIZED)) return true;

7726     if (jj_scan_token(LPAREN)) return true;

7727     if (jj_3R_88()) return true;

7728     if (jj_scan_token(RPAREN)) return true;

7729     if (jj_3R_184()) return true;

7730     return false;

7731   }

7732 

7733   private boolean jj_3R_367() {

7734     if (jj_3R_88()) return true;

7735     return false;

7736   }

7737 

7738   private boolean jj_3R_366() {

7739     if (jj_scan_token(IDENTIFIER)) return true;

7740     return false;

7741   }

7742 

7743   private boolean jj_3R_67() {

7744     Token xsp;

7745     xsp = jj_scanpos;

7746     if (jj_3R_100()) {

7747     jj_scanpos = xsp;

7748     if (jj_3R_101()) return true;

7749     }

7750     if (jj_scan_token(IDENTIFIER)) return true;

7751     xsp = jj_scanpos;

7752     if (jj_3R_102()) jj_scanpos = xsp;

7753     xsp = jj_scanpos;

7754     if (jj_3R_103()) jj_scanpos = xsp;

7755     xsp = jj_scanpos;

7756     if (jj_3R_104()) jj_scanpos = xsp;

7757     if (jj_3R_105()) return true;

7758     return false;

7759   }

7760 

7761   private boolean jj_3R_195() {

7762     if (jj_scan_token(THROW)) return true;

7763     if (jj_3R_88()) return true;

7764     if (jj_scan_token(SEMICOLON)) return true;

7765     return false;

7766   }

7767 

7768   private boolean jj_3R_389() {

7769     if (jj_scan_token(COMMA)) return true;

7770     if (jj_3R_186()) return true;

7771     return false;

7772   }

7773 

7774   private boolean jj_3R_194() {

7775     if (jj_scan_token(RETURN)) return true;

7776     Token xsp;

7777     xsp = jj_scanpos;

7778     if (jj_3R_367()) jj_scanpos = xsp;

7779     if (jj_scan_token(SEMICOLON)) return true;

7780     return false;

7781   }

7782 

7783   private boolean jj_3R_365() {

7784     if (jj_scan_token(IDENTIFIER)) return true;

7785     return false;

7786   }

7787 

7788   private boolean jj_3R_193() {

7789     if (jj_scan_token(CONTINUE)) return true;

7790     Token xsp;

7791     xsp = jj_scanpos;

7792     if (jj_3R_366()) jj_scanpos = xsp;

7793     if (jj_scan_token(SEMICOLON)) return true;

7794     return false;

7795   }

7796 

7797   private boolean jj_3R_192() {

7798     if (jj_scan_token(BREAK)) return true;

7799     Token xsp;

7800     xsp = jj_scanpos;

7801     if (jj_3R_365()) jj_scanpos = xsp;

7802     if (jj_scan_token(SEMICOLON)) return true;

7803     return false;

7804   }

7805 

7806   private boolean jj_3R_383() {

7807     if (jj_3R_388()) return true;

7808     return false;

7809   }

7810 

7811   private boolean jj_3_46() {

7812     Token xsp;

7813     xsp = jj_scanpos;

7814     if (jj_scan_token(28)) jj_scanpos = xsp;

7815     if (jj_3R_70()) return true;

7816     if (jj_scan_token(IDENTIFIER)) return true;

7817     return false;

7818   }

7819 

7820   private boolean jj_3R_388() {

7821     if (jj_3R_186()) return true;

7822     Token xsp;

7823     while (true) {

7824       xsp = jj_scanpos;

7825       if (jj_3R_389()) { jj_scanpos = xsp; break; }

7826     }

7827     return false;

7828   }

7829 

7830   private boolean jj_3R_64() {

7831     if (jj_3R_99()) return true;

7832     return false;

7833   }

7834 

7835   private boolean jj_3R_63() {

7836     if (jj_scan_token(STRICTFP)) return true;

7837     return false;

7838   }

7839 

7840   private boolean jj_3R_62() {

7841     if (jj_scan_token(VOLATILE)) return true;

7842     return false;

7843   }

7844 

7845   private boolean jj_3R_362() {

7846     if (jj_scan_token(ELSE)) return true;

7847     if (jj_3R_91()) return true;

7848     return false;

7849   }

7850 

7851   private boolean jj_3R_61() {

7852     if (jj_scan_token(TRANSIENT)) return true;

7853     return false;

7854   }

7855 

7856   private boolean jj_3R_60() {

7857     if (jj_scan_token(NATIVE)) return true;

7858     return false;

7859   }

7860 

7861   private boolean jj_3R_387() {

7862     if (jj_3R_388()) return true;

7863     return false;

7864   }

7865 

7866   private boolean jj_3R_59() {

7867     if (jj_scan_token(SYNCHRONIZED)) return true;

7868     return false;

7869   }

7870 

7871   private boolean jj_3R_58() {

7872     if (jj_scan_token(ABSTRACT)) return true;

7873     return false;

7874   }

7875 

7876   private boolean jj_3R_57() {

7877     if (jj_scan_token(FINAL)) return true;

7878     return false;

7879   }

7880 

7881   private boolean jj_3R_386() {

7882     if (jj_3R_169()) return true;

7883     return false;

7884   }

7885 

7886   private boolean jj_3R_382() {

7887     Token xsp;

7888     xsp = jj_scanpos;

7889     if (jj_3R_386()) {

7890     jj_scanpos = xsp;

7891     if (jj_3R_387()) return true;

7892     }

7893     return false;

7894   }

7895 

7896   private boolean jj_3R_56() {

7897     if (jj_scan_token(PRIVATE)) return true;

7898     return false;

7899   }

7900 

7901   private boolean jj_3_45() {

7902     if (jj_3R_94()) return true;

7903     if (jj_3R_70()) return true;

7904     if (jj_scan_token(IDENTIFIER)) return true;

7905     if (jj_scan_token(COLON)) return true;

7906     return false;

7907   }

7908 

7909   private boolean jj_3R_55() {

7910     if (jj_scan_token(PROTECTED)) return true;

7911     return false;

7912   }

7913 

7914   private boolean jj_3R_54() {

7915     if (jj_scan_token(STATIC)) return true;

7916     return false;

7917   }

7918 

7919   private boolean jj_3R_53() {

7920     if (jj_scan_token(PUBLIC)) return true;

7921     return false;

7922   }

7923 

7924   private boolean jj_3R_375() {

7925     if (jj_3R_383()) return true;

7926     return false;

7927   }

7928 

7929   private boolean jj_3R_374() {

7930     if (jj_3R_88()) return true;

7931     return false;

7932   }

7933 

7934   private boolean jj_3_2() {

7935     Token xsp;

7936     xsp = jj_scanpos;

7937     if (jj_3R_53()) {

7938     jj_scanpos = xsp;

7939     if (jj_3R_54()) {

7940     jj_scanpos = xsp;

7941     if (jj_3R_55()) {

7942     jj_scanpos = xsp;

7943     if (jj_3R_56()) {

7944     jj_scanpos = xsp;

7945     if (jj_3R_57()) {

7946     jj_scanpos = xsp;

7947     if (jj_3R_58()) {

7948     jj_scanpos = xsp;

7949     if (jj_3R_59()) {

7950     jj_scanpos = xsp;

7951     if (jj_3R_60()) {

7952     jj_scanpos = xsp;

7953     if (jj_3R_61()) {

7954     jj_scanpos = xsp;

7955     if (jj_3R_62()) {

7956     jj_scanpos = xsp;

7957     if (jj_3R_63()) {

7958     jj_scanpos = xsp;

7959     if (jj_3R_64()) return true;

7960     }

7961     }

7962     }

7963     }

7964     }

7965     }

7966     }

7967     }

7968     }

7969     }

7970     }

7971     return false;

7972   }

7973 

7974   private boolean jj_3R_373() {

7975     if (jj_3R_382()) return true;

7976     return false;

7977   }

7978 

7979   private boolean jj_3R_94() {

7980     Token xsp;

7981     while (true) {

7982       xsp = jj_scanpos;

7983       if (jj_3_2()) { jj_scanpos = xsp; break; }

7984     }

7985     return false;

7986   }

7987 

7988   private boolean jj_3R_364() {

7989     Token xsp;

7990     xsp = jj_scanpos;

7991     if (jj_3R_373()) jj_scanpos = xsp;

7992     if (jj_scan_token(SEMICOLON)) return true;

7993     xsp = jj_scanpos;

7994     if (jj_3R_374()) jj_scanpos = xsp;

7995     if (jj_scan_token(SEMICOLON)) return true;

7996     xsp = jj_scanpos;

7997     if (jj_3R_375()) jj_scanpos = xsp;

7998     return false;

7999   }

8000 

8001   private boolean jj_3R_363() {

8002     if (jj_3R_94()) return true;

8003     if (jj_3R_70()) return true;

8004     if (jj_scan_token(IDENTIFIER)) return true;

8005     if (jj_scan_token(COLON)) return true;

8006     if (jj_3R_88()) return true;

8007     return false;

8008   }

8009 

8010   private boolean jj_3R_191() {

8011     if (jj_scan_token(FOR)) return true;

8012     if (jj_scan_token(LPAREN)) return true;

8013     Token xsp;

8014     xsp = jj_scanpos;

8015     if (jj_3R_363()) {

8016     jj_scanpos = xsp;

8017     if (jj_3R_364()) return true;

8018     }

8019     if (jj_scan_token(RPAREN)) return true;

8020     if (jj_3R_91()) return true;

8021     return false;

8022   }

8023 

8024   private boolean jj_3R_190() {

8025     if (jj_scan_token(DO)) return true;

8026     if (jj_3R_91()) return true;

8027     if (jj_scan_token(WHILE)) return true;

8028     if (jj_scan_token(LPAREN)) return true;

8029     if (jj_3R_88()) return true;

8030     if (jj_scan_token(RPAREN)) return true;

8031     if (jj_scan_token(SEMICOLON)) return true;

8032     return false;

8033   }

8034 

8035   private boolean jj_3R_52() {

8036     if (jj_3R_99()) return true;

8037     return false;

8038   }

8039 

8040   private boolean jj_3R_189() {

8041     if (jj_scan_token(WHILE)) return true;

8042     if (jj_scan_token(LPAREN)) return true;

8043     if (jj_3R_88()) return true;

8044     if (jj_scan_token(RPAREN)) return true;

8045     if (jj_3R_91()) return true;

8046     return false;

8047   }

8048 

8049   private boolean jj_3_1() {

8050     Token xsp;

8051     while (true) {

8052       xsp = jj_scanpos;

8053       if (jj_3R_52()) { jj_scanpos = xsp; break; }

8054     }

8055     if (jj_scan_token(PACKAGE)) return true;

8056     return false;

8057   }

8058 

8059   private boolean jj_3_44() {

8060     if (jj_3R_74()) return true;

8061     return false;

8062   }

8063 

8064   private boolean jj_3R_170() {

8065     if (jj_3R_99()) return true;

8066     return false;

8067   }

8068 

8069   private boolean jj_3R_188() {

8070     if (jj_scan_token(IF)) return true;

8071     if (jj_scan_token(LPAREN)) return true;

8072     if (jj_3R_88()) return true;

8073     if (jj_scan_token(RPAREN)) return true;

8074     if (jj_3R_91()) return true;

8075     Token xsp;

8076     xsp = jj_scanpos;

8077     if (jj_3R_362()) jj_scanpos = xsp;

8078     return false;

8079   }

8080 

8081   private boolean jj_3R_381() {

8082     if (jj_scan_token(_DEFAULT)) return true;

8083     if (jj_scan_token(COLON)) return true;

8084     return false;

8085   }

8086 

8087   private boolean jj_3R_380() {

8088     if (jj_scan_token(CASE)) return true;

8089     if (jj_3R_88()) return true;

8090     if (jj_scan_token(COLON)) return true;

8091     return false;

8092   }

8093 

8094   private boolean jj_3R_372() {

8095     Token xsp;

8096     xsp = jj_scanpos;

8097     if (jj_3R_380()) {

8098     jj_scanpos = xsp;

8099     if (jj_3R_381()) return true;

8100     }

8101     return false;

8102   }

8103 

8104   private boolean jj_3R_214() {

8105     if (jj_3R_99()) return true;

8106     return false;

8107   }

8108 

8109   private boolean jj_3R_361() {

8110     if (jj_3R_372()) return true;

8111     Token xsp;

8112     while (true) {

8113       xsp = jj_scanpos;

8114       if (jj_3_44()) { jj_scanpos = xsp; break; }

8115     }

8116     return false;

8117   }

8118 

8119   private boolean jj_3_43() {

8120     if (jj_3R_75()) return true;

8121     Token xsp;

8122     xsp = jj_scanpos;

8123     if (jj_scan_token(97)) {

8124     jj_scanpos = xsp;

8125     if (jj_scan_token(98)) return true;

8126     }

8127     return false;

8128   }

8129 

8130   private boolean jj_3R_187() {

8131     if (jj_scan_token(SWITCH)) return true;

8132     if (jj_scan_token(LPAREN)) return true;

8133     if (jj_3R_88()) return true;

8134     if (jj_scan_token(RPAREN)) return true;

8135     if (jj_scan_token(LBRACE)) return true;

8136     Token xsp;

8137     while (true) {

8138       xsp = jj_scanpos;

8139       if (jj_3R_361()) { jj_scanpos = xsp; break; }

8140     }

8141     if (jj_scan_token(RBRACE)) return true;

8142     return false;

8143   }

8144 

8145   private boolean jj_3R_371() {

8146     if (jj_3R_232()) return true;

8147     if (jj_3R_88()) return true;

8148     return false;

8149   }

8150 

8151   private boolean jj_3R_93() {

8152     Token xsp;

8153     xsp = jj_scanpos;

8154     if (jj_scan_token(28)) {

8155     jj_scanpos = xsp;

8156     if (jj_scan_token(12)) return true;

8157     }

8158     return false;

8159   }

8160 

8161   private boolean jj_3R_210() {

8162     if (jj_3R_75()) return true;

8163     Token xsp;

8164     xsp = jj_scanpos;

8165     if (jj_3R_371()) jj_scanpos = xsp;

8166     return false;

8167   }

8168 

8169   private boolean jj_3R_209() {

8170     if (jj_3R_226()) return true;

8171     return false;

8172   }

8173 

8174   private boolean jj_3R_208() {

8175     if (jj_3R_225()) return true;

8176     return false;

8177   }

8178 

8179   private boolean jj_3R_186() {

8180     Token xsp;

8181     xsp = jj_scanpos;

8182     if (jj_3R_207()) {

8183     jj_scanpos = xsp;

8184     if (jj_3R_208()) {

8185     jj_scanpos = xsp;

8186     if (jj_3R_209()) {

8187     jj_scanpos = xsp;

8188     if (jj_3R_210()) return true;

8189     }

8190     }

8191     }

8192     return false;

8193   }

8194 

8195   private boolean jj_3R_207() {

8196     if (jj_3R_224()) return true;

8197     return false;

8198   }

8199 

8200   private boolean jj_3R_185() {

8201     if (jj_scan_token(SEMICOLON)) return true;

8202     return false;

8203   }

8204 

8205   private boolean jj_3R_92() {

8206     if (jj_3R_99()) return true;

8207     return false;

8208   }

8209 

8210   private boolean jj_3R_353() {

8211     if (jj_scan_token(COMMA)) return true;

8212     if (jj_3R_299()) return true;

8213     return false;

8214   }

8215 

8216   private boolean jj_3R_140() {

8217     if (jj_3R_99()) return true;

8218     return false;

8219   }

8220 

8221   private boolean jj_3_42() {

8222     Token xsp;

8223     xsp = jj_scanpos;

8224     if (jj_3R_92()) jj_scanpos = xsp;

8225     xsp = jj_scanpos;

8226     if (jj_3R_93()) jj_scanpos = xsp;

8227     if (jj_scan_token(CLASS)) return true;

8228     return false;

8229   }

8230 

8231   private boolean jj_3R_203() {

8232     Token xsp;

8233     xsp = jj_scanpos;

8234     if (jj_3R_213()) {

8235     jj_scanpos = xsp;

8236     if (jj_3R_214()) return true;

8237     }

8238     return false;

8239   }

8240 

8241   private boolean jj_3R_213() {

8242     if (jj_scan_token(FINAL)) return true;

8243     return false;

8244   }

8245 

8246   private boolean jj_3R_169() {

8247     Token xsp;

8248     while (true) {

8249       xsp = jj_scanpos;

8250       if (jj_3R_203()) { jj_scanpos = xsp; break; }

8251     }

8252     if (jj_3R_70()) return true;

8253     if (jj_3R_299()) return true;

8254     while (true) {

8255       xsp = jj_scanpos;

8256       if (jj_3R_353()) { jj_scanpos = xsp; break; }

8257     }

8258     return false;

8259   }

8260 

8261   private boolean jj_3R_90() {

8262     Token xsp;

8263     xsp = jj_scanpos;

8264     if (jj_scan_token(28)) {

8265     jj_scanpos = xsp;

8266     if (jj_3R_140()) return true;

8267     }

8268     return false;

8269   }

8270 

8271   private boolean jj_3R_116() {

8272     Token xsp;

8273     xsp = jj_scanpos;

8274     if (jj_3R_170()) jj_scanpos = xsp;

8275     if (jj_3R_67()) return true;

8276     return false;

8277   }

8278 

8279   private boolean jj_3_40() {

8280     Token xsp;

8281     while (true) {

8282       xsp = jj_scanpos;

8283       if (jj_3R_90()) { jj_scanpos = xsp; break; }

8284     }

8285     if (jj_3R_70()) return true;

8286     if (jj_scan_token(IDENTIFIER)) return true;

8287     return false;

8288   }

8289 

8290   private boolean jj_3_41() {

8291     if (jj_3R_91()) return true;

8292     return false;

8293   }

8294 

8295   private boolean jj_3R_115() {

8296     if (jj_3R_169()) return true;

8297     if (jj_scan_token(SEMICOLON)) return true;

8298     return false;

8299   }

8300 

8301   private boolean jj_3R_114() {

8302     if (jj_3R_168()) return true;

8303     return false;

8304   }

8305 

8306   private boolean jj_3R_74() {

8307     Token xsp;

8308     xsp = jj_scanpos;

8309     jj_lookingAhead = true;

8310     jj_semLA = isNextTokenAnAssert();

8311     jj_lookingAhead = false;

8312     if (!jj_semLA || jj_3R_114()) {

8313     jj_scanpos = xsp;

8314     if (jj_3R_115()) {

8315     jj_scanpos = xsp;

8316     if (jj_3_41()) {

8317     jj_scanpos = xsp;

8318     if (jj_3R_116()) return true;

8319     }

8320     }

8321     }

8322     return false;

8323   }

8324 

8325   private boolean jj_3_39() {

8326     if (jj_3R_74()) return true;

8327     return false;

8328   }

8329 

8330   private boolean jj_3R_184() {

8331     if (jj_scan_token(LBRACE)) return true;

8332     Token xsp;

8333     while (true) {

8334       xsp = jj_scanpos;

8335       if (jj_3_39()) { jj_scanpos = xsp; break; }

8336     }

8337     if (jj_scan_token(RBRACE)) return true;

8338     return false;

8339   }

8340 

8341   private boolean jj_3_36() {

8342     if (jj_scan_token(LBRACKET)) return true;

8343     if (jj_scan_token(RBRACKET)) return true;

8344     return false;

8345   }

8346 

8347   private boolean jj_3R_89() {

8348     if (jj_scan_token(IDENTIFIER)) return true;

8349     if (jj_scan_token(COLON)) return true;

8350     if (jj_3R_91()) return true;

8351     return false;

8352   }

8353 

8354   private boolean jj_3R_155() {

8355     if (jj_3R_197()) return true;

8356     return false;

8357   }

8358 

8359   private boolean jj_3R_154() {

8360     if (jj_3R_196()) return true;

8361     return false;

8362   }

8363 

8364   private boolean jj_3R_153() {

8365     if (jj_3R_195()) return true;

8366     return false;

8367   }

8368 

8369   private boolean jj_3R_152() {

8370     if (jj_3R_194()) return true;

8371     return false;

8372   }

8373 

8374   private boolean jj_3R_151() {

8375     if (jj_3R_193()) return true;

8376     return false;

8377   }

8378 

8379   private boolean jj_3R_150() {

8380     if (jj_3R_192()) return true;

8381     return false;

8382   }

8383 

8384   private boolean jj_3R_149() {

8385     if (jj_3R_191()) return true;

8386     return false;

8387   }

8388 

8389   private boolean jj_3R_148() {

8390     if (jj_3R_190()) return true;

8391     return false;

8392   }

8393 

8394   private boolean jj_3R_147() {

8395     if (jj_3R_189()) return true;

8396     return false;

8397   }

8398 

8399   private boolean jj_3R_146() {

8400     if (jj_3R_188()) return true;

8401     return false;

8402   }

8403 

8404   private boolean jj_3R_145() {

8405     if (jj_3R_187()) return true;

8406     return false;

8407   }

8408 

8409   private boolean jj_3R_144() {

8410     if (jj_3R_186()) return true;

8411     if (jj_scan_token(SEMICOLON)) return true;

8412     return false;

8413   }

8414 

8415   private boolean jj_3R_143() {

8416     if (jj_3R_185()) return true;

8417     return false;

8418   }

8419 

8420   private boolean jj_3R_142() {

8421     if (jj_3R_184()) return true;

8422     return false;

8423   }

8424 

8425   private boolean jj_3R_235() {

8426     if (jj_3R_78()) return true;

8427     return false;

8428   }

8429 

8430   private boolean jj_3_38() {

8431     if (jj_3R_89()) return true;

8432     return false;

8433   }

8434 

8435   private boolean jj_3R_141() {

8436     if (jj_3R_168()) return true;

8437     return false;

8438   }

8439 

8440   private boolean jj_3R_91() {

8441     Token xsp;

8442     xsp = jj_scanpos;

8443     jj_lookingAhead = true;

8444     jj_semLA = isNextTokenAnAssert();

8445     jj_lookingAhead = false;

8446     if (!jj_semLA || jj_3R_141()) {

8447     jj_scanpos = xsp;

8448     if (jj_3_38()) {

8449     jj_scanpos = xsp;

8450     if (jj_3R_142()) {

8451     jj_scanpos = xsp;

8452     if (jj_3R_143()) {

8453     jj_scanpos = xsp;

8454     if (jj_3R_144()) {

8455     jj_scanpos = xsp;

8456     if (jj_3R_145()) {

8457     jj_scanpos = xsp;

8458     if (jj_3R_146()) {

8459     jj_scanpos = xsp;

8460     if (jj_3R_147()) {

8461     jj_scanpos = xsp;

8462     if (jj_3R_148()) {

8463     jj_scanpos = xsp;

8464     if (jj_3R_149()) {

8465     jj_scanpos = xsp;

8466     if (jj_3R_150()) {

8467     jj_scanpos = xsp;

8468     if (jj_3R_151()) {

8469     jj_scanpos = xsp;

8470     if (jj_3R_152()) {

8471     jj_scanpos = xsp;

8472     if (jj_3R_153()) {

8473     jj_scanpos = xsp;

8474     if (jj_3R_154()) {

8475     jj_scanpos = xsp;

8476     if (jj_3R_155()) return true;

8477     }

8478     }

8479     }

8480     }

8481     }

8482     }

8483     }

8484     }

8485     }

8486     }

8487     }

8488     }

8489     }

8490     }

8491     }

8492     return false;

8493   }

8494 

8495   private boolean jj_3R_256() {

8496     if (jj_3R_105()) return true;

8497     return false;

8498   }

8499 

8500   private boolean jj_3R_261() {

8501     if (jj_scan_token(LBRACKET)) return true;

8502     if (jj_scan_token(RBRACKET)) return true;

8503     return false;

8504   }

8505 

8506   private boolean jj_3_35() {

8507     if (jj_scan_token(LBRACKET)) return true;

8508     if (jj_3R_88()) return true;

8509     if (jj_scan_token(RBRACKET)) return true;

8510     return false;

8511   }

8512 

8513   private boolean jj_3R_255() {

8514     Token xsp;

8515     if (jj_3R_261()) return true;

8516     while (true) {

8517       xsp = jj_scanpos;

8518       if (jj_3R_261()) { jj_scanpos = xsp; break; }

8519     }

8520     if (jj_3R_167()) return true;

8521     return false;

8522   }

8523 

8524   private boolean jj_3_37() {

8525     Token xsp;

8526     if (jj_3_35()) return true;

8527     while (true) {

8528       xsp = jj_scanpos;

8529       if (jj_3_35()) { jj_scanpos = xsp; break; }

8530     }

8531     while (true) {

8532       xsp = jj_scanpos;

8533       if (jj_3_36()) { jj_scanpos = xsp; break; }

8534     }

8535     return false;

8536   }

8537 

8538   private boolean jj_3R_234() {

8539     Token xsp;

8540     xsp = jj_scanpos;

8541     if (jj_3_37()) {

8542     jj_scanpos = xsp;

8543     if (jj_3R_255()) return true;

8544     }

8545     return false;

8546   }

8547 

8548   private boolean jj_3R_237() {

8549     if (jj_3R_76()) return true;

8550     Token xsp;

8551     xsp = jj_scanpos;

8552     if (jj_3R_256()) jj_scanpos = xsp;

8553     return false;

8554   }

8555 

8556   private boolean jj_3R_205() {

8557     if (jj_scan_token(COMMA)) return true;

8558     if (jj_3R_88()) return true;

8559     return false;

8560   }

8561 

8562   private boolean jj_3R_236() {

8563     if (jj_3R_234()) return true;

8564     return false;

8565   }

8566 

8567   private boolean jj_3R_138() {

8568     if (jj_scan_token(NEW)) return true;

8569     if (jj_3R_179()) return true;

8570     Token xsp;

8571     xsp = jj_scanpos;

8572     if (jj_3R_235()) jj_scanpos = xsp;

8573     xsp = jj_scanpos;

8574     if (jj_3R_236()) {

8575     jj_scanpos = xsp;

8576     if (jj_3R_237()) return true;

8577     }

8578     return false;

8579   }

8580 

8581   private boolean jj_3R_86() {

8582     Token xsp;

8583     xsp = jj_scanpos;

8584     if (jj_3_34()) {

8585     jj_scanpos = xsp;

8586     if (jj_3R_138()) return true;

8587     }

8588     return false;

8589   }

8590 

8591   private boolean jj_3_34() {

8592     if (jj_scan_token(NEW)) return true;

8593     if (jj_3R_83()) return true;

8594     if (jj_3R_234()) return true;

8595     return false;

8596   }

8597 

8598   private boolean jj_3R_118() {

8599     if (jj_3R_178()) return true;

8600     return false;

8601   }

8602 

8603   private boolean jj_3R_178() {

8604     if (jj_3R_88()) return true;

8605     Token xsp;

8606     while (true) {

8607       xsp = jj_scanpos;

8608       if (jj_3R_205()) { jj_scanpos = xsp; break; }

8609     }

8610     return false;

8611   }

8612 

8613   private boolean jj_3R_76() {

8614     if (jj_scan_token(LPAREN)) return true;

8615     Token xsp;

8616     xsp = jj_scanpos;

8617     if (jj_3R_118()) jj_scanpos = xsp;

8618     if (jj_scan_token(RPAREN)) return true;

8619     return false;

8620   }

8621 

8622   private boolean jj_3R_182() {

8623     if (jj_3R_204()) return true;

8624     return false;

8625   }

8626 

8627   private boolean jj_3R_230() {

8628     if (jj_scan_token(NULL)) return true;

8629     return false;

8630   }

8631 

8632   private boolean jj_3R_229() {

8633     Token xsp;

8634     xsp = jj_scanpos;

8635     if (jj_3R_240()) {

8636     jj_scanpos = xsp;

8637     if (jj_scan_token(27)) return true;

8638     }

8639     return false;

8640   }

8641 

8642   private boolean jj_3R_240() {

8643     if (jj_scan_token(TRUE)) return true;

8644     return false;

8645   }

8646 

8647   private boolean jj_3R_221() {

8648     if (jj_3R_230()) return true;

8649     return false;

8650   }

8651 

8652   private boolean jj_3R_385() {

8653     if (jj_scan_token(DECR)) return true;

8654     return false;

8655   }

8656 

8657   private boolean jj_3R_220() {

8658     if (jj_3R_229()) return true;

8659     return false;

8660   }

8661 

8662   private boolean jj_3R_219() {

8663     if (jj_scan_token(STRING_LITERAL)) return true;

8664     return false;

8665   }

8666 

8667   private boolean jj_3R_218() {

8668     if (jj_scan_token(CHARACTER_LITERAL)) return true;

8669     return false;

8670   }

8671 

8672   private boolean jj_3R_217() {

8673     if (jj_scan_token(HEX_FLOATING_POINT_LITERAL)) return true;

8674     return false;

8675   }

8676 

8677   private boolean jj_3R_216() {

8678     if (jj_scan_token(FLOATING_POINT_LITERAL)) return true;

8679     return false;

8680   }

8681 

8682   private boolean jj_3R_204() {

8683     Token xsp;

8684     xsp = jj_scanpos;

8685     if (jj_3R_215()) {

8686     jj_scanpos = xsp;

8687     if (jj_3R_216()) {

8688     jj_scanpos = xsp;

8689     if (jj_3R_217()) {

8690     jj_scanpos = xsp;

8691     if (jj_3R_218()) {

8692     jj_scanpos = xsp;

8693     if (jj_3R_219()) {

8694     jj_scanpos = xsp;

8695     if (jj_3R_220()) {

8696     jj_scanpos = xsp;

8697     if (jj_3R_221()) return true;

8698     }

8699     }

8700     }

8701     }

8702     }

8703     }

8704     return false;

8705   }

8706 

8707   private boolean jj_3R_215() {

8708     if (jj_scan_token(INTEGER_LITERAL)) return true;

8709     return false;

8710   }

8711 

8712   private boolean jj_3R_136() {

8713     if (jj_3R_76()) return true;

8714     return false;

8715   }

8716 

8717   private boolean jj_3R_135() {

8718     if (jj_scan_token(DOT)) return true;

8719     if (jj_scan_token(IDENTIFIER)) return true;

8720     return false;

8721   }

8722 

8723   private boolean jj_3_29() {

8724     if (jj_3R_85()) return true;

8725     if (jj_scan_token(DOT)) return true;

8726     if (jj_scan_token(CLASS)) return true;

8727     return false;

8728   }

8729 

8730   private boolean jj_3R_134() {

8731     if (jj_scan_token(LBRACKET)) return true;

8732     if (jj_3R_88()) return true;

8733     if (jj_scan_token(RBRACKET)) return true;

8734     return false;

8735   }

8736 

8737   private boolean jj_3_33() {

8738     if (jj_3R_87()) return true;

8739     return false;

8740   }

8741 

8742   private boolean jj_3R_348() {

8743     if (jj_scan_token(REM)) return true;

8744     return false;

8745   }

8746 

8747   private boolean jj_3_32() {

8748     if (jj_scan_token(DOT)) return true;

8749     if (jj_3R_86()) return true;

8750     return false;

8751   }

8752 

8753   private boolean jj_3R_84() {

8754     Token xsp;

8755     xsp = jj_scanpos;

8756     if (jj_3_30()) {

8757     jj_scanpos = xsp;

8758     if (jj_3_31()) {

8759     jj_scanpos = xsp;

8760     if (jj_3_32()) {

8761     jj_scanpos = xsp;

8762     if (jj_3_33()) {

8763     jj_scanpos = xsp;

8764     if (jj_3R_134()) {

8765     jj_scanpos = xsp;

8766     if (jj_3R_135()) {

8767     jj_scanpos = xsp;

8768     if (jj_3R_136()) return true;

8769     }

8770     }

8771     }

8772     }

8773     }

8774     }

8775     return false;

8776   }

8777 

8778   private boolean jj_3_31() {

8779     if (jj_scan_token(DOT)) return true;

8780     if (jj_scan_token(SUPER)) return true;

8781     return false;

8782   }

8783 

8784   private boolean jj_3_30() {

8785     if (jj_scan_token(DOT)) return true;

8786     if (jj_scan_token(THIS)) return true;

8787     return false;

8788   }

8789 

8790   private boolean jj_3R_177() {

8791     if (jj_3R_95()) return true;

8792     return false;

8793   }

8794 

8795   private boolean jj_3R_176() {

8796     if (jj_3R_85()) return true;

8797     if (jj_scan_token(DOT)) return true;

8798     if (jj_scan_token(CLASS)) return true;

8799     return false;

8800   }

8801 

8802   private boolean jj_3_28() {

8803     if (jj_3R_84()) return true;

8804     return false;

8805   }

8806 

8807   private boolean jj_3R_175() {

8808     if (jj_3R_86()) return true;

8809     return false;

8810   }

8811 

8812   private boolean jj_3R_174() {

8813     if (jj_scan_token(LPAREN)) return true;

8814     if (jj_3R_88()) return true;

8815     if (jj_scan_token(RPAREN)) return true;

8816     return false;

8817   }

8818 

8819   private boolean jj_3R_173() {

8820     if (jj_scan_token(SUPER)) return true;

8821     if (jj_scan_token(DOT)) return true;

8822     if (jj_scan_token(IDENTIFIER)) return true;

8823     return false;

8824   }

8825 

8826   private boolean jj_3R_172() {

8827     if (jj_scan_token(THIS)) return true;

8828     return false;

8829   }

8830 

8831   private boolean jj_3R_117() {

8832     Token xsp;

8833     xsp = jj_scanpos;

8834     if (jj_3R_171()) {

8835     jj_scanpos = xsp;

8836     if (jj_3R_172()) {

8837     jj_scanpos = xsp;

8838     if (jj_3R_173()) {

8839     jj_scanpos = xsp;

8840     if (jj_3R_174()) {

8841     jj_scanpos = xsp;

8842     if (jj_3R_175()) {

8843     jj_scanpos = xsp;

8844     if (jj_3R_176()) {

8845     jj_scanpos = xsp;

8846     if (jj_3R_177()) return true;

8847     }

8848     }

8849     }

8850     }

8851     }

8852     }

8853     return false;

8854   }

8855 

8856   private boolean jj_3R_171() {

8857     if (jj_3R_204()) return true;

8858     return false;

8859   }

8860 

8861   private boolean jj_3R_384() {

8862     if (jj_scan_token(INCR)) return true;

8863     return false;

8864   }

8865 

8866   private boolean jj_3R_379() {

8867     Token xsp;

8868     xsp = jj_scanpos;

8869     if (jj_3R_384()) {

8870     jj_scanpos = xsp;

8871     if (jj_3R_385()) return true;

8872     }

8873     return false;

8874   }

8875 

8876   private boolean jj_3R_87() {

8877     if (jj_scan_token(DOT)) return true;

8878     if (jj_3R_78()) return true;

8879     if (jj_scan_token(IDENTIFIER)) return true;

8880     return false;

8881   }

8882 

8883   private boolean jj_3_27() {

8884     if (jj_scan_token(LPAREN)) return true;

8885     if (jj_3R_83()) return true;

8886     return false;

8887   }

8888 

8889   private boolean jj_3R_350() {

8890     if (jj_scan_token(BANG)) return true;

8891     return false;

8892   }

8893 

8894   private boolean jj_3R_75() {

8895     if (jj_3R_117()) return true;

8896     Token xsp;

8897     while (true) {

8898       xsp = jj_scanpos;

8899       if (jj_3_28()) { jj_scanpos = xsp; break; }

8900     }

8901     return false;

8902   }

8903 

8904   private boolean jj_3R_337() {

8905     if (jj_scan_token(MINUS)) return true;

8906     return false;

8907   }

8908 

8909   private boolean jj_3R_347() {

8910     if (jj_scan_token(SLASH)) return true;

8911     return false;

8912   }

8913 

8914   private boolean jj_3R_360() {

8915     if (jj_scan_token(LPAREN)) return true;

8916     if (jj_3R_70()) return true;

8917     if (jj_scan_token(RPAREN)) return true;

8918     if (jj_3R_325()) return true;

8919     return false;

8920   }

8921 

8922   private boolean jj_3R_351() {

8923     Token xsp;

8924     xsp = jj_scanpos;

8925     if (jj_3R_359()) {

8926     jj_scanpos = xsp;

8927     if (jj_3R_360()) return true;

8928     }

8929     return false;

8930   }

8931 

8932   private boolean jj_3R_359() {

8933     if (jj_scan_token(LPAREN)) return true;

8934     if (jj_3R_70()) return true;

8935     if (jj_scan_token(RPAREN)) return true;

8936     if (jj_3R_294()) return true;

8937     return false;

8938   }

8939 

8940   private boolean jj_3_26() {

8941     if (jj_scan_token(LPAREN)) return true;

8942     if (jj_3R_70()) return true;

8943     if (jj_scan_token(LBRACKET)) return true;

8944     return false;

8945   }

8946 

8947   private boolean jj_3R_226() {

8948     if (jj_3R_75()) return true;

8949     Token xsp;

8950     xsp = jj_scanpos;

8951     if (jj_3R_379()) jj_scanpos = xsp;

8952     return false;

8953   }

8954 

8955   private boolean jj_3R_125() {

8956     if (jj_scan_token(LPAREN)) return true;

8957     if (jj_3R_70()) return true;

8958     if (jj_scan_token(RPAREN)) return true;

8959     Token xsp;

8960     xsp = jj_scanpos;

8961     if (jj_scan_token(88)) {

8962     jj_scanpos = xsp;

8963     if (jj_scan_token(87)) {

8964     jj_scanpos = xsp;

8965     if (jj_scan_token(75)) {

8966     jj_scanpos = xsp;

8967     if (jj_scan_token(72)) {

8968     jj_scanpos = xsp;

8969     if (jj_scan_token(53)) {

8970     jj_scanpos = xsp;

8971     if (jj_scan_token(50)) {

8972     jj_scanpos = xsp;

8973     if (jj_scan_token(41)) {

8974     jj_scanpos = xsp;

8975     if (jj_3R_182()) return true;

8976     }

8977     }

8978     }

8979     }

8980     }

8981     }

8982     }

8983     return false;

8984   }

8985 

8986   private boolean jj_3_24() {

8987     if (jj_3R_82()) return true;

8988     return false;

8989   }

8990 

8991   private boolean jj_3R_324() {

8992     if (jj_scan_token(MINUS)) return true;

8993     return false;

8994   }

8995 

8996   private boolean jj_3R_124() {

8997     if (jj_scan_token(LPAREN)) return true;

8998     if (jj_3R_70()) return true;

8999     if (jj_scan_token(LBRACKET)) return true;

9000     if (jj_scan_token(RBRACKET)) return true;

9001     return false;

9002   }

9003 

9004   private boolean jj_3R_82() {

9005     Token xsp;

9006     xsp = jj_scanpos;

9007     if (jj_3_25()) {

9008     jj_scanpos = xsp;

9009     if (jj_3R_124()) {

9010     jj_scanpos = xsp;

9011     if (jj_3R_125()) return true;

9012     }

9013     }

9014     return false;

9015   }

9016 

9017   private boolean jj_3_25() {

9018     if (jj_scan_token(LPAREN)) return true;

9019     if (jj_3R_83()) return true;

9020     return false;

9021   }

9022 

9023   private boolean jj_3R_340() {

9024     if (jj_3R_226()) return true;

9025     return false;

9026   }

9027 

9028   private boolean jj_3R_349() {

9029     if (jj_scan_token(TILDE)) return true;

9030     return false;

9031   }

9032 

9033   private boolean jj_3R_339() {

9034     if (jj_3R_351()) return true;

9035     return false;

9036   }

9037 

9038   private boolean jj_3R_338() {

9039     Token xsp;

9040     xsp = jj_scanpos;

9041     if (jj_3R_349()) {

9042     jj_scanpos = xsp;

9043     if (jj_3R_350()) return true;

9044     }

9045     if (jj_3R_294()) return true;

9046     return false;

9047   }

9048 

9049   private boolean jj_3R_325() {

9050     Token xsp;

9051     xsp = jj_scanpos;

9052     if (jj_3R_338()) {

9053     jj_scanpos = xsp;

9054     if (jj_3R_339()) {

9055     jj_scanpos = xsp;

9056     if (jj_3R_340()) return true;

9057     }

9058     }

9059     return false;

9060   }

9061 

9062   private boolean jj_3R_336() {

9063     if (jj_scan_token(PLUS)) return true;

9064     return false;

9065   }

9066 

9067   private boolean jj_3R_322() {

9068     Token xsp;

9069     xsp = jj_scanpos;

9070     if (jj_3R_336()) {

9071     jj_scanpos = xsp;

9072     if (jj_3R_337()) return true;

9073     }

9074     if (jj_3R_287()) return true;

9075     return false;

9076   }

9077 

9078   private boolean jj_3R_346() {

9079     if (jj_scan_token(STAR)) return true;

9080     return false;

9081   }

9082 

9083   private boolean jj_3R_225() {

9084     if (jj_scan_token(DECR)) return true;

9085     if (jj_3R_75()) return true;

9086     return false;

9087   }

9088 

9089   private boolean jj_3R_335() {

9090     Token xsp;

9091     xsp = jj_scanpos;

9092     if (jj_3R_346()) {

9093     jj_scanpos = xsp;

9094     if (jj_3R_347()) {

9095     jj_scanpos = xsp;

9096     if (jj_3R_348()) return true;

9097     }

9098     }

9099     if (jj_3R_294()) return true;

9100     return false;

9101   }

9102 

9103   private boolean jj_3R_286() {

9104     if (jj_scan_token(NE)) return true;

9105     return false;

9106   }

9107 

9108   private boolean jj_3R_224() {

9109     if (jj_scan_token(INCR)) return true;

9110     if (jj_3R_75()) return true;

9111     return false;

9112   }

9113 

9114   private boolean jj_3R_313() {

9115     if (jj_3R_325()) return true;

9116     return false;

9117   }

9118 

9119   private boolean jj_3R_312() {

9120     if (jj_3R_225()) return true;

9121     return false;

9122   }

9123 

9124   private boolean jj_3R_311() {

9125     if (jj_3R_224()) return true;

9126     return false;

9127   }

9128 

9129   private boolean jj_3R_323() {

9130     if (jj_scan_token(PLUS)) return true;

9131     return false;

9132   }

9133 

9134   private boolean jj_3R_310() {

9135     Token xsp;

9136     xsp = jj_scanpos;

9137     if (jj_3R_323()) {

9138     jj_scanpos = xsp;

9139     if (jj_3R_324()) return true;

9140     }

9141     if (jj_3R_294()) return true;

9142     return false;

9143   }

9144 

9145   private boolean jj_3R_294() {

9146     Token xsp;

9147     xsp = jj_scanpos;

9148     if (jj_3R_310()) {

9149     jj_scanpos = xsp;

9150     if (jj_3R_311()) {

9151     jj_scanpos = xsp;

9152     if (jj_3R_312()) {

9153     jj_scanpos = xsp;

9154     if (jj_3R_313()) return true;

9155     }

9156     }

9157     }

9158     return false;

9159   }

9160 

9161   private boolean jj_3R_287() {

9162     if (jj_3R_294()) return true;

9163     Token xsp;

9164     while (true) {

9165       xsp = jj_scanpos;

9166       if (jj_3R_335()) { jj_scanpos = xsp; break; }

9167     }

9168     return false;

9169   }

9170 

9171   private boolean jj_3R_278() {

9172     if (jj_3R_287()) return true;

9173     Token xsp;

9174     while (true) {

9175       xsp = jj_scanpos;

9176       if (jj_3R_322()) { jj_scanpos = xsp; break; }

9177     }

9178     return false;

9179   }

9180 

9181   private boolean jj_3_23() {

9182     if (jj_3R_81()) return true;

9183     return false;

9184   }

9185 

9186   private boolean jj_3_22() {

9187     if (jj_3R_80()) return true;

9188     return false;

9189   }

9190 

9191   private boolean jj_3R_284() {

9192     if (jj_scan_token(INSTANCEOF)) return true;

9193     if (jj_3R_70()) return true;

9194     return false;

9195   }

9196 

9197   private boolean jj_3R_79() {

9198     if (jj_scan_token(LSHIFT)) return true;

9199     return false;

9200   }

9201 

9202   private boolean jj_3_21() {

9203     Token xsp;

9204     xsp = jj_scanpos;

9205     if (jj_3R_79()) {

9206     jj_scanpos = xsp;

9207     if (jj_3_22()) {

9208     jj_scanpos = xsp;

9209     if (jj_3_23()) return true;

9210     }

9211     }

9212     if (jj_3R_278()) return true;

9213     return false;

9214   }

9215 

9216   private boolean jj_3R_285() {

9217     if (jj_scan_token(EQ)) return true;

9218     return false;

9219   }

9220 

9221   private boolean jj_3R_277() {

9222     Token xsp;

9223     xsp = jj_scanpos;

9224     if (jj_3R_285()) {

9225     jj_scanpos = xsp;

9226     if (jj_3R_286()) return true;

9227     }

9228     if (jj_3R_263()) return true;

9229     return false;

9230   }

9231 

9232   private boolean jj_3R_272() {

9233     if (jj_3R_278()) return true;

9234     Token xsp;

9235     while (true) {

9236       xsp = jj_scanpos;

9237       if (jj_3_21()) { jj_scanpos = xsp; break; }

9238     }

9239     return false;

9240   }

9241 

9242   private boolean jj_3R_309() {

9243     if (jj_scan_token(GE)) return true;

9244     return false;

9245   }

9246 

9247   private boolean jj_3R_308() {

9248     if (jj_scan_token(LE)) return true;

9249     return false;

9250   }

9251 

9252   private boolean jj_3R_307() {

9253     if (jj_scan_token(GT)) return true;

9254     return false;

9255   }

9256 

9257   private boolean jj_3R_306() {

9258     if (jj_scan_token(LT)) return true;

9259     return false;

9260   }

9261 

9262   private boolean jj_3R_271() {

9263     if (jj_scan_token(BIT_AND)) return true;

9264     if (jj_3R_260()) return true;

9265     return false;

9266   }

9267 

9268   private boolean jj_3R_293() {

9269     Token xsp;

9270     xsp = jj_scanpos;

9271     if (jj_3R_306()) {

9272     jj_scanpos = xsp;

9273     if (jj_3R_307()) {

9274     jj_scanpos = xsp;

9275     if (jj_3R_308()) {

9276     jj_scanpos = xsp;

9277     if (jj_3R_309()) return true;

9278     }

9279     }

9280     }

9281     if (jj_3R_272()) return true;

9282     return false;

9283   }

9284 

9285   private boolean jj_3R_268() {

9286     if (jj_3R_272()) return true;

9287     Token xsp;

9288     while (true) {

9289       xsp = jj_scanpos;

9290       if (jj_3R_293()) { jj_scanpos = xsp; break; }

9291     }

9292     return false;

9293   }

9294 

9295   private boolean jj_3R_262() {

9296     if (jj_scan_token(BIT_OR)) return true;

9297     if (jj_3R_233()) return true;

9298     return false;

9299   }

9300 

9301   private boolean jj_3R_267() {

9302     if (jj_scan_token(XOR)) return true;

9303     if (jj_3R_254()) return true;

9304     return false;

9305   }

9306 

9307   private boolean jj_3R_263() {

9308     if (jj_3R_268()) return true;

9309     Token xsp;

9310     xsp = jj_scanpos;

9311     if (jj_3R_284()) jj_scanpos = xsp;

9312     return false;

9313   }

9314 

9315   private boolean jj_3R_259() {

9316     if (jj_scan_token(SC_AND)) return true;

9317     if (jj_3R_223()) return true;

9318     return false;

9319   }

9320 

9321   private boolean jj_3R_260() {

9322     if (jj_3R_263()) return true;

9323     Token xsp;

9324     while (true) {

9325       xsp = jj_scanpos;

9326       if (jj_3R_277()) { jj_scanpos = xsp; break; }

9327     }

9328     return false;

9329   }

9330 

9331   private boolean jj_3R_241() {

9332     if (jj_scan_token(SC_OR)) return true;

9333     if (jj_3R_206()) return true;

9334     return false;

9335   }

9336 

9337   private boolean jj_3R_254() {

9338     if (jj_3R_260()) return true;

9339     Token xsp;

9340     while (true) {

9341       xsp = jj_scanpos;

9342       if (jj_3R_271()) { jj_scanpos = xsp; break; }

9343     }

9344     return false;

9345   }

9346 

9347   /** Generated Token Manager. */

9348   public JavaParserTokenManager token_source;

9349   /** Current token. */

9350   public Token token;

9351   /** Next token. */

9352   public Token jj_nt;

9353   private Token jj_scanpos, jj_lastpos;

9354   private int jj_la;

9355   /** Whether we are looking ahead. */

9356   private boolean jj_lookingAhead = false;

9357   private boolean jj_semLA;

9358   private int jj_gen;

9359   final private int[] jj_la1 = new int[137];

9360   static private int[] jj_la1_0;

9361   static private int[] jj_la1_1;

9362   static private int[] jj_la1_2;

9363   static private int[] jj_la1_3;

9364   static {

9365       jj_la1_init_0();

9366       jj_la1_init_1();

9367       jj_la1_init_2();

9368       jj_la1_init_3();

9369    }

9370    private static void jj_la1_init_0() {

9371       jj_la1_0 = new int[] {0x0,0x10081000,0x0,0x0,0x0,0x0,0x0,0x10001000,0x10081000,0x10081000,0x10001000,0x10001000,0x10081000,0x0,0x4000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x510cb000,0x0,0x0,0x0,0x0,0x4000000,0x0,0x510cb000,0x4104a000,0x510cb000,0x0,0x0,0x0,0x4904a000,0x4904a000,0x0,0x0,0x0,0x0,0x0,0x0,0x5104a000,0x10000000,0x10000000,0x0,0x0,0x0,0x0,0x4904a000,0x0,0x4104a000,0x4104a000,0x0,0x4000000,0x4104a000,0x4000000,0x4104a000,0x4104a000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4904a000,0x0,0x0,0x4904a000,0x8000000,0x0,0x0,0x0,0x0,0x8000000,0x0,0x0,0x8000000,0x8000000,0x4904a000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc9a4e000,0x0,0x10000000,0x10000000,0x0,0x0,0x0,0x4904a000,0x410000,0x410000,0x2000000,0x5904a000,0x4904a000,0x4904a000,0x5904a000,0x4904a000,0x0,0x0,0x0,0x4904a000,0x20000,0x20000000,0x0,0x0,0x0,0x0,0x4904a000,0x0,0x4904a000,0x510cb000,0x10081000,0x4104a000,0x510cb000,0x400000,};

9372    }

9373    private static void jj_la1_init_1() {

9374       jj_la1_1 = new int[] {0x8,0x51127140,0x0,0x0,0x0,0x20000,0x0,0x51127100,0x40,0x51127140,0x0,0x0,0x40,0x0,0x0,0x4,0x0,0x0,0x4,0x0,0x0,0x0,0x0,0x591371e0,0x0,0x0,0x0,0x0,0x0,0x0,0x591371e0,0x80100a0,0x591371e0,0x0,0x0,0x0,0x8a2506a0,0x8a2506a0,0x0,0x0,0x800000,0x0,0x0,0x0,0x100a0,0x0,0x0,0x0,0x0,0x800000,0x240000,0x8a2506a0,0x20000,0x100a0,0x100a0,0x0,0x40000,0x100a0,0x40000,0x100a0,0x80100a0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8a2506a0,0x0,0x0,0x8a2506a0,0x82240600,0x0,0x0,0x0,0x0,0x82240600,0x0,0x0,0x82000400,0x2000000,0x8a2506a0,0x0,0x0,0x0,0x0,0x200,0x0,0x0,0xae7d86a2,0x0,0x0,0x0,0x0,0x0,0x0,0x8a2506a0,0x0,0x0,0x0,0x8a2506a0,0x8a2506a0,0x8a2506a0,0x8a2506a0,0x8a2506a0,0x0,0x0,0x0,0x8a2506a0,0x0,0x0,0x0,0x0,0x0,0x0,0x8a2506a0,0x0,0x8a2506a0,0x511371e0,0x40,0x100a0,0x511371e0,0x0,};

9375    }

9376    private static void jj_la1_init_2() {

9377       jj_la1_2 = new int[] {0x0,0x120100,0x0,0x0,0x100000,0x0,0x80000,0x100000,0x100100,0x120100,0x0,0x0,0x0,0x400000,0x0,0x0,0x40000,0x40000,0x0,0x100000,0x100000,0x100100,0x40000,0x522100,0x20000,0x800,0x2000,0x40000,0x0,0x0,0x522100,0x500100,0x520100,0x40000,0x200000,0x8000,0x18029d8,0x18029d8,0x40000,0x400000,0x0,0x22000,0x8000,0x40000,0x100100,0x100000,0x100000,0x0,0x400000,0x0,0x0,0x9d8,0x0,0x0,0x100,0x40000,0x0,0x2000100,0x0,0x0,0x100,0x40000,0x200000,0x200000,0x2000000,0x80000000,0x0,0x0,0x0,0x0,0x48000000,0x48000000,0x0,0x30400000,0x30400000,0x0,0x0,0x0,0x0,0x0,0x0,0x18009d8,0x1800000,0x1800000,0x9d8,0x18009d8,0x800,0x0,0x0,0x800,0x8d8,0x100,0x88800,0xd8,0x0,0x18009d8,0x40000,0x400000,0x2000,0x8800,0x0,0x8000,0x8000,0x229d8,0x100000,0x100000,0x100000,0x40000,0x200000,0x0,0x9d8,0x0,0x0,0x0,0x1009d8,0x18009d8,0x9d8,0x1209d8,0x9d8,0x40000,0x100,0x100,0x18009d8,0x0,0x0,0x4000000,0x100000,0x100,0x40000,0x19029d8,0x40000,0x19029d8,0x120100,0x0,0x100100,0x120100,0x0,};

9378    }

9379    private static void jj_la1_init_3() {

9380       jj_la1_3 = new int[] {0x0,0x0,0x8000000,0x10000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80,0x0,0x0,0x0,0x0,0x0,0x0,0x1e,0x1e,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x800000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7ff000,0x7ff000,0x0,0x0,0x1,0x100,0x200,0x80,0x0,0x0,0x0,0x4000000,0x4000000,0x800,0x18,0x18,0x460,0x460,0x18,0x1e,0x0,0x0,0x0,0x0,0x0,0x6,0x6,0x0,0x0,0x0,0x0,0x0,0x0,0x1e,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x6,0x0,0x0,0x0,0x0,0x7ff000,0x6,0x0,0x0,0x0,0x0,0x6,0x1e,0x6,0x6,0x6,0x0,0x0,0x0,0x1e,0x0,0x0,0x0,0x0,0x0,0x0,0x1e,0x0,0x1e,0x0,0x0,0x0,0x0,0x0,};

9381    }

9382   final private JJCalls[] jj_2_rtns = new JJCalls[51];

9383   private boolean jj_rescan = false;

9384   private int jj_gc = 0;

9385 

9386   /** Constructor with user supplied CharStream. */

9387   public JavaParser(CharStream stream) {

9388     token_source = new JavaParserTokenManager(stream);

9389     token = new Token();

9390     token.next = jj_nt = token_source.getNextToken();

9391     jj_gen = 0;

9392     for (int i = 0; i < 137; i++) jj_la1[i] = -1;

9393     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();

9394   }

9395 

9396   /** Reinitialise. */

9397   public void ReInit(CharStream stream) {

9398     token_source.ReInit(stream);

9399     token = new Token();

9400     token.next = jj_nt = token_source.getNextToken();

9401     jj_lookingAhead = false;

9402     jjtree.reset();

9403     jj_gen = 0;

9404     for (int i = 0; i < 137; i++) jj_la1[i] = -1;

9405     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();

9406   }

9407 

9408   /** Constructor with generated Token Manager. */

9409   public JavaParser(JavaParserTokenManager tm) {

9410     token_source = tm;

9411     token = new Token();

9412     token.next = jj_nt = token_source.getNextToken();

9413     jj_gen = 0;

9414     for (int i = 0; i < 137; i++) jj_la1[i] = -1;

9415     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();

9416   }

9417 

9418   /** Reinitialise. */

9419   public void ReInit(JavaParserTokenManager tm) {

9420     token_source = tm;

9421     token = new Token();

9422     token.next = jj_nt = token_source.getNextToken();

9423     jjtree.reset();

9424     jj_gen = 0;

9425     for (int i = 0; i < 137; i++) jj_la1[i] = -1;

9426     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();

9427   }

9428 

9429   private Token jj_consume_token(int kind) throws ParseException {

9430     Token oldToken = token;

9431     if ((token = jj_nt).next != null) jj_nt = jj_nt.next;

9432     else jj_nt = jj_nt.next = token_source.getNextToken();

9433     if (token.kind == kind) {

9434       jj_gen++;

9435       if (++jj_gc > 100) {

9436         jj_gc = 0;

9437         for (int i = 0; i < jj_2_rtns.length; i++) {

9438           JJCalls c = jj_2_rtns[i];

9439           while (c != null) {

9440             if (c.gen < jj_gen) c.first = null;

9441             c = c.next;

9442           }

9443         }

9444       }

9445       return token;

9446     }

9447     jj_nt = token;

9448     token = oldToken;

9449     jj_kind = kind;

9450     throw generateParseException();

9451   }

9452 

9453   static private final class LookaheadSuccess extends java.lang.Error { }

9454   final private LookaheadSuccess jj_ls = new LookaheadSuccess();

9455   private boolean jj_scan_token(int kind) {

9456     if (jj_scanpos == jj_lastpos) {

9457       jj_la--;

9458       if (jj_scanpos.next == null) {

9459         jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();

9460       } else {

9461         jj_lastpos = jj_scanpos = jj_scanpos.next;

9462       }

9463     } else {

9464       jj_scanpos = jj_scanpos.next;

9465     }

9466     if (jj_rescan) {

9467       int i = 0; Token tok = token;

9468       while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; }

9469       if (tok != null) jj_add_error_token(kind, i);

9470     }

9471     if (jj_scanpos.kind != kind) return true;

9472     if (jj_la == 0 && jj_scanpos == jj_lastpos) throw jj_ls;

9473     return false;

9474   }

9475 

9476 

9477 /** Get the next Token. */

9478   final public Token getNextToken() {

9479     if ((token = jj_nt).next != null) jj_nt = jj_nt.next;

9480     else jj_nt = jj_nt.next = token_source.getNextToken();

9481     jj_gen++;

9482     return token;

9483   }

9484 

9485 /** Get the specific Token. */

9486   final public Token getToken(int index) {

9487     Token t = jj_lookingAhead ? jj_scanpos : token;

9488     for (int i = 0; i < index; i++) {

9489       if (t.next != null) t = t.next;

9490       else t = t.next = token_source.getNextToken();

9491     }

9492     return t;

9493   }

9494 

9495   private java.util.List<int[]> jj_expentries = new java.util.ArrayList<int[]>();

9496   private int[] jj_expentry;

9497   private int jj_kind = -1;

9498   private int[] jj_lasttokens = new int[100];

9499   private int jj_endpos;

9500 

9501   private void jj_add_error_token(int kind, int pos) {

9502     if (pos >= 100) return;

9503     if (pos == jj_endpos + 1) {

9504       jj_lasttokens[jj_endpos++] = kind;

9505     } else if (jj_endpos != 0) {

9506       jj_expentry = new int[jj_endpos];

9507       for (int i = 0; i < jj_endpos; i++) {

9508         jj_expentry[i] = jj_lasttokens[i];

9509       }

9510       jj_entries_loop: for (java.util.Iterator it = jj_expentries.iterator(); it.hasNext();) {

9511         int[] oldentry = (int[])(it.next());

9512         if (oldentry.length == jj_expentry.length) {

9513           for (int i = 0; i < jj_expentry.length; i++) {

9514             if (oldentry[i] != jj_expentry[i]) {

9515               continue jj_entries_loop;

9516             }

9517           }

9518           jj_expentries.add(jj_expentry);

9519           break jj_entries_loop;

9520         }

9521       }

9522       if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind;

9523     }

9524   }

9525 

9526   /** Generate ParseException. */

9527   public ParseException generateParseException() {

9528     jj_expentries.clear();

9529     boolean[] la1tokens = new boolean[125];

9530     if (jj_kind >= 0) {

9531       la1tokens[jj_kind] = true;

9532       jj_kind = -1;

9533     }

9534     for (int i = 0; i < 137; i++) {

9535       if (jj_la1[i] == jj_gen) {

9536         for (int j = 0; j < 32; j++) {

9537           if ((jj_la1_0[i] & (1<<j)) != 0) {

9538             la1tokens[j] = true;

9539           }

9540           if ((jj_la1_1[i] & (1<<j)) != 0) {

9541             la1tokens[32+j] = true;

9542           }

9543           if ((jj_la1_2[i] & (1<<j)) != 0) {

9544             la1tokens[64+j] = true;

9545           }

9546           if ((jj_la1_3[i] & (1<<j)) != 0) {

9547             la1tokens[96+j] = true;

9548           }

9549         }

9550       }

9551     }

9552     for (int i = 0; i < 125; i++) {

9553       if (la1tokens[i]) {

9554         jj_expentry = new int[1];

9555         jj_expentry[0] = i;

9556         jj_expentries.add(jj_expentry);

9557       }

9558     }

9559     jj_endpos = 0;

9560     jj_rescan_token();

9561     jj_add_error_token(0, 0);

9562     int[][] exptokseq = new int[jj_expentries.size()][];

9563     for (int i = 0; i < jj_expentries.size(); i++) {

9564       exptokseq[i] = jj_expentries.get(i);

9565     }

9566     return new ParseException(token, exptokseq, tokenImage);

9567   }

9568 

9569   /** Enable tracing. */

9570   final public void enable_tracing() {

9571   }

9572 

9573   /** Disable tracing. */

9574   final public void disable_tracing() {

9575   }

9576 

9577   private void jj_rescan_token() {

9578     jj_rescan = true;

9579     for (int i = 0; i < 51; i++) {

9580     try {

9581       JJCalls p = jj_2_rtns[i];

9582       do {

9583         if (p.gen > jj_gen) {

9584           jj_la = p.arg; jj_lastpos = jj_scanpos = p.first;

9585           switch (i) {

9586             case 0: jj_3_1(); break;

9587             case 1: jj_3_2(); break;

9588             case 2: jj_3_3(); break;

9589             case 3: jj_3_4(); break;

9590             case 4: jj_3_5(); break;

9591             case 5: jj_3_6(); break;

9592             case 6: jj_3_7(); break;

9593             case 7: jj_3_8(); break;

9594             case 8: jj_3_9(); break;

9595             case 9: jj_3_10(); break;

9596             case 10: jj_3_11(); break;

9597             case 11: jj_3_12(); break;

9598             case 12: jj_3_13(); break;

9599             case 13: jj_3_14(); break;

9600             case 14: jj_3_15(); break;

9601             case 15: jj_3_16(); break;

9602             case 16: jj_3_17(); break;

9603             case 17: jj_3_18(); break;

9604             case 18: jj_3_19(); break;

9605             case 19: jj_3_20(); break;

9606             case 20: jj_3_21(); break;

9607             case 21: jj_3_22(); break;

9608             case 22: jj_3_23(); break;

9609             case 23: jj_3_24(); break;

9610             case 24: jj_3_25(); break;

9611             case 25: jj_3_26(); break;

9612             case 26: jj_3_27(); break;

9613             case 27: jj_3_28(); break;

9614             case 28: jj_3_29(); break;

9615             case 29: jj_3_30(); break;

9616             case 30: jj_3_31(); break;

9617             case 31: jj_3_32(); break;

9618             case 32: jj_3_33(); break;

9619             case 33: jj_3_34(); break;

9620             case 34: jj_3_35(); break;

9621             case 35: jj_3_36(); break;

9622             case 36: jj_3_37(); break;

9623             case 37: jj_3_38(); break;

9624             case 38: jj_3_39(); break;

9625             case 39: jj_3_40(); break;

9626             case 40: jj_3_41(); break;

9627             case 41: jj_3_42(); break;

9628             case 42: jj_3_43(); break;

9629             case 43: jj_3_44(); break;

9630             case 44: jj_3_45(); break;

9631             case 45: jj_3_46(); break;

9632             case 46: jj_3_47(); break;

9633             case 47: jj_3_48(); break;

9634             case 48: jj_3_49(); break;

9635             case 49: jj_3_50(); break;

9636             case 50: jj_3_51(); break;

9637           }

9638         }

9639         p = p.next;

9640       } while (p != null);

9641       } catch(LookaheadSuccess ls) { }

9642     }

9643     jj_rescan = false;

9644   }

9645 

9646   private void jj_save(int index, int xla) {

9647     JJCalls p = jj_2_rtns[index];

9648     while (p.gen > jj_gen) {

9649       if (p.next == null) { p = p.next = new JJCalls(); break; }

9650       p = p.next;

9651     }

9652     p.gen = jj_gen + xla - jj_la; p.first = token; p.arg = xla;

9653   }

9654 

9655   static final class JJCalls {

9656     int gen;

9657     Token first;

9658     int arg;

9659     JJCalls next;

9660   }

9661 

9662 }