LEXING:
SKIP: 
(
        " "|"\t"|"\n"|"\r"|"\f"
    |
        <"//" (~["\n"])*>
    |
//        <"/*" (~["*"]|"*" ~["/"])* "*/">

        <"/*" (~["*"])* "*" ("*" | (~["*","/"] (~["*"])* "*"))* "/" >
)

TOKENS:

// Keywords
ABSTRACT     = "abstract"
BOOLEAN      = "boolean"
BREAK        = "break"
BYTE         = "byte"
CASE         = "case"
CATCH        = "catch"
CHAR         = "char"
CLASS        = "class"
CONST        = "const"
CONTINUE     = "continue"
_DEFAULT     = "default"
DO           = "do"
DOUBLE       = "double"
ELSE         = "else"
EXTENDS      = "extends"
FALSE        = "false"
FINAL        = "final"
FINALLY      = "finally"
FLOAT        = "float"
FOR          = "for"
GOTO         = "goto"
IF           = "if"
IMPLEMENTS   = "implements"
IMPORT       = "import"
INSTANCEOF   = "instanceof"
INT          = "int"
INTERFACE    = "interface"
LONG         = "long"
NATIVE       = "native"
NEW          = "new"
NULL         = "null"
PACKAGE      = "package"
PRIVATE      = "private"
PROTECTED    = "protected"
PUBLIC       = "public"
RETURN       = "return"
SHORT        = "short"
STATIC       = "static"
SUPER        = "super"
SWITCH       = "switch"
SYNCHRONIZED = "synchronized"
THIS         = "this"
THROW        = "throw"
THROWS       = "throws"
TRANSIENT    = "transient"
TRUE         = "true"
TRY          = "try"
VOID         = "void"
VOLATILE     = "volatile"
WHILE        = "while"
STRICTFP     = "strictfp"
ASSERT       = "assert"


// Litterals
INTEGER_LITERAL = (["1"-"9"] (["0"-"9"])* (["l","L"])?
                  | "0" ["x","X"] (["0"-"9","a"-"f","A"-"F"])+(["l","L"])?
                  | "0" (["0"-"7"])*)(["l","L"])?

FLOATING_POINT_LITERAL = 
((["0"-"9"])+ "." (["0"-"9"])* (["e","E"] (["+","-"])? (["0"-"9"])+)? 
            (["f","F","d","D"])?
| "." (["0"-"9"])+ (["e","E"] (["+","-"])? (["0"-"9"])+)? (["f","F","d","D"])?
| (["0"-"9"])+ (["e","E"] (["+","-"])? (["0"-"9"])+) (["f","F","d","D"])?
| (["0"-"9"])+ (["e","E"] (["+","-"])? (["0"-"9"])+)? ["f","F","d","D"])

CHARACTER_LITERAL = "'"
                    (   (~["'","\\","\n","\r"])
                      | ("\\"
                          ( ["n","t","b","r","f","\\","'","\""]
                          | ["0"-"7"] ( ["0"-"7"] )?
                          | ["0"-"3"] ["0"-"7"] ["0"-"7"]
                          )
                        )
                    )
                    "'"

STRING_LITERAL = "\""
                 (   (~["\"","\\","\n","\r"])
                   | ("\\"
                       ( ["n","t","b","r","f","\\","'","\""]
                       | ["0"-"7"] ( ["0"-"7"] )?
                       | ["0"-"3"] ["0"-"7"] ["0"-"7"]
                       )
                     )
                 )*
                 "\""

IDENTIFIER = [
              "\u0024",
              "\u0041"-"\u005a",
              "\u005f",
              "\u0061"-"\u007a",
              "\u00c0"-"\u00d6",
              "\u00d8"-"\u00f6",
              "\u00f8"-"\u00ff",
              "\u0100"-"\u1fff",
              "\u3040"-"\u318f",
              "\u3300"-"\u337f",
              "\u3400"-"\u3d2d",
              "\u4e00"-"\u9fff",
              "\uf900"-"\ufaff"
             ] ([
              "\u0024",
              "\u0041"-"\u005a",
              "\u005f",
              "\u0061"-"\u007a",
              "\u00c0"-"\u00d6",
              "\u00d8"-"\u00f6",
              "\u00f8"-"\u00ff",
              "\u0100"-"\u1fff",
              "\u3040"-"\u318f",
              "\u3300"-"\u337f",
              "\u3400"-"\u3d2d",
              "\u4e00"-"\u9fff",
              "\uf900"-"\ufaff"
             ]|[
              "\u0030"-"\u0039",
              "\u0660"-"\u0669",
              "\u06f0"-"\u06f9",
              "\u0966"-"\u096f",
              "\u09e6"-"\u09ef",
              "\u0a66"-"\u0a6f",
              "\u0ae6"-"\u0aef",
              "\u0b66"-"\u0b6f",
              "\u0be7"-"\u0bef",
              "\u0c66"-"\u0c6f",
              "\u0ce6"-"\u0cef",
              "\u0d66"-"\u0d6f",
              "\u0e50"-"\u0e59",
              "\u0ed0"-"\u0ed9",
              "\u1040"-"\u1049"
             ])*

