Java Doc for Parser.java in  » Scripting » jacl » org » codehaus » janino » Java Source Code / Java DocumentationJava Source Code and Java Documentation

 BlockStatement := { Identifier ':' } (
 ( Modifiers Type | ModifiersOpt BasicType ) LocalVariableDeclarators ';' |
 'class' ...

 Statement :=
 LabeledStatement |
 Block |
 IfStatement |
 ForStatement |
 WhileStatement |
 DoStatement |
 TryStatement |
 'switch' ...

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

Notice that there is no Parser.setErrorHandler() method, but parse errors always throw a ParseException .

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

 AndExpression :=
 EqualityExpression { '&' EqualityExpression }
 

 ArgumentList := Expression { ',' Expression }
 

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

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

 AssignmentExpression :=
 ConditionalExpression [ AssignmentOperator AssignmentExpression ]
 AssignmentOperator :=
 '=' | '*=' | '/=' | '%=' | '+=' | '-=' | '<<=' |
 '>>=' | '>>>=' | '&=' | '^=' | '|='
 

 '{' BlockStatements '}'
 

 BlockStatement := { Identifier ':' } (
 ( Modifiers Type | ModifiersOpt BasicType ) LocalVariableDeclarators ';' |
 'class' ... |
 Statement |
 'final' Type LocalVariableDeclarators ';' |
 Expression ';' |
 Expression LocalVariableDeclarators ';'   (1)
 )
 

 BlockStatements := { BlockStatement }
 

 BracketsOpt := { '[' ']' }
 

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

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

 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 ';'
 )
 )
 

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

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

 ConditionalAndExpression :=
 InclusiveOrExpression { '&&' InclusiveOrExpression }
 

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

 ConditionalOrExpression :=
 ConditionalAndExpression { '||' ConditionalAndExpression ]
 

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

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

 DimExpr := '[' Expression ']'
 

 DimExprs := DimExpr { DimExpr }
 

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

 EmptyStatement := ';'
 

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

 ExclusiveOrExpression :=
 AndExpression { '^' AndExpression }
 

 Expression := AssignmentExpression
 

 ExpressionList := Expression { ',' Expression }
 

 ExpressionStatement := Expression ';'
 

 FieldDeclarationRest :=
 VariableDeclaratorRest
 { ',' VariableDeclarator }
 

 ForStatement :=
 'for' '('
 [ ForInit ] ';'
 [ Expression ] ';'
 [ ExpressionList ]
 ')' Statement
 

 FormalParameter := [ 'final' ] Type Identifier BracketsOpt
 

 FormalParameters := '(' [ FormalParameter { ',' FormalParameter } ] ')'
 

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

 ImportDeclaration := 'import' ImportDeclarationBody ';'
 

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

 InclusiveOrExpression :=
 ExclusiveOrExpression { '|' ExclusiveOrExpression }
 

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

 InterfaceDeclarationRest :=
 Identifier
 [ 'extends' ReferenceTypeList ]
 InterfaceBody
 

 LabeledStatement := Identifier ':' Statement
 

 LocalVariableDeclarators := VariableDeclarator { ',' VariableDeclarator }
 

 MethodBody := Block
 

 MethodDeclarationRest :=
 FormalParameters
 { '[' ']' }
 [ 'throws' ReferenceTypeList ]
 ( ';' | MethodBody )
 

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

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

 PackageDeclaration := 'package' QualifiedIdentifier ';'
 

 PackageMemberTypeDeclaration :=
 ModifiersOpt 'class' ClassDeclarationRest |
 ModifiersOpt 'interface' InterfaceDeclarationRest
 

 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
 

 ReferenceType := QualifiedIdentifier
 

 ReferenceTypeList := ReferenceType { ',' ReferenceType }
 

 RelationalExpression :=
 ShiftExpression {
 ( ( '<' | '>' | '<=' | '>=' ) ShiftExpression ) |
 ( 'instanceof' ReferenceType )
 }
 

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

 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
 

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

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

 SwitchStatement :=
 'switch' '(' Expression ')' '{' { SwitchLabels BlockStatements } '}'
 SwitchLabels := SwitchLabels { SwitchLabels }
 SwitchLabel := 'case' Expression ':' | 'default' ':'
 

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

 ThrowStatement := 'throw' Expression ';'
 

 TryStatement :=
 'try' Block Catches [ Finally ] |
 'try' Block Finally
 Catches := CatchClause { CatchClause }
 CatchClause := 'catch' '(' FormalParameter ')' Block
 Finally := 'finally' Block
 

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

 UnaryExpression :=
 { PrefixOperator } Primary { Selector } { PostfixOperator }
 PrefixOperator := '++' | '--' | '+' | '-' | '~' | '!'
 PostfixOperator := '++' | '--'
 

 VariableDeclarator := Identifier VariableDeclaratorRest
 

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

 VariableInitializer :=
 ArrayInitializer |
 Expression
 

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

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