001    /* Generated By:JavaCC: Do not edit this line. JavaParser.java */
002    package javancss.parser;
003    
004    import java.util.*;
005    
006    import ccl.util.Util;
007    
008    import javancss.FunctionMetric;
009    import javancss.ObjectMetric;
010    import javancss.PackageMetric;
011    
012    /**
013     * Java source code parser based on a grammar compiled by
014     * JavaCC from Java1.1.jj to the JavaParser class.<p>
015     *
016     * This class is responsible for parsing Java code and counting
017     * all metrics during this parsing process.
018     * The rest of the application is only responsible for invoking
019     * this parser in a convenient way and to present the results
020     * to the user.<p>
021     *
022     * This grammar is based on the Java grammar that comes as an
023     * example with JavaCC, but has been extended to collect the
024     * metrics data (and adapted to support real life and jdk 1.4
025     * Java sources as well).
026     *
027     * @author    Sriram Sankar (original JavaCC grammar)
028     *            , Chr. Clemens Lee <clemens@kclee.com> (JavaNCSS metrics)
029     *            , additional counting of javadoc comments done by
030     *              Emilio Gongora, <emilio@sms.nl> and
031     *              Guillermo Rodriguez, <guille@sms.nl>.
032     *            Anonymous class count patch by Vesa Karvonnen, <vesa_karvonen@hotmail.com> 2002-10-30.
033     * @version   2000-01-31 $Id: Java1.1.jj 171 2009-05-31 20:12:01Z hboutemy $
034     */
035    public class JavaParser implements JavaParserInterface, JavaParserConstants {
036        {
037            /* // DEBUG MODE
038            Util.setDebug( true );
039            // */
040        }
041        private boolean _bReturn         = false;
042        private int     _ncss            = 0;     // general counter
043        private int     _loc             = 0;
044        private int     _cyc             = 1;
045        private int     _localCases      = 0;
046        private String  _sName           = "";    // name of last token
047        private String  _sParameter      = "";
048        private String  _sPackage        = "";
049        private String  _sClass          = "";
050        private String  _sFunction       = "";
051        private int     _functions       = 0;     // number of functions in this class
052        //private int     _topLevelClasses = 0;
053        private int     _classes         = 0;
054        private int     _classLevel      = 0;
055        private int     _anonClassCount  = 1;
056    
057        private int     _jvdcLines = 0;           // added by SMS
058        private int     _jvdc      = 0;
059        private boolean _bPrivate  = true;//false;        // added by SMS
060        private boolean _bPublic   = true;        // added by SMS
061    
062        /**
063         * For each class the number of formal
064         * comments in toplevel methods, constructors, inner
065         * classes, and for the class itself are counted.
066         * The top level comment has to be directly before
067         * the class definition, not before the package or
068         * import statement as it is often seen in source code
069         * examples (at the beginning of your source files you
070         * should instead put your copyright notice).
071         */
072        private int    _javadocs   = 0;              // global javadocs
073        private List/*<FunctionMetric>*/ _vFunctions = new ArrayList();   // holds the statistics for each method
074    
075        /**
076         * Metrics for each class/interface are stored in this
077         * vector.
078         */
079        private List/*<ObjectMetric>*/ _vClasses = new ArrayList();
080        private List _vImports = new ArrayList();
081        private Object[] _aoPackage = null;
082        private Map/*<String,PackageMetric>*/ _htPackage = new HashMap();
083        private PackageMetric _pPackageMetric;
084    
085        private Token _tmpToken = null;
086        /** Argh, too much of a state machine. */
087        private Token _tmpResultToken = null;
088    
089        private String _formatPackage(String sPackage_) {
090            if (sPackage_.equals("")) {
091                return ".";
092            }
093    
094            return sPackage_.substring(0, sPackage_.length() - 1);
095        }
096    
097        public void parse() throws Exception {
098          CompilationUnit();
099        }
100    
101        public void parseImportUnit() throws Exception {
102          ImportUnit();
103        }
104    
105        public int getNcss() {
106            return _ncss;
107        }
108    
109        public int getLOC() {
110            return _loc;
111        }
112    
113        // added by SMS
114        public int getJvdc() {
115            return _jvdc;
116        }
117    
118        /*public int getTopLevelClasses() {
119          return _topLevelClasses;
120          }*/
121    
122        public List/*<FunctionMetric>*/ getFunction() {
123            return _vFunctions;
124        }
125    
126        /**
127         * @return Top level classes in sorted order
128         */
129        public List/*<ObjectMetric>*/ getObject() {
130            Collections.sort(_vClasses);
131            return _vClasses;
132        }
133    
134        /**
135         * @return The empty package consists of the name ".".
136         */
137        public Map/*<String,PackageMetric>*/ getPackage() {
138            return _htPackage;
139        }
140    
141        public List getImports() {
142            return _vImports;
143        }
144    
145        /**
146         * name, beginLine, ...
147         */
148        public Object[] getPackageObjects() {
149            return _aoPackage;
150        }
151    
152        /**
153         * if javancss is used with cat *.java a long
154         * input stream might get generated, so line
155         * number information in case of an parse exception
156         * is not very useful.
157         */
158        public String getLastFunction() {
159            return _sPackage + _sClass + _sFunction;
160        }
161    
162       /**
163        * Class to hold modifiers.
164        */
165       static public final class ModifierSet
166       {
167         /* Definitions of the bits in the modifiers field.  */
168         public static final int PUBLIC = 0x0001;
169         public static final int PROTECTED = 0x0002;
170         public static final int PRIVATE = 0x0004;
171         public static final int ABSTRACT = 0x0008;
172         public static final int STATIC = 0x0010;
173         public static final int FINAL = 0x0020;
174         public static final int SYNCHRONIZED = 0x0040;
175         public static final int NATIVE = 0x0080;
176         public static final int TRANSIENT = 0x0100;
177         public static final int VOLATILE = 0x0200;
178         public static final int STRICTFP = 0x1000;
179    
180         /** A set of accessors that indicate whether the specified modifier
181             is in the set. */
182    
183         public boolean isPublic(int modifiers)
184         {
185           return (modifiers & PUBLIC) != 0;
186         }
187    
188         public boolean isProtected(int modifiers)
189         {
190           return (modifiers & PROTECTED) != 0;
191         }
192    
193         public boolean isPrivate(int modifiers)
194         {
195           return (modifiers & PRIVATE) != 0;
196         }
197    
198         public boolean isStatic(int modifiers)
199         {
200           return (modifiers & STATIC) != 0;
201         }
202    
203         public boolean isAbstract(int modifiers)
204         {
205           return (modifiers & ABSTRACT) != 0;
206         }
207    
208         public boolean isFinal(int modifiers)
209         {
210           return (modifiers & FINAL) != 0;
211         }
212    
213         public boolean isNative(int modifiers)
214         {
215           return (modifiers & NATIVE) != 0;
216         }
217    
218         public boolean isStrictfp(int modifiers)
219         {
220           return (modifiers & STRICTFP) != 0;
221         }
222    
223         public boolean isSynchronized(int modifiers)
224         {
225           return (modifiers & SYNCHRONIZED) != 0;
226         }
227    
228         public boolean isTransient(int modifiers)
229          {
230           return (modifiers & TRANSIENT) != 0;
231         }
232    
233         public boolean isVolatile(int modifiers)
234         {
235           return (modifiers & VOLATILE) != 0;
236         }
237    
238         /**
239          * Removes the given modifier.
240          */
241         static int removeModifier(int modifiers, int mod)
242         {
243            return modifiers & ~mod;
244         }
245       }
246    
247    /*****************************************
248     * THE JAVA LANGUAGE GRAMMAR STARTS HERE *
249     *****************************************/
250    
251    /*
252     * Program structuring syntax follows.
253     */
254      final public void CompilationUnit() throws ParseException {
255        int oldNcss = 0;
256    
257        // added by SMS
258        int oldFormal = 0;
259        int oldSingle = 0;
260        int oldMulti  = 0;
261    
262        JavaParserTokenManager._iSingleComments = 0;
263        JavaParserTokenManager._iMultiComments = 0;
264        JavaParserTokenManager._iFormalComments = 0;
265    
266        JavaParserTokenManager._iMultiCommentsLast = 0;
267    
268        _bPrivate = true;
269                    _sPackage = "";
270                    _pPackageMetric = new PackageMetric();      // this object manages the metrics
271    
272        if (jj_2_1(2147483647)) {
273          PackageDeclaration();
274        } else {
275          ;
276        }
277        label_1:
278        while (true) {
279          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
280          case IMPORT:
281            ;
282            break;
283          default:
284            jj_la1[0] = jj_gen;
285            break label_1;
286          }
287          ImportDeclaration();
288        }
289        label_2:
290        while (true) {
291          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
292          case ABSTRACT:
293          case CLASS:
294          case ENUM:
295          case FINAL:
296          case INTERFACE:
297          case NATIVE:
298          case PRIVATE:
299          case PROTECTED:
300          case PUBLIC:
301          case STATIC:
302          case TESTAAAA:
303          case SYNCHRONIZED:
304          case TRANSIENT:
305          case VOLATILE:
306          case SEMICOLON:
307          case AT:
308            ;
309            break;
310          default:
311            jj_la1[1] = jj_gen;
312            break label_2;
313          }
314          TypeDeclaration();
315        }
316                 // Package classes and functions are set inside
317                 // class and interface bodies.
318                 _pPackageMetric.ncss = _ncss;
319    
320                 // added by SMS
321                 _pPackageMetric.javadocsLn = JavaParserTokenManager._iFormalComments;
322                 _pPackageMetric.singleLn   = JavaParserTokenManager._iSingleComments;
323                 _pPackageMetric.multiLn    = JavaParserTokenManager._iMultiComments;
324                 //
325    
326                 _htPackage.put(_formatPackage(_sPackage),
327                                _pPackageMetric);
328        label_3:
329        while (true) {
330          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
331          case IMPORT:
332          case PACKAGE:
333          case AT:
334            ;
335            break;
336          default:
337            jj_la1[2] = jj_gen;
338            break label_3;
339          }
340          oldNcss = _ncss;
341          _sPackage = "";
342          _pPackageMetric = new PackageMetric();
343    
344          // added by SMS
345          oldFormal = JavaParserTokenManager._iFormalComments;
346          oldSingle = JavaParserTokenManager._iSingleComments;
347          oldMulti  = JavaParserTokenManager._iMultiComments;
348          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
349          case PACKAGE:
350          case AT:
351            PackageDeclaration();
352            break;
353          case IMPORT:
354            ImportDeclaration();
355            break;
356          default:
357            jj_la1[3] = jj_gen;
358            jj_consume_token(-1);
359            throw new ParseException();
360          }
361          label_4:
362          while (true) {
363            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
364            case IMPORT:
365              ;
366              break;
367            default:
368              jj_la1[4] = jj_gen;
369              break label_4;
370            }
371            ImportDeclaration();
372          }
373          label_5:
374          while (true) {
375            TypeDeclaration();
376            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
377            case ABSTRACT:
378            case CLASS:
379            case ENUM:
380            case FINAL:
381            case INTERFACE:
382            case NATIVE:
383            case PRIVATE:
384            case PROTECTED:
385            case PUBLIC:
386            case STATIC:
387            case TESTAAAA:
388            case SYNCHRONIZED:
389            case TRANSIENT:
390            case VOLATILE:
391            case SEMICOLON:
392            case AT:
393              ;
394              break;
395            default:
396              jj_la1[5] = jj_gen;
397              break label_5;
398            }
399          }
400          // Package classes and functions are set inside
401          // class and interface bodies.
402          _pPackageMetric.ncss = _ncss - oldNcss;
403    
404          // added by SMS
405          _pPackageMetric.javadocsLn = JavaParserTokenManager._iFormalComments - oldFormal;
406          _pPackageMetric.singleLn   = JavaParserTokenManager._iSingleComments - oldSingle;
407          _pPackageMetric.multiLn    = JavaParserTokenManager._iMultiComments  - oldMulti;
408          //
409    
410          PackageMetric pckmPrevious = (PackageMetric)_htPackage.
411                 get(_formatPackage(_sPackage));
412          _pPackageMetric.add(pckmPrevious);
413          _htPackage.put(_formatPackage(_sPackage),
414                         _pPackageMetric);
415        }
416        jj_consume_token(0);
417                 Token pToken = getToken(1);
418                 _loc = pToken.endLine;
419      }
420    
421      final public void ImportUnit() throws ParseException {
422        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
423        case PACKAGE:
424        case AT:
425          PackageDeclaration();
426          break;
427        default:
428          jj_la1[6] = jj_gen;
429          ;
430        }
431        label_6:
432        while (true) {
433          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
434          case IMPORT:
435            ;
436            break;
437          default:
438            jj_la1[7] = jj_gen;
439            break label_6;
440          }
441          ImportDeclaration();
442        }
443        label_7:
444        while (true) {
445          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
446          case ABSTRACT:
447          case FINAL:
448          case PUBLIC:
449          case TESTAAAA:
450          case SYNCHRONIZED:
451            ;
452            break;
453          default:
454            jj_la1[8] = jj_gen;
455            break label_7;
456          }
457          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
458          case ABSTRACT:
459            jj_consume_token(ABSTRACT);
460            break;
461          case FINAL:
462            jj_consume_token(FINAL);
463            break;
464          case PUBLIC:
465            jj_consume_token(PUBLIC);
466            break;
467          case SYNCHRONIZED:
468            jj_consume_token(SYNCHRONIZED);
469            break;
470          case TESTAAAA:
471            jj_consume_token(TESTAAAA);
472            break;
473          default:
474            jj_la1[9] = jj_gen;
475            jj_consume_token(-1);
476            throw new ParseException();
477          }
478        }
479        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
480        case CLASS:
481          jj_consume_token(CLASS);
482          break;
483        case INTERFACE:
484          jj_consume_token(INTERFACE);
485          break;
486        default:
487          jj_la1[10] = jj_gen;
488          jj_consume_token(-1);
489          throw new ParseException();
490        }
491      }
492    
493      final public void PackageDeclaration() throws ParseException {
494        int beginLine = 1;
495        int beginColumn = 1;
496        label_8:
497        while (true) {
498          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
499          case AT:
500            ;
501            break;
502          default:
503            jj_la1[11] = jj_gen;
504            break label_8;
505          }
506          Annotation();
507        }
508        jj_consume_token(PACKAGE);
509          _anonClassCount = 1;
510    
511          Token pToken = getToken( 0 );
512          beginLine = pToken.beginLine ;
513          beginColumn = pToken.beginColumn;
514          _aoPackage = new Object[ 5 ];
515        Name();
516          _aoPackage[ 0 ] = _sName;
517          _aoPackage[ 1 ] = new Integer( beginLine );
518          _aoPackage[ 2 ] = new Integer( beginColumn );
519        jj_consume_token(SEMICOLON);
520          _aoPackage[ 3 ] = new Integer( getToken( 0 ).endLine );
521          _aoPackage[ 4 ] = new Integer( getToken( 0 ).endColumn );
522          _ncss++;
523          Util.debug( "_ncss++" );
524          _sPackage = _sName + ".";
525      }
526    
527      final public void ImportDeclaration() throws ParseException {
528        int beginLine = 1;
529        int beginColumn = 1;
530        Object[] aoImport = null;
531        jj_consume_token(IMPORT);
532          Token pToken = getToken( 0 );
533          beginLine = pToken.beginLine ;
534          beginColumn = pToken.beginColumn;
535        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
536        case STATIC:
537          jj_consume_token(STATIC);
538          break;
539        default:
540          jj_la1[12] = jj_gen;
541          ;
542        }
543        Name();
544          aoImport = new Object[ 5 ];
545          aoImport[ 0 ] = _sName;
546          aoImport[ 1 ] = new Integer( beginLine );
547          aoImport[ 2 ] = new Integer( beginColumn );
548        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
549        case DOT:
550          jj_consume_token(DOT);
551          jj_consume_token(STAR);
552                  aoImport[ 0 ] = aoImport[ 0 ].toString() + ".*";
553          break;
554        default:
555          jj_la1[13] = jj_gen;
556          ;
557        }
558        jj_consume_token(SEMICOLON);
559          aoImport[ 3 ] = new Integer( getToken( 0 ).endLine );
560          aoImport[ 4 ] = new Integer( getToken( 0 ).endColumn );
561          _vImports.add( aoImport );
562          _ncss++;
563          Util.debug( "_ncss++" );
564      }
565    
566      final public void TypeDeclaration() throws ParseException {
567       int modifiers;
568        if (jj_2_2(2147483647)) {
569          ClassDeclaration();
570        } else if (jj_2_3(2147483647)) {
571          modifiers = Modifiers();
572          EnumDeclaration(modifiers);
573        } else if (jj_2_4(2147483647)) {
574          InterfaceDeclaration();
575        } else {
576          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
577          case ABSTRACT:
578          case FINAL:
579          case NATIVE:
580          case PRIVATE:
581          case PROTECTED:
582          case PUBLIC:
583          case STATIC:
584          case TESTAAAA:
585          case SYNCHRONIZED:
586          case TRANSIENT:
587          case VOLATILE:
588          case AT:
589            modifiers = Modifiers();
590            AnnotationTypeDeclaration(modifiers);
591            break;
592          case SEMICOLON:
593            jj_consume_token(SEMICOLON);
594            break;
595          default:
596            jj_la1[14] = jj_gen;
597            jj_consume_token(-1);
598            throw new ParseException();
599          }
600        }
601      }
602    
603    /*
604     * Declaration syntax follows.
605     */
606      final public void ClassDeclaration() throws ParseException {
607        Token tmpToken = null;
608        _javadocs = 0;
609        ObjectMetric metric = null;
610    
611        // added by SMS
612        int oldSingle = 0;
613        int oldMulti  = 0;
614    
615        _jvdcLines    = 0;
616        boolean bTemp = _bPublic;
617        _bPublic      = false;
618        //
619    
620            //Added by REYNAUD Sebastien (LOGICA)
621            Token myToken = null;
622        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
623        case AT:
624             myToken = getToken(1);
625          Annotation();
626             tmpToken = myToken;
627          break;
628        default:
629          jj_la1[15] = jj_gen;
630          ;
631        }
632        label_9:
633        while (true) {
634          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
635          case AT:
636            ;
637            break;
638          default:
639            jj_la1[16] = jj_gen;
640            break label_9;
641          }
642          Annotation();
643        }
644        label_10:
645        while (true) {
646          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
647          case ABSTRACT:
648          case FINAL:
649          case PUBLIC:
650          case TESTAAAA:
651          case SYNCHRONIZED:
652            ;
653            break;
654          default:
655            jj_la1[17] = jj_gen;
656            break label_10;
657          }
658          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
659          case ABSTRACT:
660            jj_consume_token(ABSTRACT);
661          if ( tmpToken == null ) {
662              tmpToken = getToken( 0 );
663          }
664            break;
665          case FINAL:
666            jj_consume_token(FINAL);
667          if ( tmpToken == null ) {
668              tmpToken = getToken( 0 );
669          }
670            break;
671          case PUBLIC:
672            jj_consume_token(PUBLIC);
673          _bPublic = true;         // added by SMS
674          if ( tmpToken == null ) {
675              tmpToken = getToken( 0 );
676          }
677            break;
678          case SYNCHRONIZED:
679            jj_consume_token(SYNCHRONIZED);
680          if ( tmpToken == null ) {
681              tmpToken = getToken( 0 );
682          }
683            break;
684          case TESTAAAA:
685            jj_consume_token(TESTAAAA);
686          if ( tmpToken == null ) {
687              tmpToken = getToken( 0 );
688          }
689            break;
690          default:
691            jj_la1[18] = jj_gen;
692            jj_consume_token(-1);
693            throw new ParseException();
694          }
695        }
696          if ( tmpToken == null ) {
697              tmpToken = getToken( 1 );
698          }
699          while( tmpToken.specialToken != null ) {
700              if ( tmpToken.specialToken.image.startsWith( "/**" ) ) {
701                  _javadocs++;
702                  Util.debug( "ClassDeclaration()._javadocs++" );
703                  if (_bPublic || _bPrivate) {
704                      Util.debug( "_jvdc++" );
705                      _jvdc++;
706                      _jvdcLines += JavaParserTokenManager._iMultiCommentsLast;
707                      JavaParserTokenManager._iFormalComments += JavaParserTokenManager._iMultiCommentsLast;
708                  }
709                  JavaParserTokenManager._iMultiComments -= JavaParserTokenManager._iMultiCommentsLast;
710                  break;
711              }  else if ( tmpToken.specialToken.image.startsWith( "/*" ) ) {
712                  break;
713              }
714    
715              //System.out.println("\n"+tmpToken.specialToken.image);
716    
717              tmpToken = tmpToken.specialToken;
718          }
719    
720          oldSingle = JavaParserTokenManager._iSingleComments;
721          oldMulti = JavaParserTokenManager._iMultiComments;
722        UnmodifiedClassDeclaration();
723                 /* removed by SMS
724                 while( tmpToken.specialToken != null ) {
725                     if ( tmpToken.specialToken.image.startsWith( "/**" ) ) {
726                         _javadocs++;
727                     }
728                     tmpToken = tmpToken.specialToken;
729                 }
730                 */
731                 metric = (ObjectMetric)_vClasses.get( _vClasses.size() - 1);
732                 metric.javadocs = _javadocs;
733    
734                 // added by SMS
735                 metric.javadocsLn = _jvdcLines;
736                 metric.singleLn = JavaParserTokenManager._iSingleComments - oldSingle;
737                 metric.multiLn = JavaParserTokenManager._iMultiComments - oldMulti;
738                 //
739    
740                // added by SMS
741                _bPublic = bTemp;
742      }
743    
744      final public void UnmodifiedClassDeclaration() throws ParseException {
745            String sOldClass = _sClass;
746            int oldNcss = _ncss;
747            int oldFunctions = _functions;
748            int oldClasses = _classes;
749    
750                    //Added by REYNAUD Sebastien (LOGICA)
751                    int oldJavadocs = _javadocs;
752                    if (!_sClass.equals("")) {
753                            _sClass += ".";
754                    }
755                    _sClass += getToken(2).image;
756                    _classLevel ++;
757        Modifiers();
758        jj_consume_token(CLASS);
759        Identifier();
760        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
761        case LT:
762          TypeParameters();
763          break;
764        default:
765          jj_la1[19] = jj_gen;
766          ;
767        }
768        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
769        case EXTENDS:
770          jj_consume_token(EXTENDS);
771          Name();
772          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
773          case LT:
774            TypeArguments();
775            break;
776          default:
777            jj_la1[20] = jj_gen;
778            ;
779          }
780          label_11:
781          while (true) {
782            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
783            case DOT:
784              ;
785              break;
786            default:
787              jj_la1[21] = jj_gen;
788              break label_11;
789            }
790            jj_consume_token(DOT);
791            Name();
792            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
793            case LT:
794              TypeArguments();
795              break;
796            default:
797              jj_la1[22] = jj_gen;
798              ;
799            }
800          }
801          break;
802        default:
803          jj_la1[23] = jj_gen;
804          ;
805        }
806        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
807        case IMPLEMENTS:
808          jj_consume_token(IMPLEMENTS);
809          NameList();
810          break;
811        default:
812          jj_la1[24] = jj_gen;
813          ;
814        }
815        ClassBody();
816                    _ncss++;
817                    Util.debug( "_ncss++" );
818                    _classLevel--;
819                    if (_classLevel == 0) {
820                            //_topLevelClasses++;
821                            ObjectMetric metric = new ObjectMetric();
822                            metric.name = _sPackage + _sClass;
823                            metric.ncss = _ncss - oldNcss;
824                            metric.functions = _functions - oldFunctions;
825                            metric.classes = _classes - oldClasses;
826                            Token lastToken = getToken( 0 );
827                            //metric.add( new Integer( lastToken.endLine ) );
828                            //metric.add( new Integer( lastToken.endColumn ) );
829                            //metric.add( new Integer( _javadocs ) );
830                            _vClasses.add( metric );
831                            _pPackageMetric.functions += _functions - oldFunctions;
832                            _pPackageMetric.classes++;
833    
834                            // added by SMS
835                            _pPackageMetric.javadocs += _javadocs;
836                            //_pPackageMetric.javadocsLn += JavaParserTokenManager._iFormalComments - oldFormal;
837                            //_pPackageMetric.singleLn += JavaParserTokenManager._iSingleComments - oldSingle;
838                            //_pPackageMetric.multiLn += JavaParserTokenManager._iMultiComments - oldMulti;
839                            //
840                    }
841                            //Added by REYNAUD Sebastien (LOGICA)
842                            else
843                            {
844                            ObjectMetric metric1 = new ObjectMetric();
845                      metric1.name = _sPackage + _sClass ;
846                            metric1.ncss = _ncss - oldNcss;
847                      metric1.functions = _functions - oldFunctions;
848                      metric1.classes = _classes - oldClasses;
849                      Token lastToken = getToken( 0 );
850                      _vClasses.add( metric1 );
851                      _pPackageMetric.functions += _functions - oldFunctions;
852                      _pPackageMetric.classes++;
853                            metric1.javadocs = _javadocs - oldJavadocs;
854                            }
855                            //
856    
857                    _functions = oldFunctions;
858                    _classes = oldClasses + 1;
859                    _sClass = sOldClass;
860      }
861    
862      final public void ClassBody() throws ParseException {
863        jj_consume_token(LBRACE);
864        label_12:
865        while (true) {
866          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
867          case ABSTRACT:
868          case ASSERT:
869          case BOOLEAN:
870          case BYTE:
871          case CHAR:
872          case CLASS:
873          case DOUBLE:
874          case ENUM:
875          case FINAL:
876          case FLOAT:
877          case INT:
878          case INTERFACE:
879          case LONG:
880          case NATIVE:
881          case PRIVATE:
882          case PROTECTED:
883          case PUBLIC:
884          case SHORT:
885          case STATIC:
886          case TESTAAAA:
887          case SYNCHRONIZED:
888          case TRANSIENT:
889          case VOID:
890          case VOLATILE:
891          case IDENTIFIER:
892          case LBRACE:
893          case SEMICOLON:
894          case AT:
895          case LT:
896            ;
897            break;
898          default:
899            jj_la1[25] = jj_gen;
900            break label_12;
901          }
902          ClassBodyDeclaration();
903        }
904        jj_consume_token(RBRACE);
905      }
906    
907      final public void NestedClassDeclaration() throws ParseException {
908        // added by SMS
909        Token tmpToken = null;
910    
911        boolean bTemp = _bPublic;
912        _bPublic = false;
913        boolean bPublic = false;
914    
915            //Added by REYNAUD Sebastien (LOGICA)
916            Token myToken = null;
917        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
918        case AT:
919             myToken = getToken(1);
920          Annotation();
921             tmpToken = myToken;
922          break;
923        default:
924          jj_la1[26] = jj_gen;
925          ;
926        }
927        label_13:
928        while (true) {
929          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
930          case AT:
931            ;
932            break;
933          default:
934            jj_la1[27] = jj_gen;
935            break label_13;
936          }
937          Annotation();
938        }
939            if(tmpToken==null)
940            {
941                    tmpToken = getToken( 1 );
942            }
943        label_14:
944        while (true) {
945          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
946          case ABSTRACT:
947          case FINAL:
948          case PRIVATE:
949          case PROTECTED:
950          case PUBLIC:
951          case STATIC:
952          case TESTAAAA:
953            ;
954            break;
955          default:
956            jj_la1[28] = jj_gen;
957            break label_14;
958          }
959          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
960          case STATIC:
961            jj_consume_token(STATIC);
962            break;
963          case ABSTRACT:
964            jj_consume_token(ABSTRACT);
965            break;
966          case FINAL:
967            jj_consume_token(FINAL);
968            break;
969          case PUBLIC:
970            jj_consume_token(PUBLIC);
971                   bPublic = true;
972            break;
973          case PROTECTED:
974            jj_consume_token(PROTECTED);
975                      bPublic = true;
976            break;
977          case PRIVATE:
978            jj_consume_token(PRIVATE);
979            break;
980          case TESTAAAA:
981            jj_consume_token(TESTAAAA);
982            break;
983          default:
984            jj_la1[29] = jj_gen;
985            jj_consume_token(-1);
986            throw new ParseException();
987          }
988        }
989                            //tmpToken = getToken( 0 );//Removed by REYNAUD Sebastien (LOGICA)
990    
991                    while( tmpToken.specialToken != null ) {
992                        if ( tmpToken.specialToken.image.startsWith( "/**" ) ) {
993                            _javadocs++;
994                            Util.debug( "NestedClassDeclaration()._javadocs++" );
995                            if ((_bPublic && bPublic) || _bPrivate) {
996                                Util.debug( "_jvdc++" );
997                                _jvdc++;
998                                _jvdcLines += JavaParserTokenManager._iMultiCommentsLast;
999                                JavaParserTokenManager._iFormalComments += JavaParserTokenManager._iMultiCommentsLast;
1000                            }
1001                            JavaParserTokenManager._iMultiComments -= JavaParserTokenManager._iMultiCommentsLast;
1002                            break;
1003                        }  else if ( tmpToken.specialToken.image.startsWith( "/*" ) ) {
1004                            break;
1005                        }
1006    
1007                        //System.out.println("\n"+tmpToken.specialToken.image);
1008    
1009                        tmpToken = tmpToken.specialToken;
1010                    }
1011        UnmodifiedClassDeclaration();
1012           //added by SMS
1013          _bPublic = bTemp;
1014      }
1015    
1016      final public void ClassBodyDeclaration() throws ParseException {
1017        int modifiers;
1018        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1019        case SEMICOLON:
1020          EmptyStatement();
1021          break;
1022        default:
1023          jj_la1[31] = jj_gen;
1024          if (jj_2_5(2)) {
1025            Initializer();
1026          } else if (jj_2_6(2147483647)) {
1027            modifiers = Modifiers();
1028            AnnotationTypeDeclaration(modifiers);
1029          } else if (jj_2_7(2147483647)) {
1030            CreationAnnotation();
1031          } else if (jj_2_8(2147483647)) {
1032            NestedClassDeclaration();
1033          } else if (jj_2_9(2147483647)) {
1034            //LOOKAHEAD( ( "static" | "abstract" | "final" | "public" | "protected" | "private" | "strictfp" )* "interface" )
1035              modifiers = Modifiers();
1036            NestedInterfaceDeclaration();
1037          } else if (jj_2_10(2147483647)) {
1038            modifiers = Modifiers();
1039            EnumDeclaration(modifiers);
1040          } else if (jj_2_11(2147483647)) {
1041            ConstructorDeclaration();
1042          } else if (jj_2_12(2147483647)) {
1043            MethodDeclaration();
1044          } else {
1045            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1046            case BOOLEAN:
1047            case BYTE:
1048            case CHAR:
1049            case DOUBLE:
1050            case FINAL:
1051            case FLOAT:
1052            case INT:
1053            case LONG:
1054            case PRIVATE:
1055            case PROTECTED:
1056            case PUBLIC:
1057            case SHORT:
1058            case STATIC:
1059            case TRANSIENT:
1060            case VOLATILE:
1061            case IDENTIFIER:
1062            case AT:
1063              label_15:
1064              while (true) {
1065                switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1066                case AT:
1067                  ;
1068                  break;
1069                default:
1070                  jj_la1[30] = jj_gen;
1071                  break label_15;
1072                }
1073                Annotation();
1074              }
1075              FieldDeclaration();
1076              break;
1077            default:
1078              jj_la1[32] = jj_gen;
1079              jj_consume_token(-1);
1080              throw new ParseException();
1081            }
1082          }
1083        }
1084      }
1085    
1086    // This production is to determine lookahead only.
1087      final public void MethodDeclarationLookahead() throws ParseException {
1088        label_16:
1089        while (true) {
1090          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1091          case AT:
1092            ;
1093            break;
1094          default:
1095            jj_la1[33] = jj_gen;
1096            break label_16;
1097          }
1098          Annotation();
1099        }
1100        label_17:
1101        while (true) {
1102          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1103          case ABSTRACT:
1104          case FINAL:
1105          case NATIVE:
1106          case PRIVATE:
1107          case PROTECTED:
1108          case PUBLIC:
1109          case STATIC:
1110          case TESTAAAA:
1111          case SYNCHRONIZED:
1112            ;
1113            break;
1114          default:
1115            jj_la1[34] = jj_gen;
1116            break label_17;
1117          }
1118          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1119          case PUBLIC:
1120            jj_consume_token(PUBLIC);
1121            break;
1122          case PROTECTED:
1123            jj_consume_token(PROTECTED);
1124            break;
1125          case PRIVATE:
1126            jj_consume_token(PRIVATE);
1127            break;
1128          case STATIC:
1129            jj_consume_token(STATIC);
1130            break;
1131          case ABSTRACT:
1132            jj_consume_token(ABSTRACT);
1133            break;
1134          case FINAL:
1135            jj_consume_token(FINAL);
1136            break;
1137          case NATIVE:
1138            jj_consume_token(NATIVE);
1139            break;
1140          case SYNCHRONIZED:
1141            jj_consume_token(SYNCHRONIZED);
1142            break;
1143          case TESTAAAA:
1144            jj_consume_token(TESTAAAA);
1145            break;
1146          default:
1147            jj_la1[35] = jj_gen;
1148            jj_consume_token(-1);
1149            throw new ParseException();
1150          }
1151        }
1152        label_18:
1153        while (true) {
1154          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1155          case AT:
1156            ;
1157            break;
1158          default:
1159            jj_la1[36] = jj_gen;
1160            break label_18;
1161          }
1162          Annotation();
1163        }
1164        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1165        case LT:
1166          TypeParameters();
1167          break;
1168        default:
1169          jj_la1[37] = jj_gen;
1170          ;
1171        }
1172        ResultType();
1173        Identifier();
1174        jj_consume_token(LPAREN);
1175      }
1176    
1177      final public void InterfaceDeclaration() throws ParseException {
1178            Token tmpToken = null;
1179            _javadocs = 0;
1180            //boolean bClassComment = false;
1181            ObjectMetric metric = null;
1182    
1183            // added by SMS
1184            int oldSingle;
1185            int oldMulti;
1186    
1187            _jvdcLines = 0;
1188            boolean bTemp = _bPublic;
1189            _bPublic = false;
1190            //
1191    
1192            //Added by REYNAUD Sebastien (LOGICA)
1193            Token myToken=null;
1194        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1195        case AT:
1196             myToken = getToken(1);
1197          Annotation();
1198             tmpToken = myToken;
1199          break;
1200        default:
1201          jj_la1[38] = jj_gen;
1202          ;
1203        }
1204        label_19:
1205        while (true) {
1206          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1207          case AT:
1208            ;
1209            break;
1210          default:
1211            jj_la1[39] = jj_gen;
1212            break label_19;
1213          }
1214          Annotation();
1215        }
1216        label_20:
1217        while (true) {
1218          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1219          case ABSTRACT:
1220          case PUBLIC:
1221          case TESTAAAA:
1222            ;
1223            break;
1224          default:
1225            jj_la1[40] = jj_gen;
1226            break label_20;
1227          }
1228          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1229          case TESTAAAA:
1230            jj_consume_token(TESTAAAA);
1231            break;
1232          case ABSTRACT:
1233            jj_consume_token(ABSTRACT);
1234          if ( tmpToken == null ) {
1235              tmpToken = getToken( 0 );
1236          }
1237            break;
1238          case PUBLIC:
1239            jj_consume_token(PUBLIC);
1240          _bPublic = true;         // added by SMS
1241          if ( tmpToken == null ) {
1242              tmpToken = getToken( 0 );
1243          }
1244            break;
1245          default:
1246            jj_la1[41] = jj_gen;
1247            jj_consume_token(-1);
1248            throw new ParseException();
1249          }
1250        }
1251          if ( tmpToken == null ) {
1252              tmpToken = getToken( 1 );
1253          }
1254                    while( tmpToken.specialToken != null ) {
1255                        if ( tmpToken.specialToken.image.startsWith( "/**" ) ) {
1256                            _javadocs++;
1257                            Util.debug( "InterfaceDeclaration()._javadocs++" );
1258                            if (_bPublic || _bPrivate) {
1259                                Util.debug( "_jvdc++" );
1260                                _jvdc++;
1261                                _jvdcLines += JavaParserTokenManager._iMultiCommentsLast;
1262                                JavaParserTokenManager._iFormalComments += JavaParserTokenManager._iMultiCommentsLast;
1263                            }
1264                            JavaParserTokenManager._iMultiComments -= JavaParserTokenManager._iMultiCommentsLast;
1265                            break;
1266                        }  else if ( tmpToken.specialToken.image.startsWith( "/*" ) ) {
1267                            break;
1268                        }
1269    
1270                        //System.out.println("\n"+tmpToken.specialToken.image);
1271    
1272                        tmpToken = tmpToken.specialToken;
1273                    }
1274    
1275                    oldSingle = JavaParserTokenManager._iSingleComments;
1276                    oldMulti = JavaParserTokenManager._iMultiComments;
1277        UnmodifiedInterfaceDeclaration();
1278                 /* removed by SMS
1279                 while( tmpToken.specialToken != null ) {
1280                     if ( tmpToken.specialToken.image.startsWith( "/**" ) ) {
1281                         _javadocs++;
1282                         bClassComment = true;
1283                     }
1284                     tmpToken = tmpToken.specialToken;
1285                     }*/
1286                 metric = (ObjectMetric)_vClasses.get( _vClasses.size() - 1 );
1287                 metric.javadocs = _javadocs;
1288    
1289                 // added by SMS
1290                 metric.javadocsLn = _jvdcLines;
1291                 metric.singleLn = JavaParserTokenManager._iSingleComments - oldSingle;
1292                 metric.multiLn = JavaParserTokenManager._iMultiComments - oldMulti;
1293                 //
1294    
1295                // added by SMS
1296                _bPublic = bTemp;
1297      }
1298    
1299      final public void NestedInterfaceDeclaration() throws ParseException {
1300        // added by SMS
1301        Token tmpToken = null;
1302    
1303        boolean bTemp = _bPublic;
1304        _bPublic = false;
1305        boolean bPublic = false;
1306    
1307            //Added by REYNAUD Sebastien (LOGICA)
1308            Token myToken=null;
1309        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1310        case AT:
1311             myToken = getToken(1);
1312          Annotation();
1313             tmpToken = myToken;
1314          break;
1315        default:
1316          jj_la1[42] = jj_gen;
1317          ;
1318        }
1319        label_21:
1320        while (true) {
1321          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1322          case AT:
1323            ;
1324            break;
1325          default:
1326            jj_la1[43] = jj_gen;
1327            break label_21;
1328          }
1329          Annotation();
1330        }
1331            if(tmpToken==null)
1332            {
1333                    tmpToken = getToken( 1 );
1334            }
1335        label_22:
1336        while (true) {
1337          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1338          case ABSTRACT:
1339          case FINAL:
1340          case PRIVATE:
1341          case PROTECTED:
1342          case PUBLIC:
1343          case STATIC:
1344          case TESTAAAA:
1345            ;
1346            break;
1347          default:
1348            jj_la1[44] = jj_gen;
1349            break label_22;
1350          }
1351          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1352          case STATIC:
1353            jj_consume_token(STATIC);
1354            break;
1355          case ABSTRACT:
1356            jj_consume_token(ABSTRACT);
1357            break;
1358          case FINAL:
1359            jj_consume_token(FINAL);
1360            break;
1361          case PUBLIC:
1362            jj_consume_token(PUBLIC);
1363                   bPublic = true;
1364            break;
1365          case PROTECTED:
1366            jj_consume_token(PROTECTED);
1367                      bPublic = true;
1368            break;
1369          case PRIVATE:
1370            jj_consume_token(PRIVATE);
1371            break;
1372          case TESTAAAA:
1373            jj_consume_token(TESTAAAA);
1374            break;
1375          default:
1376            jj_la1[45] = jj_gen;
1377            jj_consume_token(-1);
1378            throw new ParseException();
1379          }
1380        }
1381                            //tmpToken = getToken( 0 );     //Removed by REYNAUD Sebastien (LOGICA)
1382    
1383                    while( tmpToken.specialToken != null ) {
1384                        if ( tmpToken.specialToken.image.startsWith( "/**" ) ) {
1385                            _javadocs++;
1386                            if ((_bPublic && bPublic) || _bPrivate) {
1387                                Util.debug( "_jvdc++" );
1388                                _jvdc++;
1389                                _jvdcLines += JavaParserTokenManager._iMultiCommentsLast;
1390                                JavaParserTokenManager._iFormalComments += JavaParserTokenManager._iMultiCommentsLast;
1391                            }
1392                            JavaParserTokenManager._iMultiComments -= JavaParserTokenManager._iMultiCommentsLast;
1393                            break;
1394                        }  else if ( tmpToken.specialToken.image.startsWith( "/*" ) ) {
1395                            break;
1396                        }
1397    
1398                        //System.out.println("\n"+tmpToken.specialToken.image);
1399    
1400                        tmpToken = tmpToken.specialToken;
1401                    }
1402        UnmodifiedInterfaceDeclaration();
1403          // added by SMS
1404          _bPublic = bTemp;
1405      }
1406    
1407      final public void UnmodifiedInterfaceDeclaration() throws ParseException {
1408            String sOldClass = _sClass;
1409            int oldNcss = _ncss;
1410            int oldFunctions = _functions;
1411            int oldClasses = _classes;
1412    
1413                    //Added by REYNAUD Sebastien (LOGICA)
1414                    int oldJavadocs = _javadocs;
1415                    if (!_sClass.equals("")) {
1416                            _sClass += ".";
1417                    }
1418                    _sClass += getToken(2).image;
1419                    _classLevel ++;
1420        jj_consume_token(INTERFACE);
1421        Identifier();
1422        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1423        case LT:
1424          TypeParameters();
1425          break;
1426        default:
1427          jj_la1[46] = jj_gen;
1428          ;
1429        }
1430        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1431        case EXTENDS:
1432          jj_consume_token(EXTENDS);
1433          NameList();
1434          break;
1435        default:
1436          jj_la1[47] = jj_gen;
1437          ;
1438        }
1439        jj_consume_token(LBRACE);
1440        label_23:
1441        while (true) {
1442          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1443          case ABSTRACT:
1444          case BOOLEAN:
1445          case BYTE:
1446          case CHAR:
1447          case CLASS:
1448          case DOUBLE:
1449          case ENUM:
1450          case FINAL:
1451          case FLOAT:
1452          case INT:
1453          case INTERFACE:
1454          case LONG:
1455          case NATIVE:
1456          case PRIVATE:
1457          case PROTECTED:
1458          case PUBLIC:
1459          case SHORT:
1460          case STATIC:
1461          case TESTAAAA:
1462          case SYNCHRONIZED:
1463          case TRANSIENT:
1464          case VOID:
1465          case VOLATILE:
1466          case IDENTIFIER:
1467          case SEMICOLON:
1468          case AT:
1469          case LT:
1470            ;
1471            break;
1472          default:
1473            jj_la1[48] = jj_gen;
1474            break label_23;
1475          }
1476          InterfaceMemberDeclaration();
1477        }
1478        jj_consume_token(RBRACE);
1479                    _ncss++;
1480                    Util.debug( "_ncss++" );
1481                    _classLevel--;
1482                    if (_classLevel == 0)
1483                    {
1484                            //_topLevelClasses++;
1485                            ObjectMetric metric = new ObjectMetric();
1486                            metric.name = _sPackage + _sClass;
1487                            metric.ncss = _ncss - oldNcss;
1488                            metric.functions = _functions - oldFunctions;
1489                            metric.classes = _classes - oldClasses;
1490                            //metric.add( Util.getConstantObject() );
1491                            //metric.add( Util.getConstantObject() );
1492                            _vClasses.add( metric );
1493                            _pPackageMetric.functions += _functions - oldFunctions;
1494                            _pPackageMetric.classes++;
1495    
1496                            // added by SMS
1497                            _pPackageMetric.javadocs += _javadocs;
1498                            //_pPackageMetric.javadocsLn += JavaParserTokenManager._iFormalComments - oldFormal;
1499                            //_pPackageMetric.singleLn += JavaParserTokenManager._iSingleComments - oldSingle;
1500                            //_pPackageMetric.multiLn += JavaParserTokenManager._iMultiComments - oldMulti;
1501                            //
1502                    }
1503                            //Added by REYNAUD Sebastien (LOGICA)
1504                            else
1505                            {
1506                            ObjectMetric metric1 = new ObjectMetric();
1507                      metric1.name = _sPackage + _sClass;
1508                            metric1.ncss = _ncss - oldNcss;
1509                      metric1.functions = _functions - oldFunctions;
1510                      metric1.classes = _classes - oldClasses;
1511                      Token lastToken = getToken( 0 );
1512                      _vClasses.add( metric1 );
1513                      _pPackageMetric.functions += _functions - oldFunctions;
1514                      _pPackageMetric.classes++;
1515                            //_pPackageMetric.javadocs += _javadocs;
1516                            metric1.javadocs = _javadocs - oldJavadocs;
1517                            }
1518                            //
1519    
1520                    _functions = oldFunctions;
1521                    _classes = oldClasses + 1;
1522                    _sClass = sOldClass;
1523      }
1524    
1525      final public void InterfaceMemberDeclaration() throws ParseException {
1526       int modifiers;
1527        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1528        case SEMICOLON:
1529          EmptyStatement();
1530          break;
1531        default:
1532          jj_la1[49] = jj_gen;
1533          if (jj_2_13(2147483647)) {
1534            NestedClassDeclaration();
1535          } else if (jj_2_14(2147483647)) {
1536            NestedInterfaceDeclaration();
1537          } else if (jj_2_15(2147483647)) {
1538            modifiers = Modifiers();
1539            EnumDeclaration(modifiers);
1540          } else if (jj_2_16(2147483647)) {
1541            MethodDeclaration();
1542          } else {
1543            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1544            case ABSTRACT:
1545            case BOOLEAN:
1546            case BYTE:
1547            case CHAR:
1548            case DOUBLE:
1549            case FINAL:
1550            case FLOAT:
1551            case INT:
1552            case LONG:
1553            case NATIVE:
1554            case PRIVATE:
1555            case PROTECTED:
1556            case PUBLIC:
1557            case SHORT:
1558            case STATIC:
1559            case TESTAAAA:
1560            case SYNCHRONIZED:
1561            case TRANSIENT:
1562            case VOLATILE:
1563            case IDENTIFIER:
1564            case AT:
1565              modifiers = Modifiers();
1566              FieldDeclaration();
1567              break;
1568            default:
1569              jj_la1[50] = jj_gen;
1570              jj_consume_token(-1);
1571              throw new ParseException();
1572            }
1573          }
1574        }
1575      }
1576    
1577      final public void FieldDeclaration() throws ParseException {
1578        // added by SMS
1579        Token tmpToken = null;
1580        boolean bPublic = false;
1581        label_24:
1582        while (true) {
1583          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1584          case FINAL:
1585          case PRIVATE:
1586          case PROTECTED:
1587          case PUBLIC:
1588          case STATIC:
1589          case TRANSIENT:
1590          case VOLATILE:
1591            ;
1592            break;
1593          default:
1594            jj_la1[51] = jj_gen;
1595            break label_24;
1596          }
1597          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1598          case PUBLIC:
1599            jj_consume_token(PUBLIC);
1600                   bPublic = true;
1601            break;
1602          case PROTECTED:
1603            jj_consume_token(PROTECTED);
1604                      bPublic = true;
1605            break;
1606          case PRIVATE:
1607            jj_consume_token(PRIVATE);
1608            break;
1609          case STATIC:
1610            jj_consume_token(STATIC);
1611            break;
1612          case FINAL:
1613            jj_consume_token(FINAL);
1614            break;
1615          case TRANSIENT:
1616            jj_consume_token(TRANSIENT);
1617            break;
1618          case VOLATILE:
1619            jj_consume_token(VOLATILE);
1620            break;
1621          default:
1622            jj_la1[52] = jj_gen;
1623            jj_consume_token(-1);
1624            throw new ParseException();
1625          }
1626        }
1627                    tmpToken = getToken( 0 );
1628    
1629                    while( tmpToken.specialToken != null )
1630                    {
1631                        if ( tmpToken.specialToken.image.startsWith( "/**" ) )
1632                        {
1633                            if ((bPublic && _bPublic) || _bPrivate)
1634                            {
1635                                //_javadocs++;
1636                                Util.debug( "_jvdc++" );
1637                                _jvdc++;
1638                                _jvdcLines += JavaParserTokenManager._iMultiCommentsLast;
1639                                JavaParserTokenManager._iFormalComments += JavaParserTokenManager._iMultiCommentsLast;
1640                            }
1641                            JavaParserTokenManager._iMultiComments -= JavaParserTokenManager._iMultiCommentsLast;
1642                            break;
1643                        }
1644                        else if ( tmpToken.specialToken.image.startsWith( "/*" ) )
1645                        {
1646                            break;
1647                        }
1648    
1649                        //System.out.println("\n"+tmpToken.specialToken.image);
1650    
1651                        tmpToken = tmpToken.specialToken;
1652                    }
1653        label_25:
1654        while (true) {
1655          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1656          case AT:
1657            ;
1658            break;
1659          default:
1660            jj_la1[53] = jj_gen;
1661            break label_25;
1662          }
1663          Annotation();
1664        }
1665        Type();
1666        VariableDeclarator();
1667        label_26:
1668        while (true) {
1669          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1670          case COMMA:
1671            ;
1672            break;
1673          default:
1674            jj_la1[54] = jj_gen;
1675            break label_26;
1676          }
1677          jj_consume_token(COMMA);
1678          VariableDeclarator();
1679        }
1680        jj_consume_token(SEMICOLON);
1681        _ncss++; Util.debug( "_ncss++" );
1682      }
1683    
1684      final public void VariableDeclarator() throws ParseException {
1685        VariableDeclaratorId();
1686        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1687        case ASSIGN:
1688          jj_consume_token(ASSIGN);
1689          VariableInitializer();
1690          break;
1691        default:
1692          jj_la1[55] = jj_gen;
1693          ;
1694        }
1695      }
1696    
1697      final public void VariableDeclaratorId() throws ParseException {
1698        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1699        case ENUM:
1700          jj_consume_token(ENUM);
1701          break;
1702        case ASSERT:
1703        case IDENTIFIER:
1704          Identifier();
1705          break;
1706        default:
1707          jj_la1[56] = jj_gen;
1708          jj_consume_token(-1);
1709          throw new ParseException();
1710        }
1711        label_27:
1712        while (true) {
1713          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1714          case LBRACKET:
1715            ;
1716            break;
1717          default:
1718            jj_la1[57] = jj_gen;
1719            break label_27;
1720          }
1721          jj_consume_token(LBRACKET);
1722          jj_consume_token(RBRACKET);
1723                                              _sName += "[]";
1724        }
1725      }
1726    
1727      final public void VariableInitializer() throws ParseException {
1728        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1729        case LBRACE:
1730          ArrayInitializer();
1731          break;
1732        case ASSERT:
1733        case BOOLEAN:
1734        case BYTE:
1735        case CHAR:
1736        case DOUBLE:
1737        case ENUM:
1738        case FALSE:
1739        case FLOAT:
1740        case INT:
1741        case LONG:
1742        case NEW:
1743        case NULL:
1744        case SHORT:
1745        case SUPER:
1746        case THIS:
1747        case TRUE:
1748        case VOID:
1749        case INTEGER_LITERAL:
1750        case FLOATING_POINT_LITERAL:
1751        case CHARACTER_LITERAL:
1752        case STRING_LITERAL:
1753        case IDENTIFIER:
1754        case LPAREN:
1755        case BANG:
1756        case TILDE:
1757        case INCR:
1758        case DECR:
1759        case PLUS:
1760        case MINUS:
1761          Expression();
1762          break;
1763        default:
1764          jj_la1[58] = jj_gen;
1765          jj_consume_token(-1);
1766          throw new ParseException();
1767        }
1768      }
1769    
1770      final public void ArrayInitializer() throws ParseException {
1771        jj_consume_token(LBRACE);
1772        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1773        case ASSERT:
1774        case BOOLEAN:
1775        case BYTE:
1776        case CHAR:
1777        case DOUBLE:
1778        case ENUM:
1779        case FALSE:
1780        case FLOAT:
1781        case INT:
1782        case LONG:
1783        case NEW:
1784        case NULL:
1785        case SHORT:
1786        case SUPER:
1787        case THIS:
1788        case TRUE:
1789        case VOID:
1790        case INTEGER_LITERAL:
1791        case FLOATING_POINT_LITERAL:
1792        case CHARACTER_LITERAL:
1793        case STRING_LITERAL:
1794        case IDENTIFIER:
1795        case LPAREN:
1796        case LBRACE:
1797        case BANG:
1798        case TILDE:
1799        case INCR:
1800        case DECR:
1801        case PLUS:
1802        case MINUS:
1803          VariableInitializer();
1804          label_28:
1805          while (true) {
1806            if (jj_2_17(2)) {
1807              ;
1808            } else {
1809              break label_28;
1810            }
1811            jj_consume_token(COMMA);
1812            VariableInitializer();
1813          }
1814          break;
1815        default:
1816          jj_la1[59] = jj_gen;
1817          ;
1818        }
1819        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1820        case COMMA:
1821          jj_consume_token(COMMA);
1822          break;
1823        default:
1824          jj_la1[60] = jj_gen;
1825          ;
1826        }
1827        jj_consume_token(RBRACE);
1828      }
1829    
1830      final public void MethodDeclaration() throws ParseException {
1831        int oldNcss = _ncss;
1832        int oldFunctions = _functions;
1833        String sOldFunction = _sFunction;
1834        int oldcyc = _cyc;
1835        boolean bOldReturn = _bReturn;
1836        Token tmpToken = null;
1837        int jvdc = 0;
1838    
1839        // added by SMS
1840        int jvdcLines = 0;
1841        int oldSingle;
1842        int oldMulti;
1843        boolean bPublic = false;
1844        //
1845    
1846            //Added by REYNAUD Sebastien (LOGICA)
1847            Token myToken = null;
1848            _tmpToken=null;
1849        if ( _tmpToken != null )
1850        {
1851            tmpToken = _tmpToken;
1852        }
1853        label_29:
1854        while (true) {
1855          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1856          case AT:
1857            ;
1858            break;
1859          default:
1860            jj_la1[61] = jj_gen;
1861            break label_29;
1862          }
1863             myToken = getToken(1);
1864          Annotation();
1865          if ( tmpToken == null ) {
1866    
1867              //tmpToken = getToken( 0 ); //Removed by REYNAUD Sebastien (LOGICA)
1868    
1869                    //Added by REYNAUD Sebastien (LOGICA)
1870                    tmpToken = myToken;
1871                    //
1872          }
1873        }
1874        label_30:
1875        while (true) {
1876          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1877          case ABSTRACT:
1878          case FINAL:
1879          case NATIVE:
1880          case PRIVATE:
1881          case PROTECTED:
1882          case PUBLIC:
1883          case STATIC:
1884          case TESTAAAA:
1885          case SYNCHRONIZED:
1886            ;
1887            break;
1888          default:
1889            jj_la1[62] = jj_gen;
1890            break label_30;
1891          }
1892          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1893          case PUBLIC:
1894            jj_consume_token(PUBLIC);
1895                   bPublic = true;
1896          if ( tmpToken == null ) {
1897              tmpToken = getToken( 0 );
1898          }
1899            break;
1900          case PROTECTED:
1901            jj_consume_token(PROTECTED);
1902                        bPublic = true;
1903          if ( tmpToken == null ) {
1904              tmpToken = getToken( 0 );
1905          }
1906            break;
1907          case PRIVATE:
1908            jj_consume_token(PRIVATE);
1909          if ( tmpToken == null ) {
1910              tmpToken = getToken( 0 );
1911          }
1912            break;
1913          case STATIC:
1914            jj_consume_token(STATIC);
1915          if ( tmpToken == null ) {
1916              tmpToken = getToken( 0 );
1917          }
1918            break;
1919          case ABSTRACT:
1920            jj_consume_token(ABSTRACT);
1921          if ( tmpToken == null ) {
1922              tmpToken = getToken( 0 );
1923          }
1924            break;
1925          case FINAL:
1926            jj_consume_token(FINAL);
1927          if ( tmpToken == null ) {
1928              tmpToken = getToken( 0 );
1929          }
1930            break;
1931          case NATIVE:
1932            jj_consume_token(NATIVE);
1933          if ( tmpToken == null ) {
1934              tmpToken = getToken( 0 );
1935          }
1936            break;
1937          case SYNCHRONIZED:
1938            jj_consume_token(SYNCHRONIZED);
1939          if ( tmpToken == null ) {
1940              tmpToken = getToken( 0 );
1941          }
1942            break;
1943          case TESTAAAA:
1944            jj_consume_token(TESTAAAA);
1945          if ( tmpToken == null ) {
1946              tmpToken = getToken( 0 );
1947          }
1948            break;
1949          default:
1950            jj_la1[63] = jj_gen;
1951            jj_consume_token(-1);
1952            throw new ParseException();
1953          }
1954        }
1955        label_31:
1956        while (true) {
1957          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1958          case AT:
1959            ;
1960            break;
1961          default:
1962            jj_la1[64] = jj_gen;
1963            break label_31;
1964          }
1965          Annotation();
1966        }
1967        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1968        case LT:
1969          TypeParameters();
1970          break;
1971        default:
1972          jj_la1[65] = jj_gen;
1973          ;
1974        }
1975                   _tmpResultToken = null;
1976        ResultType();
1977                if ( tmpToken == null )
1978                {
1979                    tmpToken = _tmpResultToken;
1980                    if ( tmpToken == null )
1981                    {
1982                        tmpToken = getToken( 0 );
1983                    }
1984                    Util.debug( "result type tmpToken: " + tmpToken );
1985                }
1986        MethodDeclarator();
1987        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1988        case THROWS:
1989          jj_consume_token(THROWS);
1990          NameList();
1991          break;
1992        default:
1993          jj_la1[66] = jj_gen;
1994          ;
1995        }
1996                    _cyc = 1;
1997                    _bReturn = false;
1998        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1999        case LBRACE:
2000          Block();
2001          break;
2002        case SEMICOLON:
2003          jj_consume_token(SEMICOLON);
2004          break;
2005        default:
2006          jj_la1[67] = jj_gen;
2007          jj_consume_token(-1);
2008          throw new ParseException();
2009        }
2010      // added by SMS
2011      {
2012          Util.debug( "Token: " + String.valueOf( tmpToken.image ) );
2013          while( tmpToken.specialToken != null )
2014          {
2015              Util.debug( "Token comment: " + String.valueOf( tmpToken.specialToken.image ) );
2016              if ( tmpToken.specialToken.image.startsWith( "/**" ) )
2017              {
2018                  _javadocs++;
2019                  Util.debug( "MethodDeclaration()._javadocs++" );
2020                  jvdc++;
2021                  if ((bPublic && _bPublic) || _bPrivate) {
2022                      Util.debug( "_jvdc++" );
2023                      _jvdc++;
2024                      jvdcLines = JavaParserTokenManager._iMultiCommentsLast;
2025                      _jvdcLines += jvdcLines;
2026                      JavaParserTokenManager._iFormalComments += jvdcLines;
2027                  }
2028                  JavaParserTokenManager._iMultiComments -= jvdcLines;
2029                  break;
2030              }  else if ( tmpToken.specialToken.image.startsWith( "/*" ) ) {
2031                  jvdcLines = 0;
2032                  break;
2033              }
2034    
2035              //System.out.println("\n"+tmpToken.specialToken.image);
2036    
2037              tmpToken = tmpToken.specialToken;
2038          }
2039    
2040          oldSingle = JavaParserTokenManager._iSingleComments;
2041          oldMulti = JavaParserTokenManager._iMultiComments;
2042      }
2043    
2044    
2045                 // removed by ccl
2046                 /*
2047                 while( tmpToken.specialToken != null ) {
2048                     if ( tmpToken.specialToken.image.startsWith( "/**" ) ) {
2049                         jvdc++;
2050                         _javadocs++;
2051                     }
2052                     tmpToken = tmpToken.specialToken;
2053                 }
2054                 */
2055                 // removed by SMS
2056                 /*
2057                   while( tmpToken.specialToken != null ) {
2058                   if ( tmpToken.specialToken.image.startsWith( "/**" ) ) {
2059                   jvdc++;
2060                   _javadocs++;
2061                   _bJavadoc = true;
2062                   }
2063    
2064                   tmpToken = tmpToken.specialToken;
2065                   }
2066                 */
2067    
2068                 if (_bReturn)
2069                 {
2070                     _cyc--;
2071                 }
2072                 _ncss++;
2073                 Util.debug( "MethodDeclaration()._ncss++" );
2074    
2075                 FunctionMetric functionMetrics = new FunctionMetric();
2076                 functionMetrics.name = _sPackage + _sClass + _sFunction;
2077                 functionMetrics.ncss = _ncss - oldNcss;
2078                 functionMetrics.ccn = _cyc;
2079                 functionMetrics.javadocs = jvdc;
2080    
2081                 // added by SMS
2082                 functionMetrics.javadocsLn = 0; //jvdcLines;
2083                 functionMetrics.singleLn = 0; //JavaParserTokenManager._iSingleComments - oldSingle;
2084                 functionMetrics.multiLn = 0; //JavaParserTokenManager._iMultiComments - oldMulti;
2085                 //
2086    
2087                 _vFunctions.add(functionMetrics);
2088                 _sFunction = sOldFunction;
2089                 _functions = oldFunctions + 1;
2090                 _cyc = oldcyc;
2091                 _bReturn = bOldReturn;
2092    
2093                    //Added by REYNAUD Sebastien (LOGICA)
2094                    _tmpToken = null;
2095                    //
2096    
2097      }
2098    
2099      final public void MethodDeclarator() throws ParseException {
2100                    _sFunction = "." + getToken(1).image;
2101        Identifier();
2102        FormalParameters();
2103                    _sFunction += _sParameter;
2104        label_32:
2105        while (true) {
2106          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2107          case LBRACKET:
2108            ;
2109            break;
2110          default:
2111            jj_la1[68] = jj_gen;
2112            break label_32;
2113          }
2114          jj_consume_token(LBRACKET);
2115          jj_consume_token(RBRACKET);
2116                  _sFunction += "[]";
2117        }
2118      }
2119    
2120      final public void FormalParameters() throws ParseException {
2121                    _sParameter = "(";
2122        jj_consume_token(LPAREN);
2123        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2124        case ABSTRACT:
2125        case BOOLEAN:
2126        case BYTE:
2127        case CHAR:
2128        case DOUBLE:
2129        case FINAL:
2130        case FLOAT:
2131        case INT:
2132        case LONG:
2133        case NATIVE:
2134        case PRIVATE:
2135        case PROTECTED:
2136        case PUBLIC:
2137        case SHORT:
2138        case STATIC:
2139        case TESTAAAA:
2140        case SYNCHRONIZED:
2141        case TRANSIENT:
2142        case VOLATILE:
2143        case IDENTIFIER:
2144        case AT:
2145          FormalParameter();
2146                                _sParameter += _sName;
2147          label_33:
2148          while (true) {
2149            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2150            case COMMA:
2151              ;
2152              break;
2153            default:
2154              jj_la1[69] = jj_gen;
2155              break label_33;
2156            }
2157            jj_consume_token(COMMA);
2158            FormalParameter();
2159                                _sParameter += "," + _sName;
2160          }
2161          break;
2162        default:
2163          jj_la1[70] = jj_gen;
2164          ;
2165        }
2166        jj_consume_token(RPAREN);
2167                    _sParameter += ")";
2168      }
2169    
2170      final public void FormalParameter() throws ParseException {
2171        Modifiers();
2172        Type();
2173        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2174        case ELLIPSIS:
2175          jj_consume_token(ELLIPSIS);
2176          break;
2177        default:
2178          jj_la1[71] = jj_gen;
2179          ;
2180        }
2181        VariableDeclaratorId();
2182      }
2183    
2184      final public void ConstructorDeclaration() throws ParseException {
2185            int oldNcss = _ncss;
2186            int oldFunctions = _functions;
2187            String sOldFunction = _sFunction;
2188            int oldcyc = _cyc;
2189            boolean bOldReturn = _bReturn;
2190            Token tmpToken = null;
2191            int jvdc = 0;
2192    
2193            // added by SMS
2194            int oldSingle;
2195            int oldMulti;
2196            int jvdcLines = 0;
2197            boolean bPublic = false;
2198            //
2199    
2200            //Added by REYNAUD Sebastien (LOGICA)
2201            Token myToken = null;
2202        label_34:
2203        while (true) {
2204          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2205          case AT:
2206            ;
2207            break;
2208          default:
2209            jj_la1[72] = jj_gen;
2210            break label_34;
2211          }
2212             myToken = getToken(1);
2213          Annotation();
2214            if ( tmpToken == null )
2215                    {
2216                            tmpToken = myToken;
2217            }
2218        }
2219        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2220        case PRIVATE:
2221        case PROTECTED:
2222        case PUBLIC:
2223          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2224          case PUBLIC:
2225            jj_consume_token(PUBLIC);
2226                   bPublic = true;
2227          if ( tmpToken == null ) {
2228              tmpToken = getToken( 0 );
2229          }
2230            break;
2231          case PROTECTED:
2232            jj_consume_token(PROTECTED);
2233                     bPublic = true;
2234          if ( tmpToken == null ) {
2235              tmpToken = getToken( 0 );
2236          }
2237            break;
2238          case PRIVATE:
2239            jj_consume_token(PRIVATE);
2240          if ( tmpToken == null ) {
2241              tmpToken = getToken( 0 );
2242          }
2243            break;
2244          default:
2245            jj_la1[73] = jj_gen;
2246            jj_consume_token(-1);
2247            throw new ParseException();
2248          }
2249          break;
2250        default:
2251          jj_la1[74] = jj_gen;
2252          ;
2253        }
2254        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2255        case LT:
2256          TypeParameters();
2257          break;
2258        default:
2259          jj_la1[75] = jj_gen;
2260          ;
2261        }
2262        Identifier();
2263                if ( tmpToken == null ) {
2264                    tmpToken = getToken( 0 );
2265                }
2266                    _cyc = 1;
2267                    _sFunction = _sPackage + _sClass + "." + getToken(0).image;
2268        FormalParameters();
2269                    _sFunction += _sParameter;
2270                    _bReturn = false;
2271        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2272        case THROWS:
2273          jj_consume_token(THROWS);
2274          NameList();
2275          break;
2276        default:
2277          jj_la1[76] = jj_gen;
2278          ;
2279        }
2280        jj_consume_token(LBRACE);
2281        if (jj_2_18(2147483647)) {
2282          ExplicitConstructorInvocation();
2283        } else {
2284          ;
2285        }
2286        if (jj_2_19(2147483647)) {
2287          ExplicitConstructorInvocation();
2288        } else {
2289          ;
2290        }
2291                    while( tmpToken.specialToken != null ) {
2292                        if ( tmpToken.specialToken.image.startsWith( "/**" ) ) {
2293                            _javadocs++;
2294                            jvdc++;
2295                            if ((bPublic && _bPublic) || _bPrivate) {
2296                                Util.debug( "_jvdc++" );
2297                                _jvdc++;
2298                                jvdcLines = JavaParserTokenManager._iMultiCommentsLast;
2299                                _jvdcLines += jvdcLines;
2300                                JavaParserTokenManager._iFormalComments += jvdcLines;
2301                            }
2302                            JavaParserTokenManager._iMultiComments -= jvdcLines;
2303                            break;
2304                        }  else if ( tmpToken.specialToken.image.startsWith( "/*" ) ) {
2305                            jvdcLines = 0;
2306                            break;
2307                        }
2308    
2309                        //System.out.println("\n"+tmpToken.specialToken.image);
2310    
2311                        tmpToken = tmpToken.specialToken;
2312                    }
2313    
2314    
2315                    oldSingle = JavaParserTokenManager._iSingleComments;
2316                    oldMulti = JavaParserTokenManager._iMultiComments;
2317        label_35:
2318        while (true) {
2319          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2320          case ABSTRACT:
2321          case ASSERT:
2322          case BOOLEAN:
2323          case BREAK:
2324          case BYTE:
2325          case CHAR:
2326          case CLASS:
2327          case CONTINUE:
2328          case DO:
2329          case DOUBLE:
2330          case ENUM:
2331          case FALSE:
2332          case FINAL:
2333          case FLOAT:
2334          case FOR:
2335          case IF:
2336          case INT:
2337          case INTERFACE:
2338          case LONG:
2339          case NATIVE:
2340          case NEW:
2341          case NULL:
2342          case PRIVATE:
2343          case PROTECTED:
2344          case PUBLIC:
2345          case RETURN:
2346          case SHORT:
2347          case STATIC:
2348          case TESTAAAA:
2349          case SUPER:
2350          case SWITCH:
2351          case SYNCHRONIZED:
2352          case THIS:
2353          case THROW:
2354          case TRANSIENT:
2355          case TRUE:
2356          case TRY:
2357          case VOID:
2358          case VOLATILE:
2359          case WHILE:
2360          case INTEGER_LITERAL:
2361          case FLOATING_POINT_LITERAL:
2362          case CHARACTER_LITERAL:
2363          case STRING_LITERAL:
2364          case IDENTIFIER:
2365          case LPAREN:
2366          case LBRACE:
2367          case SEMICOLON:
2368          case AT:
2369          case INCR:
2370          case DECR:
2371            ;
2372            break;
2373          default:
2374            jj_la1[77] = jj_gen;
2375            break label_35;
2376          }
2377          BlockStatement();
2378        }
2379        jj_consume_token(RBRACE);
2380                /*
2381                    while( tmpToken.specialToken != null ) {
2382                        if ( tmpToken.specialToken.image.startsWith( "/**" ) ) {
2383                            jvdc++;
2384                            _javadocs++;
2385                        }
2386                        tmpToken = tmpToken.specialToken;
2387                    }
2388                */
2389                    if (_bReturn) {
2390                            _cyc--;
2391                    }
2392                    _ncss++;
2393                    Util.debug( "_ncss++" );
2394    
2395                    FunctionMetric functionMetrics = new FunctionMetric();
2396                    functionMetrics.name = _sFunction;
2397                    functionMetrics.ncss = _ncss - oldNcss;
2398                    functionMetrics.ccn = _cyc;
2399                    functionMetrics.javadocs = jvdc;
2400    
2401                    // added by SMS
2402                    functionMetrics.javadocsLn = jvdcLines;
2403                    functionMetrics.singleLn = JavaParserTokenManager._iSingleComments - oldSingle;
2404                    functionMetrics.multiLn = JavaParserTokenManager._iMultiComments - oldMulti;
2405                    //
2406    
2407                    _vFunctions.add(functionMetrics);
2408                    _sFunction = sOldFunction;
2409                    _functions = oldFunctions + 1;
2410                    _cyc = oldcyc;
2411                    _bReturn = bOldReturn;
2412    
2413                    //Added by REYNAUD Sebastien (LOGICA)
2414                    _tmpToken = null;
2415                    //
2416    
2417      }
2418    
2419      final public void ExplicitConstructorInvocation() throws ParseException {
2420        if (jj_2_21(2147483647)) {
2421          jj_consume_token(THIS);
2422          Arguments();
2423          jj_consume_token(SEMICOLON);
2424               _ncss++;       Util.debug( "_ncss++" );
2425        } else {
2426          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2427          case ASSERT:
2428          case BOOLEAN:
2429          case BYTE:
2430          case CHAR:
2431          case DOUBLE:
2432          case ENUM:
2433          case FALSE:
2434          case FLOAT:
2435          case INT:
2436          case LONG:
2437          case NEW:
2438          case NULL:
2439          case SHORT:
2440          case SUPER:
2441          case THIS:
2442          case TRUE:
2443          case VOID:
2444          case INTEGER_LITERAL:
2445          case FLOATING_POINT_LITERAL:
2446          case CHARACTER_LITERAL:
2447          case STRING_LITERAL:
2448          case IDENTIFIER:
2449          case LPAREN:
2450            if (jj_2_20(2147483647)) {
2451              PrimaryExpression();
2452              jj_consume_token(DOT);
2453            } else {
2454              ;
2455            }
2456            jj_consume_token(SUPER);
2457            Arguments();
2458            jj_consume_token(SEMICOLON);
2459        _ncss++;       Util.debug( "_ncss++" );
2460    //System.out.println( "\n\nAfter ExplicitConstructorInvocation\n" );
2461    
2462            break;
2463          default:
2464            jj_la1[78] = jj_gen;
2465            jj_consume_token(-1);
2466            throw new ParseException();
2467          }
2468        }
2469      }
2470    
2471      final public void Initializer() throws ParseException {
2472        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2473        case STATIC:
2474          jj_consume_token(STATIC);
2475          break;
2476        default:
2477          jj_la1[79] = jj_gen;
2478          ;
2479        }
2480        Block();
2481              _ncss++;       Util.debug( "_ncss++" );
2482      }
2483    
2484    /*
2485     * Type, name and expression syntax follows.
2486     */
2487      final public void Type() throws ParseException {
2488        if (jj_2_22(2)) {
2489          ReferenceType();
2490        } else {
2491          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2492          case BOOLEAN:
2493          case BYTE:
2494          case CHAR:
2495          case DOUBLE:
2496          case FLOAT:
2497          case INT:
2498          case LONG:
2499          case SHORT:
2500            PrimitiveType();
2501                      _sName = getToken(0).image;
2502            break;
2503          default:
2504            jj_la1[80] = jj_gen;
2505            jj_consume_token(-1);
2506            throw new ParseException();
2507          }
2508        }
2509      }
2510    
2511    /*
2512    ccl 2008-01-24
2513    {
2514      ( PrimitiveType()
2515              {
2516                      _sName = getToken(0).image;
2517              }
2518        | Name()
2519        [TypeArguments() ["." Identifier()] ]
2520    ) ( "[" "]" { _sName += "[]"; } )*
2521    }
2522    */
2523    
2524    /*
2525     * Takes special consideration for assert.
2526     */
2527      final public void FieldTypeLookahead() throws ParseException {
2528        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2529        case BOOLEAN:
2530        case BYTE:
2531        case CHAR:
2532        case DOUBLE:
2533        case FLOAT:
2534        case INT:
2535        case LONG:
2536        case SHORT:
2537          PrimitiveType();
2538          break;
2539        case IDENTIFIER:
2540          FieldTypeNameLookahead();
2541          break;
2542        default:
2543          jj_la1[81] = jj_gen;
2544          jj_consume_token(-1);
2545          throw new ParseException();
2546        }
2547        label_36:
2548        while (true) {
2549          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2550          case LBRACKET:
2551            ;
2552            break;
2553          default:
2554            jj_la1[82] = jj_gen;
2555            break label_36;
2556          }
2557          jj_consume_token(LBRACKET);
2558          jj_consume_token(RBRACKET);
2559        }
2560      }
2561    
2562      final public void PrimitiveType() throws ParseException {
2563        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2564        case BOOLEAN:
2565          jj_consume_token(BOOLEAN);
2566          break;
2567        case CHAR:
2568          jj_consume_token(CHAR);
2569          break;
2570        case BYTE:
2571          jj_consume_token(BYTE);
2572          break;
2573        case SHORT:
2574          jj_consume_token(SHORT);
2575          break;
2576        case INT:
2577          jj_consume_token(INT);
2578          break;
2579        case LONG:
2580          jj_consume_token(LONG);
2581          break;
2582        case FLOAT:
2583          jj_consume_token(FLOAT);
2584          break;
2585        case DOUBLE:
2586          jj_consume_token(DOUBLE);
2587          break;
2588        default:
2589          jj_la1[83] = jj_gen;
2590          jj_consume_token(-1);
2591          throw new ParseException();
2592        }
2593      }
2594    
2595      final public void ResultType() throws ParseException {
2596        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2597        case VOID:
2598          jj_consume_token(VOID);
2599          break;
2600        case BOOLEAN:
2601        case BYTE:
2602        case CHAR:
2603        case DOUBLE:
2604        case FLOAT:
2605        case INT:
2606        case LONG:
2607        case SHORT:
2608        case IDENTIFIER:
2609          Type();
2610          break;
2611        default:
2612          jj_la1[84] = jj_gen;
2613          jj_consume_token(-1);
2614          throw new ParseException();
2615        }
2616      }
2617    
2618      final public void Name() throws ParseException {
2619        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2620        case ENUM:
2621          jj_consume_token(ENUM);
2622          break;
2623        case ASSERT:
2624        case IDENTIFIER:
2625          Identifier();
2626          break;
2627        default:
2628          jj_la1[85] = jj_gen;
2629          jj_consume_token(-1);
2630          throw new ParseException();
2631        }
2632                    _sName = getToken(0).image;
2633                    _tmpResultToken = getToken( 0 );
2634                    Util.debug( "Name._tmpResultToken: " + _tmpResultToken );
2635        label_37:
2636        while (true) {
2637          if (jj_2_23(2)) {
2638            ;
2639          } else {
2640            break label_37;
2641          }
2642          jj_consume_token(DOT);
2643          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2644          case ENUM:
2645            jj_consume_token(ENUM);
2646            break;
2647          case ASSERT:
2648          case IDENTIFIER:
2649            Identifier();
2650            break;
2651          default:
2652            jj_la1[86] = jj_gen;
2653            jj_consume_token(-1);
2654            throw new ParseException();
2655          }
2656                    _sName += "." + getToken(0).image;
2657        }
2658      }
2659    
2660    /**
2661     * Takes special consideration for assert.
2662     */
2663      final public void FieldTypeNameLookahead() throws ParseException {
2664        jj_consume_token(IDENTIFIER);
2665        label_38:
2666        while (true) {
2667          if (jj_2_24(2)) {
2668            ;
2669          } else {
2670            break label_38;
2671          }
2672          jj_consume_token(DOT);
2673          Identifier();
2674        }
2675      }
2676    
2677      final public void NameList() throws ParseException {
2678        Name();
2679        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2680        case LT:
2681          TypeArguments();
2682          break;
2683        default:
2684          jj_la1[87] = jj_gen;
2685          ;
2686        }
2687        label_39:
2688        while (true) {
2689          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2690          case COMMA:
2691            ;
2692            break;
2693          default:
2694            jj_la1[88] = jj_gen;
2695            break label_39;
2696          }
2697          jj_consume_token(COMMA);
2698          Name();
2699          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2700          case LT:
2701            TypeArguments();
2702            break;
2703          default:
2704            jj_la1[89] = jj_gen;
2705            ;
2706          }
2707        }
2708      }
2709    
2710    /*
2711     * Expression syntax follows.
2712     */
2713      final public void Expression() throws ParseException {
2714        if (jj_2_25(2147483647)) {
2715          Assignment();
2716        } else {
2717          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2718          case ASSERT:
2719          case BOOLEAN:
2720          case BYTE:
2721          case CHAR:
2722          case DOUBLE:
2723          case ENUM:
2724          case FALSE:
2725          case FLOAT:
2726          case INT:
2727          case LONG:
2728          case NEW:
2729          case NULL:
2730          case SHORT:
2731          case SUPER:
2732          case THIS:
2733          case TRUE:
2734          case VOID:
2735          case INTEGER_LITERAL:
2736          case FLOATING_POINT_LITERAL:
2737          case CHARACTER_LITERAL:
2738          case STRING_LITERAL:
2739          case IDENTIFIER:
2740          case LPAREN:
2741          case BANG:
2742          case TILDE:
2743          case INCR:
2744          case DECR:
2745          case PLUS:
2746          case MINUS:
2747            ConditionalExpression();
2748            break;
2749          default:
2750            jj_la1[90] = jj_gen;
2751            jj_consume_token(-1);
2752            throw new ParseException();
2753          }
2754        }
2755      }
2756    
2757      final public void Assignment() throws ParseException {
2758        PrimaryExpression();
2759        AssignmentOperator();
2760        Expression();
2761      }
2762    
2763      final public void AssignmentOperator() throws ParseException {
2764        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2765        case ASSIGN:
2766          jj_consume_token(ASSIGN);
2767          break;
2768        case STARASSIGN:
2769          jj_consume_token(STARASSIGN);
2770          break;
2771        case SLASHASSIGN:
2772          jj_consume_token(SLASHASSIGN);
2773          break;
2774        case REMASSIGN:
2775          jj_consume_token(REMASSIGN);
2776          break;
2777        case PLUSASSIGN:
2778          jj_consume_token(PLUSASSIGN);
2779          break;
2780        case MINUSASSIGN:
2781          jj_consume_token(MINUSASSIGN);
2782          break;
2783        case LSHIFTASSIGN:
2784          jj_consume_token(LSHIFTASSIGN);
2785          break;
2786        case RSIGNEDSHIFTASSIGN:
2787          jj_consume_token(RSIGNEDSHIFTASSIGN);
2788          break;
2789        case RUNSIGNEDSHIFTASSIGN:
2790          jj_consume_token(RUNSIGNEDSHIFTASSIGN);
2791          break;
2792        case ANDASSIGN:
2793          jj_consume_token(ANDASSIGN);
2794          break;
2795        case XORASSIGN:
2796          jj_consume_token(XORASSIGN);
2797          break;
2798        case ORASSIGN:
2799          jj_consume_token(ORASSIGN);
2800          break;
2801        default:
2802          jj_la1[91] = jj_gen;
2803          jj_consume_token(-1);
2804          throw new ParseException();
2805        }
2806      }
2807    
2808      final public void ConditionalExpression() throws ParseException {
2809        ConditionalOrExpression();
2810        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2811        case HOOK:
2812          jj_consume_token(HOOK);
2813          Expression();
2814          jj_consume_token(COLON);
2815          ConditionalExpression();
2816                                                                                 _cyc++;
2817          break;
2818        default:
2819          jj_la1[92] = jj_gen;
2820          ;
2821        }
2822      }
2823    
2824      final public void ConditionalOrExpression() throws ParseException {
2825        ConditionalAndExpression();
2826        label_40:
2827        while (true) {
2828          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2829          case SC_OR:
2830            ;
2831            break;
2832          default:
2833            jj_la1[93] = jj_gen;
2834            break label_40;
2835          }
2836          jj_consume_token(SC_OR);
2837                                          _cyc++;
2838          ConditionalAndExpression();
2839        }
2840      }
2841    
2842      final public void ConditionalAndExpression() throws ParseException {
2843        InclusiveOrExpression();
2844        label_41:
2845        while (true) {
2846          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2847          case SC_AND:
2848            ;
2849            break;
2850          default:
2851            jj_la1[94] = jj_gen;
2852            break label_41;
2853          }
2854          jj_consume_token(SC_AND);
2855                                       _cyc++;
2856          InclusiveOrExpression();
2857        }
2858      }
2859    
2860      final public void InclusiveOrExpression() throws ParseException {
2861        ExclusiveOrExpression();
2862        label_42:
2863        while (true) {
2864          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2865          case BIT_OR:
2866            ;
2867            break;
2868          default:
2869            jj_la1[95] = jj_gen;
2870            break label_42;
2871          }
2872          jj_consume_token(BIT_OR);
2873          ExclusiveOrExpression();
2874        }
2875      }
2876    
2877      final public void ExclusiveOrExpression() throws ParseException {
2878        AndExpression();
2879        label_43:
2880        while (true) {
2881          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2882          case XOR:
2883            ;
2884            break;
2885          default:
2886            jj_la1[96] = jj_gen;
2887            break label_43;
2888          }
2889          jj_consume_token(XOR);
2890          AndExpression();
2891        }
2892      }
2893    
2894      final public void AndExpression() throws ParseException {
2895        EqualityExpression();
2896        label_44:
2897        while (true) {
2898          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2899          case BIT_AND:
2900            ;
2901            break;
2902          default:
2903            jj_la1[97] = jj_gen;
2904            break label_44;
2905          }
2906          jj_consume_token(BIT_AND);
2907          EqualityExpression();
2908        }
2909      }
2910    
2911      final public void EqualityExpression() throws ParseException {
2912        InstanceOfExpression();
2913        label_45:
2914        while (true) {
2915          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2916          case EQ:
2917          case NE:
2918            ;
2919            break;
2920          default:
2921            jj_la1[98] = jj_gen;
2922            break label_45;
2923          }
2924          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2925          case EQ:
2926            jj_consume_token(EQ);
2927            break;
2928          case NE:
2929            jj_consume_token(NE);
2930            break;
2931          default:
2932            jj_la1[99] = jj_gen;
2933            jj_consume_token(-1);
2934            throw new ParseException();
2935          }
2936          InstanceOfExpression();
2937        }
2938      }
2939    
2940      final public void InstanceOfExpression() throws ParseException {
2941        RelationalExpression();
2942        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2943        case INSTANCEOF:
2944          jj_consume_token(INSTANCEOF);
2945          Type();
2946          break;
2947        default:
2948          jj_la1[100] = jj_gen;
2949          ;
2950        }
2951      }
2952    
2953      final public void RelationalExpression() throws ParseException {
2954        ShiftExpression();
2955        label_46:
2956        while (true) {
2957          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2958          case GT:
2959          case LT:
2960          case LE:
2961          case GE:
2962            ;
2963            break;
2964          default:
2965            jj_la1[101] = jj_gen;
2966            break label_46;
2967          }
2968          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2969          case LT:
2970            jj_consume_token(LT);
2971            break;
2972          case GT:
2973            jj_consume_token(GT);
2974            break;
2975          case LE:
2976            jj_consume_token(LE);
2977            break;
2978          case GE:
2979            jj_consume_token(GE);
2980            break;
2981          default:
2982            jj_la1[102] = jj_gen;
2983            jj_consume_token(-1);
2984            throw new ParseException();
2985          }
2986          ShiftExpression();
2987        }
2988      }
2989    
2990      final public void ShiftExpression() throws ParseException {
2991        AdditiveExpression();
2992        label_47:
2993        while (true) {
2994          if (jj_2_26(3)) {
2995            ;
2996          } else {
2997            break label_47;
2998          }
2999          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3000          case LSHIFT:
3001            jj_consume_token(LSHIFT);
3002            break;
3003          case GT:
3004            jj_consume_token(GT);
3005            jj_consume_token(GT);
3006            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3007            case GT:
3008              jj_consume_token(GT);
3009              break;
3010            default:
3011              jj_la1[103] = jj_gen;
3012              ;
3013            }
3014            break;
3015          default:
3016            jj_la1[104] = jj_gen;
3017            jj_consume_token(-1);
3018            throw new ParseException();
3019          }
3020          AdditiveExpression();
3021        }
3022      }
3023    
3024      final public void AdditiveExpression() throws ParseException {
3025        MultiplicativeExpression();
3026        label_48:
3027        while (true) {
3028          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3029          case PLUS:
3030          case MINUS:
3031            ;
3032            break;
3033          default:
3034            jj_la1[105] = jj_gen;
3035            break label_48;
3036          }
3037          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3038          case PLUS:
3039            jj_consume_token(PLUS);
3040            break;
3041          case MINUS:
3042            jj_consume_token(MINUS);
3043            break;
3044          default:
3045            jj_la1[106] = jj_gen;
3046            jj_consume_token(-1);
3047            throw new ParseException();
3048          }
3049          MultiplicativeExpression();
3050        }
3051      }
3052    
3053      final public void MultiplicativeExpression() throws ParseException {
3054        UnaryExpression();
3055        label_49:
3056        while (true) {
3057          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3058          case STAR:
3059          case SLASH:
3060          case REM:
3061            ;
3062            break;
3063          default:
3064            jj_la1[107] = jj_gen;
3065            break label_49;
3066          }
3067          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3068          case STAR:
3069            jj_consume_token(STAR);
3070            break;
3071          case SLASH:
3072            jj_consume_token(SLASH);
3073            break;
3074          case REM:
3075            jj_consume_token(REM);
3076            break;
3077          default:
3078            jj_la1[108] = jj_gen;
3079            jj_consume_token(-1);
3080            throw new ParseException();
3081          }
3082          UnaryExpression();
3083        }
3084      }
3085    
3086      final public void UnaryExpression() throws ParseException {
3087        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3088        case PLUS:
3089        case MINUS:
3090          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3091          case PLUS:
3092            jj_consume_token(PLUS);
3093            break;
3094          case MINUS:
3095            jj_consume_token(MINUS);
3096            break;
3097          default:
3098            jj_la1[109] = jj_gen;
3099            jj_consume_token(-1);
3100            throw new ParseException();
3101          }
3102          UnaryExpression();
3103          break;
3104        case INCR:
3105          PreIncrementExpression();
3106          break;
3107        case DECR:
3108          PreDecrementExpression();
3109          break;
3110        case ASSERT:
3111        case BOOLEAN:
3112        case BYTE:
3113        case CHAR:
3114        case DOUBLE:
3115        case ENUM:
3116        case FALSE:
3117        case FLOAT:
3118        case INT:
3119        case LONG:
3120        case NEW:
3121        case NULL:
3122        case SHORT:
3123        case SUPER:
3124        case THIS:
3125        case TRUE:
3126        case VOID:
3127        case INTEGER_LITERAL:
3128        case FLOATING_POINT_LITERAL:
3129        case CHARACTER_LITERAL:
3130        case STRING_LITERAL:
3131        case IDENTIFIER:
3132        case LPAREN:
3133        case BANG:
3134        case TILDE:
3135          UnaryExpressionNotPlusMinus();
3136          break;
3137        default:
3138          jj_la1[110] = jj_gen;
3139          jj_consume_token(-1);
3140          throw new ParseException();
3141        }
3142      }
3143    
3144      final public void PreIncrementExpression() throws ParseException {
3145        jj_consume_token(INCR);
3146        PrimaryExpression();
3147      }
3148    
3149      final public void PreDecrementExpression() throws ParseException {
3150        jj_consume_token(DECR);
3151        PrimaryExpression();
3152      }
3153    
3154      final public void UnaryExpressionNotPlusMinus() throws ParseException {
3155        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3156        case BANG:
3157        case TILDE:
3158          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3159          case TILDE:
3160            jj_consume_token(TILDE);
3161            break;
3162          case BANG:
3163            jj_consume_token(BANG);
3164            break;
3165          default:
3166            jj_la1[111] = jj_gen;
3167            jj_consume_token(-1);
3168            throw new ParseException();
3169          }
3170          UnaryExpression();
3171          break;
3172        default:
3173          jj_la1[112] = jj_gen;
3174          if (jj_2_27(2147483647)) {
3175            CastExpression();
3176          } else {
3177            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3178            case ASSERT:
3179            case BOOLEAN:
3180            case BYTE:
3181            case CHAR:
3182            case DOUBLE:
3183            case ENUM:
3184            case FALSE:
3185            case FLOAT:
3186            case INT:
3187            case LONG:
3188            case NEW:
3189            case NULL:
3190            case SHORT:
3191            case SUPER:
3192            case THIS:
3193            case TRUE:
3194            case VOID:
3195            case INTEGER_LITERAL:
3196            case FLOATING_POINT_LITERAL:
3197            case CHARACTER_LITERAL:
3198            case STRING_LITERAL:
3199            case IDENTIFIER:
3200            case LPAREN:
3201              PostfixExpression();
3202              break;
3203            default:
3204              jj_la1[113] = jj_gen;
3205              jj_consume_token(-1);
3206              throw new ParseException();
3207            }
3208          }
3209        }
3210      }
3211    
3212    // This production is to determine lookahead only.  The LOOKAHEAD specifications
3213    // below are not used, but they are there just to indicate that we know about
3214    // this.
3215      final public void CastLookahead() throws ParseException {
3216        if (jj_2_28(2)) {
3217          jj_consume_token(LPAREN);
3218          PrimitiveType();
3219        } else if (jj_2_29(2147483647)) {
3220          jj_consume_token(LPAREN);
3221          Type();
3222          jj_consume_token(LBRACKET);
3223          jj_consume_token(RBRACKET);
3224        } else {
3225          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3226          case LPAREN:
3227            jj_consume_token(LPAREN);
3228            Type();
3229            jj_consume_token(RPAREN);
3230            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3231            case TILDE:
3232              jj_consume_token(TILDE);
3233              break;
3234            case BANG:
3235              jj_consume_token(BANG);
3236              break;
3237            case LPAREN:
3238              jj_consume_token(LPAREN);
3239              break;
3240            case ASSERT:
3241            case IDENTIFIER:
3242              Identifier();
3243              break;
3244            case THIS:
3245              jj_consume_token(THIS);
3246              break;
3247            case SUPER:
3248              jj_consume_token(SUPER);
3249              break;
3250            case NEW:
3251              jj_consume_token(NEW);
3252              break;
3253            case FALSE:
3254            case NULL:
3255            case TRUE:
3256            case INTEGER_LITERAL:
3257            case FLOATING_POINT_LITERAL:
3258            case CHARACTER_LITERAL:
3259            case STRING_LITERAL:
3260              Literal();
3261              break;
3262            default:
3263              jj_la1[114] = jj_gen;
3264              jj_consume_token(-1);
3265              throw new ParseException();
3266            }
3267            break;
3268          default:
3269            jj_la1[115] = jj_gen;
3270            jj_consume_token(-1);
3271            throw new ParseException();
3272          }
3273        }
3274      }
3275    
3276    // To fix bug Test48.java. Clemens [2000-10-03]
3277      final public void PostfixLookahead() throws ParseException {
3278        jj_consume_token(LPAREN);
3279        Name();
3280        label_50:
3281        while (true) {
3282          if (jj_2_30(2)) {
3283            ;
3284          } else {
3285            break label_50;
3286          }
3287          jj_consume_token(LBRACKET);
3288          jj_consume_token(RBRACKET);
3289        }
3290        jj_consume_token(DOT);
3291      }
3292    
3293      final public void PostfixExpression() throws ParseException {
3294        PrimaryExpression();
3295        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3296        case INCR:
3297        case DECR:
3298          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3299          case INCR:
3300            jj_consume_token(INCR);
3301            break;
3302          case DECR:
3303            jj_consume_token(DECR);
3304            break;
3305          default:
3306            jj_la1[116] = jj_gen;
3307            jj_consume_token(-1);
3308            throw new ParseException();
3309          }
3310          break;
3311        default:
3312          jj_la1[117] = jj_gen;
3313          ;
3314        }
3315      }
3316    
3317      final public void CastExpression() throws ParseException {
3318        if (jj_2_31(2147483647)) {
3319          jj_consume_token(LPAREN);
3320          Type();
3321          jj_consume_token(RPAREN);
3322          UnaryExpression();
3323        } else {
3324          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3325          case LPAREN:
3326            jj_consume_token(LPAREN);
3327            Type();
3328            jj_consume_token(RPAREN);
3329            UnaryExpressionNotPlusMinus();
3330            break;
3331          default:
3332            jj_la1[118] = jj_gen;
3333            jj_consume_token(-1);
3334            throw new ParseException();
3335          }
3336        }
3337      }
3338    
3339      final public void PrimaryExpression() throws ParseException {
3340        PrimaryPrefix();
3341        label_51:
3342        while (true) {
3343          if (jj_2_32(2)) {
3344            ;
3345          } else {
3346            break label_51;
3347          }
3348          PrimarySuffix();
3349        }
3350      }
3351    
3352      final public void PrimaryPrefix() throws ParseException {
3353        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3354        case FALSE:
3355        case NULL:
3356        case TRUE:
3357        case INTEGER_LITERAL:
3358        case FLOATING_POINT_LITERAL:
3359        case CHARACTER_LITERAL:
3360        case STRING_LITERAL:
3361          Literal();
3362          break;
3363        case THIS:
3364          jj_consume_token(THIS);
3365          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3366          case DOT:
3367            jj_consume_token(DOT);
3368            break;
3369          default:
3370            jj_la1[119] = jj_gen;
3371            ;
3372          }
3373          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3374          case ASSERT:
3375          case IDENTIFIER:
3376            Identifier();
3377            break;
3378          default:
3379            jj_la1[120] = jj_gen;
3380            ;
3381          }
3382          break;
3383        default:
3384          jj_la1[123] = jj_gen;
3385          if (jj_2_34(2)) {
3386            jj_consume_token(SUPER);
3387            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3388            case DOT:
3389              jj_consume_token(DOT);
3390              break;
3391            default:
3392              jj_la1[121] = jj_gen;
3393              ;
3394            }
3395            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3396            case ASSERT:
3397            case IDENTIFIER:
3398              Identifier();
3399              break;
3400            default:
3401              jj_la1[122] = jj_gen;
3402              ;
3403            }
3404          } else {
3405            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3406            case LPAREN:
3407              jj_consume_token(LPAREN);
3408              Expression();
3409              jj_consume_token(RPAREN);
3410              break;
3411            case NEW:
3412              AllocationExpression();
3413              break;
3414            default:
3415              jj_la1[124] = jj_gen;
3416              if (jj_2_35(2147483647)) {
3417                ResultType();
3418                jj_consume_token(DOT);
3419                jj_consume_token(CLASS);
3420              } else {
3421                switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3422                case ASSERT:
3423                case ENUM:
3424                case IDENTIFIER:
3425                  Name();
3426                  if (jj_2_33(3)) {
3427                    jj_consume_token(DOT);
3428                    jj_consume_token(SUPER);
3429                    jj_consume_token(DOT);
3430                    Identifier();
3431                  } else {
3432                    ;
3433                  }
3434                  break;
3435                default:
3436                  jj_la1[125] = jj_gen;
3437                  jj_consume_token(-1);
3438                  throw new ParseException();
3439                }
3440              }
3441            }
3442          }
3443        }
3444      }
3445    
3446      final public void PrimarySuffix() throws ParseException {
3447        if (jj_2_36(2)) {
3448          jj_consume_token(DOT);
3449          jj_consume_token(THIS);
3450        } else if (jj_2_37(2)) {
3451          jj_consume_token(DOT);
3452          AllocationExpression();
3453        } else if (jj_2_38(3)) {
3454          MemberSelector();
3455        } else {
3456          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3457          case LBRACKET:
3458            jj_consume_token(LBRACKET);
3459            Expression();
3460            jj_consume_token(RBRACKET);
3461            break;
3462          case DOT:
3463            jj_consume_token(DOT);
3464            Identifier();
3465            break;
3466          case LPAREN:
3467            Arguments();
3468            break;
3469          default:
3470            jj_la1[126] = jj_gen;
3471            jj_consume_token(-1);
3472            throw new ParseException();
3473          }
3474        }
3475      }
3476    
3477      final public void Literal() throws ParseException {
3478        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3479        case INTEGER_LITERAL:
3480          jj_consume_token(INTEGER_LITERAL);
3481          break;
3482        case FLOATING_POINT_LITERAL:
3483          jj_consume_token(FLOATING_POINT_LITERAL);
3484          break;
3485        case CHARACTER_LITERAL:
3486          jj_consume_token(CHARACTER_LITERAL);
3487          break;
3488        case STRING_LITERAL:
3489          jj_consume_token(STRING_LITERAL);
3490          break;
3491        case FALSE:
3492        case TRUE:
3493          BooleanLiteral();
3494          break;
3495        case NULL:
3496          NullLiteral();
3497          break;
3498        default:
3499          jj_la1[127] = jj_gen;
3500          jj_consume_token(-1);
3501          throw new ParseException();
3502        }
3503      }
3504    
3505      final public void BooleanLiteral() throws ParseException {
3506        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3507        case TRUE:
3508          jj_consume_token(TRUE);
3509          break;
3510        case FALSE:
3511          jj_consume_token(FALSE);
3512          break;
3513        default:
3514          jj_la1[128] = jj_gen;
3515          jj_consume_token(-1);
3516          throw new ParseException();
3517        }
3518      }
3519    
3520      final public void NullLiteral() throws ParseException {
3521        jj_consume_token(NULL);
3522      }
3523    
3524      final public void Arguments() throws ParseException {
3525        jj_consume_token(LPAREN);
3526        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3527        case ASSERT:
3528        case BOOLEAN:
3529        case BYTE:
3530        case CHAR:
3531        case DOUBLE:
3532        case ENUM:
3533        case FALSE:
3534        case FLOAT:
3535        case INT:
3536        case LONG:
3537        case NEW:
3538        case NULL:
3539        case SHORT:
3540        case SUPER:
3541        case THIS:
3542        case TRUE:
3543        case VOID:
3544        case INTEGER_LITERAL:
3545        case FLOATING_POINT_LITERAL:
3546        case CHARACTER_LITERAL:
3547        case STRING_LITERAL:
3548        case IDENTIFIER:
3549        case LPAREN:
3550        case BANG:
3551        case TILDE:
3552        case INCR:
3553        case DECR:
3554        case PLUS:
3555        case MINUS:
3556          ArgumentList();
3557          break;
3558        default:
3559          jj_la1[129] = jj_gen;
3560          ;
3561        }
3562        jj_consume_token(RPAREN);
3563      }
3564    
3565      final public void ArgumentList() throws ParseException {
3566        Expression();
3567        label_52:
3568        while (true) {
3569          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3570          case COMMA:
3571            ;
3572            break;
3573          default:
3574            jj_la1[130] = jj_gen;
3575            break label_52;
3576          }
3577          jj_consume_token(COMMA);
3578          Expression();
3579        }
3580      }
3581    
3582      final public void AllocationExpression() throws ParseException {
3583            String sOldClass = _sClass;
3584            //int oldNcss = _ncss;
3585            int oldFunctions = _functions;
3586            int oldClasses = _classes;
3587            String sName;
3588    
3589            //Added by REYNAUD Sebastien (LOGICA)
3590            int oldJavadocs = _javadocs;
3591            int oldNcss = _ncss;
3592        if (jj_2_39(2)) {
3593          jj_consume_token(NEW);
3594          PrimitiveType();
3595          ArrayDimsAndInits();
3596        } else {
3597          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3598          case NEW:
3599            jj_consume_token(NEW);
3600            Name();
3601                              sName = _sName;
3602            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3603            case LT:
3604              TypeArguments();
3605              break;
3606            default:
3607              jj_la1[131] = jj_gen;
3608              ;
3609            }
3610            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3611            case LBRACKET:
3612              ArrayDimsAndInits();
3613              break;
3614            case LPAREN:
3615              Arguments();
3616              switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3617              case LBRACE:
3618                             if (!_sClass.equals("")) {
3619                                     _sClass += ".";
3620                             }
3621                             /*_sClass += sName;*/
3622                             //_sClass += sName + "$" + _anonClassCount ;//Removed by REYNAUD Sebastien (LOGICA)
3623    
3624                                    //Added by REYNAUD Sebastien (LOGICA)
3625                                    _sClass += sName;
3626                                    //
3627                             _classLevel ++;
3628                ClassBody();
3629                                    //Added by REYNAUD Sebastien (LOGICA)
3630                                    ObjectMetric metric = new ObjectMetric();
3631                                    metric.name = _sPackage + _sClass;
3632                                    metric.ncss = _ncss - oldNcss;
3633                                metric.functions = _functions - oldFunctions;
3634                          metric.classes = _classes - oldClasses;
3635                            Token lastToken = getToken( 0 );
3636                            _vClasses.add( metric );
3637                            _pPackageMetric.functions += _functions - oldFunctions;
3638                            _pPackageMetric.classes++;
3639                                    metric.javadocs = _javadocs - oldJavadocs;
3640                                    //
3641                                    _classLevel--;
3642                                    _functions = oldFunctions;
3643                                    _classes = oldClasses + 1;
3644                                    _sClass = sOldClass;
3645                break;
3646              default:
3647                jj_la1[132] = jj_gen;
3648                ;
3649              }
3650              break;
3651            default:
3652              jj_la1[133] = jj_gen;
3653              jj_consume_token(-1);
3654              throw new ParseException();
3655            }
3656            break;
3657          default:
3658            jj_la1[134] = jj_gen;
3659            jj_consume_token(-1);
3660            throw new ParseException();
3661          }
3662        }
3663      }
3664    
3665    /*
3666     * The third LOOKAHEAD specification below is to parse to PrimarySuffix
3667     * if there is an expression between the "[...]".
3668     */
3669      final public void ArrayDimsAndInits() throws ParseException {
3670        if (jj_2_42(2)) {
3671          label_53:
3672          while (true) {
3673            jj_consume_token(LBRACKET);
3674            Expression();
3675            jj_consume_token(RBRACKET);
3676            if (jj_2_40(2)) {
3677              ;
3678            } else {
3679              break label_53;
3680            }
3681          }
3682          label_54:
3683          while (true) {
3684            if (jj_2_41(2)) {
3685              ;
3686            } else {
3687              break label_54;
3688            }
3689            jj_consume_token(LBRACKET);
3690            jj_consume_token(RBRACKET);
3691          }
3692        } else {
3693          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3694          case LBRACKET:
3695            label_55:
3696            while (true) {
3697              jj_consume_token(LBRACKET);
3698              jj_consume_token(RBRACKET);
3699              switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3700              case LBRACKET:
3701                ;
3702                break;
3703              default:
3704                jj_la1[135] = jj_gen;
3705                break label_55;
3706              }
3707            }
3708            ArrayInitializer();
3709            break;
3710          default:
3711            jj_la1[136] = jj_gen;
3712            jj_consume_token(-1);
3713            throw new ParseException();
3714          }
3715        }
3716      }
3717    
3718    /*
3719     * Statement syntax follows.
3720     */
3721      final public void Statement() throws ParseException {
3722            _bReturn = false;
3723        if (jj_2_43(2)) {
3724          LabeledStatement();
3725        } else if (jj_2_44(2147483647)) {
3726          AssertStatement();
3727        } else {
3728          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3729          case LBRACE:
3730            Block();
3731            break;
3732          case SEMICOLON:
3733            EmptyStatement();
3734            break;
3735          case ASSERT:
3736          case BOOLEAN:
3737          case BYTE:
3738          case CHAR:
3739          case DOUBLE:
3740          case ENUM:
3741          case FALSE:
3742          case FLOAT:
3743          case INT:
3744          case LONG:
3745          case NEW:
3746          case NULL:
3747          case SHORT:
3748          case SUPER:
3749          case THIS:
3750          case TRUE:
3751          case VOID:
3752          case INTEGER_LITERAL:
3753          case FLOATING_POINT_LITERAL:
3754          case CHARACTER_LITERAL:
3755          case STRING_LITERAL:
3756          case IDENTIFIER:
3757          case LPAREN:
3758          case INCR:
3759          case DECR:
3760            StatementExpression();
3761            jj_consume_token(SEMICOLON);
3762              _ncss++;       Util.debug( "_ncss++" );
3763            break;
3764          case SWITCH:
3765            SwitchStatement();
3766            break;
3767          case IF:
3768            IfStatement();
3769              _cyc++;
3770            break;
3771          case WHILE:
3772            WhileStatement();
3773              _cyc++;
3774            break;
3775          case DO:
3776            DoStatement();
3777              _cyc++;
3778            break;
3779          case FOR:
3780            ForStatement();
3781              _cyc++;
3782            break;
3783          case BREAK:
3784            BreakStatement();
3785            break;
3786          case CONTINUE:
3787            ContinueStatement();
3788            break;
3789          case RETURN:
3790            ReturnStatement();
3791            break;
3792          case THROW:
3793            ThrowStatement();
3794            break;
3795          case SYNCHRONIZED:
3796            SynchronizedStatement();
3797            break;
3798          case TRY:
3799            TryStatement();
3800            break;
3801          default:
3802            jj_la1[137] = jj_gen;
3803            jj_consume_token(-1);
3804            throw new ParseException();
3805          }
3806        }
3807      }
3808    
3809      final public void LabeledStatement() throws ParseException {
3810        Identifier();
3811        jj_consume_token(COLON);
3812        Statement();
3813              _ncss++;       Util.debug( "_ncss++" );
3814      }
3815    
3816      final public void AssertStatementLookahead() throws ParseException {
3817        jj_consume_token(ASSERT);
3818        Expression();
3819      }
3820    
3821      final public void AssertStatement() throws ParseException {
3822        jj_consume_token(ASSERT);
3823        Expression();
3824        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3825        case COLON:
3826          jj_consume_token(COLON);
3827          Expression();
3828          break;
3829        default:
3830          jj_la1[138] = jj_gen;
3831          ;
3832        }
3833        jj_consume_token(SEMICOLON);
3834        _ncss++;       Util.debug( "_ncss++" );
3835      }
3836    
3837      final public void Block() throws ParseException {
3838        jj_consume_token(LBRACE);
3839        label_56:
3840        while (true) {
3841          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3842          case ABSTRACT:
3843          case ASSERT:
3844          case BOOLEAN:
3845          case BREAK:
3846          case BYTE:
3847          case CHAR:
3848          case CLASS:
3849          case CONTINUE:
3850          case DO:
3851          case DOUBLE:
3852          case ENUM:
3853          case FALSE:
3854          case FINAL:
3855          case FLOAT:
3856          case FOR:
3857          case IF:
3858          case INT:
3859          case INTERFACE:
3860          case LONG:
3861          case NATIVE:
3862          case NEW:
3863          case NULL:
3864          case PRIVATE:
3865          case PROTECTED:
3866          case PUBLIC:
3867          case RETURN:
3868          case SHORT:
3869          case STATIC:
3870          case TESTAAAA:
3871          case SUPER:
3872          case SWITCH:
3873          case SYNCHRONIZED:
3874          case THIS:
3875          case THROW:
3876          case TRANSIENT:
3877          case TRUE:
3878          case TRY:
3879          case VOID:
3880          case VOLATILE:
3881          case WHILE:
3882          case INTEGER_LITERAL:
3883          case FLOATING_POINT_LITERAL:
3884          case CHARACTER_LITERAL:
3885          case STRING_LITERAL:
3886          case IDENTIFIER:
3887          case LPAREN:
3888          case LBRACE:
3889          case SEMICOLON:
3890          case AT:
3891          case INCR:
3892          case DECR:
3893            ;
3894            break;
3895          default:
3896            jj_la1[139] = jj_gen;
3897            break label_56;
3898          }
3899          BlockStatement();
3900        }
3901        jj_consume_token(RBRACE);
3902      }
3903    
3904      final public void BlockStatement() throws ParseException {
3905        if (jj_2_45(2147483647)) {
3906          LocalVariableDeclaration();
3907          jj_consume_token(SEMICOLON);
3908                    _ncss++;       Util.debug( "_ncss++" );
3909        } else {
3910          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3911          case ASSERT:
3912          case BOOLEAN:
3913          case BREAK:
3914          case BYTE:
3915          case CHAR:
3916          case CONTINUE:
3917          case DO:
3918          case DOUBLE:
3919          case ENUM:
3920          case FALSE:
3921          case FLOAT:
3922          case FOR:
3923          case IF:
3924          case INT:
3925          case LONG:
3926          case NEW:
3927          case NULL:
3928          case RETURN:
3929          case SHORT:
3930          case SUPER:
3931          case SWITCH:
3932          case SYNCHRONIZED:
3933          case THIS:
3934          case THROW:
3935          case TRUE:
3936          case TRY:
3937          case VOID:
3938          case WHILE:
3939          case INTEGER_LITERAL:
3940          case FLOATING_POINT_LITERAL:
3941          case CHARACTER_LITERAL:
3942          case STRING_LITERAL:
3943          case IDENTIFIER:
3944          case LPAREN:
3945          case LBRACE:
3946          case SEMICOLON:
3947          case INCR:
3948          case DECR:
3949            Statement();
3950            break;
3951          case ABSTRACT:
3952          case CLASS:
3953          case FINAL:
3954          case NATIVE:
3955          case PRIVATE:
3956          case PROTECTED:
3957          case PUBLIC:
3958          case STATIC:
3959          case TESTAAAA:
3960          case TRANSIENT:
3961          case VOLATILE:
3962          case AT:
3963            UnmodifiedClassDeclaration();
3964            break;
3965          case INTERFACE:
3966            UnmodifiedInterfaceDeclaration();
3967            break;
3968          default:
3969            jj_la1[140] = jj_gen;
3970            jj_consume_token(-1);
3971            throw new ParseException();
3972          }
3973        }
3974      }
3975    
3976    /*void LocalVariableDeclaration() :
3977    {}
3978    {
3979      [ "final" ] Type() VariableDeclarator() ( "," VariableDeclarator() )*
3980    }*/
3981      final public void LocalVariableDeclaration() throws ParseException {
3982        Modifiers();
3983        Type();
3984        VariableDeclarator();
3985        label_57:
3986        while (true) {
3987          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3988          case COMMA:
3989            ;
3990            break;
3991          default:
3992            jj_la1[141] = jj_gen;
3993            break label_57;
3994          }
3995          jj_consume_token(COMMA);
3996          VariableDeclarator();
3997        }
3998      }
3999    
4000      final public void EmptyStatement() throws ParseException {
4001        jj_consume_token(SEMICOLON);
4002      }
4003    
4004      final public void StatementExpression() throws ParseException {
4005        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4006        case INCR:
4007          PreIncrementExpression();
4008          break;
4009        case DECR:
4010          PreDecrementExpression();
4011          break;
4012        case ASSERT:
4013        case BOOLEAN:
4014        case BYTE:
4015        case CHAR:
4016        case DOUBLE:
4017        case ENUM:
4018        case FALSE:
4019        case FLOAT:
4020        case INT:
4021        case LONG:
4022        case NEW:
4023        case NULL:
4024        case SHORT:
4025        case SUPER:
4026        case THIS:
4027        case TRUE:
4028        case VOID:
4029        case INTEGER_LITERAL:
4030        case FLOATING_POINT_LITERAL:
4031        case CHARACTER_LITERAL:
4032        case STRING_LITERAL:
4033        case IDENTIFIER:
4034        case LPAREN:
4035          PrimaryExpression();
4036          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4037          case ASSIGN:
4038          case INCR:
4039          case DECR:
4040          case PLUSASSIGN:
4041          case MINUSASSIGN:
4042          case STARASSIGN:
4043          case SLASHASSIGN:
4044          case ANDASSIGN:
4045          case ORASSIGN:
4046          case XORASSIGN:
4047          case REMASSIGN:
4048          case LSHIFTASSIGN:
4049          case RSIGNEDSHIFTASSIGN:
4050          case RUNSIGNEDSHIFTASSIGN:
4051            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4052            case INCR:
4053              jj_consume_token(INCR);
4054              break;
4055            case DECR:
4056              jj_consume_token(DECR);
4057              break;
4058            case ASSIGN:
4059            case PLUSASSIGN:
4060            case MINUSASSIGN:
4061            case STARASSIGN:
4062            case SLASHASSIGN:
4063            case ANDASSIGN:
4064            case ORASSIGN:
4065            case XORASSIGN:
4066            case REMASSIGN:
4067            case LSHIFTASSIGN:
4068            case RSIGNEDSHIFTASSIGN:
4069            case RUNSIGNEDSHIFTASSIGN:
4070              AssignmentOperator();
4071              Expression();
4072              break;
4073            default:
4074              jj_la1[142] = jj_gen;
4075              jj_consume_token(-1);
4076              throw new ParseException();
4077            }
4078            break;
4079          default:
4080            jj_la1[143] = jj_gen;
4081            ;
4082          }
4083          break;
4084        default:
4085          jj_la1[144] = jj_gen;
4086          jj_consume_token(-1);
4087          throw new ParseException();
4088        }
4089      }
4090    
4091      final public void SwitchStatement() throws ParseException {
4092                    _localCases = 0;
4093        jj_consume_token(SWITCH);
4094        jj_consume_token(LPAREN);
4095        Expression();
4096        jj_consume_token(RPAREN);
4097        jj_consume_token(LBRACE);
4098        label_58:
4099        while (true) {
4100          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4101          case CASE:
4102          case _DEFAULT:
4103            ;
4104            break;
4105          default:
4106            jj_la1[145] = jj_gen;
4107            break label_58;
4108          }
4109          SwitchLabel();
4110          label_59:
4111          while (true) {
4112            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4113            case ABSTRACT:
4114            case ASSERT:
4115            case BOOLEAN:
4116            case BREAK:
4117            case BYTE:
4118            case CHAR:
4119            case CLASS:
4120            case CONTINUE:
4121            case DO:
4122            case DOUBLE:
4123            case ENUM:
4124            case FALSE:
4125            case FINAL:
4126            case FLOAT:
4127            case FOR:
4128            case IF:
4129            case INT:
4130            case INTERFACE:
4131            case LONG:
4132            case NATIVE:
4133            case NEW:
4134            case NULL:
4135            case PRIVATE:
4136            case PROTECTED:
4137            case PUBLIC:
4138            case RETURN:
4139            case SHORT:
4140            case STATIC:
4141            case TESTAAAA:
4142            case SUPER:
4143            case SWITCH:
4144            case SYNCHRONIZED:
4145            case THIS:
4146            case THROW:
4147            case TRANSIENT:
4148            case TRUE:
4149            case TRY:
4150            case VOID:
4151            case VOLATILE:
4152            case WHILE:
4153            case INTEGER_LITERAL:
4154            case FLOATING_POINT_LITERAL:
4155            case CHARACTER_LITERAL:
4156            case STRING_LITERAL:
4157            case IDENTIFIER:
4158            case LPAREN:
4159            case LBRACE:
4160            case SEMICOLON:
4161            case AT:
4162            case INCR:
4163            case DECR:
4164              ;
4165              break;
4166            default:
4167              jj_la1[146] = jj_gen;
4168              break label_59;
4169            }
4170            BlockStatement();
4171          }
4172        }
4173        jj_consume_token(RBRACE);
4174              _ncss++;       Util.debug( "_ncss++" );
4175      }
4176    
4177      final public void SwitchLabel() throws ParseException {
4178        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4179        case CASE:
4180          jj_consume_token(CASE);
4181          Expression();
4182          jj_consume_token(COLON);
4183                    _ncss++;
4184                    Util.debug( "_ncss++" );
4185                    _localCases++;
4186                    _cyc++;
4187          break;
4188        case _DEFAULT:
4189          jj_consume_token(_DEFAULT);
4190          jj_consume_token(COLON);
4191                    _ncss++;       Util.debug( "_ncss++" );
4192          break;
4193        default:
4194          jj_la1[147] = jj_gen;
4195          jj_consume_token(-1);
4196          throw new ParseException();
4197        }
4198      }
4199    
4200      final public void IfStatement() throws ParseException {
4201        jj_consume_token(IF);
4202        jj_consume_token(LPAREN);
4203        Expression();
4204        jj_consume_token(RPAREN);
4205        Statement();
4206        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4207        case ELSE:
4208          jj_consume_token(ELSE);
4209                                                                    _ncss++;       Util.debug( "_ncss++" );
4210          Statement();
4211          break;
4212        default:
4213          jj_la1[148] = jj_gen;
4214          ;
4215        }
4216              _ncss++;       Util.debug( "_ncss++" );
4217      }
4218    
4219      final public void WhileStatement() throws ParseException {
4220        jj_consume_token(WHILE);
4221        jj_consume_token(LPAREN);
4222        Expression();
4223        jj_consume_token(RPAREN);
4224        Statement();
4225              _ncss++;       Util.debug( "_ncss++" );
4226      }
4227    
4228      final public void DoStatement() throws ParseException {
4229        jj_consume_token(DO);
4230        Statement();
4231        jj_consume_token(WHILE);
4232        jj_consume_token(LPAREN);
4233        Expression();
4234        jj_consume_token(RPAREN);
4235        jj_consume_token(SEMICOLON);
4236              _ncss++;       Util.debug( "_ncss++" );
4237      }
4238    
4239      final public void ForStatement() throws ParseException {
4240        jj_consume_token(FOR);
4241        jj_consume_token(LPAREN);
4242        if (jj_2_46(2147483647)) {
4243          Modifiers();
4244          Type();
4245          jj_consume_token(IDENTIFIER);
4246          jj_consume_token(COLON);
4247          Expression();
4248        } else {
4249          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4250          case ABSTRACT:
4251          case ASSERT:
4252          case BOOLEAN:
4253          case BYTE:
4254          case CHAR:
4255          case DOUBLE:
4256          case ENUM:
4257          case FALSE:
4258          case FINAL:
4259          case FLOAT:
4260          case INT:
4261          case LONG:
4262          case NATIVE:
4263          case NEW:
4264          case NULL:
4265          case PRIVATE:
4266          case PROTECTED:
4267          case PUBLIC:
4268          case SHORT:
4269          case STATIC:
4270          case TESTAAAA:
4271          case SUPER:
4272          case SYNCHRONIZED:
4273          case THIS:
4274          case TRANSIENT:
4275          case TRUE:
4276          case VOID:
4277          case VOLATILE:
4278          case INTEGER_LITERAL:
4279          case FLOATING_POINT_LITERAL:
4280          case CHARACTER_LITERAL:
4281          case STRING_LITERAL:
4282          case IDENTIFIER:
4283          case LPAREN:
4284          case SEMICOLON:
4285          case AT:
4286          case INCR:
4287          case DECR:
4288            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4289            case ABSTRACT:
4290            case ASSERT:
4291            case BOOLEAN:
4292            case BYTE:
4293            case CHAR:
4294            case DOUBLE:
4295            case ENUM:
4296            case FALSE:
4297            case FINAL:
4298            case FLOAT:
4299            case INT:
4300            case LONG:
4301            case NATIVE:
4302            case NEW:
4303            case NULL:
4304            case PRIVATE:
4305            case PROTECTED:
4306            case PUBLIC:
4307            case SHORT:
4308            case STATIC:
4309            case TESTAAAA:
4310            case SUPER:
4311            case SYNCHRONIZED:
4312            case THIS:
4313            case TRANSIENT:
4314            case TRUE:
4315            case VOID:
4316            case VOLATILE:
4317            case INTEGER_LITERAL:
4318            case FLOATING_POINT_LITERAL:
4319            case CHARACTER_LITERAL:
4320            case STRING_LITERAL:
4321            case IDENTIFIER:
4322            case LPAREN:
4323            case AT:
4324            case INCR:
4325            case DECR:
4326              ForInit();
4327              break;
4328            default:
4329              jj_la1[149] = jj_gen;
4330              ;
4331            }
4332            jj_consume_token(SEMICOLON);
4333            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4334            case ASSERT:
4335            case BOOLEAN:
4336            case BYTE:
4337            case CHAR:
4338            case DOUBLE:
4339            case ENUM:
4340            case FALSE:
4341            case FLOAT:
4342            case INT:
4343            case LONG:
4344            case NEW:
4345            case NULL:
4346            case SHORT:
4347            case SUPER:
4348            case THIS:
4349            case TRUE:
4350            case VOID:
4351            case INTEGER_LITERAL:
4352            case FLOATING_POINT_LITERAL:
4353            case CHARACTER_LITERAL:
4354            case STRING_LITERAL:
4355            case IDENTIFIER:
4356            case LPAREN:
4357            case BANG:
4358            case TILDE:
4359            case INCR:
4360            case DECR:
4361            case PLUS:
4362            case MINUS:
4363              Expression();
4364              break;
4365            default:
4366              jj_la1[150] = jj_gen;
4367              ;
4368            }
4369            jj_consume_token(SEMICOLON);
4370            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4371            case ASSERT:
4372            case BOOLEAN:
4373            case BYTE:
4374            case CHAR:
4375            case DOUBLE:
4376            case ENUM:
4377            case FALSE:
4378            case FLOAT:
4379            case INT:
4380            case LONG:
4381            case NEW:
4382            case NULL:
4383            case SHORT:
4384            case SUPER:
4385            case THIS:
4386            case TRUE:
4387            case VOID:
4388            case INTEGER_LITERAL:
4389            case FLOATING_POINT_LITERAL:
4390            case CHARACTER_LITERAL:
4391            case STRING_LITERAL:
4392            case IDENTIFIER:
4393            case LPAREN:
4394            case INCR:
4395            case DECR:
4396              ForUpdate();
4397              break;
4398            default:
4399              jj_la1[151] = jj_gen;
4400              ;
4401            }
4402            break;
4403          default:
4404            jj_la1[152] = jj_gen;
4405            jj_consume_token(-1);
4406            throw new ParseException();
4407          }
4408        }
4409        jj_consume_token(RPAREN);
4410        Statement();
4411              _ncss++;       Util.debug( "_ncss++" );
4412      }
4413    
4414      final public void ForInit() throws ParseException {
4415        if (jj_2_47(2147483647)) {
4416          LocalVariableDeclaration();
4417        } else {
4418          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4419          case ASSERT:
4420          case BOOLEAN:
4421          case BYTE:
4422          case CHAR:
4423          case DOUBLE:
4424          case ENUM:
4425          case FALSE:
4426          case FLOAT:
4427          case INT:
4428          case LONG:
4429          case NEW:
4430          case NULL:
4431          case SHORT:
4432          case SUPER:
4433          case THIS:
4434          case TRUE:
4435          case VOID:
4436          case INTEGER_LITERAL:
4437          case FLOATING_POINT_LITERAL:
4438          case CHARACTER_LITERAL:
4439          case STRING_LITERAL:
4440          case IDENTIFIER:
4441          case LPAREN:
4442          case INCR:
4443          case DECR:
4444            StatementExpressionList();
4445            break;
4446          default:
4447            jj_la1[153] = jj_gen;
4448            jj_consume_token(-1);
4449            throw new ParseException();
4450          }
4451        }
4452      }
4453    
4454      final public void StatementExpressionList() throws ParseException {
4455        StatementExpression();
4456        label_60:
4457        while (true) {
4458          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4459          case COMMA:
4460            ;
4461            break;
4462          default:
4463            jj_la1[154] = jj_gen;
4464            break label_60;
4465          }
4466          jj_consume_token(COMMA);
4467          StatementExpression();
4468        }
4469      }
4470    
4471      final public void ForUpdate() throws ParseException {
4472        StatementExpressionList();
4473      }
4474    
4475      final public void BreakStatement() throws ParseException {
4476        jj_consume_token(BREAK);
4477        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4478        case ASSERT:
4479        case IDENTIFIER:
4480          Identifier();
4481          break;
4482        default:
4483          jj_la1[155] = jj_gen;
4484          ;
4485        }
4486        jj_consume_token(SEMICOLON);
4487              _ncss++;       Util.debug( "_ncss++" );
4488      }
4489    
4490      final public void ContinueStatement() throws ParseException {
4491        jj_consume_token(CONTINUE);
4492        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4493        case ASSERT:
4494        case IDENTIFIER:
4495          Identifier();
4496          break;
4497        default:
4498          jj_la1[156] = jj_gen;
4499          ;
4500        }
4501        jj_consume_token(SEMICOLON);
4502              _ncss++;       Util.debug( "_ncss++" );
4503      }
4504    
4505      final public void ReturnStatement() throws ParseException {
4506        jj_consume_token(RETURN);
4507        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4508        case ASSERT:
4509        case BOOLEAN:
4510        case BYTE:
4511        case CHAR:
4512        case DOUBLE:
4513        case ENUM:
4514        case FALSE:
4515        case FLOAT:
4516        case INT:
4517        case LONG:
4518        case NEW:
4519        case NULL:
4520        case SHORT:
4521        case SUPER:
4522        case THIS:
4523        case TRUE:
4524        case VOID:
4525        case INTEGER_LITERAL:
4526        case FLOATING_POINT_LITERAL:
4527        case CHARACTER_LITERAL:
4528        case STRING_LITERAL:
4529        case IDENTIFIER:
4530        case LPAREN:
4531        case BANG:
4532        case TILDE:
4533        case INCR:
4534        case DECR:
4535        case PLUS:
4536        case MINUS:
4537          Expression();
4538          break;
4539        default:
4540          jj_la1[157] = jj_gen;
4541          ;
4542        }
4543        jj_consume_token(SEMICOLON);
4544                    _ncss++;
4545                    Util.debug( "_ncss++" );
4546                    _cyc++;
4547                    _bReturn = true;
4548      }
4549    
4550      final public void ThrowStatement() throws ParseException {
4551        jj_consume_token(THROW);
4552        Expression();
4553        jj_consume_token(SEMICOLON);
4554                    _ncss++;
4555                    Util.debug( "_ncss++" );
4556                    _cyc++;
4557      }
4558    
4559      final public void SynchronizedStatement() throws ParseException {
4560        jj_consume_token(SYNCHRONIZED);
4561        jj_consume_token(LPAREN);
4562        Expression();
4563        jj_consume_token(RPAREN);
4564        Block();
4565              _ncss++;       Util.debug( "_ncss++" );
4566      }
4567    
4568      final public void TryStatement() throws ParseException {
4569        jj_consume_token(TRY);
4570        Block();
4571        label_61:
4572        while (true) {
4573          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4574          case CATCH:
4575            ;
4576            break;
4577          default:
4578            jj_la1[158] = jj_gen;
4579            break label_61;
4580          }
4581          jj_consume_token(CATCH);
4582          jj_consume_token(LPAREN);
4583          FormalParameter();
4584          jj_consume_token(RPAREN);
4585          Block();
4586                                                    _ncss++;       Util.debug( "_ncss++" ); _cyc++;
4587        }
4588        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4589        case FINALLY:
4590          jj_consume_token(FINALLY);
4591          Block();
4592                            _ncss++;       Util.debug( "_ncss++" );
4593          break;
4594        default:
4595          jj_la1[159] = jj_gen;
4596          ;
4597        }
4598      }
4599    
4600      final public void Identifier() throws ParseException {
4601        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4602        case IDENTIFIER:
4603          jj_consume_token(IDENTIFIER);
4604          break;
4605        case ASSERT:
4606          jj_consume_token(ASSERT);
4607          break;
4608        default:
4609          jj_la1[160] = jj_gen;
4610          jj_consume_token(-1);
4611          throw new ParseException();
4612        }
4613      }
4614    
4615    /* Annotation syntax follows. */
4616      final public void Annotation() throws ParseException {
4617        if (jj_2_48(2147483647)) {
4618          NormalAnnotation();
4619        } else if (jj_2_49(2147483647)) {
4620          SingleMemberAnnotation();
4621        } else {
4622          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4623          case AT:
4624            MarkerAnnotation();
4625            break;
4626          default:
4627            jj_la1[161] = jj_gen;
4628            jj_consume_token(-1);
4629            throw new ParseException();
4630          }
4631        }
4632      }
4633    
4634      final public void NormalAnnotation() throws ParseException {
4635        jj_consume_token(AT);
4636        Name();
4637        jj_consume_token(LPAREN);
4638        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4639        case IDENTIFIER:
4640          MemberValuePairs();
4641          break;
4642        default:
4643          jj_la1[162] = jj_gen;
4644          ;
4645        }
4646        jj_consume_token(RPAREN);
4647      }
4648    
4649      final public void MarkerAnnotation() throws ParseException {
4650        jj_consume_token(AT);
4651        Name();
4652      }
4653    
4654      final public void SingleMemberAnnotation() throws ParseException {
4655        jj_consume_token(AT);
4656        Name();
4657        jj_consume_token(LPAREN);
4658        MemberValue();
4659        jj_consume_token(RPAREN);
4660      }
4661    
4662      final public void MemberValuePairs() throws ParseException {
4663        MemberValuePair();
4664        label_62:
4665        while (true) {
4666          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4667          case COMMA:
4668            ;
4669            break;
4670          default:
4671            jj_la1[163] = jj_gen;
4672            break label_62;
4673          }
4674          jj_consume_token(COMMA);
4675          MemberValuePair();
4676        }
4677      }
4678    
4679      final public void MemberValuePair() throws ParseException {
4680        jj_consume_token(IDENTIFIER);
4681        jj_consume_token(ASSIGN);
4682        MemberValue();
4683      }
4684    
4685      final public void MemberValue() throws ParseException {
4686        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4687        case AT:
4688          Annotation();
4689          break;
4690        case LBRACE:
4691          MemberValueArrayInitializer();
4692          break;
4693        case ASSERT:
4694        case BOOLEAN:
4695        case BYTE:
4696        case CHAR:
4697        case DOUBLE:
4698        case ENUM:
4699        case FALSE:
4700        case FLOAT:
4701        case INT:
4702        case LONG:
4703        case NEW:
4704        case NULL:
4705        case SHORT:
4706        case SUPER:
4707        case THIS:
4708        case TRUE:
4709        case VOID:
4710        case INTEGER_LITERAL:
4711        case FLOATING_POINT_LITERAL:
4712        case CHARACTER_LITERAL:
4713        case STRING_LITERAL:
4714        case IDENTIFIER:
4715        case LPAREN:
4716        case BANG:
4717        case TILDE:
4718        case INCR:
4719        case DECR:
4720        case PLUS:
4721        case MINUS:
4722          ConditionalExpression();
4723          break;
4724        default:
4725          jj_la1[164] = jj_gen;
4726          jj_consume_token(-1);
4727          throw new ParseException();
4728        }
4729      }
4730    
4731      final public void MemberValueArrayInitializer() throws ParseException {
4732        jj_consume_token(LBRACE);
4733        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4734        case ASSERT:
4735        case BOOLEAN:
4736        case BYTE:
4737        case CHAR:
4738        case DOUBLE:
4739        case ENUM:
4740        case FALSE:
4741        case FLOAT:
4742        case INT:
4743        case LONG:
4744        case NEW:
4745        case NULL:
4746        case SHORT:
4747        case SUPER:
4748        case THIS:
4749        case TRUE:
4750        case VOID:
4751        case INTEGER_LITERAL:
4752        case FLOATING_POINT_LITERAL:
4753        case CHARACTER_LITERAL:
4754        case STRING_LITERAL:
4755        case IDENTIFIER:
4756        case LPAREN:
4757        case LBRACE:
4758        case AT:
4759        case BANG:
4760        case TILDE:
4761        case INCR:
4762        case DECR:
4763        case PLUS:
4764        case MINUS:
4765          MemberValue();
4766          break;
4767        default:
4768          jj_la1[165] = jj_gen;
4769          ;
4770        }
4771        label_63:
4772        while (true) {
4773          if (jj_2_50(2)) {
4774            ;
4775          } else {
4776            break label_63;
4777          }
4778          jj_consume_token(COMMA);
4779          MemberValue();
4780        }
4781        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4782        case COMMA:
4783          jj_consume_token(COMMA);
4784          break;
4785        default:
4786          jj_la1[166] = jj_gen;
4787          ;
4788        }
4789        jj_consume_token(RBRACE);
4790      }
4791    
4792    /*
4793     =================================================
4794     Java 1.5 stuff starts here
4795     =================================================
4796    */
4797    
4798    /* Annotation Types. */
4799    
4800    //Added by REYNAUD Sebastien (LOGICA)
4801      final public void CreationAnnotation() throws ParseException {
4802        jj_consume_token(AT);
4803        jj_consume_token(INTERFACE);
4804        jj_consume_token(IDENTIFIER);
4805        jj_consume_token(LBRACE);
4806        label_64:
4807        while (true) {
4808          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4809          case ABSTRACT:
4810          case BOOLEAN:
4811          case BYTE:
4812          case CHAR:
4813          case CLASS:
4814          case DOUBLE:
4815          case ENUM:
4816          case FINAL:
4817          case FLOAT:
4818          case INT:
4819          case INTERFACE:
4820          case LONG:
4821          case NATIVE:
4822          case PRIVATE:
4823          case PROTECTED:
4824          case PUBLIC:
4825          case SHORT:
4826          case STATIC:
4827          case TESTAAAA:
4828          case SYNCHRONIZED:
4829          case TRANSIENT:
4830          case VOLATILE:
4831          case IDENTIFIER:
4832          case SEMICOLON:
4833          case AT:
4834            ;
4835            break;
4836          default:
4837            jj_la1[167] = jj_gen;
4838            break label_64;
4839          }
4840          AnnotationTypeMemberDeclaration();
4841        }
4842        jj_consume_token(RBRACE);
4843      }
4844    
4845    //
4846      final public void AnnotationTypeDeclaration(int modifiers) throws ParseException {
4847        jj_consume_token(AT);
4848        jj_consume_token(INTERFACE);
4849        jj_consume_token(IDENTIFIER);
4850        AnnotationTypeBody();
4851      }
4852    
4853      final public void AnnotationTypeBody() throws ParseException {
4854        jj_consume_token(LBRACE);
4855           _ncss++;       Util.debug( "_ncss++" );
4856        label_65:
4857        while (true) {
4858          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4859          case ABSTRACT:
4860          case BOOLEAN:
4861          case BYTE:
4862          case CHAR:
4863          case CLASS:
4864          case DOUBLE:
4865          case ENUM:
4866          case FINAL:
4867          case FLOAT:
4868          case INT:
4869          case INTERFACE:
4870          case LONG:
4871          case NATIVE:
4872          case PRIVATE:
4873          case PROTECTED:
4874          case PUBLIC:
4875          case SHORT:
4876          case STATIC:
4877          case TESTAAAA:
4878          case SYNCHRONIZED:
4879          case TRANSIENT:
4880          case VOLATILE:
4881          case IDENTIFIER:
4882          case SEMICOLON:
4883          case AT:
4884            ;
4885            break;
4886          default:
4887            jj_la1[168] = jj_gen;
4888            break label_65;
4889          }
4890          AnnotationTypeMemberDeclaration();
4891        }
4892        jj_consume_token(RBRACE);
4893      }
4894    
4895      final public void AnnotationTypeMemberDeclaration() throws ParseException {
4896       int modifiers;
4897        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4898        case ABSTRACT:
4899        case BOOLEAN:
4900        case BYTE:
4901        case CHAR:
4902        case CLASS:
4903        case DOUBLE:
4904        case ENUM:
4905        case FINAL:
4906        case FLOAT:
4907        case INT:
4908        case INTERFACE:
4909        case LONG:
4910        case NATIVE:
4911        case PRIVATE:
4912        case PROTECTED:
4913        case PUBLIC:
4914        case SHORT:
4915        case STATIC:
4916        case TESTAAAA:
4917        case SYNCHRONIZED:
4918        case TRANSIENT:
4919        case VOLATILE:
4920        case IDENTIFIER:
4921        case AT:
4922          modifiers = Modifiers();
4923          if (jj_2_51(2147483647)) {
4924            Type();
4925            jj_consume_token(IDENTIFIER);
4926            jj_consume_token(LPAREN);
4927            jj_consume_token(RPAREN);
4928            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4929            case _DEFAULT:
4930              DefaultValue();
4931              break;
4932            default:
4933              jj_la1[169] = jj_gen;
4934              ;
4935            }
4936            jj_consume_token(SEMICOLON);
4937                _ncss++;
4938                Util.debug( "_ncss++" );
4939          } else {
4940            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4941            case CLASS:
4942            case INTERFACE:
4943              ClassOrInterfaceDeclaration(modifiers);
4944              break;
4945            case ENUM:
4946              EnumDeclaration(modifiers);
4947              break;
4948            case AT:
4949              AnnotationTypeDeclaration(modifiers);
4950              break;
4951            case BOOLEAN:
4952            case BYTE:
4953            case CHAR:
4954            case DOUBLE:
4955            case FLOAT:
4956            case INT:
4957            case LONG:
4958            case SHORT:
4959            case IDENTIFIER:
4960              FieldDeclaration15(modifiers);
4961              break;
4962            default:
4963              jj_la1[170] = jj_gen;
4964              jj_consume_token(-1);
4965              throw new ParseException();
4966            }
4967          }
4968          break;
4969        case SEMICOLON:
4970          jj_consume_token(SEMICOLON);
4971                _ncss++;
4972                Util.debug( "_ncss++" );
4973          break;
4974        default:
4975          jj_la1[171] = jj_gen;
4976          jj_consume_token(-1);
4977          throw new ParseException();
4978        }
4979      }
4980    
4981      final public void DefaultValue() throws ParseException {
4982        jj_consume_token(_DEFAULT);
4983        MemberValue();
4984      }
4985    
4986    /*
4987     * Modifiers. We match all modifiers in a single rule to reduce the chances of
4988     * syntax errors for simple modifier mistakes. It will also enable us to give
4989     * better error messages.
4990     */
4991      final public int Modifiers() throws ParseException {
4992       int modifiers = 0;
4993       _tmpToken = null;
4994        label_66:
4995        while (true) {
4996          if (jj_2_52(2)) {
4997            ;
4998          } else {
4999            break label_66;
5000          }
5001          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5002          case PUBLIC:
5003            jj_consume_token(PUBLIC);
5004                  modifiers |= ModifierSet.PUBLIC;
5005          if ( _tmpToken == null ) {
5006              _tmpToken = getToken( 0 );
5007          }
5008            break;
5009          case STATIC:
5010            jj_consume_token(STATIC);
5011                  modifiers |= ModifierSet.STATIC;       if ( _tmpToken == null ) {
5012              _tmpToken = getToken( 0 );
5013          }
5014            break;
5015          case PROTECTED:
5016            jj_consume_token(PROTECTED);
5017                     modifiers |= ModifierSet.PROTECTED;       if ( _tmpToken == null ) {
5018           _tmpToken = getToken( 0 );
5019          }
5020            break;
5021          case PRIVATE:
5022            jj_consume_token(PRIVATE);
5023                   modifiers |= ModifierSet.PRIVATE;       if ( _tmpToken == null ) {
5024              _tmpToken = getToken( 0 );
5025          }
5026            break;
5027          case FINAL:
5028            jj_consume_token(FINAL);
5029                 modifiers |= ModifierSet.FINAL;       if ( _tmpToken == null ) {
5030           _tmpToken = getToken( 0 );
5031          }
5032            break;
5033          case ABSTRACT:
5034            jj_consume_token(ABSTRACT);
5035                    modifiers |= ModifierSet.ABSTRACT;       if ( _tmpToken == null ) {
5036              _tmpToken = getToken( 0 );
5037          }
5038            break;
5039          case SYNCHRONIZED:
5040            jj_consume_token(SYNCHRONIZED);
5041                        modifiers |= ModifierSet.SYNCHRONIZED;       if ( _tmpToken == null ) {
5042              _tmpToken = getToken( 0 );
5043          }
5044            break;
5045          case NATIVE:
5046            jj_consume_token(NATIVE);
5047                  modifiers |= ModifierSet.NATIVE;       if ( _tmpToken == null ) {
5048              _tmpToken = getToken( 0 );
5049          }
5050            break;
5051          case TRANSIENT:
5052            jj_consume_token(TRANSIENT);
5053                     modifiers |= ModifierSet.TRANSIENT;       if ( _tmpToken == null ) {
5054              _tmpToken = getToken( 0 );
5055          }
5056            break;
5057          case VOLATILE:
5058            jj_consume_token(VOLATILE);
5059                    modifiers |= ModifierSet.VOLATILE;       if ( _tmpToken == null ) {
5060              _tmpToken = getToken( 0 );
5061          }
5062            break;
5063          case TESTAAAA:
5064            jj_consume_token(TESTAAAA);
5065                    modifiers |= ModifierSet.STRICTFP;       if ( _tmpToken == null ) {
5066              _tmpToken = getToken( 0 );
5067          }
5068            break;
5069          case AT:
5070            Annotation();
5071            break;
5072          default:
5073            jj_la1[172] = jj_gen;
5074            jj_consume_token(-1);
5075            throw new ParseException();
5076          }
5077        }
5078        {if (true) return modifiers;}
5079        throw new Error("Missing return statement in function");
5080      }
5081    
5082      final public void ClassOrInterfaceDeclaration(int modifiers) throws ParseException {
5083       boolean isInterface = false;
5084        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5085        case CLASS:
5086          jj_consume_token(CLASS);
5087          break;
5088        case INTERFACE:
5089          jj_consume_token(INTERFACE);
5090                                isInterface = true;
5091          break;
5092        default:
5093          jj_la1[173] = jj_gen;
5094          jj_consume_token(-1);
5095          throw new ParseException();
5096        }
5097        jj_consume_token(IDENTIFIER);
5098        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5099        case LT:
5100          TypeParameters();
5101          break;
5102        default:
5103          jj_la1[174] = jj_gen;
5104          ;
5105        }
5106        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5107        case EXTENDS:
5108          ExtendsList(isInterface);
5109          break;
5110        default:
5111          jj_la1[175] = jj_gen;
5112          ;
5113        }
5114        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5115        case IMPLEMENTS:
5116          ImplementsList(isInterface);
5117          break;
5118        default:
5119          jj_la1[176] = jj_gen;
5120          ;
5121        }
5122        ClassOrInterfaceBody(isInterface);
5123      }
5124    
5125      final public void EnumDeclaration(int modifiers) throws ParseException {
5126            String sOldClass = _sClass;
5127            int oldClasses = _classes;
5128            int oldNcss = _ncss;
5129            int oldFunctions = _functions;
5130    
5131            // Chris Povirk
5132            int oldSingle;
5133            int oldMulti;
5134          Util.debug( "EnumDeclaration().START" );
5135        jj_consume_token(ENUM);
5136        jj_consume_token(IDENTIFIER);
5137                    if (!_sClass.equals("")) {
5138                            _sClass += ".";
5139                    }
5140                    _sClass += getToken(0).image;
5141                    _classLevel ++;
5142        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5143        case IMPLEMENTS:
5144          ImplementsList(false);
5145          break;
5146        default:
5147          jj_la1[177] = jj_gen;
5148          ;
5149        }
5150            // Chris Povirk
5151          oldSingle = JavaParserTokenManager._iSingleComments;
5152          oldMulti = JavaParserTokenManager._iMultiComments;
5153        EnumBody();
5154                 _classLevel--;
5155                 if (_classLevel == 0) {
5156                     //_topLevelClasses++;
5157                     ObjectMetric metric = new ObjectMetric();
5158                     metric.name = _sPackage + _sClass;
5159                     metric.ncss = _ncss - oldNcss;
5160                     metric.functions = _functions - oldFunctions;
5161                     metric.classes = _classes - oldClasses;
5162                     Token lastToken = getToken( 0 );
5163                     //metric.add( new Integer( lastToken.endLine ) );
5164                     //metric.add( new Integer( lastToken.endColumn ) );
5165                     metric.javadocs = _javadocs;
5166    
5167                     // Chris Povirk
5168                     metric.javadocsLn = _jvdcLines;
5169                     metric.singleLn = JavaParserTokenManager._iSingleComments - oldSingle;
5170                     metric.multiLn = JavaParserTokenManager._iMultiComments - oldMulti;
5171    
5172                     _vClasses.add(metric);
5173                     _pPackageMetric.functions += _functions - oldFunctions;
5174                     _pPackageMetric.classes++;
5175    
5176                     // added by SMS
5177                     _pPackageMetric.javadocs += _javadocs;
5178                     //_pPackageMetric.javadocsLn += JavaParserTokenManager._iFormalComments - oldFormal;
5179                     //_pPackageMetric.singleLn += JavaParserTokenManager._iSingleComments - oldSingle;
5180                     //_pPackageMetric.multiLn += Manager._iMultiComments - oldMulti;
5181                     //
5182                 }
5183                 _functions = oldFunctions;
5184                 _classes = oldClasses + 1;
5185                 _sClass = sOldClass;
5186      }
5187    
5188      final public void TypeParameters() throws ParseException {
5189        jj_consume_token(LT);
5190        TypeParameter();
5191        label_67:
5192        while (true) {
5193          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5194          case COMMA:
5195            ;
5196            break;
5197          default:
5198            jj_la1[178] = jj_gen;
5199            break label_67;
5200          }
5201          jj_consume_token(COMMA);
5202          TypeParameter();
5203        }
5204        jj_consume_token(GT);
5205      }
5206    
5207      final public void ExtendsList(boolean isInterface) throws ParseException {
5208       boolean extendsMoreThanOne = false;
5209        jj_consume_token(EXTENDS);
5210        ClassOrInterfaceType();
5211        label_68:
5212        while (true) {
5213          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5214          case COMMA:
5215            ;
5216            break;
5217          default:
5218            jj_la1[179] = jj_gen;
5219            break label_68;
5220          }
5221          jj_consume_token(COMMA);
5222          ClassOrInterfaceType();
5223                                      extendsMoreThanOne = true;
5224        }
5225          if (extendsMoreThanOne && !isInterface)
5226             {if (true) throw new ParseException("A class cannot extend more than one other class");}
5227      }
5228    
5229      final public void ImplementsList(boolean isInterface) throws ParseException {
5230        jj_consume_token(IMPLEMENTS);
5231        ClassOrInterfaceType();
5232        label_69:
5233        while (true) {
5234          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5235          case COMMA:
5236            ;
5237            break;
5238          default:
5239            jj_la1[180] = jj_gen;
5240            break label_69;
5241          }
5242          jj_consume_token(COMMA);
5243          ClassOrInterfaceType();
5244        }
5245          if (isInterface)
5246             {if (true) throw new ParseException("An interface cannot implement other interfaces");}
5247      }
5248    
5249      final public void ClassOrInterfaceBody(boolean isInterface) throws ParseException {
5250        jj_consume_token(LBRACE);
5251               _ncss++; Util.debug( "ClassOrInterfaceBody()._ncss++" );
5252        label_70:
5253        while (true) {
5254          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5255          case ABSTRACT:
5256          case ASSERT:
5257          case BOOLEAN:
5258          case BYTE:
5259          case CHAR:
5260          case CLASS:
5261          case DOUBLE:
5262          case ENUM:
5263          case FINAL:
5264          case FLOAT:
5265          case INT:
5266          case INTERFACE:
5267          case LONG:
5268          case NATIVE:
5269          case PRIVATE:
5270          case PROTECTED:
5271          case PUBLIC:
5272          case SHORT:
5273          case STATIC:
5274          case TESTAAAA:
5275          case SYNCHRONIZED:
5276          case TRANSIENT:
5277          case VOID:
5278          case VOLATILE:
5279          case IDENTIFIER:
5280          case LBRACE:
5281          case SEMICOLON:
5282          case AT:
5283          case LT:
5284            ;
5285            break;
5286          default:
5287            jj_la1[181] = jj_gen;
5288            break label_70;
5289          }
5290          ClassOrInterfaceBodyDeclaration(isInterface);
5291        }
5292        jj_consume_token(RBRACE);
5293      }
5294    
5295      final public void EnumBody() throws ParseException {
5296        jj_consume_token(LBRACE);
5297                   _ncss++;
5298                   Util.debug( "_ncss++" );
5299        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5300        case ABSTRACT:
5301        case FINAL:
5302        case NATIVE:
5303        case PRIVATE:
5304        case PROTECTED:
5305        case PUBLIC:
5306        case STATIC:
5307        case TESTAAAA:
5308        case SYNCHRONIZED:
5309        case TRANSIENT:
5310        case VOLATILE:
5311        case IDENTIFIER:
5312        case AT:
5313          EnumConstant();
5314          label_71:
5315          while (true) {
5316            if (jj_2_53(2)) {
5317              ;
5318            } else {
5319              break label_71;
5320            }
5321            jj_consume_token(COMMA);
5322            EnumConstant();
5323          }
5324          break;
5325        default:
5326          jj_la1[182] = jj_gen;
5327          ;
5328        }
5329        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5330        case COMMA:
5331          jj_consume_token(COMMA);
5332          break;
5333        default:
5334          jj_la1[183] = jj_gen;
5335          ;
5336        }
5337        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5338        case SEMICOLON:
5339          jj_consume_token(SEMICOLON);
5340          label_72:
5341          while (true) {
5342            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5343            case ABSTRACT:
5344            case ASSERT:
5345            case BOOLEAN:
5346            case BYTE:
5347            case CHAR:
5348            case CLASS:
5349            case DOUBLE:
5350            case ENUM:
5351            case FINAL:
5352            case FLOAT:
5353            case INT:
5354            case INTERFACE:
5355            case LONG:
5356            case NATIVE:
5357            case PRIVATE:
5358            case PROTECTED:
5359            case PUBLIC:
5360            case SHORT:
5361            case STATIC:
5362            case TESTAAAA:
5363            case SYNCHRONIZED:
5364            case TRANSIENT:
5365            case VOID:
5366            case VOLATILE:
5367            case IDENTIFIER:
5368            case LBRACE:
5369            case SEMICOLON:
5370            case AT:
5371            case LT:
5372              ;
5373              break;
5374            default:
5375              jj_la1[184] = jj_gen;
5376              break label_72;
5377            }
5378            ClassOrInterfaceBodyDeclaration(false);
5379          }
5380          break;
5381        default:
5382          jj_la1[185] = jj_gen;
5383          ;
5384        }
5385        jj_consume_token(RBRACE);
5386      }
5387    
5388      final public void TypeParameter() throws ParseException {
5389        jj_consume_token(IDENTIFIER);
5390        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5391        case EXTENDS:
5392          TypeBound();
5393          break;
5394        default:
5395          jj_la1[186] = jj_gen;
5396          ;
5397        }
5398      }
5399    
5400      final public void ClassOrInterfaceType() throws ParseException {
5401        jj_consume_token(IDENTIFIER);
5402                    _sName = getToken(0).image;
5403                    if ( _tmpResultToken == null )
5404                    {
5405                      _tmpResultToken = getToken( 0 );
5406                      Util.debug( "ClassOrInterfaceType._tmpResultToken: " + _tmpResultToken );
5407                    }
5408        if (jj_2_54(4)) {
5409          TypeArguments();
5410        } else {
5411          ;
5412        }
5413        label_73:
5414        while (true) {
5415          if (jj_2_55(2)) {
5416            ;
5417          } else {
5418            break label_73;
5419          }
5420          jj_consume_token(DOT);
5421          jj_consume_token(IDENTIFIER);
5422                    _sName += "." + getToken(0).image;
5423          if (jj_2_56(2)) {
5424            TypeArguments();
5425          } else {
5426            ;
5427          }
5428        }
5429      }
5430    
5431      final public void ClassOrInterfaceBodyDeclaration(boolean isInterface) throws ParseException {
5432       //boolean isNestedInterface = false;
5433       int modifiers;
5434        if (jj_2_59(2)) {
5435          Initializer();
5436         if (isInterface)
5437            {if (true) throw new ParseException("An interface cannot have initializers");}
5438        } else {
5439          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5440          case ABSTRACT:
5441          case ASSERT:
5442          case BOOLEAN:
5443          case BYTE:
5444          case CHAR:
5445          case CLASS:
5446          case DOUBLE:
5447          case ENUM:
5448          case FINAL:
5449          case FLOAT:
5450          case INT:
5451          case INTERFACE:
5452          case LONG:
5453          case NATIVE:
5454          case PRIVATE:
5455          case PROTECTED:
5456          case PUBLIC:
5457          case SHORT:
5458          case STATIC:
5459          case TESTAAAA:
5460          case SYNCHRONIZED:
5461          case TRANSIENT:
5462          case VOID:
5463          case VOLATILE:
5464          case IDENTIFIER:
5465          case AT:
5466          case LT:
5467            modifiers = Modifiers();
5468            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5469            case CLASS:
5470            case INTERFACE:
5471              ClassOrInterfaceDeclaration(modifiers);
5472              break;
5473            case ENUM:
5474              EnumDeclaration(modifiers);
5475              break;
5476            default:
5477              jj_la1[187] = jj_gen;
5478              if (jj_2_57(2147483647)) {
5479                ConstructorDeclaration();
5480              } else if (jj_2_58(2147483647)) {
5481                FieldDeclaration15(modifiers);
5482              } else {
5483                switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5484                case ABSTRACT:
5485                case BOOLEAN:
5486                case BYTE:
5487                case CHAR:
5488                case DOUBLE:
5489                case FINAL:
5490                case FLOAT:
5491                case INT:
5492                case LONG:
5493                case NATIVE:
5494                case PRIVATE:
5495                case PROTECTED:
5496                case PUBLIC:
5497                case SHORT:
5498                case STATIC:
5499                case TESTAAAA:
5500                case SYNCHRONIZED:
5501                case VOID:
5502                case IDENTIFIER:
5503                case AT:
5504                case LT:
5505                  MethodDeclaration15(modifiers);
5506                  break;
5507                default:
5508                  jj_la1[188] = jj_gen;
5509                  jj_consume_token(-1);
5510                  throw new ParseException();
5511                }
5512              }
5513            }
5514            break;
5515          case SEMICOLON:
5516            jj_consume_token(SEMICOLON);
5517            break;
5518          default:
5519            jj_la1[189] = jj_gen;
5520            jj_consume_token(-1);
5521            throw new ParseException();
5522          }
5523        }
5524      }
5525    
5526      final public void EnumConstant() throws ParseException {
5527        Modifiers();
5528        jj_consume_token(IDENTIFIER);
5529        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5530        case LPAREN:
5531          Arguments();
5532          break;
5533        default:
5534          jj_la1[190] = jj_gen;
5535          ;
5536        }
5537        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5538        case LBRACE:
5539          ClassOrInterfaceBody(false);
5540          break;
5541        default:
5542          jj_la1[191] = jj_gen;
5543          ;
5544        }
5545      }
5546    
5547      final public void TypeBound() throws ParseException {
5548        jj_consume_token(EXTENDS);
5549        ClassOrInterfaceType();
5550        label_74:
5551        while (true) {
5552          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5553          case BIT_AND:
5554            ;
5555            break;
5556          default:
5557            jj_la1[192] = jj_gen;
5558            break label_74;
5559          }
5560          jj_consume_token(BIT_AND);
5561          ClassOrInterfaceType();
5562        }
5563      }
5564    
5565      final public void TypeArguments() throws ParseException {
5566        jj_consume_token(LT);
5567        TypeArgument();
5568        label_75:
5569        while (true) {
5570          if (jj_2_60(2)) {
5571            ;
5572          } else {
5573            break label_75;
5574          }
5575          jj_consume_token(COMMA);
5576          TypeArgument();
5577        }
5578        jj_consume_token(GT);
5579      }
5580    
5581      final public void TypeArgument() throws ParseException {
5582        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5583        case BOOLEAN:
5584        case BYTE:
5585        case CHAR:
5586        case DOUBLE:
5587        case FLOAT:
5588        case INT:
5589        case LONG:
5590        case SHORT:
5591        case IDENTIFIER:
5592          ReferenceType();
5593          break;
5594        case HOOK:
5595          jj_consume_token(HOOK);
5596          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5597          case EXTENDS:
5598          case SUPER:
5599            WildcardBounds();
5600            break;
5601          default:
5602            jj_la1[193] = jj_gen;
5603            ;
5604          }
5605          break;
5606        default:
5607          jj_la1[194] = jj_gen;
5608          jj_consume_token(-1);
5609          throw new ParseException();
5610        }
5611      }
5612    
5613      final public void ReferenceType() throws ParseException {
5614        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5615        case BOOLEAN:
5616        case BYTE:
5617        case CHAR:
5618        case DOUBLE:
5619        case FLOAT:
5620        case INT:
5621        case LONG:
5622        case SHORT:
5623          PrimitiveType();
5624          label_76:
5625          while (true) {
5626            jj_consume_token(LBRACKET);
5627            jj_consume_token(RBRACKET);
5628                                                _sName += "[]";
5629            if (jj_2_61(2)) {
5630              ;
5631            } else {
5632              break label_76;
5633            }
5634          }
5635          break;
5636        case IDENTIFIER:
5637          ClassOrInterfaceType();
5638          label_77:
5639          while (true) {
5640            if (jj_2_62(2)) {
5641              ;
5642            } else {
5643              break label_77;
5644            }
5645            jj_consume_token(LBRACKET);
5646            jj_consume_token(RBRACKET);
5647                                                           _sName += "[]";
5648          }
5649          break;
5650        default:
5651          jj_la1[195] = jj_gen;
5652          jj_consume_token(-1);
5653          throw new ParseException();
5654        }
5655      }
5656    
5657      final public void WildcardBounds() throws ParseException {
5658        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5659        case EXTENDS:
5660          jj_consume_token(EXTENDS);
5661          ReferenceType();
5662          break;
5663        case SUPER:
5664          jj_consume_token(SUPER);
5665          ReferenceType();
5666          break;
5667        default:
5668          jj_la1[196] = jj_gen;
5669          jj_consume_token(-1);
5670          throw new ParseException();
5671        }
5672      }
5673    
5674      final public void FieldDeclaration15(int modifiers) throws ParseException {
5675        Type();
5676        VariableDeclarator();
5677        label_78:
5678        while (true) {
5679          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5680          case COMMA:
5681            ;
5682            break;
5683          default:
5684            jj_la1[197] = jj_gen;
5685            break label_78;
5686          }
5687          jj_consume_token(COMMA);
5688          VariableDeclarator();
5689        }
5690        jj_consume_token(SEMICOLON);
5691      }
5692    
5693      final public void MethodDeclaration15(int modifiers) throws ParseException {
5694        MethodDeclaration();
5695      }
5696    
5697      final public void MethodDeclarator15() throws ParseException {
5698        jj_consume_token(IDENTIFIER);
5699        FormalParameters();
5700        label_79:
5701        while (true) {
5702          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5703          case LBRACKET:
5704            ;
5705            break;
5706          default:
5707            jj_la1[198] = jj_gen;
5708            break label_79;
5709          }
5710          jj_consume_token(LBRACKET);
5711          jj_consume_token(RBRACKET);
5712        }
5713      }
5714    
5715      final public void FormalParameters15() throws ParseException {
5716        jj_consume_token(LPAREN);
5717        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5718        case ABSTRACT:
5719        case BOOLEAN:
5720        case BYTE:
5721        case CHAR:
5722        case DOUBLE:
5723        case FINAL:
5724        case FLOAT:
5725        case INT:
5726        case LONG:
5727        case NATIVE:
5728        case PRIVATE:
5729        case PROTECTED:
5730        case PUBLIC:
5731        case SHORT:
5732        case STATIC:
5733        case TESTAAAA:
5734        case SYNCHRONIZED:
5735        case TRANSIENT:
5736        case VOLATILE:
5737        case IDENTIFIER:
5738        case AT:
5739          FormalParameter15();
5740          label_80:
5741          while (true) {
5742            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5743            case COMMA:
5744              ;
5745              break;
5746            default:
5747              jj_la1[199] = jj_gen;
5748              break label_80;
5749            }
5750            jj_consume_token(COMMA);
5751            FormalParameter15();
5752          }
5753          break;
5754        default:
5755          jj_la1[200] = jj_gen;
5756          ;
5757        }
5758        jj_consume_token(RPAREN);
5759      }
5760    
5761      final public void FormalParameter15() throws ParseException {
5762        Modifiers();
5763        Type();
5764        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5765        case ELLIPSIS:
5766          jj_consume_token(ELLIPSIS);
5767          break;
5768        default:
5769          jj_la1[201] = jj_gen;
5770          ;
5771        }
5772        VariableDeclaratorId();
5773      }
5774    
5775      final public void MemberSelector() throws ParseException {
5776        jj_consume_token(DOT);
5777        TypeArguments();
5778        jj_consume_token(IDENTIFIER);
5779      }
5780    
5781      private boolean jj_2_1(int xla) {
5782        jj_la = xla; jj_lastpos = jj_scanpos = token;
5783        try { return !jj_3_1(); }
5784        catch(LookaheadSuccess ls) { return true; }
5785        finally { jj_save(0, xla); }
5786      }
5787    
5788      private boolean jj_2_2(int xla) {
5789        jj_la = xla; jj_lastpos = jj_scanpos = token;
5790        try { return !jj_3_2(); }
5791        catch(LookaheadSuccess ls) { return true; }
5792        finally { jj_save(1, xla); }
5793      }
5794    
5795      private boolean jj_2_3(int xla) {
5796        jj_la = xla; jj_lastpos = jj_scanpos = token;
5797        try { return !jj_3_3(); }
5798        catch(LookaheadSuccess ls) { return true; }
5799        finally { jj_save(2, xla); }
5800      }
5801    
5802      private boolean jj_2_4(int xla) {
5803        jj_la = xla; jj_lastpos = jj_scanpos = token;
5804        try { return !jj_3_4(); }
5805        catch(LookaheadSuccess ls) { return true; }
5806        finally { jj_save(3, xla); }
5807      }
5808    
5809      private boolean jj_2_5(int xla) {
5810        jj_la = xla; jj_lastpos = jj_scanpos = token;
5811        try { return !jj_3_5(); }
5812        catch(LookaheadSuccess ls) { return true; }
5813        finally { jj_save(4, xla); }
5814      }
5815    
5816      private boolean jj_2_6(int xla) {
5817        jj_la = xla; jj_lastpos = jj_scanpos = token;
5818        try { return !jj_3_6(); }
5819        catch(LookaheadSuccess ls) { return true; }
5820        finally { jj_save(5, xla); }
5821      }
5822    
5823      private boolean jj_2_7(int xla) {
5824        jj_la = xla; jj_lastpos = jj_scanpos = token;
5825        try { return !jj_3_7(); }
5826        catch(LookaheadSuccess ls) { return true; }
5827        finally { jj_save(6, xla); }
5828      }
5829    
5830      private boolean jj_2_8(int xla) {
5831        jj_la = xla; jj_lastpos = jj_scanpos = token;
5832        try { return !jj_3_8(); }
5833        catch(LookaheadSuccess ls) { return true; }
5834        finally { jj_save(7, xla); }
5835      }
5836    
5837      private boolean jj_2_9(int xla) {
5838        jj_la = xla; jj_lastpos = jj_scanpos = token;
5839        try { return !jj_3_9(); }
5840        catch(LookaheadSuccess ls) { return true; }
5841        finally { jj_save(8, xla); }
5842      }
5843    
5844      private boolean jj_2_10(int xla) {
5845        jj_la = xla; jj_lastpos = jj_scanpos = token;
5846        try { return !jj_3_10(); }
5847        catch(LookaheadSuccess ls) { return true; }
5848        finally { jj_save(9, xla); }
5849      }
5850    
5851      private boolean jj_2_11(int xla) {
5852        jj_la = xla; jj_lastpos = jj_scanpos = token;
5853        try { return !jj_3_11(); }
5854        catch(LookaheadSuccess ls) { return true; }
5855        finally { jj_save(10, xla); }
5856      }
5857    
5858      private boolean jj_2_12(int xla) {
5859        jj_la = xla; jj_lastpos = jj_scanpos = token;
5860        try { return !jj_3_12(); }
5861        catch(LookaheadSuccess ls) { return true; }
5862        finally { jj_save(11, xla); }
5863      }
5864    
5865      private boolean jj_2_13(int xla) {
5866        jj_la = xla; jj_lastpos = jj_scanpos = token;
5867        try { return !jj_3_13(); }
5868        catch(LookaheadSuccess ls) { return true; }
5869        finally { jj_save(12, xla); }
5870      }
5871    
5872      private boolean jj_2_14(int xla) {
5873        jj_la = xla; jj_lastpos = jj_scanpos = token;
5874        try { return !jj_3_14(); }
5875        catch(LookaheadSuccess ls) { return true; }
5876        finally { jj_save(13, xla); }
5877      }
5878    
5879      private boolean jj_2_15(int xla) {
5880        jj_la = xla; jj_lastpos = jj_scanpos = token;
5881        try { return !jj_3_15(); }
5882        catch(LookaheadSuccess ls) { return true; }
5883        finally { jj_save(14, xla); }
5884      }
5885    
5886      private boolean jj_2_16(int xla) {
5887        jj_la = xla; jj_lastpos = jj_scanpos = token;
5888        try { return !jj_3_16(); }
5889        catch(LookaheadSuccess ls) { return true; }
5890        finally { jj_save(15, xla); }
5891      }
5892    
5893      private boolean jj_2_17(int xla) {
5894        jj_la = xla; jj_lastpos = jj_scanpos = token;
5895        try { return !jj_3_17(); }
5896        catch(LookaheadSuccess ls) { return true; }
5897        finally { jj_save(16, xla); }
5898      }
5899    
5900      private boolean jj_2_18(int xla) {
5901        jj_la = xla; jj_lastpos = jj_scanpos = token;
5902        try { return !jj_3_18(); }
5903        catch(LookaheadSuccess ls) { return true; }
5904        finally { jj_save(17, xla); }
5905      }
5906    
5907      private boolean jj_2_19(int xla) {
5908        jj_la = xla; jj_lastpos = jj_scanpos = token;
5909        try { return !jj_3_19(); }
5910        catch(LookaheadSuccess ls) { return true; }
5911        finally { jj_save(18, xla); }
5912      }
5913    
5914      private boolean jj_2_20(int xla) {
5915        jj_la = xla; jj_lastpos = jj_scanpos = token;
5916        try { return !jj_3_20(); }
5917        catch(LookaheadSuccess ls) { return true; }
5918        finally { jj_save(19, xla); }
5919      }
5920    
5921      private boolean jj_2_21(int xla) {
5922        jj_la = xla; jj_lastpos = jj_scanpos = token;
5923        try { return !jj_3_21(); }
5924        catch(LookaheadSuccess ls) { return true; }
5925        finally { jj_save(20, xla); }
5926      }
5927    
5928      private boolean jj_2_22(int xla) {
5929        jj_la = xla; jj_lastpos = jj_scanpos = token;
5930        try { return !jj_3_22(); }
5931        catch(LookaheadSuccess ls) { return true; }
5932        finally { jj_save(21, xla); }
5933      }
5934    
5935      private boolean jj_2_23(int xla) {
5936        jj_la = xla; jj_lastpos = jj_scanpos = token;
5937        try { return !jj_3_23(); }
5938        catch(LookaheadSuccess ls) { return true; }
5939        finally { jj_save(22, xla); }
5940      }
5941    
5942      private boolean jj_2_24(int xla) {
5943        jj_la = xla; jj_lastpos = jj_scanpos = token;
5944        try { return !jj_3_24(); }
5945        catch(LookaheadSuccess ls) { return true; }
5946        finally { jj_save(23, xla); }
5947      }
5948    
5949      private boolean jj_2_25(int xla) {
5950        jj_la = xla; jj_lastpos = jj_scanpos = token;
5951        try { return !jj_3_25(); }
5952        catch(LookaheadSuccess ls) { return true; }
5953        finally { jj_save(24, xla); }
5954      }
5955    
5956      private boolean jj_2_26(int xla) {
5957        jj_la = xla; jj_lastpos = jj_scanpos = token;
5958        try { return !jj_3_26(); }
5959        catch(LookaheadSuccess ls) { return true; }
5960        finally { jj_save(25, xla); }
5961      }
5962    
5963      private boolean jj_2_27(int xla) {
5964        jj_la = xla; jj_lastpos = jj_scanpos = token;
5965        try { return !jj_3_27(); }
5966        catch(LookaheadSuccess ls) { return true; }
5967        finally { jj_save(26, xla); }
5968      }
5969    
5970      private boolean jj_2_28(int xla) {
5971        jj_la = xla; jj_lastpos = jj_scanpos = token;
5972        try { return !jj_3_28(); }
5973        catch(LookaheadSuccess ls) { return true; }
5974        finally { jj_save(27, xla); }
5975      }
5976    
5977      private boolean jj_2_29(int xla) {
5978        jj_la = xla; jj_lastpos = jj_scanpos = token;
5979        try { return !jj_3_29(); }
5980        catch(LookaheadSuccess ls) { return true; }
5981        finally { jj_save(28, xla); }
5982      }
5983    
5984      private boolean jj_2_30(int xla) {
5985        jj_la = xla; jj_lastpos = jj_scanpos = token;
5986        try { return !jj_3_30(); }
5987        catch(LookaheadSuccess ls) { return true; }
5988        finally { jj_save(29, xla); }
5989      }
5990    
5991      private boolean jj_2_31(int xla) {
5992        jj_la = xla; jj_lastpos = jj_scanpos = token;
5993        try { return !jj_3_31(); }
5994        catch(LookaheadSuccess ls) { return true; }
5995        finally { jj_save(30, xla); }
5996      }
5997    
5998      private boolean jj_2_32(int xla) {
5999        jj_la = xla; jj_lastpos = jj_scanpos = token;
6000        try { return !jj_3_32(); }
6001        catch(LookaheadSuccess ls) { return true; }
6002        finally { jj_save(31, xla); }
6003      }
6004    
6005      private boolean jj_2_33(int xla) {
6006        jj_la = xla; jj_lastpos = jj_scanpos = token;
6007        try { return !jj_3_33(); }
6008        catch(LookaheadSuccess ls) { return true; }
6009        finally { jj_save(32, xla); }
6010      }
6011    
6012      private boolean jj_2_34(int xla) {
6013        jj_la = xla; jj_lastpos = jj_scanpos = token;
6014        try { return !jj_3_34(); }
6015        catch(LookaheadSuccess ls) { return true; }
6016        finally { jj_save(33, xla); }
6017      }
6018    
6019      private boolean jj_2_35(int xla) {
6020        jj_la = xla; jj_lastpos = jj_scanpos = token;
6021        try { return !jj_3_35(); }
6022        catch(LookaheadSuccess ls) { return true; }
6023        finally { jj_save(34, xla); }
6024      }
6025    
6026      private boolean jj_2_36(int xla) {
6027        jj_la = xla; jj_lastpos = jj_scanpos = token;
6028        try { return !jj_3_36(); }
6029        catch(LookaheadSuccess ls) { return true; }
6030        finally { jj_save(35, xla); }
6031      }
6032    
6033      private boolean jj_2_37(int xla) {
6034        jj_la = xla; jj_lastpos = jj_scanpos = token;
6035        try { return !jj_3_37(); }
6036        catch(LookaheadSuccess ls) { return true; }
6037        finally { jj_save(36, xla); }
6038      }
6039    
6040      private boolean jj_2_38(int xla) {
6041        jj_la = xla; jj_lastpos = jj_scanpos = token;
6042        try { return !jj_3_38(); }
6043        catch(LookaheadSuccess ls) { return true; }
6044        finally { jj_save(37, xla); }
6045      }
6046    
6047      private boolean jj_2_39(int xla) {
6048        jj_la = xla; jj_lastpos = jj_scanpos = token;
6049        try { return !jj_3_39(); }
6050        catch(LookaheadSuccess ls) { return true; }
6051        finally { jj_save(38, xla); }
6052      }
6053    
6054      private boolean jj_2_40(int xla) {
6055        jj_la = xla; jj_lastpos = jj_scanpos = token;
6056        try { return !jj_3_40(); }
6057        catch(LookaheadSuccess ls) { return true; }
6058        finally { jj_save(39, xla); }
6059      }
6060    
6061      private boolean jj_2_41(int xla) {
6062        jj_la = xla; jj_lastpos = jj_scanpos = token;
6063        try { return !jj_3_41(); }
6064        catch(LookaheadSuccess ls) { return true; }
6065        finally { jj_save(40, xla); }
6066      }
6067    
6068      private boolean jj_2_42(int xla) {
6069        jj_la = xla; jj_lastpos = jj_scanpos = token;
6070        try { return !jj_3_42(); }
6071        catch(LookaheadSuccess ls) { return true; }
6072        finally { jj_save(41, xla); }
6073      }
6074    
6075      private boolean jj_2_43(int xla) {
6076        jj_la = xla; jj_lastpos = jj_scanpos = token;
6077        try { return !jj_3_43(); }
6078        catch(LookaheadSuccess ls) { return true; }
6079        finally { jj_save(42, xla); }
6080      }
6081    
6082      private boolean jj_2_44(int xla) {
6083        jj_la = xla; jj_lastpos = jj_scanpos = token;
6084        try { return !jj_3_44(); }
6085        catch(LookaheadSuccess ls) { return true; }
6086        finally { jj_save(43, xla); }
6087      }
6088    
6089      private boolean jj_2_45(int xla) {
6090        jj_la = xla; jj_lastpos = jj_scanpos = token;
6091        try { return !jj_3_45(); }
6092        catch(LookaheadSuccess ls) { return true; }
6093        finally { jj_save(44, xla); }
6094      }
6095    
6096      private boolean jj_2_46(int xla) {
6097        jj_la = xla; jj_lastpos = jj_scanpos = token;
6098        try { return !jj_3_46(); }
6099        catch(LookaheadSuccess ls) { return true; }
6100        finally { jj_save(45, xla); }
6101      }
6102    
6103      private boolean jj_2_47(int xla) {
6104        jj_la = xla; jj_lastpos = jj_scanpos = token;
6105        try { return !jj_3_47(); }
6106        catch(LookaheadSuccess ls) { return true; }
6107        finally { jj_save(46, xla); }
6108      }
6109    
6110      private boolean jj_2_48(int xla) {
6111        jj_la = xla; jj_lastpos = jj_scanpos = token;
6112        try { return !jj_3_48(); }
6113        catch(LookaheadSuccess ls) { return true; }
6114        finally { jj_save(47, xla); }
6115      }
6116    
6117      private boolean jj_2_49(int xla) {
6118        jj_la = xla; jj_lastpos = jj_scanpos = token;
6119        try { return !jj_3_49(); }
6120        catch(LookaheadSuccess ls) { return true; }
6121        finally { jj_save(48, xla); }
6122      }
6123    
6124      private boolean jj_2_50(int xla) {
6125        jj_la = xla; jj_lastpos = jj_scanpos = token;
6126        try { return !jj_3_50(); }
6127        catch(LookaheadSuccess ls) { return true; }
6128        finally { jj_save(49, xla); }
6129      }
6130    
6131      private boolean jj_2_51(int xla) {
6132        jj_la = xla; jj_lastpos = jj_scanpos = token;
6133        try { return !jj_3_51(); }
6134        catch(LookaheadSuccess ls) { return true; }
6135        finally { jj_save(50, xla); }
6136      }
6137    
6138      private boolean jj_2_52(int xla) {
6139        jj_la = xla; jj_lastpos = jj_scanpos = token;
6140        try { return !jj_3_52(); }
6141        catch(LookaheadSuccess ls) { return true; }
6142        finally { jj_save(51, xla); }
6143      }
6144    
6145      private boolean jj_2_53(int xla) {
6146        jj_la = xla; jj_lastpos = jj_scanpos = token;
6147        try { return !jj_3_53(); }
6148        catch(LookaheadSuccess ls) { return true; }
6149        finally { jj_save(52, xla); }
6150      }
6151    
6152      private boolean jj_2_54(int xla) {
6153        jj_la = xla; jj_lastpos = jj_scanpos = token;
6154        try { return !jj_3_54(); }
6155        catch(LookaheadSuccess ls) { return true; }
6156        finally { jj_save(53, xla); }
6157      }
6158    
6159      private boolean jj_2_55(int xla) {
6160        jj_la = xla; jj_lastpos = jj_scanpos = token;
6161        try { return !jj_3_55(); }
6162        catch(LookaheadSuccess ls) { return true; }
6163        finally { jj_save(54, xla); }
6164      }
6165    
6166      private boolean jj_2_56(int xla) {
6167        jj_la = xla; jj_lastpos = jj_scanpos = token;
6168        try { return !jj_3_56(); }
6169        catch(LookaheadSuccess ls) { return true; }
6170        finally { jj_save(55, xla); }
6171      }
6172    
6173      private boolean jj_2_57(int xla) {
6174        jj_la = xla; jj_lastpos = jj_scanpos = token;
6175        try { return !jj_3_57(); }
6176        catch(LookaheadSuccess ls) { return true; }
6177        finally { jj_save(56, xla); }
6178      }
6179    
6180      private boolean jj_2_58(int xla) {
6181        jj_la = xla; jj_lastpos = jj_scanpos = token;
6182        try { return !jj_3_58(); }
6183        catch(LookaheadSuccess ls) { return true; }
6184        finally { jj_save(57, xla); }
6185      }
6186    
6187      private boolean jj_2_59(int xla) {
6188        jj_la = xla; jj_lastpos = jj_scanpos = token;
6189        try { return !jj_3_59(); }
6190        catch(LookaheadSuccess ls) { return true; }
6191        finally { jj_save(58, xla); }
6192      }
6193    
6194      private boolean jj_2_60(int xla) {
6195        jj_la = xla; jj_lastpos = jj_scanpos = token;
6196        try { return !jj_3_60(); }
6197        catch(LookaheadSuccess ls) { return true; }
6198        finally { jj_save(59, xla); }
6199      }
6200    
6201      private boolean jj_2_61(int xla) {
6202        jj_la = xla; jj_lastpos = jj_scanpos = token;
6203        try { return !jj_3_61(); }
6204        catch(LookaheadSuccess ls) { return true; }
6205        finally { jj_save(60, xla); }
6206      }
6207    
6208      private boolean jj_2_62(int xla) {
6209        jj_la = xla; jj_lastpos = jj_scanpos = token;
6210        try { return !jj_3_62(); }
6211        catch(LookaheadSuccess ls) { return true; }
6212        finally { jj_save(61, xla); }
6213      }
6214    
6215      private boolean jj_3R_190() {
6216        if (jj_3R_102()) return true;
6217        if (jj_3R_106()) return true;
6218        if (jj_3R_117()) return true;
6219        return false;
6220      }
6221    
6222      private boolean jj_3R_394() {
6223        if (jj_3R_111()) return true;
6224        if (jj_scan_token(IDENTIFIER)) return true;
6225        if (jj_scan_token(LPAREN)) return true;
6226        if (jj_scan_token(RPAREN)) return true;
6227        Token xsp;
6228        xsp = jj_scanpos;
6229        if (jj_3R_410()) jj_scanpos = xsp;
6230        if (jj_scan_token(SEMICOLON)) return true;
6231        return false;
6232      }
6233    
6234      private boolean jj_3R_379() {
6235        if (jj_3R_84()) return true;
6236        Token xsp;
6237        xsp = jj_scanpos;
6238        if (jj_3R_394()) {
6239        jj_scanpos = xsp;
6240        if (jj_3R_395()) {
6241        jj_scanpos = xsp;
6242        if (jj_3R_396()) {
6243        jj_scanpos = xsp;
6244        if (jj_3R_397()) {
6245        jj_scanpos = xsp;
6246        if (jj_3R_398()) return true;
6247        }
6248        }
6249        }
6250        }
6251        return false;
6252      }
6253    
6254      private boolean jj_3R_345() {
6255        Token xsp;
6256        xsp = jj_scanpos;
6257        if (jj_3R_379()) {
6258        jj_scanpos = xsp;
6259        if (jj_3R_380()) return true;
6260        }
6261        return false;
6262      }
6263    
6264      private boolean jj_3R_165() {
6265        if (jj_3R_191()) return true;
6266        return false;
6267      }
6268    
6269      private boolean jj_3R_408() {
6270        if (jj_3R_137()) return true;
6271        return false;
6272      }
6273    
6274      private boolean jj_3R_117() {
6275        Token xsp;
6276        xsp = jj_scanpos;
6277        if (jj_3R_164()) {
6278        jj_scanpos = xsp;
6279        if (jj_3R_165()) return true;
6280        }
6281        return false;
6282      }
6283    
6284      private boolean jj_3R_164() {
6285        if (jj_3R_190()) return true;
6286        return false;
6287      }
6288    
6289      private boolean jj_3R_314() {
6290        if (jj_scan_token(LBRACE)) return true;
6291        Token xsp;
6292        while (true) {
6293          xsp = jj_scanpos;
6294          if (jj_3R_344()) { jj_scanpos = xsp; break; }
6295        }
6296        if (jj_scan_token(RBRACE)) return true;
6297        return false;
6298      }
6299    
6300      private boolean jj_3R_388() {
6301        if (jj_3R_137()) return true;
6302        return false;
6303      }
6304    
6305      private boolean jj_3R_352() {
6306        if (jj_scan_token(PROTECTED)) return true;
6307        return false;
6308      }
6309    
6310      private boolean jj_3R_351() {
6311        if (jj_scan_token(PUBLIC)) return true;
6312        return false;
6313      }
6314    
6315      private boolean jj_3R_321() {
6316        Token xsp;
6317        xsp = jj_scanpos;
6318        if (jj_scan_token(52)) {
6319        jj_scanpos = xsp;
6320        if (jj_scan_token(13)) {
6321        jj_scanpos = xsp;
6322        if (jj_scan_token(31)) {
6323        jj_scanpos = xsp;
6324        if (jj_3R_351()) {
6325        jj_scanpos = xsp;
6326        if (jj_3R_352()) {
6327        jj_scanpos = xsp;
6328        if (jj_scan_token(47)) {
6329        jj_scanpos = xsp;
6330        if (jj_scan_token(53)) return true;
6331        }
6332        }
6333        }
6334        }
6335        }
6336        }
6337        return false;
6338      }
6339    
6340      private boolean jj_3R_303() {
6341        if (jj_scan_token(AT)) return true;
6342        if (jj_scan_token(INTERFACE)) return true;
6343        if (jj_scan_token(IDENTIFIER)) return true;
6344        if (jj_3R_314()) return true;
6345        return false;
6346      }
6347    
6348      private boolean jj_3_50() {
6349        if (jj_scan_token(COMMA)) return true;
6350        if (jj_3R_123()) return true;
6351        return false;
6352      }
6353    
6354      private boolean jj_3R_389() {
6355        if (jj_scan_token(COMMA)) return true;
6356        if (jj_3R_94()) return true;
6357        Token xsp;
6358        xsp = jj_scanpos;
6359        if (jj_3R_408()) jj_scanpos = xsp;
6360        return false;
6361      }
6362    
6363      private boolean jj_3R_104() {
6364        if (jj_3R_105()) return true;
6365        return false;
6366      }
6367    
6368      private boolean jj_3R_363() {
6369        if (jj_3R_94()) return true;
6370        Token xsp;
6371        xsp = jj_scanpos;
6372        if (jj_3R_388()) jj_scanpos = xsp;
6373        while (true) {
6374          xsp = jj_scanpos;
6375          if (jj_3R_389()) { jj_scanpos = xsp; break; }
6376        }
6377        return false;
6378      }
6379    
6380      private boolean jj_3R_320() {
6381        if (jj_3R_141()) return true;
6382        return false;
6383      }
6384    
6385      private boolean jj_3R_304() {
6386        if (jj_scan_token(AT)) return true;
6387        if (jj_scan_token(INTERFACE)) return true;
6388        if (jj_scan_token(IDENTIFIER)) return true;
6389        if (jj_scan_token(LBRACE)) return true;
6390        Token xsp;
6391        while (true) {
6392          xsp = jj_scanpos;
6393          if (jj_3R_315()) { jj_scanpos = xsp; break; }
6394        }
6395        if (jj_scan_token(RBRACE)) return true;
6396        return false;
6397      }
6398    
6399      private boolean jj_3R_319() {
6400        if (jj_3R_141()) return true;
6401        return false;
6402      }
6403    
6404      private boolean jj_3_24() {
6405        if (jj_scan_token(DOT)) return true;
6406        if (jj_3R_105()) return true;
6407        return false;
6408      }
6409    
6410      private boolean jj_3R_306() {
6411        Token xsp;
6412        xsp = jj_scanpos;
6413        if (jj_3R_319()) jj_scanpos = xsp;
6414        while (true) {
6415          xsp = jj_scanpos;
6416          if (jj_3R_320()) { jj_scanpos = xsp; break; }
6417        }
6418        while (true) {
6419          xsp = jj_scanpos;
6420          if (jj_3R_321()) { jj_scanpos = xsp; break; }
6421        }
6422        if (jj_3R_225()) return true;
6423        return false;
6424      }
6425    
6426      private boolean jj_3R_261() {
6427        if (jj_3R_123()) return true;
6428        return false;
6429      }
6430    
6431      private boolean jj_3R_192() {
6432        if (jj_scan_token(LBRACE)) return true;
6433        Token xsp;
6434        xsp = jj_scanpos;
6435        if (jj_3R_261()) jj_scanpos = xsp;
6436        while (true) {
6437          xsp = jj_scanpos;
6438          if (jj_3_50()) { jj_scanpos = xsp; break; }
6439        }
6440        xsp = jj_scanpos;
6441        if (jj_scan_token(84)) jj_scanpos = xsp;
6442        if (jj_scan_token(RBRACE)) return true;
6443        return false;
6444      }
6445    
6446      private boolean jj_3R_240() {
6447        if (jj_scan_token(COMMA)) return true;
6448        if (jj_3R_239()) return true;
6449        return false;
6450      }
6451    
6452      private boolean jj_3R_144() {
6453        if (jj_3R_105()) return true;
6454        return false;
6455      }
6456    
6457      private boolean jj_3_23() {
6458        if (jj_scan_token(DOT)) return true;
6459        Token xsp;
6460        xsp = jj_scanpos;
6461        if (jj_scan_token(28)) {
6462        jj_scanpos = xsp;
6463        if (jj_3R_104()) return true;
6464        }
6465        return false;
6466      }
6467    
6468      private boolean jj_3R_168() {
6469        if (jj_3R_191()) return true;
6470        return false;
6471      }
6472    
6473      private boolean jj_3R_167() {
6474        if (jj_3R_192()) return true;
6475        return false;
6476      }
6477    
6478      private boolean jj_3R_123() {
6479        Token xsp;
6480        xsp = jj_scanpos;
6481        if (jj_3R_166()) {
6482        jj_scanpos = xsp;
6483        if (jj_3R_167()) {
6484        jj_scanpos = xsp;
6485        if (jj_3R_168()) return true;
6486        }
6487        }
6488        return false;
6489      }
6490    
6491      private boolean jj_3R_166() {
6492        if (jj_3R_141()) return true;
6493        return false;
6494      }
6495    
6496      private boolean jj_3R_94() {
6497        Token xsp;
6498        xsp = jj_scanpos;
6499        if (jj_scan_token(28)) {
6500        jj_scanpos = xsp;
6501        if (jj_3R_144()) return true;
6502        }
6503        while (true) {
6504          xsp = jj_scanpos;
6505          if (jj_3_23()) { jj_scanpos = xsp; break; }
6506        }
6507        return false;
6508      }
6509    
6510      private boolean jj_3R_239() {
6511        if (jj_scan_token(IDENTIFIER)) return true;
6512        if (jj_scan_token(ASSIGN)) return true;
6513        if (jj_3R_123()) return true;
6514        return false;
6515      }
6516    
6517      private boolean jj_3R_221() {
6518        if (jj_3R_239()) return true;
6519        Token xsp;
6520        while (true) {
6521          xsp = jj_scanpos;
6522          if (jj_3R_240()) { jj_scanpos = xsp; break; }
6523        }
6524        return false;
6525      }
6526    
6527      private boolean jj_3R_207() {
6528        if (jj_3R_221()) return true;
6529        return false;
6530      }
6531    
6532      private boolean jj_3R_122() {
6533        if (jj_scan_token(IDENTIFIER)) return true;
6534        if (jj_scan_token(ASSIGN)) return true;
6535        return false;
6536      }
6537    
6538      private boolean jj_3R_162() {
6539        if (jj_3R_111()) return true;
6540        return false;
6541      }
6542    
6543      private boolean jj_3R_114() {
6544        Token xsp;
6545        xsp = jj_scanpos;
6546        if (jj_scan_token(63)) {
6547        jj_scanpos = xsp;
6548        if (jj_3R_162()) return true;
6549        }
6550        return false;
6551      }
6552    
6553      private boolean jj_3R_194() {
6554        if (jj_scan_token(AT)) return true;
6555        if (jj_3R_94()) return true;
6556        if (jj_scan_token(LPAREN)) return true;
6557        if (jj_3R_123()) return true;
6558        if (jj_scan_token(RPAREN)) return true;
6559        return false;
6560      }
6561    
6562      private boolean jj_3R_195() {
6563        if (jj_scan_token(AT)) return true;
6564        if (jj_3R_94()) return true;
6565        return false;
6566      }
6567    
6568      private boolean jj_3_49() {
6569        if (jj_scan_token(AT)) return true;
6570        if (jj_3R_94()) return true;
6571        if (jj_scan_token(LPAREN)) return true;
6572        return false;
6573      }
6574    
6575      private boolean jj_3R_193() {
6576        if (jj_scan_token(AT)) return true;
6577        if (jj_3R_94()) return true;
6578        if (jj_scan_token(LPAREN)) return true;
6579        Token xsp;
6580        xsp = jj_scanpos;
6581        if (jj_3R_207()) jj_scanpos = xsp;
6582        if (jj_scan_token(RPAREN)) return true;
6583        return false;
6584      }
6585    
6586      private boolean jj_3_48() {
6587        if (jj_scan_token(AT)) return true;
6588        if (jj_3R_94()) return true;
6589        if (jj_scan_token(LPAREN)) return true;
6590        Token xsp;
6591        xsp = jj_scanpos;
6592        if (jj_3R_122()) {
6593        jj_scanpos = xsp;
6594        if (jj_scan_token(78)) return true;
6595        }
6596        return false;
6597      }
6598    
6599      private boolean jj_3R_173() {
6600        if (jj_3R_195()) return true;
6601        return false;
6602      }
6603    
6604      private boolean jj_3R_110() {
6605        Token xsp;
6606        xsp = jj_scanpos;
6607        if (jj_scan_token(15)) {
6608        jj_scanpos = xsp;
6609        if (jj_scan_token(20)) {
6610        jj_scanpos = xsp;
6611        if (jj_scan_token(17)) {
6612        jj_scanpos = xsp;
6613        if (jj_scan_token(51)) {
6614        jj_scanpos = xsp;
6615        if (jj_scan_token(40)) {
6616        jj_scanpos = xsp;
6617        if (jj_scan_token(42)) {
6618        jj_scanpos = xsp;
6619        if (jj_scan_token(33)) {
6620        jj_scanpos = xsp;
6621        if (jj_scan_token(26)) return true;
6622        }
6623        }
6624        }
6625        }
6626        }
6627        }
6628        }
6629        return false;
6630      }
6631    
6632      private boolean jj_3R_172() {
6633        if (jj_3R_194()) return true;
6634        return false;
6635      }
6636    
6637      private boolean jj_3R_141() {
6638        Token xsp;
6639        xsp = jj_scanpos;
6640        if (jj_3R_171()) {
6641        jj_scanpos = xsp;
6642        if (jj_3R_172()) {
6643        jj_scanpos = xsp;
6644        if (jj_3R_173()) return true;
6645        }
6646        }
6647        return false;
6648      }
6649    
6650      private boolean jj_3R_171() {
6651        if (jj_3R_193()) return true;
6652        return false;
6653      }
6654    
6655      private boolean jj_3R_105() {
6656        Token xsp;
6657        xsp = jj_scanpos;
6658        if (jj_scan_token(74)) {
6659        jj_scanpos = xsp;
6660        if (jj_scan_token(14)) return true;
6661        }
6662        return false;
6663      }
6664    
6665      private boolean jj_3R_439() {
6666        if (jj_scan_token(FINALLY)) return true;
6667        if (jj_3R_142()) return true;
6668        return false;
6669      }
6670    
6671      private boolean jj_3R_93() {
6672        if (jj_3R_143()) return true;
6673        return false;
6674      }
6675    
6676      private boolean jj_3R_438() {
6677        if (jj_scan_token(CATCH)) return true;
6678        if (jj_scan_token(LPAREN)) return true;
6679        if (jj_3R_386()) return true;
6680        if (jj_scan_token(RPAREN)) return true;
6681        if (jj_3R_142()) return true;
6682        return false;
6683      }
6684    
6685      private boolean jj_3R_274() {
6686        if (jj_scan_token(TRY)) return true;
6687        if (jj_3R_142()) return true;
6688        Token xsp;
6689        while (true) {
6690          xsp = jj_scanpos;
6691          if (jj_3R_438()) { jj_scanpos = xsp; break; }
6692        }
6693        xsp = jj_scanpos;
6694        if (jj_3R_439()) jj_scanpos = xsp;
6695        return false;
6696      }
6697    
6698      private boolean jj_3R_158() {
6699        if (jj_3R_110()) return true;
6700        return false;
6701      }
6702    
6703      private boolean jj_3R_111() {
6704        Token xsp;
6705        xsp = jj_scanpos;
6706        if (jj_3_22()) {
6707        jj_scanpos = xsp;
6708        if (jj_3R_158()) return true;
6709        }
6710        return false;
6711      }
6712    
6713      private boolean jj_3_22() {
6714        if (jj_3R_103()) return true;
6715        return false;
6716      }
6717    
6718      private boolean jj_3R_273() {
6719        if (jj_scan_token(SYNCHRONIZED)) return true;
6720        if (jj_scan_token(LPAREN)) return true;
6721        if (jj_3R_117()) return true;
6722        if (jj_scan_token(RPAREN)) return true;
6723        if (jj_3R_142()) return true;
6724        return false;
6725      }
6726    
6727      private boolean jj_3R_85() {
6728        Token xsp;
6729        xsp = jj_scanpos;
6730        if (jj_scan_token(52)) jj_scanpos = xsp;
6731        if (jj_3R_142()) return true;
6732        return false;
6733      }
6734    
6735      private boolean jj_3R_272() {
6736        if (jj_scan_token(THROW)) return true;
6737        if (jj_3R_117()) return true;
6738        if (jj_scan_token(SEMICOLON)) return true;
6739        return false;
6740      }
6741    
6742      private boolean jj_3R_437() {
6743        if (jj_3R_117()) return true;
6744        return false;
6745      }
6746    
6747      private boolean jj_3_20() {
6748        if (jj_3R_102()) return true;
6749        if (jj_scan_token(DOT)) return true;
6750        return false;
6751      }
6752    
6753      private boolean jj_3R_436() {
6754        if (jj_3R_105()) return true;
6755        return false;
6756      }
6757    
6758      private boolean jj_3_21() {
6759        if (jj_scan_token(THIS)) return true;
6760        if (jj_scan_token(LPAREN)) return true;
6761        return false;
6762      }
6763    
6764      private boolean jj_3R_121() {
6765        if (jj_3R_105()) return true;
6766        return false;
6767      }
6768    
6769      private boolean jj_3R_409() {
6770        if (jj_3R_102()) return true;
6771        if (jj_scan_token(DOT)) return true;
6772        return false;
6773      }
6774    
6775      private boolean jj_3R_271() {
6776        if (jj_scan_token(RETURN)) return true;
6777        Token xsp;
6778        xsp = jj_scanpos;
6779        if (jj_3R_437()) jj_scanpos = xsp;
6780        if (jj_scan_token(SEMICOLON)) return true;
6781        return false;
6782      }
6783    
6784      private boolean jj_3R_391() {
6785        Token xsp;
6786        xsp = jj_scanpos;
6787        if (jj_3R_409()) jj_scanpos = xsp;
6788        if (jj_scan_token(SUPER)) return true;
6789        if (jj_3R_189()) return true;
6790        if (jj_scan_token(SEMICOLON)) return true;
6791        return false;
6792      }
6793    
6794      private boolean jj_3R_92() {
6795        Token xsp;
6796        xsp = jj_scanpos;
6797        if (jj_scan_token(49)) {
6798        jj_scanpos = xsp;
6799        if (jj_scan_token(48)) {
6800        jj_scanpos = xsp;
6801        if (jj_scan_token(47)) return true;
6802        }
6803        }
6804        return false;
6805      }
6806    
6807      private boolean jj_3R_455() {
6808        if (jj_scan_token(COMMA)) return true;
6809        if (jj_3R_263()) return true;
6810        return false;
6811      }
6812    
6813      private boolean jj_3R_446() {
6814        if (jj_3R_451()) return true;
6815        return false;
6816      }
6817    
6818      private boolean jj_3R_435() {
6819        if (jj_3R_105()) return true;
6820        return false;
6821      }
6822    
6823      private boolean jj_3R_390() {
6824        if (jj_scan_token(THIS)) return true;
6825        if (jj_3R_189()) return true;
6826        if (jj_scan_token(SEMICOLON)) return true;
6827        return false;
6828      }
6829    
6830      private boolean jj_3R_364() {
6831        Token xsp;
6832        xsp = jj_scanpos;
6833        if (jj_3R_390()) {
6834        jj_scanpos = xsp;
6835        if (jj_3R_391()) return true;
6836        }
6837        return false;
6838      }
6839    
6840      private boolean jj_3R_270() {
6841        if (jj_scan_token(CONTINUE)) return true;
6842        Token xsp;
6843        xsp = jj_scanpos;
6844        if (jj_3R_436()) jj_scanpos = xsp;
6845        if (jj_scan_token(SEMICOLON)) return true;
6846        return false;
6847      }
6848    
6849      private boolean jj_3R_147() {
6850        if (jj_3R_141()) return true;
6851        return false;
6852      }
6853    
6854      private boolean jj_3R_148() {
6855        if (jj_3R_143()) return true;
6856        return false;
6857      }
6858    
6859      private boolean jj_3R_146() {
6860        Token xsp;
6861        xsp = jj_scanpos;
6862        if (jj_scan_token(49)) {
6863        jj_scanpos = xsp;
6864        if (jj_scan_token(48)) {
6865        jj_scanpos = xsp;
6866        if (jj_scan_token(47)) {
6867        jj_scanpos = xsp;
6868        if (jj_scan_token(52)) {
6869        jj_scanpos = xsp;
6870        if (jj_scan_token(13)) {
6871        jj_scanpos = xsp;
6872        if (jj_scan_token(31)) {
6873        jj_scanpos = xsp;
6874        if (jj_scan_token(43)) {
6875        jj_scanpos = xsp;
6876        if (jj_scan_token(56)) {
6877        jj_scanpos = xsp;
6878        if (jj_scan_token(53)) return true;
6879        }
6880        }
6881        }
6882        }
6883        }
6884        }
6885        }
6886        }
6887        return false;
6888      }
6889    
6890      private boolean jj_3R_269() {
6891        if (jj_scan_token(BREAK)) return true;
6892        Token xsp;
6893        xsp = jj_scanpos;
6894        if (jj_3R_435()) jj_scanpos = xsp;
6895        if (jj_scan_token(SEMICOLON)) return true;
6896        return false;
6897      }
6898    
6899      private boolean jj_3R_145() {
6900        if (jj_3R_141()) return true;
6901        return false;
6902      }
6903    
6904      private boolean jj_3R_95() {
6905        Token xsp;
6906        while (true) {
6907          xsp = jj_scanpos;
6908          if (jj_3R_145()) { jj_scanpos = xsp; break; }
6909        }
6910        while (true) {
6911          xsp = jj_scanpos;
6912          if (jj_3R_146()) { jj_scanpos = xsp; break; }
6913        }
6914        while (true) {
6915          xsp = jj_scanpos;
6916          if (jj_3R_147()) { jj_scanpos = xsp; break; }
6917        }
6918        xsp = jj_scanpos;
6919        if (jj_3R_148()) jj_scanpos = xsp;
6920        if (jj_3R_114()) return true;
6921        if (jj_3R_105()) return true;
6922        if (jj_scan_token(LPAREN)) return true;
6923        return false;
6924      }
6925    
6926      private boolean jj_3R_91() {
6927        if (jj_3R_141()) return true;
6928        return false;
6929      }
6930    
6931      private boolean jj_3_11() {
6932        Token xsp;
6933        while (true) {
6934          xsp = jj_scanpos;
6935          if (jj_3R_91()) { jj_scanpos = xsp; break; }
6936        }
6937        xsp = jj_scanpos;
6938        if (jj_3R_92()) jj_scanpos = xsp;
6939        xsp = jj_scanpos;
6940        if (jj_3R_93()) jj_scanpos = xsp;
6941        if (jj_3R_94()) return true;
6942        if (jj_scan_token(LPAREN)) return true;
6943        return false;
6944      }
6945    
6946      private boolean jj_3_12() {
6947        if (jj_3R_95()) return true;
6948        return false;
6949      }
6950    
6951      private boolean jj_3R_451() {
6952        if (jj_3R_454()) return true;
6953        return false;
6954      }
6955    
6956      private boolean jj_3R_90() {
6957        Token xsp;
6958        xsp = jj_scanpos;
6959        if (jj_scan_token(52)) {
6960        jj_scanpos = xsp;
6961        if (jj_scan_token(13)) {
6962        jj_scanpos = xsp;
6963        if (jj_scan_token(31)) {
6964        jj_scanpos = xsp;
6965        if (jj_scan_token(49)) {
6966        jj_scanpos = xsp;
6967        if (jj_scan_token(48)) {
6968        jj_scanpos = xsp;
6969        if (jj_scan_token(47)) {
6970        jj_scanpos = xsp;
6971        if (jj_scan_token(53)) return true;
6972        }
6973        }
6974        }
6975        }
6976        }
6977        }
6978        return false;
6979      }
6980    
6981      private boolean jj_3_47() {
6982        Token xsp;
6983        xsp = jj_scanpos;
6984        if (jj_scan_token(31)) jj_scanpos = xsp;
6985        if (jj_3R_111()) return true;
6986        xsp = jj_scanpos;
6987        if (jj_scan_token(28)) {
6988        jj_scanpos = xsp;
6989        if (jj_3R_121()) return true;
6990        }
6991        return false;
6992      }
6993    
6994      private boolean jj_3R_445() {
6995        if (jj_3R_117()) return true;
6996        return false;
6997      }
6998    
6999      private boolean jj_3R_310() {
7000        if (jj_3R_141()) return true;
7001        return false;
7002      }
7003    
7004      private boolean jj_3R_454() {
7005        if (jj_3R_263()) return true;
7006        Token xsp;
7007        while (true) {
7008          xsp = jj_scanpos;
7009          if (jj_3R_455()) { jj_scanpos = xsp; break; }
7010        }
7011        return false;
7012      }
7013    
7014      private boolean jj_3R_300() {
7015        Token xsp;
7016        while (true) {
7017          xsp = jj_scanpos;
7018          if (jj_3R_310()) { jj_scanpos = xsp; break; }
7019        }
7020        if (jj_3R_311()) return true;
7021        return false;
7022      }
7023    
7024      private boolean jj_3R_432() {
7025        if (jj_scan_token(ELSE)) return true;
7026        if (jj_3R_223()) return true;
7027        return false;
7028      }
7029    
7030      private boolean jj_3R_299() {
7031        if (jj_3R_309()) return true;
7032        return false;
7033      }
7034    
7035      private boolean jj_3R_298() {
7036        if (jj_3R_308()) return true;
7037        return false;
7038      }
7039    
7040      private boolean jj_3_10() {
7041        if (jj_3R_84()) return true;
7042        if (jj_scan_token(ENUM)) return true;
7043        return false;
7044      }
7045    
7046      private boolean jj_3R_453() {
7047        if (jj_3R_454()) return true;
7048        return false;
7049      }
7050    
7051      private boolean jj_3_46() {
7052        if (jj_3R_84()) return true;
7053        if (jj_3R_111()) return true;
7054        if (jj_scan_token(IDENTIFIER)) return true;
7055        if (jj_scan_token(COLON)) return true;
7056        return false;
7057      }
7058    
7059      private boolean jj_3R_87() {
7060        Token xsp;
7061        xsp = jj_scanpos;
7062        if (jj_scan_token(52)) {
7063        jj_scanpos = xsp;
7064        if (jj_scan_token(13)) {
7065        jj_scanpos = xsp;
7066        if (jj_scan_token(31)) {
7067        jj_scanpos = xsp;
7068        if (jj_scan_token(49)) {
7069        jj_scanpos = xsp;
7070        if (jj_scan_token(48)) {
7071        jj_scanpos = xsp;
7072        if (jj_scan_token(47)) {
7073        jj_scanpos = xsp;
7074        if (jj_scan_token(53)) return true;
7075        }
7076        }
7077        }
7078        }
7079        }
7080        }
7081        return false;
7082      }
7083    
7084      private boolean jj_3R_452() {
7085        if (jj_3R_222()) return true;
7086        return false;
7087      }
7088    
7089      private boolean jj_3R_450() {
7090        Token xsp;
7091        xsp = jj_scanpos;
7092        if (jj_3R_452()) {
7093        jj_scanpos = xsp;
7094        if (jj_3R_453()) return true;
7095        }
7096        return false;
7097      }
7098    
7099      private boolean jj_3_9() {
7100        if (jj_3R_84()) return true;
7101        if (jj_scan_token(INTERFACE)) return true;
7102        return false;
7103      }
7104    
7105      private boolean jj_3R_297() {
7106        if (jj_3R_84()) return true;
7107        if (jj_3R_307()) return true;
7108        return false;
7109      }
7110    
7111      private boolean jj_3R_89() {
7112        if (jj_3R_141()) return true;
7113        return false;
7114      }
7115    
7116      private boolean jj_3_8() {
7117        Token xsp;
7118        while (true) {
7119          xsp = jj_scanpos;
7120          if (jj_3R_89()) { jj_scanpos = xsp; break; }
7121        }
7122        while (true) {
7123          xsp = jj_scanpos;
7124          if (jj_3R_90()) { jj_scanpos = xsp; break; }
7125        }
7126        if (jj_scan_token(CLASS)) return true;
7127        return false;
7128      }
7129    
7130      private boolean jj_3R_444() {
7131        if (jj_3R_450()) return true;
7132        return false;
7133      }
7134    
7135      private boolean jj_3R_433() {
7136        if (jj_3R_84()) return true;
7137        if (jj_3R_111()) return true;
7138        if (jj_scan_token(IDENTIFIER)) return true;
7139        if (jj_scan_token(COLON)) return true;
7140        if (jj_3R_117()) return true;
7141        return false;
7142      }
7143    
7144      private boolean jj_3R_350() {
7145        if (jj_scan_token(IMPLEMENTS)) return true;
7146        if (jj_3R_363()) return true;
7147        return false;
7148      }
7149    
7150      private boolean jj_3R_434() {
7151        Token xsp;
7152        xsp = jj_scanpos;
7153        if (jj_3R_444()) jj_scanpos = xsp;
7154        if (jj_scan_token(SEMICOLON)) return true;
7155        xsp = jj_scanpos;
7156        if (jj_3R_445()) jj_scanpos = xsp;
7157        if (jj_scan_token(SEMICOLON)) return true;
7158        xsp = jj_scanpos;
7159        if (jj_3R_446()) jj_scanpos = xsp;
7160        return false;
7161      }
7162    
7163      private boolean jj_3R_296() {
7164        if (jj_3R_84()) return true;
7165        if (jj_3R_306()) return true;
7166        return false;
7167      }
7168    
7169      private boolean jj_3R_88() {
7170        if (jj_3R_141()) return true;
7171        return false;
7172      }
7173    
7174      private boolean jj_3_7() {
7175        Token xsp;
7176        while (true) {
7177          xsp = jj_scanpos;
7178          if (jj_3R_88()) { jj_scanpos = xsp; break; }
7179        }
7180        if (jj_scan_token(AT)) return true;
7181        if (jj_scan_token(INTERFACE)) return true;
7182        return false;
7183      }
7184    
7185      private boolean jj_3R_268() {
7186        if (jj_scan_token(FOR)) return true;
7187        if (jj_scan_token(LPAREN)) return true;
7188        Token xsp;
7189        xsp = jj_scanpos;
7190        if (jj_3R_433()) {
7191        jj_scanpos = xsp;
7192        if (jj_3R_434()) return true;
7193        }
7194        if (jj_scan_token(RPAREN)) return true;
7195        if (jj_3R_223()) return true;
7196        return false;
7197      }
7198    
7199      private boolean jj_3R_86() {
7200        if (jj_3R_141()) return true;
7201        return false;
7202      }
7203    
7204      private boolean jj_3_6() {
7205        Token xsp;
7206        while (true) {
7207          xsp = jj_scanpos;
7208          if (jj_3R_86()) { jj_scanpos = xsp; break; }
7209        }
7210        while (true) {
7211          xsp = jj_scanpos;
7212          if (jj_3R_87()) { jj_scanpos = xsp; break; }
7213        }
7214        if (jj_scan_token(AT)) return true;
7215        if (jj_scan_token(INTERFACE)) return true;
7216        return false;
7217      }
7218    
7219      private boolean jj_3R_295() {
7220        if (jj_3R_305()) return true;
7221        return false;
7222      }
7223    
7224      private boolean jj_3R_331() {
7225        if (jj_3R_196()) return true;
7226        return false;
7227      }
7228    
7229      private boolean jj_3R_267() {
7230        if (jj_scan_token(DO)) return true;
7231        if (jj_3R_223()) return true;
7232        if (jj_scan_token(WHILE)) return true;
7233        if (jj_scan_token(LPAREN)) return true;
7234        if (jj_3R_117()) return true;
7235        if (jj_scan_token(RPAREN)) return true;
7236        if (jj_scan_token(SEMICOLON)) return true;
7237        return false;
7238      }
7239    
7240      private boolean jj_3R_294() {
7241        if (jj_3R_304()) return true;
7242        return false;
7243      }
7244    
7245      private boolean jj_3R_293() {
7246        if (jj_3R_84()) return true;
7247        if (jj_3R_303()) return true;
7248        return false;
7249      }
7250    
7251      private boolean jj_3R_266() {
7252        if (jj_scan_token(WHILE)) return true;
7253        if (jj_scan_token(LPAREN)) return true;
7254        if (jj_3R_117()) return true;
7255        if (jj_scan_token(RPAREN)) return true;
7256        if (jj_3R_223()) return true;
7257        return false;
7258      }
7259    
7260      private boolean jj_3_5() {
7261        if (jj_3R_85()) return true;
7262        return false;
7263      }
7264    
7265      private boolean jj_3R_290() {
7266        Token xsp;
7267        xsp = jj_scanpos;
7268        if (jj_scan_token(83)) {
7269        jj_scanpos = xsp;
7270        if (jj_3_5()) {
7271        jj_scanpos = xsp;
7272        if (jj_3R_293()) {
7273        jj_scanpos = xsp;
7274        if (jj_3R_294()) {
7275        jj_scanpos = xsp;
7276        if (jj_3R_295()) {
7277        jj_scanpos = xsp;
7278        if (jj_3R_296()) {
7279        jj_scanpos = xsp;
7280        if (jj_3R_297()) {
7281        jj_scanpos = xsp;
7282        if (jj_3R_298()) {
7283        jj_scanpos = xsp;
7284        if (jj_3R_299()) {
7285        jj_scanpos = xsp;
7286        if (jj_3R_300()) return true;
7287        }
7288        }
7289        }
7290        }
7291        }
7292        }
7293        }
7294        }
7295        }
7296        return false;
7297      }
7298    
7299      private boolean jj_3R_265() {
7300        if (jj_scan_token(IF)) return true;
7301        if (jj_scan_token(LPAREN)) return true;
7302        if (jj_3R_117()) return true;
7303        if (jj_scan_token(RPAREN)) return true;
7304        if (jj_3R_223()) return true;
7305        Token xsp;
7306        xsp = jj_scanpos;
7307        if (jj_3R_432()) jj_scanpos = xsp;
7308        return false;
7309      }
7310    
7311      private boolean jj_3R_399() {
7312        if (jj_3R_137()) return true;
7313        return false;
7314      }
7315    
7316      private boolean jj_3R_101() {
7317        if (jj_3R_102()) return true;
7318        if (jj_scan_token(DOT)) return true;
7319        return false;
7320      }
7321    
7322      private boolean jj_3R_443() {
7323        if (jj_3R_196()) return true;
7324        return false;
7325      }
7326    
7327      private boolean jj_3_19() {
7328        Token xsp;
7329        xsp = jj_scanpos;
7330        if (jj_3R_101()) jj_scanpos = xsp;
7331        if (jj_scan_token(SUPER)) return true;
7332        if (jj_scan_token(LPAREN)) return true;
7333        return false;
7334      }
7335    
7336      private boolean jj_3_18() {
7337        if (jj_scan_token(THIS)) return true;
7338        if (jj_scan_token(LPAREN)) return true;
7339        return false;
7340      }
7341    
7342      private boolean jj_3R_449() {
7343        if (jj_scan_token(_DEFAULT)) return true;
7344        if (jj_scan_token(COLON)) return true;
7345        return false;
7346      }
7347    
7348      private boolean jj_3R_382() {
7349        if (jj_scan_token(DOT)) return true;
7350        if (jj_3R_94()) return true;
7351        Token xsp;
7352        xsp = jj_scanpos;
7353        if (jj_3R_399()) jj_scanpos = xsp;
7354        return false;
7355      }
7356    
7357      private boolean jj_3R_330() {
7358        if (jj_3R_364()) return true;
7359        return false;
7360      }
7361    
7362      private boolean jj_3R_329() {
7363        if (jj_3R_364()) return true;
7364        return false;
7365      }
7366    
7367      private boolean jj_3R_448() {
7368        if (jj_scan_token(CASE)) return true;
7369        if (jj_3R_117()) return true;
7370        if (jj_scan_token(COLON)) return true;
7371        return false;
7372      }
7373    
7374      private boolean jj_3R_442() {
7375        Token xsp;
7376        xsp = jj_scanpos;
7377        if (jj_3R_448()) {
7378        jj_scanpos = xsp;
7379        if (jj_3R_449()) return true;
7380        }
7381        return false;
7382      }
7383    
7384      private boolean jj_3R_431() {
7385        if (jj_3R_442()) return true;
7386        Token xsp;
7387        while (true) {
7388          xsp = jj_scanpos;
7389          if (jj_3R_443()) { jj_scanpos = xsp; break; }
7390        }
7391        return false;
7392      }
7393    
7394      private boolean jj_3R_120() {
7395        if (jj_scan_token(LBRACKET)) return true;
7396        if (jj_scan_token(RBRACKET)) return true;
7397        return false;
7398      }
7399    
7400      private boolean jj_3R_264() {
7401        if (jj_scan_token(SWITCH)) return true;
7402        if (jj_scan_token(LPAREN)) return true;
7403        if (jj_3R_117()) return true;
7404        if (jj_scan_token(RPAREN)) return true;
7405        if (jj_scan_token(LBRACE)) return true;
7406        Token xsp;
7407        while (true) {
7408          xsp = jj_scanpos;
7409          if (jj_3R_431()) { jj_scanpos = xsp; break; }
7410        }
7411        if (jj_scan_token(RBRACE)) return true;
7412        return false;
7413      }
7414    
7415      private boolean jj_3R_415() {
7416        if (jj_scan_token(COMMA)) return true;
7417        if (jj_3R_341()) return true;
7418        return false;
7419      }
7420    
7421      private boolean jj_3R_328() {
7422        if (jj_scan_token(THROWS)) return true;
7423        if (jj_3R_363()) return true;
7424        return false;
7425      }
7426    
7427      private boolean jj_3R_447() {
7428        if (jj_3R_106()) return true;
7429        if (jj_3R_117()) return true;
7430        return false;
7431      }
7432    
7433      private boolean jj_3R_347() {
7434        if (jj_scan_token(PROTECTED)) return true;
7435        return false;
7436      }
7437    
7438      private boolean jj_3R_346() {
7439        if (jj_scan_token(PUBLIC)) return true;
7440        return false;
7441      }
7442    
7443      private boolean jj_3R_318() {
7444        Token xsp;
7445        xsp = jj_scanpos;
7446        if (jj_scan_token(52)) {
7447        jj_scanpos = xsp;
7448        if (jj_scan_token(13)) {
7449        jj_scanpos = xsp;
7450        if (jj_scan_token(31)) {
7451        jj_scanpos = xsp;
7452        if (jj_3R_346()) {
7453        jj_scanpos = xsp;
7454        if (jj_3R_347()) {
7455        jj_scanpos = xsp;
7456        if (jj_scan_token(47)) {
7457        jj_scanpos = xsp;
7458        if (jj_scan_token(53)) return true;
7459        }
7460        }
7461        }
7462        }
7463        }
7464        }
7465        return false;
7466      }
7467    
7468      private boolean jj_3R_441() {
7469        Token xsp;
7470        xsp = jj_scanpos;
7471        if (jj_scan_token(100)) {
7472        jj_scanpos = xsp;
7473        if (jj_scan_token(101)) {
7474        jj_scanpos = xsp;
7475        if (jj_3R_447()) return true;
7476        }
7477        }
7478        return false;
7479      }
7480    
7481      private boolean jj_3R_326() {
7482        if (jj_3R_143()) return true;
7483        return false;
7484      }
7485    
7486      private boolean jj_3R_317() {
7487        if (jj_3R_141()) return true;
7488        return false;
7489      }
7490    
7491      private boolean jj_3R_285() {
7492        if (jj_3R_102()) return true;
7493        Token xsp;
7494        xsp = jj_scanpos;
7495        if (jj_3R_441()) jj_scanpos = xsp;
7496        return false;
7497      }
7498    
7499      private boolean jj_3R_284() {
7500        if (jj_3R_215()) return true;
7501        return false;
7502      }
7503    
7504      private boolean jj_3R_361() {
7505        if (jj_scan_token(PRIVATE)) return true;
7506        return false;
7507      }
7508    
7509      private boolean jj_3R_263() {
7510        Token xsp;
7511        xsp = jj_scanpos;
7512        if (jj_3R_283()) {
7513        jj_scanpos = xsp;
7514        if (jj_3R_284()) {
7515        jj_scanpos = xsp;
7516        if (jj_3R_285()) return true;
7517        }
7518        }
7519        return false;
7520      }
7521    
7522      private boolean jj_3R_283() {
7523        if (jj_3R_214()) return true;
7524        return false;
7525      }
7526    
7527      private boolean jj_3R_316() {
7528        if (jj_3R_141()) return true;
7529        return false;
7530      }
7531    
7532      private boolean jj_3R_305() {
7533        Token xsp;
7534        xsp = jj_scanpos;
7535        if (jj_3R_316()) jj_scanpos = xsp;
7536        while (true) {
7537          xsp = jj_scanpos;
7538          if (jj_3R_317()) { jj_scanpos = xsp; break; }
7539        }
7540        while (true) {
7541          xsp = jj_scanpos;
7542          if (jj_3R_318()) { jj_scanpos = xsp; break; }
7543        }
7544        if (jj_3R_224()) return true;
7545        return false;
7546      }
7547    
7548      private boolean jj_3R_360() {
7549        if (jj_scan_token(PROTECTED)) return true;
7550        return false;
7551      }
7552    
7553      private boolean jj_3R_359() {
7554        if (jj_scan_token(PUBLIC)) return true;
7555        return false;
7556      }
7557    
7558      private boolean jj_3R_325() {
7559        Token xsp;
7560        xsp = jj_scanpos;
7561        if (jj_3R_359()) {
7562        jj_scanpos = xsp;
7563        if (jj_3R_360()) {
7564        jj_scanpos = xsp;
7565        if (jj_3R_361()) return true;
7566        }
7567        }
7568        return false;
7569      }
7570    
7571      private boolean jj_3R_324() {
7572        if (jj_3R_141()) return true;
7573        return false;
7574      }
7575    
7576      private boolean jj_3R_222() {
7577        if (jj_3R_84()) return true;
7578        if (jj_3R_111()) return true;
7579        if (jj_3R_341()) return true;
7580        Token xsp;
7581        while (true) {
7582          xsp = jj_scanpos;
7583          if (jj_3R_415()) { jj_scanpos = xsp; break; }
7584        }
7585        return false;
7586      }
7587    
7588      private boolean jj_3R_381() {
7589        if (jj_3R_137()) return true;
7590        return false;
7591      }
7592    
7593      private boolean jj_3R_308() {
7594        Token xsp;
7595        while (true) {
7596          xsp = jj_scanpos;
7597          if (jj_3R_324()) { jj_scanpos = xsp; break; }
7598        }
7599        xsp = jj_scanpos;
7600        if (jj_3R_325()) jj_scanpos = xsp;
7601        xsp = jj_scanpos;
7602        if (jj_3R_326()) jj_scanpos = xsp;
7603        if (jj_3R_105()) return true;
7604        if (jj_3R_327()) return true;
7605        xsp = jj_scanpos;
7606        if (jj_3R_328()) jj_scanpos = xsp;
7607        if (jj_scan_token(LBRACE)) return true;
7608        xsp = jj_scanpos;
7609        if (jj_3R_329()) jj_scanpos = xsp;
7610        xsp = jj_scanpos;
7611        if (jj_3R_330()) jj_scanpos = xsp;
7612        while (true) {
7613          xsp = jj_scanpos;
7614          if (jj_3R_331()) { jj_scanpos = xsp; break; }
7615        }
7616        if (jj_scan_token(RBRACE)) return true;
7617        return false;
7618      }
7619    
7620      private boolean jj_3R_287() {
7621        if (jj_3R_290()) return true;
7622        return false;
7623      }
7624    
7625      private boolean jj_3R_276() {
7626        if (jj_scan_token(LBRACE)) return true;
7627        Token xsp;
7628        while (true) {
7629          xsp = jj_scanpos;
7630          if (jj_3R_287()) { jj_scanpos = xsp; break; }
7631        }
7632        if (jj_scan_token(RBRACE)) return true;
7633        return false;
7634      }
7635    
7636      private boolean jj_3_45() {
7637        if (jj_3R_84()) return true;
7638        if (jj_3R_111()) return true;
7639        Token xsp;
7640        xsp = jj_scanpos;
7641        if (jj_scan_token(28)) {
7642        jj_scanpos = xsp;
7643        if (jj_scan_token(74)) return true;
7644        }
7645        xsp = jj_scanpos;
7646        if (jj_scan_token(83)) {
7647        jj_scanpos = xsp;
7648        if (jj_scan_token(87)) {
7649        jj_scanpos = xsp;
7650        if (jj_scan_token(84)) {
7651        jj_scanpos = xsp;
7652        if (jj_3R_120()) return true;
7653        }
7654        }
7655        }
7656        return false;
7657      }
7658    
7659      private boolean jj_3R_211() {
7660        if (jj_3R_225()) return true;
7661        return false;
7662      }
7663    
7664      private boolean jj_3R_210() {
7665        if (jj_3R_224()) return true;
7666        return false;
7667      }
7668    
7669      private boolean jj_3R_209() {
7670        if (jj_3R_223()) return true;
7671        return false;
7672      }
7673    
7674      private boolean jj_3R_349() {
7675        if (jj_scan_token(EXTENDS)) return true;
7676        if (jj_3R_94()) return true;
7677        Token xsp;
7678        xsp = jj_scanpos;
7679        if (jj_3R_381()) jj_scanpos = xsp;
7680        while (true) {
7681          xsp = jj_scanpos;
7682          if (jj_3R_382()) { jj_scanpos = xsp; break; }
7683        }
7684        return false;
7685      }
7686    
7687      private boolean jj_3R_196() {
7688        Token xsp;
7689        xsp = jj_scanpos;
7690        if (jj_3R_208()) {
7691        jj_scanpos = xsp;
7692        if (jj_3R_209()) {
7693        jj_scanpos = xsp;
7694        if (jj_3R_210()) {
7695        jj_scanpos = xsp;
7696        if (jj_3R_211()) return true;
7697        }
7698        }
7699        }
7700        return false;
7701      }
7702    
7703      private boolean jj_3R_208() {
7704        if (jj_3R_222()) return true;
7705        if (jj_scan_token(SEMICOLON)) return true;
7706        return false;
7707      }
7708    
7709      private boolean jj_3R_174() {
7710        if (jj_3R_196()) return true;
7711        return false;
7712      }
7713    
7714      private boolean jj_3R_386() {
7715        if (jj_3R_84()) return true;
7716        if (jj_3R_111()) return true;
7717        Token xsp;
7718        xsp = jj_scanpos;
7719        if (jj_scan_token(122)) jj_scanpos = xsp;
7720        if (jj_3R_377()) return true;
7721        return false;
7722      }
7723    
7724      private boolean jj_3R_142() {
7725        if (jj_scan_token(LBRACE)) return true;
7726        Token xsp;
7727        while (true) {
7728          xsp = jj_scanpos;
7729          if (jj_3R_174()) { jj_scanpos = xsp; break; }
7730        }
7731        if (jj_scan_token(RBRACE)) return true;
7732        return false;
7733      }
7734    
7735      private boolean jj_3R_430() {
7736        if (jj_scan_token(COLON)) return true;
7737        if (jj_3R_117()) return true;
7738        return false;
7739      }
7740    
7741      private boolean jj_3R_348() {
7742        if (jj_3R_143()) return true;
7743        return false;
7744      }
7745    
7746      private boolean jj_3R_362() {
7747        if (jj_3R_386()) return true;
7748        Token xsp;
7749        while (true) {
7750          xsp = jj_scanpos;
7751          if (jj_3R_387()) { jj_scanpos = xsp; break; }
7752        }
7753        return false;
7754      }
7755    
7756      private boolean jj_3R_262() {
7757        if (jj_scan_token(ASSERT)) return true;
7758        if (jj_3R_117()) return true;
7759        Token xsp;
7760        xsp = jj_scanpos;
7761        if (jj_3R_430()) jj_scanpos = xsp;
7762        if (jj_scan_token(SEMICOLON)) return true;
7763        return false;
7764      }
7765    
7766      private boolean jj_3R_387() {
7767        if (jj_scan_token(COMMA)) return true;
7768        if (jj_3R_386()) return true;
7769        return false;
7770      }
7771    
7772      private boolean jj_3R_327() {
7773        if (jj_scan_token(LPAREN)) return true;
7774        Token xsp;
7775        xsp = jj_scanpos;
7776        if (jj_3R_362()) jj_scanpos = xsp;
7777        if (jj_scan_token(RPAREN)) return true;
7778        return false;
7779      }
7780    
7781      private boolean jj_3R_119() {
7782        if (jj_scan_token(ASSERT)) return true;
7783        if (jj_3R_117()) return true;
7784        return false;
7785      }
7786    
7787      private boolean jj_3R_374() {
7788        if (jj_scan_token(LBRACKET)) return true;
7789        if (jj_scan_token(RBRACKET)) return true;
7790        return false;
7791      }
7792    
7793      private boolean jj_3R_336() {
7794        if (jj_3R_105()) return true;
7795        if (jj_3R_327()) return true;
7796        Token xsp;
7797        while (true) {
7798          xsp = jj_scanpos;
7799          if (jj_3R_374()) { jj_scanpos = xsp; break; }
7800        }
7801        return false;
7802      }
7803    
7804      private boolean jj_3R_118() {
7805        if (jj_3R_105()) return true;
7806        if (jj_scan_token(COLON)) return true;
7807        if (jj_3R_223()) return true;
7808        return false;
7809      }
7810    
7811      private boolean jj_3R_224() {
7812        if (jj_3R_84()) return true;
7813        if (jj_scan_token(CLASS)) return true;
7814        if (jj_3R_105()) return true;
7815        Token xsp;
7816        xsp = jj_scanpos;
7817        if (jj_3R_348()) jj_scanpos = xsp;
7818        xsp = jj_scanpos;
7819        if (jj_3R_349()) jj_scanpos = xsp;
7820        xsp = jj_scanpos;
7821        if (jj_3R_350()) jj_scanpos = xsp;
7822        if (jj_3R_276()) return true;
7823        return false;
7824      }
7825    
7826      private boolean jj_3R_254() {
7827        if (jj_3R_274()) return true;
7828        return false;
7829      }
7830    
7831      private boolean jj_3R_253() {
7832        if (jj_3R_273()) return true;
7833        return false;
7834      }
7835    
7836      private boolean jj_3R_252() {
7837        if (jj_3R_272()) return true;
7838        return false;
7839      }
7840    
7841      private boolean jj_3R_251() {
7842        if (jj_3R_271()) return true;
7843        return false;
7844      }
7845    
7846      private boolean jj_3R_250() {
7847        if (jj_3R_270()) return true;
7848        return false;
7849      }
7850    
7851      private boolean jj_3R_249() {
7852        if (jj_3R_269()) return true;
7853        return false;
7854      }
7855    
7856      private boolean jj_3R_248() {
7857        if (jj_3R_268()) return true;
7858        return false;
7859      }
7860    
7861      private boolean jj_3_41() {
7862        if (jj_scan_token(LBRACKET)) return true;
7863        if (jj_scan_token(RBRACKET)) return true;
7864        return false;
7865      }
7866    
7867      private boolean jj_3R_247() {
7868        if (jj_3R_267()) return true;
7869        return false;
7870      }
7871    
7872      private boolean jj_3R_246() {
7873        if (jj_3R_266()) return true;
7874        return false;
7875      }
7876    
7877      private boolean jj_3R_116() {
7878        if (jj_scan_token(DOT)) return true;
7879        if (jj_3R_137()) return true;
7880        if (jj_scan_token(IDENTIFIER)) return true;
7881        return false;
7882      }
7883    
7884      private boolean jj_3R_245() {
7885        if (jj_3R_265()) return true;
7886        return false;
7887      }
7888    
7889      private boolean jj_3R_244() {
7890        if (jj_3R_264()) return true;
7891        return false;
7892      }
7893    
7894      private boolean jj_3_44() {
7895        if (jj_3R_119()) return true;
7896        return false;
7897      }
7898    
7899      private boolean jj_3R_421() {
7900        if (jj_scan_token(COMMA)) return true;
7901        if (jj_3R_341()) return true;
7902        return false;
7903      }
7904    
7905      private boolean jj_3R_243() {
7906        if (jj_3R_263()) return true;
7907        if (jj_scan_token(SEMICOLON)) return true;
7908        return false;
7909      }
7910    
7911      private boolean jj_3R_242() {
7912        if (jj_3R_142()) return true;
7913        return false;
7914      }
7915    
7916      private boolean jj_3R_241() {
7917        if (jj_3R_262()) return true;
7918        return false;
7919      }
7920    
7921      private boolean jj_3_43() {
7922        if (jj_3R_118()) return true;
7923        return false;
7924      }
7925    
7926      private boolean jj_3R_223() {
7927        Token xsp;
7928        xsp = jj_scanpos;
7929        if (jj_3_43()) {
7930        jj_scanpos = xsp;
7931        if (jj_3R_241()) {
7932        jj_scanpos = xsp;
7933        if (jj_3R_242()) {
7934        jj_scanpos = xsp;
7935        if (jj_scan_token(83)) {
7936        jj_scanpos = xsp;
7937        if (jj_3R_243()) {
7938        jj_scanpos = xsp;
7939        if (jj_3R_244()) {
7940        jj_scanpos = xsp;
7941        if (jj_3R_245()) {
7942        jj_scanpos = xsp;
7943        if (jj_3R_246()) {
7944        jj_scanpos = xsp;
7945        if (jj_3R_247()) {
7946        jj_scanpos = xsp;
7947        if (jj_3R_248()) {
7948        jj_scanpos = xsp;
7949        if (jj_3R_249()) {
7950        jj_scanpos = xsp;
7951        if (jj_3R_250()) {
7952        jj_scanpos = xsp;
7953        if (jj_3R_251()) {
7954        jj_scanpos = xsp;
7955        if (jj_3R_252()) {
7956        jj_scanpos = xsp;
7957        if (jj_3R_253()) {
7958        jj_scanpos = xsp;
7959        if (jj_3R_254()) return true;
7960        }
7961        }
7962        }
7963        }
7964        }
7965        }
7966        }
7967        }
7968        }
7969        }
7970        }
7971        }
7972        }
7973        }
7974        }
7975        return false;
7976      }
7977    
7978      private boolean jj_3_62() {
7979        if (jj_scan_token(LBRACKET)) return true;
7980        if (jj_scan_token(RBRACKET)) return true;
7981        return false;
7982      }
7983    
7984      private boolean jj_3R_429() {
7985        if (jj_3R_309()) return true;
7986        return false;
7987      }
7988    
7989      private boolean jj_3R_275() {
7990        if (jj_scan_token(LBRACKET)) return true;
7991        if (jj_scan_token(RBRACKET)) return true;
7992        return false;
7993      }
7994    
7995      private boolean jj_3_40() {
7996        if (jj_scan_token(LBRACKET)) return true;
7997        if (jj_3R_117()) return true;
7998        if (jj_scan_token(RBRACKET)) return true;
7999        return false;
8000      }
8001    
8002      private boolean jj_3R_255() {
8003        Token xsp;
8004        if (jj_3R_275()) return true;
8005        while (true) {
8006          xsp = jj_scanpos;
8007          if (jj_3R_275()) { jj_scanpos = xsp; break; }
8008        }
8009        if (jj_3R_177()) return true;
8010        return false;
8011      }
8012    
8013      private boolean jj_3_42() {
8014        Token xsp;
8015        if (jj_3_40()) return true;
8016        while (true) {
8017          xsp = jj_scanpos;
8018          if (jj_3_40()) { jj_scanpos = xsp; break; }
8019        }
8020        while (true) {
8021          xsp = jj_scanpos;
8022          if (jj_3_41()) { jj_scanpos = xsp; break; }
8023        }
8024        return false;
8025      }
8026    
8027      private boolean jj_3R_228() {
8028        Token xsp;
8029        xsp = jj_scanpos;
8030        if (jj_3_42()) {
8031        jj_scanpos = xsp;
8032        if (jj_3R_255()) return true;
8033        }
8034        return false;
8035      }
8036    
8037      private boolean jj_3_61() {
8038        if (jj_scan_token(LBRACKET)) return true;
8039        if (jj_scan_token(RBRACKET)) return true;
8040        return false;
8041      }
8042    
8043      private boolean jj_3R_412() {
8044        if (jj_3R_111()) return true;
8045        if (jj_3R_341()) return true;
8046        Token xsp;
8047        while (true) {
8048          xsp = jj_scanpos;
8049          if (jj_3R_421()) { jj_scanpos = xsp; break; }
8050        }
8051        if (jj_scan_token(SEMICOLON)) return true;
8052        return false;
8053      }
8054    
8055      private boolean jj_3R_238() {
8056        if (jj_scan_token(SUPER)) return true;
8057        if (jj_3R_103()) return true;
8058        return false;
8059      }
8060    
8061      private boolean jj_3R_220() {
8062        Token xsp;
8063        xsp = jj_scanpos;
8064        if (jj_3R_237()) {
8065        jj_scanpos = xsp;
8066        if (jj_3R_238()) return true;
8067        }
8068        return false;
8069      }
8070    
8071      private boolean jj_3R_237() {
8072        if (jj_scan_token(EXTENDS)) return true;
8073        if (jj_3R_103()) return true;
8074        return false;
8075      }
8076    
8077      private boolean jj_3R_406() {
8078        if (jj_3R_413()) return true;
8079        return false;
8080      }
8081    
8082      private boolean jj_3_60() {
8083        if (jj_scan_token(COMMA)) return true;
8084        if (jj_3R_140()) return true;
8085        return false;
8086      }
8087    
8088      private boolean jj_3R_226() {
8089        if (jj_scan_token(BIT_AND)) return true;
8090        if (jj_3R_184()) return true;
8091        return false;
8092      }
8093    
8094      private boolean jj_3R_153() {
8095        if (jj_3R_184()) return true;
8096        Token xsp;
8097        while (true) {
8098          xsp = jj_scanpos;
8099          if (jj_3_62()) { jj_scanpos = xsp; break; }
8100        }
8101        return false;
8102      }
8103    
8104      private boolean jj_3R_152() {
8105        if (jj_3R_110()) return true;
8106        Token xsp;
8107        if (jj_3_61()) return true;
8108        while (true) {
8109          xsp = jj_scanpos;
8110          if (jj_3_61()) { jj_scanpos = xsp; break; }
8111        }
8112        return false;
8113      }
8114    
8115      private boolean jj_3R_103() {
8116        Token xsp;
8117        xsp = jj_scanpos;
8118        if (jj_3R_152()) {
8119        jj_scanpos = xsp;
8120        if (jj_3R_153()) return true;
8121        }
8122        return false;
8123      }
8124    
8125      private boolean jj_3R_206() {
8126        if (jj_3R_220()) return true;
8127        return false;
8128      }
8129    
8130      private boolean jj_3R_337() {
8131        if (jj_scan_token(THROWS)) return true;
8132        if (jj_3R_363()) return true;
8133        return false;
8134      }
8135    
8136      private boolean jj_3R_170() {
8137        if (jj_scan_token(HOOK)) return true;
8138        Token xsp;
8139        xsp = jj_scanpos;
8140        if (jj_3R_206()) jj_scanpos = xsp;
8141        return false;
8142      }
8143    
8144      private boolean jj_3R_256() {
8145        if (jj_3R_276()) return true;
8146        return false;
8147      }
8148    
8149      private boolean jj_3R_140() {
8150        Token xsp;
8151        xsp = jj_scanpos;
8152        if (jj_3R_169()) {
8153        jj_scanpos = xsp;
8154        if (jj_3R_170()) return true;
8155        }
8156        return false;
8157      }
8158    
8159      private boolean jj_3R_169() {
8160        if (jj_3R_103()) return true;
8161        return false;
8162      }
8163    
8164      private boolean jj_3R_405() {
8165        if (jj_3R_189()) return true;
8166        return false;
8167      }
8168    
8169      private boolean jj_3R_139() {
8170        if (jj_scan_token(LBRACKET)) return true;
8171        if (jj_scan_token(RBRACKET)) return true;
8172        return false;
8173      }
8174    
8175      private boolean jj_3R_137() {
8176        if (jj_scan_token(LT)) return true;
8177        if (jj_3R_140()) return true;
8178        Token xsp;
8179        while (true) {
8180          xsp = jj_scanpos;
8181          if (jj_3_60()) { jj_scanpos = xsp; break; }
8182        }
8183        if (jj_scan_token(GT)) return true;
8184        return false;
8185      }
8186    
8187      private boolean jj_3R_338() {
8188        if (jj_3R_142()) return true;
8189        return false;
8190      }
8191    
8192      private boolean jj_3R_231() {
8193        if (jj_3R_189()) return true;
8194        Token xsp;
8195        xsp = jj_scanpos;
8196        if (jj_3R_256()) jj_scanpos = xsp;
8197        return false;
8198      }
8199    
8200      private boolean jj_3R_230() {
8201        if (jj_3R_228()) return true;
8202        return false;
8203      }
8204    
8205      private boolean jj_3R_163() {
8206        if (jj_scan_token(NEW)) return true;
8207        if (jj_3R_94()) return true;
8208        Token xsp;
8209        xsp = jj_scanpos;
8210        if (jj_3R_229()) jj_scanpos = xsp;
8211        xsp = jj_scanpos;
8212        if (jj_3R_230()) {
8213        jj_scanpos = xsp;
8214        if (jj_3R_231()) return true;
8215        }
8216        return false;
8217      }
8218    
8219      private boolean jj_3R_229() {
8220        if (jj_3R_137()) return true;
8221        return false;
8222      }
8223    
8224      private boolean jj_3R_212() {
8225        if (jj_scan_token(EXTENDS)) return true;
8226        if (jj_3R_184()) return true;
8227        Token xsp;
8228        while (true) {
8229          xsp = jj_scanpos;
8230          if (jj_3R_226()) { jj_scanpos = xsp; break; }
8231        }
8232        return false;
8233      }
8234    
8235      private boolean jj_3_58() {
8236        if (jj_3R_111()) return true;
8237        if (jj_scan_token(IDENTIFIER)) return true;
8238        Token xsp;
8239        while (true) {
8240          xsp = jj_scanpos;
8241          if (jj_3R_139()) { jj_scanpos = xsp; break; }
8242        }
8243        xsp = jj_scanpos;
8244        if (jj_scan_token(84)) {
8245        jj_scanpos = xsp;
8246        if (jj_scan_token(87)) {
8247        jj_scanpos = xsp;
8248        if (jj_scan_token(83)) return true;
8249        }
8250        }
8251        return false;
8252      }
8253    
8254      private boolean jj_3R_138() {
8255        if (jj_3R_143()) return true;
8256        return false;
8257      }
8258    
8259      private boolean jj_3R_115() {
8260        Token xsp;
8261        xsp = jj_scanpos;
8262        if (jj_3_39()) {
8263        jj_scanpos = xsp;
8264        if (jj_3R_163()) return true;
8265        }
8266        return false;
8267      }
8268    
8269      private boolean jj_3_39() {
8270        if (jj_scan_token(NEW)) return true;
8271        if (jj_3R_110()) return true;
8272        if (jj_3R_228()) return true;
8273        return false;
8274      }
8275    
8276      private boolean jj_3R_136() {
8277        if (jj_3R_84()) return true;
8278        if (jj_scan_token(IDENTIFIER)) return true;
8279        Token xsp;
8280        xsp = jj_scanpos;
8281        if (jj_3R_405()) jj_scanpos = xsp;
8282        xsp = jj_scanpos;
8283        if (jj_3R_406()) jj_scanpos = xsp;
8284        return false;
8285      }
8286    
8287      private boolean jj_3_57() {
8288        Token xsp;
8289        xsp = jj_scanpos;
8290        if (jj_3R_138()) jj_scanpos = xsp;
8291        if (jj_scan_token(IDENTIFIER)) return true;
8292        if (jj_scan_token(LPAREN)) return true;
8293        return false;
8294      }
8295    
8296      private boolean jj_3R_277() {
8297        if (jj_scan_token(COMMA)) return true;
8298        if (jj_3R_117()) return true;
8299        return false;
8300      }
8301    
8302      private boolean jj_3R_427() {
8303        if (jj_3R_429()) return true;
8304        return false;
8305      }
8306    
8307      private boolean jj_3R_335() {
8308        if (jj_3R_143()) return true;
8309        return false;
8310      }
8311    
8312      private boolean jj_3R_426() {
8313        if (jj_3R_412()) return true;
8314        return false;
8315      }
8316    
8317      private boolean jj_3R_425() {
8318        if (jj_3R_308()) return true;
8319        return false;
8320      }
8321    
8322      private boolean jj_3R_424() {
8323        if (jj_3R_307()) return true;
8324        return false;
8325      }
8326    
8327      private boolean jj_3R_334() {
8328        if (jj_3R_141()) return true;
8329        return false;
8330      }
8331    
8332      private boolean jj_3R_423() {
8333        if (jj_3R_411()) return true;
8334        return false;
8335      }
8336    
8337      private boolean jj_3R_217() {
8338        if (jj_3R_117()) return true;
8339        Token xsp;
8340        while (true) {
8341          xsp = jj_scanpos;
8342          if (jj_3R_277()) { jj_scanpos = xsp; break; }
8343        }
8344        return false;
8345      }
8346    
8347      private boolean jj_3R_204() {
8348        if (jj_3R_217()) return true;
8349        return false;
8350      }
8351    
8352      private boolean jj_3R_414() {
8353        if (jj_3R_84()) return true;
8354        Token xsp;
8355        xsp = jj_scanpos;
8356        if (jj_3R_423()) {
8357        jj_scanpos = xsp;
8358        if (jj_3R_424()) {
8359        jj_scanpos = xsp;
8360        if (jj_3R_425()) {
8361        jj_scanpos = xsp;
8362        if (jj_3R_426()) {
8363        jj_scanpos = xsp;
8364        if (jj_3R_427()) return true;
8365        }
8366        }
8367        }
8368        }
8369        return false;
8370      }
8371    
8372      private boolean jj_3_4() {
8373        if (jj_3R_84()) return true;
8374        if (jj_scan_token(INTERFACE)) return true;
8375        return false;
8376      }
8377    
8378      private boolean jj_3R_189() {
8379        if (jj_scan_token(LPAREN)) return true;
8380        Token xsp;
8381        xsp = jj_scanpos;
8382        if (jj_3R_204()) jj_scanpos = xsp;
8383        if (jj_scan_token(RPAREN)) return true;
8384        return false;
8385      }
8386    
8387      private boolean jj_3R_373() {
8388        if (jj_scan_token(TESTAAAA)) return true;
8389        return false;
8390      }
8391    
8392      private boolean jj_3R_83() {
8393        Token xsp;
8394        xsp = jj_scanpos;
8395        if (jj_scan_token(13)) {
8396        jj_scanpos = xsp;
8397        if (jj_scan_token(31)) {
8398        jj_scanpos = xsp;
8399        if (jj_scan_token(49)) {
8400        jj_scanpos = xsp;
8401        if (jj_scan_token(56)) {
8402        jj_scanpos = xsp;
8403        if (jj_scan_token(53)) return true;
8404        }
8405        }
8406        }
8407        }
8408        return false;
8409      }
8410    
8411      private boolean jj_3R_407() {
8412        Token xsp;
8413        xsp = jj_scanpos;
8414        if (jj_3_59()) {
8415        jj_scanpos = xsp;
8416        if (jj_3R_414()) {
8417        jj_scanpos = xsp;
8418        if (jj_scan_token(83)) return true;
8419        }
8420        }
8421        return false;
8422      }
8423    
8424      private boolean jj_3_59() {
8425        if (jj_3R_85()) return true;
8426        return false;
8427      }
8428    
8429      private boolean jj_3R_372() {
8430        if (jj_scan_token(SYNCHRONIZED)) return true;
8431        return false;
8432      }
8433    
8434      private boolean jj_3R_371() {
8435        if (jj_scan_token(NATIVE)) return true;
8436        return false;
8437      }
8438    
8439      private boolean jj_3_3() {
8440        if (jj_3R_84()) return true;
8441        if (jj_scan_token(ENUM)) return true;
8442        if (jj_scan_token(IDENTIFIER)) return true;
8443        return false;
8444      }
8445    
8446      private boolean jj_3_56() {
8447        if (jj_3R_137()) return true;
8448        return false;
8449      }
8450    
8451      private boolean jj_3R_227() {
8452        Token xsp;
8453        xsp = jj_scanpos;
8454        if (jj_scan_token(61)) {
8455        jj_scanpos = xsp;
8456        if (jj_scan_token(30)) return true;
8457        }
8458        return false;
8459      }
8460    
8461      private boolean jj_3_55() {
8462        if (jj_scan_token(DOT)) return true;
8463        if (jj_scan_token(IDENTIFIER)) return true;
8464        Token xsp;
8465        xsp = jj_scanpos;
8466        if (jj_3_56()) jj_scanpos = xsp;
8467        return false;
8468      }
8469    
8470      private boolean jj_3R_197() {
8471        if (jj_3R_212()) return true;
8472        return false;
8473      }
8474    
8475      private boolean jj_3R_82() {
8476        if (jj_3R_141()) return true;
8477        return false;
8478      }
8479    
8480      private boolean jj_3R_370() {
8481        if (jj_scan_token(FINAL)) return true;
8482        return false;
8483      }
8484    
8485      private boolean jj_3_2() {
8486        Token xsp;
8487        while (true) {
8488          xsp = jj_scanpos;
8489          if (jj_3R_82()) { jj_scanpos = xsp; break; }
8490        }
8491        while (true) {
8492          xsp = jj_scanpos;
8493          if (jj_3R_83()) { jj_scanpos = xsp; break; }
8494        }
8495        if (jj_scan_token(CLASS)) return true;
8496        return false;
8497      }
8498    
8499      private boolean jj_3_54() {
8500        if (jj_3R_137()) return true;
8501        return false;
8502      }
8503    
8504      private boolean jj_3_53() {
8505        if (jj_scan_token(COMMA)) return true;
8506        if (jj_3R_136()) return true;
8507        return false;
8508      }
8509    
8510      private boolean jj_3R_213() {
8511        if (jj_3R_227()) return true;
8512        return false;
8513      }
8514    
8515      private boolean jj_3R_369() {
8516        if (jj_scan_token(ABSTRACT)) return true;
8517        return false;
8518      }
8519    
8520      private boolean jj_3R_184() {
8521        if (jj_scan_token(IDENTIFIER)) return true;
8522        Token xsp;
8523        xsp = jj_scanpos;
8524        if (jj_3_54()) jj_scanpos = xsp;
8525        while (true) {
8526          xsp = jj_scanpos;
8527          if (jj_3_55()) { jj_scanpos = xsp; break; }
8528        }
8529        return false;
8530      }
8531    
8532      private boolean jj_3R_368() {
8533        if (jj_scan_token(STATIC)) return true;
8534        return false;
8535      }
8536    
8537      private boolean jj_3R_385() {
8538        if (jj_3R_407()) return true;
8539        return false;
8540      }
8541    
8542      private boolean jj_3R_198() {
8543        Token xsp;
8544        xsp = jj_scanpos;
8545        if (jj_scan_token(66)) {
8546        jj_scanpos = xsp;
8547        if (jj_scan_token(70)) {
8548        jj_scanpos = xsp;
8549        if (jj_scan_token(72)) {
8550        jj_scanpos = xsp;
8551        if (jj_scan_token(73)) {
8552        jj_scanpos = xsp;
8553        if (jj_3R_213()) {
8554        jj_scanpos = xsp;
8555        if (jj_scan_token(45)) return true;
8556        }
8557        }
8558        }
8559        }
8560        }
8561        return false;
8562      }
8563    
8564      private boolean jj_3R_175() {
8565        if (jj_scan_token(IDENTIFIER)) return true;
8566        Token xsp;
8567        xsp = jj_scanpos;
8568        if (jj_3R_197()) jj_scanpos = xsp;
8569        return false;
8570      }
8571    
8572      private boolean jj_3R_367() {
8573        if (jj_scan_token(PRIVATE)) return true;
8574        return false;
8575      }
8576    
8577      private boolean jj_3R_358() {
8578        if (jj_scan_token(SEMICOLON)) return true;
8579        Token xsp;
8580        while (true) {
8581          xsp = jj_scanpos;
8582          if (jj_3R_385()) { jj_scanpos = xsp; break; }
8583        }
8584        return false;
8585      }
8586    
8587      private boolean jj_3R_366() {
8588        if (jj_scan_token(PROTECTED)) return true;
8589        return false;
8590      }
8591    
8592      private boolean jj_3R_161() {
8593        if (jj_3R_189()) return true;
8594        return false;
8595      }
8596    
8597      private boolean jj_3R_357() {
8598        if (jj_3R_136()) return true;
8599        Token xsp;
8600        while (true) {
8601          xsp = jj_scanpos;
8602          if (jj_3_53()) { jj_scanpos = xsp; break; }
8603        }
8604        return false;
8605      }
8606    
8607      private boolean jj_3R_160() {
8608        if (jj_scan_token(DOT)) return true;
8609        if (jj_3R_105()) return true;
8610        return false;
8611      }
8612    
8613      private boolean jj_3R_159() {
8614        if (jj_scan_token(LBRACKET)) return true;
8615        if (jj_3R_117()) return true;
8616        if (jj_scan_token(RBRACKET)) return true;
8617        return false;
8618      }
8619    
8620      private boolean jj_3R_365() {
8621        if (jj_scan_token(PUBLIC)) return true;
8622        return false;
8623      }
8624    
8625      private boolean jj_3R_333() {
8626        Token xsp;
8627        xsp = jj_scanpos;
8628        if (jj_3R_365()) {
8629        jj_scanpos = xsp;
8630        if (jj_3R_366()) {
8631        jj_scanpos = xsp;
8632        if (jj_3R_367()) {
8633        jj_scanpos = xsp;
8634        if (jj_3R_368()) {
8635        jj_scanpos = xsp;
8636        if (jj_3R_369()) {
8637        jj_scanpos = xsp;
8638        if (jj_3R_370()) {
8639        jj_scanpos = xsp;
8640        if (jj_3R_371()) {
8641        jj_scanpos = xsp;
8642        if (jj_3R_372()) {
8643        jj_scanpos = xsp;
8644        if (jj_3R_373()) return true;
8645        }
8646        }
8647        }
8648        }
8649        }
8650        }
8651        }
8652        }
8653        return false;
8654      }
8655    
8656      private boolean jj_3R_323() {
8657        if (jj_scan_token(LBRACE)) return true;
8658        Token xsp;
8659        xsp = jj_scanpos;
8660        if (jj_3R_357()) jj_scanpos = xsp;
8661        xsp = jj_scanpos;
8662        if (jj_scan_token(84)) jj_scanpos = xsp;
8663        xsp = jj_scanpos;
8664        if (jj_3R_358()) jj_scanpos = xsp;
8665        if (jj_scan_token(RBRACE)) return true;
8666        return false;
8667      }
8668    
8669      private boolean jj_3_38() {
8670        if (jj_3R_116()) return true;
8671        return false;
8672      }
8673    
8674      private boolean jj_3_33() {
8675        if (jj_scan_token(DOT)) return true;
8676        if (jj_scan_token(SUPER)) return true;
8677        if (jj_scan_token(DOT)) return true;
8678        if (jj_3R_105()) return true;
8679        return false;
8680      }
8681    
8682      private boolean jj_3_37() {
8683        if (jj_scan_token(DOT)) return true;
8684        if (jj_3R_115()) return true;
8685        return false;
8686      }
8687    
8688      private boolean jj_3R_112() {
8689        Token xsp;
8690        xsp = jj_scanpos;
8691        if (jj_3_36()) {
8692        jj_scanpos = xsp;
8693        if (jj_3_37()) {
8694        jj_scanpos = xsp;
8695        if (jj_3_38()) {
8696        jj_scanpos = xsp;
8697        if (jj_3R_159()) {
8698        jj_scanpos = xsp;
8699        if (jj_3R_160()) {
8700        jj_scanpos = xsp;
8701        if (jj_3R_161()) return true;
8702        }
8703        }
8704        }
8705        }
8706        }
8707        return false;
8708      }
8709    
8710      private boolean jj_3_36() {
8711        if (jj_scan_token(DOT)) return true;
8712        if (jj_scan_token(THIS)) return true;
8713        return false;
8714      }
8715    
8716      private boolean jj_3R_422() {
8717        if (jj_3R_407()) return true;
8718        return false;
8719      }
8720    
8721      private boolean jj_3R_413() {
8722        if (jj_scan_token(LBRACE)) return true;
8723        Token xsp;
8724        while (true) {
8725          xsp = jj_scanpos;
8726          if (jj_3R_422()) { jj_scanpos = xsp; break; }
8727        }
8728        if (jj_scan_token(RBRACE)) return true;
8729        return false;
8730      }
8731    
8732      private boolean jj_3_35() {
8733        if (jj_3R_114()) return true;
8734        if (jj_scan_token(DOT)) return true;
8735        if (jj_scan_token(CLASS)) return true;
8736        return false;
8737      }
8738    
8739      private boolean jj_3R_183() {
8740        if (jj_3R_94()) return true;
8741        Token xsp;
8742        xsp = jj_scanpos;
8743        if (jj_3_33()) jj_scanpos = xsp;
8744        return false;
8745      }
8746    
8747      private boolean jj_3R_332() {
8748        if (jj_3R_141()) return true;
8749        return false;
8750      }
8751    
8752      private boolean jj_3R_188() {
8753        if (jj_3R_198()) return true;
8754        return false;
8755      }
8756    
8757      private boolean jj_3R_384() {
8758        if (jj_scan_token(COMMA)) return true;
8759        if (jj_3R_184()) return true;
8760        return false;
8761      }
8762    
8763      private boolean jj_3R_113() {
8764        if (jj_3R_105()) return true;
8765        return false;
8766      }
8767    
8768      private boolean jj_3R_356() {
8769        if (jj_scan_token(IMPLEMENTS)) return true;
8770        if (jj_3R_184()) return true;
8771        Token xsp;
8772        while (true) {
8773          xsp = jj_scanpos;
8774          if (jj_3R_384()) { jj_scanpos = xsp; break; }
8775        }
8776        return false;
8777      }
8778    
8779      private boolean jj_3_17() {
8780        if (jj_scan_token(COMMA)) return true;
8781        if (jj_3R_100()) return true;
8782        return false;
8783      }
8784    
8785      private boolean jj_3R_182() {
8786        if (jj_3R_114()) return true;
8787        if (jj_scan_token(DOT)) return true;
8788        if (jj_scan_token(CLASS)) return true;
8789        return false;
8790      }
8791    
8792      private boolean jj_3R_176() {
8793        if (jj_scan_token(COMMA)) return true;
8794        if (jj_3R_175()) return true;
8795        return false;
8796      }
8797    
8798      private boolean jj_3R_309() {
8799        Token xsp;
8800        while (true) {
8801          xsp = jj_scanpos;
8802          if (jj_3R_332()) { jj_scanpos = xsp; break; }
8803        }
8804        while (true) {
8805          xsp = jj_scanpos;
8806          if (jj_3R_333()) { jj_scanpos = xsp; break; }
8807        }
8808        while (true) {
8809          xsp = jj_scanpos;
8810          if (jj_3R_334()) { jj_scanpos = xsp; break; }
8811        }
8812        xsp = jj_scanpos;
8813        if (jj_3R_335()) jj_scanpos = xsp;
8814        if (jj_3R_114()) return true;
8815        if (jj_3R_336()) return true;
8816        xsp = jj_scanpos;
8817        if (jj_3R_337()) jj_scanpos = xsp;
8818        xsp = jj_scanpos;
8819        if (jj_3R_338()) {
8820        jj_scanpos = xsp;
8821        if (jj_scan_token(83)) return true;
8822        }
8823        return false;
8824      }
8825    
8826      private boolean jj_3R_181() {
8827        if (jj_3R_115()) return true;
8828        return false;
8829      }
8830    
8831      private boolean jj_3R_180() {
8832        if (jj_scan_token(LPAREN)) return true;
8833        if (jj_3R_117()) return true;
8834        if (jj_scan_token(RPAREN)) return true;
8835        return false;
8836      }
8837    
8838      private boolean jj_3R_440() {
8839        if (jj_scan_token(COMMA)) return true;
8840        if (jj_3R_184()) return true;
8841        return false;
8842      }
8843    
8844      private boolean jj_3R_428() {
8845        if (jj_scan_token(EXTENDS)) return true;
8846        if (jj_3R_184()) return true;
8847        Token xsp;
8848        while (true) {
8849          xsp = jj_scanpos;
8850          if (jj_3R_440()) { jj_scanpos = xsp; break; }
8851        }
8852        return false;
8853      }
8854    
8855      private boolean jj_3R_342() {
8856        if (jj_scan_token(COMMA)) return true;
8857        if (jj_3R_341()) return true;
8858        return false;
8859      }
8860    
8861      private boolean jj_3R_393() {
8862        if (jj_scan_token(LBRACKET)) return true;
8863        if (jj_scan_token(RBRACKET)) return true;
8864        return false;
8865      }
8866    
8867      private boolean jj_3R_199() {
8868        if (jj_3R_105()) return true;
8869        return false;
8870      }
8871    
8872      private boolean jj_3_34() {
8873        if (jj_scan_token(SUPER)) return true;
8874        Token xsp;
8875        xsp = jj_scanpos;
8876        if (jj_scan_token(85)) jj_scanpos = xsp;
8877        xsp = jj_scanpos;
8878        if (jj_3R_113()) jj_scanpos = xsp;
8879        return false;
8880      }
8881    
8882      private boolean jj_3_32() {
8883        if (jj_3R_112()) return true;
8884        return false;
8885      }
8886    
8887      private boolean jj_3R_143() {
8888        if (jj_scan_token(LT)) return true;
8889        if (jj_3R_175()) return true;
8890        Token xsp;
8891        while (true) {
8892          xsp = jj_scanpos;
8893          if (jj_3R_176()) { jj_scanpos = xsp; break; }
8894        }
8895        if (jj_scan_token(GT)) return true;
8896        return false;
8897      }
8898    
8899      private boolean jj_3R_286() {
8900        if (jj_3R_100()) return true;
8901        Token xsp;
8902        while (true) {
8903          xsp = jj_scanpos;
8904          if (jj_3_17()) { jj_scanpos = xsp; break; }
8905        }
8906        return false;
8907      }
8908    
8909      private boolean jj_3R_378() {
8910        if (jj_scan_token(ASSIGN)) return true;
8911        if (jj_3R_100()) return true;
8912        return false;
8913      }
8914    
8915      private boolean jj_3R_179() {
8916        if (jj_scan_token(THIS)) return true;
8917        Token xsp;
8918        xsp = jj_scanpos;
8919        if (jj_scan_token(85)) jj_scanpos = xsp;
8920        xsp = jj_scanpos;
8921        if (jj_3R_199()) jj_scanpos = xsp;
8922        return false;
8923      }
8924    
8925      private boolean jj_3R_392() {
8926        if (jj_3R_105()) return true;
8927        return false;
8928      }
8929    
8930      private boolean jj_3R_177() {
8931        if (jj_scan_token(LBRACE)) return true;
8932        Token xsp;
8933        xsp = jj_scanpos;
8934        if (jj_3R_286()) jj_scanpos = xsp;
8935        xsp = jj_scanpos;
8936        if (jj_scan_token(84)) jj_scanpos = xsp;
8937        if (jj_scan_token(RBRACE)) return true;
8938        return false;
8939      }
8940    
8941      private boolean jj_3R_151() {
8942        Token xsp;
8943        xsp = jj_scanpos;
8944        if (jj_3R_178()) {
8945        jj_scanpos = xsp;
8946        if (jj_3R_179()) {
8947        jj_scanpos = xsp;
8948        if (jj_3_34()) {
8949        jj_scanpos = xsp;
8950        if (jj_3R_180()) {
8951        jj_scanpos = xsp;
8952        if (jj_3R_181()) {
8953        jj_scanpos = xsp;
8954        if (jj_3R_182()) {
8955        jj_scanpos = xsp;
8956        if (jj_3R_183()) return true;
8957        }
8958        }
8959        }
8960        }
8961        }
8962        }
8963        return false;
8964      }
8965    
8966      private boolean jj_3R_178() {
8967        if (jj_3R_198()) return true;
8968        return false;
8969      }
8970    
8971      private boolean jj_3R_280() {
8972        Token xsp;
8973        xsp = jj_scanpos;
8974        if (jj_scan_token(100)) {
8975        jj_scanpos = xsp;
8976        if (jj_scan_token(101)) return true;
8977        }
8978        return false;
8979      }
8980    
8981      private boolean jj_3R_187() {
8982        if (jj_3R_105()) return true;
8983        return false;
8984      }
8985    
8986      private boolean jj_3R_150() {
8987        if (jj_3R_117()) return true;
8988        return false;
8989      }
8990    
8991      private boolean jj_3R_99() {
8992        Token xsp;
8993        xsp = jj_scanpos;
8994        if (jj_scan_token(52)) {
8995        jj_scanpos = xsp;
8996        if (jj_scan_token(13)) {
8997        jj_scanpos = xsp;
8998        if (jj_scan_token(31)) {
8999        jj_scanpos = xsp;
9000        if (jj_scan_token(49)) {
9001        jj_scanpos = xsp;
9002        if (jj_scan_token(48)) {
9003        jj_scanpos = xsp;
9004        if (jj_scan_token(47)) {
9005        jj_scanpos = xsp;
9006        if (jj_scan_token(53)) return true;
9007        }
9008        }
9009        }
9010        }
9011        }
9012        }
9013        return false;
9014      }
9015    
9016      private boolean jj_3R_102() {
9017        if (jj_3R_151()) return true;
9018        Token xsp;
9019        while (true) {
9020          xsp = jj_scanpos;
9021          if (jj_3_32()) { jj_scanpos = xsp; break; }
9022        }
9023        return false;
9024      }
9025    
9026      private boolean jj_3R_377() {
9027        Token xsp;
9028        xsp = jj_scanpos;
9029        if (jj_scan_token(28)) {
9030        jj_scanpos = xsp;
9031        if (jj_3R_392()) return true;
9032        }
9033        while (true) {
9034          xsp = jj_scanpos;
9035          if (jj_3R_393()) { jj_scanpos = xsp; break; }
9036        }
9037        return false;
9038      }
9039    
9040      private boolean jj_3R_149() {
9041        if (jj_3R_177()) return true;
9042        return false;
9043      }
9044    
9045      private boolean jj_3R_100() {
9046        Token xsp;
9047        xsp = jj_scanpos;
9048        if (jj_3R_149()) {
9049        jj_scanpos = xsp;
9050        if (jj_3R_150()) return true;
9051        }
9052        return false;
9053      }
9054    
9055      private boolean jj_3_31() {
9056        if (jj_scan_token(LPAREN)) return true;
9057        if (jj_3R_110()) return true;
9058        return false;
9059      }
9060    
9061      private boolean jj_3R_97() {
9062        Token xsp;
9063        xsp = jj_scanpos;
9064        if (jj_scan_token(52)) {
9065        jj_scanpos = xsp;
9066        if (jj_scan_token(13)) {
9067        jj_scanpos = xsp;
9068        if (jj_scan_token(31)) {
9069        jj_scanpos = xsp;
9070        if (jj_scan_token(49)) {
9071        jj_scanpos = xsp;
9072        if (jj_scan_token(48)) {
9073        jj_scanpos = xsp;
9074        if (jj_scan_token(47)) {
9075        jj_scanpos = xsp;
9076        if (jj_scan_token(53)) return true;
9077        }
9078        }
9079        }
9080        }
9081        }
9082        }
9083        return false;
9084      }
9085    
9086      private boolean jj_3R_279() {
9087        if (jj_scan_token(LPAREN)) return true;
9088        if (jj_3R_111()) return true;
9089        if (jj_scan_token(RPAREN)) return true;
9090        if (jj_3R_216()) return true;
9091        return false;
9092      }
9093    
9094      private boolean jj_3_30() {
9095        if (jj_scan_token(LBRACKET)) return true;
9096        if (jj_scan_token(RBRACKET)) return true;
9097        return false;
9098      }
9099    
9100      private boolean jj_3R_257() {
9101        Token xsp;
9102        xsp = jj_scanpos;
9103        if (jj_3R_278()) {
9104        jj_scanpos = xsp;
9105        if (jj_3R_279()) return true;
9106        }
9107        return false;
9108      }
9109    
9110      private boolean jj_3R_278() {
9111        if (jj_scan_token(LPAREN)) return true;
9112        if (jj_3R_111()) return true;
9113        if (jj_scan_token(RPAREN)) return true;
9114        if (jj_3R_185()) return true;
9115        return false;
9116      }
9117    
9118      private boolean jj_3R_341() {
9119        if (jj_3R_377()) return true;
9120        Token xsp;
9121        xsp = jj_scanpos;
9122        if (jj_3R_378()) jj_scanpos = xsp;
9123        return false;
9124      }
9125    
9126      private boolean jj_3R_258() {
9127        if (jj_3R_102()) return true;
9128        Token xsp;
9129        xsp = jj_scanpos;
9130        if (jj_3R_280()) jj_scanpos = xsp;
9131        return false;
9132      }
9133    
9134      private boolean jj_3R_340() {
9135        if (jj_3R_141()) return true;
9136        return false;
9137      }
9138    
9139      private boolean jj_3R_98() {
9140        if (jj_3R_141()) return true;
9141        return false;
9142      }
9143    
9144      private boolean jj_3_14() {
9145        Token xsp;
9146        while (true) {
9147          xsp = jj_scanpos;
9148          if (jj_3R_98()) { jj_scanpos = xsp; break; }
9149        }
9150        while (true) {
9151          xsp = jj_scanpos;
9152          if (jj_3R_99()) { jj_scanpos = xsp; break; }
9153        }
9154        if (jj_scan_token(INTERFACE)) return true;
9155        return false;
9156      }
9157    
9158      private boolean jj_3R_96() {
9159        if (jj_3R_141()) return true;
9160        return false;
9161      }
9162    
9163      private boolean jj_3_13() {
9164        Token xsp;
9165        while (true) {
9166          xsp = jj_scanpos;
9167          if (jj_3R_96()) { jj_scanpos = xsp; break; }
9168        }
9169        while (true) {
9170          xsp = jj_scanpos;
9171          if (jj_3R_97()) { jj_scanpos = xsp; break; }
9172        }
9173        if (jj_scan_token(CLASS)) return true;
9174        return false;
9175      }
9176    
9177      private boolean jj_3_29() {
9178        if (jj_scan_token(LPAREN)) return true;
9179        if (jj_3R_111()) return true;
9180        if (jj_scan_token(LBRACKET)) return true;
9181        return false;
9182      }
9183    
9184      private boolean jj_3R_322() {
9185        if (jj_3R_356()) return true;
9186        return false;
9187      }
9188    
9189      private boolean jj_3R_157() {
9190        if (jj_scan_token(LPAREN)) return true;
9191        if (jj_3R_111()) return true;
9192        if (jj_scan_token(RPAREN)) return true;
9193        Token xsp;
9194        xsp = jj_scanpos;
9195        if (jj_scan_token(91)) {
9196        jj_scanpos = xsp;
9197        if (jj_scan_token(90)) {
9198        jj_scanpos = xsp;
9199        if (jj_scan_token(77)) {
9200        jj_scanpos = xsp;
9201        if (jj_3R_187()) {
9202        jj_scanpos = xsp;
9203        if (jj_scan_token(57)) {
9204        jj_scanpos = xsp;
9205        if (jj_scan_token(54)) {
9206        jj_scanpos = xsp;
9207        if (jj_scan_token(44)) {
9208        jj_scanpos = xsp;
9209        if (jj_3R_188()) return true;
9210        }
9211        }
9212        }
9213        }
9214        }
9215        }
9216        }
9217        return false;
9218      }
9219    
9220      private boolean jj_3R_156() {
9221        if (jj_scan_token(LPAREN)) return true;
9222        if (jj_3R_111()) return true;
9223        if (jj_scan_token(LBRACKET)) return true;
9224        if (jj_scan_token(RBRACKET)) return true;
9225        return false;
9226      }
9227    
9228      private boolean jj_3R_307() {
9229        if (jj_scan_token(ENUM)) return true;
9230        if (jj_scan_token(IDENTIFIER)) return true;
9231        Token xsp;
9232        xsp = jj_scanpos;
9233        if (jj_3R_322()) jj_scanpos = xsp;
9234        if (jj_3R_323()) return true;
9235        return false;
9236      }
9237    
9238      private boolean jj_3R_109() {
9239        Token xsp;
9240        xsp = jj_scanpos;
9241        if (jj_3_28()) {
9242        jj_scanpos = xsp;
9243        if (jj_3R_156()) {
9244        jj_scanpos = xsp;
9245        if (jj_3R_157()) return true;
9246        }
9247        }
9248        return false;
9249      }
9250    
9251      private boolean jj_3_28() {
9252        if (jj_scan_token(LPAREN)) return true;
9253        if (jj_3R_110()) return true;
9254        return false;
9255      }
9256    
9257      private boolean jj_3_27() {
9258        if (jj_3R_109()) return true;
9259        return false;
9260      }
9261    
9262      private boolean jj_3R_81() {
9263        if (jj_3R_141()) return true;
9264        return false;
9265      }
9266    
9267      private boolean jj_3R_417() {
9268        if (jj_scan_token(INTERFACE)) return true;
9269        return false;
9270      }
9271    
9272      private boolean jj_3R_376() {
9273        if (jj_scan_token(PROTECTED)) return true;
9274        return false;
9275      }
9276    
9277      private boolean jj_3R_375() {
9278        if (jj_scan_token(PUBLIC)) return true;
9279        return false;
9280      }
9281    
9282      private boolean jj_3R_339() {
9283        Token xsp;
9284        xsp = jj_scanpos;
9285        if (jj_3R_375()) {
9286        jj_scanpos = xsp;
9287        if (jj_3R_376()) {
9288        jj_scanpos = xsp;
9289        if (jj_scan_token(47)) {
9290        jj_scanpos = xsp;
9291        if (jj_scan_token(52)) {
9292        jj_scanpos = xsp;
9293        if (jj_scan_token(31)) {
9294        jj_scanpos = xsp;
9295        if (jj_scan_token(60)) {
9296        jj_scanpos = xsp;
9297        if (jj_scan_token(64)) return true;
9298        }
9299        }
9300        }
9301        }
9302        }
9303        }
9304        return false;
9305      }
9306    
9307      private boolean jj_3_1() {
9308        Token xsp;
9309        while (true) {
9310          xsp = jj_scanpos;
9311          if (jj_3R_81()) { jj_scanpos = xsp; break; }
9312        }
9313        if (jj_scan_token(PACKAGE)) return true;
9314        return false;
9315      }
9316    
9317      private boolean jj_3R_311() {
9318        Token xsp;
9319        while (true) {
9320          xsp = jj_scanpos;
9321          if (jj_3R_339()) { jj_scanpos = xsp; break; }
9322        }
9323        while (true) {
9324          xsp = jj_scanpos;
9325          if (jj_3R_340()) { jj_scanpos = xsp; break; }
9326        }
9327        if (jj_3R_111()) return true;
9328        if (jj_3R_341()) return true;
9329        while (true) {
9330          xsp = jj_scanpos;
9331          if (jj_3R_342()) { jj_scanpos = xsp; break; }
9332        }
9333        if (jj_scan_token(SEMICOLON)) return true;
9334        return false;
9335      }
9336    
9337      private boolean jj_3R_234() {
9338        if (jj_3R_258()) return true;
9339        return false;
9340      }
9341    
9342      private boolean jj_3R_420() {
9343        if (jj_3R_356()) return true;
9344        return false;
9345      }
9346    
9347      private boolean jj_3_16() {
9348        if (jj_3R_95()) return true;
9349        return false;
9350      }
9351    
9352      private boolean jj_3R_419() {
9353        if (jj_3R_428()) return true;
9354        return false;
9355      }
9356    
9357      private boolean jj_3R_233() {
9358        if (jj_3R_257()) return true;
9359        return false;
9360      }
9361    
9362      private boolean jj_3R_418() {
9363        if (jj_3R_143()) return true;
9364        return false;
9365      }
9366    
9367      private boolean jj_3R_107() {
9368        if (jj_scan_token(GT)) return true;
9369        if (jj_scan_token(GT)) return true;
9370        Token xsp;
9371        xsp = jj_scanpos;
9372        if (jj_scan_token(88)) jj_scanpos = xsp;
9373        return false;
9374      }
9375    
9376      private boolean jj_3R_411() {
9377        Token xsp;
9378        xsp = jj_scanpos;
9379        if (jj_scan_token(21)) {
9380        jj_scanpos = xsp;
9381        if (jj_3R_417()) return true;
9382        }
9383        if (jj_scan_token(IDENTIFIER)) return true;
9384        xsp = jj_scanpos;
9385        if (jj_3R_418()) jj_scanpos = xsp;
9386        xsp = jj_scanpos;
9387        if (jj_3R_419()) jj_scanpos = xsp;
9388        xsp = jj_scanpos;
9389        if (jj_3R_420()) jj_scanpos = xsp;
9390        if (jj_3R_413()) return true;
9391        return false;
9392      }
9393    
9394      private boolean jj_3R_216() {
9395        Token xsp;
9396        xsp = jj_scanpos;
9397        if (jj_3R_232()) {
9398        jj_scanpos = xsp;
9399        if (jj_3R_233()) {
9400        jj_scanpos = xsp;
9401        if (jj_3R_234()) return true;
9402        }
9403        }
9404        return false;
9405      }
9406    
9407      private boolean jj_3R_232() {
9408        Token xsp;
9409        xsp = jj_scanpos;
9410        if (jj_scan_token(91)) {
9411        jj_scanpos = xsp;
9412        if (jj_scan_token(90)) return true;
9413        }
9414        if (jj_3R_185()) return true;
9415        return false;
9416      }
9417    
9418      private boolean jj_3_15() {
9419        if (jj_3R_84()) return true;
9420        if (jj_scan_token(ENUM)) return true;
9421        if (jj_scan_token(IDENTIFIER)) return true;
9422        return false;
9423      }
9424    
9425      private boolean jj_3R_404() {
9426        if (jj_3R_84()) return true;
9427        if (jj_3R_311()) return true;
9428        return false;
9429      }
9430    
9431      private boolean jj_3R_403() {
9432        if (jj_3R_309()) return true;
9433        return false;
9434      }
9435    
9436      private boolean jj_3R_215() {
9437        if (jj_scan_token(DECR)) return true;
9438        if (jj_3R_102()) return true;
9439        return false;
9440      }
9441    
9442      private boolean jj_3R_155() {
9443        Token xsp;
9444        xsp = jj_scanpos;
9445        if (jj_scan_token(102)) {
9446        jj_scanpos = xsp;
9447        if (jj_scan_token(103)) return true;
9448        }
9449        if (jj_3R_154()) return true;
9450        return false;
9451      }
9452    
9453      private boolean jj_3R_186() {
9454        Token xsp;
9455        xsp = jj_scanpos;
9456        if (jj_scan_token(104)) {
9457        jj_scanpos = xsp;
9458        if (jj_scan_token(105)) {
9459        jj_scanpos = xsp;
9460        if (jj_scan_token(109)) return true;
9461        }
9462        }
9463        if (jj_3R_185()) return true;
9464        return false;
9465      }
9466    
9467      private boolean jj_3R_402() {
9468        if (jj_3R_84()) return true;
9469        if (jj_3R_307()) return true;
9470        return false;
9471      }
9472    
9473      private boolean jj_3R_214() {
9474        if (jj_scan_token(INCR)) return true;
9475        if (jj_3R_102()) return true;
9476        return false;
9477      }
9478    
9479      private boolean jj_3R_135() {
9480        if (jj_3R_141()) return true;
9481        return false;
9482      }
9483    
9484      private boolean jj_3R_401() {
9485        if (jj_3R_306()) return true;
9486        return false;
9487      }
9488    
9489      private boolean jj_3R_400() {
9490        if (jj_3R_305()) return true;
9491        return false;
9492      }
9493    
9494      private boolean jj_3R_203() {
9495        if (jj_3R_216()) return true;
9496        return false;
9497      }
9498    
9499      private boolean jj_3R_134() {
9500        if (jj_scan_token(TESTAAAA)) return true;
9501        return false;
9502      }
9503    
9504      private boolean jj_3R_383() {
9505        Token xsp;
9506        xsp = jj_scanpos;
9507        if (jj_scan_token(83)) {
9508        jj_scanpos = xsp;
9509        if (jj_3R_400()) {
9510        jj_scanpos = xsp;
9511        if (jj_3R_401()) {
9512        jj_scanpos = xsp;
9513        if (jj_3R_402()) {
9514        jj_scanpos = xsp;
9515        if (jj_3R_403()) {
9516        jj_scanpos = xsp;
9517        if (jj_3R_404()) return true;
9518        }
9519        }
9520        }
9521        }
9522        }
9523        return false;
9524      }
9525    
9526      private boolean jj_3R_202() {
9527        if (jj_3R_215()) return true;
9528        return false;
9529      }
9530    
9531      private boolean jj_3_26() {
9532        Token xsp;
9533        xsp = jj_scanpos;
9534        if (jj_scan_token(110)) {
9535        jj_scanpos = xsp;
9536        if (jj_3R_107()) return true;
9537        }
9538        if (jj_3R_108()) return true;
9539        return false;
9540      }
9541    
9542      private boolean jj_3R_201() {
9543        if (jj_3R_214()) return true;
9544        return false;
9545      }
9546    
9547      private boolean jj_3R_133() {
9548        if (jj_scan_token(VOLATILE)) return true;
9549        return false;
9550      }
9551    
9552      private boolean jj_3R_185() {
9553        Token xsp;
9554        xsp = jj_scanpos;
9555        if (jj_3R_200()) {
9556        jj_scanpos = xsp;
9557        if (jj_3R_201()) {
9558        jj_scanpos = xsp;
9559        if (jj_3R_202()) {
9560        jj_scanpos = xsp;
9561        if (jj_3R_203()) return true;
9562        }
9563        }
9564        }
9565        return false;
9566      }
9567    
9568      private boolean jj_3R_200() {
9569        Token xsp;
9570        xsp = jj_scanpos;
9571        if (jj_scan_token(102)) {
9572        jj_scanpos = xsp;
9573        if (jj_scan_token(103)) return true;
9574        }
9575        if (jj_3R_185()) return true;
9576        return false;
9577      }
9578    
9579      private boolean jj_3R_132() {
9580        if (jj_scan_token(TRANSIENT)) return true;
9581        return false;
9582      }
9583    
9584      private boolean jj_3R_354() {
9585        if (jj_scan_token(EXTENDS)) return true;
9586        if (jj_3R_363()) return true;
9587        return false;
9588      }
9589    
9590      private boolean jj_3R_154() {
9591        if (jj_3R_185()) return true;
9592        Token xsp;
9593        while (true) {
9594          xsp = jj_scanpos;
9595          if (jj_3R_186()) { jj_scanpos = xsp; break; }
9596        }
9597        return false;
9598      }
9599    
9600      private boolean jj_3R_131() {
9601        if (jj_scan_token(NATIVE)) return true;
9602        return false;
9603      }
9604    
9605      private boolean jj_3R_343() {
9606        Token xsp;
9607        xsp = jj_scanpos;
9608        if (jj_scan_token(89)) {
9609        jj_scanpos = xsp;
9610        if (jj_scan_token(88)) {
9611        jj_scanpos = xsp;
9612        if (jj_scan_token(95)) {
9613        jj_scanpos = xsp;
9614        if (jj_scan_token(96)) return true;
9615        }
9616        }
9617        }
9618        if (jj_3R_312()) return true;
9619        return false;
9620      }
9621    
9622      private boolean jj_3R_313() {
9623        if (jj_scan_token(INSTANCEOF)) return true;
9624        if (jj_3R_111()) return true;
9625        return false;
9626      }
9627    
9628      private boolean jj_3R_108() {
9629        if (jj_3R_154()) return true;
9630        Token xsp;
9631        while (true) {
9632          xsp = jj_scanpos;
9633          if (jj_3R_155()) { jj_scanpos = xsp; break; }
9634        }
9635        return false;
9636      }
9637    
9638      private boolean jj_3R_130() {
9639        if (jj_scan_token(SYNCHRONIZED)) return true;
9640        return false;
9641      }
9642    
9643      private boolean jj_3R_302() {
9644        Token xsp;
9645        xsp = jj_scanpos;
9646        if (jj_scan_token(94)) {
9647        jj_scanpos = xsp;
9648        if (jj_scan_token(97)) return true;
9649        }
9650        if (jj_3R_291()) return true;
9651        return false;
9652      }
9653    
9654      private boolean jj_3R_129() {
9655        if (jj_scan_token(ABSTRACT)) return true;
9656        return false;
9657      }
9658    
9659      private boolean jj_3R_312() {
9660        if (jj_3R_108()) return true;
9661        Token xsp;
9662        while (true) {
9663          xsp = jj_scanpos;
9664          if (jj_3_26()) { jj_scanpos = xsp; break; }
9665        }
9666        return false;
9667      }
9668    
9669      private boolean jj_3R_128() {
9670        if (jj_scan_token(FINAL)) return true;
9671        return false;
9672      }
9673    
9674      private boolean jj_3R_353() {
9675        if (jj_3R_143()) return true;
9676        return false;
9677      }
9678    
9679      private boolean jj_3R_292() {
9680        if (jj_scan_token(BIT_AND)) return true;
9681        if (jj_3R_288()) return true;
9682        return false;
9683      }
9684    
9685      private boolean jj_3R_127() {
9686        if (jj_scan_token(PRIVATE)) return true;
9687        return false;
9688      }
9689    
9690      private boolean jj_3R_301() {
9691        if (jj_3R_312()) return true;
9692        Token xsp;
9693        while (true) {
9694          xsp = jj_scanpos;
9695          if (jj_3R_343()) { jj_scanpos = xsp; break; }
9696        }
9697        return false;
9698      }
9699    
9700      private boolean jj_3R_282() {
9701        if (jj_scan_token(BIT_OR)) return true;
9702        if (jj_3R_259()) return true;
9703        return false;
9704      }
9705    
9706      private boolean jj_3R_126() {
9707        if (jj_scan_token(PROTECTED)) return true;
9708        return false;
9709      }
9710    
9711      private boolean jj_3R_289() {
9712        if (jj_scan_token(XOR)) return true;
9713        if (jj_3R_281()) return true;
9714        return false;
9715      }
9716    
9717      private boolean jj_3R_291() {
9718        if (jj_3R_301()) return true;
9719        Token xsp;
9720        xsp = jj_scanpos;
9721        if (jj_3R_313()) jj_scanpos = xsp;
9722        return false;
9723      }
9724    
9725      private boolean jj_3R_125() {
9726        if (jj_scan_token(STATIC)) return true;
9727        return false;
9728      }
9729    
9730      private boolean jj_3R_260() {
9731        if (jj_scan_token(SC_AND)) return true;
9732        if (jj_3R_235()) return true;
9733        return false;
9734      }
9735    
9736      private boolean jj_3R_288() {
9737        if (jj_3R_291()) return true;
9738        Token xsp;
9739        while (true) {
9740          xsp = jj_scanpos;
9741          if (jj_3R_302()) { jj_scanpos = xsp; break; }
9742        }
9743        return false;
9744      }
9745    
9746      private boolean jj_3R_236() {
9747        if (jj_scan_token(SC_OR)) return true;
9748        if (jj_3R_218()) return true;
9749        return false;
9750      }
9751    
9752      private boolean jj_3R_355() {
9753        if (jj_3R_383()) return true;
9754        return false;
9755      }
9756    
9757      private boolean jj_3R_124() {
9758        if (jj_scan_token(PUBLIC)) return true;
9759        return false;
9760      }
9761    
9762      private boolean jj_3R_281() {
9763        if (jj_3R_288()) return true;
9764        Token xsp;
9765        while (true) {
9766          xsp = jj_scanpos;
9767          if (jj_3R_292()) { jj_scanpos = xsp; break; }
9768        }
9769        return false;
9770      }
9771    
9772      private boolean jj_3_52() {
9773        Token xsp;
9774        xsp = jj_scanpos;
9775        if (jj_3R_124()) {
9776        jj_scanpos = xsp;
9777        if (jj_3R_125()) {
9778        jj_scanpos = xsp;
9779        if (jj_3R_126()) {
9780        jj_scanpos = xsp;
9781        if (jj_3R_127()) {
9782        jj_scanpos = xsp;
9783        if (jj_3R_128()) {
9784        jj_scanpos = xsp;
9785        if (jj_3R_129()) {
9786        jj_scanpos = xsp;
9787        if (jj_3R_130()) {
9788        jj_scanpos = xsp;
9789        if (jj_3R_131()) {
9790        jj_scanpos = xsp;
9791        if (jj_3R_132()) {
9792        jj_scanpos = xsp;
9793        if (jj_3R_133()) {
9794        jj_scanpos = xsp;
9795        if (jj_3R_134()) {
9796        jj_scanpos = xsp;
9797        if (jj_3R_135()) return true;
9798        }
9799        }
9800        }
9801        }
9802        }
9803        }
9804        }
9805        }
9806        }
9807        }
9808        }
9809        return false;
9810      }
9811    
9812      private boolean jj_3R_219() {
9813        if (jj_scan_token(HOOK)) return true;
9814        if (jj_3R_117()) return true;
9815        if (jj_scan_token(COLON)) return true;
9816        if (jj_3R_191()) return true;
9817        return false;
9818      }
9819    
9820      private boolean jj_3R_84() {
9821        Token xsp;
9822        while (true) {
9823          xsp = jj_scanpos;
9824          if (jj_3_52()) { jj_scanpos = xsp; break; }
9825        }
9826        return false;
9827      }
9828    
9829      private boolean jj_3R_225() {
9830        if (jj_scan_token(INTERFACE)) return true;
9831        if (jj_3R_105()) return true;
9832        Token xsp;
9833        xsp = jj_scanpos;
9834        if (jj_3R_353()) jj_scanpos = xsp;
9835        xsp = jj_scanpos;
9836        if (jj_3R_354()) jj_scanpos = xsp;
9837        if (jj_scan_token(LBRACE)) return true;
9838        while (true) {
9839          xsp = jj_scanpos;
9840          if (jj_3R_355()) { jj_scanpos = xsp; break; }
9841        }
9842        if (jj_scan_token(RBRACE)) return true;
9843        return false;
9844      }
9845    
9846      private boolean jj_3R_344() {
9847        if (jj_3R_345()) return true;
9848        return false;
9849      }
9850    
9851      private boolean jj_3R_259() {
9852        if (jj_3R_281()) return true;
9853        Token xsp;
9854        while (true) {
9855          xsp = jj_scanpos;
9856          if (jj_3R_289()) { jj_scanpos = xsp; break; }
9857        }
9858        return false;
9859      }
9860    
9861      private boolean jj_3R_410() {
9862        if (jj_3R_416()) return true;
9863        return false;
9864      }
9865    
9866      private boolean jj_3R_235() {
9867        if (jj_3R_259()) return true;
9868        Token xsp;
9869        while (true) {
9870          xsp = jj_scanpos;
9871          if (jj_3R_282()) { jj_scanpos = xsp; break; }
9872        }
9873        return false;
9874      }
9875    
9876      private boolean jj_3R_416() {
9877        if (jj_scan_token(_DEFAULT)) return true;
9878        if (jj_3R_123()) return true;
9879        return false;
9880      }
9881    
9882      private boolean jj_3R_218() {
9883        if (jj_3R_235()) return true;
9884        Token xsp;
9885        while (true) {
9886          xsp = jj_scanpos;
9887          if (jj_3R_260()) { jj_scanpos = xsp; break; }
9888        }
9889        return false;
9890      }
9891    
9892      private boolean jj_3R_380() {
9893        if (jj_scan_token(SEMICOLON)) return true;
9894        return false;
9895      }
9896    
9897      private boolean jj_3R_205() {
9898        if (jj_3R_218()) return true;
9899        Token xsp;
9900        while (true) {
9901          xsp = jj_scanpos;
9902          if (jj_3R_236()) { jj_scanpos = xsp; break; }
9903        }
9904        return false;
9905      }
9906    
9907      private boolean jj_3R_398() {
9908        if (jj_3R_412()) return true;
9909        return false;
9910      }
9911    
9912      private boolean jj_3R_191() {
9913        if (jj_3R_205()) return true;
9914        Token xsp;
9915        xsp = jj_scanpos;
9916        if (jj_3R_219()) jj_scanpos = xsp;
9917        return false;
9918      }
9919    
9920      private boolean jj_3R_397() {
9921        if (jj_3R_303()) return true;
9922        return false;
9923      }
9924    
9925      private boolean jj_3R_315() {
9926        if (jj_3R_345()) return true;
9927        return false;
9928      }
9929    
9930      private boolean jj_3R_396() {
9931        if (jj_3R_307()) return true;
9932        return false;
9933      }
9934    
9935      private boolean jj_3_51() {
9936        if (jj_3R_111()) return true;
9937        if (jj_scan_token(IDENTIFIER)) return true;
9938        if (jj_scan_token(LPAREN)) return true;
9939        return false;
9940      }
9941    
9942      private boolean jj_3R_395() {
9943        if (jj_3R_411()) return true;
9944        return false;
9945      }
9946    
9947      private boolean jj_3R_106() {
9948        Token xsp;
9949        xsp = jj_scanpos;
9950        if (jj_scan_token(87)) {
9951        jj_scanpos = xsp;
9952        if (jj_scan_token(113)) {
9953        jj_scanpos = xsp;
9954        if (jj_scan_token(114)) {
9955        jj_scanpos = xsp;
9956        if (jj_scan_token(118)) {
9957        jj_scanpos = xsp;
9958        if (jj_scan_token(111)) {
9959        jj_scanpos = xsp;
9960        if (jj_scan_token(112)) {
9961        jj_scanpos = xsp;
9962        if (jj_scan_token(119)) {
9963        jj_scanpos = xsp;
9964        if (jj_scan_token(120)) {
9965        jj_scanpos = xsp;
9966        if (jj_scan_token(121)) {
9967        jj_scanpos = xsp;
9968        if (jj_scan_token(115)) {
9969        jj_scanpos = xsp;
9970        if (jj_scan_token(117)) {
9971        jj_scanpos = xsp;
9972        if (jj_scan_token(116)) return true;
9973        }
9974        }
9975        }
9976        }
9977        }
9978        }
9979        }
9980        }
9981        }
9982        }
9983        }
9984        return false;
9985      }
9986    
9987      private boolean jj_3_25() {
9988        if (jj_3R_102()) return true;
9989        if (jj_3R_106()) return true;
9990        return false;
9991      }
9992    
9993      /** Generated Token Manager. */
9994      public JavaParserTokenManager token_source;
9995      JavaCharStream jj_input_stream;
9996      /** Current token. */
9997      public Token token;
9998      /** Next token. */
9999      public Token jj_nt;
10000      private int jj_ntk;
10001      private Token jj_scanpos, jj_lastpos;
10002      private int jj_la;
10003      private int jj_gen;
10004      final private int[] jj_la1 = new int[202];
10005      static private int[] jj_la1_0;
10006      static private int[] jj_la1_1;
10007      static private int[] jj_la1_2;
10008      static private int[] jj_la1_3;
10009      static {
10010          jj_la1_init_0();
10011          jj_la1_init_1();
10012          jj_la1_init_2();
10013          jj_la1_init_3();
10014       }
10015       private static void jj_la1_init_0() {
10016          jj_la1_0 = new int[] {0x0,0x90202000,0x0,0x0,0x0,0x90202000,0x0,0x0,0x80002000,0x80002000,0x200000,0x0,0x0,0x0,0x80002000,0x0,0x0,0x80002000,0x80002000,0x0,0x0,0x0,0x0,0x20000000,0x0,0x9432e000,0x0,0x0,0x80002000,0x80002000,0x0,0x0,0x84128000,0x0,0x80002000,0x80002000,0x0,0x0,0x0,0x0,0x2000,0x2000,0x0,0x0,0x80002000,0x80002000,0x0,0x20000000,0x9432a000,0x0,0x8412a000,0x80000000,0x80000000,0x0,0x0,0x0,0x10004000,0x0,0x5412c000,0x5412c000,0x0,0x0,0x80002000,0x80002000,0x0,0x0,0x0,0x0,0x0,0x0,0x8412a000,0x0,0x0,0x0,0x0,0x0,0x0,0xd6b3e000,0x5412c000,0x0,0x4128000,0x4128000,0x0,0x4128000,0x4128000,0x10004000,0x10004000,0x0,0x0,0x0,0x5412c000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x5412c000,0x0,0x0,0x5412c000,0x40004000,0x0,0x0,0x0,0x0,0x0,0x4000,0x0,0x4000,0x40000000,0x0,0x10004000,0x0,0x40000000,0x40000000,0x5412c000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x5693c000,0x0,0xd6b3e000,0xd6b3e000,0x0,0x0,0x0,0x5412c000,0x1040000,0xd6b3e000,0x1040000,0x8000000,0xd412e000,0x5412c000,0x5412c000,0xd412e000,0x5412c000,0x0,0x4000,0x4000,0x5412c000,0x80000,0x0,0x4000,0x0,0x0,0x0,0x5412c000,0x5412c000,0x0,0x9432a000,0x9432a000,0x1000000,0x14328000,0x9432a000,0x80002000,0x200000,0x0,0x20000000,0x0,0x0,0x0,0x0,0x0,0x9432e000,0x80002000,0x0,0x9432e000,0x0,0x20000000,0x10200000,0x8412a000,0x9432e000,0x0,0x0,0x0,0x20000000,0x4128000,0x4128000,0x20000000,0x0,0x0,0x0,0x8412a000,0x0,};
10017       }
10018       private static void jj_la1_init_1() {
10019          jj_la1_1 = new int[] {0x40,0x11338a00,0x4040,0x4040,0x40,0x11338a00,0x4000,0x40,0x1220000,0x1220000,0x200,0x0,0x100000,0x0,0x11338800,0x0,0x0,0x1220000,0x1220000,0x0,0x0,0x0,0x0,0x0,0x20,0x913b8f02,0x0,0x0,0x338000,0x338000,0x0,0x0,0x101b8502,0x0,0x1338800,0x1338800,0x0,0x0,0x0,0x0,0x220000,0x220000,0x0,0x0,0x338000,0x338000,0x0,0x0,0x913b8f02,0x0,0x113b8d02,0x10138000,0x10138000,0x0,0x0,0x0,0x0,0x0,0xa2483502,0xa2483502,0x0,0x0,0x1338800,0x1338800,0x0,0x0,0x8000000,0x0,0x0,0x0,0x113b8d02,0x0,0x0,0x38000,0x38000,0x0,0x8000000,0xf7ffbf16,0xa2483502,0x100000,0x80502,0x80502,0x0,0x80502,0x80080502,0x0,0x0,0x0,0x0,0x0,0xa2483502,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xa2483502,0x0,0x0,0xa2483502,0x22403000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x22002000,0x1000,0x0,0x0,0x20002000,0x20000000,0xa2483502,0x0,0x0,0x0,0x0,0x1000,0x0,0x0,0xe7cc3516,0x0,0xf7ffbf16,0xf7ffbf16,0x0,0x0,0x0,0xa2483502,0x0,0xf7ffbf16,0x0,0x0,0xb37bbd02,0xa2483502,0xa2483502,0xb37bbd02,0xa2483502,0x0,0x0,0x0,0xa2483502,0x0,0x1,0x0,0x0,0x0,0x0,0xa2483502,0xa2483502,0x0,0x113b8f02,0x113b8f02,0x0,0x80702,0x113b8f02,0x11338800,0x200,0x0,0x0,0x20,0x20,0x0,0x0,0x0,0x913b8f02,0x11338800,0x0,0x913b8f02,0x0,0x0,0x200,0x813b8d02,0x913b8f02,0x0,0x0,0x0,0x400000,0x80502,0x80502,0x400000,0x0,0x0,0x0,0x113b8d02,0x0,};
10020       }
10021       private static void jj_la1_init_2() {
10022          jj_la1_2 = new int[] {0x0,0x480001,0x400000,0x400000,0x0,0x480001,0x400000,0x0,0x0,0x0,0x0,0x400000,0x0,0x200000,0x480001,0x400000,0x400000,0x0,0x0,0x2000000,0x2000000,0x200000,0x2000000,0x0,0x0,0x2488401,0x400000,0x400000,0x0,0x0,0x400000,0x80000,0x400401,0x400000,0x0,0x0,0x400000,0x2000000,0x400000,0x400000,0x0,0x0,0x400000,0x400000,0x0,0x0,0x2000000,0x0,0x2480401,0x80000,0x400401,0x1,0x1,0x400000,0x100000,0x800000,0x400,0x20000,0xc00a744,0xc00a744,0x100000,0x400000,0x0,0x0,0x400000,0x2000000,0x0,0x88000,0x20000,0x100000,0x400401,0x0,0x400000,0x0,0x0,0x2000000,0x0,0x48a747,0x2744,0x0,0x0,0x400,0x20000,0x0,0x400,0x400,0x400,0x2000000,0x100000,0x2000000,0xc002744,0x800000,0x10000000,0x0,0x0,0x0,0x0,0x0,0x40000000,0x40000000,0x0,0x83000000,0x83000000,0x1000000,0x1000000,0x0,0x0,0x0,0x0,0x0,0xc002744,0xc000000,0xc000000,0x2744,0xc002744,0x2000,0x0,0x0,0x2000,0x200000,0x400,0x200000,0x400,0x344,0x2000,0x400,0x222000,0x344,0x0,0xc002744,0x100000,0x2000000,0x8000,0x22000,0x0,0x20000,0x20000,0x8a746,0x20000000,0x48a747,0x48a747,0x100000,0x800000,0x800000,0x2744,0x0,0x48a747,0x0,0x0,0x402745,0xc002744,0x2744,0x482745,0x2744,0x100000,0x400,0x400,0xc002744,0x0,0x0,0x400,0x400000,0x400,0x100000,0xc40a744,0xc40a744,0x100000,0x480401,0x480401,0x0,0x400400,0x480401,0x400001,0x0,0x2000000,0x0,0x0,0x0,0x100000,0x100000,0x100000,0x2488401,0x400401,0x100000,0x2488401,0x80000,0x0,0x0,0x2400400,0x2480401,0x2000,0x8000,0x0,0x0,0x10000400,0x400,0x0,0x100000,0x20000,0x100000,0x400401,0x0,};
10023       }
10024       private static void jj_la1_init_3() {
10025          jj_la1_3 = new int[] {0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xf0,0xf0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4000000,0x0,0x0,0x0,0x0,0x0,0x30,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xf0,0x3ff8000,0x0,0x4,0x8,0x800,0x1000,0x400,0x2,0x2,0x0,0x1,0x1,0x0,0x4000,0xc0,0xc0,0x2300,0x2300,0xc0,0xf0,0x0,0x0,0x0,0x0,0x0,0x30,0x30,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xf0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x30,0x0,0x30,0x30,0x0,0x3ff8030,0x3ff8030,0x30,0x0,0x30,0x0,0x0,0x30,0xf0,0x30,0x30,0x30,0x0,0x0,0x0,0xf0,0x0,0x0,0x0,0x0,0x0,0x0,0xf0,0xf0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x400,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4000000,};
10026       }
10027      final private JJCalls[] jj_2_rtns = new JJCalls[62];
10028      private boolean jj_rescan = false;
10029      private int jj_gc = 0;
10030    
10031      /** Constructor with InputStream. */
10032      public JavaParser(java.io.InputStream stream) {
10033         this(stream, null);
10034      }
10035      /** Constructor with InputStream and supplied encoding */
10036      public JavaParser(java.io.InputStream stream, String encoding) {
10037        try { jj_input_stream = new JavaCharStream(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); }
10038        token_source = new JavaParserTokenManager(jj_input_stream);
10039        token = new Token();
10040        jj_ntk = -1;
10041        jj_gen = 0;
10042        for (int i = 0; i < 202; i++) jj_la1[i] = -1;
10043        for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
10044      }
10045    
10046      /** Reinitialise. */
10047      public void ReInit(java.io.InputStream stream) {
10048         ReInit(stream, null);
10049      }
10050      /** Reinitialise. */
10051      public void ReInit(java.io.InputStream stream, String encoding) {
10052        try { jj_input_stream.ReInit(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); }
10053        token_source.ReInit(jj_input_stream);
10054        token = new Token();
10055        jj_ntk = -1;
10056        jj_gen = 0;
10057        for (int i = 0; i < 202; i++) jj_la1[i] = -1;
10058        for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
10059      }
10060    
10061      /** Constructor. */
10062      public JavaParser(java.io.Reader stream) {
10063        jj_input_stream = new JavaCharStream(stream, 1, 1);
10064        token_source = new JavaParserTokenManager(jj_input_stream);
10065        token = new Token();
10066        jj_ntk = -1;
10067        jj_gen = 0;
10068        for (int i = 0; i < 202; i++) jj_la1[i] = -1;
10069        for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
10070      }
10071    
10072      /** Reinitialise. */
10073      public void ReInit(java.io.Reader stream) {
10074        jj_input_stream.ReInit(stream, 1, 1);
10075        token_source.ReInit(jj_input_stream);
10076        token = new Token();
10077        jj_ntk = -1;
10078        jj_gen = 0;
10079        for (int i = 0; i < 202; i++) jj_la1[i] = -1;
10080        for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
10081      }
10082    
10083      /** Constructor with generated Token Manager. */
10084      public JavaParser(JavaParserTokenManager tm) {
10085        token_source = tm;
10086        token = new Token();
10087        jj_ntk = -1;
10088        jj_gen = 0;
10089        for (int i = 0; i < 202; i++) jj_la1[i] = -1;
10090        for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
10091      }
10092    
10093      /** Reinitialise. */
10094      public void ReInit(JavaParserTokenManager tm) {
10095        token_source = tm;
10096        token = new Token();
10097        jj_ntk = -1;
10098        jj_gen = 0;
10099        for (int i = 0; i < 202; i++) jj_la1[i] = -1;
10100        for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
10101      }
10102    
10103      private Token jj_consume_token(int kind) throws ParseException {
10104        Token oldToken;
10105        if ((oldToken = token).next != null) token = token.next;
10106        else token = token.next = token_source.getNextToken();
10107        jj_ntk = -1;
10108        if (token.kind == kind) {
10109          jj_gen++;
10110          if (++jj_gc > 100) {
10111            jj_gc = 0;
10112            for (int i = 0; i < jj_2_rtns.length; i++) {
10113              JJCalls c = jj_2_rtns[i];
10114              while (c != null) {
10115                if (c.gen < jj_gen) c.first = null;
10116                c = c.next;
10117              }
10118            }
10119          }
10120          return token;
10121        }
10122        token = oldToken;
10123        jj_kind = kind;
10124        throw generateParseException();
10125      }
10126    
10127      static private final class LookaheadSuccess extends java.lang.Error { }
10128      final private LookaheadSuccess jj_ls = new LookaheadSuccess();
10129      private boolean jj_scan_token(int kind) {
10130        if (jj_scanpos == jj_lastpos) {
10131          jj_la--;
10132          if (jj_scanpos.next == null) {
10133            jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
10134          } else {
10135            jj_lastpos = jj_scanpos = jj_scanpos.next;
10136          }
10137        } else {
10138          jj_scanpos = jj_scanpos.next;
10139        }
10140        if (jj_rescan) {
10141          int i = 0; Token tok = token;
10142          while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; }
10143          if (tok != null) jj_add_error_token(kind, i);
10144        }
10145        if (jj_scanpos.kind != kind) return true;
10146        if (jj_la == 0 && jj_scanpos == jj_lastpos) throw jj_ls;
10147        return false;
10148      }
10149    
10150    
10151    /** Get the next Token. */
10152      final public Token getNextToken() {
10153        if (token.next != null) token = token.next;
10154        else token = token.next = token_source.getNextToken();
10155        jj_ntk = -1;
10156        jj_gen++;
10157        return token;
10158      }
10159    
10160    /** Get the specific Token. */
10161      final public Token getToken(int index) {
10162        Token t = token;
10163        for (int i = 0; i < index; i++) {
10164          if (t.next != null) t = t.next;
10165          else t = t.next = token_source.getNextToken();
10166        }
10167        return t;
10168      }
10169    
10170      private int jj_ntk() {
10171        if ((jj_nt=token.next) == null)
10172          return (jj_ntk = (token.next=token_source.getNextToken()).kind);
10173        else
10174          return (jj_ntk = jj_nt.kind);
10175      }
10176    
10177      private java.util.List jj_expentries = new java.util.ArrayList();
10178      private int[] jj_expentry;
10179      private int jj_kind = -1;
10180      private int[] jj_lasttokens = new int[100];
10181      private int jj_endpos;
10182    
10183      private void jj_add_error_token(int kind, int pos) {
10184        if (pos >= 100) return;
10185        if (pos == jj_endpos + 1) {
10186          jj_lasttokens[jj_endpos++] = kind;
10187        } else if (jj_endpos != 0) {
10188          jj_expentry = new int[jj_endpos];
10189          for (int i = 0; i < jj_endpos; i++) {
10190            jj_expentry[i] = jj_lasttokens[i];
10191          }
10192          jj_entries_loop: for (java.util.Iterator it = jj_expentries.iterator(); it.hasNext();) {
10193            int[] oldentry = (int[])(it.next());
10194            if (oldentry.length == jj_expentry.length) {
10195              for (int i = 0; i < jj_expentry.length; i++) {
10196                if (oldentry[i] != jj_expentry[i]) {
10197                  continue jj_entries_loop;
10198                }
10199              }
10200              jj_expentries.add(jj_expentry);
10201              break jj_entries_loop;
10202            }
10203          }
10204          if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind;
10205        }
10206      }
10207    
10208      /** Generate ParseException. */
10209      public ParseException generateParseException() {
10210        jj_expentries.clear();
10211        boolean[] la1tokens = new boolean[123];
10212        if (jj_kind >= 0) {
10213          la1tokens[jj_kind] = true;
10214          jj_kind = -1;
10215        }
10216        for (int i = 0; i < 202; i++) {
10217          if (jj_la1[i] == jj_gen) {
10218            for (int j = 0; j < 32; j++) {
10219              if ((jj_la1_0[i] & (1<<j)) != 0) {
10220                la1tokens[j] = true;
10221              }
10222              if ((jj_la1_1[i] & (1<<j)) != 0) {
10223                la1tokens[32+j] = true;
10224              }
10225              if ((jj_la1_2[i] & (1<<j)) != 0) {
10226                la1tokens[64+j] = true;
10227              }
10228              if ((jj_la1_3[i] & (1<<j)) != 0) {
10229                la1tokens[96+j] = true;
10230              }
10231            }
10232          }
10233        }
10234        for (int i = 0; i < 123; i++) {
10235          if (la1tokens[i]) {
10236            jj_expentry = new int[1];
10237            jj_expentry[0] = i;
10238            jj_expentries.add(jj_expentry);
10239          }
10240        }
10241        jj_endpos = 0;
10242        jj_rescan_token();
10243        jj_add_error_token(0, 0);
10244        int[][] exptokseq = new int[jj_expentries.size()][];
10245        for (int i = 0; i < jj_expentries.size(); i++) {
10246          exptokseq[i] = (int[])jj_expentries.get(i);
10247        }
10248        return new ParseException(token, exptokseq, tokenImage);
10249      }
10250    
10251      /** Enable tracing. */
10252      final public void enable_tracing() {
10253      }
10254    
10255      /** Disable tracing. */
10256      final public void disable_tracing() {
10257      }
10258    
10259      private void jj_rescan_token() {
10260        jj_rescan = true;
10261        for (int i = 0; i < 62; i++) {
10262        try {
10263          JJCalls p = jj_2_rtns[i];
10264          do {
10265            if (p.gen > jj_gen) {
10266              jj_la = p.arg; jj_lastpos = jj_scanpos = p.first;
10267              switch (i) {
10268                case 0: jj_3_1(); break;
10269                case 1: jj_3_2(); break;
10270                case 2: jj_3_3(); break;
10271                case 3: jj_3_4(); break;
10272                case 4: jj_3_5(); break;
10273                case 5: jj_3_6(); break;
10274                case 6: jj_3_7(); break;
10275                case 7: jj_3_8(); break;
10276                case 8: jj_3_9(); break;
10277                case 9: jj_3_10(); break;
10278                case 10: jj_3_11(); break;
10279                case 11: jj_3_12(); break;
10280                case 12: jj_3_13(); break;
10281                case 13: jj_3_14(); break;
10282                case 14: jj_3_15(); break;
10283                case 15: jj_3_16(); break;
10284                case 16: jj_3_17(); break;
10285                case 17: jj_3_18(); break;
10286                case 18: jj_3_19(); break;
10287                case 19: jj_3_20(); break;
10288                case 20: jj_3_21(); break;
10289                case 21: jj_3_22(); break;
10290                case 22: jj_3_23(); break;
10291                case 23: jj_3_24(); break;
10292                case 24: jj_3_25(); break;
10293                case 25: jj_3_26(); break;
10294                case 26: jj_3_27(); break;
10295                case 27: jj_3_28(); break;
10296                case 28: jj_3_29(); break;
10297                case 29: jj_3_30(); break;
10298                case 30: jj_3_31(); break;
10299                case 31: jj_3_32(); break;
10300                case 32: jj_3_33(); break;
10301                case 33: jj_3_34(); break;
10302                case 34: jj_3_35(); break;
10303                case 35: jj_3_36(); break;
10304                case 36: jj_3_37(); break;
10305                case 37: jj_3_38(); break;
10306                case 38: jj_3_39(); break;
10307                case 39: jj_3_40(); break;
10308                case 40: jj_3_41(); break;
10309                case 41: jj_3_42(); break;
10310                case 42: jj_3_43(); break;
10311                case 43: jj_3_44(); break;
10312                case 44: jj_3_45(); break;
10313                case 45: jj_3_46(); break;
10314                case 46: jj_3_47(); break;
10315                case 47: jj_3_48(); break;
10316                case 48: jj_3_49(); break;
10317                case 49: jj_3_50(); break;
10318                case 50: jj_3_51(); break;
10319                case 51: jj_3_52(); break;
10320                case 52: jj_3_53(); break;
10321                case 53: jj_3_54(); break;
10322                case 54: jj_3_55(); break;
10323                case 55: jj_3_56(); break;
10324                case 56: jj_3_57(); break;
10325                case 57: jj_3_58(); break;
10326                case 58: jj_3_59(); break;
10327                case 59: jj_3_60(); break;
10328                case 60: jj_3_61(); break;
10329                case 61: jj_3_62(); break;
10330              }
10331            }
10332            p = p.next;
10333          } while (p != null);
10334          } catch(LookaheadSuccess ls) { }
10335        }
10336        jj_rescan = false;
10337      }
10338    
10339      private void jj_save(int index, int xla) {
10340        JJCalls p = jj_2_rtns[index];
10341        while (p.gen > jj_gen) {
10342          if (p.next == null) { p = p.next = new JJCalls(); break; }
10343          p = p.next;
10344        }
10345        p.gen = jj_gen + xla - jj_la; p.first = token; p.arg = xla;
10346      }
10347    
10348      static final class JJCalls {
10349        int gen;
10350        Token first;
10351        int arg;
10352        JJCalls next;
10353      }
10354    
10355    }