janino.net

org.codehaus.janino
Class Parser

  extended by org.codehaus.janino.Parser

public class Parser
extends

A parser for the Java™ programming language.

'JLS7' refers to the .


Nested Class Summary
static class Parser.ClassDeclarationContext
          Enumerator for the kinds of context where a class declaration can occur.
static class Parser.InterfaceDeclarationContext
          Enumerator for the kinds of context where an interface declaration can occur.
 
Constructor Summary
Parser(Scanner scanner)
           
 
Method Summary
protected  CompileException compileException( message)
          Convenience method for throwing a CompileException.
 Scanner getScanner()
           
 Location location()
           
 Java.Atom parseAdditiveExpression()
           AdditiveExpression := MultiplicativeExpression { ( '+' | '-' ) MultiplicativeExpression }
 Java.Atom parseAndExpression()
           AndExpression := EqualityExpression { '&' EqualityExpression }
 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()
           '{' BlockStatements '}'
 Java.BlockStatement parseBlockStatement()
           BlockStatement := { Identifier ':' } ( ( Modifiers Type | ModifiersOpt BasicType ) VariableDeclarators ';' | 'class' ... | Statement | 'final' Type VariableDeclarators ';' | Expression ';' | Expression VariableDeclarators ';' (1) ) (1) "Expression" must pose a type, and has optional trailing brackets.
 <Java.BlockStatement> parseBlockStatements()
           BlockStatements := { BlockStatement }
 Java.Statement parseBreakStatement()
           BreakStatement := 'break' [ Identifier ] ';'
 void parseClassBody(Java.ClassDeclaration classDeclaration)
           ClassBody := '{' { ClassBodyDeclaration } '}'
 void parseClassBodyDeclaration(Java.ClassDeclaration classDeclaration)
           ClassBodyDeclaration := ';' | ModifiersOpt ( Block | // Instance (JLS7 8.6) or static initializer (JLS7 8.7) 'void' Identifier MethodDeclarationRest | 'class' ClassDeclarationRest | 'interface' InterfaceDeclarationRest | ConstructorDeclarator | Type Identifier ( MethodDeclarationRest | FieldDeclarationRest ';' ) )
 Java.NamedClassDeclaration parseClassDeclarationRest( optionalDocComment, Java.Modifiers modifiers, Parser.ClassDeclarationContext context)
           ClassDeclarationRest := Identifier [ typeParameters ] [ 'extends' ReferenceType ] [ 'implements' ReferenceTypeList ] ClassBody
 Java.CompilationUnit parseCompilationUnit()
           CompilationUnit := [ PackageDeclaration ] { ImportDeclaration } { TypeDeclaration }
 Java.Atom parseConditionalAndExpression()
           ConditionalAndExpression := InclusiveOrExpression { '&&' InclusiveOrExpression }
 Java.Atom parseConditionalExpression()
           ConditionalExpression := ConditionalOrExpression [ '?'
 Java.Atom parseConditionalOrExpression()
           ConditionalOrExpression := ConditionalAndExpression { '||' ConditionalAndExpression ]
 Java.ConstructorDeclarator parseConstructorDeclarator( optionalDocComment, Java.Modifiers modifiers)
           ConstructorDeclarator := Identifier FormalParameters [ 'throws' ReferenceTypeList ] '{' [ 'this' Arguments ';' | 'super' Arguments ';' | Primary '.'
 Java.Statement parseContinueStatement()
           ContinueStatement := 'continue' [ Identifier ] ';'
 Java.Rvalue parseDimExpr()
           DimExpr := '[' Expression ']'
 Java.Rvalue[] parseDimExprs()
           DimExprs := DimExpr { DimExpr }
 Java.Statement parseDoStatement()
           DoStatement := 'do' Statement 'while' '(' Expression ')' ';'
 Java.Statement parseEmptyStatement()
           EmptyStatement := ';'
 Java.Atom parseEqualityExpression()
           EqualityExpression := RelationalExpression { ( '==' | '!
 Java.Atom parseExclusiveOrExpression()
           ExclusiveOrExpression := AndExpression { '^' AndExpression }
 Java.Atom parseExpression()
           Expression := AssignmentExpression
 Java.Rvalue[] parseExpressionList()
           ExpressionList := Expression { ',' Expression }
 Java.Statement parseExpressionStatement()
           ExpressionStatement := Expression ';'
 Java.VariableDeclarator[] parseFieldDeclarationRest( name)
           FieldDeclarationRest := VariableDeclaratorRest { ',' VariableDeclarator }
 Java.FunctionDeclarator.FormalParameter parseFormalParameter(boolean[] hasEllipsis)
           FormalParameter := [ 'final' ] Type [ '.' '.' '.' ] Identifier BracketsOpt
 Java.FunctionDeclarator.FormalParameters parseFormalParameters()
           FormalParameters := '(' [ FormalParameter { ',' FormalParameter } ] ')'
 Java.Statement parseForStatement()
           ForStatement := 'for' '(' [ ForInit ] ';' [ Expression ] ';' [ ExpressionList ] ')' Statement | 'for' '(' FormalParameter ':' Expression ')' Statement ForInit := Modifiers Type VariableDeclarators | ModifiersOpt BasicType VariableDeclarators | Expression VariableDeclarators (1) | Expression { ',' Expression } (1) "Expression" must pose a type.
 Java.Statement parseIfStatement()
           IfStatement := 'if' '(' Expression ')' Statement [ 'else' Statement ]
 Java.CompilationUnit.ImportDeclaration parseImportDeclaration()
           ImportDeclaration := 'import' ImportDeclarationBody ';'
 Java.CompilationUnit.ImportDeclaration parseImportDeclarationBody()
           ImportDeclarationBody := [ 'static' ] Identifier { '.'
 Java.Atom parseInclusiveOrExpression()
           InclusiveOrExpression := ExclusiveOrExpression { '|' ExclusiveOrExpression }
 void parseInterfaceBody(Java.InterfaceDeclaration interfaceDeclaration)
           InterfaceBody := '{' { ';' | ModifiersOpt ( 'void' Identifier MethodDeclarationRest | 'class' ClassDeclarationRest | 'interface' InterfaceDeclarationRest | Type Identifier ( MethodDeclarationRest | FieldDeclarationRest ) ) } '}'
 Java.InterfaceDeclaration parseInterfaceDeclarationRest( optionalDocComment, Java.Modifiers modifiers, Parser.InterfaceDeclarationContext context)
           InterfaceDeclarationRest := Identifier [ typeParameters ] [ 'extends' ReferenceTypeList ] InterfaceBody
 Java.Statement parseLabeledStatement()
           LabeledStatement := Identifier ':' Statement
 Java.Rvalue parseLiteral()
           Literal := IntegerLiteral | FloatingPointLiteral | BooleanLiteral | CharacterLiteral | StringLiteral | NullLiteral
 Java.Block parseMethodBody()
           MethodBody := Block
 Java.MethodDeclarator parseMethodDeclarationRest( optionalDocComment, Java.Modifiers modifiers, Java.Type type,  name)
           MethodDeclarationRest := FormalParameters { '[' ']' } [ 'throws' ReferenceTypeList ] ( ';' | MethodBody )
 Java.Modifiers parseModifiers()
           ModifiersAndAnnotations := { 'public' | 'protected' | 'private' | 'static' | 'abstract' | 'final' | 'native' | 'synchronized' | 'transient' | 'volatile' | 'strictfp' | Annotation }
 Java.Atom parseMultiplicativeExpression()
           MultiplicativeExpression := UnaryExpression { ( '*' | '/' | '%' ) UnaryExpression }
 Java.PackageDeclaration parsePackageDeclaration()
           PackageDeclaration := 'package' QualifiedIdentifier ';'
 Java.PackageMemberTypeDeclaration parsePackageMemberTypeDeclaration()
           PackageMemberTypeDeclaration := ModifiersOpt 'class' ClassDeclarationRest | ModifiersOpt 'interface' InterfaceDeclarationRest
 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 '[]' { '[]' } '.'
 [] parseQualifiedIdentifier()
           QualifiedIdentifier := Identifier { '.'
 Java.ReferenceType parseReferenceType()
           ReferenceType := QualifiedIdentifier [ TypeArguments ]
 Java.ReferenceType[] parseReferenceTypeList()
           ReferenceTypeList := ReferenceType { ',' ReferenceType }
 Java.Atom parseRelationalExpression()
           RelationalExpression := ShiftExpression { 'instanceof' ReferenceType | '<' ShiftExpression [ { ',' TypeArgument } '>' ] | '<' TypeArgument [ { ',' TypeArgument } '>' ] | ( '>' | '<=' | '>=' ) ShiftExpression }
 Java.Statement parseReturnStatement()
           ReturnStatement := 'return' [ Expression ] ';'
 Java.Atom parseSelector(Java.Atom atom)
           Selector := '.'
 Java.Atom parseShiftExpression()
           ShiftExpression := AdditiveExpression { ( '<<' | '>>' | '>>>' ) AdditiveExpression }
 Java.Statement parseStatement()
           Statement := LabeledStatement | Block | IfStatement | ForStatement | WhileStatement | DoStatement | TryStatement | 'switch' ... | 'synchronized' ... | ReturnStatement | ThrowStatement | BreakStatement | ContinueStatement | EmptyStatement | ExpressionStatement
 Java.Statement parseSwitchStatement()
           SwitchStatement := 'switch' '(' Expression ')' '{' { SwitchLabels BlockStatements } '}' SwitchLabels := SwitchLabels { SwitchLabels } SwitchLabel := 'case' Expression ':' | 'default' ':'
 Java.Statement parseSynchronizedStatement()
           SynchronizedStatement := 'synchronized' '(' expression ')' Block
 Java.Statement parseThrowStatement()
           ThrowStatement := 'throw' Expression ';'
 Java.Statement parseTryStatement()
           TryStatement := 'try' Block Catches [ Finally ] | 'try' Block Finally Catches := CatchClause { CatchClause } CatchClause := 'catch' '(' FormalParameter ')' Block Finally := 'finally' Block
 Java.Type parseType()
           Type := ( 'byte' | 'short' | 'char' | 'int' | 'long' | 'float' | 'double' | 'boolean' | ReferenceType ) { '[' ']' }
 Java.Atom parseUnaryExpression()
           UnaryExpression := { PrefixOperator } Primary { Selector } { PostfixOperator } PrefixOperator := '++' | '--' | '+' | '-' | '~' | '!'
 Java.VariableDeclarator parseVariableDeclarator()
           VariableDeclarator := Identifier VariableDeclaratorRest
 Java.VariableDeclarator parseVariableDeclaratorRest( name)
           VariableDeclaratorRest := { '[' ']' } [ '=' VariableInitializer ] Used by field declarations and local variable declarations.
 Java.VariableDeclarator[] parseVariableDeclarators()
           VariableDeclarators := VariableDeclarator { ',' VariableDeclarator }
 Java.ArrayInitializerOrRvalue parseVariableInitializer()
           VariableInitializer := ArrayInitializer | Expression
 Java.Statement parseWhileStatement()
           WhileStatement := 'while' '(' Expression ')' Statement
 Scanner.Token peek()
           
 int peek(int[] suspected)
          Checks whether the type of the next token is any of the suspected; does not consume the next token.
 boolean peek( suspected)
           
 int peek([] suspected)
          Checks whether the value of the next token equals any of the suspected; does not consume the next token.
 boolean peekEof()
           
  peekIdentifier()
           
 boolean peekLiteral()
           
 Scanner.Token peekNextButOne()
           
 boolean peekNextButOne( suspected)
           
 boolean peekRead( suspected)
           
 int peekRead([] values)
           
 Scanner.Token read()
           
 void read( expected)
          Verifies that the value of the next token equals expected, and consumes the token.
 int read([] expected)
          Verifies that the value of the next token equals one of the expected, and consumes the token.
  readIdentifier()
           
  readOperator()
           
 void setWarningHandler(WarningHandler optionalWarningHandler)
          By default, warnings are discarded, but an application my install a WarningHandler.
 
Methods inherited from class java.lang.
, , , , , , , , , ,
 

Constructor Detail

Parser

public Parser(Scanner scanner)
Method Detail

getScanner

public Scanner getScanner()
Returns:
The scanner that produces the tokens for this parser.

parseCompilationUnit

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

Throws:
CompileException

parsePackageDeclaration

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

Throws:
CompileException

parseImportDeclaration

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

Throws:
CompileException

parseImportDeclarationBody

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

Throws:
CompileException

parseQualifiedIdentifier

public [] parseQualifiedIdentifier()
                                  throws CompileException,
                                         
   QualifiedIdentifier := Identifier { '.' Identifier }
 

Throws:
CompileException

parsePackageMemberTypeDeclaration

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

Throws:
CompileException

parseModifiers

public Java.Modifiers parseModifiers()
                              throws CompileException,
                                     
   ModifiersAndAnnotations := { 'public' | 'protected' | 'private' | 'static' | 'abstract' | 'final' | 'native'
           | 'synchronized' | 'transient' | 'volatile' | 'strictfp' | Annotation }
 

Throws:
CompileException

parseClassDeclarationRest

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

Throws:
CompileException

parseClassBody

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

Throws:
CompileException

parseClassBodyDeclaration

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

 

Throws:
CompileException

parseInterfaceDeclarationRest

public Java.InterfaceDeclaration parseInterfaceDeclarationRest( optionalDocComment,
                                                               Java.Modifiers modifiers,
                                                               Parser.InterfaceDeclarationContext context)
                                                        throws CompileException,
                                                               
   InterfaceDeclarationRest :=
     Identifier [ typeParameters ]
     [ 'extends' ReferenceTypeList ]
     InterfaceBody
 

Throws:
CompileException

parseInterfaceBody

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

Throws:
CompileException

parseConstructorDeclarator

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

Throws:
CompileException

parseMethodDeclarationRest

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

Throws:
CompileException

parseVariableInitializer

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

Throws:
CompileException

parseArrayInitializer

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

Throws:
CompileException

parseFormalParameters

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

Throws:
CompileException

parseFormalParameter

public Java.FunctionDeclarator.FormalParameter parseFormalParameter(boolean[] hasEllipsis)
                                                             throws CompileException,
                                                                    
   FormalParameter := [ 'final' ] Type [ '.' '.' '.' ] Identifier BracketsOpt
 

Throws:
CompileException

parseMethodBody

public Java.Block parseMethodBody()
                           throws CompileException,
                                  
   MethodBody := Block
 

Throws:
CompileException

parseBlock

public Java.Block parseBlock()
                      throws CompileException,
                             
   '{' BlockStatements '}'
 

Throws:
CompileException

parseBlockStatements

public <Java.BlockStatement> parseBlockStatements()
                                               throws CompileException,
                                                      
   BlockStatements := { BlockStatement }
 

Throws:
CompileException

parseBlockStatement

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

Throws:
CompileException

parseVariableDeclarators

public Java.VariableDeclarator[] parseVariableDeclarators()
                                                   throws CompileException,
                                                          
   VariableDeclarators := VariableDeclarator { ',' VariableDeclarator }
 

Throws:
CompileException

parseFieldDeclarationRest

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

Throws:
CompileException

parseVariableDeclarator

public Java.VariableDeclarator parseVariableDeclarator()
                                                throws CompileException,
                                                       
   VariableDeclarator := Identifier VariableDeclaratorRest
 

Throws:
CompileException

parseVariableDeclaratorRest

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

Throws:
CompileException

parseStatement

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

Throws:
CompileException

parseLabeledStatement

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

Throws:
CompileException

parseIfStatement

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

Throws:
CompileException

parseForStatement

public Java.Statement parseForStatement()
                                 throws CompileException,
                                        
   ForStatement :=
     'for' '(' [ ForInit ] ';' [ Expression ] ';' [ ExpressionList ] ')' Statement
     | 'for' '(' FormalParameter ':' Expression ')' Statement

   ForInit :=
     Modifiers Type VariableDeclarators
     | ModifiersOpt BasicType VariableDeclarators
     | Expression VariableDeclarators              (1)
     | Expression { ',' Expression }
 
(1) "Expression" must pose a type.

Throws:
CompileException

parseWhileStatement

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

Throws:
CompileException

parseDoStatement

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

Throws:
CompileException

parseTryStatement

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

   Catches := CatchClause { CatchClause }

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

   Finally := 'finally' Block
 

Throws:
CompileException

parseSwitchStatement

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

   SwitchLabels := SwitchLabels { SwitchLabels }

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

Throws:
CompileException

parseSynchronizedStatement

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

Throws:
CompileException

parseReturnStatement

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

Throws:
CompileException

parseThrowStatement

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

Throws:
CompileException

parseBreakStatement

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

Throws:
CompileException

parseContinueStatement

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

Throws:
CompileException

parseAssertStatement

public Java.Statement parseAssertStatement()
                                    throws CompileException,
                                           
   AssertStatement := 'assert' Expression [ ':' Expression ] ';'
 

Throws:
CompileException

parseEmptyStatement

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

Throws:
CompileException

parseExpressionList

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

Throws:
CompileException

parseType

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

Throws:
CompileException

parseReferenceType

public Java.ReferenceType parseReferenceType()
                                      throws CompileException,
                                             
   ReferenceType := QualifiedIdentifier [ TypeArguments ]
 

Throws:
CompileException

parseReferenceTypeList

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

Throws:
CompileException

parseExpression

public Java.Atom parseExpression()
                          throws CompileException,
                                 
   Expression := AssignmentExpression
 

Throws:
CompileException

parseAssignmentExpression

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

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

Throws:
CompileException

parseConditionalExpression

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

Throws:
CompileException

parseConditionalOrExpression

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

Throws:
CompileException

parseConditionalAndExpression

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

Throws:
CompileException

parseInclusiveOrExpression

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

Throws:
CompileException

parseExclusiveOrExpression

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

Throws:
CompileException

parseAndExpression

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

Throws:
CompileException

parseEqualityExpression

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

Throws:
CompileException

parseRelationalExpression

public Java.Atom parseRelationalExpression()
                                    throws CompileException,
                                           
   RelationalExpression :=
     ShiftExpression {
       'instanceof' ReferenceType
       | '<' ShiftExpression [ { ',' TypeArgument } '>' ]
       | '<' TypeArgument [ { ',' TypeArgument } '>' ]
       | ( '>' | '<=' | '>=' ) ShiftExpression
     }
 

Throws:
CompileException

parseShiftExpression

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

Throws:
CompileException

parseAdditiveExpression

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

Throws:
CompileException

parseMultiplicativeExpression

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

Throws:
CompileException

parseUnaryExpression

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

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

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

Throws:
CompileException

parsePrimary

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

Throws:
CompileException

parseSelector

public Java.Atom parseSelector(Java.Atom atom)
                        throws CompileException,
                               
   Selector :=
     '.' Identifier |                               // FieldAccess 15.11.1
     '.' Identifier Arguments |                     // MethodInvocation
     '.' '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
 

Throws:
CompileException

parseDimExprs

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

Throws:
CompileException

parseDimExpr

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

Throws:
CompileException

parseArguments

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

Throws:
CompileException

parseArgumentList

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

Throws:
CompileException

parseLiteral

public Java.Rvalue parseLiteral()
                         throws CompileException,
                                
   Literal :=
     IntegerLiteral
     | FloatingPointLiteral
     | BooleanLiteral
     | CharacterLiteral
     | StringLiteral
     | NullLiteral
 

Throws:
CompileException

parseExpressionStatement

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

Throws:
CompileException

location

public Location location()
Returns:
The location of the first character of the previously peek()ed or read() token

peek

public Scanner.Token peek()
                   throws CompileException,
                          
Returns:
The next token, but does not consume it
Throws:
CompileException

peekNextButOne

public Scanner.Token peekNextButOne()
                             throws CompileException,
                                    
Returns:
The next-but-one token, but consumes neither the next nor the next-but-one token
Throws:
CompileException

read

public Scanner.Token read()
                   throws CompileException,
                          
Returns:
The next and also consumes it, or null iff the scanner is at end-of-input
Throws:
CompileException

peek

public boolean peek( suspected)
             throws CompileException,
                    
Returns:
Whether the value of the next token equals suspected; does not consume the next token
Throws:
CompileException

peek

public int peek([] suspected)
         throws CompileException,
                
Checks whether the value of the next token equals any of the suspected; does not consume the next token.

Returns:
The index of the first of the suspected that equals the value of the next token, or -1 if the value of the next token equals none of the suspected
Throws:
CompileException

peek

public int peek(int[] suspected)
         throws CompileException,
                
Checks whether the type of the next token is any of the suspected; does not consume the next token.

Returns:
The index of the first of the suspected types that is the next token's type, or -1 if the type of the next token is none of the suspected types
Throws:
CompileException

peekNextButOne

public boolean peekNextButOne( suspected)
                       throws CompileException,
                              
Returns:
Whether the value of the next-but-one token equals the suspected; consumes neither the next nor the next-but-one token
Throws:
CompileException

read

public void read( expected)
          throws CompileException,
                 
Verifies that the value of the next token equals expected, and consumes the token.

Throws:
CompileException - The value of the next token does not equal expected (this includes the case that the scanner is at end-of-input)

read

public int read([] expected)
         throws CompileException,
                
Verifies that the value of the next token equals one of the expected, and consumes the token.

Returns:
The index of the consumed token within expected
Throws:
CompileException - The value of the next token does not equal any of the expected (this includes the case where the scanner is at end-of-input)

peekRead

public boolean peekRead( suspected)
                 throws CompileException,
                        
Returns:
Whether the value of the next token equals the suspected; if so, it consumes the next token
Throws:
CompileException

peekRead

public int peekRead([] values)
             throws CompileException,
                    
Returns:
-1 iff the next token is none of values
Throws:
CompileException

peekEof

public boolean peekEof()
                throws CompileException,
                       
Returns:
Whether the scanner is at end-of-input
Throws:
CompileException

peekIdentifier

public  peekIdentifier()
                      throws CompileException,
                             
Returns:
null iff the next token is not an identifier, otherwise the value of the identifier token
Throws:
CompileException

peekLiteral

public boolean peekLiteral()
                    throws CompileException,
                           
Returns:
Whether the next token is a literal
Throws:
CompileException

readIdentifier

public  readIdentifier()
                      throws CompileException,
                             
Returns:
The value of the next token, which is an indentifier
Throws:
CompileException - The next token is not an identifier

readOperator

public  readOperator()
                    throws CompileException,
                           
Returns:
The value of the next token, which is an operator
Throws:
CompileException - The next token is not an 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 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:
optionalWarningHandler - null to indicate that no warnings be issued

compileException

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


janino.net