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