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