// separators
LPAREN    = "("
RPAREN    = ")"
LBRACE    = "{"
RBRACE    = "}"
LBRACKET  = "[" 
RBRACKET  = "]" 
SEMICOLON = ";"
COMMA     = ","
DOT       = "."

// operators
ASSIGN               = "="
GT                   = ">"
LT                   = "<"
BANG                 = "!"
TILDE                = "~"
HOOK                 = "?"
COLON                = ":"
EQ                   = "=="
LE                   = "<="
GE                   = ">="
NE                   = "!="
SC_OR                = "||"
SC_AND               = "&&"
INCR                 = "++"
DECR                 = "--"
PLUS                 = "+"
MINUS                = "-"
STAR                 = "*"
SLASH                = "/"
BIT_AND              = "&"
BIT_OR               = "|"
XOR                  = "^"
REM                  = "%"
LSHIFT               = "<<"
RSIGNEDSHIFT         = ">>"
RUNSIGNEDSHIFT       = ">>>"
PLUSASSIGN           = "+="
MINUSASSIGN          = "-="
STARASSIGN           = "*="
SLASHASSIGN          = "/="
ANDASSIGN            = "&="
ORASSIGN             = "|="
XORASSIGN            = "^="
REMASSIGN            = "%="
LSHIFTASSIGN         = "<<="
RSIGNEDSHIFTASSIGN   = ">>="
RUNSIGNEDSHIFTASSIGN = ">>>="


GRAMMAR:

///////////////////////////////////////////////////////////////////////////
////////////////////// Program structure syntax ///////////////////////////
///////////////////////////////////////////////////////////////////////////

CompilationUnit ::= (PackageDeclaration)? (ImportDeclaration)*   (TypeDeclaration)*
                ;

PackageDeclaration ::= PACKAGE Name SEMICOLON
                   ;

ImportDeclaration ::= IMPORT Name (DOT STAR)? SEMICOLON
                  ;

TypeDeclaration ::= {LOOKAHEAD((<ABSTRACT> | <FINAL> | <PUBLIC> | <STRICTFP>)* 
                                  <CLASS>)}
                    ClassDeclaration
                |   InterfaceDeclaration
                |   SEMICOLON
                ;

///////////////////////////////////////////////////////////////////////////
///////////////////////// Declaration syntax //////////////////////////////
///////////////////////////////////////////////////////////////////////////

ClassDeclaration ::= ( ABSTRACT | FINAL | PUBLIC | STRICTFP)*
                     UnmodifiedClassDeclaration
                 ;

UnmodifiedClassDeclaration ::= 
            CLASS IDENTIFIER (EXTENDS Name)? (IMPLEMENTS NameList)?
            ClassBody
                           ;

ClassBody ::= LBRACE (ClassBodyDeclaration)* RBRACE
          ;

NestedClassDeclaration ::= ( STATIC | ABSTRACT | FINAL | 
                                PUBLIC | PROTECTED | PRIVATE | STRICTFP)*
                           UnmodifiedClassDeclaration
                       ;

ClassBodyDeclaration ::= {LOOKAHEAD(2)} Initializer
                     |
                         {LOOKAHEAD((<STATIC> | <ABSTRACT> | <FINAL> | 
                                     <PUBLIC> | <PROTECTED> | <PRIVATE> | 
                                     <STRICTFP>)* <CLASS>)}
                         NestedClassDeclaration
                     |
                         {LOOKAHEAD((<STATIC> | <ABSTRACT> | <FINAL> | 
                                     <PUBLIC> | <PROTECTED> | <PRIVATE> | 
                                     <STRICTFP>)* <INTERFACE>)}
                         NestedInterfaceDeclaration
                     |
                         {LOOKAHEAD([<PUBLIC> | <PROTECTED> | 
                                        <PRIVATE>] Name() <LPAREN>)}
                         ConstructorDeclaration
                     |
                         {LOOKAHEAD(MethodDeclarationLookahead())}
                         MethodDeclaration
                     |
                         FieldDeclaration
                     ;

