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