Example usage for org.eclipse.jdt.internal.compiler.ast OperatorIds LESS

List of usage examples for org.eclipse.jdt.internal.compiler.ast OperatorIds LESS

Introduction

In this page you can find the example usage for org.eclipse.jdt.internal.compiler.ast OperatorIds LESS.

Prototype

int LESS

To view the source code for org.eclipse.jdt.internal.compiler.ast OperatorIds LESS.

Click Source Link

Usage

From source file:com.android.tools.lint.psi.EcjPsiBuilder.java

License:Apache License

/** Look up the PSI element type for the given ECJ operator */
@NonNull//from  w w w.  j ava  2 s . c  om
private IElementType ecjToPsiToken(int operator) {
    switch (operator) {
    case OperatorIds.PLUS_PLUS:
        return JavaTokenType.PLUSPLUS;
    case OperatorIds.MINUS_MINUS:
        return JavaTokenType.MINUSMINUS;
    case OperatorIds.TWIDDLE:
        return JavaTokenType.TILDE;
    case OperatorIds.NOT:
        return JavaTokenType.EXCL;
    case OperatorIds.PLUS:
        return JavaTokenType.PLUS;
    case OperatorIds.MINUS:
        return JavaTokenType.MINUS;
    case OperatorIds.OR_OR:
        return JavaTokenType.OROR;
    case OperatorIds.AND_AND:
        return JavaTokenType.ANDAND;
    case OperatorIds.OR:
        return JavaTokenType.OR;
    case OperatorIds.XOR:
        return JavaTokenType.XOR;
    case OperatorIds.AND:
        return JavaTokenType.AND;
    case OperatorIds.EQUAL_EQUAL:
        return JavaTokenType.EQEQ;
    case OperatorIds.NOT_EQUAL:
        return JavaTokenType.NE;
    case OperatorIds.GREATER:
        return JavaTokenType.GT;
    case OperatorIds.GREATER_EQUAL:
        return JavaTokenType.GE;
    case OperatorIds.LESS:
        return JavaTokenType.LT;
    case OperatorIds.LESS_EQUAL:
        return JavaTokenType.LE;
    case OperatorIds.LEFT_SHIFT:
        return JavaTokenType.LTLT;
    case OperatorIds.RIGHT_SHIFT:
        return JavaTokenType.GTGT;
    case OperatorIds.UNSIGNED_RIGHT_SHIFT:
        return JavaTokenType.GTGTGT;
    case OperatorIds.MULTIPLY:
        return JavaTokenType.ASTERISK;
    case OperatorIds.DIVIDE:
        return JavaTokenType.DIV;
    case OperatorIds.REMAINDER:
        return JavaTokenType.PERC;
    case OperatorIds.EQUAL:
        return JavaTokenType.EQ;
    default:
        return JavaTokenType.IDENTIFIER;
    }
}

From source file:lombok.eclipse.handlers.singulars.EclipseJavaUtilSingularizer.java

License:Open Source License

protected List<Statement> createJavaUtilSimpleCreationAndFillStatements(SingularData data,
        EclipseNode builderType, boolean mapMode, boolean defineVar, boolean addInitialCapacityArg,
        boolean nullGuard, String targetType) {
    char[] varName = mapMode ? (new String(data.getPluralName()) + "$key").toCharArray() : data.getPluralName();

    Statement createStat;//from   w  w  w . jav a  2s. c o m
    {
        // pluralName = new java.util.TargetType(initialCap);
        Expression[] constructorArgs = null;
        if (addInitialCapacityArg) {
            // this.varName.size() < MAX_POWER_OF_2 ? 1 + this.varName.size() + (this.varName.size() - 3) / 3 : Integer.MAX_VALUE;
            // lessThanCutOff = this.varName.size() < MAX_POWER_OF_2
            Expression lessThanCutoff = new BinaryExpression(getSize(builderType, varName, nullGuard),
                    makeIntLiteral("0x40000000".toCharArray(), null), OperatorIds.LESS);
            FieldReference integerMaxValue = new FieldReference("MAX_VALUE".toCharArray(), 0L);
            integerMaxValue.receiver = new QualifiedNameReference(TypeConstants.JAVA_LANG_INTEGER, NULL_POSS, 0,
                    0);
            Expression sizeFormulaLeft = new BinaryExpression(makeIntLiteral(new char[] { '1' }, null),
                    getSize(builderType, varName, nullGuard), OperatorIds.PLUS);
            Expression sizeFormulaRightLeft = new BinaryExpression(getSize(builderType, varName, nullGuard),
                    makeIntLiteral(new char[] { '3' }, null), OperatorIds.MINUS);
            Expression sizeFormulaRight = new BinaryExpression(sizeFormulaRightLeft,
                    makeIntLiteral(new char[] { '3' }, null), OperatorIds.DIVIDE);
            Expression sizeFormula = new BinaryExpression(sizeFormulaLeft, sizeFormulaRight, OperatorIds.PLUS);
            Expression cond = new ConditionalExpression(lessThanCutoff, sizeFormula, integerMaxValue);
            constructorArgs = new Expression[] { cond };
        }

        TypeReference targetTypeRef = new QualifiedTypeReference(
                new char[][] { TypeConstants.JAVA, TypeConstants.UTIL, targetType.toCharArray() }, NULL_POSS);
        targetTypeRef = addTypeArgs(mapMode ? 2 : 1, false, builderType, targetTypeRef, data.getTypeArgs());
        AllocationExpression constructorCall = new AllocationExpression();
        constructorCall.type = targetTypeRef;
        constructorCall.arguments = constructorArgs;

        if (defineVar) {
            TypeReference localShadowerType = new QualifiedTypeReference(fromQualifiedName(data.getTargetFqn()),
                    NULL_POSS);
            localShadowerType = addTypeArgs(mapMode ? 2 : 1, false, builderType, localShadowerType,
                    data.getTypeArgs());
            LocalDeclaration localShadowerDecl = new LocalDeclaration(data.getPluralName(), 0, 0);
            localShadowerDecl.type = localShadowerType;
            localShadowerDecl.initialization = constructorCall;
            createStat = localShadowerDecl;
        } else {
            createStat = new Assignment(new SingleNameReference(data.getPluralName(), 0L), constructorCall, 0);
        }
    }

    Statement fillStat;
    {
        if (mapMode) {
            // for (int $i = 0; $i < this.pluralname$key.size(); i++) pluralname.put(this.pluralname$key.get($i), this.pluralname$value.get($i));
            char[] iVar = new char[] { '$', 'i' };
            MessageSend pluralnameDotPut = new MessageSend();
            pluralnameDotPut.selector = new char[] { 'p', 'u', 't' };
            pluralnameDotPut.receiver = new SingleNameReference(data.getPluralName(), 0L);
            FieldReference thisDotKey = new FieldReference(varName, 0L);
            thisDotKey.receiver = new ThisReference(0, 0);
            FieldReference thisDotValue = new FieldReference(
                    (new String(data.getPluralName()) + "$value").toCharArray(), 0L);
            thisDotValue.receiver = new ThisReference(0, 0);
            MessageSend keyArg = new MessageSend();
            keyArg.receiver = thisDotKey;
            keyArg.arguments = new Expression[] { new SingleNameReference(iVar, 0L) };
            keyArg.selector = new char[] { 'g', 'e', 't' };
            MessageSend valueArg = new MessageSend();
            valueArg.receiver = thisDotValue;
            valueArg.arguments = new Expression[] { new SingleNameReference(iVar, 0L) };
            valueArg.selector = new char[] { 'g', 'e', 't' };
            pluralnameDotPut.arguments = new Expression[] { keyArg, valueArg };

            LocalDeclaration forInit = new LocalDeclaration(iVar, 0, 0);
            forInit.type = TypeReference.baseTypeReference(TypeIds.T_int, 0);
            forInit.initialization = makeIntLiteral(new char[] { '0' }, null);
            Expression checkExpr = new BinaryExpression(new SingleNameReference(iVar, 0L),
                    getSize(builderType, varName, nullGuard), OperatorIds.LESS);
            Expression incrementExpr = new PostfixExpression(new SingleNameReference(iVar, 0L), IntLiteral.One,
                    OperatorIds.PLUS, 0);
            fillStat = new ForStatement(new Statement[] { forInit }, checkExpr,
                    new Statement[] { incrementExpr }, pluralnameDotPut, true, 0, 0);
        } else {
            // pluralname.addAll(this.pluralname);
            MessageSend pluralnameDotAddAll = new MessageSend();
            pluralnameDotAddAll.selector = new char[] { 'a', 'd', 'd', 'A', 'l', 'l' };
            pluralnameDotAddAll.receiver = new SingleNameReference(data.getPluralName(), 0L);
            FieldReference thisDotPluralname = new FieldReference(varName, 0L);
            thisDotPluralname.receiver = new ThisReference(0, 0);
            pluralnameDotAddAll.arguments = new Expression[] { thisDotPluralname };
            fillStat = pluralnameDotAddAll;
        }

        if (nullGuard) {
            FieldReference thisDotField = new FieldReference(varName, 0L);
            thisDotField.receiver = new ThisReference(0, 0);
            Expression cond = new EqualExpression(thisDotField, new NullLiteral(0, 0), OperatorIds.NOT_EQUAL);
            fillStat = new IfStatement(cond, fillStat, 0, 0);
        }
    }

    Statement unmodifiableStat;
    {
        // pluralname = Collections.unmodifiableInterfaceType(pluralname);
        Expression arg = new SingleNameReference(data.getPluralName(), 0L);
        MessageSend invoke = new MessageSend();
        invoke.arguments = new Expression[] { arg };
        invoke.selector = ("unmodifiable" + data.getTargetSimpleType()).toCharArray();
        invoke.receiver = new QualifiedNameReference(JAVA_UTIL_COLLECTIONS, NULL_POSS, 0, 0);
        unmodifiableStat = new Assignment(new SingleNameReference(data.getPluralName(), 0L), invoke, 0);
    }

    return Arrays.asList(createStat, fillStat, unmodifiableStat);
}

From source file:org.eclipse.jdt.core.dom.ASTConverter.java

License:Open Source License

protected InfixExpression.Operator getOperatorFor(int operatorID) {
    switch (operatorID) {
    case org.eclipse.jdt.internal.compiler.ast.OperatorIds.EQUAL_EQUAL:
        return InfixExpression.Operator.EQUALS;
    case org.eclipse.jdt.internal.compiler.ast.OperatorIds.LESS_EQUAL:
        return InfixExpression.Operator.LESS_EQUALS;
    case org.eclipse.jdt.internal.compiler.ast.OperatorIds.GREATER_EQUAL:
        return InfixExpression.Operator.GREATER_EQUALS;
    case org.eclipse.jdt.internal.compiler.ast.OperatorIds.NOT_EQUAL:
        return InfixExpression.Operator.NOT_EQUALS;
    case org.eclipse.jdt.internal.compiler.ast.OperatorIds.LEFT_SHIFT:
        return InfixExpression.Operator.LEFT_SHIFT;
    case org.eclipse.jdt.internal.compiler.ast.OperatorIds.RIGHT_SHIFT:
        return InfixExpression.Operator.RIGHT_SHIFT_SIGNED;
    case org.eclipse.jdt.internal.compiler.ast.OperatorIds.UNSIGNED_RIGHT_SHIFT:
        return InfixExpression.Operator.RIGHT_SHIFT_UNSIGNED;
    case org.eclipse.jdt.internal.compiler.ast.OperatorIds.OR_OR:
        return InfixExpression.Operator.CONDITIONAL_OR;
    case org.eclipse.jdt.internal.compiler.ast.OperatorIds.AND_AND:
        return InfixExpression.Operator.CONDITIONAL_AND;
    case org.eclipse.jdt.internal.compiler.ast.OperatorIds.PLUS:
        return InfixExpression.Operator.PLUS;
    case org.eclipse.jdt.internal.compiler.ast.OperatorIds.MINUS:
        return InfixExpression.Operator.MINUS;
    case org.eclipse.jdt.internal.compiler.ast.OperatorIds.REMAINDER:
        return InfixExpression.Operator.REMAINDER;
    case org.eclipse.jdt.internal.compiler.ast.OperatorIds.XOR:
        return InfixExpression.Operator.XOR;
    case org.eclipse.jdt.internal.compiler.ast.OperatorIds.AND:
        return InfixExpression.Operator.AND;
    case org.eclipse.jdt.internal.compiler.ast.OperatorIds.MULTIPLY:
        return InfixExpression.Operator.TIMES;
    case org.eclipse.jdt.internal.compiler.ast.OperatorIds.OR:
        return InfixExpression.Operator.OR;
    case org.eclipse.jdt.internal.compiler.ast.OperatorIds.DIVIDE:
        return InfixExpression.Operator.DIVIDE;
    case org.eclipse.jdt.internal.compiler.ast.OperatorIds.GREATER:
        return InfixExpression.Operator.GREATER;
    case org.eclipse.jdt.internal.compiler.ast.OperatorIds.LESS:
        return InfixExpression.Operator.LESS;
    }// ww  w.ja v a  2  s.  co m
    return null;
}

From source file:org.eclipse.jdt.internal.compiler.parser.Parser.java

License:Open Source License

