//===========================================================================
//
//  Parsing Expression Grammar of Java 1.7 for Mouse 1.1 - 1.6.
//  Based on Java Language Specification, Java SE 7 Edition, dated 2012-07-27,
//  obtained from http://docs.oracle.com/javase/specs/jls/se7/html/index.html.
//
//---------------------------------------------------------------------------
//
//  Copyright (C) 2006, 2009, 2010, 2011, 2013
//  by Roman R Redziejowski(www.romanredz.se).
//
//  The author gives unlimited permission to copy and distribute
//  this file, with or without modifications, as long as this notice
//  is preserved, and any changes are properly documented.
//
//  This file is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
//
//---------------------------------------------------------------------------
//
//  Latest update 2013-04-23
//
//---------------------------------------------------------------------------
//  Change log
//---------------------------------------------------------------------------
//
//    2006-12-06 Posted on Internet.
//    2009-04-04 Modified to conform to Mouse syntax:
//               Underscore removed from names
//               \f in Space replaced by Unicode for FormFeed.
//    2009-07-10 Unused rule THREADSAFE removed.
//    2009-07-10 Copying and distribution conditions relaxed by the author.
//    2010-07-01 Updated Mouse version in the comment.
//    2010-09-15 Updated comment on Java release.
//    2010-09-18 Updated list of reserved words ("keywords") according to
//               JLS 3.9: added "const" and "goto", removed "threadsafe".
//    2010-09-18 Removed superfluous "?" everywhere after "Spacing".
//    2010-10-05 Removed erroneous "TypeArguments?" from "EnumConstant".
//               See JLS 8.9, JLS 18.1.
//               NB. "Annotations" are optional, but not shown as such in JLS.
//    2010-10-20 Corrected "FormalParameterList" according to JLS 8.4.1.
//               NB. "VariableModifiers" in "FormalParameter" and "LastFormalParameter"
//               are optional, but not shown as such in JLS.
//    2010-10-20 Corrected "Annotation" according to JLS 9.7.
//               Is incorrect in JLS 18.1 (does not allow list of value pairs).
//    2010-10-20 Corrected "LocalVariableDeclarationStatement".
//               Is incorrect in JLS 18.1: only FINAL allowed as "VariableModifier".
//               Is incorrect in JLS 14.4: "VariableModifiers" not shown as optional.
//    2010-10-20 Corrected "AnnotationTypeElementRest": added SEMI as last alternative.
//               See JLS 9.6. NB. Missing in JLS 18.1.
//    2010-10-20 Moved "Identifier" from "AnnotationTypeElementRest" to
//               "AnnotationMethodRest". Was incorrect in JLS 18.1.
//    2010-10-21 Inverted order of alternatives in "HexSignificand".
//    2010-10-24 Corrected previous correction: moved SEMI from
//               "AnnotationTypeElementRest" to "AnnotationTypeElementDeclaration".
//    2010-10-25 Repeated "u" allowed in UnicodeEscape (JLS 3.3).
//               Line terminators not allowed in StringLiteral (JLS 3.10.5).
//               (Found thanks to Java PEG for Parboiled, which in turn credits
//               Reinier Zwitserloot for finding it.)
//
//---------------------------------------------------------------------------
//    Change log for Java 1.7 starts here.
//    Updates based on project documentation, guess, and javac parser code.
//---------------------------------------------------------------------------
//
//    2011-07-18 Implemented Binary Literals: added "BinaryNumeral".
//    2011-07-19 Implemented Underscores in Numerical Literals:
//               Added "Digits" and "HexDigits". Removed "Digit".
//               Modified "DecimalNumeral", "HexNumeral", "BinaryNumeral",
//               "OctalNumeral", "DecimalFloat", "Exponent",
//               "HexSignificand", and "BinaryExponent".
//    2011-07-19 Added SEMI after "VariableDeclarators" in "MemberDecl" (JLS 8.3).
//    2011-07-21 Corrected "ArrayInitializer" to allow for "{,}" (JLS 10.6).
//    2011-07-20 Implemented Type Inference for Generic Instance Creation:
//               Added "Diamond".
//               Modified "ClassCreatorRest" by adding "Diamond?".
//    2011-07-20 Implemented try-with-resources Statement:
//               Added try-with-resources as an alternative of "Statement".
//               Added "Resource".
//    2011-07-20 Implemented catching of multiple exceptions:
//               Modified "Catch" to allow multiple exception types.
//    2011-10-15 Updated Mouse version in the comment.
//    2011-11-05 Updated Mouse version in the comment.
//
//---------------------------------------------------------------------------
//    Updates based on the new Java Language Specifications
//    (SE7 Edition of 2012-07-27)
//---------------------------------------------------------------------------
//
//    2013-02-15 Try-with-resource (14.20.3): replaced "Modifiers*"
//               in "Resource" by "(FINAL / Annotation)*",
//               which is the syntax for VariableModifier*.
//    2013-02-15  Diamond operator: Copied definition of "Creator",
//               "CreatedName", "TypeArgumentsOrDiamond",
//               "NonWildcardTypeArgumentsOrDiamond", "ClassCreatorRest",
//               "ArrayCreatorRest", and "InnerCreator" from Chapter 18.
//               Removed "Diamond".
//    2013-02-15 In "Creator", allowed "BasicType" for array creator.
//               Was obviously an error. See JLS 15.10.
//               (Found already 2006-11-10, not corrected in SE7.)
//    2013-02-15 Expanded "ArrayCreatorRest".
//    2013-02-18 Line terminators not allowed in CharLiteral (JLS 3.10.4).
//    2013-02-19 Added "NonWildcardTypeArguments?" in the second alternative
//               of "SuperSuffix". Version in Chapter 18 is incorrect.
//               See JLS 15.10.
//    2013-02-19 Added semicolon as dummy import declaration.
//    2013-02-19 Commented deviations from JLS SE7.
//    2013-04-23 Updated Mouse version in the comment.
//               Corrected spelling in a comment to IdentifierSuffix.
//
//===========================================================================

