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