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