//-------------------------------------------------------------------------
//  Compilation Unit
//-------------------------------------------------------------------------

CompilationUnit
    = Spacing PackageDeclaration? ImportDeclaration* TypeDeclaration* EOT
    ;

PackageDeclaration
    = Annotation* PACKAGE QualifiedIdentifier SEMI
    ;

ImportDeclaration
    = IMPORT STATIC? QualifiedIdentifier (DOT STAR)? SEMI
    / SEMI
    ;

    // Experiment shows that Java accepts dummy semicolon among
    // import declaration - which is not allowed according to JLS.

TypeDeclaration
    = Modifier*
      ( ClassDeclaration
      / EnumDeclaration
      / InterfaceDeclaration
      / AnnotationTypeDeclaration
      )
    / SEMI
    ;

//-------------------------------------------------------------------------
//  Class Declaration
//-------------------------------------------------------------------------

ClassDeclaration
    = CLASS Identifier TypeParameters? (EXTENDS ClassType)? (IMPLEMENTS ClassTypeList)? ClassBody
    ;

ClassBody
    = LWING ClassBodyDeclaration* RWING
    ;

ClassBodyDeclaration
    = SEMI
    / STATIC? Block                                    // Static or Instance Initializer
    / Modifier* MemberDecl                             // ClassMemberDeclaration
    ;

MemberDecl
    = TypeParameters GenericMethodOrConstructorRest    // Generic Method or Constructor
    / Type Identifier MethodDeclaratorRest             // Method
    / Type VariableDeclarators SEMI                    // Field
    / VOID Identifier VoidMethodDeclaratorRest         // Void method
    / Identifier ConstructorDeclaratorRest             // Constructor
    / InterfaceDeclaration                             // Interface
    / ClassDeclaration                                 // Class
    / EnumDeclaration                                  // Enum
    / AnnotationTypeDeclaration                        // Annotation
    ;

GenericMethodOrConstructorRest
    = (Type / VOID) Identifier MethodDeclaratorRest
    / Identifier ConstructorDeclaratorRest
    ;

MethodDeclaratorRest
    = FormalParameters Dim* (THROWS ClassTypeList)? (MethodBody / SEMI)
    ;

VoidMethodDeclaratorRest
    = FormalParameters (THROWS ClassTypeList)? (MethodBody / SEMI)
    ;

