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