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