ConstructorDeclaratorRest
    = FormalParameters (THROWS ClassTypeList)? MethodBody
    ;

MethodBody
    = Block
    ;

//-------------------------------------------------------------------------
//  Interface Declaration
//-------------------------------------------------------------------------

InterfaceDeclaration
    = INTERFACE Identifier TypeParameters? (EXTENDS ClassTypeList)? InterfaceBody
    ;

InterfaceBody
    = LWING InterfaceBodyDeclaration* RWING
    ;

InterfaceBodyDeclaration
    = Modifier* InterfaceMemberDecl
    / SEMI
    ;

InterfaceMemberDecl
    = InterfaceMethodOrFieldDecl
    / InterfaceGenericMethodDecl
    / VOID Identifier VoidInterfaceMethodDeclaratorRest
    / InterfaceDeclaration
    / AnnotationTypeDeclaration
    / ClassDeclaration
    / EnumDeclaration
    ;

InterfaceMethodOrFieldDecl
    = Type Identifier InterfaceMethodOrFieldRest
    ;

InterfaceMethodOrFieldRest
    = ConstantDeclaratorsRest SEMI
    / InterfaceMethodDeclaratorRest
    ;

InterfaceMethodDeclaratorRest
    = FormalParameters Dim* (THROWS ClassTypeList)? SEMI
    ;

InterfaceGenericMethodDecl
    = TypeParameters (Type / VOID) Identifier InterfaceMethodDeclaratorRest
    ;

VoidInterfaceMethodDeclaratorRest
    = FormalParameters (THROWS ClassTypeList)? SEMI
    ;

ConstantDeclaratorsRest
    = ConstantDeclaratorRest (COMMA ConstantDeclarator)*
    ;

ConstantDeclarator
    = Identifier ConstantDeclaratorRest
    ;

ConstantDeclaratorRest
    = Dim* EQU VariableInitializer
    ;

//-------------------------------------------------------------------------
//  Enum Declaration
//-------------------------------------------------------------------------

EnumDeclaration
    = ENUM Identifier (IMPLEMENTS ClassTypeList)? EnumBody
    ;

EnumBody
    = LWING EnumConstants? COMMA? EnumBodyDeclarations? RWING
    ;

EnumConstants
    = EnumConstant (COMMA EnumConstant)*
    ;

EnumConstant
    = Annotation* Identifier Arguments? ClassBody?
    ;

EnumBodyDeclarations
    = SEMI ClassBodyDeclaration*
    ;

//-------------------------------------------------------------------------
//  Variable Declarations
//-------------------------------------------------------------------------

LocalVariableDeclarationStatement
    = (FINAL / Annotation)* Type VariableDeclarators SEMI
    ;

VariableDeclarators
    = VariableDeclarator (COMMA VariableDeclarator)*
    ;

VariableDeclarator
    = Identifier Dim* (EQU VariableInitializer)?
    ;

//-------------------------------------------------------------------------
//  Formal Parameters
//-------------------------------------------------------------------------

FormalParameters
    = LPAR FormalParameterList? RPAR
    ;

FormalParameter
    = (FINAL / Annotation)* Type VariableDeclaratorId
    ;

LastFormalParameter
    = (FINAL / Annotation)* Type ELLIPSIS VariableDeclaratorId
    ;

FormalParameterList
    = FormalParameter (COMMA FormalParameter)* (COMMA LastFormalParameter)?
    / LastFormalParameter
    ;

VariableDeclaratorId
    = Identifier Dim*
    ;

//-------------------------------------------------------------------------
//  Statements
//-------------------------------------------------------------------------

Block
    = LWING BlockStatements RWING
    ;

BlockStatements
    = BlockStatement*
    ;

BlockStatement
    = LocalVariableDeclarationStatement
    / Modifier*
      ( ClassDeclaration
      / EnumDeclaration
      )
    / Statement
    ;

