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.

Field Summary

Fields

Modifier and Type	Field	Description
private static final String[]	ACCESS_MODIFIER_KEYWORDS
private String	docComment	The optional JAVADOC comment preceding the invalid reference #nextToken .
private static final List<Set<String>>	MUTUALLY_EXCLUSIVE_ACCESS_MODIFIERS
private boolean	preferParametrizedTypes
private final Scanner	scanner
private int	sourceVersion
private final TokenStream	tokenStream
private WarningHandler	warningHandler

Constructor Summary

Constructors

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

Method Summary

Modifier and Type	Method	Description
private Java.Modifier[]	annotationTypeElementModifiers(Java.Modifier[] modifiers)
private Java.Modifier[]	checkModifiers(Java.Modifier[] modifiers, String... allowedKeywords)	Verifies that the modifiers are consistent.
private Java.Modifier[]	classModifiers(Java.Modifier[] modifiers)
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.
private Java.Modifier[]	constantModifiers(Java.Modifier[] modifiers)
private Java.Modifier[]	constructorModifiers(Java.Modifier[] modifiers)
String	doc()	Gets the text of the doc comment (a.k.a.
private Java.Modifier[]	enumConstantModifiers(Java.Modifier[] modifiers)
private Java.Modifier[]	fieldModifiers(Java.Modifier[] modifiers)
Scanner	getScanner()
private int	getSourceVersion()
private static boolean	hasAccessModifier(Java.Modifier[] modifiers, String... keywords)
private static boolean	hasAccessModifierOtherThan(Java.Modifier[] modifiers, String... keywords)
private Java.Modifier[]	interfaceMethodModifiers(Java.Modifier[] modifiers)
private Java.Modifier[]	interfaceModifiers(Java.Modifier[] modifiers)
private static String	join(String[] sa, String separator)
Location	location()
private Java.Modifier[]	methodModifiers(Java.Modifier[] modifiers)
private Java.Modifier[]	packageMemberClassModifiers(Java.Modifier[] modifiers)
private Java.Modifier[]	packageMemberInterfaceModifiers(Java.Modifier[] modifiers)
private Java.Modifier[]	packageModifiers(Java.Modifier[] modifiers)
Java.AbstractCompilationUnit	parseAbstractCompilationUnit()	CompilationUnit := [ PackageDeclaration ] { ImportDeclaration } { TypeDeclaration }
Java.Atom	parseAdditiveExpression()	AdditiveExpression := MultiplicativeExpression { ( '+' | '-' ) MultiplicativeExpression }
Java.Atom	parseAndExpression()	AndExpression := EqualityExpression { '&' EqualityExpression }
private Java.Annotation	parseAnnotation()	Annotation := MarkerAnnotation // JLS7 9.7.2 | SingleElementAnnotation // JLS7 9.7.3 | NormalAnnotation // JLS7 9.7.1 MarkerAnnotation := '@' Identifier SingleElementAnnotation := '@' Identifier '(' ElementValue ')' NormalAnnotation := '@' TypeName '(' ElementValuePairsOpt ')' ElementValuePairsOpt := [ ElementValuePair { ',' ElementValuePair } ]
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 }
(package private) int	parseBracketsOpt()	BracketsOpt := { '[' ']' }
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 ')' ';'
private Java.ElementValue	parseElementValue()	ElementValue := ConditionalExpression | Annotation | ElementValueArrayInitializer
private Java.ElementValue	parseElementValueArrayInitializer()	ElementValueArrayInitializer := '{' { ElementValue | ',' } '}'
private Java.ElementValuePair	parseElementValuePair()	ElementValuePair := Identifier '=' ElementValue
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
private Java.LambdaBody	parseLambdaBody()	LambdaBody :=
private Java.LambdaExpression	parseLambdaExpression()	LambdaExpression := LambdaParameters '->' LambdaBody
private Java.LambdaParameters	parseLambdaParameters()	LambdaParameters := Identifier | '(' [ FormalParameterList ] ')' | '(' InferredFormalParameterList ')'
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
private Java.PackageMemberTypeDeclaration	parsePackageMemberTypeDeclarationRest(String docComment, Java.Modifier[] modifiers)	PackageMemberTypeDeclarationRest := 'class' ClassDeclarationRest | 'enum' EnumDeclarationRest | 'interface' InterfaceDeclarationRest '@' 'interface' AnnotationTypeDeclarationRest
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 }
private Java.TryStatement.Resource	parseResource()	Resource := Modifiers Type VariableDeclarator | VariableAccess
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 ) { '[' ']' }
private Java.TypeArgument	parseTypeArgument()	TypeArgument := ReferenceType { '[' ']' } <= The optional brackets are missing in JLS7, section 18!? | PrimitiveType '[' ']' { '[' ']' } | '?' extends ReferenceType | '?' super ReferenceType
private Java.TypeArgument[]	parseTypeArgumentsOpt()	TypeArguments := 'invalid input: '<'' [ TypeArgument { ',' TypeArgument } ] '>'
private Java.TypeParameter	parseTypeParameter()	TypeParameter := identifier [ 'extends' ( identifier | ReferenceType { 'invalid input: '&'' ReferenceType }
private Java.TypeParameter[]	parseTypeParametersOpt()	TypeParameters := 'invalid input: '<'' TypeParameter { ',' TypeParameter } '>'
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)
private boolean	peekLiteral()
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.
private Java.Modifier[]	variableModifiers(Java.Modifier[] modifiers)
private void	verifyIdentifierIsConventionalClassOrInterfaceName(String id, Location loc)	Issues a warning if the given identifier does not comply with the class and interface type naming conventions (JLS7 6.8.2).
private void	verifyIdentifierIsConventionalFieldName(String id, Location loc)	Issues a warning if the given identifier does not comply with the field naming conventions (JLS7 6.8.4) and constant naming conventions (JLS7 6.8.5).
private void	verifyIdentifierIsConventionalLocalVariableOrParameterName(String id, Location loc)	Issues a warning if the given identifier does not comply with the local variable and parameter naming conventions (JLS7 6.8.6).
private void	verifyIdentifierIsConventionalMethodName(String id, Location loc)	Issues a warning if the given identifier does not comply with the method naming conventions (JLS7 6.8.3).
private void	verifyStringIsConventionalPackageName(String s, Location loc)	Issues a warning if the given string does not comply with the package naming conventions.
private void	warning(String handle, String message)
private void	warning(String handle, String message, Location location)	Issues a warning with the given message and location and returns.

Methods inherited from class Object

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

Field Details

scanner

private final Scanner scanner

tokenStream

private final TokenStream tokenStream

docComment

@Nullable
private String docComment

The optional JAVADOC comment preceding the

invalid reference

#nextToken

.

ACCESS_MODIFIER_KEYWORDS

private static final String[] ACCESS_MODIFIER_KEYWORDS

preferParametrizedTypes

private boolean preferParametrizedTypes

sourceVersion

private int sourceVersion

warningHandler

@Nullable
private WarningHandler warningHandler

MUTUALLY_EXCLUSIVE_ACCESS_MODIFIERS

private static final List<Set<String>> MUTUALLY_EXCLUSIVE_ACCESS_MODIFIERS

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

parsePackageMemberTypeDeclarationRest

private Java.PackageMemberTypeDeclaration parsePackageMemberTypeDeclarationRest(@Nullable
 String docComment,
 Java.Modifier[] modifiers)
                                                                         throws CompileException,
IOException

  PackageMemberTypeDeclarationRest :=
            'class' ClassDeclarationRest |
            'enum' EnumDeclarationRest |
            'interface' InterfaceDeclarationRest
            '@' 'interface' AnnotationTypeDeclarationRest

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

parseAnnotation

private Java.Annotation parseAnnotation()
                                 throws CompileException,
IOException

  Annotation :=
          MarkerAnnotation             // JLS7 9.7.2
          | SingleElementAnnotation    // JLS7 9.7.3
          | NormalAnnotation           // JLS7 9.7.1

  MarkerAnnotation        := '@' Identifier

  SingleElementAnnotation := '@' Identifier '(' ElementValue ')'

  NormalAnnotation        := '@' TypeName '(' ElementValuePairsOpt ')'

  ElementValuePairsOpt    := [ ElementValuePair { ',' ElementValuePair } ]

Throws:

CompileException

IOException

parseElementValuePair

private Java.ElementValuePair parseElementValuePair()
                                             throws CompileException,
IOException

  ElementValuePair := Identifier '=' ElementValue

Throws:

CompileException

IOException

parseElementValue

private Java.ElementValue parseElementValue()
                                     throws CompileException,
IOException

  ElementValue :=
          ConditionalExpression
          | Annotation
          | ElementValueArrayInitializer

Throws:

CompileException

IOException

parseElementValueArrayInitializer

private Java.ElementValue parseElementValueArrayInitializer()
                                                     throws CompileException,
IOException

  ElementValueArrayInitializer := '{' { ElementValue | ',' } '}'

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

getSourceVersion

private int getSourceVersion()

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

parseBracketsOpt

int parseBracketsOpt()
              throws CompileException,
IOException

  BracketsOpt := { '[' ']' }

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

parseResource

private Java.TryStatement.Resource parseResource()
                                          throws CompileException,
IOException

Resource :=
    Modifiers Type VariableDeclarator
    | VariableAccess

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

parseTypeParametersOpt

@Nullable
private Java.TypeParameter[] parseTypeParametersOpt()
                                             throws CompileException,
IOException

  TypeParameters := 'invalid input: '<'' TypeParameter { ',' TypeParameter } '>'

Throws:

CompileException

IOException

parseTypeParameter

private Java.TypeParameter parseTypeParameter()
                                       throws CompileException,
IOException

  TypeParameter := identifier [ 'extends' ( identifier | ReferenceType { 'invalid input: '&'' ReferenceType }

Throws:

CompileException

IOException

parseTypeArgumentsOpt

@Nullable
private Java.TypeArgument[] parseTypeArgumentsOpt()
                                           throws CompileException,
IOException

  TypeArguments := 'invalid input: '<'' [ TypeArgument { ',' TypeArgument } ] '>'

Returns:

null iff there are no type arguments

Throws:

CompileException

IOException

parseTypeArgument

private Java.TypeArgument parseTypeArgument()
                                     throws CompileException,
IOException

  TypeArgument :=
    ReferenceType { '[' ']' }    <= The optional brackets are missing in JLS7, section 18!?
    | PrimitiveType '[' ']' { '[' ']' }
    | '?' extends ReferenceType
    | '?' super ReferenceType

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

parseLambdaExpression

private Java.LambdaExpression parseLambdaExpression()
                                             throws CompileException,
IOException

  LambdaExpression := LambdaParameters '->' LambdaBody

Throws:

CompileException

IOException

parseLambdaParameters

private Java.LambdaParameters parseLambdaParameters()
                                             throws CompileException,
IOException

  LambdaParameters :=
      Identifier
      | '(' [ FormalParameterList ] ')'
      | '(' InferredFormalParameterList ')'

Throws:

CompileException

IOException

parseLambdaBody

private Java.LambdaBody parseLambdaBody()
                                 throws CompileException,
IOException

  LambdaBody :=

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

peekLiteral

private boolean peekLiteral()
                     throws CompileException,
IOException

Throws:

CompileException

IOException

verifyStringIsConventionalPackageName

private void verifyStringIsConventionalPackageName(String s,
 Location loc)
                                            throws CompileException

Issues a warning if the given string does not comply with the package naming conventions.

Throws:

CompileException

verifyIdentifierIsConventionalClassOrInterfaceName

private void verifyIdentifierIsConventionalClassOrInterfaceName(String id,
 Location loc)
                                                         throws CompileException

Issues a warning if the given identifier does not comply with the class and interface type naming conventions (JLS7 6.8.2).

Throws:

CompileException

verifyIdentifierIsConventionalMethodName

private void verifyIdentifierIsConventionalMethodName(String id,
 Location loc)
                                               throws CompileException

Issues a warning if the given identifier does not comply with the method naming conventions (JLS7 6.8.3).

Throws:

CompileException

verifyIdentifierIsConventionalFieldName

private void verifyIdentifierIsConventionalFieldName(String id,
 Location loc)
                                              throws CompileException

Issues a warning if the given identifier does not comply with the field naming conventions (JLS7 6.8.4) and constant naming conventions (JLS7 6.8.5).

Throws:

CompileException

verifyIdentifierIsConventionalLocalVariableOrParameterName

private void verifyIdentifierIsConventionalLocalVariableOrParameterName(String id,
 Location loc)
                                                                 throws CompileException

Issues a warning if the given identifier does not comply with the local variable and parameter naming conventions (JLS7 6.8.6).

Throws:

CompileException

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

warning

private void warning(String handle,
 String message)
              throws CompileException

Throws:

CompileException

warning

private void warning(String handle,
 String message,
 @Nullable
 Location location)
              throws CompileException

Issues a warning with the given message and location and returns. This is done through a WarningHandler that was installed through setWarningHandler(WarningHandler).

The handle argument qualifies the warning and is typically used by the WarningHandler to suppress individual warnings.

Throws:

CompileException - The optionally installed WarningHandler decided to throw a CompileException

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.

join

private static String join(@Nullable
 String[] sa,
 String separator)

hasAccessModifier

private static boolean hasAccessModifier(Java.Modifier[] modifiers,
 String... keywords)

hasAccessModifierOtherThan

private static boolean hasAccessModifierOtherThan(Java.Modifier[] modifiers,
 String... keywords)

packageModifiers

private Java.Modifier[] packageModifiers(Java.Modifier[] modifiers)
                                  throws CompileException

Throws:

CompileException

classModifiers

private Java.Modifier[] classModifiers(Java.Modifier[] modifiers)
                                throws CompileException

Throws:

CompileException

packageMemberClassModifiers

private Java.Modifier[] packageMemberClassModifiers(Java.Modifier[] modifiers)
                                             throws CompileException

Throws:

CompileException

fieldModifiers

private Java.Modifier[] fieldModifiers(Java.Modifier[] modifiers)
                                throws CompileException

Throws:

CompileException

methodModifiers

private Java.Modifier[] methodModifiers(Java.Modifier[] modifiers)
                                 throws CompileException

Throws:

CompileException

variableModifiers

private Java.Modifier[] variableModifiers(Java.Modifier[] modifiers)
                                   throws CompileException

Throws:

CompileException

constructorModifiers

private Java.Modifier[] constructorModifiers(Java.Modifier[] modifiers)
                                      throws CompileException

Throws:

CompileException

enumConstantModifiers

private Java.Modifier[] enumConstantModifiers(Java.Modifier[] modifiers)
                                       throws CompileException

Throws:

CompileException

interfaceModifiers

private Java.Modifier[] interfaceModifiers(Java.Modifier[] modifiers)
                                    throws CompileException

Throws:

CompileException

packageMemberInterfaceModifiers

private Java.Modifier[] packageMemberInterfaceModifiers(Java.Modifier[] modifiers)
                                                 throws CompileException

Throws:

CompileException

constantModifiers

private Java.Modifier[] constantModifiers(Java.Modifier[] modifiers)
                                   throws CompileException

Throws:

CompileException

interfaceMethodModifiers

private Java.Modifier[] interfaceMethodModifiers(Java.Modifier[] modifiers)
                                          throws CompileException

Throws:

CompileException

annotationTypeElementModifiers

private Java.Modifier[] annotationTypeElementModifiers(Java.Modifier[] modifiers)
                                                throws CompileException

Throws:

CompileException

checkModifiers

private Java.Modifier[] checkModifiers(Java.Modifier[] modifiers,
 String... allowedKeywords)
                                throws CompileException

Verifies that the modifiers are consistent.

• No two annotations must have the same type.
• No access modifier must appear more than once
• Certain modifier combinations must not occur (e.g. abstract final).

Returns:

modifiers

Throws:

CompileException