KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > net > sourceforge > pmd > ast > JavaParser


1 /* Generated By:JJTree&JavaCC: Do not edit this line. JavaParser.java */
2 package net.sourceforge.pmd.ast;
3 import java.util.*;
4 import net.sourceforge.pmd.PMD;
5 public class JavaParser/*@bgen(jjtree)*/implements JavaParserTreeConstants, JavaParserConstants {/*@bgen(jjtree)*/
6   protected JJTJavaParserState jjtree = new JJTJavaParserState();
7   private boolean isJDK13;
8   private boolean isJDK15;
9
10   public void setJDK13() {
11    this.isJDK13 = true;
12   }
13
14   public void setJDK15() {
15    this.isJDK15 = true;
16   }
17
18   private void checkForBadAssertUsage(String JavaDoc in, String JavaDoc usage) {
19     if (!isJDK13 && in.equals("assert")) {
20       throw new ParseException("Can't use 'assert' as " + usage + " when running in JDK 1.4 mode!");
21     }
22   }
23
24   private void checkForBadStaticImportUsage() {
25     if (!isJDK15) {
26       throw new ParseException("Can't use static imports when running in JDK 1.4 mode!");
27     }
28   }
29
30   private void checkForBadGenericsUsage() {
31     if (!isJDK15) {
32       throw new ParseException("Can't use generics unless running in JDK 1.5 mode!");
33     }
34   }
35
36   private void checkForBadVariableArgumentsUsage() {
37     if (!isJDK15) {
38       throw new ParseException("Can't use variable arguments (varargs) when running in JDK 1.4 mode!");
39     }
40   }
41
42   private void checkForBadJDK15ForLoopSyntaxArgumentsUsage() {
43     if (!isJDK15) {
44       throw new ParseException("Can't use JDK 1.5 for loop syntax when running in JDK 1.4 mode!");
45     }
46   }
47
48   private void checkForBadEnumUsage(String JavaDoc in, String JavaDoc usage) {
49     if (isJDK15 && in.equals("enum")) {
50       throw new ParseException("Can't use 'enum' as " + usage + " when running in JDK 1.5 mode!");
51     }
52   }
53
54   private void checkForBadHexFloatingPointLiteral() {
55     if (!isJDK15) {
56       throw new ParseException("ERROR: Can't use hexadecimal floating point literals in pre-JDK 1.5 target");
57     }
58   }
59
60   // This is a semantic LOOKAHEAD to determine if we're dealing with an assert
61
// Note that this can't be replaced with a syntactic lookahead
62
// since "assert" isn't a string literal token
63
private boolean isNextTokenAnAssert() {
64     boolean res = getToken(1).image.equals("assert");
65     if (res && isJDK13 && getToken(2).image.equals("(")) {
66      res = false;
67     }
68     return res;
69   }
70
71   private boolean isPrecededByComment(Token tok) {
72       boolean res = false;
73       while (!res && tok.specialToken != null) {
74           tok = tok.specialToken;
75           res = tok.kind == SINGLE_LINE_COMMENT ||
76                 tok.kind == FORMAL_COMMENT ||
77                 tok.kind == MULTI_LINE_COMMENT;
78       }
79       return res;
80   }
81
82   public Map getExcludeMap() {
83     return token_source.getExcludeMap();
84   }
85
86   public void setExcludeMarker(String JavaDoc marker) {
87     token_source.setExcludeMarker(marker);
88   }
89
90 /*****************************************
91  * THE JAVA LANGUAGE GRAMMAR STARTS HERE *
92  *****************************************/

93
94 /*
95  * Program structuring syntax follows.
96  */

97   final public ASTCompilationUnit CompilationUnit() throws ParseException {
98  /*@bgen(jjtree) CompilationUnit */
99   ASTCompilationUnit jjtn000 = new ASTCompilationUnit(this, JJTCOMPILATIONUNIT);
100   boolean jjtc000 = true;
101   jjtree.openNodeScope(jjtn000);
102     try {
103       if (jj_2_1(2147483647)) {
104         PackageDeclaration();
105       } else {
106         ;
107       }
108       label_1:
109       while (true) {
110         switch (jj_nt.kind) {
111         case IMPORT:
112           ;
113           break;
114         default:
115           jj_la1[0] = jj_gen;
116           break label_1;
117         }
118         ImportDeclaration();
119       }
120       label_2:
121       while (true) {
122         switch (jj_nt.kind) {
123         case ABSTRACT:
124         case CLASS:
125         case FINAL:
126         case INTERFACE:
127         case NATIVE:
128         case PRIVATE:
129         case PROTECTED:
130         case PUBLIC:
131         case STATIC:
132         case SYNCHRONIZED:
133         case TRANSIENT:
134         case VOLATILE:
135         case STRICTFP:
136         case IDENTIFIER:
137         case SEMICOLON:
138         case AT:
139           ;
140           break;
141         default:
142           jj_la1[1] = jj_gen;
143           break label_2;
144         }
145         TypeDeclaration();
146       }
147       switch (jj_nt.kind) {
148       case 123:
149         jj_consume_token(123);
150         break;
151       default:
152         jj_la1[2] = jj_gen;
153         ;
154       }
155       switch (jj_nt.kind) {
156       case 124:
157         jj_consume_token(124);
158         break;
159       default:
160         jj_la1[3] = jj_gen;
161         ;
162       }
163       jj_consume_token(0);
164   jjtree.closeNodeScope(jjtn000, true);
165   jjtc000 = false;
166  {if (true) return jjtn000;}
167     } catch (Throwable JavaDoc jjte000) {
168     if (jjtc000) {
169       jjtree.clearNodeScope(jjtn000);
170       jjtc000 = false;
171     } else {
172       jjtree.popNode();
173     }
174     if (jjte000 instanceof RuntimeException JavaDoc) {
175       {if (true) throw (RuntimeException JavaDoc)jjte000;}
176     }
177     if (jjte000 instanceof ParseException) {
178       {if (true) throw (ParseException)jjte000;}
179     }
180     {if (true) throw (Error JavaDoc)jjte000;}
181     } finally {
182     if (jjtc000) {
183       jjtree.closeNodeScope(jjtn000, true);
184     }
185     }
186     throw new RuntimeException JavaDoc("Missing return statement in function");
187   }
188
189   final public void PackageDeclaration() throws ParseException {
190  /*@bgen(jjtree) PackageDeclaration */
191   ASTPackageDeclaration jjtn000 = new ASTPackageDeclaration(this, JJTPACKAGEDECLARATION);
192   boolean jjtc000 = true;
193   jjtree.openNodeScope(jjtn000);
194     try {
195       label_3:
196       while (true) {
197         switch (jj_nt.kind) {
198         case AT:
199           ;
200           break;
201         default:
202           jj_la1[4] = jj_gen;
203           break label_3;
204         }
205         Annotation();
206       }
207       jj_consume_token(PACKAGE);
208       Name();
209       jj_consume_token(SEMICOLON);
210     } catch (Throwable JavaDoc jjte000) {
211     if (jjtc000) {
212       jjtree.clearNodeScope(jjtn000);
213       jjtc000 = false;
214     } else {
215       jjtree.popNode();
216     }
217     if (jjte000 instanceof RuntimeException JavaDoc) {
218       {if (true) throw (RuntimeException JavaDoc)jjte000;}
219     }
220     if (jjte000 instanceof ParseException) {
221       {if (true) throw (ParseException)jjte000;}
222     }
223     {if (true) throw (Error JavaDoc)jjte000;}
224     } finally {
225     if (jjtc000) {
226       jjtree.closeNodeScope(jjtn000, true);
227     }
228     }
229   }
230
231   final public void ImportDeclaration() throws ParseException {
232  /*@bgen(jjtree) ImportDeclaration */
233   ASTImportDeclaration jjtn000 = new ASTImportDeclaration(this, JJTIMPORTDECLARATION);
234   boolean jjtc000 = true;
235   jjtree.openNodeScope(jjtn000);
236     try {
237       jj_consume_token(IMPORT);
238       switch (jj_nt.kind) {
239       case STATIC:
240         jj_consume_token(STATIC);
241                        checkForBadStaticImportUsage();jjtn000.setStatic();
242         break;
243       default:
244         jj_la1[5] = jj_gen;
245         ;
246       }
247       Name();
248       switch (jj_nt.kind) {
249       case DOT:
250         jj_consume_token(DOT);
251         jj_consume_token(STAR);
252                                                                                                 jjtn000.setImportOnDemand();
253         break;
254       default:
255         jj_la1[6] = jj_gen;
256         ;
257       }
258       jj_consume_token(SEMICOLON);
259     } catch (Throwable JavaDoc jjte000) {
260     if (jjtc000) {
261       jjtree.clearNodeScope(jjtn000);
262       jjtc000 = false;
263     } else {
264       jjtree.popNode();
265     }
266     if (jjte000 instanceof RuntimeException JavaDoc) {
267       {if (true) throw (RuntimeException JavaDoc)jjte000;}
268     }
269     if (jjte000 instanceof ParseException) {
270       {if (true) throw (ParseException)jjte000;}
271     }
272     {if (true) throw (Error JavaDoc)jjte000;}
273     } finally {
274     if (jjtc000) {
275       jjtree.closeNodeScope(jjtn000, true);
276     }
277     }
278   }
279
280 /*
281  * Modifiers. We match all modifiers in a single rule to reduce the chances of
282  * syntax errors for simple modifier mistakes. It will also enable us to give
283  * better error messages.
284  */

285   final public int Modifiers() throws ParseException {
286    int modifiers = 0;
287     label_4:
288     while (true) {
289       if (jj_2_2(2)) {
290         ;
291       } else {
292         break label_4;
293       }
294       switch (jj_nt.kind) {
295       case PUBLIC:
296         jj_consume_token(PUBLIC);
297               modifiers |= AccessNode.PUBLIC;
298         break;
299       case STATIC:
300         jj_consume_token(STATIC);
301                modifiers |= AccessNode.STATIC;
302         break;
303       case PROTECTED:
304         jj_consume_token(PROTECTED);
305                   modifiers |= AccessNode.PROTECTED;
306         break;
307       case PRIVATE:
308         jj_consume_token(PRIVATE);
309                 modifiers |= AccessNode.PRIVATE;
310         break;
311       case FINAL:
312         jj_consume_token(FINAL);
313               modifiers |= AccessNode.FINAL;
314         break;
315       case ABSTRACT:
316         jj_consume_token(ABSTRACT);
317                  modifiers |= AccessNode.ABSTRACT;
318         break;
319       case SYNCHRONIZED:
320         jj_consume_token(SYNCHRONIZED);
321                      modifiers |= AccessNode.SYNCHRONIZED;
322         break;
323       case NATIVE:
324         jj_consume_token(NATIVE);
325                modifiers |= AccessNode.NATIVE;
326         break;
327       case TRANSIENT:
328         jj_consume_token(TRANSIENT);
329                   modifiers |= AccessNode.TRANSIENT;
330         break;
331       case VOLATILE:
332         jj_consume_token(VOLATILE);
333                  modifiers |= AccessNode.VOLATILE;
334         break;
335       case STRICTFP:
336         jj_consume_token(STRICTFP);
337                  modifiers |= AccessNode.STRICTFP;
338         break;
339       case AT:
340         Annotation();
341         break;
342       default:
343         jj_la1[7] = jj_gen;
344         jj_consume_token(-1);
345         throw new ParseException();
346       }
347     }
348     {if (true) return modifiers;}
349     throw new RuntimeException JavaDoc("Missing return statement in function");
350   }
351
352 /*
353  * Declaration syntax follows.
354  */

355   final public void TypeDeclaration() throws ParseException {
356  /*@bgen(jjtree) TypeDeclaration */
357    ASTTypeDeclaration jjtn000 = new ASTTypeDeclaration(this, JJTTYPEDECLARATION);
358    boolean jjtc000 = true;
359    jjtree.openNodeScope(jjtn000);int modifiers;
360     try {
361       switch (jj_nt.kind) {
362       case SEMICOLON:
363         jj_consume_token(SEMICOLON);
364         break;
365       case ABSTRACT:
366       case CLASS:
367       case FINAL:
368       case INTERFACE:
369       case NATIVE:
370       case PRIVATE:
371       case PROTECTED:
372       case PUBLIC:
373       case STATIC:
374       case SYNCHRONIZED:
375       case TRANSIENT:
376       case VOLATILE:
377       case STRICTFP:
378       case IDENTIFIER:
379       case AT:
380         modifiers = Modifiers();
381         switch (jj_nt.kind) {
382         case ABSTRACT:
383         case CLASS:
384         case FINAL:
385         case INTERFACE:
386           ClassOrInterfaceDeclaration(modifiers);
387           break;
388         case IDENTIFIER:
389           EnumDeclaration(modifiers);
390           break;
391         case AT:
392           AnnotationTypeDeclaration(modifiers);
393           break;
394         default:
395           jj_la1[8] = jj_gen;
396           jj_consume_token(-1);
397           throw new ParseException();
398         }
399         break;
400       default:
401         jj_la1[9] = jj_gen;
402         jj_consume_token(-1);
403         throw new ParseException();
404       }
405     } catch (Throwable JavaDoc jjte000) {
406     if (jjtc000) {
407       jjtree.clearNodeScope(jjtn000);
408       jjtc000 = false;
409     } else {
410       jjtree.popNode();
411     }
412     if (jjte000 instanceof RuntimeException JavaDoc) {
413       {if (true) throw (RuntimeException JavaDoc)jjte000;}
414     }
415     if (jjte000 instanceof ParseException) {
416       {if (true) throw (ParseException)jjte000;}
417     }
418     {if (true) throw (Error JavaDoc)jjte000;}
419     } finally {
420     if (jjtc000) {
421       jjtree.closeNodeScope(jjtn000, true);
422     }
423     }
424   }
425
426   final public void ClassOrInterfaceDeclaration(int modifiers) throws ParseException {
427  /*@bgen(jjtree) ClassOrInterfaceDeclaration */
428 ASTClassOrInterfaceDeclaration jjtn000 = new ASTClassOrInterfaceDeclaration(this, JJTCLASSORINTERFACEDECLARATION);
429 boolean jjtc000 = true;
430 jjtree.openNodeScope(jjtn000);Token t = null;
431 jjtn000.setModifiers(modifiers);
432     try {
433       switch (jj_nt.kind) {
434       case ABSTRACT:
435       case CLASS:
436       case FINAL:
437         switch (jj_nt.kind) {
438         case ABSTRACT:
439         case FINAL:
440           switch (jj_nt.kind) {
441           case FINAL:
442             jj_consume_token(FINAL);
443             break;
444           case ABSTRACT:
445             jj_consume_token(ABSTRACT);
446             break;
447           default:
448             jj_la1[10] = jj_gen;
449             jj_consume_token(-1);
450             throw new ParseException();
451           }
452           break;
453         default:
454           jj_la1[11] = jj_gen;
455           ;
456         }
457         jj_consume_token(CLASS);
458         break;
459       case INTERFACE:
460         jj_consume_token(INTERFACE);
461                                                                                                                      jjtn000.setInterface();
462         break;
463       default:
464         jj_la1[12] = jj_gen;
465         jj_consume_token(-1);
466         throw new ParseException();
467       }
468       t = jj_consume_token(IDENTIFIER);
469                    jjtn000.setImage(t.image);
470       switch (jj_nt.kind) {
471       case LT:
472         TypeParameters();
473         break;
474       default:
475         jj_la1[13] = jj_gen;
476         ;
477       }
478       switch (jj_nt.kind) {
479       case EXTENDS:
480         ExtendsList();
481         break;
482       default:
483         jj_la1[14] = jj_gen;
484         ;
485       }
486       switch (jj_nt.kind) {
487       case IMPLEMENTS:
488         ImplementsList();
489         break;
490       default:
491         jj_la1[15] = jj_gen;
492         ;
493       }
494       ClassOrInterfaceBody();
495     } catch (Throwable JavaDoc jjte000) {
496     if (jjtc000) {
497       jjtree.clearNodeScope(jjtn000);
498       jjtc000 = false;
499     } else {
500       jjtree.popNode();
501     }
502     if (jjte000 instanceof RuntimeException JavaDoc) {
503       {if (true) throw (RuntimeException JavaDoc)jjte000;}
504     }
505     if (jjte000 instanceof ParseException) {
506       {if (true) throw (ParseException)jjte000;}
507     }
508     {if (true) throw (Error JavaDoc)jjte000;}
509     } finally {
510     if (jjtc000) {
511       jjtree.closeNodeScope(jjtn000, true);
512     }
513     }
514   }
515
516   final public void ExtendsList() throws ParseException {
517  /*@bgen(jjtree) ExtendsList */
518    ASTExtendsList jjtn000 = new ASTExtendsList(this, JJTEXTENDSLIST);
519    boolean jjtc000 = true;
520    jjtree.openNodeScope(jjtn000);boolean extendsMoreThanOne = false;
521     try {
522       jj_consume_token(EXTENDS);
523       ClassOrInterfaceType();
524       label_5:
525       while (true) {
526         switch (jj_nt.kind) {
527         case COMMA:
528           ;
529           break;
530         default:
531           jj_la1[16] = jj_gen;
532           break label_5;
533         }
534         jj_consume_token(COMMA);
535         ClassOrInterfaceType();
536                                   extendsMoreThanOne = true;
537       }
538     } catch (Throwable JavaDoc jjte000) {
539      if (jjtc000) {
540        jjtree.clearNodeScope(jjtn000);
541        jjtc000 = false;
542      } else {
543        jjtree.popNode();
544      }
545      if (jjte000 instanceof RuntimeException JavaDoc) {
546        {if (true) throw (RuntimeException JavaDoc)jjte000;}
547      }
548      if (jjte000 instanceof ParseException) {
549        {if (true) throw (ParseException)jjte000;}
550      }
551      {if (true) throw (Error JavaDoc)jjte000;}
552     } finally {
553      if (jjtc000) {
554        jjtree.closeNodeScope(jjtn000, true);
555      }
556     }
557   }
558
559   final public void ImplementsList() throws ParseException {
560  /*@bgen(jjtree) ImplementsList */
561   ASTImplementsList jjtn000 = new ASTImplementsList(this, JJTIMPLEMENTSLIST);
562   boolean jjtc000 = true;
563   jjtree.openNodeScope(jjtn000);
564     try {
565       jj_consume_token(IMPLEMENTS);
566       ClassOrInterfaceType();
567       label_6:
568       while (true) {
569         switch (jj_nt.kind) {
570         case COMMA:
571           ;
572           break;
573         default:
574           jj_la1[17] = jj_gen;
575           break label_6;
576         }
577         jj_consume_token(COMMA);
578         ClassOrInterfaceType();
579       }
580     } catch (Throwable JavaDoc jjte000) {
581      if (jjtc000) {
582        jjtree.clearNodeScope(jjtn000);
583        jjtc000 = false;
584      } else {
585        jjtree.popNode();
586      }
587      if (jjte000 instanceof RuntimeException JavaDoc) {
588        {if (true) throw (RuntimeException JavaDoc)jjte000;}
589      }
590      if (jjte000 instanceof ParseException) {
591        {if (true) throw (ParseException)jjte000;}
592      }
593      {if (true) throw (Error JavaDoc)jjte000;}
594     } finally {
595      if (jjtc000) {
596        jjtree.closeNodeScope(jjtn000, true);
597      }
598     }
599   }
600
601   final public void EnumDeclaration(int modifiers) throws ParseException {
602  /*@bgen(jjtree) EnumDeclaration */
603 ASTEnumDeclaration jjtn000 = new ASTEnumDeclaration(this, JJTENUMDECLARATION);
604 boolean jjtc000 = true;
605 jjtree.openNodeScope(jjtn000);Token t;
606 jjtn000.setModifiers(modifiers);
607     try {
608       t = jj_consume_token(IDENTIFIER);
609     if (!t.image.equals("enum")) {
610       {if (true) throw new ParseException("ERROR: expecting enum");}
611     }
612     if (!this.isJDK15) {
613       {if (true) throw new ParseException("ERROR: Can't use enum as a keyword in pre-JDK 1.5 target");}
614     }
615       t = jj_consume_token(IDENTIFIER);
616                   jjtn000.setImage(t.image);
617       switch (jj_nt.kind) {
618       case IMPLEMENTS:
619         ImplementsList();
620         break;
621       default:
622         jj_la1[18] = jj_gen;
623         ;
624       }
625       EnumBody();
626     } catch (Throwable JavaDoc jjte000) {
627     if (jjtc000) {
628       jjtree.clearNodeScope(jjtn000);
629       jjtc000 = false;
630     } else {
631       jjtree.popNode();
632     }
633     if (jjte000 instanceof RuntimeException JavaDoc) {
634       {if (true) throw (RuntimeException JavaDoc)jjte000;}
635     }
636     if (jjte000 instanceof ParseException) {
637       {if (true) throw (ParseException)jjte000;}
638     }
639     {if (true) throw (Error JavaDoc)jjte000;}
640     } finally {
641     if (jjtc000) {
642       jjtree.closeNodeScope(jjtn000, true);
643     }
644     }
645   }
646
647   final public void EnumBody() throws ParseException {
648  /*@bgen(jjtree) EnumBody */
649   ASTEnumBody jjtn000 = new ASTEnumBody(this, JJTENUMBODY);
650   boolean jjtc000 = true;
651   jjtree.openNodeScope(jjtn000);
652     try {
653       jj_consume_token(LBRACE);
654       switch (jj_nt.kind) {
655       case IDENTIFIER:
656       case AT:
657         label_7:
658         while (true) {
659           switch (jj_nt.kind) {
660           case AT:
661             ;
662             break;
663           default:
664             jj_la1[19] = jj_gen;
665             break label_7;
666           }
667           Annotation();
668         }
669         EnumConstant();
670         label_8:
671         while (true) {
672           if (jj_2_3(2)) {
673             ;
674           } else {
675             break label_8;
676           }
677           jj_consume_token(COMMA);
678           label_9:
679           while (true) {
680             switch (jj_nt.kind) {
681             case AT:
682               ;
683               break;
684             default:
685               jj_la1[20] = jj_gen;
686               break label_9;
687             }
688             Annotation();
689           }
690           EnumConstant();
691         }
692         break;
693       default:
694         jj_la1[21] = jj_gen;
695         ;
696       }
697       switch (jj_nt.kind) {
698       case COMMA:
699         jj_consume_token(COMMA);
700         break;
701       default:
702         jj_la1[22] = jj_gen;
703         ;
704       }
705       switch (jj_nt.kind) {
706       case SEMICOLON:
707         jj_consume_token(SEMICOLON);
708         label_10:
709         while (true) {
710           switch (jj_nt.kind) {
711           case ABSTRACT:
712           case BOOLEAN:
713           case BYTE:
714           case CHAR:
715           case CLASS:
716           case DOUBLE:
717           case FINAL:
718           case FLOAT:
719           case INT:
720           case INTERFACE:
721           case LONG:
722           case NATIVE:
723           case PRIVATE:
724           case PROTECTED:
725           case PUBLIC:
726           case SHORT:
727           case STATIC:
728           case SYNCHRONIZED:
729           case TRANSIENT:
730           case VOID:
731           case VOLATILE:
732           case STRICTFP:
733           case IDENTIFIER:
734           case LBRACE:
735           case SEMICOLON:
736           case AT:
737           case LT:
738             ;
739             break;
740           default:
741             jj_la1[23] = jj_gen;
742             break label_10;
743           }
744           ClassOrInterfaceBodyDeclaration();
745         }
746         break;
747       default:
748         jj_la1[24] = jj_gen;
749         ;
750       }
751       jj_consume_token(RBRACE);
752     } catch (Throwable JavaDoc jjte000) {
753      if (jjtc000) {
754        jjtree.clearNodeScope(jjtn000);
755        jjtc000 = false;
756      } else {
757        jjtree.popNode();
758      }
759      if (jjte000 instanceof RuntimeException JavaDoc) {
760        {if (true) throw (RuntimeException JavaDoc)jjte000;}
761      }
762      if (jjte000 instanceof ParseException) {
763        {if (true) throw (ParseException)jjte000;}
764      }
765      {if (true) throw (Error JavaDoc)jjte000;}
766     } finally {
767      if (jjtc000) {
768        jjtree.closeNodeScope(jjtn000, true);
769      }
770     }
771   }
772
773   final public void EnumConstant() throws ParseException {
774  /*@bgen(jjtree) EnumConstant */
775  ASTEnumConstant jjtn000 = new ASTEnumConstant(this, JJTENUMCONSTANT);
776  boolean jjtc000 = true;
777  jjtree.openNodeScope(jjtn000);Token t;
778     try {
779       t = jj_consume_token(IDENTIFIER);
780                   jjtn000.setImage(t.image);
781       switch (jj_nt.kind) {
782       case LPAREN:
783         Arguments();
784         break;
785       default:
786         jj_la1[25] = jj_gen;
787         ;
788       }
789       switch (jj_nt.kind) {
790       case LBRACE:
791         ClassOrInterfaceBody();
792         break;
793       default:
794         jj_la1[26] = jj_gen;
795         ;
796       }
797     } catch (Throwable JavaDoc jjte000) {
798     if (jjtc000) {
799       jjtree.clearNodeScope(jjtn000);
800       jjtc000 = false;
801     } else {
802       jjtree.popNode();
803     }
804     if (jjte000 instanceof RuntimeException JavaDoc) {
805       {if (true) throw (RuntimeException JavaDoc)jjte000;}
806     }
807     if (jjte000 instanceof ParseException) {
808       {if (true) throw (ParseException)jjte000;}
809     }
810     {if (true) throw (Error JavaDoc)jjte000;}
811     } finally {
812     if (jjtc000) {
813       jjtree.closeNodeScope(jjtn000, true);
814     }
815     }
816   }
817
818   final public void TypeParameters() throws ParseException {
819  /*@bgen(jjtree) TypeParameters */
820   ASTTypeParameters jjtn000 = new ASTTypeParameters(this, JJTTYPEPARAMETERS);
821   boolean jjtc000 = true;
822   jjtree.openNodeScope(jjtn000);
823     try {
824       jj_consume_token(LT);
825         checkForBadGenericsUsage();
826       TypeParameter();
827       label_11:
828       while (true) {
829         switch (jj_nt.kind) {
830         case COMMA:
831           ;
832           break;
833         default:
834           jj_la1[27] = jj_gen;
835           break label_11;
836         }
837         jj_consume_token(COMMA);
838         TypeParameter();
839       }
840       jj_consume_token(GT);
841     } catch (Throwable JavaDoc jjte000) {
842      if (jjtc000) {
843        jjtree.clearNodeScope(jjtn000);
844        jjtc000 = false;
845      } else {
846        jjtree.popNode();
847      }
848      if (jjte000 instanceof RuntimeException JavaDoc) {
849        {if (true) throw (RuntimeException JavaDoc)jjte000;}
850      }
851      if (jjte000 instanceof ParseException) {
852        {if (true) throw (ParseException)jjte000;}
853      }
854      {if (true) throw (Error JavaDoc)jjte000;}
855     } finally {
856      if (jjtc000) {
857        jjtree.closeNodeScope(jjtn000, true);
858      }
859     }
860   }
861
862   final public void TypeParameter() throws ParseException {
863  /*@bgen(jjtree) TypeParameter */
864   ASTTypeParameter jjtn000 = new ASTTypeParameter(this, JJTTYPEPARAMETER);
865   boolean jjtc000 = true;
866   jjtree.openNodeScope(jjtn000);
867     try {
868       jj_consume_token(IDENTIFIER);
869       switch (jj_nt.kind) {
870       case EXTENDS:
871         TypeBound();
872         break;
873       default:
874         jj_la1[28] = jj_gen;
875         ;
876       }
877     } catch (Throwable JavaDoc jjte000) {
878      if (jjtc000) {
879        jjtree.clearNodeScope(jjtn000);
880        jjtc000 = false;
881      } else {
882        jjtree.popNode();
883      }
884      if (jjte000 instanceof RuntimeException JavaDoc) {
885        {if (true) throw (RuntimeException JavaDoc)jjte000;}
886      }
887      if (jjte000 instanceof ParseException) {
888        {if (true) throw (ParseException)jjte000;}
889      }
890      {if (true) throw (Error JavaDoc)jjte000;}
891     } finally {
892      if (jjtc000) {
893        jjtree.closeNodeScope(jjtn000, true);
894      }
895     }
896   }
897
898   final public void TypeBound() throws ParseException {
899  /*@bgen(jjtree) TypeBound */
900   ASTTypeBound jjtn000 = new ASTTypeBound(this, JJTTYPEBOUND);
901   boolean jjtc000 = true;
902   jjtree.openNodeScope(jjtn000);
903     try {
904       jj_consume_token(EXTENDS);
905       ClassOrInterfaceType();
906       label_12:
907       while (true) {
908         switch (jj_nt.kind) {
909         case BIT_AND:
910           ;
911           break;
912         default:
913           jj_la1[29] = jj_gen;
914           break label_12;
915         }
916         jj_consume_token(BIT_AND);
917         ClassOrInterfaceType();
918       }
919     } catch (Throwable JavaDoc jjte000) {
920      if (jjtc000) {
921        jjtree.clearNodeScope(jjtn000);
922        jjtc000 = false;
923      } else {
924        jjtree.popNode();
925      }
926      if (jjte000 instanceof RuntimeException JavaDoc) {
927        {if (true) throw (RuntimeException JavaDoc)jjte000;}
928      }
929      if (jjte000 instanceof ParseException) {
930        {if (true) throw (ParseException)jjte000;}
931      }
932      {if (true) throw (Error JavaDoc)jjte000;}
933     } finally {
934      if (jjtc000) {
935        jjtree.closeNodeScope(jjtn000, true);
936      }
937     }
938   }
939
940   final public void ClassOrInterfaceBody() throws ParseException {
941  /*@bgen(jjtree) ClassOrInterfaceBody */
942   ASTClassOrInterfaceBody jjtn000 = new ASTClassOrInterfaceBody(this, JJTCLASSORINTERFACEBODY);
943   boolean jjtc000 = true;
944   jjtree.openNodeScope(jjtn000);
945     try {
946       jj_consume_token(LBRACE);
947       label_13:
948       while (true) {
949         switch (jj_nt.kind) {
950         case ABSTRACT:
951         case BOOLEAN:
952         case BYTE:
953         case CHAR:
954         case CLASS:
955         case DOUBLE:
956         case FINAL:
957         case FLOAT:
958         case INT:
959         case INTERFACE:
960         case LONG:
961         case NATIVE:
962         case PRIVATE:
963         case PROTECTED:
964         case PUBLIC:
965         case SHORT:
966         case STATIC:
967         case SYNCHRONIZED:
968         case TRANSIENT:
969         case VOID:
970         case VOLATILE:
971         case STRICTFP:
972         case IDENTIFIER:
973         case LBRACE:
974         case SEMICOLON:
975         case AT:
976         case LT:
977           ;
978           break;
979         default:
980           jj_la1[30] = jj_gen;
981           break label_13;
982         }
983         ClassOrInterfaceBodyDeclaration();
984       }
985       jj_consume_token(RBRACE);
986     } catch (Throwable JavaDoc jjte000) {
987     if (jjtc000) {
988       jjtree.clearNodeScope(jjtn000);
989       jjtc000 = false;
990     } else {
991       jjtree.popNode();
992     }
993     if (jjte000 instanceof RuntimeException JavaDoc) {
994       {if (true) throw (RuntimeException JavaDoc)jjte000;}
995     }
996     if (jjte000 instanceof ParseException) {
997       {if (true) throw (ParseException)jjte000;}
998     }
999     {if (true) throw (Error JavaDoc)jjte000;}
1000    } finally {
1001    if (jjtc000) {
1002      jjtree.closeNodeScope(jjtn000, true);
1003    }
1004    }
1005  }
1006
1007  final public void ClassOrInterfaceBodyDeclaration() throws ParseException {
1008 /*@bgen(jjtree) ClassOrInterfaceBodyDeclaration */
1009   ASTClassOrInterfaceBodyDeclaration jjtn000 = new ASTClassOrInterfaceBodyDeclaration(this, JJTCLASSORINTERFACEBODYDECLARATION);
1010   boolean jjtc000 = true;
1011   jjtree.openNodeScope(jjtn000);int modifiers;
1012    try {
1013      if (jj_2_8(2147483647)) {
1014        Initializer();
1015      } else {
1016        switch (jj_nt.kind) {
1017        case ABSTRACT:
1018        case BOOLEAN:
1019        case BYTE:
1020        case CHAR:
1021        case CLASS:
1022        case DOUBLE:
1023        case FINAL:
1024        case FLOAT:
1025        case INT:
1026        case INTERFACE:
1027        case LONG:
1028        case NATIVE:
1029        case PRIVATE:
1030        case PROTECTED:
1031        case PUBLIC:
1032        case SHORT:
1033        case STATIC:
1034        case SYNCHRONIZED:
1035        case TRANSIENT:
1036        case VOID:
1037        case VOLATILE:
1038        case STRICTFP:
1039        case IDENTIFIER:
1040        case AT:
1041        case LT:
1042          modifiers = Modifiers();
1043          if (jj_2_4(3)) {
1044            ClassOrInterfaceDeclaration(modifiers);
1045          } else if (jj_2_5(3)) {
1046            EnumDeclaration(modifiers);
1047          } else if (jj_2_6(2147483647)) {
1048            ConstructorDeclaration(modifiers);
1049          } else if (jj_2_7(2147483647)) {
1050            FieldDeclaration(modifiers);
1051          } else {
1052            switch (jj_nt.kind) {
1053            case BOOLEAN:
1054            case BYTE:
1055            case CHAR:
1056            case DOUBLE:
1057            case FLOAT:
1058            case INT:
1059            case LONG:
1060            case SHORT:
1061            case VOID:
1062            case IDENTIFIER:
1063            case LT:
1064              MethodDeclaration(modifiers);
1065              break;
1066            case AT:
1067              AnnotationTypeDeclaration(modifiers);
1068              break;
1069            default:
1070              jj_la1[31] = jj_gen;
1071              jj_consume_token(-1);
1072              throw new ParseException();
1073            }
1074          }
1075          break;
1076        case SEMICOLON:
1077          jj_consume_token(SEMICOLON);
1078          break;
1079        default:
1080          jj_la1[32] = jj_gen;
1081          jj_consume_token(-1);
1082          throw new ParseException();
1083        }
1084      }
1085    } catch (Throwable JavaDoc jjte000) {
1086    if (jjtc000) {
1087      jjtree.clearNodeScope(jjtn000);
1088      jjtc000 = false;
1089    } else {
1090      jjtree.popNode();
1091    }
1092    if (jjte000 instanceof RuntimeException JavaDoc) {
1093      {if (true) throw (RuntimeException JavaDoc)jjte000;}
1094    }
1095    if (jjte000 instanceof ParseException) {
1096      {if (true) throw (ParseException)jjte000;}
1097    }
1098    {if (true) throw (Error JavaDoc)jjte000;}
1099    } finally {
1100    if (jjtc000) {
1101      jjtree.closeNodeScope(jjtn000, true);
1102    }
1103    }
1104  }
1105
1106  final public void FieldDeclaration(int modifiers) throws ParseException {
1107 /*@bgen(jjtree) FieldDeclaration */
1108 ASTFieldDeclaration jjtn000 = new ASTFieldDeclaration(this, JJTFIELDDECLARATION);
1109 boolean jjtc000 = true;
1110 jjtree.openNodeScope(jjtn000);jjtn000.setModifiers(modifiers);
1111    try {
1112      Type();
1113      VariableDeclarator();
1114      label_14:
1115      while (true) {
1116        switch (jj_nt.kind) {
1117        case COMMA:
1118          ;
1119          break;
1120        default:
1121          jj_la1[33] = jj_gen;
1122          break label_14;
1123        }
1124        jj_consume_token(COMMA);
1125        VariableDeclarator();
1126      }
1127      jj_consume_token(SEMICOLON);
1128    } catch (Throwable JavaDoc jjte000) {
1129    if (jjtc000) {
1130      jjtree.clearNodeScope(jjtn000);
1131      jjtc000 = false;
1132    } else {
1133      jjtree.popNode();
1134    }
1135    if (jjte000 instanceof RuntimeException JavaDoc) {
1136      {if (true) throw (RuntimeException JavaDoc)jjte000;}
1137    }
1138    if (jjte000 instanceof ParseException) {
1139      {if (true) throw (ParseException)jjte000;}
1140    }
1141    {if (true) throw (Error JavaDoc)jjte000;}
1142    } finally {
1143    if (jjtc000) {
1144      jjtree.closeNodeScope(jjtn000, true);
1145    }
1146    }
1147  }
1148
1149  final public void VariableDeclarator() throws ParseException {
1150 /*@bgen(jjtree) VariableDeclarator */
1151  ASTVariableDeclarator jjtn000 = new ASTVariableDeclarator(this, JJTVARIABLEDECLARATOR);
1152  boolean jjtc000 = true;
1153  jjtree.openNodeScope(jjtn000);
1154    try {
1155      VariableDeclaratorId();
1156      switch (jj_nt.kind) {
1157      case ASSIGN:
1158        jj_consume_token(ASSIGN);
1159        VariableInitializer();
1160        break;
1161      default:
1162        jj_la1[34] = jj_gen;
1163        ;
1164      }
1165    } catch (Throwable JavaDoc jjte000) {
1166    if (jjtc000) {
1167      jjtree.clearNodeScope(jjtn000);
1168      jjtc000 = false;
1169    } else {
1170      jjtree.popNode();
1171    }
1172    if (jjte000 instanceof RuntimeException JavaDoc) {
1173      {if (true) throw (RuntimeException JavaDoc)jjte000;}
1174    }
1175    if (jjte000 instanceof ParseException) {
1176      {if (true) throw (ParseException)jjte000;}
1177    }
1178    {if (true) throw (Error JavaDoc)jjte000;}
1179    } finally {
1180    if (jjtc000) {
1181      jjtree.closeNodeScope(jjtn000, true);
1182    }
1183    }
1184  }
1185
1186  final public void VariableDeclaratorId() throws ParseException {
1187 /*@bgen(jjtree) VariableDeclaratorId */
1188 ASTVariableDeclaratorId jjtn000 = new ASTVariableDeclaratorId(this, JJTVARIABLEDECLARATORID);
1189 boolean jjtc000 = true;
1190 jjtree.openNodeScope(jjtn000);Token t;
1191    try {
1192      t = jj_consume_token(IDENTIFIER);
1193      label_15:
1194      while (true) {
1195        switch (jj_nt.kind) {
1196        case LBRACKET:
1197          ;
1198          break;
1199        default:
1200          jj_la1[35] = jj_gen;
1201          break label_15;
1202        }
1203        jj_consume_token(LBRACKET);
1204        jj_consume_token(RBRACKET);
1205               jjtn000.bumpArrayDepth();
1206      }
1207    jjtree.closeNodeScope(jjtn000, true);
1208    jjtc000 = false;
1209    checkForBadAssertUsage(t.image, "a variable name");
1210    checkForBadEnumUsage(t.image, "a variable name");
1211    jjtn000.setImage( t.image );
1212    } finally {
1213    if (jjtc000) {
1214      jjtree.closeNodeScope(jjtn000, true);
1215    }
1216    }
1217  }
1218
1219  final public void VariableInitializer() throws ParseException {
1220 /*@bgen(jjtree) VariableInitializer */
1221  ASTVariableInitializer jjtn000 = new ASTVariableInitializer(this, JJTVARIABLEINITIALIZER);
1222  boolean jjtc000 = true;
1223  jjtree.openNodeScope(jjtn000);
1224    try {
1225      switch (jj_nt.kind) {
1226      case LBRACE:
1227        ArrayInitializer();
1228        break;
1229      case BOOLEAN:
1230      case BYTE:
1231      case CHAR:
1232      case DOUBLE:
1233      case FALSE:
1234      case FLOAT:
1235      case INT:
1236      case LONG:
1237      case NEW:
1238      case NULL:
1239      case SHORT:
1240      case SUPER:
1241      case THIS:
1242      case TRUE:
1243      case VOID:
1244      case INTEGER_LITERAL:
1245      case FLOATING_POINT_LITERAL:
1246      case HEX_FLOATING_POINT_LITERAL:
1247      case CHARACTER_LITERAL:
1248      case STRING_LITERAL:
1249      case IDENTIFIER:
1250      case LPAREN:
1251      case BANG:
1252      case TILDE:
1253      case INCR:
1254      case DECR:
1255      case PLUS:
1256      case MINUS:
1257        Expression();
1258        break;
1259      default:
1260        jj_la1[36] = jj_gen;
1261        jj_consume_token(-1);
1262        throw new ParseException();
1263      }
1264    } catch (Throwable JavaDoc jjte000) {
1265    if (jjtc000) {
1266      jjtree.clearNodeScope(jjtn000);
1267      jjtc000 = false;
1268    } else {
1269      jjtree.popNode();
1270    }
1271    if (jjte000 instanceof RuntimeException JavaDoc) {
1272      {if (true) throw (RuntimeException JavaDoc)jjte000;}
1273    }
1274    if (jjte000 instanceof ParseException) {
1275      {if (true) throw (ParseException)jjte000;}
1276    }
1277    {if (true) throw (Error JavaDoc)jjte000;}
1278    } finally {
1279    if (jjtc000) {
1280      jjtree.closeNodeScope(jjtn000, true);
1281    }
1282    }
1283  }
1284
1285  final public void ArrayInitializer() throws ParseException {
1286 /*@bgen(jjtree) ArrayInitializer */
1287  ASTArrayInitializer jjtn000 = new ASTArrayInitializer(this, JJTARRAYINITIALIZER);
1288  boolean jjtc000 = true;
1289  jjtree.openNodeScope(jjtn000);
1290    try {
1291      jj_consume_token(LBRACE);
1292      switch (jj_nt.kind) {
1293      case BOOLEAN:
1294      case BYTE:
1295      case CHAR:
1296      case DOUBLE:
1297      case FALSE:
1298      case FLOAT:
1299      case INT:
1300      case LONG:
1301      case NEW:
1302      case NULL:
1303      case SHORT:
1304      case SUPER:
1305      case THIS:
1306      case TRUE:
1307      case VOID:
1308      case INTEGER_LITERAL:
1309      case FLOATING_POINT_LITERAL:
1310      case HEX_FLOATING_POINT_LITERAL:
1311      case CHARACTER_LITERAL:
1312      case STRING_LITERAL:
1313      case IDENTIFIER:
1314      case LPAREN:
1315      case LBRACE:
1316      case BANG:
1317      case TILDE:
1318      case INCR:
1319      case DECR:
1320      case PLUS:
1321      case MINUS:
1322        VariableInitializer();
1323        label_16:
1324        while (true) {
1325          if (jj_2_9(2)) {
1326            ;
1327          } else {
1328            break label_16;
1329          }
1330          jj_consume_token(COMMA);
1331          VariableInitializer();
1332        }
1333        break;
1334      default:
1335        jj_la1[37] = jj_gen;
1336        ;
1337      }
1338      switch (jj_nt.kind) {
1339      case COMMA:
1340        jj_consume_token(COMMA);
1341        break;
1342      default:
1343        jj_la1[38] = jj_gen;
1344        ;
1345      }
1346      jj_consume_token(RBRACE);
1347    } catch (Throwable JavaDoc jjte000) {
1348    if (jjtc000) {
1349      jjtree.clearNodeScope(jjtn000);
1350      jjtc000 = false;
1351    } else {
1352      jjtree.popNode();
1353    }
1354    if (jjte000 instanceof RuntimeException JavaDoc) {
1355      {if (true) throw (RuntimeException JavaDoc)jjte000;}
1356    }
1357    if (jjte000 instanceof ParseException) {
1358      {if (true) throw (ParseException)jjte000;}
1359    }
1360    {if (true) throw (Error JavaDoc)jjte000;}
1361    } finally {
1362    if (jjtc000) {
1363      jjtree.closeNodeScope(jjtn000, true);
1364    }
1365    }
1366  }
1367
1368  final public void MethodDeclaration(int modifiers) throws ParseException {
1369 /*@bgen(jjtree) MethodDeclaration */
1370 ASTMethodDeclaration jjtn000 = new ASTMethodDeclaration(this, JJTMETHODDECLARATION);
1371 boolean jjtc000 = true;
1372 jjtree.openNodeScope(jjtn000);jjtn000.setModifiers(modifiers);
1373    try {
1374      switch (jj_nt.kind) {
1375      case LT:
1376        TypeParameters();
1377        break;
1378      default:
1379        jj_la1[39] = jj_gen;
1380        ;
1381      }
1382      ResultType();
1383      MethodDeclarator();
1384      switch (jj_nt.kind) {
1385      case THROWS:
1386        jj_consume_token(THROWS);
1387        NameList();
1388        break;
1389      default:
1390        jj_la1[40] = jj_gen;
1391        ;
1392      }
1393      switch (jj_nt.kind) {
1394      case LBRACE:
1395        Block();
1396        break;
1397      case SEMICOLON:
1398        jj_consume_token(SEMICOLON);
1399        break;
1400      default:
1401        jj_la1[41] = jj_gen;
1402        jj_consume_token(-1);
1403        throw new ParseException();
1404      }
1405    } catch (Throwable JavaDoc jjte000) {
1406    if (jjtc000) {
1407      jjtree.clearNodeScope(jjtn000);
1408      jjtc000 = false;
1409    } else {
1410      jjtree.popNode();
1411    }
1412    if (jjte000 instanceof RuntimeException JavaDoc) {
1413      {if (true) throw (RuntimeException JavaDoc)jjte000;}
1414    }
1415    if (jjte000 instanceof ParseException) {
1416      {if (true) throw (ParseException)jjte000;}
1417    }
1418    {if (true) throw (Error JavaDoc)jjte000;}
1419    } finally {
1420    if (jjtc000) {
1421      jjtree.closeNodeScope(jjtn000, true);
1422    }
1423    }
1424  }
1425
1426  final public void MethodDeclarator() throws ParseException {
1427 /*@bgen(jjtree) MethodDeclarator */
1428 ASTMethodDeclarator jjtn000 = new ASTMethodDeclarator(this, JJTMETHODDECLARATOR);
1429 boolean jjtc000 = true;
1430 jjtree.openNodeScope(jjtn000);Token t;
1431    try {
1432      t = jj_consume_token(IDENTIFIER);
1433    checkForBadAssertUsage(t.image, "a method name");
1434    checkForBadEnumUsage(t.image, "a method name");
1435    jjtn000.setImage( t.image );
1436      FormalParameters();
1437      label_17:
1438      while (true) {
1439        switch (jj_nt.kind) {
1440        case LBRACKET:
1441          ;
1442          break;
1443        default:
1444          jj_la1[42] = jj_gen;
1445          break label_17;
1446        }
1447        jj_consume_token(LBRACKET);
1448        jj_consume_token(RBRACKET);
1449      }
1450    } catch (Throwable JavaDoc jjte000) {
1451    if (jjtc000) {
1452      jjtree.clearNodeScope(jjtn000);
1453      jjtc000 = false;
1454    } else {
1455      jjtree.popNode();
1456    }
1457    if (jjte000 instanceof RuntimeException JavaDoc) {
1458      {if (true) throw (RuntimeException JavaDoc)jjte000;}
1459    }
1460    if (jjte000 instanceof ParseException) {
1461      {if (true) throw (ParseException)jjte000;}
1462    }
1463    {if (true) throw (Error JavaDoc)jjte000;}
1464    } finally {
1465    if (jjtc000) {
1466      jjtree.closeNodeScope(jjtn000, true);
1467    }
1468    }
1469  }
1470
1471  final public void FormalParameters() throws ParseException {
1472 /*@bgen(jjtree) FormalParameters */
1473  ASTFormalParameters jjtn000 = new ASTFormalParameters(this, JJTFORMALPARAMETERS);
1474  boolean jjtc000 = true;
1475  jjtree.openNodeScope(jjtn000);
1476    try {
1477      jj_consume_token(LPAREN);
1478      switch (jj_nt.kind) {
1479      case BOOLEAN:
1480      case BYTE:
1481      case CHAR:
1482      case DOUBLE:
1483      case FINAL:
1484      case FLOAT:
1485      case INT:
1486      case LONG:
1487      case SHORT:
1488      case IDENTIFIER:
1489      case AT:
1490        FormalParameter();
1491        label_18:
1492        while (true) {
1493          switch (jj_nt.kind) {
1494          case COMMA:
1495            ;
1496            break;
1497          default:
1498            jj_la1[43] = jj_gen;
1499            break label_18;
1500          }
1501          jj_consume_token(COMMA);
1502          FormalParameter();
1503        }
1504        break;
1505      default:
1506        jj_la1[44] = jj_gen;
1507        ;
1508      }
1509      jj_consume_token(RPAREN);
1510    } catch (Throwable JavaDoc jjte000) {
1511    if (jjtc000) {
1512      jjtree.clearNodeScope(jjtn000);
1513      jjtc000 = false;
1514    } else {
1515      jjtree.popNode();
1516    }
1517    if (jjte000 instanceof RuntimeException JavaDoc) {
1518      {if (true) throw (RuntimeException JavaDoc)jjte000;}
1519    }
1520    if (jjte000 instanceof ParseException) {
1521      {if (true) throw (ParseException)jjte000;}
1522    }
1523    {if (true) throw (Error JavaDoc)jjte000;}
1524    } finally {
1525    if (jjtc000) {
1526      jjtree.closeNodeScope(jjtn000, true);
1527    }
1528    }
1529  }
1530
1531  final public void FormalParameter() throws ParseException {
1532 /*@bgen(jjtree) FormalParameter */
1533  ASTFormalParameter jjtn000 = new ASTFormalParameter(this, JJTFORMALPARAMETER);
1534  boolean jjtc000 = true;
1535  jjtree.openNodeScope(jjtn000);
1536    try {
1537      label_19:
1538      while (true) {
1539        switch (jj_nt.kind) {
1540        case FINAL:
1541        case AT:
1542          ;
1543          break;
1544        default:
1545          jj_la1[45] = jj_gen;
1546          break label_19;
1547        }
1548        switch (jj_nt.kind) {
1549        case FINAL:
1550          jj_consume_token(FINAL);
1551              jjtn000.setFinal();
1552          break;
1553        case AT:
1554          Annotation();
1555          break;
1556        default:
1557          jj_la1[46] = jj_gen;
1558          jj_consume_token(-1);
1559          throw new ParseException();
1560        }
1561      }
1562      Type();
1563      switch (jj_nt.kind) {
1564      case ELLIPSIS:
1565        jj_consume_token(ELLIPSIS);
1566            checkForBadVariableArgumentsUsage();
1567                                                   jjtn000.setVarargs();
1568        break;
1569      default:
1570        jj_la1[47] = jj_gen;
1571        ;
1572      }
1573      VariableDeclaratorId();
1574    } catch (Throwable JavaDoc jjte000) {
1575     if (jjtc000) {
1576       jjtree.clearNodeScope(jjtn000);
1577       jjtc000 = false;
1578     } else {
1579       jjtree.popNode();
1580     }
1581     if (jjte000 instanceof RuntimeException JavaDoc) {
1582       {if (true) throw (RuntimeException JavaDoc)jjte000;}
1583     }
1584     if (jjte000 instanceof ParseException) {
1585       {if (true) throw (ParseException)jjte000;}
1586     }
1587     {if (true) throw (Error JavaDoc)jjte000;}
1588    } finally {
1589     if (jjtc000) {
1590       jjtree.closeNodeScope(jjtn000, true);
1591     }
1592    }
1593  }
1594
1595  final public void ConstructorDeclaration(int modifiers) throws ParseException {
1596 /*@bgen(jjtree) ConstructorDeclaration */
1597 ASTConstructorDeclaration jjtn000 = new ASTConstructorDeclaration(this, JJTCONSTRUCTORDECLARATION);
1598 boolean jjtc000 = true;
1599 jjtree.openNodeScope(jjtn000);jjtn000.setModifiers(modifiers);
1600Token t;
1601    try {
1602      switch (jj_nt.kind) {
1603      case LT:
1604        TypeParameters();
1605        break;
1606      default:
1607        jj_la1[48] = jj_gen;
1608        ;
1609      }
1610      jj_consume_token(IDENTIFIER);
1611      FormalParameters();
1612      switch (jj_nt.kind) {
1613      case THROWS:
1614        jj_consume_token(THROWS);
1615        NameList();
1616        break;
1617      default:
1618        jj_la1[49] = jj_gen;
1619        ;
1620      }
1621      jj_consume_token(LBRACE);
1622      if (jj_2_10(2147483647)) {
1623        ExplicitConstructorInvocation();
1624      } else {
1625        ;
1626      }
1627      label_20:
1628      while (true) {
1629        if (jj_2_11(1)) {
1630          ;
1631        } else {
1632          break label_20;
1633        }
1634        BlockStatement();
1635      }
1636      t = jj_consume_token(RBRACE);
1637            jjtree.closeNodeScope(jjtn000, true);
1638            jjtc000 = false;
1639            if (isPrecededByComment(t)) { jjtn000.setContainsComment(); }
1640    } catch (Throwable JavaDoc jjte000) {
1641      if (jjtc000) {
1642        jjtree.clearNodeScope(jjtn000);
1643        jjtc000 = false;
1644      } else {
1645        jjtree.popNode();
1646      }
1647      if (jjte000 instanceof RuntimeException JavaDoc) {
1648        {if (true) throw (RuntimeException JavaDoc)jjte000;}
1649      }
1650      if (jjte000 instanceof ParseException) {
1651        {if (true) throw (ParseException)jjte000;}
1652      }
1653      {if (true) throw (Error JavaDoc)jjte000;}
1654    } finally {
1655      if (jjtc000) {
1656        jjtree.closeNodeScope(jjtn000, true);
1657      }
1658    }
1659  }
1660
1661  final public void ExplicitConstructorInvocation() throws ParseException {
1662 /*@bgen(jjtree) ExplicitConstructorInvocation */
1663  ASTExplicitConstructorInvocation jjtn000 = new ASTExplicitConstructorInvocation(this, JJTEXPLICITCONSTRUCTORINVOCATION);
1664  boolean jjtc000 = true;
1665  jjtree.openNodeScope(jjtn000);
1666    try {
1667      if (jj_2_13(2147483647)) {
1668        jj_consume_token(THIS);
1669                                             jjtn000.setIsThis();
1670        Arguments();
1671        jj_consume_token(SEMICOLON);
1672      } else {
1673        switch (jj_nt.kind) {
1674        case BOOLEAN:
1675        case BYTE:
1676        case CHAR:
1677        case DOUBLE:
1678        case FALSE:
1679        case FLOAT:
1680        case INT:
1681        case LONG:
1682        case NEW:
1683        case NULL:
1684        case SHORT:
1685        case SUPER:
1686        case THIS:
1687        case TRUE:
1688        case VOID:
1689        case INTEGER_LITERAL:
1690        case FLOATING_POINT_LITERAL:
1691        case HEX_FLOATING_POINT_LITERAL:
1692        case CHARACTER_LITERAL:
1693        case STRING_LITERAL:
1694        case IDENTIFIER:
1695        case LPAREN:
1696          if (jj_2_12(2)) {
1697            PrimaryExpression();
1698            jj_consume_token(DOT);
1699            jj_consume_token(SUPER);
1700            jj_consume_token(LPAREN);
1701          } else {
1702            ;
1703          }
1704          switch (jj_nt.kind) {
1705          case SUPER:
1706            jj_consume_token(SUPER);
1707            break;
1708          case THIS:
1709            jj_consume_token(THIS);
1710            break;
1711          default:
1712            jj_la1[50] = jj_gen;
1713            jj_consume_token(-1);
1714            throw new ParseException();
1715          }
1716          Arguments();
1717          jj_consume_token(SEMICOLON);
1718          break;
1719        default:
1720          jj_la1[51] = jj_gen;
1721          jj_consume_token(-1);
1722          throw new ParseException();
1723        }
1724      }
1725    } catch (Throwable JavaDoc jjte000) {
1726    if (jjtc000) {
1727      jjtree.clearNodeScope(jjtn000);
1728      jjtc000 = false;
1729    } else {
1730      jjtree.popNode();
1731    }
1732    if (jjte000 instanceof RuntimeException JavaDoc) {
1733      {if (true) throw (RuntimeException JavaDoc)jjte000;}
1734    }
1735    if (jjte000 instanceof ParseException) {
1736      {if (true) throw (ParseException)jjte000;}
1737    }
1738    {if (true) throw (Error JavaDoc)jjte000;}
1739    } finally {
1740    if (jjtc000) {
1741      jjtree.closeNodeScope(jjtn000, true);
1742    }
1743    }
1744  }
1745
1746  final public void Initializer() throws ParseException {
1747 /*@bgen(jjtree) Initializer */
1748  ASTInitializer jjtn000 = new ASTInitializer(this, JJTINITIALIZER);
1749  boolean jjtc000 = true;
1750  jjtree.openNodeScope(jjtn000);
1751    try {
1752      switch (jj_nt.kind) {
1753      case STATIC:
1754        jj_consume_token(STATIC);
1755              jjtn000.setStatic();
1756        break;
1757      default:
1758        jj_la1[52] = jj_gen;
1759        ;
1760      }
1761      Block();
1762    } catch (Throwable JavaDoc jjte000) {
1763    if (jjtc000) {
1764      jjtree.clearNodeScope(jjtn000);
1765      jjtc000 = false;
1766    } else {
1767      jjtree.popNode();
1768    }
1769    if (jjte000 instanceof RuntimeException JavaDoc) {
1770      {if (true) throw (RuntimeException JavaDoc)jjte000;}
1771    }
1772    if (jjte000 instanceof ParseException) {
1773      {if (true) throw (ParseException)jjte000;}
1774    }
1775    {if (true) throw (Error JavaDoc)jjte000;}
1776    } finally {
1777    if (jjtc000) {
1778      jjtree.closeNodeScope(jjtn000, true);
1779    }
1780    }
1781  }
1782
1783/*
1784 * Type, name and expression syntax follows.
1785 */

1786  final public void Type() throws ParseException {
1787 /*@bgen(jjtree) Type */
1788  ASTType jjtn000 = new ASTType(this, JJTTYPE);
1789  boolean jjtc000 = true;
1790  jjtree.openNodeScope(jjtn000);
1791    try {
1792      if (jj_2_14(2)) {
1793        ReferenceType();
1794      } else {
1795        switch (jj_nt.kind) {
1796        case BOOLEAN:
1797        case BYTE:
1798        case CHAR:
1799        case DOUBLE:
1800        case FLOAT:
1801        case INT:
1802        case LONG:
1803        case SHORT:
1804          PrimitiveType();
1805          break;
1806        default:
1807          jj_la1[53] = jj_gen;
1808          jj_consume_token(-1);
1809          throw new ParseException();
1810        }
1811      }
1812    } catch (Throwable JavaDoc jjte000) {
1813     if (jjtc000) {
1814       jjtree.clearNodeScope(jjtn000);
1815       jjtc000 = false;
1816     } else {
1817       jjtree.popNode();
1818     }
1819     if (jjte000 instanceof RuntimeException JavaDoc) {
1820       {if (true) throw (RuntimeException JavaDoc)jjte000;}
1821     }
1822     if (jjte000 instanceof ParseException) {
1823       {if (true) throw (ParseException)jjte000;}
1824     }
1825     {if (true) throw (Error JavaDoc)jjte000;}
1826    } finally {
1827     if (jjtc000) {
1828       jjtree.closeNodeScope(jjtn000, true);
1829     }
1830    }
1831  }
1832
1833  final public void ReferenceType() throws ParseException {
1834 /*@bgen(jjtree) ReferenceType */
1835  ASTReferenceType jjtn000 = new ASTReferenceType(this, JJTREFERENCETYPE);
1836  boolean jjtc000 = true;
1837  jjtree.openNodeScope(jjtn000);
1838    try {
1839      switch (jj_nt.kind) {
1840      case BOOLEAN:
1841      case BYTE:
1842      case CHAR:
1843      case DOUBLE:
1844      case FLOAT:
1845      case INT:
1846      case LONG:
1847      case SHORT:
1848        PrimitiveType();
1849        label_21:
1850        while (true) {
1851          jj_consume_token(LBRACKET);
1852          jj_consume_token(RBRACKET);
1853                                            jjtn000.bumpArrayDepth();
1854          if (jj_2_15(2)) {
1855            ;
1856          } else {
1857            break label_21;
1858          }
1859        }
1860        break;
1861      case IDENTIFIER:
1862        ClassOrInterfaceType();
1863        label_22:
1864        while (true) {
1865          if (jj_2_16(2)) {
1866            ;
1867          } else {
1868            break label_22;
1869          }
1870          jj_consume_token(LBRACKET);
1871          jj_consume_token(RBRACKET);
1872                                                       jjtn000.bumpArrayDepth();
1873        }
1874        break;
1875      default:
1876        jj_la1[54] = jj_gen;
1877        jj_consume_token(-1);
1878        throw new ParseException();
1879      }
1880    } catch (Throwable JavaDoc jjte000) {
1881     if (jjtc000) {
1882       jjtree.clearNodeScope(jjtn000);
1883       jjtc000 = false;
1884     } else {
1885       jjtree.popNode();
1886     }
1887     if (jjte000 instanceof RuntimeException JavaDoc) {
1888       {if (true) throw (RuntimeException JavaDoc)jjte000;}
1889     }
1890     if (jjte000 instanceof ParseException) {
1891       {if (true) throw (ParseException)jjte000;}
1892     }
1893     {if (true) throw (Error JavaDoc)jjte000;}
1894    } finally {
1895     if (jjtc000) {
1896       jjtree.closeNodeScope(jjtn000, true);
1897     }
1898    }
1899  }
1900
1901  final public void ClassOrInterfaceType() throws ParseException {
1902 /*@bgen(jjtree) ClassOrInterfaceType */
1903  ASTClassOrInterfaceType jjtn000 = new ASTClassOrInterfaceType(this, JJTCLASSORINTERFACETYPE);
1904  boolean jjtc000 = true;
1905  jjtree.openNodeScope(jjtn000);StringBuffer JavaDoc s = new StringBuffer JavaDoc();
1906  Token t;
1907    try {
1908      t = jj_consume_token(IDENTIFIER);
1909                  s.append(t.image);
1910      if (jj_2_17(2)) {
1911        TypeArguments();
1912      } else {
1913        ;
1914      }
1915      label_23:
1916      while (true) {
1917        if (jj_2_18(2)) {
1918          ;
1919        } else {
1920          break label_23;
1921        }
1922        jj_consume_token(DOT);
1923        t = jj_consume_token(IDENTIFIER);
1924                                     s.append('.').append(t.image);
1925        if (jj_2_19(2)) {
1926          TypeArguments();
1927        } else {
1928          ;
1929        }
1930      }
1931    jjtree.closeNodeScope(jjtn000, true);
1932    jjtc000 = false;
1933   jjtn000.setImage(s.toString());
1934    } catch (Throwable JavaDoc jjte000) {
1935    if (jjtc000) {
1936      jjtree.clearNodeScope(jjtn000);
1937      jjtc000 = false;
1938    } else {
1939      jjtree.popNode();
1940    }
1941    if (jjte000 instanceof RuntimeException JavaDoc) {
1942      {if (true) throw (RuntimeException JavaDoc)jjte000;}
1943    }
1944    if (jjte000 instanceof ParseException) {
1945      {if (true) throw (ParseException)jjte000;}
1946    }
1947    {if (true) throw (Error JavaDoc)jjte000;}
1948    } finally {
1949    if (jjtc000) {
1950      jjtree.closeNodeScope(jjtn000, true);
1951    }
1952    }
1953  }
1954
1955  final public void TypeArguments() throws ParseException {
1956 /*@bgen(jjtree) TypeArguments */
1957  ASTTypeArguments jjtn000 = new ASTTypeArguments(this, JJTTYPEARGUMENTS);
1958  boolean jjtc000 = true;
1959  jjtree.openNodeScope(jjtn000);
1960    try {
1961      jj_consume_token(LT);
1962        checkForBadGenericsUsage();
1963      TypeArgument();
1964      label_24:
1965      while (true) {
1966        switch (jj_nt.kind) {
1967        case COMMA:
1968          ;
1969          break;
1970        default:
1971          jj_la1[55] = jj_gen;
1972          break label_24;
1973        }
1974        jj_consume_token(COMMA);
1975        TypeArgument();
1976      }
1977      jj_consume_token(GT);
1978    } catch (Throwable JavaDoc jjte000) {
1979     if (jjtc000) {
1980       jjtree.clearNodeScope(jjtn000);
1981       jjtc000 = false;
1982     } else {
1983       jjtree.popNode();
1984     }
1985     if (jjte000 instanceof RuntimeException JavaDoc) {
1986       {if (true) throw (RuntimeException JavaDoc)jjte000;}
1987     }
1988     if (jjte000 instanceof ParseException) {
1989       {if (true) throw (ParseException)jjte000;}
1990     }
1991     {if (true) throw (Error JavaDoc)jjte000;}
1992    } finally {
1993     if (jjtc000) {
1994       jjtree.closeNodeScope(jjtn000, true);
1995     }
1996    }
1997  }
1998
1999  final public void TypeArgument() throws ParseException {
2000 /*@bgen(jjtree) TypeArgument */
2001  ASTTypeArgument jjtn000 = new ASTTypeArgument(this, JJTTYPEARGUMENT);
2002  boolean jjtc000 = true;
2003  jjtree.openNodeScope(jjtn000);
2004    try {
2005      switch (jj_nt.kind) {
2006      case BOOLEAN:
2007      case BYTE:
2008      case CHAR:
2009      case DOUBLE:
2010      case FLOAT:
2011      case INT:
2012      case LONG:
2013      case SHORT:
2014      case IDENTIFIER:
2015        ReferenceType();
2016        break;
2017      case HOOK:
2018        jj_consume_token(HOOK);
2019        switch (jj_nt.kind) {
2020        case EXTENDS:
2021        case SUPER:
2022          WildcardBounds();
2023          break;
2024        default:
2025          jj_la1[56] = jj_gen;
2026          ;
2027        }
2028        break;
2029      default:
2030        jj_la1[57] = jj_gen;
2031        jj_consume_token(-1);
2032        throw new ParseException();
2033      }
2034    } catch (Throwable JavaDoc jjte000) {
2035     if (jjtc000) {
2036       jjtree.clearNodeScope(jjtn000);
2037       jjtc000 = false;
2038     } else {
2039       jjtree.popNode();
2040     }
2041     if (jjte000 instanceof RuntimeException JavaDoc) {
2042       {if (true) throw (RuntimeException JavaDoc)jjte000;}
2043     }
2044     if (jjte000 instanceof ParseException) {
2045       {if (true) throw (ParseException)jjte000;}
2046     }
2047     {if (true) throw (Error JavaDoc)jjte000;}
2048    } finally {
2049     if (jjtc000) {
2050       jjtree.closeNodeScope(jjtn000, true);
2051     }
2052    }
2053  }
2054
2055  final public void WildcardBounds() throws ParseException {
2056 /*@bgen(jjtree) WildcardBounds */
2057  ASTWildcardBounds jjtn000 = new ASTWildcardBounds(this, JJTWILDCARDBOUNDS);
2058  boolean jjtc000 = true;
2059  jjtree.openNodeScope(jjtn000);
2060    try {
2061      switch (jj_nt.kind) {
2062      case EXTENDS:
2063        jj_consume_token(EXTENDS);
2064        ReferenceType();
2065        break;
2066      case SUPER:
2067        jj_consume_token(SUPER);
2068        ReferenceType();
2069        break;
2070      default:
2071        jj_la1[58] = jj_gen;
2072        jj_consume_token(-1);
2073        throw new ParseException();
2074      }
2075    } catch (Throwable JavaDoc jjte000) {
2076     if (jjtc000) {
2077       jjtree.clearNodeScope(jjtn000);
2078       jjtc000 = false;
2079     } else {
2080       jjtree.popNode();
2081     }
2082     if (jjte000 instanceof RuntimeException JavaDoc) {
2083       {if (true) throw (RuntimeException JavaDoc)jjte000;}
2084     }
2085     if (jjte000 instanceof ParseException) {
2086       {if (true) throw (ParseException)jjte000;}
2087     }
2088     {if (true) throw (Error JavaDoc)jjte000;}
2089    } finally {
2090     if (jjtc000) {
2091       jjtree.closeNodeScope(jjtn000, true);
2092     }
2093    }
2094  }
2095
2096  final public void PrimitiveType() throws ParseException {
2097 /*@bgen(jjtree) PrimitiveType */
2098  ASTPrimitiveType jjtn000 = new ASTPrimitiveType(this, JJTPRIMITIVETYPE);
2099  boolean jjtc000 = true;
2100  jjtree.openNodeScope(jjtn000);
2101    try {
2102      switch (jj_nt.kind) {
2103      case BOOLEAN:
2104        jj_consume_token(BOOLEAN);
2105              jjtree.closeNodeScope(jjtn000, true);
2106              jjtc000 = false;
2107             jjtn000.setImage("boolean");
2108        break;
2109      case CHAR:
2110        jj_consume_token(CHAR);
2111           jjtree.closeNodeScope(jjtn000, true);
2112           jjtc000 = false;
2113          jjtn000.setImage("char");
2114        break;
2115      case BYTE:
2116        jj_consume_token(BYTE);
2117           jjtree.closeNodeScope(jjtn000, true);
2118           jjtc000 = false;
2119          jjtn000.setImage("byte");
2120        break;
2121      case SHORT:
2122        jj_consume_token(SHORT);
2123            jjtree.closeNodeScope(jjtn000, true);
2124            jjtc000 = false;
2125           jjtn000.setImage("short");
2126        break;
2127      case INT:
2128        jj_consume_token(INT);
2129          jjtree.closeNodeScope(jjtn000, true);
2130          jjtc000 = false;
2131         jjtn000.setImage("int");
2132        break;
2133      case LONG:
2134        jj_consume_token(LONG);
2135           jjtree.closeNodeScope(jjtn000, true);
2136           jjtc000 = false;
2137          jjtn000.setImage("long");
2138        break;
2139      case FLOAT:
2140        jj_consume_token(FLOAT);
2141            jjtree.closeNodeScope(jjtn000, true);
2142            jjtc000 = false;
2143           jjtn000.setImage("float");
2144        break;
2145      case DOUBLE:
2146        jj_consume_token(DOUBLE);
2147             jjtree.closeNodeScope(jjtn000, true);
2148             jjtc000 = false;
2149            jjtn000.setImage("double");
2150        break;
2151      default:
2152        jj_la1[59] = jj_gen;
2153        jj_consume_token(-1);
2154        throw new ParseException();
2155      }
2156    } finally {
2157    if (jjtc000) {
2158      jjtree.closeNodeScope(jjtn000, true);
2159    }
2160    }
2161  }
2162
2163  final public void ResultType() throws ParseException {
2164 /*@bgen(jjtree) ResultType */
2165  ASTResultType jjtn000 = new ASTResultType(this, JJTRESULTTYPE);
2166  boolean jjtc000 = true;
2167  jjtree.openNodeScope(jjtn000);
2168    try {
2169      switch (jj_nt.kind) {
2170      case VOID:
2171        jj_consume_token(VOID);
2172        break;
2173      case BOOLEAN:
2174      case BYTE:
2175      case CHAR:
2176      case DOUBLE:
2177      case FLOAT:
2178      case INT:
2179      case LONG:
2180      case SHORT:
2181      case IDENTIFIER:
2182        Type();
2183        break;
2184      default:
2185        jj_la1[60] = jj_gen;
2186        jj_consume_token(-1);
2187        throw new ParseException();
2188      }
2189    } catch (Throwable JavaDoc jjte000) {
2190    if (jjtc000) {
2191      jjtree.clearNodeScope(jjtn000);
2192      jjtc000 = false;
2193    } else {
2194      jjtree.popNode();
2195    }
2196    if (jjte000 instanceof RuntimeException JavaDoc) {
2197      {if (true) throw (RuntimeException JavaDoc)jjte000;}
2198    }
2199    if (jjte000 instanceof ParseException) {
2200      {if (true) throw (ParseException)jjte000;}
2201    }
2202    {if (true) throw (Error JavaDoc)jjte000;}
2203    } finally {
2204    if (jjtc000) {
2205      jjtree.closeNodeScope(jjtn000, true);
2206    }
2207    }
2208  }
2209
2210  final public void Name() throws ParseException {
2211 /*@bgen(jjtree) Name */
2212  ASTName jjtn000 = new ASTName(this, JJTNAME);
2213  boolean jjtc000 = true;
2214  jjtree.openNodeScope(jjtn000);StringBuffer JavaDoc s = new StringBuffer JavaDoc();
2215  Token t;
2216    try {
2217      t = jj_consume_token(IDENTIFIER);
2218    jjtn000.testingOnly__setBeginLine( t.beginLine);
2219    jjtn000.testingOnly__setBeginColumn( t.beginColumn);
2220    s.append(t.image);
2221      label_25:
2222      while (true) {
2223        if (jj_2_20(2)) {
2224          ;
2225        } else {
2226          break label_25;
2227        }
2228        jj_consume_token(DOT);
2229        t = jj_consume_token(IDENTIFIER);
2230     s.append('.').append(t.image);
2231      }
2232    jjtree.closeNodeScope(jjtn000, true);
2233    jjtc000 = false;
2234   jjtn000.setImage(s.toString());
2235    } finally {
2236    if (jjtc000) {
2237      jjtree.closeNodeScope(jjtn000, true);
2238    }
2239    }
2240  }
2241
2242  final public void NameList() throws ParseException {
2243 /*@bgen(jjtree) NameList */
2244  ASTNameList jjtn000 = new ASTNameList(this, JJTNAMELIST);
2245  boolean jjtc000 = true;
2246  jjtree.openNodeScope(jjtn000);
2247    try {
2248      Name();
2249      label_26:
2250      while (true) {
2251        switch (jj_nt.kind) {
2252        case COMMA:
2253          ;
2254          break;
2255        default:
2256          jj_la1[61] = jj_gen;
2257          break label_26;
2258        }
2259        jj_consume_token(COMMA);
2260        Name();
2261      }
2262    } catch (Throwable JavaDoc jjte000) {
2263    if (jjtc000) {
2264      jjtree.clearNodeScope(jjtn000);
2265      jjtc000 = false;
2266    } else {
2267      jjtree.popNode();
2268    }
2269    if (jjte000 instanceof RuntimeException JavaDoc) {
2270      {if (true) throw (RuntimeException JavaDoc)jjte000;}
2271    }
2272    if (jjte000 instanceof ParseException) {
2273      {if (true) throw (ParseException)jjte000;}
2274    }
2275    {if (true) throw (Error JavaDoc)jjte000;}
2276    } finally {
2277    if (jjtc000) {
2278      jjtree.closeNodeScope(jjtn000, true);
2279    }
2280    }
2281  }
2282
2283/*
2284 * Expression syntax follows.
2285 */

2286  final public void Expression() throws ParseException {
2287 /*@bgen(jjtree) Expression */
2288  ASTExpression jjtn000 = new ASTExpression(this, JJTEXPRESSION);
2289  boolean jjtc000 = true;
2290  jjtree.openNodeScope(jjtn000);
2291    try {
2292      ConditionalExpression();
2293      switch (jj_nt.kind) {
2294      case ASSIGN:
2295      case PLUSASSIGN:
2296      case MINUSASSIGN:
2297      case STARASSIGN:
2298      case SLASHASSIGN:
2299      case ANDASSIGN:
2300      case ORASSIGN:
2301      case XORASSIGN:
2302      case REMASSIGN:
2303      case LSHIFTASSIGN:
2304      case RSIGNEDSHIFTASSIGN:
2305      case RUNSIGNEDSHIFTASSIGN:
2306        AssignmentOperator();
2307        Expression();
2308        break;
2309      default:
2310        jj_la1[62] = jj_gen;
2311        ;
2312      }
2313    } catch (Throwable JavaDoc jjte000) {
2314    if (jjtc000) {
2315      jjtree.clearNodeScope(jjtn000);
2316      jjtc000 = false;
2317    } else {
2318      jjtree.popNode();
2319    }
2320    if (jjte000 instanceof RuntimeException JavaDoc) {
2321      {if (true) throw (RuntimeException JavaDoc)jjte000;}
2322    }
2323    if (jjte000 instanceof ParseException) {
2324      {if (true) throw (ParseException)jjte000;}
2325    }
2326    {if (true) throw (Error JavaDoc)jjte000;}
2327    } finally {
2328    if (jjtc000) {
2329      jjtree.closeNodeScope(jjtn000, true);
2330    }
2331    }
2332  }
2333
2334  final public void AssignmentOperator() throws ParseException {
2335 /*@bgen(jjtree) AssignmentOperator */
2336  ASTAssignmentOperator jjtn000 = new ASTAssignmentOperator(this, JJTASSIGNMENTOPERATOR);
2337  boolean jjtc000 = true;
2338  jjtree.openNodeScope(jjtn000);
2339    try {
2340      switch (jj_nt.kind) {
2341      case ASSIGN:
2342        jj_consume_token(ASSIGN);
2343                jjtree.closeNodeScope(jjtn000, true);
2344                jjtc000 = false;
2345               jjtn000.setImage("=");
2346        break;
2347      case STARASSIGN:
2348        jj_consume_token(STARASSIGN);
2349                jjtree.closeNodeScope(jjtn000, true);
2350                jjtc000 = false;
2351               jjtn000.setImage("*="); jjtn000.setCompound();
2352        break;
2353      case SLASHASSIGN:
2354        jj_consume_token(SLASHASSIGN);
2355                jjtree.closeNodeScope(jjtn000, true);
2356                jjtc000 = false;
2357               jjtn000.setImage("/="); jjtn000.setCompound();
2358        break;
2359      case REMASSIGN:
2360        jj_consume_token(REMASSIGN);
2361                jjtree.closeNodeScope(jjtn000, true);
2362                jjtc000 = false;
2363               jjtn000.setImage("%="); jjtn000.setCompound();
2364        break;
2365      case PLUSASSIGN:
2366        jj_consume_token(PLUSASSIGN);
2367                jjtree.closeNodeScope(jjtn000, true);
2368                jjtc000 = false;
2369               jjtn000.setImage("+="); jjtn000.setCompound();
2370        break;
2371      case MINUSASSIGN:
2372        jj_consume_token(MINUSASSIGN);
2373                jjtree.closeNodeScope(jjtn000, true);
2374                jjtc000 = false;
2375               jjtn000.setImage("-="); jjtn000.setCompound();
2376        break;
2377      case LSHIFTASSIGN:
2378        jj_consume_token(LSHIFTASSIGN);
2379                jjtree.closeNodeScope(jjtn000, true);
2380                jjtc000 = false;
2381               jjtn000.setImage("<<="); jjtn000.setCompound();
2382        break;
2383      case RSIGNEDSHIFTASSIGN:
2384        jj_consume_token(RSIGNEDSHIFTASSIGN);
2385                jjtree.closeNodeScope(jjtn000, true);
2386                jjtc000 = false;
2387               jjtn000.setImage(">>="); jjtn000.setCompound();
2388        break;
2389      case RUNSIGNEDSHIFTASSIGN:
2390        jj_consume_token(RUNSIGNEDSHIFTASSIGN);
2391                jjtree.closeNodeScope(jjtn000, true);
2392                jjtc000 = false;
2393               jjtn000.setImage(">>>="); jjtn000.setCompound();
2394        break;
2395      case ANDASSIGN:
2396        jj_consume_token(ANDASSIGN);
2397                jjtree.closeNodeScope(jjtn000, true);
2398                jjtc000 = false;
2399               jjtn000.setImage("&="); jjtn000.setCompound();
2400        break;
2401      case XORASSIGN:
2402        jj_consume_token(XORASSIGN);
2403                jjtree.closeNodeScope(jjtn000, true);
2404                jjtc000 = false;
2405               jjtn000.setImage("^="); jjtn000.setCompound();
2406        break;
2407      case ORASSIGN:
2408        jj_consume_token(ORASSIGN);
2409                jjtree.closeNodeScope(jjtn000, true);
2410                jjtc000 = false;
2411               jjtn000.setImage("|="); jjtn000.setCompound();
2412        break;
2413      default:
2414        jj_la1[63] = jj_gen;
2415        jj_consume_token(-1);
2416        throw new ParseException();
2417      }
2418    } finally {
2419        if (jjtc000) {
2420          jjtree.closeNodeScope(jjtn000, true);
2421        }
2422    }
2423  }
2424
2425  final public void ConditionalExpression() throws ParseException {
2426 /*@bgen(jjtree) #ConditionalExpression(> 1) */
2427  ASTConditionalExpression jjtn000 = new ASTConditionalExpression(this, JJTCONDITIONALEXPRESSION);
2428  boolean jjtc000 = true;
2429  jjtree.openNodeScope(jjtn000);
2430    try {
2431      ConditionalOrExpression();
2432      switch (jj_nt.kind) {
2433      case HOOK:
2434        jj_consume_token(HOOK);
2435                                   jjtn000.setTernary();
2436        Expression();
2437        jj_consume_token(COLON);
2438        ConditionalExpression();
2439        break;
2440      default:
2441        jj_la1[64] = jj_gen;
2442        ;
2443      }
2444    } catch (Throwable JavaDoc jjte000) {
2445    if (jjtc000) {
2446      jjtree.clearNodeScope(jjtn000);
2447      jjtc000 = false;
2448    } else {
2449      jjtree.popNode();
2450    }
2451    if (jjte000 instanceof RuntimeException JavaDoc) {
2452      {if (true) throw (RuntimeException JavaDoc)jjte000;}
2453    }
2454    if (jjte000 instanceof ParseException) {
2455      {if (true) throw (ParseException)jjte000;}
2456    }
2457    {if (true) throw (Error JavaDoc)jjte000;}
2458    } finally {
2459    if (jjtc000) {
2460      jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
2461    }
2462    }
2463  }
2464
2465  final public void ConditionalOrExpression() throws ParseException {
2466 /*@bgen(jjtree) #ConditionalOrExpression(> 1) */
2467  ASTConditionalOrExpression jjtn000 = new ASTConditionalOrExpression(this, JJTCONDITIONALOREXPRESSION);
2468  boolean jjtc000 = true;
2469  jjtree.openNodeScope(jjtn000);
2470    try {
2471      ConditionalAndExpression();
2472      label_27:
2473      while (true) {
2474        switch (jj_nt.kind) {
2475        case SC_OR:
2476          ;
2477          break;
2478        default:
2479          jj_la1[65] = jj_gen;
2480          break label_27;
2481        }
2482        jj_consume_token(SC_OR);
2483        ConditionalAndExpression();
2484      }
2485    } catch (Throwable JavaDoc jjte000) {
2486    if (jjtc000) {
2487      jjtree.clearNodeScope(jjtn000);
2488      jjtc000 = false;
2489    } else {
2490      jjtree.popNode();
2491    }
2492    if (jjte000 instanceof RuntimeException JavaDoc) {
2493      {if (true) throw (RuntimeException JavaDoc)jjte000;}
2494    }
2495    if (jjte000 instanceof ParseException) {
2496      {if (true) throw (ParseException)jjte000;}
2497    }
2498    {if (true) throw (Error JavaDoc)jjte000;}
2499    } finally {
2500    if (jjtc000) {
2501      jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
2502    }
2503    }
2504  }
2505
2506  final public void ConditionalAndExpression() throws ParseException {
2507 /*@bgen(jjtree) #ConditionalAndExpression(> 1) */
2508  ASTConditionalAndExpression jjtn000 = new ASTConditionalAndExpression(this, JJTCONDITIONALANDEXPRESSION);
2509  boolean jjtc000 = true;
2510  jjtree.openNodeScope(jjtn000);
2511    try {
2512      InclusiveOrExpression();
2513      label_28:
2514      while (true) {
2515        switch (jj_nt.kind) {
2516        case SC_AND:
2517          ;
2518          break;
2519        default:
2520          jj_la1[66] = jj_gen;
2521          break label_28;
2522        }
2523        jj_consume_token(SC_AND);
2524        InclusiveOrExpression();
2525      }
2526    } catch (Throwable JavaDoc jjte000) {
2527    if (jjtc000) {
2528      jjtree.clearNodeScope(jjtn000);
2529      jjtc000 = false;
2530    } else {
2531      jjtree.popNode();
2532    }
2533    if (jjte000 instanceof RuntimeException JavaDoc) {
2534      {if (true) throw (RuntimeException JavaDoc)jjte000;}
2535    }
2536    if (jjte000 instanceof ParseException) {
2537      {if (true) throw (ParseException)jjte000;}
2538    }
2539    {if (true) throw (Error JavaDoc)jjte000;}
2540    } finally {
2541    if (jjtc000) {
2542      jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
2543    }
2544    }
2545  }
2546
2547  final public void InclusiveOrExpression() throws ParseException {
2548 /*@bgen(jjtree) #InclusiveOrExpression(> 1) */
2549  ASTInclusiveOrExpression jjtn000 = new ASTInclusiveOrExpression(this, JJTINCLUSIVEOREXPRESSION);
2550  boolean jjtc000 = true;
2551  jjtree.openNodeScope(jjtn000);
2552    try {
2553      ExclusiveOrExpression();
2554      label_29:
2555      while (true) {
2556        switch (jj_nt.kind) {
2557        case BIT_OR:
2558          ;
2559          break;
2560        default:
2561          jj_la1[67] = jj_gen;
2562          break label_29;
2563        }
2564        jj_consume_token(BIT_OR);
2565        ExclusiveOrExpression();
2566      }
2567    } catch (Throwable JavaDoc jjte000) {
2568    if (jjtc000) {
2569      jjtree.clearNodeScope(jjtn000);
2570      jjtc000 = false;
2571    } else {
2572      jjtree.popNode();
2573    }
2574    if (jjte000 instanceof RuntimeException JavaDoc) {
2575      {if (true) throw (RuntimeException JavaDoc)jjte000;}
2576    }
2577    if (jjte000 instanceof ParseException) {
2578      {if (true) throw (ParseException)jjte000;}
2579    }
2580    {if (true) throw (Error JavaDoc)jjte000;}
2581    } finally {
2582    if (jjtc000) {
2583      jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
2584    }
2585    }
2586  }
2587
2588  final public void ExclusiveOrExpression() throws ParseException {
2589 /*@bgen(jjtree) #ExclusiveOrExpression(> 1) */
2590  ASTExclusiveOrExpression jjtn000 = new ASTExclusiveOrExpression(this, JJTEXCLUSIVEOREXPRESSION);
2591  boolean jjtc000 = true;
2592  jjtree.openNodeScope(jjtn000);
2593    try {
2594      AndExpression();
2595      label_30:
2596      while (true) {
2597        switch (jj_nt.kind) {
2598        case XOR:
2599          ;
2600          break;
2601        default:
2602          jj_la1[68] = jj_gen;
2603          break label_30;
2604        }
2605        jj_consume_token(XOR);
2606        AndExpression();
2607      }
2608    } catch (Throwable JavaDoc jjte000) {
2609    if (jjtc000) {
2610      jjtree.clearNodeScope(jjtn000);
2611      jjtc000 = false;
2612    } else {
2613      jjtree.popNode();
2614    }
2615    if (jjte000 instanceof RuntimeException JavaDoc) {
2616      {if (true) throw (RuntimeException JavaDoc)jjte000;}
2617    }
2618    if (jjte000 instanceof ParseException) {
2619      {if (true) throw (ParseException)jjte000;}
2620    }
2621    {if (true) throw (Error JavaDoc)jjte000;}
2622    } finally {
2623    if (jjtc000) {
2624      jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
2625    }
2626    }
2627  }
2628
2629  final public void AndExpression() throws ParseException {
2630 /*@bgen(jjtree) #AndExpression(> 1) */
2631  ASTAndExpression jjtn000 = new ASTAndExpression(this, JJTANDEXPRESSION);
2632  boolean jjtc000 = true;
2633  jjtree.openNodeScope(jjtn000);
2634    try {
2635      EqualityExpression();
2636      label_31:
2637      while (true) {
2638        switch (jj_nt.kind) {
2639        case BIT_AND:
2640          ;
2641          break;
2642        default:
2643          jj_la1[69] = jj_gen;
2644          break label_31;
2645        }
2646        jj_consume_token(BIT_AND);
2647        EqualityExpression();
2648      }
2649    } catch (Throwable JavaDoc jjte000) {
2650    if (jjtc000) {
2651      jjtree.clearNodeScope(jjtn000);
2652      jjtc000 = false;
2653    } else {
2654      jjtree.popNode();
2655    }
2656    if (jjte000 instanceof RuntimeException JavaDoc) {
2657      {if (true) throw (RuntimeException JavaDoc)jjte000;}
2658    }
2659    if (jjte000 instanceof ParseException) {
2660      {if (true) throw (ParseException)jjte000;}
2661    }
2662    {if (true) throw (Error JavaDoc)jjte000;}
2663    } finally {
2664    if (jjtc000) {
2665      jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
2666    }
2667    }
2668  }
2669
2670  final public void EqualityExpression() throws ParseException {
2671 /*@bgen(jjtree) #EqualityExpression(> 1) */
2672  ASTEqualityExpression jjtn000 = new ASTEqualityExpression(this, JJTEQUALITYEXPRESSION);
2673  boolean jjtc000 = true;
2674  jjtree.openNodeScope(jjtn000);
2675    try {
2676      InstanceOfExpression();
2677      label_32:
2678      while (true) {
2679        switch (jj_nt.kind) {
2680        case EQ:
2681        case NE:
2682          ;
2683          break;
2684        default:
2685          jj_la1[70] = jj_gen;
2686          break label_32;
2687        }
2688        switch (jj_nt.kind) {
2689        case EQ:
2690          jj_consume_token(EQ);
2691                                    jjtn000.setImage("==");
2692          break;
2693        case NE:
2694          jj_consume_token(NE);
2695                                                                     jjtn000.setImage("!=");
2696          break;
2697        default:
2698          jj_la1[71] = jj_gen;
2699          jj_consume_token(-1);
2700          throw new ParseException();
2701        }
2702        InstanceOfExpression();
2703      }
2704    } catch (Throwable JavaDoc jjte000) {
2705    if (jjtc000) {
2706      jjtree.clearNodeScope(jjtn000);
2707      jjtc000 = false;
2708    } else {
2709      jjtree.popNode();
2710    }
2711    if (jjte000 instanceof RuntimeException JavaDoc) {
2712      {if (true) throw (RuntimeException JavaDoc)jjte000;}
2713    }
2714    if (jjte000 instanceof ParseException) {
2715      {if (true) throw (ParseException)jjte000;}
2716    }
2717    {if (true) throw (Error JavaDoc)jjte000;}
2718    } finally {
2719    if (jjtc000) {
2720      jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
2721    }
2722    }
2723  }
2724
2725  final public void InstanceOfExpression() throws ParseException {
2726 /*@bgen(jjtree) #InstanceOfExpression(> 1) */
2727  ASTInstanceOfExpression jjtn000 = new ASTInstanceOfExpression(this, JJTINSTANCEOFEXPRESSION);
2728  boolean jjtc000 = true;
2729  jjtree.openNodeScope(jjtn000);
2730    try {
2731      RelationalExpression();
2732      switch (jj_nt.kind) {
2733      case INSTANCEOF:
2734        jj_consume_token(INSTANCEOF);
2735        Type();
2736        break;
2737      default:
2738        jj_la1[72] = jj_gen;
2739        ;
2740      }
2741    } catch (Throwable JavaDoc jjte000) {
2742    if (jjtc000) {
2743      jjtree.clearNodeScope(jjtn000);
2744      jjtc000 = false;
2745    } else {
2746      jjtree.popNode();
2747    }
2748    if (jjte000 instanceof RuntimeException JavaDoc) {
2749      {if (true) throw (RuntimeException JavaDoc)jjte000;}
2750    }
2751    if (jjte000 instanceof ParseException) {
2752      {if (true) throw (ParseException)jjte000;}
2753    }
2754    {if (true) throw (Error JavaDoc)jjte000;}
2755    } finally {
2756    if (jjtc000) {
2757      jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
2758    }
2759    }
2760  }
2761
2762  final public void RelationalExpression() throws ParseException {
2763 /*@bgen(jjtree) #RelationalExpression(> 1) */
2764  ASTRelationalExpression jjtn000 = new ASTRelationalExpression(this, JJTRELATIONALEXPRESSION);
2765  boolean jjtc000 = true;
2766  jjtree.openNodeScope(jjtn000);
2767    try {
2768      ShiftExpression();
2769      label_33:
2770      while (true) {
2771        switch (jj_nt.kind) {
2772        case LT:
2773        case LE:
2774        case GE:
2775        case GT:
2776          ;
2777          break;
2778        default:
2779          jj_la1[73] = jj_gen;
2780          break label_33;
2781        }
2782        switch (jj_nt.kind) {
2783        case LT:
2784          jj_consume_token(LT);
2785           jjtn000.setImage("<");
2786          break;
2787        case GT:
2788          jj_consume_token(GT);
2789            jjtn000.setImage(">");
2790          break;
2791        case LE:
2792          jj_consume_token(LE);
2793             jjtn000.setImage("<=");
2794          break;
2795        case GE:
2796          jj_consume_token(GE);
2797             jjtn000.setImage(">=");
2798          break;
2799        default:
2800          jj_la1[74] = jj_gen;
2801          jj_consume_token(-1);
2802          throw new ParseException();
2803        }
2804        ShiftExpression();
2805      }
2806    } catch (Throwable JavaDoc jjte000) {
2807    if (jjtc000) {
2808      jjtree.clearNodeScope(jjtn000);
2809      jjtc000 = false;
2810    } else {
2811      jjtree.popNode();
2812    }
2813    if (jjte000 instanceof RuntimeException JavaDoc) {
2814      {if (true) throw (RuntimeException JavaDoc)jjte000;}
2815    }
2816    if (jjte000 instanceof ParseException) {
2817      {if (true) throw (ParseException)jjte000;}
2818    }
2819    {if (true) throw (Error JavaDoc)jjte000;}
2820    } finally {
2821    if (jjtc000) {
2822      jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
2823    }
2824    }
2825  }
2826
2827  final public void ShiftExpression() throws ParseException {
2828 /*@bgen(jjtree) #ShiftExpression(> 1) */
2829  ASTShiftExpression jjtn000 = new ASTShiftExpression(this, JJTSHIFTEXPRESSION);
2830  boolean jjtc000 = true;
2831  jjtree.openNodeScope(jjtn000);
2832    try {
2833      AdditiveExpression();
2834      label_34:
2835      while (true) {
2836        if (jj_2_21(1)) {
2837          ;
2838        } else {
2839          break label_34;
2840        }
2841        switch (jj_nt.kind) {
2842        case LSHIFT:
2843          jj_consume_token(LSHIFT);
2844             jjtn000.setImage("<<");
2845          break;
2846        default:
2847          jj_la1[75] = jj_gen;
2848          if (jj_2_22(1)) {
2849            RSIGNEDSHIFT();
2850          } else if (jj_2_23(1)) {
2851            RUNSIGNEDSHIFT();
2852          } else {
2853            jj_consume_token(-1);
2854            throw new ParseException();
2855          }
2856        }
2857        AdditiveExpression();
2858      }
2859    } catch (Throwable JavaDoc jjte000) {
2860    if (jjtc000) {
2861      jjtree.clearNodeScope(jjtn000);
2862      jjtc000 = false;
2863    } else {
2864      jjtree.popNode();
2865    }
2866    if (jjte000 instanceof RuntimeException JavaDoc) {
2867      {if (true) throw (RuntimeException JavaDoc)jjte000;}
2868    }
2869    if (jjte000 instanceof ParseException) {
2870      {if (true) throw (ParseException)jjte000;}
2871    }
2872    {if (true) throw (Error JavaDoc)jjte000;}
2873    } finally {
2874    if (jjtc000) {
2875      jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
2876    }
2877    }
2878  }
2879
2880  final public void AdditiveExpression() throws ParseException {
2881 /*@bgen(jjtree) #AdditiveExpression(> 1) */
2882  ASTAdditiveExpression jjtn000 = new ASTAdditiveExpression(this, JJTADDITIVEEXPRESSION);
2883  boolean jjtc000 = true;
2884  jjtree.openNodeScope(jjtn000);
2885    try {
2886      MultiplicativeExpression();
2887      label_35:
2888      while (true) {
2889        switch (jj_nt.kind) {
2890        case PLUS:
2891        case MINUS:
2892          ;
2893          break;
2894        default:
2895          jj_la1[76] = jj_gen;
2896          break label_35;
2897        }
2898        switch (jj_nt.kind) {
2899        case PLUS:
2900          jj_consume_token(PLUS);
2901                                      jjtn000.setImage("+");
2902          break;
2903        case MINUS:
2904          jj_consume_token(MINUS);
2905                                                                     jjtn000.setImage("-");
2906          break;
2907        default:
2908          jj_la1[77] = jj_gen;
2909          jj_consume_token(-1);
2910          throw new ParseException();
2911        }
2912        MultiplicativeExpression();
2913      }
2914    } catch (Throwable JavaDoc jjte000) {
2915    if (jjtc000) {
2916      jjtree.clearNodeScope(jjtn000);
2917      jjtc000 = false;
2918    } else {
2919      jjtree.popNode();
2920    }
2921    if (jjte000 instanceof RuntimeException JavaDoc) {
2922      {if (true) throw (RuntimeException JavaDoc)jjte000;}
2923    }
2924    if (jjte000 instanceof ParseException) {
2925      {if (true) throw (ParseException)jjte000;}
2926    }
2927    {if (true) throw (Error JavaDoc)jjte000;}
2928    } finally {
2929    if (jjtc000) {
2930      jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
2931    }
2932    }
2933  }
2934
2935  final public void MultiplicativeExpression() throws ParseException {
2936 /*@bgen(jjtree) #MultiplicativeExpression(> 1) */
2937  ASTMultiplicativeExpression jjtn000 = new ASTMultiplicativeExpression(this, JJTMULTIPLICATIVEEXPRESSION);
2938  boolean jjtc000 = true;
2939  jjtree.openNodeScope(jjtn000);
2940    try {
2941      UnaryExpression();
2942      label_36:
2943      while (true) {
2944        switch (jj_nt.kind) {
2945        case STAR:
2946        case SLASH:
2947        case REM:
2948          ;
2949          break;
2950        default:
2951          jj_la1[78] = jj_gen;
2952          break label_36;
2953        }
2954        switch (jj_nt.kind) {
2955        case STAR:
2956          jj_consume_token(STAR);
2957                             jjtn000.setImage("*");
2958          break;
2959        case SLASH:
2960          jj_consume_token(SLASH);
2961                                                            jjtn000.setImage("/");
2962          break;
2963        case REM:
2964          jj_consume_token(REM);
2965                                                                                           jjtn000.setImage("%");
2966          break;
2967        default:
2968          jj_la1[79] = jj_gen;
2969          jj_consume_token(-1);
2970          throw new ParseException();
2971        }
2972        UnaryExpression();
2973      }
2974    } catch (Throwable JavaDoc jjte000) {
2975    if (jjtc000) {
2976      jjtree.clearNodeScope(jjtn000);
2977      jjtc000 = false;
2978    } else {
2979      jjtree.popNode();
2980    }
2981    if (jjte000 instanceof RuntimeException JavaDoc) {
2982      {if (true) throw (RuntimeException JavaDoc)jjte000;}
2983    }
2984    if (jjte000 instanceof ParseException) {
2985      {if (true) throw (ParseException)jjte000;}
2986    }
2987    {if (true) throw (Error JavaDoc)jjte000;}
2988    } finally {
2989    if (jjtc000) {
2990      jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
2991    }
2992    }
2993  }
2994
2995  final public void UnaryExpression() throws ParseException {
2996 /*@bgen(jjtree) #UnaryExpression( ( jjtn000 . getImage ( ) != null )) */
2997  ASTUnaryExpression jjtn000 = new ASTUnaryExpression(this, JJTUNARYEXPRESSION);
2998  boolean jjtc000 = true;
2999  jjtree.openNodeScope(jjtn000);
3000    try {
3001      switch (jj_nt.kind) {
3002      case PLUS:
3003      case MINUS:
3004        switch (jj_nt.kind) {
3005        case PLUS:
3006          jj_consume_token(PLUS);
3007        jjtn000.setImage("+");
3008          break;
3009        case MINUS:
3010          jj_consume_token(MINUS);
3011                                       jjtn000.setImage("-");
3012          break;
3013        default:
3014          jj_la1[80] = jj_gen;
3015          jj_consume_token(-1);
3016          throw new ParseException();
3017        }
3018        UnaryExpression();
3019        break;
3020      case INCR:
3021        PreIncrementExpression();
3022        break;
3023      case DECR:
3024        PreDecrementExpression();
3025        break;
3026      case BOOLEAN:
3027      case BYTE:
3028      case CHAR:
3029      case DOUBLE:
3030      case FALSE:
3031      case FLOAT:
3032      case INT:
3033      case LONG:
3034      case NEW:
3035      case NULL:
3036      case SHORT:
3037      case SUPER:
3038      case THIS:
3039      case TRUE:
3040      case VOID:
3041      case INTEGER_LITERAL:
3042      case FLOATING_POINT_LITERAL:
3043      case HEX_FLOATING_POINT_LITERAL:
3044      case CHARACTER_LITERAL:
3045      case STRING_LITERAL:
3046      case IDENTIFIER:
3047      case LPAREN:
3048      case BANG:
3049      case TILDE:
3050        UnaryExpressionNotPlusMinus();
3051        break;
3052      default:
3053        jj_la1[81] = jj_gen;
3054        jj_consume_token(-1);
3055        throw new ParseException();
3056      }
3057    } catch (Throwable JavaDoc jjte000) {
3058    if (jjtc000) {
3059      jjtree.clearNodeScope(jjtn000);
3060      jjtc000 = false;
3061    } else {
3062      jjtree.popNode();
3063    }
3064    if (jjte000 instanceof RuntimeException JavaDoc) {
3065      {if (true) throw (RuntimeException JavaDoc)jjte000;}
3066    }
3067    if (jjte000 instanceof ParseException) {
3068      {if (true) throw (ParseException)jjte000;}
3069    }
3070    {if (true) throw (Error JavaDoc)jjte000;}
3071    } finally {
3072    if (jjtc000) {
3073      jjtree.closeNodeScope(jjtn000, ( jjtn000 . getImage ( ) != null ));
3074    }
3075    }
3076  }
3077
3078  final public void PreIncrementExpression() throws ParseException {
3079 /*@bgen(jjtree) PreIncrementExpression */
3080  ASTPreIncrementExpression jjtn000 = new ASTPreIncrementExpression(this, JJTPREINCREMENTEXPRESSION);
3081  boolean jjtc000 = true;
3082  jjtree.openNodeScope(jjtn000);
3083    try {
3084      jj_consume_token(INCR);
3085      PrimaryExpression();
3086    } catch (Throwable JavaDoc jjte000) {
3087    if (jjtc000) {
3088      jjtree.clearNodeScope(jjtn000);
3089      jjtc000 = false;
3090    } else {
3091      jjtree.popNode();
3092    }
3093    if (jjte000 instanceof RuntimeException JavaDoc) {
3094      {if (true) throw (RuntimeException JavaDoc)jjte000;}
3095    }
3096    if (jjte000 instanceof ParseException) {
3097      {if (true) throw (ParseException)jjte000;}
3098    }
3099    {if (true) throw (Error JavaDoc)jjte000;}
3100    } finally {
3101    if (jjtc000) {
3102      jjtree.closeNodeScope(jjtn000, true);
3103    }
3104    }
3105  }
3106
3107  final public void PreDecrementExpression() throws ParseException {
3108 /*@bgen(jjtree) PreDecrementExpression */
3109  ASTPreDecrementExpression jjtn000 = new ASTPreDecrementExpression(this, JJTPREDECREMENTEXPRESSION);
3110  boolean jjtc000 = true;
3111  jjtree.openNodeScope(jjtn000);
3112    try {
3113      jj_consume_token(DECR);
3114      PrimaryExpression();
3115    } catch (Throwable JavaDoc jjte000) {
3116    if (jjtc000) {
3117      jjtree.clearNodeScope(jjtn000);
3118      jjtc000 = false;
3119    } else {
3120      jjtree.popNode();
3121    }
3122    if (jjte000 instanceof RuntimeException JavaDoc) {
3123      {if (true) throw (RuntimeException JavaDoc)jjte000;}
3124    }
3125    if (jjte000 instanceof ParseException) {
3126      {if (true) throw (ParseException)jjte000;}
3127    }
3128    {if (true) throw (Error JavaDoc)jjte000;}
3129    } finally {
3130    if (jjtc000) {
3131      jjtree.closeNodeScope(jjtn000, true);
3132    }
3133    }
3134  }
3135
3136  final public void UnaryExpressionNotPlusMinus() throws ParseException {
3137 /*@bgen(jjtree) #UnaryExpressionNotPlusMinus( ( jjtn000 . getImage ( ) != null )) */
3138  ASTUnaryExpressionNotPlusMinus jjtn000 = new ASTUnaryExpressionNotPlusMinus(this, JJTUNARYEXPRESSIONNOTPLUSMINUS);
3139  boolean jjtc000 = true;
3140  jjtree.openNodeScope(jjtn000);
3141    try {
3142      switch (jj_nt.kind) {
3143      case BANG:
3144      case TILDE:
3145        switch (jj_nt.kind) {
3146        case TILDE:
3147          jj_consume_token(TILDE);
3148        jjtn000.setImage("~");
3149          break;
3150        case BANG:
3151          jj_consume_token(BANG);
3152                                       jjtn000.setImage("!");
3153          break;
3154        default:
3155          jj_la1[82] = jj_gen;
3156          jj_consume_token(-1);
3157          throw new ParseException();
3158        }
3159        UnaryExpression();
3160        break;
3161      default:
3162        jj_la1[83] = jj_gen;
3163        if (jj_2_24(2147483647)) {
3164          CastExpression();
3165        } else {
3166          switch (jj_nt.kind) {
3167          case BOOLEAN:
3168          case BYTE:
3169          case CHAR:
3170          case DOUBLE:
3171          case FALSE:
3172          case FLOAT:
3173          case INT:
3174          case LONG:
3175          case NEW:
3176          case NULL:
3177          case SHORT:
3178          case SUPER:
3179          case THIS:
3180          case TRUE:
3181          case VOID:
3182          case INTEGER_LITERAL:
3183          case FLOATING_POINT_LITERAL:
3184          case HEX_FLOATING_POINT_LITERAL:
3185          case CHARACTER_LITERAL:
3186          case STRING_LITERAL:
3187          case IDENTIFIER:
3188          case LPAREN:
3189            PostfixExpression();
3190            break;
3191          default:
3192            jj_la1[84] = jj_gen;
3193            jj_consume_token(-1);
3194            throw new ParseException();
3195          }
3196        }
3197      }
3198    } catch (Throwable JavaDoc jjte000) {
3199   if (jjtc000) {
3200     jjtree.clearNodeScope(jjtn000);
3201     jjtc000 = false;
3202   } else {
3203     jjtree.popNode();
3204   }
3205   if (jjte000 instanceof RuntimeException JavaDoc) {
3206     {if (true) throw (RuntimeException JavaDoc)jjte000;}
3207   }
3208   if (jjte000 instanceof ParseException) {
3209     {if (true) throw (ParseException)jjte000;}
3210   }
3211   {if (true) throw (Error JavaDoc)jjte000;}
3212    } finally {
3213   if (jjtc000) {
3214     jjtree.closeNodeScope(jjtn000, ( jjtn000 . getImage ( ) != null ));
3215   }
3216    }
3217  }
3218
3219// This production is to determine lookahead only. The LOOKAHEAD specifications
3220
// below are not used, but they are there just to indicate that we know about
3221
// this.
3222
final public void CastLookahead() throws ParseException {
3223    if (jj_2_25(2)) {
3224      jj_consume_token(LPAREN);
3225      PrimitiveType();
3226    } else if (jj_2_26(2147483647)) {
3227      jj_consume_token(LPAREN);
3228      Type();
3229      jj_consume_token(LBRACKET);
3230      jj_consume_token(RBRACKET);
3231    } else {
3232      switch (jj_nt.kind) {
3233      case LPAREN:
3234        jj_consume_token(LPAREN);
3235        Type();
3236        jj_consume_token(RPAREN);
3237        switch (jj_nt.kind) {
3238        case TILDE:
3239          jj_consume_token(TILDE);
3240          break;
3241        case BANG:
3242          jj_consume_token(BANG);
3243          break;
3244        case LPAREN:
3245          jj_consume_token(LPAREN);
3246          break;
3247        case IDENTIFIER:
3248          jj_consume_token(IDENTIFIER);
3249          break;
3250        case THIS:
3251          jj_consume_token(THIS);
3252          break;
3253        case SUPER:
3254          jj_consume_token(SUPER);
3255          break;
3256        case NEW:
3257          jj_consume_token(NEW);
3258          break;
3259        case FALSE:
3260        case NULL:
3261        case TRUE:
3262        case INTEGER_LITERAL:
3263        case FLOATING_POINT_LITERAL:
3264        case HEX_FLOATING_POINT_LITERAL:
3265        case CHARACTER_LITERAL:
3266        case STRING_LITERAL:
3267          Literal();
3268          break;
3269        default:
3270          jj_la1[85] = jj_gen;
3271          jj_consume_token(-1);
3272          throw new ParseException();
3273        }
3274        break;
3275      default:
3276        jj_la1[86] = jj_gen;
3277        jj_consume_token(-1);
3278        throw new ParseException();
3279      }
3280    }
3281  }
3282
3283  final public void PostfixExpression() throws ParseException {
3284 /*@bgen(jjtree) #PostfixExpression( ( jjtn000 . getImage ( ) != null )) */
3285  ASTPostfixExpression jjtn000 = new ASTPostfixExpression(this, JJTPOSTFIXEXPRESSION);
3286  boolean jjtc000 = true;
3287  jjtree.openNodeScope(jjtn000);
3288    try {
3289      PrimaryExpression();
3290      switch (jj_nt.kind) {
3291      case INCR:
3292      case DECR:
3293        switch (jj_nt.kind) {
3294        case INCR:
3295          jj_consume_token(INCR);
3296                              jjtn000.setImage("++");
3297          break;
3298        case DECR:
3299          jj_consume_token(DECR);
3300                                                               jjtn000.setImage("--");
3301          break;
3302        default:
3303          jj_la1[87] = jj_gen;
3304          jj_consume_token(-1);
3305          throw new ParseException();
3306        }
3307        break;
3308      default:
3309        jj_la1[88] = jj_gen;
3310        ;
3311      }
3312    } catch (Throwable JavaDoc jjte000) {
3313    if (jjtc000) {
3314      jjtree.clearNodeScope(jjtn000);
3315      jjtc000 = false;
3316    } else {
3317      jjtree.popNode();
3318    }
3319    if (jjte000 instanceof RuntimeException JavaDoc) {
3320      {if (true) throw (RuntimeException JavaDoc)jjte000;}
3321    }
3322    if (jjte000 instanceof ParseException) {
3323      {if (true) throw (ParseException)jjte000;}
3324    }
3325    {if (true) throw (Error JavaDoc)jjte000;}
3326    } finally {
3327    if (jjtc000) {
3328      jjtree.closeNodeScope(jjtn000, ( jjtn000 . getImage ( ) != null ));
3329    }
3330    }
3331  }
3332
3333  final public void CastExpression() throws ParseException {
3334 /*@bgen(jjtree) #CastExpression(> 1) */
3335  ASTCastExpression jjtn000 = new ASTCastExpression(this, JJTCASTEXPRESSION);
3336  boolean jjtc000 = true;
3337  jjtree.openNodeScope(jjtn000);
3338    try {
3339      if (jj_2_27(2147483647)) {
3340        jj_consume_token(LPAREN);
3341        Type();
3342        jj_consume_token(RPAREN);
3343        UnaryExpression();
3344      } else {
3345        switch (jj_nt.kind) {
3346        case LPAREN:
3347          jj_consume_token(LPAREN);
3348          Type();
3349          jj_consume_token(RPAREN);
3350          UnaryExpressionNotPlusMinus();
3351          break;
3352        default:
3353          jj_la1[89] = jj_gen;
3354          jj_consume_token(-1);
3355          throw new ParseException();
3356        }
3357      }
3358    } catch (Throwable JavaDoc jjte000) {
3359    if (jjtc000) {
3360      jjtree.clearNodeScope(jjtn000);
3361      jjtc000 = false;
3362    } else {
3363      jjtree.popNode();
3364    }
3365    if (jjte000 instanceof RuntimeException JavaDoc) {
3366      {if (true) throw (RuntimeException JavaDoc)jjte000;}
3367    }
3368    if (jjte000 instanceof ParseException) {
3369      {if (true) throw (ParseException)jjte000;}
3370    }
3371    {if (true) throw (Error JavaDoc)jjte000;}
3372    } finally {
3373    if (jjtc000) {
3374      jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
3375    }
3376    }
3377  }
3378
3379  final public void PrimaryExpression() throws ParseException {
3380 /*@bgen(jjtree) PrimaryExpression */
3381  ASTPrimaryExpression jjtn000 = new ASTPrimaryExpression(this, JJTPRIMARYEXPRESSION);
3382  boolean jjtc000 = true;
3383  jjtree.openNodeScope(jjtn000);
3384    try {
3385      PrimaryPrefix();
3386      label_37:
3387      while (true) {
3388        if (jj_2_28(2)) {
3389          ;
3390        } else {
3391          break label_37;
3392        }
3393        PrimarySuffix();
3394      }
3395    } catch (Throwable JavaDoc jjte000) {
3396    if (jjtc000) {
3397      jjtree.clearNodeScope(jjtn000);
3398      jjtc000 = false;
3399    } else {
3400      jjtree.popNode();
3401    }
3402    if (jjte000 instanceof RuntimeException JavaDoc) {
3403      {if (true) throw (RuntimeException JavaDoc)jjte000;}
3404    }
3405    if (jjte000 instanceof ParseException) {
3406      {if (true) throw (ParseException)jjte000;}
3407    }
3408    {if (true) throw (Error JavaDoc)jjte000;}
3409    } finally {
3410    if (jjtc000) {
3411      jjtree.closeNodeScope(jjtn000, true);
3412    }
3413    }
3414  }
3415
3416  final public void MemberSelector() throws ParseException {
3417 /*@bgen(jjtree) MemberSelector */
3418ASTMemberSelector jjtn000 = new ASTMemberSelector(this, JJTMEMBERSELECTOR);
3419boolean jjtc000 = true;
3420jjtree.openNodeScope(jjtn000);Token t;
3421    try {
3422      jj_consume_token(DOT);
3423      TypeArguments();
3424      t = jj_consume_token(IDENTIFIER);
3425                                       jjtree.closeNodeScope(jjtn000, true);
3426                                       jjtc000 = false;
3427                                      jjtn000.setImage(t.image);
3428    } catch (Throwable JavaDoc jjte000) {
3429    if (jjtc000) {
3430      jjtree.clearNodeScope(jjtn000);
3431      jjtc000 = false;
3432    } else {
3433      jjtree.popNode();
3434    }
3435    if (jjte000 instanceof RuntimeException JavaDoc) {
3436      {if (true) throw (RuntimeException JavaDoc)jjte000;}
3437    }
3438    if (jjte000 instanceof ParseException) {
3439      {if (true) throw (ParseException)jjte000;}
3440    }
3441    {if (true) throw (Error JavaDoc)jjte000;}
3442    } finally {
3443    if (jjtc000) {
3444      jjtree.closeNodeScope(jjtn000, true);
3445    }
3446    }
3447  }
3448
3449  final public void PrimaryPrefix() throws ParseException {
3450 /*@bgen(jjtree) PrimaryPrefix */
3451 ASTPrimaryPrefix jjtn000 = new ASTPrimaryPrefix(this, JJTPRIMARYPREFIX);
3452 boolean jjtc000 = true;
3453 jjtree.openNodeScope(jjtn000);Token t;
3454    try {
3455      switch (jj_nt.kind) {
3456      case FALSE:
3457      case NULL:
3458      case TRUE:
3459      case INTEGER_LITERAL:
3460      case FLOATING_POINT_LITERAL:
3461      case HEX_FLOATING_POINT_LITERAL:
3462      case CHARACTER_LITERAL:
3463      case STRING_LITERAL:
3464        Literal();
3465        break;
3466      case THIS:
3467        jj_consume_token(THIS);
3468           jjtree.closeNodeScope(jjtn000, true);
3469           jjtc000 = false;
3470          jjtn000.setUsesThisModifier();
3471        break;
3472      case SUPER:
3473        jj_consume_token(SUPER);
3474           jjtn000.setUsesSuperModifier();
3475        jj_consume_token(DOT);
3476        t = jj_consume_token(IDENTIFIER);
3477                                                                 jjtree.closeNodeScope(jjtn000, true);
3478                                                                 jjtc000 = false;
3479                                                                jjtn000.setImage(t.image);
3480        break;
3481      case LPAREN:
3482        jj_consume_token(LPAREN);
3483        Expression();
3484        jj_consume_token(RPAREN);
3485        break;
3486      case NEW:
3487        AllocationExpression();
3488        break;
3489      default:
3490        jj_la1[90] = jj_gen;
3491        if (jj_2_29(2147483647)) {
3492          ResultType();
3493          jj_consume_token(DOT);
3494          jj_consume_token(CLASS);
3495        } else {
3496          switch (jj_nt.kind) {
3497          case IDENTIFIER:
3498            Name();
3499            break;
3500          default:
3501            jj_la1[91] = jj_gen;
3502            jj_consume_token(-1);
3503            throw new ParseException();
3504          }
3505        }
3506      }
3507    } catch (Throwable JavaDoc jjte000) {
3508    if (jjtc000) {
3509      jjtree.clearNodeScope(jjtn000);
3510      jjtc000 = false;
3511    } else {
3512      jjtree.popNode();
3513    }
3514    if (jjte000 instanceof RuntimeException JavaDoc) {
3515      {if (true) throw (RuntimeException JavaDoc)jjte000;}
3516    }
3517    if (jjte000 instanceof ParseException) {
3518      {if (true) throw (ParseException)jjte000;}
3519    }
3520    {if (true) throw (Error JavaDoc)jjte000;}
3521    } finally {
3522    if (jjtc000) {
3523      jjtree.closeNodeScope(jjtn000, true);
3524    }
3525    }
3526  }
3527
3528  final public void PrimarySuffix() throws ParseException {
3529 /*@bgen(jjtree) PrimarySuffix */
3530 ASTPrimarySuffix jjtn000 = new ASTPrimarySuffix(this, JJTPRIMARYSUFFIX);
3531 boolean jjtc000 = true;
3532 jjtree.openNodeScope(jjtn000);Token t;
3533    try {
3534      if (jj_2_30(2)) {
3535        jj_consume_token(DOT);
3536        jj_consume_token(THIS);
3537      } else if (jj_2_31(2)) {
3538        jj_consume_token(DOT);
3539        jj_consume_token(SUPER);
3540      } else if (jj_2_32(2)) {
3541        jj_consume_token(DOT);
3542        AllocationExpression();
3543      } else if (jj_2_33(3)) {
3544        MemberSelector();
3545      } else {
3546        switch (jj_nt.kind) {
3547        case LBRACKET:
3548          jj_consume_token(LBRACKET);
3549          Expression();
3550          jj_consume_token(RBRACKET);
3551                         jjtree.closeNodeScope(jjtn000, true);
3552                         jjtc000 = false;
3553                        jjtn000.setIsArrayDereference();
3554          break;
3555        case DOT:
3556          jj_consume_token(DOT);
3557          t = jj_consume_token(IDENTIFIER);
3558                       jjtree.closeNodeScope(jjtn000, true);
3559                       jjtc000 = false;
3560                      jjtn000.setImage(t.image);
3561          break;
3562        case LPAREN:
3563          Arguments();
3564                jjtree.closeNodeScope(jjtn000, true);
3565                jjtc000 = false;
3566               jjtn000.setIsArguments();
3567          break;
3568        default:
3569          jj_la1[92] = jj_gen;
3570          jj_consume_token(-1);
3571          throw new ParseException();
3572        }
3573      }
3574    } catch (Throwable JavaDoc jjte000) {
3575    if (jjtc000) {
3576      jjtree.clearNodeScope(jjtn000);
3577      jjtc000 = false;
3578    } else {
3579      jjtree.popNode();
3580    }
3581    if (jjte000 instanceof RuntimeException JavaDoc) {
3582      {if (true) throw (RuntimeException JavaDoc)jjte000;}
3583    }
3584    if (jjte000 instanceof ParseException) {
3585      {if (true) throw (ParseException)jjte000;}
3586    }
3587    {if (true) throw (Error JavaDoc)jjte000;}
3588    } finally {
3589    if (jjtc000) {
3590      jjtree.closeNodeScope(jjtn000, true);
3591    }
3592    }
3593  }
3594
3595  final public void Literal() throws ParseException {
3596 /*@bgen(jjtree) Literal */
3597  ASTLiteral jjtn000 = new ASTLiteral(this, JJTLITERAL);
3598  boolean jjtc000 = true;
3599  jjtree.openNodeScope(jjtn000);
3600    try {
3601      switch (jj_nt.kind) {
3602      case INTEGER_LITERAL:
3603  Token t;
3604        t = jj_consume_token(INTEGER_LITERAL);
3605                        jjtree.closeNodeScope(jjtn000, true);
3606                        jjtc000 = false;
3607                       jjtn000.setImage(t.image);
3608        break;
3609      case FLOATING_POINT_LITERAL:
3610        t = jj_consume_token(FLOATING_POINT_LITERAL);
3611                               jjtree.closeNodeScope(jjtn000, true);
3612                               jjtc000 = false;
3613                              jjtn000.setImage(t.image);
3614        break;
3615      case HEX_FLOATING_POINT_LITERAL:
3616        t = jj_consume_token(HEX_FLOATING_POINT_LITERAL);
3617                                   jjtree.closeNodeScope(jjtn000, true);
3618                                   jjtc000 = false;
3619                                   checkForBadHexFloatingPointLiteral(); jjtn000.setImage(t.image);
3620        break;
3621      case CHARACTER_LITERAL:
3622        t = jj_consume_token(CHARACTER_LITERAL);
3623                          jjtree.closeNodeScope(jjtn000, true);
3624                          jjtc000 = false;
3625                         jjtn000.setImage(t.image);
3626        break;
3627      case STRING_LITERAL:
3628        t = jj_consume_token(STRING_LITERAL);
3629                       jjtree.closeNodeScope(jjtn000, true);
3630                       jjtc000 = false;
3631                      jjtn000.setImage(t.image);
3632        break;
3633      case FALSE:
3634      case TRUE:
3635        BooleanLiteral();
3636        break;
3637      case NULL:
3638        NullLiteral();
3639        break;
3640      default:
3641        jj_la1[93] = jj_gen;
3642        jj_consume_token(-1);
3643        throw new ParseException();
3644      }
3645    } catch (Throwable JavaDoc jjte000) {
3646  if (jjtc000) {
3647    jjtree.clearNodeScope(jjtn000);
3648    jjtc000 = false;
3649  } else {
3650    jjtree.popNode();
3651  }
3652  if (jjte000 instanceof RuntimeException JavaDoc) {
3653    {if (true) throw (RuntimeException JavaDoc)jjte000;}
3654  }
3655  if (jjte000 instanceof ParseException) {
3656    {if (true) throw (ParseException)jjte000;}
3657  }
3658  {if (true) throw (Error JavaDoc)jjte000;}
3659    } finally {
3660  if (jjtc000) {
3661    jjtree.closeNodeScope(jjtn000, true);
3662  }
3663    }
3664  }
3665
3666  final public void BooleanLiteral() throws ParseException {
3667 /*@bgen(jjtree) BooleanLiteral */
3668  ASTBooleanLiteral jjtn000 = new ASTBooleanLiteral(this, JJTBOOLEANLITERAL);
3669  boolean jjtc000 = true;
3670  jjtree.openNodeScope(jjtn000);
3671    try {
3672      switch (jj_nt.kind) {
3673      case TRUE:
3674        jj_consume_token(TRUE);
3675           jjtree.closeNodeScope(jjtn000, true);
3676           jjtc000 = false;
3677           jjtn000.setTrue();
3678        break;
3679      case FALSE:
3680        jj_consume_token(FALSE);
3681        break;
3682      default:
3683        jj_la1[94] = jj_gen;
3684        jj_consume_token(-1);
3685        throw new ParseException();
3686      }
3687    } finally {
3688    if (jjtc000) {
3689      jjtree.closeNodeScope(jjtn000, true);
3690    }
3691    }
3692  }
3693
3694  final public void NullLiteral() throws ParseException {
3695 /*@bgen(jjtree) NullLiteral */
3696  ASTNullLiteral jjtn000 = new ASTNullLiteral(this, JJTNULLLITERAL);
3697  boolean jjtc000 = true;
3698  jjtree.openNodeScope(jjtn000);
3699    try {
3700      jj_consume_token(NULL);
3701    } finally {
3702    if (jjtc000) {
3703      jjtree.closeNodeScope(jjtn000, true);
3704    }
3705    }
3706  }
3707
3708  final public void Arguments() throws ParseException {
3709 /*@bgen(jjtree) Arguments */
3710  ASTArguments jjtn000 = new ASTArguments(this, JJTARGUMENTS);
3711  boolean jjtc000 = true;
3712  jjtree.openNodeScope(jjtn000);
3713    try {
3714      jj_consume_token(LPAREN);
3715      switch (jj_nt.kind) {
3716      case BOOLEAN:
3717      case BYTE:
3718      case CHAR:
3719      case DOUBLE:
3720      case FALSE:
3721      case FLOAT:
3722      case INT:
3723      case LONG:
3724      case NEW:
3725      case NULL:
3726      case SHORT:
3727      case SUPER:
3728      case THIS:
3729      case TRUE:
3730      case VOID:
3731      case INTEGER_LITERAL:
3732      case FLOATING_POINT_LITERAL:
3733      case HEX_FLOATING_POINT_LITERAL:
3734      case CHARACTER_LITERAL:
3735      case STRING_LITERAL:
3736      case IDENTIFIER:
3737      case LPAREN:
3738      case BANG:
3739      case TILDE:
3740      case INCR:
3741      case DECR:
3742      case PLUS:
3743      case MINUS:
3744        ArgumentList();
3745        break;
3746      default:
3747        jj_la1[95] = jj_gen;
3748        ;
3749      }
3750      jj_consume_token(RPAREN);
3751    } catch (Throwable JavaDoc jjte000) {
3752    if (jjtc000) {
3753      jjtree.clearNodeScope(jjtn000);
3754      jjtc000 = false;
3755    } else {
3756      jjtree.popNode();
3757    }
3758    if (jjte000 instanceof RuntimeException JavaDoc) {
3759      {if (true) throw (RuntimeException JavaDoc)jjte000;}
3760    }
3761    if (jjte000 instanceof ParseException) {
3762      {if (true) throw (ParseException)jjte000;}
3763    }
3764    {if (true) throw (Error JavaDoc)jjte000;}
3765    } finally {
3766    if (jjtc000) {
3767      jjtree.closeNodeScope(jjtn000, true);
3768    }
3769    }
3770  }
3771
3772  final public void ArgumentList() throws ParseException {
3773 /*@bgen(jjtree) ArgumentList */
3774  ASTArgumentList jjtn000 = new ASTArgumentList(this, JJTARGUMENTLIST);
3775  boolean jjtc000 = true;
3776  jjtree.openNodeScope(jjtn000);
3777    try {
3778      Expression();
3779      label_38:
3780      while (true) {
3781        switch (jj_nt.kind) {
3782        case COMMA:
3783          ;
3784          break;
3785        default:
3786          jj_la1[96] = jj_gen;
3787          break label_38;
3788        }
3789        jj_consume_token(COMMA);
3790        Expression();
3791      }
3792    } catch (Throwable JavaDoc jjte000) {
3793    if (jjtc000) {
3794      jjtree.clearNodeScope(jjtn000);
3795      jjtc000 = false;
3796    } else {
3797      jjtree.popNode();
3798    }
3799    if (jjte000 instanceof RuntimeException JavaDoc) {
3800      {if (true) throw (RuntimeException JavaDoc)jjte000;}
3801    }
3802    if (jjte000 instanceof ParseException) {
3803      {if (true) throw (ParseException)jjte000;}
3804    }
3805    {if (true) throw (Error JavaDoc)jjte000;}
3806    } finally {
3807    if (jjtc000) {
3808      jjtree.closeNodeScope(jjtn000, true);
3809    }
3810    }
3811  }
3812
3813  final public void AllocationExpression() throws ParseException {
3814 /*@bgen(jjtree) AllocationExpression */
3815  ASTAllocationExpression jjtn000 = new ASTAllocationExpression(this, JJTALLOCATIONEXPRESSION);
3816  boolean jjtc000 = true;
3817  jjtree.openNodeScope(jjtn000);
3818    try {
3819      if (jj_2_34(2)) {
3820        jj_consume_token(NEW);
3821        PrimitiveType();
3822        ArrayDimsAndInits();
3823      } else {
3824        switch (jj_nt.kind) {
3825        case NEW:
3826          jj_consume_token(NEW);
3827          ClassOrInterfaceType();
3828          switch (jj_nt.kind) {
3829          case LT:
3830            TypeArguments();
3831            break;
3832          default:
3833            jj_la1[97] = jj_gen;
3834            ;
3835          }
3836          switch (jj_nt.kind) {
3837          case LBRACKET:
3838            ArrayDimsAndInits();
3839            break;
3840          case LPAREN:
3841            Arguments();
3842            switch (jj_nt.kind) {
3843            case LBRACE:
3844              ClassOrInterfaceBody();
3845              break;
3846            default:
3847              jj_la1[98] = jj_gen;
3848              ;
3849            }
3850            break;
3851          default:
3852            jj_la1[99] = jj_gen;
3853            jj_consume_token(-1);
3854            throw new ParseException();
3855          }
3856          break;
3857        default:
3858          jj_la1[100] = jj_gen;
3859          jj_consume_token(-1);
3860          throw new ParseException();
3861        }
3862      }
3863    } catch (Throwable JavaDoc jjte000) {
3864    if (jjtc000) {
3865      jjtree.clearNodeScope(jjtn000);
3866      jjtc000 = false;
3867    } else {
3868      jjtree.popNode();
3869    }
3870    if (jjte000 instanceof RuntimeException JavaDoc) {
3871      {if (true) throw (RuntimeException JavaDoc)jjte000;}
3872    }
3873    if (jjte000 instanceof ParseException) {
3874      {if (true) throw (ParseException)jjte000;}
3875    }
3876    {if (true) throw (Error JavaDoc)jjte000;}
3877    } finally {
3878    if (jjtc000) {
3879      jjtree.closeNodeScope(jjtn000, true);
3880    }
3881    }
3882  }
3883
3884/*
3885 * The second LOOKAHEAD specification below is to parse to PrimarySuffix
3886 * if there is an expression between the "[...]".
3887 */

3888  final public void ArrayDimsAndInits() throws ParseException {
3889 /*@bgen(jjtree) ArrayDimsAndInits */
3890  ASTArrayDimsAndInits jjtn000 = new ASTArrayDimsAndInits(this, JJTARRAYDIMSANDINITS);
3891  boolean jjtc000 = true;
3892  jjtree.openNodeScope(jjtn000);
3893    try {
3894      if (jj_2_37(2)) {
3895        label_39:
3896        while (true) {
3897          jj_consume_token(LBRACKET);
3898          Expression();
3899          jj_consume_token(RBRACKET);
3900          if (jj_2_35(2)) {
3901            ;
3902          } else {
3903            break label_39;
3904          }
3905        }
3906        label_40:
3907        while (true) {
3908          if (jj_2_36(2)) {
3909            ;
3910          } else {
3911            break label_40;
3912          }
3913          jj_consume_token(LBRACKET);
3914          jj_consume_token(RBRACKET);
3915        }
3916      } else {
3917        switch (jj_nt.kind) {
3918        case LBRACKET:
3919          label_41:
3920          while (true) {
3921            jj_consume_token(LBRACKET);
3922            jj_consume_token(RBRACKET);
3923            switch (jj_nt.kind) {
3924            case LBRACKET:
3925              ;
3926              break;
3927            default:
3928              jj_la1[101] = jj_gen;
3929              break label_41;
3930            }
3931          }
3932          ArrayInitializer();
3933          break;
3934        default:
3935          jj_la1[102] = jj_gen;
3936          jj_consume_token(-1);
3937          throw new ParseException();
3938        }
3939      }
3940    } catch (Throwable JavaDoc jjte000) {
3941    if (jjtc000) {
3942      jjtree.clearNodeScope(jjtn000);
3943      jjtc000 = false;
3944    } else {
3945      jjtree.popNode();
3946    }
3947    if (jjte000 instanceof RuntimeException JavaDoc) {
3948      {if (true) throw (RuntimeException JavaDoc)jjte000;}
3949    }
3950    if (jjte000 instanceof ParseException) {
3951      {if (true) throw (ParseException)jjte000;}
3952    }
3953    {if (true) throw (Error JavaDoc)jjte000;}
3954    } finally {
3955    if (jjtc000) {
3956      jjtree.closeNodeScope(jjtn000, true);
3957    }
3958    }
3959  }
3960
3961/*
3962 * Statement syntax follows.
3963 */

3964  final public void Statement() throws ParseException {
3965 /*@bgen(jjtree) Statement */
3966  ASTStatement jjtn000 = new ASTStatement(this, JJTSTATEMENT);
3967  boolean jjtc000 = true;
3968  jjtree.openNodeScope(jjtn000);
3969    try {
3970      if (isNextTokenAnAssert()) {
3971        AssertStatement();
3972      } else if (jj_2_38(2)) {
3973        LabeledStatement();
3974      } else {
3975        switch (jj_nt.kind) {
3976        case LBRACE:
3977          Block();
3978          break;
3979        case SEMICOLON:
3980          EmptyStatement();
3981          break;
3982        case BOOLEAN:
3983        case BYTE:
3984        case CHAR:
3985        case DOUBLE:
3986        case FALSE:
3987        case FLOAT:
3988        case INT:
3989        case LONG:
3990        case NEW:
3991        case NULL:
3992        case SHORT:
3993        case SUPER:
3994        case THIS:
3995        case TRUE:
3996        case VOID:
3997        case INTEGER_LITERAL:
3998        case FLOATING_POINT_LITERAL:
3999        case HEX_FLOATING_POINT_LITERAL:
4000        case CHARACTER_LITERAL:
4001        case STRING_LITERAL:
4002        case IDENTIFIER:
4003        case LPAREN:
4004        case INCR:
4005        case DECR:
4006          StatementExpression();
4007          jj_consume_token(SEMICOLON);
4008          break;
4009        case SWITCH:
4010          SwitchStatement();
4011          break;
4012        case IF:
4013          IfStatement();
4014          break;
4015        case WHILE:
4016          WhileStatement();
4017          break;
4018        case DO:
4019          DoStatement();
4020          break;
4021        case FOR:
4022          ForStatement();
4023          break;
4024        case BREAK:
4025          BreakStatement();
4026          break;
4027        case CONTINUE:
4028          ContinueStatement();
4029          break;
4030        case RETURN:
4031          ReturnStatement();
4032          break;
4033        case THROW:
4034          ThrowStatement();
4035          break;
4036        case SYNCHRONIZED:
4037          SynchronizedStatement();
4038          break;
4039        case TRY:
4040          TryStatement();
4041          break;
4042        default:
4043          jj_la1[103] = jj_gen;
4044          jj_consume_token(-1);
4045          throw new ParseException();
4046        }
4047      }
4048    } catch (Throwable JavaDoc jjte000) {
4049    if (jjtc000) {
4050      jjtree.clearNodeScope(jjtn000);
4051      jjtc000 = false;
4052    } else {
4053      jjtree.popNode();
4054    }
4055    if (jjte000 instanceof RuntimeException JavaDoc) {
4056      {if (true) throw (RuntimeException JavaDoc)jjte000;}
4057    }
4058    if (jjte000 instanceof ParseException) {
4059      {if (true) throw (ParseException)jjte000;}
4060    }
4061    {if (true) throw (Error JavaDoc)jjte000;}
4062    } finally {
4063    if (jjtc000) {
4064      jjtree.closeNodeScope(jjtn000, true);
4065    }
4066    }
4067  }
4068
4069  final public void LabeledStatement() throws ParseException {
4070 /*@bgen(jjtree) LabeledStatement */
4071 ASTLabeledStatement jjtn000 = new ASTLabeledStatement(this, JJTLABELEDSTATEMENT);
4072 boolean jjtc000 = true;
4073 jjtree.openNodeScope(jjtn000);Token t;
4074    try {
4075      t = jj_consume_token(IDENTIFIER);
4076                  jjtn000.setImage(t.image);
4077      jj_consume_token(COLON);
4078      Statement();
4079    } catch (Throwable JavaDoc jjte000) {
4080    if (jjtc000) {
4081      jjtree.clearNodeScope(jjtn000);
4082      jjtc000 = false;
4083    } else {
4084      jjtree.popNode();
4085    }
4086    if (jjte000 instanceof RuntimeException JavaDoc) {
4087      {if (true) throw (RuntimeException JavaDoc)jjte000;}
4088    }
4089    if (jjte000 instanceof ParseException) {
4090      {if (true) throw (ParseException)jjte000;}
4091    }
4092    {if (true) throw (Error JavaDoc)jjte000;}
4093    } finally {
4094    if (jjtc000) {
4095      jjtree.closeNodeScope(jjtn000, true);
4096    }
4097    }
4098  }
4099
4100  final public void Block() throws ParseException {
4101 /*@bgen(jjtree) Block */
4102 ASTBlock jjtn000 = new ASTBlock(this, JJTBLOCK);
4103 boolean jjtc000 = true;
4104 jjtree.openNodeScope(jjtn000);Token t;
4105    try {
4106      jj_consume_token(LBRACE);
4107      label_42:
4108      while (true) {
4109        if (jj_2_39(1)) {
4110          ;
4111        } else {
4112          break label_42;
4113        }
4114        BlockStatement();
4115      }
4116      t = jj_consume_token(RBRACE);
4117                                          jjtree.closeNodeScope(jjtn000, true);
4118                                          jjtc000 = false;
4119                                          if (isPrecededByComment(t)) { jjtn000.setContainsComment(); }
4120    } catch (Throwable JavaDoc jjte000) {
4121        if (jjtc000) {
4122          jjtree.clearNodeScope(jjtn000);
4123          jjtc000 = false;
4124        } else {
4125          jjtree.popNode();
4126        }
4127        if (jjte000 instanceof RuntimeException JavaDoc) {
4128          {if (true) throw (RuntimeException JavaDoc)jjte000;}
4129        }
4130        if (jjte000 instanceof ParseException) {
4131          {if (true) throw (ParseException)jjte000;}
4132        }
4133        {if (true) throw (Error JavaDoc)jjte000;}
4134    } finally {
4135        if (jjtc000) {
4136          jjtree.closeNodeScope(jjtn000, true);
4137        }
4138    }
4139  }
4140
4141  final public void BlockStatement() throws ParseException {
4142 /*@bgen(jjtree) BlockStatement */
4143  ASTBlockStatement jjtn000 = new ASTBlockStatement(this, JJTBLOCKSTATEMENT);
4144  boolean jjtc000 = true;
4145  jjtree.openNodeScope(jjtn000);
4146    try {
4147      if (isNextTokenAnAssert()) {
4148        AssertStatement();
4149      } else if (jj_2_40(2147483647)) {
4150        LocalVariableDeclaration();
4151        jj_consume_token(SEMICOLON);
4152      } else if (jj_2_41(1)) {
4153        Statement();
4154      } else if (jj_2_42(2147483647)) {
4155        ClassOrInterfaceDeclaration(0);
4156      } else {
4157        jj_consume_token(-1);
4158        throw new ParseException();
4159      }
4160    } catch (Throwable JavaDoc jjte000) {
4161    if (jjtc000) {
4162      jjtree.clearNodeScope(jjtn000);
4163      jjtc000 = false;
4164    } else {
4165      jjtree.popNode();
4166    }
4167    if (jjte000 instanceof RuntimeException JavaDoc) {
4168      {if (true) throw (RuntimeException JavaDoc)jjte000;}
4169    }
4170    if (jjte000 instanceof ParseException) {
4171      {if (true) throw (ParseException)jjte000;}
4172    }
4173    {if (true) throw (Error JavaDoc)jjte000;}
4174    } finally {
4175    if (jjtc000) {
4176      jjtree.closeNodeScope(jjtn000, true);
4177    }
4178    }
4179  }
4180
4181  final public void LocalVariableDeclaration() throws ParseException {
4182 /*@bgen(jjtree) LocalVariableDeclaration */
4183  ASTLocalVariableDeclaration jjtn000 = new ASTLocalVariableDeclaration(this, JJTLOCALVARIABLEDECLARATION);
4184  boolean jjtc000 = true;
4185  jjtree.openNodeScope(jjtn000);
4186    try {
4187      label_43:
4188      while (true) {
4189        switch (jj_nt.kind) {
4190        case FINAL:
4191        case AT:
4192          ;
4193          break;
4194        default:
4195          jj_la1[104] = jj_gen;
4196          break label_43;
4197        }
4198        switch (jj_nt.kind) {
4199        case FINAL:
4200          jj_consume_token(FINAL);
4201             jjtn000.setFinal();
4202          break;
4203        case AT:
4204          Annotation();
4205          break;
4206        default:
4207          jj_la1[105] = jj_gen;
4208          jj_consume_token(-1);
4209          throw new ParseException();
4210        }
4211      }
4212      Type();
4213      VariableDeclarator();
4214      label_44:
4215      while (true) {
4216        switch (jj_nt.kind) {
4217        case COMMA:
4218          ;
4219          break;
4220        default:
4221          jj_la1[106] = jj_gen;
4222          break label_44;
4223        }
4224        jj_consume_token(COMMA);
4225        VariableDeclarator();
4226      }
4227    } catch (Throwable JavaDoc jjte000) {
4228    if (jjtc000) {
4229      jjtree.clearNodeScope(jjtn000);
4230      jjtc000 = false;
4231    } else {
4232      jjtree.popNode();
4233    }
4234    if (jjte000 instanceof RuntimeException JavaDoc) {
4235      {if (true) throw (RuntimeException JavaDoc)jjte000;}
4236    }
4237    if (jjte000 instanceof ParseException) {
4238      {if (true) throw (ParseException)jjte000;}
4239    }
4240    {if (true) throw (Error JavaDoc)jjte000;}
4241    } finally {
4242    if (jjtc000) {
4243      jjtree.closeNodeScope(jjtn000, true);
4244    }
4245    }
4246  }
4247
4248  final public void EmptyStatement() throws ParseException {
4249 /*@bgen(jjtree) EmptyStatement */
4250  ASTEmptyStatement jjtn000 = new ASTEmptyStatement(this, JJTEMPTYSTATEMENT);
4251  boolean jjtc000 = true;
4252  jjtree.openNodeScope(jjtn000);
4253    try {
4254      jj_consume_token(SEMICOLON);
4255    } finally {
4256    if (jjtc000) {
4257      jjtree.closeNodeScope(jjtn000, true);
4258    }
4259    }
4260  }
4261
4262  final public void StatementExpression() throws ParseException {
4263 /*@bgen(jjtree) StatementExpression */
4264  ASTStatementExpression jjtn000 = new ASTStatementExpression(this, JJTSTATEMENTEXPRESSION);
4265  boolean jjtc000 = true;
4266  jjtree.openNodeScope(jjtn000);
4267    try {
4268      switch (jj_nt.kind) {
4269      case INCR:
4270        PreIncrementExpression();
4271        break;
4272      case DECR:
4273        PreDecrementExpression();
4274        break;
4275      default:
4276        jj_la1[108] = jj_gen;
4277        if (jj_2_43(2147483647)) {
4278          PostfixExpression();
4279        } else {
4280          switch (jj_nt.kind) {
4281          case BOOLEAN:
4282          case BYTE:
4283          case CHAR:
4284          case DOUBLE:
4285          case FALSE:
4286          case FLOAT:
4287          case INT:
4288          case LONG:
4289          case NEW:
4290          case NULL:
4291          case SHORT:
4292          case SUPER:
4293          case THIS:
4294          case TRUE:
4295          case VOID:
4296          case INTEGER_LITERAL:
4297          case FLOATING_POINT_LITERAL:
4298          case HEX_FLOATING_POINT_LITERAL:
4299          case CHARACTER_LITERAL:
4300          case STRING_LITERAL:
4301          case IDENTIFIER:
4302          case LPAREN:
4303            PrimaryExpression();
4304            switch (jj_nt.kind) {
4305            case ASSIGN:
4306            case PLUSASSIGN:
4307            case MINUSASSIGN:
4308            case STARASSIGN:
4309            case SLASHASSIGN:
4310            case ANDASSIGN:
4311            case ORASSIGN:
4312            case XORASSIGN:
4313            case REMASSIGN:
4314            case LSHIFTASSIGN:
4315            case RSIGNEDSHIFTASSIGN:
4316            case RUNSIGNEDSHIFTASSIGN:
4317              AssignmentOperator();
4318              Expression();
4319              break;
4320            default:
4321              jj_la1[107] = jj_gen;
4322              ;
4323            }
4324            break;
4325          default:
4326            jj_la1[109] = jj_gen;
4327            jj_consume_token(-1);
4328            throw new ParseException();
4329          }
4330        }
4331      }
4332    } catch (Throwable JavaDoc jjte000) {
4333    if (jjtc000) {
4334      jjtree.clearNodeScope(jjtn000);
4335      jjtc000 = false;
4336    } else {
4337      jjtree.popNode();
4338    }
4339    if (jjte000 instanceof RuntimeException JavaDoc) {
4340      {if (true) throw (RuntimeException JavaDoc)jjte000;}
4341    }
4342    if (jjte000 instanceof ParseException) {
4343      {if (true) throw (ParseException)jjte000;}
4344    }
4345    {if (true) throw (Error JavaDoc)jjte000;}
4346    } finally {
4347    if (jjtc000) {
4348      jjtree.closeNodeScope(jjtn000, true);
4349    }
4350    }
4351  }
4352
4353  final public void SwitchStatement() throws ParseException {
4354 /*@bgen(jjtree) SwitchStatement */
4355  ASTSwitchStatement jjtn000 = new ASTSwitchStatement(this, JJTSWITCHSTATEMENT);
4356  boolean jjtc000 = true;
4357  jjtree.openNodeScope(jjtn000);
4358    try {
4359      jj_consume_token(SWITCH);
4360      jj_consume_token(LPAREN);
4361      Expression();
4362      jj_consume_token(RPAREN);
4363      jj_consume_token(LBRACE);
4364      label_45:
4365      while (true) {
4366        switch (jj_nt.kind) {
4367        case CASE:
4368        case _DEFAULT:
4369          ;
4370          break;
4371        default:
4372          jj_la1[110] = jj_gen;
4373          break label_45;
4374        }
4375        SwitchLabel();
4376        label_46:
4377        while (true) {
4378          if (jj_2_44(1)) {
4379            ;
4380          } else {
4381            break label_46;
4382          }
4383          BlockStatement();
4384        }
4385      }
4386      jj_consume_token(RBRACE);
4387    } catch (Throwable JavaDoc jjte000) {
4388    if (jjtc000) {
4389      jjtree.clearNodeScope(jjtn000);
4390      jjtc000 = false;
4391    } else {
4392      jjtree.popNode();
4393    }
4394    if (jjte000 instanceof RuntimeException JavaDoc) {
4395      {if (true) throw (RuntimeException JavaDoc)jjte000;}
4396    }
4397    if (jjte000 instanceof ParseException) {
4398      {if (true) throw (ParseException)jjte000;}
4399    }
4400    {if (true) throw (Error JavaDoc)jjte000;}
4401    } finally {
4402    if (jjtc000) {
4403      jjtree.closeNodeScope(jjtn000, true);
4404    }
4405    }
4406  }
4407
4408  final public void SwitchLabel() throws ParseException {
4409 /*@bgen(jjtree) SwitchLabel */
4410  ASTSwitchLabel jjtn000 = new ASTSwitchLabel(this, JJTSWITCHLABEL);
4411  boolean jjtc000 = true;
4412  jjtree.openNodeScope(jjtn000);
4413    try {
4414      switch (jj_nt.kind) {
4415      case CASE:
4416        jj_consume_token(CASE);
4417        Expression();
4418        jj_consume_token(COLON);
4419        break;
4420      case _DEFAULT:
4421        jj_consume_token(_DEFAULT);
4422             jjtn000.setDefault();
4423        jj_consume_token(COLON);
4424        break;
4425      default:
4426        jj_la1[111] = jj_gen;
4427        jj_consume_token(-1);
4428        throw new ParseException();
4429      }
4430    } catch (Throwable JavaDoc jjte000) {
4431    if (jjtc000) {
4432      jjtree.clearNodeScope(jjtn000);
4433      jjtc000 = false;
4434    } else {
4435      jjtree.popNode();
4436    }
4437    if (jjte000 instanceof RuntimeException JavaDoc) {
4438      {if (true) throw (RuntimeException JavaDoc)jjte000;}
4439    }
4440    if (jjte000 instanceof ParseException) {
4441      {if (true) throw (ParseException)jjte000;}
4442    }
4443    {if (true) throw (Error JavaDoc)jjte000;}
4444    } finally {
4445    if (jjtc000) {
4446      jjtree.closeNodeScope(jjtn000, true);
4447    }
4448    }
4449  }
4450
4451  final public void IfStatement() throws ParseException {
4452 /*@bgen(jjtree) IfStatement */
4453  ASTIfStatement jjtn000 = new ASTIfStatement(this, JJTIFSTATEMENT);
4454  boolean jjtc000 = true;
4455  jjtree.openNodeScope(jjtn000);
4456    try {
4457      jj_consume_token(IF);
4458      jj_consume_token(LPAREN);
4459      Expression();
4460      jj_consume_token(RPAREN);
4461      Statement();
4462      switch (jj_nt.kind) {
4463      case ELSE:
4464        jj_consume_token(ELSE);
4465                                                               jjtn000.setHasElse();
4466        Statement();
4467        break;
4468      default:
4469        jj_la1[112] = jj_gen;
4470        ;
4471      }
4472  jjtree.closeNodeScope(jjtn000, true);
4473  jjtc000 = false;
4474
4475    } catch (Throwable JavaDoc jjte000) {
4476    if (jjtc000) {
4477      jjtree.clearNodeScope(jjtn000);
4478      jjtc000 = false;
4479    } else {
4480      jjtree.popNode();
4481    }
4482    if (jjte000 instanceof RuntimeException JavaDoc) {
4483      {if (true) throw (RuntimeException JavaDoc)jjte000;}
4484    }
4485    if (jjte000 instanceof ParseException) {
4486      {if (true) throw (ParseException)jjte000;}
4487    }
4488    {if (true) throw (Error JavaDoc)jjte000;}
4489    } finally {
4490    if (jjtc000) {
4491      jjtree.closeNodeScope(jjtn000, true);
4492    }
4493    }
4494  }
4495
4496  final public void WhileStatement() throws ParseException {
4497 /*@bgen(jjtree) WhileStatement */
4498  ASTWhileStatement jjtn000 = new ASTWhileStatement(this, JJTWHILESTATEMENT);
4499  boolean jjtc000 = true;
4500  jjtree.openNodeScope(jjtn000);
4501    try {
4502      jj_consume_token(WHILE);
4503      jj_consume_token(LPAREN);
4504      Expression();
4505      jj_consume_token(RPAREN);
4506      Statement();
4507    } catch (Throwable JavaDoc jjte000) {
4508    if (jjtc000) {
4509      jjtree.clearNodeScope(jjtn000);
4510      jjtc000 = false;
4511    } else {
4512      jjtree.popNode();
4513    }
4514    if (jjte000 instanceof RuntimeException JavaDoc) {
4515      {if (true) throw (RuntimeException JavaDoc)jjte000;}
4516    }
4517    if (jjte000 instanceof ParseException) {
4518      {if (true) throw (ParseException)jjte000;}
4519    }
4520    {if (true) throw (Error JavaDoc)jjte000;}
4521    } finally {
4522    if (jjtc000) {
4523      jjtree.closeNodeScope(jjtn000, true);
4524    }
4525    }
4526  }
4527
4528  final public void DoStatement() throws ParseException {
4529 /*@bgen(jjtree) DoStatement */
4530  ASTDoStatement jjtn000 = new ASTDoStatement(this, JJTDOSTATEMENT);
4531  boolean jjtc000 = true;
4532  jjtree.openNodeScope(jjtn000);
4533    try {
4534      jj_consume_token(DO);
4535      Statement();
4536      jj_consume_token(WHILE);
4537      jj_consume_token(LPAREN);
4538      Expression();
4539      jj_consume_token(RPAREN);
4540      jj_consume_token(SEMICOLON);
4541    } catch (Throwable JavaDoc jjte000) {
4542    if (jjtc000) {
4543      jjtree.clearNodeScope(jjtn000);
4544      jjtc000 = false;
4545    } else {
4546      jjtree.popNode();
4547    }
4548    if (jjte000 instanceof RuntimeException JavaDoc) {
4549      {if (true) throw (RuntimeException JavaDoc)jjte000;}
4550    }
4551    if (jjte000 instanceof ParseException) {
4552      {if (true) throw (ParseException)jjte000;}
4553    }
4554    {if (true) throw (Error JavaDoc)jjte000;}
4555    } finally {
4556    if (jjtc000) {
4557      jjtree.closeNodeScope(jjtn000, true);
4558    }
4559    }
4560  }
4561
4562  final public void ForStatement() throws ParseException {
4563 /*@bgen(jjtree) ForStatement */
4564  ASTForStatement jjtn000 = new ASTForStatement(this, JJTFORSTATEMENT);
4565  boolean jjtc000 = true;
4566  jjtree.openNodeScope(jjtn000);
4567    try {
4568      jj_consume_token(FOR);
4569      jj_consume_token(LPAREN);
4570      if (jj_2_45(2147483647)) {
4571       checkForBadJDK15ForLoopSyntaxArgumentsUsage();
4572        Modifiers();
4573        Type();
4574        jj_consume_token(IDENTIFIER);
4575        jj_consume_token(COLON);
4576        Expression();
4577      } else {
4578        switch (jj_nt.kind) {
4579        case BOOLEAN:
4580        case BYTE:
4581        case CHAR:
4582        case DOUBLE:
4583        case FALSE:
4584        case FINAL:
4585        case FLOAT:
4586        case INT:
4587        case LONG:
4588        case NEW:
4589        case NULL:
4590        case SHORT:
4591        case SUPER:
4592        case THIS:
4593        case TRUE:
4594        case VOID:
4595        case INTEGER_LITERAL:
4596        case FLOATING_POINT_LITERAL:
4597        case HEX_FLOATING_POINT_LITERAL:
4598        case CHARACTER_LITERAL:
4599        case STRING_LITERAL:
4600        case IDENTIFIER:
4601        case LPAREN:
4602        case SEMICOLON:
4603        case AT:
4604        case INCR:
4605        case DECR:
4606          switch (jj_nt.kind) {
4607          case BOOLEAN:
4608          case BYTE:
4609          case CHAR:
4610          case DOUBLE:
4611          case FALSE:
4612          case FINAL:
4613          case FLOAT:
4614          case INT:
4615          case LONG:
4616          case NEW:
4617          case NULL:
4618          case SHORT:
4619          case SUPER:
4620          case THIS:
4621          case TRUE:
4622          case VOID:
4623          case INTEGER_LITERAL:
4624          case FLOATING_POINT_LITERAL:
4625          case HEX_FLOATING_POINT_LITERAL:
4626          case CHARACTER_LITERAL:
4627          case STRING_LITERAL:
4628          case IDENTIFIER:
4629          case LPAREN:
4630          case AT:
4631          case INCR:
4632          case DECR:
4633            ForInit();
4634            break;
4635          default:
4636            jj_la1[113] = jj_gen;
4637            ;
4638          }
4639          jj_consume_token(SEMICOLON);
4640          switch (jj_nt.kind) {
4641          case BOOLEAN:
4642          case BYTE:
4643          case CHAR:
4644          case DOUBLE:
4645          case FALSE:
4646          case FLOAT:
4647          case INT:
4648          case LONG:
4649          case NEW:
4650          case NULL:
4651          case SHORT:
4652          case SUPER:
4653          case THIS:
4654          case TRUE:
4655          case VOID:
4656          case INTEGER_LITERAL:
4657          case FLOATING_POINT_LITERAL:
4658          case HEX_FLOATING_POINT_LITERAL:
4659          case CHARACTER_LITERAL:
4660          case STRING_LITERAL:
4661          case IDENTIFIER:
4662          case LPAREN:
4663          case BANG:
4664          case TILDE:
4665          case INCR:
4666          case DECR:
4667          case PLUS:
4668          case MINUS:
4669            Expression();
4670            break;
4671          default:
4672            jj_la1[114] = jj_gen;
4673            ;
4674          }
4675          jj_consume_token(SEMICOLON);
4676          switch (jj_nt.kind) {
4677          case BOOLEAN:
4678          case BYTE:
4679          case CHAR:
4680          case DOUBLE:
4681          case FALSE:
4682          case FLOAT:
4683          case INT:
4684          case LONG:
4685          case NEW:
4686          case NULL:
4687          case SHORT:
4688          case SUPER:
4689          case THIS:
4690          case TRUE:
4691          case VOID:
4692          case INTEGER_LITERAL:
4693          case FLOATING_POINT_LITERAL:
4694          case HEX_FLOATING_POINT_LITERAL:
4695          case CHARACTER_LITERAL:
4696          case STRING_LITERAL:
4697          case IDENTIFIER:
4698          case LPAREN:
4699          case INCR:
4700          case DECR:
4701            ForUpdate();
4702            break;
4703          default:
4704            jj_la1[115] = jj_gen;
4705            ;
4706          }
4707          break;
4708        default:
4709          jj_la1[116] = jj_gen;
4710          jj_consume_token(-1);
4711          throw new ParseException();
4712        }
4713      }
4714      jj_consume_token(RPAREN);
4715      Statement();
4716    } catch (Throwable JavaDoc jjte000) {
4717    if (jjtc000) {
4718      jjtree.clearNodeScope(jjtn000);
4719      jjtc000 = false;
4720    } else {
4721      jjtree.popNode();
4722    }
4723    if (jjte000 instanceof RuntimeException JavaDoc) {
4724      {if (true) throw (RuntimeException JavaDoc)jjte000;}
4725    }
4726    if (jjte000 instanceof ParseException) {
4727      {if (true) throw (ParseException)jjte000;}
4728    }
4729    {if (true) throw (Error JavaDoc)jjte000;}
4730    } finally {
4731    if (jjtc000) {
4732      jjtree.closeNodeScope(jjtn000, true);
4733    }
4734    }
4735  }
4736
4737  final public void ForInit() throws ParseException {
4738 /*@bgen(jjtree) ForInit */
4739  ASTForInit jjtn000 = new ASTForInit(this, JJTFORINIT);
4740  boolean jjtc000 = true;
4741  jjtree.openNodeScope(jjtn000);
4742    try {
4743      if (jj_2_46(2147483647)) {
4744        LocalVariableDeclaration();
4745      } else {
4746        switch (jj_nt.kind) {
4747        case BOOLEAN:
4748        case BYTE:
4749        case CHAR:
4750        case DOUBLE:
4751        case FALSE:
4752        case FLOAT:
4753        case INT:
4754        case LONG:
4755        case NEW:
4756        case NULL:
4757        case SHORT:
4758        case SUPER:
4759        case THIS:
4760        case TRUE:
4761        case VOID:
4762        case INTEGER_LITERAL:
4763        case FLOATING_POINT_LITERAL:
4764        case HEX_FLOATING_POINT_LITERAL:
4765        case CHARACTER_LITERAL:
4766        case STRING_LITERAL:
4767        case IDENTIFIER:
4768        case LPAREN:
4769        case INCR:
4770        case DECR:
4771          StatementExpressionList();
4772          break;
4773        default:
4774          jj_la1[117] = jj_gen;
4775          jj_consume_token(-1);
4776          throw new ParseException();
4777        }
4778      }
4779    } catch (Throwable JavaDoc jjte000) {
4780    if (jjtc000) {
4781      jjtree.clearNodeScope(jjtn000);
4782      jjtc000 = false;
4783    } else {
4784      jjtree.popNode();
4785    }
4786    if (jjte000 instanceof RuntimeException JavaDoc) {
4787      {if (true) throw (RuntimeException JavaDoc)jjte000;}
4788    }
4789    if (jjte000 instanceof ParseException) {
4790      {if (true) throw (ParseException)jjte000;}
4791    }
4792    {if (true) throw (Error JavaDoc)jjte000;}
4793    } finally {
4794    if (jjtc000) {
4795      jjtree.closeNodeScope(jjtn000, true);
4796    }
4797    }
4798  }
4799
4800  final public void StatementExpressionList() throws ParseException {
4801 /*@bgen(jjtree) StatementExpressionList */
4802  ASTStatementExpressionList jjtn000 = new ASTStatementExpressionList(this, JJTSTATEMENTEXPRESSIONLIST);
4803  boolean jjtc000 = true;
4804  jjtree.openNodeScope(jjtn000);
4805    try {
4806      StatementExpression();
4807      label_47:
4808      while (true) {
4809        switch (jj_nt.kind) {
4810        case COMMA:
4811          ;
4812          break;
4813        default:
4814          jj_la1[118] = jj_gen;
4815          break label_47;
4816        }
4817        jj_consume_token(COMMA);
4818        StatementExpression();
4819      }
4820    } catch (Throwable JavaDoc jjte000) {
4821    if (jjtc000) {
4822      jjtree.clearNodeScope(jjtn000);
4823      jjtc000 = false;
4824    } else {
4825      jjtree.popNode();
4826    }
4827    if (jjte000 instanceof RuntimeException JavaDoc) {
4828      {if (true) throw (RuntimeException JavaDoc)jjte000;}
4829    }
4830    if (jjte000 instanceof ParseException) {
4831      {if (true) throw (ParseException)jjte000;}
4832    }
4833    {if (true) throw (Error JavaDoc)jjte000;}
4834    } finally {
4835    if (jjtc000) {
4836      jjtree.closeNodeScope(jjtn000, true);
4837    }
4838    }
4839  }
4840
4841  final public void ForUpdate() throws ParseException {
4842 /*@bgen(jjtree) ForUpdate */
4843  ASTForUpdate jjtn000 = new ASTForUpdate(this, JJTFORUPDATE);
4844  boolean jjtc000 = true;
4845  jjtree.openNodeScope(jjtn000);
4846    try {
4847      StatementExpressionList();
4848    } catch (Throwable JavaDoc jjte000) {
4849    if (jjtc000) {
4850      jjtree.clearNodeScope(jjtn000);
4851      jjtc000 = false;
4852    } else {
4853      jjtree.popNode();
4854    }
4855    if (jjte000 instanceof RuntimeException JavaDoc) {
4856      {if (true) throw (RuntimeException JavaDoc)jjte000;}
4857    }
4858    if (jjte000 instanceof ParseException) {
4859      {if (true) throw (ParseException)jjte000;}
4860    }
4861    {if (true) throw (Error JavaDoc)jjte000;}
4862    } finally {
4863    if (jjtc000) {
4864      jjtree.closeNodeScope(jjtn000, true);
4865    }
4866    }
4867  }
4868
4869  final public void BreakStatement() throws ParseException {
4870 /*@bgen(jjtree) BreakStatement */
4871 ASTBreakStatement jjtn000 = new ASTBreakStatement(this, JJTBREAKSTATEMENT);
4872 boolean jjtc000 = true;
4873 jjtree.openNodeScope(jjtn000);Token t;
4874    try {
4875      jj_consume_token(BREAK);
4876      switch (jj_nt.kind) {
4877      case IDENTIFIER:
4878        t = jj_consume_token(IDENTIFIER);
4879                            jjtn000.setImage(t.image);
4880        break;
4881      default:
4882        jj_la1[119] = jj_gen;
4883        ;
4884      }
4885      jj_consume_token(SEMICOLON);
4886    } finally {
4887    if (jjtc000) {
4888      jjtree.closeNodeScope(jjtn000, true);
4889    }
4890    }
4891  }
4892
4893  final public void ContinueStatement() throws ParseException {
4894 /*@bgen(jjtree) ContinueStatement */
4895 ASTContinueStatement jjtn000 = new ASTContinueStatement(this, JJTCONTINUESTATEMENT);
4896 boolean jjtc000 = true;
4897 jjtree.openNodeScope(jjtn000);Token t;
4898    try {
4899      jj_consume_token(CONTINUE);
4900      switch (jj_nt.kind) {
4901      case IDENTIFIER:
4902        t = jj_consume_token(IDENTIFIER);
4903                               jjtn000.setImage(t.image);
4904        break;
4905      default:
4906        jj_la1[120] = jj_gen;
4907        ;
4908      }
4909      jj_consume_token(SEMICOLON);
4910    } finally {
4911    if (jjtc000) {
4912      jjtree.closeNodeScope(jjtn000, true);
4913    }
4914    }
4915  }
4916
4917  final public void ReturnStatement() throws ParseException {
4918 /*@bgen(jjtree) ReturnStatement */
4919  ASTReturnStatement jjtn000 = new ASTReturnStatement(this, JJTRETURNSTATEMENT);
4920  boolean jjtc000 = true;
4921  jjtree.openNodeScope(jjtn000);
4922    try {
4923      jj_consume_token(RETURN);
4924      switch (jj_nt.kind) {
4925      case BOOLEAN:
4926      case BYTE:
4927      case CHAR:
4928      case DOUBLE:
4929      case FALSE:
4930      case FLOAT:
4931      case INT:
4932      case LONG:
4933      case NEW:
4934      case NULL:
4935      case SHORT:
4936      case SUPER:
4937      case THIS:
4938      case TRUE:
4939      case VOID:
4940      case INTEGER_LITERAL:
4941      case FLOATING_POINT_LITERAL:
4942      case HEX_FLOATING_POINT_LITERAL:
4943      case CHARACTER_LITERAL:
4944      case STRING_LITERAL:
4945      case IDENTIFIER:
4946      case LPAREN:
4947      case BANG:
4948      case TILDE:
4949      case INCR:
4950      case DECR:
4951      case PLUS:
4952      case MINUS:
4953        Expression();
4954        break;
4955      default:
4956        jj_la1[121] = jj_gen;
4957        ;
4958      }
4959      jj_consume_token(SEMICOLON);
4960    } catch (Throwable JavaDoc jjte000) {
4961    if (jjtc000) {
4962      jjtree.clearNodeScope(jjtn000);
4963      jjtc000 = false;
4964    } else {
4965      jjtree.popNode();
4966    }
4967    if (jjte000 instanceof RuntimeException JavaDoc) {
4968      {if (true) throw (RuntimeException JavaDoc)jjte000;}
4969    }
4970    if (jjte000 instanceof ParseException) {
4971      {if (true) throw (ParseException)jjte000;}
4972    }
4973    {if (true) throw (Error JavaDoc)jjte000;}
4974    } finally {
4975    if (jjtc000) {
4976      jjtree.closeNodeScope(jjtn000, true);
4977    }
4978    }
4979  }
4980
4981  final public void ThrowStatement() throws ParseException {
4982 /*@bgen(jjtree) ThrowStatement */
4983  ASTThrowStatement jjtn000 = new ASTThrowStatement(this, JJTTHROWSTATEMENT);
4984  boolean jjtc000 = true;
4985  jjtree.openNodeScope(jjtn000);
4986    try {
4987      jj_consume_token(THROW);
4988      Expression();
4989      jj_consume_token(SEMICOLON);
4990    } catch (Throwable JavaDoc jjte000) {
4991    if (jjtc000) {
4992      jjtree.clearNodeScope(jjtn000);
4993      jjtc000 = false;
4994    } else {
4995      jjtree.popNode();
4996    }
4997    if (jjte000 instanceof RuntimeException JavaDoc) {
4998      {if (true) throw (RuntimeException JavaDoc)jjte000;}
4999    }
5000    if (jjte000 instanceof ParseException) {
5001      {if (true) throw (ParseException)jjte000;}
5002    }
5003    {if (true) throw (Error JavaDoc)jjte000;}
5004    } finally {
5005    if (jjtc000) {
5006      jjtree.closeNodeScope(jjtn000, true);
5007    }
5008    }
5009  }
5010
5011  final public void SynchronizedStatement() throws ParseException {
5012 /*@bgen(jjtree) SynchronizedStatement */
5013  ASTSynchronizedStatement jjtn000 = new ASTSynchronizedStatement(this, JJTSYNCHRONIZEDSTATEMENT);
5014  boolean jjtc000 = true;
5015  jjtree.openNodeScope(jjtn000);
5016    try {
5017      jj_consume_token(SYNCHRONIZED);
5018      jj_consume_token(LPAREN);
5019      Expression();
5020      jj_consume_token(RPAREN);
5021      Block();
5022    } catch (Throwable JavaDoc jjte000) {
5023    if (jjtc000) {
5024      jjtree.clearNodeScope(jjtn000);
5025      jjtc000 = false;
5026    } else {
5027      jjtree.popNode();
5028    }
5029    if (jjte000 instanceof RuntimeException JavaDoc) {
5030      {if (true) throw (RuntimeException JavaDoc)jjte000;}
5031    }
5032    if (jjte000 instanceof ParseException) {
5033      {if (true) throw (ParseException)jjte000;}
5034    }
5035    {if (true) throw (Error JavaDoc)jjte000;}
5036    } finally {
5037    if (jjtc000) {
5038      jjtree.closeNodeScope(jjtn000, true);
5039    }
5040    }
5041  }
5042
5043  final public void TryStatement() throws ParseException {
5044 /*@bgen(jjtree) TryStatement */
5045  ASTTryStatement jjtn000 = new ASTTryStatement(this, JJTTRYSTATEMENT);
5046  boolean jjtc000 = true;
5047  jjtree.openNodeScope(jjtn000);
5048    try {
5049      jj_consume_token(TRY);
5050      Block();
5051      label_48:
5052      while (true) {
5053        switch (jj_nt.kind) {
5054        case CATCH:
5055          ;
5056          break;
5057        default:
5058          jj_la1[122] = jj_gen;
5059          break label_48;
5060        }
5061        CatchStatement();
5062      }
5063      switch (jj_nt.kind) {
5064      case FINALLY:
5065        FinallyStatement();
5066        break;
5067      default:
5068        jj_la1[123] = jj_gen;
5069        ;
5070      }
5071    } catch (Throwable JavaDoc jjte000) {
5072    if (jjtc000) {
5073      jjtree.clearNodeScope(jjtn000);
5074      jjtc000 = false;
5075    } else {
5076      jjtree.popNode();
5077    }
5078    if (jjte000 instanceof RuntimeException JavaDoc) {
5079      {if (true) throw (RuntimeException JavaDoc)jjte000;}
5080    }
5081    if (jjte000 instanceof ParseException) {
5082      {if (true) throw (ParseException)jjte000;}
5083    }
5084    {if (true) throw (Error JavaDoc)jjte000;}
5085    } finally {
5086    if (jjtc000) {
5087      jjtree.closeNodeScope(jjtn000, true);
5088    }
5089    }
5090  }
5091
5092  final public void CatchStatement() throws ParseException {
5093 /*@bgen(jjtree) CatchStatement */
5094  ASTCatchStatement jjtn000 = new ASTCatchStatement(this, JJTCATCHSTATEMENT);
5095  boolean jjtc000 = true;
5096  jjtree.openNodeScope(jjtn000);
5097    try {
5098      jj_consume_token(CATCH);
5099      jj_consume_token(LPAREN);
5100      FormalParameter();
5101      jj_consume_token(RPAREN);
5102      Block();
5103    } catch (Throwable JavaDoc jjte000) {
5104    if (jjtc000) {
5105      jjtree.clearNodeScope(jjtn000);
5106      jjtc000 = false;
5107    } else {
5108      jjtree.popNode();
5109    }
5110    if (jjte000 instanceof RuntimeException JavaDoc) {
5111      {if (true) throw (RuntimeException JavaDoc)jjte000;}
5112    }
5113    if (jjte000 instanceof ParseException) {
5114      {if (true) throw (ParseException)jjte000;}
5115    }
5116    {if (true) throw (Error JavaDoc)jjte000;}
5117    } finally {
5118    if (jjtc000) {
5119      jjtree.closeNodeScope(jjtn000, true);
5120    }
5121    }
5122  }
5123
5124  final public void FinallyStatement() throws ParseException {
5125 /*@bgen(jjtree) FinallyStatement */
5126  ASTFinallyStatement jjtn000 = new ASTFinallyStatement(this, JJTFINALLYSTATEMENT);
5127  boolean jjtc000 = true;
5128  jjtree.openNodeScope(jjtn000);
5129    try {
5130      jj_consume_token(FINALLY);
5131      Block();
5132    } catch (Throwable JavaDoc jjte000) {
5133      if (jjtc000) {
5134        jjtree.clearNodeScope(jjtn000);
5135        jjtc000 = false;
5136      } else {
5137        jjtree.popNode();
5138      }
5139      if (jjte000 instanceof RuntimeException JavaDoc) {
5140        {if (true) throw (RuntimeException JavaDoc)jjte000;}
5141      }
5142      if (jjte000 instanceof ParseException) {
5143        {if (true) throw (ParseException)jjte000;}
5144      }
5145      {if (true) throw (Error JavaDoc)jjte000;}
5146    } finally {
5147      if (jjtc000) {
5148        jjtree.closeNodeScope(jjtn000, true);
5149      }
5150    }
5151  }
5152
5153  final public void AssertStatement() throws ParseException {
5154 /*@bgen(jjtree) AssertStatement */
5155    ASTAssertStatement jjtn000 = new ASTAssertStatement(this, JJTASSERTSTATEMENT);
5156    boolean jjtc000 = true;
5157    jjtree.openNodeScope(jjtn000);if (isJDK13) {
5158        throw new ParseException("Can't use 'assert' as a keyword when running in JDK 1.3 mode!");
5159    }
5160    try {
5161      jj_consume_token(IDENTIFIER);
5162      Expression();
5163      switch (jj_nt.kind) {
5164      case COLON:
5165        jj_consume_token(COLON);
5166        Expression();
5167        break;
5168      default:
5169        jj_la1[124] = jj_gen;
5170        ;
5171      }
5172      jj_consume_token(SEMICOLON);
5173    } catch (Throwable JavaDoc jjte000) {
5174    if (jjtc000) {
5175      jjtree.clearNodeScope(jjtn000);
5176      jjtc000 = false;
5177    } else {
5178      jjtree.popNode();
5179    }
5180    if (jjte000 instanceof RuntimeException JavaDoc) {
5181      {if (true) throw (RuntimeException JavaDoc)jjte000;}
5182    }
5183    if (jjte000 instanceof ParseException) {
5184      {if (true) throw (ParseException)jjte000;}
5185    }
5186    {if (true) throw (Error JavaDoc)jjte000;}
5187    } finally {
5188    if (jjtc000) {
5189      jjtree.closeNodeScope(jjtn000, true);
5190    }
5191    }
5192  }
5193
5194/* We use productions to match >>>, >> and > so that we can keep the
5195 * type declaration syntax with generics clean
5196 */

5197  final public void RUNSIGNEDSHIFT() throws ParseException {
5198 /*@bgen(jjtree) RUNSIGNEDSHIFT */
5199  ASTRUNSIGNEDSHIFT jjtn000 = new ASTRUNSIGNEDSHIFT(this, JJTRUNSIGNEDSHIFT);
5200  boolean jjtc000 = true;
5201  jjtree.openNodeScope(jjtn000);
5202    try {
5203      if (getToken(1).kind == GT &&
5204                      ((Token.GTToken)getToken(1)).realKind == RUNSIGNEDSHIFT) {
5205
5206      } else {
5207        jj_consume_token(-1);
5208        throw new ParseException();
5209      }
5210      jj_consume_token(GT);
5211      jj_consume_token(GT);
5212      jj_consume_token(GT);
5213    } finally {
5214    if (jjtc000) {
5215      jjtree.closeNodeScope(jjtn000, true);
5216    }
5217    }
5218  }
5219
5220  final public void RSIGNEDSHIFT() throws ParseException {
5221 /*@bgen(jjtree) RSIGNEDSHIFT */
5222  ASTRSIGNEDSHIFT jjtn000 = new ASTRSIGNEDSHIFT(this, JJTRSIGNEDSHIFT);
5223  boolean jjtc000 = true;
5224  jjtree.openNodeScope(jjtn000);
5225    try {
5226      if (getToken(1).kind == GT &&
5227                      ((Token.GTToken)getToken(1)).realKind == RSIGNEDSHIFT) {
5228
5229      } else {
5230        jj_consume_token(-1);
5231        throw new ParseException();
5232      }
5233      jj_consume_token(GT);
5234      jj_consume_token(GT);
5235    } finally {
5236    if (jjtc000) {
5237      jjtree.closeNodeScope(jjtn000, true);
5238    }
5239    }
5240  }
5241
5242/* Annotation syntax follows. */
5243  final public void Annotation() throws ParseException {
5244 /*@bgen(jjtree) Annotation */
5245  ASTAnnotation jjtn000 = new ASTAnnotation(this, JJTANNOTATION);
5246  boolean jjtc000 = true;
5247  jjtree.openNodeScope(jjtn000);
5248    try {
5249      if (jj_2_47(2147483647)) {
5250        NormalAnnotation();
5251      } else if (jj_2_48(2147483647)) {
5252        SingleMemberAnnotation();
5253      } else {
5254        switch (jj_nt.kind) {
5255        case AT:
5256          MarkerAnnotation();
5257          break;
5258        default:
5259          jj_la1[125] = jj_gen;
5260          jj_consume_token(-1);
5261          throw new ParseException();
5262        }
5263      }
5264    } catch (Throwable JavaDoc jjte000) {
5265     if (jjtc000) {
5266       jjtree.clearNodeScope(jjtn000);
5267       jjtc000 = false;
5268     } else {
5269       jjtree.popNode();
5270     }
5271     if (jjte000 instanceof RuntimeException JavaDoc) {
5272       {if (true) throw (RuntimeException JavaDoc)jjte000;}
5273     }
5274     if (jjte000 instanceof ParseException) {
5275       {if (true) throw (ParseException)jjte000;}
5276     }
5277     {if (true) throw (Error JavaDoc)jjte000;}
5278    } finally {
5279     if (jjtc000) {
5280       jjtree.closeNodeScope(jjtn000, true);
5281     }
5282    }
5283  }
5284
5285  final public void NormalAnnotation() throws ParseException {
5286 /*@bgen(jjtree) NormalAnnotation */
5287  ASTNormalAnnotation jjtn000 = new ASTNormalAnnotation(this, JJTNORMALANNOTATION);
5288  boolean jjtc000 = true;
5289  jjtree.openNodeScope(jjtn000);
5290    try {
5291      jj_consume_token(AT);
5292      Name();
5293      jj_consume_token(LPAREN);
5294      switch (jj_nt.kind) {
5295      case IDENTIFIER:
5296        MemberValuePairs();
5297        break;
5298      default:
5299        jj_la1[126] = jj_gen;
5300        ;
5301      }
5302      jj_consume_token(RPAREN);
5303    } catch (Throwable JavaDoc jjte000) {
5304     if (jjtc000) {
5305       jjtree.clearNodeScope(jjtn000);
5306       jjtc000 = false;
5307     } else {
5308       jjtree.popNode();
5309     }
5310     if (jjte000 instanceof RuntimeException JavaDoc) {
5311       {if (true) throw (RuntimeException JavaDoc)jjte000;}
5312     }
5313     if (jjte000 instanceof ParseException) {
5314       {if (true) throw (ParseException)jjte000;}
5315     }
5316     {if (true) throw (Error JavaDoc)jjte000;}
5317    } finally {
5318     if (jjtc000) {
5319       jjtree.closeNodeScope(jjtn000, true);
5320     }
5321    }
5322  }
5323
5324  final public void MarkerAnnotation() throws ParseException {
5325 /*@bgen(jjtree) MarkerAnnotation */
5326  ASTMarkerAnnotation jjtn000 = new ASTMarkerAnnotation(this, JJTMARKERANNOTATION);
5327  boolean jjtc000 = true;
5328  jjtree.openNodeScope(jjtn000);
5329    try {
5330      jj_consume_token(AT);
5331      Name();
5332    } catch (Throwable JavaDoc jjte000) {
5333    if (jjtc000) {
5334      jjtree.clearNodeScope(jjtn000);
5335      jjtc000 = false;
5336    } else {
5337      jjtree.popNode();
5338    }
5339    if (jjte000 instanceof RuntimeException JavaDoc) {
5340      {if (true) throw (RuntimeException JavaDoc)jjte000;}
5341    }
5342    if (jjte000 instanceof ParseException) {
5343      {if (true) throw (ParseException)jjte000;}
5344    }
5345    {if (true) throw (Error JavaDoc)jjte000;}
5346    } finally {
5347    if (jjtc000) {
5348      jjtree.closeNodeScope(jjtn000, true);
5349    }
5350    }
5351  }
5352
5353  final public void SingleMemberAnnotation() throws ParseException {
5354 /*@bgen(jjtree) SingleMemberAnnotation */
5355  ASTSingleMemberAnnotation jjtn000 = new ASTSingleMemberAnnotation(this, JJTSINGLEMEMBERANNOTATION);
5356  boolean jjtc000 = true;
5357  jjtree.openNodeScope(jjtn000);
5358    try {
5359      jj_consume_token(AT);
5360      Name();
5361      jj_consume_token(LPAREN);
5362      MemberValue();
5363      jj_consume_token(RPAREN);
5364    } catch (Throwable JavaDoc jjte000) {
5365    if (jjtc000) {
5366      jjtree.clearNodeScope(jjtn000);
5367      jjtc000 = false;
5368    } else {
5369      jjtree.popNode();
5370    }
5371    if (jjte000 instanceof RuntimeException JavaDoc) {
5372      {if (true) throw (RuntimeException JavaDoc)jjte000;}
5373    }
5374    if (jjte000 instanceof ParseException) {
5375      {if (true) throw (ParseException)jjte000;}
5376    }
5377    {if (true) throw (Error JavaDoc)jjte000;}
5378    } finally {
5379    if (jjtc000) {
5380      jjtree.closeNodeScope(jjtn000, true);
5381    }
5382    }
5383  }
5384
5385  final public void MemberValuePairs() throws ParseException {
5386 /*@bgen(jjtree) MemberValuePairs */
5387  ASTMemberValuePairs jjtn000 = new ASTMemberValuePairs(this, JJTMEMBERVALUEPAIRS);
5388  boolean jjtc000 = true;
5389  jjtree.openNodeScope(jjtn000);
5390    try {
5391      MemberValuePair();
5392      label_49:
5393      while (true) {
5394        switch (jj_nt.kind) {
5395        case COMMA:
5396          ;
5397          break;
5398        default:
5399          jj_la1[127] = jj_gen;
5400          break label_49;
5401        }
5402        jj_consume_token(COMMA);
5403        MemberValuePair();
5404      }
5405    } catch (Throwable JavaDoc jjte000) {
5406     if (jjtc000) {
5407       jjtree.clearNodeScope(jjtn000);
5408       jjtc000 = false;
5409     } else {
5410       jjtree.popNode();
5411     }
5412     if (jjte000 instanceof RuntimeException JavaDoc) {
5413       {if (true) throw (RuntimeException JavaDoc)jjte000;}
5414     }
5415     if (jjte000 instanceof ParseException) {
5416       {if (true) throw (ParseException)jjte000;}
5417     }
5418     {if (true) throw (Error JavaDoc)jjte000;}
5419    } finally {
5420     if (jjtc000) {
5421       jjtree.closeNodeScope(jjtn000, true);
5422     }
5423    }
5424  }
5425
5426  final public void MemberValuePair() throws ParseException {
5427 /*@bgen(jjtree) MemberValuePair */
5428 ASTMemberValuePair jjtn000 = new ASTMemberValuePair(this, JJTMEMBERVALUEPAIR);
5429 boolean jjtc000 = true;
5430 jjtree.openNodeScope(jjtn000);Token t;
5431    try {
5432      t = jj_consume_token(IDENTIFIER);
5433                     jjtn000.setImage(t.image);
5434      jj_consume_token(ASSIGN);
5435      MemberValue();
5436    } catch (Throwable JavaDoc jjte000) {
5437      if (jjtc000) {
5438        jjtree.clearNodeScope(jjtn000);
5439        jjtc000 = false;
5440      } else {
5441        jjtree.popNode();
5442      }
5443      if (jjte000 instanceof RuntimeException JavaDoc) {
5444        {if (true) throw (RuntimeException JavaDoc)jjte000;}
5445      }
5446      if (jjte000 instanceof ParseException) {
5447        {if (true) throw (ParseException)jjte000;}
5448      }
5449      {if (true) throw (Error JavaDoc)jjte000;}
5450    } finally {
5451      if (jjtc000) {
5452        jjtree.closeNodeScope(jjtn000, true);
5453      }
5454    }
5455  }
5456
5457  final public void MemberValue() throws ParseException {
5458 /*@bgen(jjtree) MemberValue */
5459  ASTMemberValue jjtn000 = new ASTMemberValue(this, JJTMEMBERVALUE);
5460  boolean jjtc000 = true;
5461  jjtree.openNodeScope(jjtn000);
5462    try {
5463      switch (jj_nt.kind) {
5464      case AT:
5465        Annotation();
5466        break;
5467      case LBRACE:
5468        MemberValueArrayInitializer();
5469        break;
5470      case BOOLEAN:
5471      case BYTE:
5472      case CHAR:
5473      case DOUBLE:
5474      case FALSE:
5475      case FLOAT:
5476      case INT:
5477      case LONG:
5478      case NEW:
5479      case NULL:
5480      case SHORT:
5481      case SUPER:
5482      case THIS:
5483      case TRUE:
5484      case VOID:
5485      case INTEGER_LITERAL:
5486      case FLOATING_POINT_LITERAL:
5487      case HEX_FLOATING_POINT_LITERAL:
5488      case CHARACTER_LITERAL:
5489      case STRING_LITERAL:
5490      case IDENTIFIER:
5491      case LPAREN:
5492      case BANG:
5493      case TILDE:
5494      case INCR:
5495      case DECR:
5496      case PLUS:
5497      case MINUS:
5498        ConditionalExpression();
5499        break;
5500      default:
5501        jj_la1[128] = jj_gen;
5502        jj_consume_token(-1);
5503        throw new ParseException();
5504      }
5505    } catch (Throwable JavaDoc jjte000) {
5506     if (jjtc000) {
5507       jjtree.clearNodeScope(jjtn000);
5508       jjtc000 = false;
5509     } else {
5510       jjtree.popNode();
5511     }
5512     if (jjte000 instanceof RuntimeException JavaDoc) {
5513       {if (true) throw (RuntimeException JavaDoc)jjte000;}
5514     }
5515     if (jjte000 instanceof ParseException) {
5516       {if (true) throw (ParseException)jjte000;}
5517     }
5518     {if (true) throw (Error JavaDoc)jjte000;}
5519    } finally {
5520     if (jjtc000) {
5521       jjtree.closeNodeScope(jjtn000, true);
5522     }
5523    }
5524  }
5525
5526  final public void MemberValueArrayInitializer() throws ParseException {
5527 /*@bgen(jjtree) MemberValueArrayInitializer */
5528  ASTMemberValueArrayInitializer jjtn000 = new ASTMemberValueArrayInitializer(this, JJTMEMBERVALUEARRAYINITIALIZER);
5529  boolean jjtc000 = true;
5530  jjtree.openNodeScope(jjtn000);
5531    try {
5532      jj_consume_token(LBRACE);
5533      switch (jj_nt.kind) {
5534      case BOOLEAN:
5535      case BYTE:
5536      case CHAR:
5537      case DOUBLE:
5538      case FALSE:
5539      case FLOAT:
5540      case INT:
5541      case LONG:
5542      case NEW:
5543      case NULL:
5544      case SHORT:
5545      case SUPER:
5546      case THIS:
5547      case TRUE:
5548      case VOID:
5549      case INTEGER_LITERAL:
5550      case FLOATING_POINT_LITERAL:
5551      case HEX_FLOATING_POINT_LITERAL:
5552      case CHARACTER_LITERAL:
5553      case STRING_LITERAL:
5554      case IDENTIFIER:
5555      case LPAREN:
5556      case LBRACE:
5557      case AT:
5558      case BANG:
5559      case TILDE:
5560      case INCR:
5561      case DECR:
5562      case PLUS:
5563      case MINUS:
5564        MemberValue();
5565        label_50:
5566        while (true) {
5567          if (jj_2_49(2)) {
5568            ;
5569          } else {
5570            break label_50;
5571          }
5572          jj_consume_token(COMMA);
5573          MemberValue();
5574        }
5575        switch (jj_nt.kind) {
5576        case COMMA:
5577          jj_consume_token(COMMA);
5578          break;
5579        default:
5580          jj_la1[129] = jj_gen;
5581          ;
5582        }
5583        break;
5584      default:
5585        jj_la1[130] = jj_gen;
5586        ;
5587      }
5588      jj_consume_token(RBRACE);
5589    } catch (Throwable JavaDoc jjte000) {
5590    if (jjtc000) {
5591      jjtree.clearNodeScope(jjtn000);
5592      jjtc000 = false;
5593    } else {
5594      jjtree.popNode();
5595    }
5596    if (jjte000 instanceof RuntimeException JavaDoc) {
5597      {if (true) throw (RuntimeException JavaDoc)jjte000;}
5598    }
5599    if (jjte000 instanceof ParseException) {
5600      {if (true) throw (ParseException)jjte000;}
5601    }
5602    {if (true) throw (Error JavaDoc)jjte000;}
5603    } finally {
5604    if (jjtc000) {
5605      jjtree.closeNodeScope(jjtn000, true);
5606    }
5607    }
5608  }
5609
5610/* Annotation Types. */
5611  final public void AnnotationTypeDeclaration(int modifiers) throws ParseException {
5612 /*@bgen(jjtree) AnnotationTypeDeclaration */
5613ASTAnnotationTypeDeclaration jjtn000 = new ASTAnnotationTypeDeclaration(this, JJTANNOTATIONTYPEDECLARATION);
5614boolean jjtc000 = true;
5615jjtree.openNodeScope(jjtn000);Token t;
5616jjtn000.setModifiers(modifiers);
5617    try {
5618      jj_consume_token(AT);
5619      jj_consume_token(INTERFACE);
5620      t = jj_consume_token(IDENTIFIER);
5621                                  jjtn000.setImage(t.image);
5622      AnnotationTypeBody();
5623    } catch (Throwable JavaDoc jjte000) {
5624    if (jjtc000) {
5625      jjtree.clearNodeScope(jjtn000);
5626      jjtc000 = false;
5627    } else {
5628      jjtree.popNode();
5629    }
5630    if (jjte000 instanceof RuntimeException JavaDoc) {
5631      {if (true) throw (RuntimeException JavaDoc)jjte000;}
5632    }
5633    if (jjte000 instanceof ParseException) {
5634      {if (true) throw (ParseException)jjte000;}
5635    }
5636    {if (true) throw (Error JavaDoc)jjte000;}
5637    } finally {
5638    if (jjtc000) {
5639      jjtree.closeNodeScope(jjtn000, true);
5640    }
5641    }
5642  }
5643
5644  final public void AnnotationTypeBody() throws ParseException {
5645 /*@bgen(jjtree) AnnotationTypeBody */
5646  ASTAnnotationTypeBody jjtn000 = new ASTAnnotationTypeBody(this, JJTANNOTATIONTYPEBODY);
5647  boolean jjtc000 = true;
5648  jjtree.openNodeScope(jjtn000);
5649    try {
5650      jj_consume_token(LBRACE);
5651      label_51:
5652      while (true) {
5653        switch (jj_nt.kind) {
5654        case ABSTRACT:
5655        case BOOLEAN:
5656        case BYTE:
5657        case CHAR:
5658        case CLASS:
5659        case DOUBLE:
5660        case FINAL:
5661        case FLOAT:
5662        case INT:
5663        case INTERFACE:
5664        case LONG:
5665        case NATIVE:
5666        case PRIVATE:
5667        case PROTECTED:
5668        case PUBLIC:
5669        case SHORT:
5670        case STATIC:
5671        case SYNCHRONIZED:
5672        case TRANSIENT:
5673        case VOLATILE:
5674        case STRICTFP:
5675        case IDENTIFIER:
5676        case SEMICOLON:
5677        case AT:
5678          ;
5679          break;
5680        default:
5681          jj_la1[131] = jj_gen;
5682          break label_51;
5683        }
5684        AnnotationTypeMemberDeclaration();
5685      }
5686      jj_consume_token(RBRACE);
5687    } catch (Throwable JavaDoc jjte000) {
5688    if (jjtc000) {
5689      jjtree.clearNodeScope(jjtn000);
5690      jjtc000 = false;
5691    } else {
5692      jjtree.popNode();
5693    }
5694    if (jjte000 instanceof RuntimeException JavaDoc) {
5695      {if (true) throw (RuntimeException JavaDoc)jjte000;}
5696    }
5697    if (jjte000 instanceof ParseException) {
5698      {if (true) throw (ParseException)jjte000;}
5699    }
5700    {if (true) throw (Error JavaDoc)jjte000;}
5701    } finally {
5702    if (jjtc000) {
5703      jjtree.closeNodeScope(jjtn000, true);
5704    }
5705    }
5706  }
5707
5708  final public void AnnotationTypeMemberDeclaration() throws ParseException {
5709 /*@bgen(jjtree) AnnotationTypeMemberDeclaration */
5710   ASTAnnotationTypeMemberDeclaration jjtn000 = new ASTAnnotationTypeMemberDeclaration(this, JJTANNOTATIONTYPEMEMBERDECLARATION);
5711   boolean jjtc000 = true;
5712   jjtree.openNodeScope(jjtn000);int modifiers;
5713    try {
5714      switch (jj_nt.kind) {
5715      case ABSTRACT:
5716      case BOOLEAN:
5717      case BYTE:
5718      case CHAR:
5719      case CLASS:
5720      case DOUBLE:
5721      case FINAL:
5722      case FLOAT:
5723      case INT:
5724      case INTERFACE:
5725      case LONG:
5726      case NATIVE:
5727      case PRIVATE:
5728      case PROTECTED:
5729      case PUBLIC:
5730      case SHORT:
5731      case STATIC:
5732      case SYNCHRONIZED:
5733      case TRANSIENT:
5734      case VOLATILE:
5735      case STRICTFP:
5736      case IDENTIFIER:
5737      case AT:
5738        modifiers = Modifiers();
5739        if (jj_2_50(2147483647)) {
5740          Type();
5741          jj_consume_token(IDENTIFIER);
5742          jj_consume_token(LPAREN);
5743          jj_consume_token(RPAREN);
5744          switch (jj_nt.kind) {
5745          case _DEFAULT:
5746            DefaultValue();
5747            break;
5748          default:
5749            jj_la1[132] = jj_gen;
5750            ;
5751          }
5752          jj_consume_token(SEMICOLON);
5753        } else {
5754          switch (jj_nt.kind) {
5755          case ABSTRACT:
5756          case CLASS:
5757          case FINAL:
5758          case INTERFACE:
5759            ClassOrInterfaceDeclaration(modifiers);
5760            break;
5761          default:
5762            jj_la1[133] = jj_gen;
5763            if (jj_2_51(2147483647)) {
5764              EnumDeclaration(modifiers);
5765            } else {
5766              switch (jj_nt.kind) {
5767              case AT:
5768                AnnotationTypeDeclaration(modifiers);
5769                break;
5770              case BOOLEAN:
5771              case BYTE:
5772              case CHAR:
5773              case DOUBLE:
5774              case FLOAT:
5775              case INT:
5776              case LONG:
5777              case SHORT:
5778              case IDENTIFIER:
5779                FieldDeclaration(modifiers);
5780                break;
5781              default:
5782                jj_la1[134] = jj_gen;
5783                jj_consume_token(-1);
5784                throw new ParseException();
5785              }
5786            }
5787          }
5788        }
5789        break;
5790      case SEMICOLON:
5791        jj_consume_token(SEMICOLON);
5792        break;
5793      default:
5794        jj_la1[135] = jj_gen;
5795        jj_consume_token(-1);
5796        throw new ParseException();
5797      }
5798    } catch (Throwable JavaDoc jjte000) {
5799   if (jjtc000) {
5800     jjtree.clearNodeScope(jjtn000);
5801     jjtc000 = false;
5802   } else {
5803     jjtree.popNode();
5804   }
5805   if (jjte000 instanceof RuntimeException JavaDoc) {
5806     {if (true) throw (RuntimeException JavaDoc)jjte000;}
5807   }
5808   if (jjte000 instanceof ParseException) {
5809     {if (true) throw (ParseException)jjte000;}
5810   }
5811   {if (true) throw (Error JavaDoc)jjte000;}
5812    } finally {
5813   if (jjtc000) {
5814     jjtree.closeNodeScope(jjtn000, true);
5815   }
5816    }
5817  }
5818
5819  final public void DefaultValue() throws ParseException {
5820 /*@bgen(jjtree) DefaultValue */
5821  ASTDefaultValue jjtn000 = new ASTDefaultValue(this, JJTDEFAULTVALUE);
5822  boolean jjtc000 = true;
5823  jjtree.openNodeScope(jjtn000);
5824    try {
5825      jj_consume_token(_DEFAULT);
5826      MemberValue();
5827    } catch (Throwable JavaDoc jjte000) {
5828    if (jjtc000) {
5829      jjtree.clearNodeScope(jjtn000);
5830      jjtc000 = false;
5831    } else {
5832      jjtree.popNode();
5833    }
5834    if (jjte000 instanceof RuntimeException JavaDoc) {
5835      {if (true) throw (RuntimeException JavaDoc)jjte000;}
5836    }
5837    if (jjte000 instanceof ParseException) {
5838      {if (true) throw (ParseException)jjte000;}
5839    }
5840    {if (true) throw (Error JavaDoc)jjte000;}
5841    } finally {
5842    if (jjtc000) {
5843      jjtree.closeNodeScope(jjtn000, true);
5844    }
5845    }
5846  }
5847
5848  final private boolean jj_2_1(int xla) {
5849    jj_la = xla; jj_lastpos = jj_scanpos = token;
5850    try { return !jj_3_1(); }
5851    catch(LookaheadSuccess ls) { return true; }
5852    finally { jj_save(0, xla); }
5853  }
5854
5855  final private boolean jj_2_2(int xla) {
5856    jj_la = xla; jj_lastpos = jj_scanpos = token;
5857    try { return !jj_3_2(); }
5858    catch(LookaheadSuccess ls) { return true; }
5859    finally { jj_save(1, xla); }
5860  }
5861
5862  final private boolean jj_2_3(int xla) {
5863    jj_la = xla; jj_lastpos = jj_scanpos = token;
5864    try { return !jj_3_3(); }
5865    catch(LookaheadSuccess ls) { return true; }
5866    finally { jj_save(2, xla); }
5867  }
5868
5869  final private boolean jj_2_4(int xla) {
5870    jj_la = xla; jj_lastpos = jj_scanpos = token;
5871    try { return !jj_3_4(); }
5872    catch(LookaheadSuccess ls) { return true; }
5873    finally { jj_save(3, xla); }
5874  }
5875
5876  final private boolean jj_2_5(int xla) {
5877    jj_la = xla; jj_lastpos = jj_scanpos = token;
5878    try { return !jj_3_5(); }
5879    catch(LookaheadSuccess ls) { return true; }
5880    finally { jj_save(4, xla); }
5881  }
5882
5883  final private boolean jj_2_6(int xla) {
5884    jj_la = xla; jj_lastpos = jj_scanpos = token;
5885    try { return !jj_3_6(); }
5886    catch(LookaheadSuccess ls) { return true; }
5887    finally { jj_save(5, xla); }
5888  }
5889
5890  final private boolean jj_2_7(int xla) {
5891    jj_la = xla; jj_lastpos = jj_scanpos = token;
5892    try { return !jj_3_7(); }
5893    catch(LookaheadSuccess ls) { return true; }
5894    finally { jj_save(6, xla); }
5895  }
5896
5897  final private boolean jj_2_8(int xla) {
5898    jj_la = xla; jj_lastpos = jj_scanpos = token;
5899    try { return !jj_3_8(); }
5900    catch(LookaheadSuccess ls) { return true; }
5901    finally { jj_save(7, xla); }
5902  }
5903
5904  final private boolean jj_2_9(int xla) {
5905    jj_la = xla; jj_lastpos = jj_scanpos = token;
5906    try { return !jj_3_9(); }
5907    catch(LookaheadSuccess ls) { return true; }
5908    finally { jj_save(8, xla); }
5909  }
5910
5911  final private boolean jj_2_10(int xla) {
5912    jj_la = xla; jj_lastpos = jj_scanpos = token;
5913    try { return !jj_3_10(); }
5914    catch(LookaheadSuccess ls) { return true; }
5915    finally { jj_save(9, xla); }
5916  }
5917
5918  final private boolean jj_2_11(int xla) {
5919    jj_la = xla; jj_lastpos = jj_scanpos = token;
5920    try { return !jj_3_11(); }
5921    catch(LookaheadSuccess ls) { return true; }
5922    finally { jj_save(10, xla); }
5923  }
5924
5925  final private boolean jj_2_12(int xla) {
5926    jj_la = xla; jj_lastpos = jj_scanpos = token;
5927    try { return !jj_3_12(); }
5928    catch(LookaheadSuccess ls) { return true; }
5929    finally { jj_save(11, xla); }
5930  }
5931
5932  final private boolean jj_2_13(int xla) {
5933    jj_la = xla; jj_lastpos = jj_scanpos = token;
5934    try { return !jj_3_13(); }
5935    catch(LookaheadSuccess ls) { return true; }
5936    finally { jj_save(12, xla); }
5937  }
5938
5939  final private boolean jj_2_14(int xla) {
5940    jj_la = xla; jj_lastpos = jj_scanpos = token;
5941    try { return !jj_3_14(); }
5942    catch(LookaheadSuccess ls) { return true; }
5943    finally { jj_save(13, xla); }
5944  }
5945
5946  final private boolean jj_2_15(int xla) {
5947    jj_la = xla; jj_lastpos = jj_scanpos = token;
5948    try { return !jj_3_15(); }
5949    catch(LookaheadSuccess ls) { return true; }
5950    finally { jj_save(14, xla); }
5951  }
5952
5953  final private boolean jj_2_16(int xla) {
5954    jj_la = xla; jj_lastpos = jj_scanpos = token;
5955    try { return !jj_3_16(); }
5956    catch(LookaheadSuccess ls) { return true; }
5957    finally { jj_save(15, xla); }
5958  }
5959
5960  final private boolean jj_2_17(int xla) {
5961    jj_la = xla; jj_lastpos = jj_scanpos = token;
5962    try { return !jj_3_17(); }
5963    catch(LookaheadSuccess ls) { return true; }
5964    finally { jj_save(16, xla); }
5965  }
5966
5967  final private boolean jj_2_18(int xla) {
5968    jj_la = xla; jj_lastpos = jj_scanpos = token;
5969    try { return !jj_3_18(); }
5970    catch(LookaheadSuccess ls) { return true; }
5971    finally { jj_save(17, xla); }
5972  }
5973
5974  final private boolean jj_2_19(int xla) {
5975    jj_la = xla; jj_lastpos = jj_scanpos = token;
5976    try { return !jj_3_19(); }
5977    catch(LookaheadSuccess ls) { return true; }
5978    finally { jj_save(18, xla); }
5979  }
5980
5981  final private boolean jj_2_20(int xla) {
5982    jj_la = xla; jj_lastpos = jj_scanpos = token;
5983    try { return !jj_3_20(); }
5984    catch(LookaheadSuccess ls) { return true; }
5985    finally { jj_save(19, xla); }
5986  }
5987
5988  final private boolean jj_2_21(int xla) {
5989    jj_la = xla; jj_lastpos = jj_scanpos = token;
5990    try { return !jj_3_21(); }
5991    catch(LookaheadSuccess ls) { return true; }
5992    finally { jj_save(20, xla); }
5993  }
5994
5995  final private boolean jj_2_22(int xla) {
5996    jj_la = xla; jj_lastpos = jj_scanpos = token;
5997    try { return !jj_3_22(); }
5998    catch(LookaheadSuccess ls) { return true; }
5999    finally { jj_save(21, xla); }
6000  }
6001
6002  final private boolean jj_2_23(int xla) {
6003    jj_la = xla; jj_lastpos = jj_scanpos = token;
6004    try { return !jj_3_23(); }
6005    catch(LookaheadSuccess ls) { return true; }
6006    finally { jj_save(22, xla); }
6007  }
6008
6009  final private boolean jj_2_24(int xla) {
6010    jj_la = xla; jj_lastpos = jj_scanpos = token;
6011    try { return !jj_3_24(); }
6012    catch(LookaheadSuccess ls) { return true; }
6013    finally { jj_save(23, xla); }
6014  }
6015
6016  final private boolean jj_2_25(int xla) {
6017    jj_la = xla; jj_lastpos = jj_scanpos = token;
6018    try { return !jj_3_25(); }
6019    catch(LookaheadSuccess ls) { return true; }
6020    finally { jj_save(24, xla); }
6021  }
6022
6023  final private boolean jj_2_26(int xla) {
6024    jj_la = xla; jj_lastpos = jj_scanpos = token;
6025    try { return !jj_3_26(); }
6026    catch(LookaheadSuccess ls) { return true; }
6027    finally { jj_save(25, xla); }
6028  }
6029
6030  final private boolean jj_2_27(int xla) {
6031    jj_la = xla; jj_lastpos = jj_scanpos = token;
6032    try { return !jj_3_27(); }
6033    catch(LookaheadSuccess ls) { return true; }
6034    finally { jj_save(26, xla); }
6035  }
6036
6037  final private boolean jj_2_28(int xla) {
6038    jj_la = xla; jj_lastpos = jj_scanpos = token;
6039    try { return !jj_3_28(); }
6040    catch(LookaheadSuccess ls) { return true; }
6041    finally { jj_save(27, xla); }
6042  }
6043
6044  final private boolean jj_2_29(int xla) {
6045    jj_la = xla; jj_lastpos = jj_scanpos = token;
6046    try { return !jj_3_29(); }
6047    catch(LookaheadSuccess ls) { return true; }
6048    finally { jj_save(28, xla); }
6049  }
6050
6051  final private boolean jj_2_30(int xla) {
6052    jj_la = xla; jj_lastpos = jj_scanpos = token;
6053    try { return !jj_3_30(); }
6054    catch(LookaheadSuccess ls) { return true; }
6055    finally { jj_save(29, xla); }
6056  }
6057
6058  final private boolean jj_2_31(int xla) {
6059    jj_la = xla; jj_lastpos = jj_scanpos = token;
6060    try { return !jj_3_31(); }
6061    catch(LookaheadSuccess ls) { return true; }
6062    finally { jj_save(30, xla); }
6063  }
6064
6065  final private boolean jj_2_32(int xla) {
6066    jj_la = xla; jj_lastpos = jj_scanpos = token;
6067    try { return !jj_3_32(); }
6068    catch(LookaheadSuccess ls) { return true; }
6069    finally { jj_save(31, xla); }
6070  }
6071
6072  final private boolean jj_2_33(int xla) {
6073    jj_la = xla; jj_lastpos = jj_scanpos = token;
6074    try { return !jj_3_33(); }
6075    catch(LookaheadSuccess ls) { return true; }
6076    finally { jj_save(32, xla); }
6077  }
6078
6079  final private boolean jj_2_34(int xla) {
6080    jj_la = xla; jj_lastpos = jj_scanpos = token;
6081    try { return !jj_3_34(); }
6082    catch(LookaheadSuccess ls) { return true; }
6083    finally { jj_save(33, xla); }
6084  }
6085
6086  final private boolean jj_2_35(int xla) {
6087    jj_la = xla; jj_lastpos = jj_scanpos = token;
6088    try { return !jj_3_35(); }
6089    catch(LookaheadSuccess ls) { return true; }
6090    finally { jj_save(34, xla); }
6091  }
6092
6093  final private boolean jj_2_36(int xla) {
6094    jj_la = xla; jj_lastpos = jj_scanpos = token;
6095    try { return !jj_3_36(); }
6096    catch(LookaheadSuccess ls) { return true; }
6097    finally { jj_save(35, xla); }
6098  }
6099
6100  final private boolean jj_2_37(int xla) {
6101    jj_la = xla; jj_lastpos = jj_scanpos = token;
6102    try { return !jj_3_37(); }
6103    catch(LookaheadSuccess ls) { return true; }
6104    finally { jj_save(36, xla); }
6105  }
6106
6107  final private boolean jj_2_38(int xla) {
6108    jj_la = xla; jj_lastpos = jj_scanpos = token;
6109    try { return !jj_3_38(); }
6110    catch(LookaheadSuccess ls) { return true; }
6111    finally { jj_save(37, xla); }
6112  }
6113
6114  final private boolean jj_2_39(int xla) {
6115    jj_la = xla; jj_lastpos = jj_scanpos = token;
6116    try { return !jj_3_39(); }
6117    catch(LookaheadSuccess ls) { return true; }
6118    finally { jj_save(38, xla); }
6119  }
6120
6121  final private boolean jj_2_40(int xla) {
6122    jj_la = xla; jj_lastpos = jj_scanpos = token;
6123    try { return !jj_3_40(); }
6124    catch(LookaheadSuccess ls) { return true; }
6125    finally { jj_save(39, xla); }
6126  }
6127
6128  final private boolean jj_2_41(int xla) {
6129    jj_la = xla; jj_lastpos = jj_scanpos = token;
6130    try { return !jj_3_41(); }
6131    catch(LookaheadSuccess ls) { return true; }
6132    finally { jj_save(40, xla); }
6133  }
6134
6135  final private boolean jj_2_42(int xla) {
6136    jj_la = xla; jj_lastpos = jj_scanpos = token;
6137    try { return !jj_3_42(); }
6138    catch(LookaheadSuccess ls) { return true; }
6139    finally { jj_save(41, xla); }
6140  }
6141
6142  final private boolean jj_2_43(int xla) {
6143    jj_la = xla; jj_lastpos = jj_scanpos = token;
6144    try { return !jj_3_43(); }
6145    catch(LookaheadSuccess ls) { return true; }
6146    finally { jj_save(42, xla); }
6147  }
6148
6149  final private boolean jj_2_44(int xla) {
6150    jj_la = xla; jj_lastpos = jj_scanpos = token;
6151    try { return !jj_3_44(); }
6152    catch(LookaheadSuccess ls) { return true; }
6153    finally { jj_save(43, xla); }
6154  }
6155
6156  final private boolean jj_2_45(int xla) {
6157    jj_la = xla; jj_lastpos = jj_scanpos = token;
6158    try { return !jj_3_45(); }
6159    catch(LookaheadSuccess ls) { return true; }
6160    finally { jj_save(44, xla); }
6161  }
6162
6163  final private boolean jj_2_46(int xla) {
6164    jj_la = xla; jj_lastpos = jj_scanpos = token;
6165    try { return !jj_3_46(); }
6166    catch(LookaheadSuccess ls) { return true; }
6167    finally { jj_save(45, xla); }
6168  }
6169
6170  final private boolean jj_2_47(int xla) {
6171    jj_la = xla; jj_lastpos = jj_scanpos = token;
6172    try { return !jj_3_47(); }
6173    catch(LookaheadSuccess ls) { return true; }
6174    finally { jj_save(46, xla); }
6175  }
6176
6177  final private boolean jj_2_48(int xla) {
6178    jj_la = xla; jj_lastpos = jj_scanpos = token;
6179    try { return !jj_3_48(); }
6180    catch(LookaheadSuccess ls) { return true; }
6181    finally { jj_save(47, xla); }
6182  }
6183
6184  final private boolean jj_2_49(int xla) {
6185    jj_la = xla; jj_lastpos = jj_scanpos = token;
6186    try { return !jj_3_49(); }
6187    catch(LookaheadSuccess ls) { return true; }
6188    finally { jj_save(48, xla); }
6189  }
6190
6191  final private boolean jj_2_50(int xla) {
6192    jj_la = xla; jj_lastpos = jj_scanpos = token;
6193    try { return !jj_3_50(); }
6194    catch(LookaheadSuccess ls) { return true; }
6195    finally { jj_save(49, xla); }
6196  }
6197
6198  final private boolean jj_2_51(int xla) {
6199    jj_la = xla; jj_lastpos = jj_scanpos = token;
6200    try { return !jj_3_51(); }
6201    catch(LookaheadSuccess ls) { return true; }
6202    finally { jj_save(50, xla); }
6203  }
6204
6205  final private boolean jj_3R_256() {
6206    if (jj_scan_token(SC_AND)) return true;
6207    if (jj_3R_220()) return true;
6208    return false;
6209  }
6210
6211  final private boolean jj_3R_257() {
6212    if (jj_3R_260()) return true;
6213    Token xsp;
6214    while (true) {
6215      xsp = jj_scanpos;
6216      if (jj_3R_274()) { jj_scanpos = xsp; break; }
6217    }
6218    return false;
6219  }
6220
6221  final private boolean jj_3R_238() {
6222    if (jj_scan_token(SC_OR)) return true;
6223    if (jj_3R_203()) return true;
6224    return false;
6225  }
6226
6227  final private boolean jj_3R_251() {
6228    if (jj_3R_257()) return true;
6229    Token xsp;
6230    while (true) {
6231      xsp = jj_scanpos;
6232      if (jj_3R_268()) { jj_scanpos = xsp; break; }
6233    }
6234    return false;
6235  }
6236
6237  final private boolean jj_3R_228() {
6238    if (jj_scan_token(HOOK)) return true;
6239    if (jj_3R_88()) return true;
6240    if (jj_scan_token(COLON)) return true;
6241    if (jj_3R_137()) return true;
6242    return false;
6243  }
6244
6245  final private boolean jj_3R_230() {
6246    if (jj_3R_251()) return true;
6247    Token xsp;
6248    while (true) {
6249      xsp = jj_scanpos;
6250      if (jj_3R_264()) { jj_scanpos = xsp; break; }
6251    }
6252    return false;
6253  }
6254
6255  final private boolean jj_3R_220() {
6256    if (jj_3R_230()) return true;
6257    Token xsp;
6258    while (true) {
6259      xsp = jj_scanpos;
6260      if (jj_3R_259()) { jj_scanpos = xsp; break; }
6261    }
6262    return false;
6263  }
6264
6265  final private boolean jj_3R_203() {
6266    if (jj_3R_220()) return true;
6267    Token xsp;
6268    while (true) {
6269      xsp = jj_scanpos;
6270      if (jj_3R_256()) { jj_scanpos = xsp; break; }
6271    }
6272    return false;
6273  }
6274
6275  final private boolean jj_3R_180() {
6276    if (jj_3R_203()) return true;
6277    Token xsp;
6278    while (true) {
6279      xsp = jj_scanpos;
6280      if (jj_3R_238()) { jj_scanpos = xsp; break; }
6281    }
6282    return false;
6283  }
6284
6285  final private boolean jj_3R_137() {
6286    if (jj_3R_180()) return true;
6287    Token xsp;
6288    xsp = jj_scanpos;
6289    if (jj_3R_228()) jj_scanpos = xsp;
6290    return false;
6291  }
6292
6293  final private boolean jj_3R_250() {
6294    if (jj_scan_token(ORASSIGN)) return true;
6295    return false;
6296  }
6297
6298  final private boolean jj_3R_249() {
6299    if (jj_scan_token(XORASSIGN)) return true;
6300    return false;
6301  }
6302
6303  final private boolean jj_3R_248() {
6304    if (jj_scan_token(ANDASSIGN)) return true;
6305    return false;
6306  }
6307
6308  final private boolean jj_3R_247() {
6309    if (jj_scan_token(RUNSIGNEDSHIFTASSIGN)) return true;
6310    return false;
6311  }
6312
6313  final private boolean jj_3R_246() {
6314    if (jj_scan_token(RSIGNEDSHIFTASSIGN)) return true;
6315    return false;
6316  }
6317
6318  final private boolean jj_3R_245() {
6319    if (jj_scan_token(LSHIFTASSIGN)) return true;
6320    return false;
6321  }
6322
6323  final private boolean jj_3R_244() {
6324    if (jj_scan_token(MINUSASSIGN)) return true;
6325    return false;
6326  }
6327
6328  final private boolean jj_3R_243() {
6329    if (jj_scan_token(PLUSASSIGN)) return true;
6330    return false;
6331  }
6332
6333  final private boolean jj_3R_242() {
6334    if (jj_scan_token(REMASSIGN)) return true;
6335    return false;
6336  }
6337
6338  final private boolean jj_3R_241() {
6339    if (jj_scan_token(SLASHASSIGN)) return true;
6340    return false;
6341  }
6342
6343  final private boolean jj_3R_240() {
6344    if (jj_scan_token(STARASSIGN)) return true;
6345    return false;
6346  }
6347
6348  final private boolean jj_3R_229() {
6349    Token xsp;
6350    xsp = jj_scanpos;
6351    if (jj_3R_239()) {
6352    jj_scanpos = xsp;
6353    if (jj_3R_240()) {
6354    jj_scanpos = xsp;
6355    if (jj_3R_241()) {
6356    jj_scanpos = xsp;
6357    if (jj_3R_242()) {
6358    jj_scanpos = xsp;
6359    if (jj_3R_243()) {
6360    jj_scanpos = xsp;
6361    if (jj_3R_244()) {
6362    jj_scanpos = xsp;
6363    if (jj_3R_245()) {
6364    jj_scanpos = xsp;
6365    if (jj_3R_246()) {
6366    jj_scanpos = xsp;
6367    if (jj_3R_247()) {
6368    jj_scanpos = xsp;
6369    if (jj_3R_248()) {
6370    jj_scanpos = xsp;
6371    if (jj_3R_249()) {
6372    jj_scanpos = xsp;
6373    if (jj_3R_250()) return true;
6374    }
6375    }
6376    }
6377    }
6378    }
6379    }
6380    }
6381    }
6382    }
6383    }
6384    }
6385    return false;
6386  }
6387
6388  final private boolean jj_3R_239() {
6389    if (jj_scan_token(ASSIGN)) return true;
6390    return false;
6391  }
6392
6393  final private boolean jj_3R_219() {
6394    if (jj_3R_229()) return true;
6395    if (jj_3R_88()) return true;
6396    return false;
6397  }
6398
6399  final private boolean jj_3R_88() {
6400    if (jj_3R_137()) return true;
6401    Token xsp;
6402    xsp = jj_scanpos;
6403    if (jj_3R_219()) jj_scanpos = xsp;
6404    return false;
6405  }
6406
6407  final private boolean jj_3R_329() {
6408    if (jj_scan_token(COMMA)) return true;
6409    if (jj_3R_94()) return true;
6410    return false;
6411  }
6412
6413  final private boolean jj_3R_314() {
6414    if (jj_3R_94()) return true;
6415    Token xsp;
6416    while (true) {
6417      xsp = jj_scanpos;
6418      if (jj_3R_329()) { jj_scanpos = xsp; break; }
6419    }
6420    return false;
6421  }
6422
6423  final private boolean jj_3_19() {
6424    if (jj_3R_78()) return true;
6425    return false;
6426  }
6427
6428  final private boolean jj_3_20() {
6429    if (jj_scan_token(DOT)) return true;
6430    if (jj_scan_token(IDENTIFIER)) return true;
6431    return false;
6432  }
6433
6434  final private boolean jj_3R_254() {
6435    if (jj_scan_token(COMMA)) return true;
6436    if (jj_3R_119()) return true;
6437    return false;
6438  }
6439
6440  final private boolean jj_3R_94() {
6441    if (jj_scan_token(IDENTIFIER)) return true;
6442    Token xsp;
6443    while (true) {
6444      xsp = jj_scanpos;
6445      if (jj_3_20()) { jj_scanpos = xsp; break; }
6446    }
6447    return false;
6448  }
6449
6450  final private boolean jj_3R_135() {
6451    if (jj_3R_70()) return true;
6452    return false;
6453  }
6454
6455  final private boolean jj_3R_85() {
6456    Token xsp;
6457    xsp = jj_scanpos;
6458    if (jj_scan_token(59)) {
6459    jj_scanpos = xsp;
6460    if (jj_3R_135()) return true;
6461    }
6462    return false;
6463  }
6464
6465  final private boolean jj_3R_131() {
6466    if (jj_scan_token(DOUBLE)) return true;
6467    return false;
6468  }
6469
6470  final private boolean jj_3R_130() {
6471    if (jj_scan_token(FLOAT)) return true;
6472    return false;
6473  }
6474
6475  final private boolean jj_3R_129() {
6476    if (jj_scan_token(LONG)) return true;
6477    return false;
6478  }
6479
6480  final private boolean jj_3R_128() {
6481    if (jj_scan_token(INT)) return true;
6482    return false;
6483  }
6484
6485  final private boolean jj_3R_127() {
6486    if (jj_scan_token(SHORT)) return true;
6487    return false;
6488  }
6489
6490  final private boolean jj_3R_126() {
6491    if (jj_scan_token(BYTE)) return true;
6492    return false;
6493  }
6494
6495  final private boolean jj_3R_125() {
6496    if (jj_scan_token(CHAR)) return true;
6497    return false;
6498  }
6499
6500  final private boolean jj_3R_124() {
6501    if (jj_scan_token(BOOLEAN)) return true;
6502    return false;
6503  }
6504
6505  final private boolean jj_3R_83() {
6506    Token xsp;
6507    xsp = jj_scanpos;
6508    if (jj_3R_124()) {
6509    jj_scanpos = xsp;
6510    if (jj_3R_125()) {
6511    jj_scanpos = xsp;
6512    if (jj_3R_126()) {
6513    jj_scanpos = xsp;
6514    if (jj_3R_127()) {
6515    jj_scanpos = xsp;
6516    if (jj_3R_128()) {
6517    jj_scanpos = xsp;
6518    if (jj_3R_129()) {
6519    jj_scanpos = xsp;
6520    if (jj_3R_130()) {
6521    jj_scanpos = xsp;
6522    if (jj_3R_131()) return true;
6523    }
6524    }
6525    }
6526    }
6527    }
6528    }
6529    }
6530    return false;
6531  }
6532
6533  final private boolean jj_3R_273() {
6534    if (jj_scan_token(SUPER)) return true;
6535    if (jj_3R_77()) return true;
6536    return false;
6537  }
6538
6539  final private boolean jj_3R_263() {
6540    if (jj_3R_267()) return true;
6541    return false;
6542  }
6543
6544  final private boolean jj_3R_267() {
6545    Token xsp;
6546    xsp = jj_scanpos;
6547    if (jj_3R_272()) {
6548    jj_scanpos = xsp;
6549    if (jj_3R_273()) return true;
6550    }
6551    return false;
6552  }
6553
6554  final private boolean jj_3R_272() {
6555    if (jj_scan_token(EXTENDS)) return true;
6556    if (jj_3R_77()) return true;
6557    return false;
6558  }
6559
6560  final private boolean jj_3_16() {
6561    if (jj_scan_token(LBRACKET)) return true;
6562    if (jj_scan_token(RBRACKET)) return true;
6563    return false;
6564  }
6565
6566  final private boolean jj_3R_178() {
6567    if (jj_scan_token(HOOK)) return true;
6568    Token xsp;
6569    xsp = jj_scanpos;
6570    if (jj_3R_263()) jj_scanpos = xsp;
6571    return false;
6572  }
6573
6574  final private boolean jj_3R_119() {
6575    Token xsp;
6576    xsp = jj_scanpos;
6577    if (jj_3R_177()) {
6578    jj_scanpos = xsp;
6579    if (jj_3R_178()) return true;
6580    }
6581    return false;
6582  }
6583
6584  final private boolean jj_3R_177() {
6585    if (jj_3R_77()) return true;
6586    return false;
6587  }
6588
6589  final private boolean jj_3R_78() {
6590    if (jj_scan_token(LT)) return true;
6591    if (jj_3R_119()) return true;
6592    Token xsp;
6593    while (true) {
6594      xsp = jj_scanpos;
6595      if (jj_3R_254()) { jj_scanpos = xsp; break; }
6596    }
6597    if (jj_scan_token(GT)) return true;
6598    return false;
6599  }
6600
6601  final private boolean jj_3_15() {
6602    if (jj_scan_token(LBRACKET)) return true;
6603    if (jj_scan_token(RBRACKET)) return true;
6604    return false;
6605  }
6606
6607  final private boolean jj_3_18() {
6608    if (jj_scan_token(DOT)) return true;
6609    if (jj_scan_token(IDENTIFIER)) return true;
6610    Token xsp;
6611    xsp = jj_scanpos;
6612    if (jj_3_19()) jj_scanpos = xsp;
6613    return false;
6614  }
6615
6616  final private boolean jj_3_17() {
6617    if (jj_3R_78()) return true;
6618    return false;
6619  }
6620
6621  final private boolean jj_3R_176() {
6622    if (jj_scan_token(IDENTIFIER)) return true;
6623    Token xsp;
6624    xsp = jj_scanpos;
6625    if (jj_3_17()) jj_scanpos = xsp;
6626    while (true) {
6627      xsp = jj_scanpos;
6628      if (jj_3_18()) { jj_scanpos = xsp; break; }
6629    }
6630    return false;
6631  }
6632
6633  final private boolean jj_3R_360() {
6634    if (jj_3R_370()) return true;
6635    return false;
6636  }
6637
6638  final private boolean jj_3R_118() {
6639    if (jj_3R_176()) return true;
6640    Token xsp;
6641    while (true) {
6642      xsp = jj_scanpos;
6643      if (jj_3_16()) { jj_scanpos = xsp; break; }
6644    }
6645    return false;
6646  }
6647
6648  final private boolean jj_3R_117() {
6649    if (jj_3R_83()) return true;
6650    Token xsp;
6651    if (jj_3_15()) return true;
6652    while (true) {
6653      xsp = jj_scanpos;
6654      if (jj_3_15()) { jj_scanpos = xsp; break; }
6655    }
6656    return false;
6657  }
6658
6659  final private boolean jj_3R_77() {
6660    Token xsp;
6661    xsp = jj_scanpos;
6662    if (jj_3R_117()) {
6663    jj_scanpos = xsp;
6664    if (jj_3R_118()) return true;
6665    }
6666    return false;
6667  }
6668
6669  final private boolean jj_3R_294() {
6670    if (jj_scan_token(THROWS)) return true;
6671    if (jj_3R_314()) return true;
6672    return false;
6673  }
6674
6675  final private boolean jj_3R_107() {
6676    if (jj_3R_83()) return true;
6677    return false;
6678  }
6679
6680  final private boolean jj_3_14() {
6681    if (jj_3R_77()) return true;
6682    return false;
6683  }
6684
6685  final private boolean jj_3R_70() {
6686    Token xsp;
6687    xsp = jj_scanpos;
6688    if (jj_3_14()) {
6689    jj_scanpos = xsp;
6690    if (jj_3R_107()) return true;
6691    }
6692    return false;
6693  }
6694
6695  final private boolean jj_3R_352() {
6696    if (jj_3R_97()) return true;
6697    return false;
6698  }
6699
6700  final private boolean jj_3_13() {
6701    if (jj_scan_token(THIS)) return true;
6702    if (jj_3R_76()) return true;
6703    if (jj_scan_token(SEMICOLON)) return true;
6704    return false;
6705  }
6706
6707  final private boolean jj_3R_285() {
6708    if (jj_scan_token(STATIC)) return true;
6709    return false;
6710  }
6711
6712  final private boolean jj_3R_276() {
6713    Token xsp;
6714    xsp = jj_scanpos;
6715    if (jj_3R_285()) jj_scanpos = xsp;
6716    if (jj_3R_181()) return true;
6717    return false;
6718  }
6719
6720  final private boolean jj_3_10() {
6721    if (jj_3R_73()) return true;
6722    return false;
6723  }
6724
6725  final private boolean jj_3_12() {
6726    if (jj_3R_75()) return true;
6727    if (jj_scan_token(DOT)) return true;
6728    if (jj_scan_token(SUPER)) return true;
6729    if (jj_scan_token(LPAREN)) return true;
6730    return false;
6731  }
6732
6733  final private boolean jj_3R_111() {
6734    Token xsp;
6735    xsp = jj_scanpos;
6736    if (jj_3_12()) jj_scanpos = xsp;
6737    xsp = jj_scanpos;
6738    if (jj_scan_token(50)) {
6739    jj_scanpos = xsp;
6740    if (jj_scan_token(53)) return true;
6741    }
6742    if (jj_3R_76()) return true;
6743    if (jj_scan_token(SEMICOLON)) return true;
6744    return false;
6745  }
6746
6747  final private boolean jj_3R_110() {
6748    if (jj_scan_token(THIS)) return true;
6749    if (jj_3R_76()) return true;
6750    if (jj_scan_token(SEMICOLON)) return true;
6751    return false;
6752  }
6753
6754  final private boolean jj_3R_73() {
6755    Token xsp;
6756    xsp = jj_scanpos;
6757    if (jj_3R_110()) {
6758    jj_scanpos = xsp;
6759    if (jj_3R_111()) return true;
6760    }
6761    return false;
6762  }
6763
6764  final private boolean jj_3R_328() {
6765    if (jj_scan_token(COMMA)) return true;
6766    if (jj_3R_327()) return true;
6767    return false;
6768  }
6769
6770  final private boolean jj_3_11() {
6771    if (jj_3R_74()) return true;
6772    return false;
6773  }
6774
6775  final private boolean jj_3R_295() {
6776    if (jj_3R_73()) return true;
6777    return false;
6778  }
6779
6780  final private boolean jj_3R_292() {
6781    if (jj_3R_106()) return true;
6782    return false;
6783  }
6784
6785  final private boolean jj_3R_286() {
6786    Token xsp;
6787    xsp = jj_scanpos;
6788    if (jj_3R_292()) jj_scanpos = xsp;
6789    if (jj_scan_token(IDENTIFIER)) return true;
6790    if (jj_3R_293()) return true;
6791    xsp = jj_scanpos;
6792    if (jj_3R_294()) jj_scanpos = xsp;
6793    if (jj_scan_token(LBRACE)) return true;
6794    xsp = jj_scanpos;
6795    if (jj_3R_295()) jj_scanpos = xsp;
6796    while (true) {
6797      xsp = jj_scanpos;
6798      if (jj_3_11()) { jj_scanpos = xsp; break; }
6799    }
6800    if (jj_scan_token(RBRACE)) return true;
6801    return false;
6802  }
6803
6804  final private boolean jj_3R_317() {
6805    if (jj_scan_token(LBRACKET)) return true;
6806    if (jj_scan_token(RBRACKET)) return true;
6807    return false;
6808  }
6809
6810  final private boolean jj_3R_300() {
6811    if (jj_scan_token(THROWS)) return true;
6812    if (jj_3R_314()) return true;
6813    return false;
6814  }
6815
6816  final private boolean jj_3R_341() {
6817    if (jj_scan_token(ELLIPSIS)) return true;
6818    return false;
6819  }
6820
6821  final private boolean jj_3R_351() {
6822    if (jj_scan_token(FINAL)) return true;
6823    return false;
6824  }
6825
6826  final private boolean jj_3R_340() {
6827    Token xsp;
6828    xsp = jj_scanpos;
6829    if (jj_3R_351()) {
6830    jj_scanpos = xsp;
6831    if (jj_3R_352()) return true;
6832    }
6833    return false;
6834  }
6835
6836  final private boolean jj_3R_327() {
6837    Token xsp;
6838    while (true) {
6839      xsp = jj_scanpos;
6840      if (jj_3R_340()) { jj_scanpos = xsp; break; }
6841    }
6842    if (jj_3R_70()) return true;
6843    xsp = jj_scanpos;
6844    if (jj_3R_341()) jj_scanpos = xsp;
6845    if (jj_3R_315()) return true;
6846    return false;
6847  }
6848
6849  final private boolean jj_3R_313() {
6850    if (jj_3R_327()) return true;
6851    Token xsp;
6852    while (true) {
6853      xsp = jj_scanpos;
6854      if (jj_3R_328()) { jj_scanpos = xsp; break; }
6855    }
6856    return false;
6857  }
6858
6859  final private boolean jj_3R_370() {
6860    if (jj_scan_token(_DEFAULT)) return true;
6861    if (jj_3R_96()) return true;
6862    return false;
6863  }
6864
6865  final private boolean jj_3_9() {
6866    if (jj_scan_token(COMMA)) return true;
6867    if (jj_3R_72()) return true;
6868    return false;
6869  }
6870
6871  final private boolean jj_3_51() {
6872    if (jj_scan_token(IDENTIFIER)) return true;
6873    if (jj_scan_token(IDENTIFIER)) return true;
6874    return false;
6875  }
6876
6877  final private boolean jj_3R_293() {
6878    if (jj_scan_token(LPAREN)) return true;
6879    Token xsp;
6880    xsp = jj_scanpos;
6881    if (jj_3R_313()) jj_scanpos = xsp;
6882    if (jj_scan_token(RPAREN)) return true;
6883    return false;
6884  }
6885
6886  final private boolean jj_3_50() {
6887    if (jj_3R_70()) return true;
6888    if (jj_scan_token(IDENTIFIER)) return true;
6889    if (jj_scan_token(LPAREN)) return true;
6890    return false;
6891  }
6892
6893  final private boolean jj_3R_357() {
6894    if (jj_3R_287()) return true;
6895    return false;
6896  }
6897
6898  final private boolean jj_3R_356() {
6899    if (jj_3R_289()) return true;
6900    return false;
6901  }
6902
6903  final private boolean jj_3R_355() {
6904    if (jj_3R_68()) return true;
6905    return false;
6906  }
6907
6908  final private boolean jj_3R_354() {
6909    if (jj_3R_67()) return true;
6910    return false;
6911  }
6912
6913  final private boolean jj_3R_353() {
6914    if (jj_3R_70()) return true;
6915    if (jj_scan_token(IDENTIFIER)) return true;
6916    if (jj_scan_token(LPAREN)) return true;
6917    if (jj_scan_token(RPAREN)) return true;
6918    Token xsp;
6919    xsp = jj_scanpos;
6920    if (jj_3R_360()) jj_scanpos = xsp;
6921    if (jj_scan_token(SEMICOLON)) return true;
6922    return false;
6923  }
6924
6925  final private boolean jj_3R_299() {
6926    if (jj_scan_token(IDENTIFIER)) return true;
6927    if (jj_3R_293()) return true;
6928    Token xsp;
6929    while (true) {
6930      xsp = jj_scanpos;
6931      if (jj_3R_317()) { jj_scanpos = xsp; break; }
6932    }
6933    return false;
6934  }
6935
6936  final private boolean jj_3R_342() {
6937    if (jj_3R_93()) return true;
6938    Token xsp;
6939    xsp = jj_scanpos;
6940    if (jj_3R_353()) {
6941    jj_scanpos = xsp;
6942    if (jj_3R_354()) {
6943    jj_scanpos = xsp;
6944    if (jj_3R_355()) {
6945    jj_scanpos = xsp;
6946    if (jj_3R_356()) {
6947    jj_scanpos = xsp;
6948    if (jj_3R_357()) return true;
6949    }
6950    }
6951    }
6952    }
6953    return false;
6954  }
6955
6956  final private boolean jj_3R_331() {
6957    Token xsp;
6958    xsp = jj_scanpos;
6959    if (jj_3R_342()) {
6960    jj_scanpos = xsp;
6961    if (jj_scan_token(81)) return true;
6962    }
6963    return false;
6964  }
6965
6966  final private boolean jj_3R_301() {
6967    if (jj_3R_181()) return true;
6968    return false;
6969  }
6970
6971  final private boolean jj_3R_318() {
6972    if (jj_3R_331()) return true;
6973    return false;
6974  }
6975
6976  final private boolean jj_3R_298() {
6977    if (jj_3R_106()) return true;
6978    return false;
6979  }
6980
6981  final private boolean jj_3R_288() {
6982    Token xsp;
6983    xsp = jj_scanpos;
6984    if (jj_3R_298()) jj_scanpos = xsp;
6985    if (jj_3R_85()) return true;
6986    if (jj_3R_299()) return true;
6987    xsp = jj_scanpos;
6988    if (jj_3R_300()) jj_scanpos = xsp;
6989    xsp = jj_scanpos;
6990    if (jj_3R_301()) {
6991    jj_scanpos = xsp;
6992    if (jj_scan_token(81)) return true;
6993    }
6994    return false;
6995  }
6996
6997  final private boolean jj_3R_261() {
6998    if (jj_3R_72()) return true;
6999    Token xsp;
7000    while (true) {
7001      xsp = jj_scanpos;
7002      if (jj_3_9()) { jj_scanpos = xsp; break; }
7003    }
7004    return false;
7005  }
7006
7007  final private boolean jj_3_49() {
7008    if (jj_scan_token(COMMA)) return true;
7009    if (jj_3R_96()) return true;
7010    return false;
7011  }
7012
7013  final private boolean jj_3R_302() {
7014    if (jj_scan_token(LBRACE)) return true;
7015    Token xsp;
7016    while (true) {
7017      xsp = jj_scanpos;
7018      if (jj_3R_318()) { jj_scanpos = xsp; break; }
7019    }
7020    if (jj_scan_token(RBRACE)) return true;
7021    return false;
7022  }
7023
7024  final private boolean jj_3R_316() {
7025    if (jj_scan_token(ASSIGN)) return true;
7026    if (jj_3R_72()) return true;
7027    return false;
7028  }
7029
7030  final private boolean jj_3R_165() {
7031    if (jj_scan_token(LBRACE)) return true;
7032    Token xsp;
7033    xsp = jj_scanpos;
7034    if (jj_3R_261()) jj_scanpos = xsp;
7035    xsp = jj_scanpos;
7036    if (jj_scan_token(82)) jj_scanpos = xsp;
7037    if (jj_scan_token(RBRACE)) return true;
7038    return false;
7039  }
7040
7041  final private boolean jj_3R_297() {
7042    if (jj_scan_token(COMMA)) return true;
7043    if (jj_3R_296()) return true;
7044    return false;
7045  }
7046
7047  final private boolean jj_3R_289() {
7048    if (jj_scan_token(AT)) return true;
7049    if (jj_scan_token(INTERFACE)) return true;
7050    if (jj_scan_token(IDENTIFIER)) return true;
7051    if (jj_3R_302()) return true;
7052    return false;
7053  }
7054
7055  final private boolean jj_3R_71() {
7056    if (jj_scan_token(LBRACKET)) return true;
7057    if (jj_scan_token(RBRACKET)) return true;
7058    return false;
7059  }
7060
7061  final private boolean jj_3R_109() {
7062    if (jj_3R_88()) return true;
7063    return false;
7064  }
7065
7066  final private boolean jj_3R_108() {
7067    if (jj_3R_165()) return true;
7068    return false;
7069  }
7070
7071  final private boolean jj_3R_72() {
7072    Token xsp;
7073    xsp = jj_scanpos;
7074    if (jj_3R_108()) {
7075    jj_scanpos = xsp;
7076    if (jj_3R_109()) return true;
7077    }
7078    return false;
7079  }
7080
7081  final private boolean jj_3R_255() {
7082    if (jj_3R_96()) return true;
7083    Token xsp;
7084    while (true) {
7085      xsp = jj_scanpos;
7086      if (jj_3_49()) { jj_scanpos = xsp; break; }
7087    }
7088    xsp = jj_scanpos;
7089    if (jj_scan_token(82)) jj_scanpos = xsp;
7090    return false;
7091  }
7092
7093  final private boolean jj_3R_195() {
7094    if (jj_scan_token(LBRACE)) return true;
7095    Token xsp;
7096    xsp = jj_scanpos;
7097    if (jj_3R_255()) jj_scanpos = xsp;
7098    if (jj_scan_token(RBRACE)) return true;
7099    return false;
7100  }
7101
7102  final private boolean jj_3R_339() {
7103    if (jj_3R_103()) return true;
7104    return false;
7105  }
7106
7107  final private boolean jj_3R_330() {
7108    if (jj_scan_token(LBRACKET)) return true;
7109    if (jj_scan_token(RBRACKET)) return true;
7110    return false;
7111  }
7112
7113  final private boolean jj_3R_236() {
7114    if (jj_scan_token(COMMA)) return true;
7115    if (jj_3R_235()) return true;
7116    return false;
7117  }
7118
7119  final private boolean jj_3R_315() {
7120    if (jj_scan_token(IDENTIFIER)) return true;
7121    Token xsp;
7122    while (true) {
7123      xsp = jj_scanpos;
7124      if (jj_3R_330()) { jj_scanpos = xsp; break; }
7125    }
7126    return false;
7127  }
7128
7129  final private boolean jj_3R_164() {
7130    if (jj_scan_token(COMMA)) return true;
7131    if (jj_3R_163()) return true;
7132    return false;
7133  }
7134
7135  final private boolean jj_3R_156() {
7136    if (jj_3R_137()) return true;
7137    return false;
7138  }
7139
7140  final private boolean jj_3R_155() {
7141    if (jj_3R_195()) return true;
7142    return false;
7143  }
7144
7145  final private boolean jj_3R_225() {
7146    if (jj_scan_token(BIT_AND)) return true;
7147    if (jj_3R_176()) return true;
7148    return false;
7149  }
7150
7151  final private boolean jj_3R_96() {
7152    Token xsp;
7153    xsp = jj_scanpos;
7154    if (jj_3R_154()) {
7155    jj_scanpos = xsp;
7156    if (jj_3R_155()) {
7157    jj_scanpos = xsp;
7158    if (jj_3R_156()) return true;
7159    }
7160    }
7161    return false;
7162  }
7163
7164  final private boolean jj_3R_154() {
7165    if (jj_3R_97()) return true;
7166    return false;
7167  }
7168
7169  final private boolean jj_3R_296() {
7170    if (jj_3R_315()) return true;
7171    Token xsp;
7172    xsp = jj_scanpos;
7173    if (jj_3R_316()) jj_scanpos = xsp;
7174    return false;
7175  }
7176
7177  final private boolean jj_3R_69() {
7178    if (jj_3R_106()) return true;
7179    return false;
7180  }
7181
7182  final private boolean jj_3_7() {
7183    if (jj_3R_70()) return true;
7184    if (jj_scan_token(IDENTIFIER)) return true;
7185    Token xsp;
7186    while (true) {
7187      xsp = jj_scanpos;
7188      if (jj_3R_71()) { jj_scanpos = xsp; break; }
7189    }
7190    xsp = jj_scanpos;
7191    if (jj_scan_token(82)) {
7192    jj_scanpos = xsp;
7193    if (jj_scan_token(85)) {
7194    jj_scanpos = xsp;
7195    if (jj_scan_token(81)) return true;
7196    }
7197    }
7198    return false;
7199  }
7200
7201  final private boolean jj_3_6() {
7202    Token xsp;
7203    xsp = jj_scanpos;
7204    if (jj_3R_69()) jj_scanpos = xsp;
7205    if (jj_scan_token(IDENTIFIER)) return true;
7206    if (jj_scan_token(LPAREN)) return true;
7207    return false;
7208  }
7209
7210  final private boolean jj_3R_235() {
7211    if (jj_scan_token(IDENTIFIER)) return true;
7212    if (jj_scan_token(ASSIGN)) return true;
7213    if (jj_3R_96()) return true;
7214    return false;
7215  }
7216
7217  final private boolean jj_3R_287() {
7218    if (jj_3R_70()) return true;
7219    if (jj_3R_296()) return true;
7220    Token xsp;
7221    while (true) {
7222      xsp = jj_scanpos;
7223      if (jj_3R_297()) { jj_scanpos = xsp; break; }
7224    }
7225    if (jj_scan_token(SEMICOLON)) return true;
7226    return false;
7227  }
7228
7229  final private boolean jj_3R_65() {
7230    if (jj_3R_97()) return true;
7231    return false;
7232  }
7233
7234  final private boolean jj_3R_338() {
7235    if (jj_3R_76()) return true;
7236    return false;
7237  }
7238
7239  final private boolean jj_3R_99() {
7240    if (jj_scan_token(INTERFACE)) return true;
7241    return false;
7242  }
7243
7244  final private boolean jj_3R_280() {
7245    if (jj_3R_289()) return true;
7246    return false;
7247  }
7248
7249  final private boolean jj_3R_224() {
7250    if (jj_3R_235()) return true;
7251    Token xsp;
7252    while (true) {
7253      xsp = jj_scanpos;
7254      if (jj_3R_236()) { jj_scanpos = xsp; break; }
7255    }
7256    return false;
7257  }
7258
7259  final private boolean jj_3_8() {
7260    Token xsp;
7261    xsp = jj_scanpos;
7262    if (jj_scan_token(49)) jj_scanpos = xsp;
7263    if (jj_scan_token(LBRACE)) return true;
7264    return false;
7265  }
7266
7267  final private boolean jj_3R_279() {
7268    if (jj_3R_288()) return true;
7269    return false;
7270  }
7271
7272  final private boolean jj_3R_208() {
7273    if (jj_3R_224()) return true;
7274    return false;
7275  }
7276
7277  final private boolean jj_3R_278() {
7278    if (jj_3R_287()) return true;
7279    return false;
7280  }
7281
7282  final private boolean jj_3R_95() {
7283    if (jj_scan_token(IDENTIFIER)) return true;
7284    if (jj_scan_token(ASSIGN)) return true;
7285    return false;
7286  }
7287
7288  final private boolean jj_3R_277() {
7289    if (jj_3R_286()) return true;
7290    return false;
7291  }
7292
7293  final private boolean jj_3_5() {
7294    if (jj_3R_68()) return true;
7295    return false;
7296  }
7297
7298  final private boolean jj_3_4() {
7299    if (jj_3R_67()) return true;
7300    return false;
7301  }
7302
7303  final private boolean jj_3R_197() {
7304    if (jj_scan_token(AT)) return true;
7305    if (jj_3R_94()) return true;
7306    if (jj_scan_token(LPAREN)) return true;
7307    if (jj_3R_96()) return true;
7308    if (jj_scan_token(RPAREN)) return true;
7309    return false;
7310  }
7311
7312  final private boolean jj_3R_271() {
7313    if (jj_3R_93()) return true;
7314    Token xsp;
7315    xsp = jj_scanpos;
7316    if (jj_3_4()) {
7317    jj_scanpos = xsp;
7318    if (jj_3_5()) {
7319    jj_scanpos = xsp;
7320    if (jj_3R_277()) {
7321    jj_scanpos = xsp;
7322    if (jj_3R_278()) {
7323    jj_scanpos = xsp;
7324    if (jj_3R_279()) {
7325    jj_scanpos = xsp;
7326    if (jj_3R_280()) return true;
7327    }
7328    }
7329    }
7330    }
7331    }
7332    return false;
7333  }
7334
7335  final private boolean jj_3R_266() {
7336    Token xsp;
7337    xsp = jj_scanpos;
7338    if (jj_3R_270()) {
7339    jj_scanpos = xsp;
7340    if (jj_3R_271()) {
7341    jj_scanpos = xsp;
7342    if (jj_scan_token(81)) return true;
7343    }
7344    }
7345    return false;
7346  }
7347
7348  final private boolean jj_3R_270() {
7349    if (jj_3R_276()) return true;
7350    return false;
7351  }
7352
7353  final private boolean jj_3R_262() {
7354    if (jj_3R_266()) return true;
7355    return false;
7356  }
7357
7358  final private boolean jj_3R_198() {
7359    if (jj_scan_token(AT)) return true;
7360    if (jj_3R_94()) return true;
7361    return false;
7362  }
7363
7364  final private boolean jj_3_3() {
7365    if (jj_scan_token(COMMA)) return true;
7366    Token xsp;
7367    while (true) {
7368      xsp = jj_scanpos;
7369      if (jj_3R_65()) { jj_scanpos = xsp; break; }
7370    }
7371    if (jj_3R_66()) return true;
7372    return false;
7373  }
7374
7375  final private boolean jj_3R_199() {
7376    if (jj_3R_209()) return true;
7377    return false;
7378  }
7379
7380  final private boolean jj_3_48() {
7381    if (jj_scan_token(AT)) return true;
7382    if (jj_3R_94()) return true;
7383    if (jj_scan_token(LPAREN)) return true;
7384    return false;
7385  }
7386
7387  final private boolean jj_3R_103() {
7388    if (jj_scan_token(LBRACE)) return true;
7389    Token xsp;
7390    while (true) {
7391      xsp = jj_scanpos;
7392      if (jj_3R_262()) { jj_scanpos = xsp; break; }
7393    }
7394    if (jj_scan_token(RBRACE)) return true;
7395    return false;
7396  }
7397
7398  final private boolean jj_3R_196() {
7399    if (jj_scan_token(AT)) return true;
7400    if (jj_3R_94()) return true;
7401    if (jj_scan_token(LPAREN)) return true;
7402    Token xsp;
7403    xsp = jj_scanpos;
7404    if (jj_3R_208()) jj_scanpos = xsp;
7405    if (jj_scan_token(RPAREN)) return true;
7406    return false;
7407  }
7408
7409  final private boolean jj_3_47() {
7410    if (jj_scan_token(AT)) return true;
7411    if (jj_3R_94()) return true;
7412    if (jj_scan_token(LPAREN)) return true;
7413    Token xsp;
7414    xsp = jj_scanpos;
7415    if (jj_3R_95()) {
7416    jj_scanpos = xsp;
7417    if (jj_scan_token(76)) return true;
7418    }
7419    return false;
7420  }
7421
7422  final private boolean jj_3R_209() {
7423    if (jj_scan_token(EXTENDS)) return true;
7424    if (jj_3R_176()) return true;
7425    Token xsp;
7426    while (true) {
7427      xsp = jj_scanpos;
7428      if (jj_3R_225()) { jj_scanpos = xsp; break; }
7429    }
7430    return false;
7431  }
7432
7433  final private boolean jj_3R_159() {
7434    if (jj_3R_198()) return true;
7435    return false;
7436  }
7437
7438  final private boolean jj_3R_158() {
7439    if (jj_3R_197()) return true;
7440    return false;
7441  }
7442
7443  final private boolean jj_3R_160() {
7444    Token xsp;
7445    xsp = jj_scanpos;
7446    if (jj_scan_token(28)) {
7447    jj_scanpos = xsp;
7448    if (jj_scan_token(12)) return true;
7449    }
7450    return false;
7451  }
7452
7453  final private boolean jj_3R_98() {
7454    Token xsp;
7455    xsp = jj_scanpos;
7456    if (jj_3R_160()) jj_scanpos = xsp;
7457    if (jj_scan_token(CLASS)) return true;
7458    return false;
7459  }
7460
7461  final private boolean jj_3R_163() {
7462    if (jj_scan_token(IDENTIFIER)) return true;
7463    Token xsp;
7464    xsp = jj_scanpos;
7465    if (jj_3R_199()) jj_scanpos = xsp;
7466    return false;
7467  }
7468
7469  final private boolean jj_3R_120() {
7470    return false;
7471  }
7472
7473  final private boolean jj_3R_97() {
7474    Token xsp;
7475    xsp = jj_scanpos;
7476    if (jj_3R_157()) {
7477    jj_scanpos = xsp;
7478    if (jj_3R_158()) {
7479    jj_scanpos = xsp;
7480    if (jj_3R_159()) return true;
7481    }
7482    }
7483    return false;
7484  }
7485
7486  final private boolean jj_3R_157() {
7487    if (jj_3R_196()) return true;
7488    return false;
7489  }
7490
7491  final private boolean jj_3R_349() {
7492    if (jj_scan_token(COLON)) return true;
7493    if (jj_3R_88()) return true;
7494    return false;
7495  }
7496
7497  final private boolean jj_3R_106() {
7498    if (jj_scan_token(LT)) return true;
7499    if (jj_3R_163()) return true;
7500    Token xsp;
7501    while (true) {
7502      xsp = jj_scanpos;
7503      if (jj_3R_164()) { jj_scanpos = xsp; break; }
7504    }
7505    if (jj_scan_token(GT)) return true;
7506    return false;
7507  }
7508
7509  final private boolean jj_3R_121() {
7510    return false;
7511  }
7512
7513  final private boolean jj_3R_326() {
7514    if (jj_3R_266()) return true;
7515    return false;
7516  }
7517
7518  final private boolean jj_3R_66() {
7519    if (jj_scan_token(IDENTIFIER)) return true;
7520    Token xsp;
7521    xsp = jj_scanpos;
7522    if (jj_3R_338()) jj_scanpos = xsp;
7523    xsp = jj_scanpos;
7524    if (jj_3R_339()) jj_scanpos = xsp;
7525    return false;
7526  }
7527
7528  final private boolean jj_3R_80() {
7529    Token xsp;
7530    xsp = jj_scanpos;
7531    lookingAhead = true;
7532    jj_semLA = getToken(1).kind == GT &&
7533                ((Token.GTToken)getToken(1)).realKind == RSIGNEDSHIFT;
7534    lookingAhead = false;
7535    if (!jj_semLA || jj_3R_120()) return true;
7536    if (jj_scan_token(GT)) return true;
7537    if (jj_scan_token(GT)) return true;
7538    return false;
7539  }
7540
7541  final private boolean jj_3R_312() {
7542    if (jj_scan_token(SEMICOLON)) return true;
7543    Token xsp;
7544    while (true) {
7545      xsp = jj_scanpos;
7546      if (jj_3R_326()) { jj_scanpos = xsp; break; }
7547    }
7548    return false;
7549  }
7550
7551  final private boolean jj_3R_325() {
7552    if (jj_3R_97()) return true;
7553    return false;
7554  }
7555
7556  final private boolean jj_3R_311() {
7557    Token xsp;
7558    while (true) {
7559      xsp = jj_scanpos;
7560      if (jj_3R_325()) { jj_scanpos = xsp; break; }
7561    }
7562    if (jj_3R_66()) return true;
7563    while (true) {
7564      xsp = jj_scanpos;
7565      if (jj_3_3()) { jj_scanpos = xsp; break; }
7566    }
7567    return false;
7568  }
7569
7570  final private boolean jj_3R_105() {
7571    if (jj_scan_token(LBRACE)) return true;
7572    Token xsp;
7573    xsp = jj_scanpos;
7574    if (jj_3R_311()) jj_scanpos = xsp;
7575    xsp = jj_scanpos;
7576    if (jj_scan_token(82)) jj_scanpos = xsp;
7577    xsp = jj_scanpos;
7578    if (jj_3R_312()) jj_scanpos = xsp;
7579    if (jj_scan_token(RBRACE)) return true;
7580    return false;
7581  }
7582
7583  final private boolean jj_3R_81() {
7584    Token xsp;
7585    xsp = jj_scanpos;
7586    lookingAhead = true;
7587    jj_semLA = getToken(1).kind == GT &&
7588                ((Token.GTToken)getToken(1)).realKind == RUNSIGNEDSHIFT;
7589    lookingAhead = false;
7590    if (!jj_semLA || jj_3R_121()) return true;
7591    if (jj_scan_token(GT)) return true;
7592    if (jj_scan_token(GT)) return true;
7593    if (jj_scan_token(GT)) return true;
7594    return false;
7595  }
7596
7597  final private boolean jj_3R_104() {
7598    if (jj_3R_162()) return true;
7599    return false;
7600  }
7601
7602  final private boolean jj_3R_166() {
7603    if (jj_scan_token(IDENTIFIER)) return true;
7604    if (jj_3R_88()) return true;
7605    Token xsp;
7606    xsp = jj_scanpos;
7607    if (jj_3R_349()) jj_scanpos = xsp;
7608    if (jj_scan_token(SEMICOLON)) return true;
7609    return false;
7610  }
7611
7612  final private boolean jj_3R_68() {
7613    if (jj_scan_token(IDENTIFIER)) return true;
7614    if (jj_scan_token(IDENTIFIER)) return true;
7615    Token xsp;
7616    xsp = jj_scanpos;
7617    if (jj_3R_104()) jj_scanpos = xsp;
7618    if (jj_3R_105()) return true;
7619    return false;
7620  }
7621
7622  final private boolean jj_3R_377() {
7623    if (jj_scan_token(FINALLY)) return true;
7624    if (jj_3R_181()) return true;
7625    return false;
7626  }
7627
7628  final private boolean jj_3R_324() {
7629    if (jj_scan_token(COMMA)) return true;
7630    if (jj_3R_176()) return true;
7631    return false;
7632  }
7633
7634  final private boolean jj_3R_162() {
7635    if (jj_scan_token(IMPLEMENTS)) return true;
7636    if (jj_3R_176()) return true;
7637    Token xsp;
7638    while (true) {
7639      xsp = jj_scanpos;
7640      if (jj_3R_324()) { jj_scanpos = xsp; break; }
7641    }
7642    return false;
7643  }
7644
7645  final private boolean jj_3R_376() {
7646    if (jj_scan_token(CATCH)) return true;
7647    if (jj_scan_token(LPAREN)) return true;
7648    if (jj_3R_327()) return true;
7649    if (jj_scan_token(RPAREN)) return true;
7650    if (jj_3R_181()) return true;
7651    return false;
7652  }
7653
7654  final private boolean jj_3R_323() {
7655    if (jj_scan_token(COMMA)) return true;
7656    if (jj_3R_176()) return true;
7657    return false;
7658  }
7659
7660  final private boolean jj_3R_369() {
7661    if (jj_3R_377()) return true;
7662    return false;
7663  }
7664
7665  final private boolean jj_3R_368() {
7666    if (jj_3R_376()) return true;
7667    return false;
7668  }
7669
7670  final private boolean jj_3R_161() {
7671    if (jj_scan_token(EXTENDS)) return true;
7672    if (jj_3R_176()) return true;
7673    Token xsp;
7674    while (true) {
7675      xsp = jj_scanpos;
7676      if (jj_3R_323()) { jj_scanpos = xsp; break; }
7677    }
7678    return false;
7679  }
7680
7681  final private boolean jj_3R_194() {
7682    if (jj_scan_token(TRY)) return true;
7683    if (jj_3R_181()) return true;
7684    Token xsp;
7685    while (true) {
7686      xsp = jj_scanpos;
7687      if (jj_3R_368()) { jj_scanpos = xsp; break; }
7688    }
7689    xsp = jj_scanpos;
7690    if (jj_3R_369()) jj_scanpos = xsp;
7691    return false;
7692  }
7693
7694  final private boolean jj_3R_102() {
7695    if (jj_3R_162()) return true;
7696    return false;
7697  }
7698
7699  final private boolean jj_3R_101() {
7700    if (jj_3R_161()) return true;
7701    return false;
7702  }
7703
7704  final private boolean jj_3R_100() {
7705    if (jj_3R_106()) return true;
7706    return false;
7707  }
7708
7709  final private boolean jj_3R_193() {
7710    if (jj_scan_token(SYNCHRONIZED)) return true;
7711    if (jj_scan_token(LPAREN)) return true;
7712    if (jj_3R_88()) return true;
7713    if (jj_scan_token(RPAREN)) return true;
7714    if (jj_3R_181()) return true;
7715    return false;
7716  }
7717
7718  final private boolean jj_3R_367() {
7719    if (jj_3R_88()) return true;
7720    return false;
7721  }
7722
7723  final private boolean jj_3R_67() {
7724    Token xsp;
7725    xsp = jj_scanpos;
7726    if (jj_3R_98()) {
7727    jj_scanpos = xsp;
7728    if (jj_3R_99()) return true;
7729    }
7730    if (jj_scan_token(IDENTIFIER)) return true;
7731    xsp = jj_scanpos;
7732    if (jj_3R_100()) jj_scanpos = xsp;
7733    xsp = jj_scanpos;
7734    if (jj_3R_101()) jj_scanpos = xsp;
7735    xsp = jj_scanpos;
7736    if (jj_3R_102()) jj_scanpos = xsp;
7737    if (jj_3R_103()) return true;
7738    return false;
7739  }
7740
7741  final private boolean jj_3R_366() {
7742    if (jj_scan_token(IDENTIFIER)) return true;
7743    return false;
7744  }
7745
7746  final private boolean jj_3R_192() {
7747    if (jj_scan_token(THROW)) return true;
7748    if (jj_3R_88()) return true;
7749    if (jj_scan_token(SEMICOLON)) return true;
7750    return false;
7751  }
7752
7753  final private boolean jj_3R_388() {
7754    if (jj_scan_token(COMMA)) return true;
7755    if (jj_3R_183()) return true;
7756    return false;
7757  }
7758
7759  final private boolean jj_3R_191() {
7760    if (jj_scan_token(RETURN)) return true;
7761    Token xsp;
7762    xsp = jj_scanpos;
7763    if (jj_3R_367()) jj_scanpos = xsp;
7764    if (jj_scan_token(SEMICOLON)) return true;
7765    return false;
7766  }
7767
7768  final private boolean jj_3R_365() {
7769    if (jj_scan_token(IDENTIFIER)) return true;
7770    return false;
7771  }
7772
7773  final private boolean jj_3R_190() {
7774    if (jj_scan_token(CONTINUE)) return true;
7775    Token xsp;
7776    xsp = jj_scanpos;
7777    if (jj_3R_366()) jj_scanpos = xsp;
7778    if (jj_scan_token(SEMICOLON)) return true;
7779    return false;
7780  }
7781
7782  final private boolean jj_3R_189() {
7783    if (jj_scan_token(BREAK)) return true;
7784    Token xsp;
7785    xsp = jj_scanpos;
7786    if (jj_3R_365()) jj_scanpos = xsp;
7787    if (jj_scan_token(SEMICOLON)) return true;
7788    return false;
7789  }
7790
7791  final private boolean jj_3R_382() {
7792    if (jj_3R_387()) return true;
7793    return false;
7794  }
7795
7796  final private boolean jj_3_46() {
7797    Token xsp;
7798    xsp = jj_scanpos;
7799    if (jj_scan_token(28)) jj_scanpos = xsp;
7800    if (jj_3R_70()) return true;
7801    if (jj_scan_token(IDENTIFIER)) return true;
7802    return false;
7803  }
7804
7805  final private boolean jj_3R_64() {
7806    if (jj_3R_97()) return true;
7807    return false;
7808  }
7809
7810  final private boolean jj_3R_387() {
7811    if (jj_3R_183()) return true;
7812    Token xsp;
7813    while (true) {
7814      xsp = jj_scanpos;
7815      if (jj_3R_388()) { jj_scanpos = xsp; break; }
7816    }
7817    return false;
7818  }
7819
7820  final private boolean jj_3R_63() {
7821    if (jj_scan_token(STRICTFP)) return true;
7822    return false;
7823  }
7824
7825  final private boolean jj_3R_62() {
7826    if (jj_scan_token(VOLATILE)) return true;
7827    return false;
7828  }
7829
7830  final private boolean jj_3R_61() {
7831    if (jj_scan_token(TRANSIENT)) return true;
7832    return false;
7833  }
7834
7835  final private boolean jj_3R_60() {
7836    if (jj_scan_token(NATIVE)) return true;
7837    return false;
7838  }
7839
7840  final private boolean jj_3R_362() {
7841    if (jj_scan_token(ELSE)) return true;
7842    if (jj_3R_91()) return true;
7843    return false;
7844  }
7845
7846  final private boolean jj_3R_59() {
7847    if (jj_scan_token(SYNCHRONIZED)) return true;
7848    return false;
7849  }
7850
7851  final private boolean jj_3R_58() {
7852    if (jj_scan_token(ABSTRACT)) return true;
7853    return false;
7854  }
7855
7856  final private boolean jj_3R_386() {
7857    if (jj_3R_387()) return true;
7858    return false;
7859  }
7860
7861  final private boolean jj_3R_57() {
7862    if (jj_scan_token(FINAL)) return true;
7863    return false;
7864  }
7865
7866  final private boolean jj_3R_56() {
7867    if (jj_scan_token(PRIVATE)) return true;
7868    return false;
7869  }
7870
7871  final private boolean jj_3R_55() {
7872    if (jj_scan_token(PROTECTED)) return true;
7873    return false;
7874  }
7875
7876  final private boolean jj_3R_385() {
7877    if (jj_3R_167()) return true;
7878    return false;
7879  }
7880
7881  final private boolean jj_3R_381() {
7882    Token xsp;
7883    xsp = jj_scanpos;
7884    if (jj_3R_385()) {
7885    jj_scanpos = xsp;
7886    if (jj_3R_386()) return true;
7887    }
7888    return false;
7889  }
7890
7891  final private boolean jj_3R_54() {
7892    if (jj_scan_token(STATIC)) return true;
7893    return false;
7894  }
7895
7896  final private boolean jj_3_45() {
7897    if (jj_3R_93()) return true;
7898    if (jj_3R_70()) return true;
7899    if (jj_scan_token(IDENTIFIER)) return true;
7900    if (jj_scan_token(COLON)) return true;
7901    return false;
7902  }
7903
7904  final private boolean jj_3R_53() {
7905    if (jj_scan_token(PUBLIC)) return true;
7906    return false;
7907  }
7908
7909  final private boolean jj_3_2() {
7910    Token xsp;
7911    xsp = jj_scanpos;
7912    if (jj_3R_53()) {
7913    jj_scanpos = xsp;
7914    if (jj_3R_54()) {
7915    jj_scanpos = xsp;
7916    if (jj_3R_55()) {
7917    jj_scanpos = xsp;
7918    if (jj_3R_56()) {
7919    jj_scanpos = xsp;
7920    if (jj_3R_57()) {
7921    jj_scanpos = xsp;
7922    if (jj_3R_58()) {
7923    jj_scanpos = xsp;
7924    if (jj_3R_59()) {
7925    jj_scanpos = xsp;
7926    if (jj_3R_60()) {
7927    jj_scanpos = xsp;
7928    if (jj_3R_61()) {
7929    jj_scanpos = xsp;
7930    if (jj_3R_62()) {
7931    jj_scanpos = xsp;
7932    if (jj_3R_63()) {
7933    jj_scanpos = xsp;
7934    if (jj_3R_64()) return true;
7935    }
7936    }
7937    }
7938    }
7939    }
7940    }
7941    }
7942    }
7943    }
7944    }
7945    }
7946    return false;
7947  }
7948
7949  final private boolean jj_3R_375() {
7950    if (jj_3R_382()) return true;
7951    return false;
7952  }
7953
7954  final private boolean jj_3R_374() {
7955    if (jj_3R_88()) return true;
7956    return false;
7957  }
7958
7959  final private boolean jj_3R_93() {
7960    Token xsp;
7961    while (true) {
7962      xsp = jj_scanpos;
7963      if (jj_3_2()) { jj_scanpos = xsp; break; }
7964    }
7965    return false;
7966  }
7967
7968  final private boolean jj_3R_373() {
7969    if (jj_3R_381()) return true;
7970    return false;
7971  }
7972
7973  final private boolean jj_3R_364() {
7974    Token xsp;
7975    xsp = jj_scanpos;
7976    if (jj_3R_373()) jj_scanpos = xsp;
7977    if (jj_scan_token(SEMICOLON)) return true;
7978    xsp = jj_scanpos;
7979    if (jj_3R_374()) jj_scanpos = xsp;
7980    if (jj_scan_token(SEMICOLON)) return true;
7981    xsp = jj_scanpos;
7982    if (jj_3R_375()) jj_scanpos = xsp;
7983    return false;
7984  }
7985
7986  final private boolean jj_3R_363() {
7987    if (jj_3R_93()) return true;
7988    if (jj_3R_70()) return true;
7989    if (jj_scan_token(IDENTIFIER)) return true;
7990    if (jj_scan_token(COLON)) return true;
7991    if (jj_3R_88()) return true;
7992    return false;
7993  }
7994
7995  final private boolean jj_3R_188() {
7996    if (jj_scan_token(FOR)) return true;
7997    if (jj_scan_token(LPAREN)) return true;
7998    Token xsp;
7999    xsp = jj_scanpos;
8000    if (jj_3R_363()) {
8001    jj_scanpos = xsp;
8002    if (jj_3R_364()) return true;
8003    }
8004    if (jj_scan_token(RPAREN)) return true;
8005    if (jj_3R_91()) return true;
8006    return false;
8007  }
8008
8009  final private boolean jj_3R_187() {
8010    if (jj_scan_token(DO)) return true;
8011    if (jj_3R_91()) return true;
8012    if (jj_scan_token(WHILE)) return true;
8013    if (jj_scan_token(LPAREN)) return true;
8014    if (jj_3R_88()) return true;
8015    if (jj_scan_token(RPAREN)) return true;
8016    if (jj_scan_token(SEMICOLON)) return true;
8017    return false;
8018  }
8019
8020  final private boolean jj_3R_52() {
8021    if (jj_3R_97()) return true;
8022    return false;
8023  }
8024
8025  final private boolean jj_3_1() {
8026    Token xsp;
8027    while (true) {
8028      xsp = jj_scanpos;
8029      if (jj_3R_52()) { jj_scanpos = xsp; break; }
8030    }
8031    if (jj_scan_token(PACKAGE)) return true;
8032    return false;
8033  }
8034
8035  final private boolean jj_3R_186() {
8036    if (jj_scan_token(WHILE)) return true;
8037    if (jj_scan_token(LPAREN)) return true;
8038    if (jj_3R_88()) return true;
8039    if (jj_scan_token(RPAREN)) return true;
8040    if (jj_3R_91()) return true;
8041    return false;
8042  }
8043
8044  final private boolean jj_3_44() {
8045    if (jj_3R_74()) return true;
8046    return false;
8047  }
8048
8049  final private boolean jj_3R_185() {
8050    if (jj_scan_token(IF)) return true;
8051    if (jj_scan_token(LPAREN)) return true;
8052    if (jj_3R_88()) return true;
8053    if (jj_scan_token(RPAREN)) return true;
8054    if (jj_3R_91()) return true;
8055    Token xsp;
8056    xsp = jj_scanpos;
8057    if (jj_3R_362()) jj_scanpos = xsp;
8058    return false;
8059  }
8060
8061  final private boolean jj_3R_380() {
8062    if (jj_scan_token(_DEFAULT)) return true;
8063    if (jj_scan_token(COLON)) return true;
8064    return false;
8065  }
8066
8067  final private boolean jj_3R_379() {
8068    if (jj_scan_token(CASE)) return true;
8069    if (jj_3R_88()) return true;
8070    if (jj_scan_token(COLON)) return true;
8071    return false;
8072  }
8073
8074  final private boolean jj_3R_372() {
8075    Token xsp;
8076    xsp = jj_scanpos;
8077    if (jj_3R_379()) {
8078    jj_scanpos = xsp;
8079    if (jj_3R_380()) return true;
8080    }
8081    return false;
8082  }
8083
8084  final private boolean jj_3R_361() {
8085    if (jj_3R_372()) return true;
8086    Token xsp;
8087    while (true) {
8088      xsp = jj_scanpos;
8089      if (jj_3_44()) { jj_scanpos = xsp; break; }
8090    }
8091    return false;
8092  }
8093
8094  final private boolean jj_3R_211() {
8095    if (jj_3R_97()) return true;
8096    return false;
8097  }
8098
8099  final private boolean jj_3_43() {
8100    if (jj_3R_75()) return true;
8101    Token xsp;
8102    xsp = jj_scanpos;
8103    if (jj_scan_token(97)) {
8104    jj_scanpos = xsp;
8105    if (jj_scan_token(98)) return true;
8106    }
8107    return false;
8108  }
8109
8110  final private boolean jj_3R_184() {
8111    if (jj_scan_token(SWITCH)) return true;
8112    if (jj_scan_token(LPAREN)) return true;
8113    if (jj_3R_88()) return true;
8114    if (jj_scan_token(RPAREN)) return true;
8115    if (jj_scan_token(LBRACE)) return true;
8116    Token xsp;
8117    while (true) {
8118      xsp = jj_scanpos;
8119      if (jj_3R_361()) { jj_scanpos = xsp; break; }
8120    }
8121    if (jj_scan_token(RBRACE)) return true;
8122    return false;
8123  }
8124
8125  final private boolean jj_3R_371() {
8126    if (jj_3R_229()) return true;
8127    if (jj_3R_88()) return true;
8128    return false;
8129  }
8130
8131  final private boolean jj_3R_207() {
8132    if (jj_3R_75()) return true;
8133    Token xsp;
8134    xsp = jj_scanpos;
8135    if (jj_3R_371()) jj_scanpos = xsp;
8136    return false;
8137  }
8138
8139  final private boolean jj_3R_206() {
8140    if (jj_3R_223()) return true;
8141    return false;
8142  }
8143
8144  final private boolean jj_3R_205() {
8145    if (jj_3R_222()) return true;
8146    return false;
8147  }
8148
8149  final private boolean jj_3R_183() {
8150    Token xsp;
8151    xsp = jj_scanpos;
8152    if (jj_3R_204()) {
8153    jj_scanpos = xsp;
8154    if (jj_3R_205()) {
8155    jj_scanpos = xsp;
8156    if (jj_3R_206()) {
8157    jj_scanpos = xsp;
8158    if (jj_3R_207()) return true;
8159    }
8160    }
8161    }
8162    return false;
8163  }
8164
8165  final private boolean jj_3R_204() {
8166    if (jj_3R_221()) return true;
8167    return false;
8168  }
8169
8170  final private boolean jj_3R_182() {
8171    if (jj_scan_token(SEMICOLON)) return true;
8172    return false;
8173  }
8174
8175  final private boolean jj_3R_92() {
8176    Token xsp;
8177    xsp = jj_scanpos;
8178    if (jj_scan_token(28)) {
8179    jj_scanpos = xsp;
8180    if (jj_scan_token(12)) return true;
8181    }
8182    return false;
8183  }
8184
8185  final private boolean jj_3R_350() {
8186    if (jj_scan_token(COMMA)) return true;
8187    if (jj_3R_296()) return true;
8188    return false;
8189  }
8190
8191  final private boolean jj_3R_138() {
8192    if (jj_3R_97()) return true;
8193    return false;
8194  }
8195
8196  final private boolean jj_3_42() {
8197    Token xsp;
8198    xsp = jj_scanpos;
8199    if (jj_3R_92()) jj_scanpos = xsp;
8200    if (jj_scan_token(CLASS)) return true;
8201    return false;
8202  }
8203
8204  final private boolean jj_3R_200() {
8205    Token xsp;
8206    xsp = jj_scanpos;
8207    if (jj_3R_210()) {
8208    jj_scanpos = xsp;
8209    if (jj_3R_211()) return true;
8210    }
8211    return false;
8212  }
8213
8214  final private boolean jj_3R_210() {
8215    if (jj_scan_token(FINAL)) return true;
8216    return false;
8217  }
8218
8219  final private boolean jj_3R_167() {
8220    Token xsp;
8221    while (true) {
8222      xsp = jj_scanpos;
8223      if (jj_3R_200()) { jj_scanpos = xsp; break; }
8224    }
8225    if (jj_3R_70()) return true;
8226    if (jj_3R_296()) return true;
8227    while (true) {
8228      xsp = jj_scanpos;
8229      if (jj_3R_350()) { jj_scanpos = xsp; break; }
8230    }
8231    return false;
8232  }
8233
8234  final private boolean jj_3R_90() {
8235    Token xsp;
8236    xsp = jj_scanpos;
8237    if (jj_scan_token(28)) {
8238    jj_scanpos = xsp;
8239    if (jj_3R_138()) return true;
8240    }
8241    return false;
8242  }
8243
8244  final private boolean jj_3R_114() {
8245    if (jj_3R_67()) return true;
8246    return false;
8247  }
8248
8249  final private boolean jj_3_40() {
8250    Token xsp;
8251    while (true) {
8252      xsp = jj_scanpos;
8253      if (jj_3R_90()) { jj_scanpos = xsp; break; }
8254    }
8255    if (jj_3R_70()) return true;
8256    if (jj_scan_token(IDENTIFIER)) return true;
8257    return false;
8258  }
8259
8260  final private boolean jj_3_41() {
8261    if (jj_3R_91()) return true;
8262    return false;
8263  }
8264
8265  final private boolean jj_3_39() {
8266    if (jj_3R_74()) return true;
8267    return false;
8268  }
8269
8270  final private boolean jj_3R_113() {
8271    if (jj_3R_167()) return true;
8272    if (jj_scan_token(SEMICOLON)) return true;
8273    return false;
8274  }
8275
8276  final private boolean jj_3R_112() {
8277    if (jj_3R_166()) return true;
8278    return false;
8279  }
8280
8281  final private boolean jj_3R_74() {
8282    Token xsp;
8283    xsp = jj_scanpos;
8284    lookingAhead = true;
8285    jj_semLA = isNextTokenAnAssert();
8286    lookingAhead = false;
8287    if (!jj_semLA || jj_3R_112()) {
8288    jj_scanpos = xsp;
8289    if (jj_3R_113()) {
8290    jj_scanpos = xsp;
8291    if (jj_3_41()) {
8292    jj_scanpos = xsp;
8293    if (jj_3R_114()) return true;
8294    }
8295    }
8296    }
8297    return false;
8298  }
8299
8300  final private boolean jj_3R_181() {
8301    if (jj_scan_token(LBRACE)) return true;
8302    Token xsp;
8303    while (true) {
8304      xsp = jj_scanpos;
8305      if (jj_3_39()) { jj_scanpos = xsp; break; }
8306    }
8307    if (jj_scan_token(RBRACE)) return true;
8308    return false;
8309  }
8310
8311  final private boolean jj_3_36() {
8312    if (jj_scan_token(LBRACKET)) return true;
8313    if (jj_scan_token(RBRACKET)) return true;
8314    return false;
8315  }
8316
8317  final private boolean jj_3R_89() {
8318    if (jj_scan_token(IDENTIFIER)) return true;
8319    if (jj_scan_token(COLON)) return true;
8320    if (jj_3R_91()) return true;
8321    return false;
8322  }
8323
8324  final private boolean jj_3R_153() {
8325    if (jj_3R_194()) return true;
8326    return false;
8327  }
8328
8329  final private boolean jj_3R_152() {
8330    if (jj_3R_193()) return true;
8331    return false;
8332  }
8333
8334  final private boolean jj_3R_151() {
8335    if (jj_3R_192()) return true;
8336    return false;
8337  }
8338
8339  final private boolean jj_3R_150() {
8340    if (jj_3R_191()) return true;
8341    return false;
8342  }
8343
8344  final private boolean jj_3R_149() {
8345    if (jj_3R_190()) return true;
8346    return false;
8347  }
8348
8349  final private boolean jj_3R_148() {
8350    if (jj_3R_189()) return true;
8351    return false;
8352  }
8353
8354  final private boolean jj_3R_147() {
8355    if (jj_3R_188()) return true;
8356    return false;
8357  }
8358
8359  final private boolean jj_3R_146() {
8360    if (jj_3R_187()) return true;
8361    return false;
8362  }
8363
8364  final private boolean jj_3R_145() {
8365    if (jj_3R_186()) return true;
8366    return false;
8367  }
8368
8369  final private boolean jj_3R_144() {
8370    if (jj_3R_185()) return true;
8371    return false;
8372  }
8373
8374  final private boolean jj_3R_143() {
8375    if (jj_3R_184()) return true;
8376    return false;
8377  }
8378
8379  final private boolean jj_3R_142() {
8380    if (jj_3R_183()) return true;
8381    if (jj_scan_token(SEMICOLON)) return true;
8382    return false;
8383  }
8384
8385  final private boolean jj_3R_141() {
8386    if (jj_3R_182()) return true;
8387    return false;
8388  }
8389
8390  final private boolean jj_3R_140() {
8391    if (jj_3R_181()) return true;
8392    return false;
8393  }
8394
8395  final private boolean jj_3R_232() {
8396    if (jj_3R_78()) return true;
8397    return false;
8398  }
8399
8400  final private boolean jj_3_38() {
8401    if (jj_3R_89()) return true;
8402    return false;
8403  }
8404
8405  final private boolean jj_3R_139() {
8406    if (jj_3R_166()) return true;
8407    return false;
8408  }
8409
8410  final private boolean jj_3R_91() {
8411    Token xsp;
8412    xsp = jj_scanpos;
8413    lookingAhead = true;
8414    jj_semLA = isNextTokenAnAssert();
8415    lookingAhead = false;
8416    if (!jj_semLA || jj_3R_139()) {
8417    jj_scanpos = xsp;
8418    if (jj_3_38()) {
8419    jj_scanpos = xsp;
8420    if (jj_3R_140()) {
8421    jj_scanpos = xsp;
8422    if (jj_3R_141()) {
8423    jj_scanpos = xsp;
8424    if (jj_3R_142()) {
8425    jj_scanpos = xsp;
8426    if (jj_3R_143()) {
8427    jj_scanpos = xsp;
8428    if (jj_3R_144()) {
8429    jj_scanpos = xsp;
8430    if (jj_3R_145()) {
8431    jj_scanpos = xsp;
8432    if (jj_3R_146()) {
8433    jj_scanpos = xsp;
8434    if (jj_3R_147()) {
8435    jj_scanpos = xsp;
8436    if (jj_3R_148()) {
8437    jj_scanpos = xsp;
8438    if (jj_3R_149()) {
8439    jj_scanpos = xsp;
8440    if (jj_3R_150()) {
8441    jj_scanpos = xsp;
8442    if (jj_3R_151()) {
8443    jj_scanpos = xsp;
8444    if (jj_3R_152()) {
8445    jj_scanpos = xsp;
8446    if (jj_3R_153()) return true;
8447    }
8448    }
8449    }
8450    }
8451    }
8452    }
8453    }
8454    }
8455    }
8456    }
8457    }
8458    }
8459    }
8460    }
8461    }
8462    return false;
8463  }
8464
8465  final private boolean jj_3R_253() {
8466    if (jj_3R_103()) return true;
8467    return false;
8468  }
8469
8470  final private boolean jj_3R_258() {
8471    if (jj_scan_token(LBRACKET)) return true;
8472    if (jj_scan_token(RBRACKET)) return true;
8473    return false;
8474  }
8475
8476  final private boolean jj_3_35() {
8477    if (jj_scan_token(LBRACKET)) return true;
8478    if (jj_3R_88()) return true;
8479    if (jj_scan_token(RBRACKET)) return true;
8480    return false;
8481  }
8482
8483  final private boolean jj_3R_252() {
8484    Token xsp;
8485    if (jj_3R_258()) return true;
8486    while (true) {
8487      xsp = jj_scanpos;
8488      if (jj_3R_258()) { jj_scanpos = xsp; break; }
8489    }
8490    if (jj_3R_165()) return true;
8491    return false;
8492  }
8493
8494  final private boolean jj_3_37() {
8495    Token xsp;
8496    if (jj_3_35()) return true;
8497    while (true) {
8498      xsp = jj_scanpos;
8499      if (jj_3_35()) { jj_scanpos = xsp; break; }
8500    }
8501    while (true) {
8502      xsp = jj_scanpos;
8503      if (jj_3_36()) { jj_scanpos = xsp; break; }
8504    }
8505    return false;
8506  }
8507
8508  final private boolean jj_3R_231() {
8509    Token xsp;
8510    xsp = jj_scanpos;
8511    if (jj_3_37()) {
8512    jj_scanpos = xsp;
8513    if (jj_3R_252()) return true;
8514    }
8515    return false;
8516  }
8517
8518  final private boolean jj_3R_234() {
8519    if (jj_3R_76()) return true;
8520    Token xsp;
8521    xsp = jj_scanpos;
8522    if (jj_3R_253()) jj_scanpos = xsp;
8523    return false;
8524  }
8525
8526  final private boolean jj_3R_202() {
8527    if (jj_scan_token(COMMA)) return true;
8528    if (jj_3R_88()) return true;
8529    return false;
8530  }
8531
8532  final private boolean jj_3R_233() {
8533    if (jj_3R_231()) return true;
8534    return false;
8535  }
8536
8537  final private boolean jj_3R_136() {
8538    if (jj_scan_token(NEW)) return true;
8539    if (jj_3R_176()) return true;
8540    Token xsp;
8541    xsp = jj_scanpos;
8542    if (jj_3R_232()) jj_scanpos = xsp;
8543    xsp = jj_scanpos;
8544    if (jj_3R_233()) {
8545    jj_scanpos = xsp;
8546    if (jj_3R_234()) return true;
8547    }
8548    return false;
8549  }
8550
8551  final private boolean jj_3R_86() {
8552    Token xsp;
8553    xsp = jj_scanpos;
8554    if (jj_3_34()) {
8555    jj_scanpos = xsp;
8556    if (jj_3R_136()) return true;
8557    }
8558    return false;
8559  }
8560
8561  final private boolean jj_3_34() {
8562    if (jj_scan_token(NEW)) return true;
8563    if (jj_3R_83()) return true;
8564    if (jj_3R_231()) return true;
8565    return false;
8566  }
8567
8568  final private boolean jj_3R_116() {
8569    if (jj_3R_175()) return true;
8570    return false;
8571  }
8572
8573  final private boolean jj_3R_175() {
8574    if (jj_3R_88()) return true;
8575    Token xsp;
8576    while (true) {
8577      xsp = jj_scanpos;
8578      if (jj_3R_202()) { jj_scanpos = xsp; break; }
8579    }
8580    return false;
8581  }
8582
8583  final private boolean jj_3R_76() {
8584    if (jj_scan_token(LPAREN)) return true;
8585    Token xsp;
8586    xsp = jj_scanpos;
8587    if (jj_3R_116()) jj_scanpos = xsp;
8588    if (jj_scan_token(RPAREN)) return true;
8589    return false;
8590  }
8591
8592  final private boolean jj_3R_179() {
8593    if (jj_3R_201()) return true;
8594    return false;
8595  }
8596
8597  final private boolean jj_3R_227() {
8598    if (jj_scan_token(NULL)) return true;
8599    return false;
8600  }
8601
8602  final private boolean jj_3R_226() {
8603    Token xsp;
8604    xsp = jj_scanpos;
8605    if (jj_3R_237()) {
8606    jj_scanpos = xsp;
8607    if (jj_scan_token(27)) return true;
8608    }
8609    return false;
8610  }
8611
8612  final private boolean jj_3R_237() {
8613    if (jj_scan_token(TRUE)) return true;
8614    return false;
8615  }
8616
8617  final private boolean jj_3R_218() {
8618    if (jj_3R_227()) return true;
8619    return false;
8620  }
8621
8622  final private boolean jj_3R_384() {
8623    if (jj_scan_token(DECR)) return true;
8624    return false;
8625  }
8626
8627  final private boolean jj_3R_217() {
8628    if (jj_3R_226()) return true;
8629    return false;
8630  }
8631
8632  final private boolean jj_3R_216() {
8633    if (jj_scan_token(STRING_LITERAL)) return true;
8634    return false;
8635  }
8636
8637  final private boolean jj_3R_215() {
8638    if (jj_scan_token(CHARACTER_LITERAL)) return true;
8639    return false;
8640  }
8641
8642  final private boolean jj_3R_214() {
8643    if (jj_scan_token(HEX_FLOATING_POINT_LITERAL)) return true;
8644    return false;
8645  }
8646
8647  final private boolean jj_3R_213() {
8648    if (jj_scan_token(FLOATING_POINT_LITERAL)) return true;
8649    return false;
8650  }
8651
8652  final private boolean jj_3R_201() {
8653    Token xsp;
8654    xsp = jj_scanpos;
8655    if (jj_3R_212()) {
8656    jj_scanpos = xsp;
8657    if (jj_3R_213()) {
8658    jj_scanpos = xsp;
8659    if (jj_3R_214()) {
8660    jj_scanpos = xsp;
8661    if (jj_3R_215()) {
8662    jj_scanpos = xsp;
8663    if (jj_3R_216()) {
8664    jj_scanpos = xsp;
8665    if (jj_3R_217()) {
8666    jj_scanpos = xsp;
8667    if (jj_3R_218()) return true;
8668    }
8669    }
8670    }
8671    }
8672    }
8673    }
8674    return false;
8675  }
8676
8677  final private boolean jj_3R_212() {
8678    if (jj_scan_token(INTEGER_LITERAL)) return true;
8679    return false;
8680  }
8681
8682  final private boolean jj_3R_134() {
8683    if (jj_3R_76()) return true;
8684    return false;
8685  }
8686
8687  final private boolean jj_3R_133() {
8688    if (jj_scan_token(DOT)) return true;
8689    if (jj_scan_token(IDENTIFIER)) return true;
8690    return false;
8691  }
8692
8693  final private boolean jj_3_29() {
8694    if (jj_3R_85()) return true;
8695    if (jj_scan_token(DOT)) return true;
8696    if (jj_scan_token(CLASS)) return true;
8697    return false;
8698  }
8699
8700  final private boolean jj_3R_132() {
8701    if (jj_scan_token(LBRACKET)) return true;
8702    if (jj_3R_88()) return true;
8703    if (jj_scan_token(RBRACKET)) return true;
8704    return false;
8705  }
8706
8707  final private boolean jj_3_33() {
8708    if (jj_3R_87()) return true;
8709    return false;
8710  }
8711
8712  final private boolean jj_3R_345() {
8713    if (jj_scan_token(REM)) return true;
8714    return false;
8715  }
8716
8717  final private boolean jj_3_32() {
8718    if (jj_scan_token(DOT)) return true;
8719    if (jj_3R_86()) return true;
8720    return false;
8721  }
8722
8723  final private boolean jj_3R_84() {
8724    Token xsp;
8725    xsp = jj_scanpos;
8726    if (jj_3_30()) {
8727    jj_scanpos = xsp;
8728    if (jj_3_31()) {
8729    jj_scanpos = xsp;
8730    if (jj_3_32()) {
8731    jj_scanpos = xsp;
8732    if (jj_3_33()) {
8733    jj_scanpos = xsp;
8734    if (jj_3R_132()) {
8735    jj_scanpos = xsp;
8736    if (jj_3R_133()) {
8737    jj_scanpos = xsp;
8738    if (jj_3R_134()) return true;
8739    }
8740    }
8741    }
8742    }
8743    }
8744    }
8745    return false;
8746  }
8747
8748  final private boolean jj_3_31() {
8749    if (jj_scan_token(DOT)) return true;
8750    if (jj_scan_token(SUPER)) return true;
8751    return false;
8752  }
8753
8754  final private boolean jj_3_30() {
8755    if (jj_scan_token(DOT)) return true;
8756    if (jj_scan_token(THIS)) return true;
8757    return false;
8758  }
8759
8760  final private boolean jj_3R_174() {
8761    if (jj_3R_94()) return true;
8762    return false;
8763  }
8764
8765  final private boolean jj_3R_173() {
8766    if (jj_3R_85()) return true;
8767    if (jj_scan_token(DOT)) return true;
8768    if (jj_scan_token(CLASS)) return true;
8769    return false;
8770  }
8771
8772  final private boolean jj_3_28() {
8773    if (jj_3R_84()) return true;
8774    return false;
8775  }
8776
8777  final private boolean jj_3R_172() {
8778    if (jj_3R_86()) return true;
8779    return false;
8780  }
8781
8782  final private boolean jj_3R_171() {
8783    if (jj_scan_token(LPAREN)) return true;
8784    if (jj_3R_88()) return true;
8785    if (jj_scan_token(RPAREN)) return true;
8786    return false;
8787  }
8788
8789  final private boolean jj_3R_170() {
8790    if (jj_scan_token(SUPER)) return true;
8791    if (jj_scan_token(DOT)) return true;
8792    if (jj_scan_token(IDENTIFIER)) return true;
8793    return false;
8794  }
8795
8796  final private boolean jj_3R_169() {
8797    if (jj_scan_token(THIS)) return true;
8798    return false;
8799  }
8800
8801  final private boolean jj_3R_115() {
8802    Token xsp;
8803    xsp = jj_scanpos;
8804    if (jj_3R_168()) {
8805    jj_scanpos = xsp;
8806    if (jj_3R_169()) {
8807    jj_scanpos = xsp;
8808    if (jj_3R_170()) {
8809    jj_scanpos = xsp;
8810    if (jj_3R_171()) {
8811    jj_scanpos = xsp;
8812    if (jj_3R_172()) {
8813    jj_scanpos = xsp;
8814    if (jj_3R_173()) {
8815    jj_scanpos = xsp;
8816    if (jj_3R_174()) return true;
8817    }
8818    }
8819    }
8820    }
8821    }
8822    }
8823    return false;
8824  }
8825
8826  final private boolean jj_3R_168() {
8827    if (jj_3R_201()) return true;
8828    return false;
8829  }
8830
8831  final private boolean jj_3R_383() {
8832    if (jj_scan_token(INCR)) return true;
8833    return false;
8834  }
8835
8836  final private boolean jj_3R_378() {
8837    Token xsp;
8838    xsp = jj_scanpos;
8839    if (jj_3R_383()) {
8840    jj_scanpos = xsp;
8841    if (jj_3R_384()) return true;
8842    }
8843    return false;
8844  }
8845
8846  final private boolean jj_3R_87() {
8847    if (jj_scan_token(DOT)) return true;
8848    if (jj_3R_78()) return true;
8849    if (jj_scan_token(IDENTIFIER)) return true;
8850    return false;
8851  }
8852
8853  final private boolean jj_3_27() {
8854    if (jj_scan_token(LPAREN)) return true;
8855    if (jj_3R_83()) return true;
8856    return false;
8857  }
8858
8859  final private boolean jj_3R_347() {
8860    if (jj_scan_token(BANG)) return true;
8861    return false;
8862  }
8863
8864  final private boolean jj_3R_75() {
8865    if (jj_3R_115()) return true;
8866    Token xsp;
8867    while (true) {
8868      xsp = jj_scanpos;
8869      if (jj_3_28()) { jj_scanpos = xsp; break; }
8870    }
8871    return false;
8872  }
8873
8874  final private boolean jj_3R_334() {
8875    if (jj_scan_token(MINUS)) return true;
8876    return false;
8877  }
8878
8879  final private boolean jj_3R_344() {
8880    if (jj_scan_token(SLASH)) return true;
8881    return false;
8882  }
8883
8884  final private boolean jj_3R_359() {
8885    if (jj_scan_token(LPAREN)) return true;
8886    if (jj_3R_70()) return true;
8887    if (jj_scan_token(RPAREN)) return true;
8888    if (jj_3R_322()) return true;
8889    return false;
8890  }
8891
8892  final private boolean jj_3R_348() {
8893    Token xsp;
8894    xsp = jj_scanpos;
8895    if (jj_3R_358()) {
8896    jj_scanpos = xsp;
8897    if (jj_3R_359()) return true;
8898    }
8899    return false;
8900  }
8901
8902  final private boolean jj_3R_358() {
8903    if (jj_scan_token(LPAREN)) return true;
8904    if (jj_3R_70()) return true;
8905    if (jj_scan_token(RPAREN)) return true;
8906    if (jj_3R_291()) return true;
8907    return false;
8908  }
8909
8910  final private boolean jj_3_26() {
8911    if (jj_scan_token(LPAREN)) return true;
8912    if (jj_3R_70()) return true;
8913    if (jj_scan_token(LBRACKET)) return true;
8914    return false;
8915  }
8916
8917  final private boolean jj_3R_223() {
8918    if (jj_3R_75()) return true;
8919    Token xsp;
8920    xsp = jj_scanpos;
8921    if (jj_3R_378()) jj_scanpos = xsp;
8922    return false;
8923  }
8924
8925  final private boolean jj_3R_123() {
8926    if (jj_scan_token(LPAREN)) return true;
8927    if (jj_3R_70()) return true;
8928    if (jj_scan_token(RPAREN)) return true;
8929    Token xsp;
8930    xsp = jj_scanpos;
8931    if (jj_scan_token(88)) {
8932    jj_scanpos = xsp;
8933    if (jj_scan_token(87)) {
8934    jj_scanpos = xsp;
8935    if (jj_scan_token(75)) {
8936    jj_scanpos = xsp;
8937    if (jj_scan_token(72)) {
8938    jj_scanpos = xsp;
8939    if (jj_scan_token(53)) {
8940    jj_scanpos = xsp;
8941    if (jj_scan_token(50)) {
8942    jj_scanpos = xsp;
8943    if (jj_scan_token(41)) {
8944    jj_scanpos = xsp;
8945    if (jj_3R_179()) return true;
8946    }
8947    }
8948    }
8949    }
8950    }
8951    }
8952    }
8953    return false;
8954  }
8955
8956  final private boolean jj_3_24() {
8957    if (jj_3R_82()) return true;
8958    return false;
8959  }
8960
8961  final private boolean jj_3R_321() {
8962    if (jj_scan_token(MINUS)) return true;
8963    return false;
8964  }
8965
8966  final private boolean jj_3R_122() {
8967    if (jj_scan_token(LPAREN)) return true;
8968    if (jj_3R_70()) return true;
8969    if (jj_scan_token(LBRACKET)) return true;
8970    if (jj_scan_token(RBRACKET)) return true;
8971    return false;
8972  }
8973
8974  final private boolean jj_3R_82() {
8975    Token xsp;
8976    xsp = jj_scanpos;
8977    if (jj_3_25()) {
8978    jj_scanpos = xsp;
8979    if (jj_3R_122()) {
8980    jj_scanpos = xsp;
8981    if (jj_3R_123()) return true;
8982    }
8983    }
8984    return false;
8985  }
8986
8987  final private boolean jj_3_25() {
8988    if (jj_scan_token(LPAREN)) return true;
8989    if (jj_3R_83()) return true;
8990    return false;
8991  }
8992
8993  final private boolean jj_3R_337() {
8994    if (jj_3R_223()) return true;
8995    return false;
8996  }
8997
8998  final private boolean jj_3R_346() {
8999    if (jj_scan_token(TILDE)) return true;
9000    return false;
9001  }
9002
9003  final private boolean jj_3R_336() {
9004    if (jj_3R_348()) return true;
9005    return false;
9006  }
9007
9008  final private boolean jj_3R_335() {
9009    Token xsp;
9010    xsp = jj_scanpos;
9011    if (jj_3R_346()) {
9012    jj_scanpos = xsp;
9013    if (jj_3R_347()) return true;
9014    }
9015    if (jj_3R_291()) return true;
9016    return false;
9017  }
9018
9019  final private boolean jj_3R_322() {
9020    Token xsp;
9021    xsp = jj_scanpos;
9022    if (jj_3R_335()) {
9023    jj_scanpos = xsp;
9024    if (jj_3R_336()) {
9025    jj_scanpos = xsp;
9026    if (jj_3R_337()) return true;
9027    }
9028    }
9029    return false;
9030  }
9031
9032  final private boolean jj_3R_333() {
9033    if (jj_scan_token(PLUS)) return true;
9034    return false;
9035  }
9036
9037  final private boolean jj_3R_319() {
9038    Token xsp;
9039    xsp = jj_scanpos;
9040    if (jj_3R_333()) {
9041    jj_scanpos = xsp;
9042    if (jj_3R_334()) return true;
9043    }
9044    if (jj_3R_284()) return true;
9045    return false;
9046  }
9047
9048  final private boolean jj_3R_343() {
9049    if (jj_scan_token(STAR)) return true;
9050    return false;
9051  }
9052
9053  final private boolean jj_3R_222() {
9054    if (jj_scan_token(DECR)) return true;
9055    if (jj_3R_75()) return true;
9056    return false;
9057  }
9058
9059  final private boolean jj_3R_332() {
9060    Token xsp;
9061    xsp = jj_scanpos;
9062    if (jj_3R_343()) {
9063    jj_scanpos = xsp;
9064    if (jj_3R_344()) {
9065    jj_scanpos = xsp;
9066    if (jj_3R_345()) return true;
9067    }
9068    }
9069    if (jj_3R_291()) return true;
9070    return false;
9071  }
9072
9073  final private boolean jj_3R_283() {
9074    if (jj_scan_token(NE)) return true;
9075    return false;
9076  }
9077
9078  final private boolean jj_3R_221() {
9079    if (jj_scan_token(INCR)) return true;
9080    if (jj_3R_75()) return true;
9081    return false;
9082  }
9083
9084  final private boolean jj_3R_310() {
9085    if (jj_3R_322()) return true;
9086    return false;
9087  }
9088
9089  final private boolean jj_3R_309() {
9090    if (jj_3R_222()) return true;
9091    return false;
9092  }
9093
9094  final private boolean jj_3R_308() {
9095    if (jj_3R_221()) return true;
9096    return false;
9097  }
9098
9099  final private boolean jj_3R_320() {
9100    if (jj_scan_token(PLUS)) return true;
9101    return false;
9102  }
9103
9104  final private boolean jj_3R_307() {
9105    Token xsp;
9106    xsp = jj_scanpos;
9107    if (jj_3R_320()) {
9108    jj_scanpos = xsp;
9109    if (jj_3R_321()) return true;
9110    }
9111    if (jj_3R_291()) return true;
9112    return false;
9113  }
9114
9115  final private boolean jj_3R_291() {
9116    Token xsp;
9117    xsp = jj_scanpos;
9118    if (jj_3R_307()) {
9119    jj_scanpos = xsp;
9120    if (jj_3R_308()) {
9121    jj_scanpos = xsp;
9122    if (jj_3R_309()) {
9123    jj_scanpos = xsp;
9124    if (jj_3R_310()) return true;
9125    }
9126    }
9127    }
9128    return false;
9129  }
9130
9131  final private boolean jj_3R_284() {
9132    if (jj_3R_291()) return true;
9133    Token xsp;
9134    while (true) {
9135      xsp = jj_scanpos;
9136      if (jj_3R_332()) { jj_scanpos = xsp; break; }
9137    }
9138    return false;
9139  }
9140
9141  final private boolean jj_3R_275() {
9142    if (jj_3R_284()) return true;
9143    Token xsp;
9144    while (true) {
9145      xsp = jj_scanpos;
9146      if (jj_3R_319()) { jj_scanpos = xsp; break; }
9147    }
9148    return false;
9149  }
9150
9151  final private boolean jj_3_23() {
9152    if (jj_3R_81()) return true;
9153    return false;
9154  }
9155
9156  final private boolean jj_3_22() {
9157    if (jj_3R_80()) return true;
9158    return false;
9159  }
9160
9161  final private boolean jj_3R_281() {
9162    if (jj_scan_token(INSTANCEOF)) return true;
9163    if (jj_3R_70()) return true;
9164    return false;
9165  }
9166
9167  final private boolean jj_3R_79() {
9168    if (jj_scan_token(LSHIFT)) return true;
9169    return false;
9170  }
9171
9172  final private boolean jj_3_21() {
9173    Token xsp;
9174    xsp = jj_scanpos;
9175    if (jj_3R_79()) {
9176    jj_scanpos = xsp;
9177    if (jj_3_22()) {
9178    jj_scanpos = xsp;
9179    if (jj_3_23()) return true;
9180    }
9181    }
9182    if (jj_3R_275()) return true;
9183    return false;
9184  }
9185
9186  final private boolean jj_3R_282() {
9187    if (jj_scan_token(EQ)) return true;
9188    return false;
9189  }
9190
9191  final private boolean jj_3R_274() {
9192    Token xsp;
9193    xsp = jj_scanpos;
9194    if (jj_3R_282()) {
9195    jj_scanpos = xsp;
9196    if (jj_3R_283()) return true;
9197    }
9198    if (jj_3R_260()) return true;
9199    return false;
9200  }
9201
9202  final private boolean jj_3R_269() {
9203    if (jj_3R_275()) return true;
9204    Token xsp;
9205    while (true) {
9206      xsp = jj_scanpos;
9207      if (jj_3_21()) { jj_scanpos = xsp; break; }
9208    }
9209    return false;
9210  }
9211
9212  final private boolean jj_3R_306() {
9213    if (jj_scan_token(GE)) return true;
9214    return false;
9215  }
9216
9217  final private boolean jj_3R_305() {
9218    if (jj_scan_token(LE)) return true;
9219    return false;
9220  }
9221
9222  final private boolean jj_3R_304() {
9223    if (jj_scan_token(GT)) return true;
9224    return false;
9225  }
9226
9227  final private boolean jj_3R_303() {
9228    if (jj_scan_token(LT)) return true;
9229    return false;
9230  }
9231
9232  final private boolean jj_3R_268() {
9233    if (jj_scan_token(BIT_AND)) return true;
9234    if (jj_3R_257()) return true;
9235    return false;
9236  }
9237
9238  final private boolean jj_3R_290() {
9239    Token xsp;
9240    xsp = jj_scanpos;
9241    if (jj_3R_303()) {
9242    jj_scanpos = xsp;
9243    if (jj_3R_304()) {
9244    jj_scanpos = xsp;
9245    if (jj_3R_305()) {
9246    jj_scanpos = xsp;
9247    if (jj_3R_306()) return true;
9248    }
9249    }
9250    }
9251    if (jj_3R_269()) return true;
9252    return false;
9253  }
9254
9255  final private boolean jj_3R_265() {
9256    if (jj_3R_269()) return true;
9257    Token xsp;
9258    while (true) {
9259      xsp = jj_scanpos;
9260      if (jj_3R_290()) { jj_scanpos = xsp; break; }
9261    }
9262    return false;
9263  }
9264
9265  final private boolean jj_3R_259() {
9266    if (jj_scan_token(BIT_OR)) return true;
9267    if (jj_3R_230()) return true;
9268    return false;
9269  }
9270
9271  final private boolean jj_3R_264() {
9272    if (jj_scan_token(XOR)) return true;
9273    if (jj_3R_251()) return true;
9274    return false;
9275  }
9276
9277  final private boolean jj_3R_260() {
9278    if (jj_3R_265()) return true;
9279    Token xsp;
9280    xsp = jj_scanpos;
9281    if (jj_3R_281()) jj_scanpos = xsp;
9282    return false;
9283  }
9284
9285  public JavaParserTokenManager token_source;
9286  public Token token, jj_nt;
9287  private Token jj_scanpos, jj_lastpos;
9288  private int jj_la;
9289  public boolean lookingAhead = false;
9290  private boolean jj_semLA;
9291  private int jj_gen;
9292  final private int[] jj_la1 = new int[136];
9293  static private int[] jj_la1_0;
9294  static private int[] jj_la1_1;
9295  static private int[] jj_la1_2;
9296  static private int[] jj_la1_3;
9297  static {
9298      jj_la1_0();
9299      jj_la1_1();
9300      jj_la1_2();
9301      jj_la1_3();
9302   }
9303   private static void jj_la1_0() {
9304      jj_la1_0 = new int[] {0x0,0x10081000,0x0,0x0,0x0,0x0,0x0,0x10001000,0x10081000,0x10081000,0x10001000,0x10001000,0x10081000,0x0,0x4000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x510cb000,0x0,0x0,0x0,0x0,0x4000000,0x0,0x510cb000,0x4104a000,0x510cb000,0x0,0x0,0x0,0x4904a000,0x4904a000,0x0,0x0,0x0,0x0,0x0,0x0,0x5104a000,0x10000000,0x10000000,0x0,0x0,0x0,0x0,0x4904a000,0x0,0x4104a000,0x4104a000,0x0,0x4000000,0x4104a000,0x4000000,0x4104a000,0x4104a000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4904a000,0x0,0x0,0x4904a000,0x8000000,0x0,0x0,0x0,0x0,0x8000000,0x0,0x0,0x8000000,0x8000000,0x4904a000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc9a4e000,0x10000000,0x10000000,0x0,0x0,0x0,0x4904a000,0x410000,0x410000,0x2000000,0x5904a000,0x4904a000,0x4904a000,0x5904a000,0x4904a000,0x0,0x0,0x0,0x4904a000,0x20000,0x20000000,0x0,0x0,0x0,0x0,0x4904a000,0x0,0x4904a000,0x510cb000,0x400000,0x10081000,0x4104a000,0x510cb000,};
9305   }
9306   private static void jj_la1_1() {
9307      jj_la1_1 = new int[] {0x8,0x51127140,0x0,0x0,0x0,0x20000,0x0,0x51127100,0x40,0x51127140,0x0,0x0,0x40,0x0,0x0,0x4,0x0,0x0,0x4,0x0,0x0,0x0,0x0,0x591371e0,0x0,0x0,0x0,0x0,0x0,0x0,0x591371e0,0x80100a0,0x591371e0,0x0,0x0,0x0,0x8a2506a0,0x8a2506a0,0x0,0x0,0x800000,0x0,0x0,0x0,0x100a0,0x0,0x0,0x0,0x0,0x800000,0x240000,0x8a2506a0,0x20000,0x100a0,0x100a0,0x0,0x40000,0x100a0,0x40000,0x100a0,0x80100a0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8a2506a0,0x0,0x0,0x8a2506a0,0x82240600,0x0,0x0,0x0,0x0,0x82240600,0x0,0x0,0x82000400,0x2000000,0x8a2506a0,0x0,0x0,0x0,0x0,0x200,0x0,0x0,0xae7d86a2,0x0,0x0,0x0,0x0,0x0,0x8a2506a0,0x0,0x0,0x0,0x8a2506a0,0x8a2506a0,0x8a2506a0,0x8a2506a0,0x8a2506a0,0x0,0x0,0x0,0x8a2506a0,0x0,0x0,0x0,0x0,0x0,0x0,0x8a2506a0,0x0,0x8a2506a0,0x511371e0,0x0,0x40,0x100a0,0x511371e0,};
9308   }
9309   private static void jj_la1_2() {
9310      jj_la1_2 = new int[] {0x0,0x120100,0x0,0x0,0x100000,0x0,0x80000,0x100000,0x100100,0x120100,0x0,0x0,0x0,0x400000,0x0,0x0,0x40000,0x40000,0x0,0x100000,0x100000,0x100100,0x40000,0x522100,0x20000,0x800,0x2000,0x40000,0x0,0x0,0x522100,0x500100,0x520100,0x40000,0x200000,0x8000,0x18029d8,0x18029d8,0x40000,0x400000,0x0,0x22000,0x8000,0x40000,0x100100,0x100000,0x100000,0x0,0x400000,0x0,0x0,0x9d8,0x0,0x0,0x100,0x40000,0x0,0x2000100,0x0,0x0,0x100,0x40000,0x200000,0x200000,0x2000000,0x80000000,0x0,0x0,0x0,0x0,0x48000000,0x48000000,0x0,0x30400000,0x30400000,0x0,0x0,0x0,0x0,0x0,0x0,0x18009d8,0x1800000,0x1800000,0x9d8,0x18009d8,0x800,0x0,0x0,0x800,0x8d8,0x100,0x88800,0xd8,0x0,0x18009d8,0x40000,0x400000,0x2000,0x8800,0x0,0x8000,0x8000,0x229d8,0x100000,0x100000,0x40000,0x200000,0x0,0x9d8,0x0,0x0,0x0,0x1009d8,0x18009d8,0x9d8,0x1209d8,0x9d8,0x40000,0x100,0x100,0x18009d8,0x0,0x0,0x4000000,0x100000,0x100,0x40000,0x19029d8,0x40000,0x19029d8,0x120100,0x0,0x0,0x100100,0x120100,};
9311   }
9312   private static void jj_la1_3() {
9313      jj_la1_3 = new int[] {0x0,0x0,0x8000000,0x10000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80,0x0,0x0,0x0,0x0,0x0,0x0,0x1e,0x1e,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x800000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7ff000,0x7ff000,0x0,0x0,0x1,0x100,0x200,0x80,0x0,0x0,0x0,0x4000000,0x4000000,0x800,0x18,0x18,0x460,0x460,0x18,0x1e,0x0,0x0,0x0,0x0,0x0,0x6,0x6,0x0,0x0,0x0,0x0,0x0,0x0,0x1e,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x6,0x0,0x0,0x0,0x7ff000,0x6,0x0,0x0,0x0,0x0,0x6,0x1e,0x6,0x6,0x6,0x0,0x0,0x0,0x1e,0x0,0x0,0x0,0x0,0x0,0x0,0x1e,0x0,0x1e,0x0,0x0,0x0,0x0,0x0,};
9314   }
9315  final private JJCalls[] jj_2_rtns = new JJCalls[51];
9316  private boolean jj_rescan = false;
9317  private int jj_gc = 0;
9318
9319  public JavaParser(CharStream stream) {
9320    token_source = new JavaParserTokenManager(stream);
9321    token = new Token();
9322    token.next = jj_nt = token_source.getNextToken();
9323    jj_gen = 0;
9324    for (int i = 0; i < 136; i++) jj_la1[i] = -1;
9325    for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
9326  }
9327
9328  public void ReInit(CharStream stream) {
9329    token_source.ReInit(stream);
9330    token = new Token();
9331    token.next = jj_nt = token_source.getNextToken();
9332    jjtree.reset();
9333    jj_gen = 0;
9334    for (int i = 0; i < 136; i++) jj_la1[i] = -1;
9335    for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
9336  }
9337
9338  public JavaParser(JavaParserTokenManager tm) {
9339    token_source = tm;
9340    token = new Token();
9341    token.next = jj_nt = token_source.getNextToken();
9342    jj_gen = 0;
9343    for (int i = 0; i < 136; i++) jj_la1[i] = -1;
9344    for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
9345  }
9346
9347  public void ReInit(JavaParserTokenManager tm) {
9348    token_source = tm;
9349    token = new Token();
9350    token.next = jj_nt = token_source.getNextToken();
9351    jjtree.reset();
9352    jj_gen = 0;
9353    for (int i = 0; i < 136; i++) jj_la1[i] = -1;
9354    for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
9355  }
9356
9357  final private Token jj_consume_token(int kind) throws ParseException {
9358    Token oldToken = token;
9359    if ((token = jj_nt).next != null) jj_nt = jj_nt.next;
9360    else jj_nt = jj_nt.next = token_source.getNextToken();
9361    if (token.kind == kind) {
9362      jj_gen++;
9363      if (++jj_gc > 100) {
9364        jj_gc = 0;
9365        for (int i = 0; i < jj_2_rtns.length; i++) {
9366          JJCalls c = jj_2_rtns[i];
9367          while (c != null) {
9368            if (c.gen < jj_gen) c.first = null;
9369            c = c.next;
9370          }
9371        }
9372      }
9373      return token;
9374    }
9375    jj_nt = token;
9376    token = oldToken;
9377    jj_kind = kind;
9378    throw generateParseException();
9379  }
9380
9381  static private final class LookaheadSuccess extends java.lang.Error JavaDoc { }
9382  final private LookaheadSuccess jj_ls = new LookaheadSuccess();
9383  final private boolean jj_scan_token(int kind) {
9384    if (jj_scanpos == jj_lastpos) {
9385      jj_la--;
9386      if (jj_scanpos.next == null) {
9387        jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
9388      } else {
9389        jj_lastpos = jj_scanpos = jj_scanpos.next;
9390      }
9391    } else {
9392      jj_scanpos = jj_scanpos.next;
9393    }
9394    if (jj_rescan) {
9395      int i = 0; Token tok = token;
9396      while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; }
9397      if (tok != null) jj_add_error_token(kind, i);
9398    }
9399    if (jj_scanpos.kind != kind) return true;
9400    if (jj_la == 0 && jj_scanpos == jj_lastpos) throw jj_ls;
9401    return false;
9402  }
9403
9404  final public Token getNextToken() {
9405    if ((token = jj_nt).next != null) jj_nt = jj_nt.next;
9406    else jj_nt = jj_nt.next = token_source.getNextToken();
9407    jj_gen++;
9408    return token;
9409  }
9410
9411  final public Token getToken(int index) {
9412    Token t = lookingAhead ? jj_scanpos : token;
9413    for (int i = 0; i < index; i++) {
9414      if (t.next != null) t = t.next;
9415      else t = t.next = token_source.getNextToken();
9416    }
9417    return t;
9418  }
9419
9420  private java.util.Vector JavaDoc jj_expentries = new java.util.Vector JavaDoc();
9421  private int[] jj_expentry;
9422  private int jj_kind = -1;
9423  private int[] jj_lasttokens = new int[100];
9424  private int jj_endpos;
9425
9426  private void jj_add_error_token(int kind, int pos) {
9427    if (pos >= 100) return;
9428    if (pos == jj_endpos + 1) {
9429      jj_lasttokens[jj_endpos++] = kind;
9430    } else if (jj_endpos != 0) {
9431      jj_expentry = new int[jj_endpos];
9432      for (int i = 0; i < jj_endpos; i++) {
9433        jj_expentry[i] = jj_lasttokens[i];
9434      }
9435      boolean exists = false;
9436      for (java.util.Enumeration JavaDoc e = jj_expentries.elements(); e.hasMoreElements();) {
9437        int[] oldentry = (int[])(e.nextElement());
9438        if (oldentry.length == jj_expentry.length) {
9439          exists = true;
9440          for (int i = 0; i < jj_expentry.length; i++) {
9441            if (oldentry[i] != jj_expentry[i]) {
9442              exists = false;
9443              break;
9444            }
9445          }
9446          if (exists) break;
9447        }
9448      }
9449      if (!exists) jj_expentries.addElement(jj_expentry);
9450      if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind;
9451    }
9452  }
9453
9454  public ParseException generateParseException() {
9455    jj_expentries.removeAllElements();
9456    boolean[] la1tokens = new boolean[125];
9457    for (int i = 0; i < 125; i++) {
9458      la1tokens[i] = false;
9459    }
9460    if (jj_kind >= 0) {
9461      la1tokens[jj_kind] = true;
9462      jj_kind = -1;
9463    }
9464    for (int i = 0; i < 136; i++) {
9465      if (jj_la1[i] == jj_gen) {
9466        for (int j = 0; j < 32; j++) {
9467          if ((jj_la1_0[i] & (1<<j)) != 0) {
9468            la1tokens[j] = true;
9469          }
9470          if ((jj_la1_1[i] & (1<<j)) != 0) {
9471            la1tokens[32+j] = true;
9472          }
9473          if ((jj_la1_2[i] & (1<<j)) != 0) {
9474            la1tokens[64+j] = true;
9475          }
9476          if ((jj_la1_3[i] & (1<<j)) != 0) {
9477            la1tokens[96+j] = true;
9478          }
9479        }
9480      }
9481    }
9482    for (int i = 0; i < 125; i++) {
9483      if (la1tokens[i]) {
9484        jj_expentry = new int[1];
9485        jj_expentry[0] = i;
9486        jj_expentries.addElement(jj_expentry);
9487      }
9488    }
9489    jj_endpos = 0;
9490    jj_rescan_token();
9491    jj_add_error_token(0, 0);
9492    int[][] exptokseq = new int[jj_expentries.size()][];
9493    for (int i = 0; i < jj_expentries.size(); i++) {
9494      exptokseq[i] = (int[])jj_expentries.elementAt(i);
9495    }
9496    return new ParseException(token, exptokseq, tokenImage);
9497  }
9498
9499  final public void enable_tracing() {
9500  }
9501
9502  final public void disable_tracing() {
9503  }
9504
9505  final private void jj_rescan_token() {
9506    jj_rescan = true;
9507    for (int i = 0; i < 51; i++) {
9508    try {
9509      JJCalls p = jj_2_rtns[i];
9510      do {
9511        if (p.gen > jj_gen) {
9512          jj_la = p.arg; jj_lastpos = jj_scanpos = p.first;
9513          switch (i) {
9514            case 0: jj_3_1(); break;
9515            case 1: jj_3_2(); break;
9516            case 2: jj_3_3(); break;
9517            case 3: jj_3_4(); break;
9518            case 4: jj_3_5(); break;
9519            case 5: jj_3_6(); break;
9520            case 6: jj_3_7(); break;
9521            case 7: jj_3_8(); break;
9522            case 8: jj_3_9(); break;
9523            case 9: jj_3_10(); break;
9524            case 10: jj_3_11(); break;
9525            case 11: jj_3_12(); break;
9526            case 12: jj_3_13(); break;
9527            case 13: jj_3_14(); break;
9528            case 14: jj_3_15(); break;
9529            case 15: jj_3_16(); break;
9530            case 16: jj_3_17(); break;
9531            case 17: jj_3_18(); break;
9532            case 18: jj_3_19(); break;
9533            case 19: jj_3_20(); break;
9534            case 20: jj_3_21(); break;
9535            case 21: jj_3_22(); break;
9536            case 22: jj_3_23(); break;
9537            case 23: jj_3_24(); break;
9538            case 24: jj_3_25(); break;
9539            case 25: jj_3_26(); break;
9540            case 26: jj_3_27(); break;
9541            case 27: jj_3_28(); break;
9542            case 28: jj_3_29(); break;
9543            case 29: jj_3_30(); break;
9544            case 30: jj_3_31(); break;
9545            case 31: jj_3_32(); break;
9546            case 32: jj_3_33(); break;
9547            case 33: jj_3_34(); break;
9548            case 34: jj_3_35(); break;
9549            case 35: jj_3_36(); break;
9550            case 36: jj_3_37(); break;
9551            case 37: jj_3_38(); break;
9552            case 38: jj_3_39(); break;
9553            case 39: jj_3_40(); break;
9554            case 40: jj_3_41(); break;
9555            case 41: jj_3_42(); break;
9556            case 42: jj_3_43(); break;
9557            case 43: jj_3_44(); break;
9558            case 44: jj_3_45(); break;
9559            case 45: jj_3_46(); break;
9560            case 46: jj_3_47(); break;
9561            case 47: jj_3_48(); break;
9562            case 48: jj_3_49(); break;
9563            case 49: jj_3_50(); break;
9564            case 50: jj_3_51(); break;
9565          }
9566        }
9567        p = p.next;
9568      } while (p != null);
9569      } catch(LookaheadSuccess ls) { }
9570    }
9571    jj_rescan = false;
9572  }
9573
9574  final private void jj_save(int index, int xla) {
9575    JJCalls p = jj_2_rtns[index];
9576    while (p.gen > jj_gen) {
9577      if (p.next == null) { p = p.next = new JJCalls(); break; }
9578      p = p.next;
9579    }
9580    p.gen = jj_gen + xla - jj_la; p.first = token; p.arg = xla;
9581  }
9582
9583  static final class JJCalls {
9584    int gen;
9585    Token first;
9586    int arg;
9587    JJCalls next;
9588  }
9589
9590}
9591
Popular Tags