Statement
    = Block
    / ASSERT Expression (COLON Expression)? SEMI
    / IF ParExpression Statement (ELSE Statement)?
    / FOR LPAR ForInit? SEMI Expression? SEMI ForUpdate? RPAR Statement
    / FOR LPAR FormalParameter COLON Expression RPAR Statement
    / WHILE ParExpression Statement
    / DO Statement WHILE ParExpression   SEMI
    / TRY LPAR Resource (SEMI Resource)* SEMI? RPAR Block Catch* Finally?
    / TRY Block (Catch+ Finally? / Finally)
    / SWITCH ParExpression LWING SwitchBlockStatementGroups RWING
    / SYNCHRONIZED ParExpression Block
    / RETURN Expression? SEMI
    / THROW Expression   SEMI
    / BREAK Identifier? SEMI
    / CONTINUE Identifier? SEMI
    / SEMI
    / StatementExpression SEMI
    / Identifier COLON Statement
    ;

Resource
    = (FINAL / Annotation)* Type VariableDeclaratorId EQU Expression
    ;

Catch
    = CATCH LPAR (FINAL / Annotation)* Type (OR Type)* VariableDeclaratorId RPAR Block
    ;

Finally
    = FINALLY Block
    ;

SwitchBlockStatementGroups
    = SwitchBlockStatementGroup*
    ;

SwitchBlockStatementGroup
    = SwitchLabel BlockStatements
    ;

SwitchLabel
    = CASE ConstantExpression COLON
    / CASE EnumConstantName COLON
    / DEFAULT COLON
    ;

ForInit
    = (FINAL / Annotation)* Type VariableDeclarators
    / StatementExpression (COMMA StatementExpression)*
    ;

ForUpdate
    = StatementExpression (COMMA StatementExpression)*
    ;

EnumConstantName
    = Identifier
    ;

//-------------------------------------------------------------------------
//  Expressions
//-------------------------------------------------------------------------

StatementExpression
    = Expression
    ;

    // This is more generous than definition in section 14.8, which allows only
    // specific forms of Expression.


ConstantExpression
    = Expression
    ;

Expression
    = ConditionalExpression (AssignmentOperator ConditionalExpression)*
    ;

    // This definition is part of the modification in JLS Chapter 18
    // to minimize look ahead. In JLS Chapter 15.27, Expression is defined
    // as AssignmentExpression, which is effectively defined as
    // (LeftHandSide AssignmentOperator)* ConditionalExpression.
    // The above is obtained by allowing ANY ConditionalExpression
    // as LeftHandSide, which results in accepting statements like 5 = a.


AssignmentOperator
    = EQU
    / PLUSEQU
    / MINUSEQU
    / STAREQU
    / DIVEQU
    / ANDEQU
    / OREQU
    / HATEQU
    / MODEQU
    / SLEQU
    / SREQU
    / BSREQU
    ;

ConditionalExpression
    = ConditionalOrExpression (QUERY Expression COLON ConditionalOrExpression)*
    ;

ConditionalOrExpression
    = ConditionalAndExpression (OROR ConditionalAndExpression)*
    ;

ConditionalAndExpression
    = InclusiveOrExpression (ANDAND InclusiveOrExpression)*
    ;

InclusiveOrExpression
    = ExclusiveOrExpression (OR ExclusiveOrExpression)*
    ;

ExclusiveOrExpression
    = AndExpression (HAT AndExpression)*
    ;

AndExpression
    = EqualityExpression (AND EqualityExpression)*
    ;

EqualityExpression
    = RelationalExpression ((EQUAL /  NOTEQUAL) RelationalExpression)*
    ;

RelationalExpression
    = ShiftExpression ((LE / GE / LT / GT) ShiftExpression / INSTANCEOF ReferenceType)*
    ;

ShiftExpression
    = AdditiveExpression ((SL / SR / BSR) AdditiveExpression)*
    ;

AdditiveExpression
    = MultiplicativeExpression ((PLUS / MINUS) MultiplicativeExpression)*
    ;

MultiplicativeExpression
    = UnaryExpression ((STAR / DIV / MOD) UnaryExpression)*
    ;

UnaryExpression
    = PrefixOp UnaryExpression
    / LPAR Type RPAR UnaryExpression
    / Primary (Selector)* (PostfixOp)*
    ;

Primary
    = ParExpression
    / NonWildcardTypeArguments (ExplicitGenericInvocationSuffix / THIS Arguments)
    / THIS Arguments?
    / SUPER SuperSuffix
    / Literal
    / NEW Creator
    / QualifiedIdentifier IdentifierSuffix?
    / BasicType Dim* DOT CLASS
    / VOID DOT CLASS
    ;

