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 }