KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > ejen > ext > parsers > java_1_2 > JavaParser


1 /* Generated By:JJTree&JavaCC: Do not edit this line. JavaParser.java */
2 package org.ejen.ext.parsers.java_1_2;
3
4 public class JavaParser/* @bgen(jjtree)*/implements JavaParserTreeConstants, JavaParserConstants {/* @bgen(jjtree)*/
5     protected static JJTJavaParserState jjtree = new JJTJavaParserState();
6
7     /*****************************************
8      * THE JAVA LANGUAGE GRAMMAR STARTS HERE *
9      *****************************************/

10
11     /*
12      * Program structuring syntax follows.
13      */

14     static final public SimpleNode CompilationUnit() throws ParseException {
15
16         /* @bgen(jjtree) CompilationUnit */
17         SimpleNode jjtn000 = new SimpleNode(JJTCOMPILATIONUNIT);
18         boolean jjtc000 = true;
19
20         jjtree.openNodeScope(jjtn000);
21         try {
22             switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
23             case PACKAGE:
24                 PackageDeclaration();
25                 break;
26
27             default:
28                 jj_la1[0] = jj_gen;
29                 ;
30             }
31             label_1:
32             while (true) {
33                 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
34                 case IMPORT:
35                     ;
36                     break;
37
38                 default:
39                     jj_la1[1] = jj_gen;
40                     break label_1;
41                 }
42                 ImportDeclaration();
43             }
44             label_2:
45             while (true) {
46                 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
47                 case ABSTRACT:
48                 case CLASS:
49                 case FINAL:
50                 case INTERFACE:
51                 case PUBLIC:
52                 case STRICTFP:
53                 case SEMICOLON:
54                     ;
55                     break;
56
57                 default:
58                     jj_la1[2] = jj_gen;
59                     break label_2;
60                 }
61                 TypeDeclaration();
62             }
63             jj_consume_token(0);
64             jjtree.closeNodeScope(jjtn000, true);
65             jjtc000 = false; {
66                 if (true) {
67                     return jjtn000;
68                 }
69             }
70         } catch (Throwable JavaDoc jjte000) {
71             if (jjtc000) {
72                 jjtree.clearNodeScope(jjtn000);
73                 jjtc000 = false;
74             } else {
75                 jjtree.popNode();
76             }
77             if (jjte000 instanceof RuntimeException JavaDoc) { {
78                     if (true) {
79                         throw (RuntimeException JavaDoc) jjte000;
80                     }
81                 }
82             }
83             if (jjte000 instanceof ParseException) { {
84                     if (true) {
85                         throw (ParseException) jjte000;
86                     }
87                 }
88             } {
89                 if (true) {
90                     throw (Error JavaDoc) jjte000;
91                 }
92             }
93         }
94         finally {
95             if (jjtc000) {
96                 jjtree.closeNodeScope(jjtn000, true);
97             }
98         }
99         throw new Error JavaDoc("Missing return statement in function");
100     }
101
102     static final public void PackageDeclaration() throws ParseException {
103
104         /* @bgen(jjtree) PackageDeclaration */
105         SimpleNode jjtn000 = new SimpleNode(JJTPACKAGEDECLARATION);
106         boolean jjtc000 = true;
107
108         jjtree.openNodeScope(jjtn000);
109         try {
110             jj_consume_token(PACKAGE);
111             Name();
112             jj_consume_token(SEMICOLON);
113         } catch (Throwable JavaDoc jjte000) {
114             if (jjtc000) {
115                 jjtree.clearNodeScope(jjtn000);
116                 jjtc000 = false;
117             } else {
118                 jjtree.popNode();
119             }
120             if (jjte000 instanceof RuntimeException JavaDoc) { {
121                     if (true) {
122                         throw (RuntimeException JavaDoc) jjte000;
123                     }
124                 }
125             }
126             if (jjte000 instanceof ParseException) { {
127                     if (true) {
128                         throw (ParseException) jjte000;
129                     }
130                 }
131             } {
132                 if (true) {
133                     throw (Error JavaDoc) jjte000;
134                 }
135             }
136         }
137         finally {
138             if (jjtc000) {
139                 jjtree.closeNodeScope(jjtn000, true);
140             }
141         }
142     }
143
144     static final public void ImportDeclaration() throws ParseException {
145
146         /* @bgen(jjtree) ImportDeclaration */
147         SimpleNode jjtn000 = new SimpleNode(JJTIMPORTDECLARATION);
148         boolean jjtc000 = true;
149
150         jjtree.openNodeScope(jjtn000);
151         try {
152             jj_consume_token(IMPORT);
153             Name();
154             switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
155             case DOT:
156                 jj_consume_token(DOT);
157                 jj_consume_token(STAR);
158                 break;
159
160             default:
161                 jj_la1[3] = jj_gen;
162                 ;
163             }
164             jj_consume_token(SEMICOLON);
165         } catch (Throwable JavaDoc jjte000) {
166             if (jjtc000) {
167                 jjtree.clearNodeScope(jjtn000);
168                 jjtc000 = false;
169             } else {
170                 jjtree.popNode();
171             }
172             if (jjte000 instanceof RuntimeException JavaDoc) { {
173                     if (true) {
174                         throw (RuntimeException JavaDoc) jjte000;
175                     }
176                 }
177             }
178             if (jjte000 instanceof ParseException) { {
179                     if (true) {
180                         throw (ParseException) jjte000;
181                     }
182                 }
183             } {
184                 if (true) {
185                     throw (Error JavaDoc) jjte000;
186                 }
187             }
188         }
189         finally {
190             if (jjtc000) {
191                 jjtree.closeNodeScope(jjtn000, true);
192             }
193         }
194     }
195
196     static final public void TypeDeclaration() throws ParseException {
197
198         /* @bgen(jjtree) TypeDeclaration */
199         SimpleNode jjtn000 = new SimpleNode(JJTTYPEDECLARATION);
200         boolean jjtc000 = true;
201
202         jjtree.openNodeScope(jjtn000);
203         try {
204             if (jj_2_1(2147483647)) {
205                 ClassDeclaration();
206             } else {
207                 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
208                 case ABSTRACT:
209                 case INTERFACE:
210                 case PUBLIC:
211                 case STRICTFP:
212                     InterfaceDeclaration();
213                     break;
214
215                 case SEMICOLON:
216                     jj_consume_token(SEMICOLON);
217                     break;
218
219                 default:
220                     jj_la1[4] = jj_gen;
221                     jj_consume_token(-1);
222                     throw new ParseException();
223                 }
224             }
225         } catch (Throwable JavaDoc jjte000) {
226             if (jjtc000) {
227                 jjtree.clearNodeScope(jjtn000);
228                 jjtc000 = false;
229             } else {
230                 jjtree.popNode();
231             }
232             if (jjte000 instanceof RuntimeException JavaDoc) { {
233                     if (true) {
234                         throw (RuntimeException JavaDoc) jjte000;
235                     }
236                 }
237             }
238             if (jjte000 instanceof ParseException) { {
239                     if (true) {
240                         throw (ParseException) jjte000;
241                     }
242                 }
243             } {
244                 if (true) {
245                     throw (Error JavaDoc) jjte000;
246                 }
247             }
248         }
249         finally {
250             if (jjtc000) {
251                 jjtree.closeNodeScope(jjtn000, true);
252             }
253         }
254     }
255
256     /*
257      * Declaration syntax follows.
258      */