IdentifierSuffix
    = LBRK ( RBRK Dim* DOT CLASS / Expression RBRK )
    / Arguments
    / DOT
      ( CLASS
      / ExplicitGenericInvocation
      / THIS
      / SUPER Arguments
      / NEW NonWildcardTypeArguments? InnerCreator
      )
    ;

    // This definition comes from Chapter 18 in JLS Third edition.
    // The definition in JLS SE7 seems incorrect as it would mean
    // nesting of brackets.

ExplicitGenericInvocation
    = NonWildcardTypeArguments ExplicitGenericInvocationSuffix
    ;

NonWildcardTypeArguments
    = LPOINT ReferenceType (COMMA ReferenceType)* RPOINT
    ;

TypeArgumentsOrDiamond
    = LPOINT RPOINT
    / TypeArguments
    ;

NonWildcardTypeArgumentsOrDiamond
    = LPOINT RPOINT
    / NonWildcardTypeArguments
    ;

ExplicitGenericInvocationSuffix
    = SUPER SuperSuffix
    / Identifier Arguments
    ;

PrefixOp
    = INC
    / DEC
    / BANG
    / TILDA
    / PLUS
    / MINUS
    ;

PostfixOp
    = INC
    / DEC
    ;

Selector
    = DOT Identifier Arguments?
    / DOT ExplicitGenericInvocation
    / DOT THIS
    / DOT SUPER SuperSuffix
    / DOT NEW NonWildcardTypeArguments? InnerCreator
    / DimExpr
    ;

SuperSuffix
    = Arguments
    / DOT NonWildcardTypeArguments? Identifier Arguments?
    ;

    // The definition of SuperSuffix in JLS Chapter 18 is incorrect:
    // it does not allow NonWildcardTypeArguments. See JLS 15.12.


BasicType
    = ( "byte"
      / "short"
      / "char"
      / "int"
      / "long"
      / "float"
      / "double"
      / "boolean"
      ) !LetterOrDigit Spacing
    ;

Arguments
    = LPAR (Expression (COMMA Expression)*)? RPAR
    ;

Creator
    = (BasicType / CreatedName) ArrayCreatorRest
    / NonWildcardTypeArguments? CreatedName ClassCreatorRest
    ;

    // The definition of Creator in JLS Chapter 18 is incorrect:
    // it does not allow BasicType for array creator. See JLS 15.10.

CreatedName
    = Identifier TypeArgumentsOrDiamond? ( DOT Identifier TypeArgumentsOrDiamond? )*
    ;

InnerCreator
    = Identifier NonWildcardTypeArgumentsOrDiamond? ClassCreatorRest
    ;

ClassCreatorRest
    = Arguments ClassBody?
    ;

ArrayCreatorRest
    = Dim+ ArrayInitializer
    / DimExpr+ Dim*
    / Dim
    ;

    // This version comes from JLS Chapter 18.
    // It is more generous than JLS 15.10. According to that definition,
    // BasicType must be followed by at least one DimExpr or by ArrayInitializer.
    // Besides, the last alternative does not correspond to JLS 15.10,
    // and may be an error.

ArrayInitializer
    = LWING (VariableInitializer (COMMA VariableInitializer)*)? COMMA?  RWING
    ;

VariableInitializer
    = ArrayInitializer
    / Expression
    ;

ParExpression
    = LPAR Expression RPAR
    ;

QualifiedIdentifier
    = Identifier (DOT Identifier)*
    ;

Dim
    = LBRK RBRK
    ;

DimExpr
    = LBRK Expression RBRK
    ;

//-------------------------------------------------------------------------
//  Types and Modifiers
//-------------------------------------------------------------------------

Type
    = (BasicType / ClassType) Dim*
    ;

ReferenceType
    = BasicType Dim+
    / ClassType Dim*
    ;

ClassType
    = Identifier TypeArguments? (DOT Identifier TypeArguments?)*
    ;

ClassTypeList
    = ClassType (COMMA ClassType)*
    ;

