| Contents | Prev | Next | Index | +Java Language Specification +First Edition |
+CHAPTER + 19
+ ++ +This chapter presents a grammar for Java. The grammar has been mechanically +checked to insure that it is LALR(1). +
+The grammar for Java presented piecemeal in the preceding chapters is much better for exposition, but it cannot be parsed left-to-right with one token of lookahead because of certain syntactic peculiarities, some of them inherited from C and C++. These problems and the solutions adopted for the LALR(1) grammar are presented below, followed by the grammar itself.
+PackageName:+and: +
+ Identifier
+ PackageName.Identifier + +TypeName:
+ Identifier
+ PackageName.Identifier +
+MethodName:+Now consider the partial input: +
+ Identifier
+ AmbiguousName.Identifier + +AmbiguousName:
+ Identifier
+ AmbiguousName.Identifier +
class Problem1 { int m() { hayden. ++When the parser is considering the token
hayden, with one-token lookahead to
+symbol ".", it cannot yet tell whether hayden should be a PackageName that
+qualifies a type name, as in:
+hayden.Dinosaur rex = new hayden.Dinosaur(2); ++or an AmbiguousName that qualifies a method name, as in: +
hayden.print("Dinosaur Rex!"); ++Therefore, the productions shown above result in a grammar that is not LALR(1). +There are also other problems with drawing distinctions among different kinds of +names in the grammar. +
+The solution is to eliminate the nonterminals PackageName, TypeName, ExpressionName, MethodName, and AmbiguousName, replacing them all with a single nonterminal Name:
+
+Name:+A later stage of compiler analysis then sorts out the precise role of each name or +name qualifier. +
+ SimpleName
+ QualifiedName + +SimpleName:
+ Identifier + +QualifiedName:
+ Name.Identifier +
+For related reasons, these productions in §4.3:
+
+ClassOrInterfaceType:+were changed to: +
+ ClassType
+ InterfaceType + +ClassType:
+ TypeName + +InterfaceType:
+ TypeName +
+ClassOrInterfaceType:+
+ Name + +ClassType:
+ClassOrInterfaceType + +InterfaceType:
+ClassOrInterfaceType +
+FieldDeclaration:+and: +
+ FieldModifiersoptTypeVariableDeclarators; ++FieldModifiers:
+ FieldModifier
+ FieldModifiersFieldModifier + +FieldModifier: one of
+publicprotectedprivate
+ final static transient volatile +
+MethodHeader:+Now consider the partial input: +
+ MethodModifiersoptResultTypeMethodDeclaratorThrowsopt + +MethodModifiers:
+ MethodModifier
+ MethodModifiersMethodModifier + +MethodModifier: one of
+publicprotectedprivate
+ static
+ abstract final native synchronized +
class Problem2 { public static int ++When the parser is considering the token
static, with one-token lookahead to
+symbol int-or, worse yet, considering the token public with lookahead to
+static-it cannot yet tell whether this will be a field declaration such as:
+public static int maddie = 0; ++or a method declaration such as: +
public static int maddie(String art) { return art.length(); } ++Therefore, the parser cannot tell with only one-token lookahead whether
static
+(or, similarly, public) should be reduced to FieldModifier or MethodModifier.
+Therefore, the productions shown above result in a grammar that is not LALR(1).
+There are also other problems with drawing distinctions among different kinds of
+modifiers in the grammar.
++While not all contexts provoke the problem, the simplest solution is to combine all contexts in which such modifiers are used, eliminating all six of the nonterminals ClassModifiers (§8.1.2), FieldModifiers (§8.3.1), MethodModifiers (§8.4.3), ConstructorModifiers (§8.6.3), InterfaceModifiers (§9.1.2), and ConstantModifiers (§9.3) from the grammar, replacing them all with a single nonterminal Modifiers:
+
+Modifiers:+A later stage of compiler analysis then sorts out the precise role of each modifier +and whether it is permitted in a given context. +
+ Modifier
+ ModifiersModifier + +Modifier: one of
+public protected private
+ static
+ abstract final native synchronized transient volatile +
+FieldDeclaration:+and: +
+ ModifiersoptTypeVariableDeclarators; +
+MethodHeader:+where ResultType is defined as: +
+ ModifiersoptResultTypeMethodDeclaratorThrowsopt +
+ResultType:+Now consider the partial input: +
+ Type
+void +
class Problem3 { int julie ++Note that, in this simple example, no Modifiers are present. When the parser is +considering the token
int, with one-token lookahead to symbol julie, it cannot
+yet tell whether this will be a field declaration such as:
+int julie = 14; ++or a method declaration such as: +
int julie(String art) { return art.length(); } ++Therefore, after the parser reduces
int to the nonterminal Type, it cannot tell with
+only one-token lookahead whether Type should be further reduced to ResultType
+(for a method declaration) or left alone (for a field declaration). Therefore, the
+productions shown above result in a grammar that is not LALR(1).
++The solution is to eliminate the ResultType production and to have separate alternatives for MethodHeader:
+
+MethodHeader:+This allows the parser to reduce
+ ModifiersoptTypeMethodDeclaratorThrowsopt
+ ModifiersoptvoidMethodDeclaratorThrowsopt +
int to Type and then leave it as is, delaying the decision as to whether a field declaration or method declaration is in progress.+ArrayType:+and: +
+Type[ ] +
+ArrayAccess:+Now consider the partial input: +
+ Name[Expression]PrimaryNoNewArray
+[Expression] +
class Problem4 { Problem4() { peter[ ++When the parser is considering the token
peter, with one-token lookahead to
+symbol [, it cannot yet tell whether peter will be part of a type name, as in:
+peter[] team; ++or part of an array access, as in: +
peter[3] = 12; ++Therefore, after the parser reduces
peter to the nonterminal Name, it cannot tell
+with only one-token lookahead whether Name should be reduced ultimately to
+Type (for an array type) or left alone (for an array access). Therefore, the productions
+shown above result in a grammar that is not LALR(1).
++The solution is to have separate alternatives for ArrayType:
+
+ArrayType:+This allows the parser to reduce
+PrimitiveType[ ]Name
+[ ]ArrayType
+[ ] +
peter to Name and then leave it as is, delaying
+the decision as to whether an array type or array access is in progress.
++CastExpression:+Now consider the partial input: +
+(PrimitiveType)UnaryExpression
+(ReferenceType)UnaryExpressionNotPlusMinus +
class Problem5 { Problem5() { super((matthew) ++When the parser is considering the token
matthew, with one-token lookahead to
+symbol ), it cannot yet tell whether (matthew) will be a parenthesized expression,
+as in:
+super((matthew), 9); ++or a cast, as in: +
super((matthew)baz, 9); ++Therefore, after the parser reduces
matthew to the nonterminal Name, it cannot
+tell with only one-token lookahead whether Name should be further reduced to
+PostfixExpression and ultimately to Expression (for a parenthesized expression) or
+to ClassOrInterfaceType and then to ReferenceType (for a cast). Therefore, the
+productions shown above result in a grammar that is not LALR(1).
++The solution is to eliminate the use of the nonterminal ReferenceType in the definition of CastExpression, which requires some reworking of both alternatives to avoid other ambiguities:
+
+CastExpression:+This allows the parser to reduce
+(PrimitiveTypeDimsopt)UnaryExpression
+(Expression)UnaryExpressionNotPlusMinus
+(NameDims)UnaryExpressionNotPlusMinus +
matthew to Expression and then leave it there,
+delaying the decision as to whether a parenthesized expression or a cast is in
+progress. Inappropriate variants such as:
+(int[])+3 ++and: +
(matthew+1)baz ++must then be weeded out and rejected by a later stage of compiler analysis. +
+The remaining sections of this chapter constitute a LALR(1) grammar for Java syntax, in which the five problems described above have been solved.
+Goal:+
+ CompilationUnit +
+Literal:+
+ IntegerLiteral
+ FloatingPointLiteral
+ BooleanLiteral
+ CharacterLiteral
+ StringLiteral
+ NullLiteral +
+Type:+
+PrimitiveType
+ ReferenceType + +PrimitiveType:
+ NumericType
+boolean ++NumericType:
+ IntegralType
+ FloatingPointType + +IntegralType: one of
+byte short int long char ++FloatingPointType: one of
+float double ++ReferenceType:
+ ClassOrInterfaceType
+ ArrayType + +ClassOrInterfaceType:
+ Name + +ClassType:
+ClassOrInterfaceType + +InterfaceType:
+ClassOrInterfaceType + +ArrayType:
+PrimitiveType[ ]Name
+[ ]ArrayType
+[ ] +
+Name:+
+ SimpleName
+ QualifiedName + +SimpleName:
+ Identifier + +QualifiedName:
+ Name.Identifier +
+CompilationUnit:+
+ PackageDeclarationoptImportDeclarationsoptTypeDeclarationsopt + +ImportDeclarations:
+ ImportDeclaration
+ ImportDeclarationsImportDeclaration + +TypeDeclarations:
+ TypeDeclaration
+ TypeDeclarationsTypeDeclaration + +PackageDeclaration:
+packageName; ++ImportDeclaration:
+ SingleTypeImportDeclaration
+ TypeImportOnDemandDeclaration + +SingleTypeImportDeclaration:
+importName; ++TypeImportOnDemandDeclaration:
+importName. * ; ++TypeDeclaration:
+ ClassDeclaration
+ InterfaceDeclaration
+; +
+Modifiers:+
+ Modifier
+ ModifiersModifier + +Modifier: one of
+public protected private
+ static
+ abstract final native synchronized transient volatile +
+ClassDeclaration:+
+ ModifiersoptclassIdentifierSuperoptInterfacesoptClassBody + +Super:
+extendsClassType + +Interfaces:
+implementsInterfaceTypeList + +InterfaceTypeList:
+ InterfaceType
+ InterfaceTypeList,InterfaceType + +ClassBody:
+{ClassBodyDeclarationsopt} ++ClassBodyDeclarations:
+ ClassBodyDeclaration
+ ClassBodyDeclarationsClassBodyDeclaration + +ClassBodyDeclaration:
+ ClassMemberDeclaration
+ StaticInitializer
+ ConstructorDeclaration + +ClassMemberDeclaration:
+ FieldDeclaration
+ MethodDeclaration +
+FieldDeclaration:+
+ ModifiersoptTypeVariableDeclarators; ++VariableDeclarators:
+ VariableDeclarator
+ VariableDeclarators,VariableDeclarator + +VariableDeclarator:
+ VariableDeclaratorId
+ VariableDeclaratorId=VariableInitializer + +VariableDeclaratorId:
+ Identifier
+ VariableDeclaratorId[ ] ++VariableInitializer:
+ Expression
+ ArrayInitializer +
+MethodDeclaration:+
+ MethodHeaderMethodBody + +MethodHeader:
+ ModifiersoptTypeMethodDeclaratorThrowsopt
+ ModifiersoptvoidMethodDeclaratorThrowsopt + +MethodDeclarator:
+ Identifier(FormalParameterListopt)MethodDeclarator
+[ ] ++FormalParameterList:
+ FormalParameter
+ FormalParameterList,FormalParameter + +FormalParameter:
+ TypeVariableDeclaratorId + +Throws:
+throwsClassTypeList + +ClassTypeList:
+ ClassType
+ ClassTypeList,ClassType + +MethodBody:
+ Block
+; +
+StaticInitializer:+
+staticBlock +
+ConstructorDeclaration:+
+ ModifiersoptConstructorDeclaratorThrowsoptConstructorBody + +ConstructorDeclarator:
+SimpleName(FormalParameterListopt) ++ConstructorBody:
+{ExplicitConstructorInvocationoptBlockStatementsopt} ++ExplicitConstructorInvocation:
+this (ArgumentListopt) ;
+super (ArgumentListopt) ; +
+InterfaceDeclaration:+
+ ModifiersoptinterfaceIdentifierExtendsInterfacesoptInterfaceBody + +ExtendsInterfaces:
+extendsInterfaceType
+ ExtendsInterfaces,InterfaceType + +InterfaceBody:
+{InterfaceMemberDeclarationsopt} ++InterfaceMemberDeclarations:
+ InterfaceMemberDeclaration
+ InterfaceMemberDeclarationsInterfaceMemberDeclaration + +InterfaceMemberDeclaration:
+ ConstantDeclaration
+ AbstractMethodDeclaration + +ConstantDeclaration:
+ FieldDeclaration + +AbstractMethodDeclaration:
+ MethodHeader; +
+ArrayInitializer:+
+{VariableInitializersopt,opt} ++VariableInitializers:
+ VariableInitializer
+ VariableInitializers,VariableInitializer +
+Block:
+{BlockStatementsopt} ++BlockStatements:
+BlockStatement
+BlockStatementsBlockStatement + +BlockStatement:
+ LocalVariableDeclarationStatement
+ Statement + +LocalVariableDeclarationStatement:
+ LocalVariableDeclaration; ++LocalVariableDeclaration:
+ TypeVariableDeclarators + +Statement:
+ StatementWithoutTrailingSubstatement
+ LabeledStatement
+ IfThenStatement
+ IfThenElseStatement
+ WhileStatement
+ ForStatement + +StatementNoShortIf:
+ StatementWithoutTrailingSubstatement
+ LabeledStatementNoShortIf
+ IfThenElseStatementNoShortIf
+ WhileStatementNoShortIf
+ ForStatementNoShortIf + +StatementWithoutTrailingSubstatement:
+ Block
+ EmptyStatement
+ ExpressionStatement
+ SwitchStatement
+ DoStatement
+ BreakStatement
+ ContinueStatement
+ ReturnStatement
+ SynchronizedStatement
+ ThrowStatement
+ TryStatement + +EmptyStatement:
+; ++LabeledStatement:
+ Identifier:Statement + +LabeledStatementNoShortIf:
+ Identifier:StatementNoShortIf + +ExpressionStatement:
+ StatementExpression; ++StatementExpression:
+ Assignment
+ PreIncrementExpression
+ PreDecrementExpression
+ PostIncrementExpression
+ PostDecrementExpression
+ MethodInvocation
+ ClassInstanceCreationExpression +
+IfThenStatement:
+if (Expression)Statement + +IfThenElseStatement:
+if (Expression)StatementNoShortIfelseStatement + +IfThenElseStatementNoShortIf:
+if (Expression)StatementNoShortIfelseStatementNoShortIf + +SwitchStatement:
+switch (Expression)SwitchBlock + +SwitchBlock:
+{SwitchBlockStatementGroupsoptSwitchLabelsopt} ++SwitchBlockStatementGroups:
+SwitchBlockStatementGroup
+SwitchBlockStatementGroupsSwitchBlockStatementGroup + +SwitchBlockStatementGroup:
+ SwitchLabelsBlockStatements + +SwitchLabels:
+ SwitchLabel
+ SwitchLabelsSwitchLabel + +SwitchLabel:
+caseConstantExpression:+WhileStatement:
+ default : +
+while (Expression)Statement + +WhileStatementNoShortIf:
+while (Expression)StatementNoShortIf + +DoStatement:
+doStatementwhile (Expression) ; +
+ForStatement:+
+for (ForInitopt;Expressionopt;ForUpdateopt)Statement + +ForStatementNoShortIf:
+
+for (ForInitopt;Expressionopt;ForUpdateopt)StatementNoShortIf + +ForInit:
+
+StatementExpressionList
+ LocalVariableDeclaration + +ForUpdate:
+ StatementExpressionList + +StatementExpressionList:
+ StatementExpression
+ StatementExpressionList,StatementExpression + +BreakStatement:
+breakIdentifieropt; ++ContinueStatement:
+continue Identifieropt; ++ReturnStatement:
+returnExpressionopt; ++ThrowStatement:
+throwExpression; ++SynchronizedStatement:
+synchronized (Expression)Block + +TryStatement:
+tryBlockCatches
+tryBlockCatchesoptFinally + +Catches:
+ CatchClause
+ CatchesCatchClause + +CatchClause:
+catch (FormalParameter)Block + +Finally:
+finallyBlock +
+Primary:+
+ PrimaryNoNewArray
+ ArrayCreationExpression + +PrimaryNoNewArray:
+ Literal
+this
+(Expression)ClassInstanceCreationExpression
+
+ FieldAccess
+ MethodInvocation
+ ArrayAccess + +ClassInstanceCreationExpression:
+newClassType(ArgumentListopt) ++ArgumentList:
+ Expression
+ ArgumentList,Expression + +ArrayCreationExpression:
+newPrimitiveTypeDimExprsDimsopt
+newClassOrInterfaceTypeDimExprsDimsopt + +DimExprs:
+ DimExpr
+ DimExprsDimExpr + +DimExpr:
+[Expression] ++Dims:
+[ ]Dims
+[ ] ++FieldAccess:
+ Primary.Identifier
+super .Identifier + +MethodInvocation:
+ Name(ArgumentListopt)Primary
+.Identifier(ArgumentListopt)Identifier
+ super .(ArgumentListopt) ++ArrayAccess:
+ Name[Expression]PrimaryNoNewArray
+[Expression] ++PostfixExpression:
+ Primary
+ Name
+ PostIncrementExpression
+ PostDecrementExpression + +PostIncrementExpression:
+ PostfixExpression++ ++PostDecrementExpression:
+ PostfixExpression-- ++UnaryExpression:
+PreIncrementExpression
+PreDecrementExpression
++UnaryExpression
+-UnaryExpression
+ UnaryExpressionNotPlusMinus + +PreIncrementExpression:
+++UnaryExpression + +PreDecrementExpression:
+--UnaryExpression + +UnaryExpressionNotPlusMinus:
+PostfixExpression
+~UnaryExpression
+!UnaryExpression
+CastExpression + +CastExpression:
+(PrimitiveTypeDimsopt)UnaryExpression
+(Expression)UnaryExpressionNotPlusMinus
+(NameDims)UnaryExpressionNotPlusMinus + +MultiplicativeExpression:
+ UnaryExpression
+ MultiplicativeExpression*UnaryExpression
+ MultiplicativeExpression/UnaryExpression
+ MultiplicativeExpression%UnaryExpression + +AdditiveExpression:
+ MultiplicativeExpression
+ AdditiveExpression+MultiplicativeExpression
+AdditiveExpression-MultiplicativeExpression + +ShiftExpression:
+ AdditiveExpression
+ ShiftExpression<<AdditiveExpression
+ ShiftExpression>>AdditiveExpression
+ ShiftExpression>>>AdditiveExpression + +RelationalExpression:
+ ShiftExpression
+ RelationalExpression<ShiftExpression
+ RelationalExpression>ShiftExpression
+ RelationalExpression<=ShiftExpression
+ RelationalExpression>=ShiftExpression
+ RelationalExpressioninstanceofReferenceType + +EqualityExpression:
+ RelationalExpression
+ EqualityExpression==RelationalExpression
+ EqualityExpression!=RelationalExpression + +AndExpression:
+ EqualityExpression
+ AndExpression&EqualityExpression + +ExclusiveOrExpression:
+ AndExpression
+ ExclusiveOrExpression^AndExpression + +InclusiveOrExpression:
+ ExclusiveOrExpression
+ InclusiveOrExpression|ExclusiveOrExpression + +ConditionalAndExpression:
+ InclusiveOrExpression
+ ConditionalAndExpression&&InclusiveOrExpression + +ConditionalOrExpression:
+ ConditionalAndExpression
+ ConditionalOrExpression||ConditionalAndExpression + +ConditionalExpression:
+ ConditionalOrExpression
+ ConditionalOrExpression?Expression:ConditionalExpression + +AssignmentExpression:
+ ConditionalExpression
+ Assignment + +Assignment:
+ LeftHandSideAssignmentOperatorAssignmentExpression + +LeftHandSide:
+ Name
+ FieldAccess
+ ArrayAccess + +AssignmentOperator: one of
+= *= /= %= += -= <<= >>= >>>= &= ^= |= ++Expression:
+ AssignmentExpression + +ConstantExpression:
+ Expression +
+ + +
| Contents | Prev | Next | Index | +Java Language Specification +First Edition |
+Java Language Specification (HTML generated by Suzette Pelouch on April 03, 1998)
+Copyright © 1996 Sun Microsystems, Inc.
+All rights reserved
+
+Please send any comments or corrections via our feedback form
+
+
\ No newline at end of file
diff --git a/topics/java/jls2/Makefile b/topics/java/jls2/Makefile
new file mode 100644
index 00000000..b2540e77
--- /dev/null
+++ b/topics/java/jls2/Makefile
@@ -0,0 +1,6 @@
+all:
+ python ../../extraction/html2bgf/html2bgf.py syntax.html jls2.bgf
+ ../../../shared/tools/checkxml bgf jls2.bgf
+
+clean:
+ rm -f *.bgf
diff --git a/topics/java/jls2/syntax.html b/topics/java/jls2/syntax.html
new file mode 100644
index 00000000..dc242dc9
--- /dev/null
+++ b/topics/java/jls2/syntax.html
@@ -0,0 +1,399 @@
+
+
| Contents | Prev | Next | Index | +Java Language Specification +Second Edition |
+CHAPTER + 18
+ ++ +This chapter presents a grammar for the Java programming language.
+ +The grammar presented piecemeal in the preceding chapters is much better for exposition, but it is not ideally suited as a basis for a parser. The grammar presented in this chapter is the basis for the reference implementation.
+ +The grammar below uses the following BNF-style conventions:
+
+Identifier:
+ IDENTIFIER
+
+QualifiedIdentifier:
+ Identifier { . Identifier }
+
+Literal:
+ IntegerLiteral
+ FloatingPointLiteral
+ CharacterLiteral
+ StringLiteral
+ BooleanLiteral
+ NullLiteral
+
+Expression:
+ Expression1 [AssignmentOperator Expression1]]
+
+AssignmentOperator:
+ =
+ +=
+ -=
+ *=
+ /=
+ &=
+ |=
+ ^=
+ %=
+ <<=
+ >>=
+ >>>=
+
+Type:
+ Identifier { . Identifier } BracketsOpt
+ BasicType
+
+StatementExpression:
+ Expression
+
+ConstantExpression:
+ Expression
+
+Expression1:
+ Expression2 [Expression1Rest]
+
+Expression1Rest:
+ [ ? Expression : Expression1]
+
+Expression2 :
+ Expression3 [Expression2Rest]
+
+Expression2Rest:
+ {Infixop Expression3}
+ Expression3 instanceof Type
+
+Infixop:
+ ||
+ &&
+ |
+ ^
+ &
+ ==
+ !=
+ <
+ >
+ <=
+ >=
+ <<
+ >>
+ >>>
+ +
+ -
+ *
+ /
+ %
+
+Expression3:
+ PrefixOp Expression3
+ ( Expr | Type ) Expression3
+ Primary {Selector} {PostfixOp}
+
+Primary:
+ ( Expression )
+ this [Arguments]
+ super SuperSuffix
+ Literal
+ new Creator
+ Identifier { . Identifier }[ IdentifierSuffix]
+ BasicType BracketsOpt .class
+ void.class
+
+IdentifierSuffix:
+ [ ( ] BracketsOpt . class | Expression ])
+ Arguments
+ . ( class | this | super Arguments | new InnerCreator )
+
+PrefixOp:
+ ++
+ --
+ !
+ ~
+ +
+ -
+
+PostfixOp:
+ ++
+ --
+
+Selector:
+ . Identifier [Arguments]
+ . this
+ . super SuperSuffix
+ . new InnerCreator
+ [ Expression ]
+
+SuperSuffix:
+ Arguments
+ . Identifier [Arguments]
+
+BasicType:
+ byte
+ short
+ char
+ int
+ long
+ float
+ double
+ boolean
+
+ArgumentsOpt:
+ [ Arguments ]
+
+Arguments:
+ ( [Expression { , Expression }] )
+
+BracketsOpt:
+ {[]}
+
+Creator:
+ QualifiedIdentifier ( ArrayCreatorRest | ClassCreatorRest )
+
+InnerCreator:
+ Identifier ClassCreatorRest
+
+ArrayCreatorRest:
+ [ ( ] BracketsOpt ArrayInitializer | Expression ] {[ Expression ]}
+BracketsOpt )
+
+ClassCreatorRest:
+ Arguments [ClassBody]
+
+ArrayInitializer:
+ { [VariableInitializer {, VariableInitializer} [,]] }
+
+VariableInitializer:
+ ArrayInitializer
+ Expression
+
+ParExpression:
+ ( Expression )
+
+Block:
+ { BlockStatements }
+
+BlockStatements:
+ { BlockStatement }
+
+BlockStatement :
+ LocalVariableDeclarationStatement
+ ClassOrInterfaceDeclaration
+ [Identifier :] Statement
+
+LocalVariableDeclarationStatement:
+ [final] Type VariableDeclarators ;
+
+Statement:
+ Block
+ if ParExpression Statement [else Statement]
+ for ( ForInitOpt ; [Expression] ; ForUpdateOpt ) Statement
+ while ParExpression Statement
+ do Statement while ParExpression ;
+ try Block ( Catches | [Catches] finally Block )
+ switch ParExpression { SwitchBlockStatementGroups }
+ synchronized ParExpression Block
+ return [Expression] ;
+ throw Expression ;
+ break [Identifier]
+ continue [Identifier]
+ ;
+ ExpressionStatement
+ Identifier : Statement
+
+Catches:
+ CatchClause {CatchClause}
+
+CatchClause:
+ catch ( FormalParameter ) Block
+
+SwitchBlockStatementGroups:
+ { SwitchBlockStatementGroup }
+
+SwitchBlockStatementGroup:
+ SwitchLabel BlockStatements
+
+SwitchLabel:
+ case ConstantExpression :
+ default:
+
+MoreStatementExpressions:
+ { , StatementExpression }
+
+ForInit:
+ StatementExpression MoreStatementExpressions
+ [final] Type VariableDeclarators
+
+ForUpdate:
+ StatementExpression MoreStatementExpressions
+
+ModifiersOpt:
+ { Modifier }
+
+Modifier:
+ public
+ protected
+ private
+ static
+ abstract
+ final
+ native
+ synchronized
+ transient
+ volatile
+ strictfp
+
+VariableDeclarators:
+ VariableDeclarator { , VariableDeclarator }
+
+VariableDeclaratorsRest:
+ VariableDeclaratorRest { , VariableDeclarator }
+
+ConstantDeclaratorsRest:
+ ConstantDeclaratorRest { , ConstantDeclarator }
+
+VariableDeclarator:
+ Identifier VariableDeclaratorRest
+
+ConstantDeclarator:
+ Identifier ConstantDeclaratorRest
+
+VariableDeclaratorRest:
+ BracketsOpt [ = VariableInitializer]
+
+ConstantDeclaratorRest:
+ BracketsOpt = VariableInitializer
+
+VariableDeclaratorId:
+ Identifier BracketsOpt
+
+CompilationUnit:
+ [package QualifiedIdentifier ; ] {ImportDeclaration}
+{TypeDeclaration}
+
+ImportDeclaration:
+ import Identifier { . Identifier } [ . * ] ;
+
+TypeDeclaration:
+ ClassOrInterfaceDeclaration
+ ;
+
+ClassOrInterfaceDeclaration:
+ ModifiersOpt (ClassDeclaration | InterfaceDeclaration)
+
+ClassDeclaration:
+ class Identifier [extends Type] [implements TypeList] ClassBody
+
+InterfaceDeclaration:
+ interface Identifier [extends TypeList] InterfaceBody
+
+TypeList:
+ Type { , Type}
+
+ClassBody:
+ { {ClassBodyDeclaration} }
+
+InterfaceBody:
+ { {InterfaceBodyDeclaration} }
+
+ClassBodyDeclaration:
+ ;
+ [static] Block
+ ModifiersOpt MemberDecl
+
+MemberDecl:
+ MethodOrFieldDecl
+ void Identifier MethodDeclaratorRest
+ Identifier ConstructorDeclaratorRest
+ ClassOrInterfaceDeclaration
+
+MethodOrFieldDecl:
+ Type Identifier MethodOrFieldRest
+
+MethodOrFieldRest:
+ VariableDeclaratorRest
+ MethodDeclaratorRest
+
+InterfaceBodyDeclaration:
+ ;
+ ModifiersOpt InterfaceMemberDecl
+
+InterfaceMemberDecl:
+ InterfaceMethodOrFieldDecl
+ void Identifier VoidInterfaceMethodDeclaratorRest
+ ClassOrInterfaceDeclaration
+
+InterfaceMethodOrFieldDecl:
+ Type Identifier InterfaceMethodOrFieldRest
+
+InterfaceMethodOrFieldRest:
+ ConstantDeclaratorsRest ;
+ InterfaceMethodDeclaratorRest
+
+MethodDeclaratorRest:
+ FormalParameters BracketsOpt [throws QualifiedIdentifierList] (
+MethodBody | ; )
+
+VoidMethodDeclaratorRest:
+ FormalParameters [throws QualifiedIdentifierList] ( MethodBody | ; )
+
+InterfaceMethodDeclaratorRest:
+ FormalParameters BracketsOpt [throws QualifiedIdentifierList] ;
+
+VoidInterfaceMethodDeclaratorRest:
+ FormalParameters [throws QualifiedIdentifierList] ;
+
+ConstructorDeclaratorRest:
+ FormalParameters [throws QualifiedIdentifierList] MethodBody
+
+QualifiedIdentifierList:
+ QualifiedIdentifier { , QualifiedIdentifier}
+
+FormalParameters:
+ ( [FormalParameter { , FormalParameter}] )
+
+FormalParameter:
+ [final] Type VariableDeclaratorId
+
+MethodBody:
+ Block
+
+
+| Contents | Prev | Next | Index | +Java Language Specification +Second Edition |
| Contents | Prev | Next | Index | +Java Language Specification +Third Edition |
+CHAPTER + 18
+ ++ +This chapter presents a grammar for the Java programming language.
+ +The grammar presented piecemeal in the preceding chapters is much better for exposition, but it is not well suited as a basis for a parser. The grammar presented in this chapter is the basis for the reference implementation. Note that it is not an LL(1) grammar, though in many cases it minimizes the necessary look ahead.
+ +The grammar below uses the following BNF-style conventions:
+
+x | y means one of either x or y.
+Identifier:
+ IDENTIFIER
+
+QualifiedIdentifier:
+ Identifier { . Identifier }
+
+Literal:
+ IntegerLiteral
+ FloatingPointLiteral
+ CharacterLiteral
+ StringLiteral
+ BooleanLiteral
+ NullLiteral
+
+Expression:
+ Expression1 [AssignmentOperator Expression1]]
+
+AssignmentOperator:
+ =
+ +=
+ -=
+ *=
+ /=
+ &=
+ |=
+ ^=
+ %=
+ <<=
+ >>=
+ >>>=
+
+Type:
+ Identifier [TypeArguments]{ . Identifier [TypeArguments]} {[]}
+ BasicType
+
+TypeArguments:
+ < TypeArgument {, TypeArgument} >
+
+TypeArgument:
+ Type
+ ? [( extends |super ) Type]
+
+StatementExpression:
+ Expression
+
+ConstantExpression:
+ Expression
+
+Expression1:
+ Expression2 [Expression1Rest]
+
+Expression1Rest:
+ ? Expression : Expression1
+
+Expression2 :
+ Expression3 [Expression2Rest]
+
+Expression2Rest:
+ {InfixOp Expression3}
+ Expression3 instanceof Type
+
+InfixOp:
+ ||
+ &&
+ |
+ ^
+ &
+ ==
+ !=
+ <
+ >
+ <=
+ >=
+ <<
+ >>
+ >>>
+ +
+ -
+ *
+ /
+ %
+
+Expression3:
+ PrefixOp Expression3
+ ( Expression | Type ) Expression3
+ Primary {Selector} {PostfixOp}
+
+Primary:
+ ParExpression
+ NonWildcardTypeArguments (ExplicitGenericInvocationSuffix | this
+Arguments)
+ this [Arguments]
+ super SuperSuffix
+ Literal
+ new Creator
+ Identifier { . Identifier }[ IdentifierSuffix]
+ BasicType {[]} .class
+ void.class
+
+IdentifierSuffix:
+ [ ( ] {[]} . class | Expression ])
+ Arguments
+ . ( class | ExplicitGenericInvocation | this | super Arguments | new
+[NonWildcardTypeArguments] InnerCreator )
+
+ExplicitGenericInvocation:
+ NonWildcardTypeArguments ExplicitGenericInvocationSuffix
+
+NonWildcardTypeArguments:
+ < TypeList >
+
+
+ExplicitGenericInvocationSuffix:
+ super SuperSuffix
+ Identifier Arguments
+
+
+PrefixOp:
+ ++
+ --
+ !
+ ~
+ +
+ -
+
+PostfixOp:
+ ++
+ --
+
+Selector: Selector:
+ . Identifier [Arguments]
+ . ExplicitGenericInvocation
+ . this
+ . super SuperSuffix
+ . new [NonWildcardTypeArguments] InnerCreator
+ [ Expression ]
+
+SuperSuffix:
+ Arguments
+ . Identifier [Arguments]
+
+BasicType:
+ byte
+ short
+ char
+ int
+ long
+ float
+ double
+ boolean
+
+Arguments:
+ ( [Expression { , Expression }] )
+
+Creator:
+ [NonWildcardTypeArguments] CreatedName ( ArrayCreatorRest |
+ClassCreatorRest )
+
+CreatedName:
+ Identifier [NonWildcardTypeArguments] {. Identifier
+[NonWildcardTypeArguments]}
+
+InnerCreator:
+ Identifier ClassCreatorRest
+
+ArrayCreatorRest:
+ [ ( ] {[]} ArrayInitializer | Expression ] {[ Expression ]} {[]} )
+
+ClassCreatorRest:
+ Arguments [ClassBody]
+
+ArrayInitializer:
+ { [VariableInitializer {, VariableInitializer} [,]] }
+
+VariableInitializer:
+ ArrayInitializer
+ Expression
+
+ParExpression:
+ ( Expression )
+
+Block:
+ { BlockStatements }
+
+BlockStatements:
+ { BlockStatement }
+
+BlockStatement :
+ LocalVariableDeclarationStatement
+ ClassOrInterfaceDeclaration
+ [Identifier :] Statement
+
+LocalVariableDeclarationStatement:
+ [final] Type VariableDeclarators ;
+
+Statement:
+ Block
+ assert Expression [ : Expression] ;
+ if ParExpression Statement [else Statement]
+ for ( ForControl ) Statement
+ while ParExpression Statement
+ do Statement while ParExpression ;
+ try Block ( Catches | [Catches] finally Block )
+ switch ParExpression { SwitchBlockStatementGroups }
+ synchronized ParExpression Block
+ return [Expression] ;
+ throw Expression ;
+ break [Identifier]
+ continue [Identifier]
+ ;
+ StatementExpression ;
+ Identifier : Statement
+
+Catches:
+ CatchClause {CatchClause}
+
+CatchClause:
+ catch ( FormalParameter ) Block
+
+SwitchBlockStatementGroups:
+ { SwitchBlockStatementGroup }
+
+SwitchBlockStatementGroup:
+ SwitchLabel BlockStatements
+
+SwitchLabel:
+ case ConstantExpression :
+ case EnumConstantName :
+ default :
+
+MoreStatementExpressions:
+ { , StatementExpression }
+
+ForControl:
+ ForVarControl
+ ForInit; [Expression] ; [ForUpdate]
+
+ForVarControl
+ [final] [Annotations] Type Identifier ForVarControlRest
+
+Annotations:
+ Annotation [Annotations]
+
+Annotation:
+ @ TypeName [( [Identifier =] ElementValue)]
+
+ElementValue:
+ ConditionalExpression
+ Annotation
+ ElementValueArrayInitializer
+
+ConditionalExpression:
+ Expression2 Expression1Rest
+
+ ElementValueArrayInitializer:
+ { [ElementValues] [,] }
+
+ ElementValues:
+ ElementValue [ElementValues]
+
+ForVarControlRest:
+ VariableDeclaratorsRest; [Expression] ; [ForUpdate]
+ : Expression
+
+ForInit:
+ StatementExpression Expressions
+
+Modifier:
+ Annotation
+ public
+ protected
+ private
+ static
+ abstract
+ final
+ native
+ synchronized
+ transient
+ volatile
+ strictfp
+
+VariableDeclarators:
+ VariableDeclarator { , VariableDeclarator }
+
+VariableDeclaratorsRest:
+ VariableDeclaratorRest { , VariableDeclarator }
+
+ConstantDeclaratorsRest:
+ ConstantDeclaratorRest { , ConstantDeclarator }
+
+VariableDeclarator:
+ Identifier VariableDeclaratorRest
+
+ConstantDeclarator:
+ Identifier ConstantDeclaratorRest
+
+VariableDeclaratorRest:
+ {[]} [ = VariableInitializer]
+
+ConstantDeclaratorRest:
+ {[]} = VariableInitializer
+
+VariableDeclaratorId:
+ Identifier {[]}
+
+CompilationUnit:
+ [[Annotations] package QualifiedIdentifier ; ] {ImportDeclaration}
+{TypeDeclaration}
+
+ImportDeclaration:
+ import [ static] Identifier { . Identifier } [ . * ] ;
+
+TypeDeclaration:
+ ClassOrInterfaceDeclaration
+ ;
+
+ClassOrInterfaceDeclaration:
+ {Modifier} (ClassDeclaration | InterfaceDeclaration)
+
+ClassDeclaration:
+ NormalClassDeclaration
+ EnumDeclaration
+
+NormalClassDeclaration:
+ class Identifier [TypeParameters] [extends Type] [implements TypeList]
+ClassBody
+
+TypeParameters:
+ < TypeParameter {, TypeParameter} >
+
+TypeParameter:
+ Identifier [extends Bound]
+
+Bound:
+ Type {& Type}
+
+
+EnumDeclaration:
+ enum Identifier [implements TypeList] EnumBody
+
+EnumBody:
+ { [EnumConstants] [,] [EnumBodyDeclarations] }
+
+EnumConstants:
+ EnumConstant
+ EnumConstants , EnumConstant
+
+EnumConstant:
+ Annotations Identifier [Arguments] [ClassBody]
+
+EnumBodyDeclarations:
+ ; {ClassBodyDeclaration}
+
+InterfaceDeclaration:
+ NormalInterfaceDeclaration
+ AnnotationTypeDeclaration
+
+NormalInterfaceDeclaration:
+ interface Identifier [ TypeParameters] [extends TypeList] InterfaceBody
+
+TypeList:
+ Type { , Type}
+
+AnnotationTypeDeclaration:
+ @ interface Identifier AnnotationTypeBody
+
+ AnnotationTypeBody:
+ { [AnnotationTypeElementDeclarations] }
+
+ AnnotationTypeElementDeclarations:
+ AnnotationTypeElementDeclaration
+ AnnotationTypeElementDeclarations AnnotationTypeElementDeclaration
+
+AnnotationTypeElementDeclaration:
+ {Modifier} AnnotationTypeElementRest
+
+AnnotationTypeElementRest:
+ Type Identifier AnnotationMethodOrConstantRest;
+ ClassDeclaration
+ InterfaceDeclaration
+ EnumDeclaration
+ AnnotationTypeDeclaration
+
+ AnnotationMethodOrConstantRest:
+ AnnotationMethodRest
+ AnnotationConstantRest
+
+AnnotationMethodRest:
+ ( ) [DefaultValue]
+
+AnnotationConstantRest:
+ VariableDeclarators
+
+
+ DefaultValue:
+ default ElementValue
+
+ClassBody:
+ { {ClassBodyDeclaration} }
+
+InterfaceBody:
+ { {InterfaceBodyDeclaration} }
+
+ClassBodyDeclaration:
+ ;
+ [static] Block
+ {Modifier} MemberDecl
+
+MemberDecl:
+ GenericMethodOrConstructorDecl
+ MethodOrFieldDecl
+ void Identifier VoidMethodDeclaratorRest
+ Identifier ConstructorDeclaratorRest
+ InterfaceDeclaration
+ ClassDeclaration
+
+GenericMethodOrConstructorDecl:
+ TypeParameters GenericMethodOrConstructorRest
+
+GenericMethodOrConstructorRest:
+ (Type | void) Identifier MethodDeclaratorRest
+ Identifier ConstructorDeclaratorRest
+
+MethodOrFieldDecl:
+ Type Identifier MethodOrFieldRest
+
+MethodOrFieldRest:
+ VariableDeclaratorRest
+ MethodDeclaratorRest
+
+InterfaceBodyDeclaration:
+ ;
+ {Modifier} InterfaceMemberDecl
+
+InterfaceMemberDecl:
+ InterfaceMethodOrFieldDecl
+ InterfaceGenericMethodDecl
+ void Identifier VoidInterfaceMethodDeclaratorRest
+ InterfaceDeclaration
+ ClassDeclaration
+
+InterfaceMethodOrFieldDecl:
+ Type Identifier InterfaceMethodOrFieldRest
+
+InterfaceMethodOrFieldRest:
+ ConstantDeclaratorsRest ;
+ InterfaceMethodDeclaratorRest
+
+MethodDeclaratorRest:
+ FormalParameters {[]} [throws QualifiedIdentifierList] ( MethodBody | ;
+)
+
+VoidMethodDeclaratorRest:
+ FormalParameters [throws QualifiedIdentifierList] ( MethodBody | ; )
+
+InterfaceMethodDeclaratorRest:
+ FormalParameters {[]} [throws QualifiedIdentifierList] ;
+
+InterfaceGenericMethodDecl:
+ TypeParameters (Type | void) Identifier InterfaceMethodDeclaratorRest
+
+VoidInterfaceMethodDeclaratorRest:
+ FormalParameters [throws QualifiedIdentifierList] ;
+
+ConstructorDeclaratorRest:
+ FormalParameters [throws QualifiedIdentifierList] MethodBody
+
+QualifiedIdentifierList:
+ QualifiedIdentifier { , QualifiedIdentifier}
+
+FormalParameters:
+ ( [FormalParameterDecls] )
+
+FormalParameterDecls:
+ [final] [Annotations] Type FormalParameterDeclsRest]
+
+FormalParameterDeclsRest:
+ VariableDeclaratorId [ , FormalParameterDecls]
+ ... VariableDeclaratorId
+
+MethodBody:
+ Block
+
+EnumConstantName:
+ Identifier
++ + +
+
| Contents | Prev | Next | Index | +Java Language Specification +Third Edition |
+
+Copyright © 1996-2005 Sun Microsystems, Inc.
+All rights reserved
+
+Please send any comments or corrections via our feedback form
+
+
\ No newline at end of file