protected void consumeRule(int act) {
    switch (act) {
    case 30:/*from  w  ww  . j  a va 2 s .  co m*/
        if (DEBUG) {
            System.out.println("Type ::= PrimitiveType"); //$NON-NLS-1$
        }
        consumePrimitiveType();
        break;

    case 44:
        if (DEBUG) {
            System.out.println("ReferenceType ::= ClassOrInterfaceType"); //$NON-NLS-1$
        }
        consumeReferenceType();
        break;

    case 48:
        if (DEBUG) {
            System.out.println("ClassOrInterface ::= Name"); //$NON-NLS-1$
        }
        consumeClassOrInterfaceName();
        break;

    case 49:
        if (DEBUG) {
            System.out.println("ClassOrInterface ::= GenericType DOT Name"); //$NON-NLS-1$
        }
        consumeClassOrInterface();
        break;

    case 50:
        if (DEBUG) {
            System.out.println("GenericType ::= ClassOrInterface TypeArguments"); //$NON-NLS-1$
        }
        consumeGenericType();
        break;

    case 51:
        if (DEBUG) {
            System.out.println("GenericType ::= ClassOrInterface LESS GREATER"); //$NON-NLS-1$
        }
        consumeGenericTypeWithDiamond();
        break;

    case 52:
        if (DEBUG) {
            System.out.println("ArrayTypeWithTypeArgumentsName ::= GenericType DOT Name"); //$NON-NLS-1$
        }
        consumeArrayTypeWithTypeArgumentsName();
        break;

    case 53:
        if (DEBUG) {
            System.out.println("ArrayType ::= PrimitiveType Dims"); //$NON-NLS-1$
        }
        consumePrimitiveArrayType();
        break;

    case 54:
        if (DEBUG) {
            System.out.println("ArrayType ::= Name Dims"); //$NON-NLS-1$
        }
        consumeNameArrayType();
        break;

    case 55:
        if (DEBUG) {
            System.out.println("ArrayType ::= ArrayTypeWithTypeArgumentsName Dims"); //$NON-NLS-1$
        }
        consumeGenericTypeNameArrayType();
        break;

    case 56:
        if (DEBUG) {
            System.out.println("ArrayType ::= GenericType Dims"); //$NON-NLS-1$
        }
        consumeGenericTypeArrayType();
        break;

    case 61:
        if (DEBUG) {
            System.out.println("QualifiedName ::= Name DOT SimpleName"); //$NON-NLS-1$
        }
        consumeQualifiedName();
        break;

    case 62:
        if (DEBUG) {
            System.out.println("CompilationUnit ::= EnterCompilationUnit..."); //$NON-NLS-1$
        }
        consumeCompilationUnit();
        break;

    case 63:
        if (DEBUG) {
            System.out.println("InternalCompilationUnit ::= PackageDeclaration"); //$NON-NLS-1$
        }
        consumeInternalCompilationUnit();
        break;

    case 64:
        if (DEBUG) {
            System.out.println("InternalCompilationUnit ::= PackageDeclaration..."); //$NON-NLS-1$
        }
        consumeInternalCompilationUnit();
        break;

    case 65:
        if (DEBUG) {
            System.out.println("InternalCompilationUnit ::= PackageDeclaration..."); //$NON-NLS-1$
        }
        consumeInternalCompilationUnitWithTypes();
        break;

    case 66:
        if (DEBUG) {
            System.out.println("InternalCompilationUnit ::= PackageDeclaration..."); //$NON-NLS-1$
        }
        consumeInternalCompilationUnitWithTypes();
        break;

    case 67:
        if (DEBUG) {
            System.out.println("InternalCompilationUnit ::= ImportDeclarations..."); //$NON-NLS-1$
        }
        consumeInternalCompilationUnit();
        break;

    case 68:
        if (DEBUG) {
            System.out.println("InternalCompilationUnit ::= TypeDeclarations"); //$NON-NLS-1$
        }
        consumeInternalCompilationUnitWithTypes();
        break;

    case 69:
        if (DEBUG) {
            System.out.println("InternalCompilationUnit ::= ImportDeclarations..."); //$NON-NLS-1$
        }
        consumeInternalCompilationUnitWithTypes();
        break;

    case 70:
        if (DEBUG) {
            System.out.println("InternalCompilationUnit ::="); //$NON-NLS-1$
        }
        consumeEmptyInternalCompilationUnit();
        break;

    case 71:
        if (DEBUG) {
            System.out.println("ReduceImports ::="); //$NON-NLS-1$
        }
        consumeReduceImports();
        break;

    case 72:
        if (DEBUG) {
            System.out.println("EnterCompilationUnit ::="); //$NON-NLS-1$
        }
        consumeEnterCompilationUnit();
        break;

    case 88:
        if (DEBUG) {
            System.out.println("CatchHeader ::= catch LPAREN CatchFormalParameter RPAREN"); //$NON-NLS-1$
        }
        consumeCatchHeader();
        break;

    case 90:
        if (DEBUG) {
            System.out.println("ImportDeclarations ::= ImportDeclarations..."); //$NON-NLS-1$
        }
        consumeImportDeclarations();
        break;

    case 92:
        if (DEBUG) {
            System.out.println("TypeDeclarations ::= TypeDeclarations TypeDeclaration"); //$NON-NLS-1$
        }
        consumeTypeDeclarations();
        break;

    case 93:
        if (DEBUG) {
            System.out.println("PackageDeclaration ::= PackageDeclarationName SEMICOLON"); //$NON-NLS-1$
        }
        consumePackageDeclaration();
        break;

    case 94:
        if (DEBUG) {
            System.out.println("PackageDeclarationName ::= Modifiers package..."); //$NON-NLS-1$
        }
        consumePackageDeclarationNameWithModifiers();
        break;

    case 95:
        if (DEBUG) {
            System.out.println("PackageDeclarationName ::= PackageComment package Name"); //$NON-NLS-1$
        }
        consumePackageDeclarationName();
        break;

    case 96:
        if (DEBUG) {
            System.out.println("PackageComment ::="); //$NON-NLS-1$
        }
        consumePackageComment();
        break;

    case 101:
        if (DEBUG) {
            System.out.println("SingleTypeImportDeclaration ::=..."); //$NON-NLS-1$
        }
        consumeImportDeclaration();
        break;

    case 102:
        if (DEBUG) {
            System.out.println("SingleTypeImportDeclarationName ::= import Name"); //$NON-NLS-1$
        }
        consumeSingleTypeImportDeclarationName();
        break;

    case 103:
        if (DEBUG) {
            System.out.println("TypeImportOnDemandDeclaration ::=..."); //$NON-NLS-1$
        }
        consumeImportDeclaration();
        break;

    case 104:
        if (DEBUG) {
            System.out.println("TypeImportOnDemandDeclarationName ::= import Name DOT..."); //$NON-NLS-1$
        }
        consumeTypeImportOnDemandDeclarationName();
        break;

    case 107:
        if (DEBUG) {
            System.out.println("TypeDeclaration ::= SEMICOLON"); //$NON-NLS-1$
        }
        consumeEmptyTypeDeclaration();
        break;

    case 111:
        if (DEBUG) {
            System.out.println("Modifiers ::= Modifiers Modifier"); //$NON-NLS-1$
        }
        consumeModifiers2();
        break;

    case 123:
        if (DEBUG) {
            System.out.println("Modifier ::= Annotation"); //$NON-NLS-1$
        }
        consumeAnnotationAsModifier();
        break;

    case 124:
        if (DEBUG) {
            System.out.println("ClassDeclaration ::= ClassHeader ClassBody"); //$NON-NLS-1$
        }
        consumeClassDeclaration();
        break;

    case 125:
        if (DEBUG) {
            System.out.println("ClassHeader ::= ClassHeaderName ClassHeaderExtendsopt..."); //$NON-NLS-1$
        }
        consumeClassHeader();
        break;

    case 126:
        if (DEBUG) {
            System.out.println("ClassHeaderName ::= ClassHeaderName1 TypeParameters"); //$NON-NLS-1$
        }
        consumeTypeHeaderNameWithTypeParameters();
        break;

    case 128:
        if (DEBUG) {
            System.out.println("ClassHeaderName1 ::= Modifiersopt class Identifier"); //$NON-NLS-1$
        }
        consumeClassHeaderName1();
        break;

    case 129:
        if (DEBUG) {
            System.out.println("ClassHeaderExtends ::= extends ClassType"); //$NON-NLS-1$
        }
        consumeClassHeaderExtends();
        break;

    case 130:
        if (DEBUG) {
            System.out.println("ClassHeaderImplements ::= implements InterfaceTypeList"); //$NON-NLS-1$
        }
        consumeClassHeaderImplements();
        break;

    case 132:
        if (DEBUG) {
            System.out.println("InterfaceTypeList ::= InterfaceTypeList COMMA..."); //$NON-NLS-1$
        }
        consumeInterfaceTypeList();
        break;

    case 133:
        if (DEBUG) {
            System.out.println("InterfaceType ::= ClassOrInterfaceType"); //$NON-NLS-1$
        }
        consumeInterfaceType();
        break;

    case 136:
        if (DEBUG) {
            System.out.println("ClassBodyDeclarations ::= ClassBodyDeclarations..."); //$NON-NLS-1$
        }
        consumeClassBodyDeclarations();
        break;

    case 140:
        if (DEBUG) {
            System.out.println("ClassBodyDeclaration ::= Diet NestedMethod..."); //$NON-NLS-1$
        }
        consumeClassBodyDeclaration();
        break;

    case 141:
        if (DEBUG) {
            System.out.println("Diet ::="); //$NON-NLS-1$
        }
        consumeDiet();
        break;

    case 142:
        if (DEBUG) {
            System.out.println("Initializer ::= Diet NestedMethod CreateInitializer..."); //$NON-NLS-1$
        }
        consumeClassBodyDeclaration();
        break;

    case 143:
        if (DEBUG) {
            System.out.println("CreateInitializer ::="); //$NON-NLS-1$
        }
        consumeCreateInitializer();
        break;

    case 150:
        if (DEBUG) {
            System.out.println("ClassMemberDeclaration ::= SEMICOLON"); //$NON-NLS-1$
        }
        consumeEmptyTypeDeclaration();
        break;

    case 153:
        if (DEBUG) {
            System.out.println("FieldDeclaration ::= Modifiersopt Type..."); //$NON-NLS-1$
        }
        consumeFieldDeclaration();
        break;

    case 155:
        if (DEBUG) {
            System.out.println("VariableDeclarators ::= VariableDeclarators COMMA..."); //$NON-NLS-1$
        }
        consumeVariableDeclarators();
        break;

    case 158:
        if (DEBUG) {
            System.out.println("EnterVariable ::="); //$NON-NLS-1$
        }
        consumeEnterVariable();
        break;

    case 159:
        if (DEBUG) {
            System.out.println("ExitVariableWithInitialization ::="); //$NON-NLS-1$
        }
        consumeExitVariableWithInitialization();
        break;

    case 160:
        if (DEBUG) {
            System.out.println("ExitVariableWithoutInitialization ::="); //$NON-NLS-1$
        }
        consumeExitVariableWithoutInitialization();
        break;

    case 161:
        if (DEBUG) {
            System.out.println("ForceNoDiet ::="); //$NON-NLS-1$
        }
        consumeForceNoDiet();
        break;

    case 162:
        if (DEBUG) {
            System.out.println("RestoreDiet ::="); //$NON-NLS-1$
        }
        consumeRestoreDiet();
        break;

    case 167:
        if (DEBUG) {
            System.out.println("MethodDeclaration ::= MethodHeader MethodBody"); //$NON-NLS-1$
        }
        // set to true to consume a method with a body
        consumeMethodDeclaration(true);
        break;

    case 168:
        if (DEBUG) {
            System.out.println("AbstractMethodDeclaration ::= MethodHeader SEMICOLON"); //$NON-NLS-1$
        }
        // set to false to consume a method without body
        consumeMethodDeclaration(false);
        break;

    case 169:
        if (DEBUG) {
            System.out.println("MethodHeader ::= MethodHeaderName FormalParameterListopt"); //$NON-NLS-1$
        }
        consumeMethodHeader();
        break;

    case 170:
        if (DEBUG) {
            System.out.println("MethodHeaderName ::= Modifiersopt TypeParameters Type..."); //$NON-NLS-1$
        }
        consumeMethodHeaderNameWithTypeParameters(false);
        break;

    case 171:
        if (DEBUG) {
            System.out.println("MethodHeaderName ::= Modifiersopt Type Identifier LPAREN"); //$NON-NLS-1$
        }
        consumeMethodHeaderName(false);
        break;

    case 172:
        if (DEBUG) {
            System.out.println("MethodHeaderRightParen ::= RPAREN"); //$NON-NLS-1$
        }
        consumeMethodHeaderRightParen();
        break;

    case 173:
        if (DEBUG) {
            System.out.println("MethodHeaderExtendedDims ::= Dimsopt"); //$NON-NLS-1$
        }
        consumeMethodHeaderExtendedDims();
        break;

    case 174:
        if (DEBUG) {
            System.out.println("MethodHeaderThrowsClause ::= throws ClassTypeList"); //$NON-NLS-1$
        }
        consumeMethodHeaderThrowsClause();
        break;

    case 175:
        if (DEBUG) {
            System.out.println("ConstructorHeader ::= ConstructorHeaderName..."); //$NON-NLS-1$
        }
        consumeConstructorHeader();
        break;

    case 176:
        if (DEBUG) {
            System.out.println("ConstructorHeaderName ::= Modifiersopt TypeParameters..."); //$NON-NLS-1$
        }
        consumeConstructorHeaderNameWithTypeParameters();
        break;

    case 177:
        if (DEBUG) {
            System.out.println("ConstructorHeaderName ::= Modifiersopt Identifier LPAREN"); //$NON-NLS-1$
        }
        consumeConstructorHeaderName();
        break;

    case 179:
        if (DEBUG) {
            System.out.println("FormalParameterList ::= FormalParameterList COMMA..."); //$NON-NLS-1$
        }
        consumeFormalParameterList();
        break;

    case 180:
        if (DEBUG) {
            System.out.println("FormalParameter ::= Modifiersopt Type..."); //$NON-NLS-1$
        }
        consumeFormalParameter(false);
        break;

    case 181:
        if (DEBUG) {
            System.out.println("FormalParameter ::= Modifiersopt Type ELLIPSIS..."); //$NON-NLS-1$
        }
        consumeFormalParameter(true);
        break;

    case 182:
        if (DEBUG) {
            System.out.println("CatchFormalParameter ::= Modifiersopt CatchType..."); //$NON-NLS-1$
        }
        consumeCatchFormalParameter();
        break;

    case 183:
        if (DEBUG) {
            System.out.println("CatchType ::= UnionType"); //$NON-NLS-1$
        }
        consumeCatchType();
        break;

    case 184:
        if (DEBUG) {
            System.out.println("UnionType ::= Type"); //$NON-NLS-1$
        }
        consumeUnionTypeAsClassType();
        break;

    case 185:
        if (DEBUG) {
            System.out.println("UnionType ::= UnionType OR Type"); //$NON-NLS-1$
        }
        consumeUnionType();
        break;

    case 187:
        if (DEBUG) {
            System.out.println("ClassTypeList ::= ClassTypeList COMMA ClassTypeElt"); //$NON-NLS-1$
        }
        consumeClassTypeList();
        break;

    case 188:
        if (DEBUG) {
            System.out.println("ClassTypeElt ::= ClassType"); //$NON-NLS-1$
        }
        consumeClassTypeElt();
        break;

    case 189:
        if (DEBUG) {
            System.out.println("MethodBody ::= NestedMethod LBRACE BlockStatementsopt..."); //$NON-NLS-1$
        }
        consumeMethodBody();
        break;

    case 190:
        if (DEBUG) {
            System.out.println("NestedMethod ::="); //$NON-NLS-1$
        }
        consumeNestedMethod();
        break;

    case 191:
        if (DEBUG) {
            System.out.println("StaticInitializer ::= StaticOnly Block"); //$NON-NLS-1$
        }
        consumeStaticInitializer();
        break;

    case 192:
        if (DEBUG) {
            System.out.println("StaticOnly ::= static"); //$NON-NLS-1$
        }
        consumeStaticOnly();
        break;

    case 193:
        if (DEBUG) {
            System.out.println("ConstructorDeclaration ::= ConstructorHeader MethodBody"); //$NON-NLS-1$
        }
        consumeConstructorDeclaration();
        break;

    case 194:
        if (DEBUG) {
            System.out.println("ConstructorDeclaration ::= ConstructorHeader SEMICOLON"); //$NON-NLS-1$
        }
        consumeInvalidConstructorDeclaration();
        break;

    case 195:
        if (DEBUG) {
            System.out.println("ExplicitConstructorInvocation ::= this LPAREN..."); //$NON-NLS-1$
        }
        consumeExplicitConstructorInvocation(0, THIS_CALL);
        break;

    case 196:
        if (DEBUG) {
            System.out.println("ExplicitConstructorInvocation ::= OnlyTypeArguments this"); //$NON-NLS-1$
        }
        consumeExplicitConstructorInvocationWithTypeArguments(0, THIS_CALL);
        break;

    case 197:
        if (DEBUG) {
            System.out.println("ExplicitConstructorInvocation ::= super LPAREN..."); //$NON-NLS-1$
        }
        consumeExplicitConstructorInvocation(0, SUPER_CALL);
        break;

    case 198:
        if (DEBUG) {
            System.out.println("ExplicitConstructorInvocation ::= OnlyTypeArguments..."); //$NON-NLS-1$
        }
        consumeExplicitConstructorInvocationWithTypeArguments(0, SUPER_CALL);
        break;

    case 199:
        if (DEBUG) {
            System.out.println("ExplicitConstructorInvocation ::= Primary DOT super..."); //$NON-NLS-1$
        }
        consumeExplicitConstructorInvocation(1, SUPER_CALL);
        break;

    case 200:
        if (DEBUG) {
            System.out.println("ExplicitConstructorInvocation ::= Primary DOT..."); //$NON-NLS-1$
        }
        consumeExplicitConstructorInvocationWithTypeArguments(1, SUPER_CALL);
        break;

    case 201:
        if (DEBUG) {
            System.out.println("ExplicitConstructorInvocation ::= Name DOT super LPAREN"); //$NON-NLS-1$
        }
        consumeExplicitConstructorInvocation(2, SUPER_CALL);
        break;

    case 202:
        if (DEBUG) {
            System.out.println("ExplicitConstructorInvocation ::= Name DOT..."); //$NON-NLS-1$
        }
        consumeExplicitConstructorInvocationWithTypeArguments(2, SUPER_CALL);
        break;

    case 203:
        if (DEBUG) {
            System.out.println("ExplicitConstructorInvocation ::= Primary DOT this..."); //$NON-NLS-1$
        }
        consumeExplicitConstructorInvocation(1, THIS_CALL);
        break;

    case 204:
        if (DEBUG) {
            System.out.println("ExplicitConstructorInvocation ::= Primary DOT..."); //$NON-NLS-1$
        }
        consumeExplicitConstructorInvocationWithTypeArguments(1, THIS_CALL);
        break;

    case 205:
        if (DEBUG) {
            System.out.println("ExplicitConstructorInvocation ::= Name DOT this LPAREN"); //$NON-NLS-1$
        }
        consumeExplicitConstructorInvocation(2, THIS_CALL);
        break;

    case 206:
        if (DEBUG) {
            System.out.println("ExplicitConstructorInvocation ::= Name DOT..."); //$NON-NLS-1$
        }
        consumeExplicitConstructorInvocationWithTypeArguments(2, THIS_CALL);
        break;

    case 207:
        if (DEBUG) {
            System.out.println("InterfaceDeclaration ::= InterfaceHeader InterfaceBody"); //$NON-NLS-1$
        }
        consumeInterfaceDeclaration();
        break;

    case 208:
        if (DEBUG) {
            System.out.println("InterfaceHeader ::= InterfaceHeaderName..."); //$NON-NLS-1$
        }
        consumeInterfaceHeader();
        break;

    case 209:
        if (DEBUG) {
            System.out.println("InterfaceHeaderName ::= InterfaceHeaderName1..."); //$NON-NLS-1$
        }
        consumeTypeHeaderNameWithTypeParameters();
        break;

    case 211:
        if (DEBUG) {
            System.out.println("InterfaceHeaderName1 ::= Modifiersopt interface..."); //$NON-NLS-1$
        }
        consumeInterfaceHeaderName1();
        break;

    case 212:
        if (DEBUG) {
            System.out.println("InterfaceHeaderExtends ::= extends InterfaceTypeList"); //$NON-NLS-1$
        }
        consumeInterfaceHeaderExtends();
        break;

    case 215:
        if (DEBUG) {
            System.out.println("InterfaceMemberDeclarations ::=..."); //$NON-NLS-1$
        }
        consumeInterfaceMemberDeclarations();
        break;

    case 216:
        if (DEBUG) {
            System.out.println("InterfaceMemberDeclaration ::= SEMICOLON"); //$NON-NLS-1$
        }
        consumeEmptyTypeDeclaration();
        break;

    case 218:
        if (DEBUG) {
            System.out.println("InterfaceMemberDeclaration ::= MethodHeader MethodBody"); //$NON-NLS-1$
        }
        consumeInvalidMethodDeclaration();
        break;

    case 219:
        if (DEBUG) {
            System.out.println("InvalidConstructorDeclaration ::= ConstructorHeader..."); //$NON-NLS-1$
        }
        consumeInvalidConstructorDeclaration(true);
        break;

    case 220:
        if (DEBUG) {
            System.out.println("InvalidConstructorDeclaration ::= ConstructorHeader..."); //$NON-NLS-1$
        }
        consumeInvalidConstructorDeclaration(false);
        break;

    case 231:
        if (DEBUG) {
            System.out.println("PushLeftBrace ::="); //$NON-NLS-1$
        }
        consumePushLeftBrace();
        break;

    case 232:
        if (DEBUG) {
            System.out.println("ArrayInitializer ::= LBRACE PushLeftBrace ,opt RBRACE"); //$NON-NLS-1$
        }
        consumeEmptyArrayInitializer();
        break;

    case 233:
        if (DEBUG) {
            System.out.println("ArrayInitializer ::= LBRACE PushLeftBrace..."); //$NON-NLS-1$
        }
        consumeArrayInitializer();
        break;

    case 234:
        if (DEBUG) {
            System.out.println("ArrayInitializer ::= LBRACE PushLeftBrace..."); //$NON-NLS-1$
        }
        consumeArrayInitializer();
        break;

    case 236:
        if (DEBUG) {
            System.out.println("VariableInitializers ::= VariableInitializers COMMA..."); //$NON-NLS-1$
        }
        consumeVariableInitializers();
        break;

    case 237:
        if (DEBUG) {
            System.out.println("Block ::= OpenBlock LBRACE BlockStatementsopt RBRACE"); //$NON-NLS-1$
        }
        consumeBlock();
        break;

    case 238:
        if (DEBUG) {
            System.out.println("OpenBlock ::="); //$NON-NLS-1$
        }
        consumeOpenBlock();
        break;

    case 240:
        if (DEBUG) {
            System.out.println("BlockStatements ::= BlockStatements BlockStatement"); //$NON-NLS-1$
        }
        consumeBlockStatements();
        break;

    case 244:
        if (DEBUG) {
            System.out.println("BlockStatement ::= InterfaceDeclaration"); //$NON-NLS-1$
        }
        consumeInvalidInterfaceDeclaration();
        break;

    case 245:
        if (DEBUG) {
            System.out.println("BlockStatement ::= AnnotationTypeDeclaration"); //$NON-NLS-1$
        }
        consumeInvalidAnnotationTypeDeclaration();
        break;

    case 246:
        if (DEBUG) {
            System.out.println("BlockStatement ::= EnumDeclaration"); //$NON-NLS-1$
        }
        consumeInvalidEnumDeclaration();
        break;

    case 247:
        if (DEBUG) {
            System.out.println("LocalVariableDeclarationStatement ::=..."); //$NON-NLS-1$
        }
        consumeLocalVariableDeclarationStatement();
        break;

    case 248:
        if (DEBUG) {
            System.out.println("LocalVariableDeclaration ::= Type PushModifiers..."); //$NON-NLS-1$
        }
        consumeLocalVariableDeclaration();
        break;

    case 249:
        if (DEBUG) {
            System.out.println("LocalVariableDeclaration ::= Modifiers Type..."); //$NON-NLS-1$
        }
        consumeLocalVariableDeclaration();
        break;

    case 250:
        if (DEBUG) {
            System.out.println("PushModifiers ::="); //$NON-NLS-1$
        }
        consumePushModifiers();
        break;

    case 251:
        if (DEBUG) {
            System.out.println("PushModifiersForHeader ::="); //$NON-NLS-1$
        }
        consumePushModifiersForHeader();
        break;

    case 252:
        if (DEBUG) {
            System.out.println("PushRealModifiers ::="); //$NON-NLS-1$
        }
        consumePushRealModifiers();
        break;

    case 279:
        if (DEBUG) {
            System.out.println("EmptyStatement ::= SEMICOLON"); //$NON-NLS-1$
        }
        consumeEmptyStatement();
        break;

    case 280:
        if (DEBUG) {
            System.out.println("LabeledStatement ::= Label COLON Statement"); //$NON-NLS-1$
        }
        consumeStatementLabel();
        break;

    case 281:
        if (DEBUG) {
            System.out.println("LabeledStatementNoShortIf ::= Label COLON..."); //$NON-NLS-1$
        }
        consumeStatementLabel();
        break;

    case 282:
        if (DEBUG) {
            System.out.println("Label ::= Identifier"); //$NON-NLS-1$
        }
        consumeLabel();
        break;

    case 283:
        if (DEBUG) {
            System.out.println("ExpressionStatement ::= StatementExpression SEMICOLON"); //$NON-NLS-1$
        }
        consumeExpressionStatement();
        break;

    case 292:
        if (DEBUG) {
            System.out.println("IfThenStatement ::= if LPAREN Expression RPAREN..."); //$NON-NLS-1$
        }
        consumeStatementIfNoElse();
        break;

    case 293:
        if (DEBUG) {
            System.out.println("IfThenElseStatement ::= if LPAREN Expression RPAREN..."); //$NON-NLS-1$
        }
        consumeStatementIfWithElse();
        break;

    case 294:
        if (DEBUG) {
            System.out.println("IfThenElseStatementNoShortIf ::= if LPAREN Expression..."); //$NON-NLS-1$
        }
        consumeStatementIfWithElse();
        break;

    case 295:
        if (DEBUG) {
            System.out.println("SwitchStatement ::= switch LPAREN Expression RPAREN..."); //$NON-NLS-1$
        }
        consumeStatementSwitch();
        break;

    case 296:
        if (DEBUG) {
            System.out.println("SwitchBlock ::= LBRACE RBRACE"); //$NON-NLS-1$
        }
        consumeEmptySwitchBlock();
        break;

    case 299:
        if (DEBUG) {
            System.out.println("SwitchBlock ::= LBRACE SwitchBlockStatements..."); //$NON-NLS-1$
        }
        consumeSwitchBlock();
        break;

    case 301:
        if (DEBUG) {
            System.out.println("SwitchBlockStatements ::= SwitchBlockStatements..."); //$NON-NLS-1$
        }
        consumeSwitchBlockStatements();
        break;

    case 302:
        if (DEBUG) {
            System.out.println("SwitchBlockStatement ::= SwitchLabels BlockStatements"); //$NON-NLS-1$
        }
        consumeSwitchBlockStatement();
        break;

    case 304:
        if (DEBUG) {
            System.out.println("SwitchLabels ::= SwitchLabels SwitchLabel"); //$NON-NLS-1$
        }
        consumeSwitchLabels();
        break;

    case 305:
        if (DEBUG) {
            System.out.println("SwitchLabel ::= case ConstantExpression COLON"); //$NON-NLS-1$
        }
        consumeCaseLabel();
        break;

    case 306:
        if (DEBUG) {
            System.out.println("SwitchLabel ::= default COLON"); //$NON-NLS-1$
        }
        consumeDefaultLabel();
        break;

    case 307:
        if (DEBUG) {
            System.out.println("WhileStatement ::= while LPAREN Expression RPAREN..."); //$NON-NLS-1$
        }
        consumeStatementWhile();
        break;

    case 308:
        if (DEBUG) {
            System.out.println("WhileStatementNoShortIf ::= while LPAREN Expression..."); //$NON-NLS-1$
        }
        consumeStatementWhile();
        break;

    case 309:
        if (DEBUG) {
            System.out.println("DoStatement ::= do Statement while LPAREN Expression..."); //$NON-NLS-1$
        }
        consumeStatementDo();
        break;

    case 310:
        if (DEBUG) {
            System.out.println("ForStatement ::= for LPAREN ForInitopt SEMICOLON..."); //$NON-NLS-1$
        }
        consumeStatementFor();
        break;

    case 311:
        if (DEBUG) {
            System.out.println("ForStatementNoShortIf ::= for LPAREN ForInitopt..."); //$NON-NLS-1$
        }
        consumeStatementFor();
        break;

    case 312:
        if (DEBUG) {
            System.out.println("ForInit ::= StatementExpressionList"); //$NON-NLS-1$
        }
        consumeForInit();
        break;

    case 316:
        if (DEBUG) {
            System.out.println("StatementExpressionList ::= StatementExpressionList..."); //$NON-NLS-1$
        }
        consumeStatementExpressionList();
        break;

    case 317:
        if (DEBUG) {
            System.out.println("AssertStatement ::= assert Expression SEMICOLON"); //$NON-NLS-1$
        }
        consumeSimpleAssertStatement();
        break;

    case 318:
        if (DEBUG) {
            System.out.println("AssertStatement ::= assert Expression COLON Expression"); //$NON-NLS-1$
        }
        consumeAssertStatement();
        break;

    case 319:
        if (DEBUG) {
            System.out.println("BreakStatement ::= break SEMICOLON"); //$NON-NLS-1$
        }
        consumeStatementBreak();
        break;

    case 320:
        if (DEBUG) {
            System.out.println("BreakStatement ::= break Identifier SEMICOLON"); //$NON-NLS-1$
        }
        consumeStatementBreakWithLabel();
        break;

    case 321:
        if (DEBUG) {
            System.out.println("ContinueStatement ::= continue SEMICOLON"); //$NON-NLS-1$
        }
        consumeStatementContinue();
        break;

    case 322:
        if (DEBUG) {
            System.out.println("ContinueStatement ::= continue Identifier SEMICOLON"); //$NON-NLS-1$
        }
        consumeStatementContinueWithLabel();
        break;

    case 323:
        if (DEBUG) {
            System.out.println("ReturnStatement ::= return Expressionopt SEMICOLON"); //$NON-NLS-1$
        }
        consumeStatementReturn();
        break;

    case 324:
        if (DEBUG) {
            System.out.println("ThrowStatement ::= throw Expression SEMICOLON"); //$NON-NLS-1$
        }
        consumeStatementThrow();
        break;

    case 325:
        if (DEBUG) {
            System.out.println("SynchronizedStatement ::= OnlySynchronized LPAREN..."); //$NON-NLS-1$
        }
        consumeStatementSynchronized();
        break;

    case 326:
        if (DEBUG) {
            System.out.println("OnlySynchronized ::= synchronized"); //$NON-NLS-1$
        }
        consumeOnlySynchronized();
        break;

    case 327:
        if (DEBUG) {
            System.out.println("TryStatement ::= try TryBlock Catches"); //$NON-NLS-1$
        }
        consumeStatementTry(false, false);
        break;

    case 328:
        if (DEBUG) {
            System.out.println("TryStatement ::= try TryBlock Catchesopt Finally"); //$NON-NLS-1$
        }
        consumeStatementTry(true, false);
        break;

    case 329:
        if (DEBUG) {
            System.out.println("TryStatementWithResources ::= try ResourceSpecification"); //$NON-NLS-1$
        }
        consumeStatementTry(false, true);
        break;

    case 330:
        if (DEBUG) {
            System.out.println("TryStatementWithResources ::= try ResourceSpecification"); //$NON-NLS-1$
        }
        consumeStatementTry(true, true);
        break;

    case 331:
        if (DEBUG) {
            System.out.println("ResourceSpecification ::= LPAREN Resources ;opt RPAREN"); //$NON-NLS-1$
        }
        consumeResourceSpecification();
        break;

    case 332:
        if (DEBUG) {
            System.out.println(";opt ::="); //$NON-NLS-1$
        }
        consumeResourceOptionalTrailingSemiColon(false);
        break;

    case 333:
        if (DEBUG) {
            System.out.println(";opt ::= SEMICOLON"); //$NON-NLS-1$
        }
        consumeResourceOptionalTrailingSemiColon(true);
        break;

    case 334:
        if (DEBUG) {
            System.out.println("Resources ::= Resource"); //$NON-NLS-1$
        }
        consumeSingleResource();
        break;

    case 335:
        if (DEBUG) {
            System.out.println("Resources ::= Resources TrailingSemiColon Resource"); //$NON-NLS-1$
        }
        consumeMultipleResources();
        break;

    case 336:
        if (DEBUG) {
            System.out.println("TrailingSemiColon ::= SEMICOLON"); //$NON-NLS-1$
        }
        consumeResourceOptionalTrailingSemiColon(true);
        break;

    case 337:
        if (DEBUG) {
            System.out.println("Resource ::= Type PushModifiers VariableDeclaratorId..."); //$NON-NLS-1$
        }
        consumeResourceAsLocalVariableDeclaration();
        break;

    case 338:
        if (DEBUG) {
            System.out.println("Resource ::= Modifiers Type PushRealModifiers..."); //$NON-NLS-1$
        }
        consumeResourceAsLocalVariableDeclaration();
        break;

    case 340:
        if (DEBUG) {
            System.out.println("ExitTryBlock ::="); //$NON-NLS-1$
        }
        consumeExitTryBlock();
        break;

    case 342:
        if (DEBUG) {
            System.out.println("Catches ::= Catches CatchClause"); //$NON-NLS-1$
        }
        consumeCatches();
        break;

    case 343:
        if (DEBUG) {
            System.out.println("CatchClause ::= catch LPAREN CatchFormalParameter RPAREN"); //$NON-NLS-1$
        }
        consumeStatementCatch();
        break;

    case 345:
        if (DEBUG) {
            System.out.println("PushLPAREN ::= LPAREN"); //$NON-NLS-1$
        }
        consumeLeftParen();
        break;

    case 346:
        if (DEBUG) {
            System.out.println("PushRPAREN ::= RPAREN"); //$NON-NLS-1$
        }
        consumeRightParen();
        break;

    case 351:
        if (DEBUG) {
            System.out.println("PrimaryNoNewArray ::= this"); //$NON-NLS-1$
        }
        consumePrimaryNoNewArrayThis();
        break;

    case 352:
        if (DEBUG) {
            System.out.println("PrimaryNoNewArray ::= PushLPAREN Expression_NotName..."); //$NON-NLS-1$
        }
        consumePrimaryNoNewArray();
        break;

    case 353:
        if (DEBUG) {
            System.out.println("PrimaryNoNewArray ::= PushLPAREN Name PushRPAREN"); //$NON-NLS-1$
        }
        consumePrimaryNoNewArrayWithName();
        break;

    case 356:
        if (DEBUG) {
            System.out.println("PrimaryNoNewArray ::= Name DOT this"); //$NON-NLS-1$
        }
        consumePrimaryNoNewArrayNameThis();
        break;

    case 357:
        if (DEBUG) {
            System.out.println("PrimaryNoNewArray ::= Name DOT super"); //$NON-NLS-1$
        }
        consumePrimaryNoNewArrayNameSuper();
        break;

    case 358:
        if (DEBUG) {
            System.out.println("PrimaryNoNewArray ::= Name DOT class"); //$NON-NLS-1$
        }
        consumePrimaryNoNewArrayName();
        break;

    case 359:
        if (DEBUG) {
            System.out.println("PrimaryNoNewArray ::= Name Dims DOT class"); //$NON-NLS-1$
        }
        consumePrimaryNoNewArrayArrayType();
        break;

    case 360:
        if (DEBUG) {
            System.out.println("PrimaryNoNewArray ::= PrimitiveType Dims DOT class"); //$NON-NLS-1$
        }
        consumePrimaryNoNewArrayPrimitiveArrayType();
        break;

    case 361:
        if (DEBUG) {
            System.out.println("PrimaryNoNewArray ::= PrimitiveType DOT class"); //$NON-NLS-1$
        }
        consumePrimaryNoNewArrayPrimitiveType();
        break;

    case 364:
        if (DEBUG) {
            System.out.println("AllocationHeader ::= new ClassType LPAREN..."); //$NON-NLS-1$
        }
        consumeAllocationHeader();
        break;

    case 365:
        if (DEBUG) {
            System.out.println("ClassInstanceCreationExpression ::= new..."); //$NON-NLS-1$
        }
        consumeClassInstanceCreationExpressionWithTypeArguments();
        break;

    case 366:
        if (DEBUG) {
            System.out.println("ClassInstanceCreationExpression ::= new ClassType LPAREN"); //$NON-NLS-1$
        }
        consumeClassInstanceCreationExpression();
        break;

    case 367:
        if (DEBUG) {
            System.out.println("ClassInstanceCreationExpression ::= Primary DOT new..."); //$NON-NLS-1$
        }
        consumeClassInstanceCreationExpressionQualifiedWithTypeArguments();
        break;

    case 368:
        if (DEBUG) {
            System.out.println("ClassInstanceCreationExpression ::= Primary DOT new..."); //$NON-NLS-1$
        }
        consumeClassInstanceCreationExpressionQualified();
        break;

    case 369:
        if (DEBUG) {
            System.out.println("ClassInstanceCreationExpression ::=..."); //$NON-NLS-1$
        }
        consumeClassInstanceCreationExpressionQualified();
        break;

    case 370:
        if (DEBUG) {
            System.out.println("ClassInstanceCreationExpression ::=..."); //$NON-NLS-1$
        }
        consumeClassInstanceCreationExpressionQualifiedWithTypeArguments();
        break;

    case 371:
        if (DEBUG) {
            System.out.println("ClassInstanceCreationExpressionName ::= Name DOT"); //$NON-NLS-1$
        }
        consumeClassInstanceCreationExpressionName();
        break;

    case 372:
        if (DEBUG) {
            System.out.println("UnqualifiedClassBodyopt ::="); //$NON-NLS-1$
        }
        consumeClassBodyopt();
        break;

    case 374:
        if (DEBUG) {
            System.out.println("UnqualifiedEnterAnonymousClassBody ::="); //$NON-NLS-1$
        }
        consumeEnterAnonymousClassBody(false);
        break;

    case 375:
        if (DEBUG) {
            System.out.println("QualifiedClassBodyopt ::="); //$NON-NLS-1$
        }
        consumeClassBodyopt();
        break;

    case 377:
        if (DEBUG) {
            System.out.println("QualifiedEnterAnonymousClassBody ::="); //$NON-NLS-1$
        }
        consumeEnterAnonymousClassBody(true);
        break;

    case 379:
        if (DEBUG) {
            System.out.println("ArgumentList ::= ArgumentList COMMA Expression"); //$NON-NLS-1$
        }
        consumeArgumentList();
        break;

    case 380:
        if (DEBUG) {
            System.out.println("ArrayCreationHeader ::= new PrimitiveType..."); //$NON-NLS-1$
        }
        consumeArrayCreationHeader();
        break;

    case 381:
        if (DEBUG) {
            System.out.println("ArrayCreationHeader ::= new ClassOrInterfaceType..."); //$NON-NLS-1$
        }
        consumeArrayCreationHeader();
        break;

    case 382:
        if (DEBUG) {
            System.out.println("ArrayCreationWithoutArrayInitializer ::= new..."); //$NON-NLS-1$
        }
        consumeArrayCreationExpressionWithoutInitializer();
        break;

    case 383:
        if (DEBUG) {
            System.out.println("ArrayCreationWithArrayInitializer ::= new PrimitiveType"); //$NON-NLS-1$
        }
        consumeArrayCreationExpressionWithInitializer();
        break;

    case 384:
        if (DEBUG) {
            System.out.println("ArrayCreationWithoutArrayInitializer ::= new..."); //$NON-NLS-1$
        }
        consumeArrayCreationExpressionWithoutInitializer();
        break;

    case 385:
        if (DEBUG) {
            System.out.println("ArrayCreationWithArrayInitializer ::= new..."); //$NON-NLS-1$
        }
        consumeArrayCreationExpressionWithInitializer();
        break;

    case 387:
        if (DEBUG) {
            System.out.println("DimWithOrWithOutExprs ::= DimWithOrWithOutExprs..."); //$NON-NLS-1$
        }
        consumeDimWithOrWithOutExprs();
        break;

    case 389:
        if (DEBUG) {
            System.out.println("DimWithOrWithOutExpr ::= LBRACKET RBRACKET"); //$NON-NLS-1$
        }
        consumeDimWithOrWithOutExpr();
        break;

    case 390:
        if (DEBUG) {
            System.out.println("Dims ::= DimsLoop"); //$NON-NLS-1$
        }
        consumeDims();
        break;

    case 393:
        if (DEBUG) {
            System.out.println("OneDimLoop ::= LBRACKET RBRACKET"); //$NON-NLS-1$
        }
        consumeOneDimLoop();
        break;

    case 394:
        if (DEBUG) {
            System.out.println("FieldAccess ::= Primary DOT Identifier"); //$NON-NLS-1$
        }
        consumeFieldAccess(false);
        break;

    case 395:
        if (DEBUG) {
            System.out.println("FieldAccess ::= super DOT Identifier"); //$NON-NLS-1$
        }
        consumeFieldAccess(true);
        break;

    case 396:
        if (DEBUG) {
            System.out.println("MethodInvocation ::= Name LPAREN ArgumentListopt RPAREN"); //$NON-NLS-1$
        }
        consumeMethodInvocationName();
        break;

    case 397:
        if (DEBUG) {
            System.out.println("MethodInvocation ::= Name DOT OnlyTypeArguments..."); //$NON-NLS-1$
        }
        consumeMethodInvocationNameWithTypeArguments();
        break;

    case 398:
        if (DEBUG) {
            System.out.println("MethodInvocation ::= Primary DOT OnlyTypeArguments..."); //$NON-NLS-1$
        }
        consumeMethodInvocationPrimaryWithTypeArguments();
        break;

    case 399:
        if (DEBUG) {
            System.out.println("MethodInvocation ::= Primary DOT Identifier LPAREN..."); //$NON-NLS-1$
        }
        consumeMethodInvocationPrimary();
        break;

    case 400:
        if (DEBUG) {
            System.out.println("MethodInvocation ::= super DOT OnlyTypeArguments..."); //$NON-NLS-1$
        }
        consumeMethodInvocationSuperWithTypeArguments();
        break;

    case 401:
        if (DEBUG) {
            System.out.println("MethodInvocation ::= super DOT Identifier LPAREN..."); //$NON-NLS-1$
        }
        consumeMethodInvocationSuper();
        break;

    case 402:
        if (DEBUG) {
            System.out.println("ArrayAccess ::= Name LBRACKET Expression RBRACKET"); //$NON-NLS-1$
        }
        consumeArrayAccess(true);
        break;

    case 403:
        if (DEBUG) {
            System.out.println("ArrayAccess ::= PrimaryNoNewArray LBRACKET Expression..."); //$NON-NLS-1$
        }
        consumeArrayAccess(false);
        break;

    case 404:
        if (DEBUG) {
            System.out.println("ArrayAccess ::= ArrayCreationWithArrayInitializer..."); //$NON-NLS-1$
        }
        consumeArrayAccess(false);
        break;

    case 406:
        if (DEBUG) {
            System.out.println("PostfixExpression ::= Name"); //$NON-NLS-1$
        }
        consumePostfixExpression();
        break;

    case 409:
        if (DEBUG) {
            System.out.println("PostIncrementExpression ::= PostfixExpression PLUS_PLUS"); //$NON-NLS-1$
        }
        consumeUnaryExpression(OperatorIds.PLUS, true);
        break;

    case 410:
        if (DEBUG) {
            System.out.println("PostDecrementExpression ::= PostfixExpression..."); //$NON-NLS-1$
        }
        consumeUnaryExpression(OperatorIds.MINUS, true);
        break;

    case 411:
        if (DEBUG) {
            System.out.println("PushPosition ::="); //$NON-NLS-1$
        }
        consumePushPosition();
        break;

    case 414:
        if (DEBUG) {
            System.out.println("UnaryExpression ::= PLUS PushPosition UnaryExpression"); //$NON-NLS-1$
        }
        consumeUnaryExpression(OperatorIds.PLUS);
        break;

    case 415:
        if (DEBUG) {
            System.out.println("UnaryExpression ::= MINUS PushPosition UnaryExpression"); //$NON-NLS-1$
        }
        consumeUnaryExpression(OperatorIds.MINUS);
        break;

    case 417:
        if (DEBUG) {
            System.out.println("PreIncrementExpression ::= PLUS_PLUS PushPosition..."); //$NON-NLS-1$
        }
        consumeUnaryExpression(OperatorIds.PLUS, false);
        break;

    case 418:
        if (DEBUG) {
            System.out.println("PreDecrementExpression ::= MINUS_MINUS PushPosition..."); //$NON-NLS-1$
        }
        consumeUnaryExpression(OperatorIds.MINUS, false);
        break;

    case 420:
        if (DEBUG) {
            System.out.println("UnaryExpressionNotPlusMinus ::= TWIDDLE PushPosition..."); //$NON-NLS-1$
        }
        consumeUnaryExpression(OperatorIds.TWIDDLE);
        break;

    case 421:
        if (DEBUG) {
            System.out.println("UnaryExpressionNotPlusMinus ::= NOT PushPosition..."); //$NON-NLS-1$
        }
        consumeUnaryExpression(OperatorIds.NOT);
        break;

    case 423:
        if (DEBUG) {
            System.out.println("CastExpression ::= PushLPAREN PrimitiveType Dimsopt..."); //$NON-NLS-1$
        }
        consumeCastExpressionWithPrimitiveType();
        break;

    case 424:
        if (DEBUG) {
            System.out.println("CastExpression ::= PushLPAREN Name..."); //$NON-NLS-1$
        }
        consumeCastExpressionWithGenericsArray();
        break;

    case 425:
        if (DEBUG) {
            System.out.println("CastExpression ::= PushLPAREN Name..."); //$NON-NLS-1$
        }
        consumeCastExpressionWithQualifiedGenericsArray();
        break;

    case 426:
        if (DEBUG) {
            System.out.println("CastExpression ::= PushLPAREN Name PushRPAREN..."); //$NON-NLS-1$
        }
        consumeCastExpressionLL1();
        break;

    case 427:
        if (DEBUG) {
            System.out.println("CastExpression ::= PushLPAREN Name Dims PushRPAREN..."); //$NON-NLS-1$
        }
        consumeCastExpressionWithNameArray();
        break;

    case 428:
        if (DEBUG) {
            System.out.println("OnlyTypeArgumentsForCastExpression ::= OnlyTypeArguments"); //$NON-NLS-1$
        }
        consumeOnlyTypeArgumentsForCastExpression();
        break;

    case 429:
        if (DEBUG) {
            System.out.println("InsideCastExpression ::="); //$NON-NLS-1$
        }
        consumeInsideCastExpression();
        break;

    case 430:
        if (DEBUG) {
            System.out.println("InsideCastExpressionLL1 ::="); //$NON-NLS-1$
        }
        consumeInsideCastExpressionLL1();
        break;

    case 431:
        if (DEBUG) {
            System.out.println("InsideCastExpressionWithQualifiedGenerics ::="); //$NON-NLS-1$
        }
        consumeInsideCastExpressionWithQualifiedGenerics();
        break;

    case 433:
        if (DEBUG) {
            System.out.println("MultiplicativeExpression ::= MultiplicativeExpression..."); //$NON-NLS-1$
        }
        consumeBinaryExpression(OperatorIds.MULTIPLY);
        break;

    case 434:
        if (DEBUG) {
            System.out.println("MultiplicativeExpression ::= MultiplicativeExpression..."); //$NON-NLS-1$
        }
        consumeBinaryExpression(OperatorIds.DIVIDE);
        break;

    case 435:
        if (DEBUG) {
            System.out.println("MultiplicativeExpression ::= MultiplicativeExpression..."); //$NON-NLS-1$
        }
        consumeBinaryExpression(OperatorIds.REMAINDER);
        break;

    case 437:
        if (DEBUG) {
            System.out.println("AdditiveExpression ::= AdditiveExpression PLUS..."); //$NON-NLS-1$
        }
        consumeBinaryExpression(OperatorIds.PLUS);
        break;

    case 438:
        if (DEBUG) {
            System.out.println("AdditiveExpression ::= AdditiveExpression MINUS..."); //$NON-NLS-1$
        }
        consumeBinaryExpression(OperatorIds.MINUS);
        break;

    case 440:
        if (DEBUG) {
            System.out.println("ShiftExpression ::= ShiftExpression LEFT_SHIFT..."); //$NON-NLS-1$
        }
        consumeBinaryExpression(OperatorIds.LEFT_SHIFT);
        break;

    case 441:
        if (DEBUG) {
            System.out.println("ShiftExpression ::= ShiftExpression RIGHT_SHIFT..."); //$NON-NLS-1$
        }
        consumeBinaryExpression(OperatorIds.RIGHT_SHIFT);
        break;

    case 442:
        if (DEBUG) {
            System.out.println("ShiftExpression ::= ShiftExpression UNSIGNED_RIGHT_SHIFT"); //$NON-NLS-1$
        }
        consumeBinaryExpression(OperatorIds.UNSIGNED_RIGHT_SHIFT);
        break;

    case 444:
        if (DEBUG) {
            System.out.println("RelationalExpression ::= RelationalExpression LESS..."); //$NON-NLS-1$
        }
        consumeBinaryExpression(OperatorIds.LESS);
        break;

    case 445:
        if (DEBUG) {
            System.out.println("RelationalExpression ::= RelationalExpression GREATER..."); //$NON-NLS-1$
        }
        consumeBinaryExpression(OperatorIds.GREATER);
        break;

    case 446:
        if (DEBUG) {
            System.out.println("RelationalExpression ::= RelationalExpression LESS_EQUAL"); //$NON-NLS-1$
        }
        consumeBinaryExpression(OperatorIds.LESS_EQUAL);
        break;

    case 447:
        if (DEBUG) {
            System.out.println("RelationalExpression ::= RelationalExpression..."); //$NON-NLS-1$
        }
        consumeBinaryExpression(OperatorIds.GREATER_EQUAL);
        break;

    case 449:
        if (DEBUG) {
            System.out.println("InstanceofExpression ::= InstanceofExpression instanceof"); //$NON-NLS-1$
        }
        consumeInstanceOfExpression();
        break;

    case 451:
        if (DEBUG) {
            System.out.println("EqualityExpression ::= EqualityExpression EQUAL_EQUAL..."); //$NON-NLS-1$
        }
        consumeEqualityExpression(OperatorIds.EQUAL_EQUAL);
        break;

    case 452:
        if (DEBUG) {
            System.out.println("EqualityExpression ::= EqualityExpression NOT_EQUAL..."); //$NON-NLS-1$
        }
        consumeEqualityExpression(OperatorIds.NOT_EQUAL);
        break;

    case 454:
        if (DEBUG) {
            System.out.println("AndExpression ::= AndExpression AND EqualityExpression"); //$NON-NLS-1$
        }
        consumeBinaryExpression(OperatorIds.AND);
        break;

    case 456:
        if (DEBUG) {
            System.out.println("ExclusiveOrExpression ::= ExclusiveOrExpression XOR..."); //$NON-NLS-1$
        }
        consumeBinaryExpression(OperatorIds.XOR);
        break;

    case 458:
        if (DEBUG) {
            System.out.println("InclusiveOrExpression ::= InclusiveOrExpression OR..."); //$NON-NLS-1$
        }
        consumeBinaryExpression(OperatorIds.OR);
        break;

    case 460:
        if (DEBUG) {
            System.out.println("ConditionalAndExpression ::= ConditionalAndExpression..."); //$NON-NLS-1$
        }
        consumeBinaryExpression(OperatorIds.AND_AND);
        break;

    case 462:
        if (DEBUG) {
            System.out.println("ConditionalOrExpression ::= ConditionalOrExpression..."); //$NON-NLS-1$
        }
        consumeBinaryExpression(OperatorIds.OR_OR);
        break;

    case 464:
        if (DEBUG) {
            System.out.println("ConditionalExpression ::= ConditionalOrExpression..."); //$NON-NLS-1$
        }
        consumeConditionalExpression(OperatorIds.QUESTIONCOLON);
        break;

    case 467:
        if (DEBUG) {
            System.out.println("Assignment ::= PostfixExpression AssignmentOperator..."); //$NON-NLS-1$
        }
        consumeAssignment();
        break;

    case 469:
        if (DEBUG) {
            System.out.println("Assignment ::= InvalidArrayInitializerAssignement"); //$NON-NLS-1$
        }
        ignoreExpressionAssignment();
        break;

    case 470:
        if (DEBUG) {
            System.out.println("AssignmentOperator ::= EQUAL"); //$NON-NLS-1$
        }
        consumeAssignmentOperator(EQUAL);
        break;

    case 471:
        if (DEBUG) {
            System.out.println("AssignmentOperator ::= MULTIPLY_EQUAL"); //$NON-NLS-1$
        }
        consumeAssignmentOperator(MULTIPLY);
        break;

    case 472:
        if (DEBUG) {
            System.out.println("AssignmentOperator ::= DIVIDE_EQUAL"); //$NON-NLS-1$
        }
        consumeAssignmentOperator(DIVIDE);
        break;

    case 473:
        if (DEBUG) {
            System.out.println("AssignmentOperator ::= REMAINDER_EQUAL"); //$NON-NLS-1$
        }
        consumeAssignmentOperator(REMAINDER);
        break;

    case 474:
        if (DEBUG) {
            System.out.println("AssignmentOperator ::= PLUS_EQUAL"); //$NON-NLS-1$
        }
        consumeAssignmentOperator(PLUS);
        break;

    case 475:
        if (DEBUG) {
            System.out.println("AssignmentOperator ::= MINUS_EQUAL"); //$NON-NLS-1$
        }
        consumeAssignmentOperator(MINUS);
        break;

    case 476:
        if (DEBUG) {
            System.out.println("AssignmentOperator ::= LEFT_SHIFT_EQUAL"); //$NON-NLS-1$
        }
        consumeAssignmentOperator(LEFT_SHIFT);
        break;

    case 477:
        if (DEBUG) {
            System.out.println("AssignmentOperator ::= RIGHT_SHIFT_EQUAL"); //$NON-NLS-1$
        }
        consumeAssignmentOperator(RIGHT_SHIFT);
        break;

    case 478:
        if (DEBUG) {
            System.out.println("AssignmentOperator ::= UNSIGNED_RIGHT_SHIFT_EQUAL"); //$NON-NLS-1$
        }
        consumeAssignmentOperator(UNSIGNED_RIGHT_SHIFT);
        break;

    case 479:
        if (DEBUG) {
            System.out.println("AssignmentOperator ::= AND_EQUAL"); //$NON-NLS-1$
        }
        consumeAssignmentOperator(AND);
        break;

    case 480:
        if (DEBUG) {
            System.out.println("AssignmentOperator ::= XOR_EQUAL"); //$NON-NLS-1$
        }
        consumeAssignmentOperator(XOR);
        break;

    case 481:
        if (DEBUG) {
            System.out.println("AssignmentOperator ::= OR_EQUAL"); //$NON-NLS-1$
        }
        consumeAssignmentOperator(OR);
        break;

    case 485:
        if (DEBUG) {
            System.out.println("Expressionopt ::="); //$NON-NLS-1$
        }
        consumeEmptyExpression();
        break;

    case 490:
        if (DEBUG) {
            System.out.println("ClassBodyDeclarationsopt ::="); //$NON-NLS-1$
        }
        consumeEmptyClassBodyDeclarationsopt();
        break;

    case 491:
        if (DEBUG) {
            System.out.println("ClassBodyDeclarationsopt ::= NestedType..."); //$NON-NLS-1$
        }
        consumeClassBodyDeclarationsopt();
        break;

    case 492:
        if (DEBUG) {
            System.out.println("Modifiersopt ::="); //$NON-NLS-1$
        }
        consumeDefaultModifiers();
        break;

    case 493:
        if (DEBUG) {
            System.out.println("Modifiersopt ::= Modifiers"); //$NON-NLS-1$
        }
        consumeModifiers();
        break;

    case 494:
        if (DEBUG) {
            System.out.println("BlockStatementsopt ::="); //$NON-NLS-1$
        }
        consumeEmptyBlockStatementsopt();
        break;

    case 496:
        if (DEBUG) {
            System.out.println("Dimsopt ::="); //$NON-NLS-1$
        }
        consumeEmptyDimsopt();
        break;

    case 498:
        if (DEBUG) {
            System.out.println("ArgumentListopt ::="); //$NON-NLS-1$
        }
        consumeEmptyArgumentListopt();
        break;

    case 502:
        if (DEBUG) {
            System.out.println("FormalParameterListopt ::="); //$NON-NLS-1$
        }
        consumeFormalParameterListopt();
        break;

    case 506:
        if (DEBUG) {
            System.out.println("InterfaceMemberDeclarationsopt ::="); //$NON-NLS-1$
        }
        consumeEmptyInterfaceMemberDeclarationsopt();
        break;

    case 507:
        if (DEBUG) {
            System.out.println("InterfaceMemberDeclarationsopt ::= NestedType..."); //$NON-NLS-1$
        }
        consumeInterfaceMemberDeclarationsopt();
        break;

    case 508:
        if (DEBUG) {
            System.out.println("NestedType ::="); //$NON-NLS-1$
        }
        consumeNestedType();
        break;

    case 509:
        if (DEBUG) {
            System.out.println("ForInitopt ::="); //$NON-NLS-1$
        }
        consumeEmptyForInitopt();
        break;

    case 511:
        if (DEBUG) {
            System.out.println("ForUpdateopt ::="); //$NON-NLS-1$
        }
        consumeEmptyForUpdateopt();
        break;

    case 515:
        if (DEBUG) {
            System.out.println("Catchesopt ::="); //$NON-NLS-1$
        }
        consumeEmptyCatchesopt();
        break;

    case 517:
        if (DEBUG) {
            System.out.println("EnumDeclaration ::= EnumHeader EnumBody"); //$NON-NLS-1$
        }
        consumeEnumDeclaration();
        break;

    case 518:
        if (DEBUG) {
            System.out.println("EnumHeader ::= EnumHeaderName ClassHeaderImplementsopt"); //$NON-NLS-1$
        }
        consumeEnumHeader();
        break;

    case 519:
        if (DEBUG) {
            System.out.println("EnumHeaderName ::= Modifiersopt enum Identifier"); //$NON-NLS-1$
        }
        consumeEnumHeaderName();
        break;

    case 520:
        if (DEBUG) {
            System.out.println("EnumHeaderName ::= Modifiersopt enum Identifier..."); //$NON-NLS-1$
        }
        consumeEnumHeaderNameWithTypeParameters();
        break;

    case 521:
        if (DEBUG) {
            System.out.println("EnumBody ::= LBRACE EnumBodyDeclarationsopt RBRACE"); //$NON-NLS-1$
        }
        consumeEnumBodyNoConstants();
        break;

    case 522:
        if (DEBUG) {
            System.out.println("EnumBody ::= LBRACE COMMA EnumBodyDeclarationsopt..."); //$NON-NLS-1$
        }
        consumeEnumBodyNoConstants();
        break;

    case 523:
        if (DEBUG) {
            System.out.println("EnumBody ::= LBRACE EnumConstants COMMA..."); //$NON-NLS-1$
        }
        consumeEnumBodyWithConstants();
        break;

    case 524:
        if (DEBUG) {
            System.out.println("EnumBody ::= LBRACE EnumConstants..."); //$NON-NLS-1$
        }
        consumeEnumBodyWithConstants();
        break;

    case 526:
        if (DEBUG) {
            System.out.println("EnumConstants ::= EnumConstants COMMA EnumConstant"); //$NON-NLS-1$
        }
        consumeEnumConstants();
        break;

    case 527:
        if (DEBUG) {
            System.out.println("EnumConstantHeaderName ::= Modifiersopt Identifier"); //$NON-NLS-1$
        }
        consumeEnumConstantHeaderName();
        break;

    case 528:
        if (DEBUG) {
            System.out.println("EnumConstantHeader ::= EnumConstantHeaderName..."); //$NON-NLS-1$
        }
        consumeEnumConstantHeader();
        break;

    case 529:
        if (DEBUG) {
            System.out.println("EnumConstant ::= EnumConstantHeader ForceNoDiet..."); //$NON-NLS-1$
        }
        consumeEnumConstantWithClassBody();
        break;

    case 530:
        if (DEBUG) {
            System.out.println("EnumConstant ::= EnumConstantHeader"); //$NON-NLS-1$
        }
        consumeEnumConstantNoClassBody();
        break;

    case 531:
        if (DEBUG) {
            System.out.println("Arguments ::= LPAREN ArgumentListopt RPAREN"); //$NON-NLS-1$
        }
        consumeArguments();
        break;

    case 532:
        if (DEBUG) {
            System.out.println("Argumentsopt ::="); //$NON-NLS-1$
        }
        consumeEmptyArguments();
        break;

    case 534:
        if (DEBUG) {
            System.out.println("EnumDeclarations ::= SEMICOLON ClassBodyDeclarationsopt"); //$NON-NLS-1$
        }
        consumeEnumDeclarations();
        break;

    case 535:
        if (DEBUG) {
            System.out.println("EnumBodyDeclarationsopt ::="); //$NON-NLS-1$
        }
        consumeEmptyEnumDeclarations();
        break;

    case 537:
        if (DEBUG) {
            System.out.println("EnhancedForStatement ::= EnhancedForStatementHeader..."); //$NON-NLS-1$
        }
        consumeEnhancedForStatement();
        break;

    case 538:
        if (DEBUG) {
            System.out.println("EnhancedForStatementNoShortIf ::=..."); //$NON-NLS-1$
        }
        consumeEnhancedForStatement();
        break;

    case 539:
        if (DEBUG) {
            System.out.println("EnhancedForStatementHeaderInit ::= for LPAREN Type..."); //$NON-NLS-1$
        }
        consumeEnhancedForStatementHeaderInit(false);
        break;

    case 540:
        if (DEBUG) {
            System.out.println("EnhancedForStatementHeaderInit ::= for LPAREN Modifiers"); //$NON-NLS-1$
        }
        consumeEnhancedForStatementHeaderInit(true);
        break;

    case 541:
        if (DEBUG) {
            System.out.println("EnhancedForStatementHeader ::=..."); //$NON-NLS-1$
        }
        consumeEnhancedForStatementHeader();
        break;

    case 542:
        if (DEBUG) {
            System.out.println("SingleStaticImportDeclaration ::=..."); //$NON-NLS-1$
        }
        consumeImportDeclaration();
        break;

    case 543:
        if (DEBUG) {
            System.out.println("SingleStaticImportDeclarationName ::= import static Name"); //$NON-NLS-1$
        }
        consumeSingleStaticImportDeclarationName();
        break;

    case 544:
        if (DEBUG) {
            System.out.println("StaticImportOnDemandDeclaration ::=..."); //$NON-NLS-1$
        }
        consumeImportDeclaration();
        break;

    case 545:
        if (DEBUG) {
            System.out.println("StaticImportOnDemandDeclarationName ::= import static..."); //$NON-NLS-1$
        }
        consumeStaticImportOnDemandDeclarationName();
        break;

    case 546:
        if (DEBUG) {
            System.out.println("TypeArguments ::= LESS TypeArgumentList1"); //$NON-NLS-1$
        }
        consumeTypeArguments();
        break;

    case 547:
        if (DEBUG) {
            System.out.println("OnlyTypeArguments ::= LESS TypeArgumentList1"); //$NON-NLS-1$
        }
        consumeOnlyTypeArguments();
        break;

    case 549:
        if (DEBUG) {
            System.out.println("TypeArgumentList1 ::= TypeArgumentList COMMA..."); //$NON-NLS-1$
        }
        consumeTypeArgumentList1();
        break;

    case 551:
        if (DEBUG) {
            System.out.println("TypeArgumentList ::= TypeArgumentList COMMA TypeArgument"); //$NON-NLS-1$
        }
        consumeTypeArgumentList();
        break;

    case 552:
        if (DEBUG) {
            System.out.println("TypeArgument ::= ReferenceType"); //$NON-NLS-1$
        }
        consumeTypeArgument();
        break;

    case 556:
        if (DEBUG) {
            System.out.println("ReferenceType1 ::= ReferenceType GREATER"); //$NON-NLS-1$
        }
        consumeReferenceType1();
        break;

    case 557:
        if (DEBUG) {
            System.out.println("ReferenceType1 ::= ClassOrInterface LESS..."); //$NON-NLS-1$
        }
        consumeTypeArgumentReferenceType1();
        break;

    case 559:
        if (DEBUG) {
            System.out.println("TypeArgumentList2 ::= TypeArgumentList COMMA..."); //$NON-NLS-1$
        }
        consumeTypeArgumentList2();
        break;

    case 562:
        if (DEBUG) {
            System.out.println("ReferenceType2 ::= ReferenceType RIGHT_SHIFT"); //$NON-NLS-1$
        }
        consumeReferenceType2();
        break;

    case 563:
        if (DEBUG) {
            System.out.println("ReferenceType2 ::= ClassOrInterface LESS..."); //$NON-NLS-1$
        }
        consumeTypeArgumentReferenceType2();
        break;

    case 565:
        if (DEBUG) {
            System.out.println("TypeArgumentList3 ::= TypeArgumentList COMMA..."); //$NON-NLS-1$
        }
        consumeTypeArgumentList3();
        break;

    case 568:
        if (DEBUG) {
            System.out.println("ReferenceType3 ::= ReferenceType UNSIGNED_RIGHT_SHIFT"); //$NON-NLS-1$
        }
        consumeReferenceType3();
        break;

    case 569:
        if (DEBUG) {
            System.out.println("Wildcard ::= QUESTION"); //$NON-NLS-1$
        }
        consumeWildcard();
        break;

    case 570:
        if (DEBUG) {
            System.out.println("Wildcard ::= QUESTION WildcardBounds"); //$NON-NLS-1$
        }
        consumeWildcardWithBounds();
        break;

    case 571:
        if (DEBUG) {
            System.out.println("WildcardBounds ::= extends ReferenceType"); //$NON-NLS-1$
        }
        consumeWildcardBoundsExtends();
        break;

    case 572:
        if (DEBUG) {
            System.out.println("WildcardBounds ::= super ReferenceType"); //$NON-NLS-1$
        }
        consumeWildcardBoundsSuper();
        break;

    case 573:
        if (DEBUG) {
            System.out.println("Wildcard1 ::= QUESTION GREATER"); //$NON-NLS-1$
        }
        consumeWildcard1();
        break;

    case 574:
        if (DEBUG) {
            System.out.println("Wildcard1 ::= QUESTION WildcardBounds1"); //$NON-NLS-1$
        }
        consumeWildcard1WithBounds();
        break;

    case 575:
        if (DEBUG) {
            System.out.println("WildcardBounds1 ::= extends ReferenceType1"); //$NON-NLS-1$
        }
        consumeWildcardBounds1Extends();
        break;

    case 576:
        if (DEBUG) {
            System.out.println("WildcardBounds1 ::= super ReferenceType1"); //$NON-NLS-1$
        }
        consumeWildcardBounds1Super();
        break;

    case 577:
        if (DEBUG) {
            System.out.println("Wildcard2 ::= QUESTION RIGHT_SHIFT"); //$NON-NLS-1$
        }
        consumeWildcard2();
        break;

    case 578:
        if (DEBUG) {
            System.out.println("Wildcard2 ::= QUESTION WildcardBounds2"); //$NON-NLS-1$
        }
        consumeWildcard2WithBounds();
        break;

    case 579:
        if (DEBUG) {
            System.out.println("WildcardBounds2 ::= extends ReferenceType2"); //$NON-NLS-1$
        }
        consumeWildcardBounds2Extends();
        break;

    case 580:
        if (DEBUG) {
            System.out.println("WildcardBounds2 ::= super ReferenceType2"); //$NON-NLS-1$
        }
        consumeWildcardBounds2Super();
        break;

    case 581:
        if (DEBUG) {
            System.out.println("Wildcard3 ::= QUESTION UNSIGNED_RIGHT_SHIFT"); //$NON-NLS-1$
        }
        consumeWildcard3();
        break;

    case 582:
        if (DEBUG) {
            System.out.println("Wildcard3 ::= QUESTION WildcardBounds3"); //$NON-NLS-1$
        }
        consumeWildcard3WithBounds();
        break;

    case 583:
        if (DEBUG) {
            System.out.println("WildcardBounds3 ::= extends ReferenceType3"); //$NON-NLS-1$
        }
        consumeWildcardBounds3Extends();
        break;

    case 584:
        if (DEBUG) {
            System.out.println("WildcardBounds3 ::= super ReferenceType3"); //$NON-NLS-1$
        }
        consumeWildcardBounds3Super();
        break;

    case 585:
        if (DEBUG) {
            System.out.println("TypeParameterHeader ::= Identifier"); //$NON-NLS-1$
        }
        consumeTypeParameterHeader();
        break;

    case 586:
        if (DEBUG) {
            System.out.println("TypeParameters ::= LESS TypeParameterList1"); //$NON-NLS-1$
        }
        consumeTypeParameters();
        break;

    case 588:
        if (DEBUG) {
            System.out.println("TypeParameterList ::= TypeParameterList COMMA..."); //$NON-NLS-1$
        }
        consumeTypeParameterList();
        break;

    case 590:
        if (DEBUG) {
            System.out.println("TypeParameter ::= TypeParameterHeader extends..."); //$NON-NLS-1$
        }
        consumeTypeParameterWithExtends();
        break;

    case 591:
        if (DEBUG) {
            System.out.println("TypeParameter ::= TypeParameterHeader extends..."); //$NON-NLS-1$
        }
        consumeTypeParameterWithExtendsAndBounds();
        break;

    case 593:
        if (DEBUG) {
            System.out.println("AdditionalBoundList ::= AdditionalBoundList..."); //$NON-NLS-1$
        }
        consumeAdditionalBoundList();
        break;

    case 594:
        if (DEBUG) {
            System.out.println("AdditionalBound ::= AND ReferenceType"); //$NON-NLS-1$
        }
        consumeAdditionalBound();
        break;

    case 596:
        if (DEBUG) {
            System.out.println("TypeParameterList1 ::= TypeParameterList COMMA..."); //$NON-NLS-1$
        }
        consumeTypeParameterList1();
        break;

    case 597:
        if (DEBUG) {
            System.out.println("TypeParameter1 ::= TypeParameterHeader GREATER"); //$NON-NLS-1$
        }
        consumeTypeParameter1();
        break;

    case 598:
        if (DEBUG) {
            System.out.println("TypeParameter1 ::= TypeParameterHeader extends..."); //$NON-NLS-1$
        }
        consumeTypeParameter1WithExtends();
        break;

    case 599:
        if (DEBUG) {
            System.out.println("TypeParameter1 ::= TypeParameterHeader extends..."); //$NON-NLS-1$
        }
        consumeTypeParameter1WithExtendsAndBounds();
        break;

    case 601:
        if (DEBUG) {
            System.out.println("AdditionalBoundList1 ::= AdditionalBoundList..."); //$NON-NLS-1$
        }
        consumeAdditionalBoundList1();
        break;

    case 602:
        if (DEBUG) {
            System.out.println("AdditionalBound1 ::= AND ReferenceType1"); //$NON-NLS-1$
        }
        consumeAdditionalBound1();
        break;

    case 608:
        if (DEBUG) {
            System.out.println("UnaryExpression_NotName ::= PLUS PushPosition..."); //$NON-NLS-1$
        }
        consumeUnaryExpression(OperatorIds.PLUS);
        break;

    case 609:
        if (DEBUG) {
            System.out.println("UnaryExpression_NotName ::= MINUS PushPosition..."); //$NON-NLS-1$
        }
        consumeUnaryExpression(OperatorIds.MINUS);
        break;

    case 612:
        if (DEBUG) {
            System.out.println("UnaryExpressionNotPlusMinus_NotName ::= TWIDDLE..."); //$NON-NLS-1$
        }
        consumeUnaryExpression(OperatorIds.TWIDDLE);
        break;

    case 613:
        if (DEBUG) {
            System.out.println("UnaryExpressionNotPlusMinus_NotName ::= NOT PushPosition"); //$NON-NLS-1$
        }
        consumeUnaryExpression(OperatorIds.NOT);
        break;

    case 616:
        if (DEBUG) {
            System.out.println("MultiplicativeExpression_NotName ::=..."); //$NON-NLS-1$
        }
        consumeBinaryExpression(OperatorIds.MULTIPLY);
        break;

    case 617:
        if (DEBUG) {
            System.out.println("MultiplicativeExpression_NotName ::= Name MULTIPLY..."); //$NON-NLS-1$
        }
        consumeBinaryExpressionWithName(OperatorIds.MULTIPLY);
        break;

    case 618:
        if (DEBUG) {
            System.out.println("MultiplicativeExpression_NotName ::=..."); //$NON-NLS-1$
        }
        consumeBinaryExpression(OperatorIds.DIVIDE);
        break;

    case 619:
        if (DEBUG) {
            System.out.println("MultiplicativeExpression_NotName ::= Name DIVIDE..."); //$NON-NLS-1$
        }
        consumeBinaryExpressionWithName(OperatorIds.DIVIDE);
        break;

    case 620:
        if (DEBUG) {
            System.out.println("MultiplicativeExpression_NotName ::=..."); //$NON-NLS-1$
        }
        consumeBinaryExpression(OperatorIds.REMAINDER);
        break;

    case 621:
        if (DEBUG) {
            System.out.println("MultiplicativeExpression_NotName ::= Name REMAINDER..."); //$NON-NLS-1$
        }
        consumeBinaryExpressionWithName(OperatorIds.REMAINDER);
        break;

    case 623:
        if (DEBUG) {
            System.out.println("AdditiveExpression_NotName ::=..."); //$NON-NLS-1$
        }
        consumeBinaryExpression(OperatorIds.PLUS);
        break;

    case 624:
        if (DEBUG) {
            System.out.println("AdditiveExpression_NotName ::= Name PLUS..."); //$NON-NLS-1$
        }
        consumeBinaryExpressionWithName(OperatorIds.PLUS);
        break;

    case 625:
        if (DEBUG) {
            System.out.println("AdditiveExpression_NotName ::=..."); //$NON-NLS-1$
        }
        consumeBinaryExpression(OperatorIds.MINUS);
        break;

    case 626:
        if (DEBUG) {
            System.out.println("AdditiveExpression_NotName ::= Name MINUS..."); //$NON-NLS-1$
        }
        consumeBinaryExpressionWithName(OperatorIds.MINUS);
        break;

    case 628:
        if (DEBUG) {
            System.out.println("ShiftExpression_NotName ::= ShiftExpression_NotName..."); //$NON-NLS-1$
        }
        consumeBinaryExpression(OperatorIds.LEFT_SHIFT);
        break;

    case 629:
        if (DEBUG) {
            System.out.println("ShiftExpression_NotName ::= Name LEFT_SHIFT..."); //$NON-NLS-1$
        }
        consumeBinaryExpressionWithName(OperatorIds.LEFT_SHIFT);
        break;

    case 630:
        if (DEBUG) {
            System.out.println("ShiftExpression_NotName ::= ShiftExpression_NotName..."); //$NON-NLS-1$
        }
        consumeBinaryExpression(OperatorIds.RIGHT_SHIFT);
        break;

    case 631:
        if (DEBUG) {
            System.out.println("ShiftExpression_NotName ::= Name RIGHT_SHIFT..."); //$NON-NLS-1$
        }
        consumeBinaryExpressionWithName(OperatorIds.RIGHT_SHIFT);
        break;

    case 632:
        if (DEBUG) {
            System.out.println("ShiftExpression_NotName ::= ShiftExpression_NotName..."); //$NON-NLS-1$
        }
        consumeBinaryExpression(OperatorIds.UNSIGNED_RIGHT_SHIFT);
        break;

    case 633:
        if (DEBUG) {
            System.out.println("ShiftExpression_NotName ::= Name UNSIGNED_RIGHT_SHIFT..."); //$NON-NLS-1$
        }
        consumeBinaryExpressionWithName(OperatorIds.UNSIGNED_RIGHT_SHIFT);
        break;

    case 635:
        if (DEBUG) {
            System.out.println("RelationalExpression_NotName ::= ShiftExpression_NotName"); //$NON-NLS-1$
        }
        consumeBinaryExpression(OperatorIds.LESS);
        break;

    case 636:
        if (DEBUG) {
            System.out.println("RelationalExpression_NotName ::= Name LESS..."); //$NON-NLS-1$
        }
        consumeBinaryExpressionWithName(OperatorIds.LESS);
        break;

    case 637:
        if (DEBUG) {
            System.out.println("RelationalExpression_NotName ::= ShiftExpression_NotName"); //$NON-NLS-1$
        }
        consumeBinaryExpression(OperatorIds.GREATER);
        break;

    case 638:
        if (DEBUG) {
            System.out.println("RelationalExpression_NotName ::= Name GREATER..."); //$NON-NLS-1$
        }
        consumeBinaryExpressionWithName(OperatorIds.GREATER);
        break;

    case 639:
        if (DEBUG) {
            System.out.println("RelationalExpression_NotName ::=..."); //$NON-NLS-1$
        }
        consumeBinaryExpression(OperatorIds.LESS_EQUAL);
        break;

    case 640:
        if (DEBUG) {
            System.out.println("RelationalExpression_NotName ::= Name LESS_EQUAL..."); //$NON-NLS-1$
        }
        consumeBinaryExpressionWithName(OperatorIds.LESS_EQUAL);
        break;

    case 641:
        if (DEBUG) {
            System.out.println("RelationalExpression_NotName ::=..."); //$NON-NLS-1$
        }
        consumeBinaryExpression(OperatorIds.GREATER_EQUAL);
        break;

    case 642:
        if (DEBUG) {
            System.out.println("RelationalExpression_NotName ::= Name GREATER_EQUAL..."); //$NON-NLS-1$
        }
        consumeBinaryExpressionWithName(OperatorIds.GREATER_EQUAL);
        break;

    case 644:
        if (DEBUG) {
            System.out.println("InstanceofExpression_NotName ::= Name instanceof..."); //$NON-NLS-1$
        }
        consumeInstanceOfExpressionWithName();
        break;

    case 645:
        if (DEBUG) {
            System.out.println("InstanceofExpression_NotName ::=..."); //$NON-NLS-1$
        }
        consumeInstanceOfExpression();
        break;

    case 647:
        if (DEBUG) {
            System.out.println("EqualityExpression_NotName ::=..."); //$NON-NLS-1$
        }
        consumeEqualityExpression(OperatorIds.EQUAL_EQUAL);
        break;

    case 648:
        if (DEBUG) {
            System.out.println("EqualityExpression_NotName ::= Name EQUAL_EQUAL..."); //$NON-NLS-1$
        }
        consumeEqualityExpressionWithName(OperatorIds.EQUAL_EQUAL);
        break;

    case 649:
        if (DEBUG) {
            System.out.println("EqualityExpression_NotName ::=..."); //$NON-NLS-1$
        }
        consumeEqualityExpression(OperatorIds.NOT_EQUAL);
        break;

    case 650:
        if (DEBUG) {
            System.out.println("EqualityExpression_NotName ::= Name NOT_EQUAL..."); //$NON-NLS-1$
        }
        consumeEqualityExpressionWithName(OperatorIds.NOT_EQUAL);
        break;

    case 652:
        if (DEBUG) {
            System.out.println("AndExpression_NotName ::= AndExpression_NotName AND..."); //$NON-NLS-1$
        }
        consumeBinaryExpression(OperatorIds.AND);
        break;

    case 653:
        if (DEBUG) {
            System.out.println("AndExpression_NotName ::= Name AND EqualityExpression"); //$NON-NLS-1$
        }
        consumeBinaryExpressionWithName(OperatorIds.AND);
        break;

    case 655:
        if (DEBUG) {
            System.out.println("ExclusiveOrExpression_NotName ::=..."); //$NON-NLS-1$
        }
        consumeBinaryExpression(OperatorIds.XOR);
        break;

    case 656:
        if (DEBUG) {
            System.out.println("ExclusiveOrExpression_NotName ::= Name XOR AndExpression"); //$NON-NLS-1$
        }
        consumeBinaryExpressionWithName(OperatorIds.XOR);
        break;

    case 658:
        if (DEBUG) {
            System.out.println("InclusiveOrExpression_NotName ::=..."); //$NON-NLS-1$
        }
        consumeBinaryExpression(OperatorIds.OR);
        break;

    case 659:
        if (DEBUG) {
            System.out.println("InclusiveOrExpression_NotName ::= Name OR..."); //$NON-NLS-1$
        }
        consumeBinaryExpressionWithName(OperatorIds.OR);
        break;

    case 661:
        if (DEBUG) {
            System.out.println("ConditionalAndExpression_NotName ::=..."); //$NON-NLS-1$
        }
        consumeBinaryExpression(OperatorIds.AND_AND);
        break;

    case 662:
        if (DEBUG) {
            System.out.println("ConditionalAndExpression_NotName ::= Name AND_AND..."); //$NON-NLS-1$
        }
        consumeBinaryExpressionWithName(OperatorIds.AND_AND);
        break;

    case 664:
        if (DEBUG) {
            System.out.println("ConditionalOrExpression_NotName ::=..."); //$NON-NLS-1$
        }
        consumeBinaryExpression(OperatorIds.OR_OR);
        break;

    case 665:
        if (DEBUG) {
            System.out.println("ConditionalOrExpression_NotName ::= Name OR_OR..."); //$NON-NLS-1$
        }
        consumeBinaryExpressionWithName(OperatorIds.OR_OR);
        break;

    case 667:
        if (DEBUG) {
            System.out.println("ConditionalExpression_NotName ::=..."); //$NON-NLS-1$
        }
        consumeConditionalExpression(OperatorIds.QUESTIONCOLON);
        break;

    case 668:
        if (DEBUG) {
            System.out.println("ConditionalExpression_NotName ::= Name QUESTION..."); //$NON-NLS-1$
        }
        consumeConditionalExpressionWithName(OperatorIds.QUESTIONCOLON);
        break;

    case 672:
        if (DEBUG) {
            System.out.println("AnnotationTypeDeclarationHeaderName ::= Modifiers AT..."); //$NON-NLS-1$
        }
        consumeAnnotationTypeDeclarationHeaderName();
        break;

    case 673:
        if (DEBUG) {
            System.out.println("AnnotationTypeDeclarationHeaderName ::= Modifiers AT..."); //$NON-NLS-1$
        }
        consumeAnnotationTypeDeclarationHeaderNameWithTypeParameters();
        break;

    case 674:
        if (DEBUG) {
            System.out.println("AnnotationTypeDeclarationHeaderName ::= AT..."); //$NON-NLS-1$
        }
        consumeAnnotationTypeDeclarationHeaderNameWithTypeParameters();
        break;

    case 675:
        if (DEBUG) {
            System.out.println("AnnotationTypeDeclarationHeaderName ::= AT..."); //$NON-NLS-1$
        }
        consumeAnnotationTypeDeclarationHeaderName();
        break;

    case 676:
        if (DEBUG) {
            System.out.println("AnnotationTypeDeclarationHeader ::=..."); //$NON-NLS-1$
        }
        consumeAnnotationTypeDeclarationHeader();
        break;

    case 677:
        if (DEBUG) {
            System.out.println("AnnotationTypeDeclaration ::=..."); //$NON-NLS-1$
        }
        consumeAnnotationTypeDeclaration();
        break;

    case 679:
        if (DEBUG) {
            System.out.println("AnnotationTypeMemberDeclarationsopt ::="); //$NON-NLS-1$
        }
        consumeEmptyAnnotationTypeMemberDeclarationsopt();
        break;

    case 680:
        if (DEBUG) {
            System.out.println("AnnotationTypeMemberDeclarationsopt ::= NestedType..."); //$NON-NLS-1$
        }
        consumeAnnotationTypeMemberDeclarationsopt();
        break;

    case 682:
        if (DEBUG) {
            System.out.println("AnnotationTypeMemberDeclarations ::=..."); //$NON-NLS-1$
        }
        consumeAnnotationTypeMemberDeclarations();
        break;

    case 683:
        if (DEBUG) {
            System.out.println("AnnotationMethodHeaderName ::= Modifiersopt..."); //$NON-NLS-1$
        }
        consumeMethodHeaderNameWithTypeParameters(true);
        break;

    case 684:
        if (DEBUG) {
            System.out.println("AnnotationMethodHeaderName ::= Modifiersopt Type..."); //$NON-NLS-1$
        }
        consumeMethodHeaderName(true);
        break;

    case 685:
        if (DEBUG) {
            System.out.println("AnnotationMethodHeaderDefaultValueopt ::="); //$NON-NLS-1$
        }
        consumeEmptyMethodHeaderDefaultValue();
        break;

    case 686:
        if (DEBUG) {
            System.out.println("AnnotationMethodHeaderDefaultValueopt ::= DefaultValue"); //$NON-NLS-1$
        }
        consumeMethodHeaderDefaultValue();
        break;

    case 687:
        if (DEBUG) {
            System.out.println("AnnotationMethodHeader ::= AnnotationMethodHeaderName..."); //$NON-NLS-1$
        }
        consumeMethodHeader();
        break;

    case 688:
        if (DEBUG) {
            System.out.println("AnnotationTypeMemberDeclaration ::=..."); //$NON-NLS-1$
        }
        consumeAnnotationTypeMemberDeclaration();
        break;

    case 696:
        if (DEBUG) {
            System.out.println("AnnotationName ::= AT Name"); //$NON-NLS-1$
        }
        consumeAnnotationName();
        break;

    case 697:
        if (DEBUG) {
            System.out.println("NormalAnnotation ::= AnnotationName LPAREN..."); //$NON-NLS-1$
        }
        consumeNormalAnnotation();
        break;

    case 698:
        if (DEBUG) {
            System.out.println("MemberValuePairsopt ::="); //$NON-NLS-1$
        }
        consumeEmptyMemberValuePairsopt();
        break;

    case 701:
        if (DEBUG) {
            System.out.println("MemberValuePairs ::= MemberValuePairs COMMA..."); //$NON-NLS-1$
        }
        consumeMemberValuePairs();
        break;

    case 702:
        if (DEBUG) {
            System.out.println("MemberValuePair ::= SimpleName EQUAL EnterMemberValue..."); //$NON-NLS-1$
        }
        consumeMemberValuePair();
        break;

    case 703:
        if (DEBUG) {
            System.out.println("EnterMemberValue ::="); //$NON-NLS-1$
        }
        consumeEnterMemberValue();
        break;

    case 704:
        if (DEBUG) {
            System.out.println("ExitMemberValue ::="); //$NON-NLS-1$
        }
        consumeExitMemberValue();
        break;

    case 706:
        if (DEBUG) {
            System.out.println("MemberValue ::= Name"); //$NON-NLS-1$
        }
        consumeMemberValueAsName();
        break;

    case 709:
        if (DEBUG) {
            System.out.println("MemberValueArrayInitializer ::=..."); //$NON-NLS-1$
        }
        consumeMemberValueArrayInitializer();
        break;

    case 710:
        if (DEBUG) {
            System.out.println("MemberValueArrayInitializer ::=..."); //$NON-NLS-1$
        }
        consumeMemberValueArrayInitializer();
        break;

    case 711:
        if (DEBUG) {
            System.out.println("MemberValueArrayInitializer ::=..."); //$NON-NLS-1$
        }
        consumeEmptyMemberValueArrayInitializer();
        break;

    case 712:
        if (DEBUG) {
            System.out.println("MemberValueArrayInitializer ::=..."); //$NON-NLS-1$
        }
        consumeEmptyMemberValueArrayInitializer();
        break;

    case 713:
        if (DEBUG) {
            System.out.println("EnterMemberValueArrayInitializer ::="); //$NON-NLS-1$
        }
        consumeEnterMemberValueArrayInitializer();
        break;

    case 715:
        if (DEBUG) {
            System.out.println("MemberValues ::= MemberValues COMMA MemberValue"); //$NON-NLS-1$
        }
        consumeMemberValues();
        break;

    case 716:
        if (DEBUG) {
            System.out.println("MarkerAnnotation ::= AnnotationName"); //$NON-NLS-1$
        }
        consumeMarkerAnnotation();
        break;

    case 717:
        if (DEBUG) {
            System.out.println("SingleMemberAnnotationMemberValue ::= MemberValue"); //$NON-NLS-1$
        }
        consumeSingleMemberAnnotationMemberValue();
        break;

    case 718:
        if (DEBUG) {
            System.out.println("SingleMemberAnnotation ::= AnnotationName LPAREN..."); //$NON-NLS-1$
        }
        consumeSingleMemberAnnotation();
        break;

    case 719:
        if (DEBUG) {
            System.out.println("RecoveryMethodHeaderName ::= Modifiersopt TypeParameters"); //$NON-NLS-1$
        }
        consumeRecoveryMethodHeaderNameWithTypeParameters();
        break;

    case 720:
        if (DEBUG) {
            System.out.println("RecoveryMethodHeaderName ::= Modifiersopt Type..."); //$NON-NLS-1$
        }
        consumeRecoveryMethodHeaderName();
        break;

    case 721:
        if (DEBUG) {
            System.out.println("RecoveryMethodHeader ::= RecoveryMethodHeaderName..."); //$NON-NLS-1$
        }
        consumeMethodHeader();
        break;

    case 722:
        if (DEBUG) {
            System.out.println("RecoveryMethodHeader ::= RecoveryMethodHeaderName..."); //$NON-NLS-1$
        }
        consumeMethodHeader();
        break;

    }
}

