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