--main options | |
%options ACTION, AN=JavaAction.java, GP=java, | |
%options FILE-PREFIX=java, ESCAPE=$, PREFIX=TokenName, OUTPUT-SIZE=125 , | |
%options NOGOTO-DEFAULT, SINGLE-PRODUCTIONS, LALR=1 , TABLE, | |
--error recovering options..... | |
%options ERROR_MAPS | |
--grammar understanding options | |
%options first follow | |
%options TRACE=FULL , | |
%options VERBOSE | |
%options DEFERRED | |
%options NAMES=MAX | |
%options SCOPES | |
--Usefull macros helping reading/writing semantic actions | |
$Define | |
$putCase | |
/. case $rule_number : if (DEBUG) { System.out.println("$rule_text"); } //$NON-NLS-1$ | |
./ | |
$break | |
/. | |
break; | |
./ | |
$readableName | |
/.1#$rule_number=./ | |
$compliance | |
/.2#$rule_number=./ | |
$recovery | |
/.2#$rule_number= recovery./ | |
-- here it starts really ------------------------------------------ | |
$Terminals | |
Identifier | |
abstract assert boolean break byte case catch char class | |
continue const default do double else enum extends false final finally float | |
for goto if implements import instanceof int | |
interface long native new null package private | |
protected public return short static strictfp super switch | |
synchronized this throw throws transient true try void | |
volatile while | |
IntegerLiteral | |
LongLiteral | |
FloatingPointLiteral | |
DoubleLiteral | |
CharacterLiteral | |
StringLiteral | |
PLUS_PLUS | |
MINUS_MINUS | |
EQUAL_EQUAL | |
LESS_EQUAL | |
GREATER_EQUAL | |
NOT_EQUAL | |
LEFT_SHIFT | |
RIGHT_SHIFT | |
UNSIGNED_RIGHT_SHIFT | |
PLUS_EQUAL | |
MINUS_EQUAL | |
MULTIPLY_EQUAL | |
DIVIDE_EQUAL | |
AND_EQUAL | |
OR_EQUAL | |
XOR_EQUAL | |
REMAINDER_EQUAL | |
LEFT_SHIFT_EQUAL | |
RIGHT_SHIFT_EQUAL | |
UNSIGNED_RIGHT_SHIFT_EQUAL | |
OR_OR | |
AND_AND | |
PLUS | |
MINUS | |
NOT | |
REMAINDER | |
XOR | |
AND | |
MULTIPLY | |
OR | |
TWIDDLE | |
DIVIDE | |
GREATER | |
LESS | |
LPAREN | |
RPAREN | |
LBRACE | |
RBRACE | |
LBRACKET | |
RBRACKET | |
SEMICOLON | |
QUESTION | |
COLON | |
COMMA | |
DOT | |
EQUAL | |
AT | |
ELLIPSIS | |
-- BodyMarker | |
$Alias | |
'++' ::= PLUS_PLUS | |
'--' ::= MINUS_MINUS | |
'==' ::= EQUAL_EQUAL | |
'<=' ::= LESS_EQUAL | |
'>=' ::= GREATER_EQUAL | |
'!=' ::= NOT_EQUAL | |
'<<' ::= LEFT_SHIFT | |
'>>' ::= RIGHT_SHIFT | |
'>>>' ::= UNSIGNED_RIGHT_SHIFT | |
'+=' ::= PLUS_EQUAL | |
'-=' ::= MINUS_EQUAL | |
'*=' ::= MULTIPLY_EQUAL | |
'/=' ::= DIVIDE_EQUAL | |
'&=' ::= AND_EQUAL | |
'|=' ::= OR_EQUAL | |
'^=' ::= XOR_EQUAL | |
'%=' ::= REMAINDER_EQUAL | |
'<<=' ::= LEFT_SHIFT_EQUAL | |
'>>=' ::= RIGHT_SHIFT_EQUAL | |
'>>>=' ::= UNSIGNED_RIGHT_SHIFT_EQUAL | |
'||' ::= OR_OR | |
'&&' ::= AND_AND | |
'+' ::= PLUS | |
'-' ::= MINUS | |
'!' ::= NOT | |
'%' ::= REMAINDER | |
'^' ::= XOR | |
'&' ::= AND | |
'*' ::= MULTIPLY | |
'|' ::= OR | |
'~' ::= TWIDDLE | |
'/' ::= DIVIDE | |
'>' ::= GREATER | |
'<' ::= LESS | |
'(' ::= LPAREN | |
')' ::= RPAREN | |
'{' ::= LBRACE | |
'}' ::= RBRACE | |
'[' ::= LBRACKET | |
']' ::= RBRACKET | |
';' ::= SEMICOLON | |
'?' ::= QUESTION | |
':' ::= COLON | |
',' ::= COMMA | |
'.' ::= DOT | |
'=' ::= EQUAL | |
'@' ::= AT | |
'...' ::= ELLIPSIS | |
$Start | |
Goal | |
$Rules | |
/.// This method is part of an automatic generation : do NOT edit-modify | |
protected void consumeRule(int act) { | |
switch ( act ) { | |
./ | |
Goal ::= '++' CompilationUnit | |
Goal ::= '--' MethodBody | |
-- Initializer | |
Goal ::= '>>' StaticInitializer | |
Goal ::= '>>' Initializer | |
-- error recovery | |
-- Modifiersopt is used to properly consume a header and exit the rule reduction at the end of the parse() method | |
Goal ::= '>>>' Header1 Modifiersopt | |
Goal ::= '!' Header2 Modifiersopt | |
Goal ::= '*' BlockStatements | |
Goal ::= '*' CatchHeader | |
-- JDOM | |
Goal ::= '&&' FieldDeclaration | |
Goal ::= '||' ImportDeclaration | |
Goal ::= '?' PackageDeclaration | |
Goal ::= '+' TypeDeclaration | |
Goal ::= '/' GenericMethodDeclaration | |
Goal ::= '&' ClassBodyDeclarations | |
-- code snippet | |
Goal ::= '%' Expression | |
-- completion parser | |
Goal ::= '~' BlockStatementsopt | |
-- source type converter | |
Goal ::= '||' MemberValue | |
-- syntax diagnosis | |
Goal ::= '?' AnnotationTypeMemberDeclaration | |
/:$readableName Goal:/ | |
Literal -> IntegerLiteral | |
Literal -> LongLiteral | |
Literal -> FloatingPointLiteral | |
Literal -> DoubleLiteral | |
Literal -> CharacterLiteral | |
Literal -> StringLiteral | |
Literal -> null | |
Literal -> BooleanLiteral | |
/:$readableName Literal:/ | |
BooleanLiteral -> true | |
BooleanLiteral -> false | |
/:$readableName BooleanLiteral:/ | |
Type ::= PrimitiveType | |
/.$putCase consumePrimitiveType(); $break ./ | |
Type -> ReferenceType | |
/:$readableName Type:/ | |
PrimitiveType -> NumericType | |
/:$readableName PrimitiveType:/ | |
NumericType -> IntegralType | |
NumericType -> FloatingPointType | |
/:$readableName NumericType:/ | |
PrimitiveType -> 'boolean' | |
PrimitiveType -> 'void' | |
IntegralType -> 'byte' | |
IntegralType -> 'short' | |
IntegralType -> 'int' | |
IntegralType -> 'long' | |
IntegralType -> 'char' | |
/:$readableName IntegralType:/ | |
FloatingPointType -> 'float' | |
FloatingPointType -> 'double' | |
/:$readableName FloatingPointType:/ | |
ReferenceType ::= ClassOrInterfaceType | |
/.$putCase consumeReferenceType(); $break ./ | |
ReferenceType -> ArrayType | |
/:$readableName ReferenceType:/ | |
--------------------------------------------------------------- | |
-- 1.5 feature | |
--------------------------------------------------------------- | |
ClassOrInterfaceType -> ClassOrInterface | |
ClassOrInterfaceType -> GenericType | |
/:$readableName Type:/ | |
ClassOrInterface ::= Name | |
/.$putCase consumeClassOrInterfaceName(); $break ./ | |
ClassOrInterface ::= GenericType '.' Name | |
/.$putCase consumeClassOrInterface(); $break ./ | |
/:$readableName Type:/ | |
GenericType ::= ClassOrInterface TypeArguments | |
/.$putCase consumeGenericType(); $break ./ | |
/:$readableName GenericType:/ | |
-- | |
-- These rules have been rewritten to avoid some conflicts introduced | |
-- by adding the 1.1 features | |
-- | |
-- ArrayType ::= PrimitiveType '[' ']' | |
-- ArrayType ::= Name '[' ']' | |
-- ArrayType ::= ArrayType '[' ']' | |
-- | |
ArrayTypeWithTypeArgumentsName ::= GenericType '.' Name | |
/.$putCase consumeArrayTypeWithTypeArgumentsName(); $break ./ | |
/:$readableName ArrayTypeWithTypeArgumentsName:/ | |
ArrayType ::= PrimitiveType Dims | |
/.$putCase consumePrimitiveArrayType(); $break ./ | |
ArrayType ::= Name Dims | |
/.$putCase consumeNameArrayType(); $break ./ | |
ArrayType ::= ArrayTypeWithTypeArgumentsName Dims | |
/.$putCase consumeGenericTypeNameArrayType(); $break ./ | |
ArrayType ::= GenericType Dims | |
/.$putCase consumeGenericTypeArrayType(); $break ./ | |
/:$readableName ArrayType:/ | |
ClassType -> ClassOrInterfaceType | |
/:$readableName ClassType:/ | |
-------------------------------------------------------------- | |
-------------------------------------------------------------- | |
Name -> SimpleName | |
Name -> QualifiedName | |
/:$readableName Name:/ | |
SimpleName -> 'Identifier' | |
/:$readableName SimpleName:/ | |
QualifiedName ::= Name '.' SimpleName | |
/.$putCase consumeQualifiedName(); $break ./ | |
/:$readableName QualifiedName:/ | |
CompilationUnit ::= EnterCompilationUnit InternalCompilationUnit | |
/.$putCase consumeCompilationUnit(); $break ./ | |
/:$readableName CompilationUnit:/ | |
InternalCompilationUnit ::= PackageDeclaration | |
/.$putCase consumeInternalCompilationUnit(); $break ./ | |
InternalCompilationUnit ::= PackageDeclaration ImportDeclarations ReduceImports | |
/.$putCase consumeInternalCompilationUnit(); $break ./ | |
InternalCompilationUnit ::= PackageDeclaration ImportDeclarations ReduceImports TypeDeclarations | |
/.$putCase consumeInternalCompilationUnitWithTypes(); $break ./ | |
InternalCompilationUnit ::= PackageDeclaration TypeDeclarations | |
/.$putCase consumeInternalCompilationUnitWithTypes(); $break ./ | |
InternalCompilationUnit ::= ImportDeclarations ReduceImports | |
/.$putCase consumeInternalCompilationUnit(); $break ./ | |
InternalCompilationUnit ::= TypeDeclarations | |
/.$putCase consumeInternalCompilationUnitWithTypes(); $break ./ | |
InternalCompilationUnit ::= ImportDeclarations ReduceImports TypeDeclarations | |
/.$putCase consumeInternalCompilationUnitWithTypes(); $break ./ | |
InternalCompilationUnit ::= $empty | |
/.$putCase consumeEmptyInternalCompilationUnit(); $break ./ | |
/:$readableName CompilationUnit:/ | |
ReduceImports ::= $empty | |
/.$putCase consumeReduceImports(); $break ./ | |
/:$readableName ReduceImports:/ | |
EnterCompilationUnit ::= $empty | |
/.$putCase consumeEnterCompilationUnit(); $break ./ | |
/:$readableName EnterCompilationUnit:/ | |
Header -> ImportDeclaration | |
Header -> PackageDeclaration | |
Header -> ClassHeader | |
Header -> InterfaceHeader | |
Header -> EnumHeader | |
Header -> AnnotationTypeDeclarationHeader | |
Header -> StaticInitializer | |
Header -> RecoveryMethodHeader | |
Header -> FieldDeclaration | |
Header -> AllocationHeader | |
Header -> ArrayCreationHeader | |
/:$readableName Header:/ | |
Header1 -> Header | |
Header1 -> ConstructorHeader | |
/:$readableName Header1:/ | |
Header2 -> Header | |
Header2 -> EnumConstantHeader | |
/:$readableName Header2:/ | |
CatchHeader ::= 'catch' '(' FormalParameter ')' '{' | |
/.$putCase consumeCatchHeader(); $break ./ | |
/:$readableName CatchHeader:/ | |
ImportDeclarations -> ImportDeclaration | |
ImportDeclarations ::= ImportDeclarations ImportDeclaration | |
/.$putCase consumeImportDeclarations(); $break ./ | |
/:$readableName ImportDeclarations:/ | |
TypeDeclarations -> TypeDeclaration | |
TypeDeclarations ::= TypeDeclarations TypeDeclaration | |
/.$putCase consumeTypeDeclarations(); $break ./ | |
/:$readableName TypeDeclarations:/ | |
PackageDeclaration ::= PackageDeclarationName ';' | |
/.$putCase consumePackageDeclaration(); $break ./ | |
/:$readableName PackageDeclaration:/ | |
PackageDeclarationName ::= Modifiers 'package' PushRealModifiers Name | |
/.$putCase consumePackageDeclarationNameWithModifiers(); $break ./ | |
/:$readableName PackageDeclarationName:/ | |
/:$compliance 1.5:/ | |
PackageDeclarationName ::= PackageComment 'package' Name | |
/.$putCase consumePackageDeclarationName(); $break ./ | |
/:$readableName PackageDeclarationName:/ | |
PackageComment ::= $empty | |
/.$putCase consumePackageComment(); $break ./ | |
/:$readableName PackageComment:/ | |
ImportDeclaration -> SingleTypeImportDeclaration | |
ImportDeclaration -> TypeImportOnDemandDeclaration | |
----------------------------------------------- | |
-- 1.5 feature | |
----------------------------------------------- | |
ImportDeclaration -> SingleStaticImportDeclaration | |
ImportDeclaration -> StaticImportOnDemandDeclaration | |
/:$readableName ImportDeclaration:/ | |
SingleTypeImportDeclaration ::= SingleTypeImportDeclarationName ';' | |
/.$putCase consumeImportDeclaration(); $break ./ | |
/:$readableName SingleTypeImportDeclaration:/ | |
SingleTypeImportDeclarationName ::= 'import' Name | |
/.$putCase consumeSingleTypeImportDeclarationName(); $break ./ | |
/:$readableName SingleTypeImportDeclarationName:/ | |
TypeImportOnDemandDeclaration ::= TypeImportOnDemandDeclarationName ';' | |
/.$putCase consumeImportDeclaration(); $break ./ | |
/:$readableName TypeImportOnDemandDeclaration:/ | |
TypeImportOnDemandDeclarationName ::= 'import' Name '.' '*' | |
/.$putCase consumeTypeImportOnDemandDeclarationName(); $break ./ | |
/:$readableName TypeImportOnDemandDeclarationName:/ | |
TypeDeclaration -> ClassDeclaration | |
TypeDeclaration -> InterfaceDeclaration | |
-- this declaration in part of a list od declaration and we will | |
-- use and optimized list length calculation process | |
-- thus we decrement the number while it will be incremend..... | |
TypeDeclaration ::= ';' | |
/. $putCase consumeEmptyTypeDeclaration(); $break ./ | |
----------------------------------------------- | |
-- 1.5 feature | |
----------------------------------------------- | |
TypeDeclaration -> EnumDeclaration | |
TypeDeclaration -> AnnotationTypeDeclaration | |
/:$readableName TypeDeclaration:/ | |
--18.7 Only in the LALR(1) Grammar | |
Modifiers -> Modifier | |
Modifiers ::= Modifiers Modifier | |
/.$putCase consumeModifiers2(); $break ./ | |
/:$readableName Modifiers:/ | |
Modifier -> 'public' | |
Modifier -> 'protected' | |
Modifier -> 'private' | |
Modifier -> 'static' | |
Modifier -> 'abstract' | |
Modifier -> 'final' | |
Modifier -> 'native' | |
Modifier -> 'synchronized' | |
Modifier -> 'transient' | |
Modifier -> 'volatile' | |
Modifier -> 'strictfp' | |
Modifier ::= Annotation | |
/.$putCase consumeAnnotationAsModifier(); $break ./ | |
/:$readableName Modifier:/ | |
--18.8 Productions from 8: Class Declarations | |
--ClassModifier ::= | |
-- 'abstract' | |
-- | 'final' | |
-- | 'public' | |
--18.8.1 Productions from 8.1: Class Declarations | |
ClassDeclaration ::= ClassHeader ClassBody | |
/.$putCase consumeClassDeclaration(); $break ./ | |
/:$readableName ClassDeclaration:/ | |
ClassHeader ::= ClassHeaderName ClassHeaderExtendsopt ClassHeaderImplementsopt | |
/.$putCase consumeClassHeader(); $break ./ | |
/:$readableName ClassHeader:/ | |
----------------------------------------------- | |
-- 1.5 features : generics | |
----------------------------------------------- | |
ClassHeaderName ::= ClassHeaderName1 TypeParameters | |
/.$putCase consumeTypeHeaderNameWithTypeParameters(); $break ./ | |
ClassHeaderName -> ClassHeaderName1 | |
/:$readableName ClassHeaderName:/ | |
ClassHeaderName1 ::= Modifiersopt 'class' 'Identifier' | |
/.$putCase consumeClassHeaderName1(); $break ./ | |
/:$readableName ClassHeaderName:/ | |
ClassHeaderExtends ::= 'extends' ClassType | |
/.$putCase consumeClassHeaderExtends(); $break ./ | |
/:$readableName ClassHeaderExtends:/ | |
ClassHeaderImplements ::= 'implements' InterfaceTypeList | |
/.$putCase consumeClassHeaderImplements(); $break ./ | |
/:$readableName ClassHeaderImplements:/ | |
InterfaceTypeList -> InterfaceType | |
InterfaceTypeList ::= InterfaceTypeList ',' InterfaceType | |
/.$putCase consumeInterfaceTypeList(); $break ./ | |
/:$readableName InterfaceTypeList:/ | |
InterfaceType ::= ClassOrInterfaceType | |
/.$putCase consumeInterfaceType(); $break ./ | |
/:$readableName InterfaceType:/ | |
ClassBody ::= '{' ClassBodyDeclarationsopt '}' | |
/:$readableName ClassBody:/ | |
ClassBodyDeclarations ::= ClassBodyDeclaration | |
ClassBodyDeclarations ::= ClassBodyDeclarations ClassBodyDeclaration | |
/.$putCase consumeClassBodyDeclarations(); $break ./ | |
/:$readableName ClassBodyDeclarations:/ | |
ClassBodyDeclaration -> ClassMemberDeclaration | |
ClassBodyDeclaration -> StaticInitializer | |
ClassBodyDeclaration -> ConstructorDeclaration | |
--1.1 feature | |
ClassBodyDeclaration ::= Diet NestedMethod Block | |
/.$putCase consumeClassBodyDeclaration(); $break ./ | |
/:$readableName ClassBodyDeclaration:/ | |
Diet ::= $empty | |
/.$putCase consumeDiet(); $break./ | |
/:$readableName Diet:/ | |
Initializer ::= Diet NestedMethod Block | |
/.$putCase consumeClassBodyDeclaration(); $break ./ | |
/:$readableName Initializer:/ | |
ClassMemberDeclaration -> FieldDeclaration | |
ClassMemberDeclaration -> MethodDeclaration | |
--1.1 feature | |
ClassMemberDeclaration -> ClassDeclaration | |
--1.1 feature | |
ClassMemberDeclaration -> InterfaceDeclaration | |
-- 1.5 feature | |
ClassMemberDeclaration -> EnumDeclaration | |
ClassMemberDeclaration -> AnnotationTypeDeclaration | |
/:$readableName ClassMemberDeclaration:/ | |
-- Empty declarations are not valid Java ClassMemberDeclarations. | |
-- However, since the current (2/14/97) Java compiler accepts them | |
-- (in fact, some of the official tests contain this erroneous | |
-- syntax) | |
ClassMemberDeclaration ::= ';' | |
/.$putCase consumeEmptyClassMemberDeclaration(); $break./ | |
GenericMethodDeclaration -> MethodDeclaration | |
GenericMethodDeclaration -> ConstructorDeclaration | |
/:$readableName GenericMethodDeclaration:/ | |
--18.8.2 Productions from 8.3: Field Declarations | |
--VariableModifier ::= | |
-- 'public' | |
-- | 'protected' | |
-- | 'private' | |
-- | 'static' | |
-- | 'final' | |
-- | 'transient' | |
-- | 'volatile' | |
FieldDeclaration ::= Modifiersopt Type VariableDeclarators ';' | |
/.$putCase consumeFieldDeclaration(); $break ./ | |
/:$readableName FieldDeclaration:/ | |
VariableDeclarators -> VariableDeclarator | |
VariableDeclarators ::= VariableDeclarators ',' VariableDeclarator | |
/.$putCase consumeVariableDeclarators(); $break ./ | |
/:$readableName VariableDeclarators:/ | |
VariableDeclarator ::= VariableDeclaratorId EnterVariable ExitVariableWithoutInitialization | |
VariableDeclarator ::= VariableDeclaratorId EnterVariable '=' ForceNoDiet VariableInitializer RestoreDiet ExitVariableWithInitialization | |
/:$readableName VariableDeclarator:/ | |
EnterVariable ::= $empty | |
/.$putCase consumeEnterVariable(); $break ./ | |
/:$readableName EnterVariable:/ | |
ExitVariableWithInitialization ::= $empty | |
/.$putCase consumeExitVariableWithInitialization(); $break ./ | |
/:$readableName ExitVariableWithInitialization:/ | |
ExitVariableWithoutInitialization ::= $empty | |
/.$putCase consumeExitVariableWithoutInitialization(); $break ./ | |
/:$readableName ExitVariableWithoutInitialization:/ | |
ForceNoDiet ::= $empty | |
/.$putCase consumeForceNoDiet(); $break ./ | |
/:$readableName ForceNoDiet:/ | |
RestoreDiet ::= $empty | |
/.$putCase consumeRestoreDiet(); $break ./ | |
/:$readableName RestoreDiet:/ | |
VariableDeclaratorId ::= 'Identifier' Dimsopt | |
/:$readableName VariableDeclaratorId:/ | |
VariableInitializer -> Expression | |
VariableInitializer -> ArrayInitializer | |
/:$readableName VariableInitializer:/ | |
--18.8.3 Productions from 8.4: Method Declarations | |
--MethodModifier ::= | |
-- 'public' | |
-- | 'protected' | |
-- | 'private' | |
-- | 'static' | |
-- | 'abstract' | |
-- | 'final' | |
-- | 'native' | |
-- | 'synchronized' | |
-- | |
MethodDeclaration -> AbstractMethodDeclaration | |
MethodDeclaration ::= MethodHeader MethodBody | |
/.$putCase // set to true to consume a method with a body | |
consumeMethodDeclaration(true); $break ./ | |
/:$readableName MethodDeclaration:/ | |
AbstractMethodDeclaration ::= MethodHeader ';' | |
/.$putCase // set to false to consume a method without body | |
consumeMethodDeclaration(false); $break ./ | |
/:$readableName MethodDeclaration:/ | |
MethodHeader ::= MethodHeaderName FormalParameterListopt MethodHeaderRightParen MethodHeaderExtendedDims MethodHeaderThrowsClauseopt | |
/.$putCase consumeMethodHeader(); $break ./ | |
/:$readableName MethodDeclaration:/ | |
MethodHeaderName ::= Modifiersopt TypeParameters Type 'Identifier' '(' | |
/.$putCase consumeMethodHeaderNameWithTypeParameters(false); $break ./ | |
MethodHeaderName ::= Modifiersopt Type 'Identifier' '(' | |
/.$putCase consumeMethodHeaderName(false); $break ./ | |
/:$readableName MethodHeaderName:/ | |
MethodHeaderRightParen ::= ')' | |
/.$putCase consumeMethodHeaderRightParen(); $break ./ | |
/:$readableName ):/ | |
MethodHeaderExtendedDims ::= Dimsopt | |
/.$putCase consumeMethodHeaderExtendedDims(); $break ./ | |
/:$readableName MethodHeaderExtendedDims:/ | |
MethodHeaderThrowsClause ::= 'throws' ClassTypeList | |
/.$putCase consumeMethodHeaderThrowsClause(); $break ./ | |
/:$readableName MethodHeaderThrowsClause:/ | |
ConstructorHeader ::= ConstructorHeaderName FormalParameterListopt MethodHeaderRightParen MethodHeaderThrowsClauseopt | |
/.$putCase consumeConstructorHeader(); $break ./ | |
/:$readableName ConstructorDeclaration:/ | |
ConstructorHeaderName ::= Modifiersopt TypeParameters 'Identifier' '(' | |
/.$putCase consumeConstructorHeaderNameWithTypeParameters(); $break ./ | |
ConstructorHeaderName ::= Modifiersopt 'Identifier' '(' | |
/.$putCase consumeConstructorHeaderName(); $break ./ | |
/:$readableName ConstructorHeaderName:/ | |
FormalParameterList -> FormalParameter | |
FormalParameterList ::= FormalParameterList ',' FormalParameter | |
/.$putCase consumeFormalParameterList(); $break ./ | |
/:$readableName FormalParameterList:/ | |
--1.1 feature | |
FormalParameter ::= Modifiersopt Type VariableDeclaratorId | |
/.$putCase consumeFormalParameter(false); $break ./ | |
FormalParameter ::= Modifiersopt Type '...' VariableDeclaratorId | |
/.$putCase consumeFormalParameter(true); $break ./ | |
/:$readableName FormalParameter:/ | |
/:$compliance 1.5:/ | |
ClassTypeList -> ClassTypeElt | |
ClassTypeList ::= ClassTypeList ',' ClassTypeElt | |
/.$putCase consumeClassTypeList(); $break ./ | |
/:$readableName ClassTypeList:/ | |
ClassTypeElt ::= ClassType | |
/.$putCase consumeClassTypeElt(); $break ./ | |
/:$readableName ClassType:/ | |
MethodBody ::= NestedMethod '{' BlockStatementsopt '}' | |
/.$putCase consumeMethodBody(); $break ./ | |
/:$readableName MethodBody:/ | |
NestedMethod ::= $empty | |
/.$putCase consumeNestedMethod(); $break ./ | |
/:$readableName NestedMethod:/ | |
--18.8.4 Productions from 8.5: Static Initializers | |
StaticInitializer ::= StaticOnly Block | |
/.$putCase consumeStaticInitializer(); $break./ | |
/:$readableName StaticInitializer:/ | |
StaticOnly ::= 'static' | |
/.$putCase consumeStaticOnly(); $break ./ | |
/:$readableName StaticOnly:/ | |
--18.8.5 Productions from 8.6: Constructor Declarations | |
--ConstructorModifier ::= | |
-- 'public' | |
-- | 'protected' | |
-- | 'private' | |
-- | |
-- | |
ConstructorDeclaration ::= ConstructorHeader MethodBody | |
/.$putCase consumeConstructorDeclaration() ; $break ./ | |
-- These rules are added to be able to parse constructors with no body | |
ConstructorDeclaration ::= ConstructorHeader ';' | |
/.$putCase consumeInvalidConstructorDeclaration() ; $break ./ | |
/:$readableName ConstructorDeclaration:/ | |
-- the rules ExplicitConstructorInvocationopt has been expanded | |
-- in the rule below in order to make the grammar lalr(1). | |
ExplicitConstructorInvocation ::= 'this' '(' ArgumentListopt ')' ';' | |
/.$putCase consumeExplicitConstructorInvocation(0, THIS_CALL); $break ./ | |
ExplicitConstructorInvocation ::= OnlyTypeArguments 'this' '(' ArgumentListopt ')' ';' | |
/.$putCase consumeExplicitConstructorInvocationWithTypeArguments(0,THIS_CALL); $break ./ | |
ExplicitConstructorInvocation ::= 'super' '(' ArgumentListopt ')' ';' | |
/.$putCase consumeExplicitConstructorInvocation(0,SUPER_CALL); $break ./ | |
ExplicitConstructorInvocation ::= OnlyTypeArguments 'super' '(' ArgumentListopt ')' ';' | |
/.$putCase consumeExplicitConstructorInvocationWithTypeArguments(0,SUPER_CALL); $break ./ | |
--1.1 feature | |
ExplicitConstructorInvocation ::= Primary '.' 'super' '(' ArgumentListopt ')' ';' | |
/.$putCase consumeExplicitConstructorInvocation(1, SUPER_CALL); $break ./ | |
ExplicitConstructorInvocation ::= Primary '.' OnlyTypeArguments 'super' '(' ArgumentListopt ')' ';' | |
/.$putCase consumeExplicitConstructorInvocationWithTypeArguments(1, SUPER_CALL); $break ./ | |
--1.1 feature | |
ExplicitConstructorInvocation ::= Name '.' 'super' '(' ArgumentListopt ')' ';' | |
/.$putCase consumeExplicitConstructorInvocation(2, SUPER_CALL); $break ./ | |
ExplicitConstructorInvocation ::= Name '.' OnlyTypeArguments 'super' '(' ArgumentListopt ')' ';' | |
/.$putCase consumeExplicitConstructorInvocationWithTypeArguments(2, SUPER_CALL); $break ./ | |
--1.1 feature | |
ExplicitConstructorInvocation ::= Primary '.' 'this' '(' ArgumentListopt ')' ';' | |
/.$putCase consumeExplicitConstructorInvocation(1, THIS_CALL); $break ./ | |
ExplicitConstructorInvocation ::= Primary '.' OnlyTypeArguments 'this' '(' ArgumentListopt ')' ';' | |
/.$putCase consumeExplicitConstructorInvocationWithTypeArguments(1, THIS_CALL); $break ./ | |
--1.1 feature | |
ExplicitConstructorInvocation ::= Name '.' 'this' '(' ArgumentListopt ')' ';' | |
/.$putCase consumeExplicitConstructorInvocation(2, THIS_CALL); $break ./ | |
ExplicitConstructorInvocation ::= Name '.' OnlyTypeArguments 'this' '(' ArgumentListopt ')' ';' | |
/.$putCase consumeExplicitConstructorInvocationWithTypeArguments(2, THIS_CALL); $break ./ | |
/:$readableName ExplicitConstructorInvocation:/ | |
--18.9 Productions from 9: Interface Declarations | |
--18.9.1 Productions from 9.1: Interface Declarations | |
--InterfaceModifier ::= | |
-- 'public' | |
-- | 'abstract' | |
-- | |
InterfaceDeclaration ::= InterfaceHeader InterfaceBody | |
/.$putCase consumeInterfaceDeclaration(); $break ./ | |
/:$readableName InterfaceDeclaration:/ | |
InterfaceHeader ::= InterfaceHeaderName InterfaceHeaderExtendsopt | |
/.$putCase consumeInterfaceHeader(); $break ./ | |
/:$readableName InterfaceHeader:/ | |
----------------------------------------------- | |
-- 1.5 features : generics | |
----------------------------------------------- | |
InterfaceHeaderName ::= InterfaceHeaderName1 TypeParameters | |
/.$putCase consumeTypeHeaderNameWithTypeParameters(); $break ./ | |
InterfaceHeaderName -> InterfaceHeaderName1 | |
/:$readableName InterfaceHeaderName:/ | |
InterfaceHeaderName1 ::= Modifiersopt interface Identifier | |
/.$putCase consumeInterfaceHeaderName1(); $break ./ | |
/:$readableName InterfaceHeaderName:/ | |
InterfaceHeaderExtends ::= 'extends' InterfaceTypeList | |
/.$putCase consumeInterfaceHeaderExtends(); $break ./ | |
/:$readableName InterfaceHeaderExtends:/ | |
InterfaceBody ::= '{' InterfaceMemberDeclarationsopt '}' | |
/:$readableName InterfaceBody:/ | |
InterfaceMemberDeclarations -> InterfaceMemberDeclaration | |
InterfaceMemberDeclarations ::= InterfaceMemberDeclarations InterfaceMemberDeclaration | |
/.$putCase consumeInterfaceMemberDeclarations(); $break ./ | |
/:$readableName InterfaceMemberDeclarations:/ | |
--same as for class members | |
InterfaceMemberDeclaration ::= ';' | |
/.$putCase consumeEmptyInterfaceMemberDeclaration(); $break ./ | |
/:$readableName InterfaceMemberDeclaration:/ | |
InterfaceMemberDeclaration -> ConstantDeclaration | |
InterfaceMemberDeclaration ::= MethodHeader MethodBody | |
/.$putCase consumeInvalidMethodDeclaration(); $break ./ | |
/:$readableName InterfaceMemberDeclaration:/ | |
-- These rules are added to be able to parse constructors inside interface and then report a relevent error message | |
InvalidConstructorDeclaration ::= ConstructorHeader MethodBody | |
/.$putCase consumeInvalidConstructorDeclaration(true); $break ./ | |
InvalidConstructorDeclaration ::= ConstructorHeader ';' | |
/.$putCase consumeInvalidConstructorDeclaration(false); $break ./ | |
/:$readableName InvalidConstructorDeclaration:/ | |
InterfaceMemberDeclaration -> AbstractMethodDeclaration | |
InterfaceMemberDeclaration -> InvalidConstructorDeclaration | |
--1.1 feature | |
InterfaceMemberDeclaration -> ClassDeclaration | |
--1.1 feature | |
InterfaceMemberDeclaration -> InterfaceDeclaration | |
InterfaceMemberDeclaration -> EnumDeclaration | |
InterfaceMemberDeclaration -> AnnotationTypeDeclaration | |
/:$readableName InterfaceMemberDeclaration:/ | |
ConstantDeclaration -> FieldDeclaration | |
/:$readableName ConstantDeclaration:/ | |
PushLeftBrace ::= $empty | |
/.$putCase consumePushLeftBrace(); $break ./ | |
/:$readableName PushLeftBrace:/ | |
ArrayInitializer ::= '{' PushLeftBrace ,opt '}' | |
/.$putCase consumeEmptyArrayInitializer(); $break ./ | |
ArrayInitializer ::= '{' PushLeftBrace VariableInitializers '}' | |
/.$putCase consumeArrayInitializer(); $break ./ | |
ArrayInitializer ::= '{' PushLeftBrace VariableInitializers , '}' | |
/.$putCase consumeArrayInitializer(); $break ./ | |
/:$readableName ArrayInitializer:/ | |
VariableInitializers ::= VariableInitializer | |
VariableInitializers ::= VariableInitializers ',' VariableInitializer | |
/.$putCase consumeVariableInitializers(); $break ./ | |
/:$readableName VariableInitializers:/ | |
Block ::= OpenBlock '{' BlockStatementsopt '}' | |
/.$putCase consumeBlock(); $break ./ | |
/:$readableName Block:/ | |
OpenBlock ::= $empty | |
/.$putCase consumeOpenBlock() ; $break ./ | |
/:$readableName OpenBlock:/ | |
BlockStatements -> BlockStatement | |
BlockStatements ::= BlockStatements BlockStatement | |
/.$putCase consumeBlockStatements() ; $break ./ | |
/:$readableName BlockStatements:/ | |
BlockStatement -> LocalVariableDeclarationStatement | |
BlockStatement -> Statement | |
--1.1 feature | |
BlockStatement -> ClassDeclaration | |
BlockStatement ::= InterfaceDeclaration | |
/.$putCase consumeInvalidInterfaceDeclaration(); $break ./ | |
/:$readableName BlockStatement:/ | |
BlockStatement ::= AnnotationTypeDeclaration | |
/.$putCase consumeInvalidAnnotationTypeDeclaration(); $break ./ | |
/:$readableName BlockStatement:/ | |
BlockStatement ::= EnumDeclaration | |
/.$putCase consumeInvalidEnumDeclaration(); $break ./ | |
/:$readableName BlockStatement:/ | |
LocalVariableDeclarationStatement ::= LocalVariableDeclaration ';' | |
/.$putCase consumeLocalVariableDeclarationStatement(); $break ./ | |
/:$readableName LocalVariableDeclarationStatement:/ | |
LocalVariableDeclaration ::= Type PushModifiers VariableDeclarators | |
/.$putCase consumeLocalVariableDeclaration(); $break ./ | |
-- 1.1 feature | |
-- The modifiers part of this rule makes the grammar more permissive. | |
-- The only modifier here is final. We put Modifiers to allow multiple modifiers | |
-- This will require to check the validity of the modifier | |
LocalVariableDeclaration ::= Modifiers Type PushRealModifiers VariableDeclarators | |
/.$putCase consumeLocalVariableDeclaration(); $break ./ | |
/:$readableName LocalVariableDeclaration:/ | |
PushModifiers ::= $empty | |
/.$putCase consumePushModifiers(); $break ./ | |
/:$readableName PushModifiers:/ | |
PushModifiersForHeader ::= $empty | |
/.$putCase consumePushModifiersForHeader(); $break ./ | |
/:$readableName PushModifiersForHeader:/ | |
PushRealModifiers ::= $empty | |
/.$putCase consumePushRealModifiers(); $break ./ | |
/:$readableName PushRealModifiers:/ | |
Statement -> StatementWithoutTrailingSubstatement | |
Statement -> LabeledStatement | |
Statement -> IfThenStatement | |
Statement -> IfThenElseStatement | |
Statement -> WhileStatement | |
Statement -> ForStatement | |
----------------------------------------------- | |
-- 1.5 feature | |
----------------------------------------------- | |
Statement -> EnhancedForStatement | |
/:$readableName Statement:/ | |
StatementNoShortIf -> StatementWithoutTrailingSubstatement | |
StatementNoShortIf -> LabeledStatementNoShortIf | |
StatementNoShortIf -> IfThenElseStatementNoShortIf | |
StatementNoShortIf -> WhileStatementNoShortIf | |
StatementNoShortIf -> ForStatementNoShortIf | |
----------------------------------------------- | |
-- 1.5 feature | |
----------------------------------------------- | |
StatementNoShortIf -> EnhancedForStatementNoShortIf | |
/:$readableName Statement:/ | |
StatementWithoutTrailingSubstatement -> AssertStatement | |
StatementWithoutTrailingSubstatement -> Block | |
StatementWithoutTrailingSubstatement -> EmptyStatement | |
StatementWithoutTrailingSubstatement -> ExpressionStatement | |
StatementWithoutTrailingSubstatement -> SwitchStatement | |
StatementWithoutTrailingSubstatement -> DoStatement | |
StatementWithoutTrailingSubstatement -> BreakStatement | |
StatementWithoutTrailingSubstatement -> ContinueStatement | |
StatementWithoutTrailingSubstatement -> ReturnStatement | |
StatementWithoutTrailingSubstatement -> SynchronizedStatement | |
StatementWithoutTrailingSubstatement -> ThrowStatement | |
StatementWithoutTrailingSubstatement -> TryStatement | |
/:$readableName Statement:/ | |
EmptyStatement ::= ';' | |
/.$putCase consumeEmptyStatement(); $break ./ | |
/:$readableName EmptyStatement:/ | |
LabeledStatement ::= 'Identifier' ':' Statement | |
/.$putCase consumeStatementLabel() ; $break ./ | |
/:$readableName LabeledStatement:/ | |
LabeledStatementNoShortIf ::= 'Identifier' ':' StatementNoShortIf | |
/.$putCase consumeStatementLabel() ; $break ./ | |
/:$readableName LabeledStatement:/ | |
ExpressionStatement ::= StatementExpression ';' | |
/. $putCase consumeExpressionStatement(); $break ./ | |
ExpressionStatement ::= ExplicitConstructorInvocation | |
/:$readableName Statement:/ | |
StatementExpression ::= Assignment | |
StatementExpression ::= PreIncrementExpression | |
StatementExpression ::= PreDecrementExpression | |
StatementExpression ::= PostIncrementExpression | |
StatementExpression ::= PostDecrementExpression | |
StatementExpression ::= MethodInvocation | |
StatementExpression ::= ClassInstanceCreationExpression | |
/:$readableName Expression:/ | |
IfThenStatement ::= 'if' '(' Expression ')' Statement | |
/.$putCase consumeStatementIfNoElse(); $break ./ | |
/:$readableName IfStatement:/ | |
IfThenElseStatement ::= 'if' '(' Expression ')' StatementNoShortIf 'else' Statement | |
/.$putCase consumeStatementIfWithElse(); $break ./ | |
/:$readableName IfStatement:/ | |
IfThenElseStatementNoShortIf ::= 'if' '(' Expression ')' StatementNoShortIf 'else' StatementNoShortIf | |
/.$putCase consumeStatementIfWithElse(); $break ./ | |
/:$readableName IfStatement:/ | |
SwitchStatement ::= 'switch' '(' Expression ')' OpenBlock SwitchBlock | |
/.$putCase consumeStatementSwitch() ; $break ./ | |
/:$readableName SwitchStatement:/ | |
SwitchBlock ::= '{' '}' | |
/.$putCase consumeEmptySwitchBlock() ; $break ./ | |
SwitchBlock ::= '{' SwitchBlockStatements '}' | |
SwitchBlock ::= '{' SwitchLabels '}' | |
SwitchBlock ::= '{' SwitchBlockStatements SwitchLabels '}' | |
/.$putCase consumeSwitchBlock() ; $break ./ | |
/:$readableName SwitchBlock:/ | |
SwitchBlockStatements -> SwitchBlockStatement | |
SwitchBlockStatements ::= SwitchBlockStatements SwitchBlockStatement | |
/.$putCase consumeSwitchBlockStatements() ; $break ./ | |
/:$readableName SwitchBlockStatements:/ | |
SwitchBlockStatement ::= SwitchLabels BlockStatements | |
/.$putCase consumeSwitchBlockStatement() ; $break ./ | |
/:$readableName SwitchBlockStatement:/ | |
SwitchLabels -> SwitchLabel | |
SwitchLabels ::= SwitchLabels SwitchLabel | |
/.$putCase consumeSwitchLabels() ; $break ./ | |
/:$readableName SwitchLabels:/ | |
SwitchLabel ::= 'case' ConstantExpression ':' | |
/. $putCase consumeCaseLabel(); $break ./ | |
SwitchLabel ::= 'default' ':' | |
/. $putCase consumeDefaultLabel(); $break ./ | |
/:$readableName SwitchLabel:/ | |
WhileStatement ::= 'while' '(' Expression ')' Statement | |
/.$putCase consumeStatementWhile() ; $break ./ | |
/:$readableName WhileStatement:/ | |
WhileStatementNoShortIf ::= 'while' '(' Expression ')' StatementNoShortIf | |
/.$putCase consumeStatementWhile() ; $break ./ | |
/:$readableName WhileStatement:/ | |
DoStatement ::= 'do' Statement 'while' '(' Expression ')' ';' | |
/.$putCase consumeStatementDo() ; $break ./ | |
/:$readableName DoStatement:/ | |
ForStatement ::= 'for' '(' ForInitopt ';' Expressionopt ';' ForUpdateopt ')' Statement | |
/.$putCase consumeStatementFor() ; $break ./ | |
/:$readableName ForStatement:/ | |
ForStatementNoShortIf ::= 'for' '(' ForInitopt ';' Expressionopt ';' ForUpdateopt ')' StatementNoShortIf | |
/.$putCase consumeStatementFor() ; $break ./ | |
/:$readableName ForStatement:/ | |
--the minus one allows to avoid a stack-to-stack transfer | |
ForInit ::= StatementExpressionList | |
/.$putCase consumeForInit() ; $break ./ | |
ForInit -> LocalVariableDeclaration | |
/:$readableName ForInit:/ | |
ForUpdate -> StatementExpressionList | |
/:$readableName ForUpdate:/ | |
StatementExpressionList -> StatementExpression | |
StatementExpressionList ::= StatementExpressionList ',' StatementExpression | |
/.$putCase consumeStatementExpressionList() ; $break ./ | |
/:$readableName StatementExpressionList:/ | |
-- 1.4 feature | |
AssertStatement ::= 'assert' Expression ';' | |
/.$putCase consumeSimpleAssertStatement() ; $break ./ | |
/:$compliance 1.4:/ | |
AssertStatement ::= 'assert' Expression ':' Expression ';' | |
/.$putCase consumeAssertStatement() ; $break ./ | |
/:$readableName AssertStatement:/ | |
/:$compliance 1.4:/ | |
BreakStatement ::= 'break' ';' | |
/.$putCase consumeStatementBreak() ; $break ./ | |
BreakStatement ::= 'break' Identifier ';' | |
/.$putCase consumeStatementBreakWithLabel() ; $break ./ | |
/:$readableName BreakStatement:/ | |
ContinueStatement ::= 'continue' ';' | |
/.$putCase consumeStatementContinue() ; $break ./ | |
ContinueStatement ::= 'continue' Identifier ';' | |
/.$putCase consumeStatementContinueWithLabel() ; $break ./ | |
/:$readableName ContinueStatement:/ | |
ReturnStatement ::= 'return' Expressionopt ';' | |
/.$putCase consumeStatementReturn() ; $break ./ | |
/:$readableName ReturnStatement:/ | |
ThrowStatement ::= 'throw' Expression ';' | |
/.$putCase consumeStatementThrow(); $break ./ | |
/:$readableName ThrowStatement:/ | |
SynchronizedStatement ::= OnlySynchronized '(' Expression ')' Block | |
/.$putCase consumeStatementSynchronized(); $break ./ | |
/:$readableName SynchronizedStatement:/ | |
OnlySynchronized ::= 'synchronized' | |
/.$putCase consumeOnlySynchronized(); $break ./ | |
/:$readableName OnlySynchronized:/ | |
TryStatement ::= 'try' TryBlock Catches | |
/.$putCase consumeStatementTry(false); $break ./ | |
TryStatement ::= 'try' TryBlock Catchesopt Finally | |
/.$putCase consumeStatementTry(true); $break ./ | |
/:$readableName TryStatement:/ | |
TryBlock ::= Block ExitTryBlock | |
/:$readableName Block:/ | |
ExitTryBlock ::= $empty | |
/.$putCase consumeExitTryBlock(); $break ./ | |
/:$readableName ExitTryBlock:/ | |
Catches -> CatchClause | |
Catches ::= Catches CatchClause | |
/.$putCase consumeCatches(); $break ./ | |
/:$readableName Catches:/ | |
CatchClause ::= 'catch' '(' FormalParameter ')' Block | |
/.$putCase consumeStatementCatch() ; $break ./ | |
/:$readableName CatchClause:/ | |
Finally ::= 'finally' Block | |
/:$readableName Finally:/ | |
--18.12 Productions from 14: Expressions | |
--for source positionning purpose | |
PushLPAREN ::= '(' | |
/.$putCase consumeLeftParen(); $break ./ | |
/:$readableName (:/ | |
PushRPAREN ::= ')' | |
/.$putCase consumeRightParen(); $break ./ | |
/:$readableName ):/ | |
Primary -> PrimaryNoNewArray | |
Primary -> ArrayCreationWithArrayInitializer | |
Primary -> ArrayCreationWithoutArrayInitializer | |
/:$readableName Expression:/ | |
PrimaryNoNewArray -> Literal | |
PrimaryNoNewArray ::= 'this' | |
/.$putCase consumePrimaryNoNewArrayThis(); $break ./ | |
PrimaryNoNewArray ::= PushLPAREN Expression_NotName PushRPAREN | |
/.$putCase consumePrimaryNoNewArray(); $break ./ | |
PrimaryNoNewArray ::= PushLPAREN Name PushRPAREN | |
/.$putCase consumePrimaryNoNewArrayWithName(); $break ./ | |
PrimaryNoNewArray -> ClassInstanceCreationExpression | |
PrimaryNoNewArray -> FieldAccess | |
--1.1 feature | |
PrimaryNoNewArray ::= Name '.' 'this' | |
/.$putCase consumePrimaryNoNewArrayNameThis(); $break ./ | |
PrimaryNoNewArray ::= Name '.' 'super' | |
/.$putCase consumePrimaryNoNewArrayNameSuper(); $break ./ | |
--1.1 feature | |
--PrimaryNoNewArray ::= Type '.' 'class' | |
--inline Type in the previous rule in order to make the grammar LL1 instead | |
-- of LL2. The result is the 3 next rules. | |
PrimaryNoNewArray ::= Name '.' 'class' | |
/.$putCase consumePrimaryNoNewArrayName(); $break ./ | |
PrimaryNoNewArray ::= Name Dims '.' 'class' | |
/.$putCase consumePrimaryNoNewArrayArrayType(); $break ./ | |
PrimaryNoNewArray ::= PrimitiveType Dims '.' 'class' | |
/.$putCase consumePrimaryNoNewArrayPrimitiveArrayType(); $break ./ | |
PrimaryNoNewArray ::= PrimitiveType '.' 'class' | |
/.$putCase consumePrimaryNoNewArrayPrimitiveType(); $break ./ | |
PrimaryNoNewArray -> MethodInvocation | |
PrimaryNoNewArray -> ArrayAccess | |
/:$readableName Expression:/ | |
--1.1 feature | |
-- | |
-- In Java 1.0 a ClassBody could not appear at all in a | |
-- ClassInstanceCreationExpression. | |
-- | |
AllocationHeader ::= 'new' ClassType '(' ArgumentListopt ')' | |
/.$putCase consumeAllocationHeader(); $break ./ | |
/:$readableName AllocationHeader:/ | |
ClassInstanceCreationExpression ::= 'new' OnlyTypeArguments ClassType '(' ArgumentListopt ')' ClassBodyopt | |
/.$putCase consumeClassInstanceCreationExpressionWithTypeArguments(); $break ./ | |
ClassInstanceCreationExpression ::= 'new' ClassType '(' ArgumentListopt ')' ClassBodyopt | |
/.$putCase consumeClassInstanceCreationExpression(); $break ./ | |
--1.1 feature | |
ClassInstanceCreationExpression ::= Primary '.' 'new' OnlyTypeArguments ClassType '(' ArgumentListopt ')' ClassBodyopt | |
/.$putCase consumeClassInstanceCreationExpressionQualifiedWithTypeArguments() ; $break ./ | |
ClassInstanceCreationExpression ::= Primary '.' 'new' ClassType '(' ArgumentListopt ')' ClassBodyopt | |
/.$putCase consumeClassInstanceCreationExpressionQualified() ; $break ./ | |
--1.1 feature | |
ClassInstanceCreationExpression ::= ClassInstanceCreationExpressionName 'new' ClassType '(' ArgumentListopt ')' ClassBodyopt | |
/.$putCase consumeClassInstanceCreationExpressionQualified() ; $break ./ | |
/:$readableName ClassInstanceCreationExpression:/ | |
ClassInstanceCreationExpression ::= ClassInstanceCreationExpressionName 'new' OnlyTypeArguments ClassType '(' ArgumentListopt ')' ClassBodyopt | |
/.$putCase consumeClassInstanceCreationExpressionQualifiedWithTypeArguments() ; $break ./ | |
/:$readableName ClassInstanceCreationExpression:/ | |
ClassInstanceCreationExpressionName ::= Name '.' | |
/.$putCase consumeClassInstanceCreationExpressionName() ; $break ./ | |
/:$readableName ClassInstanceCreationExpressionName:/ | |
ClassBodyopt ::= $empty --test made using null as contents | |
/.$putCase consumeClassBodyopt(); $break ./ | |
ClassBodyopt ::= EnterAnonymousClassBody ClassBody | |
/:$readableName ClassBody:/ | |
EnterAnonymousClassBody ::= $empty | |
/.$putCase consumeEnterAnonymousClassBody(); $break ./ | |
/:$readableName EnterAnonymousClassBody:/ | |
ArgumentList ::= Expression | |
ArgumentList ::= ArgumentList ',' Expression | |
/.$putCase consumeArgumentList(); $break ./ | |
/:$readableName ArgumentList:/ | |
ArrayCreationHeader ::= 'new' PrimitiveType DimWithOrWithOutExprs | |
/.$putCase consumeArrayCreationHeader(); $break ./ | |
ArrayCreationHeader ::= 'new' ClassOrInterfaceType DimWithOrWithOutExprs | |
/.$putCase consumeArrayCreationHeader(); $break ./ | |
/:$readableName ArrayCreationHeader:/ | |
ArrayCreationWithoutArrayInitializer ::= 'new' PrimitiveType DimWithOrWithOutExprs | |
/.$putCase consumeArrayCreationExpressionWithoutInitializer(); $break ./ | |
/:$readableName ArrayCreationWithoutArrayInitializer:/ | |
ArrayCreationWithArrayInitializer ::= 'new' PrimitiveType DimWithOrWithOutExprs ArrayInitializer | |
/.$putCase consumeArrayCreationExpressionWithInitializer(); $break ./ | |
/:$readableName ArrayCreationWithArrayInitializer:/ | |
ArrayCreationWithoutArrayInitializer ::= 'new' ClassOrInterfaceType DimWithOrWithOutExprs | |
/.$putCase consumeArrayCreationExpressionWithoutInitializer(); $break ./ | |
ArrayCreationWithArrayInitializer ::= 'new' ClassOrInterfaceType DimWithOrWithOutExprs ArrayInitializer | |
/.$putCase consumeArrayCreationExpressionWithInitializer(); $break ./ | |
DimWithOrWithOutExprs ::= DimWithOrWithOutExpr | |
DimWithOrWithOutExprs ::= DimWithOrWithOutExprs DimWithOrWithOutExpr | |
/.$putCase consumeDimWithOrWithOutExprs(); $break ./ | |
/:$readableName Dimensions:/ | |
DimWithOrWithOutExpr ::= '[' Expression ']' | |
DimWithOrWithOutExpr ::= '[' ']' | |
/. $putCase consumeDimWithOrWithOutExpr(); $break ./ | |
/:$readableName Dimension:/ | |
-- ----------------------------------------------- | |
Dims ::= DimsLoop | |
/. $putCase consumeDims(); $break ./ | |
/:$readableName Dimensions:/ | |
DimsLoop -> OneDimLoop | |
DimsLoop ::= DimsLoop OneDimLoop | |
/:$readableName Dimensions:/ | |
OneDimLoop ::= '[' ']' | |
/. $putCase consumeOneDimLoop(); $break ./ | |
/:$readableName Dimension:/ | |
FieldAccess ::= Primary '.' 'Identifier' | |
/.$putCase consumeFieldAccess(false); $break ./ | |
FieldAccess ::= 'super' '.' 'Identifier' | |
/.$putCase consumeFieldAccess(true); $break ./ | |
/:$readableName FieldAccess:/ | |
MethodInvocation ::= Name '(' ArgumentListopt ')' | |
/.$putCase consumeMethodInvocationName(); $break ./ | |
MethodInvocation ::= Name '.' OnlyTypeArguments 'Identifier' '(' ArgumentListopt ')' | |
/.$putCase consumeMethodInvocationNameWithTypeArguments(); $break ./ | |
MethodInvocation ::= Primary '.' OnlyTypeArguments 'Identifier' '(' ArgumentListopt ')' | |
/.$putCase consumeMethodInvocationPrimaryWithTypeArguments(); $break ./ | |
MethodInvocation ::= Primary '.' 'Identifier' '(' ArgumentListopt ')' | |
/.$putCase consumeMethodInvocationPrimary(); $break ./ | |
MethodInvocation ::= 'super' '.' OnlyTypeArguments 'Identifier' '(' ArgumentListopt ')' | |
/.$putCase consumeMethodInvocationSuperWithTypeArguments(); $break ./ | |
MethodInvocation ::= 'super' '.' 'Identifier' '(' ArgumentListopt ')' | |
/.$putCase consumeMethodInvocationSuper(); $break ./ | |
/:$readableName MethodInvocation:/ | |
ArrayAccess ::= Name '[' Expression ']' | |
/.$putCase consumeArrayAccess(true); $break ./ | |
ArrayAccess ::= PrimaryNoNewArray '[' Expression ']' | |
/.$putCase consumeArrayAccess(false); $break ./ | |
ArrayAccess ::= ArrayCreationWithArrayInitializer '[' Expression ']' | |
/.$putCase consumeArrayAccess(false); $break ./ | |
/:$readableName ArrayAccess:/ | |
PostfixExpression -> Primary | |
PostfixExpression ::= Name | |
/.$putCase consumePostfixExpression(); $break ./ | |
PostfixExpression -> PostIncrementExpression | |
PostfixExpression -> PostDecrementExpression | |
/:$readableName Expression:/ | |
PostIncrementExpression ::= PostfixExpression '++' | |
/.$putCase consumeUnaryExpression(OperatorIds.PLUS,true); $break ./ | |
/:$readableName PostIncrementExpression:/ | |
PostDecrementExpression ::= PostfixExpression '--' | |
/.$putCase consumeUnaryExpression(OperatorIds.MINUS,true); $break ./ | |
/:$readableName PostDecrementExpression:/ | |
--for source managment purpose | |
PushPosition ::= $empty | |
/.$putCase consumePushPosition(); $break ./ | |
/:$readableName PushPosition:/ | |
UnaryExpression -> PreIncrementExpression | |
UnaryExpression -> PreDecrementExpression | |
UnaryExpression ::= '+' PushPosition UnaryExpression | |
/.$putCase consumeUnaryExpression(OperatorIds.PLUS); $break ./ | |
UnaryExpression ::= '-' PushPosition UnaryExpression | |
/.$putCase consumeUnaryExpression(OperatorIds.MINUS); $break ./ | |
UnaryExpression -> UnaryExpressionNotPlusMinus | |
/:$readableName Expression:/ | |
PreIncrementExpression ::= '++' PushPosition UnaryExpression | |
/.$putCase consumeUnaryExpression(OperatorIds.PLUS,false); $break ./ | |
/:$readableName PreIncrementExpression:/ | |
PreDecrementExpression ::= '--' PushPosition UnaryExpression | |
/.$putCase consumeUnaryExpression(OperatorIds.MINUS,false); $break ./ | |
/:$readableName PreDecrementExpression:/ | |
UnaryExpressionNotPlusMinus -> PostfixExpression | |
UnaryExpressionNotPlusMinus ::= '~' PushPosition UnaryExpression | |
/.$putCase consumeUnaryExpression(OperatorIds.TWIDDLE); $break ./ | |
UnaryExpressionNotPlusMinus ::= '!' PushPosition UnaryExpression | |
/.$putCase consumeUnaryExpression(OperatorIds.NOT); $break ./ | |
UnaryExpressionNotPlusMinus -> CastExpression | |
/:$readableName Expression:/ | |
CastExpression ::= PushLPAREN PrimitiveType Dimsopt PushRPAREN InsideCastExpression UnaryExpression | |
/.$putCase consumeCastExpressionWithPrimitiveType(); $break ./ | |
CastExpression ::= PushLPAREN Name OnlyTypeArgumentsForCastExpression Dimsopt PushRPAREN InsideCastExpression UnaryExpressionNotPlusMinus | |
/.$putCase consumeCastExpressionWithGenericsArray(); $break ./ | |
CastExpression ::= PushLPAREN Name OnlyTypeArgumentsForCastExpression '.' ClassOrInterfaceType Dimsopt PushRPAREN InsideCastExpressionWithQualifiedGenerics UnaryExpressionNotPlusMinus | |
/.$putCase consumeCastExpressionWithQualifiedGenericsArray(); $break ./ | |
CastExpression ::= PushLPAREN Name PushRPAREN InsideCastExpressionLL1 UnaryExpressionNotPlusMinus | |
/.$putCase consumeCastExpressionLL1(); $break ./ | |
CastExpression ::= PushLPAREN Name Dims PushRPAREN InsideCastExpression UnaryExpressionNotPlusMinus | |
/.$putCase consumeCastExpressionWithNameArray(); $break ./ | |
/:$readableName CastExpression:/ | |
OnlyTypeArgumentsForCastExpression ::= OnlyTypeArguments | |
/.$putCase consumeOnlyTypeArgumentsForCastExpression(); $break ./ | |
/:$readableName TypeArguments:/ | |
InsideCastExpression ::= $empty | |
/.$putCase consumeInsideCastExpression(); $break ./ | |
/:$readableName InsideCastExpression:/ | |
InsideCastExpressionLL1 ::= $empty | |
/.$putCase consumeInsideCastExpressionLL1(); $break ./ | |
/:$readableName InsideCastExpression:/ | |
InsideCastExpressionWithQualifiedGenerics ::= $empty | |
/.$putCase consumeInsideCastExpressionWithQualifiedGenerics(); $break ./ | |
/:$readableName InsideCastExpression:/ | |
MultiplicativeExpression -> UnaryExpression | |
MultiplicativeExpression ::= MultiplicativeExpression '*' UnaryExpression | |
/.$putCase consumeBinaryExpression(OperatorIds.MULTIPLY); $break ./ | |
MultiplicativeExpression ::= MultiplicativeExpression '/' UnaryExpression | |
/.$putCase consumeBinaryExpression(OperatorIds.DIVIDE); $break ./ | |
MultiplicativeExpression ::= MultiplicativeExpression '%' UnaryExpression | |
/.$putCase consumeBinaryExpression(OperatorIds.REMAINDER); $break ./ | |
/:$readableName Expression:/ | |
AdditiveExpression -> MultiplicativeExpression | |
AdditiveExpression ::= AdditiveExpression '+' MultiplicativeExpression | |
/.$putCase consumeBinaryExpression(OperatorIds.PLUS); $break ./ | |
AdditiveExpression ::= AdditiveExpression '-' MultiplicativeExpression | |
/.$putCase consumeBinaryExpression(OperatorIds.MINUS); $break ./ | |
/:$readableName Expression:/ | |
ShiftExpression -> AdditiveExpression | |
ShiftExpression ::= ShiftExpression '<<' AdditiveExpression | |
/.$putCase consumeBinaryExpression(OperatorIds.LEFT_SHIFT); $break ./ | |
ShiftExpression ::= ShiftExpression '>>' AdditiveExpression | |
/.$putCase consumeBinaryExpression(OperatorIds.RIGHT_SHIFT); $break ./ | |
ShiftExpression ::= ShiftExpression '>>>' AdditiveExpression | |
/.$putCase consumeBinaryExpression(OperatorIds.UNSIGNED_RIGHT_SHIFT); $break ./ | |
/:$readableName Expression:/ | |
RelationalExpression -> ShiftExpression | |
RelationalExpression ::= RelationalExpression '<' ShiftExpression | |
/.$putCase consumeBinaryExpression(OperatorIds.LESS); $break ./ | |
RelationalExpression ::= RelationalExpression '>' ShiftExpression | |
/.$putCase consumeBinaryExpression(OperatorIds.GREATER); $break ./ | |
RelationalExpression ::= RelationalExpression '<=' ShiftExpression | |
/.$putCase consumeBinaryExpression(OperatorIds.LESS_EQUAL); $break ./ | |
RelationalExpression ::= RelationalExpression '>=' ShiftExpression | |
/.$putCase consumeBinaryExpression(OperatorIds.GREATER_EQUAL); $break ./ | |
/:$readableName Expression:/ | |
InstanceofExpression -> RelationalExpression | |
InstanceofExpression ::= InstanceofExpression 'instanceof' ReferenceType | |
/.$putCase consumeInstanceOfExpression(OperatorIds.INSTANCEOF); $break ./ | |
/:$readableName Expression:/ | |
EqualityExpression -> InstanceofExpression | |
EqualityExpression ::= EqualityExpression '==' InstanceofExpression | |
/.$putCase consumeEqualityExpression(OperatorIds.EQUAL_EQUAL); $break ./ | |
EqualityExpression ::= EqualityExpression '!=' InstanceofExpression | |
/.$putCase consumeEqualityExpression(OperatorIds.NOT_EQUAL); $break ./ | |
/:$readableName Expression:/ | |
AndExpression -> EqualityExpression | |
AndExpression ::= AndExpression '&' EqualityExpression | |
/.$putCase consumeBinaryExpression(OperatorIds.AND); $break ./ | |
/:$readableName Expression:/ | |
ExclusiveOrExpression -> AndExpression | |
ExclusiveOrExpression ::= ExclusiveOrExpression '^' AndExpression | |
/.$putCase consumeBinaryExpression(OperatorIds.XOR); $break ./ | |
/:$readableName Expression:/ | |
InclusiveOrExpression -> ExclusiveOrExpression | |
InclusiveOrExpression ::= InclusiveOrExpression '|' ExclusiveOrExpression | |
/.$putCase consumeBinaryExpression(OperatorIds.OR); $break ./ | |
/:$readableName Expression:/ | |
ConditionalAndExpression -> InclusiveOrExpression | |
ConditionalAndExpression ::= ConditionalAndExpression '&&' InclusiveOrExpression | |
/.$putCase consumeBinaryExpression(OperatorIds.AND_AND); $break ./ | |
/:$readableName Expression:/ | |
ConditionalOrExpression -> ConditionalAndExpression | |
ConditionalOrExpression ::= ConditionalOrExpression '||' ConditionalAndExpression | |
/.$putCase consumeBinaryExpression(OperatorIds.OR_OR); $break ./ | |
/:$readableName Expression:/ | |
ConditionalExpression -> ConditionalOrExpression | |
ConditionalExpression ::= ConditionalOrExpression '?' Expression ':' ConditionalExpression | |
/.$putCase consumeConditionalExpression(OperatorIds.QUESTIONCOLON) ; $break ./ | |
/:$readableName Expression:/ | |
AssignmentExpression -> ConditionalExpression | |
AssignmentExpression -> Assignment | |
/:$readableName Expression:/ | |
Assignment ::= PostfixExpression AssignmentOperator AssignmentExpression | |
/.$putCase consumeAssignment(); $break ./ | |
/:$readableName Assignment:/ | |
-- this rule is added to parse an array initializer in a assigment and then report a syntax error knowing the exact senario | |
InvalidArrayInitializerAssignement ::= PostfixExpression AssignmentOperator ArrayInitializer | |
/:$readableName ArrayInitializerAssignement:/ | |
Assignment ::= InvalidArrayInitializerAssignement | |
/.$putcase ignoreExpressionAssignment();$break ./ | |
AssignmentOperator ::= '=' | |
/.$putCase consumeAssignmentOperator(EQUAL); $break ./ | |
AssignmentOperator ::= '*=' | |
/.$putCase consumeAssignmentOperator(MULTIPLY); $break ./ | |
AssignmentOperator ::= '/=' | |
/.$putCase consumeAssignmentOperator(DIVIDE); $break ./ | |
AssignmentOperator ::= '%=' | |
/.$putCase consumeAssignmentOperator(REMAINDER); $break ./ | |
AssignmentOperator ::= '+=' | |
/.$putCase consumeAssignmentOperator(PLUS); $break ./ | |
AssignmentOperator ::= '-=' | |
/.$putCase consumeAssignmentOperator(MINUS); $break ./ | |
AssignmentOperator ::= '<<=' | |
/.$putCase consumeAssignmentOperator(LEFT_SHIFT); $break ./ | |
AssignmentOperator ::= '>>=' | |
/.$putCase consumeAssignmentOperator(RIGHT_SHIFT); $break ./ | |
AssignmentOperator ::= '>>>=' | |
/.$putCase consumeAssignmentOperator(UNSIGNED_RIGHT_SHIFT); $break ./ | |
AssignmentOperator ::= '&=' | |
/.$putCase consumeAssignmentOperator(AND); $break ./ | |
AssignmentOperator ::= '^=' | |
/.$putCase consumeAssignmentOperator(XOR); $break ./ | |
AssignmentOperator ::= '|=' | |
/.$putCase consumeAssignmentOperator(OR); $break ./ | |
/:$readableName AssignmentOperator:/ | |
Expression -> AssignmentExpression | |
/:$readableName Expression:/ | |
-- The following rules are for optional nonterminals. | |
-- | |
ClassHeaderExtendsopt ::= $empty | |
ClassHeaderExtendsopt -> ClassHeaderExtends | |
/:$readableName ClassHeaderExtends:/ | |
Expressionopt ::= $empty | |
/.$putCase consumeEmptyExpression(); $break ./ | |
Expressionopt -> Expression | |
/:$readableName Expression:/ | |
ConstantExpression -> Expression | |
/:$readableName ConstantExpression:/ | |
--------------------------------------------------------------------------------------- | |
-- | |
-- The rules below are for optional terminal symbols. An optional comma, | |
-- is only used in the context of an array initializer - It is a | |
-- "syntactic sugar" that otherwise serves no other purpose. By contrast, | |
-- an optional identifier is used in the definition of a break and | |
-- continue statement. When the identifier does not appear, a NULL | |
-- is produced. When the identifier is present, the user should use the | |
-- corresponding TOKEN(i) method. See break statement as an example. | |
-- | |
--------------------------------------------------------------------------------------- | |
,opt -> $empty | |
,opt -> , | |
/:$readableName ,:/ | |
ClassBodyDeclarationsopt ::= $empty | |
/.$putCase consumeEmptyClassBodyDeclarationsopt(); $break ./ | |
ClassBodyDeclarationsopt ::= NestedType ClassBodyDeclarations | |
/.$putCase consumeClassBodyDeclarationsopt(); $break ./ | |
/:$readableName ClassBodyDeclarations:/ | |
Modifiersopt ::= $empty | |
/. $putCase consumeDefaultModifiers(); $break ./ | |
Modifiersopt ::= Modifiers | |
/.$putCase consumeModifiers(); $break ./ | |
/:$readableName Modifiers:/ | |
BlockStatementsopt ::= $empty | |
/.$putCase consumeEmptyBlockStatementsopt(); $break ./ | |
BlockStatementsopt -> BlockStatements | |
/:$readableName BlockStatements:/ | |
Dimsopt ::= $empty | |
/. $putCase consumeEmptyDimsopt(); $break ./ | |
Dimsopt -> Dims | |
/:$readableName Dimensions:/ | |
ArgumentListopt ::= $empty | |
/. $putCase consumeEmptyArgumentListopt(); $break ./ | |
ArgumentListopt -> ArgumentList | |
/:$readableName ArgumentList:/ | |
MethodHeaderThrowsClauseopt ::= $empty | |
MethodHeaderThrowsClauseopt -> MethodHeaderThrowsClause | |
/:$readableName MethodHeaderThrowsClause:/ | |
FormalParameterListopt ::= $empty | |
/.$putcase consumeFormalParameterListopt(); $break ./ | |
FormalParameterListopt -> FormalParameterList | |
/:$readableName FormalParameterList:/ | |
ClassHeaderImplementsopt ::= $empty | |
ClassHeaderImplementsopt -> ClassHeaderImplements | |
/:$readableName ClassHeaderImplements:/ | |
InterfaceMemberDeclarationsopt ::= $empty | |
/. $putCase consumeEmptyInterfaceMemberDeclarationsopt(); $break ./ | |
InterfaceMemberDeclarationsopt ::= NestedType InterfaceMemberDeclarations | |
/. $putCase consumeInterfaceMemberDeclarationsopt(); $break ./ | |
/:$readableName InterfaceMemberDeclarations:/ | |
NestedType ::= $empty | |
/.$putCase consumeNestedType(); $break./ | |
/:$readableName NestedType:/ | |
ForInitopt ::= $empty | |
/. $putCase consumeEmptyForInitopt(); $break ./ | |
ForInitopt -> ForInit | |
/:$readableName ForInit:/ | |
ForUpdateopt ::= $empty | |
/. $putCase consumeEmptyForUpdateopt(); $break ./ | |
ForUpdateopt -> ForUpdate | |
/:$readableName ForUpdate:/ | |
InterfaceHeaderExtendsopt ::= $empty | |
InterfaceHeaderExtendsopt -> InterfaceHeaderExtends | |
/:$readableName InterfaceHeaderExtends:/ | |
Catchesopt ::= $empty | |
/. $putCase consumeEmptyCatchesopt(); $break ./ | |
Catchesopt -> Catches | |
/:$readableName Catches:/ | |
----------------------------------------------- | |
-- 1.5 features : enum type | |
----------------------------------------------- | |
EnumDeclaration ::= EnumHeader EnumBody | |
/. $putCase consumeEnumDeclaration(); $break ./ | |
/:$readableName EnumDeclaration:/ | |
EnumHeader ::= EnumHeaderName ClassHeaderImplementsopt | |
/. $putCase consumeEnumHeader(); $break ./ | |
/:$readableName EnumHeader:/ | |
EnumHeaderName ::= Modifiersopt 'enum' Identifier | |
/. $putCase consumeEnumHeaderName(); $break ./ | |
/:$readableName EnumHeaderName:/ | |
/:$compliance 1.5:/ | |
EnumBody ::= '{' EnumBodyDeclarationsopt '}' | |
/. $putCase consumeEnumBodyNoConstants(); $break ./ | |
EnumBody ::= '{' ',' EnumBodyDeclarationsopt '}' | |
/. $putCase consumeEnumBodyNoConstants(); $break ./ | |
EnumBody ::= '{' EnumConstants ',' EnumBodyDeclarationsopt '}' | |
/. $putCase consumeEnumBodyWithConstants(); $break ./ | |
EnumBody ::= '{' EnumConstants EnumBodyDeclarationsopt '}' | |
/. $putCase consumeEnumBodyWithConstants(); $break ./ | |
/:$readableName EnumBody:/ | |
EnumConstants -> EnumConstant | |
EnumConstants ::= EnumConstants ',' EnumConstant | |
/.$putCase consumeEnumConstants(); $break ./ | |
/:$readableName EnumConstants:/ | |
EnumConstantHeaderName ::= Modifiersopt Identifier | |
/.$putCase consumeEnumConstantHeaderName(); $break ./ | |
/:$readableName EnumConstantHeaderName:/ | |
EnumConstantHeader ::= EnumConstantHeaderName Argumentsopt | |
/.$putCase consumeEnumConstantHeader(); $break ./ | |
/:$readableName EnumConstantHeader:/ | |
EnumConstant ::= EnumConstantHeader ForceNoDiet ClassBody RestoreDiet | |
/.$putCase consumeEnumConstantWithClassBody(); $break ./ | |
EnumConstant ::= EnumConstantHeader | |
/.$putCase consumeEnumConstantNoClassBody(); $break ./ | |
/:$readableName EnumConstant:/ | |
Arguments ::= '(' ArgumentListopt ')' | |
/.$putCase consumeArguments(); $break ./ | |
/:$readableName Arguments:/ | |
Argumentsopt ::= $empty | |
/.$putCase consumeEmptyArguments(); $break ./ | |
Argumentsopt -> Arguments | |
/:$readableName Argumentsopt:/ | |
EnumDeclarations ::= ';' ClassBodyDeclarationsopt | |
/.$putCase consumeEnumDeclarations(); $break ./ | |
/:$readableName EnumDeclarations:/ | |
EnumBodyDeclarationsopt ::= $empty | |
/.$putCase consumeEmptyEnumDeclarations(); $break ./ | |
EnumBodyDeclarationsopt -> EnumDeclarations | |
/:$readableName EnumBodyDeclarationsopt:/ | |
----------------------------------------------- | |
-- 1.5 features : enhanced for statement | |
----------------------------------------------- | |
EnhancedForStatement ::= EnhancedForStatementHeader Statement | |
/.$putCase consumeEnhancedForStatement(); $break ./ | |
/:$readableName EnhancedForStatement:/ | |
EnhancedForStatementNoShortIf ::= EnhancedForStatementHeader StatementNoShortIf | |
/.$putCase consumeEnhancedForStatement(); $break ./ | |
/:$readableName EnhancedForStatementNoShortIf:/ | |
EnhancedForStatementHeader ::= 'for' '(' Type PushModifiers Identifier Dimsopt ':' Expression ')' | |
/.$putCase consumeEnhancedForStatementHeader(false); $break ./ | |
/:$readableName EnhancedForStatementHeader:/ | |
/:$compliance 1.5:/ | |
EnhancedForStatementHeader ::= 'for' '(' Modifiers Type PushRealModifiers Identifier Dimsopt ':' Expression ')' | |
/.$putCase consumeEnhancedForStatementHeader(true); $break ./ | |
/:$readableName EnhancedForStatementHeader:/ | |
/:$compliance 1.5:/ | |
----------------------------------------------- | |
-- 1.5 features : static imports | |
----------------------------------------------- | |
SingleStaticImportDeclaration ::= SingleStaticImportDeclarationName ';' | |
/.$putCase consumeImportDeclaration(); $break ./ | |
/:$readableName SingleStaticImportDeclaration:/ | |
SingleStaticImportDeclarationName ::= 'import' 'static' Name | |
/.$putCase consumeSingleStaticImportDeclarationName(); $break ./ | |
/:$readableName SingleStaticImportDeclarationName:/ | |
/:$compliance 1.5:/ | |
StaticImportOnDemandDeclaration ::= StaticImportOnDemandDeclarationName ';' | |
/.$putCase consumeImportDeclaration(); $break ./ | |
/:$readableName StaticImportOnDemandDeclaration:/ | |
StaticImportOnDemandDeclarationName ::= 'import' 'static' Name '.' '*' | |
/.$putCase consumeStaticImportOnDemandDeclarationName(); $break ./ | |
/:$readableName StaticImportOnDemandDeclarationName:/ | |
/:$compliance 1.5:/ | |
----------------------------------------------- | |
-- 1.5 features : generics | |
----------------------------------------------- | |
TypeArguments ::= '<' TypeArgumentList1 | |
/.$putCase consumeTypeArguments(); $break ./ | |
/:$readableName TypeArguments:/ | |
/:$compliance 1.5:/ | |
OnlyTypeArguments ::= '<' TypeArgumentList1 | |
/.$putCase consumeOnlyTypeArguments(); $break ./ | |
/:$readableName TypeArguments:/ | |
/:$compliance 1.5:/ | |
TypeArgumentList1 -> TypeArgument1 | |
/:$compliance 1.5:/ | |
TypeArgumentList1 ::= TypeArgumentList ',' TypeArgument1 | |
/.$putCase consumeTypeArgumentList1(); $break ./ | |
/:$readableName TypeArgumentList1:/ | |
/:$compliance 1.5:/ | |
TypeArgumentList -> TypeArgument | |
/:$compliance 1.5:/ | |
TypeArgumentList ::= TypeArgumentList ',' TypeArgument | |
/.$putCase consumeTypeArgumentList(); $break ./ | |
/:$readableName TypeArgumentList:/ | |
/:$compliance 1.5:/ | |
TypeArgument ::= ReferenceType | |
/.$putCase consumeTypeArgument(); $break ./ | |
/:$compliance 1.5:/ | |
TypeArgument -> Wildcard | |
/:$readableName TypeArgument:/ | |
/:$compliance 1.5:/ | |
TypeArgument1 -> ReferenceType1 | |
/:$compliance 1.5:/ | |
TypeArgument1 -> Wildcard1 | |
/:$readableName TypeArgument1:/ | |
/:$compliance 1.5:/ | |
ReferenceType1 ::= ReferenceType '>' | |
/.$putCase consumeReferenceType1(); $break ./ | |
/:$compliance 1.5:/ | |
ReferenceType1 ::= ClassOrInterface '<' TypeArgumentList2 | |
/.$putCase consumeTypeArgumentReferenceType1(); $break ./ | |
/:$readableName ReferenceType1:/ | |
/:$compliance 1.5:/ | |
TypeArgumentList2 -> TypeArgument2 | |
/:$compliance 1.5:/ | |
TypeArgumentList2 ::= TypeArgumentList ',' TypeArgument2 | |
/.$putCase consumeTypeArgumentList2(); $break ./ | |
/:$readableName TypeArgumentList2:/ | |
/:$compliance 1.5:/ | |
TypeArgument2 -> ReferenceType2 | |
/:$compliance 1.5:/ | |
TypeArgument2 -> Wildcard2 | |
/:$readableName TypeArgument2:/ | |
/:$compliance 1.5:/ | |
ReferenceType2 ::= ReferenceType '>>' | |
/.$putCase consumeReferenceType2(); $break ./ | |
/:$compliance 1.5:/ | |
ReferenceType2 ::= ClassOrInterface '<' TypeArgumentList3 | |
/.$putCase consumeTypeArgumentReferenceType2(); $break ./ | |
/:$readableName ReferenceType2:/ | |
/:$compliance 1.5:/ | |
TypeArgumentList3 -> TypeArgument3 | |
TypeArgumentList3 ::= TypeArgumentList ',' TypeArgument3 | |
/.$putCase consumeTypeArgumentList3(); $break ./ | |
/:$readableName TypeArgumentList3:/ | |
/:$compliance 1.5:/ | |
TypeArgument3 -> ReferenceType3 | |
TypeArgument3 -> Wildcard3 | |
/:$readableName TypeArgument3:/ | |
/:$compliance 1.5:/ | |
ReferenceType3 ::= ReferenceType '>>>' | |
/.$putCase consumeReferenceType3(); $break ./ | |
/:$readableName ReferenceType3:/ | |
/:$compliance 1.5:/ | |
Wildcard ::= '?' | |
/.$putCase consumeWildcard(); $break ./ | |
/:$compliance 1.5:/ | |
Wildcard ::= '?' WildcardBounds | |
/.$putCase consumeWildcardWithBounds(); $break ./ | |
/:$readableName Wildcard:/ | |
/:$compliance 1.5:/ | |
WildcardBounds ::= 'extends' ReferenceType | |
/.$putCase consumeWildcardBoundsExtends(); $break ./ | |
/:$compliance 1.5:/ | |
WildcardBounds ::= 'super' ReferenceType | |
/.$putCase consumeWildcardBoundsSuper(); $break ./ | |
/:$readableName WildcardBounds:/ | |
/:$compliance 1.5:/ | |
Wildcard1 ::= '?' '>' | |
/.$putCase consumeWildcard1(); $break ./ | |
/:$compliance 1.5:/ | |
Wildcard1 ::= '?' WildcardBounds1 | |
/.$putCase consumeWildcard1WithBounds(); $break ./ | |
/:$readableName Wildcard1:/ | |
/:$compliance 1.5:/ | |
WildcardBounds1 ::= 'extends' ReferenceType1 | |
/.$putCase consumeWildcardBounds1Extends(); $break ./ | |
/:$compliance 1.5:/ | |
WildcardBounds1 ::= 'super' ReferenceType1 | |
/.$putCase consumeWildcardBounds1Super(); $break ./ | |
/:$readableName WildcardBounds1:/ | |
/:$compliance 1.5:/ | |
Wildcard2 ::= '?' '>>' | |
/.$putCase consumeWildcard2(); $break ./ | |
/:$compliance 1.5:/ | |
Wildcard2 ::= '?' WildcardBounds2 | |
/.$putCase consumeWildcard2WithBounds(); $break ./ | |
/:$readableName Wildcard2:/ | |
/:$compliance 1.5:/ | |
WildcardBounds2 ::= 'extends' ReferenceType2 | |
/.$putCase consumeWildcardBounds2Extends(); $break ./ | |
/:$compliance 1.5:/ | |
WildcardBounds2 ::= 'super' ReferenceType2 | |
/.$putCase consumeWildcardBounds2Super(); $break ./ | |
/:$readableName WildcardBounds2:/ | |
/:$compliance 1.5:/ | |
Wildcard3 ::= '?' '>>>' | |
/.$putCase consumeWildcard3(); $break ./ | |
/:$compliance 1.5:/ | |
Wildcard3 ::= '?' WildcardBounds3 | |
/.$putCase consumeWildcard3WithBounds(); $break ./ | |
/:$readableName Wildcard3:/ | |
/:$compliance 1.5:/ | |
WildcardBounds3 ::= 'extends' ReferenceType3 | |
/.$putCase consumeWildcardBounds3Extends(); $break ./ | |
/:$compliance 1.5:/ | |
WildcardBounds3 ::= 'super' ReferenceType3 | |
/.$putCase consumeWildcardBounds3Super(); $break ./ | |
/:$readableName WildcardBound3:/ | |
/:$compliance 1.5:/ | |
TypeParameterHeader ::= Identifier | |
/.$putCase consumeTypeParameterHeader(); $break ./ | |
/:$readableName TypeParameter:/ | |
/:$compliance 1.5:/ | |
TypeParameters ::= '<' TypeParameterList1 | |
/.$putCase consumeTypeParameters(); $break ./ | |
/:$readableName TypeParameters:/ | |
/:$compliance 1.5:/ | |
TypeParameterList -> TypeParameter | |
/:$compliance 1.5:/ | |
TypeParameterList ::= TypeParameterList ',' TypeParameter | |
/.$putCase consumeTypeParameterList(); $break ./ | |
/:$readableName TypeParameterList:/ | |
/:$compliance 1.5:/ | |
TypeParameter -> TypeParameterHeader | |
/:$compliance 1.5:/ | |
TypeParameter ::= TypeParameterHeader 'extends' ReferenceType | |
/.$putCase consumeTypeParameterWithExtends(); $break ./ | |
/:$compliance 1.5:/ | |
TypeParameter ::= TypeParameterHeader 'extends' ReferenceType AdditionalBoundList | |
/.$putCase consumeTypeParameterWithExtendsAndBounds(); $break ./ | |
/:$readableName TypeParameter:/ | |
/:$compliance 1.5:/ | |
AdditionalBoundList -> AdditionalBound | |
/:$compliance 1.5:/ | |
AdditionalBoundList ::= AdditionalBoundList AdditionalBound | |
/.$putCase consumeAdditionalBoundList(); $break ./ | |
/:$readableName AdditionalBoundList:/ | |
AdditionalBound ::= '&' ReferenceType | |
/.$putCase consumeAdditionalBound(); $break ./ | |
/:$readableName AdditionalBound:/ | |
/:$compliance 1.5:/ | |
TypeParameterList1 -> TypeParameter1 | |
/:$compliance 1.5:/ | |
TypeParameterList1 ::= TypeParameterList ',' TypeParameter1 | |
/.$putCase consumeTypeParameterList1(); $break ./ | |
/:$readableName TypeParameterList1:/ | |
/:$compliance 1.5:/ | |
TypeParameter1 ::= TypeParameterHeader '>' | |
/.$putCase consumeTypeParameter1(); $break ./ | |
/:$compliance 1.5:/ | |
TypeParameter1 ::= TypeParameterHeader 'extends' ReferenceType1 | |
/.$putCase consumeTypeParameter1WithExtends(); $break ./ | |
/:$compliance 1.5:/ | |
TypeParameter1 ::= TypeParameterHeader 'extends' ReferenceType AdditionalBoundList1 | |
/.$putCase consumeTypeParameter1WithExtendsAndBounds(); $break ./ | |
/:$readableName TypeParameter1:/ | |
/:$compliance 1.5:/ | |
AdditionalBoundList1 -> AdditionalBound1 | |
/:$compliance 1.5:/ | |
AdditionalBoundList1 ::= AdditionalBoundList AdditionalBound1 | |
/.$putCase consumeAdditionalBoundList1(); $break ./ | |
/:$readableName AdditionalBoundList1:/ | |
/:$compliance 1.5:/ | |
AdditionalBound1 ::= '&' ReferenceType1 | |
/.$putCase consumeAdditionalBound1(); $break ./ | |
/:$readableName AdditionalBound1:/ | |
/:$compliance 1.5:/ | |
------------------------------------------------- | |
-- Duplicate rules to remove ambiguity for (x) -- | |
------------------------------------------------- | |
PostfixExpression_NotName -> Primary | |
PostfixExpression_NotName -> PostIncrementExpression | |
PostfixExpression_NotName -> PostDecrementExpression | |
/:$readableName Expression:/ | |
UnaryExpression_NotName -> PreIncrementExpression | |
UnaryExpression_NotName -> PreDecrementExpression | |
UnaryExpression_NotName ::= '+' PushPosition UnaryExpression | |
/.$putCase consumeUnaryExpression(OperatorIds.PLUS); $break ./ | |
UnaryExpression_NotName ::= '-' PushPosition UnaryExpression | |
/.$putCase consumeUnaryExpression(OperatorIds.MINUS); $break ./ | |
UnaryExpression_NotName -> UnaryExpressionNotPlusMinus_NotName | |
/:$readableName Expression:/ | |
UnaryExpressionNotPlusMinus_NotName -> PostfixExpression_NotName | |
UnaryExpressionNotPlusMinus_NotName ::= '~' PushPosition UnaryExpression | |
/.$putCase consumeUnaryExpression(OperatorIds.TWIDDLE); $break ./ | |
UnaryExpressionNotPlusMinus_NotName ::= '!' PushPosition UnaryExpression | |
/.$putCase consumeUnaryExpression(OperatorIds.NOT); $break ./ | |
UnaryExpressionNotPlusMinus_NotName -> CastExpression | |
/:$readableName Expression:/ | |
MultiplicativeExpression_NotName -> UnaryExpression_NotName | |
MultiplicativeExpression_NotName ::= MultiplicativeExpression_NotName '*' UnaryExpression | |
/.$putCase consumeBinaryExpression(OperatorIds.MULTIPLY); $break ./ | |
MultiplicativeExpression_NotName ::= Name '*' UnaryExpression | |
/.$putCase consumeBinaryExpressionWithName(OperatorIds.MULTIPLY); $break ./ | |
MultiplicativeExpression_NotName ::= MultiplicativeExpression_NotName '/' UnaryExpression | |
/.$putCase consumeBinaryExpression(OperatorIds.DIVIDE); $break ./ | |
MultiplicativeExpression_NotName ::= Name '/' UnaryExpression | |
/.$putCase consumeBinaryExpressionWithName(OperatorIds.DIVIDE); $break ./ | |
MultiplicativeExpression_NotName ::= MultiplicativeExpression_NotName '%' UnaryExpression | |
/.$putCase consumeBinaryExpression(OperatorIds.REMAINDER); $break ./ | |
MultiplicativeExpression_NotName ::= Name '%' UnaryExpression | |
/.$putCase consumeBinaryExpressionWithName(OperatorIds.REMAINDER); $break ./ | |
/:$readableName Expression:/ | |
AdditiveExpression_NotName -> MultiplicativeExpression_NotName | |
AdditiveExpression_NotName ::= AdditiveExpression_NotName '+' MultiplicativeExpression | |
/.$putCase consumeBinaryExpression(OperatorIds.PLUS); $break ./ | |
AdditiveExpression_NotName ::= Name '+' MultiplicativeExpression | |
/.$putCase consumeBinaryExpressionWithName(OperatorIds.PLUS); $break ./ | |
AdditiveExpression_NotName ::= AdditiveExpression_NotName '-' MultiplicativeExpression | |
/.$putCase consumeBinaryExpression(OperatorIds.MINUS); $break ./ | |
AdditiveExpression_NotName ::= Name '-' MultiplicativeExpression | |
/.$putCase consumeBinaryExpressionWithName(OperatorIds.MINUS); $break ./ | |
/:$readableName Expression:/ | |
ShiftExpression_NotName -> AdditiveExpression_NotName | |
ShiftExpression_NotName ::= ShiftExpression_NotName '<<' AdditiveExpression | |
/.$putCase consumeBinaryExpression(OperatorIds.LEFT_SHIFT); $break ./ | |
ShiftExpression_NotName ::= Name '<<' AdditiveExpression | |
/.$putCase consumeBinaryExpressionWithName(OperatorIds.LEFT_SHIFT); $break ./ | |
ShiftExpression_NotName ::= ShiftExpression_NotName '>>' AdditiveExpression | |
/.$putCase consumeBinaryExpression(OperatorIds.RIGHT_SHIFT); $break ./ | |
ShiftExpression_NotName ::= Name '>>' AdditiveExpression | |
/.$putCase consumeBinaryExpressionWithName(OperatorIds.RIGHT_SHIFT); $break ./ | |
ShiftExpression_NotName ::= ShiftExpression_NotName '>>>' AdditiveExpression | |
/.$putCase consumeBinaryExpression(OperatorIds.UNSIGNED_RIGHT_SHIFT); $break ./ | |
ShiftExpression_NotName ::= Name '>>>' AdditiveExpression | |
/.$putCase consumeBinaryExpressionWithName(OperatorIds.UNSIGNED_RIGHT_SHIFT); $break ./ | |
/:$readableName Expression:/ | |
RelationalExpression_NotName -> ShiftExpression_NotName | |
RelationalExpression_NotName ::= ShiftExpression_NotName '<' ShiftExpression | |
/.$putCase consumeBinaryExpression(OperatorIds.LESS); $break ./ | |
RelationalExpression_NotName ::= Name '<' ShiftExpression | |
/.$putCase consumeBinaryExpressionWithName(OperatorIds.LESS); $break ./ | |
RelationalExpression_NotName ::= ShiftExpression_NotName '>' ShiftExpression | |
/.$putCase consumeBinaryExpression(OperatorIds.GREATER); $break ./ | |
RelationalExpression_NotName ::= Name '>' ShiftExpression | |
/.$putCase consumeBinaryExpressionWithName(OperatorIds.GREATER); $break ./ | |
RelationalExpression_NotName ::= RelationalExpression_NotName '<=' ShiftExpression | |
/.$putCase consumeBinaryExpression(OperatorIds.LESS_EQUAL); $break ./ | |
RelationalExpression_NotName ::= Name '<=' ShiftExpression | |
/.$putCase consumeBinaryExpressionWithName(OperatorIds.LESS_EQUAL); $break ./ | |
RelationalExpression_NotName ::= RelationalExpression_NotName '>=' ShiftExpression | |
/.$putCase consumeBinaryExpression(OperatorIds.GREATER_EQUAL); $break ./ | |
RelationalExpression_NotName ::= Name '>=' ShiftExpression | |
/.$putCase consumeBinaryExpressionWithName(OperatorIds.GREATER_EQUAL); $break ./ | |
/:$readableName Expression:/ | |
InstanceofExpression_NotName -> RelationalExpression_NotName | |
InstanceofExpression_NotName ::= Name 'instanceof' ReferenceType | |
/.$putCase consumeInstanceOfExpressionWithName(OperatorIds.INSTANCEOF); $break ./ | |
InstanceofExpression_NotName ::= InstanceofExpression_NotName 'instanceof' ReferenceType | |
/.$putCase consumeInstanceOfExpression(OperatorIds.INSTANCEOF); $break ./ | |
/:$readableName Expression:/ | |
EqualityExpression_NotName -> InstanceofExpression_NotName | |
EqualityExpression_NotName ::= EqualityExpression_NotName '==' InstanceofExpression | |
/.$putCase consumeEqualityExpression(OperatorIds.EQUAL_EQUAL); $break ./ | |
EqualityExpression_NotName ::= Name '==' InstanceofExpression | |
/.$putCase consumeEqualityExpressionWithName(OperatorIds.EQUAL_EQUAL); $break ./ | |
EqualityExpression_NotName ::= EqualityExpression_NotName '!=' InstanceofExpression | |
/.$putCase consumeEqualityExpression(OperatorIds.NOT_EQUAL); $break ./ | |
EqualityExpression_NotName ::= Name '!=' InstanceofExpression | |
/.$putCase consumeEqualityExpressionWithName(OperatorIds.NOT_EQUAL); $break ./ | |
/:$readableName Expression:/ | |
AndExpression_NotName -> EqualityExpression_NotName | |
AndExpression_NotName ::= AndExpression_NotName '&' EqualityExpression | |
/.$putCase consumeBinaryExpression(OperatorIds.AND); $break ./ | |
AndExpression_NotName ::= Name '&' EqualityExpression | |
/.$putCase consumeBinaryExpressionWithName(OperatorIds.AND); $break ./ | |
/:$readableName Expression:/ | |
ExclusiveOrExpression_NotName -> AndExpression_NotName | |
ExclusiveOrExpression_NotName ::= ExclusiveOrExpression_NotName '^' AndExpression | |
/.$putCase consumeBinaryExpression(OperatorIds.XOR); $break ./ | |
ExclusiveOrExpression_NotName ::= Name '^' AndExpression | |
/.$putCase consumeBinaryExpressionWithName(OperatorIds.XOR); $break ./ | |
/:$readableName Expression:/ | |
InclusiveOrExpression_NotName -> ExclusiveOrExpression_NotName | |
InclusiveOrExpression_NotName ::= InclusiveOrExpression_NotName '|' ExclusiveOrExpression | |
/.$putCase consumeBinaryExpression(OperatorIds.OR); $break ./ | |
InclusiveOrExpression_NotName ::= Name '|' ExclusiveOrExpression | |
/.$putCase consumeBinaryExpressionWithName(OperatorIds.OR); $break ./ | |
/:$readableName Expression:/ | |
ConditionalAndExpression_NotName -> InclusiveOrExpression_NotName | |
ConditionalAndExpression_NotName ::= ConditionalAndExpression_NotName '&&' InclusiveOrExpression | |
/.$putCase consumeBinaryExpression(OperatorIds.AND_AND); $break ./ | |
ConditionalAndExpression_NotName ::= Name '&&' InclusiveOrExpression | |
/.$putCase consumeBinaryExpressionWithName(OperatorIds.AND_AND); $break ./ | |
/:$readableName Expression:/ | |
ConditionalOrExpression_NotName -> ConditionalAndExpression_NotName | |
ConditionalOrExpression_NotName ::= ConditionalOrExpression_NotName '||' ConditionalAndExpression | |
/.$putCase consumeBinaryExpression(OperatorIds.OR_OR); $break ./ | |
ConditionalOrExpression_NotName ::= Name '||' ConditionalAndExpression | |
/.$putCase consumeBinaryExpressionWithName(OperatorIds.OR_OR); $break ./ | |
/:$readableName Expression:/ | |
ConditionalExpression_NotName -> ConditionalOrExpression_NotName | |
ConditionalExpression_NotName ::= ConditionalOrExpression_NotName '?' Expression ':' ConditionalExpression | |
/.$putCase consumeConditionalExpression(OperatorIds.QUESTIONCOLON) ; $break ./ | |
ConditionalExpression_NotName ::= Name '?' Expression ':' ConditionalExpression | |
/.$putCase consumeConditionalExpressionWithName(OperatorIds.QUESTIONCOLON) ; $break ./ | |
/:$readableName Expression:/ | |
AssignmentExpression_NotName -> ConditionalExpression_NotName | |
AssignmentExpression_NotName -> Assignment | |
/:$readableName Expression:/ | |
Expression_NotName -> AssignmentExpression_NotName | |
/:$readableName Expression:/ | |
----------------------------------------------- | |
-- 1.5 features : end of generics | |
----------------------------------------------- | |
----------------------------------------------- | |
-- 1.5 features : annotation - Metadata feature jsr175 | |
----------------------------------------------- | |
AnnotationTypeDeclarationHeaderName ::= Modifiers '@' PushRealModifiers interface Identifier | |
/.$putCase consumeAnnotationTypeDeclarationHeaderName() ; $break ./ | |
/:$compliance 1.5:/ | |
AnnotationTypeDeclarationHeaderName ::= '@' PushModifiersForHeader interface Identifier | |
/.$putCase consumeAnnotationTypeDeclarationHeaderName() ; $break ./ | |
/:$readableName AnnotationTypeDeclarationHeaderName:/ | |
/:$compliance 1.5:/ | |
AnnotationTypeDeclarationHeader ::= AnnotationTypeDeclarationHeaderName ClassHeaderExtendsopt ClassHeaderImplementsopt | |
/.$putCase consumeAnnotationTypeDeclarationHeader() ; $break ./ | |
/:$readableName AnnotationTypeDeclarationHeader:/ | |
/:$compliance 1.5:/ | |
AnnotationTypeDeclaration ::= AnnotationTypeDeclarationHeader AnnotationTypeBody | |
/.$putCase consumeAnnotationTypeDeclaration() ; $break ./ | |
/:$readableName AnnotationTypeDeclaration:/ | |
/:$compliance 1.5:/ | |
AnnotationTypeBody ::= '{' AnnotationTypeMemberDeclarationsopt '}' | |
/:$readableName AnnotationTypeBody:/ | |
/:$compliance 1.5:/ | |
AnnotationTypeMemberDeclarationsopt ::= $empty | |
/.$putCase consumeEmptyAnnotationTypeMemberDeclarationsopt() ; $break ./ | |
/:$compliance 1.5:/ | |
AnnotationTypeMemberDeclarationsopt -> AnnotationTypeMemberDeclarations | |
/:$readableName AnnotationTypeMemberDeclarations:/ | |
/:$compliance 1.5:/ | |
AnnotationTypeMemberDeclarations -> AnnotationTypeMemberDeclaration | |
/:$compliance 1.5:/ | |
AnnotationTypeMemberDeclarations ::= AnnotationTypeMemberDeclarations AnnotationTypeMemberDeclaration | |
/.$putCase consumeAnnotationTypeMemberDeclarations() ; $break ./ | |
/:$readableName AnnotationTypeMemberDeclarations:/ | |
/:$compliance 1.5:/ | |
AnnotationMethodHeaderName ::= Modifiersopt TypeParameters Type 'Identifier' '(' | |
/.$putCase consumeMethodHeaderNameWithTypeParameters(true); $break ./ | |
AnnotationMethodHeaderName ::= Modifiersopt Type 'Identifier' '(' | |
/.$putCase consumeMethodHeaderName(true); $break ./ | |
/:$readableName MethodHeaderName:/ | |
AnnotationMethodHeaderDefaultValueopt ::= $empty | |
/.$putCase consumeEmptyMethodHeaderDefaultValue() ; $break ./ | |
/:$readableName MethodHeaderDefaultValue:/ | |
/:$compliance 1.5:/ | |
AnnotationMethodHeaderDefaultValueopt ::= DefaultValue | |
/.$putCase consumeMethodHeaderDefaultValue(); $break ./ | |
/:$readableName MethodHeaderDefaultValue:/ | |
/:$compliance 1.5:/ | |
AnnotationMethodHeader ::= AnnotationMethodHeaderName FormalParameterListopt MethodHeaderRightParen MethodHeaderExtendedDims AnnotationMethodHeaderDefaultValueopt | |
/.$putCase consumeMethodHeader(); $break ./ | |
/:$readableName AnnotationMethodHeader:/ | |
/:$compliance 1.5:/ | |
AnnotationTypeMemberDeclaration ::= AnnotationMethodHeader ';' | |
/.$putCase consumeAnnotationTypeMemberDeclaration() ; $break ./ | |
/:$compliance 1.5:/ | |
AnnotationTypeMemberDeclaration -> ConstantDeclaration | |
/:$compliance 1.5:/ | |
AnnotationTypeMemberDeclaration -> ConstructorDeclaration | |
/:$compliance 1.5:/ | |
AnnotationTypeMemberDeclaration -> TypeDeclaration | |
/:$readableName AnnotationTypeMemberDeclaration:/ | |
/:$compliance 1.5:/ | |
DefaultValue ::= 'default' MemberValue | |
/:$readableName DefaultValue:/ | |
/:$compliance 1.5:/ | |
Annotation -> NormalAnnotation | |
/:$compliance 1.5:/ | |
Annotation -> MarkerAnnotation | |
/:$compliance 1.5:/ | |
Annotation -> SingleMemberAnnotation | |
/:$readableName Annotation:/ | |
/:$compliance 1.5:/ | |
AnnotationName ::= '@' Name | |
/.$putCase consumeAnnotationName() ; $break ./ | |
/:$readableName AnnotationName:/ | |
/:$compliance 1.5:/ | |
NormalAnnotation ::= AnnotationName '(' MemberValuePairsopt ')' | |
/.$putCase consumeNormalAnnotation() ; $break ./ | |
/:$readableName NormalAnnotation:/ | |
/:$compliance 1.5:/ | |
MemberValuePairsopt ::= $empty | |
/.$putCase consumeEmptyMemberValuePairsopt() ; $break ./ | |
/:$compliance 1.5:/ | |
MemberValuePairsopt -> MemberValuePairs | |
/:$readableName MemberValuePairsopt:/ | |
/:$compliance 1.5:/ | |
MemberValuePairs -> MemberValuePair | |
/:$compliance 1.5:/ | |
MemberValuePairs ::= MemberValuePairs ',' MemberValuePair | |
/.$putCase consumeMemberValuePairs() ; $break ./ | |
/:$readableName MemberValuePairs:/ | |
/:$compliance 1.5:/ | |
MemberValuePair ::= SimpleName '=' EnterMemberValue MemberValue ExitMemberValue | |
/.$putCase consumeMemberValuePair() ; $break ./ | |
/:$readableName MemberValuePair:/ | |
/:$compliance 1.5:/ | |
EnterMemberValue ::= $empty | |
/.$putCase consumeEnterMemberValue() ; $break ./ | |
/:$readableName EnterMemberValue:/ | |
/:$compliance 1.5:/ | |
ExitMemberValue ::= $empty | |
/.$putCase consumeExitMemberValue() ; $break ./ | |
/:$readableName ExitMemberValue:/ | |
/:$compliance 1.5:/ | |
MemberValue -> ConditionalExpression_NotName | |
/:$compliance 1.5:/ | |
MemberValue ::= Name | |
/.$putCase consumeMemberValueAsName() ; $break ./ | |
/:$compliance 1.5:/ | |
MemberValue -> Annotation | |
/:$compliance 1.5:/ | |
MemberValue -> MemberValueArrayInitializer | |
/:$readableName MemberValue:/ | |
/:$compliance 1.5:/ | |
MemberValueArrayInitializer ::= '{' PushLeftBrace MemberValues ',' '}' | |
/.$putCase consumeMemberValueArrayInitializer() ; $break ./ | |
/:$compliance 1.5:/ | |
MemberValueArrayInitializer ::= '{' PushLeftBrace MemberValues '}' | |
/.$putCase consumeMemberValueArrayInitializer() ; $break ./ | |
/:$compliance 1.5:/ | |
MemberValueArrayInitializer ::= '{' PushLeftBrace ',' '}' | |
/.$putCase consumeEmptyMemberValueArrayInitializer() ; $break ./ | |
/:$compliance 1.5:/ | |
MemberValueArrayInitializer ::= '{' PushLeftBrace '}' | |
/.$putCase consumeEmptyMemberValueArrayInitializer() ; $break ./ | |
/:$readableName MemberValueArrayInitializer:/ | |
/:$compliance 1.5:/ | |
MemberValues -> MemberValue | |
/:$compliance 1.5:/ | |
MemberValues ::= MemberValues ',' MemberValue | |
/.$putCase consumeMemberValues() ; $break ./ | |
/:$readableName MemberValues:/ | |
/:$compliance 1.5:/ | |
MarkerAnnotation ::= AnnotationName | |
/.$putCase consumeMarkerAnnotation() ; $break ./ | |
/:$readableName MarkerAnnotation:/ | |
/:$compliance 1.5:/ | |
SingleMemberAnnotation ::= AnnotationName '(' MemberValue ')' | |
/.$putCase consumeSingleMemberAnnotation() ; $break ./ | |
/:$readableName SingleMemberAnnotation:/ | |
/:$compliance 1.5:/ | |
-------------------------------------- | |
-- 1.5 features : end of annotation -- | |
-------------------------------------- | |
----------------------------------- | |
-- 1.5 features : recovery rules -- | |
----------------------------------- | |
RecoveryMethodHeaderName ::= Modifiersopt TypeParameters Type 'Identifier' '(' | |
/.$putCase consumeRecoveryMethodHeaderNameWithTypeParameters(); $break ./ | |
/:$compliance 1.5:/ | |
RecoveryMethodHeaderName ::= Modifiersopt Type 'Identifier' '(' | |
/.$putCase consumeRecoveryMethodHeaderName(); $break ./ | |
/:$readableName MethodHeaderName:/ | |
RecoveryMethodHeader ::= RecoveryMethodHeaderName FormalParameterListopt MethodHeaderRightParen MethodHeaderExtendedDims AnnotationMethodHeaderDefaultValueopt | |
/.$putCase consumeMethodHeader(); $break ./ | |
RecoveryMethodHeader ::= RecoveryMethodHeaderName FormalParameterListopt MethodHeaderRightParen MethodHeaderExtendedDims MethodHeaderThrowsClause | |
/.$putCase consumeMethodHeader(); $break ./ | |
/:$readableName MethodHeader:/ | |
----------------------------------- | |
-- 1.5 features : recovery rules -- | |
----------------------------------- | |
/. } | |
}./ | |
$names | |
PLUS_PLUS ::= '++' | |
MINUS_MINUS ::= '--' | |
EQUAL_EQUAL ::= '==' | |
LESS_EQUAL ::= '<=' | |
GREATER_EQUAL ::= '>=' | |
NOT_EQUAL ::= '!=' | |
LEFT_SHIFT ::= '<<' | |
RIGHT_SHIFT ::= '>>' | |
UNSIGNED_RIGHT_SHIFT ::= '>>>' | |
PLUS_EQUAL ::= '+=' | |
MINUS_EQUAL ::= '-=' | |
MULTIPLY_EQUAL ::= '*=' | |
DIVIDE_EQUAL ::= '/=' | |
AND_EQUAL ::= '&=' | |
OR_EQUAL ::= '|=' | |
XOR_EQUAL ::= '^=' | |
REMAINDER_EQUAL ::= '%=' | |
LEFT_SHIFT_EQUAL ::= '<<=' | |
RIGHT_SHIFT_EQUAL ::= '>>=' | |
UNSIGNED_RIGHT_SHIFT_EQUAL ::= '>>>=' | |
OR_OR ::= '||' | |
AND_AND ::= '&&' | |
PLUS ::= '+' | |
MINUS ::= '-' | |
NOT ::= '!' | |
REMAINDER ::= '%' | |
XOR ::= '^' | |
AND ::= '&' | |
MULTIPLY ::= '*' | |
OR ::= '|' | |
TWIDDLE ::= '~' | |
DIVIDE ::= '/' | |
GREATER ::= '>' | |
LESS ::= '<' | |
LPAREN ::= '(' | |
RPAREN ::= ')' | |
LBRACE ::= '{' | |
RBRACE ::= '}' | |
LBRACKET ::= '[' | |
RBRACKET ::= ']' | |
SEMICOLON ::= ';' | |
QUESTION ::= '?' | |
COLON ::= ':' | |
COMMA ::= ',' | |
DOT ::= '.' | |
EQUAL ::= '=' | |
AT ::= '@' | |
ELLIPSIS ::= '...' | |
$end | |
-- need a carriage return after the $end |