From source file:org.eclipse.objectteams.otdt.internal.core.compiler.lifting.ArrayTranslations.java

License:Open Source License

/**
 *    for(int i0=0;i0 < role.length;i0++)
 *   {/*from ww w.j  a v  a  2s.  c om*/
 *      result = new Base[role.length][][];
 *      for(...){
 *         ...
 *            for(int i2=0;i2 < role[i0][i1].length;i2++){
 *                 result[i0][i1][i2] = translate(role[i0][i1][i2]);
 *             }
 *          ...
 *       }
 *   }
 * @param currentDimension counter for recursion only. invoke initially with 0.
 * @param arrayDimensions maximum of dimensions of the array
 * @return the new created ForStatement with all subcycles
 */
private ForStatement generateForStatement(int currentDimension, int arrayDimensions, AstGenerator gen) {

    Statement[] init = new Statement[1];
    char[] name = generateArrayIndexName(currentDimension);

    LocalDeclaration initializer = new LocalDeclaration(name, 0, 0);
    initializer.initialization = IntLiteral.buildIntLiteral("0".toCharArray(), 0, 0); //$NON-NLS-1$
    initializer.type = new SingleTypeReference(TypeConstants.INT, 0);
    init[0] = initializer;

    SingleNameReference condLeft = new SingleNameReference(name, 0);

    FieldReference condRight = new FieldReference(IOTConstants.LENGTH, 0);
    SingleNameReference roleNameReference = gen.singleNameReference(ROLE_ARRAY_ARG);
    decapsulationInput(roleNameReference);

    Expression lastArrayReference = roleNameReference;

    for (int idx = 0; idx < currentDimension; idx++) {
        SingleNameReference pos = new SingleNameReference(generateArrayIndexName(idx), 0);
        ArrayReference nextArray = new ArrayReference(lastArrayReference, pos);
        lastArrayReference = nextArray;
    }
    condRight.receiver = lastArrayReference;

    Expression cond = new BinaryExpression(condLeft, condRight, OperatorIds.LESS);
    Statement[] inc = new Statement[1];

    inc[0] = new PostfixExpression(new SingleNameReference(name, 0), IntLiteral.One, OperatorIds.PLUS, 0);

    Block action = new Block(0);

    // result = new Base[role.length][][];
    Assignment arrayInstantiation = generateArrayInstantiation(currentDimension + 1, arrayDimensions, gen);

    // if(r1 == null)continue;
    IfStatement ifStatement = generateIfStatement(currentDimension + 1, arrayDimensions);

    if (currentDimension < arrayDimensions - 1) {
        ForStatement innerForStatement = generateForStatement(currentDimension + 1, arrayDimensions, gen);
        action.statements = new Statement[3];
        action.statements[0] = ifStatement;
        action.statements[1] = arrayInstantiation;
        action.statements[2] = innerForStatement;
    } else {
        action.statements = new Statement[2];
        action.statements[0] = ifStatement;
        action.statements[1] = arrayInstantiation;
    }

    // for(;i0 < role.length;i0++)
    ForStatement outerForStatement = new ForStatement(init, cond, inc, action, true, 0, 0);

    return outerForStatement;
}

