View Javadoc

    1   /* Generated By:JJTree&JavaCC: Do not edit this line. JavaParser.java */
    2   package net.sourceforge.pmd.lang.java.ast;
    3   import java.util.*;
    4   import net.sourceforge.pmd.PMD;
    5   import net.sourceforge.pmd.lang.ast.CharStream;
    6   import net.sourceforge.pmd.lang.ast.TokenMgrError;
    7   public class JavaParser/*@bgen(jjtree)*/implements JavaParserTreeConstants, JavaParserConstants {/*@bgen(jjtree)*/
    8     protected JJTJavaParserState jjtree = new JJTJavaParserState();
    9     private int jdkVersion = 0;
    10
    11    public void setJdkVersion(int jdkVersion) {
    12     this.jdkVersion = jdkVersion;
    13    }
    14
    15    private void checkForBadAssertUsage(String in, String usage) {
    16      if (jdkVersion > 3 && in.equals("assert")) {
    17        throw new ParseException("Can't use 'assert' as " + usage + " when running in JDK 1.4 mode!");
    18      }
    19    }
    20
    21    private void checkForBadStaticImportUsage() {
    22      if (jdkVersion < 5) {
    23        throw new ParseException("Can't use static imports when running in JDK 1.4 mode!");
    24      }
    25    }
    26
    27    private void checkForBadAnnotationUsage() {
    28      if (jdkVersion < 5) {
    29        throw new ParseException("Can't use annotations when running in JDK 1.4 mode!");
    30      }
    31    }
    32
    33    private void checkForBadGenericsUsage() {
    34      if (jdkVersion < 5) {
    35        throw new ParseException("Can't use generics unless running in JDK 1.5 mode!");
    36      }
    37    }
    38
    39    private void checkForBadVariableArgumentsUsage() {
    40      if (jdkVersion < 5) {
    41        throw new ParseException("Can't use variable arguments (varargs) when running in JDK 1.4 mode!");
    42      }
    43    }
    44
    45    private void checkForBadJDK15ForLoopSyntaxArgumentsUsage() {
    46      if (jdkVersion < 5) {
    47        throw new ParseException("Can't use JDK 1.5 for loop syntax when running in JDK 1.4 mode!");
    48      }
    49    }
    50
    51    private void checkForBadEnumUsage(String in, String usage) {
    52      if (jdkVersion >= 5 && in.equals("enum")) {
    53        throw new ParseException("Can't use 'enum' as " + usage + " when running in JDK 1.5 mode!");
    54      }
    55    }
    56
    57    private void checkForBadHexFloatingPointLiteral() {
    58      if (jdkVersion < 5) {
    59        throw new ParseException("Can't use hexadecimal floating point literals in pre-JDK 1.5 target");
    60      }
    61    }
    62
    63    private void checkForBadNumericalLiteralslUsage(Token token) {
    64      if (jdkVersion < 7) {
    65        if (token.image.contains("_")) {
    66          throw new ParseException("Can't use underscores in numerical literals when running in JDK inferior to 1.7 mode!");
    67        }
    68
    69        if (token.image.startsWith("0b") || token.image.startsWith("0B")) {
    70          throw new ParseException("Can't use binary numerical literals when running in JDK inferior to 1.7 mode!");
    71        }
    72      }
    73    }
    74
    75    private void checkForBadDiamondUsage() {
    76          if (jdkVersion < 7) {
    77        throw new ParseException("Cannot use the diamond generic notation when running in JDK inferior to 1.7 mode!");
    78          }
    79    }
    80
    81    private void checkForBadTryWithResourcesUsage() {
    82          if (jdkVersion < 7) {
    83        throw new ParseException("Cannot use the try-with-resources notation when running in JDK inferior to 1.7 mode!");
    84          }
    85    }
    86
    87    // This is a semantic LOOKAHEAD to determine if we're dealing with an assert
    88    // Note that this can't be replaced with a syntactic lookahead
    89    // since "assert" isn't a string literal token
    90    private boolean isNextTokenAnAssert() {
    91      boolean res = getToken(1).image.equals("assert");
    92      if (res && jdkVersion <= 3 && getToken(2).image.equals("(")) {
    93       res = false;
    94      }
    95      return res;
    96    }
    97
    98    private boolean isPrecededByComment(Token tok) {
    99        boolean res = false;
    100       while (!res && tok.specialToken != null) {
    101           tok = tok.specialToken;
    102           res = tok.kind == SINGLE_LINE_COMMENT ||
    103                 tok.kind == FORMAL_COMMENT ||
    104                 tok.kind == MULTI_LINE_COMMENT;
    105       }
    106       return res;
    107   }
    108
    109   public Map<Integer, String> getSuppressMap() {
    110     return token_source.getSuppressMap();
    111   }
    112
    113   public void setSuppressMarker(String marker) {
    114     token_source.setSuppressMarker(marker);
    115   }
    116
    117 /*****************************************
    118  * THE JAVA LANGUAGE GRAMMAR STARTS HERE *
    119  *****************************************/
    120
    121 /*
    122  * Program structuring syntax follows.
    123  */
    124   final public ASTCompilationUnit CompilationUnit() throws ParseException {
    125  /*@bgen(jjtree) CompilationUnit */
    126   ASTCompilationUnit jjtn000 = new ASTCompilationUnit(this, JJTCOMPILATIONUNIT);
    127   boolean jjtc000 = true;
    128   jjtree.openNodeScope(jjtn000);
    129     try {
    130       if (jj_2_1(2147483647)) {
    131         PackageDeclaration();
    132       } else {
    133         ;
    134       }
    135       label_1:
    136       while (true) {
    137         switch (jj_nt.kind) {
    138         case IMPORT:
    139           ;
    140           break;
    141         default:
    142           jj_la1[0] = jj_gen;
    143           break label_1;
    144         }
    145         ImportDeclaration();
    146       }
    147       label_2:
    148       while (true) {
    149         switch (jj_nt.kind) {
    150         case ABSTRACT:
    151         case CLASS:
    152         case FINAL:
    153         case INTERFACE:
    154         case NATIVE:
    155         case PRIVATE:
    156         case PROTECTED:
    157         case PUBLIC:
    158         case STATIC:
    159         case SYNCHRONIZED:
    160         case TRANSIENT:
    161         case VOLATILE:
    162         case STRICTFP:
    163         case IDENTIFIER:
    164         case SEMICOLON:
    165         case AT:
    166           ;
    167           break;
    168         default:
    169           jj_la1[1] = jj_gen;
    170           break label_2;
    171         }
    172         TypeDeclaration();
    173       }
    174       switch (jj_nt.kind) {
    175       case 124:
    176         jj_consume_token(124);
    177         break;
    178       default:
    179         jj_la1[2] = jj_gen;
    180         ;
    181       }
    182       switch (jj_nt.kind) {
    183       case 125:
    184         jj_consume_token(125);
    185         break;
    186       default:
    187         jj_la1[3] = jj_gen;
    188         ;
    189       }
    190       jj_consume_token(0);
    191   jjtree.closeNodeScope(jjtn000, true);
    192   jjtc000 = false;
    193  jjtn000.setComments(token_source.comments);
    194  {if (true) return jjtn000;}
    195     } catch (Throwable jjte000) {
    196     if (jjtc000) {
    197       jjtree.clearNodeScope(jjtn000);
    198       jjtc000 = false;
    199     } else {
    200       jjtree.popNode();
    201     }
    202     if (jjte000 instanceof RuntimeException) {
    203       {if (true) throw (RuntimeException)jjte000;}
    204     }
    205     if (jjte000 instanceof ParseException) {
    206       {if (true) throw (ParseException)jjte000;}
    207     }
    208     {if (true) throw (Error)jjte000;}
    209     } finally {
    210     if (jjtc000) {
    211       jjtree.closeNodeScope(jjtn000, true);
    212     }
    213     }
    214     throw new RuntimeException("Missing return statement in function");
    215   }
    216
    217   final public void PackageDeclaration() throws ParseException {
    218  /*@bgen(jjtree) PackageDeclaration */
    219   ASTPackageDeclaration jjtn000 = new ASTPackageDeclaration(this, JJTPACKAGEDECLARATION);
    220   boolean jjtc000 = true;
    221   jjtree.openNodeScope(jjtn000);
    222     try {
    223       label_3:
    224       while (true) {
    225         switch (jj_nt.kind) {
    226         case AT:
    227           ;
    228           break;
    229         default:
    230           jj_la1[4] = jj_gen;
    231           break label_3;
    232         }
    233         Annotation();
    234       }
    235       jj_consume_token(PACKAGE);
    236       Name();
    237       jj_consume_token(SEMICOLON);
    238     } catch (Throwable jjte000) {
    239     if (jjtc000) {
    240       jjtree.clearNodeScope(jjtn000);
    241       jjtc000 = false;
    242     } else {
    243       jjtree.popNode();
    244     }
    245     if (jjte000 instanceof RuntimeException) {
    246       {if (true) throw (RuntimeException)jjte000;}
    247     }
    248     if (jjte000 instanceof ParseException) {
    249       {if (true) throw (ParseException)jjte000;}
    250     }
    251     {if (true) throw (Error)jjte000;}
    252     } finally {
    253     if (jjtc000) {
    254       jjtree.closeNodeScope(jjtn000, true);
    255     }
    256     }
    257   }
    258
    259   final public void ImportDeclaration() throws ParseException {
    260  /*@bgen(jjtree) ImportDeclaration */
    261   ASTImportDeclaration jjtn000 = new ASTImportDeclaration(this, JJTIMPORTDECLARATION);
    262   boolean jjtc000 = true;
    263   jjtree.openNodeScope(jjtn000);
    264     try {
    265       jj_consume_token(IMPORT);
    266       switch (jj_nt.kind) {
    267       case STATIC:
    268         jj_consume_token(STATIC);
    269                        checkForBadStaticImportUsage();jjtn000.setStatic();
    270         break;
    271       default:
    272         jj_la1[5] = jj_gen;
    273         ;
    274       }
    275       Name();
    276       switch (jj_nt.kind) {
    277       case DOT:
    278         jj_consume_token(DOT);
    279         jj_consume_token(STAR);
    280                                                                                                 jjtn000.setImportOnDemand();
    281         break;
    282       default:
    283         jj_la1[6] = jj_gen;
    284         ;
    285       }
    286       jj_consume_token(SEMICOLON);
    287     } catch (Throwable jjte000) {
    288     if (jjtc000) {
    289       jjtree.clearNodeScope(jjtn000);
    290       jjtc000 = false;
    291     } else {
    292       jjtree.popNode();
    293     }
    294     if (jjte000 instanceof RuntimeException) {
    295       {if (true) throw (RuntimeException)jjte000;}
    296     }
    297     if (jjte000 instanceof ParseException) {
    298       {if (true) throw (ParseException)jjte000;}
    299     }
    300     {if (true) throw (Error)jjte000;}
    301     } finally {
    302     if (jjtc000) {
    303       jjtree.closeNodeScope(jjtn000, true);
    304     }
    305     }
    306   }
    307
    308 /*
    309  * Modifiers. We match all modifiers in a single rule to reduce the chances of
    310  * syntax errors for simple modifier mistakes. It will also enable us to give
    311  * better error messages.
    312  */
    313   final public int Modifiers() throws ParseException {
    314    int modifiers = 0;
    315     label_4:
    316     while (true) {
    317       if (jj_2_2(2)) {
    318         ;
    319       } else {
    320         break label_4;
    321       }
    322       switch (jj_nt.kind) {
    323       case PUBLIC:
    324         jj_consume_token(PUBLIC);
    325               modifiers |= AccessNode.PUBLIC;
    326         break;
    327       case STATIC:
    328         jj_consume_token(STATIC);
    329                modifiers |= AccessNode.STATIC;
    330         break;
    331       case PROTECTED:
    332         jj_consume_token(PROTECTED);
    333                   modifiers |= AccessNode.PROTECTED;
    334         break;
    335       case PRIVATE:
    336         jj_consume_token(PRIVATE);
    337                 modifiers |= AccessNode.PRIVATE;
    338         break;
    339       case FINAL:
    340         jj_consume_token(FINAL);
    341               modifiers |= AccessNode.FINAL;
    342         break;
    343       case ABSTRACT:
    344         jj_consume_token(ABSTRACT);
    345                  modifiers |= AccessNode.ABSTRACT;
    346         break;
    347       case SYNCHRONIZED:
    348         jj_consume_token(SYNCHRONIZED);
    349                      modifiers |= AccessNode.SYNCHRONIZED;
    350         break;
    351       case NATIVE:
    352         jj_consume_token(NATIVE);
    353                modifiers |= AccessNode.NATIVE;
    354         break;
    355       case TRANSIENT:
    356         jj_consume_token(TRANSIENT);
    357                   modifiers |= AccessNode.TRANSIENT;
    358         break;
    359       case VOLATILE:
    360         jj_consume_token(VOLATILE);
    361                  modifiers |= AccessNode.VOLATILE;
    362         break;
    363       case STRICTFP:
    364         jj_consume_token(STRICTFP);
    365                  modifiers |= AccessNode.STRICTFP;
    366         break;
    367       case AT:
    368         Annotation();
    369         break;
    370       default:
    371         jj_la1[7] = jj_gen;
    372         jj_consume_token(-1);
    373         throw new ParseException();
    374       }
    375     }
    376     {if (true) return modifiers;}
    377     throw new RuntimeException("Missing return statement in function");
    378   }
    379
    380 /*
    381  * Declaration syntax follows.
    382  */
    383   final public void TypeDeclaration() throws ParseException {
    384  /*@bgen(jjtree) TypeDeclaration */
    385    ASTTypeDeclaration jjtn000 = new ASTTypeDeclaration(this, JJTTYPEDECLARATION);
    386    boolean jjtc000 = true;
    387    jjtree.openNodeScope(jjtn000);int modifiers;
    388     try {
    389       switch (jj_nt.kind) {
    390       case SEMICOLON:
    391         jj_consume_token(SEMICOLON);
    392         break;
    393       case ABSTRACT:
    394       case CLASS:
    395       case FINAL:
    396       case INTERFACE:
    397       case NATIVE:
    398       case PRIVATE:
    399       case PROTECTED:
    400       case PUBLIC:
    401       case STATIC:
    402       case SYNCHRONIZED:
    403       case TRANSIENT:
    404       case VOLATILE:
    405       case STRICTFP:
    406       case IDENTIFIER:
    407       case AT:
    408         modifiers = Modifiers();
    409         switch (jj_nt.kind) {
    410         case ABSTRACT:
    411         case CLASS:
    412         case FINAL:
    413         case INTERFACE:
    414           ClassOrInterfaceDeclaration(modifiers);
    415           break;
    416         case IDENTIFIER:
    417           EnumDeclaration(modifiers);
    418           break;
    419         case AT:
    420           AnnotationTypeDeclaration(modifiers);
    421           break;
    422         default:
    423           jj_la1[8] = jj_gen;
    424           jj_consume_token(-1);
    425           throw new ParseException();
    426         }
    427         break;
    428       default:
    429         jj_la1[9] = jj_gen;
    430         jj_consume_token(-1);
    431         throw new ParseException();
    432       }
    433     } catch (Throwable jjte000) {
    434     if (jjtc000) {
    435       jjtree.clearNodeScope(jjtn000);
    436       jjtc000 = false;
    437     } else {
    438       jjtree.popNode();
    439     }
    440     if (jjte000 instanceof RuntimeException) {
    441       {if (true) throw (RuntimeException)jjte000;}
    442     }
    443     if (jjte000 instanceof ParseException) {
    444       {if (true) throw (ParseException)jjte000;}
    445     }
    446     {if (true) throw (Error)jjte000;}
    447     } finally {
    448     if (jjtc000) {
    449       jjtree.closeNodeScope(jjtn000, true);
    450     }
    451     }
    452   }
    453
    454   final public void ClassOrInterfaceDeclaration(int modifiers) throws ParseException {
    455  /*@bgen(jjtree) ClassOrInterfaceDeclaration */
    456 ASTClassOrInterfaceDeclaration jjtn000 = new ASTClassOrInterfaceDeclaration(this, JJTCLASSORINTERFACEDECLARATION);
    457 boolean jjtc000 = true;
    458 jjtree.openNodeScope(jjtn000);Token t = null;
    459 jjtn000.setModifiers(modifiers);
    460     try {
    461       switch (jj_nt.kind) {
    462       case ABSTRACT:
    463       case CLASS:
    464       case FINAL:
    465         switch (jj_nt.kind) {
    466         case ABSTRACT:
    467         case FINAL:
    468           switch (jj_nt.kind) {
    469           case FINAL:
    470             jj_consume_token(FINAL);
    471             break;
    472           case ABSTRACT:
    473             jj_consume_token(ABSTRACT);
    474             break;
    475           default:
    476             jj_la1[10] = jj_gen;
    477             jj_consume_token(-1);
    478             throw new ParseException();
    479           }
    480           break;
    481         default:
    482           jj_la1[11] = jj_gen;
    483           ;
    484         }
    485         jj_consume_token(CLASS);
    486         break;
    487       case INTERFACE:
    488         jj_consume_token(INTERFACE);
    489                                                                                                                      jjtn000.setInterface();
    490         break;
    491       default:
    492         jj_la1[12] = jj_gen;
    493         jj_consume_token(-1);
    494         throw new ParseException();
    495       }
    496       t = jj_consume_token(IDENTIFIER);
    497                    jjtn000.setImage(t.image);
    498       switch (jj_nt.kind) {
    499       case LT:
    500         TypeParameters();
    501         break;
    502       default:
    503         jj_la1[13] = jj_gen;
    504         ;
    505       }
    506       switch (jj_nt.kind) {
    507       case EXTENDS:
    508         ExtendsList();
    509         break;
    510       default:
    511         jj_la1[14] = jj_gen;
    512         ;
    513       }
    514       switch (jj_nt.kind) {
    515       case IMPLEMENTS:
    516         ImplementsList();
    517         break;
    518       default:
    519         jj_la1[15] = jj_gen;
    520         ;
    521       }
    522       ClassOrInterfaceBody();
    523     } catch (Throwable jjte000) {
    524     if (jjtc000) {
    525       jjtree.clearNodeScope(jjtn000);
    526       jjtc000 = false;
    527     } else {
    528       jjtree.popNode();
    529     }
    530     if (jjte000 instanceof RuntimeException) {
    531       {if (true) throw (RuntimeException)jjte000;}
    532     }
    533     if (jjte000 instanceof ParseException) {
    534       {if (true) throw (ParseException)jjte000;}
    535     }
    536     {if (true) throw (Error)jjte000;}
    537     } finally {
    538     if (jjtc000) {
    539       jjtree.closeNodeScope(jjtn000, true);
    540     }
    541     }
    542   }
    543
    544   final public void ExtendsList() throws ParseException {
    545  /*@bgen(jjtree) ExtendsList */
    546    ASTExtendsList jjtn000 = new ASTExtendsList(this, JJTEXTENDSLIST);
    547    boolean jjtc000 = true;
    548    jjtree.openNodeScope(jjtn000);boolean extendsMoreThanOne = false;
    549     try {
    550       jj_consume_token(EXTENDS);
    551       ClassOrInterfaceType();
    552       label_5:
    553       while (true) {
    554         switch (jj_nt.kind) {
    555         case COMMA:
    556           ;
    557           break;
    558         default:
    559           jj_la1[16] = jj_gen;
    560           break label_5;
    561         }
    562         jj_consume_token(COMMA);
    563         ClassOrInterfaceType();
    564                                   extendsMoreThanOne = true;
    565       }
    566     } catch (Throwable jjte000) {
    567      if (jjtc000) {
    568        jjtree.clearNodeScope(jjtn000);
    569        jjtc000 = false;
    570      } else {
    571        jjtree.popNode();
    572      }
    573      if (jjte000 instanceof RuntimeException) {
    574        {if (true) throw (RuntimeException)jjte000;}
    575      }
    576      if (jjte000 instanceof ParseException) {
    577        {if (true) throw (ParseException)jjte000;}
    578      }
    579      {if (true) throw (Error)jjte000;}
    580     } finally {
    581      if (jjtc000) {
    582        jjtree.closeNodeScope(jjtn000, true);
    583      }
    584     }
    585   }
    586
    587   final public void ImplementsList() throws ParseException {
    588  /*@bgen(jjtree) ImplementsList */
    589   ASTImplementsList jjtn000 = new ASTImplementsList(this, JJTIMPLEMENTSLIST);
    590   boolean jjtc000 = true;
    591   jjtree.openNodeScope(jjtn000);
    592     try {
    593       jj_consume_token(IMPLEMENTS);
    594       ClassOrInterfaceType();
    595       label_6:
    596       while (true) {
    597         switch (jj_nt.kind) {
    598         case COMMA:
    599           ;
    600           break;
    601         default:
    602           jj_la1[17] = jj_gen;
    603           break label_6;
    604         }
    605         jj_consume_token(COMMA);
    606         ClassOrInterfaceType();
    607       }
    608     } catch (Throwable jjte000) {
    609      if (jjtc000) {
    610        jjtree.clearNodeScope(jjtn000);
    611        jjtc000 = false;
    612      } else {
    613        jjtree.popNode();
    614      }
    615      if (jjte000 instanceof RuntimeException) {
    616        {if (true) throw (RuntimeException)jjte000;}
    617      }
    618      if (jjte000 instanceof ParseException) {
    619        {if (true) throw (ParseException)jjte000;}
    620      }
    621      {if (true) throw (Error)jjte000;}
    622     } finally {
    623      if (jjtc000) {
    624        jjtree.closeNodeScope(jjtn000, true);
    625      }
    626     }
    627   }
    628
    629   final public void EnumDeclaration(int modifiers) throws ParseException {
    630  /*@bgen(jjtree) EnumDeclaration */
    631 ASTEnumDeclaration jjtn000 = new ASTEnumDeclaration(this, JJTENUMDECLARATION);
    632 boolean jjtc000 = true;
    633 jjtree.openNodeScope(jjtn000);Token t;
    634 jjtn000.setModifiers(modifiers);
    635     try {
    636       t = jj_consume_token(IDENTIFIER);
    637     if (!t.image.equals("enum")) {
    638       {if (true) throw new ParseException("ERROR: expecting enum");}
    639     }
    640
    641     if (jdkVersion < 5) {
    642       {if (true) throw new ParseException("ERROR: Can't use enum as a keyword in pre-JDK 1.5 target");}
    643     }
    644       t = jj_consume_token(IDENTIFIER);
    645                   jjtn000.setImage(t.image);
    646       switch (jj_nt.kind) {
    647       case IMPLEMENTS:
    648         ImplementsList();
    649         break;
    650       default:
    651         jj_la1[18] = jj_gen;
    652         ;
    653       }
    654       EnumBody();
    655     } catch (Throwable jjte000) {
    656     if (jjtc000) {
    657       jjtree.clearNodeScope(jjtn000);
    658       jjtc000 = false;
    659     } else {
    660       jjtree.popNode();
    661     }
    662     if (jjte000 instanceof RuntimeException) {
    663       {if (true) throw (RuntimeException)jjte000;}
    664     }
    665     if (jjte000 instanceof ParseException) {
    666       {if (true) throw (ParseException)jjte000;}
    667     }
    668     {if (true) throw (Error)jjte000;}
    669     } finally {
    670     if (jjtc000) {
    671       jjtree.closeNodeScope(jjtn000, true);
    672     }
    673     }
    674   }
    675
    676   final public void EnumBody() throws ParseException {
    677  /*@bgen(jjtree) EnumBody */
    678   ASTEnumBody jjtn000 = new ASTEnumBody(this, JJTENUMBODY);
    679   boolean jjtc000 = true;
    680   jjtree.openNodeScope(jjtn000);
    681     try {
    682       jj_consume_token(LBRACE);
    683       switch (jj_nt.kind) {
    684       case IDENTIFIER:
    685       case AT:
    686         label_7:
    687         while (true) {
    688           switch (jj_nt.kind) {
    689           case AT:
    690             ;
    691             break;
    692           default:
    693             jj_la1[19] = jj_gen;
    694             break label_7;
    695           }
    696           Annotation();
    697         }
    698         EnumConstant();
    699         label_8:
    700         while (true) {
    701           if (jj_2_3(2)) {
    702             ;
    703           } else {
    704             break label_8;
    705           }
    706           jj_consume_token(COMMA);
    707           label_9:
    708           while (true) {
    709             switch (jj_nt.kind) {
    710             case AT:
    711               ;
    712               break;
    713             default:
    714               jj_la1[20] = jj_gen;
    715               break label_9;
    716             }
    717             Annotation();
    718           }
    719           EnumConstant();
    720         }
    721         break;
    722       default:
    723         jj_la1[21] = jj_gen;
    724         ;
    725       }
    726       switch (jj_nt.kind) {
    727       case COMMA:
    728         jj_consume_token(COMMA);
    729         break;
    730       default:
    731         jj_la1[22] = jj_gen;
    732         ;
    733       }
    734       switch (jj_nt.kind) {
    735       case SEMICOLON:
    736         jj_consume_token(SEMICOLON);
    737         label_10:
    738         while (true) {
    739           switch (jj_nt.kind) {
    740           case ABSTRACT:
    741           case BOOLEAN:
    742           case BYTE:
    743           case CHAR:
    744           case CLASS:
    745           case DOUBLE:
    746           case FINAL:
    747           case FLOAT:
    748           case INT:
    749           case INTERFACE:
    750           case LONG:
    751           case NATIVE:
    752           case PRIVATE:
    753           case PROTECTED:
    754           case PUBLIC:
    755           case SHORT:
    756           case STATIC:
    757           case SYNCHRONIZED:
    758           case TRANSIENT:
    759           case VOID:
    760           case VOLATILE:
    761           case STRICTFP:
    762           case IDENTIFIER:
    763           case LBRACE:
    764           case SEMICOLON:
    765           case AT:
    766           case LT:
    767             ;
    768             break;
    769           default:
    770             jj_la1[23] = jj_gen;
    771             break label_10;
    772           }
    773           ClassOrInterfaceBodyDeclaration();
    774         }
    775         break;
    776       default:
    777         jj_la1[24] = jj_gen;
    778         ;
    779       }
    780       jj_consume_token(RBRACE);
    781     } catch (Throwable jjte000) {
    782      if (jjtc000) {
    783        jjtree.clearNodeScope(jjtn000);
    784        jjtc000 = false;
    785      } else {
    786        jjtree.popNode();
    787      }
    788      if (jjte000 instanceof RuntimeException) {
    789        {if (true) throw (RuntimeException)jjte000;}
    790      }
    791      if (jjte000 instanceof ParseException) {
    792        {if (true) throw (ParseException)jjte000;}
    793      }
    794      {if (true) throw (Error)jjte000;}
    795     } finally {
    796      if (jjtc000) {
    797        jjtree.closeNodeScope(jjtn000, true);
    798      }
    799     }
    800   }
    801
    802   final public void EnumConstant() throws ParseException {
    803  /*@bgen(jjtree) EnumConstant */
    804  ASTEnumConstant jjtn000 = new ASTEnumConstant(this, JJTENUMCONSTANT);
    805  boolean jjtc000 = true;
    806  jjtree.openNodeScope(jjtn000);Token t;
    807     try {
    808       t = jj_consume_token(IDENTIFIER);
    809                   jjtn000.setImage(t.image);
    810       switch (jj_nt.kind) {
    811       case LPAREN:
    812         Arguments();
    813         break;
    814       default:
    815         jj_la1[25] = jj_gen;
    816         ;
    817       }
    818       switch (jj_nt.kind) {
    819       case LBRACE:
    820         ClassOrInterfaceBody();
    821         break;
    822       default:
    823         jj_la1[26] = jj_gen;
    824         ;
    825       }
    826     } catch (Throwable jjte000) {
    827     if (jjtc000) {
    828       jjtree.clearNodeScope(jjtn000);
    829       jjtc000 = false;
    830     } else {
    831       jjtree.popNode();
    832     }
    833     if (jjte000 instanceof RuntimeException) {
    834       {if (true) throw (RuntimeException)jjte000;}
    835     }
    836     if (jjte000 instanceof ParseException) {
    837       {if (true) throw (ParseException)jjte000;}
    838     }
    839     {if (true) throw (Error)jjte000;}
    840     } finally {
    841     if (jjtc000) {
    842       jjtree.closeNodeScope(jjtn000, true);
    843     }
    844     }
    845   }
    846
    847   final public void TypeParameters() throws ParseException {
    848  /*@bgen(jjtree) TypeParameters */
    849   ASTTypeParameters jjtn000 = new ASTTypeParameters(this, JJTTYPEPARAMETERS);
    850   boolean jjtc000 = true;
    851   jjtree.openNodeScope(jjtn000);
    852     try {
    853       jj_consume_token(LT);
    854         checkForBadGenericsUsage();
    855       TypeParameter();
    856       label_11:
    857       while (true) {
    858         switch (jj_nt.kind) {
    859         case COMMA:
    860           ;
    861           break;
    862         default:
    863           jj_la1[27] = jj_gen;
    864           break label_11;
    865         }
    866         jj_consume_token(COMMA);
    867         TypeParameter();
    868       }
    869       jj_consume_token(GT);
    870     } catch (Throwable jjte000) {
    871      if (jjtc000) {
    872        jjtree.clearNodeScope(jjtn000);
    873        jjtc000 = false;
    874      } else {
    875        jjtree.popNode();
    876      }
    877      if (jjte000 instanceof RuntimeException) {
    878        {if (true) throw (RuntimeException)jjte000;}
    879      }
    880      if (jjte000 instanceof ParseException) {
    881        {if (true) throw (ParseException)jjte000;}
    882      }
    883      {if (true) throw (Error)jjte000;}
    884     } finally {
    885      if (jjtc000) {
    886        jjtree.closeNodeScope(jjtn000, true);
    887      }
    888     }
    889   }
    890
    891   final public void TypeParameter() throws ParseException {
    892  /*@bgen(jjtree) TypeParameter */
    893  ASTTypeParameter jjtn000 = new ASTTypeParameter(this, JJTTYPEPARAMETER);
    894  boolean jjtc000 = true;
    895  jjtree.openNodeScope(jjtn000);Token t;
    896     try {
    897       t = jj_consume_token(IDENTIFIER);
    898                    jjtn000.setImage(t.image);
    899       switch (jj_nt.kind) {
    900       case EXTENDS:
    901         TypeBound();
    902         break;
    903       default:
    904         jj_la1[28] = jj_gen;
    905         ;
    906       }
    907     } catch (Throwable jjte000) {
    908      if (jjtc000) {
    909        jjtree.clearNodeScope(jjtn000);
    910        jjtc000 = false;
    911      } else {
    912        jjtree.popNode();
    913      }
    914      if (jjte000 instanceof RuntimeException) {
    915        {if (true) throw (RuntimeException)jjte000;}
    916      }
    917      if (jjte000 instanceof ParseException) {
    918        {if (true) throw (ParseException)jjte000;}
    919      }
    920      {if (true) throw (Error)jjte000;}
    921     } finally {
    922      if (jjtc000) {
    923        jjtree.closeNodeScope(jjtn000, true);
    924      }
    925     }
    926   }
    927
    928   final public void TypeBound() throws ParseException {
    929  /*@bgen(jjtree) TypeBound */
    930   ASTTypeBound jjtn000 = new ASTTypeBound(this, JJTTYPEBOUND);
    931   boolean jjtc000 = true;
    932   jjtree.openNodeScope(jjtn000);
    933     try {
    934       jj_consume_token(EXTENDS);
    935       ClassOrInterfaceType();
    936       label_12:
    937       while (true) {
    938         switch (jj_nt.kind) {
    939         case BIT_AND:
    940           ;
    941           break;
    942         default:
    943           jj_la1[29] = jj_gen;
    944           break label_12;
    945         }
    946         jj_consume_token(BIT_AND);
    947         ClassOrInterfaceType();
    948       }
    949     } catch (Throwable jjte000) {
    950      if (jjtc000) {
    951        jjtree.clearNodeScope(jjtn000);
    952        jjtc000 = false;
    953      } else {
    954        jjtree.popNode();
    955      }
    956      if (jjte000 instanceof RuntimeException) {
    957        {if (true) throw (RuntimeException)jjte000;}
    958      }
    959      if (jjte000 instanceof ParseException) {
    960        {if (true) throw (ParseException)jjte000;}
    961      }
    962      {if (true) throw (Error)jjte000;}
    963     } finally {
    964      if (jjtc000) {
    965        jjtree.closeNodeScope(jjtn000, true);
    966      }
    967     }
    968   }
    969
    970   final public void ClassOrInterfaceBody() throws ParseException {
    971  /*@bgen(jjtree) ClassOrInterfaceBody */
    972   ASTClassOrInterfaceBody jjtn000 = new ASTClassOrInterfaceBody(this, JJTCLASSORINTERFACEBODY);
    973   boolean jjtc000 = true;
    974   jjtree.openNodeScope(jjtn000);
    975     try {
    976       jj_consume_token(LBRACE);
    977       label_13:
    978       while (true) {
    979         switch (jj_nt.kind) {
    980         case ABSTRACT:
    981         case BOOLEAN:
    982         case BYTE:
    983         case CHAR:
    984         case CLASS:
    985         case DOUBLE:
    986         case FINAL:
    987         case FLOAT:
    988         case INT:
    989         case INTERFACE:
    990         case LONG:
    991         case NATIVE:
    992         case PRIVATE:
    993         case PROTECTED:
    994         case PUBLIC:
    995         case SHORT:
    996         case STATIC:
    997         case SYNCHRONIZED:
    998         case TRANSIENT:
    999         case VOID:
    1000         case VOLATILE:
    1001         case STRICTFP:
    1002         case IDENTIFIER:
    1003         case LBRACE:
    1004         case SEMICOLON:
    1005         case AT:
    1006         case LT:
    1007           ;
    1008           break;
    1009         default:
    1010           jj_la1[30] = jj_gen;
    1011           break label_13;
    1012         }
    1013         ClassOrInterfaceBodyDeclaration();
    1014       }
    1015       jj_consume_token(RBRACE);
    1016     } catch (Throwable jjte000) {
    1017     if (jjtc000) {
    1018       jjtree.clearNodeScope(jjtn000);
    1019       jjtc000 = false;
    1020     } else {
    1021       jjtree.popNode();
    1022     }
    1023     if (jjte000 instanceof RuntimeException) {
    1024       {if (true) throw (RuntimeException)jjte000;}
    1025     }
    1026     if (jjte000 instanceof ParseException) {
    1027       {if (true) throw (ParseException)jjte000;}
    1028     }
    1029     {if (true) throw (Error)jjte000;}
    1030     } finally {
    1031     if (jjtc000) {
    1032       jjtree.closeNodeScope(jjtn000, true);
    1033     }
    1034     }
    1035   }
    1036
    1037   final public void ClassOrInterfaceBodyDeclaration() throws ParseException {
    1038  /*@bgen(jjtree) ClassOrInterfaceBodyDeclaration */
    1039    ASTClassOrInterfaceBodyDeclaration jjtn000 = new ASTClassOrInterfaceBodyDeclaration(this, JJTCLASSORINTERFACEBODYDECLARATION);
    1040    boolean jjtc000 = true;
    1041    jjtree.openNodeScope(jjtn000);int modifiers;
    1042     try {
    1043       if (jj_2_8(2147483647)) {
    1044         Initializer();
    1045       } else {
    1046         switch (jj_nt.kind) {
    1047         case ABSTRACT:
    1048         case BOOLEAN:
    1049         case BYTE:
    1050         case CHAR:
    1051         case CLASS:
    1052         case DOUBLE:
    1053         case FINAL:
    1054         case FLOAT:
    1055         case INT:
    1056         case INTERFACE:
    1057         case LONG:
    1058         case NATIVE:
    1059         case PRIVATE:
    1060         case PROTECTED:
    1061         case PUBLIC:
    1062         case SHORT:
    1063         case STATIC:
    1064         case SYNCHRONIZED:
    1065         case TRANSIENT:
    1066         case VOID:
    1067         case VOLATILE:
    1068         case STRICTFP:
    1069         case IDENTIFIER:
    1070         case AT:
    1071         case LT:
    1072           modifiers = Modifiers();
    1073           if (jj_2_4(3)) {
    1074             ClassOrInterfaceDeclaration(modifiers);
    1075           } else if (jj_2_5(3)) {
    1076             EnumDeclaration(modifiers);
    1077           } else if (jj_2_6(2147483647)) {
    1078             ConstructorDeclaration(modifiers);
    1079           } else if (jj_2_7(2147483647)) {
    1080             FieldDeclaration(modifiers);
    1081           } else {
    1082             switch (jj_nt.kind) {
    1083             case BOOLEAN:
    1084             case BYTE:
    1085             case CHAR:
    1086             case DOUBLE:
    1087             case FLOAT:
    1088             case INT:
    1089             case LONG:
    1090             case SHORT:
    1091             case VOID:
    1092             case IDENTIFIER:
    1093             case LT:
    1094               MethodDeclaration(modifiers);
    1095               break;
    1096             case AT:
    1097               AnnotationTypeDeclaration(modifiers);
    1098               break;
    1099             default:
    1100               jj_la1[31] = jj_gen;
    1101               jj_consume_token(-1);
    1102               throw new ParseException();
    1103             }
    1104           }
    1105           break;
    1106         case SEMICOLON:
    1107           jj_consume_token(SEMICOLON);
    1108           break;
    1109         default:
    1110           jj_la1[32] = jj_gen;
    1111           jj_consume_token(-1);
    1112           throw new ParseException();
    1113         }
    1114       }
    1115     } catch (Throwable jjte000) {
    1116     if (jjtc000) {
    1117       jjtree.clearNodeScope(jjtn000);
    1118       jjtc000 = false;
    1119     } else {
    1120       jjtree.popNode();
    1121     }
    1122     if (jjte000 instanceof RuntimeException) {
    1123       {if (true) throw (RuntimeException)jjte000;}
    1124     }
    1125     if (jjte000 instanceof ParseException) {
    1126       {if (true) throw (ParseException)jjte000;}
    1127     }
    1128     {if (true) throw (Error)jjte000;}
    1129     } finally {
    1130     if (jjtc000) {
    1131       jjtree.closeNodeScope(jjtn000, true);
    1132     }
    1133     }
    1134   }
    1135
    1136   final public void FieldDeclaration(int modifiers) throws ParseException {
    1137  /*@bgen(jjtree) FieldDeclaration */
    1138  ASTFieldDeclaration jjtn000 = new ASTFieldDeclaration(this, JJTFIELDDECLARATION);
    1139  boolean jjtc000 = true;
    1140  jjtree.openNodeScope(jjtn000);jjtn000.setModifiers(modifiers);
    1141     try {
    1142       Type();
    1143       VariableDeclarator();
    1144       label_14:
    1145       while (true) {
    1146         switch (jj_nt.kind) {
    1147         case COMMA:
    1148           ;
    1149           break;
    1150         default:
    1151           jj_la1[33] = jj_gen;
    1152           break label_14;
    1153         }
    1154         jj_consume_token(COMMA);
    1155         VariableDeclarator();
    1156       }
    1157       jj_consume_token(SEMICOLON);
    1158     } catch (Throwable jjte000) {
    1159     if (jjtc000) {
    1160       jjtree.clearNodeScope(jjtn000);
    1161       jjtc000 = false;
    1162     } else {
    1163       jjtree.popNode();
    1164     }
    1165     if (jjte000 instanceof RuntimeException) {
    1166       {if (true) throw (RuntimeException)jjte000;}
    1167     }
    1168     if (jjte000 instanceof ParseException) {
    1169       {if (true) throw (ParseException)jjte000;}
    1170     }
    1171     {if (true) throw (Error)jjte000;}
    1172     } finally {
    1173     if (jjtc000) {
    1174       jjtree.closeNodeScope(jjtn000, true);
    1175     }
    1176     }
    1177   }
    1178
    1179   final public void VariableDeclarator() throws ParseException {
    1180  /*@bgen(jjtree) VariableDeclarator */
    1181   ASTVariableDeclarator jjtn000 = new ASTVariableDeclarator(this, JJTVARIABLEDECLARATOR);
    1182   boolean jjtc000 = true;
    1183   jjtree.openNodeScope(jjtn000);
    1184     try {
    1185       VariableDeclaratorId();
    1186       switch (jj_nt.kind) {
    1187       case ASSIGN:
    1188         jj_consume_token(ASSIGN);
    1189         VariableInitializer();
    1190         break;
    1191       default:
    1192         jj_la1[34] = jj_gen;
    1193         ;
    1194       }
    1195     } catch (Throwable jjte000) {
    1196     if (jjtc000) {
    1197       jjtree.clearNodeScope(jjtn000);
    1198       jjtc000 = false;
    1199     } else {
    1200       jjtree.popNode();
    1201     }
    1202     if (jjte000 instanceof RuntimeException) {
    1203       {if (true) throw (RuntimeException)jjte000;}
    1204     }
    1205     if (jjte000 instanceof ParseException) {
    1206       {if (true) throw (ParseException)jjte000;}
    1207     }
    1208     {if (true) throw (Error)jjte000;}
    1209     } finally {
    1210     if (jjtc000) {
    1211       jjtree.closeNodeScope(jjtn000, true);
    1212     }
    1213     }
    1214   }
    1215
    1216   final public void VariableDeclaratorId() throws ParseException {
    1217  /*@bgen(jjtree) VariableDeclaratorId */
    1218  ASTVariableDeclaratorId jjtn000 = new ASTVariableDeclaratorId(this, JJTVARIABLEDECLARATORID);
    1219  boolean jjtc000 = true;
    1220  jjtree.openNodeScope(jjtn000);Token t;
    1221     try {
    1222       t = jj_consume_token(IDENTIFIER);
    1223       label_15:
    1224       while (true) {
    1225         switch (jj_nt.kind) {
    1226         case LBRACKET:
    1227           ;
    1228           break;
    1229         default:
    1230           jj_la1[35] = jj_gen;
    1231           break label_15;
    1232         }
    1233         jj_consume_token(LBRACKET);
    1234         jj_consume_token(RBRACKET);
    1235                jjtn000.bumpArrayDepth();
    1236       }
    1237     jjtree.closeNodeScope(jjtn000, true);
    1238     jjtc000 = false;
    1239     checkForBadAssertUsage(t.image, "a variable name");
    1240     checkForBadEnumUsage(t.image, "a variable name");
    1241     jjtn000.setImage( t.image );
    1242     } finally {
    1243     if (jjtc000) {
    1244       jjtree.closeNodeScope(jjtn000, true);
    1245     }
    1246     }
    1247   }
    1248
    1249   final public void VariableInitializer() throws ParseException {
    1250  /*@bgen(jjtree) VariableInitializer */
    1251   ASTVariableInitializer jjtn000 = new ASTVariableInitializer(this, JJTVARIABLEINITIALIZER);
    1252   boolean jjtc000 = true;
    1253   jjtree.openNodeScope(jjtn000);
    1254     try {
    1255       switch (jj_nt.kind) {
    1256       case LBRACE:
    1257         ArrayInitializer();
    1258         break;
    1259       case BOOLEAN:
    1260       case BYTE:
    1261       case CHAR:
    1262       case DOUBLE:
    1263       case FALSE:
    1264       case FLOAT:
    1265       case INT:
    1266       case LONG:
    1267       case NEW:
    1268       case NULL:
    1269       case SHORT:
    1270       case SUPER:
    1271       case THIS:
    1272       case TRUE:
    1273       case VOID:
    1274       case INTEGER_LITERAL:
    1275       case FLOATING_POINT_LITERAL:
    1276       case HEX_FLOATING_POINT_LITERAL:
    1277       case CHARACTER_LITERAL:
    1278       case STRING_LITERAL:
    1279       case IDENTIFIER:
    1280       case LPAREN:
    1281       case BANG:
    1282       case TILDE:
    1283       case INCR:
    1284       case DECR:
    1285       case PLUS:
    1286       case MINUS:
    1287         Expression();
    1288         break;
    1289       default:
    1290         jj_la1[36] = jj_gen;
    1291         jj_consume_token(-1);
    1292         throw new ParseException();
    1293       }
    1294     } catch (Throwable jjte000) {
    1295     if (jjtc000) {
    1296       jjtree.clearNodeScope(jjtn000);
    1297       jjtc000 = false;
    1298     } else {
    1299       jjtree.popNode();
    1300     }
    1301     if (jjte000 instanceof RuntimeException) {
    1302       {if (true) throw (RuntimeException)jjte000;}
    1303     }
    1304     if (jjte000 instanceof ParseException) {
    1305       {if (true) throw (ParseException)jjte000;}
    1306     }
    1307     {if (true) throw (Error)jjte000;}
    1308     } finally {
    1309     if (jjtc000) {
    1310       jjtree.closeNodeScope(jjtn000, true);
    1311     }
    1312     }
    1313   }
    1314
    1315   final public void ArrayInitializer() throws ParseException {
    1316  /*@bgen(jjtree) ArrayInitializer */
    1317   ASTArrayInitializer jjtn000 = new ASTArrayInitializer(this, JJTARRAYINITIALIZER);
    1318   boolean jjtc000 = true;
    1319   jjtree.openNodeScope(jjtn000);
    1320     try {
    1321       jj_consume_token(LBRACE);
    1322       switch (jj_nt.kind) {
    1323       case BOOLEAN:
    1324       case BYTE:
    1325       case CHAR:
    1326       case DOUBLE:
    1327       case FALSE:
    1328       case FLOAT:
    1329       case INT:
    1330       case LONG:
    1331       case NEW:
    1332       case NULL:
    1333       case SHORT:
    1334       case SUPER:
    1335       case THIS:
    1336       case TRUE:
    1337       case VOID:
    1338       case INTEGER_LITERAL:
    1339       case FLOATING_POINT_LITERAL:
    1340       case HEX_FLOATING_POINT_LITERAL:
    1341       case CHARACTER_LITERAL:
    1342       case STRING_LITERAL:
    1343       case IDENTIFIER:
    1344       case LPAREN:
    1345       case LBRACE:
    1346       case BANG:
    1347       case TILDE:
    1348       case INCR:
    1349       case DECR:
    1350       case PLUS:
    1351       case MINUS:
    1352         VariableInitializer();
    1353         label_16:
    1354         while (true) {
    1355           if (jj_2_9(2)) {
    1356             ;
    1357           } else {
    1358             break label_16;
    1359           }
    1360           jj_consume_token(COMMA);
    1361           VariableInitializer();
    1362         }
    1363         break;
    1364       default:
    1365         jj_la1[37] = jj_gen;
    1366         ;
    1367       }
    1368       switch (jj_nt.kind) {
    1369       case COMMA:
    1370         jj_consume_token(COMMA);
    1371         break;
    1372       default:
    1373         jj_la1[38] = jj_gen;
    1374         ;
    1375       }
    1376       jj_consume_token(RBRACE);
    1377     } catch (Throwable jjte000) {
    1378     if (jjtc000) {
    1379       jjtree.clearNodeScope(jjtn000);
    1380       jjtc000 = false;
    1381     } else {
    1382       jjtree.popNode();
    1383     }
    1384     if (jjte000 instanceof RuntimeException) {
    1385       {if (true) throw (RuntimeException)jjte000;}
    1386     }
    1387     if (jjte000 instanceof ParseException) {
    1388       {if (true) throw (ParseException)jjte000;}
    1389     }
    1390     {if (true) throw (Error)jjte000;}
    1391     } finally {
    1392     if (jjtc000) {
    1393       jjtree.closeNodeScope(jjtn000, true);
    1394     }
    1395     }
    1396   }
    1397
    1398   final public void MethodDeclaration(int modifiers) throws ParseException {
    1399  /*@bgen(jjtree) MethodDeclaration */
    1400  ASTMethodDeclaration jjtn000 = new ASTMethodDeclaration(this, JJTMETHODDECLARATION);
    1401  boolean jjtc000 = true;
    1402  jjtree.openNodeScope(jjtn000);jjtn000.setModifiers(modifiers);
    1403     try {
    1404       switch (jj_nt.kind) {
    1405       case LT:
    1406         TypeParameters();
    1407         break;
    1408       default:
    1409         jj_la1[39] = jj_gen;
    1410         ;
    1411       }
    1412       ResultType();
    1413       MethodDeclarator();
    1414       switch (jj_nt.kind) {
    1415       case THROWS:
    1416         jj_consume_token(THROWS);
    1417         NameList();
    1418         break;
    1419       default:
    1420         jj_la1[40] = jj_gen;
    1421         ;
    1422       }
    1423       switch (jj_nt.kind) {
    1424       case LBRACE:
    1425         Block();
    1426         break;
    1427       case SEMICOLON:
    1428         jj_consume_token(SEMICOLON);
    1429         break;
    1430       default:
    1431         jj_la1[41] = jj_gen;
    1432         jj_consume_token(-1);
    1433         throw new ParseException();
    1434       }
    1435     } catch (Throwable jjte000) {
    1436     if (jjtc000) {
    1437       jjtree.clearNodeScope(jjtn000);
    1438       jjtc000 = false;
    1439     } else {
    1440       jjtree.popNode();
    1441     }
    1442     if (jjte000 instanceof RuntimeException) {
    1443       {if (true) throw (RuntimeException)jjte000;}
    1444     }
    1445     if (jjte000 instanceof ParseException) {
    1446       {if (true) throw (ParseException)jjte000;}
    1447     }
    1448     {if (true) throw (Error)jjte000;}
    1449     } finally {
    1450     if (jjtc000) {
    1451       jjtree.closeNodeScope(jjtn000, true);
    1452     }
    1453     }
    1454   }
    1455
    1456   final public void MethodDeclarator() throws ParseException {
    1457  /*@bgen(jjtree) MethodDeclarator */
    1458  ASTMethodDeclarator jjtn000 = new ASTMethodDeclarator(this, JJTMETHODDECLARATOR);
    1459  boolean jjtc000 = true;
    1460  jjtree.openNodeScope(jjtn000);Token t;
    1461     try {
    1462       t = jj_consume_token(IDENTIFIER);
    1463     checkForBadAssertUsage(t.image, "a method name");
    1464     checkForBadEnumUsage(t.image, "a method name");
    1465     jjtn000.setImage( t.image );
    1466       FormalParameters();
    1467       label_17:
    1468       while (true) {
    1469         switch (jj_nt.kind) {
    1470         case LBRACKET:
    1471           ;
    1472           break;
    1473         default:
    1474           jj_la1[42] = jj_gen;
    1475           break label_17;
    1476         }
    1477         jj_consume_token(LBRACKET);
    1478         jj_consume_token(RBRACKET);
    1479       }
    1480     } catch (Throwable jjte000) {
    1481     if (jjtc000) {
    1482       jjtree.clearNodeScope(jjtn000);
    1483       jjtc000 = false;
    1484     } else {
    1485       jjtree.popNode();
    1486     }
    1487     if (jjte000 instanceof RuntimeException) {
    1488       {if (true) throw (RuntimeException)jjte000;}
    1489     }
    1490     if (jjte000 instanceof ParseException) {
    1491       {if (true) throw (ParseException)jjte000;}
    1492     }
    1493     {if (true) throw (Error)jjte000;}
    1494     } finally {
    1495     if (jjtc000) {
    1496       jjtree.closeNodeScope(jjtn000, true);
    1497     }
    1498     }
    1499   }
    1500
    1501   final public void FormalParameters() throws ParseException {
    1502  /*@bgen(jjtree) FormalParameters */
    1503   ASTFormalParameters jjtn000 = new ASTFormalParameters(this, JJTFORMALPARAMETERS);
    1504   boolean jjtc000 = true;
    1505   jjtree.openNodeScope(jjtn000);
    1506     try {
    1507       jj_consume_token(LPAREN);
    1508       switch (jj_nt.kind) {
    1509       case BOOLEAN:
    1510       case BYTE:
    1511       case CHAR:
    1512       case DOUBLE:
    1513       case FINAL:
    1514       case FLOAT:
    1515       case INT:
    1516       case LONG:
    1517       case SHORT:
    1518       case IDENTIFIER:
    1519       case AT:
    1520         FormalParameter();
    1521         label_18:
    1522         while (true) {
    1523           switch (jj_nt.kind) {
    1524           case COMMA:
    1525             ;
    1526             break;
    1527           default:
    1528             jj_la1[43] = jj_gen;
    1529             break label_18;
    1530           }
    1531           jj_consume_token(COMMA);
    1532           FormalParameter();
    1533         }
    1534         break;
    1535       default:
    1536         jj_la1[44] = jj_gen;
    1537         ;
    1538       }
    1539       jj_consume_token(RPAREN);
    1540     } catch (Throwable jjte000) {
    1541     if (jjtc000) {
    1542       jjtree.clearNodeScope(jjtn000);
    1543       jjtc000 = false;
    1544     } else {
    1545       jjtree.popNode();
    1546     }
    1547     if (jjte000 instanceof RuntimeException) {
    1548       {if (true) throw (RuntimeException)jjte000;}
    1549     }
    1550     if (jjte000 instanceof ParseException) {
    1551       {if (true) throw (ParseException)jjte000;}
    1552     }
    1553     {if (true) throw (Error)jjte000;}
    1554     } finally {
    1555     if (jjtc000) {
    1556       jjtree.closeNodeScope(jjtn000, true);
    1557     }
    1558     }
    1559   }
    1560
    1561   final public void FormalParameter() throws ParseException {
    1562  /*@bgen(jjtree) FormalParameter */
    1563   ASTFormalParameter jjtn000 = new ASTFormalParameter(this, JJTFORMALPARAMETER);
    1564   boolean jjtc000 = true;
    1565   jjtree.openNodeScope(jjtn000);
    1566     try {
    1567       label_19:
    1568       while (true) {
    1569         switch (jj_nt.kind) {
    1570         case FINAL:
    1571         case AT:
    1572           ;
    1573           break;
    1574         default:
    1575           jj_la1[45] = jj_gen;
    1576           break label_19;
    1577         }
    1578         switch (jj_nt.kind) {
    1579         case FINAL:
    1580           jj_consume_token(FINAL);
    1581               jjtn000.setFinal(true);
    1582           break;
    1583         case AT:
    1584           Annotation();
    1585           break;
    1586         default:
    1587           jj_la1[46] = jj_gen;
    1588           jj_consume_token(-1);
    1589           throw new ParseException();
    1590         }
    1591       }
    1592       Type();
    1593       label_20:
    1594       while (true) {
    1595         switch (jj_nt.kind) {
    1596         case BIT_OR:
    1597           ;
    1598           break;
    1599         default:
    1600           jj_la1[47] = jj_gen;
    1601           break label_20;
    1602         }
    1603         jj_consume_token(BIT_OR);
    1604         Type();
    1605       }
    1606       switch (jj_nt.kind) {
    1607       case ELLIPSIS:
    1608         jj_consume_token(ELLIPSIS);
    1609             checkForBadVariableArgumentsUsage();
    1610                                                    jjtn000.setVarargs();
    1611         break;
    1612       default:
    1613         jj_la1[48] = jj_gen;
    1614         ;
    1615       }
    1616       VariableDeclaratorId();
    1617     } catch (Throwable jjte000) {
    1618      if (jjtc000) {
    1619        jjtree.clearNodeScope(jjtn000);
    1620        jjtc000 = false;
    1621      } else {
    1622        jjtree.popNode();
    1623      }
    1624      if (jjte000 instanceof RuntimeException) {
    1625        {if (true) throw (RuntimeException)jjte000;}
    1626      }
    1627      if (jjte000 instanceof ParseException) {
    1628        {if (true) throw (ParseException)jjte000;}
    1629      }
    1630      {if (true) throw (Error)jjte000;}
    1631     } finally {
    1632      if (jjtc000) {
    1633        jjtree.closeNodeScope(jjtn000, true);
    1634      }
    1635     }
    1636   }
    1637
    1638   final public void ConstructorDeclaration(int modifiers) throws ParseException {
    1639  /*@bgen(jjtree) ConstructorDeclaration */
    1640  ASTConstructorDeclaration jjtn000 = new ASTConstructorDeclaration(this, JJTCONSTRUCTORDECLARATION);
    1641  boolean jjtc000 = true;
    1642  jjtree.openNodeScope(jjtn000);jjtn000.setModifiers(modifiers);
    1643 Token t;
    1644     try {
    1645       switch (jj_nt.kind) {
    1646       case LT:
    1647         TypeParameters();
    1648         break;
    1649       default:
    1650         jj_la1[49] = jj_gen;
    1651         ;
    1652       }
    1653       jj_consume_token(IDENTIFIER);
    1654       FormalParameters();
    1655       switch (jj_nt.kind) {
    1656       case THROWS:
    1657         jj_consume_token(THROWS);
    1658         NameList();
    1659         break;
    1660       default:
    1661         jj_la1[50] = jj_gen;
    1662         ;
    1663       }
    1664       jj_consume_token(LBRACE);
    1665       if (jj_2_10(2147483647)) {
    1666         ExplicitConstructorInvocation();
    1667       } else {
    1668         ;
    1669       }
    1670       label_21:
    1671       while (true) {
    1672         if (jj_2_11(1)) {
    1673           ;
    1674         } else {
    1675           break label_21;
    1676         }
    1677         BlockStatement();
    1678       }
    1679       t = jj_consume_token(RBRACE);
    1680             jjtree.closeNodeScope(jjtn000, true);
    1681             jjtc000 = false;
    1682             if (isPrecededByComment(t)) { jjtn000.setContainsComment(); }
    1683     } catch (Throwable jjte000) {
    1684       if (jjtc000) {
    1685         jjtree.clearNodeScope(jjtn000);
    1686         jjtc000 = false;
    1687       } else {
    1688         jjtree.popNode();
    1689       }
    1690       if (jjte000 instanceof RuntimeException) {
    1691         {if (true) throw (RuntimeException)jjte000;}
    1692       }
    1693       if (jjte000 instanceof ParseException) {
    1694         {if (true) throw (ParseException)jjte000;}
    1695       }
    1696       {if (true) throw (Error)jjte000;}
    1697     } finally {
    1698       if (jjtc000) {
    1699         jjtree.closeNodeScope(jjtn000, true);
    1700       }
    1701     }
    1702   }
    1703
    1704   final public void ExplicitConstructorInvocation() throws ParseException {
    1705  /*@bgen(jjtree) ExplicitConstructorInvocation */
    1706   ASTExplicitConstructorInvocation jjtn000 = new ASTExplicitConstructorInvocation(this, JJTEXPLICITCONSTRUCTORINVOCATION);
    1707   boolean jjtc000 = true;
    1708   jjtree.openNodeScope(jjtn000);
    1709     try {
    1710       if (jj_2_13(2147483647)) {
    1711         jj_consume_token(THIS);
    1712                                             jjtn000.setIsThis();
    1713         Arguments();
    1714         jj_consume_token(SEMICOLON);
    1715       } else if (jj_2_14(2147483647)) {
    1716         TypeArguments();
    1717         jj_consume_token(THIS);
    1718                                                                             jjtn000.setIsThis();
    1719         Arguments();
    1720         jj_consume_token(SEMICOLON);
    1721       } else {
    1722         switch (jj_nt.kind) {
    1723         case BOOLEAN:
    1724         case BYTE:
    1725         case CHAR:
    1726         case DOUBLE:
    1727         case FALSE:
    1728         case FLOAT:
    1729         case INT:
    1730         case LONG:
    1731         case NEW:
    1732         case NULL:
    1733         case SHORT:
    1734         case SUPER:
    1735         case THIS:
    1736         case TRUE:
    1737         case VOID:
    1738         case INTEGER_LITERAL:
    1739         case FLOATING_POINT_LITERAL:
    1740         case HEX_FLOATING_POINT_LITERAL:
    1741         case CHARACTER_LITERAL:
    1742         case STRING_LITERAL:
    1743         case IDENTIFIER:
    1744         case LPAREN:
    1745         case LT:
    1746           if (jj_2_12(2147483647)) {
    1747             PrimaryExpression();
    1748             jj_consume_token(DOT);
    1749           } else {
    1750             ;
    1751           }
    1752           switch (jj_nt.kind) {
    1753           case LT:
    1754             TypeArguments();
    1755             break;
    1756           default:
    1757             jj_la1[51] = jj_gen;
    1758             ;
    1759           }
    1760           jj_consume_token(SUPER);
    1761                                                                                               jjtn000.setIsSuper();
    1762           Arguments();
    1763           jj_consume_token(SEMICOLON);
    1764           break;
    1765         default:
    1766           jj_la1[52] = jj_gen;
    1767           jj_consume_token(-1);
    1768           throw new ParseException();
    1769         }
    1770       }
    1771     } catch (Throwable jjte000) {
    1772     if (jjtc000) {
    1773       jjtree.clearNodeScope(jjtn000);
    1774       jjtc000 = false;
    1775     } else {
    1776       jjtree.popNode();
    1777     }
    1778     if (jjte000 instanceof RuntimeException) {
    1779       {if (true) throw (RuntimeException)jjte000;}
    1780     }
    1781     if (jjte000 instanceof ParseException) {
    1782       {if (true) throw (ParseException)jjte000;}
    1783     }
    1784     {if (true) throw (Error)jjte000;}
    1785     } finally {
    1786     if (jjtc000) {
    1787       jjtree.closeNodeScope(jjtn000, true);
    1788     }
    1789     }
    1790   }
    1791
    1792   final public void Initializer() throws ParseException {
    1793  /*@bgen(jjtree) Initializer */
    1794   ASTInitializer jjtn000 = new ASTInitializer(this, JJTINITIALIZER);
    1795   boolean jjtc000 = true;
    1796   jjtree.openNodeScope(jjtn000);
    1797     try {
    1798       switch (jj_nt.kind) {
    1799       case STATIC:
    1800         jj_consume_token(STATIC);
    1801               jjtn000.setStatic();
    1802         break;
    1803       default:
    1804         jj_la1[53] = jj_gen;
    1805         ;
    1806       }
    1807       Block();
    1808     } catch (Throwable jjte000) {
    1809     if (jjtc000) {
    1810       jjtree.clearNodeScope(jjtn000);
    1811       jjtc000 = false;
    1812     } else {
    1813       jjtree.popNode();
    1814     }
    1815     if (jjte000 instanceof RuntimeException) {
    1816       {if (true) throw (RuntimeException)jjte000;}
    1817     }
    1818     if (jjte000 instanceof ParseException) {
    1819       {if (true) throw (ParseException)jjte000;}
    1820     }
    1821     {if (true) throw (Error)jjte000;}
    1822     } finally {
    1823     if (jjtc000) {
    1824       jjtree.closeNodeScope(jjtn000, true);
    1825     }
    1826     }
    1827   }
    1828
    1829 /*
    1830  * Type, name and expression syntax follows.
    1831  */
    1832   final public void Type() throws ParseException {
    1833  /*@bgen(jjtree) Type */
    1834   ASTType jjtn000 = new ASTType(this, JJTTYPE);
    1835   boolean jjtc000 = true;
    1836   jjtree.openNodeScope(jjtn000);
    1837     try {
    1838       if (jj_2_15(2)) {
    1839         ReferenceType();
    1840       } else {
    1841         switch (jj_nt.kind) {
    1842         case BOOLEAN:
    1843         case BYTE:
    1844         case CHAR:
    1845         case DOUBLE:
    1846         case FLOAT:
    1847         case INT:
    1848         case LONG:
    1849         case SHORT:
    1850           PrimitiveType();
    1851           break;
    1852         default:
    1853           jj_la1[54] = jj_gen;
    1854           jj_consume_token(-1);
    1855           throw new ParseException();
    1856         }
    1857       }
    1858     } catch (Throwable jjte000) {
    1859      if (jjtc000) {
    1860        jjtree.clearNodeScope(jjtn000);
    1861        jjtc000 = false;
    1862      } else {
    1863        jjtree.popNode();
    1864      }
    1865      if (jjte000 instanceof RuntimeException) {
    1866        {if (true) throw (RuntimeException)jjte000;}
    1867      }
    1868      if (jjte000 instanceof ParseException) {
    1869        {if (true) throw (ParseException)jjte000;}
    1870      }
    1871      {if (true) throw (Error)jjte000;}
    1872     } finally {
    1873      if (jjtc000) {
    1874        jjtree.closeNodeScope(jjtn000, true);
    1875      }
    1876     }
    1877   }
    1878
    1879   final public void ReferenceType() throws ParseException {
    1880  /*@bgen(jjtree) ReferenceType */
    1881   ASTReferenceType jjtn000 = new ASTReferenceType(this, JJTREFERENCETYPE);
    1882   boolean jjtc000 = true;
    1883   jjtree.openNodeScope(jjtn000);
    1884     try {
    1885       switch (jj_nt.kind) {
    1886       case BOOLEAN:
    1887       case BYTE:
    1888       case CHAR:
    1889       case DOUBLE:
    1890       case FLOAT:
    1891       case INT:
    1892       case LONG:
    1893       case SHORT:
    1894         PrimitiveType();
    1895         label_22:
    1896         while (true) {
    1897           jj_consume_token(LBRACKET);
    1898           jj_consume_token(RBRACKET);
    1899                                             jjtn000.bumpArrayDepth();
    1900           if (jj_2_16(2)) {
    1901             ;
    1902           } else {
    1903             break label_22;
    1904           }
    1905         }
    1906         break;
    1907       case IDENTIFIER:
    1908         ClassOrInterfaceType();
    1909         label_23:
    1910         while (true) {
    1911           if (jj_2_17(2)) {
    1912             ;
    1913           } else {
    1914             break label_23;
    1915           }
    1916           jj_consume_token(LBRACKET);
    1917           jj_consume_token(RBRACKET);
    1918                                                        jjtn000.bumpArrayDepth();
    1919         }
    1920         break;
    1921       default:
    1922         jj_la1[55] = jj_gen;
    1923         jj_consume_token(-1);
    1924         throw new ParseException();
    1925       }
    1926     } catch (Throwable jjte000) {
    1927      if (jjtc000) {
    1928        jjtree.clearNodeScope(jjtn000);
    1929        jjtc000 = false;
    1930      } else {
    1931        jjtree.popNode();
    1932      }
    1933      if (jjte000 instanceof RuntimeException) {
    1934        {if (true) throw (RuntimeException)jjte000;}
    1935      }
    1936      if (jjte000 instanceof ParseException) {
    1937        {if (true) throw (ParseException)jjte000;}
    1938      }
    1939      {if (true) throw (Error)jjte000;}
    1940     } finally {
    1941      if (jjtc000) {
    1942        jjtree.closeNodeScope(jjtn000, true);
    1943      }
    1944     }
    1945   }
    1946
    1947   final public void ClassOrInterfaceType() throws ParseException {
    1948  /*@bgen(jjtree) ClassOrInterfaceType */
    1949   ASTClassOrInterfaceType jjtn000 = new ASTClassOrInterfaceType(this, JJTCLASSORINTERFACETYPE);
    1950   boolean jjtc000 = true;
    1951   jjtree.openNodeScope(jjtn000);StringBuffer s = new StringBuffer();
    1952   Token t;
    1953     try {
    1954       t = jj_consume_token(IDENTIFIER);
    1955                   s.append(t.image);
    1956       if (jj_2_18(2)) {
    1957         TypeArguments();
    1958       } else {
    1959         ;
    1960       }
    1961       label_24:
    1962       while (true) {
    1963         if (jj_2_19(2)) {
    1964           ;
    1965         } else {
    1966           break label_24;
    1967         }
    1968         jj_consume_token(DOT);
    1969         t = jj_consume_token(IDENTIFIER);
    1970                                      s.append('.').append(t.image);
    1971         if (jj_2_20(2)) {
    1972           TypeArguments();
    1973         } else {
    1974           ;
    1975         }
    1976       }
    1977     jjtree.closeNodeScope(jjtn000, true);
    1978     jjtc000 = false;
    1979    jjtn000.setImage(s.toString());
    1980     } catch (Throwable jjte000) {
    1981     if (jjtc000) {
    1982       jjtree.clearNodeScope(jjtn000);
    1983       jjtc000 = false;
    1984     } else {
    1985       jjtree.popNode();
    1986     }
    1987     if (jjte000 instanceof RuntimeException) {
    1988       {if (true) throw (RuntimeException)jjte000;}
    1989     }
    1990     if (jjte000 instanceof ParseException) {
    1991       {if (true) throw (ParseException)jjte000;}
    1992     }
    1993     {if (true) throw (Error)jjte000;}
    1994     } finally {
    1995     if (jjtc000) {
    1996       jjtree.closeNodeScope(jjtn000, true);
    1997     }
    1998     }
    1999   }
    2000
    2001   final public void TypeArguments() throws ParseException {
    2002  /*@bgen(jjtree) TypeArguments */
    2003   ASTTypeArguments jjtn000 = new ASTTypeArguments(this, JJTTYPEARGUMENTS);
    2004   boolean jjtc000 = true;
    2005   jjtree.openNodeScope(jjtn000);
    2006     try {
    2007       if (jj_2_21(2)) {
    2008         jj_consume_token(LT);
    2009         checkForBadGenericsUsage();
    2010         TypeArgument();
    2011         label_25:
    2012         while (true) {
    2013           switch (jj_nt.kind) {
    2014           case COMMA:
    2015             ;
    2016             break;
    2017           default:
    2018             jj_la1[56] = jj_gen;
    2019             break label_25;
    2020           }
    2021           jj_consume_token(COMMA);
    2022           TypeArgument();
    2023         }
    2024         jj_consume_token(GT);
    2025       } else {
    2026         switch (jj_nt.kind) {
    2027         case LT:
    2028           jj_consume_token(LT);
    2029         checkForBadDiamondUsage();
    2030           jj_consume_token(GT);
    2031           break;
    2032         default:
    2033           jj_la1[57] = jj_gen;
    2034           jj_consume_token(-1);
    2035           throw new ParseException();
    2036         }
    2037       }
    2038     } catch (Throwable jjte000) {
    2039      if (jjtc000) {
    2040        jjtree.clearNodeScope(jjtn000);
    2041        jjtc000 = false;
    2042      } else {
    2043        jjtree.popNode();
    2044      }
    2045      if (jjte000 instanceof RuntimeException) {
    2046        {if (true) throw (RuntimeException)jjte000;}
    2047      }
    2048      if (jjte000 instanceof ParseException) {
    2049        {if (true) throw (ParseException)jjte000;}
    2050      }
    2051      {if (true) throw (Error)jjte000;}
    2052     } finally {
    2053      if (jjtc000) {
    2054        jjtree.closeNodeScope(jjtn000, true);
    2055      }
    2056     }
    2057   }
    2058
    2059   final public void TypeArgument() throws ParseException {
    2060  /*@bgen(jjtree) TypeArgument */
    2061   ASTTypeArgument jjtn000 = new ASTTypeArgument(this, JJTTYPEARGUMENT);
    2062   boolean jjtc000 = true;
    2063   jjtree.openNodeScope(jjtn000);
    2064     try {
    2065       switch (jj_nt.kind) {
    2066       case BOOLEAN:
    2067       case BYTE:
    2068       case CHAR:
    2069       case DOUBLE:
    2070       case FLOAT:
    2071       case INT:
    2072       case LONG:
    2073       case SHORT:
    2074       case IDENTIFIER:
    2075         ReferenceType();
    2076         break;
    2077       case HOOK:
    2078         jj_consume_token(HOOK);
    2079         switch (jj_nt.kind) {
    2080         case EXTENDS:
    2081         case SUPER:
    2082           WildcardBounds();
    2083           break;
    2084         default:
    2085           jj_la1[58] = jj_gen;
    2086           ;
    2087         }
    2088         break;
    2089       default:
    2090         jj_la1[59] = jj_gen;
    2091         jj_consume_token(-1);
    2092         throw new ParseException();
    2093       }
    2094     } catch (Throwable jjte000) {
    2095      if (jjtc000) {
    2096        jjtree.clearNodeScope(jjtn000);
    2097        jjtc000 = false;
    2098      } else {
    2099        jjtree.popNode();
    2100      }
    2101      if (jjte000 instanceof RuntimeException) {
    2102        {if (true) throw (RuntimeException)jjte000;}
    2103      }
    2104      if (jjte000 instanceof ParseException) {
    2105        {if (true) throw (ParseException)jjte000;}
    2106      }
    2107      {if (true) throw (Error)jjte000;}
    2108     } finally {
    2109      if (jjtc000) {
    2110        jjtree.closeNodeScope(jjtn000, true);
    2111      }
    2112     }
    2113   }
    2114
    2115   final public void WildcardBounds() throws ParseException {
    2116  /*@bgen(jjtree) WildcardBounds */
    2117   ASTWildcardBounds jjtn000 = new ASTWildcardBounds(this, JJTWILDCARDBOUNDS);
    2118   boolean jjtc000 = true;
    2119   jjtree.openNodeScope(jjtn000);
    2120     try {
    2121       switch (jj_nt.kind) {
    2122       case EXTENDS:
    2123         jj_consume_token(EXTENDS);
    2124         ReferenceType();
    2125         break;
    2126       case SUPER:
    2127         jj_consume_token(SUPER);
    2128         ReferenceType();
    2129         break;
    2130       default:
    2131         jj_la1[60] = jj_gen;
    2132         jj_consume_token(-1);
    2133         throw new ParseException();
    2134       }
    2135     } catch (Throwable jjte000) {
    2136      if (jjtc000) {
    2137        jjtree.clearNodeScope(jjtn000);
    2138        jjtc000 = false;
    2139      } else {
    2140        jjtree.popNode();
    2141      }
    2142      if (jjte000 instanceof RuntimeException) {
    2143        {if (true) throw (RuntimeException)jjte000;}
    2144      }
    2145      if (jjte000 instanceof ParseException) {
    2146        {if (true) throw (ParseException)jjte000;}
    2147      }
    2148      {if (true) throw (Error)jjte000;}
    2149     } finally {
    2150      if (jjtc000) {
    2151        jjtree.closeNodeScope(jjtn000, true);
    2152      }
    2153     }
    2154   }
    2155
    2156   final public void PrimitiveType() throws ParseException {
    2157  /*@bgen(jjtree) PrimitiveType */
    2158   ASTPrimitiveType jjtn000 = new ASTPrimitiveType(this, JJTPRIMITIVETYPE);
    2159   boolean jjtc000 = true;
    2160   jjtree.openNodeScope(jjtn000);
    2161     try {
    2162       switch (jj_nt.kind) {
    2163       case BOOLEAN:
    2164         jj_consume_token(BOOLEAN);
    2165               jjtree.closeNodeScope(jjtn000, true);
    2166               jjtc000 = false;
    2167              jjtn000.setImage("boolean");
    2168         break;
    2169       case CHAR:
    2170         jj_consume_token(CHAR);
    2171            jjtree.closeNodeScope(jjtn000, true);
    2172            jjtc000 = false;
    2173           jjtn000.setImage("char");
    2174         break;
    2175       case BYTE:
    2176         jj_consume_token(BYTE);
    2177            jjtree.closeNodeScope(jjtn000, true);
    2178            jjtc000 = false;
    2179           jjtn000.setImage("byte");
    2180         break;
    2181       case SHORT:
    2182         jj_consume_token(SHORT);
    2183             jjtree.closeNodeScope(jjtn000, true);
    2184             jjtc000 = false;
    2185            jjtn000.setImage("short");
    2186         break;
    2187       case INT:
    2188         jj_consume_token(INT);
    2189           jjtree.closeNodeScope(jjtn000, true);
    2190           jjtc000 = false;
    2191          jjtn000.setImage("int");
    2192         break;
    2193       case LONG:
    2194         jj_consume_token(LONG);
    2195            jjtree.closeNodeScope(jjtn000, true);
    2196            jjtc000 = false;
    2197           jjtn000.setImage("long");
    2198         break;
    2199       case FLOAT:
    2200         jj_consume_token(FLOAT);
    2201             jjtree.closeNodeScope(jjtn000, true);
    2202             jjtc000 = false;
    2203            jjtn000.setImage("float");
    2204         break;
    2205       case DOUBLE:
    2206         jj_consume_token(DOUBLE);
    2207              jjtree.closeNodeScope(jjtn000, true);
    2208              jjtc000 = false;
    2209             jjtn000.setImage("double");
    2210         break;
    2211       default:
    2212         jj_la1[61] = jj_gen;
    2213         jj_consume_token(-1);
    2214         throw new ParseException();
    2215       }
    2216     } finally {
    2217     if (jjtc000) {
    2218       jjtree.closeNodeScope(jjtn000, true);
    2219     }
    2220     }
    2221   }
    2222
    2223   final public void ResultType() throws ParseException {
    2224  /*@bgen(jjtree) ResultType */
    2225   ASTResultType jjtn000 = new ASTResultType(this, JJTRESULTTYPE);
    2226   boolean jjtc000 = true;
    2227   jjtree.openNodeScope(jjtn000);
    2228     try {
    2229       switch (jj_nt.kind) {
    2230       case VOID:
    2231         jj_consume_token(VOID);
    2232         break;
    2233       case BOOLEAN:
    2234       case BYTE:
    2235       case CHAR:
    2236       case DOUBLE:
    2237       case FLOAT:
    2238       case INT:
    2239       case LONG:
    2240       case SHORT:
    2241       case IDENTIFIER:
    2242         Type();
    2243         break;
    2244       default:
    2245         jj_la1[62] = jj_gen;
    2246         jj_consume_token(-1);
    2247         throw new ParseException();
    2248       }
    2249     } catch (Throwable jjte000) {
    2250     if (jjtc000) {
    2251       jjtree.clearNodeScope(jjtn000);
    2252       jjtc000 = false;
    2253     } else {
    2254       jjtree.popNode();
    2255     }
    2256     if (jjte000 instanceof RuntimeException) {
    2257       {if (true) throw (RuntimeException)jjte000;}
    2258     }
    2259     if (jjte000 instanceof ParseException) {
    2260       {if (true) throw (ParseException)jjte000;}
    2261     }
    2262     {if (true) throw (Error)jjte000;}
    2263     } finally {
    2264     if (jjtc000) {
    2265       jjtree.closeNodeScope(jjtn000, true);
    2266     }
    2267     }
    2268   }
    2269
    2270   final public void Name() throws ParseException {
    2271  /*@bgen(jjtree) Name */
    2272   ASTName jjtn000 = new ASTName(this, JJTNAME);
    2273   boolean jjtc000 = true;
    2274   jjtree.openNodeScope(jjtn000);StringBuffer s = new StringBuffer();
    2275   Token t;
    2276     try {
    2277       t = jj_consume_token(IDENTIFIER);
    2278     jjtn000.testingOnly__setBeginLine( t.beginLine);
    2279     jjtn000.testingOnly__setBeginColumn( t.beginColumn);
    2280     s.append(t.image);
    2281       label_26:
    2282       while (true) {
    2283         if (jj_2_22(2)) {
    2284           ;
    2285         } else {
    2286           break label_26;
    2287         }
    2288         jj_consume_token(DOT);
    2289         t = jj_consume_token(IDENTIFIER);
    2290      s.append('.').append(t.image);
    2291       }
    2292     jjtree.closeNodeScope(jjtn000, true);
    2293     jjtc000 = false;
    2294    jjtn000.setImage(s.toString());
    2295     } finally {
    2296     if (jjtc000) {
    2297       jjtree.closeNodeScope(jjtn000, true);
    2298     }
    2299     }
    2300   }
    2301
    2302   final public void NameList() throws ParseException {
    2303  /*@bgen(jjtree) NameList */
    2304   ASTNameList jjtn000 = new ASTNameList(this, JJTNAMELIST);
    2305   boolean jjtc000 = true;
    2306   jjtree.openNodeScope(jjtn000);
    2307     try {
    2308       Name();
    2309       label_27:
    2310       while (true) {
    2311         switch (jj_nt.kind) {
    2312         case COMMA:
    2313           ;
    2314           break;
    2315         default:
    2316           jj_la1[63] = jj_gen;
    2317           break label_27;
    2318         }
    2319         jj_consume_token(COMMA);
    2320         Name();
    2321       }
    2322     } catch (Throwable jjte000) {
    2323     if (jjtc000) {
    2324       jjtree.clearNodeScope(jjtn000);
    2325       jjtc000 = false;
    2326     } else {
    2327       jjtree.popNode();
    2328     }
    2329     if (jjte000 instanceof RuntimeException) {
    2330       {if (true) throw (RuntimeException)jjte000;}
    2331     }
    2332     if (jjte000 instanceof ParseException) {
    2333       {if (true) throw (ParseException)jjte000;}
    2334     }
    2335     {if (true) throw (Error)jjte000;}
    2336     } finally {
    2337     if (jjtc000) {
    2338       jjtree.closeNodeScope(jjtn000, true);
    2339     }
    2340     }
    2341   }
    2342
    2343 /*
    2344  * Expression syntax follows.
    2345  */
    2346   final public void Expression() throws ParseException {
    2347  /*@bgen(jjtree) Expression */
    2348   ASTExpression jjtn000 = new ASTExpression(this, JJTEXPRESSION);
    2349   boolean jjtc000 = true;
    2350   jjtree.openNodeScope(jjtn000);
    2351     try {
    2352       ConditionalExpression();
    2353       switch (jj_nt.kind) {
    2354       case ASSIGN:
    2355       case PLUSASSIGN:
    2356       case MINUSASSIGN:
    2357       case STARASSIGN:
    2358       case SLASHASSIGN:
    2359       case ANDASSIGN:
    2360       case ORASSIGN:
    2361       case XORASSIGN:
    2362       case REMASSIGN:
    2363       case LSHIFTASSIGN:
    2364       case RSIGNEDSHIFTASSIGN:
    2365       case RUNSIGNEDSHIFTASSIGN:
    2366         AssignmentOperator();
    2367         Expression();
    2368         break;
    2369       default:
    2370         jj_la1[64] = jj_gen;
    2371         ;
    2372       }
    2373     } catch (Throwable jjte000) {
    2374     if (jjtc000) {
    2375       jjtree.clearNodeScope(jjtn000);
    2376       jjtc000 = false;
    2377     } else {
    2378       jjtree.popNode();
    2379     }
    2380     if (jjte000 instanceof RuntimeException) {
    2381       {if (true) throw (RuntimeException)jjte000;}
    2382     }
    2383     if (jjte000 instanceof ParseException) {
    2384       {if (true) throw (ParseException)jjte000;}
    2385     }
    2386     {if (true) throw (Error)jjte000;}
    2387     } finally {
    2388     if (jjtc000) {
    2389       jjtree.closeNodeScope(jjtn000, true);
    2390     }
    2391     }
    2392   }
    2393
    2394   final public void AssignmentOperator() throws ParseException {
    2395  /*@bgen(jjtree) AssignmentOperator */
    2396   ASTAssignmentOperator jjtn000 = new ASTAssignmentOperator(this, JJTASSIGNMENTOPERATOR);
    2397   boolean jjtc000 = true;
    2398   jjtree.openNodeScope(jjtn000);
    2399     try {
    2400       switch (jj_nt.kind) {
    2401       case ASSIGN:
    2402         jj_consume_token(ASSIGN);
    2403                 jjtree.closeNodeScope(jjtn000, true);
    2404                 jjtc000 = false;
    2405                jjtn000.setImage("=");
    2406         break;
    2407       case STARASSIGN:
    2408         jj_consume_token(STARASSIGN);
    2409                 jjtree.closeNodeScope(jjtn000, true);
    2410                 jjtc000 = false;
    2411                jjtn000.setImage("*="); jjtn000.setCompound();
    2412         break;
    2413       case SLASHASSIGN:
    2414         jj_consume_token(SLASHASSIGN);
    2415                 jjtree.closeNodeScope(jjtn000, true);
    2416                 jjtc000 = false;
    2417                jjtn000.setImage("/="); jjtn000.setCompound();
    2418         break;
    2419       case REMASSIGN:
    2420         jj_consume_token(REMASSIGN);
    2421                 jjtree.closeNodeScope(jjtn000, true);
    2422                 jjtc000 = false;
    2423                jjtn000.setImage("%="); jjtn000.setCompound();
    2424         break;
    2425       case PLUSASSIGN:
    2426         jj_consume_token(PLUSASSIGN);
    2427                 jjtree.closeNodeScope(jjtn000, true);
    2428                 jjtc000 = false;
    2429                jjtn000.setImage("+="); jjtn000.setCompound();
    2430         break;
    2431       case MINUSASSIGN:
    2432         jj_consume_token(MINUSASSIGN);
    2433                 jjtree.closeNodeScope(jjtn000, true);
    2434                 jjtc000 = false;
    2435                jjtn000.setImage("-="); jjtn000.setCompound();
    2436         break;
    2437       case LSHIFTASSIGN:
    2438         jj_consume_token(LSHIFTASSIGN);
    2439                 jjtree.closeNodeScope(jjtn000, true);
    2440                 jjtc000 = false;
    2441                jjtn000.setImage("<<="); jjtn000.setCompound();
    2442         break;
    2443       case RSIGNEDSHIFTASSIGN:
    2444         jj_consume_token(RSIGNEDSHIFTASSIGN);
    2445                 jjtree.closeNodeScope(jjtn000, true);
    2446                 jjtc000 = false;
    2447                jjtn000.setImage(">>="); jjtn000.setCompound();
    2448         break;
    2449       case RUNSIGNEDSHIFTASSIGN:
    2450         jj_consume_token(RUNSIGNEDSHIFTASSIGN);
    2451                 jjtree.closeNodeScope(jjtn000, true);
    2452                 jjtc000 = false;
    2453                jjtn000.setImage(">>>="); jjtn000.setCompound();
    2454         break;
    2455       case ANDASSIGN:
    2456         jj_consume_token(ANDASSIGN);
    2457                 jjtree.closeNodeScope(jjtn000, true);
    2458                 jjtc000 = false;
    2459                jjtn000.setImage("&="); jjtn000.setCompound();
    2460         break;
    2461       case XORASSIGN:
    2462         jj_consume_token(XORASSIGN);
    2463                 jjtree.closeNodeScope(jjtn000, true);
    2464                 jjtc000 = false;
    2465                jjtn000.setImage("^="); jjtn000.setCompound();
    2466         break;
    2467       case ORASSIGN:
    2468         jj_consume_token(ORASSIGN);
    2469                 jjtree.closeNodeScope(jjtn000, true);
    2470                 jjtc000 = false;
    2471                jjtn000.setImage("|="); jjtn000.setCompound();
    2472         break;
    2473       default:
    2474         jj_la1[65] = jj_gen;
    2475         jj_consume_token(-1);
    2476         throw new ParseException();
    2477       }
    2478     } finally {
    2479         if (jjtc000) {
    2480           jjtree.closeNodeScope(jjtn000, true);
    2481         }
    2482     }
    2483   }
    2484
    2485   final public void ConditionalExpression() throws ParseException {
    2486  /*@bgen(jjtree) #ConditionalExpression(> 1) */
    2487   ASTConditionalExpression jjtn000 = new ASTConditionalExpression(this, JJTCONDITIONALEXPRESSION);
    2488   boolean jjtc000 = true;
    2489   jjtree.openNodeScope(jjtn000);
    2490     try {
    2491       ConditionalOrExpression();
    2492       switch (jj_nt.kind) {
    2493       case HOOK:
    2494         jj_consume_token(HOOK);
    2495                                    jjtn000.setTernary();
    2496         Expression();
    2497         jj_consume_token(COLON);
    2498         ConditionalExpression();
    2499         break;
    2500       default:
    2501         jj_la1[66] = jj_gen;
    2502         ;
    2503       }
    2504     } catch (Throwable jjte000) {
    2505     if (jjtc000) {
    2506       jjtree.clearNodeScope(jjtn000);
    2507       jjtc000 = false;
    2508     } else {
    2509       jjtree.popNode();
    2510     }
    2511     if (jjte000 instanceof RuntimeException) {
    2512       {if (true) throw (RuntimeException)jjte000;}
    2513     }
    2514     if (jjte000 instanceof ParseException) {
    2515       {if (true) throw (ParseException)jjte000;}
    2516     }
    2517     {if (true) throw (Error)jjte000;}
    2518     } finally {
    2519     if (jjtc000) {
    2520       jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
    2521     }
    2522     }
    2523   }
    2524
    2525   final public void ConditionalOrExpression() throws ParseException {
    2526  /*@bgen(jjtree) #ConditionalOrExpression(> 1) */
    2527   ASTConditionalOrExpression jjtn000 = new ASTConditionalOrExpression(this, JJTCONDITIONALOREXPRESSION);
    2528   boolean jjtc000 = true;
    2529   jjtree.openNodeScope(jjtn000);
    2530     try {
    2531       ConditionalAndExpression();
    2532       label_28:
    2533       while (true) {
    2534         switch (jj_nt.kind) {
    2535         case SC_OR:
    2536           ;
    2537           break;
    2538         default:
    2539           jj_la1[67] = jj_gen;
    2540           break label_28;
    2541         }
    2542         jj_consume_token(SC_OR);
    2543         ConditionalAndExpression();
    2544       }
    2545     } catch (Throwable jjte000) {
    2546     if (jjtc000) {
    2547       jjtree.clearNodeScope(jjtn000);
    2548       jjtc000 = false;
    2549     } else {
    2550       jjtree.popNode();
    2551     }
    2552     if (jjte000 instanceof RuntimeException) {
    2553       {if (true) throw (RuntimeException)jjte000;}
    2554     }
    2555     if (jjte000 instanceof ParseException) {
    2556       {if (true) throw (ParseException)jjte000;}
    2557     }
    2558     {if (true) throw (Error)jjte000;}
    2559     } finally {
    2560     if (jjtc000) {
    2561       jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
    2562     }
    2563     }
    2564   }
    2565
    2566   final public void ConditionalAndExpression() throws ParseException {
    2567  /*@bgen(jjtree) #ConditionalAndExpression(> 1) */
    2568   ASTConditionalAndExpression jjtn000 = new ASTConditionalAndExpression(this, JJTCONDITIONALANDEXPRESSION);
    2569   boolean jjtc000 = true;
    2570   jjtree.openNodeScope(jjtn000);
    2571     try {
    2572       InclusiveOrExpression();
    2573       label_29:
    2574       while (true) {
    2575         switch (jj_nt.kind) {
    2576         case SC_AND:
    2577           ;
    2578           break;
    2579         default:
    2580           jj_la1[68] = jj_gen;
    2581           break label_29;
    2582         }
    2583         jj_consume_token(SC_AND);
    2584         InclusiveOrExpression();
    2585       }
    2586     } catch (Throwable jjte000) {
    2587     if (jjtc000) {
    2588       jjtree.clearNodeScope(jjtn000);
    2589       jjtc000 = false;
    2590     } else {
    2591       jjtree.popNode();
    2592     }
    2593     if (jjte000 instanceof RuntimeException) {
    2594       {if (true) throw (RuntimeException)jjte000;}
    2595     }
    2596     if (jjte000 instanceof ParseException) {
    2597       {if (true) throw (ParseException)jjte000;}
    2598     }
    2599     {if (true) throw (Error)jjte000;}
    2600     } finally {
    2601     if (jjtc000) {
    2602       jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
    2603     }
    2604     }
    2605   }
    2606
    2607   final public void InclusiveOrExpression() throws ParseException {
    2608  /*@bgen(jjtree) #InclusiveOrExpression(> 1) */
    2609   ASTInclusiveOrExpression jjtn000 = new ASTInclusiveOrExpression(this, JJTINCLUSIVEOREXPRESSION);
    2610   boolean jjtc000 = true;
    2611   jjtree.openNodeScope(jjtn000);
    2612     try {
    2613       ExclusiveOrExpression();
    2614       label_30:
    2615       while (true) {
    2616         switch (jj_nt.kind) {
    2617         case BIT_OR:
    2618           ;
    2619           break;
    2620         default:
    2621           jj_la1[69] = jj_gen;
    2622           break label_30;
    2623         }
    2624         jj_consume_token(BIT_OR);
    2625         ExclusiveOrExpression();
    2626       }
    2627     } catch (Throwable jjte000) {
    2628     if (jjtc000) {
    2629       jjtree.clearNodeScope(jjtn000);
    2630       jjtc000 = false;
    2631     } else {
    2632       jjtree.popNode();
    2633     }
    2634     if (jjte000 instanceof RuntimeException) {
    2635       {if (true) throw (RuntimeException)jjte000;}
    2636     }
    2637     if (jjte000 instanceof ParseException) {
    2638       {if (true) throw (ParseException)jjte000;}
    2639     }
    2640     {if (true) throw (Error)jjte000;}
    2641     } finally {
    2642     if (jjtc000) {
    2643       jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
    2644     }
    2645     }
    2646   }
    2647
    2648   final public void ExclusiveOrExpression() throws ParseException {
    2649  /*@bgen(jjtree) #ExclusiveOrExpression(> 1) */
    2650   ASTExclusiveOrExpression jjtn000 = new ASTExclusiveOrExpression(this, JJTEXCLUSIVEOREXPRESSION);
    2651   boolean jjtc000 = true;
    2652   jjtree.openNodeScope(jjtn000);
    2653     try {
    2654       AndExpression();
    2655       label_31:
    2656       while (true) {
    2657         switch (jj_nt.kind) {
    2658         case XOR:
    2659           ;
    2660           break;
    2661         default:
    2662           jj_la1[70] = jj_gen;
    2663           break label_31;
    2664         }
    2665         jj_consume_token(XOR);
    2666         AndExpression();
    2667       }
    2668     } catch (Throwable jjte000) {
    2669     if (jjtc000) {
    2670       jjtree.clearNodeScope(jjtn000);
    2671       jjtc000 = false;
    2672     } else {
    2673       jjtree.popNode();
    2674     }
    2675     if (jjte000 instanceof RuntimeException) {
    2676       {if (true) throw (RuntimeException)jjte000;}
    2677     }
    2678     if (jjte000 instanceof ParseException) {
    2679       {if (true) throw (ParseException)jjte000;}
    2680     }
    2681     {if (true) throw (Error)jjte000;}
    2682     } finally {
    2683     if (jjtc000) {
    2684       jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
    2685     }
    2686     }
    2687   }
    2688
    2689   final public void AndExpression() throws ParseException {
    2690  /*@bgen(jjtree) #AndExpression(> 1) */
    2691   ASTAndExpression jjtn000 = new ASTAndExpression(this, JJTANDEXPRESSION);
    2692   boolean jjtc000 = true;
    2693   jjtree.openNodeScope(jjtn000);
    2694     try {
    2695       EqualityExpression();
    2696       label_32:
    2697       while (true) {
    2698         switch (jj_nt.kind) {
    2699         case BIT_AND:
    2700           ;
    2701           break;
    2702         default:
    2703           jj_la1[71] = jj_gen;
    2704           break label_32;
    2705         }
    2706         jj_consume_token(BIT_AND);
    2707         EqualityExpression();
    2708       }
    2709     } catch (Throwable jjte000) {
    2710     if (jjtc000) {
    2711       jjtree.clearNodeScope(jjtn000);
    2712       jjtc000 = false;
    2713     } else {
    2714       jjtree.popNode();
    2715     }
    2716     if (jjte000 instanceof RuntimeException) {
    2717       {if (true) throw (RuntimeException)jjte000;}
    2718     }
    2719     if (jjte000 instanceof ParseException) {
    2720       {if (true) throw (ParseException)jjte000;}
    2721     }
    2722     {if (true) throw (Error)jjte000;}
    2723     } finally {
    2724     if (jjtc000) {
    2725       jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
    2726     }
    2727     }
    2728   }
    2729
    2730   final public void EqualityExpression() throws ParseException {
    2731  /*@bgen(jjtree) #EqualityExpression(> 1) */
    2732   ASTEqualityExpression jjtn000 = new ASTEqualityExpression(this, JJTEQUALITYEXPRESSION);
    2733   boolean jjtc000 = true;
    2734   jjtree.openNodeScope(jjtn000);
    2735     try {
    2736       InstanceOfExpression();
    2737       label_33:
    2738       while (true) {
    2739         switch (jj_nt.kind) {
    2740         case EQ:
    2741         case NE:
    2742           ;
    2743           break;
    2744         default:
    2745           jj_la1[72] = jj_gen;
    2746           break label_33;
    2747         }
    2748         switch (jj_nt.kind) {
    2749         case EQ:
    2750           jj_consume_token(EQ);
    2751                                     jjtn000.setImage("==");
    2752           break;
    2753         case NE:
    2754           jj_consume_token(NE);
    2755                                                                      jjtn000.setImage("!=");
    2756           break;
    2757         default:
    2758           jj_la1[73] = jj_gen;
    2759           jj_consume_token(-1);
    2760           throw new ParseException();
    2761         }
    2762         InstanceOfExpression();
    2763       }
    2764     } catch (Throwable jjte000) {
    2765     if (jjtc000) {
    2766       jjtree.clearNodeScope(jjtn000);
    2767       jjtc000 = false;
    2768     } else {
    2769       jjtree.popNode();
    2770     }
    2771     if (jjte000 instanceof RuntimeException) {
    2772       {if (true) throw (RuntimeException)jjte000;}
    2773     }
    2774     if (jjte000 instanceof ParseException) {
    2775       {if (true) throw (ParseException)jjte000;}
    2776     }
    2777     {if (true) throw (Error)jjte000;}
    2778     } finally {
    2779     if (jjtc000) {
    2780       jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
    2781     }
    2782     }
    2783   }
    2784
    2785   final public void InstanceOfExpression() throws ParseException {
    2786  /*@bgen(jjtree) #InstanceOfExpression(> 1) */
    2787   ASTInstanceOfExpression jjtn000 = new ASTInstanceOfExpression(this, JJTINSTANCEOFEXPRESSION);
    2788   boolean jjtc000 = true;
    2789   jjtree.openNodeScope(jjtn000);
    2790     try {
    2791       RelationalExpression();
    2792       switch (jj_nt.kind) {
    2793       case INSTANCEOF:
    2794         jj_consume_token(INSTANCEOF);
    2795         Type();
    2796         break;
    2797       default:
    2798         jj_la1[74] = jj_gen;
    2799         ;
    2800       }
    2801     } catch (Throwable jjte000) {
    2802     if (jjtc000) {
    2803       jjtree.clearNodeScope(jjtn000);
    2804       jjtc000 = false;
    2805     } else {
    2806       jjtree.popNode();
    2807     }
    2808     if (jjte000 instanceof RuntimeException) {
    2809       {if (true) throw (RuntimeException)jjte000;}
    2810     }
    2811     if (jjte000 instanceof ParseException) {
    2812       {if (true) throw (ParseException)jjte000;}
    2813     }
    2814     {if (true) throw (Error)jjte000;}
    2815     } finally {
    2816     if (jjtc000) {
    2817       jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
    2818     }
    2819     }
    2820   }
    2821
    2822   final public void RelationalExpression() throws ParseException {
    2823  /*@bgen(jjtree) #RelationalExpression(> 1) */
    2824   ASTRelationalExpression jjtn000 = new ASTRelationalExpression(this, JJTRELATIONALEXPRESSION);
    2825   boolean jjtc000 = true;
    2826   jjtree.openNodeScope(jjtn000);
    2827     try {
    2828       ShiftExpression();
    2829       label_34:
    2830       while (true) {
    2831         switch (jj_nt.kind) {
    2832         case LT:
    2833         case LE:
    2834         case GE:
    2835         case GT:
    2836           ;
    2837           break;
    2838         default:
    2839           jj_la1[75] = jj_gen;
    2840           break label_34;
    2841         }
    2842         switch (jj_nt.kind) {
    2843         case LT:
    2844           jj_consume_token(LT);
    2845            jjtn000.setImage("<");
    2846           break;
    2847         case GT:
    2848           jj_consume_token(GT);
    2849             jjtn000.setImage(">");
    2850           break;
    2851         case LE:
    2852           jj_consume_token(LE);
    2853              jjtn000.setImage("<=");
    2854           break;
    2855         case GE:
    2856           jj_consume_token(GE);
    2857              jjtn000.setImage(">=");
    2858           break;
    2859         default:
    2860           jj_la1[76] = jj_gen;
    2861           jj_consume_token(-1);
    2862           throw new ParseException();
    2863         }
    2864         ShiftExpression();
    2865       }
    2866     } catch (Throwable jjte000) {
    2867     if (jjtc000) {
    2868       jjtree.clearNodeScope(jjtn000);
    2869       jjtc000 = false;
    2870     } else {
    2871       jjtree.popNode();
    2872     }
    2873     if (jjte000 instanceof RuntimeException) {
    2874       {if (true) throw (RuntimeException)jjte000;}
    2875     }
    2876     if (jjte000 instanceof ParseException) {
    2877       {if (true) throw (ParseException)jjte000;}
    2878     }
    2879     {if (true) throw (Error)jjte000;}
    2880     } finally {
    2881     if (jjtc000) {
    2882       jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
    2883     }
    2884     }
    2885   }
    2886
    2887   final public void ShiftExpression() throws ParseException {
    2888  /*@bgen(jjtree) #ShiftExpression(> 1) */
    2889   ASTShiftExpression jjtn000 = new ASTShiftExpression(this, JJTSHIFTEXPRESSION);
    2890   boolean jjtc000 = true;
    2891   jjtree.openNodeScope(jjtn000);
    2892     try {
    2893       AdditiveExpression();
    2894       label_35:
    2895       while (true) {
    2896         if (jj_2_23(1)) {
    2897           ;
    2898         } else {
    2899           break label_35;
    2900         }
    2901         switch (jj_nt.kind) {
    2902         case LSHIFT:
    2903           jj_consume_token(LSHIFT);
    2904              jjtn000.setImage("<<");
    2905           break;
    2906         default:
    2907           jj_la1[77] = jj_gen;
    2908           if (jj_2_24(1)) {
    2909             RSIGNEDSHIFT();
    2910           } else if (jj_2_25(1)) {
    2911             RUNSIGNEDSHIFT();
    2912           } else {
    2913             jj_consume_token(-1);
    2914             throw new ParseException();
    2915           }
    2916         }
    2917         AdditiveExpression();
    2918       }
    2919     } catch (Throwable jjte000) {
    2920     if (jjtc000) {
    2921       jjtree.clearNodeScope(jjtn000);
    2922       jjtc000 = false;
    2923     } else {
    2924       jjtree.popNode();
    2925     }
    2926     if (jjte000 instanceof RuntimeException) {
    2927       {if (true) throw (RuntimeException)jjte000;}
    2928     }
    2929     if (jjte000 instanceof ParseException) {
    2930       {if (true) throw (ParseException)jjte000;}
    2931     }
    2932     {if (true) throw (Error)jjte000;}
    2933     } finally {
    2934     if (jjtc000) {
    2935       jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
    2936     }
    2937     }
    2938   }
    2939
    2940   final public void AdditiveExpression() throws ParseException {
    2941  /*@bgen(jjtree) #AdditiveExpression(> 1) */
    2942   ASTAdditiveExpression jjtn000 = new ASTAdditiveExpression(this, JJTADDITIVEEXPRESSION);
    2943   boolean jjtc000 = true;
    2944   jjtree.openNodeScope(jjtn000);
    2945     try {
    2946       MultiplicativeExpression();
    2947       label_36:
    2948       while (true) {
    2949         switch (jj_nt.kind) {
    2950         case PLUS:
    2951         case MINUS:
    2952           ;
    2953           break;
    2954         default:
    2955           jj_la1[78] = jj_gen;
    2956           break label_36;
    2957         }
    2958         switch (jj_nt.kind) {
    2959         case PLUS:
    2960           jj_consume_token(PLUS);
    2961                                       jjtn000.setImage("+");
    2962           break;
    2963         case MINUS:
    2964           jj_consume_token(MINUS);
    2965                                                                      jjtn000.setImage("-");
    2966           break;
    2967         default:
    2968           jj_la1[79] = jj_gen;
    2969           jj_consume_token(-1);
    2970           throw new ParseException();
    2971         }
    2972         MultiplicativeExpression();
    2973       }
    2974     } catch (Throwable jjte000) {
    2975     if (jjtc000) {
    2976       jjtree.clearNodeScope(jjtn000);
    2977       jjtc000 = false;
    2978     } else {
    2979       jjtree.popNode();
    2980     }
    2981     if (jjte000 instanceof RuntimeException) {
    2982       {if (true) throw (RuntimeException)jjte000;}
    2983     }
    2984     if (jjte000 instanceof ParseException) {
    2985       {if (true) throw (ParseException)jjte000;}
    2986     }
    2987     {if (true) throw (Error)jjte000;}
    2988     } finally {
    2989     if (jjtc000) {
    2990       jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
    2991     }
    2992     }
    2993   }
    2994
    2995   final public void MultiplicativeExpression() throws ParseException {
    2996  /*@bgen(jjtree) #MultiplicativeExpression(> 1) */
    2997   ASTMultiplicativeExpression jjtn000 = new ASTMultiplicativeExpression(this, JJTMULTIPLICATIVEEXPRESSION);
    2998   boolean jjtc000 = true;
    2999   jjtree.openNodeScope(jjtn000);
    3000     try {
    3001       UnaryExpression();
    3002       label_37:
    3003       while (true) {
    3004         switch (jj_nt.kind) {
    3005         case STAR:
    3006         case SLASH:
    3007         case REM:
    3008           ;
    3009           break;
    3010         default:
    3011           jj_la1[80] = jj_gen;
    3012           break label_37;
    3013         }
    3014         switch (jj_nt.kind) {
    3015         case STAR:
    3016           jj_consume_token(STAR);
    3017                              jjtn000.setImage("*");
    3018           break;
    3019         case SLASH:
    3020           jj_consume_token(SLASH);
    3021                                                             jjtn000.setImage("/");
    3022           break;
    3023         case REM:
    3024           jj_consume_token(REM);
    3025                                                                                            jjtn000.setImage("%");
    3026           break;
    3027         default:
    3028           jj_la1[81] = jj_gen;
    3029           jj_consume_token(-1);
    3030           throw new ParseException();
    3031         }
    3032         UnaryExpression();
    3033       }
    3034     } catch (Throwable jjte000) {
    3035     if (jjtc000) {
    3036       jjtree.clearNodeScope(jjtn000);
    3037       jjtc000 = false;
    3038     } else {
    3039       jjtree.popNode();
    3040     }
    3041     if (jjte000 instanceof RuntimeException) {
    3042       {if (true) throw (RuntimeException)jjte000;}
    3043     }
    3044     if (jjte000 instanceof ParseException) {
    3045       {if (true) throw (ParseException)jjte000;}
    3046     }
    3047     {if (true) throw (Error)jjte000;}
    3048     } finally {
    3049     if (jjtc000) {
    3050       jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
    3051     }
    3052     }
    3053   }
    3054
    3055   final public void UnaryExpression() throws ParseException {
    3056  /*@bgen(jjtree) #UnaryExpression( ( jjtn000 . getImage ( ) != null )) */
    3057   ASTUnaryExpression jjtn000 = new ASTUnaryExpression(this, JJTUNARYEXPRESSION);
    3058   boolean jjtc000 = true;
    3059   jjtree.openNodeScope(jjtn000);
    3060     try {
    3061       switch (jj_nt.kind) {
    3062       case PLUS:
    3063       case MINUS:
    3064         switch (jj_nt.kind) {
    3065         case PLUS:
    3066           jj_consume_token(PLUS);
    3067         jjtn000.setImage("+");
    3068           break;
    3069         case MINUS:
    3070           jj_consume_token(MINUS);
    3071                                        jjtn000.setImage("-");
    3072           break;
    3073         default:
    3074           jj_la1[82] = jj_gen;
    3075           jj_consume_token(-1);
    3076           throw new ParseException();
    3077         }
    3078         UnaryExpression();
    3079         break;
    3080       case INCR:
    3081         PreIncrementExpression();
    3082         break;
    3083       case DECR:
    3084         PreDecrementExpression();
    3085         break;
    3086       case BOOLEAN:
    3087       case BYTE:
    3088       case CHAR:
    3089       case DOUBLE:
    3090       case FALSE:
    3091       case FLOAT:
    3092       case INT:
    3093       case LONG:
    3094       case NEW:
    3095       case NULL:
    3096       case SHORT:
    3097       case SUPER:
    3098       case THIS:
    3099       case TRUE:
    3100       case VOID:
    3101       case INTEGER_LITERAL:
    3102       case FLOATING_POINT_LITERAL:
    3103       case HEX_FLOATING_POINT_LITERAL:
    3104       case CHARACTER_LITERAL:
    3105       case STRING_LITERAL:
    3106       case IDENTIFIER:
    3107       case LPAREN:
    3108       case BANG:
    3109       case TILDE:
    3110         UnaryExpressionNotPlusMinus();
    3111         break;
    3112       default:
    3113         jj_la1[83] = jj_gen;
    3114         jj_consume_token(-1);
    3115         throw new ParseException();
    3116       }
    3117     } catch (Throwable jjte000) {
    3118     if (jjtc000) {
    3119       jjtree.clearNodeScope(jjtn000);
    3120       jjtc000 = false;
    3121     } else {
    3122       jjtree.popNode();
    3123     }
    3124     if (jjte000 instanceof RuntimeException) {
    3125       {if (true) throw (RuntimeException)jjte000;}
    3126     }
    3127     if (jjte000 instanceof ParseException) {
    3128       {if (true) throw (ParseException)jjte000;}
    3129     }
    3130     {if (true) throw (Error)jjte000;}
    3131     } finally {
    3132     if (jjtc000) {
    3133       jjtree.closeNodeScope(jjtn000,  ( jjtn000 . getImage ( ) != null ));
    3134     }
    3135     }
    3136   }
    3137
    3138   final public void PreIncrementExpression() throws ParseException {
    3139  /*@bgen(jjtree) PreIncrementExpression */
    3140   ASTPreIncrementExpression jjtn000 = new ASTPreIncrementExpression(this, JJTPREINCREMENTEXPRESSION);
    3141   boolean jjtc000 = true;
    3142   jjtree.openNodeScope(jjtn000);
    3143     try {
    3144       jj_consume_token(INCR);
    3145       PrimaryExpression();
    3146     } catch (Throwable jjte000) {
    3147     if (jjtc000) {
    3148       jjtree.clearNodeScope(jjtn000);
    3149       jjtc000 = false;
    3150     } else {
    3151       jjtree.popNode();
    3152     }
    3153     if (jjte000 instanceof RuntimeException) {
    3154       {if (true) throw (RuntimeException)jjte000;}
    3155     }
    3156     if (jjte000 instanceof ParseException) {
    3157       {if (true) throw (ParseException)jjte000;}
    3158     }
    3159     {if (true) throw (Error)jjte000;}
    3160     } finally {
    3161     if (jjtc000) {
    3162       jjtree.closeNodeScope(jjtn000, true);
    3163     }
    3164     }
    3165   }
    3166
    3167   final public void PreDecrementExpression() throws ParseException {
    3168  /*@bgen(jjtree) PreDecrementExpression */
    3169   ASTPreDecrementExpression jjtn000 = new ASTPreDecrementExpression(this, JJTPREDECREMENTEXPRESSION);
    3170   boolean jjtc000 = true;
    3171   jjtree.openNodeScope(jjtn000);
    3172     try {
    3173       jj_consume_token(DECR);
    3174       PrimaryExpression();
    3175     } catch (Throwable jjte000) {
    3176     if (jjtc000) {
    3177       jjtree.clearNodeScope(jjtn000);
    3178       jjtc000 = false;
    3179     } else {
    3180       jjtree.popNode();
    3181     }
    3182     if (jjte000 instanceof RuntimeException) {
    3183       {if (true) throw (RuntimeException)jjte000;}
    3184     }
    3185     if (jjte000 instanceof ParseException) {
    3186       {if (true) throw (ParseException)jjte000;}
    3187     }
    3188     {if (true) throw (Error)jjte000;}
    3189     } finally {
    3190     if (jjtc000) {
    3191       jjtree.closeNodeScope(jjtn000, true);
    3192     }
    3193     }
    3194   }
    3195
    3196   final public void UnaryExpressionNotPlusMinus() throws ParseException {
    3197  /*@bgen(jjtree) #UnaryExpressionNotPlusMinus( ( jjtn000 . getImage ( ) != null )) */
    3198   ASTUnaryExpressionNotPlusMinus jjtn000 = new ASTUnaryExpressionNotPlusMinus(this, JJTUNARYEXPRESSIONNOTPLUSMINUS);
    3199   boolean jjtc000 = true;
    3200   jjtree.openNodeScope(jjtn000);
    3201     try {
    3202       switch (jj_nt.kind) {
    3203       case BANG:
    3204       case TILDE:
    3205         switch (jj_nt.kind) {
    3206         case TILDE:
    3207           jj_consume_token(TILDE);
    3208         jjtn000.setImage("~");
    3209           break;
    3210         case BANG:
    3211           jj_consume_token(BANG);
    3212                                        jjtn000.setImage("!");
    3213           break;
    3214         default:
    3215           jj_la1[84] = jj_gen;
    3216           jj_consume_token(-1);
    3217           throw new ParseException();
    3218         }
    3219         UnaryExpression();
    3220         break;
    3221       default:
    3222         jj_la1[85] = jj_gen;
    3223         if (jj_2_26(2147483647)) {
    3224           CastExpression();
    3225         } else {
    3226           switch (jj_nt.kind) {
    3227           case BOOLEAN:
    3228           case BYTE:
    3229           case CHAR:
    3230           case DOUBLE:
    3231           case FALSE:
    3232           case FLOAT:
    3233           case INT:
    3234           case LONG:
    3235           case NEW:
    3236           case NULL:
    3237           case SHORT:
    3238           case SUPER:
    3239           case THIS:
    3240           case TRUE:
    3241           case VOID:
    3242           case INTEGER_LITERAL:
    3243           case FLOATING_POINT_LITERAL:
    3244           case HEX_FLOATING_POINT_LITERAL:
    3245           case CHARACTER_LITERAL:
    3246           case STRING_LITERAL:
    3247           case IDENTIFIER:
    3248           case LPAREN:
    3249             PostfixExpression();
    3250             break;
    3251           default:
    3252             jj_la1[86] = jj_gen;
    3253             jj_consume_token(-1);
    3254             throw new ParseException();
    3255           }
    3256         }
    3257       }
    3258     } catch (Throwable jjte000) {
    3259    if (jjtc000) {
    3260      jjtree.clearNodeScope(jjtn000);
    3261      jjtc000 = false;
    3262    } else {
    3263      jjtree.popNode();
    3264    }
    3265    if (jjte000 instanceof RuntimeException) {
    3266      {if (true) throw (RuntimeException)jjte000;}
    3267    }
    3268    if (jjte000 instanceof ParseException) {
    3269      {if (true) throw (ParseException)jjte000;}
    3270    }
    3271    {if (true) throw (Error)jjte000;}
    3272     } finally {
    3273    if (jjtc000) {
    3274      jjtree.closeNodeScope(jjtn000,  ( jjtn000 . getImage ( ) != null ));
    3275    }
    3276     }
    3277   }
    3278
    3279 // This production is to determine lookahead only.  The LOOKAHEAD specifications
    3280 // below are not used, but they are there just to indicate that we know about
    3281 // this.
    3282   final public void CastLookahead() throws ParseException {
    3283     if (jj_2_27(3)) {
    3284       jj_consume_token(LPAREN);
    3285       PrimitiveType();
    3286       jj_consume_token(RPAREN);
    3287     } else if (jj_2_28(2147483647)) {
    3288       jj_consume_token(LPAREN);
    3289       Type();
    3290       jj_consume_token(LBRACKET);
    3291       jj_consume_token(RBRACKET);
    3292     } else {
    3293       switch (jj_nt.kind) {
    3294       case LPAREN:
    3295         jj_consume_token(LPAREN);
    3296         Type();
    3297         jj_consume_token(RPAREN);
    3298         switch (jj_nt.kind) {
    3299         case TILDE:
    3300           jj_consume_token(TILDE);
    3301           break;
    3302         case BANG:
    3303           jj_consume_token(BANG);
    3304           break;
    3305         case LPAREN:
    3306           jj_consume_token(LPAREN);
    3307           break;
    3308         case IDENTIFIER:
    3309           jj_consume_token(IDENTIFIER);
    3310           break;
    3311         case THIS:
    3312           jj_consume_token(THIS);
    3313           break;
    3314         case SUPER:
    3315           jj_consume_token(SUPER);
    3316           break;
    3317         case NEW:
    3318           jj_consume_token(NEW);
    3319           break;
    3320         case FALSE:
    3321         case NULL:
    3322         case TRUE:
    3323         case INTEGER_LITERAL:
    3324         case FLOATING_POINT_LITERAL:
    3325         case HEX_FLOATING_POINT_LITERAL:
    3326         case CHARACTER_LITERAL:
    3327         case STRING_LITERAL:
    3328           Literal();
    3329           break;
    3330         default:
    3331           jj_la1[87] = jj_gen;
    3332           jj_consume_token(-1);
    3333           throw new ParseException();
    3334         }
    3335         break;
    3336       default:
    3337         jj_la1[88] = jj_gen;
    3338         jj_consume_token(-1);
    3339         throw new ParseException();
    3340       }
    3341     }
    3342   }
    3343
    3344   final public void PostfixExpression() throws ParseException {
    3345  /*@bgen(jjtree) #PostfixExpression( ( jjtn000 . getImage ( ) != null )) */
    3346   ASTPostfixExpression jjtn000 = new ASTPostfixExpression(this, JJTPOSTFIXEXPRESSION);
    3347   boolean jjtc000 = true;
    3348   jjtree.openNodeScope(jjtn000);
    3349     try {
    3350       PrimaryExpression();
    3351       switch (jj_nt.kind) {
    3352       case INCR:
    3353       case DECR:
    3354         switch (jj_nt.kind) {
    3355         case INCR:
    3356           jj_consume_token(INCR);
    3357                               jjtn000.setImage("++");
    3358           break;
    3359         case DECR:
    3360           jj_consume_token(DECR);
    3361                                                                jjtn000.setImage("--");
    3362           break;
    3363         default:
    3364           jj_la1[89] = jj_gen;
    3365           jj_consume_token(-1);
    3366           throw new ParseException();
    3367         }
    3368         break;
    3369       default:
    3370         jj_la1[90] = jj_gen;
    3371         ;
    3372       }
    3373     } catch (Throwable jjte000) {
    3374     if (jjtc000) {
    3375       jjtree.clearNodeScope(jjtn000);
    3376       jjtc000 = false;
    3377     } else {
    3378       jjtree.popNode();
    3379     }
    3380     if (jjte000 instanceof RuntimeException) {
    3381       {if (true) throw (RuntimeException)jjte000;}
    3382     }
    3383     if (jjte000 instanceof ParseException) {
    3384       {if (true) throw (ParseException)jjte000;}
    3385     }
    3386     {if (true) throw (Error)jjte000;}
    3387     } finally {
    3388     if (jjtc000) {
    3389       jjtree.closeNodeScope(jjtn000,  ( jjtn000 . getImage ( ) != null ));
    3390     }
    3391     }
    3392   }
    3393
    3394   final public void CastExpression() throws ParseException {
    3395  /*@bgen(jjtree) #CastExpression(> 1) */
    3396   ASTCastExpression jjtn000 = new ASTCastExpression(this, JJTCASTEXPRESSION);
    3397   boolean jjtc000 = true;
    3398   jjtree.openNodeScope(jjtn000);
    3399     try {
    3400       if (jj_2_29(2147483647)) {
    3401         jj_consume_token(LPAREN);
    3402         Type();
    3403         jj_consume_token(RPAREN);
    3404         UnaryExpression();
    3405       } else {
    3406         switch (jj_nt.kind) {
    3407         case LPAREN:
    3408           jj_consume_token(LPAREN);
    3409           Type();
    3410           jj_consume_token(RPAREN);
    3411           UnaryExpressionNotPlusMinus();
    3412           break;
    3413         default:
    3414           jj_la1[91] = jj_gen;
    3415           jj_consume_token(-1);
    3416           throw new ParseException();
    3417         }
    3418       }
    3419     } catch (Throwable jjte000) {
    3420     if (jjtc000) {
    3421       jjtree.clearNodeScope(jjtn000);
    3422       jjtc000 = false;
    3423     } else {
    3424       jjtree.popNode();
    3425     }
    3426     if (jjte000 instanceof RuntimeException) {
    3427       {if (true) throw (RuntimeException)jjte000;}
    3428     }
    3429     if (jjte000 instanceof ParseException) {
    3430       {if (true) throw (ParseException)jjte000;}
    3431     }
    3432     {if (true) throw (Error)jjte000;}
    3433     } finally {
    3434     if (jjtc000) {
    3435       jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
    3436     }
    3437     }
    3438   }
    3439
    3440   final public void PrimaryExpression() throws ParseException {
    3441  /*@bgen(jjtree) PrimaryExpression */
    3442   ASTPrimaryExpression jjtn000 = new ASTPrimaryExpression(this, JJTPRIMARYEXPRESSION);
    3443   boolean jjtc000 = true;
    3444   jjtree.openNodeScope(jjtn000);
    3445     try {
    3446       PrimaryPrefix();
    3447       label_38:
    3448       while (true) {
    3449         if (jj_2_30(2)) {
    3450           ;
    3451         } else {
    3452           break label_38;
    3453         }
    3454         PrimarySuffix();
    3455       }
    3456     } catch (Throwable jjte000) {
    3457     if (jjtc000) {
    3458       jjtree.clearNodeScope(jjtn000);
    3459       jjtc000 = false;
    3460     } else {
    3461       jjtree.popNode();
    3462     }
    3463     if (jjte000 instanceof RuntimeException) {
    3464       {if (true) throw (RuntimeException)jjte000;}
    3465     }
    3466     if (jjte000 instanceof ParseException) {
    3467       {if (true) throw (ParseException)jjte000;}
    3468     }
    3469     {if (true) throw (Error)jjte000;}
    3470     } finally {
    3471     if (jjtc000) {
    3472       jjtree.closeNodeScope(jjtn000, true);
    3473     }
    3474     }
    3475   }
    3476
    3477   final public void MemberSelector() throws ParseException {
    3478  /*@bgen(jjtree) MemberSelector */
    3479 ASTMemberSelector jjtn000 = new ASTMemberSelector(this, JJTMEMBERSELECTOR);
    3480 boolean jjtc000 = true;
    3481 jjtree.openNodeScope(jjtn000);Token t;
    3482     try {
    3483       jj_consume_token(DOT);
    3484       TypeArguments();
    3485       t = jj_consume_token(IDENTIFIER);
    3486                                        jjtree.closeNodeScope(jjtn000, true);
    3487                                        jjtc000 = false;
    3488                                       jjtn000.setImage(t.image);
    3489     } catch (Throwable jjte000) {
    3490     if (jjtc000) {
    3491       jjtree.clearNodeScope(jjtn000);
    3492       jjtc000 = false;
    3493     } else {
    3494       jjtree.popNode();
    3495     }
    3496     if (jjte000 instanceof RuntimeException) {
    3497       {if (true) throw (RuntimeException)jjte000;}
    3498     }
    3499     if (jjte000 instanceof ParseException) {
    3500       {if (true) throw (ParseException)jjte000;}
    3501     }
    3502     {if (true) throw (Error)jjte000;}
    3503     } finally {
    3504     if (jjtc000) {
    3505       jjtree.closeNodeScope(jjtn000, true);
    3506     }
    3507     }
    3508   }
    3509
    3510   final public void PrimaryPrefix() throws ParseException {
    3511  /*@bgen(jjtree) PrimaryPrefix */
    3512  ASTPrimaryPrefix jjtn000 = new ASTPrimaryPrefix(this, JJTPRIMARYPREFIX);
    3513  boolean jjtc000 = true;
    3514  jjtree.openNodeScope(jjtn000);Token t;
    3515     try {
    3516       switch (jj_nt.kind) {
    3517       case FALSE:
    3518       case NULL:
    3519       case TRUE:
    3520       case INTEGER_LITERAL:
    3521       case FLOATING_POINT_LITERAL:
    3522       case HEX_FLOATING_POINT_LITERAL:
    3523       case CHARACTER_LITERAL:
    3524       case STRING_LITERAL:
    3525         Literal();
    3526         break;
    3527       case THIS:
    3528         jj_consume_token(THIS);
    3529            jjtree.closeNodeScope(jjtn000, true);
    3530            jjtc000 = false;
    3531           jjtn000.setUsesThisModifier();
    3532         break;
    3533       case SUPER:
    3534         jj_consume_token(SUPER);
    3535             jjtree.closeNodeScope(jjtn000, true);
    3536             jjtc000 = false;
    3537            jjtn000.setUsesSuperModifier();
    3538         break;
    3539       case LPAREN:
    3540         jj_consume_token(LPAREN);
    3541         Expression();
    3542         jj_consume_token(RPAREN);
    3543         break;
    3544       case NEW:
    3545         AllocationExpression();
    3546         break;
    3547       default:
    3548         jj_la1[92] = jj_gen;
    3549         if (jj_2_31(2147483647)) {
    3550           ResultType();
    3551           jj_consume_token(DOT);
    3552           jj_consume_token(CLASS);
    3553         } else {
    3554           switch (jj_nt.kind) {
    3555           case IDENTIFIER:
    3556             Name();
    3557             break;
    3558           default:
    3559             jj_la1[93] = jj_gen;
    3560             jj_consume_token(-1);
    3561             throw new ParseException();
    3562           }
    3563         }
    3564       }
    3565     } catch (Throwable jjte000) {
    3566     if (jjtc000) {
    3567       jjtree.clearNodeScope(jjtn000);
    3568       jjtc000 = false;
    3569     } else {
    3570       jjtree.popNode();
    3571     }
    3572     if (jjte000 instanceof RuntimeException) {
    3573       {if (true) throw (RuntimeException)jjte000;}
    3574     }
    3575     if (jjte000 instanceof ParseException) {
    3576       {if (true) throw (ParseException)jjte000;}
    3577     }
    3578     {if (true) throw (Error)jjte000;}
    3579     } finally {
    3580     if (jjtc000) {
    3581       jjtree.closeNodeScope(jjtn000, true);
    3582     }
    3583     }
    3584   }
    3585
    3586   final public void PrimarySuffix() throws ParseException {
    3587  /*@bgen(jjtree) PrimarySuffix */
    3588  ASTPrimarySuffix jjtn000 = new ASTPrimarySuffix(this, JJTPRIMARYSUFFIX);
    3589  boolean jjtc000 = true;
    3590  jjtree.openNodeScope(jjtn000);Token t;
    3591     try {
    3592       if (jj_2_32(2)) {
    3593         jj_consume_token(DOT);
    3594         jj_consume_token(THIS);
    3595       } else if (jj_2_33(2)) {
    3596         jj_consume_token(DOT);
    3597         jj_consume_token(SUPER);
    3598       } else if (jj_2_34(2)) {
    3599         jj_consume_token(DOT);
    3600         AllocationExpression();
    3601       } else if (jj_2_35(3)) {
    3602         MemberSelector();
    3603       } else {
    3604         switch (jj_nt.kind) {
    3605         case LBRACKET:
    3606           jj_consume_token(LBRACKET);
    3607           Expression();
    3608           jj_consume_token(RBRACKET);
    3609                          jjtree.closeNodeScope(jjtn000, true);
    3610                          jjtc000 = false;
    3611                         jjtn000.setIsArrayDereference();
    3612           break;
    3613         case DOT:
    3614           jj_consume_token(DOT);
    3615           t = jj_consume_token(IDENTIFIER);
    3616                        jjtree.closeNodeScope(jjtn000, true);
    3617                        jjtc000 = false;
    3618                       jjtn000.setImage(t.image);
    3619           break;
    3620         case LPAREN:
    3621           Arguments();
    3622                 jjtree.closeNodeScope(jjtn000, true);
    3623                 jjtc000 = false;
    3624                jjtn000.setIsArguments();
    3625           break;
    3626         default:
    3627           jj_la1[94] = jj_gen;
    3628           jj_consume_token(-1);
    3629           throw new ParseException();
    3630         }
    3631       }
    3632     } catch (Throwable jjte000) {
    3633     if (jjtc000) {
    3634       jjtree.clearNodeScope(jjtn000);
    3635       jjtc000 = false;
    3636     } else {
    3637       jjtree.popNode();
    3638     }
    3639     if (jjte000 instanceof RuntimeException) {
    3640       {if (true) throw (RuntimeException)jjte000;}
    3641     }
    3642     if (jjte000 instanceof ParseException) {
    3643       {if (true) throw (ParseException)jjte000;}
    3644     }
    3645     {if (true) throw (Error)jjte000;}
    3646     } finally {
    3647     if (jjtc000) {
    3648       jjtree.closeNodeScope(jjtn000, true);
    3649     }
    3650     }
    3651   }
    3652
    3653   final public void Literal() throws ParseException {
    3654  /*@bgen(jjtree) Literal */
    3655   ASTLiteral jjtn000 = new ASTLiteral(this, JJTLITERAL);
    3656   boolean jjtc000 = true;
    3657   jjtree.openNodeScope(jjtn000);
    3658     try {
    3659       switch (jj_nt.kind) {
    3660       case INTEGER_LITERAL:
    3661   Token t;
    3662         t = jj_consume_token(INTEGER_LITERAL);
    3663                         jjtree.closeNodeScope(jjtn000, true);
    3664                         jjtc000 = false;
    3665                         checkForBadNumericalLiteralslUsage(t); jjtn000.setImage(t.image); jjtn000.setIntLiteral();
    3666         break;
    3667       case FLOATING_POINT_LITERAL:
    3668         t = jj_consume_token(FLOATING_POINT_LITERAL);
    3669                                jjtree.closeNodeScope(jjtn000, true);
    3670                                jjtc000 = false;
    3671                                checkForBadNumericalLiteralslUsage(t); jjtn000.setImage(t.image); jjtn000.setFloatLiteral();
    3672         break;
    3673       case HEX_FLOATING_POINT_LITERAL:
    3674         t = jj_consume_token(HEX_FLOATING_POINT_LITERAL);
    3675                                    jjtree.closeNodeScope(jjtn000, true);
    3676                                    jjtc000 = false;
    3677                                    checkForBadHexFloatingPointLiteral(); checkForBadNumericalLiteralslUsage(t); jjtn000.setImage(t.image); jjtn000.setFloatLiteral();
    3678         break;
    3679       case CHARACTER_LITERAL:
    3680         t = jj_consume_token(CHARACTER_LITERAL);
    3681                           jjtree.closeNodeScope(jjtn000, true);
    3682                           jjtc000 = false;
    3683                          jjtn000.setImage(t.image); jjtn000.setCharLiteral();
    3684         break;
    3685       case STRING_LITERAL:
    3686         t = jj_consume_token(STRING_LITERAL);
    3687                        jjtree.closeNodeScope(jjtn000, true);
    3688                        jjtc000 = false;
    3689                       jjtn000.setImage(t.image); jjtn000.setStringLiteral();
    3690         break;
    3691       case FALSE:
    3692       case TRUE:
    3693         BooleanLiteral();
    3694         break;
    3695       case NULL:
    3696         NullLiteral();
    3697         break;
    3698       default:
    3699         jj_la1[95] = jj_gen;
    3700         jj_consume_token(-1);
    3701         throw new ParseException();
    3702       }
    3703     } catch (Throwable jjte000) {
    3704   if (jjtc000) {
    3705     jjtree.clearNodeScope(jjtn000);
    3706     jjtc000 = false;
    3707   } else {
    3708     jjtree.popNode();
    3709   }
    3710   if (jjte000 instanceof RuntimeException) {
    3711     {if (true) throw (RuntimeException)jjte000;}
    3712   }
    3713   if (jjte000 instanceof ParseException) {
    3714     {if (true) throw (ParseException)jjte000;}
    3715   }
    3716   {if (true) throw (Error)jjte000;}
    3717     } finally {
    3718   if (jjtc000) {
    3719     jjtree.closeNodeScope(jjtn000, true);
    3720   }
    3721     }
    3722   }
    3723
    3724   final public void BooleanLiteral() throws ParseException {
    3725  /*@bgen(jjtree) BooleanLiteral */
    3726   ASTBooleanLiteral jjtn000 = new ASTBooleanLiteral(this, JJTBOOLEANLITERAL);
    3727   boolean jjtc000 = true;
    3728   jjtree.openNodeScope(jjtn000);
    3729     try {
    3730       switch (jj_nt.kind) {
    3731       case TRUE:
    3732         jj_consume_token(TRUE);
    3733            jjtree.closeNodeScope(jjtn000, true);
    3734            jjtc000 = false;
    3735            jjtn000.setTrue();
    3736         break;
    3737       case FALSE:
    3738         jj_consume_token(FALSE);
    3739         break;
    3740       default:
    3741         jj_la1[96] = jj_gen;
    3742         jj_consume_token(-1);
    3743         throw new ParseException();
    3744       }
    3745     } finally {
    3746     if (jjtc000) {
    3747       jjtree.closeNodeScope(jjtn000, true);
    3748     }
    3749     }
    3750   }
    3751
    3752   final public void NullLiteral() throws ParseException {
    3753  /*@bgen(jjtree) NullLiteral */
    3754   ASTNullLiteral jjtn000 = new ASTNullLiteral(this, JJTNULLLITERAL);
    3755   boolean jjtc000 = true;
    3756   jjtree.openNodeScope(jjtn000);
    3757     try {
    3758       jj_consume_token(NULL);
    3759     } finally {
    3760     if (jjtc000) {
    3761       jjtree.closeNodeScope(jjtn000, true);
    3762     }
    3763     }
    3764   }
    3765
    3766   final public void Arguments() throws ParseException {
    3767  /*@bgen(jjtree) Arguments */
    3768   ASTArguments jjtn000 = new ASTArguments(this, JJTARGUMENTS);
    3769   boolean jjtc000 = true;
    3770   jjtree.openNodeScope(jjtn000);
    3771     try {
    3772       jj_consume_token(LPAREN);
    3773       switch (jj_nt.kind) {
    3774       case BOOLEAN:
    3775       case BYTE:
    3776       case CHAR:
    3777       case DOUBLE:
    3778       case FALSE:
    3779       case FLOAT:
    3780       case INT:
    3781       case LONG:
    3782       case NEW:
    3783       case NULL:
    3784       case SHORT:
    3785       case SUPER:
    3786       case THIS:
    3787       case TRUE:
    3788       case VOID:
    3789       case INTEGER_LITERAL:
    3790       case FLOATING_POINT_LITERAL:
    3791       case HEX_FLOATING_POINT_LITERAL:
    3792       case CHARACTER_LITERAL:
    3793       case STRING_LITERAL:
    3794       case IDENTIFIER:
    3795       case LPAREN:
    3796       case BANG:
    3797       case TILDE:
    3798       case INCR:
    3799       case DECR:
    3800       case PLUS:
    3801       case MINUS:
    3802         ArgumentList();
    3803         break;
    3804       default:
    3805         jj_la1[97] = jj_gen;
    3806         ;
    3807       }
    3808       jj_consume_token(RPAREN);
    3809     } catch (Throwable jjte000) {
    3810     if (jjtc000) {
    3811       jjtree.clearNodeScope(jjtn000);
    3812       jjtc000 = false;
    3813     } else {
    3814       jjtree.popNode();
    3815     }
    3816     if (jjte000 instanceof RuntimeException) {
    3817       {if (true) throw (RuntimeException)jjte000;}
    3818     }
    3819     if (jjte000 instanceof ParseException) {
    3820       {if (true) throw (ParseException)jjte000;}
    3821     }
    3822     {if (true) throw (Error)jjte000;}
    3823     } finally {
    3824     if (jjtc000) {
    3825       jjtree.closeNodeScope(jjtn000, true);
    3826     }
    3827     }
    3828   }
    3829
    3830   final public void ArgumentList() throws ParseException {
    3831  /*@bgen(jjtree) ArgumentList */
    3832   ASTArgumentList jjtn000 = new ASTArgumentList(this, JJTARGUMENTLIST);
    3833   boolean jjtc000 = true;
    3834   jjtree.openNodeScope(jjtn000);
    3835     try {
    3836       Expression();
    3837       label_39:
    3838       while (true) {
    3839         switch (jj_nt.kind) {
    3840         case COMMA:
    3841           ;
    3842           break;
    3843         default:
    3844           jj_la1[98] = jj_gen;
    3845           break label_39;
    3846         }
    3847         jj_consume_token(COMMA);
    3848         Expression();
    3849       }
    3850     } catch (Throwable jjte000) {
    3851     if (jjtc000) {
    3852       jjtree.clearNodeScope(jjtn000);
    3853       jjtc000 = false;
    3854     } else {
    3855       jjtree.popNode();
    3856     }
    3857     if (jjte000 instanceof RuntimeException) {
    3858       {if (true) throw (RuntimeException)jjte000;}
    3859     }
    3860     if (jjte000 instanceof ParseException) {
    3861       {if (true) throw (ParseException)jjte000;}
    3862     }
    3863     {if (true) throw (Error)jjte000;}
    3864     } finally {
    3865     if (jjtc000) {
    3866       jjtree.closeNodeScope(jjtn000, true);
    3867     }
    3868     }
    3869   }
    3870
    3871   final public void AllocationExpression() throws ParseException {
    3872  /*@bgen(jjtree) AllocationExpression */
    3873   ASTAllocationExpression jjtn000 = new ASTAllocationExpression(this, JJTALLOCATIONEXPRESSION);
    3874   boolean jjtc000 = true;
    3875   jjtree.openNodeScope(jjtn000);
    3876     try {
    3877       if (jj_2_36(2)) {
    3878         jj_consume_token(NEW);
    3879         PrimitiveType();
    3880         ArrayDimsAndInits();
    3881       } else {
    3882         switch (jj_nt.kind) {
    3883         case NEW:
    3884           jj_consume_token(NEW);
    3885           ClassOrInterfaceType();
    3886           switch (jj_nt.kind) {
    3887           case LT:
    3888             TypeArguments();
    3889             break;
    3890           default:
    3891             jj_la1[99] = jj_gen;
    3892             ;
    3893           }
    3894           switch (jj_nt.kind) {
    3895           case LBRACKET:
    3896             ArrayDimsAndInits();
    3897             break;
    3898           case LPAREN:
    3899             Arguments();
    3900             switch (jj_nt.kind) {
    3901             case LBRACE:
    3902               ClassOrInterfaceBody();
    3903               break;
    3904             default:
    3905               jj_la1[100] = jj_gen;
    3906               ;
    3907             }
    3908             break;
    3909           default:
    3910             jj_la1[101] = jj_gen;
    3911             jj_consume_token(-1);
    3912             throw new ParseException();
    3913           }
    3914           break;
    3915         default:
    3916           jj_la1[102] = jj_gen;
    3917           jj_consume_token(-1);
    3918           throw new ParseException();
    3919         }
    3920       }
    3921     } catch (Throwable jjte000) {
    3922     if (jjtc000) {
    3923       jjtree.clearNodeScope(jjtn000);
    3924       jjtc000 = false;
    3925     } else {
    3926       jjtree.popNode();
    3927     }
    3928     if (jjte000 instanceof RuntimeException) {
    3929       {if (true) throw (RuntimeException)jjte000;}
    3930     }
    3931     if (jjte000 instanceof ParseException) {
    3932       {if (true) throw (ParseException)jjte000;}
    3933     }
    3934     {if (true) throw (Error)jjte000;}
    3935     } finally {
    3936     if (jjtc000) {
    3937       jjtree.closeNodeScope(jjtn000, true);
    3938     }
    3939     }
    3940   }
    3941
    3942 /*
    3943  * The second LOOKAHEAD specification below is to parse to PrimarySuffix
    3944  * if there is an expression between the "[...]".
    3945  */
    3946   final public void ArrayDimsAndInits() throws ParseException {
    3947  /*@bgen(jjtree) ArrayDimsAndInits */
    3948   ASTArrayDimsAndInits jjtn000 = new ASTArrayDimsAndInits(this, JJTARRAYDIMSANDINITS);
    3949   boolean jjtc000 = true;
    3950   jjtree.openNodeScope(jjtn000);
    3951     try {
    3952       if (jj_2_39(2)) {
    3953         label_40:
    3954         while (true) {
    3955           jj_consume_token(LBRACKET);
    3956           Expression();
    3957           jj_consume_token(RBRACKET);
    3958           if (jj_2_37(2)) {
    3959             ;
    3960           } else {
    3961             break label_40;
    3962           }
    3963         }
    3964         label_41:
    3965         while (true) {
    3966           if (jj_2_38(2)) {
    3967             ;
    3968           } else {
    3969             break label_41;
    3970           }
    3971           jj_consume_token(LBRACKET);
    3972           jj_consume_token(RBRACKET);
    3973         }
    3974       } else {
    3975         switch (jj_nt.kind) {
    3976         case LBRACKET:
    3977           label_42:
    3978           while (true) {
    3979             jj_consume_token(LBRACKET);
    3980             jj_consume_token(RBRACKET);
    3981             switch (jj_nt.kind) {
    3982             case LBRACKET:
    3983               ;
    3984               break;
    3985             default:
    3986               jj_la1[103] = jj_gen;
    3987               break label_42;
    3988             }
    3989           }
    3990           ArrayInitializer();
    3991           break;
    3992         default:
    3993           jj_la1[104] = jj_gen;
    3994           jj_consume_token(-1);
    3995           throw new ParseException();
    3996         }
    3997       }
    3998     } catch (Throwable jjte000) {
    3999     if (jjtc000) {
    4000       jjtree.clearNodeScope(jjtn000);
    4001       jjtc000 = false;
    4002     } else {
    4003       jjtree.popNode();
    4004     }
    4005     if (jjte000 instanceof RuntimeException) {
    4006       {if (true) throw (RuntimeException)jjte000;}
    4007     }
    4008     if (jjte000 instanceof ParseException) {
    4009       {if (true) throw (ParseException)jjte000;}
    4010     }
    4011     {if (true) throw (Error)jjte000;}
    4012     } finally {
    4013     if (jjtc000) {
    4014       jjtree.closeNodeScope(jjtn000, true);
    4015     }
    4016     }
    4017   }
    4018
    4019 /*
    4020  * Statement syntax follows.
    4021  */
    4022   final public void Statement() throws ParseException {
    4023  /*@bgen(jjtree) Statement */
    4024   ASTStatement jjtn000 = new ASTStatement(this, JJTSTATEMENT);
    4025   boolean jjtc000 = true;
    4026   jjtree.openNodeScope(jjtn000);
    4027     try {
    4028       if (isNextTokenAnAssert()) {
    4029         AssertStatement();
    4030       } else if (jj_2_40(2)) {
    4031         LabeledStatement();
    4032       } else {
    4033         switch (jj_nt.kind) {
    4034         case LBRACE:
    4035           Block();
    4036           break;
    4037         case SEMICOLON:
    4038           EmptyStatement();
    4039           break;
    4040         case BOOLEAN:
    4041         case BYTE:
    4042         case CHAR:
    4043         case DOUBLE:
    4044         case FALSE:
    4045         case FLOAT:
    4046         case INT:
    4047         case LONG:
    4048         case NEW:
    4049         case NULL:
    4050         case SHORT:
    4051         case SUPER:
    4052         case THIS:
    4053         case TRUE:
    4054         case VOID:
    4055         case INTEGER_LITERAL:
    4056         case FLOATING_POINT_LITERAL:
    4057         case HEX_FLOATING_POINT_LITERAL:
    4058         case CHARACTER_LITERAL:
    4059         case STRING_LITERAL:
    4060         case IDENTIFIER:
    4061         case LPAREN:
    4062         case INCR:
    4063         case DECR:
    4064           StatementExpression();
    4065           jj_consume_token(SEMICOLON);
    4066           break;
    4067         case SWITCH:
    4068           SwitchStatement();
    4069           break;
    4070         case IF:
    4071           IfStatement();
    4072           break;
    4073         case WHILE:
    4074           WhileStatement();
    4075           break;
    4076         case DO:
    4077           DoStatement();
    4078           break;
    4079         case FOR:
    4080           ForStatement();
    4081           break;
    4082         case BREAK:
    4083           BreakStatement();
    4084           break;
    4085         case CONTINUE:
    4086           ContinueStatement();
    4087           break;
    4088         case RETURN:
    4089           ReturnStatement();
    4090           break;
    4091         case THROW:
    4092           ThrowStatement();
    4093           break;
    4094         case SYNCHRONIZED:
    4095           SynchronizedStatement();
    4096           break;
    4097         case TRY:
    4098           TryStatement();
    4099           break;
    4100         default:
    4101           jj_la1[105] = jj_gen;
    4102           jj_consume_token(-1);
    4103           throw new ParseException();
    4104         }
    4105       }
    4106     } catch (Throwable jjte000) {
    4107     if (jjtc000) {
    4108       jjtree.clearNodeScope(jjtn000);
    4109       jjtc000 = false;
    4110     } else {
    4111       jjtree.popNode();
    4112     }
    4113     if (jjte000 instanceof RuntimeException) {
    4114       {if (true) throw (RuntimeException)jjte000;}
    4115     }
    4116     if (jjte000 instanceof ParseException) {
    4117       {if (true) throw (ParseException)jjte000;}
    4118     }
    4119     {if (true) throw (Error)jjte000;}
    4120     } finally {
    4121     if (jjtc000) {
    4122       jjtree.closeNodeScope(jjtn000, true);
    4123     }
    4124     }
    4125   }
    4126
    4127   final public void LabeledStatement() throws ParseException {
    4128  /*@bgen(jjtree) LabeledStatement */
    4129  ASTLabeledStatement jjtn000 = new ASTLabeledStatement(this, JJTLABELEDSTATEMENT);
    4130  boolean jjtc000 = true;
    4131  jjtree.openNodeScope(jjtn000);Token t;
    4132     try {
    4133       t = jj_consume_token(IDENTIFIER);
    4134                   jjtn000.setImage(t.image);
    4135       jj_consume_token(COLON);
    4136       Statement();
    4137     } catch (Throwable jjte000) {
    4138     if (jjtc000) {
    4139       jjtree.clearNodeScope(jjtn000);
    4140       jjtc000 = false;
    4141     } else {
    4142       jjtree.popNode();
    4143     }
    4144     if (jjte000 instanceof RuntimeException) {
    4145       {if (true) throw (RuntimeException)jjte000;}
    4146     }
    4147     if (jjte000 instanceof ParseException) {
    4148       {if (true) throw (ParseException)jjte000;}
    4149     }
    4150     {if (true) throw (Error)jjte000;}
    4151     } finally {
    4152     if (jjtc000) {
    4153       jjtree.closeNodeScope(jjtn000, true);
    4154     }
    4155     }
    4156   }
    4157
    4158   final public void Block() throws ParseException {
    4159  /*@bgen(jjtree) Block */
    4160  ASTBlock jjtn000 = new ASTBlock(this, JJTBLOCK);
    4161  boolean jjtc000 = true;
    4162  jjtree.openNodeScope(jjtn000);Token t;
    4163     try {
    4164       jj_consume_token(LBRACE);
    4165       label_43:
    4166       while (true) {
    4167         if (jj_2_41(1)) {
    4168           ;
    4169         } else {
    4170           break label_43;
    4171         }
    4172         BlockStatement();
    4173       }
    4174       t = jj_consume_token(RBRACE);
    4175                                       jjtree.closeNodeScope(jjtn000, true);
    4176                                       jjtc000 = false;
    4177                                       if (isPrecededByComment(t)) { jjtn000.setContainsComment(); }
    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 BlockStatement() throws ParseException {
    4200  /*@bgen(jjtree) BlockStatement */
    4201   ASTBlockStatement jjtn000 = new ASTBlockStatement(this, JJTBLOCKSTATEMENT);
    4202   boolean jjtc000 = true;
    4203   jjtree.openNodeScope(jjtn000);
    4204     try {
    4205       if (isNextTokenAnAssert()) {
    4206         AssertStatement();
    4207       } else if (jj_2_42(2147483647)) {
    4208         LocalVariableDeclaration();
    4209         jj_consume_token(SEMICOLON);
    4210       } else if (jj_2_43(1)) {
    4211         Statement();
    4212       } else if (jj_2_44(2147483647)) {
    4213         switch (jj_nt.kind) {
    4214         case AT:
    4215           Annotation();
    4216           break;
    4217         default:
    4218           jj_la1[106] = jj_gen;
    4219           ;
    4220         }
    4221         ClassOrInterfaceDeclaration(0);
    4222       } else {
    4223         jj_consume_token(-1);
    4224         throw new ParseException();
    4225       }
    4226     } catch (Throwable jjte000) {
    4227     if (jjtc000) {
    4228       jjtree.clearNodeScope(jjtn000);
    4229       jjtc000 = false;
    4230     } else {
    4231       jjtree.popNode();
    4232     }
    4233     if (jjte000 instanceof RuntimeException) {
    4234       {if (true) throw (RuntimeException)jjte000;}
    4235     }
    4236     if (jjte000 instanceof ParseException) {
    4237       {if (true) throw (ParseException)jjte000;}
    4238     }
    4239     {if (true) throw (Error)jjte000;}
    4240     } finally {
    4241     if (jjtc000) {
    4242       jjtree.closeNodeScope(jjtn000, true);
    4243     }
    4244     }
    4245   }
    4246
    4247   final public void LocalVariableDeclaration() throws ParseException {
    4248  /*@bgen(jjtree) LocalVariableDeclaration */
    4249   ASTLocalVariableDeclaration jjtn000 = new ASTLocalVariableDeclaration(this, JJTLOCALVARIABLEDECLARATION);
    4250   boolean jjtc000 = true;
    4251   jjtree.openNodeScope(jjtn000);
    4252     try {
    4253       label_44:
    4254       while (true) {
    4255         switch (jj_nt.kind) {
    4256         case FINAL:
    4257         case AT:
    4258           ;
    4259           break;
    4260         default:
    4261           jj_la1[107] = jj_gen;
    4262           break label_44;
    4263         }
    4264         switch (jj_nt.kind) {
    4265         case FINAL:
    4266           jj_consume_token(FINAL);
    4267              jjtn000.setFinal(true);
    4268           break;
    4269         case AT:
    4270           Annotation();
    4271           break;
    4272         default:
    4273           jj_la1[108] = jj_gen;
    4274           jj_consume_token(-1);
    4275           throw new ParseException();
    4276         }
    4277       }
    4278       Type();
    4279       VariableDeclarator();
    4280       label_45:
    4281       while (true) {
    4282         switch (jj_nt.kind) {
    4283         case COMMA:
    4284           ;
    4285           break;
    4286         default:
    4287           jj_la1[109] = jj_gen;
    4288           break label_45;
    4289         }
    4290         jj_consume_token(COMMA);
    4291         VariableDeclarator();
    4292       }
    4293     } catch (Throwable jjte000) {
    4294     if (jjtc000) {
    4295       jjtree.clearNodeScope(jjtn000);
    4296       jjtc000 = false;
    4297     } else {
    4298       jjtree.popNode();
    4299     }
    4300     if (jjte000 instanceof RuntimeException) {
    4301       {if (true) throw (RuntimeException)jjte000;}
    4302     }
    4303     if (jjte000 instanceof ParseException) {
    4304       {if (true) throw (ParseException)jjte000;}
    4305     }
    4306     {if (true) throw (Error)jjte000;}
    4307     } finally {
    4308     if (jjtc000) {
    4309       jjtree.closeNodeScope(jjtn000, true);
    4310     }
    4311     }
    4312   }
    4313
    4314   final public void EmptyStatement() throws ParseException {
    4315  /*@bgen(jjtree) EmptyStatement */
    4316   ASTEmptyStatement jjtn000 = new ASTEmptyStatement(this, JJTEMPTYSTATEMENT);
    4317   boolean jjtc000 = true;
    4318   jjtree.openNodeScope(jjtn000);
    4319     try {
    4320       jj_consume_token(SEMICOLON);
    4321     } finally {
    4322     if (jjtc000) {
    4323       jjtree.closeNodeScope(jjtn000, true);
    4324     }
    4325     }
    4326   }
    4327
    4328   final public void StatementExpression() throws ParseException {
    4329  /*@bgen(jjtree) StatementExpression */
    4330   ASTStatementExpression jjtn000 = new ASTStatementExpression(this, JJTSTATEMENTEXPRESSION);
    4331   boolean jjtc000 = true;
    4332   jjtree.openNodeScope(jjtn000);
    4333     try {
    4334       switch (jj_nt.kind) {
    4335       case INCR:
    4336         PreIncrementExpression();
    4337         break;
    4338       case DECR:
    4339         PreDecrementExpression();
    4340         break;
    4341       default:
    4342         jj_la1[111] = jj_gen;
    4343         if (jj_2_45(2147483647)) {
    4344           PostfixExpression();
    4345         } else {
    4346           switch (jj_nt.kind) {
    4347           case BOOLEAN:
    4348           case BYTE:
    4349           case CHAR:
    4350           case DOUBLE:
    4351           case FALSE:
    4352           case FLOAT:
    4353           case INT:
    4354           case LONG:
    4355           case NEW:
    4356           case NULL:
    4357           case SHORT:
    4358           case SUPER:
    4359           case THIS:
    4360           case TRUE:
    4361           case VOID:
    4362           case INTEGER_LITERAL:
    4363           case FLOATING_POINT_LITERAL:
    4364           case HEX_FLOATING_POINT_LITERAL:
    4365           case CHARACTER_LITERAL:
    4366           case STRING_LITERAL:
    4367           case IDENTIFIER:
    4368           case LPAREN:
    4369             PrimaryExpression();
    4370             switch (jj_nt.kind) {
    4371             case ASSIGN:
    4372             case PLUSASSIGN:
    4373             case MINUSASSIGN:
    4374             case STARASSIGN:
    4375             case SLASHASSIGN:
    4376             case ANDASSIGN:
    4377             case ORASSIGN:
    4378             case XORASSIGN:
    4379             case REMASSIGN:
    4380             case LSHIFTASSIGN:
    4381             case RSIGNEDSHIFTASSIGN:
    4382             case RUNSIGNEDSHIFTASSIGN:
    4383               AssignmentOperator();
    4384               Expression();
    4385               break;
    4386             default:
    4387               jj_la1[110] = jj_gen;
    4388               ;
    4389             }
    4390             break;
    4391           default:
    4392             jj_la1[112] = jj_gen;
    4393             jj_consume_token(-1);
    4394             throw new ParseException();
    4395           }
    4396         }
    4397       }
    4398     } catch (Throwable jjte000) {
    4399     if (jjtc000) {
    4400       jjtree.clearNodeScope(jjtn000);
    4401       jjtc000 = false;
    4402     } else {
    4403       jjtree.popNode();
    4404     }
    4405     if (jjte000 instanceof RuntimeException) {
    4406       {if (true) throw (RuntimeException)jjte000;}
    4407     }
    4408     if (jjte000 instanceof ParseException) {
    4409       {if (true) throw (ParseException)jjte000;}
    4410     }
    4411     {if (true) throw (Error)jjte000;}
    4412     } finally {
    4413     if (jjtc000) {
    4414       jjtree.closeNodeScope(jjtn000, true);
    4415     }
    4416     }
    4417   }
    4418
    4419   final public void SwitchStatement() throws ParseException {
    4420  /*@bgen(jjtree) SwitchStatement */
    4421   ASTSwitchStatement jjtn000 = new ASTSwitchStatement(this, JJTSWITCHSTATEMENT);
    4422   boolean jjtc000 = true;
    4423   jjtree.openNodeScope(jjtn000);
    4424     try {
    4425       jj_consume_token(SWITCH);
    4426       jj_consume_token(LPAREN);
    4427       Expression();
    4428       jj_consume_token(RPAREN);
    4429       jj_consume_token(LBRACE);
    4430       label_46:
    4431       while (true) {
    4432         switch (jj_nt.kind) {
    4433         case CASE:
    4434         case _DEFAULT:
    4435           ;
    4436           break;
    4437         default:
    4438           jj_la1[113] = jj_gen;
    4439           break label_46;
    4440         }
    4441         SwitchLabel();
    4442         label_47:
    4443         while (true) {
    4444           if (jj_2_46(1)) {
    4445             ;
    4446           } else {
    4447             break label_47;
    4448           }
    4449           BlockStatement();
    4450         }
    4451       }
    4452       jj_consume_token(RBRACE);
    4453     } catch (Throwable jjte000) {
    4454     if (jjtc000) {
    4455       jjtree.clearNodeScope(jjtn000);
    4456       jjtc000 = false;
    4457     } else {
    4458       jjtree.popNode();
    4459     }
    4460     if (jjte000 instanceof RuntimeException) {
    4461       {if (true) throw (RuntimeException)jjte000;}
    4462     }
    4463     if (jjte000 instanceof ParseException) {
    4464       {if (true) throw (ParseException)jjte000;}
    4465     }
    4466     {if (true) throw (Error)jjte000;}
    4467     } finally {
    4468     if (jjtc000) {
    4469       jjtree.closeNodeScope(jjtn000, true);
    4470     }
    4471     }
    4472   }
    4473
    4474   final public void SwitchLabel() throws ParseException {
    4475  /*@bgen(jjtree) SwitchLabel */
    4476   ASTSwitchLabel jjtn000 = new ASTSwitchLabel(this, JJTSWITCHLABEL);
    4477   boolean jjtc000 = true;
    4478   jjtree.openNodeScope(jjtn000);
    4479     try {
    4480       switch (jj_nt.kind) {
    4481       case CASE:
    4482         jj_consume_token(CASE);
    4483         Expression();
    4484         jj_consume_token(COLON);
    4485         break;
    4486       case _DEFAULT:
    4487         jj_consume_token(_DEFAULT);
    4488              jjtn000.setDefault();
    4489         jj_consume_token(COLON);
    4490         break;
    4491       default:
    4492         jj_la1[114] = jj_gen;
    4493         jj_consume_token(-1);
    4494         throw new ParseException();
    4495       }
    4496     } catch (Throwable jjte000) {
    4497     if (jjtc000) {
    4498       jjtree.clearNodeScope(jjtn000);
    4499       jjtc000 = false;
    4500     } else {
    4501       jjtree.popNode();
    4502     }
    4503     if (jjte000 instanceof RuntimeException) {
    4504       {if (true) throw (RuntimeException)jjte000;}
    4505     }
    4506     if (jjte000 instanceof ParseException) {
    4507       {if (true) throw (ParseException)jjte000;}
    4508     }
    4509     {if (true) throw (Error)jjte000;}
    4510     } finally {
    4511     if (jjtc000) {
    4512       jjtree.closeNodeScope(jjtn000, true);
    4513     }
    4514     }
    4515   }
    4516
    4517   final public void IfStatement() throws ParseException {
    4518  /*@bgen(jjtree) IfStatement */
    4519   ASTIfStatement jjtn000 = new ASTIfStatement(this, JJTIFSTATEMENT);
    4520   boolean jjtc000 = true;
    4521   jjtree.openNodeScope(jjtn000);
    4522     try {
    4523       jj_consume_token(IF);
    4524       jj_consume_token(LPAREN);
    4525       Expression();
    4526       jj_consume_token(RPAREN);
    4527       Statement();
    4528       switch (jj_nt.kind) {
    4529       case ELSE:
    4530         jj_consume_token(ELSE);
    4531                                                                jjtn000.setHasElse();
    4532         Statement();
    4533         break;
    4534       default:
    4535         jj_la1[115] = jj_gen;
    4536         ;
    4537       }
    4538   jjtree.closeNodeScope(jjtn000, true);
    4539   jjtc000 = false;
    4540
    4541     } catch (Throwable jjte000) {
    4542     if (jjtc000) {
    4543       jjtree.clearNodeScope(jjtn000);
    4544       jjtc000 = false;
    4545     } else {
    4546       jjtree.popNode();
    4547     }
    4548     if (jjte000 instanceof RuntimeException) {
    4549       {if (true) throw (RuntimeException)jjte000;}
    4550     }
    4551     if (jjte000 instanceof ParseException) {
    4552       {if (true) throw (ParseException)jjte000;}
    4553     }
    4554     {if (true) throw (Error)jjte000;}
    4555     } finally {
    4556     if (jjtc000) {
    4557       jjtree.closeNodeScope(jjtn000, true);
    4558     }
    4559     }
    4560   }
    4561
    4562   final public void WhileStatement() throws ParseException {
    4563  /*@bgen(jjtree) WhileStatement */
    4564   ASTWhileStatement jjtn000 = new ASTWhileStatement(this, JJTWHILESTATEMENT);
    4565   boolean jjtc000 = true;
    4566   jjtree.openNodeScope(jjtn000);
    4567     try {
    4568       jj_consume_token(WHILE);
    4569       jj_consume_token(LPAREN);
    4570       Expression();
    4571       jj_consume_token(RPAREN);
    4572       Statement();
    4573     } catch (Throwable jjte000) {
    4574     if (jjtc000) {
    4575       jjtree.clearNodeScope(jjtn000);
    4576       jjtc000 = false;
    4577     } else {
    4578       jjtree.popNode();
    4579     }
    4580     if (jjte000 instanceof RuntimeException) {
    4581       {if (true) throw (RuntimeException)jjte000;}
    4582     }
    4583     if (jjte000 instanceof ParseException) {
    4584       {if (true) throw (ParseException)jjte000;}
    4585     }
    4586     {if (true) throw (Error)jjte000;}
    4587     } finally {
    4588     if (jjtc000) {
    4589       jjtree.closeNodeScope(jjtn000, true);
    4590     }
    4591     }
    4592   }
    4593
    4594   final public void DoStatement() throws ParseException {
    4595  /*@bgen(jjtree) DoStatement */
    4596   ASTDoStatement jjtn000 = new ASTDoStatement(this, JJTDOSTATEMENT);
    4597   boolean jjtc000 = true;
    4598   jjtree.openNodeScope(jjtn000);
    4599     try {
    4600       jj_consume_token(DO);
    4601       Statement();
    4602       jj_consume_token(WHILE);
    4603       jj_consume_token(LPAREN);
    4604       Expression();
    4605       jj_consume_token(RPAREN);
    4606       jj_consume_token(SEMICOLON);
    4607     } catch (Throwable jjte000) {
    4608     if (jjtc000) {
    4609       jjtree.clearNodeScope(jjtn000);
    4610       jjtc000 = false;
    4611     } else {
    4612       jjtree.popNode();
    4613     }
    4614     if (jjte000 instanceof RuntimeException) {
    4615       {if (true) throw (RuntimeException)jjte000;}
    4616     }
    4617     if (jjte000 instanceof ParseException) {
    4618       {if (true) throw (ParseException)jjte000;}
    4619     }
    4620     {if (true) throw (Error)jjte000;}
    4621     } finally {
    4622     if (jjtc000) {
    4623       jjtree.closeNodeScope(jjtn000, true);
    4624     }
    4625     }
    4626   }
    4627
    4628   final public void ForStatement() throws ParseException {
    4629  /*@bgen(jjtree) ForStatement */
    4630   ASTForStatement jjtn000 = new ASTForStatement(this, JJTFORSTATEMENT);
    4631   boolean jjtc000 = true;
    4632   jjtree.openNodeScope(jjtn000);
    4633     try {
    4634       jj_consume_token(FOR);
    4635       jj_consume_token(LPAREN);
    4636       if (jj_2_47(2147483647)) {
    4637        checkForBadJDK15ForLoopSyntaxArgumentsUsage();
    4638         LocalVariableDeclaration();
    4639         jj_consume_token(COLON);
    4640         Expression();
    4641       } else {
    4642         switch (jj_nt.kind) {
    4643         case BOOLEAN:
    4644         case BYTE:
    4645         case CHAR:
    4646         case DOUBLE:
    4647         case FALSE:
    4648         case FINAL:
    4649         case FLOAT:
    4650         case INT:
    4651         case LONG:
    4652         case NEW:
    4653         case NULL:
    4654         case SHORT:
    4655         case SUPER:
    4656         case THIS:
    4657         case TRUE:
    4658         case VOID:
    4659         case INTEGER_LITERAL:
    4660         case FLOATING_POINT_LITERAL:
    4661         case HEX_FLOATING_POINT_LITERAL:
    4662         case CHARACTER_LITERAL:
    4663         case STRING_LITERAL:
    4664         case IDENTIFIER:
    4665         case LPAREN:
    4666         case SEMICOLON:
    4667         case AT:
    4668         case INCR:
    4669         case DECR:
    4670           switch (jj_nt.kind) {
    4671           case BOOLEAN:
    4672           case BYTE:
    4673           case CHAR:
    4674           case DOUBLE:
    4675           case FALSE:
    4676           case FINAL:
    4677           case FLOAT:
    4678           case INT:
    4679           case LONG:
    4680           case NEW:
    4681           case NULL:
    4682           case SHORT:
    4683           case SUPER:
    4684           case THIS:
    4685           case TRUE:
    4686           case VOID:
    4687           case INTEGER_LITERAL:
    4688           case FLOATING_POINT_LITERAL:
    4689           case HEX_FLOATING_POINT_LITERAL:
    4690           case CHARACTER_LITERAL:
    4691           case STRING_LITERAL:
    4692           case IDENTIFIER:
    4693           case LPAREN:
    4694           case AT:
    4695           case INCR:
    4696           case DECR:
    4697             ForInit();
    4698             break;
    4699           default:
    4700             jj_la1[116] = jj_gen;
    4701             ;
    4702           }
    4703           jj_consume_token(SEMICOLON);
    4704           switch (jj_nt.kind) {
    4705           case BOOLEAN:
    4706           case BYTE:
    4707           case CHAR:
    4708           case DOUBLE:
    4709           case FALSE:
    4710           case FLOAT:
    4711           case INT:
    4712           case LONG:
    4713           case NEW:
    4714           case NULL:
    4715           case SHORT:
    4716           case SUPER:
    4717           case THIS:
    4718           case TRUE:
    4719           case VOID:
    4720           case INTEGER_LITERAL:
    4721           case FLOATING_POINT_LITERAL:
    4722           case HEX_FLOATING_POINT_LITERAL:
    4723           case CHARACTER_LITERAL:
    4724           case STRING_LITERAL:
    4725           case IDENTIFIER:
    4726           case LPAREN:
    4727           case BANG:
    4728           case TILDE:
    4729           case INCR:
    4730           case DECR:
    4731           case PLUS:
    4732           case MINUS:
    4733             Expression();
    4734             break;
    4735           default:
    4736             jj_la1[117] = jj_gen;
    4737             ;
    4738           }
    4739           jj_consume_token(SEMICOLON);
    4740           switch (jj_nt.kind) {
    4741           case BOOLEAN:
    4742           case BYTE:
    4743           case CHAR:
    4744           case DOUBLE:
    4745           case FALSE:
    4746           case FLOAT:
    4747           case INT:
    4748           case LONG:
    4749           case NEW:
    4750           case NULL:
    4751           case SHORT:
    4752           case SUPER:
    4753           case THIS:
    4754           case TRUE:
    4755           case VOID:
    4756           case INTEGER_LITERAL:
    4757           case FLOATING_POINT_LITERAL:
    4758           case HEX_FLOATING_POINT_LITERAL:
    4759           case CHARACTER_LITERAL:
    4760           case STRING_LITERAL:
    4761           case IDENTIFIER:
    4762           case LPAREN:
    4763           case INCR:
    4764           case DECR:
    4765             ForUpdate();
    4766             break;
    4767           default:
    4768             jj_la1[118] = jj_gen;
    4769             ;
    4770           }
    4771           break;
    4772         default:
    4773           jj_la1[119] = jj_gen;
    4774           jj_consume_token(-1);
    4775           throw new ParseException();
    4776         }
    4777       }
    4778       jj_consume_token(RPAREN);
    4779       Statement();
    4780     } catch (Throwable jjte000) {
    4781     if (jjtc000) {
    4782       jjtree.clearNodeScope(jjtn000);
    4783       jjtc000 = false;
    4784     } else {
    4785       jjtree.popNode();
    4786     }
    4787     if (jjte000 instanceof RuntimeException) {
    4788       {if (true) throw (RuntimeException)jjte000;}
    4789     }
    4790     if (jjte000 instanceof ParseException) {
    4791       {if (true) throw (ParseException)jjte000;}
    4792     }
    4793     {if (true) throw (Error)jjte000;}
    4794     } finally {
    4795     if (jjtc000) {
    4796       jjtree.closeNodeScope(jjtn000, true);
    4797     }
    4798     }
    4799   }
    4800
    4801   final public void ForInit() throws ParseException {
    4802  /*@bgen(jjtree) ForInit */
    4803   ASTForInit jjtn000 = new ASTForInit(this, JJTFORINIT);
    4804   boolean jjtc000 = true;
    4805   jjtree.openNodeScope(jjtn000);
    4806     try {
    4807       if (jj_2_48(2147483647)) {
    4808         LocalVariableDeclaration();
    4809       } else {
    4810         switch (jj_nt.kind) {
    4811         case BOOLEAN:
    4812         case BYTE:
    4813         case CHAR:
    4814         case DOUBLE:
    4815         case FALSE:
    4816         case FLOAT:
    4817         case INT:
    4818         case LONG:
    4819         case NEW:
    4820         case NULL:
    4821         case SHORT:
    4822         case SUPER:
    4823         case THIS:
    4824         case TRUE:
    4825         case VOID:
    4826         case INTEGER_LITERAL:
    4827         case FLOATING_POINT_LITERAL:
    4828         case HEX_FLOATING_POINT_LITERAL:
    4829         case CHARACTER_LITERAL:
    4830         case STRING_LITERAL:
    4831         case IDENTIFIER:
    4832         case LPAREN:
    4833         case INCR:
    4834         case DECR:
    4835           StatementExpressionList();
    4836           break;
    4837         default:
    4838           jj_la1[120] = jj_gen;
    4839           jj_consume_token(-1);
    4840           throw new ParseException();
    4841         }
    4842       }
    4843     } catch (Throwable jjte000) {
    4844     if (jjtc000) {
    4845       jjtree.clearNodeScope(jjtn000);
    4846       jjtc000 = false;
    4847     } else {
    4848       jjtree.popNode();
    4849     }
    4850     if (jjte000 instanceof RuntimeException) {
    4851       {if (true) throw (RuntimeException)jjte000;}
    4852     }
    4853     if (jjte000 instanceof ParseException) {
    4854       {if (true) throw (ParseException)jjte000;}
    4855     }
    4856     {if (true) throw (Error)jjte000;}
    4857     } finally {
    4858     if (jjtc000) {
    4859       jjtree.closeNodeScope(jjtn000, true);
    4860     }
    4861     }
    4862   }
    4863
    4864   final public void StatementExpressionList() throws ParseException {
    4865  /*@bgen(jjtree) StatementExpressionList */
    4866   ASTStatementExpressionList jjtn000 = new ASTStatementExpressionList(this, JJTSTATEMENTEXPRESSIONLIST);
    4867   boolean jjtc000 = true;
    4868   jjtree.openNodeScope(jjtn000);
    4869     try {
    4870       StatementExpression();
    4871       label_48:
    4872       while (true) {
    4873         switch (jj_nt.kind) {
    4874         case COMMA:
    4875           ;
    4876           break;
    4877         default:
    4878           jj_la1[121] = jj_gen;
    4879           break label_48;
    4880         }
    4881         jj_consume_token(COMMA);
    4882         StatementExpression();
    4883       }
    4884     } catch (Throwable jjte000) {
    4885     if (jjtc000) {
    4886       jjtree.clearNodeScope(jjtn000);
    4887       jjtc000 = false;
    4888     } else {
    4889       jjtree.popNode();
    4890     }
    4891     if (jjte000 instanceof RuntimeException) {
    4892       {if (true) throw (RuntimeException)jjte000;}
    4893     }
    4894     if (jjte000 instanceof ParseException) {
    4895       {if (true) throw (ParseException)jjte000;}
    4896     }
    4897     {if (true) throw (Error)jjte000;}
    4898     } finally {
    4899     if (jjtc000) {
    4900       jjtree.closeNodeScope(jjtn000, true);
    4901     }
    4902     }
    4903   }
    4904
    4905   final public void ForUpdate() throws ParseException {
    4906  /*@bgen(jjtree) ForUpdate */
    4907   ASTForUpdate jjtn000 = new ASTForUpdate(this, JJTFORUPDATE);
    4908   boolean jjtc000 = true;
    4909   jjtree.openNodeScope(jjtn000);
    4910     try {
    4911       StatementExpressionList();
    4912     } catch (Throwable jjte000) {
    4913     if (jjtc000) {
    4914       jjtree.clearNodeScope(jjtn000);
    4915       jjtc000 = false;
    4916     } else {
    4917       jjtree.popNode();
    4918     }
    4919     if (jjte000 instanceof RuntimeException) {
    4920       {if (true) throw (RuntimeException)jjte000;}
    4921     }
    4922     if (jjte000 instanceof ParseException) {
    4923       {if (true) throw (ParseException)jjte000;}
    4924     }
    4925     {if (true) throw (Error)jjte000;}
    4926     } finally {
    4927     if (jjtc000) {
    4928       jjtree.closeNodeScope(jjtn000, true);
    4929     }
    4930     }
    4931   }
    4932
    4933   final public void BreakStatement() throws ParseException {
    4934  /*@bgen(jjtree) BreakStatement */
    4935  ASTBreakStatement jjtn000 = new ASTBreakStatement(this, JJTBREAKSTATEMENT);
    4936  boolean jjtc000 = true;
    4937  jjtree.openNodeScope(jjtn000);Token t;
    4938     try {
    4939       jj_consume_token(BREAK);
    4940       switch (jj_nt.kind) {
    4941       case IDENTIFIER:
    4942         t = jj_consume_token(IDENTIFIER);
    4943                             jjtn000.setImage(t.image);
    4944         break;
    4945       default:
    4946         jj_la1[122] = jj_gen;
    4947         ;
    4948       }
    4949       jj_consume_token(SEMICOLON);
    4950     } finally {
    4951     if (jjtc000) {
    4952       jjtree.closeNodeScope(jjtn000, true);
    4953     }
    4954     }
    4955   }
    4956
    4957   final public void ContinueStatement() throws ParseException {
    4958  /*@bgen(jjtree) ContinueStatement */
    4959  ASTContinueStatement jjtn000 = new ASTContinueStatement(this, JJTCONTINUESTATEMENT);
    4960  boolean jjtc000 = true;
    4961  jjtree.openNodeScope(jjtn000);Token t;
    4962     try {
    4963       jj_consume_token(CONTINUE);
    4964       switch (jj_nt.kind) {
    4965       case IDENTIFIER:
    4966         t = jj_consume_token(IDENTIFIER);
    4967                                jjtn000.setImage(t.image);
    4968         break;
    4969       default:
    4970         jj_la1[123] = jj_gen;
    4971         ;
    4972       }
    4973       jj_consume_token(SEMICOLON);
    4974     } finally {
    4975     if (jjtc000) {
    4976       jjtree.closeNodeScope(jjtn000, true);
    4977     }
    4978     }
    4979   }
    4980
    4981   final public void ReturnStatement() throws ParseException {
    4982  /*@bgen(jjtree) ReturnStatement */
    4983   ASTReturnStatement jjtn000 = new ASTReturnStatement(this, JJTRETURNSTATEMENT);
    4984   boolean jjtc000 = true;
    4985   jjtree.openNodeScope(jjtn000);
    4986     try {
    4987       jj_consume_token(RETURN);
    4988       switch (jj_nt.kind) {
    4989       case BOOLEAN:
    4990       case BYTE:
    4991       case CHAR:
    4992       case DOUBLE:
    4993       case FALSE:
    4994       case FLOAT:
    4995       case INT:
    4996       case LONG:
    4997       case NEW:
    4998       case NULL:
    4999       case SHORT:
    5000       case SUPER:
    5001       case THIS:
    5002       case TRUE:
    5003       case VOID:
    5004       case INTEGER_LITERAL:
    5005       case FLOATING_POINT_LITERAL:
    5006       case HEX_FLOATING_POINT_LITERAL:
    5007       case CHARACTER_LITERAL:
    5008       case STRING_LITERAL:
    5009       case IDENTIFIER:
    5010       case LPAREN:
    5011       case BANG:
    5012       case TILDE:
    5013       case INCR:
    5014       case DECR:
    5015       case PLUS:
    5016       case MINUS:
    5017         Expression();
    5018         break;
    5019       default:
    5020         jj_la1[124] = jj_gen;
    5021         ;
    5022       }
    5023       jj_consume_token(SEMICOLON);
    5024     } catch (Throwable jjte000) {
    5025     if (jjtc000) {
    5026       jjtree.clearNodeScope(jjtn000);
    5027       jjtc000 = false;
    5028     } else {
    5029       jjtree.popNode();
    5030     }
    5031     if (jjte000 instanceof RuntimeException) {
    5032       {if (true) throw (RuntimeException)jjte000;}
    5033     }
    5034     if (jjte000 instanceof ParseException) {
    5035       {if (true) throw (ParseException)jjte000;}
    5036     }
    5037     {if (true) throw (Error)jjte000;}
    5038     } finally {
    5039     if (jjtc000) {
    5040       jjtree.closeNodeScope(jjtn000, true);
    5041     }
    5042     }
    5043   }
    5044
    5045   final public void ThrowStatement() throws ParseException {
    5046  /*@bgen(jjtree) ThrowStatement */
    5047   ASTThrowStatement jjtn000 = new ASTThrowStatement(this, JJTTHROWSTATEMENT);
    5048   boolean jjtc000 = true;
    5049   jjtree.openNodeScope(jjtn000);
    5050     try {
    5051       jj_consume_token(THROW);
    5052       Expression();
    5053       jj_consume_token(SEMICOLON);
    5054     } catch (Throwable jjte000) {
    5055     if (jjtc000) {
    5056       jjtree.clearNodeScope(jjtn000);
    5057       jjtc000 = false;
    5058     } else {
    5059       jjtree.popNode();
    5060     }
    5061     if (jjte000 instanceof RuntimeException) {
    5062       {if (true) throw (RuntimeException)jjte000;}
    5063     }
    5064     if (jjte000 instanceof ParseException) {
    5065       {if (true) throw (ParseException)jjte000;}
    5066     }
    5067     {if (true) throw (Error)jjte000;}
    5068     } finally {
    5069     if (jjtc000) {
    5070       jjtree.closeNodeScope(jjtn000, true);
    5071     }
    5072     }
    5073   }
    5074
    5075   final public void SynchronizedStatement() throws ParseException {
    5076  /*@bgen(jjtree) SynchronizedStatement */
    5077   ASTSynchronizedStatement jjtn000 = new ASTSynchronizedStatement(this, JJTSYNCHRONIZEDSTATEMENT);
    5078   boolean jjtc000 = true;
    5079   jjtree.openNodeScope(jjtn000);
    5080     try {
    5081       jj_consume_token(SYNCHRONIZED);
    5082       jj_consume_token(LPAREN);
    5083       Expression();
    5084       jj_consume_token(RPAREN);
    5085       Block();
    5086     } catch (Throwable jjte000) {
    5087     if (jjtc000) {
    5088       jjtree.clearNodeScope(jjtn000);
    5089       jjtc000 = false;
    5090     } else {
    5091       jjtree.popNode();
    5092     }
    5093     if (jjte000 instanceof RuntimeException) {
    5094       {if (true) throw (RuntimeException)jjte000;}
    5095     }
    5096     if (jjte000 instanceof ParseException) {
    5097       {if (true) throw (ParseException)jjte000;}
    5098     }
    5099     {if (true) throw (Error)jjte000;}
    5100     } finally {
    5101     if (jjtc000) {
    5102       jjtree.closeNodeScope(jjtn000, true);
    5103     }
    5104     }
    5105   }
    5106
    5107   final public void TryStatement() throws ParseException {
    5108  /*@bgen(jjtree) TryStatement */
    5109   ASTTryStatement jjtn000 = new ASTTryStatement(this, JJTTRYSTATEMENT);
    5110   boolean jjtc000 = true;
    5111   jjtree.openNodeScope(jjtn000);
    5112     try {
    5113       jj_consume_token(TRY);
    5114       switch (jj_nt.kind) {
    5115       case LPAREN:
    5116         ResourceSpecification();
    5117         break;
    5118       default:
    5119         jj_la1[125] = jj_gen;
    5120         ;
    5121       }
    5122       Block();
    5123       label_49:
    5124       while (true) {
    5125         switch (jj_nt.kind) {
    5126         case CATCH:
    5127           ;
    5128           break;
    5129         default:
    5130           jj_la1[126] = jj_gen;
    5131           break label_49;
    5132         }
    5133         CatchStatement();
    5134       }
    5135       switch (jj_nt.kind) {
    5136       case FINALLY:
    5137         FinallyStatement();
    5138         break;
    5139       default:
    5140         jj_la1[127] = jj_gen;
    5141         ;
    5142       }
    5143     } catch (Throwable jjte000) {
    5144     if (jjtc000) {
    5145       jjtree.clearNodeScope(jjtn000);
    5146       jjtc000 = false;
    5147     } else {
    5148       jjtree.popNode();
    5149     }
    5150     if (jjte000 instanceof RuntimeException) {
    5151       {if (true) throw (RuntimeException)jjte000;}
    5152     }
    5153     if (jjte000 instanceof ParseException) {
    5154       {if (true) throw (ParseException)jjte000;}
    5155     }
    5156     {if (true) throw (Error)jjte000;}
    5157     } finally {
    5158     if (jjtc000) {
    5159       jjtree.closeNodeScope(jjtn000, true);
    5160     }
    5161     }
    5162   }
    5163
    5164   final public void ResourceSpecification() throws ParseException {
    5165  /*@bgen(jjtree) ResourceSpecification */
    5166   ASTResourceSpecification jjtn000 = new ASTResourceSpecification(this, JJTRESOURCESPECIFICATION);
    5167   boolean jjtc000 = true;
    5168   jjtree.openNodeScope(jjtn000);
    5169     try {
    5170      checkForBadTryWithResourcesUsage();
    5171       jj_consume_token(LPAREN);
    5172       Resources();
    5173       if (jj_2_49(2)) {
    5174         jj_consume_token(SEMICOLON);
    5175       } else {
    5176         ;
    5177       }
    5178       jj_consume_token(RPAREN);
    5179     } catch (Throwable jjte000) {
    5180       if (jjtc000) {
    5181         jjtree.clearNodeScope(jjtn000);
    5182         jjtc000 = false;
    5183       } else {
    5184         jjtree.popNode();
    5185       }
    5186       if (jjte000 instanceof RuntimeException) {
    5187         {if (true) throw (RuntimeException)jjte000;}
    5188       }
    5189       if (jjte000 instanceof ParseException) {
    5190         {if (true) throw (ParseException)jjte000;}
    5191       }
    5192       {if (true) throw (Error)jjte000;}
    5193     } finally {
    5194       if (jjtc000) {
    5195         jjtree.closeNodeScope(jjtn000, true);
    5196       }
    5197     }
    5198   }
    5199
    5200   final public void Resources() throws ParseException {
    5201  /*@bgen(jjtree) Resources */
    5202   ASTResources jjtn000 = new ASTResources(this, JJTRESOURCES);
    5203   boolean jjtc000 = true;
    5204   jjtree.openNodeScope(jjtn000);
    5205     try {
    5206       Resource();
    5207       label_50:
    5208       while (true) {
    5209         if (jj_2_50(2)) {
    5210           ;
    5211         } else {
    5212           break label_50;
    5213         }
    5214         jj_consume_token(SEMICOLON);
    5215         Resource();
    5216       }
    5217     } catch (Throwable jjte000) {
    5218           if (jjtc000) {
    5219             jjtree.clearNodeScope(jjtn000);
    5220             jjtc000 = false;
    5221           } else {
    5222             jjtree.popNode();
    5223           }
    5224           if (jjte000 instanceof RuntimeException) {
    5225             {if (true) throw (RuntimeException)jjte000;}
    5226           }
    5227           if (jjte000 instanceof ParseException) {
    5228             {if (true) throw (ParseException)jjte000;}
    5229           }
    5230           {if (true) throw (Error)jjte000;}
    5231     } finally {
    5232           if (jjtc000) {
    5233             jjtree.closeNodeScope(jjtn000, true);
    5234           }
    5235     }
    5236   }
    5237
    5238   final public void Resource() throws ParseException {
    5239  /*@bgen(jjtree) Resource */
    5240   ASTResource jjtn000 = new ASTResource(this, JJTRESOURCE);
    5241   boolean jjtc000 = true;
    5242   jjtree.openNodeScope(jjtn000);
    5243     try {
    5244       label_51:
    5245       while (true) {
    5246         switch (jj_nt.kind) {
    5247         case FINAL:
    5248         case AT:
    5249           ;
    5250           break;
    5251         default:
    5252           jj_la1[128] = jj_gen;
    5253           break label_51;
    5254         }
    5255         switch (jj_nt.kind) {
    5256         case FINAL:
    5257           jj_consume_token(FINAL);
    5258           break;
    5259         case AT:
    5260           Annotation();
    5261           break;
    5262         default:
    5263           jj_la1[129] = jj_gen;
    5264           jj_consume_token(-1);
    5265           throw new ParseException();
    5266         }
    5267       }
    5268       Type();
    5269       VariableDeclaratorId();
    5270       jj_consume_token(ASSIGN);
    5271       Expression();
    5272     } catch (Throwable jjte000) {
    5273           if (jjtc000) {
    5274             jjtree.clearNodeScope(jjtn000);
    5275             jjtc000 = false;
    5276           } else {
    5277             jjtree.popNode();
    5278           }
    5279           if (jjte000 instanceof RuntimeException) {
    5280             {if (true) throw (RuntimeException)jjte000;}
    5281           }
    5282           if (jjte000 instanceof ParseException) {
    5283             {if (true) throw (ParseException)jjte000;}
    5284           }
    5285           {if (true) throw (Error)jjte000;}
    5286     } finally {
    5287           if (jjtc000) {
    5288             jjtree.closeNodeScope(jjtn000, true);
    5289           }
    5290     }
    5291   }
    5292
    5293   final public void CatchStatement() throws ParseException {
    5294  /*@bgen(jjtree) CatchStatement */
    5295   ASTCatchStatement jjtn000 = new ASTCatchStatement(this, JJTCATCHSTATEMENT);
    5296   boolean jjtc000 = true;
    5297   jjtree.openNodeScope(jjtn000);
    5298     try {
    5299       jj_consume_token(CATCH);
    5300       jj_consume_token(LPAREN);
    5301       FormalParameter();
    5302       jj_consume_token(RPAREN);
    5303       Block();
    5304     } catch (Throwable jjte000) {
    5305     if (jjtc000) {
    5306       jjtree.clearNodeScope(jjtn000);
    5307       jjtc000 = false;
    5308     } else {
    5309       jjtree.popNode();
    5310     }
    5311     if (jjte000 instanceof RuntimeException) {
    5312       {if (true) throw (RuntimeException)jjte000;}
    5313     }
    5314     if (jjte000 instanceof ParseException) {
    5315       {if (true) throw (ParseException)jjte000;}
    5316     }
    5317     {if (true) throw (Error)jjte000;}
    5318     } finally {
    5319     if (jjtc000) {
    5320       jjtree.closeNodeScope(jjtn000, true);
    5321     }
    5322     }
    5323   }
    5324
    5325   final public void FinallyStatement() throws ParseException {
    5326  /*@bgen(jjtree) FinallyStatement */
    5327   ASTFinallyStatement jjtn000 = new ASTFinallyStatement(this, JJTFINALLYSTATEMENT);
    5328   boolean jjtc000 = true;
    5329   jjtree.openNodeScope(jjtn000);
    5330     try {
    5331       jj_consume_token(FINALLY);
    5332       Block();
    5333     } catch (Throwable jjte000) {
    5334       if (jjtc000) {
    5335         jjtree.clearNodeScope(jjtn000);
    5336         jjtc000 = false;
    5337       } else {
    5338         jjtree.popNode();
    5339       }
    5340       if (jjte000 instanceof RuntimeException) {
    5341         {if (true) throw (RuntimeException)jjte000;}
    5342       }
    5343       if (jjte000 instanceof ParseException) {
    5344         {if (true) throw (ParseException)jjte000;}
    5345       }
    5346       {if (true) throw (Error)jjte000;}
    5347     } finally {
    5348       if (jjtc000) {
    5349         jjtree.closeNodeScope(jjtn000, true);
    5350       }
    5351     }
    5352   }
    5353
    5354   final public void AssertStatement() throws ParseException {
    5355  /*@bgen(jjtree) AssertStatement */
    5356     ASTAssertStatement jjtn000 = new ASTAssertStatement(this, JJTASSERTSTATEMENT);
    5357     boolean jjtc000 = true;
    5358     jjtree.openNodeScope(jjtn000);if (jdkVersion <= 3) {
    5359         throw new ParseException("Can't use 'assert' as a keyword when running in JDK 1.3 mode!");
    5360     }
    5361     try {
    5362       jj_consume_token(IDENTIFIER);
    5363       Expression();
    5364       switch (jj_nt.kind) {
    5365       case COLON:
    5366         jj_consume_token(COLON);
    5367         Expression();
    5368         break;
    5369       default:
    5370         jj_la1[130] = jj_gen;
    5371         ;
    5372       }
    5373       jj_consume_token(SEMICOLON);
    5374     } catch (Throwable jjte000) {
    5375     if (jjtc000) {
    5376       jjtree.clearNodeScope(jjtn000);
    5377       jjtc000 = false;
    5378     } else {
    5379       jjtree.popNode();
    5380     }
    5381     if (jjte000 instanceof RuntimeException) {
    5382       {if (true) throw (RuntimeException)jjte000;}
    5383     }
    5384     if (jjte000 instanceof ParseException) {
    5385       {if (true) throw (ParseException)jjte000;}
    5386     }
    5387     {if (true) throw (Error)jjte000;}
    5388     } finally {
    5389     if (jjtc000) {
    5390       jjtree.closeNodeScope(jjtn000, true);
    5391     }
    5392     }
    5393   }
    5394
    5395 /* We use productions to match >>>, >> and > so that we can keep the
    5396  * type declaration syntax with generics clean
    5397  */
    5398   final public void RUNSIGNEDSHIFT() throws ParseException {
    5399  /*@bgen(jjtree) RUNSIGNEDSHIFT */
    5400   ASTRUNSIGNEDSHIFT jjtn000 = new ASTRUNSIGNEDSHIFT(this, JJTRUNSIGNEDSHIFT);
    5401   boolean jjtc000 = true;
    5402   jjtree.openNodeScope(jjtn000);
    5403     try {
    5404       if (getToken(1).kind == GT &&
    5405                       ((Token.GTToken)getToken(1)).realKind == RUNSIGNEDSHIFT) {
    5406
    5407       } else {
    5408         jj_consume_token(-1);
    5409         throw new ParseException();
    5410       }
    5411       jj_consume_token(GT);
    5412       jj_consume_token(GT);
    5413       jj_consume_token(GT);
    5414     } finally {
    5415     if (jjtc000) {
    5416       jjtree.closeNodeScope(jjtn000, true);
    5417     }
    5418     }
    5419   }
    5420
    5421   final public void RSIGNEDSHIFT() throws ParseException {
    5422  /*@bgen(jjtree) RSIGNEDSHIFT */
    5423   ASTRSIGNEDSHIFT jjtn000 = new ASTRSIGNEDSHIFT(this, JJTRSIGNEDSHIFT);
    5424   boolean jjtc000 = true;
    5425   jjtree.openNodeScope(jjtn000);
    5426     try {
    5427       if (getToken(1).kind == GT &&
    5428                       ((Token.GTToken)getToken(1)).realKind == RSIGNEDSHIFT) {
    5429
    5430       } else {
    5431         jj_consume_token(-1);
    5432         throw new ParseException();
    5433       }
    5434       jj_consume_token(GT);
    5435       jj_consume_token(GT);
    5436     } finally {
    5437     if (jjtc000) {
    5438       jjtree.closeNodeScope(jjtn000, true);
    5439     }
    5440     }
    5441   }
    5442
    5443 /* Annotation syntax follows. */
    5444   final public void Annotation() throws ParseException {
    5445  /*@bgen(jjtree) Annotation */
    5446   ASTAnnotation jjtn000 = new ASTAnnotation(this, JJTANNOTATION);
    5447   boolean jjtc000 = true;
    5448   jjtree.openNodeScope(jjtn000);
    5449     try {
    5450       if (jj_2_51(2147483647)) {
    5451         NormalAnnotation();
    5452       } else if (jj_2_52(2147483647)) {
    5453         SingleMemberAnnotation();
    5454       } else {
    5455         switch (jj_nt.kind) {
    5456         case AT:
    5457           MarkerAnnotation();
    5458           break;
    5459         default:
    5460           jj_la1[131] = jj_gen;
    5461           jj_consume_token(-1);
    5462           throw new ParseException();
    5463         }
    5464       }
    5465     } catch (Throwable jjte000) {
    5466      if (jjtc000) {
    5467        jjtree.clearNodeScope(jjtn000);
    5468        jjtc000 = false;
    5469      } else {
    5470        jjtree.popNode();
    5471      }
    5472      if (jjte000 instanceof RuntimeException) {
    5473        {if (true) throw (RuntimeException)jjte000;}
    5474      }
    5475      if (jjte000 instanceof ParseException) {
    5476        {if (true) throw (ParseException)jjte000;}
    5477      }
    5478      {if (true) throw (Error)jjte000;}
    5479     } finally {
    5480      if (jjtc000) {
    5481        jjtree.closeNodeScope(jjtn000, true);
    5482      }
    5483     }
    5484   }
    5485
    5486   final public void NormalAnnotation() throws ParseException {
    5487  /*@bgen(jjtree) NormalAnnotation */
    5488   ASTNormalAnnotation jjtn000 = new ASTNormalAnnotation(this, JJTNORMALANNOTATION);
    5489   boolean jjtc000 = true;
    5490   jjtree.openNodeScope(jjtn000);
    5491     try {
    5492       jj_consume_token(AT);
    5493       Name();
    5494       jj_consume_token(LPAREN);
    5495       switch (jj_nt.kind) {
    5496       case IDENTIFIER:
    5497         MemberValuePairs();
    5498         break;
    5499       default:
    5500         jj_la1[132] = jj_gen;
    5501         ;
    5502       }
    5503       jj_consume_token(RPAREN);
    5504                                                jjtree.closeNodeScope(jjtn000, true);
    5505                                                jjtc000 = false;
    5506                                               checkForBadAnnotationUsage();
    5507     } catch (Throwable jjte000) {
    5508      if (jjtc000) {
    5509        jjtree.clearNodeScope(jjtn000);
    5510        jjtc000 = false;
    5511      } else {
    5512        jjtree.popNode();
    5513      }
    5514      if (jjte000 instanceof RuntimeException) {
    5515        {if (true) throw (RuntimeException)jjte000;}
    5516      }
    5517      if (jjte000 instanceof ParseException) {
    5518        {if (true) throw (ParseException)jjte000;}
    5519      }
    5520      {if (true) throw (Error)jjte000;}
    5521     } finally {
    5522      if (jjtc000) {
    5523        jjtree.closeNodeScope(jjtn000, true);
    5524      }
    5525     }
    5526   }
    5527
    5528   final public void MarkerAnnotation() throws ParseException {
    5529  /*@bgen(jjtree) MarkerAnnotation */
    5530   ASTMarkerAnnotation jjtn000 = new ASTMarkerAnnotation(this, JJTMARKERANNOTATION);
    5531   boolean jjtc000 = true;
    5532   jjtree.openNodeScope(jjtn000);
    5533     try {
    5534       jj_consume_token(AT);
    5535       Name();
    5536                jjtree.closeNodeScope(jjtn000, true);
    5537                jjtc000 = false;
    5538               checkForBadAnnotationUsage();
    5539     } catch (Throwable jjte000) {
    5540     if (jjtc000) {
    5541       jjtree.clearNodeScope(jjtn000);
    5542       jjtc000 = false;
    5543     } else {
    5544       jjtree.popNode();
    5545     }
    5546     if (jjte000 instanceof RuntimeException) {
    5547       {if (true) throw (RuntimeException)jjte000;}
    5548     }
    5549     if (jjte000 instanceof ParseException) {
    5550       {if (true) throw (ParseException)jjte000;}
    5551     }
    5552     {if (true) throw (Error)jjte000;}
    5553     } finally {
    5554     if (jjtc000) {
    5555       jjtree.closeNodeScope(jjtn000, true);
    5556     }
    5557     }
    5558   }
    5559
    5560   final public void SingleMemberAnnotation() throws ParseException {
    5561  /*@bgen(jjtree) SingleMemberAnnotation */
    5562   ASTSingleMemberAnnotation jjtn000 = new ASTSingleMemberAnnotation(this, JJTSINGLEMEMBERANNOTATION);
    5563   boolean jjtc000 = true;
    5564   jjtree.openNodeScope(jjtn000);
    5565     try {
    5566       jj_consume_token(AT);
    5567       Name();
    5568       jj_consume_token(LPAREN);
    5569       MemberValue();
    5570       jj_consume_token(RPAREN);
    5571                                      jjtree.closeNodeScope(jjtn000, true);
    5572                                      jjtc000 = false;
    5573                                     checkForBadAnnotationUsage();
    5574     } catch (Throwable jjte000) {
    5575     if (jjtc000) {
    5576       jjtree.clearNodeScope(jjtn000);
    5577       jjtc000 = false;
    5578     } else {
    5579       jjtree.popNode();
    5580     }
    5581     if (jjte000 instanceof RuntimeException) {
    5582       {if (true) throw (RuntimeException)jjte000;}
    5583     }
    5584     if (jjte000 instanceof ParseException) {
    5585       {if (true) throw (ParseException)jjte000;}
    5586     }
    5587     {if (true) throw (Error)jjte000;}
    5588     } finally {
    5589     if (jjtc000) {
    5590       jjtree.closeNodeScope(jjtn000, true);
    5591     }
    5592     }
    5593   }
    5594
    5595   final public void MemberValuePairs() throws ParseException {
    5596  /*@bgen(jjtree) MemberValuePairs */
    5597   ASTMemberValuePairs jjtn000 = new ASTMemberValuePairs(this, JJTMEMBERVALUEPAIRS);
    5598   boolean jjtc000 = true;
    5599   jjtree.openNodeScope(jjtn000);
    5600     try {
    5601       MemberValuePair();
    5602       label_52:
    5603       while (true) {
    5604         switch (jj_nt.kind) {
    5605         case COMMA:
    5606           ;
    5607           break;
    5608         default:
    5609           jj_la1[133] = jj_gen;
    5610           break label_52;
    5611         }
    5612         jj_consume_token(COMMA);
    5613         MemberValuePair();
    5614       }
    5615     } catch (Throwable jjte000) {
    5616      if (jjtc000) {
    5617        jjtree.clearNodeScope(jjtn000);
    5618        jjtc000 = false;
    5619      } else {
    5620        jjtree.popNode();
    5621      }
    5622      if (jjte000 instanceof RuntimeException) {
    5623        {if (true) throw (RuntimeException)jjte000;}
    5624      }
    5625      if (jjte000 instanceof ParseException) {
    5626        {if (true) throw (ParseException)jjte000;}
    5627      }
    5628      {if (true) throw (Error)jjte000;}
    5629     } finally {
    5630      if (jjtc000) {
    5631        jjtree.closeNodeScope(jjtn000, true);
    5632      }
    5633     }
    5634   }
    5635
    5636   final public void MemberValuePair() throws ParseException {
    5637  /*@bgen(jjtree) MemberValuePair */
    5638  ASTMemberValuePair jjtn000 = new ASTMemberValuePair(this, JJTMEMBERVALUEPAIR);
    5639  boolean jjtc000 = true;
    5640  jjtree.openNodeScope(jjtn000);Token t;
    5641     try {
    5642       t = jj_consume_token(IDENTIFIER);
    5643                      jjtn000.setImage(t.image);
    5644       jj_consume_token(ASSIGN);
    5645       MemberValue();
    5646     } catch (Throwable jjte000) {
    5647       if (jjtc000) {
    5648         jjtree.clearNodeScope(jjtn000);
    5649         jjtc000 = false;
    5650       } else {
    5651         jjtree.popNode();
    5652       }
    5653       if (jjte000 instanceof RuntimeException) {
    5654         {if (true) throw (RuntimeException)jjte000;}
    5655       }
    5656       if (jjte000 instanceof ParseException) {
    5657         {if (true) throw (ParseException)jjte000;}
    5658       }
    5659       {if (true) throw (Error)jjte000;}
    5660     } finally {
    5661       if (jjtc000) {
    5662         jjtree.closeNodeScope(jjtn000, true);
    5663       }
    5664     }
    5665   }
    5666
    5667   final public void MemberValue() throws ParseException {
    5668  /*@bgen(jjtree) MemberValue */
    5669   ASTMemberValue jjtn000 = new ASTMemberValue(this, JJTMEMBERVALUE);
    5670   boolean jjtc000 = true;
    5671   jjtree.openNodeScope(jjtn000);
    5672     try {
    5673       switch (jj_nt.kind) {
    5674       case AT:
    5675         Annotation();
    5676         break;
    5677       case LBRACE:
    5678         MemberValueArrayInitializer();
    5679         break;
    5680       case BOOLEAN:
    5681       case BYTE:
    5682       case CHAR:
    5683       case DOUBLE:
    5684       case FALSE:
    5685       case FLOAT:
    5686       case INT:
    5687       case LONG:
    5688       case NEW:
    5689       case NULL:
    5690       case SHORT:
    5691       case SUPER:
    5692       case THIS:
    5693       case TRUE:
    5694       case VOID:
    5695       case INTEGER_LITERAL:
    5696       case FLOATING_POINT_LITERAL:
    5697       case HEX_FLOATING_POINT_LITERAL:
    5698       case CHARACTER_LITERAL:
    5699       case STRING_LITERAL:
    5700       case IDENTIFIER:
    5701       case LPAREN:
    5702       case BANG:
    5703       case TILDE:
    5704       case INCR:
    5705       case DECR:
    5706       case PLUS:
    5707       case MINUS:
    5708         ConditionalExpression();
    5709         break;
    5710       default:
    5711         jj_la1[134] = jj_gen;
    5712         jj_consume_token(-1);
    5713         throw new ParseException();
    5714       }
    5715     } catch (Throwable jjte000) {
    5716      if (jjtc000) {
    5717        jjtree.clearNodeScope(jjtn000);
    5718        jjtc000 = false;
    5719      } else {
    5720        jjtree.popNode();
    5721      }
    5722      if (jjte000 instanceof RuntimeException) {
    5723        {if (true) throw (RuntimeException)jjte000;}
    5724      }
    5725      if (jjte000 instanceof ParseException) {
    5726        {if (true) throw (ParseException)jjte000;}
    5727      }
    5728      {if (true) throw (Error)jjte000;}
    5729     } finally {
    5730      if (jjtc000) {
    5731        jjtree.closeNodeScope(jjtn000, true);
    5732      }
    5733     }
    5734   }
    5735
    5736   final public void MemberValueArrayInitializer() throws ParseException {
    5737  /*@bgen(jjtree) MemberValueArrayInitializer */
    5738   ASTMemberValueArrayInitializer jjtn000 = new ASTMemberValueArrayInitializer(this, JJTMEMBERVALUEARRAYINITIALIZER);
    5739   boolean jjtc000 = true;
    5740   jjtree.openNodeScope(jjtn000);
    5741     try {
    5742       jj_consume_token(LBRACE);
    5743       switch (jj_nt.kind) {
    5744       case BOOLEAN:
    5745       case BYTE:
    5746       case CHAR:
    5747       case DOUBLE:
    5748       case FALSE:
    5749       case FLOAT:
    5750       case INT:
    5751       case LONG:
    5752       case NEW:
    5753       case NULL:
    5754       case SHORT:
    5755       case SUPER:
    5756       case THIS:
    5757       case TRUE:
    5758       case VOID:
    5759       case INTEGER_LITERAL:
    5760       case FLOATING_POINT_LITERAL:
    5761       case HEX_FLOATING_POINT_LITERAL:
    5762       case CHARACTER_LITERAL:
    5763       case STRING_LITERAL:
    5764       case IDENTIFIER:
    5765       case LPAREN:
    5766       case LBRACE:
    5767       case AT:
    5768       case BANG:
    5769       case TILDE:
    5770       case INCR:
    5771       case DECR:
    5772       case PLUS:
    5773       case MINUS:
    5774         MemberValue();
    5775         label_53:
    5776         while (true) {
    5777           if (jj_2_53(2)) {
    5778             ;
    5779           } else {
    5780             break label_53;
    5781           }
    5782           jj_consume_token(COMMA);
    5783           MemberValue();
    5784         }
    5785         switch (jj_nt.kind) {
    5786         case COMMA:
    5787           jj_consume_token(COMMA);
    5788           break;
    5789         default:
    5790           jj_la1[135] = jj_gen;
    5791           ;
    5792         }
    5793         break;
    5794       default:
    5795         jj_la1[136] = jj_gen;
    5796         ;
    5797       }
    5798       jj_consume_token(RBRACE);
    5799     } catch (Throwable jjte000) {
    5800     if (jjtc000) {
    5801       jjtree.clearNodeScope(jjtn000);
    5802       jjtc000 = false;
    5803     } else {
    5804       jjtree.popNode();
    5805     }
    5806     if (jjte000 instanceof RuntimeException) {
    5807       {if (true) throw (RuntimeException)jjte000;}
    5808     }
    5809     if (jjte000 instanceof ParseException) {
    5810       {if (true) throw (ParseException)jjte000;}
    5811     }
    5812     {if (true) throw (Error)jjte000;}
    5813     } finally {
    5814     if (jjtc000) {
    5815       jjtree.closeNodeScope(jjtn000, true);
    5816     }
    5817     }
    5818   }
    5819
    5820 /* Annotation Types. */
    5821   final public void AnnotationTypeDeclaration(int modifiers) throws ParseException {
    5822  /*@bgen(jjtree) AnnotationTypeDeclaration */
    5823 ASTAnnotationTypeDeclaration jjtn000 = new ASTAnnotationTypeDeclaration(this, JJTANNOTATIONTYPEDECLARATION);
    5824 boolean jjtc000 = true;
    5825 jjtree.openNodeScope(jjtn000);Token t;
    5826 jjtn000.setModifiers(modifiers);
    5827     try {
    5828       jj_consume_token(AT);
    5829       jj_consume_token(INTERFACE);
    5830       t = jj_consume_token(IDENTIFIER);
    5831                                   checkForBadAnnotationUsage();jjtn000.setImage(t.image);
    5832       AnnotationTypeBody();
    5833     } catch (Throwable jjte000) {
    5834     if (jjtc000) {
    5835       jjtree.clearNodeScope(jjtn000);
    5836       jjtc000 = false;
    5837     } else {
    5838       jjtree.popNode();
    5839     }
    5840     if (jjte000 instanceof RuntimeException) {
    5841       {if (true) throw (RuntimeException)jjte000;}
    5842     }
    5843     if (jjte000 instanceof ParseException) {
    5844       {if (true) throw (ParseException)jjte000;}
    5845     }
    5846     {if (true) throw (Error)jjte000;}
    5847     } finally {
    5848     if (jjtc000) {
    5849       jjtree.closeNodeScope(jjtn000, true);
    5850     }
    5851     }
    5852   }
    5853
    5854   final public void AnnotationTypeBody() throws ParseException {
    5855  /*@bgen(jjtree) AnnotationTypeBody */
    5856   ASTAnnotationTypeBody jjtn000 = new ASTAnnotationTypeBody(this, JJTANNOTATIONTYPEBODY);
    5857   boolean jjtc000 = true;
    5858   jjtree.openNodeScope(jjtn000);
    5859     try {
    5860       jj_consume_token(LBRACE);
    5861       label_54:
    5862       while (true) {
    5863         switch (jj_nt.kind) {
    5864         case ABSTRACT:
    5865         case BOOLEAN:
    5866         case BYTE:
    5867         case CHAR:
    5868         case CLASS:
    5869         case DOUBLE:
    5870         case FINAL:
    5871         case FLOAT:
    5872         case INT:
    5873         case INTERFACE:
    5874         case LONG:
    5875         case NATIVE:
    5876         case PRIVATE:
    5877         case PROTECTED:
    5878         case PUBLIC:
    5879         case SHORT:
    5880         case STATIC:
    5881         case SYNCHRONIZED:
    5882         case TRANSIENT:
    5883         case VOLATILE:
    5884         case STRICTFP:
    5885         case IDENTIFIER:
    5886         case SEMICOLON:
    5887         case AT:
    5888           ;
    5889           break;
    5890         default:
    5891           jj_la1[137] = jj_gen;
    5892           break label_54;
    5893         }
    5894         AnnotationTypeMemberDeclaration();
    5895       }
    5896       jj_consume_token(RBRACE);
    5897     } catch (Throwable jjte000) {
    5898     if (jjtc000) {
    5899       jjtree.clearNodeScope(jjtn000);
    5900       jjtc000 = false;
    5901     } else {
    5902       jjtree.popNode();
    5903     }
    5904     if (jjte000 instanceof RuntimeException) {
    5905       {if (true) throw (RuntimeException)jjte000;}
    5906     }
    5907     if (jjte000 instanceof ParseException) {
    5908       {if (true) throw (ParseException)jjte000;}
    5909     }
    5910     {if (true) throw (Error)jjte000;}
    5911     } finally {
    5912     if (jjtc000) {
    5913       jjtree.closeNodeScope(jjtn000, true);
    5914     }
    5915     }
    5916   }
    5917
    5918   final public void AnnotationTypeMemberDeclaration() throws ParseException {
    5919  /*@bgen(jjtree) AnnotationTypeMemberDeclaration */
    5920    ASTAnnotationTypeMemberDeclaration jjtn000 = new ASTAnnotationTypeMemberDeclaration(this, JJTANNOTATIONTYPEMEMBERDECLARATION);
    5921    boolean jjtc000 = true;
    5922    jjtree.openNodeScope(jjtn000);int modifiers;
    5923     try {
    5924       switch (jj_nt.kind) {
    5925       case ABSTRACT:
    5926       case BOOLEAN:
    5927       case BYTE:
    5928       case CHAR:
    5929       case CLASS:
    5930       case DOUBLE:
    5931       case FINAL:
    5932       case FLOAT:
    5933       case INT:
    5934       case INTERFACE:
    5935       case LONG:
    5936       case NATIVE:
    5937       case PRIVATE:
    5938       case PROTECTED:
    5939       case PUBLIC:
    5940       case SHORT:
    5941       case STATIC:
    5942       case SYNCHRONIZED:
    5943       case TRANSIENT:
    5944       case VOLATILE:
    5945       case STRICTFP:
    5946       case IDENTIFIER:
    5947       case AT:
    5948         modifiers = Modifiers();
    5949         if (jj_2_54(3)) {
    5950           AnnotationMethodDeclaration(modifiers);
    5951         } else {
    5952           switch (jj_nt.kind) {
    5953           case ABSTRACT:
    5954           case CLASS:
    5955           case FINAL:
    5956           case INTERFACE:
    5957             ClassOrInterfaceDeclaration(modifiers);
    5958             break;
    5959           default:
    5960             jj_la1[138] = jj_gen;
    5961             if (jj_2_55(3)) {
    5962               EnumDeclaration(modifiers);
    5963             } else {
    5964               switch (jj_nt.kind) {
    5965               case AT:
    5966                 AnnotationTypeDeclaration(modifiers);
    5967                 break;
    5968               case BOOLEAN:
    5969               case BYTE:
    5970               case CHAR:
    5971               case DOUBLE:
    5972               case FLOAT:
    5973               case INT:
    5974               case LONG:
    5975               case SHORT:
    5976               case IDENTIFIER:
    5977                 FieldDeclaration(modifiers);
    5978                 break;
    5979               default:
    5980                 jj_la1[139] = jj_gen;
    5981                 jj_consume_token(-1);
    5982                 throw new ParseException();
    5983               }
    5984             }
    5985           }
    5986         }
    5987         break;
    5988       case SEMICOLON:
    5989         jj_consume_token(SEMICOLON);
    5990         break;
    5991       default:
    5992         jj_la1[140] = jj_gen;
    5993         jj_consume_token(-1);
    5994         throw new ParseException();
    5995       }
    5996     } catch (Throwable jjte000) {
    5997    if (jjtc000) {
    5998      jjtree.clearNodeScope(jjtn000);
    5999      jjtc000 = false;
    6000    } else {
    6001      jjtree.popNode();
    6002    }
    6003    if (jjte000 instanceof RuntimeException) {
    6004      {if (true) throw (RuntimeException)jjte000;}
    6005    }
    6006    if (jjte000 instanceof ParseException) {
    6007      {if (true) throw (ParseException)jjte000;}
    6008    }
    6009    {if (true) throw (Error)jjte000;}
    6010     } finally {
    6011    if (jjtc000) {
    6012      jjtree.closeNodeScope(jjtn000, true);
    6013    }
    6014     }
    6015   }
    6016
    6017   final public void AnnotationMethodDeclaration(int modifiers) throws ParseException {
    6018  /*@bgen(jjtree) AnnotationMethodDeclaration */
    6019   ASTAnnotationMethodDeclaration jjtn000 = new ASTAnnotationMethodDeclaration(this, JJTANNOTATIONMETHODDECLARATION);
    6020   boolean jjtc000 = true;
    6021   jjtree.openNodeScope(jjtn000);Token t;
    6022   jjtn000.setModifiers(modifiers);
    6023     try {
    6024       Type();
    6025       t = jj_consume_token(IDENTIFIER);
    6026       jj_consume_token(LPAREN);
    6027       jj_consume_token(RPAREN);
    6028       switch (jj_nt.kind) {
    6029       case _DEFAULT:
    6030         DefaultValue();
    6031         break;
    6032       default:
    6033         jj_la1[141] = jj_gen;
    6034         ;
    6035       }
    6036       jj_consume_token(SEMICOLON);
    6037     jjtree.closeNodeScope(jjtn000, true);
    6038     jjtc000 = false;
    6039     jjtn000.setImage(t.image);
    6040     } catch (Throwable jjte000) {
    6041     if (jjtc000) {
    6042       jjtree.clearNodeScope(jjtn000);
    6043       jjtc000 = false;
    6044     } else {
    6045       jjtree.popNode();
    6046     }
    6047     if (jjte000 instanceof RuntimeException) {
    6048       {if (true) throw (RuntimeException)jjte000;}
    6049     }
    6050     if (jjte000 instanceof ParseException) {
    6051       {if (true) throw (ParseException)jjte000;}
    6052     }
    6053     {if (true) throw (Error)jjte000;}
    6054     } finally {
    6055     if (jjtc000) {
    6056       jjtree.closeNodeScope(jjtn000, true);
    6057     }
    6058     }
    6059   }
    6060
    6061   final public void DefaultValue() throws ParseException {
    6062  /*@bgen(jjtree) DefaultValue */
    6063   ASTDefaultValue jjtn000 = new ASTDefaultValue(this, JJTDEFAULTVALUE);
    6064   boolean jjtc000 = true;
    6065   jjtree.openNodeScope(jjtn000);
    6066     try {
    6067       jj_consume_token(_DEFAULT);
    6068       MemberValue();
    6069     } catch (Throwable jjte000) {
    6070     if (jjtc000) {
    6071       jjtree.clearNodeScope(jjtn000);
    6072       jjtc000 = false;
    6073     } else {
    6074       jjtree.popNode();
    6075     }
    6076     if (jjte000 instanceof RuntimeException) {
    6077       {if (true) throw (RuntimeException)jjte000;}
    6078     }
    6079     if (jjte000 instanceof ParseException) {
    6080       {if (true) throw (ParseException)jjte000;}
    6081     }
    6082     {if (true) throw (Error)jjte000;}
    6083     } finally {
    6084     if (jjtc000) {
    6085       jjtree.closeNodeScope(jjtn000, true);
    6086     }
    6087     }
    6088   }
    6089
    6090   private boolean jj_2_1(int xla) {
    6091     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6092     try { return !jj_3_1(); }
    6093     catch(LookaheadSuccess ls) { return true; }
    6094     finally { jj_save(0, xla); }
    6095   }
    6096
    6097   private boolean jj_2_2(int xla) {
    6098     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6099     try { return !jj_3_2(); }
    6100     catch(LookaheadSuccess ls) { return true; }
    6101     finally { jj_save(1, xla); }
    6102   }
    6103
    6104   private boolean jj_2_3(int xla) {
    6105     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6106     try { return !jj_3_3(); }
    6107     catch(LookaheadSuccess ls) { return true; }
    6108     finally { jj_save(2, xla); }
    6109   }
    6110
    6111   private boolean jj_2_4(int xla) {
    6112     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6113     try { return !jj_3_4(); }
    6114     catch(LookaheadSuccess ls) { return true; }
    6115     finally { jj_save(3, xla); }
    6116   }
    6117
    6118   private boolean jj_2_5(int xla) {
    6119     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6120     try { return !jj_3_5(); }
    6121     catch(LookaheadSuccess ls) { return true; }
    6122     finally { jj_save(4, xla); }
    6123   }
    6124
    6125   private boolean jj_2_6(int xla) {
    6126     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6127     try { return !jj_3_6(); }
    6128     catch(LookaheadSuccess ls) { return true; }
    6129     finally { jj_save(5, xla); }
    6130   }
    6131
    6132   private boolean jj_2_7(int xla) {
    6133     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6134     try { return !jj_3_7(); }
    6135     catch(LookaheadSuccess ls) { return true; }
    6136     finally { jj_save(6, xla); }
    6137   }
    6138
    6139   private boolean jj_2_8(int xla) {
    6140     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6141     try { return !jj_3_8(); }
    6142     catch(LookaheadSuccess ls) { return true; }
    6143     finally { jj_save(7, xla); }
    6144   }
    6145
    6146   private boolean jj_2_9(int xla) {
    6147     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6148     try { return !jj_3_9(); }
    6149     catch(LookaheadSuccess ls) { return true; }
    6150     finally { jj_save(8, xla); }
    6151   }
    6152
    6153   private boolean jj_2_10(int xla) {
    6154     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6155     try { return !jj_3_10(); }
    6156     catch(LookaheadSuccess ls) { return true; }
    6157     finally { jj_save(9, xla); }
    6158   }
    6159
    6160   private boolean jj_2_11(int xla) {
    6161     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6162     try { return !jj_3_11(); }
    6163     catch(LookaheadSuccess ls) { return true; }
    6164     finally { jj_save(10, xla); }
    6165   }
    6166
    6167   private boolean jj_2_12(int xla) {
    6168     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6169     try { return !jj_3_12(); }
    6170     catch(LookaheadSuccess ls) { return true; }
    6171     finally { jj_save(11, xla); }
    6172   }
    6173
    6174   private boolean jj_2_13(int xla) {
    6175     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6176     try { return !jj_3_13(); }
    6177     catch(LookaheadSuccess ls) { return true; }
    6178     finally { jj_save(12, xla); }
    6179   }
    6180
    6181   private boolean jj_2_14(int xla) {
    6182     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6183     try { return !jj_3_14(); }
    6184     catch(LookaheadSuccess ls) { return true; }
    6185     finally { jj_save(13, xla); }
    6186   }
    6187
    6188   private boolean jj_2_15(int xla) {
    6189     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6190     try { return !jj_3_15(); }
    6191     catch(LookaheadSuccess ls) { return true; }
    6192     finally { jj_save(14, xla); }
    6193   }
    6194
    6195   private boolean jj_2_16(int xla) {
    6196     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6197     try { return !jj_3_16(); }
    6198     catch(LookaheadSuccess ls) { return true; }
    6199     finally { jj_save(15, xla); }
    6200   }
    6201
    6202   private boolean jj_2_17(int xla) {
    6203     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6204     try { return !jj_3_17(); }
    6205     catch(LookaheadSuccess ls) { return true; }
    6206     finally { jj_save(16, xla); }
    6207   }
    6208
    6209   private boolean jj_2_18(int xla) {
    6210     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6211     try { return !jj_3_18(); }
    6212     catch(LookaheadSuccess ls) { return true; }
    6213     finally { jj_save(17, xla); }
    6214   }
    6215
    6216   private boolean jj_2_19(int xla) {
    6217     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6218     try { return !jj_3_19(); }
    6219     catch(LookaheadSuccess ls) { return true; }
    6220     finally { jj_save(18, xla); }
    6221   }
    6222
    6223   private boolean jj_2_20(int xla) {
    6224     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6225     try { return !jj_3_20(); }
    6226     catch(LookaheadSuccess ls) { return true; }
    6227     finally { jj_save(19, xla); }
    6228   }
    6229
    6230   private boolean jj_2_21(int xla) {
    6231     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6232     try { return !jj_3_21(); }
    6233     catch(LookaheadSuccess ls) { return true; }
    6234     finally { jj_save(20, xla); }
    6235   }
    6236
    6237   private boolean jj_2_22(int xla) {
    6238     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6239     try { return !jj_3_22(); }
    6240     catch(LookaheadSuccess ls) { return true; }
    6241     finally { jj_save(21, xla); }
    6242   }
    6243
    6244   private boolean jj_2_23(int xla) {
    6245     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6246     try { return !jj_3_23(); }
    6247     catch(LookaheadSuccess ls) { return true; }
    6248     finally { jj_save(22, xla); }
    6249   }
    6250
    6251   private boolean jj_2_24(int xla) {
    6252     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6253     try { return !jj_3_24(); }
    6254     catch(LookaheadSuccess ls) { return true; }
    6255     finally { jj_save(23, xla); }
    6256   }
    6257
    6258   private boolean jj_2_25(int xla) {
    6259     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6260     try { return !jj_3_25(); }
    6261     catch(LookaheadSuccess ls) { return true; }
    6262     finally { jj_save(24, xla); }
    6263   }
    6264
    6265   private boolean jj_2_26(int xla) {
    6266     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6267     try { return !jj_3_26(); }
    6268     catch(LookaheadSuccess ls) { return true; }
    6269     finally { jj_save(25, xla); }
    6270   }
    6271
    6272   private boolean jj_2_27(int xla) {
    6273     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6274     try { return !jj_3_27(); }
    6275     catch(LookaheadSuccess ls) { return true; }
    6276     finally { jj_save(26, xla); }
    6277   }
    6278
    6279   private boolean jj_2_28(int xla) {
    6280     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6281     try { return !jj_3_28(); }
    6282     catch(LookaheadSuccess ls) { return true; }
    6283     finally { jj_save(27, xla); }
    6284   }
    6285
    6286   private boolean jj_2_29(int xla) {
    6287     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6288     try { return !jj_3_29(); }
    6289     catch(LookaheadSuccess ls) { return true; }
    6290     finally { jj_save(28, xla); }
    6291   }
    6292
    6293   private boolean jj_2_30(int xla) {
    6294     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6295     try { return !jj_3_30(); }
    6296     catch(LookaheadSuccess ls) { return true; }
    6297     finally { jj_save(29, xla); }
    6298   }
    6299
    6300   private boolean jj_2_31(int xla) {
    6301     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6302     try { return !jj_3_31(); }
    6303     catch(LookaheadSuccess ls) { return true; }
    6304     finally { jj_save(30, xla); }
    6305   }
    6306
    6307   private boolean jj_2_32(int xla) {
    6308     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6309     try { return !jj_3_32(); }
    6310     catch(LookaheadSuccess ls) { return true; }
    6311     finally { jj_save(31, xla); }
    6312   }
    6313
    6314   private boolean jj_2_33(int xla) {
    6315     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6316     try { return !jj_3_33(); }
    6317     catch(LookaheadSuccess ls) { return true; }
    6318     finally { jj_save(32, xla); }
    6319   }
    6320
    6321   private boolean jj_2_34(int xla) {
    6322     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6323     try { return !jj_3_34(); }
    6324     catch(LookaheadSuccess ls) { return true; }
    6325     finally { jj_save(33, xla); }
    6326   }
    6327
    6328   private boolean jj_2_35(int xla) {
    6329     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6330     try { return !jj_3_35(); }
    6331     catch(LookaheadSuccess ls) { return true; }
    6332     finally { jj_save(34, xla); }
    6333   }
    6334
    6335   private boolean jj_2_36(int xla) {
    6336     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6337     try { return !jj_3_36(); }
    6338     catch(LookaheadSuccess ls) { return true; }
    6339     finally { jj_save(35, xla); }
    6340   }
    6341
    6342   private boolean jj_2_37(int xla) {
    6343     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6344     try { return !jj_3_37(); }
    6345     catch(LookaheadSuccess ls) { return true; }
    6346     finally { jj_save(36, xla); }
    6347   }
    6348
    6349   private boolean jj_2_38(int xla) {
    6350     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6351     try { return !jj_3_38(); }
    6352     catch(LookaheadSuccess ls) { return true; }
    6353     finally { jj_save(37, xla); }
    6354   }
    6355
    6356   private boolean jj_2_39(int xla) {
    6357     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6358     try { return !jj_3_39(); }
    6359     catch(LookaheadSuccess ls) { return true; }
    6360     finally { jj_save(38, xla); }
    6361   }
    6362
    6363   private boolean jj_2_40(int xla) {
    6364     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6365     try { return !jj_3_40(); }
    6366     catch(LookaheadSuccess ls) { return true; }
    6367     finally { jj_save(39, xla); }
    6368   }
    6369
    6370   private boolean jj_2_41(int xla) {
    6371     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6372     try { return !jj_3_41(); }
    6373     catch(LookaheadSuccess ls) { return true; }
    6374     finally { jj_save(40, xla); }
    6375   }
    6376
    6377   private boolean jj_2_42(int xla) {
    6378     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6379     try { return !jj_3_42(); }
    6380     catch(LookaheadSuccess ls) { return true; }
    6381     finally { jj_save(41, xla); }
    6382   }
    6383
    6384   private boolean jj_2_43(int xla) {
    6385     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6386     try { return !jj_3_43(); }
    6387     catch(LookaheadSuccess ls) { return true; }
    6388     finally { jj_save(42, xla); }
    6389   }
    6390
    6391   private boolean jj_2_44(int xla) {
    6392     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6393     try { return !jj_3_44(); }
    6394     catch(LookaheadSuccess ls) { return true; }
    6395     finally { jj_save(43, xla); }
    6396   }
    6397
    6398   private boolean jj_2_45(int xla) {
    6399     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6400     try { return !jj_3_45(); }
    6401     catch(LookaheadSuccess ls) { return true; }
    6402     finally { jj_save(44, xla); }
    6403   }
    6404
    6405   private boolean jj_2_46(int xla) {
    6406     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6407     try { return !jj_3_46(); }
    6408     catch(LookaheadSuccess ls) { return true; }
    6409     finally { jj_save(45, xla); }
    6410   }
    6411
    6412   private boolean jj_2_47(int xla) {
    6413     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6414     try { return !jj_3_47(); }
    6415     catch(LookaheadSuccess ls) { return true; }
    6416     finally { jj_save(46, xla); }
    6417   }
    6418
    6419   private boolean jj_2_48(int xla) {
    6420     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6421     try { return !jj_3_48(); }
    6422     catch(LookaheadSuccess ls) { return true; }
    6423     finally { jj_save(47, xla); }
    6424   }
    6425
    6426   private boolean jj_2_49(int xla) {
    6427     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6428     try { return !jj_3_49(); }
    6429     catch(LookaheadSuccess ls) { return true; }
    6430     finally { jj_save(48, xla); }
    6431   }
    6432
    6433   private boolean jj_2_50(int xla) {
    6434     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6435     try { return !jj_3_50(); }
    6436     catch(LookaheadSuccess ls) { return true; }
    6437     finally { jj_save(49, xla); }
    6438   }
    6439
    6440   private boolean jj_2_51(int xla) {
    6441     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6442     try { return !jj_3_51(); }
    6443     catch(LookaheadSuccess ls) { return true; }
    6444     finally { jj_save(50, xla); }
    6445   }
    6446
    6447   private boolean jj_2_52(int xla) {
    6448     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6449     try { return !jj_3_52(); }
    6450     catch(LookaheadSuccess ls) { return true; }
    6451     finally { jj_save(51, xla); }
    6452   }
    6453
    6454   private boolean jj_2_53(int xla) {
    6455     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6456     try { return !jj_3_53(); }
    6457     catch(LookaheadSuccess ls) { return true; }
    6458     finally { jj_save(52, xla); }
    6459   }
    6460
    6461   private boolean jj_2_54(int xla) {
    6462     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6463     try { return !jj_3_54(); }
    6464     catch(LookaheadSuccess ls) { return true; }
    6465     finally { jj_save(53, xla); }
    6466   }
    6467
    6468   private boolean jj_2_55(int xla) {
    6469     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6470     try { return !jj_3_55(); }
    6471     catch(LookaheadSuccess ls) { return true; }
    6472     finally { jj_save(54, xla); }
    6473   }
    6474
    6475   private boolean jj_3R_341() {
    6476     if (jj_scan_token(COMMA)) return true;
    6477     if (jj_3R_100()) return true;
    6478     return false;
    6479   }
    6480
    6481   private boolean jj_3R_327() {
    6482     if (jj_3R_100()) return true;
    6483     Token xsp;
    6484     while (true) {
    6485       xsp = jj_scanpos;
    6486       if (jj_3R_341()) { jj_scanpos = xsp; break; }
    6487     }
    6488     return false;
    6489   }
    6490
    6491   private boolean jj_3_20() {
    6492     if (jj_3R_80()) return true;
    6493     return false;
    6494   }
    6495
    6496   private boolean jj_3_22() {
    6497     if (jj_scan_token(DOT)) return true;
    6498     if (jj_scan_token(IDENTIFIER)) return true;
    6499     return false;
    6500   }
    6501
    6502   private boolean jj_3R_192() {
    6503     if (jj_scan_token(COMMA)) return true;
    6504     if (jj_3R_82()) return true;
    6505     return false;
    6506   }
    6507
    6508   private boolean jj_3R_100() {
    6509     if (jj_scan_token(IDENTIFIER)) return true;
    6510     Token xsp;
    6511     while (true) {
    6512       xsp = jj_scanpos;
    6513       if (jj_3_22()) { jj_scanpos = xsp; break; }
    6514     }
    6515     return false;
    6516   }
    6517
    6518   private boolean jj_3R_145() {
    6519     if (jj_3R_73()) return true;
    6520     return false;
    6521   }
    6522
    6523   private boolean jj_3R_89() {
    6524     Token xsp;
    6525     xsp = jj_scanpos;
    6526     if (jj_scan_token(59)) {
    6527     jj_scanpos = xsp;
    6528     if (jj_3R_145()) return true;
    6529     }
    6530     return false;
    6531   }
    6532
    6533   private boolean jj_3R_141() {
    6534     if (jj_scan_token(DOUBLE)) return true;
    6535     return false;
    6536   }
    6537
    6538   private boolean jj_3R_140() {
    6539     if (jj_scan_token(FLOAT)) return true;
    6540     return false;
    6541   }
    6542
    6543   private boolean jj_3R_139() {
    6544     if (jj_scan_token(LONG)) return true;
    6545     return false;
    6546   }
    6547
    6548   private boolean jj_3R_138() {
    6549     if (jj_scan_token(INT)) return true;
    6550     return false;
    6551   }
    6552
    6553   private boolean jj_3R_137() {
    6554     if (jj_scan_token(SHORT)) return true;
    6555     return false;
    6556   }
    6557
    6558   private boolean jj_3R_136() {
    6559     if (jj_scan_token(BYTE)) return true;
    6560     return false;
    6561   }
    6562
    6563   private boolean jj_3R_135() {
    6564     if (jj_scan_token(CHAR)) return true;
    6565     return false;
    6566   }
    6567
    6568   private boolean jj_3R_134() {
    6569     if (jj_scan_token(BOOLEAN)) return true;
    6570     return false;
    6571   }
    6572
    6573   private boolean jj_3R_87() {
    6574     Token xsp;
    6575     xsp = jj_scanpos;
    6576     if (jj_3R_134()) {
    6577     jj_scanpos = xsp;
    6578     if (jj_3R_135()) {
    6579     jj_scanpos = xsp;
    6580     if (jj_3R_136()) {
    6581     jj_scanpos = xsp;
    6582     if (jj_3R_137()) {
    6583     jj_scanpos = xsp;
    6584     if (jj_3R_138()) {
    6585     jj_scanpos = xsp;
    6586     if (jj_3R_139()) {
    6587     jj_scanpos = xsp;
    6588     if (jj_3R_140()) {
    6589     jj_scanpos = xsp;
    6590     if (jj_3R_141()) return true;
    6591     }
    6592     }
    6593     }
    6594     }
    6595     }
    6596     }
    6597     }
    6598     return false;
    6599   }
    6600
    6601   private boolean jj_3R_181() {
    6602     if (jj_3R_80()) return true;
    6603     return false;
    6604   }
    6605
    6606   private boolean jj_3R_274() {
    6607     if (jj_scan_token(SUPER)) return true;
    6608     if (jj_3R_81()) return true;
    6609     return false;
    6610   }
    6611
    6612   private boolean jj_3R_238() {
    6613     if (jj_3R_253()) return true;
    6614     return false;
    6615   }
    6616
    6617   private boolean jj_3R_253() {
    6618     Token xsp;
    6619     xsp = jj_scanpos;
    6620     if (jj_3R_273()) {
    6621     jj_scanpos = xsp;
    6622     if (jj_3R_274()) return true;
    6623     }
    6624     return false;
    6625   }
    6626
    6627   private boolean jj_3R_273() {
    6628     if (jj_scan_token(EXTENDS)) return true;
    6629     if (jj_3R_81()) return true;
    6630     return false;
    6631   }
    6632
    6633   private boolean jj_3R_129() {
    6634     if (jj_scan_token(HOOK)) return true;
    6635     Token xsp;
    6636     xsp = jj_scanpos;
    6637     if (jj_3R_238()) jj_scanpos = xsp;
    6638     return false;
    6639   }
    6640
    6641   private boolean jj_3_17() {
    6642     if (jj_scan_token(LBRACKET)) return true;
    6643     if (jj_scan_token(RBRACKET)) return true;
    6644     return false;
    6645   }
    6646
    6647   private boolean jj_3R_128() {
    6648     if (jj_3R_81()) return true;
    6649     return false;
    6650   }
    6651
    6652   private boolean jj_3R_82() {
    6653     Token xsp;
    6654     xsp = jj_scanpos;
    6655     if (jj_3R_128()) {
    6656     jj_scanpos = xsp;
    6657     if (jj_3R_129()) return true;
    6658     }
    6659     return false;
    6660   }
    6661
    6662   private boolean jj_3R_125() {
    6663     if (jj_scan_token(LT)) return true;
    6664     if (jj_scan_token(GT)) return true;
    6665     return false;
    6666   }
    6667
    6668   private boolean jj_3R_80() {
    6669     Token xsp;
    6670     xsp = jj_scanpos;
    6671     if (jj_3_21()) {
    6672     jj_scanpos = xsp;
    6673     if (jj_3R_125()) return true;
    6674     }
    6675     return false;
    6676   }
    6677
    6678   private boolean jj_3_21() {
    6679     if (jj_scan_token(LT)) return true;
    6680     if (jj_3R_82()) return true;
    6681     Token xsp;
    6682     while (true) {
    6683       xsp = jj_scanpos;
    6684       if (jj_3R_192()) { jj_scanpos = xsp; break; }
    6685     }
    6686     if (jj_scan_token(GT)) return true;
    6687     return false;
    6688   }
    6689
    6690   private boolean jj_3_16() {
    6691     if (jj_scan_token(LBRACKET)) return true;
    6692     if (jj_scan_token(RBRACKET)) return true;
    6693     return false;
    6694   }
    6695
    6696   private boolean jj_3R_382() {
    6697     if (jj_3R_391()) return true;
    6698     return false;
    6699   }
    6700
    6701   private boolean jj_3_19() {
    6702     if (jj_scan_token(DOT)) return true;
    6703     if (jj_scan_token(IDENTIFIER)) return true;
    6704     Token xsp;
    6705     xsp = jj_scanpos;
    6706     if (jj_3_20()) jj_scanpos = xsp;
    6707     return false;
    6708   }
    6709
    6710   private boolean jj_3_18() {
    6711     if (jj_3R_80()) return true;
    6712     return false;
    6713   }
    6714
    6715   private boolean jj_3R_193() {
    6716     if (jj_scan_token(IDENTIFIER)) return true;
    6717     Token xsp;
    6718     xsp = jj_scanpos;
    6719     if (jj_3_18()) jj_scanpos = xsp;
    6720     while (true) {
    6721       xsp = jj_scanpos;
    6722       if (jj_3_19()) { jj_scanpos = xsp; break; }
    6723     }
    6724     return false;
    6725   }
    6726
    6727   private boolean jj_3R_127() {
    6728     if (jj_3R_193()) return true;
    6729     Token xsp;
    6730     while (true) {
    6731       xsp = jj_scanpos;
    6732       if (jj_3_17()) { jj_scanpos = xsp; break; }
    6733     }
    6734     return false;
    6735   }
    6736
    6737   private boolean jj_3R_126() {
    6738     if (jj_3R_87()) return true;
    6739     Token xsp;
    6740     if (jj_3_16()) return true;
    6741     while (true) {
    6742       xsp = jj_scanpos;
    6743       if (jj_3_16()) { jj_scanpos = xsp; break; }
    6744     }
    6745     return false;
    6746   }
    6747
    6748   private boolean jj_3R_81() {
    6749     Token xsp;
    6750     xsp = jj_scanpos;
    6751     if (jj_3R_126()) {
    6752     jj_scanpos = xsp;
    6753     if (jj_3R_127()) return true;
    6754     }
    6755     return false;
    6756   }
    6757
    6758   private boolean jj_3R_311() {
    6759     if (jj_scan_token(THROWS)) return true;
    6760     if (jj_3R_327()) return true;
    6761     return false;
    6762   }
    6763
    6764   private boolean jj_3R_114() {
    6765     if (jj_3R_87()) return true;
    6766     return false;
    6767   }
    6768
    6769   private boolean jj_3R_73() {
    6770     Token xsp;
    6771     xsp = jj_scanpos;
    6772     if (jj_3_15()) {
    6773     jj_scanpos = xsp;
    6774     if (jj_3R_114()) return true;
    6775     }
    6776     return false;
    6777   }
    6778
    6779   private boolean jj_3_15() {
    6780     if (jj_3R_81()) return true;
    6781     return false;
    6782   }
    6783
    6784   private boolean jj_3R_391() {
    6785     if (jj_scan_token(_DEFAULT)) return true;
    6786     if (jj_3R_102()) return true;
    6787     return false;
    6788   }
    6789
    6790   private boolean jj_3R_363() {
    6791     if (jj_3R_104()) return true;
    6792     return false;
    6793   }
    6794
    6795   private boolean jj_3_12() {
    6796     if (jj_3R_78()) return true;
    6797     if (jj_scan_token(DOT)) return true;
    6798     return false;
    6799   }
    6800
    6801   private boolean jj_3R_302() {
    6802     if (jj_scan_token(STATIC)) return true;
    6803     return false;
    6804   }
    6805
    6806   private boolean jj_3_14() {
    6807     if (jj_3R_80()) return true;
    6808     if (jj_scan_token(THIS)) return true;
    6809     if (jj_3R_79()) return true;
    6810     if (jj_scan_token(SEMICOLON)) return true;
    6811     return false;
    6812   }
    6813
    6814   private boolean jj_3R_103() {
    6815     if (jj_3R_73()) return true;
    6816     if (jj_scan_token(IDENTIFIER)) return true;
    6817     if (jj_scan_token(LPAREN)) return true;
    6818     if (jj_scan_token(RPAREN)) return true;
    6819     Token xsp;
    6820     xsp = jj_scanpos;
    6821     if (jj_3R_382()) jj_scanpos = xsp;
    6822     if (jj_scan_token(SEMICOLON)) return true;
    6823     return false;
    6824   }
    6825
    6826   private boolean jj_3R_292() {
    6827     Token xsp;
    6828     xsp = jj_scanpos;
    6829     if (jj_3R_302()) jj_scanpos = xsp;
    6830     if (jj_3R_196()) return true;
    6831     return false;
    6832   }
    6833
    6834   private boolean jj_3_13() {
    6835     if (jj_scan_token(THIS)) return true;
    6836     if (jj_3R_79()) return true;
    6837     if (jj_scan_token(SEMICOLON)) return true;
    6838     return false;
    6839   }
    6840
    6841   private boolean jj_3_10() {
    6842     if (jj_3R_76()) return true;
    6843     return false;
    6844   }
    6845
    6846   private boolean jj_3R_180() {
    6847     if (jj_3R_78()) return true;
    6848     if (jj_scan_token(DOT)) return true;
    6849     return false;
    6850   }
    6851
    6852   private boolean jj_3R_119() {
    6853     Token xsp;
    6854     xsp = jj_scanpos;
    6855     if (jj_3R_180()) jj_scanpos = xsp;
    6856     xsp = jj_scanpos;
    6857     if (jj_3R_181()) jj_scanpos = xsp;
    6858     if (jj_scan_token(SUPER)) return true;
    6859     if (jj_3R_79()) return true;
    6860     if (jj_scan_token(SEMICOLON)) return true;
    6861     return false;
    6862   }
    6863
    6864   private boolean jj_3R_118() {
    6865     if (jj_3R_80()) return true;
    6866     if (jj_scan_token(THIS)) return true;
    6867     if (jj_3R_79()) return true;
    6868     if (jj_scan_token(SEMICOLON)) return true;
    6869     return false;
    6870   }
    6871
    6872   private boolean jj_3R_366() {
    6873     if (jj_3R_304()) return true;
    6874     return false;
    6875   }
    6876
    6877   private boolean jj_3R_117() {
    6878     if (jj_scan_token(THIS)) return true;
    6879     if (jj_3R_79()) return true;
    6880     if (jj_scan_token(SEMICOLON)) return true;
    6881     return false;
    6882   }
    6883
    6884   private boolean jj_3R_76() {
    6885     Token xsp;
    6886     xsp = jj_scanpos;
    6887     if (jj_3R_117()) {
    6888     jj_scanpos = xsp;
    6889     if (jj_3R_118()) {
    6890     jj_scanpos = xsp;
    6891     if (jj_3R_119()) return true;
    6892     }
    6893     }
    6894     return false;
    6895   }
    6896
    6897   private boolean jj_3R_365() {
    6898     if (jj_3R_306()) return true;
    6899     return false;
    6900   }
    6901
    6902   private boolean jj_3R_340() {
    6903     if (jj_scan_token(COMMA)) return true;
    6904     if (jj_3R_339()) return true;
    6905     return false;
    6906   }
    6907
    6908   private boolean jj_3_11() {
    6909     if (jj_3R_77()) return true;
    6910     return false;
    6911   }
    6912
    6913   private boolean jj_3R_312() {
    6914     if (jj_3R_76()) return true;
    6915     return false;
    6916   }
    6917
    6918   private boolean jj_3_55() {
    6919     if (jj_3R_71()) return true;
    6920     return false;
    6921   }
    6922
    6923   private boolean jj_3R_364() {
    6924     if (jj_3R_70()) return true;
    6925     return false;
    6926   }
    6927
    6928   private boolean jj_3R_309() {
    6929     if (jj_3R_113()) return true;
    6930     return false;
    6931   }
    6932
    6933   private boolean jj_3_54() {
    6934     if (jj_3R_103()) return true;
    6935     return false;
    6936   }
    6937
    6938   private boolean jj_3R_303() {
    6939     Token xsp;
    6940     xsp = jj_scanpos;
    6941     if (jj_3R_309()) jj_scanpos = xsp;
    6942     if (jj_scan_token(IDENTIFIER)) return true;
    6943     if (jj_3R_310()) return true;
    6944     xsp = jj_scanpos;
    6945     if (jj_3R_311()) jj_scanpos = xsp;
    6946     if (jj_scan_token(LBRACE)) return true;
    6947     xsp = jj_scanpos;
    6948     if (jj_3R_312()) jj_scanpos = xsp;
    6949     while (true) {
    6950       xsp = jj_scanpos;
    6951       if (jj_3_11()) { jj_scanpos = xsp; break; }
    6952     }
    6953     if (jj_scan_token(RBRACE)) return true;
    6954     return false;
    6955   }
    6956
    6957   private boolean jj_3R_352() {
    6958     if (jj_scan_token(BIT_OR)) return true;
    6959     if (jj_3R_73()) return true;
    6960     return false;
    6961   }
    6962
    6963   private boolean jj_3R_354() {
    6964     if (jj_3R_293()) return true;
    6965     Token xsp;
    6966     xsp = jj_scanpos;
    6967     if (jj_3_54()) {
    6968     jj_scanpos = xsp;
    6969     if (jj_3R_364()) {
    6970     jj_scanpos = xsp;
    6971     if (jj_3_55()) {
    6972     jj_scanpos = xsp;
    6973     if (jj_3R_365()) {
    6974     jj_scanpos = xsp;
    6975     if (jj_3R_366()) return true;
    6976     }
    6977     }
    6978     }
    6979     }
    6980     return false;
    6981   }
    6982
    6983   private boolean jj_3R_342() {
    6984     Token xsp;
    6985     xsp = jj_scanpos;
    6986     if (jj_3R_354()) {
    6987     jj_scanpos = xsp;
    6988     if (jj_scan_token(82)) return true;
    6989     }
    6990     return false;
    6991   }
    6992
    6993   private boolean jj_3R_329() {
    6994     if (jj_3R_342()) return true;
    6995     return false;
    6996   }
    6997
    6998   private boolean jj_3R_328() {
    6999     if (jj_scan_token(LBRACKET)) return true;
    7000     if (jj_scan_token(RBRACKET)) return true;
    7001     return false;
    7002   }
    7003
    7004   private boolean jj_3R_316() {
    7005     if (jj_scan_token(THROWS)) return true;
    7006     if (jj_3R_327()) return true;
    7007     return false;
    7008   }
    7009
    7010   private boolean jj_3R_353() {
    7011     if (jj_scan_token(ELLIPSIS)) return true;
    7012     return false;
    7013   }
    7014
    7015   private boolean jj_3_53() {
    7016     if (jj_scan_token(COMMA)) return true;
    7017     if (jj_3R_102()) return true;
    7018     return false;
    7019   }
    7020
    7021   private boolean jj_3R_362() {
    7022     if (jj_scan_token(FINAL)) return true;
    7023     return false;
    7024   }
    7025
    7026   private boolean jj_3R_351() {
    7027     Token xsp;
    7028     xsp = jj_scanpos;
    7029     if (jj_3R_362()) {
    7030     jj_scanpos = xsp;
    7031     if (jj_3R_363()) return true;
    7032     }
    7033     return false;
    7034   }
    7035
    7036   private boolean jj_3R_318() {
    7037     if (jj_scan_token(LBRACE)) return true;
    7038     Token xsp;
    7039     while (true) {
    7040       xsp = jj_scanpos;
    7041       if (jj_3R_329()) { jj_scanpos = xsp; break; }
    7042     }
    7043     if (jj_scan_token(RBRACE)) return true;
    7044     return false;
    7045   }
    7046
    7047   private boolean jj_3R_339() {
    7048     Token xsp;
    7049     while (true) {
    7050       xsp = jj_scanpos;
    7051       if (jj_3R_351()) { jj_scanpos = xsp; break; }
    7052     }
    7053     if (jj_3R_73()) return true;
    7054     while (true) {
    7055       xsp = jj_scanpos;
    7056       if (jj_3R_352()) { jj_scanpos = xsp; break; }
    7057     }
    7058     xsp = jj_scanpos;
    7059     if (jj_3R_353()) jj_scanpos = xsp;
    7060     if (jj_3R_212()) return true;
    7061     return false;
    7062   }
    7063
    7064   private boolean jj_3R_326() {
    7065     if (jj_3R_339()) return true;
    7066     Token xsp;
    7067     while (true) {
    7068       xsp = jj_scanpos;
    7069       if (jj_3R_340()) { jj_scanpos = xsp; break; }
    7070     }
    7071     return false;
    7072   }
    7073
    7074   private boolean jj_3R_306() {
    7075     if (jj_scan_token(AT)) return true;
    7076     if (jj_scan_token(INTERFACE)) return true;
    7077     if (jj_scan_token(IDENTIFIER)) return true;
    7078     if (jj_3R_318()) return true;
    7079     return false;
    7080   }
    7081
    7082   private boolean jj_3_9() {
    7083     if (jj_scan_token(COMMA)) return true;
    7084     if (jj_3R_75()) return true;
    7085     return false;
    7086   }
    7087
    7088   private boolean jj_3R_310() {
    7089     if (jj_scan_token(LPAREN)) return true;
    7090     Token xsp;
    7091     xsp = jj_scanpos;
    7092     if (jj_3R_326()) jj_scanpos = xsp;
    7093     if (jj_scan_token(RPAREN)) return true;
    7094     return false;
    7095   }
    7096
    7097   private boolean jj_3R_277() {
    7098     if (jj_3R_102()) return true;
    7099     Token xsp;
    7100     while (true) {
    7101       xsp = jj_scanpos;
    7102       if (jj_3_53()) { jj_scanpos = xsp; break; }
    7103     }
    7104     xsp = jj_scanpos;
    7105     if (jj_scan_token(83)) jj_scanpos = xsp;
    7106     return false;
    7107   }
    7108
    7109   private boolean jj_3R_215() {
    7110     if (jj_scan_token(LBRACE)) return true;
    7111     Token xsp;
    7112     xsp = jj_scanpos;
    7113     if (jj_3R_277()) jj_scanpos = xsp;
    7114     if (jj_scan_token(RBRACE)) return true;
    7115     return false;
    7116   }
    7117
    7118   private boolean jj_3R_256() {
    7119     if (jj_scan_token(COMMA)) return true;
    7120     if (jj_3R_255()) return true;
    7121     return false;
    7122   }
    7123
    7124   private boolean jj_3R_315() {
    7125     if (jj_scan_token(IDENTIFIER)) return true;
    7126     if (jj_3R_310()) return true;
    7127     Token xsp;
    7128     while (true) {
    7129       xsp = jj_scanpos;
    7130       if (jj_3R_328()) { jj_scanpos = xsp; break; }
    7131     }
    7132     return false;
    7133   }
    7134
    7135   private boolean jj_3R_170() {
    7136     if (jj_3R_147()) return true;
    7137     return false;
    7138   }
    7139
    7140   private boolean jj_3R_169() {
    7141     if (jj_3R_215()) return true;
    7142     return false;
    7143   }
    7144
    7145   private boolean jj_3R_317() {
    7146     if (jj_3R_196()) return true;
    7147     return false;
    7148   }
    7149
    7150   private boolean jj_3R_102() {
    7151     Token xsp;
    7152     xsp = jj_scanpos;
    7153     if (jj_3R_168()) {
    7154     jj_scanpos = xsp;
    7155     if (jj_3R_169()) {
    7156     jj_scanpos = xsp;
    7157     if (jj_3R_170()) return true;
    7158     }
    7159     }
    7160     return false;
    7161   }
    7162
    7163   private boolean jj_3R_168() {
    7164     if (jj_3R_104()) return true;
    7165     return false;
    7166   }
    7167
    7168   private boolean jj_3R_314() {
    7169     if (jj_3R_113()) return true;
    7170     return false;
    7171   }
    7172
    7173   private boolean jj_3R_305() {
    7174     Token xsp;
    7175     xsp = jj_scanpos;
    7176     if (jj_3R_314()) jj_scanpos = xsp;
    7177     if (jj_3R_89()) return true;
    7178     if (jj_3R_315()) return true;
    7179     xsp = jj_scanpos;
    7180     if (jj_3R_316()) jj_scanpos = xsp;
    7181     xsp = jj_scanpos;
    7182     if (jj_3R_317()) {
    7183     jj_scanpos = xsp;
    7184     if (jj_scan_token(82)) return true;
    7185     }
    7186     return false;
    7187   }
    7188
    7189   private boolean jj_3R_276() {
    7190     if (jj_3R_75()) return true;
    7191     Token xsp;
    7192     while (true) {
    7193       xsp = jj_scanpos;
    7194       if (jj_3_9()) { jj_scanpos = xsp; break; }
    7195     }
    7196     return false;
    7197   }
    7198
    7199   private boolean jj_3R_255() {
    7200     if (jj_scan_token(IDENTIFIER)) return true;
    7201     if (jj_scan_token(ASSIGN)) return true;
    7202     if (jj_3R_102()) return true;
    7203     return false;
    7204   }
    7205
    7206   private boolean jj_3R_179() {
    7207     if (jj_scan_token(LBRACE)) return true;
    7208     Token xsp;
    7209     xsp = jj_scanpos;
    7210     if (jj_3R_276()) jj_scanpos = xsp;
    7211     xsp = jj_scanpos;
    7212     if (jj_scan_token(83)) jj_scanpos = xsp;
    7213     if (jj_scan_token(RBRACE)) return true;
    7214     return false;
    7215   }
    7216
    7217   private boolean jj_3R_213() {
    7218     if (jj_scan_token(ASSIGN)) return true;
    7219     if (jj_3R_75()) return true;
    7220     return false;
    7221   }
    7222
    7223   private boolean jj_3R_313() {
    7224     if (jj_scan_token(COMMA)) return true;
    7225     if (jj_3R_165()) return true;
    7226     return false;
    7227   }
    7228
    7229   private boolean jj_3R_243() {
    7230     if (jj_3R_255()) return true;
    7231     Token xsp;
    7232     while (true) {
    7233       xsp = jj_scanpos;
    7234       if (jj_3R_256()) { jj_scanpos = xsp; break; }
    7235     }
    7236     return false;
    7237   }
    7238
    7239   private boolean jj_3R_228() {
    7240     if (jj_3R_243()) return true;
    7241     return false;
    7242   }
    7243
    7244   private boolean jj_3R_74() {
    7245     if (jj_scan_token(LBRACKET)) return true;
    7246     if (jj_scan_token(RBRACKET)) return true;
    7247     return false;
    7248   }
    7249
    7250   private boolean jj_3R_101() {
    7251     if (jj_scan_token(IDENTIFIER)) return true;
    7252     if (jj_scan_token(ASSIGN)) return true;
    7253     return false;
    7254   }
    7255
    7256   private boolean jj_3R_116() {
    7257     if (jj_3R_92()) return true;
    7258     return false;
    7259   }
    7260
    7261   private boolean jj_3R_115() {
    7262     if (jj_3R_179()) return true;
    7263     return false;
    7264   }
    7265
    7266   private boolean jj_3R_75() {
    7267     Token xsp;
    7268     xsp = jj_scanpos;
    7269     if (jj_3R_115()) {
    7270     jj_scanpos = xsp;
    7271     if (jj_3R_116()) return true;
    7272     }
    7273     return false;
    7274   }
    7275
    7276   private boolean jj_3R_217() {
    7277     if (jj_scan_token(AT)) return true;
    7278     if (jj_3R_100()) return true;
    7279     if (jj_scan_token(LPAREN)) return true;
    7280     if (jj_3R_102()) return true;
    7281     if (jj_scan_token(RPAREN)) return true;
    7282     return false;
    7283   }
    7284
    7285   private boolean jj_3R_350() {
    7286     if (jj_3R_110()) return true;
    7287     return false;
    7288   }
    7289
    7290   private boolean jj_3R_227() {
    7291     if (jj_scan_token(LBRACKET)) return true;
    7292     if (jj_scan_token(RBRACKET)) return true;
    7293     return false;
    7294   }
    7295
    7296   private boolean jj_3R_218() {
    7297     if (jj_scan_token(AT)) return true;
    7298     if (jj_3R_100()) return true;
    7299     return false;
    7300   }
    7301
    7302   private boolean jj_3R_178() {
    7303     if (jj_scan_token(COMMA)) return true;
    7304     if (jj_3R_177()) return true;
    7305     return false;
    7306   }
    7307
    7308   private boolean jj_3R_212() {
    7309     if (jj_scan_token(IDENTIFIER)) return true;
    7310     Token xsp;
    7311     while (true) {
    7312       xsp = jj_scanpos;
    7313       if (jj_3R_227()) { jj_scanpos = xsp; break; }
    7314     }
    7315     return false;
    7316   }
    7317
    7318   private boolean jj_3R_219() {
    7319     if (jj_3R_229()) return true;
    7320     return false;
    7321   }
    7322
    7323   private boolean jj_3_52() {
    7324     if (jj_scan_token(AT)) return true;
    7325     if (jj_3R_100()) return true;
    7326     if (jj_scan_token(LPAREN)) return true;
    7327     return false;
    7328   }
    7329
    7330   private boolean jj_3R_216() {
    7331     if (jj_scan_token(AT)) return true;
    7332     if (jj_3R_100()) return true;
    7333     if (jj_scan_token(LPAREN)) return true;
    7334     Token xsp;
    7335     xsp = jj_scanpos;
    7336     if (jj_3R_228()) jj_scanpos = xsp;
    7337     if (jj_scan_token(RPAREN)) return true;
    7338     return false;
    7339   }
    7340
    7341   private boolean jj_3_51() {
    7342     if (jj_scan_token(AT)) return true;
    7343     if (jj_3R_100()) return true;
    7344     if (jj_scan_token(LPAREN)) return true;
    7345     Token xsp;
    7346     xsp = jj_scanpos;
    7347     if (jj_3R_101()) {
    7348     jj_scanpos = xsp;
    7349     if (jj_scan_token(77)) return true;
    7350     }
    7351     return false;
    7352   }
    7353
    7354   private boolean jj_3R_244() {
    7355     if (jj_scan_token(BIT_AND)) return true;
    7356     if (jj_3R_193()) return true;
    7357     return false;
    7358   }
    7359
    7360   private boolean jj_3R_165() {
    7361     if (jj_3R_212()) return true;
    7362     Token xsp;
    7363     xsp = jj_scanpos;
    7364     if (jj_3R_213()) jj_scanpos = xsp;
    7365     return false;
    7366   }
    7367
    7368   private boolean jj_3R_72() {
    7369     if (jj_3R_113()) return true;
    7370     return false;
    7371   }
    7372
    7373   private boolean jj_3_7() {
    7374     if (jj_3R_73()) return true;
    7375     if (jj_scan_token(IDENTIFIER)) return true;
    7376     Token xsp;
    7377     while (true) {
    7378       xsp = jj_scanpos;
    7379       if (jj_3R_74()) { jj_scanpos = xsp; break; }
    7380     }
    7381     xsp = jj_scanpos;
    7382     if (jj_scan_token(83)) {
    7383     jj_scanpos = xsp;
    7384     if (jj_scan_token(86)) {
    7385     jj_scanpos = xsp;
    7386     if (jj_scan_token(82)) return true;
    7387     }
    7388     }
    7389     return false;
    7390   }
    7391
    7392   private boolean jj_3R_173() {
    7393     if (jj_3R_218()) return true;
    7394     return false;
    7395   }
    7396
    7397   private boolean jj_3_6() {
    7398     Token xsp;
    7399     xsp = jj_scanpos;
    7400     if (jj_3R_72()) jj_scanpos = xsp;
    7401     if (jj_scan_token(IDENTIFIER)) return true;
    7402     if (jj_scan_token(LPAREN)) return true;
    7403     return false;
    7404   }
    7405
    7406   private boolean jj_3R_172() {
    7407     if (jj_3R_217()) return true;
    7408     return false;
    7409   }
    7410
    7411   private boolean jj_3R_304() {
    7412     if (jj_3R_73()) return true;
    7413     if (jj_3R_165()) return true;
    7414     Token xsp;
    7415     while (true) {
    7416       xsp = jj_scanpos;
    7417       if (jj_3R_313()) { jj_scanpos = xsp; break; }
    7418     }
    7419     if (jj_scan_token(SEMICOLON)) return true;
    7420     return false;
    7421   }
    7422
    7423   private boolean jj_3R_68() {
    7424     if (jj_3R_104()) return true;
    7425     return false;
    7426   }
    7427
    7428   private boolean jj_3R_349() {
    7429     if (jj_3R_79()) return true;
    7430     return false;
    7431   }
    7432
    7433   private boolean jj_3R_130() {
    7434     return false;
    7435   }
    7436
    7437   private boolean jj_3R_104() {
    7438     Token xsp;
    7439     xsp = jj_scanpos;
    7440     if (jj_3R_171()) {
    7441     jj_scanpos = xsp;
    7442     if (jj_3R_172()) {
    7443     jj_scanpos = xsp;
    7444     if (jj_3R_173()) return true;
    7445     }
    7446     }
    7447     return false;
    7448   }
    7449
    7450   private boolean jj_3R_171() {
    7451     if (jj_3R_216()) return true;
    7452     return false;
    7453   }
    7454
    7455   private boolean jj_3R_106() {
    7456     if (jj_scan_token(INTERFACE)) return true;
    7457     return false;
    7458   }
    7459
    7460   private boolean jj_3R_361() {
    7461     if (jj_scan_token(COLON)) return true;
    7462     if (jj_3R_92()) return true;
    7463     return false;
    7464   }
    7465
    7466   private boolean jj_3R_297() {
    7467     if (jj_3R_306()) return true;
    7468     return false;
    7469   }
    7470
    7471   private boolean jj_3R_296() {
    7472     if (jj_3R_305()) return true;
    7473     return false;
    7474   }
    7475
    7476   private boolean jj_3_8() {
    7477     Token xsp;
    7478     xsp = jj_scanpos;
    7479     if (jj_scan_token(49)) jj_scanpos = xsp;
    7480     if (jj_scan_token(LBRACE)) return true;
    7481     return false;
    7482   }
    7483
    7484   private boolean jj_3R_295() {
    7485     if (jj_3R_304()) return true;
    7486     return false;
    7487   }
    7488
    7489   private boolean jj_3R_294() {
    7490     if (jj_3R_303()) return true;
    7491     return false;
    7492   }
    7493
    7494   private boolean jj_3_5() {
    7495     if (jj_3R_71()) return true;
    7496     return false;
    7497   }
    7498
    7499   private boolean jj_3R_131() {
    7500     return false;
    7501   }
    7502
    7503   private boolean jj_3_4() {
    7504     if (jj_3R_70()) return true;
    7505     return false;
    7506   }
    7507
    7508   private boolean jj_3R_289() {
    7509     if (jj_3R_293()) return true;
    7510     Token xsp;
    7511     xsp = jj_scanpos;
    7512     if (jj_3_4()) {
    7513     jj_scanpos = xsp;
    7514     if (jj_3_5()) {
    7515     jj_scanpos = xsp;
    7516     if (jj_3R_294()) {
    7517     jj_scanpos = xsp;
    7518     if (jj_3R_295()) {
    7519     jj_scanpos = xsp;
    7520     if (jj_3R_296()) {
    7521     jj_scanpos = xsp;
    7522     if (jj_3R_297()) return true;
    7523     }
    7524     }
    7525     }
    7526     }
    7527     }
    7528     return false;
    7529   }
    7530
    7531   private boolean jj_3R_84() {
    7532     jj_lookingAhead = true;
    7533     jj_semLA = getToken(1).kind == GT &&
    7534                 ((Token.GTToken)getToken(1)).realKind == RSIGNEDSHIFT;
    7535     jj_lookingAhead = false;
    7536     if (!jj_semLA || jj_3R_130()) return true;
    7537     if (jj_scan_token(GT)) return true;
    7538     if (jj_scan_token(GT)) return true;
    7539     return false;
    7540   }
    7541
    7542   private boolean jj_3R_285() {
    7543     Token xsp;
    7544     xsp = jj_scanpos;
    7545     if (jj_3R_288()) {
    7546     jj_scanpos = xsp;
    7547     if (jj_3R_289()) {
    7548     jj_scanpos = xsp;
    7549     if (jj_scan_token(82)) return true;
    7550     }
    7551     }
    7552     return false;
    7553   }
    7554
    7555   private boolean jj_3R_288() {
    7556     if (jj_3R_292()) return true;
    7557     return false;
    7558   }
    7559
    7560   private boolean jj_3R_282() {
    7561     if (jj_3R_285()) return true;
    7562     return false;
    7563   }
    7564
    7565   private boolean jj_3_3() {
    7566     if (jj_scan_token(COMMA)) return true;
    7567     Token xsp;
    7568     while (true) {
    7569       xsp = jj_scanpos;
    7570       if (jj_3R_68()) { jj_scanpos = xsp; break; }
    7571     }
    7572     if (jj_3R_69()) return true;
    7573     return false;
    7574   }
    7575
    7576   private boolean jj_3R_110() {
    7577     if (jj_scan_token(LBRACE)) return true;
    7578     Token xsp;
    7579     while (true) {
    7580       xsp = jj_scanpos;
    7581       if (jj_3R_282()) { jj_scanpos = xsp; break; }
    7582     }
    7583     if (jj_scan_token(RBRACE)) return true;
    7584     return false;
    7585   }
    7586
    7587   private boolean jj_3R_85() {
    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_131()) 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_229() {
    7600     if (jj_scan_token(EXTENDS)) return true;
    7601     if (jj_3R_193()) return true;
    7602     Token xsp;
    7603     while (true) {
    7604       xsp = jj_scanpos;
    7605       if (jj_3R_244()) { jj_scanpos = xsp; break; }
    7606     }
    7607     return false;
    7608   }
    7609
    7610   private boolean jj_3R_182() {
    7611     if (jj_scan_token(IDENTIFIER)) return true;
    7612     if (jj_3R_92()) return true;
    7613     Token xsp;
    7614     xsp = jj_scanpos;
    7615     if (jj_3R_361()) jj_scanpos = xsp;
    7616     if (jj_scan_token(SEMICOLON)) return true;
    7617     return false;
    7618   }
    7619
    7620   private boolean jj_3R_174() {
    7621     Token xsp;
    7622     xsp = jj_scanpos;
    7623     if (jj_scan_token(28)) {
    7624     jj_scanpos = xsp;
    7625     if (jj_scan_token(12)) return true;
    7626     }
    7627     return false;
    7628   }
    7629
    7630   private boolean jj_3R_177() {
    7631     if (jj_scan_token(IDENTIFIER)) return true;
    7632     Token xsp;
    7633     xsp = jj_scanpos;
    7634     if (jj_3R_219()) jj_scanpos = xsp;
    7635     return false;
    7636   }
    7637
    7638   private boolean jj_3R_105() {
    7639     Token xsp;
    7640     xsp = jj_scanpos;
    7641     if (jj_3R_174()) jj_scanpos = xsp;
    7642     if (jj_scan_token(CLASS)) return true;
    7643     return false;
    7644   }
    7645
    7646   private boolean jj_3R_113() {
    7647     if (jj_scan_token(LT)) return true;
    7648     if (jj_3R_177()) return true;
    7649     Token xsp;
    7650     while (true) {
    7651       xsp = jj_scanpos;
    7652       if (jj_3R_178()) { jj_scanpos = xsp; break; }
    7653     }
    7654     if (jj_scan_token(GT)) return true;
    7655     return false;
    7656   }
    7657
    7658   private boolean jj_3R_390() {
    7659     if (jj_scan_token(FINALLY)) return true;
    7660     if (jj_3R_196()) return true;
    7661     return false;
    7662   }
    7663
    7664   private boolean jj_3R_214() {
    7665     if (jj_3R_104()) return true;
    7666     return false;
    7667   }
    7668
    7669   private boolean jj_3R_338() {
    7670     if (jj_3R_285()) return true;
    7671     return false;
    7672   }
    7673
    7674   private boolean jj_3R_69() {
    7675     if (jj_scan_token(IDENTIFIER)) return true;
    7676     Token xsp;
    7677     xsp = jj_scanpos;
    7678     if (jj_3R_349()) jj_scanpos = xsp;
    7679     xsp = jj_scanpos;
    7680     if (jj_3R_350()) jj_scanpos = xsp;
    7681     return false;
    7682   }
    7683
    7684   private boolean jj_3_50() {
    7685     if (jj_scan_token(SEMICOLON)) return true;
    7686     if (jj_3R_99()) return true;
    7687     return false;
    7688   }
    7689
    7690   private boolean jj_3R_389() {
    7691     if (jj_scan_token(CATCH)) return true;
    7692     if (jj_scan_token(LPAREN)) return true;
    7693     if (jj_3R_339()) return true;
    7694     if (jj_scan_token(RPAREN)) return true;
    7695     if (jj_3R_196()) return true;
    7696     return false;
    7697   }
    7698
    7699   private boolean jj_3R_325() {
    7700     if (jj_scan_token(SEMICOLON)) return true;
    7701     Token xsp;
    7702     while (true) {
    7703       xsp = jj_scanpos;
    7704       if (jj_3R_338()) { jj_scanpos = xsp; break; }
    7705     }
    7706     return false;
    7707   }
    7708
    7709   private boolean jj_3R_337() {
    7710     if (jj_3R_104()) return true;
    7711     return false;
    7712   }
    7713
    7714   private boolean jj_3R_167() {
    7715     Token xsp;
    7716     xsp = jj_scanpos;
    7717     if (jj_scan_token(28)) {
    7718     jj_scanpos = xsp;
    7719     if (jj_3R_214()) return true;
    7720     }
    7721     return false;
    7722   }
    7723
    7724   private boolean jj_3R_324() {
    7725     Token xsp;
    7726     while (true) {
    7727       xsp = jj_scanpos;
    7728       if (jj_3R_337()) { jj_scanpos = xsp; break; }
    7729     }
    7730     if (jj_3R_69()) return true;
    7731     while (true) {
    7732       xsp = jj_scanpos;
    7733       if (jj_3_3()) { jj_scanpos = xsp; break; }
    7734     }
    7735     return false;
    7736   }
    7737
    7738   private boolean jj_3R_99() {
    7739     Token xsp;
    7740     while (true) {
    7741       xsp = jj_scanpos;
    7742       if (jj_3R_167()) { jj_scanpos = xsp; break; }
    7743     }
    7744     if (jj_3R_73()) return true;
    7745     if (jj_3R_212()) return true;
    7746     if (jj_scan_token(ASSIGN)) return true;
    7747     if (jj_3R_92()) return true;
    7748     return false;
    7749   }
    7750
    7751   private boolean jj_3R_112() {
    7752     if (jj_scan_token(LBRACE)) return true;
    7753     Token xsp;
    7754     xsp = jj_scanpos;
    7755     if (jj_3R_324()) jj_scanpos = xsp;
    7756     xsp = jj_scanpos;
    7757     if (jj_scan_token(83)) jj_scanpos = xsp;
    7758     xsp = jj_scanpos;
    7759     if (jj_3R_325()) jj_scanpos = xsp;
    7760     if (jj_scan_token(RBRACE)) return true;
    7761     return false;
    7762   }
    7763
    7764   private boolean jj_3R_397() {
    7765     if (jj_3R_99()) return true;
    7766     Token xsp;
    7767     while (true) {
    7768       xsp = jj_scanpos;
    7769       if (jj_3_50()) { jj_scanpos = xsp; break; }
    7770     }
    7771     return false;
    7772   }
    7773
    7774   private boolean jj_3R_111() {
    7775     if (jj_3R_176()) return true;
    7776     return false;
    7777   }
    7778
    7779   private boolean jj_3_49() {
    7780     if (jj_scan_token(SEMICOLON)) return true;
    7781     return false;
    7782   }
    7783
    7784   private boolean jj_3R_71() {
    7785     if (jj_scan_token(IDENTIFIER)) return true;
    7786     if (jj_scan_token(IDENTIFIER)) return true;
    7787     Token xsp;
    7788     xsp = jj_scanpos;
    7789     if (jj_3R_111()) jj_scanpos = xsp;
    7790     if (jj_3R_112()) return true;
    7791     return false;
    7792   }
    7793
    7794   private boolean jj_3R_388() {
    7795     if (jj_scan_token(LPAREN)) return true;
    7796     if (jj_3R_397()) return true;
    7797     Token xsp;
    7798     xsp = jj_scanpos;
    7799     if (jj_3_49()) jj_scanpos = xsp;
    7800     if (jj_scan_token(RPAREN)) return true;
    7801     return false;
    7802   }
    7803
    7804   private boolean jj_3R_379() {
    7805     if (jj_3R_388()) return true;
    7806     return false;
    7807   }
    7808
    7809   private boolean jj_3R_381() {
    7810     if (jj_3R_390()) return true;
    7811     return false;
    7812   }
    7813
    7814   private boolean jj_3R_336() {
    7815     if (jj_scan_token(COMMA)) return true;
    7816     if (jj_3R_193()) return true;
    7817     return false;
    7818   }
    7819
    7820   private boolean jj_3R_380() {
    7821     if (jj_3R_389()) return true;
    7822     return false;
    7823   }
    7824
    7825   private boolean jj_3R_176() {
    7826     if (jj_scan_token(IMPLEMENTS)) return true;
    7827     if (jj_3R_193()) return true;
    7828     Token xsp;
    7829     while (true) {
    7830       xsp = jj_scanpos;
    7831       if (jj_3R_336()) { jj_scanpos = xsp; break; }
    7832     }
    7833     return false;
    7834   }
    7835
    7836   private boolean jj_3R_209() {
    7837     if (jj_scan_token(TRY)) return true;
    7838     Token xsp;
    7839     xsp = jj_scanpos;
    7840     if (jj_3R_379()) jj_scanpos = xsp;
    7841     if (jj_3R_196()) return true;
    7842     while (true) {
    7843       xsp = jj_scanpos;
    7844       if (jj_3R_380()) { jj_scanpos = xsp; break; }
    7845     }
    7846     xsp = jj_scanpos;
    7847     if (jj_3R_381()) jj_scanpos = xsp;
    7848     return false;
    7849   }
    7850
    7851   private boolean jj_3R_335() {
    7852     if (jj_scan_token(COMMA)) return true;
    7853     if (jj_3R_193()) return true;
    7854     return false;
    7855   }
    7856
    7857   private boolean jj_3R_175() {
    7858     if (jj_scan_token(EXTENDS)) return true;
    7859     if (jj_3R_193()) return true;
    7860     Token xsp;
    7861     while (true) {
    7862       xsp = jj_scanpos;
    7863       if (jj_3R_335()) { jj_scanpos = xsp; break; }
    7864     }
    7865     return false;
    7866   }
    7867
    7868   private boolean jj_3R_208() {
    7869     if (jj_scan_token(SYNCHRONIZED)) return true;
    7870     if (jj_scan_token(LPAREN)) return true;
    7871     if (jj_3R_92()) return true;
    7872     if (jj_scan_token(RPAREN)) return true;
    7873     if (jj_3R_196()) return true;
    7874     return false;
    7875   }
    7876
    7877   private boolean jj_3R_378() {
    7878     if (jj_3R_92()) return true;
    7879     return false;
    7880   }
    7881
    7882   private boolean jj_3R_109() {
    7883     if (jj_3R_176()) return true;
    7884     return false;
    7885   }
    7886
    7887   private boolean jj_3R_377() {
    7888     if (jj_scan_token(IDENTIFIER)) return true;
    7889     return false;
    7890   }
    7891
    7892   private boolean jj_3R_108() {
    7893     if (jj_3R_175()) return true;
    7894     return false;
    7895   }
    7896
    7897   private boolean jj_3R_107() {
    7898     if (jj_3R_113()) return true;
    7899     return false;
    7900   }
    7901
    7902   private boolean jj_3R_207() {
    7903     if (jj_scan_token(THROW)) return true;
    7904     if (jj_3R_92()) return true;
    7905     if (jj_scan_token(SEMICOLON)) return true;
    7906     return false;
    7907   }
    7908
    7909   private boolean jj_3R_70() {
    7910     Token xsp;
    7911     xsp = jj_scanpos;
    7912     if (jj_3R_105()) {
    7913     jj_scanpos = xsp;
    7914     if (jj_3R_106()) return true;
    7915     }
    7916     if (jj_scan_token(IDENTIFIER)) return true;
    7917     xsp = jj_scanpos;
    7918     if (jj_3R_107()) jj_scanpos = xsp;
    7919     xsp = jj_scanpos;
    7920     if (jj_3R_108()) jj_scanpos = xsp;
    7921     xsp = jj_scanpos;
    7922     if (jj_3R_109()) jj_scanpos = xsp;
    7923     if (jj_3R_110()) return true;
    7924     return false;
    7925   }
    7926
    7927   private boolean jj_3R_403() {
    7928     if (jj_scan_token(COMMA)) return true;
    7929     if (jj_3R_198()) return true;
    7930     return false;
    7931   }
    7932
    7933   private boolean jj_3R_206() {
    7934     if (jj_scan_token(RETURN)) return true;
    7935     Token xsp;
    7936     xsp = jj_scanpos;
    7937     if (jj_3R_378()) jj_scanpos = xsp;
    7938     if (jj_scan_token(SEMICOLON)) return true;
    7939     return false;
    7940   }
    7941
    7942   private boolean jj_3R_376() {
    7943     if (jj_scan_token(IDENTIFIER)) return true;
    7944     return false;
    7945   }
    7946
    7947   private boolean jj_3R_205() {
    7948     if (jj_scan_token(CONTINUE)) return true;
    7949     Token xsp;
    7950     xsp = jj_scanpos;
    7951     if (jj_3R_377()) jj_scanpos = xsp;
    7952     if (jj_scan_token(SEMICOLON)) return true;
    7953     return false;
    7954   }
    7955
    7956   private boolean jj_3R_204() {
    7957     if (jj_scan_token(BREAK)) return true;
    7958     Token xsp;
    7959     xsp = jj_scanpos;
    7960     if (jj_3R_376()) jj_scanpos = xsp;
    7961     if (jj_scan_token(SEMICOLON)) return true;
    7962     return false;
    7963   }
    7964
    7965   private boolean jj_3R_396() {
    7966     if (jj_3R_402()) return true;
    7967     return false;
    7968   }
    7969
    7970   private boolean jj_3_48() {
    7971     if (jj_3R_98()) return true;
    7972     return false;
    7973   }
    7974
    7975   private boolean jj_3R_402() {
    7976     if (jj_3R_198()) return true;
    7977     Token xsp;
    7978     while (true) {
    7979       xsp = jj_scanpos;
    7980       if (jj_3R_403()) { jj_scanpos = xsp; break; }
    7981     }
    7982     return false;
    7983   }
    7984
    7985   private boolean jj_3R_373() {
    7986     if (jj_scan_token(ELSE)) return true;
    7987     if (jj_3R_95()) return true;
    7988     return false;
    7989   }
    7990
    7991   private boolean jj_3R_401() {
    7992     if (jj_3R_402()) return true;
    7993     return false;
    7994   }
    7995
    7996   private boolean jj_3R_67() {
    7997     if (jj_3R_104()) return true;
    7998     return false;
    7999   }
    8000
    8001   private boolean jj_3R_66() {
    8002     if (jj_scan_token(STRICTFP)) return true;
    8003     return false;
    8004   }
    8005
    8006   private boolean jj_3R_400() {
    8007     if (jj_3R_98()) return true;
    8008     return false;
    8009   }
    8010
    8011   private boolean jj_3R_395() {
    8012     Token xsp;
    8013     xsp = jj_scanpos;
    8014     if (jj_3R_400()) {
    8015     jj_scanpos = xsp;
    8016     if (jj_3R_401()) return true;
    8017     }
    8018     return false;
    8019   }
    8020
    8021   private boolean jj_3R_65() {
    8022     if (jj_scan_token(VOLATILE)) return true;
    8023     return false;
    8024   }
    8025
    8026   private boolean jj_3_47() {
    8027     if (jj_3R_98()) return true;
    8028     if (jj_scan_token(COLON)) return true;
    8029     return false;
    8030   }
    8031
    8032   private boolean jj_3R_64() {
    8033     if (jj_scan_token(TRANSIENT)) return true;
    8034     return false;
    8035   }
    8036
    8037   private boolean jj_3R_63() {
    8038     if (jj_scan_token(NATIVE)) return true;
    8039     return false;
    8040   }
    8041
    8042   private boolean jj_3R_62() {
    8043     if (jj_scan_token(SYNCHRONIZED)) return true;
    8044     return false;
    8045   }
    8046
    8047   private boolean jj_3R_61() {
    8048     if (jj_scan_token(ABSTRACT)) return true;
    8049     return false;
    8050   }
    8051
    8052   private boolean jj_3R_60() {
    8053     if (jj_scan_token(FINAL)) return true;
    8054     return false;
    8055   }
    8056
    8057   private boolean jj_3R_387() {
    8058     if (jj_3R_396()) return true;
    8059     return false;
    8060   }
    8061
    8062   private boolean jj_3R_59() {
    8063     if (jj_scan_token(PRIVATE)) return true;
    8064     return false;
    8065   }
    8066
    8067   private boolean jj_3R_386() {
    8068     if (jj_3R_92()) return true;
    8069     return false;
    8070   }
    8071
    8072   private boolean jj_3R_58() {
    8073     if (jj_scan_token(PROTECTED)) return true;
    8074     return false;
    8075   }
    8076
    8077   private boolean jj_3R_385() {
    8078     if (jj_3R_395()) return true;
    8079     return false;
    8080   }
    8081
    8082   private boolean jj_3R_57() {
    8083     if (jj_scan_token(STATIC)) return true;
    8084     return false;
    8085   }
    8086
    8087   private boolean jj_3R_375() {
    8088     Token xsp;
    8089     xsp = jj_scanpos;
    8090     if (jj_3R_385()) jj_scanpos = xsp;
    8091     if (jj_scan_token(SEMICOLON)) return true;
    8092     xsp = jj_scanpos;
    8093     if (jj_3R_386()) jj_scanpos = xsp;
    8094     if (jj_scan_token(SEMICOLON)) return true;
    8095     xsp = jj_scanpos;
    8096     if (jj_3R_387()) jj_scanpos = xsp;
    8097     return false;
    8098   }
    8099
    8100   private boolean jj_3R_374() {
    8101     if (jj_3R_98()) return true;
    8102     if (jj_scan_token(COLON)) return true;
    8103     if (jj_3R_92()) return true;
    8104     return false;
    8105   }
    8106
    8107   private boolean jj_3R_56() {
    8108     if (jj_scan_token(PUBLIC)) return true;
    8109     return false;
    8110   }
    8111
    8112   private boolean jj_3_2() {
    8113     Token xsp;
    8114     xsp = jj_scanpos;
    8115     if (jj_3R_56()) {
    8116     jj_scanpos = xsp;
    8117     if (jj_3R_57()) {
    8118     jj_scanpos = xsp;
    8119     if (jj_3R_58()) {
    8120     jj_scanpos = xsp;
    8121     if (jj_3R_59()) {
    8122     jj_scanpos = xsp;
    8123     if (jj_3R_60()) {
    8124     jj_scanpos = xsp;
    8125     if (jj_3R_61()) {
    8126     jj_scanpos = xsp;
    8127     if (jj_3R_62()) {
    8128     jj_scanpos = xsp;
    8129     if (jj_3R_63()) {
    8130     jj_scanpos = xsp;
    8131     if (jj_3R_64()) {
    8132     jj_scanpos = xsp;
    8133     if (jj_3R_65()) {
    8134     jj_scanpos = xsp;
    8135     if (jj_3R_66()) {
    8136     jj_scanpos = xsp;
    8137     if (jj_3R_67()) return true;
    8138     }
    8139     }
    8140     }
    8141     }
    8142     }
    8143     }
    8144     }
    8145     }
    8146     }
    8147     }
    8148     }
    8149     return false;
    8150   }
    8151
    8152   private boolean jj_3R_293() {
    8153     Token xsp;
    8154     while (true) {
    8155       xsp = jj_scanpos;
    8156       if (jj_3_2()) { jj_scanpos = xsp; break; }
    8157     }
    8158     return false;
    8159   }
    8160
    8161   private boolean jj_3R_203() {
    8162     if (jj_scan_token(FOR)) return true;
    8163     if (jj_scan_token(LPAREN)) return true;
    8164     Token xsp;
    8165     xsp = jj_scanpos;
    8166     if (jj_3R_374()) {
    8167     jj_scanpos = xsp;
    8168     if (jj_3R_375()) return true;
    8169     }
    8170     if (jj_scan_token(RPAREN)) return true;
    8171     if (jj_3R_95()) return true;
    8172     return false;
    8173   }
    8174
    8175   private boolean jj_3R_202() {
    8176     if (jj_scan_token(DO)) return true;
    8177     if (jj_3R_95()) return true;
    8178     if (jj_scan_token(WHILE)) return true;
    8179     if (jj_scan_token(LPAREN)) return true;
    8180     if (jj_3R_92()) return true;
    8181     if (jj_scan_token(RPAREN)) return true;
    8182     if (jj_scan_token(SEMICOLON)) return true;
    8183     return false;
    8184   }
    8185
    8186   private boolean jj_3R_201() {
    8187     if (jj_scan_token(WHILE)) return true;
    8188     if (jj_scan_token(LPAREN)) return true;
    8189     if (jj_3R_92()) return true;
    8190     if (jj_scan_token(RPAREN)) return true;
    8191     if (jj_3R_95()) return true;
    8192     return false;
    8193   }
    8194
    8195   private boolean jj_3R_55() {
    8196     if (jj_3R_104()) return true;
    8197     return false;
    8198   }
    8199
    8200   private boolean jj_3_1() {
    8201     Token xsp;
    8202     while (true) {
    8203       xsp = jj_scanpos;
    8204       if (jj_3R_55()) { jj_scanpos = xsp; break; }
    8205     }
    8206     if (jj_scan_token(PACKAGE)) return true;
    8207     return false;
    8208   }
    8209
    8210   private boolean jj_3_46() {
    8211     if (jj_3R_77()) return true;
    8212     return false;
    8213   }
    8214
    8215   private boolean jj_3R_183() {
    8216     if (jj_3R_104()) return true;
    8217     return false;
    8218   }
    8219
    8220   private boolean jj_3R_200() {
    8221     if (jj_scan_token(IF)) return true;
    8222     if (jj_scan_token(LPAREN)) return true;
    8223     if (jj_3R_92()) return true;
    8224     if (jj_scan_token(RPAREN)) return true;
    8225     if (jj_3R_95()) return true;
    8226     Token xsp;
    8227     xsp = jj_scanpos;
    8228     if (jj_3R_373()) jj_scanpos = xsp;
    8229     return false;
    8230   }
    8231
    8232   private boolean jj_3R_394() {
    8233     if (jj_scan_token(_DEFAULT)) return true;
    8234     if (jj_scan_token(COLON)) return true;
    8235     return false;
    8236   }
    8237
    8238   private boolean jj_3R_393() {
    8239     if (jj_scan_token(CASE)) return true;
    8240     if (jj_3R_92()) return true;
    8241     if (jj_scan_token(COLON)) return true;
    8242     return false;
    8243   }
    8244
    8245   private boolean jj_3R_384() {
    8246     Token xsp;
    8247     xsp = jj_scanpos;
    8248     if (jj_3R_393()) {
    8249     jj_scanpos = xsp;
    8250     if (jj_3R_394()) return true;
    8251     }
    8252     return false;
    8253   }
    8254
    8255   private boolean jj_3R_211() {
    8256     if (jj_3R_104()) return true;
    8257     return false;
    8258   }
    8259
    8260   private boolean jj_3R_372() {
    8261     if (jj_3R_384()) return true;
    8262     Token xsp;
    8263     while (true) {
    8264       xsp = jj_scanpos;
    8265       if (jj_3_46()) { jj_scanpos = xsp; break; }
    8266     }
    8267     return false;
    8268   }
    8269
    8270   private boolean jj_3_45() {
    8271     if (jj_3R_78()) return true;
    8272     Token xsp;
    8273     xsp = jj_scanpos;
    8274     if (jj_scan_token(98)) {
    8275     jj_scanpos = xsp;
    8276     if (jj_scan_token(99)) return true;
    8277     }
    8278     return false;
    8279   }
    8280
    8281   private boolean jj_3R_199() {
    8282     if (jj_scan_token(SWITCH)) return true;
    8283     if (jj_scan_token(LPAREN)) return true;
    8284     if (jj_3R_92()) return true;
    8285     if (jj_scan_token(RPAREN)) return true;
    8286     if (jj_scan_token(LBRACE)) return true;
    8287     Token xsp;
    8288     while (true) {
    8289       xsp = jj_scanpos;
    8290       if (jj_3R_372()) { jj_scanpos = xsp; break; }
    8291     }
    8292     if (jj_scan_token(RBRACE)) return true;
    8293     return false;
    8294   }
    8295
    8296   private boolean jj_3R_383() {
    8297     if (jj_3R_248()) return true;
    8298     if (jj_3R_92()) return true;
    8299     return false;
    8300   }
    8301
    8302   private boolean jj_3R_97() {
    8303     Token xsp;
    8304     xsp = jj_scanpos;
    8305     if (jj_scan_token(28)) {
    8306     jj_scanpos = xsp;
    8307     if (jj_scan_token(12)) return true;
    8308     }
    8309     return false;
    8310   }
    8311
    8312   private boolean jj_3R_226() {
    8313     if (jj_3R_78()) return true;
    8314     Token xsp;
    8315     xsp = jj_scanpos;
    8316     if (jj_3R_383()) jj_scanpos = xsp;
    8317     return false;
    8318   }
    8319
    8320   private boolean jj_3R_225() {
    8321     if (jj_3R_242()) return true;
    8322     return false;
    8323   }
    8324
    8325   private boolean jj_3R_224() {
    8326     if (jj_3R_241()) return true;
    8327     return false;
    8328   }
    8329
    8330   private boolean jj_3R_198() {
    8331     Token xsp;
    8332     xsp = jj_scanpos;
    8333     if (jj_3R_223()) {
    8334     jj_scanpos = xsp;
    8335     if (jj_3R_224()) {
    8336     jj_scanpos = xsp;
    8337     if (jj_3R_225()) {
    8338     jj_scanpos = xsp;
    8339     if (jj_3R_226()) return true;
    8340     }
    8341     }
    8342     }
    8343     return false;
    8344   }
    8345
    8346   private boolean jj_3R_223() {
    8347     if (jj_3R_240()) return true;
    8348     return false;
    8349   }
    8350
    8351   private boolean jj_3R_197() {
    8352     if (jj_scan_token(SEMICOLON)) return true;
    8353     return false;
    8354   }
    8355
    8356   private boolean jj_3R_96() {
    8357     if (jj_3R_104()) return true;
    8358     return false;
    8359   }
    8360
    8361   private boolean jj_3_44() {
    8362     Token xsp;
    8363     xsp = jj_scanpos;
    8364     if (jj_3R_96()) jj_scanpos = xsp;
    8365     xsp = jj_scanpos;
    8366     if (jj_3R_97()) jj_scanpos = xsp;
    8367     if (jj_scan_token(CLASS)) return true;
    8368     return false;
    8369   }
    8370
    8371   private boolean jj_3R_148() {
    8372     if (jj_3R_104()) return true;
    8373     return false;
    8374   }
    8375
    8376   private boolean jj_3R_166() {
    8377     if (jj_scan_token(COMMA)) return true;
    8378     if (jj_3R_165()) return true;
    8379     return false;
    8380   }
    8381
    8382   private boolean jj_3R_164() {
    8383     Token xsp;
    8384     xsp = jj_scanpos;
    8385     if (jj_3R_210()) {
    8386     jj_scanpos = xsp;
    8387     if (jj_3R_211()) return true;
    8388     }
    8389     return false;
    8390   }
    8391
    8392   private boolean jj_3R_210() {
    8393     if (jj_scan_token(FINAL)) return true;
    8394     return false;
    8395   }
    8396
    8397   private boolean jj_3R_98() {
    8398     Token xsp;
    8399     while (true) {
    8400       xsp = jj_scanpos;
    8401       if (jj_3R_164()) { jj_scanpos = xsp; break; }
    8402     }
    8403     if (jj_3R_73()) return true;
    8404     if (jj_3R_165()) return true;
    8405     while (true) {
    8406       xsp = jj_scanpos;
    8407       if (jj_3R_166()) { jj_scanpos = xsp; break; }
    8408     }
    8409     return false;
    8410   }
    8411
    8412   private boolean jj_3R_94() {
    8413     Token xsp;
    8414     xsp = jj_scanpos;
    8415     if (jj_scan_token(28)) {
    8416     jj_scanpos = xsp;
    8417     if (jj_3R_148()) return true;
    8418     }
    8419     return false;
    8420   }
    8421
    8422   private boolean jj_3R_122() {
    8423     Token xsp;
    8424     xsp = jj_scanpos;
    8425     if (jj_3R_183()) jj_scanpos = xsp;
    8426     if (jj_3R_70()) return true;
    8427     return false;
    8428   }
    8429
    8430   private boolean jj_3_42() {
    8431     Token xsp;
    8432     while (true) {
    8433       xsp = jj_scanpos;
    8434       if (jj_3R_94()) { jj_scanpos = xsp; break; }
    8435     }
    8436     if (jj_3R_73()) return true;
    8437     if (jj_scan_token(IDENTIFIER)) return true;
    8438     return false;
    8439   }
    8440
    8441   private boolean jj_3_43() {
    8442     if (jj_3R_95()) return true;
    8443     return false;
    8444   }
    8445
    8446   private boolean jj_3R_121() {
    8447     if (jj_3R_98()) return true;
    8448     if (jj_scan_token(SEMICOLON)) return true;
    8449     return false;
    8450   }
    8451
    8452   private boolean jj_3R_120() {
    8453     if (jj_3R_182()) return true;
    8454     return false;
    8455   }
    8456
    8457   private boolean jj_3R_77() {
    8458     Token xsp;
    8459     xsp = jj_scanpos;
    8460     jj_lookingAhead = true;
    8461     jj_semLA = isNextTokenAnAssert();
    8462     jj_lookingAhead = false;
    8463     if (!jj_semLA || jj_3R_120()) {
    8464     jj_scanpos = xsp;
    8465     if (jj_3R_121()) {
    8466     jj_scanpos = xsp;
    8467     if (jj_3_43()) {
    8468     jj_scanpos = xsp;
    8469     if (jj_3R_122()) return true;
    8470     }
    8471     }
    8472     }
    8473     return false;
    8474   }
    8475
    8476   private boolean jj_3_41() {
    8477     if (jj_3R_77()) return true;
    8478     return false;
    8479   }
    8480
    8481   private boolean jj_3R_196() {
    8482     if (jj_scan_token(LBRACE)) return true;
    8483     Token xsp;
    8484     while (true) {
    8485       xsp = jj_scanpos;
    8486       if (jj_3_41()) { jj_scanpos = xsp; break; }
    8487     }
    8488     if (jj_scan_token(RBRACE)) return true;
    8489     return false;
    8490   }
    8491
    8492   private boolean jj_3_38() {
    8493     if (jj_scan_token(LBRACKET)) return true;
    8494     if (jj_scan_token(RBRACKET)) return true;
    8495     return false;
    8496   }
    8497
    8498   private boolean jj_3R_93() {
    8499     if (jj_scan_token(IDENTIFIER)) return true;
    8500     if (jj_scan_token(COLON)) return true;
    8501     if (jj_3R_95()) return true;
    8502     return false;
    8503   }
    8504
    8505   private boolean jj_3R_163() {
    8506     if (jj_3R_209()) return true;
    8507     return false;
    8508   }
    8509
    8510   private boolean jj_3R_162() {
    8511     if (jj_3R_208()) return true;
    8512     return false;
    8513   }
    8514
    8515   private boolean jj_3R_161() {
    8516     if (jj_3R_207()) return true;
    8517     return false;
    8518   }
    8519
    8520   private boolean jj_3R_160() {
    8521     if (jj_3R_206()) return true;
    8522     return false;
    8523   }
    8524
    8525   private boolean jj_3R_159() {
    8526     if (jj_3R_205()) return true;
    8527     return false;
    8528   }
    8529
    8530   private boolean jj_3R_158() {
    8531     if (jj_3R_204()) return true;
    8532     return false;
    8533   }
    8534
    8535   private boolean jj_3R_157() {
    8536     if (jj_3R_203()) return true;
    8537     return false;
    8538   }
    8539
    8540   private boolean jj_3R_156() {
    8541     if (jj_3R_202()) return true;
    8542     return false;
    8543   }
    8544
    8545   private boolean jj_3R_155() {
    8546     if (jj_3R_201()) return true;
    8547     return false;
    8548   }
    8549
    8550   private boolean jj_3R_154() {
    8551     if (jj_3R_200()) return true;
    8552     return false;
    8553   }
    8554
    8555   private boolean jj_3R_153() {
    8556     if (jj_3R_199()) return true;
    8557     return false;
    8558   }
    8559
    8560   private boolean jj_3R_152() {
    8561     if (jj_3R_198()) return true;
    8562     if (jj_scan_token(SEMICOLON)) return true;
    8563     return false;
    8564   }
    8565
    8566   private boolean jj_3R_151() {
    8567     if (jj_3R_197()) return true;
    8568     return false;
    8569   }
    8570
    8571   private boolean jj_3R_150() {
    8572     if (jj_3R_196()) return true;
    8573     return false;
    8574   }
    8575
    8576   private boolean jj_3R_250() {
    8577     if (jj_3R_80()) return true;
    8578     return false;
    8579   }
    8580
    8581   private boolean jj_3_40() {
    8582     if (jj_3R_93()) return true;
    8583     return false;
    8584   }
    8585
    8586   private boolean jj_3R_95() {
    8587     Token xsp;
    8588     xsp = jj_scanpos;
    8589     jj_lookingAhead = true;
    8590     jj_semLA = isNextTokenAnAssert();
    8591     jj_lookingAhead = false;
    8592     if (!jj_semLA || jj_3R_149()) {
    8593     jj_scanpos = xsp;
    8594     if (jj_3_40()) {
    8595     jj_scanpos = xsp;
    8596     if (jj_3R_150()) {
    8597     jj_scanpos = xsp;
    8598     if (jj_3R_151()) {
    8599     jj_scanpos = xsp;
    8600     if (jj_3R_152()) {
    8601     jj_scanpos = xsp;
    8602     if (jj_3R_153()) {
    8603     jj_scanpos = xsp;
    8604     if (jj_3R_154()) {
    8605     jj_scanpos = xsp;
    8606     if (jj_3R_155()) {
    8607     jj_scanpos = xsp;
    8608     if (jj_3R_156()) {
    8609     jj_scanpos = xsp;
    8610     if (jj_3R_157()) {
    8611     jj_scanpos = xsp;
    8612     if (jj_3R_158()) {
    8613     jj_scanpos = xsp;
    8614     if (jj_3R_159()) {
    8615     jj_scanpos = xsp;
    8616     if (jj_3R_160()) {
    8617     jj_scanpos = xsp;
    8618     if (jj_3R_161()) {
    8619     jj_scanpos = xsp;
    8620     if (jj_3R_162()) {
    8621     jj_scanpos = xsp;
    8622     if (jj_3R_163()) return true;
    8623     }
    8624     }
    8625     }
    8626     }
    8627     }
    8628     }
    8629     }
    8630     }
    8631     }
    8632     }
    8633     }
    8634     }
    8635     }
    8636     }
    8637     }
    8638     return false;
    8639   }
    8640
    8641   private boolean jj_3R_149() {
    8642     if (jj_3R_182()) return true;
    8643     return false;
    8644   }
    8645
    8646   private boolean jj_3R_272() {
    8647     if (jj_3R_110()) return true;
    8648     return false;
    8649   }
    8650
    8651   private boolean jj_3R_279() {
    8652     if (jj_scan_token(LBRACKET)) return true;
    8653     if (jj_scan_token(RBRACKET)) return true;
    8654     return false;
    8655   }
    8656
    8657   private boolean jj_3_37() {
    8658     if (jj_scan_token(LBRACKET)) return true;
    8659     if (jj_3R_92()) return true;
    8660     if (jj_scan_token(RBRACKET)) return true;
    8661     return false;
    8662   }
    8663
    8664   private boolean jj_3R_271() {
    8665     Token xsp;
    8666     if (jj_3R_279()) return true;
    8667     while (true) {
    8668       xsp = jj_scanpos;
    8669       if (jj_3R_279()) { jj_scanpos = xsp; break; }
    8670     }
    8671     if (jj_3R_179()) return true;
    8672     return false;
    8673   }
    8674
    8675   private boolean jj_3_39() {
    8676     Token xsp;
    8677     if (jj_3_37()) return true;
    8678     while (true) {
    8679       xsp = jj_scanpos;
    8680       if (jj_3_37()) { jj_scanpos = xsp; break; }
    8681     }
    8682     while (true) {
    8683       xsp = jj_scanpos;
    8684       if (jj_3_38()) { jj_scanpos = xsp; break; }
    8685     }
    8686     return false;
    8687   }
    8688
    8689   private boolean jj_3R_249() {
    8690     Token xsp;
    8691     xsp = jj_scanpos;
    8692     if (jj_3_39()) {
    8693     jj_scanpos = xsp;
    8694     if (jj_3R_271()) return true;
    8695     }
    8696     return false;
    8697   }
    8698
    8699   private boolean jj_3R_252() {
    8700     if (jj_3R_79()) return true;
    8701     Token xsp;
    8702     xsp = jj_scanpos;
    8703     if (jj_3R_272()) jj_scanpos = xsp;
    8704     return false;
    8705   }
    8706
    8707   private boolean jj_3R_221() {
    8708     if (jj_scan_token(COMMA)) return true;
    8709     if (jj_3R_92()) return true;
    8710     return false;
    8711   }
    8712
    8713   private boolean jj_3R_251() {
    8714     if (jj_3R_249()) return true;
    8715     return false;
    8716   }
    8717
    8718   private boolean jj_3R_146() {
    8719     if (jj_scan_token(NEW)) return true;
    8720     if (jj_3R_193()) return true;
    8721     Token xsp;
    8722     xsp = jj_scanpos;
    8723     if (jj_3R_250()) jj_scanpos = xsp;
    8724     xsp = jj_scanpos;
    8725     if (jj_3R_251()) {
    8726     jj_scanpos = xsp;
    8727     if (jj_3R_252()) return true;
    8728     }
    8729     return false;
    8730   }
    8731
    8732   private boolean jj_3R_90() {
    8733     Token xsp;
    8734     xsp = jj_scanpos;
    8735     if (jj_3_36()) {
    8736     jj_scanpos = xsp;
    8737     if (jj_3R_146()) return true;
    8738     }
    8739     return false;
    8740   }
    8741
    8742   private boolean jj_3_36() {
    8743     if (jj_scan_token(NEW)) return true;
    8744     if (jj_3R_87()) return true;
    8745     if (jj_3R_249()) return true;
    8746     return false;
    8747   }
    8748
    8749   private boolean jj_3R_124() {
    8750     if (jj_3R_191()) return true;
    8751     return false;
    8752   }
    8753
    8754   private boolean jj_3R_191() {
    8755     if (jj_3R_92()) return true;
    8756     Token xsp;
    8757     while (true) {
    8758       xsp = jj_scanpos;
    8759       if (jj_3R_221()) { jj_scanpos = xsp; break; }
    8760     }
    8761     return false;
    8762   }
    8763
    8764   private boolean jj_3R_79() {
    8765     if (jj_scan_token(LPAREN)) return true;
    8766     Token xsp;
    8767     xsp = jj_scanpos;
    8768     if (jj_3R_124()) jj_scanpos = xsp;
    8769     if (jj_scan_token(RPAREN)) return true;
    8770     return false;
    8771   }
    8772
    8773   private boolean jj_3R_194() {
    8774     if (jj_3R_220()) return true;
    8775     return false;
    8776   }
    8777
    8778   private boolean jj_3R_246() {
    8779     if (jj_scan_token(NULL)) return true;
    8780     return false;
    8781   }
    8782
    8783   private boolean jj_3R_245() {
    8784     Token xsp;
    8785     xsp = jj_scanpos;
    8786     if (jj_3R_257()) {
    8787     jj_scanpos = xsp;
    8788     if (jj_scan_token(27)) return true;
    8789     }
    8790     return false;
    8791   }
    8792
    8793   private boolean jj_3R_257() {
    8794     if (jj_scan_token(TRUE)) return true;
    8795     return false;
    8796   }
    8797
    8798   private boolean jj_3R_236() {
    8799     if (jj_3R_246()) return true;
    8800     return false;
    8801   }
    8802
    8803   private boolean jj_3R_399() {
    8804     if (jj_scan_token(DECR)) return true;
    8805     return false;
    8806   }
    8807
    8808   private boolean jj_3R_235() {
    8809     if (jj_3R_245()) return true;
    8810     return false;
    8811   }
    8812
    8813   private boolean jj_3R_234() {
    8814     if (jj_scan_token(STRING_LITERAL)) return true;
    8815     return false;
    8816   }
    8817
    8818   private boolean jj_3R_233() {
    8819     if (jj_scan_token(CHARACTER_LITERAL)) return true;
    8820     return false;
    8821   }
    8822
    8823   private boolean jj_3R_232() {
    8824     if (jj_scan_token(HEX_FLOATING_POINT_LITERAL)) return true;
    8825     return false;
    8826   }
    8827
    8828   private boolean jj_3R_231() {
    8829     if (jj_scan_token(FLOATING_POINT_LITERAL)) return true;
    8830     return false;
    8831   }
    8832
    8833   private boolean jj_3R_220() {
    8834     Token xsp;
    8835     xsp = jj_scanpos;
    8836     if (jj_3R_230()) {
    8837     jj_scanpos = xsp;
    8838     if (jj_3R_231()) {
    8839     jj_scanpos = xsp;
    8840     if (jj_3R_232()) {
    8841     jj_scanpos = xsp;
    8842     if (jj_3R_233()) {
    8843     jj_scanpos = xsp;
    8844     if (jj_3R_234()) {
    8845     jj_scanpos = xsp;
    8846     if (jj_3R_235()) {
    8847     jj_scanpos = xsp;
    8848     if (jj_3R_236()) return true;
    8849     }
    8850     }
    8851     }
    8852     }
    8853     }
    8854     }
    8855     return false;
    8856   }
    8857
    8858   private boolean jj_3R_230() {
    8859     if (jj_scan_token(INTEGER_LITERAL)) return true;
    8860     return false;
    8861   }
    8862
    8863   private boolean jj_3R_144() {
    8864     if (jj_3R_79()) return true;
    8865     return false;
    8866   }
    8867
    8868   private boolean jj_3_31() {
    8869     if (jj_3R_89()) return true;
    8870     if (jj_scan_token(DOT)) return true;
    8871     if (jj_scan_token(CLASS)) return true;
    8872     return false;
    8873   }
    8874
    8875   private boolean jj_3R_143() {
    8876     if (jj_scan_token(DOT)) return true;
    8877     if (jj_scan_token(IDENTIFIER)) return true;
    8878     return false;
    8879   }
    8880
    8881   private boolean jj_3R_142() {
    8882     if (jj_scan_token(LBRACKET)) return true;
    8883     if (jj_3R_92()) return true;
    8884     if (jj_scan_token(RBRACKET)) return true;
    8885     return false;
    8886   }
    8887
    8888   private boolean jj_3_35() {
    8889     if (jj_3R_91()) return true;
    8890     return false;
    8891   }
    8892
    8893   private boolean jj_3R_360() {
    8894     if (jj_scan_token(REM)) return true;
    8895     return false;
    8896   }
    8897
    8898   private boolean jj_3_34() {
    8899     if (jj_scan_token(DOT)) return true;
    8900     if (jj_3R_90()) return true;
    8901     return false;
    8902   }
    8903
    8904   private boolean jj_3R_88() {
    8905     Token xsp;
    8906     xsp = jj_scanpos;
    8907     if (jj_3_32()) {
    8908     jj_scanpos = xsp;
    8909     if (jj_3_33()) {
    8910     jj_scanpos = xsp;
    8911     if (jj_3_34()) {
    8912     jj_scanpos = xsp;
    8913     if (jj_3_35()) {
    8914     jj_scanpos = xsp;
    8915     if (jj_3R_142()) {
    8916     jj_scanpos = xsp;
    8917     if (jj_3R_143()) {
    8918     jj_scanpos = xsp;
    8919     if (jj_3R_144()) return true;
    8920     }
    8921     }
    8922     }
    8923     }
    8924     }
    8925     }
    8926     return false;
    8927   }
    8928
    8929   private boolean jj_3_33() {
    8930     if (jj_scan_token(DOT)) return true;
    8931     if (jj_scan_token(SUPER)) return true;
    8932     return false;
    8933   }
    8934
    8935   private boolean jj_3_32() {
    8936     if (jj_scan_token(DOT)) return true;
    8937     if (jj_scan_token(THIS)) return true;
    8938     return false;
    8939   }
    8940
    8941   private boolean jj_3R_190() {
    8942     if (jj_3R_100()) return true;
    8943     return false;
    8944   }
    8945
    8946   private boolean jj_3R_189() {
    8947     if (jj_3R_89()) return true;
    8948     if (jj_scan_token(DOT)) return true;
    8949     if (jj_scan_token(CLASS)) return true;
    8950     return false;
    8951   }
    8952
    8953   private boolean jj_3_30() {
    8954     if (jj_3R_88()) return true;
    8955     return false;
    8956   }
    8957
    8958   private boolean jj_3R_188() {
    8959     if (jj_3R_90()) return true;
    8960     return false;
    8961   }
    8962
    8963   private boolean jj_3R_187() {
    8964     if (jj_scan_token(LPAREN)) return true;
    8965     if (jj_3R_92()) return true;
    8966     if (jj_scan_token(RPAREN)) return true;
    8967     return false;
    8968   }
    8969
    8970   private boolean jj_3R_186() {
    8971     if (jj_scan_token(SUPER)) return true;
    8972     return false;
    8973   }
    8974
    8975   private boolean jj_3R_185() {
    8976     if (jj_scan_token(THIS)) return true;
    8977     return false;
    8978   }
    8979
    8980   private boolean jj_3R_123() {
    8981     Token xsp;
    8982     xsp = jj_scanpos;
    8983     if (jj_3R_184()) {
    8984     jj_scanpos = xsp;
    8985     if (jj_3R_185()) {
    8986     jj_scanpos = xsp;
    8987     if (jj_3R_186()) {
    8988     jj_scanpos = xsp;
    8989     if (jj_3R_187()) {
    8990     jj_scanpos = xsp;
    8991     if (jj_3R_188()) {
    8992     jj_scanpos = xsp;
    8993     if (jj_3R_189()) {
    8994     jj_scanpos = xsp;
    8995     if (jj_3R_190()) return true;
    8996     }
    8997     }
    8998     }
    8999     }
    9000     }
    9001     }
    9002     return false;
    9003   }
    9004
    9005   private boolean jj_3R_184() {
    9006     if (jj_3R_220()) return true;
    9007     return false;
    9008   }
    9009
    9010   private boolean jj_3R_398() {
    9011     if (jj_scan_token(INCR)) return true;
    9012     return false;
    9013   }
    9014
    9015   private boolean jj_3R_392() {
    9016     Token xsp;
    9017     xsp = jj_scanpos;
    9018     if (jj_3R_398()) {
    9019     jj_scanpos = xsp;
    9020     if (jj_3R_399()) return true;
    9021     }
    9022     return false;
    9023   }
    9024
    9025   private boolean jj_3R_91() {
    9026     if (jj_scan_token(DOT)) return true;
    9027     if (jj_3R_80()) return true;
    9028     if (jj_scan_token(IDENTIFIER)) return true;
    9029     return false;
    9030   }
    9031
    9032   private boolean jj_3_29() {
    9033     if (jj_scan_token(LPAREN)) return true;
    9034     if (jj_3R_87()) return true;
    9035     return false;
    9036   }
    9037
    9038   private boolean jj_3R_368() {
    9039     if (jj_scan_token(BANG)) return true;
    9040     return false;
    9041   }
    9042
    9043   private boolean jj_3R_78() {
    9044     if (jj_3R_123()) return true;
    9045     Token xsp;
    9046     while (true) {
    9047       xsp = jj_scanpos;
    9048       if (jj_3_30()) { jj_scanpos = xsp; break; }
    9049     }
    9050     return false;
    9051   }
    9052
    9053   private boolean jj_3R_348() {
    9054     if (jj_scan_token(MINUS)) return true;
    9055     return false;
    9056   }
    9057
    9058   private boolean jj_3R_359() {
    9059     if (jj_scan_token(SLASH)) return true;
    9060     return false;
    9061   }
    9062
    9063   private boolean jj_3R_371() {
    9064     if (jj_scan_token(LPAREN)) return true;
    9065     if (jj_3R_73()) return true;
    9066     if (jj_scan_token(RPAREN)) return true;
    9067     if (jj_3R_345()) return true;
    9068     return false;
    9069   }
    9070
    9071   private boolean jj_3R_369() {
    9072     Token xsp;
    9073     xsp = jj_scanpos;
    9074     if (jj_3R_370()) {
    9075     jj_scanpos = xsp;
    9076     if (jj_3R_371()) return true;
    9077     }
    9078     return false;
    9079   }
    9080
    9081   private boolean jj_3R_370() {
    9082     if (jj_scan_token(LPAREN)) return true;
    9083     if (jj_3R_73()) return true;
    9084     if (jj_scan_token(RPAREN)) return true;
    9085     if (jj_3R_319()) return true;
    9086     return false;
    9087   }
    9088
    9089   private boolean jj_3_28() {
    9090     if (jj_scan_token(LPAREN)) return true;
    9091     if (jj_3R_73()) return true;
    9092     if (jj_scan_token(LBRACKET)) return true;
    9093     return false;
    9094   }
    9095
    9096   private boolean jj_3R_242() {
    9097     if (jj_3R_78()) return true;
    9098     Token xsp;
    9099     xsp = jj_scanpos;
    9100     if (jj_3R_392()) jj_scanpos = xsp;
    9101     return false;
    9102   }
    9103
    9104   private boolean jj_3R_133() {
    9105     if (jj_scan_token(LPAREN)) return true;
    9106     if (jj_3R_73()) return true;
    9107     if (jj_scan_token(RPAREN)) return true;
    9108     Token xsp;
    9109     xsp = jj_scanpos;
    9110     if (jj_scan_token(89)) {
    9111     jj_scanpos = xsp;
    9112     if (jj_scan_token(88)) {
    9113     jj_scanpos = xsp;
    9114     if (jj_scan_token(76)) {
    9115     jj_scanpos = xsp;
    9116     if (jj_scan_token(73)) {
    9117     jj_scanpos = xsp;
    9118     if (jj_scan_token(53)) {
    9119     jj_scanpos = xsp;
    9120     if (jj_scan_token(50)) {
    9121     jj_scanpos = xsp;
    9122     if (jj_scan_token(41)) {
    9123     jj_scanpos = xsp;
    9124     if (jj_3R_194()) return true;
    9125     }
    9126     }
    9127     }
    9128     }
    9129     }
    9130     }
    9131     }
    9132     return false;
    9133   }
    9134
    9135   private boolean jj_3_26() {
    9136     if (jj_3R_86()) return true;
    9137     return false;
    9138   }
    9139
    9140   private boolean jj_3R_344() {
    9141     if (jj_scan_token(MINUS)) return true;
    9142     return false;
    9143   }
    9144
    9145   private boolean jj_3R_132() {
    9146     if (jj_scan_token(LPAREN)) return true;
    9147     if (jj_3R_73()) return true;
    9148     if (jj_scan_token(LBRACKET)) return true;
    9149     if (jj_scan_token(RBRACKET)) return true;
    9150     return false;
    9151   }
    9152
    9153   private boolean jj_3R_86() {
    9154     Token xsp;
    9155     xsp = jj_scanpos;
    9156     if (jj_3_27()) {
    9157     jj_scanpos = xsp;
    9158     if (jj_3R_132()) {
    9159     jj_scanpos = xsp;
    9160     if (jj_3R_133()) return true;
    9161     }
    9162     }
    9163     return false;
    9164   }
    9165
    9166   private boolean jj_3_27() {
    9167     if (jj_scan_token(LPAREN)) return true;
    9168     if (jj_3R_87()) return true;
    9169     if (jj_scan_token(RPAREN)) return true;
    9170     return false;
    9171   }
    9172
    9173   private boolean jj_3R_357() {
    9174     if (jj_3R_242()) return true;
    9175     return false;
    9176   }
    9177
    9178   private boolean jj_3R_367() {
    9179     if (jj_scan_token(TILDE)) return true;
    9180     return false;
    9181   }
    9182
    9183   private boolean jj_3R_356() {
    9184     if (jj_3R_369()) return true;
    9185     return false;
    9186   }
    9187
    9188   private boolean jj_3R_355() {
    9189     Token xsp;
    9190     xsp = jj_scanpos;
    9191     if (jj_3R_367()) {
    9192     jj_scanpos = xsp;
    9193     if (jj_3R_368()) return true;
    9194     }
    9195     if (jj_3R_319()) return true;
    9196     return false;
    9197   }
    9198
    9199   private boolean jj_3R_345() {
    9200     Token xsp;
    9201     xsp = jj_scanpos;
    9202     if (jj_3R_355()) {
    9203     jj_scanpos = xsp;
    9204     if (jj_3R_356()) {
    9205     jj_scanpos = xsp;
    9206     if (jj_3R_357()) return true;
    9207     }
    9208     }
    9209     return false;
    9210   }
    9211
    9212   private boolean jj_3R_347() {
    9213     if (jj_scan_token(PLUS)) return true;
    9214     return false;
    9215   }
    9216
    9217   private boolean jj_3R_334() {
    9218     Token xsp;
    9219     xsp = jj_scanpos;
    9220     if (jj_3R_347()) {
    9221     jj_scanpos = xsp;
    9222     if (jj_3R_348()) return true;
    9223     }
    9224     if (jj_3R_307()) return true;
    9225     return false;
    9226   }
    9227
    9228   private boolean jj_3R_358() {
    9229     if (jj_scan_token(STAR)) return true;
    9230     return false;
    9231   }
    9232
    9233   private boolean jj_3R_241() {
    9234     if (jj_scan_token(DECR)) return true;
    9235     if (jj_3R_78()) return true;
    9236     return false;
    9237   }
    9238
    9239   private boolean jj_3R_346() {
    9240     Token xsp;
    9241     xsp = jj_scanpos;
    9242     if (jj_3R_358()) {
    9243     jj_scanpos = xsp;
    9244     if (jj_3R_359()) {
    9245     jj_scanpos = xsp;
    9246     if (jj_3R_360()) return true;
    9247     }
    9248     }
    9249     if (jj_3R_319()) return true;
    9250     return false;
    9251   }
    9252
    9253   private boolean jj_3R_301() {
    9254     if (jj_scan_token(NE)) return true;
    9255     return false;
    9256   }
    9257
    9258   private boolean jj_3R_240() {
    9259     if (jj_scan_token(INCR)) return true;
    9260     if (jj_3R_78()) return true;
    9261     return false;
    9262   }
    9263
    9264   private boolean jj_3R_333() {
    9265     if (jj_3R_345()) return true;
    9266     return false;
    9267   }
    9268
    9269   private boolean jj_3R_332() {
    9270     if (jj_3R_241()) return true;
    9271     return false;
    9272   }
    9273
    9274   private boolean jj_3R_331() {
    9275     if (jj_3R_240()) return true;
    9276     return false;
    9277   }
    9278
    9279   private boolean jj_3R_343() {
    9280     if (jj_scan_token(PLUS)) return true;
    9281     return false;
    9282   }
    9283
    9284   private boolean jj_3R_330() {
    9285     Token xsp;
    9286     xsp = jj_scanpos;
    9287     if (jj_3R_343()) {
    9288     jj_scanpos = xsp;
    9289     if (jj_3R_344()) return true;
    9290     }
    9291     if (jj_3R_319()) return true;
    9292     return false;
    9293   }
    9294
    9295   private boolean jj_3R_319() {
    9296     Token xsp;
    9297     xsp = jj_scanpos;
    9298     if (jj_3R_330()) {
    9299     jj_scanpos = xsp;
    9300     if (jj_3R_331()) {
    9301     jj_scanpos = xsp;
    9302     if (jj_3R_332()) {
    9303     jj_scanpos = xsp;
    9304     if (jj_3R_333()) return true;
    9305     }
    9306     }
    9307     }
    9308     return false;
    9309   }
    9310
    9311   private boolean jj_3R_307() {
    9312     if (jj_3R_319()) return true;
    9313     Token xsp;
    9314     while (true) {
    9315       xsp = jj_scanpos;
    9316       if (jj_3R_346()) { jj_scanpos = xsp; break; }
    9317     }
    9318     return false;
    9319   }
    9320
    9321   private boolean jj_3R_298() {
    9322     if (jj_3R_307()) return true;
    9323     Token xsp;
    9324     while (true) {
    9325       xsp = jj_scanpos;
    9326       if (jj_3R_334()) { jj_scanpos = xsp; break; }
    9327     }
    9328     return false;
    9329   }
    9330
    9331   private boolean jj_3_25() {
    9332     if (jj_3R_85()) return true;
    9333     return false;
    9334   }
    9335
    9336   private boolean jj_3_24() {
    9337     if (jj_3R_84()) return true;
    9338     return false;
    9339   }
    9340
    9341   private boolean jj_3R_299() {
    9342     if (jj_scan_token(INSTANCEOF)) return true;
    9343     if (jj_3R_73()) return true;
    9344     return false;
    9345   }
    9346
    9347   private boolean jj_3R_83() {
    9348     if (jj_scan_token(LSHIFT)) return true;
    9349     return false;
    9350   }
    9351
    9352   private boolean jj_3R_300() {
    9353     if (jj_scan_token(EQ)) return true;
    9354     return false;
    9355   }
    9356
    9357   private boolean jj_3_23() {
    9358     Token xsp;
    9359     xsp = jj_scanpos;
    9360     if (jj_3R_83()) {
    9361     jj_scanpos = xsp;
    9362     if (jj_3_24()) {
    9363     jj_scanpos = xsp;
    9364     if (jj_3_25()) return true;
    9365     }
    9366     }
    9367     if (jj_3R_298()) return true;
    9368     return false;
    9369   }
    9370
    9371   private boolean jj_3R_291() {
    9372     Token xsp;
    9373     xsp = jj_scanpos;
    9374     if (jj_3R_300()) {
    9375     jj_scanpos = xsp;
    9376     if (jj_3R_301()) return true;
    9377     }
    9378     if (jj_3R_283()) return true;
    9379     return false;
    9380   }
    9381
    9382   private boolean jj_3R_290() {
    9383     if (jj_3R_298()) return true;
    9384     Token xsp;
    9385     while (true) {
    9386       xsp = jj_scanpos;
    9387       if (jj_3_23()) { jj_scanpos = xsp; break; }
    9388     }
    9389     return false;
    9390   }
    9391
    9392   private boolean jj_3R_323() {
    9393     if (jj_scan_token(GE)) return true;
    9394     return false;
    9395   }
    9396
    9397   private boolean jj_3R_322() {
    9398     if (jj_scan_token(LE)) return true;
    9399     return false;
    9400   }
    9401
    9402   private boolean jj_3R_321() {
    9403     if (jj_scan_token(GT)) return true;
    9404     return false;
    9405   }
    9406
    9407   private boolean jj_3R_320() {
    9408     if (jj_scan_token(LT)) return true;
    9409     return false;
    9410   }
    9411
    9412   private boolean jj_3R_287() {
    9413     if (jj_scan_token(BIT_AND)) return true;
    9414     if (jj_3R_280()) return true;
    9415     return false;
    9416   }
    9417
    9418   private boolean jj_3R_308() {
    9419     Token xsp;
    9420     xsp = jj_scanpos;
    9421     if (jj_3R_320()) {
    9422     jj_scanpos = xsp;
    9423     if (jj_3R_321()) {
    9424     jj_scanpos = xsp;
    9425     if (jj_3R_322()) {
    9426     jj_scanpos = xsp;
    9427     if (jj_3R_323()) return true;
    9428     }
    9429     }
    9430     }
    9431     if (jj_3R_290()) return true;
    9432     return false;
    9433   }
    9434
    9435   private boolean jj_3R_286() {
    9436     if (jj_3R_290()) return true;
    9437     Token xsp;
    9438     while (true) {
    9439       xsp = jj_scanpos;
    9440       if (jj_3R_308()) { jj_scanpos = xsp; break; }
    9441     }
    9442     return false;
    9443   }
    9444
    9445   private boolean jj_3R_281() {
    9446     if (jj_scan_token(BIT_OR)) return true;
    9447     if (jj_3R_254()) return true;
    9448     return false;
    9449   }
    9450
    9451   private boolean jj_3R_284() {
    9452     if (jj_scan_token(XOR)) return true;
    9453     if (jj_3R_275()) return true;
    9454     return false;
    9455   }
    9456
    9457   private boolean jj_3R_283() {
    9458     if (jj_3R_286()) return true;
    9459     Token xsp;
    9460     xsp = jj_scanpos;
    9461     if (jj_3R_299()) jj_scanpos = xsp;
    9462     return false;
    9463   }
    9464
    9465   private boolean jj_3R_278() {
    9466     if (jj_scan_token(SC_AND)) return true;
    9467     if (jj_3R_239()) return true;
    9468     return false;
    9469   }
    9470
    9471   private boolean jj_3R_280() {
    9472     if (jj_3R_283()) return true;
    9473     Token xsp;
    9474     while (true) {
    9475       xsp = jj_scanpos;
    9476       if (jj_3R_291()) { jj_scanpos = xsp; break; }
    9477     }
    9478     return false;
    9479   }
    9480
    9481   private boolean jj_3R_258() {
    9482     if (jj_scan_token(SC_OR)) return true;
    9483     if (jj_3R_222()) return true;
    9484     return false;
    9485   }
    9486
    9487   private boolean jj_3R_275() {
    9488     if (jj_3R_280()) return true;
    9489     Token xsp;
    9490     while (true) {
    9491       xsp = jj_scanpos;
    9492       if (jj_3R_287()) { jj_scanpos = xsp; break; }
    9493     }
    9494     return false;
    9495   }
    9496
    9497   private boolean jj_3R_247() {
    9498     if (jj_scan_token(HOOK)) return true;
    9499     if (jj_3R_92()) return true;
    9500     if (jj_scan_token(COLON)) return true;
    9501     if (jj_3R_147()) return true;
    9502     return false;
    9503   }
    9504
    9505   private boolean jj_3R_254() {
    9506     if (jj_3R_275()) return true;
    9507     Token xsp;
    9508     while (true) {
    9509       xsp = jj_scanpos;
    9510       if (jj_3R_284()) { jj_scanpos = xsp; break; }
    9511     }
    9512     return false;
    9513   }
    9514
    9515   private boolean jj_3R_239() {
    9516     if (jj_3R_254()) return true;
    9517     Token xsp;
    9518     while (true) {
    9519       xsp = jj_scanpos;
    9520       if (jj_3R_281()) { jj_scanpos = xsp; break; }
    9521     }
    9522     return false;
    9523   }
    9524
    9525   private boolean jj_3R_222() {
    9526     if (jj_3R_239()) return true;
    9527     Token xsp;
    9528     while (true) {
    9529       xsp = jj_scanpos;
    9530       if (jj_3R_278()) { jj_scanpos = xsp; break; }
    9531     }
    9532     return false;
    9533   }
    9534
    9535   private boolean jj_3R_195() {
    9536     if (jj_3R_222()) return true;
    9537     Token xsp;
    9538     while (true) {
    9539       xsp = jj_scanpos;
    9540       if (jj_3R_258()) { jj_scanpos = xsp; break; }
    9541     }
    9542     return false;
    9543   }
    9544
    9545   private boolean jj_3R_147() {
    9546     if (jj_3R_195()) return true;
    9547     Token xsp;
    9548     xsp = jj_scanpos;
    9549     if (jj_3R_247()) jj_scanpos = xsp;
    9550     return false;
    9551   }
    9552
    9553   private boolean jj_3R_270() {
    9554     if (jj_scan_token(ORASSIGN)) return true;
    9555     return false;
    9556   }
    9557
    9558   private boolean jj_3R_269() {
    9559     if (jj_scan_token(XORASSIGN)) return true;
    9560     return false;
    9561   }
    9562
    9563   private boolean jj_3R_268() {
    9564     if (jj_scan_token(ANDASSIGN)) return true;
    9565     return false;
    9566   }
    9567
    9568   private boolean jj_3R_267() {
    9569     if (jj_scan_token(RUNSIGNEDSHIFTASSIGN)) return true;
    9570     return false;
    9571   }
    9572
    9573   private boolean jj_3R_266() {
    9574     if (jj_scan_token(RSIGNEDSHIFTASSIGN)) return true;
    9575     return false;
    9576   }
    9577
    9578   private boolean jj_3R_265() {
    9579     if (jj_scan_token(LSHIFTASSIGN)) return true;
    9580     return false;
    9581   }
    9582
    9583   private boolean jj_3R_264() {
    9584     if (jj_scan_token(MINUSASSIGN)) return true;
    9585     return false;
    9586   }
    9587
    9588   private boolean jj_3R_263() {
    9589     if (jj_scan_token(PLUSASSIGN)) return true;
    9590     return false;
    9591   }
    9592
    9593   private boolean jj_3R_262() {
    9594     if (jj_scan_token(REMASSIGN)) return true;
    9595     return false;
    9596   }
    9597
    9598   private boolean jj_3R_261() {
    9599     if (jj_scan_token(SLASHASSIGN)) return true;
    9600     return false;
    9601   }
    9602
    9603   private boolean jj_3R_260() {
    9604     if (jj_scan_token(STARASSIGN)) return true;
    9605     return false;
    9606   }
    9607
    9608   private boolean jj_3R_248() {
    9609     Token xsp;
    9610     xsp = jj_scanpos;
    9611     if (jj_3R_259()) {
    9612     jj_scanpos = xsp;
    9613     if (jj_3R_260()) {
    9614     jj_scanpos = xsp;
    9615     if (jj_3R_261()) {
    9616     jj_scanpos = xsp;
    9617     if (jj_3R_262()) {
    9618     jj_scanpos = xsp;
    9619     if (jj_3R_263()) {
    9620     jj_scanpos = xsp;
    9621     if (jj_3R_264()) {
    9622     jj_scanpos = xsp;
    9623     if (jj_3R_265()) {
    9624     jj_scanpos = xsp;
    9625     if (jj_3R_266()) {
    9626     jj_scanpos = xsp;
    9627     if (jj_3R_267()) {
    9628     jj_scanpos = xsp;
    9629     if (jj_3R_268()) {
    9630     jj_scanpos = xsp;
    9631     if (jj_3R_269()) {
    9632     jj_scanpos = xsp;
    9633     if (jj_3R_270()) return true;
    9634     }
    9635     }
    9636     }
    9637     }
    9638     }
    9639     }
    9640     }
    9641     }
    9642     }
    9643     }
    9644     }
    9645     return false;
    9646   }
    9647
    9648   private boolean jj_3R_259() {
    9649     if (jj_scan_token(ASSIGN)) return true;
    9650     return false;
    9651   }
    9652
    9653   private boolean jj_3R_237() {
    9654     if (jj_3R_248()) return true;
    9655     if (jj_3R_92()) return true;
    9656     return false;
    9657   }
    9658
    9659   private boolean jj_3R_92() {
    9660     if (jj_3R_147()) return true;
    9661     Token xsp;
    9662     xsp = jj_scanpos;
    9663     if (jj_3R_237()) jj_scanpos = xsp;
    9664     return false;
    9665   }
    9666
    9667   /** Generated Token Manager. */
    9668   public JavaParserTokenManager token_source;
    9669   /** Current token. */
    9670   public Token token;
    9671   /** Next token. */
    9672   public Token jj_nt;
    9673   private Token jj_scanpos, jj_lastpos;
    9674   private int jj_la;
    9675   /** Whether we are looking ahead. */
    9676   private boolean jj_lookingAhead = false;
    9677   private boolean jj_semLA;
    9678   private int jj_gen;
    9679   final private int[] jj_la1 = new int[142];
    9680   static private int[] jj_la1_0;
    9681   static private int[] jj_la1_1;
    9682   static private int[] jj_la1_2;
    9683   static private int[] jj_la1_3;
    9684   static {
    9685       jj_la1_init_0();
    9686       jj_la1_init_1();
    9687       jj_la1_init_2();
    9688       jj_la1_init_3();
    9689    }
    9690    private static void jj_la1_init_0() {
    9691       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,0x0,0x4904a000,0x0,0x4104a000,0x4104a000,0x0,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,0x0,0x20000,0x20000000,0x10000000,0x10000000,0x0,0x0,0x0,0x0,0x4904a000,0x0,0x4904a000,0x510cb000,0x10081000,0x4104a000,0x510cb000,0x400000,};
    9692    }
    9693    private static void jj_la1_init_1() {
    9694       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,0x0,0x800000,0x0,0x8a2506a0,0x20000,0x100a0,0x100a0,0x0,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,0x0,0x0,0x0,0x8a2506a0,0x0,0x8a2506a0,0x511371e0,0x40,0x100a0,0x511371e0,0x0,};
    9695    }
    9696    private static void jj_la1_init_2() {
    9697       jj_la1_2 = new int[] {0x0,0x240200,0x0,0x0,0x200000,0x0,0x100000,0x200000,0x200200,0x240200,0x0,0x0,0x0,0x800000,0x0,0x0,0x80000,0x80000,0x0,0x200000,0x200000,0x200200,0x80000,0xa44200,0x40000,0x1000,0x4000,0x80000,0x0,0x0,0xa44200,0xa00200,0xa40200,0x80000,0x400000,0x10000,0x30053b0,0x30053b0,0x80000,0x800000,0x0,0x44000,0x10000,0x80000,0x200200,0x200000,0x200000,0x0,0x0,0x800000,0x0,0x800000,0x8013b0,0x0,0x0,0x200,0x80000,0x800000,0x0,0x4000200,0x0,0x0,0x200,0x80000,0x400000,0x400000,0x4000000,0x0,0x0,0x0,0x0,0x0,0x90000000,0x90000000,0x0,0x60800000,0x60800000,0x0,0x0,0x0,0x0,0x0,0x0,0x30013b0,0x3000000,0x3000000,0x13b0,0x30013b0,0x1000,0x0,0x0,0x1000,0x11b0,0x200,0x111000,0x1b0,0x0,0x30013b0,0x80000,0x800000,0x4000,0x11000,0x0,0x10000,0x10000,0x453b0,0x200000,0x200000,0x200000,0x80000,0x400000,0x0,0x13b0,0x0,0x0,0x0,0x2013b0,0x30013b0,0x13b0,0x2413b0,0x13b0,0x80000,0x200,0x200,0x30013b0,0x1000,0x0,0x0,0x200000,0x200000,0x8000000,0x200000,0x200,0x80000,0x32053b0,0x80000,0x32053b0,0x240200,0x0,0x200200,0x240200,0x0,};
    9698    }
    9699    private static void jj_la1_init_3() {
    9700       jj_la1_3 = new int[] {0x0,0x0,0x10000000,0x20000000,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,0x100,0x0,0x0,0x0,0x0,0x0,0x0,0x3c,0x3c,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x200,0x1000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffe000,0xffe000,0x0,0x1,0x2,0x200,0x400,0x100,0x0,0x0,0x0,0x8000000,0x8000000,0x1000,0x30,0x30,0x8c0,0x8c0,0x30,0x3c,0x0,0x0,0x0,0x0,0x0,0xc,0xc,0x0,0x0,0x0,0x0,0x0,0x0,0x3c,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc,0x0,0x0,0x0,0x0,0xffe000,0xc,0x0,0x0,0x0,0x0,0xc,0x3c,0xc,0xc,0xc,0x0,0x0,0x0,0x3c,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3c,0x0,0x3c,0x0,0x0,0x0,0x0,0x0,};
    9701    }
    9702   final private JJCalls[] jj_2_rtns = new JJCalls[55];
    9703   private boolean jj_rescan = false;
    9704   private int jj_gc = 0;
    9705
    9706   /** Constructor with user supplied CharStream. */
    9707   public JavaParser(CharStream stream) {
    9708     token_source = new JavaParserTokenManager(stream);
    9709     token = new Token();
    9710     token.next = jj_nt = token_source.getNextToken();
    9711     jj_gen = 0;
    9712     for (int i = 0; i < 142; i++) jj_la1[i] = -1;
    9713     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
    9714   }
    9715
    9716   /** Reinitialise. */
    9717   public void ReInit(CharStream stream) {
    9718     token_source.ReInit(stream);
    9719     token = new Token();
    9720     token.next = jj_nt = token_source.getNextToken();
    9721     jj_lookingAhead = false;
    9722     jjtree.reset();
    9723     jj_gen = 0;
    9724     for (int i = 0; i < 142; i++) jj_la1[i] = -1;
    9725     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
    9726   }
    9727
    9728   /** Constructor with generated Token Manager. */
    9729   public JavaParser(JavaParserTokenManager tm) {
    9730     token_source = tm;
    9731     token = new Token();
    9732     token.next = jj_nt = token_source.getNextToken();
    9733     jj_gen = 0;
    9734     for (int i = 0; i < 142; i++) jj_la1[i] = -1;
    9735     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
    9736   }
    9737
    9738   /** Reinitialise. */
    9739   public void ReInit(JavaParserTokenManager tm) {
    9740     token_source = tm;
    9741     token = new Token();
    9742     token.next = jj_nt = token_source.getNextToken();
    9743     jjtree.reset();
    9744     jj_gen = 0;
    9745     for (int i = 0; i < 142; i++) jj_la1[i] = -1;
    9746     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
    9747   }
    9748
    9749   private Token jj_consume_token(int kind) throws ParseException {
    9750     Token oldToken = token;
    9751     if ((token = jj_nt).next != null) jj_nt = jj_nt.next;
    9752     else jj_nt = jj_nt.next = token_source.getNextToken();
    9753     if (token.kind == kind) {
    9754       jj_gen++;
    9755       if (++jj_gc > 100) {
    9756         jj_gc = 0;
    9757         for (int i = 0; i < jj_2_rtns.length; i++) {
    9758           JJCalls c = jj_2_rtns[i];
    9759           while (c != null) {
    9760             if (c.gen < jj_gen) c.first = null;
    9761             c = c.next;
    9762           }
    9763         }
    9764       }
    9765       return token;
    9766     }
    9767     jj_nt = token;
    9768     token = oldToken;
    9769     jj_kind = kind;
    9770     throw generateParseException();
    9771   }
    9772
    9773   static private final class LookaheadSuccess extends java.lang.Error { }
    9774   final private LookaheadSuccess jj_ls = new LookaheadSuccess();
    9775   private boolean jj_scan_token(int kind) {
    9776     if (jj_scanpos == jj_lastpos) {
    9777       jj_la--;
    9778       if (jj_scanpos.next == null) {
    9779         jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
    9780       } else {
    9781         jj_lastpos = jj_scanpos = jj_scanpos.next;
    9782       }
    9783     } else {
    9784       jj_scanpos = jj_scanpos.next;
    9785     }
    9786     if (jj_rescan) {
    9787       int i = 0; Token tok = token;
    9788       while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; }
    9789       if (tok != null) jj_add_error_token(kind, i);
    9790     }
    9791     if (jj_scanpos.kind != kind) return true;
    9792     if (jj_la == 0 && jj_scanpos == jj_lastpos) throw jj_ls;
    9793     return false;
    9794   }
    9795
    9796
    9797 /** Get the next Token. */
    9798   final public Token getNextToken() {
    9799     if ((token = jj_nt).next != null) jj_nt = jj_nt.next;
    9800     else jj_nt = jj_nt.next = token_source.getNextToken();
    9801     jj_gen++;
    9802     return token;
    9803   }
    9804
    9805 /** Get the specific Token. */
    9806   final public Token getToken(int index) {
    9807     Token t = jj_lookingAhead ? jj_scanpos : token;
    9808     for (int i = 0; i < index; i++) {
    9809       if (t.next != null) t = t.next;
    9810       else t = t.next = token_source.getNextToken();
    9811     }
    9812     return t;
    9813   }
    9814
    9815   private java.util.List<int[]> jj_expentries = new java.util.ArrayList<int[]>();
    9816   private int[] jj_expentry;
    9817   private int jj_kind = -1;
    9818   private int[] jj_lasttokens = new int[100];
    9819   private int jj_endpos;
    9820
    9821   private void jj_add_error_token(int kind, int pos) {
    9822     if (pos >= 100) return;
    9823     if (pos == jj_endpos + 1) {
    9824       jj_lasttokens[jj_endpos++] = kind;
    9825     } else if (jj_endpos != 0) {
    9826       jj_expentry = new int[jj_endpos];
    9827       for (int i = 0; i < jj_endpos; i++) {
    9828         jj_expentry[i] = jj_lasttokens[i];
    9829       }
    9830       jj_entries_loop: for (java.util.Iterator it = jj_expentries.iterator(); it.hasNext();) {
    9831         int[] oldentry = (int[])(it.next());
    9832         if (oldentry.length == jj_expentry.length) {
    9833           for (int i = 0; i < jj_expentry.length; i++) {
    9834             if (oldentry[i] != jj_expentry[i]) {
    9835               continue jj_entries_loop;
    9836             }
    9837           }
    9838           jj_expentries.add(jj_expentry);
    9839           break jj_entries_loop;
    9840         }
    9841       }
    9842       if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind;
    9843     }
    9844   }
    9845
    9846   /** Generate ParseException. */
    9847   public ParseException generateParseException() {
    9848     jj_expentries.clear();
    9849     boolean[] la1tokens = new boolean[126];
    9850     if (jj_kind >= 0) {
    9851       la1tokens[jj_kind] = true;
    9852       jj_kind = -1;
    9853     }
    9854     for (int i = 0; i < 142; i++) {
    9855       if (jj_la1[i] == jj_gen) {
    9856         for (int j = 0; j < 32; j++) {
    9857           if ((jj_la1_0[i] & (1<<j)) != 0) {
    9858             la1tokens[j] = true;
    9859           }
    9860           if ((jj_la1_1[i] & (1<<j)) != 0) {
    9861             la1tokens[32+j] = true;
    9862           }
    9863           if ((jj_la1_2[i] & (1<<j)) != 0) {
    9864             la1tokens[64+j] = true;
    9865           }
    9866           if ((jj_la1_3[i] & (1<<j)) != 0) {
    9867             la1tokens[96+j] = true;
    9868           }
    9869         }
    9870       }
    9871     }
    9872     for (int i = 0; i < 126; i++) {
    9873       if (la1tokens[i]) {
    9874         jj_expentry = new int[1];
    9875         jj_expentry[0] = i;
    9876         jj_expentries.add(jj_expentry);
    9877       }
    9878     }
    9879     jj_endpos = 0;
    9880     jj_rescan_token();
    9881     jj_add_error_token(0, 0);
    9882     int[][] exptokseq = new int[jj_expentries.size()][];
    9883     for (int i = 0; i < jj_expentries.size(); i++) {
    9884       exptokseq[i] = jj_expentries.get(i);
    9885     }
    9886     return new ParseException(token, exptokseq, tokenImage);
    9887   }
    9888
    9889   /** Enable tracing. */
    9890   final public void enable_tracing() {
    9891   }
    9892
    9893   /** Disable tracing. */
    9894   final public void disable_tracing() {
    9895   }
    9896
    9897   private void jj_rescan_token() {
    9898     jj_rescan = true;
    9899     for (int i = 0; i < 55; i++) {
    9900     try {
    9901       JJCalls p = jj_2_rtns[i];
    9902       do {
    9903         if (p.gen > jj_gen) {
    9904           jj_la = p.arg; jj_lastpos = jj_scanpos = p.first;
    9905           switch (i) {
    9906             case 0: jj_3_1(); break;
    9907             case 1: jj_3_2(); break;
    9908             case 2: jj_3_3(); break;
    9909             case 3: jj_3_4(); break;
    9910             case 4: jj_3_5(); break;
    9911             case 5: jj_3_6(); break;
    9912             case 6: jj_3_7(); break;
    9913             case 7: jj_3_8(); break;
    9914             case 8: jj_3_9(); break;
    9915             case 9: jj_3_10(); break;
    9916             case 10: jj_3_11(); break;
    9917             case 11: jj_3_12(); break;
    9918             case 12: jj_3_13(); break;
    9919             case 13: jj_3_14(); break;
    9920             case 14: jj_3_15(); break;
    9921             case 15: jj_3_16(); break;
    9922             case 16: jj_3_17(); break;
    9923             case 17: jj_3_18(); break;
    9924             case 18: jj_3_19(); break;
    9925             case 19: jj_3_20(); break;
    9926             case 20: jj_3_21(); break;
    9927             case 21: jj_3_22(); break;
    9928             case 22: jj_3_23(); break;
    9929             case 23: jj_3_24(); break;
    9930             case 24: jj_3_25(); break;
    9931             case 25: jj_3_26(); break;
    9932             case 26: jj_3_27(); break;
    9933             case 27: jj_3_28(); break;
    9934             case 28: jj_3_29(); break;
    9935             case 29: jj_3_30(); break;
    9936             case 30: jj_3_31(); break;
    9937             case 31: jj_3_32(); break;
    9938             case 32: jj_3_33(); break;
    9939             case 33: jj_3_34(); break;
    9940             case 34: jj_3_35(); break;
    9941             case 35: jj_3_36(); break;
    9942             case 36: jj_3_37(); break;
    9943             case 37: jj_3_38(); break;
    9944             case 38: jj_3_39(); break;
    9945             case 39: jj_3_40(); break;
    9946             case 40: jj_3_41(); break;
    9947             case 41: jj_3_42(); break;
    9948             case 42: jj_3_43(); break;
    9949             case 43: jj_3_44(); break;
    9950             case 44: jj_3_45(); break;
    9951             case 45: jj_3_46(); break;
    9952             case 46: jj_3_47(); break;
    9953             case 47: jj_3_48(); break;
    9954             case 48: jj_3_49(); break;
    9955             case 49: jj_3_50(); break;
    9956             case 50: jj_3_51(); break;
    9957             case 51: jj_3_52(); break;
    9958             case 52: jj_3_53(); break;
    9959             case 53: jj_3_54(); break;
    9960             case 54: jj_3_55(); break;
    9961           }
    9962         }
    9963         p = p.next;
    9964       } while (p != null);
    9965       } catch(LookaheadSuccess ls) { }
    9966     }
    9967     jj_rescan = false;
    9968   }
    9969
    9970   private void jj_save(int index, int xla) {
    9971     JJCalls p = jj_2_rtns[index];
    9972     while (p.gen > jj_gen) {
    9973       if (p.next == null) { p = p.next = new JJCalls(); break; }
    9974       p = p.next;
    9975     }
    9976     p.gen = jj_gen + xla - jj_la; p.first = token; p.arg = xla;
    9977   }
    9978
    9979   static final class JJCalls {
    9980     int gen;
    9981     Token first;
    9982     int arg;
    9983     JJCalls next;
    9984   }
    9985
    9986 }