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