Package org.codehaus.janino

# Class Parser

java.lang.Object
org.codehaus.janino.Parser

public class Parser extends Object
A parser for the Java programming language.

'JLS7' refers to the Java Language Specification, Java SE 7 Edition.

## Nested Class Summary

Nested Classes
Modifier and Type
Class
Description
`static enum`
`Parser.ClassDeclarationContext`
The kinds of context where a class declaration can occur.
`static enum`
`Parser.InterfaceDeclarationContext`
The kinds of context where an interface declaration can occur.
`static enum`
`Parser.MethodDeclarationContext`
The kinds of context where a method declaration can occur.

## Constructor Summary

Constructors
Constructor
Description
`Parser(Scanner scanner)`
`Parser(Scanner scanner, TokenStream tokenStream)`

## Method Summary

Modifier and Type
Method
Description
`protected final CompileException`
`compileException(String message)`
Convenience method for throwing a `CompileException`.
`protected static CompileException`
`compileException(String message, Location location)`
Convenience method for throwing a `CompileException`.
`String`
`doc()`
Gets the text of the doc comment (a.k.a.
`Scanner`
`getScanner()`
`Location`
`location()`
`Java.AbstractCompilationUnit`
`parseAbstractCompilationUnit()`
CompilationUnit := [ PackageDeclaration ] { ImportDeclaration } { TypeDeclaration }
`Java.Atom`
`parseAdditiveExpression()`
AdditiveExpression := MultiplicativeExpression { ( '+' | '-' ) MultiplicativeExpression }
`Java.Atom`
`parseAndExpression()`
AndExpression := EqualityExpression { '&' EqualityExpression }
`Java.AnnotationTypeDeclaration`
`parseAnnotationTypeDeclarationRest(String docComment, Java.Modifier[] modifiers, Parser.InterfaceDeclarationContext context)`
AnnotationTypeDeclarationRest := Identifier AnnotationTypeBody
`Java.Rvalue[]`
`parseArgumentList()`
ArgumentList := Expression { ',' Expression }
`Java.Rvalue[]`
`parseArguments()`
Arguments := '(' [ ArgumentList ] ')'
`Java.ArrayInitializer`
`parseArrayInitializer()`
ArrayInitializer := '{' [ VariableInitializer { ',' VariableInitializer } [ ',' ] '}'
`Java.Statement`
`parseAssertStatement()`
AssertStatement := 'assert' Expression [ ':' Expression ] ';'
`Java.Atom`
`parseAssignmentExpression()`
AssignmentExpression := ConditionalExpression [ AssignmentOperator AssignmentExpression ] AssignmentOperator := '=' | '*=' | '/=' | '%=' | '+=' | '-=' | '<<=' | '>>=' | '>>>=' | '&=' | '^=' | '|='
`Java.Block`
`parseBlock()`
Block := '{' BlockStatements '}'
`Java.BlockStatement`
`parseBlockStatement()`
BlockStatement := Statement | (1) 'class' ...
`List<Java.BlockStatement>`
`parseBlockStatements()`
BlockStatements := { BlockStatement }
`Java.Statement`
`parseBreakStatement()`
BreakStatement := 'break' [ Identifier ] ';'
`Java.CatchParameter`
`parseCatchParameter()`
CatchFormalParameter := { VariableModifier } CatchType VariableDeclaratorId CatchType := UnannClassType { '|' ClassType } VariableModifier := Annotation | 'final' VariableDeclaratorId := Identifier [ Dims ] Dims := { Annotation } '[' ']' { { Annotation } '[' ']' } UnannClassType := Identifier [ TypeArguments ] | UnannClassOrInterfaceType '.' { Annotation } Identifier [ TypeArguments ] UnannInterfaceType := UnannClassType UnannClassOrInterfaceType := UnannClassType | UnannInterfaceType ClassType := { Annotation } Identifier [ TypeArguments ] | ClassOrInterfaceType '.' { Annotation } Identifier [ TypeArguments ]
`void`
`parseClassBody(Java.AbstractClassDeclaration classDeclaration)`
ClassBody := '{' { ClassBodyDeclaration } '}'
`void`
`parseClassBodyDeclaration(Java.AbstractClassDeclaration classDeclaration)`
ClassBodyDeclaration := ';' | ModifiersOpt ( Block | // Instance (JLS7 8.6) or static initializer (JLS7 8.7) 'void' Identifier MethodDeclarationRest | 'class' ClassDeclarationRest | 'interface' InterfaceDeclarationRest | ConstructorDeclarator | [ TypeArguments ] Type Identifier MethodDeclarationRest | Type Identifier FieldDeclarationRest ';' )
`Java.NamedClassDeclaration`
`parseClassDeclarationRest(String docComment, Java.Modifier[] modifiers, Parser.ClassDeclarationContext context)`
ClassDeclarationRest := Identifier [ typeParameters ] [ 'extends' ReferenceType ] [ 'implements' ReferenceTypeList ] ClassBody
`Java.Atom`
`parseConditionalAndExpression()`
ConditionalAndExpression := InclusiveOrExpression { '&&' InclusiveOrExpression }
`Java.Atom`
`parseConditionalExpression()`
ConditionalExpression := ConditionalOrExpression [ '?' Expression ':' ConditionalExpression ]
`Java.Atom`
`parseConditionalOrExpression()`
ConditionalOrExpression := ConditionalAndExpression { '||' ConditionalAndExpression ]
`Java.ConstructorDeclarator`
`parseConstructorDeclarator(String docComment, Java.Modifier[] modifiers)`
ConstructorDeclarator := Identifier FormalParameters [ 'throws' ReferenceTypeList ] '{' [ 'this' Arguments ';' | 'super' Arguments ';' | Primary '.' 'super' Arguments ';' ] BlockStatements '}'
`Java.Statement`
`parseContinueStatement()`
ContinueStatement := 'continue' [ Identifier ] ';'
`Java.Rvalue`
`parseDimExpr()`
DimExpr := '[' Expression ']'
`Java.Rvalue[]`
`parseDimExprs()`
DimExprs := DimExpr { DimExpr }
`Java.Statement`
`parseDoStatement()`
DoStatement := 'do' Statement 'while' '(' Expression ')' ';'
`Java.Statement`
`parseEmptyStatement()`
EmptyStatement := ';'
`void`
`parseEnumBody(Java.EnumDeclaration enumDeclaration)`
EnumBody := '{' [ EnumConstant { ',' EnumConstant } [ ',' ] [ ';' ] { ClassBodyDeclaration } '}'
`Java.EnumConstant`
`parseEnumConstant()`
EnumConstant := [ Annotations ] Identifier [ Arguments ] [ ClassBody ]
`Java.EnumDeclaration`
`parseEnumDeclarationRest(String docComment, Java.Modifier[] modifiers, Parser.ClassDeclarationContext context)`
EnumDeclarationRest := Identifier [ 'implements' ReferenceTypeList ] EnumBody
`Java.Atom`
`parseEqualityExpression()`
EqualityExpression := RelationalExpression { ( '==' | '!=' ) RelationalExpression }
`Java.Atom`
`parseExclusiveOrExpression()`
ExclusiveOrExpression := AndExpression { '^' AndExpression }
`Java.Rvalue`
`parseExpression()`
Expression := AssignmentExpression | LambdaExpression
`Java.Rvalue[]`
`parseExpressionList()`
ExpressionList := Expression { ',' Expression }
`Java.Atom`
`parseExpressionOrType()`
Same as `parseExpression()`, but types like `int` or `Map<String, Object>` are also parsed.
`Java.Statement`
`parseExpressionStatement()`
ExpressionStatement := Expression ';'
`Java.VariableDeclarator[]`
`parseFieldDeclarationRest(String name)`
FieldDeclarationRest := VariableDeclaratorRest { ',' VariableDeclarator }
`Java.FunctionDeclarator.FormalParameter`
`parseFormalParameter(boolean[] hasEllipsis)`
FormalParameter := [ 'final' ] Type FormalParameterRest
`Java.FunctionDeclarator.FormalParameters`
`parseFormalParameterList()`
FormalParameterList := FormalParameter { ',' FormalParameter }
`Java.FunctionDeclarator.FormalParameters`
`parseFormalParameterListRest(Java.Type firstParameterType)`
FormalParameterListRest := Identifier { ',' FormalParameter }
`Java.FunctionDeclarator.FormalParameter`
`parseFormalParameterRest(Java.Modifier[] modifiers, Java.Type type, boolean[] hasEllipsis)`
FormalParameterRest := [ '.' '.' '.' ] Identifier BracketsOpt
`Java.FunctionDeclarator.FormalParameters`
`parseFormalParameters()`
FormalParameters := '(' [ FormalParameterList ] ')'
`Java.Statement`
`parseForStatement()`
ForStatement := 'for' '(' [ ForInit ] ';' [ Expression ] ';' [ ExpressionList ] ')' Statement | 'for' '(' FormalParameter ':' Expression ')' Statement ForInit := Modifiers Type VariableDeclarators | ModifiersOpt PrimitiveType VariableDeclarators | Expression VariableDeclarators (1) | Expression { ',' Expression }
`Java.Statement`
`parseIfStatement()`
IfStatement := 'if' '(' Expression ')' Statement [ 'else' Statement ]
`Java.AbstractCompilationUnit.ImportDeclaration`
`parseImportDeclaration()`
ImportDeclaration := 'import' ImportDeclarationBody ';'
`Java.AbstractCompilationUnit.ImportDeclaration`
`parseImportDeclarationBody()`
ImportDeclarationBody := [ 'static' ] Identifier { '.' Identifier } [ '.' '*' ]
`Java.Atom`
`parseInclusiveOrExpression()`
InclusiveOrExpression := ExclusiveOrExpression { '|' ExclusiveOrExpression }
`void`
`parseInterfaceBody(Java.InterfaceDeclaration interfaceDeclaration)`
InterfaceBody := '{' { ';' | ModifiersOpt ( 'void' Identifier MethodDeclarationRest | 'class' ClassDeclarationRest | 'interface' InterfaceDeclarationRest | Type Identifier ( MethodDeclarationRest | FieldDeclarationRest ) ) } '}'
`Java.InterfaceDeclaration`
`parseInterfaceDeclarationRest(String docComment, Java.Modifier[] modifiers, Parser.InterfaceDeclarationContext context)`
InterfaceDeclarationRest := Identifier [ typeParameters ] [ 'extends' ReferenceTypeList ] InterfaceBody
`Java.Statement`
`parseLabeledStatement()`
LabeledStatement := Identifier ':' Statement
`Java.Rvalue`
`parseLiteral()`
Literal := IntegerLiteral | FloatingPointLiteral | BooleanLiteral | CharacterLiteral | StringLiteral | NullLiteral
`Java.Block`
`parseMethodBody()`
MethodBody := Block
`Java.MethodDeclarator`
`parseMethodDeclaration()`
Equivalent with `parseMethodDeclaration(false, MethodDeclarationContext.CLASS_DECLARATION)`.
`Java.MethodDeclarator`
`parseMethodDeclaration(boolean allowDefaultClause, Parser.MethodDeclarationContext context)`
MethodDeclaration := [ DocComment ] Modifiers [ TypeParameters ] VoidOrType Identifier MethodDeclarationRest
`Java.MethodDeclarator`
`parseMethodDeclarationRest(String docComment, Java.Modifier[] modifiers, Java.TypeParameter[] typeParameters, Java.Type type, String name, boolean allowDefaultClause, Parser.MethodDeclarationContext context)`
MethodDeclarationRest := FormalParameters { '[' ']' } [ 'throws' ReferenceTypeList ] [ 'default' expression ] ( ';' | MethodBody )
`Java.Modifier[]`
`parseModifiers()`
Modifiers := { Modifier }
`Java.ModuleDeclaration`
`parseModuleDeclarationRest(Java.Modifier[] modifiers)`
ModuleDeclarationRest := [ 'open' ] 'module' identifier { '.' identifier} '{' { ModuleDirective } '}'
`Java.Atom`
`parseMultiplicativeExpression()`
MultiplicativeExpression := UnaryExpression { ( '*' | '/' | '%' ) UnaryExpression }
`Java.Modifier`
`parseOptionalModifier()`
Modifier := Annotation | 'public' | 'protected' | 'private' | 'static' | 'abstract' | 'final' | 'native' | 'synchronized' | 'transient' | 'volatile' | 'strictfp' | 'default'
`Java.PackageDeclaration`
`parsePackageDeclaration()`
PackageDeclaration := 'package' QualifiedIdentifier ';'
`Java.PackageDeclaration`
`parsePackageDeclarationRest(String docComment, Java.Modifier[] modifiers)`
PackageDeclaration := { PackageModifier } 'package' identifier { '.' identifier} ';'
`Java.PackageMemberTypeDeclaration`
`parsePackageMemberTypeDeclaration()`
PackageMemberTypeDeclaration := ModifiersOpt PackageMemberTypeDeclarationRest
`Java.Atom`
`parsePrimary()`
Primary := CastExpression | // CastExpression 15.16 '(' Expression ')' | // ParenthesizedExpression 15.8.5 Literal | // Literal 15.8.1 Name | // AmbiguousName Name Arguments | // MethodInvocation Name '[]' { '[]' } | // ArrayType 10.1 Name '[]' { '[]' } '.' 'class' | // ClassLiteral 15.8.2 'this' | // This 15.8.3 'this' Arguments | // Alternate constructor invocation 8.8.5.1 'super' Arguments | // Unqualified superclass constructor invocation 8.8.5.1 'super' '.' Identifier | // SuperclassFieldAccess 15.11.2 'super' '.' Identifier Arguments | // SuperclassMethodInvocation 15.12.4.9 NewClassInstance | NewAnonymousClassInstance | // ClassInstanceCreationExpression 15.9 NewArray | // ArrayCreationExpression 15.10 NewInitializedArray | // ArrayInitializer 10.6 PrimitiveType { '[]' } | // Type PrimitiveType { '[]' } '.' 'class' | // ClassLiteral 15.8.2 'void' '.' 'class' | // ClassLiteral 15.8.2 MethodReference // MethodReference JLS9 15.13 Name := Identifier { '.' Identifier } CastExpression := '(' PrimitiveType { '[]' } ')' UnaryExpression | '(' Expression ')' UnaryExpression NewClassInstance := 'new' ReferenceType Arguments NewAnonymousClassInstance := 'new' ReferenceType Arguments [ ClassBody ] NewArray := 'new' Type DimExprs { '[]' } NewInitializedArray := 'new' ArrayType ArrayInitializer
`String[]`
`parseQualifiedIdentifier()`
QualifiedIdentifier := Identifier { '.' Identifier }
`Java.ReferenceType`
`parseReferenceType()`
ReferenceType := { Annotation } QualifiedIdentifier [ TypeArguments ]
`Java.ReferenceType[]`
`parseReferenceTypeList()`
ReferenceTypeList := ReferenceType { ',' ReferenceType }
`Java.Atom`
`parseRelationalExpression()`
RelationalExpression := ShiftExpression { 'instanceof' ReferenceType | '<' ShiftExpression [ { ',' TypeArgument } '>' ] | '<' TypeArgument [ { ',' TypeArgument } '>' ] | ( '>' | '<=' | '>=' ) ShiftExpression }
`Java.Statement`
`parseReturnStatement()`
ReturnStatement := 'return' [ Expression ] ';'
`Java.Atom`
`parseSelector(Java.Atom atom)`
Selector := '.' Identifier | // FieldAccess 15.11.1 '.' Identifier Arguments | // MethodInvocation '.' '<' TypeList '>' 'super' Arguments // Superconstructor invocation (?) '.' '<' TypeList '>' 'super' '.' .
`Java.Atom`
`parseShiftExpression()`
ShiftExpression := AdditiveExpression { ( '<<' | '>>' | '>>>' ) AdditiveExpression }
`Java.Statement`
`parseStatement()`
Statement := LabeledStatement | Block | IfStatement | ForStatement | WhileStatement | DoStatement | TryStatement | 'switch' ...
`Java.Statement`
`parseSwitchStatement()`
SwitchStatement := 'switch' '(' Expression ')' '{' { SwitchLabels BlockStatements } '}' SwitchLabels := SwitchLabels { SwitchLabels } SwitchLabel := 'case' Expression ':' | 'default' ':'
`Java.Statement`
`parseSynchronizedStatement()`
SynchronizedStatement := 'synchronized' '(' expression ')' Block
`Java.Statement`
`parseThrowStatement()`
ThrowStatement := 'throw' Expression ';'
`Java.Statement`
`parseTryStatement()`
TryStatement := 'try' Block Catches [ Finally ] | 'try' Block Finally Catches := CatchClause { CatchClause } CatchClause := 'catch' '(' FormalParameter ')' Block Finally := 'finally' Block
`Java.Type`
`parseType()`
Type := ( 'byte' | 'short' | 'char' | 'int' | 'long' | 'float' | 'double' | 'boolean' | ReferenceType ) { '[' ']' }
`Java.Atom`
`parseUnaryExpression()`
UnaryExpression := { PrefixOperator } Primary { Selector } { PostfixOperator } PrefixOperator := '++' | '--' | '+' | '-' | '~' | '!' PostfixOperator := '++' | '--'
`Java.VariableDeclarator`
`parseVariableDeclarator()`
VariableDeclarator := Identifier VariableDeclaratorRest
`Java.VariableDeclarator`
`parseVariableDeclaratorRest(String name)`
VariableDeclaratorRest := { '[' ']' } [ '=' VariableInitializer ]
`Java.VariableDeclarator[]`
`parseVariableDeclarators()`
VariableDeclarators := VariableDeclarator { ',' VariableDeclarator }
`Java.ArrayInitializerOrRvalue`
`parseVariableInitializer()`
VariableInitializer := ArrayInitializer | Expression
`Java.Type`
`parseVoidOrType()`
VoidOrType := 'void' | Type
`Java.Statement`
`parseWhileStatement()`
WhileStatement := 'while' '(' Expression ')' Statement
`Token`
`peek()`
`boolean`
`peek(String suspected)`
`int`
`peek(String... suspected)`
`boolean`
`peek(TokenType suspected)`
`int`
`peek(TokenType... suspected)`
`Token`
`peekNextButOne()`
`boolean`
`peekNextButOne(String suspected)`
`boolean`
`peekNextButOne(TokenType suspected)`
`boolean`
`peekRead(String suspected)`
`int`
`peekRead(String... suspected)`
`String`
`peekRead(TokenType suspected)`
`Token`
`read()`
`void`
`read(String expected)`
`int`
`read(String... expected)`
`String`
`read(TokenType expected)`
`void`
`setSourceVersion(int version)`
`void`
`setWarningHandler(WarningHandler warningHandler)`
By default, warnings are discarded, but an application my install a `WarningHandler`.

### Methods inherited from class java.lang.Object

`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

## Constructor Details

### Parser

public Parser(Scanner scanner)

### Parser

public Parser(Scanner scanner, TokenStream tokenStream)

## Method Details

### doc

@Nullable public String doc()
Gets the text of the doc comment (a.k.a. "JAVADOC comment") preceding the next token.

Returns:
  `null` if the next token is not preceded by a doc comment

### getScanner

public Scanner getScanner()

Returns:
  The scanner that produces the tokens for this parser.

### parseAbstractCompilationUnit

public Java.AbstractCompilationUnit parseAbstractCompilationUnit() throws CompileException, IOException

       CompilationUnit := [ PackageDeclaration ]
                          { ImportDeclaration }
                          { TypeDeclaration }

Throws:
  `CompileException`
  `IOException`

### parseModuleDeclarationRest

public Java.ModuleDeclaration parseModuleDeclarationRest(Java.Modifier[] modifiers) throws CompileException, IOException

       ModuleDeclarationRest := [ 'open' ] 'module' identifier { '.' identifier} '{' { ModuleDirective } '}'

Throws:
  `CompileException`
  `IOException`

### parsePackageDeclaration

public Java.PackageDeclaration parsePackageDeclaration() throws CompileException, IOException

       PackageDeclaration := 'package' QualifiedIdentifier ';'

Throws:
  `CompileException`
  `IOException`

### parsePackageDeclarationRest

public Java.PackageDeclaration parsePackageDeclarationRest(@Nullable String docComment, Java.Modifier[] modifiers) throws CompileException, IOException

       PackageDeclaration := { PackageModifier } 'package' identifier { '.' identifier} ';'

Throws:
  `CompileException`
  `IOException`

### parseImportDeclaration

public Java.AbstractCompilationUnit.ImportDeclaration parseImportDeclaration() throws CompileException, IOException

       ImportDeclaration := 'import' ImportDeclarationBody ';'

Throws:
  `CompileException`
  `IOException`

### parseImportDeclarationBody

public Java.AbstractCompilationUnit.ImportDeclaration parseImportDeclarationBody() throws CompileException, IOException

       ImportDeclarationBody := [ 'static' ] Identifier { '.' Identifier } [ '.' '*' ]

Throws:
  `CompileException`
  `IOException`

### parseQualifiedIdentifier

public String[] parseQualifiedIdentifier() throws CompileException, IOException

       QualifiedIdentifier := Identifier { '.' Identifier }

Throws:
  `CompileException`
  `IOException`

### parsePackageMemberTypeDeclaration

public Java.PackageMemberTypeDeclaration parsePackageMemberTypeDeclaration() throws CompileException, IOException

       PackageMemberTypeDeclaration := ModifiersOpt PackageMemberTypeDeclarationRest

Throws:
  `CompileException`
  `IOException`

### parseModifiers

public Java.Modifier[] parseModifiers() throws CompileException, IOException

       Modifiers := { Modifier }

Includes the case "no modifiers".

Throws:
  `CompileException`
  `IOException`

### parseOptionalModifier

@Nullable public Java.Modifier parseOptionalModifier() throws CompileException, IOException

       Modifier :=
           Annotation
           | 'public' | 'protected' | 'private'
           | 'static' | 'abstract' | 'final' | 'native' | 'synchronized' | 'transient' | 'volatile' | 'strictfp'
           | 'default'

Throws:
  `CompileException`
  `IOException`

### parseClassDeclarationRest

public Java.NamedClassDeclaration parseClassDeclarationRest(@Nullable String docComment, Java.Modifier[] modifiers, Parser.ClassDeclarationContext context) throws CompileException, IOException

       ClassDeclarationRest :=
            Identifier [ typeParameters ]
            [ 'extends' ReferenceType ]
            [ 'implements' ReferenceTypeList ]
            ClassBody

Throws:
  `CompileException`
  `IOException`

### parseEnumDeclarationRest

public Java.EnumDeclaration parseEnumDeclarationRest(@Nullable String docComment, Java.Modifier[] modifiers, Parser.ClassDeclarationContext context) throws CompileException, IOException

       EnumDeclarationRest := Identifier [ 'implements' ReferenceTypeList ] EnumBody

Throws:
  `CompileException`
  `IOException`

### parseClassBody

public void parseClassBody(Java.AbstractClassDeclaration classDeclaration) throws CompileException, IOException

       ClassBody := '{' { ClassBodyDeclaration } '}'

Throws:
  `CompileException`
  `IOException`

### parseEnumBody

public void parseEnumBody(Java.EnumDeclaration enumDeclaration) throws CompileException, IOException

       EnumBody := '{' [ EnumConstant { ',' EnumConstant } [ ',' ] [ ';' ] { ClassBodyDeclaration } '}'

Throws:
  `CompileException`
  `IOException`

### parseEnumConstant

public Java.EnumConstant parseEnumConstant() throws CompileException, IOException

       EnumConstant := [ Annotations ] Identifier [ Arguments ] [ ClassBody ]

Throws:
  `CompileException`
  `IOException`

### parseClassBodyDeclaration

public void parseClassBodyDeclaration(Java.AbstractClassDeclaration classDeclaration) throws CompileException, IOException

       ClassBodyDeclaration :=
         ';' |
         ModifiersOpt (
           Block |                                    // Instance (JLS7 8.6) or static initializer (JLS7 8.7)
           'void' Identifier MethodDeclarationRest |
           'class' ClassDeclarationRest |
           'interface' InterfaceDeclarationRest |
           ConstructorDeclarator |
           [ TypeArguments ] Type Identifier MethodDeclarationRest |
           Type Identifier FieldDeclarationRest ';'
         )

Throws:
  `CompileException`
  `IOException`

### parseInterfaceDeclarationRest

public Java.InterfaceDeclaration parseInterfaceDeclarationRest(@Nullable String docComment, Java.Modifier[] modifiers, Parser.InterfaceDeclarationContext context) throws CompileException, IOException

       InterfaceDeclarationRest :=
         Identifier [ typeParameters ]
         [ 'extends' ReferenceTypeList ]
         InterfaceBody

Throws:
  `CompileException`
  `IOException`

### parseAnnotationTypeDeclarationRest

public Java.AnnotationTypeDeclaration parseAnnotationTypeDeclarationRest(@Nullable String docComment, Java.Modifier[] modifiers, Parser.InterfaceDeclarationContext context) throws CompileException, IOException

       AnnotationTypeDeclarationRest := Identifier AnnotationTypeBody

Throws:
  `CompileException`
  `IOException`

### parseInterfaceBody

public void parseInterfaceBody(Java.InterfaceDeclaration interfaceDeclaration) throws CompileException, IOException

       InterfaceBody := '{' {
         ';' |
         ModifiersOpt (
           'void' Identifier MethodDeclarationRest |
           'class' ClassDeclarationRest |
           'interface' InterfaceDeclarationRest |
           Type Identifier (
             MethodDeclarationRest |
             FieldDeclarationRest
           )
         )
       } '}'

Throws:
  `CompileException`
  `IOException`

### parseConstructorDeclarator

public Java.ConstructorDeclarator parseConstructorDeclarator(@Nullable String docComment, Java.Modifier[] modifiers) throws CompileException, IOException

       ConstructorDeclarator :=
         Identifier
         FormalParameters
         [ 'throws' ReferenceTypeList ]
         '{'
           [ 'this' Arguments ';' | 'super' Arguments ';' | Primary '.' 'super' Arguments ';' ]
           BlockStatements
         '}'

Throws:
  `CompileException`
  `IOException`

### parseMethodDeclaration

public Java.MethodDeclarator parseMethodDeclaration() throws CompileException, IOException
Equivalent with `parseMethodDeclaration(false, MethodDeclarationContext.CLASS_DECLARATION)`.

Throws:
  `CompileException`
  `IOException`
See Also:
  - `parseMethodDeclaration(boolean, MethodDeclarationContext)`

### parseMethodDeclaration

public Java.MethodDeclarator parseMethodDeclaration(boolean allowDefaultClause, Parser.MethodDeclarationContext context) throws CompileException, IOException

       MethodDeclaration :=
         [ DocComment ] Modifiers [ TypeParameters ] VoidOrType Identifier MethodDeclarationRest

Parameters:
  `allowDefaultClause` - Whether a "default clause" for an "annotation type element" (JLS8 9.6.2) should be parsed
Throws:
  `CompileException`
  `IOException`

### parseVoidOrType

public Java.Type parseVoidOrType() throws CompileException, IOException

       VoidOrType := 'void' | Type

Throws:
  `CompileException`
  `IOException`

### parseMethodDeclarationRest

public Java.MethodDeclarator parseMethodDeclarationRest(@Nullable String docComment, Java.Modifier[] modifiers, @Nullable Java.TypeParameter[] typeParameters, Java.Type type, String name, boolean allowDefaultClause, Parser.MethodDeclarationContext context) throws CompileException, IOException

       MethodDeclarationRest :=
         FormalParameters
         { '[' ']' }
         [ 'throws' ReferenceTypeList ]
         [ 'default' expression ]
         ( ';' | MethodBody )

Parameters:
  `allowDefaultClause` - Whether a "default clause" for an "annotation type element" (JLS8 9.6.2) should be parsed
Throws:
  `CompileException`
  `IOException`

### parseVariableInitializer

public Java.ArrayInitializerOrRvalue parseVariableInitializer() throws CompileException, IOException

       VariableInitializer :=
         ArrayInitializer |
         Expression

Throws:
  `CompileException`
  `IOException`

### parseArrayInitializer

public Java.ArrayInitializer parseArrayInitializer() throws CompileException, IOException

       ArrayInitializer :=
         '{' [ VariableInitializer { ',' VariableInitializer } [ ',' ] '}'

Throws:
  `CompileException`
  `IOException`

### parseFormalParameters

public Java.FunctionDeclarator.FormalParameters parseFormalParameters() throws CompileException, IOException

       FormalParameters := '(' [ FormalParameterList ] ')'

Throws:
  `CompileException`
  `IOException`

### parseFormalParameterList

public Java.FunctionDeclarator.FormalParameters parseFormalParameterList() throws CompileException, IOException

       FormalParameterList := FormalParameter { ',' FormalParameter }

Throws:
  `CompileException`
  `IOException`

### parseFormalParameterListRest

public Java.FunctionDeclarator.FormalParameters parseFormalParameterListRest(Java.Type firstParameterType) throws CompileException, IOException

       FormalParameterListRest := Identifier { ',' FormalParameter }

Throws:
  `CompileException`
  `IOException`

### parseFormalParameter

public Java.FunctionDeclarator.FormalParameter parseFormalParameter(boolean[] hasEllipsis) throws CompileException, IOException

       FormalParameter := [ 'final' ] Type FormalParameterRest

Throws:
  `CompileException`
  `IOException`

### parseFormalParameterRest

public Java.FunctionDeclarator.FormalParameter parseFormalParameterRest(Java.Modifier[] modifiers, Java.Type type, boolean[] hasEllipsis) throws CompileException, IOException

       FormalParameterRest := [ '.' '.' '.' ] Identifier BracketsOpt

Parameters:
  `hasEllipsis` - After return, the zeroth element indicates whether the formal parameter was declared with an ellipsis
Throws:
  `CompileException`
  `IOException`

### parseCatchParameter

public Java.CatchParameter parseCatchParameter() throws CompileException, IOException

       CatchFormalParameter      := { VariableModifier } CatchType VariableDeclaratorId
       CatchType                 := UnannClassType { '|' ClassType }
       VariableModifier          := Annotation | 'final'
       VariableDeclaratorId      := Identifier [ Dims ]
       Dims                      := { Annotation } '[' ']' { { Annotation } '[' ']' }
       UnannClassType            :=
           Identifier [ TypeArguments ]
           | UnannClassOrInterfaceType '.' { Annotation } Identifier [ TypeArguments ]
       UnannInterfaceType        := UnannClassType
       UnannClassOrInterfaceType := UnannClassType | UnannInterfaceType
       ClassType                 :=
           { Annotation } Identifier [ TypeArguments ]
           | ClassOrInterfaceType '.' { Annotation } Identifier [ TypeArguments ]

Throws:
  `CompileException`
  `IOException`

### parseMethodBody

public Java.Block parseMethodBody() throws CompileException, IOException

       MethodBody := Block

Throws:
  `CompileException`
  `IOException`

### parseBlock

public Java.Block parseBlock() throws CompileException, IOException

       Block := '{' BlockStatements '}'

Throws:
  `CompileException`
  `IOException`

### parseBlockStatements

public List<Java.BlockStatement> parseBlockStatements() throws CompileException, IOException

       BlockStatements := { BlockStatement }

Throws:
  `CompileException`
  `IOException`

### parseBlockStatement

public Java.BlockStatement parseBlockStatement() throws CompileException, IOException

       BlockStatement :=
         Statement |                                     (1)
         'class' ... |                                   (2)
         Modifiers Type VariableDeclarators ';' |
         Expression ';' |
         Expression BracketsOpt VariableDeclarators ';'  (3)

(1) Includes the "labeled statement".

(2) Local class declaration.

(3) Local variable declaration statement; "Expression" must pose a type, and has optional trailing brackets.

Throws:
  `CompileException`
  `IOException`

### parseVariableDeclarators

public Java.VariableDeclarator[] parseVariableDeclarators() throws CompileException, IOException

       VariableDeclarators := VariableDeclarator { ',' VariableDeclarator }

Throws:
  `CompileException`
  `IOException`

### parseFieldDeclarationRest

public Java.VariableDeclarator[] parseFieldDeclarationRest(String name) throws CompileException, IOException

       FieldDeclarationRest :=
         VariableDeclaratorRest
         { ',' VariableDeclarator }

Throws:
  `CompileException`
  `IOException`

### parseVariableDeclarator

public Java.VariableDeclarator parseVariableDeclarator() throws CompileException, IOException

       VariableDeclarator := Identifier VariableDeclaratorRest

Throws:
  `CompileException`
  `IOException`

### parseVariableDeclaratorRest

public Java.VariableDeclarator parseVariableDeclaratorRest(String name) throws CompileException, IOException

       VariableDeclaratorRest := { '[' ']' } [ '=' VariableInitializer ]

Used by field declarations and local variable declarations.

Throws:
  `CompileException`
  `IOException`

### parseStatement

public Java.Statement parseStatement() throws CompileException, IOException

       Statement :=
         LabeledStatement |
         Block |
         IfStatement |
         ForStatement |
         WhileStatement |
         DoStatement |
         TryStatement |
         'switch' ... |
         'synchronized' ... |
         ReturnStatement |
         ThrowStatement |
         BreakStatement |
         ContinueStatement |
         EmptyStatement |
         ExpressionStatement

Throws:
  `CompileException`
  `IOException`

### parseLabeledStatement

public Java.Statement parseLabeledStatement() throws CompileException, IOException

       LabeledStatement := Identifier ':' Statement

Throws:
  `CompileException`
  `IOException`

### parseIfStatement

public Java.Statement parseIfStatement() throws CompileException, IOException

       IfStatement := 'if' '(' Expression ')' Statement [ 'else' Statement ]

Throws:
  `CompileException`
  `IOException`

### parseForStatement

public Java.Statement parseForStatement() throws CompileException, IOException

       ForStatement :=
         'for' '(' [ ForInit ] ';' [ Expression ] ';' [ ExpressionList ] ')' Statement
         | 'for' '(' FormalParameter ':' Expression ')' Statement

       ForInit :=
         Modifiers Type VariableDeclarators
         | ModifiersOpt PrimitiveType VariableDeclarators
         | Expression VariableDeclarators              (1)
         | Expression { ',' Expression }

(1) "Expression" must pose a type.

Throws:
  `CompileException`
  `IOException`

### parseWhileStatement

public Java.Statement parseWhileStatement() throws CompileException, IOException

       WhileStatement := 'while' '(' Expression ')' Statement

Throws:
  `CompileException`
  `IOException`

### parseDoStatement

public Java.Statement parseDoStatement() throws CompileException, IOException

       DoStatement := 'do' Statement 'while' '(' Expression ')' ';'

Throws:
  `CompileException`
  `IOException`

### parseTryStatement

public Java.Statement parseTryStatement() throws CompileException, IOException

       TryStatement :=
         'try' Block Catches [ Finally ] |
         'try' Block Finally

       Catches := CatchClause { CatchClause }

       CatchClause := 'catch' '(' FormalParameter ')' Block

       Finally := 'finally' Block

Throws:
  `CompileException`
  `IOException`

### parseSwitchStatement

public Java.Statement parseSwitchStatement() throws CompileException, IOException

       SwitchStatement :=
         'switch' '(' Expression ')' '{' { SwitchLabels BlockStatements } '}'

       SwitchLabels := SwitchLabels { SwitchLabels }

       SwitchLabel := 'case' Expression ':' | 'default' ':'

Throws:
  `CompileException`
  `IOException`

### parseSynchronizedStatement

public Java.Statement parseSynchronizedStatement() throws CompileException, IOException

       SynchronizedStatement :=
         'synchronized' '(' expression ')' Block

Throws:
  `CompileException`
  `IOException`

### parseReturnStatement

public Java.Statement parseReturnStatement() throws CompileException, IOException

       ReturnStatement := 'return' [ Expression ] ';'

Throws:
  `CompileException`
  `IOException`

### parseThrowStatement

public Java.Statement parseThrowStatement() throws CompileException, IOException

       ThrowStatement := 'throw' Expression ';'

Throws:
  `CompileException`
  `IOException`

### parseBreakStatement

public Java.Statement parseBreakStatement() throws CompileException, IOException

       BreakStatement := 'break' [ Identifier ] ';'

Throws:
  `CompileException`
  `IOException`

### parseContinueStatement

public Java.Statement parseContinueStatement() throws CompileException, IOException

       ContinueStatement := 'continue' [ Identifier ] ';'

Throws:
  `CompileException`
  `IOException`

### parseAssertStatement

public Java.Statement parseAssertStatement() throws CompileException, IOException

       AssertStatement := 'assert' Expression [ ':' Expression ] ';'

Throws:
  `CompileException`
  `IOException`

### parseEmptyStatement

public Java.Statement parseEmptyStatement() throws CompileException, IOException

       EmptyStatement := ';'

Throws:
  `CompileException`
  `IOException`

### parseExpressionList

public Java.Rvalue[] parseExpressionList() throws CompileException, IOException

       ExpressionList := Expression { ',' Expression }

Throws:
  `CompileException`
  `IOException`

### parseType

public Java.Type parseType() throws CompileException, IOException

       Type := (
         'byte' | 'short' | 'char' | 'int' | 'long' |
         'float' | 'double' | 'boolean' |
         ReferenceType
       ) { '[' ']' }

Throws:
  `CompileException`
  `IOException`

### parseReferenceType

public Java.ReferenceType parseReferenceType() throws CompileException, IOException

       ReferenceType := { Annotation } QualifiedIdentifier [ TypeArguments ]

Throws:
  `CompileException`
  `IOException`

### parseReferenceTypeList

public Java.ReferenceType[] parseReferenceTypeList() throws CompileException, IOException

       ReferenceTypeList := ReferenceType { ',' ReferenceType }

Throws:
  `CompileException`
  `IOException`

### parseExpression

public Java.Rvalue parseExpression() throws CompileException, IOException

       Expression := AssignmentExpression | LambdaExpression

Notice that all other kinds of lambda expressions are parsed in `parsePrimary()`.

Throws:
  `CompileException`
  `IOException`

### parseExpressionOrType

public Java.Atom parseExpressionOrType() throws CompileException, IOException
Same as `parseExpression()`, but types like `int` or `Map<String, Object>` are also parsed.

Throws:
  `CompileException`
  `IOException`

### parseAssignmentExpression

public Java.Atom parseAssignmentExpression() throws CompileException, IOException

       AssignmentExpression :=
         ConditionalExpression [ AssignmentOperator AssignmentExpression ]

       AssignmentOperator :=
         '=' | '*=' | '/=' | '%=' | '+=' | '-=' | '<<=' |
         '>>=' | '>>>=' | '&=' | '^=' | '|='

Throws:
  `CompileException`
  `IOException`

### parseConditionalExpression

public Java.Atom parseConditionalExpression() throws CompileException, IOException

       ConditionalExpression :=
         ConditionalOrExpression [ '?' Expression ':' ConditionalExpression ]

Throws:
  `CompileException`
  `IOException`

### parseConditionalOrExpression

public Java.Atom parseConditionalOrExpression() throws CompileException, IOException

       ConditionalOrExpression :=
         ConditionalAndExpression { '||' ConditionalAndExpression ]

Throws:
  `CompileException`
  `IOException`

### parseConditionalAndExpression

public Java.Atom parseConditionalAndExpression() throws CompileException, IOException

       ConditionalAndExpression :=
         InclusiveOrExpression { '&&' InclusiveOrExpression }

Throws:
  `CompileException`
  `IOException`

### parseInclusiveOrExpression

public Java.Atom parseInclusiveOrExpression() throws CompileException, IOException

       InclusiveOrExpression :=
         ExclusiveOrExpression { '|' ExclusiveOrExpression }

Throws:
  `CompileException`
  `IOException`

### parseExclusiveOrExpression

public Java.Atom parseExclusiveOrExpression() throws CompileException, IOException

       ExclusiveOrExpression :=
         AndExpression { '^' AndExpression }

Throws:
  `CompileException`
  `IOException`

### parseAndExpression

public Java.Atom parseAndExpression() throws CompileException, IOException

       AndExpression :=
         EqualityExpression { '&' EqualityExpression }

Throws:
  `CompileException`
  `IOException`

### parseEqualityExpression

public Java.Atom parseEqualityExpression() throws CompileException, IOException

       EqualityExpression :=
         RelationalExpression { ( '==' | '!=' ) RelationalExpression }

Throws:
  `CompileException`
  `IOException`

### parseRelationalExpression

public Java.Atom parseRelationalExpression() throws CompileException, IOException

       RelationalExpression :=
         ShiftExpression {
           'instanceof' ReferenceType
           | '<' ShiftExpression [ { ',' TypeArgument } '>' ]
           | '<' TypeArgument [ { ',' TypeArgument } '>' ]
           | ( '>' | '<=' | '>=' ) ShiftExpression
         }

Throws:
  `CompileException`
  `IOException`

### parseShiftExpression

public Java.Atom parseShiftExpression() throws CompileException, IOException

       ShiftExpression :=
         AdditiveExpression { ( '<<' | '>>' | '>>>' ) AdditiveExpression }

Throws:
  `CompileException`
  `IOException`

### parseAdditiveExpression

public Java.Atom parseAdditiveExpression() throws CompileException, IOException

       AdditiveExpression :=
         MultiplicativeExpression { ( '+' | '-' ) MultiplicativeExpression }

Throws:
  `CompileException`
  `IOException`

### parseMultiplicativeExpression

public Java.Atom parseMultiplicativeExpression() throws CompileException, IOException

       MultiplicativeExpression :=
         UnaryExpression { ( '*' | '/' | '%' ) UnaryExpression }

Throws:
  `CompileException`
  `IOException`

### parseUnaryExpression

public Java.Atom parseUnaryExpression() throws CompileException, IOException

       UnaryExpression :=
         { PrefixOperator } Primary { Selector } { PostfixOperator }

       PrefixOperator := '++' | '--' | '+' | '-' | '~' | '!'

       PostfixOperator := '++' | '--'

Throws:
  `CompileException`
  `IOException`

### parsePrimary

public Java.Atom parsePrimary() throws CompileException, IOException

       Primary :=
         CastExpression |                        // CastExpression 15.16
         '(' Expression ')' |                    // ParenthesizedExpression 15.8.5
         Literal |                               // Literal 15.8.1
         Name |                                  // AmbiguousName
         Name Arguments |                        // MethodInvocation
         Name '[]' { '[]' } |                    // ArrayType 10.1
         Name '[]' { '[]' } '.' 'class' |        // ClassLiteral 15.8.2
         'this' |                                // This 15.8.3
         'this' Arguments |                      // Alternate constructor invocation 8.8.5.1
         'super' Arguments |                     // Unqualified superclass constructor invocation 8.8.5.1
         'super' '.' Identifier |                // SuperclassFieldAccess 15.11.2
         'super' '.' Identifier Arguments |      // SuperclassMethodInvocation 15.12.4.9
         NewClassInstance |
         NewAnonymousClassInstance |             // ClassInstanceCreationExpression 15.9
         NewArray |                              // ArrayCreationExpression 15.10
         NewInitializedArray |                   // ArrayInitializer 10.6
         PrimitiveType { '[]' } |                // Type
         PrimitiveType { '[]' } '.' 'class' |    // ClassLiteral 15.8.2
         'void' '.' 'class' |                    // ClassLiteral 15.8.2
         MethodReference                         // MethodReference JLS9 15.13

       Name :=
         Identifier { '.' Identifier }

       CastExpression :=
         '(' PrimitiveType { '[]' } ')' UnaryExpression |
         '(' Expression ')' UnaryExpression

       NewClassInstance := 'new' ReferenceType Arguments

       NewAnonymousClassInstance := 'new' ReferenceType Arguments [ ClassBody ]

       NewArray := 'new' Type DimExprs { '[]' }

       NewInitializedArray := 'new' ArrayType ArrayInitializer

Throws:
  `CompileException`
  `IOException`

### parseSelector

public Java.Atom parseSelector(Java.Atom atom) throws CompileException, IOException

       Selector :=
         '.' Identifier |                                // FieldAccess 15.11.1
         '.' Identifier Arguments |                      // MethodInvocation
         '.' '<' TypeList '>' 'super' Arguments                  // Superconstructor invocation (?)
         '.' '<' TypeList '>' 'super' '.' . Identifier           // ???
         '.' '<' TypeList '>' 'super' '.' . Identifier Arguments // Supermethod invocation
         '.' '<' TypeList '>' Identifier Arguments // ExplicitGenericInvocation
         '.' 'this'                                      // QualifiedThis 15.8.4
         '.' 'super' Arguments                           // Qualified superclass constructor invocation (JLS7 8.8.7.1)
         '.' 'super' '.' Identifier |                    // SuperclassFieldReference (JLS7 15.11.2)
         '.' 'super' '.' Identifier Arguments |          // SuperclassMethodInvocation (JLS7 15.12.3)
         '.' 'new' Identifier Arguments [ ClassBody ] |  // QualifiedClassInstanceCreationExpression  15.9
         '.' 'class'
         '[' Expression ']'                              // ArrayAccessExpression 15.13

       ExplicitGenericInvocationSuffix :=
         'super' SuperSuffix
         | Identifier Arguments

Throws:
  `CompileException`
  `IOException`

### parseDimExprs

public Java.Rvalue[] parseDimExprs() throws CompileException, IOException

       DimExprs := DimExpr { DimExpr }

Throws:
  `CompileException`
  `IOException`

### parseDimExpr

public Java.Rvalue parseDimExpr() throws CompileException, IOException

       DimExpr := '[' Expression ']'

Throws:
  `CompileException`
  `IOException`

### parseArguments

public Java.Rvalue[] parseArguments() throws CompileException, IOException

       Arguments := '(' [ ArgumentList ] ')'

Throws:
  `CompileException`
  `IOException`

### parseArgumentList

public Java.Rvalue[] parseArgumentList() throws CompileException, IOException

       ArgumentList := Expression { ',' Expression }

Throws:
  `CompileException`
  `IOException`

### parseLiteral

public Java.Rvalue parseLiteral() throws CompileException, IOException

       Literal :=
         IntegerLiteral
         | FloatingPointLiteral
         | BooleanLiteral
         | CharacterLiteral
         | StringLiteral
         | NullLiteral

Throws:
  `CompileException`
  `IOException`

### parseExpressionStatement

public Java.Statement parseExpressionStatement() throws CompileException, IOException

       ExpressionStatement := Expression ';'

Throws:
  `CompileException`
  `IOException`

### location

public Location location()

Returns:
  The location of the first character of the previously read (not peeked!) token

### peek

public Token peek() throws CompileException, IOException

Throws:
  `CompileException`
  `IOException`

### read

public Token read() throws CompileException, IOException

Throws:
  `CompileException`
  `IOException`

### peek

public boolean peek(String suspected) throws CompileException, IOException

Throws:
  `CompileException`
  `IOException`

### peek

public int peek(String... suspected) throws CompileException, IOException

Throws:
  `CompileException`
  `IOException`

### peek

public boolean peek(TokenType suspected) throws CompileException, IOException

Throws:
  `CompileException`
  `IOException`

### peek

public int peek(TokenType... suspected) throws CompileException, IOException

Throws:
  `CompileException`
  `IOException`

### peekNextButOne

public Token peekNextButOne() throws CompileException, IOException

Throws:
  `CompileException`
  `IOException`

### peekNextButOne

public boolean peekNextButOne(String suspected) throws CompileException, IOException

Throws:
  `CompileException`
  `IOException`

### peekNextButOne

public boolean peekNextButOne(TokenType suspected) throws CompileException, IOException

Throws:
  `CompileException`
  `IOException`

### read

public void read(String expected) throws CompileException, IOException

Throws:
  `CompileException`
  `IOException`

### read

public int read(String... expected) throws CompileException, IOException

Throws:
  `CompileException`
  `IOException`

### read

public String read(TokenType expected) throws CompileException, IOException

Throws:
  `CompileException`
  `IOException`

### peekRead

public boolean peekRead(String suspected) throws CompileException, IOException

Throws:
  `CompileException`
  `IOException`

### peekRead

public int peekRead(String... suspected) throws CompileException, IOException

Throws:
  `CompileException`
  `IOException`

### peekRead

@Nullable public String peekRead(TokenType suspected) throws CompileException, IOException

Throws:
  `CompileException`
  `IOException`

### setSourceVersion

public void setSourceVersion(int version)

### setWarningHandler

public void setWarningHandler(@Nullable WarningHandler warningHandler)
By default, warnings are discarded, but an application my install a `WarningHandler`.

Notice that there is no `Parser.setErrorHandler()` method, but parse errors always throw a `CompileException`. The reason being is that there is no reasonable way to recover from parse errors and continue parsing, so there is no need to install a custom parse error handler.

Parameters:
  `warningHandler` - `null` to indicate that no warnings be issued

### compileException

protected final CompileException compileException(String message)
Convenience method for throwing a `CompileException`.

### compileException

protected static CompileException compileException(String message, Location location)
Convenience method for throwing a `CompileException`.