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