259     static final public void ClassDeclaration() throws ParseException {
260
261         /* @bgen(jjtree) ClassDeclaration */
262         SimpleNode jjtn000 = new SimpleNode(JJTCLASSDECLARATION);
263         boolean jjtc000 = true;
264
265         jjtree.openNodeScope(jjtn000);
266         try {
267             label_3:
268             while (true) {
269                 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
270                 case ABSTRACT:
271                 case FINAL:
272                 case PUBLIC:
273                 case STRICTFP:
274                     ;
275                     break;
276
277                 default:
278                     jj_la1[5] = jj_gen;
279                     break label_3;
280                 }
281                 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
282                 case ABSTRACT:
283                     jj_consume_token(ABSTRACT);
284                     break;
285
286                 case FINAL:
287                     jj_consume_token(FINAL);
288                     break;
289
290                 case PUBLIC:
291                     jj_consume_token(PUBLIC);
292                     break;
293
294                 case STRICTFP:
295                     jj_consume_token(STRICTFP);
296                     break;
297
298                 default:
299                     jj_la1[6] = jj_gen;
300                     jj_consume_token(-1);
301                     throw new ParseException();
302                 }
303             }
304             UnmodifiedClassDeclaration();
305         } catch (Throwable JavaDoc jjte000) {
306             if (jjtc000) {
307                 jjtree.clearNodeScope(jjtn000);
308                 jjtc000 = false;
309             } else {
310                 jjtree.popNode();
311             }
312             if (jjte000 instanceof RuntimeException JavaDoc) { {
313                     if (true) {
314                         throw (RuntimeException JavaDoc) jjte000;
315                     }
316                 }
317             }
318             if (jjte000 instanceof ParseException) { {
319                     if (true) {
320                         throw (ParseException) jjte000;
321                     }
322                 }
323             } {
324                 if (true) {
325                     throw (Error JavaDoc) jjte000;
326                 }
327             }
328         }
329         finally {
330             if (jjtc000) {
331                 jjtree.closeNodeScope(jjtn000, true);
332             }
333         }
334     }
335
336     static final public void UnmodifiedClassDeclaration() throws ParseException {
337
338         /* @bgen(jjtree) UnmodifiedClassDeclaration */
339         SimpleNode jjtn000 = new SimpleNode(JJTUNMODIFIEDCLASSDECLARATION);
340         boolean jjtc000 = true;
341
342         jjtree.openNodeScope(jjtn000);
343         try {
344             jj_consume_token(CLASS);
345             jj_consume_token(IDENTIFIER);
346             switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
347             case EXTENDS:
348                 jj_consume_token(EXTENDS);
349                 Name();
350                 break;
351
352             default:
353                 jj_la1[7] = jj_gen;
354                 ;
355             }
356             switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
357             case IMPLEMENTS:
358                 jj_consume_token(IMPLEMENTS);
359                 NameList();
360                 break;
361
362             default:
363                 jj_la1[8] = jj_gen;
364                 ;
365             }
366             ClassBody();
367         } catch (Throwable JavaDoc jjte000) {
368             if (jjtc000) {
369                 jjtree.clearNodeScope(jjtn000);
370                 jjtc000 = false;
371             } else {
372                 jjtree.popNode();
373             }
374             if (jjte000 instanceof RuntimeException JavaDoc) { {
375                     if (true) {
376                         throw (RuntimeException JavaDoc) jjte000;
377                     }
378                 }
379             }
380             if (jjte000 instanceof ParseException) { {
381                     if (true) {
382                         throw (ParseException) jjte000;
383                     }
384                 }
385             } {
386                 if (true) {
387                     throw (Error JavaDoc) jjte000;
388                 }
389             }
390         }
391         finally {
392             if (jjtc000) {
393                 jjtree.closeNodeScope(jjtn000, true);
394             }
395         }
396     }
397
398     static final public void ClassBody() throws ParseException {
399
400         /* @bgen(jjtree) ClassBody */
401         SimpleNode jjtn000 = new SimpleNode(JJTCLASSBODY);
402         boolean jjtc000 = true;
403
404         jjtree.openNodeScope(jjtn000);
405         try {
406             jj_consume_token(LBRACE);
407             label_4:
408             while (true) {
409                 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
410                 case ABSTRACT:
411                 case BOOLEAN:
412                 case BYTE:
413                 case CHAR:
414                 case CLASS:
415                 case DOUBLE:
416                 case FINAL:
417                 case FLOAT:
418                 case INT:
419                 case INTERFACE:
420                 case LONG:
421                 case NATIVE:
422                 case PRIVATE:
423                 case PROTECTED:
424                 case PUBLIC:
425                 case SHORT:
426                 case STATIC:
427                 case SYNCHRONIZED:
428                 case TRANSIENT:
429                 case VOID:
430                 case VOLATILE:
431                 case STRICTFP:
432                 case IDENTIFIER:
433                 case LBRACE:
434                     ;
435                     break;
436
437                 default:
438                     jj_la1[9] = jj_gen;
439                     break label_4;
440                 }
441                 ClassBodyDeclaration();
442             }
443             jj_consume_token(RBRACE);
444         } catch (Throwable JavaDoc jjte000) {
445             if (jjtc000) {
446                 jjtree.clearNodeScope(jjtn000);
447                 jjtc000 = false;
448             } else {
449                 jjtree.popNode();
450             }
451             if (jjte000 instanceof RuntimeException JavaDoc) { {
452                     if (true) {
453                         throw (RuntimeException JavaDoc) jjte000;
454                     }
455                 }
456             }
457             if (jjte000 instanceof ParseException) { {
458                     if (true) {
459                         throw (ParseException) jjte000;
460                     }
461                 }
462             } {
463                 if (true) {
464                     throw (Error JavaDoc) jjte000;
465                 }
466             }
467         }
468         finally {
469             if (jjtc000) {
470                 jjtree.closeNodeScope(jjtn000, true);
471             }
472         }
473     }
474
475     static final public void NestedClassDeclaration() throws ParseException {
476
477         /* @bgen(jjtree) NestedClassDeclaration */
478         SimpleNode jjtn000 = new SimpleNode(JJTNESTEDCLASSDECLARATION);
479         boolean jjtc000 = true;
480
481         jjtree.openNodeScope(jjtn000);
482         try {
483             label_5:
484             while (true) {
485                 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
486                 case ABSTRACT:
487                 case FINAL:
488                 case PRIVATE:
489                 case PROTECTED:
490                 case PUBLIC:
491                 case STATIC:
492                 case STRICTFP:
493                     ;
494                     break;
495
496                 default:
497                     jj_la1[10] = jj_gen;
498                     break label_5;
499                 }
500                 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
501                 case STATIC:
502                     jj_consume_token(STATIC);
503                     break;
504
505                 case ABSTRACT:
506                     jj_consume_token(ABSTRACT);
507                     break;
508
509                 case FINAL:
510                     jj_consume_token(FINAL);
511                     break;
512
513                 case PUBLIC:
514                     jj_consume_token(PUBLIC);
515                     break;
516
517                 case PROTECTED:
518                     jj_consume_token(PROTECTED);
519                     break;
520
521                 case PRIVATE:
522                     jj_consume_token(PRIVATE);
523                     break;
524
525                 case STRICTFP:
526                     jj_consume_token(STRICTFP);
527                     break;
528
529                 default:
530                     jj_la1[11] = jj_gen;
531                     jj_consume_token(-1);
532                     throw new ParseException();
533                 }
534             }
535             UnmodifiedClassDeclaration();
536         } catch (Throwable JavaDoc jjte000) {
537             if (jjtc000) {
538                 jjtree.clearNodeScope(jjtn000);
539                 jjtc000 = false;
540             } else {
541                 jjtree.popNode();
542             }
543             if (jjte000 instanceof RuntimeException JavaDoc) { {
544                     if (true) {
545                         throw (RuntimeException JavaDoc) jjte000;
546                     }
547                 }
548             }
549             if (jjte000 instanceof ParseException) { {
550                     if (true) {
551                         throw (ParseException) jjte000;
552                     }
553                 }
554             } {
555                 if (true) {
556                     throw (Error JavaDoc) jjte000;
557                 }
558             }
559         }
560         finally {
561             if (jjtc000) {
562                 jjtree.closeNodeScope(jjtn000, true);
563             }
564         }
565     }
566
567     static final public void ClassBodyDeclaration() throws ParseException {
568
569         /* @bgen(jjtree) ClassBodyDeclaration */
570         SimpleNode jjtn000 = new SimpleNode(JJTCLASSBODYDECLARATION);
571         boolean jjtc000 = true;
572
573         jjtree.openNodeScope(jjtn000);
574         try {
575             if (jj_2_2(2)) {
576                 Initializer();
577             } else if (jj_2_3(2147483647)) {
578                 NestedClassDeclaration();
579             } else if (jj_2_4(2147483647)) {
580                 NestedInterfaceDeclaration();
581             } else if (jj_2_5(2147483647)) {
582                 ConstructorDeclaration();
583             } else if (jj_2_6(2147483647)) {
584                 MethodDeclaration();
585             } else {
586                 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
587                 case BOOLEAN:
588                 case BYTE:
589                 case CHAR:
590                 case DOUBLE:
591                 case FINAL:
592                 case FLOAT:
593                 case INT:
594                 case LONG:
595                 case PRIVATE:
596                 case PROTECTED:
597                 case PUBLIC:
598                 case SHORT:
599                 case STATIC:
600                 case TRANSIENT:
601                 case VOLATILE:
602                 case IDENTIFIER:
603                     FieldDeclaration();
604                     break;
605
606                 default:
607                     jj_la1[12] = jj_gen;
608                     jj_consume_token(-1);
609                     throw new ParseException();
610                 }
611             }
612         } catch (Throwable JavaDoc jjte000) {
613             if (jjtc000) {
614                 jjtree.clearNodeScope(jjtn000);
615                 jjtc000 = false;
616             } else {
617                 jjtree.popNode();
618             }
619             if (jjte000 instanceof RuntimeException JavaDoc) { {
620                     if (true) {
621                         throw (RuntimeException JavaDoc) jjte000;
622                     }
623                 }
624             }
625             if (jjte000 instanceof ParseException) { {
626                     if (true) {
627                         throw (ParseException) jjte000;
628                     }
629                 }
630             } {
631                 if (true) {
632                     throw (Error JavaDoc) jjte000;
633                 }
634             }
635         }
636         finally {
637             if (jjtc000) {
638                 jjtree.closeNodeScope(jjtn000, true);
639             }
640         }
641     }
642
643     // This production is to determine lookahead only.
644
static final public void MethodDeclarationLookahead() throws ParseException {
645
646         /* @bgen(jjtree) MethodDeclarationLookahead */
647         SimpleNode jjtn000 = new SimpleNode(JJTMETHODDECLARATIONLOOKAHEAD);
648         boolean jjtc000 = true;
649
650         jjtree.openNodeScope(jjtn000);
651         try {
652             label_6:
653             while (true) {
654                 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
655                 case ABSTRACT:
656                 case FINAL:
657                 case NATIVE:
658                 case PRIVATE:
659                 case PROTECTED:
660                 case PUBLIC:
661                 case STATIC:
662                 case SYNCHRONIZED:
663                 case STRICTFP:
664                     ;
665                     break;
666
667                 default:
668                     jj_la1[13] = jj_gen;
669                     break label_6;
670                 }
671                 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
672                 case PUBLIC:
673                     jj_consume_token(PUBLIC);
674                     break;
675
676                 case PROTECTED:
677                     jj_consume_token(PROTECTED);
678                     break;
679
680                 case PRIVATE:
681                     jj_consume_token(PRIVATE);
682                     break;
683
684                 case STATIC:
685                     jj_consume_token(STATIC);
686                     break;
687
688                 case ABSTRACT:
689                     jj_consume_token(ABSTRACT);
690                     break;
691
692                 case FINAL:
693                     jj_consume_token(FINAL);
694                     break;
695
696                 case NATIVE:
697                     jj_consume_token(NATIVE);
698                     break;
699
700                 case SYNCHRONIZED:
701                     jj_consume_token(SYNCHRONIZED);
702                     break;
703
704                 case STRICTFP:
705                     jj_consume_token(STRICTFP);
706                     break;
707
708                 default:
709                     jj_la1[14] = jj_gen;
710                     jj_consume_token(-1);
711                     throw new ParseException();
712                 }
713             }
714             ResultType();
715             jj_consume_token(IDENTIFIER);
716             jj_consume_token(LPAREN);
717         } catch (Throwable JavaDoc jjte000) {
718             if (jjtc000) {
719                 jjtree.clearNodeScope(jjtn000);
720                 jjtc000 = false;
721             } else {
722                 jjtree.popNode();
723             }
724             if (jjte000 instanceof RuntimeException JavaDoc) { {
725                     if (true) {
726                         throw (RuntimeException JavaDoc) jjte000;
727                     }
728                 }
729             }
730             if (jjte000 instanceof ParseException) { {
731                     if (true) {
732                         throw (ParseException) jjte000;
733                     }
734                 }
735             } {
736                 if (true) {
737                     throw (Error JavaDoc) jjte000;
738                 }
739             }
740         }
741         finally {
742             if (jjtc000) {
743                 jjtree.closeNodeScope(jjtn000, true);
744             }
745         }
746     }
747
748     static final public void InterfaceDeclaration() throws ParseException {
749
750         /* @bgen(jjtree) InterfaceDeclaration */
751         SimpleNode jjtn000 = new SimpleNode(JJTINTERFACEDECLARATION);
752         boolean jjtc000 = true;
753
754         jjtree.openNodeScope(jjtn000);
755         try {
756             label_7:
757             while (true) {
758                 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
759                 case ABSTRACT:
760                 case PUBLIC:
761                 case STRICTFP:
762                     ;
763                     break;
764
765                 default:
766                     jj_la1[15] = jj_gen;
767                     break label_7;
768                 }
769                 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
770                 case ABSTRACT:
771                     jj_consume_token(ABSTRACT);
772                     break;
773
774                 case PUBLIC:
775                     jj_consume_token(PUBLIC);
776                     break;
777
778                 case STRICTFP:
779                     jj_consume_token(STRICTFP);
780                     break;
781
782                 default:
783                     jj_la1[16] = jj_gen;
784                     jj_consume_token(-1);
785                     throw new ParseException();
786                 }
787             }
788             UnmodifiedInterfaceDeclaration();
789         } catch (Throwable JavaDoc jjte000) {
790             if (jjtc000) {
791                 jjtree.clearNodeScope(jjtn000);
792                 jjtc000 = false;
793             } else {
794                 jjtree.popNode();
795             }
796             if (jjte000 instanceof RuntimeException JavaDoc) { {
797                     if (true) {
798                         throw (RuntimeException JavaDoc) jjte000;
799                     }
800                 }
801             }
802             if (jjte000 instanceof ParseException) { {
803                     if (true) {
804                         throw (ParseException) jjte000;
805                     }
806                 }
807             } {
808                 if (true) {
809                     throw (Error JavaDoc) jjte000;
810                 }
811             }
812         }
813         finally {
814             if (jjtc000) {
815                 jjtree.closeNodeScope(jjtn000, true);
816             }
817         }
818     }
819
820     static final public void NestedInterfaceDeclaration() throws ParseException {
821
822         /* @bgen(jjtree) NestedInterfaceDeclaration */
823         SimpleNode jjtn000 = new SimpleNode(JJTNESTEDINTERFACEDECLARATION);
824         boolean jjtc000 = true;
825
826         jjtree.openNodeScope(jjtn000);
827         try {
828             label_8:
829             while (true) {
830                 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
831                 case ABSTRACT:
832                 case FINAL:
833                 case PRIVATE:
834                 case PROTECTED:
835                 case PUBLIC:
836                 case STATIC:
837                 case STRICTFP:
838                     ;
839                     break;
840
841                 default:
842                     jj_la1[17] = jj_gen;
843                     break label_8;
844                 }
845                 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
846                 case STATIC:
847                     jj_consume_token(STATIC);
848                     break;
849
850                 case ABSTRACT:
851                     jj_consume_token(ABSTRACT);
852                     break;
853
854                 case FINAL:
855                     jj_consume_token(FINAL);
856                     break;
857
858                 case PUBLIC:
859                     jj_consume_token(PUBLIC);
860                     break;
861
862                 case PROTECTED:
863                     jj_consume_token(PROTECTED);
864                     break;
865
866                 case PRIVATE:
867                     jj_consume_token(PRIVATE);
868                     break;
869
870                 case STRICTFP:
871                     jj_consume_token(STRICTFP);
872                     break;
873
874                 default:
875                     jj_la1[18] = jj_gen;
876                     jj_consume_token(-1);
877                     throw new ParseException();
878                 }
879             }
880             UnmodifiedInterfaceDeclaration();
881         } catch (Throwable JavaDoc jjte000) {
882             if (jjtc000) {
883                 jjtree.clearNodeScope(jjtn000);
884                 jjtc000 = false;
885             } else {
886                 jjtree.popNode();
887             }
888             if (jjte000 instanceof RuntimeException JavaDoc) { {
889                     if (true) {
890                         throw (RuntimeException JavaDoc) jjte000;
891                     }
892                 }
893             }
894             if (jjte000 instanceof ParseException) { {
895                     if (true) {
896                         throw (ParseException) jjte000;
897                     }
898                 }
899             } {
900                 if (true) {
901                     throw (Error JavaDoc) jjte000;
902                 }
903             }
904         }
905         finally {
906             if (jjtc000) {
907                 jjtree.closeNodeScope(jjtn000, true);
908             }
909         }
910     }
911
912     static final public void UnmodifiedInterfaceDeclaration() throws ParseException {
913
914         /* @bgen(jjtree) UnmodifiedInterfaceDeclaration */
915         SimpleNode jjtn000 = new SimpleNode(JJTUNMODIFIEDINTERFACEDECLARATION);
916         boolean jjtc000 = true;
917
918         jjtree.openNodeScope(jjtn000);
919         try {
920             jj_consume_token(INTERFACE);
921             jj_consume_token(IDENTIFIER);
922             switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
923             case EXTENDS:
924                 jj_consume_token(EXTENDS);
925                 NameList();
926                 break;
927
928             default:
929                 jj_la1[19] = jj_gen;
930                 ;
931             }
932             jj_consume_token(LBRACE);
933             label_9:
934             while (true) {
935                 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
936                 case ABSTRACT:
937                 case BOOLEAN:
938                 case BYTE:
939                 case CHAR:
940                 case CLASS:
941                 case DOUBLE:
942                 case FINAL:
943                 case FLOAT:
944                 case INT:
945                 case INTERFACE:
946                 case LONG:
947                 case NATIVE:
948                 case PRIVATE:
949                 case PROTECTED:
950                 case PUBLIC:
951                 case SHORT:
952                 case STATIC:
953                 case SYNCHRONIZED:
954                 case TRANSIENT:
955                 case VOID:
956                 case VOLATILE:
957                 case STRICTFP:
958                 case IDENTIFIER:
959                     ;
960                     break;
961
962                 default:
963                     jj_la1[20] = jj_gen;
964                     break label_9;
965                 }
966                 InterfaceMemberDeclaration();
967             }
968             jj_consume_token(RBRACE);
969         } catch (Throwable JavaDoc jjte000) {
970             if (jjtc000) {
971                 jjtree.clearNodeScope(jjtn000);
972                 jjtc000 = false;
973             } else {
974                 jjtree.popNode();
975             }
976             if (jjte000 instanceof RuntimeException JavaDoc) { {
977                     if (true) {
978                         throw (RuntimeException JavaDoc) jjte000;
979                     }
980                 }
981             }
982             if (jjte000 instanceof ParseException) { {
983                     if (true) {
984                         throw (ParseException) jjte000;
985                     }
986                 }
987             } {
988                 if (true) {
989                     throw (Error JavaDoc) jjte000;
990                 }
991             }
992         }
993         finally {
994             if (jjtc000) {
995                 jjtree.closeNodeScope(jjtn000, true);
996             }
997         }
998     }
999
1000    static final public void InterfaceMemberDeclaration() throws ParseException {
1001
1002        /* @bgen(jjtree) InterfaceMemberDeclaration */
1003        SimpleNode jjtn000 = new SimpleNode(JJTINTERFACEMEMBERDECLARATION);
1004        boolean jjtc000 = true;
1005
1006        jjtree.openNodeScope(jjtn000);
1007        try {
1008            if (jj_2_7(2147483647)) {
1009                NestedClassDeclaration();
1010            } else if (jj_2_8(2147483647)) {
1011                NestedInterfaceDeclaration();
1012            } else if (jj_2_9(2147483647)) {
1013                MethodDeclaration();
1014            } else {
1015                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1016                case BOOLEAN:
1017                case BYTE:
1018                case CHAR:
1019                case DOUBLE:
1020                case FINAL:
1021                case FLOAT:
1022                case INT:
1023                case LONG:
1024                case PRIVATE:
1025                case PROTECTED:
1026                case PUBLIC:
1027                case SHORT:
1028                case STATIC:
1029                case TRANSIENT:
1030                case VOLATILE:
1031                case IDENTIFIER:
1032                    FieldDeclaration();
1033                    break;
1034
1035                default:
1036                    jj_la1[21] = jj_gen;
1037                    jj_consume_token(-1);
1038                    throw new ParseException();
1039                }
1040            }
1041        } catch (Throwable JavaDoc jjte000) {
1042            if (jjtc000) {
1043                jjtree.clearNodeScope(jjtn000);
1044                jjtc000 = false;
1045            } else {
1046                jjtree.popNode();
1047            }
1048            if (jjte000 instanceof RuntimeException JavaDoc) { {
1049                    if (true) {
1050                        throw (RuntimeException JavaDoc) jjte000;
1051                    }
1052                }
1053            }
1054            if (jjte000 instanceof ParseException) { {
1055                    if (true) {
1056                        throw (ParseException) jjte000;
1057                    }
1058                }
1059            } {
1060                if (true) {
1061                    throw (Error JavaDoc) jjte000;
1062                }
1063            }
1064        }
1065        finally {
1066            if (jjtc000) {
1067                jjtree.closeNodeScope(jjtn000, true);
1068            }
1069        }
1070    }
1071
1072    static final public void FieldDeclaration() throws ParseException {
1073
1074        /* @bgen(jjtree) FieldDeclaration */
1075        SimpleNode jjtn000 = new SimpleNode(JJTFIELDDECLARATION);
1076        boolean jjtc000 = true;
1077
1078        jjtree.openNodeScope(jjtn000);
1079        try {
1080            label_10:
1081            while (true) {
1082                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1083                case FINAL:
1084                case PRIVATE:
1085                case PROTECTED:
1086                case PUBLIC:
1087                case STATIC:
1088                case TRANSIENT:
1089                case VOLATILE:
1090                    ;
1091                    break;
1092
1093                default:
1094                    jj_la1[22] = jj_gen;
1095                    break label_10;
1096                }
1097                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1098                case PUBLIC:
1099                    jj_consume_token(PUBLIC);
1100                    break;
1101
1102                case PROTECTED:
1103                    jj_consume_token(PROTECTED);
1104                    break;
1105
1106                case PRIVATE:
1107                    jj_consume_token(PRIVATE);
1108                    break;
1109
1110                case STATIC:
1111                    jj_consume_token(STATIC);
1112                    break;
1113
1114                case FINAL:
1115                    jj_consume_token(FINAL);
1116                    break;
1117
1118                case TRANSIENT:
1119                    jj_consume_token(TRANSIENT);
1120                    break;
1121
1122                case VOLATILE:
1123                    jj_consume_token(VOLATILE);
1124                    break;
1125
1126                default:
1127                    jj_la1[23] = jj_gen;
1128                    jj_consume_token(-1);
1129                    throw new ParseException();
1130                }
1131            }
1132            Type();
1133            VariableDeclarator();
1134            label_11:
1135            while (true) {
1136                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1137                case COMMA:
1138                    ;
1139                    break;
1140
1141                default:
1142                    jj_la1[24] = jj_gen;
1143                    break label_11;
1144                }
1145                jj_consume_token(COMMA);
1146                VariableDeclarator();
1147            }
1148            jj_consume_token(SEMICOLON);
1149        } catch (Throwable JavaDoc jjte000) {
1150            if (jjtc000) {
1151                jjtree.clearNodeScope(jjtn000);
1152                jjtc000 = false;
1153            } else {
1154                jjtree.popNode();
1155            }
1156            if (jjte000 instanceof RuntimeException JavaDoc) { {
1157                    if (true) {
1158                        throw (RuntimeException JavaDoc) jjte000;
1159                    }
1160                }
1161            }
1162            if (jjte000 instanceof ParseException) { {
1163                    if (true) {
1164                        throw (ParseException) jjte000;
1165                    }
1166                }
1167            } {
1168                if (true) {
1169                    throw (Error JavaDoc) jjte000;
1170                }
1171            }
1172        }
1173        finally {
1174            if (jjtc000) {
1175                jjtree.closeNodeScope(jjtn000, true);
1176            }
1177        }
1178    }
1179
1180    static final public void VariableDeclarator() throws ParseException {
1181
1182        /* @bgen(jjtree) VariableDeclarator */
1183        SimpleNode jjtn000 = new SimpleNode(JJTVARIABLEDECLARATOR);
1184        boolean jjtc000 = true;
1185
1186        jjtree.openNodeScope(jjtn000);
1187        try {
1188            VariableDeclaratorId();
1189            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1190            case ASSIGN:
1191                jj_consume_token(ASSIGN);
1192                VariableInitializer();
1193                break;
1194
1195            default:
1196                jj_la1[25] = jj_gen;
1197                ;
1198            }
1199        } catch (Throwable JavaDoc jjte000) {
1200            if (jjtc000) {
1201                jjtree.clearNodeScope(jjtn000);
1202                jjtc000 = false;
1203            } else {
1204                jjtree.popNode();
1205            }
1206            if (jjte000 instanceof RuntimeException JavaDoc) { {
1207                    if (true) {
1208                        throw (RuntimeException JavaDoc) jjte000;
1209                    }
1210                }
1211            }
1212            if (jjte000 instanceof ParseException) { {
1213                    if (true) {
1214                        throw (ParseException) jjte000;
1215                    }
1216                }
1217            } {
1218                if (true) {
1219                    throw (Error JavaDoc) jjte000;
1220                }
1221            }
1222        }
1223        finally {
1224            if (jjtc000) {
1225                jjtree.closeNodeScope(jjtn000, true);
1226            }
1227        }
1228    }
1229
1230    static final public void VariableDeclaratorId() throws ParseException {
1231
1232        /* @bgen(jjtree) VariableDeclaratorId */
1233        SimpleNode jjtn000 = new SimpleNode(JJTVARIABLEDECLARATORID);
1234        boolean jjtc000 = true;
1235
1236        jjtree.openNodeScope(jjtn000);
1237        try {
1238            jj_consume_token(IDENTIFIER);
1239            label_12:
1240            while (true) {
1241                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1242                case LBRACKET:
1243                    ;
1244                    break;
1245
1246                default:
1247                    jj_la1[26] = jj_gen;
1248                    break label_12;
1249                }
1250                jj_consume_token(LBRACKET);
1251                jj_consume_token(RBRACKET);
1252            }
1253        }
1254        finally {
1255            if (jjtc000) {
1256                jjtree.closeNodeScope(jjtn000, true);
1257            }
1258        }
1259    }
1260
1261    static final public void VariableInitializer() throws ParseException {
1262
1263        /* @bgen(jjtree) VariableInitializer */
1264        SimpleNode jjtn000 = new SimpleNode(JJTVARIABLEINITIALIZER);
1265        boolean jjtc000 = true;
1266
1267        jjtree.openNodeScope(jjtn000);
1268        try {
1269            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1270            case LBRACE:
1271                ArrayInitializer();
1272                break;
1273
1274            case BOOLEAN:
1275            case BYTE:
1276            case CHAR:
1277            case DOUBLE:
1278            case FALSE:
1279            case FLOAT:
1280            case INT:
1281            case LONG:
1282            case NEW:
1283            case NULL:
1284            case SHORT:
1285            case SUPER:
1286            case THIS:
1287            case TRUE:
1288            case VOID:
1289            case INTEGER_LITERAL:
1290            case FLOATING_POINT_LITERAL:
1291            case CHARACTER_LITERAL:
1292            case STRING_LITERAL:
1293            case IDENTIFIER:
1294            case LPAREN:
1295            case BANG:
1296            case TILDE:
1297            case INCR:
1298            case DECR:
1299            case PLUS:
1300            case MINUS:
1301                Expression();
1302                break;
1303
1304            default:
1305                jj_la1[27] = jj_gen;
1306                jj_consume_token(-1);
1307                throw new ParseException();
1308            }
1309        } catch (Throwable JavaDoc jjte000) {
1310            if (jjtc000) {
1311                jjtree.clearNodeScope(jjtn000);
1312                jjtc000 = false;
1313            } else {
1314                jjtree.popNode();
1315            }
1316            if (jjte000 instanceof RuntimeException JavaDoc) { {
1317                    if (true) {
1318                        throw (RuntimeException JavaDoc) jjte000;
1319                    }
1320                }
1321            }
1322            if (jjte000 instanceof ParseException) { {
1323                    if (true) {
1324                        throw (ParseException) jjte000;
1325                    }
1326                }
1327            } {
1328                if (true) {
1329                    throw (Error JavaDoc) jjte000;
1330                }
1331            }
1332        }
1333        finally {
1334            if (jjtc000) {
1335                jjtree.closeNodeScope(jjtn000, true);
1336            }
1337        }
1338    }
1339
1340    static final public void ArrayInitializer() throws ParseException {
1341
1342        /* @bgen(jjtree) ArrayInitializer */
1343        SimpleNode jjtn000 = new SimpleNode(JJTARRAYINITIALIZER);
1344        boolean jjtc000 = true;
1345
1346        jjtree.openNodeScope(jjtn000);
1347        try {
1348            jj_consume_token(LBRACE);
1349            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1350            case BOOLEAN:
1351            case BYTE:
1352            case CHAR:
1353            case DOUBLE:
1354            case FALSE:
1355            case FLOAT:
1356            case INT:
1357            case LONG:
1358            case NEW:
1359            case NULL:
1360            case SHORT:
1361            case SUPER:
1362            case THIS:
1363            case TRUE:
1364            case VOID:
1365            case INTEGER_LITERAL:
1366            case FLOATING_POINT_LITERAL:
1367            case CHARACTER_LITERAL:
1368            case STRING_LITERAL:
1369            case IDENTIFIER:
1370            case LPAREN:
1371            case LBRACE:
1372            case BANG:
1373            case TILDE:
1374            case INCR:
1375            case DECR:
1376            case PLUS:
1377            case MINUS:
1378                VariableInitializer();
1379                label_13:
1380                while (true) {
1381                    if (jj_2_10(2)) {
1382                        ;
1383                    } else {
1384                        break label_13;
1385                    }
1386                    jj_consume_token(COMMA);
1387                    VariableInitializer();
1388                }
1389                break;
1390
1391            default:
1392                jj_la1[28] = jj_gen;
1393                ;
1394            }
1395            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1396            case COMMA:
1397                jj_consume_token(COMMA);
1398                break;
1399
1400            default:
1401                jj_la1[29] = jj_gen;
1402                ;
1403            }
1404            jj_consume_token(RBRACE);
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) {
1414                        throw (RuntimeException JavaDoc) jjte000;
1415                    }
1416                }
1417            }
1418            if (jjte000 instanceof ParseException) { {
1419                    if (true) {
1420                        throw (ParseException) jjte000;
1421                    }
1422                }
1423            } {
1424                if (true) {
1425                    throw (Error JavaDoc) jjte000;
1426                }
1427            }
1428        }
1429        finally {
1430            if (jjtc000) {
1431                jjtree.closeNodeScope(jjtn000, true);
1432            }
1433        }
1434    }
1435
1436    static final public void MethodDeclaration() throws ParseException {
1437
1438        /* @bgen(jjtree) MethodDeclaration */
1439        SimpleNode jjtn000 = new SimpleNode(JJTMETHODDECLARATION);
1440        boolean jjtc000 = true;
1441
1442        jjtree.openNodeScope(jjtn000);
1443        try {
1444            label_14:
1445            while (true) {
1446                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1447                case ABSTRACT:
1448                case FINAL:
1449                case NATIVE:
1450                case PRIVATE:
1451                case PROTECTED:
1452                case PUBLIC:
1453                case STATIC:
1454                case SYNCHRONIZED:
1455                case STRICTFP:
1456                    ;
1457                    break;
1458
1459                default:
1460                    jj_la1[30] = jj_gen;
1461                    break label_14;
1462                }
1463                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1464                case PUBLIC:
1465                    jj_consume_token(PUBLIC);
1466                    break;
1467
1468                case PROTECTED:
1469                    jj_consume_token(PROTECTED);
1470                    break;
1471
1472                case PRIVATE:
1473                    jj_consume_token(PRIVATE);
1474                    break;
1475
1476                case STATIC:
1477                    jj_consume_token(STATIC);
1478                    break;
1479
1480                case ABSTRACT:
1481                    jj_consume_token(ABSTRACT);
1482                    break;
1483
1484                case FINAL:
1485                    jj_consume_token(FINAL);
1486                    break;
1487
1488                case NATIVE:
1489                    jj_consume_token(NATIVE);
1490                    break;
1491
1492                case SYNCHRONIZED:
1493                    jj_consume_token(SYNCHRONIZED);
1494                    break;
1495
1496                case STRICTFP:
1497                    jj_consume_token(STRICTFP);
1498                    break;
1499
1500                default:
1501                    jj_la1[31] = jj_gen;
1502                    jj_consume_token(-1);
1503                    throw new ParseException();
1504                }
1505            }
1506            ResultType();
1507            MethodDeclarator();
1508            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1509            case THROWS:
1510                jj_consume_token(THROWS);
1511                NameList();
1512                break;
1513
1514            default:
1515                jj_la1[32] = jj_gen;
1516                ;
1517            }
1518            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1519            case LBRACE:
1520                Block();
1521                break;
1522
1523            case SEMICOLON:
1524                jj_consume_token(SEMICOLON);
1525                break;
1526
1527            default:
1528                jj_la1[33] = jj_gen;
1529                jj_consume_token(-1);
1530                throw new ParseException();
1531            }
1532        } catch (Throwable JavaDoc jjte000) {
1533            if (jjtc000) {
1534                jjtree.clearNodeScope(jjtn000);
1535                jjtc000 = false;
1536            } else {
1537                jjtree.popNode();
1538            }
1539            if (jjte000 instanceof RuntimeException JavaDoc) { {
1540                    if (true) {
1541                        throw (RuntimeException JavaDoc) jjte000;
1542                    }
1543                }
1544            }
1545            if (jjte000 instanceof ParseException) { {
1546                    if (true) {
1547                        throw (ParseException) jjte000;
1548                    }
1549                }
1550            } {
1551                if (true) {
1552                    throw (Error JavaDoc) jjte000;
1553                }
1554            }
1555        }
1556        finally {
1557            if (jjtc000) {
1558                jjtree.closeNodeScope(jjtn000, true);
1559            }
1560        }
1561    }
1562
1563    static final public void MethodDeclarator() throws ParseException {
1564
1565        /* @bgen(jjtree) MethodDeclarator */
1566        SimpleNode jjtn000 = new SimpleNode(JJTMETHODDECLARATOR);
1567        boolean jjtc000 = true;
1568
1569        jjtree.openNodeScope(jjtn000);
1570        try {
1571            jj_consume_token(IDENTIFIER);
1572            FormalParameters();
1573            label_15:
1574            while (true) {
1575                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1576                case LBRACKET:
1577                    ;
1578                    break;
1579
1580                default:
1581                    jj_la1[34] = jj_gen;
1582                    break label_15;
1583                }
1584                jj_consume_token(LBRACKET);
1585                jj_consume_token(RBRACKET);
1586            }
1587        } catch (Throwable JavaDoc jjte000) {
1588            if (jjtc000) {
1589                jjtree.clearNodeScope(jjtn000);
1590                jjtc000 = false;
1591            } else {
1592                jjtree.popNode();
1593            }
1594            if (jjte000 instanceof RuntimeException JavaDoc) { {
1595                    if (true) {
1596                        throw (RuntimeException JavaDoc) jjte000;
1597                    }
1598                }
1599            }
1600            if (jjte000 instanceof ParseException) { {
1601                    if (true) {
1602                        throw (ParseException) jjte000;
1603                    }
1604                }
1605            } {
1606                if (true) {
1607                    throw (Error JavaDoc) jjte000;
1608                }
1609            }
1610        }
1611        finally {
1612            if (jjtc000) {
1613                jjtree.closeNodeScope(jjtn000, true);
1614            }
1615        }
1616    }
1617
1618    static final public void FormalParameters() throws ParseException {
1619
1620        /* @bgen(jjtree) FormalParameters */
1621        SimpleNode jjtn000 = new SimpleNode(JJTFORMALPARAMETERS);
1622        boolean jjtc000 = true;
1623
1624        jjtree.openNodeScope(jjtn000);
1625        try {
1626            jj_consume_token(LPAREN);
1627            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1628            case BOOLEAN:
1629            case BYTE:
1630            case CHAR:
1631            case DOUBLE:
1632            case FINAL:
1633            case FLOAT:
1634            case INT:
1635            case LONG:
1636            case SHORT:
1637            case IDENTIFIER:
1638                FormalParameter();
1639                label_16:
1640                while (true) {
1641                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1642                    case COMMA:
1643                        ;
1644                        break;
1645
1646                    default:
1647                        jj_la1[35] = jj_gen;
1648                        break label_16;
1649                    }
1650                    jj_consume_token(COMMA);
1651                    FormalParameter();
1652                }
1653                break;
1654
1655            default:
1656                jj_la1[36] = jj_gen;
1657                ;
1658            }
1659            jj_consume_token(RPAREN);
1660        } catch (Throwable JavaDoc jjte000) {
1661            if (jjtc000) {
1662                jjtree.clearNodeScope(jjtn000);
1663                jjtc000 = false;
1664            } else {
1665                jjtree.popNode();
1666            }
1667            if (jjte000 instanceof RuntimeException JavaDoc) { {
1668                    if (true) {
1669                        throw (RuntimeException JavaDoc) jjte000;
1670                    }
1671                }
1672            }
1673            if (jjte000 instanceof ParseException) { {
1674                    if (true) {
1675                        throw (ParseException) jjte000;
1676                    }
1677                }
1678            } {
1679                if (true) {
1680                    throw (Error JavaDoc) jjte000;
1681                }
1682            }
1683        }
1684        finally {
1685            if (jjtc000) {
1686                jjtree.closeNodeScope(jjtn000, true);
1687            }
1688        }
1689    }
1690
1691    static final public void FormalParameter() throws ParseException {
1692
1693        /* @bgen(jjtree) FormalParameter */
1694        SimpleNode jjtn000 = new SimpleNode(JJTFORMALPARAMETER);
1695        boolean jjtc000 = true;
1696
1697        jjtree.openNodeScope(jjtn000);
1698        try {
1699            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1700            case FINAL:
1701                jj_consume_token(FINAL);
1702                break;
1703
1704            default:
1705                jj_la1[37] = jj_gen;
1706                ;
1707            }
1708            Type();
1709            VariableDeclaratorId();
1710        } catch (Throwable JavaDoc jjte000) {
1711            if (jjtc000) {
1712                jjtree.clearNodeScope(jjtn000);
1713                jjtc000 = false;
1714            } else {
1715                jjtree.popNode();
1716            }
1717            if (jjte000 instanceof RuntimeException JavaDoc) { {
1718                    if (true) {
1719                        throw (RuntimeException JavaDoc) jjte000;
1720                    }
1721                }
1722            }
1723            if (jjte000 instanceof ParseException) { {
1724                    if (true) {
1725                        throw (ParseException) jjte000;
1726                    }
1727                }
1728            } {
1729                if (true) {
1730                    throw (Error JavaDoc) jjte000;
1731                }
1732            }
1733        }
1734        finally {
1735            if (jjtc000) {
1736                jjtree.closeNodeScope(jjtn000, true);
1737            }
1738        }
1739    }
1740
1741    static final public void ConstructorDeclaration() throws ParseException {
1742
1743        /* @bgen(jjtree) ConstructorDeclaration */
1744        SimpleNode jjtn000 = new SimpleNode(JJTCONSTRUCTORDECLARATION);
1745        boolean jjtc000 = true;
1746
1747        jjtree.openNodeScope(jjtn000);
1748        try {
1749            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1750            case PRIVATE:
1751            case PROTECTED:
1752            case PUBLIC:
1753                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1754                case PUBLIC:
1755                    jj_consume_token(PUBLIC);
1756                    break;
1757
1758                case PROTECTED:
1759                    jj_consume_token(PROTECTED);
1760                    break;
1761
1762                case PRIVATE:
1763                    jj_consume_token(PRIVATE);
1764                    break;
1765
1766                default:
1767                    jj_la1[38] = jj_gen;
1768                    jj_consume_token(-1);
1769                    throw new ParseException();
1770                }
1771                break;
1772
1773            default:
1774                jj_la1[39] = jj_gen;
1775                ;
1776            }
1777            jj_consume_token(IDENTIFIER);
1778            FormalParameters();
1779            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1780            case THROWS:
1781                jj_consume_token(THROWS);
1782                NameList();
1783                break;
1784
1785            default:
1786                jj_la1[40] = jj_gen;
1787                ;
1788            }
1789            jj_consume_token(LBRACE);
1790            if (jj_2_11(2147483647)) {
1791                ExplicitConstructorInvocation();
1792            } else {
1793                ;
1794            }
1795            label_17:
1796            while (true) {
1797                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1798                case BOOLEAN:
1799                case BREAK:
1800                case BYTE:
1801                case CHAR:
1802                case CLASS:
1803                case CONTINUE:
1804                case DO:
1805                case DOUBLE:
1806                case FALSE:
1807                case FINAL:
1808                case FLOAT:
1809                case FOR:
1810                case IF:
1811                case INT:
1812                case INTERFACE:
1813                case LONG:
1814                case NEW:
1815                case NULL:
1816                case RETURN:
1817                case SHORT:
1818                case SUPER:
1819                case SWITCH:
1820                case SYNCHRONIZED:
1821                case THIS:
1822                case THROW:
1823                case TRUE:
1824                case TRY:
1825                case VOID:
1826                case WHILE:
1827                case INTEGER_LITERAL:
1828                case FLOATING_POINT_LITERAL:
1829                case CHARACTER_LITERAL:
1830                case STRING_LITERAL:
1831                case IDENTIFIER:
1832                case LPAREN:
1833                case LBRACE:
1834                case SEMICOLON:
1835                case INCR:
1836                case DECR:
1837                    ;
1838                    break;
1839
1840                default:
1841                    jj_la1[41] = jj_gen;
1842                    break label_17;
1843                }
1844                BlockStatement();
1845            }
1846            jj_consume_token(RBRACE);
1847        } catch (Throwable JavaDoc jjte000) {
1848            if (jjtc000) {
1849                jjtree.clearNodeScope(jjtn000);
1850                jjtc000 = false;
1851            } else {
1852                jjtree.popNode();
1853            }
1854            if (jjte000 instanceof RuntimeException JavaDoc) { {
1855                    if (true) {
1856                        throw (RuntimeException JavaDoc) jjte000;
1857                    }
1858                }
1859            }
1860            if (jjte000 instanceof ParseException) { {
1861                    if (true) {
1862                        throw (ParseException) jjte000;
1863                    }
1864                }
1865            } {
1866                if (true) {
1867                    throw (Error JavaDoc) jjte000;
1868                }
1869            }
1870        }
1871        finally {
1872            if (jjtc000) {
1873                jjtree.closeNodeScope(jjtn000, true);
1874            }
1875        }
1876    }
1877
1878    static final public void ExplicitConstructorInvocation() throws ParseException {
1879
1880        /* @bgen(jjtree) ExplicitConstructorInvocation */
1881        SimpleNode jjtn000 = new SimpleNode(JJTEXPLICITCONSTRUCTORINVOCATION);
1882        boolean jjtc000 = true;
1883
1884        jjtree.openNodeScope(jjtn000);
1885        try {
1886            if (jj_2_13(2147483647)) {
1887                jj_consume_token(THIS);
1888                Arguments();
1889                jj_consume_token(SEMICOLON);
1890            } else {
1891                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1892                case BOOLEAN:
1893                case BYTE:
1894                case CHAR:
1895                case DOUBLE:
1896                case FALSE:
1897                case FLOAT:
1898                case INT:
1899                case LONG:
1900                case NEW:
1901                case NULL:
1902                case SHORT:
1903                case SUPER:
1904                case THIS:
1905                case TRUE:
1906                case VOID:
1907                case INTEGER_LITERAL:
1908                case FLOATING_POINT_LITERAL:
1909                case CHARACTER_LITERAL:
1910                case STRING_LITERAL:
1911                case IDENTIFIER:
1912                case LPAREN:
1913                    if (jj_2_12(2)) {
1914                        PrimaryExpression();
1915                        jj_consume_token(DOT);
1916                    } else {
1917                        ;
1918                    }
1919                    jj_consume_token(SUPER);
1920                    Arguments();
1921                    jj_consume_token(SEMICOLON);
1922                    break;
1923
1924                default:
1925                    jj_la1[42] = jj_gen;
1926                    jj_consume_token(-1);
1927                    throw new ParseException();
1928                }
1929            }
1930        } catch (Throwable JavaDoc jjte000) {
1931            if (jjtc000) {
1932                jjtree.clearNodeScope(jjtn000);
1933                jjtc000 = false;
1934            } else {
1935                jjtree.popNode();
1936            }
1937            if (jjte000 instanceof RuntimeException JavaDoc) { {
1938                    if (true) {
1939                        throw (RuntimeException JavaDoc) jjte000;
1940                    }
1941                }
1942            }
1943            if (jjte000 instanceof ParseException) { {
1944                    if (true) {
1945                        throw (ParseException) jjte000;
1946                    }
1947                }
1948            } {
1949                if (true) {
1950                    throw (Error JavaDoc) jjte000;
1951                }
1952            }
1953        }
1954        finally {
1955            if (jjtc000) {
1956                jjtree.closeNodeScope(jjtn000, true);
1957            }
1958        }
1959    }
1960
1961    static final public void Initializer() throws ParseException {
1962
1963        /* @bgen(jjtree) Initializer */
1964        SimpleNode jjtn000 = new SimpleNode(JJTINITIALIZER);
1965        boolean jjtc000 = true;
1966
1967        jjtree.openNodeScope(jjtn000);
1968        try {
1969            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1970            case STATIC:
1971                jj_consume_token(STATIC);
1972                break;
1973
1974            default:
1975                jj_la1[43] = jj_gen;
1976                ;
1977            }
1978            Block();
1979        } catch (Throwable JavaDoc jjte000) {
1980            if (jjtc000) {
1981                jjtree.clearNodeScope(jjtn000);
1982                jjtc000 = false;
1983            } else {
1984                jjtree.popNode();
1985            }
1986            if (jjte000 instanceof RuntimeException JavaDoc) { {
1987                    if (true) {
1988                        throw (RuntimeException JavaDoc) jjte000;
1989                    }
1990                }
1991            }
1992            if (jjte000 instanceof ParseException) { {
1993                    if (true) {
1994                        throw (ParseException) jjte000;
1995                    }
1996                }
1997            } {
1998                if (true) {
1999                    throw (Error JavaDoc) jjte000;
2000                }
2001            }
2002        }
2003        finally {
2004            if (jjtc000) {
2005                jjtree.closeNodeScope(jjtn000, true);
2006            }
2007        }
2008    }
2009
2010    /*
2011     * Type, name and expression syntax follows.
2012     */