From source file:spoon.support.builder.JDTTreeBuilder.java

License:Open Source License

BinaryOperatorKind getBinaryOperatorKind(int bits) {
    // switch ((bits & ASTNode.OperatorMASK) >> ASTNode.OperatorSHIFT) {
    switch (bits) {
    case OperatorIds.EQUAL_EQUAL:
        return BinaryOperatorKind.EQ;
    case OperatorIds.LESS_EQUAL:
        return BinaryOperatorKind.LE;
    case OperatorIds.GREATER_EQUAL:
        return BinaryOperatorKind.GE;
    case OperatorIds.NOT_EQUAL:
        return BinaryOperatorKind.NE;
    case OperatorIds.LEFT_SHIFT:
        return BinaryOperatorKind.SL;
    case OperatorIds.RIGHT_SHIFT:
        return BinaryOperatorKind.SR;
    case OperatorIds.UNSIGNED_RIGHT_SHIFT:
        return BinaryOperatorKind.USR;
    case OperatorIds.OR_OR:
        return BinaryOperatorKind.OR;
    case OperatorIds.AND_AND:
        return BinaryOperatorKind.AND;
    case OperatorIds.PLUS:
        return BinaryOperatorKind.PLUS;
    case OperatorIds.MINUS:
        return BinaryOperatorKind.MINUS;
    case OperatorIds.NOT:
        return BinaryOperatorKind.NE;
    case OperatorIds.REMAINDER:
        return BinaryOperatorKind.MOD;
    case OperatorIds.XOR:
        return BinaryOperatorKind.BITXOR;
    case OperatorIds.AND:
        return BinaryOperatorKind.BITAND;
    case OperatorIds.MULTIPLY:
        return BinaryOperatorKind.MUL;
    case OperatorIds.OR:
        return BinaryOperatorKind.BITOR;
    case OperatorIds.DIVIDE:
        return BinaryOperatorKind.DIV;
    case OperatorIds.GREATER:
        return BinaryOperatorKind.GT;
    case OperatorIds.LESS:
        return BinaryOperatorKind.LT;
    case OperatorIds.QUESTIONCOLON:
        throw new RuntimeException("Unknow operator");
    case OperatorIds.EQUAL:
        return BinaryOperatorKind.EQ;
    }//from   w  ww.j ava 2 s . c  o m
    return null;
}

