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

```
public class Parser
extends java.lang.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 class`	`Parser.ClassDeclarationContext`	The kinds of context where a class declaration can occur.
`static class`	`Parser.InterfaceDeclarationContext`	The kinds of context where an interface declaration can occur.
`static class`	`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

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`protected CompileException`	`compileException(java.lang.String message)`	Convenience method for throwing a `CompileException`.
`protected static CompileException`	`compileException(java.lang.String message, Location location)`	Convenience method for throwing a `CompileException`.
`java.lang.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(java.lang.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' ... \| (2) Modifiers Type VariableDeclarators ';' \| Expression ';' \| Expression BracketsOpt VariableDeclarators ';' (3)
`java.util.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(java.lang.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 [ '?'
`Java.Atom`	`parseConditionalOrExpression()`	ConditionalOrExpression := ConditionalAndExpression { '\|\|' ConditionalAndExpression ]
`Java.ConstructorDeclarator`	`parseConstructorDeclarator(java.lang.String docComment, Java.Modifier[] modifiers)`	ConstructorDeclarator := Identifier FormalParameters [ 'throws' ReferenceTypeList ] '{' [ 'this' Arguments ';' \| 'super' Arguments ';' \| Primary '.'
`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(java.lang.String docComment, Java.Modifier[] modifiers, Parser.ClassDeclarationContext context)`	EnumDeclarationRest := Identifier [ 'implements' ReferenceTypeList ] EnumBody
`Java.Atom`	`parseEqualityExpression()`	EqualityExpression := 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(java.lang.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 { '.'
`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(java.lang.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(java.lang.String docComment, Java.Modifier[] modifiers, Java.TypeParameter[] typeParameters, Java.Type type, java.lang.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(java.lang.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 '[]' { '[]' } '.'
`java.lang.String[]`	`parseQualifiedIdentifier()`	QualifiedIdentifier := 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 := '.'
`Java.Atom`	`parseShiftExpression()`	ShiftExpression := AdditiveExpression { ( '<<' \| '>>' \| '>>>' ) AdditiveExpression }
`Java.Statement`	`parseStatement()`	Statement := LabeledStatement \| Block \| IfStatement \| ForStatement \| WhileStatement \| DoStatement \| TryStatement \| 'switch' ... \| 'synchronized' ... \| ReturnStatement \| ThrowStatement \| BreakStatement \| ContinueStatement \| EmptyStatement \| ExpressionStatement
`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 := '++' \| '--' \| '+' \| '-' \| '~' \| '!'
`Java.VariableDeclarator`	`parseVariableDeclarator()`	VariableDeclarator := Identifier VariableDeclaratorRest
`Java.VariableDeclarator`	`parseVariableDeclaratorRest(java.lang.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(java.lang.String suspected)`
`int`	`peek(java.lang.String... suspected)`
`boolean`	`peek(TokenType suspected)`
`int`	`peek(TokenType... suspected)`
`Token`	`peekNextButOne()`
`boolean`	`peekNextButOne(java.lang.String suspected)`
`boolean`	`peekNextButOne(TokenType suspected)`
`boolean`	`peekRead(java.lang.String suspected)`
`int`	`peekRead(java.lang.String... suspected)`
`java.lang.String`	`peekRead(TokenType suspected)`
`Token`	`read()`
`void`	`read(java.lang.String expected)`
`int`	`read(java.lang.String... expected)`
`java.lang.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 Detail

Parser
```
public Parser(Scanner scanner)
```

Parser

public Parser(Scanner scanner,
              TokenStream tokenStream)

Method Detail

doc
```
@Nullable
public java.lang.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,
                                                                 java.io.IOException

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

Throws:: CompileException; java.io.IOException

parseModuleDeclarationRest

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

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

Throws:: CompileException; java.io.IOException

parsePackageDeclaration

public Java.PackageDeclaration parsePackageDeclaration()
                                                throws CompileException,
                                                       java.io.IOException

   PackageDeclaration := 'package' QualifiedIdentifier ';'

Throws:: CompileException; java.io.IOException

parsePackageDeclarationRest

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

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

Throws:: CompileException; java.io.IOException

parseImportDeclaration

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

   ImportDeclaration := 'import' ImportDeclarationBody ';'

Throws:: CompileException; java.io.IOException

parseImportDeclarationBody

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

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

Throws:: CompileException; java.io.IOException

parseQualifiedIdentifier

public java.lang.String[] parseQualifiedIdentifier()
                                            throws CompileException,
                                                   java.io.IOException

   QualifiedIdentifier := Identifier { '.' Identifier }

Throws:: CompileException; java.io.IOException

parsePackageMemberTypeDeclaration

public Java.PackageMemberTypeDeclaration parsePackageMemberTypeDeclaration()
                                                                    throws CompileException,
                                                                           java.io.IOException

   PackageMemberTypeDeclaration := ModifiersOpt PackageMemberTypeDeclarationRest

Throws:: CompileException; java.io.IOException

parseModifiers

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

   Modifiers := { Modifier }

Includes the case "no modifiers".

Throws:: CompileException; java.io.IOException

parseOptionalModifier

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

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

Throws:: CompileException; java.io.IOException

parseClassDeclarationRest

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

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

Throws:: CompileException; java.io.IOException

parseEnumDeclarationRest

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

   EnumDeclarationRest := Identifier [ 'implements' ReferenceTypeList ] EnumBody

Throws:: CompileException; java.io.IOException

parseClassBody

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

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

Throws:: CompileException; java.io.IOException

parseEnumBody

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

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

Throws:: CompileException; java.io.IOException

parseEnumConstant

public Java.EnumConstant parseEnumConstant()
                                    throws CompileException,
                                           java.io.IOException

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

Throws:: CompileException; java.io.IOException

parseClassBodyDeclaration

public void parseClassBodyDeclaration(Java.AbstractClassDeclaration classDeclaration)
                               throws CompileException,
                                      java.io.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; java.io.IOException

parseInterfaceDeclarationRest

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

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

Throws:: CompileException; java.io.IOException

parseAnnotationTypeDeclarationRest

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

   AnnotationTypeDeclarationRest := Identifier AnnotationTypeBody

Throws:: CompileException; java.io.IOException

parseInterfaceBody

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

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

Throws:: CompileException; java.io.IOException

parseConstructorDeclarator

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

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

Throws:: CompileException; java.io.IOException

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

Throws:

CompileException

java.io.IOException

See Also:

parseMethodDeclaration(boolean, MethodDeclarationContext)

parseMethodDeclaration

public Java.MethodDeclarator parseMethodDeclaration(boolean allowDefaultClause,
                                                    Parser.MethodDeclarationContext context)
                                             throws CompileException,
                                                    java.io.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; java.io.IOException

parseVoidOrType

public Java.Type parseVoidOrType()
                          throws CompileException,
                                 java.io.IOException

   VoidOrType := 'void' | Type

Throws:: CompileException; java.io.IOException

parseMethodDeclarationRest

public Java.MethodDeclarator parseMethodDeclarationRest(@Nullable
                                                        java.lang.String docComment,
                                                        Java.Modifier[] modifiers,
                                                        @Nullable
                                                        Java.TypeParameter[] typeParameters,
                                                        Java.Type type,
                                                        java.lang.String name,
                                                        boolean allowDefaultClause,
                                                        Parser.MethodDeclarationContext context)
                                                 throws CompileException,
                                                        java.io.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; java.io.IOException

parseVariableInitializer

public Java.ArrayInitializerOrRvalue parseVariableInitializer()
                                                       throws CompileException,
                                                              java.io.IOException

   VariableInitializer :=
     ArrayInitializer |
     Expression

Throws:: CompileException; java.io.IOException

parseArrayInitializer

public Java.ArrayInitializer parseArrayInitializer()
                                            throws CompileException,
                                                   java.io.IOException

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

Throws:: CompileException; java.io.IOException

parseFormalParameters

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

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

Throws:: CompileException; java.io.IOException

parseFormalParameterList

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

   FormalParameterList := FormalParameter { ',' FormalParameter }

Throws:: CompileException; java.io.IOException

parseFormalParameterListRest

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

   FormalParameterListRest := Identifier { ',' FormalParameter }

Throws:: CompileException; java.io.IOException

parseFormalParameter

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

   FormalParameter := [ 'final' ] Type FormalParameterRest

Throws:: CompileException; java.io.IOException

parseFormalParameterRest

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

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

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

parseCatchParameter

public Java.CatchParameter parseCatchParameter()
                                        throws CompileException,
                                               java.io.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; java.io.IOException

parseMethodBody

public Java.Block parseMethodBody()
                           throws CompileException,
                                  java.io.IOException

   MethodBody := Block

Throws:: CompileException; java.io.IOException

parseBlock

public Java.Block parseBlock()
                      throws CompileException,
                             java.io.IOException

   Block := '{' BlockStatements '}'

Throws:: CompileException; java.io.IOException

parseBlockStatements

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

   BlockStatements := { BlockStatement }

Throws:: CompileException; java.io.IOException

parseBlockStatement

public Java.BlockStatement parseBlockStatement()
                                        throws CompileException,
                                               java.io.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; java.io.IOException

parseVariableDeclarators

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

   VariableDeclarators := VariableDeclarator { ',' VariableDeclarator }

Throws:: CompileException; java.io.IOException

parseFieldDeclarationRest

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

   FieldDeclarationRest :=
     VariableDeclaratorRest
     { ',' VariableDeclarator }

Throws:: CompileException; java.io.IOException

parseVariableDeclarator

public Java.VariableDeclarator parseVariableDeclarator()
                                                throws CompileException,
                                                       java.io.IOException

   VariableDeclarator := Identifier VariableDeclaratorRest

Throws:: CompileException; java.io.IOException

parseVariableDeclaratorRest

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

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

Used by field declarations and local variable declarations.

Throws:: CompileException; java.io.IOException

parseStatement

public Java.Statement parseStatement()
                              throws CompileException,
                                     java.io.IOException

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

Throws:: CompileException; java.io.IOException

parseLabeledStatement

public Java.Statement parseLabeledStatement()
                                     throws CompileException,
                                            java.io.IOException

   LabeledStatement := Identifier ':' Statement

Throws:: CompileException; java.io.IOException

parseIfStatement

public Java.Statement parseIfStatement()
                                throws CompileException,
                                       java.io.IOException

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

Throws:: CompileException; java.io.IOException

parseForStatement

public Java.Statement parseForStatement()
                                 throws CompileException,
                                        java.io.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; java.io.IOException

parseWhileStatement

public Java.Statement parseWhileStatement()
                                   throws CompileException,
                                          java.io.IOException

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

Throws:: CompileException; java.io.IOException

parseDoStatement

public Java.Statement parseDoStatement()
                                throws CompileException,
                                       java.io.IOException

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

Throws:: CompileException; java.io.IOException

parseTryStatement

public Java.Statement parseTryStatement()
                                 throws CompileException,
                                        java.io.IOException

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

   Catches := CatchClause { CatchClause }

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

   Finally := 'finally' Block

Throws:: CompileException; java.io.IOException

parseSwitchStatement

public Java.Statement parseSwitchStatement()
                                    throws CompileException,
                                           java.io.IOException

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

   SwitchLabels := SwitchLabels { SwitchLabels }

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

Throws:: CompileException; java.io.IOException

parseSynchronizedStatement

public Java.Statement parseSynchronizedStatement()
                                          throws CompileException,
                                                 java.io.IOException

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

Throws:: CompileException; java.io.IOException

parseReturnStatement

public Java.Statement parseReturnStatement()
                                    throws CompileException,
                                           java.io.IOException

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

Throws:: CompileException; java.io.IOException

parseThrowStatement

public Java.Statement parseThrowStatement()
                                   throws CompileException,
                                          java.io.IOException

   ThrowStatement := 'throw' Expression ';'

Throws:: CompileException; java.io.IOException

parseBreakStatement

public Java.Statement parseBreakStatement()
                                   throws CompileException,
                                          java.io.IOException

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

Throws:: CompileException; java.io.IOException

parseContinueStatement

public Java.Statement parseContinueStatement()
                                      throws CompileException,
                                             java.io.IOException

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

Throws:: CompileException; java.io.IOException

parseAssertStatement

public Java.Statement parseAssertStatement()
                                    throws CompileException,
                                           java.io.IOException

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

Throws:: CompileException; java.io.IOException

parseEmptyStatement

public Java.Statement parseEmptyStatement()
                                   throws CompileException,
                                          java.io.IOException

   EmptyStatement := ';'

Throws:: CompileException; java.io.IOException

parseExpressionList

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

   ExpressionList := Expression { ',' Expression }

Throws:: CompileException; java.io.IOException

parseType

public Java.Type parseType()
                    throws CompileException,
                           java.io.IOException

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

Throws:: CompileException; java.io.IOException

parseReferenceType

public Java.ReferenceType parseReferenceType()
                                      throws CompileException,
                                             java.io.IOException

   ReferenceType := { Annotation } QualifiedIdentifier [ TypeArguments ]

Throws:: CompileException; java.io.IOException

parseReferenceTypeList

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

   ReferenceTypeList := ReferenceType { ',' ReferenceType }

Throws:: CompileException; java.io.IOException

parseExpression

public Java.Rvalue parseExpression()
                            throws CompileException,
                                   java.io.IOException

   Expression := AssignmentExpression | LambdaExpression

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

Throws:: CompileException; java.io.IOException

parseExpressionOrType

public Java.Atom parseExpressionOrType()
                                throws CompileException,
                                       java.io.IOException

Same as parseExpression(), but types like int or Map<String, Object> are also parsed.

Throws:: CompileException; java.io.IOException

parseAssignmentExpression

public Java.Atom parseAssignmentExpression()
                                    throws CompileException,
                                           java.io.IOException

   AssignmentExpression :=
     ConditionalExpression [ AssignmentOperator AssignmentExpression ]

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

Throws:: CompileException; java.io.IOException

parseConditionalExpression

public Java.Atom parseConditionalExpression()
                                     throws CompileException,
                                            java.io.IOException

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

Throws:: CompileException; java.io.IOException

parseConditionalOrExpression

public Java.Atom parseConditionalOrExpression()
                                       throws CompileException,
                                              java.io.IOException

   ConditionalOrExpression :=
     ConditionalAndExpression { '||' ConditionalAndExpression ]

Throws:: CompileException; java.io.IOException

parseConditionalAndExpression

public Java.Atom parseConditionalAndExpression()
                                        throws CompileException,
                                               java.io.IOException

   ConditionalAndExpression :=
     InclusiveOrExpression { '&&' InclusiveOrExpression }

Throws:: CompileException; java.io.IOException

parseInclusiveOrExpression

public Java.Atom parseInclusiveOrExpression()
                                     throws CompileException,
                                            java.io.IOException

   InclusiveOrExpression :=
     ExclusiveOrExpression { '|' ExclusiveOrExpression }

Throws:: CompileException; java.io.IOException

parseExclusiveOrExpression

public Java.Atom parseExclusiveOrExpression()
                                     throws CompileException,
                                            java.io.IOException

   ExclusiveOrExpression :=
     AndExpression { '^' AndExpression }

Throws:: CompileException; java.io.IOException

parseAndExpression

public Java.Atom parseAndExpression()
                             throws CompileException,
                                    java.io.IOException

   AndExpression :=
     EqualityExpression { '&' EqualityExpression }

Throws:: CompileException; java.io.IOException

parseEqualityExpression

public Java.Atom parseEqualityExpression()
                                  throws CompileException,
                                         java.io.IOException

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

Throws:: CompileException; java.io.IOException

parseRelationalExpression

public Java.Atom parseRelationalExpression()
                                    throws CompileException,
                                           java.io.IOException

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

Throws:: CompileException; java.io.IOException

parseShiftExpression

public Java.Atom parseShiftExpression()
                               throws CompileException,
                                      java.io.IOException

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

Throws:: CompileException; java.io.IOException

parseAdditiveExpression

public Java.Atom parseAdditiveExpression()
                                  throws CompileException,
                                         java.io.IOException

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

Throws:: CompileException; java.io.IOException

parseMultiplicativeExpression

public Java.Atom parseMultiplicativeExpression()
                                        throws CompileException,
                                               java.io.IOException

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

Throws:: CompileException; java.io.IOException

parseUnaryExpression

public Java.Atom parseUnaryExpression()
                               throws CompileException,
                                      java.io.IOException

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

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

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

Throws:: CompileException; java.io.IOException

parsePrimary

public Java.Atom parsePrimary()
                       throws CompileException,
                              java.io.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; java.io.IOException

parseSelector

public Java.Atom parseSelector(Java.Atom atom)
                        throws CompileException,
                               java.io.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; java.io.IOException

parseDimExprs

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

   DimExprs := DimExpr { DimExpr }

Throws:: CompileException; java.io.IOException

parseDimExpr

public Java.Rvalue parseDimExpr()
                         throws CompileException,
                                java.io.IOException

   DimExpr := '[' Expression ']'

Throws:: CompileException; java.io.IOException

parseArguments

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

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

Throws:: CompileException; java.io.IOException

parseArgumentList

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

   ArgumentList := Expression { ',' Expression }

Throws:: CompileException; java.io.IOException

parseLiteral

public Java.Rvalue parseLiteral()
                         throws CompileException,
                                java.io.IOException

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

Throws:: CompileException; java.io.IOException

parseExpressionStatement

public Java.Statement parseExpressionStatement()
                                        throws CompileException,
                                               java.io.IOException

   ExpressionStatement := Expression ';'

Throws:: CompileException; java.io.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,
                  java.io.IOException

Throws:: CompileException; java.io.IOException

read

public Token read()
           throws CompileException,
                  java.io.IOException

Throws:: CompileException; java.io.IOException

peek

public boolean peek(java.lang.String suspected)
             throws CompileException,
                    java.io.IOException

Throws:: CompileException; java.io.IOException

peek

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

Throws:: CompileException; java.io.IOException

peek

public boolean peek(TokenType suspected)
             throws CompileException,
                    java.io.IOException

Throws:: CompileException; java.io.IOException

peek

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

Throws:: CompileException; java.io.IOException

peekNextButOne

public Token peekNextButOne()
                     throws CompileException,
                            java.io.IOException

Throws:: CompileException; java.io.IOException

peekNextButOne

public boolean peekNextButOne(java.lang.String suspected)
                       throws CompileException,
                              java.io.IOException

Throws:: CompileException; java.io.IOException

peekNextButOne

public boolean peekNextButOne(TokenType suspected)
                       throws CompileException,
                              java.io.IOException

Throws:: CompileException; java.io.IOException

read

public void read(java.lang.String expected)
          throws CompileException,
                 java.io.IOException

Throws:: CompileException; java.io.IOException

read

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

Throws:: CompileException; java.io.IOException

read

public java.lang.String read(TokenType expected)
                      throws CompileException,
                             java.io.IOException

Throws:: CompileException; java.io.IOException

peekRead

public boolean peekRead(java.lang.String suspected)
                 throws CompileException,
                        java.io.IOException

Throws:: CompileException; java.io.IOException

peekRead

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

Throws:: CompileException; java.io.IOException

peekRead

@Nullable
public java.lang.String peekRead(TokenType suspected)
                          throws CompileException,
                                 java.io.IOException

Throws:: CompileException; java.io.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(java.lang.String message)

Convenience method for throwing a CompileException.

compileException

protected static CompileException compileException(java.lang.String message,
                                                   Location location)

Convenience method for throwing a CompileException.

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

Class Parser

Nested Class Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

Parser

Parser

Method Detail

doc

getScanner

parseAbstractCompilationUnit

parseModuleDeclarationRest

parsePackageDeclaration

parsePackageDeclarationRest

parseImportDeclaration

parseImportDeclarationBody

parseQualifiedIdentifier

parsePackageMemberTypeDeclaration

parseModifiers

parseOptionalModifier

parseClassDeclarationRest

parseEnumDeclarationRest

parseClassBody

parseEnumBody

parseEnumConstant

parseClassBodyDeclaration

parseInterfaceDeclarationRest

parseAnnotationTypeDeclarationRest

parseInterfaceBody

parseConstructorDeclarator

parseMethodDeclaration

parseMethodDeclaration

parseVoidOrType

parseMethodDeclarationRest

parseVariableInitializer

parseArrayInitializer

parseFormalParameters

parseFormalParameterList

parseFormalParameterListRest

parseFormalParameter

parseFormalParameterRest

parseCatchParameter

parseMethodBody

parseBlock

parseBlockStatements

parseBlockStatement

parseVariableDeclarators

parseFieldDeclarationRest

parseVariableDeclarator

parseVariableDeclaratorRest

parseStatement

parseLabeledStatement

parseIfStatement

parseForStatement

parseWhileStatement

parseDoStatement

parseTryStatement

parseSwitchStatement

parseSynchronizedStatement

parseReturnStatement

parseThrowStatement

parseBreakStatement

parseContinueStatement

parseAssertStatement

parseEmptyStatement

parseExpressionList

parseType

parseReferenceType

parseReferenceTypeList

parseExpression

parseExpressionOrType

parseAssignmentExpression

parseConditionalExpression

parseConditionalOrExpression

parseConditionalAndExpression

parseInclusiveOrExpression

parseExclusiveOrExpression

parseAndExpression

parseEqualityExpression