org.codehaus.janino

Class Parser

public class Parser extends Object

A parser for the JavaTM programming language.
Nested Class Summary
static classParser.ClassDeclarationContext
static classParser.InterfaceDeclarationContext
static classParser.ParseException
An exception that reflects an error during parsing.
Constructor Summary
Parser(Scanner scanner)
Method Summary
voideatToken()
ScannergetScanner()
Locationlocation()
Java.AtomparseAdditiveExpression()
   AdditiveExpression :=
     MultiplicativeExpression { ( '+' | '-' ) MultiplicativeExpression }
 
Java.AtomparseAndExpression()
   AndExpression :=
     EqualityExpression { '&' EqualityExpression }
 
Java.Rvalue[]parseArgumentList()
   ArgumentList := Expression { ',' Expression }
 
Java.Rvalue[]parseArguments()
   Arguments := '(' [ ArgumentList ] ')'
 
Java.ArrayInitializerparseArrayInitializer()
   ArrayInitializer :=
     '{' [ VariableInitializer { ',' VariableInitializer } [ ',' ] '}'
 
Java.AtomparseAssignmentExpression()
   AssignmentExpression :=
     ConditionalExpression [ AssignmentOperator AssignmentExpression ]

   AssignmentOperator :=
     '=' | '*=' | '/=' | '%=' | '+=' | '-=' | '<<=' |
     '>>=' | '>>>=' | '&=' | '^=' | '|='
 
Java.BlockparseBlock()
   '{' BlockStatements '}'
 
Java.BlockStatementparseBlockStatement()
   BlockStatement := { Identifier ':' } (
     ( Modifiers Type | ModifiersOpt BasicType ) LocalVariableDeclarators ';' |
     'class' ... 
ListparseBlockStatements()
   BlockStatements := { BlockStatement }
 
Java.StatementparseBreakStatement()
   BreakStatement := 'break' [ Identifier ] ';'
 
voidparseClassBody(Java.ClassDeclaration classDeclaration)
   ClassBody := '{' { ClassBodyDeclaration } '}'
 
voidparseClassBodyDeclaration(Java.ClassDeclaration classDeclaration)
   ClassBodyDeclaration :=
     ';' |
     ModifiersOpt (
       Block |                                    // Instance (JLS2 8.6) or static initializer (JLS2 8.7)
       'void' Identifier MethodDeclarationRest |
       'class' ClassDeclarationRest |
       'interface' InterfaceDeclarationRest |
       ConstructorDeclarator |
       Type Identifier (
         MethodDeclarationRest |
         FieldDeclarationRest ';'
       )
     )

 
Java.NamedClassDeclarationparseClassDeclarationRest(String optionalDocComment, short modifiers, Parser.ClassDeclarationContext context)
   ClassDeclarationRest :=
        Identifier
        [ 'extends' ReferenceType ]
        [ 'implements' ReferenceTypeList ]
        ClassBody
 
Java.CompilationUnitparseCompilationUnit()
   CompilationUnit := [ PackageDeclaration ]
                      { ImportDeclaration }
                      { TypeDeclaration }
 
Java.AtomparseConditionalAndExpression()
   ConditionalAndExpression :=
     InclusiveOrExpression { '&&' InclusiveOrExpression }
 
Java.AtomparseConditionalExpression()
   ConditionalExpression :=
     ConditionalOrExpression [ '?
Java.AtomparseConditionalOrExpression()
   ConditionalOrExpression :=
     ConditionalAndExpression { '||' ConditionalAndExpression ]
 
Java.ConstructorDeclaratorparseConstructorDeclarator(String optionalDocComment, short modifiers)
   ConstructorDeclarator :=
     Identifier
     FormalParameters
     [ 'throws' ReferenceTypeList ]
     '{'
       [ 'this' Arguments ';' | 'super' Arguments ';' | Primary '.' 'super' Arguments ';' ]
       BlockStatements
     '}'
 
Java.StatementparseContinueStatement()
   ContinueStatement := 'continue' [ Identifier ] ';'
 
Java.RvalueparseDimExpr()
   DimExpr := '[' Expression ']'
 
Java.Rvalue[]parseDimExprs()
   DimExprs := DimExpr { DimExpr }
 
Java.StatementparseDoStatement()
   DoStatement := 'do' Statement 'while' '(' Expression ')' ';'
 
Java.StatementparseEmptyStatement()
   EmptyStatement := ';'
 
Java.AtomparseEqualityExpression()
   EqualityExpression :=
     RelationalExpression { ( '==' | '!
Java.AtomparseExclusiveOrExpression()
   ExclusiveOrExpression :=
     AndExpression { '^' AndExpression }
 
Java.AtomparseExpression()
   Expression := AssignmentExpression
 
Java.Rvalue[]parseExpressionList()
   ExpressionList := Expression { ',' Expression }
 
Java.StatementparseExpressionStatement()
   ExpressionStatement := Expression ';'
 
Java.VariableDeclarator[]parseFieldDeclarationRest(String name)
   FieldDeclarationRest :=
     VariableDeclaratorRest
     { ',' VariableDeclarator }
 
Java.FunctionDeclarator.FormalParameterparseFormalParameter()
   FormalParameter := [ 'final' ] Type Identifier BracketsOpt
 
Java.FunctionDeclarator.FormalParameter[]parseFormalParameters()
   FormalParameters := '(' [ FormalParameter { ',' FormalParameter } ] ')'
 
Java.StatementparseForStatement()
   ForStatement :=
     'for' '('
       [ ForInit ] ';'
       [ Expression ] ';'
       [ ExpressionList ]
     ')' Statement
 
Java.StatementparseIfStatement()
   IfStatement := 'if' '(' Expression ')' Statement [ 'else' Statement ]
 
Java.CompilationUnit.ImportDeclarationparseImportDeclaration()
   ImportDeclaration := 'import' ImportDeclarationBody ';'
 
Java.CompilationUnit.ImportDeclarationparseImportDeclarationBody()
   ImportDeclarationBody := [ 'static' ] Identifier { '.' Identifier } [ '.' '*' ]
 
Java.AtomparseInclusiveOrExpression()
   InclusiveOrExpression :=
     ExclusiveOrExpression { '|' ExclusiveOrExpression }
 
voidparseInterfaceBody(Java.InterfaceDeclaration interfaceDeclaration)
   InterfaceBody := '{' {
     ';' |
     ModifiersOpt (
       'void' Identifier MethodDeclarationRest |
       'class' ClassDeclarationRest |
       'interface' InterfaceDeclarationRest |
       Type Identifier (
         MethodDeclarationRest |
         FieldDeclarationRest
       )
     )
   } '}'
 
Java.InterfaceDeclarationparseInterfaceDeclarationRest(String optionalDocComment, short modifiers, Parser.InterfaceDeclarationContext context)
   InterfaceDeclarationRest :=
     Identifier
     [ 'extends' ReferenceTypeList ]
     InterfaceBody
 
Java.StatementparseLabeledStatement()
   LabeledStatement := Identifier ':' Statement
 
Java.AtomparseLiteral()
Java.VariableDeclarator[]parseLocalVariableDeclarators()
   LocalVariableDeclarators := VariableDeclarator { ',' VariableDeclarator }
 
Java.BlockparseMethodBody()
   MethodBody := Block
 
Java.MethodDeclaratorparseMethodDeclarationRest(String optionalDocComment, short modifiers, Java.Type type, String name)
   MethodDeclarationRest :=
     FormalParameters
     { '[' ']' }
     [ 'throws' ReferenceTypeList ]
     ( ';' | MethodBody )
 
shortparseModifiersOpt()
   ModifiersOpt := { 'public' | 'protected' | 'private' | 'static' |
           'abstract' | 'final' | 'native' | 'synchronized' |
           'transient' | 'volatile' | 'strictfp'
 
Java.AtomparseMultiplicativeExpression()
   MultiplicativeExpression :=
     UnaryExpression { ( '*' | '/' | '%' ) UnaryExpression }
 
Java.PackageDeclarationparsePackageDeclaration()
   PackageDeclaration := 'package' QualifiedIdentifier ';'
 
Java.PackageMemberTypeDeclarationparsePackageMemberTypeDeclaration()
   PackageMemberTypeDeclaration :=
             ModifiersOpt 'class' ClassDeclarationRest |
             ModifiersOpt 'interface' InterfaceDeclarationRest
 
Java.AtomparsePrimary()
   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
     BasicType { '[]' } |                    // Type
     BasicType { '[]' } '.' 'class' |        // ClassLiteral 15.8.2
     'void' '.' 'class'                      // ClassLiteral 15.8.2

   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.ReferenceTypeparseReferenceType()
   ReferenceType := QualifiedIdentifier
 
Java.ReferenceType[]parseReferenceTypeList()
   ReferenceTypeList := ReferenceType { ',' ReferenceType }
 
Java.AtomparseRelationalExpression()
   RelationalExpression :=
     ShiftExpression {
       ( ( '<' | '>' | '<=' | '>=' ) ShiftExpression ) |
       ( 'instanceof' ReferenceType )
     }
 
Java.StatementparseReturnStatement()
   ReturnStatement := 'return' [ Expression ] ';'
 
Java.AtomparseSelector(Java.Atom atom)
   Selector :=
     '.' Identifier |                       // FieldAccess 15.11.1
     '.' Identifier Arguments |             // MethodInvocation
     '.' 'this'                             // QualifiedThis 15.8.4
     '.' 'super' Arguments                  // Qualified superclass constructor invocation (JLS 8.8.5.1)
     '.' 'super' '.' Identifier |           // SuperclassFieldReference (JLS 15.11.2)
     '.' 'super' '.' Identifier Arguments | // SuperclassMethodInvocation (JLS 15.12.4.9)
     '.' 'new' Identifier Arguments [ ClassBody ] | // QualifiedClassInstanceCreationExpression  15.9
     '.' 'class'
     '[' Expression ']'                     // ArrayAccessExpression 15.13
 
Java.AtomparseShiftExpression()
   ShiftExpression :=
     AdditiveExpression { ( '<<' | '>>' | '>>>' ) AdditiveExpression }
 
Java.StatementparseStatement()
   Statement :=
     LabeledStatement |
     Block |
     IfStatement |
     ForStatement |
     WhileStatement |
     DoStatement |
     TryStatement |
     'switch' ... 
Java.StatementparseSwitchStatement()
   SwitchStatement :=
     'switch' '(' Expression ')' '{' { SwitchLabels BlockStatements } '}'

   SwitchLabels := SwitchLabels { SwitchLabels }

   SwitchLabel := 'case' Expression ':' | 'default' ':'
 
Java.StatementparseSynchronizedStatement()
   SynchronizedStatement :=
     'synchronized' '(' expression ')' Block
 
Java.StatementparseThrowStatement()
   ThrowStatement := 'throw' Expression ';'
 
Java.StatementparseTryStatement()
   TryStatement :=
     'try' Block Catches [ Finally ] |
     'try' Block Finally

   Catches := CatchClause { CatchClause }

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

   Finally := 'finally' Block
 
Java.TypeparseType()
   Type := (
     'byte' | 'short' | 'char' | 'int' | 'long' |
     'float' | 'double' | 'boolean' |
     ReferenceType
   ) { '[' ']' }
 
Java.AtomparseUnaryExpression()
   UnaryExpression :=
     { PrefixOperator } Primary { Selector } { PostfixOperator }

   PrefixOperator := '++' | '--' | '+' | '-' | '~' | '!
Java.VariableDeclaratorparseVariableDeclarator()
   VariableDeclarator := Identifier VariableDeclaratorRest
 
Java.VariableDeclaratorparseVariableDeclaratorRest(String name)
   VariableDeclaratorRest := { '[' ']' } [ '=' VariableInitializer ]
 
Used by field declarations and local variable declarations.
Java.ArrayInitializerOrRvalueparseVariableInitializer()
   VariableInitializer :=
     ArrayInitializer |
     Expression
 
Java.StatementparseWhileStatement()
   WhileStatement := 'while' '(' Expression ')' Statement
 
booleanpeekIdentifier()
booleanpeekKeyword()
booleanpeekKeyword(String keyword)
booleanpeekKeyword(String[] keywords)
booleanpeekOperator(String operator)
booleanpeekOperator(String[] operators)
StringreadIdentifier()
voidreadKeyword(String keyword)
StringreadOperator()
voidreadOperator(String operator)
voidsetWarningHandler(WarningHandler optionalWarningHandler)
By default, warnings are discarded, but an application my install a WarningHandler.
protected voidthrowParseException(String message)
Convenience method for throwing a ParseException.

Constructor Detail

Parser

public Parser(Scanner scanner)

Method Detail

eatToken

public void eatToken()

getScanner

public Scanner getScanner()

location

public Location location()

parseAdditiveExpression

public Java.Atom parseAdditiveExpression()
   AdditiveExpression :=
     MultiplicativeExpression { ( '+' | '-' ) MultiplicativeExpression }
 

parseAndExpression

public Java.Atom parseAndExpression()
   AndExpression :=
     EqualityExpression { '&' EqualityExpression }
 

parseArgumentList

public Java.Rvalue[] parseArgumentList()
   ArgumentList := Expression { ',' Expression }
 

parseArguments

public Java.Rvalue[] parseArguments()
   Arguments := '(' [ ArgumentList ] ')'
 

parseArrayInitializer

public Java.ArrayInitializer parseArrayInitializer()
   ArrayInitializer :=
     '{' [ VariableInitializer { ',' VariableInitializer } [ ',' ] '}'
 

parseAssignmentExpression

public Java.Atom parseAssignmentExpression()
   AssignmentExpression :=
     ConditionalExpression [ AssignmentOperator AssignmentExpression ]

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

parseBlock

public Java.Block parseBlock()
   '{' BlockStatements '}'
 

parseBlockStatement

public Java.BlockStatement parseBlockStatement()
   BlockStatement := { Identifier ':' } (
     ( Modifiers Type | ModifiersOpt BasicType ) LocalVariableDeclarators ';' |
     'class' ... |
     Statement |
     'final' Type LocalVariableDeclarators ';' |
     Expression ';' |
     Expression LocalVariableDeclarators ';'   (1)
   )
 
(1) "Expression" must pose a type, and has optional trailing brackets.

parseBlockStatements

public List parseBlockStatements()
   BlockStatements := { BlockStatement }
 

parseBreakStatement

public Java.Statement parseBreakStatement()
   BreakStatement := 'break' [ Identifier ] ';'
 

parseClassBody

public void parseClassBody(Java.ClassDeclaration classDeclaration)
   ClassBody := '{' { ClassBodyDeclaration } '}'
 

parseClassBodyDeclaration

public void parseClassBodyDeclaration(Java.ClassDeclaration classDeclaration)
   ClassBodyDeclaration :=
     ';' |
     ModifiersOpt (
       Block |                                    // Instance (JLS2 8.6) or static initializer (JLS2 8.7)
       'void' Identifier MethodDeclarationRest |
       'class' ClassDeclarationRest |
       'interface' InterfaceDeclarationRest |
       ConstructorDeclarator |
       Type Identifier (
         MethodDeclarationRest |
         FieldDeclarationRest ';'
       )
     )

 

parseClassDeclarationRest

public Java.NamedClassDeclaration parseClassDeclarationRest(String optionalDocComment, short modifiers, Parser.ClassDeclarationContext context)
   ClassDeclarationRest :=
        Identifier
        [ 'extends' ReferenceType ]
        [ 'implements' ReferenceTypeList ]
        ClassBody
 

parseCompilationUnit

public Java.CompilationUnit parseCompilationUnit()
   CompilationUnit := [ PackageDeclaration ]
                      { ImportDeclaration }
                      { TypeDeclaration }
 

parseConditionalAndExpression

public Java.Atom parseConditionalAndExpression()
   ConditionalAndExpression :=
     InclusiveOrExpression { '&&' InclusiveOrExpression }
 

parseConditionalExpression

public Java.Atom parseConditionalExpression()
   ConditionalExpression :=
     ConditionalOrExpression [ '?' Expression ':' ConditionalExpression ]
 

parseConditionalOrExpression

public Java.Atom parseConditionalOrExpression()
   ConditionalOrExpression :=
     ConditionalAndExpression { '||' ConditionalAndExpression ]
 

parseConstructorDeclarator

public Java.ConstructorDeclarator parseConstructorDeclarator(String optionalDocComment, short modifiers)
   ConstructorDeclarator :=
     Identifier
     FormalParameters
     [ 'throws' ReferenceTypeList ]
     '{'
       [ 'this' Arguments ';' | 'super' Arguments ';' | Primary '.' 'super' Arguments ';' ]
       BlockStatements
     '}'
 

parseContinueStatement

public Java.Statement parseContinueStatement()
   ContinueStatement := 'continue' [ Identifier ] ';'
 

parseDimExpr

public Java.Rvalue parseDimExpr()
   DimExpr := '[' Expression ']'
 

parseDimExprs

public Java.Rvalue[] parseDimExprs()
   DimExprs := DimExpr { DimExpr }
 

parseDoStatement

public Java.Statement parseDoStatement()
   DoStatement := 'do' Statement 'while' '(' Expression ')' ';'
 

parseEmptyStatement

public Java.Statement parseEmptyStatement()
   EmptyStatement := ';'
 

parseEqualityExpression

public Java.Atom parseEqualityExpression()
   EqualityExpression :=
     RelationalExpression { ( '==' | '!=' ) RelationalExpression }
 

parseExclusiveOrExpression

public Java.Atom parseExclusiveOrExpression()
   ExclusiveOrExpression :=
     AndExpression { '^' AndExpression }
 

parseExpression

public Java.Atom parseExpression()
   Expression := AssignmentExpression
 

parseExpressionList

public Java.Rvalue[] parseExpressionList()
   ExpressionList := Expression { ',' Expression }
 

parseExpressionStatement

public Java.Statement parseExpressionStatement()
   ExpressionStatement := Expression ';'
 

parseFieldDeclarationRest

public Java.VariableDeclarator[] parseFieldDeclarationRest(String name)
   FieldDeclarationRest :=
     VariableDeclaratorRest
     { ',' VariableDeclarator }
 

parseFormalParameter

public Java.FunctionDeclarator.FormalParameter parseFormalParameter()
   FormalParameter := [ 'final' ] Type Identifier BracketsOpt
 

parseFormalParameters

public Java.FunctionDeclarator.FormalParameter[] parseFormalParameters()
   FormalParameters := '(' [ FormalParameter { ',' FormalParameter } ] ')'
 

parseForStatement

public Java.Statement parseForStatement()
   ForStatement :=
     'for' '('
       [ ForInit ] ';'
       [ Expression ] ';'
       [ ExpressionList ]
     ')' Statement
 

parseIfStatement

public Java.Statement parseIfStatement()
   IfStatement := 'if' '(' Expression ')' Statement [ 'else' Statement ]
 

parseImportDeclaration

public Java.CompilationUnit.ImportDeclaration parseImportDeclaration()
   ImportDeclaration := 'import' ImportDeclarationBody ';'
 

parseImportDeclarationBody

public Java.CompilationUnit.ImportDeclaration parseImportDeclarationBody()
   ImportDeclarationBody := [ 'static' ] Identifier { '.' Identifier } [ '.' '*' ]
 

parseInclusiveOrExpression

public Java.Atom parseInclusiveOrExpression()
   InclusiveOrExpression :=
     ExclusiveOrExpression { '|' ExclusiveOrExpression }
 

parseInterfaceBody

public void parseInterfaceBody(Java.InterfaceDeclaration interfaceDeclaration)
   InterfaceBody := '{' {
     ';' |
     ModifiersOpt (
       'void' Identifier MethodDeclarationRest |
       'class' ClassDeclarationRest |
       'interface' InterfaceDeclarationRest |
       Type Identifier (
         MethodDeclarationRest |
         FieldDeclarationRest
       )
     )
   } '}'
 

parseInterfaceDeclarationRest

public Java.InterfaceDeclaration parseInterfaceDeclarationRest(String optionalDocComment, short modifiers, Parser.InterfaceDeclarationContext context)
   InterfaceDeclarationRest :=
     Identifier
     [ 'extends' ReferenceTypeList ]
     InterfaceBody
 

parseLabeledStatement

public Java.Statement parseLabeledStatement()
   LabeledStatement := Identifier ':' Statement
 

parseLiteral

public Java.Atom parseLiteral()

parseLocalVariableDeclarators

public Java.VariableDeclarator[] parseLocalVariableDeclarators()
   LocalVariableDeclarators := VariableDeclarator { ',' VariableDeclarator }
 

parseMethodBody

public Java.Block parseMethodBody()
   MethodBody := Block
 

parseMethodDeclarationRest

public Java.MethodDeclarator parseMethodDeclarationRest(String optionalDocComment, short modifiers, Java.Type type, String name)
   MethodDeclarationRest :=
     FormalParameters
     { '[' ']' }
     [ 'throws' ReferenceTypeList ]
     ( ';' | MethodBody )
 

parseModifiersOpt

public short parseModifiersOpt()
   ModifiersOpt := { 'public' | 'protected' | 'private' | 'static' |
           'abstract' | 'final' | 'native' | 'synchronized' |
           'transient' | 'volatile' | 'strictfp'
 

parseMultiplicativeExpression

public Java.Atom parseMultiplicativeExpression()
   MultiplicativeExpression :=
     UnaryExpression { ( '*' | '/' | '%' ) UnaryExpression }
 

parsePackageDeclaration

public Java.PackageDeclaration parsePackageDeclaration()
   PackageDeclaration := 'package' QualifiedIdentifier ';'
 

parsePackageMemberTypeDeclaration

public Java.PackageMemberTypeDeclaration parsePackageMemberTypeDeclaration()
   PackageMemberTypeDeclaration :=
             ModifiersOpt 'class' ClassDeclarationRest |
             ModifiersOpt 'interface' InterfaceDeclarationRest
 

parsePrimary

public 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
     BasicType { '[]' } |                    // Type
     BasicType { '[]' } '.' 'class' |        // ClassLiteral 15.8.2
     'void' '.' 'class'                      // ClassLiteral 15.8.2

   CastExpression :=
     '(' PrimitiveType { '[]' } ')' UnaryExpression |
     '(' Expression ')' UnaryExpression
 
   NewClassInstance := 'new' ReferenceType Arguments
 
   NewAnonymousClassInstance := 'new' ReferenceType Arguments [ ClassBody ]
 
   NewArray := 'new' Type DimExprs { '[]' }
 
   NewInitializedArray := 'new' ArrayType ArrayInitializer
 

parseQualifiedIdentifier

public String[] parseQualifiedIdentifier()
QualifiedIdentifier := Identifier { '.' Identifier }

parseReferenceType

public Java.ReferenceType parseReferenceType()
   ReferenceType := QualifiedIdentifier
 

parseReferenceTypeList

public Java.ReferenceType[] parseReferenceTypeList()
   ReferenceTypeList := ReferenceType { ',' ReferenceType }
 

parseRelationalExpression

public Java.Atom parseRelationalExpression()
   RelationalExpression :=
     ShiftExpression {
       ( ( '<' | '>' | '<=' | '>=' ) ShiftExpression ) |
       ( 'instanceof' ReferenceType )
     }
 

parseReturnStatement

public Java.Statement parseReturnStatement()
   ReturnStatement := 'return' [ Expression ] ';'
 

parseSelector

public Java.Atom parseSelector(Java.Atom atom)
   Selector :=
     '.' Identifier |                       // FieldAccess 15.11.1
     '.' Identifier Arguments |             // MethodInvocation
     '.' 'this'                             // QualifiedThis 15.8.4
     '.' 'super' Arguments                  // Qualified superclass constructor invocation (JLS 8.8.5.1)
     '.' 'super' '.' Identifier |           // SuperclassFieldReference (JLS 15.11.2)
     '.' 'super' '.' Identifier Arguments | // SuperclassMethodInvocation (JLS 15.12.4.9)
     '.' 'new' Identifier Arguments [ ClassBody ] | // QualifiedClassInstanceCreationExpression  15.9
     '.' 'class'
     '[' Expression ']'                     // ArrayAccessExpression 15.13
 

parseShiftExpression

public Java.Atom parseShiftExpression()
   ShiftExpression :=
     AdditiveExpression { ( '<<' | '>>' | '>>>' ) AdditiveExpression }
 

parseStatement

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

parseSwitchStatement

public Java.Statement parseSwitchStatement()
   SwitchStatement :=
     'switch' '(' Expression ')' '{' { SwitchLabels BlockStatements } '}'

   SwitchLabels := SwitchLabels { SwitchLabels }

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

parseSynchronizedStatement

public Java.Statement parseSynchronizedStatement()
   SynchronizedStatement :=
     'synchronized' '(' expression ')' Block
 

parseThrowStatement

public Java.Statement parseThrowStatement()
   ThrowStatement := 'throw' Expression ';'
 

parseTryStatement

public Java.Statement parseTryStatement()
   TryStatement :=
     'try' Block Catches [ Finally ] |
     'try' Block Finally

   Catches := CatchClause { CatchClause }

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

   Finally := 'finally' Block
 

parseType

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

parseUnaryExpression

public Java.Atom parseUnaryExpression()
   UnaryExpression :=
     { PrefixOperator } Primary { Selector } { PostfixOperator }

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

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

parseVariableDeclarator

public Java.VariableDeclarator parseVariableDeclarator()
   VariableDeclarator := Identifier VariableDeclaratorRest
 

parseVariableDeclaratorRest

public Java.VariableDeclarator parseVariableDeclaratorRest(String name)
   VariableDeclaratorRest := { '[' ']' } [ '=' VariableInitializer ]
 
Used by field declarations and local variable declarations.

parseVariableInitializer

public Java.ArrayInitializerOrRvalue parseVariableInitializer()
   VariableInitializer :=
     ArrayInitializer |
     Expression
 

parseWhileStatement

public Java.Statement parseWhileStatement()
   WhileStatement := 'while' '(' Expression ')' Statement
 

peekIdentifier

public boolean peekIdentifier()

peekKeyword

public boolean peekKeyword()

peekKeyword

public boolean peekKeyword(String keyword)

peekKeyword

public boolean peekKeyword(String[] keywords)

peekOperator

public boolean peekOperator(String operator)

peekOperator

public boolean peekOperator(String[] operators)

readIdentifier

public String readIdentifier()

readKeyword

public void readKeyword(String keyword)

readOperator

public String readOperator()

readOperator

public void readOperator(String operator)

setWarningHandler

public void setWarningHandler(WarningHandler optionalWarningHandler)
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 ParseException. 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: optionalWarningHandler null to indicate that no warnings be issued

throwParseException

protected final void throwParseException(String message)
Convenience method for throwing a ParseException.