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