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