TypeArguments
    = LPOINT TypeArgument (COMMA TypeArgument)* RPOINT
    ;

TypeArgument
    = ReferenceType
    / QUERY ((EXTENDS / SUPER) ReferenceType)?
    ;

TypeParameters
    = LPOINT TypeParameter (COMMA TypeParameter)* RPOINT
    ;

TypeParameter
    = Identifier (EXTENDS Bound)?
    ;

Bound
    = ClassType (AND ClassType)*
    ;

Modifier
    = Annotation
    / ( "public"
      / "protected"
      / "private"
      / "static"
      / "abstract"
      / "final"
      / "native"
      / "synchronized"
      / "transient"
      / "volatile"
      / "strictfp"
      ) !LetterOrDigit Spacing
    ;

    // This common definition of Modifier is part of the modification
    // in JLS Chapter 18 to minimize look ahead. The main body of JLS has
    // different lists of modifiers for different language elements.

//-------------------------------------------------------------------------
//  Annotations
//-------------------------------------------------------------------------

AnnotationTypeDeclaration
    = AT INTERFACE Identifier AnnotationTypeBody
    ;

AnnotationTypeBody
    = LWING AnnotationTypeElementDeclaration* RWING
    ;

AnnotationTypeElementDeclaration
    = Modifier* AnnotationTypeElementRest
    / SEMI
    ;

AnnotationTypeElementRest
    = Type AnnotationMethodOrConstantRest SEMI
    / ClassDeclaration
    / EnumDeclaration
    / InterfaceDeclaration
    / AnnotationTypeDeclaration
    ;

AnnotationMethodOrConstantRest
    = AnnotationMethodRest
    / AnnotationConstantRest
    ;

AnnotationMethodRest
    = Identifier LPAR RPAR DefaultValue?
    ;

AnnotationConstantRest
    = VariableDeclarators
    ;

DefaultValue
    = DEFAULT ElementValue
    ;

Annotation
    = NormalAnnotation
    / SingleElementAnnotation
    / MarkerAnnotation
    ;

NormalAnnotation
    = AT QualifiedIdentifier LPAR ElementValuePairs? RPAR
    ;

SingleElementAnnotation
    = AT QualifiedIdentifier LPAR ElementValue RPAR
    ;

MarkerAnnotation
    = AT QualifiedIdentifier
    ;

ElementValuePairs
    = ElementValuePair (COMMA ElementValuePair)*
    ;

ElementValuePair
    = Identifier EQU ElementValue
    ;

ElementValue
    = ConditionalExpression
    / Annotation
    / ElementValueArrayInitializer
    ;

ElementValueArrayInitializer
    = LWING ElementValues? COMMA? RWING
    ;

ElementValues
    = ElementValue (COMMA ElementValue)*
    ;


//=========================================================================
//  Lexical Structure
//=========================================================================
//-------------------------------------------------------------------------
//  JLS 3.1-3  Unicode
//-------------------------------------------------------------------------
//  The Unicode escapes in Java source are converted
//  to Java characters by a preprocessor prior to parsing.
//  This is not emulated here; the Unicode escapes are only allowed
//  in string and character literals. They are treated as error in other
//  structures (except comments). The warning in JLS 3.10.5 against using
//  Unicode escapes for line terminators and quotes in string and character
//  literals does not apply here.
//-------------------------------------------------------------------------

//-------------------------------------------------------------------------
//  JLS 3.6-7  Spacing
//-------------------------------------------------------------------------

Spacing
    = ( [ \t\r\n\u000C]+          // WhiteSpace
      / "/*" (!"*/" _)* "*/"      // TraditionalComment
      / "//" (![\r\n] _)* [\r\n]  // EndOfLineComment
      )* ;

//-------------------------------------------------------------------------
//  JLS 3.8  Identifiers
//-------------------------------------------------------------------------

Identifier  = !Keyword Letter LetterOrDigit* Spacing;

Letter = [a-z] / [A-Z] / [_$] ;

LetterOrDigit = [a-z] / [A-Z] / [0-9] / [_$] ;

    // These are traditional definitions of letters and digits.
    // JLS defines letters and digits as Unicode characters recognized
    // as such by special Java procedures, which is difficult
    // to express in terms of Parsing Expressions.

