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