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