From source file:spoon.support.compiler.jdt.JDTTreeBuilder.java

License:Open Source License

BinaryOperatorKind getBinaryOperatorKind(int bits) {
    // switch ((bits & ASTNode.OperatorMASK) >> ASTNode.OperatorSHIFT) {
    switch (bits) {
    case OperatorIds.EQUAL_EQUAL:
        return BinaryOperatorKind.EQ;
    case OperatorIds.LESS_EQUAL:
        return BinaryOperatorKind.LE;
    case OperatorIds.GREATER_EQUAL:
        return BinaryOperatorKind.GE;
    case OperatorIds.NOT_EQUAL:
        return BinaryOperatorKind.NE;
    case OperatorIds.LEFT_SHIFT:
        return BinaryOperatorKind.SL;
    case OperatorIds.RIGHT_SHIFT:
        return BinaryOperatorKind.SR;
    case OperatorIds.UNSIGNED_RIGHT_SHIFT:
        return BinaryOperatorKind.USR;
    case OperatorIds.OR_OR:
        return BinaryOperatorKind.OR;
    case OperatorIds.AND_AND:
        return BinaryOperatorKind.AND;
    case OperatorIds.PLUS:
        return BinaryOperatorKind.PLUS;
    case OperatorIds.MINUS:
        return BinaryOperatorKind.MINUS;
    case OperatorIds.NOT:
        return BinaryOperatorKind.NE;
    case OperatorIds.REMAINDER:
        return BinaryOperatorKind.MOD;
    case OperatorIds.XOR:
        return BinaryOperatorKind.BITXOR;
    case OperatorIds.AND:
        return BinaryOperatorKind.BITAND;
    case OperatorIds.MULTIPLY:
        return BinaryOperatorKind.MUL;
    case OperatorIds.OR:
        return BinaryOperatorKind.BITOR;
    case OperatorIds.DIVIDE:
        return BinaryOperatorKind.DIV;
    case OperatorIds.GREATER:
        return BinaryOperatorKind.GT;
    case OperatorIds.LESS:
        return BinaryOperatorKind.LT;
    case OperatorIds.QUESTIONCOLON:
        throw new RuntimeException("Unknown operator");
    case OperatorIds.EQUAL:
        return BinaryOperatorKind.EQ;
    }//from   w w w  .  ja va 2 s  . c om
    return null;
}

