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