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