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