Web Site

org.codehaus.janino
Class Parser

java.lang.Object
  extended byorg.codehaus.janino.Parser

public class Parser
extends Object

Implementation of a simplified compiler for the JavaTM programming language. The following elements of the Java programming language are implemented:

Limitations:


Nested Class Summary
static class Parser.ParseException
          An exception that reflects an error during parsing.
 
Constructor Summary
Parser(Scanner scanner)
           
 
Method Summary
 Java.Atom parseAdditiveExpression(Java.Scope enclosingScope)
           AdditiveExpression := MultiplicativeExpression { ( '+' | '-' ) MultiplicativeExpression }
 Java.Atom parseAndExpression(Java.Scope enclosingScope)
           AndExpression := EqualityExpression { '&' EqualityExpression }
 Java.Rvalue[] parseArgumentList(Java.Scope enclosingScope)
           ArgumentList := Expression { ',' Expression }
 Java.Rvalue[] parseArguments(Java.Scope enclosingScope)
           Arguments := '(' [ ArgumentList ] ')'
 Java.Rvalue parseArrayInitializer(Java.Scope enclosingScope, Java.ArrayType arrayType)
           ArrayInitializer := '{' [ VariableInitializer { ',' VariableInitializer } [ ',' ] '}'
 Java.Atom parseAssignmentExpression(Java.Scope enclosingScope)
           AssignmentExpression := ConditionalExpression [ AssignmentOperator AssignmentExpression ] AssignmentOperator := '=' | '*=' | '/=' | '%=' | '+=' | '-=' | '<<=' | '>>=' | '>>>=' | '&=' | '^=' | '|='
 Java.Block parseBlock(Java.Scope enclosingScope)
           '{' BlockStatements '}'
 Java.BlockStatement parseBlockStatement(Java.Block enclosingBlock)
           BlockStatement := { Identifier ':' } ( ( Modifiers Type | ModifiersOpt BasicType ) LocalVariableDeclarators ';' | 'class' ...
 List parseBlockStatements(Java.Block enclosingBlock)
           BlockStatements := { BlockStatement }
 Java.Statement parseBreakStatement(Java.Scope enclosingScope)
           BreakStatement := 'break' [ Identifier ] ';'
 void parseClassBody(Java.ClassDeclaration classDeclaration)
           ClassBody := '{' { ClassBodyDeclaration } '}'
 void parseClassBodyDeclaration(Java.ClassDeclaration classDeclaration)
           ClassBodyDeclaration := ';' | ModifiersOpt ( Block | // Instance (JLS2 8.6) or static initializer (JLS2 8.7) 'void' Identifier MethodDeclaratorRest | 'class' ClassDeclarationRest | 'interface' InterfaceDeclarationRest | ConstructorDeclarator | Type Identifier ( MethodDeclaratorRest | FieldDeclaratorsRest ';' ) )
 Java.NamedClassDeclaration parseClassDeclarationRest(Java.Scope enclosingScope, String optionalDocComment, short modifiers)
           ClassDeclarationRest := Identifier [ 'extends' ReferenceType ] [ 'implements' ReferenceTypeList ] ClassBody
 org.codehaus.janino.Java.NamedTypeDeclaration parseClassOrInterfaceDeclaration(Java.Scope enclosingScope)
           ClassOrInterfaceDeclaration := ModifiersOpt 'class' ClassDeclarationRest | ModifiersOpt 'interface' InterfaceDeclarationRest
 Java.CompilationUnit parseCompilationUnit()
           CompilationUnit := [ 'package' QualifiedIdentifier ';' ] { ImportDeclaration } { TypeDeclaration }
 Java.Atom parseConditionalAndExpression(Java.Scope enclosingScope)
           ConditionalAndExpression := InclusiveOrExpression { '&&' InclusiveOrExpression }
 Java.Atom parseConditionalExpression(Java.Scope enclosingScope)
           ConditionalExpression := ConditionalOrExpression [ '?' Expression ':' ConditionalExpression ]
 Java.Atom parseConditionalOrExpression(Java.Scope enclosingScope)
           ConditionalOrExpression := ConditionalAndExpression { '||' ConditionalAndExpression ]
 Java.ConstructorDeclarator parseConstructorDeclarator(Java.ClassDeclaration declaringClass, String optionalDocComment, short modifiers)
           ConstructorDeclarator := FormalParameters [ 'throws' ReferenceTypeList ] '{' [ 'this' Arguments ';' | 'super' Arguments ';' ] BlockStatements '}'
 Java.Statement parseContinueStatement(Java.Scope enclosingScope)
           ContinueStatement := 'continue' [ Identifier ] ';'
 Java.Rvalue parseDimExpr(Java.Scope enclosingScope)
           DimExpr := '[' Expression ']'
 Java.Rvalue[] parseDimExprs(Java.Scope enclosingScope)
           DimExprs := DimExpr { DimExpr }
 Java.Statement parseDoStatement(Java.Scope enclosingScope)
           DoStatement := 'do' Statement 'while' '(' Expression ')' ';'
 Java.Statement parseEmptyStatement(Java.Scope enclosingScope)
           EmptyStatement := ';'
 Java.Atom parseEqualityExpression(Java.Scope enclosingScope)
           EqualityExpression := RelationalExpression { ( '==' | '!=' ) RelationalExpression }
 Java.Atom parseExclusiveOrExpression(Java.Scope enclosingScope)
           ExclusiveOrExpression := AndExpression { '^' AndExpression }
 Java.Atom parseExpression(Java.Scope enclosingScope)
           Expression := AssignmentExpression
 Java.Rvalue[] parseExpressionList(Java.Scope enclosingScope)
           ExpressionList := Expression { ',' Expression }
 Java.Statement parseExpressionStatement(Java.Scope enclosingScope)
           ExpressionStatement := Expression ';'
 Java.VariableDeclarator[] parseFieldDeclaratorsRest(Java.Scope enclosingScope, Java.Type type, String name)
           FieldDeclaratorsRest := VariableDeclaratorRest { ',' VariableDeclarator }
 Java.FormalParameter parseFormalParameter(Java.Scope enclosingScope)
           FormalParameter := [ 'final' ] Type Identifier BracketsOpt
 Java.FormalParameter[] parseFormalParameters(Java.Scope enclosingScope)
           FormalParameters := '(' [ FormalParameter { ',' FormalParameter } ] ')'
 Java.Statement parseForStatement(Java.Scope enclosingScope)
           ForStatement := 'for' '(' [ ForInit ] ';' [ Expression ] ';' [ ExpressionList ] ')' Statement
 Java.Statement parseIfStatement(Java.Scope enclosingScope)
           IfStatement := 'if' '(' Expression ')' Statement [ 'else' Statement ]
 Java.ImportDeclaration parseImportDeclaration()
           ImportDeclaration := 'import' Identifier { '.' Identifier } [ '.' '*' ] ';'
 Java.Atom parseInclusiveOrExpression(Java.Scope enclosingScope)
           InclusiveOrExpression := ExclusiveOrExpression { '|' ExclusiveOrExpression }
 void parseInterfaceBody(Java.InterfaceDeclaration interfaceDeclaration)
           InterfaceBody := '{' { ';' | ModifiersOpt ( 'void' Identifier MethodDeclaratorRest | 'class' ClassDeclarationRest | 'interface' InterfaceDeclarationRest | Type Identifier ( MethodDeclaratorRest | FieldDeclaratorsRest ) ) } '}'
 Java.InterfaceDeclaration parseInterfaceDeclarationRest(Java.Scope enclosingScope, String optionalDocComment, short modifiers)
           InterfaceDeclarationRest := Identifier [ 'extends' ReferenceTypeList ] InterfaceBody
 Java.Statement parseLabeledStatement(Java.Scope enclosingScope)
           LabeledStatement := Identifier ':' Statement
 Java.Atom parseLiteral()
           
 Java.VariableDeclarator[] parseLocalVariableDeclarators(Java.Scope enclosingScope, Java.Type type)
           LocalVariableDeclarators := VariableDeclarator { ',' VariableDeclarator }
 Java.Block parseMethodBody(Java.FunctionDeclarator declaringFunction)
           MethodBody := Block
 Java.MethodDeclarator parseMethodDeclaratorRest(Java.AbstractTypeDeclaration declaringType, String optionalDocComment, short modifiers, Java.Type type, String name)
           MethodDeclaratorRest := FormalParameters { '[' ']' } [ 'throws' ReferenceTypeList ] ( ';' | MethodBody )
 short parseModifiersOpt()
           ModifiersOpt := { 'public' | 'protected' | 'private' | 'static' | 'abstract' | 'final' | 'native' | 'synchronized' | 'transient' | 'volatile' | 'strictfp'
 Java.Atom parseMultiplicativeExpression(Java.Scope enclosingScope)
           MultiplicativeExpression := UnaryExpression { ( '*' | '/' | '%' ) UnaryExpression }
 Java.Atom parsePrimary(Java.Scope enclosingScope)
           Primary := '(' PrimitiveType { '[]' } ')' UnaryExpression | // CastExpression 15.16 '(' Expression ')' UnaryExpression | // 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 'new' ReferenceType Arguments [ ClassBody ] | // ClassInstanceCreationExpression 15.9 'new' Type DimExprs { '[]' } | // ArrayCreationExpression 15.10 'new' ArrayType ArrayInitializer | // ArrayInitializer 10.6 BasicType { '[]' } | // Type BasicType { '[]' } '.' 'class' | // ClassLiteral 15.8.2 'void' '.' 'class' // ClassLiteral 15.8.2
 String[] parseQualifiedIdentifier()
          QualifiedIdentifier := Identifier { '.' Identifier }
 Java.ReferenceType parseReferenceType(Java.Scope scope)
           ReferenceType := QualifiedIdentifier
 Java.ReferenceType[] parseReferenceTypeList(Java.Scope scope)
           ReferenceTypeList := ReferenceType { ',' ReferenceType }
 Java.Atom parseRelationalExpression(Java.Scope enclosingScope)
           RelationalExpression := ShiftExpression { ( ( '<' | '>' | '<=' | '>=' ) ShiftExpression ) | ( 'instanceof' ReferenceType ) }
 Java.Statement parseReturnStatement(Java.Scope enclosingScope)
           ReturnStatement := 'return' [ Expression ] ';'
 Java.Atom parseSelector(Java.Scope enclosingScope, 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.Atom parseShiftExpression(Java.Scope enclosingScope)
           ShiftExpression := AdditiveExpression { ( '<<' | '>>' | '>>>' ) AdditiveExpression }
 Java.Statement parseStatement(Java.Scope enclosingScope)
           Statement := LabeledStatement | Block | IfStatement | ForStatement | WhileStatement | DoStatement | TryStatement | 'switch' ...
 Java.Statement parseSwitchStatement(Java.Scope enclosingScope)
           SwitchStatement := 'switch' '(' Expression ')' '{' { SwitchLabels BlockStatements } '}' SwitchLabels := SwitchLabels { SwitchLabels } SwitchLabel := 'case' Expression ':' | 'default' ':'
 Java.Statement parseSynchronizedStatement(Java.Scope enclosingScope)
           SynchronizedStatement := 'synchronized' '(' expression ')' Block
 Java.Statement parseThrowStatement(Java.Scope enclosingScope)
           ThrowStatement := 'throw' Expression ';'
 Java.Statement parseTryStatement(Java.Scope enclosingScope)
           TryStatement := 'try' Block Catches [ Finally ] | 'try' Block Finally Catches := CatchClause { CatchClause } CatchClause := 'catch' '(' FormalParameter ')' Block Finally := 'finally' Block
 Java.Type parseType(Java.Scope scope)
           Type := ( 'byte' | 'short' | 'char' | 'int' | 'long' | 'float' | 'double' | 'boolean' | ReferenceType ) { '[' ']' }
 org.codehaus.janino.Java.NamedTypeDeclaration parseTypeDeclaration(Java.CompilationUnit compilationUnit)
           TypeDeclaration := ClassOrInterfaceDeclaration
 Java.Atom parseUnaryExpression(Java.Scope enclosingScope)
           UnaryExpression := { PrefixOperator } Primary { Selector } { PostfixOperator } PrefixOperator := '++' | '--' | '+' | '-' | '~' | '!' PostfixOperator := '++' | '--'
 Java.VariableDeclarator parseVariableDeclarator(Java.Scope enclosingScope, Java.Type type)
           VariableDeclarator := Identifier VariableDeclaratorRest
 Java.VariableDeclarator parseVariableDeclaratorRest(Java.Scope enclosingScope, Java.Type type, String name)
           VariableDeclaratorRest := { '[' ']' } [ '=' VariableInitializer ]
 Java.Rvalue parseVariableInitializer(Java.Scope enclosingScope, Java.Type type)
           VariableInitializer := ArrayInitializer | Expression
 Java.Statement parseWhileStatement(Java.Scope enclosingScope)
           WhileStatement := 'while' '(' Expression ')' Statement
 void setWarningHandler(WarningHandler warningHandler)
          By default, warnings are discarded, but an application my install a (thread-local) WarningHandler.
 
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
 

Constructor Detail

Parser

public Parser(Scanner scanner)
Method Detail

parseCompilationUnit

public Java.CompilationUnit parseCompilationUnit()
                                          throws Parser.ParseException,
                                                 Scanner.ScanException,
                                                 IOException
   CompilationUnit := [ 'package' QualifiedIdentifier ';' ]
                      { ImportDeclaration }
                      { TypeDeclaration }
 

Throws:
Parser.ParseException
Scanner.ScanException
IOException

parseImportDeclaration

public Java.ImportDeclaration parseImportDeclaration()
                                              throws Parser.ParseException,
                                                     Scanner.ScanException,
                                                     IOException
   ImportDeclaration := 'import' Identifier
                        { '.' Identifier }
                        [ '.' '*' ]
                        ';'
 

Throws:
Parser.ParseException
Scanner.ScanException
IOException

parseQualifiedIdentifier

public String[] parseQualifiedIdentifier()
                                  throws Parser.ParseException,
                                         Scanner.ScanException,
                                         IOException
QualifiedIdentifier := Identifier { '.' Identifier }

Throws:
Parser.ParseException
Scanner.ScanException
IOException

parseTypeDeclaration

public org.codehaus.janino.Java.NamedTypeDeclaration parseTypeDeclaration(Java.CompilationUnit compilationUnit)
                                                                   throws Parser.ParseException,
                                                                          Scanner.ScanException,
                                                                          IOException
   TypeDeclaration := ClassOrInterfaceDeclaration
 

Throws:
Parser.ParseException
Scanner.ScanException
IOException

parseClassOrInterfaceDeclaration

public org.codehaus.janino.Java.NamedTypeDeclaration parseClassOrInterfaceDeclaration(Java.Scope enclosingScope)
                                                                               throws Parser.ParseException,
                                                                                      Scanner.ScanException,
                                                                                      IOException
   ClassOrInterfaceDeclaration :=
             ModifiersOpt 'class' ClassDeclarationRest |
             ModifiersOpt 'interface' InterfaceDeclarationRest
 

Throws:
Parser.ParseException
Scanner.ScanException
IOException

parseModifiersOpt

public short parseModifiersOpt()
                        throws Parser.ParseException,
                               Scanner.ScanException,
                               IOException
   ModifiersOpt := { 'public' | 'protected' | 'private' | 'static' |
           'abstract' | 'final' | 'native' | 'synchronized' |
           'transient' | 'volatile' | 'strictfp'
 

Throws:
Parser.ParseException
Scanner.ScanException
IOException

parseClassDeclarationRest

public Java.NamedClassDeclaration parseClassDeclarationRest(Java.Scope enclosingScope,
                                                            String optionalDocComment,
                                                            short modifiers)
                                                     throws Parser.ParseException,
                                                            Scanner.ScanException,
                                                            IOException
   ClassDeclarationRest :=
        Identifier
        [ 'extends' ReferenceType ]
        [ 'implements' ReferenceTypeList ]
        ClassBody
 

Throws:
Parser.ParseException
Scanner.ScanException
IOException

parseClassBody

public void parseClassBody(Java.ClassDeclaration classDeclaration)
                    throws Parser.ParseException,
                           Scanner.ScanException,
                           IOException
   ClassBody := '{' { ClassBodyDeclaration } '}'
 

Throws:
Parser.ParseException
Scanner.ScanException
IOException

parseClassBodyDeclaration

public void parseClassBodyDeclaration(Java.ClassDeclaration classDeclaration)
                               throws Parser.ParseException,
                                      Scanner.ScanException,
                                      IOException
   ClassBodyDeclaration :=
     ';' |
     ModifiersOpt (
       Block |                                    // Instance (JLS2 8.6) or static initializer (JLS2 8.7)
       'void' Identifier MethodDeclaratorRest |
       'class' ClassDeclarationRest |
       'interface' InterfaceDeclarationRest |
       ConstructorDeclarator |
       Type Identifier (
         MethodDeclaratorRest |
         FieldDeclaratorsRest ';'
       )
     )

 

Throws:
Parser.ParseException
Scanner.ScanException
IOException

parseInterfaceDeclarationRest

public Java.InterfaceDeclaration parseInterfaceDeclarationRest(Java.Scope enclosingScope,
                                                               String optionalDocComment,
                                                               short modifiers)
                                                        throws Parser.ParseException,
                                                               Scanner.ScanException,
                                                               IOException
   InterfaceDeclarationRest :=
     Identifier
     [ 'extends' ReferenceTypeList ]
     InterfaceBody
 

Throws:
Parser.ParseException
Scanner.ScanException
IOException

parseInterfaceBody

public void parseInterfaceBody(Java.InterfaceDeclaration interfaceDeclaration)
                        throws Parser.ParseException,
                               Scanner.ScanException,
                               IOException
   InterfaceBody := '{' {
     ';' |
     ModifiersOpt (
       'void' Identifier MethodDeclaratorRest |
       'class' ClassDeclarationRest |
       'interface' InterfaceDeclarationRest |
       Type Identifier (
         MethodDeclaratorRest |
         FieldDeclaratorsRest
       )
     )
   } '}'
 

Throws:
Parser.ParseException
Scanner.ScanException
IOException

parseConstructorDeclarator

public Java.ConstructorDeclarator parseConstructorDeclarator(Java.ClassDeclaration declaringClass,
                                                             String optionalDocComment,
                                                             short modifiers)
                                                      throws Parser.ParseException,
                                                             Scanner.ScanException,
                                                             IOException
   ConstructorDeclarator :=
     FormalParameters
     [ 'throws' ReferenceTypeList ]
     '{'
       [ 'this' Arguments ';' | 'super' Arguments ';' ]
       BlockStatements
     '}'
 

Throws:
Parser.ParseException
Scanner.ScanException
IOException

parseMethodDeclaratorRest

public Java.MethodDeclarator parseMethodDeclaratorRest(Java.AbstractTypeDeclaration declaringType,
                                                       String optionalDocComment,
                                                       short modifiers,
                                                       Java.Type type,
                                                       String name)
                                                throws Parser.ParseException,
                                                       Scanner.ScanException,
                                                       IOException
   MethodDeclaratorRest :=
     FormalParameters
     { '[' ']' }
     [ 'throws' ReferenceTypeList ]
     ( ';' | MethodBody )
 

Throws:
Parser.ParseException
Scanner.ScanException
IOException

parseVariableInitializer

public Java.Rvalue parseVariableInitializer(Java.Scope enclosingScope,
                                            Java.Type type)
                                     throws Parser.ParseException,
                                            Scanner.ScanException,
                                            IOException
   VariableInitializer :=
     ArrayInitializer |
     Expression
 

Throws:
Parser.ParseException
Scanner.ScanException
IOException

parseArrayInitializer

public Java.Rvalue parseArrayInitializer(Java.Scope enclosingScope,
                                         Java.ArrayType arrayType)
                                  throws Parser.ParseException,
                                         Scanner.ScanException,
                                         IOException
   ArrayInitializer :=
     '{' [ VariableInitializer { ',' VariableInitializer } [ ',' ] '}'
 

Throws:
Parser.ParseException
Scanner.ScanException
IOException

parseFormalParameters

public Java.FormalParameter[] parseFormalParameters(Java.Scope enclosingScope)
                                             throws Parser.ParseException,
                                                    Scanner.ScanException,
                                                    IOException
   FormalParameters := '(' [ FormalParameter { ',' FormalParameter } ] ')'
 

Throws:
Parser.ParseException
Scanner.ScanException
IOException

parseFormalParameter

public Java.FormalParameter parseFormalParameter(Java.Scope enclosingScope)
                                          throws Parser.ParseException,
                                                 Scanner.ScanException,
                                                 IOException
   FormalParameter := [ 'final' ] Type Identifier BracketsOpt
 

Throws:
Parser.ParseException
Scanner.ScanException
IOException

parseMethodBody

public Java.Block parseMethodBody(Java.FunctionDeclarator declaringFunction)
                           throws Parser.ParseException,
                                  Scanner.ScanException,
                                  IOException
   MethodBody := Block
 

Throws:
Parser.ParseException
Scanner.ScanException
IOException

parseBlock

public Java.Block parseBlock(Java.Scope enclosingScope)
                      throws Parser.ParseException,
                             Scanner.ScanException,
                             IOException
   '{' BlockStatements '}'
 

Throws:
Parser.ParseException
Scanner.ScanException
IOException

parseBlockStatements

public List parseBlockStatements(Java.Block enclosingBlock)
                          throws Parser.ParseException,
                                 Scanner.ScanException,
                                 IOException
   BlockStatements := { BlockStatement }
 

Throws:
Parser.ParseException
Scanner.ScanException
IOException

parseBlockStatement

public Java.BlockStatement parseBlockStatement(Java.Block enclosingBlock)
                                        throws Parser.ParseException,
                                               Scanner.ScanException,
                                               IOException
   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.

Throws:
Parser.ParseException
Scanner.ScanException
IOException

parseLocalVariableDeclarators

public Java.VariableDeclarator[] parseLocalVariableDeclarators(Java.Scope enclosingScope,
                                                               Java.Type type)
                                                        throws Parser.ParseException,
                                                               Scanner.ScanException,
                                                               IOException
   LocalVariableDeclarators := VariableDeclarator { ',' VariableDeclarator }
 

Throws:
Parser.ParseException
Scanner.ScanException
IOException

parseFieldDeclaratorsRest

public Java.VariableDeclarator[] parseFieldDeclaratorsRest(Java.Scope enclosingScope,
                                                           Java.Type type,
                                                           String name)
                                                    throws Parser.ParseException,
                                                           Scanner.ScanException,
                                                           IOException
   FieldDeclaratorsRest :=
     VariableDeclaratorRest
     { ',' VariableDeclarator }
 

Throws:
Parser.ParseException
Scanner.ScanException
IOException

parseVariableDeclarator

public Java.VariableDeclarator parseVariableDeclarator(Java.Scope enclosingScope,
                                                       Java.Type type)
                                                throws Parser.ParseException,
                                                       Scanner.ScanException,
                                                       IOException
   VariableDeclarator := Identifier VariableDeclaratorRest
 

Throws:
Parser.ParseException
Scanner.ScanException
IOException

parseVariableDeclaratorRest

public Java.VariableDeclarator parseVariableDeclaratorRest(Java.Scope enclosingScope,
                                                           Java.Type type,
                                                           String name)
                                                    throws Parser.ParseException,
                                                           Scanner.ScanException,
                                                           IOException
   VariableDeclaratorRest := { '[' ']' } [ '=' VariableInitializer ]
 
Used by field declarations and local variable declarations.

Throws:
Parser.ParseException
Scanner.ScanException
IOException

parseStatement

public Java.Statement parseStatement(Java.Scope enclosingScope)
                              throws Parser.ParseException,
                                     Scanner.ScanException,
                                     IOException
   Statement :=
     LabeledStatement |
     Block |
     IfStatement |
     ForStatement |
     WhileStatement |
     DoStatement |
     TryStatement |
     'switch' ... |
     'synchronized' ... |
     ReturnStatement |
     ThrowStatement |
     BreakStatement |
     ContinueStatement |
     EmptyStatement |
     ExpressionStatement
 

Throws:
Parser.ParseException
Scanner.ScanException
IOException

parseLabeledStatement

public Java.Statement parseLabeledStatement(Java.Scope enclosingScope)
                                     throws Parser.ParseException,
                                            Scanner.ScanException,
                                            IOException
   LabeledStatement := Identifier ':' Statement
 

Throws:
Parser.ParseException
Scanner.ScanException
IOException

parseIfStatement

public Java.Statement parseIfStatement(Java.Scope enclosingScope)
                                throws Parser.ParseException,
                                       Scanner.ScanException,
                                       IOException
   IfStatement := 'if' '(' Expression ')' Statement [ 'else' Statement ]
 

Throws:
Parser.ParseException
Scanner.ScanException
IOException

parseForStatement

public Java.Statement parseForStatement(Java.Scope enclosingScope)
                                 throws Parser.ParseException,
                                        Scanner.ScanException,
                                        IOException
   ForStatement :=
     'for' '('
       [ ForInit ] ';'
       [ Expression ] ';'
       [ ExpressionList ]
     ')' Statement
 

Throws:
Parser.ParseException
Scanner.ScanException
IOException

parseWhileStatement

public Java.Statement parseWhileStatement(Java.Scope enclosingScope)
                                   throws Parser.ParseException,
                                          Scanner.ScanException,
                                          IOException
   WhileStatement := 'while' '(' Expression ')' Statement
 

Throws:
Parser.ParseException
Scanner.ScanException
IOException

parseDoStatement

public Java.Statement parseDoStatement(Java.Scope enclosingScope)
                                throws Parser.ParseException,
                                       Scanner.ScanException,
                                       IOException
   DoStatement := 'do' Statement 'while' '(' Expression ')' ';'
 

Throws:
Parser.ParseException
Scanner.ScanException
IOException

parseTryStatement

public Java.Statement parseTryStatement(Java.Scope enclosingScope)
                                 throws Parser.ParseException,
                                        Scanner.ScanException,
                                        IOException
   TryStatement :=
     'try' Block Catches [ Finally ] |
     'try' Block Finally

   Catches := CatchClause { CatchClause }

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

   Finally := 'finally' Block
 

Throws:
Parser.ParseException
Scanner.ScanException
IOException

parseSwitchStatement

public Java.Statement parseSwitchStatement(Java.Scope enclosingScope)
                                    throws Parser.ParseException,
                                           Scanner.ScanException,
                                           IOException
   SwitchStatement :=
     'switch' '(' Expression ')' '{' { SwitchLabels BlockStatements } '}'

   SwitchLabels := SwitchLabels { SwitchLabels }

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

Throws:
Parser.ParseException
Scanner.ScanException
IOException

parseSynchronizedStatement

public Java.Statement parseSynchronizedStatement(Java.Scope enclosingScope)
                                          throws Parser.ParseException,
                                                 Scanner.ScanException,
                                                 IOException
   SynchronizedStatement :=
     'synchronized' '(' expression ')' Block
 

Throws:
Parser.ParseException
Scanner.ScanException
IOException

parseReturnStatement

public Java.Statement parseReturnStatement(Java.Scope enclosingScope)
                                    throws Parser.ParseException,
                                           Scanner.ScanException,
                                           IOException
   ReturnStatement := 'return' [ Expression ] ';'
 

Throws:
Parser.ParseException
Scanner.ScanException
IOException

parseThrowStatement

public Java.Statement parseThrowStatement(Java.Scope enclosingScope)
                                   throws Parser.ParseException,
                                          Scanner.ScanException,
                                          IOException
   ThrowStatement := 'throw' Expression ';'
 

Throws:
Parser.ParseException
Scanner.ScanException
IOException

parseBreakStatement

public Java.Statement parseBreakStatement(Java.Scope enclosingScope)
                                   throws Parser.ParseException,
                                          Scanner.ScanException,
                                          IOException
   BreakStatement := 'break' [ Identifier ] ';'
 

Throws:
Parser.ParseException
Scanner.ScanException
IOException

parseContinueStatement

public Java.Statement parseContinueStatement(Java.Scope enclosingScope)
                                      throws Parser.ParseException,
                                             Scanner.ScanException,
                                             IOException
   ContinueStatement := 'continue' [ Identifier ] ';'
 

Throws:
Parser.ParseException
Scanner.ScanException
IOException

parseEmptyStatement

public Java.Statement parseEmptyStatement(Java.Scope enclosingScope)
                                   throws Parser.ParseException,
                                          Scanner.ScanException,
                                          IOException
   EmptyStatement := ';'
 

Throws:
Parser.ParseException
Scanner.ScanException
IOException

parseExpressionList

public Java.Rvalue[] parseExpressionList(Java.Scope enclosingScope)
                                  throws Parser.ParseException,
                                         Scanner.ScanException,
                                         IOException
   ExpressionList := Expression { ',' Expression }
 

Throws:
Parser.ParseException
Scanner.ScanException
IOException

parseType

public Java.Type parseType(Java.Scope scope)
                    throws Parser.ParseException,
                           Scanner.ScanException,
                           IOException
   Type := (
     'byte' | 'short' | 'char' | 'int' | 'long' |
     'float' | 'double' | 'boolean' |
     ReferenceType
   ) { '[' ']' }
 

Throws:
Parser.ParseException
Scanner.ScanException
IOException

parseReferenceType

public Java.ReferenceType parseReferenceType(Java.Scope scope)
                                      throws Parser.ParseException,
                                             Scanner.ScanException,
                                             IOException
   ReferenceType := QualifiedIdentifier
 

Throws:
Parser.ParseException
Scanner.ScanException
IOException

parseReferenceTypeList

public Java.ReferenceType[] parseReferenceTypeList(Java.Scope scope)
                                            throws Parser.ParseException,
                                                   Scanner.ScanException,
                                                   IOException
   ReferenceTypeList := ReferenceType { ',' ReferenceType }
 

Throws:
Parser.ParseException
Scanner.ScanException
IOException

parseExpression

public Java.Atom parseExpression(Java.Scope enclosingScope)
                          throws Parser.ParseException,
                                 Scanner.ScanException,
                                 IOException
   Expression := AssignmentExpression
 

Throws:
Parser.ParseException
Scanner.ScanException
IOException

parseAssignmentExpression

public Java.Atom parseAssignmentExpression(Java.Scope enclosingScope)
                                    throws Parser.ParseException,
                                           Scanner.ScanException,
                                           IOException
   AssignmentExpression :=
     ConditionalExpression [ AssignmentOperator AssignmentExpression ]

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

Throws:
Parser.ParseException
Scanner.ScanException
IOException

parseConditionalExpression

public Java.Atom parseConditionalExpression(Java.Scope enclosingScope)
                                     throws Parser.ParseException,
                                            Scanner.ScanException,
                                            IOException
   ConditionalExpression :=
     ConditionalOrExpression [ '?' Expression ':' ConditionalExpression ]
 

Throws:
Parser.ParseException
Scanner.ScanException
IOException

parseConditionalOrExpression

public Java.Atom parseConditionalOrExpression(Java.Scope enclosingScope)
                                       throws Parser.ParseException,
                                              Scanner.ScanException,
                                              IOException
   ConditionalOrExpression :=
     ConditionalAndExpression { '||' ConditionalAndExpression ]
 

Throws:
Parser.ParseException
Scanner.ScanException
IOException

parseConditionalAndExpression

public Java.Atom parseConditionalAndExpression(Java.Scope enclosingScope)
                                        throws Parser.ParseException,
                                               Scanner.ScanException,
                                               IOException
   ConditionalAndExpression :=
     InclusiveOrExpression { '&&' InclusiveOrExpression }
 

Throws:
Parser.ParseException
Scanner.ScanException
IOException

parseInclusiveOrExpression

public Java.Atom parseInclusiveOrExpression(Java.Scope enclosingScope)
                                     throws Parser.ParseException,
                                            Scanner.ScanException,
                                            IOException
   InclusiveOrExpression :=
     ExclusiveOrExpression { '|' ExclusiveOrExpression }
 

Throws:
Parser.ParseException
Scanner.ScanException
IOException

parseExclusiveOrExpression

public Java.Atom parseExclusiveOrExpression(Java.Scope enclosingScope)
                                     throws Parser.ParseException,
                                            Scanner.ScanException,
                                            IOException
   ExclusiveOrExpression :=
     AndExpression { '^' AndExpression }
 

Throws:
Parser.ParseException
Scanner.ScanException
IOException

parseAndExpression

public Java.Atom parseAndExpression(Java.Scope enclosingScope)
                             throws Parser.ParseException,
                                    Scanner.ScanException,
                                    IOException
   AndExpression :=
     EqualityExpression { '&' EqualityExpression }
 

Throws:
Parser.ParseException
Scanner.ScanException
IOException

parseEqualityExpression

public Java.Atom parseEqualityExpression(Java.Scope enclosingScope)
                                  throws Parser.ParseException,
                                         Scanner.ScanException,
                                         IOException
   EqualityExpression :=
     RelationalExpression { ( '==' | '!=' ) RelationalExpression }
 

Throws:
Parser.ParseException
Scanner.ScanException
IOException

parseRelationalExpression

public Java.Atom parseRelationalExpression(Java.Scope enclosingScope)
                                    throws Parser.ParseException,
                                           Scanner.ScanException,
                                           IOException
   RelationalExpression :=
     ShiftExpression {
       ( ( '<' | '>' | '<=' | '>=' ) ShiftExpression ) |
       ( 'instanceof' ReferenceType )
     }
 

Throws:
Parser.ParseException
Scanner.ScanException
IOException

parseShiftExpression

public Java.Atom parseShiftExpression(Java.Scope enclosingScope)
                               throws Parser.ParseException,
                                      Scanner.ScanException,
                                      IOException
   ShiftExpression :=
     AdditiveExpression { ( '<<' | '>>' | '>>>' ) AdditiveExpression }
 

Throws:
Parser.ParseException
Scanner.ScanException
IOException

parseAdditiveExpression

public Java.Atom parseAdditiveExpression(Java.Scope enclosingScope)
                                  throws Parser.ParseException,
                                         Scanner.ScanException,
                                         IOException
   AdditiveExpression :=
     MultiplicativeExpression { ( '+' | '-' ) MultiplicativeExpression }
 

Throws:
Parser.ParseException
Scanner.ScanException
IOException

parseMultiplicativeExpression

public Java.Atom parseMultiplicativeExpression(Java.Scope enclosingScope)
                                        throws Parser.ParseException,
                                               Scanner.ScanException,
                                               IOException
   MultiplicativeExpression :=
     UnaryExpression { ( '*' | '/' | '%' ) UnaryExpression }
 

Throws:
Parser.ParseException
Scanner.ScanException
IOException

parseUnaryExpression

public Java.Atom parseUnaryExpression(Java.Scope enclosingScope)
                               throws Parser.ParseException,
                                      Scanner.ScanException,
                                      IOException
   UnaryExpression :=
     { PrefixOperator } Primary { Selector } { PostfixOperator }

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

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

Throws:
Parser.ParseException
Scanner.ScanException
IOException

parsePrimary

public Java.Atom parsePrimary(Java.Scope enclosingScope)
                       throws Parser.ParseException,
                              Scanner.ScanException,
                              IOException
   Primary :=
     '(' PrimitiveType { '[]' } ')' UnaryExpression | // CastExpression 15.16
     '(' Expression ')' UnaryExpression |    // 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
     'new' ReferenceType Arguments [ ClassBody ] | // ClassInstanceCreationExpression 15.9
     'new' Type DimExprs { '[]' } |          // ArrayCreationExpression 15.10
     'new' ArrayType ArrayInitializer |      // ArrayInitializer 10.6
     BasicType { '[]' } |                    // Type
     BasicType { '[]' } '.' 'class' |        // ClassLiteral 15.8.2
     'void' '.' 'class'                      // ClassLiteral 15.8.2
 

Throws:
Parser.ParseException
Scanner.ScanException
IOException

parseSelector

public Java.Atom parseSelector(Java.Scope enclosingScope,
                               Java.Atom atom)
                        throws Parser.ParseException,
                               Scanner.ScanException,
                               IOException
   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
 

Throws:
Parser.ParseException
Scanner.ScanException
IOException

parseDimExprs

public Java.Rvalue[] parseDimExprs(Java.Scope enclosingScope)
                            throws Parser.ParseException,
                                   Scanner.ScanException,
                                   IOException
   DimExprs := DimExpr { DimExpr }
 

Throws:
Parser.ParseException
Scanner.ScanException
IOException

parseDimExpr

public Java.Rvalue parseDimExpr(Java.Scope enclosingScope)
                         throws Scanner.ScanException,
                                Parser.ParseException,
                                IOException
   DimExpr := '[' Expression ']'
 

Throws:
Scanner.ScanException
Parser.ParseException
IOException

parseArguments

public Java.Rvalue[] parseArguments(Java.Scope enclosingScope)
                             throws Parser.ParseException,
                                    Scanner.ScanException,
                                    IOException
   Arguments := '(' [ ArgumentList ] ')'
 

Throws:
Parser.ParseException
Scanner.ScanException
IOException

parseArgumentList

public Java.Rvalue[] parseArgumentList(Java.Scope enclosingScope)
                                throws Parser.ParseException,
                                       Scanner.ScanException,
                                       IOException
   ArgumentList := Expression { ',' Expression }
 

Throws:
Parser.ParseException
Scanner.ScanException
IOException

parseLiteral

public Java.Atom parseLiteral()
                       throws Parser.ParseException,
                              Scanner.ScanException,
                              IOException
Throws:
Parser.ParseException
Scanner.ScanException
IOException

parseExpressionStatement

public Java.Statement parseExpressionStatement(Java.Scope enclosingScope)
                                        throws Parser.ParseException,
                                               Scanner.ScanException,
                                               IOException
   ExpressionStatement := Expression ';'
 

Throws:
Parser.ParseException
Scanner.ScanException
IOException

setWarningHandler

public void setWarningHandler(WarningHandler warningHandler)
By default, warnings are discarded, but an application my install a (thread-local) WarningHandler.


Web Site