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