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    }