//-------------------------------------------------------------------------
//  JLS 3.9  Keywords
//  More precisely: reserved words. According to JLS, "true", "false",
//  and "null" are technically not keywords - but still must not appear
//  as identifiers. Keywords "const" and "goto" are not used; JLS explains
//  the reason.
//-------------------------------------------------------------------------

Keyword

    = ( "abstract"
      / "assert"
      / "boolean"
      / "break"
      / "byte"
      / "case"
      / "catch"
      / "char"
      / "class"
      / "const"
      / "continue"
      / "default"
      / "double"
      / "do"
      / "else"
      / "enum"
      / "extends"
      / "false"
      / "finally"
      / "final"
      / "float"
      / "for"
      / "goto"
      / "if"
      / "implements"
      / "import"
      / "interface"
      / "int"
      / "instanceof"
      / "long"
      / "native"
      / "new"
      / "null"
      / "package"
      / "private"
      / "protected"
      / "public"
      / "return"
      / "short"
      / "static"
      / "strictfp"
      / "super"
      / "switch"
      / "synchronized"
      / "this"
      / "throws"
      / "throw"
      / "transient"
      / "true"
      / "try"
      / "void"
      / "volatile"
      / "while"
      ) !LetterOrDigit
    ;

ASSERT       = "assert"       !LetterOrDigit Spacing ;
BREAK        = "break"        !LetterOrDigit Spacing ;
CASE         = "case"         !LetterOrDigit Spacing ;
CATCH        = "catch"        !LetterOrDigit Spacing ;
CLASS        = "class"        !LetterOrDigit Spacing ;
CONTINUE     = "continue"     !LetterOrDigit Spacing ;
DEFAULT      = "default"      !LetterOrDigit Spacing ;
DO           = "do"           !LetterOrDigit Spacing ;
ELSE         = "else"         !LetterOrDigit Spacing ;
ENUM         = "enum"         !LetterOrDigit Spacing ;
EXTENDS      = "extends"      !LetterOrDigit Spacing ;
FINALLY      = "finally"      !LetterOrDigit Spacing ;
FINAL        = "final"        !LetterOrDigit Spacing ;
FOR          = "for"          !LetterOrDigit Spacing ;
IF           = "if"           !LetterOrDigit Spacing ;
IMPLEMENTS   = "implements"   !LetterOrDigit Spacing ;
IMPORT       = "import"       !LetterOrDigit Spacing ;
INTERFACE    = "interface"    !LetterOrDigit Spacing ;
INSTANCEOF   = "instanceof"   !LetterOrDigit Spacing ;
NEW          = "new"          !LetterOrDigit Spacing ;
PACKAGE      = "package"      !LetterOrDigit Spacing ;
RETURN       = "return"       !LetterOrDigit Spacing ;
STATIC       = "static"       !LetterOrDigit Spacing ;
SUPER        = "super"        !LetterOrDigit Spacing ;
SWITCH       = "switch"       !LetterOrDigit Spacing ;
SYNCHRONIZED = "synchronized" !LetterOrDigit Spacing ;
THIS         = "this"         !LetterOrDigit Spacing ;
THROWS       = "throws"       !LetterOrDigit Spacing ;
THROW        = "throw"        !LetterOrDigit Spacing ;
TRY          = "try"          !LetterOrDigit Spacing ;
VOID         = "void"         !LetterOrDigit Spacing ;
WHILE        = "while"        !LetterOrDigit Spacing ;

//-------------------------------------------------------------------------
//  JLS 3.10  Literals
//-------------------------------------------------------------------------

Literal
    = ( FloatLiteral
      / IntegerLiteral          // May be a prefix of FloatLiteral
      / CharLiteral
      / StringLiteral
      / "true"  !LetterOrDigit
      / "false" !LetterOrDigit
      / "null"  !LetterOrDigit
      ) Spacing
    ;

IntegerLiteral
    = ( HexNumeral
      / BinaryNumeral
      / OctalNumeral            // May be a prefix of HexNumeral or BinaryNumeral
      / DecimalNumeral          // May be a prefix of OctalNumeral
      ) [lL]?
    ;

DecimalNumeral
    = "0"
    / [1-9]([_]*[0-9])*
    ;