// a lookahead production
MethodDeclarationLookahead ::= ( PUBLIC | PROTECTED | PRIVATE | STATIC |
                                 ABSTRACT | FINAL | NATIVE | SYNCHRONIZED
                                 | STRICTFP)*
                               ResultType IDENTIFIER LPAREN
                           ;

InterfaceDeclaration ::= (ABSTRACT | PUBLIC | STRICTFP)*
                         UnmodifiedInterfaceDeclaration
                     ;

NestedInterfaceDeclaration ::= ( STATIC | ABSTRACT | FINAL | 
                                 PUBLIC | PROTECTED | PRIVATE | STRICTFP
                               )*
                               UnmodifiedInterfaceDeclaration
                           ;

UnmodifiedInterfaceDeclaration ::= INTERFACE IDENTIFIER (EXTENDS NameList)?
                                   LBRACE (InterfaceMemberDeclaration)* RBRACE
                               ;

InterfaceMemberDeclaration ::= {LOOKAHEAD((<STATIC> | <ABSTRACT> | <FINAL> | 
                                              <PUBLIC> | <PROTECTED> | <PRIVATE> | 
                                              <STRICTFP>)* <CLASS>)}
                               NestedClassDeclaration
                           |
                               {LOOKAHEAD((<STATIC> | <ABSTRACT> | <FINAL> | 
                                              <PUBLIC> | <PROTECTED> | <PRIVATE> | 
                                              <STRICTFP>)* <INTERFACE>)}
                               NestedInterfaceDeclaration
                           |
                               {LOOKAHEAD(MethodDeclarationLookahead())}
                               MethodDeclaration
                           |
                               FieldDeclaration
                           ;

FieldDeclaration ::= (PUBLIC | PROTECTED | PRIVATE | 
                      STATIC | FINAL | TRANSIENT | VOLATILE )*
                     Type VariableDeclarator (COMMA VariableDeclarator)* SEMICOLON
                 ;

VariableDeclarator ::= VariableDeclaratorId (ASSIGN VariableInitializer)?
                   ;

VariableDeclaratorId ::= IDENTIFIER ( LBRACKET RBRACKET )*
                     ;

VariableInitializer ::= ArrayInitializer
                    |
                        Expression
                    ;

ArrayInitializer ::= LBRACE (VariableInitializer (
                                {LOOKAHEAD(2)} COMMA VariableInitializer)*)? 
                            (COMMA)? 
                     RBRACE
                 ;

MethodDeclaration ::= ( PUBLIC | PROTECTED | PRIVATE | STATIC |
                        ABSTRACT | FINAL | NATIVE | SYNCHRONIZED | STRICTFP
                      )*
                      ResultType MethodDeclarator (THROWS NameList)?
                      ( Block | SEMICOLON )
                  ;

MethodDeclarator ::= IDENTIFIER FormalParameters (LBRACKET RBRACKET)*
                 ;

FormalParameters ::= LPAREN (FormalParameter (COMMA FormalParameter)*)? RPAREN
                 ;

FormalParameter ::= (FINAL)? Type VariableDeclaratorId
                ;

ConstructorDeclaration ::= (PUBLIC | PROTECTED | PRIVATE)?
                           IDENTIFIER FormalParameters (THROWS NameList)?
                           LBRACE 
                           ({LOOKAHEAD(ExplicitConstructorInvocation())} 
                                ExplicitConstructorInvocation)?
                           (BlockStatement)*
                           RBRACE
                       ;

ExplicitConstructorInvocation ::= {LOOKAHEAD(<THIS> Arguments() <SEMICOLON>)}
                                  THIS Arguments SEMICOLON
                              |
                                  ({LOOKAHEAD(2)} PrimaryExpression DOT)? 
                                        SUPER Arguments SEMICOLON
                              ;

Initializer ::= (STATIC)? Block
            ;

///////////////////////////////////////////////////////////////////////////
//////////// Type, name and expression syntax follows. ////////////////////
///////////////////////////////////////////////////////////////////////////

Type ::= (PrimitiveType | Name) (LBRACKET RBRACKET)*
     ;

PrimitiveType ::= BOOLEAN | CHAR | BYTE | SHORT | INT | LONG | FLOAT |
                  DOUBLE
              ;

ResultType ::= VOID | Type
           ;

