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