1
2 package net.sourceforge.pmd.ast;
3 import java.util.*;
4 import net.sourceforge.pmd.PMD;
5 public class JavaParser
6 protected JJTJavaParserState jjtree = new JJTJavaParserState();
7 private boolean isJDK13;
8 private boolean isJDK15;
9
10 public void setJDK13() {
11 this.isJDK13 = true;
12 }
13
14 public void setJDK15() {
15 this.isJDK15 = true;
16 }
17
18 private void checkForBadAssertUsage(String in, String usage) {
19 if (!isJDK13 && in.equals("assert")) {
20 throw new ParseException("Can't use 'assert' as " + usage + " when running in JDK 1.4 mode!");
21 }
22 }
23
24 private void checkForBadStaticImportUsage() {
25 if (!isJDK15) {
26 throw new ParseException("Can't use static imports when running in JDK 1.4 mode!");
27 }
28 }
29
30 private void checkForBadAnnotationUsage() {
31 if (!isJDK15) {
32 throw new ParseException("Can't use annotations when running in JDK 1.4 mode!");
33 }
34 }
35
36 private void checkForBadGenericsUsage() {
37 if (!isJDK15) {
38 throw new ParseException("Can't use generics unless running in JDK 1.5 mode!");
39 }
40 }
41
42 private void checkForBadVariableArgumentsUsage() {
43 if (!isJDK15) {
44 throw new ParseException("Can't use variable arguments (varargs) when running in JDK 1.4 mode!");
45 }
46 }
47
48 private void checkForBadJDK15ForLoopSyntaxArgumentsUsage() {
49 if (!isJDK15) {
50 throw new ParseException("Can't use JDK 1.5 for loop syntax when running in JDK 1.4 mode!");
51 }
52 }
53
54 private void checkForBadEnumUsage(String in, String usage) {
55 if (isJDK15 && in.equals("enum")) {
56 throw new ParseException("Can't use 'enum' as " + usage + " when running in JDK 1.5 mode!");
57 }
58 }
59
60 private void checkForBadHexFloatingPointLiteral() {
61 if (!isJDK15) {
62 throw new ParseException("ERROR: Can't use hexadecimal floating point literals in pre-JDK 1.5 target");
63 }
64 }
65
66
67
68
69 private boolean isNextTokenAnAssert() {
70 boolean res = getToken(1).image.equals("assert");
71 if (res && isJDK13 && getToken(2).image.equals("(")) {
72 res = false;
73 }
74 return res;
75 }
76
77 private boolean isPrecededByComment(Token tok) {
78 boolean res = false;
79 while (!res && tok.specialToken != null) {
80 tok = tok.specialToken;
81 res = tok.kind == SINGLE_LINE_COMMENT ||
82 tok.kind == FORMAL_COMMENT ||
83 tok.kind == MULTI_LINE_COMMENT;
84 }
85 return res;
86 }
87
88 public Map<Integer, String> getExcludeMap() {
89 return token_source.getExcludeMap();
90 }
91
92 public void setExcludeMarker(String marker) {
93 token_source.setExcludeMarker(marker);
94 }
95
96 /*****************************************
97 * THE JAVA LANGUAGE GRAMMAR STARTS HERE *
98 *****************************************/
99
100
101
102
103 final public ASTCompilationUnit CompilationUnit() throws ParseException {
104
105 ASTCompilationUnit jjtn000 = new ASTCompilationUnit(this, JJTCOMPILATIONUNIT);
106 boolean jjtc000 = true;
107 jjtree.openNodeScope(jjtn000);
108 try {
109 if (jj_2_1(2147483647)) {
110 PackageDeclaration();
111 } else {
112 ;
113 }
114 label_1:
115 while (true) {
116 switch (jj_nt.kind) {
117 case IMPORT:
118 ;
119 break;
120 default:
121 jj_la1[0] = jj_gen;
122 break label_1;
123 }
124 ImportDeclaration();
125 }
126 label_2:
127 while (true) {
128 switch (jj_nt.kind) {
129 case ABSTRACT:
130 case CLASS:
131 case FINAL:
132 case INTERFACE:
133 case NATIVE:
134 case PRIVATE:
135 case PROTECTED:
136 case PUBLIC:
137 case STATIC:
138 case SYNCHRONIZED:
139 case TRANSIENT:
140 case VOLATILE:
141 case STRICTFP:
142 case IDENTIFIER:
143 case SEMICOLON:
144 case AT:
145 ;
146 break;
147 default:
148 jj_la1[1] = jj_gen;
149 break label_2;
150 }
151 TypeDeclaration();
152 }
153 switch (jj_nt.kind) {
154 case 123:
155 jj_consume_token(123);
156 break;
157 default:
158 jj_la1[2] = jj_gen;
159 ;
160 }
161 switch (jj_nt.kind) {
162 case 124:
163 jj_consume_token(124);
164 break;
165 default:
166 jj_la1[3] = jj_gen;
167 ;
168 }
169 jj_consume_token(0);
170 jjtree.closeNodeScope(jjtn000, true);
171 jjtc000 = false;
172 jjtn000.setComments(token_source.comments);
173 {if (true) return jjtn000;}
174 } catch (Throwable jjte000) {
175 if (jjtc000) {
176 jjtree.clearNodeScope(jjtn000);
177 jjtc000 = false;
178 } else {
179 jjtree.popNode();
180 }
181 if (jjte000 instanceof RuntimeException) {
182 {if (true) throw (RuntimeException)jjte000;}
183 }
184 if (jjte000 instanceof ParseException) {
185 {if (true) throw (ParseException)jjte000;}
186 }
187 {if (true) throw (Error)jjte000;}
188 } finally {
189 if (jjtc000) {
190 jjtree.closeNodeScope(jjtn000, true);
191 }
192 }
193 throw new RuntimeException("Missing return statement in function");
194 }
195
196 final public void PackageDeclaration() throws ParseException {
197
198 ASTPackageDeclaration jjtn000 = new ASTPackageDeclaration(this, JJTPACKAGEDECLARATION);
199 boolean jjtc000 = true;
200 jjtree.openNodeScope(jjtn000);
201 try {
202 label_3:
203 while (true) {
204 switch (jj_nt.kind) {
205 case AT:
206 ;
207 break;
208 default:
209 jj_la1[4] = jj_gen;
210 break label_3;
211 }
212 Annotation();
213 }
214 jj_consume_token(PACKAGE);
215 Name();
216 jj_consume_token(SEMICOLON);
217 } catch (Throwable jjte000) {
218 if (jjtc000) {
219 jjtree.clearNodeScope(jjtn000);
220 jjtc000 = false;
221 } else {
222 jjtree.popNode();
223 }
224 if (jjte000 instanceof RuntimeException) {
225 {if (true) throw (RuntimeException)jjte000;}
226 }
227 if (jjte000 instanceof ParseException) {
228 {if (true) throw (ParseException)jjte000;}
229 }
230 {if (true) throw (Error)jjte000;}
231 } finally {
232 if (jjtc000) {
233 jjtree.closeNodeScope(jjtn000, true);
234 }
235 }
236 }
237
238 final public void ImportDeclaration() throws ParseException {
239
240 ASTImportDeclaration jjtn000 = new ASTImportDeclaration(this, JJTIMPORTDECLARATION);
241 boolean jjtc000 = true;
242 jjtree.openNodeScope(jjtn000);
243 try {
244 jj_consume_token(IMPORT);
245 switch (jj_nt.kind) {
246 case STATIC:
247 jj_consume_token(STATIC);
248 checkForBadStaticImportUsage();jjtn000.setStatic();
249 break;
250 default:
251 jj_la1[5] = jj_gen;
252 ;
253 }
254 Name();
255 switch (jj_nt.kind) {
256 case DOT:
257 jj_consume_token(DOT);
258 jj_consume_token(STAR);
259 jjtn000.setImportOnDemand();
260 break;
261 default:
262 jj_la1[6] = jj_gen;
263 ;
264 }
265 jj_consume_token(SEMICOLON);
266 } catch (Throwable jjte000) {
267 if (jjtc000) {
268 jjtree.clearNodeScope(jjtn000);
269 jjtc000 = false;
270 } else {
271 jjtree.popNode();
272 }
273 if (jjte000 instanceof RuntimeException) {
274 {if (true) throw (RuntimeException)jjte000;}
275 }
276 if (jjte000 instanceof ParseException) {
277 {if (true) throw (ParseException)jjte000;}
278 }
279 {if (true) throw (Error)jjte000;}
280 } finally {
281 if (jjtc000) {
282 jjtree.closeNodeScope(jjtn000, true);
283 }
284 }
285 }
286
287
288
289
290
291
292 final public int Modifiers() throws ParseException {
293 int modifiers = 0;
294 label_4:
295 while (true) {
296 if (jj_2_2(2)) {
297 ;
298 } else {
299 break label_4;
300 }
301 switch (jj_nt.kind) {
302 case PUBLIC:
303 jj_consume_token(PUBLIC);
304 modifiers |= AccessNode.PUBLIC;
305 break;
306 case STATIC:
307 jj_consume_token(STATIC);
308 modifiers |= AccessNode.STATIC;
309 break;
310 case PROTECTED:
311 jj_consume_token(PROTECTED);
312 modifiers |= AccessNode.PROTECTED;
313 break;
314 case PRIVATE:
315 jj_consume_token(PRIVATE);
316 modifiers |= AccessNode.PRIVATE;
317 break;
318 case FINAL:
319 jj_consume_token(FINAL);
320 modifiers |= AccessNode.FINAL;
321 break;
322 case ABSTRACT:
323 jj_consume_token(ABSTRACT);
324 modifiers |= AccessNode.ABSTRACT;
325 break;
326 case SYNCHRONIZED:
327 jj_consume_token(SYNCHRONIZED);
328 modifiers |= AccessNode.SYNCHRONIZED;
329 break;
330 case NATIVE:
331 jj_consume_token(NATIVE);
332 modifiers |= AccessNode.NATIVE;
333 break;
334 case TRANSIENT:
335 jj_consume_token(TRANSIENT);
336 modifiers |= AccessNode.TRANSIENT;
337 break;
338 case VOLATILE:
339 jj_consume_token(VOLATILE);
340 modifiers |= AccessNode.VOLATILE;
341 break;
342 case STRICTFP:
343 jj_consume_token(STRICTFP);
344 modifiers |= AccessNode.STRICTFP;
345 break;
346 case AT:
347 Annotation();
348 break;
349 default:
350 jj_la1[7] = jj_gen;
351 jj_consume_token(-1);
352 throw new ParseException();
353 }
354 }
355 {if (true) return modifiers;}
356 throw new RuntimeException("Missing return statement in function");
357 }
358
359
360
361
362 final public void TypeDeclaration() throws ParseException {
363
364 ASTTypeDeclaration jjtn000 = new ASTTypeDeclaration(this, JJTTYPEDECLARATION);
365 boolean jjtc000 = true;
366 jjtree.openNodeScope(jjtn000);int modifiers;
367 try {
368 switch (jj_nt.kind) {
369 case SEMICOLON:
370 jj_consume_token(SEMICOLON);
371 break;
372 case ABSTRACT:
373 case CLASS:
374 case FINAL:
375 case INTERFACE:
376 case NATIVE:
377 case PRIVATE:
378 case PROTECTED:
379 case PUBLIC:
380 case STATIC:
381 case SYNCHRONIZED:
382 case TRANSIENT:
383 case VOLATILE:
384 case STRICTFP:
385 case IDENTIFIER:
386 case AT:
387 modifiers = Modifiers();
388 switch (jj_nt.kind) {
389 case ABSTRACT:
390 case CLASS:
391 case FINAL:
392 case INTERFACE:
393 ClassOrInterfaceDeclaration(modifiers);
394 break;
395 case IDENTIFIER:
396 EnumDeclaration(modifiers);
397 break;
398 case AT:
399 AnnotationTypeDeclaration(modifiers);
400 break;
401 default:
402 jj_la1[8] = jj_gen;
403 jj_consume_token(-1);
404 throw new ParseException();
405 }
406 break;
407 default:
408 jj_la1[9] = jj_gen;
409 jj_consume_token(-1);
410 throw new ParseException();
411 }
412 } catch (Throwable jjte000) {
413 if (jjtc000) {
414 jjtree.clearNodeScope(jjtn000);
415 jjtc000 = false;
416 } else {
417 jjtree.popNode();
418 }
419 if (jjte000 instanceof RuntimeException) {
420 {if (true) throw (RuntimeException)jjte000;}
421 }
422 if (jjte000 instanceof ParseException) {
423 {if (true) throw (ParseException)jjte000;}
424 }
425 {if (true) throw (Error)jjte000;}
426 } finally {
427 if (jjtc000) {
428 jjtree.closeNodeScope(jjtn000, true);
429 }
430 }
431 }
432
433 final public void ClassOrInterfaceDeclaration(int modifiers) throws ParseException {
434
435 ASTClassOrInterfaceDeclaration jjtn000 = new ASTClassOrInterfaceDeclaration(this, JJTCLASSORINTERFACEDECLARATION);
436 boolean jjtc000 = true;
437 jjtree.openNodeScope(jjtn000);Token t = null;
438 jjtn000.setModifiers(modifiers);
439 try {
440 switch (jj_nt.kind) {
441 case ABSTRACT:
442 case CLASS:
443 case FINAL:
444 switch (jj_nt.kind) {
445 case ABSTRACT:
446 case FINAL:
447 switch (jj_nt.kind) {
448 case FINAL:
449 jj_consume_token(FINAL);
450 break;
451 case ABSTRACT:
452 jj_consume_token(ABSTRACT);
453 break;
454 default:
455 jj_la1[10] = jj_gen;
456 jj_consume_token(-1);
457 throw new ParseException();
458 }
459 break;
460 default:
461 jj_la1[11] = jj_gen;
462 ;
463 }
464 jj_consume_token(CLASS);
465 break;
466 case INTERFACE:
467 jj_consume_token(INTERFACE);
468 jjtn000.setInterface();
469 break;
470 default:
471 jj_la1[12] = jj_gen;
472 jj_consume_token(-1);
473 throw new ParseException();
474 }
475 t = jj_consume_token(IDENTIFIER);
476 jjtn000.setImage(t.image);
477 switch (jj_nt.kind) {
478 case LT:
479 TypeParameters();
480 break;
481 default:
482 jj_la1[13] = jj_gen;
483 ;
484 }
485 switch (jj_nt.kind) {
486 case EXTENDS:
487 ExtendsList();
488 break;
489 default:
490 jj_la1[14] = jj_gen;
491 ;
492 }
493 switch (jj_nt.kind) {
494 case IMPLEMENTS:
495 ImplementsList();
496 break;
497 default:
498 jj_la1[15] = jj_gen;
499 ;
500 }
501 ClassOrInterfaceBody();
502 } catch (Throwable jjte000) {
503 if (jjtc000) {
504 jjtree.clearNodeScope(jjtn000);
505 jjtc000 = false;
506 } else {
507 jjtree.popNode();
508 }
509 if (jjte000 instanceof RuntimeException) {
510 {if (true) throw (RuntimeException)jjte000;}
511 }
512 if (jjte000 instanceof ParseException) {
513 {if (true) throw (ParseException)jjte000;}
514 }
515 {if (true) throw (Error)jjte000;}
516 } finally {
517 if (jjtc000) {
518 jjtree.closeNodeScope(jjtn000, true);
519 }
520 }
521 }
522
523 final public void ExtendsList() throws ParseException {
524
525 ASTExtendsList jjtn000 = new ASTExtendsList(this, JJTEXTENDSLIST);
526 boolean jjtc000 = true;
527 jjtree.openNodeScope(jjtn000);boolean extendsMoreThanOne = false;
528 try {
529 jj_consume_token(EXTENDS);
530 ClassOrInterfaceType();
531 label_5:
532 while (true) {
533 switch (jj_nt.kind) {
534 case COMMA:
535 ;
536 break;
537 default:
538 jj_la1[16] = jj_gen;
539 break label_5;
540 }
541 jj_consume_token(COMMA);
542 ClassOrInterfaceType();
543 extendsMoreThanOne = true;
544 }
545 } catch (Throwable jjte000) {
546 if (jjtc000) {
547 jjtree.clearNodeScope(jjtn000);
548 jjtc000 = false;
549 } else {
550 jjtree.popNode();
551 }
552 if (jjte000 instanceof RuntimeException) {
553 {if (true) throw (RuntimeException)jjte000;}
554 }
555 if (jjte000 instanceof ParseException) {
556 {if (true) throw (ParseException)jjte000;}
557 }
558 {if (true) throw (Error)jjte000;}
559 } finally {
560 if (jjtc000) {
561 jjtree.closeNodeScope(jjtn000, true);
562 }
563 }
564 }
565
566 final public void ImplementsList() throws ParseException {
567
568 ASTImplementsList jjtn000 = new ASTImplementsList(this, JJTIMPLEMENTSLIST);
569 boolean jjtc000 = true;
570 jjtree.openNodeScope(jjtn000);
571 try {
572 jj_consume_token(IMPLEMENTS);
573 ClassOrInterfaceType();
574 label_6:
575 while (true) {
576 switch (jj_nt.kind) {
577 case COMMA:
578 ;
579 break;
580 default:
581 jj_la1[17] = jj_gen;
582 break label_6;
583 }
584 jj_consume_token(COMMA);
585 ClassOrInterfaceType();
586 }
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 }
605 }
606 }
607
608 final public void EnumDeclaration(int modifiers) throws ParseException {
609
610 ASTEnumDeclaration jjtn000 = new ASTEnumDeclaration(this, JJTENUMDECLARATION);
611 boolean jjtc000 = true;
612 jjtree.openNodeScope(jjtn000);Token t;
613 jjtn000.setModifiers(modifiers);
614 try {
615 t = jj_consume_token(IDENTIFIER);
616 if (!t.image.equals("enum")) {
617 {if (true) throw new ParseException("ERROR: expecting enum");}
618 }
619 if (!this.isJDK15) {
620 {if (true) throw new ParseException("ERROR: Can't use enum as a keyword in pre-JDK 1.5 target");}
621 }
622 t = jj_consume_token(IDENTIFIER);
623 jjtn000.setImage(t.image);
624 switch (jj_nt.kind) {
625 case IMPLEMENTS:
626 ImplementsList();
627 break;
628 default:
629 jj_la1[18] = jj_gen;
630 ;
631 }
632 EnumBody();
633 } catch (Throwable jjte000) {
634 if (jjtc000) {
635 jjtree.clearNodeScope(jjtn000);
636 jjtc000 = false;
637 } else {
638 jjtree.popNode();
639 }
640 if (jjte000 instanceof RuntimeException) {
641 {if (true) throw (RuntimeException)jjte000;}
642 }
643 if (jjte000 instanceof ParseException) {
644 {if (true) throw (ParseException)jjte000;}
645 }
646 {if (true) throw (Error)jjte000;}
647 } finally {
648 if (jjtc000) {
649 jjtree.closeNodeScope(jjtn000, true);
650 }
651 }
652 }
653
654 final public void EnumBody() throws ParseException {
655
656 ASTEnumBody jjtn000 = new ASTEnumBody(this, JJTENUMBODY);
657 boolean jjtc000 = true;
658 jjtree.openNodeScope(jjtn000);
659 try {
660 jj_consume_token(LBRACE);
661 switch (jj_nt.kind) {
662 case IDENTIFIER:
663 case AT:
664 label_7:
665 while (true) {
666 switch (jj_nt.kind) {
667 case AT:
668 ;
669 break;
670 default:
671 jj_la1[19] = jj_gen;
672 break label_7;
673 }
674 Annotation();
675 }
676 EnumConstant();
677 label_8:
678 while (true) {
679 if (jj_2_3(2)) {
680 ;
681 } else {
682 break label_8;
683 }
684 jj_consume_token(COMMA);
685 label_9:
686 while (true) {
687 switch (jj_nt.kind) {
688 case AT:
689 ;
690 break;
691 default:
692 jj_la1[20] = jj_gen;
693 break label_9;
694 }
695 Annotation();
696 }
697 EnumConstant();
698 }
699 break;
700 default:
701 jj_la1[21] = jj_gen;
702 ;
703 }
704 switch (jj_nt.kind) {
705 case COMMA:
706 jj_consume_token(COMMA);
707 break;
708 default:
709 jj_la1[22] = jj_gen;
710 ;
711 }
712 switch (jj_nt.kind) {
713 case SEMICOLON:
714 jj_consume_token(SEMICOLON);
715 label_10:
716 while (true) {
717 switch (jj_nt.kind) {
718 case ABSTRACT:
719 case BOOLEAN:
720 case BYTE:
721 case CHAR:
722 case CLASS:
723 case DOUBLE:
724 case FINAL:
725 case FLOAT:
726 case INT:
727 case INTERFACE:
728 case LONG:
729 case NATIVE:
730 case PRIVATE:
731 case PROTECTED:
732 case PUBLIC:
733 case SHORT:
734 case STATIC:
735 case SYNCHRONIZED:
736 case TRANSIENT:
737 case VOID:
738 case VOLATILE:
739 case STRICTFP:
740 case IDENTIFIER:
741 case LBRACE:
742 case SEMICOLON:
743 case AT:
744 case LT:
745 ;
746 break;
747 default:
748 jj_la1[23] = jj_gen;
749 break label_10;
750 }
751 ClassOrInterfaceBodyDeclaration();
752 }
753 break;
754 default:
755 jj_la1[24] = jj_gen;
756 ;
757 }
758 jj_consume_token(RBRACE);
759 } catch (Throwable jjte000) {
760 if (jjtc000) {
761 jjtree.clearNodeScope(jjtn000);
762 jjtc000 = false;
763 } else {
764 jjtree.popNode();
765 }
766 if (jjte000 instanceof RuntimeException) {
767 {if (true) throw (RuntimeException)jjte000;}
768 }
769 if (jjte000 instanceof ParseException) {
770 {if (true) throw (ParseException)jjte000;}
771 }
772 {if (true) throw (Error)jjte000;}
773 } finally {
774 if (jjtc000) {
775 jjtree.closeNodeScope(jjtn000, true);
776 }
777 }
778 }
779
780 final public void EnumConstant() throws ParseException {
781
782 ASTEnumConstant jjtn000 = new ASTEnumConstant(this, JJTENUMCONSTANT);
783 boolean jjtc000 = true;
784 jjtree.openNodeScope(jjtn000);Token t;
785 try {
786 t = jj_consume_token(IDENTIFIER);
787 jjtn000.setImage(t.image);
788 switch (jj_nt.kind) {
789 case LPAREN:
790 Arguments();
791 break;
792 default:
793 jj_la1[25] = jj_gen;
794 ;
795 }
796 switch (jj_nt.kind) {
797 case LBRACE:
798 ClassOrInterfaceBody();
799 break;
800 default:
801 jj_la1[26] = jj_gen;
802 ;
803 }
804 } catch (Throwable jjte000) {
805 if (jjtc000) {
806 jjtree.clearNodeScope(jjtn000);
807 jjtc000 = false;
808 } else {
809 jjtree.popNode();
810 }
811 if (jjte000 instanceof RuntimeException) {
812 {if (true) throw (RuntimeException)jjte000;}
813 }
814 if (jjte000 instanceof ParseException) {
815 {if (true) throw (ParseException)jjte000;}
816 }
817 {if (true) throw (Error)jjte000;}
818 } finally {
819 if (jjtc000) {
820 jjtree.closeNodeScope(jjtn000, true);
821 }
822 }
823 }
824
825 final public void TypeParameters() throws ParseException {
826
827 ASTTypeParameters jjtn000 = new ASTTypeParameters(this, JJTTYPEPARAMETERS);
828 boolean jjtc000 = true;
829 jjtree.openNodeScope(jjtn000);
830 try {
831 jj_consume_token(LT);
832 checkForBadGenericsUsage();
833 TypeParameter();
834 label_11:
835 while (true) {
836 switch (jj_nt.kind) {
837 case COMMA:
838 ;
839 break;
840 default:
841 jj_la1[27] = jj_gen;
842 break label_11;
843 }
844 jj_consume_token(COMMA);
845 TypeParameter();
846 }
847 jj_consume_token(GT);
848 } catch (Throwable jjte000) {
849 if (jjtc000) {
850 jjtree.clearNodeScope(jjtn000);
851 jjtc000 = false;
852 } else {
853 jjtree.popNode();
854 }
855 if (jjte000 instanceof RuntimeException) {
856 {if (true) throw (RuntimeException)jjte000;}
857 }
858 if (jjte000 instanceof ParseException) {
859 {if (true) throw (ParseException)jjte000;}
860 }
861 {if (true) throw (Error)jjte000;}
862 } finally {
863 if (jjtc000) {
864 jjtree.closeNodeScope(jjtn000, true);
865 }
866 }
867 }
868
869 final public void TypeParameter() throws ParseException {
870
871 ASTTypeParameter jjtn000 = new ASTTypeParameter(this, JJTTYPEPARAMETER);
872 boolean jjtc000 = true;
873 jjtree.openNodeScope(jjtn000);
874 try {
875 jj_consume_token(IDENTIFIER);
876 switch (jj_nt.kind) {
877 case EXTENDS:
878 TypeBound();
879 break;
880 default:
881 jj_la1[28] = jj_gen;
882 ;
883 }
884 } catch (Throwable jjte000) {
885 if (jjtc000) {
886 jjtree.clearNodeScope(jjtn000);
887 jjtc000 = false;
888 } else {
889 jjtree.popNode();
890 }
891 if (jjte000 instanceof RuntimeException) {
892 {if (true) throw (RuntimeException)jjte000;}
893 }
894 if (jjte000 instanceof ParseException) {
895 {if (true) throw (ParseException)jjte000;}
896 }
897 {if (true) throw (Error)jjte000;}
898 } finally {
899 if (jjtc000) {
900 jjtree.closeNodeScope(jjtn000, true);
901 }
902 }
903 }
904
905 final public void TypeBound() throws ParseException {
906
907 ASTTypeBound jjtn000 = new ASTTypeBound(this, JJTTYPEBOUND);
908 boolean jjtc000 = true;
909 jjtree.openNodeScope(jjtn000);
910 try {
911 jj_consume_token(EXTENDS);
912 ClassOrInterfaceType();
913 label_12:
914 while (true) {
915 switch (jj_nt.kind) {
916 case BIT_AND:
917 ;
918 break;
919 default:
920 jj_la1[29] = jj_gen;
921 break label_12;
922 }
923 jj_consume_token(BIT_AND);
924 ClassOrInterfaceType();
925 }
926 } catch (Throwable jjte000) {
927 if (jjtc000) {
928 jjtree.clearNodeScope(jjtn000);
929 jjtc000 = false;
930 } else {
931 jjtree.popNode();
932 }
933 if (jjte000 instanceof RuntimeException) {
934 {if (true) throw (RuntimeException)jjte000;}
935 }
936 if (jjte000 instanceof ParseException) {
937 {if (true) throw (ParseException)jjte000;}
938 }
939 {if (true) throw (Error)jjte000;}
940 } finally {
941 if (jjtc000) {
942 jjtree.closeNodeScope(jjtn000, true);
943 }
944 }
945 }
946
947 final public void ClassOrInterfaceBody() throws ParseException {
948
949 ASTClassOrInterfaceBody jjtn000 = new ASTClassOrInterfaceBody(this, JJTCLASSORINTERFACEBODY);
950 boolean jjtc000 = true;
951 jjtree.openNodeScope(jjtn000);
952 try {
953 jj_consume_token(LBRACE);
954 label_13:
955 while (true) {
956 switch (jj_nt.kind) {
957 case ABSTRACT:
958 case BOOLEAN:
959 case BYTE:
960 case CHAR:
961 case CLASS:
962 case DOUBLE:
963 case FINAL:
964 case FLOAT:
965 case INT:
966 case INTERFACE:
967 case LONG:
968 case NATIVE:
969 case PRIVATE:
970 case PROTECTED:
971 case PUBLIC:
972 case SHORT:
973 case STATIC:
974 case SYNCHRONIZED:
975 case TRANSIENT:
976 case VOID:
977 case VOLATILE:
978 case STRICTFP:
979 case IDENTIFIER:
980 case LBRACE:
981 case SEMICOLON:
982 case AT:
983 case LT:
984 ;
985 break;
986 default:
987 jj_la1[30] = jj_gen;
988 break label_13;
989 }
990 ClassOrInterfaceBodyDeclaration();
991 }
992 jj_consume_token(RBRACE);
993 } catch (Throwable jjte000) {
994 if (jjtc000) {
995 jjtree.clearNodeScope(jjtn000);
996 jjtc000 = false;
997 } else {
998 jjtree.popNode();
999 }
1000 if (jjte000 instanceof RuntimeException) {
1001 {if (true) throw (RuntimeException)jjte000;}
1002 }
1003 if (jjte000 instanceof ParseException) {
1004 {if (true) throw (ParseException)jjte000;}
1005 }
1006 {if (true) throw (Error)jjte000;}
1007 } finally {
1008 if (jjtc000) {
1009 jjtree.closeNodeScope(jjtn000, true);
1010 }
1011 }
1012 }
1013
1014 final public void ClassOrInterfaceBodyDeclaration() throws ParseException {
1015
1016 ASTClassOrInterfaceBodyDeclaration jjtn000 = new ASTClassOrInterfaceBodyDeclaration(this, JJTCLASSORINTERFACEBODYDECLARATION);
1017 boolean jjtc000 = true;
1018 jjtree.openNodeScope(jjtn000);int modifiers;
1019 try {
1020 if (jj_2_8(2147483647)) {
1021 Initializer();
1022 } else {
1023 switch (jj_nt.kind) {
1024 case ABSTRACT:
1025 case BOOLEAN:
1026 case BYTE:
1027 case CHAR:
1028 case CLASS:
1029 case DOUBLE:
1030 case FINAL:
1031 case FLOAT:
1032 case INT:
1033 case INTERFACE:
1034 case LONG:
1035 case NATIVE:
1036 case PRIVATE:
1037 case PROTECTED:
1038 case PUBLIC:
1039 case SHORT:
1040 case STATIC:
1041 case SYNCHRONIZED:
1042 case TRANSIENT:
1043 case VOID:
1044 case VOLATILE:
1045 case STRICTFP:
1046 case IDENTIFIER:
1047 case AT:
1048 case LT:
1049 modifiers = Modifiers();
1050 if (jj_2_4(3)) {
1051 ClassOrInterfaceDeclaration(modifiers);
1052 } else if (jj_2_5(3)) {
1053 EnumDeclaration(modifiers);
1054 } else if (jj_2_6(2147483647)) {
1055 ConstructorDeclaration(modifiers);
1056 } else if (jj_2_7(2147483647)) {
1057 FieldDeclaration(modifiers);
1058 } else {
1059 switch (jj_nt.kind) {
1060 case BOOLEAN:
1061 case BYTE:
1062 case CHAR:
1063 case DOUBLE:
1064 case FLOAT:
1065 case INT:
1066 case LONG:
1067 case SHORT:
1068 case VOID:
1069 case IDENTIFIER:
1070 case LT:
1071 MethodDeclaration(modifiers);
1072 break;
1073 case AT:
1074 AnnotationTypeDeclaration(modifiers);
1075 break;
1076 default:
1077 jj_la1[31] = jj_gen;
1078 jj_consume_token(-1);
1079 throw new ParseException();
1080 }
1081 }
1082 break;
1083 case SEMICOLON:
1084 jj_consume_token(SEMICOLON);
1085 break;
1086 default:
1087 jj_la1[32] = jj_gen;
1088 jj_consume_token(-1);
1089 throw new ParseException();
1090 }
1091 }
1092 } catch (Throwable jjte000) {
1093 if (jjtc000) {
1094 jjtree.clearNodeScope(jjtn000);
1095 jjtc000 = false;
1096 } else {
1097 jjtree.popNode();
1098 }
1099 if (jjte000 instanceof RuntimeException) {
1100 {if (true) throw (RuntimeException)jjte000;}
1101 }
1102 if (jjte000 instanceof ParseException) {
1103 {if (true) throw (ParseException)jjte000;}
1104 }
1105 {if (true) throw (Error)jjte000;}
1106 } finally {
1107 if (jjtc000) {
1108 jjtree.closeNodeScope(jjtn000, true);
1109 }
1110 }
1111 }
1112
1113 final public void FieldDeclaration(int modifiers) throws ParseException {
1114
1115 ASTFieldDeclaration jjtn000 = new ASTFieldDeclaration(this, JJTFIELDDECLARATION);
1116 boolean jjtc000 = true;
1117 jjtree.openNodeScope(jjtn000);jjtn000.setModifiers(modifiers);
1118 try {
1119 Type();
1120 VariableDeclarator();
1121 label_14:
1122 while (true) {
1123 switch (jj_nt.kind) {
1124 case COMMA:
1125 ;
1126 break;
1127 default:
1128 jj_la1[33] = jj_gen;
1129 break label_14;
1130 }
1131 jj_consume_token(COMMA);
1132 VariableDeclarator();
1133 }
1134 jj_consume_token(SEMICOLON);
1135 } catch (Throwable jjte000) {
1136 if (jjtc000) {
1137 jjtree.clearNodeScope(jjtn000);
1138 jjtc000 = false;
1139 } else {
1140 jjtree.popNode();
1141 }
1142 if (jjte000 instanceof RuntimeException) {
1143 {if (true) throw (RuntimeException)jjte000;}
1144 }
1145 if (jjte000 instanceof ParseException) {
1146 {if (true) throw (ParseException)jjte000;}
1147 }
1148 {if (true) throw (Error)jjte000;}
1149 } finally {
1150 if (jjtc000) {
1151 jjtree.closeNodeScope(jjtn000, true);
1152 }
1153 }
1154 }
1155
1156 final public void VariableDeclarator() throws ParseException {
1157
1158 ASTVariableDeclarator jjtn000 = new ASTVariableDeclarator(this, JJTVARIABLEDECLARATOR);
1159 boolean jjtc000 = true;
1160 jjtree.openNodeScope(jjtn000);
1161 try {
1162 VariableDeclaratorId();
1163 switch (jj_nt.kind) {
1164 case ASSIGN:
1165 jj_consume_token(ASSIGN);
1166 VariableInitializer();
1167 break;
1168 default:
1169 jj_la1[34] = jj_gen;
1170 ;
1171 }
1172 } catch (Throwable jjte000) {
1173 if (jjtc000) {
1174 jjtree.clearNodeScope(jjtn000);
1175 jjtc000 = false;
1176 } else {
1177 jjtree.popNode();
1178 }
1179 if (jjte000 instanceof RuntimeException) {
1180 {if (true) throw (RuntimeException)jjte000;}
1181 }
1182 if (jjte000 instanceof ParseException) {
1183 {if (true) throw (ParseException)jjte000;}
1184 }
1185 {if (true) throw (Error)jjte000;}
1186 } finally {
1187 if (jjtc000) {
1188 jjtree.closeNodeScope(jjtn000, true);
1189 }
1190 }
1191 }
1192
1193 final public void VariableDeclaratorId() throws ParseException {
1194
1195 ASTVariableDeclaratorId jjtn000 = new ASTVariableDeclaratorId(this, JJTVARIABLEDECLARATORID);
1196 boolean jjtc000 = true;
1197 jjtree.openNodeScope(jjtn000);Token t;
1198 try {
1199 t = jj_consume_token(IDENTIFIER);
1200 label_15:
1201 while (true) {
1202 switch (jj_nt.kind) {
1203 case LBRACKET:
1204 ;
1205 break;
1206 default:
1207 jj_la1[35] = jj_gen;
1208 break label_15;
1209 }
1210 jj_consume_token(LBRACKET);
1211 jj_consume_token(RBRACKET);
1212 jjtn000.bumpArrayDepth();
1213 }
1214 jjtree.closeNodeScope(jjtn000, true);
1215 jjtc000 = false;
1216 checkForBadAssertUsage(t.image, "a variable name");
1217 checkForBadEnumUsage(t.image, "a variable name");
1218 jjtn000.setImage( t.image );
1219 } finally {
1220 if (jjtc000) {
1221 jjtree.closeNodeScope(jjtn000, true);
1222 }
1223 }
1224 }
1225
1226 final public void VariableInitializer() throws ParseException {
1227
1228 ASTVariableInitializer jjtn000 = new ASTVariableInitializer(this, JJTVARIABLEINITIALIZER);
1229 boolean jjtc000 = true;
1230 jjtree.openNodeScope(jjtn000);
1231 try {
1232 switch (jj_nt.kind) {
1233 case LBRACE:
1234 ArrayInitializer();
1235 break;
1236 case BOOLEAN:
1237 case BYTE:
1238 case CHAR:
1239 case DOUBLE:
1240 case FALSE:
1241 case FLOAT:
1242 case INT:
1243 case LONG:
1244 case NEW:
1245 case NULL:
1246 case SHORT:
1247 case SUPER:
1248 case THIS:
1249 case TRUE:
1250 case VOID:
1251 case INTEGER_LITERAL:
1252 case FLOATING_POINT_LITERAL:
1253 case HEX_FLOATING_POINT_LITERAL:
1254 case CHARACTER_LITERAL:
1255 case STRING_LITERAL:
1256 case IDENTIFIER:
1257 case LPAREN:
1258 case BANG:
1259 case TILDE:
1260 case INCR:
1261 case DECR:
1262 case PLUS:
1263 case MINUS:
1264 Expression();
1265 break;
1266 default:
1267 jj_la1[36] = jj_gen;
1268 jj_consume_token(-1);
1269 throw new ParseException();
1270 }
1271 } catch (Throwable jjte000) {
1272 if (jjtc000) {
1273 jjtree.clearNodeScope(jjtn000);
1274 jjtc000 = false;
1275 } else {
1276 jjtree.popNode();
1277 }
1278 if (jjte000 instanceof RuntimeException) {
1279 {if (true) throw (RuntimeException)jjte000;}
1280 }
1281 if (jjte000 instanceof ParseException) {
1282 {if (true) throw (ParseException)jjte000;}
1283 }
1284 {if (true) throw (Error)jjte000;}
1285 } finally {
1286 if (jjtc000) {
1287 jjtree.closeNodeScope(jjtn000, true);
1288 }
1289 }
1290 }
1291
1292 final public void ArrayInitializer() throws ParseException {
1293
1294 ASTArrayInitializer jjtn000 = new ASTArrayInitializer(this, JJTARRAYINITIALIZER);
1295 boolean jjtc000 = true;
1296 jjtree.openNodeScope(jjtn000);
1297 try {
1298 jj_consume_token(LBRACE);
1299 switch (jj_nt.kind) {
1300 case BOOLEAN:
1301 case BYTE:
1302 case CHAR:
1303 case DOUBLE:
1304 case FALSE:
1305 case FLOAT:
1306 case INT:
1307 case LONG:
1308 case NEW:
1309 case NULL:
1310 case SHORT:
1311 case SUPER:
1312 case THIS:
1313 case TRUE:
1314 case VOID:
1315 case INTEGER_LITERAL:
1316 case FLOATING_POINT_LITERAL:
1317 case HEX_FLOATING_POINT_LITERAL:
1318 case CHARACTER_LITERAL:
1319 case STRING_LITERAL:
1320 case IDENTIFIER:
1321 case LPAREN:
1322 case LBRACE:
1323 case BANG:
1324 case TILDE:
1325 case INCR:
1326 case DECR:
1327 case PLUS:
1328 case MINUS:
1329 VariableInitializer();
1330 label_16:
1331 while (true) {
1332 if (jj_2_9(2)) {
1333 ;
1334 } else {
1335 break label_16;
1336 }
1337 jj_consume_token(COMMA);
1338 VariableInitializer();
1339 }
1340 break;
1341 default:
1342 jj_la1[37] = jj_gen;
1343 ;
1344 }
1345 switch (jj_nt.kind) {
1346 case COMMA:
1347 jj_consume_token(COMMA);
1348 break;
1349 default:
1350 jj_la1[38] = jj_gen;
1351 ;
1352 }
1353 jj_consume_token(RBRACE);
1354 } catch (Throwable jjte000) {
1355 if (jjtc000) {
1356 jjtree.clearNodeScope(jjtn000);
1357 jjtc000 = false;
1358 } else {
1359 jjtree.popNode();
1360 }
1361 if (jjte000 instanceof RuntimeException) {
1362 {if (true) throw (RuntimeException)jjte000;}
1363 }
1364 if (jjte000 instanceof ParseException) {
1365 {if (true) throw (ParseException)jjte000;}
1366 }
1367 {if (true) throw (Error)jjte000;}
1368 } finally {
1369 if (jjtc000) {
1370 jjtree.closeNodeScope(jjtn000, true);
1371 }
1372 }
1373 }
1374
1375 final public void MethodDeclaration(int modifiers) throws ParseException {
1376
1377 ASTMethodDeclaration jjtn000 = new ASTMethodDeclaration(this, JJTMETHODDECLARATION);
1378 boolean jjtc000 = true;
1379 jjtree.openNodeScope(jjtn000);jjtn000.setModifiers(modifiers);
1380 try {
1381 switch (jj_nt.kind) {
1382 case LT:
1383 TypeParameters();
1384 break;
1385 default:
1386 jj_la1[39] = jj_gen;
1387 ;
1388 }
1389 ResultType();
1390 MethodDeclarator();
1391 switch (jj_nt.kind) {
1392 case THROWS:
1393 jj_consume_token(THROWS);
1394 NameList();
1395 break;
1396 default:
1397 jj_la1[40] = jj_gen;
1398 ;
1399 }
1400 switch (jj_nt.kind) {
1401 case LBRACE:
1402 Block();
1403 break;
1404 case SEMICOLON:
1405 jj_consume_token(SEMICOLON);
1406 break;
1407 default:
1408 jj_la1[41] = jj_gen;
1409 jj_consume_token(-1);
1410 throw new ParseException();
1411 }
1412 } catch (Throwable jjte000) {
1413 if (jjtc000) {
1414 jjtree.clearNodeScope(jjtn000);
1415 jjtc000 = false;
1416 } else {
1417 jjtree.popNode();
1418 }
1419 if (jjte000 instanceof RuntimeException) {
1420 {if (true) throw (RuntimeException)jjte000;}
1421 }
1422 if (jjte000 instanceof ParseException) {
1423 {if (true) throw (ParseException)jjte000;}
1424 }
1425 {if (true) throw (Error)jjte000;}
1426 } finally {
1427 if (jjtc000) {
1428 jjtree.closeNodeScope(jjtn000, true);
1429 }
1430 }
1431 }
1432
1433 final public void MethodDeclarator() throws ParseException {
1434
1435 ASTMethodDeclarator jjtn000 = new ASTMethodDeclarator(this, JJTMETHODDECLARATOR);
1436 boolean jjtc000 = true;
1437 jjtree.openNodeScope(jjtn000);Token t;
1438 try {
1439 t = jj_consume_token(IDENTIFIER);
1440 checkForBadAssertUsage(t.image, "a method name");
1441 checkForBadEnumUsage(t.image, "a method name");
1442 jjtn000.setImage( t.image );
1443 FormalParameters();
1444 label_17:
1445 while (true) {
1446 switch (jj_nt.kind) {
1447 case LBRACKET:
1448 ;
1449 break;
1450 default:
1451 jj_la1[42] = jj_gen;
1452 break label_17;
1453 }
1454 jj_consume_token(LBRACKET);
1455 jj_consume_token(RBRACKET);
1456 }
1457 } catch (Throwable jjte000) {
1458 if (jjtc000) {
1459 jjtree.clearNodeScope(jjtn000);
1460 jjtc000 = false;
1461 } else {
1462 jjtree.popNode();
1463 }
1464 if (jjte000 instanceof RuntimeException) {
1465 {if (true) throw (RuntimeException)jjte000;}
1466 }
1467 if (jjte000 instanceof ParseException) {
1468 {if (true) throw (ParseException)jjte000;}
1469 }
1470 {if (true) throw (Error)jjte000;}
1471 } finally {
1472 if (jjtc000) {
1473 jjtree.closeNodeScope(jjtn000, true);
1474 }
1475 }
1476 }
1477
1478 final public void FormalParameters() throws ParseException {
1479
1480 ASTFormalParameters jjtn000 = new ASTFormalParameters(this, JJTFORMALPARAMETERS);
1481 boolean jjtc000 = true;
1482 jjtree.openNodeScope(jjtn000);
1483 try {
1484 jj_consume_token(LPAREN);
1485 switch (jj_nt.kind) {
1486 case BOOLEAN:
1487 case BYTE:
1488 case CHAR:
1489 case DOUBLE:
1490 case FINAL:
1491 case FLOAT:
1492 case INT:
1493 case LONG:
1494 case SHORT:
1495 case IDENTIFIER:
1496 case AT:
1497 FormalParameter();
1498 label_18:
1499 while (true) {
1500 switch (jj_nt.kind) {
1501 case COMMA:
1502 ;
1503 break;
1504 default:
1505 jj_la1[43] = jj_gen;
1506 break label_18;
1507 }
1508 jj_consume_token(COMMA);
1509 FormalParameter();
1510 }
1511 break;
1512 default:
1513 jj_la1[44] = jj_gen;
1514 ;
1515 }
1516 jj_consume_token(RPAREN);
1517 } catch (Throwable jjte000) {
1518 if (jjtc000) {
1519 jjtree.clearNodeScope(jjtn000);
1520 jjtc000 = false;
1521 } else {
1522 jjtree.popNode();
1523 }
1524 if (jjte000 instanceof RuntimeException) {
1525 {if (true) throw (RuntimeException)jjte000;}
1526 }
1527 if (jjte000 instanceof ParseException) {
1528 {if (true) throw (ParseException)jjte000;}
1529 }
1530 {if (true) throw (Error)jjte000;}
1531 } finally {
1532 if (jjtc000) {
1533 jjtree.closeNodeScope(jjtn000, true);
1534 }
1535 }
1536 }
1537
1538 final public void FormalParameter() throws ParseException {
1539
1540 ASTFormalParameter jjtn000 = new ASTFormalParameter(this, JJTFORMALPARAMETER);
1541 boolean jjtc000 = true;
1542 jjtree.openNodeScope(jjtn000);
1543 try {
1544 label_19:
1545 while (true) {
1546 switch (jj_nt.kind) {
1547 case FINAL:
1548 case AT:
1549 ;
1550 break;
1551 default:
1552 jj_la1[45] = jj_gen;
1553 break label_19;
1554 }
1555 switch (jj_nt.kind) {
1556 case FINAL:
1557 jj_consume_token(FINAL);
1558 jjtn000.setFinal();
1559 break;
1560 case AT:
1561 Annotation();
1562 break;
1563 default:
1564 jj_la1[46] = jj_gen;
1565 jj_consume_token(-1);
1566 throw new ParseException();
1567 }
1568 }
1569 Type();
1570 switch (jj_nt.kind) {
1571 case ELLIPSIS:
1572 jj_consume_token(ELLIPSIS);
1573 checkForBadVariableArgumentsUsage();
1574 jjtn000.setVarargs();
1575 break;
1576 default:
1577 jj_la1[47] = jj_gen;
1578 ;
1579 }
1580 VariableDeclaratorId();
1581 } catch (Throwable jjte000) {
1582 if (jjtc000) {
1583 jjtree.clearNodeScope(jjtn000);
1584 jjtc000 = false;
1585 } else {
1586 jjtree.popNode();
1587 }
1588 if (jjte000 instanceof RuntimeException) {
1589 {if (true) throw (RuntimeException)jjte000;}
1590 }
1591 if (jjte000 instanceof ParseException) {
1592 {if (true) throw (ParseException)jjte000;}
1593 }
1594 {if (true) throw (Error)jjte000;}
1595 } finally {
1596 if (jjtc000) {
1597 jjtree.closeNodeScope(jjtn000, true);
1598 }
1599 }
1600 }
1601
1602 final public void ConstructorDeclaration(int modifiers) throws ParseException {
1603
1604 ASTConstructorDeclaration jjtn000 = new ASTConstructorDeclaration(this, JJTCONSTRUCTORDECLARATION);
1605 boolean jjtc000 = true;
1606 jjtree.openNodeScope(jjtn000);jjtn000.setModifiers(modifiers);
1607 Token t;
1608 try {
1609 switch (jj_nt.kind) {
1610 case LT:
1611 TypeParameters();
1612 break;
1613 default:
1614 jj_la1[48] = jj_gen;
1615 ;
1616 }
1617 jj_consume_token(IDENTIFIER);
1618 FormalParameters();
1619 switch (jj_nt.kind) {
1620 case THROWS:
1621 jj_consume_token(THROWS);
1622 NameList();
1623 break;
1624 default:
1625 jj_la1[49] = jj_gen;
1626 ;
1627 }
1628 jj_consume_token(LBRACE);
1629 if (jj_2_10(2147483647)) {
1630 ExplicitConstructorInvocation();
1631 } else {
1632 ;
1633 }
1634 label_20:
1635 while (true) {
1636 if (jj_2_11(1)) {
1637 ;
1638 } else {
1639 break label_20;
1640 }
1641 BlockStatement();
1642 }
1643 t = jj_consume_token(RBRACE);
1644 jjtree.closeNodeScope(jjtn000, true);
1645 jjtc000 = false;
1646 if (isPrecededByComment(t)) { jjtn000.setContainsComment(); }
1647 } catch (Throwable jjte000) {
1648 if (jjtc000) {
1649 jjtree.clearNodeScope(jjtn000);
1650 jjtc000 = false;
1651 } else {
1652 jjtree.popNode();
1653 }
1654 if (jjte000 instanceof RuntimeException) {
1655 {if (true) throw (RuntimeException)jjte000;}
1656 }
1657 if (jjte000 instanceof ParseException) {
1658 {if (true) throw (ParseException)jjte000;}
1659 }
1660 {if (true) throw (Error)jjte000;}
1661 } finally {
1662