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