Sharing Java

The BCPL Grammar

noreply@blogger.com (Gaute Lykkenborg) — Tue, 21 Feb 2012 21:54:00 +0000

This is the formal syntax of BCPL (Richards & Whitby-Strevens 1980:161-165). The grammar is written in ISO/IEC 14977 EBNF notation (ISO/IEC 1996).

Grammar | The goal symbol program | Index

letter =: 'A' | 'B' | 'C' | 'D' | 'E' | 'F' | 'G' | 'H' | 'I' | 'J' | 'K' | 'L' | 'M' | 'N' | 'O' | 'P' | 'Q' | 'R' | 'S' | 'T' | 'U' | 'V' | 'W' | 'X' | 'Y' | 'Z' ;
octal digit =: '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' ;
hex digit =: '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' | 'A' | 'B' | 'C' | 'D' | 'E' | 'F' ;
digit =: '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' ;
string constant =: '"', ? 255 or fewer characters ?, '"' ;
character constant =: "'", ? one character ?, "'" ;
octal number =: '#', octal digit, {octal digit} ;
hex number =: '#X', hex digit, {hex digit} ;
number =: octal number | hex number | digit, {digit} ;
identifier =: letter, {letter | digit | '.'} ;
address op =: '@' | '!' ;
mult op =: '*' | '/' | 'REM' ;
add op =: '+' | '-' ;
rel op =: '=' | '¬=' | '<=' | '>=' | '<' | '>' ;
shift op =: '<<' | '>>' ;
and op =: '&' ;
or op =: '|' ;
eqv op =: 'EQV' | 'NEQV' ;
not op =: '¬' ;
element =: character constant | string constant | number | identifier | 'TRUE' | 'FALSE' ;
primary E =: primary E, '(', expression list, ')' | primary E, '(', ')' | '(', expression, ')' | element ;
vector E =: vector E, '!', primary E | primary E ;
address E =: address op, address E | vector E ;
mult E =: mult E, mult op, address E | address E ;
add E =: add E, add op, mult E | add op, mult E | mult E ;
rel E =: add E, {rel op, add E} ;
shift E =: shift E, shift op, add E | rel E ;
not E =: not op, shift E | shift E ;
and E =: not E, {and op, not E} ;
or E =: and E, {or op, and E} ;
eqv E =: or E, {eqv op, or E} ;
conditional E =: eqv E, '->', conditional E, ',', conditional E | eqv E ;
expression =: conditional E | 'TABLE', constant expression, {',', constant expression} | 'VALOF', command ;
c element =: character constant | number | identifier | 'TRUE' | 'FALSE' | '(', constant expression, ')' ;
c mult E =: c mult E, mult op, c element | c element ;
c add E =: c add E, add op, c mult E | add op, c mult E | c mult E ;
c shift E =: c shift E, shift op, c add E | c add E ;
c and E =: c and E, and op, c shift E | c shift E ;
constant expression =: constant expression, or op, c and E | c and E ;
expression list =: expression, {',', expression} ;
name list =: name, {',', name} ;
manifest item =: identifier, '=', constant expression ;
manifest list =: manifest item, {';', manifest item} ;
manifest declaration =: 'MANIFEST', '$(', manifest list, '$)' ;
static declaration =: 'STATIC', '$(', manifest list, '$)' ;
global item =: identifier, ':', constant expression ;
global list =: global item, {';', global item} ;
global declaration =: 'GLOBAL', '$(', global list, '$)' ;
simple definition =: name list, '=', expression list ;
vector definition =: identifier, '=', 'VEC', constant expression ;
function definition =: identifier, '(', name list, ')', '=', expression | identifier, '(', ')', '=', expression ;
routine definition =: identifier, '(', name list, ')', 'BE', command | identifier, '(', ')', 'BE', command ;
definition =: simple definition | vector definition | function definition | routine definition ;
simultaneous declaration =: 'LET', definition, {'AND', definition} ;
declaration =: simultaneous declaration | manifest declaration | static declaration | global declaration ;
lhse =: identifier | vector E, '!', primary E | '!', primary E ;
left hand side list =: lhse, {',', lhse} ;
assignment =: left hand side list, ':=', expression list ;
simple command =: 'BREAK' | 'LOOP' | 'ENDCASE' | 'RETURN' | 'FINISH' ;
goto command =: 'GOTO', expression ;
routine command =: primary E, '(', expression list, ')' | primary E, '(', ')' ;
resultis command =: 'RESULTIS', expression ;
switchon command =: 'SWITCHON', expression, 'INTO', compound command ;
repeatable command =: assignment | simple command | goto command | routine command | resultis command | repeated command | switchon command | compound command | block ;
repeated command =: repeatable command, 'REAPEAT' | repeatable command, 'REPEATUNTIL', expression | repeatable command, 'REPEATWHILE', expression ;
until command =: 'UNTIL', expression, 'DO', command ;
while command =: 'WHILE', expression, 'DO', command ;
for command =: 'FOR', identifier, '=', expression, 'TO', expression, 'BY', constant expression, 'DO', command | 'FOR', identifier, '=', expression, 'TO', expression, 'DO', command ;
repetitive command =: repeated command | until command | while command | for command ;
test command =: 'TEST', expression, 'THEN', command, 'ELSE', command ;
if command =: 'IF', expression, 'THEN', command ;
unless command =: 'UNLESS', expression, 'THEN', command ;
unlabelled command =: repeatable command | repetitive command | test command | if command ;
label prefix =: identifier, ':' ;
case prefix =: 'CASE', constant expression, ':' ;
default prefix =: 'DEFAULT', ':' ;
prefix =: label prefix | case prefix | default prefix ;
command =: unlabelled command | prefix, command | prefix ;
command list =: command, {';', command} ;
declaration part =: declaration, {';', declaration} ;
block =: '$(', declaration part, ';', command list, '$)' ;
compound command =: '$(', command list, '$)' ;
program =: declaration part ;

'!': address op; lhse; vector E
'#': octal number
'#X': hex number
'$(': block; compound command; global declaration; manifest declaration; static declaration
'$)': block; compound command; global declaration; manifest declaration; static declaration
'&': and op
'¬': not op
'¬=': rel op
"'": character constant
'(': c element; function definition; primary E; routine command; routine definition
')': c element; function definition; primary E; routine command; routine definition
'"': string constant
'*': mult op
'+': add op
',': conditional E; expression list; expression; left hand side list; name list
'-': add op
'->': conditional E
'.': identifier
'/': mult op
'0': digit; hex digit; octal digit
'1': digit; hex digit; octal digit
'2': digit; hex digit; octal digit
? 255 or fewer characters ?: string constant
'3': digit; hex digit; octal digit
'4': digit; hex digit; octal digit
'5': digit; hex digit; octal digit
'6': digit; hex digit; octal digit
'7': digit; hex digit; octal digit
'8': digit; hex digit
'9': digit; hex digit
':': case prefix; default prefix; global item; label prefix
':=': assignment
';': block; command list; declaration part; global list; manifest list
'<': rel op
'<<': shift op
'<=': rel op
'=': for command; function definition; manifest item; rel op; simple definition; vector definition
'>': rel op
'>=': rel op
'>>': shift op
'@': address op
'A': hex digit; letter
'AND': simultaneous declaration
'B': hex digit; letter
'BE': routine definition
'BREAK': simple command
'BY': for command
'C': hex digit; letter
'CASE': case prefix
'D': hex digit; letter
'DEFAULT': default prefix
'DO': for command; until command; while command
'E': hex digit; letter
'ELSE': test command
'ENDCASE': simple command
'EQV': eqv op
'F': hex digit; letter
'FALSE': c element; element
'FINISH': simple command
'FOR': for command
'G': letter
'GLOBAL': global declaration
'GOTO': goto command
'H': letter
'I': letter
'IF': if command
'INTO': switchon command
'J': letter
'K': letter
'L': letter
'LET': simultaneous declaration
'LOOP': simple command
'M': letter
'MANIFEST': manifest declaration
'N': letter
'NEQV': eqv op
'O': letter
'P': letter
'Q': letter
'R': letter
'REAPEAT': repeated command
'REM': mult op
'REPEATUNTIL': repeated command
'REPEATWHILE': repeated command
'RESULTIS': resultis command
'RETURN': simple command
'S': letter
'STATIC': static declaration
'SWITCHON': switchon command
'T': letter
'TABLE': expression
'TEST': test command
'THEN': if command; test command; unless command
'TO': for command
'TRUE': c element; element
'U': letter
'UNLESS': unless command
'UNTIL': until command
'V': letter
'VALOF': expression
'VEC': vector definition
'W': letter
'WHILE': while command
'X': letter
'Y': letter
'Z': letter
add E: add E; rel E; shift E
add op: add E; add op; c add E
address E: address E; mult E
address op: address E; address op
and E: and E; or E
and op: and E; and op; c and E
assignment: assignment; repeatable command
block: block; repeatable command
c add E: c add E; c shift E
c and E: c and E; constant expression
c element: c element; c mult E
c mult E: c add E; c mult E
c shift E: c and E; c shift E
case prefix: case prefix; prefix
character constant: c element; character constant; element
command list: block; command list; compound command
command: command list; command; expression; for command; if command; routine definition; test command; unless command; until command; while command
compound command: compound command; repeatable command; switchon command
conditional E: conditional E; expression
constant expression: c element; case prefix; constant expression; expression; for command; global item; manifest item; vector definition
declaration part: block; declaration part; program
declaration: declaration part; declaration
default prefix: default prefix; prefix
definition: definition; simultaneous declaration
digit: digit; identifier; number
element: element; primary E
eqv E: conditional E; eqv E
eqv op: eqv E; eqv op
expression list: assignment; expression list; primary E; routine command; simple definition
expression: expression list; expression; for command; function definition; goto command; if command; primary E; repeated command; resultis command; switchon command; test command; unless command; until command; while command
for command: for command; repetitive command
function definition: definition; function definition
global declaration: declaration; global declaration
global item: global item; global list
global list: global declaration; global list
goto command: goto command; repeatable command
hex digit: hex digit; hex number
hex number: hex number; number
identifier: c element; element; for command; function definition; global item; identifier; label prefix; lhse; manifest item; routine definition; vector definition
if command: if command; unlabelled command
label prefix: label prefix; prefix
left hand side list: assignment; left hand side list
letter: identifier; letter
lhse: left hand side list; lhse
manifest declaration: declaration; manifest declaration
manifest item: manifest item; manifest list
manifest list: manifest declaration; manifest list; static declaration
mult E: add E; mult E
mult op: c mult E; mult E; mult op
name list: function definition; name list; routine definition; simple definition
name: name list
not E: and E; not E
not op: not E; not op
number: c element; element; number
octal digit: octal digit; octal number
octal number: number; octal number
? one character ?: character constant
or E: eqv E; or E
or op: constant expression; or E; or op
prefix: command; prefix
primary E: lhse; primary E; routine command; vector E
program: program
rel E: rel E; shift E
rel op: rel E; rel op
repeatable command: repeatable command; repeated command; unlabelled command
repeated command: repeatable command; repeated command; repetitive command
repetitive command: repetitive command; unlabelled command
resultis command: repeatable command; resultis command
routine command: repeatable command; routine command
routine definition: definition; routine definition
shift E: not E; shift E
shift op: c shift E; shift E; shift op
simple command: repeatable command; simple command
simple definition: definition; simple definition
simultaneous declaration: declaration; simultaneous declaration
static declaration: declaration; static declaration
string constant: element; string constant
switchon command: repeatable command; switchon command
test command: test command; unlabelled command
unlabelled command: command; unlabelled command
unless command: unless command
until command: repetitive command; until command
vector E: address E; lhse; vector E
vector definition: definition; vector definition
while command: repetitive command; while command
'|': or op

References

ISO/IEC. (1996). ISO/IEC 14977 : 1996(E). ISO/IEC. Retrieved Saturday, March 26, 2005 from http://www.cl.cam.ac.uk/~mgk25/iso-ebnf.html.
Richards, Martin & Colin Whitby-Strevens. (1980). BCPL - the language and its compiler. Bristol: Cambridge University Press.

The Java JLS2 Grammar

noreply@blogger.com (Gaute Lykkenborg) — Tue, 21 Feb 2012 19:06:00 +0000

This is the formal syntax of Java (JLS2 2000) from The Java Language Specification, Second Edition. The grammar is written in ISO/IEC 14977 EBNF notation (ISO/IEC 1996).

Grammar | The goal symbol Input | The goal symbol CompilationUnit | Index

