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         AllocationExpression();
    3598       } else if (jj_2_34(3)) {
    3599         MemberSelector();
    3600       } else {
    3601         switch (jj_nt.kind) {
    3602         case LBRACKET:
    3603           jj_consume_token(LBRACKET);
    3604           Expression();
    3605           jj_consume_token(RBRACKET);
    3606                          jjtree.closeNodeScope(jjtn000, true);
    3607                          jjtc000 = false;
    3608                         jjtn000.setIsArrayDereference();
    3609           break;
    3610         case DOT:
    3611           jj_consume_token(DOT);
    3612           t = jj_consume_token(IDENTIFIER);
    3613                        jjtree.closeNodeScope(jjtn000, true);
    3614                        jjtc000 = false;
    3615                       jjtn000.setImage(t.image);
    3616           break;
    3617         case LPAREN:
    3618           Arguments();
    3619                 jjtree.closeNodeScope(jjtn000, true);
    3620                 jjtc000 = false;
    3621                jjtn000.setIsArguments();
    3622           break;
    3623         default:
    3624           jj_la1[94] = jj_gen;
    3625           jj_consume_token(-1);
    3626           throw new ParseException();
    3627         }
    3628       }
    3629     } catch (Throwable jjte000) {
    3630     if (jjtc000) {
    3631       jjtree.clearNodeScope(jjtn000);
    3632       jjtc000 = false;
    3633     } else {
    3634       jjtree.popNode();
    3635     }
    3636     if (jjte000 instanceof RuntimeException) {
    3637       {if (true) throw (RuntimeException)jjte000;}
    3638     }
    3639     if (jjte000 instanceof ParseException) {
    3640       {if (true) throw (ParseException)jjte000;}
    3641     }
    3642     {if (true) throw (Error)jjte000;}
    3643     } finally {
    3644     if (jjtc000) {
    3645       jjtree.closeNodeScope(jjtn000, true);
    3646     }
    3647     }
    3648   }
    3649
    3650   final public void Literal() throws ParseException {
    3651  /*@bgen(jjtree) Literal */
    3652   ASTLiteral jjtn000 = new ASTLiteral(this, JJTLITERAL);
    3653   boolean jjtc000 = true;
    3654   jjtree.openNodeScope(jjtn000);
    3655     try {
    3656       switch (jj_nt.kind) {
    3657       case INTEGER_LITERAL:
    3658   Token t;
    3659         t = jj_consume_token(INTEGER_LITERAL);
    3660                         jjtree.closeNodeScope(jjtn000, true);
    3661                         jjtc000 = false;
    3662                         checkForBadNumericalLiteralslUsage(t); jjtn000.setImage(t.image); jjtn000.setIntLiteral();
    3663         break;
    3664       case FLOATING_POINT_LITERAL:
    3665         t = jj_consume_token(FLOATING_POINT_LITERAL);
    3666                                jjtree.closeNodeScope(jjtn000, true);
    3667                                jjtc000 = false;
    3668                                checkForBadNumericalLiteralslUsage(t); jjtn000.setImage(t.image); jjtn000.setFloatLiteral();
    3669         break;
    3670       case HEX_FLOATING_POINT_LITERAL:
    3671         t = jj_consume_token(HEX_FLOATING_POINT_LITERAL);
    3672                                    jjtree.closeNodeScope(jjtn000, true);
    3673                                    jjtc000 = false;
    3674                                    checkForBadHexFloatingPointLiteral(); checkForBadNumericalLiteralslUsage(t); jjtn000.setImage(t.image); jjtn000.setFloatLiteral();
    3675         break;
    3676       case CHARACTER_LITERAL:
    3677         t = jj_consume_token(CHARACTER_LITERAL);
    3678                           jjtree.closeNodeScope(jjtn000, true);
    3679                           jjtc000 = false;
    3680                          jjtn000.setImage(t.image); jjtn000.setCharLiteral();
    3681         break;
    3682       case STRING_LITERAL:
    3683         t = jj_consume_token(STRING_LITERAL);
    3684                        jjtree.closeNodeScope(jjtn000, true);
    3685                        jjtc000 = false;
    3686                       jjtn000.setImage(t.image); jjtn000.setStringLiteral();
    3687         break;
    3688       case FALSE:
    3689       case TRUE:
    3690         BooleanLiteral();
    3691         break;
    3692       case NULL:
    3693         NullLiteral();
    3694         break;
    3695       default:
    3696         jj_la1[95] = jj_gen;
    3697         jj_consume_token(-1);
    3698         throw new ParseException();
    3699       }
    3700     } catch (Throwable jjte000) {
    3701   if (jjtc000) {
    3702     jjtree.clearNodeScope(jjtn000);
    3703     jjtc000 = false;
    3704   } else {
    3705     jjtree.popNode();
    3706   }
    3707   if (jjte000 instanceof RuntimeException) {
    3708     {if (true) throw (RuntimeException)jjte000;}
    3709   }
    3710   if (jjte000 instanceof ParseException) {
    3711     {if (true) throw (ParseException)jjte000;}
    3712   }
    3713   {if (true) throw (Error)jjte000;}
    3714     } finally {
    3715   if (jjtc000) {
    3716     jjtree.closeNodeScope(jjtn000, true);
    3717   }
    3718     }
    3719   }
    3720
    3721   final public void BooleanLiteral() throws ParseException {
    3722  /*@bgen(jjtree) BooleanLiteral */
    3723   ASTBooleanLiteral jjtn000 = new ASTBooleanLiteral(this, JJTBOOLEANLITERAL);
    3724   boolean jjtc000 = true;
    3725   jjtree.openNodeScope(jjtn000);
    3726     try {
    3727       switch (jj_nt.kind) {
    3728       case TRUE:
    3729         jj_consume_token(TRUE);
    3730            jjtree.closeNodeScope(jjtn000, true);
    3731            jjtc000 = false;
    3732            jjtn000.setTrue();
    3733         break;
    3734       case FALSE:
    3735         jj_consume_token(FALSE);
    3736         break;
    3737       default:
    3738         jj_la1[96] = jj_gen;
    3739         jj_consume_token(-1);
    3740         throw new ParseException();
    3741       }
    3742     } finally {
    3743     if (jjtc000) {
    3744       jjtree.closeNodeScope(jjtn000, true);
    3745     }
    3746     }
    3747   }
    3748
    3749   final public void NullLiteral() throws ParseException {
    3750  /*@bgen(jjtree) NullLiteral */
    3751   ASTNullLiteral jjtn000 = new ASTNullLiteral(this, JJTNULLLITERAL);
    3752   boolean jjtc000 = true;
    3753   jjtree.openNodeScope(jjtn000);
    3754     try {
    3755       jj_consume_token(NULL);
    3756     } finally {
    3757     if (jjtc000) {
    3758       jjtree.closeNodeScope(jjtn000, true);
    3759     }
    3760     }
    3761   }
    3762
    3763   final public void Arguments() throws ParseException {
    3764  /*@bgen(jjtree) Arguments */
    3765   ASTArguments jjtn000 = new ASTArguments(this, JJTARGUMENTS);
    3766   boolean jjtc000 = true;
    3767   jjtree.openNodeScope(jjtn000);
    3768     try {
    3769       jj_consume_token(LPAREN);
    3770       switch (jj_nt.kind) {
    3771       case BOOLEAN:
    3772       case BYTE:
    3773       case CHAR:
    3774       case DOUBLE:
    3775       case FALSE:
    3776       case FLOAT:
    3777       case INT:
    3778       case LONG:
    3779       case NEW:
    3780       case NULL:
    3781       case SHORT:
    3782       case SUPER:
    3783       case THIS:
    3784       case TRUE:
    3785       case VOID:
    3786       case INTEGER_LITERAL:
    3787       case FLOATING_POINT_LITERAL:
    3788       case HEX_FLOATING_POINT_LITERAL:
    3789       case CHARACTER_LITERAL:
    3790       case STRING_LITERAL:
    3791       case IDENTIFIER:
    3792       case LPAREN:
    3793       case BANG:
    3794       case TILDE:
    3795       case INCR:
    3796       case DECR:
    3797       case PLUS:
    3798       case MINUS:
    3799         ArgumentList();
    3800         break;
    3801       default:
    3802         jj_la1[97] = jj_gen;
    3803         ;
    3804       }
    3805       jj_consume_token(RPAREN);
    3806     } catch (Throwable jjte000) {
    3807     if (jjtc000) {
    3808       jjtree.clearNodeScope(jjtn000);
    3809       jjtc000 = false;
    3810     } else {
    3811       jjtree.popNode();
    3812     }
    3813     if (jjte000 instanceof RuntimeException) {
    3814       {if (true) throw (RuntimeException)jjte000;}
    3815     }
    3816     if (jjte000 instanceof ParseException) {
    3817       {if (true) throw (ParseException)jjte000;}
    3818     }
    3819     {if (true) throw (Error)jjte000;}
    3820     } finally {
    3821     if (jjtc000) {
    3822       jjtree.closeNodeScope(jjtn000, true);
    3823     }
    3824     }
    3825   }
    3826
    3827   final public void ArgumentList() throws ParseException {
    3828  /*@bgen(jjtree) ArgumentList */
    3829   ASTArgumentList jjtn000 = new ASTArgumentList(this, JJTARGUMENTLIST);
    3830   boolean jjtc000 = true;
    3831   jjtree.openNodeScope(jjtn000);
    3832     try {
    3833       Expression();
    3834       label_39:
    3835       while (true) {
    3836         switch (jj_nt.kind) {
    3837         case COMMA:
    3838           ;
    3839           break;
    3840         default:
    3841           jj_la1[98] = jj_gen;
    3842           break label_39;
    3843         }
    3844         jj_consume_token(COMMA);
    3845         Expression();
    3846       }
    3847     } catch (Throwable jjte000) {
    3848     if (jjtc000) {
    3849       jjtree.clearNodeScope(jjtn000);
    3850       jjtc000 = false;
    3851     } else {
    3852       jjtree.popNode();
    3853     }
    3854     if (jjte000 instanceof RuntimeException) {
    3855       {if (true) throw (RuntimeException)jjte000;}
    3856     }
    3857     if (jjte000 instanceof ParseException) {
    3858       {if (true) throw (ParseException)jjte000;}
    3859     }
    3860     {if (true) throw (Error)jjte000;}
    3861     } finally {
    3862     if (jjtc000) {
    3863       jjtree.closeNodeScope(jjtn000, true);
    3864     }
    3865     }
    3866   }
    3867
    3868   final public void AllocationExpression() throws ParseException {
    3869  /*@bgen(jjtree) AllocationExpression */
    3870   ASTAllocationExpression jjtn000 = new ASTAllocationExpression(this, JJTALLOCATIONEXPRESSION);
    3871   boolean jjtc000 = true;
    3872   jjtree.openNodeScope(jjtn000);
    3873     try {
    3874       if (jj_2_35(2)) {
    3875         jj_consume_token(NEW);
    3876         PrimitiveType();
    3877         ArrayDimsAndInits();
    3878       } else {
    3879         switch (jj_nt.kind) {
    3880         case NEW:
    3881           jj_consume_token(NEW);
    3882           ClassOrInterfaceType();
    3883           switch (jj_nt.kind) {
    3884           case LT:
    3885             TypeArguments();
    3886             break;
    3887           default:
    3888             jj_la1[99] = jj_gen;
    3889             ;
    3890           }
    3891           switch (jj_nt.kind) {
    3892           case LBRACKET:
    3893             ArrayDimsAndInits();
    3894             break;
    3895           case LPAREN:
    3896             Arguments();
    3897             switch (jj_nt.kind) {
    3898             case LBRACE:
    3899               ClassOrInterfaceBody();
    3900               break;
    3901             default:
    3902               jj_la1[100] = jj_gen;
    3903               ;
    3904             }
    3905             break;
    3906           default:
    3907             jj_la1[101] = jj_gen;
    3908             jj_consume_token(-1);
    3909             throw new ParseException();
    3910           }
    3911           break;
    3912         default:
    3913           jj_la1[102] = jj_gen;
    3914           jj_consume_token(-1);
    3915           throw new ParseException();
    3916         }
    3917       }
    3918     } catch (Throwable jjte000) {
    3919     if (jjtc000) {
    3920       jjtree.clearNodeScope(jjtn000);
    3921       jjtc000 = false;
    3922     } else {
    3923       jjtree.popNode();
    3924     }
    3925     if (jjte000 instanceof RuntimeException) {
    3926       {if (true) throw (RuntimeException)jjte000;}
    3927     }
    3928     if (jjte000 instanceof ParseException) {
    3929       {if (true) throw (ParseException)jjte000;}
    3930     }
    3931     {if (true) throw (Error)jjte000;}
    3932     } finally {
    3933     if (jjtc000) {
    3934       jjtree.closeNodeScope(jjtn000, true);
    3935     }
    3936     }
    3937   }
    3938
    3939 /*
    3940  * The second LOOKAHEAD specification below is to parse to PrimarySuffix
    3941  * if there is an expression between the "[...]".
    3942  */
    3943   final public void ArrayDimsAndInits() throws ParseException {
    3944  /*@bgen(jjtree) ArrayDimsAndInits */
    3945   ASTArrayDimsAndInits jjtn000 = new ASTArrayDimsAndInits(this, JJTARRAYDIMSANDINITS);
    3946   boolean jjtc000 = true;
    3947   jjtree.openNodeScope(jjtn000);
    3948     try {
    3949       if (jj_2_38(2)) {
    3950         label_40:
    3951         while (true) {
    3952           jj_consume_token(LBRACKET);
    3953           Expression();
    3954           jj_consume_token(RBRACKET);
    3955           if (jj_2_36(2)) {
    3956             ;
    3957           } else {
    3958             break label_40;
    3959           }
    3960         }
    3961         label_41:
    3962         while (true) {
    3963           if (jj_2_37(2)) {
    3964             ;
    3965           } else {
    3966             break label_41;
    3967           }
    3968           jj_consume_token(LBRACKET);
    3969           jj_consume_token(RBRACKET);
    3970         }
    3971       } else {
    3972         switch (jj_nt.kind) {
    3973         case LBRACKET:
    3974           label_42:
    3975           while (true) {
    3976             jj_consume_token(LBRACKET);
    3977             jj_consume_token(RBRACKET);
    3978             switch (jj_nt.kind) {
    3979             case LBRACKET:
    3980               ;
    3981               break;
    3982             default:
    3983               jj_la1[103] = jj_gen;
    3984               break label_42;
    3985             }
    3986           }
    3987           ArrayInitializer();
    3988           break;
    3989         default:
    3990           jj_la1[104] = jj_gen;
    3991           jj_consume_token(-1);
    3992           throw new ParseException();
    3993         }
    3994       }
    3995     } catch (Throwable jjte000) {
    3996     if (jjtc000) {
    3997       jjtree.clearNodeScope(jjtn000);
    3998       jjtc000 = false;
    3999     } else {
    4000       jjtree.popNode();
    4001     }
    4002     if (jjte000 instanceof RuntimeException) {
    4003       {if (true) throw (RuntimeException)jjte000;}
    4004     }
    4005     if (jjte000 instanceof ParseException) {
    4006       {if (true) throw (ParseException)jjte000;}
    4007     }
    4008     {if (true) throw (Error)jjte000;}
    4009     } finally {
    4010     if (jjtc000) {
    4011       jjtree.closeNodeScope(jjtn000, true);
    4012     }
    4013     }
    4014   }
    4015
    4016 /*
    4017  * Statement syntax follows.
    4018  */
    4019   final public void Statement() throws ParseException {
    4020  /*@bgen(jjtree) Statement */
    4021   ASTStatement jjtn000 = new ASTStatement(this, JJTSTATEMENT);
    4022   boolean jjtc000 = true;
    4023   jjtree.openNodeScope(jjtn000);
    4024     try {
    4025       if (isNextTokenAnAssert()) {
    4026         AssertStatement();
    4027       } else if (jj_2_39(2)) {
    4028         LabeledStatement();
    4029       } else {
    4030         switch (jj_nt.kind) {
    4031         case LBRACE:
    4032           Block();
    4033           break;
    4034         case SEMICOLON:
    4035           EmptyStatement();
    4036           break;
    4037         case BOOLEAN:
    4038         case BYTE:
    4039         case CHAR:
    4040         case DOUBLE:
    4041         case FALSE:
    4042         case FLOAT:
    4043         case INT:
    4044         case LONG:
    4045         case NEW:
    4046         case NULL:
    4047         case SHORT:
    4048         case SUPER:
    4049         case THIS:
    4050         case TRUE:
    4051         case VOID:
    4052         case INTEGER_LITERAL:
    4053         case FLOATING_POINT_LITERAL:
    4054         case HEX_FLOATING_POINT_LITERAL:
    4055         case CHARACTER_LITERAL:
    4056         case STRING_LITERAL:
    4057         case IDENTIFIER:
    4058         case LPAREN:
    4059         case INCR:
    4060         case DECR:
    4061           StatementExpression();
    4062           jj_consume_token(SEMICOLON);
    4063           break;
    4064         case SWITCH:
    4065           SwitchStatement();
    4066           break;
    4067         case IF:
    4068           IfStatement();
    4069           break;
    4070         case WHILE:
    4071           WhileStatement();
    4072           break;
    4073         case DO:
    4074           DoStatement();
    4075           break;
    4076         case FOR:
    4077           ForStatement();
    4078           break;
    4079         case BREAK:
    4080           BreakStatement();
    4081           break;
    4082         case CONTINUE:
    4083           ContinueStatement();
    4084           break;
    4085         case RETURN:
    4086           ReturnStatement();
    4087           break;
    4088         case THROW:
    4089           ThrowStatement();
    4090           break;
    4091         case SYNCHRONIZED:
    4092           SynchronizedStatement();
    4093           break;
    4094         case TRY:
    4095           TryStatement();
    4096           break;
    4097         default:
    4098           jj_la1[105] = jj_gen;
    4099           jj_consume_token(-1);
    4100           throw new ParseException();
    4101         }
    4102       }
    4103     } catch (Throwable jjte000) {
    4104     if (jjtc000) {
    4105       jjtree.clearNodeScope(jjtn000);
    4106       jjtc000 = false;
    4107     } else {
    4108       jjtree.popNode();
    4109     }
    4110     if (jjte000 instanceof RuntimeException) {
    4111       {if (true) throw (RuntimeException)jjte000;}
    4112     }
    4113     if (jjte000 instanceof ParseException) {
    4114       {if (true) throw (ParseException)jjte000;}
    4115     }
    4116     {if (true) throw (Error)jjte000;}
    4117     } finally {
    4118     if (jjtc000) {
    4119       jjtree.closeNodeScope(jjtn000, true);
    4120     }
    4121     }
    4122   }
    4123
    4124   final public void LabeledStatement() throws ParseException {
    4125  /*@bgen(jjtree) LabeledStatement */
    4126  ASTLabeledStatement jjtn000 = new ASTLabeledStatement(this, JJTLABELEDSTATEMENT);
    4127  boolean jjtc000 = true;
    4128  jjtree.openNodeScope(jjtn000);Token t;
    4129     try {
    4130       t = jj_consume_token(IDENTIFIER);
    4131                   jjtn000.setImage(t.image);
    4132       jj_consume_token(COLON);
    4133       Statement();
    4134     } catch (Throwable jjte000) {
    4135     if (jjtc000) {
    4136       jjtree.clearNodeScope(jjtn000);
    4137       jjtc000 = false;
    4138     } else {
    4139       jjtree.popNode();
    4140     }
    4141     if (jjte000 instanceof RuntimeException) {
    4142       {if (true) throw (RuntimeException)jjte000;}
    4143     }
    4144     if (jjte000 instanceof ParseException) {
    4145       {if (true) throw (ParseException)jjte000;}
    4146     }
    4147     {if (true) throw (Error)jjte000;}
    4148     } finally {
    4149     if (jjtc000) {
    4150       jjtree.closeNodeScope(jjtn000, true);
    4151     }
    4152     }
    4153   }
    4154
    4155   final public void Block() throws ParseException {
    4156  /*@bgen(jjtree) Block */
    4157  ASTBlock jjtn000 = new ASTBlock(this, JJTBLOCK);
    4158  boolean jjtc000 = true;
    4159  jjtree.openNodeScope(jjtn000);Token t;
    4160     try {
    4161       jj_consume_token(LBRACE);
    4162       label_43:
    4163       while (true) {
    4164         if (jj_2_40(1)) {
    4165           ;
    4166         } else {
    4167           break label_43;
    4168         }
    4169         BlockStatement();
    4170       }
    4171       t = jj_consume_token(RBRACE);
    4172                                       jjtree.closeNodeScope(jjtn000, true);
    4173                                       jjtc000 = false;
    4174                                       if (isPrecededByComment(t)) { jjtn000.setContainsComment(); }
    4175     } catch (Throwable jjte000) {
    4176         if (jjtc000) {
    4177           jjtree.clearNodeScope(jjtn000);
    4178           jjtc000 = false;
    4179         } else {
    4180           jjtree.popNode();
    4181         }
    4182         if (jjte000 instanceof RuntimeException) {
    4183           {if (true) throw (RuntimeException)jjte000;}
    4184         }
    4185         if (jjte000 instanceof ParseException) {
    4186           {if (true) throw (ParseException)jjte000;}
    4187         }
    4188         {if (true) throw (Error)jjte000;}
    4189     } finally {
    4190         if (jjtc000) {
    4191           jjtree.closeNodeScope(jjtn000, true);
    4192         }
    4193     }
    4194   }
    4195
    4196   final public void BlockStatement() throws ParseException {
    4197  /*@bgen(jjtree) BlockStatement */
    4198   ASTBlockStatement jjtn000 = new ASTBlockStatement(this, JJTBLOCKSTATEMENT);
    4199   boolean jjtc000 = true;
    4200   jjtree.openNodeScope(jjtn000);
    4201     try {
    4202       if (isNextTokenAnAssert()) {
    4203         AssertStatement();
    4204       } else if (jj_2_41(2147483647)) {
    4205         LocalVariableDeclaration();
    4206         jj_consume_token(SEMICOLON);
    4207       } else if (jj_2_42(1)) {
    4208         Statement();
    4209       } else if (jj_2_43(2147483647)) {
    4210         switch (jj_nt.kind) {
    4211         case AT:
    4212           Annotation();
    4213           break;
    4214         default:
    4215           jj_la1[106] = jj_gen;
    4216           ;
    4217         }
    4218         ClassOrInterfaceDeclaration(0);
    4219       } else {
    4220         jj_consume_token(-1);
    4221         throw new ParseException();
    4222       }
    4223     } catch (Throwable jjte000) {
    4224     if (jjtc000) {
    4225       jjtree.clearNodeScope(jjtn000);
    4226       jjtc000 = false;
    4227     } else {
    4228       jjtree.popNode();
    4229     }
    4230     if (jjte000 instanceof RuntimeException) {
    4231       {if (true) throw (RuntimeException)jjte000;}
    4232     }
    4233     if (jjte000 instanceof ParseException) {
    4234       {if (true) throw (ParseException)jjte000;}
    4235     }
    4236     {if (true) throw (Error)jjte000;}
    4237     } finally {
    4238     if (jjtc000) {
    4239       jjtree.closeNodeScope(jjtn000, true);
    4240     }
    4241     }
    4242   }
    4243
    4244   final public void LocalVariableDeclaration() throws ParseException {
    4245  /*@bgen(jjtree) LocalVariableDeclaration */
    4246   ASTLocalVariableDeclaration jjtn000 = new ASTLocalVariableDeclaration(this, JJTLOCALVARIABLEDECLARATION);
    4247   boolean jjtc000 = true;
    4248   jjtree.openNodeScope(jjtn000);
    4249     try {
    4250       label_44:
    4251       while (true) {
    4252         switch (jj_nt.kind) {
    4253         case FINAL:
    4254         case AT:
    4255           ;
    4256           break;
    4257         default:
    4258           jj_la1[107] = jj_gen;
    4259           break label_44;
    4260         }
    4261         switch (jj_nt.kind) {
    4262         case FINAL:
    4263           jj_consume_token(FINAL);
    4264              jjtn000.setFinal(true);
    4265           break;
    4266         case AT:
    4267           Annotation();
    4268           break;
    4269         default:
    4270           jj_la1[108] = jj_gen;
    4271           jj_consume_token(-1);
    4272           throw new ParseException();
    4273         }
    4274       }
    4275       Type();
    4276       VariableDeclarator();
    4277       label_45:
    4278       while (true) {
    4279         switch (jj_nt.kind) {
    4280         case COMMA:
    4281           ;
    4282           break;
    4283         default:
    4284           jj_la1[109] = jj_gen;
    4285           break label_45;
    4286         }
    4287         jj_consume_token(COMMA);
    4288         VariableDeclarator();
    4289       }
    4290     } catch (Throwable jjte000) {
    4291     if (jjtc000) {
    4292       jjtree.clearNodeScope(jjtn000);
    4293       jjtc000 = false;
    4294     } else {
    4295       jjtree.popNode();
    4296     }
    4297     if (jjte000 instanceof RuntimeException) {
    4298       {if (true) throw (RuntimeException)jjte000;}
    4299     }
    4300     if (jjte000 instanceof ParseException) {
    4301       {if (true) throw (ParseException)jjte000;}
    4302     }
    4303     {if (true) throw (Error)jjte000;}
    4304     } finally {
    4305     if (jjtc000) {
    4306       jjtree.closeNodeScope(jjtn000, true);
    4307     }
    4308     }
    4309   }
    4310
    4311   final public void EmptyStatement() throws ParseException {
    4312  /*@bgen(jjtree) EmptyStatement */
    4313   ASTEmptyStatement jjtn000 = new ASTEmptyStatement(this, JJTEMPTYSTATEMENT);
    4314   boolean jjtc000 = true;
    4315   jjtree.openNodeScope(jjtn000);
    4316     try {
    4317       jj_consume_token(SEMICOLON);
    4318     } finally {
    4319     if (jjtc000) {
    4320       jjtree.closeNodeScope(jjtn000, true);
    4321     }
    4322     }
    4323   }
    4324
    4325   final public void StatementExpression() throws ParseException {
    4326  /*@bgen(jjtree) StatementExpression */
    4327   ASTStatementExpression jjtn000 = new ASTStatementExpression(this, JJTSTATEMENTEXPRESSION);
    4328   boolean jjtc000 = true;
    4329   jjtree.openNodeScope(jjtn000);
    4330     try {
    4331       switch (jj_nt.kind) {
    4332       case INCR:
    4333         PreIncrementExpression();
    4334         break;
    4335       case DECR:
    4336         PreDecrementExpression();
    4337         break;
    4338       default:
    4339         jj_la1[111] = jj_gen;
    4340         if (jj_2_44(2147483647)) {
    4341           PostfixExpression();
    4342         } else {
    4343           switch (jj_nt.kind) {
    4344           case BOOLEAN:
    4345           case BYTE:
    4346           case CHAR:
    4347           case DOUBLE:
    4348           case FALSE:
    4349           case FLOAT:
    4350           case INT:
    4351           case LONG:
    4352           case NEW:
    4353           case NULL:
    4354           case SHORT:
    4355           case SUPER:
    4356           case THIS:
    4357           case TRUE:
    4358           case VOID:
    4359           case INTEGER_LITERAL:
    4360           case FLOATING_POINT_LITERAL:
    4361           case HEX_FLOATING_POINT_LITERAL:
    4362           case CHARACTER_LITERAL:
    4363           case STRING_LITERAL:
    4364           case IDENTIFIER:
    4365           case LPAREN:
    4366             PrimaryExpression();
    4367             switch (jj_nt.kind) {
    4368             case ASSIGN:
    4369             case PLUSASSIGN:
    4370             case MINUSASSIGN:
    4371             case STARASSIGN:
    4372             case SLASHASSIGN:
    4373             case ANDASSIGN:
    4374             case ORASSIGN:
    4375             case XORASSIGN:
    4376             case REMASSIGN:
    4377             case LSHIFTASSIGN:
    4378             case RSIGNEDSHIFTASSIGN:
    4379             case RUNSIGNEDSHIFTASSIGN:
    4380               AssignmentOperator();
    4381               Expression();
    4382               break;
    4383             default:
    4384               jj_la1[110] = jj_gen;
    4385               ;
    4386             }
    4387             break;
    4388           default:
    4389             jj_la1[112] = jj_gen;
    4390             jj_consume_token(-1);
    4391             throw new ParseException();
    4392           }
    4393         }
    4394       }
    4395     } catch (Throwable jjte000) {
    4396     if (jjtc000) {
    4397       jjtree.clearNodeScope(jjtn000);
    4398       jjtc000 = false;
    4399     } else {
    4400       jjtree.popNode();
    4401     }
    4402     if (jjte000 instanceof RuntimeException) {
    4403       {if (true) throw (RuntimeException)jjte000;}
    4404     }
    4405     if (jjte000 instanceof ParseException) {
    4406       {if (true) throw (ParseException)jjte000;}
    4407     }
    4408     {if (true) throw (Error)jjte000;}
    4409     } finally {
    4410     if (jjtc000) {
    4411       jjtree.closeNodeScope(jjtn000, true);
    4412     }
    4413     }
    4414   }
    4415
    4416   final public void SwitchStatement() throws ParseException {
    4417  /*@bgen(jjtree) SwitchStatement */
    4418   ASTSwitchStatement jjtn000 = new ASTSwitchStatement(this, JJTSWITCHSTATEMENT);
    4419   boolean jjtc000 = true;
    4420   jjtree.openNodeScope(jjtn000);
    4421     try {
    4422       jj_consume_token(SWITCH);
    4423       jj_consume_token(LPAREN);
    4424       Expression();
    4425       jj_consume_token(RPAREN);
    4426       jj_consume_token(LBRACE);
    4427       label_46:
    4428       while (true) {
    4429         switch (jj_nt.kind) {
    4430         case CASE:
    4431         case _DEFAULT:
    4432           ;
    4433           break;
    4434         default:
    4435           jj_la1[113] = jj_gen;
    4436           break label_46;
    4437         }
    4438         SwitchLabel();
    4439         label_47:
    4440         while (true) {
    4441           if (jj_2_45(1)) {
    4442             ;
    4443           } else {
    4444             break label_47;
    4445           }
    4446           BlockStatement();
    4447         }
    4448       }
    4449       jj_consume_token(RBRACE);
    4450     } catch (Throwable jjte000) {
    4451     if (jjtc000) {
    4452       jjtree.clearNodeScope(jjtn000);
    4453       jjtc000 = false;
    4454     } else {
    4455       jjtree.popNode();
    4456     }
    4457     if (jjte000 instanceof RuntimeException) {
    4458       {if (true) throw (RuntimeException)jjte000;}
    4459     }
    4460     if (jjte000 instanceof ParseException) {
    4461       {if (true) throw (ParseException)jjte000;}
    4462     }
    4463     {if (true) throw (Error)jjte000;}
    4464     } finally {
    4465     if (jjtc000) {
    4466       jjtree.closeNodeScope(jjtn000, true);
    4467     }
    4468     }
    4469   }
    4470
    4471   final public void SwitchLabel() throws ParseException {
    4472  /*@bgen(jjtree) SwitchLabel */
    4473   ASTSwitchLabel jjtn000 = new ASTSwitchLabel(this, JJTSWITCHLABEL);
    4474   boolean jjtc000 = true;
    4475   jjtree.openNodeScope(jjtn000);
    4476     try {
    4477       switch (jj_nt.kind) {
    4478       case CASE:
    4479         jj_consume_token(CASE);
    4480         Expression();
    4481         jj_consume_token(COLON);
    4482         break;
    4483       case _DEFAULT:
    4484         jj_consume_token(_DEFAULT);
    4485              jjtn000.setDefault();
    4486         jj_consume_token(COLON);
    4487         break;
    4488       default:
    4489         jj_la1[114] = jj_gen;
    4490         jj_consume_token(-1);
    4491         throw new ParseException();
    4492       }
    4493     } catch (Throwable jjte000) {
    4494     if (jjtc000) {
    4495       jjtree.clearNodeScope(jjtn000);
    4496       jjtc000 = false;
    4497     } else {
    4498       jjtree.popNode();
    4499     }
    4500     if (jjte000 instanceof RuntimeException) {
    4501       {if (true) throw (RuntimeException)jjte000;}
    4502     }
    4503     if (jjte000 instanceof ParseException) {
    4504       {if (true) throw (ParseException)jjte000;}
    4505     }
    4506     {if (true) throw (Error)jjte000;}
    4507     } finally {
    4508     if (jjtc000) {
    4509       jjtree.closeNodeScope(jjtn000, true);
    4510     }
    4511     }
    4512   }
    4513
    4514   final public void IfStatement() throws ParseException {
    4515  /*@bgen(jjtree) IfStatement */
    4516   ASTIfStatement jjtn000 = new ASTIfStatement(this, JJTIFSTATEMENT);
    4517   boolean jjtc000 = true;
    4518   jjtree.openNodeScope(jjtn000);
    4519     try {
    4520       jj_consume_token(IF);
    4521       jj_consume_token(LPAREN);
    4522       Expression();
    4523       jj_consume_token(RPAREN);
    4524       Statement();
    4525       switch (jj_nt.kind) {
    4526       case ELSE:
    4527         jj_consume_token(ELSE);
    4528                                                                jjtn000.setHasElse();
    4529         Statement();
    4530         break;
    4531       default:
    4532         jj_la1[115] = jj_gen;
    4533         ;
    4534       }
    4535   jjtree.closeNodeScope(jjtn000, true);
    4536   jjtc000 = false;
    4537
    4538     } catch (Throwable jjte000) {
    4539     if (jjtc000) {
    4540       jjtree.clearNodeScope(jjtn000);
    4541       jjtc000 = false;
    4542     } else {
    4543       jjtree.popNode();
    4544     }
    4545     if (jjte000 instanceof RuntimeException) {
    4546       {if (true) throw (RuntimeException)jjte000;}
    4547     }
    4548     if (jjte000 instanceof ParseException) {
    4549       {if (true) throw (ParseException)jjte000;}
    4550     }
    4551     {if (true) throw (Error)jjte000;}
    4552     } finally {
    4553     if (jjtc000) {
    4554       jjtree.closeNodeScope(jjtn000, true);
    4555     }
    4556     }
    4557   }
    4558
    4559   final public void WhileStatement() throws ParseException {
    4560  /*@bgen(jjtree) WhileStatement */
    4561   ASTWhileStatement jjtn000 = new ASTWhileStatement(this, JJTWHILESTATEMENT);
    4562   boolean jjtc000 = true;
    4563   jjtree.openNodeScope(jjtn000);
    4564     try {
    4565       jj_consume_token(WHILE);
    4566       jj_consume_token(LPAREN);
    4567       Expression();
    4568       jj_consume_token(RPAREN);
    4569       Statement();
    4570     } catch (Throwable jjte000) {
    4571     if (jjtc000) {
    4572       jjtree.clearNodeScope(jjtn000);
    4573       jjtc000 = false;
    4574     } else {
    4575       jjtree.popNode();
    4576     }
    4577     if (jjte000 instanceof RuntimeException) {
    4578       {if (true) throw (RuntimeException)jjte000;}
    4579     }
    4580     if (jjte000 instanceof ParseException) {
    4581       {if (true) throw (ParseException)jjte000;}
    4582     }
    4583     {if (true) throw (Error)jjte000;}
    4584     } finally {
    4585     if (jjtc000) {
    4586       jjtree.closeNodeScope(jjtn000, true);
    4587     }
    4588     }
    4589   }
    4590
    4591   final public void DoStatement() throws ParseException {
    4592  /*@bgen(jjtree) DoStatement */
    4593   ASTDoStatement jjtn000 = new ASTDoStatement(this, JJTDOSTATEMENT);
    4594   boolean jjtc000 = true;
    4595   jjtree.openNodeScope(jjtn000);
    4596     try {
    4597       jj_consume_token(DO);
    4598       Statement();
    4599       jj_consume_token(WHILE);
    4600       jj_consume_token(LPAREN);
    4601       Expression();
    4602       jj_consume_token(RPAREN);
    4603       jj_consume_token(SEMICOLON);
    4604     } catch (Throwable jjte000) {
    4605     if (jjtc000) {
    4606       jjtree.clearNodeScope(jjtn000);
    4607       jjtc000 = false;
    4608     } else {
    4609       jjtree.popNode();
    4610     }
    4611     if (jjte000 instanceof RuntimeException) {
    4612       {if (true) throw (RuntimeException)jjte000;}
    4613     }
    4614     if (jjte000 instanceof ParseException) {
    4615       {if (true) throw (ParseException)jjte000;}
    4616     }
    4617     {if (true) throw (Error)jjte000;}
    4618     } finally {
    4619     if (jjtc000) {
    4620       jjtree.closeNodeScope(jjtn000, true);
    4621     }
    4622     }
    4623   }
    4624
    4625   final public void ForStatement() throws ParseException {
    4626  /*@bgen(jjtree) ForStatement */
    4627   ASTForStatement jjtn000 = new ASTForStatement(this, JJTFORSTATEMENT);
    4628   boolean jjtc000 = true;
    4629   jjtree.openNodeScope(jjtn000);
    4630     try {
    4631       jj_consume_token(FOR);
    4632       jj_consume_token(LPAREN);
    4633       if (jj_2_46(2147483647)) {
    4634        checkForBadJDK15ForLoopSyntaxArgumentsUsage();
    4635         LocalVariableDeclaration();
    4636         jj_consume_token(COLON);
    4637         Expression();
    4638       } else {
    4639         switch (jj_nt.kind) {
    4640         case BOOLEAN:
    4641         case BYTE:
    4642         case CHAR:
    4643         case DOUBLE:
    4644         case FALSE:
    4645         case FINAL:
    4646         case FLOAT:
    4647         case INT:
    4648         case LONG:
    4649         case NEW:
    4650         case NULL:
    4651         case SHORT:
    4652         case SUPER:
    4653         case THIS:
    4654         case TRUE:
    4655         case VOID:
    4656         case INTEGER_LITERAL:
    4657         case FLOATING_POINT_LITERAL:
    4658         case HEX_FLOATING_POINT_LITERAL:
    4659         case CHARACTER_LITERAL:
    4660         case STRING_LITERAL:
    4661         case IDENTIFIER:
    4662         case LPAREN:
    4663         case SEMICOLON:
    4664         case AT:
    4665         case INCR:
    4666         case DECR:
    4667           switch (jj_nt.kind) {
    4668           case BOOLEAN:
    4669           case BYTE:
    4670           case CHAR:
    4671           case DOUBLE:
    4672           case FALSE:
    4673           case FINAL:
    4674           case FLOAT:
    4675           case INT:
    4676           case LONG:
    4677           case NEW:
    4678           case NULL:
    4679           case SHORT:
    4680           case SUPER:
    4681           case THIS:
    4682           case TRUE:
    4683           case VOID:
    4684           case INTEGER_LITERAL:
    4685           case FLOATING_POINT_LITERAL:
    4686           case HEX_FLOATING_POINT_LITERAL:
    4687           case CHARACTER_LITERAL:
    4688           case STRING_LITERAL:
    4689           case IDENTIFIER:
    4690           case LPAREN:
    4691           case AT:
    4692           case INCR:
    4693           case DECR:
    4694             ForInit();
    4695             break;
    4696           default:
    4697             jj_la1[116] = jj_gen;
    4698             ;
    4699           }
    4700           jj_consume_token(SEMICOLON);
    4701           switch (jj_nt.kind) {
    4702           case BOOLEAN:
    4703           case BYTE:
    4704           case CHAR:
    4705           case DOUBLE:
    4706           case FALSE:
    4707           case FLOAT:
    4708           case INT:
    4709           case LONG:
    4710           case NEW:
    4711           case NULL:
    4712           case SHORT:
    4713           case SUPER:
    4714           case THIS:
    4715           case TRUE:
    4716           case VOID:
    4717           case INTEGER_LITERAL:
    4718           case FLOATING_POINT_LITERAL:
    4719           case HEX_FLOATING_POINT_LITERAL:
    4720           case CHARACTER_LITERAL:
    4721           case STRING_LITERAL:
    4722           case IDENTIFIER:
    4723           case LPAREN:
    4724           case BANG:
    4725           case TILDE:
    4726           case INCR:
    4727           case DECR:
    4728           case PLUS:
    4729           case MINUS:
    4730             Expression();
    4731             break;
    4732           default:
    4733             jj_la1[117] = jj_gen;
    4734             ;
    4735           }
    4736           jj_consume_token(SEMICOLON);
    4737           switch (jj_nt.kind) {
    4738           case BOOLEAN:
    4739           case BYTE:
    4740           case CHAR:
    4741           case DOUBLE:
    4742           case FALSE:
    4743           case FLOAT:
    4744           case INT:
    4745           case LONG:
    4746           case NEW:
    4747           case NULL:
    4748           case SHORT:
    4749           case SUPER:
    4750           case THIS:
    4751           case TRUE:
    4752           case VOID:
    4753           case INTEGER_LITERAL:
    4754           case FLOATING_POINT_LITERAL:
    4755           case HEX_FLOATING_POINT_LITERAL:
    4756           case CHARACTER_LITERAL:
    4757           case STRING_LITERAL:
    4758           case IDENTIFIER:
    4759           case LPAREN:
    4760           case INCR:
    4761           case DECR:
    4762             ForUpdate();
    4763             break;
    4764           default:
    4765             jj_la1[118] = jj_gen;
    4766             ;
    4767           }
    4768           break;
    4769         default:
    4770           jj_la1[119] = jj_gen;
    4771           jj_consume_token(-1);
    4772           throw new ParseException();
    4773         }
    4774       }
    4775       jj_consume_token(RPAREN);
    4776       Statement();
    4777     } catch (Throwable jjte000) {
    4778     if (jjtc000) {
    4779       jjtree.clearNodeScope(jjtn000);
    4780       jjtc000 = false;
    4781     } else {
    4782       jjtree.popNode();
    4783     }
    4784     if (jjte000 instanceof RuntimeException) {
    4785       {if (true) throw (RuntimeException)jjte000;}
    4786     }
    4787     if (jjte000 instanceof ParseException) {
    4788       {if (true) throw (ParseException)jjte000;}
    4789     }
    4790     {if (true) throw (Error)jjte000;}
    4791     } finally {
    4792     if (jjtc000) {
    4793       jjtree.closeNodeScope(jjtn000, true);
    4794     }
    4795     }
    4796   }
    4797
    4798   final public void ForInit() throws ParseException {
    4799  /*@bgen(jjtree) ForInit */
    4800   ASTForInit jjtn000 = new ASTForInit(this, JJTFORINIT);
    4801   boolean jjtc000 = true;
    4802   jjtree.openNodeScope(jjtn000);
    4803     try {
    4804       if (jj_2_47(2147483647)) {
    4805         LocalVariableDeclaration();
    4806       } else {
    4807         switch (jj_nt.kind) {
    4808         case BOOLEAN:
    4809         case BYTE:
    4810         case CHAR:
    4811         case DOUBLE:
    4812         case FALSE:
    4813         case FLOAT:
    4814         case INT:
    4815         case LONG:
    4816         case NEW:
    4817         case NULL:
    4818         case SHORT:
    4819         case SUPER:
    4820         case THIS:
    4821         case TRUE:
    4822         case VOID:
    4823         case INTEGER_LITERAL:
    4824         case FLOATING_POINT_LITERAL:
    4825         case HEX_FLOATING_POINT_LITERAL:
    4826         case CHARACTER_LITERAL:
    4827         case STRING_LITERAL:
    4828         case IDENTIFIER:
    4829         case LPAREN:
    4830         case INCR:
    4831         case DECR:
    4832           StatementExpressionList();
    4833           break;
    4834         default:
    4835           jj_la1[120] = jj_gen;
    4836           jj_consume_token(-1);
    4837           throw new ParseException();
    4838         }
    4839       }
    4840     } catch (Throwable jjte000) {
    4841     if (jjtc000) {
    4842       jjtree.clearNodeScope(jjtn000);
    4843       jjtc000 = false;
    4844     } else {
    4845       jjtree.popNode();
    4846     }
    4847     if (jjte000 instanceof RuntimeException) {
    4848       {if (true) throw (RuntimeException)jjte000;}
    4849     }
    4850     if (jjte000 instanceof ParseException) {
    4851       {if (true) throw (ParseException)jjte000;}
    4852     }
    4853     {if (true) throw (Error)jjte000;}
    4854     } finally {
    4855     if (jjtc000) {
    4856       jjtree.closeNodeScope(jjtn000, true);
    4857     }
    4858     }
    4859   }
    4860
    4861   final public void StatementExpressionList() throws ParseException {
    4862  /*@bgen(jjtree) StatementExpressionList */
    4863   ASTStatementExpressionList jjtn000 = new ASTStatementExpressionList(this, JJTSTATEMENTEXPRESSIONLIST);
    4864   boolean jjtc000 = true;
    4865   jjtree.openNodeScope(jjtn000);
    4866     try {
    4867       StatementExpression();
    4868       label_48:
    4869       while (true) {
    4870         switch (jj_nt.kind) {
    4871         case COMMA:
    4872           ;
    4873           break;
    4874         default:
    4875           jj_la1[121] = jj_gen;
    4876           break label_48;
    4877         }
    4878         jj_consume_token(COMMA);
    4879         StatementExpression();
    4880       }
    4881     } catch (Throwable jjte000) {
    4882     if (jjtc000) {
    4883       jjtree.clearNodeScope(jjtn000);
    4884       jjtc000 = false;
    4885     } else {
    4886       jjtree.popNode();
    4887     }
    4888     if (jjte000 instanceof RuntimeException) {
    4889       {if (true) throw (RuntimeException)jjte000;}
    4890     }
    4891     if (jjte000 instanceof ParseException) {
    4892       {if (true) throw (ParseException)jjte000;}
    4893     }
    4894     {if (true) throw (Error)jjte000;}
    4895     } finally {
    4896     if (jjtc000) {
    4897       jjtree.closeNodeScope(jjtn000, true);
    4898     }
    4899     }
    4900   }
    4901
    4902   final public void ForUpdate() throws ParseException {
    4903  /*@bgen(jjtree) ForUpdate */
    4904   ASTForUpdate jjtn000 = new ASTForUpdate(this, JJTFORUPDATE);
    4905   boolean jjtc000 = true;
    4906   jjtree.openNodeScope(jjtn000);
    4907     try {
    4908       StatementExpressionList();
    4909     } catch (Throwable jjte000) {
    4910     if (jjtc000) {
    4911       jjtree.clearNodeScope(jjtn000);
    4912       jjtc000 = false;
    4913     } else {
    4914       jjtree.popNode();
    4915     }
    4916     if (jjte000 instanceof RuntimeException) {
    4917       {if (true) throw (RuntimeException)jjte000;}
    4918     }
    4919     if (jjte000 instanceof ParseException) {
    4920       {if (true) throw (ParseException)jjte000;}
    4921     }
    4922     {if (true) throw (Error)jjte000;}
    4923     } finally {
    4924     if (jjtc000) {
    4925       jjtree.closeNodeScope(jjtn000, true);
    4926     }
    4927     }
    4928   }
    4929
    4930   final public void BreakStatement() throws ParseException {
    4931  /*@bgen(jjtree) BreakStatement */
    4932  ASTBreakStatement jjtn000 = new ASTBreakStatement(this, JJTBREAKSTATEMENT);
    4933  boolean jjtc000 = true;
    4934  jjtree.openNodeScope(jjtn000);Token t;
    4935     try {
    4936       jj_consume_token(BREAK);
    4937       switch (jj_nt.kind) {
    4938       case IDENTIFIER:
    4939         t = jj_consume_token(IDENTIFIER);
    4940                             jjtn000.setImage(t.image);
    4941         break;
    4942       default:
    4943         jj_la1[122] = jj_gen;
    4944         ;
    4945       }
    4946       jj_consume_token(SEMICOLON);
    4947     } finally {
    4948     if (jjtc000) {
    4949       jjtree.closeNodeScope(jjtn000, true);
    4950     }
    4951     }
    4952   }
    4953
    4954   final public void ContinueStatement() throws ParseException {
    4955  /*@bgen(jjtree) ContinueStatement */
    4956  ASTContinueStatement jjtn000 = new ASTContinueStatement(this, JJTCONTINUESTATEMENT);
    4957  boolean jjtc000 = true;
    4958  jjtree.openNodeScope(jjtn000);Token t;
    4959     try {
    4960       jj_consume_token(CONTINUE);
    4961       switch (jj_nt.kind) {
    4962       case IDENTIFIER:
    4963         t = jj_consume_token(IDENTIFIER);
    4964                                jjtn000.setImage(t.image);
    4965         break;
    4966       default:
    4967         jj_la1[123] = jj_gen;
    4968         ;
    4969       }
    4970       jj_consume_token(SEMICOLON);
    4971     } finally {
    4972     if (jjtc000) {
    4973       jjtree.closeNodeScope(jjtn000, true);
    4974     }
    4975     }
    4976   }
    4977
    4978   final public void ReturnStatement() throws ParseException {
    4979  /*@bgen(jjtree) ReturnStatement */
    4980   ASTReturnStatement jjtn000 = new ASTReturnStatement(this, JJTRETURNSTATEMENT);
    4981   boolean jjtc000 = true;
    4982   jjtree.openNodeScope(jjtn000);
    4983     try {
    4984       jj_consume_token(RETURN);
    4985       switch (jj_nt.kind) {
    4986       case BOOLEAN:
    4987       case BYTE:
    4988       case CHAR:
    4989       case DOUBLE:
    4990       case FALSE:
    4991       case FLOAT:
    4992       case INT:
    4993       case LONG:
    4994       case NEW:
    4995       case NULL:
    4996       case SHORT:
    4997       case SUPER:
    4998       case THIS:
    4999       case TRUE:
    5000       case VOID:
    5001       case INTEGER_LITERAL:
    5002       case FLOATING_POINT_LITERAL:
    5003       case HEX_FLOATING_POINT_LITERAL:
    5004       case CHARACTER_LITERAL:
    5005       case STRING_LITERAL:
    5006       case IDENTIFIER:
    5007       case LPAREN:
    5008       case BANG:
    5009       case TILDE:
    5010       case INCR:
    5011       case DECR:
    5012       case PLUS:
    5013       case MINUS:
    5014         Expression();
    5015         break;
    5016       default:
    5017         jj_la1[124] = jj_gen;
    5018         ;
    5019       }
    5020       jj_consume_token(SEMICOLON);
    5021     } catch (Throwable jjte000) {
    5022     if (jjtc000) {
    5023       jjtree.clearNodeScope(jjtn000);
    5024       jjtc000 = false;
    5025     } else {
    5026       jjtree.popNode();
    5027     }
    5028     if (jjte000 instanceof RuntimeException) {
    5029       {if (true) throw (RuntimeException)jjte000;}
    5030     }
    5031     if (jjte000 instanceof ParseException) {
    5032       {if (true) throw (ParseException)jjte000;}
    5033     }
    5034     {if (true) throw (Error)jjte000;}
    5035     } finally {
    5036     if (jjtc000) {
    5037       jjtree.closeNodeScope(jjtn000, true);
    5038     }
    5039     }
    5040   }
    5041
    5042   final public void ThrowStatement() throws ParseException {
    5043  /*@bgen(jjtree) ThrowStatement */
    5044   ASTThrowStatement jjtn000 = new ASTThrowStatement(this, JJTTHROWSTATEMENT);
    5045   boolean jjtc000 = true;
    5046   jjtree.openNodeScope(jjtn000);
    5047     try {
    5048       jj_consume_token(THROW);
    5049       Expression();
    5050       jj_consume_token(SEMICOLON);
    5051     } catch (Throwable jjte000) {
    5052     if (jjtc000) {
    5053       jjtree.clearNodeScope(jjtn000);
    5054       jjtc000 = false;
    5055     } else {
    5056       jjtree.popNode();
    5057     }
    5058     if (jjte000 instanceof RuntimeException) {
    5059       {if (true) throw (RuntimeException)jjte000;}
    5060     }
    5061     if (jjte000 instanceof ParseException) {
    5062       {if (true) throw (ParseException)jjte000;}
    5063     }
    5064     {if (true) throw (Error)jjte000;}
    5065     } finally {
    5066     if (jjtc000) {
    5067       jjtree.closeNodeScope(jjtn000, true);
    5068     }
    5069     }
    5070   }
    5071
    5072   final public void SynchronizedStatement() throws ParseException {
    5073  /*@bgen(jjtree) SynchronizedStatement */
    5074   ASTSynchronizedStatement jjtn000 = new ASTSynchronizedStatement(this, JJTSYNCHRONIZEDSTATEMENT);
    5075   boolean jjtc000 = true;
    5076   jjtree.openNodeScope(jjtn000);
    5077     try {
    5078       jj_consume_token(SYNCHRONIZED);
    5079       jj_consume_token(LPAREN);
    5080       Expression();
    5081       jj_consume_token(RPAREN);
    5082       Block();
    5083     } catch (Throwable jjte000) {
    5084     if (jjtc000) {
    5085       jjtree.clearNodeScope(jjtn000);
    5086       jjtc000 = false;
    5087     } else {
    5088       jjtree.popNode();
    5089     }
    5090     if (jjte000 instanceof RuntimeException) {
    5091       {if (true) throw (RuntimeException)jjte000;}
    5092     }
    5093     if (jjte000 instanceof ParseException) {
    5094       {if (true) throw (ParseException)jjte000;}
    5095     }
    5096     {if (true) throw (Error)jjte000;}
    5097     } finally {
    5098     if (jjtc000) {
    5099       jjtree.closeNodeScope(jjtn000, true);
    5100     }
    5101     }
    5102   }
    5103
    5104   final public void TryStatement() throws ParseException {
    5105  /*@bgen(jjtree) TryStatement */
    5106   ASTTryStatement jjtn000 = new ASTTryStatement(this, JJTTRYSTATEMENT);
    5107   boolean jjtc000 = true;
    5108   jjtree.openNodeScope(jjtn000);
    5109     try {
    5110       jj_consume_token(TRY);
    5111       switch (jj_nt.kind) {
    5112       case LPAREN:
    5113         ResourceSpecification();
    5114         break;
    5115       default:
    5116         jj_la1[125] = jj_gen;
    5117         ;
    5118       }
    5119       Block();
    5120       label_49:
    5121       while (true) {
    5122         switch (jj_nt.kind) {
    5123         case CATCH:
    5124           ;
    5125           break;
    5126         default:
    5127           jj_la1[126] = jj_gen;
    5128           break label_49;
    5129         }
    5130         CatchStatement();
    5131       }
    5132       switch (jj_nt.kind) {
    5133       case FINALLY:
    5134         FinallyStatement();
    5135         break;
    5136       default:
    5137         jj_la1[127] = jj_gen;
    5138         ;
    5139       }
    5140     } catch (Throwable jjte000) {
    5141     if (jjtc000) {
    5142       jjtree.clearNodeScope(jjtn000);
    5143       jjtc000 = false;
    5144     } else {
    5145       jjtree.popNode();
    5146     }
    5147     if (jjte000 instanceof RuntimeException) {
    5148       {if (true) throw (RuntimeException)jjte000;}
    5149     }
    5150     if (jjte000 instanceof ParseException) {
    5151       {if (true) throw (ParseException)jjte000;}
    5152     }
    5153     {if (true) throw (Error)jjte000;}
    5154     } finally {
    5155     if (jjtc000) {
    5156       jjtree.closeNodeScope(jjtn000, true);
    5157     }
    5158     }
    5159   }
    5160
    5161   final public void ResourceSpecification() throws ParseException {
    5162  /*@bgen(jjtree) ResourceSpecification */
    5163   ASTResourceSpecification jjtn000 = new ASTResourceSpecification(this, JJTRESOURCESPECIFICATION);
    5164   boolean jjtc000 = true;
    5165   jjtree.openNodeScope(jjtn000);
    5166     try {
    5167      checkForBadTryWithResourcesUsage();
    5168       jj_consume_token(LPAREN);
    5169       Resources();
    5170       if (jj_2_48(2)) {
    5171         jj_consume_token(SEMICOLON);
    5172       } else {
    5173         ;
    5174       }
    5175       jj_consume_token(RPAREN);
    5176     } catch (Throwable jjte000) {
    5177       if (jjtc000) {
    5178         jjtree.clearNodeScope(jjtn000);
    5179         jjtc000 = false;
    5180       } else {
    5181         jjtree.popNode();
    5182       }
    5183       if (jjte000 instanceof RuntimeException) {
    5184         {if (true) throw (RuntimeException)jjte000;}
    5185       }
    5186       if (jjte000 instanceof ParseException) {
    5187         {if (true) throw (ParseException)jjte000;}
    5188       }
    5189       {if (true) throw (Error)jjte000;}
    5190     } finally {
    5191       if (jjtc000) {
    5192         jjtree.closeNodeScope(jjtn000, true);
    5193       }
    5194     }
    5195   }
    5196
    5197   final public void Resources() throws ParseException {
    5198  /*@bgen(jjtree) Resources */
    5199   ASTResources jjtn000 = new ASTResources(this, JJTRESOURCES);
    5200   boolean jjtc000 = true;
    5201   jjtree.openNodeScope(jjtn000);
    5202     try {
    5203       Resource();
    5204       label_50:
    5205       while (true) {
    5206         if (jj_2_49(2)) {
    5207           ;
    5208         } else {
    5209           break label_50;
    5210         }
    5211         jj_consume_token(SEMICOLON);
    5212         Resource();
    5213       }
    5214     } catch (Throwable jjte000) {
    5215           if (jjtc000) {
    5216             jjtree.clearNodeScope(jjtn000);
    5217             jjtc000 = false;
    5218           } else {
    5219             jjtree.popNode();
    5220           }
    5221           if (jjte000 instanceof RuntimeException) {
    5222             {if (true) throw (RuntimeException)jjte000;}
    5223           }
    5224           if (jjte000 instanceof ParseException) {
    5225             {if (true) throw (ParseException)jjte000;}
    5226           }
    5227           {if (true) throw (Error)jjte000;}
    5228     } finally {
    5229           if (jjtc000) {
    5230             jjtree.closeNodeScope(jjtn000, true);
    5231           }
    5232     }
    5233   }
    5234
    5235   final public void Resource() throws ParseException {
    5236  /*@bgen(jjtree) Resource */
    5237   ASTResource jjtn000 = new ASTResource(this, JJTRESOURCE);
    5238   boolean jjtc000 = true;
    5239   jjtree.openNodeScope(jjtn000);
    5240     try {
    5241       label_51:
    5242       while (true) {
    5243         switch (jj_nt.kind) {
    5244         case FINAL:
    5245         case AT:
    5246           ;
    5247           break;
    5248         default:
    5249           jj_la1[128] = jj_gen;
    5250           break label_51;
    5251         }
    5252         switch (jj_nt.kind) {
    5253         case FINAL:
    5254           jj_consume_token(FINAL);
    5255           break;
    5256         case AT:
    5257           Annotation();
    5258           break;
    5259         default:
    5260           jj_la1[129] = jj_gen;
    5261           jj_consume_token(-1);
    5262           throw new ParseException();
    5263         }
    5264       }
    5265       Type();
    5266       VariableDeclaratorId();
    5267       jj_consume_token(ASSIGN);
    5268       Expression();
    5269     } catch (Throwable jjte000) {
    5270           if (jjtc000) {
    5271             jjtree.clearNodeScope(jjtn000);
    5272             jjtc000 = false;
    5273           } else {
    5274             jjtree.popNode();
    5275           }
    5276           if (jjte000 instanceof RuntimeException) {
    5277             {if (true) throw (RuntimeException)jjte000;}
    5278           }
    5279           if (jjte000 instanceof ParseException) {
    5280             {if (true) throw (ParseException)jjte000;}
    5281           }
    5282           {if (true) throw (Error)jjte000;}
    5283     } finally {
    5284           if (jjtc000) {
    5285             jjtree.closeNodeScope(jjtn000, true);
    5286           }
    5287     }
    5288   }
    5289
    5290   final public void CatchStatement() throws ParseException {
    5291  /*@bgen(jjtree) CatchStatement */
    5292   ASTCatchStatement jjtn000 = new ASTCatchStatement(this, JJTCATCHSTATEMENT);
    5293   boolean jjtc000 = true;
    5294   jjtree.openNodeScope(jjtn000);
    5295     try {
    5296       jj_consume_token(CATCH);
    5297       jj_consume_token(LPAREN);
    5298       FormalParameter();
    5299       jj_consume_token(RPAREN);
    5300       Block();
    5301     } catch (Throwable jjte000) {
    5302     if (jjtc000) {
    5303       jjtree.clearNodeScope(jjtn000);
    5304       jjtc000 = false;
    5305     } else {
    5306       jjtree.popNode();
    5307     }
    5308     if (jjte000 instanceof RuntimeException) {
    5309       {if (true) throw (RuntimeException)jjte000;}
    5310     }
    5311     if (jjte000 instanceof ParseException) {
    5312       {if (true) throw (ParseException)jjte000;}
    5313     }
    5314     {if (true) throw (Error)jjte000;}
    5315     } finally {
    5316     if (jjtc000) {
    5317       jjtree.closeNodeScope(jjtn000, true);
    5318     }
    5319     }
    5320   }
    5321
    5322   final public void FinallyStatement() throws ParseException {
    5323  /*@bgen(jjtree) FinallyStatement */
    5324   ASTFinallyStatement jjtn000 = new ASTFinallyStatement(this, JJTFINALLYSTATEMENT);
    5325   boolean jjtc000 = true;
    5326   jjtree.openNodeScope(jjtn000);
    5327     try {
    5328       jj_consume_token(FINALLY);
    5329       Block();
    5330     } catch (Throwable jjte000) {
    5331       if (jjtc000) {
    5332         jjtree.clearNodeScope(jjtn000);
    5333         jjtc000 = false;
    5334       } else {
    5335         jjtree.popNode();
    5336       }
    5337       if (jjte000 instanceof RuntimeException) {
    5338         {if (true) throw (RuntimeException)jjte000;}
    5339       }
    5340       if (jjte000 instanceof ParseException) {
    5341         {if (true) throw (ParseException)jjte000;}
    5342       }
    5343       {if (true) throw (Error)jjte000;}
    5344     } finally {
    5345       if (jjtc000) {
    5346         jjtree.closeNodeScope(jjtn000, true);
    5347       }
    5348     }
    5349   }
    5350
    5351   final public void AssertStatement() throws ParseException {
    5352  /*@bgen(jjtree) AssertStatement */
    5353     ASTAssertStatement jjtn000 = new ASTAssertStatement(this, JJTASSERTSTATEMENT);
    5354     boolean jjtc000 = true;
    5355     jjtree.openNodeScope(jjtn000);if (jdkVersion <= 3) {
    5356         throw new ParseException("Can't use 'assert' as a keyword when running in JDK 1.3 mode!");
    5357     }
    5358     try {
    5359       jj_consume_token(IDENTIFIER);
    5360       Expression();
    5361       switch (jj_nt.kind) {
    5362       case COLON:
    5363         jj_consume_token(COLON);
    5364         Expression();
    5365         break;
    5366       default:
    5367         jj_la1[130] = jj_gen;
    5368         ;
    5369       }
    5370       jj_consume_token(SEMICOLON);
    5371     } catch (Throwable jjte000) {
    5372     if (jjtc000) {
    5373       jjtree.clearNodeScope(jjtn000);
    5374       jjtc000 = false;
    5375     } else {
    5376       jjtree.popNode();
    5377     }
    5378     if (jjte000 instanceof RuntimeException) {
    5379       {if (true) throw (RuntimeException)jjte000;}
    5380     }
    5381     if (jjte000 instanceof ParseException) {
    5382       {if (true) throw (ParseException)jjte000;}
    5383     }
    5384     {if (true) throw (Error)jjte000;}
    5385     } finally {
    5386     if (jjtc000) {
    5387       jjtree.closeNodeScope(jjtn000, true);
    5388     }
    5389     }
    5390   }
    5391
    5392 /* We use productions to match >>>, >> and > so that we can keep the
    5393  * type declaration syntax with generics clean
    5394  */
    5395   final public void RUNSIGNEDSHIFT() throws ParseException {
    5396  /*@bgen(jjtree) RUNSIGNEDSHIFT */
    5397   ASTRUNSIGNEDSHIFT jjtn000 = new ASTRUNSIGNEDSHIFT(this, JJTRUNSIGNEDSHIFT);
    5398   boolean jjtc000 = true;
    5399   jjtree.openNodeScope(jjtn000);
    5400     try {
    5401       if (getToken(1).kind == GT &&
    5402                       ((Token.GTToken)getToken(1)).realKind == RUNSIGNEDSHIFT) {
    5403
    5404       } else {
    5405         jj_consume_token(-1);
    5406         throw new ParseException();
    5407       }
    5408       jj_consume_token(GT);
    5409       jj_consume_token(GT);
    5410       jj_consume_token(GT);
    5411     } finally {
    5412     if (jjtc000) {
    5413       jjtree.closeNodeScope(jjtn000, true);
    5414     }
    5415     }
    5416   }
    5417
    5418   final public void RSIGNEDSHIFT() throws ParseException {
    5419  /*@bgen(jjtree) RSIGNEDSHIFT */
    5420   ASTRSIGNEDSHIFT jjtn000 = new ASTRSIGNEDSHIFT(this, JJTRSIGNEDSHIFT);
    5421   boolean jjtc000 = true;
    5422   jjtree.openNodeScope(jjtn000);
    5423     try {
    5424       if (getToken(1).kind == GT &&
    5425                       ((Token.GTToken)getToken(1)).realKind == RSIGNEDSHIFT) {
    5426
    5427       } else {
    5428         jj_consume_token(-1);
    5429         throw new ParseException();
    5430       }
    5431       jj_consume_token(GT);
    5432       jj_consume_token(GT);
    5433     } finally {
    5434     if (jjtc000) {
    5435       jjtree.closeNodeScope(jjtn000, true);
    5436     }
    5437     }
    5438   }
    5439
    5440 /* Annotation syntax follows. */
    5441   final public void Annotation() throws ParseException {
    5442  /*@bgen(jjtree) Annotation */
    5443   ASTAnnotation jjtn000 = new ASTAnnotation(this, JJTANNOTATION);
    5444   boolean jjtc000 = true;
    5445   jjtree.openNodeScope(jjtn000);
    5446     try {
    5447       if (jj_2_50(2147483647)) {
    5448         NormalAnnotation();
    5449       } else if (jj_2_51(2147483647)) {
    5450         SingleMemberAnnotation();
    5451       } else {
    5452         switch (jj_nt.kind) {
    5453         case AT:
    5454           MarkerAnnotation();
    5455           break;
    5456         default:
    5457           jj_la1[131] = jj_gen;
    5458           jj_consume_token(-1);
    5459           throw new ParseException();
    5460         }
    5461       }
    5462     } catch (Throwable jjte000) {
    5463      if (jjtc000) {
    5464        jjtree.clearNodeScope(jjtn000);
    5465        jjtc000 = false;
    5466      } else {
    5467        jjtree.popNode();
    5468      }
    5469      if (jjte000 instanceof RuntimeException) {
    5470        {if (true) throw (RuntimeException)jjte000;}
    5471      }
    5472      if (jjte000 instanceof ParseException) {
    5473        {if (true) throw (ParseException)jjte000;}
    5474      }
    5475      {if (true) throw (Error)jjte000;}
    5476     } finally {
    5477      if (jjtc000) {
    5478        jjtree.closeNodeScope(jjtn000, true);
    5479      }
    5480     }
    5481   }
    5482
    5483   final public void NormalAnnotation() throws ParseException {
    5484  /*@bgen(jjtree) NormalAnnotation */
    5485   ASTNormalAnnotation jjtn000 = new ASTNormalAnnotation(this, JJTNORMALANNOTATION);
    5486   boolean jjtc000 = true;
    5487   jjtree.openNodeScope(jjtn000);
    5488     try {
    5489       jj_consume_token(AT);
    5490       Name();
    5491       jj_consume_token(LPAREN);
    5492       switch (jj_nt.kind) {
    5493       case IDENTIFIER:
    5494         MemberValuePairs();
    5495         break;
    5496       default:
    5497         jj_la1[132] = jj_gen;
    5498         ;
    5499       }
    5500       jj_consume_token(RPAREN);
    5501                                                jjtree.closeNodeScope(jjtn000, true);
    5502                                                jjtc000 = false;
    5503                                               checkForBadAnnotationUsage();
    5504     } catch (Throwable jjte000) {
    5505      if (jjtc000) {
    5506        jjtree.clearNodeScope(jjtn000);
    5507        jjtc000 = false;
    5508      } else {
    5509        jjtree.popNode();
    5510      }
    5511      if (jjte000 instanceof RuntimeException) {
    5512        {if (true) throw (RuntimeException)jjte000;}
    5513      }
    5514      if (jjte000 instanceof ParseException) {
    5515        {if (true) throw (ParseException)jjte000;}
    5516      }
    5517      {if (true) throw (Error)jjte000;}
    5518     } finally {
    5519      if (jjtc000) {
    5520        jjtree.closeNodeScope(jjtn000, true);
    5521      }
    5522     }
    5523   }
    5524
    5525   final public void MarkerAnnotation() throws ParseException {
    5526  /*@bgen(jjtree) MarkerAnnotation */
    5527   ASTMarkerAnnotation jjtn000 = new ASTMarkerAnnotation(this, JJTMARKERANNOTATION);
    5528   boolean jjtc000 = true;
    5529   jjtree.openNodeScope(jjtn000);
    5530     try {
    5531       jj_consume_token(AT);
    5532       Name();
    5533                jjtree.closeNodeScope(jjtn000, true);
    5534                jjtc000 = false;
    5535               checkForBadAnnotationUsage();
    5536     } catch (Throwable jjte000) {
    5537     if (jjtc000) {
    5538       jjtree.clearNodeScope(jjtn000);
    5539       jjtc000 = false;
    5540     } else {
    5541       jjtree.popNode();
    5542     }
    5543     if (jjte000 instanceof RuntimeException) {
    5544       {if (true) throw (RuntimeException)jjte000;}
    5545     }
    5546     if (jjte000 instanceof ParseException) {
    5547       {if (true) throw (ParseException)jjte000;}
    5548     }
    5549     {if (true) throw (Error)jjte000;}
    5550     } finally {
    5551     if (jjtc000) {
    5552       jjtree.closeNodeScope(jjtn000, true);
    5553     }
    5554     }
    5555   }
    5556
    5557   final public void SingleMemberAnnotation() throws ParseException {
    5558  /*@bgen(jjtree) SingleMemberAnnotation */
    5559   ASTSingleMemberAnnotation jjtn000 = new ASTSingleMemberAnnotation(this, JJTSINGLEMEMBERANNOTATION);
    5560   boolean jjtc000 = true;
    5561   jjtree.openNodeScope(jjtn000);
    5562     try {
    5563       jj_consume_token(AT);
    5564       Name();
    5565       jj_consume_token(LPAREN);
    5566       MemberValue();
    5567       jj_consume_token(RPAREN);
    5568                                      jjtree.closeNodeScope(jjtn000, true);
    5569                                      jjtc000 = false;
    5570                                     checkForBadAnnotationUsage();
    5571     } catch (Throwable jjte000) {
    5572     if (jjtc000) {
    5573       jjtree.clearNodeScope(jjtn000);
    5574       jjtc000 = false;
    5575     } else {
    5576       jjtree.popNode();
    5577     }
    5578     if (jjte000 instanceof RuntimeException) {
    5579       {if (true) throw (RuntimeException)jjte000;}
    5580     }
    5581     if (jjte000 instanceof ParseException) {
    5582       {if (true) throw (ParseException)jjte000;}
    5583     }
    5584     {if (true) throw (Error)jjte000;}
    5585     } finally {
    5586     if (jjtc000) {
    5587       jjtree.closeNodeScope(jjtn000, true);
    5588     }
    5589     }
    5590   }
    5591
    5592   final public void MemberValuePairs() throws ParseException {
    5593  /*@bgen(jjtree) MemberValuePairs */
    5594   ASTMemberValuePairs jjtn000 = new ASTMemberValuePairs(this, JJTMEMBERVALUEPAIRS);
    5595   boolean jjtc000 = true;
    5596   jjtree.openNodeScope(jjtn000);
    5597     try {
    5598       MemberValuePair();
    5599       label_52:
    5600       while (true) {
    5601         switch (jj_nt.kind) {
    5602         case COMMA:
    5603           ;
    5604           break;
    5605         default:
    5606           jj_la1[133] = jj_gen;
    5607           break label_52;
    5608         }
    5609         jj_consume_token(COMMA);
    5610         MemberValuePair();
    5611       }
    5612     } catch (Throwable jjte000) {
    5613      if (jjtc000) {
    5614        jjtree.clearNodeScope(jjtn000);
    5615        jjtc000 = false;
    5616      } else {
    5617        jjtree.popNode();
    5618      }
    5619      if (jjte000 instanceof RuntimeException) {
    5620        {if (true) throw (RuntimeException)jjte000;}
    5621      }
    5622      if (jjte000 instanceof ParseException) {
    5623        {if (true) throw (ParseException)jjte000;}
    5624      }
    5625      {if (true) throw (Error)jjte000;}
    5626     } finally {
    5627      if (jjtc000) {
    5628        jjtree.closeNodeScope(jjtn000, true);
    5629      }
    5630     }
    5631   }
    5632
    5633   final public void MemberValuePair() throws ParseException {
    5634  /*@bgen(jjtree) MemberValuePair */
    5635  ASTMemberValuePair jjtn000 = new ASTMemberValuePair(this, JJTMEMBERVALUEPAIR);
    5636  boolean jjtc000 = true;
    5637  jjtree.openNodeScope(jjtn000);Token t;
    5638     try {
    5639       t = jj_consume_token(IDENTIFIER);
    5640                      jjtn000.setImage(t.image);
    5641       jj_consume_token(ASSIGN);
    5642       MemberValue();
    5643     } catch (Throwable jjte000) {
    5644       if (jjtc000) {
    5645         jjtree.clearNodeScope(jjtn000);
    5646         jjtc000 = false;
    5647       } else {
    5648         jjtree.popNode();
    5649       }
    5650       if (jjte000 instanceof RuntimeException) {
    5651         {if (true) throw (RuntimeException)jjte000;}
    5652       }
    5653       if (jjte000 instanceof ParseException) {
    5654         {if (true) throw (ParseException)jjte000;}
    5655       }
    5656       {if (true) throw (Error)jjte000;}
    5657     } finally {
    5658       if (jjtc000) {
    5659         jjtree.closeNodeScope(jjtn000, true);
    5660       }
    5661     }
    5662   }
    5663
    5664   final public void MemberValue() throws ParseException {
    5665  /*@bgen(jjtree) MemberValue */
    5666   ASTMemberValue jjtn000 = new ASTMemberValue(this, JJTMEMBERVALUE);
    5667   boolean jjtc000 = true;
    5668   jjtree.openNodeScope(jjtn000);
    5669     try {
    5670       switch (jj_nt.kind) {
    5671       case AT:
    5672         Annotation();
    5673         break;
    5674       case LBRACE:
    5675         MemberValueArrayInitializer();
    5676         break;
    5677       case BOOLEAN:
    5678       case BYTE:
    5679       case CHAR:
    5680       case DOUBLE:
    5681       case FALSE:
    5682       case FLOAT:
    5683       case INT:
    5684       case LONG:
    5685       case NEW:
    5686       case NULL:
    5687       case SHORT:
    5688       case SUPER:
    5689       case THIS:
    5690       case TRUE:
    5691       case VOID:
    5692       case INTEGER_LITERAL:
    5693       case FLOATING_POINT_LITERAL:
    5694       case HEX_FLOATING_POINT_LITERAL:
    5695       case CHARACTER_LITERAL:
    5696       case STRING_LITERAL:
    5697       case IDENTIFIER:
    5698       case LPAREN:
    5699       case BANG:
    5700       case TILDE:
    5701       case INCR:
    5702       case DECR:
    5703       case PLUS:
    5704       case MINUS:
    5705         ConditionalExpression();
    5706         break;
    5707       default:
    5708         jj_la1[134] = jj_gen;
    5709         jj_consume_token(-1);
    5710         throw new ParseException();
    5711       }
    5712     } catch (Throwable jjte000) {
    5713      if (jjtc000) {
    5714        jjtree.clearNodeScope(jjtn000);
    5715        jjtc000 = false;
    5716      } else {
    5717        jjtree.popNode();
    5718      }
    5719      if (jjte000 instanceof RuntimeException) {
    5720        {if (true) throw (RuntimeException)jjte000;}
    5721      }
    5722      if (jjte000 instanceof ParseException) {
    5723        {if (true) throw (ParseException)jjte000;}
    5724      }
    5725      {if (true) throw (Error)jjte000;}
    5726     } finally {
    5727      if (jjtc000) {
    5728        jjtree.closeNodeScope(jjtn000, true);
    5729      }
    5730     }
    5731   }
    5732
    5733   final public void MemberValueArrayInitializer() throws ParseException {
    5734  /*@bgen(jjtree) MemberValueArrayInitializer */
    5735   ASTMemberValueArrayInitializer jjtn000 = new ASTMemberValueArrayInitializer(this, JJTMEMBERVALUEARRAYINITIALIZER);
    5736   boolean jjtc000 = true;
    5737   jjtree.openNodeScope(jjtn000);
    5738     try {
    5739       jj_consume_token(LBRACE);
    5740       switch (jj_nt.kind) {
    5741       case BOOLEAN:
    5742       case BYTE:
    5743       case CHAR:
    5744       case DOUBLE:
    5745       case FALSE:
    5746       case FLOAT:
    5747       case INT:
    5748       case LONG:
    5749       case NEW:
    5750       case NULL:
    5751       case SHORT:
    5752       case SUPER:
    5753       case THIS:
    5754       case TRUE:
    5755       case VOID:
    5756       case INTEGER_LITERAL:
    5757       case FLOATING_POINT_LITERAL:
    5758       case HEX_FLOATING_POINT_LITERAL:
    5759       case CHARACTER_LITERAL:
    5760       case STRING_LITERAL:
    5761       case IDENTIFIER:
    5762       case LPAREN:
    5763       case LBRACE:
    5764       case AT:
    5765       case BANG:
    5766       case TILDE:
    5767       case INCR:
    5768       case DECR:
    5769       case PLUS:
    5770       case MINUS:
    5771         MemberValue();
    5772         label_53:
    5773         while (true) {
    5774           if (jj_2_52(2)) {
    5775             ;
    5776           } else {
    5777             break label_53;
    5778           }
    5779           jj_consume_token(COMMA);
    5780           MemberValue();
    5781         }
    5782         switch (jj_nt.kind) {
    5783         case COMMA:
    5784           jj_consume_token(COMMA);
    5785           break;
    5786         default:
    5787           jj_la1[135] = jj_gen;
    5788           ;
    5789         }
    5790         break;
    5791       default:
    5792         jj_la1[136] = jj_gen;
    5793         ;
    5794       }
    5795       jj_consume_token(RBRACE);
    5796     } catch (Throwable jjte000) {
    5797     if (jjtc000) {
    5798       jjtree.clearNodeScope(jjtn000);
    5799       jjtc000 = false;
    5800     } else {
    5801       jjtree.popNode();
    5802     }
    5803     if (jjte000 instanceof RuntimeException) {
    5804       {if (true) throw (RuntimeException)jjte000;}
    5805     }
    5806     if (jjte000 instanceof ParseException) {
    5807       {if (true) throw (ParseException)jjte000;}
    5808     }
    5809     {if (true) throw (Error)jjte000;}
    5810     } finally {
    5811     if (jjtc000) {
    5812       jjtree.closeNodeScope(jjtn000, true);
    5813     }
    5814     }
    5815   }
    5816
    5817 /* Annotation Types. */
    5818   final public void AnnotationTypeDeclaration(int modifiers) throws ParseException {
    5819  /*@bgen(jjtree) AnnotationTypeDeclaration */
    5820 ASTAnnotationTypeDeclaration jjtn000 = new ASTAnnotationTypeDeclaration(this, JJTANNOTATIONTYPEDECLARATION);
    5821 boolean jjtc000 = true;
    5822 jjtree.openNodeScope(jjtn000);Token t;
    5823 jjtn000.setModifiers(modifiers);
    5824     try {
    5825       jj_consume_token(AT);
    5826       jj_consume_token(INTERFACE);
    5827       t = jj_consume_token(IDENTIFIER);
    5828                                   checkForBadAnnotationUsage();jjtn000.setImage(t.image);
    5829       AnnotationTypeBody();
    5830     } catch (Throwable jjte000) {
    5831     if (jjtc000) {
    5832       jjtree.clearNodeScope(jjtn000);
    5833       jjtc000 = false;
    5834     } else {
    5835       jjtree.popNode();
    5836     }
    5837     if (jjte000 instanceof RuntimeException) {
    5838       {if (true) throw (RuntimeException)jjte000;}
    5839     }
    5840     if (jjte000 instanceof ParseException) {
    5841       {if (true) throw (ParseException)jjte000;}
    5842     }
    5843     {if (true) throw (Error)jjte000;}
    5844     } finally {
    5845     if (jjtc000) {
    5846       jjtree.closeNodeScope(jjtn000, true);
    5847     }
    5848     }
    5849   }
    5850
    5851   final public void AnnotationTypeBody() throws ParseException {
    5852  /*@bgen(jjtree) AnnotationTypeBody */
    5853   ASTAnnotationTypeBody jjtn000 = new ASTAnnotationTypeBody(this, JJTANNOTATIONTYPEBODY);
    5854   boolean jjtc000 = true;
    5855   jjtree.openNodeScope(jjtn000);
    5856     try {
    5857       jj_consume_token(LBRACE);
    5858       label_54:
    5859       while (true) {
    5860         switch (jj_nt.kind) {
    5861         case ABSTRACT:
    5862         case BOOLEAN:
    5863         case BYTE:
    5864         case CHAR:
    5865         case CLASS:
    5866         case DOUBLE:
    5867         case FINAL:
    5868         case FLOAT:
    5869         case INT:
    5870         case INTERFACE:
    5871         case LONG:
    5872         case NATIVE:
    5873         case PRIVATE:
    5874         case PROTECTED:
    5875         case PUBLIC:
    5876         case SHORT:
    5877         case STATIC:
    5878         case SYNCHRONIZED:
    5879         case TRANSIENT:
    5880         case VOLATILE:
    5881         case STRICTFP:
    5882         case IDENTIFIER:
    5883         case SEMICOLON:
    5884         case AT:
    5885           ;
    5886           break;
    5887         default:
    5888           jj_la1[137] = jj_gen;
    5889           break label_54;
    5890         }
    5891         AnnotationTypeMemberDeclaration();
    5892       }
    5893       jj_consume_token(RBRACE);
    5894     } catch (Throwable jjte000) {
    5895     if (jjtc000) {
    5896       jjtree.clearNodeScope(jjtn000);
    5897       jjtc000 = false;
    5898     } else {
    5899       jjtree.popNode();
    5900     }
    5901     if (jjte000 instanceof RuntimeException) {
    5902       {if (true) throw (RuntimeException)jjte000;}
    5903     }
    5904     if (jjte000 instanceof ParseException) {
    5905       {if (true) throw (ParseException)jjte000;}
    5906     }
    5907     {if (true) throw (Error)jjte000;}
    5908     } finally {
    5909     if (jjtc000) {
    5910       jjtree.closeNodeScope(jjtn000, true);
    5911     }
    5912     }
    5913   }
    5914
    5915   final public void AnnotationTypeMemberDeclaration() throws ParseException {
    5916  /*@bgen(jjtree) AnnotationTypeMemberDeclaration */
    5917    ASTAnnotationTypeMemberDeclaration jjtn000 = new ASTAnnotationTypeMemberDeclaration(this, JJTANNOTATIONTYPEMEMBERDECLARATION);
    5918    boolean jjtc000 = true;
    5919    jjtree.openNodeScope(jjtn000);int modifiers;
    5920     try {
    5921       switch (jj_nt.kind) {
    5922       case ABSTRACT:
    5923       case BOOLEAN:
    5924       case BYTE:
    5925       case CHAR:
    5926       case CLASS:
    5927       case DOUBLE:
    5928       case FINAL:
    5929       case FLOAT:
    5930       case INT:
    5931       case INTERFACE:
    5932       case LONG:
    5933       case NATIVE:
    5934       case PRIVATE:
    5935       case PROTECTED:
    5936       case PUBLIC:
    5937       case SHORT:
    5938       case STATIC:
    5939       case SYNCHRONIZED:
    5940       case TRANSIENT:
    5941       case VOLATILE:
    5942       case STRICTFP:
    5943       case IDENTIFIER:
    5944       case AT:
    5945         modifiers = Modifiers();
    5946         if (jj_2_53(3)) {
    5947           AnnotationMethodDeclaration(modifiers);
    5948         } else {
    5949           switch (jj_nt.kind) {
    5950           case ABSTRACT:
    5951           case CLASS:
    5952           case FINAL:
    5953           case INTERFACE:
    5954             ClassOrInterfaceDeclaration(modifiers);
    5955             break;
    5956           default:
    5957             jj_la1[138] = jj_gen;
    5958             if (jj_2_54(3)) {
    5959               EnumDeclaration(modifiers);
    5960             } else {
    5961               switch (jj_nt.kind) {
    5962               case AT:
    5963                 AnnotationTypeDeclaration(modifiers);
    5964                 break;
    5965               case BOOLEAN:
    5966               case BYTE:
    5967               case CHAR:
    5968               case DOUBLE:
    5969               case FLOAT:
    5970               case INT:
    5971               case LONG:
    5972               case SHORT:
    5973               case IDENTIFIER:
    5974                 FieldDeclaration(modifiers);
    5975                 break;
    5976               default:
    5977                 jj_la1[139] = jj_gen;
    5978                 jj_consume_token(-1);
    5979                 throw new ParseException();
    5980               }
    5981             }
    5982           }
    5983         }
    5984         break;
    5985       case SEMICOLON:
    5986         jj_consume_token(SEMICOLON);
    5987         break;
    5988       default:
    5989         jj_la1[140] = jj_gen;
    5990         jj_consume_token(-1);
    5991         throw new ParseException();
    5992       }
    5993     } catch (Throwable jjte000) {
    5994    if (jjtc000) {
    5995      jjtree.clearNodeScope(jjtn000);
    5996      jjtc000 = false;
    5997    } else {
    5998      jjtree.popNode();
    5999    }
    6000    if (jjte000 instanceof RuntimeException) {
    6001      {if (true) throw (RuntimeException)jjte000;}
    6002    }
    6003    if (jjte000 instanceof ParseException) {
    6004      {if (true) throw (ParseException)jjte000;}
    6005    }
    6006    {if (true) throw (Error)jjte000;}
    6007     } finally {
    6008    if (jjtc000) {
    6009      jjtree.closeNodeScope(jjtn000, true);
    6010    }
    6011     }
    6012   }
    6013
    6014   final public void AnnotationMethodDeclaration(int modifiers) throws ParseException {
    6015  /*@bgen(jjtree) AnnotationMethodDeclaration */
    6016   ASTAnnotationMethodDeclaration jjtn000 = new ASTAnnotationMethodDeclaration(this, JJTANNOTATIONMETHODDECLARATION);
    6017   boolean jjtc000 = true;
    6018   jjtree.openNodeScope(jjtn000);Token t;
    6019   jjtn000.setModifiers(modifiers);
    6020     try {
    6021       Type();
    6022       t = jj_consume_token(IDENTIFIER);
    6023       jj_consume_token(LPAREN);
    6024       jj_consume_token(RPAREN);
    6025       switch (jj_nt.kind) {
    6026       case _DEFAULT:
    6027         DefaultValue();
    6028         break;
    6029       default:
    6030         jj_la1[141] = jj_gen;
    6031         ;
    6032       }
    6033       jj_consume_token(SEMICOLON);
    6034     jjtree.closeNodeScope(jjtn000, true);
    6035     jjtc000 = false;
    6036     jjtn000.setImage(t.image);
    6037     } catch (Throwable jjte000) {
    6038     if (jjtc000) {
    6039       jjtree.clearNodeScope(jjtn000);
    6040       jjtc000 = false;
    6041     } else {
    6042       jjtree.popNode();
    6043     }
    6044     if (jjte000 instanceof RuntimeException) {
    6045       {if (true) throw (RuntimeException)jjte000;}
    6046     }
    6047     if (jjte000 instanceof ParseException) {
    6048       {if (true) throw (ParseException)jjte000;}
    6049     }
    6050     {if (true) throw (Error)jjte000;}
    6051     } finally {
    6052     if (jjtc000) {
    6053       jjtree.closeNodeScope(jjtn000, true);
    6054     }
    6055     }
    6056   }
    6057
    6058   final public void DefaultValue() throws ParseException {
    6059  /*@bgen(jjtree) DefaultValue */
    6060   ASTDefaultValue jjtn000 = new ASTDefaultValue(this, JJTDEFAULTVALUE);
    6061   boolean jjtc000 = true;
    6062   jjtree.openNodeScope(jjtn000);
    6063     try {
    6064       jj_consume_token(_DEFAULT);
    6065       MemberValue();
    6066     } catch (Throwable jjte000) {
    6067     if (jjtc000) {
    6068       jjtree.clearNodeScope(jjtn000);
    6069       jjtc000 = false;
    6070     } else {
    6071       jjtree.popNode();
    6072     }
    6073     if (jjte000 instanceof RuntimeException) {
    6074       {if (true) throw (RuntimeException)jjte000;}
    6075     }
    6076     if (jjte000 instanceof ParseException) {
    6077       {if (true) throw (ParseException)jjte000;}
    6078     }
    6079     {if (true) throw (Error)jjte000;}
    6080     } finally {
    6081     if (jjtc000) {
    6082       jjtree.closeNodeScope(jjtn000, true);
    6083     }
    6084     }
    6085   }
    6086
    6087   private boolean jj_2_1(int xla) {
    6088     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6089     try { return !jj_3_1(); }
    6090     catch(LookaheadSuccess ls) { return true; }
    6091     finally { jj_save(0, xla); }
    6092   }
    6093
    6094   private boolean jj_2_2(int xla) {
    6095     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6096     try { return !jj_3_2(); }
    6097     catch(LookaheadSuccess ls) { return true; }
    6098     finally { jj_save(1, xla); }
    6099   }
    6100
    6101   private boolean jj_2_3(int xla) {
    6102     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6103     try { return !jj_3_3(); }
    6104     catch(LookaheadSuccess ls) { return true; }
    6105     finally { jj_save(2, xla); }
    6106   }
    6107
    6108   private boolean jj_2_4(int xla) {
    6109     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6110     try { return !jj_3_4(); }
    6111     catch(LookaheadSuccess ls) { return true; }
    6112     finally { jj_save(3, xla); }
    6113   }
    6114
    6115   private boolean jj_2_5(int xla) {
    6116     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6117     try { return !jj_3_5(); }
    6118     catch(LookaheadSuccess ls) { return true; }
    6119     finally { jj_save(4, xla); }
    6120   }
    6121
    6122   private boolean jj_2_6(int xla) {
    6123     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6124     try { return !jj_3_6(); }
    6125     catch(LookaheadSuccess ls) { return true; }
    6126     finally { jj_save(5, xla); }
    6127   }
    6128
    6129   private boolean jj_2_7(int xla) {
    6130     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6131     try { return !jj_3_7(); }
    6132     catch(LookaheadSuccess ls) { return true; }
    6133     finally { jj_save(6, xla); }
    6134   }
    6135
    6136   private boolean jj_2_8(int xla) {
    6137     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6138     try { return !jj_3_8(); }
    6139     catch(LookaheadSuccess ls) { return true; }
    6140     finally { jj_save(7, xla); }
    6141   }
    6142
    6143   private boolean jj_2_9(int xla) {
    6144     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6145     try { return !jj_3_9(); }
    6146     catch(LookaheadSuccess ls) { return true; }
    6147     finally { jj_save(8, xla); }
    6148   }
    6149
    6150   private boolean jj_2_10(int xla) {
    6151     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6152     try { return !jj_3_10(); }
    6153     catch(LookaheadSuccess ls) { return true; }
    6154     finally { jj_save(9, xla); }
    6155   }
    6156
    6157   private boolean jj_2_11(int xla) {
    6158     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6159     try { return !jj_3_11(); }
    6160     catch(LookaheadSuccess ls) { return true; }
    6161     finally { jj_save(10, xla); }
    6162   }
    6163
    6164   private boolean jj_2_12(int xla) {
    6165     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6166     try { return !jj_3_12(); }
    6167     catch(LookaheadSuccess ls) { return true; }
    6168     finally { jj_save(11, xla); }
    6169   }
    6170
    6171   private boolean jj_2_13(int xla) {
    6172     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6173     try { return !jj_3_13(); }
    6174     catch(LookaheadSuccess ls) { return true; }
    6175     finally { jj_save(12, xla); }
    6176   }
    6177
    6178   private boolean jj_2_14(int xla) {
    6179     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6180     try { return !jj_3_14(); }
    6181     catch(LookaheadSuccess ls) { return true; }
    6182     finally { jj_save(13, xla); }
    6183   }
    6184
    6185   private boolean jj_2_15(int xla) {
    6186     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6187     try { return !jj_3_15(); }
    6188     catch(LookaheadSuccess ls) { return true; }
    6189     finally { jj_save(14, xla); }
    6190   }
    6191
    6192   private boolean jj_2_16(int xla) {
    6193     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6194     try { return !jj_3_16(); }
    6195     catch(LookaheadSuccess ls) { return true; }
    6196     finally { jj_save(15, xla); }
    6197   }
    6198
    6199   private boolean jj_2_17(int xla) {
    6200     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6201     try { return !jj_3_17(); }
    6202     catch(LookaheadSuccess ls) { return true; }
    6203     finally { jj_save(16, xla); }
    6204   }
    6205
    6206   private boolean jj_2_18(int xla) {
    6207     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6208     try { return !jj_3_18(); }
    6209     catch(LookaheadSuccess ls) { return true; }
    6210     finally { jj_save(17, xla); }
    6211   }
    6212
    6213   private boolean jj_2_19(int xla) {
    6214     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6215     try { return !jj_3_19(); }
    6216     catch(LookaheadSuccess ls) { return true; }
    6217     finally { jj_save(18, xla); }
    6218   }
    6219
    6220   private boolean jj_2_20(int xla) {
    6221     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6222     try { return !jj_3_20(); }
    6223     catch(LookaheadSuccess ls) { return true; }
    6224     finally { jj_save(19, xla); }
    6225   }
    6226
    6227   private boolean jj_2_21(int xla) {
    6228     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6229     try { return !jj_3_21(); }
    6230     catch(LookaheadSuccess ls) { return true; }
    6231     finally { jj_save(20, xla); }
    6232   }
    6233
    6234   private boolean jj_2_22(int xla) {
    6235     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6236     try { return !jj_3_22(); }
    6237     catch(LookaheadSuccess ls) { return true; }
    6238     finally { jj_save(21, xla); }
    6239   }
    6240
    6241   private boolean jj_2_23(int xla) {
    6242     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6243     try { return !jj_3_23(); }
    6244     catch(LookaheadSuccess ls) { return true; }
    6245     finally { jj_save(22, xla); }
    6246   }
    6247
    6248   private boolean jj_2_24(int xla) {
    6249     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6250     try { return !jj_3_24(); }
    6251     catch(LookaheadSuccess ls) { return true; }
    6252     finally { jj_save(23, xla); }
    6253   }
    6254
    6255   private boolean jj_2_25(int xla) {
    6256     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6257     try { return !jj_3_25(); }
    6258     catch(LookaheadSuccess ls) { return true; }
    6259     finally { jj_save(24, xla); }
    6260   }
    6261
    6262   private boolean jj_2_26(int xla) {
    6263     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6264     try { return !jj_3_26(); }
    6265     catch(LookaheadSuccess ls) { return true; }
    6266     finally { jj_save(25, xla); }
    6267   }
    6268
    6269   private boolean jj_2_27(int xla) {
    6270     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6271     try { return !jj_3_27(); }
    6272     catch(LookaheadSuccess ls) { return true; }
    6273     finally { jj_save(26, xla); }
    6274   }
    6275
    6276   private boolean jj_2_28(int xla) {
    6277     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6278     try { return !jj_3_28(); }
    6279     catch(LookaheadSuccess ls) { return true; }
    6280     finally { jj_save(27, xla); }
    6281   }
    6282
    6283   private boolean jj_2_29(int xla) {
    6284     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6285     try { return !jj_3_29(); }
    6286     catch(LookaheadSuccess ls) { return true; }
    6287     finally { jj_save(28, xla); }
    6288   }
    6289
    6290   private boolean jj_2_30(int xla) {
    6291     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6292     try { return !jj_3_30(); }
    6293     catch(LookaheadSuccess ls) { return true; }
    6294     finally { jj_save(29, xla); }
    6295   }
    6296
    6297   private boolean jj_2_31(int xla) {
    6298     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6299     try { return !jj_3_31(); }
    6300     catch(LookaheadSuccess ls) { return true; }
    6301     finally { jj_save(30, xla); }
    6302   }
    6303
    6304   private boolean jj_2_32(int xla) {
    6305     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6306     try { return !jj_3_32(); }
    6307     catch(LookaheadSuccess ls) { return true; }
    6308     finally { jj_save(31, xla); }
    6309   }
    6310
    6311   private boolean jj_2_33(int xla) {
    6312     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6313     try { return !jj_3_33(); }
    6314     catch(LookaheadSuccess ls) { return true; }
    6315     finally { jj_save(32, xla); }
    6316   }
    6317
    6318   private boolean jj_2_34(int xla) {
    6319     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6320     try { return !jj_3_34(); }
    6321     catch(LookaheadSuccess ls) { return true; }
    6322     finally { jj_save(33, xla); }
    6323   }
    6324
    6325   private boolean jj_2_35(int xla) {
    6326     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6327     try { return !jj_3_35(); }
    6328     catch(LookaheadSuccess ls) { return true; }
    6329     finally { jj_save(34, xla); }
    6330   }
    6331
    6332   private boolean jj_2_36(int xla) {
    6333     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6334     try { return !jj_3_36(); }
    6335     catch(LookaheadSuccess ls) { return true; }
    6336     finally { jj_save(35, xla); }
    6337   }
    6338
    6339   private boolean jj_2_37(int xla) {
    6340     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6341     try { return !jj_3_37(); }
    6342     catch(LookaheadSuccess ls) { return true; }
    6343     finally { jj_save(36, xla); }
    6344   }
    6345
    6346   private boolean jj_2_38(int xla) {
    6347     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6348     try { return !jj_3_38(); }
    6349     catch(LookaheadSuccess ls) { return true; }
    6350     finally { jj_save(37, xla); }
    6351   }
    6352
    6353   private boolean jj_2_39(int xla) {
    6354     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6355     try { return !jj_3_39(); }
    6356     catch(LookaheadSuccess ls) { return true; }
    6357     finally { jj_save(38, xla); }
    6358   }
    6359
    6360   private boolean jj_2_40(int xla) {
    6361     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6362     try { return !jj_3_40(); }
    6363     catch(LookaheadSuccess ls) { return true; }
    6364     finally { jj_save(39, xla); }
    6365   }
    6366
    6367   private boolean jj_2_41(int xla) {
    6368     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6369     try { return !jj_3_41(); }
    6370     catch(LookaheadSuccess ls) { return true; }
    6371     finally { jj_save(40, xla); }
    6372   }
    6373
    6374   private boolean jj_2_42(int xla) {
    6375     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6376     try { return !jj_3_42(); }
    6377     catch(LookaheadSuccess ls) { return true; }
    6378     finally { jj_save(41, xla); }
    6379   }
    6380
    6381   private boolean jj_2_43(int xla) {
    6382     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6383     try { return !jj_3_43(); }
    6384     catch(LookaheadSuccess ls) { return true; }
    6385     finally { jj_save(42, xla); }
    6386   }
    6387
    6388   private boolean jj_2_44(int xla) {
    6389     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6390     try { return !jj_3_44(); }
    6391     catch(LookaheadSuccess ls) { return true; }
    6392     finally { jj_save(43, xla); }
    6393   }
    6394
    6395   private boolean jj_2_45(int xla) {
    6396     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6397     try { return !jj_3_45(); }
    6398     catch(LookaheadSuccess ls) { return true; }
    6399     finally { jj_save(44, xla); }
    6400   }
    6401
    6402   private boolean jj_2_46(int xla) {
    6403     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6404     try { return !jj_3_46(); }
    6405     catch(LookaheadSuccess ls) { return true; }
    6406     finally { jj_save(45, xla); }
    6407   }
    6408
    6409   private boolean jj_2_47(int xla) {
    6410     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6411     try { return !jj_3_47(); }
    6412     catch(LookaheadSuccess ls) { return true; }
    6413     finally { jj_save(46, xla); }
    6414   }
    6415
    6416   private boolean jj_2_48(int xla) {
    6417     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6418     try { return !jj_3_48(); }
    6419     catch(LookaheadSuccess ls) { return true; }
    6420     finally { jj_save(47, xla); }
    6421   }
    6422
    6423   private boolean jj_2_49(int xla) {
    6424     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6425     try { return !jj_3_49(); }
    6426     catch(LookaheadSuccess ls) { return true; }
    6427     finally { jj_save(48, xla); }
    6428   }
    6429
    6430   private boolean jj_2_50(int xla) {
    6431     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6432     try { return !jj_3_50(); }
    6433     catch(LookaheadSuccess ls) { return true; }
    6434     finally { jj_save(49, xla); }
    6435   }
    6436
    6437   private boolean jj_2_51(int xla) {
    6438     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6439     try { return !jj_3_51(); }
    6440     catch(LookaheadSuccess ls) { return true; }
    6441     finally { jj_save(50, xla); }
    6442   }
    6443
    6444   private boolean jj_2_52(int xla) {
    6445     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6446     try { return !jj_3_52(); }
    6447     catch(LookaheadSuccess ls) { return true; }
    6448     finally { jj_save(51, xla); }
    6449   }
    6450
    6451   private boolean jj_2_53(int xla) {
    6452     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6453     try { return !jj_3_53(); }
    6454     catch(LookaheadSuccess ls) { return true; }
    6455     finally { jj_save(52, xla); }
    6456   }
    6457
    6458   private boolean jj_2_54(int xla) {
    6459     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6460     try { return !jj_3_54(); }
    6461     catch(LookaheadSuccess ls) { return true; }
    6462     finally { jj_save(53, xla); }
    6463   }
    6464
    6465   private boolean jj_3R_341() {
    6466     if (jj_scan_token(COMMA)) return true;
    6467     if (jj_3R_100()) return true;
    6468     return false;
    6469   }
    6470
    6471   private boolean jj_3R_327() {
    6472     if (jj_3R_100()) return true;
    6473     Token xsp;
    6474     while (true) {
    6475       xsp = jj_scanpos;
    6476       if (jj_3R_341()) { jj_scanpos = xsp; break; }
    6477     }
    6478     return false;
    6479   }
    6480
    6481   private boolean jj_3_20() {
    6482     if (jj_3R_80()) return true;
    6483     return false;
    6484   }
    6485
    6486   private boolean jj_3_22() {
    6487     if (jj_scan_token(DOT)) return true;
    6488     if (jj_scan_token(IDENTIFIER)) return true;
    6489     return false;
    6490   }
    6491
    6492   private boolean jj_3R_192() {
    6493     if (jj_scan_token(COMMA)) return true;
    6494     if (jj_3R_82()) return true;
    6495     return false;
    6496   }
    6497
    6498   private boolean jj_3R_100() {
    6499     if (jj_scan_token(IDENTIFIER)) return true;
    6500     Token xsp;
    6501     while (true) {
    6502       xsp = jj_scanpos;
    6503       if (jj_3_22()) { jj_scanpos = xsp; break; }
    6504     }
    6505     return false;
    6506   }
    6507
    6508   private boolean jj_3R_145() {
    6509     if (jj_3R_73()) return true;
    6510     return false;
    6511   }
    6512
    6513   private boolean jj_3R_89() {
    6514     Token xsp;
    6515     xsp = jj_scanpos;
    6516     if (jj_scan_token(59)) {
    6517     jj_scanpos = xsp;
    6518     if (jj_3R_145()) return true;
    6519     }
    6520     return false;
    6521   }
    6522
    6523   private boolean jj_3R_141() {
    6524     if (jj_scan_token(DOUBLE)) return true;
    6525     return false;
    6526   }
    6527
    6528   private boolean jj_3R_140() {
    6529     if (jj_scan_token(FLOAT)) return true;
    6530     return false;
    6531   }
    6532
    6533   private boolean jj_3R_139() {
    6534     if (jj_scan_token(LONG)) return true;
    6535     return false;
    6536   }
    6537
    6538   private boolean jj_3R_138() {
    6539     if (jj_scan_token(INT)) return true;
    6540     return false;
    6541   }
    6542
    6543   private boolean jj_3R_137() {
    6544     if (jj_scan_token(SHORT)) return true;
    6545     return false;
    6546   }
    6547
    6548   private boolean jj_3R_136() {
    6549     if (jj_scan_token(BYTE)) return true;
    6550     return false;
    6551   }
    6552
    6553   private boolean jj_3R_135() {
    6554     if (jj_scan_token(CHAR)) return true;
    6555     return false;
    6556   }
    6557
    6558   private boolean jj_3R_134() {
    6559     if (jj_scan_token(BOOLEAN)) return true;
    6560     return false;
    6561   }
    6562
    6563   private boolean jj_3R_87() {
    6564     Token xsp;
    6565     xsp = jj_scanpos;
    6566     if (jj_3R_134()) {
    6567     jj_scanpos = xsp;
    6568     if (jj_3R_135()) {
    6569     jj_scanpos = xsp;
    6570     if (jj_3R_136()) {
    6571     jj_scanpos = xsp;
    6572     if (jj_3R_137()) {
    6573     jj_scanpos = xsp;
    6574     if (jj_3R_138()) {
    6575     jj_scanpos = xsp;
    6576     if (jj_3R_139()) {
    6577     jj_scanpos = xsp;
    6578     if (jj_3R_140()) {
    6579     jj_scanpos = xsp;
    6580     if (jj_3R_141()) return true;
    6581     }
    6582     }
    6583     }
    6584     }
    6585     }
    6586     }
    6587     }
    6588     return false;
    6589   }
    6590
    6591   private boolean jj_3R_181() {
    6592     if (jj_3R_80()) return true;
    6593     return false;
    6594   }
    6595
    6596   private boolean jj_3R_274() {
    6597     if (jj_scan_token(SUPER)) return true;
    6598     if (jj_3R_81()) return true;
    6599     return false;
    6600   }
    6601
    6602   private boolean jj_3R_238() {
    6603     if (jj_3R_253()) return true;
    6604     return false;
    6605   }
    6606
    6607   private boolean jj_3R_253() {
    6608     Token xsp;
    6609     xsp = jj_scanpos;
    6610     if (jj_3R_273()) {
    6611     jj_scanpos = xsp;
    6612     if (jj_3R_274()) return true;
    6613     }
    6614     return false;
    6615   }
    6616
    6617   private boolean jj_3R_273() {
    6618     if (jj_scan_token(EXTENDS)) return true;
    6619     if (jj_3R_81()) return true;
    6620     return false;
    6621   }
    6622
    6623   private boolean jj_3R_129() {
    6624     if (jj_scan_token(HOOK)) return true;
    6625     Token xsp;
    6626     xsp = jj_scanpos;
    6627     if (jj_3R_238()) jj_scanpos = xsp;
    6628     return false;
    6629   }
    6630
    6631   private boolean jj_3_17() {
    6632     if (jj_scan_token(LBRACKET)) return true;
    6633     if (jj_scan_token(RBRACKET)) return true;
    6634     return false;
    6635   }
    6636
    6637   private boolean jj_3R_128() {
    6638     if (jj_3R_81()) return true;
    6639     return false;
    6640   }
    6641
    6642   private boolean jj_3R_82() {
    6643     Token xsp;
    6644     xsp = jj_scanpos;
    6645     if (jj_3R_128()) {
    6646     jj_scanpos = xsp;
    6647     if (jj_3R_129()) return true;
    6648     }
    6649     return false;
    6650   }
    6651
    6652   private boolean jj_3R_125() {
    6653     if (jj_scan_token(LT)) return true;
    6654     if (jj_scan_token(GT)) return true;
    6655     return false;
    6656   }
    6657
    6658   private boolean jj_3R_80() {
    6659     Token xsp;
    6660     xsp = jj_scanpos;
    6661     if (jj_3_21()) {
    6662     jj_scanpos = xsp;
    6663     if (jj_3R_125()) return true;
    6664     }
    6665     return false;
    6666   }
    6667
    6668   private boolean jj_3_21() {
    6669     if (jj_scan_token(LT)) return true;
    6670     if (jj_3R_82()) return true;
    6671     Token xsp;
    6672     while (true) {
    6673       xsp = jj_scanpos;
    6674       if (jj_3R_192()) { jj_scanpos = xsp; break; }
    6675     }
    6676     if (jj_scan_token(GT)) return true;
    6677     return false;
    6678   }
    6679
    6680   private boolean jj_3_16() {
    6681     if (jj_scan_token(LBRACKET)) return true;
    6682     if (jj_scan_token(RBRACKET)) return true;
    6683     return false;
    6684   }
    6685
    6686   private boolean jj_3R_382() {
    6687     if (jj_3R_391()) return true;
    6688     return false;
    6689   }
    6690
    6691   private boolean jj_3_19() {
    6692     if (jj_scan_token(DOT)) return true;
    6693     if (jj_scan_token(IDENTIFIER)) return true;
    6694     Token xsp;
    6695     xsp = jj_scanpos;
    6696     if (jj_3_20()) jj_scanpos = xsp;
    6697     return false;
    6698   }
    6699
    6700   private boolean jj_3_18() {
    6701     if (jj_3R_80()) return true;
    6702     return false;
    6703   }
    6704
    6705   private boolean jj_3R_193() {
    6706     if (jj_scan_token(IDENTIFIER)) return true;
    6707     Token xsp;
    6708     xsp = jj_scanpos;
    6709     if (jj_3_18()) jj_scanpos = xsp;
    6710     while (true) {
    6711       xsp = jj_scanpos;
    6712       if (jj_3_19()) { jj_scanpos = xsp; break; }
    6713     }
    6714     return false;
    6715   }
    6716
    6717   private boolean jj_3R_127() {
    6718     if (jj_3R_193()) return true;
    6719     Token xsp;
    6720     while (true) {
    6721       xsp = jj_scanpos;
    6722       if (jj_3_17()) { jj_scanpos = xsp; break; }
    6723     }
    6724     return false;
    6725   }
    6726
    6727   private boolean jj_3R_126() {
    6728     if (jj_3R_87()) return true;
    6729     Token xsp;
    6730     if (jj_3_16()) return true;
    6731     while (true) {
    6732       xsp = jj_scanpos;
    6733       if (jj_3_16()) { jj_scanpos = xsp; break; }
    6734     }
    6735     return false;
    6736   }
    6737
    6738   private boolean jj_3R_81() {
    6739     Token xsp;
    6740     xsp = jj_scanpos;
    6741     if (jj_3R_126()) {
    6742     jj_scanpos = xsp;
    6743     if (jj_3R_127()) return true;
    6744     }
    6745     return false;
    6746   }
    6747
    6748   private boolean jj_3R_311() {
    6749     if (jj_scan_token(THROWS)) return true;
    6750     if (jj_3R_327()) return true;
    6751     return false;
    6752   }
    6753
    6754   private boolean jj_3R_114() {
    6755     if (jj_3R_87()) return true;
    6756     return false;
    6757   }
    6758
    6759   private boolean jj_3R_73() {
    6760     Token xsp;
    6761     xsp = jj_scanpos;
    6762     if (jj_3_15()) {
    6763     jj_scanpos = xsp;
    6764     if (jj_3R_114()) return true;
    6765     }
    6766     return false;
    6767   }
    6768
    6769   private boolean jj_3_15() {
    6770     if (jj_3R_81()) return true;
    6771     return false;
    6772   }
    6773
    6774   private boolean jj_3R_391() {
    6775     if (jj_scan_token(_DEFAULT)) return true;
    6776     if (jj_3R_102()) return true;
    6777     return false;
    6778   }
    6779
    6780   private boolean jj_3R_363() {
    6781     if (jj_3R_104()) return true;
    6782     return false;
    6783   }
    6784
    6785   private boolean jj_3_12() {
    6786     if (jj_3R_78()) return true;
    6787     if (jj_scan_token(DOT)) return true;
    6788     return false;
    6789   }
    6790
    6791   private boolean jj_3R_302() {
    6792     if (jj_scan_token(STATIC)) return true;
    6793     return false;
    6794   }
    6795
    6796   private boolean jj_3_14() {
    6797     if (jj_3R_80()) return true;
    6798     if (jj_scan_token(THIS)) return true;
    6799     if (jj_3R_79()) return true;
    6800     if (jj_scan_token(SEMICOLON)) return true;
    6801     return false;
    6802   }
    6803
    6804   private boolean jj_3R_292() {
    6805     Token xsp;
    6806     xsp = jj_scanpos;
    6807     if (jj_3R_302()) jj_scanpos = xsp;
    6808     if (jj_3R_196()) return true;
    6809     return false;
    6810   }
    6811
    6812   private boolean jj_3_13() {
    6813     if (jj_scan_token(THIS)) return true;
    6814     if (jj_3R_79()) return true;
    6815     if (jj_scan_token(SEMICOLON)) return true;
    6816     return false;
    6817   }
    6818
    6819   private boolean jj_3R_103() {
    6820     if (jj_3R_73()) return true;
    6821     if (jj_scan_token(IDENTIFIER)) return true;
    6822     if (jj_scan_token(LPAREN)) return true;
    6823     if (jj_scan_token(RPAREN)) return true;
    6824     Token xsp;
    6825     xsp = jj_scanpos;
    6826     if (jj_3R_382()) jj_scanpos = xsp;
    6827     if (jj_scan_token(SEMICOLON)) return true;
    6828     return false;
    6829   }
    6830
    6831   private boolean jj_3_10() {
    6832     if (jj_3R_76()) return true;
    6833     return false;
    6834   }
    6835
    6836   private boolean jj_3R_180() {
    6837     if (jj_3R_78()) return true;
    6838     if (jj_scan_token(DOT)) return true;
    6839     return false;
    6840   }
    6841
    6842   private boolean jj_3R_119() {
    6843     Token xsp;
    6844     xsp = jj_scanpos;
    6845     if (jj_3R_180()) jj_scanpos = xsp;
    6846     xsp = jj_scanpos;
    6847     if (jj_3R_181()) jj_scanpos = xsp;
    6848     if (jj_scan_token(SUPER)) return true;
    6849     if (jj_3R_79()) return true;
    6850     if (jj_scan_token(SEMICOLON)) return true;
    6851     return false;
    6852   }
    6853
    6854   private boolean jj_3R_118() {
    6855     if (jj_3R_80()) return true;
    6856     if (jj_scan_token(THIS)) return true;
    6857     if (jj_3R_79()) return true;
    6858     if (jj_scan_token(SEMICOLON)) return true;
    6859     return false;
    6860   }
    6861
    6862   private boolean jj_3R_117() {
    6863     if (jj_scan_token(THIS)) return true;
    6864     if (jj_3R_79()) return true;
    6865     if (jj_scan_token(SEMICOLON)) return true;
    6866     return false;
    6867   }
    6868
    6869   private boolean jj_3R_76() {
    6870     Token xsp;
    6871     xsp = jj_scanpos;
    6872     if (jj_3R_117()) {
    6873     jj_scanpos = xsp;
    6874     if (jj_3R_118()) {
    6875     jj_scanpos = xsp;
    6876     if (jj_3R_119()) return true;
    6877     }
    6878     }
    6879     return false;
    6880   }
    6881
    6882   private boolean jj_3R_366() {
    6883     if (jj_3R_304()) return true;
    6884     return false;
    6885   }
    6886
    6887   private boolean jj_3R_340() {
    6888     if (jj_scan_token(COMMA)) return true;
    6889     if (jj_3R_339()) return true;
    6890     return false;
    6891   }
    6892
    6893   private boolean jj_3R_365() {
    6894     if (jj_3R_306()) return true;
    6895     return false;
    6896   }
    6897
    6898   private boolean jj_3_11() {
    6899     if (jj_3R_77()) return true;
    6900     return false;
    6901   }
    6902
    6903   private boolean jj_3R_312() {
    6904     if (jj_3R_76()) return true;
    6905     return false;
    6906   }
    6907
    6908   private boolean jj_3_54() {
    6909     if (jj_3R_71()) return true;
    6910     return false;
    6911   }
    6912
    6913   private boolean jj_3R_364() {
    6914     if (jj_3R_70()) return true;
    6915     return false;
    6916   }
    6917
    6918   private boolean jj_3R_309() {
    6919     if (jj_3R_113()) return true;
    6920     return false;
    6921   }
    6922
    6923   private boolean jj_3R_303() {
    6924     Token xsp;
    6925     xsp = jj_scanpos;
    6926     if (jj_3R_309()) jj_scanpos = xsp;
    6927     if (jj_scan_token(IDENTIFIER)) return true;
    6928     if (jj_3R_310()) return true;
    6929     xsp = jj_scanpos;
    6930     if (jj_3R_311()) jj_scanpos = xsp;
    6931     if (jj_scan_token(LBRACE)) return true;
    6932     xsp = jj_scanpos;
    6933     if (jj_3R_312()) jj_scanpos = xsp;
    6934     while (true) {
    6935       xsp = jj_scanpos;
    6936       if (jj_3_11()) { jj_scanpos = xsp; break; }
    6937     }
    6938     if (jj_scan_token(RBRACE)) return true;
    6939     return false;
    6940   }
    6941
    6942   private boolean jj_3_53() {
    6943     if (jj_3R_103()) return true;
    6944     return false;
    6945   }
    6946
    6947   private boolean jj_3R_352() {
    6948     if (jj_scan_token(BIT_OR)) return true;
    6949     if (jj_3R_73()) return true;
    6950     return false;
    6951   }
    6952
    6953   private boolean jj_3R_354() {
    6954     if (jj_3R_293()) return true;
    6955     Token xsp;
    6956     xsp = jj_scanpos;
    6957     if (jj_3_53()) {
    6958     jj_scanpos = xsp;
    6959     if (jj_3R_364()) {
    6960     jj_scanpos = xsp;
    6961     if (jj_3_54()) {
    6962     jj_scanpos = xsp;
    6963     if (jj_3R_365()) {
    6964     jj_scanpos = xsp;
    6965     if (jj_3R_366()) return true;
    6966     }
    6967     }
    6968     }
    6969     }
    6970     return false;
    6971   }
    6972
    6973   private boolean jj_3R_342() {
    6974     Token xsp;
    6975     xsp = jj_scanpos;
    6976     if (jj_3R_354()) {
    6977     jj_scanpos = xsp;
    6978     if (jj_scan_token(82)) return true;
    6979     }
    6980     return false;
    6981   }
    6982
    6983   private boolean jj_3R_329() {
    6984     if (jj_3R_342()) return true;
    6985     return false;
    6986   }
    6987
    6988   private boolean jj_3R_328() {
    6989     if (jj_scan_token(LBRACKET)) return true;
    6990     if (jj_scan_token(RBRACKET)) return true;
    6991     return false;
    6992   }
    6993
    6994   private boolean jj_3R_316() {
    6995     if (jj_scan_token(THROWS)) return true;
    6996     if (jj_3R_327()) return true;
    6997     return false;
    6998   }
    6999
    7000   private boolean jj_3R_353() {
    7001     if (jj_scan_token(ELLIPSIS)) return true;
    7002     return false;
    7003   }
    7004
    7005   private boolean jj_3_52() {
    7006     if (jj_scan_token(COMMA)) return true;
    7007     if (jj_3R_102()) return true;
    7008     return false;
    7009   }
    7010
    7011   private boolean jj_3R_362() {
    7012     if (jj_scan_token(FINAL)) return true;
    7013     return false;
    7014   }
    7015
    7016   private boolean jj_3R_351() {
    7017     Token xsp;
    7018     xsp = jj_scanpos;
    7019     if (jj_3R_362()) {
    7020     jj_scanpos = xsp;
    7021     if (jj_3R_363()) return true;
    7022     }
    7023     return false;
    7024   }
    7025
    7026   private boolean jj_3R_339() {
    7027     Token xsp;
    7028     while (true) {
    7029       xsp = jj_scanpos;
    7030       if (jj_3R_351()) { jj_scanpos = xsp; break; }
    7031     }
    7032     if (jj_3R_73()) return true;
    7033     while (true) {
    7034       xsp = jj_scanpos;
    7035       if (jj_3R_352()) { jj_scanpos = xsp; break; }
    7036     }
    7037     xsp = jj_scanpos;
    7038     if (jj_3R_353()) jj_scanpos = xsp;
    7039     if (jj_3R_212()) return true;
    7040     return false;
    7041   }
    7042
    7043   private boolean jj_3R_318() {
    7044     if (jj_scan_token(LBRACE)) return true;
    7045     Token xsp;
    7046     while (true) {
    7047       xsp = jj_scanpos;
    7048       if (jj_3R_329()) { jj_scanpos = xsp; break; }
    7049     }
    7050     if (jj_scan_token(RBRACE)) return true;
    7051     return false;
    7052   }
    7053
    7054   private boolean jj_3R_326() {
    7055     if (jj_3R_339()) return true;
    7056     Token xsp;
    7057     while (true) {
    7058       xsp = jj_scanpos;
    7059       if (jj_3R_340()) { jj_scanpos = xsp; break; }
    7060     }
    7061     return false;
    7062   }
    7063
    7064   private boolean jj_3_9() {
    7065     if (jj_scan_token(COMMA)) return true;
    7066     if (jj_3R_75()) return true;
    7067     return false;
    7068   }
    7069
    7070   private boolean jj_3R_306() {
    7071     if (jj_scan_token(AT)) return true;
    7072     if (jj_scan_token(INTERFACE)) return true;
    7073     if (jj_scan_token(IDENTIFIER)) return true;
    7074     if (jj_3R_318()) return true;
    7075     return false;
    7076   }
    7077
    7078   private boolean jj_3R_310() {
    7079     if (jj_scan_token(LPAREN)) return true;
    7080     Token xsp;
    7081     xsp = jj_scanpos;
    7082     if (jj_3R_326()) jj_scanpos = xsp;
    7083     if (jj_scan_token(RPAREN)) return true;
    7084     return false;
    7085   }
    7086
    7087   private boolean jj_3R_277() {
    7088     if (jj_3R_102()) return true;
    7089     Token xsp;
    7090     while (true) {
    7091       xsp = jj_scanpos;
    7092       if (jj_3_52()) { jj_scanpos = xsp; break; }
    7093     }
    7094     xsp = jj_scanpos;
    7095     if (jj_scan_token(83)) jj_scanpos = xsp;
    7096     return false;
    7097   }
    7098
    7099   private boolean jj_3R_215() {
    7100     if (jj_scan_token(LBRACE)) return true;
    7101     Token xsp;
    7102     xsp = jj_scanpos;
    7103     if (jj_3R_277()) jj_scanpos = xsp;
    7104     if (jj_scan_token(RBRACE)) return true;
    7105     return false;
    7106   }
    7107
    7108   private boolean jj_3R_256() {
    7109     if (jj_scan_token(COMMA)) return true;
    7110     if (jj_3R_255()) return true;
    7111     return false;
    7112   }
    7113
    7114   private boolean jj_3R_315() {
    7115     if (jj_scan_token(IDENTIFIER)) return true;
    7116     if (jj_3R_310()) return true;
    7117     Token xsp;
    7118     while (true) {
    7119       xsp = jj_scanpos;
    7120       if (jj_3R_328()) { jj_scanpos = xsp; break; }
    7121     }
    7122     return false;
    7123   }
    7124
    7125   private boolean jj_3R_170() {
    7126     if (jj_3R_147()) return true;
    7127     return false;
    7128   }
    7129
    7130   private boolean jj_3R_317() {
    7131     if (jj_3R_196()) return true;
    7132     return false;
    7133   }
    7134
    7135   private boolean jj_3R_169() {
    7136     if (jj_3R_215()) return true;
    7137     return false;
    7138   }
    7139
    7140   private boolean jj_3R_314() {
    7141     if (jj_3R_113()) return true;
    7142     return false;
    7143   }
    7144
    7145   private boolean jj_3R_102() {
    7146     Token xsp;
    7147     xsp = jj_scanpos;
    7148     if (jj_3R_168()) {
    7149     jj_scanpos = xsp;
    7150     if (jj_3R_169()) {
    7151     jj_scanpos = xsp;
    7152     if (jj_3R_170()) return true;
    7153     }
    7154     }
    7155     return false;
    7156   }
    7157
    7158   private boolean jj_3R_168() {
    7159     if (jj_3R_104()) return true;
    7160     return false;
    7161   }
    7162
    7163   private boolean jj_3R_305() {
    7164     Token xsp;
    7165     xsp = jj_scanpos;
    7166     if (jj_3R_314()) jj_scanpos = xsp;
    7167     if (jj_3R_89()) return true;
    7168     if (jj_3R_315()) return true;
    7169     xsp = jj_scanpos;
    7170     if (jj_3R_316()) jj_scanpos = xsp;
    7171     xsp = jj_scanpos;
    7172     if (jj_3R_317()) {
    7173     jj_scanpos = xsp;
    7174     if (jj_scan_token(82)) return true;
    7175     }
    7176     return false;
    7177   }
    7178
    7179   private boolean jj_3R_276() {
    7180     if (jj_3R_75()) return true;
    7181     Token xsp;
    7182     while (true) {
    7183       xsp = jj_scanpos;
    7184       if (jj_3_9()) { jj_scanpos = xsp; break; }
    7185     }
    7186     return false;
    7187   }
    7188
    7189   private boolean jj_3R_255() {
    7190     if (jj_scan_token(IDENTIFIER)) return true;
    7191     if (jj_scan_token(ASSIGN)) return true;
    7192     if (jj_3R_102()) return true;
    7193     return false;
    7194   }
    7195
    7196   private boolean jj_3R_179() {
    7197     if (jj_scan_token(LBRACE)) return true;
    7198     Token xsp;
    7199     xsp = jj_scanpos;
    7200     if (jj_3R_276()) jj_scanpos = xsp;
    7201     xsp = jj_scanpos;
    7202     if (jj_scan_token(83)) jj_scanpos = xsp;
    7203     if (jj_scan_token(RBRACE)) return true;
    7204     return false;
    7205   }
    7206
    7207   private boolean jj_3R_213() {
    7208     if (jj_scan_token(ASSIGN)) return true;
    7209     if (jj_3R_75()) return true;
    7210     return false;
    7211   }
    7212
    7213   private boolean jj_3R_313() {
    7214     if (jj_scan_token(COMMA)) return true;
    7215     if (jj_3R_165()) return true;
    7216     return false;
    7217   }
    7218
    7219   private boolean jj_3R_243() {
    7220     if (jj_3R_255()) return true;
    7221     Token xsp;
    7222     while (true) {
    7223       xsp = jj_scanpos;
    7224       if (jj_3R_256()) { jj_scanpos = xsp; break; }
    7225     }
    7226     return false;
    7227   }
    7228
    7229   private boolean jj_3R_74() {
    7230     if (jj_scan_token(LBRACKET)) return true;
    7231     if (jj_scan_token(RBRACKET)) return true;
    7232     return false;
    7233   }
    7234
    7235   private boolean jj_3R_228() {
    7236     if (jj_3R_243()) return true;
    7237     return false;
    7238   }
    7239
    7240   private boolean jj_3R_116() {
    7241     if (jj_3R_92()) return true;
    7242     return false;
    7243   }
    7244
    7245   private boolean jj_3R_101() {
    7246     if (jj_scan_token(IDENTIFIER)) return true;
    7247     if (jj_scan_token(ASSIGN)) return true;
    7248     return false;
    7249   }
    7250
    7251   private boolean jj_3R_115() {
    7252     if (jj_3R_179()) return true;
    7253     return false;
    7254   }
    7255
    7256   private boolean jj_3R_75() {
    7257     Token xsp;
    7258     xsp = jj_scanpos;
    7259     if (jj_3R_115()) {
    7260     jj_scanpos = xsp;
    7261     if (jj_3R_116()) return true;
    7262     }
    7263     return false;
    7264   }
    7265
    7266   private boolean jj_3R_217() {
    7267     if (jj_scan_token(AT)) return true;
    7268     if (jj_3R_100()) return true;
    7269     if (jj_scan_token(LPAREN)) return true;
    7270     if (jj_3R_102()) return true;
    7271     if (jj_scan_token(RPAREN)) return true;
    7272     return false;
    7273   }
    7274
    7275   private boolean jj_3R_350() {
    7276     if (jj_3R_110()) return true;
    7277     return false;
    7278   }
    7279
    7280   private boolean jj_3R_227() {
    7281     if (jj_scan_token(LBRACKET)) return true;
    7282     if (jj_scan_token(RBRACKET)) return true;
    7283     return false;
    7284   }
    7285
    7286   private boolean jj_3R_218() {
    7287     if (jj_scan_token(AT)) return true;
    7288     if (jj_3R_100()) return true;
    7289     return false;
    7290   }
    7291
    7292   private boolean jj_3R_178() {
    7293     if (jj_scan_token(COMMA)) return true;
    7294     if (jj_3R_177()) return true;
    7295     return false;
    7296   }
    7297
    7298   private boolean jj_3R_212() {
    7299     if (jj_scan_token(IDENTIFIER)) return true;
    7300     Token xsp;
    7301     while (true) {
    7302       xsp = jj_scanpos;
    7303       if (jj_3R_227()) { jj_scanpos = xsp; break; }
    7304     }
    7305     return false;
    7306   }
    7307
    7308   private boolean jj_3R_219() {
    7309     if (jj_3R_229()) return true;
    7310     return false;
    7311   }
    7312
    7313   private boolean jj_3_51() {
    7314     if (jj_scan_token(AT)) return true;
    7315     if (jj_3R_100()) return true;
    7316     if (jj_scan_token(LPAREN)) return true;
    7317     return false;
    7318   }
    7319
    7320   private boolean jj_3R_216() {
    7321     if (jj_scan_token(AT)) return true;
    7322     if (jj_3R_100()) return true;
    7323     if (jj_scan_token(LPAREN)) return true;
    7324     Token xsp;
    7325     xsp = jj_scanpos;
    7326     if (jj_3R_228()) jj_scanpos = xsp;
    7327     if (jj_scan_token(RPAREN)) return true;
    7328     return false;
    7329   }
    7330
    7331   private boolean jj_3_50() {
    7332     if (jj_scan_token(AT)) return true;
    7333     if (jj_3R_100()) return true;
    7334     if (jj_scan_token(LPAREN)) return true;
    7335     Token xsp;
    7336     xsp = jj_scanpos;
    7337     if (jj_3R_101()) {
    7338     jj_scanpos = xsp;
    7339     if (jj_scan_token(77)) return true;
    7340     }
    7341     return false;
    7342   }
    7343
    7344   private boolean jj_3R_244() {
    7345     if (jj_scan_token(BIT_AND)) return true;
    7346     if (jj_3R_193()) return true;
    7347     return false;
    7348   }
    7349
    7350   private boolean jj_3R_165() {
    7351     if (jj_3R_212()) return true;
    7352     Token xsp;
    7353     xsp = jj_scanpos;
    7354     if (jj_3R_213()) jj_scanpos = xsp;
    7355     return false;
    7356   }
    7357
    7358   private boolean jj_3R_72() {
    7359     if (jj_3R_113()) return true;
    7360     return false;
    7361   }
    7362
    7363   private boolean jj_3_7() {
    7364     if (jj_3R_73()) return true;
    7365     if (jj_scan_token(IDENTIFIER)) return true;
    7366     Token xsp;
    7367     while (true) {
    7368       xsp = jj_scanpos;
    7369       if (jj_3R_74()) { jj_scanpos = xsp; break; }
    7370     }
    7371     xsp = jj_scanpos;
    7372     if (jj_scan_token(83)) {
    7373     jj_scanpos = xsp;
    7374     if (jj_scan_token(86)) {
    7375     jj_scanpos = xsp;
    7376     if (jj_scan_token(82)) return true;
    7377     }
    7378     }
    7379     return false;
    7380   }
    7381
    7382   private boolean jj_3_6() {
    7383     Token xsp;
    7384     xsp = jj_scanpos;
    7385     if (jj_3R_72()) jj_scanpos = xsp;
    7386     if (jj_scan_token(IDENTIFIER)) return true;
    7387     if (jj_scan_token(LPAREN)) return true;
    7388     return false;
    7389   }
    7390
    7391   private boolean jj_3R_173() {
    7392     if (jj_3R_218()) return true;
    7393     return false;
    7394   }
    7395
    7396   private boolean jj_3R_304() {
    7397     if (jj_3R_73()) return true;
    7398     if (jj_3R_165()) return true;
    7399     Token xsp;
    7400     while (true) {
    7401       xsp = jj_scanpos;
    7402       if (jj_3R_313()) { jj_scanpos = xsp; break; }
    7403     }
    7404     if (jj_scan_token(SEMICOLON)) return true;
    7405     return false;
    7406   }
    7407
    7408   private boolean jj_3R_68() {
    7409     if (jj_3R_104()) return true;
    7410     return false;
    7411   }
    7412
    7413   private boolean jj_3R_172() {
    7414     if (jj_3R_217()) return true;
    7415     return false;
    7416   }
    7417
    7418   private boolean jj_3R_349() {
    7419     if (jj_3R_79()) return true;
    7420     return false;
    7421   }
    7422
    7423   private boolean jj_3R_130() {
    7424     return false;
    7425   }
    7426
    7427   private boolean jj_3R_104() {
    7428     Token xsp;
    7429     xsp = jj_scanpos;
    7430     if (jj_3R_171()) {
    7431     jj_scanpos = xsp;
    7432     if (jj_3R_172()) {
    7433     jj_scanpos = xsp;
    7434     if (jj_3R_173()) return true;
    7435     }
    7436     }
    7437     return false;
    7438   }
    7439
    7440   private boolean jj_3R_171() {
    7441     if (jj_3R_216()) return true;
    7442     return false;
    7443   }
    7444
    7445   private boolean jj_3R_106() {
    7446     if (jj_scan_token(INTERFACE)) return true;
    7447     return false;
    7448   }
    7449
    7450   private boolean jj_3R_297() {
    7451     if (jj_3R_306()) return true;
    7452     return false;
    7453   }
    7454
    7455   private boolean jj_3R_361() {
    7456     if (jj_scan_token(COLON)) return true;
    7457     if (jj_3R_92()) return true;
    7458     return false;
    7459   }
    7460
    7461   private boolean jj_3R_296() {
    7462     if (jj_3R_305()) return true;
    7463     return false;
    7464   }
    7465
    7466   private boolean jj_3_8() {
    7467     Token xsp;
    7468     xsp = jj_scanpos;
    7469     if (jj_scan_token(49)) jj_scanpos = xsp;
    7470     if (jj_scan_token(LBRACE)) return true;
    7471     return false;
    7472   }
    7473
    7474   private boolean jj_3R_295() {
    7475     if (jj_3R_304()) return true;
    7476     return false;
    7477   }
    7478
    7479   private boolean jj_3R_294() {
    7480     if (jj_3R_303()) return true;
    7481     return false;
    7482   }
    7483
    7484   private boolean jj_3_5() {
    7485     if (jj_3R_71()) return true;
    7486     return false;
    7487   }
    7488
    7489   private boolean jj_3_4() {
    7490     if (jj_3R_70()) return true;
    7491     return false;
    7492   }
    7493
    7494   private boolean jj_3R_131() {
    7495     return false;
    7496   }
    7497
    7498   private boolean jj_3R_289() {
    7499     if (jj_3R_293()) return true;
    7500     Token xsp;
    7501     xsp = jj_scanpos;
    7502     if (jj_3_4()) {
    7503     jj_scanpos = xsp;
    7504     if (jj_3_5()) {
    7505     jj_scanpos = xsp;
    7506     if (jj_3R_294()) {
    7507     jj_scanpos = xsp;
    7508     if (jj_3R_295()) {
    7509     jj_scanpos = xsp;
    7510     if (jj_3R_296()) {
    7511     jj_scanpos = xsp;
    7512     if (jj_3R_297()) return true;
    7513     }
    7514     }
    7515     }
    7516     }
    7517     }
    7518     return false;
    7519   }
    7520
    7521   private boolean jj_3R_285() {
    7522     Token xsp;
    7523     xsp = jj_scanpos;
    7524     if (jj_3R_288()) {
    7525     jj_scanpos = xsp;
    7526     if (jj_3R_289()) {
    7527     jj_scanpos = xsp;
    7528     if (jj_scan_token(82)) return true;
    7529     }
    7530     }
    7531     return false;
    7532   }
    7533
    7534   private boolean jj_3R_84() {
    7535     jj_lookingAhead = true;
    7536     jj_semLA = getToken(1).kind == GT &&
    7537                 ((Token.GTToken)getToken(1)).realKind == RSIGNEDSHIFT;
    7538     jj_lookingAhead = false;
    7539     if (!jj_semLA || jj_3R_130()) return true;
    7540     if (jj_scan_token(GT)) return true;
    7541     if (jj_scan_token(GT)) return true;
    7542     return false;
    7543   }
    7544
    7545   private boolean jj_3R_288() {
    7546     if (jj_3R_292()) return true;
    7547     return false;
    7548   }
    7549
    7550   private boolean jj_3R_282() {
    7551     if (jj_3R_285()) return true;
    7552     return false;
    7553   }
    7554
    7555   private boolean jj_3_3() {
    7556     if (jj_scan_token(COMMA)) return true;
    7557     Token xsp;
    7558     while (true) {
    7559       xsp = jj_scanpos;
    7560       if (jj_3R_68()) { jj_scanpos = xsp; break; }
    7561     }
    7562     if (jj_3R_69()) return true;
    7563     return false;
    7564   }
    7565
    7566   private boolean jj_3R_110() {
    7567     if (jj_scan_token(LBRACE)) return true;
    7568     Token xsp;
    7569     while (true) {
    7570       xsp = jj_scanpos;
    7571       if (jj_3R_282()) { jj_scanpos = xsp; break; }
    7572     }
    7573     if (jj_scan_token(RBRACE)) return true;
    7574     return false;
    7575   }
    7576
    7577   private boolean jj_3R_85() {
    7578     jj_lookingAhead = true;
    7579     jj_semLA = getToken(1).kind == GT &&
    7580                 ((Token.GTToken)getToken(1)).realKind == RUNSIGNEDSHIFT;
    7581     jj_lookingAhead = false;
    7582     if (!jj_semLA || jj_3R_131()) return true;
    7583     if (jj_scan_token(GT)) return true;
    7584     if (jj_scan_token(GT)) return true;
    7585     if (jj_scan_token(GT)) return true;
    7586     return false;
    7587   }
    7588
    7589   private boolean jj_3R_229() {
    7590     if (jj_scan_token(EXTENDS)) return true;
    7591     if (jj_3R_193()) return true;
    7592     Token xsp;
    7593     while (true) {
    7594       xsp = jj_scanpos;
    7595       if (jj_3R_244()) { jj_scanpos = xsp; break; }
    7596     }
    7597     return false;
    7598   }
    7599
    7600   private boolean jj_3R_174() {
    7601     Token xsp;
    7602     xsp = jj_scanpos;
    7603     if (jj_scan_token(28)) {
    7604     jj_scanpos = xsp;
    7605     if (jj_scan_token(12)) return true;
    7606     }
    7607     return false;
    7608   }
    7609
    7610   private boolean jj_3R_177() {
    7611     if (jj_scan_token(IDENTIFIER)) return true;
    7612     Token xsp;
    7613     xsp = jj_scanpos;
    7614     if (jj_3R_219()) jj_scanpos = xsp;
    7615     return false;
    7616   }
    7617
    7618   private boolean jj_3R_182() {
    7619     if (jj_scan_token(IDENTIFIER)) return true;
    7620     if (jj_3R_92()) return true;
    7621     Token xsp;
    7622     xsp = jj_scanpos;
    7623     if (jj_3R_361()) jj_scanpos = xsp;
    7624     if (jj_scan_token(SEMICOLON)) return true;
    7625     return false;
    7626   }
    7627
    7628   private boolean jj_3R_105() {
    7629     Token xsp;
    7630     xsp = jj_scanpos;
    7631     if (jj_3R_174()) jj_scanpos = xsp;
    7632     if (jj_scan_token(CLASS)) return true;
    7633     return false;
    7634   }
    7635
    7636   private boolean jj_3R_113() {
    7637     if (jj_scan_token(LT)) return true;
    7638     if (jj_3R_177()) return true;
    7639     Token xsp;
    7640     while (true) {
    7641       xsp = jj_scanpos;
    7642       if (jj_3R_178()) { jj_scanpos = xsp; break; }
    7643     }
    7644     if (jj_scan_token(GT)) return true;
    7645     return false;
    7646   }
    7647
    7648   private boolean jj_3R_390() {
    7649     if (jj_scan_token(FINALLY)) return true;
    7650     if (jj_3R_196()) return true;
    7651     return false;
    7652   }
    7653
    7654   private boolean jj_3R_214() {
    7655     if (jj_3R_104()) return true;
    7656     return false;
    7657   }
    7658
    7659   private boolean jj_3R_338() {
    7660     if (jj_3R_285()) return true;
    7661     return false;
    7662   }
    7663
    7664   private boolean jj_3R_69() {
    7665     if (jj_scan_token(IDENTIFIER)) return true;
    7666     Token xsp;
    7667     xsp = jj_scanpos;
    7668     if (jj_3R_349()) jj_scanpos = xsp;
    7669     xsp = jj_scanpos;
    7670     if (jj_3R_350()) jj_scanpos = xsp;
    7671     return false;
    7672   }
    7673
    7674   private boolean jj_3_49() {
    7675     if (jj_scan_token(SEMICOLON)) return true;
    7676     if (jj_3R_99()) return true;
    7677     return false;
    7678   }
    7679
    7680   private boolean jj_3R_325() {
    7681     if (jj_scan_token(SEMICOLON)) return true;
    7682     Token xsp;
    7683     while (true) {
    7684       xsp = jj_scanpos;
    7685       if (jj_3R_338()) { jj_scanpos = xsp; break; }
    7686     }
    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_337() {
    7700     if (jj_3R_104()) return true;
    7701     return false;
    7702   }
    7703
    7704   private boolean jj_3R_324() {
    7705     Token xsp;
    7706     while (true) {
    7707       xsp = jj_scanpos;
    7708       if (jj_3R_337()) { jj_scanpos = xsp; break; }
    7709     }
    7710     if (jj_3R_69()) return true;
    7711     while (true) {
    7712       xsp = jj_scanpos;
    7713       if (jj_3_3()) { jj_scanpos = xsp; break; }
    7714     }
    7715     return false;
    7716   }
    7717
    7718   private boolean jj_3R_167() {
    7719     Token xsp;
    7720     xsp = jj_scanpos;
    7721     if (jj_scan_token(28)) {
    7722     jj_scanpos = xsp;
    7723     if (jj_3R_214()) return true;
    7724     }
    7725     return false;
    7726   }
    7727
    7728   private boolean jj_3R_112() {
    7729     if (jj_scan_token(LBRACE)) return true;
    7730     Token xsp;
    7731     xsp = jj_scanpos;
    7732     if (jj_3R_324()) jj_scanpos = xsp;
    7733     xsp = jj_scanpos;
    7734     if (jj_scan_token(83)) jj_scanpos = xsp;
    7735     xsp = jj_scanpos;
    7736     if (jj_3R_325()) jj_scanpos = xsp;
    7737     if (jj_scan_token(RBRACE)) return true;
    7738     return false;
    7739   }
    7740
    7741   private boolean jj_3R_99() {
    7742     Token xsp;
    7743     while (true) {
    7744       xsp = jj_scanpos;
    7745       if (jj_3R_167()) { jj_scanpos = xsp; break; }
    7746     }
    7747     if (jj_3R_73()) return true;
    7748     if (jj_3R_212()) return true;
    7749     if (jj_scan_token(ASSIGN)) return true;
    7750     if (jj_3R_92()) return true;
    7751     return false;
    7752   }
    7753
    7754   private boolean jj_3R_397() {
    7755     if (jj_3R_99()) return true;
    7756     Token xsp;
    7757     while (true) {
    7758       xsp = jj_scanpos;
    7759       if (jj_3_49()) { jj_scanpos = xsp; break; }
    7760     }
    7761     return false;
    7762   }
    7763
    7764   private boolean jj_3R_111() {
    7765     if (jj_3R_176()) return true;
    7766     return false;
    7767   }
    7768
    7769   private boolean jj_3_48() {
    7770     if (jj_scan_token(SEMICOLON)) return true;
    7771     return false;
    7772   }
    7773
    7774   private boolean jj_3R_71() {
    7775     if (jj_scan_token(IDENTIFIER)) return true;
    7776     if (jj_scan_token(IDENTIFIER)) return true;
    7777     Token xsp;
    7778     xsp = jj_scanpos;
    7779     if (jj_3R_111()) jj_scanpos = xsp;
    7780     if (jj_3R_112()) return true;
    7781     return false;
    7782   }
    7783
    7784   private boolean jj_3R_388() {
    7785     if (jj_scan_token(LPAREN)) return true;
    7786     if (jj_3R_397()) return true;
    7787     Token xsp;
    7788     xsp = jj_scanpos;
    7789     if (jj_3_48()) jj_scanpos = xsp;
    7790     if (jj_scan_token(RPAREN)) return true;
    7791     return false;
    7792   }
    7793
    7794   private boolean jj_3R_379() {
    7795     if (jj_3R_388()) return true;
    7796     return false;
    7797   }
    7798
    7799   private boolean jj_3R_336() {
    7800     if (jj_scan_token(COMMA)) return true;
    7801     if (jj_3R_193()) return true;
    7802     return false;
    7803   }
    7804
    7805   private boolean jj_3R_381() {
    7806     if (jj_3R_390()) return true;
    7807     return false;
    7808   }
    7809
    7810   private boolean jj_3R_380() {
    7811     if (jj_3R_389()) return true;
    7812     return false;
    7813   }
    7814
    7815   private boolean jj_3R_176() {
    7816     if (jj_scan_token(IMPLEMENTS)) return true;
    7817     if (jj_3R_193()) return true;
    7818     Token xsp;
    7819     while (true) {
    7820       xsp = jj_scanpos;
    7821       if (jj_3R_336()) { jj_scanpos = xsp; break; }
    7822     }
    7823     return false;
    7824   }
    7825
    7826   private boolean jj_3R_209() {
    7827     if (jj_scan_token(TRY)) return true;
    7828     Token xsp;
    7829     xsp = jj_scanpos;
    7830     if (jj_3R_379()) jj_scanpos = xsp;
    7831     if (jj_3R_196()) return true;
    7832     while (true) {
    7833       xsp = jj_scanpos;
    7834       if (jj_3R_380()) { jj_scanpos = xsp; break; }
    7835     }
    7836     xsp = jj_scanpos;
    7837     if (jj_3R_381()) jj_scanpos = xsp;
    7838     return false;
    7839   }
    7840
    7841   private boolean jj_3R_335() {
    7842     if (jj_scan_token(COMMA)) return true;
    7843     if (jj_3R_193()) return true;
    7844     return false;
    7845   }
    7846
    7847   private boolean jj_3R_175() {
    7848     if (jj_scan_token(EXTENDS)) return true;
    7849     if (jj_3R_193()) return true;
    7850     Token xsp;
    7851     while (true) {
    7852       xsp = jj_scanpos;
    7853       if (jj_3R_335()) { jj_scanpos = xsp; break; }
    7854     }
    7855     return false;
    7856   }
    7857
    7858   private boolean jj_3R_208() {
    7859     if (jj_scan_token(SYNCHRONIZED)) return true;
    7860     if (jj_scan_token(LPAREN)) return true;
    7861     if (jj_3R_92()) return true;
    7862     if (jj_scan_token(RPAREN)) return true;
    7863     if (jj_3R_196()) return true;
    7864     return false;
    7865   }
    7866
    7867   private boolean jj_3R_378() {
    7868     if (jj_3R_92()) return true;
    7869     return false;
    7870   }
    7871
    7872   private boolean jj_3R_109() {
    7873     if (jj_3R_176()) return true;
    7874     return false;
    7875   }
    7876
    7877   private boolean jj_3R_108() {
    7878     if (jj_3R_175()) return true;
    7879     return false;
    7880   }
    7881
    7882   private boolean jj_3R_377() {
    7883     if (jj_scan_token(IDENTIFIER)) return true;
    7884     return false;
    7885   }
    7886
    7887   private boolean jj_3R_107() {
    7888     if (jj_3R_113()) return true;
    7889     return false;
    7890   }
    7891
    7892   private boolean jj_3R_207() {
    7893     if (jj_scan_token(THROW)) return true;
    7894     if (jj_3R_92()) return true;
    7895     if (jj_scan_token(SEMICOLON)) return true;
    7896     return false;
    7897   }
    7898
    7899   private boolean jj_3R_70() {
    7900     Token xsp;
    7901     xsp = jj_scanpos;
    7902     if (jj_3R_105()) {
    7903     jj_scanpos = xsp;
    7904     if (jj_3R_106()) return true;
    7905     }
    7906     if (jj_scan_token(IDENTIFIER)) return true;
    7907     xsp = jj_scanpos;
    7908     if (jj_3R_107()) jj_scanpos = xsp;
    7909     xsp = jj_scanpos;
    7910     if (jj_3R_108()) jj_scanpos = xsp;
    7911     xsp = jj_scanpos;
    7912     if (jj_3R_109()) jj_scanpos = xsp;
    7913     if (jj_3R_110()) return true;
    7914     return false;
    7915   }
    7916
    7917   private boolean jj_3R_403() {
    7918     if (jj_scan_token(COMMA)) return true;
    7919     if (jj_3R_198()) return true;
    7920     return false;
    7921   }
    7922
    7923   private boolean jj_3R_206() {
    7924     if (jj_scan_token(RETURN)) return true;
    7925     Token xsp;
    7926     xsp = jj_scanpos;
    7927     if (jj_3R_378()) jj_scanpos = xsp;
    7928     if (jj_scan_token(SEMICOLON)) return true;
    7929     return false;
    7930   }
    7931
    7932   private boolean jj_3R_376() {
    7933     if (jj_scan_token(IDENTIFIER)) return true;
    7934     return false;
    7935   }
    7936
    7937   private boolean jj_3R_205() {
    7938     if (jj_scan_token(CONTINUE)) return true;
    7939     Token xsp;
    7940     xsp = jj_scanpos;
    7941     if (jj_3R_377()) jj_scanpos = xsp;
    7942     if (jj_scan_token(SEMICOLON)) return true;
    7943     return false;
    7944   }
    7945
    7946   private boolean jj_3R_204() {
    7947     if (jj_scan_token(BREAK)) return true;
    7948     Token xsp;
    7949     xsp = jj_scanpos;
    7950     if (jj_3R_376()) jj_scanpos = xsp;
    7951     if (jj_scan_token(SEMICOLON)) return true;
    7952     return false;
    7953   }
    7954
    7955   private boolean jj_3R_396() {
    7956     if (jj_3R_402()) return true;
    7957     return false;
    7958   }
    7959
    7960   private boolean jj_3_47() {
    7961     if (jj_3R_98()) return true;
    7962     return false;
    7963   }
    7964
    7965   private boolean jj_3R_402() {
    7966     if (jj_3R_198()) return true;
    7967     Token xsp;
    7968     while (true) {
    7969       xsp = jj_scanpos;
    7970       if (jj_3R_403()) { jj_scanpos = xsp; break; }
    7971     }
    7972     return false;
    7973   }
    7974
    7975   private boolean jj_3R_373() {
    7976     if (jj_scan_token(ELSE)) return true;
    7977     if (jj_3R_95()) return true;
    7978     return false;
    7979   }
    7980
    7981   private boolean jj_3R_401() {
    7982     if (jj_3R_402()) return true;
    7983     return false;
    7984   }
    7985
    7986   private boolean jj_3R_67() {
    7987     if (jj_3R_104()) return true;
    7988     return false;
    7989   }
    7990
    7991   private boolean jj_3R_66() {
    7992     if (jj_scan_token(STRICTFP)) return true;
    7993     return false;
    7994   }
    7995
    7996   private boolean jj_3R_65() {
    7997     if (jj_scan_token(VOLATILE)) return true;
    7998     return false;
    7999   }
    8000
    8001   private boolean jj_3R_400() {
    8002     if (jj_3R_98()) return true;
    8003     return false;
    8004   }
    8005
    8006   private boolean jj_3R_395() {
    8007     Token xsp;
    8008     xsp = jj_scanpos;
    8009     if (jj_3R_400()) {
    8010     jj_scanpos = xsp;
    8011     if (jj_3R_401()) return true;
    8012     }
    8013     return false;
    8014   }
    8015
    8016   private boolean jj_3R_64() {
    8017     if (jj_scan_token(TRANSIENT)) return true;
    8018     return false;
    8019   }
    8020
    8021   private boolean jj_3_46() {
    8022     if (jj_3R_98()) return true;
    8023     if (jj_scan_token(COLON)) return true;
    8024     return false;
    8025   }
    8026
    8027   private boolean jj_3R_63() {
    8028     if (jj_scan_token(NATIVE)) return true;
    8029     return false;
    8030   }
    8031
    8032   private boolean jj_3R_62() {
    8033     if (jj_scan_token(SYNCHRONIZED)) return true;
    8034     return false;
    8035   }
    8036
    8037   private boolean jj_3R_61() {
    8038     if (jj_scan_token(ABSTRACT)) return true;
    8039     return false;
    8040   }
    8041
    8042   private boolean jj_3R_60() {
    8043     if (jj_scan_token(FINAL)) return true;
    8044     return false;
    8045   }
    8046
    8047   private boolean jj_3R_59() {
    8048     if (jj_scan_token(PRIVATE)) return true;
    8049     return false;
    8050   }
    8051
    8052   private boolean jj_3R_387() {
    8053     if (jj_3R_396()) return true;
    8054     return false;
    8055   }
    8056
    8057   private boolean jj_3R_58() {
    8058     if (jj_scan_token(PROTECTED)) return true;
    8059     return false;
    8060   }
    8061
    8062   private boolean jj_3R_386() {
    8063     if (jj_3R_92()) return true;
    8064     return false;
    8065   }
    8066
    8067   private boolean jj_3R_57() {
    8068     if (jj_scan_token(STATIC)) return true;
    8069     return false;
    8070   }
    8071
    8072   private boolean jj_3R_385() {
    8073     if (jj_3R_395()) return true;
    8074     return false;
    8075   }
    8076
    8077   private boolean jj_3R_56() {
    8078     if (jj_scan_token(PUBLIC)) return true;
    8079     return false;
    8080   }
    8081
    8082   private boolean jj_3R_375() {
    8083     Token xsp;
    8084     xsp = jj_scanpos;
    8085     if (jj_3R_385()) jj_scanpos = xsp;
    8086     if (jj_scan_token(SEMICOLON)) return true;
    8087     xsp = jj_scanpos;
    8088     if (jj_3R_386()) jj_scanpos = xsp;
    8089     if (jj_scan_token(SEMICOLON)) return true;
    8090     xsp = jj_scanpos;
    8091     if (jj_3R_387()) jj_scanpos = xsp;
    8092     return false;
    8093   }
    8094
    8095   private boolean jj_3R_374() {
    8096     if (jj_3R_98()) return true;
    8097     if (jj_scan_token(COLON)) return true;
    8098     if (jj_3R_92()) return true;
    8099     return false;
    8100   }
    8101
    8102   private boolean jj_3_2() {
    8103     Token xsp;
    8104     xsp = jj_scanpos;
    8105     if (jj_3R_56()) {
    8106     jj_scanpos = xsp;
    8107     if (jj_3R_57()) {
    8108     jj_scanpos = xsp;
    8109     if (jj_3R_58()) {
    8110     jj_scanpos = xsp;
    8111     if (jj_3R_59()) {
    8112     jj_scanpos = xsp;
    8113     if (jj_3R_60()) {
    8114     jj_scanpos = xsp;
    8115     if (jj_3R_61()) {
    8116     jj_scanpos = xsp;
    8117     if (jj_3R_62()) {
    8118     jj_scanpos = xsp;
    8119     if (jj_3R_63()) {
    8120     jj_scanpos = xsp;
    8121     if (jj_3R_64()) {
    8122     jj_scanpos = xsp;
    8123     if (jj_3R_65()) {
    8124     jj_scanpos = xsp;
    8125     if (jj_3R_66()) {
    8126     jj_scanpos = xsp;
    8127     if (jj_3R_67()) return true;
    8128     }
    8129     }
    8130     }
    8131     }
    8132     }
    8133     }
    8134     }
    8135     }
    8136     }
    8137     }
    8138     }
    8139     return false;
    8140   }
    8141
    8142   private boolean jj_3R_293() {
    8143     Token xsp;
    8144     while (true) {
    8145       xsp = jj_scanpos;
    8146       if (jj_3_2()) { jj_scanpos = xsp; break; }
    8147     }
    8148     return false;
    8149   }
    8150
    8151   private boolean jj_3R_203() {
    8152     if (jj_scan_token(FOR)) return true;
    8153     if (jj_scan_token(LPAREN)) return true;
    8154     Token xsp;
    8155     xsp = jj_scanpos;
    8156     if (jj_3R_374()) {
    8157     jj_scanpos = xsp;
    8158     if (jj_3R_375()) return true;
    8159     }
    8160     if (jj_scan_token(RPAREN)) return true;
    8161     if (jj_3R_95()) return true;
    8162     return false;
    8163   }
    8164
    8165   private boolean jj_3R_202() {
    8166     if (jj_scan_token(DO)) return true;
    8167     if (jj_3R_95()) return true;
    8168     if (jj_scan_token(WHILE)) return true;
    8169     if (jj_scan_token(LPAREN)) return true;
    8170     if (jj_3R_92()) return true;
    8171     if (jj_scan_token(RPAREN)) return true;
    8172     if (jj_scan_token(SEMICOLON)) return true;
    8173     return false;
    8174   }
    8175
    8176   private boolean jj_3R_201() {
    8177     if (jj_scan_token(WHILE)) return true;
    8178     if (jj_scan_token(LPAREN)) return true;
    8179     if (jj_3R_92()) return true;
    8180     if (jj_scan_token(RPAREN)) return true;
    8181     if (jj_3R_95()) return true;
    8182     return false;
    8183   }
    8184
    8185   private boolean jj_3R_55() {
    8186     if (jj_3R_104()) return true;
    8187     return false;
    8188   }
    8189
    8190   private boolean jj_3_1() {
    8191     Token xsp;
    8192     while (true) {
    8193       xsp = jj_scanpos;
    8194       if (jj_3R_55()) { jj_scanpos = xsp; break; }
    8195     }
    8196     if (jj_scan_token(PACKAGE)) return true;
    8197     return false;
    8198   }
    8199
    8200   private boolean jj_3_45() {
    8201     if (jj_3R_77()) return true;
    8202     return false;
    8203   }
    8204
    8205   private boolean jj_3R_183() {
    8206     if (jj_3R_104()) return true;
    8207     return false;
    8208   }
    8209
    8210   private boolean jj_3R_200() {
    8211     if (jj_scan_token(IF)) return true;
    8212     if (jj_scan_token(LPAREN)) return true;
    8213     if (jj_3R_92()) return true;
    8214     if (jj_scan_token(RPAREN)) return true;
    8215     if (jj_3R_95()) return true;
    8216     Token xsp;
    8217     xsp = jj_scanpos;
    8218     if (jj_3R_373()) jj_scanpos = xsp;
    8219     return false;
    8220   }
    8221
    8222   private boolean jj_3R_394() {
    8223     if (jj_scan_token(_DEFAULT)) return true;
    8224     if (jj_scan_token(COLON)) return true;
    8225     return false;
    8226   }
    8227
    8228   private boolean jj_3R_393() {
    8229     if (jj_scan_token(CASE)) return true;
    8230     if (jj_3R_92()) return true;
    8231     if (jj_scan_token(COLON)) return true;
    8232     return false;
    8233   }
    8234
    8235   private boolean jj_3R_384() {
    8236     Token xsp;
    8237     xsp = jj_scanpos;
    8238     if (jj_3R_393()) {
    8239     jj_scanpos = xsp;
    8240     if (jj_3R_394()) return true;
    8241     }
    8242     return false;
    8243   }
    8244
    8245   private boolean jj_3R_211() {
    8246     if (jj_3R_104()) return true;
    8247     return false;
    8248   }
    8249
    8250   private boolean jj_3R_372() {
    8251     if (jj_3R_384()) return true;
    8252     Token xsp;
    8253     while (true) {
    8254       xsp = jj_scanpos;
    8255       if (jj_3_45()) { jj_scanpos = xsp; break; }
    8256     }
    8257     return false;
    8258   }
    8259
    8260   private boolean jj_3_44() {
    8261     if (jj_3R_78()) return true;
    8262     Token xsp;
    8263     xsp = jj_scanpos;
    8264     if (jj_scan_token(98)) {
    8265     jj_scanpos = xsp;
    8266     if (jj_scan_token(99)) return true;
    8267     }
    8268     return false;
    8269   }
    8270
    8271   private boolean jj_3R_199() {
    8272     if (jj_scan_token(SWITCH)) return true;
    8273     if (jj_scan_token(LPAREN)) return true;
    8274     if (jj_3R_92()) return true;
    8275     if (jj_scan_token(RPAREN)) return true;
    8276     if (jj_scan_token(LBRACE)) return true;
    8277     Token xsp;
    8278     while (true) {
    8279       xsp = jj_scanpos;
    8280       if (jj_3R_372()) { jj_scanpos = xsp; break; }
    8281     }
    8282     if (jj_scan_token(RBRACE)) return true;
    8283     return false;
    8284   }
    8285
    8286   private boolean jj_3R_383() {
    8287     if (jj_3R_248()) return true;
    8288     if (jj_3R_92()) return true;
    8289     return false;
    8290   }
    8291
    8292   private boolean jj_3R_97() {
    8293     Token xsp;
    8294     xsp = jj_scanpos;
    8295     if (jj_scan_token(28)) {
    8296     jj_scanpos = xsp;
    8297     if (jj_scan_token(12)) return true;
    8298     }
    8299     return false;
    8300   }
    8301
    8302   private boolean jj_3R_226() {
    8303     if (jj_3R_78()) return true;
    8304     Token xsp;
    8305     xsp = jj_scanpos;
    8306     if (jj_3R_383()) jj_scanpos = xsp;
    8307     return false;
    8308   }
    8309
    8310   private boolean jj_3R_225() {
    8311     if (jj_3R_242()) return true;
    8312     return false;
    8313   }
    8314
    8315   private boolean jj_3R_224() {
    8316     if (jj_3R_241()) return true;
    8317     return false;
    8318   }
    8319
    8320   private boolean jj_3R_198() {
    8321     Token xsp;
    8322     xsp = jj_scanpos;
    8323     if (jj_3R_223()) {
    8324     jj_scanpos = xsp;
    8325     if (jj_3R_224()) {
    8326     jj_scanpos = xsp;
    8327     if (jj_3R_225()) {
    8328     jj_scanpos = xsp;
    8329     if (jj_3R_226()) return true;
    8330     }
    8331     }
    8332     }
    8333     return false;
    8334   }
    8335
    8336   private boolean jj_3R_223() {
    8337     if (jj_3R_240()) return true;
    8338     return false;
    8339   }
    8340
    8341   private boolean jj_3R_197() {
    8342     if (jj_scan_token(SEMICOLON)) return true;
    8343     return false;
    8344   }
    8345
    8346   private boolean jj_3R_96() {
    8347     if (jj_3R_104()) return true;
    8348     return false;
    8349   }
    8350
    8351   private boolean jj_3_43() {
    8352     Token xsp;
    8353     xsp = jj_scanpos;
    8354     if (jj_3R_96()) jj_scanpos = xsp;
    8355     xsp = jj_scanpos;
    8356     if (jj_3R_97()) jj_scanpos = xsp;
    8357     if (jj_scan_token(CLASS)) return true;
    8358     return false;
    8359   }
    8360
    8361   private boolean jj_3R_148() {
    8362     if (jj_3R_104()) return true;
    8363     return false;
    8364   }
    8365
    8366   private boolean jj_3R_166() {
    8367     if (jj_scan_token(COMMA)) return true;
    8368     if (jj_3R_165()) return true;
    8369     return false;
    8370   }
    8371
    8372   private boolean jj_3R_164() {
    8373     Token xsp;
    8374     xsp = jj_scanpos;
    8375     if (jj_3R_210()) {
    8376     jj_scanpos = xsp;
    8377     if (jj_3R_211()) return true;
    8378     }
    8379     return false;
    8380   }
    8381
    8382   private boolean jj_3R_210() {
    8383     if (jj_scan_token(FINAL)) return true;
    8384     return false;
    8385   }
    8386
    8387   private boolean jj_3R_98() {
    8388     Token xsp;
    8389     while (true) {
    8390       xsp = jj_scanpos;
    8391       if (jj_3R_164()) { jj_scanpos = xsp; break; }
    8392     }
    8393     if (jj_3R_73()) return true;
    8394     if (jj_3R_165()) return true;
    8395     while (true) {
    8396       xsp = jj_scanpos;
    8397       if (jj_3R_166()) { jj_scanpos = xsp; break; }
    8398     }
    8399     return false;
    8400   }
    8401
    8402   private boolean jj_3R_94() {
    8403     Token xsp;
    8404     xsp = jj_scanpos;
    8405     if (jj_scan_token(28)) {
    8406     jj_scanpos = xsp;
    8407     if (jj_3R_148()) return true;
    8408     }
    8409     return false;
    8410   }
    8411
    8412   private boolean jj_3R_122() {
    8413     Token xsp;
    8414     xsp = jj_scanpos;
    8415     if (jj_3R_183()) jj_scanpos = xsp;
    8416     if (jj_3R_70()) return true;
    8417     return false;
    8418   }
    8419
    8420   private boolean jj_3_41() {
    8421     Token xsp;
    8422     while (true) {
    8423       xsp = jj_scanpos;
    8424       if (jj_3R_94()) { jj_scanpos = xsp; break; }
    8425     }
    8426     if (jj_3R_73()) return true;
    8427     if (jj_scan_token(IDENTIFIER)) return true;
    8428     return false;
    8429   }
    8430
    8431   private boolean jj_3_42() {
    8432     if (jj_3R_95()) return true;
    8433     return false;
    8434   }
    8435
    8436   private boolean jj_3R_121() {
    8437     if (jj_3R_98()) return true;
    8438     if (jj_scan_token(SEMICOLON)) return true;
    8439     return false;
    8440   }
    8441
    8442   private boolean jj_3R_120() {
    8443     if (jj_3R_182()) return true;
    8444     return false;
    8445   }
    8446
    8447   private boolean jj_3R_77() {
    8448     Token xsp;
    8449     xsp = jj_scanpos;
    8450     jj_lookingAhead = true;
    8451     jj_semLA = isNextTokenAnAssert();
    8452     jj_lookingAhead = false;
    8453     if (!jj_semLA || jj_3R_120()) {
    8454     jj_scanpos = xsp;
    8455     if (jj_3R_121()) {
    8456     jj_scanpos = xsp;
    8457     if (jj_3_42()) {
    8458     jj_scanpos = xsp;
    8459     if (jj_3R_122()) return true;
    8460     }
    8461     }
    8462     }
    8463     return false;
    8464   }
    8465
    8466   private boolean jj_3_40() {
    8467     if (jj_3R_77()) return true;
    8468     return false;
    8469   }
    8470
    8471   private boolean jj_3R_196() {
    8472     if (jj_scan_token(LBRACE)) return true;
    8473     Token xsp;
    8474     while (true) {
    8475       xsp = jj_scanpos;
    8476       if (jj_3_40()) { jj_scanpos = xsp; break; }
    8477     }
    8478     if (jj_scan_token(RBRACE)) return true;
    8479     return false;
    8480   }
    8481
    8482   private boolean jj_3_37() {
    8483     if (jj_scan_token(LBRACKET)) return true;
    8484     if (jj_scan_token(RBRACKET)) return true;
    8485     return false;
    8486   }
    8487
    8488   private boolean jj_3R_93() {
    8489     if (jj_scan_token(IDENTIFIER)) return true;
    8490     if (jj_scan_token(COLON)) return true;
    8491     if (jj_3R_95()) return true;
    8492     return false;
    8493   }
    8494
    8495   private boolean jj_3R_163() {
    8496     if (jj_3R_209()) return true;
    8497     return false;
    8498   }
    8499
    8500   private boolean jj_3R_162() {
    8501     if (jj_3R_208()) return true;
    8502     return false;
    8503   }
    8504
    8505   private boolean jj_3R_161() {
    8506     if (jj_3R_207()) return true;
    8507     return false;
    8508   }
    8509
    8510   private boolean jj_3R_160() {
    8511     if (jj_3R_206()) return true;
    8512     return false;
    8513   }
    8514
    8515   private boolean jj_3R_159() {
    8516     if (jj_3R_205()) return true;
    8517     return false;
    8518   }
    8519
    8520   private boolean jj_3R_158() {
    8521     if (jj_3R_204()) return true;
    8522     return false;
    8523   }
    8524
    8525   private boolean jj_3R_157() {
    8526     if (jj_3R_203()) return true;
    8527     return false;
    8528   }
    8529
    8530   private boolean jj_3R_156() {
    8531     if (jj_3R_202()) return true;
    8532     return false;
    8533   }
    8534
    8535   private boolean jj_3R_155() {
    8536     if (jj_3R_201()) return true;
    8537     return false;
    8538   }
    8539
    8540   private boolean jj_3R_154() {
    8541     if (jj_3R_200()) return true;
    8542     return false;
    8543   }
    8544
    8545   private boolean jj_3R_153() {
    8546     if (jj_3R_199()) return true;
    8547     return false;
    8548   }
    8549
    8550   private boolean jj_3R_152() {
    8551     if (jj_3R_198()) return true;
    8552     if (jj_scan_token(SEMICOLON)) return true;
    8553     return false;
    8554   }
    8555
    8556   private boolean jj_3R_151() {
    8557     if (jj_3R_197()) return true;
    8558     return false;
    8559   }
    8560
    8561   private boolean jj_3R_150() {
    8562     if (jj_3R_196()) return true;
    8563     return false;
    8564   }
    8565
    8566   private boolean jj_3R_250() {
    8567     if (jj_3R_80()) return true;
    8568     return false;
    8569   }
    8570
    8571   private boolean jj_3_39() {
    8572     if (jj_3R_93()) return true;
    8573     return false;
    8574   }
    8575
    8576   private boolean jj_3R_95() {
    8577     Token xsp;
    8578     xsp = jj_scanpos;
    8579     jj_lookingAhead = true;
    8580     jj_semLA = isNextTokenAnAssert();
    8581     jj_lookingAhead = false;
    8582     if (!jj_semLA || jj_3R_149()) {
    8583     jj_scanpos = xsp;
    8584     if (jj_3_39()) {
    8585     jj_scanpos = xsp;
    8586     if (jj_3R_150()) {
    8587     jj_scanpos = xsp;
    8588     if (jj_3R_151()) {
    8589     jj_scanpos = xsp;
    8590     if (jj_3R_152()) {
    8591     jj_scanpos = xsp;
    8592     if (jj_3R_153()) {
    8593     jj_scanpos = xsp;
    8594     if (jj_3R_154()) {
    8595     jj_scanpos = xsp;
    8596     if (jj_3R_155()) {
    8597     jj_scanpos = xsp;
    8598     if (jj_3R_156()) {
    8599     jj_scanpos = xsp;
    8600     if (jj_3R_157()) {
    8601     jj_scanpos = xsp;
    8602     if (jj_3R_158()) {
    8603     jj_scanpos = xsp;
    8604     if (jj_3R_159()) {
    8605     jj_scanpos = xsp;
    8606     if (jj_3R_160()) {
    8607     jj_scanpos = xsp;
    8608     if (jj_3R_161()) {
    8609     jj_scanpos = xsp;
    8610     if (jj_3R_162()) {
    8611     jj_scanpos = xsp;
    8612     if (jj_3R_163()) return true;
    8613     }
    8614     }
    8615     }
    8616     }
    8617     }
    8618     }
    8619     }
    8620     }
    8621     }
    8622     }
    8623     }
    8624     }
    8625     }
    8626     }
    8627     }
    8628     return false;
    8629   }
    8630
    8631   private boolean jj_3R_149() {
    8632     if (jj_3R_182()) return true;
    8633     return false;
    8634   }
    8635
    8636   private boolean jj_3R_272() {
    8637     if (jj_3R_110()) return true;
    8638     return false;
    8639   }
    8640
    8641   private boolean jj_3R_279() {
    8642     if (jj_scan_token(LBRACKET)) return true;
    8643     if (jj_scan_token(RBRACKET)) return true;
    8644     return false;
    8645   }
    8646
    8647   private boolean jj_3_36() {
    8648     if (jj_scan_token(LBRACKET)) return true;
    8649     if (jj_3R_92()) return true;
    8650     if (jj_scan_token(RBRACKET)) return true;
    8651     return false;
    8652   }
    8653
    8654   private boolean jj_3R_271() {
    8655     Token xsp;
    8656     if (jj_3R_279()) return true;
    8657     while (true) {
    8658       xsp = jj_scanpos;
    8659       if (jj_3R_279()) { jj_scanpos = xsp; break; }
    8660     }
    8661     if (jj_3R_179()) return true;
    8662     return false;
    8663   }
    8664
    8665   private boolean jj_3_38() {
    8666     Token xsp;
    8667     if (jj_3_36()) return true;
    8668     while (true) {
    8669       xsp = jj_scanpos;
    8670       if (jj_3_36()) { jj_scanpos = xsp; break; }
    8671     }
    8672     while (true) {
    8673       xsp = jj_scanpos;
    8674       if (jj_3_37()) { jj_scanpos = xsp; break; }
    8675     }
    8676     return false;
    8677   }
    8678
    8679   private boolean jj_3R_249() {
    8680     Token xsp;
    8681     xsp = jj_scanpos;
    8682     if (jj_3_38()) {
    8683     jj_scanpos = xsp;
    8684     if (jj_3R_271()) return true;
    8685     }
    8686     return false;
    8687   }
    8688
    8689   private boolean jj_3R_252() {
    8690     if (jj_3R_79()) return true;
    8691     Token xsp;
    8692     xsp = jj_scanpos;
    8693     if (jj_3R_272()) jj_scanpos = xsp;
    8694     return false;
    8695   }
    8696
    8697   private boolean jj_3R_221() {
    8698     if (jj_scan_token(COMMA)) return true;
    8699     if (jj_3R_92()) return true;
    8700     return false;
    8701   }
    8702
    8703   private boolean jj_3R_251() {
    8704     if (jj_3R_249()) return true;
    8705     return false;
    8706   }
    8707
    8708   private boolean jj_3R_146() {
    8709     if (jj_scan_token(NEW)) return true;
    8710     if (jj_3R_193()) return true;
    8711     Token xsp;
    8712     xsp = jj_scanpos;
    8713     if (jj_3R_250()) jj_scanpos = xsp;
    8714     xsp = jj_scanpos;
    8715     if (jj_3R_251()) {
    8716     jj_scanpos = xsp;
    8717     if (jj_3R_252()) return true;
    8718     }
    8719     return false;
    8720   }
    8721
    8722   private boolean jj_3R_90() {
    8723     Token xsp;
    8724     xsp = jj_scanpos;
    8725     if (jj_3_35()) {
    8726     jj_scanpos = xsp;
    8727     if (jj_3R_146()) return true;
    8728     }
    8729     return false;
    8730   }
    8731
    8732   private boolean jj_3_35() {
    8733     if (jj_scan_token(NEW)) return true;
    8734     if (jj_3R_87()) return true;
    8735     if (jj_3R_249()) return true;
    8736     return false;
    8737   }
    8738
    8739   private boolean jj_3R_124() {
    8740     if (jj_3R_191()) return true;
    8741     return false;
    8742   }
    8743
    8744   private boolean jj_3R_191() {
    8745     if (jj_3R_92()) return true;
    8746     Token xsp;
    8747     while (true) {
    8748       xsp = jj_scanpos;
    8749       if (jj_3R_221()) { jj_scanpos = xsp; break; }
    8750     }
    8751     return false;
    8752   }
    8753
    8754   private boolean jj_3R_79() {
    8755     if (jj_scan_token(LPAREN)) return true;
    8756     Token xsp;
    8757     xsp = jj_scanpos;
    8758     if (jj_3R_124()) jj_scanpos = xsp;
    8759     if (jj_scan_token(RPAREN)) return true;
    8760     return false;
    8761   }
    8762
    8763   private boolean jj_3R_194() {
    8764     if (jj_3R_220()) return true;
    8765     return false;
    8766   }
    8767
    8768   private boolean jj_3R_246() {
    8769     if (jj_scan_token(NULL)) return true;
    8770     return false;
    8771   }
    8772
    8773   private boolean jj_3R_245() {
    8774     Token xsp;
    8775     xsp = jj_scanpos;
    8776     if (jj_3R_257()) {
    8777     jj_scanpos = xsp;
    8778     if (jj_scan_token(27)) return true;
    8779     }
    8780     return false;
    8781   }
    8782
    8783   private boolean jj_3R_257() {
    8784     if (jj_scan_token(TRUE)) return true;
    8785     return false;
    8786   }
    8787
    8788   private boolean jj_3R_399() {
    8789     if (jj_scan_token(DECR)) return true;
    8790     return false;
    8791   }
    8792
    8793   private boolean jj_3R_236() {
    8794     if (jj_3R_246()) return true;
    8795     return false;
    8796   }
    8797
    8798   private boolean jj_3R_235() {
    8799     if (jj_3R_245()) return true;
    8800     return false;
    8801   }
    8802
    8803   private boolean jj_3R_234() {
    8804     if (jj_scan_token(STRING_LITERAL)) return true;
    8805     return false;
    8806   }
    8807
    8808   private boolean jj_3R_233() {
    8809     if (jj_scan_token(CHARACTER_LITERAL)) return true;
    8810     return false;
    8811   }
    8812
    8813   private boolean jj_3R_232() {
    8814     if (jj_scan_token(HEX_FLOATING_POINT_LITERAL)) return true;
    8815     return false;
    8816   }
    8817
    8818   private boolean jj_3R_231() {
    8819     if (jj_scan_token(FLOATING_POINT_LITERAL)) return true;
    8820     return false;
    8821   }
    8822
    8823   private boolean jj_3R_220() {
    8824     Token xsp;
    8825     xsp = jj_scanpos;
    8826     if (jj_3R_230()) {
    8827     jj_scanpos = xsp;
    8828     if (jj_3R_231()) {
    8829     jj_scanpos = xsp;
    8830     if (jj_3R_232()) {
    8831     jj_scanpos = xsp;
    8832     if (jj_3R_233()) {
    8833     jj_scanpos = xsp;
    8834     if (jj_3R_234()) {
    8835     jj_scanpos = xsp;
    8836     if (jj_3R_235()) {
    8837     jj_scanpos = xsp;
    8838     if (jj_3R_236()) return true;
    8839     }
    8840     }
    8841     }
    8842     }
    8843     }
    8844     }
    8845     return false;
    8846   }
    8847
    8848   private boolean jj_3R_230() {
    8849     if (jj_scan_token(INTEGER_LITERAL)) return true;
    8850     return false;
    8851   }
    8852
    8853   private boolean jj_3_31() {
    8854     if (jj_3R_89()) return true;
    8855     if (jj_scan_token(DOT)) return true;
    8856     if (jj_scan_token(CLASS)) return true;
    8857     return false;
    8858   }
    8859
    8860   private boolean jj_3R_144() {
    8861     if (jj_3R_79()) return true;
    8862     return false;
    8863   }
    8864
    8865   private boolean jj_3R_143() {
    8866     if (jj_scan_token(DOT)) return true;
    8867     if (jj_scan_token(IDENTIFIER)) return true;
    8868     return false;
    8869   }
    8870
    8871   private boolean jj_3R_142() {
    8872     if (jj_scan_token(LBRACKET)) return true;
    8873     if (jj_3R_92()) return true;
    8874     if (jj_scan_token(RBRACKET)) return true;
    8875     return false;
    8876   }
    8877
    8878   private boolean jj_3R_360() {
    8879     if (jj_scan_token(REM)) return true;
    8880     return false;
    8881   }
    8882
    8883   private boolean jj_3_34() {
    8884     if (jj_3R_91()) return true;
    8885     return false;
    8886   }
    8887
    8888   private boolean jj_3R_88() {
    8889     Token xsp;
    8890     xsp = jj_scanpos;
    8891     if (jj_3_32()) {
    8892     jj_scanpos = xsp;
    8893     if (jj_3_33()) {
    8894     jj_scanpos = xsp;
    8895     if (jj_3_34()) {
    8896     jj_scanpos = xsp;
    8897     if (jj_3R_142()) {
    8898     jj_scanpos = xsp;
    8899     if (jj_3R_143()) {
    8900     jj_scanpos = xsp;
    8901     if (jj_3R_144()) return true;
    8902     }
    8903     }
    8904     }
    8905     }
    8906     }
    8907     return false;
    8908   }
    8909
    8910   private boolean jj_3_33() {
    8911     if (jj_scan_token(DOT)) return true;
    8912     if (jj_3R_90()) return true;
    8913     return false;
    8914   }
    8915
    8916   private boolean jj_3_32() {
    8917     if (jj_scan_token(DOT)) return true;
    8918     if (jj_scan_token(THIS)) return true;
    8919     return false;
    8920   }
    8921
    8922   private boolean jj_3R_190() {
    8923     if (jj_3R_100()) return true;
    8924     return false;
    8925   }
    8926
    8927   private boolean jj_3R_189() {
    8928     if (jj_3R_89()) return true;
    8929     if (jj_scan_token(DOT)) return true;
    8930     if (jj_scan_token(CLASS)) return true;
    8931     return false;
    8932   }
    8933
    8934   private boolean jj_3_30() {
    8935     if (jj_3R_88()) return true;
    8936     return false;
    8937   }
    8938
    8939   private boolean jj_3R_188() {
    8940     if (jj_3R_90()) return true;
    8941     return false;
    8942   }
    8943
    8944   private boolean jj_3R_187() {
    8945     if (jj_scan_token(LPAREN)) return true;
    8946     if (jj_3R_92()) return true;
    8947     if (jj_scan_token(RPAREN)) return true;
    8948     return false;
    8949   }
    8950
    8951   private boolean jj_3R_186() {
    8952     if (jj_scan_token(SUPER)) return true;
    8953     return false;
    8954   }
    8955
    8956   private boolean jj_3R_185() {
    8957     if (jj_scan_token(THIS)) return true;
    8958     return false;
    8959   }
    8960
    8961   private boolean jj_3R_123() {
    8962     Token xsp;
    8963     xsp = jj_scanpos;
    8964     if (jj_3R_184()) {
    8965     jj_scanpos = xsp;
    8966     if (jj_3R_185()) {
    8967     jj_scanpos = xsp;
    8968     if (jj_3R_186()) {
    8969     jj_scanpos = xsp;
    8970     if (jj_3R_187()) {
    8971     jj_scanpos = xsp;
    8972     if (jj_3R_188()) {
    8973     jj_scanpos = xsp;
    8974     if (jj_3R_189()) {
    8975     jj_scanpos = xsp;
    8976     if (jj_3R_190()) return true;
    8977     }
    8978     }
    8979     }
    8980     }
    8981     }
    8982     }
    8983     return false;
    8984   }
    8985
    8986   private boolean jj_3R_184() {
    8987     if (jj_3R_220()) return true;
    8988     return false;
    8989   }
    8990
    8991   private boolean jj_3R_398() {
    8992     if (jj_scan_token(INCR)) return true;
    8993     return false;
    8994   }
    8995
    8996   private boolean jj_3R_392() {
    8997     Token xsp;
    8998     xsp = jj_scanpos;
    8999     if (jj_3R_398()) {
    9000     jj_scanpos = xsp;
    9001     if (jj_3R_399()) return true;
    9002     }
    9003     return false;
    9004   }
    9005
    9006   private boolean jj_3R_91() {
    9007     if (jj_scan_token(DOT)) return true;
    9008     if (jj_3R_80()) return true;
    9009     if (jj_scan_token(IDENTIFIER)) return true;
    9010     return false;
    9011   }
    9012
    9013   private boolean jj_3_29() {
    9014     if (jj_scan_token(LPAREN)) return true;
    9015     if (jj_3R_87()) return true;
    9016     return false;
    9017   }
    9018
    9019   private boolean jj_3R_368() {
    9020     if (jj_scan_token(BANG)) return true;
    9021     return false;
    9022   }
    9023
    9024   private boolean jj_3R_78() {
    9025     if (jj_3R_123()) return true;
    9026     Token xsp;
    9027     while (true) {
    9028       xsp = jj_scanpos;
    9029       if (jj_3_30()) { jj_scanpos = xsp; break; }
    9030     }
    9031     return false;
    9032   }
    9033
    9034   private boolean jj_3R_348() {
    9035     if (jj_scan_token(MINUS)) return true;
    9036     return false;
    9037   }
    9038
    9039   private boolean jj_3R_359() {
    9040     if (jj_scan_token(SLASH)) return true;
    9041     return false;
    9042   }
    9043
    9044   private boolean jj_3R_371() {
    9045     if (jj_scan_token(LPAREN)) return true;
    9046     if (jj_3R_73()) return true;
    9047     if (jj_scan_token(RPAREN)) return true;
    9048     if (jj_3R_345()) return true;
    9049     return false;
    9050   }
    9051
    9052   private boolean jj_3R_369() {
    9053     Token xsp;
    9054     xsp = jj_scanpos;
    9055     if (jj_3R_370()) {
    9056     jj_scanpos = xsp;
    9057     if (jj_3R_371()) return true;
    9058     }
    9059     return false;
    9060   }
    9061
    9062   private boolean jj_3R_370() {
    9063     if (jj_scan_token(LPAREN)) return true;
    9064     if (jj_3R_73()) return true;
    9065     if (jj_scan_token(RPAREN)) return true;
    9066     if (jj_3R_319()) return true;
    9067     return false;
    9068   }
    9069
    9070   private boolean jj_3_28() {
    9071     if (jj_scan_token(LPAREN)) return true;
    9072     if (jj_3R_73()) return true;
    9073     if (jj_scan_token(LBRACKET)) return true;
    9074     return false;
    9075   }
    9076
    9077   private boolean jj_3R_242() {
    9078     if (jj_3R_78()) return true;
    9079     Token xsp;
    9080     xsp = jj_scanpos;
    9081     if (jj_3R_392()) jj_scanpos = xsp;
    9082     return false;
    9083   }
    9084
    9085   private boolean jj_3R_133() {
    9086     if (jj_scan_token(LPAREN)) return true;
    9087     if (jj_3R_73()) return true;
    9088     if (jj_scan_token(RPAREN)) return true;
    9089     Token xsp;
    9090     xsp = jj_scanpos;
    9091     if (jj_scan_token(89)) {
    9092     jj_scanpos = xsp;
    9093     if (jj_scan_token(88)) {
    9094     jj_scanpos = xsp;
    9095     if (jj_scan_token(76)) {
    9096     jj_scanpos = xsp;
    9097     if (jj_scan_token(73)) {
    9098     jj_scanpos = xsp;
    9099     if (jj_scan_token(53)) {
    9100     jj_scanpos = xsp;
    9101     if (jj_scan_token(50)) {
    9102     jj_scanpos = xsp;
    9103     if (jj_scan_token(41)) {
    9104     jj_scanpos = xsp;
    9105     if (jj_3R_194()) return true;
    9106     }
    9107     }
    9108     }
    9109     }
    9110     }
    9111     }
    9112     }
    9113     return false;
    9114   }
    9115
    9116   private boolean jj_3_26() {
    9117     if (jj_3R_86()) return true;
    9118     return false;
    9119   }
    9120
    9121   private boolean jj_3R_344() {
    9122     if (jj_scan_token(MINUS)) return true;
    9123     return false;
    9124   }
    9125
    9126   private boolean jj_3R_132() {
    9127     if (jj_scan_token(LPAREN)) return true;
    9128     if (jj_3R_73()) return true;
    9129     if (jj_scan_token(LBRACKET)) return true;
    9130     if (jj_scan_token(RBRACKET)) return true;
    9131     return false;
    9132   }
    9133
    9134   private boolean jj_3R_86() {
    9135     Token xsp;
    9136     xsp = jj_scanpos;
    9137     if (jj_3_27()) {
    9138     jj_scanpos = xsp;
    9139     if (jj_3R_132()) {
    9140     jj_scanpos = xsp;
    9141     if (jj_3R_133()) return true;
    9142     }
    9143     }
    9144     return false;
    9145   }
    9146
    9147   private boolean jj_3_27() {
    9148     if (jj_scan_token(LPAREN)) return true;
    9149     if (jj_3R_87()) return true;
    9150     if (jj_scan_token(RPAREN)) return true;
    9151     return false;
    9152   }
    9153
    9154   private boolean jj_3R_357() {
    9155     if (jj_3R_242()) return true;
    9156     return false;
    9157   }
    9158
    9159   private boolean jj_3R_367() {
    9160     if (jj_scan_token(TILDE)) return true;
    9161     return false;
    9162   }
    9163
    9164   private boolean jj_3R_356() {
    9165     if (jj_3R_369()) return true;
    9166     return false;
    9167   }
    9168
    9169   private boolean jj_3R_355() {
    9170     Token xsp;
    9171     xsp = jj_scanpos;
    9172     if (jj_3R_367()) {
    9173     jj_scanpos = xsp;
    9174     if (jj_3R_368()) return true;
    9175     }
    9176     if (jj_3R_319()) return true;
    9177     return false;
    9178   }
    9179
    9180   private boolean jj_3R_345() {
    9181     Token xsp;
    9182     xsp = jj_scanpos;
    9183     if (jj_3R_355()) {
    9184     jj_scanpos = xsp;
    9185     if (jj_3R_356()) {
    9186     jj_scanpos = xsp;
    9187     if (jj_3R_357()) return true;
    9188     }
    9189     }
    9190     return false;
    9191   }
    9192
    9193   private boolean jj_3R_347() {
    9194     if (jj_scan_token(PLUS)) return true;
    9195     return false;
    9196   }
    9197
    9198   private boolean jj_3R_334() {
    9199     Token xsp;
    9200     xsp = jj_scanpos;
    9201     if (jj_3R_347()) {
    9202     jj_scanpos = xsp;
    9203     if (jj_3R_348()) return true;
    9204     }
    9205     if (jj_3R_307()) return true;
    9206     return false;
    9207   }
    9208
    9209   private boolean jj_3R_358() {
    9210     if (jj_scan_token(STAR)) return true;
    9211     return false;
    9212   }
    9213
    9214   private boolean jj_3R_241() {
    9215     if (jj_scan_token(DECR)) return true;
    9216     if (jj_3R_78()) return true;
    9217     return false;
    9218   }
    9219
    9220   private boolean jj_3R_346() {
    9221     Token xsp;
    9222     xsp = jj_scanpos;
    9223     if (jj_3R_358()) {
    9224     jj_scanpos = xsp;
    9225     if (jj_3R_359()) {
    9226     jj_scanpos = xsp;
    9227     if (jj_3R_360()) return true;
    9228     }
    9229     }
    9230     if (jj_3R_319()) return true;
    9231     return false;
    9232   }
    9233
    9234   private boolean jj_3R_301() {
    9235     if (jj_scan_token(NE)) return true;
    9236     return false;
    9237   }
    9238
    9239   private boolean jj_3R_240() {
    9240     if (jj_scan_token(INCR)) return true;
    9241     if (jj_3R_78()) return true;
    9242     return false;
    9243   }
    9244
    9245   private boolean jj_3R_333() {
    9246     if (jj_3R_345()) return true;
    9247     return false;
    9248   }
    9249
    9250   private boolean jj_3R_332() {
    9251     if (jj_3R_241()) return true;
    9252     return false;
    9253   }
    9254
    9255   private boolean jj_3R_331() {
    9256     if (jj_3R_240()) return true;
    9257     return false;
    9258   }
    9259
    9260   private boolean jj_3R_343() {
    9261     if (jj_scan_token(PLUS)) return true;
    9262     return false;
    9263   }
    9264
    9265   private boolean jj_3R_330() {
    9266     Token xsp;
    9267     xsp = jj_scanpos;
    9268     if (jj_3R_343()) {
    9269     jj_scanpos = xsp;
    9270     if (jj_3R_344()) return true;
    9271     }
    9272     if (jj_3R_319()) return true;
    9273     return false;
    9274   }
    9275
    9276   private boolean jj_3R_319() {
    9277     Token xsp;
    9278     xsp = jj_scanpos;
    9279     if (jj_3R_330()) {
    9280     jj_scanpos = xsp;
    9281     if (jj_3R_331()) {
    9282     jj_scanpos = xsp;
    9283     if (jj_3R_332()) {
    9284     jj_scanpos = xsp;
    9285     if (jj_3R_333()) return true;
    9286     }
    9287     }
    9288     }
    9289     return false;
    9290   }
    9291
    9292   private boolean jj_3R_307() {
    9293     if (jj_3R_319()) return true;
    9294     Token xsp;
    9295     while (true) {
    9296       xsp = jj_scanpos;
    9297       if (jj_3R_346()) { jj_scanpos = xsp; break; }
    9298     }
    9299     return false;
    9300   }
    9301
    9302   private boolean jj_3R_298() {
    9303     if (jj_3R_307()) return true;
    9304     Token xsp;
    9305     while (true) {
    9306       xsp = jj_scanpos;
    9307       if (jj_3R_334()) { jj_scanpos = xsp; break; }
    9308     }
    9309     return false;
    9310   }
    9311
    9312   private boolean jj_3_25() {
    9313     if (jj_3R_85()) return true;
    9314     return false;
    9315   }
    9316
    9317   private boolean jj_3_24() {
    9318     if (jj_3R_84()) return true;
    9319     return false;
    9320   }
    9321
    9322   private boolean jj_3R_299() {
    9323     if (jj_scan_token(INSTANCEOF)) return true;
    9324     if (jj_3R_73()) return true;
    9325     return false;
    9326   }
    9327
    9328   private boolean jj_3R_83() {
    9329     if (jj_scan_token(LSHIFT)) return true;
    9330     return false;
    9331   }
    9332
    9333   private boolean jj_3R_300() {
    9334     if (jj_scan_token(EQ)) return true;
    9335     return false;
    9336   }
    9337
    9338   private boolean jj_3_23() {
    9339     Token xsp;
    9340     xsp = jj_scanpos;
    9341     if (jj_3R_83()) {
    9342     jj_scanpos = xsp;
    9343     if (jj_3_24()) {
    9344     jj_scanpos = xsp;
    9345     if (jj_3_25()) return true;
    9346     }
    9347     }
    9348     if (jj_3R_298()) return true;
    9349     return false;
    9350   }
    9351
    9352   private boolean jj_3R_291() {
    9353     Token xsp;
    9354     xsp = jj_scanpos;
    9355     if (jj_3R_300()) {
    9356     jj_scanpos = xsp;
    9357     if (jj_3R_301()) return true;
    9358     }
    9359     if (jj_3R_283()) return true;
    9360     return false;
    9361   }
    9362
    9363   private boolean jj_3R_290() {
    9364     if (jj_3R_298()) return true;
    9365     Token xsp;
    9366     while (true) {
    9367       xsp = jj_scanpos;
    9368       if (jj_3_23()) { jj_scanpos = xsp; break; }
    9369     }
    9370     return false;
    9371   }
    9372
    9373   private boolean jj_3R_323() {
    9374     if (jj_scan_token(GE)) return true;
    9375     return false;
    9376   }
    9377
    9378   private boolean jj_3R_322() {
    9379     if (jj_scan_token(LE)) return true;
    9380     return false;
    9381   }
    9382
    9383   private boolean jj_3R_321() {
    9384     if (jj_scan_token(GT)) return true;
    9385     return false;
    9386   }
    9387
    9388   private boolean jj_3R_320() {
    9389     if (jj_scan_token(LT)) return true;
    9390     return false;
    9391   }
    9392
    9393   private boolean jj_3R_287() {
    9394     if (jj_scan_token(BIT_AND)) return true;
    9395     if (jj_3R_280()) return true;
    9396     return false;
    9397   }
    9398
    9399   private boolean jj_3R_308() {
    9400     Token xsp;
    9401     xsp = jj_scanpos;
    9402     if (jj_3R_320()) {
    9403     jj_scanpos = xsp;
    9404     if (jj_3R_321()) {
    9405     jj_scanpos = xsp;
    9406     if (jj_3R_322()) {
    9407     jj_scanpos = xsp;
    9408     if (jj_3R_323()) return true;
    9409     }
    9410     }
    9411     }
    9412     if (jj_3R_290()) return true;
    9413     return false;
    9414   }
    9415
    9416   private boolean jj_3R_286() {
    9417     if (jj_3R_290()) return true;
    9418     Token xsp;
    9419     while (true) {
    9420       xsp = jj_scanpos;
    9421       if (jj_3R_308()) { jj_scanpos = xsp; break; }
    9422     }
    9423     return false;
    9424   }
    9425
    9426   private boolean jj_3R_281() {
    9427     if (jj_scan_token(BIT_OR)) return true;
    9428     if (jj_3R_254()) return true;
    9429     return false;
    9430   }
    9431
    9432   private boolean jj_3R_284() {
    9433     if (jj_scan_token(XOR)) return true;
    9434     if (jj_3R_275()) return true;
    9435     return false;
    9436   }
    9437
    9438   private boolean jj_3R_283() {
    9439     if (jj_3R_286()) return true;
    9440     Token xsp;
    9441     xsp = jj_scanpos;
    9442     if (jj_3R_299()) jj_scanpos = xsp;
    9443     return false;
    9444   }
    9445
    9446   private boolean jj_3R_278() {
    9447     if (jj_scan_token(SC_AND)) return true;
    9448     if (jj_3R_239()) return true;
    9449     return false;
    9450   }
    9451
    9452   private boolean jj_3R_280() {
    9453     if (jj_3R_283()) return true;
    9454     Token xsp;
    9455     while (true) {
    9456       xsp = jj_scanpos;
    9457       if (jj_3R_291()) { jj_scanpos = xsp; break; }
    9458     }
    9459     return false;
    9460   }
    9461
    9462   private boolean jj_3R_258() {
    9463     if (jj_scan_token(SC_OR)) return true;
    9464     if (jj_3R_222()) return true;
    9465     return false;
    9466   }
    9467
    9468   private boolean jj_3R_275() {
    9469     if (jj_3R_280()) return true;
    9470     Token xsp;
    9471     while (true) {
    9472       xsp = jj_scanpos;
    9473       if (jj_3R_287()) { jj_scanpos = xsp; break; }
    9474     }
    9475     return false;
    9476   }
    9477
    9478   private boolean jj_3R_247() {
    9479     if (jj_scan_token(HOOK)) return true;
    9480     if (jj_3R_92()) return true;
    9481     if (jj_scan_token(COLON)) return true;
    9482     if (jj_3R_147()) return true;
    9483     return false;
    9484   }
    9485
    9486   private boolean jj_3R_254() {
    9487     if (jj_3R_275()) return true;
    9488     Token xsp;
    9489     while (true) {
    9490       xsp = jj_scanpos;
    9491       if (jj_3R_284()) { jj_scanpos = xsp; break; }
    9492     }
    9493     return false;
    9494   }
    9495
    9496   private boolean jj_3R_239() {
    9497     if (jj_3R_254()) return true;
    9498     Token xsp;
    9499     while (true) {
    9500       xsp = jj_scanpos;
    9501       if (jj_3R_281()) { jj_scanpos = xsp; break; }
    9502     }
    9503     return false;
    9504   }
    9505
    9506   private boolean jj_3R_222() {
    9507     if (jj_3R_239()) return true;
    9508     Token xsp;
    9509     while (true) {
    9510       xsp = jj_scanpos;
    9511       if (jj_3R_278()) { jj_scanpos = xsp; break; }
    9512     }
    9513     return false;
    9514   }
    9515
    9516   private boolean jj_3R_195() {
    9517     if (jj_3R_222()) return true;
    9518     Token xsp;
    9519     while (true) {
    9520       xsp = jj_scanpos;
    9521       if (jj_3R_258()) { jj_scanpos = xsp; break; }
    9522     }
    9523     return false;
    9524   }
    9525
    9526   private boolean jj_3R_147() {
    9527     if (jj_3R_195()) return true;
    9528     Token xsp;
    9529     xsp = jj_scanpos;
    9530     if (jj_3R_247()) jj_scanpos = xsp;
    9531     return false;
    9532   }
    9533
    9534   private boolean jj_3R_270() {
    9535     if (jj_scan_token(ORASSIGN)) return true;
    9536     return false;
    9537   }
    9538
    9539   private boolean jj_3R_269() {
    9540     if (jj_scan_token(XORASSIGN)) return true;
    9541     return false;
    9542   }
    9543
    9544   private boolean jj_3R_268() {
    9545     if (jj_scan_token(ANDASSIGN)) return true;
    9546     return false;
    9547   }
    9548
    9549   private boolean jj_3R_267() {
    9550     if (jj_scan_token(RUNSIGNEDSHIFTASSIGN)) return true;
    9551     return false;
    9552   }
    9553
    9554   private boolean jj_3R_266() {
    9555     if (jj_scan_token(RSIGNEDSHIFTASSIGN)) return true;
    9556     return false;
    9557   }
    9558
    9559   private boolean jj_3R_265() {
    9560     if (jj_scan_token(LSHIFTASSIGN)) return true;
    9561     return false;
    9562   }
    9563
    9564   private boolean jj_3R_264() {
    9565     if (jj_scan_token(MINUSASSIGN)) return true;
    9566     return false;
    9567   }
    9568
    9569   private boolean jj_3R_263() {
    9570     if (jj_scan_token(PLUSASSIGN)) return true;
    9571     return false;
    9572   }
    9573
    9574   private boolean jj_3R_262() {
    9575     if (jj_scan_token(REMASSIGN)) return true;
    9576     return false;
    9577   }
    9578
    9579   private boolean jj_3R_261() {
    9580     if (jj_scan_token(SLASHASSIGN)) return true;
    9581     return false;
    9582   }
    9583
    9584   private boolean jj_3R_260() {
    9585     if (jj_scan_token(STARASSIGN)) return true;
    9586     return false;
    9587   }
    9588
    9589   private boolean jj_3R_248() {
    9590     Token xsp;
    9591     xsp = jj_scanpos;
    9592     if (jj_3R_259()) {
    9593     jj_scanpos = xsp;
    9594     if (jj_3R_260()) {
    9595     jj_scanpos = xsp;
    9596     if (jj_3R_261()) {
    9597     jj_scanpos = xsp;
    9598     if (jj_3R_262()) {
    9599     jj_scanpos = xsp;
    9600     if (jj_3R_263()) {
    9601     jj_scanpos = xsp;
    9602     if (jj_3R_264()) {
    9603     jj_scanpos = xsp;
    9604     if (jj_3R_265()) {
    9605     jj_scanpos = xsp;
    9606     if (jj_3R_266()) {
    9607     jj_scanpos = xsp;
    9608     if (jj_3R_267()) {
    9609     jj_scanpos = xsp;
    9610     if (jj_3R_268()) {
    9611     jj_scanpos = xsp;
    9612     if (jj_3R_269()) {
    9613     jj_scanpos = xsp;
    9614     if (jj_3R_270()) return true;
    9615     }
    9616     }
    9617     }
    9618     }
    9619     }
    9620     }
    9621     }
    9622     }
    9623     }
    9624     }
    9625     }
    9626     return false;
    9627   }
    9628
    9629   private boolean jj_3R_259() {
    9630     if (jj_scan_token(ASSIGN)) return true;
    9631     return false;
    9632   }
    9633
    9634   private boolean jj_3R_237() {
    9635     if (jj_3R_248()) return true;
    9636     if (jj_3R_92()) return true;
    9637     return false;
    9638   }
    9639
    9640   private boolean jj_3R_92() {
    9641     if (jj_3R_147()) return true;
    9642     Token xsp;
    9643     xsp = jj_scanpos;
    9644     if (jj_3R_237()) jj_scanpos = xsp;
    9645     return false;
    9646   }
    9647
    9648   /** Generated Token Manager. */
    9649   public JavaParserTokenManager token_source;
    9650   /** Current token. */
    9651   public Token token;
    9652   /** Next token. */
    9653   public Token jj_nt;
    9654   private Token jj_scanpos, jj_lastpos;
    9655   private int jj_la;
    9656   /** Whether we are looking ahead. */
    9657   private boolean jj_lookingAhead = false;
    9658   private boolean jj_semLA;
    9659   private int jj_gen;
    9660   final private int[] jj_la1 = new int[142];
    9661   static private int[] jj_la1_0;
    9662   static private int[] jj_la1_1;
    9663   static private int[] jj_la1_2;
    9664   static private int[] jj_la1_3;
    9665   static {
    9666       jj_la1_init_0();
    9667       jj_la1_init_1();
    9668       jj_la1_init_2();
    9669       jj_la1_init_3();
    9670    }
    9671    private static void jj_la1_init_0() {
    9672       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,};
    9673    }
    9674    private static void jj_la1_init_1() {
    9675       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,};
    9676    }
    9677    private static void jj_la1_init_2() {
    9678       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,};
    9679    }
    9680    private static void jj_la1_init_3() {
    9681       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,};
    9682    }
    9683   final private JJCalls[] jj_2_rtns = new JJCalls[54];
    9684   private boolean jj_rescan = false;
    9685   private int jj_gc = 0;
    9686
    9687   /** Constructor with user supplied CharStream. */
    9688   public JavaParser(CharStream stream) {
    9689     token_source = new JavaParserTokenManager(stream);
    9690     token = new Token();
    9691     token.next = jj_nt = token_source.getNextToken();
    9692     jj_gen = 0;
    9693     for (int i = 0; i < 142; i++) jj_la1[i] = -1;
    9694     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
    9695   }
    9696
    9697   /** Reinitialise. */
    9698   public void ReInit(CharStream stream) {
    9699     token_source.ReInit(stream);
    9700     token = new Token();
    9701     token.next = jj_nt = token_source.getNextToken();
    9702     jj_lookingAhead = false;
    9703     jjtree.reset();
    9704     jj_gen = 0;
    9705     for (int i = 0; i < 142; i++) jj_la1[i] = -1;
    9706     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
    9707   }
    9708
    9709   /** Constructor with generated Token Manager. */
    9710   public JavaParser(JavaParserTokenManager tm) {
    9711     token_source = tm;
    9712     token = new Token();
    9713     token.next = jj_nt = token_source.getNextToken();
    9714     jj_gen = 0;
    9715     for (int i = 0; i < 142; i++) jj_la1[i] = -1;
    9716     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
    9717   }
    9718
    9719   /** Reinitialise. */
    9720   public void ReInit(JavaParserTokenManager tm) {
    9721     token_source = tm;
    9722     token = new Token();
    9723     token.next = jj_nt = token_source.getNextToken();
    9724     jjtree.reset();
    9725     jj_gen = 0;
    9726     for (int i = 0; i < 142; i++) jj_la1[i] = -1;
    9727     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
    9728   }
    9729
    9730   private Token jj_consume_token(int kind) throws ParseException {
    9731     Token oldToken = token;
    9732     if ((token = jj_nt).next != null) jj_nt = jj_nt.next;
    9733     else jj_nt = jj_nt.next = token_source.getNextToken();
    9734     if (token.kind == kind) {
    9735       jj_gen++;
    9736       if (++jj_gc > 100) {
    9737         jj_gc = 0;
    9738         for (int i = 0; i < jj_2_rtns.length; i++) {
    9739           JJCalls c = jj_2_rtns[i];
    9740           while (c != null) {
    9741             if (c.gen < jj_gen) c.first = null;
    9742             c = c.next;
    9743           }
    9744         }
    9745       }
    9746       return token;
    9747     }
    9748     jj_nt = token;
    9749     token = oldToken;
    9750     jj_kind = kind;
    9751     throw generateParseException();
    9752   }
    9753
    9754   static private final class LookaheadSuccess extends java.lang.Error { }
    9755   final private LookaheadSuccess jj_ls = new LookaheadSuccess();
    9756   private boolean jj_scan_token(int kind) {
    9757     if (jj_scanpos == jj_lastpos) {
    9758       jj_la--;
    9759       if (jj_scanpos.next == null) {
    9760         jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
    9761       } else {
    9762         jj_lastpos = jj_scanpos = jj_scanpos.next;
    9763       }
    9764     } else {
    9765       jj_scanpos = jj_scanpos.next;
    9766     }
    9767     if (jj_rescan) {
    9768       int i = 0; Token tok = token;
    9769       while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; }
    9770       if (tok != null) jj_add_error_token(kind, i);
    9771     }
    9772     if (jj_scanpos.kind != kind) return true;
    9773     if (jj_la == 0 && jj_scanpos == jj_lastpos) throw jj_ls;
    9774     return false;
    9775   }
    9776
    9777
    9778 /** Get the next Token. */
    9779   final public Token getNextToken() {
    9780     if ((token = jj_nt).next != null) jj_nt = jj_nt.next;
    9781     else jj_nt = jj_nt.next = token_source.getNextToken();
    9782     jj_gen++;
    9783     return token;
    9784   }
    9785
    9786 /** Get the specific Token. */
    9787   final public Token getToken(int index) {
    9788     Token t = jj_lookingAhead ? jj_scanpos : token;
    9789     for (int i = 0; i < index; i++) {
    9790       if (t.next != null) t = t.next;
    9791       else t = t.next = token_source.getNextToken();
    9792     }
    9793     return t;
    9794   }
    9795
    9796   private java.util.List<int[]> jj_expentries = new java.util.ArrayList<int[]>();
    9797   private int[] jj_expentry;
    9798   private int jj_kind = -1;
    9799   private int[] jj_lasttokens = new int[100];
    9800   private int jj_endpos;
    9801
    9802   private void jj_add_error_token(int kind, int pos) {
    9803     if (pos >= 100) return;
    9804     if (pos == jj_endpos + 1) {
    9805       jj_lasttokens[jj_endpos++] = kind;
    9806     } else if (jj_endpos != 0) {
    9807       jj_expentry = new int[jj_endpos];
    9808       for (int i = 0; i < jj_endpos; i++) {
    9809         jj_expentry[i] = jj_lasttokens[i];
    9810       }
    9811       jj_entries_loop: for (java.util.Iterator it = jj_expentries.iterator(); it.hasNext();) {
    9812         int[] oldentry = (int[])(it.next());
    9813         if (oldentry.length == jj_expentry.length) {
    9814           for (int i = 0; i < jj_expentry.length; i++) {
    9815             if (oldentry[i] != jj_expentry[i]) {
    9816               continue jj_entries_loop;
    9817             }
    9818           }
    9819           jj_expentries.add(jj_expentry);
    9820           break jj_entries_loop;
    9821         }
    9822       }
    9823       if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind;
    9824     }
    9825   }
    9826
    9827   /** Generate ParseException. */
    9828   public ParseException generateParseException() {
    9829     jj_expentries.clear();
    9830     boolean[] la1tokens = new boolean[126];
    9831     if (jj_kind >= 0) {
    9832       la1tokens[jj_kind] = true;
    9833       jj_kind = -1;
    9834     }
    9835     for (int i = 0; i < 142; i++) {
    9836       if (jj_la1[i] == jj_gen) {
    9837         for (int j = 0; j < 32; j++) {
    9838           if ((jj_la1_0[i] & (1<<j)) != 0) {
    9839             la1tokens[j] = true;
    9840           }
    9841           if ((jj_la1_1[i] & (1<<j)) != 0) {
    9842             la1tokens[32+j] = true;
    9843           }
    9844           if ((jj_la1_2[i] & (1<<j)) != 0) {
    9845             la1tokens[64+j] = true;
    9846           }
    9847           if ((jj_la1_3[i] & (1<<j)) != 0) {
    9848             la1tokens[96+j] = true;
    9849           }
    9850         }
    9851       }
    9852     }
    9853     for (int i = 0; i < 126; i++) {
    9854       if (la1tokens[i]) {
    9855         jj_expentry = new int[1];
    9856         jj_expentry[0] = i;
    9857         jj_expentries.add(jj_expentry);
    9858       }
    9859     }
    9860     jj_endpos = 0;
    9861     jj_rescan_token();
    9862     jj_add_error_token(0, 0);
    9863     int[][] exptokseq = new int[jj_expentries.size()][];
    9864     for (int i = 0; i < jj_expentries.size(); i++) {
    9865       exptokseq[i] = jj_expentries.get(i);
    9866     }
    9867     return new ParseException(token, exptokseq, tokenImage);
    9868   }
    9869
    9870   /** Enable tracing. */
    9871   final public void enable_tracing() {
    9872   }
    9873
    9874   /** Disable tracing. */
    9875   final public void disable_tracing() {
    9876   }
    9877
    9878   private void jj_rescan_token() {
    9879     jj_rescan = true;
    9880     for (int i = 0; i < 54; i++) {
    9881     try {
    9882       JJCalls p = jj_2_rtns[i];
    9883       do {
    9884         if (p.gen > jj_gen) {
    9885           jj_la = p.arg; jj_lastpos = jj_scanpos = p.first;
    9886           switch (i) {
    9887             case 0: jj_3_1(); break;
    9888             case 1: jj_3_2(); break;
    9889             case 2: jj_3_3(); break;
    9890             case 3: jj_3_4(); break;
    9891             case 4: jj_3_5(); break;
    9892             case 5: jj_3_6(); break;
    9893             case 6: jj_3_7(); break;
    9894             case 7: jj_3_8(); break;
    9895             case 8: jj_3_9(); break;
    9896             case 9: jj_3_10(); break;
    9897             case 10: jj_3_11(); break;
    9898             case 11: jj_3_12(); break;
    9899             case 12: jj_3_13(); break;
    9900             case 13: jj_3_14(); break;
    9901             case 14: jj_3_15(); break;
    9902             case 15: jj_3_16(); break;
    9903             case 16: jj_3_17(); break;
    9904             case 17: jj_3_18(); break;
    9905             case 18: jj_3_19(); break;
    9906             case 19: jj_3_20(); break;
    9907             case 20: jj_3_21(); break;
    9908             case 21: jj_3_22(); break;
    9909             case 22: jj_3_23(); break;
    9910             case 23: jj_3_24(); break;
    9911             case 24: jj_3_25(); break;
    9912             case 25: jj_3_26(); break;
    9913             case 26: jj_3_27(); break;
    9914             case 27: jj_3_28(); break;
    9915             case 28: jj_3_29(); break;
    9916             case 29: jj_3_30(); break;
    9917             case 30: jj_3_31(); break;
    9918             case 31: jj_3_32(); break;
    9919             case 32: jj_3_33(); break;
    9920             case 33: jj_3_34(); break;
    9921             case 34: jj_3_35(); break;
    9922             case 35: jj_3_36(); break;
    9923             case 36: jj_3_37(); break;
    9924             case 37: jj_3_38(); break;
    9925             case 38: jj_3_39(); break;
    9926             case 39: jj_3_40(); break;
    9927             case 40: jj_3_41(); break;
    9928             case 41: jj_3_42(); break;
    9929             case 42: jj_3_43(); break;
    9930             case 43: jj_3_44(); break;
    9931             case 44: jj_3_45(); break;
    9932             case 45: jj_3_46(); break;
    9933             case 46: jj_3_47(); break;
    9934             case 47: jj_3_48(); break;
    9935             case 48: jj_3_49(); break;
    9936             case 49: jj_3_50(); break;
    9937             case 50: jj_3_51(); break;
    9938             case 51: jj_3_52(); break;
    9939             case 52: jj_3_53(); break;
    9940             case 53: jj_3_54(); break;
    9941           }
    9942         }
    9943         p = p.next;
    9944       } while (p != null);
    9945       } catch(LookaheadSuccess ls) { }
    9946     }
    9947     jj_rescan = false;
    9948   }
    9949
    9950   private void jj_save(int index, int xla) {
    9951     JJCalls p = jj_2_rtns[index];
    9952     while (p.gen > jj_gen) {
    9953       if (p.next == null) { p = p.next = new JJCalls(); break; }
    9954       p = p.next;
    9955     }
    9956     p.gen = jj_gen + xla - jj_la; p.first = token; p.arg = xla;
    9957   }
    9958
    9959   static final class JJCalls {
    9960     int gen;
    9961     Token first;
    9962     int arg;
    9963     JJCalls next;
    9964   }
    9965
    9966 }