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