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