// A lookahead of 2 is required below since "Name" can be followed
// by a ".*" when used in the context of an "ImportDeclaration".
Name ::= IDENTIFIER ( {LOOKAHEAD(2)} DOT IDENTIFIER)*
     ;

NameList ::= Name ( COMMA Name)*
         ;

///////////////////////////////////////////////////////////////////////////
////////////////////// Expression syntax follows. /////////////////////////
///////////////////////////////////////////////////////////////////////////

Expression ::= ConditionalExpression 
               (AssignmentOperator Expression)?
           ;

AssignmentOperator ::= ASSIGN | STARASSIGN | SLASHASSIGN | REMASSIGN |
                       PLUSASSIGN | MINUSASSIGN | LSHIFTASSIGN |
                       RSIGNEDSHIFTASSIGN | RUNSIGNEDSHIFTASSIGN |
                       ANDASSIGN | XORASSIGN | ORASSIGN
                   ;

ConditionalExpression ::= ConditionalOrExpression
                          (HOOK Expression COLON ConditionalExpression)?
                      ;

ConditionalOrExpression ::= ConditionalAndExpression 
                            (SC_OR ConditionalAndExpression)*
                        ;

ConditionalAndExpression ::= InclusiveOrExpression (SC_AND InclusiveOrExpression)*
                         ;

InclusiveOrExpression ::= ExclusiveOrExpression (BIT_OR ExclusiveOrExpression)*
                      ;

ExclusiveOrExpression ::= AndExpression (XOR AndExpression)*
                      ;

AndExpression ::= EqualityExpression (BIT_AND EqualityExpression)*
              ;

EqualityExpression ::= InstanceOfExpression (( EQ | NE) InstanceOfExpression)*
                   ;

InstanceOfExpression ::= RelationalExpression (INSTANCEOF Type)?
                     ;

RelationalExpression ::= ShiftExpression (( LT | GT | LE | GE ) ShiftExpression)*
                     ;

ShiftExpression ::= AdditiveExpression
                    ((LSHIFT | RSIGNEDSHIFT | RUNSIGNEDSHIFT) AdditiveExpression)*
                ;

AdditiveExpression ::= MultiplicativeExpression
                       (( PLUS | MINUS ) MultiplicativeExpression)*
                   ;

MultiplicativeExpression ::= UnaryExpression
                             (( STAR | SLASH | REM ) UnaryExpression)*
                         ;

UnaryExpression ::= (PLUS | MINUS) UnaryExpression
                |
                    PreIncrementExpression
                |
                    PreDecrementExpression
                |
                    UnaryExpressionNotPlusMinus
                ;

PreIncrementExpression ::= INCR PrimaryExpression
                       ;

PreDecrementExpression ::= DECR PrimaryExpression
                       ;

UnaryExpressionNotPlusMinus ::= (TILDE | BANG) UnaryExpression
                            |
                                {LOOKAHEAD(CastLookahead())}
                                CastExpression
                            |
                                PostfixExpression
                            ;

CastLookahead ::= {LOOKAHEAD(2)} LPAREN PrimitiveType
              |   {LOOKAHEAD(<LPAREN> Name() <LBRACKET>)}
                  LPAREN Name LBRACKET RBRACKET
              |
                  LPAREN Name RPAREN (TILDE | BANG | LPAREN | IDENTIFIER |
                                      THIS | SUPER | NEW | Literal)
              ;

PostfixExpression ::= PrimaryExpression (INCR | DECR)?
                  ;

CastExpression ::= {LOOKAHEAD(<LPAREN> PrimitiveType())}
                   LPAREN Type RPAREN UnaryExpression
               |
                   LPAREN Type RPAREN UnaryExpressionNotPlusMinus
               ;

PrimaryExpression ::= PrimaryPrefix ({LOOKAHEAD(2)} PrimarySuffix)*
                  ;

PrimaryPrefix ::= Literal | THIS | SUPER DOT IDENTIFIER |
                  LPAREN Expression RPAREN
              |
                  AllocationExpression
              |
                  {LOOKAHEAD(ResultType() <DOT> <CLASS>)}
                  ResultType DOT CLASS
              |
                  Name
              ;

PrimarySuffix ::= {LOOKAHEAD(2)} DOT THIS |
                  {LOOKAHEAD(2)} DOT AllocationExpression |
                  LBRACKET Expression RBRACKET |
                  DOT IDENTIFIER |
                  Arguments
              ;

