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