XJavaDoc - 1.1

Clover coverage report - XJavaDoc - 1.1
Coverage timestamp: Mon Oct 4 2004 23:49:51 BST
FRAMES NO FRAMES
file stats:	LOC:	7,948		Methods:	570
	NCLOC:	7,245		Classes:	3
30 day Evaluation Version distributed via the Maven Jar Repository. Clover is not free. You have 30 days to evaluate it. Please visit http://www.thecortex.net/clover to obtain a licensed version of Clover
Source file
Conditionals
Statements
Methods
TOTAL
SimpleParser.java
29.2%
44.3%
64.7%
40.1%
 /* Generated By:JavaCC: Do not edit this line. SimpleParser.java */
 package xjavadoc;
 
 import java.lang.reflect.Modifier;
 import java.util.*;
 import java.io.InputStream;
 import java.io.ByteArrayInputStream;
 
 public class SimpleParser implements JavaParser, SimpleParserConstants {
    private XJavaDoc _xJavaDoc;
    private XTagFactory _tagFactory;
 
    private String _packageName = "";
    // The class we're currently parsing
    private SourceClass _sourceClass;
    private Stack _sourceClassStack = new Stack();
 
    // Flag that tells us if the main class/interface has been parsed.
    // Needed to support more than one "outer" class in one source.
    private boolean _hasParsedMain = false;
 
 
    private static final void setToken(AbstractProgramElement element, Token token) {
        element.setToken( token );
        //element.setDoc(getJavaDocSpecialToken( token ));
    }
 
    private final void clearNameBuffer() {
       if( _nameBuffer.length() > 0 ) {
          _nameBuffer.delete(0, _nameBuffer.length());
       }
    }
 
    private final StringBuffer _nameBuffer = new StringBuffer();
 
    private static class Parameter {
       public String type;
       public String name;
       public int dimension;
    }
    private Parameter _parameter;
 
    // Reference to the first token in a Name() production.
    private Token _nameToken;
 
    /**
     * Should be called before UnmodifiedClassDeclaration or UnmodifiedInterfaceDeclaration
     */
    private SourceClass pushAndGet() {
        // Push a source class onto the stack. If the stack is empty,
        // push the outer class. Otherwise, instantiate a new (inner) class
        // and push that instead.
        SourceClass clazz = null;
        if( _sourceClassStack.isEmpty() ) {
           // It's an outer class. In rare cases there is more than one outer classes
           // in one source. handle that here.
           if( !_hasParsedMain ) {
              // the usual case
              clazz = _sourceClass;
           } else {
              // the source contains more than one classes
              clazz = new SourceClass(_sourceClass, 0, _tagFactory);
           }
        } else {
           clazz = new SourceClass(currentClass(), _tagFactory);
        }
        _sourceClassStack.push(clazz);
        return clazz;
    }
 
    /**
     * Should be called after UnmodifiedClassDeclaration or UnmodifiedInterfaceDeclaration
     */
    private void popAndAddInner() {
     SourceClass clazz = (SourceClass) _sourceClassStack.pop();
     if( clazz.getContainingClass() != null ) {
         // Add the class as an inner class
         currentClass().addInnerClass(clazz);
         _xJavaDoc.addSourceClass(clazz);
     }
    }
 
    private SourceClass currentClass() {
        return (SourceClass)_sourceClassStack.peek();
    }
 
     /** 
      * This constructor was added to allow the re-use of parsers.
      * The normal constructor takes a single argument which 
      * an InputStream. This simply creates a re-usable parser
      * object, we satisfy the requirement of an InputStream
      * by using a newline character as an input stream.
      */
     public SimpleParser( XJavaDoc xJavaDoc, XTagFactory tagFactory )
     {
         this(new ByteArrayInputStream("\n".getBytes()));
         _xJavaDoc = xJavaDoc;
         _tagFactory = tagFactory;
     }
 
     /** 
      * This was also added to allow parsers to be
      * re-usable. Normal JavaCC use entails passing an
      * input stream to the constructor and the parsing
      * process is carried out once. We want to be able
      * to re-use parsers: we do this by adding this
      * method and re-initializing the lexer with
      * the new stream that we want parsed.
      */
     public void populate(SourceClass sourceClass)
         throws ParseException
     {
         _sourceClass = sourceClass;
 
         // Reset state
         _sourceClassStack.clear();
         _packageName = "";
         _parameter = new Parameter();
         _nameToken = null;
         clearNameBuffer();
 
         try
         {
 
             // now reinit the Parser with this CharStream
             // 
             ReInit(sourceClass.getReader());
 
             // Start the parsing.
             CompilationUnit( sourceClass );
         }
         catch (ParseException pe)
         {
             throw new ParseException (pe.currentToken,
                 pe.expectedTokenSequences, pe.tokenImage);
         }
         catch (TokenMgrError tme)
         {
             throw new ParseException("Lexical error: " + tme.toString());
         }
     }
 
 /*****************************************
  * THE JAVA LANGUAGE GRAMMAR STARTS HERE *
  *****************************************/
 
 /*
  * Program structuring syntax follows.
  */
   final public void CompilationUnit(SourceClass sourceClass) throws ParseException {
     switch (jj_nt.kind) {
     case PACKAGE:
       PackageDeclaration();
       break;
     default:
       jj_la1[0] = jj_gen;
       ;
     }
     label_1:
     while (true) {
       switch (jj_nt.kind) {
       case IMPORT:
         ;
         break;
       default:
         jj_la1[1] = jj_gen;
         break label_1;
       }
       ImportDeclaration();
     }
     label_2:
     while (true) {
       switch (jj_nt.kind) {
       case ABSTRACT:
       case CLASS:
       case FINAL:
       case INTERFACE:
       case PUBLIC:
       case STRICTFP:
       case SEMICOLON:
         ;
         break;
       default:
         jj_la1[2] = jj_gen;
         break label_2;
       }
       TypeDeclaration();
     }
     jj_consume_token(0);
       // sourceClass must know about the CompilationUnit node
       // if it wants to mutate or print the code
       // In SimpleParser we can't use nodes
 
     if( _sourceClassStack.size() != 0 ) {
        {if (true) throw new IllegalStateException("There should be no more classes on the stack:" + _sourceClassStack.size());}
     }
   }
 
   final public void PackageDeclaration() throws ParseException {
     jj_consume_token(PACKAGE);
     _packageName = Name();
     jj_consume_token(SEMICOLON);
      _sourceClass.setContainingPackage( _packageName );
   }
 
   final public void ImportDeclaration() throws ParseException {
    String importedElement;
    boolean isPackage = false;
     jj_consume_token(IMPORT);
     importedElement = Name();
     switch (jj_nt.kind) {
     case DOT:
       jj_consume_token(DOT);
       jj_consume_token(STAR);
      isPackage = true;
       break;
     default:
       jj_la1[3] = jj_gen;
       ;
     }
     jj_consume_token(SEMICOLON);
      if( isPackage ) {
         _sourceClass.addImportedPackage(importedElement);
      } else {
         _sourceClass.addImportedClass(importedElement);
      }
   }
 
   final public void TypeDeclaration() throws ParseException {
     if (jj_2_1(2147483647)) {
       ClassDeclaration();
     _hasParsedMain = true;
     } else {
       switch (jj_nt.kind) {
       case ABSTRACT:
       case INTERFACE:
       case PUBLIC:
       case STRICTFP:
         InterfaceDeclaration();
     _hasParsedMain = true;
         break;
       case SEMICOLON:
         jj_consume_token(SEMICOLON);
         break;
       default:
         jj_la1[4] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
     }
   }
 
 /*
  * Declaration syntax follows.
  */
 
 /*
 Javadoc is stored in special tokens, and will either be
 attached to the first modifier token (if there are any modifiers)
 or to the first token in UnmodifiedClassDeclaration
 */
   final public void ClassDeclaration() throws ParseException {
    SourceClass sourceClass = pushAndGet();
    Token t = null;
     label_3:
     while (true) {
       switch (jj_nt.kind) {
       case ABSTRACT:
       case FINAL:
       case PUBLIC:
       case STRICTFP:
         ;
         break;
       default:
         jj_la1[5] = jj_gen;
         break label_3;
       }
       switch (jj_nt.kind) {
       case ABSTRACT:
         t = jj_consume_token(ABSTRACT);
        setToken(sourceClass, t);
        sourceClass.addModifier( Modifier.ABSTRACT );
         break;
       case FINAL:
         t = jj_consume_token(FINAL);
        setToken(sourceClass, t);
        sourceClass.addModifier( Modifier.FINAL );
         break;
       case PUBLIC:
         t = jj_consume_token(PUBLIC);
        setToken(sourceClass, t);
        sourceClass.addModifier( Modifier.PUBLIC );
         break;
       case STRICTFP:
         t = jj_consume_token(STRICTFP);
        setToken(sourceClass, t);
        sourceClass.addModifier( Modifier.STRICT );
         break;
       default:
         jj_la1[6] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
     }
     UnmodifiedClassDeclaration();
      popAndAddInner();
   }
 
   final public void UnmodifiedClassDeclaration() throws ParseException {
    // Get a ref to the containing class
    SourceClass sourceClass = currentClass();
 
    Token ct;
    Token name = null;
    String superclass = null;
     ct = jj_consume_token(CLASS);
         if(sourceClass!=null) {
             setToken( sourceClass, ct );
             sourceClass.setInterface( false );
         }
     name = jj_consume_token(IDENTIFIER);
     if(sourceClass.isInner()) {
         sourceClass.setName(name.image);
         _xJavaDoc.addPackageMaybe( _packageName ).addClass(sourceClass);
         _xJavaDoc.addSourceClass( sourceClass );
     } else {
         sourceClass.setQualifiedName(Util.getQualifiedNameFor(_packageName,name.image));
         _xJavaDoc.addPackageMaybe( _packageName ).addClass(sourceClass);
         _xJavaDoc.addSourceClass( sourceClass );
         sourceClass.resolveImportedClasses();
 
         // we're adding to xjavadoc in case we're an "extra" class (XJD-8).
         _xJavaDoc.addSourceClass(sourceClass);
     }
     switch (jj_nt.kind) {
     case EXTENDS:
       jj_consume_token(EXTENDS);
       superclass = Name();
       break;
     default:
       jj_la1[7] = jj_gen;
       ;
     }
     switch (jj_nt.kind) {
     case IMPLEMENTS:
       jj_consume_token(IMPLEMENTS);
       Interfaces_NameList();
       break;
     default:
       jj_la1[8] = jj_gen;
       ;
     }
     ClassBody();
     if( superclass != null ) {
         sourceClass.setSuperclass(superclass);
     } else {
         sourceClass.setSuperclass("java.lang.Object");
     }
   }
 
   final public void ClassBody() throws ParseException {
     jj_consume_token(LBRACE);
     label_4:
     while (true) {
       switch (jj_nt.kind) {
       case ABSTRACT:
       case BOOLEAN:
       case BYTE:
       case CHAR:
       case CLASS:
       case DOUBLE:
       case FINAL:
       case FLOAT:
       case INT:
       case INTERFACE:
       case LONG:
       case NATIVE:
       case PRIVATE:
       case PROTECTED:
       case PUBLIC:
       case SHORT:
       case STATIC:
       case SYNCHRONIZED:
       case TRANSIENT:
       case VOID:
       case VOLATILE:
       case STRICTFP:
       case IDENTIFIER:
       case LBRACE:
         ;
         break;
       default:
         jj_la1[9] = jj_gen;
         break label_4;
       }
       ClassBodyDeclaration();
     }
     jj_consume_token(RBRACE);
   }
 
   final public void NestedClassDeclaration() throws ParseException {
    SourceClass sourceClass = pushAndGet();
    Token t;
     label_5:
     while (true) {
       switch (jj_nt.kind) {
       case ABSTRACT:
       case FINAL:
       case PRIVATE:
       case PROTECTED:
       case PUBLIC:
       case STATIC:
       case STRICTFP:
         ;
         break;
       default:
         jj_la1[10] = jj_gen;
         break label_5;
       }
       switch (jj_nt.kind) {
       case STATIC:
         t = jj_consume_token(STATIC);
        sourceClass.addModifier( Modifier.STATIC );
        sourceClass.setToken( t );
         break;
       case ABSTRACT:
         t = jj_consume_token(ABSTRACT);
        sourceClass.addModifier( Modifier.ABSTRACT );
        sourceClass.setToken( t );
         break;
       case FINAL:
         t = jj_consume_token(FINAL);
        sourceClass.addModifier( Modifier.FINAL );
        sourceClass.setToken( t );
         break;
       case PUBLIC:
         t = jj_consume_token(PUBLIC);
        sourceClass.addModifier( Modifier.PUBLIC );
        sourceClass.setToken( t );
         break;
       case PROTECTED:
         t = jj_consume_token(PROTECTED);
        sourceClass.addModifier( Modifier.PROTECTED );
        sourceClass.setToken( t );
         break;
       case PRIVATE:
         t = jj_consume_token(PRIVATE);
        sourceClass.addModifier( Modifier.PRIVATE );
        sourceClass.setToken( t );
         break;
       case STRICTFP:
         t = jj_consume_token(STRICTFP);
        sourceClass.addModifier( Modifier.STRICT );
        sourceClass.setToken( t );
         break;
       default:
         jj_la1[11] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
     }
     UnmodifiedClassDeclaration();
     popAndAddInner();
   }
 
   final public void ClassBodyDeclaration() throws ParseException {
    SourceClass sourceClass = currentClass();
     if (jj_2_2(2)) {
       Initializer();
     } else if (jj_2_3(2147483647)) {
       NestedClassDeclaration();
     } else if (jj_2_4(2147483647)) {
       NestedInterfaceDeclaration();
     } else if (jj_2_5(2147483647)) {
       ConstructorDeclaration();
     } else if (jj_2_6(2147483647)) {
       MethodDeclaration();
     } else {
       switch (jj_nt.kind) {
       case BOOLEAN:
       case BYTE:
       case CHAR:
       case DOUBLE:
       case FINAL:
       case FLOAT:
       case INT:
       case LONG:
       case PRIVATE:
       case PROTECTED:
       case PUBLIC:
       case SHORT:
       case STATIC:
       case TRANSIENT:
       case VOLATILE:
       case IDENTIFIER:
         FieldDeclaration();
         break;
       default:
         jj_la1[12] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
     }
   }
 
 // This production is to determine lookahead only.
   final public void MethodDeclarationLookahead() throws ParseException {
     label_6:
     while (true) {
       switch (jj_nt.kind) {
       case ABSTRACT:
       case FINAL:
       case NATIVE:
       case PRIVATE:
       case PROTECTED:
       case PUBLIC:
       case STATIC:
       case SYNCHRONIZED:
       case STRICTFP:
         ;
         break;
       default:
         jj_la1[13] = jj_gen;
         break label_6;
       }
       switch (jj_nt.kind) {
       case PUBLIC:
         jj_consume_token(PUBLIC);
         break;
       case PROTECTED:
         jj_consume_token(PROTECTED);
         break;
       case PRIVATE:
         jj_consume_token(PRIVATE);
         break;
       case STATIC:
         jj_consume_token(STATIC);
         break;
       case ABSTRACT:
         jj_consume_token(ABSTRACT);
         break;
       case FINAL:
         jj_consume_token(FINAL);
         break;
       case NATIVE:
         jj_consume_token(NATIVE);
         break;
       case SYNCHRONIZED:
         jj_consume_token(SYNCHRONIZED);
         break;
       case STRICTFP:
         jj_consume_token(STRICTFP);
         break;
       default:
         jj_la1[14] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
     }
     ResultType(null);
     jj_consume_token(IDENTIFIER);
     jj_consume_token(LPAREN);
   }
 
   final public void InterfaceDeclaration() throws ParseException {
    SourceClass sourceClass = pushAndGet();
    Token t = null;
     label_7:
     while (true) {
       switch (jj_nt.kind) {
       case ABSTRACT:
       case PUBLIC:
       case STRICTFP:
         ;
         break;
       default:
         jj_la1[15] = jj_gen;
         break label_7;
       }
       switch (jj_nt.kind) {
       case ABSTRACT:
         t = jj_consume_token(ABSTRACT);
        sourceClass.addModifier( Modifier.ABSTRACT );
        sourceClass.setToken( t );
         break;
       case PUBLIC:
         t = jj_consume_token(PUBLIC);
        sourceClass.addModifier( Modifier.PUBLIC );
        sourceClass.setToken( t );
         break;
       case STRICTFP:
         t = jj_consume_token(STRICTFP);
        sourceClass.addModifier( Modifier.STRICT );
        sourceClass.setToken( t );
         break;
       default:
         jj_la1[16] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
     }
     UnmodifiedInterfaceDeclaration();
      popAndAddInner();
   }
 
   final public void NestedInterfaceDeclaration() throws ParseException {
    SourceClass sourceClass = pushAndGet();
    Token t;
     label_8:
     while (true) {
       switch (jj_nt.kind) {
       case ABSTRACT:
       case FINAL:
       case PRIVATE:
       case PROTECTED:
       case PUBLIC:
       case STATIC:
       case STRICTFP:
         ;
         break;
       default:
         jj_la1[17] = jj_gen;
         break label_8;
       }
       switch (jj_nt.kind) {
       case STATIC:
         t = jj_consume_token(STATIC);
        sourceClass.addModifier( Modifier.STATIC );
        sourceClass.setToken( t );
         break;
       case ABSTRACT:
         t = jj_consume_token(ABSTRACT);
        sourceClass.addModifier( Modifier.ABSTRACT );
        sourceClass.setToken( t );
         break;
       case FINAL:
         t = jj_consume_token(FINAL);
        sourceClass.addModifier( Modifier.FINAL );
        sourceClass.setToken( t );
         break;
       case PUBLIC:
         t = jj_consume_token(PUBLIC);
        sourceClass.addModifier( Modifier.PUBLIC );
        sourceClass.setToken( t );
         break;
       case PROTECTED:
         t = jj_consume_token(PROTECTED);
        sourceClass.addModifier( Modifier.PROTECTED );
        sourceClass.setToken( t );
         break;
       case PRIVATE:
         t = jj_consume_token(PRIVATE);
        sourceClass.addModifier( Modifier.PRIVATE );
        sourceClass.setToken( t );
         break;
       case STRICTFP:
         t = jj_consume_token(STRICTFP);
        sourceClass.addModifier( Modifier.STRICT );
        sourceClass.setToken( t );
         break;
       default:
         jj_la1[18] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
     }
     UnmodifiedInterfaceDeclaration();
     popAndAddInner();
   }
 
   final public void UnmodifiedInterfaceDeclaration() throws ParseException {
    SourceClass sourceClass = currentClass();
    Token it;
    Token name = null;
     it = jj_consume_token(INTERFACE);
     name = jj_consume_token(IDENTIFIER);
       // interfaces are always abstract
       sourceClass.addModifier( Modifier.ABSTRACT );
 
       if(sourceClass.isInner()) {
         sourceClass.setName(name.image);
         _xJavaDoc.addPackageMaybe( _packageName ).addClass(sourceClass);
         _xJavaDoc.addSourceClass( sourceClass );
       } else {
         sourceClass.setQualifiedName(Util.getQualifiedNameFor(_packageName,name.image));
         _xJavaDoc.addPackageMaybe( _packageName ).addClass(sourceClass);
         _xJavaDoc.addSourceClass( sourceClass );
         sourceClass.resolveImportedClasses();
       }
 
       sourceClass.setInterface( true );
       setToken(sourceClass,it);
     switch (jj_nt.kind) {
     case EXTENDS:
       jj_consume_token(EXTENDS);
       Interfaces_NameList();
       break;
     default:
       jj_la1[19] = jj_gen;
       ;
     }
     jj_consume_token(LBRACE);
     label_9:
     while (true) {
       switch (jj_nt.kind) {
       case ABSTRACT:
       case BOOLEAN:
       case BYTE:
       case CHAR:
       case CLASS:
       case DOUBLE:
       case FINAL:
       case FLOAT:
       case INT:
       case INTERFACE:
       case LONG:
       case NATIVE:
       case PRIVATE:
       case PROTECTED:
       case PUBLIC:
       case SHORT:
       case STATIC:
       case SYNCHRONIZED:
       case TRANSIENT:
       case VOID:
       case VOLATILE:
       case STRICTFP:
       case IDENTIFIER:
         ;
         break;
       default:
         jj_la1[20] = jj_gen;
         break label_9;
       }
       InterfaceMemberDeclaration();
     }
     jj_consume_token(RBRACE);
     if(sourceClass.isInner()) {
         sourceClass.setName(name.image);
     }
   }
 
   final public void InterfaceMemberDeclaration() throws ParseException {
     if (jj_2_7(2147483647)) {
       NestedClassDeclaration();
     } else if (jj_2_8(2147483647)) {
       NestedInterfaceDeclaration();
     } else if (jj_2_9(2147483647)) {
       MethodDeclaration();
     } else {
       switch (jj_nt.kind) {
       case BOOLEAN:
       case BYTE:
       case CHAR:
       case DOUBLE:
       case FINAL:
       case FLOAT:
       case INT:
       case LONG:
       case PRIVATE:
       case PROTECTED:
       case PUBLIC:
       case SHORT:
       case STATIC:
       case TRANSIENT:
       case VOLATILE:
       case IDENTIFIER:
         FieldDeclaration();
         break;
       default:
         jj_la1[21] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
     }
   }
 
   final public void FieldDeclaration() throws ParseException {
    SourceClass sourceClass = currentClass();
 
    /* NOTE: We also support lame style like
 
    private static int a,b,c,d;
 
    They should share the same javadoc, type and modifiers
    */
 
    Token t = null;
    FieldImpl fieldImpl = null;
    fieldImpl = new FieldImpl(sourceClass, _tagFactory);
     label_10:
     while (true) {
       switch (jj_nt.kind) {
       case FINAL:
       case PRIVATE:
       case PROTECTED:
       case PUBLIC:
       case STATIC:
       case TRANSIENT:
       case VOLATILE:
         ;
         break;
       default:
         jj_la1[22] = jj_gen;
         break label_10;
       }
       switch (jj_nt.kind) {
       case PUBLIC:
         t = jj_consume_token(PUBLIC);
        fieldImpl.addModifier( Modifier.PUBLIC );
        setToken(fieldImpl,t);
         break;
       case PROTECTED:
         t = jj_consume_token(PROTECTED);
        fieldImpl.addModifier( Modifier.PROTECTED );
        setToken(fieldImpl,t);
         break;
       case PRIVATE:
         t = jj_consume_token(PRIVATE);
        fieldImpl.addModifier( Modifier.PRIVATE );
        setToken(fieldImpl,t);
         break;
       case STATIC:
         t = jj_consume_token(STATIC);
        fieldImpl.addModifier( Modifier.STATIC );
        setToken(fieldImpl,t);
         break;
       case FINAL:
         t = jj_consume_token(FINAL);
        fieldImpl.addModifier( Modifier.FINAL );
        setToken(fieldImpl,t);
         break;
       case TRANSIENT:
         t = jj_consume_token(TRANSIENT);
        fieldImpl.addModifier( Modifier.TRANSIENT );
        setToken(fieldImpl,t);
         break;
       case VOLATILE:
         t = jj_consume_token(VOLATILE);
        fieldImpl.addModifier( Modifier.VOLATILE );
        setToken(fieldImpl,t);
         break;
       default:
         jj_la1[23] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
     }
     Field_Type(fieldImpl);
     FieldDeclarator(fieldImpl);
     label_11:
     while (true) {
       switch (jj_nt.kind) {
       case COMMA:
         ;
         break;
       default:
         jj_la1[24] = jj_gen;
         break label_11;
       }
       jj_consume_token(COMMA);
         FieldImpl badProgrammingStyleFieldImpl = new FieldImpl(sourceClass, _tagFactory);
         badProgrammingStyleFieldImpl.setType(fieldImpl.getTypeAsString());
       FieldDeclarator(badProgrammingStyleFieldImpl);
         sourceClass.addField(badProgrammingStyleFieldImpl);
     }
     jj_consume_token(SEMICOLON);
     // we must add the field after parsing the field because the name must be set
     sourceClass.addField(fieldImpl);
   }
 
   final public void FieldDeclarator(FieldImpl fieldImpl) throws ParseException {
     Field_VariableDeclaratorId(fieldImpl);
     switch (jj_nt.kind) {
     case ASSIGN:
       jj_consume_token(ASSIGN);
       VariableInitializer();
       break;
     default:
       jj_la1[25] = jj_gen;
       ;
     }
   }
 
   final public void VariableDeclarator() throws ParseException {
     VariableDeclaratorId();
     switch (jj_nt.kind) {
     case ASSIGN:
       jj_consume_token(ASSIGN);
       VariableInitializer();
       break;
     default:
       jj_la1[26] = jj_gen;
       ;
     }
   }
 
   final public void Field_VariableDeclaratorId(FieldImpl fieldImpl) throws ParseException {
    Token t = null;
     t = jj_consume_token(IDENTIFIER);
     label_12:
     while (true) {
       switch (jj_nt.kind) {
       case LBRACKET:
         ;
         break;
       default:
         jj_la1[27] = jj_gen;
         break label_12;
       }
       jj_consume_token(LBRACKET);
       jj_consume_token(RBRACKET);
                              fieldImpl.setDimension(fieldImpl.getDimension() + 1);
     }
      fieldImpl.setName( t.image );
   }
 
   final public void Parameter_VariableDeclaratorId() throws ParseException {
    Token t = null;
     t = jj_consume_token(IDENTIFIER);
     label_13:
     while (true) {
       switch (jj_nt.kind) {
       case LBRACKET:
         ;
         break;
       default:
         jj_la1[28] = jj_gen;
         break label_13;
       }
       jj_consume_token(LBRACKET);
       jj_consume_token(RBRACKET);
                              _parameter.dimension++;
     }
      _parameter.name = t.image;
   }
 
   final public void VariableDeclaratorId() throws ParseException {
     jj_consume_token(IDENTIFIER);
     label_14:
     while (true) {
       switch (jj_nt.kind) {
       case LBRACKET:
         ;
         break;
       default:
         jj_la1[29] = jj_gen;
         break label_14;
       }
       jj_consume_token(LBRACKET);
       jj_consume_token(RBRACKET);
     }
   }
 
   final public void VariableInitializer() throws ParseException {
     switch (jj_nt.kind) {
     case LBRACE:
       ArrayInitializer();
       break;
     case BOOLEAN:
     case BYTE:
     case CHAR:
     case DOUBLE:
     case FALSE:
     case FLOAT:
     case INT:
     case LONG:
     case NEW:
     case NULL:
     case SHORT:
     case SUPER:
     case THIS:
     case TRUE:
     case VOID:
     case INTEGER_LITERAL:
     case FLOATING_POINT_LITERAL:
     case CHARACTER_LITERAL:
     case STRING_LITERAL:
     case IDENTIFIER:
     case LPAREN:
     case BANG:
     case TILDE:
     case INCR:
     case DECR:
     case PLUS:
     case MINUS:
       Expression();
       break;
     default:
       jj_la1[30] = jj_gen;
       jj_consume_token(-1);
       throw new ParseException();
     }
   }
 
   final public void ArrayInitializer() throws ParseException {
     jj_consume_token(LBRACE);
     switch (jj_nt.kind) {
     case BOOLEAN:
     case BYTE:
     case CHAR:
     case DOUBLE:
     case FALSE:
     case FLOAT:
     case INT:
     case LONG:
     case NEW:
     case NULL:
     case SHORT:
     case SUPER:
     case THIS:
     case TRUE:
     case VOID:
     case INTEGER_LITERAL:
     case FLOATING_POINT_LITERAL:
     case CHARACTER_LITERAL:
     case STRING_LITERAL:
     case IDENTIFIER:
     case LPAREN:
     case LBRACE:
     case BANG:
     case TILDE:
     case INCR:
     case DECR:
     case PLUS:
     case MINUS:
       VariableInitializer();
       label_15:
       while (true) {
         if (jj_2_10(2)) {
           ;
         } else {
           break label_15;
         }
         jj_consume_token(COMMA);
         VariableInitializer();
       }
       break;
     default:
       jj_la1[31] = jj_gen;
       ;
     }
     switch (jj_nt.kind) {
     case COMMA:
       jj_consume_token(COMMA);
       break;
     default:
       jj_la1[32] = jj_gen;
       ;
     }
     jj_consume_token(RBRACE);
   }
 
   final public void MethodDeclaration() throws ParseException {
    SourceClass sourceClass = currentClass();
 
    Token t = null;
    String exceptions = null;
 
    //this may remain null for anonymous inner classes (sourceClass==null), not a problem because we're not going to access class structure of an anonymous inner class
    MethodImpl methodImpl = null;
 
     if(sourceClass!=null) {
        methodImpl = new MethodImpl(sourceClass, _tagFactory);
     }
     label_16:
     while (true) {
       switch (jj_nt.kind) {
       case ABSTRACT:
       case FINAL:
       case NATIVE:
       case PRIVATE:
       case PROTECTED:
       case PUBLIC:
       case STATIC:
       case SYNCHRONIZED:
       case STRICTFP:
         ;
         break;
       default:
         jj_la1[33] = jj_gen;
         break label_16;
       }
       switch (jj_nt.kind) {
       case PUBLIC:
         t = jj_consume_token(PUBLIC);
         if(methodImpl!=null) {
             methodImpl.addModifier( Modifier.PUBLIC );
             setToken( methodImpl, t );
         }
         break;
       case PROTECTED:
         t = jj_consume_token(PROTECTED);
         if(methodImpl!=null) {
             methodImpl.addModifier( Modifier.PROTECTED );
             setToken( methodImpl, t );
         }
         break;
       case PRIVATE:
         t = jj_consume_token(PRIVATE);
         if(methodImpl!=null) {
             methodImpl.addModifier( Modifier.PRIVATE );
             setToken( methodImpl, t );
         }
         break;
       case STATIC:
         t = jj_consume_token(STATIC);
         if(methodImpl!=null) {
             methodImpl.addModifier( Modifier.STATIC );
             setToken( methodImpl, t );
         }
         break;
       case ABSTRACT:
         t = jj_consume_token(ABSTRACT);
         if(methodImpl!=null) {
             methodImpl.addModifier( Modifier.ABSTRACT );
             setToken( methodImpl, t );
         }
         break;
       case FINAL:
         t = jj_consume_token(FINAL);
         if(methodImpl!=null) {
             methodImpl.addModifier( Modifier.FINAL );
             setToken( methodImpl, t );
         }
         break;
       case NATIVE:
         t = jj_consume_token(NATIVE);
         if(methodImpl!=null) {
             methodImpl.addModifier( Modifier.NATIVE );
             setToken( methodImpl, t );
         }
         break;
       case SYNCHRONIZED:
         t = jj_consume_token(SYNCHRONIZED);
         if(methodImpl!=null) {
             methodImpl.addModifier( Modifier.SYNCHRONIZED );
             setToken( methodImpl, t );
         }
         break;
       case STRICTFP:
         t = jj_consume_token(STRICTFP);
         if(methodImpl!=null) {
             methodImpl.addModifier( Modifier.STRICT );
             setToken( methodImpl, t );
         }
         break;
       default:
         jj_la1[34] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
     }
     ResultType(methodImpl);
     MethodDeclarator(methodImpl);
     switch (jj_nt.kind) {
     case THROWS:
       jj_consume_token(THROWS);
       ExecutableMemberThrows_NameList(methodImpl);
       break;
     default:
       jj_la1[35] = jj_gen;
       ;
     }
     switch (jj_nt.kind) {
     case LBRACE:
       Method_Block();
       break;
     case SEMICOLON:
       jj_consume_token(SEMICOLON);
       break;
     default:
       jj_la1[36] = jj_gen;
       jj_consume_token(-1);
       throw new ParseException();
     }
     // we must add the method after the fields are in, because the
     // signature must be complete when adding
     sourceClass.addMethod(methodImpl);
   }
 
   final public void MethodDeclarator(MethodImpl methodImpl) throws ParseException {
    Token t = null;
     t = jj_consume_token(IDENTIFIER);
      if( methodImpl != null ) {
         methodImpl.setName( t.image );
      }
     FormalParameters(methodImpl);
     label_17:
     while (true) {
       switch (jj_nt.kind) {
       case LBRACKET:
         ;
         break;
       default:
         jj_la1[37] = jj_gen;
         break label_17;
       }
       jj_consume_token(LBRACKET);
       jj_consume_token(RBRACKET);
      methodImpl.setReturnDimension( methodImpl.getReturnType().getDimension() + 1 );
     }
   }
 
   final public void FormalParameters(AbstractExecutableMember member) throws ParseException {
     jj_consume_token(LPAREN);
     switch (jj_nt.kind) {
     case BOOLEAN:
     case BYTE:
     case CHAR:
     case DOUBLE:
     case FINAL:
     case FLOAT:
     case INT:
     case LONG:
     case SHORT:
     case IDENTIFIER:
       FormalParameter(member);
       label_18:
       while (true) {
         switch (jj_nt.kind) {
         case COMMA:
           ;
           break;
         default:
           jj_la1[38] = jj_gen;
           break label_18;
         }
         jj_consume_token(COMMA);
         FormalParameter(member);
       }
       break;
     default:
       jj_la1[39] = jj_gen;
       ;
     }
     jj_consume_token(RPAREN);
   }
 
   final public void FormalParameter(AbstractExecutableMember member) throws ParseException {
    if(member != null) {
       // reset the _parameter helper's dimension
       _parameter.dimension = 0;
    }
     switch (jj_nt.kind) {
     case FINAL:
       jj_consume_token(FINAL);
       break;
     default:
       jj_la1[40] = jj_gen;
       ;
     }
     Parameter_Type();
     Parameter_VariableDeclaratorId();
      if( member != null ) {
         member.addParameterData(_parameter.type, _parameter.name, _parameter.dimension);
      }
   }
 
   final public void ConstructorDeclaration() throws ParseException {
    SourceClass sourceClass = currentClass();
    Token t = null;
    ConstructorImpl constructor = constructor = new ConstructorImpl(sourceClass, _tagFactory);
     switch (jj_nt.kind) {
     case PRIVATE:
     case PROTECTED:
     case PUBLIC:
       switch (jj_nt.kind) {
       case PUBLIC:
         t = jj_consume_token(PUBLIC);
        constructor.addModifier( Modifier.PUBLIC );
        setToken( constructor, t );
         break;
       case PROTECTED:
         t = jj_consume_token(PROTECTED);
        constructor.addModifier( Modifier.PROTECTED );
        setToken( constructor, t );
         break;
       case PRIVATE:
         t = jj_consume_token(PRIVATE);
        constructor.addModifier( Modifier.PRIVATE );
        setToken( constructor, t );
         break;
       default:
         jj_la1[41] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
       break;
     default:
       jj_la1[42] = jj_gen;
       ;
     }
     jj_consume_token(IDENTIFIER);
     FormalParameters(constructor);
     switch (jj_nt.kind) {
     case THROWS:
       jj_consume_token(THROWS);
       ExecutableMemberThrows_NameList(constructor);
       break;
     default:
       jj_la1[43] = jj_gen;
       ;
     }
     jj_consume_token(LBRACE);
     if (jj_2_11(2147483647)) {
       ExplicitConstructorInvocation();
     } else {
       ;
     }
     label_19:
     while (true) {
       switch (jj_nt.kind) {
       case BOOLEAN:
       case BREAK:
       case BYTE:
       case CHAR:
       case CLASS:
       case CONTINUE:
       case DO:
       case DOUBLE:
       case FALSE:
       case FINAL:
       case FLOAT:
       case FOR:
       case IF:
       case INT:
       case INTERFACE:
       case LONG:
       case NEW:
       case NULL:
       case RETURN:
       case SHORT:
       case SUPER:
       case SWITCH:
       case SYNCHRONIZED:
       case THIS:
       case THROW:
       case TRUE:
       case TRY:
       case VOID:
       case WHILE:
       case ASSERT:
       case INTEGER_LITERAL:
       case FLOATING_POINT_LITERAL:
       case CHARACTER_LITERAL:
       case STRING_LITERAL:
       case IDENTIFIER:
       case LPAREN:
       case LBRACE:
       case SEMICOLON:
       case INCR:
       case DECR:
         ;
         break;
       default:
         jj_la1[44] = jj_gen;
         break label_19;
       }
       BlockStatement();
     }
     jj_consume_token(RBRACE);
     // we must add the method after the fields are in, because the
     // signature must be complete when adding
     sourceClass.addConstructor(constructor);
   }
 
   final public void ExplicitConstructorInvocation() throws ParseException {
     if (jj_2_13(2147483647)) {
       jj_consume_token(THIS);
       Arguments();
       jj_consume_token(SEMICOLON);
     } else {
       switch (jj_nt.kind) {
       case BOOLEAN:
       case BYTE:
       case CHAR:
       case DOUBLE:
       case FALSE:
       case FLOAT:
       case INT:
       case LONG:
       case NEW:
       case NULL:
       case SHORT:
       case SUPER:
       case THIS:
       case TRUE:
       case VOID:
       case INTEGER_LITERAL:
       case FLOATING_POINT_LITERAL:
       case CHARACTER_LITERAL:
       case STRING_LITERAL:
       case IDENTIFIER:
       case LPAREN:
         if (jj_2_12(2)) {
           PrimaryExpression();
           jj_consume_token(DOT);
         } else {
           ;
         }
         jj_consume_token(SUPER);
         Arguments();
         jj_consume_token(SEMICOLON);
         break;
       default:
         jj_la1[45] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
     }
   }
 
   final public void Initializer() throws ParseException {
     switch (jj_nt.kind) {
     case STATIC:
       jj_consume_token(STATIC);
       break;
     default:
       jj_la1[46] = jj_gen;
       ;
     }
     Block();
   }
 
 /*
  * Type, name and expression syntax follows.
  */
   final public void Field_Type(FieldImpl fieldImpl) throws ParseException {
    Token typeToken;
    String type;
     switch (jj_nt.kind) {
     case BOOLEAN:
     case BYTE:
     case CHAR:
     case DOUBLE:
     case FLOAT:
     case INT:
     case LONG:
     case SHORT:
       typeToken = PrimitiveType();
       if( fieldImpl != null ) {
         fieldImpl.setType(typeToken.image);
         setToken( fieldImpl, typeToken );
       }
       break;
     case IDENTIFIER:
       type = Name();
       if( fieldImpl != null ) {
         fieldImpl.setType(type);
         setToken( fieldImpl, _nameToken );
       }
       break;
     default:
       jj_la1[47] = jj_gen;
       jj_consume_token(-1);
       throw new ParseException();
     }
     label_20:
     while (true) {
       switch (jj_nt.kind) {
       case LBRACKET:
         ;
         break;
       default:
         jj_la1[48] = jj_gen;
         break label_20;
       }
       jj_consume_token(LBRACKET);
       jj_consume_token(RBRACKET);
      if( fieldImpl != null ) {
         fieldImpl.setDimension(fieldImpl.getDimension() + 1);
      }
     }
   }
 
   final public void MethodResult_Type(MethodImpl methodImpl) throws ParseException {
    Token typeToken;
    String type;
     switch (jj_nt.kind) {
     case BOOLEAN:
     case BYTE:
     case CHAR:
     case DOUBLE:
     case FLOAT:
     case INT:
     case LONG:
     case SHORT:
       typeToken = PrimitiveType();
       if( methodImpl != null ) {
         methodImpl.setReturnType(typeToken.image);
         setToken( methodImpl, typeToken );
       }
       break;
     case IDENTIFIER:
       type = Name();
       if( methodImpl != null ) {
         methodImpl.setReturnType(type);
         setToken( methodImpl, _nameToken );
       }
       break;
     default:
       jj_la1[49] = jj_gen;
       jj_consume_token(-1);
       throw new ParseException();
     }
     label_21:
     while (true) {
       switch (jj_nt.kind) {
       case LBRACKET:
         ;
         break;
       default:
         jj_la1[50] = jj_gen;
         break label_21;
       }
       jj_consume_token(LBRACKET);
       jj_consume_token(RBRACKET);
      if( methodImpl != null ) {
         methodImpl.setReturnDimension(methodImpl.getReturnType().getDimension() + 1);
      }
     }
   }
 
   final public void Parameter_Type() throws ParseException {
    Token primitive;
    String name;
     switch (jj_nt.kind) {
     case BOOLEAN:
     case BYTE:
     case CHAR:
     case DOUBLE:
     case FLOAT:
     case INT:
     case LONG:
     case SHORT:
       primitive = PrimitiveType();
        _parameter.type = primitive.image;
       break;
     case IDENTIFIER:
       name = Name();
        _parameter.type = name;
       break;
     default:
       jj_la1[51] = jj_gen;
       jj_consume_token(-1);
       throw new ParseException();
     }
     label_22:
     while (true) {
       switch (jj_nt.kind) {
       case LBRACKET:
         ;
         break;
       default:
         jj_la1[52] = jj_gen;
         break label_22;
       }
       jj_consume_token(LBRACKET);
       jj_consume_token(RBRACKET);
               _parameter.dimension++;
     }
   }
 
   final public void Type() throws ParseException {
     switch (jj_nt.kind) {
     case BOOLEAN:
     case BYTE:
     case CHAR:
     case DOUBLE:
     case FLOAT:
     case INT:
     case LONG:
     case SHORT:
       PrimitiveType();
       break;
     case IDENTIFIER:
       Name();
       break;
     default:
       jj_la1[53] = jj_gen;
       jj_consume_token(-1);
       throw new ParseException();
     }
     label_23:
     while (true) {
       switch (jj_nt.kind) {
       case LBRACKET:
         ;
         break;
       default:
         jj_la1[54] = jj_gen;
         break label_23;
       }
       jj_consume_token(LBRACKET);
       jj_consume_token(RBRACKET);
     }
   }
 
   final public Token PrimitiveType() throws ParseException {
    Token t = null;
     switch (jj_nt.kind) {
     case BOOLEAN:
       t = jj_consume_token(BOOLEAN);
                 {if (true) return t;}
       break;
     case CHAR:
       t = jj_consume_token(CHAR);
              {if (true) return t;}
       break;
     case BYTE:
       t = jj_consume_token(BYTE);
              {if (true) return t;}
       break;
     case SHORT:
       t = jj_consume_token(SHORT);
               {if (true) return t;}
       break;
     case INT:
       t = jj_consume_token(INT);
             {if (true) return t;}
       break;
     case LONG:
       t = jj_consume_token(LONG);
              {if (true) return t;}
       break;
     case FLOAT:
       t = jj_consume_token(FLOAT);
               {if (true) return t;}
       break;
     case DOUBLE:
       t = jj_consume_token(DOUBLE);
                {if (true) return t;}
       break;
     default:
       jj_la1[55] = jj_gen;
       jj_consume_token(-1);
       throw new ParseException();
     }
     throw new Error("Missing return statement in function");
   }
 
   final public void ResultType(MethodImpl methodImpl) throws ParseException {
    Token t = null;
     switch (jj_nt.kind) {
     case VOID:
       t = jj_consume_token(VOID);
      if( methodImpl != null ) {
         methodImpl.setReturnType( "void" );
         methodImpl.setReturnDimension( 0 );
         setToken( methodImpl, t );
      }
       break;
     case BOOLEAN:
     case BYTE:
     case CHAR:
     case DOUBLE:
     case FLOAT:
     case INT:
     case LONG:
     case SHORT:
     case IDENTIFIER:
       MethodResult_Type(methodImpl);
       break;
     default:
       jj_la1[56] = jj_gen;
       jj_consume_token(-1);
       throw new ParseException();
     }
   }
 
   final public String Name() throws ParseException {
    // reset the buffer
    clearNameBuffer();
    Token t = null;
     _nameToken = jj_consume_token(IDENTIFIER);
      _nameBuffer.append(_nameToken.image);
     label_24:
     while (true) {
       if (jj_2_14(2)) {
         ;
       } else {
         break label_24;
       }
       jj_consume_token(DOT);
       t = jj_consume_token(IDENTIFIER);
      _nameBuffer.append(".").append(t.image);
     }
      {if (true) return _nameBuffer.toString();}
     throw new Error("Missing return statement in function");
   }
 
   final public void ExecutableMemberThrows_Name(AbstractExecutableMember member) throws ParseException {
    // reset the buffer
    clearNameBuffer();
    Token t = null;
     t = jj_consume_token(IDENTIFIER);
      _nameBuffer.append(t.image);
     label_25:
     while (true) {
       switch (jj_nt.kind) {
       case DOT:
         ;
         break;
       default:
         jj_la1[57] = jj_gen;
         break label_25;
       }
       jj_consume_token(DOT);
       t = jj_consume_token(IDENTIFIER);
      _nameBuffer.append(".").append(t.image);
     }
      if( member != null ) {
         member.addThrownException( _nameBuffer.toString() );
      }
   }
 
   final public void Interfaces_Name() throws ParseException {
    SourceClass sourceClass = currentClass();
 
    // reset the buffer
    clearNameBuffer();
    Token t = null;
     t = jj_consume_token(IDENTIFIER);
      _nameBuffer.append(t.image);
     label_26:
     while (true) {
       switch (jj_nt.kind) {
       case DOT:
         ;
         break;
       default:
         jj_la1[58] = jj_gen;
         break label_26;
       }
       jj_consume_token(DOT);
       t = jj_consume_token(IDENTIFIER);
      _nameBuffer.append(".").append(t.image);
     }
      sourceClass.addInterface( _nameBuffer.toString() );
   }
 
   final public void NameList() throws ParseException {
     Name();
     label_27:
     while (true) {
       switch (jj_nt.kind) {
       case COMMA:
         ;
         break;
       default:
         jj_la1[59] = jj_gen;
         break label_27;
       }
       jj_consume_token(COMMA);
       Name();
     }
   }
 
   final public void ExecutableMemberThrows_NameList(AbstractExecutableMember member) throws ParseException {
     ExecutableMemberThrows_Name(member);
     label_28:
     while (true) {
       switch (jj_nt.kind) {
       case COMMA:
         ;
         break;
       default:
         jj_la1[60] = jj_gen;
         break label_28;
       }
       jj_consume_token(COMMA);
       ExecutableMemberThrows_Name(member);
     }
   }
 
   final public void Interfaces_NameList() throws ParseException {
     Interfaces_Name();
     label_29:
     while (true) {
       switch (jj_nt.kind) {
       case COMMA:
         ;
         break;
       default:
         jj_la1[61] = jj_gen;
         break label_29;
       }
       jj_consume_token(COMMA);
       Interfaces_Name();
     }
   }
 
 /*
  * Expression syntax follows.
  */
   final public void Expression() throws ParseException {
     ConditionalExpression();
     switch (jj_nt.kind) {
     case ASSIGN:
     case PLUSASSIGN:
     case MINUSASSIGN:
     case STARASSIGN:
     case SLASHASSIGN:
     case ANDASSIGN:
     case ORASSIGN:
     case XORASSIGN:
     case REMASSIGN:
     case LSHIFTASSIGN:
     case RSIGNEDSHIFTASSIGN:
     case RUNSIGNEDSHIFTASSIGN:
       AssignmentOperator();
       Expression();
       break;
     default:
       jj_la1[62] = jj_gen;
       ;
     }
   }
 
   final public void AssignmentOperator() throws ParseException {
     switch (jj_nt.kind) {
     case ASSIGN:
       jj_consume_token(ASSIGN);
       break;
     case STARASSIGN:
       jj_consume_token(STARASSIGN);
       break;
     case SLASHASSIGN:
       jj_consume_token(SLASHASSIGN);
       break;
     case REMASSIGN:
       jj_consume_token(REMASSIGN);
       break;
     case PLUSASSIGN:
       jj_consume_token(PLUSASSIGN);
       break;
     case MINUSASSIGN:
       jj_consume_token(MINUSASSIGN);
       break;
     case LSHIFTASSIGN:
       jj_consume_token(LSHIFTASSIGN);
       break;
     case RSIGNEDSHIFTASSIGN:
       jj_consume_token(RSIGNEDSHIFTASSIGN);
       break;
     case RUNSIGNEDSHIFTASSIGN:
       jj_consume_token(RUNSIGNEDSHIFTASSIGN);
       break;
     case ANDASSIGN:
       jj_consume_token(ANDASSIGN);
       break;
     case XORASSIGN:
       jj_consume_token(XORASSIGN);
       break;
     case ORASSIGN:
       jj_consume_token(ORASSIGN);
       break;
     default:
       jj_la1[63] = jj_gen;
       jj_consume_token(-1);
       throw new ParseException();
     }
   }
 
   final public void ConditionalExpression() throws ParseException {
     ConditionalOrExpression();
     switch (jj_nt.kind) {
     case HOOK:
       jj_consume_token(HOOK);
       Expression();
       jj_consume_token(COLON);
       ConditionalExpression();
       break;
     default:
       jj_la1[64] = jj_gen;
       ;
     }
   }
 
   final public void ConditionalOrExpression() throws ParseException {
     ConditionalAndExpression();
     label_30:
     while (true) {
       switch (jj_nt.kind) {
       case SC_OR:
         ;
         break;
       default:
         jj_la1[65] = jj_gen;
         break label_30;
       }
       jj_consume_token(SC_OR);
       ConditionalAndExpression();
     }
   }
 
   final public void ConditionalAndExpression() throws ParseException {
     InclusiveOrExpression();
     label_31:
     while (true) {
       switch (jj_nt.kind) {
       case SC_AND:
         ;
         break;
       default:
         jj_la1[66] = jj_gen;
         break label_31;
       }
       jj_consume_token(SC_AND);
       InclusiveOrExpression();
     }
   }
 
   final public void InclusiveOrExpression() throws ParseException {
     ExclusiveOrExpression();
     label_32:
     while (true) {
       switch (jj_nt.kind) {
       case BIT_OR:
         ;
         break;
       default:
         jj_la1[67] = jj_gen;
         break label_32;
       }
       jj_consume_token(BIT_OR);
       ExclusiveOrExpression();
     }
   }
 
   final public void ExclusiveOrExpression() throws ParseException {
     AndExpression();
     label_33:
     while (true) {
       switch (jj_nt.kind) {
       case XOR:
         ;
         break;
       default:
         jj_la1[68] = jj_gen;
         break label_33;
       }
       jj_consume_token(XOR);
       AndExpression();
     }
   }
 
   final public void AndExpression() throws ParseException {
     EqualityExpression();
     label_34:
     while (true) {
       switch (jj_nt.kind) {
       case BIT_AND:
         ;
         break;
       default:
         jj_la1[69] = jj_gen;
         break label_34;
       }
       jj_consume_token(BIT_AND);
       EqualityExpression();
     }
   }
 
   final public void EqualityExpression() throws ParseException {
     InstanceOfExpression();
     label_35:
     while (true) {
       switch (jj_nt.kind) {
       case EQ:
       case NE:
         ;
         break;
       default:
         jj_la1[70] = jj_gen;
         break label_35;
       }
       switch (jj_nt.kind) {
       case EQ:
         jj_consume_token(EQ);
         break;
       case NE:
         jj_consume_token(NE);
         break;
       default:
         jj_la1[71] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
       InstanceOfExpression();
     }
   }
 
   final public void InstanceOfExpression() throws ParseException {
     RelationalExpression();
     switch (jj_nt.kind) {
     case INSTANCEOF:
       jj_consume_token(INSTANCEOF);
       Type();
       break;
     default:
       jj_la1[72] = jj_gen;
       ;
     }
   }
 
   final public void RelationalExpression() throws ParseException {
     ShiftExpression();
     label_36:
     while (true) {
       switch (jj_nt.kind) {
       case GT:
       case LT:
       case LE:
       case GE:
         ;
         break;
       default:
         jj_la1[73] = jj_gen;
         break label_36;
       }
       switch (jj_nt.kind) {
       case LT:
         jj_consume_token(LT);
         break;
       case GT:
         jj_consume_token(GT);
         break;
       case LE:
         jj_consume_token(LE);
         break;
       case GE:
         jj_consume_token(GE);
         break;
       default:
         jj_la1[74] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
       ShiftExpression();
     }
   }
 
   final public void ShiftExpression() throws ParseException {
     AdditiveExpression();
     label_37:
     while (true) {
       switch (jj_nt.kind) {
       case LSHIFT:
       case RSIGNEDSHIFT:
       case RUNSIGNEDSHIFT:
         ;
         break;
       default:
         jj_la1[75] = jj_gen;
         break label_37;
       }
       switch (jj_nt.kind) {
       case LSHIFT:
         jj_consume_token(LSHIFT);
         break;
       case RSIGNEDSHIFT:
         jj_consume_token(RSIGNEDSHIFT);
         break;
       case RUNSIGNEDSHIFT:
         jj_consume_token(RUNSIGNEDSHIFT);
         break;
       default:
         jj_la1[76] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
       AdditiveExpression();
     }
   }
 
   final public void AdditiveExpression() throws ParseException {
     MultiplicativeExpression();
     label_38:
     while (true) {
       switch (jj_nt.kind) {
       case PLUS:
       case MINUS:
         ;
         break;
       default:
         jj_la1[77] = jj_gen;
         break label_38;
       }
       switch (jj_nt.kind) {
       case PLUS:
         jj_consume_token(PLUS);
         break;
       case MINUS:
         jj_consume_token(MINUS);
         break;
       default:
         jj_la1[78] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
       MultiplicativeExpression();
     }
   }
 
   final public void MultiplicativeExpression() throws ParseException {
     UnaryExpression();
     label_39:
     while (true) {
       switch (jj_nt.kind) {
       case STAR:
       case SLASH:
       case REM:
         ;
         break;
       default:
         jj_la1[79] = jj_gen;
         break label_39;
       }
       switch (jj_nt.kind) {
       case STAR:
         jj_consume_token(STAR);
         break;
       case SLASH:
         jj_consume_token(SLASH);
         break;
       case REM:
         jj_consume_token(REM);
         break;
       default:
         jj_la1[80] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
       UnaryExpression();
     }
   }
 
   final public void UnaryExpression() throws ParseException {
     switch (jj_nt.kind) {
     case PLUS:
     case MINUS:
       switch (jj_nt.kind) {
       case PLUS:
         jj_consume_token(PLUS);
         break;
       case MINUS:
         jj_consume_token(MINUS);
         break;
       default:
         jj_la1[81] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
       UnaryExpression();
       break;
     case INCR:
       PreIncrementExpression();
       break;
     case DECR:
       PreDecrementExpression();
       break;
     case BOOLEAN:
     case BYTE:
     case CHAR:
     case DOUBLE:
     case FALSE:
     case FLOAT:
     case INT:
     case LONG:
     case NEW:
     case NULL:
     case SHORT:
     case SUPER:
     case THIS:
     case TRUE:
     case VOID:
     case INTEGER_LITERAL:
     case FLOATING_POINT_LITERAL:
     case CHARACTER_LITERAL:
     case STRING_LITERAL:
     case IDENTIFIER:
     case LPAREN:
     case BANG:
     case TILDE:
       UnaryExpressionNotPlusMinus();
       break;
     default:
       jj_la1[82] = jj_gen;
       jj_consume_token(-1);
       throw new ParseException();
     }
   }
 
   final public void PreIncrementExpression() throws ParseException {
     jj_consume_token(INCR);
     PrimaryExpression();
   }
 
   final public void PreDecrementExpression() throws ParseException {
     jj_consume_token(DECR);
     PrimaryExpression();
   }
 
   final public void UnaryExpressionNotPlusMinus() throws ParseException {
     switch (jj_nt.kind) {
     case BANG:
     case TILDE:
       switch (jj_nt.kind) {
       case TILDE:
         jj_consume_token(TILDE);
         break;
       case BANG:
         jj_consume_token(BANG);
         break;
       default:
         jj_la1[83] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
       UnaryExpression();
       break;
     default:
       jj_la1[84] = jj_gen;
       if (jj_2_15(2147483647)) {
         CastExpression();
       } else {
         switch (jj_nt.kind) {
         case BOOLEAN:
         case BYTE:
         case CHAR:
         case DOUBLE:
         case FALSE:
         case FLOAT:
         case INT:
         case LONG:
         case NEW:
         case NULL:
         case SHORT:
         case SUPER:
         case THIS:
         case TRUE:
         case VOID:
         case INTEGER_LITERAL:
         case FLOATING_POINT_LITERAL:
         case CHARACTER_LITERAL:
         case STRING_LITERAL:
         case IDENTIFIER:
         case LPAREN:
           PostfixExpression();
           break;
         default:
           jj_la1[85] = jj_gen;
           jj_consume_token(-1);
           throw new ParseException();
         }
       }
     }
   }
 
 // This production is to determine lookahead only.  The LOOKAHEAD specifications
 // below are not used, but they are there just to indicate that we know about
 // this.
   final public void CastLookahead() throws ParseException {
     if (jj_2_16(2)) {
       jj_consume_token(LPAREN);
       PrimitiveType();
     } else if (jj_2_17(2147483647)) {
       jj_consume_token(LPAREN);
       Name();
       jj_consume_token(LBRACKET);
       jj_consume_token(RBRACKET);
     } else {
       switch (jj_nt.kind) {
       case LPAREN:
         jj_consume_token(LPAREN);
         Name();
         jj_consume_token(RPAREN);
         switch (jj_nt.kind) {
         case TILDE:
           jj_consume_token(TILDE);
           break;
         case BANG:
           jj_consume_token(BANG);
           break;
         case LPAREN:
           jj_consume_token(LPAREN);
           break;
         case IDENTIFIER:
           jj_consume_token(IDENTIFIER);
           break;
         case THIS:
           jj_consume_token(THIS);
           break;
         case SUPER:
           jj_consume_token(SUPER);
           break;
         case NEW:
           jj_consume_token(NEW);
           break;
         case FALSE:
         case NULL:
         case TRUE:
         case INTEGER_LITERAL:
         case FLOATING_POINT_LITERAL:
         case CHARACTER_LITERAL:
         case STRING_LITERAL:
           Literal();
           break;
         default:
           jj_la1[86] = jj_gen;
           jj_consume_token(-1);
           throw new ParseException();
         }
         break;
       default:
         jj_la1[87] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
     }
   }
 
   final public void PostfixExpression() throws ParseException {
     PrimaryExpression();
     switch (jj_nt.kind) {
     case INCR:
     case DECR:
       switch (jj_nt.kind) {
       case INCR:
         jj_consume_token(INCR);
         break;
       case DECR:
         jj_consume_token(DECR);
         break;
       default:
         jj_la1[88] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
       break;
     default:
       jj_la1[89] = jj_gen;
       ;
     }
   }
 
   final public void CastExpression() throws ParseException {
     if (jj_2_18(2147483647)) {
       jj_consume_token(LPAREN);
       Type();
       jj_consume_token(RPAREN);
       UnaryExpression();
     } else {
       switch (jj_nt.kind) {
       case LPAREN:
         jj_consume_token(LPAREN);
         Type();
         jj_consume_token(RPAREN);
         UnaryExpressionNotPlusMinus();
         break;
       default:
         jj_la1[90] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
     }
   }
 
   final public void PrimaryExpression() throws ParseException {
     PrimaryPrefix();
     label_40:
     while (true) {
       if (jj_2_19(2)) {
         ;
       } else {
         break label_40;
       }
       PrimarySuffix();
     }
   }
 
   final public void PrimaryPrefix() throws ParseException {
     switch (jj_nt.kind) {
     case FALSE:
     case NULL:
     case TRUE:
     case INTEGER_LITERAL:
     case FLOATING_POINT_LITERAL:
     case CHARACTER_LITERAL:
     case STRING_LITERAL:
       Literal();
       break;
     case THIS:
       jj_consume_token(THIS);
       break;
     case SUPER:
       jj_consume_token(SUPER);
       jj_consume_token(DOT);
       jj_consume_token(IDENTIFIER);
       break;
     case LPAREN:
       jj_consume_token(LPAREN);
       Expression();
       jj_consume_token(RPAREN);
       break;
     case NEW:
       AllocationExpression();
       break;
     default:
       jj_la1[91] = jj_gen;
       if (jj_2_20(2147483647)) {
         ResultType(null);
         jj_consume_token(DOT);
         jj_consume_token(CLASS);
       } else {
         switch (jj_nt.kind) {
         case IDENTIFIER:
           Name();
           break;
         default:
           jj_la1[92] = jj_gen;
           jj_consume_token(-1);
           throw new ParseException();
         }
       }
     }
   }
 
   final public void PrimarySuffix() throws ParseException {
     if (jj_2_21(2)) {
       jj_consume_token(DOT);
       jj_consume_token(THIS);
     } else if (jj_2_22(2)) {
       jj_consume_token(DOT);
       jj_consume_token(SUPER);
     } else if (jj_2_23(2)) {
       jj_consume_token(DOT);
       AllocationExpression();
     } else {
       switch (jj_nt.kind) {
       case LBRACKET:
         jj_consume_token(LBRACKET);
         Expression();
         jj_consume_token(RBRACKET);
         break;
       case DOT:
         jj_consume_token(DOT);
         jj_consume_token(IDENTIFIER);
         break;
       case LPAREN:
         Arguments();
         break;
       default:
         jj_la1[93] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
     }
   }
 
   final public void Literal() throws ParseException {
     switch (jj_nt.kind) {
     case INTEGER_LITERAL:
       jj_consume_token(INTEGER_LITERAL);
       break;
     case FLOATING_POINT_LITERAL:
       jj_consume_token(FLOATING_POINT_LITERAL);
       break;
     case CHARACTER_LITERAL:
       jj_consume_token(CHARACTER_LITERAL);
       break;
     case STRING_LITERAL:
       jj_consume_token(STRING_LITERAL);
       break;
     case FALSE:
     case TRUE:
       BooleanLiteral();
       break;
     case NULL:
       NullLiteral();
       break;
     default:
       jj_la1[94] = jj_gen;
       jj_consume_token(-1);
       throw new ParseException();
     }
   }
 
   final public void BooleanLiteral() throws ParseException {
     switch (jj_nt.kind) {
     case TRUE:
       jj_consume_token(TRUE);
       break;
     case FALSE:
       jj_consume_token(FALSE);
       break;
     default:
       jj_la1[95] = jj_gen;
       jj_consume_token(-1);
       throw new ParseException();
     }
   }
 
   final public void NullLiteral() throws ParseException {
     jj_consume_token(NULL);
   }
 
   final public void Arguments() throws ParseException {
     jj_consume_token(LPAREN);
     switch (jj_nt.kind) {
     case BOOLEAN:
     case BYTE:
     case CHAR:
     case DOUBLE:
     case FALSE:
     case FLOAT:
     case INT:
     case LONG:
     case NEW:
     case NULL:
     case SHORT:
     case SUPER:
     case THIS:
     case TRUE:
     case VOID:
     case INTEGER_LITERAL:
     case FLOATING_POINT_LITERAL:
     case CHARACTER_LITERAL:
     case STRING_LITERAL:
     case IDENTIFIER:
     case LPAREN:
     case BANG:
     case TILDE:
     case INCR:
     case DECR:
     case PLUS:
     case MINUS:
       ArgumentList();
       break;
     default:
       jj_la1[96] = jj_gen;
       ;
     }
     jj_consume_token(RPAREN);
   }
 
   final public void ArgumentList() throws ParseException {
     Expression();
     label_41:
     while (true) {
       switch (jj_nt.kind) {
       case COMMA:
         ;
         break;
       default:
         jj_la1[97] = jj_gen;
         break label_41;
       }
       jj_consume_token(COMMA);
       Expression();
     }
   }
 
 /**
  * @todo Anonymous classes will cause NPE. Need to check for nullity in a lot of places
  */
   final public void AllocationExpression() throws ParseException {
    String realisedClass;
     if (jj_2_24(2)) {
       jj_consume_token(NEW);
       PrimitiveType();
       ArrayDimsAndInits();
     } else {
       switch (jj_nt.kind) {
       case NEW:
         jj_consume_token(NEW);
         realisedClass = Name();
         switch (jj_nt.kind) {
         case LBRACKET:
           ArrayDimsAndInits();
           break;
         case LPAREN:
           Arguments();
           switch (jj_nt.kind) {
           case LBRACE:
             // ANONYMOUS CLASS
             SourceClass containingClass = currentClass();
         pushAndGet();
             ClassBody();
         // Don't care about anonymous classes. They don't have javadocs
         // _xJavaDoc.addSourceClass(anonymousClass);
         currentClass().setName(containingClass.getNextAnonymousClassName());
         currentClass().setRealised(realisedClass);
         popAndAddInner();
             break;
           default:
             jj_la1[98] = jj_gen;
             ;
           }
           break;
         default:
           jj_la1[99] = jj_gen;
           jj_consume_token(-1);
           throw new ParseException();
         }
         break;
       default:
         jj_la1[100] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
     }
   }
 
 /*
  * The second LOOKAHEAD specification below is to parse to PrimarySuffix
  * if there is an expression between the "[...]".
  */
   final public void ArrayDimsAndInits() throws ParseException {
     if (jj_2_27(2)) {
       label_42:
       while (true) {
         jj_consume_token(LBRACKET);
         Expression();
         jj_consume_token(RBRACKET);
         if (jj_2_25(2)) {
           ;
         } else {
           break label_42;
         }
       }
       label_43:
       while (true) {
         if (jj_2_26(2)) {
           ;
         } else {
           break label_43;
         }
         jj_consume_token(LBRACKET);
         jj_consume_token(RBRACKET);
       }
     } else {
       switch (jj_nt.kind) {
       case LBRACKET:
         label_44:
         while (true) {
           jj_consume_token(LBRACKET);
           jj_consume_token(RBRACKET);
           switch (jj_nt.kind) {
           case LBRACKET:
             ;
             break;
           default:
             jj_la1[101] = jj_gen;
             break label_44;
           }
         }
         ArrayInitializer();
         break;
       default:
         jj_la1[102] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
     }
   }
 
 /*
  * Statement syntax follows.
  */
   final public void Statement() throws ParseException {
     if (jj_2_28(2)) {
       LabeledStatement();
     } else {
       switch (jj_nt.kind) {
       case LBRACE:
         Block();
         break;
       case SEMICOLON:
         EmptyStatement();
         break;
       case BOOLEAN:
       case BYTE:
       case CHAR:
       case DOUBLE:
       case FALSE:
       case FLOAT:
       case INT:
       case LONG:
       case NEW:
       case NULL:
       case SHORT:
       case SUPER:
       case THIS:
       case TRUE:
       case VOID:
       case INTEGER_LITERAL:
       case FLOATING_POINT_LITERAL:
       case CHARACTER_LITERAL:
       case STRING_LITERAL:
       case IDENTIFIER:
       case LPAREN:
       case INCR:
       case DECR:
         StatementExpression();
         jj_consume_token(SEMICOLON);
         break;
       case SWITCH:
         SwitchStatement();
         break;
       case IF:
         IfStatement();
         break;
       case WHILE:
         WhileStatement();
         break;
       case DO:
         DoStatement();
         break;
       case FOR:
         ForStatement();
         break;
       case BREAK:
         BreakStatement();
         break;
       case CONTINUE:
         ContinueStatement();
         break;
       case RETURN:
         ReturnStatement();
         break;
       case THROW:
         ThrowStatement();
         break;
       case SYNCHRONIZED:
         SynchronizedStatement();
         break;
       case TRY:
         TryStatement();
         break;
       case ASSERT:
         AssertStatement();
         break;
       default:
         jj_la1[103] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
     }
   }
 
   final public void LabeledStatement() throws ParseException {
     jj_consume_token(IDENTIFIER);
     jj_consume_token(COLON);
     Statement();
   }
 
   final public void Block() throws ParseException {
     jj_consume_token(LBRACE);
     label_45:
     while (true) {
       switch (jj_nt.kind) {
       case BOOLEAN:
       case BREAK:
       case BYTE:
       case CHAR:
       case CLASS:
       case CONTINUE:
       case DO:
       case DOUBLE:
       case FALSE:
       case FINAL:
       case FLOAT:
       case FOR:
       case IF:
       case INT:
       case INTERFACE:
       case LONG:
       case NEW:
       case NULL:
       case RETURN:
       case SHORT:
       case SUPER:
       case SWITCH:
       case SYNCHRONIZED:
       case THIS:
       case THROW:
       case TRUE:
       case TRY:
       case VOID:
       case WHILE:
       case ASSERT:
       case INTEGER_LITERAL:
       case FLOATING_POINT_LITERAL:
       case CHARACTER_LITERAL:
       case STRING_LITERAL:
       case IDENTIFIER:
       case LPAREN:
       case LBRACE:
       case SEMICOLON:
       case INCR:
       case DECR:
         ;
         break;
       default:
         jj_la1[104] = jj_gen;
         break label_45;
       }
       BlockStatement();
     }
     jj_consume_token(RBRACE);
   }
 
   final public void Method_Block() throws ParseException {
     jj_consume_token(LBRACE);
     label_46:
     while (true) {
       switch (jj_nt.kind) {
       case BOOLEAN:
       case BREAK:
       case BYTE:
       case CHAR:
       case CLASS:
       case CONTINUE:
       case DO:
       case DOUBLE:
       case FALSE:
       case FINAL:
       case FLOAT:
       case FOR:
       case IF:
       case INT:
       case INTERFACE:
       case LONG:
       case NEW:
       case NULL:
       case RETURN:
       case SHORT:
       case SUPER:
       case SWITCH:
       case SYNCHRONIZED:
       case THIS:
       case THROW:
       case TRUE:
       case TRY:
       case VOID:
       case WHILE:
       case ASSERT:
       case INTEGER_LITERAL:
       case FLOATING_POINT_LITERAL:
       case CHARACTER_LITERAL:
       case STRING_LITERAL:
       case IDENTIFIER:
       case LPAREN:
       case LBRACE:
       case SEMICOLON:
       case INCR:
       case DECR:
         ;
         break;
       default:
         jj_la1[105] = jj_gen;
         break label_46;
       }
       Method_BlockStatement();
     }
     jj_consume_token(RBRACE);
     switch (jj_nt.kind) {
     case SEMICOLON:
       jj_consume_token(SEMICOLON);
       break;
     default:
       jj_la1[106] = jj_gen;
       ;
     }
   }
 
 /**
  * @todo not sure if the UnmodifiedClassDeclaration/UnmodifiedInterfaceDeclaration
  * ever get called, now that we have two different blocks. It would be nice to remove them
  */
   final public void BlockStatement() throws ParseException {
     if (jj_2_29(2147483647)) {
       LocalVariableDeclaration();
       jj_consume_token(SEMICOLON);
     } else {
       switch (jj_nt.kind) {
       case BOOLEAN:
       case BREAK:
       case BYTE:
       case CHAR:
       case CONTINUE:
       case DO:
       case DOUBLE:
       case FALSE:
       case FLOAT:
       case FOR:
       case IF:
       case INT:
       case LONG:
       case NEW:
       case NULL:
       case RETURN:
       case SHORT:
       case SUPER:
       case SWITCH:
       case SYNCHRONIZED:
       case THIS:
       case THROW:
       case TRUE:
       case TRY:
       case VOID:
       case WHILE:
       case ASSERT:
       case INTEGER_LITERAL:
       case FLOATING_POINT_LITERAL:
       case CHARACTER_LITERAL:
       case STRING_LITERAL:
       case IDENTIFIER:
       case LPAREN:
       case LBRACE:
       case SEMICOLON:
       case INCR:
       case DECR:
         Statement();
         break;
       case CLASS:
      pushAndGet();
         UnmodifiedClassDeclaration();
      popAndAddInner();
         break;
       case INTERFACE:
      pushAndGet();
         UnmodifiedInterfaceDeclaration();
      popAndAddInner();
         break;
       default:
         jj_la1[107] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
     }
   }
 
   final public void Method_BlockStatement() throws ParseException {
     if (jj_2_30(2147483647)) {
       LocalVariableDeclaration();
       jj_consume_token(SEMICOLON);
     } else {
       switch (jj_nt.kind) {
       case BOOLEAN:
       case BREAK:
       case BYTE:
       case CHAR:
       case CONTINUE:
       case DO:
       case DOUBLE:
       case FALSE:
       case FLOAT:
       case FOR:
       case IF:
       case INT:
       case LONG:
       case NEW:
       case NULL:
       case RETURN:
       case SHORT:
       case SUPER:
       case SWITCH:
       case SYNCHRONIZED:
       case THIS:
       case THROW:
       case TRUE:
       case TRY:
       case VOID:
       case WHILE:
       case ASSERT:
       case INTEGER_LITERAL:
       case FLOATING_POINT_LITERAL:
       case CHARACTER_LITERAL:
       case STRING_LITERAL:
       case IDENTIFIER:
       case LPAREN:
       case LBRACE:
       case SEMICOLON:
       case INCR:
       case DECR:
         Statement();
         break;
       case CLASS:
      pushAndGet();
         UnmodifiedClassDeclaration();
      popAndAddInner();
         break;
       case INTERFACE:
      pushAndGet();
         UnmodifiedInterfaceDeclaration();
      popAndAddInner();
         break;
       default:
         jj_la1[108] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
     }
   }
 
   final public void LocalVariableDeclaration() throws ParseException {
     switch (jj_nt.kind) {
     case FINAL:
       jj_consume_token(FINAL);
       break;
     default:
       jj_la1[109] = jj_gen;
       ;
     }
     Type();
     VariableDeclarator();
     label_47:
     while (true) {
       switch (jj_nt.kind) {
       case COMMA:
         ;
         break;
       default:
         jj_la1[110] = jj_gen;
         break label_47;
       }
       jj_consume_token(COMMA);
       VariableDeclarator();
     }
   }
 
   final public void EmptyStatement() throws ParseException {
     jj_consume_token(SEMICOLON);
   }
 
   final public void StatementExpression() throws ParseException {
     switch (jj_nt.kind) {
     case INCR:
       PreIncrementExpression();
       break;
     case DECR:
       PreDecrementExpression();
       break;
     case BOOLEAN:
     case BYTE:
     case CHAR:
     case DOUBLE:
     case FALSE:
     case FLOAT:
     case INT:
     case LONG:
     case NEW:
     case NULL:
     case SHORT:
     case SUPER:
     case THIS:
     case TRUE:
     case VOID:
     case INTEGER_LITERAL:
     case FLOATING_POINT_LITERAL:
     case CHARACTER_LITERAL:
     case STRING_LITERAL:
     case IDENTIFIER:
     case LPAREN:
       PrimaryExpression();
       switch (jj_nt.kind) {
       case ASSIGN:
       case INCR:
       case DECR:
       case PLUSASSIGN:
       case MINUSASSIGN:
       case STARASSIGN:
       case SLASHASSIGN:
       case ANDASSIGN:
       case ORASSIGN:
       case XORASSIGN:
       case REMASSIGN:
       case LSHIFTASSIGN:
       case RSIGNEDSHIFTASSIGN:
       case RUNSIGNEDSHIFTASSIGN:
         switch (jj_nt.kind) {
         case INCR:
           jj_consume_token(INCR);
           break;
         case DECR:
           jj_consume_token(DECR);
           break;
         case ASSIGN:
         case PLUSASSIGN:
         case MINUSASSIGN:
         case STARASSIGN:
         case SLASHASSIGN:
         case ANDASSIGN:
         case ORASSIGN:
         case XORASSIGN:
         case REMASSIGN:
         case LSHIFTASSIGN:
         case RSIGNEDSHIFTASSIGN:
         case RUNSIGNEDSHIFTASSIGN:
           AssignmentOperator();
           Expression();
           break;
         default:
           jj_la1[111] = jj_gen;
           jj_consume_token(-1);
           throw new ParseException();
         }
         break;
       default:
         jj_la1[112] = jj_gen;
         ;
       }
       break;
     default:
       jj_la1[113] = jj_gen;
       jj_consume_token(-1);
       throw new ParseException();
     }
   }
 
   final public void SwitchStatement() throws ParseException {
     jj_consume_token(SWITCH);
     jj_consume_token(LPAREN);
     Expression();
     jj_consume_token(RPAREN);
     jj_consume_token(LBRACE);
     label_48:
     while (true) {
       switch (jj_nt.kind) {
       case CASE:
       case _DEFAULT:
         ;
         break;
       default:
         jj_la1[114] = jj_gen;
         break label_48;
       }
       SwitchLabel();
       label_49:
       while (true) {
         switch (jj_nt.kind) {
         case BOOLEAN:
         case BREAK:
         case BYTE:
         case CHAR:
         case CLASS:
         case CONTINUE:
         case DO:
         case DOUBLE:
         case FALSE:
         case FINAL:
         case FLOAT:
         case FOR:
         case IF:
         case INT:
         case INTERFACE:
         case LONG:
         case NEW:
         case NULL:
         case RETURN:
         case SHORT:
         case SUPER:
         case SWITCH:
         case SYNCHRONIZED:
         case THIS:
         case THROW:
         case TRUE:
         case TRY:
         case VOID:
         case WHILE:
         case ASSERT:
         case INTEGER_LITERAL:
         case FLOATING_POINT_LITERAL:
         case CHARACTER_LITERAL:
         case STRING_LITERAL:
         case IDENTIFIER:
         case LPAREN:
         case LBRACE:
         case SEMICOLON:
         case INCR:
         case DECR:
           ;
           break;
         default:
           jj_la1[115] = jj_gen;
           break label_49;
         }
         BlockStatement();
       }
     }
     jj_consume_token(RBRACE);
   }
 
   final public void SwitchLabel() throws ParseException {
     switch (jj_nt.kind) {
     case CASE:
       jj_consume_token(CASE);
       Expression();
       jj_consume_token(COLON);
       break;
     case _DEFAULT:
       jj_consume_token(_DEFAULT);
       jj_consume_token(COLON);
       break;
     default:
       jj_la1[116] = jj_gen;