HexNumeral
    = ("0x" / "0X") HexDigits
    ;

BinaryNumeral
    = ("0b" / "0B") [01]([_]*[01])*
    ;

OctalNumeral
    = "0" ([_]*[0-7])+
    ;

FloatLiteral
    = HexFloat
    / DecimalFloat
    ;

DecimalFloat
    = Digits "." Digits?  Exponent? [fFdD]?
    / "." Digits Exponent? [fFdD]?
    / Digits Exponent [fFdD]?
    / Digits Exponent? [fFdD]
    ;

Exponent
    = [eE] [+\-]? Digits
    ;

HexFloat
    = HexSignificand BinaryExponent [fFdD]?
    ;

HexSignificand
    = ("0x" / "0X") HexDigits? "." HexDigits
    / HexNumeral "."?                           // May be a prefix of above
    ;

BinaryExponent
    = [pP] [+\-]? Digits
    ;

Digits
    = [0-9]([_]*[0-9])*
    ;

HexDigits
    = HexDigit ([_]*HexDigit)*
    ;

HexDigit
    = [a-f] / [A-F] / [0-9]
    ;

CharLiteral
    = "'" (Escape / !['\\\n\r] _) "'"                      // this " keeps the editor happy
    ;

StringLiteral
    = "\"" (Escape / !["\\\n\r] _)* "\""                   // this " keeps the editor happy
    ;

Escape
    = "\\" ([btnfr"'\\] / OctalEscape / UnicodeEscape)     // this " keeps the editor happy
    ;

OctalEscape
    = [0-3][0-7][0-7]
    / [0-7][0-7]
    / [0-7]
    ;

UnicodeEscape
    = "u"+ HexDigit HexDigit HexDigit HexDigit
    ;

//-------------------------------------------------------------------------
//  JLS 3.11-12  Separators, Operators
//-------------------------------------------------------------------------

AT              =   "@"       Spacing;
AND             =   "&"![=&]  Spacing;
ANDAND          =   "&&"      Spacing;
ANDEQU          =   "&="      Spacing;
BANG            =   "!" !"="  Spacing;
BSR             =   ">>>"!"=" Spacing;
BSREQU          =   ">>>="    Spacing;
COLON           =   ":"       Spacing;
COMMA           =   ","       Spacing;
DEC             =   "--"      Spacing;
DIV             =   "/" !"="  Spacing;
DIVEQU          =   "/="      Spacing;
DOT             =   "."       Spacing;
ELLIPSIS        =   "..."     Spacing;
EQU             =   "=" !"="  Spacing;
EQUAL           =   "=="      Spacing;
GE              =   ">="      Spacing;
GT              =   ">"![=>]  Spacing;
HAT             =   "^"!"="   Spacing;
HATEQU          =   "^="      Spacing;
INC             =   "++"      Spacing;
LBRK            =   "["       Spacing;
LE              =   "<="      Spacing;
LPAR            =   "("       Spacing;
LPOINT          =   "<"       Spacing;
LT              =   "<"![=<]  Spacing;
LWING           =   "{"       Spacing;
MINUS           =   "-"![=\-] Spacing;
MINUSEQU        =   "-="      Spacing;
MOD             =   "%"!"="   Spacing;
MODEQU          =   "%="      Spacing;
NOTEQUAL        =   "!="      Spacing;
OR              =   "|"![=|]  Spacing;
OREQU           =   "|="      Spacing;
OROR            =   "||"      Spacing;
PLUS            =   "+"![=+]  Spacing;
PLUSEQU         =   "+="      Spacing;
QUERY           =   "?"       Spacing;
RBRK            =   "]"       Spacing;
RPAR            =   ")"       Spacing;
RPOINT          =   ">"       Spacing;
RWING           =   "}"       Spacing;
SEMI            =   ";"       Spacing;
SL              =   "<<"!"="  Spacing;
SLEQU           =   "<<="     Spacing;
SR              =   ">>"![=>] Spacing;
SREQU           =   ">>="     Spacing;
STAR            =   "*"!"="   Spacing;
STAREQU         =   "*="      Spacing;
TILDA           =   "~"       Spacing;

EOT = !_ ;