2013    static final public void Type() throws ParseException {
2014
2015        /* @bgen(jjtree) Type */
2016        SimpleNode jjtn000 = new SimpleNode(JJTTYPE);
2017        boolean jjtc000 = true;
2018
2019        jjtree.openNodeScope(jjtn000);
2020        try {
2021            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2022            case BOOLEAN:
2023            case BYTE:
2024            case CHAR:
2025            case DOUBLE:
2026            case FLOAT:
2027            case INT:
2028            case LONG:
2029            case SHORT:
2030                PrimitiveType();
2031                break;
2032
2033            case IDENTIFIER:
2034                Name();
2035                break;
2036
2037            default:
2038                jj_la1[44] = jj_gen;
2039                jj_consume_token(-1);
2040                throw new ParseException();
2041            }
2042            label_18:
2043            while (true) {
2044                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2045                case LBRACKET:
2046                    ;
2047                    break;
2048
2049                default:
2050                    jj_la1[45] = jj_gen;
2051                    break label_18;
2052                }
2053                jj_consume_token(LBRACKET);
2054                jj_consume_token(RBRACKET);
2055            }
2056        } catch (Throwable JavaDoc jjte000) {
2057            if (jjtc000) {
2058                jjtree.clearNodeScope(jjtn000);
2059                jjtc000 = false;
2060            } else {
2061                jjtree.popNode();
2062            }
2063            if (jjte000 instanceof RuntimeException JavaDoc) { {
2064                    if (true) {
2065                        throw (RuntimeException JavaDoc) jjte000;
2066                    }
2067                }
2068            }
2069            if (jjte000 instanceof ParseException) { {
2070                    if (true) {
2071                        throw (ParseException) jjte000;
2072                    }
2073                }
2074            } {
2075                if (true) {
2076                    throw (Error JavaDoc) jjte000;
2077                }
2078            }
2079        }
2080        finally {
2081            if (jjtc000) {
2082                jjtree.closeNodeScope(jjtn000, true);
2083            }
2084        }
2085    }
2086
2087    static final public void PrimitiveType() throws ParseException {
2088
2089        /* @bgen(jjtree) PrimitiveType */
2090        SimpleNode jjtn000 = new SimpleNode(JJTPRIMITIVETYPE);
2091        boolean jjtc000 = true;
2092
2093        jjtree.openNodeScope(jjtn000);
2094        try {
2095            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2096            case BOOLEAN:
2097                jj_consume_token(BOOLEAN);
2098                break;
2099
2100            case CHAR:
2101                jj_consume_token(CHAR);
2102                break;
2103
2104            case BYTE:
2105                jj_consume_token(BYTE);
2106                break;
2107
2108            case SHORT:
2109                jj_consume_token(SHORT);
2110                break;
2111
2112            case INT:
2113                jj_consume_token(INT);
2114                break;
2115
2116            case LONG:
2117                jj_consume_token(LONG);
2118                break;
2119
2120            case FLOAT:
2121                jj_consume_token(FLOAT);
2122                break;
2123
2124            case DOUBLE:
2125                jj_consume_token(DOUBLE);
2126                break;
2127
2128            default:
2129                jj_la1[46] = jj_gen;
2130                jj_consume_token(-1);
2131                throw new ParseException();
2132            }
2133        }
2134        finally {
2135            if (jjtc000) {
2136                jjtree.closeNodeScope(jjtn000, true);
2137            }
2138        }
2139    }
2140
2141    static final public void ResultType() throws ParseException {
2142
2143        /* @bgen(jjtree) ResultType */
2144        SimpleNode jjtn000 = new SimpleNode(JJTRESULTTYPE);
2145        boolean jjtc000 = true;
2146
2147        jjtree.openNodeScope(jjtn000);
2148        try {
2149            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2150            case VOID:
2151                jj_consume_token(VOID);
2152                break;
2153
2154            case BOOLEAN:
2155            case BYTE:
2156            case CHAR:
2157            case DOUBLE:
2158            case FLOAT:
2159            case INT:
2160            case LONG:
2161            case SHORT:
2162            case IDENTIFIER:
2163                Type();
2164                break;
2165
2166            default:
2167                jj_la1[47] = jj_gen;
2168                jj_consume_token(-1);
2169                throw new ParseException();
2170            }
2171        } catch (Throwable JavaDoc jjte000) {
2172            if (jjtc000) {
2173                jjtree.clearNodeScope(jjtn000);
2174                jjtc000 = false;
2175            } else {
2176                jjtree.popNode();
2177            }
2178            if (jjte000 instanceof RuntimeException JavaDoc) { {
2179                    if (true) {
2180                        throw (RuntimeException JavaDoc) jjte000;
2181                    }
2182                }
2183            }
2184            if (jjte000 instanceof ParseException) { {
2185                    if (true) {
2186                        throw (ParseException) jjte000;
2187                    }
2188                }
2189            } {
2190                if (true) {
2191                    throw (Error JavaDoc) jjte000;
2192                }
2193            }
2194        }
2195        finally {
2196            if (jjtc000) {
2197                jjtree.closeNodeScope(jjtn000, true);
2198            }
2199        }
2200    }
2201
2202    static final public void Name() throws ParseException {
2203
2204        /* @bgen(jjtree) Name */
2205        SimpleNode jjtn000 = new SimpleNode(JJTNAME);
2206        boolean jjtc000 = true;
2207
2208        jjtree.openNodeScope(jjtn000);
2209        try {
2210            jj_consume_token(IDENTIFIER);
2211            label_19:
2212            while (true) {
2213                if (jj_2_14(2)) {
2214                    ;
2215                } else {
2216                    break label_19;
2217                }
2218                jj_consume_token(DOT);
2219                jj_consume_token(IDENTIFIER);
2220            }
2221        }
2222        finally {
2223            if (jjtc000) {
2224                jjtree.closeNodeScope(jjtn000, true);
2225            }
2226        }
2227    }
2228
2229    static final public void NameList() throws ParseException {
2230
2231        /* @bgen(jjtree) NameList */
2232        SimpleNode jjtn000 = new SimpleNode(JJTNAMELIST);
2233        boolean jjtc000 = true;
2234
2235        jjtree.openNodeScope(jjtn000);
2236        try {
2237            Name();
2238            label_20:
2239            while (true) {
2240                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2241                case COMMA:
2242                    ;
2243                    break;
2244
2245                default:
2246                    jj_la1[48] = jj_gen;
2247                    break label_20;
2248                }
2249                jj_consume_token(COMMA);
2250                Name();
2251            }
2252        } catch (Throwable JavaDoc jjte000) {
2253            if (jjtc000) {
2254                jjtree.clearNodeScope(jjtn000);
2255                jjtc000 = false;
2256            } else {
2257                jjtree.popNode();
2258            }
2259            if (jjte000 instanceof RuntimeException JavaDoc) { {
2260                    if (true) {
2261                        throw (RuntimeException JavaDoc) jjte000;
2262                    }
2263                }
2264            }
2265            if (jjte000 instanceof ParseException) { {
2266                    if (true) {
2267                        throw (ParseException) jjte000;
2268                    }
2269                }
2270            } {
2271                if (true) {
2272                    throw (Error JavaDoc) jjte000;
2273                }
2274            }
2275        }
2276        finally {
2277            if (jjtc000) {
2278                jjtree.closeNodeScope(jjtn000, true);
2279            }
2280        }
2281    }
2282
2283    /*
2284     * Expression syntax follows.
2285     */

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