From source file:spoon.support.compiler.jdt.JDTTreeBuilderQuery.java

License:Open Source License

/**
 * Converts the binary operator from JDT to Spoon.
 *
 * @param operator//w  w w . j  a va  2s.  co m
 *       Identifier of the binary operator.
 * @return enum value of {@link BinaryOperatorKind}.
 */
static BinaryOperatorKind getBinaryOperatorKind(int operator) {
    switch (operator) {
    case OperatorIds.EQUAL_EQUAL:
        return BinaryOperatorKind.EQ;
    case OperatorIds.LESS_EQUAL:
        return BinaryOperatorKind.LE;
    case OperatorIds.GREATER_EQUAL:
        return BinaryOperatorKind.GE;
    case OperatorIds.NOT_EQUAL:
        return BinaryOperatorKind.NE;
    case OperatorIds.LEFT_SHIFT:
        return BinaryOperatorKind.SL;
    case OperatorIds.RIGHT_SHIFT:
        return BinaryOperatorKind.SR;
    case OperatorIds.UNSIGNED_RIGHT_SHIFT:
        return BinaryOperatorKind.USR;
    case OperatorIds.OR_OR:
        return BinaryOperatorKind.OR;
    case OperatorIds.AND_AND:
        return BinaryOperatorKind.AND;
    case OperatorIds.PLUS:
        return BinaryOperatorKind.PLUS;
    case OperatorIds.MINUS:
        return BinaryOperatorKind.MINUS;
    case OperatorIds.NOT:
        return BinaryOperatorKind.NE;
    case OperatorIds.REMAINDER:
        return BinaryOperatorKind.MOD;
    case OperatorIds.XOR:
        return BinaryOperatorKind.BITXOR;
    case OperatorIds.AND:
        return BinaryOperatorKind.BITAND;
    case OperatorIds.MULTIPLY:
        return BinaryOperatorKind.MUL;
    case OperatorIds.OR:
        return BinaryOperatorKind.BITOR;
    case OperatorIds.DIVIDE:
        return BinaryOperatorKind.DIV;
    case OperatorIds.GREATER:
        return BinaryOperatorKind.GT;
    case OperatorIds.LESS:
        return BinaryOperatorKind.LT;
    case OperatorIds.QUESTIONCOLON:
        throw new RuntimeException("Unknown operator");
    case OperatorIds.EQUAL:
        return BinaryOperatorKind.EQ;
    }
    return null;
}