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