4191    static final public void ArrayDimsAndInits() throws ParseException {
4192
4193        /* @bgen(jjtree) ArrayDimsAndInits */
4194        SimpleNode jjtn000 = new SimpleNode(JJTARRAYDIMSANDINITS);
4195        boolean jjtc000 = true;
4196
4197        jjtree.openNodeScope(jjtn000);
4198        try {
4199            if (jj_2_26(2)) {
4200                label_33:
4201                while (true) {
4202                    jj_consume_token(LBRACKET);
4203                    Expression();
4204                    jj_consume_token(RBRACKET);
4205                    if (jj_2_24(2)) {
4206                        ;
4207                    } else {
4208                        break label_33;
4209                    }
4210                }
4211                label_34:
4212                while (true) {
4213                    if (jj_2_25(2)) {
4214                        ;
4215                    } else {
4216                        break label_34;
4217                    }
4218                    jj_consume_token(LBRACKET);
4219                    jj_consume_token(RBRACKET);
4220                }
4221            } else {
4222                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
4223                case LBRACKET:
4224                    label_35:
4225                    while (true) {
4226                        jj_consume_token(LBRACKET);
4227                        jj_consume_token(RBRACKET);
4228                        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
4229                        case LBRACKET:
4230                            ;
4231                            break;
4232
4233                        default:
4234                            jj_la1[88] = jj_gen;
4235                            break label_35;
4236                        }
4237                    }
4238                    ArrayInitializer();
4239                    break;
4240
4241                default:
4242                    jj_la1[89] = jj_gen;
4243                    jj_consume_token(-1);
4244                    throw new ParseException();
4245                }
4246            }
4247        } catch (Throwable JavaDoc jjte000) {
4248            if (jjtc000) {
4249                jjtree.clearNodeScope(jjtn000);
4250                jjtc000 = false;
4251            } else {
4252                jjtree.popNode();
4253            }
4254            if (jjte000 instanceof RuntimeException JavaDoc) { {
4255                    if (true) {
4256                        throw (RuntimeException JavaDoc) jjte000;
4257                    }
4258                }
4259            }
4260            if (jjte000 instanceof ParseException) { {
4261                    if (true) {
4262                        throw (ParseException) jjte000;
4263                    }
4264                }
4265            } {
4266                if (true) {
4267                    throw (Error JavaDoc) jjte000;
4268                }
4269            }
4270        }
4271        finally {
4272            if (jjtc000) {
4273                jjtree.closeNodeScope(jjtn000, true);
4274            }
4275        }
4276    }
4277
4278    /*
4279     * Statement syntax follows.
4280     */

