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