1
2 package net.sourceforge.pmd.lang.java.ast;
3 import java.util.ArrayList;
4 import java.util.List;
5 import java.util.Map;
6 import net.sourceforge.pmd.lang.ast.CharStream;
7 import net.sourceforge.pmd.lang.ast.TokenMgrError;
8 public class JavaParserimplements JavaParserTreeConstants, JavaParserConstants {
9 protected JJTJavaParserState jjtree = new JJTJavaParserState();
10 private int jdkVersion = 0;
11
12 public void setJdkVersion(int jdkVersion) {
13 this.jdkVersion = jdkVersion;
14 }
15
16 private void throwParseException(String message) {
17 int line = -1;
18 int col = -1;
19 if (jj_lastpos != null) {
20 line = jj_lastpos.beginLine;
21 col = jj_lastpos.beginColumn;
22 }
23 throw new ParseException("Line " + line + ", Column " + col + ": " + message);
24 }
25
26 private void checkForBadAssertUsage(String in, String usage) {
27 if (jdkVersion > 3 && in.equals("assert")) {
28 throwParseException("Can't use 'assert' as " + usage + " when running in JDK 1.4 mode!");
29 }
30 }
31
32 private void checkForBadStaticImportUsage() {
33 if (jdkVersion < 5) {
34 throwParseException("Can't use static imports when running in JDK 1.4 mode!");
35 }
36 }
37
38 private void checkForBadAnnotationUsage() {
39 if (jdkVersion < 5) {
40 throwParseException("Can't use annotations when running in JDK 1.4 mode!");
41 }
42 }
43
44 private void checkForBadGenericsUsage() {
45 if (jdkVersion < 5) {
46 throwParseException("Can't use generics unless running in JDK 1.5 mode!");
47 }
48 }
49
50 private void checkForBadVariableArgumentsUsage() {
51 if (jdkVersion < 5) {
52 throwParseException("Can't use variable arguments (varargs) when running in JDK 1.4 mode!");
53 }
54 }
55
56 private void checkForBadJDK15ForLoopSyntaxArgumentsUsage() {
57 if (jdkVersion < 5) {
58 throwParseException("Can't use JDK 1.5 for loop syntax when running in JDK 1.4 mode!");
59 }
60 }
61
62 private void checkForBadEnumUsage(String in, String usage) {
63 if (jdkVersion >= 5 && in.equals("enum")) {
64 throwParseException("Can't use 'enum' as " + usage + " when running in JDK 1.5 mode!");
65 }
66 }
67
68 private void checkForBadHexFloatingPointLiteral() {
69 if (jdkVersion < 5) {
70 throwParseException("Can't use hexadecimal floating point literals in pre-JDK 1.5 target");
71 }
72 }
73
74 private void checkForBadNumericalLiteralslUsage(Token token) {
75 if (jdkVersion < 7) {
76 if (token.image.contains("_")) {
77 throwParseException("Can't use underscores in numerical literals when running in JDK inferior to 1.7 mode!");
78 }
79
80 if (token.image.startsWith("0b") || token.image.startsWith("0B")) {
81 throwParseException("Can't use binary numerical literals when running in JDK inferior to 1.7 mode!");
82 }
83 }
84 }
85
86 private void checkForBadDiamondUsage() {
87 if (jdkVersion < 7) {
88 throwParseException("Cannot use the diamond generic notation when running in JDK inferior to 1.7 mode!");
89 }
90 }
91
92 private void checkForBadTryWithResourcesUsage() {
93 if (jdkVersion < 7) {
94 throwParseException("Cannot use the try-with-resources notation when running in JDK inferior to 1.7 mode!");
95 }
96 }
97
98 private void checkForBadMultipleExceptionsCatching() {
99 if (jdkVersion < 7) {
100 throwParseException("Cannot catch multiple exceptions when running in JDK inferior to 1.7 mode!");
101 }
102 }
103
104 private void checkForBadLambdaUsage() {
105 if (jdkVersion < 8) {
106 throwParseException("Cannot use lambda expressions when running in JDK inferior to 1.8 mode!");
107 }
108 }
109 private void checkForBadMethodReferenceUsage() {
110 if (jdkVersion < 8) {
111 throwParseException("Cannot use method references when running in JDK inferior to 1.8 mode!");
112 }
113 }
114 private void checkForBadDefaultImplementationUsage() {
115 if (jdkVersion < 8) {
116 throwParseException("Cannot use default implementations in interfaces when running in JDK inferior to 1.8 mode!");
117 }
118 }
119 private void checkForBadIntersectionTypesInCasts() {
120 if (jdkVersion < 8) {
121 throwParseException("Cannot use intersection types in casts when running in JDK inferior to 1.8 mode!");
122 }
123 }
124 private void checkForBadTypeAnnotations() {
125 if (jdkVersion < 8) {
126 throwParseException("Cannot use type annotations when running in JDK inferior to 1.8 mode!");
127 }
128 }
129
130
131
132
133 private boolean isNextTokenAnAssert() {
134 boolean res = getToken(1).image.equals("assert");
135 if (res && jdkVersion <= 3 && getToken(2).image.equals("(")) {
136 res = false;
137 }
138 return res;
139 }
140
141 private boolean isPrecededByComment(Token tok) {
142 boolean res = false;
143 while (!res && tok.specialToken != null) {
144 tok = tok.specialToken;
145 res = tok.kind == SINGLE_LINE_COMMENT ||
146 tok.kind == FORMAL_COMMENT ||
147 tok.kind == MULTI_LINE_COMMENT;
148 }
149 return res;
150 }
151
152 public Map<Integer, String> getSuppressMap() {
153 return token_source.getSuppressMap();
154 }
155
156 public void setSuppressMarker(String marker) {
157 token_source.setSuppressMarker(marker);
158 }
159
160
161
162
163
164
165
166
167 final public ASTCompilationUnit CompilationUnit() throws ParseException {
168
169 ASTCompilationUnit jjtn000 = new ASTCompilationUnit(this, JJTCOMPILATIONUNIT);
170 boolean jjtc000 = true;
171 jjtree.openNodeScope(jjtn000);
172 try {
173 if (jj_2_1(2147483647)) {
174 PackageDeclaration();
175 } else {
176 ;
177 }
178 label_1:
179 while (true) {
180 switch (jj_nt.kind) {
181 case IMPORT:
182 ;
183 break;
184 default:
185 jj_la1[0] = jj_gen;
186 break label_1;
187 }
188 ImportDeclaration();
189 }
190 label_2:
191 while (true) {
192 switch (jj_nt.kind) {
193 case ABSTRACT:
194 case CLASS:
195 case _DEFAULT:
196 case FINAL:
197 case INTERFACE:
198 case NATIVE:
199 case PRIVATE:
200 case PROTECTED:
201 case PUBLIC:
202 case STATIC:
203 case SYNCHRONIZED:
204 case TRANSIENT:
205 case VOLATILE:
206 case STRICTFP:
207 case IDENTIFIER:
208 case SEMICOLON:
209 case AT:
210 ;
211 break;
212 default:
213 jj_la1[1] = jj_gen;
214 break label_2;
215 }
216 TypeDeclaration();
217 }
218 switch (jj_nt.kind) {
219 case 126:
220 jj_consume_token(126);
221 break;
222 default:
223 jj_la1[2] = jj_gen;
224 ;
225 }
226 switch (jj_nt.kind) {
227 case 127:
228 jj_consume_token(127);
229 break;
230 default:
231 jj_la1[3] = jj_gen;
232 ;
233 }
234 jj_consume_token(0);
235 jjtree.closeNodeScope(jjtn000, true);
236 jjtc000 = false;
237 jjtn000.setComments(token_source.comments);
238 {if (true) return jjtn000;}
239 } catch (Throwable jjte000) {
240 if (jjtc000) {
241 jjtree.clearNodeScope(jjtn000);
242 jjtc000 = false;
243 } else {
244 jjtree.popNode();
245 }
246 if (jjte000 instanceof RuntimeException) {
247 {if (true) throw (RuntimeException)jjte000;}
248 }
249 if (jjte000 instanceof ParseException) {
250 {if (true) throw (ParseException)jjte000;}
251 }
252 {if (true) throw (Error)jjte000;}
253 } finally {
254 if (jjtc000) {
255 jjtree.closeNodeScope(jjtn000, true);
256 }
257 }
258 throw new RuntimeException("Missing return statement in function");
259 }
260
261 final public void PackageDeclaration() throws ParseException {
262
263 ASTPackageDeclaration jjtn000 = new ASTPackageDeclaration(this, JJTPACKAGEDECLARATION);
264 boolean jjtc000 = true;
265 jjtree.openNodeScope(jjtn000);
266 try {
267 label_3:
268 while (true) {
269 switch (jj_nt.kind) {
270 case AT:
271 ;
272 break;
273 default:
274 jj_la1[4] = jj_gen;
275 break label_3;
276 }
277 Annotation();
278 }
279 jj_consume_token(PACKAGE);
280 Name();
281 jj_consume_token(SEMICOLON);
282 } catch (Throwable jjte000) {
283 if (jjtc000) {
284 jjtree.clearNodeScope(jjtn000);
285 jjtc000 = false;
286 } else {
287 jjtree.popNode();
288 }
289 if (jjte000 instanceof RuntimeException) {
290 {if (true) throw (RuntimeException)jjte000;}
291 }
292 if (jjte000 instanceof ParseException) {
293 {if (true) throw (ParseException)jjte000;}
294 }
295 {if (true) throw (Error)jjte000;}
296 } finally {
297 if (jjtc000) {
298 jjtree.closeNodeScope(jjtn000, true);
299 }
300 }
301 }
302
303 final public void ImportDeclaration() throws ParseException {
304
305 ASTImportDeclaration jjtn000 = new ASTImportDeclaration(this, JJTIMPORTDECLARATION);
306 boolean jjtc000 = true;
307 jjtree.openNodeScope(jjtn000);
308 try {
309 jj_consume_token(IMPORT);
310 switch (jj_nt.kind) {
311 case STATIC:
312 jj_consume_token(STATIC);
313 checkForBadStaticImportUsage();jjtn000.setStatic();
314 break;
315 default:
316 jj_la1[5] = jj_gen;
317 ;
318 }
319 Name();
320 switch (jj_nt.kind) {
321 case DOT:
322 jj_consume_token(DOT);
323 jj_consume_token(STAR);
324 jjtn000.setImportOnDemand();
325 break;
326 default:
327 jj_la1[6] = jj_gen;
328 ;
329 }
330 jj_consume_token(SEMICOLON);
331 } catch (Throwable jjte000) {
332 if (jjtc000) {
333 jjtree.clearNodeScope(jjtn000);
334 jjtc000 = false;
335 } else {
336 jjtree.popNode();
337 }
338 if (jjte000 instanceof RuntimeException) {
339 {if (true) throw (RuntimeException)jjte000;}
340 }
341 if (jjte000 instanceof ParseException) {
342 {if (true) throw (ParseException)jjte000;}
343 }
344 {if (true) throw (Error)jjte000;}
345 } finally {
346 if (jjtc000) {
347 jjtree.closeNodeScope(jjtn000, true);
348 }
349 }
350 }
351
352
353
354
355
356
357 final public int Modifiers() throws ParseException {
358 int modifiers = 0;
359 label_4:
360 while (true) {
361 if (jj_2_2(2)) {
362 ;
363 } else {
364 break label_4;
365 }
366 switch (jj_nt.kind) {
367 case PUBLIC:
368 jj_consume_token(PUBLIC);
369 modifiers |= AccessNode.PUBLIC;
370 break;
371 case STATIC:
372 jj_consume_token(STATIC);
373 modifiers |= AccessNode.STATIC;
374 break;
375 case PROTECTED:
376 jj_consume_token(PROTECTED);
377 modifiers |= AccessNode.PROTECTED;
378 break;
379 case PRIVATE:
380 jj_consume_token(PRIVATE);
381 modifiers |= AccessNode.PRIVATE;
382 break;
383 case FINAL:
384 jj_consume_token(FINAL);
385 modifiers |= AccessNode.FINAL;
386 break;
387 case ABSTRACT:
388 jj_consume_token(ABSTRACT);
389 modifiers |= AccessNode.ABSTRACT;
390 break;
391 case SYNCHRONIZED:
392 jj_consume_token(SYNCHRONIZED);
393 modifiers |= AccessNode.SYNCHRONIZED;
394 break;
395 case NATIVE:
396 jj_consume_token(NATIVE);
397 modifiers |= AccessNode.NATIVE;
398 break;
399 case TRANSIENT:
400 jj_consume_token(TRANSIENT);
401 modifiers |= AccessNode.TRANSIENT;
402 break;
403 case VOLATILE:
404 jj_consume_token(VOLATILE);
405 modifiers |= AccessNode.VOLATILE;
406 break;
407 case STRICTFP:
408 jj_consume_token(STRICTFP);
409 modifiers |= AccessNode.STRICTFP;
410 break;
411 case _DEFAULT:
412 jj_consume_token(_DEFAULT);
413 modifiers |= AccessNode.DEFAULT; checkForBadDefaultImplementationUsage();
414 break;
415 case AT:
416 Annotation();
417 break;
418 default:
419 jj_la1[7] = jj_gen;
420 jj_consume_token(-1);
421 throw new ParseException();
422 }
423 }
424 {if (true) return modifiers;}
425 throw new RuntimeException("Missing return statement in function");
426 }
427
428
429
430
431 final public void TypeDeclaration() throws ParseException {
432
433 ASTTypeDeclaration jjtn000 = new ASTTypeDeclaration(this, JJTTYPEDECLARATION);
434 boolean jjtc000 = true;
435 jjtree.openNodeScope(jjtn000);int modifiers;
436 try {
437 switch (jj_nt.kind) {
438 case SEMICOLON:
439 jj_consume_token(SEMICOLON);
440 break;
441 case ABSTRACT:
442 case CLASS:
443 case _DEFAULT:
444 case FINAL:
445 case INTERFACE:
446 case NATIVE:
447 case PRIVATE:
448 case PROTECTED:
449 case PUBLIC:
450 case STATIC:
451 case SYNCHRONIZED:
452 case TRANSIENT:
453 case VOLATILE:
454 case STRICTFP:
455 case IDENTIFIER:
456 case AT:
457 modifiers = Modifiers();
458 switch (jj_nt.kind) {
459 case ABSTRACT:
460 case CLASS:
461 case FINAL:
462 case INTERFACE:
463 ClassOrInterfaceDeclaration(modifiers);
464 break;
465 case IDENTIFIER:
466 EnumDeclaration(modifiers);
467 break;
468 case AT:
469 AnnotationTypeDeclaration(modifiers);
470 break;
471 default:
472 jj_la1[8] = jj_gen;
473 jj_consume_token(-1);
474 throw new ParseException();
475 }
476 break;
477 default:
478 jj_la1[9] = jj_gen;
479 jj_consume_token(-1);
480 throw new ParseException();
481 }
482 } catch (Throwable jjte000) {
483 if (jjtc000) {
484 jjtree.clearNodeScope(jjtn000);
485 jjtc000 = false;
486 } else {
487 jjtree.popNode();
488 }
489 if (jjte000 instanceof RuntimeException) {
490 {if (true) throw (RuntimeException)jjte000;}
491 }
492 if (jjte000 instanceof ParseException) {
493 {if (true) throw (ParseException)jjte000;}
494 }
495 {if (true) throw (Error)jjte000;}
496 } finally {
497 if (jjtc000) {
498 jjtree.closeNodeScope(jjtn000, true);
499 }
500 }
501 }
502
503 final public void ClassOrInterfaceDeclaration(int modifiers) throws ParseException {
504
505 ASTClassOrInterfaceDeclaration jjtn000 = new ASTClassOrInterfaceDeclaration(this, JJTCLASSORINTERFACEDECLARATION);
506 boolean jjtc000 = true;
507 jjtree.openNodeScope(jjtn000);Token t = null;
508 jjtn000.setModifiers(modifiers);
509 try {
510 switch (jj_nt.kind) {
511 case ABSTRACT:
512 case CLASS:
513 case FINAL:
514 switch (jj_nt.kind) {
515 case ABSTRACT:
516 case FINAL:
517 switch (jj_nt.kind) {
518 case FINAL:
519 jj_consume_token(FINAL);
520 break;
521 case ABSTRACT:
522 jj_consume_token(ABSTRACT);
523 break;
524 default:
525 jj_la1[10] = jj_gen;
526 jj_consume_token(-1);
527 throw new ParseException();
528 }
529 break;
530 default:
531 jj_la1[11] = jj_gen;
532 ;
533 }
534 jj_consume_token(CLASS);
535 break;
536 case INTERFACE:
537 jj_consume_token(INTERFACE);
538 jjtn000.setInterface();
539 break;
540 default:
541 jj_la1[12] = jj_gen;
542 jj_consume_token(-1);
543 throw new ParseException();
544 }
545 t = jj_consume_token(IDENTIFIER);
546 jjtn000.setImage(t.image);
547 switch (jj_nt.kind) {
548 case LT:
549 TypeParameters();
550 break;
551 default:
552 jj_la1[13] = jj_gen;
553 ;
554 }
555 switch (jj_nt.kind) {
556 case EXTENDS:
557 ExtendsList();
558 break;
559 default:
560 jj_la1[14] = jj_gen;
561 ;
562 }
563 switch (jj_nt.kind) {
564 case IMPLEMENTS:
565 ImplementsList();
566 break;
567 default:
568 jj_la1[15] = jj_gen;
569 ;
570 }
571 ClassOrInterfaceBody();
572 } catch (Throwable jjte000) {
573 if (jjtc000) {
574 jjtree.clearNodeScope(jjtn000);
575 jjtc000 = false;
576 } else {
577 jjtree.popNode();
578 }
579 if (jjte000 instanceof RuntimeException) {
580 {if (true) throw (RuntimeException)jjte000;}
581 }
582 if (jjte000 instanceof ParseException) {
583 {if (true) throw (ParseException)jjte000;}
584 }
585 {if (true) throw (Error)jjte000;}
586 } finally {
587 if (jjtc000) {
588 jjtree.closeNodeScope(jjtn000, true);
589 }
590 }
591 }
592
593 final public void ExtendsList() throws ParseException {
594
595 ASTExtendsList jjtn000 = new ASTExtendsList(this, JJTEXTENDSLIST);
596 boolean jjtc000 = true;
597 jjtree.openNodeScope(jjtn000);boolean extendsMoreThanOne = false;
598 try {
599 jj_consume_token(EXTENDS);
600 label_5:
601 while (true) {
602 switch (jj_nt.kind) {
603 case AT:
604 ;
605 break;
606 default:
607 jj_la1[16] = jj_gen;
608 break label_5;
609 }
610 Annotation();
611 checkForBadTypeAnnotations();
612 }
613 ClassOrInterfaceType();
614 label_6:
615 while (true) {
616 switch (jj_nt.kind) {
617 case COMMA:
618 ;
619 break;
620 default:
621 jj_la1[17] = jj_gen;
622 break label_6;
623 }
624 jj_consume_token(COMMA);
625 label_7:
626 while (true) {
627 switch (jj_nt.kind) {
628 case AT:
629 ;
630 break;
631 default:
632 jj_la1[18] = jj_gen;
633 break label_7;
634 }
635 Annotation();
636 checkForBadTypeAnnotations();
637 }
638 ClassOrInterfaceType();
639 extendsMoreThanOne = true;
640 }
641 } catch (Throwable jjte000) {
642 if (jjtc000) {
643 jjtree.clearNodeScope(jjtn000);
644 jjtc000 = false;
645 } else {
646 jjtree.popNode();
647 }
648 if (jjte000 instanceof RuntimeException) {
649 {if (true) throw (RuntimeException)jjte000;}
650 }
651 if (jjte000 instanceof ParseException) {
652 {if (true) throw (ParseException)jjte000;}
653 }
654 {if (true) throw (Error)jjte000;}
655 } finally {
656 if (jjtc000) {
657 jjtree.closeNodeScope(jjtn000, true);
658 }
659 }
660 }
661
662 final public void ImplementsList() throws ParseException {
663
664 ASTImplementsList jjtn000 = new ASTImplementsList(this, JJTIMPLEMENTSLIST);
665 boolean jjtc000 = true;
666 jjtree.openNodeScope(jjtn000);
667 try {
668 jj_consume_token(IMPLEMENTS);
669 label_8:
670 while (true) {
671 switch (jj_nt.kind) {
672 case AT:
673 ;
674 break;
675 default:
676 jj_la1[19] = jj_gen;
677 break label_8;
678 }
679 Annotation();
680 checkForBadTypeAnnotations();
681 }
682 ClassOrInterfaceType();
683 label_9:
684 while (true) {
685 switch (jj_nt.kind) {
686 case COMMA:
687 ;
688 break;
689 default:
690 jj_la1[20] = jj_gen;
691 break label_9;
692 }
693 jj_consume_token(COMMA);
694 label_10:
695 while (true) {
696 switch (jj_nt.kind) {
697 case AT:
698 ;
699 break;
700 default:
701 jj_la1[21] = jj_gen;
702 break label_10;
703 }
704 Annotation();
705 checkForBadTypeAnnotations();
706 }
707 ClassOrInterfaceType();
708 }
709 } catch (Throwable jjte000) {
710 if (jjtc000) {
711 jjtree.clearNodeScope(jjtn000);
712 jjtc000 = false;
713 } else {
714 jjtree.popNode();
715 }
716 if (jjte000 instanceof RuntimeException) {
717 {if (true) throw (RuntimeException)jjte000;}
718 }
719 if (jjte000 instanceof ParseException) {
720 {if (true) throw (ParseException)jjte000;}
721 }
722 {if (true) throw (Error)jjte000;}
723 } finally {
724 if (jjtc000) {
725 jjtree.closeNodeScope(jjtn000, true);
726 }
727 }
728 }
729
730 final public void EnumDeclaration(int modifiers) throws ParseException {
731
732 ASTEnumDeclaration jjtn000 = new ASTEnumDeclaration(this, JJTENUMDECLARATION);
733 boolean jjtc000 = true;
734 jjtree.openNodeScope(jjtn000);Token t;
735 jjtn000.setModifiers(modifiers);
736 try {
737 t = jj_consume_token(IDENTIFIER);
738 if (!t.image.equals("enum")) {
739 {if (true) throw new ParseException("ERROR: expecting enum");}
740 }
741
742 if (jdkVersion < 5) {
743 {if (true) throw new ParseException("ERROR: Can't use enum as a keyword in pre-JDK 1.5 target");}
744 }
745 t = jj_consume_token(IDENTIFIER);
746 jjtn000.setImage(t.image);
747 switch (jj_nt.kind) {
748 case IMPLEMENTS:
749 ImplementsList();
750 break;
751 default:
752 jj_la1[22] = jj_gen;
753 ;
754 }
755 EnumBody();
756 } catch (Throwable jjte000) {
757 if (jjtc000) {
758 jjtree.clearNodeScope(jjtn000);
759 jjtc000 = false;
760 } else {
761 jjtree.popNode();
762 }
763 if (jjte000 instanceof RuntimeException) {
764 {if (true) throw (RuntimeException)jjte000;}
765 }
766 if (jjte000 instanceof ParseException) {
767 {if (true) throw (ParseException)jjte000;}
768 }
769 {if (true) throw (Error)jjte000;}
770 } finally {
771 if (jjtc000) {
772 jjtree.closeNodeScope(jjtn000, true);
773 }
774 }
775 }
776
777 final public void EnumBody() throws ParseException {
778
779 ASTEnumBody jjtn000 = new ASTEnumBody(this, JJTENUMBODY);
780 boolean jjtc000 = true;
781 jjtree.openNodeScope(jjtn000);
782 try {
783 jj_consume_token(LBRACE);
784 switch (jj_nt.kind) {
785 case IDENTIFIER:
786 case AT:
787 label_11:
788 while (true) {
789 switch (jj_nt.kind) {
790 case AT:
791 ;
792 break;
793 default:
794 jj_la1[23] = jj_gen;
795 break label_11;
796 }
797 Annotation();
798 }
799 EnumConstant();
800 label_12:
801 while (true) {
802 if (jj_2_3(2)) {
803 ;
804 } else {
805 break label_12;
806 }
807 jj_consume_token(COMMA);
808 label_13:
809 while (true) {
810 switch (jj_nt.kind) {
811 case AT:
812 ;
813 break;
814 default:
815 jj_la1[24] = jj_gen;
816 break label_13;
817 }
818 Annotation();
819 }
820 EnumConstant();
821 }
822 break;
823 default:
824 jj_la1[25] = jj_gen;
825 ;
826 }
827 switch (jj_nt.kind) {
828 case COMMA:
829 jj_consume_token(COMMA);
830 break;
831 default:
832 jj_la1[26] = jj_gen;
833 ;
834 }
835 switch (jj_nt.kind) {
836 case SEMICOLON:
837 jj_consume_token(SEMICOLON);
838 label_14:
839 while (true) {
840 switch (jj_nt.kind) {
841 case ABSTRACT:
842 case BOOLEAN:
843 case BYTE:
844 case CHAR:
845 case CLASS:
846 case _DEFAULT:
847 case DOUBLE:
848 case FINAL:
849 case FLOAT:
850 case INT:
851 case INTERFACE:
852 case LONG:
853 case NATIVE:
854 case PRIVATE:
855 case PROTECTED:
856 case PUBLIC:
857 case SHORT:
858 case STATIC:
859 case SYNCHRONIZED:
860 case TRANSIENT:
861 case VOID:
862 case VOLATILE:
863 case STRICTFP:
864 case IDENTIFIER:
865 case LBRACE:
866 case SEMICOLON:
867 case AT:
868 case LT:
869 ;
870 break;
871 default:
872 jj_la1[27] = jj_gen;
873 break label_14;
874 }
875 ClassOrInterfaceBodyDeclaration();
876 }
877 break;
878 default:
879 jj_la1[28] = jj_gen;
880 ;
881 }
882 jj_consume_token(RBRACE);
883 } catch (Throwable jjte000) {
884 if (jjtc000) {
885 jjtree.clearNodeScope(jjtn000);
886 jjtc000 = false;
887 } else {
888 jjtree.popNode();
889 }
890 if (jjte000 instanceof RuntimeException) {
891 {if (true) throw (RuntimeException)jjte000;}
892 }
893 if (jjte000 instanceof ParseException) {
894 {if (true) throw (ParseException)jjte000;}
895 }
896 {if (true) throw (Error)jjte000;}
897 } finally {
898 if (jjtc000) {
899 jjtree.closeNodeScope(jjtn000, true);
900 }
901 }
902 }
903
904 final public void EnumConstant() throws ParseException {
905
906 ASTEnumConstant jjtn000 = new ASTEnumConstant(this, JJTENUMCONSTANT);
907 boolean jjtc000 = true;
908 jjtree.openNodeScope(jjtn000);Token t;
909 try {
910 t = jj_consume_token(IDENTIFIER);
911 jjtn000.setImage(t.image);
912 switch (jj_nt.kind) {
913 case LPAREN:
914 Arguments();
915 break;
916 default:
917 jj_la1[29] = jj_gen;
918 ;
919 }
920 switch (jj_nt.kind) {
921 case LBRACE:
922 ClassOrInterfaceBody();
923 break;
924 default:
925 jj_la1[30] = jj_gen;
926 ;
927 }
928 } catch (Throwable jjte000) {
929 if (jjtc000) {
930 jjtree.clearNodeScope(jjtn000);
931 jjtc000 = false;
932 } else {
933 jjtree.popNode();
934 }
935 if (jjte000 instanceof RuntimeException) {
936 {if (true) throw (RuntimeException)jjte000;}
937 }
938 if (jjte000 instanceof ParseException) {
939 {if (true) throw (ParseException)jjte000;}
940 }
941 {if (true) throw (Error)jjte000;}
942 } finally {
943 if (jjtc000) {
944 jjtree.closeNodeScope(jjtn000, true);
945 }
946 }
947 }
948
949 final public void TypeParameters() throws ParseException {
950
951 ASTTypeParameters jjtn000 = new ASTTypeParameters(this, JJTTYPEPARAMETERS);
952 boolean jjtc000 = true;
953 jjtree.openNodeScope(jjtn000);
954 try {
955 jj_consume_token(LT);
956 checkForBadGenericsUsage();
957 TypeParameter();
958 label_15:
959 while (true) {
960 switch (jj_nt.kind) {
961 case COMMA:
962 ;
963 break;
964 default:
965 jj_la1[31] = jj_gen;
966 break label_15;
967 }
968 jj_consume_token(COMMA);
969 TypeParameter();
970 }
971 jj_consume_token(GT);
972 } catch (Throwable jjte000) {
973 if (jjtc000) {
974 jjtree.clearNodeScope(jjtn000);
975 jjtc000 = false;
976 } else {
977 jjtree.popNode();
978 }
979 if (jjte000 instanceof RuntimeException) {
980 {if (true) throw (RuntimeException)jjte000;}
981 }
982 if (jjte000 instanceof ParseException) {
983 {if (true) throw (ParseException)jjte000;}
984 }
985 {if (true) throw (Error)jjte000;}
986 } finally {
987 if (jjtc000) {
988 jjtree.closeNodeScope(jjtn000, true);
989 }
990 }
991 }
992
993 final public void TypeParameter() throws ParseException {
994
995 ASTTypeParameter jjtn000 = new ASTTypeParameter(this, JJTTYPEPARAMETER);
996 boolean jjtc000 = true;
997 jjtree.openNodeScope(jjtn000);Token t;
998 try {
999 label_16:
1000 while (true) {
1001 switch (jj_nt.kind) {
1002 case AT:
1003 ;
1004 break;
1005 default:
1006 jj_la1[32] = jj_gen;
1007 break label_16;
1008 }
1009 Annotation();
1010 checkForBadTypeAnnotations();
1011 }
1012 t = jj_consume_token(IDENTIFIER);
1013 jjtn000.setImage(t.image);
1014 switch (jj_nt.kind) {
1015 case EXTENDS:
1016 TypeBound();
1017 break;
1018 default:
1019 jj_la1[33] = jj_gen;
1020 ;
1021 }
1022 } catch (Throwable jjte000) {
1023 if (jjtc000) {
1024 jjtree.clearNodeScope(jjtn000);
1025 jjtc000 = false;
1026 } else {
1027 jjtree.popNode();
1028 }
1029 if (jjte000 instanceof RuntimeException) {
1030 {if (true) throw (RuntimeException)jjte000;}
1031 }
1032 if (jjte000 instanceof ParseException) {
1033 {if (true) throw (ParseException)jjte000;}
1034 }
1035 {if (true) throw (Error)jjte000;}
1036 } finally {
1037 if (jjtc000) {
1038 jjtree.closeNodeScope(jjtn000, true);
1039 }
1040 }
1041 }
1042
1043 final public void TypeBound() throws ParseException {
1044
1045 ASTTypeBound jjtn000 = new ASTTypeBound(this, JJTTYPEBOUND);
1046 boolean jjtc000 = true;
1047 jjtree.openNodeScope(jjtn000);
1048 try {
1049 jj_consume_token(EXTENDS);
1050 ClassOrInterfaceType();
1051 label_17:
1052 while (true) {
1053 switch (jj_nt.kind) {
1054 case BIT_AND:
1055 ;
1056 break;
1057 default:
1058 jj_la1[34] = jj_gen;
1059 break label_17;
1060 }
1061 jj_consume_token(BIT_AND);
1062 ClassOrInterfaceType();
1063 }
1064 } catch (Throwable jjte000) {
1065 if (jjtc000) {
1066 jjtree.clearNodeScope(jjtn000);
1067 jjtc000 = false;
1068 } else {
1069 jjtree.popNode();
1070 }
1071 if (jjte000 instanceof RuntimeException) {
1072 {if (true) throw (RuntimeException)jjte000;}
1073 }
1074 if (jjte000 instanceof ParseException) {
1075 {if (true) throw (ParseException)jjte000;}
1076 }
1077 {if (true) throw (Error)jjte000;}
1078 } finally {
1079 if (jjtc000) {
1080 jjtree.closeNodeScope(jjtn000, true);
1081 }
1082 }
1083 }
1084
1085 final public void ClassOrInterfaceBody() throws ParseException {
1086
1087 ASTClassOrInterfaceBody jjtn000 = new ASTClassOrInterfaceBody(this, JJTCLASSORINTERFACEBODY);
1088 boolean jjtc000 = true;
1089 jjtree.openNodeScope(jjtn000);
1090 try {
1091 jj_consume_token(LBRACE);
1092 label_18:
1093 while (true) {
1094 switch (jj_nt.kind) {
1095 case ABSTRACT:
1096 case BOOLEAN:
1097 case BYTE:
1098 case CHAR:
1099 case CLASS:
1100 case _DEFAULT:
1101 case DOUBLE:
1102 case FINAL:
1103 case FLOAT:
1104 case INT:
1105 case INTERFACE:
1106 case LONG:
1107 case NATIVE:
1108 case PRIVATE:
1109 case PROTECTED:
1110 case PUBLIC:
1111 case SHORT:
1112 case STATIC:
1113 case SYNCHRONIZED:
1114 case TRANSIENT:
1115 case VOID:
1116 case VOLATILE:
1117 case STRICTFP:
1118 case IDENTIFIER:
1119 case LBRACE:
1120 case SEMICOLON:
1121 case AT:
1122 case LT:
1123 ;
1124 break;
1125 default:
1126 jj_la1[35] = jj_gen;
1127 break label_18;
1128 }
1129 ClassOrInterfaceBodyDeclaration();
1130 }
1131 jj_consume_token(RBRACE);
1132 } catch (Throwable jjte000) {
1133 if (jjtc000) {
1134 jjtree.clearNodeScope(jjtn000);
1135 jjtc000 = false;
1136 } else {
1137 jjtree.popNode();
1138 }
1139 if (jjte000 instanceof RuntimeException) {
1140 {if (true) throw (RuntimeException)jjte000;}
1141 }
1142 if (jjte000 instanceof ParseException) {
1143 {if (true) throw (ParseException)jjte000;}
1144 }
1145 {if (true) throw (Error)jjte000;}
1146 } finally {
1147 if (jjtc000) {
1148 jjtree.closeNodeScope(jjtn000, true);
1149 }
1150 }
1151 }
1152
1153 final public void ClassOrInterfaceBodyDeclaration() throws ParseException {
1154
1155 ASTClassOrInterfaceBodyDeclaration jjtn000 = new ASTClassOrInterfaceBodyDeclaration(this, JJTCLASSORINTERFACEBODYDECLARATION);
1156 boolean jjtc000 = true;
1157 jjtree.openNodeScope(jjtn000);int modifiers;
1158 try {
1159 if (jj_2_8(2147483647)) {
1160 Initializer();
1161 } else {
1162 switch (jj_nt.kind) {
1163 case ABSTRACT:
1164 case BOOLEAN:
1165 case BYTE:
1166 case CHAR:
1167 case CLASS:
1168 case _DEFAULT:
1169 case DOUBLE:
1170 case FINAL:
1171 case FLOAT:
1172 case INT:
1173 case INTERFACE:
1174 case LONG:
1175 case NATIVE:
1176 case PRIVATE:
1177 case PROTECTED:
1178 case PUBLIC:
1179 case SHORT:
1180 case STATIC:
1181 case SYNCHRONIZED:
1182 case TRANSIENT:
1183 case VOID:
1184 case VOLATILE:
1185 case STRICTFP:
1186 case IDENTIFIER:
1187 case AT:
1188 case LT:
1189 modifiers = Modifiers();
1190 if (jj_2_4(3)) {
1191 ClassOrInterfaceDeclaration(modifiers);
1192 } else if (jj_2_5(3)) {
1193 EnumDeclaration(modifiers);
1194 } else if (jj_2_6(2147483647)) {
1195 ConstructorDeclaration(modifiers);
1196 } else if (jj_2_7(2147483647)) {
1197 FieldDeclaration(modifiers);
1198 } else {
1199 switch (jj_nt.kind) {
1200 case BOOLEAN:
1201 case BYTE:
1202 case CHAR:
1203 case DOUBLE:
1204 case FLOAT:
1205 case INT:
1206 case LONG:
1207 case SHORT:
1208 case VOID:
1209 case IDENTIFIER:
1210 case LT:
1211 MethodDeclaration(modifiers);
1212 break;
1213 case AT:
1214 AnnotationTypeDeclaration(modifiers);
1215 break;
1216 default:
1217 jj_la1[36] = jj_gen;
1218 jj_consume_token(-1);
1219 throw new ParseException();
1220 }
1221 }
1222 break;
1223 case SEMICOLON:
1224 jj_consume_token(SEMICOLON);
1225 break;
1226 default:
1227 jj_la1[37] = jj_gen;
1228 jj_consume_token(-1);
1229 throw new ParseException();
1230 }
1231 }
1232 } catch (Throwable jjte000) {
1233 if (jjtc000) {
1234 jjtree.clearNodeScope(jjtn000);
1235 jjtc000 = false;
1236 } else {
1237 jjtree.popNode();
1238 }
1239 if (jjte000 instanceof RuntimeException) {
1240 {if (true) throw (RuntimeException)jjte000;}
1241 }
1242 if (jjte000 instanceof ParseException) {
1243 {if (true) throw (ParseException)jjte000;}
1244 }
1245 {if (true) throw (Error)jjte000;}
1246 } finally {
1247 if (jjtc000) {
1248 jjtree.closeNodeScope(jjtn000, true);
1249 }
1250 }
1251 }
1252
1253 final public void FieldDeclaration(int modifiers) throws ParseException {
1254
1255 ASTFieldDeclaration jjtn000 = new ASTFieldDeclaration(this, JJTFIELDDECLARATION);
1256 boolean jjtc000 = true;
1257 jjtree.openNodeScope(jjtn000);jjtn000.setModifiers(modifiers);
1258 try {
1259 Type();
1260 VariableDeclarator();
1261 label_19:
1262 while (true) {
1263 switch (jj_nt.kind) {
1264 case COMMA:
1265 ;
1266 break;
1267 default:
1268 jj_la1[38] = jj_gen;
1269 break label_19;
1270 }
1271 jj_consume_token(COMMA);
1272 VariableDeclarator();
1273 }
1274 jj_consume_token(SEMICOLON);
1275 } catch (Throwable jjte000) {
1276 if (jjtc000) {
1277 jjtree.clearNodeScope(jjtn000);
1278 jjtc000 = false;
1279 } else {
1280 jjtree.popNode();
1281 }
1282 if (jjte000 instanceof RuntimeException) {
1283 {if (true) throw (RuntimeException)jjte000;}
1284 }
1285 if (jjte000 instanceof ParseException) {
1286 {if (true) throw (ParseException)jjte000;}
1287 }
1288 {if (true) throw (Error)jjte000;}
1289 } finally {
1290 if (jjtc000) {
1291 jjtree.closeNodeScope(jjtn000, true);
1292 }
1293 }
1294 }
1295
1296 final public void VariableDeclarator() throws ParseException {
1297
1298 ASTVariableDeclarator jjtn000 = new ASTVariableDeclarator(this, JJTVARIABLEDECLARATOR);
1299 boolean jjtc000 = true;
1300 jjtree.openNodeScope(jjtn000);
1301 try {
1302 VariableDeclaratorId();
1303 switch (jj_nt.kind) {
1304 case ASSIGN:
1305 jj_consume_token(ASSIGN);
1306 VariableInitializer();
1307 break;
1308 default:
1309 jj_la1[39] = jj_gen;
1310 ;
1311 }
1312 } catch (Throwable jjte000) {
1313 if (jjtc000) {
1314 jjtree.clearNodeScope(jjtn000);
1315 jjtc000 = false;
1316 } else {
1317 jjtree.popNode();
1318 }
1319 if (jjte000 instanceof RuntimeException) {
1320 {if (true) throw (RuntimeException)jjte000;}
1321 }
1322 if (jjte000 instanceof ParseException) {
1323 {if (true) throw (ParseException)jjte000;}
1324 }
1325 {if (true) throw (Error)jjte000;}
1326 } finally {
1327 if (jjtc000) {
1328 jjtree.closeNodeScope(jjtn000, true);
1329 }
1330 }
1331 }
1332
1333 final public void VariableDeclaratorId() throws ParseException {
1334
1335 ASTVariableDeclaratorId jjtn000 = new ASTVariableDeclaratorId(this, JJTVARIABLEDECLARATORID);
1336 boolean jjtc000 = true;
1337 jjtree.openNodeScope(jjtn000);Token t;
1338 try {
1339 t = jj_consume_token(IDENTIFIER);
1340 label_20:
1341 while (true) {
1342 switch (jj_nt.kind) {
1343 case LBRACKET:
1344 ;
1345 break;
1346 default:
1347 jj_la1[40] = jj_gen;
1348 break label_20;
1349 }
1350 jj_consume_token(LBRACKET);
1351 jj_consume_token(RBRACKET);
1352 jjtn000.bumpArrayDepth();
1353 }
1354 jjtree.closeNodeScope(jjtn000, true);
1355 jjtc000 = false;
1356 checkForBadAssertUsage(t.image, "a variable name");
1357 checkForBadEnumUsage(t.image, "a variable name");
1358 jjtn000.setImage( t.image );
1359 } finally {
1360 if (jjtc000) {
1361 jjtree.closeNodeScope(jjtn000, true);
1362 }
1363 }
1364 }
1365
1366 final public void VariableInitializer() throws ParseException {
1367
1368 ASTVariableInitializer jjtn000 = new ASTVariableInitializer(this, JJTVARIABLEINITIALIZER);
1369 boolean jjtc000 = true;
1370 jjtree.openNodeScope(jjtn000);
1371 try {
1372 switch (jj_nt.kind) {
1373 case LBRACE:
1374 ArrayInitializer();
1375 break;
1376 case BOOLEAN:
1377 case BYTE:
1378 case CHAR:
1379 case DOUBLE:
1380 case FALSE:
1381 case FLOAT:
1382 case INT:
1383 case LONG:
1384 case NEW:
1385 case NULL:
1386 case SHORT:
1387 case SUPER:
1388 case THIS:
1389 case TRUE:
1390 case VOID:
1391 case INTEGER_LITERAL:
1392 case FLOATING_POINT_LITERAL:
1393 case HEX_FLOATING_POINT_LITERAL:
1394 case CHARACTER_LITERAL:
1395 case STRING_LITERAL:
1396 case IDENTIFIER:
1397 case LPAREN:
1398 case BANG:
1399 case TILDE:
1400 case INCR:
1401 case DECR:
1402 case PLUS:
1403 case MINUS:
1404 Expression();
1405 break;
1406 default:
1407 jj_la1[41] = jj_gen;
1408 jj_consume_token(-1);
1409 throw new ParseException();
1410 }
1411 } catch (Throwable jjte000) {
1412 if (jjtc000) {
1413 jjtree.clearNodeScope(jjtn000);
1414 jjtc000 = false;
1415 } else {
1416 jjtree.popNode();
1417 }
1418 if (jjte000 instanceof RuntimeException) {
1419 {if (true) throw (RuntimeException)jjte000;}
1420 }
1421 if (jjte000 instanceof ParseException) {
1422 {if (true) throw (ParseException)jjte000;}
1423 }
1424 {if (true) throw (Error)jjte000;}
1425 } finally {
1426 if (jjtc000) {
1427 jjtree.closeNodeScope(jjtn000, true);
1428 }
1429 }
1430 }
1431
1432 final public void ArrayInitializer() throws ParseException {
1433
1434 ASTArrayInitializer jjtn000 = new ASTArrayInitializer(this, JJTARRAYINITIALIZER);
1435 boolean jjtc000 = true;
1436 jjtree.openNodeScope(jjtn000);
1437 try {
1438 jj_consume_token(LBRACE);
1439 switch (jj_nt.kind) {
1440 case BOOLEAN:
1441 case BYTE:
1442 case CHAR:
1443 case DOUBLE:
1444 case FALSE:
1445 case FLOAT:
1446 case INT:
1447 case LONG:
1448 case NEW:
1449 case NULL:
1450 case SHORT:
1451 case SUPER:
1452 case THIS:
1453 case TRUE:
1454 case VOID:
1455 case INTEGER_LITERAL:
1456 case FLOATING_POINT_LITERAL:
1457 case HEX_FLOATING_POINT_LITERAL:
1458 case CHARACTER_LITERAL:
1459 case STRING_LITERAL:
1460 case IDENTIFIER:
1461 case LPAREN:
1462 case LBRACE:
1463 case BANG:
1464 case TILDE:
1465 case INCR:
1466 case DECR:
1467 case PLUS:
1468 case MINUS:
1469 VariableInitializer();
1470 label_21:
1471 while (true) {
1472 if (jj_2_9(2)) {
1473 ;
1474 } else {
1475 break label_21;
1476 }
1477 jj_consume_token(COMMA);
1478 VariableInitializer();
1479 }
1480 break;
1481 default:
1482 jj_la1[42] = jj_gen;
1483 ;
1484 }
1485 switch (jj_nt.kind) {
1486 case COMMA:
1487 jj_consume_token(COMMA);
1488 break;
1489 default:
1490 jj_la1[43] = jj_gen;
1491 ;
1492 }
1493 jj_consume_token(RBRACE);
1494 } catch (Throwable jjte000) {
1495 if (jjtc000) {
1496 jjtree.clearNodeScope(jjtn000);
1497 jjtc000 = false;
1498 } else {
1499 jjtree.popNode();
1500 }
1501 if (jjte000 instanceof RuntimeException) {
1502 {if (true) throw (RuntimeException)jjte000;}
1503 }
1504 if (jjte000 instanceof ParseException) {
1505 {if (true) throw (ParseException)jjte000;}
1506 }
1507 {if (true) throw (Error)jjte000;}
1508 } finally {
1509 if (jjtc000) {
1510 jjtree.closeNodeScope(jjtn000, true);
1511 }
1512 }
1513 }
1514
1515 final public void MethodDeclaration(int modifiers) throws ParseException {
1516
1517 ASTMethodDeclaration jjtn000 = new ASTMethodDeclaration(this, JJTMETHODDECLARATION);
1518 boolean jjtc000 = true;
1519 jjtree.openNodeScope(jjtn000);jjtn000.setModifiers(modifiers);
1520 try {
1521 switch (jj_nt.kind) {
1522 case LT:
1523 TypeParameters();
1524 break;
1525 default:
1526 jj_la1[44] = jj_gen;
1527 ;
1528 }
1529 ResultType();
1530 MethodDeclarator();
1531 switch (jj_nt.kind) {
1532 case THROWS:
1533 jj_consume_token(THROWS);
1534 NameList();
1535 break;
1536 default:
1537 jj_la1[45] = jj_gen;
1538 ;
1539 }
1540 switch (jj_nt.kind) {
1541 case LBRACE:
1542 Block();
1543 break;
1544 case SEMICOLON:
1545 jj_consume_token(SEMICOLON);
1546 break;
1547 default:
1548 jj_la1[46] = jj_gen;
1549 jj_consume_token(-1);
1550 throw new ParseException();
1551 }
1552 } catch (Throwable jjte000) {
1553 if (jjtc000) {
1554 jjtree.clearNodeScope(jjtn000);
1555 jjtc000 = false;
1556 } else {
1557 jjtree.popNode();
1558 }
1559 if (jjte000 instanceof RuntimeException) {
1560 {if (true) throw (RuntimeException)jjte000;}
1561 }
1562 if (jjte000 instanceof ParseException) {
1563 {if (true) throw (ParseException)jjte000;}
1564 }
1565 {if (true) throw (Error)jjte000;}
1566 } finally {
1567 if (jjtc000) {
1568 jjtree.closeNodeScope(jjtn000, true);
1569 }
1570 }
1571 }
1572
1573 final public void MethodDeclarator() throws ParseException {
1574
1575 ASTMethodDeclarator jjtn000 = new ASTMethodDeclarator(this, JJTMETHODDECLARATOR);
1576 boolean jjtc000 = true;
1577 jjtree.openNodeScope(jjtn000);Token t;
1578 try {
1579 t = jj_consume_token(IDENTIFIER);
1580 checkForBadAssertUsage(t.image, "a method name");
1581 checkForBadEnumUsage(t.image, "a method name");
1582 jjtn000.setImage( t.image );
1583 FormalParameters();
1584 label_22:
1585 while (true) {
1586 switch (jj_nt.kind) {
1587 case LBRACKET:
1588 ;
1589 break;
1590 default:
1591 jj_la1[47] = jj_gen;
1592 break label_22;
1593 }
1594 jj_consume_token(LBRACKET);
1595 jj_consume_token(RBRACKET);
1596 }
1597 } catch (Throwable jjte000) {
1598 if (jjtc000) {
1599 jjtree.clearNodeScope(jjtn000);
1600 jjtc000 = false;
1601 } else {
1602 jjtree.popNode();
1603 }
1604 if (jjte000 instanceof RuntimeException) {
1605 {if (true) throw (RuntimeException)jjte000;}
1606 }
1607 if (jjte000 instanceof ParseException) {
1608 {if (true) throw (ParseException)jjte000;}
1609 }
1610 {if (true) throw (Error)jjte000;}
1611 } finally {
1612 if (jjtc000) {
1613 jjtree.closeNodeScope(jjtn000, true);
1614 }
1615 }
1616 }
1617
1618 final public void FormalParameters() throws ParseException {
1619
1620 ASTFormalParameters jjtn000 = new ASTFormalParameters(this, JJTFORMALPARAMETERS);
1621 boolean jjtc000 = true;
1622 jjtree.openNodeScope(jjtn000);
1623 try {
1624 jj_consume_token(LPAREN);
1625 switch (jj_nt.kind) {
1626 case BOOLEAN:
1627 case BYTE:
1628 case CHAR:
1629 case DOUBLE:
1630 case FINAL:
1631 case FLOAT:
1632 case INT:
1633 case LONG:
1634 case SHORT:
1635 case IDENTIFIER:
1636 case AT:
1637 FormalParameter();
1638 label_23:
1639 while (true) {
1640 switch (jj_nt.kind) {
1641 case COMMA:
1642 ;
1643 break;
1644 default:
1645 jj_la1[48] = jj_gen;
1646 break label_23;
1647 }
1648 jj_consume_token(COMMA);
1649 FormalParameter();
1650 }
1651 break;
1652 default:
1653 jj_la1[49] = jj_gen;
1654 ;
1655 }
1656 jj_consume_token(RPAREN);
1657 } catch (Throwable jjte000) {
1658 if (jjtc000) {
1659 jjtree.clearNodeScope(jjtn000);
1660 jjtc000 = false;
1661 } else {
1662 jjtree.popNode();
1663 }
1664 if (jjte000 instanceof RuntimeException) {
1665 {if (true) throw (RuntimeException)jjte000;}
1666 }
1667 if (jjte000 instanceof ParseException) {
1668 {if (true) throw (ParseException)jjte000;}
1669 }
1670 {if (true) throw (Error)jjte000;}
1671 } finally {
1672 if (jjtc000) {
1673 jjtree.closeNodeScope(jjtn000, true);
1674 }
1675 }
1676 }
1677
1678 final public void FormalParameter() throws ParseException {
1679
1680 ASTFormalParameter jjtn000 = new ASTFormalParameter(this, JJTFORMALPARAMETER);
1681 boolean jjtc000 = true;
1682 jjtree.openNodeScope(jjtn000);
1683 try {
1684 label_24:
1685 while (true) {
1686 switch (jj_nt.kind) {
1687 case FINAL:
1688 case AT:
1689 ;
1690 break;
1691 default:
1692 jj_la1[50] = jj_gen;
1693 break label_24;
1694 }
1695 switch (jj_nt.kind) {
1696 case FINAL:
1697 jj_consume_token(FINAL);
1698 jjtn000.setFinal(true);
1699 break;
1700 case AT:
1701 Annotation();
1702 break;
1703 default:
1704 jj_la1[51] = jj_gen;
1705 jj_consume_token(-1);
1706 throw new ParseException();
1707 }
1708 }
1709 Type();
1710 label_25:
1711 while (true) {
1712 switch (jj_nt.kind) {
1713 case BIT_OR:
1714 ;
1715 break;
1716 default:
1717 jj_la1[52] = jj_gen;
1718 break label_25;
1719 }
1720 jj_consume_token(BIT_OR);
1721 checkForBadMultipleExceptionsCatching();
1722 Type();
1723 }
1724 switch (jj_nt.kind) {
1725 case ELLIPSIS:
1726 jj_consume_token(ELLIPSIS);
1727 checkForBadVariableArgumentsUsage();
1728 jjtn000.setVarargs();
1729 break;
1730 default:
1731 jj_la1[53] = jj_gen;
1732 ;
1733 }
1734 VariableDeclaratorId();
1735 } catch (Throwable jjte000) {
1736 if (jjtc000) {
1737 jjtree.clearNodeScope(jjtn000);
1738 jjtc000 = false;
1739 } else {
1740 jjtree.popNode();
1741 }
1742 if (jjte000 instanceof RuntimeException) {
1743 {if (true) throw (RuntimeException)jjte000;}
1744 }
1745 if (jjte000 instanceof ParseException) {
1746 {if (true) throw (ParseException)jjte000;}
1747 }
1748 {if (true) throw (Error)jjte000;}
1749 } finally {
1750 if (jjtc000) {
1751 jjtree.closeNodeScope(jjtn000, true);
1752 }
1753 }
1754 }
1755
1756 final public void ConstructorDeclaration(int modifiers) throws ParseException {
1757
1758 ASTConstructorDeclaration jjtn000 = new ASTConstructorDeclaration(this, JJTCONSTRUCTORDECLARATION);
1759 boolean jjtc000 = true;
1760 jjtree.openNodeScope(jjtn000);jjtn000.setModifiers(modifiers);
1761 Token t;
1762 try {
1763 switch (jj_nt.kind) {
1764 case LT:
1765 TypeParameters();
1766 break;
1767 default:
1768 jj_la1[54] = jj_gen;
1769 ;
1770 }
1771 jj_consume_token(IDENTIFIER);
1772 FormalParameters();
1773 switch (jj_nt.kind) {
1774 case THROWS:
1775 jj_consume_token(THROWS);
1776 NameList();
1777 break;
1778 default:
1779 jj_la1[55] = jj_gen;
1780 ;
1781 }
1782 jj_consume_token(LBRACE);
1783 if (jj_2_10(2147483647)) {
1784 ExplicitConstructorInvocation();
1785 } else {
1786 ;
1787 }
1788 label_26:
1789 while (true) {
1790 if (jj_2_11(1)) {
1791 ;
1792 } else {
1793 break label_26;
1794 }
1795 BlockStatement();
1796 }
1797 t = jj_consume_token(RBRACE);
1798 jjtree.closeNodeScope(jjtn000, true);
1799 jjtc000 = false;
1800 if (isPrecededByComment(t)) { jjtn000.setContainsComment(); }
1801 } catch (Throwable jjte000) {
1802 if (jjtc000) {
1803 jjtree.clearNodeScope(jjtn000);
1804 jjtc000 = false;
1805 } else {
1806 jjtree.popNode();
1807 }
1808 if (jjte000 instanceof RuntimeException) {
1809 {if (true) throw (RuntimeException)jjte000;}
1810 }
1811 if (jjte000 instanceof ParseException) {
1812 {if (true) throw (ParseException)jjte000;}
1813 }
1814 {if (true) throw (Error)jjte000;}
1815 } finally {
1816 if (jjtc000) {
1817 jjtree.closeNodeScope(jjtn000, true);
1818 }
1819 }
1820 }
1821
1822 final public void ExplicitConstructorInvocation() throws ParseException {
1823
1824 ASTExplicitConstructorInvocation jjtn000 = new ASTExplicitConstructorInvocation(this, JJTEXPLICITCONSTRUCTORINVOCATION);
1825 boolean jjtc000 = true;
1826 jjtree.openNodeScope(jjtn000);
1827 try {
1828 if (jj_2_13(2147483647)) {
1829 jj_consume_token(THIS);
1830 jjtn000.setIsThis();
1831 Arguments();
1832 jj_consume_token(SEMICOLON);
1833 } else if (jj_2_14(2147483647)) {
1834 TypeArguments();
1835 jj_consume_token(THIS);
1836 jjtn000.setIsThis();
1837 Arguments();
1838 jj_consume_token(SEMICOLON);
1839 } else {
1840 switch (jj_nt.kind) {
1841 case BOOLEAN:
1842 case BYTE:
1843 case CHAR:
1844 case DOUBLE:
1845 case FALSE:
1846 case FLOAT:
1847 case INT:
1848 case LONG:
1849 case NEW:
1850 case NULL:
1851 case SHORT:
1852 case SUPER:
1853 case THIS:
1854 case TRUE:
1855 case VOID:
1856 case INTEGER_LITERAL:
1857 case FLOATING_POINT_LITERAL:
1858 case HEX_FLOATING_POINT_LITERAL:
1859 case CHARACTER_LITERAL:
1860 case STRING_LITERAL:
1861 case IDENTIFIER:
1862 case LPAREN:
1863 case LT:
1864 if (jj_2_12(2147483647)) {
1865 PrimaryExpression();
1866 jj_consume_token(DOT);
1867 } else {
1868 ;
1869 }
1870 switch (jj_nt.kind) {
1871 case LT:
1872 TypeArguments();
1873 break;
1874 default:
1875 jj_la1[56] = jj_gen;
1876 ;
1877 }
1878 jj_consume_token(SUPER);
1879 jjtn000.setIsSuper();
1880 Arguments();
1881 jj_consume_token(SEMICOLON);
1882 break;
1883 default:
1884 jj_la1[57] = jj_gen;
1885 jj_consume_token(-1);
1886 throw new ParseException();
1887 }
1888 }
1889 } catch (Throwable jjte000) {
1890 if (jjtc000) {
1891 jjtree.clearNodeScope(jjtn000);
1892 jjtc000 = false;
1893 } else {
1894 jjtree.popNode();
1895 }
1896 if (jjte000 instanceof RuntimeException) {
1897 {if (true) throw (RuntimeException)jjte000;}
1898 }
1899 if (jjte000 instanceof ParseException) {
1900 {if (true) throw (ParseException)jjte000;}
1901 }
1902 {if (true) throw (Error)jjte000;}
1903 } finally {
1904 if (jjtc000) {
1905 jjtree.closeNodeScope(jjtn000, true);
1906 }
1907 }
1908 }
1909
1910 final public void Initializer() throws ParseException {
1911
1912 ASTInitializer jjtn000 = new ASTInitializer(this, JJTINITIALIZER);
1913 boolean jjtc000 = true;
1914 jjtree.openNodeScope(jjtn000);
1915 try {
1916 switch (jj_nt.kind) {
1917 case STATIC:
1918 jj_consume_token(STATIC);
1919 jjtn000.setStatic();
1920 break;
1921 default:
1922 jj_la1[58] = jj_gen;
1923 ;
1924 }
1925 Block();
1926 } catch (Throwable jjte000) {
1927 if (jjtc000) {
1928 jjtree.clearNodeScope(jjtn000);
1929 jjtc000 = false;
1930 } else {
1931 jjtree.popNode();
1932 }
1933 if (jjte000 instanceof RuntimeException) {
1934 {if (true) throw (RuntimeException)jjte000;}
1935 }
1936 if (jjte000 instanceof ParseException) {
1937 {if (true) throw (ParseException)jjte000;}
1938 }
1939 {if (true) throw (Error)jjte000;}
1940 } finally {
1941 if (jjtc000) {
1942 jjtree.closeNodeScope(jjtn000, true);
1943 }
1944 }
1945 }
1946
1947
1948
1949
1950 final public void Type() throws ParseException {
1951
1952 ASTType jjtn000 = new ASTType(this, JJTTYPE);
1953 boolean jjtc000 = true;
1954 jjtree.openNodeScope(jjtn000);
1955 try {
1956 if (jj_2_15(2)) {
1957 ReferenceType();
1958 } else {
1959 switch (jj_nt.kind) {
1960 case BOOLEAN:
1961 case BYTE:
1962 case CHAR:
1963 case DOUBLE:
1964 case FLOAT:
1965 case INT:
1966 case LONG:
1967 case SHORT:
1968 PrimitiveType();
1969 break;
1970 default:
1971 jj_la1[59] = jj_gen;
1972 jj_consume_token(-1);
1973 throw new ParseException();
1974 }
1975 }
1976 } catch (Throwable jjte000) {
1977 if (jjtc000) {
1978 jjtree.clearNodeScope(jjtn000);
1979 jjtc000 = false;
1980 } else {
1981 jjtree.popNode();
1982 }
1983 if (jjte000 instanceof RuntimeException) {
1984 {if (true) throw (RuntimeException)jjte000;}
1985 }
1986 if (jjte000 instanceof ParseException) {
1987 {if (true) throw (ParseException)jjte000;}
1988 }
1989 {if (true) throw (Error)jjte000;}
1990 } finally {
1991 if (jjtc000) {
1992 jjtree.closeNodeScope(jjtn000, true);
1993 }
1994 }
1995 }
1996
1997 final public void ReferenceType() throws ParseException {
1998
1999 ASTReferenceType jjtn000 = new ASTReferenceType(this, JJTREFERENCETYPE);
2000 boolean jjtc000 = true;
2001 jjtree.openNodeScope(jjtn000);
2002 try {
2003 switch (jj_nt.kind) {
2004 case BOOLEAN:
2005 case BYTE:
2006 case CHAR:
2007 case DOUBLE:
2008 case FLOAT:
2009 case INT:
2010 case LONG:
2011 case SHORT:
2012 PrimitiveType();
2013 label_27:
2014 while (true) {
2015 jj_consume_token(LBRACKET);
2016 jj_consume_token(RBRACKET);
2017 jjtn000.bumpArrayDepth();
2018 if (jj_2_16(2)) {
2019 ;
2020 } else {
2021 break label_27;
2022 }
2023 }
2024 break;
2025 case IDENTIFIER:
2026 ClassOrInterfaceType();
2027 label_28:
2028 while (true) {
2029 if (jj_2_17(2)) {
2030 ;
2031 } else {
2032 break label_28;
2033 }
2034 jj_consume_token(LBRACKET);
2035 jj_consume_token(RBRACKET);
2036 jjtn000.bumpArrayDepth();
2037 }
2038 break;
2039 default:
2040 jj_la1[60] = jj_gen;
2041 jj_consume_token(-1);
2042 throw new ParseException();
2043 }
2044 } catch (Throwable jjte000) {
2045 if (jjtc000) {
2046 jjtree.clearNodeScope(jjtn000);
2047 jjtc000 = false;
2048 } else {
2049 jjtree.popNode();
2050 }
2051 if (jjte000 instanceof RuntimeException) {
2052 {if (true) throw (RuntimeException)jjte000;}
2053 }
2054 if (jjte000 instanceof ParseException) {
2055 {if (true) throw (ParseException)jjte000;}
2056 }
2057 {if (true) throw (Error)jjte000;}
2058 } finally {
2059 if (jjtc000) {
2060 jjtree.closeNodeScope(jjtn000, true);
2061 }
2062 }
2063 }
2064
2065 final public void ClassOrInterfaceType() throws ParseException {
2066
2067 ASTClassOrInterfaceType jjtn000 = new ASTClassOrInterfaceType(this, JJTCLASSORINTERFACETYPE);
2068 boolean jjtc000 = true;
2069 jjtree.openNodeScope(jjtn000);StringBuffer s = new StringBuffer();
2070 Token t;
2071 try {
2072 t = jj_consume_token(IDENTIFIER);
2073 s.append(t.image);
2074 if (jj_2_18(2)) {
2075 TypeArguments();
2076 } else {
2077 ;
2078 }
2079 label_29:
2080 while (true) {
2081 if (jj_2_19(2)) {
2082 ;
2083 } else {
2084 break label_29;
2085 }
2086 jj_consume_token(DOT);
2087 t = jj_consume_token(IDENTIFIER);
2088 s.append('.').append(t.image);
2089 if (jj_2_20(2)) {
2090 TypeArguments();
2091 } else {
2092 ;
2093 }
2094 }
2095 jjtree.closeNodeScope(jjtn000, true);
2096 jjtc000 = false;
2097 jjtn000.setImage(s.toString());
2098 } catch (Throwable jjte000) {
2099 if (jjtc000) {
2100 jjtree.clearNodeScope(jjtn000);
2101 jjtc000 = false;
2102 } else {
2103 jjtree.popNode();
2104 }
2105 if (jjte000 instanceof RuntimeException) {
2106 {if (true) throw (RuntimeException)jjte000;}
2107 }
2108 if (jjte000 instanceof ParseException) {
2109 {if (true) throw (ParseException)jjte000;}
2110 }
2111 {if (true) throw (Error)jjte000;}
2112 } finally {
2113 if (jjtc000) {
2114 jjtree.closeNodeScope(jjtn000, true);
2115 }
2116 }
2117 }
2118
2119 final public void TypeArguments() throws ParseException {
2120
2121 ASTTypeArguments jjtn000 = new ASTTypeArguments(this, JJTTYPEARGUMENTS);
2122 boolean jjtc000 = true;
2123 jjtree.openNodeScope(jjtn000);
2124 try {
2125 if (jj_2_21(2)) {
2126 jj_consume_token(LT);
2127 checkForBadGenericsUsage();
2128 TypeArgument();
2129 label_30:
2130 while (true) {
2131 switch (jj_nt.kind) {
2132 case COMMA:
2133 ;
2134 break;
2135 default:
2136 jj_la1[61] = jj_gen;
2137 break label_30;
2138 }
2139 jj_consume_token(COMMA);
2140 TypeArgument();
2141 }
2142 jj_consume_token(GT);
2143 } else {
2144 switch (jj_nt.kind) {
2145 case LT:
2146 jj_consume_token(LT);
2147 checkForBadDiamondUsage();
2148 jj_consume_token(GT);
2149 break;
2150 default:
2151 jj_la1[62] = jj_gen;
2152 jj_consume_token(-1);
2153 throw new ParseException();
2154 }
2155 }
2156 } catch (Throwable jjte000) {
2157 if (jjtc000) {
2158 jjtree.clearNodeScope(jjtn000);
2159 jjtc000 = false;
2160 } else {
2161 jjtree.popNode();
2162 }
2163 if (jjte000 instanceof RuntimeException) {
2164 {if (true) throw (RuntimeException)jjte000;}
2165 }
2166 if (jjte000 instanceof ParseException) {
2167 {if (true) throw (ParseException)jjte000;}
2168 }
2169 {if (true) throw (Error)jjte000;}
2170 } finally {
2171 if (jjtc000) {
2172 jjtree.closeNodeScope(jjtn000, true);
2173 }
2174 }
2175 }
2176
2177 final public void TypeArgument() throws ParseException {
2178
2179 ASTTypeArgument jjtn000 = new ASTTypeArgument(this, JJTTYPEARGUMENT);
2180 boolean jjtc000 = true;
2181 jjtree.openNodeScope(jjtn000);
2182 try {
2183 switch (jj_nt.kind) {
2184 case BOOLEAN:
2185 case BYTE:
2186 case CHAR:
2187 case DOUBLE:
2188 case FLOAT:
2189 case INT:
2190 case LONG:
2191 case SHORT:
2192 case IDENTIFIER:
2193 case AT:
2194 label_31:
2195 while (true) {
2196 switch (jj_nt.kind) {
2197 case AT:
2198 ;
2199 break;
2200 default:
2201 jj_la1[63] = jj_gen;
2202 break label_31;
2203 }
2204 Annotation();
2205 checkForBadTypeAnnotations();
2206 }
2207 ReferenceType();
2208 break;
2209 case HOOK:
2210 jj_consume_token(HOOK);
2211 switch (jj_nt.kind) {
2212 case EXTENDS:
2213 case SUPER:
2214 WildcardBounds();
2215 break;
2216 default:
2217 jj_la1[64] = jj_gen;
2218 ;
2219 }
2220 break;
2221 default:
2222 jj_la1[65] = jj_gen;
2223 jj_consume_token(-1);
2224 throw new ParseException();
2225 }
2226 } catch (Throwable jjte000) {
2227 if (jjtc000) {
2228 jjtree.clearNodeScope(jjtn000);
2229 jjtc000 = false;
2230 } else {
2231 jjtree.popNode();
2232 }
2233 if (jjte000 instanceof RuntimeException) {
2234 {if (true) throw (RuntimeException)jjte000;}
2235 }
2236 if (jjte000 instanceof ParseException) {
2237 {if (true) throw (ParseException)jjte000;}
2238 }
2239 {if (true) throw (Error)jjte000;}
2240 } finally {
2241 if (jjtc000) {
2242 jjtree.closeNodeScope(jjtn000, true);
2243 }
2244 }
2245 }
2246
2247 final public void WildcardBounds() throws ParseException {
2248
2249 ASTWildcardBounds jjtn000 = new ASTWildcardBounds(this, JJTWILDCARDBOUNDS);
2250 boolean jjtc000 = true;
2251 jjtree.openNodeScope(jjtn000);
2252 try {
2253 switch (jj_nt.kind) {
2254 case EXTENDS:
2255 jj_consume_token(EXTENDS);
2256 label_32:
2257 while (true) {
2258 switch (jj_nt.kind) {
2259 case AT:
2260 ;
2261 break;
2262 default:
2263 jj_la1[66] = jj_gen;
2264 break label_32;
2265 }
2266 Annotation();
2267 checkForBadTypeAnnotations();
2268 }
2269 ReferenceType();
2270 break;
2271 case SUPER:
2272 jj_consume_token(SUPER);
2273 label_33:
2274 while (true) {
2275 switch (jj_nt.kind) {
2276 case AT:
2277 ;
2278 break;
2279 default:
2280 jj_la1[67] = jj_gen;
2281 break label_33;
2282 }
2283 Annotation();
2284 checkForBadTypeAnnotations();
2285 }
2286 ReferenceType();
2287 break;
2288 default:
2289 jj_la1[68] = jj_gen;
2290 jj_consume_token(-1);
2291 throw new ParseException();
2292 }
2293 } catch (Throwable jjte000) {
2294 if (jjtc000) {
2295 jjtree.clearNodeScope(jjtn000);
2296 jjtc000 = false;
2297 } else {
2298 jjtree.popNode();
2299 }
2300 if (jjte000 instanceof RuntimeException) {
2301 {if (true) throw (RuntimeException)jjte000;}
2302 }
2303 if (jjte000 instanceof ParseException) {
2304 {if (true) throw (ParseException)jjte000;}
2305 }
2306 {if (true) throw (Error)jjte000;}
2307 } finally {
2308 if (jjtc000) {
2309 jjtree.closeNodeScope(jjtn000, true);
2310 }
2311 }
2312 }
2313
2314 final public void PrimitiveType() throws ParseException {
2315
2316 ASTPrimitiveType jjtn000 = new ASTPrimitiveType(this, JJTPRIMITIVETYPE);
2317 boolean jjtc000 = true;
2318 jjtree.openNodeScope(jjtn000);
2319 try {
2320 switch (jj_nt.kind) {
2321 case BOOLEAN:
2322 jj_consume_token(BOOLEAN);
2323 jjtree.closeNodeScope(jjtn000, true);
2324 jjtc000 = false;
2325 jjtn000.setImage("boolean");
2326 break;
2327 case CHAR:
2328 jj_consume_token(CHAR);
2329 jjtree.closeNodeScope(jjtn000, true);
2330 jjtc000 = false;
2331 jjtn000.setImage("char");
2332 break;
2333 case BYTE:
2334 jj_consume_token(BYTE);
2335 jjtree.closeNodeScope(jjtn000, true);
2336 jjtc000 = false;
2337 jjtn000.setImage("byte");
2338 break;
2339 case SHORT:
2340 jj_consume_token(SHORT);
2341 jjtree.closeNodeScope(jjtn000, true);
2342 jjtc000 = false;
2343 jjtn000.setImage("short");
2344 break;
2345 case INT:
2346 jj_consume_token(INT);
2347 jjtree.closeNodeScope(jjtn000, true);
2348 jjtc000 = false;
2349 jjtn000.setImage("int");
2350 break;
2351 case LONG:
2352 jj_consume_token(LONG);
2353 jjtree.closeNodeScope(jjtn000, true);
2354 jjtc000 = false;
2355 jjtn000.setImage("long");
2356 break;
2357 case FLOAT:
2358 jj_consume_token(FLOAT);
2359 jjtree.closeNodeScope(jjtn000, true);
2360 jjtc000 = false;
2361 jjtn000.setImage("float");
2362 break;
2363 case DOUBLE:
2364 jj_consume_token(DOUBLE);
2365 jjtree.closeNodeScope(jjtn000, true);
2366 jjtc000 = false;
2367 jjtn000.setImage("double");
2368 break;
2369 default:
2370 jj_la1[69] = jj_gen;
2371 jj_consume_token(-1);
2372 throw new ParseException();
2373 }
2374 } finally {
2375 if (jjtc000) {
2376 jjtree.closeNodeScope(jjtn000, true);
2377 }
2378 }
2379 }
2380
2381 final public void ResultType() throws ParseException {
2382
2383 ASTResultType jjtn000 = new ASTResultType(this, JJTRESULTTYPE);
2384 boolean jjtc000 = true;
2385 jjtree.openNodeScope(jjtn000);
2386 try {
2387 switch (jj_nt.kind) {
2388 case VOID:
2389 jj_consume_token(VOID);
2390 break;
2391 case BOOLEAN:
2392 case BYTE:
2393 case CHAR:
2394 case DOUBLE:
2395 case FLOAT:
2396 case INT:
2397 case LONG:
2398 case SHORT:
2399 case IDENTIFIER:
2400 Type();
2401 break;
2402 default:
2403 jj_la1[70] = jj_gen;
2404 jj_consume_token(-1);
2405 throw new ParseException();
2406 }
2407 } catch (Throwable jjte000) {
2408 if (jjtc000) {
2409 jjtree.clearNodeScope(jjtn000);
2410 jjtc000 = false;
2411 } else {
2412 jjtree.popNode();
2413 }
2414 if (jjte000 instanceof RuntimeException) {
2415 {if (true) throw (RuntimeException)jjte000;}
2416 }
2417 if (jjte000 instanceof ParseException) {
2418 {if (true) throw (ParseException)jjte000;}
2419 }
2420 {if (true) throw (Error)jjte000;}
2421 } finally {
2422 if (jjtc000) {
2423 jjtree.closeNodeScope(jjtn000, true);
2424 }
2425 }
2426 }
2427
2428 final public void Name() throws ParseException {
2429
2430 ASTName jjtn000 = new ASTName(this, JJTNAME);
2431 boolean jjtc000 = true;
2432 jjtree.openNodeScope(jjtn000);StringBuffer s = new StringBuffer();
2433 Token t;
2434 try {
2435 t = jj_consume_token(IDENTIFIER);
2436 jjtn000.testingOnly__setBeginLine( t.beginLine);
2437 jjtn000.testingOnly__setBeginColumn( t.beginColumn);
2438 s.append(t.image);
2439 label_34:
2440 while (true) {
2441 if (jj_2_22(2)) {
2442 ;
2443 } else {
2444 break label_34;
2445 }
2446 jj_consume_token(DOT);
2447 t = jj_consume_token(IDENTIFIER);
2448 s.append('.').append(t.image);
2449 }
2450 jjtree.closeNodeScope(jjtn000, true);
2451 jjtc000 = false;
2452 jjtn000.setImage(s.toString());
2453 } finally {
2454 if (jjtc000) {
2455 jjtree.closeNodeScope(jjtn000, true);
2456 }
2457 }
2458 }
2459
2460 final public void NameList() throws ParseException {
2461
2462 ASTNameList jjtn000 = new ASTNameList(this, JJTNAMELIST);
2463 boolean jjtc000 = true;
2464 jjtree.openNodeScope(jjtn000);
2465 try {
2466 label_35:
2467 while (true) {
2468 switch (jj_nt.kind) {
2469 case AT:
2470 ;
2471 break;
2472 default:
2473 jj_la1[71] = jj_gen;
2474 break label_35;
2475 }
2476 Annotation();
2477 checkForBadTypeAnnotations();
2478 }
2479 Name();
2480 label_36:
2481 while (true) {
2482 switch (jj_nt.kind) {
2483 case COMMA:
2484 ;
2485 break;
2486 default:
2487 jj_la1[72] = jj_gen;
2488 break label_36;
2489 }
2490 jj_consume_token(COMMA);
2491 label_37:
2492 while (true) {
2493 switch (jj_nt.kind) {
2494 case AT:
2495 ;
2496 break;
2497 default:
2498 jj_la1[73] = jj_gen;
2499 break label_37;
2500 }
2501 Annotation();
2502 checkForBadTypeAnnotations();
2503 }
2504 Name();
2505 }
2506 } catch (Throwable jjte000) {
2507 if (jjtc000) {
2508 jjtree.clearNodeScope(jjtn000);
2509 jjtc000 = false;
2510 } else {
2511 jjtree.popNode();
2512 }
2513 if (jjte000 instanceof RuntimeException) {
2514 {if (true) throw (RuntimeException)jjte000;}
2515 }
2516 if (jjte000 instanceof ParseException) {
2517 {if (true) throw (ParseException)jjte000;}
2518 }
2519 {if (true) throw (Error)jjte000;}
2520 } finally {
2521 if (jjtc000) {
2522 jjtree.closeNodeScope(jjtn000, true);
2523 }
2524 }
2525 }
2526
2527
2528
2529
2530 final public void Expression() throws ParseException {
2531
2532 ASTExpression jjtn000 = new ASTExpression(this, JJTEXPRESSION);
2533 boolean jjtc000 = true;
2534 jjtree.openNodeScope(jjtn000);
2535 try {
2536 ConditionalExpression();
2537 if (jj_2_23(2)) {
2538 AssignmentOperator();
2539 Expression();
2540 } else {
2541 ;
2542 }
2543 } catch (Throwable jjte000) {
2544 if (jjtc000) {
2545 jjtree.clearNodeScope(jjtn000);
2546 jjtc000 = false;
2547 } else {
2548 jjtree.popNode();
2549 }
2550 if (jjte000 instanceof RuntimeException) {
2551 {if (true) throw (RuntimeException)jjte000;}
2552 }
2553 if (jjte000 instanceof ParseException) {
2554 {if (true) throw (ParseException)jjte000;}
2555 }
2556 {if (true) throw (Error)jjte000;}
2557 } finally {
2558 if (jjtc000) {
2559 jjtree.closeNodeScope(jjtn000, true);
2560 }
2561 }
2562 }
2563
2564 final public void AssignmentOperator() throws ParseException {
2565
2566 ASTAssignmentOperator jjtn000 = new ASTAssignmentOperator(this, JJTASSIGNMENTOPERATOR);
2567 boolean jjtc000 = true;
2568 jjtree.openNodeScope(jjtn000);
2569 try {
2570 switch (jj_nt.kind) {
2571 case ASSIGN:
2572 jj_consume_token(ASSIGN);
2573 jjtree.closeNodeScope(jjtn000, true);
2574 jjtc000 = false;
2575 jjtn000.setImage("=");
2576 break;
2577 case STARASSIGN:
2578 jj_consume_token(STARASSIGN);
2579 jjtree.closeNodeScope(jjtn000, true);
2580 jjtc000 = false;
2581 jjtn000.setImage("*="); jjtn000.setCompound();
2582 break;
2583 case SLASHASSIGN:
2584 jj_consume_token(SLASHASSIGN);
2585 jjtree.closeNodeScope(jjtn000, true);
2586 jjtc000 = false;
2587 jjtn000.setImage("/="); jjtn000.setCompound();
2588 break;
2589 case REMASSIGN:
2590 jj_consume_token(REMASSIGN);
2591 jjtree.closeNodeScope(jjtn000, true);
2592 jjtc000 = false;
2593 jjtn000.setImage("%="); jjtn000.setCompound();
2594 break;
2595 case PLUSASSIGN:
2596 jj_consume_token(PLUSASSIGN);
2597 jjtree.closeNodeScope(jjtn000, true);
2598 jjtc000 = false;
2599 jjtn000.setImage("+="); jjtn000.setCompound();
2600 break;
2601 case MINUSASSIGN:
2602 jj_consume_token(MINUSASSIGN);
2603 jjtree.closeNodeScope(jjtn000, true);
2604 jjtc000 = false;
2605 jjtn000.setImage("-="); jjtn000.setCompound();
2606 break;
2607 case LSHIFTASSIGN:
2608 jj_consume_token(LSHIFTASSIGN);
2609 jjtree.closeNodeScope(jjtn000, true);
2610 jjtc000 = false;
2611 jjtn000.setImage("<<="); jjtn000.setCompound();
2612 break;
2613 case RSIGNEDSHIFTASSIGN:
2614 jj_consume_token(RSIGNEDSHIFTASSIGN);
2615 jjtree.closeNodeScope(jjtn000, true);
2616 jjtc000 = false;
2617 jjtn000.setImage(">>="); jjtn000.setCompound();
2618 break;
2619 case RUNSIGNEDSHIFTASSIGN:
2620 jj_consume_token(RUNSIGNEDSHIFTASSIGN);
2621 jjtree.closeNodeScope(jjtn000, true);
2622 jjtc000 = false;
2623 jjtn000.setImage(">>>="); jjtn000.setCompound();
2624 break;
2625 case ANDASSIGN:
2626 jj_consume_token(ANDASSIGN);
2627 jjtree.closeNodeScope(jjtn000, true);
2628 jjtc000 = false;
2629 jjtn000.setImage("&="); jjtn000.setCompound();
2630 break;
2631 case XORASSIGN:
2632 jj_consume_token(XORASSIGN);
2633 jjtree.closeNodeScope(jjtn000, true);
2634 jjtc000 = false;
2635 jjtn000.setImage("^="); jjtn000.setCompound();
2636 break;
2637 case ORASSIGN:
2638 jj_consume_token(ORASSIGN);
2639 jjtree.closeNodeScope(jjtn000, true);
2640 jjtc000 = false;
2641 jjtn000.setImage("|="); jjtn000.setCompound();
2642 break;
2643 default:
2644 jj_la1[74] = jj_gen;
2645 jj_consume_token(-1);
2646 throw new ParseException();
2647 }
2648 } finally {
2649 if (jjtc000) {
2650 jjtree.closeNodeScope(jjtn000, true);
2651 }
2652 }
2653 }
2654
2655 final public void ConditionalExpression() throws ParseException {
2656
2657 ASTConditionalExpression jjtn000 = new ASTConditionalExpression(this, JJTCONDITIONALEXPRESSION);
2658 boolean jjtc000 = true;
2659 jjtree.openNodeScope(jjtn000);
2660 try {
2661 ConditionalOrExpression();
2662 if (jj_2_24(2)) {
2663 jj_consume_token(HOOK);
2664 jjtn000.setTernary();
2665 Expression();
2666 jj_consume_token(COLON);
2667 ConditionalExpression();
2668 } else {
2669 ;
2670 }
2671 } catch (Throwable jjte000) {
2672 if (jjtc000) {
2673 jjtree.clearNodeScope(jjtn000);
2674 jjtc000 = false;
2675 } else {
2676 jjtree.popNode();
2677 }
2678 if (jjte000 instanceof RuntimeException) {
2679 {if (true) throw (RuntimeException)jjte000;}
2680 }
2681 if (jjte000 instanceof ParseException) {
2682 {if (true) throw (ParseException)jjte000;}
2683 }
2684 {if (true) throw (Error)jjte000;}
2685 } finally {
2686 if (jjtc000) {
2687 jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
2688 }
2689 }
2690 }
2691
2692 final public void ConditionalOrExpression() throws ParseException {
2693
2694 ASTConditionalOrExpression jjtn000 = new ASTConditionalOrExpression(this, JJTCONDITIONALOREXPRESSION);
2695 boolean jjtc000 = true;
2696 jjtree.openNodeScope(jjtn000);
2697 try {
2698 ConditionalAndExpression();
2699 label_38:
2700 while (true) {
2701 if (jj_2_25(2)) {
2702 ;
2703 } else {
2704 break label_38;
2705 }
2706 jj_consume_token(SC_OR);
2707 ConditionalAndExpression();
2708 }
2709 } catch (Throwable jjte000) {
2710 if (jjtc000) {
2711 jjtree.clearNodeScope(jjtn000);
2712 jjtc000 = false;
2713 } else {
2714 jjtree.popNode();
2715 }
2716 if (jjte000 instanceof RuntimeException) {
2717 {if (true) throw (RuntimeException)jjte000;}
2718 }
2719 if (jjte000 instanceof ParseException) {
2720 {if (true) throw (ParseException)jjte000;}
2721 }
2722 {if (true) throw (Error)jjte000;}
2723 } finally {
2724 if (jjtc000) {
2725 jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
2726 }
2727 }
2728 }
2729
2730 final public void ConditionalAndExpression() throws ParseException {
2731
2732 ASTConditionalAndExpression jjtn000 = new ASTConditionalAndExpression(this, JJTCONDITIONALANDEXPRESSION);
2733 boolean jjtc000 = true;
2734 jjtree.openNodeScope(jjtn000);
2735 try {
2736 InclusiveOrExpression();
2737 label_39:
2738 while (true) {
2739 if (jj_2_26(2)) {
2740 ;
2741 } else {
2742 break label_39;
2743 }
2744 jj_consume_token(SC_AND);
2745 InclusiveOrExpression();
2746 }
2747 } catch (Throwable jjte000) {
2748 if (jjtc000) {
2749 jjtree.clearNodeScope(jjtn000);
2750 jjtc000 = false;
2751 } else {
2752 jjtree.popNode();
2753 }
2754 if (jjte000 instanceof RuntimeException) {
2755 {if (true) throw (RuntimeException)jjte000;}
2756 }
2757 if (jjte000 instanceof ParseException) {
2758 {if (true) throw (ParseException)jjte000;}
2759 }
2760 {if (true) throw (Error)jjte000;}
2761 } finally {
2762 if (jjtc000) {
2763 jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
2764 }
2765 }
2766 }
2767
2768 final public void InclusiveOrExpression() throws ParseException {
2769
2770 ASTInclusiveOrExpression jjtn000 = new ASTInclusiveOrExpression(this, JJTINCLUSIVEOREXPRESSION);
2771 boolean jjtc000 = true;
2772 jjtree.openNodeScope(jjtn000);
2773 try {
2774 ExclusiveOrExpression();
2775 label_40:
2776 while (true) {
2777 if (jj_2_27(2)) {
2778 ;
2779 } else {
2780 break label_40;
2781 }
2782 jj_consume_token(BIT_OR);
2783 ExclusiveOrExpression();
2784 }
2785 } catch (Throwable jjte000) {
2786 if (jjtc000) {
2787 jjtree.clearNodeScope(jjtn000);
2788 jjtc000 = false;
2789 } else {
2790 jjtree.popNode();
2791 }
2792 if (jjte000 instanceof RuntimeException) {
2793 {if (true) throw (RuntimeException)jjte000;}
2794 }
2795 if (jjte000 instanceof ParseException) {
2796 {if (true) throw (ParseException)jjte000;}
2797 }
2798 {if (true) throw (Error)jjte000;}
2799 } finally {
2800 if (jjtc000) {
2801 jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
2802 }
2803 }
2804 }
2805
2806 final public void ExclusiveOrExpression() throws ParseException {
2807
2808 ASTExclusiveOrExpression jjtn000 = new ASTExclusiveOrExpression(this, JJTEXCLUSIVEOREXPRESSION);
2809 boolean jjtc000 = true;
2810 jjtree.openNodeScope(jjtn000);
2811 try {
2812 AndExpression();
2813 label_41:
2814 while (true) {
2815 if (jj_2_28(2)) {
2816 ;
2817 } else {
2818 break label_41;
2819 }
2820 jj_consume_token(XOR);
2821 AndExpression();
2822 }
2823 } catch (Throwable jjte000) {
2824 if (jjtc000) {
2825 jjtree.clearNodeScope(jjtn000);
2826 jjtc000 = false;
2827 } else {
2828 jjtree.popNode();
2829 }
2830 if (jjte000 instanceof RuntimeException) {
2831 {if (true) throw (RuntimeException)jjte000;}
2832 }
2833 if (jjte000 instanceof ParseException) {
2834 {if (true) throw (ParseException)jjte000;}
2835 }
2836 {if (true) throw (Error)jjte000;}
2837 } finally {
2838 if (jjtc000) {
2839 jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
2840 }
2841 }
2842 }
2843
2844 final public void AndExpression() throws ParseException {
2845
2846 ASTAndExpression jjtn000 = new ASTAndExpression(this, JJTANDEXPRESSION);
2847 boolean jjtc000 = true;
2848 jjtree.openNodeScope(jjtn000);
2849 try {
2850 EqualityExpression();
2851 label_42:
2852 while (true) {
2853 if (jj_2_29(2)) {
2854 ;
2855 } else {
2856 break label_42;
2857 }
2858 jj_consume_token(BIT_AND);
2859 EqualityExpression();
2860 }
2861 } catch (Throwable jjte000) {
2862 if (jjtc000) {
2863 jjtree.clearNodeScope(jjtn000);
2864 jjtc000 = false;
2865 } else {
2866 jjtree.popNode();
2867 }
2868 if (jjte000 instanceof RuntimeException) {
2869 {if (true) throw (RuntimeException)jjte000;}
2870 }
2871 if (jjte000 instanceof ParseException) {
2872 {if (true) throw (ParseException)jjte000;}
2873 }
2874 {if (true) throw (Error)jjte000;}
2875 } finally {
2876 if (jjtc000) {
2877 jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
2878 }
2879 }
2880 }
2881
2882 final public void EqualityExpression() throws ParseException {
2883
2884 ASTEqualityExpression jjtn000 = new ASTEqualityExpression(this, JJTEQUALITYEXPRESSION);
2885 boolean jjtc000 = true;
2886 jjtree.openNodeScope(jjtn000);
2887 try {
2888 InstanceOfExpression();
2889 label_43:
2890 while (true) {
2891 if (jj_2_30(2)) {
2892 ;
2893 } else {
2894 break label_43;
2895 }
2896 switch (jj_nt.kind) {
2897 case EQ:
2898 jj_consume_token(EQ);
2899 jjtn000.setImage("==");
2900 break;
2901 case NE:
2902 jj_consume_token(NE);
2903 jjtn000.setImage("!=");
2904 break;
2905 default:
2906 jj_la1[75] = jj_gen;
2907 jj_consume_token(-1);
2908 throw new ParseException();
2909 }
2910 InstanceOfExpression();
2911 }
2912 } catch (Throwable jjte000) {
2913 if (jjtc000) {
2914 jjtree.clearNodeScope(jjtn000);
2915 jjtc000 = false;
2916 } else {
2917 jjtree.popNode();
2918 }
2919 if (jjte000 instanceof RuntimeException) {
2920 {if (true) throw (RuntimeException)jjte000;}
2921 }
2922 if (jjte000 instanceof ParseException) {
2923 {if (true) throw (ParseException)jjte000;}
2924 }
2925 {if (true) throw (Error)jjte000;}
2926 } finally {
2927 if (jjtc000) {
2928 jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
2929 }
2930 }
2931 }
2932
2933 final public void InstanceOfExpression() throws ParseException {
2934
2935 ASTInstanceOfExpression jjtn000 = new ASTInstanceOfExpression(this, JJTINSTANCEOFEXPRESSION);
2936 boolean jjtc000 = true;
2937 jjtree.openNodeScope(jjtn000);
2938 try {
2939 RelationalExpression();
2940 if (jj_2_31(2)) {
2941 jj_consume_token(INSTANCEOF);
2942 Type();
2943 } else {
2944 ;
2945 }
2946 } catch (Throwable jjte000) {
2947 if (jjtc000) {
2948 jjtree.clearNodeScope(jjtn000);
2949 jjtc000 = false;
2950 } else {
2951 jjtree.popNode();
2952 }
2953 if (jjte000 instanceof RuntimeException) {
2954 {if (true) throw (RuntimeException)jjte000;}
2955 }
2956 if (jjte000 instanceof ParseException) {
2957 {if (true) throw (ParseException)jjte000;}
2958 }
2959 {if (true) throw (Error)jjte000;}
2960 } finally {
2961 if (jjtc000) {
2962 jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
2963 }
2964 }
2965 }
2966
2967 final public void RelationalExpression() throws ParseException {
2968
2969 ASTRelationalExpression jjtn000 = new ASTRelationalExpression(this, JJTRELATIONALEXPRESSION);
2970 boolean jjtc000 = true;
2971 jjtree.openNodeScope(jjtn000);
2972 try {
2973 ShiftExpression();
2974 label_44:
2975 while (true) {
2976 if (jj_2_32(2)) {
2977 ;
2978 } else {
2979 break label_44;
2980 }
2981 switch (jj_nt.kind) {
2982 case LT:
2983 jj_consume_token(LT);
2984 jjtn000.setImage("<");
2985 break;
2986 case GT:
2987 jj_consume_token(GT);
2988 jjtn000.setImage(">");
2989 break;
2990 case LE:
2991 jj_consume_token(LE);
2992 jjtn000.setImage("<=");
2993 break;
2994 case GE:
2995 jj_consume_token(GE);
2996 jjtn000.setImage(">=");
2997 break;
2998 default:
2999 jj_la1[76] = jj_gen;
3000 jj_consume_token(-1);
3001 throw new ParseException();
3002 }
3003 ShiftExpression();
3004 }
3005 } catch (Throwable jjte000) {
3006 if (jjtc000) {
3007 jjtree.clearNodeScope(jjtn000);
3008 jjtc000 = false;
3009 } else {
3010 jjtree.popNode();
3011 }
3012 if (jjte000 instanceof RuntimeException) {
3013 {if (true) throw (RuntimeException)jjte000;}
3014 }
3015 if (jjte000 instanceof ParseException) {
3016 {if (true) throw (ParseException)jjte000;}
3017 }
3018 {if (true) throw (Error)jjte000;}
3019 } finally {
3020 if (jjtc000) {
3021 jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
3022 }
3023 }
3024 }
3025
3026 final public void ShiftExpression() throws ParseException {
3027
3028 ASTShiftExpression jjtn000 = new ASTShiftExpression(this, JJTSHIFTEXPRESSION);
3029 boolean jjtc000 = true;
3030 jjtree.openNodeScope(jjtn000);
3031 try {
3032 AdditiveExpression();
3033 label_45:
3034 while (true) {
3035 if (jj_2_33(2)) {
3036 ;
3037 } else {
3038 break label_45;
3039 }
3040 switch (jj_nt.kind) {
3041 case LSHIFT:
3042 jj_consume_token(LSHIFT);
3043 jjtn000.setImage("<<");
3044 break;
3045 default:
3046 jj_la1[77] = jj_gen;
3047 if (jj_2_34(1)) {
3048 RSIGNEDSHIFT();
3049 } else if (jj_2_35(1)) {
3050 RUNSIGNEDSHIFT();
3051 } else {
3052 jj_consume_token(-1);
3053 throw new ParseException();
3054 }
3055 }
3056 AdditiveExpression();
3057 }
3058 } catch (Throwable jjte000) {
3059 if (jjtc000) {
3060 jjtree.clearNodeScope(jjtn000);
3061 jjtc000 = false;
3062 } else {
3063 jjtree.popNode();
3064 }
3065 if (jjte000 instanceof RuntimeException) {
3066 {if (true) throw (RuntimeException)jjte000;}
3067 }
3068 if (jjte000 instanceof ParseException) {
3069 {if (true) throw (ParseException)jjte000;}
3070 }
3071 {if (true) throw (Error)jjte000;}
3072 } finally {
3073 if (jjtc000) {
3074 jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
3075 }
3076 }
3077 }
3078
3079 final public void AdditiveExpression() throws ParseException {
3080
3081 ASTAdditiveExpression jjtn000 = new ASTAdditiveExpression(this, JJTADDITIVEEXPRESSION);
3082 boolean jjtc000 = true;
3083 jjtree.openNodeScope(jjtn000);
3084 try {
3085 MultiplicativeExpression();
3086 label_46:
3087 while (true) {
3088 if (jj_2_36(2)) {
3089 ;
3090 } else {
3091 break label_46;
3092 }
3093 switch (jj_nt.kind) {
3094 case PLUS:
3095 jj_consume_token(PLUS);
3096 jjtn000.setImage("+");
3097 break;
3098 case MINUS:
3099 jj_consume_token(MINUS);
3100 jjtn000.setImage("-");
3101 break;
3102 default:
3103 jj_la1[78] = jj_gen;
3104 jj_consume_token(-1);
3105 throw new ParseException();
3106 }
3107 MultiplicativeExpression();
3108 }
3109 } catch (Throwable jjte000) {
3110 if (jjtc000) {
3111 jjtree.clearNodeScope(jjtn000);
3112 jjtc000 = false;
3113 } else {
3114 jjtree.popNode();
3115 }
3116 if (jjte000 instanceof RuntimeException) {
3117 {if (true) throw (RuntimeException)jjte000;}
3118 }
3119 if (jjte000 instanceof ParseException) {
3120 {if (true) throw (ParseException)jjte000;}
3121 }
3122 {if (true) throw (Error)jjte000;}
3123 } finally {
3124 if (jjtc000) {
3125 jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
3126 }
3127 }
3128 }
3129
3130 final public void MultiplicativeExpression() throws ParseException {
3131
3132 ASTMultiplicativeExpression jjtn000 = new ASTMultiplicativeExpression(this, JJTMULTIPLICATIVEEXPRESSION);
3133 boolean jjtc000 = true;
3134 jjtree.openNodeScope(jjtn000);
3135 try {
3136 UnaryExpression();
3137 label_47:
3138 while (true) {
3139 if (jj_2_37(2)) {
3140 ;
3141 } else {
3142 break label_47;
3143 }
3144 switch (jj_nt.kind) {
3145 case STAR:
3146 jj_consume_token(STAR);
3147 jjtn000.setImage("*");
3148 break;
3149 case SLASH:
3150 jj_consume_token(SLASH);
3151 jjtn000.setImage("/");
3152 break;
3153 case REM:
3154 jj_consume_token(REM);
3155 jjtn000.setImage("%");
3156 break;
3157 default:
3158 jj_la1[79] = jj_gen;
3159 jj_consume_token(-1);
3160 throw new ParseException();
3161 }
3162 UnaryExpression();
3163 }
3164 } catch (Throwable jjte000) {
3165 if (jjtc000) {
3166 jjtree.clearNodeScope(jjtn000);
3167 jjtc000 = false;
3168 } else {
3169 jjtree.popNode();
3170 }
3171 if (jjte000 instanceof RuntimeException) {
3172 {if (true) throw (RuntimeException)jjte000;}
3173 }
3174 if (jjte000 instanceof ParseException) {
3175 {if (true) throw (ParseException)jjte000;}
3176 }
3177 {if (true) throw (Error)jjte000;}
3178 } finally {
3179 if (jjtc000) {
3180 jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
3181 }
3182 }
3183 }
3184
3185 final public void UnaryExpression() throws ParseException {
3186
3187 ASTUnaryExpression jjtn000 = new ASTUnaryExpression(this, JJTUNARYEXPRESSION);
3188 boolean jjtc000 = true;
3189 jjtree.openNodeScope(jjtn000);
3190 try {
3191 switch (jj_nt.kind) {
3192 case PLUS:
3193 case MINUS:
3194 switch (jj_nt.kind) {
3195 case PLUS:
3196 jj_consume_token(PLUS);
3197 jjtn000.setImage("+");
3198 break;
3199 case MINUS:
3200 jj_consume_token(MINUS);
3201 jjtn000.setImage("-");
3202 break;
3203 default:
3204 jj_la1[80] = jj_gen;
3205 jj_consume_token(-1);
3206 throw new ParseException();
3207 }
3208 UnaryExpression();
3209 break;
3210 case INCR:
3211 PreIncrementExpression();
3212 break;
3213 case DECR:
3214 PreDecrementExpression();
3215 break;
3216 case BOOLEAN:
3217 case BYTE:
3218 case CHAR:
3219 case DOUBLE:
3220 case FALSE:
3221 case FLOAT:
3222 case INT:
3223 case LONG:
3224 case NEW:
3225 case NULL:
3226 case SHORT:
3227 case SUPER:
3228 case THIS:
3229 case TRUE:
3230 case VOID:
3231 case INTEGER_LITERAL:
3232 case FLOATING_POINT_LITERAL:
3233 case HEX_FLOATING_POINT_LITERAL:
3234 case CHARACTER_LITERAL:
3235 case STRING_LITERAL:
3236 case IDENTIFIER:
3237 case LPAREN:
3238 case BANG:
3239 case TILDE:
3240 UnaryExpressionNotPlusMinus();
3241 break;
3242 default:
3243 jj_la1[81] = jj_gen;
3244 jj_consume_token(-1);
3245 throw new ParseException();
3246 }
3247 } catch (Throwable jjte000) {
3248 if (jjtc000) {
3249 jjtree.clearNodeScope(jjtn000);
3250 jjtc000 = false;
3251 } else {
3252 jjtree.popNode();
3253 }
3254 if (jjte000 instanceof RuntimeException) {
3255 {if (true) throw (RuntimeException)jjte000;}
3256 }
3257 if (jjte000 instanceof ParseException) {
3258 {if (true) throw (ParseException)jjte000;}
3259 }
3260 {if (true) throw (Error)jjte000;}
3261 } finally {
3262 if (jjtc000) {
3263 jjtree.closeNodeScope(jjtn000, ( jjtn000 . getImage ( ) != null ));
3264 }
3265 }
3266 }
3267
3268 final public void PreIncrementExpression() throws ParseException {
3269
3270 ASTPreIncrementExpression jjtn000 = new ASTPreIncrementExpression(this, JJTPREINCREMENTEXPRESSION);
3271 boolean jjtc000 = true;
3272 jjtree.openNodeScope(jjtn000);
3273 try {
3274 jj_consume_token(INCR);
3275 PrimaryExpression();
3276 } catch (Throwable jjte000) {
3277 if (jjtc000) {
3278 jjtree.clearNodeScope(jjtn000);
3279 jjtc000 = false;
3280 } else {
3281 jjtree.popNode();
3282 }
3283 if (jjte000 instanceof RuntimeException) {
3284 {if (true) throw (RuntimeException)jjte000;}
3285 }
3286 if (jjte000 instanceof ParseException) {
3287 {if (true) throw (ParseException)jjte000;}
3288 }
3289 {if (true) throw (Error)jjte000;}
3290 } finally {
3291 if (jjtc000) {
3292 jjtree.closeNodeScope(jjtn000, true);
3293 }
3294 }
3295 }
3296
3297 final public void PreDecrementExpression() throws ParseException {
3298
3299 ASTPreDecrementExpression jjtn000 = new ASTPreDecrementExpression(this, JJTPREDECREMENTEXPRESSION);
3300 boolean jjtc000 = true;
3301 jjtree.openNodeScope(jjtn000);
3302 try {
3303 jj_consume_token(DECR);
3304 PrimaryExpression();
3305 } catch (Throwable jjte000) {
3306 if (jjtc000) {
3307 jjtree.clearNodeScope(jjtn000);
3308 jjtc000 = false;
3309 } else {
3310 jjtree.popNode();
3311 }
3312 if (jjte000 instanceof RuntimeException) {
3313 {if (true) throw (RuntimeException)jjte000;}
3314 }
3315 if (jjte000 instanceof ParseException) {
3316 {if (true) throw (ParseException)jjte000;}
3317 }
3318 {if (true) throw (Error)jjte000;}
3319 } finally {
3320 if (jjtc000) {
3321 jjtree.closeNodeScope(jjtn000, true);
3322 }
3323 }
3324 }
3325
3326 final public void UnaryExpressionNotPlusMinus() throws ParseException {
3327
3328 ASTUnaryExpressionNotPlusMinus jjtn000 = new ASTUnaryExpressionNotPlusMinus(this, JJTUNARYEXPRESSIONNOTPLUSMINUS);
3329 boolean jjtc000 = true;
3330 jjtree.openNodeScope(jjtn000);
3331 try {
3332 switch (jj_nt.kind) {
3333 case BANG:
3334 case TILDE:
3335 switch (jj_nt.kind) {
3336 case TILDE:
3337 jj_consume_token(TILDE);
3338 jjtn000.setImage("~");
3339 break;
3340 case BANG:
3341 jj_consume_token(BANG);
3342 jjtn000.setImage("!");
3343 break;
3344 default:
3345 jj_la1[82] = jj_gen;
3346 jj_consume_token(-1);
3347 throw new ParseException();
3348 }
3349 UnaryExpression();
3350 break;
3351 default:
3352 jj_la1[83] = jj_gen;
3353 if (jj_2_38(2147483647)) {
3354 CastExpression();
3355 } else {
3356 switch (jj_nt.kind) {
3357 case BOOLEAN:
3358 case BYTE:
3359 case CHAR:
3360 case DOUBLE:
3361 case FALSE:
3362 case FLOAT:
3363 case INT:
3364 case LONG:
3365 case NEW:
3366 case NULL:
3367 case SHORT:
3368 case SUPER:
3369 case THIS:
3370 case TRUE:
3371 case VOID:
3372 case INTEGER_LITERAL:
3373 case FLOATING_POINT_LITERAL:
3374 case HEX_FLOATING_POINT_LITERAL:
3375 case CHARACTER_LITERAL:
3376 case STRING_LITERAL:
3377 case IDENTIFIER:
3378 case LPAREN:
3379 PostfixExpression();
3380 break;
3381 default:
3382 jj_la1[84] = jj_gen;
3383 jj_consume_token(-1);
3384 throw new ParseException();
3385 }
3386 }
3387 }
3388 } catch (Throwable jjte000) {
3389 if (jjtc000) {
3390 jjtree.clearNodeScope(jjtn000);
3391 jjtc000 = false;
3392 } else {
3393 jjtree.popNode();
3394 }
3395 if (jjte000 instanceof RuntimeException) {
3396 {if (true) throw (RuntimeException)jjte000;}
3397 }
3398 if (jjte000 instanceof ParseException) {
3399 {if (true) throw (ParseException)jjte000;}
3400 }
3401 {if (true) throw (Error)jjte000;}
3402 } finally {
3403 if (jjtc000) {
3404 jjtree.closeNodeScope(jjtn000, ( jjtn000 . getImage ( ) != null ));
3405 }
3406 }
3407 }
3408
3409 final public void PostfixExpression() throws ParseException {
3410
3411 ASTPostfixExpression jjtn000 = new ASTPostfixExpression(this, JJTPOSTFIXEXPRESSION);
3412 boolean jjtc000 = true;
3413 jjtree.openNodeScope(jjtn000);
3414 try {
3415 PrimaryExpression();
3416 switch (jj_nt.kind) {
3417 case INCR:
3418 case DECR:
3419 switch (jj_nt.kind) {
3420 case INCR:
3421 jj_consume_token(INCR);
3422 jjtn000.setImage("++");
3423 break;
3424 case DECR:
3425 jj_consume_token(DECR);
3426 jjtn000.setImage("--");
3427 break;
3428 default:
3429 jj_la1[85] = jj_gen;
3430 jj_consume_token(-1);
3431 throw new ParseException();
3432 }
3433 break;
3434 default:
3435 jj_la1[86] = jj_gen;
3436 ;
3437 }
3438 } catch (Throwable jjte000) {
3439 if (jjtc000) {
3440 jjtree.clearNodeScope(jjtn000);
3441 jjtc000 = false;
3442 } else {
3443 jjtree.popNode();
3444 }
3445 if (jjte000 instanceof RuntimeException) {
3446 {if (true) throw (RuntimeException)jjte000;}
3447 }
3448 if (jjte000 instanceof ParseException) {
3449 {if (true) throw (ParseException)jjte000;}
3450 }
3451 {if (true) throw (Error)jjte000;}
3452 } finally {
3453 if (jjtc000) {
3454 jjtree.closeNodeScope(jjtn000, ( jjtn000 . getImage ( ) != null ));
3455 }
3456 }
3457 }
3458
3459 final public void CastExpression() throws ParseException {
3460
3461 ASTCastExpression jjtn000 = new ASTCastExpression(this, JJTCASTEXPRESSION);
3462 boolean jjtc000 = true;
3463 jjtree.openNodeScope(jjtn000);
3464 try {
3465 if (jj_2_39(2147483647)) {
3466 jj_consume_token(LPAREN);
3467 label_48:
3468 while (true) {
3469 switch (jj_nt.kind) {
3470 case AT:
3471 ;
3472 break;
3473 default:
3474 jj_la1[87] = jj_gen;
3475 break label_48;
3476 }
3477 Annotation();
3478 checkForBadTypeAnnotations();
3479 }
3480 Type();
3481 jj_consume_token(RPAREN);
3482 UnaryExpression();
3483 } else if (jj_2_40(2147483647)) {
3484 jj_consume_token(LPAREN);
3485 label_49:
3486 while (true) {
3487 switch (jj_nt.kind) {
3488 case AT:
3489 ;
3490 break;
3491 default:
3492 jj_la1[88] = jj_gen;
3493 break label_49;
3494 }
3495 Annotation();
3496 checkForBadTypeAnnotations();
3497 }
3498 Type();
3499 label_50:
3500 while (true) {
3501 jj_consume_token(BIT_AND);
3502 checkForBadIntersectionTypesInCasts(); jjtn000.setIntersectionTypes(true);
3503 ReferenceType();
3504 switch (jj_nt.kind) {
3505 case BIT_AND:
3506 ;
3507 break;
3508 default:
3509 jj_la1[89] = jj_gen;
3510 break label_50;
3511 }
3512 }
3513 jj_consume_token(RPAREN);
3514 UnaryExpressionNotPlusMinus();
3515 } else {
3516 switch (jj_nt.kind) {
3517 case LPAREN:
3518 jj_consume_token(LPAREN);
3519 label_51:
3520 while (true) {
3521 switch (jj_nt.kind) {
3522 case AT:
3523 ;
3524 break;
3525 default:
3526 jj_la1[90] = jj_gen;
3527 break label_51;
3528 }
3529 Annotation();
3530 checkForBadTypeAnnotations();
3531 }
3532 Type();
3533 jj_consume_token(RPAREN);
3534 UnaryExpressionNotPlusMinus();
3535 break;
3536 default:
3537 jj_la1[91] = jj_gen;
3538 jj_consume_token(-1);
3539 throw new ParseException();
3540 }
3541 }
3542 } catch (Throwable jjte000) {
3543 if (jjtc000) {
3544 jjtree.clearNodeScope(jjtn000);
3545 jjtc000 = false;
3546 } else {
3547 jjtree.popNode();
3548 }
3549 if (jjte000 instanceof RuntimeException) {
3550 {if (true) throw (RuntimeException)jjte000;}
3551 }
3552 if (jjte000 instanceof ParseException) {
3553 {if (true) throw (ParseException)jjte000;}
3554 }
3555 {if (true) throw (Error)jjte000;}
3556 } finally {
3557 if (jjtc000) {
3558 jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
3559 }
3560 }
3561 }
3562
3563 final public void PrimaryExpression() throws ParseException {
3564
3565 ASTPrimaryExpression jjtn000 = new ASTPrimaryExpression(this, JJTPRIMARYEXPRESSION);
3566 boolean jjtc000 = true;
3567 jjtree.openNodeScope(jjtn000);
3568 try {
3569 PrimaryPrefix();
3570 label_52:
3571 while (true) {
3572 if (jj_2_41(2)) {
3573 ;
3574 } else {
3575 break label_52;
3576 }
3577 PrimarySuffix();
3578 }
3579 } catch (Throwable jjte000) {
3580 if (jjtc000) {
3581 jjtree.clearNodeScope(jjtn000);
3582 jjtc000 = false;
3583 } else {
3584 jjtree.popNode();
3585 }
3586 if (jjte000 instanceof RuntimeException) {
3587 {if (true) throw (RuntimeException)jjte000;}
3588 }
3589 if (jjte000 instanceof ParseException) {
3590 {if (true) throw (ParseException)jjte000;}
3591 }
3592 {if (true) throw (Error)jjte000;}
3593 } finally {
3594 if (jjtc000) {
3595 jjtree.closeNodeScope(jjtn000, true);
3596 }
3597 }
3598 }
3599
3600 final public void MemberSelector() throws ParseException {
3601
3602 ASTMemberSelector jjtn000 = new ASTMemberSelector(this, JJTMEMBERSELECTOR);
3603 boolean jjtc000 = true;
3604 jjtree.openNodeScope(jjtn000);Token t;
3605 try {
3606 switch (jj_nt.kind) {
3607 case DOT:
3608 jj_consume_token(DOT);
3609 TypeArguments();
3610 t = jj_consume_token(IDENTIFIER);
3611 jjtree.closeNodeScope(jjtn000, true);
3612 jjtc000 = false;
3613 jjtn000.setImage(t.image);
3614 break;
3615 case METHOD_REF:
3616 MethodReference();
3617 break;
3618 default:
3619 jj_la1[92] = jj_gen;
3620 jj_consume_token(-1);
3621 throw new ParseException();
3622 }
3623 } catch (Throwable jjte000) {
3624 if (jjtc000) {
3625 jjtree.clearNodeScope(jjtn000);
3626 jjtc000 = false;
3627 } else {
3628 jjtree.popNode();
3629 }
3630 if (jjte000 instanceof RuntimeException) {
3631 {if (true) throw (RuntimeException)jjte000;}
3632 }
3633 if (jjte000 instanceof ParseException) {
3634 {if (true) throw (ParseException)jjte000;}
3635 }
3636 {if (true) throw (Error)jjte000;}
3637 } finally {
3638 if (jjtc000) {
3639 jjtree.closeNodeScope(jjtn000, true);
3640 }
3641 }
3642 }
3643
3644 final public void MethodReference() throws ParseException {
3645
3646 ASTMethodReference jjtn000 = new ASTMethodReference(this, JJTMETHODREFERENCE);
3647 boolean jjtc000 = true;
3648 jjtree.openNodeScope(jjtn000);Token t; checkForBadMethodReferenceUsage();
3649 try {
3650 jj_consume_token(METHOD_REF);
3651 switch (jj_nt.kind) {
3652 case NEW:
3653 jj_consume_token(NEW);
3654 jjtree.closeNodeScope(jjtn000, true);
3655 jjtc000 = false;
3656 jjtn000.setImage("new");
3657 break;
3658 case IDENTIFIER:
3659 t = jj_consume_token(IDENTIFIER);
3660 jjtree.closeNodeScope(jjtn000, true);
3661 jjtc000 = false;
3662 jjtn000.setImage(t.image);
3663 break;
3664 default:
3665 jj_la1[93] = jj_gen;
3666 jj_consume_token(-1);
3667 throw new ParseException();
3668 }
3669 } finally {
3670 if (jjtc000) {
3671 jjtree.closeNodeScope(jjtn000, true);
3672 }
3673 }
3674 }
3675
3676 final public void PrimaryPrefix() throws ParseException {
3677
3678 ASTPrimaryPrefix jjtn000 = new ASTPrimaryPrefix(this, JJTPRIMARYPREFIX);
3679 boolean jjtc000 = true;
3680 jjtree.openNodeScope(jjtn000);Token t;
3681 try {
3682 switch (jj_nt.kind) {
3683 case FALSE:
3684 case NULL:
3685 case TRUE:
3686 case INTEGER_LITERAL:
3687 case FLOATING_POINT_LITERAL:
3688 case HEX_FLOATING_POINT_LITERAL:
3689 case CHARACTER_LITERAL:
3690 case STRING_LITERAL:
3691 Literal();
3692 break;
3693 case THIS:
3694 jj_consume_token(THIS);
3695 jjtree.closeNodeScope(jjtn000, true);
3696 jjtc000 = false;
3697 jjtn000.setUsesThisModifier();
3698 break;
3699 case SUPER:
3700 jj_consume_token(SUPER);
3701 jjtree.closeNodeScope(jjtn000, true);
3702 jjtc000 = false;
3703 jjtn000.setUsesSuperModifier();
3704 break;
3705 default:
3706 jj_la1[94] = jj_gen;
3707 if (jj_2_42(2147483647)) {
3708 LambdaExpression();
3709 } else if (jj_2_43(2147483647)) {
3710 LambdaExpression();
3711 } else if (jj_2_44(2147483647)) {
3712 LambdaExpression();
3713 } else if (jj_2_45(2147483647)) {
3714 LambdaExpression();
3715 } else if (jj_2_46(3)) {
3716 jj_consume_token(LPAREN);
3717 Expression();
3718 jj_consume_token(RPAREN);
3719 } else {
3720 switch (jj_nt.kind) {
3721 case NEW:
3722 AllocationExpression();
3723 break;
3724 default:
3725 jj_la1[95] = jj_gen;
3726 if (jj_2_47(2147483647)) {
3727 ResultType();
3728 jj_consume_token(DOT);
3729 jj_consume_token(CLASS);
3730 } else if (jj_2_48(2147483647)) {
3731 Name();
3732 } else if (jj_2_49(2147483647)) {
3733 ReferenceType();
3734 MethodReference();
3735 } else {
3736 switch (jj_nt.kind) {
3737 case IDENTIFIER:
3738 Name();
3739 break;
3740 default:
3741 jj_la1[96] = jj_gen;
3742 jj_consume_token(-1);
3743 throw new ParseException();
3744 }
3745 }
3746 }
3747 }
3748 }
3749 } catch (Throwable jjte000) {
3750 if (jjtc000) {
3751 jjtree.clearNodeScope(jjtn000);
3752 jjtc000 = false;
3753 } else {
3754 jjtree.popNode();
3755 }
3756 if (jjte000 instanceof RuntimeException) {
3757 {if (true) throw (RuntimeException)jjte000;}
3758 }
3759 if (jjte000 instanceof ParseException) {
3760 {if (true) throw (ParseException)jjte000;}
3761 }
3762 {if (true) throw (Error)jjte000;}
3763 } finally {
3764 if (jjtc000) {
3765 jjtree.closeNodeScope(jjtn000, true);
3766 }
3767 }
3768 }
3769
3770 final public void LambdaExpression() throws ParseException {
3771
3772 ASTLambdaExpression jjtn000 = new ASTLambdaExpression(this, JJTLAMBDAEXPRESSION);
3773 boolean jjtc000 = true;
3774 jjtree.openNodeScope(jjtn000);checkForBadLambdaUsage();
3775 try {
3776 switch (jj_nt.kind) {
3777 case IDENTIFIER:
3778 VariableDeclaratorId();
3779 jj_consume_token(LAMBDA);
3780 switch (jj_nt.kind) {
3781 case BOOLEAN:
3782 case BYTE:
3783 case CHAR:
3784 case DOUBLE:
3785 case FALSE:
3786 case FLOAT:
3787 case INT:
3788 case LONG:
3789 case NEW:
3790 case NULL:
3791 case SHORT:
3792 case SUPER:
3793 case THIS:
3794 case TRUE:
3795 case VOID:
3796 case INTEGER_LITERAL:
3797 case FLOATING_POINT_LITERAL:
3798 case HEX_FLOATING_POINT_LITERAL:
3799 case CHARACTER_LITERAL:
3800 case STRING_LITERAL:
3801 case IDENTIFIER:
3802 case LPAREN:
3803 case BANG:
3804 case TILDE:
3805 case INCR:
3806 case DECR:
3807 case PLUS:
3808 case MINUS:
3809 Expression();
3810 break;
3811 case LBRACE:
3812 Block();
3813 break;
3814 default:
3815 jj_la1[97] = jj_gen;
3816 jj_consume_token(-1);
3817 throw new ParseException();
3818 }
3819 break;
3820 default:
3821 jj_la1[101] = jj_gen;
3822 if (jj_2_50(3)) {
3823 FormalParameters();
3824 jj_consume_token(LAMBDA);
3825 switch (jj_nt.kind) {
3826 case BOOLEAN:
3827 case BYTE:
3828 case CHAR:
3829 case DOUBLE:
3830 case FALSE:
3831 case FLOAT:
3832 case INT:
3833 case LONG:
3834 case NEW:
3835 case NULL:
3836 case SHORT:
3837 case SUPER:
3838 case THIS:
3839 case TRUE:
3840 case VOID:
3841 case INTEGER_LITERAL:
3842 case FLOATING_POINT_LITERAL:
3843 case HEX_FLOATING_POINT_LITERAL:
3844 case CHARACTER_LITERAL:
3845 case STRING_LITERAL:
3846 case IDENTIFIER:
3847 case LPAREN:
3848 case BANG:
3849 case TILDE:
3850 case INCR:
3851 case DECR:
3852 case PLUS:
3853 case MINUS:
3854 Expression();
3855 break;
3856 case LBRACE:
3857 Block();
3858 break;
3859 default:
3860 jj_la1[98] = jj_gen;
3861 jj_consume_token(-1);
3862 throw new ParseException();
3863 }
3864 } else if (jj_2_51(3)) {
3865 jj_consume_token(LPAREN);
3866 VariableDeclaratorId();
3867 label_53:
3868 while (true) {
3869 switch (jj_nt.kind) {
3870 case COMMA:
3871 ;
3872 break;
3873 default:
3874 jj_la1[99] = jj_gen;
3875 break label_53;
3876 }
3877 jj_consume_token(COMMA);
3878 VariableDeclaratorId();
3879 }
3880 jj_consume_token(RPAREN);
3881 jj_consume_token(LAMBDA);
3882 switch (jj_nt.kind) {
3883 case BOOLEAN:
3884 case BYTE:
3885 case CHAR:
3886 case DOUBLE:
3887 case FALSE:
3888 case FLOAT:
3889 case INT:
3890 case LONG:
3891 case NEW:
3892 case NULL:
3893 case SHORT:
3894 case SUPER:
3895 case THIS:
3896 case TRUE:
3897 case VOID:
3898 case INTEGER_LITERAL:
3899 case FLOATING_POINT_LITERAL:
3900 case HEX_FLOATING_POINT_LITERAL:
3901 case CHARACTER_LITERAL:
3902 case STRING_LITERAL:
3903 case IDENTIFIER:
3904 case LPAREN:
3905 case BANG:
3906 case TILDE:
3907 case INCR:
3908 case DECR:
3909 case PLUS:
3910 case MINUS:
3911 Expression();
3912 break;
3913 case LBRACE:
3914 Block();
3915 break;
3916 default:
3917 jj_la1[100] = jj_gen;
3918 jj_consume_token(-1);
3919 throw new ParseException();
3920 }
3921 } else {
3922 jj_consume_token(-1);
3923 throw new ParseException();
3924 }
3925 }
3926 } catch (Throwable jjte000) {
3927 if (jjtc000) {
3928 jjtree.clearNodeScope(jjtn000);
3929 jjtc000 = false;
3930 } else {
3931 jjtree.popNode();
3932 }
3933 if (jjte000 instanceof RuntimeException) {
3934 {if (true) throw (RuntimeException)jjte000;}
3935 }
3936 if (jjte000 instanceof ParseException) {
3937 {if (true) throw (ParseException)jjte000;}
3938 }
3939 {if (true) throw (Error)jjte000;}
3940 } finally {
3941 if (jjtc000) {
3942 jjtree.closeNodeScope(jjtn000, true);
3943 }
3944 }
3945 }
3946
3947 final public void PrimarySuffix() throws ParseException {
3948
3949 ASTPrimarySuffix jjtn000 = new ASTPrimarySuffix(this, JJTPRIMARYSUFFIX);
3950 boolean jjtc000 = true;
3951 jjtree.openNodeScope(jjtn000);Token t;
3952 try {
3953 if (jj_2_52(2)) {
3954 jj_consume_token(DOT);
3955 jj_consume_token(THIS);
3956 } else if (jj_2_53(2)) {
3957 jj_consume_token(DOT);
3958 jj_consume_token(SUPER);
3959 } else if (jj_2_54(2)) {
3960 jj_consume_token(DOT);
3961 AllocationExpression();
3962 } else if (jj_2_55(3)) {
3963 MemberSelector();
3964 } else {
3965 switch (jj_nt.kind) {
3966 case LBRACKET:
3967 jj_consume_token(LBRACKET);
3968 Expression();
3969 jj_consume_token(RBRACKET);
3970 jjtree.closeNodeScope(jjtn000, true);
3971 jjtc000 = false;
3972 jjtn000.setIsArrayDereference();
3973 break;
3974 case DOT:
3975 jj_consume_token(DOT);
3976 t = jj_consume_token(IDENTIFIER);
3977 jjtree.closeNodeScope(jjtn000, true);
3978 jjtc000 = false;
3979 jjtn000.setImage(t.image);
3980 break;
3981 case LPAREN:
3982 Arguments();
3983 jjtree.closeNodeScope(jjtn000, true);
3984 jjtc000 = false;
3985 jjtn000.setIsArguments();
3986 break;
3987 default:
3988 jj_la1[102] = jj_gen;
3989 jj_consume_token(-1);
3990 throw new ParseException();
3991 }
3992 }
3993 } catch (Throwable jjte000) {
3994 if (jjtc000) {
3995 jjtree.clearNodeScope(jjtn000);
3996 jjtc000 = false;
3997 } else {
3998 jjtree.popNode();
3999 }
4000 if (jjte000 instanceof RuntimeException) {
4001 {if (true) throw (RuntimeException)jjte000;}
4002 }
4003 if (jjte000 instanceof ParseException) {
4004 {if (true) throw (ParseException)jjte000;}
4005 }
4006 {if (true) throw (Error)jjte000;}
4007 } finally {
4008 if (jjtc000) {
4009 jjtree.closeNodeScope(jjtn000, true);
4010 }
4011 }
4012 }
4013
4014 final public void Literal() throws ParseException {
4015
4016 ASTLiteral jjtn000 = new ASTLiteral(this, JJTLITERAL);
4017 boolean jjtc000 = true;
4018 jjtree.openNodeScope(jjtn000);
4019 try {
4020 switch (jj_nt.kind) {
4021 case INTEGER_LITERAL:
4022 Token t;
4023 t = jj_consume_token(INTEGER_LITERAL);
4024 jjtree.closeNodeScope(jjtn000, true);
4025 jjtc000 = false;
4026 checkForBadNumericalLiteralslUsage(t); jjtn000.setImage(t.image); jjtn000.setIntLiteral();
4027 break;
4028 case FLOATING_POINT_LITERAL:
4029 t = jj_consume_token(FLOATING_POINT_LITERAL);
4030 jjtree.closeNodeScope(jjtn000, true);
4031 jjtc000 = false;
4032 checkForBadNumericalLiteralslUsage(t); jjtn000.setImage(t.image); jjtn000.setFloatLiteral();
4033 break;
4034 case HEX_FLOATING_POINT_LITERAL:
4035 t = jj_consume_token(HEX_FLOATING_POINT_LITERAL);
4036 jjtree.closeNodeScope(jjtn000, true);
4037 jjtc000 = false;
4038 checkForBadHexFloatingPointLiteral(); checkForBadNumericalLiteralslUsage(t); jjtn000.setImage(t.image); jjtn000.setFloatLiteral();
4039 break;
4040 case CHARACTER_LITERAL:
4041 t = jj_consume_token(CHARACTER_LITERAL);
4042 jjtree.closeNodeScope(jjtn000, true);
4043 jjtc000 = false;
4044 jjtn000.setImage(t.image); jjtn000.setCharLiteral();
4045 break;
4046 case STRING_LITERAL:
4047 t = jj_consume_token(STRING_LITERAL);
4048 jjtree.closeNodeScope(jjtn000, true);
4049 jjtc000 = false;
4050 jjtn000.setImage(t.image); jjtn000.setStringLiteral();
4051 break;
4052 case FALSE:
4053 case TRUE:
4054 BooleanLiteral();
4055 break;
4056 case NULL:
4057 NullLiteral();
4058 break;
4059 default:
4060 jj_la1[103] = jj_gen;
4061 jj_consume_token(-1);
4062 throw new ParseException();
4063 }
4064 } catch (Throwable jjte000) {
4065 if (jjtc000) {
4066 jjtree.clearNodeScope(jjtn000);
4067 jjtc000 = false;
4068 } else {
4069 jjtree.popNode();
4070 }
4071 if (jjte000 instanceof RuntimeException) {
4072 {if (true) throw (RuntimeException)jjte000;}
4073 }
4074 if (jjte000 instanceof ParseException) {
4075 {if (true) throw (ParseException)jjte000;}
4076 }
4077 {if (true) throw (Error)jjte000;}
4078 } finally {
4079 if (jjtc000) {
4080 jjtree.closeNodeScope(jjtn000, true);
4081 }
4082 }
4083 }
4084
4085 final public void BooleanLiteral() throws ParseException {
4086
4087 ASTBooleanLiteral jjtn000 = new ASTBooleanLiteral(this, JJTBOOLEANLITERAL);
4088 boolean jjtc000 = true;
4089 jjtree.openNodeScope(jjtn000);
4090 try {
4091 switch (jj_nt.kind) {
4092 case TRUE:
4093 jj_consume_token(TRUE);
4094 jjtree.closeNodeScope(jjtn000, true);
4095 jjtc000 = false;
4096 jjtn000.setTrue();
4097 break;
4098 case FALSE:
4099 jj_consume_token(FALSE);
4100 break;
4101 default:
4102 jj_la1[104] = jj_gen;
4103 jj_consume_token(-1);
4104 throw new ParseException();
4105 }
4106 } finally {
4107 if (jjtc000) {
4108 jjtree.closeNodeScope(jjtn000, true);
4109 }
4110 }
4111 }
4112
4113 final public void NullLiteral() throws ParseException {
4114
4115 ASTNullLiteral jjtn000 = new ASTNullLiteral(this, JJTNULLLITERAL);
4116 boolean jjtc000 = true;
4117 jjtree.openNodeScope(jjtn000);
4118 try {
4119 jj_consume_token(NULL);
4120 } finally {
4121 if (jjtc000) {
4122 jjtree.closeNodeScope(jjtn000, true);
4123 }
4124 }
4125 }
4126
4127 final public void Arguments() throws ParseException {
4128
4129 ASTArguments jjtn000 = new ASTArguments(this, JJTARGUMENTS);
4130 boolean jjtc000 = true;
4131 jjtree.openNodeScope(jjtn000);
4132 try {
4133 jj_consume_token(LPAREN);
4134 switch (jj_nt.kind) {
4135 case BOOLEAN:
4136 case BYTE:
4137 case CHAR:
4138 case DOUBLE:
4139 case FALSE:
4140 case FLOAT:
4141 case INT:
4142 case LONG:
4143 case NEW:
4144 case NULL:
4145 case SHORT:
4146 case SUPER:
4147 case THIS:
4148 case TRUE:
4149 case VOID:
4150 case INTEGER_LITERAL:
4151 case FLOATING_POINT_LITERAL:
4152 case HEX_FLOATING_POINT_LITERAL:
4153 case CHARACTER_LITERAL:
4154 case STRING_LITERAL:
4155 case IDENTIFIER:
4156 case LPAREN:
4157 case BANG:
4158 case TILDE:
4159 case INCR:
4160 case DECR:
4161 case PLUS:
4162 case MINUS:
4163 ArgumentList();
4164 break;
4165 default:
4166 jj_la1[105] = jj_gen;
4167 ;
4168 }
4169 jj_consume_token(RPAREN);
4170 } catch (Throwable jjte000) {
4171 if (jjtc000) {
4172 jjtree.clearNodeScope(jjtn000);
4173 jjtc000 = false;
4174 } else {
4175 jjtree.popNode();
4176 }
4177 if (jjte000 instanceof RuntimeException) {
4178 {if (true) throw (RuntimeException)jjte000;}
4179 }
4180 if (jjte000 instanceof ParseException) {
4181 {if (true) throw (ParseException)jjte000;}
4182 }
4183 {if (true) throw (Error)jjte000;}
4184 } finally {
4185 if (jjtc000) {
4186 jjtree.closeNodeScope(jjtn000, true);
4187 }
4188 }
4189 }
4190
4191 final public void ArgumentList() throws ParseException {
4192
4193 ASTArgumentList jjtn000 = new ASTArgumentList(this, JJTARGUMENTLIST);
4194 boolean jjtc000 = true;
4195 jjtree.openNodeScope(jjtn000);
4196 try {
4197 Expression();
4198 label_54:
4199 while (true) {
4200 switch (jj_nt.kind) {
4201 case COMMA:
4202 ;
4203 break;
4204 default:
4205 jj_la1[106] = jj_gen;
4206 break label_54;
4207 }
4208 jj_consume_token(COMMA);
4209 Expression();
4210 }
4211 } catch (Throwable jjte000) {
4212 if (jjtc000) {
4213 jjtree.clearNodeScope(jjtn000);
4214 jjtc000 = false;
4215 } else {
4216 jjtree.popNode();
4217 }
4218 if (jjte000 instanceof RuntimeException) {
4219 {if (true) throw (RuntimeException)jjte000;}
4220 }
4221 if (jjte000 instanceof ParseException) {
4222 {if (true) throw (ParseException)jjte000;}
4223 }
4224 {if (true) throw (Error)jjte000;}
4225 } finally {
4226 if (jjtc000) {
4227 jjtree.closeNodeScope(jjtn000, true);
4228 }
4229 }
4230 }
4231
4232 final public void AllocationExpression() throws ParseException {
4233
4234 ASTAllocationExpression jjtn000 = new ASTAllocationExpression(this, JJTALLOCATIONEXPRESSION);
4235 boolean jjtc000 = true;
4236 jjtree.openNodeScope(jjtn000);
4237 try {
4238 jj_consume_token(NEW);
4239 label_55:
4240 while (true) {
4241 switch (jj_nt.kind) {
4242 case AT:
4243 ;
4244 break;
4245 default:
4246 jj_la1[107] = jj_gen;
4247 break label_55;
4248 }
4249 Annotation();
4250 checkForBadTypeAnnotations();
4251 }
4252 if (jj_2_56(2)) {
4253 PrimitiveType();
4254 ArrayDimsAndInits();
4255 } else {
4256 switch (jj_nt.kind) {
4257 case IDENTIFIER:
4258 ClassOrInterfaceType();
4259 switch (jj_nt.kind) {
4260 case LT:
4261 TypeArguments();
4262 break;
4263 default:
4264 jj_la1[108] = jj_gen;
4265 ;
4266 }
4267 switch (jj_nt.kind) {
4268 case LBRACKET:
4269 ArrayDimsAndInits();
4270 break;
4271 case LPAREN:
4272 Arguments();
4273 switch (jj_nt.kind) {
4274 case LBRACE:
4275 ClassOrInterfaceBody();
4276 break;
4277 default:
4278 jj_la1[109] = jj_gen;
4279 ;
4280 }
4281 break;
4282 default:
4283 jj_la1[110] = jj_gen;
4284 jj_consume_token(-1);
4285 throw new ParseException();
4286 }
4287 break;
4288 default:
4289 jj_la1[111] = jj_gen;
4290 jj_consume_token(-1);
4291 throw new ParseException();
4292 }
4293 }
4294 } catch (Throwable jjte000) {
4295 if (jjtc000) {
4296 jjtree.clearNodeScope(jjtn000);
4297 jjtc000 = false;
4298 } else {
4299 jjtree.popNode();
4300 }
4301 if (jjte000 instanceof RuntimeException) {
4302 {if (true) throw (RuntimeException)jjte000;}
4303 }
4304 if (jjte000 instanceof ParseException) {
4305 {if (true) throw (ParseException)jjte000;}
4306 }
4307 {if (true) throw (Error)jjte000;}
4308 } finally {
4309 if (jjtc000) {
4310 jjtree.closeNodeScope(jjtn000, true);
4311 }
4312 }
4313 }
4314
4315
4316
4317
4318
4319 final public void ArrayDimsAndInits() throws ParseException {
4320
4321 ASTArrayDimsAndInits jjtn000 = new ASTArrayDimsAndInits(this, JJTARRAYDIMSANDINITS);
4322 boolean jjtc000 = true;
4323 jjtree.openNodeScope(jjtn000);
4324 try {
4325 if (jj_2_59(2)) {
4326 label_56:
4327 while (true) {
4328 jj_consume_token(LBRACKET);
4329 Expression();
4330 jj_consume_token(RBRACKET);
4331 if (jj_2_57(2)) {
4332 ;
4333 } else {
4334 break label_56;
4335 }
4336 }
4337 label_57:
4338 while (true) {
4339 if (jj_2_58(2)) {
4340 ;
4341 } else {
4342 break label_57;
4343 }
4344 jj_consume_token(LBRACKET);
4345 jj_consume_token(RBRACKET);
4346 }
4347 } else {
4348 switch (jj_nt.kind) {
4349 case LBRACKET:
4350 label_58:
4351 while (true) {
4352 jj_consume_token(LBRACKET);
4353 jj_consume_token(RBRACKET);
4354 switch (jj_nt.kind) {
4355 case LBRACKET:
4356 ;
4357 break;
4358 default:
4359 jj_la1[112] = jj_gen;
4360 break label_58;
4361 }
4362 }
4363 ArrayInitializer();
4364 break;
4365 default:
4366 jj_la1[113] = jj_gen;
4367 jj_consume_token(-1);
4368 throw new ParseException();
4369 }
4370 }
4371 } catch (Throwable jjte000) {
4372 if (jjtc000) {
4373 jjtree.clearNodeScope(jjtn000);
4374 jjtc000 = false;
4375 } else {
4376 jjtree.popNode();
4377 }
4378 if (jjte000 instanceof RuntimeException) {
4379 {if (true) throw (RuntimeException)jjte000;}
4380 }
4381 if (jjte000 instanceof ParseException) {
4382 {if (true) throw (ParseException)jjte000;}
4383 }
4384 {if (true) throw (Error)jjte000;}
4385 } finally {
4386 if (jjtc000) {
4387 jjtree.closeNodeScope(jjtn000, true);
4388 }
4389 }
4390 }
4391
4392
4393
4394
4395 final public void Statement() throws ParseException {
4396
4397 ASTStatement jjtn000 = new ASTStatement(this, JJTSTATEMENT);
4398 boolean jjtc000 = true;
4399 jjtree.openNodeScope(jjtn000);
4400 try {
4401 if (isNextTokenAnAssert()) {
4402 AssertStatement();
4403 } else if (jj_2_60(2)) {
4404 LabeledStatement();
4405 } else {
4406 switch (jj_nt.kind) {
4407 case LBRACE:
4408 Block();
4409 break;
4410 case SEMICOLON:
4411 EmptyStatement();
4412 break;
4413 case BOOLEAN:
4414 case BYTE:
4415 case CHAR:
4416 case DOUBLE:
4417 case FALSE:
4418 case FLOAT:
4419 case INT:
4420 case LONG:
4421 case NEW:
4422 case NULL:
4423 case SHORT:
4424 case SUPER:
4425 case THIS:
4426 case TRUE:
4427 case VOID:
4428 case INTEGER_LITERAL:
4429 case FLOATING_POINT_LITERAL:
4430 case HEX_FLOATING_POINT_LITERAL:
4431 case CHARACTER_LITERAL:
4432 case STRING_LITERAL:
4433 case IDENTIFIER:
4434 case LPAREN:
4435 case INCR:
4436 case DECR:
4437 StatementExpression();
4438 jj_consume_token(SEMICOLON);
4439 break;
4440 case SWITCH:
4441 SwitchStatement();
4442 break;
4443 case IF:
4444 IfStatement();
4445 break;
4446 case WHILE:
4447 WhileStatement();
4448 break;
4449 case DO:
4450 DoStatement();
4451 break;
4452 case FOR:
4453 ForStatement();
4454 break;
4455 case BREAK:
4456 BreakStatement();
4457 break;
4458 case CONTINUE:
4459 ContinueStatement();
4460 break;
4461 case RETURN:
4462 ReturnStatement();
4463 break;
4464 case THROW:
4465 ThrowStatement();
4466 break;
4467 case SYNCHRONIZED:
4468 SynchronizedStatement();
4469 break;
4470 case TRY:
4471 TryStatement();
4472 break;
4473 default:
4474 jj_la1[114] = jj_gen;
4475 jj_consume_token(-1);
4476 throw new ParseException();
4477 }
4478 }
4479 } catch (Throwable jjte000) {
4480 if (jjtc000) {
4481 jjtree.clearNodeScope(jjtn000);
4482 jjtc000 = false;
4483 } else {
4484 jjtree.popNode();
4485 }
4486 if (jjte000 instanceof RuntimeException) {
4487 {if (true) throw (RuntimeException)jjte000;}
4488 }
4489 if (jjte000 instanceof ParseException) {
4490 {if (true) throw (ParseException)jjte000;}
4491 }
4492 {if (true) throw (Error)jjte000;}
4493 } finally {
4494 if (jjtc000) {
4495 jjtree.closeNodeScope(jjtn000, true);
4496 }
4497 }
4498 }
4499
4500 final public void LabeledStatement() throws ParseException {
4501
4502 ASTLabeledStatement jjtn000 = new ASTLabeledStatement(this, JJTLABELEDSTATEMENT);
4503 boolean jjtc000 = true;
4504 jjtree.openNodeScope(jjtn000);Token t;
4505 try {
4506 t = jj_consume_token(IDENTIFIER);
4507 jjtn000.setImage(t.image);
4508 jj_consume_token(COLON);
4509 Statement();
4510 } catch (Throwable jjte000) {
4511 if (jjtc000) {
4512 jjtree.clearNodeScope(jjtn000);
4513 jjtc000 = false;
4514 } else {
4515 jjtree.popNode();
4516 }
4517 if (jjte000 instanceof RuntimeException) {
4518 {if (true) throw (RuntimeException)jjte000;}
4519 }
4520 if (jjte000 instanceof ParseException) {
4521 {if (true) throw (ParseException)jjte000;}
4522 }
4523 {if (true) throw (Error)jjte000;}
4524 } finally {
4525 if (jjtc000) {
4526 jjtree.closeNodeScope(jjtn000, true);
4527 }
4528 }
4529 }
4530
4531 final public void Block() throws ParseException {
4532
4533 ASTBlock jjtn000 = new ASTBlock(this, JJTBLOCK);
4534 boolean jjtc000 = true;
4535 jjtree.openNodeScope(jjtn000);Token t;
4536 try {
4537 jj_consume_token(LBRACE);
4538 label_59:
4539 while (true) {
4540 if (jj_2_61(1)) {
4541 ;
4542 } else {
4543 break label_59;
4544 }
4545 BlockStatement();
4546 }
4547 t = jj_consume_token(RBRACE);
4548 jjtree.closeNodeScope(jjtn000, true);
4549 jjtc000 = false;
4550 if (isPrecededByComment(t)) { jjtn000.setContainsComment(); }
4551 } catch (Throwable jjte000) {
4552 if (jjtc000) {
4553 jjtree.clearNodeScope(jjtn000);
4554 jjtc000 = false;
4555 } else {
4556 jjtree.popNode();
4557 }
4558 if (jjte000 instanceof RuntimeException) {
4559 {if (true) throw (RuntimeException)jjte000;}
4560 }
4561 if (jjte000 instanceof ParseException) {
4562 {if (true) throw (ParseException)jjte000;}
4563 }
4564 {if (true) throw (Error)jjte000;}
4565 } finally {
4566 if (jjtc000) {
4567 jjtree.closeNodeScope(jjtn000, true);
4568 }
4569 }
4570 }
4571
4572 final public void BlockStatement() throws ParseException {
4573
4574 ASTBlockStatement jjtn000 = new ASTBlockStatement(this, JJTBLOCKSTATEMENT);
4575 boolean jjtc000 = true;
4576 jjtree.openNodeScope(jjtn000);
4577 try {
4578 if (isNextTokenAnAssert()) {
4579 AssertStatement();
4580 } else if (jj_2_62(2147483647)) {
4581 LocalVariableDeclaration();
4582 jj_consume_token(SEMICOLON);
4583 } else if (jj_2_63(1)) {
4584 Statement();
4585 } else if (jj_2_64(2147483647)) {
4586 switch (jj_nt.kind) {
4587 case AT:
4588 Annotation();
4589 break;
4590 default:
4591 jj_la1[115] = jj_gen;
4592 ;
4593 }
4594 ClassOrInterfaceDeclaration(0);
4595 } else {
4596 jj_consume_token(-1);
4597 throw new ParseException();
4598 }
4599 } catch (Throwable jjte000) {
4600 if (jjtc000) {
4601 jjtree.clearNodeScope(jjtn000);
4602 jjtc000 = false;
4603 } else {
4604 jjtree.popNode();
4605 }
4606 if (jjte000 instanceof RuntimeException) {
4607 {if (true) throw (RuntimeException)jjte000;}
4608 }
4609 if (jjte000 instanceof ParseException) {
4610 {if (true) throw (ParseException)jjte000;}
4611 }
4612 {if (true) throw (Error)jjte000;}
4613 } finally {
4614 if (jjtc000) {
4615 jjtree.closeNodeScope(jjtn000, true);
4616 }
4617 }
4618 }
4619
4620 final public void LocalVariableDeclaration() throws ParseException {
4621
4622 ASTLocalVariableDeclaration jjtn000 = new ASTLocalVariableDeclaration(this, JJTLOCALVARIABLEDECLARATION);
4623 boolean jjtc000 = true;
4624 jjtree.openNodeScope(jjtn000);
4625 try {
4626 label_60:
4627 while (true) {
4628 switch (jj_nt.kind) {
4629 case FINAL:
4630 case AT:
4631 ;
4632 break;
4633 default:
4634 jj_la1[116] = jj_gen;
4635 break label_60;
4636 }
4637 switch (jj_nt.kind) {
4638 case FINAL:
4639 jj_consume_token(FINAL);
4640 jjtn000.setFinal(true);
4641 break;
4642 case AT:
4643 Annotation();
4644 break;
4645 default:
4646 jj_la1[117] = jj_gen;
4647 jj_consume_token(-1);
4648 throw new ParseException();
4649 }
4650 }
4651 Type();
4652 VariableDeclarator();
4653 label_61:
4654 while (true) {
4655 switch (jj_nt.kind) {
4656 case COMMA:
4657 ;
4658 break;
4659 default:
4660 jj_la1[118] = jj_gen;
4661 break label_61;
4662 }
4663 jj_consume_token(COMMA);
4664 VariableDeclarator();
4665 }
4666 } catch (Throwable jjte000) {
4667 if (jjtc000) {
4668 jjtree.clearNodeScope(jjtn000);
4669 jjtc000 = false;
4670 } else {
4671 jjtree.popNode();
4672 }
4673 if (jjte000 instanceof RuntimeException) {
4674 {if (true) throw (RuntimeException)jjte000;}
4675 }
4676 if (jjte000 instanceof ParseException) {
4677 {if (true) throw (ParseException)jjte000;}
4678 }
4679 {if (true) throw (Error)jjte000;}
4680 } finally {
4681 if (jjtc000) {
4682 jjtree.closeNodeScope(jjtn000, true);
4683 }
4684 }
4685 }
4686
4687 final public void EmptyStatement() throws ParseException {
4688
4689 ASTEmptyStatement jjtn000 = new ASTEmptyStatement(this, JJTEMPTYSTATEMENT);
4690 boolean jjtc000 = true;
4691 jjtree.openNodeScope(jjtn000);
4692 try {
4693 jj_consume_token(SEMICOLON);
4694 } finally {
4695 if (jjtc000) {
4696 jjtree.closeNodeScope(jjtn000, true);
4697 }
4698 }
4699 }
4700
4701 final public void StatementExpression() throws ParseException {
4702
4703 ASTStatementExpression jjtn000 = new ASTStatementExpression(this, JJTSTATEMENTEXPRESSION);
4704 boolean jjtc000 = true;
4705 jjtree.openNodeScope(jjtn000);
4706 try {
4707 switch (jj_nt.kind) {
4708 case INCR:
4709 PreIncrementExpression();
4710 break;
4711 case DECR:
4712 PreDecrementExpression();
4713 break;
4714 default:
4715 jj_la1[120] = jj_gen;
4716 if (jj_2_65(2147483647)) {
4717 PostfixExpression();
4718 } else {
4719 switch (jj_nt.kind) {
4720 case BOOLEAN:
4721 case BYTE:
4722 case CHAR:
4723 case DOUBLE:
4724 case FALSE:
4725 case FLOAT:
4726 case INT:
4727 case LONG:
4728 case NEW:
4729 case NULL:
4730 case SHORT:
4731 case SUPER:
4732 case THIS:
4733 case TRUE:
4734 case VOID:
4735 case INTEGER_LITERAL:
4736 case FLOATING_POINT_LITERAL:
4737 case HEX_FLOATING_POINT_LITERAL:
4738 case CHARACTER_LITERAL:
4739 case STRING_LITERAL:
4740 case IDENTIFIER:
4741 case LPAREN:
4742 PrimaryExpression();
4743 switch (jj_nt.kind) {
4744 case ASSIGN:
4745 case PLUSASSIGN:
4746 case MINUSASSIGN:
4747 case STARASSIGN:
4748 case SLASHASSIGN:
4749 case ANDASSIGN:
4750 case ORASSIGN:
4751 case XORASSIGN:
4752 case REMASSIGN:
4753 case LSHIFTASSIGN:
4754 case RSIGNEDSHIFTASSIGN:
4755 case RUNSIGNEDSHIFTASSIGN:
4756 AssignmentOperator();
4757 Expression();
4758 break;
4759 default:
4760 jj_la1[119] = jj_gen;
4761 ;
4762 }
4763 break;
4764 default:
4765 jj_la1[121] = jj_gen;
4766 jj_consume_token(-1);
4767 throw new ParseException();
4768 }
4769 }
4770 }
4771 } catch (Throwable jjte000) {
4772 if (jjtc000) {
4773 jjtree.clearNodeScope(jjtn000);
4774 jjtc000 = false;
4775 } else {
4776 jjtree.popNode();
4777 }
4778 if (jjte000 instanceof RuntimeException) {
4779 {if (true) throw (RuntimeException)jjte000;}
4780 }
4781 if (jjte000 instanceof ParseException) {
4782 {if (true) throw (ParseException)jjte000;}
4783 }
4784 {if (true) throw (Error)jjte000;}
4785 } finally {
4786 if (jjtc000) {
4787 jjtree.closeNodeScope(jjtn000, true);
4788 }
4789 }
4790 }
4791
4792 final public void SwitchStatement() throws ParseException {
4793
4794 ASTSwitchStatement jjtn000 = new ASTSwitchStatement(this, JJTSWITCHSTATEMENT);
4795 boolean jjtc000 = true;
4796 jjtree.openNodeScope(jjtn000);
4797 try {
4798 jj_consume_token(SWITCH);
4799 jj_consume_token(LPAREN);
4800 Expression();
4801 jj_consume_token(RPAREN);
4802 jj_consume_token(LBRACE);
4803 label_62:
4804 while (true) {
4805 switch (jj_nt.kind) {
4806 case CASE:
4807 case _DEFAULT:
4808 ;
4809 break;
4810 default:
4811 jj_la1[122] = jj_gen;
4812 break label_62;
4813 }
4814 SwitchLabel();
4815 label_63:
4816 while (true) {
4817 if (jj_2_66(1)) {
4818 ;
4819 } else {
4820 break label_63;
4821 }
4822 BlockStatement();
4823 }
4824 }
4825 jj_consume_token(RBRACE);
4826 } catch (Throwable jjte000) {
4827 if (jjtc000) {
4828 jjtree.clearNodeScope(jjtn000);
4829 jjtc000 = false;
4830 } else {
4831 jjtree.popNode();
4832 }
4833 if (jjte000 instanceof RuntimeException) {
4834 {if (true) throw (RuntimeException)jjte000;}
4835 }
4836 if (jjte000 instanceof ParseException) {
4837 {if (true) throw (ParseException)jjte000;}
4838 }
4839 {if (true) throw (Error)jjte000;}
4840 } finally {
4841 if (jjtc000) {
4842 jjtree.closeNodeScope(jjtn000, true);
4843 }
4844 }
4845 }
4846
4847 final public void SwitchLabel() throws ParseException {
4848
4849 ASTSwitchLabel jjtn000 = new ASTSwitchLabel(this, JJTSWITCHLABEL);
4850 boolean jjtc000 = true;
4851 jjtree.openNodeScope(jjtn000);
4852 try {
4853 switch (jj_nt.kind) {
4854 case CASE:
4855 jj_consume_token(CASE);
4856 Expression();
4857 jj_consume_token(COLON);
4858 break;
4859 case _DEFAULT:
4860 jj_consume_token(_DEFAULT);
4861 jjtn000.setDefault();
4862 jj_consume_token(COLON);
4863 break;
4864 default:
4865 jj_la1[123] = jj_gen;
4866 jj_consume_token(-1);
4867 throw new ParseException();
4868 }
4869 } catch (Throwable jjte000) {
4870 if (jjtc000) {
4871 jjtree.clearNodeScope(jjtn000);
4872 jjtc000 = false;
4873 } else {
4874 jjtree.popNode();
4875 }
4876 if (jjte000 instanceof RuntimeException) {
4877 {if (true) throw (RuntimeException)jjte000;}
4878 }
4879 if (jjte000 instanceof ParseException) {
4880 {if (true) throw (ParseException)jjte000;}
4881 }
4882 {if (true) throw (Error)jjte000;}
4883 } finally {
4884 if (jjtc000) {
4885 jjtree.closeNodeScope(jjtn000, true);
4886 }
4887 }
4888 }
4889
4890 final public void IfStatement() throws ParseException {
4891
4892 ASTIfStatement jjtn000 = new ASTIfStatement(this, JJTIFSTATEMENT);
4893 boolean jjtc000 = true;
4894 jjtree.openNodeScope(jjtn000);
4895 try {
4896 jj_consume_token(IF);
4897 jj_consume_token(LPAREN);
4898 Expression();
4899 jj_consume_token(RPAREN);
4900 Statement();
4901 switch (jj_nt.kind) {
4902 case ELSE:
4903 jj_consume_token(ELSE);
4904 jjtn000.setHasElse();
4905 Statement();
4906 break;
4907 default:
4908 jj_la1[124] = jj_gen;
4909 ;
4910 }
4911 jjtree.closeNodeScope(jjtn000, true);
4912 jjtc000 = false;
4913
4914 } catch (Throwable jjte000) {
4915 if (jjtc000) {
4916 jjtree.clearNodeScope(jjtn000);
4917 jjtc000 = false;
4918 } else {
4919 jjtree.popNode();
4920 }
4921 if (jjte000 instanceof RuntimeException) {
4922 {if (true) throw (RuntimeException)jjte000;}
4923 }
4924 if (jjte000 instanceof ParseException) {
4925 {if (true) throw (ParseException)jjte000;}
4926 }
4927 {if (true) throw (Error)jjte000;}
4928 } finally {
4929 if (jjtc000) {
4930 jjtree.closeNodeScope(jjtn000, true);
4931 }
4932 }
4933 }
4934
4935 final public void WhileStatement() throws ParseException {
4936
4937 ASTWhileStatement jjtn000 = new ASTWhileStatement(this, JJTWHILESTATEMENT);
4938 boolean jjtc000 = true;
4939 jjtree.openNodeScope(jjtn000);
4940 try {
4941 jj_consume_token(WHILE);
4942 jj_consume_token(LPAREN);
4943 Expression();
4944 jj_consume_token(RPAREN);
4945 Statement();
4946 } catch (Throwable jjte000) {
4947 if (jjtc000) {
4948 jjtree.clearNodeScope(jjtn000);
4949 jjtc000 = false;
4950 } else {
4951 jjtree.popNode();
4952 }
4953 if (jjte000 instanceof RuntimeException) {
4954 {if (true) throw (RuntimeException)jjte000;}
4955 }
4956 if (jjte000 instanceof ParseException) {
4957 {if (true) throw (ParseException)jjte000;}
4958 }
4959 {if (true) throw (Error)jjte000;}
4960 } finally {
4961 if (jjtc000) {
4962 jjtree.closeNodeScope(jjtn000, true);
4963 }
4964 }
4965 }
4966
4967 final public void DoStatement() throws ParseException {
4968
4969 ASTDoStatement jjtn000 = new ASTDoStatement(this, JJTDOSTATEMENT);
4970 boolean jjtc000 = true;
4971 jjtree.openNodeScope(jjtn000);
4972 try {
4973 jj_consume_token(DO);
4974 Statement();
4975 jj_consume_token(WHILE);
4976 jj_consume_token(LPAREN);
4977 Expression();
4978 jj_consume_token(RPAREN);
4979 jj_consume_token(SEMICOLON);
4980 } catch (Throwable jjte000) {
4981 if (jjtc000) {
4982 jjtree.clearNodeScope(jjtn000);
4983 jjtc000 = false;
4984 } else {
4985 jjtree.popNode();
4986 }
4987 if (jjte000 instanceof RuntimeException) {
4988 {if (true) throw (RuntimeException)jjte000;}
4989 }
4990 if (jjte000 instanceof ParseException) {
4991 {if (true) throw (ParseException)jjte000;}
4992 }
4993 {if (true) throw (Error)jjte000;}
4994 } finally {
4995 if (jjtc000) {
4996 jjtree.closeNodeScope(jjtn000, true);
4997 }
4998 }
4999 }
5000
5001 final public void ForStatement() throws ParseException {
5002
5003 ASTForStatement jjtn000 = new ASTForStatement(this, JJTFORSTATEMENT);
5004 boolean jjtc000 = true;
5005 jjtree.openNodeScope(jjtn000);
5006 try {
5007 jj_consume_token(FOR);
5008 jj_consume_token(LPAREN);
5009 if (jj_2_67(2147483647)) {
5010 checkForBadJDK15ForLoopSyntaxArgumentsUsage();
5011 LocalVariableDeclaration();
5012 jj_consume_token(COLON);
5013 Expression();
5014 } else {
5015 switch (jj_nt.kind) {
5016 case BOOLEAN:
5017 case BYTE:
5018 case CHAR:
5019 case DOUBLE:
5020 case FALSE:
5021 case FINAL:
5022 case FLOAT:
5023 case INT:
5024 case LONG:
5025 case NEW:
5026 case NULL:
5027 case SHORT:
5028 case SUPER:
5029 case THIS:
5030 case TRUE:
5031 case VOID:
5032 case INTEGER_LITERAL:
5033 case FLOATING_POINT_LITERAL:
5034 case HEX_FLOATING_POINT_LITERAL:
5035 case CHARACTER_LITERAL:
5036 case STRING_LITERAL:
5037 case IDENTIFIER:
5038 case LPAREN:
5039 case SEMICOLON:
5040 case AT:
5041 case INCR:
5042 case DECR:
5043 switch (jj_nt.kind) {
5044 case BOOLEAN:
5045 case BYTE:
5046 case CHAR:
5047 case DOUBLE:
5048 case FALSE:
5049 case FINAL:
5050 case FLOAT:
5051 case INT:
5052 case LONG:
5053 case NEW:
5054 case NULL:
5055 case SHORT:
5056 case SUPER:
5057 case THIS:
5058 case TRUE:
5059 case VOID:
5060 case INTEGER_LITERAL:
5061 case FLOATING_POINT_LITERAL:
5062 case HEX_FLOATING_POINT_LITERAL:
5063 case CHARACTER_LITERAL:
5064 case STRING_LITERAL:
5065 case IDENTIFIER:
5066 case LPAREN:
5067 case AT:
5068 case INCR:
5069 case DECR:
5070 ForInit();
5071 break;
5072 default:
5073 jj_la1[125] = jj_gen;
5074 ;
5075 }
5076 jj_consume_token(SEMICOLON);
5077 switch (jj_nt.kind) {
5078 case BOOLEAN:
5079 case BYTE:
5080 case CHAR:
5081 case DOUBLE:
5082 case FALSE:
5083 case FLOAT:
5084 case INT:
5085 case LONG:
5086 case NEW:
5087 case NULL:
5088 case SHORT:
5089 case SUPER:
5090 case THIS:
5091 case TRUE:
5092 case VOID:
5093 case INTEGER_LITERAL:
5094 case FLOATING_POINT_LITERAL:
5095 case HEX_FLOATING_POINT_LITERAL:
5096 case CHARACTER_LITERAL:
5097 case STRING_LITERAL:
5098 case IDENTIFIER:
5099 case LPAREN:
5100 case BANG:
5101 case TILDE:
5102 case INCR:
5103 case DECR:
5104 case PLUS:
5105 case MINUS:
5106 Expression();
5107 break;
5108 default:
5109 jj_la1[126] = jj_gen;
5110 ;
5111 }
5112 jj_consume_token(SEMICOLON);
5113 switch (jj_nt.kind) {
5114 case BOOLEAN:
5115 case BYTE:
5116 case CHAR:
5117 case DOUBLE:
5118 case FALSE:
5119 case FLOAT:
5120 case INT:
5121 case LONG:
5122 case NEW:
5123 case NULL:
5124 case SHORT:
5125 case SUPER:
5126 case THIS:
5127 case TRUE:
5128 case VOID:
5129 case INTEGER_LITERAL:
5130 case FLOATING_POINT_LITERAL:
5131 case HEX_FLOATING_POINT_LITERAL:
5132 case CHARACTER_LITERAL:
5133 case STRING_LITERAL:
5134 case IDENTIFIER:
5135 case LPAREN:
5136 case INCR:
5137 case DECR:
5138 ForUpdate();
5139 break;
5140 default:
5141 jj_la1[127] = jj_gen;
5142 ;
5143 }
5144 break;
5145 default:
5146 jj_la1[128] = jj_gen;
5147 jj_consume_token(-1);
5148 throw new ParseException();
5149 }
5150 }
5151 jj_consume_token(RPAREN);
5152 Statement();
5153 } catch (Throwable jjte000) {
5154 if (jjtc000) {
5155 jjtree.clearNodeScope(jjtn000);
5156 jjtc000 = false;
5157 } else {
5158 jjtree.popNode();
5159 }
5160 if (jjte000 instanceof RuntimeException) {
5161 {if (true) throw (RuntimeException)jjte000;}
5162 }
5163 if (jjte000 instanceof ParseException) {
5164 {if (true) throw (ParseException)jjte000;}
5165 }
5166 {if (true) throw (Error)jjte000;}
5167 } finally {
5168 if (jjtc000) {
5169 jjtree.closeNodeScope(jjtn000, true);
5170 }
5171 }
5172 }
5173
5174 final public void ForInit() throws ParseException {
5175
5176 ASTForInit jjtn000 = new ASTForInit(this, JJTFORINIT);
5177 boolean jjtc000 = true;
5178 jjtree.openNodeScope(jjtn000);
5179 try {
5180 if (jj_2_68(2147483647)) {
5181 LocalVariableDeclaration();
5182 } else {
5183 switch (jj_nt.kind) {
5184 case BOOLEAN:
5185 case BYTE:
5186 case CHAR:
5187 case DOUBLE:
5188 case FALSE:
5189 case FLOAT:
5190 case INT:
5191 case LONG:
5192 case NEW:
5193 case NULL:
5194 case SHORT:
5195 case SUPER:
5196 case THIS:
5197 case TRUE:
5198 case VOID:
5199 case INTEGER_LITERAL:
5200 case FLOATING_POINT_LITERAL:
5201 case HEX_FLOATING_POINT_LITERAL:
5202 case CHARACTER_LITERAL:
5203 case STRING_LITERAL:
5204 case IDENTIFIER:
5205 case LPAREN:
5206 case INCR:
5207 case DECR:
5208 StatementExpressionList();
5209 break;
5210 default:
5211 jj_la1[129] = jj_gen;
5212 jj_consume_token(-1);
5213 throw new ParseException();
5214 }
5215 }
5216 } catch (Throwable jjte000) {
5217 if (jjtc000) {
5218 jjtree.clearNodeScope(jjtn000);
5219 jjtc000 = false;
5220 } else {
5221 jjtree.popNode();
5222 }
5223 if (jjte000 instanceof RuntimeException) {
5224 {if (true) throw (RuntimeException)jjte000;}
5225 }
5226 if (jjte000 instanceof ParseException) {
5227 {if (true) throw (ParseException)jjte000;}
5228 }
5229 {if (true) throw (Error)jjte000;}
5230 } finally {
5231 if (jjtc000) {
5232 jjtree.closeNodeScope(jjtn000, true);
5233 }
5234 }
5235 }
5236
5237 final public void StatementExpressionList() throws ParseException {
5238
5239 ASTStatementExpressionList jjtn000 = new ASTStatementExpressionList(this, JJTSTATEMENTEXPRESSIONLIST);
5240 boolean jjtc000 = true;
5241 jjtree.openNodeScope(jjtn000);
5242 try {
5243 StatementExpression();
5244 label_64:
5245 while (true) {
5246 switch (jj_nt.kind) {
5247 case COMMA:
5248 ;
5249 break;
5250 default:
5251 jj_la1[130] = jj_gen;
5252 break label_64;
5253 }
5254 jj_consume_token(COMMA);
5255 StatementExpression();
5256 }
5257 } catch (Throwable jjte000) {
5258 if (jjtc000) {
5259 jjtree.clearNodeScope(jjtn000);
5260 jjtc000 = false;
5261 } else {
5262 jjtree.popNode();
5263 }
5264 if (jjte000 instanceof RuntimeException) {
5265 {if (true) throw (RuntimeException)jjte000;}
5266 }
5267 if (jjte000 instanceof ParseException) {
5268 {if (true) throw (ParseException)jjte000;}
5269 }
5270 {if (true) throw (Error)jjte000;}
5271 } finally {
5272 if (jjtc000) {
5273 jjtree.closeNodeScope(jjtn000, true);
5274 }
5275 }
5276 }
5277
5278 final public void ForUpdate() throws ParseException {
5279
5280 ASTForUpdate jjtn000 = new ASTForUpdate(this, JJTFORUPDATE);
5281 boolean jjtc000 = true;
5282 jjtree.openNodeScope(jjtn000);
5283 try {
5284 StatementExpressionList();
5285 } catch (Throwable jjte000) {
5286 if (jjtc000) {
5287 jjtree.clearNodeScope(jjtn000);
5288 jjtc000 = false;
5289 } else {
5290 jjtree.popNode();
5291 }
5292 if (jjte000 instanceof RuntimeException) {
5293 {if (true) throw (RuntimeException)jjte000;}
5294 }
5295 if (jjte000 instanceof ParseException) {
5296 {if (true) throw (ParseException)jjte000;}
5297 }
5298 {if (true) throw (Error)jjte000;}
5299 } finally {
5300 if (jjtc000) {
5301 jjtree.closeNodeScope(jjtn000, true);
5302 }
5303 }
5304 }
5305
5306 final public void BreakStatement() throws ParseException {
5307
5308 ASTBreakStatement jjtn000 = new ASTBreakStatement(this, JJTBREAKSTATEMENT);
5309 boolean jjtc000 = true;
5310 jjtree.openNodeScope(jjtn000);Token t;
5311 try {
5312 jj_consume_token(BREAK);
5313 switch (jj_nt.kind) {
5314 case IDENTIFIER:
5315 t = jj_consume_token(IDENTIFIER);
5316 jjtn000.setImage(t.image);
5317 break;
5318 default:
5319 jj_la1[131] = jj_gen;
5320 ;
5321 }
5322 jj_consume_token(SEMICOLON);
5323 } finally {
5324 if (jjtc000) {
5325 jjtree.closeNodeScope(jjtn000, true);
5326 }
5327 }
5328 }
5329
5330 final public void ContinueStatement() throws ParseException {
5331
5332 ASTContinueStatement jjtn000 = new ASTContinueStatement(this, JJTCONTINUESTATEMENT);
5333 boolean jjtc000 = true;
5334 jjtree.openNodeScope(jjtn000);Token t;
5335 try {
5336 jj_consume_token(CONTINUE);
5337 switch (jj_nt.kind) {
5338 case IDENTIFIER:
5339 t = jj_consume_token(IDENTIFIER);
5340 jjtn000.setImage(t.image);
5341 break;
5342 default:
5343 jj_la1[132] = jj_gen;
5344 ;
5345 }
5346 jj_consume_token(SEMICOLON);
5347 } finally {
5348 if (jjtc000) {
5349 jjtree.closeNodeScope(jjtn000, true);
5350 }
5351 }
5352 }
5353
5354 final public void ReturnStatement() throws ParseException {
5355
5356 ASTReturnStatement jjtn000 = new ASTReturnStatement(this, JJTRETURNSTATEMENT);
5357 boolean jjtc000 = true;
5358 jjtree.openNodeScope(jjtn000);
5359 try {
5360 jj_consume_token(RETURN);
5361 switch (jj_nt.kind) {
5362 case BOOLEAN:
5363 case BYTE:
5364 case CHAR:
5365 case DOUBLE:
5366 case FALSE:
5367 case FLOAT:
5368 case INT:
5369 case LONG:
5370 case NEW:
5371 case NULL:
5372 case SHORT:
5373 case SUPER:
5374 case THIS:
5375 case TRUE:
5376 case VOID:
5377 case INTEGER_LITERAL:
5378 case FLOATING_POINT_LITERAL:
5379 case HEX_FLOATING_POINT_LITERAL:
5380 case CHARACTER_LITERAL:
5381 case STRING_LITERAL:
5382 case IDENTIFIER:
5383 case LPAREN:
5384 case BANG:
5385 case TILDE:
5386 case INCR:
5387 case DECR:
5388 case PLUS:
5389 case MINUS:
5390 Expression();
5391 break;
5392 default:
5393 jj_la1[133] = jj_gen;
5394 ;
5395 }
5396 jj_consume_token(SEMICOLON);
5397 } catch (Throwable jjte000) {
5398 if (jjtc000) {
5399 jjtree.clearNodeScope(jjtn000);
5400 jjtc000 = false;
5401 } else {
5402 jjtree.popNode();
5403 }
5404 if (jjte000 instanceof RuntimeException) {
5405 {if (true) throw (RuntimeException)jjte000;}
5406 }
5407 if (jjte000 instanceof ParseException) {
5408 {if (true) throw (ParseException)jjte000;}
5409 }
5410 {if (true) throw (Error)jjte000;}
5411 } finally {
5412 if (jjtc000) {
5413 jjtree.closeNodeScope(jjtn000, true);
5414 }
5415 }
5416 }
5417
5418 final public void ThrowStatement() throws ParseException {
5419
5420 ASTThrowStatement jjtn000 = new ASTThrowStatement(this, JJTTHROWSTATEMENT);
5421 boolean jjtc000 = true;
5422 jjtree.openNodeScope(jjtn000);
5423 try {
5424 jj_consume_token(THROW);
5425 Expression();
5426 jj_consume_token(SEMICOLON);
5427 } catch (Throwable jjte000) {
5428 if (jjtc000) {
5429 jjtree.clearNodeScope(jjtn000);
5430 jjtc000 = false;
5431 } else {
5432 jjtree.popNode();
5433 }
5434 if (jjte000 instanceof RuntimeException) {
5435 {if (true) throw (RuntimeException)jjte000;}
5436 }
5437 if (jjte000 instanceof ParseException) {
5438 {if (true) throw (ParseException)jjte000;}
5439 }
5440 {if (true) throw (Error)jjte000;}
5441 } finally {
5442 if (jjtc000) {
5443 jjtree.closeNodeScope(jjtn000, true);
5444 }
5445 }
5446 }
5447
5448 final public void SynchronizedStatement() throws ParseException {
5449
5450 ASTSynchronizedStatement jjtn000 = new ASTSynchronizedStatement(this, JJTSYNCHRONIZEDSTATEMENT);
5451 boolean jjtc000 = true;
5452 jjtree.openNodeScope(jjtn000);
5453 try {
5454 jj_consume_token(SYNCHRONIZED);
5455 jj_consume_token(LPAREN);
5456 Expression();
5457 jj_consume_token(RPAREN);
5458 Block();
5459 } catch (Throwable jjte000) {
5460 if (jjtc000) {
5461 jjtree.clearNodeScope(jjtn000);
5462 jjtc000 = false;
5463 } else {
5464 jjtree.popNode();
5465 }
5466 if (jjte000 instanceof RuntimeException) {
5467 {if (true) throw (RuntimeException)jjte000;}
5468 }
5469 if (jjte000 instanceof ParseException) {
5470 {if (true) throw (ParseException)jjte000;}
5471 }
5472 {if (true) throw (Error)jjte000;}
5473 } finally {
5474 if (jjtc000) {
5475 jjtree.closeNodeScope(jjtn000, true);
5476 }
5477 }
5478 }
5479
5480 final public void TryStatement() throws ParseException {
5481
5482 ASTTryStatement jjtn000 = new ASTTryStatement(this, JJTTRYSTATEMENT);
5483 boolean jjtc000 = true;
5484 jjtree.openNodeScope(jjtn000);
5485 try {
5486 jj_consume_token(TRY);
5487 switch (jj_nt.kind) {
5488 case LPAREN:
5489 ResourceSpecification();
5490 break;
5491 default:
5492 jj_la1[134] = jj_gen;
5493 ;
5494 }
5495 Block();
5496 label_65:
5497 while (true) {
5498 switch (jj_nt.kind) {
5499 case CATCH:
5500 ;
5501 break;
5502 default:
5503 jj_la1[135] = jj_gen;
5504 break label_65;
5505 }
5506 CatchStatement();
5507 }
5508 switch (jj_nt.kind) {
5509 case FINALLY:
5510 FinallyStatement();
5511 break;
5512 default:
5513 jj_la1[136] = jj_gen;
5514 ;
5515 }
5516 } catch (Throwable jjte000) {
5517 if (jjtc000) {
5518 jjtree.clearNodeScope(jjtn000);
5519 jjtc000 = false;
5520 } else {
5521 jjtree.popNode();
5522 }
5523 if (jjte000 instanceof RuntimeException) {
5524 {if (true) throw (RuntimeException)jjte000;}
5525 }
5526 if (jjte000 instanceof ParseException) {
5527 {if (true) throw (ParseException)jjte000;}
5528 }
5529 {if (true) throw (Error)jjte000;}
5530 } finally {
5531 if (jjtc000) {
5532 jjtree.closeNodeScope(jjtn000, true);
5533 }
5534 }
5535 }
5536
5537 final public void ResourceSpecification() throws ParseException {
5538
5539 ASTResourceSpecification jjtn000 = new ASTResourceSpecification(this, JJTRESOURCESPECIFICATION);
5540 boolean jjtc000 = true;
5541 jjtree.openNodeScope(jjtn000);
5542 try {
5543 checkForBadTryWithResourcesUsage();
5544 jj_consume_token(LPAREN);
5545 Resources();
5546 if (jj_2_69(2)) {
5547 jj_consume_token(SEMICOLON);
5548 } else {
5549 ;
5550 }
5551 jj_consume_token(RPAREN);
5552 } catch (Throwable jjte000) {
5553 if (jjtc000) {
5554 jjtree.clearNodeScope(jjtn000);
5555 jjtc000 = false;
5556 } else {
5557 jjtree.popNode();
5558 }
5559 if (jjte000 instanceof RuntimeException) {
5560 {if (true) throw (RuntimeException)jjte000;}
5561 }
5562 if (jjte000 instanceof ParseException) {
5563 {if (true) throw (ParseException)jjte000;}
5564 }
5565 {if (true) throw (Error)jjte000;}
5566 } finally {
5567 if (jjtc000) {
5568 jjtree.closeNodeScope(jjtn000, true);
5569 }
5570 }
5571 }
5572
5573 final public void Resources() throws ParseException {
5574
5575 ASTResources jjtn000 = new ASTResources(this, JJTRESOURCES);
5576 boolean jjtc000 = true;
5577 jjtree.openNodeScope(jjtn000);
5578 try {
5579 Resource();
5580 label_66:
5581 while (true) {
5582 if (jj_2_70(2)) {
5583 ;
5584 } else {
5585 break label_66;
5586 }
5587 jj_consume_token(SEMICOLON);
5588 Resource();
5589 }
5590 } catch (Throwable jjte000) {
5591 if (jjtc000) {
5592 jjtree.clearNodeScope(jjtn000);
5593 jjtc000 = false;
5594 } else {
5595 jjtree.popNode();
5596 }
5597 if (jjte000 instanceof RuntimeException) {
5598 {if (true) throw (RuntimeException)jjte000;}
5599 }
5600 if (jjte000 instanceof ParseException) {
5601 {if (true) throw (ParseException)jjte000;}
5602 }
5603 {if (true) throw (Error)jjte000;}
5604 } finally {
5605 if (jjtc000) {
5606 jjtree.closeNodeScope(jjtn000, true);
5607 }
5608 }
5609 }
5610
5611 final public void Resource() throws ParseException {
5612
5613 ASTResource jjtn000 = new ASTResource(this, JJTRESOURCE);
5614 boolean jjtc000 = true;
5615 jjtree.openNodeScope(jjtn000);
5616 try {
5617 label_67:
5618 while (true) {
5619 switch (jj_nt.kind) {
5620 case FINAL:
5621 case AT:
5622 ;
5623 break;
5624 default:
5625 jj_la1[137] = jj_gen;
5626 break label_67;
5627 }
5628 switch (jj_nt.kind) {
5629 case FINAL:
5630 jj_consume_token(FINAL);
5631 break;
5632 case AT:
5633 Annotation();
5634 break;
5635 default:
5636 jj_la1[138] = jj_gen;
5637 jj_consume_token(-1);
5638 throw new ParseException();
5639 }
5640 }
5641 Type();
5642 VariableDeclaratorId();
5643 jj_consume_token(ASSIGN);
5644 Expression();
5645 } catch (Throwable jjte000) {
5646 if (jjtc000) {
5647 jjtree.clearNodeScope(jjtn000);
5648 jjtc000 = false;
5649 } else {
5650 jjtree.popNode();
5651 }
5652 if (jjte000 instanceof RuntimeException) {
5653 {if (true) throw (RuntimeException)jjte000;}
5654 }
5655 if (jjte000 instanceof ParseException) {
5656 {if (true) throw (ParseException)jjte000;}
5657 }
5658 {if (true) throw (Error)jjte000;}
5659 } finally {
5660 if (jjtc000) {
5661 jjtree.closeNodeScope(jjtn000, true);
5662 }
5663 }
5664 }
5665
5666 final public void CatchStatement() throws ParseException {
5667
5668 ASTCatchStatement jjtn000 = new ASTCatchStatement(this, JJTCATCHSTATEMENT);
5669 boolean jjtc000 = true;
5670 jjtree.openNodeScope(jjtn000);
5671 try {
5672 jj_consume_token(CATCH);
5673 jj_consume_token(LPAREN);
5674 FormalParameter();
5675 jj_consume_token(RPAREN);
5676 Block();
5677 } catch (Throwable jjte000) {
5678 if (jjtc000) {
5679 jjtree.clearNodeScope(jjtn000);
5680 jjtc000 = false;
5681 } else {
5682 jjtree.popNode();
5683 }
5684 if (jjte000 instanceof RuntimeException) {
5685 {if (true) throw (RuntimeException)jjte000;}
5686 }
5687 if (jjte000 instanceof ParseException) {
5688 {if (true) throw (ParseException)jjte000;}
5689 }
5690 {if (true) throw (Error)jjte000;}
5691 } finally {
5692 if (jjtc000) {
5693 jjtree.closeNodeScope(jjtn000, true);
5694 }
5695 }
5696 }
5697
5698 final public void FinallyStatement() throws ParseException {
5699
5700 ASTFinallyStatement jjtn000 = new ASTFinallyStatement(this, JJTFINALLYSTATEMENT);
5701 boolean jjtc000 = true;
5702 jjtree.openNodeScope(jjtn000);
5703 try {
5704 jj_consume_token(FINALLY);
5705 Block();
5706 } catch (Throwable jjte000) {
5707 if (jjtc000) {
5708 jjtree.clearNodeScope(jjtn000);
5709 jjtc000 = false;
5710 } else {
5711 jjtree.popNode();
5712 }
5713 if (jjte000 instanceof RuntimeException) {
5714 {if (true) throw (RuntimeException)jjte000;}
5715 }
5716 if (jjte000 instanceof ParseException) {
5717 {if (true) throw (ParseException)jjte000;}
5718 }
5719 {if (true) throw (Error)jjte000;}
5720 } finally {
5721 if (jjtc000) {
5722 jjtree.closeNodeScope(jjtn000, true);
5723 }
5724 }
5725 }
5726
5727 final public void AssertStatement() throws ParseException {
5728
5729 ASTAssertStatement jjtn000 = new ASTAssertStatement(this, JJTASSERTSTATEMENT);
5730 boolean jjtc000 = true;
5731 jjtree.openNodeScope(jjtn000);if (jdkVersion <= 3) {
5732 throw new ParseException("Can't use 'assert' as a keyword when running in JDK 1.3 mode!");
5733 }
5734 try {
5735 jj_consume_token(IDENTIFIER);
5736 Expression();
5737 switch (jj_nt.kind) {
5738 case COLON:
5739 jj_consume_token(COLON);
5740 Expression();
5741 break;
5742 default:
5743 jj_la1[139] = jj_gen;
5744 ;
5745 }
5746 jj_consume_token(SEMICOLON);
5747 } catch (Throwable jjte000) {
5748 if (jjtc000) {
5749 jjtree.clearNodeScope(jjtn000);
5750 jjtc000 = false;
5751 } else {
5752 jjtree.popNode();
5753 }
5754 if (jjte000 instanceof RuntimeException) {
5755 {if (true) throw (RuntimeException)jjte000;}
5756 }
5757 if (jjte000 instanceof ParseException) {
5758 {if (true) throw (ParseException)jjte000;}
5759 }
5760 {if (true) throw (Error)jjte000;}
5761 } finally {
5762 if (jjtc000) {
5763 jjtree.closeNodeScope(jjtn000, true);
5764 }
5765 }
5766 }
5767
5768
5769
5770
5771 final public void RUNSIGNEDSHIFT() throws ParseException {
5772
5773 ASTRUNSIGNEDSHIFT jjtn000 = new ASTRUNSIGNEDSHIFT(this, JJTRUNSIGNEDSHIFT);
5774 boolean jjtc000 = true;
5775 jjtree.openNodeScope(jjtn000);
5776 try {
5777 if (getToken(1).kind == GT &&
5778 ((Token.GTToken)getToken(1)).realKind == RUNSIGNEDSHIFT) {
5779
5780 } else {
5781 jj_consume_token(-1);
5782 throw new ParseException();
5783 }
5784 jj_consume_token(GT);
5785 jj_consume_token(GT);
5786 jj_consume_token(GT);
5787 } finally {
5788 if (jjtc000) {
5789 jjtree.closeNodeScope(jjtn000, true);
5790 }
5791 }
5792 }
5793
5794 final public void RSIGNEDSHIFT() throws ParseException {
5795
5796 ASTRSIGNEDSHIFT jjtn000 = new ASTRSIGNEDSHIFT(this, JJTRSIGNEDSHIFT);
5797 boolean jjtc000 = true;
5798 jjtree.openNodeScope(jjtn000);
5799 try {
5800 if (getToken(1).kind == GT &&
5801 ((Token.GTToken)getToken(1)).realKind == RSIGNEDSHIFT) {
5802
5803 } else {
5804 jj_consume_token(-1);
5805 throw new ParseException();
5806 }
5807 jj_consume_token(GT);
5808 jj_consume_token(GT);
5809 } finally {
5810 if (jjtc000) {
5811 jjtree.closeNodeScope(jjtn000, true);
5812 }
5813 }
5814 }
5815
5816
5817 final public void Annotation() throws ParseException {
5818
5819 ASTAnnotation jjtn000 = new ASTAnnotation(this, JJTANNOTATION);
5820 boolean jjtc000 = true;
5821 jjtree.openNodeScope(jjtn000);
5822 try {
5823 if (jj_2_71(2147483647)) {
5824 NormalAnnotation();
5825 } else if (jj_2_72(2147483647)) {
5826 SingleMemberAnnotation();
5827 } else {
5828 switch (jj_nt.kind) {
5829 case AT:
5830 MarkerAnnotation();
5831 break;
5832 default:
5833 jj_la1[140] = jj_gen;
5834 jj_consume_token(-1);
5835 throw new ParseException();
5836 }
5837 }
5838 } catch (Throwable jjte000) {
5839 if (jjtc000) {
5840 jjtree.clearNodeScope(jjtn000);
5841 jjtc000 = false;
5842 } else {
5843 jjtree.popNode();
5844 }
5845 if (jjte000 instanceof RuntimeException) {
5846 {if (true) throw (RuntimeException)jjte000;}
5847 }
5848 if (jjte000 instanceof ParseException) {
5849 {if (true) throw (ParseException)jjte000;}
5850 }
5851 {if (true) throw (Error)jjte000;}
5852 } finally {
5853 if (jjtc000) {
5854 jjtree.closeNodeScope(jjtn000, true);
5855 }
5856 }
5857 }
5858
5859 final public void NormalAnnotation() throws ParseException {
5860
5861 ASTNormalAnnotation jjtn000 = new ASTNormalAnnotation(this, JJTNORMALANNOTATION);
5862 boolean jjtc000 = true;
5863 jjtree.openNodeScope(jjtn000);
5864 try {
5865 jj_consume_token(AT);
5866 Name();
5867 jj_consume_token(LPAREN);
5868 switch (jj_nt.kind) {
5869 case IDENTIFIER:
5870 MemberValuePairs();
5871 break;
5872 default:
5873 jj_la1[141] = jj_gen;
5874 ;
5875 }
5876 jj_consume_token(RPAREN);
5877 jjtree.closeNodeScope(jjtn000, true);
5878 jjtc000 = false;
5879 checkForBadAnnotationUsage();
5880 } catch (Throwable jjte000) {
5881 if (jjtc000) {
5882 jjtree.clearNodeScope(jjtn000);
5883 jjtc000 = false;
5884 } else {
5885 jjtree.popNode();
5886 }
5887 if (jjte000 instanceof RuntimeException) {
5888 {if (true) throw (RuntimeException)jjte000;}
5889 }
5890 if (jjte000 instanceof ParseException) {
5891 {if (true) throw (ParseException)jjte000;}
5892 }
5893 {if (true) throw (Error)jjte000;}
5894 } finally {
5895 if (jjtc000) {
5896 jjtree.closeNodeScope(jjtn000, true);
5897 }
5898 }
5899 }
5900
5901 final public void MarkerAnnotation() throws ParseException {
5902
5903 ASTMarkerAnnotation jjtn000 = new ASTMarkerAnnotation(this, JJTMARKERANNOTATION);
5904 boolean jjtc000 = true;
5905 jjtree.openNodeScope(jjtn000);
5906 try {
5907 jj_consume_token(AT);
5908 Name();
5909 jjtree.closeNodeScope(jjtn000, true);
5910 jjtc000 = false;
5911 checkForBadAnnotationUsage();
5912 } catch (Throwable jjte000) {
5913 if (jjtc000) {
5914 jjtree.clearNodeScope(jjtn000);
5915 jjtc000 = false;
5916 } else {
5917 jjtree.popNode();
5918 }
5919 if (jjte000 instanceof RuntimeException) {
5920 {if (true) throw (RuntimeException)jjte000;}
5921 }
5922 if (jjte000 instanceof ParseException) {
5923 {if (true) throw (ParseException)jjte000;}
5924 }
5925 {if (true) throw (Error)jjte000;}
5926 } finally {
5927 if (jjtc000) {
5928 jjtree.closeNodeScope(jjtn000, true);
5929 }
5930 }
5931 }
5932
5933 final public void SingleMemberAnnotation() throws ParseException {
5934
5935 ASTSingleMemberAnnotation jjtn000 = new ASTSingleMemberAnnotation(this, JJTSINGLEMEMBERANNOTATION);
5936 boolean jjtc000 = true;
5937 jjtree.openNodeScope(jjtn000);
5938 try {
5939 jj_consume_token(AT);
5940 Name();
5941 jj_consume_token(LPAREN);
5942 MemberValue();
5943 jj_consume_token(RPAREN);
5944 jjtree.closeNodeScope(jjtn000, true);
5945 jjtc000 = false;
5946 checkForBadAnnotationUsage();
5947 } catch (Throwable jjte000) {
5948 if (jjtc000) {
5949 jjtree.clearNodeScope(jjtn000);
5950 jjtc000 = false;
5951 } else {
5952 jjtree.popNode();
5953 }
5954 if (jjte000 instanceof RuntimeException) {
5955 {if (true) throw (RuntimeException)jjte000;}
5956 }
5957 if (jjte000 instanceof ParseException) {
5958 {if (true) throw (ParseException)jjte000;}
5959 }
5960 {if (true) throw (Error)jjte000;}
5961 } finally {
5962 if (jjtc000) {
5963 jjtree.closeNodeScope(jjtn000, true);
5964 }
5965 }
5966 }
5967
5968 final public void MemberValuePairs() throws ParseException {
5969
5970 ASTMemberValuePairs jjtn000 = new ASTMemberValuePairs(this, JJTMEMBERVALUEPAIRS);
5971 boolean jjtc000 = true;
5972 jjtree.openNodeScope(jjtn000);
5973 try {
5974 MemberValuePair();
5975 label_68:
5976 while (true) {
5977 switch (jj_nt.kind) {
5978 case COMMA:
5979 ;
5980 break;
5981 default:
5982 jj_la1[142] = jj_gen;
5983 break label_68;
5984 }
5985 jj_consume_token(COMMA);
5986 MemberValuePair();
5987 }
5988 } catch (Throwable jjte000) {
5989 if (jjtc000) {
5990 jjtree.clearNodeScope(jjtn000);
5991 jjtc000 = false;
5992 } else {
5993 jjtree.popNode();
5994 }
5995 if (jjte000 instanceof RuntimeException) {
5996 {if (true) throw (RuntimeException)jjte000;}
5997 }
5998 if (jjte000 instanceof ParseException) {
5999 {if (true) throw (ParseException)jjte000;}
6000 }
6001 {if (true) throw (Error)jjte000;}
6002 } finally {
6003 if (jjtc000) {
6004 jjtree.closeNodeScope(jjtn000, true);
6005 }
6006 }
6007 }
6008
6009 final public void MemberValuePair() throws ParseException {
6010
6011 ASTMemberValuePair jjtn000 = new ASTMemberValuePair(this, JJTMEMBERVALUEPAIR);
6012 boolean jjtc000 = true;
6013 jjtree.openNodeScope(jjtn000);Token t;
6014 try {
6015 t = jj_consume_token(IDENTIFIER);
6016 jjtn000.setImage(t.image);
6017 jj_consume_token(ASSIGN);
6018 MemberValue();
6019 } catch (Throwable jjte000) {
6020 if (jjtc000) {
6021 jjtree.clearNodeScope(jjtn000);
6022 jjtc000 = false;
6023 } else {
6024 jjtree.popNode();
6025 }
6026 if (jjte000 instanceof RuntimeException) {
6027 {if (true) throw (RuntimeException)jjte000;}
6028 }
6029 if (jjte000 instanceof ParseException) {
6030 {if (true) throw (ParseException)jjte000;}
6031 }
6032 {if (true) throw (Error)jjte000;}
6033 } finally {
6034 if (jjtc000) {
6035 jjtree.closeNodeScope(jjtn000, true);
6036 }
6037 }
6038 }
6039
6040 final public void MemberValue() throws ParseException {
6041
6042 ASTMemberValue jjtn000 = new ASTMemberValue(this, JJTMEMBERVALUE);
6043 boolean jjtc000 = true;
6044 jjtree.openNodeScope(jjtn000);
6045 try {
6046 switch (jj_nt.kind) {
6047 case AT:
6048 Annotation();
6049 break;
6050 case LBRACE:
6051 MemberValueArrayInitializer();
6052 break;
6053 case BOOLEAN:
6054 case BYTE:
6055 case CHAR:
6056 case DOUBLE:
6057 case FALSE:
6058 case FLOAT:
6059 case INT:
6060 case LONG:
6061 case NEW:
6062 case NULL:
6063 case SHORT:
6064 case SUPER:
6065 case THIS:
6066 case TRUE:
6067 case VOID:
6068 case INTEGER_LITERAL:
6069 case FLOATING_POINT_LITERAL:
6070 case HEX_FLOATING_POINT_LITERAL:
6071 case CHARACTER_LITERAL:
6072 case STRING_LITERAL:
6073 case IDENTIFIER:
6074 case LPAREN:
6075 case BANG:
6076 case TILDE:
6077 case INCR:
6078 case DECR:
6079 case PLUS:
6080 case MINUS:
6081 ConditionalExpression();
6082 break;
6083 default:
6084 jj_la1[143] = jj_gen;
6085 jj_consume_token(-1);
6086 throw new ParseException();
6087 }
6088 } catch (Throwable jjte000) {
6089 if (jjtc000) {
6090 jjtree.clearNodeScope(jjtn000);
6091 jjtc000 = false;
6092 } else {
6093 jjtree.popNode();
6094 }
6095 if (jjte000 instanceof RuntimeException) {
6096 {if (true) throw (RuntimeException)jjte000;}
6097 }
6098 if (jjte000 instanceof ParseException) {
6099 {if (true) throw (ParseException)jjte000;}
6100 }
6101 {if (true) throw (Error)jjte000;}
6102 } finally {
6103 if (jjtc000) {
6104 jjtree.closeNodeScope(jjtn000, true);
6105 }
6106 }
6107 }
6108
6109 final public void MemberValueArrayInitializer() throws ParseException {
6110
6111 ASTMemberValueArrayInitializer jjtn000 = new ASTMemberValueArrayInitializer(this, JJTMEMBERVALUEARRAYINITIALIZER);
6112 boolean jjtc000 = true;
6113 jjtree.openNodeScope(jjtn000);
6114 try {
6115 jj_consume_token(LBRACE);
6116 switch (jj_nt.kind) {
6117 case BOOLEAN:
6118 case BYTE:
6119 case CHAR:
6120 case DOUBLE:
6121 case FALSE:
6122 case FLOAT:
6123 case INT:
6124 case LONG:
6125 case NEW:
6126 case NULL:
6127 case SHORT:
6128 case SUPER:
6129 case THIS:
6130 case TRUE:
6131 case VOID:
6132 case INTEGER_LITERAL:
6133 case FLOATING_POINT_LITERAL:
6134 case HEX_FLOATING_POINT_LITERAL:
6135 case CHARACTER_LITERAL:
6136 case STRING_LITERAL:
6137 case IDENTIFIER:
6138 case LPAREN:
6139 case LBRACE:
6140 case AT:
6141 case BANG:
6142 case TILDE:
6143 case INCR:
6144 case DECR:
6145 case PLUS:
6146 case MINUS:
6147 MemberValue();
6148 label_69:
6149 while (true) {
6150 if (jj_2_73(2)) {
6151 ;
6152 } else {
6153 break label_69;
6154 }
6155 jj_consume_token(COMMA);
6156 MemberValue();
6157 }
6158 switch (jj_nt.kind) {
6159 case COMMA:
6160 jj_consume_token(COMMA);
6161 break;
6162 default:
6163 jj_la1[144] = jj_gen;
6164 ;
6165 }
6166 break;
6167 default:
6168 jj_la1[145] = jj_gen;
6169 ;
6170 }
6171 jj_consume_token(RBRACE);
6172 } catch (Throwable jjte000) {
6173 if (jjtc000) {
6174 jjtree.clearNodeScope(jjtn000);
6175 jjtc000 = false;
6176 } else {
6177 jjtree.popNode();
6178 }
6179 if (jjte000 instanceof RuntimeException) {
6180 {if (true) throw (RuntimeException)jjte000;}
6181 }
6182 if (jjte000 instanceof ParseException) {
6183 {if (true) throw (ParseException)jjte000;}
6184 }
6185 {if (true) throw (Error)jjte000;}
6186 } finally {
6187 if (jjtc000) {
6188 jjtree.closeNodeScope(jjtn000, true);
6189 }
6190 }
6191 }
6192
6193
6194 final public void AnnotationTypeDeclaration(int modifiers) throws ParseException {
6195
6196 ASTAnnotationTypeDeclaration jjtn000 = new ASTAnnotationTypeDeclaration(this, JJTANNOTATIONTYPEDECLARATION);
6197 boolean jjtc000 = true;
6198 jjtree.openNodeScope(jjtn000);Token t;
6199 jjtn000.setModifiers(modifiers);
6200 try {
6201 jj_consume_token(AT);
6202 jj_consume_token(INTERFACE);
6203 t = jj_consume_token(IDENTIFIER);
6204 checkForBadAnnotationUsage();jjtn000.setImage(t.image);
6205 AnnotationTypeBody();
6206 } catch (Throwable jjte000) {
6207 if (jjtc000) {
6208 jjtree.clearNodeScope(jjtn000);
6209 jjtc000 = false;
6210 } else {
6211 jjtree.popNode();
6212 }
6213 if (jjte000 instanceof RuntimeException) {
6214 {if (true) throw (RuntimeException)jjte000;}
6215 }
6216 if (jjte000 instanceof ParseException) {
6217 {if (true) throw (ParseException)jjte000;}
6218 }
6219 {if (true) throw (Error)jjte000;}
6220 } finally {
6221 if (jjtc000) {
6222 jjtree.closeNodeScope(jjtn000, true);
6223 }
6224 }
6225 }
6226
6227 final public void AnnotationTypeBody() throws ParseException {
6228
6229 ASTAnnotationTypeBody jjtn000 = new ASTAnnotationTypeBody(this, JJTANNOTATIONTYPEBODY);
6230 boolean jjtc000 = true;
6231 jjtree.openNodeScope(jjtn000);
6232 try {
6233 jj_consume_token(LBRACE);
6234 label_70:
6235 while (true) {
6236 switch (jj_nt.kind) {
6237 case ABSTRACT:
6238 case BOOLEAN:
6239 case BYTE:
6240 case CHAR:
6241 case CLASS:
6242 case _DEFAULT:
6243 case DOUBLE:
6244 case FINAL:
6245 case FLOAT:
6246 case INT:
6247 case INTERFACE:
6248 case LONG:
6249 case NATIVE:
6250 case PRIVATE:
6251 case PROTECTED:
6252 case PUBLIC:
6253 case SHORT:
6254 case STATIC:
6255 case SYNCHRONIZED:
6256 case TRANSIENT:
6257 case VOLATILE:
6258 case STRICTFP:
6259 case IDENTIFIER:
6260 case SEMICOLON:
6261 case AT:
6262 ;
6263 break;
6264 default:
6265 jj_la1[146] = jj_gen;
6266 break label_70;
6267 }
6268 AnnotationTypeMemberDeclaration();
6269 }
6270 jj_consume_token(RBRACE);
6271 } catch (Throwable jjte000) {
6272 if (jjtc000) {
6273 jjtree.clearNodeScope(jjtn000);
6274 jjtc000 = false;
6275 } else {
6276 jjtree.popNode();
6277 }
6278 if (jjte000 instanceof RuntimeException) {
6279 {if (true) throw (RuntimeException)jjte000;}
6280 }
6281 if (jjte000 instanceof ParseException) {
6282 {if (true) throw (ParseException)jjte000;}
6283 }
6284 {if (true) throw (Error)jjte000;}
6285 } finally {
6286 if (jjtc000) {
6287 jjtree.closeNodeScope(jjtn000, true);
6288 }
6289 }
6290 }
6291
6292 final public void AnnotationTypeMemberDeclaration() throws ParseException {
6293
6294 ASTAnnotationTypeMemberDeclaration jjtn000 = new ASTAnnotationTypeMemberDeclaration(this, JJTANNOTATIONTYPEMEMBERDECLARATION);
6295 boolean jjtc000 = true;
6296 jjtree.openNodeScope(jjtn000);int modifiers;
6297 try {
6298 switch (jj_nt.kind) {
6299 case ABSTRACT:
6300 case BOOLEAN:
6301 case BYTE:
6302 case CHAR:
6303 case CLASS:
6304 case _DEFAULT:
6305 case DOUBLE:
6306 case FINAL:
6307 case FLOAT:
6308 case INT:
6309 case INTERFACE:
6310 case LONG:
6311 case NATIVE:
6312 case PRIVATE:
6313 case PROTECTED:
6314 case PUBLIC:
6315 case SHORT:
6316 case STATIC:
6317 case SYNCHRONIZED:
6318 case TRANSIENT:
6319 case VOLATILE:
6320 case STRICTFP:
6321 case IDENTIFIER:
6322 case AT:
6323 modifiers = Modifiers();
6324 if (jj_2_74(3)) {
6325 AnnotationMethodDeclaration(modifiers);
6326 } else {
6327 switch (jj_nt.kind) {
6328 case ABSTRACT:
6329 case CLASS:
6330 case FINAL:
6331 case INTERFACE:
6332 ClassOrInterfaceDeclaration(modifiers);
6333 break;
6334 default:
6335 jj_la1[147] = jj_gen;
6336 if (jj_2_75(3)) {
6337 EnumDeclaration(modifiers);
6338 } else {
6339 switch (jj_nt.kind) {
6340 case AT:
6341 AnnotationTypeDeclaration(modifiers);
6342 break;
6343 case BOOLEAN:
6344 case BYTE:
6345 case CHAR:
6346 case DOUBLE:
6347 case FLOAT:
6348 case INT:
6349 case LONG:
6350 case SHORT:
6351 case IDENTIFIER:
6352 FieldDeclaration(modifiers);
6353 break;
6354 default:
6355 jj_la1[148] = jj_gen;
6356 jj_consume_token(-1);
6357 throw new ParseException();
6358 }
6359 }
6360 }
6361 }
6362 break;
6363 case SEMICOLON:
6364 jj_consume_token(SEMICOLON);
6365 break;
6366 default:
6367 jj_la1[149] = jj_gen;
6368 jj_consume_token(-1);
6369 throw new ParseException();
6370 }
6371 } catch (Throwable jjte000) {
6372 if (jjtc000) {
6373 jjtree.clearNodeScope(jjtn000);
6374 jjtc000 = false;
6375 } else {
6376 jjtree.popNode();
6377 }
6378 if (jjte000 instanceof RuntimeException) {
6379 {if (true) throw (RuntimeException)jjte000;}
6380 }
6381 if (jjte000 instanceof ParseException) {
6382 {if (true) throw (ParseException)jjte000;}
6383 }
6384 {if (true) throw (Error)jjte000;}
6385 } finally {
6386 if (jjtc000) {
6387 jjtree.closeNodeScope(jjtn000, true);
6388 }
6389 }
6390 }
6391
6392 final public void AnnotationMethodDeclaration(int modifiers) throws ParseException {
6393
6394 ASTAnnotationMethodDeclaration jjtn000 = new ASTAnnotationMethodDeclaration(this, JJTANNOTATIONMETHODDECLARATION);
6395 boolean jjtc000 = true;
6396 jjtree.openNodeScope(jjtn000);Token t;
6397 jjtn000.setModifiers(modifiers);
6398 try {
6399 Type();
6400 t = jj_consume_token(IDENTIFIER);
6401 jj_consume_token(LPAREN);
6402 jj_consume_token(RPAREN);
6403 switch (jj_nt.kind) {
6404 case _DEFAULT:
6405 DefaultValue();
6406 break;
6407 default:
6408 jj_la1[150] = jj_gen;
6409 ;
6410 }
6411 jj_consume_token(SEMICOLON);
6412 jjtree.closeNodeScope(jjtn000, true);
6413 jjtc000 = false;
6414 jjtn000.setImage(t.image);
6415 } catch (Throwable jjte000) {
6416 if (jjtc000) {
6417 jjtree.clearNodeScope(jjtn000);
6418 jjtc000 = false;
6419 } else {
6420 jjtree.popNode();
6421 }
6422 if (jjte000 instanceof RuntimeException) {
6423 {if (true) throw (RuntimeException)jjte000;}
6424 }
6425 if (jjte000 instanceof ParseException) {
6426 {if (true) throw (ParseException)jjte000;}
6427 }
6428 {if (true) throw (Error)jjte000;}
6429 } finally {
6430 if (jjtc000) {
6431 jjtree.closeNodeScope(jjtn000, true);
6432 }
6433 }
6434 }
6435
6436 final public void DefaultValue() throws ParseException {
6437
6438 ASTDefaultValue jjtn000 = new ASTDefaultValue(this, JJTDEFAULTVALUE);
6439 boolean jjtc000 = true;
6440 jjtree.openNodeScope(jjtn000);
6441 try {
6442 jj_consume_token(_DEFAULT);
6443 MemberValue();
6444 } catch (Throwable jjte000) {
6445 if (jjtc000) {
6446 jjtree.clearNodeScope(jjtn000);
6447 jjtc000 = false;
6448 } else {
6449 jjtree.popNode();
6450 }
6451 if (jjte000 instanceof RuntimeException) {
6452 {if (true) throw (RuntimeException)jjte000;}
6453 }
6454 if (jjte000 instanceof ParseException) {
6455 {if (true) throw (ParseException)jjte000;}
6456 }
6457 {if (true) throw (Error)jjte000;}
6458 } finally {
6459 if (jjtc000) {
6460 jjtree.closeNodeScope(jjtn000, true);
6461 }
6462 }
6463 }
6464
6465 private boolean jj_2_1(int xla) {
6466 jj_la = xla; jj_lastpos = jj_scanpos = token;
6467 try { return !jj_3_1(); }
6468 catch(LookaheadSuccess ls) { return true; }
6469 finally { jj_save(0, xla); }
6470 }
6471
6472 private boolean jj_2_2(int xla) {
6473 jj_la = xla; jj_lastpos = jj_scanpos = token;
6474 try { return !jj_3_2(); }
6475 catch(LookaheadSuccess ls) { return true; }
6476 finally { jj_save(1, xla); }
6477 }
6478
6479 private boolean jj_2_3(int xla) {
6480 jj_la = xla; jj_lastpos = jj_scanpos = token;
6481 try { return !jj_3_3(); }
6482 catch(LookaheadSuccess ls) { return true; }
6483 finally { jj_save(2, xla); }
6484 }
6485
6486 private boolean jj_2_4(int xla) {
6487 jj_la = xla; jj_lastpos = jj_scanpos = token;
6488 try { return !jj_3_4(); }
6489 catch(LookaheadSuccess ls) { return true; }
6490 finally { jj_save(3, xla); }
6491 }
6492
6493 private boolean jj_2_5(int xla) {
6494 jj_la = xla; jj_lastpos = jj_scanpos = token;
6495 try { return !jj_3_5(); }
6496 catch(LookaheadSuccess ls) { return true; }
6497 finally { jj_save(4, xla); }
6498 }
6499
6500 private boolean jj_2_6(int xla) {
6501 jj_la = xla; jj_lastpos = jj_scanpos = token;
6502 try { return !jj_3_6(); }
6503 catch(LookaheadSuccess ls) { return true; }
6504 finally { jj_save(5, xla); }
6505 }
6506
6507 private boolean jj_2_7(int xla) {
6508 jj_la = xla; jj_lastpos = jj_scanpos = token;
6509 try { return !jj_3_7(); }
6510 catch(LookaheadSuccess ls) { return true; }
6511 finally { jj_save(6, xla); }
6512 }
6513
6514 private boolean jj_2_8(int xla) {
6515 jj_la = xla; jj_lastpos = jj_scanpos = token;
6516 try { return !jj_3_8(); }
6517 catch(LookaheadSuccess ls) { return true; }
6518 finally { jj_save(7, xla); }
6519 }
6520
6521 private boolean jj_2_9(int xla) {
6522 jj_la = xla; jj_lastpos = jj_scanpos = token;
6523 try { return !jj_3_9(); }
6524 catch(LookaheadSuccess ls) { return true; }
6525 finally { jj_save(8, xla); }
6526 }
6527
6528 private boolean jj_2_10(int xla) {
6529 jj_la = xla; jj_lastpos = jj_scanpos = token;
6530 try { return !jj_3_10(); }
6531 catch(LookaheadSuccess ls) { return true; }
6532 finally { jj_save(9, xla); }
6533 }
6534
6535 private boolean jj_2_11(int xla) {
6536 jj_la = xla; jj_lastpos = jj_scanpos = token;
6537 try { return !jj_3_11(); }
6538 catch(LookaheadSuccess ls) { return true; }
6539 finally { jj_save(10, xla); }
6540 }
6541
6542 private boolean jj_2_12(int xla) {
6543 jj_la = xla; jj_lastpos = jj_scanpos = token;
6544 try { return !jj_3_12(); }
6545 catch(LookaheadSuccess ls) { return true; }
6546 finally { jj_save(11, xla); }
6547 }
6548
6549 private boolean jj_2_13(int xla) {
6550 jj_la = xla; jj_lastpos = jj_scanpos = token;
6551 try { return !jj_3_13(); }
6552 catch(LookaheadSuccess ls) { return true; }
6553 finally { jj_save(12, xla); }
6554 }
6555
6556 private boolean jj_2_14(int xla) {
6557 jj_la = xla; jj_lastpos = jj_scanpos = token;
6558 try { return !jj_3_14(); }
6559 catch(LookaheadSuccess ls) { return true; }
6560 finally { jj_save(13, xla); }
6561 }
6562
6563 private boolean jj_2_15(int xla) {
6564 jj_la = xla; jj_lastpos = jj_scanpos = token;
6565 try { return !jj_3_15(); }
6566 catch(LookaheadSuccess ls) { return true; }
6567 finally { jj_save(14, xla); }
6568 }
6569
6570 private boolean jj_2_16(int xla) {
6571 jj_la = xla; jj_lastpos = jj_scanpos = token;
6572 try { return !jj_3_16(); }
6573 catch(LookaheadSuccess ls) { return true; }
6574 finally { jj_save(15, xla); }
6575 }
6576
6577 private boolean jj_2_17(int xla) {
6578 jj_la = xla; jj_lastpos = jj_scanpos = token;
6579 try { return !jj_3_17(); }
6580 catch(LookaheadSuccess ls) { return true; }
6581 finally { jj_save(16, xla); }
6582 }
6583
6584 private boolean jj_2_18(int xla) {
6585 jj_la = xla; jj_lastpos = jj_scanpos = token;
6586 try { return !jj_3_18(); }
6587 catch(LookaheadSuccess ls) { return true; }
6588 finally { jj_save(17, xla); }
6589 }
6590
6591 private boolean jj_2_19(int xla) {
6592 jj_la = xla; jj_lastpos = jj_scanpos = token;
6593 try { return !jj_3_19(); }
6594 catch(LookaheadSuccess ls) { return true; }
6595 finally { jj_save(18, xla); }
6596 }
6597
6598 private boolean jj_2_20(int xla) {
6599 jj_la = xla; jj_lastpos = jj_scanpos = token;
6600 try { return !jj_3_20(); }
6601 catch(LookaheadSuccess ls) { return true; }
6602 finally { jj_save(19, xla); }
6603 }
6604
6605 private boolean jj_2_21(int xla) {
6606 jj_la = xla; jj_lastpos = jj_scanpos = token;
6607 try { return !jj_3_21(); }
6608 catch(LookaheadSuccess ls) { return true; }
6609 finally { jj_save(20, xla); }
6610 }
6611
6612 private boolean jj_2_22(int xla) {
6613 jj_la = xla; jj_lastpos = jj_scanpos = token;
6614 try { return !jj_3_22(); }
6615 catch(LookaheadSuccess ls) { return true; }
6616 finally { jj_save(21, xla); }
6617 }
6618
6619 private boolean jj_2_23(int xla) {
6620 jj_la = xla; jj_lastpos = jj_scanpos = token;
6621 try { return !jj_3_23(); }
6622 catch(LookaheadSuccess ls) { return true; }
6623 finally { jj_save(22, xla); }
6624 }
6625
6626 private boolean jj_2_24(int xla) {
6627 jj_la = xla; jj_lastpos = jj_scanpos = token;
6628 try { return !jj_3_24(); }
6629 catch(LookaheadSuccess ls) { return true; }
6630 finally { jj_save(23, xla); }
6631 }
6632
6633 private boolean jj_2_25(int xla) {
6634 jj_la = xla; jj_lastpos = jj_scanpos = token;
6635 try { return !jj_3_25(); }
6636 catch(LookaheadSuccess ls) { return true; }
6637 finally { jj_save(24, xla); }
6638 }
6639
6640 private boolean jj_2_26(int xla) {
6641 jj_la = xla; jj_lastpos = jj_scanpos = token;
6642 try { return !jj_3_26(); }
6643 catch(LookaheadSuccess ls) { return true; }
6644 finally { jj_save(25, xla); }
6645 }
6646
6647 private boolean jj_2_27(int xla) {
6648 jj_la = xla; jj_lastpos = jj_scanpos = token;
6649 try { return !jj_3_27(); }
6650 catch(LookaheadSuccess ls) { return true; }
6651 finally { jj_save(26, xla); }
6652 }
6653
6654 private boolean jj_2_28(int xla) {
6655 jj_la = xla; jj_lastpos = jj_scanpos = token;
6656 try { return !jj_3_28(); }
6657 catch(LookaheadSuccess ls) { return true; }
6658 finally { jj_save(27, xla); }
6659 }
6660
6661 private boolean jj_2_29(int xla) {
6662 jj_la = xla; jj_lastpos = jj_scanpos = token;
6663 try { return !jj_3_29(); }
6664 catch(LookaheadSuccess ls) { return true; }
6665 finally { jj_save(28, xla); }
6666 }
6667
6668 private boolean jj_2_30(int xla) {
6669 jj_la = xla; jj_lastpos = jj_scanpos = token;
6670 try { return !jj_3_30(); }
6671 catch(LookaheadSuccess ls) { return true; }
6672 finally { jj_save(29, xla); }
6673 }
6674
6675 private boolean jj_2_31(int xla) {
6676 jj_la = xla; jj_lastpos = jj_scanpos = token;
6677 try { return !jj_3_31(); }
6678 catch(LookaheadSuccess ls) { return true; }
6679 finally { jj_save(30, xla); }
6680 }
6681
6682 private boolean jj_2_32(int xla) {
6683 jj_la = xla; jj_lastpos = jj_scanpos = token;
6684 try { return !jj_3_32(); }
6685 catch(LookaheadSuccess ls) { return true; }
6686 finally { jj_save(31, xla); }
6687 }
6688
6689 private boolean jj_2_33(int xla) {
6690 jj_la = xla; jj_lastpos = jj_scanpos = token;
6691 try { return !jj_3_33(); }
6692 catch(LookaheadSuccess ls) { return true; }
6693 finally { jj_save(32, xla); }
6694 }
6695
6696 private boolean jj_2_34(int xla) {
6697 jj_la = xla; jj_lastpos = jj_scanpos = token;
6698 try { return !jj_3_34(); }
6699 catch(LookaheadSuccess ls) { return true; }
6700 finally { jj_save(33, xla); }
6701 }
6702
6703 private boolean jj_2_35(int xla) {
6704 jj_la = xla; jj_lastpos = jj_scanpos = token;
6705 try { return !jj_3_35(); }
6706 catch(LookaheadSuccess ls) { return true; }
6707 finally { jj_save(34, xla); }
6708 }
6709
6710 private boolean jj_2_36(int xla) {
6711 jj_la = xla; jj_lastpos = jj_scanpos = token;
6712 try { return !jj_3_36(); }
6713 catch(LookaheadSuccess ls) { return true; }
6714 finally { jj_save(35, xla); }
6715 }
6716
6717 private boolean jj_2_37(int xla) {
6718 jj_la = xla; jj_lastpos = jj_scanpos = token;
6719 try { return !jj_3_37(); }
6720 catch(LookaheadSuccess ls) { return true; }
6721 finally { jj_save(36, xla); }
6722 }
6723
6724 private boolean jj_2_38(int xla) {
6725 jj_la = xla; jj_lastpos = jj_scanpos = token;
6726 try { return !jj_3_38(); }
6727 catch(LookaheadSuccess ls) { return true; }
6728 finally { jj_save(37, xla); }
6729 }
6730
6731 private boolean jj_2_39(int xla) {
6732 jj_la = xla; jj_lastpos = jj_scanpos = token;
6733 try { return !jj_3_39(); }
6734 catch(LookaheadSuccess ls) { return true; }
6735 finally { jj_save(38, xla); }
6736 }
6737
6738 private boolean jj_2_40(int xla) {
6739 jj_la = xla; jj_lastpos = jj_scanpos = token;
6740 try { return !jj_3_40(); }
6741 catch(LookaheadSuccess ls) { return true; }
6742 finally { jj_save(39, xla); }
6743 }
6744
6745 private boolean jj_2_41(int xla) {
6746 jj_la = xla; jj_lastpos = jj_scanpos = token;
6747 try { return !jj_3_41(); }
6748 catch(LookaheadSuccess ls) { return true; }
6749 finally { jj_save(40, xla); }
6750 }
6751
6752 private boolean jj_2_42(int xla) {
6753 jj_la = xla; jj_lastpos = jj_scanpos = token;
6754 try { return !jj_3_42(); }
6755 catch(LookaheadSuccess ls) { return true; }
6756 finally { jj_save(41, xla); }
6757 }
6758
6759 private boolean jj_2_43(int xla) {
6760 jj_la = xla; jj_lastpos = jj_scanpos = token;
6761 try { return !jj_3_43(); }
6762 catch(LookaheadSuccess ls) { return true; }
6763 finally { jj_save(42, xla); }
6764 }
6765
6766 private boolean jj_2_44(int xla) {
6767 jj_la = xla; jj_lastpos = jj_scanpos = token;
6768 try { return !jj_3_44(); }
6769 catch(LookaheadSuccess ls) { return true; }
6770 finally { jj_save(43, xla); }
6771 }
6772
6773 private boolean jj_2_45(int xla) {
6774 jj_la = xla; jj_lastpos = jj_scanpos = token;
6775 try { return !jj_3_45(); }
6776 catch(LookaheadSuccess ls) { return true; }
6777 finally { jj_save(44, xla); }
6778 }
6779
6780 private boolean jj_2_46(int xla) {
6781 jj_la = xla; jj_lastpos = jj_scanpos = token;
6782 try { return !jj_3_46(); }
6783 catch(LookaheadSuccess ls) { return true; }
6784 finally { jj_save(45, xla); }
6785 }
6786
6787 private boolean jj_2_47(int xla) {
6788 jj_la = xla; jj_lastpos = jj_scanpos = token;
6789 try { return !jj_3_47(); }
6790 catch(LookaheadSuccess ls) { return true; }
6791 finally { jj_save(46, xla); }
6792 }
6793
6794 private boolean jj_2_48(int xla) {
6795 jj_la = xla; jj_lastpos = jj_scanpos = token;
6796 try { return !jj_3_48(); }
6797 catch(LookaheadSuccess ls) { return true; }
6798 finally { jj_save(47, xla); }
6799 }
6800
6801 private boolean jj_2_49(int xla) {
6802 jj_la = xla; jj_lastpos = jj_scanpos = token;
6803 try { return !jj_3_49(); }
6804 catch(LookaheadSuccess ls) { return true; }
6805 finally { jj_save(48, xla); }
6806 }
6807
6808 private boolean jj_2_50(int xla) {
6809 jj_la = xla; jj_lastpos = jj_scanpos = token;
6810 try { return !jj_3_50(); }
6811 catch(LookaheadSuccess ls) { return true; }
6812 finally { jj_save(49, xla); }
6813 }
6814
6815 private boolean jj_2_51(int xla) {
6816 jj_la = xla; jj_lastpos = jj_scanpos = token;
6817 try { return !jj_3_51(); }
6818 catch(LookaheadSuccess ls) { return true; }
6819 finally { jj_save(50, xla); }
6820 }
6821
6822 private boolean jj_2_52(int xla) {
6823 jj_la = xla; jj_lastpos = jj_scanpos = token;
6824 try { return !jj_3_52(); }
6825 catch(LookaheadSuccess ls) { return true; }
6826 finally { jj_save(51, xla); }
6827 }
6828
6829 private boolean jj_2_53(int xla) {
6830 jj_la = xla; jj_lastpos = jj_scanpos = token;
6831 try { return !jj_3_53(); }
6832 catch(LookaheadSuccess ls) { return true; }
6833 finally { jj_save(52, xla); }
6834 }
6835
6836 private boolean jj_2_54(int xla) {
6837 jj_la = xla; jj_lastpos = jj_scanpos = token;
6838 try { return !jj_3_54(); }
6839 catch(LookaheadSuccess ls) { return true; }
6840 finally { jj_save(53, xla); }
6841 }
6842
6843 private boolean jj_2_55(int xla) {
6844 jj_la = xla; jj_lastpos = jj_scanpos = token;
6845 try { return !jj_3_55(); }
6846 catch(LookaheadSuccess ls) { return true; }
6847 finally { jj_save(54, xla); }
6848 }
6849
6850 private boolean jj_2_56(int xla) {
6851 jj_la = xla; jj_lastpos = jj_scanpos = token;
6852 try { return !jj_3_56(); }
6853 catch(LookaheadSuccess ls) { return true; }
6854 finally { jj_save(55, xla); }
6855 }
6856
6857 private boolean jj_2_57(int xla) {
6858 jj_la = xla; jj_lastpos = jj_scanpos = token;
6859 try { return !jj_3_57(); }
6860 catch(LookaheadSuccess ls) { return true; }
6861 finally { jj_save(56, xla); }
6862 }
6863
6864 private boolean jj_2_58(int xla) {
6865 jj_la = xla; jj_lastpos = jj_scanpos = token;
6866 try { return !jj_3_58(); }
6867 catch(LookaheadSuccess ls) { return true; }
6868 finally { jj_save(57, xla); }
6869 }
6870
6871 private boolean jj_2_59(int xla) {
6872 jj_la = xla; jj_lastpos = jj_scanpos = token;
6873 try { return !jj_3_59(); }
6874 catch(LookaheadSuccess ls) { return true; }
6875 finally { jj_save(58, xla); }
6876 }
6877
6878 private boolean jj_2_60(int xla) {
6879 jj_la = xla; jj_lastpos = jj_scanpos = token;
6880 try { return !jj_3_60(); }
6881 catch(LookaheadSuccess ls) { return true; }
6882 finally { jj_save(59, xla); }
6883 }
6884
6885 private boolean jj_2_61(int xla) {
6886 jj_la = xla; jj_lastpos = jj_scanpos = token;
6887 try { return !jj_3_61(); }
6888 catch(LookaheadSuccess ls) { return true; }
6889 finally { jj_save(60, xla); }
6890 }
6891
6892 private boolean jj_2_62(int xla) {
6893 jj_la = xla; jj_lastpos = jj_scanpos = token;
6894 try { return !jj_3_62(); }
6895 catch(LookaheadSuccess ls) { return true; }
6896 finally { jj_save(61, xla); }
6897 }
6898
6899 private boolean jj_2_63(int xla) {
6900 jj_la = xla; jj_lastpos = jj_scanpos = token;
6901 try { return !jj_3_63(); }
6902 catch(LookaheadSuccess ls) { return true; }
6903 finally { jj_save(62, xla); }
6904 }
6905
6906 private boolean jj_2_64(int xla) {
6907 jj_la = xla; jj_lastpos = jj_scanpos = token;
6908 try { return !jj_3_64(); }
6909 catch(LookaheadSuccess ls) { return true; }
6910 finally { jj_save(63, xla); }
6911 }
6912
6913 private boolean jj_2_65(int xla) {
6914 jj_la = xla; jj_lastpos = jj_scanpos = token;
6915 try { return !jj_3_65(); }
6916 catch(LookaheadSuccess ls) { return true; }
6917 finally { jj_save(64, xla); }
6918 }
6919
6920 private boolean jj_2_66(int xla) {
6921 jj_la = xla; jj_lastpos = jj_scanpos = token;
6922 try { return !jj_3_66(); }
6923 catch(LookaheadSuccess ls) { return true; }
6924 finally { jj_save(65, xla); }
6925 }
6926
6927 private boolean jj_2_67(int xla) {
6928 jj_la = xla; jj_lastpos = jj_scanpos = token;
6929 try { return !jj_3_67(); }
6930 catch(LookaheadSuccess ls) { return true; }
6931 finally { jj_save(66, xla); }
6932 }
6933
6934 private boolean jj_2_68(int xla) {
6935 jj_la = xla; jj_lastpos = jj_scanpos = token;
6936 try { return !jj_3_68(); }
6937 catch(LookaheadSuccess ls) { return true; }
6938 finally { jj_save(67, xla); }
6939 }
6940
6941 private boolean jj_2_69(int xla) {
6942 jj_la = xla; jj_lastpos = jj_scanpos = token;
6943 try { return !jj_3_69(); }
6944 catch(LookaheadSuccess ls) { return true; }
6945 finally { jj_save(68, xla); }
6946 }
6947
6948 private boolean jj_2_70(int xla) {
6949 jj_la = xla; jj_lastpos = jj_scanpos = token;
6950 try { return !jj_3_70(); }
6951 catch(LookaheadSuccess ls) { return true; }
6952 finally { jj_save(69, xla); }
6953 }
6954
6955 private boolean jj_2_71(int xla) {
6956 jj_la = xla; jj_lastpos = jj_scanpos = token;
6957 try { return !jj_3_71(); }
6958 catch(LookaheadSuccess ls) { return true; }
6959 finally { jj_save(70, xla); }
6960 }
6961
6962 private boolean jj_2_72(int xla) {
6963 jj_la = xla; jj_lastpos = jj_scanpos = token;
6964 try { return !jj_3_72(); }
6965 catch(LookaheadSuccess ls) { return true; }
6966 finally { jj_save(71, xla); }
6967 }
6968
6969 private boolean jj_2_73(int xla) {
6970 jj_la = xla; jj_lastpos = jj_scanpos = token;
6971 try { return !jj_3_73(); }
6972 catch(LookaheadSuccess ls) { return true; }
6973 finally { jj_save(72, xla); }
6974 }
6975
6976 private boolean jj_2_74(int xla) {
6977 jj_la = xla; jj_lastpos = jj_scanpos = token;
6978 try { return !jj_3_74(); }
6979 catch(LookaheadSuccess ls) { return true; }
6980 finally { jj_save(73, xla); }
6981 }
6982
6983 private boolean jj_2_75(int xla) {
6984 jj_la = xla; jj_lastpos = jj_scanpos = token;
6985 try { return !jj_3_75(); }
6986 catch(LookaheadSuccess ls) { return true; }
6987 finally { jj_save(74, xla); }
6988 }
6989
6990 private boolean jj_3R_219() {
6991 if (jj_scan_token(BYTE)) return true;
6992 return false;
6993 }
6994
6995 private boolean jj_3R_218() {
6996 if (jj_scan_token(CHAR)) return true;
6997 return false;
6998 }
6999
7000 private boolean jj_3R_142() {
7001 Token xsp;
7002 xsp = jj_scanpos;
7003 if (jj_3R_217()) {
7004 jj_scanpos = xsp;
7005 if (jj_3R_218()) {
7006 jj_scanpos = xsp;
7007 if (jj_3R_219()) {
7008 jj_scanpos = xsp;
7009 if (jj_3R_220()) {
7010 jj_scanpos = xsp;
7011 if (jj_3R_221()) {
7012 jj_scanpos = xsp;
7013 if (jj_3R_222()) {
7014 jj_scanpos = xsp;
7015 if (jj_3R_223()) {
7016 jj_scanpos = xsp;
7017 if (jj_3R_224()) return true;
7018 }
7019 }
7020 }
7021 }
7022 }
7023 }
7024 }
7025 return false;
7026 }
7027
7028 private boolean jj_3R_217() {
7029 if (jj_scan_token(BOOLEAN)) return true;
7030 return false;
7031 }
7032
7033 private boolean jj_3R_259() {
7034 if (jj_3R_97()) return true;
7035 return false;
7036 }
7037
7038 private boolean jj_3R_360() {
7039 if (jj_scan_token(SUPER)) return true;
7040 Token xsp;
7041 while (true) {
7042 xsp = jj_scanpos;
7043 if (jj_3R_366()) { jj_scanpos = xsp; break; }
7044 }
7045 if (jj_3R_98()) return true;
7046 return false;
7047 }
7048
7049 private boolean jj_3R_359() {
7050 if (jj_scan_token(EXTENDS)) return true;
7051 Token xsp;
7052 while (true) {
7053 xsp = jj_scanpos;
7054 if (jj_3R_365()) { jj_scanpos = xsp; break; }
7055 }
7056 if (jj_3R_98()) return true;
7057 return false;
7058 }
7059
7060 private boolean jj_3R_353() {
7061 Token xsp;
7062 xsp = jj_scanpos;
7063 if (jj_3R_359()) {
7064 jj_scanpos = xsp;
7065 if (jj_3R_360()) return true;
7066 }
7067 return false;
7068 }
7069
7070 private boolean jj_3R_341() {
7071 if (jj_3R_353()) return true;
7072 return false;
7073 }
7074
7075 private boolean jj_3_17() {
7076 if (jj_scan_token(LBRACKET)) return true;
7077 if (jj_scan_token(RBRACKET)) return true;
7078 return false;
7079 }
7080
7081 private boolean jj_3R_179() {
7082 if (jj_scan_token(HOOK)) return true;
7083 Token xsp;
7084 xsp = jj_scanpos;
7085 if (jj_3R_341()) jj_scanpos = xsp;
7086 return false;
7087 }
7088
7089 private boolean jj_3R_442() {
7090 if (jj_3R_443()) return true;
7091 return false;
7092 }
7093
7094 private boolean jj_3R_277() {
7095 if (jj_3R_154()) return true;
7096 return false;
7097 }
7098
7099 private boolean jj_3R_99() {
7100 Token xsp;
7101 xsp = jj_scanpos;
7102 if (jj_3R_178()) {
7103 jj_scanpos = xsp;
7104 if (jj_3R_179()) return true;
7105 }
7106 return false;
7107 }
7108
7109 private boolean jj_3R_178() {
7110 Token xsp;
7111 while (true) {
7112 xsp = jj_scanpos;
7113 if (jj_3R_277()) { jj_scanpos = xsp; break; }
7114 }
7115 if (jj_3R_98()) return true;
7116 return false;
7117 }
7118
7119 private boolean jj_3R_175() {
7120 if (jj_scan_token(LT)) return true;
7121 if (jj_scan_token(GT)) return true;
7122 return false;
7123 }
7124
7125 private boolean jj_3R_97() {
7126 Token xsp;
7127 xsp = jj_scanpos;
7128 if (jj_3_21()) {
7129 jj_scanpos = xsp;
7130 if (jj_3R_175()) return true;
7131 }
7132 return false;
7133 }
7134
7135 private boolean jj_3_21() {
7136 if (jj_scan_token(LT)) return true;
7137 if (jj_3R_99()) return true;
7138 Token xsp;
7139 while (true) {
7140 xsp = jj_scanpos;
7141 if (jj_3R_275()) { jj_scanpos = xsp; break; }
7142 }
7143 if (jj_scan_token(GT)) return true;
7144 return false;
7145 }
7146
7147 private boolean jj_3_16() {
7148 if (jj_scan_token(LBRACKET)) return true;
7149 if (jj_scan_token(RBRACKET)) return true;
7150 return false;
7151 }
7152
7153 private boolean jj_3_19() {
7154 if (jj_scan_token(DOT)) return true;
7155 if (jj_scan_token(IDENTIFIER)) return true;
7156 Token xsp;
7157 xsp = jj_scanpos;
7158 if (jj_3_20()) jj_scanpos = xsp;
7159 return false;
7160 }
7161
7162 private boolean jj_3_18() {
7163 if (jj_3R_97()) return true;
7164 return false;
7165 }
7166
7167 private boolean jj_3R_276() {
7168 if (jj_scan_token(IDENTIFIER)) return true;
7169 Token xsp;
7170 xsp = jj_scanpos;
7171 if (jj_3_18()) jj_scanpos = xsp;
7172 while (true) {
7173 xsp = jj_scanpos;
7174 if (jj_3_19()) { jj_scanpos = xsp; break; }
7175 }
7176 return false;
7177 }
7178
7179 private boolean jj_3R_443() {
7180 if (jj_scan_token(_DEFAULT)) return true;
7181 if (jj_3R_152()) return true;
7182 return false;
7183 }
7184
7185 private boolean jj_3R_177() {
7186 if (jj_3R_276()) return true;
7187 Token xsp;
7188 while (true) {
7189 xsp = jj_scanpos;
7190 if (jj_3_17()) { jj_scanpos = xsp; break; }
7191 }
7192 return false;
7193 }
7194
7195 private boolean jj_3R_98() {
7196 Token xsp;
7197 xsp = jj_scanpos;
7198 if (jj_3R_176()) {
7199 jj_scanpos = xsp;
7200 if (jj_3R_177()) return true;
7201 }
7202 return false;
7203 }
7204
7205 private boolean jj_3R_176() {
7206 if (jj_3R_142()) return true;
7207 Token xsp;
7208 if (jj_3_16()) return true;
7209 while (true) {
7210 xsp = jj_scanpos;
7211 if (jj_3_16()) { jj_scanpos = xsp; break; }
7212 }
7213 return false;
7214 }
7215
7216 private boolean jj_3R_153() {
7217 if (jj_3R_90()) return true;
7218 if (jj_scan_token(IDENTIFIER)) return true;
7219 if (jj_scan_token(LPAREN)) return true;
7220 if (jj_scan_token(RPAREN)) return true;
7221 Token xsp;
7222 xsp = jj_scanpos;
7223 if (jj_3R_442()) jj_scanpos = xsp;
7224 if (jj_scan_token(SEMICOLON)) return true;
7225 return false;
7226 }
7227
7228 private boolean jj_3R_413() {
7229 if (jj_scan_token(THROWS)) return true;
7230 if (jj_3R_426()) return true;
7231 return false;
7232 }
7233
7234 private boolean jj_3R_164() {
7235 if (jj_3R_142()) return true;
7236 return false;
7237 }
7238
7239 private boolean jj_3R_90() {
7240 Token xsp;
7241 xsp = jj_scanpos;
7242 if (jj_3_15()) {
7243 jj_scanpos = xsp;
7244 if (jj_3R_164()) return true;
7245 }
7246 return false;
7247 }
7248
7249 private boolean jj_3_15() {
7250 if (jj_3R_98()) return true;
7251 return false;
7252 }
7253
7254 private boolean jj_3R_289() {
7255 if (jj_3R_154()) return true;
7256 return false;
7257 }
7258
7259 private boolean jj_3_12() {
7260 if (jj_3R_95()) return true;
7261 if (jj_scan_token(DOT)) return true;
7262 return false;
7263 }
7264
7265 private boolean jj_3R_441() {
7266 if (jj_3R_404()) return true;
7267 return false;
7268 }
7269
7270 private boolean jj_3R_440() {
7271 if (jj_3R_406()) return true;
7272 return false;
7273 }
7274
7275 private boolean jj_3R_402() {
7276 if (jj_scan_token(STATIC)) return true;
7277 return false;
7278 }
7279
7280 private boolean jj_3_14() {
7281 if (jj_3R_97()) return true;
7282 if (jj_scan_token(THIS)) return true;
7283 if (jj_3R_96()) return true;
7284 if (jj_scan_token(SEMICOLON)) return true;
7285 return false;
7286 }
7287
7288 private boolean jj_3_75() {
7289 if (jj_3R_88()) return true;
7290 return false;
7291 }
7292
7293 private boolean jj_3R_386() {
7294 Token xsp;
7295 xsp = jj_scanpos;
7296 if (jj_3R_402()) jj_scanpos = xsp;
7297 if (jj_3R_297()) return true;
7298 return false;
7299 }
7300
7301 private boolean jj_3_13() {
7302 if (jj_scan_token(THIS)) return true;
7303 if (jj_3R_96()) return true;
7304 if (jj_scan_token(SEMICOLON)) return true;
7305 return false;
7306 }
7307
7308 private boolean jj_3R_439() {
7309 if (jj_3R_87()) return true;
7310 return false;
7311 }
7312
7313 private boolean jj_3_74() {
7314 if (jj_3R_153()) return true;
7315 return false;
7316 }
7317
7318 private boolean jj_3_10() {
7319 if (jj_3R_93()) return true;
7320 return false;
7321 }
7322
7323 private boolean jj_3R_258() {
7324 if (jj_3R_95()) return true;
7325 if (jj_scan_token(DOT)) return true;
7326 return false;
7327 }
7328
7329 private boolean jj_3R_169() {
7330 Token xsp;
7331 xsp = jj_scanpos;
7332 if (jj_3R_258()) jj_scanpos = xsp;
7333 xsp = jj_scanpos;
7334 if (jj_3R_259()) jj_scanpos = xsp;
7335 if (jj_scan_token(SUPER)) return true;
7336 if (jj_3R_96()) return true;
7337 if (jj_scan_token(SEMICOLON)) return true;
7338 return false;
7339 }
7340
7341 private boolean jj_3R_438() {
7342 if (jj_3R_387()) return true;
7343 Token xsp;
7344 xsp = jj_scanpos;
7345 if (jj_3_74()) {
7346 jj_scanpos = xsp;
7347 if (jj_3R_439()) {
7348 jj_scanpos = xsp;
7349 if (jj_3_75()) {
7350 jj_scanpos = xsp;
7351 if (jj_3R_440()) {
7352 jj_scanpos = xsp;
7353 if (jj_3R_441()) return true;
7354 }
7355 }
7356 }
7357 }
7358 return false;
7359 }
7360
7361 private boolean jj_3R_434() {
7362 Token xsp;
7363 xsp = jj_scanpos;
7364 if (jj_3R_438()) {
7365 jj_scanpos = xsp;
7366 if (jj_scan_token(82)) return true;
7367 }
7368 return false;
7369 }
7370
7371 private boolean jj_3R_428() {
7372 if (jj_3R_434()) return true;
7373 return false;
7374 }
7375
7376 private boolean jj_3R_168() {
7377 if (jj_3R_97()) return true;
7378 if (jj_scan_token(THIS)) return true;
7379 if (jj_3R_96()) return true;
7380 if (jj_scan_token(SEMICOLON)) return true;
7381 return false;
7382 }
7383
7384 private boolean jj_3R_93() {
7385 Token xsp;
7386 xsp = jj_scanpos;
7387 if (jj_3R_167()) {
7388 jj_scanpos = xsp;
7389 if (jj_3R_168()) {
7390 jj_scanpos = xsp;
7391 if (jj_3R_169()) return true;
7392 }
7393 }
7394 return false;
7395 }
7396
7397 private boolean jj_3R_167() {
7398 if (jj_scan_token(THIS)) return true;
7399 if (jj_3R_96()) return true;
7400 if (jj_scan_token(SEMICOLON)) return true;
7401 return false;
7402 }
7403
7404 private boolean jj_3_73() {
7405 if (jj_scan_token(COMMA)) return true;
7406 if (jj_3R_152()) return true;
7407 return false;
7408 }
7409
7410 private boolean jj_3R_345() {
7411 if (jj_scan_token(COMMA)) return true;
7412 if (jj_3R_132()) return true;
7413 return false;
7414 }
7415
7416 private boolean jj_3_11() {
7417 if (jj_3R_94()) return true;
7418 return false;
7419 }
7420
7421 private boolean jj_3R_420() {
7422 if (jj_scan_token(LBRACE)) return true;
7423 Token xsp;
7424 while (true) {
7425 xsp = jj_scanpos;
7426 if (jj_3R_428()) { jj_scanpos = xsp; break; }
7427 }
7428 if (jj_scan_token(RBRACE)) return true;
7429 return false;
7430 }
7431
7432 private boolean jj_3R_414() {
7433 if (jj_3R_93()) return true;
7434 return false;
7435 }
7436
7437 private boolean jj_3R_412() {
7438 if (jj_3R_163()) return true;
7439 return false;
7440 }
7441
7442 private boolean jj_3R_403() {
7443 Token xsp;
7444 xsp = jj_scanpos;
7445 if (jj_3R_412()) jj_scanpos = xsp;
7446 if (jj_scan_token(IDENTIFIER)) return true;
7447 if (jj_3R_138()) return true;
7448 xsp = jj_scanpos;
7449 if (jj_3R_413()) jj_scanpos = xsp;
7450 if (jj_scan_token(LBRACE)) return true;
7451 xsp = jj_scanpos;
7452 if (jj_3R_414()) jj_scanpos = xsp;
7453 while (true) {
7454 xsp = jj_scanpos;
7455 if (jj_3_11()) { jj_scanpos = xsp; break; }
7456 }
7457 if (jj_scan_token(RBRACE)) return true;
7458 return false;
7459 }
7460
7461 private boolean jj_3R_406() {
7462 if (jj_scan_token(AT)) return true;
7463 if (jj_scan_token(INTERFACE)) return true;
7464 if (jj_scan_token(IDENTIFIER)) return true;
7465 if (jj_3R_420()) return true;
7466 return false;
7467 }
7468
7469 private boolean jj_3R_208() {
7470 if (jj_scan_token(BIT_OR)) return true;
7471 if (jj_3R_90()) return true;
7472 return false;
7473 }
7474
7475 private boolean jj_3R_427() {
7476 if (jj_scan_token(LBRACKET)) return true;
7477 if (jj_scan_token(RBRACKET)) return true;
7478 return false;
7479 }
7480
7481 private boolean jj_3R_418() {
7482 if (jj_scan_token(THROWS)) return true;
7483 if (jj_3R_426()) return true;
7484 return false;
7485 }
7486
7487 private boolean jj_3R_209() {
7488 if (jj_scan_token(ELLIPSIS)) return true;
7489 return false;
7490 }
7491
7492 private boolean jj_3R_364() {
7493 if (jj_3R_152()) return true;
7494 Token xsp;
7495 while (true) {
7496 xsp = jj_scanpos;
7497 if (jj_3_73()) { jj_scanpos = xsp; break; }
7498 }
7499 xsp = jj_scanpos;
7500 if (jj_scan_token(83)) jj_scanpos = xsp;
7501 return false;
7502 }
7503
7504 private boolean jj_3R_288() {
7505 if (jj_scan_token(FINAL)) return true;
7506 return false;
7507 }
7508
7509 private boolean jj_3R_207() {
7510 Token xsp;
7511 xsp = jj_scanpos;
7512 if (jj_3R_288()) {
7513 jj_scanpos = xsp;
7514 if (jj_3R_289()) return true;
7515 }
7516 return false;
7517 }
7518
7519 private boolean jj_3R_132() {
7520 Token xsp;
7521 while (true) {
7522 xsp = jj_scanpos;
7523 if (jj_3R_207()) { jj_scanpos = xsp; break; }
7524 }
7525 if (jj_3R_90()) return true;
7526 while (true) {
7527 xsp = jj_scanpos;
7528 if (jj_3R_208()) { jj_scanpos = xsp; break; }
7529 }
7530 xsp = jj_scanpos;
7531 if (jj_3R_209()) jj_scanpos = xsp;
7532 if (jj_3R_130()) return true;
7533 return false;
7534 }
7535
7536 private boolean jj_3R_315() {
7537 if (jj_scan_token(LBRACE)) return true;
7538 Token xsp;
7539 xsp = jj_scanpos;
7540 if (jj_3R_364()) jj_scanpos = xsp;
7541 if (jj_scan_token(RBRACE)) return true;
7542 return false;
7543 }
7544
7545 private boolean jj_3R_214() {
7546 if (jj_3R_132()) return true;
7547 Token xsp;
7548 while (true) {
7549 xsp = jj_scanpos;
7550 if (jj_3R_345()) { jj_scanpos = xsp; break; }
7551 }
7552 return false;
7553 }
7554
7555 private boolean jj_3R_356() {
7556 if (jj_scan_token(COMMA)) return true;
7557 if (jj_3R_355()) return true;
7558 return false;
7559 }
7560
7561 private boolean jj_3_9() {
7562 if (jj_scan_token(COMMA)) return true;
7563 if (jj_3R_92()) return true;
7564 return false;
7565 }
7566
7567 private boolean jj_3R_248() {
7568 if (jj_3R_192()) return true;
7569 return false;
7570 }
7571
7572 private boolean jj_3R_138() {
7573 if (jj_scan_token(LPAREN)) return true;
7574 Token xsp;
7575 xsp = jj_scanpos;
7576 if (jj_3R_214()) jj_scanpos = xsp;
7577 if (jj_scan_token(RPAREN)) return true;
7578 return false;
7579 }
7580
7581 private boolean jj_3R_247() {
7582 if (jj_3R_315()) return true;
7583 return false;
7584 }
7585
7586 private boolean jj_3R_152() {
7587 Token xsp;
7588 xsp = jj_scanpos;
7589 if (jj_3R_246()) {
7590 jj_scanpos = xsp;
7591 if (jj_3R_247()) {
7592 jj_scanpos = xsp;
7593 if (jj_3R_248()) return true;
7594 }
7595 }
7596 return false;
7597 }
7598
7599 private boolean jj_3R_246() {
7600 if (jj_3R_154()) return true;
7601 return false;
7602 }
7603
7604 private boolean jj_3R_355() {
7605 if (jj_scan_token(IDENTIFIER)) return true;
7606 if (jj_scan_token(ASSIGN)) return true;
7607 if (jj_3R_152()) return true;
7608 return false;
7609 }
7610
7611 private boolean jj_3R_417() {
7612 if (jj_scan_token(IDENTIFIER)) return true;
7613 if (jj_3R_138()) return true;
7614 Token xsp;
7615 while (true) {
7616 xsp = jj_scanpos;
7617 if (jj_3R_427()) { jj_scanpos = xsp; break; }
7618 }
7619 return false;
7620 }
7621
7622 private boolean jj_3R_346() {
7623 if (jj_3R_355()) return true;
7624 Token xsp;
7625 while (true) {
7626 xsp = jj_scanpos;
7627 if (jj_3R_356()) { jj_scanpos = xsp; break; }
7628 }
7629 return false;
7630 }
7631
7632 private boolean jj_3R_330() {
7633 if (jj_3R_346()) return true;
7634 return false;
7635 }
7636
7637 private boolean jj_3R_419() {
7638 if (jj_3R_297()) return true;
7639 return false;
7640 }
7641
7642 private boolean jj_3R_151() {
7643 if (jj_scan_token(IDENTIFIER)) return true;
7644 if (jj_scan_token(ASSIGN)) return true;
7645 return false;
7646 }
7647
7648 private boolean jj_3R_416() {
7649 if (jj_3R_163()) return true;
7650 return false;
7651 }
7652
7653 private boolean jj_3R_405() {
7654 Token xsp;
7655 xsp = jj_scanpos;
7656 if (jj_3R_416()) jj_scanpos = xsp;
7657 if (jj_3R_135()) return true;
7658 if (jj_3R_417()) return true;
7659 xsp = jj_scanpos;
7660 if (jj_3R_418()) jj_scanpos = xsp;
7661 xsp = jj_scanpos;
7662 if (jj_3R_419()) {
7663 jj_scanpos = xsp;
7664 if (jj_scan_token(82)) return true;
7665 }
7666 return false;
7667 }
7668
7669 private boolean jj_3R_363() {
7670 if (jj_3R_92()) return true;
7671 Token xsp;
7672 while (true) {
7673 xsp = jj_scanpos;
7674 if (jj_3_9()) { jj_scanpos = xsp; break; }
7675 }
7676 return false;
7677 }
7678
7679 private boolean jj_3R_317() {
7680 if (jj_scan_token(AT)) return true;
7681 if (jj_3R_136()) return true;
7682 if (jj_scan_token(LPAREN)) return true;
7683 if (jj_3R_152()) return true;
7684 if (jj_scan_token(RPAREN)) return true;
7685 return false;
7686 }
7687
7688 private boolean jj_3R_313() {
7689 if (jj_scan_token(ASSIGN)) return true;
7690 if (jj_3R_92()) return true;
7691 return false;
7692 }
7693
7694 private boolean jj_3R_257() {
7695 if (jj_scan_token(LBRACE)) return true;
7696 Token xsp;
7697 xsp = jj_scanpos;
7698 if (jj_3R_363()) jj_scanpos = xsp;
7699 xsp = jj_scanpos;
7700 if (jj_scan_token(83)) jj_scanpos = xsp;
7701 if (jj_scan_token(RBRACE)) return true;
7702 return false;
7703 }
7704
7705 private boolean jj_3R_415() {
7706 if (jj_scan_token(COMMA)) return true;
7707 if (jj_3R_243()) return true;
7708 return false;
7709 }
7710
7711 private boolean jj_3R_318() {
7712 if (jj_scan_token(AT)) return true;
7713 if (jj_3R_136()) return true;
7714 return false;
7715 }
7716
7717 private boolean jj_3_72() {
7718 if (jj_scan_token(AT)) return true;
7719 if (jj_3R_136()) return true;
7720 if (jj_scan_token(LPAREN)) return true;
7721 return false;
7722 }
7723
7724 private boolean jj_3R_91() {
7725 if (jj_scan_token(LBRACKET)) return true;
7726 if (jj_scan_token(RBRACKET)) return true;
7727 return false;
7728 }
7729
7730 private boolean jj_3R_316() {
7731 if (jj_scan_token(AT)) return true;
7732 if (jj_3R_136()) return true;
7733 if (jj_scan_token(LPAREN)) return true;
7734 Token xsp;
7735 xsp = jj_scanpos;
7736 if (jj_3R_330()) jj_scanpos = xsp;
7737 if (jj_scan_token(RPAREN)) return true;
7738 return false;
7739 }
7740
7741 private boolean jj_3R_166() {
7742 if (jj_3R_101()) return true;
7743 return false;
7744 }
7745
7746 private boolean jj_3R_92() {
7747 Token xsp;
7748 xsp = jj_scanpos;
7749 if (jj_3R_165()) {
7750 jj_scanpos = xsp;
7751 if (jj_3R_166()) return true;
7752 }
7753 return false;
7754 }
7755
7756 private boolean jj_3R_165() {
7757 if (jj_3R_257()) return true;
7758 return false;
7759 }
7760
7761 private boolean jj_3_71() {
7762 if (jj_scan_token(AT)) return true;
7763 if (jj_3R_136()) return true;
7764 if (jj_scan_token(LPAREN)) return true;
7765 Token xsp;
7766 xsp = jj_scanpos;
7767 if (jj_3R_151()) {
7768 jj_scanpos = xsp;
7769 if (jj_scan_token(77)) return true;
7770 }
7771 return false;
7772 }
7773
7774 private boolean jj_3R_251() {
7775 if (jj_3R_318()) return true;
7776 return false;
7777 }
7778
7779 private boolean jj_3R_250() {
7780 if (jj_3R_317()) return true;
7781 return false;
7782 }
7783
7784 private boolean jj_3R_206() {
7785 if (jj_scan_token(LBRACKET)) return true;
7786 if (jj_scan_token(RBRACKET)) return true;
7787 return false;
7788 }
7789
7790 private boolean jj_3R_436() {
7791 if (jj_3R_160()) return true;
7792 return false;
7793 }
7794
7795 private boolean jj_3R_154() {
7796 Token xsp;
7797 xsp = jj_scanpos;
7798 if (jj_3R_249()) {
7799 jj_scanpos = xsp;
7800 if (jj_3R_250()) {
7801 jj_scanpos = xsp;
7802 if (jj_3R_251()) return true;
7803 }
7804 }
7805 return false;
7806 }
7807
7808 private boolean jj_3R_194() {
7809 return false;
7810 }
7811
7812 private boolean jj_3R_249() {
7813 if (jj_3R_316()) return true;
7814 return false;
7815 }
7816
7817 private boolean jj_3R_320() {
7818 if (jj_3R_331()) return true;
7819 return false;
7820 }
7821
7822 private boolean jj_3R_130() {
7823 if (jj_scan_token(IDENTIFIER)) return true;
7824 Token xsp;
7825 while (true) {
7826 xsp = jj_scanpos;
7827 if (jj_3R_206()) { jj_scanpos = xsp; break; }
7828 }
7829 return false;
7830 }
7831
7832 private boolean jj_3R_256() {
7833 if (jj_scan_token(COMMA)) return true;
7834 if (jj_3R_255()) return true;
7835 return false;
7836 }
7837
7838 private boolean jj_3R_368() {
7839 if (jj_scan_token(COLON)) return true;
7840 if (jj_3R_101()) return true;
7841 return false;
7842 }
7843
7844 private boolean jj_3R_347() {
7845 if (jj_scan_token(BIT_AND)) return true;
7846 if (jj_3R_276()) return true;
7847 return false;
7848 }
7849
7850 private boolean jj_3R_243() {
7851 if (jj_3R_130()) return true;
7852 Token xsp;
7853 xsp = jj_scanpos;
7854 if (jj_3R_313()) jj_scanpos = xsp;
7855 return false;
7856 }
7857
7858 private boolean jj_3R_89() {
7859 if (jj_3R_163()) return true;
7860 return false;
7861 }
7862
7863 private boolean jj_3_7() {
7864 if (jj_3R_90()) return true;
7865 if (jj_scan_token(IDENTIFIER)) return true;
7866 Token xsp;
7867 while (true) {
7868 xsp = jj_scanpos;
7869 if (jj_3R_91()) { jj_scanpos = xsp; break; }
7870 }
7871 xsp = jj_scanpos;
7872 if (jj_scan_token(83)) {
7873 jj_scanpos = xsp;
7874 if (jj_scan_token(86)) {
7875 jj_scanpos = xsp;
7876 if (jj_scan_token(82)) return true;
7877 }
7878 }
7879 return false;
7880 }
7881
7882 private boolean jj_3R_195() {
7883 return false;
7884 }
7885
7886 private boolean jj_3_6() {
7887 Token xsp;
7888 xsp = jj_scanpos;
7889 if (jj_3R_89()) jj_scanpos = xsp;
7890 if (jj_scan_token(IDENTIFIER)) return true;
7891 if (jj_scan_token(LPAREN)) return true;
7892 return false;
7893 }
7894
7895 private boolean jj_3R_117() {
7896 jj_lookingAhead = true;
7897 jj_semLA = getToken(1).kind == GT &&
7898 ((Token.GTToken)getToken(1)).realKind == RSIGNEDSHIFT;
7899 jj_lookingAhead = false;
7900 if (!jj_semLA || jj_3R_194()) return true;
7901 if (jj_scan_token(GT)) return true;
7902 if (jj_scan_token(GT)) return true;
7903 return false;
7904 }
7905
7906 private boolean jj_3R_404() {
7907 if (jj_3R_90()) return true;
7908 if (jj_3R_243()) return true;
7909 Token xsp;
7910 while (true) {
7911 xsp = jj_scanpos;
7912 if (jj_3R_415()) { jj_scanpos = xsp; break; }
7913 }
7914 if (jj_scan_token(SEMICOLON)) return true;
7915 return false;
7916 }
7917
7918 private boolean jj_3R_85() {
7919 if (jj_3R_154()) return true;
7920 return false;
7921 }
7922
7923 private boolean jj_3R_435() {
7924 if (jj_3R_96()) return true;
7925 return false;
7926 }
7927
7928 private boolean jj_3R_391() {
7929 if (jj_3R_406()) return true;
7930 return false;
7931 }
7932
7933 private boolean jj_3R_156() {
7934 if (jj_scan_token(INTERFACE)) return true;
7935 return false;
7936 }
7937
7938 private boolean jj_3R_390() {
7939 if (jj_3R_405()) return true;
7940 return false;
7941 }
7942
7943 private boolean jj_3_8() {
7944 Token xsp;
7945 xsp = jj_scanpos;
7946 if (jj_scan_token(49)) jj_scanpos = xsp;
7947 if (jj_scan_token(LBRACE)) return true;
7948 return false;
7949 }
7950
7951 private boolean jj_3R_389() {
7952 if (jj_3R_404()) return true;
7953 return false;
7954 }
7955
7956 private boolean jj_3R_388() {
7957 if (jj_3R_403()) return true;
7958 return false;
7959 }
7960
7961 private boolean jj_3R_118() {
7962 jj_lookingAhead = true;
7963 jj_semLA = getToken(1).kind == GT &&
7964 ((Token.GTToken)getToken(1)).realKind == RUNSIGNEDSHIFT;
7965 jj_lookingAhead = false;
7966 if (!jj_semLA || jj_3R_195()) return true;
7967 if (jj_scan_token(GT)) return true;
7968 if (jj_scan_token(GT)) return true;
7969 if (jj_scan_token(GT)) return true;
7970 return false;
7971 }
7972
7973 private boolean jj_3_5() {
7974 if (jj_3R_88()) return true;
7975 return false;
7976 }
7977
7978 private boolean jj_3_4() {
7979 if (jj_3R_87()) return true;
7980 return false;
7981 }
7982
7983 private boolean jj_3R_371() {
7984 if (jj_3R_387()) return true;
7985 Token xsp;
7986 xsp = jj_scanpos;
7987 if (jj_3_4()) {
7988 jj_scanpos = xsp;
7989 if (jj_3_5()) {
7990 jj_scanpos = xsp;
7991 if (jj_3R_388()) {
7992 jj_scanpos = xsp;
7993 if (jj_3R_389()) {
7994 jj_scanpos = xsp;
7995 if (jj_3R_390()) {
7996 jj_scanpos = xsp;
7997 if (jj_3R_391()) return true;
7998 }
7999 }
8000 }
8001 }
8002 }
8003 return false;
8004 }
8005
8006 private boolean jj_3R_369() {
8007 Token xsp;
8008 xsp = jj_scanpos;
8009 if (jj_3R_370()) {
8010 jj_scanpos = xsp;
8011 if (jj_3R_371()) {
8012 jj_scanpos = xsp;
8013 if (jj_scan_token(82)) return true;
8014 }
8015 }
8016 return false;
8017 }
8018
8019 private boolean jj_3R_370() {
8020 if (jj_3R_386()) return true;
8021 return false;
8022 }
8023
8024 private boolean jj_3R_367() {
8025 if (jj_3R_369()) return true;
8026 return false;
8027 }
8028
8029 private boolean jj_3R_260() {
8030 if (jj_scan_token(IDENTIFIER)) return true;
8031 if (jj_3R_101()) return true;
8032 Token xsp;
8033 xsp = jj_scanpos;
8034 if (jj_3R_368()) jj_scanpos = xsp;
8035 if (jj_scan_token(SEMICOLON)) return true;
8036 return false;
8037 }
8038
8039 private boolean jj_3_3() {
8040 if (jj_scan_token(COMMA)) return true;
8041 Token xsp;
8042 while (true) {
8043 xsp = jj_scanpos;
8044 if (jj_3R_85()) { jj_scanpos = xsp; break; }
8045 }
8046 if (jj_3R_86()) return true;
8047 return false;
8048 }
8049
8050 private boolean jj_3R_160() {
8051 if (jj_scan_token(LBRACE)) return true;
8052 Token xsp;
8053 while (true) {
8054 xsp = jj_scanpos;
8055 if (jj_3R_367()) { jj_scanpos = xsp; break; }
8056 }
8057 if (jj_scan_token(RBRACE)) return true;
8058 return false;
8059 }
8060
8061 private boolean jj_3R_399() {
8062 if (jj_scan_token(FINALLY)) return true;
8063 if (jj_3R_297()) return true;
8064 return false;
8065 }
8066
8067 private boolean jj_3R_331() {
8068 if (jj_scan_token(EXTENDS)) return true;
8069 if (jj_3R_276()) return true;
8070 Token xsp;
8071 while (true) {
8072 xsp = jj_scanpos;
8073 if (jj_3R_347()) { jj_scanpos = xsp; break; }
8074 }
8075 return false;
8076 }
8077
8078 private boolean jj_3R_314() {
8079 if (jj_3R_154()) return true;
8080 return false;
8081 }
8082
8083 private boolean jj_3R_319() {
8084 if (jj_3R_154()) return true;
8085 return false;
8086 }
8087
8088 private boolean jj_3_70() {
8089 if (jj_scan_token(SEMICOLON)) return true;
8090 if (jj_3R_150()) return true;
8091 return false;
8092 }
8093
8094 private boolean jj_3R_252() {
8095 Token xsp;
8096 xsp = jj_scanpos;
8097 if (jj_scan_token(28)) {
8098 jj_scanpos = xsp;
8099 if (jj_scan_token(12)) return true;
8100 }
8101 return false;
8102 }
8103
8104 private boolean jj_3R_255() {
8105 Token xsp;
8106 while (true) {
8107 xsp = jj_scanpos;
8108 if (jj_3R_319()) { jj_scanpos = xsp; break; }
8109 }
8110 if (jj_scan_token(IDENTIFIER)) return true;
8111 xsp = jj_scanpos;
8112 if (jj_3R_320()) jj_scanpos = xsp;
8113 return false;
8114 }
8115
8116 private boolean jj_3R_398() {
8117 if (jj_scan_token(CATCH)) return true;
8118 if (jj_scan_token(LPAREN)) return true;
8119 if (jj_3R_132()) return true;
8120 if (jj_scan_token(RPAREN)) return true;
8121 if (jj_3R_297()) return true;
8122 return false;
8123 }
8124
8125 private boolean jj_3R_155() {
8126 Token xsp;
8127 xsp = jj_scanpos;
8128 if (jj_3R_252()) jj_scanpos = xsp;
8129 if (jj_scan_token(CLASS)) return true;
8130 return false;
8131 }
8132
8133 private boolean jj_3R_245() {
8134 Token xsp;
8135 xsp = jj_scanpos;
8136 if (jj_scan_token(28)) {
8137 jj_scanpos = xsp;
8138 if (jj_3R_314()) return true;
8139 }
8140 return false;
8141 }
8142
8143 private boolean jj_3R_150() {
8144 Token xsp;
8145 while (true) {
8146 xsp = jj_scanpos;
8147 if (jj_3R_245()) { jj_scanpos = xsp; break; }
8148 }
8149 if (jj_3R_90()) return true;
8150 if (jj_3R_130()) return true;
8151 if (jj_scan_token(ASSIGN)) return true;
8152 if (jj_3R_101()) return true;
8153 return false;
8154 }
8155
8156 private boolean jj_3R_163() {
8157 if (jj_scan_token(LT)) return true;
8158 if (jj_3R_255()) return true;
8159 Token xsp;
8160 while (true) {
8161 xsp = jj_scanpos;
8162 if (jj_3R_256()) { jj_scanpos = xsp; break; }
8163 }
8164 if (jj_scan_token(GT)) return true;
8165 return false;
8166 }
8167
8168 private boolean jj_3R_431() {
8169 if (jj_3R_369()) return true;
8170 return false;
8171 }
8172
8173 private boolean jj_3R_411() {
8174 if (jj_3R_150()) return true;
8175 Token xsp;
8176 while (true) {
8177 xsp = jj_scanpos;
8178 if (jj_3_70()) { jj_scanpos = xsp; break; }
8179 }
8180 return false;
8181 }
8182
8183 private boolean jj_3R_86() {
8184 if (jj_scan_token(IDENTIFIER)) return true;
8185 Token xsp;
8186 xsp = jj_scanpos;
8187 if (jj_3R_435()) jj_scanpos = xsp;
8188 xsp = jj_scanpos;
8189 if (jj_3R_436()) jj_scanpos = xsp;
8190 return false;
8191 }
8192
8193 private boolean jj_3R_425() {
8194 if (jj_scan_token(SEMICOLON)) return true;
8195 Token xsp;
8196 while (true) {
8197 xsp = jj_scanpos;
8198 if (jj_3R_431()) { jj_scanpos = xsp; break; }
8199 }
8200 return false;
8201 }
8202
8203 private boolean jj_3_69() {
8204 if (jj_scan_token(SEMICOLON)) return true;
8205 return false;
8206 }
8207
8208 private boolean jj_3R_430() {
8209 if (jj_3R_154()) return true;
8210 return false;
8211 }
8212
8213 private boolean jj_3R_424() {
8214 Token xsp;
8215 while (true) {
8216 xsp = jj_scanpos;
8217 if (jj_3R_430()) { jj_scanpos = xsp; break; }
8218 }
8219 if (jj_3R_86()) return true;
8220 while (true) {
8221 xsp = jj_scanpos;
8222 if (jj_3_3()) { jj_scanpos = xsp; break; }
8223 }
8224 return false;
8225 }
8226
8227 private boolean jj_3R_162() {
8228 if (jj_scan_token(LBRACE)) return true;
8229 Token xsp;
8230 xsp = jj_scanpos;
8231 if (jj_3R_424()) jj_scanpos = xsp;
8232 xsp = jj_scanpos;
8233 if (jj_scan_token(83)) jj_scanpos = xsp;
8234 xsp = jj_scanpos;
8235 if (jj_3R_425()) jj_scanpos = xsp;
8236 if (jj_scan_token(RBRACE)) return true;
8237 return false;
8238 }
8239
8240 private boolean jj_3R_397() {
8241 if (jj_scan_token(LPAREN)) return true;
8242 if (jj_3R_411()) return true;
8243 Token xsp;
8244 xsp = jj_scanpos;
8245 if (jj_3_69()) jj_scanpos = xsp;
8246 if (jj_scan_token(RPAREN)) return true;
8247 return false;
8248 }
8249
8250 private boolean jj_3R_379() {
8251 if (jj_3R_397()) return true;
8252 return false;
8253 }
8254
8255 private boolean jj_3R_161() {
8256 if (jj_3R_254()) return true;
8257 return false;
8258 }
8259
8260 private boolean jj_3R_381() {
8261 if (jj_3R_399()) return true;
8262 return false;
8263 }
8264
8265 private boolean jj_3R_380() {
8266 if (jj_3R_398()) return true;
8267 return false;
8268 }
8269
8270 private boolean jj_3R_310() {
8271 if (jj_scan_token(TRY)) return true;
8272 Token xsp;
8273 xsp = jj_scanpos;
8274 if (jj_3R_379()) jj_scanpos = xsp;
8275 if (jj_3R_297()) return true;
8276 while (true) {
8277 xsp = jj_scanpos;
8278 if (jj_3R_380()) { jj_scanpos = xsp; break; }
8279 }
8280 xsp = jj_scanpos;
8281 if (jj_3R_381()) jj_scanpos = xsp;
8282 return false;
8283 }
8284
8285 private boolean jj_3R_384() {
8286 if (jj_3R_154()) return true;
8287 return false;
8288 }
8289
8290 private boolean jj_3R_88() {
8291 if (jj_scan_token(IDENTIFIER)) return true;
8292 if (jj_scan_token(IDENTIFIER)) return true;
8293 Token xsp;
8294 xsp = jj_scanpos;
8295 if (jj_3R_161()) jj_scanpos = xsp;
8296 if (jj_3R_162()) return true;
8297 return false;
8298 }
8299
8300 private boolean jj_3R_401() {
8301 if (jj_3R_154()) return true;
8302 return false;
8303 }
8304
8305 private boolean jj_3R_309() {
8306 if (jj_scan_token(SYNCHRONIZED)) return true;
8307 if (jj_scan_token(LPAREN)) return true;
8308 if (jj_3R_101()) return true;
8309 if (jj_scan_token(RPAREN)) return true;
8310 if (jj_3R_297()) return true;
8311 return false;
8312 }
8313
8314 private boolean jj_3R_382() {
8315 if (jj_3R_154()) return true;
8316 return false;
8317 }
8318
8319 private boolean jj_3R_378() {
8320 if (jj_3R_101()) return true;
8321 return false;
8322 }
8323
8324 private boolean jj_3R_385() {
8325 if (jj_scan_token(COMMA)) return true;
8326 Token xsp;
8327 while (true) {
8328 xsp = jj_scanpos;
8329 if (jj_3R_401()) { jj_scanpos = xsp; break; }
8330 }
8331 if (jj_3R_276()) return true;
8332 return false;
8333 }
8334
8335 private boolean jj_3R_400() {
8336 if (jj_3R_154()) return true;
8337 return false;
8338 }
8339
8340 private boolean jj_3R_377() {
8341 if (jj_scan_token(IDENTIFIER)) return true;
8342 return false;
8343 }
8344
8345 private boolean jj_3R_254() {
8346 if (jj_scan_token(IMPLEMENTS)) return true;
8347 Token xsp;
8348 while (true) {
8349 xsp = jj_scanpos;
8350 if (jj_3R_384()) { jj_scanpos = xsp; break; }
8351 }
8352 if (jj_3R_276()) return true;
8353 while (true) {
8354 xsp = jj_scanpos;
8355 if (jj_3R_385()) { jj_scanpos = xsp; break; }
8356 }
8357 return false;
8358 }
8359
8360 private boolean jj_3R_308() {
8361 if (jj_scan_token(THROW)) return true;
8362 if (jj_3R_101()) return true;
8363 if (jj_scan_token(SEMICOLON)) return true;
8364 return false;
8365 }
8366
8367 private boolean jj_3R_383() {
8368 if (jj_scan_token(COMMA)) return true;
8369 Token xsp;
8370 while (true) {
8371 xsp = jj_scanpos;
8372 if (jj_3R_400()) { jj_scanpos = xsp; break; }
8373 }
8374 if (jj_3R_276()) return true;
8375 return false;
8376 }
8377
8378 private boolean jj_3R_429() {
8379 if (jj_scan_token(COMMA)) return true;
8380 if (jj_3R_299()) return true;
8381 return false;
8382 }
8383
8384 private boolean jj_3R_307() {
8385 if (jj_scan_token(RETURN)) return true;
8386 Token xsp;
8387 xsp = jj_scanpos;
8388 if (jj_3R_378()) jj_scanpos = xsp;
8389 if (jj_scan_token(SEMICOLON)) return true;
8390 return false;
8391 }
8392
8393 private boolean jj_3R_253() {
8394 if (jj_scan_token(EXTENDS)) return true;
8395 Token xsp;
8396 while (true) {
8397 xsp = jj_scanpos;
8398 if (jj_3R_382()) { jj_scanpos = xsp; break; }
8399 }
8400 if (jj_3R_276()) return true;
8401 while (true) {
8402 xsp = jj_scanpos;
8403 if (jj_3R_383()) { jj_scanpos = xsp; break; }
8404 }
8405 return false;
8406 }
8407
8408 private boolean jj_3R_376() {
8409 if (jj_scan_token(IDENTIFIER)) return true;
8410 return false;
8411 }
8412
8413 private boolean jj_3R_306() {
8414 if (jj_scan_token(CONTINUE)) return true;
8415 Token xsp;
8416 xsp = jj_scanpos;
8417 if (jj_3R_377()) jj_scanpos = xsp;
8418 if (jj_scan_token(SEMICOLON)) return true;
8419 return false;
8420 }
8421
8422 private boolean jj_3R_159() {
8423 if (jj_3R_254()) return true;
8424 return false;
8425 }
8426
8427 private boolean jj_3R_158() {
8428 if (jj_3R_253()) return true;
8429 return false;
8430 }
8431
8432 private boolean jj_3R_157() {
8433 if (jj_3R_163()) return true;
8434 return false;
8435 }
8436
8437 private boolean jj_3R_305() {
8438 if (jj_scan_token(BREAK)) return true;
8439 Token xsp;
8440 xsp = jj_scanpos;
8441 if (jj_3R_376()) jj_scanpos = xsp;
8442 if (jj_scan_token(SEMICOLON)) return true;
8443 return false;
8444 }
8445
8446 private boolean jj_3R_87() {
8447 Token xsp;
8448 xsp = jj_scanpos;
8449 if (jj_3R_155()) {
8450 jj_scanpos = xsp;
8451 if (jj_3R_156()) return true;
8452 }
8453 if (jj_scan_token(IDENTIFIER)) return true;
8454 xsp = jj_scanpos;
8455 if (jj_3R_157()) jj_scanpos = xsp;
8456 xsp = jj_scanpos;
8457 if (jj_3R_158()) jj_scanpos = xsp;
8458 xsp = jj_scanpos;
8459 if (jj_3R_159()) jj_scanpos = xsp;
8460 if (jj_3R_160()) return true;
8461 return false;
8462 }
8463
8464 private boolean jj_3R_410() {
8465 if (jj_3R_423()) return true;
8466 return false;
8467 }
8468
8469 private boolean jj_3_68() {
8470 if (jj_3R_149()) return true;
8471 return false;
8472 }
8473
8474 private boolean jj_3R_423() {
8475 if (jj_3R_299()) return true;
8476 Token xsp;
8477 while (true) {
8478 xsp = jj_scanpos;
8479 if (jj_3R_429()) { jj_scanpos = xsp; break; }
8480 }
8481 return false;
8482 }
8483
8484 private boolean jj_3R_373() {
8485 if (jj_scan_token(ELSE)) return true;
8486 if (jj_3R_146()) return true;
8487 return false;
8488 }
8489
8490 private boolean jj_3R_422() {
8491 if (jj_3R_423()) return true;
8492 return false;
8493 }
8494
8495 private boolean jj_3R_421() {
8496 if (jj_3R_149()) return true;
8497 return false;
8498 }
8499
8500 private boolean jj_3R_409() {
8501 Token xsp;
8502 xsp = jj_scanpos;
8503 if (jj_3R_421()) {
8504 jj_scanpos = xsp;
8505 if (jj_3R_422()) return true;
8506 }
8507 return false;
8508 }
8509
8510 private boolean jj_3_67() {
8511 if (jj_3R_149()) return true;
8512 if (jj_scan_token(COLON)) return true;
8513 return false;
8514 }
8515
8516 private boolean jj_3R_396() {
8517 if (jj_3R_410()) return true;
8518 return false;
8519 }
8520
8521 private boolean jj_3R_395() {
8522 if (jj_3R_101()) return true;
8523 return false;
8524 }
8525
8526 private boolean jj_3R_394() {
8527 if (jj_3R_409()) return true;
8528 return false;
8529 }
8530
8531 private boolean jj_3R_375() {
8532 Token xsp;
8533 xsp = jj_scanpos;
8534 if (jj_3R_394()) jj_scanpos = xsp;
8535 if (jj_scan_token(SEMICOLON)) return true;
8536 xsp = jj_scanpos;
8537 if (jj_3R_395()) jj_scanpos = xsp;
8538 if (jj_scan_token(SEMICOLON)) return true;
8539 xsp = jj_scanpos;
8540 if (jj_3R_396()) jj_scanpos = xsp;
8541 return false;
8542 }
8543
8544 private boolean jj_3R_374() {
8545 if (jj_3R_149()) return true;
8546 if (jj_scan_token(COLON)) return true;
8547 if (jj_3R_101()) return true;
8548 return false;
8549 }
8550
8551 private boolean jj_3R_84() {
8552 if (jj_3R_154()) return true;
8553 return false;
8554 }
8555
8556 private boolean jj_3R_83() {
8557 if (jj_scan_token(_DEFAULT)) return true;
8558 return false;
8559 }
8560
8561 private boolean jj_3R_304() {
8562 if (jj_scan_token(FOR)) return true;
8563 if (jj_scan_token(LPAREN)) return true;
8564 Token xsp;
8565 xsp = jj_scanpos;
8566 if (jj_3R_374()) {
8567 jj_scanpos = xsp;
8568 if (jj_3R_375()) return true;
8569 }
8570 if (jj_scan_token(RPAREN)) return true;
8571 if (jj_3R_146()) return true;
8572 return false;
8573 }
8574
8575 private boolean jj_3R_82() {
8576 if (jj_scan_token(STRICTFP)) return true;
8577 return false;
8578 }
8579
8580 private boolean jj_3R_81() {
8581 if (jj_scan_token(VOLATILE)) return true;
8582 return false;
8583 }
8584
8585 private boolean jj_3R_80() {
8586 if (jj_scan_token(TRANSIENT)) return true;
8587 return false;
8588 }
8589
8590 private boolean jj_3R_79() {
8591 if (jj_scan_token(NATIVE)) return true;
8592 return false;
8593 }
8594
8595 private boolean jj_3R_78() {
8596 if (jj_scan_token(SYNCHRONIZED)) return true;
8597 return false;
8598 }
8599
8600 private boolean jj_3R_77() {
8601 if (jj_scan_token(ABSTRACT)) return true;
8602 return false;
8603 }
8604
8605 private boolean jj_3R_303() {
8606 if (jj_scan_token(DO)) return true;
8607 if (jj_3R_146()) return true;
8608 if (jj_scan_token(WHILE)) return true;
8609 if (jj_scan_token(LPAREN)) return true;
8610 if (jj_3R_101()) return true;
8611 if (jj_scan_token(RPAREN)) return true;
8612 if (jj_scan_token(SEMICOLON)) return true;
8613 return false;
8614 }
8615
8616 private boolean jj_3R_76() {
8617 if (jj_scan_token(FINAL)) return true;
8618 return false;
8619 }
8620
8621 private boolean jj_3R_75() {
8622 if (jj_scan_token(PRIVATE)) return true;
8623 return false;
8624 }
8625
8626 private boolean jj_3R_74() {
8627 if (jj_scan_token(PROTECTED)) return true;
8628 return false;
8629 }
8630
8631 private boolean jj_3R_73() {
8632 if (jj_scan_token(STATIC)) return true;
8633 return false;
8634 }
8635
8636 private boolean jj_3R_72() {
8637 if (jj_scan_token(PUBLIC)) return true;
8638 return false;
8639 }
8640
8641 private boolean jj_3R_302() {
8642 if (jj_scan_token(WHILE)) return true;
8643 if (jj_scan_token(LPAREN)) return true;
8644 if (jj_3R_101()) return true;
8645 if (jj_scan_token(RPAREN)) return true;
8646 if (jj_3R_146()) return true;
8647 return false;
8648 }
8649
8650 private boolean jj_3_2() {
8651 Token xsp;
8652 xsp = jj_scanpos;
8653 if (jj_3R_72()) {
8654 jj_scanpos = xsp;
8655 if (jj_3R_73()) {
8656 jj_scanpos = xsp;
8657 if (jj_3R_74()) {
8658 jj_scanpos = xsp;
8659 if (jj_3R_75()) {
8660 jj_scanpos = xsp;
8661 if (jj_3R_76()) {
8662 jj_scanpos = xsp;
8663 if (jj_3R_77()) {
8664 jj_scanpos = xsp;
8665 if (jj_3R_78()) {
8666 jj_scanpos = xsp;
8667 if (jj_3R_79()) {
8668 jj_scanpos = xsp;
8669 if (jj_3R_80()) {
8670 jj_scanpos = xsp;
8671 if (jj_3R_81()) {
8672 jj_scanpos = xsp;
8673 if (jj_3R_82()) {
8674 jj_scanpos = xsp;
8675 if (jj_3R_83()) {
8676 jj_scanpos = xsp;
8677 if (jj_3R_84()) return true;
8678 }
8679 }
8680 }
8681 }
8682 }
8683 }
8684 }
8685 }
8686 }
8687 }
8688 }
8689 }
8690 return false;
8691 }
8692
8693 private boolean jj_3R_387() {
8694 Token xsp;
8695 while (true) {
8696 xsp = jj_scanpos;
8697 if (jj_3_2()) { jj_scanpos = xsp; break; }
8698 }
8699 return false;
8700 }
8701
8702 private boolean jj_3R_301() {
8703 if (jj_scan_token(IF)) return true;
8704 if (jj_scan_token(LPAREN)) return true;
8705 if (jj_3R_101()) return true;
8706 if (jj_scan_token(RPAREN)) return true;
8707 if (jj_3R_146()) return true;
8708 Token xsp;
8709 xsp = jj_scanpos;
8710 if (jj_3R_373()) jj_scanpos = xsp;
8711 return false;
8712 }
8713
8714 private boolean jj_3_66() {
8715 if (jj_3R_94()) return true;
8716 return false;
8717 }
8718
8719 private boolean jj_3R_261() {
8720 if (jj_3R_154()) return true;
8721 return false;
8722 }
8723
8724 private boolean jj_3R_408() {
8725 if (jj_scan_token(_DEFAULT)) return true;
8726 if (jj_scan_token(COLON)) return true;
8727 return false;
8728 }
8729
8730 private boolean jj_3R_407() {
8731 if (jj_scan_token(CASE)) return true;
8732 if (jj_3R_101()) return true;
8733 if (jj_scan_token(COLON)) return true;
8734 return false;
8735 }
8736
8737 private boolean jj_3R_393() {
8738 Token xsp;
8739 xsp = jj_scanpos;
8740 if (jj_3R_407()) {
8741 jj_scanpos = xsp;
8742 if (jj_3R_408()) return true;
8743 }
8744 return false;
8745 }
8746
8747 private boolean jj_3R_312() {
8748 if (jj_3R_154()) return true;
8749 return false;
8750 }
8751
8752 private boolean jj_3R_71() {
8753 if (jj_3R_154()) return true;
8754 return false;
8755 }
8756
8757 private boolean jj_3R_372() {
8758 if (jj_3R_393()) return true;
8759 Token xsp;
8760 while (true) {
8761 xsp = jj_scanpos;
8762 if (jj_3_66()) { jj_scanpos = xsp; break; }
8763 }
8764 return false;
8765 }
8766
8767 private boolean jj_3_1() {
8768 Token xsp;
8769 while (true) {
8770 xsp = jj_scanpos;
8771 if (jj_3R_71()) { jj_scanpos = xsp; break; }
8772 }
8773 if (jj_scan_token(PACKAGE)) return true;
8774 return false;
8775 }
8776
8777 private boolean jj_3R_300() {
8778 if (jj_scan_token(SWITCH)) return true;
8779 if (jj_scan_token(LPAREN)) return true;
8780 if (jj_3R_101()) return true;
8781 if (jj_scan_token(RPAREN)) return true;
8782 if (jj_scan_token(LBRACE)) return true;
8783 Token xsp;
8784 while (true) {
8785 xsp = jj_scanpos;
8786 if (jj_3R_372()) { jj_scanpos = xsp; break; }
8787 }
8788 if (jj_scan_token(RBRACE)) return true;
8789 return false;
8790 }
8791
8792 private boolean jj_3_65() {
8793 if (jj_3R_95()) return true;
8794 Token xsp;
8795 xsp = jj_scanpos;
8796 if (jj_scan_token(98)) {
8797 jj_scanpos = xsp;
8798 if (jj_scan_token(99)) return true;
8799 }
8800 return false;
8801 }
8802
8803 private boolean jj_3R_392() {
8804 if (jj_3R_100()) return true;
8805 if (jj_3R_101()) return true;
8806 return false;
8807 }
8808
8809 private boolean jj_3R_329() {
8810 if (jj_3R_95()) return true;
8811 Token xsp;
8812 xsp = jj_scanpos;
8813 if (jj_3R_392()) jj_scanpos = xsp;
8814 return false;
8815 }
8816
8817 private boolean jj_3R_148() {
8818 Token xsp;
8819 xsp = jj_scanpos;
8820 if (jj_scan_token(28)) {
8821 jj_scanpos = xsp;
8822 if (jj_scan_token(12)) return true;
8823 }
8824 return false;
8825 }
8826
8827 private boolean jj_3R_328() {
8828 if (jj_3R_344()) return true;
8829 return false;
8830 }
8831
8832 private boolean jj_3R_327() {
8833 if (jj_3R_282()) return true;
8834 return false;
8835 }
8836
8837 private boolean jj_3R_326() {
8838 if (jj_3R_281()) return true;
8839 return false;
8840 }
8841
8842 private boolean jj_3R_299() {
8843 Token xsp;
8844 xsp = jj_scanpos;
8845 if (jj_3R_326()) {
8846 jj_scanpos = xsp;
8847 if (jj_3R_327()) {
8848 jj_scanpos = xsp;
8849 if (jj_3R_328()) {
8850 jj_scanpos = xsp;
8851 if (jj_3R_329()) return true;
8852 }
8853 }
8854 }
8855 return false;
8856 }
8857
8858 private boolean jj_3R_298() {
8859 if (jj_scan_token(SEMICOLON)) return true;
8860 return false;
8861 }
8862
8863 private boolean jj_3R_147() {
8864 if (jj_3R_154()) return true;
8865 return false;
8866 }
8867
8868 private boolean jj_3_64() {
8869 Token xsp;
8870 xsp = jj_scanpos;
8871 if (jj_3R_147()) jj_scanpos = xsp;
8872 xsp = jj_scanpos;
8873 if (jj_3R_148()) jj_scanpos = xsp;
8874 if (jj_scan_token(CLASS)) return true;
8875 return false;
8876 }
8877
8878 private boolean jj_3R_226() {
8879 if (jj_3R_154()) return true;
8880 return false;
8881 }
8882
8883 private boolean jj_3R_244() {
8884 if (jj_scan_token(COMMA)) return true;
8885 if (jj_3R_243()) return true;
8886 return false;
8887 }
8888
8889 private boolean jj_3R_311() {
8890 if (jj_scan_token(FINAL)) return true;
8891 return false;
8892 }
8893
8894 private boolean jj_3R_242() {
8895 Token xsp;
8896 xsp = jj_scanpos;
8897 if (jj_3R_311()) {
8898 jj_scanpos = xsp;
8899 if (jj_3R_312()) return true;
8900 }
8901 return false;
8902 }
8903
8904 private boolean jj_3R_149() {
8905 Token xsp;
8906 while (true) {
8907 xsp = jj_scanpos;
8908 if (jj_3R_242()) { jj_scanpos = xsp; break; }
8909 }
8910 if (jj_3R_90()) return true;
8911 if (jj_3R_243()) return true;
8912 while (true) {
8913 xsp = jj_scanpos;
8914 if (jj_3R_244()) { jj_scanpos = xsp; break; }
8915 }
8916 return false;
8917 }
8918
8919 private boolean jj_3R_145() {
8920 Token xsp;
8921 xsp = jj_scanpos;
8922 if (jj_scan_token(28)) {
8923 jj_scanpos = xsp;
8924 if (jj_3R_226()) return true;
8925 }
8926 return false;
8927 }
8928
8929 private boolean jj_3R_172() {
8930 Token xsp;
8931 xsp = jj_scanpos;
8932 if (jj_3R_261()) jj_scanpos = xsp;
8933 if (jj_3R_87()) return true;
8934 return false;
8935 }
8936
8937 private boolean jj_3_62() {
8938 Token xsp;
8939 while (true) {
8940 xsp = jj_scanpos;
8941 if (jj_3R_145()) { jj_scanpos = xsp; break; }
8942 }
8943 if (jj_3R_90()) return true;
8944 if (jj_scan_token(IDENTIFIER)) return true;
8945 return false;
8946 }
8947
8948 private boolean jj_3_63() {
8949 if (jj_3R_146()) return true;
8950 return false;
8951 }
8952
8953 private boolean jj_3R_171() {
8954 if (jj_3R_149()) return true;
8955 if (jj_scan_token(SEMICOLON)) return true;
8956 return false;
8957 }
8958
8959 private boolean jj_3R_94() {
8960 Token xsp;
8961 xsp = jj_scanpos;
8962 jj_lookingAhead = true;
8963 jj_semLA = isNextTokenAnAssert();
8964 jj_lookingAhead = false;
8965 if (!jj_semLA || jj_3R_170()) {
8966 jj_scanpos = xsp;
8967 if (jj_3R_171()) {
8968 jj_scanpos = xsp;
8969 if (jj_3_63()) {
8970 jj_scanpos = xsp;
8971 if (jj_3R_172()) return true;
8972 }
8973 }
8974 }
8975 return false;
8976 }
8977
8978 private boolean jj_3_61() {
8979 if (jj_3R_94()) return true;
8980 return false;
8981 }
8982
8983 private boolean jj_3R_170() {
8984 if (jj_3R_260()) return true;
8985 return false;
8986 }
8987
8988 private boolean jj_3R_297() {
8989 if (jj_scan_token(LBRACE)) return true;
8990 Token xsp;
8991 while (true) {
8992 xsp = jj_scanpos;
8993 if (jj_3_61()) { jj_scanpos = xsp; break; }
8994 }
8995 if (jj_scan_token(RBRACE)) return true;
8996 return false;
8997 }
8998
8999 private boolean jj_3_58() {
9000 if (jj_scan_token(LBRACKET)) return true;
9001 if (jj_scan_token(RBRACKET)) return true;
9002 return false;
9003 }
9004
9005 private boolean jj_3R_144() {
9006 if (jj_scan_token(IDENTIFIER)) return true;
9007 if (jj_scan_token(COLON)) return true;
9008 if (jj_3R_146()) return true;
9009 return false;
9010 }
9011
9012 private boolean jj_3R_241() {
9013 if (jj_3R_310()) return true;
9014 return false;
9015 }
9016
9017 private boolean jj_3R_240() {
9018 if (jj_3R_309()) return true;
9019 return false;
9020 }
9021
9022 private boolean jj_3R_239() {
9023 if (jj_3R_308()) return true;
9024 return false;
9025 }
9026
9027 private boolean jj_3R_295() {
9028 if (jj_3R_297()) return true;
9029 return false;
9030 }
9031
9032 private boolean jj_3R_238() {
9033 if (jj_3R_307()) return true;
9034 return false;
9035 }
9036
9037 private boolean jj_3R_237() {
9038 if (jj_3R_306()) return true;
9039 return false;
9040 }
9041
9042 private boolean jj_3R_236() {
9043 if (jj_3R_305()) return true;
9044 return false;
9045 }
9046
9047 private boolean jj_3R_235() {
9048 if (jj_3R_304()) return true;
9049 return false;
9050 }
9051
9052 private boolean jj_3R_234() {
9053 if (jj_3R_303()) return true;
9054 return false;
9055 }
9056
9057 private boolean jj_3R_233() {
9058 if (jj_3R_302()) return true;
9059 return false;
9060 }
9061
9062 private boolean jj_3R_232() {
9063 if (jj_3R_301()) return true;
9064 return false;
9065 }
9066
9067 private boolean jj_3R_231() {
9068 if (jj_3R_300()) return true;
9069 return false;
9070 }
9071
9072 private boolean jj_3R_230() {
9073 if (jj_3R_299()) return true;
9074 if (jj_scan_token(SEMICOLON)) return true;
9075 return false;
9076 }
9077
9078 private boolean jj_3R_229() {
9079 if (jj_3R_298()) return true;
9080 return false;
9081 }
9082
9083 private boolean jj_3R_228() {
9084 if (jj_3R_297()) return true;
9085 return false;
9086 }
9087
9088 private boolean jj_3_60() {
9089 if (jj_3R_144()) return true;
9090 return false;
9091 }
9092
9093 private boolean jj_3R_146() {
9094 Token xsp;
9095 xsp = jj_scanpos;
9096 jj_lookingAhead = true;
9097 jj_semLA = isNextTokenAnAssert();
9098 jj_lookingAhead = false;
9099 if (!jj_semLA || jj_3R_227()) {
9100 jj_scanpos = xsp;
9101 if (jj_3_60()) {
9102 jj_scanpos = xsp;
9103 if (jj_3R_228()) {
9104 jj_scanpos = xsp;
9105 if (jj_3R_229()) {
9106 jj_scanpos = xsp;
9107 if (jj_3R_230()) {
9108 jj_scanpos = xsp;
9109 if (jj_3R_231()) {
9110 jj_scanpos = xsp;
9111 if (jj_3R_232()) {
9112 jj_scanpos = xsp;
9113 if (jj_3R_233()) {
9114 jj_scanpos = xsp;
9115 if (jj_3R_234()) {
9116 jj_scanpos = xsp;
9117 if (jj_3R_235()) {
9118 jj_scanpos = xsp;
9119 if (jj_3R_236()) {
9120 jj_scanpos = xsp;
9121 if (jj_3R_237()) {
9122 jj_scanpos = xsp;
9123 if (jj_3R_238()) {
9124 jj_scanpos = xsp;
9125 if (jj_3R_239()) {
9126 jj_scanpos = xsp;
9127 if (jj_3R_240()) {
9128 jj_scanpos = xsp;
9129 if (jj_3R_241()) return true;
9130 }
9131 }
9132 }
9133 }
9134 }
9135 }
9136 }
9137 }
9138 }
9139 }
9140 }
9141 }
9142 }
9143 }
9144 }
9145 return false;
9146 }
9147
9148 private boolean jj_3R_227() {
9149 if (jj_3R_260()) return true;
9150 return false;
9151 }
9152
9153 private boolean jj_3R_350() {
9154 if (jj_3R_97()) return true;
9155 return false;
9156 }
9157
9158 private boolean jj_3R_294() {
9159 if (jj_3R_101()) return true;
9160 return false;
9161 }
9162
9163 private boolean jj_3R_358() {
9164 if (jj_3R_160()) return true;
9165 return false;
9166 }
9167
9168 private boolean jj_3R_296() {
9169 if (jj_scan_token(LBRACKET)) return true;
9170 if (jj_scan_token(RBRACKET)) return true;
9171 return false;
9172 }
9173
9174 private boolean jj_3_57() {
9175 if (jj_scan_token(LBRACKET)) return true;
9176 if (jj_3R_101()) return true;
9177 if (jj_scan_token(RBRACKET)) return true;
9178 return false;
9179 }
9180
9181 private boolean jj_3R_225() {
9182 Token xsp;
9183 if (jj_3R_296()) return true;
9184 while (true) {
9185 xsp = jj_scanpos;
9186 if (jj_3R_296()) { jj_scanpos = xsp; break; }
9187 }
9188 if (jj_3R_257()) return true;
9189 return false;
9190 }
9191
9192 private boolean jj_3_59() {
9193 Token xsp;
9194 if (jj_3_57()) return true;
9195 while (true) {
9196 xsp = jj_scanpos;
9197 if (jj_3_57()) { jj_scanpos = xsp; break; }
9198 }
9199 while (true) {
9200 xsp = jj_scanpos;
9201 if (jj_3_58()) { jj_scanpos = xsp; break; }
9202 }
9203 return false;
9204 }
9205
9206 private boolean jj_3R_143() {
9207 Token xsp;
9208 xsp = jj_scanpos;
9209 if (jj_3_59()) {
9210 jj_scanpos = xsp;
9211 if (jj_3R_225()) return true;
9212 }
9213 return false;
9214 }
9215
9216 private boolean jj_3R_352() {
9217 if (jj_3R_96()) return true;
9218 Token xsp;
9219 xsp = jj_scanpos;
9220 if (jj_3R_358()) jj_scanpos = xsp;
9221 return false;
9222 }
9223
9224 private boolean jj_3R_351() {
9225 if (jj_3R_143()) return true;
9226 return false;
9227 }
9228
9229 private boolean jj_3R_322() {
9230 if (jj_scan_token(COMMA)) return true;
9231 if (jj_3R_101()) return true;
9232 return false;
9233 }
9234
9235 private boolean jj_3R_339() {
9236 if (jj_3R_154()) return true;
9237 return false;
9238 }
9239
9240 private boolean jj_3R_340() {
9241 if (jj_3R_276()) return true;
9242 Token xsp;
9243 xsp = jj_scanpos;
9244 if (jj_3R_350()) jj_scanpos = xsp;
9245 xsp = jj_scanpos;
9246 if (jj_3R_351()) {
9247 jj_scanpos = xsp;
9248 if (jj_3R_352()) return true;
9249 }
9250 return false;
9251 }
9252
9253 private boolean jj_3R_286() {
9254 if (jj_scan_token(BIT_AND)) return true;
9255 if (jj_3R_98()) return true;
9256 return false;
9257 }
9258
9259 private boolean jj_3_56() {
9260 if (jj_3R_142()) return true;
9261 if (jj_3R_143()) return true;
9262 return false;
9263 }
9264
9265 private boolean jj_3R_293() {
9266 if (jj_3R_297()) return true;
9267 return false;
9268 }
9269
9270 private boolean jj_3R_140() {
9271 if (jj_scan_token(NEW)) return true;
9272 Token xsp;
9273 while (true) {
9274 xsp = jj_scanpos;
9275 if (jj_3R_339()) { jj_scanpos = xsp; break; }
9276 }
9277 xsp = jj_scanpos;
9278 if (jj_3_56()) {
9279 jj_scanpos = xsp;
9280 if (jj_3R_340()) return true;
9281 }
9282 return false;
9283 }
9284
9285 private boolean jj_3R_131() {
9286 if (jj_scan_token(COMMA)) return true;
9287 if (jj_3R_130()) return true;
9288 return false;
9289 }
9290
9291 private boolean jj_3R_174() {
9292 if (jj_3R_274()) return true;
9293 return false;
9294 }
9295
9296 private boolean jj_3R_274() {
9297 if (jj_3R_101()) return true;
9298 Token xsp;
9299 while (true) {
9300 xsp = jj_scanpos;
9301 if (jj_3R_322()) { jj_scanpos = xsp; break; }
9302 }
9303 return false;
9304 }
9305
9306 private boolean jj_3R_291() {
9307 if (jj_3R_297()) return true;
9308 return false;
9309 }
9310
9311 private boolean jj_3R_139() {
9312 if (jj_scan_token(COMMA)) return true;
9313 if (jj_3R_130()) return true;
9314 return false;
9315 }
9316
9317 private boolean jj_3R_133() {
9318 if (jj_scan_token(COMMA)) return true;
9319 if (jj_3R_132()) return true;
9320 return false;
9321 }
9322
9323 private boolean jj_3R_96() {
9324 if (jj_scan_token(LPAREN)) return true;
9325 Token xsp;
9326 xsp = jj_scanpos;
9327 if (jj_3R_174()) jj_scanpos = xsp;
9328 if (jj_scan_token(RPAREN)) return true;
9329 return false;
9330 }
9331
9332 private boolean jj_3R_292() {
9333 if (jj_3R_101()) return true;
9334 return false;
9335 }
9336
9337 private boolean jj_3R_349() {
9338 if (jj_scan_token(NULL)) return true;
9339 return false;
9340 }
9341
9342 private boolean jj_3R_357() {
9343 if (jj_scan_token(TRUE)) return true;
9344 return false;
9345 }
9346
9347 private boolean jj_3R_348() {
9348 Token xsp;
9349 xsp = jj_scanpos;
9350 if (jj_3R_357()) {
9351 jj_scanpos = xsp;
9352 if (jj_scan_token(27)) return true;
9353 }
9354 return false;
9355 }
9356
9357 private boolean jj_3R_290() {
9358 if (jj_3R_101()) return true;
9359 return false;
9360 }
9361
9362 private boolean jj_3R_338() {
9363 if (jj_3R_349()) return true;
9364 return false;
9365 }
9366
9367 private boolean jj_3R_337() {
9368 if (jj_3R_348()) return true;
9369 return false;
9370 }
9371
9372 private boolean jj_3R_336() {
9373 if (jj_scan_token(STRING_LITERAL)) return true;
9374 return false;
9375 }
9376
9377 private boolean jj_3R_335() {
9378 if (jj_scan_token(CHARACTER_LITERAL)) return true;
9379 return false;
9380 }
9381
9382 private boolean jj_3R_334() {
9383 if (jj_scan_token(HEX_FLOATING_POINT_LITERAL)) return true;
9384 return false;
9385 }
9386
9387 private boolean jj_3R_333() {
9388 if (jj_scan_token(FLOATING_POINT_LITERAL)) return true;
9389 return false;
9390 }
9391
9392 private boolean jj_3R_332() {
9393 if (jj_scan_token(INTEGER_LITERAL)) return true;
9394 return false;
9395 }
9396
9397 private boolean jj_3R_321() {
9398 Token xsp;
9399 xsp = jj_scanpos;
9400 if (jj_3R_332()) {
9401 jj_scanpos = xsp;
9402 if (jj_3R_333()) {
9403 jj_scanpos = xsp;
9404 if (jj_3R_334()) {
9405 jj_scanpos = xsp;
9406 if (jj_3R_335()) {
9407 jj_scanpos = xsp;
9408 if (jj_3R_336()) {
9409 jj_scanpos = xsp;
9410 if (jj_3R_337()) {
9411 jj_scanpos = xsp;
9412 if (jj_3R_338()) return true;
9413 }
9414 }
9415 }
9416 }
9417 }
9418 }
9419 return false;
9420 }
9421
9422 private boolean jj_3R_213() {
9423 if (jj_scan_token(IDENTIFIER)) return true;
9424 return false;
9425 }
9426
9427 private boolean jj_3R_205() {
9428 if (jj_3R_96()) return true;
9429 return false;
9430 }
9431
9432 private boolean jj_3R_204() {
9433 if (jj_scan_token(DOT)) return true;
9434 if (jj_scan_token(IDENTIFIER)) return true;
9435 return false;
9436 }
9437
9438 private boolean jj_3R_203() {
9439 if (jj_scan_token(LBRACKET)) return true;
9440 if (jj_3R_101()) return true;
9441 if (jj_scan_token(RBRACKET)) return true;
9442 return false;
9443 }
9444
9445 private boolean jj_3_55() {
9446 if (jj_3R_141()) return true;
9447 return false;
9448 }
9449
9450 private boolean jj_3R_124() {
9451 if (jj_scan_token(REM)) return true;
9452 return false;
9453 }
9454
9455 private boolean jj_3_54() {
9456 if (jj_scan_token(DOT)) return true;
9457 if (jj_3R_140()) return true;
9458 return false;
9459 }
9460
9461 private boolean jj_3R_129() {
9462 Token xsp;
9463 xsp = jj_scanpos;
9464 if (jj_3_52()) {
9465 jj_scanpos = xsp;
9466 if (jj_3_53()) {
9467 jj_scanpos = xsp;
9468 if (jj_3_54()) {
9469 jj_scanpos = xsp;
9470 if (jj_3_55()) {
9471 jj_scanpos = xsp;
9472 if (jj_3R_203()) {
9473 jj_scanpos = xsp;
9474 if (jj_3R_204()) {
9475 jj_scanpos = xsp;
9476 if (jj_3R_205()) return true;
9477 }
9478 }
9479 }
9480 }
9481 }
9482 }
9483 return false;
9484 }
9485
9486 private boolean jj_3_53() {
9487 if (jj_scan_token(DOT)) return true;
9488 if (jj_scan_token(SUPER)) return true;
9489 return false;
9490 }
9491
9492 private boolean jj_3_52() {
9493 if (jj_scan_token(DOT)) return true;
9494 if (jj_scan_token(THIS)) return true;
9495 return false;
9496 }
9497
9498 private boolean jj_3_49() {
9499 if (jj_3R_98()) return true;
9500 if (jj_3R_137()) return true;
9501 return false;
9502 }
9503
9504 private boolean jj_3_48() {
9505 if (jj_3R_136()) return true;
9506 if (jj_scan_token(METHOD_REF)) return true;
9507 return false;
9508 }
9509
9510 private boolean jj_3R_362() {
9511 if (jj_scan_token(DECR)) return true;
9512 return false;
9513 }
9514
9515 private boolean jj_3_47() {
9516 if (jj_3R_135()) return true;
9517 if (jj_scan_token(DOT)) return true;
9518 if (jj_scan_token(CLASS)) return true;
9519 return false;
9520 }
9521
9522 private boolean jj_3_51() {
9523 if (jj_scan_token(LPAREN)) return true;
9524 if (jj_3R_130()) return true;
9525 Token xsp;
9526 while (true) {
9527 xsp = jj_scanpos;
9528 if (jj_3R_139()) { jj_scanpos = xsp; break; }
9529 }
9530 if (jj_scan_token(RPAREN)) return true;
9531 if (jj_scan_token(LAMBDA)) return true;
9532 xsp = jj_scanpos;
9533 if (jj_3R_294()) {
9534 jj_scanpos = xsp;
9535 if (jj_3R_295()) return true;
9536 }
9537 return false;
9538 }
9539
9540 private boolean jj_3R_285() {
9541 if (jj_3R_154()) return true;
9542 return false;
9543 }
9544
9545 private boolean jj_3_50() {
9546 if (jj_3R_138()) return true;
9547 if (jj_scan_token(LAMBDA)) return true;
9548 Token xsp;
9549 xsp = jj_scanpos;
9550 if (jj_3R_292()) {
9551 jj_scanpos = xsp;
9552 if (jj_3R_293()) return true;
9553 }
9554 return false;
9555 }
9556
9557 private boolean jj_3R_284() {
9558 if (jj_3R_154()) return true;
9559 return false;
9560 }
9561
9562 private boolean jj_3R_134() {
9563 Token xsp;
9564 xsp = jj_scanpos;
9565 if (jj_3R_210()) {
9566 jj_scanpos = xsp;
9567 if (jj_3_50()) {
9568 jj_scanpos = xsp;
9569 if (jj_3_51()) return true;
9570 }
9571 }
9572 return false;
9573 }
9574
9575 private boolean jj_3R_210() {
9576 if (jj_3R_130()) return true;
9577 if (jj_scan_token(LAMBDA)) return true;
9578 Token xsp;
9579 xsp = jj_scanpos;
9580 if (jj_3R_290()) {
9581 jj_scanpos = xsp;
9582 if (jj_3R_291()) return true;
9583 }
9584 return false;
9585 }
9586
9587 private boolean jj_3_45() {
9588 if (jj_3R_134()) return true;
9589 return false;
9590 }
9591
9592 private boolean jj_3_44() {
9593 if (jj_scan_token(LPAREN)) return true;
9594 if (jj_3R_132()) return true;
9595 if (jj_scan_token(COMMA)) return true;
9596 if (jj_3R_132()) return true;
9597 Token xsp;
9598 xsp = jj_scanpos;
9599 if (jj_3R_133()) jj_scanpos = xsp;
9600 if (jj_scan_token(RPAREN)) return true;
9601 if (jj_scan_token(LAMBDA)) return true;
9602 return false;
9603 }
9604
9605 private boolean jj_3_43() {
9606 if (jj_scan_token(LPAREN)) return true;
9607 if (jj_3R_130()) return true;
9608 if (jj_scan_token(COMMA)) return true;
9609 if (jj_3R_130()) return true;
9610 Token xsp;
9611 xsp = jj_scanpos;
9612 if (jj_3R_131()) jj_scanpos = xsp;
9613 if (jj_scan_token(RPAREN)) return true;
9614 if (jj_scan_token(LAMBDA)) return true;
9615 return false;
9616 }
9617
9618 private boolean jj_3_42() {
9619 if (jj_scan_token(IDENTIFIER)) return true;
9620 if (jj_scan_token(LAMBDA)) return true;
9621 return false;
9622 }
9623
9624 private boolean jj_3R_273() {
9625 if (jj_3R_136()) return true;
9626 return false;
9627 }
9628
9629 private boolean jj_3R_272() {
9630 if (jj_3R_98()) return true;
9631 if (jj_3R_137()) return true;
9632 return false;
9633 }
9634
9635 private boolean jj_3R_271() {
9636 if (jj_3R_136()) return true;
9637 return false;
9638 }
9639
9640 private boolean jj_3R_270() {
9641 if (jj_3R_135()) return true;
9642 if (jj_scan_token(DOT)) return true;
9643 if (jj_scan_token(CLASS)) return true;
9644 return false;
9645 }
9646
9647 private boolean jj_3R_269() {
9648 if (jj_3R_140()) return true;
9649 return false;
9650 }
9651
9652 private boolean jj_3_46() {
9653 if (jj_scan_token(LPAREN)) return true;
9654 if (jj_3R_101()) return true;
9655 if (jj_scan_token(RPAREN)) return true;
9656 return false;
9657 }
9658
9659 private boolean jj_3R_268() {
9660 if (jj_3R_134()) return true;
9661 return false;
9662 }
9663
9664 private boolean jj_3R_267() {
9665 if (jj_3R_134()) return true;
9666 return false;
9667 }
9668
9669 private boolean jj_3R_266() {
9670 if (jj_3R_134()) return true;
9671 return false;
9672 }
9673
9674 private boolean jj_3R_265() {
9675 if (jj_3R_134()) return true;
9676 return false;
9677 }
9678
9679 private boolean jj_3R_264() {
9680 if (jj_scan_token(SUPER)) return true;
9681 return false;
9682 }
9683
9684 private boolean jj_3R_263() {
9685 if (jj_scan_token(THIS)) return true;
9686 return false;
9687 }
9688
9689 private boolean jj_3R_173() {
9690 Token xsp;
9691 xsp = jj_scanpos;
9692 if (jj_3R_262()) {
9693 jj_scanpos = xsp;
9694 if (jj_3R_263()) {
9695 jj_scanpos = xsp;
9696 if (jj_3R_264()) {
9697 jj_scanpos = xsp;
9698 if (jj_3R_265()) {
9699 jj_scanpos = xsp;
9700 if (jj_3R_266()) {
9701 jj_scanpos = xsp;
9702 if (jj_3R_267()) {
9703 jj_scanpos = xsp;
9704 if (jj_3R_268()) {
9705 jj_scanpos = xsp;
9706 if (jj_3_46()) {
9707 jj_scanpos = xsp;
9708 if (jj_3R_269()) {
9709 jj_scanpos = xsp;
9710 if (jj_3R_270()) {
9711 jj_scanpos = xsp;
9712 if (jj_3R_271()) {
9713 jj_scanpos = xsp;
9714 if (jj_3R_272()) {
9715 jj_scanpos = xsp;
9716 if (jj_3R_273()) return true;
9717 }
9718 }
9719 }
9720 }
9721 }
9722 }
9723 }
9724 }
9725 }
9726 }
9727 }
9728 }
9729 return false;
9730 }
9731
9732 private boolean jj_3R_212() {
9733 if (jj_scan_token(NEW)) return true;
9734 return false;
9735 }
9736
9737 private boolean jj_3R_262() {
9738 if (jj_3R_321()) return true;
9739 return false;
9740 }
9741
9742 private boolean jj_3R_120() {
9743 if (jj_scan_token(MINUS)) return true;
9744 return false;
9745 }
9746
9747 private boolean jj_3_41() {
9748 if (jj_3R_129()) return true;
9749 return false;
9750 }
9751
9752 private boolean jj_3R_123() {
9753 if (jj_scan_token(SLASH)) return true;
9754 return false;
9755 }
9756
9757 private boolean jj_3R_137() {
9758 if (jj_scan_token(METHOD_REF)) return true;
9759 Token xsp;
9760 xsp = jj_scanpos;
9761 if (jj_3R_212()) {
9762 jj_scanpos = xsp;
9763 if (jj_3R_213()) return true;
9764 }
9765 return false;
9766 }
9767
9768 private boolean jj_3R_343() {
9769 if (jj_scan_token(BANG)) return true;
9770 return false;
9771 }
9772
9773 private boolean jj_3R_216() {
9774 if (jj_3R_137()) return true;
9775 return false;
9776 }
9777
9778 private boolean jj_3R_361() {
9779 if (jj_scan_token(INCR)) return true;
9780 return false;
9781 }
9782
9783 private boolean jj_3R_354() {
9784 Token xsp;
9785 xsp = jj_scanpos;
9786 if (jj_3R_361()) {
9787 jj_scanpos = xsp;
9788 if (jj_3R_362()) return true;
9789 }
9790 return false;
9791 }
9792
9793 private boolean jj_3R_128() {
9794 if (jj_3R_154()) return true;
9795 return false;
9796 }
9797
9798 private boolean jj_3R_141() {
9799 Token xsp;
9800 xsp = jj_scanpos;
9801 if (jj_3R_215()) {
9802 jj_scanpos = xsp;
9803 if (jj_3R_216()) return true;
9804 }
9805 return false;
9806 }
9807
9808 private boolean jj_3R_215() {
9809 if (jj_scan_token(DOT)) return true;
9810 if (jj_3R_97()) return true;
9811 if (jj_scan_token(IDENTIFIER)) return true;
9812 return false;
9813 }
9814
9815 private boolean jj_3R_127() {
9816 if (jj_3R_154()) return true;
9817 return false;
9818 }
9819
9820 private boolean jj_3_40() {
9821 if (jj_scan_token(LPAREN)) return true;
9822 Token xsp;
9823 while (true) {
9824 xsp = jj_scanpos;
9825 if (jj_3R_128()) { jj_scanpos = xsp; break; }
9826 }
9827 if (jj_3R_90()) return true;
9828 if (jj_scan_token(BIT_AND)) return true;
9829 return false;
9830 }
9831
9832 private boolean jj_3_39() {
9833 if (jj_scan_token(LPAREN)) return true;
9834 Token xsp;
9835 while (true) {
9836 xsp = jj_scanpos;
9837 if (jj_3R_127()) { jj_scanpos = xsp; break; }
9838 }
9839 if (jj_3R_90()) return true;
9840 if (jj_scan_token(RPAREN)) return true;
9841 return false;
9842 }
9843
9844 private boolean jj_3R_95() {
9845 if (jj_3R_173()) return true;
9846 Token xsp;
9847 while (true) {
9848 xsp = jj_scanpos;
9849 if (jj_3_41()) { jj_scanpos = xsp; break; }
9850 }
9851 return false;
9852 }
9853
9854 private boolean jj_3R_287() {
9855 if (jj_3R_154()) return true;
9856 return false;
9857 }
9858
9859 private boolean jj_3R_202() {
9860 if (jj_scan_token(LPAREN)) return true;
9861 Token xsp;
9862 while (true) {
9863 xsp = jj_scanpos;
9864 if (jj_3R_287()) { jj_scanpos = xsp; break; }
9865 }
9866 if (jj_3R_90()) return true;
9867 if (jj_scan_token(RPAREN)) return true;
9868 if (jj_3R_283()) return true;
9869 return false;
9870 }
9871
9872 private boolean jj_3R_201() {
9873 if (jj_scan_token(LPAREN)) return true;
9874 Token xsp;
9875 while (true) {
9876 xsp = jj_scanpos;
9877 if (jj_3R_285()) { jj_scanpos = xsp; break; }
9878 }
9879 if (jj_3R_90()) return true;
9880 if (jj_3R_286()) return true;
9881 while (true) {
9882 xsp = jj_scanpos;
9883 if (jj_3R_286()) { jj_scanpos = xsp; break; }
9884 }
9885 if (jj_scan_token(RPAREN)) return true;
9886 if (jj_3R_283()) return true;
9887 return false;
9888 }
9889
9890 private boolean jj_3R_126() {
9891 Token xsp;
9892 xsp = jj_scanpos;
9893 if (jj_3R_200()) {
9894 jj_scanpos = xsp;
9895 if (jj_3R_201()) {
9896 jj_scanpos = xsp;
9897 if (jj_3R_202()) return true;
9898 }
9899 }
9900 return false;
9901 }
9902
9903 private boolean jj_3R_200() {
9904 if (jj_scan_token(LPAREN)) return true;
9905 Token xsp;
9906 while (true) {
9907 xsp = jj_scanpos;
9908 if (jj_3R_284()) { jj_scanpos = xsp; break; }
9909 }
9910 if (jj_3R_90()) return true;
9911 if (jj_scan_token(RPAREN)) return true;
9912 if (jj_3R_125()) return true;
9913 return false;
9914 }
9915
9916 private boolean jj_3_38() {
9917 if (jj_3R_126()) return true;
9918 return false;
9919 }
9920
9921 private boolean jj_3R_119() {
9922 if (jj_scan_token(PLUS)) return true;
9923 return false;
9924 }
9925
9926 private boolean jj_3R_280() {
9927 if (jj_scan_token(MINUS)) return true;
9928 return false;
9929 }
9930
9931 private boolean jj_3R_344() {
9932 if (jj_3R_95()) return true;
9933 Token xsp;
9934 xsp = jj_scanpos;
9935 if (jj_3R_354()) jj_scanpos = xsp;
9936 return false;
9937 }
9938
9939 private boolean jj_3R_122() {
9940 if (jj_scan_token(STAR)) return true;
9941 return false;
9942 }
9943
9944 private boolean jj_3R_108() {
9945 if (jj_scan_token(NE)) return true;
9946 return false;
9947 }
9948
9949 private boolean jj_3R_325() {
9950 if (jj_3R_344()) return true;
9951 return false;
9952 }
9953
9954 private boolean jj_3R_342() {
9955 if (jj_scan_token(TILDE)) return true;
9956 return false;
9957 }
9958
9959 private boolean jj_3R_324() {
9960 if (jj_3R_126()) return true;
9961 return false;
9962 }
9963
9964 private boolean jj_3R_323() {
9965 Token xsp;
9966 xsp = jj_scanpos;
9967 if (jj_3R_342()) {
9968 jj_scanpos = xsp;
9969 if (jj_3R_343()) return true;
9970 }
9971 if (jj_3R_125()) return true;
9972 return false;
9973 }
9974
9975 private boolean jj_3R_283() {
9976 Token xsp;
9977 xsp = jj_scanpos;
9978 if (jj_3R_323()) {
9979 jj_scanpos = xsp;
9980 if (jj_3R_324()) {
9981 jj_scanpos = xsp;
9982 if (jj_3R_325()) return true;
9983 }
9984 }
9985 return false;
9986 }
9987
9988 private boolean jj_3_36() {
9989 Token xsp;
9990 xsp = jj_scanpos;
9991 if (jj_3R_119()) {
9992 jj_scanpos = xsp;
9993 if (jj_3R_120()) return true;
9994 }
9995 if (jj_3R_121()) return true;
9996 return false;
9997 }
9998
9999 private boolean jj_3R_282() {
10000 if (jj_scan_token(DECR)) return true;
10001 if (jj_3R_95()) return true;
10002 return false;
10003 }
10004
10005 private boolean jj_3_37() {
10006 Token xsp;
10007 xsp = jj_scanpos;
10008 if (jj_3R_122()) {
10009 jj_scanpos = xsp;
10010 if (jj_3R_123()) {
10011 jj_scanpos = xsp;
10012 if (jj_3R_124()) return true;
10013 }
10014 }
10015 if (jj_3R_125()) return true;
10016 return false;
10017 }
10018
10019 private boolean jj_3R_281() {
10020 if (jj_scan_token(INCR)) return true;
10021 if (jj_3R_95()) return true;
10022 return false;
10023 }
10024
10025 private boolean jj_3R_199() {
10026 if (jj_3R_283()) return true;
10027 return false;
10028 }
10029
10030 private boolean jj_3R_198() {
10031 if (jj_3R_282()) return true;
10032 return false;
10033 }
10034
10035 private boolean jj_3R_197() {
10036 if (jj_3R_281()) return true;
10037 return false;
10038 }
10039
10040 private boolean jj_3R_279() {
10041 if (jj_scan_token(PLUS)) return true;
10042 return false;
10043 }
10044
10045 private boolean jj_3R_125() {
10046 Token xsp;
10047 xsp = jj_scanpos;
10048 if (jj_3R_196()) {
10049 jj_scanpos = xsp;
10050 if (jj_3R_197()) {
10051 jj_scanpos = xsp;
10052 if (jj_3R_198()) {
10053 jj_scanpos = xsp;
10054 if (jj_3R_199()) return true;
10055 }
10056 }
10057 }
10058 return false;
10059 }
10060
10061 private boolean jj_3R_196() {
10062 Token xsp;
10063 xsp = jj_scanpos;
10064 if (jj_3R_279()) {
10065 jj_scanpos = xsp;
10066 if (jj_3R_280()) return true;
10067 }
10068 if (jj_3R_125()) return true;
10069 return false;
10070 }
10071
10072 private boolean jj_3R_121() {
10073 if (jj_3R_125()) return true;
10074 Token xsp;
10075 while (true) {
10076 xsp = jj_scanpos;
10077 if (jj_3_37()) { jj_scanpos = xsp; break; }
10078 }
10079 return false;
10080 }
10081
10082 private boolean jj_3R_107() {
10083 if (jj_scan_token(EQ)) return true;
10084 return false;
10085 }
10086
10087 private boolean jj_3R_116() {
10088 if (jj_3R_121()) return true;
10089 Token xsp;
10090 while (true) {
10091 xsp = jj_scanpos;
10092 if (jj_3_36()) { jj_scanpos = xsp; break; }
10093 }
10094 return false;
10095 }
10096
10097 private boolean jj_3_35() {
10098 if (jj_3R_118()) return true;
10099 return false;
10100 }
10101
10102 private boolean jj_3_34() {
10103 if (jj_3R_117()) return true;
10104 return false;
10105 }
10106
10107 private boolean jj_3_31() {
10108 if (jj_scan_token(INSTANCEOF)) return true;
10109 if (jj_3R_90()) return true;
10110 return false;
10111 }
10112
10113 private boolean jj_3R_115() {
10114 if (jj_scan_token(LSHIFT)) return true;
10115 return false;
10116 }
10117
10118 private boolean jj_3_33() {
10119 Token xsp;
10120 xsp = jj_scanpos;
10121 if (jj_3R_115()) {
10122 jj_scanpos = xsp;
10123 if (jj_3_34()) {
10124 jj_scanpos = xsp;
10125 if (jj_3_35()) return true;
10126 }
10127 }
10128 if (jj_3R_116()) return true;
10129 return false;
10130 }
10131
10132 private boolean jj_3_30() {
10133 Token xsp;
10134 xsp = jj_scanpos;
10135 if (jj_3R_107()) {
10136 jj_scanpos = xsp;
10137 if (jj_3R_108()) return true;
10138 }
10139 if (jj_3R_109()) return true;
10140 return false;
10141 }
10142
10143 private boolean jj_3R_114() {
10144 if (jj_3R_116()) return true;
10145 Token xsp;
10146 while (true) {
10147 xsp = jj_scanpos;
10148 if (jj_3_33()) { jj_scanpos = xsp; break; }
10149 }
10150 return false;
10151 }
10152
10153 private boolean jj_3R_113() {
10154 if (jj_scan_token(GE)) return true;
10155 return false;
10156 }
10157
10158 private boolean jj_3R_112() {
10159 if (jj_scan_token(LE)) return true;
10160 return false;
10161 }
10162
10163 private boolean jj_3R_111() {
10164 if (jj_scan_token(GT)) return true;
10165 return false;
10166 }
10167
10168 private boolean jj_3R_110() {
10169 if (jj_scan_token(LT)) return true;
10170 return false;
10171 }
10172
10173 private boolean jj_3_29() {
10174 if (jj_scan_token(BIT_AND)) return true;
10175 if (jj_3R_106()) return true;
10176 return false;
10177 }
10178
10179 private boolean jj_3_32() {
10180 Token xsp;
10181 xsp = jj_scanpos;
10182 if (jj_3R_110()) {
10183 jj_scanpos = xsp;
10184 if (jj_3R_111()) {
10185 jj_scanpos = xsp;
10186 if (jj_3R_112()) {
10187 jj_scanpos = xsp;
10188 if (jj_3R_113()) return true;
10189 }
10190 }
10191 }
10192 if (jj_3R_114()) return true;
10193 return false;
10194 }
10195
10196 private boolean jj_3R_193() {
10197 if (jj_3R_114()) return true;
10198 Token xsp;
10199 while (true) {
10200 xsp = jj_scanpos;
10201 if (jj_3_32()) { jj_scanpos = xsp; break; }
10202 }
10203 return false;
10204 }
10205
10206 private boolean jj_3_27() {
10207 if (jj_scan_token(BIT_OR)) return true;
10208 if (jj_3R_104()) return true;
10209 return false;
10210 }
10211
10212 private boolean jj_3_28() {
10213 if (jj_scan_token(XOR)) return true;
10214 if (jj_3R_105()) return true;
10215 return false;
10216 }
10217
10218 private boolean jj_3R_109() {
10219 if (jj_3R_193()) return true;
10220 Token xsp;
10221 xsp = jj_scanpos;
10222 if (jj_3_31()) jj_scanpos = xsp;
10223 return false;
10224 }
10225
10226 private boolean jj_3_26() {
10227 if (jj_scan_token(SC_AND)) return true;
10228 if (jj_3R_103()) return true;
10229 return false;
10230 }
10231
10232 private boolean jj_3R_106() {
10233 if (jj_3R_109()) return true;
10234 Token xsp;
10235 while (true) {
10236 xsp = jj_scanpos;
10237 if (jj_3_30()) { jj_scanpos = xsp; break; }
10238 }
10239 return false;
10240 }
10241
10242 private boolean jj_3_25() {
10243 if (jj_scan_token(SC_OR)) return true;
10244 if (jj_3R_102()) return true;
10245 return false;
10246 }
10247
10248 private boolean jj_3R_105() {
10249 if (jj_3R_106()) return true;
10250 Token xsp;
10251 while (true) {
10252 xsp = jj_scanpos;
10253 if (jj_3_29()) { jj_scanpos = xsp; break; }
10254 }
10255 return false;
10256 }
10257
10258 private boolean jj_3_24() {
10259 if (jj_scan_token(HOOK)) return true;
10260 if (jj_3R_101()) return true;
10261 if (jj_scan_token(COLON)) return true;
10262 if (jj_3R_192()) return true;
10263 return false;
10264 }
10265
10266 private boolean jj_3R_104() {
10267 if (jj_3R_105()) return true;
10268 Token xsp;
10269 while (true) {
10270 xsp = jj_scanpos;
10271 if (jj_3_28()) { jj_scanpos = xsp; break; }
10272 }
10273 return false;
10274 }
10275
10276 private boolean jj_3R_103() {
10277 if (jj_3R_104()) return true;
10278 Token xsp;
10279 while (true) {
10280 xsp = jj_scanpos;
10281 if (jj_3_27()) { jj_scanpos = xsp; break; }
10282 }
10283 return false;
10284 }
10285
10286 private boolean jj_3R_102() {
10287 if (jj_3R_103()) return true;
10288 Token xsp;
10289 while (true) {
10290 xsp = jj_scanpos;
10291 if (jj_3_26()) { jj_scanpos = xsp; break; }
10292 }
10293 return false;
10294 }
10295
10296 private boolean jj_3R_278() {
10297 if (jj_3R_102()) return true;
10298 Token xsp;
10299 while (true) {
10300 xsp = jj_scanpos;
10301 if (jj_3_25()) { jj_scanpos = xsp; break; }
10302 }
10303 return false;
10304 }
10305
10306 private boolean jj_3R_192() {
10307 if (jj_3R_278()) return true;
10308 Token xsp;
10309 xsp = jj_scanpos;
10310 if (jj_3_24()) jj_scanpos = xsp;
10311 return false;
10312 }
10313
10314 private boolean jj_3R_191() {
10315 if (jj_scan_token(ORASSIGN)) return true;
10316 return false;
10317 }
10318
10319 private boolean jj_3R_190() {
10320 if (jj_scan_token(XORASSIGN)) return true;
10321 return false;
10322 }
10323
10324 private boolean jj_3R_189() {
10325 if (jj_scan_token(ANDASSIGN)) return true;
10326 return false;
10327 }
10328
10329 private boolean jj_3R_188() {
10330 if (jj_scan_token(RUNSIGNEDSHIFTASSIGN)) return true;
10331 return false;
10332 }
10333
10334 private boolean jj_3R_187() {
10335 if (jj_scan_token(RSIGNEDSHIFTASSIGN)) return true;
10336 return false;
10337 }
10338
10339 private boolean jj_3R_186() {
10340 if (jj_scan_token(LSHIFTASSIGN)) return true;
10341 return false;
10342 }
10343
10344 private boolean jj_3R_185() {
10345 if (jj_scan_token(MINUSASSIGN)) return true;
10346 return false;
10347 }
10348
10349 private boolean jj_3R_184() {
10350 if (jj_scan_token(PLUSASSIGN)) return true;
10351 return false;
10352 }
10353
10354 private boolean jj_3R_183() {
10355 if (jj_scan_token(REMASSIGN)) return true;
10356 return false;
10357 }
10358
10359 private boolean jj_3R_182() {
10360 if (jj_scan_token(SLASHASSIGN)) return true;
10361 return false;
10362 }
10363
10364 private boolean jj_3R_181() {
10365 if (jj_scan_token(STARASSIGN)) return true;
10366 return false;
10367 }
10368
10369 private boolean jj_3R_100() {
10370 Token xsp;
10371 xsp = jj_scanpos;
10372 if (jj_3R_180()) {
10373 jj_scanpos = xsp;
10374 if (jj_3R_181()) {
10375 jj_scanpos = xsp;
10376 if (jj_3R_182()) {
10377 jj_scanpos = xsp;
10378 if (jj_3R_183()) {
10379 jj_scanpos = xsp;
10380 if (jj_3R_184()) {
10381 jj_scanpos = xsp;
10382 if (jj_3R_185()) {
10383 jj_scanpos = xsp;
10384 if (jj_3R_186()) {
10385 jj_scanpos = xsp;
10386 if (jj_3R_187()) {
10387 jj_scanpos = xsp;
10388 if (jj_3R_188()) {
10389 jj_scanpos = xsp;
10390 if (jj_3R_189()) {
10391 jj_scanpos = xsp;
10392 if (jj_3R_190()) {
10393 jj_scanpos = xsp;
10394 if (jj_3R_191()) return true;
10395 }
10396 }
10397 }
10398 }
10399 }
10400 }
10401 }
10402 }
10403 }
10404 }
10405 }
10406 return false;
10407 }
10408
10409 private boolean jj_3R_180() {
10410 if (jj_scan_token(ASSIGN)) return true;
10411 return false;
10412 }
10413
10414 private boolean jj_3_23() {
10415 if (jj_3R_100()) return true;
10416 if (jj_3R_101()) return true;
10417 return false;
10418 }
10419
10420 private boolean jj_3R_101() {
10421 if (jj_3R_192()) return true;
10422 Token xsp;
10423 xsp = jj_scanpos;
10424 if (jj_3_23()) jj_scanpos = xsp;
10425 return false;
10426 }
10427
10428 private boolean jj_3R_437() {
10429 if (jj_3R_154()) return true;
10430 return false;
10431 }
10432
10433 private boolean jj_3R_433() {
10434 if (jj_scan_token(COMMA)) return true;
10435 Token xsp;
10436 while (true) {
10437 xsp = jj_scanpos;
10438 if (jj_3R_437()) { jj_scanpos = xsp; break; }
10439 }
10440 if (jj_3R_136()) return true;
10441 return false;
10442 }
10443
10444 private boolean jj_3R_432() {
10445 if (jj_3R_154()) return true;
10446 return false;
10447 }
10448
10449 private boolean jj_3R_426() {
10450 Token xsp;
10451 while (true) {
10452 xsp = jj_scanpos;
10453 if (jj_3R_432()) { jj_scanpos = xsp; break; }
10454 }
10455 if (jj_3R_136()) return true;
10456 while (true) {
10457 xsp = jj_scanpos;
10458 if (jj_3R_433()) { jj_scanpos = xsp; break; }
10459 }
10460 return false;
10461 }
10462
10463 private boolean jj_3_20() {
10464 if (jj_3R_97()) return true;
10465 return false;
10466 }
10467
10468 private boolean jj_3_22() {
10469 if (jj_scan_token(DOT)) return true;
10470 if (jj_scan_token(IDENTIFIER)) return true;
10471 return false;
10472 }
10473
10474 private boolean jj_3R_275() {
10475 if (jj_scan_token(COMMA)) return true;
10476 if (jj_3R_99()) return true;
10477 return false;
10478 }
10479
10480 private boolean jj_3R_136() {
10481 if (jj_scan_token(IDENTIFIER)) return true;
10482 Token xsp;
10483 while (true) {
10484 xsp = jj_scanpos;
10485 if (jj_3_22()) { jj_scanpos = xsp; break; }
10486 }
10487 return false;
10488 }
10489
10490 private boolean jj_3R_211() {
10491 if (jj_3R_90()) return true;
10492 return false;
10493 }
10494
10495 private boolean jj_3R_135() {
10496 Token xsp;
10497 xsp = jj_scanpos;
10498 if (jj_scan_token(59)) {
10499 jj_scanpos = xsp;
10500 if (jj_3R_211()) return true;
10501 }
10502 return false;
10503 }
10504
10505 private boolean jj_3R_224() {
10506 if (jj_scan_token(DOUBLE)) return true;
10507 return false;
10508 }
10509
10510 private boolean jj_3R_223() {
10511 if (jj_scan_token(FLOAT)) return true;
10512 return false;
10513 }
10514
10515 private boolean jj_3R_222() {
10516 if (jj_scan_token(LONG)) return true;
10517 return false;
10518 }
10519
10520 private boolean jj_3R_366() {
10521 if (jj_3R_154()) return true;
10522 return false;
10523 }
10524
10525 private boolean jj_3R_365() {
10526 if (jj_3R_154()) return true;
10527 return false;
10528 }
10529
10530 private boolean jj_3R_221() {
10531 if (jj_scan_token(INT)) return true;
10532 return false;
10533 }
10534
10535 private boolean jj_3R_220() {
10536 if (jj_scan_token(SHORT)) return true;
10537 return false;
10538 }
10539
10540
10541 public JavaParserTokenManager token_source;
10542
10543 public Token token;
10544
10545 public Token jj_nt;
10546 private Token jj_scanpos, jj_lastpos;
10547 private int jj_la;
10548
10549 private boolean jj_lookingAhead = false;
10550 private boolean jj_semLA;
10551 private int jj_gen;
10552 final private int[] jj_la1 = new int[151];
10553 static private int[] jj_la1_0;
10554 static private int[] jj_la1_1;
10555 static private int[] jj_la1_2;
10556 static private int[] jj_la1_3;
10557 static {
10558 jj_la1_init_0();
10559 jj_la1_init_1();
10560 jj_la1_init_2();
10561 jj_la1_init_3();
10562 }
10563 private static void jj_la1_init_0() {
10564 jj_la1_0 = new int[] {0x0,0x10481000,0x0,0x0,0x0,0x0,0x0,0x10401000,0x10081000,0x10481000,0x10001000,0x10001000,0x10081000,0x0,0x4000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x514cb000,0x0,0x0,0x0,0x0,0x0,0x4000000,0x0,0x514cb000,0x4104a000,0x514cb000,0x0,0x0,0x0,0x4904a000,0x4904a000,0x0,0x0,0x0,0x0,0x0,0x0,0x5104a000,0x10000000,0x10000000,0x0,0x0,0x0,0x0,0x0,0x4904a000,0x0,0x4104a000,0x4104a000,0x0,0x0,0x0,0x4000000,0x4104a000,0x0,0x0,0x4000000,0x4104a000,0x4104a000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4904a000,0x0,0x0,0x4904a000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8000000,0x0,0x0,0x4904a000,0x4904a000,0x0,0x4904a000,0x0,0x0,0x8000000,0x8000000,0x4904a000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc9a4e000,0x0,0x10000000,0x10000000,0x0,0x0,0x0,0x4904a000,0x410000,0x410000,0x2000000,0x5904a000,0x4904a000,0x4904a000,0x5904a000,0x4904a000,0x0,0x0,0x0,0x4904a000,0x0,0x20000,0x20000000,0x10000000,0x10000000,0x0,0x0,0x0,0x0,0x4904a000,0x0,0x4904a000,0x514cb000,0x10081000,0x4104a000,0x514cb000,0x400000,};
10565 }
10566 private static void jj_la1_init_1() {
10567 jj_la1_1 = new int[] {0x8,0x51127140,0x0,0x0,0x0,0x20000,0x0,0x51127100,0x40,0x51127140,0x0,0x0,0x40,0x0,0x0,0x4,0x0,0x0,0x0,0x0,0x0,0x0,0x4,0x0,0x0,0x0,0x0,0x591371e0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x591371e0,0x80100a0,0x591371e0,0x0,0x0,0x0,0x8a2506a0,0x8a2506a0,0x0,0x0,0x800000,0x0,0x0,0x0,0x100a0,0x0,0x0,0x0,0x0,0x0,0x800000,0x0,0x8a2506a0,0x20000,0x100a0,0x100a0,0x0,0x0,0x0,0x40000,0x100a0,0x0,0x0,0x40000,0x100a0,0x80100a0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8a2506a0,0x0,0x0,0x8a2506a0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x200,0x82240400,0x200,0x0,0x8a2506a0,0x8a2506a0,0x0,0x8a2506a0,0x0,0x0,0x82000400,0x2000000,0x8a2506a0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xae7d86a2,0x0,0x0,0x0,0x0,0x0,0x0,0x8a2506a0,0x0,0x0,0x0,0x8a2506a0,0x8a2506a0,0x8a2506a0,0x8a2506a0,0x8a2506a0,0x0,0x0,0x0,0x8a2506a0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8a2506a0,0x0,0x8a2506a0,0x511371e0,0x40,0x100a0,0x511371e0,0x0,};
10568 }
10569 private static void jj_la1_init_2() {
10570 jj_la1_2 = new int[] {0x0,0x240200,0x0,0x0,0x200000,0x0,0x100000,0x200000,0x200200,0x240200,0x0,0x0,0x0,0x800000,0x0,0x0,0x200000,0x80000,0x200000,0x200000,0x80000,0x200000,0x0,0x200000,0x200000,0x200200,0x80000,0xa44200,0x40000,0x1000,0x4000,0x80000,0x200000,0x0,0x0,0xa44200,0xa00200,0xa40200,0x80000,0x400000,0x10000,0x30053b0,0x30053b0,0x80000,0x800000,0x0,0x44000,0x10000,0x80000,0x200200,0x200000,0x200000,0x0,0x0,0x800000,0x0,0x800000,0x8013b0,0x0,0x0,0x200,0x80000,0x800000,0x200000,0x0,0x4200200,0x200000,0x200000,0x0,0x0,0x200,0x200000,0x80000,0x200000,0x400000,0x90000000,0x60800000,0x0,0x0,0x0,0x0,0x30013b0,0x3000000,0x3000000,0x13b0,0x0,0x0,0x200000,0x200000,0x0,0x200000,0x1000,0x100000,0x200,0x1b0,0x0,0x200,0x30053b0,0x30053b0,0x80000,0x30053b0,0x200,0x111000,0x1b0,0x0,0x30013b0,0x80000,0x200000,0x800000,0x4000,0x11000,0x200,0x10000,0x10000,0x453b0,0x200000,0x200000,0x200000,0x80000,0x400000,0x0,0x13b0,0x0,0x0,0x0,0x2013b0,0x30013b0,0x13b0,0x2413b0,0x13b0,0x80000,0x200,0x200,0x30013b0,0x1000,0x0,0x0,0x200000,0x200000,0x8000000,0x200000,0x200,0x80000,0x32053b0,0x80000,0x32053b0,0x240200,0x0,0x200200,0x240200,0x0,};
10571 }
10572 private static void jj_la1_init_3() {
10573 jj_la1_3 = new int[] {0x0,0x0,0x40000000,0x80000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x100,0x0,0x0,0x0,0x0,0x0,0x0,0x3c,0x3c,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x200,0x1000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffe000,0x0,0x20000000,0x1000,0x30,0x8c0,0x30,0x3c,0x0,0x0,0x0,0xc,0xc,0x0,0x0,0x100,0x0,0x0,0x4000000,0x0,0x0,0x0,0x0,0x3c,0x3c,0x0,0x3c,0x0,0x0,0x0,0x0,0x3c,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc,0x0,0x0,0x0,0x0,0xffe000,0xc,0x0,0x0,0x0,0x0,0xc,0x3c,0xc,0xc,0xc,0x0,0x0,0x0,0x3c,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3c,0x0,0x3c,0x0,0x0,0x0,0x0,0x0,};
10574 }
10575 final private JJCalls[] jj_2_rtns = new JJCalls[75];
10576 private boolean jj_rescan = false;
10577 private int jj_gc = 0;
10578
10579
10580 public JavaParser(CharStream stream) {
10581 token_source = new JavaParserTokenManager(stream);
10582 token = new Token();
10583 token.next = jj_nt = token_source.getNextToken();
10584 jj_gen = 0;
10585 for (int i = 0; i < 151; i++) jj_la1[i] = -1;
10586 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
10587 }
10588
10589
10590 public void ReInit(CharStream stream) {
10591 token_source.ReInit(stream);
10592 token = new Token();
10593 token.next = jj_nt = token_source.getNextToken();
10594 jj_lookingAhead = false;
10595 jjtree.reset();
10596 jj_gen = 0;
10597 for (int i = 0; i < 151; i++) jj_la1[i] = -1;
10598 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
10599 }
10600
10601
10602 public JavaParser(JavaParserTokenManager tm) {
10603 token_source = tm;
10604 token = new Token();
10605 token.next = jj_nt = token_source.getNextToken();
10606 jj_gen = 0;
10607 for (int i = 0; i < 151; i++) jj_la1[i] = -1;
10608 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
10609 }
10610
10611
10612 public void ReInit(JavaParserTokenManager tm) {
10613 token_source = tm;
10614 token = new Token();
10615 token.next = jj_nt = token_source.getNextToken();
10616 jjtree.reset();
10617 jj_gen = 0;
10618 for (int i = 0; i < 151; i++) jj_la1[i] = -1;
10619 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
10620 }
10621
10622 private Token jj_consume_token(int kind) throws ParseException {
10623 Token oldToken = token;
10624 if ((token = jj_nt).next != null) jj_nt = jj_nt.next;
10625 else jj_nt = jj_nt.next = token_source.getNextToken();
10626 if (token.kind == kind) {
10627 jj_gen++;
10628 if (++jj_gc > 100) {
10629 jj_gc = 0;
10630 for (int i = 0; i < jj_2_rtns.length; i++) {
10631 JJCalls c = jj_2_rtns[i];
10632 while (c != null) {
10633 if (c.gen < jj_gen) c.first = null;
10634 c = c.next;
10635 }
10636 }
10637 }
10638 return token;
10639 }
10640 jj_nt = token;
10641 token = oldToken;
10642 jj_kind = kind;
10643 throw generateParseException();
10644 }
10645
10646 static private final class LookaheadSuccess extends java.lang.Error { }
10647 final private LookaheadSuccess jj_ls = new LookaheadSuccess();
10648 private boolean jj_scan_token(int kind) {
10649 if (jj_scanpos == jj_lastpos) {
10650 jj_la--;
10651 if (jj_scanpos.next == null) {
10652 jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
10653 } else {
10654 jj_lastpos = jj_scanpos = jj_scanpos.next;
10655 }
10656 } else {
10657 jj_scanpos = jj_scanpos.next;
10658 }
10659 if (jj_rescan) {
10660 int i = 0; Token tok = token;
10661 while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; }
10662 if (tok != null) jj_add_error_token(kind, i);
10663 }
10664 if (jj_scanpos.kind != kind) return true;
10665 if (jj_la == 0 && jj_scanpos == jj_lastpos) throw jj_ls;
10666 return false;
10667 }
10668
10669
10670
10671 final public Token getNextToken() {
10672 if ((token = jj_nt).next != null) jj_nt = jj_nt.next;
10673 else jj_nt = jj_nt.next = token_source.getNextToken();
10674 jj_gen++;
10675 return token;
10676 }
10677
10678
10679 final public Token getToken(int index) {
10680 Token t = jj_lookingAhead ? jj_scanpos : token;
10681 for (int i = 0; i < index; i++) {
10682 if (t.next != null) t = t.next;
10683 else t = t.next = token_source.getNextToken();
10684 }
10685 return t;
10686 }
10687
10688 private java.util.List<int[]> jj_expentries = new java.util.ArrayList<int[]>();
10689 private int[] jj_expentry;
10690 private int jj_kind = -1;
10691 private int[] jj_lasttokens = new int[100];
10692 private int jj_endpos;
10693
10694 private void jj_add_error_token(int kind, int pos) {
10695 if (pos >= 100) return;
10696 if (pos == jj_endpos + 1) {
10697 jj_lasttokens[jj_endpos++] = kind;
10698 } else if (jj_endpos != 0) {
10699 jj_expentry = new int[jj_endpos];
10700 for (int i = 0; i < jj_endpos; i++) {
10701 jj_expentry[i] = jj_lasttokens[i];
10702 }
10703 jj_entries_loop: for (java.util.Iterator<?> it = jj_expentries.iterator(); it.hasNext();) {
10704 int[] oldentry = (int[])(it.next());
10705 if (oldentry.length == jj_expentry.length) {
10706 for (int i = 0; i < jj_expentry.length; i++) {
10707 if (oldentry[i] != jj_expentry[i]) {
10708 continue jj_entries_loop;
10709 }
10710 }
10711 jj_expentries.add(jj_expentry);
10712 break jj_entries_loop;
10713 }
10714 }
10715 if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind;
10716 }
10717 }
10718
10719
10720 public ParseException generateParseException() {
10721 jj_expentries.clear();
10722 boolean[] la1tokens = new boolean[128];
10723 if (jj_kind >= 0) {
10724 la1tokens[jj_kind] = true;
10725 jj_kind = -1;
10726 }
10727 for (int i = 0; i < 151; i++) {
10728 if (jj_la1[i] == jj_gen) {
10729 for (int j = 0; j < 32; j++) {
10730 if ((jj_la1_0[i] & (1<<j)) != 0) {
10731 la1tokens[j] = true;
10732 }
10733 if ((jj_la1_1[i] & (1<<j)) != 0) {
10734 la1tokens[32+j] = true;
10735 }
10736 if ((jj_la1_2[i] & (1<<j)) != 0) {
10737 la1tokens[64+j] = true;
10738 }
10739 if ((jj_la1_3[i] & (1<<j)) != 0) {
10740 la1tokens[96+j] = true;
10741 }
10742 }
10743 }
10744 }
10745 for (int i = 0; i < 128; i++) {
10746 if (la1tokens[i]) {
10747 jj_expentry = new int[1];
10748 jj_expentry[0] = i;
10749 jj_expentries.add(jj_expentry);
10750 }
10751 }
10752 jj_endpos = 0;
10753 jj_rescan_token();
10754 jj_add_error_token(0, 0);
10755 int[][] exptokseq = new int[jj_expentries.size()][];
10756 for (int i = 0; i < jj_expentries.size(); i++) {
10757 exptokseq[i] = jj_expentries.get(i);
10758 }
10759 return new ParseException(token, exptokseq, tokenImage);
10760 }
10761
10762
10763 final public void enable_tracing() {
10764 }
10765
10766
10767 final public void disable_tracing() {
10768 }
10769
10770 private void jj_rescan_token() {
10771 jj_rescan = true;
10772 for (int i = 0; i < 75; i++) {
10773 try {
10774 JJCalls p = jj_2_rtns[i];
10775 do {
10776 if (p.gen > jj_gen) {
10777 jj_la = p.arg; jj_lastpos = jj_scanpos = p.first;
10778 switch (i) {
10779 case 0: jj_3_1(); break;
10780 case 1: jj_3_2(); break;
10781 case 2: jj_3_3(); break;
10782 case 3: jj_3_4(); break;
10783 case 4: jj_3_5(); break;
10784 case 5: jj_3_6(); break;
10785 case 6: jj_3_7(); break;
10786 case 7: jj_3_8(); break;
10787 case 8: jj_3_9(); break;
10788 case 9: jj_3_10(); break;
10789 case 10: jj_3_11(); break;
10790 case 11: jj_3_12(); break;
10791 case 12: jj_3_13(); break;
10792 case 13: jj_3_14(); break;
10793 case 14: jj_3_15(); break;
10794 case 15: jj_3_16(); break;
10795 case 16: jj_3_17(); break;
10796 case 17: jj_3_18(); break;
10797 case 18: jj_3_19(); break;
10798 case 19: jj_3_20(); break;
10799 case 20: jj_3_21(); break;
10800 case 21: jj_3_22(); break;
10801 case 22: jj_3_23(); break;
10802 case 23: jj_3_24(); break;
10803 case 24: jj_3_25(); break;
10804 case 25: jj_3_26(); break;
10805 case 26: jj_3_27(); break;
10806 case 27: jj_3_28(); break;
10807 case 28: jj_3_29(); break;
10808 case 29: jj_3_30(); break;
10809 case 30: jj_3_31(); break;
10810 case 31: jj_3_32(); break;
10811 case 32: jj_3_33(); break;
10812 case 33: jj_3_34(); break;
10813 case 34: jj_3_35(); break;
10814 case 35: jj_3_36(); break;
10815 case 36: jj_3_37(); break;
10816 case 37: jj_3_38(); break;
10817 case 38: jj_3_39(); break;
10818 case 39: jj_3_40(); break;
10819 case 40: jj_3_41(); break;
10820 case 41: jj_3_42(); break;
10821 case 42: jj_3_43(); break;
10822 case 43: jj_3_44(); break;
10823 case 44: jj_3_45(); break;
10824 case 45: jj_3_46(); break;
10825 case 46: jj_3_47(); break;
10826 case 47: jj_3_48(); break;
10827 case 48: jj_3_49(); break;
10828 case 49: jj_3_50(); break;
10829 case 50: jj_3_51(); break;
10830 case 51: jj_3_52(); break;
10831 case 52: jj_3_53(); break;
10832 case 53: jj_3_54(); break;
10833 case 54: jj_3_55(); break;
10834 case 55: jj_3_56(); break;
10835 case 56: jj_3_57(); break;
10836 case 57: jj_3_58(); break;
10837 case 58: jj_3_59(); break;
10838 case 59: jj_3_60(); break;
10839 case 60: jj_3_61(); break;
10840 case 61: jj_3_62(); break;
10841 case 62: jj_3_63(); break;
10842 case 63: jj_3_64(); break;
10843 case 64: jj_3_65(); break;
10844 case 65: jj_3_66(); break;
10845 case 66: jj_3_67(); break;
10846 case 67: jj_3_68(); break;
10847 case 68: jj_3_69(); break;
10848 case 69: jj_3_70(); break;
10849 case 70: jj_3_71(); break;
10850 case 71: jj_3_72(); break;
10851 case 72: jj_3_73(); break;
10852 case 73: jj_3_74(); break;
10853 case 74: jj_3_75(); break;
10854 }
10855 }
10856 p = p.next;
10857 } while (p != null);
10858 } catch(LookaheadSuccess ls) { }
10859 }
10860 jj_rescan = false;
10861 }
10862
10863 private void jj_save(int index, int xla) {
10864 JJCalls p = jj_2_rtns[index];
10865 while (p.gen > jj_gen) {
10866 if (p.next == null) { p = p.next = new JJCalls(); break; }
10867 p = p.next;
10868 }
10869 p.gen = jj_gen + xla - jj_la; p.first = token; p.arg = xla;
10870 }
10871
10872 static final class JJCalls {
10873 int gen;
10874 Token first;
10875 int arg;
10876 JJCalls next;
10877 }
10878
10879 }