UnicodeInputCharacter =: UnicodeEscape | RawInputCharacter ;
UnicodeEscape =: '\', UnicodeMarker, HexDigit, HexDigit, HexDigit, HexDigit ;
UnicodeMarker =: 'u' | UnicodeMarker, 'u' ;
RawInputCharacter =: ? any Unicode character ? ;
HexDigit =: '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' | 'a' | 'b' | 'c' | 'd' | 'e' | 'f' | 'A' | 'B' | 'C' | 'D' | 'E' | 'F' ;
LineTerminator =: ? the ASCII LF character, also known as "newline" ? | ? the ASCII CR character, also known as "return" ? | ? the ASCII CR character followed by the ASCII LF character ? ;
InputCharacter =: UnicodeInputCharacter - (? CR ? | ? LF ?) ;
Input =: [InputElements], [Sub] ;
InputElements =: InputElement | InputElements, InputElement ;
InputElement =: WhiteSpace | Comment | Token ;
Token =: Identifier | Keyword | Literal | Separator | Operator ;
Sub =: ? the ASCII SUB character, also known as "control-Z" ? ;
WhiteSpace =: ? the ASCII SP character, also known as "space" ? | ? the ASCII HT character, also known as "horizontal tab" ? | ? the ASCII FF character, also known as "form feed" ? | LineTerminator ;
Comment =: TraditionalComment | EndOfLineComment ;
TraditionalComment =: '/', '*', NotStar, CommentTail ;
EndOfLineComment =: '/', '/', [CharactersInLine], LineTerminator ;
CommentTail =: '*', CommentTailStar | NotStar, CommentTail ;
CommentTailStar =: '/' | '*', CommentTailStar | NotStarNotSlash, CommentTail ;
NotStar =: InputCharacter - '*' | LineTerminator ;
NotStarNotSlash =: InputCharacter - ('*' | '/') | LineTerminator ;
CharactersInLine =: InputCharacter | CharactersInLine, InputCharacter ;
Identifier =: IdentifierChars - (Keyword | BooleanLiteral | NullLiteral) ;
IdentifierChars =: JavaLetter | IdentifierChars, JavaLetterOrDigit ;
JavaLetter =: ? any Unicode character that is a Java letter ? ;
JavaLetterOrDigit =: ? any Unicode character that is a Java letter-or-digit ? ;
Keyword =: 'abstract' | 'boolean' | 'break' | 'byte' | 'case' | 'catch' | 'char' | 'class' | 'const' | 'continue' | 'default' | 'do' | 'double' | 'else' | 'extends' | 'final' | 'finally' | 'float' | 'for' | 'goto' | 'if' | 'implements' | 'import' | 'instanceof' | 'int' | 'interface' | 'long' | 'native' | 'new' | 'package' | 'private' | 'protected' | 'public' | 'return' | 'short' | 'static' | 'strictfp' | 'super' | 'switch' | 'synchronized' | 'this' | 'throw' | 'throws' | 'transient' | 'try' | 'void' | 'volatile' | 'while' ;
Literal =: IntegerLiteral | FloatingPointLiteral | BooleanLiteral | CharacterLiteral | StringLiteral | NullLiteral ;
IntegerLiteral =: DecimalIntegerLiteral | HexIntegerLiteral | OctalIntegerLiteral ;
DecimalIntegerLiteral =: DecimalNumeral, [IntegerTypeSuffix] ;
HexIntegerLiteral =: HexNumeral, [IntegerTypeSuffix] ;
OctalIntegerLiteral =: OctalNumeral, [IntegerTypeSuffix] ;
IntegerTypeSuffix =: 'l' | 'L' ;
DecimalNumeral =: '0' | NonZeroDigit, [Digits] ;
Digits =: Digit | Digits, Digit ;
Digit =: '0' | NonZeroDigit ;
NonZeroDigit =: '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' ;
HexNumeral =: '0', 'x', HexDigits | '0', 'X', HexDigits ;
HexDigits =: HexDigit | HexDigit, HexDigits ;
OctalNumeral =: '0', OctalDigits ;
OctalDigits =: OctalDigit | OctalDigit, OctalDigits ;
OctalDigit =: '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' ;
FloatingPointLiteral =: Digits, '.', [Digits], [ExponentPart], [FloatTypeSuffix] | '.', Digits, [ExponentPart], [FloatTypeSuffix] | Digits, ExponentPart, [FloatTypeSuffix] | Digits, [ExponentPart], FloatTypeSuffix ;
ExponentPart =: ExponentIndicator, SignedInteger ;
ExponentIndicator =: 'e' | 'E' ;
SignedInteger =: [Sign], Digits ;
Sign =: '+' | '-' ;
FloatTypeSuffix =: 'f' | 'F' | 'd' | 'D' ;
BooleanLiteral =: 'true' | 'false' ;
CharacterLiteral =: "'", SingleCharacter, "'" | "'", EscapeSequence, "'" ;
SingleCharacter =: InputCharacter - ("'" | '\') ;
StringLiteral =: '"', [StringCharacters], '"' ;
StringCharacters =: StringCharacter | StringCharacters, StringCharacter ;
StringCharacter =: InputCharacter - ('"' | '\') | EscapeSequence ;
EscapeSequence =: '\', 'b' | '\', 't' | '\', 'n' | '\', 'f' | '\', 'r' | '\', '"' | '\', "'" | '\', '\' | OctalEscape ;
OctalEscape =: '\', OctalDigit | '\', OctalDigit, OctalDigit | '\', ZeroToThree, OctalDigit, OctalDigit ;
OctalDigit =: '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' ;
ZeroToThree =: '0' | '1' | '2' | '3' ;
NullLiteral =: 'null' ;
Separator =: '(' | ')' | '{' | '}' | '[' | ']' | ';' | ',' | '.' ;
Operator =: '!' | '!=' | '%' | '%=' | '&' | '&&' | '&=' | '*' | '*=' | '+' | '++' | '+=' | '-' | '--' | '-=' | '/' | '/=' | ':' | '<' | '<<' | '<<=' | '<=' | '=' | '==' | '>' | '>=' | '>>' | '>>=' | '>>>' | '>>>=' | '?' | '^' | '^=' | '|' | '|=' | '||' | '~' ;
Type =: PrimitiveType | ReferenceType ;
PrimitiveType =: NumericType | 'boolean' ;
NumericType =: IntegralType | FloatingPointType ;
IntegralType =: 'byte' | 'short' | 'int' | 'long' | 'char' ;
FloatingPointType =: 'float' | 'double' ;
ReferenceType =: ClassOrInterfaceType | ArrayType ;
ClassOrInterfaceType =: ClassType | InterfaceType ;
ClassType =: TypeName ;
InterfaceType =: TypeName ;
ArrayType =: Type, '[', ']' ;
PackageName =: Identifier | PackageName, '.', Identifier ;
TypeName =: Identifier | PackageOrTypeName, '.', Identifier ;
ExpressionName =: Identifier | AmbiguousName, '.', Identifier ;
MethodName =: Identifier | AmbiguousName, '.', Identifier ;
PackageOrTypeName =: Identifier | PackageOrTypeName, '.', Identifier ;
AmbiguousName =: Identifier | AmbiguousName, '.', Identifier ;
CompilationUnit =: [PackageDeclaration], [ImportDeclarations], [TypeDeclarations] ;
ImportDeclarations =: ImportDeclaration | ImportDeclarations, ImportDeclaration ;
TypeDeclarations =: TypeDeclaration | TypeDeclarations, TypeDeclaration ;
PackageDeclaration =: 'package', PackageName, ';' ;
ImportDeclaration =: SingleTypeImportDeclaration | TypeImportOnDemandDeclaration ;
SingleTypeImportDeclaration =: 'import', TypeName, ';' ;
TypeImportOnDemandDeclaration =: 'import', PackageOrTypeName, '.', '*', ';' ;
TypeDeclaration =: ClassDeclaration | InterfaceDeclaration | ';' ;
ClassDeclaration =: [ClassModifiers], 'class', Identifier, [Super], [Interfaces], ClassBody ;
ClassModifiers =: ClassModifier | ClassModifiers, ClassModifier ;
ClassModifier =: 'public' | 'protected' | 'private' | 'abstract' | 'static' | 'final' | 'strictfp' ;
Super =: 'extends', ClassType ;
ClassType =: TypeName ;
Interfaces =: 'implements', InterfaceTypeList ;
InterfaceTypeList =: InterfaceType | InterfaceTypeList, ',', InterfaceType ;
ClassBody =: '{', [ClassBodyDeclarations], '}' ;
ClassBodyDeclarations =: ClassBodyDeclaration | ClassBodyDeclarations, ClassBodyDeclaration ;
ClassBodyDeclaration =: ClassMemberDeclaration | InstanceInitializer | StaticInitializer | ConstructorDeclaration ;
ClassMemberDeclaration =: FieldDeclaration | MethodDeclaration | ClassDeclaration | InterfaceDeclaration | ';' ;
FieldDeclaration =: [FieldModifiers], Type, VariableDeclarators, ';' ;
VariableDeclarators =: VariableDeclarator | VariableDeclarators, ',', VariableDeclarator ;
VariableDeclarator =: VariableDeclaratorId | VariableDeclaratorId, '=', VariableInitializer ;
VariableDeclaratorId =: Identifier | VariableDeclaratorId, '[', ']' ;
VariableInitializer =: Expression | ArrayInitializer ;
FieldModifiers =: FieldModifier | FieldModifiers, FieldModifier ;
FieldModifier =: 'public' | 'protected' | 'private' | 'static' | 'final' | 'transient' | 'volatile' ;
MethodDeclaration =: MethodHeader, MethodBody ;
MethodHeader =: [MethodModifiers], ResultType, MethodDeclarator, [Throws] ;
ResultType =: Type | 'void' ;
MethodDeclarator =: Identifier, '(', [FormalParameterList], ')' | MethodDeclarator, '[', ']' ;
FormalParameterList =: FormalParameter | FormalParameterList, ',', FormalParameter ;
FormalParameter =: ['final'], Type, VariableDeclaratorId ;
VariableDeclaratorId =: Identifier | VariableDeclaratorId, '[', ']' ;
MethodModifiers =: MethodModifier | MethodModifiers, MethodModifier ;
MethodModifier =: 'public' | 'protected' | 'private' | 'abstract' | 'static' | 'final' | 'native' | 'synchronized' | 'strictfp' ;
Throws =: 'throws', ClassTypeList ;
ClassTypeList =: ClassType | ClassTypeList, ',', ClassType ;
MethodBody =: Block | ';' ;
InstanceInitializer =: Block ;
StaticInitializer =: 'static', Block ;
ConstructorDeclaration =: [ConstructorModifiers], ConstructorDeclarator, [Throws], ConstructorBody ;
ConstructorDeclarator =: SimpleTypeName, '(', [FormalParameterList], ')' ;
ConstructorModifiers =: ConstructorModifier | ConstructorModifiers, ConstructorModifier ;
ConstructorModifier =: 'public' | 'protected' | 'private' ;
ConstructorBody =: '{', [ExplicitConstructorInvocation], [BlockStatements], '}' ;
ExplicitConstructorInvocation =: 'this', '(', [ArgumentList], ')', ';' | 'super', '(', [ArgumentList], ')', ';' | Primary, '.', 'super', '(', [ArgumentList], ')', ';' ;
InterfaceDeclaration =: [InterfaceModifiers], 'interface', Identifier, [ExtendsInterfaces], InterfaceBody ;
InterfaceModifiers =: InterfaceModifier | InterfaceModifiers, InterfaceModifier ;
InterfaceModifier =: 'public' | 'protected' | 'private' | 'abstract' | 'static' | 'strictfp' ;
ExtendsInterfaces =: 'extends', InterfaceType | ExtendsInterfaces, ',', InterfaceType ;
InterfaceType =: TypeName ;
InterfaceBody =: '{', [InterfaceMemberDeclarations], '}' ;
InterfaceMemberDeclarations =: InterfaceMemberDeclaration | InterfaceMemberDeclarations, InterfaceMemberDeclaration ;
InterfaceMemberDeclaration =: ConstantDeclaration | AbstractMethodDeclaration | ClassDeclaration | InterfaceDeclaration | ';' ;
ConstantDeclaration =: [ConstantModifiers], Type, VariableDeclarators ;
ConstantModifiers =: ConstantModifier | ConstantModifiers, ConstantModifier ;
ConstantModifier =: 'public' | 'static' | 'final' ;
AbstractMethodDeclaration =: [AbstractMethodModifiers], ResultType, MethodDeclarator, [Throws], ';' ;
AbstractMethodModifiers =: AbstractMethodModifier | AbstractMethodModifiers, AbstractMethodModifier ;
AbstractMethodModifier =: 'public', 'abstract' ;
ArrayInitializer =: '{', [VariableInitializers], [','], '}' ;
VariableInitializers =: VariableInitializer | VariableInitializers, ',', VariableInitializer ;
Block =: '{', [BlockStatements], '}' ;
BlockStatements =: BlockStatement | BlockStatements, BlockStatement ;
BlockStatement =: LocalVariableDeclarationStatement | ClassDeclaration | Statement ;
LocalVariableDeclarationStatement =: LocalVariableDeclaration, ';' ;
LocalVariableDeclaration =: ['final'], Type, VariableDeclarators ;
VariableDeclarators =: VariableDeclarator | VariableDeclarators, ',', VariableDeclarator ;
VariableDeclarator =: VariableDeclaratorId | VariableDeclaratorId, '=', VariableInitializer ;
VariableDeclaratorId =: Identifier | VariableDeclaratorId, '[', ']' ;
VariableInitializer =: Expression | ArrayInitializer ;
Statement =: StatementWithoutTrailingSubstatement | LabeledStatement | IfThenStatement | IfThenElseStatement | WhileStatement | ForStatement ;
StatementWithoutTrailingSubstatement =: Block | EmptyStatement | ExpressionStatement | SwitchStatement | DoStatement | BreakStatement | ContinueStatement | ReturnStatement | SynchronizedStatement | ThrowStatement | TryStatement ;
StatementNoShortIf =: StatementWithoutTrailingSubstatement | LabeledStatementNoShortIf | IfThenElseStatementNoShortIf | WhileStatementNoShortIf | ForStatementNoShortIf ;
EmptyStatement =: ';' ;
LabeledStatement =: Identifier, ':', Statement ;
LabeledStatementNoShortIf =: Identifier, ':', StatementNoShortIf ;
ExpressionStatement =: StatementExpression, ';' ;
StatementExpression =: Assignment | PreIncrementExpression | PreDecrementExpression | PostIncrementExpression | PostDecrementExpression | MethodInvocation | ClassInstanceCreationExpression ;
IfThenStatement =: 'if', '(', Expression, ')', Statement ;
IfThenElseStatement =: 'if', '(', Expression, ')', StatementNoShortIf, 'else', Statement ;
IfThenElseStatementNoShortIf =: 'if', '(', Expression, ')', StatementNoShortIf, 'else', StatementNoShortIf ;
SwitchStatement =: 'switch', '(', Expression, ')', SwitchBlock ;
SwitchBlock =: '{', [SwitchBlockStatementGroups], [SwitchLabels], '}' ;
SwitchBlockStatementGroups =: SwitchBlockStatementGroup | SwitchBlockStatementGroups, SwitchBlockStatementGroup ;
SwitchBlockStatementGroup =: SwitchLabels, BlockStatements ;
SwitchLabels =: SwitchLabel | SwitchLabels, SwitchLabel ;
SwitchLabel =: 'case', ConstantExpression, ':' | 'default', ':' ;
WhileStatement =: 'while', '(', Expression, ')', Statement ;
WhileStatementNoShortIf =: 'while', '(', Expression, ')', StatementNoShortIf ;
DoStatement =: 'do', Statement, 'while', '(', Expression, ')', ';' ;
ForStatement =: 'for', '(', [ForInit], ';', [Expression], ';', [ForUpdate], ')', Statement ;
ForStatementNoShortIf =: 'for', '(', [ForInit], ';', [Expression], ';', [ForUpdate], ')', StatementNoShortIf ;
ForInit =: StatementExpressionList | LocalVariableDeclaration ;
ForUpdate =: StatementExpressionList ;
StatementExpressionList =: StatementExpression | StatementExpressionList, ',', StatementExpression ;
BreakStatement =: 'break', [Identifier], ';' ;
ContinueStatement =: 'continue', [Identifier], ';' ;
ReturnStatement =: 'return', [Expression], ';' ;
ThrowStatement =: 'throw', Expression, ';' ;
SynchronizedStatement =: 'synchronized', '(', Expression, ')', Block ;
TryStatement =: 'try', Block, Catches | 'try', Block, [Catches], Finally ;
Catches =: CatchClause | Catches, CatchClause ;
CatchClause =: 'catch', '(', FormalParameter, ')', Block ;
Finally =: 'finally', Block ;
Primary =: PrimaryNoNewArray | ArrayCreationExpression ;
PrimaryNoNewArray =: Literal | Type, '.', 'class' | 'void', '.', 'class' | 'this' | ClassName, '.', 'this' | '(', Expression, ')' | ClassInstanceCreationExpression | FieldAccess | MethodInvocation | ArrayAccess ;
Literal =: IntegerLiteral | FloatingPointLiteral | BooleanLiteral | CharacterLiteral | StringLiteral | NullLiteral ;
ClassInstanceCreationExpression =: 'new', ClassOrInterfaceType, '(', [ArgumentList], ')', [ClassBody] | Primary, '.', 'new', Identifier, '(', [ArgumentList], ')', [ClassBody] ;
ArgumentList =: Expression | ArgumentList, ',', Expression ;
ArrayCreationExpression =: 'new', PrimitiveType, DimExprs, [Dims] | 'new', TypeName, DimExprs, [Dims] | 'new', PrimitiveType, Dims, ArrayInitializer | 'new', TypeName, Dims, ArrayInitializer ;
DimExprs =: DimExpr | DimExprs, DimExpr ;
DimExpr =: '[', Expression, ']' ;
Dims =: '[', ']' | Dims, '[', ']' ;
FieldAccess =: Primary, '.', Identifier | 'super', '.', Identifier | ClassName, '.', 'super', '.', Identifier ;
MethodInvocation =: MethodName, '(', [ArgumentList], ')' | Primary, '.', Identifier, '(', [ArgumentList], ')' | 'super', '.', Identifier, '(', [ArgumentList], ')' | ClassName, '.', 'super', '.', Identifier, '(', [ArgumentList], ')' ;
ArgumentList =: Expression | ArgumentList, ',', Expression ;
ArrayAccess =: ExpressionName, '[', Expression, ']' | PrimaryNoNewArray, '[', Expression, ']' ;
PostfixExpression =: Primary | ExpressionName | PostIncrementExpression | PostDecrementExpression ;
PostIncrementExpression =: PostfixExpression, '++' ;
PostDecrementExpression =: PostfixExpression, '--' ;
UnaryExpression =: PreIncrementExpression | PreDecrementExpression | '+', UnaryExpression | '-', UnaryExpression | UnaryExpressionNotPlusMinus ;
PreIncrementExpression =: '++', UnaryExpression ;
PreDecrementExpression =: '--', UnaryExpression ;
UnaryExpressionNotPlusMinus =: PostfixExpression | '~', UnaryExpression | '!', UnaryExpression | CastExpression ;
CastExpression =: '(', PrimitiveType, [Dims], ')', UnaryExpression | '(', ReferenceType, ')', UnaryExpressionNotPlusMinus ;
MultiplicativeExpression =: UnaryExpression | MultiplicativeExpression, '*', UnaryExpression | MultiplicativeExpression, '/', UnaryExpression | MultiplicativeExpression, '%', UnaryExpression ;
AdditiveExpression =: MultiplicativeExpression | AdditiveExpression, '+', MultiplicativeExpression | AdditiveExpression, '-', MultiplicativeExpression ;
ShiftExpression =: AdditiveExpression | ShiftExpression, '<<', AdditiveExpression | ShiftExpression, '>>', AdditiveExpression | ShiftExpression, '>>>', AdditiveExpression ;
RelationalExpression =: ShiftExpression | RelationalExpression, '<', ShiftExpression | RelationalExpression, '>', ShiftExpression | RelationalExpression, '<=', ShiftExpression | RelationalExpression, '>=', ShiftExpression | RelationalExpression, 'instanceof', ReferenceType ;
EqualityExpression =: RelationalExpression | EqualityExpression, '==', RelationalExpression | EqualityExpression, '!=', RelationalExpression ;
AndExpression =: EqualityExpression | AndExpression, '&', EqualityExpression ;
ExclusiveOrExpression =: AndExpression | ExclusiveOrExpression, '^', AndExpression ;
InclusiveOrExpression =: ExclusiveOrExpression | InclusiveOrExpression, '|', ExclusiveOrExpression ;
ConditionalAndExpression =: InclusiveOrExpression | ConditionalAndExpression, '&&', InclusiveOrExpression ;
ConditionalOrExpression =: ConditionalAndExpression | ConditionalOrExpression, '||', ConditionalAndExpression ;
ConditionalExpression =: ConditionalOrExpression | ConditionalOrExpression, '?', Expression, ':', ConditionalExpression ;
AssignmentExpression =: ConditionalExpression | Assignment ;
Assignment =: LeftHandSide, AssignmentOperator, AssignmentExpression ;
LeftHandSide =: ExpressionName | FieldAccess | ArrayAccess ;
AssignmentOperator =: '=' | '*=' | '/=' | '%=' | '+=' | '-=' | '<<=' | '>>=' | '>>>=' | '&=' | '^=' | '|=' ;
Expression =: AssignmentExpression ;
ConstantExpression =: Expression ;

'!': Operator; UnaryExpressionNotPlusMinus
'!=': EqualityExpression; Operator
'%': MultiplicativeExpression; Operator
'%=': AssignmentOperator; Operator
'&': AndExpression; Operator
'&&': ConditionalAndExpression; Operator
'&=': AssignmentOperator; Operator
"'": CharacterLiteral; EscapeSequence; SingleCharacter
'(': CastExpression; CatchClause; ClassInstanceCreationExpression; ConstructorDeclarator; DoStatement; ExplicitConstructorInvocation; ForStatement; ForStatementNoShortIf; IfThenElseStatement; IfThenElseStatementNoShortIf; IfThenStatement; MethodDeclarator; MethodInvocation; PrimaryNoNewArray; Separator; SwitchStatement; SynchronizedStatement; WhileStatement; WhileStatementNoShortIf
')': CastExpression; CatchClause; ClassInstanceCreationExpression; ConstructorDeclarator; DoStatement; ExplicitConstructorInvocation; ForStatement; ForStatementNoShortIf; IfThenElseStatement; IfThenElseStatementNoShortIf; IfThenStatement; MethodDeclarator; MethodInvocation; PrimaryNoNewArray; Separator; SwitchStatement; SynchronizedStatement; WhileStatement; WhileStatementNoShortIf
'"': EscapeSequence; StringCharacter; StringLiteral
'*': CommentTail; CommentTailStar; MultiplicativeExpression; NotStar; NotStarNotSlash; Operator; TraditionalComment; TypeImportOnDemandDeclaration
'*=': AssignmentOperator; Operator
'+': AdditiveExpression; Operator; Sign; UnaryExpression
'++': Operator; PostIncrementExpression; PreIncrementExpression
'+=': AssignmentOperator; Operator
',': ArgumentList; ArrayInitializer; ClassTypeList; ExtendsInterfaces; FormalParameterList; InterfaceTypeList; Separator; StatementExpressionList; VariableDeclarators; VariableInitializers
'-': AdditiveExpression; Operator; Sign; UnaryExpression
'--': Operator; PostDecrementExpression; PreDecrementExpression
'-=': AssignmentOperator; Operator
'.': AmbiguousName; ClassInstanceCreationExpression; ExplicitConstructorInvocation; ExpressionName; FieldAccess; FloatingPointLiteral; MethodInvocation; MethodName; PackageName; PackageOrTypeName; PrimaryNoNewArray; Separator; TypeImportOnDemandDeclaration; TypeName
'/': CommentTailStar; EndOfLineComment; MultiplicativeExpression; NotStarNotSlash; Operator; TraditionalComment
'/=': AssignmentOperator; Operator
'0': DecimalNumeral; Digit; HexDigit; HexNumeral; OctalDigit; OctalNumeral; ZeroToThree
'1': HexDigit; NonZeroDigit; OctalDigit; ZeroToThree
'2': HexDigit; NonZeroDigit; OctalDigit; ZeroToThree
'3': HexDigit; NonZeroDigit; OctalDigit; ZeroToThree
'4': HexDigit; NonZeroDigit; OctalDigit
'5': HexDigit; NonZeroDigit; OctalDigit
'6': HexDigit; NonZeroDigit; OctalDigit
'7': HexDigit; NonZeroDigit; OctalDigit
'8': HexDigit; NonZeroDigit
'9': HexDigit; NonZeroDigit
':': ConditionalExpression; LabeledStatement; LabeledStatementNoShortIf; Operator; SwitchLabel
';': AbstractMethodDeclaration; BreakStatement; ClassMemberDeclaration; ContinueStatement; DoStatement; EmptyStatement; ExplicitConstructorInvocation; ExpressionStatement; FieldDeclaration; ForStatement; ForStatementNoShortIf; InterfaceMemberDeclaration; LocalVariableDeclarationStatement; MethodBody; PackageDeclaration; ReturnStatement; Separator; SingleTypeImportDeclaration; ThrowStatement; TypeDeclaration; TypeImportOnDemandDeclaration
'<': Operator; RelationalExpression
'<<': Operator; ShiftExpression
'<<=': AssignmentOperator; Operator
'<=': Operator; RelationalExpression
'=': AssignmentOperator; Operator; VariableDeclarator
'==': EqualityExpression; Operator
'>': Operator; RelationalExpression
'>=': Operator; RelationalExpression
'>>': Operator; ShiftExpression
'>>=': AssignmentOperator; Operator
'>>>': Operator; ShiftExpression
'>>>=': AssignmentOperator; Operator
'?': ConditionalExpression; Operator
'A': HexDigit
AbstractMethodDeclaration: AbstractMethodDeclaration; InterfaceMemberDeclaration
AbstractMethodModifier: AbstractMethodModifier; AbstractMethodModifiers
AbstractMethodModifiers: AbstractMethodDeclaration; AbstractMethodModifiers
AdditiveExpression: AdditiveExpression; ShiftExpression
AmbiguousName: AmbiguousName; ExpressionName; MethodName
AndExpression: AndExpression; ExclusiveOrExpression
ArgumentList: ArgumentList; ClassInstanceCreationExpression; ExplicitConstructorInvocation; MethodInvocation
ArrayAccess: ArrayAccess; LeftHandSide; PrimaryNoNewArray
ArrayCreationExpression: ArrayCreationExpression; Primary
ArrayInitializer: ArrayCreationExpression; ArrayInitializer; VariableInitializer
ArrayType: ArrayType; ReferenceType
Assignment: Assignment; AssignmentExpression; StatementExpression
AssignmentExpression: Assignment; AssignmentExpression; Expression
AssignmentOperator: Assignment; AssignmentOperator
'B': HexDigit
Block: Block; CatchClause; Finally; InstanceInitializer; MethodBody; StatementWithoutTrailingSubstatement; StaticInitializer; SynchronizedStatement; TryStatement
BlockStatement: BlockStatement; BlockStatements
BlockStatements: Block; BlockStatements; ConstructorBody; SwitchBlockStatementGroup
BooleanLiteral: BooleanLiteral; Identifier; Literal
BreakStatement: BreakStatement; StatementWithoutTrailingSubstatement
'C': HexDigit
? CR ?: InputCharacter
CastExpression: CastExpression; UnaryExpressionNotPlusMinus
CatchClause: CatchClause; Catches
Catches: Catches; TryStatement
CharacterLiteral: CharacterLiteral; Literal
CharactersInLine: CharactersInLine; EndOfLineComment
ClassBody: ClassBody; ClassDeclaration; ClassInstanceCreationExpression
ClassBodyDeclaration: ClassBodyDeclaration; ClassBodyDeclarations
ClassBodyDeclarations: ClassBody; ClassBodyDeclarations
ClassDeclaration: BlockStatement; ClassDeclaration; ClassMemberDeclaration; InterfaceMemberDeclaration; TypeDeclaration
ClassInstanceCreationExpression: ClassInstanceCreationExpression; PrimaryNoNewArray; StatementExpression
ClassMemberDeclaration: ClassBodyDeclaration; ClassMemberDeclaration
ClassModifier: ClassModifier; ClassModifiers
ClassModifiers: ClassDeclaration; ClassModifiers
ClassName: FieldAccess; MethodInvocation; PrimaryNoNewArray
ClassOrInterfaceType: ClassInstanceCreationExpression; ClassOrInterfaceType; ReferenceType
ClassType: ClassOrInterfaceType; ClassType; ClassTypeList; Super
ClassTypeList: ClassTypeList; Throws
Comment: Comment; InputElement
CommentTail: CommentTail; CommentTailStar; TraditionalComment
CommentTailStar: CommentTail; CommentTailStar
CompilationUnit: CompilationUnit
ConditionalAndExpression: ConditionalAndExpression; ConditionalOrExpression
ConditionalExpression: AssignmentExpression; ConditionalExpression
ConditionalOrExpression: ConditionalExpression; ConditionalOrExpression
ConstantDeclaration: ConstantDeclaration; InterfaceMemberDeclaration
ConstantExpression: ConstantExpression; SwitchLabel
ConstantModifier: ConstantModifier; ConstantModifiers
ConstantModifiers: ConstantDeclaration; ConstantModifiers
ConstructorBody: ConstructorBody; ConstructorDeclaration
ConstructorDeclaration: ClassBodyDeclaration; ConstructorDeclaration
ConstructorDeclarator: ConstructorDeclaration; ConstructorDeclarator
ConstructorModifier: ConstructorModifier; ConstructorModifiers
ConstructorModifiers: ConstructorDeclaration; ConstructorModifiers
ContinueStatement: ContinueStatement; StatementWithoutTrailingSubstatement
'D': FloatTypeSuffix; HexDigit
DecimalIntegerLiteral: DecimalIntegerLiteral; IntegerLiteral
DecimalNumeral: DecimalIntegerLiteral; DecimalNumeral
Digit: Digit; Digits
Digits: DecimalNumeral; Digits; FloatingPointLiteral; SignedInteger
DimExpr: DimExpr; DimExprs
DimExprs: ArrayCreationExpression; DimExprs
Dims: ArrayCreationExpression; CastExpression; Dims
DoStatement: DoStatement; StatementWithoutTrailingSubstatement
'E': ExponentIndicator; HexDigit
EmptyStatement: EmptyStatement; StatementWithoutTrailingSubstatement
EndOfLineComment: Comment; EndOfLineComment
EqualityExpression: AndExpression; EqualityExpression
EscapeSequence: CharacterLiteral; EscapeSequence; StringCharacter
ExclusiveOrExpression: ExclusiveOrExpression; InclusiveOrExpression
ExplicitConstructorInvocation: ConstructorBody; ExplicitConstructorInvocation
ExponentIndicator: ExponentIndicator; ExponentPart
ExponentPart: ExponentPart; FloatingPointLiteral
Expression: ArgumentList; ArrayAccess; ConditionalExpression; ConstantExpression; DimExpr; DoStatement; Expression; ForStatement; ForStatementNoShortIf; IfThenElseStatement; IfThenElseStatementNoShortIf; IfThenStatement; PrimaryNoNewArray; ReturnStatement; SwitchStatement; SynchronizedStatement; ThrowStatement; VariableInitializer; WhileStatement; WhileStatementNoShortIf
ExpressionName: ArrayAccess; ExpressionName; LeftHandSide; PostfixExpression
ExpressionStatement: ExpressionStatement; StatementWithoutTrailingSubstatement
ExtendsInterfaces: ExtendsInterfaces; InterfaceDeclaration
'F': FloatTypeSuffix; HexDigit
FieldAccess: FieldAccess; LeftHandSide; PrimaryNoNewArray
FieldDeclaration: ClassMemberDeclaration; FieldDeclaration
FieldModifier: FieldModifier; FieldModifiers
FieldModifiers: FieldDeclaration; FieldModifiers
Finally: Finally; TryStatement
FloatTypeSuffix: FloatTypeSuffix; FloatingPointLiteral
FloatingPointLiteral: FloatingPointLiteral; Literal
FloatingPointType: FloatingPointType; NumericType
ForInit: ForInit; ForStatement; ForStatementNoShortIf
ForStatement: ForStatement; Statement
ForStatementNoShortIf: ForStatementNoShortIf; StatementNoShortIf
ForUpdate: ForStatement; ForStatementNoShortIf; ForUpdate
FormalParameter: CatchClause; FormalParameter; FormalParameterList
FormalParameterList: ConstructorDeclarator; FormalParameterList; MethodDeclarator
HexDigit: HexDigit; HexDigits; UnicodeEscape
HexDigits: HexDigits; HexNumeral
HexIntegerLiteral: HexIntegerLiteral; IntegerLiteral
HexNumeral: HexIntegerLiteral; HexNumeral
Identifier: AmbiguousName; BreakStatement; ClassDeclaration; ClassInstanceCreationExpression; ContinueStatement; ExpressionName; FieldAccess; Identifier; InterfaceDeclaration; LabeledStatement; LabeledStatementNoShortIf; MethodDeclarator; MethodInvocation; MethodName; PackageName; PackageOrTypeName; Token; TypeName; VariableDeclaratorId
IdentifierChars: Identifier; IdentifierChars
IfThenElseStatement: IfThenElseStatement; Statement
IfThenElseStatementNoShortIf: IfThenElseStatementNoShortIf; StatementNoShortIf
IfThenStatement: IfThenStatement; Statement
ImportDeclaration: ImportDeclaration; ImportDeclarations
ImportDeclarations: CompilationUnit; ImportDeclarations
InclusiveOrExpression: ConditionalAndExpression; InclusiveOrExpression
Input: Input
InputCharacter: CharactersInLine; InputCharacter; NotStar; NotStarNotSlash; SingleCharacter; StringCharacter
InputElement: InputElement; InputElements
InputElements: Input; InputElements
InstanceInitializer: ClassBodyDeclaration; InstanceInitializer
IntegerLiteral: IntegerLiteral; Literal
IntegerTypeSuffix: DecimalIntegerLiteral; HexIntegerLiteral; IntegerTypeSuffix; OctalIntegerLiteral
IntegralType: IntegralType; NumericType
InterfaceBody: InterfaceBody; InterfaceDeclaration
InterfaceDeclaration: ClassMemberDeclaration; InterfaceDeclaration; InterfaceMemberDeclaration; TypeDeclaration
InterfaceMemberDeclaration: InterfaceMemberDeclaration; InterfaceMemberDeclarations
InterfaceMemberDeclarations: InterfaceBody; InterfaceMemberDeclarations
InterfaceModifier: InterfaceModifier; InterfaceModifiers
InterfaceModifiers: InterfaceDeclaration; InterfaceModifiers
InterfaceType: ClassOrInterfaceType; ExtendsInterfaces; InterfaceType; InterfaceTypeList
InterfaceTypeList: InterfaceTypeList; Interfaces
Interfaces: ClassDeclaration; Interfaces
JavaLetter: IdentifierChars; JavaLetter
JavaLetterOrDigit: IdentifierChars; JavaLetterOrDigit
Keyword: Identifier; Keyword; Token
'L': IntegerTypeSuffix
? LF ?: InputCharacter
LabeledStatement: LabeledStatement; Statement
LabeledStatementNoShortIf: LabeledStatementNoShortIf; StatementNoShortIf
LeftHandSide: Assignment; LeftHandSide
LineTerminator: EndOfLineComment; LineTerminator; NotStar; NotStarNotSlash; WhiteSpace
Literal: Literal; PrimaryNoNewArray; Token
LocalVariableDeclaration: ForInit; LocalVariableDeclaration; LocalVariableDeclarationStatement
LocalVariableDeclarationStatement: BlockStatement; LocalVariableDeclarationStatement
MethodBody: MethodBody; MethodDeclaration
MethodDeclaration: ClassMemberDeclaration; MethodDeclaration
MethodDeclarator: AbstractMethodDeclaration; MethodDeclarator; MethodHeader
MethodHeader: MethodDeclaration; MethodHeader
MethodInvocation: MethodInvocation; PrimaryNoNewArray; StatementExpression
MethodModifier: MethodModifier; MethodModifiers
MethodModifiers: MethodHeader; MethodModifiers
MethodName: MethodInvocation; MethodName
MultiplicativeExpression: AdditiveExpression; MultiplicativeExpression
NonZeroDigit: DecimalNumeral; Digit; NonZeroDigit
NotStar: CommentTail; NotStar; TraditionalComment
NotStarNotSlash: CommentTailStar; NotStarNotSlash
NullLiteral: Identifier; Literal; NullLiteral
NumericType: NumericType; PrimitiveType
OctalDigit: OctalDigit; OctalDigits; OctalEscape
OctalDigits: OctalDigits; OctalNumeral
OctalEscape: EscapeSequence; OctalEscape
OctalIntegerLiteral: IntegerLiteral; OctalIntegerLiteral
OctalNumeral: OctalIntegerLiteral; OctalNumeral
Operator: Operator; Token
PackageDeclaration: CompilationUnit; PackageDeclaration
PackageName: PackageDeclaration; PackageName
PackageOrTypeName: PackageOrTypeName; TypeImportOnDemandDeclaration; TypeName
PostDecrementExpression: PostDecrementExpression; PostfixExpression; StatementExpression
PostIncrementExpression: PostIncrementExpression; PostfixExpression; StatementExpression
PostfixExpression: PostDecrementExpression; PostIncrementExpression; PostfixExpression; UnaryExpressionNotPlusMinus
PreDecrementExpression: PreDecrementExpression; StatementExpression; UnaryExpression
PreIncrementExpression: PreIncrementExpression; StatementExpression; UnaryExpression
Primary: ClassInstanceCreationExpression; ExplicitConstructorInvocation; FieldAccess; MethodInvocation; PostfixExpression; Primary
PrimaryNoNewArray: ArrayAccess; Primary; PrimaryNoNewArray
PrimitiveType: ArrayCreationExpression; CastExpression; PrimitiveType; Type
RawInputCharacter: RawInputCharacter; UnicodeInputCharacter
ReferenceType: CastExpression; ReferenceType; RelationalExpression; Type
RelationalExpression: EqualityExpression; RelationalExpression
ResultType: AbstractMethodDeclaration; MethodHeader; ResultType
ReturnStatement: ReturnStatement; StatementWithoutTrailingSubstatement
Separator: Separator; Token
ShiftExpression: RelationalExpression; ShiftExpression
Sign: Sign; SignedInteger
SignedInteger: ExponentPart; SignedInteger
SimpleTypeName: ConstructorDeclarator
SingleCharacter: CharacterLiteral; SingleCharacter
SingleTypeImportDeclaration: ImportDeclaration; SingleTypeImportDeclaration
Statement: BlockStatement; DoStatement; ForStatement; IfThenElseStatement; IfThenStatement; LabeledStatement; Statement; WhileStatement
StatementExpression: ExpressionStatement; StatementExpression; StatementExpressionList
StatementExpressionList: ForInit; ForUpdate; StatementExpressionList
StatementNoShortIf: ForStatementNoShortIf; IfThenElseStatement; IfThenElseStatementNoShortIf; LabeledStatementNoShortIf; StatementNoShortIf; WhileStatementNoShortIf
StatementWithoutTrailingSubstatement: Statement; StatementNoShortIf; StatementWithoutTrailingSubstatement
StaticInitializer: ClassBodyDeclaration; StaticInitializer
StringCharacter: StringCharacter; StringCharacters
StringCharacters: StringCharacters; StringLiteral
StringLiteral: Literal; StringLiteral
Sub: Input; Sub
Super: ClassDeclaration; Super
SwitchBlock: SwitchBlock; SwitchStatement
SwitchBlockStatementGroup: SwitchBlockStatementGroup; SwitchBlockStatementGroups
SwitchBlockStatementGroups: SwitchBlock; SwitchBlockStatementGroups
SwitchLabel: SwitchLabel; SwitchLabels
SwitchLabels: SwitchBlock; SwitchBlockStatementGroup; SwitchLabels
SwitchStatement: StatementWithoutTrailingSubstatement; SwitchStatement
SynchronizedStatement: StatementWithoutTrailingSubstatement; SynchronizedStatement
ThrowStatement: StatementWithoutTrailingSubstatement; ThrowStatement
Throws: AbstractMethodDeclaration; ConstructorDeclaration; MethodHeader; Throws
Token: InputElement; Token
TraditionalComment: Comment; TraditionalComment
TryStatement: StatementWithoutTrailingSubstatement; TryStatement
Type: ArrayType; ConstantDeclaration; FieldDeclaration; FormalParameter; LocalVariableDeclaration; PrimaryNoNewArray; ResultType; Type
TypeDeclaration: TypeDeclaration; TypeDeclarations
TypeDeclarations: CompilationUnit; TypeDeclarations
TypeImportOnDemandDeclaration: ImportDeclaration; TypeImportOnDemandDeclaration
TypeName: ArrayCreationExpression; ClassType; InterfaceType; SingleTypeImportDeclaration; TypeName
UnaryExpression: CastExpression; MultiplicativeExpression; PreDecrementExpression; PreIncrementExpression; UnaryExpression; UnaryExpressionNotPlusMinus
UnaryExpressionNotPlusMinus: CastExpression; UnaryExpression; UnaryExpressionNotPlusMinus
UnicodeEscape: UnicodeEscape; UnicodeInputCharacter
UnicodeInputCharacter: InputCharacter; UnicodeInputCharacter
UnicodeMarker: UnicodeEscape; UnicodeMarker
VariableDeclarator: VariableDeclarator; VariableDeclarators
VariableDeclaratorId: FormalParameter; VariableDeclarator; VariableDeclaratorId
VariableDeclarators: ConstantDeclaration; FieldDeclaration; LocalVariableDeclaration; VariableDeclarators
VariableInitializer: VariableDeclarator; VariableInitializer; VariableInitializers
VariableInitializers: ArrayInitializer; VariableInitializers
WhileStatement: Statement; WhileStatement
WhileStatementNoShortIf: StatementNoShortIf; WhileStatementNoShortIf
WhiteSpace: InputElement; WhiteSpace
'X': HexNumeral
ZeroToThree: OctalEscape; ZeroToThree
'[': ArrayAccess; ArrayType; DimExpr; Dims; MethodDeclarator; Separator; VariableDeclaratorId
'\': EscapeSequence; OctalEscape; SingleCharacter; StringCharacter; UnicodeEscape
']': ArrayAccess; ArrayType; DimExpr; Dims; MethodDeclarator; Separator; VariableDeclaratorId
'^': ExclusiveOrExpression; Operator
'^=': AssignmentOperator; Operator
'a': HexDigit
'abstract': AbstractMethodModifier; ClassModifier; InterfaceModifier; Keyword; MethodModifier
? any Unicode character that is a Java letter ?: JavaLetter
? any Unicode character that is a Java letter-or-digit ?: JavaLetterOrDigit
? any Unicode character ?: RawInputCharacter
'b': EscapeSequence; HexDigit
'boolean': Keyword; PrimitiveType
'break': BreakStatement; Keyword
'byte': IntegralType; Keyword
'c': HexDigit
'case': Keyword; SwitchLabel
'catch': CatchClause; Keyword
'char': IntegralType; Keyword
'class': ClassDeclaration; Keyword; PrimaryNoNewArray
'const': Keyword
'continue': ContinueStatement; Keyword
'd': FloatTypeSuffix; HexDigit
'default': Keyword; SwitchLabel
'do': DoStatement; Keyword
'double': FloatingPointType; Keyword
'e': ExponentIndicator; HexDigit
'else': IfThenElseStatement; IfThenElseStatementNoShortIf; Keyword
'extends': ExtendsInterfaces; Keyword; Super
'f': EscapeSequence; FloatTypeSuffix; HexDigit
'false': BooleanLiteral
'final': ClassModifier; ConstantModifier; FieldModifier; FormalParameter; Keyword; LocalVariableDeclaration; MethodModifier
'finally': Finally; Keyword
'float': FloatingPointType; Keyword
'for': ForStatement; ForStatementNoShortIf; Keyword
'goto': Keyword
'if': IfThenElseStatement; IfThenElseStatementNoShortIf; IfThenStatement; Keyword
'implements': Interfaces; Keyword
'import': Keyword; SingleTypeImportDeclaration; TypeImportOnDemandDeclaration
'instanceof': Keyword; RelationalExpression
'int': IntegralType; Keyword
'interface': InterfaceDeclaration; Keyword
'l': IntegerTypeSuffix
'long': IntegralType; Keyword
'n': EscapeSequence
'native': Keyword; MethodModifier
'new': ArrayCreationExpression; ClassInstanceCreationExpression; Keyword
'null': NullLiteral
'package': Keyword; PackageDeclaration
'private': ClassModifier; ConstructorModifier; FieldModifier; InterfaceModifier; Keyword; MethodModifier
'protected': ClassModifier; ConstructorModifier; FieldModifier; InterfaceModifier; Keyword; MethodModifier
'public': AbstractMethodModifier; ClassModifier; ConstantModifier; ConstructorModifier; FieldModifier; InterfaceModifier; Keyword; MethodModifier
'r': EscapeSequence
'return': Keyword; ReturnStatement
'short': IntegralType; Keyword
'static': ClassModifier; ConstantModifier; FieldModifier; InterfaceModifier; Keyword; MethodModifier; StaticInitializer
'strictfp': ClassModifier; InterfaceModifier; Keyword; MethodModifier
'super': ExplicitConstructorInvocation; FieldAccess; Keyword; MethodInvocation
'switch': Keyword; SwitchStatement
'synchronized': Keyword; MethodModifier; SynchronizedStatement
't': EscapeSequence
? the ASCII CR character followed by the ASCII LF character ?: LineTerminator
? the ASCII CR character, also known as "return" ?: LineTerminator
? the ASCII FF character, also known as "form feed" ?: WhiteSpace
? the ASCII HT character, also known as "horizontal tab" ?: WhiteSpace
? the ASCII LF character, also known as "newline" ?: LineTerminator
? the ASCII SP character, also known as "space" ?: WhiteSpace
? the ASCII SUB character, also known as "control-Z" ?: Sub
'this': ExplicitConstructorInvocation; Keyword; PrimaryNoNewArray
'throw': Keyword; ThrowStatement
'throws': Keyword; Throws
'transient': FieldModifier; Keyword
'true': BooleanLiteral
'try': Keyword; TryStatement
'u': UnicodeMarker
'void': Keyword; PrimaryNoNewArray; ResultType
'volatile': FieldModifier; Keyword
'while': DoStatement; Keyword; WhileStatement; WhileStatementNoShortIf
'x': HexNumeral
'{': ArrayInitializer; Block; ClassBody; ConstructorBody; InterfaceBody; Separator; SwitchBlock
'|': InclusiveOrExpression; Operator
'|=': AssignmentOperator; Operator
'||': ConditionalOrExpression; Operator
'}': ArrayInitializer; Block; ClassBody; ConstructorBody; InterfaceBody; Separator; SwitchBlock
'~': Operator; UnaryExpressionNotPlusMinus

References

ISO/IEC. (1996). ISO/IEC 14977 : 1996(E). ISO/IEC. Retrieved Saturday, March 26, 2005 from http://www.cl.cam.ac.uk/~mgk25/iso-ebnf.html.
JLS2. (2000). The Java Language Specification, Second Edition. California: Sun Microsystems, Inc. Retrieved Monday, Monday, April 04, 2005 from http://java.sun.com/docs/books/jls/.

The Java JLS3 Grammar

noreply@blogger.com (Gaute Lykkenborg) — Tue, 21 Feb 2012 18:26:00 +0000

This is the formal syntax of Java (JLS3 2005). The grammar is written in ISO/IEC 14977 EBNF notation (ISO/IEC 1996).

Grammar | The goal symbol Input | The goal symbol CompilationUnit | Index

UnicodeInputCharacter =: UnicodeEscape | RawInputCharacter ;
UnicodeEscape =: '\', UnicodeMarker, HexDigit, HexDigit, HexDigit, HexDigit ;
UnicodeMarker =: 'u' | UnicodeMarker, 'u' ;
RawInputCharacter =: ? any Unicode character ? ;
HexDigit =: '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' | 'a' | 'b' | 'c' | 'd' | 'e' | 'f' | 'A' | 'B' | 'C' | 'D' | 'E' | 'F' ;
LineTerminator =: ? the ASCII LF character, also known as "newline" ? | ? the ASCII CR character, also known as "return" ? | ? the ASCII CR character followed by the ASCII LF character ? ;
InputCharacter =: UnicodeInputCharacter - (? CR ? | ? LF ?) ;
Input =: [InputElements], [Sub] ;
InputElements =: InputElement | InputElements, InputElement ;
InputElement =: WhiteSpace | Comment | Token ;
Token =: Identifier | Keyword | Literal | Separator | Operator ;
Sub =: ? the ASCII SUB character, also known as "control-Z" ? ;
WhiteSpace =: ? the ASCII SP character, also known as "space" ? | ? the ASCII HT character, also known as "horizontal tab" ? | ? the ASCII FF character, also known as "form feed" ? | LineTerminator ;
Comment =: TraditionalComment | EndOfLineComment ;
TraditionalComment =: '/', '*', CommentTail ;
EndOfLineComment =: '/', '/', [CharactersInLine] ;
CommentTail =: '*', CommentTailStar | NotStar, CommentTail ;
CommentTailStar =: '/' | '*', CommentTailStar | NotStarNotSlash, CommentTail ;
NotStar =: InputCharacter - '*' | LineTerminator ;
NotStarNotSlash =: InputCharacter - ('*' | '/') | LineTerminator ;
CharactersInLine =: InputCharacter | CharactersInLine, InputCharacter ;
Identifier =: IdentifierChars - (Keyword | BooleanLiteral | NullLiteral) ;
IdentifierChars =: JavaLetter | IdentifierChars, JavaLetterOrDigit ;
JavaLetter =: ? any Unicode character that is a Java letter ? ;
JavaLetterOrDigit =: ? any Unicode character that is a Java letter-or-digit ? ;
Keyword =: 'abstract' | 'assert' | 'boolean' | 'break' | 'byte' | 'case' | 'catch' | 'char' | 'class' | 'const' | 'continue' | 'default' | 'do' | 'double' | 'else' | 'enum' | 'extends' | 'final' | 'finally' | 'float' | 'for' | 'goto' | 'if' | 'implements' | 'import' | 'instanceof' | 'int' | 'interface' | 'long' | 'native' | 'new' | 'package' | 'private' | 'protected' | 'public' | 'return' | 'short' | 'static' | 'strictfp' | 'super' | 'switch' | 'synchronized' | 'this' | 'throw' | 'throws' | 'transient' | 'try' | 'void' | 'volatile' | 'while' ;
Literal =: IntegerLiteral | FloatingPointLiteral | BooleanLiteral | CharacterLiteral | StringLiteral | NullLiteral ;
IntegerLiteral =: DecimalIntegerLiteral | HexIntegerLiteral | OctalIntegerLiteral ;
DecimalIntegerLiteral =: DecimalNumeral, [IntegerTypeSuffix] ;
HexIntegerLiteral =: HexNumeral, [IntegerTypeSuffix] ;
OctalIntegerLiteral =: OctalNumeral, [IntegerTypeSuffix] ;
IntegerTypeSuffix =: 'l' | 'L' ;
DecimalNumeral =: '0' | NonZeroDigit, [Digits] ;
Digits =: Digit | Digits, Digit ;
Digit =: '0' | NonZeroDigit ;
NonZeroDigit =: '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' ;
HexNumeral =: '0', 'x', HexDigits | '0', 'X', HexDigits ;
HexDigits =: HexDigit | HexDigit, HexDigits ;
OctalNumeral =: '0', OctalDigits ;
OctalDigits =: OctalDigit | OctalDigit, OctalDigits ;
OctalDigit =: '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' ;
FloatingPointLiteral =: DecimalFloatingPointLiteral | HexadecimalFloatingPointLiteral ;
DecimalFloatingPointLiteral =: Digits, '.', [Digits], [ExponentPart], [FloatTypeSuffix] | '.', Digits, [ExponentPart], [FloatTypeSuffix] | Digits, ExponentPart, [FloatTypeSuffix] | Digits, [ExponentPart], FloatTypeSuffix ;
ExponentPart =: ExponentIndicator, SignedInteger ;
ExponentIndicator =: 'e' | 'E' ;
SignedInteger =: [Sign], Digits ;
Sign =: '+' | '-' ;
FloatTypeSuffix =: 'f' | 'F' | 'd' | 'D' ;
HexadecimalFloatingPointLiteral =: HexSignificand, BinaryExponent, [FloatTypeSuffix] ;
HexSignificand =: HexNumeral | HexNumeral, '.' | '0x', [HexDigits], '.', HexDigits | '0X', [HexDigits], '.', HexDigits ;
BinaryExponent =: BinaryExponentIndicator, SignedInteger ;
BinaryExponentIndicator =: 'p' | 'P' ;
BooleanLiteral =: 'true' | 'false' ;
CharacterLiteral =: "'", SingleCharacter, "'" | "'", EscapeSequence, "'" ;
SingleCharacter =: InputCharacter - ("'" | '\') ;
StringLiteral =: '"', [StringCharacters], '"' ;
StringCharacters =: StringCharacter | StringCharacters, StringCharacter ;
StringCharacter =: InputCharacter - ('"' | '\') | EscapeSequence ;
EscapeSequence =: '\', 'b' | '\', 't' | '\', 'n' | '\', 'f' | '\', 'r' | '\', '"' | '\', "'" | '\', '\' | OctalEscape ;
OctalEscape =: '\', OctalDigit | '\', OctalDigit, OctalDigit | '\', ZeroToThree, OctalDigit, OctalDigit ;
ZeroToThree =: '0' | '1' | '2' | '3' ;
NullLiteral =: 'null' ;
Separator =: '(' | ')' | '{' | '}' | '[' | ']' | ';' | ',' | '.' ;
Operator =: '=' | '>' | '<' | '!' | '~' | '?' | ':' | '==' | '<=' | '>=' | '!=' | '&&' | '||' | '++' | '--' | '+' | '-' | '*' | '/' | '&' | '|' | '^' | '%' | '<<' | '>>' | '>>>' | '+=' | '-=' | '*=' | '/=' | '&=' | '|=' | '^=' | '%=' | '<<=' | '>>=' | '>>>=' ;
Type =: PrimitiveType | ReferenceType ;
PrimitiveType =: NumericType | 'boolean' ;
NumericType =: IntegralType | FloatingPointType ;
IntegralType =: 'byte' | 'short' | 'int' | 'long' | 'char' ;
FloatingPointType =: 'float' | 'double' ;
ReferenceType =: ClassOrInterfaceType | TypeVariable | ArrayType ;
ClassOrInterfaceType =: ClassType | InterfaceType ;
ClassType =: TypeDeclSpecifier, [TypeArguments] ;
InterfaceType =: TypeDeclSpecifier, [TypeArguments] ;
TypeDeclSpecifier =: TypeName | ClassOrInterfaceType, '.', Identifier ;
TypeName =: Identifier | (TypeName | PackageOrTypeName), '.', Identifier ;
TypeVariable =: Identifier ;
ArrayType =: Type, '[', ']' ;
TypeParameter =: TypeVariable, [TypeBound] ;
TypeBound =: 'extends', ClassOrInterfaceType, [AdditionalBoundList] ;
AdditionalBoundList =: AdditionalBound, AdditionalBoundList | AdditionalBound ;
AdditionalBound =: '&', InterfaceType ;
TypeArguments =: '<', ActualTypeArgumentList, '>' ;
ActualTypeArgumentList =: ActualTypeArgument | ActualTypeArgumentList, ',', ActualTypeArgument ;
ActualTypeArgument =: ReferenceType | Wildcard ;
Wildcard =: '?', [WildcardBounds] ;
WildcardBounds =: 'extends', ReferenceType | 'super', ReferenceType ;
PackageName =: Identifier | PackageName, '.', Identifier ;
ExpressionName =: Identifier | AmbiguousName, '.', Identifier ;
MethodName =: Identifier | AmbiguousName, '.', Identifier ;
PackageOrTypeName =: Identifier | PackageOrTypeName, '.', Identifier ;
AmbiguousName =: Identifier | AmbiguousName, '.', Identifier ;
CompilationUnit =: [PackageDeclaration], [ImportDeclarations], [TypeDeclarations] ;
ImportDeclarations =: ImportDeclaration | ImportDeclarations, ImportDeclaration ;
TypeDeclarations =: TypeDeclaration | TypeDeclarations, TypeDeclaration ;
PackageDeclaration =: [Annotations], 'package', PackageName, ';' ;
ImportDeclaration =: SingleTypeImportDeclaration | TypeImportOnDemandDeclaration | SingleStaticImportDeclaration | StaticImportOnDemandDeclaration ;
SingleTypeImportDeclaration =: 'import', TypeName, ';' ;
TypeImportOnDemandDeclaration =: 'import', PackageOrTypeName, '.', '*', ';' ;
SingleStaticImportDeclaration =: 'import', 'static', TypeName, '.', Identifier, ';' ;
StaticImportOnDemandDeclaration =: 'import', 'static', TypeName, '.', '*', ';' ;
TypeDeclaration =: ClassDeclaration | InterfaceDeclaration | ';' ;
ClassDeclaration =: NormalClassDeclaration | EnumDeclaration ;
NormalClassDeclaration =: [ClassModifiers], 'class', Identifier, [TypeParameters], [Super], [Interfaces], ClassBody ;
ClassModifiers =: ClassModifier | ClassModifiers, ClassModifier ;
ClassModifier =: Annotation | 'public' | 'protected' | 'private' | 'abstract' | 'static' | 'final' | 'strictfp' ;
TypeParameters =: '<', TypeParameterList, '>' ;
TypeParameterList =: TypeParameterList, ',', TypeParameter | TypeParameter ;
Super =: 'extends', ClassType ;
Interfaces =: 'implements', InterfaceTypeList ;
InterfaceTypeList =: InterfaceType | InterfaceTypeList, ',', InterfaceType ;
ClassBody =: '{', [ClassBodyDeclarations], '}' ;
ClassBodyDeclarations =: ClassBodyDeclaration | ClassBodyDeclarations, ClassBodyDeclaration ;
ClassBodyDeclaration =: ClassMemberDeclaration | InstanceInitializer | StaticInitializer | ConstructorDeclaration ;
ClassMemberDeclaration =: FieldDeclaration | MethodDeclaration | ClassDeclaration | InterfaceDeclaration | ';' ;
FieldDeclaration =: [FieldModifiers], Type, VariableDeclarators, ';' ;
VariableDeclarators =: VariableDeclarator | VariableDeclarators, ',', VariableDeclarator ;
VariableDeclarator =: VariableDeclaratorId | VariableDeclaratorId, '=', VariableInitializer ;
VariableDeclaratorId =: Identifier | VariableDeclaratorId, '[', ']' ;
VariableInitializer =: Expression | ArrayInitializer ;
FieldModifiers =: FieldModifier | FieldModifiers, FieldModifier ;
FieldModifier =: Annotation | 'public' | 'protected' | 'private' | 'static' | 'final' | 'transient' | 'volatile' ;
MethodDeclaration =: MethodHeader, MethodBody ;
MethodHeader =: [MethodModifiers], [TypeParameters], ResultType, MethodDeclarator, [Throws] ;
ResultType =: Type | 'void' ;
MethodDeclarator =: Identifier, '(', [FormalParameterList], ')' | MethodDeclarator, '[', ']' ;
FormalParameterList =: LastFormalParameter | FormalParameters, ',', LastFormalParameter ;
FormalParameters =: FormalParameter | FormalParameters, ',', FormalParameter ;
FormalParameter =: VariableModifiers, Type, VariableDeclaratorId ;
VariableModifiers =: VariableModifier | VariableModifiers, VariableModifier ;
VariableModifier =: 'final' | Annotation ;
LastFormalParameter =: VariableModifiers, Type, ['...'], VariableDeclaratorId ;
MethodModifiers =: MethodModifier | MethodModifiers, MethodModifier ;
MethodModifier =: Annotation | 'public' | 'protected' | 'private' | 'abstract' | 'static' | 'final' | 'synchronized' | 'native' | 'strictfp' ;
Throws =: 'throws', ExceptionTypeList ;
ExceptionTypeList =: ExceptionType | ExceptionTypeList, ',', ExceptionType ;
ExceptionType =: ClassType | TypeVariable ;
MethodBody =: Block | ';' ;
InstanceInitializer =: Block ;
StaticInitializer =: 'static', Block ;
ConstructorDeclaration =: [ConstructorModifiers], ConstructorDeclarator, [Throws], ConstructorBody ;
ConstructorDeclarator =: [TypeParameters], Identifier, '(', [FormalParameterList], ')' ;
ConstructorModifiers =: ConstructorModifier | ConstructorModifiers, ConstructorModifier ;
ConstructorModifier =: Annotation | 'public' | 'protected' | 'private' ;
ConstructorBody =: '{', [ExplicitConstructorInvocation], [BlockStatements], '}' ;
ExplicitConstructorInvocation =: [NonWildTypeArguments], 'this', '(', [ArgumentList], ')', ';' | [NonWildTypeArguments], 'super', '(', [ArgumentList], ')', ';' | Primary, '.', [NonWildTypeArguments], 'super', '(', [ArgumentList], ')', ';' ;
NonWildTypeArguments =: '<', ReferenceTypeList, '>' ;
ReferenceTypeList =: ReferenceType | ReferenceTypeList, ',', ReferenceType ;
EnumDeclaration =: [ClassModifiers], 'enum', Identifier, [Interfaces], EnumBody ;
EnumBody =: '{', [EnumConstants], [','], [EnumBodyDeclarations], '}' ;
EnumConstants =: EnumConstant | EnumConstants, ',', EnumConstant ;
EnumConstant =: Annotations, Identifier, [Arguments], [ClassBody] ;
Arguments =: '(', [ArgumentList], ')' ;
EnumBodyDeclarations =: ';', [ClassBodyDeclarations] ;
InterfaceDeclaration =: NormalInterfaceDeclaration | AnnotationTypeDeclaration ;
NormalInterfaceDeclaration =: [InterfaceModifiers], 'interface', Identifier, [TypeParameters], [ExtendsInterfaces], InterfaceBody ;
InterfaceModifiers =: InterfaceModifier | InterfaceModifiers, InterfaceModifier ;
InterfaceModifier =: Annotation | 'public' | 'protected' | 'private' | 'abstract' | 'static' | 'strictfp' ;
ExtendsInterfaces =: 'extends', InterfaceType | ExtendsInterfaces, ',', InterfaceType ;
InterfaceBody =: '{', [InterfaceMemberDeclarations], '}' ;
InterfaceMemberDeclarations =: InterfaceMemberDeclaration | InterfaceMemberDeclarations, InterfaceMemberDeclaration ;
InterfaceMemberDeclaration =: ConstantDeclaration | AbstractMethodDeclaration | ClassDeclaration | InterfaceDeclaration | ';' ;
ConstantDeclaration =: [ConstantModifiers], Type, VariableDeclarators, ';' ;
ConstantModifiers =: ConstantModifier | ConstantModifier, ConstantModifiers ;
ConstantModifier =: Annotation | 'public' | 'static' | 'final' ;
AbstractMethodDeclaration =: [AbstractMethodModifiers], [TypeParameters], ResultType, MethodDeclarator, [Throws], ';' ;
AbstractMethodModifiers =: AbstractMethodModifier | AbstractMethodModifiers, AbstractMethodModifier ;
AbstractMethodModifier =: Annotation, 'public', 'abstract' ;
AnnotationTypeDeclaration =: [InterfaceModifiers], '@', 'interface', Identifier, AnnotationTypeBody ;
AnnotationTypeBody =: '{', [AnnotationTypeElementDeclarations], '}' ;
AnnotationTypeElementDeclarations =: AnnotationTypeElementDeclaration | AnnotationTypeElementDeclarations, AnnotationTypeElementDeclaration ;
AnnotationTypeElementDeclaration =: [AbstractMethodModifiers], Type, Identifier, '(', ')', [DefaultValue], ';' | ConstantDeclaration | ClassDeclaration | InterfaceDeclaration | EnumDeclaration | AnnotationTypeDeclaration | ';' ;
DefaultValue =: 'default', ElementValue ;
Annotations =: Annotation | Annotations, Annotation ;
Annotation =: NormalAnnotation | MarkerAnnotation | SingleElementAnnotation ;
NormalAnnotation =: '@', TypeName, '(', [ElementValuePairs], ')' ;
ElementValuePairs =: ElementValuePair | ElementValuePairs, ',', ElementValuePair ;
ElementValuePair =: Identifier, '=', ElementValue ;
ElementValue =: ConditionalExpression | Annotation | ElementValueArrayInitializer ;
ElementValueArrayInitializer =: '{', [ElementValues], [','], '}' ;
ElementValues =: ElementValue | ElementValues, ',', ElementValue ;
MarkerAnnotation =: '@', TypeName ;
SingleElementAnnotation =: '@', TypeName, '(', ElementValue, ')' ;
ArrayInitializer =: '{', [VariableInitializers], [','], '}' ;
VariableInitializers =: VariableInitializer | VariableInitializers, ',', VariableInitializer ;
Block =: '{', [BlockStatements], '}' ;
BlockStatements =: BlockStatement | BlockStatements, BlockStatement ;
BlockStatement =: LocalVariableDeclarationStatement | ClassDeclaration | Statement ;
LocalVariableDeclarationStatement =: LocalVariableDeclaration, ';' ;
LocalVariableDeclaration =: VariableModifiers, Type, VariableDeclarators ;
Statement =: StatementWithoutTrailingSubstatement | LabeledStatement | IfThenStatement | IfThenElseStatement | WhileStatement | ForStatement ;
StatementWithoutTrailingSubstatement =: Block | EmptyStatement | ExpressionStatement | AssertStatement | SwitchStatement | DoStatement | BreakStatement | ContinueStatement | ReturnStatement | SynchronizedStatement | ThrowStatement | TryStatement ;
StatementNoShortIf =: StatementWithoutTrailingSubstatement | LabeledStatementNoShortIf | IfThenElseStatementNoShortIf | WhileStatementNoShortIf | ForStatementNoShortIf ;
EmptyStatement =: ';' ;
LabeledStatement =: Identifier, ':', Statement ;
LabeledStatementNoShortIf =: Identifier, ':', StatementNoShortIf ;
ExpressionStatement =: StatementExpression, ';' ;
StatementExpression =: Assignment | PreIncrementExpression | PreDecrementExpression | PostIncrementExpression | PostDecrementExpression | MethodInvocation | ClassInstanceCreationExpression ;
IfThenStatement =: 'if', '(', Expression, ')', Statement ;
IfThenElseStatement =: 'if', '(', Expression, ')', StatementNoShortIf, 'else', Statement ;
IfThenElseStatementNoShortIf =: 'if', '(', Expression, ')', StatementNoShortIf, 'else', StatementNoShortIf ;
AssertStatement =: 'assert', Expression, ';' | 'assert', Expression, ':', Expression, ';' ;
SwitchStatement =: 'switch', '(', Expression, ')', SwitchBlock ;
SwitchBlock =: '{', [SwitchBlockStatementGroups], [SwitchLabels], '}' ;
SwitchBlockStatementGroups =: SwitchBlockStatementGroup | SwitchBlockStatementGroups, SwitchBlockStatementGroup ;
SwitchBlockStatementGroup =: SwitchLabels, BlockStatements ;
SwitchLabels =: SwitchLabel | SwitchLabels, SwitchLabel ;
SwitchLabel =: 'case', ConstantExpression, ':' | 'case', EnumConstantName, ':' | 'default', ':' ;
EnumConstantName =: Identifier ;
WhileStatement =: 'while', '(', Expression, ')', Statement ;
WhileStatementNoShortIf =: 'while', '(', Expression, ')', StatementNoShortIf ;
DoStatement =: 'do', Statement, 'while', '(', Expression, ')', ';' ;
ForStatement =: BasicForStatement | EnhancedForStatement ;
BasicForStatement =: 'for', '(', [ForInit], ';', [Expression], ';', [ForUpdate], ')', Statement ;
ForStatementNoShortIf =: 'for', '(', [ForInit], ';', [Expression], ';', [ForUpdate], ')', StatementNoShortIf ;
ForInit =: StatementExpressionList | LocalVariableDeclaration ;
ForUpdate =: StatementExpressionList ;
StatementExpressionList =: StatementExpression | StatementExpressionList, ',', StatementExpression ;
EnhancedForStatement =: 'for', '(', [VariableModifiers], Type, Identifier, ':', Expression, ')', Statement ;
BreakStatement =: 'break', [Identifier], ';' ;
ContinueStatement =: 'continue', [Identifier], ';' ;
ReturnStatement =: 'return', [Expression], ';' ;
ThrowStatement =: 'throw', Expression, ';' ;
SynchronizedStatement =: 'synchronized', '(', Expression, ')', Block ;
TryStatement =: 'try', Block, Catches | 'try', Block, [Catches], Finally ;
Catches =: CatchClause | Catches, CatchClause ;
CatchClause =: 'catch', '(', FormalParameter, ')', Block ;
Finally =: 'finally', Block ;
Primary =: PrimaryNoNewArray | ArrayCreationExpression ;
PrimaryNoNewArray =: Literal | Type, '.', 'class' | 'void', '.', 'class' | 'this' | ClassName, '.', 'this' | '(', Expression, ')' | ClassInstanceCreationExpression | FieldAccess | MethodInvocation | ArrayAccess ;
ClassInstanceCreationExpression =: 'new', [TypeArguments], ClassOrInterfaceType, '(', [ArgumentList], ')', [ClassBody] | Primary, '.', 'new', [TypeArguments], Identifier, [TypeArguments], '(', [ArgumentList], ')', [ClassBody] ;
ArgumentList =: Expression | ArgumentList, ',', Expression ;
ArrayCreationExpression =: 'new', PrimitiveType, DimExprs, [Dims] | 'new', ClassOrInterfaceType, DimExprs, [Dims] | 'new', PrimitiveType, Dims, ArrayInitializer | 'new', ClassOrInterfaceType, Dims, ArrayInitializer ;
DimExprs =: DimExpr | DimExprs, DimExpr ;
DimExpr =: '[', Expression, ']' ;
Dims =: '[', ']' | Dims, '[', ']' ;
FieldAccess =: Primary, '.', Identifier | 'super', '.', Identifier | ClassName, '.', 'super', '.', Identifier ;
MethodInvocation =: MethodName, '(', [ArgumentList], ')' | Primary, '.', [NonWildTypeArguments], Identifier, '(', [ArgumentList], ')' | 'super', '.', [NonWildTypeArguments], Identifier, '(', [ArgumentList], ')' | ClassName, '.', 'super', '.', [NonWildTypeArguments], Identifier, '(', [ArgumentList], ')' | TypeName, '.', [NonWildTypeArguments], Identifier, '(', [ArgumentList], ')' ;
ArrayAccess =: ExpressionName, '[', Expression, ']' | PrimaryNoNewArray, '[', Expression, ']' ;
PostfixExpression =: Primary | ExpressionName | PostIncrementExpression | PostDecrementExpression ;
PostIncrementExpression =: PostfixExpression, '++' ;
PostDecrementExpression =: PostfixExpression, '--' ;
UnaryExpression =: PreIncrementExpression | PreDecrementExpression | '+', UnaryExpression | '-', UnaryExpression | UnaryExpressionNotPlusMinus ;
PreIncrementExpression =: '++', UnaryExpression ;
PreDecrementExpression =: '--', UnaryExpression ;
UnaryExpressionNotPlusMinus =: PostfixExpression | '~', UnaryExpression | '!', UnaryExpression | CastExpression ;
CastExpression =: '(', PrimitiveType, [Dims], ')', UnaryExpression | '(', ReferenceType, ')', UnaryExpressionNotPlusMinus ;
MultiplicativeExpression =: UnaryExpression | MultiplicativeExpression, '*', UnaryExpression | MultiplicativeExpression, '/', UnaryExpression | MultiplicativeExpression, '%', UnaryExpression ;
AdditiveExpression =: MultiplicativeExpression | AdditiveExpression, '+', MultiplicativeExpression | AdditiveExpression, '-', MultiplicativeExpression ;
ShiftExpression =: AdditiveExpression | ShiftExpression, '<<', AdditiveExpression | ShiftExpression, '>>', AdditiveExpression | ShiftExpression, '>>>', AdditiveExpression ;
RelationalExpression =: ShiftExpression | RelationalExpression, '<', ShiftExpression | RelationalExpression, '>', ShiftExpression | RelationalExpression, '<=', ShiftExpression | RelationalExpression, '>=', ShiftExpression | RelationalExpression, 'instanceof', ReferenceType ;
EqualityExpression =: RelationalExpression | EqualityExpression, '==', RelationalExpression | EqualityExpression, '!=', RelationalExpression ;
AndExpression =: EqualityExpression | AndExpression, '&', EqualityExpression ;
ExclusiveOrExpression =: AndExpression | ExclusiveOrExpression, '^', AndExpression ;
InclusiveOrExpression =: ExclusiveOrExpression | InclusiveOrExpression, '|', ExclusiveOrExpression ;
ConditionalAndExpression =: InclusiveOrExpression | ConditionalAndExpression, '&&', InclusiveOrExpression ;
ConditionalOrExpression =: ConditionalAndExpression | ConditionalOrExpression, '||', ConditionalAndExpression ;
ConditionalExpression =: ConditionalOrExpression | ConditionalOrExpression, '?', Expression, ':', ConditionalExpression ;
AssignmentExpression =: ConditionalExpression | Assignment ;
Assignment =: LeftHandSide, AssignmentOperator, AssignmentExpression ;
LeftHandSide =: ExpressionName | FieldAccess | ArrayAccess ;
AssignmentOperator =: '=' | '*=' | '/=' | '%=' | '+=' | '-=' | '<<=' | '>>=' | '>>>=' | '&=' | '^=' | '|=' ;
Expression =: AssignmentExpression ;
ConstantExpression =: Expression ;

'!': Operator; UnaryExpressionNotPlusMinus
'!=': EqualityExpression; Operator
'%': MultiplicativeExpression; Operator
'%=': AssignmentOperator; Operator
'&': AdditionalBound; AndExpression; Operator
'&&': ConditionalAndExpression; Operator
'&=': AssignmentOperator; Operator
'>': NonWildTypeArguments; Operator; RelationalExpression; TypeArguments; TypeParameters
'>>': Operator; ShiftExpression
'>>>': Operator; ShiftExpression
'>>>=': AssignmentOperator; Operator
'>>=': AssignmentOperator; Operator
'>=': Operator; RelationalExpression
'<': NonWildTypeArguments; Operator; RelationalExpression; TypeArguments; TypeParameters
'<<': Operator; ShiftExpression
'<<=': AssignmentOperator; Operator
'<=': Operator; RelationalExpression
"'": CharacterLiteral; EscapeSequence; SingleCharacter
'(': AnnotationTypeElementDeclaration; Arguments; BasicForStatement; CastExpression; CatchClause; ClassInstanceCreationExpression; ConstructorDeclarator; DoStatement; EnhancedForStatement; ExplicitConstructorInvocation; ForStatementNoShortIf; IfThenElseStatement; IfThenElseStatementNoShortIf; IfThenStatement; MethodDeclarator; MethodInvocation; NormalAnnotation; PrimaryNoNewArray; Separator; SingleElementAnnotation; SwitchStatement; SynchronizedStatement; WhileStatement; WhileStatementNoShortIf
')': AnnotationTypeElementDeclaration; Arguments; BasicForStatement; CastExpression; CatchClause; ClassInstanceCreationExpression; ConstructorDeclarator; DoStatement; EnhancedForStatement; ExplicitConstructorInvocation; ForStatementNoShortIf; IfThenElseStatement; IfThenElseStatementNoShortIf; IfThenStatement; MethodDeclarator; MethodInvocation; NormalAnnotation; PrimaryNoNewArray; Separator; SingleElementAnnotation; SwitchStatement; SynchronizedStatement; WhileStatement; WhileStatementNoShortIf
'"': EscapeSequence; StringCharacter; StringLiteral
'*': CommentTail; CommentTailStar; MultiplicativeExpression; NotStar; NotStarNotSlash; Operator; StaticImportOnDemandDeclaration; TraditionalComment; TypeImportOnDemandDeclaration
'*=': AssignmentOperator; Operator
'+': AdditiveExpression; Operator; Sign; UnaryExpression
'++': Operator; PostIncrementExpression; PreIncrementExpression
'+=': AssignmentOperator; Operator
',': ActualTypeArgumentList; ArgumentList; ArrayInitializer; ElementValueArrayInitializer; ElementValuePairs; ElementValues; EnumBody; EnumConstants; ExceptionTypeList; ExtendsInterfaces; FormalParameterList; FormalParameters; InterfaceTypeList; ReferenceTypeList; Separator; StatementExpressionList; TypeParameterList; VariableDeclarators; VariableInitializers
'-': AdditiveExpression; Operator; Sign; UnaryExpression
'--': Operator; PostDecrementExpression; PreDecrementExpression
'-=': AssignmentOperator; Operator
'.': AmbiguousName; ClassInstanceCreationExpression; DecimalFloatingPointLiteral; ExplicitConstructorInvocation; ExpressionName; FieldAccess; HexSignificand; MethodInvocation; MethodName; PackageName; PackageOrTypeName; PrimaryNoNewArray; Separator; SingleStaticImportDeclaration; StaticImportOnDemandDeclaration; TypeDeclSpecifier; TypeImportOnDemandDeclaration; TypeName
'...': LastFormalParameter
'/': CommentTailStar; EndOfLineComment; MultiplicativeExpression; NotStarNotSlash; Operator; TraditionalComment
'/=': AssignmentOperator; Operator
'0': DecimalNumeral; Digit; HexDigit; HexNumeral; OctalDigit; OctalNumeral; ZeroToThree
'0X': HexSignificand
'0x': HexSignificand
'1': HexDigit; NonZeroDigit; OctalDigit; ZeroToThree
'2': HexDigit; NonZeroDigit; OctalDigit; ZeroToThree
'3': HexDigit; NonZeroDigit; OctalDigit; ZeroToThree
'4': HexDigit; NonZeroDigit; OctalDigit
'5': HexDigit; NonZeroDigit; OctalDigit
'6': HexDigit; NonZeroDigit; OctalDigit
'7': HexDigit; NonZeroDigit; OctalDigit
'8': HexDigit; NonZeroDigit
'9': HexDigit; NonZeroDigit
':': AssertStatement; ConditionalExpression; EnhancedForStatement; LabeledStatement; LabeledStatementNoShortIf; Operator; SwitchLabel
';': AbstractMethodDeclaration; AnnotationTypeElementDeclaration; AssertStatement; BasicForStatement; BreakStatement; ClassMemberDeclaration; ConstantDeclaration; ContinueStatement; DoStatement; EmptyStatement; EnumBodyDeclarations; ExplicitConstructorInvocation; ExpressionStatement; FieldDeclaration; ForStatementNoShortIf; InterfaceMemberDeclaration; LocalVariableDeclarationStatement; MethodBody; PackageDeclaration; ReturnStatement; Separator; SingleStaticImportDeclaration; SingleTypeImportDeclaration; StaticImportOnDemandDeclaration; ThrowStatement; TypeDeclaration; TypeImportOnDemandDeclaration
'=': AssignmentOperator; ElementValuePair; Operator; VariableDeclarator
'==': EqualityExpression; Operator
'?': ConditionalExpression; Operator; Wildcard
'@': AnnotationTypeDeclaration; MarkerAnnotation; NormalAnnotation; SingleElementAnnotation
'A': HexDigit
AbstractMethodDeclaration: AbstractMethodDeclaration; InterfaceMemberDeclaration
AbstractMethodModifier: AbstractMethodModifier; AbstractMethodModifiers
AbstractMethodModifiers: AbstractMethodDeclaration; AbstractMethodModifiers; AnnotationTypeElementDeclaration
ActualTypeArgument: ActualTypeArgument; ActualTypeArgumentList
ActualTypeArgumentList: ActualTypeArgumentList; TypeArguments
AdditionalBound: AdditionalBound; AdditionalBoundList
AdditionalBoundList: AdditionalBoundList; TypeBound
AdditiveExpression: AdditiveExpression; ShiftExpression
AmbiguousName: AmbiguousName; ExpressionName; MethodName
AndExpression: AndExpression; ExclusiveOrExpression
Annotation: AbstractMethodModifier; Annotation; Annotations; ClassModifier; ConstantModifier; ConstructorModifier; ElementValue; FieldModifier; InterfaceModifier; MethodModifier; VariableModifier
AnnotationTypeBody: AnnotationTypeBody; AnnotationTypeDeclaration
AnnotationTypeDeclaration: AnnotationTypeDeclaration; AnnotationTypeElementDeclaration; InterfaceDeclaration
AnnotationTypeElementDeclaration: AnnotationTypeElementDeclaration; AnnotationTypeElementDeclarations
AnnotationTypeElementDeclarations: AnnotationTypeBody; AnnotationTypeElementDeclarations
Annotations: Annotations; EnumConstant; PackageDeclaration
ArgumentList: ArgumentList; Arguments; ClassInstanceCreationExpression; ExplicitConstructorInvocation; MethodInvocation
Arguments: Arguments; EnumConstant
ArrayAccess: ArrayAccess; LeftHandSide; PrimaryNoNewArray
ArrayCreationExpression: ArrayCreationExpression; Primary
ArrayInitializer: ArrayCreationExpression; ArrayInitializer; VariableInitializer
ArrayType: ArrayType; ReferenceType
AssertStatement: AssertStatement; StatementWithoutTrailingSubstatement
Assignment: Assignment; AssignmentExpression; StatementExpression
AssignmentExpression: Assignment; AssignmentExpression; Expression
AssignmentOperator: Assignment; AssignmentOperator
'B': HexDigit
BasicForStatement: BasicForStatement; ForStatement
BinaryExponent: BinaryExponent; HexadecimalFloatingPointLiteral
BinaryExponentIndicator: BinaryExponent; BinaryExponentIndicator
Block: Block; CatchClause; Finally; InstanceInitializer; MethodBody; StatementWithoutTrailingSubstatement; StaticInitializer; SynchronizedStatement; TryStatement
BlockStatement: BlockStatement; BlockStatements
BlockStatements: Block; BlockStatements; ConstructorBody; SwitchBlockStatementGroup
BooleanLiteral: BooleanLiteral; Identifier; Literal
BreakStatement: BreakStatement; StatementWithoutTrailingSubstatement
'C': HexDigit
? CR ?: InputCharacter
CastExpression: CastExpression; UnaryExpressionNotPlusMinus
CatchClause: CatchClause; Catches
Catches: Catches; TryStatement
CharacterLiteral: CharacterLiteral; Literal
CharactersInLine: CharactersInLine; EndOfLineComment
ClassBody: ClassBody; ClassInstanceCreationExpression; EnumConstant; NormalClassDeclaration
ClassBodyDeclaration: ClassBodyDeclaration; ClassBodyDeclarations
ClassBodyDeclarations: ClassBody; ClassBodyDeclarations; EnumBodyDeclarations
ClassDeclaration: AnnotationTypeElementDeclaration; BlockStatement; ClassDeclaration; ClassMemberDeclaration; InterfaceMemberDeclaration; TypeDeclaration
ClassInstanceCreationExpression: ClassInstanceCreationExpression; PrimaryNoNewArray; StatementExpression
ClassMemberDeclaration: ClassBodyDeclaration; ClassMemberDeclaration
ClassModifier: ClassModifier; ClassModifiers
ClassModifiers: ClassModifiers; EnumDeclaration; NormalClassDeclaration
ClassName: FieldAccess; MethodInvocation; PrimaryNoNewArray
ClassOrInterfaceType: ArrayCreationExpression; ClassInstanceCreationExpression; ClassOrInterfaceType; ReferenceType; TypeBound; TypeDeclSpecifier
ClassType: ClassOrInterfaceType; ClassType; ExceptionType; Super
Comment: Comment; InputElement
CommentTail: CommentTail; CommentTailStar; TraditionalComment
CommentTailStar: CommentTail; CommentTailStar
CompilationUnit: CompilationUnit
ConditionalAndExpression: ConditionalAndExpression; ConditionalOrExpression
ConditionalExpression: AssignmentExpression; ConditionalExpression; ElementValue
ConditionalOrExpression: ConditionalExpression; ConditionalOrExpression
ConstantDeclaration: AnnotationTypeElementDeclaration; ConstantDeclaration; InterfaceMemberDeclaration
ConstantExpression: ConstantExpression; SwitchLabel
ConstantModifier: ConstantModifier; ConstantModifiers
ConstantModifiers: ConstantDeclaration; ConstantModifiers
ConstructorBody: ConstructorBody; ConstructorDeclaration
ConstructorDeclaration: ClassBodyDeclaration; ConstructorDeclaration
ConstructorDeclarator: ConstructorDeclaration; ConstructorDeclarator
ConstructorModifier: ConstructorModifier; ConstructorModifiers
ConstructorModifiers: ConstructorDeclaration; ConstructorModifiers
ContinueStatement: ContinueStatement; StatementWithoutTrailingSubstatement
'D': FloatTypeSuffix; HexDigit
DecimalFloatingPointLiteral: DecimalFloatingPointLiteral; FloatingPointLiteral
DecimalIntegerLiteral: DecimalIntegerLiteral; IntegerLiteral
DecimalNumeral: DecimalIntegerLiteral; DecimalNumeral
DefaultValue: AnnotationTypeElementDeclaration; DefaultValue
Digit: Digit; Digits
Digits: DecimalFloatingPointLiteral; DecimalNumeral; Digits; SignedInteger
DimExpr: DimExpr; DimExprs
DimExprs: ArrayCreationExpression; DimExprs
Dims: ArrayCreationExpression; CastExpression; Dims
DoStatement: DoStatement; StatementWithoutTrailingSubstatement
'E': ExponentIndicator; HexDigit
ElementValue: DefaultValue; ElementValue; ElementValuePair; ElementValues; SingleElementAnnotation
ElementValueArrayInitializer: ElementValue; ElementValueArrayInitializer
ElementValuePair: ElementValuePair; ElementValuePairs
ElementValuePairs: ElementValuePairs; NormalAnnotation
ElementValues: ElementValueArrayInitializer; ElementValues
EmptyStatement: EmptyStatement; StatementWithoutTrailingSubstatement
EndOfLineComment: Comment; EndOfLineComment
EnhancedForStatement: EnhancedForStatement; ForStatement
EnumBody: EnumBody; EnumDeclaration
EnumBodyDeclarations: EnumBody; EnumBodyDeclarations
EnumConstant: EnumConstant; EnumConstants
EnumConstantName: EnumConstantName; SwitchLabel
EnumConstants: EnumBody; EnumConstants
EnumDeclaration: AnnotationTypeElementDeclaration; ClassDeclaration; EnumDeclaration
EqualityExpression: AndExpression; EqualityExpression
EscapeSequence: CharacterLiteral; EscapeSequence; StringCharacter
ExceptionType: ExceptionType; ExceptionTypeList
ExceptionTypeList: ExceptionTypeList; Throws
ExclusiveOrExpression: ExclusiveOrExpression; InclusiveOrExpression
ExplicitConstructorInvocation: ConstructorBody; ExplicitConstructorInvocation
ExponentIndicator: ExponentIndicator; ExponentPart
ExponentPart: DecimalFloatingPointLiteral; ExponentPart
Expression: ArgumentList; ArrayAccess; AssertStatement; BasicForStatement; ConditionalExpression; ConstantExpression; DimExpr; DoStatement; EnhancedForStatement; Expression; ForStatementNoShortIf; IfThenElseStatement; IfThenElseStatementNoShortIf; IfThenStatement; PrimaryNoNewArray; ReturnStatement; SwitchStatement; SynchronizedStatement; ThrowStatement; VariableInitializer; WhileStatement; WhileStatementNoShortIf
ExpressionName: ArrayAccess; ExpressionName; LeftHandSide; PostfixExpression
ExpressionStatement: ExpressionStatement; StatementWithoutTrailingSubstatement
ExtendsInterfaces: ExtendsInterfaces; NormalInterfaceDeclaration
'F': FloatTypeSuffix; HexDigit
FieldAccess: FieldAccess; LeftHandSide; PrimaryNoNewArray
FieldDeclaration: ClassMemberDeclaration; FieldDeclaration
FieldModifier: FieldModifier; FieldModifiers
FieldModifiers: FieldDeclaration; FieldModifiers
Finally: Finally; TryStatement
FloatTypeSuffix: DecimalFloatingPointLiteral; FloatTypeSuffix; HexadecimalFloatingPointLiteral
FloatingPointLiteral: FloatingPointLiteral; Literal
FloatingPointType: FloatingPointType; NumericType
ForInit: BasicForStatement; ForInit; ForStatementNoShortIf
ForStatement: ForStatement; Statement
ForStatementNoShortIf: ForStatementNoShortIf; StatementNoShortIf
ForUpdate: BasicForStatement; ForStatementNoShortIf; ForUpdate
FormalParameter: CatchClause; FormalParameter; FormalParameters
FormalParameterList: ConstructorDeclarator; FormalParameterList; MethodDeclarator
FormalParameters: FormalParameterList; FormalParameters
HexDigit: HexDigit; HexDigits; UnicodeEscape
HexDigits: HexDigits; HexNumeral; HexSignificand
HexIntegerLiteral: HexIntegerLiteral; IntegerLiteral
HexNumeral: HexIntegerLiteral; HexNumeral; HexSignificand
HexSignificand: HexSignificand; HexadecimalFloatingPointLiteral
HexadecimalFloatingPointLiteral: FloatingPointLiteral; HexadecimalFloatingPointLiteral
Identifier: AmbiguousName; AnnotationTypeDeclaration; AnnotationTypeElementDeclaration; BreakStatement; ClassInstanceCreationExpression; ConstructorDeclarator; ContinueStatement; ElementValuePair; EnhancedForStatement; EnumConstant; EnumConstantName; EnumDeclaration; ExpressionName; FieldAccess; Identifier; LabeledStatement; LabeledStatementNoShortIf; MethodDeclarator; MethodInvocation; MethodName; NormalClassDeclaration; NormalInterfaceDeclaration; PackageName; PackageOrTypeName; SingleStaticImportDeclaration; Token; TypeDeclSpecifier; TypeName; TypeVariable; VariableDeclaratorId
IdentifierChars: Identifier; IdentifierChars
IfThenElseStatement: IfThenElseStatement; Statement
IfThenElseStatementNoShortIf: IfThenElseStatementNoShortIf; StatementNoShortIf
IfThenStatement: IfThenStatement; Statement
ImportDeclaration: ImportDeclaration; ImportDeclarations
ImportDeclarations: CompilationUnit; ImportDeclarations
InclusiveOrExpression: ConditionalAndExpression; InclusiveOrExpression
Input: Input
InputCharacter: CharactersInLine; InputCharacter; NotStar; NotStarNotSlash; SingleCharacter; StringCharacter
InputElement: InputElement; InputElements
InputElements: Input; InputElements
InstanceInitializer: ClassBodyDeclaration; InstanceInitializer
IntegerLiteral: IntegerLiteral; Literal
IntegerTypeSuffix: DecimalIntegerLiteral; HexIntegerLiteral; IntegerTypeSuffix; OctalIntegerLiteral
IntegralType: IntegralType; NumericType
InterfaceBody: InterfaceBody; NormalInterfaceDeclaration
InterfaceDeclaration: AnnotationTypeElementDeclaration; ClassMemberDeclaration; InterfaceDeclaration; InterfaceMemberDeclaration; TypeDeclaration
InterfaceMemberDeclaration: InterfaceMemberDeclaration; InterfaceMemberDeclarations
InterfaceMemberDeclarations: InterfaceBody; InterfaceMemberDeclarations
InterfaceModifier: InterfaceModifier; InterfaceModifiers
InterfaceModifiers: AnnotationTypeDeclaration; InterfaceModifiers; NormalInterfaceDeclaration
InterfaceType: AdditionalBound; ClassOrInterfaceType; ExtendsInterfaces; InterfaceType; InterfaceTypeList
InterfaceTypeList: InterfaceTypeList; Interfaces
Interfaces: EnumDeclaration; Interfaces; NormalClassDeclaration
JavaLetter: IdentifierChars; JavaLetter
JavaLetterOrDigit: IdentifierChars; JavaLetterOrDigit
Keyword: Identifier; Keyword; Token
'L': IntegerTypeSuffix
? LF ?: InputCharacter
LabeledStatement: LabeledStatement; Statement
LabeledStatementNoShortIf: LabeledStatementNoShortIf; StatementNoShortIf
LastFormalParameter: FormalParameterList; LastFormalParameter
LeftHandSide: Assignment; LeftHandSide
LineTerminator: LineTerminator; NotStar; NotStarNotSlash; WhiteSpace
Literal: Literal; PrimaryNoNewArray; Token
LocalVariableDeclaration: ForInit; LocalVariableDeclaration; LocalVariableDeclarationStatement
LocalVariableDeclarationStatement: BlockStatement; LocalVariableDeclarationStatement
MarkerAnnotation: Annotation; MarkerAnnotation
MethodBody: MethodBody; MethodDeclaration
MethodDeclaration: ClassMemberDeclaration; MethodDeclaration
MethodDeclarator: AbstractMethodDeclaration; MethodDeclarator; MethodHeader
MethodHeader: MethodDeclaration; MethodHeader
MethodInvocation: MethodInvocation; PrimaryNoNewArray; StatementExpression
MethodModifier: MethodModifier; MethodModifiers
MethodModifiers: MethodHeader; MethodModifiers
MethodName: MethodInvocation; MethodName
MultiplicativeExpression: AdditiveExpression; MultiplicativeExpression
NonWildTypeArguments: ExplicitConstructorInvocation; MethodInvocation; NonWildTypeArguments
NonZeroDigit: DecimalNumeral; Digit; NonZeroDigit
NormalAnnotation: Annotation; NormalAnnotation
NormalClassDeclaration: ClassDeclaration; NormalClassDeclaration
NormalInterfaceDeclaration: InterfaceDeclaration; NormalInterfaceDeclaration
NotStar: CommentTail; NotStar
NotStarNotSlash: CommentTailStar; NotStarNotSlash
NullLiteral: Identifier; Literal; NullLiteral
NumericType: NumericType; PrimitiveType
OctalDigit: OctalDigit; OctalDigits; OctalEscape
OctalDigits: OctalDigits; OctalNumeral
OctalEscape: EscapeSequence; OctalEscape
OctalIntegerLiteral: IntegerLiteral; OctalIntegerLiteral
OctalNumeral: OctalIntegerLiteral; OctalNumeral
Operator: Operator; Token
'P': BinaryExponentIndicator
PackageDeclaration: CompilationUnit; PackageDeclaration
PackageName: PackageDeclaration; PackageName
PackageOrTypeName: PackageOrTypeName; TypeImportOnDemandDeclaration; TypeName
PostDecrementExpression: PostDecrementExpression; PostfixExpression; StatementExpression
PostIncrementExpression: PostIncrementExpression; PostfixExpression; StatementExpression
PostfixExpression: PostDecrementExpression; PostIncrementExpression; PostfixExpression; UnaryExpressionNotPlusMinus
PreDecrementExpression: PreDecrementExpression; StatementExpression; UnaryExpression
PreIncrementExpression: PreIncrementExpression; StatementExpression; UnaryExpression
Primary: ClassInstanceCreationExpression; ExplicitConstructorInvocation; FieldAccess; MethodInvocation; PostfixExpression; Primary
PrimaryNoNewArray: ArrayAccess; Primary; PrimaryNoNewArray
PrimitiveType: ArrayCreationExpression; CastExpression; PrimitiveType; Type
RawInputCharacter: RawInputCharacter; UnicodeInputCharacter
ReferenceType: ActualTypeArgument; CastExpression; ReferenceType; ReferenceTypeList; RelationalExpression; Type; WildcardBounds
ReferenceTypeList: NonWildTypeArguments; ReferenceTypeList
RelationalExpression: EqualityExpression; RelationalExpression
ResultType: AbstractMethodDeclaration; MethodHeader; ResultType
ReturnStatement: ReturnStatement; StatementWithoutTrailingSubstatement
Separator: Separator; Token
ShiftExpression: RelationalExpression; ShiftExpression
Sign: Sign; SignedInteger
SignedInteger: BinaryExponent; ExponentPart; SignedInteger
SingleCharacter: CharacterLiteral; SingleCharacter
SingleElementAnnotation: Annotation; SingleElementAnnotation
SingleStaticImportDeclaration: ImportDeclaration; SingleStaticImportDeclaration
SingleTypeImportDeclaration: ImportDeclaration; SingleTypeImportDeclaration
Statement: BasicForStatement; BlockStatement; DoStatement; EnhancedForStatement; IfThenElseStatement; IfThenStatement; LabeledStatement; Statement; WhileStatement
StatementExpression: ExpressionStatement; StatementExpression; StatementExpressionList
StatementExpressionList: ForInit; ForUpdate; StatementExpressionList
StatementNoShortIf: ForStatementNoShortIf; IfThenElseStatement; IfThenElseStatementNoShortIf; LabeledStatementNoShortIf; StatementNoShortIf; WhileStatementNoShortIf
StatementWithoutTrailingSubstatement: Statement; StatementNoShortIf; StatementWithoutTrailingSubstatement
StaticImportOnDemandDeclaration: ImportDeclaration; StaticImportOnDemandDeclaration
StaticInitializer: ClassBodyDeclaration; StaticInitializer
StringCharacter: StringCharacter; StringCharacters
StringCharacters: StringCharacters; StringLiteral
StringLiteral: Literal; StringLiteral
Sub: Input; Sub
Super: NormalClassDeclaration; Super
SwitchBlock: SwitchBlock; SwitchStatement
SwitchBlockStatementGroup: SwitchBlockStatementGroup; SwitchBlockStatementGroups
SwitchBlockStatementGroups: SwitchBlock; SwitchBlockStatementGroups
SwitchLabel: SwitchLabel; SwitchLabels
SwitchLabels: SwitchBlock; SwitchBlockStatementGroup; SwitchLabels
SwitchStatement: StatementWithoutTrailingSubstatement; SwitchStatement
SynchronizedStatement: StatementWithoutTrailingSubstatement; SynchronizedStatement
ThrowStatement: StatementWithoutTrailingSubstatement; ThrowStatement
Throws: AbstractMethodDeclaration; ConstructorDeclaration; MethodHeader; Throws
Token: InputElement; Token
TraditionalComment: Comment; TraditionalComment
TryStatement: StatementWithoutTrailingSubstatement; TryStatement
Type: AnnotationTypeElementDeclaration; ArrayType; ConstantDeclaration; EnhancedForStatement; FieldDeclaration; FormalParameter; LastFormalParameter; LocalVariableDeclaration; PrimaryNoNewArray; ResultType; Type
TypeArguments: ClassInstanceCreationExpression; ClassType; InterfaceType; TypeArguments
TypeBound: TypeBound; TypeParameter
TypeDeclSpecifier: ClassType; InterfaceType; TypeDeclSpecifier
TypeDeclaration: TypeDeclaration; TypeDeclarations
TypeDeclarations: CompilationUnit; TypeDeclarations
TypeImportOnDemandDeclaration: ImportDeclaration; TypeImportOnDemandDeclaration
TypeName: MarkerAnnotation; MethodInvocation; NormalAnnotation; SingleElementAnnotation; SingleStaticImportDeclaration; SingleTypeImportDeclaration; StaticImportOnDemandDeclaration; TypeDeclSpecifier; TypeName
TypeParameter: TypeParameter; TypeParameterList
TypeParameterList: TypeParameterList; TypeParameters
TypeParameters: AbstractMethodDeclaration; ConstructorDeclarator; MethodHeader; NormalClassDeclaration; NormalInterfaceDeclaration; TypeParameters
TypeVariable: ExceptionType; ReferenceType; TypeParameter; TypeVariable
UnaryExpression: CastExpression; MultiplicativeExpression; PreDecrementExpression; PreIncrementExpression; UnaryExpression; UnaryExpressionNotPlusMinus
UnaryExpressionNotPlusMinus: CastExpression; UnaryExpression; UnaryExpressionNotPlusMinus
UnicodeEscape: UnicodeEscape; UnicodeInputCharacter
UnicodeInputCharacter: InputCharacter; UnicodeInputCharacter
UnicodeMarker: UnicodeEscape; UnicodeMarker
VariableDeclarator: VariableDeclarator; VariableDeclarators
VariableDeclaratorId: FormalParameter; LastFormalParameter; VariableDeclarator; VariableDeclaratorId
VariableDeclarators: ConstantDeclaration; FieldDeclaration; LocalVariableDeclaration; VariableDeclarators
VariableInitializer: VariableDeclarator; VariableInitializer; VariableInitializers
VariableInitializers: ArrayInitializer; VariableInitializers
VariableModifier: VariableModifier; VariableModifiers
VariableModifiers: EnhancedForStatement; FormalParameter; LastFormalParameter; LocalVariableDeclaration; VariableModifiers
WhileStatement: Statement; WhileStatement
WhileStatementNoShortIf: StatementNoShortIf; WhileStatementNoShortIf
WhiteSpace: InputElement; WhiteSpace
Wildcard: ActualTypeArgument; Wildcard
WildcardBounds: Wildcard; WildcardBounds
'X': HexNumeral
ZeroToThree: OctalEscape; ZeroToThree
'[': ArrayAccess; ArrayType; DimExpr; Dims; MethodDeclarator; Separator; VariableDeclaratorId
'\': EscapeSequence; OctalEscape; SingleCharacter; StringCharacter; UnicodeEscape
']': ArrayAccess; ArrayType; DimExpr; Dims; MethodDeclarator; Separator; VariableDeclaratorId
'^': ExclusiveOrExpression; Operator
'^=': AssignmentOperator; Operator
'a': HexDigit
'abstract': AbstractMethodModifier; ClassModifier; InterfaceModifier; Keyword; MethodModifier
? any Unicode character that is a Java letter ?: JavaLetter
? any Unicode character that is a Java letter-or-digit ?: JavaLetterOrDigit
? any Unicode character ?: RawInputCharacter
'assert': AssertStatement; Keyword
'b': EscapeSequence; HexDigit
'boolean': Keyword; PrimitiveType
'break': BreakStatement; Keyword
'byte': IntegralType; Keyword
'c': HexDigit
'case': Keyword; SwitchLabel
'catch': CatchClause; Keyword
'char': IntegralType; Keyword
'class': Keyword; NormalClassDeclaration; PrimaryNoNewArray
'const': Keyword
'continue': ContinueStatement; Keyword
'd': FloatTypeSuffix; HexDigit
'default': DefaultValue; Keyword; SwitchLabel
'do': DoStatement; Keyword
'double': FloatingPointType; Keyword
'e': ExponentIndicator; HexDigit
'else': IfThenElseStatement; IfThenElseStatementNoShortIf; Keyword
'enum': EnumDeclaration; Keyword
'extends': ExtendsInterfaces; Keyword; Super; TypeBound; WildcardBounds
'f': EscapeSequence; FloatTypeSuffix; HexDigit
'false': BooleanLiteral
'final': ClassModifier; ConstantModifier; FieldModifier; Keyword; MethodModifier; VariableModifier
'finally': Finally; Keyword
'float': FloatingPointType; Keyword
'for': BasicForStatement; EnhancedForStatement; ForStatementNoShortIf; Keyword
'goto': Keyword
'if': IfThenElseStatement; IfThenElseStatementNoShortIf; IfThenStatement; Keyword
'implements': Interfaces; Keyword
'import': Keyword; SingleStaticImportDeclaration; SingleTypeImportDeclaration; StaticImportOnDemandDeclaration; TypeImportOnDemandDeclaration
'instanceof': Keyword; RelationalExpression
'int': IntegralType; Keyword
'interface': AnnotationTypeDeclaration; Keyword; NormalInterfaceDeclaration
'l': IntegerTypeSuffix
'long': IntegralType; Keyword
'n': EscapeSequence
'native': Keyword; MethodModifier
'new': ArrayCreationExpression; ClassInstanceCreationExpression; Keyword
'null': NullLiteral
'p': BinaryExponentIndicator
'package': Keyword; PackageDeclaration
'private': ClassModifier; ConstructorModifier; FieldModifier; InterfaceModifier; Keyword; MethodModifier
'protected': ClassModifier; ConstructorModifier; FieldModifier; InterfaceModifier; Keyword; MethodModifier
'public': AbstractMethodModifier; ClassModifier; ConstantModifier; ConstructorModifier; FieldModifier; InterfaceModifier; Keyword; MethodModifier
'r': EscapeSequence
'return': Keyword; ReturnStatement
'short': IntegralType; Keyword
'static': ClassModifier; ConstantModifier; FieldModifier; InterfaceModifier; Keyword; MethodModifier; SingleStaticImportDeclaration; StaticImportOnDemandDeclaration; StaticInitializer
'strictfp': ClassModifier; InterfaceModifier; Keyword; MethodModifier
'super': ExplicitConstructorInvocation; FieldAccess; Keyword; MethodInvocation; WildcardBounds
'switch': Keyword; SwitchStatement
'synchronized': Keyword; MethodModifier; SynchronizedStatement
't': EscapeSequence
? the ASCII CR character followed by the ASCII LF character ?: LineTerminator
? the ASCII CR character, also known as "return" ?: LineTerminator
? the ASCII FF character, also known as "form feed" ?: WhiteSpace
? the ASCII HT character, also known as "horizontal tab" ?: WhiteSpace
? the ASCII LF character, also known as "newline" ?: LineTerminator
? the ASCII SP character, also known as "space" ?: WhiteSpace
? the ASCII SUB character, also known as "control-Z" ?: Sub
'this': ExplicitConstructorInvocation; Keyword; PrimaryNoNewArray
'throw': Keyword; ThrowStatement
'throws': Keyword; Throws
'transient': FieldModifier; Keyword
'true': BooleanLiteral
'try': Keyword; TryStatement
'u': UnicodeMarker
'void': Keyword; PrimaryNoNewArray; ResultType
'volatile': FieldModifier; Keyword
'while': DoStatement; Keyword; WhileStatement; WhileStatementNoShortIf
'x': HexNumeral
'{': AnnotationTypeBody; ArrayInitializer; Block; ClassBody; ConstructorBody; ElementValueArrayInitializer; EnumBody; InterfaceBody; Separator; SwitchBlock
'|': InclusiveOrExpression; Operator
'|=': AssignmentOperator; Operator
'||': ConditionalOrExpression; Operator
'}': AnnotationTypeBody; ArrayInitializer; Block; ClassBody; ConstructorBody; ElementValueArrayInitializer; EnumBody; InterfaceBody; Separator; SwitchBlock
'~': Operator; UnaryExpressionNotPlusMinus

References

ISO/IEC. (1996). ISO/IEC 14977 : 1996(E). ISO/IEC. Retrieved Saturday, March 26, 2005 from http://www.cl.cam.ac.uk/~mgk25/iso-ebnf.html.
JLS3. (2005). The Java Language Specification, 3rd Edition (pre-publication PDF release). California: Sun Microsystems, Inc. Retrieved Tuesday, April 19, 2005 from http://java.sun.com/docs/books/jls/download/langspec-3.0.pdf.

How to Search Open Source Code

noreply@blogger.com (Gaute Lykkenborg) — Tue, 16 Dec 2008 20:09:00 +0000

Koders.com, is a search engine for open source and other downloadable code (http://www.koders.com/).

Methods

noreply@blogger.com (Gaute Lykkenborg) — Mon, 05 May 2008 13:00:00 +0000

Introduction

A method is a named block that can be called, and where program execution can continue. Other names for methods in non-object-oriented languages are functions and procedures. But unlike functions and procedures, methods are also members of a class.

Program

1 package sharingjava;
2 
3 public class Example {
4 
5     public static void main(String[] args) {
6         System.out.println("Hello World!");
7     }
8 
9 }

Discussion

In the example program, the main method starts at line 5. The main method is a method that serves as a starting point for program execution. The main method is called automatically when program execution begins. You will get a runtime error if this method is missing.

One more thing... It's impossible to know that your program need the main method just by examining the grammar. You will not find it there.

Here is the Java grammar for writing methods:

MethodDeclaration =

MethodHeader, MethodBody ;

Old Table of Contents

noreply@blogger.com (Gaute Lykkenborg) — Tue, 22 Apr 2008 20:03:00 +0000

Introduction to Programs and Programming

Keywords

Explicit and Implicit Code

Syntax Decoration

Values, Operators, Expressions, Types and Variables

More about Types

Conversions

Control Structures

Sequence
Conditional
Iteration
Jump Statements

The 'break' Statement
The 'continue' Statement
The 'return' Statement

Branching Statements

The 'if' Statement
The 'else' Statement
The 'switch' Statement

The 'break', 'continue' and 'return' statements are not Branching Statements

Recursion
Escape Sequence

The java.lang Package

The String Class

indexOf()
endsWith()
compareTo()

The Object Class

'toString'

The Math Class

The random Method

Monte Carlo Calculation of Pi

Bugs

Memoization
Binary Numbers

Language Extensions

J2SE 1.4.0 (Merlin)

Assertion Facility

J2SE 5.0 (1.5.0) (Tiger)

J2SE 6.0 (1.6.0) (Mustang)
J2SE 7.0 (1.7.0) (Dolphin)

Swing Applications

The Main Parts of a Swing Application

HOWTOs

Downloading and Installing Java

How to Write, Compile and Run Java Programs

Types

How to Read an Unsigned 'byte'

Performance

Swing

Source Code

Applications

Swing

Installed Look and Feels

Design Patterns

The Singleton Design Pattern

History

Machine Language
Assembly Language
FORTRAN
ALGOL 60
SIMULA 67
CPL
BCPL
B
C
C++
Java

Grammars

The BCPL Grammar
The Java Language Specification, First Edition
The Java Language Specification, Second Edition
The Java Language Specification, Third Edition

References
Java Tutorials on the Web
Lykkenborg BSD License for Java Source Code
Tutorial Standards and Conventions

How to Write, Compile and Run a GCJ Application

noreply@blogger.com (Gaute Lykkenborg) — Mon, 22 Oct 2007 19:36:00 +0000

How to Write GCJ Application

Writing an GCJ application is similar to writing any application.

How to compile a GCJ Application

This is how to compile and link with gcj in one step (Gao 2003):

[user]$ gcj --main=HelloWorld -o HelloWorld HelloWorld.java

How to run a GCJ Application

This is how to run a GCJ Application:

[user]$ ./HelloWorld
Hello World!

References

Gao, Weiqi. (2003). GCJ---The GNU Compiler for Java St. Louis, MO: Object Computing, Inc. Retrieved Monday, April 11, 2005 from http://www.ociweb.com/jnb/jnbJan2003.html.
GCJ: The GNU Compiler for Java
Compiling Java with GCJ

Computing Factorial using BigDecimal

noreply@blogger.com (Gaute Lykkenborg) — Fri, 14 Sep 2007 16:49:00 +0000

This demonstration program computes the factorial using BigDecimal. However, there exists more efficient algorithms, see http://www.luschny.de/math/factorial/FastFactorialFunctions.htm

import java.math.BigInteger;

public class FactorialTest {    
    public static void main(String[] args) {
        long l = 10000;
        BigInteger bi = factorial(l);
        System.out.println(bi);
        System.out.println(bi.toString().length());
    }
    
    /* ordinary factorial code */
    public static long factorial(int n) {
        long f = 1;
        
        while (n > 1) {
            f *= n--;
        }
        
        return f;
    }
    
    /* BigInteger factorial code */
    public static BigInteger factorial(long n) {
        BigInteger f = BigInteger.ONE;              // long f = 1;
        BigInteger g = BigInteger.valueOf(n);       // int n
        
        while (g.compareTo(BigInteger.ONE) == 1) {  // while (n > 1) {
            f = f.multiply(g);                      // f *= n;
            g = g.subtract(BigInteger.ONE);         // n--;
        }
        
        return f;
    }
}

Star Trek

noreply@blogger.com (Gaute Lykkenborg) — Tue, 22 May 2007 09:33:00 +0000

Introduction

Star Trek is a classic computer game written by Mike Mayfield, 20 October 1972. The game is based on the Star Trek television show. This program is a direct port to Java from the original BASIC program, and does not use object-oriented programming (OOP).

                                 * * *   Star Trek   * * *

Do you want instructions (they're long!): no

You must destroy 13 Klingons in 30 stardates with 2 starbases.

Combat Area      Condition Red
   Shields dangerously low

Short Range Sensor Scan

   1   2   3   4   5   6   7   8
 ---------------------------------
1              *
2                                  Stardate:            2486
3              *       *           Condition:           Red
4 +++  *       *                   Quadrant:            2, 6
5     <*>                          Sector:              5, 2
6                                  Energy:              3000.0
7                  *               Photon Torpedoes:    10
8                                  Shields:             0.0
 ---------------------------------

Command:

Download the Star Trek Java port

How to compile the Star Trek Java port

Write the following in a Linux terminal window or MS-DOS window:

javac StarTrek.java

How to run the Star Trek Java port

Write the following in a Linux terminal window or MS-DOS window:

java StarTrek

References

The original Star Trek BASIC program can be found here:

Resources

Star Trek Instructions

noreply@blogger.com (Gaute Lykkenborg) — Tue, 22 May 2007 08:04:00 +0000

The Galaxy

The galaxy is divided into an [8, 8] quadrant grid which is in turn divided into an [8, 8] sector grid. The cast of characters is as follows:


  <*> = Enterprise
  +++ = Klingon
  >!< = Starbase
   *  = Star

Commands

Command 0 = Warp Engine Control (WEC)


   4  3  2
    \ ^ /
     \^/
  5 ----- 1
     /^\
    / ^ \
   6  7  8

   Course

Course is in a Circular Numerical Vector Arrangement (CNVA) as shown. Integer and real values may be used. Therefore course 1.5 is half way between 1 and 2. A vector of 9 is undefined, but values may approach 9. One Warp Factor (WF) is the size of one quadrant. Therefore to get from quadrant [6, 5] to [5, 5] you would use course 3, warp factor 1.

Command 1 = Short Range Sensor Scan (SRSS)

Prints the quadrant you are currently in, including stars, Klingons, starbases, and the Enterprise; along with other pertinate information.

Command 2 = Long Range Sensor Scan (LRSS)

Shows conditions in space for one quadrant on each side of the Enterprise in the middle of the scan. The scan is coded in the form XXX, where the units digit is the number of stars, the tens digit is the number of starbases and the hundreds digit is the number of Klingons.

Command 3 = Phaser Control (PC)

Allows you to destroy the Klingons by hitting him with suitably large numbers of energy units to deplete his shield power. Keep in mind that when you shoot at him, he gonna shoot at you too.

Command 4 = Photon Torpedo Control (PTC)

Course is the same as used in Warp Engine Control (WEC). If you hit the Klingon, he is destroyed and cannot fire back at you. If you miss, he will fire phasers at you.

Note: The Library Computer (command 7) has an option to compute torpedo trajectory for you (option 2).

Command 5 = Shield Control (SC)

Defines number of energy units to be assigned to shields energy is taken from total ship's energy.

Note: Total energy includes shield energy.

Command 6 = Damage Control Report (DCR)

Gives state of repairs of all devices. A state of repair less than zero shows that the device is temporarily damaged.

Command 7 = Library Computer (LC)

The Library Computer contains three options:

Option 0 = Cumulative Galactic Record (CGR)

Shows computer memory of the results of all previous Long Range Sensor Scans.
Option 1 = Status Report (SR)

Shows number of Klingons, stardates and starbases left.
Option 2 = Photon Torpedo Data (PTD)

Gives trajectory and distance between the Enterprise and all Klingons in your quadrant.

Expressions

noreply@blogger.com (Gaute Lykkenborg) — Tue, 24 Apr 2007 13:01:00 +0000

A running program should be able to do calculations, much like a calculator. For example:

public class Main {
    public static void main(String[] args) {
        System.out.println(2 + 2 + 2);
    }
}

A calculation that produces a value, such as 6 * 9, is called an expression.

http://en.wikipedia.org/wiki/Expression_%28programming%29

Fibonacci Numbers

noreply@blogger.com (Gaute Lykkenborg) — Mon, 23 Apr 2007 07:52:00 +0000

import java.math.BigInteger;

public class Main {
    public static void main(String[] args) {
        int n = Integer.parseInt(args[0]);
        System.out.println("iterativeFib:    " + iterativeFib(n));
        System.out.println("recursiveFib:    " + recursiveFib(n));
        System.out.println("iterativeBigFib: " + iterativeBigFib(n));
        System.out.println("recursiveBigFib: " + recursiveBigFib(n));
        System.out.println("memoizedBigFib:  " + memoizedBigFib(null, n));
        System.out.println("dynamicBigFib:   " + dynamicBigFib(n));
    }
    
    // Iterative Programming
    public static long iterativeFib(final int n) {
        long prev1 = 1, prev2 = 1, current = 1;
        
        for (int i = 3; i <= n; i++) {
            current += prev2;
            prev2 = prev1;
            prev1 = current;
        }
        
        return current;
    }
    
    // Recursive Programming
    public static long recursiveFib(final int n) {
        if (n <= 2) {
            return 1;
        } else {
            return recursiveFib(n - 1) + recursiveFib(n - 2);
        }
    }
    
    // Arbitrary-Precision Math
    
    // Iterative Programming
    public static BigInteger iterativeBigFib(final int n) {
        BigInteger prev1 = BigInteger.ONE, prev2 = BigInteger.ONE, current = BigInteger.ONE;
        
        for (int i = 3; i <= n; i++) {
            current = current.add(prev2);
            prev2 = prev1;
            prev1 = current;
        }
        
        return current;
    }
    
    // Recursive Programming
    public static BigInteger recursiveBigFib(final int n) {
        if (n <= 2) {
            return BigInteger.ONE;
        } else {
            return recursiveBigFib(n - 1).add(recursiveBigFib(n - 2));
        }
    }
    
    // Memoization
    public static BigInteger memoizedBigFib(BigInteger[] fibarray, final int n) {
        if (fibarray == null)
            fibarray = new BigInteger[n + 1];
        
        if (n <= 2) {
            return BigInteger.ONE;
        } else {
            return fibarray[n] == null ? fibarray[n] = memoizedBigFib(fibarray, n - 1).add(memoizedBigFib(fibarray, n - 2)) : fibarray[n];
        }
    }
    
    // Dynamic Programming
    public static BigInteger dynamicBigFib(final int n) {
        BigInteger[] fibarray = new BigInteger[n + 1];
        
        if (n <= 2) {
            return BigInteger.ONE;
        } else {
            fibarray[1] = BigInteger.ONE;
            fibarray[2] = BigInteger.ONE;
            for (int i = 3; i <= n; i++) {
                fibarray[i] = fibarray[i - 1].add(fibarray[i - 2]);
            }
            return fibarray[n];
        }
    }
}

[user]$ javac Fib.java
[user]$ java Fib 45
iterativeFib:    1134903170
recursiveFib:    1134903170
iterativeBigFib: 1134903170
recursiveBigFib: 1134903170
memoizedBigFib:  1134903170
dynamicBigFib:   1134903170

The first run went OK, but the recursive methods took a long time to finish.

[user]$ javac Fib.java
[user]$ java Fib 95
iterativeFib:    -4953053512429003327
recursiveFib:    -4953053512429003327
iterativeBigFib: 31940434634990099905
recursiveBigFib: 31940434634990099905
memoizedBigFib:  31940434634990099905
dynamicBigFib:   31940434634990099905

The recursive methods are very slow. I didn't have the time to wait — so I fudged the answers... Also, the two first answers are clearly wrong, because the largest value a long variable can hold is 9223372036854775807.

Power of 2

noreply@blogger.com (Gaute Lykkenborg) — Fri, 20 Apr 2007 11:51:00 +0000

Program

public class Main {
    public static void main(String[] args) {
        for (int i = 0; i <= 62; i++) {
            System.out.println(i + ": " + (long) Math.pow(2, i));
        }
    }
}

Output

0: 1
1: 2
2: 4
3: 8
4: 16
5: 32
6: 64
7: 128
8: 256
9: 512
10: 1024
11: 2048
12: 4096
13: 8192
14: 16384
15: 32768
16: 65536
17: 131072
18: 262144
19: 524288
20: 1048576
21: 2097152
22: 4194304
23: 8388608
24: 16777216
25: 33554432
26: 67108864
27: 134217728
28: 268435456
29: 536870912
30: 1073741824
31: 2147483648
32: 4294967296
33: 8589934592
34: 17179869184
35: 34359738368
36: 68719476736
37: 137438953472
38: 274877906944
39: 549755813888
40: 1099511627776
41: 2199023255552
42: 4398046511104
43: 8796093022208
44: 17592186044416
45: 35184372088832
46: 70368744177664
47: 140737488355328
48: 281474976710656
49: 562949953421312
50: 1125899906842624
51: 2251799813685248
52: 4503599627370496
53: 9007199254740992
54: 18014398509481984
55: 36028797018963968
56: 72057594037927936
57: 144115188075855872
58: 288230376151711744
59: 576460752303423488
60: 1152921504606846976
61: 2305843009213693952
62: 4611686018427387904

Cool Java page at darcia.org

noreply@blogger.com (Gaute Lykkenborg) — Wed, 11 Apr 2007 10:24:00 +0000

This is a cool Java page at darcia.org. You can check it out here: Java archive at [darcia.org] .Invent .Share .Think Creative

Converting between Primitive Types and String

noreply@blogger.com (Gaute Lykkenborg) — Wed, 11 Apr 2007 09:28:00 +0000

*Converting between Primitive Types and String*
From	To	Example
`byte`	`String`	`byte b = -127; String s = Byte.toString(b);`
`int`	`String`	`int i = 1450; String s = Integer.toString(i);`
`String`	`int`	`String s = "1335"; int i = Integer.parseInt(s);`

The Integer.toString() method is typically used to convert an integer to a String. Also, Integer.toString() is preferred to String.valueOf(), because String.valueOf() ends up calling Integer.toString() anyway.

Do not write int i = 8100; String s = String.valueOf(i);, because it is inefficient to use public static String valueOf(int i) { from class String. Use public static String toString(int i) { from class Integer instead. public static String valueOf(int i) { from class String simply calls public static String toString(int i, int radix) { from class Integer which in turn calls public static String toString(int i) { from class Integer.

Similarly, use code like byte b = Byte.parseByte("35"); for converting bytes.

How to convert between boolean and int

noreply@blogger.com (Gaute Lykkenborg) — Tue, 10 Apr 2007 15:47:00 +0000

Program

public class Main {
    public static void main(String[] args) {
        int i = booleanToInt(false);
        System.out.println(i);
        
        boolean b = intToBoolean(42);
        System.out.println(b);
    }
    
    /*
     * Returns 1 if the argument is true, 0 if the argument is false.
     */
    static int booleanToInt(boolean b) {
        return (b ? 1 : 0);  
    }
    
    /*
     * Returns false if the argument is 0, true for any other argument.
     */
    static boolean intToBoolean(int i) {        
        return (i == 0 ? false : true);
    }
}

Output

0
true

Sharing Java Search Engine

noreply@blogger.com (Gaute Lykkenborg) — Mon, 09 Apr 2007 17:18:00 +0000

How to exit a Java program

noreply@blogger.com (Gaute Lykkenborg) — Sun, 08 Apr 2007 11:52:00 +0000

System.exit(0);

The canonical order of Java modifier names

noreply@blogger.com (Gaute Lykkenborg) — Sun, 08 Apr 2007 10:25:00 +0000

Introduction

The canonical order of Java modifier names is:

Modifiers =: 'public' | 'protected' | 'private' | 'abstract' | 'static' | 'final' | 'transient' | 'volatile' | 'synchronized' | 'native' | 'strictfp' | 'interface' ;

(Modifier (Java 2 Platform SE 5.0))

Program

import java.lang.reflect.*;

public class Main {
    final static strictfp public class MyClass {
    }
    
    public static void main(String[] args) {
        MyClass mc = new MyClass();
        Class c = mc.getClass();
        int m = c.getModifiers();

        // Print the modifier names in canonical order
        System.out.println(Modifier.toString(m));
    }    
}

Output

public static final strictfp

Adding Lessons

noreply@blogger.com (Gaute Lykkenborg) — Wed, 28 Mar 2007 18:30:00 +0000

Introduction

Imagine that you are a teacher, and need to come up with some adding lessons for your class. The students should add three numbers together between 1 and 9, because adding with 0 is too easy. The result should be less than 10, so that the students don't have to carry the one.

Program

public class Adding {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        int count = 0;
        
        for (int i = 1; i < 10; i++) {
            for (int j = 1; j < 10; j++) {
                for (int k = 1; k < 10; k++) {
                    int sum = i +  j + k;
                    if (sum <= 10 ) {
                        String s = i + " + " + j + " + " + k + " = " + sum;
                        list.add(s);
                        count++;
                    }
                }
            }
        }
        
        System.out.println(count);
        Collections.shuffle(list, new Random());
        
        for (String t : list ) {
            System.out.println(t);
        }
    }
}

Output

120
3 + 6 + 1 = 10
2 + 2 + 1 = 5
3 + 5 + 2 = 10
7 + 2 + 1 = 10
2 + 4 + 4 = 10
1 + 1 + 5 = 7
3 + 3 + 4 = 10
4 + 1 + 3 = 8
2 + 2 + 3 = 7
3 + 1 + 2 = 6
...

Discussion

The program first calculates all legal combinations. Each combination is then put into a list, then the combinations are shuffled, so that they are in random order, and finally printed.

The teacher could create three random numbers between 1 and 9

number1 = (int) (Math.random() * 9 + 1);
number2 = (int) (Math.random() * 9 + 1);
number3 = (int) (Math.random() * 9 + 1);

and then repeat the process until the sum is between 1 and 10, but the algorithm would be harder to understand, it would be a lot slower, and it would probably not create all combinations.

Conclusion

The idea of putting the combinations into a list, and then shuffle the list, results in a program that take up a little memory, but the resulting code is easy to understand and easy to modify.

Heads or Tails

noreply@blogger.com (Gaute Lykkenborg) — Wed, 28 Mar 2007 09:59:00 +0000

Program

public class CoinFlipping {
    public static void main(String[] args) {
        int heads = 0;
        int tails = 0;
        
        for (int i = 0; i < 10; i++) {
            int number = (int) (Math.random() * 2);
            
            if (number == 0) {
                heads++;
                System.out.print("Head, ");
                
            } else { // number == 1
                tails++;
                System.out.print("Tail, ");
            }
        }
        
        System.out.println();
        System.out.println("Heads: " + heads);
        System.out.println("Tails: " + tails);      
        System.out.println("Count: " + (heads + tails));      
    }
}

Output

Tail, Head, Tail, Tail, Head, Head, Tail, Tail, Head, Tail, 
Heads: 4
Tails: 6
Count: 10

Widening Primitive Conversion

noreply@blogger.com (Gaute Lykkenborg) — Tue, 27 Mar 2007 18:56:00 +0000

Introduction

The widening primitive conversions are implicit casts, meaning that the programmer does not have to tell the compiler that a primitive type need to be converted. You can cast implicitly from a type with fewer bits to a type with more bits.

Note: char cannot be converted to short implicitly.

*Converting Primitive Types by Implicit Cast*
From type	To type	Example
byte	int	`int i; byte b = 125; i = b; // i = 125`
int	double	`double d; int i = 512; d = i; // d = 512.0`
int	float	`float f; int i = 35; f = i; // f = 35.0`

Program

public class Main {
    public static void main(String[] args) {
        byte b = (byte) 54; 
        short s = b;
        s = b; // implicit cast
        System.out.println(s);
    }    
}

Output

Narrowing Primitive Conversions

noreply@blogger.com (Gaute Lykkenborg) — Tue, 27 Mar 2007 18:50:00 +0000

Introduction

You have to cast explicitly from a type with more bits to a type with fewer bits.

*Converting Primitive Types by Explicit Cast*
From type	To type	Example
int	byte	`byte b; int i; i = 20; b = (byte) i; // b = 20`
double	int	`int i; double d = 22.18; i = (int) d; // i = 22`
float	int	`int i; float f = 34.92f; i = (int) f; // f = 34`

Program

public class Main {
    public static void main(String[] args) {
        int i = 20; 
        byte b = (byte) i; // explicit cast
        System.out.println(b);
    }    
}

Output

Downloading and Installing Java

noreply@blogger.com (Gaute Lykkenborg) — Tue, 27 Mar 2007 09:32:00 +0000

If you do not know if your computer supports the Java 2 Platform, you can open a terminal window, and type the command "java -version".

C:\>java -version

If the computer returns a message like:

java version "1.x.x"
...

then your computer supports the Java. If your computer do not support Java, then you must download and install the Java from Sun Microsystems. You can download java at Java SE Downloads.

End-users need to download the Java Runtime Environment (JRE) to run Java. Programmers need to install the JDK. JRE is included in the JDK. Programmers may also need NetBeans IDE. It is possible to download JDK with NetBeans, or download the packages separately.

Monte Carlo Calculation of Pi

noreply@blogger.com (Gaute Lykkenborg) — Mon, 26 Mar 2007 17:02:00 +0000

Program

class MonteCarlo {
    public static void main(String[] args) {
        double x, y;
        int hits = 0, limit = Integer.MAX_VALUE;

        for (int i = 0; i < limit; i++) {
            x = Math.random();
            y = Math.random();
            if (x * x + y * y <= 1) hits++;
        }

        System.out.println(4.0 * hits / limit);
        System.out.println(Math.PI);
    }
}

Output

Be prepared to wait for a while. (The program ran for 7 minutes and 48 seconds on my 1.86 GHz computer.)

[user]$ javac MonteCarlo.java
[user]$ java MonteCarlo
3.141600906449184
3.141592653589793

Discussion

The approximation Pi = 3.14166 was first obtained by Claudius Ptolemy (c. 150 AD) (O'Connor & Robertson 2001).

For a somewhat more accurate calculation of Pi, see: Computing Pi using BigDecimal.

Sharing Java

The BCPL Grammar

Grammar

Index

References

The Java JLS2 Grammar

Grammar

Index

References

The Java JLS3 Grammar

Grammar

Index

References

How to Search Open Source Code

Methods

Introduction

Program

Discussion

Old Table of Contents

How to Write, Compile and Run a GCJ Application

How to Write GCJ Application

How to compile a GCJ Application

How to run a GCJ Application

References

Computing Factorial using BigDecimal

Star Trek

Introduction

Download the Star Trek Java port

How to compile the Star Trek Java port

How to run the Star Trek Java port

References

Resources

Star Trek Instructions

The Galaxy

Commands

Command 0 = Warp Engine Control (WEC)

Command 1 = Short Range Sensor Scan (SRSS)

Command 2 = Long Range Sensor Scan (LRSS)

Command 3 = Phaser Control (PC)

Command 4 = Photon Torpedo Control (PTC)

Command 5 = Shield Control (SC)

Command 6 = Damage Control Report (DCR)

Command 7 = Library Computer (LC)

Option 0 = Cumulative Galactic Record (CGR)

Option 1 = Status Report (SR)

Option 2 = Photon Torpedo Data (PTD)

Expressions

Fibonacci Numbers

Power of 2

Program

Output

Cool Java page at darcia.org

Converting between Primitive Types and String

How to convert between boolean and int

Program

Output

Sharing Java Search Engine

How to exit a Java program

The canonical order of Java modifier names

Introduction

Program

Output

Adding Lessons

Introduction

Program

Output

Discussion

Conclusion

Heads or Tails

Program

Output

Widening Primitive Conversion

Introduction

Program

Output

Narrowing Primitive Conversions

Introduction

Program

Output

Downloading and Installing Java