case-sensitive // cause that's what Java is

= source

<sourcepart> <source> = source

! <int> = translatorcall

<translatorcall> = sourcepart

<classdecl> = sourcepart

<modifiers> class <identifier> <typeparams> = classhead

static = modifier

public = modifier

abstract = modifier

protected = modifier

final = modifier

transient = modifier

volatile = modifier

synchronized = modifier

= modifiers

<modifier> <modifiers> = modifiers

<classhead> { } = emptyclass

<emptyclass> = classdecl

<classhead> { <classbody> } = classdecl

<classbody> <classbody> = classbody

; = classbody

<vardecl> = classbody

<qid> = type

<qid> <typeparams> = type

<type> [] = type

<> = typeargs

< <typelist> > = typeargs

<typeargs> = typeargs_opt

= typeargs_opt

= typeparams

< <typeparamlist_opt> > = typeparams

= typeparamlist_opt

<typeparamlist> = typeparamlist_opt

<typeparam> = typeparamlist

<typeparam>, <typeparamlist> = typeparamlist

<type> = typeparam

<type> extends <type> = typeparam

<type> implements <type> = typeparam

<type> = typelist

<type>, <typelist> = typelist

<block> = blockorsemicolon

; = blockorsemicolon

() = argsdecl2

(<argsdecl>) = argsdecl2

= throws_opt

throws <typelist> = throws_opt

<modifiers> <type> <identifier> <argsdecl2> <throws_opt> <blockorsemicolon> = method

<modifiers> <identifier> <argsdecl2> <throws_opt> <block> = constructordecl

<modifiers> * <argsdecl2> <throws_opt> <block> = constructordecl // javax

<constructordecl> = classbody

<method> = classbody

<classdecl> = classbody // inner classes!

<identifier> = expX

<quoted> = expX

<int> = expX

-<int> = expX

// explist, args

<exp> = actualExplist

<exp>, <actualExplist> = actualExplist

<actualExplist> = explist

= explist

(<explist>) = args

// function calls - precedence?

<identifier> <args> = call

<call> = expX

// method call - precedence?

<exp>.<call> = methodcall

<methodcall> = expX

// qualified identifier

<identifier> = qid

<identifier>.<qid> = qid

<qid> = expX

// "new" expressions

new <qid> <typeargs_opt> = newexp // JavaX!

new <qid> <typeargs_opt> <args> = newexp

<newexp> = exp

// bracketing expressions - gives highest precedence

( <exp> ) = expX

// binary operators

<expX> = exp3

<exp3> = exp2

<exp2> * <exp3> = exp2

<exp2> / <exp3> = exp2

<exp2> = exp1

<exp1> + <exp2> = exp1

<exp1> - <exp2> = exp1

<exp1> = exp0

<exp1> < <exp1> = exp0

<exp1> > <exp1> = exp0

<exp1> != <exp1> = exp0

= empty // hack...

<exp1> = <empty> = <exp1> = exp0

// m1 = minus 1...

<exp0> = expm1

<exp0> ? <exp0> : <exp0> = expm1 // priority?

// casts (where in hierarchy?)

(<type>) <exp1> = exp1

<expm1> = exp

<type> <identifier> = argsdecl

<type> * <identifier> = argsdecl // javax

<argsdecl>, <argsdecl> = argsdecl

// variable declarations (both local and fields)

// simple variable declaration

<modifiers> <type> <identifier> = vardeclShort

<vardeclShort>; = <vardecl>

// same with initializer

<modifiers> <type> <identifier> = <exp> = vardeclShort

// todo: multiple decls...

<vardecl> = statement

<classdecl> = statement -- local class declared in code

// empty statement

; = statement

// if statements!

= else

else <statement> = else

if (<exp>) <statement> <else> = if

// extra rule because parser has trouble with empty classes at end of stream...

if (<exp>) <statement> = if

<if> = statement

// empty statement

; = emptyStatement

<emptyStatement> = statement

// return statement!

ret = returnKeyword

return = returnKeyword

<returnKeyword> <exp>; = return

<return> = statement

// statement list

= statements

<statement> <statements> = statements

// blocks!

{ <statements> } = block

<block> = statement

// assigments!

<exp> = <exp> = assignmentShort

<exp> += <exp> = assignmentShort

<exp> -= <exp> = assignmentShort

<exp> *= <exp> = assignmentShort

<exp> /= <exp> = assignmentShort

// etc...

<assignmentShort>; = statement

<call>; = statement

<methodcall>; = statement

<newexp>; = statement

// for! - gotta look how it is defined exactly...

= for1

<vardeclShort> = for1

<explist> = for1

<assignmentShort> = for1

<explist> = for2

for (<for1>; <for2>; <for1>) <statement> = for

<for> = statement

// foreach

for (<modifiers> <type> <identifier> : <exp>) <statement> = foreach

<foreach> = statement

// imports

import <qid>; = import

import <qid>.*; = import

import static <qid>; = import

import static <qid>.*; = import

<import> = sourcepart

// synchronized statement

synchronized(<exp>) <statement> = statement

// try / catch

catch (<vardecl>) <block> = catch

finally <block> = catches

<catch> = catches

<catch> <catches> = catches

try <block> <catches> = try

<try> = statement