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(2147483647)) {
3716 LambdaExpression();
3717 } else if (jj_2_47(3)) {
3718 jj_consume_token(LPAREN);
3719 Expression();
3720 jj_consume_token(RPAREN);
3721 } else {
3722 switch (jj_nt.kind) {
3723 case NEW:
3724 AllocationExpression();
3725 break;
3726 default:
3727 jj_la1[95] = jj_gen;
3728 if (jj_2_48(2147483647)) {
3729 ResultType();
3730 jj_consume_token(DOT);
3731 jj_consume_token(CLASS);
3732 } else if (jj_2_49(2147483647)) {
3733 Name();
3734 } else if (jj_2_50(2147483647)) {
3735 ReferenceType();
3736 MethodReference();
3737 } else {
3738 switch (jj_nt.kind) {
3739 case IDENTIFIER:
3740 Name();
3741 break;
3742 default:
3743 jj_la1[96] = jj_gen;
3744 jj_consume_token(-1);
3745 throw new ParseException();
3746 }
3747 }
3748 }
3749 }
3750 }
3751 } catch (Throwable jjte000) {
3752 if (jjtc000) {
3753 jjtree.clearNodeScope(jjtn000);
3754 jjtc000 = false;
3755 } else {
3756 jjtree.popNode();
3757 }
3758 if (jjte000 instanceof RuntimeException) {
3759 {if (true) throw (RuntimeException)jjte000;}
3760 }
3761 if (jjte000 instanceof ParseException) {
3762 {if (true) throw (ParseException)jjte000;}
3763 }
3764 {if (true) throw (Error)jjte000;}
3765 } finally {
3766 if (jjtc000) {
3767 jjtree.closeNodeScope(jjtn000, true);
3768 }
3769 }
3770 }
3771
3772 final public void LambdaExpression() throws ParseException {
3773
3774 ASTLambdaExpression jjtn000 = new ASTLambdaExpression(this, JJTLAMBDAEXPRESSION);
3775 boolean jjtc000 = true;
3776 jjtree.openNodeScope(jjtn000);checkForBadLambdaUsage();
3777 try {
3778 switch (jj_nt.kind) {
3779 case IDENTIFIER:
3780 VariableDeclaratorId();
3781 jj_consume_token(LAMBDA);
3782 switch (jj_nt.kind) {
3783 case BOOLEAN:
3784 case BYTE:
3785 case CHAR:
3786 case DOUBLE:
3787 case FALSE:
3788 case FLOAT:
3789 case INT:
3790 case LONG:
3791 case NEW:
3792 case NULL:
3793 case SHORT:
3794 case SUPER:
3795 case THIS:
3796 case TRUE:
3797 case VOID:
3798 case INTEGER_LITERAL:
3799 case FLOATING_POINT_LITERAL:
3800 case HEX_FLOATING_POINT_LITERAL:
3801 case CHARACTER_LITERAL:
3802 case STRING_LITERAL:
3803 case IDENTIFIER:
3804 case LPAREN:
3805 case BANG:
3806 case TILDE:
3807 case INCR:
3808 case DECR:
3809 case PLUS:
3810 case MINUS:
3811 Expression();
3812 break;
3813 case LBRACE:
3814 Block();
3815 break;
3816 default:
3817 jj_la1[97] = jj_gen;
3818 jj_consume_token(-1);
3819 throw new ParseException();
3820 }
3821 break;
3822 default:
3823 jj_la1[101] = jj_gen;
3824 if (jj_2_51(3)) {
3825 FormalParameters();
3826 jj_consume_token(LAMBDA);
3827 switch (jj_nt.kind) {
3828 case BOOLEAN:
3829 case BYTE:
3830 case CHAR:
3831 case DOUBLE:
3832 case FALSE:
3833 case FLOAT:
3834 case INT:
3835 case LONG:
3836 case NEW:
3837 case NULL:
3838 case SHORT:
3839 case SUPER:
3840 case THIS:
3841 case TRUE:
3842 case VOID:
3843 case INTEGER_LITERAL:
3844 case FLOATING_POINT_LITERAL:
3845 case HEX_FLOATING_POINT_LITERAL:
3846 case CHARACTER_LITERAL:
3847 case STRING_LITERAL:
3848 case IDENTIFIER:
3849 case LPAREN:
3850 case BANG:
3851 case TILDE:
3852 case INCR:
3853 case DECR:
3854 case PLUS:
3855 case MINUS:
3856 Expression();
3857 break;
3858 case LBRACE:
3859 Block();
3860 break;
3861 default:
3862 jj_la1[98] = jj_gen;
3863 jj_consume_token(-1);
3864 throw new ParseException();
3865 }
3866 } else if (jj_2_52(3)) {
3867 jj_consume_token(LPAREN);
3868 VariableDeclaratorId();
3869 label_53:
3870 while (true) {
3871 switch (jj_nt.kind) {
3872 case COMMA:
3873 ;
3874 break;
3875 default:
3876 jj_la1[99] = jj_gen;
3877 break label_53;
3878 }
3879 jj_consume_token(COMMA);
3880 VariableDeclaratorId();
3881 }
3882 jj_consume_token(RPAREN);
3883 jj_consume_token(LAMBDA);
3884 switch (jj_nt.kind) {
3885 case BOOLEAN:
3886 case BYTE:
3887 case CHAR:
3888 case DOUBLE:
3889 case FALSE:
3890 case FLOAT:
3891 case INT:
3892 case LONG:
3893 case NEW:
3894 case NULL:
3895 case SHORT:
3896 case SUPER:
3897 case THIS:
3898 case TRUE:
3899 case VOID:
3900 case INTEGER_LITERAL:
3901 case FLOATING_POINT_LITERAL:
3902 case HEX_FLOATING_POINT_LITERAL:
3903 case CHARACTER_LITERAL:
3904 case STRING_LITERAL:
3905 case IDENTIFIER:
3906 case LPAREN:
3907 case BANG:
3908 case TILDE:
3909 case INCR:
3910 case DECR:
3911 case PLUS:
3912 case MINUS:
3913 Expression();
3914 break;
3915 case LBRACE:
3916 Block();
3917 break;
3918 default:
3919 jj_la1[100] = jj_gen;
3920 jj_consume_token(-1);
3921 throw new ParseException();
3922 }
3923 } else {
3924 jj_consume_token(-1);
3925 throw new ParseException();
3926 }
3927 }
3928 } catch (Throwable jjte000) {
3929 if (jjtc000) {
3930 jjtree.clearNodeScope(jjtn000);
3931 jjtc000 = false;
3932 } else {
3933 jjtree.popNode();
3934 }
3935 if (jjte000 instanceof RuntimeException) {
3936 {if (true) throw (RuntimeException)jjte000;}
3937 }
3938 if (jjte000 instanceof ParseException) {
3939 {if (true) throw (ParseException)jjte000;}
3940 }
3941 {if (true) throw (Error)jjte000;}
3942 } finally {
3943 if (jjtc000) {
3944 jjtree.closeNodeScope(jjtn000, true);
3945 }
3946 }
3947 }
3948
3949 final public void PrimarySuffix() throws ParseException {
3950
3951 ASTPrimarySuffix jjtn000 = new ASTPrimarySuffix(this, JJTPRIMARYSUFFIX);
3952 boolean jjtc000 = true;
3953 jjtree.openNodeScope(jjtn000);Token t;
3954 try {
3955 if (jj_2_53(2)) {
3956 jj_consume_token(DOT);
3957 jj_consume_token(THIS);
3958 } else if (jj_2_54(2)) {
3959 jj_consume_token(DOT);
3960 jj_consume_token(SUPER);
3961 } else if (jj_2_55(2)) {
3962 jj_consume_token(DOT);
3963 AllocationExpression();
3964 } else if (jj_2_56(3)) {
3965 MemberSelector();
3966 } else {
3967 switch (jj_nt.kind) {
3968 case LBRACKET:
3969 jj_consume_token(LBRACKET);
3970 Expression();
3971 jj_consume_token(RBRACKET);
3972 jjtree.closeNodeScope(jjtn000, true);
3973 jjtc000 = false;
3974 jjtn000.setIsArrayDereference();
3975 break;
3976 case DOT:
3977 jj_consume_token(DOT);
3978 t = jj_consume_token(IDENTIFIER);
3979 jjtree.closeNodeScope(jjtn000, true);
3980 jjtc000 = false;
3981 jjtn000.setImage(t.image);
3982 break;
3983 case LPAREN:
3984 Arguments();
3985 jjtree.closeNodeScope(jjtn000, true);
3986 jjtc000 = false;
3987 jjtn000.setIsArguments();
3988 break;
3989 default:
3990 jj_la1[102] = jj_gen;
3991 jj_consume_token(-1);
3992 throw new ParseException();
3993 }
3994 }
3995 } catch (Throwable jjte000) {
3996 if (jjtc000) {
3997 jjtree.clearNodeScope(jjtn000);
3998 jjtc000 = false;
3999 } else {
4000 jjtree.popNode();
4001 }
4002 if (jjte000 instanceof RuntimeException) {
4003 {if (true) throw (RuntimeException)jjte000;}
4004 }
4005 if (jjte000 instanceof ParseException) {
4006 {if (true) throw (ParseException)jjte000;}
4007 }
4008 {if (true) throw (Error)jjte000;}
4009 } finally {
4010 if (jjtc000) {
4011 jjtree.closeNodeScope(jjtn000, true);
4012 }
4013 }
4014 }
4015
4016 final public void Literal() throws ParseException {
4017
4018 ASTLiteral jjtn000 = new ASTLiteral(this, JJTLITERAL);
4019 boolean jjtc000 = true;
4020 jjtree.openNodeScope(jjtn000);
4021 try {
4022 switch (jj_nt.kind) {
4023 case INTEGER_LITERAL:
4024 Token t;
4025 t = jj_consume_token(INTEGER_LITERAL);
4026 jjtree.closeNodeScope(jjtn000, true);
4027 jjtc000 = false;
4028 checkForBadNumericalLiteralslUsage(t); jjtn000.setImage(t.image); jjtn000.setIntLiteral();
4029 break;
4030 case FLOATING_POINT_LITERAL:
4031 t = jj_consume_token(FLOATING_POINT_LITERAL);
4032 jjtree.closeNodeScope(jjtn000, true);
4033 jjtc000 = false;
4034 checkForBadNumericalLiteralslUsage(t); jjtn000.setImage(t.image); jjtn000.setFloatLiteral();
4035 break;
4036 case HEX_FLOATING_POINT_LITERAL:
4037 t = jj_consume_token(HEX_FLOATING_POINT_LITERAL);
4038 jjtree.closeNodeScope(jjtn000, true);
4039 jjtc000 = false;
4040 checkForBadHexFloatingPointLiteral(); checkForBadNumericalLiteralslUsage(t); jjtn000.setImage(t.image); jjtn000.setFloatLiteral();
4041 break;
4042 case CHARACTER_LITERAL:
4043 t = jj_consume_token(CHARACTER_LITERAL);
4044 jjtree.closeNodeScope(jjtn000, true);
4045 jjtc000 = false;
4046 jjtn000.setImage(t.image); jjtn000.setCharLiteral();
4047 break;
4048 case STRING_LITERAL:
4049 t = jj_consume_token(STRING_LITERAL);
4050 jjtree.closeNodeScope(jjtn000, true);
4051 jjtc000 = false;
4052 jjtn000.setImage(t.image); jjtn000.setStringLiteral();
4053 break;
4054 case FALSE:
4055 case TRUE:
4056 BooleanLiteral();
4057 break;
4058 case NULL:
4059 NullLiteral();
4060 break;
4061 default:
4062 jj_la1[103] = jj_gen;
4063 jj_consume_token(-1);
4064 throw new ParseException();
4065 }
4066 } catch (Throwable jjte000) {
4067 if (jjtc000) {
4068 jjtree.clearNodeScope(jjtn000);
4069 jjtc000 = false;
4070 } else {
4071 jjtree.popNode();
4072 }
4073 if (jjte000 instanceof RuntimeException) {
4074 {if (true) throw (RuntimeException)jjte000;}
4075 }
4076 if (jjte000 instanceof ParseException) {
4077 {if (true) throw (ParseException)jjte000;}
4078 }
4079 {if (true) throw (Error)jjte000;}
4080 } finally {
4081 if (jjtc000) {
4082 jjtree.closeNodeScope(jjtn000, true);
4083 }
4084 }
4085 }
4086
4087 final public void BooleanLiteral() throws ParseException {
4088
4089 ASTBooleanLiteral jjtn000 = new ASTBooleanLiteral(this, JJTBOOLEANLITERAL);
4090 boolean jjtc000 = true;
4091 jjtree.openNodeScope(jjtn000);
4092 try {
4093 switch (jj_nt.kind) {
4094 case TRUE:
4095 jj_consume_token(TRUE);
4096 jjtree.closeNodeScope(jjtn000, true);
4097 jjtc000 = false;
4098 jjtn000.setTrue();
4099 break;
4100 case FALSE:
4101 jj_consume_token(FALSE);
4102 break;
4103 default:
4104 jj_la1[104] = jj_gen;
4105 jj_consume_token(-1);
4106 throw new ParseException();
4107 }
4108 } finally {
4109 if (jjtc000) {
4110 jjtree.closeNodeScope(jjtn000, true);
4111 }
4112 }
4113 }
4114
4115 final public void NullLiteral() throws ParseException {
4116
4117 ASTNullLiteral jjtn000 = new ASTNullLiteral(this, JJTNULLLITERAL);
4118 boolean jjtc000 = true;
4119 jjtree.openNodeScope(jjtn000);
4120 try {
4121 jj_consume_token(NULL);
4122 } finally {
4123 if (jjtc000) {
4124 jjtree.closeNodeScope(jjtn000, true);
4125 }
4126 }
4127 }
4128
4129 final public void Arguments() throws ParseException {
4130
4131 ASTArguments jjtn000 = new ASTArguments(this, JJTARGUMENTS);
4132 boolean jjtc000 = true;
4133 jjtree.openNodeScope(jjtn000);
4134 try {
4135 jj_consume_token(LPAREN);
4136 switch (jj_nt.kind) {
4137 case BOOLEAN:
4138 case BYTE:
4139 case CHAR:
4140 case DOUBLE:
4141 case FALSE:
4142 case FLOAT:
4143 case INT:
4144 case LONG:
4145 case NEW:
4146 case NULL:
4147 case SHORT:
4148 case SUPER:
4149 case THIS:
4150 case TRUE:
4151 case VOID:
4152 case INTEGER_LITERAL:
4153 case FLOATING_POINT_LITERAL:
4154 case HEX_FLOATING_POINT_LITERAL:
4155 case CHARACTER_LITERAL:
4156 case STRING_LITERAL:
4157 case IDENTIFIER:
4158 case LPAREN:
4159 case BANG:
4160 case TILDE:
4161 case INCR:
4162 case DECR:
4163 case PLUS:
4164 case MINUS:
4165 ArgumentList();
4166 break;
4167 default:
4168 jj_la1[105] = jj_gen;
4169 ;
4170 }
4171 jj_consume_token(RPAREN);
4172 } catch (Throwable jjte000) {
4173 if (jjtc000) {
4174 jjtree.clearNodeScope(jjtn000);
4175 jjtc000 = false;
4176 } else {
4177 jjtree.popNode();
4178 }
4179 if (jjte000 instanceof RuntimeException) {
4180 {if (true) throw (RuntimeException)jjte000;}
4181 }
4182 if (jjte000 instanceof ParseException) {
4183 {if (true) throw (ParseException)jjte000;}
4184 }
4185 {if (true) throw (Error)jjte000;}
4186 } finally {
4187 if (jjtc000) {
4188 jjtree.closeNodeScope(jjtn000, true);
4189 }
4190 }
4191 }
4192
4193 final public void ArgumentList() throws ParseException {
4194
4195 ASTArgumentList jjtn000 = new ASTArgumentList(this, JJTARGUMENTLIST);
4196 boolean jjtc000 = true;
4197 jjtree.openNodeScope(jjtn000);
4198 try {
4199 Expression();
4200 label_54:
4201 while (true) {
4202 switch (jj_nt.kind) {
4203 case COMMA:
4204 ;
4205 break;
4206 default:
4207 jj_la1[106] = jj_gen;
4208 break label_54;
4209 }
4210 jj_consume_token(COMMA);
4211 Expression();
4212 }
4213 } catch (Throwable jjte000) {
4214 if (jjtc000) {
4215 jjtree.clearNodeScope(jjtn000);
4216 jjtc000 = false;
4217 } else {
4218 jjtree.popNode();
4219 }
4220 if (jjte000 instanceof RuntimeException) {
4221 {if (true) throw (RuntimeException)jjte000;}
4222 }
4223 if (jjte000 instanceof ParseException) {
4224 {if (true) throw (ParseException)jjte000;}
4225 }
4226 {if (true) throw (Error)jjte000;}
4227 } finally {
4228 if (jjtc000) {
4229 jjtree.closeNodeScope(jjtn000, true);
4230 }
4231 }
4232 }
4233
4234 final public void AllocationExpression() throws ParseException {
4235
4236 ASTAllocationExpression jjtn000 = new ASTAllocationExpression(this, JJTALLOCATIONEXPRESSION);
4237 boolean jjtc000 = true;
4238 jjtree.openNodeScope(jjtn000);
4239 try {
4240 jj_consume_token(NEW);
4241 label_55:
4242 while (true) {
4243 switch (jj_nt.kind) {
4244 case AT:
4245 ;
4246 break;
4247 default:
4248 jj_la1[107] = jj_gen;
4249 break label_55;
4250 }
4251 Annotation();
4252 checkForBadTypeAnnotations();
4253 }
4254 if (jj_2_57(2)) {
4255 PrimitiveType();
4256 ArrayDimsAndInits();
4257 } else {
4258 switch (jj_nt.kind) {
4259 case IDENTIFIER:
4260 ClassOrInterfaceType();
4261 switch (jj_nt.kind) {
4262 case LT:
4263 TypeArguments();
4264 break;
4265 default:
4266 jj_la1[108] = jj_gen;
4267 ;
4268 }
4269 switch (jj_nt.kind) {
4270 case LBRACKET:
4271 ArrayDimsAndInits();
4272 break;
4273 case LPAREN:
4274 Arguments();
4275 switch (jj_nt.kind) {
4276 case LBRACE:
4277 ClassOrInterfaceBody();
4278 break;
4279 default:
4280 jj_la1[109] = jj_gen;
4281 ;
4282 }
4283 break;
4284 default:
4285 jj_la1[110] = jj_gen;
4286 jj_consume_token(-1);
4287 throw new ParseException();
4288 }
4289 break;
4290 default:
4291 jj_la1[111] = jj_gen;
4292 jj_consume_token(-1);
4293 throw new ParseException();
4294 }
4295 }
4296 } catch (Throwable jjte000) {
4297 if (jjtc000) {
4298 jjtree.clearNodeScope(jjtn000);
4299 jjtc000 = false;
4300 } else {
4301 jjtree.popNode();
4302 }
4303 if (jjte000 instanceof RuntimeException) {
4304 {if (true) throw (RuntimeException)jjte000;}
4305 }
4306 if (jjte000 instanceof ParseException) {
4307 {if (true) throw (ParseException)jjte000;}
4308 }
4309 {if (true) throw (Error)jjte000;}
4310 } finally {
4311 if (jjtc000) {
4312 jjtree.closeNodeScope(jjtn000, true);
4313 }
4314 }
4315 }
4316
4317
4318
4319
4320
4321 final public void ArrayDimsAndInits() throws ParseException {
4322
4323 ASTArrayDimsAndInits jjtn000 = new ASTArrayDimsAndInits(this, JJTARRAYDIMSANDINITS);
4324 boolean jjtc000 = true;
4325 jjtree.openNodeScope(jjtn000);
4326 try {
4327 if (jj_2_60(2)) {
4328 label_56:
4329 while (true) {
4330 jj_consume_token(LBRACKET);
4331 Expression();
4332 jj_consume_token(RBRACKET);
4333 if (jj_2_58(2)) {
4334 ;
4335 } else {
4336 break label_56;
4337 }
4338 }
4339 label_57:
4340 while (true) {
4341 if (jj_2_59(2)) {
4342 ;
4343 } else {
4344 break label_57;
4345 }
4346 jj_consume_token(LBRACKET);
4347 jj_consume_token(RBRACKET);
4348 }
4349 } else {
4350 switch (jj_nt.kind) {
4351 case LBRACKET:
4352 label_58:
4353 while (true) {
4354 jj_consume_token(LBRACKET);
4355 jj_consume_token(RBRACKET);
4356 switch (jj_nt.kind) {
4357 case LBRACKET:
4358 ;
4359 break;
4360 default:
4361 jj_la1[112] = jj_gen;
4362 break label_58;
4363 }
4364 }
4365 ArrayInitializer();
4366 break;
4367 default:
4368 jj_la1[113] = jj_gen;
4369 jj_consume_token(-1);
4370 throw new ParseException();
4371 }
4372 }
4373 } catch (Throwable jjte000) {
4374 if (jjtc000) {
4375 jjtree.clearNodeScope(jjtn000);
4376 jjtc000 = false;
4377 } else {
4378 jjtree.popNode();
4379 }
4380 if (jjte000 instanceof RuntimeException) {
4381 {if (true) throw (RuntimeException)jjte000;}
4382 }
4383 if (jjte000 instanceof ParseException) {
4384 {if (true) throw (ParseException)jjte000;}
4385 }
4386 {if (true) throw (Error)jjte000;}
4387 } finally {
4388 if (jjtc000) {
4389 jjtree.closeNodeScope(jjtn000, true);
4390 }
4391 }
4392 }
4393
4394
4395
4396
4397 final public void Statement() throws ParseException {
4398
4399 ASTStatement jjtn000 = new ASTStatement(this, JJTSTATEMENT);
4400 boolean jjtc000 = true;
4401 jjtree.openNodeScope(jjtn000);
4402 try {
4403 if (isNextTokenAnAssert()) {
4404 AssertStatement();
4405 } else if (jj_2_61(2)) {
4406 LabeledStatement();
4407 } else {
4408 switch (jj_nt.kind) {
4409 case LBRACE:
4410 Block();
4411 break;
4412 case SEMICOLON:
4413 EmptyStatement();
4414 break;
4415 case BOOLEAN:
4416 case BYTE:
4417 case CHAR:
4418 case DOUBLE:
4419 case FALSE:
4420 case FLOAT:
4421 case INT:
4422 case LONG:
4423 case NEW:
4424 case NULL:
4425 case SHORT:
4426 case SUPER:
4427 case THIS:
4428 case TRUE:
4429 case VOID:
4430 case INTEGER_LITERAL:
4431 case FLOATING_POINT_LITERAL:
4432 case HEX_FLOATING_POINT_LITERAL:
4433 case CHARACTER_LITERAL:
4434 case STRING_LITERAL:
4435 case IDENTIFIER:
4436 case LPAREN:
4437 case INCR:
4438 case DECR:
4439 StatementExpression();
4440 jj_consume_token(SEMICOLON);
4441 break;
4442 case SWITCH:
4443 SwitchStatement();
4444 break;
4445 case IF:
4446 IfStatement();
4447 break;
4448 case WHILE:
4449 WhileStatement();
4450 break;
4451 case DO:
4452 DoStatement();
4453 break;
4454 case FOR:
4455 ForStatement();
4456 break;
4457 case BREAK:
4458 BreakStatement();
4459 break;
4460 case CONTINUE:
4461 ContinueStatement();
4462 break;
4463 case RETURN:
4464 ReturnStatement();
4465 break;
4466 case THROW:
4467 ThrowStatement();
4468 break;
4469 case SYNCHRONIZED:
4470 SynchronizedStatement();
4471 break;
4472 case TRY:
4473 TryStatement();
4474 break;
4475 default:
4476 jj_la1[114] = jj_gen;
4477 jj_consume_token(-1);
4478 throw new ParseException();
4479 }
4480 }
4481 } catch (Throwable jjte000) {
4482 if (jjtc000) {
4483 jjtree.clearNodeScope(jjtn000);
4484 jjtc000 = false;
4485 } else {
4486 jjtree.popNode();
4487 }
4488 if (jjte000 instanceof RuntimeException) {
4489 {if (true) throw (RuntimeException)jjte000;}
4490 }
4491 if (jjte000 instanceof ParseException) {
4492 {if (true) throw (ParseException)jjte000;}
4493 }
4494 {if (true) throw (Error)jjte000;}
4495 } finally {
4496 if (jjtc000) {
4497 jjtree.closeNodeScope(jjtn000, true);
4498 }
4499 }
4500 }
4501
4502 final public void LabeledStatement() throws ParseException {
4503
4504 ASTLabeledStatement jjtn000 = new ASTLabeledStatement(this, JJTLABELEDSTATEMENT);
4505 boolean jjtc000 = true;
4506 jjtree.openNodeScope(jjtn000);Token t;
4507 try {
4508 t = jj_consume_token(IDENTIFIER);
4509 jjtn000.setImage(t.image);
4510 jj_consume_token(COLON);
4511 Statement();
4512 } catch (Throwable jjte000) {
4513 if (jjtc000) {
4514 jjtree.clearNodeScope(jjtn000);
4515 jjtc000 = false;
4516 } else {
4517 jjtree.popNode();
4518 }
4519 if (jjte000 instanceof RuntimeException) {
4520 {if (true) throw (RuntimeException)jjte000;}
4521 }
4522 if (jjte000 instanceof ParseException) {
4523 {if (true) throw (ParseException)jjte000;}
4524 }
4525 {if (true) throw (Error)jjte000;}
4526 } finally {
4527 if (jjtc000) {
4528 jjtree.closeNodeScope(jjtn000, true);
4529 }
4530 }
4531 }
4532
4533 final public void Block() throws ParseException {
4534
4535 ASTBlock jjtn000 = new ASTBlock(this, JJTBLOCK);
4536 boolean jjtc000 = true;
4537 jjtree.openNodeScope(jjtn000);Token t;
4538 try {
4539 jj_consume_token(LBRACE);
4540 label_59:
4541 while (true) {
4542 if (jj_2_62(1)) {
4543 ;
4544 } else {
4545 break label_59;
4546 }
4547 BlockStatement();
4548 }
4549 t = jj_consume_token(RBRACE);
4550 jjtree.closeNodeScope(jjtn000, true);
4551 jjtc000 = false;
4552 if (isPrecededByComment(t)) { jjtn000.setContainsComment(); }
4553 } catch (Throwable jjte000) {
4554 if (jjtc000) {
4555 jjtree.clearNodeScope(jjtn000);
4556 jjtc000 = false;
4557 } else {
4558 jjtree.popNode();
4559 }
4560 if (jjte000 instanceof RuntimeException) {
4561 {if (true) throw (RuntimeException)jjte000;}
4562 }
4563 if (jjte000 instanceof ParseException) {
4564 {if (true) throw (ParseException)jjte000;}
4565 }
4566 {if (true) throw (Error)jjte000;}
4567 } finally {
4568 if (jjtc000) {
4569 jjtree.closeNodeScope(jjtn000, true);
4570 }
4571 }
4572 }
4573
4574 final public void BlockStatement() throws ParseException {
4575
4576 ASTBlockStatement jjtn000 = new ASTBlockStatement(this, JJTBLOCKSTATEMENT);
4577 boolean jjtc000 = true;
4578 jjtree.openNodeScope(jjtn000);
4579 try {
4580 if (isNextTokenAnAssert()) {
4581 AssertStatement();
4582 } else if (jj_2_63(2147483647)) {
4583 LocalVariableDeclaration();
4584 jj_consume_token(SEMICOLON);
4585 } else if (jj_2_64(1)) {
4586 Statement();
4587 } else if (jj_2_65(2147483647)) {
4588 switch (jj_nt.kind) {
4589 case AT:
4590 Annotation();
4591 break;
4592 default:
4593 jj_la1[115] = jj_gen;
4594 ;
4595 }
4596 ClassOrInterfaceDeclaration(0);
4597 } else {
4598 jj_consume_token(-1);
4599 throw new ParseException();
4600 }
4601 } catch (Throwable jjte000) {
4602 if (jjtc000) {
4603 jjtree.clearNodeScope(jjtn000);
4604 jjtc000 = false;
4605 } else {
4606 jjtree.popNode();
4607 }
4608 if (jjte000 instanceof RuntimeException) {
4609 {if (true) throw (RuntimeException)jjte000;}
4610 }
4611 if (jjte000 instanceof ParseException) {
4612 {if (true) throw (ParseException)jjte000;}
4613 }
4614 {if (true) throw (Error)jjte000;}
4615 } finally {
4616 if (jjtc000) {
4617 jjtree.closeNodeScope(jjtn000, true);
4618 }
4619 }
4620 }
4621
4622 final public void LocalVariableDeclaration() throws ParseException {
4623
4624 ASTLocalVariableDeclaration jjtn000 = new ASTLocalVariableDeclaration(this, JJTLOCALVARIABLEDECLARATION);
4625 boolean jjtc000 = true;
4626 jjtree.openNodeScope(jjtn000);
4627 try {
4628 label_60:
4629 while (true) {
4630 switch (jj_nt.kind) {
4631 case FINAL:
4632 case AT:
4633 ;
4634 break;
4635 default:
4636 jj_la1[116] = jj_gen;
4637 break label_60;
4638 }
4639 switch (jj_nt.kind) {
4640 case FINAL:
4641 jj_consume_token(FINAL);
4642 jjtn000.setFinal(true);
4643 break;
4644 case AT:
4645 Annotation();
4646 break;
4647 default:
4648 jj_la1[117] = jj_gen;
4649 jj_consume_token(-1);
4650 throw new ParseException();
4651 }
4652 }
4653 Type();
4654 VariableDeclarator();
4655 label_61:
4656 while (true) {
4657 switch (jj_nt.kind) {
4658 case COMMA:
4659 ;
4660 break;
4661 default:
4662 jj_la1[118] = jj_gen;
4663 break label_61;
4664 }
4665 jj_consume_token(COMMA);
4666 VariableDeclarator();
4667 }
4668 } catch (Throwable jjte000) {
4669 if (jjtc000) {
4670 jjtree.clearNodeScope(jjtn000);
4671 jjtc000 = false;
4672 } else {
4673 jjtree.popNode();
4674 }
4675 if (jjte000 instanceof RuntimeException) {
4676 {if (true) throw (RuntimeException)jjte000;}
4677 }
4678 if (jjte000 instanceof ParseException) {
4679 {if (true) throw (ParseException)jjte000;}
4680 }
4681 {if (true) throw (Error)jjte000;}
4682 } finally {
4683 if (jjtc000) {
4684 jjtree.closeNodeScope(jjtn000, true);
4685 }
4686 }
4687 }
4688
4689 final public void EmptyStatement() throws ParseException {
4690
4691 ASTEmptyStatement jjtn000 = new ASTEmptyStatement(this, JJTEMPTYSTATEMENT);
4692 boolean jjtc000 = true;
4693 jjtree.openNodeScope(jjtn000);
4694 try {
4695 jj_consume_token(SEMICOLON);
4696 } finally {
4697 if (jjtc000) {
4698 jjtree.closeNodeScope(jjtn000, true);
4699 }
4700 }
4701 }
4702
4703 final public void StatementExpression() throws ParseException {
4704
4705 ASTStatementExpression jjtn000 = new ASTStatementExpression(this, JJTSTATEMENTEXPRESSION);
4706 boolean jjtc000 = true;
4707 jjtree.openNodeScope(jjtn000);
4708 try {
4709 switch (jj_nt.kind) {
4710 case INCR:
4711 PreIncrementExpression();
4712 break;
4713 case DECR:
4714 PreDecrementExpression();
4715 break;
4716 default:
4717 jj_la1[120] = jj_gen;
4718 if (jj_2_66(2147483647)) {
4719 PostfixExpression();
4720 } else {
4721 switch (jj_nt.kind) {
4722 case BOOLEAN:
4723 case BYTE:
4724 case CHAR:
4725 case DOUBLE:
4726 case FALSE:
4727 case FLOAT:
4728 case INT:
4729 case LONG:
4730 case NEW:
4731 case NULL:
4732 case SHORT:
4733 case SUPER:
4734 case THIS:
4735 case TRUE:
4736 case VOID:
4737 case INTEGER_LITERAL:
4738 case FLOATING_POINT_LITERAL:
4739 case HEX_FLOATING_POINT_LITERAL:
4740 case CHARACTER_LITERAL:
4741 case STRING_LITERAL:
4742 case IDENTIFIER:
4743 case LPAREN:
4744 PrimaryExpression();
4745 switch (jj_nt.kind) {
4746 case ASSIGN:
4747 case PLUSASSIGN:
4748 case MINUSASSIGN:
4749 case STARASSIGN:
4750 case SLASHASSIGN:
4751 case ANDASSIGN:
4752 case ORASSIGN:
4753 case XORASSIGN:
4754 case REMASSIGN:
4755 case LSHIFTASSIGN:
4756 case RSIGNEDSHIFTASSIGN:
4757 case RUNSIGNEDSHIFTASSIGN:
4758 AssignmentOperator();
4759 Expression();
4760 break;
4761 default:
4762 jj_la1[119] = jj_gen;
4763 ;
4764 }
4765 break;
4766 default:
4767 jj_la1[121] = jj_gen;
4768 jj_consume_token(-1);
4769 throw new ParseException();
4770 }
4771 }
4772 }
4773 } catch (Throwable jjte000) {
4774 if (jjtc000) {
4775 jjtree.clearNodeScope(jjtn000);
4776 jjtc000 = false;
4777 } else {
4778 jjtree.popNode();
4779 }
4780 if (jjte000 instanceof RuntimeException) {
4781 {if (true) throw (RuntimeException)jjte000;}
4782 }
4783 if (jjte000 instanceof ParseException) {
4784 {if (true) throw (ParseException)jjte000;}
4785 }
4786 {if (true) throw (Error)jjte000;}
4787 } finally {
4788 if (jjtc000) {
4789 jjtree.closeNodeScope(jjtn000, true);
4790 }
4791 }
4792 }
4793
4794 final public void SwitchStatement() throws ParseException {
4795
4796 ASTSwitchStatement jjtn000 = new ASTSwitchStatement(this, JJTSWITCHSTATEMENT);
4797 boolean jjtc000 = true;
4798 jjtree.openNodeScope(jjtn000);
4799 try {
4800 jj_consume_token(SWITCH);
4801 jj_consume_token(LPAREN);
4802 Expression();
4803 jj_consume_token(RPAREN);
4804 jj_consume_token(LBRACE);
4805 label_62:
4806 while (true) {
4807 switch (jj_nt.kind) {
4808 case CASE:
4809 case _DEFAULT:
4810 ;
4811 break;
4812 default:
4813 jj_la1[122] = jj_gen;
4814 break label_62;
4815 }
4816 SwitchLabel();
4817 label_63:
4818 while (true) {
4819 if (jj_2_67(1)) {
4820 ;
4821 } else {
4822 break label_63;
4823 }
4824 BlockStatement();
4825 }
4826 }
4827 jj_consume_token(RBRACE);
4828 } catch (Throwable jjte000) {
4829 if (jjtc000) {
4830 jjtree.clearNodeScope(jjtn000);
4831 jjtc000 = false;
4832 } else {
4833 jjtree.popNode();
4834 }
4835 if (jjte000 instanceof RuntimeException) {
4836 {if (true) throw (RuntimeException)jjte000;}
4837 }
4838 if (jjte000 instanceof ParseException) {
4839 {if (true) throw (ParseException)jjte000;}
4840 }
4841 {if (true) throw (Error)jjte000;}
4842 } finally {
4843 if (jjtc000) {
4844 jjtree.closeNodeScope(jjtn000, true);
4845 }
4846 }
4847 }
4848
4849 final public void SwitchLabel() throws ParseException {
4850
4851 ASTSwitchLabel jjtn000 = new ASTSwitchLabel(this, JJTSWITCHLABEL);
4852 boolean jjtc000 = true;
4853 jjtree.openNodeScope(jjtn000);
4854 try {
4855 switch (jj_nt.kind) {
4856 case CASE:
4857 jj_consume_token(CASE);
4858 Expression();
4859 jj_consume_token(COLON);
4860 break;
4861 case _DEFAULT:
4862 jj_consume_token(_DEFAULT);
4863 jjtn000.setDefault();
4864 jj_consume_token(COLON);
4865 break;
4866 default:
4867 jj_la1[123] = jj_gen;
4868 jj_consume_token(-1);
4869 throw new ParseException();
4870 }
4871 } catch (Throwable jjte000) {
4872 if (jjtc000) {
4873 jjtree.clearNodeScope(jjtn000);
4874 jjtc000 = false;
4875 } else {
4876 jjtree.popNode();
4877 }
4878 if (jjte000 instanceof RuntimeException) {
4879 {if (true) throw (RuntimeException)jjte000;}
4880 }
4881 if (jjte000 instanceof ParseException) {
4882 {if (true) throw (ParseException)jjte000;}
4883 }
4884 {if (true) throw (Error)jjte000;}
4885 } finally {
4886 if (jjtc000) {
4887 jjtree.closeNodeScope(jjtn000, true);
4888 }
4889 }
4890 }
4891
4892 final public void IfStatement() throws ParseException {
4893
4894 ASTIfStatement jjtn000 = new ASTIfStatement(this, JJTIFSTATEMENT);
4895 boolean jjtc000 = true;
4896 jjtree.openNodeScope(jjtn000);
4897 try {
4898 jj_consume_token(IF);
4899 jj_consume_token(LPAREN);
4900 Expression();
4901 jj_consume_token(RPAREN);
4902 Statement();
4903 switch (jj_nt.kind) {
4904 case ELSE:
4905 jj_consume_token(ELSE);
4906 jjtn000.setHasElse();
4907 Statement();
4908 break;
4909 default:
4910 jj_la1[124] = jj_gen;
4911 ;
4912 }
4913 jjtree.closeNodeScope(jjtn000, true);
4914 jjtc000 = false;
4915
4916 } catch (Throwable jjte000) {
4917 if (jjtc000) {
4918 jjtree.clearNodeScope(jjtn000);
4919 jjtc000 = false;
4920 } else {
4921 jjtree.popNode();
4922 }
4923 if (jjte000 instanceof RuntimeException) {
4924 {if (true) throw (RuntimeException)jjte000;}
4925 }
4926 if (jjte000 instanceof ParseException) {
4927 {if (true) throw (ParseException)jjte000;}
4928 }
4929 {if (true) throw (Error)jjte000;}
4930 } finally {
4931 if (jjtc000) {
4932 jjtree.closeNodeScope(jjtn000, true);
4933 }
4934 }
4935 }
4936
4937 final public void WhileStatement() throws ParseException {
4938
4939 ASTWhileStatement jjtn000 = new ASTWhileStatement(this, JJTWHILESTATEMENT);
4940 boolean jjtc000 = true;
4941 jjtree.openNodeScope(jjtn000);
4942 try {
4943 jj_consume_token(WHILE);
4944 jj_consume_token(LPAREN);
4945 Expression();
4946 jj_consume_token(RPAREN);
4947 Statement();
4948 } catch (Throwable jjte000) {
4949 if (jjtc000) {
4950 jjtree.clearNodeScope(jjtn000);
4951 jjtc000 = false;
4952 } else {
4953 jjtree.popNode();
4954 }
4955 if (jjte000 instanceof RuntimeException) {
4956 {if (true) throw (RuntimeException)jjte000;}
4957 }
4958 if (jjte000 instanceof ParseException) {
4959 {if (true) throw (ParseException)jjte000;}
4960 }
4961 {if (true) throw (Error)jjte000;}
4962 } finally {
4963 if (jjtc000) {
4964 jjtree.closeNodeScope(jjtn000, true);
4965 }
4966 }
4967 }
4968
4969 final public void DoStatement() throws ParseException {
4970
4971 ASTDoStatement jjtn000 = new ASTDoStatement(this, JJTDOSTATEMENT);
4972 boolean jjtc000 = true;
4973 jjtree.openNodeScope(jjtn000);
4974 try {
4975 jj_consume_token(DO);
4976 Statement();
4977 jj_consume_token(WHILE);
4978 jj_consume_token(LPAREN);
4979 Expression();
4980 jj_consume_token(RPAREN);
4981 jj_consume_token(SEMICOLON);
4982 } catch (Throwable jjte000) {
4983 if (jjtc000) {
4984 jjtree.clearNodeScope(jjtn000);
4985 jjtc000 = false;
4986 } else {
4987 jjtree.popNode();
4988 }
4989 if (jjte000 instanceof RuntimeException) {
4990 {if (true) throw (RuntimeException)jjte000;}
4991 }
4992 if (jjte000 instanceof ParseException) {
4993 {if (true) throw (ParseException)jjte000;}
4994 }
4995 {if (true) throw (Error)jjte000;}
4996 } finally {
4997 if (jjtc000) {
4998 jjtree.closeNodeScope(jjtn000, true);
4999 }
5000 }
5001 }
5002
5003 final public void ForStatement() throws ParseException {
5004
5005 ASTForStatement jjtn000 = new ASTForStatement(this, JJTFORSTATEMENT);
5006 boolean jjtc000 = true;
5007 jjtree.openNodeScope(jjtn000);
5008 try {
5009 jj_consume_token(FOR);
5010 jj_consume_token(LPAREN);
5011 if (jj_2_68(2147483647)) {
5012 checkForBadJDK15ForLoopSyntaxArgumentsUsage();
5013 LocalVariableDeclaration();
5014 jj_consume_token(COLON);
5015 Expression();
5016 } else {
5017 switch (jj_nt.kind) {
5018 case BOOLEAN:
5019 case BYTE:
5020 case CHAR:
5021 case DOUBLE:
5022 case FALSE:
5023 case FINAL:
5024 case FLOAT:
5025 case INT:
5026 case LONG:
5027 case NEW:
5028 case NULL:
5029 case SHORT:
5030 case SUPER:
5031 case THIS:
5032 case TRUE:
5033 case VOID:
5034 case INTEGER_LITERAL:
5035 case FLOATING_POINT_LITERAL:
5036 case HEX_FLOATING_POINT_LITERAL:
5037 case CHARACTER_LITERAL:
5038 case STRING_LITERAL:
5039 case IDENTIFIER:
5040 case LPAREN:
5041 case SEMICOLON:
5042 case AT:
5043 case INCR:
5044 case DECR:
5045 switch (jj_nt.kind) {
5046 case BOOLEAN:
5047 case BYTE:
5048 case CHAR:
5049 case DOUBLE:
5050 case FALSE:
5051 case FINAL:
5052 case FLOAT:
5053 case INT:
5054 case LONG:
5055 case NEW:
5056 case NULL:
5057 case SHORT:
5058 case SUPER:
5059 case THIS:
5060 case TRUE:
5061 case VOID:
5062 case INTEGER_LITERAL:
5063 case FLOATING_POINT_LITERAL:
5064 case HEX_FLOATING_POINT_LITERAL:
5065 case CHARACTER_LITERAL:
5066 case STRING_LITERAL:
5067 case IDENTIFIER:
5068 case LPAREN:
5069 case AT:
5070 case INCR:
5071 case DECR:
5072 ForInit();
5073 break;
5074 default:
5075 jj_la1[125] = jj_gen;
5076 ;
5077 }
5078 jj_consume_token(SEMICOLON);
5079 switch (jj_nt.kind) {
5080 case BOOLEAN:
5081 case BYTE:
5082 case CHAR:
5083 case DOUBLE:
5084 case FALSE:
5085 case FLOAT:
5086 case INT:
5087 case LONG:
5088 case NEW:
5089 case NULL:
5090 case SHORT:
5091 case SUPER:
5092 case THIS:
5093 case TRUE:
5094 case VOID:
5095 case INTEGER_LITERAL:
5096 case FLOATING_POINT_LITERAL:
5097 case HEX_FLOATING_POINT_LITERAL:
5098 case CHARACTER_LITERAL:
5099 case STRING_LITERAL:
5100 case IDENTIFIER:
5101 case LPAREN:
5102 case BANG:
5103 case TILDE:
5104 case INCR:
5105 case DECR:
5106 case PLUS:
5107 case MINUS:
5108 Expression();
5109 break;
5110 default:
5111 jj_la1[126] = jj_gen;
5112 ;
5113 }
5114 jj_consume_token(SEMICOLON);
5115 switch (jj_nt.kind) {
5116 case BOOLEAN:
5117 case BYTE:
5118 case CHAR:
5119 case DOUBLE:
5120 case FALSE:
5121 case FLOAT:
5122 case INT:
5123 case LONG:
5124 case NEW:
5125 case NULL:
5126 case SHORT:
5127 case SUPER:
5128 case THIS:
5129 case TRUE:
5130 case VOID:
5131 case INTEGER_LITERAL:
5132 case FLOATING_POINT_LITERAL:
5133 case HEX_FLOATING_POINT_LITERAL:
5134 case CHARACTER_LITERAL:
5135 case STRING_LITERAL:
5136 case IDENTIFIER:
5137 case LPAREN:
5138 case INCR:
5139 case DECR:
5140 ForUpdate();
5141 break;
5142 default:
5143 jj_la1[127] = jj_gen;
5144 ;
5145 }
5146 break;
5147 default:
5148 jj_la1[128] = jj_gen;
5149 jj_consume_token(-1);
5150 throw new ParseException();
5151 }
5152 }
5153 jj_consume_token(RPAREN);
5154 Statement();
5155 } catch (Throwable jjte000) {
5156 if (jjtc000) {
5157 jjtree.clearNodeScope(jjtn000);
5158 jjtc000 = false;
5159 } else {
5160 jjtree.popNode();
5161 }
5162 if (jjte000 instanceof RuntimeException) {
5163 {if (true) throw (RuntimeException)jjte000;}
5164 }
5165 if (jjte000 instanceof ParseException) {
5166 {if (true) throw (ParseException)jjte000;}
5167 }
5168 {if (true) throw (Error)jjte000;}
5169 } finally {
5170 if (jjtc000) {
5171 jjtree.closeNodeScope(jjtn000, true);
5172 }
5173 }
5174 }
5175
5176 final public void ForInit() throws ParseException {
5177
5178 ASTForInit jjtn000 = new ASTForInit(this, JJTFORINIT);
5179 boolean jjtc000 = true;
5180 jjtree.openNodeScope(jjtn000);
5181 try {
5182 if (jj_2_69(2147483647)) {
5183 LocalVariableDeclaration();
5184 } else {
5185 switch (jj_nt.kind) {
5186 case BOOLEAN:
5187 case BYTE:
5188 case CHAR:
5189 case DOUBLE:
5190 case FALSE:
5191 case FLOAT:
5192 case INT:
5193 case LONG:
5194 case NEW:
5195 case NULL:
5196 case SHORT:
5197 case SUPER:
5198 case THIS:
5199 case TRUE:
5200 case VOID:
5201 case INTEGER_LITERAL:
5202 case FLOATING_POINT_LITERAL:
5203 case HEX_FLOATING_POINT_LITERAL:
5204 case CHARACTER_LITERAL:
5205 case STRING_LITERAL:
5206 case IDENTIFIER:
5207 case LPAREN:
5208 case INCR:
5209 case DECR:
5210 StatementExpressionList();
5211 break;
5212 default:
5213 jj_la1[129] = jj_gen;
5214 jj_consume_token(-1);
5215 throw new ParseException();
5216 }
5217 }
5218 } catch (Throwable jjte000) {
5219 if (jjtc000) {
5220 jjtree.clearNodeScope(jjtn000);
5221 jjtc000 = false;
5222 } else {
5223 jjtree.popNode();
5224 }
5225 if (jjte000 instanceof RuntimeException) {
5226 {if (true) throw (RuntimeException)jjte000;}
5227 }
5228 if (jjte000 instanceof ParseException) {
5229 {if (true) throw (ParseException)jjte000;}
5230 }
5231 {if (true) throw (Error)jjte000;}
5232 } finally {
5233 if (jjtc000) {
5234 jjtree.closeNodeScope(jjtn000, true);
5235 }
5236 }
5237 }
5238
5239 final public void StatementExpressionList() throws ParseException {
5240
5241 ASTStatementExpressionList jjtn000 = new ASTStatementExpressionList(this, JJTSTATEMENTEXPRESSIONLIST);
5242 boolean jjtc000 = true;
5243 jjtree.openNodeScope(jjtn000);
5244 try {
5245 StatementExpression();
5246 label_64:
5247 while (true) {
5248 switch (jj_nt.kind) {
5249 case COMMA:
5250 ;
5251 break;
5252 default:
5253 jj_la1[130] = jj_gen;
5254 break label_64;
5255 }
5256 jj_consume_token(COMMA);
5257 StatementExpression();
5258 }
5259 } catch (Throwable jjte000) {
5260 if (jjtc000) {
5261 jjtree.clearNodeScope(jjtn000);
5262 jjtc000 = false;
5263 } else {
5264 jjtree.popNode();
5265 }
5266 if (jjte000 instanceof RuntimeException) {
5267 {if (true) throw (RuntimeException)jjte000;}
5268 }
5269 if (jjte000 instanceof ParseException) {
5270 {if (true) throw (ParseException)jjte000;}
5271 }
5272 {if (true) throw (Error)jjte000;}
5273 } finally {
5274 if (jjtc000) {
5275 jjtree.closeNodeScope(jjtn000, true);
5276 }
5277 }
5278 }
5279
5280 final public void ForUpdate() throws ParseException {
5281
5282 ASTForUpdate jjtn000 = new ASTForUpdate(this, JJTFORUPDATE);
5283 boolean jjtc000 = true;
5284 jjtree.openNodeScope(jjtn000);
5285 try {
5286 StatementExpressionList();
5287 } catch (Throwable jjte000) {
5288 if (jjtc000) {
5289 jjtree.clearNodeScope(jjtn000);
5290 jjtc000 = false;
5291 } else {
5292 jjtree.popNode();
5293 }
5294 if (jjte000 instanceof RuntimeException) {
5295 {if (true) throw (RuntimeException)jjte000;}
5296 }
5297 if (jjte000 instanceof ParseException) {
5298 {if (true) throw (ParseException)jjte000;}
5299 }
5300 {if (true) throw (Error)jjte000;}
5301 } finally {
5302 if (jjtc000) {
5303 jjtree.closeNodeScope(jjtn000, true);
5304 }
5305 }
5306 }
5307
5308 final public void BreakStatement() throws ParseException {
5309
5310 ASTBreakStatement jjtn000 = new ASTBreakStatement(this, JJTBREAKSTATEMENT);
5311 boolean jjtc000 = true;
5312 jjtree.openNodeScope(jjtn000);Token t;
5313 try {
5314 jj_consume_token(BREAK);
5315 switch (jj_nt.kind) {
5316 case IDENTIFIER:
5317 t = jj_consume_token(IDENTIFIER);
5318 jjtn000.setImage(t.image);
5319 break;
5320 default:
5321 jj_la1[131] = jj_gen;
5322 ;
5323 }
5324 jj_consume_token(SEMICOLON);
5325 } finally {
5326 if (jjtc000) {
5327 jjtree.closeNodeScope(jjtn000, true);
5328 }
5329 }
5330 }
5331
5332 final public void ContinueStatement() throws ParseException {
5333
5334 ASTContinueStatement jjtn000 = new ASTContinueStatement(this, JJTCONTINUESTATEMENT);
5335 boolean jjtc000 = true;
5336 jjtree.openNodeScope(jjtn000);Token t;
5337 try {
5338 jj_consume_token(CONTINUE);
5339 switch (jj_nt.kind) {
5340 case IDENTIFIER:
5341 t = jj_consume_token(IDENTIFIER);
5342 jjtn000.setImage(t.image);
5343 break;
5344 default:
5345 jj_la1[132] = jj_gen;
5346 ;
5347 }
5348 jj_consume_token(SEMICOLON);
5349 } finally {
5350 if (jjtc000) {
5351 jjtree.closeNodeScope(jjtn000, true);
5352 }
5353 }
5354 }
5355
5356 final public void ReturnStatement() throws ParseException {
5357
5358 ASTReturnStatement jjtn000 = new ASTReturnStatement(this, JJTRETURNSTATEMENT);
5359 boolean jjtc000 = true;
5360 jjtree.openNodeScope(jjtn000);
5361 try {
5362 jj_consume_token(RETURN);
5363 switch (jj_nt.kind) {
5364 case BOOLEAN:
5365 case BYTE:
5366 case CHAR:
5367 case DOUBLE:
5368 case FALSE:
5369 case FLOAT:
5370 case INT:
5371 case LONG:
5372 case NEW:
5373 case NULL:
5374 case SHORT:
5375 case SUPER:
5376 case THIS:
5377 case TRUE:
5378 case VOID:
5379 case INTEGER_LITERAL:
5380 case FLOATING_POINT_LITERAL:
5381 case HEX_FLOATING_POINT_LITERAL:
5382 case CHARACTER_LITERAL:
5383 case STRING_LITERAL:
5384 case IDENTIFIER:
5385 case LPAREN:
5386 case BANG:
5387 case TILDE:
5388 case INCR:
5389 case DECR:
5390 case PLUS:
5391 case MINUS:
5392 Expression();
5393 break;
5394 default:
5395 jj_la1[133] = jj_gen;
5396 ;
5397 }
5398 jj_consume_token(SEMICOLON);
5399 } catch (Throwable jjte000) {
5400 if (jjtc000) {
5401 jjtree.clearNodeScope(jjtn000);
5402 jjtc000 = false;
5403 } else {
5404 jjtree.popNode();
5405 }
5406 if (jjte000 instanceof RuntimeException) {
5407 {if (true) throw (RuntimeException)jjte000;}
5408 }
5409 if (jjte000 instanceof ParseException) {
5410 {if (true) throw (ParseException)jjte000;}
5411 }
5412 {if (true) throw (Error)jjte000;}
5413 } finally {
5414 if (jjtc000) {
5415 jjtree.closeNodeScope(jjtn000, true);
5416 }
5417 }
5418 }
5419
5420 final public void ThrowStatement() throws ParseException {
5421
5422 ASTThrowStatement jjtn000 = new ASTThrowStatement(this, JJTTHROWSTATEMENT);
5423 boolean jjtc000 = true;
5424 jjtree.openNodeScope(jjtn000);
5425 try {
5426 jj_consume_token(THROW);
5427 Expression();
5428 jj_consume_token(SEMICOLON);
5429 } catch (Throwable jjte000) {
5430 if (jjtc000) {
5431 jjtree.clearNodeScope(jjtn000);
5432 jjtc000 = false;
5433 } else {
5434 jjtree.popNode();
5435 }
5436 if (jjte000 instanceof RuntimeException) {
5437 {if (true) throw (RuntimeException)jjte000;}
5438 }
5439 if (jjte000 instanceof ParseException) {
5440 {if (true) throw (ParseException)jjte000;}
5441 }
5442 {if (true) throw (Error)jjte000;}
5443 } finally {
5444 if (jjtc000) {
5445 jjtree.closeNodeScope(jjtn000, true);
5446 }
5447 }
5448 }
5449
5450 final public void SynchronizedStatement() throws ParseException {
5451
5452 ASTSynchronizedStatement jjtn000 = new ASTSynchronizedStatement(this, JJTSYNCHRONIZEDSTATEMENT);
5453 boolean jjtc000 = true;
5454 jjtree.openNodeScope(jjtn000);
5455 try {
5456 jj_consume_token(SYNCHRONIZED);
5457 jj_consume_token(LPAREN);
5458 Expression();
5459 jj_consume_token(RPAREN);
5460 Block();
5461 } catch (Throwable jjte000) {
5462 if (jjtc000) {
5463 jjtree.clearNodeScope(jjtn000);
5464 jjtc000 = false;
5465 } else {
5466 jjtree.popNode();
5467 }
5468 if (jjte000 instanceof RuntimeException) {
5469 {if (true) throw (RuntimeException)jjte000;}
5470 }
5471 if (jjte000 instanceof ParseException) {
5472 {if (true) throw (ParseException)jjte000;}
5473 }
5474 {if (true) throw (Error)jjte000;}
5475 } finally {
5476 if (jjtc000) {
5477 jjtree.closeNodeScope(jjtn000, true);
5478 }
5479 }
5480 }
5481
5482 final public void TryStatement() throws ParseException {
5483
5484 ASTTryStatement jjtn000 = new ASTTryStatement(this, JJTTRYSTATEMENT);
5485 boolean jjtc000 = true;
5486 jjtree.openNodeScope(jjtn000);
5487 try {
5488 jj_consume_token(TRY);
5489 switch (jj_nt.kind) {
5490 case LPAREN:
5491 ResourceSpecification();
5492 break;
5493 default:
5494 jj_la1[134] = jj_gen;
5495 ;
5496 }
5497 Block();
5498 label_65:
5499 while (true) {
5500 switch (jj_nt.kind) {
5501 case CATCH:
5502 ;
5503 break;
5504 default:
5505 jj_la1[135] = jj_gen;
5506 break label_65;
5507 }
5508 CatchStatement();
5509 }
5510 switch (jj_nt.kind) {
5511 case FINALLY:
5512 FinallyStatement();
5513 break;
5514 default:
5515 jj_la1[136] = jj_gen;
5516 ;
5517 }
5518 } catch (Throwable jjte000) {
5519 if (jjtc000) {
5520 jjtree.clearNodeScope(jjtn000);
5521 jjtc000 = false;
5522 } else {
5523 jjtree.popNode();
5524 }
5525 if (jjte000 instanceof RuntimeException) {
5526 {if (true) throw (RuntimeException)jjte000;}
5527 }
5528 if (jjte000 instanceof ParseException) {
5529 {if (true) throw (ParseException)jjte000;}
5530 }
5531 {if (true) throw (Error)jjte000;}
5532 } finally {
5533 if (jjtc000) {
5534 jjtree.closeNodeScope(jjtn000, true);
5535 }
5536 }
5537 }
5538
5539 final public void ResourceSpecification() throws ParseException {
5540
5541 ASTResourceSpecification jjtn000 = new ASTResourceSpecification(this, JJTRESOURCESPECIFICATION);
5542 boolean jjtc000 = true;
5543 jjtree.openNodeScope(jjtn000);
5544 try {
5545 checkForBadTryWithResourcesUsage();
5546 jj_consume_token(LPAREN);
5547 Resources();
5548 if (jj_2_70(2)) {
5549 jj_consume_token(SEMICOLON);
5550 } else {
5551 ;
5552 }
5553 jj_consume_token(RPAREN);
5554 } catch (Throwable jjte000) {
5555 if (jjtc000) {
5556 jjtree.clearNodeScope(jjtn000);
5557 jjtc000 = false;
5558 } else {
5559 jjtree.popNode();
5560 }
5561 if (jjte000 instanceof RuntimeException) {
5562 {if (true) throw (RuntimeException)jjte000;}
5563 }
5564 if (jjte000 instanceof ParseException) {
5565 {if (true) throw (ParseException)jjte000;}
5566 }
5567 {if (true) throw (Error)jjte000;}
5568 } finally {
5569 if (jjtc000) {
5570 jjtree.closeNodeScope(jjtn000, true);
5571 }
5572 }
5573 }
5574
5575 final public void Resources() throws ParseException {
5576
5577 ASTResources jjtn000 = new ASTResources(this, JJTRESOURCES);
5578 boolean jjtc000 = true;
5579 jjtree.openNodeScope(jjtn000);
5580 try {
5581 Resource();
5582 label_66:
5583 while (true) {
5584 if (jj_2_71(2)) {
5585 ;
5586 } else {
5587 break label_66;
5588 }
5589 jj_consume_token(SEMICOLON);
5590 Resource();
5591 }
5592 } catch (Throwable jjte000) {
5593 if (jjtc000) {
5594 jjtree.clearNodeScope(jjtn000);
5595 jjtc000 = false;
5596 } else {
5597 jjtree.popNode();
5598 }
5599 if (jjte000 instanceof RuntimeException) {
5600 {if (true) throw (RuntimeException)jjte000;}
5601 }
5602 if (jjte000 instanceof ParseException) {
5603 {if (true) throw (ParseException)jjte000;}
5604 }
5605 {if (true) throw (Error)jjte000;}
5606 } finally {
5607 if (jjtc000) {
5608 jjtree.closeNodeScope(jjtn000, true);
5609 }
5610 }
5611 }
5612
5613 final public void Resource() throws ParseException {
5614
5615 ASTResource jjtn000 = new ASTResource(this, JJTRESOURCE);
5616 boolean jjtc000 = true;
5617 jjtree.openNodeScope(jjtn000);
5618 try {
5619 label_67:
5620 while (true) {
5621 switch (jj_nt.kind) {
5622 case FINAL:
5623 case AT:
5624 ;
5625 break;
5626 default:
5627 jj_la1[137] = jj_gen;
5628 break label_67;
5629 }
5630 switch (jj_nt.kind) {
5631 case FINAL:
5632 jj_consume_token(FINAL);
5633 break;
5634 case AT:
5635 Annotation();
5636 break;
5637 default:
5638 jj_la1[138] = jj_gen;
5639 jj_consume_token(-1);
5640 throw new ParseException();
5641 }
5642 }
5643 Type();
5644 VariableDeclaratorId();
5645 jj_consume_token(ASSIGN);
5646 Expression();
5647 } catch (Throwable jjte000) {
5648 if (jjtc000) {
5649 jjtree.clearNodeScope(jjtn000);
5650 jjtc000 = false;
5651 } else {
5652 jjtree.popNode();
5653 }
5654 if (jjte000 instanceof RuntimeException) {
5655 {if (true) throw (RuntimeException)jjte000;}
5656 }
5657 if (jjte000 instanceof ParseException) {
5658 {if (true) throw (ParseException)jjte000;}
5659 }
5660 {if (true) throw (Error)jjte000;}
5661 } finally {
5662 if (jjtc000) {
5663 jjtree.closeNodeScope(jjtn000, true);
5664 }
5665 }
5666 }
5667
5668 final public void CatchStatement() throws ParseException {
5669
5670 ASTCatchStatement jjtn000 = new ASTCatchStatement(this, JJTCATCHSTATEMENT);
5671 boolean jjtc000 = true;
5672 jjtree.openNodeScope(jjtn000);
5673 try {
5674 jj_consume_token(CATCH);
5675 jj_consume_token(LPAREN);
5676 FormalParameter();
5677 jj_consume_token(RPAREN);
5678 Block();
5679 } catch (Throwable jjte000) {
5680 if (jjtc000) {
5681 jjtree.clearNodeScope(jjtn000);
5682 jjtc000 = false;
5683 } else {
5684 jjtree.popNode();
5685 }
5686 if (jjte000 instanceof RuntimeException) {
5687 {if (true) throw (RuntimeException)jjte000;}
5688 }
5689 if (jjte000 instanceof ParseException) {
5690 {if (true) throw (ParseException)jjte000;}
5691 }
5692 {if (true) throw (Error)jjte000;}
5693 } finally {
5694 if (jjtc000) {
5695 jjtree.closeNodeScope(jjtn000, true);
5696 }
5697 }
5698 }
5699
5700 final public void FinallyStatement() throws ParseException {
5701
5702 ASTFinallyStatement jjtn000 = new ASTFinallyStatement(this, JJTFINALLYSTATEMENT);
5703 boolean jjtc000 = true;
5704 jjtree.openNodeScope(jjtn000);
5705 try {
5706 jj_consume_token(FINALLY);
5707 Block();
5708 } catch (Throwable jjte000) {
5709 if (jjtc000) {
5710 jjtree.clearNodeScope(jjtn000);
5711 jjtc000 = false;
5712 } else {
5713 jjtree.popNode();
5714 }
5715 if (jjte000 instanceof RuntimeException) {
5716 {if (true) throw (RuntimeException)jjte000;}
5717 }
5718 if (jjte000 instanceof ParseException) {
5719 {if (true) throw (ParseException)jjte000;}
5720 }
5721 {if (true) throw (Error)jjte000;}
5722 } finally {
5723 if (jjtc000) {
5724 jjtree.closeNodeScope(jjtn000, true);
5725 }
5726 }
5727 }
5728
5729 final public void AssertStatement() throws ParseException {
5730
5731 ASTAssertStatement jjtn000 = new ASTAssertStatement(this, JJTASSERTSTATEMENT);
5732 boolean jjtc000 = true;
5733 jjtree.openNodeScope(jjtn000);if (jdkVersion <= 3) {
5734 throw new ParseException("Can't use 'assert' as a keyword when running in JDK 1.3 mode!");
5735 }
5736 try {
5737 jj_consume_token(IDENTIFIER);
5738 Expression();
5739 switch (jj_nt.kind) {
5740 case COLON:
5741 jj_consume_token(COLON);
5742 Expression();
5743 break;
5744 default:
5745 jj_la1[139] = jj_gen;
5746 ;
5747 }
5748 jj_consume_token(SEMICOLON);
5749 } catch (Throwable jjte000) {
5750 if (jjtc000) {
5751 jjtree.clearNodeScope(jjtn000);
5752 jjtc000 = false;
5753 } else {
5754 jjtree.popNode();
5755 }
5756 if (jjte000 instanceof RuntimeException) {
5757 {if (true) throw (RuntimeException)jjte000;}
5758 }
5759 if (jjte000 instanceof ParseException) {
5760 {if (true) throw (ParseException)jjte000;}
5761 }
5762 {if (true) throw (Error)jjte000;}
5763 } finally {
5764 if (jjtc000) {
5765 jjtree.closeNodeScope(jjtn000, true);
5766 }
5767 }
5768 }
5769
5770
5771
5772
5773 final public void RUNSIGNEDSHIFT() throws ParseException {
5774
5775 ASTRUNSIGNEDSHIFT jjtn000 = new ASTRUNSIGNEDSHIFT(this, JJTRUNSIGNEDSHIFT);
5776 boolean jjtc000 = true;
5777 jjtree.openNodeScope(jjtn000);
5778 try {
5779 if (getToken(1).kind == GT &&
5780 ((Token.GTToken)getToken(1)).realKind == RUNSIGNEDSHIFT) {
5781
5782 } else {
5783 jj_consume_token(-1);
5784 throw new ParseException();
5785 }
5786 jj_consume_token(GT);
5787 jj_consume_token(GT);
5788 jj_consume_token(GT);
5789 } finally {
5790 if (jjtc000) {
5791 jjtree.closeNodeScope(jjtn000, true);
5792 }
5793 }
5794 }
5795
5796 final public void RSIGNEDSHIFT() throws ParseException {
5797
5798 ASTRSIGNEDSHIFT jjtn000 = new ASTRSIGNEDSHIFT(this, JJTRSIGNEDSHIFT);
5799 boolean jjtc000 = true;
5800 jjtree.openNodeScope(jjtn000);
5801 try {
5802 if (getToken(1).kind == GT &&
5803 ((Token.GTToken)getToken(1)).realKind == RSIGNEDSHIFT) {
5804
5805 } else {
5806 jj_consume_token(-1);
5807 throw new ParseException();
5808 }
5809 jj_consume_token(GT);
5810 jj_consume_token(GT);
5811 } finally {
5812 if (jjtc000) {
5813 jjtree.closeNodeScope(jjtn000, true);
5814 }
5815 }
5816 }
5817
5818
5819 final public void Annotation() throws ParseException {
5820
5821 ASTAnnotation jjtn000 = new ASTAnnotation(this, JJTANNOTATION);
5822 boolean jjtc000 = true;
5823 jjtree.openNodeScope(jjtn000);
5824 try {
5825 if (jj_2_72(2147483647)) {
5826 NormalAnnotation();
5827 } else if (jj_2_73(2147483647)) {
5828 SingleMemberAnnotation();
5829 } else {
5830 switch (jj_nt.kind) {
5831 case AT:
5832 MarkerAnnotation();
5833 break;
5834 default:
5835 jj_la1[140] = jj_gen;
5836 jj_consume_token(-1);
5837 throw new ParseException();
5838 }
5839 }
5840 } catch (Throwable jjte000) {
5841 if (jjtc000) {
5842 jjtree.clearNodeScope(jjtn000);
5843 jjtc000 = false;
5844 } else {
5845 jjtree.popNode();
5846 }
5847 if (jjte000 instanceof RuntimeException) {
5848 {if (true) throw (RuntimeException)jjte000;}
5849 }
5850 if (jjte000 instanceof ParseException) {
5851 {if (true) throw (ParseException)jjte000;}
5852 }
5853 {if (true) throw (Error)jjte000;}
5854 } finally {
5855 if (jjtc000) {
5856 jjtree.closeNodeScope(jjtn000, true);
5857 }
5858 }
5859 }
5860
5861 final public void NormalAnnotation() throws ParseException {
5862
5863 ASTNormalAnnotation jjtn000 = new ASTNormalAnnotation(this, JJTNORMALANNOTATION);
5864 boolean jjtc000 = true;
5865 jjtree.openNodeScope(jjtn000);
5866 try {
5867 jj_consume_token(AT);
5868 Name();
5869 jj_consume_token(LPAREN);
5870 switch (jj_nt.kind) {
5871 case IDENTIFIER:
5872 MemberValuePairs();
5873 break;
5874 default:
5875 jj_la1[141] = jj_gen;
5876 ;
5877 }
5878 jj_consume_token(RPAREN);
5879 jjtree.closeNodeScope(jjtn000, true);
5880 jjtc000 = false;
5881 checkForBadAnnotationUsage();
5882 } catch (Throwable jjte000) {
5883 if (jjtc000) {
5884 jjtree.clearNodeScope(jjtn000);
5885 jjtc000 = false;
5886 } else {
5887 jjtree.popNode();
5888 }
5889 if (jjte000 instanceof RuntimeException) {
5890 {if (true) throw (RuntimeException)jjte000;}
5891 }
5892 if (jjte000 instanceof ParseException) {
5893 {if (true) throw (ParseException)jjte000;}
5894 }
5895 {if (true) throw (Error)jjte000;}
5896 } finally {
5897 if (jjtc000) {
5898 jjtree.closeNodeScope(jjtn000, true);
5899 }
5900 }
5901 }
5902
5903 final public void MarkerAnnotation() throws ParseException {
5904
5905 ASTMarkerAnnotation jjtn000 = new ASTMarkerAnnotation(this, JJTMARKERANNOTATION);
5906 boolean jjtc000 = true;
5907 jjtree.openNodeScope(jjtn000);
5908 try {
5909 jj_consume_token(AT);
5910 Name();
5911 jjtree.closeNodeScope(jjtn000, true);
5912 jjtc000 = false;
5913 checkForBadAnnotationUsage();
5914 } catch (Throwable jjte000) {
5915 if (jjtc000) {
5916 jjtree.clearNodeScope(jjtn000);
5917 jjtc000 = false;
5918 } else {
5919 jjtree.popNode();
5920 }
5921 if (jjte000 instanceof RuntimeException) {
5922 {if (true) throw (RuntimeException)jjte000;}
5923 }
5924 if (jjte000 instanceof ParseException) {
5925 {if (true) throw (ParseException)jjte000;}
5926 }
5927 {if (true) throw (Error)jjte000;}
5928 } finally {
5929 if (jjtc000) {
5930 jjtree.closeNodeScope(jjtn000, true);
5931 }
5932 }
5933 }
5934
5935 final public void SingleMemberAnnotation() throws ParseException {
5936
5937 ASTSingleMemberAnnotation jjtn000 = new ASTSingleMemberAnnotation(this, JJTSINGLEMEMBERANNOTATION);
5938 boolean jjtc000 = true;
5939 jjtree.openNodeScope(jjtn000);
5940 try {
5941 jj_consume_token(AT);
5942 Name();
5943 jj_consume_token(LPAREN);
5944 MemberValue();
5945 jj_consume_token(RPAREN);
5946 jjtree.closeNodeScope(jjtn000, true);
5947 jjtc000 = false;
5948 checkForBadAnnotationUsage();
5949 } catch (Throwable jjte000) {
5950 if (jjtc000) {
5951 jjtree.clearNodeScope(jjtn000);
5952 jjtc000 = false;
5953 } else {
5954 jjtree.popNode();
5955 }
5956 if (jjte000 instanceof RuntimeException) {
5957 {if (true) throw (RuntimeException)jjte000;}
5958 }
5959 if (jjte000 instanceof ParseException) {
5960 {if (true) throw (ParseException)jjte000;}
5961 }
5962 {if (true) throw (Error)jjte000;}
5963 } finally {
5964 if (jjtc000) {
5965 jjtree.closeNodeScope(jjtn000, true);
5966 }
5967 }
5968 }
5969
5970 final public void MemberValuePairs() throws ParseException {
5971
5972 ASTMemberValuePairs jjtn000 = new ASTMemberValuePairs(this, JJTMEMBERVALUEPAIRS);
5973 boolean jjtc000 = true;
5974 jjtree.openNodeScope(jjtn000);
5975 try {
5976 MemberValuePair();
5977 label_68:
5978 while (true) {
5979 switch (jj_nt.kind) {
5980 case COMMA:
5981 ;
5982 break;
5983 default:
5984 jj_la1[142] = jj_gen;
5985 break label_68;
5986 }
5987 jj_consume_token(COMMA);
5988 MemberValuePair();
5989 }
5990 } catch (Throwable jjte000) {
5991 if (jjtc000) {
5992 jjtree.clearNodeScope(jjtn000);
5993 jjtc000 = false;
5994 } else {
5995 jjtree.popNode();
5996 }
5997 if (jjte000 instanceof RuntimeException) {
5998 {if (true) throw (RuntimeException)jjte000;}
5999 }
6000 if (jjte000 instanceof ParseException) {
6001 {if (true) throw (ParseException)jjte000;}
6002 }
6003 {if (true) throw (Error)jjte000;}
6004 } finally {
6005 if (jjtc000) {
6006 jjtree.closeNodeScope(jjtn000, true);
6007 }
6008 }
6009 }
6010
6011 final public void MemberValuePair() throws ParseException {
6012
6013 ASTMemberValuePair jjtn000 = new ASTMemberValuePair(this, JJTMEMBERVALUEPAIR);
6014 boolean jjtc000 = true;
6015 jjtree.openNodeScope(jjtn000);Token t;
6016 try {
6017 t = jj_consume_token(IDENTIFIER);
6018 jjtn000.setImage(t.image);
6019 jj_consume_token(ASSIGN);
6020 MemberValue();
6021 } catch (Throwable jjte000) {
6022 if (jjtc000) {
6023 jjtree.clearNodeScope(jjtn000);
6024 jjtc000 = false;
6025 } else {
6026 jjtree.popNode();
6027 }
6028 if (jjte000 instanceof RuntimeException) {
6029 {if (true) throw (RuntimeException)jjte000;}
6030 }
6031 if (jjte000 instanceof ParseException) {
6032 {if (true) throw (ParseException)jjte000;}
6033 }
6034 {if (true) throw (Error)jjte000;}
6035 } finally {
6036 if (jjtc000) {
6037 jjtree.closeNodeScope(jjtn000, true);
6038 }
6039 }
6040 }
6041
6042 final public void MemberValue() throws ParseException {
6043
6044 ASTMemberValue jjtn000 = new ASTMemberValue(this, JJTMEMBERVALUE);
6045 boolean jjtc000 = true;
6046 jjtree.openNodeScope(jjtn000);
6047 try {
6048 switch (jj_nt.kind) {
6049 case AT:
6050 Annotation();
6051 break;
6052 case LBRACE:
6053 MemberValueArrayInitializer();
6054 break;
6055 case BOOLEAN:
6056 case BYTE:
6057 case CHAR:
6058 case DOUBLE:
6059 case FALSE:
6060 case FLOAT:
6061 case INT:
6062 case LONG:
6063 case NEW:
6064 case NULL:
6065 case SHORT:
6066 case SUPER:
6067 case THIS:
6068 case TRUE:
6069 case VOID:
6070 case INTEGER_LITERAL:
6071 case FLOATING_POINT_LITERAL:
6072 case HEX_FLOATING_POINT_LITERAL:
6073 case CHARACTER_LITERAL:
6074 case STRING_LITERAL:
6075 case IDENTIFIER:
6076 case LPAREN:
6077 case BANG:
6078 case TILDE:
6079 case INCR:
6080 case DECR:
6081 case PLUS:
6082 case MINUS:
6083 ConditionalExpression();
6084 break;
6085 default:
6086 jj_la1[143] = jj_gen;
6087 jj_consume_token(-1);
6088 throw new ParseException();
6089 }
6090 } catch (Throwable jjte000) {
6091 if (jjtc000) {
6092 jjtree.clearNodeScope(jjtn000);
6093 jjtc000 = false;
6094 } else {
6095 jjtree.popNode();
6096 }
6097 if (jjte000 instanceof RuntimeException) {
6098 {if (true) throw (RuntimeException)jjte000;}
6099 }
6100 if (jjte000 instanceof ParseException) {
6101 {if (true) throw (ParseException)jjte000;}
6102 }
6103 {if (true) throw (Error)jjte000;}
6104 } finally {
6105 if (jjtc000) {
6106 jjtree.closeNodeScope(jjtn000, true);
6107 }
6108 }
6109 }
6110
6111 final public void MemberValueArrayInitializer() throws ParseException {
6112
6113 ASTMemberValueArrayInitializer jjtn000 = new ASTMemberValueArrayInitializer(this, JJTMEMBERVALUEARRAYINITIALIZER);
6114 boolean jjtc000 = true;
6115 jjtree.openNodeScope(jjtn000);
6116 try {
6117 jj_consume_token(LBRACE);
6118 switch (jj_nt.kind) {
6119 case BOOLEAN:
6120 case BYTE:
6121 case CHAR:
6122 case DOUBLE:
6123 case FALSE:
6124 case FLOAT:
6125 case INT:
6126 case LONG:
6127 case NEW:
6128 case NULL:
6129 case SHORT:
6130 case SUPER:
6131 case THIS:
6132 case TRUE:
6133 case VOID:
6134 case INTEGER_LITERAL:
6135 case FLOATING_POINT_LITERAL:
6136 case HEX_FLOATING_POINT_LITERAL:
6137 case CHARACTER_LITERAL:
6138 case STRING_LITERAL:
6139 case IDENTIFIER:
6140 case LPAREN:
6141 case LBRACE:
6142 case AT:
6143 case BANG:
6144 case TILDE:
6145 case INCR:
6146 case DECR:
6147 case PLUS:
6148 case MINUS:
6149 MemberValue();
6150 label_69:
6151 while (true) {
6152 if (jj_2_74(2)) {
6153 ;
6154 } else {
6155 break label_69;
6156 }
6157 jj_consume_token(COMMA);
6158 MemberValue();
6159 }
6160 switch (jj_nt.kind) {
6161 case COMMA:
6162 jj_consume_token(COMMA);
6163 break;
6164 default:
6165 jj_la1[144] = jj_gen;
6166 ;
6167 }
6168 break;
6169 default:
6170 jj_la1[145] = jj_gen;
6171 ;
6172 }
6173 jj_consume_token(RBRACE);
6174 } catch (Throwable jjte000) {
6175 if (jjtc000) {
6176 jjtree.clearNodeScope(jjtn000);
6177 jjtc000 = false;
6178 } else {
6179 jjtree.popNode();
6180 }
6181 if (jjte000 instanceof RuntimeException) {
6182 {if (true) throw (RuntimeException)jjte000;}
6183 }
6184 if (jjte000 instanceof ParseException) {
6185 {if (true) throw (ParseException)jjte000;}
6186 }
6187 {if (true) throw (Error)jjte000;}
6188 } finally {
6189 if (jjtc000) {
6190 jjtree.closeNodeScope(jjtn000, true);
6191 }
6192 }
6193 }
6194
6195
6196 final public void AnnotationTypeDeclaration(int modifiers) throws ParseException {
6197
6198 ASTAnnotationTypeDeclaration jjtn000 = new ASTAnnotationTypeDeclaration(this, JJTANNOTATIONTYPEDECLARATION);
6199 boolean jjtc000 = true;
6200 jjtree.openNodeScope(jjtn000);Token t;
6201 jjtn000.setModifiers(modifiers);
6202 try {
6203 jj_consume_token(AT);
6204 jj_consume_token(INTERFACE);
6205 t = jj_consume_token(IDENTIFIER);
6206 checkForBadAnnotationUsage();jjtn000.setImage(t.image);
6207 AnnotationTypeBody();
6208 } catch (Throwable jjte000) {
6209 if (jjtc000) {
6210 jjtree.clearNodeScope(jjtn000);
6211 jjtc000 = false;
6212 } else {
6213 jjtree.popNode();
6214 }
6215 if (jjte000 instanceof RuntimeException) {
6216 {if (true) throw (RuntimeException)jjte000;}
6217 }
6218 if (jjte000 instanceof ParseException) {
6219 {if (true) throw (ParseException)jjte000;}
6220 }
6221 {if (true) throw (Error)jjte000;}
6222 } finally {
6223 if (jjtc000) {
6224 jjtree.closeNodeScope(jjtn000, true);
6225 }
6226 }
6227 }
6228
6229 final public void AnnotationTypeBody() throws ParseException {
6230
6231 ASTAnnotationTypeBody jjtn000 = new ASTAnnotationTypeBody(this, JJTANNOTATIONTYPEBODY);
6232 boolean jjtc000 = true;
6233 jjtree.openNodeScope(jjtn000);
6234 try {
6235 jj_consume_token(LBRACE);
6236 label_70:
6237 while (true) {
6238 switch (jj_nt.kind) {
6239 case ABSTRACT:
6240 case BOOLEAN:
6241 case BYTE:
6242 case CHAR:
6243 case CLASS:
6244 case _DEFAULT:
6245 case DOUBLE:
6246 case FINAL:
6247 case FLOAT:
6248 case INT:
6249 case INTERFACE:
6250 case LONG:
6251 case NATIVE:
6252 case PRIVATE:
6253 case PROTECTED:
6254 case PUBLIC:
6255 case SHORT:
6256 case STATIC:
6257 case SYNCHRONIZED:
6258 case TRANSIENT:
6259 case VOLATILE:
6260 case STRICTFP:
6261 case IDENTIFIER:
6262 case SEMICOLON:
6263 case AT:
6264 ;
6265 break;
6266 default:
6267 jj_la1[146] = jj_gen;
6268 break label_70;
6269 }
6270 AnnotationTypeMemberDeclaration();
6271 }
6272 jj_consume_token(RBRACE);
6273 } catch (Throwable jjte000) {
6274 if (jjtc000) {
6275 jjtree.clearNodeScope(jjtn000);
6276 jjtc000 = false;
6277 } else {
6278 jjtree.popNode();
6279 }
6280 if (jjte000 instanceof RuntimeException) {
6281 {if (true) throw (RuntimeException)jjte000;}
6282 }
6283 if (jjte000 instanceof ParseException) {
6284 {if (true) throw (ParseException)jjte000;}
6285 }
6286 {if (true) throw (Error)jjte000;}
6287 } finally {
6288 if (jjtc000) {
6289 jjtree.closeNodeScope(jjtn000, true);
6290 }
6291 }
6292 }
6293
6294 final public void AnnotationTypeMemberDeclaration() throws ParseException {
6295
6296 ASTAnnotationTypeMemberDeclaration jjtn000 = new ASTAnnotationTypeMemberDeclaration(this, JJTANNOTATIONTYPEMEMBERDECLARATION);
6297 boolean jjtc000 = true;
6298 jjtree.openNodeScope(jjtn000);int modifiers;
6299 try {
6300 switch (jj_nt.kind) {
6301 case ABSTRACT:
6302 case BOOLEAN:
6303 case BYTE:
6304 case CHAR:
6305 case CLASS:
6306 case _DEFAULT:
6307 case DOUBLE:
6308 case FINAL:
6309 case FLOAT:
6310 case INT:
6311 case INTERFACE:
6312 case LONG:
6313 case NATIVE:
6314 case PRIVATE:
6315 case PROTECTED:
6316 case PUBLIC:
6317 case SHORT:
6318 case STATIC:
6319 case SYNCHRONIZED:
6320 case TRANSIENT:
6321 case VOLATILE:
6322 case STRICTFP:
6323 case IDENTIFIER:
6324 case AT:
6325 modifiers = Modifiers();
6326 if (jj_2_75(3)) {
6327 AnnotationMethodDeclaration(modifiers);
6328 } else {
6329 switch (jj_nt.kind) {
6330 case ABSTRACT:
6331 case CLASS:
6332 case FINAL:
6333 case INTERFACE:
6334 ClassOrInterfaceDeclaration(modifiers);
6335 break;
6336 default:
6337 jj_la1[147] = jj_gen;
6338 if (jj_2_76(3)) {
6339 EnumDeclaration(modifiers);
6340 } else {
6341 switch (jj_nt.kind) {
6342 case AT:
6343 AnnotationTypeDeclaration(modifiers);
6344 break;
6345 case BOOLEAN:
6346 case BYTE:
6347 case CHAR:
6348 case DOUBLE:
6349 case FLOAT:
6350 case INT:
6351 case LONG:
6352 case SHORT:
6353 case IDENTIFIER:
6354 FieldDeclaration(modifiers);
6355 break;
6356 default:
6357 jj_la1[148] = jj_gen;
6358 jj_consume_token(-1);
6359 throw new ParseException();
6360 }
6361 }
6362 }
6363 }
6364 break;
6365 case SEMICOLON:
6366 jj_consume_token(SEMICOLON);
6367 break;
6368 default:
6369 jj_la1[149] = jj_gen;
6370 jj_consume_token(-1);
6371 throw new ParseException();
6372 }
6373 } catch (Throwable jjte000) {
6374 if (jjtc000) {
6375 jjtree.clearNodeScope(jjtn000);
6376 jjtc000 = false;
6377 } else {
6378 jjtree.popNode();
6379 }
6380 if (jjte000 instanceof RuntimeException) {
6381 {if (true) throw (RuntimeException)jjte000;}
6382 }
6383 if (jjte000 instanceof ParseException) {
6384 {if (true) throw (ParseException)jjte000;}
6385 }
6386 {if (true) throw (Error)jjte000;}
6387 } finally {
6388 if (jjtc000) {
6389 jjtree.closeNodeScope(jjtn000, true);
6390 }
6391 }
6392 }
6393
6394 final public void AnnotationMethodDeclaration(int modifiers) throws ParseException {
6395
6396 ASTAnnotationMethodDeclaration jjtn000 = new ASTAnnotationMethodDeclaration(this, JJTANNOTATIONMETHODDECLARATION);
6397 boolean jjtc000 = true;
6398 jjtree.openNodeScope(jjtn000);Token t;
6399 jjtn000.setModifiers(modifiers);
6400 try {
6401 Type();
6402 t = jj_consume_token(IDENTIFIER);
6403 jj_consume_token(LPAREN);
6404 jj_consume_token(RPAREN);
6405 switch (jj_nt.kind) {
6406 case _DEFAULT:
6407 DefaultValue();
6408 break;
6409 default:
6410 jj_la1[150] = jj_gen;
6411 ;
6412 }
6413 jj_consume_token(SEMICOLON);
6414 jjtree.closeNodeScope(jjtn000, true);
6415 jjtc000 = false;
6416 jjtn000.setImage(t.image);
6417 } catch (Throwable jjte000) {
6418 if (jjtc000) {
6419 jjtree.clearNodeScope(jjtn000);
6420 jjtc000 = false;
6421 } else {
6422 jjtree.popNode();
6423 }
6424 if (jjte000 instanceof RuntimeException) {
6425 {if (true) throw (RuntimeException)jjte000;}
6426 }
6427 if (jjte000 instanceof ParseException) {
6428 {if (true) throw (ParseException)jjte000;}
6429 }
6430 {if (true) throw (Error)jjte000;}
6431 } finally {
6432 if (jjtc000) {
6433 jjtree.closeNodeScope(jjtn000, true);
6434 }
6435 }
6436 }
6437
6438 final public void DefaultValue() throws ParseException {
6439
6440 ASTDefaultValue jjtn000 = new ASTDefaultValue(this, JJTDEFAULTVALUE);
6441 boolean jjtc000 = true;
6442 jjtree.openNodeScope(jjtn000);
6443 try {
6444 jj_consume_token(_DEFAULT);
6445 MemberValue();
6446 } catch (Throwable jjte000) {
6447 if (jjtc000) {
6448 jjtree.clearNodeScope(jjtn000);
6449 jjtc000 = false;
6450 } else {
6451 jjtree.popNode();
6452 }
6453 if (jjte000 instanceof RuntimeException) {
6454 {if (true) throw (RuntimeException)jjte000;}
6455 }
6456 if (jjte000 instanceof ParseException) {
6457 {if (true) throw (ParseException)jjte000;}
6458 }
6459 {if (true) throw (Error)jjte000;}
6460 } finally {
6461 if (jjtc000) {
6462 jjtree.closeNodeScope(jjtn000, true);
6463 }
6464 }
6465 }
6466
6467 private boolean jj_2_1(int xla) {
6468 jj_la = xla; jj_lastpos = jj_scanpos = token;
6469 try { return !jj_3_1(); }
6470 catch(LookaheadSuccess ls) { return true; }
6471 finally { jj_save(0, xla); }
6472 }
6473
6474 private boolean jj_2_2(int xla) {
6475 jj_la = xla; jj_lastpos = jj_scanpos = token;
6476 try { return !jj_3_2(); }
6477 catch(LookaheadSuccess ls) { return true; }
6478 finally { jj_save(1, xla); }
6479 }
6480
6481 private boolean jj_2_3(int xla) {
6482 jj_la = xla; jj_lastpos = jj_scanpos = token;
6483 try { return !jj_3_3(); }
6484 catch(LookaheadSuccess ls) { return true; }
6485 finally { jj_save(2, xla); }
6486 }
6487
6488 private boolean jj_2_4(int xla) {
6489 jj_la = xla; jj_lastpos = jj_scanpos = token;
6490 try { return !jj_3_4(); }
6491 catch(LookaheadSuccess ls) { return true; }
6492 finally { jj_save(3, xla); }
6493 }
6494
6495 private boolean jj_2_5(int xla) {
6496 jj_la = xla; jj_lastpos = jj_scanpos = token;
6497 try { return !jj_3_5(); }
6498 catch(LookaheadSuccess ls) { return true; }
6499 finally { jj_save(4, xla); }
6500 }
6501
6502 private boolean jj_2_6(int xla) {
6503 jj_la = xla; jj_lastpos = jj_scanpos = token;
6504 try { return !jj_3_6(); }
6505 catch(LookaheadSuccess ls) { return true; }
6506 finally { jj_save(5, xla); }
6507 }
6508
6509 private boolean jj_2_7(int xla) {
6510 jj_la = xla; jj_lastpos = jj_scanpos = token;
6511 try { return !jj_3_7(); }
6512 catch(LookaheadSuccess ls) { return true; }
6513 finally { jj_save(6, xla); }
6514 }
6515
6516 private boolean jj_2_8(int xla) {
6517 jj_la = xla; jj_lastpos = jj_scanpos = token;
6518 try { return !jj_3_8(); }
6519 catch(LookaheadSuccess ls) { return true; }
6520 finally { jj_save(7, xla); }
6521 }
6522
6523 private boolean jj_2_9(int xla) {
6524 jj_la = xla; jj_lastpos = jj_scanpos = token;
6525 try { return !jj_3_9(); }
6526 catch(LookaheadSuccess ls) { return true; }
6527 finally { jj_save(8, xla); }
6528 }
6529
6530 private boolean jj_2_10(int xla) {
6531 jj_la = xla; jj_lastpos = jj_scanpos = token;
6532 try { return !jj_3_10(); }
6533 catch(LookaheadSuccess ls) { return true; }
6534 finally { jj_save(9, xla); }
6535 }
6536
6537 private boolean jj_2_11(int xla) {
6538 jj_la = xla; jj_lastpos = jj_scanpos = token;
6539 try { return !jj_3_11(); }
6540 catch(LookaheadSuccess ls) { return true; }
6541 finally { jj_save(10, xla); }
6542 }
6543
6544 private boolean jj_2_12(int xla) {
6545 jj_la = xla; jj_lastpos = jj_scanpos = token;
6546 try { return !jj_3_12(); }
6547 catch(LookaheadSuccess ls) { return true; }
6548 finally { jj_save(11, xla); }
6549 }
6550
6551 private boolean jj_2_13(int xla) {
6552 jj_la = xla; jj_lastpos = jj_scanpos = token;
6553 try { return !jj_3_13(); }
6554 catch(LookaheadSuccess ls) { return true; }
6555 finally { jj_save(12, xla); }
6556 }
6557
6558 private boolean jj_2_14(int xla) {
6559 jj_la = xla; jj_lastpos = jj_scanpos = token;
6560 try { return !jj_3_14(); }
6561 catch(LookaheadSuccess ls) { return true; }
6562 finally { jj_save(13, xla); }
6563 }
6564
6565 private boolean jj_2_15(int xla) {
6566 jj_la = xla; jj_lastpos = jj_scanpos = token;
6567 try { return !jj_3_15(); }
6568 catch(LookaheadSuccess ls) { return true; }
6569 finally { jj_save(14, xla); }
6570 }
6571
6572 private boolean jj_2_16(int xla) {
6573 jj_la = xla; jj_lastpos = jj_scanpos = token;
6574 try { return !jj_3_16(); }
6575 catch(LookaheadSuccess ls) { return true; }
6576 finally { jj_save(15, xla); }
6577 }
6578
6579 private boolean jj_2_17(int xla) {
6580 jj_la = xla; jj_lastpos = jj_scanpos = token;
6581 try { return !jj_3_17(); }
6582 catch(LookaheadSuccess ls) { return true; }
6583 finally { jj_save(16, xla); }
6584 }
6585
6586 private boolean jj_2_18(int xla) {
6587 jj_la = xla; jj_lastpos = jj_scanpos = token;
6588 try { return !jj_3_18(); }
6589 catch(LookaheadSuccess ls) { return true; }
6590 finally { jj_save(17, xla); }
6591 }
6592
6593 private boolean jj_2_19(int xla) {
6594 jj_la = xla; jj_lastpos = jj_scanpos = token;
6595 try { return !jj_3_19(); }
6596 catch(LookaheadSuccess ls) { return true; }
6597 finally { jj_save(18, xla); }
6598 }
6599
6600 private boolean jj_2_20(int xla) {
6601 jj_la = xla; jj_lastpos = jj_scanpos = token;
6602 try { return !jj_3_20(); }
6603 catch(LookaheadSuccess ls) { return true; }
6604 finally { jj_save(19, xla); }
6605 }
6606
6607 private boolean jj_2_21(int xla) {
6608 jj_la = xla; jj_lastpos = jj_scanpos = token;
6609 try { return !jj_3_21(); }
6610 catch(LookaheadSuccess ls) { return true; }
6611 finally { jj_save(20, xla); }
6612 }
6613
6614 private boolean jj_2_22(int xla) {
6615 jj_la = xla; jj_lastpos = jj_scanpos = token;
6616 try { return !jj_3_22(); }
6617 catch(LookaheadSuccess ls) { return true; }
6618 finally { jj_save(21, xla); }
6619 }
6620
6621 private boolean jj_2_23(int xla) {
6622 jj_la = xla; jj_lastpos = jj_scanpos = token;
6623 try { return !jj_3_23(); }
6624 catch(LookaheadSuccess ls) { return true; }
6625 finally { jj_save(22, xla); }
6626 }
6627
6628 private boolean jj_2_24(int xla) {
6629 jj_la = xla; jj_lastpos = jj_scanpos = token;
6630 try { return !jj_3_24(); }
6631 catch(LookaheadSuccess ls) { return true; }
6632 finally { jj_save(23, xla); }
6633 }
6634
6635 private boolean jj_2_25(int xla) {
6636 jj_la = xla; jj_lastpos = jj_scanpos = token;
6637 try { return !jj_3_25(); }
6638 catch(LookaheadSuccess ls) { return true; }
6639 finally { jj_save(24, xla); }
6640 }
6641
6642 private boolean jj_2_26(int xla) {
6643 jj_la = xla; jj_lastpos = jj_scanpos = token;
6644 try { return !jj_3_26(); }
6645 catch(LookaheadSuccess ls) { return true; }
6646 finally { jj_save(25, xla); }
6647 }
6648
6649 private boolean jj_2_27(int xla) {
6650 jj_la = xla; jj_lastpos = jj_scanpos = token;
6651 try { return !jj_3_27(); }
6652 catch(LookaheadSuccess ls) { return true; }
6653 finally { jj_save(26, xla); }
6654 }
6655
6656 private boolean jj_2_28(int xla) {
6657 jj_la = xla; jj_lastpos = jj_scanpos = token;
6658 try { return !jj_3_28(); }
6659 catch(LookaheadSuccess ls) { return true; }
6660 finally { jj_save(27, xla); }
6661 }
6662
6663 private boolean jj_2_29(int xla) {
6664 jj_la = xla; jj_lastpos = jj_scanpos = token;
6665 try { return !jj_3_29(); }
6666 catch(LookaheadSuccess ls) { return true; }
6667 finally { jj_save(28, xla); }
6668 }
6669
6670 private boolean jj_2_30(int xla) {
6671 jj_la = xla; jj_lastpos = jj_scanpos = token;
6672 try { return !jj_3_30(); }
6673 catch(LookaheadSuccess ls) { return true; }
6674 finally { jj_save(29, xla); }
6675 }
6676
6677 private boolean jj_2_31(int xla) {
6678 jj_la = xla; jj_lastpos = jj_scanpos = token;
6679 try { return !jj_3_31(); }
6680 catch(LookaheadSuccess ls) { return true; }
6681 finally { jj_save(30, xla); }
6682 }
6683
6684 private boolean jj_2_32(int xla) {
6685 jj_la = xla; jj_lastpos = jj_scanpos = token;
6686 try { return !jj_3_32(); }
6687 catch(LookaheadSuccess ls) { return true; }
6688 finally { jj_save(31, xla); }
6689 }
6690
6691 private boolean jj_2_33(int xla) {
6692 jj_la = xla; jj_lastpos = jj_scanpos = token;
6693 try { return !jj_3_33(); }
6694 catch(LookaheadSuccess ls) { return true; }
6695 finally { jj_save(32, xla); }
6696 }
6697
6698 private boolean jj_2_34(int xla) {
6699 jj_la = xla; jj_lastpos = jj_scanpos = token;
6700 try { return !jj_3_34(); }
6701 catch(LookaheadSuccess ls) { return true; }
6702 finally { jj_save(33, xla); }
6703 }
6704
6705 private boolean jj_2_35(int xla) {
6706 jj_la = xla; jj_lastpos = jj_scanpos = token;
6707 try { return !jj_3_35(); }
6708 catch(LookaheadSuccess ls) { return true; }
6709 finally { jj_save(34, xla); }
6710 }
6711
6712 private boolean jj_2_36(int xla) {
6713 jj_la = xla; jj_lastpos = jj_scanpos = token;
6714 try { return !jj_3_36(); }
6715 catch(LookaheadSuccess ls) { return true; }
6716 finally { jj_save(35, xla); }
6717 }
6718
6719 private boolean jj_2_37(int xla) {
6720 jj_la = xla; jj_lastpos = jj_scanpos = token;
6721 try { return !jj_3_37(); }
6722 catch(LookaheadSuccess ls) { return true; }
6723 finally { jj_save(36, xla); }
6724 }
6725
6726 private boolean jj_2_38(int xla) {
6727 jj_la = xla; jj_lastpos = jj_scanpos = token;
6728 try { return !jj_3_38(); }
6729 catch(LookaheadSuccess ls) { return true; }
6730 finally { jj_save(37, xla); }
6731 }
6732
6733 private boolean jj_2_39(int xla) {
6734 jj_la = xla; jj_lastpos = jj_scanpos = token;
6735 try { return !jj_3_39(); }
6736 catch(LookaheadSuccess ls) { return true; }
6737 finally { jj_save(38, xla); }
6738 }
6739
6740 private boolean jj_2_40(int xla) {
6741 jj_la = xla; jj_lastpos = jj_scanpos = token;
6742 try { return !jj_3_40(); }
6743 catch(LookaheadSuccess ls) { return true; }
6744 finally { jj_save(39, xla); }
6745 }
6746
6747 private boolean jj_2_41(int xla) {
6748 jj_la = xla; jj_lastpos = jj_scanpos = token;
6749 try { return !jj_3_41(); }
6750 catch(LookaheadSuccess ls) { return true; }
6751 finally { jj_save(40, xla); }
6752 }
6753
6754 private boolean jj_2_42(int xla) {
6755 jj_la = xla; jj_lastpos = jj_scanpos = token;
6756 try { return !jj_3_42(); }
6757 catch(LookaheadSuccess ls) { return true; }
6758 finally { jj_save(41, xla); }
6759 }
6760
6761 private boolean jj_2_43(int xla) {
6762 jj_la = xla; jj_lastpos = jj_scanpos = token;
6763 try { return !jj_3_43(); }
6764 catch(LookaheadSuccess ls) { return true; }
6765 finally { jj_save(42, xla); }
6766 }
6767
6768 private boolean jj_2_44(int xla) {
6769 jj_la = xla; jj_lastpos = jj_scanpos = token;
6770 try { return !jj_3_44(); }
6771 catch(LookaheadSuccess ls) { return true; }
6772 finally { jj_save(43, xla); }
6773 }
6774
6775 private boolean jj_2_45(int xla) {
6776 jj_la = xla; jj_lastpos = jj_scanpos = token;
6777 try { return !jj_3_45(); }
6778 catch(LookaheadSuccess ls) { return true; }
6779 finally { jj_save(44, xla); }
6780 }
6781
6782 private boolean jj_2_46(int xla) {
6783 jj_la = xla; jj_lastpos = jj_scanpos = token;
6784 try { return !jj_3_46(); }
6785 catch(LookaheadSuccess ls) { return true; }
6786 finally { jj_save(45, xla); }
6787 }
6788
6789 private boolean jj_2_47(int xla) {
6790 jj_la = xla; jj_lastpos = jj_scanpos = token;
6791 try { return !jj_3_47(); }
6792 catch(LookaheadSuccess ls) { return true; }
6793 finally { jj_save(46, xla); }
6794 }
6795
6796 private boolean jj_2_48(int xla) {
6797 jj_la = xla; jj_lastpos = jj_scanpos = token;
6798 try { return !jj_3_48(); }
6799 catch(LookaheadSuccess ls) { return true; }
6800 finally { jj_save(47, xla); }
6801 }
6802
6803 private boolean jj_2_49(int xla) {
6804 jj_la = xla; jj_lastpos = jj_scanpos = token;
6805 try { return !jj_3_49(); }
6806 catch(LookaheadSuccess ls) { return true; }
6807 finally { jj_save(48, xla); }
6808 }
6809
6810 private boolean jj_2_50(int xla) {
6811 jj_la = xla; jj_lastpos = jj_scanpos = token;
6812 try { return !jj_3_50(); }
6813 catch(LookaheadSuccess ls) { return true; }
6814 finally { jj_save(49, xla); }
6815 }
6816
6817 private boolean jj_2_51(int xla) {
6818 jj_la = xla; jj_lastpos = jj_scanpos = token;
6819 try { return !jj_3_51(); }
6820 catch(LookaheadSuccess ls) { return true; }
6821 finally { jj_save(50, xla); }
6822 }
6823
6824 private boolean jj_2_52(int xla) {
6825 jj_la = xla; jj_lastpos = jj_scanpos = token;
6826 try { return !jj_3_52(); }
6827 catch(LookaheadSuccess ls) { return true; }
6828 finally { jj_save(51, xla); }
6829 }
6830
6831 private boolean jj_2_53(int xla) {
6832 jj_la = xla; jj_lastpos = jj_scanpos = token;
6833 try { return !jj_3_53(); }
6834 catch(LookaheadSuccess ls) { return true; }
6835 finally { jj_save(52, xla); }
6836 }
6837
6838 private boolean jj_2_54(int xla) {
6839 jj_la = xla; jj_lastpos = jj_scanpos = token;
6840 try { return !jj_3_54(); }
6841 catch(LookaheadSuccess ls) { return true; }
6842 finally { jj_save(53, xla); }
6843 }
6844
6845 private boolean jj_2_55(int xla) {
6846 jj_la = xla; jj_lastpos = jj_scanpos = token;
6847 try { return !jj_3_55(); }
6848 catch(LookaheadSuccess ls) { return true; }
6849 finally { jj_save(54, xla); }
6850 }
6851
6852 private boolean jj_2_56(int xla) {
6853 jj_la = xla; jj_lastpos = jj_scanpos = token;
6854 try { return !jj_3_56(); }
6855 catch(LookaheadSuccess ls) { return true; }
6856 finally { jj_save(55, xla); }
6857 }
6858
6859 private boolean jj_2_57(int xla) {
6860 jj_la = xla; jj_lastpos = jj_scanpos = token;
6861 try { return !jj_3_57(); }
6862 catch(LookaheadSuccess ls) { return true; }
6863 finally { jj_save(56, xla); }
6864 }
6865
6866 private boolean jj_2_58(int xla) {
6867 jj_la = xla; jj_lastpos = jj_scanpos = token;
6868 try { return !jj_3_58(); }
6869 catch(LookaheadSuccess ls) { return true; }
6870 finally { jj_save(57, xla); }
6871 }
6872
6873 private boolean jj_2_59(int xla) {
6874 jj_la = xla; jj_lastpos = jj_scanpos = token;
6875 try { return !jj_3_59(); }
6876 catch(LookaheadSuccess ls) { return true; }
6877 finally { jj_save(58, xla); }
6878 }
6879
6880 private boolean jj_2_60(int xla) {
6881 jj_la = xla; jj_lastpos = jj_scanpos = token;
6882 try { return !jj_3_60(); }
6883 catch(LookaheadSuccess ls) { return true; }
6884 finally { jj_save(59, xla); }
6885 }
6886
6887 private boolean jj_2_61(int xla) {
6888 jj_la = xla; jj_lastpos = jj_scanpos = token;
6889 try { return !jj_3_61(); }
6890 catch(LookaheadSuccess ls) { return true; }
6891 finally { jj_save(60, xla); }
6892 }
6893
6894 private boolean jj_2_62(int xla) {
6895 jj_la = xla; jj_lastpos = jj_scanpos = token;
6896 try { return !jj_3_62(); }
6897 catch(LookaheadSuccess ls) { return true; }
6898 finally { jj_save(61, xla); }
6899 }
6900
6901 private boolean jj_2_63(int xla) {
6902 jj_la = xla; jj_lastpos = jj_scanpos = token;
6903 try { return !jj_3_63(); }
6904 catch(LookaheadSuccess ls) { return true; }
6905 finally { jj_save(62, xla); }
6906 }
6907
6908 private boolean jj_2_64(int xla) {
6909 jj_la = xla; jj_lastpos = jj_scanpos = token;
6910 try { return !jj_3_64(); }
6911 catch(LookaheadSuccess ls) { return true; }
6912 finally { jj_save(63, xla); }
6913 }
6914
6915 private boolean jj_2_65(int xla) {
6916 jj_la = xla; jj_lastpos = jj_scanpos = token;
6917 try { return !jj_3_65(); }
6918 catch(LookaheadSuccess ls) { return true; }
6919 finally { jj_save(64, xla); }
6920 }
6921
6922 private boolean jj_2_66(int xla) {
6923 jj_la = xla; jj_lastpos = jj_scanpos = token;
6924 try { return !jj_3_66(); }
6925 catch(LookaheadSuccess ls) { return true; }
6926 finally { jj_save(65, xla); }
6927 }
6928
6929 private boolean jj_2_67(int xla) {
6930 jj_la = xla; jj_lastpos = jj_scanpos = token;
6931 try { return !jj_3_67(); }
6932 catch(LookaheadSuccess ls) { return true; }
6933 finally { jj_save(66, xla); }
6934 }
6935
6936 private boolean jj_2_68(int xla) {
6937 jj_la = xla; jj_lastpos = jj_scanpos = token;
6938 try { return !jj_3_68(); }
6939 catch(LookaheadSuccess ls) { return true; }
6940 finally { jj_save(67, xla); }
6941 }
6942
6943 private boolean jj_2_69(int xla) {
6944 jj_la = xla; jj_lastpos = jj_scanpos = token;
6945 try { return !jj_3_69(); }
6946 catch(LookaheadSuccess ls) { return true; }
6947 finally { jj_save(68, xla); }
6948 }
6949
6950 private boolean jj_2_70(int xla) {
6951 jj_la = xla; jj_lastpos = jj_scanpos = token;
6952 try { return !jj_3_70(); }
6953 catch(LookaheadSuccess ls) { return true; }
6954 finally { jj_save(69, xla); }
6955 }
6956
6957 private boolean jj_2_71(int xla) {
6958 jj_la = xla; jj_lastpos = jj_scanpos = token;
6959 try { return !jj_3_71(); }
6960 catch(LookaheadSuccess ls) { return true; }
6961 finally { jj_save(70, xla); }
6962 }
6963
6964 private boolean jj_2_72(int xla) {
6965 jj_la = xla; jj_lastpos = jj_scanpos = token;
6966 try { return !jj_3_72(); }
6967 catch(LookaheadSuccess ls) { return true; }
6968 finally { jj_save(71, xla); }
6969 }
6970
6971 private boolean jj_2_73(int xla) {
6972 jj_la = xla; jj_lastpos = jj_scanpos = token;
6973 try { return !jj_3_73(); }
6974 catch(LookaheadSuccess ls) { return true; }
6975 finally { jj_save(72, xla); }
6976 }
6977
6978 private boolean jj_2_74(int xla) {
6979 jj_la = xla; jj_lastpos = jj_scanpos = token;
6980 try { return !jj_3_74(); }
6981 catch(LookaheadSuccess ls) { return true; }
6982 finally { jj_save(73, xla); }
6983 }
6984
6985 private boolean jj_2_75(int xla) {
6986 jj_la = xla; jj_lastpos = jj_scanpos = token;
6987 try { return !jj_3_75(); }
6988 catch(LookaheadSuccess ls) { return true; }
6989 finally { jj_save(74, xla); }
6990 }
6991
6992 private boolean jj_2_76(int xla) {
6993 jj_la = xla; jj_lastpos = jj_scanpos = token;
6994 try { return !jj_3_76(); }
6995 catch(LookaheadSuccess ls) { return true; }
6996 finally { jj_save(75, xla); }
6997 }
6998
6999 private boolean jj_3R_259() {
7000 if (jj_3R_97()) return true;
7001 return false;
7002 }
7003
7004 private boolean jj_3R_361() {
7005 if (jj_scan_token(SUPER)) return true;
7006 Token xsp;
7007 while (true) {
7008 xsp = jj_scanpos;
7009 if (jj_3R_367()) { jj_scanpos = xsp; break; }
7010 }
7011 if (jj_3R_98()) return true;
7012 return false;
7013 }
7014
7015 private boolean jj_3R_360() {
7016 if (jj_scan_token(EXTENDS)) return true;
7017 Token xsp;
7018 while (true) {
7019 xsp = jj_scanpos;
7020 if (jj_3R_366()) { jj_scanpos = xsp; break; }
7021 }
7022 if (jj_3R_98()) return true;
7023 return false;
7024 }
7025
7026 private boolean jj_3R_354() {
7027 Token xsp;
7028 xsp = jj_scanpos;
7029 if (jj_3R_360()) {
7030 jj_scanpos = xsp;
7031 if (jj_3R_361()) return true;
7032 }
7033 return false;
7034 }
7035
7036 private boolean jj_3R_342() {
7037 if (jj_3R_354()) return true;
7038 return false;
7039 }
7040
7041 private boolean jj_3R_443() {
7042 if (jj_3R_444()) return true;
7043 return false;
7044 }
7045
7046 private boolean jj_3_17() {
7047 if (jj_scan_token(LBRACKET)) return true;
7048 if (jj_scan_token(RBRACKET)) return true;
7049 return false;
7050 }
7051
7052 private boolean jj_3R_179() {
7053 if (jj_scan_token(HOOK)) return true;
7054 Token xsp;
7055 xsp = jj_scanpos;
7056 if (jj_3R_342()) jj_scanpos = xsp;
7057 return false;
7058 }
7059
7060 private boolean jj_3R_278() {
7061 if (jj_3R_154()) return true;
7062 return false;
7063 }
7064
7065 private boolean jj_3R_99() {
7066 Token xsp;
7067 xsp = jj_scanpos;
7068 if (jj_3R_178()) {
7069 jj_scanpos = xsp;
7070 if (jj_3R_179()) return true;
7071 }
7072 return false;
7073 }
7074
7075 private boolean jj_3R_178() {
7076 Token xsp;
7077 while (true) {
7078 xsp = jj_scanpos;
7079 if (jj_3R_278()) { jj_scanpos = xsp; break; }
7080 }
7081 if (jj_3R_98()) return true;
7082 return false;
7083 }
7084
7085 private boolean jj_3R_175() {
7086 if (jj_scan_token(LT)) return true;
7087 if (jj_scan_token(GT)) return true;
7088 return false;
7089 }
7090
7091 private boolean jj_3R_97() {
7092 Token xsp;
7093 xsp = jj_scanpos;
7094 if (jj_3_21()) {
7095 jj_scanpos = xsp;
7096 if (jj_3R_175()) return true;
7097 }
7098 return false;
7099 }
7100
7101 private boolean jj_3_21() {
7102 if (jj_scan_token(LT)) return true;
7103 if (jj_3R_99()) return true;
7104 Token xsp;
7105 while (true) {
7106 xsp = jj_scanpos;
7107 if (jj_3R_276()) { jj_scanpos = xsp; break; }
7108 }
7109 if (jj_scan_token(GT)) return true;
7110 return false;
7111 }
7112
7113 private boolean jj_3_16() {
7114 if (jj_scan_token(LBRACKET)) return true;
7115 if (jj_scan_token(RBRACKET)) return true;
7116 return false;
7117 }
7118
7119 private boolean jj_3_19() {
7120 if (jj_scan_token(DOT)) return true;
7121 if (jj_scan_token(IDENTIFIER)) return true;
7122 Token xsp;
7123 xsp = jj_scanpos;
7124 if (jj_3_20()) jj_scanpos = xsp;
7125 return false;
7126 }
7127
7128 private boolean jj_3_18() {
7129 if (jj_3R_97()) return true;
7130 return false;
7131 }
7132
7133 private boolean jj_3R_277() {
7134 if (jj_scan_token(IDENTIFIER)) return true;
7135 Token xsp;
7136 xsp = jj_scanpos;
7137 if (jj_3_18()) jj_scanpos = xsp;
7138 while (true) {
7139 xsp = jj_scanpos;
7140 if (jj_3_19()) { jj_scanpos = xsp; break; }
7141 }
7142 return false;
7143 }
7144
7145 private boolean jj_3R_444() {
7146 if (jj_scan_token(_DEFAULT)) return true;
7147 if (jj_3R_152()) return true;
7148 return false;
7149 }
7150
7151 private boolean jj_3R_177() {
7152 if (jj_3R_277()) return true;
7153 Token xsp;
7154 while (true) {
7155 xsp = jj_scanpos;
7156 if (jj_3_17()) { jj_scanpos = xsp; break; }
7157 }
7158 return false;
7159 }
7160
7161 private boolean jj_3R_98() {
7162 Token xsp;
7163 xsp = jj_scanpos;
7164 if (jj_3R_176()) {
7165 jj_scanpos = xsp;
7166 if (jj_3R_177()) return true;
7167 }
7168 return false;
7169 }
7170
7171 private boolean jj_3R_176() {
7172 if (jj_3R_142()) return true;
7173 Token xsp;
7174 if (jj_3_16()) return true;
7175 while (true) {
7176 xsp = jj_scanpos;
7177 if (jj_3_16()) { jj_scanpos = xsp; break; }
7178 }
7179 return false;
7180 }
7181
7182 private boolean jj_3R_153() {
7183 if (jj_3R_90()) return true;
7184 if (jj_scan_token(IDENTIFIER)) return true;
7185 if (jj_scan_token(LPAREN)) return true;
7186 if (jj_scan_token(RPAREN)) return true;
7187 Token xsp;
7188 xsp = jj_scanpos;
7189 if (jj_3R_443()) jj_scanpos = xsp;
7190 if (jj_scan_token(SEMICOLON)) return true;
7191 return false;
7192 }
7193
7194 private boolean jj_3R_414() {
7195 if (jj_scan_token(THROWS)) return true;
7196 if (jj_3R_427()) return true;
7197 return false;
7198 }
7199
7200 private boolean jj_3R_164() {
7201 if (jj_3R_142()) return true;
7202 return false;
7203 }
7204
7205 private boolean jj_3R_90() {
7206 Token xsp;
7207 xsp = jj_scanpos;
7208 if (jj_3_15()) {
7209 jj_scanpos = xsp;
7210 if (jj_3R_164()) return true;
7211 }
7212 return false;
7213 }
7214
7215 private boolean jj_3_15() {
7216 if (jj_3R_98()) return true;
7217 return false;
7218 }
7219
7220 private boolean jj_3R_290() {
7221 if (jj_3R_154()) return true;
7222 return false;
7223 }
7224
7225 private boolean jj_3R_442() {
7226 if (jj_3R_405()) return true;
7227 return false;
7228 }
7229
7230 private boolean jj_3_12() {
7231 if (jj_3R_95()) return true;
7232 if (jj_scan_token(DOT)) return true;
7233 return false;
7234 }
7235
7236 private boolean jj_3R_441() {
7237 if (jj_3R_407()) return true;
7238 return false;
7239 }
7240
7241 private boolean jj_3R_403() {
7242 if (jj_scan_token(STATIC)) return true;
7243 return false;
7244 }
7245
7246 private boolean jj_3_14() {
7247 if (jj_3R_97()) return true;
7248 if (jj_scan_token(THIS)) return true;
7249 if (jj_3R_96()) return true;
7250 if (jj_scan_token(SEMICOLON)) return true;
7251 return false;
7252 }
7253
7254 private boolean jj_3_76() {
7255 if (jj_3R_88()) return true;
7256 return false;
7257 }
7258
7259 private boolean jj_3R_440() {
7260 if (jj_3R_87()) return true;
7261 return false;
7262 }
7263
7264 private boolean jj_3R_387() {
7265 Token xsp;
7266 xsp = jj_scanpos;
7267 if (jj_3R_403()) jj_scanpos = xsp;
7268 if (jj_3R_298()) return true;
7269 return false;
7270 }
7271
7272 private boolean jj_3_13() {
7273 if (jj_scan_token(THIS)) return true;
7274 if (jj_3R_96()) return true;
7275 if (jj_scan_token(SEMICOLON)) return true;
7276 return false;
7277 }
7278
7279 private boolean jj_3_75() {
7280 if (jj_3R_153()) return true;
7281 return false;
7282 }
7283
7284 private boolean jj_3_10() {
7285 if (jj_3R_93()) return true;
7286 return false;
7287 }
7288
7289 private boolean jj_3R_258() {
7290 if (jj_3R_95()) return true;
7291 if (jj_scan_token(DOT)) return true;
7292 return false;
7293 }
7294
7295 private boolean jj_3R_439() {
7296 if (jj_3R_388()) return true;
7297 Token xsp;
7298 xsp = jj_scanpos;
7299 if (jj_3_75()) {
7300 jj_scanpos = xsp;
7301 if (jj_3R_440()) {
7302 jj_scanpos = xsp;
7303 if (jj_3_76()) {
7304 jj_scanpos = xsp;
7305 if (jj_3R_441()) {
7306 jj_scanpos = xsp;
7307 if (jj_3R_442()) return true;
7308 }
7309 }
7310 }
7311 }
7312 return false;
7313 }
7314
7315 private boolean jj_3R_435() {
7316 Token xsp;
7317 xsp = jj_scanpos;
7318 if (jj_3R_439()) {
7319 jj_scanpos = xsp;
7320 if (jj_scan_token(82)) return true;
7321 }
7322 return false;
7323 }
7324
7325 private boolean jj_3R_169() {
7326 Token xsp;
7327 xsp = jj_scanpos;
7328 if (jj_3R_258()) jj_scanpos = xsp;
7329 xsp = jj_scanpos;
7330 if (jj_3R_259()) jj_scanpos = xsp;
7331 if (jj_scan_token(SUPER)) return true;
7332 if (jj_3R_96()) return true;
7333 if (jj_scan_token(SEMICOLON)) return true;
7334 return false;
7335 }
7336
7337 private boolean jj_3R_429() {
7338 if (jj_3R_435()) return true;
7339 return false;
7340 }
7341
7342 private boolean jj_3R_168() {
7343 if (jj_3R_97()) return true;
7344 if (jj_scan_token(THIS)) return true;
7345 if (jj_3R_96()) return true;
7346 if (jj_scan_token(SEMICOLON)) return true;
7347 return false;
7348 }
7349
7350 private boolean jj_3R_93() {
7351 Token xsp;
7352 xsp = jj_scanpos;
7353 if (jj_3R_167()) {
7354 jj_scanpos = xsp;
7355 if (jj_3R_168()) {
7356 jj_scanpos = xsp;
7357 if (jj_3R_169()) return true;
7358 }
7359 }
7360 return false;
7361 }
7362
7363 private boolean jj_3R_167() {
7364 if (jj_scan_token(THIS)) return true;
7365 if (jj_3R_96()) return true;
7366 if (jj_scan_token(SEMICOLON)) return true;
7367 return false;
7368 }
7369
7370 private boolean jj_3_74() {
7371 if (jj_scan_token(COMMA)) return true;
7372 if (jj_3R_152()) return true;
7373 return false;
7374 }
7375
7376 private boolean jj_3R_346() {
7377 if (jj_scan_token(COMMA)) return true;
7378 if (jj_3R_132()) return true;
7379 return false;
7380 }
7381
7382 private boolean jj_3R_421() {
7383 if (jj_scan_token(LBRACE)) return true;
7384 Token xsp;
7385 while (true) {
7386 xsp = jj_scanpos;
7387 if (jj_3R_429()) { jj_scanpos = xsp; break; }
7388 }
7389 if (jj_scan_token(RBRACE)) return true;
7390 return false;
7391 }
7392
7393 private boolean jj_3_11() {
7394 if (jj_3R_94()) return true;
7395 return false;
7396 }
7397
7398 private boolean jj_3R_415() {
7399 if (jj_3R_93()) return true;
7400 return false;
7401 }
7402
7403 private boolean jj_3R_413() {
7404 if (jj_3R_163()) return true;
7405 return false;
7406 }
7407
7408 private boolean jj_3R_407() {
7409 if (jj_scan_token(AT)) return true;
7410 if (jj_scan_token(INTERFACE)) return true;
7411 if (jj_scan_token(IDENTIFIER)) return true;
7412 if (jj_3R_421()) return true;
7413 return false;
7414 }
7415
7416 private boolean jj_3R_404() {
7417 Token xsp;
7418 xsp = jj_scanpos;
7419 if (jj_3R_413()) jj_scanpos = xsp;
7420 if (jj_scan_token(IDENTIFIER)) return true;
7421 if (jj_3R_138()) return true;
7422 xsp = jj_scanpos;
7423 if (jj_3R_414()) jj_scanpos = xsp;
7424 if (jj_scan_token(LBRACE)) return true;
7425 xsp = jj_scanpos;
7426 if (jj_3R_415()) jj_scanpos = xsp;
7427 while (true) {
7428 xsp = jj_scanpos;
7429 if (jj_3_11()) { jj_scanpos = xsp; break; }
7430 }
7431 if (jj_scan_token(RBRACE)) return true;
7432 return false;
7433 }
7434
7435 private boolean jj_3R_208() {
7436 if (jj_scan_token(BIT_OR)) return true;
7437 if (jj_3R_90()) return true;
7438 return false;
7439 }
7440
7441 private boolean jj_3R_428() {
7442 if (jj_scan_token(LBRACKET)) return true;
7443 if (jj_scan_token(RBRACKET)) return true;
7444 return false;
7445 }
7446
7447 private boolean jj_3R_419() {
7448 if (jj_scan_token(THROWS)) return true;
7449 if (jj_3R_427()) return true;
7450 return false;
7451 }
7452
7453 private boolean jj_3R_365() {
7454 if (jj_3R_152()) return true;
7455 Token xsp;
7456 while (true) {
7457 xsp = jj_scanpos;
7458 if (jj_3_74()) { jj_scanpos = xsp; break; }
7459 }
7460 xsp = jj_scanpos;
7461 if (jj_scan_token(83)) jj_scanpos = xsp;
7462 return false;
7463 }
7464
7465 private boolean jj_3R_209() {
7466 if (jj_scan_token(ELLIPSIS)) return true;
7467 return false;
7468 }
7469
7470 private boolean jj_3R_289() {
7471 if (jj_scan_token(FINAL)) return true;
7472 return false;
7473 }
7474
7475 private boolean jj_3R_207() {
7476 Token xsp;
7477 xsp = jj_scanpos;
7478 if (jj_3R_289()) {
7479 jj_scanpos = xsp;
7480 if (jj_3R_290()) return true;
7481 }
7482 return false;
7483 }
7484
7485 private boolean jj_3R_132() {
7486 Token xsp;
7487 while (true) {
7488 xsp = jj_scanpos;
7489 if (jj_3R_207()) { jj_scanpos = xsp; break; }
7490 }
7491 if (jj_3R_90()) return true;
7492 while (true) {
7493 xsp = jj_scanpos;
7494 if (jj_3R_208()) { jj_scanpos = xsp; break; }
7495 }
7496 xsp = jj_scanpos;
7497 if (jj_3R_209()) jj_scanpos = xsp;
7498 if (jj_3R_130()) return true;
7499 return false;
7500 }
7501
7502 private boolean jj_3R_316() {
7503 if (jj_scan_token(LBRACE)) return true;
7504 Token xsp;
7505 xsp = jj_scanpos;
7506 if (jj_3R_365()) jj_scanpos = xsp;
7507 if (jj_scan_token(RBRACE)) return true;
7508 return false;
7509 }
7510
7511 private boolean jj_3R_357() {
7512 if (jj_scan_token(COMMA)) return true;
7513 if (jj_3R_356()) return true;
7514 return false;
7515 }
7516
7517 private boolean jj_3R_214() {
7518 if (jj_3R_132()) return true;
7519 Token xsp;
7520 while (true) {
7521 xsp = jj_scanpos;
7522 if (jj_3R_346()) { jj_scanpos = xsp; break; }
7523 }
7524 return false;
7525 }
7526
7527 private boolean jj_3_9() {
7528 if (jj_scan_token(COMMA)) return true;
7529 if (jj_3R_92()) return true;
7530 return false;
7531 }
7532
7533 private boolean jj_3R_248() {
7534 if (jj_3R_192()) return true;
7535 return false;
7536 }
7537
7538 private boolean jj_3R_138() {
7539 if (jj_scan_token(LPAREN)) return true;
7540 Token xsp;
7541 xsp = jj_scanpos;
7542 if (jj_3R_214()) jj_scanpos = xsp;
7543 if (jj_scan_token(RPAREN)) return true;
7544 return false;
7545 }
7546
7547 private boolean jj_3R_247() {
7548 if (jj_3R_316()) return true;
7549 return false;
7550 }
7551
7552 private boolean jj_3R_152() {
7553 Token xsp;
7554 xsp = jj_scanpos;
7555 if (jj_3R_246()) {
7556 jj_scanpos = xsp;
7557 if (jj_3R_247()) {
7558 jj_scanpos = xsp;
7559 if (jj_3R_248()) return true;
7560 }
7561 }
7562 return false;
7563 }
7564
7565 private boolean jj_3R_246() {
7566 if (jj_3R_154()) return true;
7567 return false;
7568 }
7569
7570 private boolean jj_3R_356() {
7571 if (jj_scan_token(IDENTIFIER)) return true;
7572 if (jj_scan_token(ASSIGN)) return true;
7573 if (jj_3R_152()) return true;
7574 return false;
7575 }
7576
7577 private boolean jj_3R_418() {
7578 if (jj_scan_token(IDENTIFIER)) return true;
7579 if (jj_3R_138()) return true;
7580 Token xsp;
7581 while (true) {
7582 xsp = jj_scanpos;
7583 if (jj_3R_428()) { jj_scanpos = xsp; break; }
7584 }
7585 return false;
7586 }
7587
7588 private boolean jj_3R_347() {
7589 if (jj_3R_356()) return true;
7590 Token xsp;
7591 while (true) {
7592 xsp = jj_scanpos;
7593 if (jj_3R_357()) { jj_scanpos = xsp; break; }
7594 }
7595 return false;
7596 }
7597
7598 private boolean jj_3R_331() {
7599 if (jj_3R_347()) return true;
7600 return false;
7601 }
7602
7603 private boolean jj_3R_151() {
7604 if (jj_scan_token(IDENTIFIER)) return true;
7605 if (jj_scan_token(ASSIGN)) return true;
7606 return false;
7607 }
7608
7609 private boolean jj_3R_420() {
7610 if (jj_3R_298()) return true;
7611 return false;
7612 }
7613
7614 private boolean jj_3R_417() {
7615 if (jj_3R_163()) return true;
7616 return false;
7617 }
7618
7619 private boolean jj_3R_406() {
7620 Token xsp;
7621 xsp = jj_scanpos;
7622 if (jj_3R_417()) jj_scanpos = xsp;
7623 if (jj_3R_135()) return true;
7624 if (jj_3R_418()) return true;
7625 xsp = jj_scanpos;
7626 if (jj_3R_419()) jj_scanpos = xsp;
7627 xsp = jj_scanpos;
7628 if (jj_3R_420()) {
7629 jj_scanpos = xsp;
7630 if (jj_scan_token(82)) return true;
7631 }
7632 return false;
7633 }
7634
7635 private boolean jj_3R_364() {
7636 if (jj_3R_92()) return true;
7637 Token xsp;
7638 while (true) {
7639 xsp = jj_scanpos;
7640 if (jj_3_9()) { jj_scanpos = xsp; break; }
7641 }
7642 return false;
7643 }
7644
7645 private boolean jj_3R_318() {
7646 if (jj_scan_token(AT)) return true;
7647 if (jj_3R_136()) return true;
7648 if (jj_scan_token(LPAREN)) return true;
7649 if (jj_3R_152()) return true;
7650 if (jj_scan_token(RPAREN)) return true;
7651 return false;
7652 }
7653
7654 private boolean jj_3R_319() {
7655 if (jj_scan_token(AT)) return true;
7656 if (jj_3R_136()) return true;
7657 return false;
7658 }
7659
7660 private boolean jj_3R_314() {
7661 if (jj_scan_token(ASSIGN)) return true;
7662 if (jj_3R_92()) return true;
7663 return false;
7664 }
7665
7666 private boolean jj_3R_257() {
7667 if (jj_scan_token(LBRACE)) return true;
7668 Token xsp;
7669 xsp = jj_scanpos;
7670 if (jj_3R_364()) jj_scanpos = xsp;
7671 xsp = jj_scanpos;
7672 if (jj_scan_token(83)) jj_scanpos = xsp;
7673 if (jj_scan_token(RBRACE)) return true;
7674 return false;
7675 }
7676
7677 private boolean jj_3R_416() {
7678 if (jj_scan_token(COMMA)) return true;
7679 if (jj_3R_243()) return true;
7680 return false;
7681 }
7682
7683 private boolean jj_3_73() {
7684 if (jj_scan_token(AT)) return true;
7685 if (jj_3R_136()) return true;
7686 if (jj_scan_token(LPAREN)) return true;
7687 return false;
7688 }
7689
7690 private boolean jj_3R_317() {
7691 if (jj_scan_token(AT)) return true;
7692 if (jj_3R_136()) return true;
7693 if (jj_scan_token(LPAREN)) return true;
7694 Token xsp;
7695 xsp = jj_scanpos;
7696 if (jj_3R_331()) jj_scanpos = xsp;
7697 if (jj_scan_token(RPAREN)) return true;
7698 return false;
7699 }
7700
7701 private boolean jj_3R_91() {
7702 if (jj_scan_token(LBRACKET)) return true;
7703 if (jj_scan_token(RBRACKET)) return true;
7704 return false;
7705 }
7706
7707 private boolean jj_3R_166() {
7708 if (jj_3R_101()) return true;
7709 return false;
7710 }
7711
7712 private boolean jj_3_72() {
7713 if (jj_scan_token(AT)) return true;
7714 if (jj_3R_136()) return true;
7715 if (jj_scan_token(LPAREN)) return true;
7716 Token xsp;
7717 xsp = jj_scanpos;
7718 if (jj_3R_151()) {
7719 jj_scanpos = xsp;
7720 if (jj_scan_token(77)) return true;
7721 }
7722 return false;
7723 }
7724
7725 private boolean jj_3R_92() {
7726 Token xsp;
7727 xsp = jj_scanpos;
7728 if (jj_3R_165()) {
7729 jj_scanpos = xsp;
7730 if (jj_3R_166()) return true;
7731 }
7732 return false;
7733 }
7734
7735 private boolean jj_3R_165() {
7736 if (jj_3R_257()) return true;
7737 return false;
7738 }
7739
7740 private boolean jj_3R_251() {
7741 if (jj_3R_319()) return true;
7742 return false;
7743 }
7744
7745 private boolean jj_3R_250() {
7746 if (jj_3R_318()) return true;
7747 return false;
7748 }
7749
7750 private boolean jj_3R_206() {
7751 if (jj_scan_token(LBRACKET)) return true;
7752 if (jj_scan_token(RBRACKET)) return true;
7753 return false;
7754 }
7755
7756 private boolean jj_3R_437() {
7757 if (jj_3R_160()) return true;
7758 return false;
7759 }
7760
7761 private boolean jj_3R_154() {
7762 Token xsp;
7763 xsp = jj_scanpos;
7764 if (jj_3R_249()) {
7765 jj_scanpos = xsp;
7766 if (jj_3R_250()) {
7767 jj_scanpos = xsp;
7768 if (jj_3R_251()) return true;
7769 }
7770 }
7771 return false;
7772 }
7773
7774 private boolean jj_3R_194() {
7775 return false;
7776 }
7777
7778 private boolean jj_3R_249() {
7779 if (jj_3R_317()) return true;
7780 return false;
7781 }
7782
7783 private boolean jj_3R_321() {
7784 if (jj_3R_332()) return true;
7785 return false;
7786 }
7787
7788 private boolean jj_3R_130() {
7789 if (jj_scan_token(IDENTIFIER)) return true;
7790 Token xsp;
7791 while (true) {
7792 xsp = jj_scanpos;
7793 if (jj_3R_206()) { jj_scanpos = xsp; break; }
7794 }
7795 return false;
7796 }
7797
7798 private boolean jj_3R_369() {
7799 if (jj_scan_token(COLON)) return true;
7800 if (jj_3R_101()) return true;
7801 return false;
7802 }
7803
7804 private boolean jj_3R_256() {
7805 if (jj_scan_token(COMMA)) return true;
7806 if (jj_3R_255()) return true;
7807 return false;
7808 }
7809
7810 private boolean jj_3R_348() {
7811 if (jj_scan_token(BIT_AND)) return true;
7812 if (jj_3R_277()) return true;
7813 return false;
7814 }
7815
7816 private boolean jj_3R_243() {
7817 if (jj_3R_130()) return true;
7818 Token xsp;
7819 xsp = jj_scanpos;
7820 if (jj_3R_314()) jj_scanpos = xsp;
7821 return false;
7822 }
7823
7824 private boolean jj_3R_89() {
7825 if (jj_3R_163()) return true;
7826 return false;
7827 }
7828
7829 private boolean jj_3R_195() {
7830 return false;
7831 }
7832
7833 private boolean jj_3_7() {
7834 if (jj_3R_90()) return true;
7835 if (jj_scan_token(IDENTIFIER)) return true;
7836 Token xsp;
7837 while (true) {
7838 xsp = jj_scanpos;
7839 if (jj_3R_91()) { jj_scanpos = xsp; break; }
7840 }
7841 xsp = jj_scanpos;
7842 if (jj_scan_token(83)) {
7843 jj_scanpos = xsp;
7844 if (jj_scan_token(86)) {
7845 jj_scanpos = xsp;
7846 if (jj_scan_token(82)) return true;
7847 }
7848 }
7849 return false;
7850 }
7851
7852 private boolean jj_3_6() {
7853 Token xsp;
7854 xsp = jj_scanpos;
7855 if (jj_3R_89()) jj_scanpos = xsp;
7856 if (jj_scan_token(IDENTIFIER)) return true;
7857 if (jj_scan_token(LPAREN)) return true;
7858 return false;
7859 }
7860
7861 private boolean jj_3R_117() {
7862 jj_lookingAhead = true;
7863 jj_semLA = getToken(1).kind == GT &&
7864 ((Token.GTToken)getToken(1)).realKind == RSIGNEDSHIFT;
7865 jj_lookingAhead = false;
7866 if (!jj_semLA || jj_3R_194()) return true;
7867 if (jj_scan_token(GT)) return true;
7868 if (jj_scan_token(GT)) return true;
7869 return false;
7870 }
7871
7872 private boolean jj_3R_405() {
7873 if (jj_3R_90()) return true;
7874 if (jj_3R_243()) return true;
7875 Token xsp;
7876 while (true) {
7877 xsp = jj_scanpos;
7878 if (jj_3R_416()) { jj_scanpos = xsp; break; }
7879 }
7880 if (jj_scan_token(SEMICOLON)) return true;
7881 return false;
7882 }
7883
7884 private boolean jj_3R_85() {
7885 if (jj_3R_154()) return true;
7886 return false;
7887 }
7888
7889 private boolean jj_3R_436() {
7890 if (jj_3R_96()) return true;
7891 return false;
7892 }
7893
7894 private boolean jj_3R_392() {
7895 if (jj_3R_407()) return true;
7896 return false;
7897 }
7898
7899 private boolean jj_3R_156() {
7900 if (jj_scan_token(INTERFACE)) return true;
7901 return false;
7902 }
7903
7904 private boolean jj_3R_391() {
7905 if (jj_3R_406()) return true;
7906 return false;
7907 }
7908
7909 private boolean jj_3_8() {
7910 Token xsp;
7911 xsp = jj_scanpos;
7912 if (jj_scan_token(49)) jj_scanpos = xsp;
7913 if (jj_scan_token(LBRACE)) return true;
7914 return false;
7915 }
7916
7917 private boolean jj_3R_390() {
7918 if (jj_3R_405()) return true;
7919 return false;
7920 }
7921
7922 private boolean jj_3R_118() {
7923 jj_lookingAhead = true;
7924 jj_semLA = getToken(1).kind == GT &&
7925 ((Token.GTToken)getToken(1)).realKind == RUNSIGNEDSHIFT;
7926 jj_lookingAhead = false;
7927 if (!jj_semLA || jj_3R_195()) return true;
7928 if (jj_scan_token(GT)) return true;
7929 if (jj_scan_token(GT)) return true;
7930 if (jj_scan_token(GT)) return true;
7931 return false;
7932 }
7933
7934 private boolean jj_3R_389() {
7935 if (jj_3R_404()) return true;
7936 return false;
7937 }
7938
7939 private boolean jj_3_5() {
7940 if (jj_3R_88()) return true;
7941 return false;
7942 }
7943
7944 private boolean jj_3_4() {
7945 if (jj_3R_87()) return true;
7946 return false;
7947 }
7948
7949 private boolean jj_3R_372() {
7950 if (jj_3R_388()) return true;
7951 Token xsp;
7952 xsp = jj_scanpos;
7953 if (jj_3_4()) {
7954 jj_scanpos = xsp;
7955 if (jj_3_5()) {
7956 jj_scanpos = xsp;
7957 if (jj_3R_389()) {
7958 jj_scanpos = xsp;
7959 if (jj_3R_390()) {
7960 jj_scanpos = xsp;
7961 if (jj_3R_391()) {
7962 jj_scanpos = xsp;
7963 if (jj_3R_392()) return true;
7964 }
7965 }
7966 }
7967 }
7968 }
7969 return false;
7970 }
7971
7972 private boolean jj_3R_370() {
7973 Token xsp;
7974 xsp = jj_scanpos;
7975 if (jj_3R_371()) {
7976 jj_scanpos = xsp;
7977 if (jj_3R_372()) {
7978 jj_scanpos = xsp;
7979 if (jj_scan_token(82)) return true;
7980 }
7981 }
7982 return false;
7983 }
7984
7985 private boolean jj_3R_371() {
7986 if (jj_3R_387()) return true;
7987 return false;
7988 }
7989
7990 private boolean jj_3R_368() {
7991 if (jj_3R_370()) return true;
7992 return false;
7993 }
7994
7995 private boolean jj_3R_260() {
7996 if (jj_scan_token(IDENTIFIER)) return true;
7997 if (jj_3R_101()) return true;
7998 Token xsp;
7999 xsp = jj_scanpos;
8000 if (jj_3R_369()) jj_scanpos = xsp;
8001 if (jj_scan_token(SEMICOLON)) return true;
8002 return false;
8003 }
8004
8005 private boolean jj_3_3() {
8006 if (jj_scan_token(COMMA)) return true;
8007 Token xsp;
8008 while (true) {
8009 xsp = jj_scanpos;
8010 if (jj_3R_85()) { jj_scanpos = xsp; break; }
8011 }
8012 if (jj_3R_86()) return true;
8013 return false;
8014 }
8015
8016 private boolean jj_3R_160() {
8017 if (jj_scan_token(LBRACE)) return true;
8018 Token xsp;
8019 while (true) {
8020 xsp = jj_scanpos;
8021 if (jj_3R_368()) { jj_scanpos = xsp; break; }
8022 }
8023 if (jj_scan_token(RBRACE)) return true;
8024 return false;
8025 }
8026
8027 private boolean jj_3R_400() {
8028 if (jj_scan_token(FINALLY)) return true;
8029 if (jj_3R_298()) return true;
8030 return false;
8031 }
8032
8033 private boolean jj_3R_315() {
8034 if (jj_3R_154()) return true;
8035 return false;
8036 }
8037
8038 private boolean jj_3R_332() {
8039 if (jj_scan_token(EXTENDS)) return true;
8040 if (jj_3R_277()) return true;
8041 Token xsp;
8042 while (true) {
8043 xsp = jj_scanpos;
8044 if (jj_3R_348()) { jj_scanpos = xsp; break; }
8045 }
8046 return false;
8047 }
8048
8049 private boolean jj_3_71() {
8050 if (jj_scan_token(SEMICOLON)) return true;
8051 if (jj_3R_150()) return true;
8052 return false;
8053 }
8054
8055 private boolean jj_3R_320() {
8056 if (jj_3R_154()) return true;
8057 return false;
8058 }
8059
8060 private boolean jj_3R_399() {
8061 if (jj_scan_token(CATCH)) return true;
8062 if (jj_scan_token(LPAREN)) return true;
8063 if (jj_3R_132()) return true;
8064 if (jj_scan_token(RPAREN)) return true;
8065 if (jj_3R_298()) return true;
8066 return false;
8067 }
8068
8069 private boolean jj_3R_252() {
8070 Token xsp;
8071 xsp = jj_scanpos;
8072 if (jj_scan_token(28)) {
8073 jj_scanpos = xsp;
8074 if (jj_scan_token(12)) return true;
8075 }
8076 return false;
8077 }
8078
8079 private boolean jj_3R_255() {
8080 Token xsp;
8081 while (true) {
8082 xsp = jj_scanpos;
8083 if (jj_3R_320()) { jj_scanpos = xsp; break; }
8084 }
8085 if (jj_scan_token(IDENTIFIER)) return true;
8086 xsp = jj_scanpos;
8087 if (jj_3R_321()) jj_scanpos = xsp;
8088 return false;
8089 }
8090
8091 private boolean jj_3R_155() {
8092 Token xsp;
8093 xsp = jj_scanpos;
8094 if (jj_3R_252()) jj_scanpos = xsp;
8095 if (jj_scan_token(CLASS)) return true;
8096 return false;
8097 }
8098
8099 private boolean jj_3R_245() {
8100 Token xsp;
8101 xsp = jj_scanpos;
8102 if (jj_scan_token(28)) {
8103 jj_scanpos = xsp;
8104 if (jj_3R_315()) return true;
8105 }
8106 return false;
8107 }
8108
8109 private boolean jj_3R_150() {
8110 Token xsp;
8111 while (true) {
8112 xsp = jj_scanpos;
8113 if (jj_3R_245()) { jj_scanpos = xsp; break; }
8114 }
8115 if (jj_3R_90()) return true;
8116 if (jj_3R_130()) return true;
8117 if (jj_scan_token(ASSIGN)) return true;
8118 if (jj_3R_101()) return true;
8119 return false;
8120 }
8121
8122 private boolean jj_3R_163() {
8123 if (jj_scan_token(LT)) return true;
8124 if (jj_3R_255()) return true;
8125 Token xsp;
8126 while (true) {
8127 xsp = jj_scanpos;
8128 if (jj_3R_256()) { jj_scanpos = xsp; break; }
8129 }
8130 if (jj_scan_token(GT)) return true;
8131 return false;
8132 }
8133
8134 private boolean jj_3R_412() {
8135 if (jj_3R_150()) return true;
8136 Token xsp;
8137 while (true) {
8138 xsp = jj_scanpos;
8139 if (jj_3_71()) { jj_scanpos = xsp; break; }
8140 }
8141 return false;
8142 }
8143
8144 private boolean jj_3R_432() {
8145 if (jj_3R_370()) return true;
8146 return false;
8147 }
8148
8149 private boolean jj_3R_86() {
8150 if (jj_scan_token(IDENTIFIER)) return true;
8151 Token xsp;
8152 xsp = jj_scanpos;
8153 if (jj_3R_436()) jj_scanpos = xsp;
8154 xsp = jj_scanpos;
8155 if (jj_3R_437()) jj_scanpos = xsp;
8156 return false;
8157 }
8158
8159 private boolean jj_3_70() {
8160 if (jj_scan_token(SEMICOLON)) return true;
8161 return false;
8162 }
8163
8164 private boolean jj_3R_426() {
8165 if (jj_scan_token(SEMICOLON)) return true;
8166 Token xsp;
8167 while (true) {
8168 xsp = jj_scanpos;
8169 if (jj_3R_432()) { jj_scanpos = xsp; break; }
8170 }
8171 return false;
8172 }
8173
8174 private boolean jj_3R_431() {
8175 if (jj_3R_154()) return true;
8176 return false;
8177 }
8178
8179 private boolean jj_3R_425() {
8180 Token xsp;
8181 while (true) {
8182 xsp = jj_scanpos;
8183 if (jj_3R_431()) { jj_scanpos = xsp; break; }
8184 }
8185 if (jj_3R_86()) return true;
8186 while (true) {
8187 xsp = jj_scanpos;
8188 if (jj_3_3()) { jj_scanpos = xsp; break; }
8189 }
8190 return false;
8191 }
8192
8193 private boolean jj_3R_162() {
8194 if (jj_scan_token(LBRACE)) return true;
8195 Token xsp;
8196 xsp = jj_scanpos;
8197 if (jj_3R_425()) jj_scanpos = xsp;
8198 xsp = jj_scanpos;
8199 if (jj_scan_token(83)) jj_scanpos = xsp;
8200 xsp = jj_scanpos;
8201 if (jj_3R_426()) jj_scanpos = xsp;
8202 if (jj_scan_token(RBRACE)) return true;
8203 return false;
8204 }
8205
8206 private boolean jj_3R_398() {
8207 if (jj_scan_token(LPAREN)) return true;
8208 if (jj_3R_412()) return true;
8209 Token xsp;
8210 xsp = jj_scanpos;
8211 if (jj_3_70()) jj_scanpos = xsp;
8212 if (jj_scan_token(RPAREN)) return true;
8213 return false;
8214 }
8215
8216 private boolean jj_3R_380() {
8217 if (jj_3R_398()) return true;
8218 return false;
8219 }
8220
8221 private boolean jj_3R_161() {
8222 if (jj_3R_254()) return true;
8223 return false;
8224 }
8225
8226 private boolean jj_3R_382() {
8227 if (jj_3R_400()) return true;
8228 return false;
8229 }
8230
8231 private boolean jj_3R_381() {
8232 if (jj_3R_399()) return true;
8233 return false;
8234 }
8235
8236 private boolean jj_3R_311() {
8237 if (jj_scan_token(TRY)) return true;
8238 Token xsp;
8239 xsp = jj_scanpos;
8240 if (jj_3R_380()) jj_scanpos = xsp;
8241 if (jj_3R_298()) return true;
8242 while (true) {
8243 xsp = jj_scanpos;
8244 if (jj_3R_381()) { jj_scanpos = xsp; break; }
8245 }
8246 xsp = jj_scanpos;
8247 if (jj_3R_382()) jj_scanpos = xsp;
8248 return false;
8249 }
8250
8251 private boolean jj_3R_385() {
8252 if (jj_3R_154()) return true;
8253 return false;
8254 }
8255
8256 private boolean jj_3R_88() {
8257 if (jj_scan_token(IDENTIFIER)) return true;
8258 if (jj_scan_token(IDENTIFIER)) return true;
8259 Token xsp;
8260 xsp = jj_scanpos;
8261 if (jj_3R_161()) jj_scanpos = xsp;
8262 if (jj_3R_162()) return true;
8263 return false;
8264 }
8265
8266 private boolean jj_3R_402() {
8267 if (jj_3R_154()) return true;
8268 return false;
8269 }
8270
8271 private boolean jj_3R_310() {
8272 if (jj_scan_token(SYNCHRONIZED)) return true;
8273 if (jj_scan_token(LPAREN)) return true;
8274 if (jj_3R_101()) return true;
8275 if (jj_scan_token(RPAREN)) return true;
8276 if (jj_3R_298()) return true;
8277 return false;
8278 }
8279
8280 private boolean jj_3R_379() {
8281 if (jj_3R_101()) return true;
8282 return false;
8283 }
8284
8285 private boolean jj_3R_383() {
8286 if (jj_3R_154()) return true;
8287 return false;
8288 }
8289
8290 private boolean jj_3R_386() {
8291 if (jj_scan_token(COMMA)) return true;
8292 Token xsp;
8293 while (true) {
8294 xsp = jj_scanpos;
8295 if (jj_3R_402()) { jj_scanpos = xsp; break; }
8296 }
8297 if (jj_3R_277()) return true;
8298 return false;
8299 }
8300
8301 private boolean jj_3R_401() {
8302 if (jj_3R_154()) return true;
8303 return false;
8304 }
8305
8306 private boolean jj_3R_378() {
8307 if (jj_scan_token(IDENTIFIER)) return true;
8308 return false;
8309 }
8310
8311 private boolean jj_3R_309() {
8312 if (jj_scan_token(THROW)) return true;
8313 if (jj_3R_101()) return true;
8314 if (jj_scan_token(SEMICOLON)) return true;
8315 return false;
8316 }
8317
8318 private boolean jj_3R_254() {
8319 if (jj_scan_token(IMPLEMENTS)) return true;
8320 Token xsp;
8321 while (true) {
8322 xsp = jj_scanpos;
8323 if (jj_3R_385()) { jj_scanpos = xsp; break; }
8324 }
8325 if (jj_3R_277()) return true;
8326 while (true) {
8327 xsp = jj_scanpos;
8328 if (jj_3R_386()) { jj_scanpos = xsp; break; }
8329 }
8330 return false;
8331 }
8332
8333 private boolean jj_3R_384() {
8334 if (jj_scan_token(COMMA)) return true;
8335 Token xsp;
8336 while (true) {
8337 xsp = jj_scanpos;
8338 if (jj_3R_401()) { jj_scanpos = xsp; break; }
8339 }
8340 if (jj_3R_277()) return true;
8341 return false;
8342 }
8343
8344 private boolean jj_3R_430() {
8345 if (jj_scan_token(COMMA)) return true;
8346 if (jj_3R_300()) return true;
8347 return false;
8348 }
8349
8350 private boolean jj_3R_308() {
8351 if (jj_scan_token(RETURN)) return true;
8352 Token xsp;
8353 xsp = jj_scanpos;
8354 if (jj_3R_379()) jj_scanpos = xsp;
8355 if (jj_scan_token(SEMICOLON)) return true;
8356 return false;
8357 }
8358
8359 private boolean jj_3R_253() {
8360 if (jj_scan_token(EXTENDS)) return true;
8361 Token xsp;
8362 while (true) {
8363 xsp = jj_scanpos;
8364 if (jj_3R_383()) { jj_scanpos = xsp; break; }
8365 }
8366 if (jj_3R_277()) return true;
8367 while (true) {
8368 xsp = jj_scanpos;
8369 if (jj_3R_384()) { jj_scanpos = xsp; break; }
8370 }
8371 return false;
8372 }
8373
8374 private boolean jj_3R_377() {
8375 if (jj_scan_token(IDENTIFIER)) return true;
8376 return false;
8377 }
8378
8379 private boolean jj_3R_307() {
8380 if (jj_scan_token(CONTINUE)) return true;
8381 Token xsp;
8382 xsp = jj_scanpos;
8383 if (jj_3R_378()) jj_scanpos = xsp;
8384 if (jj_scan_token(SEMICOLON)) return true;
8385 return false;
8386 }
8387
8388 private boolean jj_3R_159() {
8389 if (jj_3R_254()) return true;
8390 return false;
8391 }
8392
8393 private boolean jj_3R_158() {
8394 if (jj_3R_253()) return true;
8395 return false;
8396 }
8397
8398 private boolean jj_3R_157() {
8399 if (jj_3R_163()) return true;
8400 return false;
8401 }
8402
8403 private boolean jj_3R_306() {
8404 if (jj_scan_token(BREAK)) return true;
8405 Token xsp;
8406 xsp = jj_scanpos;
8407 if (jj_3R_377()) jj_scanpos = xsp;
8408 if (jj_scan_token(SEMICOLON)) return true;
8409 return false;
8410 }
8411
8412 private boolean jj_3R_87() {
8413 Token xsp;
8414 xsp = jj_scanpos;
8415 if (jj_3R_155()) {
8416 jj_scanpos = xsp;
8417 if (jj_3R_156()) return true;
8418 }
8419 if (jj_scan_token(IDENTIFIER)) return true;
8420 xsp = jj_scanpos;
8421 if (jj_3R_157()) jj_scanpos = xsp;
8422 xsp = jj_scanpos;
8423 if (jj_3R_158()) jj_scanpos = xsp;
8424 xsp = jj_scanpos;
8425 if (jj_3R_159()) jj_scanpos = xsp;
8426 if (jj_3R_160()) return true;
8427 return false;
8428 }
8429
8430 private boolean jj_3R_411() {
8431 if (jj_3R_424()) return true;
8432 return false;
8433 }
8434
8435 private boolean jj_3_69() {
8436 if (jj_3R_149()) return true;
8437 return false;
8438 }
8439
8440 private boolean jj_3R_424() {
8441 if (jj_3R_300()) return true;
8442 Token xsp;
8443 while (true) {
8444 xsp = jj_scanpos;
8445 if (jj_3R_430()) { jj_scanpos = xsp; break; }
8446 }
8447 return false;
8448 }
8449
8450 private boolean jj_3R_374() {
8451 if (jj_scan_token(ELSE)) return true;
8452 if (jj_3R_146()) return true;
8453 return false;
8454 }
8455
8456 private boolean jj_3R_423() {
8457 if (jj_3R_424()) return true;
8458 return false;
8459 }
8460
8461 private boolean jj_3R_422() {
8462 if (jj_3R_149()) return true;
8463 return false;
8464 }
8465
8466 private boolean jj_3R_410() {
8467 Token xsp;
8468 xsp = jj_scanpos;
8469 if (jj_3R_422()) {
8470 jj_scanpos = xsp;
8471 if (jj_3R_423()) return true;
8472 }
8473 return false;
8474 }
8475
8476 private boolean jj_3_68() {
8477 if (jj_3R_149()) return true;
8478 if (jj_scan_token(COLON)) return true;
8479 return false;
8480 }
8481
8482 private boolean jj_3R_397() {
8483 if (jj_3R_411()) return true;
8484 return false;
8485 }
8486
8487 private boolean jj_3R_396() {
8488 if (jj_3R_101()) return true;
8489 return false;
8490 }
8491
8492 private boolean jj_3R_395() {
8493 if (jj_3R_410()) return true;
8494 return false;
8495 }
8496
8497 private boolean jj_3R_376() {
8498 Token xsp;
8499 xsp = jj_scanpos;
8500 if (jj_3R_395()) jj_scanpos = xsp;
8501 if (jj_scan_token(SEMICOLON)) return true;
8502 xsp = jj_scanpos;
8503 if (jj_3R_396()) jj_scanpos = xsp;
8504 if (jj_scan_token(SEMICOLON)) return true;
8505 xsp = jj_scanpos;
8506 if (jj_3R_397()) jj_scanpos = xsp;
8507 return false;
8508 }
8509
8510 private boolean jj_3R_375() {
8511 if (jj_3R_149()) return true;
8512 if (jj_scan_token(COLON)) return true;
8513 if (jj_3R_101()) return true;
8514 return false;
8515 }
8516
8517 private boolean jj_3R_84() {
8518 if (jj_3R_154()) return true;
8519 return false;
8520 }
8521
8522 private boolean jj_3R_305() {
8523 if (jj_scan_token(FOR)) return true;
8524 if (jj_scan_token(LPAREN)) return true;
8525 Token xsp;
8526 xsp = jj_scanpos;
8527 if (jj_3R_375()) {
8528 jj_scanpos = xsp;
8529 if (jj_3R_376()) return true;
8530 }
8531 if (jj_scan_token(RPAREN)) return true;
8532 if (jj_3R_146()) return true;
8533 return false;
8534 }
8535
8536 private boolean jj_3R_83() {
8537 if (jj_scan_token(_DEFAULT)) return true;
8538 return false;
8539 }
8540
8541 private boolean jj_3R_82() {
8542 if (jj_scan_token(STRICTFP)) return true;
8543 return false;
8544 }
8545
8546 private boolean jj_3R_81() {
8547 if (jj_scan_token(VOLATILE)) return true;
8548 return false;
8549 }
8550
8551 private boolean jj_3R_80() {
8552 if (jj_scan_token(TRANSIENT)) return true;
8553 return false;
8554 }
8555
8556 private boolean jj_3R_79() {
8557 if (jj_scan_token(NATIVE)) return true;
8558 return false;
8559 }
8560
8561 private boolean jj_3R_78() {
8562 if (jj_scan_token(SYNCHRONIZED)) return true;
8563 return false;
8564 }
8565
8566 private boolean jj_3R_304() {
8567 if (jj_scan_token(DO)) return true;
8568 if (jj_3R_146()) return true;
8569 if (jj_scan_token(WHILE)) return true;
8570 if (jj_scan_token(LPAREN)) return true;
8571 if (jj_3R_101()) return true;
8572 if (jj_scan_token(RPAREN)) return true;
8573 if (jj_scan_token(SEMICOLON)) return true;
8574 return false;
8575 }
8576
8577 private boolean jj_3R_77() {
8578 if (jj_scan_token(ABSTRACT)) return true;
8579 return false;
8580 }
8581
8582 private boolean jj_3R_76() {
8583 if (jj_scan_token(FINAL)) return true;
8584 return false;
8585 }
8586
8587 private boolean jj_3R_75() {
8588 if (jj_scan_token(PRIVATE)) return true;
8589 return false;
8590 }
8591
8592 private boolean jj_3R_74() {
8593 if (jj_scan_token(PROTECTED)) return true;
8594 return false;
8595 }
8596
8597 private boolean jj_3R_73() {
8598 if (jj_scan_token(STATIC)) return true;
8599 return false;
8600 }
8601
8602 private boolean jj_3R_303() {
8603 if (jj_scan_token(WHILE)) return true;
8604 if (jj_scan_token(LPAREN)) return true;
8605 if (jj_3R_101()) return true;
8606 if (jj_scan_token(RPAREN)) return true;
8607 if (jj_3R_146()) return true;
8608 return false;
8609 }
8610
8611 private boolean jj_3R_72() {
8612 if (jj_scan_token(PUBLIC)) return true;
8613 return false;
8614 }
8615
8616 private boolean jj_3_2() {
8617 Token xsp;
8618 xsp = jj_scanpos;
8619 if (jj_3R_72()) {
8620 jj_scanpos = xsp;
8621 if (jj_3R_73()) {
8622 jj_scanpos = xsp;
8623 if (jj_3R_74()) {
8624 jj_scanpos = xsp;
8625 if (jj_3R_75()) {
8626 jj_scanpos = xsp;
8627 if (jj_3R_76()) {
8628 jj_scanpos = xsp;
8629 if (jj_3R_77()) {
8630 jj_scanpos = xsp;
8631 if (jj_3R_78()) {
8632 jj_scanpos = xsp;
8633 if (jj_3R_79()) {
8634 jj_scanpos = xsp;
8635 if (jj_3R_80()) {
8636 jj_scanpos = xsp;
8637 if (jj_3R_81()) {
8638 jj_scanpos = xsp;
8639 if (jj_3R_82()) {
8640 jj_scanpos = xsp;
8641 if (jj_3R_83()) {
8642 jj_scanpos = xsp;
8643 if (jj_3R_84()) return true;
8644 }
8645 }
8646 }
8647 }
8648 }
8649 }
8650 }
8651 }
8652 }
8653 }
8654 }
8655 }
8656 return false;
8657 }
8658
8659 private boolean jj_3R_388() {
8660 Token xsp;
8661 while (true) {
8662 xsp = jj_scanpos;
8663 if (jj_3_2()) { jj_scanpos = xsp; break; }
8664 }
8665 return false;
8666 }
8667
8668 private boolean jj_3R_302() {
8669 if (jj_scan_token(IF)) return true;
8670 if (jj_scan_token(LPAREN)) return true;
8671 if (jj_3R_101()) return true;
8672 if (jj_scan_token(RPAREN)) return true;
8673 if (jj_3R_146()) return true;
8674 Token xsp;
8675 xsp = jj_scanpos;
8676 if (jj_3R_374()) jj_scanpos = xsp;
8677 return false;
8678 }
8679
8680 private boolean jj_3_67() {
8681 if (jj_3R_94()) return true;
8682 return false;
8683 }
8684
8685 private boolean jj_3R_261() {
8686 if (jj_3R_154()) return true;
8687 return false;
8688 }
8689
8690 private boolean jj_3R_409() {
8691 if (jj_scan_token(_DEFAULT)) return true;
8692 if (jj_scan_token(COLON)) return true;
8693 return false;
8694 }
8695
8696 private boolean jj_3R_408() {
8697 if (jj_scan_token(CASE)) return true;
8698 if (jj_3R_101()) return true;
8699 if (jj_scan_token(COLON)) return true;
8700 return false;
8701 }
8702
8703 private boolean jj_3R_394() {
8704 Token xsp;
8705 xsp = jj_scanpos;
8706 if (jj_3R_408()) {
8707 jj_scanpos = xsp;
8708 if (jj_3R_409()) return true;
8709 }
8710 return false;
8711 }
8712
8713 private boolean jj_3R_313() {
8714 if (jj_3R_154()) return true;
8715 return false;
8716 }
8717
8718 private boolean jj_3R_373() {
8719 if (jj_3R_394()) return true;
8720 Token xsp;
8721 while (true) {
8722 xsp = jj_scanpos;
8723 if (jj_3_67()) { jj_scanpos = xsp; break; }
8724 }
8725 return false;
8726 }
8727
8728 private boolean jj_3R_71() {
8729 if (jj_3R_154()) return true;
8730 return false;
8731 }
8732
8733 private boolean jj_3_1() {
8734 Token xsp;
8735 while (true) {
8736 xsp = jj_scanpos;
8737 if (jj_3R_71()) { jj_scanpos = xsp; break; }
8738 }
8739 if (jj_scan_token(PACKAGE)) return true;
8740 return false;
8741 }
8742
8743 private boolean jj_3R_301() {
8744 if (jj_scan_token(SWITCH)) return true;
8745 if (jj_scan_token(LPAREN)) return true;
8746 if (jj_3R_101()) return true;
8747 if (jj_scan_token(RPAREN)) return true;
8748 if (jj_scan_token(LBRACE)) return true;
8749 Token xsp;
8750 while (true) {
8751 xsp = jj_scanpos;
8752 if (jj_3R_373()) { jj_scanpos = xsp; break; }
8753 }
8754 if (jj_scan_token(RBRACE)) return true;
8755 return false;
8756 }
8757
8758 private boolean jj_3_66() {
8759 if (jj_3R_95()) return true;
8760 Token xsp;
8761 xsp = jj_scanpos;
8762 if (jj_scan_token(98)) {
8763 jj_scanpos = xsp;
8764 if (jj_scan_token(99)) return true;
8765 }
8766 return false;
8767 }
8768
8769 private boolean jj_3R_393() {
8770 if (jj_3R_100()) return true;
8771 if (jj_3R_101()) return true;
8772 return false;
8773 }
8774
8775 private boolean jj_3R_330() {
8776 if (jj_3R_95()) return true;
8777 Token xsp;
8778 xsp = jj_scanpos;
8779 if (jj_3R_393()) jj_scanpos = xsp;
8780 return false;
8781 }
8782
8783 private boolean jj_3R_148() {
8784 Token xsp;
8785 xsp = jj_scanpos;
8786 if (jj_scan_token(28)) {
8787 jj_scanpos = xsp;
8788 if (jj_scan_token(12)) return true;
8789 }
8790 return false;
8791 }
8792
8793 private boolean jj_3R_329() {
8794 if (jj_3R_345()) return true;
8795 return false;
8796 }
8797
8798 private boolean jj_3R_328() {
8799 if (jj_3R_283()) return true;
8800 return false;
8801 }
8802
8803 private boolean jj_3R_327() {
8804 if (jj_3R_282()) return true;
8805 return false;
8806 }
8807
8808 private boolean jj_3R_300() {
8809 Token xsp;
8810 xsp = jj_scanpos;
8811 if (jj_3R_327()) {
8812 jj_scanpos = xsp;
8813 if (jj_3R_328()) {
8814 jj_scanpos = xsp;
8815 if (jj_3R_329()) {
8816 jj_scanpos = xsp;
8817 if (jj_3R_330()) return true;
8818 }
8819 }
8820 }
8821 return false;
8822 }
8823
8824 private boolean jj_3R_299() {
8825 if (jj_scan_token(SEMICOLON)) return true;
8826 return false;
8827 }
8828
8829 private boolean jj_3R_147() {
8830 if (jj_3R_154()) return true;
8831 return false;
8832 }
8833
8834 private boolean jj_3_65() {
8835 Token xsp;
8836 xsp = jj_scanpos;
8837 if (jj_3R_147()) jj_scanpos = xsp;
8838 xsp = jj_scanpos;
8839 if (jj_3R_148()) jj_scanpos = xsp;
8840 if (jj_scan_token(CLASS)) return true;
8841 return false;
8842 }
8843
8844 private boolean jj_3R_226() {
8845 if (jj_3R_154()) return true;
8846 return false;
8847 }
8848
8849 private boolean jj_3R_244() {
8850 if (jj_scan_token(COMMA)) return true;
8851 if (jj_3R_243()) return true;
8852 return false;
8853 }
8854
8855 private boolean jj_3R_312() {
8856 if (jj_scan_token(FINAL)) return true;
8857 return false;
8858 }
8859
8860 private boolean jj_3R_242() {
8861 Token xsp;
8862 xsp = jj_scanpos;
8863 if (jj_3R_312()) {
8864 jj_scanpos = xsp;
8865 if (jj_3R_313()) return true;
8866 }
8867 return false;
8868 }
8869
8870 private boolean jj_3R_149() {
8871 Token xsp;
8872 while (true) {
8873 xsp = jj_scanpos;
8874 if (jj_3R_242()) { jj_scanpos = xsp; break; }
8875 }
8876 if (jj_3R_90()) return true;
8877 if (jj_3R_243()) return true;
8878 while (true) {
8879 xsp = jj_scanpos;
8880 if (jj_3R_244()) { jj_scanpos = xsp; break; }
8881 }
8882 return false;
8883 }
8884
8885 private boolean jj_3R_145() {
8886 Token xsp;
8887 xsp = jj_scanpos;
8888 if (jj_scan_token(28)) {
8889 jj_scanpos = xsp;
8890 if (jj_3R_226()) return true;
8891 }
8892 return false;
8893 }
8894
8895 private boolean jj_3R_172() {
8896 Token xsp;
8897 xsp = jj_scanpos;
8898 if (jj_3R_261()) jj_scanpos = xsp;
8899 if (jj_3R_87()) return true;
8900 return false;
8901 }
8902
8903 private boolean jj_3_63() {
8904 Token xsp;
8905 while (true) {
8906 xsp = jj_scanpos;
8907 if (jj_3R_145()) { jj_scanpos = xsp; break; }
8908 }
8909 if (jj_3R_90()) return true;
8910 if (jj_scan_token(IDENTIFIER)) return true;
8911 return false;
8912 }
8913
8914 private boolean jj_3_64() {
8915 if (jj_3R_146()) return true;
8916 return false;
8917 }
8918
8919 private boolean jj_3R_171() {
8920 if (jj_3R_149()) return true;
8921 if (jj_scan_token(SEMICOLON)) return true;
8922 return false;
8923 }
8924
8925 private boolean jj_3R_94() {
8926 Token xsp;
8927 xsp = jj_scanpos;
8928 jj_lookingAhead = true;
8929 jj_semLA = isNextTokenAnAssert();
8930 jj_lookingAhead = false;
8931 if (!jj_semLA || jj_3R_170()) {
8932 jj_scanpos = xsp;
8933 if (jj_3R_171()) {
8934 jj_scanpos = xsp;
8935 if (jj_3_64()) {
8936 jj_scanpos = xsp;
8937 if (jj_3R_172()) return true;
8938 }
8939 }
8940 }
8941 return false;
8942 }
8943
8944 private boolean jj_3_62() {
8945 if (jj_3R_94()) return true;
8946 return false;
8947 }
8948
8949 private boolean jj_3R_170() {
8950 if (jj_3R_260()) return true;
8951 return false;
8952 }
8953
8954 private boolean jj_3R_298() {
8955 if (jj_scan_token(LBRACE)) return true;
8956 Token xsp;
8957 while (true) {
8958 xsp = jj_scanpos;
8959 if (jj_3_62()) { jj_scanpos = xsp; break; }
8960 }
8961 if (jj_scan_token(RBRACE)) return true;
8962 return false;
8963 }
8964
8965 private boolean jj_3_59() {
8966 if (jj_scan_token(LBRACKET)) return true;
8967 if (jj_scan_token(RBRACKET)) return true;
8968 return false;
8969 }
8970
8971 private boolean jj_3R_144() {
8972 if (jj_scan_token(IDENTIFIER)) return true;
8973 if (jj_scan_token(COLON)) return true;
8974 if (jj_3R_146()) return true;
8975 return false;
8976 }
8977
8978 private boolean jj_3R_241() {
8979 if (jj_3R_311()) return true;
8980 return false;
8981 }
8982
8983 private boolean jj_3R_240() {
8984 if (jj_3R_310()) return true;
8985 return false;
8986 }
8987
8988 private boolean jj_3R_239() {
8989 if (jj_3R_309()) return true;
8990 return false;
8991 }
8992
8993 private boolean jj_3R_296() {
8994 if (jj_3R_298()) return true;
8995 return false;
8996 }
8997
8998 private boolean jj_3R_238() {
8999 if (jj_3R_308()) return true;
9000 return false;
9001 }
9002
9003 private boolean jj_3R_237() {
9004 if (jj_3R_307()) return true;
9005 return false;
9006 }
9007
9008 private boolean jj_3R_236() {
9009 if (jj_3R_306()) return true;
9010 return false;
9011 }
9012
9013 private boolean jj_3R_235() {
9014 if (jj_3R_305()) return true;
9015 return false;
9016 }
9017
9018 private boolean jj_3R_234() {
9019 if (jj_3R_304()) return true;
9020 return false;
9021 }
9022
9023 private boolean jj_3R_233() {
9024 if (jj_3R_303()) return true;
9025 return false;
9026 }
9027
9028 private boolean jj_3R_232() {
9029 if (jj_3R_302()) return true;
9030 return false;
9031 }
9032
9033 private boolean jj_3R_231() {
9034 if (jj_3R_301()) return true;
9035 return false;
9036 }
9037
9038 private boolean jj_3R_230() {
9039 if (jj_3R_300()) return true;
9040 if (jj_scan_token(SEMICOLON)) return true;
9041 return false;
9042 }
9043
9044 private boolean jj_3R_229() {
9045 if (jj_3R_299()) return true;
9046 return false;
9047 }
9048
9049 private boolean jj_3R_228() {
9050 if (jj_3R_298()) return true;
9051 return false;
9052 }
9053
9054 private boolean jj_3_61() {
9055 if (jj_3R_144()) return true;
9056 return false;
9057 }
9058
9059 private boolean jj_3R_146() {
9060 Token xsp;
9061 xsp = jj_scanpos;
9062 jj_lookingAhead = true;
9063 jj_semLA = isNextTokenAnAssert();
9064 jj_lookingAhead = false;
9065 if (!jj_semLA || jj_3R_227()) {
9066 jj_scanpos = xsp;
9067 if (jj_3_61()) {
9068 jj_scanpos = xsp;
9069 if (jj_3R_228()) {
9070 jj_scanpos = xsp;
9071 if (jj_3R_229()) {
9072 jj_scanpos = xsp;
9073 if (jj_3R_230()) {
9074 jj_scanpos = xsp;
9075 if (jj_3R_231()) {
9076 jj_scanpos = xsp;
9077 if (jj_3R_232()) {
9078 jj_scanpos = xsp;
9079 if (jj_3R_233()) {
9080 jj_scanpos = xsp;
9081 if (jj_3R_234()) {
9082 jj_scanpos = xsp;
9083 if (jj_3R_235()) {
9084 jj_scanpos = xsp;
9085 if (jj_3R_236()) {
9086 jj_scanpos = xsp;
9087 if (jj_3R_237()) {
9088 jj_scanpos = xsp;
9089 if (jj_3R_238()) {
9090 jj_scanpos = xsp;
9091 if (jj_3R_239()) {
9092 jj_scanpos = xsp;
9093 if (jj_3R_240()) {
9094 jj_scanpos = xsp;
9095 if (jj_3R_241()) return true;
9096 }
9097 }
9098 }
9099 }
9100 }
9101 }
9102 }
9103 }
9104 }
9105 }
9106 }
9107 }
9108 }
9109 }
9110 }
9111 return false;
9112 }
9113
9114 private boolean jj_3R_227() {
9115 if (jj_3R_260()) return true;
9116 return false;
9117 }
9118
9119 private boolean jj_3R_351() {
9120 if (jj_3R_97()) return true;
9121 return false;
9122 }
9123
9124 private boolean jj_3R_295() {
9125 if (jj_3R_101()) return true;
9126 return false;
9127 }
9128
9129 private boolean jj_3R_359() {
9130 if (jj_3R_160()) return true;
9131 return false;
9132 }
9133
9134 private boolean jj_3R_297() {
9135 if (jj_scan_token(LBRACKET)) return true;
9136 if (jj_scan_token(RBRACKET)) return true;
9137 return false;
9138 }
9139
9140 private boolean jj_3_58() {
9141 if (jj_scan_token(LBRACKET)) return true;
9142 if (jj_3R_101()) return true;
9143 if (jj_scan_token(RBRACKET)) return true;
9144 return false;
9145 }
9146
9147 private boolean jj_3R_225() {
9148 Token xsp;
9149 if (jj_3R_297()) return true;
9150 while (true) {
9151 xsp = jj_scanpos;
9152 if (jj_3R_297()) { jj_scanpos = xsp; break; }
9153 }
9154 if (jj_3R_257()) return true;
9155 return false;
9156 }
9157
9158 private boolean jj_3_60() {
9159 Token xsp;
9160 if (jj_3_58()) return true;
9161 while (true) {
9162 xsp = jj_scanpos;
9163 if (jj_3_58()) { jj_scanpos = xsp; break; }
9164 }
9165 while (true) {
9166 xsp = jj_scanpos;
9167 if (jj_3_59()) { jj_scanpos = xsp; break; }
9168 }
9169 return false;
9170 }
9171
9172 private boolean jj_3R_143() {
9173 Token xsp;
9174 xsp = jj_scanpos;
9175 if (jj_3_60()) {
9176 jj_scanpos = xsp;
9177 if (jj_3R_225()) return true;
9178 }
9179 return false;
9180 }
9181
9182 private boolean jj_3R_353() {
9183 if (jj_3R_96()) return true;
9184 Token xsp;
9185 xsp = jj_scanpos;
9186 if (jj_3R_359()) jj_scanpos = xsp;
9187 return false;
9188 }
9189
9190 private boolean jj_3R_352() {
9191 if (jj_3R_143()) return true;
9192 return false;
9193 }
9194
9195 private boolean jj_3R_323() {
9196 if (jj_scan_token(COMMA)) return true;
9197 if (jj_3R_101()) return true;
9198 return false;
9199 }
9200
9201 private boolean jj_3R_340() {
9202 if (jj_3R_154()) return true;
9203 return false;
9204 }
9205
9206 private boolean jj_3R_341() {
9207 if (jj_3R_277()) return true;
9208 Token xsp;
9209 xsp = jj_scanpos;
9210 if (jj_3R_351()) jj_scanpos = xsp;
9211 xsp = jj_scanpos;
9212 if (jj_3R_352()) {
9213 jj_scanpos = xsp;
9214 if (jj_3R_353()) return true;
9215 }
9216 return false;
9217 }
9218
9219 private boolean jj_3R_287() {
9220 if (jj_scan_token(BIT_AND)) return true;
9221 if (jj_3R_98()) return true;
9222 return false;
9223 }
9224
9225 private boolean jj_3_57() {
9226 if (jj_3R_142()) return true;
9227 if (jj_3R_143()) return true;
9228 return false;
9229 }
9230
9231 private boolean jj_3R_294() {
9232 if (jj_3R_298()) return true;
9233 return false;
9234 }
9235
9236 private boolean jj_3R_140() {
9237 if (jj_scan_token(NEW)) return true;
9238 Token xsp;
9239 while (true) {
9240 xsp = jj_scanpos;
9241 if (jj_3R_340()) { jj_scanpos = xsp; break; }
9242 }
9243 xsp = jj_scanpos;
9244 if (jj_3_57()) {
9245 jj_scanpos = xsp;
9246 if (jj_3R_341()) return true;
9247 }
9248 return false;
9249 }
9250
9251 private boolean jj_3R_131() {
9252 if (jj_scan_token(COMMA)) return true;
9253 if (jj_3R_130()) return true;
9254 return false;
9255 }
9256
9257 private boolean jj_3R_174() {
9258 if (jj_3R_275()) return true;
9259 return false;
9260 }
9261
9262 private boolean jj_3R_275() {
9263 if (jj_3R_101()) return true;
9264 Token xsp;
9265 while (true) {
9266 xsp = jj_scanpos;
9267 if (jj_3R_323()) { jj_scanpos = xsp; break; }
9268 }
9269 return false;
9270 }
9271
9272 private boolean jj_3R_292() {
9273 if (jj_3R_298()) return true;
9274 return false;
9275 }
9276
9277 private boolean jj_3R_139() {
9278 if (jj_scan_token(COMMA)) return true;
9279 if (jj_3R_130()) return true;
9280 return false;
9281 }
9282
9283 private boolean jj_3R_133() {
9284 if (jj_scan_token(COMMA)) return true;
9285 if (jj_3R_132()) return true;
9286 return false;
9287 }
9288
9289 private boolean jj_3R_96() {
9290 if (jj_scan_token(LPAREN)) return true;
9291 Token xsp;
9292 xsp = jj_scanpos;
9293 if (jj_3R_174()) jj_scanpos = xsp;
9294 if (jj_scan_token(RPAREN)) return true;
9295 return false;
9296 }
9297
9298 private boolean jj_3R_293() {
9299 if (jj_3R_101()) return true;
9300 return false;
9301 }
9302
9303 private boolean jj_3R_350() {
9304 if (jj_scan_token(NULL)) return true;
9305 return false;
9306 }
9307
9308 private boolean jj_3R_358() {
9309 if (jj_scan_token(TRUE)) return true;
9310 return false;
9311 }
9312
9313 private boolean jj_3R_349() {
9314 Token xsp;
9315 xsp = jj_scanpos;
9316 if (jj_3R_358()) {
9317 jj_scanpos = xsp;
9318 if (jj_scan_token(27)) return true;
9319 }
9320 return false;
9321 }
9322
9323 private boolean jj_3R_291() {
9324 if (jj_3R_101()) return true;
9325 return false;
9326 }
9327
9328 private boolean jj_3R_339() {
9329 if (jj_3R_350()) return true;
9330 return false;
9331 }
9332
9333 private boolean jj_3R_338() {
9334 if (jj_3R_349()) return true;
9335 return false;
9336 }
9337
9338 private boolean jj_3R_337() {
9339 if (jj_scan_token(STRING_LITERAL)) return true;
9340 return false;
9341 }
9342
9343 private boolean jj_3R_336() {
9344 if (jj_scan_token(CHARACTER_LITERAL)) return true;
9345 return false;
9346 }
9347
9348 private boolean jj_3R_335() {
9349 if (jj_scan_token(HEX_FLOATING_POINT_LITERAL)) return true;
9350 return false;
9351 }
9352
9353 private boolean jj_3R_334() {
9354 if (jj_scan_token(FLOATING_POINT_LITERAL)) return true;
9355 return false;
9356 }
9357
9358 private boolean jj_3R_333() {
9359 if (jj_scan_token(INTEGER_LITERAL)) return true;
9360 return false;
9361 }
9362
9363 private boolean jj_3R_322() {
9364 Token xsp;
9365 xsp = jj_scanpos;
9366 if (jj_3R_333()) {
9367 jj_scanpos = xsp;
9368 if (jj_3R_334()) {
9369 jj_scanpos = xsp;
9370 if (jj_3R_335()) {
9371 jj_scanpos = xsp;
9372 if (jj_3R_336()) {
9373 jj_scanpos = xsp;
9374 if (jj_3R_337()) {
9375 jj_scanpos = xsp;
9376 if (jj_3R_338()) {
9377 jj_scanpos = xsp;
9378 if (jj_3R_339()) return true;
9379 }
9380 }
9381 }
9382 }
9383 }
9384 }
9385 return false;
9386 }
9387
9388 private boolean jj_3R_213() {
9389 if (jj_scan_token(IDENTIFIER)) return true;
9390 return false;
9391 }
9392
9393 private boolean jj_3R_205() {
9394 if (jj_3R_96()) return true;
9395 return false;
9396 }
9397
9398 private boolean jj_3R_204() {
9399 if (jj_scan_token(DOT)) return true;
9400 if (jj_scan_token(IDENTIFIER)) return true;
9401 return false;
9402 }
9403
9404 private boolean jj_3R_203() {
9405 if (jj_scan_token(LBRACKET)) return true;
9406 if (jj_3R_101()) return true;
9407 if (jj_scan_token(RBRACKET)) return true;
9408 return false;
9409 }
9410
9411 private boolean jj_3_56() {
9412 if (jj_3R_141()) return true;
9413 return false;
9414 }
9415
9416 private boolean jj_3_55() {
9417 if (jj_scan_token(DOT)) return true;
9418 if (jj_3R_140()) return true;
9419 return false;
9420 }
9421
9422 private boolean jj_3R_129() {
9423 Token xsp;
9424 xsp = jj_scanpos;
9425 if (jj_3_53()) {
9426 jj_scanpos = xsp;
9427 if (jj_3_54()) {
9428 jj_scanpos = xsp;
9429 if (jj_3_55()) {
9430 jj_scanpos = xsp;
9431 if (jj_3_56()) {
9432 jj_scanpos = xsp;
9433 if (jj_3R_203()) {
9434 jj_scanpos = xsp;
9435 if (jj_3R_204()) {
9436 jj_scanpos = xsp;
9437 if (jj_3R_205()) return true;
9438 }
9439 }
9440 }
9441 }
9442 }
9443 }
9444 return false;
9445 }
9446
9447 private boolean jj_3R_124() {
9448 if (jj_scan_token(REM)) return true;
9449 return false;
9450 }
9451
9452 private boolean jj_3_54() {
9453 if (jj_scan_token(DOT)) return true;
9454 if (jj_scan_token(SUPER)) return true;
9455 return false;
9456 }
9457
9458 private boolean jj_3_53() {
9459 if (jj_scan_token(DOT)) return true;
9460 if (jj_scan_token(THIS)) return true;
9461 return false;
9462 }
9463
9464 private boolean jj_3_50() {
9465 if (jj_3R_98()) return true;
9466 if (jj_3R_137()) return true;
9467 return false;
9468 }
9469
9470 private boolean jj_3_49() {
9471 if (jj_3R_136()) return true;
9472 if (jj_scan_token(METHOD_REF)) return true;
9473 return false;
9474 }
9475
9476 private boolean jj_3_48() {
9477 if (jj_3R_135()) return true;
9478 if (jj_scan_token(DOT)) return true;
9479 if (jj_scan_token(CLASS)) return true;
9480 return false;
9481 }
9482
9483 private boolean jj_3_52() {
9484 if (jj_scan_token(LPAREN)) return true;
9485 if (jj_3R_130()) return true;
9486 Token xsp;
9487 while (true) {
9488 xsp = jj_scanpos;
9489 if (jj_3R_139()) { jj_scanpos = xsp; break; }
9490 }
9491 if (jj_scan_token(RPAREN)) return true;
9492 if (jj_scan_token(LAMBDA)) return true;
9493 xsp = jj_scanpos;
9494 if (jj_3R_295()) {
9495 jj_scanpos = xsp;
9496 if (jj_3R_296()) return true;
9497 }
9498 return false;
9499 }
9500
9501 private boolean jj_3R_363() {
9502 if (jj_scan_token(DECR)) return true;
9503 return false;
9504 }
9505
9506 private boolean jj_3_51() {
9507 if (jj_3R_138()) return true;
9508 if (jj_scan_token(LAMBDA)) return true;
9509 Token xsp;
9510 xsp = jj_scanpos;
9511 if (jj_3R_293()) {
9512 jj_scanpos = xsp;
9513 if (jj_3R_294()) return true;
9514 }
9515 return false;
9516 }
9517
9518 private boolean jj_3R_286() {
9519 if (jj_3R_154()) return true;
9520 return false;
9521 }
9522
9523 private boolean jj_3R_134() {
9524 Token xsp;
9525 xsp = jj_scanpos;
9526 if (jj_3R_210()) {
9527 jj_scanpos = xsp;
9528 if (jj_3_51()) {
9529 jj_scanpos = xsp;
9530 if (jj_3_52()) return true;
9531 }
9532 }
9533 return false;
9534 }
9535
9536 private boolean jj_3R_210() {
9537 if (jj_3R_130()) return true;
9538 if (jj_scan_token(LAMBDA)) return true;
9539 Token xsp;
9540 xsp = jj_scanpos;
9541 if (jj_3R_291()) {
9542 jj_scanpos = xsp;
9543 if (jj_3R_292()) return true;
9544 }
9545 return false;
9546 }
9547
9548 private boolean jj_3R_285() {
9549 if (jj_3R_154()) return true;
9550 return false;
9551 }
9552
9553 private boolean jj_3_46() {
9554 if (jj_3R_134()) return true;
9555 return false;
9556 }
9557
9558 private boolean jj_3_45() {
9559 if (jj_scan_token(LPAREN)) return true;
9560 if (jj_3R_132()) return true;
9561 if (jj_scan_token(COMMA)) return true;
9562 if (jj_3R_132()) return true;
9563 Token xsp;
9564 xsp = jj_scanpos;
9565 if (jj_3R_133()) jj_scanpos = xsp;
9566 if (jj_scan_token(RPAREN)) return true;
9567 if (jj_scan_token(LAMBDA)) return true;
9568 return false;
9569 }
9570
9571 private boolean jj_3_44() {
9572 if (jj_scan_token(LPAREN)) return true;
9573 if (jj_3R_130()) return true;
9574 if (jj_scan_token(COMMA)) return true;
9575 if (jj_3R_130()) return true;
9576 Token xsp;
9577 xsp = jj_scanpos;
9578 if (jj_3R_131()) jj_scanpos = xsp;
9579 if (jj_scan_token(RPAREN)) return true;
9580 if (jj_scan_token(LAMBDA)) return true;
9581 return false;
9582 }
9583
9584 private boolean jj_3_43() {
9585 if (jj_scan_token(IDENTIFIER)) return true;
9586 if (jj_scan_token(LAMBDA)) return true;
9587 return false;
9588 }
9589
9590 private boolean jj_3_42() {
9591 if (jj_scan_token(LPAREN)) return true;
9592 if (jj_scan_token(RPAREN)) return true;
9593 if (jj_scan_token(LAMBDA)) return true;
9594 return false;
9595 }
9596
9597 private boolean jj_3R_274() {
9598 if (jj_3R_136()) return true;
9599 return false;
9600 }
9601
9602 private boolean jj_3R_273() {
9603 if (jj_3R_98()) return true;
9604 if (jj_3R_137()) return true;
9605 return false;
9606 }
9607
9608 private boolean jj_3R_272() {
9609 if (jj_3R_136()) return true;
9610 return false;
9611 }
9612
9613 private boolean jj_3R_271() {
9614 if (jj_3R_135()) return true;
9615 if (jj_scan_token(DOT)) return true;
9616 if (jj_scan_token(CLASS)) return true;
9617 return false;
9618 }
9619
9620 private boolean jj_3R_270() {
9621 if (jj_3R_140()) return true;
9622 return false;
9623 }
9624
9625 private boolean jj_3_47() {
9626 if (jj_scan_token(LPAREN)) return true;
9627 if (jj_3R_101()) return true;
9628 if (jj_scan_token(RPAREN)) return true;
9629 return false;
9630 }
9631
9632 private boolean jj_3R_269() {
9633 if (jj_3R_134()) return true;
9634 return false;
9635 }
9636
9637 private boolean jj_3R_268() {
9638 if (jj_3R_134()) return true;
9639 return false;
9640 }
9641
9642 private boolean jj_3R_267() {
9643 if (jj_3R_134()) return true;
9644 return false;
9645 }
9646
9647 private boolean jj_3R_266() {
9648 if (jj_3R_134()) return true;
9649 return false;
9650 }
9651
9652 private boolean jj_3R_265() {
9653 if (jj_3R_134()) return true;
9654 return false;
9655 }
9656
9657 private boolean jj_3R_264() {
9658 if (jj_scan_token(SUPER)) return true;
9659 return false;
9660 }
9661
9662 private boolean jj_3R_263() {
9663 if (jj_scan_token(THIS)) return true;
9664 return false;
9665 }
9666
9667 private boolean jj_3R_173() {
9668 Token xsp;
9669 xsp = jj_scanpos;
9670 if (jj_3R_262()) {
9671 jj_scanpos = xsp;
9672 if (jj_3R_263()) {
9673 jj_scanpos = xsp;
9674 if (jj_3R_264()) {
9675 jj_scanpos = xsp;
9676 if (jj_3R_265()) {
9677 jj_scanpos = xsp;
9678 if (jj_3R_266()) {
9679 jj_scanpos = xsp;
9680 if (jj_3R_267()) {
9681 jj_scanpos = xsp;
9682 if (jj_3R_268()) {
9683 jj_scanpos = xsp;
9684 if (jj_3R_269()) {
9685 jj_scanpos = xsp;
9686 if (jj_3_47()) {
9687 jj_scanpos = xsp;
9688 if (jj_3R_270()) {
9689 jj_scanpos = xsp;
9690 if (jj_3R_271()) {
9691 jj_scanpos = xsp;
9692 if (jj_3R_272()) {
9693 jj_scanpos = xsp;
9694 if (jj_3R_273()) {
9695 jj_scanpos = xsp;
9696 if (jj_3R_274()) return true;
9697 }
9698 }
9699 }
9700 }
9701 }
9702 }
9703 }
9704 }
9705 }
9706 }
9707 }
9708 }
9709 }
9710 return false;
9711 }
9712
9713 private boolean jj_3R_212() {
9714 if (jj_scan_token(NEW)) return true;
9715 return false;
9716 }
9717
9718 private boolean jj_3R_262() {
9719 if (jj_3R_322()) return true;
9720 return false;
9721 }
9722
9723 private boolean jj_3R_120() {
9724 if (jj_scan_token(MINUS)) return true;
9725 return false;
9726 }
9727
9728 private boolean jj_3_41() {
9729 if (jj_3R_129()) return true;
9730 return false;
9731 }
9732
9733 private boolean jj_3R_123() {
9734 if (jj_scan_token(SLASH)) return true;
9735 return false;
9736 }
9737
9738 private boolean jj_3R_137() {
9739 if (jj_scan_token(METHOD_REF)) return true;
9740 Token xsp;
9741 xsp = jj_scanpos;
9742 if (jj_3R_212()) {
9743 jj_scanpos = xsp;
9744 if (jj_3R_213()) return true;
9745 }
9746 return false;
9747 }
9748
9749 private boolean jj_3R_344() {
9750 if (jj_scan_token(BANG)) return true;
9751 return false;
9752 }
9753
9754 private boolean jj_3R_216() {
9755 if (jj_3R_137()) return true;
9756 return false;
9757 }
9758
9759 private boolean jj_3R_362() {
9760 if (jj_scan_token(INCR)) return true;
9761 return false;
9762 }
9763
9764 private boolean jj_3R_355() {
9765 Token xsp;
9766 xsp = jj_scanpos;
9767 if (jj_3R_362()) {
9768 jj_scanpos = xsp;
9769 if (jj_3R_363()) return true;
9770 }
9771 return false;
9772 }
9773
9774 private boolean jj_3R_128() {
9775 if (jj_3R_154()) return true;
9776 return false;
9777 }
9778
9779 private boolean jj_3R_141() {
9780 Token xsp;
9781 xsp = jj_scanpos;
9782 if (jj_3R_215()) {
9783 jj_scanpos = xsp;
9784 if (jj_3R_216()) return true;
9785 }
9786 return false;
9787 }
9788
9789 private boolean jj_3R_215() {
9790 if (jj_scan_token(DOT)) return true;
9791 if (jj_3R_97()) return true;
9792 if (jj_scan_token(IDENTIFIER)) return true;
9793 return false;
9794 }
9795
9796 private boolean jj_3R_127() {
9797 if (jj_3R_154()) return true;
9798 return false;
9799 }
9800
9801 private boolean jj_3_40() {
9802 if (jj_scan_token(LPAREN)) return true;
9803 Token xsp;
9804 while (true) {
9805 xsp = jj_scanpos;
9806 if (jj_3R_128()) { jj_scanpos = xsp; break; }
9807 }
9808 if (jj_3R_90()) return true;
9809 if (jj_scan_token(BIT_AND)) return true;
9810 return false;
9811 }
9812
9813 private boolean jj_3_39() {
9814 if (jj_scan_token(LPAREN)) return true;
9815 Token xsp;
9816 while (true) {
9817 xsp = jj_scanpos;
9818 if (jj_3R_127()) { jj_scanpos = xsp; break; }
9819 }
9820 if (jj_3R_90()) return true;
9821 if (jj_scan_token(RPAREN)) return true;
9822 return false;
9823 }
9824
9825 private boolean jj_3R_95() {
9826 if (jj_3R_173()) return true;
9827 Token xsp;
9828 while (true) {
9829 xsp = jj_scanpos;
9830 if (jj_3_41()) { jj_scanpos = xsp; break; }
9831 }
9832 return false;
9833 }
9834
9835 private boolean jj_3R_288() {
9836 if (jj_3R_154()) return true;
9837 return false;
9838 }
9839
9840 private boolean jj_3R_202() {
9841 if (jj_scan_token(LPAREN)) return true;
9842 Token xsp;
9843 while (true) {
9844 xsp = jj_scanpos;
9845 if (jj_3R_288()) { jj_scanpos = xsp; break; }
9846 }
9847 if (jj_3R_90()) return true;
9848 if (jj_scan_token(RPAREN)) return true;
9849 if (jj_3R_284()) return true;
9850 return false;
9851 }
9852
9853 private boolean jj_3R_201() {
9854 if (jj_scan_token(LPAREN)) return true;
9855 Token xsp;
9856 while (true) {
9857 xsp = jj_scanpos;
9858 if (jj_3R_286()) { jj_scanpos = xsp; break; }
9859 }
9860 if (jj_3R_90()) return true;
9861 if (jj_3R_287()) return true;
9862 while (true) {
9863 xsp = jj_scanpos;
9864 if (jj_3R_287()) { jj_scanpos = xsp; break; }
9865 }
9866 if (jj_scan_token(RPAREN)) return true;
9867 if (jj_3R_284()) return true;
9868 return false;
9869 }
9870
9871 private boolean jj_3R_126() {
9872 Token xsp;
9873 xsp = jj_scanpos;
9874 if (jj_3R_200()) {
9875 jj_scanpos = xsp;
9876 if (jj_3R_201()) {
9877 jj_scanpos = xsp;
9878 if (jj_3R_202()) return true;
9879 }
9880 }
9881 return false;
9882 }
9883
9884 private boolean jj_3R_200() {
9885 if (jj_scan_token(LPAREN)) return true;
9886 Token xsp;
9887 while (true) {
9888 xsp = jj_scanpos;
9889 if (jj_3R_285()) { jj_scanpos = xsp; break; }
9890 }
9891 if (jj_3R_90()) return true;
9892 if (jj_scan_token(RPAREN)) return true;
9893 if (jj_3R_125()) return true;
9894 return false;
9895 }
9896
9897 private boolean jj_3_38() {
9898 if (jj_3R_126()) return true;
9899 return false;
9900 }
9901
9902 private boolean jj_3R_119() {
9903 if (jj_scan_token(PLUS)) return true;
9904 return false;
9905 }
9906
9907 private boolean jj_3R_281() {
9908 if (jj_scan_token(MINUS)) return true;
9909 return false;
9910 }
9911
9912 private boolean jj_3R_345() {
9913 if (jj_3R_95()) return true;
9914 Token xsp;
9915 xsp = jj_scanpos;
9916 if (jj_3R_355()) jj_scanpos = xsp;
9917 return false;
9918 }
9919
9920 private boolean jj_3R_122() {
9921 if (jj_scan_token(STAR)) return true;
9922 return false;
9923 }
9924
9925 private boolean jj_3R_108() {
9926 if (jj_scan_token(NE)) return true;
9927 return false;
9928 }
9929
9930 private boolean jj_3R_326() {
9931 if (jj_3R_345()) return true;
9932 return false;
9933 }
9934
9935 private boolean jj_3R_343() {
9936 if (jj_scan_token(TILDE)) return true;
9937 return false;
9938 }
9939
9940 private boolean jj_3R_325() {
9941 if (jj_3R_126()) return true;
9942 return false;
9943 }
9944
9945 private boolean jj_3R_324() {
9946 Token xsp;
9947 xsp = jj_scanpos;
9948 if (jj_3R_343()) {
9949 jj_scanpos = xsp;
9950 if (jj_3R_344()) return true;
9951 }
9952 if (jj_3R_125()) return true;
9953 return false;
9954 }
9955
9956 private boolean jj_3R_284() {
9957 Token xsp;
9958 xsp = jj_scanpos;
9959 if (jj_3R_324()) {
9960 jj_scanpos = xsp;
9961 if (jj_3R_325()) {
9962 jj_scanpos = xsp;
9963 if (jj_3R_326()) return true;
9964 }
9965 }
9966 return false;
9967 }
9968
9969 private boolean jj_3_36() {
9970 Token xsp;
9971 xsp = jj_scanpos;
9972 if (jj_3R_119()) {
9973 jj_scanpos = xsp;
9974 if (jj_3R_120()) return true;
9975 }
9976 if (jj_3R_121()) return true;
9977 return false;
9978 }
9979
9980 private boolean jj_3R_283() {
9981 if (jj_scan_token(DECR)) return true;
9982 if (jj_3R_95()) return true;
9983 return false;
9984 }
9985
9986 private boolean jj_3_37() {
9987 Token xsp;
9988 xsp = jj_scanpos;
9989 if (jj_3R_122()) {
9990 jj_scanpos = xsp;
9991 if (jj_3R_123()) {
9992 jj_scanpos = xsp;
9993 if (jj_3R_124()) return true;
9994 }
9995 }
9996 if (jj_3R_125()) return true;
9997 return false;
9998 }
9999
10000 private boolean jj_3R_282() {
10001 if (jj_scan_token(INCR)) return true;
10002 if (jj_3R_95()) return true;
10003 return false;
10004 }
10005
10006 private boolean jj_3R_199() {
10007 if (jj_3R_284()) return true;
10008 return false;
10009 }
10010
10011 private boolean jj_3R_198() {
10012 if (jj_3R_283()) return true;
10013 return false;
10014 }
10015
10016 private boolean jj_3R_197() {
10017 if (jj_3R_282()) return true;
10018 return false;
10019 }
10020
10021 private boolean jj_3R_280() {
10022 if (jj_scan_token(PLUS)) return true;
10023 return false;
10024 }
10025
10026 private boolean jj_3R_125() {
10027 Token xsp;
10028 xsp = jj_scanpos;
10029 if (jj_3R_196()) {
10030 jj_scanpos = xsp;
10031 if (jj_3R_197()) {
10032 jj_scanpos = xsp;
10033 if (jj_3R_198()) {
10034 jj_scanpos = xsp;
10035 if (jj_3R_199()) return true;
10036 }
10037 }
10038 }
10039 return false;
10040 }
10041
10042 private boolean jj_3R_196() {
10043 Token xsp;
10044 xsp = jj_scanpos;
10045 if (jj_3R_280()) {
10046 jj_scanpos = xsp;
10047 if (jj_3R_281()) return true;
10048 }
10049 if (jj_3R_125()) return true;
10050 return false;
10051 }
10052
10053 private boolean jj_3R_121() {
10054 if (jj_3R_125()) return true;
10055 Token xsp;
10056 while (true) {
10057 xsp = jj_scanpos;
10058 if (jj_3_37()) { jj_scanpos = xsp; break; }
10059 }
10060 return false;
10061 }
10062
10063 private boolean jj_3R_107() {
10064 if (jj_scan_token(EQ)) return true;
10065 return false;
10066 }
10067
10068 private boolean jj_3R_116() {
10069 if (jj_3R_121()) return true;
10070 Token xsp;
10071 while (true) {
10072 xsp = jj_scanpos;
10073 if (jj_3_36()) { jj_scanpos = xsp; break; }
10074 }
10075 return false;
10076 }
10077
10078 private boolean jj_3_35() {
10079 if (jj_3R_118()) return true;
10080 return false;
10081 }
10082
10083 private boolean jj_3_34() {
10084 if (jj_3R_117()) return true;
10085 return false;
10086 }
10087
10088 private boolean jj_3_31() {
10089 if (jj_scan_token(INSTANCEOF)) return true;
10090 if (jj_3R_90()) return true;
10091 return false;
10092 }
10093
10094 private boolean jj_3R_115() {
10095 if (jj_scan_token(LSHIFT)) return true;
10096 return false;
10097 }
10098
10099 private boolean jj_3_33() {
10100 Token xsp;
10101 xsp = jj_scanpos;
10102 if (jj_3R_115()) {
10103 jj_scanpos = xsp;
10104 if (jj_3_34()) {
10105 jj_scanpos = xsp;
10106 if (jj_3_35()) return true;
10107 }
10108 }
10109 if (jj_3R_116()) return true;
10110 return false;
10111 }
10112
10113 private boolean jj_3_30() {
10114 Token xsp;
10115 xsp = jj_scanpos;
10116 if (jj_3R_107()) {
10117 jj_scanpos = xsp;
10118 if (jj_3R_108()) return true;
10119 }
10120 if (jj_3R_109()) return true;
10121 return false;
10122 }
10123
10124 private boolean jj_3R_114() {
10125 if (jj_3R_116()) return true;
10126 Token xsp;
10127 while (true) {
10128 xsp = jj_scanpos;
10129 if (jj_3_33()) { jj_scanpos = xsp; break; }
10130 }
10131 return false;
10132 }
10133
10134 private boolean jj_3R_113() {
10135 if (jj_scan_token(GE)) return true;
10136 return false;
10137 }
10138
10139 private boolean jj_3R_112() {
10140 if (jj_scan_token(LE)) return true;
10141 return false;
10142 }
10143
10144 private boolean jj_3R_111() {
10145 if (jj_scan_token(GT)) return true;
10146 return false;
10147 }
10148
10149 private boolean jj_3R_110() {
10150 if (jj_scan_token(LT)) return true;
10151 return false;
10152 }
10153
10154 private boolean jj_3_29() {
10155 if (jj_scan_token(BIT_AND)) return true;
10156 if (jj_3R_106()) return true;
10157 return false;
10158 }
10159
10160 private boolean jj_3_32() {
10161 Token xsp;
10162 xsp = jj_scanpos;
10163 if (jj_3R_110()) {
10164 jj_scanpos = xsp;
10165 if (jj_3R_111()) {
10166 jj_scanpos = xsp;
10167 if (jj_3R_112()) {
10168 jj_scanpos = xsp;
10169 if (jj_3R_113()) return true;
10170 }
10171 }
10172 }
10173 if (jj_3R_114()) return true;
10174 return false;
10175 }
10176
10177 private boolean jj_3R_193() {
10178 if (jj_3R_114()) return true;
10179 Token xsp;
10180 while (true) {
10181 xsp = jj_scanpos;
10182 if (jj_3_32()) { jj_scanpos = xsp; break; }
10183 }
10184 return false;
10185 }
10186
10187 private boolean jj_3_27() {
10188 if (jj_scan_token(BIT_OR)) return true;
10189 if (jj_3R_104()) return true;
10190 return false;
10191 }
10192
10193 private boolean jj_3_28() {
10194 if (jj_scan_token(XOR)) return true;
10195 if (jj_3R_105()) return true;
10196 return false;
10197 }
10198
10199 private boolean jj_3R_109() {
10200 if (jj_3R_193()) return true;
10201 Token xsp;
10202 xsp = jj_scanpos;
10203 if (jj_3_31()) jj_scanpos = xsp;
10204 return false;
10205 }
10206
10207 private boolean jj_3_26() {
10208 if (jj_scan_token(SC_AND)) return true;
10209 if (jj_3R_103()) return true;
10210 return false;
10211 }
10212
10213 private boolean jj_3R_106() {
10214 if (jj_3R_109()) return true;
10215 Token xsp;
10216 while (true) {
10217 xsp = jj_scanpos;
10218 if (jj_3_30()) { jj_scanpos = xsp; break; }
10219 }
10220 return false;
10221 }
10222
10223 private boolean jj_3_25() {
10224 if (jj_scan_token(SC_OR)) return true;
10225 if (jj_3R_102()) return true;
10226 return false;
10227 }
10228
10229 private boolean jj_3R_105() {
10230 if (jj_3R_106()) return true;
10231 Token xsp;
10232 while (true) {
10233 xsp = jj_scanpos;
10234 if (jj_3_29()) { jj_scanpos = xsp; break; }
10235 }
10236 return false;
10237 }
10238
10239 private boolean jj_3_24() {
10240 if (jj_scan_token(HOOK)) return true;
10241 if (jj_3R_101()) return true;
10242 if (jj_scan_token(COLON)) return true;
10243 if (jj_3R_192()) return true;
10244 return false;
10245 }
10246
10247 private boolean jj_3R_104() {
10248 if (jj_3R_105()) return true;
10249 Token xsp;
10250 while (true) {
10251 xsp = jj_scanpos;
10252 if (jj_3_28()) { jj_scanpos = xsp; break; }
10253 }
10254 return false;
10255 }
10256
10257 private boolean jj_3R_103() {
10258 if (jj_3R_104()) return true;
10259 Token xsp;
10260 while (true) {
10261 xsp = jj_scanpos;
10262 if (jj_3_27()) { jj_scanpos = xsp; break; }
10263 }
10264 return false;
10265 }
10266
10267 private boolean jj_3R_102() {
10268 if (jj_3R_103()) return true;
10269 Token xsp;
10270 while (true) {
10271 xsp = jj_scanpos;
10272 if (jj_3_26()) { jj_scanpos = xsp; break; }
10273 }
10274 return false;
10275 }
10276
10277 private boolean jj_3R_279() {
10278 if (jj_3R_102()) return true;
10279 Token xsp;
10280 while (true) {
10281 xsp = jj_scanpos;
10282 if (jj_3_25()) { jj_scanpos = xsp; break; }
10283 }
10284 return false;
10285 }
10286
10287 private boolean jj_3R_192() {
10288 if (jj_3R_279()) return true;
10289 Token xsp;
10290 xsp = jj_scanpos;
10291 if (jj_3_24()) jj_scanpos = xsp;
10292 return false;
10293 }
10294
10295 private boolean jj_3R_191() {
10296 if (jj_scan_token(ORASSIGN)) return true;
10297 return false;
10298 }
10299
10300 private boolean jj_3R_190() {
10301 if (jj_scan_token(XORASSIGN)) return true;
10302 return false;
10303 }
10304
10305 private boolean jj_3R_189() {
10306 if (jj_scan_token(ANDASSIGN)) return true;
10307 return false;
10308 }
10309
10310 private boolean jj_3R_188() {
10311 if (jj_scan_token(RUNSIGNEDSHIFTASSIGN)) return true;
10312 return false;
10313 }
10314
10315 private boolean jj_3R_187() {
10316 if (jj_scan_token(RSIGNEDSHIFTASSIGN)) return true;
10317 return false;
10318 }
10319
10320 private boolean jj_3R_186() {
10321 if (jj_scan_token(LSHIFTASSIGN)) return true;
10322 return false;
10323 }
10324
10325 private boolean jj_3R_185() {
10326 if (jj_scan_token(MINUSASSIGN)) return true;
10327 return false;
10328 }
10329
10330 private boolean jj_3R_184() {
10331 if (jj_scan_token(PLUSASSIGN)) return true;
10332 return false;
10333 }
10334
10335 private boolean jj_3R_183() {
10336 if (jj_scan_token(REMASSIGN)) return true;
10337 return false;
10338 }
10339
10340 private boolean jj_3R_182() {
10341 if (jj_scan_token(SLASHASSIGN)) return true;
10342 return false;
10343 }
10344
10345 private boolean jj_3R_181() {
10346 if (jj_scan_token(STARASSIGN)) return true;
10347 return false;
10348 }
10349
10350 private boolean jj_3R_100() {
10351 Token xsp;
10352 xsp = jj_scanpos;
10353 if (jj_3R_180()) {
10354 jj_scanpos = xsp;
10355 if (jj_3R_181()) {
10356 jj_scanpos = xsp;
10357 if (jj_3R_182()) {
10358 jj_scanpos = xsp;
10359 if (jj_3R_183()) {
10360 jj_scanpos = xsp;
10361 if (jj_3R_184()) {
10362 jj_scanpos = xsp;
10363 if (jj_3R_185()) {
10364 jj_scanpos = xsp;
10365 if (jj_3R_186()) {
10366 jj_scanpos = xsp;
10367 if (jj_3R_187()) {
10368 jj_scanpos = xsp;
10369 if (jj_3R_188()) {
10370 jj_scanpos = xsp;
10371 if (jj_3R_189()) {
10372 jj_scanpos = xsp;
10373 if (jj_3R_190()) {
10374 jj_scanpos = xsp;
10375 if (jj_3R_191()) return true;
10376 }
10377 }
10378 }
10379 }
10380 }
10381 }
10382 }
10383 }
10384 }
10385 }
10386 }
10387 return false;
10388 }
10389
10390 private boolean jj_3R_180() {
10391 if (jj_scan_token(ASSIGN)) return true;
10392 return false;
10393 }
10394
10395 private boolean jj_3_23() {
10396 if (jj_3R_100()) return true;
10397 if (jj_3R_101()) return true;
10398 return false;
10399 }
10400
10401 private boolean jj_3R_101() {
10402 if (jj_3R_192()) return true;
10403 Token xsp;
10404 xsp = jj_scanpos;
10405 if (jj_3_23()) jj_scanpos = xsp;
10406 return false;
10407 }
10408
10409 private boolean jj_3R_438() {
10410 if (jj_3R_154()) return true;
10411 return false;
10412 }
10413
10414 private boolean jj_3R_434() {
10415 if (jj_scan_token(COMMA)) return true;
10416 Token xsp;
10417 while (true) {
10418 xsp = jj_scanpos;
10419 if (jj_3R_438()) { jj_scanpos = xsp; break; }
10420 }
10421 if (jj_3R_136()) return true;
10422 return false;
10423 }
10424
10425 private boolean jj_3R_433() {
10426 if (jj_3R_154()) return true;
10427 return false;
10428 }
10429
10430 private boolean jj_3R_427() {
10431 Token xsp;
10432 while (true) {
10433 xsp = jj_scanpos;
10434 if (jj_3R_433()) { jj_scanpos = xsp; break; }
10435 }
10436 if (jj_3R_136()) return true;
10437 while (true) {
10438 xsp = jj_scanpos;
10439 if (jj_3R_434()) { jj_scanpos = xsp; break; }
10440 }
10441 return false;
10442 }
10443
10444 private boolean jj_3_20() {
10445 if (jj_3R_97()) return true;
10446 return false;
10447 }
10448
10449 private boolean jj_3_22() {
10450 if (jj_scan_token(DOT)) return true;
10451 if (jj_scan_token(IDENTIFIER)) return true;
10452 return false;
10453 }
10454
10455 private boolean jj_3R_276() {
10456 if (jj_scan_token(COMMA)) return true;
10457 if (jj_3R_99()) return true;
10458 return false;
10459 }
10460
10461 private boolean jj_3R_136() {
10462 if (jj_scan_token(IDENTIFIER)) return true;
10463 Token xsp;
10464 while (true) {
10465 xsp = jj_scanpos;
10466 if (jj_3_22()) { jj_scanpos = xsp; break; }
10467 }
10468 return false;
10469 }
10470
10471 private boolean jj_3R_211() {
10472 if (jj_3R_90()) return true;
10473 return false;
10474 }
10475
10476 private boolean jj_3R_135() {
10477 Token xsp;
10478 xsp = jj_scanpos;
10479 if (jj_scan_token(59)) {
10480 jj_scanpos = xsp;
10481 if (jj_3R_211()) return true;
10482 }
10483 return false;
10484 }
10485
10486 private boolean jj_3R_224() {
10487 if (jj_scan_token(DOUBLE)) return true;
10488 return false;
10489 }
10490
10491 private boolean jj_3R_223() {
10492 if (jj_scan_token(FLOAT)) return true;
10493 return false;
10494 }
10495
10496 private boolean jj_3R_222() {
10497 if (jj_scan_token(LONG)) return true;
10498 return false;
10499 }
10500
10501 private boolean jj_3R_367() {
10502 if (jj_3R_154()) return true;
10503 return false;
10504 }
10505
10506 private boolean jj_3R_366() {
10507 if (jj_3R_154()) return true;
10508 return false;
10509 }
10510
10511 private boolean jj_3R_221() {
10512 if (jj_scan_token(INT)) return true;
10513 return false;
10514 }
10515
10516 private boolean jj_3R_220() {
10517 if (jj_scan_token(SHORT)) return true;
10518 return false;
10519 }
10520
10521 private boolean jj_3R_219() {
10522 if (jj_scan_token(BYTE)) return true;
10523 return false;
10524 }
10525
10526 private boolean jj_3R_218() {
10527 if (jj_scan_token(CHAR)) return true;
10528 return false;
10529 }
10530
10531 private boolean jj_3R_142() {
10532 Token xsp;
10533 xsp = jj_scanpos;
10534 if (jj_3R_217()) {
10535 jj_scanpos = xsp;
10536 if (jj_3R_218()) {
10537 jj_scanpos = xsp;
10538 if (jj_3R_219()) {
10539 jj_scanpos = xsp;
10540 if (jj_3R_220()) {
10541 jj_scanpos = xsp;
10542 if (jj_3R_221()) {
10543 jj_scanpos = xsp;
10544 if (jj_3R_222()) {
10545 jj_scanpos = xsp;
10546 if (jj_3R_223()) {
10547 jj_scanpos = xsp;
10548 if (jj_3R_224()) return true;
10549 }
10550 }
10551 }
10552 }
10553 }
10554 }
10555 }
10556 return false;
10557 }
10558
10559 private boolean jj_3R_217() {
10560 if (jj_scan_token(BOOLEAN)) return true;
10561 return false;
10562 }
10563
10564
10565 public JavaParserTokenManager token_source;
10566
10567 public Token token;
10568
10569 public Token jj_nt;
10570 private Token jj_scanpos, jj_lastpos;
10571 private int jj_la;
10572
10573 private boolean jj_lookingAhead = false;
10574 private boolean jj_semLA;
10575 private int jj_gen;
10576 final private int[] jj_la1 = new int[151];
10577 static private int[] jj_la1_0;
10578 static private int[] jj_la1_1;
10579 static private int[] jj_la1_2;
10580 static private int[] jj_la1_3;
10581 static {
10582 jj_la1_init_0();
10583 jj_la1_init_1();
10584 jj_la1_init_2();
10585 jj_la1_init_3();
10586 }
10587 private static void jj_la1_init_0() {
10588 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,};
10589 }
10590 private static void jj_la1_init_1() {
10591 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,};
10592 }
10593 private static void jj_la1_init_2() {
10594 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,};
10595 }
10596 private static void jj_la1_init_3() {
10597 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,};
10598 }
10599 final private JJCalls[] jj_2_rtns = new JJCalls[76];
10600 private boolean jj_rescan = false;
10601 private int jj_gc = 0;
10602
10603
10604 public JavaParser(CharStream stream) {
10605 token_source = new JavaParserTokenManager(stream);
10606 token = new Token();
10607 token.next = jj_nt = token_source.getNextToken();
10608 jj_gen = 0;
10609 for (int i = 0; i < 151; i++) jj_la1[i] = -1;
10610 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
10611 }
10612
10613
10614 public void ReInit(CharStream stream) {
10615 token_source.ReInit(stream);
10616 token = new Token();
10617 token.next = jj_nt = token_source.getNextToken();
10618 jj_lookingAhead = false;
10619 jjtree.reset();
10620 jj_gen = 0;
10621 for (int i = 0; i < 151; i++) jj_la1[i] = -1;
10622 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
10623 }
10624
10625
10626 public JavaParser(JavaParserTokenManager tm) {
10627 token_source = tm;
10628 token = new Token();
10629 token.next = jj_nt = token_source.getNextToken();
10630 jj_gen = 0;
10631 for (int i = 0; i < 151; i++) jj_la1[i] = -1;
10632 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
10633 }
10634
10635
10636 public void ReInit(JavaParserTokenManager tm) {
10637 token_source = tm;
10638 token = new Token();
10639 token.next = jj_nt = token_source.getNextToken();
10640 jjtree.reset();
10641 jj_gen = 0;
10642 for (int i = 0; i < 151; i++) jj_la1[i] = -1;
10643 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
10644 }
10645
10646 private Token jj_consume_token(int kind) throws ParseException {
10647 Token oldToken = token;
10648 if ((token = jj_nt).next != null) jj_nt = jj_nt.next;
10649 else jj_nt = jj_nt.next = token_source.getNextToken();
10650 if (token.kind == kind) {
10651 jj_gen++;
10652 if (++jj_gc > 100) {
10653 jj_gc = 0;
10654 for (int i = 0; i < jj_2_rtns.length; i++) {
10655 JJCalls c = jj_2_rtns[i];
10656 while (c != null) {
10657 if (c.gen < jj_gen) c.first = null;
10658 c = c.next;
10659 }
10660 }
10661 }
10662 return token;
10663 }
10664 jj_nt = token;
10665 token = oldToken;
10666 jj_kind = kind;
10667 throw generateParseException();
10668 }
10669
10670 static private final class LookaheadSuccess extends java.lang.Error { }
10671 final private LookaheadSuccess jj_ls = new LookaheadSuccess();
10672 private boolean jj_scan_token(int kind) {
10673 if (jj_scanpos == jj_lastpos) {
10674 jj_la--;
10675 if (jj_scanpos.next == null) {
10676 jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
10677 } else {
10678 jj_lastpos = jj_scanpos = jj_scanpos.next;
10679 }
10680 } else {
10681 jj_scanpos = jj_scanpos.next;
10682 }
10683 if (jj_rescan) {
10684 int i = 0; Token tok = token;
10685 while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; }
10686 if (tok != null) jj_add_error_token(kind, i);
10687 }
10688 if (jj_scanpos.kind != kind) return true;
10689 if (jj_la == 0 && jj_scanpos == jj_lastpos) throw jj_ls;
10690 return false;
10691 }
10692
10693
10694
10695 final public Token getNextToken() {
10696 if ((token = jj_nt).next != null) jj_nt = jj_nt.next;
10697 else jj_nt = jj_nt.next = token_source.getNextToken();
10698 jj_gen++;
10699 return token;
10700 }
10701
10702
10703 final public Token getToken(int index) {
10704 Token t = jj_lookingAhead ? jj_scanpos : token;
10705 for (int i = 0; i < index; i++) {
10706 if (t.next != null) t = t.next;
10707 else t = t.next = token_source.getNextToken();
10708 }
10709 return t;
10710 }
10711
10712 private java.util.List<int[]> jj_expentries = new java.util.ArrayList<int[]>();
10713 private int[] jj_expentry;
10714 private int jj_kind = -1;
10715 private int[] jj_lasttokens = new int[100];
10716 private int jj_endpos;
10717
10718 private void jj_add_error_token(int kind, int pos) {
10719 if (pos >= 100) return;
10720 if (pos == jj_endpos + 1) {
10721 jj_lasttokens[jj_endpos++] = kind;
10722 } else if (jj_endpos != 0) {
10723 jj_expentry = new int[jj_endpos];
10724 for (int i = 0; i < jj_endpos; i++) {
10725 jj_expentry[i] = jj_lasttokens[i];
10726 }
10727 jj_entries_loop: for (java.util.Iterator<?> it = jj_expentries.iterator(); it.hasNext();) {
10728 int[] oldentry = (int[])(it.next());
10729 if (oldentry.length == jj_expentry.length) {
10730 for (int i = 0; i < jj_expentry.length; i++) {
10731 if (oldentry[i] != jj_expentry[i]) {
10732 continue jj_entries_loop;
10733 }
10734 }
10735 jj_expentries.add(jj_expentry);
10736 break jj_entries_loop;
10737 }
10738 }
10739 if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind;
10740 }
10741 }
10742
10743
10744 public ParseException generateParseException() {
10745 jj_expentries.clear();
10746 boolean[] la1tokens = new boolean[128];
10747 if (jj_kind >= 0) {
10748 la1tokens[jj_kind] = true;
10749 jj_kind = -1;
10750 }
10751 for (int i = 0; i < 151; i++) {
10752 if (jj_la1[i] == jj_gen) {
10753 for (int j = 0; j < 32; j++) {
10754 if ((jj_la1_0[i] & (1<<j)) != 0) {
10755 la1tokens[j] = true;
10756 }
10757 if ((jj_la1_1[i] & (1<<j)) != 0) {
10758 la1tokens[32+j] = true;
10759 }
10760 if ((jj_la1_2[i] & (1<<j)) != 0) {
10761 la1tokens[64+j] = true;
10762 }
10763 if ((jj_la1_3[i] & (1<<j)) != 0) {
10764 la1tokens[96+j] = true;
10765 }
10766 }
10767 }
10768 }
10769 for (int i = 0; i < 128; i++) {
10770 if (la1tokens[i]) {
10771 jj_expentry = new int[1];
10772 jj_expentry[0] = i;
10773 jj_expentries.add(jj_expentry);
10774 }
10775 }
10776 jj_endpos = 0;
10777 jj_rescan_token();
10778 jj_add_error_token(0, 0);
10779 int[][] exptokseq = new int[jj_expentries.size()][];
10780 for (int i = 0; i < jj_expentries.size(); i++) {
10781 exptokseq[i] = jj_expentries.get(i);
10782 }
10783 return new ParseException(token, exptokseq, tokenImage);
10784 }
10785
10786
10787 final public void enable_tracing() {
10788 }
10789
10790
10791 final public void disable_tracing() {
10792 }
10793
10794 private void jj_rescan_token() {
10795 jj_rescan = true;
10796 for (int i = 0; i < 76; i++) {
10797 try {
10798 JJCalls p = jj_2_rtns[i];
10799 do {
10800 if (p.gen > jj_gen) {
10801 jj_la = p.arg; jj_lastpos = jj_scanpos = p.first;
10802 switch (i) {
10803 case 0: jj_3_1(); break;
10804 case 1: jj_3_2(); break;
10805 case 2: jj_3_3(); break;
10806 case 3: jj_3_4(); break;
10807 case 4: jj_3_5(); break;
10808 case 5: jj_3_6(); break;
10809 case 6: jj_3_7(); break;
10810 case 7: jj_3_8(); break;
10811 case 8: jj_3_9(); break;
10812 case 9: jj_3_10(); break;
10813 case 10: jj_3_11(); break;
10814 case 11: jj_3_12(); break;
10815 case 12: jj_3_13(); break;
10816 case 13: jj_3_14(); break;
10817 case 14: jj_3_15(); break;
10818 case 15: jj_3_16(); break;
10819 case 16: jj_3_17(); break;
10820 case 17: jj_3_18(); break;
10821 case 18: jj_3_19(); break;
10822 case 19: jj_3_20(); break;
10823 case 20: jj_3_21(); break;
10824 case 21: jj_3_22(); break;
10825 case 22: jj_3_23(); break;
10826 case 23: jj_3_24(); break;
10827 case 24: jj_3_25(); break;
10828 case 25: jj_3_26(); break;
10829 case 26: jj_3_27(); break;
10830 case 27: jj_3_28(); break;
10831 case 28: jj_3_29(); break;
10832 case 29: jj_3_30(); break;
10833 case 30: jj_3_31(); break;
10834 case 31: jj_3_32(); break;
10835 case 32: jj_3_33(); break;
10836 case 33: jj_3_34(); break;
10837 case 34: jj_3_35(); break;
10838 case 35: jj_3_36(); break;
10839 case 36: jj_3_37(); break;
10840 case 37: jj_3_38(); break;
10841 case 38: jj_3_39(); break;
10842 case 39: jj_3_40(); break;
10843 case 40: jj_3_41(); break;
10844 case 41: jj_3_42(); break;
10845 case 42: jj_3_43(); break;
10846 case 43: jj_3_44(); break;
10847 case 44: jj_3_45(); break;
10848 case 45: jj_3_46(); break;
10849 case 46: jj_3_47(); break;
10850 case 47: jj_3_48(); break;
10851 case 48: jj_3_49(); break;
10852 case 49: jj_3_50(); break;
10853 case 50: jj_3_51(); break;
10854 case 51: jj_3_52(); break;
10855 case 52: jj_3_53(); break;
10856 case 53: jj_3_54(); break;
10857 case 54: jj_3_55(); break;
10858 case 55: jj_3_56(); break;
10859 case 56: jj_3_57(); break;
10860 case 57: jj_3_58(); break;
10861 case 58: jj_3_59(); break;
10862 case 59: jj_3_60(); break;
10863 case 60: jj_3_61(); break;
10864 case 61: jj_3_62(); break;
10865 case 62: jj_3_63(); break;
10866 case 63: jj_3_64(); break;
10867 case 64: jj_3_65(); break;
10868 case 65: jj_3_66(); break;
10869 case 66: jj_3_67(); break;
10870 case 67: jj_3_68(); break;
10871 case 68: jj_3_69(); break;
10872 case 69: jj_3_70(); break;
10873 case 70: jj_3_71(); break;
10874 case 71: jj_3_72(); break;
10875 case 72: jj_3_73(); break;
10876 case 73: jj_3_74(); break;
10877 case 74: jj_3_75(); break;
10878 case 75: jj_3_76(); break;
10879 }
10880 }
10881 p = p.next;
10882 } while (p != null);
10883 } catch(LookaheadSuccess ls) { }
10884 }
10885 jj_rescan = false;
10886 }
10887
10888 private void jj_save(int index, int xla) {
10889 JJCalls p = jj_2_rtns[index];
10890 while (p.gen > jj_gen) {
10891 if (p.next == null) { p = p.next = new JJCalls(); break; }
10892 p = p.next;
10893 }
10894 p.gen = jj_gen + xla - jj_la; p.first = token; p.arg = xla;
10895 }
10896
10897 static final class JJCalls {
10898 int gen;
10899 Token first;
10900 int arg;
10901 JJCalls next;
10902 }
10903
10904 }