4281    static final public void Statement() throws ParseException {
4282
4283        /* @bgen(jjtree) Statement */
4284        SimpleNode jjtn000 = new SimpleNode(JJTSTATEMENT);
4285        boolean jjtc000 = true;
4286
4287        jjtree.openNodeScope(jjtn000);
4288        try {
4289            if (jj_2_27(2)) {
4290                LabeledStatement();
4291            } else {
4292                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
4293                case LBRACE:
4294                    Block();
4295                    break;
4296
4297                case SEMICOLON:
4298                    EmptyStatement();
4299                    break;
4300
4301                case BOOLEAN:
4302                case BYTE:
4303                case CHAR:
4304                case DOUBLE:
4305                case FALSE:
4306                case FLOAT:
4307                case INT:
4308                case LONG:
4309                case NEW:
4310                case NULL:
4311                case SHORT:
4312                case SUPER:
4313                case THIS:
4314                case TRUE:
4315                case VOID:
4316                case INTEGER_LITERAL:
4317                case FLOATING_POINT_LITERAL:
4318                case CHARACTER_LITERAL:
4319                case STRING_LITERAL:
4320                case IDENTIFIER:
4321                case LPAREN:
4322                case INCR:
4323                case DECR:
4324                    StatementExpression();
4325                    jj_consume_token(SEMICOLON);
4326                    break;
4327
4328                case SWITCH:
4329                    SwitchStatement();
4330                    break;
4331
4332                case IF:
4333                    IfStatement();
4334                    break;
4335
4336                case WHILE:
4337                    WhileStatement();
4338                    break;
4339
4340                case DO:
4341                    DoStatement();
4342                    break;
4343
4344                case FOR:
4345                    ForStatement();
4346                    break;
4347
4348                case BREAK:
4349                    BreakStatement();
4350                    break;
4351
4352                case CONTINUE:
4353                    ContinueStatement();
4354                    break;
4355
4356                case RETURN:
4357                    ReturnStatement();
4358                    break;
4359
4360                case THROW:
4361                    ThrowStatement();
4362                    break;
4363
4364                case SYNCHRONIZED:
4365                    SynchronizedStatement();
4366                    break;
4367
4368                case TRY:
4369                    TryStatement();
4370                    break;
4371
4372                default:
4373                    jj_la1[90] = jj_gen;
4374                    jj_consume_token(-1);
4375                    throw new ParseException();
4376                }
4377            }
4378        } catch (Throwable JavaDoc jjte000) {
4379            if (jjtc000) {
4380                jjtree.clearNodeScope(jjtn000);
4381                jjtc000 = false;
4382            } else {
4383                jjtree.popNode();
4384            }
4385            if (jjte000 instanceof RuntimeException JavaDoc) { {
4386                    if (true) {
4387                        throw (RuntimeException JavaDoc) jjte000;
4388                    }
4389                }
4390            }
4391            if (jjte000 instanceof ParseException) { {
4392                    if (true) {
4393                        throw (ParseException) jjte000;
4394                    }
4395                }
4396            } {
4397                if (true) {
4398                    throw (Error JavaDoc) jjte000;
4399                }
4400            }
4401        }
4402        finally {
4403            if (jjtc000) {
4404                jjtree.closeNodeScope(jjtn000, true);
4405            }
4406        }
4407    }
4408
4409    static final public void LabeledStatement() throws ParseException {
4410
4411        /* @bgen(jjtree) LabeledStatement */
4412        SimpleNode jjtn000 = new SimpleNode(JJTLABELEDSTATEMENT);
4413        boolean jjtc000 = true;
4414
4415        jjtree.openNodeScope(jjtn000);
4416        try {
4417            jj_consume_token(IDENTIFIER);
4418            jj_consume_token(COLON);
4419            Statement();
4420        } catch (Throwable JavaDoc jjte000) {
4421            if (jjtc000) {
4422                jjtree.clearNodeScope(jjtn000);
4423                jjtc000 = false;
4424            } else {
4425                jjtree.popNode();
4426            }
4427            if (jjte000 instanceof RuntimeException JavaDoc) { {
4428                    if (true) {
4429                        throw (RuntimeException JavaDoc) jjte000;
4430                    }
4431                }
4432            }
4433            if (jjte000 instanceof ParseException) { {
4434                    if (true) {
4435                        throw (ParseException) jjte000;
4436                    }
4437                }
4438            } {
4439                if (true) {
4440                    throw (Error JavaDoc) jjte000;
4441                }
4442            }
4443        }
4444        finally {
4445            if (jjtc000) {
4446                jjtree.closeNodeScope(jjtn000, true);
4447            }
4448        }
4449    }
4450
4451    static final public void Block() throws ParseException {
4452
4453        /* @bgen(jjtree) Block */
4454        SimpleNode jjtn000 = new SimpleNode(JJTBLOCK);
4455        boolean jjtc000 = true;
4456
4457        jjtree.openNodeScope(jjtn000);
4458        try {
4459            jj_consume_token(LBRACE);
4460            label_36:
4461            while (true) {
4462                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
4463                case BOOLEAN:
4464                case BREAK:
4465                case BYTE:
4466                case CHAR:
4467                case CLASS:
4468                case CONTINUE:
4469                case DO:
4470                case DOUBLE:
4471                case FALSE:
4472                case FINAL:
4473                case FLOAT:
4474                case FOR:
4475                case IF:
4476                case INT:
4477                case INTERFACE:
4478                case LONG:
4479                case NEW:
4480                case NULL:
4481                case RETURN:
4482                case SHORT:
4483                case SUPER:
4484                case SWITCH:
4485                case SYNCHRONIZED:
4486                case THIS:
4487                case THROW:
4488                case TRUE:
4489                case TRY:
4490                case VOID:
4491                case WHILE:
4492                case INTEGER_LITERAL:
4493                case FLOATING_POINT_LITERAL:
4494                case CHARACTER_LITERAL:
4495                case STRING_LITERAL:
4496                case IDENTIFIER:
4497                case LPAREN:
4498                case LBRACE:
4499                case SEMICOLON:
4500                case INCR:
4501                case DECR:
4502                    ;
4503                    break;
4504
4505                default:
4506                    jj_la1[91] = jj_gen;
4507                    break label_36;
4508                }
4509                BlockStatement();
4510            }
4511            jj_consume_token(RBRACE);
4512        } catch (Throwable JavaDoc jjte000) {
4513            if (jjtc000) {
4514                jjtree.clearNodeScope(jjtn000);
4515                jjtc000 = false;
4516            } else {
4517                jjtree.popNode();
4518            }
4519            if (jjte000 instanceof RuntimeException JavaDoc) { {
4520                    if (true) {
4521                        throw (RuntimeException JavaDoc) jjte000;
4522                    }
4523                }
4524            }
4525            if (jjte000 instanceof ParseException) { {
4526                    if (true) {
4527                        throw (ParseException) jjte000;
4528                    }
4529                }
4530            } {
4531                if (true) {
4532                    throw (Error JavaDoc) jjte000;
4533                }
4534            }
4535        }
4536        finally {
4537            if (jjtc000) {
4538                jjtree.closeNodeScope(jjtn000, true);
4539            }
4540        }
4541    }
4542
4543    static final public void BlockStatement() throws ParseException {
4544
4545        /* @bgen(jjtree) BlockStatement */
4546        SimpleNode jjtn000 = new SimpleNode(JJTBLOCKSTATEMENT);
4547        boolean jjtc000 = true;
4548
4549        jjtree.openNodeScope(jjtn000);
4550        try {
4551            if (jj_2_28(2147483647)) {
4552                LocalVariableDeclaration();
4553                jj_consume_token(SEMICOLON);
4554            } else {
4555                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
4556                case BOOLEAN:
4557                case BREAK:
4558                case BYTE:
4559                case CHAR:
4560                case CONTINUE:
4561                case DO:
4562                case DOUBLE:
4563                case FALSE:
4564                case FLOAT:
4565                case FOR:
4566                case IF:
4567                case INT:
4568                case LONG:
4569                case NEW:
4570                case NULL:
4571                case RETURN:
4572                case SHORT:
4573                case SUPER:
4574                case SWITCH:
4575                case SYNCHRONIZED:
4576                case THIS:
4577                case THROW:
4578                case TRUE:
4579                case TRY:
4580                case VOID:
4581                case WHILE:
4582                case INTEGER_LITERAL:
4583                case FLOATING_POINT_LITERAL:
4584                case CHARACTER_LITERAL:
4585                case STRING_LITERAL:
4586                case IDENTIFIER:
4587                case LPAREN:
4588                case LBRACE:
4589                case SEMICOLON:
4590                case INCR:
4591                case DECR:
4592                    Statement();
4593                    break;
4594
4595                case CLASS:
4596                    UnmodifiedClassDeclaration();
4597                    break;
4598
4599                case INTERFACE:
4600                    UnmodifiedInterfaceDeclaration();
4601                    break;
4602
4603                default:
4604                    jj_la1[92] = jj_gen;
4605                    jj_consume_token(-1);
4606                    throw new ParseException();
4607                }
4608            }
4609        } catch (Throwable JavaDoc jjte000) {
4610            if (jjtc000) {
4611                jjtree.clearNodeScope(jjtn000);
4612                jjtc000 = false;
4613            } else {
4614                jjtree.popNode();
4615            }
4616            if (jjte000 instanceof RuntimeException JavaDoc) { {
4617                    if (true) {
4618                        throw (RuntimeException JavaDoc) jjte000;
4619                    }
4620                }
4621            }
4622            if (jjte000 instanceof ParseException) { {
4623                    if (true) {
4624                        throw (ParseException) jjte000;
4625                    }
4626                }
4627            } {
4628                if (true) {
4629                    throw (Error JavaDoc) jjte000;
4630                }
4631            }
4632        }
4633        finally {
4634            if (jjtc000) {
4635                jjtree.closeNodeScope(jjtn000, true);
4636            }
4637        }
4638    }
4639
4640    static final public void LocalVariableDeclaration() throws ParseException {
4641
4642        /* @bgen(jjtree) LocalVariableDeclaration */
4643        SimpleNode jjtn000 = new SimpleNode(JJTLOCALVARIABLEDECLARATION);
4644        boolean jjtc000 = true;
4645
4646        jjtree.openNodeScope(jjtn000);
4647        try {
4648            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
4649            case FINAL:
4650                jj_consume_token(FINAL);
4651                break;
4652
4653            default:
4654                jj_la1[93] = jj_gen;
4655                ;
4656            }
4657            Type();
4658            VariableDeclarator();
4659            label_37:
4660            while (true) {
4661                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
4662                case COMMA:
4663                    ;
4664                    break;
4665
4666                default:
4667                    jj_la1[94] = jj_gen;
4668                    break label_37;
4669                }
4670                jj_consume_token(COMMA);
4671                VariableDeclarator();
4672            }
4673        } catch (Throwable JavaDoc jjte000) {
4674            if (jjtc000) {
4675                jjtree.clearNodeScope(jjtn000);
4676                jjtc000 = false;
4677            } else {
4678                jjtree.popNode();
4679            }
4680            if (jjte000 instanceof RuntimeException JavaDoc) { {
4681                    if (true) {
4682                        throw (RuntimeException JavaDoc) jjte000;
4683                    }
4684                }
4685            }
4686            if (jjte000 instanceof ParseException) { {
4687                    if (true) {
4688                        throw (ParseException) jjte000;
4689                    }
4690                }
4691            } {
4692                if (true) {
4693                    throw (Error JavaDoc) jjte000;
4694                }
4695            }
4696        }
4697        finally {
4698            if (jjtc000) {
4699                jjtree.closeNodeScope(jjtn000, true);
4700            }
4701        }
4702    }
4703
4704    static final public void EmptyStatement() throws ParseException {
4705
4706        /* @bgen(jjtree) EmptyStatement */
4707        SimpleNode jjtn000 = new SimpleNode(JJTEMPTYSTATEMENT);
4708        boolean jjtc000 = true;
4709
4710        jjtree.openNodeScope(jjtn000);
4711        try {
4712            jj_consume_token(SEMICOLON);
4713        }
4714        finally {
4715            if (jjtc000) {
4716                jjtree.closeNodeScope(jjtn000, true);
4717            }
4718        }
4719    }
4720
4721    static final public void StatementExpression() throws ParseException {
4722
4723        /* @bgen(jjtree) StatementExpression */
4724        SimpleNode jjtn000 = new SimpleNode(JJTSTATEMENTEXPRESSION);
4725        boolean jjtc000 = true;
4726
4727        jjtree.openNodeScope(jjtn000);
4728        try {
4729            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
4730            case INCR:
4731                PreIncrementExpression();
4732                break;
4733
4734            case DECR:
4735                PreDecrementExpression();
4736                break;
4737
4738            case BOOLEAN:
4739            case BYTE:
4740            case CHAR:
4741            case DOUBLE:
4742            case FALSE:
4743            case FLOAT:
4744            case INT:
4745            case LONG:
4746            case NEW:
4747            case NULL:
4748            case SHORT:
4749            case SUPER:
4750            case THIS:
4751            case TRUE:
4752            case VOID:
4753            case INTEGER_LITERAL:
4754            case FLOATING_POINT_LITERAL:
4755            case CHARACTER_LITERAL:
4756            case STRING_LITERAL:
4757            case IDENTIFIER:
4758            case LPAREN:
4759                PrimaryExpression();
4760                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
4761                case ASSIGN:
4762                case INCR:
4763                case DECR:
4764                case PLUSASSIGN:
4765                case MINUSASSIGN:
4766                case STARASSIGN:
4767                case SLASHASSIGN:
4768                case ANDASSIGN:
4769                case ORASSIGN:
4770                case XORASSIGN:
4771                case REMASSIGN:
4772                case LSHIFTASSIGN:
4773                case RSIGNEDSHIFTASSIGN:
4774                case RUNSIGNEDSHIFTASSIGN:
4775                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
4776                    case INCR:
4777                        jj_consume_token(INCR);
4778                        break;
4779
4780                    case DECR:
4781                        jj_consume_token(DECR);
4782                        break;
4783
4784                    case ASSIGN:
4785                    case PLUSASSIGN:
4786                    case MINUSASSIGN:
4787                    case STARASSIGN:
4788                    case SLASHASSIGN:
4789                    case ANDASSIGN:
4790                    case ORASSIGN:
4791                    case XORASSIGN:
4792                    case REMASSIGN:
4793                    case LSHIFTASSIGN:
4794                    case RSIGNEDSHIFTASSIGN:
4795                    case RUNSIGNEDSHIFTASSIGN:
4796                        AssignmentOperator();
4797                        Expression();
4798                        break;
4799
4800                    default:
4801                        jj_la1[95] = jj_gen;
4802                        jj_consume_token(-1);
4803                        throw new ParseException();
4804                    }
4805                    break;
4806
4807                default:
4808                    jj_la1[96] = jj_gen;
4809                    ;
4810                }
4811                break;
4812
4813            default:
4814                jj_la1[97] = jj_gen;
4815                jj_consume_token(-1);
4816                throw new ParseException();
4817            }
4818        } catch (Throwable JavaDoc jjte000) {
4819            if (jjtc000) {
4820                jjtree.clearNodeScope(jjtn000);
4821                jjtc000 = false;
4822            } else {
4823                jjtree.popNode();
4824            }
4825            if (jjte000 instanceof RuntimeException JavaDoc) { {
4826                    if (true) {
4827                        throw (RuntimeException JavaDoc) jjte000;
4828                    }
4829                }
4830            }
4831            if (jjte000 instanceof ParseException) { {
4832                    if (true) {
4833                        throw (ParseException) jjte000;
4834                    }
4835                }
4836            } {
4837                if (true) {
4838                    throw (Error JavaDoc) jjte000;
4839                }
4840            }
4841        }
4842        finally {
4843            if (jjtc000) {
4844                jjtree.closeNodeScope(jjtn000, true);
4845            }
4846        }
4847    }
4848
4849    static final public void SwitchStatement() throws ParseException {
4850
4851        /* @bgen(jjtree) SwitchStatement */
4852        SimpleNode jjtn000 = new SimpleNode(JJTSWITCHSTATEMENT);
4853        boolean jjtc000 = true;
4854
4855        jjtree.openNodeScope(jjtn000);
4856        try {
4857            jj_consume_token(SWITCH);
4858            jj_consume_token(LPAREN);
4859            Expression();
4860            jj_consume_token(RPAREN);
4861            jj_consume_token(LBRACE);
4862            label_38:
4863            while (true) {
4864                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
4865                case CASE:
4866                case _DEFAULT:
4867                    ;
4868                    break;
4869
4870                default:
4871                    jj_la1[98] = jj_gen;
4872                    break label_38;
4873                }
4874                SwitchLabel();
4875                label_39:
4876                while (true) {
4877                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
4878                    case BOOLEAN:
4879                    case BREAK:
4880                    case BYTE:
4881                    case CHAR:
4882                    case CLASS:
4883                    case CONTINUE:
4884                    case DO:
4885                    case DOUBLE:
4886                    case FALSE:
4887                    case FINAL:
4888                    case FLOAT:
4889                    case FOR:
4890                    case IF:
4891                    case INT:
4892                    case INTERFACE:
4893                    case LONG:
4894                    case NEW:
4895                    case NULL:
4896                    case RETURN:
4897                    case SHORT:
4898                    case SUPER:
4899                    case SWITCH:
4900                    case SYNCHRONIZED:
4901                    case THIS:
4902                    case THROW:
4903                    case TRUE:
4904                    case TRY:
4905                    case VOID:
4906                    case WHILE:
4907                    case INTEGER_LITERAL:
4908                    case FLOATING_POINT_LITERAL:
4909                    case CHARACTER_LITERAL:
4910                    case STRING_LITERAL:
4911                    case IDENTIFIER:
4912                    case LPAREN:
4913                    case LBRACE:
4914                    case SEMICOLON:
4915                    case INCR:
4916                    case DECR:
4917                        ;
4918                        break;
4919
4920                    default:
4921                        jj_la1[99] = jj_gen;
4922                        break label_39;
4923                    }
4924                    BlockStatement();
4925                }
4926            }
4927            jj_consume_token(RBRACE);
4928        } catch (Throwable JavaDoc jjte000) {
4929            if (jjtc000) {
4930                jjtree.clearNodeScope(jjtn000);
4931                jjtc000 = false;
4932            } else {
4933                jjtree.popNode();
4934            }
4935            if (jjte000 instanceof RuntimeException JavaDoc) { {
4936                    if (true) {
4937                        throw (RuntimeException JavaDoc) jjte000;
4938                    }
4939                }
4940            }
4941            if (jjte000 instanceof ParseException) { {
4942                    if (true) {
4943                        throw (ParseException) jjte000;
4944                    }
4945                }
4946            } {
4947                if (true) {
4948                    throw (Error JavaDoc) jjte000;
4949                }
4950            }
4951        }
4952        finally {
4953            if (jjtc000) {
4954                jjtree.closeNodeScope(jjtn000, true);
4955            }
4956        }
4957    }
4958
4959    static final public void SwitchLabel() throws ParseException {
4960
4961        /* @bgen(jjtree) SwitchLabel */
4962        SimpleNode jjtn000 = new SimpleNode(JJTSWITCHLABEL);
4963        boolean jjtc000 = true;
4964
4965        jjtree.openNodeScope(jjtn000);
4966        try {
4967            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
4968            case CASE:
4969                jj_consume_token(CASE);
4970                Expression();
4971                jj_consume_token(COLON);
4972                break;
4973
4974            case _DEFAULT:
4975                jj_consume_token(_DEFAULT);
4976                jj_consume_token(COLON);
4977                break;
4978
4979            default:
4980                jj_la1[100] = jj_gen;
4981                jj_consume_token(-1);
4982                throw new ParseException();
4983            }
4984        } catch (Throwable JavaDoc jjte000) {
4985            if (jjtc000) {
4986                jjtree.clearNodeScope(jjtn000);
4987                jjtc000 = false;
4988            } else {
4989                jjtree.popNode();
4990            }
4991            if (jjte000 instanceof RuntimeException JavaDoc) { {
4992                    if (true) {
4993                        throw (RuntimeException JavaDoc) jjte000;
4994                    }
4995                }
4996            }
4997            if (jjte000 instanceof ParseException) { {
4998                    if (true) {
4999                        throw (ParseException) jjte000;
5000                    }
5001                }
5002            } {
5003                if (true) {
5004                    throw (Error JavaDoc) jjte000;
5005                }
5006            }
5007        }
5008        finally {
5009            if (jjtc000) {
5010                jjtree.closeNodeScope(jjtn000, true);
5011            }
5012        }
5013    }
5014
5015    static final public void IfStatement() throws ParseException {
5016
5017        /* @bgen(jjtree) IfStatement */
5018        SimpleNode jjtn000 = new SimpleNode(JJTIFSTATEMENT);
5019        boolean jjtc000 = true;
5020
5021        jjtree.openNodeScope(jjtn000);
5022        try {
5023            jj_consume_token(IF);
5024            jj_consume_token(LPAREN);
5025            Expression();
5026            jj_consume_token(RPAREN);
5027            Statement();
5028            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
5029            case ELSE:
5030                jj_consume_token(ELSE);
5031                Statement();
5032                break;
5033
5034            default:
5035                jj_la1[101] = jj_gen;
5036                ;
5037            }
5038        } catch (Throwable JavaDoc jjte000) {
5039            if (jjtc000) {
5040                jjtree.clearNodeScope(jjtn000);
5041                jjtc000 = false;
5042            } else {
5043                jjtree.popNode();
5044            }
5045            if (jjte000 instanceof RuntimeException JavaDoc) { {
5046                    if (true) {
5047                        throw (RuntimeException JavaDoc) jjte000;
5048                    }
5049                }
5050            }
5051            if (jjte000 instanceof ParseException) { {
5052                    if (true) {
5053                        throw (ParseException) jjte000;
5054                    }
5055                }
5056            } {
5057                if (true) {
5058                    throw (Error JavaDoc) jjte000;
5059                }
5060            }
5061        }
5062        finally {
5063            if (jjtc000) {
5064                jjtree.closeNodeScope(jjtn000, true);
5065            }
5066        }
5067    }
5068
5069    static final public void WhileStatement() throws ParseException {
5070
5071        /* @bgen(jjtree) WhileStatement */
5072        SimpleNode jjtn000 = new SimpleNode(JJTWHILESTATEMENT);
5073        boolean jjtc000 = true;
5074
5075        jjtree.openNodeScope(jjtn000);
5076        try {
5077            jj_consume_token(WHILE);
5078            jj_consume_token(LPAREN);
5079            Expression();
5080            jj_consume_token(RPAREN);
5081            Statement();
5082        } catch (Throwable JavaDoc jjte000) {
5083            if (jjtc000) {
5084                jjtree.clearNodeScope(jjtn000);
5085                jjtc000 = false;
5086            } else {
5087                jjtree.popNode();
5088            }
5089            if (jjte000 instanceof RuntimeException JavaDoc) { {
5090                    if (true) {
5091                        throw (RuntimeException JavaDoc) jjte000;
5092                    }
5093                }
5094            }
5095            if (jjte000 instanceof ParseException) { {
5096                    if (true) {
5097                        throw (ParseException) jjte000;
5098                    }
5099                }
5100            } {
5101                if (true) {
5102                    throw (Error JavaDoc) jjte000;
5103                }
5104            }
5105        }
5106        finally {
5107            if (jjtc000) {
5108                jjtree.closeNodeScope(jjtn000, true);
5109            }
5110        }
5111    }
5112
5113    static final public void DoStatement() throws ParseException {
5114
5115        /* @bgen(jjtree) DoStatement */
5116        SimpleNode jjtn000 = new SimpleNode(JJTDOSTATEMENT);
5117        boolean jjtc000 = true;
5118
5119        jjtree.openNodeScope(jjtn000);
5120        try {
5121            jj_consume_token(DO);
5122            Statement();
5123            jj_consume_token(WHILE);
5124            jj_consume_token(LPAREN);
5125            Expression();
5126            jj_consume_token(RPAREN);
5127            jj_consume_token(SEMICOLON);
5128        } catch (Throwable JavaDoc jjte000) {
5129            if (jjtc000) {
5130                jjtree.clearNodeScope(jjtn000);
5131                jjtc000 = false;
5132            } else {
5133                jjtree.popNode();
5134            }
5135            if (jjte000 instanceof RuntimeException JavaDoc) { {
5136                    if (true) {
5137                        throw (RuntimeException JavaDoc) jjte000;
5138                    }
5139                }
5140            }
5141            if (jjte000 instanceof ParseException) { {
5142                    if (true) {
5143                        throw (ParseException) jjte000;
5144                    }
5145                }
5146            } {
5147                if (true) {
5148                    throw (Error JavaDoc) jjte000;
5149                }
5150            }
5151        }
5152        finally {
5153            if (jjtc000) {
5154                jjtree.closeNodeScope(jjtn000, true);
5155            }
5156        }
5157    }
5158
5159    static final public void ForStatement() throws ParseException {
5160
5161        /* @bgen(jjtree) ForStatement */
5162        SimpleNode jjtn000 = new SimpleNode(JJTFORSTATEMENT);
5163        boolean jjtc000 = true;
5164
5165        jjtree.openNodeScope(jjtn000);
5166        try {
5167            jj_consume_token(FOR);
5168            jj_consume_token(LPAREN);
5169            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
5170            case BOOLEAN:
5171            case BYTE:
5172            case CHAR:
5173            case DOUBLE:
5174            case FALSE:
5175            case FINAL:
5176            case FLOAT:
5177            case INT:
5178            case LONG:
5179            case NEW:
5180            case NULL:
5181            case SHORT:
5182            case SUPER:
5183            case THIS:
5184            case TRUE:
5185            case VOID:
5186            case INTEGER_LITERAL:
5187            case FLOATING_POINT_LITERAL:
5188            case CHARACTER_LITERAL:
5189            case STRING_LITERAL:
5190            case IDENTIFIER:
5191            case LPAREN:
5192            case INCR:
5193            case DECR:
5194                ForInit();
5195                break;
5196
5197            default:
5198                jj_la1[102] = jj_gen;
5199                ;
5200            }
5201            jj_consume_token(SEMICOLON);
5202            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
5203            case BOOLEAN:
5204            case BYTE:
5205            case CHAR:
5206            case DOUBLE:
5207            case FALSE:
5208            case FLOAT:
5209            case INT:
5210            case LONG:
5211            case NEW:
5212            case NULL:
5213            case SHORT:
5214            case SUPER:
5215            case THIS:
5216            case TRUE:
5217            case VOID:
5218            case INTEGER_LITERAL:
5219            case FLOATING_POINT_LITERAL:
5220            case CHARACTER_LITERAL:
5221            case STRING_LITERAL:
5222            case IDENTIFIER:
5223            case LPAREN:
5224            case BANG:
5225            case TILDE:
5226            case INCR:
5227            case DECR:
5228            case PLUS:
5229            case MINUS:
5230                Expression();
5231                break;
5232
5233            default:
5234                jj_la1[103] = jj_gen;
5235                ;
5236            }
5237            jj_consume_token(SEMICOLON);
5238            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
5239            case BOOLEAN:
5240            case BYTE:
5241            case CHAR:
5242            case DOUBLE:
5243            case FALSE:
5244            case FLOAT:
5245            case INT:
5246            case LONG:
5247            case NEW:
5248            case NULL:
5249            case SHORT:
5250            case SUPER:
5251            case THIS:
5252            case TRUE:
5253            case VOID:
5254            case INTEGER_LITERAL:
5255            case FLOATING_POINT_LITERAL:
5256            case CHARACTER_LITERAL:
5257            case STRING_LITERAL:
5258            case IDENTIFIER:
5259            case LPAREN:
5260            case INCR:
5261            case DECR:
5262                ForUpdate();
5263                break;
5264
5265            default:
5266                jj_la1[104] = jj_gen;
5267                ;
5268            }
5269            jj_consume_token(RPAREN);
5270            Statement();
5271        } catch (Throwable JavaDoc jjte000) {
5272            if (jjtc000) {
5273                jjtree.clearNodeScope(jjtn000);
5274                jjtc000 = false;
5275            } else {
5276                jjtree.popNode();
5277            }
5278            if (jjte000 instanceof RuntimeException JavaDoc) { {
5279                    if (true) {
5280                        throw (RuntimeException JavaDoc) jjte000;
5281                    }
5282                }
5283            }
5284            if (jjte000 instanceof ParseException) { {
5285                    if (true) {
5286                        throw (ParseException) jjte000;
5287                    }
5288                }
5289            } {
5290                if (true) {
5291                    throw (Error JavaDoc) jjte000;
5292                }
5293            }
5294        }
5295        finally {
5296            if (jjtc000) {
5297                jjtree.closeNodeScope(jjtn000, true);
5298            }
5299        }
5300    }
5301
5302    static final public void ForInit() throws ParseException {
5303
5304        /* @bgen(jjtree) ForInit */
5305        SimpleNode jjtn000 = new SimpleNode(JJTFORINIT);
5306        boolean jjtc000 = true;
5307
5308        jjtree.openNodeScope(jjtn000);
5309        try {
5310            if (jj_2_29(2147483647)) {
5311                LocalVariableDeclaration();
5312            } else {
5313                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
5314                case BOOLEAN:
5315                case BYTE:
5316                case CHAR:
5317                case DOUBLE:
5318                case FALSE:
5319                case FLOAT:
5320                case INT:
5321                case LONG:
5322                case NEW:
5323                case NULL:
5324                case SHORT:
5325                case SUPER:
5326                case THIS:
5327                case TRUE:
5328                case VOID:
5329                case INTEGER_LITERAL:
5330                case FLOATING_POINT_LITERAL:
5331                case CHARACTER_LITERAL:
5332                case STRING_LITERAL:
5333                case IDENTIFIER:
5334                case LPAREN:
5335                case INCR:
5336                case DECR:
5337                    StatementExpressionList();
5338                    break;
5339
5340                default:
5341                    jj_la1[105] = jj_gen;
5342                    jj_consume_token(-1);
5343                    throw new ParseException();
5344                }
5345            }
5346        } catch (Throwable JavaDoc jjte000) {
5347            if (jjtc000) {
5348                jjtree.clearNodeScope(jjtn000);
5349                jjtc000 = false;
5350            } else {
5351                jjtree.popNode();
5352            }
5353            if (jjte000 instanceof RuntimeException JavaDoc) { {
5354                    if (true) {
5355                        throw (RuntimeException JavaDoc) jjte000;
5356                    }
5357                }
5358            }
5359            if (jjte000 instanceof ParseException) { {
5360                    if (true) {
5361                        throw (ParseException) jjte000;
5362                    }
5363                }
5364            } {
5365                if (true) {
5366                    throw (Error JavaDoc) jjte000;
5367                }
5368            }
5369        }
5370        finally {
5371            if (jjtc000) {
5372                jjtree.closeNodeScope(jjtn000, true);
5373            }
5374        }
5375    }
5376
5377    static final public void StatementExpressionList() throws ParseException {
5378
5379        /* @bgen(jjtree) StatementExpressionList */
5380        SimpleNode jjtn000 = new SimpleNode(JJTSTATEMENTEXPRESSIONLIST);
5381        boolean jjtc000 = true;
5382
5383        jjtree.openNodeScope(jjtn000);
5384        try {
5385            StatementExpression();
5386            label_40:
5387            while (true) {
5388                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
5389                case COMMA:
5390                    ;
5391                    break;
5392
5393                default:
5394                    jj_la1[106] = jj_gen;
5395                    break label_40;
5396                }
5397                jj_consume_token(COMMA);
5398                StatementExpression();
5399            }
5400        } catch (Throwable JavaDoc jjte000) {
5401            if (jjtc000) {
5402                jjtree.clearNodeScope(jjtn000);
5403                jjtc000 = false;
5404            } else {
5405                jjtree.popNode();
5406            }
5407            if (jjte000 instanceof RuntimeException JavaDoc) { {
5408                    if (true) {
5409                        throw (RuntimeException JavaDoc) jjte000;
5410                    }
5411                }
5412            }
5413            if (jjte000 instanceof ParseException) { {
5414                    if (true) {
5415                        throw (ParseException) jjte000;
5416                    }
5417                }
5418            } {
5419                if (true) {
5420                    throw (Error JavaDoc) jjte000;
5421                }
5422            }
5423        }
5424        finally {
5425            if (jjtc000) {
5426                jjtree.closeNodeScope(jjtn000, true);
5427            }
5428        }
5429    }
5430
5431    static final public void ForUpdate() throws ParseException {
5432
5433        /* @bgen(jjtree) ForUpdate */
5434        SimpleNode jjtn000 = new SimpleNode(JJTFORUPDATE);
5435        boolean jjtc000 = true;
5436
5437        jjtree.openNodeScope(jjtn000);
5438        try {
5439            StatementExpressionList();
5440        } catch (Throwable JavaDoc jjte000) {
5441            if (jjtc000) {
5442                jjtree.clearNodeScope(jjtn000);
5443                jjtc000 = false;
5444            } else {
5445                jjtree.popNode();
5446            }
5447            if (jjte000 instanceof RuntimeException JavaDoc) { {
5448                    if (true) {
5449                        throw (RuntimeException JavaDoc) jjte000;
5450                    }
5451                }
5452            }
5453            if (jjte000 instanceof ParseException) { {
5454                    if (true) {
5455                        throw (ParseException) jjte000;
5456                    }
5457                }
5458            } {
5459                if (true) {
5460                    throw (Error JavaDoc) jjte000;
5461                }
5462            }
5463        }
5464        finally {
5465            if (jjtc000) {
5466                jjtree.closeNodeScope(jjtn000, true);
5467            }
5468        }
5469    }
5470
5471    static final public void BreakStatement() throws ParseException {
5472
5473        /* @bgen(jjtree) BreakStatement */
5474        SimpleNode jjtn000 = new SimpleNode(JJTBREAKSTATEMENT);
5475        boolean jjtc000 = true;
5476
5477        jjtree.openNodeScope(jjtn000);
5478        try {
5479            jj_consume_token(BREAK);
5480            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
5481            case IDENTIFIER:
5482                jj_consume_token(IDENTIFIER);
5483                break;
5484
5485            default:
5486                jj_la1[107] = jj_gen;
5487                ;
5488            }
5489            jj_consume_token(SEMICOLON);
5490        }
5491        finally {
5492            if (jjtc000) {
5493                jjtree.closeNodeScope(jjtn000, true);
5494            }
5495        }
5496    }
5497
5498    static final public void ContinueStatement() throws ParseException {
5499
5500        /* @bgen(jjtree) ContinueStatement */
5501        SimpleNode jjtn000 = new SimpleNode(JJTCONTINUESTATEMENT);
5502        boolean jjtc000 = true;
5503
5504        jjtree.openNodeScope(jjtn000);
5505        try {
5506            jj_consume_token(CONTINUE);
5507            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
5508            case IDENTIFIER:
5509                jj_consume_token(IDENTIFIER);
5510                break;
5511
5512            default:
5513                jj_la1[108] = jj_gen;
5514                ;
5515            }
5516            jj_consume_token(SEMICOLON);
5517        }
5518        finally {
5519            if (jjtc000) {
5520                jjtree.closeNodeScope(jjtn000, true);
5521            }
5522        }
5523    }
5524
5525    static final public void ReturnStatement() throws ParseException {
5526
5527        /* @bgen(jjtree) ReturnStatement */
5528        SimpleNode jjtn000 = new SimpleNode(JJTRETURNSTATEMENT);
5529        boolean jjtc000 = true;
5530
5531        jjtree.openNodeScope(jjtn000);
5532        try {
5533            jj_consume_token(RETURN);
5534            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
5535            case BOOLEAN:
5536            case BYTE:
5537            case CHAR:
5538            case DOUBLE:
5539            case FALSE:
5540            case FLOAT:
5541            case INT:
5542            case LONG:
5543            case NEW:
5544            case NULL:
5545            case SHORT:
5546            case SUPER:
5547            case THIS:
5548            case TRUE:
5549            case VOID:
5550            case INTEGER_LITERAL:
5551            case FLOATING_POINT_LITERAL:
5552            case CHARACTER_LITERAL:
5553            case STRING_LITERAL:
5554            case IDENTIFIER:
5555            case LPAREN:
5556            case BANG:
5557            case TILDE:
5558            case INCR:
5559            case DECR:
5560            case PLUS:
5561            case MINUS:
5562                Expression();
5563                break;
5564
5565            default:
5566                jj_la1[109] = jj_gen;
5567                ;
5568            }
5569            jj_consume_token(SEMICOLON);
5570        } catch (Throwable JavaDoc jjte000) {
5571            if (jjtc000) {
5572                jjtree.clearNodeScope(jjtn000);
5573                jjtc000 = false;
5574            } else {
5575                jjtree.popNode();
5576            }
5577            if (jjte000 instanceof RuntimeException JavaDoc) { {
5578                    if (true) {
5579                        throw (RuntimeException JavaDoc) jjte000;
5580                    }
5581                }
5582            }
5583            if (jjte000 instanceof ParseException) { {
5584                    if (true) {
5585                        throw (ParseException) jjte000;
5586                    }
5587                }
5588            } {
5589                if (true) {
5590                    throw (Error JavaDoc) jjte000;
5591                }
5592            }
5593        }
5594        finally {
5595            if (jjtc000) {
5596                jjtree.closeNodeScope(jjtn000, true);
5597            }
5598        }
5599    }
5600
5601    static final public void ThrowStatement() throws ParseException {
5602
5603        /* @bgen(jjtree) ThrowStatement */
5604        SimpleNode jjtn000 = new SimpleNode(JJTTHROWSTATEMENT);
5605        boolean jjtc000 = true;
5606
5607        jjtree.openNodeScope(jjtn000);
5608        try {
5609            jj_consume_token(THROW);
5610            Expression();
5611            jj_consume_token(SEMICOLON);
5612        } catch (Throwable JavaDoc jjte000) {
5613            if (jjtc000) {
5614                jjtree.clearNodeScope(jjtn000);
5615                jjtc000 = false;
5616            } else {
5617                jjtree.popNode();
5618            }
5619            if (jjte000 instanceof RuntimeException JavaDoc) { {
5620                    if (true) {
5621                        throw (RuntimeException JavaDoc) jjte000;
5622                    }
5623                }
5624            }
5625            if (jjte000 instanceof ParseException) { {
5626                    if (true) {
5627                        throw (ParseException) jjte000;
5628                    }
5629                }
5630            } {
5631                if (true) {
5632                    throw (Error JavaDoc) jjte000;
5633                }
5634            }
5635        }
5636        finally {
5637            if (jjtc000) {
5638                jjtree.closeNodeScope(jjtn000, true);
5639            }
5640        }
5641    }
5642
5643    static final public void SynchronizedStatement() throws ParseException {
5644
5645        /* @bgen(jjtree) SynchronizedStatement */
5646        SimpleNode jjtn000 = new SimpleNode(JJTSYNCHRONIZEDSTATEMENT);
5647        boolean jjtc000 = true;
5648
5649        jjtree.openNodeScope(jjtn000);
5650        try {
5651            jj_consume_token(SYNCHRONIZED);
5652            jj_consume_token(LPAREN);
5653            Expression();
5654            jj_consume_token(RPAREN);
5655            Block();
5656        } catch (Throwable JavaDoc jjte000) {
5657            if (jjtc000) {
5658                jjtree.clearNodeScope(jjtn000);
5659                jjtc000 = false;
5660            } else {
5661                jjtree.popNode();
5662            }
5663            if (jjte000 instanceof RuntimeException JavaDoc) { {
5664                    if (true) {
5665                        throw (RuntimeException JavaDoc) jjte000;
5666                    }
5667                }
5668            }
5669            if (jjte000 instanceof ParseException) { {
5670                    if (true) {
5671                        throw (ParseException) jjte000;
5672                    }
5673                }
5674            } {
5675                if (true) {
5676                    throw (Error JavaDoc) jjte000;
5677                }
5678            }
5679        }
5680        finally {
5681            if (jjtc000) {
5682                jjtree.closeNodeScope(jjtn000, true);
5683            }
5684        }
5685    }
5686
5687    static final public void TryStatement() throws ParseException {
5688
5689        /* @bgen(jjtree) TryStatement */
5690        SimpleNode jjtn000 = new SimpleNode(JJTTRYSTATEMENT);
5691        boolean jjtc000 = true;
5692
5693        jjtree.openNodeScope(jjtn000);
5694        try {
5695            jj_consume_token(TRY);
5696            Block();
5697            label_41:
5698            while (true) {
5699                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
5700                case CATCH:
5701                    ;
5702                    break;
5703
5704                default:
5705                    jj_la1[110] = jj_gen;
5706                    break label_41;
5707                }
5708                jj_consume_token(CATCH);
5709                jj_consume_token(LPAREN);
5710                FormalParameter();
5711                jj_consume_token(RPAREN);
5712                Block();
5713            }
5714            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
5715            case FINALLY:
5716                jj_consume_token(FINALLY);
5717                Block();
5718                break;
5719
5720            default:
5721                jj_la1[111] = jj_gen;
5722                ;
5723            }
5724        } catch (Throwable JavaDoc jjte000) {
5725            if (jjtc000) {
5726                jjtree.clearNodeScope(jjtn000);
5727                jjtc000 = false;
5728            } else {
5729                jjtree.popNode();
5730            }
5731            if (jjte000 instanceof RuntimeException JavaDoc) { {
5732                    if (true) {
5733                        throw (RuntimeException JavaDoc) jjte000;
5734                    }
5735                }
5736            }
5737            if (jjte000 instanceof ParseException) { {
5738                    if (true) {
5739                        throw (ParseException) jjte000;
5740                    }
5741                }
5742            } {
5743                if (true) {
5744                    throw (Error JavaDoc) jjte000;
5745                }
5746            }
5747        }
5748        finally {
5749            if (jjtc000) {
5750                jjtree.closeNodeScope(jjtn000, true);
5751            }
5752        }
5753    }
5754
5755    static final private boolean jj_2_1(int xla) {
5756        jj_la = xla;
5757        jj_lastpos = jj_scanpos = token;
5758        boolean retval = !jj_3_1();
5759
5760        jj_save(0, xla);
5761        return retval;
5762    }
5763
5764    static final private boolean jj_2_2(int xla) {
5765        jj_la = xla;
5766        jj_lastpos = jj_scanpos = token;
5767        boolean retval = !jj_3_2();
5768
5769        jj_save(1, xla);
5770        return retval;
5771    }
5772
5773    static final private boolean jj_2_3(int xla) {
5774        jj_la = xla;
5775        jj_lastpos = jj_scanpos = token;
5776        boolean retval = !jj_3_3();
5777
5778        jj_save(2, xla);
5779        return retval;
5780    }
5781
5782    static final private boolean jj_2_4(int xla) {
5783        jj_la = xla;
5784        jj_lastpos = jj_scanpos = token;
5785        boolean retval = !jj_3_4();
5786
5787        jj_save(3, xla);
5788        return retval;
5789    }
5790
5791    static final private boolean jj_2_5(int xla) {
5792        jj_la = xla;
5793        jj_lastpos = jj_scanpos = token;
5794        boolean retval = !jj_3_5();
5795
5796        jj_save(4, xla);
5797        return retval;
5798    }
5799
5800    static final private boolean jj_2_6(int xla) {
5801        jj_la = xla;
5802        jj_lastpos = jj_scanpos = token;
5803        boolean retval = !jj_3_6();
5804
5805        jj_save(5, xla);
5806        return retval;
5807    }
5808
5809    static final private boolean jj_2_7(int xla) {
5810        jj_la = xla;
5811        jj_lastpos = jj_scanpos = token;
5812        boolean retval = !jj_3_7();
5813
5814        jj_save(6, xla);
5815        return retval;
5816    }
5817
5818    static final private boolean jj_2_8(int xla) {
5819        jj_la = xla;
5820        jj_lastpos = jj_scanpos = token;
5821        boolean retval = !jj_3_8();
5822
5823        jj_save(7, xla);
5824        return retval;
5825    }
5826
5827    static final private boolean jj_2_9(int xla) {
5828        jj_la = xla;
5829        jj_lastpos = jj_scanpos = token;
5830        boolean retval = !jj_3_9();
5831
5832        jj_save(8, xla);
5833        return retval;
5834    }
5835
5836    static final private boolean jj_2_10(int xla) {
5837        jj_la = xla;
5838        jj_lastpos = jj_scanpos = token;
5839        boolean retval = !jj_3_10();
5840
5841        jj_save(9, xla);
5842        return retval;
5843    }
5844
5845    static final private boolean jj_2_11(int xla) {
5846        jj_la = xla;
5847        jj_lastpos = jj_scanpos = token;
5848        boolean retval = !jj_3_11();
5849
5850        jj_save(10, xla);
5851        return retval;
5852    }
5853
5854    static final private boolean jj_2_12(int xla) {
5855        jj_la = xla;
5856        jj_lastpos = jj_scanpos = token;
5857        boolean retval = !jj_3_12();
5858
5859        jj_save(11, xla);
5860        return retval;
5861    }
5862
5863    static final private boolean jj_2_13(int xla) {
5864        jj_la = xla;
5865        jj_lastpos = jj_scanpos = token;
5866        boolean retval = !jj_3_13();
5867
5868        jj_save(12, xla);
5869        return retval;
5870    }
5871
5872    static final private boolean jj_2_14(int xla) {
5873        jj_la = xla;
5874        jj_lastpos = jj_scanpos = token;
5875        boolean retval = !jj_3_14();
5876
5877        jj_save(13, xla);
5878        return retval;
5879    }
5880
5881    static final private boolean jj_2_15(int xla) {
5882        jj_la = xla;
5883        jj_lastpos = jj_scanpos = token;
5884        boolean retval = !jj_3_15();
5885
5886        jj_save(14, xla);
5887        return retval;
5888    }
5889
5890    static final private boolean jj_2_16(int xla) {
5891        jj_la = xla;
5892        jj_lastpos = jj_scanpos = token;
5893        boolean retval = !jj_3_16();
5894
5895        jj_save(15, xla);
5896        return retval;
5897    }
5898
5899    static final private boolean jj_2_17(int xla) {
5900        jj_la = xla;
5901        jj_lastpos = jj_scanpos = token;
5902        boolean retval = !jj_3_17();
5903
5904        jj_save(16, xla);
5905        return retval;
5906    }
5907
5908    static final private boolean jj_2_18(int xla) {
5909        jj_la = xla;
5910        jj_lastpos = jj_scanpos = token;
5911        boolean retval = !jj_3_18();
5912
5913        jj_save(17, xla);
5914        return retval;
5915    }
5916
5917    static final private boolean jj_2_19(int xla) {
5918        jj_la = xla;
5919        jj_lastpos = jj_scanpos = token;
5920        boolean retval = !jj_3_19();
5921
5922        jj_save(18, xla);
5923        return retval;
5924    }
5925
5926    static final private boolean jj_2_20(int xla) {
5927        jj_la = xla;
5928        jj_lastpos = jj_scanpos = token;
5929        boolean retval = !jj_3_20();
5930
5931        jj_save(19, xla);
5932        return retval;
5933    }
5934
5935    static final private boolean jj_2_21(int xla) {
5936        jj_la = xla;
5937        jj_lastpos = jj_scanpos = token;
5938        boolean retval = !jj_3_21();
5939
5940        jj_save(20, xla);
5941        return retval;
5942    }
5943
5944    static final private boolean jj_2_22(int xla) {
5945        jj_la = xla;
5946        jj_lastpos = jj_scanpos = token;
5947        boolean retval = !jj_3_22();
5948
5949        jj_save(21, xla);
5950        return retval;
5951    }
5952
5953    static final private boolean jj_2_23(int xla) {
5954        jj_la = xla;
5955        jj_lastpos = jj_scanpos = token;
5956        boolean retval = !jj_3_23();
5957
5958        jj_save(22, xla);
5959        return retval;
5960    }
5961
5962    static final private boolean jj_2_24(int xla) {
5963        jj_la = xla;
5964        jj_lastpos = jj_scanpos = token;
5965        boolean retval = !jj_3_24();
5966
5967        jj_save(23, xla);
5968        return retval;
5969    }
5970
5971    static final private boolean jj_2_25(int xla) {
5972        jj_la = xla;
5973        jj_lastpos = jj_scanpos = token;
5974        boolean retval = !jj_3_25();
5975
5976        jj_save(24, xla);
5977        return retval;
5978    }
5979
5980    static final private boolean jj_2_26(int xla) {
5981        jj_la = xla;
5982        jj_lastpos = jj_scanpos = token;
5983        boolean retval = !jj_3_26();
5984
5985        jj_save(25, xla);
5986        return retval;
5987    }
5988
5989    static final private boolean jj_2_27(int xla) {
5990        jj_la = xla;
5991        jj_lastpos = jj_scanpos = token;
5992        boolean retval = !jj_3_27();
5993
5994        jj_save(26, xla);
5995        return retval;
5996    }
5997
5998    static final private boolean jj_2_28(int xla) {
5999        jj_la = xla;
6000        jj_lastpos = jj_scanpos = token;
6001        boolean retval = !jj_3_28();
6002
6003        jj_save(27, xla);
6004        return retval;
6005    }
6006
6007    static final private boolean jj_2_29(int xla) {
6008        jj_la = xla;
6009        jj_lastpos = jj_scanpos = token;
6010        boolean retval = !jj_3_29();
6011
6012        jj_save(28, xla);
6013        return retval;
6014    }
6015
6016    static final private boolean jj_3R_364() {
6017        if (jj_scan_token(LPAREN)) {
6018            return true;
6019        }
6020        if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6021            return false;
6022        }
6023        if (jj_3R_63()) {
6024            return true;
6025        }
6026        if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6027            return false;
6028        }
6029        if (jj_scan_token(RPAREN)) {
6030            return true;
6031        }
6032        if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6033            return false;
6034        }
6035        if (jj_3R_262()) {
6036            return true;
6037        }
6038        if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6039            return false;
6040        }
6041        return false;
6042    }
6043
6044    static final private boolean jj_3R_357() {
6045        Token xsp;
6046
6047        xsp = jj_scanpos;
6048        if (jj_3R_364()) {
6049            jj_scanpos = xsp;
6050            if (jj_3R_365()) {
6051                return true;
6052            }
6053            if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6054                return false;
6055            }
6056        } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6057            return false;
6058        }
6059        return false;
6060    }
6061
6062    static final private boolean jj_3_17() {
6063        if (jj_scan_token(LPAREN)) {
6064            return true;
6065        }
6066        if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6067            return false;
6068        }
6069        if (jj_3R_47()) {
6070            return true;
6071        }
6072        if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6073            return false;
6074        }
6075        if (jj_scan_token(LBRACKET)) {
6076            return true;
6077        }
6078        if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6079