001 /*
002 * Cobertura - http://cobertura.sourceforge.net/
003 *
004 * This file was taken from JavaNCSS
005 * http://www.kclee.com/clemens/java/javancss/
006 * Copyright (C) 2000 Chr. Clemens Lee <clemens a.t kclee d.o.t com>
007 *
008 * Cobertura is free software; you can redistribute it and/or modify
009 * it under the terms of the GNU General Public License as published
010 * by the Free Software Foundation; either version 2 of the License,
011 * or (at your option) any later version.
012 *
013 * Cobertura is distributed in the hope that it will be useful, but
014 * WITHOUT ANY WARRANTY; without even the implied warranty of
015 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
016 * General Public License for more details.
017 *
018 * You should have received a copy of the GNU General Public License
019 * along with Cobertura; if not, write to the Free Software
020 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
021 * USA
022 */
023
024
025 /*
026 *
027 * WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING
028 *
029 * WARNING TO COBERTURA DEVELOPERS
030 *
031 * DO NOT MODIFY THIS FILE!
032 *
033 * MODIFY THE FILES UNDER THE JAVANCSS DIRECTORY LOCATED AT THE ROOT OF THE COBERTURA PROJECT.
034 *
035 * FOLLOW THE PROCEDURE FOR MERGING THE LATEST JAVANCSS INTO COBERTURA LOCATED AT
036 * javancss/coberturaREADME.txt
037 *
038 * WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING
039 */
040 /* Generated By:JavaCC: Do not edit this line. JavaParser15Debug.java */
041 package net.sourceforge.cobertura.javancss.parser.java15.debug;
042
043 import java.io.*;
044
045 import net.sourceforge.cobertura.javancss.parser.JavaParserInterface;
046 import java.util.*;
047
048 import net.sourceforge.cobertura.javancss.FunctionMetric;
049 import net.sourceforge.cobertura.javancss.ObjectMetric;
050 import net.sourceforge.cobertura.javancss.PackageMetric;
051
052 /**
053 * Grammar to parse Java version 1.5
054 * @author Sreenivasa Viswanadha - Simplified and enhanced for 1.5
055 */
056 public class JavaParser15Debug implements JavaParserInterface, JavaParser15DebugConstants {
057 private boolean _bReturn = false;
058 private int _ncss = 0; // general counter
059 private int _loc = 0;
060 private int _cyc = 1;
061 private int _localCases = 0;
062 private String _sName = ""; // name of last token
063 private String _sParameter = "";
064 private String _sPackage = "";
065 private String _sClass = "";
066 private String _sFunction = "";
067 private int _functions = 0; // number of functions in this class
068 //private int _topLevelClasses = 0;
069 private int _classes = 0;
070 private int _classLevel = 0;
071 private int _anonClassCount = 1;
072
073 private int _jvdcLines = 0; // added by SMS
074 private int _jvdc = 0;
075 private boolean _bPrivate = true;//false; // added by SMS
076 private boolean _bPublic = true; // added by SMS
077
078 /**
079 * For each class the number of formal
080 * comments in toplevel methods, constructors, inner
081 * classes, and for the class itself are counted.
082 * The top level comment has to be directly before
083 * the class definition, not before the package or
084 * import statement as it is often seen in source code
085 * examples (at the beginning of your source files you
086 * should instead put your copyright notice).
087 */
088 private int _javadocs = 0; // global javadocs
089 private List/*<FunctionMetric>*/ _vFunctions = new ArrayList(); // holds the statistics for each method
090
091 /**
092 * Metrics for each class/interface are stored in this
093 * vector.
094 */
095 private List/*<ObjectMetric>*/ _vClasses = new ArrayList();
096 private List _vImports = new ArrayList();
097 private Object[] _aoPackage = null;
098 private Map/*<String,PackageMetric>*/ _htPackage = new HashMap();
099 private PackageMetric _pPackageMetric;
100
101 private Token _tmpToken = null;
102 /** Argh, too much of a state machine. */
103 private Token _tmpResultToken = null;
104
105 private String _formatPackage(String sPackage_) {
106 if (sPackage_.equals("")) {
107 return ".";
108 }
109
110 return sPackage_.substring(0, sPackage_.length() - 1);
111 }
112
113
114 public void parse() throws Exception {
115 CompilationUnit();
116 }
117
118 public void parseImportUnit() throws Exception {
119 ImportUnit();
120 }
121
122 public int getNcss() {
123 return _ncss;
124 }
125
126 public int getLOC() {
127 return _loc;
128 }
129
130 // added by SMS
131 public int getJvdc() {
132 return _jvdc;
133 }
134
135 /*public int getTopLevelClasses() {
136 return _topLevelClasses;
137 }*/
138
139 public List/*<FunctionMetric>*/ getFunction() {
140 return _vFunctions;
141 }
142
143 /**
144 * @return Top level classes in sorted order
145 */
146 public List/*<ObjectMetric>*/ getObject() {
147 Collections.sort(_vClasses);
148 return _vClasses;
149 }
150
151 /**
152 * @return The empty package consists of the name ".".
153 */
154 public Map/*<String,PackageMetric>*/ getPackage() {
155 return _htPackage;
156 }
157
158 public List getImports() {
159 return _vImports;
160 }
161
162 /**
163 * name, beginLine, ...
164 */
165 public Object[] getPackageObjects() {
166 return _aoPackage;
167 }
168
169 /**
170 * if javancss is used with cat *.java a long
171 * input stream might get generated, so line
172 * number information in case of an parse exception
173 * is not very useful.
174 */
175 public String getLastFunction() {
176 return _sPackage + _sClass + _sFunction;
177 }
178 /**
179 * Class to hold modifiers.
180 */
181 static public final class ModifierSet
182 {
183 /* Definitions of the bits in the modifiers field. */
184 public static final int PUBLIC = 0x0001;
185 public static final int PROTECTED = 0x0002;
186 public static final int PRIVATE = 0x0004;
187 public static final int ABSTRACT = 0x0008;
188 public static final int STATIC = 0x0010;
189 public static final int FINAL = 0x0020;
190 public static final int SYNCHRONIZED = 0x0040;
191 public static final int NATIVE = 0x0080;
192 public static final int TRANSIENT = 0x0100;
193 public static final int VOLATILE = 0x0200;
194 public static final int STRICTFP = 0x1000;
195
196 /** A set of accessors that indicate whether the specified modifier
197 is in the set. */
198
199 public boolean isPublic(int modifiers)
200 {
201 return (modifiers & PUBLIC) != 0;
202 }
203
204 public boolean isProtected(int modifiers)
205 {
206 return (modifiers & PROTECTED) != 0;
207 }
208
209 public boolean isPrivate(int modifiers)
210 {
211 return (modifiers & PRIVATE) != 0;
212 }
213
214 public boolean isStatic(int modifiers)
215 {
216 return (modifiers & STATIC) != 0;
217 }
218
219 public boolean isAbstract(int modifiers)
220 {
221 return (modifiers & ABSTRACT) != 0;
222 }
223
224 public boolean isFinal(int modifiers)
225 {
226 return (modifiers & FINAL) != 0;
227 }
228
229 public boolean isNative(int modifiers)
230 {
231 return (modifiers & NATIVE) != 0;
232 }
233
234 public boolean isStrictfp(int modifiers)
235 {
236 return (modifiers & STRICTFP) != 0;
237 }
238
239 public boolean isSynchronized(int modifiers)
240 {
241 return (modifiers & SYNCHRONIZED) != 0;
242 }
243
244 public boolean isTransient(int modifiers)
245 {
246 return (modifiers & TRANSIENT) != 0;
247 }
248
249 public boolean isVolatile(int modifiers)
250 {
251 return (modifiers & VOLATILE) != 0;
252 }
253
254 /**
255 * Removes the given modifier.
256 */
257 static int removeModifier(int modifiers, int mod)
258 {
259 return modifiers & ~mod;
260 }
261 }
262
263 public JavaParser15Debug(String fileName)
264 {
265 this(System.in);
266 try { ReInit(new FileInputStream(new File(fileName))); }
267 catch(Exception e) { e.printStackTrace(); }
268 }
269
270 public static void main(String args[]) {
271 JavaParser15Debug parser;
272 if (args.length == 0) {
273 System.out.println("Java Parser Version 1.5: Reading from standard input . . .");
274 parser = new JavaParser15Debug(System.in);
275 } else if (args.length == 1) {
276 System.out.println("Java Parser Version 1.5: Reading from file " + args[0] + " . . .");
277 try {
278 parser = new JavaParser15Debug(new java.io.FileInputStream(args[0]));
279 } catch (java.io.FileNotFoundException e) {
280 System.out.println("Java Parser Version 1.5: File " + args[0] + " not found.");
281 return;
282 }
283 } else {
284 System.out.println("Java Parser Version 1.5: Usage is one of:");
285 System.out.println(" java javancss.parser.java15.debug.JavaParser15Debug < inputfile");
286 System.out.println("OR");
287 System.out.println(" java javancss.parser.java15.debug.JavaParser15Debug inputfile");
288 return;
289 }
290 try {
291 parser.CompilationUnit();
292 System.out.println("Java Parser Version 1.1: Java program parsed successfully.");
293 } catch (ParseException e) {
294 System.out.println(e.getMessage());
295 System.out.println("Java Parser Version 1.1: Encountered errors during parse.");
296 }
297 }
298
299 /*****************************************
300 * THE JAVA LANGUAGE GRAMMAR STARTS HERE *
301 *****************************************/
302
303 /*
304 * Program structuring syntax follows.
305 */
306 final public void CompilationUnit() throws ParseException {
307 trace_call("CompilationUnit");
308 try {
309 if (jj_2_1(2147483647)) {
310 PackageDeclaration();
311 } else {
312 ;
313 }
314 label_1:
315 while (true) {
316 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
317 case IMPORT:
318 ;
319 break;
320 default:
321 break label_1;
322 }
323 ImportDeclaration();
324 }
325 label_2:
326 while (true) {
327 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
328 case ABSTRACT:
329 case CLASS:
330 case ENUM:
331 case FINAL:
332 case INTERFACE:
333 case NATIVE:
334 case PRIVATE:
335 case PROTECTED:
336 case PUBLIC:
337 case STATIC:
338 case STRICTFP:
339 case SYNCHRONIZED:
340 case TRANSIENT:
341 case VOLATILE:
342 case SEMICOLON:
343 case AT:
344 ;
345 break;
346 default:
347 break label_2;
348 }
349 TypeDeclaration();
350 }
351 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
352 case 127:
353 jj_consume_token(127);
354 break;
355 default:
356 ;
357 }
358 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
359 case STUFF_TO_IGNORE:
360 jj_consume_token(STUFF_TO_IGNORE);
361 break;
362 default:
363 ;
364 }
365 jj_consume_token(0);
366 } finally {
367 trace_return("CompilationUnit");
368 }
369 }
370
371 final public void PackageDeclaration() throws ParseException {
372 trace_call("PackageDeclaration");
373 try {
374 Modifiers();
375 jj_consume_token(PACKAGE);
376 Name();
377 jj_consume_token(SEMICOLON);
378 } finally {
379 trace_return("PackageDeclaration");
380 }
381 }
382
383 final public void ImportUnit() throws ParseException {
384 trace_call("ImportUnit");
385 try {
386 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
387 case ABSTRACT:
388 case FINAL:
389 case NATIVE:
390 case PACKAGE:
391 case PRIVATE:
392 case PROTECTED:
393 case PUBLIC:
394 case STATIC:
395 case STRICTFP:
396 case SYNCHRONIZED:
397 case TRANSIENT:
398 case VOLATILE:
399 case AT:
400 PackageDeclaration();
401 break;
402 default:
403 ;
404 }
405 label_3:
406 while (true) {
407 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
408 case IMPORT:
409 ;
410 break;
411 default:
412 break label_3;
413 }
414 ImportDeclaration();
415 }
416 label_4:
417 while (true) {
418 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
419 case ABSTRACT:
420 case FINAL:
421 case PUBLIC:
422 case STRICTFP:
423 case SYNCHRONIZED:
424 ;
425 break;
426 default:
427 break label_4;
428 }
429 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
430 case ABSTRACT:
431 jj_consume_token(ABSTRACT);
432 break;
433 case FINAL:
434 jj_consume_token(FINAL);
435 break;
436 case PUBLIC:
437 jj_consume_token(PUBLIC);
438 break;
439 case SYNCHRONIZED:
440 jj_consume_token(SYNCHRONIZED);
441 break;
442 case STRICTFP:
443 jj_consume_token(STRICTFP);
444 break;
445 default:
446 jj_consume_token(-1);
447 throw new ParseException();
448 }
449 }
450 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
451 case CLASS:
452 jj_consume_token(CLASS);
453 break;
454 case INTERFACE:
455 jj_consume_token(INTERFACE);
456 break;
457 default:
458 jj_consume_token(-1);
459 throw new ParseException();
460 }
461 } finally {
462 trace_return("ImportUnit");
463 }
464 }
465
466 final public void ImportDeclaration() throws ParseException {
467 trace_call("ImportDeclaration");
468 try {
469 jj_consume_token(IMPORT);
470 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
471 case STATIC:
472 jj_consume_token(STATIC);
473 break;
474 default:
475 ;
476 }
477 Name();
478 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
479 case DOT:
480 jj_consume_token(DOT);
481 jj_consume_token(STAR);
482 break;
483 default:
484 ;
485 }
486 jj_consume_token(SEMICOLON);
487 } finally {
488 trace_return("ImportDeclaration");
489 }
490 }
491
492 /*
493 * Modifiers. We match all modifiers in a single rule to reduce the chances of
494 * syntax errors for simple modifier mistakes. It will also enable us to give
495 * better error messages.
496 */
497 final public int Modifiers() throws ParseException {
498 trace_call("Modifiers");
499 try {
500 int modifiers = 0;
501 label_5:
502 while (true) {
503 if (jj_2_2(2)) {
504 ;
505 } else {
506 break label_5;
507 }
508 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
509 case PUBLIC:
510 jj_consume_token(PUBLIC);
511 modifiers |= ModifierSet.PUBLIC;
512 break;
513 case STATIC:
514 jj_consume_token(STATIC);
515 modifiers |= ModifierSet.STATIC;
516 break;
517 case PROTECTED:
518 jj_consume_token(PROTECTED);
519 modifiers |= ModifierSet.PROTECTED;
520 break;
521 case PRIVATE:
522 jj_consume_token(PRIVATE);
523 modifiers |= ModifierSet.PRIVATE;
524 break;
525 case FINAL:
526 jj_consume_token(FINAL);
527 modifiers |= ModifierSet.FINAL;
528 break;
529 case ABSTRACT:
530 jj_consume_token(ABSTRACT);
531 modifiers |= ModifierSet.ABSTRACT;
532 break;
533 case SYNCHRONIZED:
534 jj_consume_token(SYNCHRONIZED);
535 modifiers |= ModifierSet.SYNCHRONIZED;
536 break;
537 case NATIVE:
538 jj_consume_token(NATIVE);
539 modifiers |= ModifierSet.NATIVE;
540 break;
541 case TRANSIENT:
542 jj_consume_token(TRANSIENT);
543 modifiers |= ModifierSet.TRANSIENT;
544 break;
545 case VOLATILE:
546 jj_consume_token(VOLATILE);
547 modifiers |= ModifierSet.VOLATILE;
548 break;
549 case STRICTFP:
550 jj_consume_token(STRICTFP);
551 modifiers |= ModifierSet.STRICTFP;
552 break;
553 case AT:
554 Annotation();
555 break;
556 default:
557 jj_consume_token(-1);
558 throw new ParseException();
559 }
560 }
561 {if (true) return modifiers;}
562 throw new Error("Missing return statement in function");
563 } finally {
564 trace_return("Modifiers");
565 }
566 }
567
568 /*
569 * Declaration syntax follows.
570 */
571 final public void TypeDeclaration() throws ParseException {
572 trace_call("TypeDeclaration");
573 try {
574 int modifiers;
575 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
576 case SEMICOLON:
577 jj_consume_token(SEMICOLON);
578 break;
579 case ABSTRACT:
580 case CLASS:
581 case ENUM:
582 case FINAL:
583 case INTERFACE:
584 case NATIVE:
585 case PRIVATE:
586 case PROTECTED:
587 case PUBLIC:
588 case STATIC:
589 case STRICTFP:
590 case SYNCHRONIZED:
591 case TRANSIENT:
592 case VOLATILE:
593 case AT:
594 modifiers = Modifiers();
595 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
596 case CLASS:
597 case INTERFACE:
598 ClassOrInterfaceDeclaration(modifiers);
599 break;
600 case ENUM:
601 EnumDeclaration(modifiers);
602 break;
603 case AT:
604 AnnotationTypeDeclaration(modifiers);
605 break;
606 default:
607 jj_consume_token(-1);
608 throw new ParseException();
609 }
610 break;
611 default:
612 jj_consume_token(-1);
613 throw new ParseException();
614 }
615 } finally {
616 trace_return("TypeDeclaration");
617 }
618 }
619
620 final public void ClassOrInterfaceDeclaration(int modifiers) throws ParseException {
621 trace_call("ClassOrInterfaceDeclaration");
622 try {
623 boolean isInterface = false;
624 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
625 case CLASS:
626 jj_consume_token(CLASS);
627 break;
628 case INTERFACE:
629 jj_consume_token(INTERFACE);
630 isInterface = true;
631 break;
632 default:
633 jj_consume_token(-1);
634 throw new ParseException();
635 }
636 jj_consume_token(IDENTIFIER);
637 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
638 case LT:
639 TypeParameters();
640 break;
641 default:
642 ;
643 }
644 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
645 case EXTENDS:
646 ExtendsList(isInterface);
647 break;
648 default:
649 ;
650 }
651 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
652 case IMPLEMENTS:
653 ImplementsList(isInterface);
654 break;
655 default:
656 ;
657 }
658 ClassOrInterfaceBody(isInterface);
659 } finally {
660 trace_return("ClassOrInterfaceDeclaration");
661 }
662 }
663
664 final public void ExtendsList(boolean isInterface) throws ParseException {
665 trace_call("ExtendsList");
666 try {
667 boolean extendsMoreThanOne = false;
668 jj_consume_token(EXTENDS);
669 ClassOrInterfaceType();
670 label_6:
671 while (true) {
672 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
673 case COMMA:
674 ;
675 break;
676 default:
677 break label_6;
678 }
679 jj_consume_token(COMMA);
680 ClassOrInterfaceType();
681 extendsMoreThanOne = true;
682 }
683 if (extendsMoreThanOne && !isInterface)
684 {if (true) throw new ParseException("A class cannot extend more than one other class");}
685 } finally {
686 trace_return("ExtendsList");
687 }
688 }
689
690 final public void ImplementsList(boolean isInterface) throws ParseException {
691 trace_call("ImplementsList");
692 try {
693 jj_consume_token(IMPLEMENTS);
694 ClassOrInterfaceType();
695 label_7:
696 while (true) {
697 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
698 case COMMA:
699 ;
700 break;
701 default:
702 break label_7;
703 }
704 jj_consume_token(COMMA);
705 ClassOrInterfaceType();
706 }
707 if (isInterface)
708 {if (true) throw new ParseException("An interface cannot implement other interfaces");}
709 } finally {
710 trace_return("ImplementsList");
711 }
712 }
713
714 final public void EnumDeclaration(int modifiers) throws ParseException {
715 trace_call("EnumDeclaration");
716 try {
717 jj_consume_token(ENUM);
718 jj_consume_token(IDENTIFIER);
719 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
720 case IMPLEMENTS:
721 ImplementsList(false);
722 break;
723 default:
724 ;
725 }
726 EnumBody();
727 } finally {
728 trace_return("EnumDeclaration");
729 }
730 }
731
732 final public void EnumBody() throws ParseException {
733 trace_call("EnumBody");
734 try {
735 jj_consume_token(LBRACE);
736 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
737 case ABSTRACT:
738 case FINAL:
739 case NATIVE:
740 case PRIVATE:
741 case PROTECTED:
742 case PUBLIC:
743 case STATIC:
744 case STRICTFP:
745 case SYNCHRONIZED:
746 case TRANSIENT:
747 case VOLATILE:
748 case IDENTIFIER:
749 case AT:
750 EnumConstant();
751 label_8:
752 while (true) {
753 if (jj_2_3(2)) {
754 ;
755 } else {
756 break label_8;
757 }
758 jj_consume_token(COMMA);
759 EnumConstant();
760 }
761 break;
762 default:
763 ;
764 }
765 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
766 case COMMA:
767 jj_consume_token(COMMA);
768 break;
769 default:
770 ;
771 }
772 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
773 case SEMICOLON:
774 jj_consume_token(SEMICOLON);
775 label_9:
776 while (true) {
777 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
778 case ABSTRACT:
779 case BOOLEAN:
780 case BYTE:
781 case CHAR:
782 case CLASS:
783 case DOUBLE:
784 case ENUM:
785 case FINAL:
786 case FLOAT:
787 case INT:
788 case INTERFACE:
789 case LONG:
790 case NATIVE:
791 case PRIVATE:
792 case PROTECTED:
793 case PUBLIC:
794 case SHORT:
795 case STATIC:
796 case STRICTFP:
797 case SYNCHRONIZED:
798 case TRANSIENT:
799 case VOID:
800 case VOLATILE:
801 case IDENTIFIER:
802 case LBRACE:
803 case SEMICOLON:
804 case AT:
805 case LT:
806 ;
807 break;
808 default:
809 break label_9;
810 }
811 ClassOrInterfaceBodyDeclaration(false);
812 }
813 break;
814 default:
815 ;
816 }
817 jj_consume_token(RBRACE);
818 } finally {
819 trace_return("EnumBody");
820 }
821 }
822
823 final public void EnumConstant() throws ParseException {
824 trace_call("EnumConstant");
825 try {
826 Modifiers();
827 jj_consume_token(IDENTIFIER);
828 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
829 case LPAREN:
830 Arguments();
831 break;
832 default:
833 ;
834 }
835 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
836 case LBRACE:
837 ClassOrInterfaceBody(false);
838 break;
839 default:
840 ;
841 }
842 } finally {
843 trace_return("EnumConstant");
844 }
845 }
846
847 final public void TypeParameters() throws ParseException {
848 trace_call("TypeParameters");
849 try {
850 jj_consume_token(LT);
851 TypeParameter();
852 label_10:
853 while (true) {
854 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
855 case COMMA:
856 ;
857 break;
858 default:
859 break label_10;
860 }
861 jj_consume_token(COMMA);
862 TypeParameter();
863 }
864 jj_consume_token(GT);
865 } finally {
866 trace_return("TypeParameters");
867 }
868 }
869
870 final public void TypeParameter() throws ParseException {
871 trace_call("TypeParameter");
872 try {
873 jj_consume_token(IDENTIFIER);
874 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
875 case EXTENDS:
876 TypeBound();
877 break;
878 default:
879 ;
880 }
881 } finally {
882 trace_return("TypeParameter");
883 }
884 }
885
886 final public void TypeBound() throws ParseException {
887 trace_call("TypeBound");
888 try {
889 jj_consume_token(EXTENDS);
890 ClassOrInterfaceType();
891 label_11:
892 while (true) {
893 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
894 case BIT_AND:
895 ;
896 break;
897 default:
898 break label_11;
899 }
900 jj_consume_token(BIT_AND);
901 ClassOrInterfaceType();
902 }
903 } finally {
904 trace_return("TypeBound");
905 }
906 }
907
908 final public void ClassOrInterfaceBody(boolean isInterface) throws ParseException {
909 trace_call("ClassOrInterfaceBody");
910 try {
911 jj_consume_token(LBRACE);
912 label_12:
913 while (true) {
914 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
915 case ABSTRACT:
916 case BOOLEAN:
917 case BYTE:
918 case CHAR:
919 case CLASS:
920 case DOUBLE:
921 case ENUM:
922 case FINAL:
923 case FLOAT:
924 case INT:
925 case INTERFACE:
926 case LONG:
927 case NATIVE:
928 case PRIVATE:
929 case PROTECTED:
930 case PUBLIC:
931 case SHORT:
932 case STATIC:
933 case STRICTFP:
934 case SYNCHRONIZED:
935 case TRANSIENT:
936 case VOID:
937 case VOLATILE:
938 case IDENTIFIER:
939 case LBRACE:
940 case SEMICOLON:
941 case AT:
942 case LT:
943 ;
944 break;
945 default:
946 break label_12;
947 }
948 ClassOrInterfaceBodyDeclaration(isInterface);
949 }
950 jj_consume_token(RBRACE);
951 } finally {
952 trace_return("ClassOrInterfaceBody");
953 }
954 }
955
956 final public void ClassOrInterfaceBodyDeclaration(boolean isInterface) throws ParseException {
957 trace_call("ClassOrInterfaceBodyDeclaration");
958 try {
959 boolean isNestedInterface = false;
960 int modifiers;
961 if (jj_2_6(2)) {
962 Initializer();
963 if (isInterface)
964 {if (true) throw new ParseException("An interface cannot have initializers");}
965 } else {
966 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
967 case ABSTRACT:
968 case BOOLEAN:
969 case BYTE:
970 case CHAR:
971 case CLASS:
972 case DOUBLE:
973 case ENUM:
974 case FINAL:
975 case FLOAT:
976 case INT:
977 case INTERFACE:
978 case LONG:
979 case NATIVE:
980 case PRIVATE:
981 case PROTECTED:
982 case PUBLIC:
983 case SHORT:
984 case STATIC:
985 case STRICTFP:
986 case SYNCHRONIZED:
987 case TRANSIENT:
988 case VOID:
989 case VOLATILE:
990 case IDENTIFIER:
991 case AT:
992 case LT:
993 modifiers = Modifiers();
994 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
995 case CLASS:
996 case INTERFACE:
997 ClassOrInterfaceDeclaration(modifiers);
998 break;
999 case ENUM:
1000 EnumDeclaration(modifiers);
1001 break;
1002 default:
1003 if (jj_2_4(2147483647)) {
1004 ConstructorDeclaration();
1005 } else if (jj_2_5(2147483647)) {
1006 FieldDeclaration(modifiers);
1007 } else {
1008 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1009 case BOOLEAN:
1010 case BYTE:
1011 case CHAR:
1012 case DOUBLE:
1013 case FLOAT:
1014 case INT:
1015 case LONG:
1016 case SHORT:
1017 case VOID:
1018 case IDENTIFIER:
1019 case LT:
1020 MethodDeclaration(modifiers);
1021 break;
1022 default:
1023 jj_consume_token(-1);
1024 throw new ParseException();
1025 }
1026 }
1027 }
1028 break;
1029 case SEMICOLON:
1030 jj_consume_token(SEMICOLON);
1031 break;
1032 default:
1033 jj_consume_token(-1);
1034 throw new ParseException();
1035 }
1036 }
1037 } finally {
1038 trace_return("ClassOrInterfaceBodyDeclaration");
1039 }
1040 }
1041
1042 final public void FieldDeclaration(int modifiers) throws ParseException {
1043 trace_call("FieldDeclaration");
1044 try {
1045 Type();
1046 VariableDeclarator();
1047 label_13:
1048 while (true) {
1049 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1050 case COMMA:
1051 ;
1052 break;
1053 default:
1054 break label_13;
1055 }
1056 jj_consume_token(COMMA);
1057 VariableDeclarator();
1058 }
1059 jj_consume_token(SEMICOLON);
1060 } finally {
1061 trace_return("FieldDeclaration");
1062 }
1063 }
1064
1065 final public void VariableDeclarator() throws ParseException {
1066 trace_call("VariableDeclarator");
1067 try {
1068 VariableDeclaratorId();
1069 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1070 case ASSIGN:
1071 jj_consume_token(ASSIGN);
1072 VariableInitializer();
1073 break;
1074 default:
1075 ;
1076 }
1077 } finally {
1078 trace_return("VariableDeclarator");
1079 }
1080 }
1081
1082 final public void VariableDeclaratorId() throws ParseException {
1083 trace_call("VariableDeclaratorId");
1084 try {
1085 jj_consume_token(IDENTIFIER);
1086 label_14:
1087 while (true) {
1088 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1089 case LBRACKET:
1090 ;
1091 break;
1092 default:
1093 break label_14;
1094 }
1095 jj_consume_token(LBRACKET);
1096 jj_consume_token(RBRACKET);
1097 }
1098 } finally {
1099 trace_return("VariableDeclaratorId");
1100 }
1101 }
1102
1103 final public void VariableInitializer() throws ParseException {
1104 trace_call("VariableInitializer");
1105 try {
1106 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1107 case LBRACE:
1108 ArrayInitializer();
1109 break;
1110 case BOOLEAN:
1111 case BYTE:
1112 case CHAR:
1113 case DOUBLE:
1114 case FALSE:
1115 case FLOAT:
1116 case INT:
1117 case LONG:
1118 case NEW:
1119 case NULL:
1120 case SHORT:
1121 case SUPER:
1122 case THIS:
1123 case TRUE:
1124 case VOID:
1125 case INTEGER_LITERAL:
1126 case FLOATING_POINT_LITERAL:
1127 case CHARACTER_LITERAL:
1128 case STRING_LITERAL:
1129 case IDENTIFIER:
1130 case LPAREN:
1131 case BANG:
1132 case TILDE:
1133 case INCR:
1134 case DECR:
1135 case PLUS:
1136 case MINUS:
1137 Expression();
1138 break;
1139 default:
1140 jj_consume_token(-1);
1141 throw new ParseException();
1142 }
1143 } finally {
1144 trace_return("VariableInitializer");
1145 }
1146 }
1147
1148 final public void ArrayInitializer() throws ParseException {
1149 trace_call("ArrayInitializer");
1150 try {
1151 jj_consume_token(LBRACE);
1152 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1153 case BOOLEAN:
1154 case BYTE:
1155 case CHAR:
1156 case DOUBLE:
1157 case FALSE:
1158 case FLOAT:
1159 case INT:
1160 case LONG:
1161 case NEW:
1162 case NULL:
1163 case SHORT:
1164 case SUPER:
1165 case THIS:
1166 case TRUE:
1167 case VOID:
1168 case INTEGER_LITERAL:
1169 case FLOATING_POINT_LITERAL:
1170 case CHARACTER_LITERAL:
1171 case STRING_LITERAL:
1172 case IDENTIFIER:
1173 case LPAREN:
1174 case LBRACE:
1175 case BANG:
1176 case TILDE:
1177 case INCR:
1178 case DECR:
1179 case PLUS:
1180 case MINUS:
1181 VariableInitializer();
1182 label_15:
1183 while (true) {
1184 if (jj_2_7(2)) {
1185 ;
1186 } else {
1187 break label_15;
1188 }
1189 jj_consume_token(COMMA);
1190 VariableInitializer();
1191 }
1192 break;
1193 default:
1194 ;
1195 }
1196 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1197 case COMMA:
1198 jj_consume_token(COMMA);
1199 break;
1200 default:
1201 ;
1202 }
1203 jj_consume_token(RBRACE);
1204 } finally {
1205 trace_return("ArrayInitializer");
1206 }
1207 }
1208
1209 final public void MethodDeclaration(int modifiers) throws ParseException {
1210 trace_call("MethodDeclaration");
1211 try {
1212 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1213 case LT:
1214 TypeParameters();
1215 break;
1216 default:
1217 ;
1218 }
1219 ResultType();
1220 MethodDeclarator();
1221 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1222 case THROWS:
1223 jj_consume_token(THROWS);
1224 NameList();
1225 break;
1226 default:
1227 ;
1228 }
1229 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1230 case LBRACE:
1231 Block();
1232 break;
1233 case SEMICOLON:
1234 jj_consume_token(SEMICOLON);
1235 break;
1236 default:
1237 jj_consume_token(-1);
1238 throw new ParseException();
1239 }
1240 } finally {
1241 trace_return("MethodDeclaration");
1242 }
1243 }
1244
1245 final public void MethodDeclarator() throws ParseException {
1246 trace_call("MethodDeclarator");
1247 try {
1248 jj_consume_token(IDENTIFIER);
1249 FormalParameters();
1250 label_16:
1251 while (true) {
1252 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1253 case LBRACKET:
1254 ;
1255 break;
1256 default:
1257 break label_16;
1258 }
1259 jj_consume_token(LBRACKET);
1260 jj_consume_token(RBRACKET);
1261 }
1262 } finally {
1263 trace_return("MethodDeclarator");
1264 }
1265 }
1266
1267 final public void FormalParameters() throws ParseException {
1268 trace_call("FormalParameters");
1269 try {
1270 jj_consume_token(LPAREN);
1271 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1272 case ABSTRACT:
1273 case BOOLEAN:
1274 case BYTE:
1275 case CHAR:
1276 case DOUBLE:
1277 case FINAL:
1278 case FLOAT:
1279 case INT:
1280 case LONG:
1281 case NATIVE:
1282 case PRIVATE:
1283 case PROTECTED:
1284 case PUBLIC:
1285 case SHORT:
1286 case STATIC:
1287 case STRICTFP:
1288 case SYNCHRONIZED:
1289 case TRANSIENT:
1290 case VOLATILE:
1291 case IDENTIFIER:
1292 case AT:
1293 FormalParameter();
1294 label_17:
1295 while (true) {
1296 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1297 case COMMA:
1298 ;
1299 break;
1300 default:
1301 break label_17;
1302 }
1303 jj_consume_token(COMMA);
1304 FormalParameter();
1305 }
1306 break;
1307 default:
1308 ;
1309 }
1310 jj_consume_token(RPAREN);
1311 } finally {
1312 trace_return("FormalParameters");
1313 }
1314 }
1315
1316 final public void FormalParameter() throws ParseException {
1317 trace_call("FormalParameter");
1318 try {
1319 Modifiers();
1320 Type();
1321 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1322 case ELLIPSIS:
1323 jj_consume_token(ELLIPSIS);
1324 break;
1325 default:
1326 ;
1327 }
1328 VariableDeclaratorId();
1329 } finally {
1330 trace_return("FormalParameter");
1331 }
1332 }
1333
1334 final public void ConstructorDeclaration() throws ParseException {
1335 trace_call("ConstructorDeclaration");
1336 try {
1337 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1338 case LT:
1339 TypeParameters();
1340 break;
1341 default:
1342 ;
1343 }
1344 jj_consume_token(IDENTIFIER);
1345 FormalParameters();
1346 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1347 case THROWS:
1348 jj_consume_token(THROWS);
1349 NameList();
1350 break;
1351 default:
1352 ;
1353 }
1354 jj_consume_token(LBRACE);
1355 if (jj_2_8(2147483647)) {
1356 ExplicitConstructorInvocation();
1357 } else {
1358 ;
1359 }
1360 label_18:
1361 while (true) {
1362 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1363 case ABSTRACT:
1364 case ASSERT:
1365 case BOOLEAN:
1366 case BREAK:
1367 case BYTE:
1368 case CHAR:
1369 case CLASS:
1370 case CONTINUE:
1371 case DO:
1372 case DOUBLE:
1373 case FALSE:
1374 case FINAL:
1375 case FLOAT:
1376 case FOR:
1377 case IF:
1378 case INT:
1379 case INTERFACE:
1380 case LONG:
1381 case NATIVE:
1382 case NEW:
1383 case NULL:
1384 case PRIVATE:
1385 case PROTECTED:
1386 case PUBLIC:
1387 case RETURN:
1388 case SHORT:
1389 case STATIC:
1390 case STRICTFP:
1391 case SUPER:
1392 case SWITCH:
1393 case SYNCHRONIZED:
1394 case THIS:
1395 case THROW:
1396 case TRANSIENT:
1397 case TRUE:
1398 case TRY:
1399 case VOID:
1400 case VOLATILE:
1401 case WHILE:
1402 case INTEGER_LITERAL:
1403 case FLOATING_POINT_LITERAL:
1404 case CHARACTER_LITERAL:
1405 case STRING_LITERAL:
1406 case IDENTIFIER:
1407 case LPAREN:
1408 case LBRACE:
1409 case SEMICOLON:
1410 case AT:
1411 case INCR:
1412 case DECR:
1413 ;
1414 break;
1415 default:
1416 break label_18;
1417 }
1418 BlockStatement();
1419 }
1420 jj_consume_token(RBRACE);
1421 } finally {
1422 trace_return("ConstructorDeclaration");
1423 }
1424 }
1425
1426 final public void ExplicitConstructorInvocation() throws ParseException {
1427 trace_call("ExplicitConstructorInvocation");
1428 try {
1429 label_19:
1430 while (true) {
1431 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1432 case IDENTIFIER:
1433 ;
1434 break;
1435 default:
1436 break label_19;
1437 }
1438 jj_consume_token(IDENTIFIER);
1439 jj_consume_token(DOT);
1440 }
1441 if (jj_2_9(2)) {
1442 jj_consume_token(THIS);
1443 jj_consume_token(DOT);
1444 } else {
1445 ;
1446 }
1447 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1448 case LT:
1449 TypeArguments();
1450 break;
1451 default:
1452 ;
1453 }
1454 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1455 case THIS:
1456 jj_consume_token(THIS);
1457 break;
1458 case SUPER:
1459 jj_consume_token(SUPER);
1460 break;
1461 default:
1462 jj_consume_token(-1);
1463 throw new ParseException();
1464 }
1465 Arguments();
1466 jj_consume_token(SEMICOLON);
1467 } finally {
1468 trace_return("ExplicitConstructorInvocation");
1469 }
1470 }
1471
1472 final public void Initializer() throws ParseException {
1473 trace_call("Initializer");
1474 try {
1475 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1476 case STATIC:
1477 jj_consume_token(STATIC);
1478 break;
1479 default:
1480 ;
1481 }
1482 Block();
1483 } finally {
1484 trace_return("Initializer");
1485 }
1486 }
1487
1488 /*
1489 * Type, name and expression syntax follows.
1490 */
1491 final public void Type() throws ParseException {
1492 trace_call("Type");
1493 try {
1494 if (jj_2_10(2)) {
1495 ReferenceType();
1496 } else {
1497 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1498 case BOOLEAN:
1499 case BYTE:
1500 case CHAR:
1501 case DOUBLE:
1502 case FLOAT:
1503 case INT:
1504 case LONG:
1505 case SHORT:
1506 PrimitiveType();
1507 break;
1508 default:
1509 jj_consume_token(-1);
1510 throw new ParseException();
1511 }
1512 }
1513 } finally {
1514 trace_return("Type");
1515 }
1516 }
1517
1518 final public void ReferenceType() throws ParseException {
1519 trace_call("ReferenceType");
1520 try {
1521 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1522 case BOOLEAN:
1523 case BYTE:
1524 case CHAR:
1525 case DOUBLE:
1526 case FLOAT:
1527 case INT:
1528 case LONG:
1529 case SHORT:
1530 PrimitiveType();
1531 label_20:
1532 while (true) {
1533 jj_consume_token(LBRACKET);
1534 jj_consume_token(RBRACKET);
1535 if (jj_2_11(2)) {
1536 ;
1537 } else {
1538 break label_20;
1539 }
1540 }
1541 break;
1542 case IDENTIFIER:
1543 ClassOrInterfaceType();
1544 label_21:
1545 while (true) {
1546 if (jj_2_12(2)) {
1547 ;
1548 } else {
1549 break label_21;
1550 }
1551 jj_consume_token(LBRACKET);
1552 jj_consume_token(RBRACKET);
1553 }
1554 break;
1555 default:
1556 jj_consume_token(-1);
1557 throw new ParseException();
1558 }
1559 } finally {
1560 trace_return("ReferenceType");
1561 }
1562 }
1563
1564 final public void ClassOrInterfaceType() throws ParseException {
1565 trace_call("ClassOrInterfaceType");
1566 try {
1567 jj_consume_token(IDENTIFIER);
1568 if (jj_2_13(2)) {
1569 TypeArguments();
1570 } else {
1571 ;
1572 }
1573 label_22:
1574 while (true) {
1575 if (jj_2_14(2)) {
1576 ;
1577 } else {
1578 break label_22;
1579 }
1580 jj_consume_token(DOT);
1581 jj_consume_token(IDENTIFIER);
1582 if (jj_2_15(2)) {
1583 TypeArguments();
1584 } else {
1585 ;
1586 }
1587 }
1588 } finally {
1589 trace_return("ClassOrInterfaceType");
1590 }
1591 }
1592
1593 final public void TypeArguments() throws ParseException {
1594 trace_call("TypeArguments");
1595 try {
1596 jj_consume_token(LT);
1597 TypeArgument();
1598 label_23:
1599 while (true) {
1600 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1601 case COMMA:
1602 ;
1603 break;
1604 default:
1605 break label_23;
1606 }
1607 jj_consume_token(COMMA);
1608 TypeArgument();
1609 }
1610 jj_consume_token(GT);
1611 } finally {
1612 trace_return("TypeArguments");
1613 }
1614 }
1615
1616 final public void TypeArgument() throws ParseException {
1617 trace_call("TypeArgument");
1618 try {
1619 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1620 case BOOLEAN:
1621 case BYTE:
1622 case CHAR:
1623 case DOUBLE:
1624 case FLOAT:
1625 case INT:
1626 case LONG:
1627 case SHORT:
1628 case IDENTIFIER:
1629 ReferenceType();
1630 break;
1631 case HOOK:
1632 jj_consume_token(HOOK);
1633 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1634 case EXTENDS:
1635 case SUPER:
1636 WildcardBounds();
1637 break;
1638 default:
1639 ;
1640 }
1641 break;
1642 default:
1643 jj_consume_token(-1);
1644 throw new ParseException();
1645 }
1646 } finally {
1647 trace_return("TypeArgument");
1648 }
1649 }
1650
1651 final public void WildcardBounds() throws ParseException {
1652 trace_call("WildcardBounds");
1653 try {
1654 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1655 case EXTENDS:
1656 jj_consume_token(EXTENDS);
1657 ReferenceType();
1658 break;
1659 case SUPER:
1660 jj_consume_token(SUPER);
1661 ReferenceType();
1662 break;
1663 default:
1664 jj_consume_token(-1);
1665 throw new ParseException();
1666 }
1667 } finally {
1668 trace_return("WildcardBounds");
1669 }
1670 }
1671
1672 final public void PrimitiveType() throws ParseException {
1673 trace_call("PrimitiveType");
1674 try {
1675 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1676 case BOOLEAN:
1677 jj_consume_token(BOOLEAN);
1678 break;
1679 case CHAR:
1680 jj_consume_token(CHAR);
1681 break;
1682 case BYTE:
1683 jj_consume_token(BYTE);
1684 break;
1685 case SHORT:
1686 jj_consume_token(SHORT);
1687 break;
1688 case INT:
1689 jj_consume_token(INT);
1690 break;
1691 case LONG:
1692 jj_consume_token(LONG);
1693 break;
1694 case FLOAT:
1695 jj_consume_token(FLOAT);
1696 break;
1697 case DOUBLE:
1698 jj_consume_token(DOUBLE);
1699 break;
1700 default:
1701 jj_consume_token(-1);
1702 throw new ParseException();
1703 }
1704 } finally {
1705 trace_return("PrimitiveType");
1706 }
1707 }
1708
1709 final public void ResultType() throws ParseException {
1710 trace_call("ResultType");
1711 try {
1712 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1713 case VOID:
1714 jj_consume_token(VOID);
1715 break;
1716 case BOOLEAN:
1717 case BYTE:
1718 case CHAR:
1719 case DOUBLE:
1720 case FLOAT:
1721 case INT:
1722 case LONG:
1723 case SHORT:
1724 case IDENTIFIER:
1725 Type();
1726 break;
1727 default:
1728 jj_consume_token(-1);
1729 throw new ParseException();
1730 }
1731 } finally {
1732 trace_return("ResultType");
1733 }
1734 }
1735
1736 final public void Name() throws ParseException {
1737 trace_call("Name");
1738 try {
1739 jj_consume_token(IDENTIFIER);
1740 label_24:
1741 while (true) {
1742 if (jj_2_16(2)) {
1743 ;
1744 } else {
1745 break label_24;
1746 }
1747 jj_consume_token(DOT);
1748 jj_consume_token(IDENTIFIER);
1749 }
1750 } finally {
1751 trace_return("Name");
1752 }
1753 }
1754
1755 final public void NameList() throws ParseException {
1756 trace_call("NameList");
1757 try {
1758 Name();
1759 label_25:
1760 while (true) {
1761 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1762 case COMMA:
1763 ;
1764 break;
1765 default:
1766 break label_25;
1767 }
1768 jj_consume_token(COMMA);
1769 Name();
1770 }
1771 } finally {
1772 trace_return("NameList");
1773 }
1774 }
1775
1776 /*
1777 * Expression syntax follows.
1778 */
1779 final public void Expression() throws ParseException {
1780 trace_call("Expression");
1781 try {
1782 ConditionalExpression();
1783 if (jj_2_17(2)) {
1784 AssignmentOperator();
1785 Expression();
1786 } else {
1787 ;
1788 }
1789 } finally {
1790 trace_return("Expression");
1791 }
1792 }
1793
1794 final public void AssignmentOperator() throws ParseException {
1795 trace_call("AssignmentOperator");
1796 try {
1797 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1798 case ASSIGN:
1799 jj_consume_token(ASSIGN);
1800 break;
1801 case STARASSIGN:
1802 jj_consume_token(STARASSIGN);
1803 break;
1804 case SLASHASSIGN:
1805 jj_consume_token(SLASHASSIGN);
1806 break;
1807 case REMASSIGN:
1808 jj_consume_token(REMASSIGN);
1809 break;
1810 case PLUSASSIGN:
1811 jj_consume_token(PLUSASSIGN);
1812 break;
1813 case MINUSASSIGN:
1814 jj_consume_token(MINUSASSIGN);
1815 break;
1816 case LSHIFTASSIGN:
1817 jj_consume_token(LSHIFTASSIGN);
1818 break;
1819 case RSIGNEDSHIFTASSIGN:
1820 jj_consume_token(RSIGNEDSHIFTASSIGN);
1821 break;
1822 case RUNSIGNEDSHIFTASSIGN:
1823 jj_consume_token(RUNSIGNEDSHIFTASSIGN);
1824 break;
1825 case ANDASSIGN:
1826 jj_consume_token(ANDASSIGN);
1827 break;
1828 case XORASSIGN:
1829 jj_consume_token(XORASSIGN);
1830 break;
1831 case ORASSIGN:
1832 jj_consume_token(ORASSIGN);
1833 break;
1834 default:
1835 jj_consume_token(-1);
1836 throw new ParseException();
1837 }
1838 } finally {
1839 trace_return("AssignmentOperator");
1840 }
1841 }
1842
1843 final public void ConditionalExpression() throws ParseException {
1844 trace_call("ConditionalExpression");
1845 try {
1846 ConditionalOrExpression();
1847 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1848 case HOOK:
1849 jj_consume_token(HOOK);
1850 Expression();
1851 jj_consume_token(COLON);
1852 Expression();
1853 break;
1854 default:
1855 ;
1856 }
1857 } finally {
1858 trace_return("ConditionalExpression");
1859 }
1860 }
1861
1862 final public void ConditionalOrExpression() throws ParseException {
1863 trace_call("ConditionalOrExpression");
1864 try {
1865 ConditionalAndExpression();
1866 label_26:
1867 while (true) {
1868 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1869 case SC_OR:
1870 ;
1871 break;
1872 default:
1873 break label_26;
1874 }
1875 jj_consume_token(SC_OR);
1876 ConditionalAndExpression();
1877 }
1878 } finally {
1879 trace_return("ConditionalOrExpression");
1880 }
1881 }
1882
1883 final public void ConditionalAndExpression() throws ParseException {
1884 trace_call("ConditionalAndExpression");
1885 try {
1886 InclusiveOrExpression();
1887 label_27:
1888 while (true) {
1889 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1890 case SC_AND:
1891 ;
1892 break;
1893 default:
1894 break label_27;
1895 }
1896 jj_consume_token(SC_AND);
1897 InclusiveOrExpression();
1898 }
1899 } finally {
1900 trace_return("ConditionalAndExpression");
1901 }
1902 }
1903
1904 final public void InclusiveOrExpression() throws ParseException {
1905 trace_call("InclusiveOrExpression");
1906 try {
1907 ExclusiveOrExpression();
1908 label_28:
1909 while (true) {
1910 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1911 case BIT_OR:
1912 ;
1913 break;
1914 default:
1915 break label_28;
1916 }
1917 jj_consume_token(BIT_OR);
1918 ExclusiveOrExpression();
1919 }
1920 } finally {
1921 trace_return("InclusiveOrExpression");
1922 }
1923 }
1924
1925 final public void ExclusiveOrExpression() throws ParseException {
1926 trace_call("ExclusiveOrExpression");
1927 try {
1928 AndExpression();
1929 label_29:
1930 while (true) {
1931 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1932 case XOR:
1933 ;
1934 break;
1935 default:
1936 break label_29;
1937 }
1938 jj_consume_token(XOR);
1939 AndExpression();
1940 }
1941 } finally {
1942 trace_return("ExclusiveOrExpression");
1943 }
1944 }
1945
1946 final public void AndExpression() throws ParseException {
1947 trace_call("AndExpression");
1948 try {
1949 EqualityExpression();
1950 label_30:
1951 while (true) {
1952 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1953 case BIT_AND:
1954 ;
1955 break;
1956 default:
1957 break label_30;
1958 }
1959 jj_consume_token(BIT_AND);
1960 EqualityExpression();
1961 }
1962 } finally {
1963 trace_return("AndExpression");
1964 }
1965 }
1966
1967 final public void EqualityExpression() throws ParseException {
1968 trace_call("EqualityExpression");
1969 try {
1970 InstanceOfExpression();
1971 label_31:
1972 while (true) {
1973 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1974 case EQ:
1975 case NE:
1976 ;
1977 break;
1978 default:
1979 break label_31;
1980 }
1981 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1982 case EQ:
1983 jj_consume_token(EQ);
1984 break;
1985 case NE:
1986 jj_consume_token(NE);
1987 break;
1988 default:
1989 jj_consume_token(-1);
1990 throw new ParseException();
1991 }
1992 InstanceOfExpression();
1993 }
1994 } finally {
1995 trace_return("EqualityExpression");
1996 }
1997 }
1998
1999 final public void InstanceOfExpression() throws ParseException {
2000 trace_call("InstanceOfExpression");
2001 try {
2002 RelationalExpression();
2003 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2004 case INSTANCEOF:
2005 jj_consume_token(INSTANCEOF);
2006 Type();
2007 break;
2008 default:
2009 ;
2010 }
2011 } finally {
2012 trace_return("InstanceOfExpression");
2013 }
2014 }
2015
2016 final public void RelationalExpression() throws ParseException {
2017 trace_call("RelationalExpression");
2018 try {
2019 ShiftExpression();
2020 label_32:
2021 while (true) {
2022 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2023 case LT:
2024 case LE:
2025 case GE:
2026 case GT:
2027 ;
2028 break;
2029 default:
2030 break label_32;
2031 }
2032 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2033 case LT:
2034 jj_consume_token(LT);
2035 break;
2036 case GT:
2037 jj_consume_token(GT);
2038 break;
2039 case LE:
2040 jj_consume_token(LE);
2041 break;
2042 case GE:
2043 jj_consume_token(GE);
2044 break;
2045 default:
2046 jj_consume_token(-1);
2047 throw new ParseException();
2048 }
2049 ShiftExpression();
2050 }
2051 } finally {
2052 trace_return("RelationalExpression");
2053 }
2054 }
2055
2056 final public void ShiftExpression() throws ParseException {
2057 trace_call("ShiftExpression");
2058 try {
2059 AdditiveExpression();
2060 label_33:
2061 while (true) {
2062 if (jj_2_18(1)) {
2063 ;
2064 } else {
2065 break label_33;
2066 }
2067 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2068 case LSHIFT:
2069 jj_consume_token(LSHIFT);
2070 break;
2071 default:
2072 if (jj_2_19(1)) {
2073 RSIGNEDSHIFT();
2074 } else if (jj_2_20(1)) {
2075 RUNSIGNEDSHIFT();
2076 } else {
2077 jj_consume_token(-1);
2078 throw new ParseException();
2079 }
2080 }
2081 AdditiveExpression();
2082 }
2083 } finally {
2084 trace_return("ShiftExpression");
2085 }
2086 }
2087
2088 final public void AdditiveExpression() throws ParseException {
2089 trace_call("AdditiveExpression");
2090 try {
2091 MultiplicativeExpression();
2092 label_34:
2093 while (true) {
2094 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2095 case PLUS:
2096 case MINUS:
2097 ;
2098 break;
2099 default:
2100 break label_34;
2101 }
2102 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2103 case PLUS:
2104 jj_consume_token(PLUS);
2105 break;
2106 case MINUS:
2107 jj_consume_token(MINUS);
2108 break;
2109 default:
2110 jj_consume_token(-1);
2111 throw new ParseException();
2112 }
2113 MultiplicativeExpression();
2114 }
2115 } finally {
2116 trace_return("AdditiveExpression");
2117 }
2118 }
2119
2120 final public void MultiplicativeExpression() throws ParseException {
2121 trace_call("MultiplicativeExpression");
2122 try {
2123 UnaryExpression();
2124 label_35:
2125 while (true) {
2126 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2127 case STAR:
2128 case SLASH:
2129 case REM:
2130 ;
2131 break;
2132 default:
2133 break label_35;
2134 }
2135 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2136 case STAR:
2137 jj_consume_token(STAR);
2138 break;
2139 case SLASH:
2140 jj_consume_token(SLASH);
2141 break;
2142 case REM:
2143 jj_consume_token(REM);
2144 break;
2145 default:
2146 jj_consume_token(-1);
2147 throw new ParseException();
2148 }
2149 UnaryExpression();
2150 }
2151 } finally {
2152 trace_return("MultiplicativeExpression");
2153 }
2154 }
2155
2156 final public void UnaryExpression() throws ParseException {
2157 trace_call("UnaryExpression");
2158 try {
2159 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2160 case PLUS:
2161 case MINUS:
2162 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2163 case PLUS:
2164 jj_consume_token(PLUS);
2165 break;
2166 case MINUS:
2167 jj_consume_token(MINUS);
2168 break;
2169 default:
2170 jj_consume_token(-1);
2171 throw new ParseException();
2172 }
2173 UnaryExpression();
2174 break;
2175 case INCR:
2176 PreIncrementExpression();
2177 break;
2178 case DECR:
2179 PreDecrementExpression();
2180 break;
2181 case BOOLEAN:
2182 case BYTE:
2183 case CHAR:
2184 case DOUBLE:
2185 case FALSE:
2186 case FLOAT:
2187 case INT:
2188 case LONG:
2189 case NEW:
2190 case NULL:
2191 case SHORT:
2192 case SUPER:
2193 case THIS:
2194 case TRUE:
2195 case VOID:
2196 case INTEGER_LITERAL:
2197 case FLOATING_POINT_LITERAL:
2198 case CHARACTER_LITERAL:
2199 case STRING_LITERAL:
2200 case IDENTIFIER:
2201 case LPAREN:
2202 case BANG:
2203 case TILDE:
2204 UnaryExpressionNotPlusMinus();
2205 break;
2206 default:
2207 jj_consume_token(-1);
2208 throw new ParseException();
2209 }
2210 } finally {
2211 trace_return("UnaryExpression");
2212 }
2213 }
2214
2215 final public void PreIncrementExpression() throws ParseException {
2216 trace_call("PreIncrementExpression");
2217 try {
2218 jj_consume_token(INCR);
2219 PrimaryExpression();
2220 } finally {
2221 trace_return("PreIncrementExpression");
2222 }
2223 }
2224
2225 final public void PreDecrementExpression() throws ParseException {
2226 trace_call("PreDecrementExpression");
2227 try {
2228 jj_consume_token(DECR);
2229 PrimaryExpression();
2230 } finally {
2231 trace_return("PreDecrementExpression");
2232 }
2233 }
2234
2235 final public void UnaryExpressionNotPlusMinus() throws ParseException {
2236 trace_call("UnaryExpressionNotPlusMinus");
2237 try {
2238 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2239 case BANG:
2240 case TILDE:
2241 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2242 case TILDE:
2243 jj_consume_token(TILDE);
2244 break;
2245 case BANG:
2246 jj_consume_token(BANG);
2247 break;
2248 default:
2249 jj_consume_token(-1);
2250 throw new ParseException();
2251 }
2252 UnaryExpression();
2253 break;
2254 default:
2255 if (jj_2_21(2147483647)) {
2256 CastExpression();
2257 } else {
2258 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2259 case BOOLEAN:
2260 case BYTE:
2261 case CHAR:
2262 case DOUBLE:
2263 case FALSE:
2264 case FLOAT:
2265 case INT:
2266 case LONG:
2267 case NEW:
2268 case NULL:
2269 case SHORT:
2270 case SUPER:
2271 case THIS:
2272 case TRUE:
2273 case VOID:
2274 case INTEGER_LITERAL:
2275 case FLOATING_POINT_LITERAL:
2276 case CHARACTER_LITERAL:
2277 case STRING_LITERAL:
2278 case IDENTIFIER:
2279 case LPAREN:
2280 PostfixExpression();
2281 break;
2282 default:
2283 jj_consume_token(-1);
2284 throw new ParseException();
2285 }
2286 }
2287 }
2288 } finally {
2289 trace_return("UnaryExpressionNotPlusMinus");
2290 }
2291 }
2292
2293 // This production is to determine lookahead only. The LOOKAHEAD specifications
2294 // below are not used, but they are there just to indicate that we know about
2295 // this.
2296 final public void CastLookahead() throws ParseException {
2297 trace_call("CastLookahead");
2298 try {
2299 if (jj_2_22(2)) {
2300 jj_consume_token(LPAREN);
2301 PrimitiveType();
2302 } else if (jj_2_23(2147483647)) {
2303 jj_consume_token(LPAREN);
2304 Type();
2305 jj_consume_token(LBRACKET);
2306 jj_consume_token(RBRACKET);
2307 } else {
2308 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2309 case LPAREN:
2310 jj_consume_token(LPAREN);
2311 Type();
2312 jj_consume_token(RPAREN);
2313 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2314 case TILDE:
2315 jj_consume_token(TILDE);
2316 break;
2317 case BANG:
2318 jj_consume_token(BANG);
2319 break;
2320 case LPAREN:
2321 jj_consume_token(LPAREN);
2322 break;
2323 case IDENTIFIER:
2324 jj_consume_token(IDENTIFIER);
2325 break;
2326 case THIS:
2327 jj_consume_token(THIS);
2328 break;
2329 case SUPER:
2330 jj_consume_token(SUPER);
2331 break;
2332 case NEW:
2333 jj_consume_token(NEW);
2334 break;
2335 case FALSE:
2336 case NULL:
2337 case TRUE:
2338 case INTEGER_LITERAL:
2339 case FLOATING_POINT_LITERAL:
2340 case CHARACTER_LITERAL:
2341 case STRING_LITERAL:
2342 Literal();
2343 break;
2344 default:
2345 jj_consume_token(-1);
2346 throw new ParseException();
2347 }
2348 break;
2349 default:
2350 jj_consume_token(-1);
2351 throw new ParseException();
2352 }
2353 }
2354 } finally {
2355 trace_return("CastLookahead");
2356 }
2357 }
2358
2359 final public void PostfixExpression() throws ParseException {
2360 trace_call("PostfixExpression");
2361 try {
2362 PrimaryExpression();
2363 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2364 case INCR:
2365 case DECR:
2366 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2367 case INCR:
2368 jj_consume_token(INCR);
2369 break;
2370 case DECR:
2371 jj_consume_token(DECR);
2372 break;
2373 default:
2374 jj_consume_token(-1);
2375 throw new ParseException();
2376 }
2377 break;
2378 default:
2379 ;
2380 }
2381 } finally {
2382 trace_return("PostfixExpression");
2383 }
2384 }
2385
2386 final public void CastExpression() throws ParseException {
2387 trace_call("CastExpression");
2388 try {
2389 if (jj_2_24(2147483647)) {
2390 jj_consume_token(LPAREN);
2391 Type();
2392 jj_consume_token(RPAREN);
2393 UnaryExpression();
2394 } else {
2395 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2396 case LPAREN:
2397 jj_consume_token(LPAREN);
2398 Type();
2399 jj_consume_token(RPAREN);
2400 UnaryExpressionNotPlusMinus();
2401 break;
2402 default:
2403 jj_consume_token(-1);
2404 throw new ParseException();
2405 }
2406 }
2407 } finally {
2408 trace_return("CastExpression");
2409 }
2410 }
2411
2412 final public void PrimaryExpression() throws ParseException {
2413 trace_call("PrimaryExpression");
2414 try {
2415 PrimaryPrefix();
2416 label_36:
2417 while (true) {
2418 if (jj_2_25(2)) {
2419 ;
2420 } else {
2421 break label_36;
2422 }
2423 PrimarySuffix();
2424 }
2425 } finally {
2426 trace_return("PrimaryExpression");
2427 }
2428 }
2429
2430 final public void MemberSelector() throws ParseException {
2431 trace_call("MemberSelector");
2432 try {
2433 jj_consume_token(DOT);
2434 TypeArguments();
2435 jj_consume_token(IDENTIFIER);
2436 } finally {
2437 trace_return("MemberSelector");
2438 }
2439 }
2440
2441 final public void PrimaryPrefix() throws ParseException {
2442 trace_call("PrimaryPrefix");
2443 try {
2444 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2445 case FALSE:
2446 case NULL:
2447 case TRUE:
2448 case INTEGER_LITERAL:
2449 case FLOATING_POINT_LITERAL:
2450 case CHARACTER_LITERAL:
2451 case STRING_LITERAL:
2452 Literal();
2453 break;
2454 default:
2455 if (jj_2_26(2147483647)) {
2456 label_37:
2457 while (true) {
2458 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2459 case IDENTIFIER:
2460 ;
2461 break;
2462 default:
2463 break label_37;
2464 }
2465 jj_consume_token(IDENTIFIER);
2466 jj_consume_token(DOT);
2467 }
2468 jj_consume_token(THIS);
2469 } else {
2470 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2471 case SUPER:
2472 jj_consume_token(SUPER);
2473 jj_consume_token(DOT);
2474 jj_consume_token(IDENTIFIER);
2475 break;
2476 case LPAREN:
2477 jj_consume_token(LPAREN);
2478 Expression();
2479 jj_consume_token(RPAREN);
2480 break;
2481 case NEW:
2482 AllocationExpression();
2483 break;
2484 default:
2485 if (jj_2_27(2147483647)) {
2486 ResultType();
2487 jj_consume_token(DOT);
2488 jj_consume_token(CLASS);
2489 } else {
2490 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2491 case IDENTIFIER:
2492 Name();
2493 break;
2494 default:
2495 jj_consume_token(-1);
2496 throw new ParseException();
2497 }
2498 }
2499 }
2500 }
2501 }
2502 } finally {
2503 trace_return("PrimaryPrefix");
2504 }
2505 }
2506
2507 final public void PrimarySuffix() throws ParseException {
2508 trace_call("PrimarySuffix");
2509 try {
2510 if (jj_2_28(2147483647)) {
2511 jj_consume_token(DOT);
2512 jj_consume_token(SUPER);
2513 } else if (jj_2_29(2147483647)) {
2514 jj_consume_token(DOT);
2515 jj_consume_token(THIS);
2516 } else if (jj_2_30(2)) {
2517 jj_consume_token(DOT);
2518 AllocationExpression();
2519 } else if (jj_2_31(3)) {
2520 MemberSelector();
2521 } else {
2522 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2523 case LBRACKET:
2524 jj_consume_token(LBRACKET);
2525 Expression();
2526 jj_consume_token(RBRACKET);
2527 break;
2528 case DOT:
2529 jj_consume_token(DOT);
2530 jj_consume_token(IDENTIFIER);
2531 break;
2532 case LPAREN:
2533 Arguments();
2534 break;
2535 default:
2536 jj_consume_token(-1);
2537 throw new ParseException();
2538 }
2539 }
2540 } finally {
2541 trace_return("PrimarySuffix");
2542 }
2543 }
2544
2545 final public void Literal() throws ParseException {
2546 trace_call("Literal");
2547 try {
2548 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2549 case INTEGER_LITERAL:
2550 jj_consume_token(INTEGER_LITERAL);
2551 break;
2552 case FLOATING_POINT_LITERAL:
2553 jj_consume_token(FLOATING_POINT_LITERAL);
2554 break;
2555 case CHARACTER_LITERAL:
2556 jj_consume_token(CHARACTER_LITERAL);
2557 break;
2558 case STRING_LITERAL:
2559 jj_consume_token(STRING_LITERAL);
2560 break;
2561 case FALSE:
2562 case TRUE:
2563 BooleanLiteral();
2564 break;
2565 case NULL:
2566 NullLiteral();
2567 break;
2568 default:
2569 jj_consume_token(-1);
2570 throw new ParseException();
2571 }
2572 } finally {
2573 trace_return("Literal");
2574 }
2575 }
2576
2577 final public void BooleanLiteral() throws ParseException {
2578 trace_call("BooleanLiteral");
2579 try {
2580 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2581 case TRUE:
2582 jj_consume_token(TRUE);
2583 break;
2584 case FALSE:
2585 jj_consume_token(FALSE);
2586 break;
2587 default:
2588 jj_consume_token(-1);
2589 throw new ParseException();
2590 }
2591 } finally {
2592 trace_return("BooleanLiteral");
2593 }
2594 }
2595
2596 final public void NullLiteral() throws ParseException {
2597 trace_call("NullLiteral");
2598 try {
2599 jj_consume_token(NULL);
2600 } finally {
2601 trace_return("NullLiteral");
2602 }
2603 }
2604
2605 final public void Arguments() throws ParseException {
2606 trace_call("Arguments");
2607 try {
2608 jj_consume_token(LPAREN);
2609 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2610 case BOOLEAN:
2611 case BYTE:
2612 case CHAR:
2613 case DOUBLE:
2614 case FALSE:
2615 case FLOAT:
2616 case INT:
2617 case LONG:
2618 case NEW:
2619 case NULL:
2620 case SHORT:
2621 case SUPER:
2622 case THIS:
2623 case TRUE:
2624 case VOID:
2625 case INTEGER_LITERAL:
2626 case FLOATING_POINT_LITERAL:
2627 case CHARACTER_LITERAL:
2628 case STRING_LITERAL:
2629 case IDENTIFIER:
2630 case LPAREN:
2631 case BANG:
2632 case TILDE:
2633 case INCR:
2634 case DECR:
2635 case PLUS:
2636 case MINUS:
2637 ArgumentList();
2638 break;
2639 default:
2640 ;
2641 }
2642 jj_consume_token(RPAREN);
2643 } finally {
2644 trace_return("Arguments");
2645 }
2646 }
2647
2648 final public void ArgumentList() throws ParseException {
2649 trace_call("ArgumentList");
2650 try {
2651 Expression();
2652 label_38:
2653 while (true) {
2654 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2655 case COMMA:
2656 ;
2657 break;
2658 default:
2659 break label_38;
2660 }
2661 jj_consume_token(COMMA);
2662 Expression();
2663 }
2664 } finally {
2665 trace_return("ArgumentList");
2666 }
2667 }
2668
2669 final public void AllocationExpression() throws ParseException {
2670 trace_call("AllocationExpression");
2671 try {
2672 if (jj_2_32(2)) {
2673 jj_consume_token(NEW);
2674 PrimitiveType();
2675 ArrayDimsAndInits();
2676 } else {
2677 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2678 case NEW:
2679 jj_consume_token(NEW);
2680 ClassOrInterfaceType();
2681 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2682 case LT:
2683 TypeArguments();
2684 break;
2685 default:
2686 ;
2687 }
2688 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2689 case LBRACKET:
2690 ArrayDimsAndInits();
2691 break;
2692 case LPAREN:
2693 Arguments();
2694 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2695 case LBRACE:
2696 ClassOrInterfaceBody(false);
2697 break;
2698 default:
2699 ;
2700 }
2701 break;
2702 default:
2703 jj_consume_token(-1);
2704 throw new ParseException();
2705 }
2706 break;
2707 default:
2708 jj_consume_token(-1);
2709 throw new ParseException();
2710 }
2711 }
2712 } finally {
2713 trace_return("AllocationExpression");
2714 }
2715 }
2716
2717 /*
2718 * The third LOOKAHEAD specification below is to parse to PrimarySuffix
2719 * if there is an expression between the "[...]".
2720 */
2721 final public void ArrayDimsAndInits() throws ParseException {
2722 trace_call("ArrayDimsAndInits");
2723 try {
2724 if (jj_2_35(2)) {
2725 label_39:
2726 while (true) {
2727 jj_consume_token(LBRACKET);
2728 Expression();
2729 jj_consume_token(RBRACKET);
2730 if (jj_2_33(2)) {
2731 ;
2732 } else {
2733 break label_39;
2734 }
2735 }
2736 label_40:
2737 while (true) {
2738 if (jj_2_34(2)) {
2739 ;
2740 } else {
2741 break label_40;
2742 }
2743 jj_consume_token(LBRACKET);
2744 jj_consume_token(RBRACKET);
2745 }
2746 } else {
2747 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2748 case LBRACKET:
2749 label_41:
2750 while (true) {
2751 jj_consume_token(LBRACKET);
2752 jj_consume_token(RBRACKET);
2753 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2754 case LBRACKET:
2755 ;
2756 break;
2757 default:
2758 break label_41;
2759 }
2760 }
2761 ArrayInitializer();
2762 break;
2763 default:
2764 jj_consume_token(-1);
2765 throw new ParseException();
2766 }
2767 }
2768 } finally {
2769 trace_return("ArrayDimsAndInits");
2770 }
2771 }
2772
2773 /*
2774 * Statement syntax follows.
2775 */
2776 final public void Statement() throws ParseException {
2777 trace_call("Statement");
2778 try {
2779 if (jj_2_36(2)) {
2780 LabeledStatement();
2781 } else {
2782 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2783 case ASSERT:
2784 AssertStatement();
2785 break;
2786 case LBRACE:
2787 Block();
2788 break;
2789 case SEMICOLON:
2790 EmptyStatement();
2791 break;
2792 case BOOLEAN:
2793 case BYTE:
2794 case CHAR:
2795 case DOUBLE:
2796 case FALSE:
2797 case FLOAT:
2798 case INT:
2799 case LONG:
2800 case NEW:
2801 case NULL:
2802 case SHORT:
2803 case SUPER:
2804 case THIS:
2805 case TRUE:
2806 case VOID:
2807 case INTEGER_LITERAL:
2808 case FLOATING_POINT_LITERAL:
2809 case CHARACTER_LITERAL:
2810 case STRING_LITERAL:
2811 case IDENTIFIER:
2812 case LPAREN:
2813 case INCR:
2814 case DECR:
2815 StatementExpression();
2816 jj_consume_token(SEMICOLON);
2817 break;
2818 case SWITCH:
2819 SwitchStatement();
2820 break;
2821 case IF:
2822 IfStatement();
2823 break;
2824 case WHILE:
2825 WhileStatement();
2826 break;
2827 case DO:
2828 DoStatement();
2829 break;
2830 case FOR:
2831 ForStatement();
2832 break;
2833 case BREAK:
2834 BreakStatement();
2835 break;
2836 case CONTINUE:
2837 ContinueStatement();
2838 break;
2839 case RETURN:
2840 ReturnStatement();
2841 break;
2842 case THROW:
2843 ThrowStatement();
2844 break;
2845 case SYNCHRONIZED:
2846 SynchronizedStatement();
2847 break;
2848 case TRY:
2849 TryStatement();
2850 break;
2851 default:
2852 jj_consume_token(-1);
2853 throw new ParseException();
2854 }
2855 }
2856 } finally {
2857 trace_return("Statement");
2858 }
2859 }
2860
2861 final public void AssertStatement() throws ParseException {
2862 trace_call("AssertStatement");
2863 try {
2864 jj_consume_token(ASSERT);
2865 Expression();
2866 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2867 case COLON:
2868 jj_consume_token(COLON);
2869 Expression();
2870 break;
2871 default:
2872 ;
2873 }
2874 jj_consume_token(SEMICOLON);
2875 } finally {
2876 trace_return("AssertStatement");
2877 }
2878 }
2879
2880 final public void LabeledStatement() throws ParseException {
2881 trace_call("LabeledStatement");
2882 try {
2883 jj_consume_token(IDENTIFIER);
2884 jj_consume_token(COLON);
2885 Statement();
2886 } finally {
2887 trace_return("LabeledStatement");
2888 }
2889 }
2890
2891 final public void Block() throws ParseException {
2892 trace_call("Block");
2893 try {
2894 jj_consume_token(LBRACE);
2895 label_42:
2896 while (true) {
2897 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2898 case ABSTRACT:
2899 case ASSERT:
2900 case BOOLEAN:
2901 case BREAK:
2902 case BYTE:
2903 case CHAR:
2904 case CLASS:
2905 case CONTINUE:
2906 case DO:
2907 case DOUBLE:
2908 case FALSE:
2909 case FINAL:
2910 case FLOAT:
2911 case FOR:
2912 case IF:
2913 case INT:
2914 case INTERFACE:
2915 case LONG:
2916 case NATIVE:
2917 case NEW:
2918 case NULL:
2919 case PRIVATE:
2920 case PROTECTED:
2921 case PUBLIC:
2922 case RETURN:
2923 case SHORT:
2924 case STATIC:
2925 case STRICTFP:
2926 case SUPER:
2927 case SWITCH:
2928 case SYNCHRONIZED:
2929 case THIS:
2930 case THROW:
2931 case TRANSIENT:
2932 case TRUE:
2933 case TRY:
2934 case VOID:
2935 case VOLATILE:
2936 case WHILE:
2937 case INTEGER_LITERAL:
2938 case FLOATING_POINT_LITERAL:
2939 case CHARACTER_LITERAL:
2940 case STRING_LITERAL:
2941 case IDENTIFIER:
2942 case LPAREN:
2943 case LBRACE:
2944 case SEMICOLON:
2945 case AT:
2946 case INCR:
2947 case DECR:
2948 ;
2949 break;
2950 default:
2951 break label_42;
2952 }
2953 BlockStatement();
2954 }
2955 jj_consume_token(RBRACE);
2956 } finally {
2957 trace_return("Block");
2958 }
2959 }
2960
2961 final public void BlockStatement() throws ParseException {
2962 trace_call("BlockStatement");
2963 try {
2964 if (jj_2_37(2147483647)) {
2965 LocalVariableDeclaration();
2966 jj_consume_token(SEMICOLON);
2967 } else {
2968 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2969 case ASSERT:
2970 case BOOLEAN:
2971 case BREAK:
2972 case BYTE:
2973 case CHAR:
2974 case CONTINUE:
2975 case DO:
2976 case DOUBLE:
2977 case FALSE:
2978 case FLOAT:
2979 case FOR:
2980 case IF:
2981 case INT:
2982 case LONG:
2983 case NEW:
2984 case NULL:
2985 case RETURN:
2986 case SHORT:
2987 case SUPER:
2988 case SWITCH:
2989 case SYNCHRONIZED:
2990 case THIS:
2991 case THROW:
2992 case TRUE:
2993 case TRY:
2994 case VOID:
2995 case WHILE:
2996 case INTEGER_LITERAL:
2997 case FLOATING_POINT_LITERAL:
2998 case CHARACTER_LITERAL:
2999 case STRING_LITERAL:
3000 case IDENTIFIER:
3001 case LPAREN:
3002 case LBRACE:
3003 case SEMICOLON:
3004 case INCR:
3005 case DECR:
3006 Statement();
3007 break;
3008 case CLASS:
3009 case INTERFACE:
3010 ClassOrInterfaceDeclaration(0);
3011 break;
3012 default:
3013 jj_consume_token(-1);
3014 throw new ParseException();
3015 }
3016 }
3017 } finally {
3018 trace_return("BlockStatement");
3019 }
3020 }
3021
3022 final public void LocalVariableDeclaration() throws ParseException {
3023 trace_call("LocalVariableDeclaration");
3024 try {
3025 Modifiers();
3026 Type();
3027 VariableDeclarator();
3028 label_43:
3029 while (true) {
3030 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3031 case COMMA:
3032 ;
3033 break;
3034 default:
3035 break label_43;
3036 }
3037 jj_consume_token(COMMA);
3038 VariableDeclarator();
3039 }
3040 } finally {
3041 trace_return("LocalVariableDeclaration");
3042 }
3043 }
3044
3045 final public void EmptyStatement() throws ParseException {
3046 trace_call("EmptyStatement");
3047 try {
3048 jj_consume_token(SEMICOLON);
3049 } finally {
3050 trace_return("EmptyStatement");
3051 }
3052 }
3053
3054 final public void StatementExpression() throws ParseException {
3055 trace_call("StatementExpression");
3056 try {
3057 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3058 case INCR:
3059 PreIncrementExpression();
3060 break;
3061 case DECR:
3062 PreDecrementExpression();
3063 break;
3064 case BOOLEAN:
3065 case BYTE:
3066 case CHAR:
3067 case DOUBLE:
3068 case FALSE:
3069 case FLOAT:
3070 case INT:
3071 case LONG:
3072 case NEW:
3073 case NULL:
3074 case SHORT:
3075 case SUPER:
3076 case THIS:
3077 case TRUE:
3078 case VOID:
3079 case INTEGER_LITERAL:
3080 case FLOATING_POINT_LITERAL:
3081 case CHARACTER_LITERAL:
3082 case STRING_LITERAL:
3083 case IDENTIFIER:
3084 case LPAREN:
3085 PrimaryExpression();
3086 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3087 case ASSIGN:
3088 case INCR:
3089 case DECR:
3090 case PLUSASSIGN:
3091 case MINUSASSIGN:
3092 case STARASSIGN:
3093 case SLASHASSIGN:
3094 case ANDASSIGN:
3095 case ORASSIGN:
3096 case XORASSIGN:
3097 case REMASSIGN:
3098 case LSHIFTASSIGN:
3099 case RSIGNEDSHIFTASSIGN:
3100 case RUNSIGNEDSHIFTASSIGN:
3101 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3102 case INCR:
3103 jj_consume_token(INCR);
3104 break;
3105 case DECR:
3106 jj_consume_token(DECR);
3107 break;
3108 case ASSIGN:
3109 case PLUSASSIGN:
3110 case MINUSASSIGN:
3111 case STARASSIGN:
3112 case SLASHASSIGN:
3113 case ANDASSIGN:
3114 case ORASSIGN:
3115 case XORASSIGN:
3116 case REMASSIGN:
3117 case LSHIFTASSIGN:
3118 case RSIGNEDSHIFTASSIGN:
3119 case RUNSIGNEDSHIFTASSIGN:
3120 AssignmentOperator();
3121 Expression();
3122 break;
3123 default:
3124 jj_consume_token(-1);
3125 throw new ParseException();
3126 }
3127 break;
3128 default:
3129 ;
3130 }
3131 break;
3132 default:
3133 jj_consume_token(-1);
3134 throw new ParseException();
3135 }
3136 } finally {
3137 trace_return("StatementExpression");
3138 }
3139 }
3140
3141 final public void SwitchStatement() throws ParseException {
3142 trace_call("SwitchStatement");
3143 try {
3144 jj_consume_token(SWITCH);
3145 jj_consume_token(LPAREN);
3146 Expression();
3147 jj_consume_token(RPAREN);
3148 jj_consume_token(LBRACE);
3149 label_44:
3150 while (true) {
3151 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3152 case CASE:
3153 case _DEFAULT:
3154 ;
3155 break;
3156 default:
3157 break label_44;
3158 }
3159 SwitchLabel();
3160 label_45:
3161 while (true) {
3162 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3163 case ABSTRACT:
3164 case ASSERT:
3165 case BOOLEAN:
3166 case BREAK:
3167 case BYTE:
3168 case CHAR:
3169 case CLASS:
3170 case CONTINUE:
3171 case DO:
3172 case DOUBLE:
3173 case FALSE:
3174 case FINAL:
3175 case FLOAT:
3176 case FOR:
3177 case IF:
3178 case INT:
3179 case INTERFACE:
3180 case LONG:
3181 case NATIVE:
3182 case NEW:
3183 case NULL:
3184 case PRIVATE:
3185 case PROTECTED:
3186 case PUBLIC:
3187 case RETURN:
3188 case SHORT:
3189 case STATIC:
3190 case STRICTFP:
3191 case SUPER:
3192 case SWITCH:
3193 case SYNCHRONIZED:
3194 case THIS:
3195 case THROW:
3196 case TRANSIENT:
3197 case TRUE:
3198 case TRY:
3199 case VOID:
3200 case VOLATILE:
3201 case WHILE:
3202 case INTEGER_LITERAL:
3203 case FLOATING_POINT_LITERAL:
3204 case CHARACTER_LITERAL:
3205 case STRING_LITERAL:
3206 case IDENTIFIER:
3207 case LPAREN:
3208 case LBRACE:
3209 case SEMICOLON:
3210 case AT:
3211 case INCR:
3212 case DECR:
3213 ;
3214 break;
3215 default:
3216 break label_45;
3217 }
3218 BlockStatement();
3219 }
3220 }
3221 jj_consume_token(RBRACE);
3222 } finally {
3223 trace_return("SwitchStatement");
3224 }
3225 }
3226
3227 final public void SwitchLabel() throws ParseException {
3228 trace_call("SwitchLabel");
3229 try {
3230 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3231 case CASE:
3232 jj_consume_token(CASE);
3233 Expression();
3234 jj_consume_token(COLON);
3235 break;
3236 case _DEFAULT:
3237 jj_consume_token(_DEFAULT);
3238 jj_consume_token(COLON);
3239 break;
3240 default:
3241 jj_consume_token(-1);
3242 throw new ParseException();
3243 }
3244 } finally {
3245 trace_return("SwitchLabel");
3246 }
3247 }
3248
3249 final public void IfStatement() throws ParseException {
3250 trace_call("IfStatement");
3251 try {
3252 jj_consume_token(IF);
3253 jj_consume_token(LPAREN);
3254 Expression();
3255 jj_consume_token(RPAREN);
3256 Statement();
3257 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3258 case ELSE:
3259 jj_consume_token(ELSE);
3260 Statement();
3261 break;
3262 default:
3263 ;
3264 }
3265 } finally {
3266 trace_return("IfStatement");
3267 }
3268 }
3269
3270 final public void WhileStatement() throws ParseException {
3271 trace_call("WhileStatement");
3272 try {
3273 jj_consume_token(WHILE);
3274 jj_consume_token(LPAREN);
3275 Expression();
3276 jj_consume_token(RPAREN);
3277 Statement();
3278 } finally {
3279 trace_return("WhileStatement");
3280 }
3281 }
3282
3283 final public void DoStatement() throws ParseException {
3284 trace_call("DoStatement");
3285 try {
3286 jj_consume_token(DO);
3287 Statement();
3288 jj_consume_token(WHILE);
3289 jj_consume_token(LPAREN);
3290 Expression();
3291 jj_consume_token(RPAREN);
3292 jj_consume_token(SEMICOLON);
3293 } finally {
3294 trace_return("DoStatement");
3295 }
3296 }
3297
3298 final public void ForStatement() throws ParseException {
3299 trace_call("ForStatement");
3300 try {
3301 jj_consume_token(FOR);
3302 jj_consume_token(LPAREN);
3303 if (jj_2_38(2147483647)) {
3304 Modifiers();
3305 Type();
3306 jj_consume_token(IDENTIFIER);
3307 jj_consume_token(COLON);
3308 Expression();
3309 } else {
3310 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3311 case ABSTRACT:
3312 case BOOLEAN:
3313 case BYTE:
3314 case CHAR:
3315 case DOUBLE:
3316 case FALSE:
3317 case FINAL:
3318 case FLOAT:
3319 case INT:
3320 case LONG:
3321 case NATIVE:
3322 case NEW:
3323 case NULL:
3324 case PRIVATE:
3325 case PROTECTED:
3326 case PUBLIC:
3327 case SHORT:
3328 case STATIC:
3329 case STRICTFP:
3330 case SUPER:
3331 case SYNCHRONIZED:
3332 case THIS:
3333 case TRANSIENT:
3334 case TRUE:
3335 case VOID:
3336 case VOLATILE:
3337 case INTEGER_LITERAL:
3338 case FLOATING_POINT_LITERAL:
3339 case CHARACTER_LITERAL:
3340 case STRING_LITERAL:
3341 case IDENTIFIER:
3342 case LPAREN:
3343 case SEMICOLON:
3344 case AT:
3345 case INCR:
3346 case DECR:
3347 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3348 case ABSTRACT:
3349 case BOOLEAN:
3350 case BYTE:
3351 case CHAR:
3352 case DOUBLE:
3353 case FALSE:
3354 case FINAL:
3355 case FLOAT:
3356 case INT:
3357 case LONG:
3358 case NATIVE:
3359 case NEW:
3360 case NULL:
3361 case PRIVATE:
3362 case PROTECTED:
3363 case PUBLIC:
3364 case SHORT:
3365 case STATIC:
3366 case STRICTFP:
3367 case SUPER:
3368 case SYNCHRONIZED:
3369 case THIS:
3370 case TRANSIENT:
3371 case TRUE:
3372 case VOID:
3373 case VOLATILE:
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 AT:
3381 case INCR:
3382 case DECR:
3383 ForInit();
3384 break;
3385 default:
3386 ;
3387 }
3388 jj_consume_token(SEMICOLON);
3389 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3390 case BOOLEAN:
3391 case BYTE:
3392 case CHAR:
3393 case DOUBLE:
3394 case FALSE:
3395 case FLOAT:
3396 case INT:
3397 case LONG:
3398 case NEW:
3399 case NULL:
3400 case SHORT:
3401 case SUPER:
3402 case THIS:
3403 case TRUE:
3404 case VOID:
3405 case INTEGER_LITERAL:
3406 case FLOATING_POINT_LITERAL:
3407 case CHARACTER_LITERAL:
3408 case STRING_LITERAL:
3409 case IDENTIFIER:
3410 case LPAREN:
3411 case BANG:
3412 case TILDE:
3413 case INCR:
3414 case DECR:
3415 case PLUS:
3416 case MINUS:
3417 Expression();
3418 break;
3419 default:
3420 ;
3421 }
3422 jj_consume_token(SEMICOLON);
3423 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3424 case BOOLEAN:
3425 case BYTE:
3426 case CHAR:
3427 case DOUBLE:
3428 case FALSE:
3429 case FLOAT:
3430 case INT:
3431 case LONG:
3432 case NEW:
3433 case NULL:
3434 case SHORT:
3435 case SUPER:
3436 case THIS:
3437 case TRUE:
3438 case VOID:
3439 case INTEGER_LITERAL:
3440 case FLOATING_POINT_LITERAL:
3441 case CHARACTER_LITERAL:
3442 case STRING_LITERAL:
3443 case IDENTIFIER:
3444 case LPAREN:
3445 case INCR:
3446 case DECR:
3447 ForUpdate();
3448 break;
3449 default:
3450 ;
3451 }
3452 break;
3453 default:
3454 jj_consume_token(-1);
3455 throw new ParseException();
3456 }
3457 }
3458 jj_consume_token(RPAREN);
3459 Statement();
3460 } finally {
3461 trace_return("ForStatement");
3462 }
3463 }
3464
3465 final public void ForInit() throws ParseException {
3466 trace_call("ForInit");
3467 try {
3468 if (jj_2_39(2147483647)) {
3469 LocalVariableDeclaration();
3470 } else {
3471 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3472 case BOOLEAN:
3473 case BYTE:
3474 case CHAR:
3475 case DOUBLE:
3476 case FALSE:
3477 case FLOAT:
3478 case INT:
3479 case LONG:
3480 case NEW:
3481 case NULL:
3482 case SHORT:
3483 case SUPER:
3484 case THIS:
3485 case TRUE:
3486 case VOID:
3487 case INTEGER_LITERAL:
3488 case FLOATING_POINT_LITERAL:
3489 case CHARACTER_LITERAL:
3490 case STRING_LITERAL:
3491 case IDENTIFIER:
3492 case LPAREN:
3493 case INCR:
3494 case DECR:
3495 StatementExpressionList();
3496 break;
3497 default:
3498 jj_consume_token(-1);
3499 throw new ParseException();
3500 }
3501 }
3502 } finally {
3503 trace_return("ForInit");
3504 }
3505 }
3506
3507 final public void StatementExpressionList() throws ParseException {
3508 trace_call("StatementExpressionList");
3509 try {
3510 StatementExpression();
3511 label_46:
3512 while (true) {
3513 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3514 case COMMA:
3515 ;
3516 break;
3517 default:
3518 break label_46;
3519 }
3520 jj_consume_token(COMMA);
3521 StatementExpression();
3522 }
3523 } finally {
3524 trace_return("StatementExpressionList");
3525 }
3526 }
3527
3528 final public void ForUpdate() throws ParseException {
3529 trace_call("ForUpdate");
3530 try {
3531 StatementExpressionList();
3532 } finally {
3533 trace_return("ForUpdate");
3534 }
3535 }
3536
3537 final public void BreakStatement() throws ParseException {
3538 trace_call("BreakStatement");
3539 try {
3540 jj_consume_token(BREAK);
3541 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3542 case IDENTIFIER:
3543 jj_consume_token(IDENTIFIER);
3544 break;
3545 default:
3546 ;
3547 }
3548 jj_consume_token(SEMICOLON);
3549 } finally {
3550 trace_return("BreakStatement");
3551 }
3552 }
3553
3554 final public void ContinueStatement() throws ParseException {
3555 trace_call("ContinueStatement");
3556 try {
3557 jj_consume_token(CONTINUE);
3558 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3559 case IDENTIFIER:
3560 jj_consume_token(IDENTIFIER);
3561 break;
3562 default:
3563 ;
3564 }
3565 jj_consume_token(SEMICOLON);
3566 } finally {
3567 trace_return("ContinueStatement");
3568 }
3569 }
3570
3571 final public void ReturnStatement() throws ParseException {
3572 trace_call("ReturnStatement");
3573 try {
3574 jj_consume_token(RETURN);
3575 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3576 case BOOLEAN:
3577 case BYTE:
3578 case CHAR:
3579 case DOUBLE:
3580 case FALSE:
3581 case FLOAT:
3582 case INT:
3583 case LONG:
3584 case NEW:
3585 case NULL:
3586 case SHORT:
3587 case SUPER:
3588 case THIS:
3589 case TRUE:
3590 case VOID:
3591 case INTEGER_LITERAL:
3592 case FLOATING_POINT_LITERAL:
3593 case CHARACTER_LITERAL:
3594 case STRING_LITERAL:
3595 case IDENTIFIER:
3596 case LPAREN:
3597 case BANG:
3598 case TILDE:
3599 case INCR:
3600 case DECR:
3601 case PLUS:
3602 case MINUS:
3603 Expression();
3604 break;
3605 default:
3606 ;
3607 }
3608 jj_consume_token(SEMICOLON);
3609 } finally {
3610 trace_return("ReturnStatement");
3611 }
3612 }
3613
3614 final public void ThrowStatement() throws ParseException {
3615 trace_call("ThrowStatement");
3616 try {
3617 jj_consume_token(THROW);
3618 Expression();
3619 jj_consume_token(SEMICOLON);
3620 } finally {
3621 trace_return("ThrowStatement");
3622 }
3623 }
3624
3625 final public void SynchronizedStatement() throws ParseException {
3626 trace_call("SynchronizedStatement");
3627 try {
3628 jj_consume_token(SYNCHRONIZED);
3629 jj_consume_token(LPAREN);
3630 Expression();
3631 jj_consume_token(RPAREN);
3632 Block();
3633 } finally {
3634 trace_return("SynchronizedStatement");
3635 }
3636 }
3637
3638 final public void TryStatement() throws ParseException {
3639 trace_call("TryStatement");
3640 try {
3641 jj_consume_token(TRY);
3642 Block();
3643 label_47:
3644 while (true) {
3645 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3646 case CATCH:
3647 ;
3648 break;
3649 default:
3650 break label_47;
3651 }
3652 jj_consume_token(CATCH);
3653 jj_consume_token(LPAREN);
3654 FormalParameter();
3655 jj_consume_token(RPAREN);
3656 Block();
3657 }
3658 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3659 case FINALLY:
3660 jj_consume_token(FINALLY);
3661 Block();
3662 break;
3663 default:
3664 ;
3665 }
3666 } finally {
3667 trace_return("TryStatement");
3668 }
3669 }
3670
3671 /* We use productions to match >>>, >> and > so that we can keep the
3672 * type declaration syntax with generics clean
3673 */
3674 final public void RUNSIGNEDSHIFT() throws ParseException {
3675 trace_call("RUNSIGNEDSHIFT");
3676 try {
3677 if (getToken(1).kind == GT &&
3678 ((Token.GTToken)getToken(1)).realKind == RUNSIGNEDSHIFT) {
3679
3680 } else {
3681 jj_consume_token(-1);
3682 throw new ParseException();
3683 }
3684 jj_consume_token(GT);
3685 jj_consume_token(GT);
3686 jj_consume_token(GT);
3687 } finally {
3688 trace_return("RUNSIGNEDSHIFT");
3689 }
3690 }
3691
3692 final public void RSIGNEDSHIFT() throws ParseException {
3693 trace_call("RSIGNEDSHIFT");
3694 try {
3695 if (getToken(1).kind == GT &&
3696 ((Token.GTToken)getToken(1)).realKind == RSIGNEDSHIFT) {
3697
3698 } else {
3699 jj_consume_token(-1);
3700 throw new ParseException();
3701 }
3702 jj_consume_token(GT);
3703 jj_consume_token(GT);
3704 } finally {
3705 trace_return("RSIGNEDSHIFT");
3706 }
3707 }
3708
3709 /* Annotation syntax follows. */
3710 final public void Annotation() throws ParseException {
3711 trace_call("Annotation");
3712 try {
3713 if (jj_2_40(2147483647)) {
3714 NormalAnnotation();
3715 } else if (jj_2_41(2147483647)) {
3716 SingleMemberAnnotation();
3717 } else {
3718 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3719 case AT:
3720 MarkerAnnotation();
3721 break;
3722 default:
3723 jj_consume_token(-1);
3724 throw new ParseException();
3725 }
3726 }
3727 } finally {
3728 trace_return("Annotation");
3729 }
3730 }
3731
3732 final public void NormalAnnotation() throws ParseException {
3733 trace_call("NormalAnnotation");
3734 try {
3735 jj_consume_token(AT);
3736 Name();
3737 jj_consume_token(LPAREN);
3738 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3739 case IDENTIFIER:
3740 MemberValuePairs();
3741 break;
3742 default:
3743 ;
3744 }
3745 jj_consume_token(RPAREN);
3746 } finally {
3747 trace_return("NormalAnnotation");
3748 }
3749 }
3750
3751 final public void MarkerAnnotation() throws ParseException {
3752 trace_call("MarkerAnnotation");
3753 try {
3754 jj_consume_token(AT);
3755 Name();
3756 } finally {
3757 trace_return("MarkerAnnotation");
3758 }
3759 }
3760
3761 final public void SingleMemberAnnotation() throws ParseException {
3762 trace_call("SingleMemberAnnotation");
3763 try {
3764 jj_consume_token(AT);
3765 Name();
3766 jj_consume_token(LPAREN);
3767 MemberValue();
3768 jj_consume_token(RPAREN);
3769 } finally {
3770 trace_return("SingleMemberAnnotation");
3771 }
3772 }
3773
3774 final public void MemberValuePairs() throws ParseException {
3775 trace_call("MemberValuePairs");
3776 try {
3777 MemberValuePair();
3778 label_48:
3779 while (true) {
3780 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3781 case COMMA:
3782 ;
3783 break;
3784 default:
3785 break label_48;
3786 }
3787 jj_consume_token(COMMA);
3788 MemberValuePair();
3789 }
3790 } finally {
3791 trace_return("MemberValuePairs");
3792 }
3793 }
3794
3795 final public void MemberValuePair() throws ParseException {
3796 trace_call("MemberValuePair");
3797 try {
3798 jj_consume_token(IDENTIFIER);
3799 jj_consume_token(ASSIGN);
3800 MemberValue();
3801 } finally {
3802 trace_return("MemberValuePair");
3803 }
3804 }
3805
3806 final public void MemberValue() throws ParseException {
3807 trace_call("MemberValue");
3808 try {
3809 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3810 case AT:
3811 Annotation();
3812 break;
3813 case LBRACE:
3814 MemberValueArrayInitializer();
3815 break;
3816 case BOOLEAN:
3817 case BYTE:
3818 case CHAR:
3819 case DOUBLE:
3820 case FALSE:
3821 case FLOAT:
3822 case INT:
3823 case LONG:
3824 case NEW:
3825 case NULL:
3826 case SHORT:
3827 case SUPER:
3828 case THIS:
3829 case TRUE:
3830 case VOID:
3831 case INTEGER_LITERAL:
3832 case FLOATING_POINT_LITERAL:
3833 case CHARACTER_LITERAL:
3834 case STRING_LITERAL:
3835 case IDENTIFIER:
3836 case LPAREN:
3837 case BANG:
3838 case TILDE:
3839 case INCR:
3840 case DECR:
3841 case PLUS:
3842 case MINUS:
3843 ConditionalExpression();
3844 break;
3845 default:
3846 jj_consume_token(-1);
3847 throw new ParseException();
3848 }
3849 } finally {
3850 trace_return("MemberValue");
3851 }
3852 }
3853
3854 final public void MemberValueArrayInitializer() throws ParseException {
3855 trace_call("MemberValueArrayInitializer");
3856 try {
3857 jj_consume_token(LBRACE);
3858 MemberValue();
3859 label_49:
3860 while (true) {
3861 if (jj_2_42(2)) {
3862 ;
3863 } else {
3864 break label_49;
3865 }
3866 jj_consume_token(COMMA);
3867 MemberValue();
3868 }
3869 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3870 case COMMA:
3871 jj_consume_token(COMMA);
3872 break;
3873 default:
3874 ;
3875 }
3876 jj_consume_token(RBRACE);
3877 } finally {
3878 trace_return("MemberValueArrayInitializer");
3879 }
3880 }
3881
3882 /* Annotation Types. */
3883 final public void AnnotationTypeDeclaration(int modifiers) throws ParseException {
3884 trace_call("AnnotationTypeDeclaration");
3885 try {
3886 jj_consume_token(AT);
3887 jj_consume_token(INTERFACE);
3888 jj_consume_token(IDENTIFIER);
3889 AnnotationTypeBody();
3890 } finally {
3891 trace_return("AnnotationTypeDeclaration");
3892 }
3893 }
3894
3895 final public void AnnotationTypeBody() throws ParseException {
3896 trace_call("AnnotationTypeBody");
3897 try {
3898 jj_consume_token(LBRACE);
3899 label_50:
3900 while (true) {
3901 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3902 case ABSTRACT:
3903 case BOOLEAN:
3904 case BYTE:
3905 case CHAR:
3906 case CLASS:
3907 case DOUBLE:
3908 case ENUM:
3909 case FINAL:
3910 case FLOAT:
3911 case INT:
3912 case INTERFACE:
3913 case LONG:
3914 case NATIVE:
3915 case PRIVATE:
3916 case PROTECTED:
3917 case PUBLIC:
3918 case SHORT:
3919 case STATIC:
3920 case STRICTFP:
3921 case SYNCHRONIZED:
3922 case TRANSIENT:
3923 case VOLATILE:
3924 case IDENTIFIER:
3925 case SEMICOLON:
3926 case AT:
3927 ;
3928 break;
3929 default:
3930 break label_50;
3931 }
3932 AnnotationTypeMemberDeclaration();
3933 }
3934 jj_consume_token(RBRACE);
3935 } finally {
3936 trace_return("AnnotationTypeBody");
3937 }
3938 }
3939
3940 final public void AnnotationTypeMemberDeclaration() throws ParseException {
3941 trace_call("AnnotationTypeMemberDeclaration");
3942 try {
3943 int modifiers;
3944 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3945 case ABSTRACT:
3946 case BOOLEAN:
3947 case BYTE:
3948 case CHAR:
3949 case CLASS:
3950 case DOUBLE:
3951 case ENUM:
3952 case FINAL:
3953 case FLOAT:
3954 case INT:
3955 case INTERFACE:
3956 case LONG:
3957 case NATIVE:
3958 case PRIVATE:
3959 case PROTECTED:
3960 case PUBLIC:
3961 case SHORT:
3962 case STATIC:
3963 case STRICTFP:
3964 case SYNCHRONIZED:
3965 case TRANSIENT:
3966 case VOLATILE:
3967 case IDENTIFIER:
3968 case AT:
3969 modifiers = Modifiers();
3970 if (jj_2_43(2147483647)) {
3971 Type();
3972 jj_consume_token(IDENTIFIER);
3973 jj_consume_token(LPAREN);
3974 jj_consume_token(RPAREN);
3975 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3976 case _DEFAULT:
3977 DefaultValue();
3978 break;
3979 default:
3980 ;
3981 }
3982 jj_consume_token(SEMICOLON);
3983 } else {
3984 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3985 case CLASS:
3986 case INTERFACE:
3987 ClassOrInterfaceDeclaration(modifiers);
3988 break;
3989 case ENUM:
3990 EnumDeclaration(modifiers);
3991 break;
3992 case AT:
3993 AnnotationTypeDeclaration(modifiers);
3994 break;
3995 case BOOLEAN:
3996 case BYTE:
3997 case CHAR:
3998 case DOUBLE:
3999 case FLOAT:
4000 case INT:
4001 case LONG:
4002 case SHORT:
4003 case IDENTIFIER:
4004 FieldDeclaration(modifiers);
4005 break;
4006 default:
4007 jj_consume_token(-1);
4008 throw new ParseException();
4009 }
4010 }
4011 break;
4012 case SEMICOLON:
4013 jj_consume_token(SEMICOLON);
4014 break;
4015 default:
4016 jj_consume_token(-1);
4017 throw new ParseException();
4018 }
4019 } finally {
4020 trace_return("AnnotationTypeMemberDeclaration");
4021 }
4022 }
4023
4024 final public void DefaultValue() throws ParseException {
4025 trace_call("DefaultValue");
4026 try {
4027 jj_consume_token(_DEFAULT);
4028 MemberValue();
4029 } finally {
4030 trace_return("DefaultValue");
4031 }
4032 }
4033
4034 private boolean jj_2_1(int xla) {
4035 jj_la = xla; jj_lastpos = jj_scanpos = token;
4036 try { return !jj_3_1(); }
4037 catch(LookaheadSuccess ls) { return true; }
4038 }
4039
4040 private boolean jj_2_2(int xla) {
4041 jj_la = xla; jj_lastpos = jj_scanpos = token;
4042 try { return !jj_3_2(); }
4043 catch(LookaheadSuccess ls) { return true; }
4044 }
4045
4046 private boolean jj_2_3(int xla) {
4047 jj_la = xla; jj_lastpos = jj_scanpos = token;
4048 try { return !jj_3_3(); }
4049 catch(LookaheadSuccess ls) { return true; }
4050 }
4051
4052 private boolean jj_2_4(int xla) {
4053 jj_la = xla; jj_lastpos = jj_scanpos = token;
4054 try { return !jj_3_4(); }
4055 catch(LookaheadSuccess ls) { return true; }
4056 }
4057
4058 private boolean jj_2_5(int xla) {
4059 jj_la = xla; jj_lastpos = jj_scanpos = token;
4060 try { return !jj_3_5(); }
4061 catch(LookaheadSuccess ls) { return true; }
4062 }
4063
4064 private boolean jj_2_6(int xla) {
4065 jj_la = xla; jj_lastpos = jj_scanpos = token;
4066 try { return !jj_3_6(); }
4067 catch(LookaheadSuccess ls) { return true; }
4068 }
4069
4070 private boolean jj_2_7(int xla) {
4071 jj_la = xla; jj_lastpos = jj_scanpos = token;
4072 try { return !jj_3_7(); }
4073 catch(LookaheadSuccess ls) { return true; }
4074 }
4075
4076 private boolean jj_2_8(int xla) {
4077 jj_la = xla; jj_lastpos = jj_scanpos = token;
4078 try { return !jj_3_8(); }
4079 catch(LookaheadSuccess ls) { return true; }
4080 }
4081
4082 private boolean jj_2_9(int xla) {
4083 jj_la = xla; jj_lastpos = jj_scanpos = token;
4084 try { return !jj_3_9(); }
4085 catch(LookaheadSuccess ls) { return true; }
4086 }
4087
4088 private boolean jj_2_10(int xla) {
4089 jj_la = xla; jj_lastpos = jj_scanpos = token;
4090 try { return !jj_3_10(); }
4091 catch(LookaheadSuccess ls) { return true; }
4092 }
4093
4094 private boolean jj_2_11(int xla) {
4095 jj_la = xla; jj_lastpos = jj_scanpos = token;
4096 try { return !jj_3_11(); }
4097 catch(LookaheadSuccess ls) { return true; }
4098 }
4099
4100 private boolean jj_2_12(int xla) {
4101 jj_la = xla; jj_lastpos = jj_scanpos = token;
4102 try { return !jj_3_12(); }
4103 catch(LookaheadSuccess ls) { return true; }
4104 }
4105
4106 private boolean jj_2_13(int xla) {
4107 jj_la = xla; jj_lastpos = jj_scanpos = token;
4108 try { return !jj_3_13(); }
4109 catch(LookaheadSuccess ls) { return true; }
4110 }
4111
4112 private boolean jj_2_14(int xla) {
4113 jj_la = xla; jj_lastpos = jj_scanpos = token;
4114 try { return !jj_3_14(); }
4115 catch(LookaheadSuccess ls) { return true; }
4116 }
4117
4118 private boolean jj_2_15(int xla) {
4119 jj_la = xla; jj_lastpos = jj_scanpos = token;
4120 try { return !jj_3_15(); }
4121 catch(LookaheadSuccess ls) { return true; }
4122 }
4123
4124 private boolean jj_2_16(int xla) {
4125 jj_la = xla; jj_lastpos = jj_scanpos = token;
4126 try { return !jj_3_16(); }
4127 catch(LookaheadSuccess ls) { return true; }
4128 }
4129
4130 private boolean jj_2_17(int xla) {
4131 jj_la = xla; jj_lastpos = jj_scanpos = token;
4132 try { return !jj_3_17(); }
4133 catch(LookaheadSuccess ls) { return true; }
4134 }
4135
4136 private boolean jj_2_18(int xla) {
4137 jj_la = xla; jj_lastpos = jj_scanpos = token;
4138 try { return !jj_3_18(); }
4139 catch(LookaheadSuccess ls) { return true; }
4140 }
4141
4142 private boolean jj_2_19(int xla) {
4143 jj_la = xla; jj_lastpos = jj_scanpos = token;
4144 try { return !jj_3_19(); }
4145 catch(LookaheadSuccess ls) { return true; }
4146 }
4147
4148 private boolean jj_2_20(int xla) {
4149 jj_la = xla; jj_lastpos = jj_scanpos = token;
4150 try { return !jj_3_20(); }
4151 catch(LookaheadSuccess ls) { return true; }
4152 }
4153
4154 private boolean jj_2_21(int xla) {
4155 jj_la = xla; jj_lastpos = jj_scanpos = token;
4156 try { return !jj_3_21(); }
4157 catch(LookaheadSuccess ls) { return true; }
4158 }
4159
4160 private boolean jj_2_22(int xla) {
4161 jj_la = xla; jj_lastpos = jj_scanpos = token;
4162 try { return !jj_3_22(); }
4163 catch(LookaheadSuccess ls) { return true; }
4164 }
4165
4166 private boolean jj_2_23(int xla) {
4167 jj_la = xla; jj_lastpos = jj_scanpos = token;
4168 try { return !jj_3_23(); }
4169 catch(LookaheadSuccess ls) { return true; }
4170 }
4171
4172 private boolean jj_2_24(int xla) {
4173 jj_la = xla; jj_lastpos = jj_scanpos = token;
4174 try { return !jj_3_24(); }
4175 catch(LookaheadSuccess ls) { return true; }
4176 }
4177
4178 private boolean jj_2_25(int xla) {
4179 jj_la = xla; jj_lastpos = jj_scanpos = token;
4180 try { return !jj_3_25(); }
4181 catch(LookaheadSuccess ls) { return true; }
4182 }
4183
4184 private boolean jj_2_26(int xla) {
4185 jj_la = xla; jj_lastpos = jj_scanpos = token;
4186 try { return !jj_3_26(); }
4187 catch(LookaheadSuccess ls) { return true; }
4188 }
4189
4190 private boolean jj_2_27(int xla) {
4191 jj_la = xla; jj_lastpos = jj_scanpos = token;
4192 try { return !jj_3_27(); }
4193 catch(LookaheadSuccess ls) { return true; }
4194 }
4195
4196 private boolean jj_2_28(int xla) {
4197 jj_la = xla; jj_lastpos = jj_scanpos = token;
4198 try { return !jj_3_28(); }
4199 catch(LookaheadSuccess ls) { return true; }
4200 }
4201
4202 private boolean jj_2_29(int xla) {
4203 jj_la = xla; jj_lastpos = jj_scanpos = token;
4204 try { return !jj_3_29(); }
4205 catch(LookaheadSuccess ls) { return true; }
4206 }
4207
4208 private boolean jj_2_30(int xla) {
4209 jj_la = xla; jj_lastpos = jj_scanpos = token;
4210 try { return !jj_3_30(); }
4211 catch(LookaheadSuccess ls) { return true; }
4212 }
4213
4214 private boolean jj_2_31(int xla) {
4215 jj_la = xla; jj_lastpos = jj_scanpos = token;
4216 try { return !jj_3_31(); }
4217 catch(LookaheadSuccess ls) { return true; }
4218 }
4219
4220 private boolean jj_2_32(int xla) {
4221 jj_la = xla; jj_lastpos = jj_scanpos = token;
4222 try { return !jj_3_32(); }
4223 catch(LookaheadSuccess ls) { return true; }
4224 }
4225
4226 private boolean jj_2_33(int xla) {
4227 jj_la = xla; jj_lastpos = jj_scanpos = token;
4228 try { return !jj_3_33(); }
4229 catch(LookaheadSuccess ls) { return true; }
4230 }
4231
4232 private boolean jj_2_34(int xla) {
4233 jj_la = xla; jj_lastpos = jj_scanpos = token;
4234 try { return !jj_3_34(); }
4235 catch(LookaheadSuccess ls) { return true; }
4236 }
4237
4238 private boolean jj_2_35(int xla) {
4239 jj_la = xla; jj_lastpos = jj_scanpos = token;
4240 try { return !jj_3_35(); }
4241 catch(LookaheadSuccess ls) { return true; }
4242 }
4243
4244 private boolean jj_2_36(int xla) {
4245 jj_la = xla; jj_lastpos = jj_scanpos = token;
4246 try { return !jj_3_36(); }
4247 catch(LookaheadSuccess ls) { return true; }
4248 }
4249
4250 private boolean jj_2_37(int xla) {
4251 jj_la = xla; jj_lastpos = jj_scanpos = token;
4252 try { return !jj_3_37(); }
4253 catch(LookaheadSuccess ls) { return true; }
4254 }
4255
4256 private boolean jj_2_38(int xla) {
4257 jj_la = xla; jj_lastpos = jj_scanpos = token;
4258 try { return !jj_3_38(); }
4259 catch(LookaheadSuccess ls) { return true; }
4260 }
4261
4262 private boolean jj_2_39(int xla) {
4263 jj_la = xla; jj_lastpos = jj_scanpos = token;
4264 try { return !jj_3_39(); }
4265 catch(LookaheadSuccess ls) { return true; }
4266 }
4267
4268 private boolean jj_2_40(int xla) {
4269 jj_la = xla; jj_lastpos = jj_scanpos = token;
4270 try { return !jj_3_40(); }
4271 catch(LookaheadSuccess ls) { return true; }
4272 }
4273
4274 private boolean jj_2_41(int xla) {
4275 jj_la = xla; jj_lastpos = jj_scanpos = token;
4276 try { return !jj_3_41(); }
4277 catch(LookaheadSuccess ls) { return true; }
4278 }
4279
4280 private boolean jj_2_42(int xla) {
4281 jj_la = xla; jj_lastpos = jj_scanpos = token;
4282 try { return !jj_3_42(); }
4283 catch(LookaheadSuccess ls) { return true; }
4284 }
4285
4286 private boolean jj_2_43(int xla) {
4287 jj_la = xla; jj_lastpos = jj_scanpos = token;
4288 try { return !jj_3_43(); }
4289 catch(LookaheadSuccess ls) { return true; }
4290 }
4291
4292 private boolean jj_3R_124() {
4293 if (jj_scan_token(IDENTIFIER)) return true;
4294 Token xsp;
4295 xsp = jj_scanpos;
4296 if (jj_3_13()) jj_scanpos = xsp;
4297 while (true) {
4298 xsp = jj_scanpos;
4299 if (jj_3_14()) { jj_scanpos = xsp; break; }
4300 }
4301 return false;
4302 }
4303
4304 private boolean jj_3R_99() {
4305 if (jj_3R_124()) return true;
4306 Token xsp;
4307 while (true) {
4308 xsp = jj_scanpos;
4309 if (jj_3_12()) { jj_scanpos = xsp; break; }
4310 }
4311 return false;
4312 }
4313
4314 private boolean jj_3R_98() {
4315 if (jj_3R_78()) return true;
4316 Token xsp;
4317 if (jj_3_11()) return true;
4318 while (true) {
4319 xsp = jj_scanpos;
4320 if (jj_3_11()) { jj_scanpos = xsp; break; }
4321 }
4322 return false;
4323 }
4324
4325 private boolean jj_3R_71() {
4326 Token xsp;
4327 xsp = jj_scanpos;
4328 if (jj_3R_98()) {
4329 jj_scanpos = xsp;
4330 if (jj_3R_99()) return true;
4331 }
4332 return false;
4333 }
4334
4335 private boolean jj_3_9() {
4336 if (jj_scan_token(THIS)) return true;
4337 if (jj_scan_token(DOT)) return true;
4338 return false;
4339 }
4340
4341 private boolean jj_3R_263() {
4342 if (jj_scan_token(THROWS)) return true;
4343 if (jj_3R_277()) return true;
4344 return false;
4345 }
4346
4347 private boolean jj_3R_91() {
4348 if (jj_3R_78()) return true;
4349 return false;
4350 }
4351
4352 private boolean jj_3_10() {
4353 if (jj_3R_71()) return true;
4354 return false;
4355 }
4356
4357 private boolean jj_3R_66() {
4358 Token xsp;
4359 xsp = jj_scanpos;
4360 if (jj_3_10()) {
4361 jj_scanpos = xsp;
4362 if (jj_3R_91()) return true;
4363 }
4364 return false;
4365 }
4366
4367 private boolean jj_3R_68() {
4368 Token xsp;
4369 xsp = jj_scanpos;
4370 if (jj_scan_token(51)) jj_scanpos = xsp;
4371 if (jj_3R_92()) return true;
4372 return false;
4373 }
4374
4375 private boolean jj_3_8() {
4376 if (jj_3R_70()) return true;
4377 return false;
4378 }
4379
4380 private boolean jj_3R_96() {
4381 if (jj_3R_72()) return true;
4382 return false;
4383 }
4384
4385 private boolean jj_3R_280() {
4386 if (jj_scan_token(LBRACKET)) return true;
4387 if (jj_scan_token(RBRACKET)) return true;
4388 return false;
4389 }
4390
4391 private boolean jj_3R_95() {
4392 if (jj_scan_token(IDENTIFIER)) return true;
4393 if (jj_scan_token(DOT)) return true;
4394 return false;
4395 }
4396
4397 private boolean jj_3R_285() {
4398 if (jj_scan_token(COMMA)) return true;
4399 if (jj_3R_284()) return true;
4400 return false;
4401 }
4402
4403 private boolean jj_3R_70() {
4404 Token xsp;
4405 while (true) {
4406 xsp = jj_scanpos;
4407 if (jj_3R_95()) { jj_scanpos = xsp; break; }
4408 }
4409 xsp = jj_scanpos;
4410 if (jj_3_9()) jj_scanpos = xsp;
4411 xsp = jj_scanpos;
4412 if (jj_3R_96()) jj_scanpos = xsp;
4413 xsp = jj_scanpos;
4414 if (jj_scan_token(56)) {
4415 jj_scanpos = xsp;
4416 if (jj_scan_token(53)) return true;
4417 }
4418 if (jj_3R_97()) return true;
4419 if (jj_scan_token(SEMICOLON)) return true;
4420 return false;
4421 }
4422
4423 private boolean jj_3R_265() {
4424 if (jj_3R_134()) return true;
4425 return false;
4426 }
4427
4428 private boolean jj_3R_264() {
4429 if (jj_3R_70()) return true;
4430 return false;
4431 }
4432
4433 private boolean jj_3R_261() {
4434 if (jj_3R_90()) return true;
4435 return false;
4436 }
4437
4438 private boolean jj_3R_253() {
4439 Token xsp;
4440 xsp = jj_scanpos;
4441 if (jj_3R_261()) jj_scanpos = xsp;
4442 if (jj_scan_token(IDENTIFIER)) return true;
4443 if (jj_3R_262()) return true;
4444 xsp = jj_scanpos;
4445 if (jj_3R_263()) jj_scanpos = xsp;
4446 if (jj_scan_token(LBRACE)) return true;
4447 xsp = jj_scanpos;
4448 if (jj_3R_264()) jj_scanpos = xsp;
4449 while (true) {
4450 xsp = jj_scanpos;
4451 if (jj_3R_265()) { jj_scanpos = xsp; break; }
4452 }
4453 if (jj_scan_token(RBRACE)) return true;
4454 return false;
4455 }
4456
4457 private boolean jj_3R_270() {
4458 if (jj_scan_token(THROWS)) return true;
4459 if (jj_3R_277()) return true;
4460 return false;
4461 }
4462
4463 private boolean jj_3_7() {
4464 if (jj_scan_token(COMMA)) return true;
4465 if (jj_3R_69()) return true;
4466 return false;
4467 }
4468
4469 private boolean jj_3R_284() {
4470 if (jj_3R_85()) return true;
4471 if (jj_3R_66()) return true;
4472 Token xsp;
4473 xsp = jj_scanpos;
4474 if (jj_scan_token(123)) jj_scanpos = xsp;
4475 if (jj_3R_278()) return true;
4476 return false;
4477 }
4478
4479 private boolean jj_3R_276() {
4480 if (jj_3R_284()) return true;
4481 Token xsp;
4482 while (true) {
4483 xsp = jj_scanpos;
4484 if (jj_3R_285()) { jj_scanpos = xsp; break; }
4485 }
4486 return false;
4487 }
4488
4489 private boolean jj_3R_262() {
4490 if (jj_scan_token(LPAREN)) return true;
4491 Token xsp;
4492 xsp = jj_scanpos;
4493 if (jj_3R_276()) jj_scanpos = xsp;
4494 if (jj_scan_token(RPAREN)) return true;
4495 return false;
4496 }
4497
4498 private boolean jj_3R_269() {
4499 if (jj_scan_token(IDENTIFIER)) return true;
4500 if (jj_3R_262()) return true;
4501 Token xsp;
4502 while (true) {
4503 xsp = jj_scanpos;
4504 if (jj_3R_280()) { jj_scanpos = xsp; break; }
4505 }
4506 return false;
4507 }
4508
4509 private boolean jj_3_43() {
4510 if (jj_3R_66()) return true;
4511 if (jj_scan_token(IDENTIFIER)) return true;
4512 if (jj_scan_token(LPAREN)) return true;
4513 return false;
4514 }
4515
4516 private boolean jj_3R_271() {
4517 if (jj_3R_92()) return true;
4518 return false;
4519 }
4520
4521 private boolean jj_3R_268() {
4522 if (jj_3R_90()) return true;
4523 return false;
4524 }
4525
4526 private boolean jj_3R_255() {
4527 Token xsp;
4528 xsp = jj_scanpos;
4529 if (jj_3R_268()) jj_scanpos = xsp;
4530 if (jj_3R_81()) return true;
4531 if (jj_3R_269()) return true;
4532 xsp = jj_scanpos;
4533 if (jj_3R_270()) jj_scanpos = xsp;
4534 xsp = jj_scanpos;
4535 if (jj_3R_271()) {
4536 jj_scanpos = xsp;
4537 if (jj_scan_token(85)) return true;
4538 }
4539 return false;
4540 }
4541
4542 private boolean jj_3R_243() {
4543 if (jj_3R_69()) return true;
4544 Token xsp;
4545 while (true) {
4546 xsp = jj_scanpos;
4547 if (jj_3_7()) { jj_scanpos = xsp; break; }
4548 }
4549 return false;
4550 }
4551
4552 private boolean jj_3R_279() {
4553 if (jj_scan_token(ASSIGN)) return true;
4554 if (jj_3R_69()) return true;
4555 return false;
4556 }
4557
4558 private boolean jj_3R_267() {
4559 if (jj_scan_token(COMMA)) return true;
4560 if (jj_3R_266()) return true;
4561 return false;
4562 }
4563
4564 private boolean jj_3R_287() {
4565 if (jj_scan_token(LBRACKET)) return true;
4566 if (jj_scan_token(RBRACKET)) return true;
4567 return false;
4568 }
4569
4570 private boolean jj_3R_122() {
4571 if (jj_scan_token(LBRACE)) return true;
4572 Token xsp;
4573 xsp = jj_scanpos;
4574 if (jj_3R_243()) jj_scanpos = xsp;
4575 xsp = jj_scanpos;
4576 if (jj_scan_token(86)) jj_scanpos = xsp;
4577 if (jj_scan_token(RBRACE)) return true;
4578 return false;
4579 }
4580
4581 private boolean jj_3_42() {
4582 if (jj_scan_token(COMMA)) return true;
4583 if (jj_3R_88()) return true;
4584 return false;
4585 }
4586
4587 private boolean jj_3R_67() {
4588 if (jj_scan_token(LBRACKET)) return true;
4589 if (jj_scan_token(RBRACKET)) return true;
4590 return false;
4591 }
4592
4593 private boolean jj_3R_94() {
4594 if (jj_3R_74()) return true;
4595 return false;
4596 }
4597
4598 private boolean jj_3R_93() {
4599 if (jj_3R_122()) return true;
4600 return false;
4601 }
4602
4603 private boolean jj_3R_69() {
4604 Token xsp;
4605 xsp = jj_scanpos;
4606 if (jj_3R_93()) {
4607 jj_scanpos = xsp;
4608 if (jj_3R_94()) return true;
4609 }
4610 return false;
4611 }
4612
4613 private boolean jj_3R_278() {
4614 if (jj_scan_token(IDENTIFIER)) return true;
4615 Token xsp;
4616 while (true) {
4617 xsp = jj_scanpos;
4618 if (jj_3R_287()) { jj_scanpos = xsp; break; }
4619 }
4620 return false;
4621 }
4622
4623 private boolean jj_3R_266() {
4624 if (jj_3R_278()) return true;
4625 Token xsp;
4626 xsp = jj_scanpos;
4627 if (jj_3R_279()) jj_scanpos = xsp;
4628 return false;
4629 }
4630
4631 private boolean jj_3R_129() {
4632 if (jj_scan_token(LBRACE)) return true;
4633 if (jj_3R_88()) return true;
4634 Token xsp;
4635 while (true) {
4636 xsp = jj_scanpos;
4637 if (jj_3_42()) { jj_scanpos = xsp; break; }
4638 }
4639 xsp = jj_scanpos;
4640 if (jj_scan_token(86)) jj_scanpos = xsp;
4641 if (jj_scan_token(RBRACE)) return true;
4642 return false;
4643 }
4644
4645 private boolean jj_3R_156() {
4646 if (jj_scan_token(COMMA)) return true;
4647 if (jj_3R_155()) return true;
4648 return false;
4649 }
4650
4651 private boolean jj_3_5() {
4652 if (jj_3R_66()) return true;
4653 if (jj_scan_token(IDENTIFIER)) return true;
4654 Token xsp;
4655 while (true) {
4656 xsp = jj_scanpos;
4657 if (jj_3R_67()) { jj_scanpos = xsp; break; }
4658 }
4659 xsp = jj_scanpos;
4660 if (jj_scan_token(86)) {
4661 jj_scanpos = xsp;
4662 if (jj_scan_token(89)) {
4663 jj_scanpos = xsp;
4664 if (jj_scan_token(85)) return true;
4665 }
4666 }
4667 return false;
4668 }
4669
4670 private boolean jj_3R_65() {
4671 if (jj_3R_90()) return true;
4672 return false;
4673 }
4674
4675 private boolean jj_3R_115() {
4676 if (jj_3R_101()) return true;
4677 return false;
4678 }
4679
4680 private boolean jj_3R_254() {
4681 if (jj_3R_66()) return true;
4682 if (jj_3R_266()) return true;
4683 Token xsp;
4684 while (true) {
4685 xsp = jj_scanpos;
4686 if (jj_3R_267()) { jj_scanpos = xsp; break; }
4687 }
4688 if (jj_scan_token(SEMICOLON)) return true;
4689 return false;
4690 }
4691
4692 private boolean jj_3_4() {
4693 Token xsp;
4694 xsp = jj_scanpos;
4695 if (jj_3R_65()) jj_scanpos = xsp;
4696 if (jj_scan_token(IDENTIFIER)) return true;
4697 if (jj_scan_token(LPAREN)) return true;
4698 return false;
4699 }
4700
4701 private boolean jj_3R_114() {
4702 if (jj_3R_129()) return true;
4703 return false;
4704 }
4705
4706 private boolean jj_3R_113() {
4707 if (jj_3R_89()) return true;
4708 return false;
4709 }
4710
4711 private boolean jj_3R_88() {
4712 Token xsp;
4713 xsp = jj_scanpos;
4714 if (jj_3R_113()) {
4715 jj_scanpos = xsp;
4716 if (jj_3R_114()) {
4717 jj_scanpos = xsp;
4718 if (jj_3R_115()) return true;
4719 }
4720 }
4721 return false;
4722 }
4723
4724 private boolean jj_3R_251() {
4725 if (jj_3R_255()) return true;
4726 return false;
4727 }
4728
4729 private boolean jj_3R_155() {
4730 if (jj_scan_token(IDENTIFIER)) return true;
4731 if (jj_scan_token(ASSIGN)) return true;
4732 if (jj_3R_88()) return true;
4733 return false;
4734 }
4735
4736 private boolean jj_3R_148() {
4737 if (jj_scan_token(BIT_AND)) return true;
4738 if (jj_3R_124()) return true;
4739 return false;
4740 }
4741
4742 private boolean jj_3R_250() {
4743 if (jj_3R_254()) return true;
4744 return false;
4745 }
4746
4747 private boolean jj_3R_249() {
4748 if (jj_3R_253()) return true;
4749 return false;
4750 }
4751
4752 private boolean jj_3R_248() {
4753 if (jj_3R_252()) return true;
4754 return false;
4755 }
4756
4757 private boolean jj_3R_147() {
4758 if (jj_3R_155()) return true;
4759 Token xsp;
4760 while (true) {
4761 xsp = jj_scanpos;
4762 if (jj_3R_156()) { jj_scanpos = xsp; break; }
4763 }
4764 return false;
4765 }
4766
4767 private boolean jj_3R_247() {
4768 if (jj_3R_151()) return true;
4769 return false;
4770 }
4771
4772 private boolean jj_3R_139() {
4773 if (jj_3R_147()) return true;
4774 return false;
4775 }
4776
4777 private boolean jj_3R_87() {
4778 if (jj_scan_token(IDENTIFIER)) return true;
4779 if (jj_scan_token(ASSIGN)) return true;
4780 return false;
4781 }
4782
4783 private boolean jj_3R_289() {
4784 if (jj_3R_242()) return true;
4785 return false;
4786 }
4787
4788 private boolean jj_3R_131() {
4789 if (jj_scan_token(AT)) return true;
4790 if (jj_3R_86()) return true;
4791 if (jj_scan_token(LPAREN)) return true;
4792 if (jj_3R_88()) return true;
4793 if (jj_scan_token(RPAREN)) return true;
4794 return false;
4795 }
4796
4797 private boolean jj_3R_246() {
4798 if (jj_3R_85()) return true;
4799 Token xsp;
4800 xsp = jj_scanpos;
4801 if (jj_3R_247()) {
4802 jj_scanpos = xsp;
4803 if (jj_3R_248()) {
4804 jj_scanpos = xsp;
4805 if (jj_3R_249()) {
4806 jj_scanpos = xsp;
4807 if (jj_3R_250()) {
4808 jj_scanpos = xsp;
4809 if (jj_3R_251()) return true;
4810 }
4811 }
4812 }
4813 }
4814 return false;
4815 }
4816
4817 private boolean jj_3R_132() {
4818 if (jj_scan_token(AT)) return true;
4819 if (jj_3R_86()) return true;
4820 return false;
4821 }
4822
4823 private boolean jj_3_6() {
4824 if (jj_3R_68()) return true;
4825 return false;
4826 }
4827
4828 private boolean jj_3R_245() {
4829 Token xsp;
4830 xsp = jj_scanpos;
4831 if (jj_3_6()) {
4832 jj_scanpos = xsp;
4833 if (jj_3R_246()) {
4834 jj_scanpos = xsp;
4835 if (jj_scan_token(85)) return true;
4836 }
4837 }
4838 return false;
4839 }
4840
4841 private boolean jj_3_41() {
4842 if (jj_scan_token(AT)) return true;
4843 if (jj_3R_86()) return true;
4844 if (jj_scan_token(LPAREN)) return true;
4845 return false;
4846 }
4847
4848 private boolean jj_3R_244() {
4849 if (jj_3R_245()) return true;
4850 return false;
4851 }
4852
4853 private boolean jj_3R_130() {
4854 if (jj_scan_token(AT)) return true;
4855 if (jj_3R_86()) return true;
4856 if (jj_scan_token(LPAREN)) return true;
4857 Token xsp;
4858 xsp = jj_scanpos;
4859 if (jj_3R_139()) jj_scanpos = xsp;
4860 if (jj_scan_token(RPAREN)) return true;
4861 return false;
4862 }
4863
4864 private boolean jj_3R_120() {
4865 if (jj_scan_token(COMMA)) return true;
4866 if (jj_3R_119()) return true;
4867 return false;
4868 }
4869
4870 private boolean jj_3_40() {
4871 if (jj_scan_token(AT)) return true;
4872 if (jj_3R_86()) return true;
4873 if (jj_scan_token(LPAREN)) return true;
4874 Token xsp;
4875 xsp = jj_scanpos;
4876 if (jj_3R_87()) {
4877 jj_scanpos = xsp;
4878 if (jj_scan_token(80)) return true;
4879 }
4880 return false;
4881 }
4882
4883 private boolean jj_3R_133() {
4884 if (jj_3R_140()) return true;
4885 return false;
4886 }
4887
4888 private boolean jj_3R_288() {
4889 if (jj_3R_97()) return true;
4890 return false;
4891 }
4892
4893 private boolean jj_3R_242() {
4894 if (jj_scan_token(LBRACE)) return true;
4895 Token xsp;
4896 while (true) {
4897 xsp = jj_scanpos;
4898 if (jj_3R_244()) { jj_scanpos = xsp; break; }
4899 }
4900 if (jj_scan_token(RBRACE)) return true;
4901 return false;
4902 }
4903
4904 private boolean jj_3R_118() {
4905 if (jj_3R_132()) return true;
4906 return false;
4907 }
4908
4909 private boolean jj_3R_117() {
4910 if (jj_3R_131()) return true;
4911 return false;
4912 }
4913
4914 private boolean jj_3R_140() {
4915 if (jj_scan_token(EXTENDS)) return true;
4916 if (jj_3R_124()) return true;
4917 Token xsp;
4918 while (true) {
4919 xsp = jj_scanpos;
4920 if (jj_3R_148()) { jj_scanpos = xsp; break; }
4921 }
4922 return false;
4923 }
4924
4925 private boolean jj_3R_116() {
4926 if (jj_3R_130()) return true;
4927 return false;
4928 }
4929
4930 private boolean jj_3R_102() {
4931 return false;
4932 }
4933
4934 private boolean jj_3R_89() {
4935 Token xsp;
4936 xsp = jj_scanpos;
4937 if (jj_3R_116()) {
4938 jj_scanpos = xsp;
4939 if (jj_3R_117()) {
4940 jj_scanpos = xsp;
4941 if (jj_3R_118()) return true;
4942 }
4943 }
4944 return false;
4945 }
4946
4947 private boolean jj_3R_119() {
4948 if (jj_scan_token(IDENTIFIER)) return true;
4949 Token xsp;
4950 xsp = jj_scanpos;
4951 if (jj_3R_133()) jj_scanpos = xsp;
4952 return false;
4953 }
4954
4955 private boolean jj_3_3() {
4956 if (jj_scan_token(COMMA)) return true;
4957 if (jj_3R_64()) return true;
4958 return false;
4959 }
4960
4961 private boolean jj_3R_103() {
4962 return false;
4963 }
4964
4965 private boolean jj_3R_90() {
4966 if (jj_scan_token(LT)) return true;
4967 if (jj_3R_119()) return true;
4968 Token xsp;
4969 while (true) {
4970 xsp = jj_scanpos;
4971 if (jj_3R_120()) { jj_scanpos = xsp; break; }
4972 }
4973 if (jj_scan_token(GT)) return true;
4974 return false;
4975 }
4976
4977 private boolean jj_3R_75() {
4978 jj_lookingAhead = true;
4979 jj_semLA = getToken(1).kind == GT &&
4980 ((Token.GTToken)getToken(1)).realKind == RSIGNEDSHIFT;
4981 jj_lookingAhead = false;
4982 if (!jj_semLA || jj_3R_102()) return true;
4983 if (jj_scan_token(GT)) return true;
4984 if (jj_scan_token(GT)) return true;
4985 return false;
4986 }
4987
4988 private boolean jj_3R_283() {
4989 if (jj_3R_245()) return true;
4990 return false;
4991 }
4992
4993 private boolean jj_3R_64() {
4994 if (jj_3R_85()) return true;
4995 if (jj_scan_token(IDENTIFIER)) return true;
4996 Token xsp;
4997 xsp = jj_scanpos;
4998 if (jj_3R_288()) jj_scanpos = xsp;
4999 xsp = jj_scanpos;
5000 if (jj_3R_289()) jj_scanpos = xsp;
5001 return false;
5002 }
5003
5004 private boolean jj_3R_76() {
5005 jj_lookingAhead = true;
5006 jj_semLA = getToken(1).kind == GT &&
5007 ((Token.GTToken)getToken(1)).realKind == RUNSIGNEDSHIFT;
5008 jj_lookingAhead = false;
5009 if (!jj_semLA || jj_3R_103()) return true;
5010 if (jj_scan_token(GT)) return true;
5011 if (jj_scan_token(GT)) return true;
5012 if (jj_scan_token(GT)) return true;
5013 return false;
5014 }
5015
5016 private boolean jj_3R_275() {
5017 if (jj_scan_token(SEMICOLON)) return true;
5018 Token xsp;
5019 while (true) {
5020 xsp = jj_scanpos;
5021 if (jj_3R_283()) { jj_scanpos = xsp; break; }
5022 }
5023 return false;
5024 }
5025
5026 private boolean jj_3R_274() {
5027 if (jj_3R_64()) return true;
5028 Token xsp;
5029 while (true) {
5030 xsp = jj_scanpos;
5031 if (jj_3_3()) { jj_scanpos = xsp; break; }
5032 }
5033 return false;
5034 }
5035
5036 private boolean jj_3R_260() {
5037 if (jj_scan_token(LBRACE)) return true;
5038 Token xsp;
5039 xsp = jj_scanpos;
5040 if (jj_3R_274()) jj_scanpos = xsp;
5041 xsp = jj_scanpos;
5042 if (jj_scan_token(86)) jj_scanpos = xsp;
5043 xsp = jj_scanpos;
5044 if (jj_3R_275()) jj_scanpos = xsp;
5045 if (jj_scan_token(RBRACE)) return true;
5046 return false;
5047 }
5048
5049 private boolean jj_3R_298() {
5050 if (jj_scan_token(FINALLY)) return true;
5051 if (jj_3R_92()) return true;
5052 return false;
5053 }
5054
5055 private boolean jj_3R_297() {
5056 if (jj_scan_token(CATCH)) return true;
5057 if (jj_scan_token(LPAREN)) return true;
5058 if (jj_3R_284()) return true;
5059 if (jj_scan_token(RPAREN)) return true;
5060 if (jj_3R_92()) return true;
5061 return false;
5062 }
5063
5064 private boolean jj_3R_259() {
5065 if (jj_3R_273()) return true;
5066 return false;
5067 }
5068
5069 private boolean jj_3R_187() {
5070 if (jj_scan_token(TRY)) return true;
5071 if (jj_3R_92()) return true;
5072 Token xsp;
5073 while (true) {
5074 xsp = jj_scanpos;
5075 if (jj_3R_297()) { jj_scanpos = xsp; break; }
5076 }
5077 xsp = jj_scanpos;
5078 if (jj_3R_298()) jj_scanpos = xsp;
5079 return false;
5080 }
5081
5082 private boolean jj_3R_252() {
5083 if (jj_scan_token(ENUM)) return true;
5084 if (jj_scan_token(IDENTIFIER)) return true;
5085 Token xsp;
5086 xsp = jj_scanpos;
5087 if (jj_3R_259()) jj_scanpos = xsp;
5088 if (jj_3R_260()) return true;
5089 return false;
5090 }
5091
5092 private boolean jj_3R_282() {
5093 if (jj_scan_token(COMMA)) return true;
5094 if (jj_3R_124()) return true;
5095 return false;
5096 }
5097
5098 private boolean jj_3R_186() {
5099 if (jj_scan_token(SYNCHRONIZED)) return true;
5100 if (jj_scan_token(LPAREN)) return true;
5101 if (jj_3R_74()) return true;
5102 if (jj_scan_token(RPAREN)) return true;
5103 if (jj_3R_92()) return true;
5104 return false;
5105 }
5106
5107 private boolean jj_3R_296() {
5108 if (jj_3R_74()) return true;
5109 return false;
5110 }
5111
5112 private boolean jj_3R_273() {
5113 if (jj_scan_token(IMPLEMENTS)) return true;
5114 if (jj_3R_124()) return true;
5115 Token xsp;
5116 while (true) {
5117 xsp = jj_scanpos;
5118 if (jj_3R_282()) { jj_scanpos = xsp; break; }
5119 }
5120 return false;
5121 }
5122
5123 private boolean jj_3R_185() {
5124 if (jj_scan_token(THROW)) return true;
5125 if (jj_3R_74()) return true;
5126 if (jj_scan_token(SEMICOLON)) return true;
5127 return false;
5128 }
5129
5130 private boolean jj_3R_304() {
5131 if (jj_3R_309()) return true;
5132 return false;
5133 }
5134
5135 private boolean jj_3R_281() {
5136 if (jj_scan_token(COMMA)) return true;
5137 if (jj_3R_124()) return true;
5138 return false;
5139 }
5140
5141 private boolean jj_3R_313() {
5142 if (jj_scan_token(COMMA)) return true;
5143 if (jj_3R_176()) return true;
5144 return false;
5145 }
5146
5147 private boolean jj_3R_184() {
5148 if (jj_scan_token(RETURN)) return true;
5149 Token xsp;
5150 xsp = jj_scanpos;
5151 if (jj_3R_296()) jj_scanpos = xsp;
5152 if (jj_scan_token(SEMICOLON)) return true;
5153 return false;
5154 }
5155
5156 private boolean jj_3R_272() {
5157 if (jj_scan_token(EXTENDS)) return true;
5158 if (jj_3R_124()) return true;
5159 Token xsp;
5160 while (true) {
5161 xsp = jj_scanpos;
5162 if (jj_3R_281()) { jj_scanpos = xsp; break; }
5163 }
5164 return false;
5165 }
5166
5167 private boolean jj_3R_171() {
5168 if (jj_scan_token(INTERFACE)) return true;
5169 return false;
5170 }
5171
5172 private boolean jj_3R_183() {
5173 if (jj_scan_token(CONTINUE)) return true;
5174 Token xsp;
5175 xsp = jj_scanpos;
5176 if (jj_scan_token(76)) jj_scanpos = xsp;
5177 if (jj_scan_token(SEMICOLON)) return true;
5178 return false;
5179 }
5180
5181 private boolean jj_3R_258() {
5182 if (jj_3R_273()) return true;
5183 return false;
5184 }
5185
5186 private boolean jj_3R_257() {
5187 if (jj_3R_272()) return true;
5188 return false;
5189 }
5190
5191 private boolean jj_3R_256() {
5192 if (jj_3R_90()) return true;
5193 return false;
5194 }
5195
5196 private boolean jj_3R_182() {
5197 if (jj_scan_token(BREAK)) return true;
5198 Token xsp;
5199 xsp = jj_scanpos;
5200 if (jj_scan_token(76)) jj_scanpos = xsp;
5201 if (jj_scan_token(SEMICOLON)) return true;
5202 return false;
5203 }
5204
5205 private boolean jj_3R_151() {
5206 Token xsp;
5207 xsp = jj_scanpos;
5208 if (jj_scan_token(20)) {
5209 jj_scanpos = xsp;
5210 if (jj_3R_171()) return true;
5211 }
5212 if (jj_scan_token(IDENTIFIER)) return true;
5213 xsp = jj_scanpos;
5214 if (jj_3R_256()) jj_scanpos = xsp;
5215 xsp = jj_scanpos;
5216 if (jj_3R_257()) jj_scanpos = xsp;
5217 xsp = jj_scanpos;
5218 if (jj_3R_258()) jj_scanpos = xsp;
5219 if (jj_3R_242()) return true;
5220 return false;
5221 }
5222
5223 private boolean jj_3R_309() {
5224 if (jj_3R_312()) return true;
5225 return false;
5226 }
5227
5228 private boolean jj_3R_303() {
5229 if (jj_3R_74()) return true;
5230 return false;
5231 }
5232
5233 private boolean jj_3_39() {
5234 if (jj_3R_85()) return true;
5235 if (jj_3R_66()) return true;
5236 if (jj_scan_token(IDENTIFIER)) return true;
5237 return false;
5238 }
5239
5240 private boolean jj_3R_312() {
5241 if (jj_3R_176()) return true;
5242 Token xsp;
5243 while (true) {
5244 xsp = jj_scanpos;
5245 if (jj_3R_313()) { jj_scanpos = xsp; break; }
5246 }
5247 return false;
5248 }
5249
5250 private boolean jj_3R_293() {
5251 if (jj_scan_token(ELSE)) return true;
5252 if (jj_3R_150()) return true;
5253 return false;
5254 }
5255
5256 private boolean jj_3R_311() {
5257 if (jj_3R_312()) return true;
5258 return false;
5259 }
5260
5261 private boolean jj_3_38() {
5262 if (jj_3R_85()) return true;
5263 if (jj_3R_66()) return true;
5264 if (jj_scan_token(IDENTIFIER)) return true;
5265 if (jj_scan_token(COLON)) return true;
5266 return false;
5267 }
5268
5269 private boolean jj_3R_310() {
5270 if (jj_3R_149()) return true;
5271 return false;
5272 }
5273
5274 private boolean jj_3R_308() {
5275 Token xsp;
5276 xsp = jj_scanpos;
5277 if (jj_3R_310()) {
5278 jj_scanpos = xsp;
5279 if (jj_3R_311()) return true;
5280 }
5281 return false;
5282 }
5283
5284 private boolean jj_3R_302() {
5285 if (jj_3R_308()) return true;
5286 return false;
5287 }
5288
5289 private boolean jj_3R_295() {
5290 Token xsp;
5291 xsp = jj_scanpos;
5292 if (jj_3R_302()) jj_scanpos = xsp;
5293 if (jj_scan_token(SEMICOLON)) return true;
5294 xsp = jj_scanpos;
5295 if (jj_3R_303()) jj_scanpos = xsp;
5296 if (jj_scan_token(SEMICOLON)) return true;
5297 xsp = jj_scanpos;
5298 if (jj_3R_304()) jj_scanpos = xsp;
5299 return false;
5300 }
5301
5302 private boolean jj_3R_294() {
5303 if (jj_3R_85()) return true;
5304 if (jj_3R_66()) return true;
5305 if (jj_scan_token(IDENTIFIER)) return true;
5306 if (jj_scan_token(COLON)) return true;
5307 if (jj_3R_74()) return true;
5308 return false;
5309 }
5310
5311 private boolean jj_3R_181() {
5312 if (jj_scan_token(FOR)) return true;
5313 if (jj_scan_token(LPAREN)) return true;
5314 Token xsp;
5315 xsp = jj_scanpos;
5316 if (jj_3R_294()) {
5317 jj_scanpos = xsp;
5318 if (jj_3R_295()) return true;
5319 }
5320 if (jj_scan_token(RPAREN)) return true;
5321 if (jj_3R_150()) return true;
5322 return false;
5323 }
5324
5325 private boolean jj_3R_63() {
5326 if (jj_3R_89()) return true;
5327 return false;
5328 }
5329
5330 private boolean jj_3R_62() {
5331 if (jj_scan_token(STRICTFP)) return true;
5332 return false;
5333 }
5334
5335 private boolean jj_3R_61() {
5336 if (jj_scan_token(VOLATILE)) return true;
5337 return false;
5338 }
5339
5340 private boolean jj_3R_180() {
5341 if (jj_scan_token(DO)) return true;
5342 if (jj_3R_150()) return true;
5343 if (jj_scan_token(WHILE)) return true;
5344 if (jj_scan_token(LPAREN)) return true;
5345 if (jj_3R_74()) return true;
5346 if (jj_scan_token(RPAREN)) return true;
5347 if (jj_scan_token(SEMICOLON)) return true;
5348 return false;
5349 }
5350
5351 private boolean jj_3R_60() {
5352 if (jj_scan_token(TRANSIENT)) return true;
5353 return false;
5354 }
5355
5356 private boolean jj_3R_59() {
5357 if (jj_scan_token(NATIVE)) return true;
5358 return false;
5359 }
5360
5361 private boolean jj_3R_58() {
5362 if (jj_scan_token(SYNCHRONIZED)) return true;
5363 return false;
5364 }
5365
5366 private boolean jj_3R_179() {
5367 if (jj_scan_token(WHILE)) return true;
5368 if (jj_scan_token(LPAREN)) return true;
5369 if (jj_3R_74()) return true;
5370 if (jj_scan_token(RPAREN)) return true;
5371 if (jj_3R_150()) return true;
5372 return false;
5373 }
5374
5375 private boolean jj_3R_57() {
5376 if (jj_scan_token(ABSTRACT)) return true;
5377 return false;
5378 }
5379
5380 private boolean jj_3R_56() {
5381 if (jj_scan_token(FINAL)) return true;
5382 return false;
5383 }
5384
5385 private boolean jj_3R_301() {
5386 if (jj_3R_134()) return true;
5387 return false;
5388 }
5389
5390 private boolean jj_3R_55() {
5391 if (jj_scan_token(PRIVATE)) return true;
5392 return false;
5393 }
5394
5395 private boolean jj_3R_178() {
5396 if (jj_scan_token(IF)) return true;
5397 if (jj_scan_token(LPAREN)) return true;
5398 if (jj_3R_74()) return true;
5399 if (jj_scan_token(RPAREN)) return true;
5400 if (jj_3R_150()) return true;
5401 Token xsp;
5402 xsp = jj_scanpos;
5403 if (jj_3R_293()) jj_scanpos = xsp;
5404 return false;
5405 }
5406
5407 private boolean jj_3R_54() {
5408 if (jj_scan_token(PROTECTED)) return true;
5409 return false;
5410 }
5411
5412 private boolean jj_3R_53() {
5413 if (jj_scan_token(STATIC)) return true;
5414 return false;
5415 }
5416
5417 private boolean jj_3R_52() {
5418 if (jj_scan_token(PUBLIC)) return true;
5419 return false;
5420 }
5421
5422 private boolean jj_3_2() {
5423 Token xsp;
5424 xsp = jj_scanpos;
5425 if (jj_3R_52()) {
5426 jj_scanpos = xsp;
5427 if (jj_3R_53()) {
5428 jj_scanpos = xsp;
5429 if (jj_3R_54()) {
5430 jj_scanpos = xsp;
5431 if (jj_3R_55()) {
5432 jj_scanpos = xsp;
5433 if (jj_3R_56()) {
5434 jj_scanpos = xsp;
5435 if (jj_3R_57()) {
5436 jj_scanpos = xsp;
5437 if (jj_3R_58()) {
5438 jj_scanpos = xsp;
5439 if (jj_3R_59()) {
5440 jj_scanpos = xsp;
5441 if (jj_3R_60()) {
5442 jj_scanpos = xsp;
5443 if (jj_3R_61()) {
5444 jj_scanpos = xsp;
5445 if (jj_3R_62()) {
5446 jj_scanpos = xsp;
5447 if (jj_3R_63()) return true;
5448 }
5449 }
5450 }
5451 }
5452 }
5453 }
5454 }
5455 }
5456 }
5457 }
5458 }
5459 return false;
5460 }
5461
5462 private boolean jj_3R_307() {
5463 if (jj_scan_token(_DEFAULT)) return true;
5464 if (jj_scan_token(COLON)) return true;
5465 return false;
5466 }
5467
5468 private boolean jj_3R_85() {
5469 Token xsp;
5470 while (true) {
5471 xsp = jj_scanpos;
5472 if (jj_3_2()) { jj_scanpos = xsp; break; }
5473 }
5474 return false;
5475 }
5476
5477 private boolean jj_3R_306() {
5478 if (jj_scan_token(CASE)) return true;
5479 if (jj_3R_74()) return true;
5480 if (jj_scan_token(COLON)) return true;
5481 return false;
5482 }
5483
5484 private boolean jj_3R_300() {
5485 Token xsp;
5486 xsp = jj_scanpos;
5487 if (jj_3R_306()) {
5488 jj_scanpos = xsp;
5489 if (jj_3R_307()) return true;
5490 }
5491 return false;
5492 }
5493
5494 private boolean jj_3R_290() {
5495 if (jj_scan_token(COMMA)) return true;
5496 if (jj_3R_266()) return true;
5497 return false;
5498 }
5499
5500 private boolean jj_3R_292() {
5501 if (jj_3R_300()) return true;
5502 Token xsp;
5503 while (true) {
5504 xsp = jj_scanpos;
5505 if (jj_3R_301()) { jj_scanpos = xsp; break; }
5506 }
5507 return false;
5508 }
5509
5510 private boolean jj_3R_177() {
5511 if (jj_scan_token(SWITCH)) return true;
5512 if (jj_scan_token(LPAREN)) return true;
5513 if (jj_3R_74()) return true;
5514 if (jj_scan_token(RPAREN)) return true;
5515 if (jj_scan_token(LBRACE)) return true;
5516 Token xsp;
5517 while (true) {
5518 xsp = jj_scanpos;
5519 if (jj_3R_292()) { jj_scanpos = xsp; break; }
5520 }
5521 if (jj_scan_token(RBRACE)) return true;
5522 return false;
5523 }
5524
5525 private boolean jj_3R_305() {
5526 if (jj_3R_73()) return true;
5527 if (jj_3R_74()) return true;
5528 return false;
5529 }
5530
5531 private boolean jj_3R_299() {
5532 Token xsp;
5533 xsp = jj_scanpos;
5534 if (jj_scan_token(101)) {
5535 jj_scanpos = xsp;
5536 if (jj_scan_token(102)) {
5537 jj_scanpos = xsp;
5538 if (jj_3R_305()) return true;
5539 }
5540 }
5541 return false;
5542 }
5543
5544 private boolean jj_3R_194() {
5545 if (jj_3R_199()) return true;
5546 Token xsp;
5547 xsp = jj_scanpos;
5548 if (jj_3R_299()) jj_scanpos = xsp;
5549 return false;
5550 }
5551
5552 private boolean jj_3R_51() {
5553 if (jj_3R_89()) return true;
5554 return false;
5555 }
5556
5557 private boolean jj_3R_193() {
5558 if (jj_3R_198()) return true;
5559 return false;
5560 }
5561
5562 private boolean jj_3_1() {
5563 Token xsp;
5564 while (true) {
5565 xsp = jj_scanpos;
5566 if (jj_3R_51()) { jj_scanpos = xsp; break; }
5567 }
5568 if (jj_scan_token(PACKAGE)) return true;
5569 return false;
5570 }
5571
5572 private boolean jj_3R_176() {
5573 Token xsp;
5574 xsp = jj_scanpos;
5575 if (jj_3R_192()) {
5576 jj_scanpos = xsp;
5577 if (jj_3R_193()) {
5578 jj_scanpos = xsp;
5579 if (jj_3R_194()) return true;
5580 }
5581 }
5582 return false;
5583 }
5584
5585 private boolean jj_3R_192() {
5586 if (jj_3R_197()) return true;
5587 return false;
5588 }
5589
5590 private boolean jj_3_37() {
5591 if (jj_3R_85()) return true;
5592 if (jj_3R_66()) return true;
5593 if (jj_scan_token(IDENTIFIER)) return true;
5594 return false;
5595 }
5596
5597 private boolean jj_3R_149() {
5598 if (jj_3R_85()) return true;
5599 if (jj_3R_66()) return true;
5600 if (jj_3R_266()) return true;
5601 Token xsp;
5602 while (true) {
5603 xsp = jj_scanpos;
5604 if (jj_3R_290()) { jj_scanpos = xsp; break; }
5605 }
5606 return false;
5607 }
5608
5609 private boolean jj_3R_291() {
5610 if (jj_scan_token(COLON)) return true;
5611 if (jj_3R_74()) return true;
5612 return false;
5613 }
5614
5615 private boolean jj_3R_143() {
5616 if (jj_3R_151()) return true;
5617 return false;
5618 }
5619
5620 private boolean jj_3R_142() {
5621 if (jj_3R_150()) return true;
5622 return false;
5623 }
5624
5625 private boolean jj_3R_141() {
5626 if (jj_3R_149()) return true;
5627 if (jj_scan_token(SEMICOLON)) return true;
5628 return false;
5629 }
5630
5631 private boolean jj_3R_134() {
5632 Token xsp;
5633 xsp = jj_scanpos;
5634 if (jj_3R_141()) {
5635 jj_scanpos = xsp;
5636 if (jj_3R_142()) {
5637 jj_scanpos = xsp;
5638 if (jj_3R_143()) return true;
5639 }
5640 }
5641 return false;
5642 }
5643
5644 private boolean jj_3R_121() {
5645 if (jj_3R_134()) return true;
5646 return false;
5647 }
5648
5649 private boolean jj_3R_92() {
5650 if (jj_scan_token(LBRACE)) return true;
5651 Token xsp;
5652 while (true) {
5653 xsp = jj_scanpos;
5654 if (jj_3R_121()) { jj_scanpos = xsp; break; }
5655 }
5656 if (jj_scan_token(RBRACE)) return true;
5657 return false;
5658 }
5659
5660 private boolean jj_3R_84() {
5661 if (jj_scan_token(IDENTIFIER)) return true;
5662 if (jj_scan_token(COLON)) return true;
5663 if (jj_3R_150()) return true;
5664 return false;
5665 }
5666
5667 private boolean jj_3R_175() {
5668 if (jj_scan_token(ASSERT)) return true;
5669 if (jj_3R_74()) return true;
5670 Token xsp;
5671 xsp = jj_scanpos;
5672 if (jj_3R_291()) jj_scanpos = xsp;
5673 if (jj_scan_token(SEMICOLON)) return true;
5674 return false;
5675 }
5676
5677 private boolean jj_3R_170() {
5678 if (jj_3R_187()) return true;
5679 return false;
5680 }
5681
5682 private boolean jj_3R_169() {
5683 if (jj_3R_186()) return true;
5684 return false;
5685 }
5686
5687 private boolean jj_3_34() {
5688 if (jj_scan_token(LBRACKET)) return true;
5689 if (jj_scan_token(RBRACKET)) return true;
5690 return false;
5691 }
5692
5693 private boolean jj_3R_168() {
5694 if (jj_3R_185()) return true;
5695 return false;
5696 }
5697
5698 private boolean jj_3R_167() {
5699 if (jj_3R_184()) return true;
5700 return false;
5701 }
5702
5703 private boolean jj_3R_166() {
5704 if (jj_3R_183()) return true;
5705 return false;
5706 }
5707
5708 private boolean jj_3R_165() {
5709 if (jj_3R_182()) return true;
5710 return false;
5711 }
5712
5713 private boolean jj_3R_164() {
5714 if (jj_3R_181()) return true;
5715 return false;
5716 }
5717
5718 private boolean jj_3R_163() {
5719 if (jj_3R_180()) return true;
5720 return false;
5721 }
5722
5723 private boolean jj_3R_162() {
5724 if (jj_3R_179()) return true;
5725 return false;
5726 }
5727
5728 private boolean jj_3R_161() {
5729 if (jj_3R_178()) return true;
5730 return false;
5731 }
5732
5733 private boolean jj_3R_160() {
5734 if (jj_3R_177()) return true;
5735 return false;
5736 }
5737
5738 private boolean jj_3R_159() {
5739 if (jj_3R_176()) return true;
5740 if (jj_scan_token(SEMICOLON)) return true;
5741 return false;
5742 }
5743
5744 private boolean jj_3R_158() {
5745 if (jj_3R_92()) return true;
5746 return false;
5747 }
5748
5749 private boolean jj_3R_157() {
5750 if (jj_3R_175()) return true;
5751 return false;
5752 }
5753
5754 private boolean jj_3R_236() {
5755 if (jj_3R_72()) return true;
5756 return false;
5757 }
5758
5759 private boolean jj_3_36() {
5760 if (jj_3R_84()) return true;
5761 return false;
5762 }
5763
5764 private boolean jj_3R_150() {
5765 Token xsp;
5766 xsp = jj_scanpos;
5767 if (jj_3_36()) {
5768 jj_scanpos = xsp;
5769 if (jj_3R_157()) {
5770 jj_scanpos = xsp;
5771 if (jj_3R_158()) {
5772 jj_scanpos = xsp;
5773 if (jj_scan_token(85)) {
5774 jj_scanpos = xsp;
5775 if (jj_3R_159()) {
5776 jj_scanpos = xsp;
5777 if (jj_3R_160()) {
5778 jj_scanpos = xsp;
5779 if (jj_3R_161()) {
5780 jj_scanpos = xsp;
5781 if (jj_3R_162()) {
5782 jj_scanpos = xsp;
5783 if (jj_3R_163()) {
5784 jj_scanpos = xsp;
5785 if (jj_3R_164()) {
5786 jj_scanpos = xsp;
5787 if (jj_3R_165()) {
5788 jj_scanpos = xsp;
5789 if (jj_3R_166()) {
5790 jj_scanpos = xsp;
5791 if (jj_3R_167()) {
5792 jj_scanpos = xsp;
5793 if (jj_3R_168()) {
5794 jj_scanpos = xsp;
5795 if (jj_3R_169()) {
5796 jj_scanpos = xsp;
5797 if (jj_3R_170()) return true;
5798 }
5799 }
5800 }
5801 }
5802 }
5803 }
5804 }
5805 }
5806 }
5807 }
5808 }
5809 }
5810 }
5811 }
5812 }
5813 return false;
5814 }
5815
5816 private boolean jj_3R_240() {
5817 if (jj_3R_242()) return true;
5818 return false;
5819 }
5820
5821 private boolean jj_3R_241() {
5822 if (jj_scan_token(LBRACKET)) return true;
5823 if (jj_scan_token(RBRACKET)) return true;
5824 return false;
5825 }
5826
5827 private boolean jj_3_33() {
5828 if (jj_scan_token(LBRACKET)) return true;
5829 if (jj_3R_74()) return true;
5830 if (jj_scan_token(RBRACKET)) return true;
5831 return false;
5832 }
5833
5834 private boolean jj_3R_239() {
5835 Token xsp;
5836 if (jj_3R_241()) return true;
5837 while (true) {
5838 xsp = jj_scanpos;
5839 if (jj_3R_241()) { jj_scanpos = xsp; break; }
5840 }
5841 if (jj_3R_122()) return true;
5842 return false;
5843 }
5844
5845 private boolean jj_3_35() {
5846 Token xsp;
5847 if (jj_3_33()) return true;
5848 while (true) {
5849 xsp = jj_scanpos;
5850 if (jj_3_33()) { jj_scanpos = xsp; break; }
5851 }
5852 while (true) {
5853 xsp = jj_scanpos;
5854 if (jj_3_34()) { jj_scanpos = xsp; break; }
5855 }
5856 return false;
5857 }
5858
5859 private boolean jj_3R_235() {
5860 Token xsp;
5861 xsp = jj_scanpos;
5862 if (jj_3_35()) {
5863 jj_scanpos = xsp;
5864 if (jj_3R_239()) return true;
5865 }
5866 return false;
5867 }
5868
5869 private boolean jj_3R_238() {
5870 if (jj_3R_97()) return true;
5871 Token xsp;
5872 xsp = jj_scanpos;
5873 if (jj_3R_240()) jj_scanpos = xsp;
5874 return false;
5875 }
5876
5877 private boolean jj_3R_144() {
5878 if (jj_scan_token(COMMA)) return true;
5879 if (jj_3R_74()) return true;
5880 return false;
5881 }
5882
5883 private boolean jj_3R_237() {
5884 if (jj_3R_235()) return true;
5885 return false;
5886 }
5887
5888 private boolean jj_3R_112() {
5889 if (jj_scan_token(NEW)) return true;
5890 if (jj_3R_124()) return true;
5891 Token xsp;
5892 xsp = jj_scanpos;
5893 if (jj_3R_236()) jj_scanpos = xsp;
5894 xsp = jj_scanpos;
5895 if (jj_3R_237()) {
5896 jj_scanpos = xsp;
5897 if (jj_3R_238()) return true;
5898 }
5899 return false;
5900 }
5901
5902 private boolean jj_3R_82() {
5903 Token xsp;
5904 xsp = jj_scanpos;
5905 if (jj_3_32()) {
5906 jj_scanpos = xsp;
5907 if (jj_3R_112()) return true;
5908 }
5909 return false;
5910 }
5911
5912 private boolean jj_3_32() {
5913 if (jj_scan_token(NEW)) return true;
5914 if (jj_3R_78()) return true;
5915 if (jj_3R_235()) return true;
5916 return false;
5917 }
5918
5919 private boolean jj_3R_136() {
5920 if (jj_3R_74()) return true;
5921 Token xsp;
5922 while (true) {
5923 xsp = jj_scanpos;
5924 if (jj_3R_144()) { jj_scanpos = xsp; break; }
5925 }
5926 return false;
5927 }
5928
5929 private boolean jj_3R_123() {
5930 if (jj_3R_136()) return true;
5931 return false;
5932 }
5933
5934 private boolean jj_3R_97() {
5935 if (jj_scan_token(LPAREN)) return true;
5936 Token xsp;
5937 xsp = jj_scanpos;
5938 if (jj_3R_123()) jj_scanpos = xsp;
5939 if (jj_scan_token(RPAREN)) return true;
5940 return false;
5941 }
5942
5943 private boolean jj_3R_154() {
5944 Token xsp;
5945 xsp = jj_scanpos;
5946 if (jj_scan_token(60)) {
5947 jj_scanpos = xsp;
5948 if (jj_scan_token(29)) return true;
5949 }
5950 return false;
5951 }
5952
5953 private boolean jj_3R_146() {
5954 if (jj_3R_154()) return true;
5955 return false;
5956 }
5957
5958 private boolean jj_3R_128() {
5959 if (jj_3R_138()) return true;
5960 return false;
5961 }
5962
5963 private boolean jj_3R_138() {
5964 Token xsp;
5965 xsp = jj_scanpos;
5966 if (jj_scan_token(65)) {
5967 jj_scanpos = xsp;
5968 if (jj_scan_token(69)) {
5969 jj_scanpos = xsp;
5970 if (jj_scan_token(74)) {
5971 jj_scanpos = xsp;
5972 if (jj_scan_token(75)) {
5973 jj_scanpos = xsp;
5974 if (jj_3R_146()) {
5975 jj_scanpos = xsp;
5976 if (jj_scan_token(44)) return true;
5977 }
5978 }
5979 }
5980 }
5981 }
5982 return false;
5983 }
5984
5985 private boolean jj_3R_110() {
5986 if (jj_3R_97()) return true;
5987 return false;
5988 }
5989
5990 private boolean jj_3R_109() {
5991 if (jj_scan_token(DOT)) return true;
5992 if (jj_scan_token(IDENTIFIER)) return true;
5993 return false;
5994 }
5995
5996 private boolean jj_3_29() {
5997 if (jj_scan_token(DOT)) return true;
5998 if (jj_scan_token(THIS)) return true;
5999 return false;
6000 }
6001
6002 private boolean jj_3R_108() {
6003 if (jj_scan_token(LBRACKET)) return true;
6004 if (jj_3R_74()) return true;
6005 if (jj_scan_token(RBRACKET)) return true;
6006 return false;
6007 }
6008
6009 private boolean jj_3_28() {
6010 if (jj_scan_token(DOT)) return true;
6011 if (jj_scan_token(SUPER)) return true;
6012 if (jj_scan_token(DOT)) return true;
6013 return false;
6014 }
6015
6016 private boolean jj_3_31() {
6017 if (jj_3R_83()) return true;
6018 return false;
6019 }
6020
6021 private boolean jj_3_30() {
6022 if (jj_scan_token(DOT)) return true;
6023 if (jj_3R_82()) return true;
6024 return false;
6025 }
6026
6027 private boolean jj_3R_107() {
6028 if (jj_scan_token(DOT)) return true;
6029 if (jj_scan_token(THIS)) return true;
6030 return false;
6031 }
6032
6033 private boolean jj_3_27() {
6034 if (jj_3R_81()) return true;
6035 if (jj_scan_token(DOT)) return true;
6036 if (jj_scan_token(CLASS)) return true;
6037 return false;
6038 }
6039
6040 private boolean jj_3R_106() {
6041 if (jj_scan_token(DOT)) return true;
6042 if (jj_scan_token(SUPER)) return true;
6043 return false;
6044 }
6045
6046 private boolean jj_3R_79() {
6047 Token xsp;
6048 xsp = jj_scanpos;
6049 if (jj_3R_106()) {
6050 jj_scanpos = xsp;
6051 if (jj_3R_107()) {
6052 jj_scanpos = xsp;
6053 if (jj_3_30()) {
6054 jj_scanpos = xsp;
6055 if (jj_3_31()) {
6056 jj_scanpos = xsp;
6057 if (jj_3R_108()) {
6058 jj_scanpos = xsp;
6059 if (jj_3R_109()) {
6060 jj_scanpos = xsp;
6061 if (jj_3R_110()) return true;
6062 }
6063 }
6064 }
6065 }
6066 }
6067 }
6068 return false;
6069 }
6070
6071 private boolean jj_3R_80() {
6072 if (jj_scan_token(IDENTIFIER)) return true;
6073 if (jj_scan_token(DOT)) return true;
6074 return false;
6075 }
6076
6077 private boolean jj_3R_211() {
6078 if (jj_3R_86()) return true;
6079 return false;
6080 }
6081
6082 private boolean jj_3_26() {
6083 Token xsp;
6084 while (true) {
6085 xsp = jj_scanpos;
6086 if (jj_3R_80()) { jj_scanpos = xsp; break; }
6087 }
6088 if (jj_scan_token(THIS)) return true;
6089 return false;
6090 }
6091
6092 private boolean jj_3R_210() {
6093 if (jj_3R_81()) return true;
6094 if (jj_scan_token(DOT)) return true;
6095 if (jj_scan_token(CLASS)) return true;
6096 return false;
6097 }
6098
6099 private boolean jj_3R_209() {
6100 if (jj_3R_82()) return true;
6101 return false;
6102 }
6103
6104 private boolean jj_3R_208() {
6105 if (jj_scan_token(LPAREN)) return true;
6106 if (jj_3R_74()) return true;
6107 if (jj_scan_token(RPAREN)) return true;
6108 return false;
6109 }
6110
6111 private boolean jj_3_25() {
6112 if (jj_3R_79()) return true;
6113 return false;
6114 }
6115
6116 private boolean jj_3R_207() {
6117 if (jj_scan_token(SUPER)) return true;
6118 if (jj_scan_token(DOT)) return true;
6119 if (jj_scan_token(IDENTIFIER)) return true;
6120 return false;
6121 }
6122
6123 private boolean jj_3R_214() {
6124 if (jj_scan_token(IDENTIFIER)) return true;
6125 if (jj_scan_token(DOT)) return true;
6126 return false;
6127 }
6128
6129 private boolean jj_3R_206() {
6130 Token xsp;
6131 while (true) {
6132 xsp = jj_scanpos;
6133 if (jj_3R_214()) { jj_scanpos = xsp; break; }
6134 }
6135 if (jj_scan_token(THIS)) return true;
6136 return false;
6137 }
6138
6139 private boolean jj_3R_202() {
6140 Token xsp;
6141 xsp = jj_scanpos;
6142 if (jj_3R_205()) {
6143 jj_scanpos = xsp;
6144 if (jj_3R_206()) {
6145 jj_scanpos = xsp;
6146 if (jj_3R_207()) {
6147 jj_scanpos = xsp;
6148 if (jj_3R_208()) {
6149 jj_scanpos = xsp;
6150 if (jj_3R_209()) {
6151 jj_scanpos = xsp;
6152 if (jj_3R_210()) {
6153 jj_scanpos = xsp;
6154 if (jj_3R_211()) return true;
6155 }
6156 }
6157 }
6158 }
6159 }
6160 }
6161 return false;
6162 }
6163
6164 private boolean jj_3R_205() {
6165 if (jj_3R_138()) return true;
6166 return false;
6167 }
6168
6169 private boolean jj_3R_234() {
6170 Token xsp;
6171 xsp = jj_scanpos;
6172 if (jj_scan_token(101)) {
6173 jj_scanpos = xsp;
6174 if (jj_scan_token(102)) return true;
6175 }
6176 return false;
6177 }
6178
6179 private boolean jj_3R_83() {
6180 if (jj_scan_token(DOT)) return true;
6181 if (jj_3R_72()) return true;
6182 if (jj_scan_token(IDENTIFIER)) return true;
6183 return false;
6184 }
6185
6186 private boolean jj_3_24() {
6187 if (jj_scan_token(LPAREN)) return true;
6188 if (jj_3R_78()) return true;
6189 return false;
6190 }
6191
6192 private boolean jj_3R_199() {
6193 if (jj_3R_202()) return true;
6194 Token xsp;
6195 while (true) {
6196 xsp = jj_scanpos;
6197 if (jj_3_25()) { jj_scanpos = xsp; break; }
6198 }
6199 return false;
6200 }
6201
6202 private boolean jj_3R_233() {
6203 if (jj_scan_token(LPAREN)) return true;
6204 if (jj_3R_66()) return true;
6205 if (jj_scan_token(RPAREN)) return true;
6206 if (jj_3R_224()) return true;
6207 return false;
6208 }
6209
6210 private boolean jj_3R_230() {
6211 Token xsp;
6212 xsp = jj_scanpos;
6213 if (jj_3R_232()) {
6214 jj_scanpos = xsp;
6215 if (jj_3R_233()) return true;
6216 }
6217 return false;
6218 }
6219
6220 private boolean jj_3R_232() {
6221 if (jj_scan_token(LPAREN)) return true;
6222 if (jj_3R_66()) return true;
6223 if (jj_scan_token(RPAREN)) return true;
6224 if (jj_3R_218()) return true;
6225 return false;
6226 }
6227
6228 private boolean jj_3_23() {
6229 if (jj_scan_token(LPAREN)) return true;
6230 if (jj_3R_66()) return true;
6231 if (jj_scan_token(LBRACKET)) return true;
6232 return false;
6233 }
6234
6235 private boolean jj_3R_231() {
6236 if (jj_3R_199()) return true;
6237 Token xsp;
6238 xsp = jj_scanpos;
6239 if (jj_3R_234()) jj_scanpos = xsp;
6240 return false;
6241 }
6242
6243 private boolean jj_3R_105() {
6244 if (jj_scan_token(LPAREN)) return true;
6245 if (jj_3R_66()) return true;
6246 if (jj_scan_token(RPAREN)) return true;
6247 Token xsp;
6248 xsp = jj_scanpos;
6249 if (jj_scan_token(92)) {
6250 jj_scanpos = xsp;
6251 if (jj_scan_token(91)) {
6252 jj_scanpos = xsp;
6253 if (jj_scan_token(79)) {
6254 jj_scanpos = xsp;
6255 if (jj_scan_token(76)) {
6256 jj_scanpos = xsp;
6257 if (jj_scan_token(56)) {
6258 jj_scanpos = xsp;
6259 if (jj_scan_token(53)) {
6260 jj_scanpos = xsp;
6261 if (jj_scan_token(43)) {
6262 jj_scanpos = xsp;
6263 if (jj_3R_128()) return true;
6264 }
6265 }
6266 }
6267 }
6268 }
6269 }
6270 }
6271 return false;
6272 }
6273
6274 private boolean jj_3R_104() {
6275 if (jj_scan_token(LPAREN)) return true;
6276 if (jj_3R_66()) return true;
6277 if (jj_scan_token(LBRACKET)) return true;
6278 if (jj_scan_token(RBRACKET)) return true;
6279 return false;
6280 }
6281
6282 private boolean jj_3_22() {
6283 if (jj_scan_token(LPAREN)) return true;
6284 if (jj_3R_78()) return true;
6285 return false;
6286 }
6287
6288 private boolean jj_3R_77() {
6289 Token xsp;
6290 xsp = jj_scanpos;
6291 if (jj_3_22()) {
6292 jj_scanpos = xsp;
6293 if (jj_3R_104()) {
6294 jj_scanpos = xsp;
6295 if (jj_3R_105()) return true;
6296 }
6297 }
6298 return false;
6299 }
6300
6301 private boolean jj_3_21() {
6302 if (jj_3R_77()) return true;
6303 return false;
6304 }
6305
6306 private boolean jj_3_20() {
6307 if (jj_3R_76()) return true;
6308 return false;
6309 }
6310
6311 private boolean jj_3R_228() {
6312 if (jj_3R_231()) return true;
6313 return false;
6314 }
6315
6316 private boolean jj_3R_227() {
6317 if (jj_3R_230()) return true;
6318 return false;
6319 }
6320
6321 private boolean jj_3R_224() {
6322 Token xsp;
6323 xsp = jj_scanpos;
6324 if (jj_3R_226()) {
6325 jj_scanpos = xsp;
6326 if (jj_3R_227()) {
6327 jj_scanpos = xsp;
6328 if (jj_3R_228()) return true;
6329 }
6330 }
6331 return false;
6332 }
6333
6334 private boolean jj_3R_226() {
6335 Token xsp;
6336 xsp = jj_scanpos;
6337 if (jj_scan_token(92)) {
6338 jj_scanpos = xsp;
6339 if (jj_scan_token(91)) return true;
6340 }
6341 if (jj_3R_218()) return true;
6342 return false;
6343 }
6344
6345 private boolean jj_3R_198() {
6346 if (jj_scan_token(DECR)) return true;
6347 if (jj_3R_199()) return true;
6348 return false;
6349 }
6350
6351 private boolean jj_3R_225() {
6352 Token xsp;
6353 xsp = jj_scanpos;
6354 if (jj_scan_token(103)) {
6355 jj_scanpos = xsp;
6356 if (jj_scan_token(104)) return true;
6357 }
6358 if (jj_3R_216()) return true;
6359 return false;
6360 }
6361
6362 private boolean jj_3_19() {
6363 if (jj_3R_75()) return true;
6364 return false;
6365 }
6366
6367 private boolean jj_3R_229() {
6368 Token xsp;
6369 xsp = jj_scanpos;
6370 if (jj_scan_token(105)) {
6371 jj_scanpos = xsp;
6372 if (jj_scan_token(106)) {
6373 jj_scanpos = xsp;
6374 if (jj_scan_token(110)) return true;
6375 }
6376 }
6377 if (jj_3R_218()) return true;
6378 return false;
6379 }
6380
6381 private boolean jj_3R_197() {
6382 if (jj_scan_token(INCR)) return true;
6383 if (jj_3R_199()) return true;
6384 return false;
6385 }
6386
6387 private boolean jj_3R_223() {
6388 if (jj_3R_224()) return true;
6389 return false;
6390 }
6391
6392 private boolean jj_3_18() {
6393 Token xsp;
6394 xsp = jj_scanpos;
6395 if (jj_scan_token(111)) {
6396 jj_scanpos = xsp;
6397 if (jj_3_19()) {
6398 jj_scanpos = xsp;
6399 if (jj_3_20()) return true;
6400 }
6401 }
6402 if (jj_3R_213()) return true;
6403 return false;
6404 }
6405
6406 private boolean jj_3R_222() {
6407 if (jj_3R_198()) return true;
6408 return false;
6409 }
6410
6411 private boolean jj_3R_221() {
6412 if (jj_3R_197()) return true;
6413 return false;
6414 }
6415
6416 private boolean jj_3R_218() {
6417 Token xsp;
6418 xsp = jj_scanpos;
6419 if (jj_3R_220()) {
6420 jj_scanpos = xsp;
6421 if (jj_3R_221()) {
6422 jj_scanpos = xsp;
6423 if (jj_3R_222()) {
6424 jj_scanpos = xsp;
6425 if (jj_3R_223()) return true;
6426 }
6427 }
6428 }
6429 return false;
6430 }
6431
6432 private boolean jj_3R_220() {
6433 Token xsp;
6434 xsp = jj_scanpos;
6435 if (jj_scan_token(103)) {
6436 jj_scanpos = xsp;
6437 if (jj_scan_token(104)) return true;
6438 }
6439 if (jj_3R_218()) return true;
6440 return false;
6441 }
6442
6443 private boolean jj_3R_219() {
6444 Token xsp;
6445 xsp = jj_scanpos;
6446 if (jj_scan_token(90)) {
6447 jj_scanpos = xsp;
6448 if (jj_scan_token(126)) {
6449 jj_scanpos = xsp;
6450 if (jj_scan_token(96)) {
6451 jj_scanpos = xsp;
6452 if (jj_scan_token(97)) return true;
6453 }
6454 }
6455 }
6456 if (jj_3R_204()) return true;
6457 return false;
6458 }
6459
6460 private boolean jj_3R_217() {
6461 if (jj_scan_token(INSTANCEOF)) return true;
6462 if (jj_3R_66()) return true;
6463 return false;
6464 }
6465
6466 private boolean jj_3R_216() {
6467 if (jj_3R_218()) return true;
6468 Token xsp;
6469 while (true) {
6470 xsp = jj_scanpos;
6471 if (jj_3R_229()) { jj_scanpos = xsp; break; }
6472 }
6473 return false;
6474 }
6475
6476 private boolean jj_3R_215() {
6477 Token xsp;
6478 xsp = jj_scanpos;
6479 if (jj_scan_token(95)) {
6480 jj_scanpos = xsp;
6481 if (jj_scan_token(98)) return true;
6482 }
6483 if (jj_3R_196()) return true;
6484 return false;
6485 }
6486
6487 private boolean jj_3R_213() {
6488 if (jj_3R_216()) return true;
6489 Token xsp;
6490 while (true) {
6491 xsp = jj_scanpos;
6492 if (jj_3R_225()) { jj_scanpos = xsp; break; }
6493 }
6494 return false;
6495 }
6496
6497 private boolean jj_3R_204() {
6498 if (jj_3R_213()) return true;
6499 Token xsp;
6500 while (true) {
6501 xsp = jj_scanpos;
6502 if (jj_3_18()) { jj_scanpos = xsp; break; }
6503 }
6504 return false;
6505 }
6506
6507 private boolean jj_3R_212() {
6508 if (jj_scan_token(BIT_AND)) return true;
6509 if (jj_3R_191()) return true;
6510 return false;
6511 }
6512
6513 private boolean jj_3R_201() {
6514 if (jj_3R_204()) return true;
6515 Token xsp;
6516 while (true) {
6517 xsp = jj_scanpos;
6518 if (jj_3R_219()) { jj_scanpos = xsp; break; }
6519 }
6520 return false;
6521 }
6522
6523 private boolean jj_3R_200() {
6524 if (jj_scan_token(BIT_OR)) return true;
6525 if (jj_3R_153()) return true;
6526 return false;
6527 }
6528
6529 private boolean jj_3R_196() {
6530 if (jj_3R_201()) return true;
6531 Token xsp;
6532 xsp = jj_scanpos;
6533 if (jj_3R_217()) jj_scanpos = xsp;
6534 return false;
6535 }
6536
6537 private boolean jj_3R_203() {
6538 if (jj_scan_token(XOR)) return true;
6539 if (jj_3R_174()) return true;
6540 return false;
6541 }
6542
6543 private boolean jj_3R_195() {
6544 if (jj_scan_token(SC_AND)) return true;
6545 if (jj_3R_145()) return true;
6546 return false;
6547 }
6548
6549 private boolean jj_3R_191() {
6550 if (jj_3R_196()) return true;
6551 Token xsp;
6552 while (true) {
6553 xsp = jj_scanpos;
6554 if (jj_3R_215()) { jj_scanpos = xsp; break; }
6555 }
6556 return false;
6557 }
6558
6559 private boolean jj_3R_190() {
6560 if (jj_scan_token(SC_OR)) return true;
6561 if (jj_3R_137()) return true;
6562 return false;
6563 }
6564
6565 private boolean jj_3R_174() {
6566 if (jj_3R_191()) return true;
6567 Token xsp;
6568 while (true) {
6569 xsp = jj_scanpos;
6570 if (jj_3R_212()) { jj_scanpos = xsp; break; }
6571 }
6572 return false;
6573 }
6574
6575 private boolean jj_3R_173() {
6576 if (jj_scan_token(HOOK)) return true;
6577 if (jj_3R_74()) return true;
6578 if (jj_scan_token(COLON)) return true;
6579 if (jj_3R_74()) return true;
6580 return false;
6581 }
6582
6583 private boolean jj_3R_153() {
6584 if (jj_3R_174()) return true;
6585 Token xsp;
6586 while (true) {
6587 xsp = jj_scanpos;
6588 if (jj_3R_203()) { jj_scanpos = xsp; break; }
6589 }
6590 return false;
6591 }
6592
6593 private boolean jj_3R_145() {
6594 if (jj_3R_153()) return true;
6595 Token xsp;
6596 while (true) {
6597 xsp = jj_scanpos;
6598 if (jj_3R_200()) { jj_scanpos = xsp; break; }
6599 }
6600 return false;
6601 }
6602
6603 private boolean jj_3R_137() {
6604 if (jj_3R_145()) return true;
6605 Token xsp;
6606 while (true) {
6607 xsp = jj_scanpos;
6608 if (jj_3R_195()) { jj_scanpos = xsp; break; }
6609 }
6610 return false;
6611 }
6612
6613 private boolean jj_3R_127() {
6614 if (jj_3R_137()) return true;
6615 Token xsp;
6616 while (true) {
6617 xsp = jj_scanpos;
6618 if (jj_3R_190()) { jj_scanpos = xsp; break; }
6619 }
6620 return false;
6621 }
6622
6623 private boolean jj_3R_101() {
6624 if (jj_3R_127()) return true;
6625 Token xsp;
6626 xsp = jj_scanpos;
6627 if (jj_3R_173()) jj_scanpos = xsp;
6628 return false;
6629 }
6630
6631 private boolean jj_3R_73() {
6632 Token xsp;
6633 xsp = jj_scanpos;
6634 if (jj_scan_token(89)) {
6635 jj_scanpos = xsp;
6636 if (jj_scan_token(114)) {
6637 jj_scanpos = xsp;
6638 if (jj_scan_token(115)) {
6639 jj_scanpos = xsp;
6640 if (jj_scan_token(119)) {
6641 jj_scanpos = xsp;
6642 if (jj_scan_token(112)) {
6643 jj_scanpos = xsp;
6644 if (jj_scan_token(113)) {
6645 jj_scanpos = xsp;
6646 if (jj_scan_token(120)) {
6647 jj_scanpos = xsp;
6648 if (jj_scan_token(121)) {
6649 jj_scanpos = xsp;
6650 if (jj_scan_token(122)) {
6651 jj_scanpos = xsp;
6652 if (jj_scan_token(116)) {
6653 jj_scanpos = xsp;
6654 if (jj_scan_token(118)) {
6655 jj_scanpos = xsp;
6656 if (jj_scan_token(117)) return true;
6657 }
6658 }
6659 }
6660 }
6661 }
6662 }
6663 }
6664 }
6665 }
6666 }
6667 }
6668 return false;
6669 }
6670
6671 private boolean jj_3_17() {
6672 if (jj_3R_73()) return true;
6673 if (jj_3R_74()) return true;
6674 return false;
6675 }
6676
6677 private boolean jj_3R_74() {
6678 if (jj_3R_101()) return true;
6679 Token xsp;
6680 xsp = jj_scanpos;
6681 if (jj_3_17()) jj_scanpos = xsp;
6682 return false;
6683 }
6684
6685 private boolean jj_3R_286() {
6686 if (jj_scan_token(COMMA)) return true;
6687 if (jj_3R_86()) return true;
6688 return false;
6689 }
6690
6691 private boolean jj_3R_277() {
6692 if (jj_3R_86()) return true;
6693 Token xsp;
6694 while (true) {
6695 xsp = jj_scanpos;
6696 if (jj_3R_286()) { jj_scanpos = xsp; break; }
6697 }
6698 return false;
6699 }
6700
6701 private boolean jj_3_16() {
6702 if (jj_scan_token(DOT)) return true;
6703 if (jj_scan_token(IDENTIFIER)) return true;
6704 return false;
6705 }
6706
6707 private boolean jj_3R_86() {
6708 if (jj_scan_token(IDENTIFIER)) return true;
6709 Token xsp;
6710 while (true) {
6711 xsp = jj_scanpos;
6712 if (jj_3_16()) { jj_scanpos = xsp; break; }
6713 }
6714 return false;
6715 }
6716
6717 private boolean jj_3R_111() {
6718 if (jj_3R_66()) return true;
6719 return false;
6720 }
6721
6722 private boolean jj_3R_81() {
6723 Token xsp;
6724 xsp = jj_scanpos;
6725 if (jj_scan_token(62)) {
6726 jj_scanpos = xsp;
6727 if (jj_3R_111()) return true;
6728 }
6729 return false;
6730 }
6731
6732 private boolean jj_3_15() {
6733 if (jj_3R_72()) return true;
6734 return false;
6735 }
6736
6737 private boolean jj_3R_78() {
6738 Token xsp;
6739 xsp = jj_scanpos;
6740 if (jj_scan_token(14)) {
6741 jj_scanpos = xsp;
6742 if (jj_scan_token(19)) {
6743 jj_scanpos = xsp;
6744 if (jj_scan_token(16)) {
6745 jj_scanpos = xsp;
6746 if (jj_scan_token(50)) {
6747 jj_scanpos = xsp;
6748 if (jj_scan_token(39)) {
6749 jj_scanpos = xsp;
6750 if (jj_scan_token(41)) {
6751 jj_scanpos = xsp;
6752 if (jj_scan_token(32)) {
6753 jj_scanpos = xsp;
6754 if (jj_scan_token(25)) return true;
6755 }
6756 }
6757 }
6758 }
6759 }
6760 }
6761 }
6762 return false;
6763 }
6764
6765 private boolean jj_3R_135() {
6766 if (jj_scan_token(COMMA)) return true;
6767 if (jj_3R_100()) return true;
6768 return false;
6769 }
6770
6771 private boolean jj_3_12() {
6772 if (jj_scan_token(LBRACKET)) return true;
6773 if (jj_scan_token(RBRACKET)) return true;
6774 return false;
6775 }
6776
6777 private boolean jj_3R_189() {
6778 if (jj_scan_token(SUPER)) return true;
6779 if (jj_3R_71()) return true;
6780 return false;
6781 }
6782
6783 private boolean jj_3R_152() {
6784 if (jj_3R_172()) return true;
6785 return false;
6786 }
6787
6788 private boolean jj_3R_172() {
6789 Token xsp;
6790 xsp = jj_scanpos;
6791 if (jj_3R_188()) {
6792 jj_scanpos = xsp;
6793 if (jj_3R_189()) return true;
6794 }
6795 return false;
6796 }
6797
6798 private boolean jj_3R_188() {
6799 if (jj_scan_token(EXTENDS)) return true;
6800 if (jj_3R_71()) return true;
6801 return false;
6802 }
6803
6804 private boolean jj_3R_126() {
6805 if (jj_scan_token(HOOK)) return true;
6806 Token xsp;
6807 xsp = jj_scanpos;
6808 if (jj_3R_152()) jj_scanpos = xsp;
6809 return false;
6810 }
6811
6812 private boolean jj_3_13() {
6813 if (jj_3R_72()) return true;
6814 return false;
6815 }
6816
6817 private boolean jj_3R_125() {
6818 if (jj_3R_71()) return true;
6819 return false;
6820 }
6821
6822 private boolean jj_3R_100() {
6823 Token xsp;
6824 xsp = jj_scanpos;
6825 if (jj_3R_125()) {
6826 jj_scanpos = xsp;
6827 if (jj_3R_126()) return true;
6828 }
6829 return false;
6830 }
6831
6832 private boolean jj_3_11() {
6833 if (jj_scan_token(LBRACKET)) return true;
6834 if (jj_scan_token(RBRACKET)) return true;
6835 return false;
6836 }
6837
6838 private boolean jj_3R_72() {
6839 if (jj_scan_token(LT)) return true;
6840 if (jj_3R_100()) return true;
6841 Token xsp;
6842 while (true) {
6843 xsp = jj_scanpos;
6844 if (jj_3R_135()) { jj_scanpos = xsp; break; }
6845 }
6846 if (jj_scan_token(GT)) return true;
6847 return false;
6848 }
6849
6850 private boolean jj_3_14() {
6851 if (jj_scan_token(DOT)) return true;
6852 if (jj_scan_token(IDENTIFIER)) return true;
6853 Token xsp;
6854 xsp = jj_scanpos;
6855 if (jj_3_15()) jj_scanpos = xsp;
6856 return false;
6857 }
6858
6859 /** Generated Token Manager. */
6860 public JavaParser15DebugTokenManager token_source;
6861 JavaCharStream jj_input_stream;
6862 /** Current token. */
6863 public Token token;
6864 /** Next token. */
6865 public Token jj_nt;
6866 private int jj_ntk;
6867 private Token jj_scanpos, jj_lastpos;
6868 private int jj_la;
6869 /** Whether we are looking ahead. */
6870 private boolean jj_lookingAhead = false;
6871 private boolean jj_semLA;
6872
6873 /** Constructor with InputStream. */
6874 public JavaParser15Debug(java.io.InputStream stream) {
6875 this(stream, null);
6876 }
6877 /** Constructor with InputStream and supplied encoding */
6878 public JavaParser15Debug(java.io.InputStream stream, String encoding) {
6879 try { jj_input_stream = new JavaCharStream(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); }
6880 token_source = new JavaParser15DebugTokenManager(jj_input_stream);
6881 token = new Token();
6882 jj_ntk = -1;
6883 }
6884
6885 /** Reinitialise. */
6886 public void ReInit(java.io.InputStream stream) {
6887 ReInit(stream, null);
6888 }
6889 /** Reinitialise. */
6890 public void ReInit(java.io.InputStream stream, String encoding) {
6891 try { jj_input_stream.ReInit(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); }
6892 token_source.ReInit(jj_input_stream);
6893 token = new Token();
6894 jj_ntk = -1;
6895 }
6896
6897 /** Constructor. */
6898 public JavaParser15Debug(java.io.Reader stream) {
6899 jj_input_stream = new JavaCharStream(stream, 1, 1);
6900 token_source = new JavaParser15DebugTokenManager(jj_input_stream);
6901 token = new Token();
6902 jj_ntk = -1;
6903 }
6904
6905 /** Reinitialise. */
6906 public void ReInit(java.io.Reader stream) {
6907 jj_input_stream.ReInit(stream, 1, 1);
6908 token_source.ReInit(jj_input_stream);
6909 token = new Token();
6910 jj_ntk = -1;
6911 }
6912
6913 /** Constructor with generated Token Manager. */
6914 public JavaParser15Debug(JavaParser15DebugTokenManager tm) {
6915 token_source = tm;
6916 token = new Token();
6917 jj_ntk = -1;
6918 }
6919
6920 /** Reinitialise. */
6921 public void ReInit(JavaParser15DebugTokenManager tm) {
6922 token_source = tm;
6923 token = new Token();
6924 jj_ntk = -1;
6925 }
6926
6927 private Token jj_consume_token(int kind) throws ParseException {
6928 Token oldToken;
6929 if ((oldToken = token).next != null) token = token.next;
6930 else token = token.next = token_source.getNextToken();
6931 jj_ntk = -1;
6932 if (token.kind == kind) {
6933 trace_token(token, "");
6934 return token;
6935 }
6936 token = oldToken;
6937 throw generateParseException();
6938 }
6939
6940 static private final class LookaheadSuccess extends java.lang.Error { }
6941 final private LookaheadSuccess jj_ls = new LookaheadSuccess();
6942 private boolean jj_scan_token(int kind) {
6943 if (jj_scanpos == jj_lastpos) {
6944 jj_la--;
6945 if (jj_scanpos.next == null) {
6946 jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
6947 } else {
6948 jj_lastpos = jj_scanpos = jj_scanpos.next;
6949 }
6950 } else {
6951 jj_scanpos = jj_scanpos.next;
6952 }
6953 if (jj_scanpos.kind != kind) return true;
6954 if (jj_la == 0 && jj_scanpos == jj_lastpos) throw jj_ls;
6955 return false;
6956 }
6957
6958
6959 /** Get the next Token. */
6960 final public Token getNextToken() {
6961 if (token.next != null) token = token.next;
6962 else token = token.next = token_source.getNextToken();
6963 jj_ntk = -1;
6964 trace_token(token, " (in getNextToken)");
6965 return token;
6966 }
6967
6968 /** Get the specific Token. */
6969 final public Token getToken(int index) {
6970 Token t = jj_lookingAhead ? jj_scanpos : token;
6971 for (int i = 0; i < index; i++) {
6972 if (t.next != null) t = t.next;
6973 else t = t.next = token_source.getNextToken();
6974 }
6975 return t;
6976 }
6977
6978 private int jj_ntk() {
6979 if ((jj_nt=token.next) == null)
6980 return (jj_ntk = (token.next=token_source.getNextToken()).kind);
6981 else
6982 return (jj_ntk = jj_nt.kind);
6983 }
6984
6985 /** Generate ParseException. */
6986 public ParseException generateParseException() {
6987 Token errortok = token.next;
6988 int line = errortok.beginLine, column = errortok.beginColumn;
6989 String mess = (errortok.kind == 0) ? tokenImage[0] : errortok.image;
6990 return new ParseException("Parse error at line " + line + ", column " + column + ". Encountered: " + mess);
6991 }
6992
6993 private int trace_indent = 0;
6994 private boolean trace_enabled = true;
6995
6996 /** Enable tracing. */
6997 final public void enable_tracing() {
6998 trace_enabled = true;
6999 }
7000
7001 /** Disable tracing. */
7002 final public void disable_tracing() {
7003 trace_enabled = false;
7004 }
7005
7006 private void trace_call(String s) {
7007 if (trace_enabled) {
7008 for (int i = 0; i < trace_indent; i++) { System.out.print(" "); }
7009 System.out.println("Call: " + s);
7010 }
7011 trace_indent = trace_indent + 2;
7012 }
7013
7014 private void trace_return(String s) {
7015 trace_indent = trace_indent - 2;
7016 if (trace_enabled) {
7017 for (int i = 0; i < trace_indent; i++) { System.out.print(" "); }
7018 System.out.println("Return: " + s);
7019 }
7020 }
7021
7022 private void trace_token(Token t, String where) {
7023 if (trace_enabled) {
7024 for (int i = 0; i < trace_indent; i++) { System.out.print(" "); }
7025 System.out.print("Consumed token: <" + tokenImage[t.kind]);
7026 if (t.kind != 0 && !tokenImage[t.kind].equals("\"" + t.image + "\"")) {
7027 System.out.print(": \"" + t.image + "\"");
7028 }
7029 System.out.println(" at line " + t.beginLine + " column " + t.beginColumn + ">" + where);
7030 }
7031 }
7032
7033 private void trace_scan(Token t1, int t2) {
7034 if (trace_enabled) {
7035 for (int i = 0; i < trace_indent; i++) { System.out.print(" "); }
7036 System.out.print("Visited token: <" + tokenImage[t1.kind]);
7037 if (t1.kind != 0 && !tokenImage[t1.kind].equals("\"" + t1.image + "\"")) {
7038 System.out.print(": \"" + t1.image + "\"");
7039 }
7040 System.out.println(" at line " + t1.beginLine + " column " + t1.beginColumn + ">; Expected token: <" + tokenImage[t2] + ">");
7041 }
7042 }
7043
7044 }