0001 /* Generated By:JJTree&JavaCC: Do not edit this line. JJTreeParser.java */
0002 package com.javadoq.jjtree;
0003 
0004 public class JJTreeParser/*@bgen(jjtree)*/implements JJTreeParserTreeConstants, JJTreeParserConstants {/*@bgen(jjtree)*/
0005   protected JJTJJTreeParserState jjtree = new JJTJJTreeParserState();
0006         void jjtreeOpenNodeScope(Node n) {
0007                 ((ASTNode)n).firstToken = getToken(1);
0008         }
0009 
0010         void jjtreeCloseNodeScope(Node n) {
0011                 ((ASTNode)n).lastToken = getToken(0);
0012         }
0013 
0014 
0015   /**
0016    * Returns true if the next token is not in the FOLLOW list of "expansion".
0017    * It is used to decide when the end of an "expansion" has been reached.
0018    */
0019   private boolean notTailOfExpansionUnit() {
0020     Token t;
0021     t = getToken(1);
0022     if (t.kind == BIT_OR || t.kind == COMMA || t.kind == RPAREN || t.kind == RBRACE || t.kind == RBRACKET) return false;
0023     return true;
0024   }
0025 
0026 /************************************************
0027  * THE JAVACC GRAMMAR SPECIFICATION STARTS HERE *
0028  ************************************************/
0029   final public ASTGrammar javacc_input() throws ParseException {
0030  /*@bgen(jjtree) Grammar */
0031   ASTGrammar jjtn000 = new ASTGrammar(this, JJTGRAMMAR);
0032   boolean jjtc000 = true;
0033   jjtree.openNodeScope(jjtn000);
0034   jjtreeOpenNodeScope(jjtn000);
0035     try {
0036       javacc_options();
0037       jj_consume_token(_PARSER_BEGIN);
0038       jj_consume_token(LPAREN);
0039       identifier();
0040       jj_consume_token(RPAREN);
0041       CompilationUnit();
0042       jj_consume_token(_PARSER_END);
0043       jj_consume_token(LPAREN);
0044       identifier();
0045       jj_consume_token(RPAREN);
0046       label_1:
0047       while (true) {
0048         production();
0049         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
0050         case _LOOKAHEAD:
0051         case _IGNORE_CASE:
0052         case _PARSER_BEGIN:
0053         case _PARSER_END:
0054         case _JAVACODE:
0055         case _TOKEN:
0056         case _SPECIAL_TOKEN:
0057         case _MORE:
0058         case _SKIP:
0059         case _TOKEN_MGR_DECLS:
0060         case _EOF:
0061         case BOOLEAN:
0062         case BYTE:
0063         case CHAR:
0064         case DOUBLE:
0065         case FLOAT:
0066         case INT:
0067         case LONG:
0068         case PRIVATE:
0069         case PROTECTED:
0070         case PUBLIC:
0071         case SHORT:
0072         case VOID:
0073         case LT:
0074         case IDENTIFIER:
0075           ;
0076           break;
0077         default:
0078           jj_la1[0] = jj_gen;
0079           break label_1;
0080         }
0081       }
0082       jj_consume_token(0);
0083     jjtree.closeNodeScope(jjtn000, true);
0084     jjtc000 = false;
0085     jjtreeCloseNodeScope(jjtn000);
0086     {if (true) return jjtn000;}
0087     } catch (Throwable jjte000) {
0088     if (jjtc000) {
0089       jjtree.clearNodeScope(jjtn000);
0090       jjtc000 = false;
0091     } else {
0092       jjtree.popNode();
0093     }
0094     if (jjte000 instanceof RuntimeException) {
0095       {if (true) throw (RuntimeException)jjte000;}
0096     }
0097     if (jjte000 instanceof ParseException) {
0098       {if (true) throw (ParseException)jjte000;}
0099     }
0100     {if (true) throw (Error)jjte000;}
0101     } finally {
0102     if (jjtc000) {
0103       jjtree.closeNodeScope(jjtn000, true);
0104       jjtreeCloseNodeScope(jjtn000);
0105     }
0106     }
0107     throw new Error("Missing return statement in function");
0108   }
0109 
0110   final public void javacc_options() throws ParseException {
0111     if (getToken(1).image.equals("options")) {
0112       jj_consume_token(IDENTIFIER);
0113       jj_consume_token(LBRACE);
0114       label_2:
0115       while (true) {
0116         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
0117         case _LOOKAHEAD:
0118         case _IGNORE_CASE:
0119         case STATIC:
0120         case IDENTIFIER:
0121           ;
0122           break;
0123         default:
0124           jj_la1[1] = jj_gen;
0125           break label_2;
0126         }
0127         option_binding();
0128       }
0129       jj_consume_token(RBRACE);
0130     } else {
0131       ;
0132     }
0133   }
0134 
0135   final public void option_binding() throws ParseException {
0136     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
0137     case IDENTIFIER:
0138       jj_consume_token(IDENTIFIER);
0139       break;
0140     case _LOOKAHEAD:
0141       jj_consume_token(_LOOKAHEAD);
0142       break;
0143     case _IGNORE_CASE:
0144       jj_consume_token(_IGNORE_CASE);
0145       break;
0146     case STATIC:
0147       jj_consume_token(STATIC);
0148       break;
0149     default:
0150       jj_la1[2] = jj_gen;
0151       jj_consume_token(-1);
0152       throw new ParseException();
0153     }
0154     jj_consume_token(ASSIGN);
0155     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
0156     case INTEGER_LITERAL:
0157       IntegerLiteral();
0158       break;
0159     case FALSE:
0160     case TRUE:
0161       BooleanLiteral();
0162       break;
0163     case STRING_LITERAL:
0164       StringLiteral();
0165       break;
0166     default:
0167       jj_la1[3] = jj_gen;
0168       jj_consume_token(-1);
0169       throw new ParseException();
0170     }
0171     jj_consume_token(SEMICOLON);
0172   }
0173 
0174   final public void production() throws ParseException {
0175     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
0176     case _JAVACODE:
0177       javacode_production();
0178       break;
0179     case _TOKEN:
0180     case _SPECIAL_TOKEN:
0181     case _MORE:
0182     case _SKIP:
0183     case LT:
0184       regular_expr_production();
0185       break;
0186     case _TOKEN_MGR_DECLS:
0187       token_manager_decls();
0188       break;
0189     case _LOOKAHEAD:
0190     case _IGNORE_CASE:
0191     case _PARSER_BEGIN:
0192     case _PARSER_END:
0193     case _EOF:
0194     case BOOLEAN:
0195     case BYTE:
0196     case CHAR:
0197     case DOUBLE:
0198     case FLOAT:
0199     case INT:
0200     case LONG:
0201     case PRIVATE:
0202     case PROTECTED:
0203     case PUBLIC:
0204     case SHORT:
0205     case VOID:
0206     case IDENTIFIER:
0207       bnf_production();
0208       break;
0209     default:
0210       jj_la1[4] = jj_gen;
0211       jj_consume_token(-1);
0212       throw new ParseException();
0213     }
0214   }
0215 
0216   final public void javacode_production() throws ParseException {
0217     jj_consume_token(_JAVACODE);
0218     AccessModifier();
0219     ResultType();
0220     identifier();
0221     FormalParameters();
0222     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
0223     case THROWS:
0224       jj_consume_token(THROWS);
0225       Name();
0226       label_3:
0227       while (true) {
0228         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
0229         case COMMA:
0230           ;
0231           break;
0232         default:
0233           jj_la1[5] = jj_gen;
0234           break label_3;
0235         }
0236         jj_consume_token(COMMA);
0237         Name();
0238       }
0239       break;
0240     default:
0241       jj_la1[6] = jj_gen;
0242       ;
0243     }
0244     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
0245     case 130:
0246       node_descriptor();
0247       break;
0248     default:
0249       jj_la1[7] = jj_gen;
0250       ;
0251     }
0252     jj_consume_token(LBRACE);
0253     label_4:
0254     while (true) {
0255       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
0256       case _LOOKAHEAD:
0257       case _IGNORE_CASE:
0258       case _PARSER_BEGIN:
0259       case _PARSER_END:
0260       case _JAVACODE:
0261       case _TOKEN:
0262       case _SPECIAL_TOKEN:
0263       case _MORE:
0264       case _SKIP:
0265       case _TOKEN_MGR_DECLS:
0266       case _EOF:
0267       case ABSTRACT:
0268       case BOOLEAN:
0269       case BREAK:
0270       case BYTE:
0271       case CHAR:
0272       case CLASS:
0273       case CONTINUE:
0274       case DO:
0275       case DOUBLE:
0276       case FALSE:
0277       case FINAL:
0278       case FLOAT:
0279       case FOR:
0280       case IF:
0281       case INT:
0282       case INTERFACE:
0283       case LONG:
0284       case NATIVE:
0285       case NEW:
0286       case NULL:
0287       case PRIVATE:
0288       case PROTECTED:
0289       case PUBLIC:
0290       case RETURN:
0291       case SHORT:
0292       case STATIC:
0293       case STRICTFP:
0294       case SUPER:
0295       case SWITCH:
0296       case SYNCHRONIZED:
0297       case THIS:
0298       case THROW:
0299       case TRANSIENT:
0300       case TRUE:
0301       case TRY:
0302       case VOID:
0303       case VOLATILE:
0304       case WHILE:
0305       case INTEGER_LITERAL:
0306       case FLOATING_POINT_LITERAL:
0307       case CHARACTER_LITERAL:
0308       case STRING_LITERAL:
0309       case LPAREN:
0310       case LBRACE:
0311       case SEMICOLON:
0312       case AT:
0313       case INCR:
0314       case DECR:
0315       case 136:
0316       case IDENTIFIER:
0317         ;
0318         break;
0319       default:
0320         jj_la1[8] = jj_gen;
0321         break label_4;
0322       }
0323       BlockStatement();
0324     }
0325     jj_consume_token(RBRACE);
0326   }
0327 
0328   final public void bnf_production() throws ParseException {
0329     AccessModifier();
0330     ResultType();
0331     identifier();
0332     FormalParameters();
0333     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
0334     case THROWS:
0335       jj_consume_token(THROWS);
0336       Name();
0337       label_5:
0338       while (true) {
0339         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
0340         case COMMA:
0341           ;
0342           break;
0343         default:
0344           jj_la1[9] = jj_gen;
0345           break label_5;
0346         }
0347         jj_consume_token(COMMA);
0348         Name();
0349       }
0350       break;
0351     default:
0352       jj_la1[10] = jj_gen;
0353       ;
0354     }
0355     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
0356     case 130:
0357       node_descriptor();
0358       break;
0359     default:
0360       jj_la1[11] = jj_gen;
0361       ;
0362     }
0363     jj_consume_token(COLON);
0364     jj_consume_token(LBRACE);
0365     label_6:
0366     while (true) {
0367       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
0368       case _LOOKAHEAD:
0369       case _IGNORE_CASE:
0370       case _PARSER_BEGIN:
0371       case _PARSER_END:
0372       case _JAVACODE:
0373       case _TOKEN:
0374       case _SPECIAL_TOKEN:
0375       case _MORE:
0376       case _SKIP:
0377       case _TOKEN_MGR_DECLS:
0378       case _EOF:
0379       case ABSTRACT:
0380       case BOOLEAN:
0381       case BREAK:
0382       case BYTE:
0383       case CHAR:
0384       case CLASS:
0385       case CONTINUE:
0386       case DO:
0387       case DOUBLE:
0388       case FALSE:
0389       case FINAL:
0390       case FLOAT:
0391       case FOR:
0392       case IF:
0393       case INT:
0394       case INTERFACE:
0395       case LONG:
0396       case NATIVE:
0397       case NEW:
0398       case NULL:
0399       case PRIVATE:
0400       case PROTECTED:
0401       case PUBLIC:
0402       case RETURN:
0403       case SHORT:
0404       case STATIC:
0405       case STRICTFP:
0406       case SUPER:
0407       case SWITCH:
0408       case SYNCHRONIZED:
0409       case THIS:
0410       case THROW:
0411       case TRANSIENT:
0412       case TRUE:
0413       case TRY:
0414       case VOID:
0415       case VOLATILE:
0416       case WHILE:
0417       case INTEGER_LITERAL:
0418       case FLOATING_POINT_LITERAL:
0419       case CHARACTER_LITERAL:
0420       case STRING_LITERAL:
0421       case LPAREN:
0422       case LBRACE:
0423       case SEMICOLON:
0424       case AT:
0425       case INCR:
0426       case DECR:
0427       case 136:
0428       case IDENTIFIER:
0429         ;
0430         break;
0431       default:
0432         jj_la1[12] = jj_gen;
0433         break label_6;
0434       }
0435       BlockStatement();
0436     }
0437     jj_consume_token(RBRACE);
0438     jj_consume_token(LBRACE);
0439     expansion_choices();
0440     jj_consume_token(RBRACE);
0441   }
0442 
0443   final public void AccessModifier() throws ParseException {
0444     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
0445     case PRIVATE:
0446     case PROTECTED:
0447     case PUBLIC:
0448       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
0449       case PUBLIC:
0450         jj_consume_token(PUBLIC);
0451         break;
0452       case PROTECTED:
0453         jj_consume_token(PROTECTED);
0454         break;
0455       case PRIVATE:
0456         jj_consume_token(PRIVATE);
0457         break;
0458       default:
0459         jj_la1[13] = jj_gen;
0460         jj_consume_token(-1);
0461         throw new ParseException();
0462       }
0463       break;
0464     default:
0465       jj_la1[14] = jj_gen;
0466       ;
0467     }
0468   }
0469 
0470   final public void regular_expr_production() throws ParseException {
0471     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
0472     case LT:
0473       if (jj_2_1(2)) {
0474         jj_consume_token(LT);
0475         jj_consume_token(STAR);
0476         jj_consume_token(GT);
0477       } else {
0478         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
0479         case LT:
0480           jj_consume_token(LT);
0481           jj_consume_token(IDENTIFIER);
0482           label_7:
0483           while (true) {
0484             switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
0485             case COMMA:
0486               ;
0487               break;
0488             default:
0489               jj_la1[15] = jj_gen;
0490               break label_7;
0491             }
0492             jj_consume_token(COMMA);
0493             jj_consume_token(IDENTIFIER);
0494           }
0495           jj_consume_token(GT);
0496           break;
0497         default:
0498           jj_la1[16] = jj_gen;
0499           jj_consume_token(-1);
0500           throw new ParseException();
0501         }
0502       }
0503       break;
0504     default:
0505       jj_la1[17] = jj_gen;
0506       ;
0507     }
0508     regexpr_kind();
0509     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
0510     case LBRACKET:
0511       jj_consume_token(LBRACKET);
0512       jj_consume_token(_IGNORE_CASE);
0513       jj_consume_token(RBRACKET);
0514       break;
0515     default:
0516       jj_la1[18] = jj_gen;
0517       ;
0518     }
0519     jj_consume_token(COLON);
0520     jj_consume_token(LBRACE);
0521     regexpr_spec();
0522     label_8:
0523     while (true) {
0524       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
0525       case BIT_OR:
0526         ;
0527         break;
0528       default:
0529         jj_la1[19] = jj_gen;
0530         break label_8;
0531       }
0532       jj_consume_token(BIT_OR);
0533       regexpr_spec();
0534     }
0535     jj_consume_token(RBRACE);
0536   }
0537 
0538   final public void token_manager_decls() throws ParseException {
0539     jj_consume_token(_TOKEN_MGR_DECLS);
0540     jj_consume_token(COLON);
0541     ClassOrInterfaceBody(false);
0542   }
0543 
0544   final public void regexpr_kind() throws ParseException {
0545     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
0546     case _TOKEN:
0547       jj_consume_token(_TOKEN);
0548       break;
0549     case _SPECIAL_TOKEN:
0550       jj_consume_token(_SPECIAL_TOKEN);
0551       break;
0552     case _SKIP:
0553       jj_consume_token(_SKIP);
0554       break;
0555     case _MORE:
0556       jj_consume_token(_MORE);
0557       break;
0558     default:
0559       jj_la1[20] = jj_gen;
0560       jj_consume_token(-1);
0561       throw new ParseException();
0562     }
0563   }
0564 
0565   final public void regexpr_spec() throws ParseException {
0566     regular_expression();
0567     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
0568     case LBRACE:
0569       Block();
0570       break;
0571     default:
0572       jj_la1[21] = jj_gen;
0573       ;
0574     }
0575     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
0576     case COLON:
0577       jj_consume_token(COLON);
0578       jj_consume_token(IDENTIFIER);
0579       break;
0580     default:
0581       jj_la1[22] = jj_gen;
0582       ;
0583     }
0584   }
0585 
0586   final public void expansion_choices() throws ParseException {
0587     expansion();
0588     label_9:
0589     while (true) {
0590       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
0591       case BIT_OR:
0592         ;
0593         break;
0594       default:
0595         jj_la1[23] = jj_gen;
0596         break label_9;
0597       }
0598       jj_consume_token(BIT_OR);
0599       expansion();
0600     }
0601   }
0602 
0603   final public void expansion() throws ParseException {
0604     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
0605     case _LOOKAHEAD:
0606       jj_consume_token(_LOOKAHEAD);
0607       jj_consume_token(LPAREN);
0608       local_lookahead();
0609       jj_consume_token(RPAREN);
0610       break;
0611     default:
0612       jj_la1[24] = jj_gen;
0613       ;
0614     }
0615     label_10:
0616     while (true) {
0617       expansion_unit();
0618       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
0619       case 130:
0620         node_descriptor();
0621         break;
0622       default:
0623         jj_la1[25] = jj_gen;
0624         ;
0625       }
0626       if (notTailOfExpansionUnit()) {
0627         ;
0628       } else {
0629         break label_10;
0630       }
0631     }
0632   }
0633 
0634   final public void local_lookahead() throws ParseException {
0635   boolean commaAtEnd = false, emptyLA = true;
0636     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
0637     case INTEGER_LITERAL:
0638       IntegerLiteral();
0639           emptyLA = false;
0640       break;
0641     default:
0642       jj_la1[26] = jj_gen;
0643       ;
0644     }
0645     if (!emptyLA && (getToken(1).kind != RPAREN)) {
0646       jj_consume_token(COMMA);
0647           commaAtEnd = true;
0648     } else {
0649       ;
0650     }
0651     if (getToken(1).kind != RPAREN && getToken(1).kind != LBRACE) {
0652       expansion_choices();
0653           emptyLA = false; commaAtEnd = false;
0654     } else {
0655       ;
0656     }
0657     if (!emptyLA && !commaAtEnd && (getToken(1).kind != RPAREN)) {
0658       jj_consume_token(COMMA);
0659           commaAtEnd = true;
0660     } else {
0661       ;
0662     }
0663     if (emptyLA || commaAtEnd) {
0664       jj_consume_token(LBRACE);
0665       Expression();
0666       jj_consume_token(RBRACE);
0667     } else {
0668       ;
0669     }
0670   }
0671 
0672   final public void expansion_unit() throws ParseException {
0673     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
0674     case _LOOKAHEAD:
0675       jj_consume_token(_LOOKAHEAD);
0676       jj_consume_token(LPAREN);
0677       local_lookahead();
0678       jj_consume_token(RPAREN);
0679       break;
0680     case LBRACE:
0681       Block();
0682       break;
0683     case LBRACKET:
0684       jj_consume_token(LBRACKET);
0685       expansion_choices();
0686       jj_consume_token(RBRACKET);
0687       break;
0688     case TRY:
0689       jj_consume_token(TRY);
0690       jj_consume_token(LBRACE);
0691       expansion_choices();
0692       jj_consume_token(RBRACE);
0693       label_11:
0694       while (true) {
0695         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
0696         case CATCH:
0697           ;
0698           break;
0699         default:
0700           jj_la1[27] = jj_gen;
0701           break label_11;
0702         }
0703         jj_consume_token(CATCH);
0704         jj_consume_token(LPAREN);
0705         Name();
0706         jj_consume_token(IDENTIFIER);
0707         jj_consume_token(RPAREN);
0708         Block();
0709       }
0710       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
0711       case FINALLY:
0712         jj_consume_token(FINALLY);
0713         Block();
0714         break;
0715       default:
0716         jj_la1[28] = jj_gen;
0717         ;
0718       }
0719       break;
0720     default:
0721       jj_la1[32] = jj_gen;
0722       if (jj_2_3(2147483647)) {
0723         if (jj_2_2(2147483647)) {
0724           PrimaryExpression();
0725           jj_consume_token(ASSIGN);
0726         } else {
0727           ;
0728         }
0729         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
0730         case STRING_LITERAL:
0731         case LT:
0732           regular_expression();
0733           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
0734           case DOT:
0735             jj_consume_token(DOT);
0736             jj_consume_token(IDENTIFIER);
0737             break;
0738           default:
0739             jj_la1[29] = jj_gen;
0740             ;
0741           }
0742           break;
0743         case IDENTIFIER:
0744           identifier();
0745           Arguments();
0746           break;
0747         default:
0748           jj_la1[30] = jj_gen;
0749           jj_consume_token(-1);
0750           throw new ParseException();
0751         }
0752       } else {
0753         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
0754         case LPAREN:
0755           jj_consume_token(LPAREN);
0756           expansion_choices();
0757           jj_consume_token(RPAREN);
0758           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
0759           case PLUS:
0760             jj_consume_token(PLUS);
0761             break;
0762           case STAR:
0763             jj_consume_token(STAR);
0764             break;
0765           case HOOK:
0766             jj_consume_token(HOOK);
0767             break;
0768           default:
0769             jj_la1[31] = jj_gen;
0770 
0771           }
0772           break;
0773         default:
0774           jj_la1[33] = jj_gen;
0775           jj_consume_token(-1);
0776           throw new ParseException();
0777         }
0778       }
0779     }
0780   }
0781 
0782   final public void regular_expression() throws ParseException {
0783     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
0784     case STRING_LITERAL:
0785       StringLiteral();
0786       break;
0787     default:
0788       jj_la1[36] = jj_gen;
0789       if (jj_2_4(3)) {
0790         jj_consume_token(LT);
0791         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
0792         case 130:
0793         case IDENTIFIER:
0794           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
0795           case 130:
0796             jj_consume_token(130);
0797             break;
0798           default:
0799             jj_la1[34] = jj_gen;
0800             ;
0801           }
0802           identifier();
0803           jj_consume_token(COLON);
0804           break;
0805         default:
0806           jj_la1[35] = jj_gen;
0807           ;
0808         }
0809         complex_regular_expression_choices();
0810         jj_consume_token(GT);
0811       } else if (jj_2_5(2)) {
0812         jj_consume_token(LT);
0813         identifier();
0814         jj_consume_token(GT);
0815       } else {
0816         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
0817         case LT:
0818           jj_consume_token(LT);
0819           jj_consume_token(_EOF);
0820           jj_consume_token(GT);
0821           break;
0822         default:
0823           jj_la1[37] = jj_gen;
0824           jj_consume_token(-1);
0825           throw new ParseException();
0826         }
0827       }
0828     }
0829   }
0830 
0831   final public void complex_regular_expression_choices() throws ParseException {
0832     complex_regular_expression();
0833     label_12:
0834     while (true) {
0835       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
0836       case BIT_OR:
0837         ;
0838         break;
0839       default:
0840         jj_la1[38] = jj_gen;
0841         break label_12;
0842       }
0843       jj_consume_token(BIT_OR);
0844       complex_regular_expression();
0845     }
0846   }
0847 
0848   final public void complex_regular_expression() throws ParseException {
0849     label_13:
0850     while (true) {
0851       complex_regular_expression_unit();
0852       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
0853       case STRING_LITERAL:
0854       case LPAREN:
0855       case LBRACKET:
0856       case LT:
0857       case TILDE:
0858         ;
0859         break;
0860       default:
0861         jj_la1[39] = jj_gen;
0862         break label_13;
0863       }
0864     }
0865   }
0866 
0867   final public void complex_regular_expression_unit() throws ParseException {
0868     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
0869     case STRING_LITERAL:
0870       StringLiteral();
0871       break;
0872     case LT:
0873       jj_consume_token(LT);
0874       identifier();
0875       jj_consume_token(GT);
0876       break;
0877     case LBRACKET:
0878     case TILDE:
0879       character_list();
0880       break;
0881     case LPAREN:
0882       jj_consume_token(LPAREN);
0883       complex_regular_expression_choices();
0884       jj_consume_token(RPAREN);
0885       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
0886       case PLUS:
0887         jj_consume_token(PLUS);
0888         break;
0889       case STAR:
0890         jj_consume_token(STAR);
0891         break;
0892       case HOOK:
0893         jj_consume_token(HOOK);
0894         break;
0895       case LBRACE:
0896         jj_consume_token(LBRACE);
0897         IntegerLiteral();
0898         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
0899         case COMMA:
0900           jj_consume_token(COMMA);
0901           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
0902           case INTEGER_LITERAL:
0903             IntegerLiteral();
0904             break;
0905           default:
0906             jj_la1[40] = jj_gen;
0907             ;
0908           }
0909           break;
0910         default:
0911           jj_la1[41] = jj_gen;
0912           ;
0913         }
0914         jj_consume_token(RBRACE);
0915         break;
0916       default:
0917         jj_la1[42] = jj_gen;
0918 
0919       }
0920       break;
0921     default:
0922       jj_la1[43] = jj_gen;
0923       jj_consume_token(-1);
0924       throw new ParseException();
0925     }
0926   }
0927 
0928   final public void character_list() throws ParseException {
0929     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
0930     case TILDE:
0931       jj_consume_token(TILDE);
0932       break;
0933     default:
0934       jj_la1[44] = jj_gen;
0935       ;
0936     }
0937     jj_consume_token(LBRACKET);
0938     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
0939     case STRING_LITERAL:
0940       character_descriptor();
0941       label_14:
0942       while (true) {
0943         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
0944         case COMMA:
0945           ;
0946           break;
0947         default:
0948           jj_la1[45] = jj_gen;
0949           break label_14;
0950         }
0951         jj_consume_token(COMMA);
0952         character_descriptor();
0953       }
0954       break;
0955     default:
0956       jj_la1[46] = jj_gen;
0957       ;
0958     }
0959     jj_consume_token(RBRACKET);
0960   }
0961 
0962   final public void character_descriptor() throws ParseException {
0963     StringLiteral();
0964     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
0965     case MINUS:
0966       jj_consume_token(MINUS);
0967       StringLiteral();
0968       break;
0969     default:
0970       jj_la1[47] = jj_gen;
0971       ;
0972     }
0973   }
0974 
0975   final public Token identifier() throws ParseException {
0976   Token t;
0977     t = jj_consume_token(IDENTIFIER);
0978           {if (true) return t;}
0979     throw new Error("Missing return statement in function");
0980   }
0981 
0982 /**********************************************
0983  * THE JJTREE PRODUCTIONS START HERE          *
0984  **********************************************/
0985   final public void node_descriptor() throws ParseException {
0986     jj_consume_token(130);
0987     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
0988     case _LOOKAHEAD:
0989     case _IGNORE_CASE:
0990     case _PARSER_BEGIN:
0991     case _PARSER_END:
0992     case _JAVACODE:
0993     case _TOKEN:
0994     case _SPECIAL_TOKEN:
0995     case _MORE:
0996     case _SKIP:
0997     case _TOKEN_MGR_DECLS:
0998     case _EOF:
0999     case IDENTIFIER:
1000       Name();
1001       break;
1002     case VOID:
1003       jj_consume_token(VOID);
1004       break;
1005     default:
1006       jj_la1[48] = jj_gen;
1007       jj_consume_token(-1);
1008       throw new ParseException();
1009     }
1010     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1011     case LPAREN:
1012       jj_consume_token(LPAREN);
1013       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1014       case GT:
1015         jj_consume_token(GT);
1016         break;
1017       default:
1018         jj_la1[49] = jj_gen;
1019         ;
1020       }
1021       node_descriptor_expression();
1022       jj_consume_token(RPAREN);
1023       break;
1024     default:
1025       jj_la1[50] = jj_gen;
1026       ;
1027     }
1028   }
1029 
1030   void node_descriptor_expression() throws ParseException {
1031   Token tok;
1032   int nesting = 1;
1033   while (true) {
1034     tok = getToken(1);
1035     if (tok.kind == 0) {
1036       throw new ParseException();
1037     }
1038     if (tok.kind == LPAREN) nesting++;
1039     if (tok.kind == RPAREN) {
1040       nesting--;
1041       if (nesting == 0) break;
1042     }
1043     tok = getNextToken();
1044   }
1045   }
1046 
1047 /**********************************************
1048  * THE JAVA GRAMMAR SPECIFICATION STARTS HERE *
1049  **********************************************/
1050 
1051 /*
1052  * The Java grammar is modified to use sequences of tokens
1053  * for the missing tokens - those that include "<<" and ">>".
1054  */
1055 
1056 /*
1057  * The following production defines Java identifiers - it
1058  * includes the reserved words of JavaCC also.
1059  */
1060   final public String JavaIdentifier() throws ParseException {
1061     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1062     case IDENTIFIER:
1063       jj_consume_token(IDENTIFIER);
1064       break;
1065     case _LOOKAHEAD:
1066       jj_consume_token(_LOOKAHEAD);
1067       break;
1068     case _IGNORE_CASE:
1069       jj_consume_token(_IGNORE_CASE);
1070       break;
1071     case _PARSER_BEGIN:
1072       jj_consume_token(_PARSER_BEGIN);
1073       break;
1074     case _PARSER_END:
1075       jj_consume_token(_PARSER_END);
1076       break;
1077     case _JAVACODE:
1078       jj_consume_token(_JAVACODE);
1079       break;
1080     case _TOKEN:
1081       jj_consume_token(_TOKEN);
1082       break;
1083     case _SPECIAL_TOKEN:
1084       jj_consume_token(_SPECIAL_TOKEN);
1085       break;
1086     case _MORE:
1087       jj_consume_token(_MORE);
1088       break;
1089     case _SKIP:
1090       jj_consume_token(_SKIP);
1091       break;
1092     case _TOKEN_MGR_DECLS:
1093       jj_consume_token(_TOKEN_MGR_DECLS);
1094       break;
1095     case _EOF:
1096       jj_consume_token(_EOF);
1097       break;
1098     default:
1099       jj_la1[51] = jj_gen;
1100       jj_consume_token(-1);
1101       throw new ParseException();
1102     }
1103                   {if (true) return token.image;}
1104     throw new Error("Missing return statement in function");
1105   }
1106 
1107 /*
1108  * Program structuring syntax follows.
1109  */
1110   final public ASTCompilationUnit CompilationUnit() throws ParseException {
1111  /*@bgen(jjtree) CompilationUnit */
1112  ASTCompilationUnit jjtn000 = new ASTCompilationUnit(this, JJTCOMPILATIONUNIT);
1113  boolean jjtc000 = true;
1114  jjtree.openNodeScope(jjtn000);
1115  jjtreeOpenNodeScope(jjtn000);String s = "";
1116     try {
1117       if (jj_2_6(2147483647)) {
1118         s = PackageDeclaration();
1119       } else {
1120         ;
1121       }
1122       label_15:
1123       while (true) {
1124         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1125         case IMPORT:
1126           ;
1127           break;
1128         default:
1129           jj_la1[52] = jj_gen;
1130           break label_15;
1131         }
1132         ImportDeclaration();
1133       }
1134       label_16:
1135       while (true) {
1136         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1137         case ABSTRACT:
1138         case CLASS:
1139         case FINAL:
1140         case INTERFACE:
1141         case NATIVE:
1142         case PRIVATE:
1143         case PROTECTED:
1144         case PUBLIC:
1145         case STATIC:
1146         case STRICTFP:
1147         case SYNCHRONIZED:
1148         case TRANSIENT:
1149         case VOLATILE:
1150         case SEMICOLON:
1151         case AT:
1152         case 131:
1153           ;
1154           break;
1155         default:
1156           jj_la1[53] = jj_gen;
1157           break label_16;
1158         }
1159         TypeDeclaration();
1160       }
1161     jjtree.closeNodeScope(jjtn000, true);
1162     jjtc000 = false;
1163     jjtreeCloseNodeScope(jjtn000);
1164     jjtn000.packageName = s;
1165     {if (true) return jjtn000;}
1166     } catch (Throwable jjte000) {
1167     if (jjtc000) {
1168       jjtree.clearNodeScope(jjtn000);
1169       jjtc000 = false;
1170     } else {
1171       jjtree.popNode();
1172     }
1173     if (jjte000 instanceof RuntimeException) {
1174       {if (true) throw (RuntimeException)jjte000;}
1175     }
1176     if (jjte000 instanceof ParseException) {
1177       {if (true) throw (ParseException)jjte000;}
1178     }
1179     {if (true) throw (Error)jjte000;}
1180     } finally {
1181     if (jjtc000) {
1182       jjtree.closeNodeScope(jjtn000, true);
1183       jjtreeCloseNodeScope(jjtn000);
1184     }
1185     }
1186     throw new Error("Missing return statement in function");
1187   }
1188 
1189   final public String PackageDeclaration() throws ParseException {
1190   String s=null;
1191     Modifiers();
1192     jj_consume_token(PACKAGE);
1193     s = PackageName();
1194     jj_consume_token(SEMICOLON);
1195         {if (true) return s;}
1196     throw new Error("Missing return statement in function");
1197   }
1198 
1199   final public String PackageName() throws ParseException {
1200  /*@bgen(jjtree) PackageName */
1201   ASTPackageName jjtn000 = new ASTPackageName(this, JJTPACKAGENAME);
1202   boolean jjtc000 = true;
1203   jjtree.openNodeScope(jjtn000);
1204   jjtreeOpenNodeScope(jjtn000);String s, ss;
1205     try {
1206       s = JavaIdentifier();
1207       label_17:
1208       while (true) {
1209         if (jj_2_7(2)) {
1210           ;
1211         } else {
1212           break label_17;
1213         }
1214         jj_consume_token(DOT);
1215         ss = JavaIdentifier();
1216                                            s += "." + ss;
1217       }
1218           jjtree.closeNodeScope(jjtn000, true);
1219           jjtc000 = false;
1220           jjtreeCloseNodeScope(jjtn000);
1221                   {if (true) return jjtn000.text = s;}
1222     } catch (Throwable jjte000) {
1223     if (jjtc000) {
1224       jjtree.clearNodeScope(jjtn000);
1225       jjtc000 = false;
1226     } else {
1227       jjtree.popNode();
1228     }
1229     if (jjte000 instanceof RuntimeException) {
1230       {if (true) throw (RuntimeException)jjte000;}
1231     }
1232     if (jjte000 instanceof ParseException) {
1233       {if (true) throw (ParseException)jjte000;}
1234     }
1235     {if (true) throw (Error)jjte000;}
1236     } finally {
1237     if (jjtc000) {
1238       jjtree.closeNodeScope(jjtn000, true);
1239       jjtreeCloseNodeScope(jjtn000);
1240     }
1241     }
1242     throw new Error("Missing return statement in function");
1243   }
1244 
1245   final public void ImportDeclaration() throws ParseException {
1246         String s = "";
1247     jj_consume_token(IMPORT);
1248     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1249     case STATIC:
1250       jj_consume_token(STATIC);
1251       break;
1252     default:
1253       jj_la1[54] = jj_gen;
1254       ;
1255     }
1256     s = ImportName();
1257     jj_consume_token(SEMICOLON);
1258   }
1259 
1260   final public String ImportName() throws ParseException {
1261  /*@bgen(jjtree) ImportName */
1262   ASTImportName jjtn000 = new ASTImportName(this, JJTIMPORTNAME);
1263   boolean jjtc000 = true;
1264   jjtree.openNodeScope(jjtn000);
1265   jjtreeOpenNodeScope(jjtn000);Token t1=null,t2=null;
1266   String s, ss;
1267     try {
1268       s = JavaIdentifier();
1269       label_18:
1270       while (true) {
1271         if (jj_2_8(2)) {
1272           ;
1273         } else {
1274           break label_18;
1275         }
1276         jj_consume_token(DOT);
1277         ss = JavaIdentifier();
1278                                            s += "." + ss;
1279       }
1280       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1281       case DOT:
1282         t1 = jj_consume_token(DOT);
1283         t2 = jj_consume_token(STAR);
1284         break;
1285       default:
1286         jj_la1[55] = jj_gen;
1287         ;
1288       }
1289           jjtree.closeNodeScope(jjtn000, true);
1290           jjtc000 = false;
1291           jjtreeCloseNodeScope(jjtn000);
1292           if (t1!= null) s += t1.image + t2.image;
1293                   {if (true) return jjtn000.text = s;}
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       jjtreeCloseNodeScope(jjtn000);
1312     }
1313     }
1314     throw new Error("Missing return statement in function");
1315   }
1316 
1317 /*
1318  * Modifiers. We match all modifiers in a single rule to reduce the chances of
1319  * syntax errors for simple modifier mistakes. It will also enable us to give
1320  * better error messages.
1321  */
1322   final public void Modifiers() throws ParseException {
1323     label_19:
1324     while (true) {
1325       if (jj_2_9(2)) {
1326         ;
1327       } else {
1328         break label_19;
1329       }
1330       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1331       case PUBLIC:
1332         jj_consume_token(PUBLIC);
1333         break;
1334       case STATIC:
1335         jj_consume_token(STATIC);
1336         break;
1337       case PROTECTED:
1338         jj_consume_token(PROTECTED);
1339         break;
1340       case PRIVATE:
1341         jj_consume_token(PRIVATE);
1342         break;
1343       case FINAL:
1344         jj_consume_token(FINAL);
1345         break;
1346       case ABSTRACT:
1347         jj_consume_token(ABSTRACT);
1348         break;
1349       case SYNCHRONIZED:
1350         jj_consume_token(SYNCHRONIZED);
1351         break;
1352       case NATIVE:
1353         jj_consume_token(NATIVE);
1354         break;
1355       case TRANSIENT:
1356         jj_consume_token(TRANSIENT);
1357         break;
1358       case VOLATILE:
1359         jj_consume_token(VOLATILE);
1360         break;
1361       case STRICTFP:
1362         jj_consume_token(STRICTFP);
1363         break;
1364       case AT:
1365         Annotation();
1366         break;
1367       default:
1368         jj_la1[56] = jj_gen;
1369         jj_consume_token(-1);
1370         throw new ParseException();
1371       }
1372     }
1373   }
1374 
1375 /*
1376  * Declaration syntax follows.
1377  */
1378   final public void TypeDeclaration() throws ParseException {
1379    ;
1380     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1381     case SEMICOLON:
1382       jj_consume_token(SEMICOLON);
1383       break;
1384     case ABSTRACT:
1385     case CLASS:
1386     case FINAL:
1387     case INTERFACE:
1388     case NATIVE:
1389     case PRIVATE:
1390     case PROTECTED:
1391     case PUBLIC:
1392     case STATIC:
1393     case STRICTFP:
1394     case SYNCHRONIZED:
1395     case TRANSIENT:
1396     case VOLATILE:
1397     case AT:
1398     case 131:
1399       Modifiers();
1400       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1401       case CLASS:
1402       case INTERFACE:
1403         ClassOrInterfaceDeclaration();
1404         break;
1405       case 131:
1406         EnumDeclaration();
1407         break;
1408       case AT:
1409         AnnotationTypeDeclaration();
1410         break;
1411       default:
1412         jj_la1[57] = jj_gen;
1413         jj_consume_token(-1);
1414         throw new ParseException();
1415       }
1416       break;
1417     default:
1418       jj_la1[58] = jj_gen;
1419       jj_consume_token(-1);
1420       throw new ParseException();
1421     }
1422   }
1423 
1424   final public String NewName() throws ParseException {
1425  /*@bgen(jjtree) NewName */
1426   ASTNewName jjtn000 = new ASTNewName(this, JJTNEWNAME);
1427   boolean jjtc000 = true;
1428   jjtree.openNodeScope(jjtn000);
1429   jjtreeOpenNodeScope(jjtn000);String s, ss;
1430     try {
1431       s = JavaIdentifier();
1432       label_20:
1433       while (true) {
1434         if (jj_2_10(2)) {
1435           ;
1436         } else {
1437           break label_20;
1438         }
1439         jj_consume_token(DOT);
1440         ss = JavaIdentifier();
1441                                            s += "." + ss;
1442       }
1443           jjtree.closeNodeScope(jjtn000, true);
1444           jjtc000 = false;
1445           jjtreeCloseNodeScope(jjtn000);
1446                   {if (true) return jjtn000.text = s;}
1447     } catch (Throwable jjte000) {
1448     if (jjtc000) {
1449       jjtree.clearNodeScope(jjtn000);
1450       jjtc000 = false;
1451     } else {
1452       jjtree.popNode();
1453     }
1454     if (jjte000 instanceof RuntimeException) {
1455       {if (true) throw (RuntimeException)jjte000;}
1456     }
1457     if (jjte000 instanceof ParseException) {
1458       {if (true) throw (ParseException)jjte000;}
1459     }
1460     {if (true) throw (Error)jjte000;}
1461     } finally {
1462     if (jjtc000) {
1463       jjtree.closeNodeScope(jjtn000, true);
1464       jjtreeCloseNodeScope(jjtn000);
1465     }
1466     }
1467     throw new Error("Missing return statement in function");
1468   }
1469 
1470   final public void ClassOrInterfaceDeclaration() throws ParseException {
1471  /*@bgen(jjtree) NewType */
1472   ASTNewType jjtn000 = new ASTNewType(this, JJTNEWTYPE);
1473   boolean jjtc000 = true;
1474   jjtree.openNodeScope(jjtn000);
1475   jjtreeOpenNodeScope(jjtn000);boolean isInterface = false;
1476   String name;
1477     try {
1478       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1479       case CLASS:
1480         jj_consume_token(CLASS);
1481         break;
1482       case INTERFACE:
1483         jj_consume_token(INTERFACE);
1484                             isInterface = true;
1485         break;
1486       default:
1487         jj_la1[59] = jj_gen;
1488         jj_consume_token(-1);
1489         throw new ParseException();
1490       }
1491       name = NewName();
1492                      jjtn000.name = name;
1493       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1494       case LT:
1495         TypeParameters();
1496         break;
1497       default:
1498         jj_la1[60] = jj_gen;
1499         ;
1500       }
1501       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1502       case EXTENDS:
1503         ExtendsList(isInterface);
1504         break;
1505       default:
1506         jj_la1[61] = jj_gen;
1507         ;
1508       }
1509       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1510       case IMPLEMENTS:
1511         ImplementsList(isInterface);
1512         break;
1513       default:
1514         jj_la1[62] = jj_gen;
1515         ;
1516       }
1517       ClassOrInterfaceBody(isInterface);
1518     } catch (Throwable jjte000) {
1519     if (jjtc000) {
1520       jjtree.clearNodeScope(jjtn000);
1521       jjtc000 = false;
1522     } else {
1523       jjtree.popNode();
1524     }
1525     if (jjte000 instanceof RuntimeException) {
1526       {if (true) throw (RuntimeException)jjte000;}
1527     }
1528     if (jjte000 instanceof ParseException) {
1529       {if (true) throw (ParseException)jjte000;}
1530     }
1531     {if (true) throw (Error)jjte000;}
1532     } finally {
1533     if (jjtc000) {
1534       jjtree.closeNodeScope(jjtn000, true);
1535       jjtreeCloseNodeScope(jjtn000);
1536     }
1537     }
1538   }
1539 
1540   final public void ExtendsList(boolean isInterface) throws ParseException {
1541  /*@bgen(jjtree) SuperList */
1542    ASTSuperList jjtn000 = new ASTSuperList(this, JJTSUPERLIST);
1543    boolean jjtc000 = true;
1544    jjtree.openNodeScope(jjtn000);
1545    jjtreeOpenNodeScope(jjtn000);boolean extendsMoreThanOne = false;
1546    String s;
1547     try {
1548       jj_consume_token(EXTENDS);
1549       s = ClassOrInterfaceType();
1550                                           jjtn000.list.add(s);
1551       label_21:
1552       while (true) {
1553         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1554         case COMMA:
1555           ;
1556           break;
1557         default:
1558           jj_la1[63] = jj_gen;
1559           break label_21;
1560         }
1561         jj_consume_token(COMMA);
1562         s = ClassOrInterfaceType();
1563                                       extendsMoreThanOne = true; jjtn000.list.add(s);
1564       }
1565      jjtree.closeNodeScope(jjtn000, true);
1566      jjtc000 = false;
1567      jjtreeCloseNodeScope(jjtn000);
1568       if (extendsMoreThanOne && !isInterface)
1569          {if (true) throw new ParseException("A class cannot extend more than one other class");}
1570     } catch (Throwable jjte000) {
1571      if (jjtc000) {
1572        jjtree.clearNodeScope(jjtn000);
1573        jjtc000 = false;
1574      } else {
1575        jjtree.popNode();
1576      }
1577      if (jjte000 instanceof RuntimeException) {
1578        {if (true) throw (RuntimeException)jjte000;}
1579      }
1580      if (jjte000 instanceof ParseException) {
1581        {if (true) throw (ParseException)jjte000;}
1582      }
1583      {if (true) throw (Error)jjte000;}
1584     } finally {
1585      if (jjtc000) {
1586        jjtree.closeNodeScope(jjtn000, true);
1587        jjtreeCloseNodeScope(jjtn000);
1588      }
1589     }
1590   }
1591 
1592   final public void ImplementsList(boolean isInterface) throws ParseException {
1593  /*@bgen(jjtree) SuperList */
1594    ASTSuperList jjtn000 = new ASTSuperList(this, JJTSUPERLIST);
1595    boolean jjtc000 = true;
1596    jjtree.openNodeScope(jjtn000);
1597    jjtreeOpenNodeScope(jjtn000);String s;
1598     try {
1599       jj_consume_token(IMPLEMENTS);
1600       s = ClassOrInterfaceType();
1601                                              jjtn000.list.add(s);
1602       label_22:
1603       while (true) {
1604         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1605         case COMMA:
1606           ;
1607           break;
1608         default:
1609           jj_la1[64] = jj_gen;
1610           break label_22;
1611         }
1612         jj_consume_token(COMMA);
1613         s = ClassOrInterfaceType();
1614                                       jjtn000.list.add(s);
1615       }
1616      jjtree.closeNodeScope(jjtn000, true);
1617      jjtc000 = false;
1618      jjtreeCloseNodeScope(jjtn000);
1619       if (isInterface)
1620          {if (true) throw new ParseException("An interface cannot implement other interfaces");}
1621     } catch (Throwable jjte000) {
1622      if (jjtc000) {
1623        jjtree.clearNodeScope(jjtn000);
1624        jjtc000 = false;
1625      } else {
1626        jjtree.popNode();
1627      }
1628      if (jjte000 instanceof RuntimeException) {
1629        {if (true) throw (RuntimeException)jjte000;}
1630      }
1631      if (jjte000 instanceof ParseException) {
1632        {if (true) throw (ParseException)jjte000;}
1633      }
1634      {if (true) throw (Error)jjte000;}
1635     } finally {
1636      if (jjtc000) {
1637        jjtree.closeNodeScope(jjtn000, true);
1638        jjtreeCloseNodeScope(jjtn000);
1639      }
1640     }
1641   }
1642 
1643   final public void EnumDeclaration() throws ParseException {
1644  /*@bgen(jjtree) NewType */
1645   ASTNewType jjtn000 = new ASTNewType(this, JJTNEWTYPE);
1646   boolean jjtc000 = true;
1647   jjtree.openNodeScope(jjtn000);
1648   jjtreeOpenNodeScope(jjtn000);String name;
1649     try {
1650       jj_consume_token(131);
1651       name = NewName();
1652                             jjtn000.name = name;
1653       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1654       case IMPLEMENTS:
1655         ImplementsList(false);
1656         break;
1657       default:
1658         jj_la1[65] = jj_gen;
1659         ;
1660       }
1661       EnumBody();
1662     } catch (Throwable jjte000) {
1663     if (jjtc000) {
1664       jjtree.clearNodeScope(jjtn000);
1665       jjtc000 = false;
1666     } else {
1667       jjtree.popNode();
1668     }
1669     if (jjte000 instanceof RuntimeException) {
1670       {if (true) throw (RuntimeException)jjte000;}
1671     }
1672     if (jjte000 instanceof ParseException) {
1673       {if (true) throw (ParseException)jjte000;}
1674     }
1675     {if (true) throw (Error)jjte000;}
1676     } finally {
1677     if (jjtc000) {
1678       jjtree.closeNodeScope(jjtn000, true);
1679       jjtreeCloseNodeScope(jjtn000);
1680     }
1681     }
1682   }
1683 
1684   final public void EnumBody() throws ParseException {
1685     jj_consume_token(LBRACE);
1686     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1687     case _LOOKAHEAD:
1688     case _IGNORE_CASE:
1689     case _PARSER_BEGIN:
1690     case _PARSER_END:
1691     case _JAVACODE:
1692     case _TOKEN:
1693     case _SPECIAL_TOKEN:
1694     case _MORE:
1695     case _SKIP:
1696     case _TOKEN_MGR_DECLS:
1697     case _EOF:
1698     case ABSTRACT:
1699     case FINAL:
1700     case NATIVE:
1701     case PRIVATE:
1702     case PROTECTED:
1703     case PUBLIC:
1704     case STATIC:
1705     case STRICTFP:
1706     case SYNCHRONIZED:
1707     case TRANSIENT:
1708     case VOLATILE:
1709     case AT:
1710     case IDENTIFIER:
1711       EnumConstant();
1712       label_23:
1713       while (true) {
1714         if (jj_2_11(2)) {
1715           ;
1716         } else {
1717           break label_23;
1718         }
1719         jj_consume_token(COMMA);
1720         EnumConstant();
1721       }
1722       break;
1723     default:
1724       jj_la1[66] = jj_gen;
1725       ;
1726     }
1727     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1728     case COMMA:
1729       jj_consume_token(COMMA);
1730       break;
1731     default:
1732       jj_la1[67] = jj_gen;
1733       ;
1734     }
1735     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1736     case SEMICOLON:
1737       jj_consume_token(SEMICOLON);
1738       label_24:
1739       while (true) {
1740         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1741         case _LOOKAHEAD:
1742         case _IGNORE_CASE:
1743         case _PARSER_BEGIN:
1744         case _PARSER_END:
1745         case _JAVACODE:
1746         case _TOKEN:
1747         case _SPECIAL_TOKEN:
1748         case _MORE:
1749         case _SKIP:
1750         case _TOKEN_MGR_DECLS:
1751         case _EOF:
1752         case ABSTRACT:
1753         case BOOLEAN:
1754         case BYTE:
1755         case CHAR:
1756         case CLASS:
1757         case DOUBLE:
1758         case FINAL:
1759         case FLOAT:
1760         case INT:
1761         case INTERFACE:
1762         case LONG:
1763         case NATIVE:
1764         case PRIVATE:
1765         case PROTECTED:
1766         case PUBLIC:
1767         case SHORT:
1768         case STATIC:
1769         case STRICTFP:
1770         case SYNCHRONIZED:
1771         case TRANSIENT:
1772         case VOID:
1773         case VOLATILE:
1774         case LBRACE:
1775         case SEMICOLON:
1776         case AT:
1777         case LT:
1778         case 131:
1779         case IDENTIFIER:
1780           ;
1781           break;
1782         default:
1783           jj_la1[68] = jj_gen;
1784           break label_24;
1785         }
1786         ClassOrInterfaceBodyDeclaration(false);
1787       }
1788       break;
1789     default:
1790       jj_la1[69] = jj_gen;
1791       ;
1792     }
1793     jj_consume_token(RBRACE);
1794   }
1795 
1796   final public void EnumConstant() throws ParseException {
1797     Modifiers();
1798     JavaIdentifier();
1799     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1800     case LPAREN:
1801       Arguments();
1802       break;
1803     default:
1804       jj_la1[70] = jj_gen;
1805       ;
1806     }
1807     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1808     case LBRACE:
1809       ClassOrInterfaceBody(false);
1810       break;
1811     default:
1812       jj_la1[71] = jj_gen;
1813       ;
1814     }
1815   }
1816 
1817   final public void TypeParameters() throws ParseException {
1818     jj_consume_token(LT);
1819     TypeParameter();
1820     label_25:
1821     while (true) {
1822       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1823       case COMMA:
1824         ;
1825         break;
1826       default:
1827         jj_la1[72] = jj_gen;
1828         break label_25;
1829       }
1830       jj_consume_token(COMMA);
1831       TypeParameter();
1832     }
1833     jj_consume_token(GT);
1834   }
1835 
1836   final public void TypeParameter() throws ParseException {
1837     JavaIdentifier();
1838     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1839     case EXTENDS:
1840       TypeBound();
1841       break;
1842     default:
1843       jj_la1[73] = jj_gen;
1844       ;
1845     }
1846   }
1847 
1848   final public void TypeBound() throws ParseException {
1849     jj_consume_token(EXTENDS);
1850     ClassOrInterfaceType();
1851     label_26:
1852     while (true) {
1853       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1854       case BIT_AND:
1855         ;
1856         break;
1857       default:
1858         jj_la1[74] = jj_gen;
1859         break label_26;
1860       }
1861       jj_consume_token(BIT_AND);
1862       ClassOrInterfaceType();
1863     }
1864   }
1865 
1866   final public void ClassOrInterfaceBody(boolean isInterface) throws ParseException {
1867     jj_consume_token(LBRACE);
1868     label_27:
1869     while (true) {
1870       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1871       case _LOOKAHEAD:
1872       case _IGNORE_CASE:
1873       case _PARSER_BEGIN:
1874       case _PARSER_END:
1875       case _JAVACODE:
1876       case _TOKEN:
1877       case _SPECIAL_TOKEN:
1878       case _MORE:
1879       case _SKIP:
1880       case _TOKEN_MGR_DECLS:
1881       case _EOF:
1882       case ABSTRACT:
1883       case BOOLEAN:
1884       case BYTE:
1885       case CHAR:
1886       case CLASS:
1887       case DOUBLE:
1888       case FINAL:
1889       case FLOAT:
1890       case INT:
1891       case INTERFACE:
1892       case LONG:
1893       case NATIVE:
1894       case PRIVATE:
1895       case PROTECTED:
1896       case PUBLIC:
1897       case SHORT:
1898       case STATIC:
1899       case STRICTFP:
1900       case SYNCHRONIZED:
1901       case TRANSIENT:
1902       case VOID:
1903       case VOLATILE:
1904       case LBRACE:
1905       case SEMICOLON:
1906       case AT:
1907       case LT:
1908       case 131:
1909       case IDENTIFIER:
1910         ;
1911         break;
1912       default:
1913         jj_la1[75] = jj_gen;
1914         break label_27;
1915       }
1916       ClassOrInterfaceBodyDeclaration(isInterface);
1917     }
1918     jj_consume_token(RBRACE);
1919   }
1920 
1921   final public void ClassOrInterfaceBodyDeclaration(boolean isInterface) throws ParseException {
1922    boolean isNestedInterface = false;
1923    int modifiers;
1924     if (jj_2_14(2)) {
1925       Initializer();
1926      if (isInterface)
1927         {if (true) throw new ParseException("An interface cannot have initializers");}
1928     } else {
1929       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1930       case _LOOKAHEAD:
1931       case _IGNORE_CASE:
1932       case _PARSER_BEGIN:
1933       case _PARSER_END:
1934       case _JAVACODE:
1935       case _TOKEN:
1936       case _SPECIAL_TOKEN:
1937       case _MORE:
1938       case _SKIP:
1939       case _TOKEN_MGR_DECLS:
1940       case _EOF:
1941       case ABSTRACT:
1942       case BOOLEAN:
1943       case BYTE:
1944       case CHAR:
1945       case CLASS:
1946       case DOUBLE:
1947       case FINAL:
1948       case FLOAT:
1949       case INT:
1950       case INTERFACE:
1951       case LONG:
1952       case NATIVE:
1953       case PRIVATE:
1954       case PROTECTED:
1955       case PUBLIC:
1956       case SHORT:
1957       case STATIC:
1958       case STRICTFP:
1959       case SYNCHRONIZED:
1960       case TRANSIENT:
1961       case VOID:
1962       case VOLATILE:
1963       case AT:
1964       case LT:
1965       case 131:
1966       case IDENTIFIER:
1967         Modifiers();
1968         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1969         case CLASS:
1970         case INTERFACE:
1971           ClassOrInterfaceDeclaration();
1972           break;
1973         case 131:
1974           EnumDeclaration();
1975           break;
1976         default:
1977           jj_la1[76] = jj_gen;
1978           if (jj_2_12(2147483647)) {
1979             ConstructorDeclaration();
1980           } else if (jj_2_13(2147483647)) {
1981             FieldDeclaration();
1982           } else {
1983             switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1984             case _LOOKAHEAD:
1985             case _IGNORE_CASE:
1986             case _PARSER_BEGIN:
1987             case _PARSER_END:
1988             case _JAVACODE:
1989             case _TOKEN:
1990             case _SPECIAL_TOKEN:
1991             case _MORE:
1992             case _SKIP:
1993             case _TOKEN_MGR_DECLS:
1994             case _EOF:
1995             case BOOLEAN:
1996             case BYTE:
1997             case CHAR:
1998             case DOUBLE:
1999             case FLOAT:
2000             case INT:
2001             case LONG:
2002             case SHORT:
2003             case VOID:
2004             case LT:
2005             case IDENTIFIER:
2006               MethodDeclaration();
2007               break;
2008             default:
2009               jj_la1[77] = jj_gen;
2010               jj_consume_token(-1);
2011               throw new ParseException();
2012             }
2013           }
2014         }
2015         break;
2016       case SEMICOLON:
2017         jj_consume_token(SEMICOLON);
2018         break;
2019       default:
2020         jj_la1[78] = jj_gen;
2021         jj_consume_token(-1);
2022         throw new ParseException();
2023       }
2024     }
2025   }
2026 
2027   final public void FieldDeclaration() throws ParseException {
2028     Type();
2029     VariableDeclarator();
2030     label_28:
2031     while (true) {
2032       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2033       case COMMA:
2034         ;
2035         break;
2036       default:
2037         jj_la1[79] = jj_gen;
2038         break label_28;
2039       }
2040       jj_consume_token(COMMA);
2041       VariableDeclarator();
2042     }
2043     jj_consume_token(SEMICOLON);
2044   }
2045 
2046   final public void FieldVariableDeclarator() throws ParseException {
2047     FieldVariableDeclaratorId();
2048     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2049     case ASSIGN:
2050       jj_consume_token(ASSIGN);
2051       VariableInitializer();
2052       break;
2053     default:
2054       jj_la1[80] = jj_gen;
2055       ;
2056     }
2057   }
2058 
2059   final public void FieldVariableDeclaratorId() throws ParseException {
2060     NewName();
2061     label_29:
2062     while (true) {
2063       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2064       case LBRACKET:
2065         ;
2066         break;
2067       default:
2068         jj_la1[81] = jj_gen;
2069         break label_29;
2070       }
2071       jj_consume_token(LBRACKET);
2072       jj_consume_token(RBRACKET);
2073     }
2074   }
2075 
2076   final public void VariableDeclarator() throws ParseException {
2077     VariableDeclaratorId();
2078     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2079     case ASSIGN:
2080       jj_consume_token(ASSIGN);
2081       VariableInitializer();
2082       break;
2083     default:
2084       jj_la1[82] = jj_gen;
2085       ;
2086     }
2087   }
2088 
2089   final public void VariableDeclaratorId() throws ParseException {
2090     JavaIdentifier();
2091     label_30:
2092     while (true) {
2093       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2094       case LBRACKET:
2095         ;
2096         break;
2097       default:
2098         jj_la1[83] = jj_gen;
2099         break label_30;
2100       }
2101       jj_consume_token(LBRACKET);
2102       jj_consume_token(RBRACKET);
2103     }
2104   }
2105 
2106   final public void VariableInitializer() throws ParseException {
2107     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2108     case LBRACE:
2109       ArrayInitializer();
2110       break;
2111     case _LOOKAHEAD:
2112     case _IGNORE_CASE:
2113     case _PARSER_BEGIN:
2114     case _PARSER_END:
2115     case _JAVACODE:
2116     case _TOKEN:
2117     case _SPECIAL_TOKEN:
2118     case _MORE:
2119     case _SKIP:
2120     case _TOKEN_MGR_DECLS:
2121     case _EOF:
2122     case BOOLEAN:
2123     case BYTE:
2124     case CHAR:
2125     case DOUBLE:
2126     case FALSE:
2127     case FLOAT:
2128     case INT:
2129     case LONG:
2130     case NEW:
2131     case NULL:
2132     case SHORT:
2133     case SUPER:
2134     case THIS:
2135     case TRUE:
2136     case VOID:
2137     case INTEGER_LITERAL:
2138     case FLOATING_POINT_LITERAL:
2139     case CHARACTER_LITERAL:
2140     case STRING_LITERAL:
2141     case LPAREN:
2142     case BANG:
2143     case TILDE:
2144     case INCR:
2145     case DECR:
2146     case PLUS:
2147     case MINUS:
2148     case IDENTIFIER:
2149       Expression();
2150       break;
2151     default:
2152       jj_la1[84] = jj_gen;
2153       jj_consume_token(-1);
2154       throw new ParseException();
2155     }
2156   }
2157 
2158   final public void ArrayInitializer() throws ParseException {
2159     jj_consume_token(LBRACE);
2160     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2161     case _LOOKAHEAD:
2162     case _IGNORE_CASE:
2163     case _PARSER_BEGIN:
2164     case _PARSER_END:
2165     case _JAVACODE:
2166     case _TOKEN:
2167     case _SPECIAL_TOKEN:
2168     case _MORE:
2169     case _SKIP:
2170     case _TOKEN_MGR_DECLS:
2171     case _EOF:
2172     case BOOLEAN:
2173     case BYTE:
2174     case CHAR:
2175     case DOUBLE:
2176     case FALSE:
2177     case FLOAT:
2178     case INT:
2179     case LONG:
2180     case NEW:
2181     case NULL:
2182     case SHORT:
2183     case SUPER:
2184     case THIS:
2185     case TRUE:
2186     case VOID:
2187     case INTEGER_LITERAL:
2188     case FLOATING_POINT_LITERAL:
2189     case CHARACTER_LITERAL:
2190     case STRING_LITERAL:
2191     case LPAREN:
2192     case LBRACE:
2193     case BANG:
2194     case TILDE:
2195     case INCR:
2196     case DECR:
2197     case PLUS:
2198     case MINUS:
2199     case IDENTIFIER:
2200       VariableInitializer();
2201       label_31:
2202       while (true) {
2203         if (jj_2_15(2)) {
2204           ;
2205         } else {
2206           break label_31;
2207         }
2208         jj_consume_token(COMMA);
2209         VariableInitializer();
2210       }
2211       break;
2212     default:
2213       jj_la1[85] = jj_gen;
2214       ;
2215     }
2216     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2217     case COMMA:
2218       jj_consume_token(COMMA);
2219       break;
2220     default:
2221       jj_la1[86] = jj_gen;
2222       ;
2223     }
2224     jj_consume_token(RBRACE);
2225   }
2226 
2227   final public void MethodDeclaration() throws ParseException {
2228     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2229     case LT:
2230       TypeParameters();
2231       break;
2232     default:
2233       jj_la1[87] = jj_gen;
2234       ;
2235     }
2236     ResultType();
2237     MethodDeclarator();
2238     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2239     case THROWS:
2240       jj_consume_token(THROWS);
2241       NameList();
2242       break;
2243     default:
2244       jj_la1[88] = jj_gen;
2245       ;
2246     }
2247     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2248     case LBRACE:
2249       Block();
2250       break;
2251     case SEMICOLON:
2252       jj_consume_token(SEMICOLON);
2253       break;
2254     default:
2255       jj_la1[89] = jj_gen;
2256       jj_consume_token(-1);
2257       throw new ParseException();
2258     }
2259   }
2260 
2261   final public void MethodDeclarator() throws ParseException {
2262     NewName();
2263     FormalParameters();
2264     label_32:
2265     while (true) {
2266       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2267       case LBRACKET:
2268         ;
2269         break;
2270       default:
2271         jj_la1[90] = jj_gen;
2272         break label_32;
2273       }
2274       jj_consume_token(LBRACKET);
2275       jj_consume_token(RBRACKET);
2276     }
2277   }
2278 
2279   final public void FormalParameters() throws ParseException {
2280     jj_consume_token(LPAREN);
2281     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2282     case _LOOKAHEAD:
2283     case _IGNORE_CASE:
2284     case _PARSER_BEGIN:
2285     case _PARSER_END:
2286     case _JAVACODE:
2287     case _TOKEN:
2288     case _SPECIAL_TOKEN:
2289     case _MORE:
2290     case _SKIP:
2291     case _TOKEN_MGR_DECLS:
2292     case _EOF:
2293     case ABSTRACT:
2294     case BOOLEAN:
2295     case BYTE:
2296     case CHAR:
2297     case DOUBLE:
2298     case FINAL:
2299     case FLOAT:
2300     case INT:
2301     case LONG:
2302     case NATIVE:
2303     case PRIVATE:
2304     case PROTECTED:
2305     case PUBLIC:
2306     case SHORT:
2307     case STATIC:
2308     case STRICTFP:
2309     case SYNCHRONIZED:
2310     case TRANSIENT:
2311     case VOLATILE:
2312     case AT:
2313     case IDENTIFIER:
2314       FormalParameter();
2315       label_33:
2316       while (true) {
2317         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2318         case COMMA:
2319           ;
2320           break;
2321         default:
2322           jj_la1[91] = jj_gen;
2323           break label_33;
2324         }
2325         jj_consume_token(COMMA);
2326         FormalParameter();
2327       }
2328       break;
2329     default:
2330       jj_la1[92] = jj_gen;
2331       ;
2332     }
2333     jj_consume_token(RPAREN);
2334   }
2335 
2336   final public void FormalParameter() throws ParseException {
2337     Modifiers();
2338     Type();
2339     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2340     case ELLIPSIS:
2341       jj_consume_token(ELLIPSIS);
2342       break;
2343     default:
2344       jj_la1[93] = jj_gen;
2345       ;
2346     }
2347     VariableDeclaratorId();
2348   }
2349 
2350   final public void ConstructorDeclaration() throws ParseException {
2351     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2352     case LT:
2353       TypeParameters();
2354       break;
2355     default:
2356       jj_la1[94] = jj_gen;
2357       ;
2358     }
2359     JavaIdentifier();
2360     FormalParameters();
2361     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2362     case THROWS:
2363       jj_consume_token(THROWS);
2364       NameList();
2365       break;
2366     default:
2367       jj_la1[95] = jj_gen;
2368       ;
2369     }
2370     jj_consume_token(LBRACE);
2371     if (jj_2_16(2147483647)) {
2372       ExplicitConstructorInvocation();
2373     } else {
2374       ;
2375     }
2376     label_34:
2377     while (true) {
2378       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2379       case _LOOKAHEAD:
2380       case _IGNORE_CASE:
2381       case _PARSER_BEGIN:
2382       case _PARSER_END:
2383       case _JAVACODE:
2384       case _TOKEN:
2385       case _SPECIAL_TOKEN:
2386       case _MORE:
2387       case _SKIP:
2388       case _TOKEN_MGR_DECLS:
2389       case _EOF:
2390       case ABSTRACT:
2391       case BOOLEAN:
2392       case BREAK:
2393       case BYTE:
2394       case CHAR:
2395       case CLASS:
2396       case CONTINUE:
2397       case DO:
2398       case DOUBLE:
2399       case FALSE:
2400       case FINAL:
2401       case FLOAT:
2402       case FOR:
2403       case IF:
2404       case INT:
2405       case INTERFACE:
2406       case LONG:
2407       case NATIVE:
2408       case NEW:
2409       case NULL:
2410       case PRIVATE:
2411       case PROTECTED:
2412       case PUBLIC:
2413       case RETURN:
2414       case SHORT:
2415       case STATIC:
2416       case STRICTFP:
2417       case SUPER:
2418       case SWITCH:
2419       case SYNCHRONIZED:
2420       case THIS:
2421       case THROW:
2422       case TRANSIENT:
2423       case TRUE:
2424       case TRY:
2425       case VOID:
2426       case VOLATILE:
2427       case WHILE:
2428       case INTEGER_LITERAL:
2429       case FLOATING_POINT_LITERAL:
2430       case CHARACTER_LITERAL:
2431       case STRING_LITERAL:
2432       case LPAREN:
2433       case LBRACE:
2434       case SEMICOLON:
2435       case AT:
2436       case INCR:
2437       case DECR:
2438       case 136:
2439       case IDENTIFIER:
2440         ;
2441         break;
2442       default:
2443         jj_la1[96] = jj_gen;
2444         break label_34;
2445       }
2446       BlockStatement();
2447     }
2448     jj_consume_token(RBRACE);
2449   }
2450 
2451   final public void ExplicitConstructorInvocation() throws ParseException {
2452     if (jj_2_18(2147483647)) {
2453       jj_consume_token(THIS);
2454       Arguments();
2455       jj_consume_token(SEMICOLON);
2456     } else {
2457       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2458       case _LOOKAHEAD:
2459       case _IGNORE_CASE:
2460       case _PARSER_BEGIN:
2461       case _PARSER_END:
2462       case _JAVACODE:
2463       case _TOKEN:
2464       case _SPECIAL_TOKEN:
2465       case _MORE:
2466       case _SKIP:
2467       case _TOKEN_MGR_DECLS:
2468       case _EOF:
2469       case BOOLEAN:
2470       case BYTE:
2471       case CHAR:
2472       case DOUBLE:
2473       case FALSE:
2474       case FLOAT:
2475       case INT:
2476       case LONG:
2477       case NEW:
2478       case NULL:
2479       case SHORT:
2480       case SUPER:
2481       case THIS:
2482       case TRUE:
2483       case VOID:
2484       case INTEGER_LITERAL:
2485       case FLOATING_POINT_LITERAL:
2486       case CHARACTER_LITERAL:
2487       case STRING_LITERAL:
2488       case LPAREN:
2489       case IDENTIFIER:
2490         if (jj_2_17(2)) {
2491           PrimaryExpression();
2492           jj_consume_token(DOT);
2493         } else {
2494           ;
2495         }
2496         jj_consume_token(SUPER);
2497         Arguments();
2498         jj_consume_token(SEMICOLON);
2499         break;
2500       default:
2501         jj_la1[97] = jj_gen;
2502         jj_consume_token(-1);
2503         throw new ParseException();
2504       }
2505     }
2506   }
2507 
2508   final public void Initializer() throws ParseException {
2509     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2510     case STATIC:
2511       jj_consume_token(STATIC);
2512       break;
2513     default:
2514       jj_la1[98] = jj_gen;
2515       ;
2516     }
2517     Block();
2518   }
2519 
2520 /*
2521  * Type, name and expression syntax follows.
2522  */
2523   final public void Type() throws ParseException {
2524     if (jj_2_19(2)) {
2525       ReferenceType();
2526     } else {
2527       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2528       case BOOLEAN:
2529       case BYTE:
2530       case CHAR:
2531       case DOUBLE:
2532       case FLOAT:
2533       case INT:
2534       case LONG:
2535       case SHORT:
2536         PrimitiveType();
2537         break;
2538       default:
2539         jj_la1[99] = jj_gen;
2540         jj_consume_token(-1);
2541         throw new ParseException();
2542       }
2543     }
2544   }
2545 
2546   final public void ReferenceType() throws ParseException {
2547     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2548     case BOOLEAN:
2549     case BYTE:
2550     case CHAR:
2551     case DOUBLE:
2552     case FLOAT:
2553     case INT:
2554     case LONG:
2555     case SHORT:
2556       PrimitiveType();
2557       label_35:
2558       while (true) {
2559         jj_consume_token(LBRACKET);
2560         jj_consume_token(RBRACKET);
2561         if (jj_2_20(2)) {
2562           ;
2563         } else {
2564           break label_35;
2565         }
2566       }
2567       break;
2568     case _LOOKAHEAD:
2569     case _IGNORE_CASE:
2570     case _PARSER_BEGIN:
2571     case _PARSER_END:
2572     case _JAVACODE:
2573     case _TOKEN:
2574     case _SPECIAL_TOKEN:
2575     case _MORE:
2576     case _SKIP:
2577     case _TOKEN_MGR_DECLS:
2578     case _EOF:
2579     case IDENTIFIER:
2580       ClassOrInterfaceType();
2581       label_36:
2582       while (true) {
2583         if (jj_2_21(2)) {
2584           ;
2585         } else {
2586           break label_36;
2587         }
2588         jj_consume_token(LBRACKET);
2589         jj_consume_token(RBRACKET);
2590       }
2591       break;
2592     default:
2593       jj_la1[100] = jj_gen;
2594       jj_consume_token(-1);
2595       throw new ParseException();
2596     }
2597   }
2598 
2599   final public String ClassOrInterfaceType() throws ParseException {
2600   String s, s1;
2601   StringBuilder sb = new StringBuilder();
2602     s = Name();
2603     if (jj_2_22(2)) {
2604       TypeArguments();
2605     } else {
2606       ;
2607     }
2608     label_37:
2609     while (true) {
2610       if (jj_2_23(2)) {
2611         ;
2612       } else {
2613         break label_37;
2614       }
2615       jj_consume_token(DOT);
2616       s1 = Name();
2617                                    sb.append("."); sb.append(s1);
2618       if (jj_2_24(2)) {
2619         TypeArguments();
2620       } else {
2621         ;
2622       }
2623     }
2624         {if (true) return s + sb.toString();}
2625     throw new Error("Missing return statement in function");
2626   }
2627 
2628   final public void TypeArguments() throws ParseException {
2629     jj_consume_token(LT);
2630     TypeArgument();
2631     label_38:
2632     while (true) {
2633       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2634       case COMMA:
2635         ;
2636         break;
2637       default:
2638         jj_la1[101] = jj_gen;
2639         break label_38;
2640       }
2641       jj_consume_token(COMMA);
2642       TypeArgument();
2643     }
2644     jj_consume_token(GT);
2645   }
2646 
2647   final public void TypeArgument() throws ParseException {
2648     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2649     case _LOOKAHEAD:
2650     case _IGNORE_CASE:
2651     case _PARSER_BEGIN:
2652     case _PARSER_END:
2653     case _JAVACODE:
2654     case _TOKEN:
2655     case _SPECIAL_TOKEN:
2656     case _MORE:
2657     case _SKIP:
2658     case _TOKEN_MGR_DECLS:
2659     case _EOF:
2660     case BOOLEAN:
2661     case BYTE:
2662     case CHAR:
2663     case DOUBLE:
2664     case FLOAT:
2665     case INT:
2666     case LONG:
2667     case SHORT:
2668     case IDENTIFIER:
2669       ReferenceType();
2670       break;
2671     case HOOK:
2672       jj_consume_token(HOOK);
2673       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2674       case EXTENDS:
2675       case SUPER:
2676         WildcardBounds();
2677         break;
2678       default:
2679         jj_la1[102] = jj_gen;
2680         ;
2681       }
2682       break;
2683     default:
2684       jj_la1[103] = jj_gen;
2685       jj_consume_token(-1);
2686       throw new ParseException();
2687     }
2688   }
2689 
2690   final public void WildcardBounds() throws ParseException {
2691     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2692     case EXTENDS:
2693       jj_consume_token(EXTENDS);
2694       ReferenceType();
2695       break;
2696     case SUPER:
2697       jj_consume_token(SUPER);
2698       ReferenceType();
2699       break;
2700     default:
2701       jj_la1[104] = jj_gen;
2702       jj_consume_token(-1);
2703       throw new ParseException();
2704     }
2705   }
2706 
2707   final public void PrimitiveType() throws ParseException {
2708     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2709     case BOOLEAN:
2710       jj_consume_token(BOOLEAN);
2711       break;
2712     case CHAR:
2713       jj_consume_token(CHAR);
2714       break;
2715     case BYTE:
2716       jj_consume_token(BYTE);
2717       break;
2718     case SHORT:
2719       jj_consume_token(SHORT);
2720       break;
2721     case INT:
2722       jj_consume_token(INT);
2723       break;
2724     case LONG:
2725       jj_consume_token(LONG);
2726       break;
2727     case FLOAT:
2728       jj_consume_token(FLOAT);
2729       break;
2730     case DOUBLE:
2731       jj_consume_token(DOUBLE);
2732       break;
2733     default:
2734       jj_la1[105] = jj_gen;
2735       jj_consume_token(-1);
2736       throw new ParseException();
2737     }
2738   }
2739 
2740   final public void ResultType() throws ParseException {
2741     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2742     case VOID:
2743       jj_consume_token(VOID);
2744       break;
2745     case _LOOKAHEAD:
2746     case _IGNORE_CASE:
2747     case _PARSER_BEGIN:
2748     case _PARSER_END:
2749     case _JAVACODE:
2750     case _TOKEN:
2751     case _SPECIAL_TOKEN:
2752     case _MORE:
2753     case _SKIP:
2754     case _TOKEN_MGR_DECLS:
2755     case _EOF:
2756     case BOOLEAN:
2757     case BYTE:
2758     case CHAR:
2759     case DOUBLE:
2760     case FLOAT:
2761     case INT:
2762     case LONG:
2763     case SHORT:
2764     case IDENTIFIER:
2765       Type();
2766       break;
2767     default:
2768       jj_la1[106] = jj_gen;
2769       jj_consume_token(-1);
2770       throw new ParseException();
2771     }
2772   }
2773 
2774   final public String Name() throws ParseException {
2775  /*@bgen(jjtree) Name */
2776   ASTName jjtn000 = new ASTName(this, JJTNAME);
2777   boolean jjtc000 = true;
2778   jjtree.openNodeScope(jjtn000);
2779   jjtreeOpenNodeScope(jjtn000);String s, ss;
2780     try {
2781       s = JavaIdentifier();
2782       label_39:
2783       while (true) {
2784         if (jj_2_25(2)) {
2785           ;
2786         } else {
2787           break label_39;
2788         }
2789         jj_consume_token(DOT);
2790         ss = JavaIdentifier();
2791                                            s += "." + ss;
2792       }
2793           jjtree.closeNodeScope(jjtn000, true);
2794           jjtc000 = false;
2795           jjtreeCloseNodeScope(jjtn000);
2796                   {if (true) return jjtn000.text = s;}
2797     } catch (Throwable jjte000) {
2798     if (jjtc000) {
2799       jjtree.clearNodeScope(jjtn000);
2800       jjtc000 = false;
2801     } else {
2802       jjtree.popNode();
2803     }
2804     if (jjte000 instanceof RuntimeException) {
2805       {if (true) throw (RuntimeException)jjte000;}
2806     }
2807     if (jjte000 instanceof ParseException) {
2808       {if (true) throw (ParseException)jjte000;}
2809     }
2810     {if (true) throw (Error)jjte000;}
2811     } finally {
2812     if (jjtc000) {
2813       jjtree.closeNodeScope(jjtn000, true);
2814       jjtreeCloseNodeScope(jjtn000);
2815     }
2816     }
2817     throw new Error("Missing return statement in function");
2818   }
2819 
2820   final public void NameList() throws ParseException {
2821     Name();
2822     label_40:
2823     while (true) {
2824       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2825       case COMMA:
2826         ;
2827         break;
2828       default:
2829         jj_la1[107] = jj_gen;
2830         break label_40;
2831       }
2832       jj_consume_token(COMMA);
2833       Name();
2834     }
2835   }
2836 
2837 /*
2838  * Expression syntax follows.
2839  */
2840   final public void Expression() throws ParseException {
2841     ConditionalExpression();
2842     if (jj_2_26(2)) {
2843       AssignmentOperator();
2844       Expression();
2845     } else {
2846       ;
2847     }
2848   }
2849 
2850   final public void AssignmentOperator() throws ParseException {
2851     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2852     case ASSIGN:
2853       jj_consume_token(ASSIGN);
2854       break;
2855     case STARASSIGN:
2856       jj_consume_token(STARASSIGN);
2857       break;
2858     case SLASHASSIGN:
2859       jj_consume_token(SLASHASSIGN);
2860       break;
2861     case REMASSIGN:
2862       jj_consume_token(REMASSIGN);
2863       break;
2864     case PLUSASSIGN:
2865       jj_consume_token(PLUSASSIGN);
2866       break;
2867     case MINUSASSIGN:
2868       jj_consume_token(MINUSASSIGN);
2869       break;
2870     case 132:
2871       jj_consume_token(132);
2872       break;
2873     case 133:
2874       jj_consume_token(133);
2875       break;
2876     case 134:
2877       jj_consume_token(134);
2878       break;
2879     case ANDASSIGN:
2880       jj_consume_token(ANDASSIGN);
2881       break;
2882     case XORASSIGN:
2883       jj_consume_token(XORASSIGN);
2884       break;
2885     case ORASSIGN:
2886       jj_consume_token(ORASSIGN);
2887       break;
2888     default:
2889       jj_la1[108] = jj_gen;
2890       jj_consume_token(-1);
2891       throw new ParseException();
2892     }
2893   }
2894 
2895   final public void ConditionalExpression() throws ParseException {
2896     ConditionalOrExpression();
2897     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2898     case HOOK:
2899       jj_consume_token(HOOK);
2900       Expression();
2901       jj_consume_token(COLON);
2902       Expression();
2903       break;
2904     default:
2905       jj_la1[109] = jj_gen;
2906       ;
2907     }
2908   }
2909 
2910   final public void ConditionalOrExpression() throws ParseException {
2911     ConditionalAndExpression();
2912     label_41:
2913     while (true) {
2914       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2915       case SC_OR:
2916         ;
2917         break;
2918       default:
2919         jj_la1[110] = jj_gen;
2920         break label_41;
2921       }
2922       jj_consume_token(SC_OR);
2923       ConditionalAndExpression();
2924     }
2925   }
2926 
2927   final public void ConditionalAndExpression() throws ParseException {
2928     InclusiveOrExpression();
2929     label_42:
2930     while (true) {
2931       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2932       case SC_AND:
2933         ;
2934         break;
2935       default:
2936         jj_la1[111] = jj_gen;
2937         break label_42;
2938       }
2939       jj_consume_token(SC_AND);
2940       InclusiveOrExpression();
2941     }
2942   }
2943 
2944   final public void InclusiveOrExpression() throws ParseException {
2945     ExclusiveOrExpression();
2946     label_43:
2947     while (true) {
2948       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2949       case BIT_OR:
2950         ;
2951         break;
2952       default:
2953         jj_la1[112] = jj_gen;
2954         break label_43;
2955       }
2956       jj_consume_token(BIT_OR);
2957       ExclusiveOrExpression();
2958     }
2959   }
2960 
2961   final public void ExclusiveOrExpression() throws ParseException {
2962     AndExpression();
2963     label_44:
2964     while (true) {
2965       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2966       case XOR:
2967         ;
2968         break;
2969       default:
2970         jj_la1[113] = jj_gen;
2971         break label_44;
2972       }
2973       jj_consume_token(XOR);
2974       AndExpression();
2975     }
2976   }
2977 
2978   final public void AndExpression() throws ParseException {
2979     EqualityExpression();
2980     label_45:
2981     while (true) {
2982       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2983       case BIT_AND:
2984         ;
2985         break;
2986       default:
2987         jj_la1[114] = jj_gen;
2988         break label_45;
2989       }
2990       jj_consume_token(BIT_AND);
2991       EqualityExpression();
2992     }
2993   }
2994 
2995   final public void EqualityExpression() throws ParseException {
2996     InstanceOfExpression();
2997     label_46:
2998     while (true) {
2999       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3000       case EQ:
3001       case NE:
3002         ;
3003         break;
3004       default:
3005         jj_la1[115] = jj_gen;
3006         break label_46;
3007       }
3008       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3009       case EQ:
3010         jj_consume_token(EQ);
3011         break;
3012       case NE:
3013         jj_consume_token(NE);
3014         break;
3015       default:
3016         jj_la1[116] = jj_gen;
3017         jj_consume_token(-1);
3018         throw new ParseException();
3019       }
3020       InstanceOfExpression();
3021     }
3022   }
3023 
3024   final public void InstanceOfExpression() throws ParseException {
3025     RelationalExpression();
3026     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3027     case INSTANCEOF:
3028       jj_consume_token(INSTANCEOF);
3029       Type();
3030       break;
3031     default:
3032       jj_la1[117] = jj_gen;
3033       ;
3034     }
3035   }
3036 
3037   final public void RelationalExpression() throws ParseException {
3038     ShiftExpression();
3039     label_47:
3040     while (true) {
3041       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3042       case LT:
3043       case LE:
3044       case GE:
3045       case GT:
3046         ;
3047         break;
3048       default:
3049         jj_la1[118] = jj_gen;
3050         break label_47;
3051       }
3052       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3053       case LT:
3054         jj_consume_token(LT);
3055         break;
3056       case GT:
3057         jj_consume_token(GT);
3058         break;
3059       case LE:
3060         jj_consume_token(LE);
3061         break;
3062       case GE:
3063         jj_consume_token(GE);
3064         break;
3065       default:
3066         jj_la1[119] = jj_gen;
3067         jj_consume_token(-1);
3068         throw new ParseException();
3069       }
3070       ShiftExpression();
3071     }
3072   }
3073 
3074   final public void ShiftExpression() throws ParseException {
3075     AdditiveExpression();
3076     label_48:
3077     while (true) {
3078       if (jj_2_27(1)) {
3079         ;
3080       } else {
3081         break label_48;
3082       }
3083       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3084       case 135:
3085         jj_consume_token(135);
3086         break;
3087       default:
3088         jj_la1[120] = jj_gen;
3089         if (jj_2_28(1)) {
3090           RSIGNEDSHIFT();
3091         } else if (jj_2_29(1)) {
3092           RUNSIGNEDSHIFT();
3093         } else {
3094           jj_consume_token(-1);
3095           throw new ParseException();
3096         }
3097       }
3098       AdditiveExpression();
3099     }
3100   }
3101 
3102   final public void AdditiveExpression() throws ParseException {
3103     MultiplicativeExpression();
3104     label_49:
3105     while (true) {
3106       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3107       case PLUS:
3108       case MINUS:
3109         ;
3110         break;
3111       default:
3112         jj_la1[121] = jj_gen;
3113         break label_49;
3114       }
3115       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3116       case PLUS:
3117         jj_consume_token(PLUS);
3118         break;
3119       case MINUS:
3120         jj_consume_token(MINUS);
3121         break;
3122       default:
3123         jj_la1[122] = jj_gen;
3124         jj_consume_token(-1);
3125         throw new ParseException();
3126       }
3127       MultiplicativeExpression();
3128     }
3129   }
3130 
3131   final public void MultiplicativeExpression() throws ParseException {
3132     UnaryExpression();
3133     label_50:
3134     while (true) {
3135       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3136       case STAR:
3137       case SLASH:
3138       case REM:
3139         ;
3140         break;
3141       default:
3142         jj_la1[123] = jj_gen;
3143         break label_50;
3144       }
3145       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3146       case STAR:
3147         jj_consume_token(STAR);
3148         break;
3149       case SLASH:
3150         jj_consume_token(SLASH);
3151         break;
3152       case REM:
3153         jj_consume_token(REM);
3154         break;
3155       default:
3156         jj_la1[124] = jj_gen;
3157         jj_consume_token(-1);
3158         throw new ParseException();
3159       }
3160       UnaryExpression();
3161     }
3162   }
3163 
3164   final public void UnaryExpression() throws ParseException {
3165     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3166     case PLUS:
3167     case MINUS:
3168       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3169       case PLUS:
3170         jj_consume_token(PLUS);
3171         break;
3172       case MINUS:
3173         jj_consume_token(MINUS);
3174         break;
3175       default:
3176         jj_la1[125] = jj_gen;
3177         jj_consume_token(-1);
3178         throw new ParseException();
3179       }
3180       UnaryExpression();
3181       break;
3182     case INCR:
3183       PreIncrementExpression();
3184       break;
3185     case DECR:
3186       PreDecrementExpression();
3187       break;
3188     case _LOOKAHEAD:
3189     case _IGNORE_CASE:
3190     case _PARSER_BEGIN:
3191     case _PARSER_END:
3192     case _JAVACODE:
3193     case _TOKEN:
3194     case _SPECIAL_TOKEN:
3195     case _MORE:
3196     case _SKIP:
3197     case _TOKEN_MGR_DECLS:
3198     case _EOF:
3199     case BOOLEAN:
3200     case BYTE:
3201     case CHAR:
3202     case DOUBLE:
3203     case FALSE:
3204     case FLOAT:
3205     case INT:
3206     case LONG:
3207     case NEW:
3208     case NULL:
3209     case SHORT:
3210     case SUPER:
3211     case THIS:
3212     case TRUE:
3213     case VOID:
3214     case INTEGER_LITERAL:
3215     case FLOATING_POINT_LITERAL:
3216     case CHARACTER_LITERAL:
3217     case STRING_LITERAL:
3218     case LPAREN:
3219     case BANG:
3220     case TILDE:
3221     case IDENTIFIER:
3222       UnaryExpressionNotPlusMinus();
3223       break;
3224     default:
3225       jj_la1[126] = jj_gen;
3226       jj_consume_token(-1);
3227       throw new ParseException();
3228     }
3229   }
3230 
3231   final public void PreIncrementExpression() throws ParseException {
3232     jj_consume_token(INCR);
3233     PrimaryExpression();
3234   }
3235 
3236   final public void PreDecrementExpression() throws ParseException {
3237     jj_consume_token(DECR);
3238     PrimaryExpression();
3239   }
3240 
3241   final public void UnaryExpressionNotPlusMinus() throws ParseException {
3242     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3243     case BANG:
3244     case TILDE:
3245       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3246       case TILDE:
3247         jj_consume_token(TILDE);
3248         break;
3249       case BANG:
3250         jj_consume_token(BANG);
3251         break;
3252       default:
3253         jj_la1[127] = jj_gen;
3254         jj_consume_token(-1);
3255         throw new ParseException();
3256       }
3257       UnaryExpression();
3258       break;
3259     default:
3260       jj_la1[128] = jj_gen;
3261       if (jj_2_30(2147483647)) {
3262         CastExpression();
3263       } else {
3264         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3265         case _LOOKAHEAD:
3266         case _IGNORE_CASE:
3267         case _PARSER_BEGIN:
3268         case _PARSER_END:
3269         case _JAVACODE:
3270         case _TOKEN:
3271         case _SPECIAL_TOKEN:
3272         case _MORE:
3273         case _SKIP:
3274         case _TOKEN_MGR_DECLS:
3275         case _EOF:
3276         case BOOLEAN:
3277         case BYTE:
3278         case CHAR:
3279         case DOUBLE:
3280         case FALSE:
3281         case FLOAT:
3282         case INT:
3283         case LONG:
3284         case NEW:
3285         case NULL:
3286         case SHORT:
3287         case SUPER:
3288         case THIS:
3289         case TRUE:
3290         case VOID:
3291         case INTEGER_LITERAL:
3292         case FLOATING_POINT_LITERAL:
3293         case CHARACTER_LITERAL:
3294         case STRING_LITERAL:
3295         case LPAREN:
3296         case IDENTIFIER:
3297           PostfixExpression();
3298           break;
3299         default:
3300           jj_la1[129] = jj_gen;
3301           jj_consume_token(-1);
3302           throw new ParseException();
3303         }
3304       }
3305     }
3306   }
3307 
3308 // This production is to determine lookahead only.  The LOOKAHEAD specifications
3309 // below are not used, but they are there just to indicate that we know about
3310 // this.
3311   final public void CastLookahead() throws ParseException {
3312     if (jj_2_31(2)) {
3313       jj_consume_token(LPAREN);
3314       PrimitiveType();
3315     } else if (jj_2_32(2147483647)) {
3316       jj_consume_token(LPAREN);
3317       Type();
3318       jj_consume_token(LBRACKET);
3319       jj_consume_token(RBRACKET);
3320     } else {
3321       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3322       case LPAREN:
3323         jj_consume_token(LPAREN);
3324         Type();
3325         jj_consume_token(RPAREN);
3326         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3327         case TILDE:
3328           jj_consume_token(TILDE);
3329           break;
3330         case BANG:
3331           jj_consume_token(BANG);
3332           break;
3333         case LPAREN:
3334           jj_consume_token(LPAREN);
3335           break;
3336         case _LOOKAHEAD:
3337         case _IGNORE_CASE:
3338         case _PARSER_BEGIN:
3339         case _PARSER_END:
3340         case _JAVACODE:
3341         case _TOKEN:
3342         case _SPECIAL_TOKEN:
3343         case _MORE:
3344         case _SKIP:
3345         case _TOKEN_MGR_DECLS:
3346         case _EOF:
3347         case IDENTIFIER:
3348           JavaIdentifier();
3349           break;
3350         case THIS:
3351           jj_consume_token(THIS);
3352           break;
3353         case SUPER:
3354           jj_consume_token(SUPER);
3355           break;
3356         case NEW:
3357           jj_consume_token(NEW);
3358           break;
3359         case FALSE:
3360         case NULL:
3361         case TRUE:
3362         case INTEGER_LITERAL:
3363         case FLOATING_POINT_LITERAL:
3364         case CHARACTER_LITERAL:
3365         case STRING_LITERAL:
3366           Literal();
3367           break;
3368         default:
3369           jj_la1[130] = jj_gen;
3370           jj_consume_token(-1);
3371           throw new ParseException();
3372         }
3373         break;
3374       default:
3375         jj_la1[131] = jj_gen;
3376         jj_consume_token(-1);
3377         throw new ParseException();
3378       }
3379     }
3380   }
3381 
3382   final public void PostfixExpression() throws ParseException {
3383     PrimaryExpression();
3384     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3385     case INCR:
3386     case DECR:
3387       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3388       case INCR:
3389         jj_consume_token(INCR);
3390         break;
3391       case DECR:
3392         jj_consume_token(DECR);
3393         break;
3394       default:
3395         jj_la1[132] = jj_gen;
3396         jj_consume_token(-1);
3397         throw new ParseException();
3398       }
3399       break;
3400     default:
3401       jj_la1[133] = jj_gen;
3402       ;
3403     }
3404   }
3405 
3406   final public void CastExpression() throws ParseException {
3407     if (jj_2_33(2147483647)) {
3408       jj_consume_token(LPAREN);
3409       Type();
3410       jj_consume_token(RPAREN);
3411       UnaryExpression();
3412     } else {
3413       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3414       case LPAREN:
3415         jj_consume_token(LPAREN);
3416         Type();
3417         jj_consume_token(RPAREN);
3418         UnaryExpressionNotPlusMinus();
3419         break;
3420       default:
3421         jj_la1[134] = jj_gen;
3422         jj_consume_token(-1);
3423         throw new ParseException();
3424       }
3425     }
3426   }
3427 
3428   final public void PrimaryExpression() throws ParseException {
3429     PrimaryPrefix();
3430     label_51:
3431     while (true) {
3432       if (jj_2_34(2)) {
3433         ;
3434       } else {
3435         break label_51;
3436       }
3437       PrimarySuffix();
3438     }
3439   }
3440 
3441   final public void MemberSelector() throws ParseException {
3442     jj_consume_token(DOT);
3443     TypeArguments();
3444     JavaIdentifier();
3445   }
3446 
3447   final public void PrimaryPrefix() throws ParseException {
3448     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3449     case FALSE:
3450     case NULL:
3451     case TRUE:
3452     case INTEGER_LITERAL:
3453     case FLOATING_POINT_LITERAL:
3454     case CHARACTER_LITERAL:
3455     case STRING_LITERAL:
3456       Literal();
3457       break;
3458     case THIS:
3459       jj_consume_token(THIS);
3460       break;
3461     case SUPER:
3462       jj_consume_token(SUPER);
3463       jj_consume_token(DOT);
3464       JavaIdentifier();
3465       break;
3466     case LPAREN:
3467       jj_consume_token(LPAREN);
3468       Expression();
3469       jj_consume_token(RPAREN);
3470       break;
3471     case NEW:
3472       AllocationExpression();
3473       break;
3474     default:
3475       jj_la1[135] = jj_gen;
3476       if (jj_2_35(2147483647)) {
3477         ResultType();
3478         jj_consume_token(DOT);
3479         jj_consume_token(CLASS);
3480       } else {
3481         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3482         case _LOOKAHEAD:
3483         case _IGNORE_CASE:
3484         case _PARSER_BEGIN:
3485         case _PARSER_END:
3486         case _JAVACODE:
3487         case _TOKEN:
3488         case _SPECIAL_TOKEN:
3489         case _MORE:
3490         case _SKIP:
3491         case _TOKEN_MGR_DECLS:
3492         case _EOF:
3493         case IDENTIFIER:
3494           Name();
3495           break;
3496         default:
3497           jj_la1[136] = jj_gen;
3498           jj_consume_token(-1);
3499           throw new ParseException();
3500         }
3501       }
3502     }
3503   }
3504 
3505   final public void PrimarySuffix() throws ParseException {
3506     if (jj_2_36(2)) {
3507       jj_consume_token(DOT);
3508       jj_consume_token(THIS);
3509     } else if (jj_2_37(2)) {
3510       jj_consume_token(DOT);
3511       AllocationExpression();
3512     } else if (jj_2_38(3)) {
3513       MemberSelector();
3514     } else {
3515       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3516       case LBRACKET:
3517         jj_consume_token(LBRACKET);
3518         Expression();
3519         jj_consume_token(RBRACKET);
3520         break;
3521       case DOT:
3522         jj_consume_token(DOT);
3523         JavaIdentifier();
3524         break;
3525       case LPAREN:
3526         Arguments();
3527         break;
3528       default:
3529         jj_la1[137] = jj_gen;
3530         jj_consume_token(-1);
3531         throw new ParseException();
3532       }
3533     }
3534   }
3535 
3536   final public void Literal() throws ParseException {
3537     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3538     case INTEGER_LITERAL:
3539       jj_consume_token(INTEGER_LITERAL);
3540       break;
3541     case FLOATING_POINT_LITERAL:
3542       jj_consume_token(FLOATING_POINT_LITERAL);
3543       break;
3544     case CHARACTER_LITERAL:
3545       jj_consume_token(CHARACTER_LITERAL);
3546       break;
3547     case STRING_LITERAL:
3548       jj_consume_token(STRING_LITERAL);
3549       break;
3550     case FALSE:
3551     case TRUE:
3552       BooleanLiteral();
3553       break;
3554     case NULL:
3555       NullLiteral();
3556       break;
3557     default:
3558       jj_la1[138] = jj_gen;
3559       jj_consume_token(-1);
3560       throw new ParseException();
3561     }
3562   }
3563 
3564   final public Token IntegerLiteral() throws ParseException {
3565   Token t;
3566     t = jj_consume_token(INTEGER_LITERAL);
3567                   {if (true) return t;}
3568     throw new Error("Missing return statement in function");
3569   }
3570 
3571   final public Token BooleanLiteral() throws ParseException {
3572   Token t;
3573     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3574     case TRUE:
3575       t = jj_consume_token(TRUE);
3576                   {if (true) return t;}
3577       break;
3578     case FALSE:
3579       t = jj_consume_token(FALSE);
3580                   {if (true) return t;}
3581       break;
3582     default:
3583       jj_la1[139] = jj_gen;
3584       jj_consume_token(-1);
3585       throw new ParseException();
3586     }
3587     throw new Error("Missing return statement in function");
3588   }
3589 
3590   final public Token StringLiteral() throws ParseException {
3591   Token t;
3592     t = jj_consume_token(STRING_LITERAL);
3593                   {if (true) return t;}
3594     throw new Error("Missing return statement in function");
3595   }
3596 
3597   final public void NullLiteral() throws ParseException {
3598     jj_consume_token(NULL);
3599   }
3600 
3601   final public void Arguments() throws ParseException {
3602     jj_consume_token(LPAREN);
3603     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3604     case _LOOKAHEAD:
3605     case _IGNORE_CASE:
3606     case _PARSER_BEGIN:
3607     case _PARSER_END:
3608     case _JAVACODE:
3609     case _TOKEN:
3610     case _SPECIAL_TOKEN:
3611     case _MORE:
3612     case _SKIP:
3613     case _TOKEN_MGR_DECLS:
3614     case _EOF:
3615     case BOOLEAN:
3616     case BYTE:
3617     case CHAR:
3618     case DOUBLE:
3619     case FALSE:
3620     case FLOAT:
3621     case INT:
3622     case LONG:
3623     case NEW:
3624     case NULL:
3625     case SHORT:
3626     case SUPER:
3627     case THIS:
3628     case TRUE:
3629     case VOID:
3630     case INTEGER_LITERAL:
3631     case FLOATING_POINT_LITERAL:
3632     case CHARACTER_LITERAL:
3633     case STRING_LITERAL:
3634     case LPAREN:
3635     case BANG:
3636     case TILDE:
3637     case INCR:
3638     case DECR:
3639     case PLUS:
3640     case MINUS:
3641     case IDENTIFIER:
3642       ArgumentList();
3643       break;
3644     default:
3645       jj_la1[140] = jj_gen;
3646       ;
3647     }
3648     jj_consume_token(RPAREN);
3649   }
3650 
3651   final public void ArgumentList() throws ParseException {
3652     Expression();
3653     label_52:
3654     while (true) {
3655       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3656       case COMMA:
3657         ;
3658         break;
3659       default:
3660         jj_la1[141] = jj_gen;
3661         break label_52;
3662       }
3663       jj_consume_token(COMMA);
3664       Expression();
3665     }
3666   }
3667 
3668   final public void AllocationExpression() throws ParseException {
3669     if (jj_2_39(2)) {
3670       jj_consume_token(NEW);
3671       PrimitiveType();
3672       ArrayDimsAndInits();
3673     } else {
3674       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3675       case NEW:
3676         jj_consume_token(NEW);
3677         ClassOrInterfaceType();
3678         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3679         case LT:
3680           TypeArguments();
3681           break;
3682         default:
3683           jj_la1[142] = jj_gen;
3684           ;
3685         }
3686         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3687         case LBRACKET:
3688           ArrayDimsAndInits();
3689           break;
3690         case LPAREN:
3691           Arguments();
3692           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3693           case LBRACE:
3694             ClassOrInterfaceBody(false);
3695             break;
3696           default:
3697             jj_la1[143] = jj_gen;
3698             ;
3699           }
3700           break;
3701         default:
3702           jj_la1[144] = jj_gen;
3703           jj_consume_token(-1);
3704           throw new ParseException();
3705         }
3706         break;
3707       default:
3708         jj_la1[145] = jj_gen;
3709         jj_consume_token(-1);
3710         throw new ParseException();
3711       }
3712     }
3713   }
3714 
3715 /*
3716  * The third LOOKAHEAD specification below is to parse to PrimarySuffix
3717  * if there is an expression between the "[...]".
3718  */
3719   final public void ArrayDimsAndInits() throws ParseException {
3720     if (jj_2_42(2)) {
3721       label_53:
3722       while (true) {
3723         jj_consume_token(LBRACKET);
3724         Expression();
3725         jj_consume_token(RBRACKET);
3726         if (jj_2_40(2)) {
3727           ;
3728         } else {
3729           break label_53;
3730         }
3731       }
3732       label_54:
3733       while (true) {
3734         if (jj_2_41(2)) {
3735           ;
3736         } else {
3737           break label_54;
3738         }
3739         jj_consume_token(LBRACKET);
3740         jj_consume_token(RBRACKET);
3741       }
3742     } else {
3743       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3744       case LBRACKET:
3745         label_55:
3746         while (true) {
3747           jj_consume_token(LBRACKET);
3748           jj_consume_token(RBRACKET);
3749           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3750           case LBRACKET:
3751             ;
3752             break;
3753           default:
3754             jj_la1[146] = jj_gen;
3755             break label_55;
3756           }
3757         }
3758         ArrayInitializer();
3759         break;
3760       default:
3761         jj_la1[147] = jj_gen;
3762         jj_consume_token(-1);
3763         throw new ParseException();
3764       }
3765     }
3766   }
3767 
3768 /*
3769  * Statement syntax follows.
3770  */
3771   final public void Statement() throws ParseException {
3772     if (jj_2_43(2)) {
3773       LabeledStatement();
3774     } else {
3775       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3776       case 136:
3777         AssertStatement();
3778         break;
3779       case LBRACE:
3780         Block();
3781         break;
3782       case SEMICOLON:
3783         EmptyStatement();
3784         break;
3785       case _LOOKAHEAD:
3786       case _IGNORE_CASE:
3787       case _PARSER_BEGIN:
3788       case _PARSER_END:
3789       case _JAVACODE:
3790       case _TOKEN:
3791       case _SPECIAL_TOKEN:
3792       case _MORE:
3793       case _SKIP:
3794       case _TOKEN_MGR_DECLS:
3795       case _EOF:
3796       case BOOLEAN:
3797       case BYTE:
3798       case CHAR:
3799       case DOUBLE:
3800       case FALSE:
3801       case FLOAT:
3802       case INT:
3803       case LONG:
3804       case NEW:
3805       case NULL:
3806       case SHORT:
3807       case SUPER:
3808       case THIS:
3809       case TRUE:
3810       case VOID:
3811       case INTEGER_LITERAL:
3812       case FLOATING_POINT_LITERAL:
3813       case CHARACTER_LITERAL:
3814       case STRING_LITERAL:
3815       case LPAREN:
3816       case INCR:
3817       case DECR:
3818       case IDENTIFIER:
3819         StatementExpression();
3820         jj_consume_token(SEMICOLON);
3821         break;
3822       case SWITCH:
3823         SwitchStatement();
3824         break;
3825       case IF:
3826         IfStatement();
3827         break;
3828       case WHILE:
3829         WhileStatement();
3830         break;
3831       case DO:
3832         DoStatement();
3833         break;
3834       case FOR:
3835         ForStatement();
3836         break;
3837       case BREAK:
3838         BreakStatement();
3839         break;
3840       case CONTINUE:
3841         ContinueStatement();
3842         break;
3843       case RETURN:
3844         ReturnStatement();
3845         break;
3846       case THROW:
3847         ThrowStatement();
3848         break;
3849       case SYNCHRONIZED:
3850         SynchronizedStatement();
3851         break;
3852       case TRY:
3853         TryStatement();
3854         break;
3855       default:
3856         jj_la1[148] = jj_gen;
3857         jj_consume_token(-1);
3858         throw new ParseException();
3859       }
3860     }
3861   }
3862 
3863   final public void AssertStatement() throws ParseException {
3864     jj_consume_token(136);
3865     Expression();
3866     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3867     case COLON:
3868       jj_consume_token(COLON);
3869       Expression();
3870       break;
3871     default:
3872       jj_la1[149] = jj_gen;
3873       ;
3874     }
3875     jj_consume_token(SEMICOLON);
3876   }
3877 
3878   final public void LabeledStatement() throws ParseException {
3879     JavaIdentifier();
3880     jj_consume_token(COLON);
3881     Statement();
3882   }
3883 
3884   final public void Block() throws ParseException {
3885     jj_consume_token(LBRACE);
3886     label_56:
3887     while (true) {
3888       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3889       case _LOOKAHEAD:
3890       case _IGNORE_CASE:
3891       case _PARSER_BEGIN:
3892       case _PARSER_END:
3893       case _JAVACODE:
3894       case _TOKEN:
3895       case _SPECIAL_TOKEN:
3896       case _MORE:
3897       case _SKIP:
3898       case _TOKEN_MGR_DECLS:
3899       case _EOF:
3900       case ABSTRACT:
3901       case BOOLEAN:
3902       case BREAK:
3903       case BYTE:
3904       case CHAR:
3905       case CLASS:
3906       case CONTINUE:
3907       case DO:
3908       case DOUBLE:
3909       case FALSE:
3910       case FINAL:
3911       case FLOAT:
3912       case FOR:
3913       case IF:
3914       case INT:
3915       case INTERFACE:
3916       case LONG:
3917       case NATIVE:
3918       case NEW:
3919       case NULL:
3920       case PRIVATE:
3921       case PROTECTED:
3922       case PUBLIC:
3923       case RETURN:
3924       case SHORT:
3925       case STATIC:
3926       case STRICTFP:
3927       case SUPER:
3928       case SWITCH:
3929       case SYNCHRONIZED:
3930       case THIS:
3931       case THROW:
3932       case TRANSIENT:
3933       case TRUE:
3934       case TRY:
3935       case VOID:
3936       case VOLATILE:
3937       case WHILE:
3938       case INTEGER_LITERAL:
3939       case FLOATING_POINT_LITERAL:
3940       case CHARACTER_LITERAL:
3941       case STRING_LITERAL:
3942       case LPAREN:
3943       case LBRACE:
3944       case SEMICOLON:
3945       case AT:
3946       case INCR:
3947       case DECR:
3948       case 136:
3949       case IDENTIFIER:
3950         ;
3951         break;
3952       default:
3953         jj_la1[150] = jj_gen;
3954         break label_56;
3955       }
3956       BlockStatement();
3957     }
3958     jj_consume_token(RBRACE);
3959   }
3960 
3961   final public void BlockStatement() throws ParseException {
3962     if (jj_2_44(2147483647)) {
3963       LocalVariableDeclaration();
3964       jj_consume_token(SEMICOLON);
3965     } else {
3966       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3967       case _LOOKAHEAD:
3968       case _IGNORE_CASE:
3969       case _PARSER_BEGIN:
3970       case _PARSER_END:
3971       case _JAVACODE:
3972       case _TOKEN:
3973       case _SPECIAL_TOKEN:
3974       case _MORE:
3975       case _SKIP:
3976       case _TOKEN_MGR_DECLS:
3977       case _EOF:
3978       case BOOLEAN:
3979       case BREAK:
3980       case BYTE:
3981       case CHAR:
3982       case CONTINUE:
3983       case DO:
3984       case DOUBLE:
3985       case FALSE:
3986       case FLOAT:
3987       case FOR:
3988       case IF:
3989       case INT:
3990       case LONG:
3991       case NEW:
3992       case NULL:
3993       case RETURN:
3994       case SHORT:
3995       case SUPER:
3996       case SWITCH:
3997       case SYNCHRONIZED:
3998       case THIS:
3999       case THROW:
4000       case TRUE:
4001       case TRY:
4002       case VOID:
4003       case WHILE:
4004       case INTEGER_LITERAL:
4005       case FLOATING_POINT_LITERAL:
4006       case CHARACTER_LITERAL:
4007       case STRING_LITERAL:
4008       case LPAREN:
4009       case LBRACE:
4010       case SEMICOLON:
4011       case INCR:
4012       case DECR:
4013       case 136:
4014       case IDENTIFIER:
4015         Statement();
4016         break;
4017       case CLASS:
4018       case INTERFACE:
4019         ClassOrInterfaceDeclaration();
4020         break;
4021       default:
4022         jj_la1[151] = jj_gen;
4023         jj_consume_token(-1);
4024         throw new ParseException();
4025       }
4026     }
4027   }
4028 
4029   final public void LocalVariableDeclaration() throws ParseException {
4030     Modifiers();
4031     Type();
4032     VariableDeclarator();
4033     label_57:
4034     while (true) {
4035       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4036       case COMMA:
4037         ;
4038         break;
4039       default:
4040         jj_la1[152] = jj_gen;
4041         break label_57;
4042       }
4043       jj_consume_token(COMMA);
4044       VariableDeclarator();
4045     }
4046   }
4047 
4048   final public void EmptyStatement() throws ParseException {
4049     jj_consume_token(SEMICOLON);
4050   }
4051 
4052   final public void StatementExpression() throws ParseException {
4053     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4054     case INCR:
4055       PreIncrementExpression();
4056       break;
4057     case DECR:
4058       PreDecrementExpression();
4059       break;
4060     case _LOOKAHEAD:
4061     case _IGNORE_CASE:
4062     case _PARSER_BEGIN:
4063     case _PARSER_END:
4064     case _JAVACODE:
4065     case _TOKEN:
4066     case _SPECIAL_TOKEN:
4067     case _MORE:
4068     case _SKIP:
4069     case _TOKEN_MGR_DECLS:
4070     case _EOF:
4071     case BOOLEAN:
4072     case BYTE:
4073     case CHAR:
4074     case DOUBLE:
4075     case FALSE:
4076     case FLOAT:
4077     case INT:
4078     case LONG:
4079     case NEW:
4080     case NULL:
4081     case SHORT:
4082     case SUPER:
4083     case THIS:
4084     case TRUE:
4085     case VOID:
4086     case INTEGER_LITERAL:
4087     case FLOATING_POINT_LITERAL:
4088     case CHARACTER_LITERAL:
4089     case STRING_LITERAL:
4090     case LPAREN:
4091     case IDENTIFIER:
4092       PrimaryExpression();
4093       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4094       case ASSIGN:
4095       case INCR:
4096       case DECR:
4097       case PLUSASSIGN:
4098       case MINUSASSIGN:
4099       case STARASSIGN:
4100       case SLASHASSIGN:
4101       case ANDASSIGN:
4102       case ORASSIGN:
4103       case XORASSIGN:
4104       case REMASSIGN:
4105       case 132:
4106       case 133:
4107       case 134:
4108         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4109         case INCR:
4110           jj_consume_token(INCR);
4111           break;
4112         case DECR:
4113           jj_consume_token(DECR);
4114           break;
4115         case ASSIGN:
4116         case PLUSASSIGN:
4117         case MINUSASSIGN:
4118         case STARASSIGN:
4119         case SLASHASSIGN:
4120         case ANDASSIGN:
4121         case ORASSIGN:
4122         case XORASSIGN:
4123         case REMASSIGN:
4124         case 132:
4125         case 133:
4126         case 134:
4127           AssignmentOperator();
4128           Expression();
4129           break;
4130         default:
4131           jj_la1[153] = jj_gen;
4132           jj_consume_token(-1);
4133           throw new ParseException();
4134         }
4135         break;
4136       default:
4137         jj_la1[154] = jj_gen;
4138         ;
4139       }
4140       break;
4141     default:
4142       jj_la1[155] = jj_gen;
4143       jj_consume_token(-1);
4144       throw new ParseException();
4145     }
4146   }
4147 
4148   final public void SwitchStatement() throws ParseException {
4149     jj_consume_token(SWITCH);
4150     jj_consume_token(LPAREN);
4151     Expression();
4152     jj_consume_token(RPAREN);
4153     jj_consume_token(LBRACE);
4154     label_58:
4155     while (true) {
4156       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4157       case CASE:
4158       case _DEFAULT:
4159         ;
4160         break;
4161       default:
4162         jj_la1[156] = jj_gen;
4163         break label_58;
4164       }
4165       SwitchLabel();
4166       label_59:
4167       while (true) {
4168         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4169         case _LOOKAHEAD:
4170         case _IGNORE_CASE:
4171         case _PARSER_BEGIN:
4172         case _PARSER_END:
4173         case _JAVACODE:
4174         case _TOKEN:
4175         case _SPECIAL_TOKEN:
4176         case _MORE:
4177         case _SKIP:
4178         case _TOKEN_MGR_DECLS:
4179         case _EOF:
4180         case ABSTRACT:
4181         case BOOLEAN:
4182         case BREAK:
4183         case BYTE:
4184         case CHAR:
4185         case CLASS:
4186         case CONTINUE:
4187         case DO:
4188         case DOUBLE:
4189         case FALSE:
4190         case FINAL:
4191         case FLOAT:
4192         case FOR:
4193         case IF:
4194         case INT:
4195         case INTERFACE:
4196         case LONG:
4197         case NATIVE:
4198         case NEW:
4199         case NULL:
4200         case PRIVATE:
4201         case PROTECTED:
4202         case PUBLIC:
4203         case RETURN:
4204         case SHORT:
4205         case STATIC:
4206         case STRICTFP:
4207         case SUPER:
4208         case SWITCH:
4209         case SYNCHRONIZED:
4210         case THIS:
4211         case THROW:
4212         case TRANSIENT:
4213         case TRUE:
4214         case TRY:
4215         case VOID:
4216         case VOLATILE:
4217         case WHILE:
4218         case INTEGER_LITERAL:
4219         case FLOATING_POINT_LITERAL:
4220         case CHARACTER_LITERAL:
4221         case STRING_LITERAL:
4222         case LPAREN:
4223         case LBRACE:
4224         case SEMICOLON:
4225         case AT:
4226         case INCR:
4227         case DECR:
4228         case 136:
4229         case IDENTIFIER:
4230           ;
4231           break;
4232         default:
4233           jj_la1[157] = jj_gen;
4234           break label_59;
4235         }
4236         BlockStatement();
4237       }
4238     }
4239     jj_consume_token(RBRACE);
4240   }
4241 
4242   final public void SwitchLabel() throws ParseException {
4243     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4244     case CASE:
4245       jj_consume_token(CASE);
4246       Expression();
4247       jj_consume_token(COLON);
4248       break;
4249     case _DEFAULT:
4250       jj_consume_token(_DEFAULT);
4251       jj_consume_token(COLON);
4252       break;
4253     default:
4254       jj_la1[158] = jj_gen;
4255       jj_consume_token(-1);
4256       throw new ParseException();
4257     }
4258   }
4259 
4260   final public void IfStatement() throws ParseException {
4261     jj_consume_token(IF);
4262     jj_consume_token(LPAREN);
4263     Expression();
4264     jj_consume_token(RPAREN);
4265     Statement();
4266     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4267     case ELSE:
4268       jj_consume_token(ELSE);
4269       Statement();
4270       break;
4271     default:
4272       jj_la1[159] = jj_gen;
4273       ;
4274     }
4275   }
4276 
4277   final public void WhileStatement() throws ParseException {
4278     jj_consume_token(WHILE);
4279     jj_consume_token(LPAREN);
4280     Expression();
4281     jj_consume_token(RPAREN);
4282     Statement();
4283   }
4284 
4285   final public void DoStatement() throws ParseException {
4286     jj_consume_token(DO);
4287     Statement();
4288     jj_consume_token(WHILE);
4289     jj_consume_token(LPAREN);
4290     Expression();
4291     jj_consume_token(RPAREN);
4292     jj_consume_token(SEMICOLON);
4293   }
4294 
4295   final public void ForStatement() throws ParseException {
4296     jj_consume_token(FOR);
4297     jj_consume_token(LPAREN);
4298     if (jj_2_45(2147483647)) {
4299       Modifiers();
4300       Type();
4301       JavaIdentifier();
4302       jj_consume_token(COLON);
4303       Expression();
4304     } else {
4305       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4306       case _LOOKAHEAD:
4307       case _IGNORE_CASE:
4308       case _PARSER_BEGIN:
4309       case _PARSER_END:
4310       case _JAVACODE:
4311       case _TOKEN:
4312       case _SPECIAL_TOKEN:
4313       case _MORE:
4314       case _SKIP:
4315       case _TOKEN_MGR_DECLS:
4316       case _EOF:
4317       case ABSTRACT:
4318       case BOOLEAN:
4319       case BYTE:
4320       case CHAR:
4321       case DOUBLE:
4322       case FALSE:
4323       case FINAL:
4324       case FLOAT:
4325       case INT:
4326       case LONG:
4327       case NATIVE:
4328       case NEW:
4329       case NULL:
4330       case PRIVATE:
4331       case PROTECTED:
4332       case PUBLIC:
4333       case SHORT:
4334       case STATIC:
4335       case STRICTFP:
4336       case SUPER:
4337       case SYNCHRONIZED:
4338       case THIS:
4339       case TRANSIENT:
4340       case TRUE:
4341       case VOID:
4342       case VOLATILE:
4343       case INTEGER_LITERAL:
4344       case FLOATING_POINT_LITERAL:
4345       case CHARACTER_LITERAL:
4346       case STRING_LITERAL:
4347       case LPAREN:
4348       case SEMICOLON:
4349       case AT:
4350       case INCR:
4351       case DECR:
4352       case IDENTIFIER:
4353         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4354         case _LOOKAHEAD:
4355         case _IGNORE_CASE:
4356         case _PARSER_BEGIN:
4357         case _PARSER_END:
4358         case _JAVACODE:
4359         case _TOKEN:
4360         case _SPECIAL_TOKEN:
4361         case _MORE:
4362         case _SKIP:
4363         case _TOKEN_MGR_DECLS:
4364         case _EOF:
4365         case ABSTRACT:
4366         case BOOLEAN:
4367         case BYTE:
4368         case CHAR:
4369         case DOUBLE:
4370         case FALSE:
4371         case FINAL:
4372         case FLOAT:
4373         case INT:
4374         case LONG:
4375         case NATIVE:
4376         case NEW:
4377         case NULL:
4378         case PRIVATE:
4379         case PROTECTED:
4380         case PUBLIC:
4381         case SHORT:
4382         case STATIC:
4383         case STRICTFP:
4384         case SUPER:
4385         case SYNCHRONIZED:
4386         case THIS:
4387         case TRANSIENT:
4388         case TRUE:
4389         case VOID:
4390         case VOLATILE:
4391         case INTEGER_LITERAL:
4392         case FLOATING_POINT_LITERAL:
4393         case CHARACTER_LITERAL:
4394         case STRING_LITERAL:
4395         case LPAREN:
4396         case AT:
4397         case INCR:
4398         case DECR:
4399         case IDENTIFIER:
4400           ForInit();
4401           break;
4402         default:
4403           jj_la1[160] = jj_gen;
4404           ;
4405         }
4406         jj_consume_token(SEMICOLON);
4407         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4408         case _LOOKAHEAD:
4409         case _IGNORE_CASE:
4410         case _PARSER_BEGIN:
4411         case _PARSER_END:
4412         case _JAVACODE:
4413         case _TOKEN:
4414         case _SPECIAL_TOKEN:
4415         case _MORE:
4416         case _SKIP:
4417         case _TOKEN_MGR_DECLS:
4418         case _EOF:
4419         case BOOLEAN:
4420         case BYTE:
4421         case CHAR:
4422         case DOUBLE:
4423         case FALSE:
4424         case FLOAT:
4425         case INT:
4426         case LONG:
4427         case NEW:
4428         case NULL:
4429         case SHORT:
4430         case SUPER:
4431         case THIS:
4432         case TRUE:
4433         case VOID:
4434         case INTEGER_LITERAL:
4435         case FLOATING_POINT_LITERAL:
4436         case CHARACTER_LITERAL:
4437         case STRING_LITERAL:
4438         case LPAREN:
4439         case BANG:
4440         case TILDE:
4441         case INCR:
4442         case DECR:
4443         case PLUS:
4444         case MINUS:
4445         case IDENTIFIER:
4446           Expression();
4447           break;
4448         default:
4449           jj_la1[161] = jj_gen;
4450           ;
4451         }
4452         jj_consume_token(SEMICOLON);
4453         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4454         case _LOOKAHEAD:
4455         case _IGNORE_CASE:
4456         case _PARSER_BEGIN:
4457         case _PARSER_END:
4458         case _JAVACODE:
4459         case _TOKEN:
4460         case _SPECIAL_TOKEN:
4461         case _MORE:
4462         case _SKIP:
4463         case _TOKEN_MGR_DECLS:
4464         case _EOF:
4465         case BOOLEAN:
4466         case BYTE:
4467         case CHAR:
4468         case DOUBLE:
4469         case FALSE:
4470         case FLOAT:
4471         case INT:
4472         case LONG:
4473         case NEW:
4474         case NULL:
4475         case SHORT:
4476         case SUPER:
4477         case THIS:
4478         case TRUE:
4479         case VOID:
4480         case INTEGER_LITERAL:
4481         case FLOATING_POINT_LITERAL:
4482         case CHARACTER_LITERAL:
4483         case STRING_LITERAL:
4484         case LPAREN:
4485         case INCR:
4486         case DECR:
4487         case IDENTIFIER:
4488           ForUpdate();
4489           break;
4490         default:
4491           jj_la1[162] = jj_gen;
4492           ;
4493         }
4494         break;
4495       default:
4496         jj_la1[163] = jj_gen;
4497         jj_consume_token(-1);
4498         throw new ParseException();
4499       }
4500     }
4501     jj_consume_token(RPAREN);
4502     Statement();
4503   }
4504 
4505   final public void ForInit() throws ParseException {
4506     if (jj_2_46(2147483647)) {
4507       LocalVariableDeclaration();
4508     } else {
4509       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4510       case _LOOKAHEAD:
4511       case _IGNORE_CASE:
4512       case _PARSER_BEGIN:
4513       case _PARSER_END:
4514       case _JAVACODE:
4515       case _TOKEN:
4516       case _SPECIAL_TOKEN:
4517       case _MORE:
4518       case _SKIP:
4519       case _TOKEN_MGR_DECLS:
4520       case _EOF:
4521       case BOOLEAN:
4522       case BYTE:
4523       case CHAR:
4524       case DOUBLE:
4525       case FALSE:
4526       case FLOAT:
4527       case INT:
4528       case LONG:
4529       case NEW:
4530       case NULL:
4531       case SHORT:
4532       case SUPER:
4533       case THIS:
4534       case TRUE:
4535       case VOID:
4536       case INTEGER_LITERAL:
4537       case FLOATING_POINT_LITERAL:
4538       case CHARACTER_LITERAL:
4539       case STRING_LITERAL:
4540       case LPAREN:
4541       case INCR:
4542       case DECR:
4543       case IDENTIFIER:
4544         StatementExpressionList();
4545         break;
4546       default:
4547         jj_la1[164] = jj_gen;
4548         jj_consume_token(-1);
4549         throw new ParseException();
4550       }
4551     }
4552   }
4553 
4554   final public void StatementExpressionList() throws ParseException {
4555     StatementExpression();
4556     label_60:
4557     while (true) {
4558       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4559       case COMMA:
4560         ;
4561         break;
4562       default:
4563         jj_la1[165] = jj_gen;
4564         break label_60;
4565       }
4566       jj_consume_token(COMMA);
4567       StatementExpression();
4568     }
4569   }
4570 
4571   final public void ForUpdate() throws ParseException {
4572     StatementExpressionList();
4573   }
4574 
4575   final public void BreakStatement() throws ParseException {
4576     jj_consume_token(BREAK);
4577     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4578     case _LOOKAHEAD:
4579     case _IGNORE_CASE:
4580     case _PARSER_BEGIN:
4581     case _PARSER_END:
4582     case _JAVACODE:
4583     case _TOKEN:
4584     case _SPECIAL_TOKEN:
4585     case _MORE:
4586     case _SKIP:
4587     case _TOKEN_MGR_DECLS:
4588     case _EOF:
4589     case IDENTIFIER:
4590       JavaIdentifier();
4591       break;
4592     default:
4593       jj_la1[166] = jj_gen;
4594       ;
4595     }
4596     jj_consume_token(SEMICOLON);
4597   }
4598 
4599   final public void ContinueStatement() throws ParseException {
4600     jj_consume_token(CONTINUE);
4601     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4602     case _LOOKAHEAD:
4603     case _IGNORE_CASE:
4604     case _PARSER_BEGIN:
4605     case _PARSER_END:
4606     case _JAVACODE:
4607     case _TOKEN:
4608     case _SPECIAL_TOKEN:
4609     case _MORE:
4610     case _SKIP:
4611     case _TOKEN_MGR_DECLS:
4612     case _EOF:
4613     case IDENTIFIER:
4614       JavaIdentifier();
4615       break;
4616     default:
4617       jj_la1[167] = jj_gen;
4618       ;
4619     }
4620     jj_consume_token(SEMICOLON);
4621   }
4622 
4623   final public void ReturnStatement() throws ParseException {
4624     jj_consume_token(RETURN);
4625     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4626     case _LOOKAHEAD:
4627     case _IGNORE_CASE:
4628     case _PARSER_BEGIN:
4629     case _PARSER_END:
4630     case _JAVACODE:
4631     case _TOKEN:
4632     case _SPECIAL_TOKEN:
4633     case _MORE:
4634     case _SKIP:
4635     case _TOKEN_MGR_DECLS:
4636     case _EOF:
4637     case BOOLEAN:
4638     case BYTE:
4639     case CHAR:
4640     case DOUBLE:
4641     case FALSE:
4642     case FLOAT:
4643     case INT:
4644     case LONG:
4645     case NEW:
4646     case NULL:
4647     case SHORT:
4648     case SUPER:
4649     case THIS:
4650     case TRUE:
4651     case VOID:
4652     case INTEGER_LITERAL:
4653     case FLOATING_POINT_LITERAL:
4654     case CHARACTER_LITERAL:
4655     case STRING_LITERAL:
4656     case LPAREN:
4657     case BANG:
4658     case TILDE:
4659     case INCR:
4660     case DECR:
4661     case PLUS:
4662     case MINUS:
4663     case IDENTIFIER:
4664       Expression();
4665       break;
4666     default:
4667       jj_la1[168] = jj_gen;
4668       ;
4669     }
4670     jj_consume_token(SEMICOLON);
4671   }
4672 
4673   final public void ThrowStatement() throws ParseException {
4674     jj_consume_token(THROW);
4675     Expression();
4676     jj_consume_token(SEMICOLON);
4677   }
4678 
4679   final public void SynchronizedStatement() throws ParseException {
4680     jj_consume_token(SYNCHRONIZED);
4681     jj_consume_token(LPAREN);
4682     Expression();
4683     jj_consume_token(RPAREN);
4684     Block();
4685   }
4686 
4687   final public void TryStatement() throws ParseException {
4688     jj_consume_token(TRY);
4689     Block();
4690     label_61:
4691     while (true) {
4692       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4693       case CATCH:
4694         ;
4695         break;
4696       default:
4697         jj_la1[169] = jj_gen;
4698         break label_61;
4699       }
4700       jj_consume_token(CATCH);
4701       jj_consume_token(LPAREN);
4702       FormalParameter();
4703       jj_consume_token(RPAREN);
4704       Block();
4705     }
4706     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4707     case FINALLY:
4708       jj_consume_token(FINALLY);
4709       Block();
4710       break;
4711     default:
4712       jj_la1[170] = jj_gen;
4713       ;
4714     }
4715   }
4716 
4717 /* We use productions to match >>>, >> and > so that we can keep the
4718  * type declaration syntax with generics clean
4719  */
4720   final public void RUNSIGNEDSHIFT() throws ParseException {
4721     if (getToken(1).kind == GT &&
4722                     getToken(1).realKind == RUNSIGNEDSHIFT) {
4723 
4724     } else {
4725       jj_consume_token(-1);
4726       throw new ParseException();
4727     }
4728     jj_consume_token(GT);
4729     jj_consume_token(GT);
4730     jj_consume_token(GT);
4731   }
4732 
4733   final public void RSIGNEDSHIFT() throws ParseException {
4734     if (getToken(1).kind == GT &&
4735                     getToken(1).realKind == RSIGNEDSHIFT) {
4736 
4737     } else {
4738       jj_consume_token(-1);
4739       throw new ParseException();
4740     }
4741     jj_consume_token(GT);
4742     jj_consume_token(GT);
4743   }
4744 
4745 /* Annotation syntax follows. */
4746   final public void Annotation() throws ParseException {
4747     if (jj_2_47(2147483647)) {
4748       NormalAnnotation();
4749     } else if (jj_2_48(2147483647)) {
4750       SingleMemberAnnotation();
4751     } else {
4752       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4753       case AT:
4754         MarkerAnnotation();
4755         break;
4756       default:
4757         jj_la1[171] = jj_gen;
4758         jj_consume_token(-1);
4759         throw new ParseException();
4760       }
4761     }
4762   }
4763 
4764   final public void NormalAnnotation() throws ParseException {
4765     jj_consume_token(AT);
4766     Name();
4767     jj_consume_token(LPAREN);
4768     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4769     case _LOOKAHEAD:
4770     case _IGNORE_CASE:
4771     case _PARSER_BEGIN:
4772     case _PARSER_END:
4773     case _JAVACODE:
4774     case _TOKEN:
4775     case _SPECIAL_TOKEN:
4776     case _MORE:
4777     case _SKIP:
4778     case _TOKEN_MGR_DECLS:
4779     case _EOF:
4780     case IDENTIFIER:
4781       MemberValuePairs();
4782       break;
4783     default:
4784       jj_la1[172] = jj_gen;
4785       ;
4786     }
4787     jj_consume_token(RPAREN);
4788   }
4789 
4790   final public void MarkerAnnotation() throws ParseException {
4791     jj_consume_token(AT);
4792     Name();
4793   }
4794 
4795   final public void SingleMemberAnnotation() throws ParseException {
4796     jj_consume_token(AT);
4797     Name();
4798     jj_consume_token(LPAREN);
4799     MemberValue();
4800     jj_consume_token(RPAREN);
4801   }
4802 
4803   final public void MemberValuePairs() throws ParseException {
4804     MemberValuePair();
4805     label_62:
4806     while (true) {
4807       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4808       case COMMA:
4809         ;
4810         break;
4811       default:
4812         jj_la1[173] = jj_gen;
4813         break label_62;
4814       }
4815       jj_consume_token(COMMA);
4816       MemberValuePair();
4817     }
4818   }
4819 
4820   final public void MemberValuePair() throws ParseException {
4821     JavaIdentifier();
4822     jj_consume_token(ASSIGN);
4823     MemberValue();
4824   }
4825 
4826   final public void MemberValue() throws ParseException {
4827     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4828     case AT:
4829       Annotation();
4830       break;
4831     case LBRACE:
4832       MemberValueArrayInitializer();
4833       break;
4834     case _LOOKAHEAD:
4835     case _IGNORE_CASE:
4836     case _PARSER_BEGIN:
4837     case _PARSER_END:
4838     case _JAVACODE:
4839     case _TOKEN:
4840     case _SPECIAL_TOKEN:
4841     case _MORE:
4842     case _SKIP:
4843     case _TOKEN_MGR_DECLS:
4844     case _EOF:
4845     case BOOLEAN:
4846     case BYTE:
4847     case CHAR:
4848     case DOUBLE:
4849     case FALSE:
4850     case FLOAT:
4851     case INT:
4852     case LONG:
4853     case NEW:
4854     case NULL:
4855     case SHORT:
4856     case SUPER:
4857     case THIS:
4858     case TRUE:
4859     case VOID:
4860     case INTEGER_LITERAL:
4861     case FLOATING_POINT_LITERAL:
4862     case CHARACTER_LITERAL:
4863     case STRING_LITERAL:
4864     case LPAREN:
4865     case BANG:
4866     case TILDE:
4867     case INCR:
4868     case DECR:
4869     case PLUS:
4870     case MINUS:
4871     case IDENTIFIER:
4872       ConditionalExpression();
4873       break;
4874     default:
4875       jj_la1[174] = jj_gen;
4876       jj_consume_token(-1);
4877       throw new ParseException();
4878     }
4879   }
4880 
4881   final public void MemberValueArrayInitializer() throws ParseException {
4882     jj_consume_token(LBRACE);
4883     MemberValue();
4884     label_63:
4885     while (true) {
4886       if (jj_2_49(2)) {
4887         ;
4888       } else {
4889         break label_63;
4890       }
4891       jj_consume_token(COMMA);
4892       MemberValue();
4893     }
4894     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4895     case COMMA:
4896       jj_consume_token(COMMA);
4897       break;
4898     default:
4899       jj_la1[175] = jj_gen;
4900       ;
4901     }
4902     jj_consume_token(RBRACE);
4903   }
4904 
4905 /* Annotation Types. */
4906   final public void AnnotationTypeDeclaration() throws ParseException {
4907     jj_consume_token(AT);
4908     jj_consume_token(INTERFACE);
4909     JavaIdentifier();
4910     AnnotationTypeBody();
4911   }
4912 
4913   final public void AnnotationTypeBody() throws ParseException {
4914     jj_consume_token(LBRACE);
4915     label_64:
4916     while (true) {
4917       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4918       case _LOOKAHEAD:
4919       case _IGNORE_CASE:
4920       case _PARSER_BEGIN:
4921       case _PARSER_END:
4922       case _JAVACODE:
4923       case _TOKEN:
4924       case _SPECIAL_TOKEN:
4925       case _MORE:
4926       case _SKIP:
4927       case _TOKEN_MGR_DECLS:
4928       case _EOF:
4929       case ABSTRACT:
4930       case BOOLEAN:
4931       case BYTE:
4932       case CHAR:
4933       case CLASS:
4934       case DOUBLE:
4935       case FINAL:
4936       case FLOAT:
4937       case INT:
4938       case INTERFACE:
4939       case LONG:
4940       case NATIVE:
4941       case PRIVATE:
4942       case PROTECTED:
4943       case PUBLIC:
4944       case SHORT:
4945       case STATIC:
4946       case STRICTFP:
4947       case SYNCHRONIZED:
4948       case TRANSIENT:
4949       case VOLATILE:
4950       case SEMICOLON:
4951       case AT:
4952       case 131:
4953       case IDENTIFIER:
4954         ;
4955         break;
4956       default:
4957         jj_la1[176] = jj_gen;
4958         break label_64;
4959       }
4960       AnnotationTypeMemberDeclaration();
4961     }
4962     jj_consume_token(RBRACE);
4963   }
4964 
4965   final public void AnnotationTypeMemberDeclaration() throws ParseException {
4966     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4967     case _LOOKAHEAD:
4968     case _IGNORE_CASE:
4969     case _PARSER_BEGIN:
4970     case _PARSER_END:
4971     case _JAVACODE:
4972     case _TOKEN:
4973     case _SPECIAL_TOKEN:
4974     case _MORE:
4975     case _SKIP:
4976     case _TOKEN_MGR_DECLS:
4977     case _EOF:
4978     case ABSTRACT:
4979     case BOOLEAN:
4980     case BYTE:
4981     case CHAR:
4982     case CLASS:
4983     case DOUBLE:
4984     case FINAL:
4985     case FLOAT:
4986     case INT:
4987     case INTERFACE:
4988     case LONG:
4989     case NATIVE:
4990     case PRIVATE:
4991     case PROTECTED:
4992     case PUBLIC:
4993     case SHORT:
4994     case STATIC:
4995     case STRICTFP:
4996     case SYNCHRONIZED:
4997     case TRANSIENT:
4998     case VOLATILE:
4999     case AT:
5000     case 131:
5001     case IDENTIFIER:
5002       Modifiers();
5003       if (jj_2_50(2147483647)) {
5004         Type();
5005         JavaIdentifier();
5006         jj_consume_token(LPAREN);
5007         jj_consume_token(RPAREN);
5008         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5009         case _DEFAULT:
5010           DefaultValue();
5011           break;
5012         default:
5013           jj_la1[177] = jj_gen;
5014           ;
5015         }
5016         jj_consume_token(SEMICOLON);
5017       } else {
5018         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5019         case CLASS:
5020         case INTERFACE:
5021           ClassOrInterfaceDeclaration();
5022           break;
5023         case 131:
5024           EnumDeclaration();
5025           break;
5026         case AT:
5027           AnnotationTypeDeclaration();
5028           break;
5029         case _LOOKAHEAD:
5030         case _IGNORE_CASE:
5031         case _PARSER_BEGIN:
5032         case _PARSER_END:
5033         case _JAVACODE:
5034         case _TOKEN:
5035         case _SPECIAL_TOKEN:
5036         case _MORE:
5037         case _SKIP:
5038         case _TOKEN_MGR_DECLS:
5039         case _EOF:
5040         case BOOLEAN:
5041         case BYTE:
5042         case CHAR:
5043         case DOUBLE:
5044         case FLOAT:
5045         case INT:
5046         case LONG:
5047         case SHORT:
5048         case IDENTIFIER:
5049           FieldDeclaration();
5050           break;
5051         default:
5052           jj_la1[178] = jj_gen;
5053           jj_consume_token(-1);
5054           throw new ParseException();
5055         }
5056       }
5057       break;
5058     case SEMICOLON:
5059       jj_consume_token(SEMICOLON);
5060       break;
5061     default:
5062       jj_la1[179] = jj_gen;
5063       jj_consume_token(-1);
5064       throw new ParseException();
5065     }
5066   }
5067 
5068   final public void DefaultValue() throws ParseException {
5069     jj_consume_token(_DEFAULT);
5070     MemberValue();
5071   }
5072 
5073   private boolean jj_2_1(int xla) {
5074     jj_la = xla; jj_lastpos = jj_scanpos = token;
5075     try { return !jj_3_1(); }
5076     catch(LookaheadSuccess ls) { return true; }
5077     finally { jj_save(0, xla); }
5078   }
5079 
5080   private boolean jj_2_2(int xla) {
5081     jj_la = xla; jj_lastpos = jj_scanpos = token;
5082     try { return !jj_3_2(); }
5083     catch(LookaheadSuccess ls) { return true; }
5084     finally { jj_save(1, xla); }
5085   }
5086 
5087   private boolean jj_2_3(int xla) {
5088     jj_la = xla; jj_lastpos = jj_scanpos = token;
5089     try { return !jj_3_3(); }
5090     catch(LookaheadSuccess ls) { return true; }
5091     finally { jj_save(2, xla); }
5092   }
5093 
5094   private boolean jj_2_4(int xla) {
5095     jj_la = xla; jj_lastpos = jj_scanpos = token;
5096     try { return !jj_3_4(); }
5097     catch(LookaheadSuccess ls) { return true; }
5098     finally { jj_save(3, xla); }
5099   }
5100 
5101   private boolean jj_2_5(int xla) {
5102     jj_la = xla; jj_lastpos = jj_scanpos = token;
5103     try { return !jj_3_5(); }
5104     catch(LookaheadSuccess ls) { return true; }
5105     finally { jj_save(4, xla); }
5106   }
5107 
5108   private boolean jj_2_6(int xla) {
5109     jj_la = xla; jj_lastpos = jj_scanpos = token;
5110     try { return !jj_3_6(); }
5111     catch(LookaheadSuccess ls) { return true; }
5112     finally { jj_save(5, xla); }
5113   }
5114 
5115   private boolean jj_2_7(int xla) {
5116     jj_la = xla; jj_lastpos = jj_scanpos = token;
5117     try { return !jj_3_7(); }
5118     catch(LookaheadSuccess ls) { return true; }
5119     finally { jj_save(6, xla); }
5120   }
5121 
5122   private boolean jj_2_8(int xla) {
5123     jj_la = xla; jj_lastpos = jj_scanpos = token;
5124     try { return !jj_3_8(); }
5125     catch(LookaheadSuccess ls) { return true; }
5126     finally { jj_save(7, xla); }
5127   }
5128 
5129   private boolean jj_2_9(int xla) {
5130     jj_la = xla; jj_lastpos = jj_scanpos = token;
5131     try { return !jj_3_9(); }
5132     catch(LookaheadSuccess ls) { return true; }
5133     finally { jj_save(8, xla); }
5134   }
5135 
5136   private boolean jj_2_10(int xla) {
5137     jj_la = xla; jj_lastpos = jj_scanpos = token;
5138     try { return !jj_3_10(); }
5139     catch(LookaheadSuccess ls) { return true; }
5140     finally { jj_save(9, xla); }
5141   }
5142 
5143   private boolean jj_2_11(int xla) {
5144     jj_la = xla; jj_lastpos = jj_scanpos = token;
5145     try { return !jj_3_11(); }
5146     catch(LookaheadSuccess ls) { return true; }
5147     finally { jj_save(10, xla); }
5148   }
5149 
5150   private boolean jj_2_12(int xla) {
5151     jj_la = xla; jj_lastpos = jj_scanpos = token;
5152     try { return !jj_3_12(); }
5153     catch(LookaheadSuccess ls) { return true; }
5154     finally { jj_save(11, xla); }
5155   }
5156 
5157   private boolean jj_2_13(int xla) {
5158     jj_la = xla; jj_lastpos = jj_scanpos = token;
5159     try { return !jj_3_13(); }
5160     catch(LookaheadSuccess ls) { return true; }
5161     finally { jj_save(12, xla); }
5162   }
5163 
5164   private boolean jj_2_14(int xla) {
5165     jj_la = xla; jj_lastpos = jj_scanpos = token;
5166     try { return !jj_3_14(); }
5167     catch(LookaheadSuccess ls) { return true; }
5168     finally { jj_save(13, xla); }
5169   }
5170 
5171   private boolean jj_2_15(int xla) {
5172     jj_la = xla; jj_lastpos = jj_scanpos = token;
5173     try { return !jj_3_15(); }
5174     catch(LookaheadSuccess ls) { return true; }
5175     finally { jj_save(14, xla); }
5176   }
5177 
5178   private boolean jj_2_16(int xla) {
5179     jj_la = xla; jj_lastpos = jj_scanpos = token;
5180     try { return !jj_3_16(); }
5181     catch(LookaheadSuccess ls) { return true; }
5182     finally { jj_save(15, xla); }
5183   }
5184 
5185   private boolean jj_2_17(int xla) {
5186     jj_la = xla; jj_lastpos = jj_scanpos = token;
5187     try { return !jj_3_17(); }
5188     catch(LookaheadSuccess ls) { return true; }
5189     finally { jj_save(16, xla); }
5190   }
5191 
5192   private boolean jj_2_18(int xla) {
5193     jj_la = xla; jj_lastpos = jj_scanpos = token;
5194     try { return !jj_3_18(); }
5195     catch(LookaheadSuccess ls) { return true; }
5196     finally { jj_save(17, xla); }
5197   }
5198 
5199   private boolean jj_2_19(int xla) {
5200     jj_la = xla; jj_lastpos = jj_scanpos = token;
5201     try { return !jj_3_19(); }
5202     catch(LookaheadSuccess ls) { return true; }
5203     finally { jj_save(18, xla); }
5204   }
5205 
5206   private boolean jj_2_20(int xla) {
5207     jj_la = xla; jj_lastpos = jj_scanpos = token;
5208     try { return !jj_3_20(); }
5209     catch(LookaheadSuccess ls) { return true; }
5210     finally { jj_save(19, xla); }
5211   }
5212 
5213   private boolean jj_2_21(int xla) {
5214     jj_la = xla; jj_lastpos = jj_scanpos = token;
5215     try { return !jj_3_21(); }
5216     catch(LookaheadSuccess ls) { return true; }
5217     finally { jj_save(20, xla); }
5218   }
5219 
5220   private boolean jj_2_22(int xla) {
5221     jj_la = xla; jj_lastpos = jj_scanpos = token;
5222     try { return !jj_3_22(); }
5223     catch(LookaheadSuccess ls) { return true; }
5224     finally { jj_save(21, xla); }
5225   }
5226 
5227   private boolean jj_2_23(int xla) {
5228     jj_la = xla; jj_lastpos = jj_scanpos = token;
5229     try { return !jj_3_23(); }
5230     catch(LookaheadSuccess ls) { return true; }
5231     finally { jj_save(22, xla); }
5232   }
5233 
5234   private boolean jj_2_24(int xla) {
5235     jj_la = xla; jj_lastpos = jj_scanpos = token;
5236     try { return !jj_3_24(); }
5237     catch(LookaheadSuccess ls) { return true; }
5238     finally { jj_save(23, xla); }
5239   }
5240 
5241   private boolean jj_2_25(int xla) {
5242     jj_la = xla; jj_lastpos = jj_scanpos = token;
5243     try { return !jj_3_25(); }
5244     catch(LookaheadSuccess ls) { return true; }
5245     finally { jj_save(24, xla); }
5246   }
5247 
5248   private boolean jj_2_26(int xla) {
5249     jj_la = xla; jj_lastpos = jj_scanpos = token;
5250     try { return !jj_3_26(); }
5251     catch(LookaheadSuccess ls) { return true; }
5252     finally { jj_save(25, xla); }
5253   }
5254 
5255   private boolean jj_2_27(int xla) {
5256     jj_la = xla; jj_lastpos = jj_scanpos = token;
5257     try { return !jj_3_27(); }
5258     catch(LookaheadSuccess ls) { return true; }
5259     finally { jj_save(26, xla); }
5260   }
5261 
5262   private boolean jj_2_28(int xla) {
5263     jj_la = xla; jj_lastpos = jj_scanpos = token;
5264     try { return !jj_3_28(); }
5265     catch(LookaheadSuccess ls) { return true; }
5266     finally { jj_save(27, xla); }
5267   }
5268 
5269   private boolean jj_2_29(int xla) {
5270     jj_la = xla; jj_lastpos = jj_scanpos = token;
5271     try { return !jj_3_29(); }
5272     catch(LookaheadSuccess ls) { return true; }
5273     finally { jj_save(28, xla); }
5274   }
5275 
5276   private boolean jj_2_30(int xla) {
5277     jj_la = xla; jj_lastpos = jj_scanpos = token;
5278     try { return !jj_3_30(); }
5279     catch(LookaheadSuccess ls) { return true; }
5280     finally { jj_save(29, xla); }
5281   }
5282 
5283   private boolean jj_2_31(int xla) {
5284     jj_la = xla; jj_lastpos = jj_scanpos = token;
5285     try { return !jj_3_31(); }
5286     catch(LookaheadSuccess ls) { return true; }
5287     finally { jj_save(30, xla); }
5288   }
5289 
5290   private boolean jj_2_32(int xla) {
5291     jj_la = xla; jj_lastpos = jj_scanpos = token;
5292     try { return !jj_3_32(); }
5293     catch(LookaheadSuccess ls) { return true; }
5294     finally { jj_save(31, xla); }
5295   }
5296 
5297   private boolean jj_2_33(int xla) {
5298     jj_la = xla; jj_lastpos = jj_scanpos = token;
5299     try { return !jj_3_33(); }
5300     catch(LookaheadSuccess ls) { return true; }
5301     finally { jj_save(32, xla); }
5302   }
5303 
5304   private boolean jj_2_34(int xla) {
5305     jj_la = xla; jj_lastpos = jj_scanpos = token;
5306     try { return !jj_3_34(); }
5307     catch(LookaheadSuccess ls) { return true; }
5308     finally { jj_save(33, xla); }
5309   }
5310 
5311   private boolean jj_2_35(int xla) {
5312     jj_la = xla; jj_lastpos = jj_scanpos = token;
5313     try { return !jj_3_35(); }
5314     catch(LookaheadSuccess ls) { return true; }
5315     finally { jj_save(34, xla); }
5316   }
5317 
5318   private boolean jj_2_36(int xla) {
5319     jj_la = xla; jj_lastpos = jj_scanpos = token;
5320     try { return !jj_3_36(); }
5321     catch(LookaheadSuccess ls) { return true; }
5322     finally { jj_save(35, xla); }
5323   }
5324 
5325   private boolean jj_2_37(int xla) {
5326     jj_la = xla; jj_lastpos = jj_scanpos = token;
5327     try { return !jj_3_37(); }
5328     catch(LookaheadSuccess ls) { return true; }
5329     finally { jj_save(36, xla); }
5330   }
5331 
5332   private boolean jj_2_38(int xla) {
5333     jj_la = xla; jj_lastpos = jj_scanpos = token;
5334     try { return !jj_3_38(); }
5335     catch(