Literal ::= INTEGER_LITERAL | FLOATING_POINT_LITERAL | CHARACTER_LITERAL |
            STRING_LITERAL | BooleanLiteral | NullLiteral
        ;

BooleanLiteral ::= TRUE | FALSE 
               ;

NullLiteral ::= NULL
            ;

Arguments ::= LPAREN (ArgumentList)? RPAREN
          ;

ArgumentList ::= Expression (COMMA Expression)*
             ;

AllocationExpression ::= {LOOKAHEAD(2)} NEW PrimitiveType ArrayDimsAndInits
                     |
                         NEW Name (ArrayDimsAndInits | Arguments (ClassBody)?)
                     ;

ArrayDimsAndInits ::= {LOOKAHEAD(2)}
                      ({LOOKAHEAD(2)} LBRACKET Expression RBRACKET)+
                      ({LOOKAHEAD(2)} LBRACKET RBRACKET)*
                  |
                      (LBRACKET RBRACKET)+ ArrayInitializer
                  ;

///////////////////////////////////////////////////////////////////////////
////////////////////// Statement syntax follows. //////////////////////////
///////////////////////////////////////////////////////////////////////////

Statement ::= {LOOKAHEAD(2)} LabeledStatement 
          |   Block | EmptyStatement | StatementExpression SEMICOLON |
              SwitchStatement | IfStatement | WhileStatement |
              DoStatement | ForStatement | BreakStatement |
              ContinueStatement | ReturnStatement | ThrowStatement |
              SynchronizedStatement | TryStatement | AssertStatement
          ;

LabeledStatement ::= IDENTIFIER COLON Statement
                 ;

Block ::= LBRACE (BlockStatement)* RBRACE
      ;

BlockStatement ::= {LOOKAHEAD((<FINAL>)? Type() <IDENTIFIER>)}
                   LocalVariableDeclaration SEMICOLON
               |   Statement | UnmodifiedClassDeclaration |
                   UnmodifiedInterfaceDeclaration
               ;

LocalVariableDeclaration ::= (FINAL)? Type VariableDeclarator
                             (COMMA VariableDeclarator)*
                         ;

EmptyStatement ::= SEMICOLON
               ;

// The last expansion of this production accepts more than the legal
// Java expansions for StatementExpression.  This expansion does not
// use PostfixExpression for performance reasons.
StatementExpression ::= PreIncrementExpression |
                        PreDecrementExpression |
                        PrimaryExpression (INCR | DECR | AssignmentOperator Expression)?
                    ;

SwitchStatement ::= SWITCH LPAREN Expression RPAREN LBRACE
                    (SwitchLabel (BlockStatement)*)* RBRACE
                ;

SwitchLabel ::= CASE Expression COLON | _DEFAULT COLON
            ;

// The disambiguating algorithm of JavaCC automatically binds dangling
// else's to the innermost if statement.  The LOOKAHEAD specification 
// is to tell JavaCC that we know what we are doing.                  
IfStatement ::= IF LPAREN Expression RPAREN Statement ({LOOKAHEAD(1)} ELSE Statement)?
            ;

WhileStatement ::= WHILE LPAREN Expression RPAREN Statement
               ;

DoStatement ::= DO Statement WHILE LPAREN Expression RPAREN SEMICOLON
            ;

ForStatement ::= FOR LPAREN (ForInit)? SEMICOLON (Expression)?
                 SEMICOLON (ForUpdate)? RPAREN Statement
             ;

ForInit ::= {LOOKAHEAD([<FINAL>] Type() <IDENTIFIER>)}
            LocalVariableDeclaration
        |
            StatementExpressionList
        ;

StatementExpressionList ::= StatementExpression (COMMA StatementExpression)*
                        ;

ForUpdate ::= StatementExpressionList
          ;

BreakStatement ::= BREAK (IDENTIFIER)? SEMICOLON
               ;

ContinueStatement ::= CONTINUE (IDENTIFIER)? SEMICOLON
                  ;

ReturnStatement ::= RETURN (Expression)? SEMICOLON
                ;

ThrowStatement ::= THROW Expression SEMICOLON
               ;

SynchronizedStatement ::= SYNCHRONIZED LPAREN Expression RPAREN Block
                      ;

// Semantic check required here to make sure that at least one
// finally/catch is present.                                  
TryStatement ::= TRY Block ( CATCH LPAREN FormalParameter RPAREN Block)*
                 (FINALLY Block)?
             ;

AssertStatement ::= ASSERT Expression (COLON Expression)? SEMICOLON
                ;