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