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

Introduction

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

Prototype

int UNSIGNED_RIGHT_SHIFT

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

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  a v  a  2  s  .c o m*/
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:com.android.tools.lint.psi.EcjPsiBuilder.java

License:Apache License

/** Look up the PSI element type for the given ECJ operator in an assignment */
@NonNull/* www.ja va  2s .  c  o m*/
private IElementType ecjAssignmentToPsiToken(int operator) {
    switch (operator) {
    case OperatorIds.PLUS:
        return JavaTokenType.PLUSEQ;
    case OperatorIds.MINUS:
        return JavaTokenType.MINUSEQ;
    case OperatorIds.MULTIPLY:
        return JavaTokenType.ASTERISKEQ;
    case OperatorIds.DIVIDE:
        return JavaTokenType.DIVEQ;
    case OperatorIds.REMAINDER:
        return JavaTokenType.PERCEQ;
    case OperatorIds.AND:
        return JavaTokenType.ANDEQ;
    case OperatorIds.XOR:
        return JavaTokenType.XOREQ;
    case OperatorIds.OR:
        return JavaTokenType.OREQ;
    case OperatorIds.LEFT_SHIFT:
        return JavaTokenType.LTLTEQ;
    case OperatorIds.RIGHT_SHIFT:
        return JavaTokenType.GTGTEQ;
    case OperatorIds.UNSIGNED_RIGHT_SHIFT:
        return JavaTokenType.GTGTGTEQ;
    default:
        return JavaTokenType.EQ;
    }
}

---

From source file:lombok.eclipse.handlers.HandleEqualsAndHashCode.java

License:Open Source License

/** Give 2 clones! */
public Expression longToIntForHashCode(Expression ref1, Expression ref2, ASTNode source) {
    int pS = source.sourceStart, pE = source.sourceEnd;
    /* (int)(ref >>> 32 ^ ref) */
    IntLiteral int32 = makeIntLiteral("32".toCharArray(), source);
    BinaryExpression higherBits = new BinaryExpression(ref1, int32, OperatorIds.UNSIGNED_RIGHT_SHIFT);
    setGeneratedBy(higherBits, source);//from   w w w  . j  a v  a2s .  co  m
    BinaryExpression xorParts = new BinaryExpression(ref2, higherBits, OperatorIds.XOR);
    setGeneratedBy(xorParts, source);
    TypeReference intRef = TypeReference.baseTypeReference(TypeIds.T_int, 0);
    intRef.sourceStart = pS;
    intRef.sourceEnd = pE;
    setGeneratedBy(intRef, source);
    CastExpression expr = makeCastExpression(xorParts, intRef, source);
    expr.sourceStart = pS;
    expr.sourceEnd = pE;
    return expr;
}

---

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

License:Open Source License

public Assignment convert(org.eclipse.jdt.internal.compiler.ast.CompoundAssignment expression) {
    Assignment assignment = new Assignment(this.ast);
    Expression lhs = convert(expression.lhs);
    assignment.setLeftHandSide(lhs);/*from   w  w  w . ja v a 2  s  .  co m*/
    int start = lhs.getStartPosition();
    assignment.setSourceRange(start, expression.sourceEnd - start + 1);
    switch (expression.operator) {
    case org.eclipse.jdt.internal.compiler.ast.OperatorIds.PLUS:
        assignment.setOperator(Assignment.Operator.PLUS_ASSIGN);
        break;
    case org.eclipse.jdt.internal.compiler.ast.OperatorIds.MINUS:
        assignment.setOperator(Assignment.Operator.MINUS_ASSIGN);
        break;
    case org.eclipse.jdt.internal.compiler.ast.OperatorIds.MULTIPLY:
        assignment.setOperator(Assignment.Operator.TIMES_ASSIGN);
        break;
    case org.eclipse.jdt.internal.compiler.ast.OperatorIds.DIVIDE:
        assignment.setOperator(Assignment.Operator.DIVIDE_ASSIGN);
        break;
    case org.eclipse.jdt.internal.compiler.ast.OperatorIds.AND:
        assignment.setOperator(Assignment.Operator.BIT_AND_ASSIGN);
        break;
    case org.eclipse.jdt.internal.compiler.ast.OperatorIds.OR:
        assignment.setOperator(Assignment.Operator.BIT_OR_ASSIGN);
        break;
    case org.eclipse.jdt.internal.compiler.ast.OperatorIds.XOR:
        assignment.setOperator(Assignment.Operator.BIT_XOR_ASSIGN);
        break;
    case org.eclipse.jdt.internal.compiler.ast.OperatorIds.REMAINDER:
        assignment.setOperator(Assignment.Operator.REMAINDER_ASSIGN);
        break;
    case org.eclipse.jdt.internal.compiler.ast.OperatorIds.LEFT_SHIFT:
        assignment.setOperator(Assignment.Operator.LEFT_SHIFT_ASSIGN);
        break;
    case org.eclipse.jdt.internal.compiler.ast.OperatorIds.RIGHT_SHIFT:
        assignment.setOperator(Assignment.Operator.RIGHT_SHIFT_SIGNED_ASSIGN);
        break;
    case org.eclipse.jdt.internal.compiler.ast.OperatorIds.UNSIGNED_RIGHT_SHIFT:
        assignment.setOperator(Assignment.Operator.RIGHT_SHIFT_UNSIGNED_ASSIGN);
        break;
    }
    assignment.setRightHandSide(convert(expression.expression));
    if (this.resolveBindings) {
        recordNodes(assignment, expression);
    }
    return assignment;
}

---

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;
    }/* w w  w  .  j  a  v a 2 s  .c om*/
    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 . c o 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: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 w w  .j a v  a2s  .co 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;
    }/*w  w  w .  jav  a2s . co  m*/
    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//from   ww w.j  a  va2  s.c  om
 *       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;
}

---