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