| --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./ |
| $recovery_template |
| /.3#$rule_number#./ |
| $no_statements_recovery |
| /.4#$rule_number# 1./ |
| -- 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 |
| |
| -- {ObjectTeams: keywords |
| as base callin playedBy precedence readonly team tsuper when with within |
| |
| -- The following symbols are recognized as keywords only in specific contexts: |
| -- After "<-": |
| replace after before |
| -- After "->": |
| get set |
| |
| -- Markus Witte} |
| |
| 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 |
| ARROW |
| COLON_COLON |
| BeginLambda |
| BeginTypeArguments |
| ElidedSemicolonAndRightBrace |
| |
| -- {ObjectTeams |
| BINDIN |
| CALLOUT_OVERRIDE |
| -- Markus Witte} |
| -- BodyMarker |
| |
| $Alias |
| |
| '::' ::= COLON_COLON |
| '->' ::= ARROW |
| '++' ::= 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 |
| |
| -- {ObjectTeams |
| '<-' ::= BINDIN |
| '=>' ::= CALLOUT_OVERRIDE |
| -- Markus Witte} |
| |
| $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 |
| Goal ::= '>>>' Header1 RecoveryExitHeader |
| Goal ::= '!' Header2 RecoveryExitHeader |
| Goal ::= '*' BlockStatements |
| Goal ::= '*' CatchHeader |
| -- JDOM |
| Goal ::= '&&' FieldDeclaration |
| Goal ::= '||' ImportDeclaration |
| Goal ::= '?' PackageDeclaration |
| Goal ::= '+' TypeDeclaration |
| Goal ::= '/' GenericMethodDeclaration |
| Goal ::= '&' ClassBodyDeclarations |
| -- code snippet |
| Goal ::= '%' Expression |
| Goal ::= '%' ArrayInitializer |
| -- completion parser |
| Goal ::= '~' BlockStatementsopt |
| -- source type converter |
| Goal ::= '||' MemberValue |
| -- syntax diagnosis |
| Goal ::= '?' AnnotationTypeMemberDeclaration |
| --{ObjectTeams new goals: |
| Goal ::= ':' CallinParameterMappings |
| Goal ::= ';' CalloutParameterMappings |
| Goal ::= '^' ParameterMapping |
| Goal ::= '<' MethodSpecShort |
| Goal ::= '>' MethodSpecLong |
| -- SH} |
| /:$readableName Goal:/ |
| |
| RecoveryExitHeader ::= $empty |
| RecoveryExitHeader ::= '...' |
| /:$readableName RecoveryExitHeader:/ |
| |
| -- {ObjectTeams |
| -- insert new Goals for Delta-Compiling |
| -- for Callin/Callout-Binding |
| -- Markus Witte} |
| |
| 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 is a wrapper that automatically allows for jsr308 style |
| -- annotations to prefix a (Java5/6) Type. If type annotations |
| -- are illegal in a certain place, use TypeInternal instead. |
| -- If type annotations are legal, but so are java5/6 style |
| -- declaration annotations, use Type0 instead. |
| |
| Type ::= TypeInternal |
| -- consumeUnannotatedType inserts 0 at the suitable place in the type |
| -- annotation stacks, so that the TOS(typeAnnotationsLengthStack) is the right |
| -- length of the type annotations 0 or otherwise. |
| /.$putCase consumeUnannotatedType(); $break ./ |
| Type ::= TypeAnnotations TypeInternal |
| /:$compliance 1.8:/ |
| /:$readableName Type:/ |
| |
| -- Type0 is to be used in places where type annotations are legal |
| -- but are not consumed as TypeAnnotations, but as modifiers. This |
| -- is because from the parser's point of view there are places where |
| -- java5/6 style declarations annotations can occur in the same place |
| -- and it is too early to tell which is which. |
| Type0 ::= TypeInternal |
| -- consumeUnannotatedType inserts 0 at the suitable place in the type |
| -- annotation stacks, so that the TOS(typeAnnotationsLengthStack) is the right |
| -- length of the type annotations 0 or otherwise. |
| /.$putCase consumeUnannotatedType(); $break ./ |
| /:$readableName Type:/ |
| |
| -- TypeInternal is the Java5/6 Type |
| TypeInternal ::= PrimitiveType |
| /.$putCase consumePrimitiveType(); $break ./ |
| TypeInternal -> ReferenceType0 |
| /:$readableName Type:/ |
| -- {ObjectTeams |
| Type -> LiftingType |
| Type -> ArrayLiftingType |
| Type -> InvalidDeclaredArrayLifting |
| -- Markus Witte} |
| /:$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:/ |
| |
| ---------------------------- JSR308------------------------------------------- |
| -- ReferenceType has been wrapped now, so that it can be used by itself without |
| -- having to spell out the rule once with Modifiers & once without. |
| -- If type annotations are not legal prefixes to ReferenceType at some point, use |
| -- ReferenceType0 instead. Otherwise reject the annotations in the parser. |
| |
| ReferenceType ::= ReferenceType0 |
| -- consumeUnannotatedType inserts 0 at the suitable place in the type |
| -- annotation stacks, so that the TOS(typeAnnotationsLengthStack) is the right |
| -- length of the type annotations 0 or otherwise. |
| /.$putCase consumeUnannotatedType(); $break ./ |
| ReferenceType ::= Modifiers ReferenceType0 |
| /.$putCase consumeAnnotatedType(); $break ./ |
| /:$compliance 1.8:/ |
| /:$readableName ReferenceType:/ |
| |
| ReferenceType0 ::= ClassOrInterfaceType0 |
| /.$putCase consumeReferenceType(); $break ./ |
| ReferenceType0 -> ArrayType |
| /:$readableName ReferenceType:/ |
| |
| Annotationsopt ::= $empty |
| /.$putCase consumeZeroTypeAnnotations(true); $break ./ |
| Annotationsopt -> TypeAnnotations |
| /:$compliance 1.8:/ |
| /:$readableName Annotationsopt:/ |
| |
| -- ClassOrInterfaceType has now been wrapped so that it automatically includes |
| -- JSR308 style optional annotations. Use ClassOrInterfaceType0 if annotations |
| -- are illegal in some place - otherwise reject the annotations in the parser. |
| ClassOrInterfaceType ::= Annotationsopt ClassOrInterfaceType0 |
| /:$readableName Type:/ |
| |
| ClassOrInterfaceType0 -> ClassOrInterface0 |
| ClassOrInterfaceType0 -> GenericType |
| /:$readableName Type:/ |
| ---------------------------- JSR308------------------------------------------- |
| |
| -- ClassOrInterface has been wrapped now so that it ALWAYS PUSHES |
| -- A 0 IN THE TYPE ANNOTATIONS LENGTH STACK. If this behavior is |
| -- not desirable, then (a) use ClassOrInterface0 if possible or (b) |
| -- if that is not possible due to conflicts, then this 0 will have |
| -- to be popped suitably when erroneous/extraneous. See the use of |
| -- the production PopZeroTypeAnnotations for examples. |
| |
| ClassOrInterface ::= ClassOrInterface0 |
| /.$putCase consumeZeroTypeAnnotations(true); $break ./ |
| /:$readableName Type:/ |
| |
| ClassOrInterface0 ::= Name |
| /.$putCase consumeClassOrInterfaceName(); $break ./ |
| ClassOrInterface0 ::= GenericTypeDotName |
| /:$readableName Type:/ |
| |
| PopZeroTypeAnnotations ::= $empty |
| /.$putCase consumeZeroTypeAnnotations(false); $break ./ |
| /:$readableName PopZeroTypeAnnotations:/ |
| |
| GenericType ::= ClassOrInterface TypeArguments PopZeroTypeAnnotations |
| /.$putCase consumeGenericType(); $break ./ |
| /:$compliance 1.5:/ |
| /:$readableName GenericType:/ |
| |
| GenericTypeDotName ::= GenericType '.' Name |
| /.$putCase consumeClassOrInterface(); $break ./ |
| /:$readableName GenericTypeDotName:/ |
| |
| GenericType ::= ClassOrInterface '<' '>' |
| /.$putCase consumeGenericTypeWithDiamond(); $break ./ |
| /:$readableName GenericType:/ |
| /:$compliance 1.7:/ |
| |
| -- {ObjectTeams: "Base as Role" types: |
| |
| LiftingType ::= ClassType 'as' ClassType |
| /.$putCase consumeLiftingType(); $break ./ |
| /:$readableName LiftingType:/ |
| |
| ArrayLiftingType ::= ArrayType 'as' ArrayType |
| /.$putCase consumeLiftingTypeArray(); $break ./ |
| /:$readableName ArrayLiftingType:/ |
| |
| -- handle invalid array liftings: "Type as Array" and "Array as Type" |
| InvalidDeclaredArrayLifting ::= ClassType 'as' ArrayType |
| /.$putCase consumeLiftingTypeArrayInvalid(); $break ./ |
| /:$readableName InvalidDeclaredArrayLifting:/ |
| |
| InvalidDeclaredArrayLifting ::= ArrayType 'as' ClassType |
| /.$putCase consumeLiftingTypeArrayInvalid(); $break ./ |
| /:$readableName InvalidDeclaredArrayLifting:/ |
| -- SH} |
| |
| -- {ObjectTeams: "base.R" types: |
| |
| BaseAnchoredType ::= 'base' '.' SimpleName |
| /.$putCase consumeBaseAnchoredType(); $break ./ |
| /:$readableName QualifiedName:/ |
| |
| -- Connecting BaseAnchoredType to other rules (2 variants): |
| -- 1.) connect via Type->ReferenceType->ClassOrInterfaceType |
| -- as well as via ClassType->ClassOrInterfaceType |
| ClassOrInterfaceType -> BaseAnchoredType |
| /:$readableName BaseAnchoredType:/ |
| |
| -- 2.) via ReferenceType we may add dimensions: |
| ReferenceType -> BaseAnchoredType Dims |
| /:$readableName ArrayOfBaseAnchoredType:/ |
| -- SH} |
| |
| -- |
| -- These rules have been rewritten to avoid some conflicts introduced |
| -- by adding the 1.1 features |
| -- |
| -- ArrayType ::= PrimitiveType '[' ']' |
| -- ArrayType ::= Name '[' ']' |
| -- ArrayType ::= ArrayType '[' ']' |
| -- |
| |
| ArrayTypeWithTypeArgumentsName ::= GenericTypeDotName |
| /:$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:/ |
| /:$recovery_template Identifier:/ |
| |
| 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 |
| --{ObjectTeams: |
| Header -> RecoveryBindingHeader |
| Header -> PrecedenceDeclaration |
| -- SH} |
| /:$readableName Header:/ |
| |
| Header1 -> Header |
| Header1 -> ConstructorHeader |
| /:$readableName Header1:/ |
| |
| Header2 -> Header |
| Header2 -> EnumConstantHeader RecoveryEnumConstantSeparatoropt |
| /:$readableName Header2:/ |
| |
| RecoveryEnumConstantSeparatoropt ::= $empty |
| RecoveryEnumConstantSeparatoropt ::= ',' |
| RecoveryEnumConstantSeparatoropt ::= ';' |
| /:$readableName RecoveryEnumConstantSeparatoropt:/ |
| |
| CatchHeader ::= 'catch' '(' CatchFormalParameter ')' '{' |
| /.$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 |
| --{ObjectTeams: base import: |
| ImportDeclaration -> SingleBaseImportDeclaration |
| -- SH} |
| ImportDeclaration -> StaticImportOnDemandDeclaration |
| /:$readableName ImportDeclaration:/ |
| |
| SingleTypeImportDeclaration ::= SingleTypeImportDeclarationName ';' |
| /.$putCase consumeImportDeclaration(); $break ./ |
| /:$readableName SingleTypeImportDeclaration:/ |
| |
| -- {ObjectTeams: special case: allow 'team' in imported package/type name: |
| -- orig: SingleTypeImportDeclarationName ::= 'import' Name |
| SingleTypeImportDeclarationName ::= 'import' ImportName |
| /.$putCase consumeSingleTypeImportDeclarationName(); $break ./ |
| /:$readableName SingleTypeImportDeclarationName:/ |
| |
| ImportName -> Name |
| ImportName ::= Name '.' 'team' '.' Name |
| /.$putCase consumeNameContainingTeam(); $break ./ |
| /:$readableName Name:/ |
| -- SH} |
| |
| 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 ./ |
| -- {ObjectTeams |
| Modifier -> 'team' |
| Modifier -> 'callin' |
| Modifier -> 'readonly' |
| -- Markus Witte} |
| /:$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:/ |
| |
| --{ObjectTeams: playedBy & guard predicate support: |
| -- orig: ClassHeader ::= ClassHeaderName ClassHeaderExtendsopt ClassHeaderImplementsopt |
| ClassHeader ::= ClassHeaderName ClassHeaderExtendsopt ClassHeaderImplementsopt ClassHeaderPlayedByopt Predicateopt |
| -- MW+SH} |
| /.$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:/ |
| |
| -- {ObjectTeams: ==== playedBy ==== |
| ClassHeaderPlayedByopt ::= $empty |
| ClassHeaderPlayedByopt -> ClassHeaderPlayedBy |
| /:$readableName ClassHeaderPlayedBy:/ |
| |
| ClassHeaderPlayedBy ::= 'playedBy' ClassType |
| /.$putCase consumeClassHeaderPlayedBy(); $break ./ |
| /:$readableName ClassHeaderPlayedBy:/ |
| |
| -- Markus Witte} |
| |
| --{ObjectTeams: ==== predicates ==== |
| Predicateopt ::= $empty |
| Predicateopt -> Predicate |
| |
| Predicate -> RolePredicate |
| Predicate -> BasePredicate |
| |
| RolePredicate ::= PredicateHeader PredicateBody |
| /:$readableName Predicate:/ |
| |
| PredicateHeader ::= 'when' |
| /.$putCase consumePredicate(false); $break ./ |
| /:$readableName PredicateHeader:/ |
| |
| BasePredicate ::= BasePredicateHeader ForceBaseIsIdentifier PredicateBody RestoreBaseKeyword |
| /:$readableName Predicate:/ |
| |
| BasePredicateHeader ::= 'base' 'when' |
| /.$putCase consumePredicate(true); $break ./ |
| /:$readableName PredicateHeader:/ |
| |
| PredicateBody ::= '(' ForceNoDiet Expression RestoreDiet ')' |
| /.$putCase consumePredicateExpression(); $break ./ |
| /:$readableName PredicateBody:/ |
| |
| PredicateBody ::= '(' ')' |
| /.$putCase consumePredicateMissingExpression(); $break ./ |
| |
| |
| ForceBaseIsIdentifier ::= $empty |
| /.$putCase consumeForceBaseIsIdentifier(); $break ./ |
| /:$readableName ForceBaseIsIdentifier:/ |
| |
| RestoreBaseKeyword ::= $empty |
| /.$putCase consumeRestoreBaseKeyword(); $break ./ |
| /:$readableName RestoreBaseKeyword:/ |
| -- SH} |
| |
| InterfaceTypeList -> InterfaceType |
| InterfaceTypeList ::= InterfaceTypeList ',' InterfaceType |
| /.$putCase consumeInterfaceTypeList(); $break ./ |
| /:$readableName InterfaceTypeList:/ |
| |
| InterfaceType ::= ClassOrInterfaceType |
| /.$putCase consumeInterfaceType(); $break ./ |
| /:$readableName InterfaceType:/ |
| |
| ClassBody ::= '{' ClassBodyDeclarationsopt '}' |
| /:$readableName ClassBody:/ |
| /:$no_statements_recovery:/ |
| |
| ClassBodyDeclarations ::= ClassBodyDeclaration |
| ClassBodyDeclarations ::= ClassBodyDeclarations ClassBodyDeclaration |
| /.$putCase consumeClassBodyDeclarations(); $break ./ |
| /:$readableName ClassBodyDeclarations:/ |
| |
| ClassBodyDeclaration -> ClassMemberDeclaration |
| ClassBodyDeclaration -> StaticInitializer |
| ClassBodyDeclaration -> ConstructorDeclaration |
| --1.1 feature |
| ClassBodyDeclaration ::= Diet NestedMethod CreateInitializer Block |
| /.$putCase consumeClassBodyDeclaration(); $break ./ |
| /:$readableName ClassBodyDeclaration:/ |
| |
| Diet ::= $empty |
| /.$putCase consumeDiet(); $break./ |
| /:$readableName Diet:/ |
| |
| Initializer ::= Diet NestedMethod CreateInitializer Block |
| /.$putCase consumeClassBodyDeclaration(); $break ./ |
| /:$readableName Initializer:/ |
| |
| CreateInitializer ::= $empty |
| /.$putCase consumeCreateInitializer(); $break./ |
| /:$readableName CreateInitializer:/ |
| |
| ClassMemberDeclaration -> FieldDeclaration |
| ClassMemberDeclaration -> MethodDeclaration |
| |
| -- {ObjectTeams |
| ClassMemberDeclaration -> BindingDeclaration |
| ClassMemberDeclaration -> PrecedenceDeclaration |
| -- Markus Witte} |
| |
| --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 consumeEmptyTypeDeclaration(); $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 Type0 VariableDeclarators ';' |
| /.$putCase consumeFieldDeclaration(); $break ./ |
| /:$readableName FieldDeclaration:/ |
| |
| VariableDeclarators -> VariableDeclarator |
| VariableDeclarators ::= VariableDeclarators ',' VariableDeclarator |
| /.$putCase consumeVariableDeclarators(); $break ./ |
| /:$readableName VariableDeclarators:/ |
| /:$recovery_template Identifier:/ |
| |
| VariableDeclarator ::= VariableDeclaratorId EnterVariable ExitVariableWithoutInitialization |
| VariableDeclarator ::= VariableDeclaratorId EnterVariable '=' ForceNoDiet VariableInitializer RestoreDiet ExitVariableWithInitialization |
| /:$readableName VariableDeclarator:/ |
| /:$recovery_template Identifier:/ |
| |
| 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:/ |
| |
| VariableDeclaratorIdOrThis ::= 'this' |
| /.$putCase consumeExplicitThisParameter(false); $break ./ |
| /:$compliance 1.8:/ |
| VariableDeclaratorIdOrThis ::= Name '.' 'this' |
| /.$putCase consumeExplicitThisParameter(true); $break ./ |
| /:$compliance 1.8:/ |
| VariableDeclaratorIdOrThis ::= VariableDeclaratorId |
| /.$putCase consumeVariableDeclaratorIdParameter(); $break ./ |
| /:$readableName VariableDeclaratorId:/ |
| |
| VariableDeclaratorId ::= 'Identifier' Dimsopt |
| /:$readableName VariableDeclaratorId:/ |
| /:$recovery_template Identifier:/ |
| |
| VariableInitializer -> Expression |
| VariableInitializer -> ArrayInitializer |
| /:$readableName VariableInitializer:/ |
| /:$recovery_template Identifier:/ |
| |
| --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 Type0 'Identifier' '(' |
| /.$putCase consumeMethodHeaderName(false); $break ./ |
| /:$readableName MethodHeaderName:/ |
| |
| MethodHeaderRightParen ::= ')' |
| /.$putCase consumeMethodHeaderRightParen(); $break ./ |
| /:$readableName ):/ |
| /:$recovery_template ):/ |
| |
| 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:/ |
| |
| PotentialNameArray -> $empty |
| /.$putCase consumePotentialNameArrayType(); $break ./ |
| /:$readableName PotentialNameArray:/ |
| |
| --1.1 feature |
| --FormalParameter ::= Modifiersopt Type VariableDeclaratorId |
| --FormalParameter ::= Modifiersopt Type '...' VariableDeclaratorId |
| --The above rules have been rewritten by inlinng the type subgrammar |
| --to avoid the conflicts resulting from jsr308 changes. |
| FormalParameter ::= Modifiersopt PrimitiveType DimsoptAnnotsopt VariableDeclaratorIdOrThis |
| /.$putCase consumeFormalParameter(false); $break ./ |
| FormalParameter ::= Modifiersopt PrimitiveType DimsoptAnnotsopt '...' VariableDeclaratorIdOrThis |
| /.$putCase consumeFormalParameter(true); $break ./ |
| /:$compliance 1.5:/ |
| FormalParameter ::= Modifiersopt Name DimsoptAnnotsopt PotentialNameArray VariableDeclaratorIdOrThis |
| /.$putCase consumeFormalParameter(false); $break ./ |
| FormalParameter ::= Modifiersopt Name DimsoptAnnotsopt PotentialNameArray '...' VariableDeclaratorIdOrThis |
| /.$putCase consumeFormalParameter(true); $break ./ |
| /:$compliance 1.5:/ |
| FormalParameter ::= Modifiersopt GenericType DimsoptAnnotsopt VariableDeclaratorIdOrThis |
| /.$putCase consumeFormalParameter(false); $break ./ |
| FormalParameter ::= Modifiersopt GenericType DimsoptAnnotsopt '...' VariableDeclaratorIdOrThis |
| /.$putCase consumeFormalParameter(true); $break ./ |
| /:$compliance 1.5:/ |
| FormalParameter ::= Modifiersopt GenericTypeDotName DimsoptAnnotsopt VariableDeclaratorIdOrThis |
| /.$putCase consumeFormalParameter(false); $break ./ |
| FormalParameter ::= Modifiersopt GenericTypeDotName DimsoptAnnotsopt '...' VariableDeclaratorIdOrThis |
| /.$putCase consumeFormalParameter(true); $break ./ |
| /:$readableName FormalParameter:/ |
| /:$compliance 1.5:/ |
| /:$recovery_template Identifier Identifier:/ |
| |
| CatchFormalParameter ::= Modifiersopt CatchType VariableDeclaratorId |
| /.$putCase consumeCatchFormalParameter(); $break ./ |
| /:$readableName FormalParameter:/ |
| /:$recovery_template Identifier Identifier:/ |
| |
| CatchType ::= UnionType |
| /.$putCase consumeCatchType(); $break ./ |
| /:$readableName CatchType:/ |
| |
| UnionType ::= TypeInternal |
| /.$putCase consumeUnionTypeAsClassType(); $break ./ |
| UnionType ::= UnionType '|' Type |
| /.$putCase consumeUnionType(); $break ./ |
| /:$readableName UnionType:/ |
| /:$compliance 1.7:/ |
| |
| ClassTypeList -> ClassTypeElt |
| ClassTypeList ::= ClassTypeList ',' ClassTypeElt |
| /.$putCase consumeClassTypeList(); $break ./ |
| /:$readableName ClassTypeList:/ |
| |
| ClassTypeElt ::= ClassType |
| /.$putCase consumeClassTypeElt(); $break ./ |
| /:$readableName ClassType:/ |
| |
| -- {ObjectTeams: added Predicateopt |
| MethodBody ::= Predicateopt NestedMethod '{' BlockStatementsopt '}' |
| /.$putCase consumeMethodBody(); $break ./ |
| /:$readableName MethodBody:/ |
| /:$no_statements_recovery:/ |
| -- SH} |
| |
| NestedMethod ::= $empty |
| /.$putCase consumeNestedMethod(); $break ./ |
| /:$readableName NestedMethod:/ |
| |
| -- {ObjectTeams ========== METHOD BINDINGS ========== |
| BindingDeclaration -> CalloutBinding |
| BindingDeclaration -> CallinBinding |
| BindingDeclaration -> InvalidCallinBinding |
| /:$readableName BindingDeclaration:/ |
| |
| -- ==== CALLOUT: ==== |
| |
| -- LONG: |
| CalloutBinding ::= CalloutHeaderLong CalloutParameterMappingsopt |
| /.$putCase consumeCalloutBindingLong(); $break ./ |
| /:$readableName CalloutBinding:/ |
| |
| CalloutHeaderLong ::= CalloutBindingLeftLong MethodSpecLong |
| /.$putCase consumeCalloutHeader(); $break ./ |
| /:$readableName CalloutHeader:/ |
| |
| CalloutHeaderLong ::= CalloutBindingLeftLong CalloutFieldSpecLong |
| /.$putCase consumeCalloutHeader(); $break ./ |
| /:$readableName CalloutHeader:/ |
| |
| CalloutBindingLeftLong ::= MethodSpecLong CalloutKind |
| /.$putCase consumeCalloutBindingLeft(true); $break ./ |
| /:$readableName CalloutBindingLeft:/ |
| |
| |
| -- SHORT: |
| -- Note(SH): Modifiersopt is needed to make grammar LALR(1), in real life modifiers must be empty |
| -- Note(SH): This rule includes callout to field short (there cannot be a distinct FieldSpecShort) |
| CalloutBinding ::= Modifiersopt CalloutBindingLeftShort CalloutModifieropt MethodSpecShort ';' |
| /.$putCase consumeCalloutHeader(); $break ./ |
| /:$readableName CalloutHeader:/ |
| |
| CalloutBindingLeftShort ::= MethodSpecShort CalloutKind |
| /.$putCase consumeCalloutBindingLeft(false); $break ./ |
| /:$readableName CalloutBindingLeft:/ |
| |
| -- this one added to give better message for parameter mappings despite of missing signatures: |
| -- Note(SH): Modifiersopt is needed to make grammar LALR(1), in real life modifiers must be empty |
| CalloutBinding ::= Modifiersopt CalloutBindingLeftShort CalloutModifieropt MethodSpecShort CalloutParameterMappings |
| /.$putCase consumeCalloutParameterMappingsInvalid(); $break ./ |
| |
| -- SYMBOLS: |
| CalloutKind -> '->' |
| CalloutKind -> '=>' |
| /:$readableName CalloutKind:/ |
| |
| CalloutModifieropt ::= $empty |
| CalloutModifieropt -> CalloutModifier |
| /:$readableName CalloutModifier:/ |
| -- get set |
| CalloutModifier ::= 'get' |
| /.$putCase consumeCalloutModifier(TokenNameget); $break ./ |
| /:$readableName CalloutModifier:/ |
| CalloutModifier ::= 'set' |
| /.$putCase consumeCalloutModifier(TokenNameset); $break ./ |
| /:$readableName CalloutModifier:/ |
| |
| |
| ---- CALLOUT-BINDING-PARAMETERMAPPING |
| CalloutParameterMappingsopt -> CalloutParameterMappings |
| CalloutParameterMappingsopt ::= ';' |
| /.$putCase consumeParameterMappingsEmpty(); $break ./ |
| /:$readableName EmptyParameterMappings:/ |
| |
| |
| CalloutParameterMappings ::= 'with' NestedParamMappings '{' CalloutParameterMappingList ,opt '}' |
| /:$readableName CalloutParameterMappings:/ |
| |
| -- note that this rule is needed for diagnose parsing where bodies of parameter mappings are ignored |
| CalloutParameterMappingList ::= $empty |
| /:$readableName EmptyParameterMappings:/ |
| |
| CalloutParameterMappingList -> ParameterMapping |
| CalloutParameterMappingList ::= CalloutParameterMappingList ',' ParameterMapping |
| /.$putCase consumeParameterMappingList(); $break ./ |
| /:$readableName CalloutParameterMappingList:/ |
| |
| ParameterMapping ::= Expression '->' 'Identifier' |
| /.$putCase consumeParameterMappingOut(); $break ./ |
| |
| ParameterMapping ::= 'Identifier' '<-' ForceBaseIsIdentifier Expression RestoreBaseKeyword |
| /.$putCase consumeParameterMappingIn(); $break ./ |
| /:$readableName ParameterMapping:/ |
| |
| |
| NestedParamMappings ::= $empty |
| /.$putCase consumeNestedParamMappings(); $break ./ |
| /:$readableName NestedParameterMappings:/ |
| |
| -- ==== CALLIN-BINDING: ==== |
| |
| -- LONG: |
| CallinBinding ::= CallinHeaderLong CallinParameterMappingsopt |
| /.$putCase consumeCallinBindingLong(); $break ./ |
| /:$readableName CallinBinding:/ |
| |
| CallinHeaderLong ::= CallinBindingLeftLong CallinModifier MethodSpecsLong Predicateopt |
| /.$putCase consumeCallinHeader(); $break ./ |
| /:$readableName CallinHeader:/ |
| |
| -- Note(SH): Modifiersopt is needed to make grammar LALR(1), in real life modifiers must be empty |
| CallinHeaderLong ::= Modifiersopt CallinLabel CallinBindingLeftLong CallinModifier MethodSpecsLong Predicateopt |
| /.$putCase consumeCallinHeader(); $break ./ |
| |
| CallinBindingLeftLong ::= MethodSpecLong '<-' |
| /.$putCase consumeCallinBindingLeft(true); $break ./ |
| /:$readableName CallinBindingLeft:/ |
| |
| -- SHORT: |
| -- Note(SH): Modifiersopt is needed to make grammar LALR(1), in real life modifiers must be empty |
| CallinBinding ::= Modifiersopt CallinBindingLeftShort CallinModifier BaseMethodSpecsShort Predicateopt ';' |
| /.$putCase consumeCallinHeader(); $break ./ |
| |
| -- Note(SH): Modifiersopt is needed to make grammar LALR(1), in real life modifiers must be empty (2 OCCURENCES!) |
| CallinBinding ::= Modifiersopt CallinLabel Modifiersopt CallinBindingLeftShort CallinModifier BaseMethodSpecsShort Predicateopt ';' |
| /.$putCase consumeCallinHeader(); $break ./ |
| |
| CallinBindingLeftShort ::= MethodSpecShort '<-' |
| /.$putCase consumeCallinBindingLeft(false); $break ./ |
| /:$readableName CallinBindingLeft:/ |
| |
| -- LABEL: |
| CallinLabel ::= SimpleName ':' |
| /.$putCase consumeCallinLabel(); $break ./ |
| /:$readableName CallinLabel:/ |
| |
| -- MODIFIER: |
| CallinModifier ::= 'replace' |
| /.$putCase consumeCallinModifier(TokenNamereplace); $break ./ |
| /:$readableName CallinModifier:/ |
| |
| CallinModifier ::= 'before' |
| /.$putCase consumeCallinModifier(TokenNamebefore); $break ./ |
| /:$readableName CallinModifier:/ |
| |
| CallinModifier ::= 'after' |
| /.$putCase consumeCallinModifier(TokenNameafter); $break ./ |
| /:$readableName CallinModifier:/ |
| |
| |
| -- These rules are added to parse invalid callin-bindings without replace/before/after modifier |
| InvalidCallinModifier ::= $empty |
| /.$putCase consumeCallinModifierMissing(); $break ./ |
| /:$readableName InvalidCallinModifier:/ |
| |
| -- Note(SH): Modifiersopt is needed to make grammar LALR(1), in real life modifiers must be empty |
| InvalidCallinBinding ::= Modifiersopt CallinBindingLeftShort InvalidCallinModifier BaseMethodSpecsShort |
| /.$putCase consumeCallinBindingInvalid(false,false); $break ./ |
| /:$readableName InvalidCallinBinding:/ |
| |
| InvalidCallinBinding ::= Modifiersopt CallinLabel Modifiersopt CallinBindingLeftShort InvalidCallinModifier BaseMethodSpecsShort |
| /.$putCase consumeCallinBindingInvalid(false,false); $break ./ |
| /:$readableName InvalidCallinBinding:/ |
| |
| InvalidCallinBinding ::= Modifiersopt CallinBindingLeftShort CallinModifier BaseMethodSpecsShort CallinParameterMappings |
| /.$putCase consumeCallinBindingInvalid(false,true); $break ./ |
| /:$readableName InvalidCallinBinding:/ |
| |
| InvalidCallinBinding ::= Modifiersopt CallinLabel Modifiersopt CallinBindingLeftShort CallinModifier BaseMethodSpecsShort CallinParameterMappings |
| /.$putCase consumeCallinBindingInvalid(false,true); $break ./ |
| /:$readableName InvalidCallinBinding:/ |
| |
| InvalidCallinBinding ::= CallinBindingLeftLong InvalidCallinModifier MethodSpecsLong CallinParameterMappingsopt |
| /.$putCase consumeCallinBindingInvalid(true,false); $break ./ |
| /:$readableName InvalidCallinBinding:/ |
| |
| InvalidCallinBinding ::= Modifiersopt CallinLabel CallinBindingLeftLong InvalidCallinModifier MethodSpecsLong CallinParameterMappingsopt |
| /.$putCase consumeCallinBindingInvalid(true,false); $break ./ |
| /:$readableName InvalidCallinBinding:/ |
| |
| |
| ---- CALLIN-BINDING-PARAMETERMAPPING |
| CallinParameterMappingsopt -> CallinParameterMappings |
| CallinParameterMappingsopt ::= ';' |
| /.$putCase consumeParameterMappingsEmpty(); $break ./ |
| /:$readableName EmptyParameterMappings:/ |
| |
| CallinParameterMappings ::= 'with' NestedParamMappings '{' CallinParameterMappingList ,opt '}' |
| /:$readableName CallinParameterMappings:/ |
| |
| -- note that this rule is needed for diagnose parsing where bodies of parameter mappings are ignored |
| CallinParameterMappingList ::= $empty |
| /:$readableName EmptyParameterMappings:/ |
| |
| CallinParameterMappingList -> ParameterMapping |
| CallinParameterMappingList ::= CallinParameterMappingList ',' ParameterMapping |
| /.$putCase consumeParameterMappingList(); $break ./ |
| /:$readableName ParameterMappingList:/ |
| |
| -- ==== METHOD_SPEC: ==== |
| |
| MethodSpecShort ::= SimpleName |
| /.$putCase consumeMethodSpecShort(); $break ./ |
| /:$readableName MethodSpecShort:/ |
| |
| MethodSpecLong ::= MethodHeaderName FormalParameterListopt MethodHeaderRightParen |
| /.$putCase consumeMethodSpecLong(false); $break ./ |
| /:$readableName MethodSpecLong:/ |
| |
| -- explicitly handle this error case: |
| MethodSpecLong ::= ConstructorHeaderName FormalParameterListopt MethodHeaderRightParen |
| /.$putCase consumeMethodSpecLongCtor(); $break ./ |
| /:$readableName IllegalMethodSpecLong:/ |
| |
| -- base of callin can use '+' after return type: |
| BaseMethodSpecLong ::= MethodHeaderName FormalParameterListopt MethodHeaderRightParen |
| /.$putCase consumeMethodSpecLong(false); $break ./ |
| /:$readableName MethodSpecLong:/ |
| |
| BaseMethodSpecLong ::= MethodSpecNamePlus FormalParameterListopt MethodHeaderRightParen |
| /.$putCase consumeMethodSpecLong(true); $break ./ |
| /:$readableName MethodSpecLong:/ |
| |
| MethodSpecNamePlus ::= Modifiersopt Type '+' 'Identifier' '(' |
| /.$putCase consumeMethodHeaderName(false); $break ./ |
| /:$readableName MethodSpecName:/ |
| |
| CalloutFieldSpecLong ::= CalloutModifier Type 'Identifier' |
| /.$putCase consumeFieldSpecLong(); $break ./ |
| /:$readableName CallloutFieldSpec:/ |
| |
| BaseMethodSpecsShort -> BaseMethodSpecListShort |
| /:$readableName MethodSpecsShort:/ |
| |
| BaseMethodSpecListShort -> BaseMethodSpecShort |
| BaseMethodSpecListShort ::= BaseMethodSpecListShort ',' BaseMethodSpecShort |
| /.$putCase consumeMethodSpecList(); $break ./ |
| /:$readableName MethodSpecListShort:/ |
| |
| BaseMethodSpecShort -> MethodSpecShort |
| |
| MethodSpecsLong -> MethodSpecListLong |
| /:$readableName MethodSpecsLong:/ |
| |
| MethodSpecListLong -> BaseMethodSpecLong |
| MethodSpecListLong ::= MethodSpecListLong ',' BaseMethodSpecLong |
| /.$putCase consumeMethodSpecList(); $break ./ |
| /:$readableName MethodSpecListLong:/ |
| |
| -- ==== PRECEDENCE DECLARATION ==== |
| PrecedenceDeclaration ::= 'precedence' BindingNames ';' |
| /.$putCase consumePrecedenceDeclaration(false); $break ./ |
| /:$readableName PrecedenceDeclaration:/ |
| |
| PrecedenceDeclaration ::= 'precedence' 'after' BindingNames ';' |
| /.$putCase consumePrecedenceDeclaration(true); $break ./ |
| /:$readableName PrecedenceAfterDeclaration:/ |
| |
| BindingNames -> BindingName |
| BindingNames ::= BindingNames ',' BindingName |
| /.$putCase consumeBindingNames(); $break ./ |
| /:$readableName CallinBindingNames:/ |
| |
| BindingName ::= Name |
| /.$putCase consumeBindingName(); $break ./ |
| /:$readableName CallinBindingName:/ |
| -- Markus Witte} |
| |
| --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 ./ |
| |
| -- {ObjectTeams |
| ExplicitConstructorInvocation ::= 'tsuper' '(' ArgumentListopt ')' ';' |
| /.$putCase consumeExplicitConstructorInvocation(0,TSUPER_CALL); $break ./ |
| |
| ExplicitConstructorInvocation ::= Name '.' 'tsuper' '(' ArgumentListopt ')' ';' |
| /.$putCase consumeExplicitConstructorInvocation(2,TSUPER_CALL); $break ./ |
| -- Markus Witte} |
| |
| --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:/ |
| |
| -- {ObjectTeams |
| BaseConstructorExpression ::= 'base' '(' ArgumentListopt ')' |
| /.$putCase consumeExplicitConstructorInvocationBase(0); $break ./ |
| /:$readableName BaseConstructorInvocation:/ |
| |
| BaseConstructorInvocation ::= 'base' '(' ArgumentListopt ')' |
| /.$putCase consumeExplicitConstructorInvocationBase(1); $break ./ |
| /:$readableName BaseConstructorInvocation:/ |
| |
| BaseConstructorInvocation ::= Primary . 'base' '(' ArgumentListopt ')' |
| /.$putCase consumeExplicitConstructorInvocationBase(2); $break ./ |
| /:$readableName QualifiedBaseConstructorInvocation:/ |
| |
| BaseConstructorInvocation ::= Name . 'base' '(' ArgumentListopt ')' |
| /.$putCase consumeExplicitConstructorInvocationBase(3); $break ./ |
| /:$readableName QualifiedBaseConstructorInvocation:/ |
| -- Markus Witte} |
| |
| --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:/ |
| |
| -- {ObjectTeams |
| -- orig: InterfaceHeader ::= InterfaceHeaderName InterfaceHeaderExtendsopt |
| InterfaceHeader ::= InterfaceHeaderName InterfaceHeaderExtendsopt ClassHeaderPlayedByopt |
| -- SH} |
| /.$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 consumeEmptyTypeDeclaration(); $break ./ |
| /:$readableName InterfaceMemberDeclaration:/ |
| |
| PushDefault ::= $empty |
| /.$putCase consumeInterfaceMethodDefault(); $break ./ |
| /:$readableName PushDefault:/ |
| /:$compliance 1.8:/ |
| |
| InterfaceMemberDeclaration -> ConstantDeclaration |
| InterfaceMemberDeclaration ::= MethodHeader 'default' PushDefault MethodBody |
| /:$compliance 1.8:/ |
| /.$putCase consumeInterfaceMethodDeclaration(true); $break ./ |
| InterfaceMemberDeclaration ::= MethodHeader MethodBody |
| /.$putCase consumeInterfaceMethodDeclaration(false); $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:/ |
| |
| -- These rules are added to be able to parse initializers inside an interface and then report a relevent error message (bug 212713) |
| InvalidInitializer -> StaticInitializer |
| InvalidInitializer -> Initializer |
| /:$readableName InvalidInitializer:/ |
| |
| InterfaceMemberDeclaration -> AbstractMethodDeclaration |
| InterfaceMemberDeclaration -> InvalidConstructorDeclaration |
| InterfaceMemberDeclaration -> InvalidInitializer |
| --1.1 feature |
| InterfaceMemberDeclaration -> ClassDeclaration |
| --1.1 feature |
| InterfaceMemberDeclaration -> InterfaceDeclaration |
| InterfaceMemberDeclaration -> EnumDeclaration |
| InterfaceMemberDeclaration -> AnnotationTypeDeclaration |
| --{ObjectTeams: bindings in role interfaces: |
| InterfaceMemberDeclaration -> BindingDeclaration |
| -- SH} |
| /:$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:/ |
| /:$recovery_template Identifier:/ |
| |
| 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 ::= Type0 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 Type0 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 |
| -- {ObjectTeams |
| Statement -> WithinStatement |
| -- Markus Witte} |
| ----------------------------------------------- |
| -- 1.5 feature |
| ----------------------------------------------- |
| Statement -> EnhancedForStatement |
| /:$readableName Statement:/ |
| /:$recovery_template ;:/ |
| |
| 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 |
| StatementWithoutTrailingSubstatement -> TryStatementWithResources |
| /:$readableName Statement:/ |
| |
| EmptyStatement ::= ';' |
| /.$putCase consumeEmptyStatement(); $break ./ |
| /:$readableName EmptyStatement:/ |
| |
| LabeledStatement ::= Label ':' Statement |
| /.$putCase consumeStatementLabel() ; $break ./ |
| /:$readableName LabeledStatement:/ |
| |
| LabeledStatementNoShortIf ::= Label ':' StatementNoShortIf |
| /.$putCase consumeStatementLabel() ; $break ./ |
| /:$readableName LabeledStatement:/ |
| |
| Label ::= 'Identifier' |
| /.$putCase consumeLabel(); $break ./ |
| /:$readableName Label:/ |
| |
| ExpressionStatement ::= StatementExpression ';' |
| /. $putCase consumeExpressionStatement(); $break ./ |
| ExpressionStatement ::= ExplicitConstructorInvocation |
| /:$readableName Statement:/ |
| |
| StatementExpression ::= Assignment |
| StatementExpression ::= PreIncrementExpression |
| StatementExpression ::= PreDecrementExpression |
| StatementExpression ::= PostIncrementExpression |
| StatementExpression ::= PostDecrementExpression |
| StatementExpression ::= MethodInvocation |
| StatementExpression ::= ClassInstanceCreationExpression |
| -- {ObjectTeams |
| StatementExpression ::= BaseConstructorInvocation |
| -- SH} |
| /:$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:/ |
| |
| -- {ObjectTeams |
| WithinStatement ::= 'within' '(' Expression ')' Statement |
| /.$putCase consumeWithinStatement(); $break ./ |
| /:$readableName WithinStatement:/ |
| -- Markus Witte} |
| |
| -- 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, false); $break ./ |
| TryStatement ::= 'try' TryBlock Catchesopt Finally |
| /.$putCase consumeStatementTry(true, false); $break ./ |
| /:$readableName TryStatement:/ |
| |
| TryStatementWithResources ::= 'try' ResourceSpecification TryBlock Catchesopt |
| /.$putCase consumeStatementTry(false, true); $break ./ |
| /:$compliance 1.7:/ |
| TryStatementWithResources ::= 'try' ResourceSpecification TryBlock Catchesopt Finally |
| /.$putCase consumeStatementTry(true, true); $break ./ |
| /:$readableName TryStatementWithResources:/ |
| /:$compliance 1.7:/ |
| |
| ResourceSpecification ::= '(' Resources ;opt ')' |
| /.$putCase consumeResourceSpecification(); $break ./ |
| /:$readableName ResourceSpecification:/ |
| /:$compliance 1.7:/ |
| |
| ;opt ::= $empty |
| /.$putCase consumeResourceOptionalTrailingSemiColon(false); $break ./ |
| /:$compliance 1.7:/ |
| ;opt ::= ';' |
| /.$putCase consumeResourceOptionalTrailingSemiColon(true); $break ./ |
| /:$readableName ;:/ |
| /:$compliance 1.7:/ |
| |
| Resources ::= Resource |
| /.$putCase consumeSingleResource(); $break ./ |
| /:$compliance 1.7:/ |
| Resources ::= Resources TrailingSemiColon Resource |
| /.$putCase consumeMultipleResources(); $break ./ |
| /:$readableName Resources:/ |
| /:$compliance 1.7:/ |
| |
| TrailingSemiColon ::= ';' |
| /.$putCase consumeResourceOptionalTrailingSemiColon(true); $break ./ |
| /:$readableName ;:/ |
| /:$compliance 1.7:/ |
| |
| Resource ::= TypeInternal PushModifiers VariableDeclaratorId EnterVariable '=' ForceNoDiet VariableInitializer RestoreDiet ExitVariableWithInitialization |
| /.$putCase consumeResourceAsLocalVariableDeclaration(); $break ./ |
| /:$readableName Resource:/ |
| /:$compliance 1.7:/ |
| |
| Resource ::= Modifiers TypeInternal PushRealModifiers VariableDeclaratorId EnterVariable '=' ForceNoDiet VariableInitializer RestoreDiet ExitVariableWithInitialization |
| /.$putCase consumeResourceAsLocalVariableDeclaration(); $break ./ |
| /:$readableName Resource:/ |
| /:$compliance 1.7:/ |
| |
| TryBlock ::= Block ExitTryBlock |
| /:$readableName Block:/ |
| |
| ExitTryBlock ::= $empty |
| /.$putCase consumeExitTryBlock(); $break ./ |
| /:$readableName ExitTryBlock:/ |
| |
| Catches -> CatchClause |
| Catches ::= Catches CatchClause |
| /.$putCase consumeCatches(); $break ./ |
| /:$readableName Catches:/ |
| |
| CatchClause ::= 'catch' '(' CatchFormalParameter ')' Block |
| /.$putCase consumeStatementCatch() ; $break ./ |
| /:$readableName CatchClause:/ |
| |
| Finally ::= 'finally' Block |
| /:$readableName Finally:/ |
| /:$recovery_template finally { }:/ |
| |
| --18.12 Productions from 14: Expressions |
| |
| --for source positioning purpose |
| PushLPAREN ::= '(' |
| /.$putCase consumeLeftParen(); $break ./ |
| /:$readableName (:/ |
| /:$recovery_template (:/ |
| PushRPARENForUnannotatedTypeCast ::= ')' |
| /.$putCase consumeRightParenForUnannotatedTypeCast(); $break ./ |
| /:$readableName ):/ |
| /:$recovery_template ):/ |
| PushRPARENForNameUnannotatedTypeCast ::= ')' |
| /.$putCase consumeRightParenForNameUnannotatedTypeCast(); $break ./ |
| /:$readableName ):/ |
| /:$recovery_template ):/ |
| PushRPAREN ::= ')' |
| /.$putCase consumeRightParen(); $break ./ |
| /:$readableName ):/ |
| /:$recovery_template ):/ |
| PushRPARENForAnnotatedTypeCast ::= ')' |
| /.$putCase consumeRightParenForAnnotatedTypeCast(); $break ./ |
| /:$readableName ):/ |
| /:$recovery_template ):/ |
| |
| PushRPARENForNameAndAnnotatedTypeCast ::= ')' |
| /.$putCase consumeRightParenForNameAndAnnotatedTypeCast(); $break ./ |
| /:$readableName ):/ |
| /:$recovery_template ):/ |
| |
| 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 |
| --{ObjectTeams: |
| PrimaryNoNewArray -> BaseConstructorExpression |
| -- SH} |
| PrimaryNoNewArray -> FieldAccess |
| --1.1 feature |
| -- javac doesn't permit type annotations here. |
| 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 ./ |
| |
| --{ObjectTeams: R<@t>.class |
| -- (start with RelationalExpression to make the grammer LL1, further syntax checking in Parser) |
| RelationalExpression ::= RelationalExpression '<' TypeAnchor '>' '.' 'class' |
| /.$putCase consumeRoleClassLiteral(); $break ./ |
| -- SH} |
| |
| PrimaryNoNewArray -> MethodInvocation |
| PrimaryNoNewArray -> ArrayAccess |
| |
| ----------------------------------------------------------------------- |
| -- Start of rules for JSR 335 |
| ----------------------------------------------------------------------- |
| |
| PrimaryNoNewArray -> LambdaExpression |
| PrimaryNoNewArray -> ReferenceExpression |
| /:$readableName Expression:/ |
| |
| -- BeginTypeArguments is a synthetic token the scanner concocts to help disambiguate |
| -- between '<' as an operator and '<' in '<' TypeArguments '>' |
| OnlyTypeArgumentsForReferenceExpression -> BeginTypeArguments OnlyTypeArguments |
| /:$readableName OnlyTypeArgumentsForReferenceExpression:/ |
| /:$compliance 1.8:/ |
| |
| ReferenceExpression ::= PrimitiveType Dims '::' NonWildTypeArgumentsopt IdentifierOrNew |
| /.$putCase consumeReferenceExpressionPrimitiveTypeForm(); $break ./ |
| ReferenceExpression ::= Name Dimsopt '::' NonWildTypeArgumentsopt IdentifierOrNew |
| /.$putCase consumeReferenceExpressionNameForm(); $break ./ |
| ReferenceExpression ::= Name OnlyTypeArgumentsForReferenceExpression Dimsopt '::' NonWildTypeArgumentsopt IdentifierOrNew |
| /.$putCase consumeReferenceExpressionTypeForm(false); $break ./ |
| ReferenceExpression ::= Name OnlyTypeArgumentsForReferenceExpression '.' ClassOrInterfaceType Dimsopt '::' NonWildTypeArgumentsopt IdentifierOrNew |
| /.$putCase consumeReferenceExpressionTypeForm(true); $break ./ |
| ReferenceExpression ::= Primary '::' NonWildTypeArgumentsopt Identifier |
| /.$putCase consumeReferenceExpressionPrimaryForm(); $break ./ |
| ReferenceExpression ::= 'super' '::' NonWildTypeArgumentsopt Identifier |
| /.$putCase consumeReferenceExpressionSuperForm(); $break ./ |
| /:$readableName ReferenceExpression:/ |
| /:$compliance 1.8:/ |
| |
| NonWildTypeArgumentsopt ::= $empty |
| /.$putCase consumeEmptyTypeArguments(); $break ./ |
| NonWildTypeArgumentsopt -> OnlyTypeArguments |
| /:$readableName NonWildTypeArgumentsopt:/ |
| /:$compliance 1.8:/ |
| |
| IdentifierOrNew ::= 'Identifier' |
| /.$putCase consumeIdentifierOrNew(false); $break ./ |
| IdentifierOrNew ::= 'new' |
| /.$putCase consumeIdentifierOrNew(true); $break ./ |
| /:$readableName IdentifierOrNew:/ |
| /:$compliance 1.8:/ |
| |
| LambdaExpression ::= LambdaParameters '->' LambdaBody |
| /.$putCase consumeLambdaExpression(); $break ./ |
| /:$readableName LambdaExpression:/ |
| /:$compliance 1.8:/ |
| |
| LambdaParameters ::= Identifier |
| /.$putCase consumeTypeElidedLambdaParameter(false); $break ./ |
| /:$readableName TypeElidedFormalParameter:/ |
| /:$compliance 1.8:/ |
| |
| -- to make the grammar LALR(1), the scanner transforms the input string to |
| -- contain synthetic tokens to signal start of lambda parameter list. |
| LambdaParameters -> BeginLambda PushLPAREN FormalParameterListopt PushRPAREN |
| LambdaParameters -> BeginLambda PushLPAREN TypeElidedFormalParameterList PushRPAREN |
| /:$readableName LambdaParameters:/ |
| /:$compliance 1.8:/ |
| |
| TypeElidedFormalParameterList -> TypeElidedFormalParameter |
| TypeElidedFormalParameterList ::= TypeElidedFormalParameterList ',' TypeElidedFormalParameter |
| /.$putCase consumeFormalParameterList(); $break ./ |
| /:$readableName TypeElidedFormalParameterList:/ |
| /:$compliance 1.8:/ |
| |
| -- to work around a shift reduce conflict, we accept Modifiersopt prefixed |
| -- identifier - downstream phases should reject input strings with modifiers. |
| TypeElidedFormalParameter ::= Modifiersopt Identifier |
| /.$putCase consumeTypeElidedLambdaParameter(true); $break ./ |
| /:$readableName TypeElidedFormalParameter:/ |
| /:$compliance 1.8:/ |
| |
| -- A lambda body of the form x is really '{' return x; '}' |
| LambdaBody -> ElidedLeftBraceAndReturn Expression ElidedSemicolonAndRightBrace |
| LambdaBody ::= NestedType NestedMethod '{' BlockStatementsopt '}' |
| /.$putCase consumeBlock(); $break ./ |
| /:$readableName LambdaBody:/ |
| /:$compliance 1.8:/ |
| |
| ElidedLeftBraceAndReturn ::= $empty |
| /.$putCase consumeElidedLeftBraceAndReturn(); $break ./ |
| /:$readableName ElidedLeftBraceAndReturn:/ |
| /:$compliance 1.8:/ |
| |
| ----------------------------------------------------------------------- |
| -- End of rules for JSR 335 |
| ----------------------------------------------------------------------- |
| |
| --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 EnterInstanceCreationArgumentList '(' ArgumentListopt ')' UnqualifiedClassBodyopt |
| /.$putCase consumeClassInstanceCreationExpressionWithTypeArguments(); $break ./ |
| |
| ClassInstanceCreationExpression ::= 'new' ClassType EnterInstanceCreationArgumentList '(' ArgumentListopt ')' UnqualifiedClassBodyopt |
| /.$putCase consumeClassInstanceCreationExpression(); $break ./ |
| --1.1 feature |
| |
| ClassInstanceCreationExpression ::= Primary '.' 'new' OnlyTypeArguments ClassType EnterInstanceCreationArgumentList '(' ArgumentListopt ')' QualifiedClassBodyopt |
| /.$putCase consumeClassInstanceCreationExpressionQualifiedWithTypeArguments() ; $break ./ |
| |
| ClassInstanceCreationExpression ::= Primary '.' 'new' ClassType EnterInstanceCreationArgumentList '(' ArgumentListopt ')' QualifiedClassBodyopt |
| /.$putCase consumeClassInstanceCreationExpressionQualified() ; $break ./ |
| |
| --1.1 feature |
| ClassInstanceCreationExpression ::= ClassInstanceCreationExpressionName 'new' ClassType EnterInstanceCreationArgumentList '(' ArgumentListopt ')' QualifiedClassBodyopt |
| /.$putCase consumeClassInstanceCreationExpressionQualified() ; $break ./ |
| /:$readableName ClassInstanceCreationExpression:/ |
| |
| ClassInstanceCreationExpression ::= ClassInstanceCreationExpressionName 'new' OnlyTypeArguments ClassType EnterInstanceCreationArgumentList '(' ArgumentListopt ')' QualifiedClassBodyopt |
| /.$putCase consumeClassInstanceCreationExpressionQualifiedWithTypeArguments() ; $break ./ |
| /:$readableName ClassInstanceCreationExpression:/ |
| |
| EnterInstanceCreationArgumentList ::= $empty |
| /.$putCase consumeEnterInstanceCreationArgumentList(); $break ./ |
| /:$readableName EnterInstanceCreationArgumentList:/ |
| |
| ClassInstanceCreationExpressionName ::= Name '.' |
| /.$putCase consumeClassInstanceCreationExpressionName() ; $break ./ |
| /:$readableName ClassInstanceCreationExpressionName:/ |
| |
| UnqualifiedClassBodyopt ::= $empty --test made using null as contents |
| /.$putCase consumeClassBodyopt(); $break ./ |
| UnqualifiedClassBodyopt ::= UnqualifiedEnterAnonymousClassBody ClassBody |
| /:$readableName ClassBody:/ |
| /:$no_statements_recovery:/ |
| |
| UnqualifiedEnterAnonymousClassBody ::= $empty |
| /.$putCase consumeEnterAnonymousClassBody(false); $break ./ |
| /:$readableName EnterAnonymousClassBody:/ |
| |
| QualifiedClassBodyopt ::= $empty --test made using null as contents |
| /.$putCase consumeClassBodyopt(); $break ./ |
| QualifiedClassBodyopt ::= QualifiedEnterAnonymousClassBody ClassBody |
| /:$readableName ClassBody:/ |
| /:$no_statements_recovery:/ |
| |
| QualifiedEnterAnonymousClassBody ::= $empty |
| /.$putCase consumeEnterAnonymousClassBody(true); $break ./ |
| /:$readableName EnterAnonymousClassBody:/ |
| |
| ArgumentList ::= Expression |
| ArgumentList ::= ArgumentList ',' Expression |
| /.$putCase consumeArgumentList(); $break ./ |
| /:$readableName ArgumentList:/ |
| |
| -- ArrayCreationHeader is used only in recovery and the consume* method is a NOP. |
| ArrayCreationHeader ::= 'new' Annotationsopt PrimitiveType DimWithOrWithOutExprs |
| /.$putCase consumeArrayCreationHeader(); $break ./ |
| ArrayCreationHeader ::= 'new' ClassOrInterfaceType DimWithOrWithOutExprs |
| /.$putCase consumeArrayCreationHeader(); $break ./ |
| /:$readableName ArrayCreationHeader:/ |
| |
| ArrayCreationWithoutArrayInitializer ::= 'new' Annotationsopt PrimitiveType DimWithOrWithOutExprs |
| /.$putCase consumeArrayCreationExpressionWithoutInitializer(); $break ./ |
| /:$readableName ArrayCreationWithoutArrayInitializer:/ |
| |
| ArrayCreationWithArrayInitializer ::= 'new' Annotationsopt 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 ::= '[' PushZeroTypeAnnotations Expression ']' |
| DimWithOrWithOutExpr ::= TypeAnnotations '[' Expression ']' |
| /:$compliance 1.8:/ |
| DimWithOrWithOutExpr ::= '[' PushZeroTypeAnnotations ']' |
| /. $putCase consumeDimWithOrWithOutExpr(); $break ./ |
| DimWithOrWithOutExpr ::= TypeAnnotations '[' ']' |
| /. $putCase consumeDimWithOrWithOutExpr(); $break ./ |
| /:$compliance 1.8:/ |
| /:$readableName Dimension:/ |
| -- ----------------------------------------------- |
| |
| -- jsr 308 |
| |
| DimsoptAnnotsopt -> $empty |
| /. $putCase consumeEmptyDimsoptAnnotsopt(); $break ./ |
| /:$readableName AnnotationsDimensionsSequence:/ |
| DimsoptAnnotsopt -> DimsAnnotLoop |
| /. $putCase consumeDimsWithTrailingAnnotsopt(); $break ./ |
| /:$readableName Dimensionsoptannotsopt:/ |
| DimsAnnotLoop ::= OneDimOrAnnot |
| DimsAnnotLoop ::= DimsAnnotLoop OneDimOrAnnot |
| /:$readableName DimsAnnotLoop:/ |
| |
| OneDimOrAnnot ::= Annotation |
| /. $putCase consumeTypeAnnotation(true); $break ./ |
| -- Complain if source level < 1.8 |
| /:$compliance 1.8:/ |
| OneDimOrAnnot -> '[' ']' |
| /. $putCase consumeOneDimLoop(true); $break ./ |
| -- Bump up dimensions && mark zero annotations. |
| /:$readableName OneDimensionOrAnnotation:/ |
| |
| TypeAnnotations ::= Annotation |
| /. $putCase consumeTypeAnnotation(false); $break ./ |
| /:$compliance 1.8:/ |
| TypeAnnotations ::= TypeAnnotations Annotation |
| /. $putCase consumeOneMoreTypeAnnotation(); $break ./ |
| /:$compliance 1.8:/ |
| /:$readableName TypeAnnotations:/ |
| |
| Dims ::= DimsLoop |
| /. $putCase consumeDims(); $break ./ |
| /:$readableName Dimensions:/ |
| DimsLoop -> OneDimLoop |
| DimsLoop ::= DimsLoop OneDimLoop |
| /:$readableName Dimensions:/ |
| OneDimLoop ::= '[' ']' |
| /. $putCase consumeOneDimLoop(false); $break ./ |
| -- Bump up dimensions && mark zero annotations. |
| /:$readableName Dimension:/ |
| OneDimLoop ::= TypeAnnotations '[' ']' |
| /:$compliance 1.8:/ |
| /. $putCase consumeOneDimLoopWithAnnotations(); $break ./ |
| -- Bump up dimensions |
| /:$readableName DimensionWithAnnotations:/ |
| |
| 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 ./ |
| |
| -- {ObjectTeams |
| MethodInvocation ::= 'tsuper' '.' 'Identifier' '(' ArgumentListopt ')' |
| /.$putCase consumeMethodInvocationTSuper(UNQUALIFIED); $break ./ |
| |
| MethodInvocation ::= 'tsuper' '.' OnlyTypeArguments 'Identifier' '(' ArgumentListopt ')' |
| /.$putCase consumeMethodInvocationTSuperWithTypeArguments(0); $break ./ |
| |
| MethodInvocation ::= Name '.' 'tsuper' '.' 'Identifier' '(' ArgumentListopt ')' |
| /.$putCase consumeMethodInvocationTSuper(QUALIFIED); $break ./ |
| |
| MethodInvocation ::= Name '.' 'tsuper' '.' OnlyTypeArguments 'Identifier' '(' ArgumentListopt ')' |
| /.$putCase consumeMethodInvocationTSuperWithTypeArguments(2); $break ./ |
| |
| MethodInvocation ::= 'base' '.' 'Identifier' '(' ArgumentListopt ')' |
| /.$putCase consumeMethodInvocationBase(false); $break ./ |
| |
| MethodInvocation ::= 'base' '.' OnlyTypeArguments 'Identifier' '(' ArgumentListopt ')' |
| /.$putCase consumeMethodInvocationBaseWithTypeArguments(false); $break ./ |
| |
| MethodInvocation ::= 'base' '.' 'super' '.' 'Identifier' '(' ArgumentListopt ')' |
| /.$putCase consumeMethodInvocationBase(true); $break ./ |
| |
| MethodInvocation ::= 'base' '.' 'super' '.' OnlyTypeArguments 'Identifier' '(' ArgumentListopt ')' |
| /.$putCase consumeMethodInvocationBaseWithTypeArguments(true); $break ./ |
| -- Markus Witte} |
| |
| /:$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 PushRPARENForUnannotatedTypeCast InsideCastExpression UnaryExpression |
| /.$putCase consumeCastExpressionWithPrimitiveType(); $break ./ |
| CastExpression ::= PushLPAREN Modifiers PrimitiveType Dimsopt PushRPARENForAnnotatedTypeCast InsideCastExpression UnaryExpression |
| /:$compliance 1.8:/ |
| /.$putCase consumeCastExpressionWithPrimitiveTypeWithTypeAnnotations(); $break ./ |
| CastExpression ::= PushLPAREN Name OnlyTypeArgumentsForCastExpression Dimsopt PushRPARENForUnannotatedTypeCast InsideCastExpression UnaryExpressionNotPlusMinus |
| /.$putCase consumeCastExpressionWithGenericsArray(); $break ./ |
| CastExpression ::= PushLPAREN Modifiers Name OnlyTypeArgumentsForCastExpression Dimsopt PushRPARENForAnnotatedTypeCast InsideCastExpression UnaryExpressionNotPlusMinus |
| /:$compliance 1.8:/ |
| /.$putCase consumeCastExpressionWithGenericsArrayWithTypeAnnotations(); $break ./ |
| CastExpression ::= PushLPAREN Name OnlyTypeArgumentsForCastExpression '.' ClassOrInterfaceType0 Dimsopt PushRPARENForUnannotatedTypeCast InsideCastExpressionWithQualifiedGenerics UnaryExpressionNotPlusMinus |
| /.$putCase consumeCastExpressionWithQualifiedGenericsArray(); $break ./ |
| CastExpression ::= PushLPAREN Modifiers Name OnlyTypeArgumentsForCastExpression '.' ClassOrInterfaceType0 Dimsopt PushRPARENForAnnotatedTypeCast InsideCastExpressionWithAnnotatedQualifiedGenerics UnaryExpressionNotPlusMinus |
| /:$compliance 1.8:/ |
| /.$putCase consumeCastExpressionWithQualifiedGenericsArrayWithTypeAnnotations(); $break ./ |
| CastExpression ::= PushLPAREN Name PushRPARENForNameUnannotatedTypeCast InsideCastExpressionLL1 UnaryExpressionNotPlusMinus |
| /.$putCase consumeCastExpressionLL1(); $break ./ |
| CastExpression ::= PushLPAREN Modifiers Name PushRPARENForNameAndAnnotatedTypeCast InsideCastExpressionLL1 UnaryExpressionNotPlusMinus |
| /:$compliance 1.8:/ |
| /.$putCase consumeCastExpressionLL1WithTypeAnnotations(); $break ./ |
| CastExpression ::= PushLPAREN Name Dims PushRPARENForUnannotatedTypeCast InsideCastExpression UnaryExpressionNotPlusMinus |
| /.$putCase consumeCastExpressionWithNameArray(); $break ./ |
| CastExpression ::= PushLPAREN Modifiers Name Dims PushRPARENForAnnotatedTypeCast InsideCastExpression UnaryExpressionNotPlusMinus |
| /:$compliance 1.8:/ |
| /.$putCase consumeCastExpressionWithNameArrayWithTypeAnnotations(); $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:/ |
| |
| InsideCastExpressionWithAnnotatedQualifiedGenerics ::= $empty |
| /.$putCase consumeInsideCastExpressionWithAnnotatedQualifiedGenerics(); $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(); $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:/ |
| /:$recovery_template Identifier:/ |
| |
| 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 ArrayInitializerAssignment:/ |
| /:$recovery:/ |
| Assignment ::= InvalidArrayInitializerAssignement |
| /.$putcase ignoreExpressionAssignment();$break ./ |
| /:$recovery:/ |
| |
| 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:/ |
| /:$recovery_template =:/ |
| |
| -- For handling lambda expressions, we need to know when a full Expression |
| -- has been reduced. |
| Expression ::= AssignmentExpression |
| /.$putCase consumeExpression(); $break ./ |
| /:$readableName Expression:/ |
| /:$recovery_template Identifier:/ |
| |
| -- 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 ./ |
| /:$compliance 1.5:/ |
| EnumHeaderName ::= Modifiersopt 'enum' Identifier TypeParameters |
| /. $putCase consumeEnumHeaderNameWithTypeParameters(); $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 ForceNoDiet Argumentsopt RestoreDiet |
| /.$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:/ |
| |
| EnhancedForStatementHeaderInit ::= 'for' '(' Type0 PushModifiers Identifier Dimsopt |
| /.$putCase consumeEnhancedForStatementHeaderInit(false); $break ./ |
| /:$readableName EnhancedForStatementHeaderInit:/ |
| |
| EnhancedForStatementHeaderInit ::= 'for' '(' Modifiers Type0 PushRealModifiers Identifier Dimsopt |
| /.$putCase consumeEnhancedForStatementHeaderInit(true); $break ./ |
| /:$readableName EnhancedForStatementHeaderInit:/ |
| |
| EnhancedForStatementHeader ::= EnhancedForStatementHeaderInit ':' Expression ')' |
| /.$putCase consumeEnhancedForStatementHeader(); $break ./ |
| /:$readableName EnhancedForStatementHeader:/ |
| /:$compliance 1.5:/ |
| |
| --{ObjectTeams: base import: |
| SingleBaseImportDeclaration ::= SingleBaseImportDeclarationName ';' |
| /.$putCase consumeImportDeclaration(); $break ./ |
| /:$readableName SingleBaseImportDeclaration:/ |
| |
| SingleBaseImportDeclarationName ::= 'import' 'base' Name |
| /.$putCase consumeSingleBaseImportDeclarationName(); $break ./ |
| /:$readableName SingleBaseImportDeclarationName:/ |
| -- SH} |
| ----------------------------------------------- |
| -- 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:/ |
| |
| --{ObjectTeams: anchored types: |
| TypeArgument -> TypeAnchor |
| TypeArgument1 -> TypeAnchor '>' |
| TypeArgument2 -> TypeAnchor '>>' |
| |
| TypeAnchor ::= '@' Name |
| /.$putCase consumeTypeAnchor(false); $break ./ |
| /:$readableName typeAnchor:/ |
| |
| -- base is a keyword in this mode, so explicitly expect it: |
| TypeAnchor ::= '@' 'base' |
| /.$putCase consumeTypeAnchor(true); $break ./ |
| /:$readableName typeAnchor:/ |
| |
| -- also 'this' requires special treatment (skip because redundant): |
| TypeAnchor ::= '@' 'this' |
| /.$putCase skipThisAnchor(); $break ./ |
| /:$readableName typeAnchor:/ |
| |
| TypeAnchor ::= '@' Name '.' 'base' |
| /:$readableName typeAnchor:/ |
| /.$putCase consumeQualifiedBaseTypeAnchor(); $break ./ |
| |
| --SH} |
| |
| 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 ./ |
| /:$compliance 1.5:/ |
| ReferenceType1 ::= Modifiers ClassOrInterface '<' TypeArgumentList2 |
| /:$compliance 1.8:/ |
| /.$putCase consumeTypeArgumentReferenceType1WithTypeAnnotations(); $break ./ |
| /:$readableName ReferenceType1:/ |
| |
| 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 ./ |
| /:$compliance 1.5:/ |
| ReferenceType2 ::= Modifiers ClassOrInterface '<' TypeArgumentList3 |
| /:$compliance 1.8:/ |
| /.$putCase consumeTypeArgumentReferenceType2WithTypeAnnotations(); $break ./ |
| /:$readableName ReferenceType2:/ |
| |
| 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:/ |
| |
| PushZeroTypeAnnotations ::= $empty |
| /.$putCase consumeZeroTypeAnnotations(true); $break ./ |
| /:$readableName ZeroTypeAnnotations:/ |
| |
| TypeParameterHeader ::= PushZeroTypeAnnotations Identifier |
| /.$putCase consumeTypeParameterHeader(); $break ./ |
| /:$compliance 1.5:/ |
| TypeParameterHeader ::= TypeAnnotations Identifier |
| /:$compliance 1.8:/ |
| /.$putCase consumeTypeParameterHeader(); $break ./ |
| /:$readableName TypeParameter:/ |
| |
| 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:/ |
| |
| --{ObjectTeams: |
| -- <B base R> |
| TypeParameter ::= TypeParameterHeader 'base' ReferenceType |
| /.$putCase consumeTypeParameterWithBase(); $break ./ |
| /:$compliance 1.5:/ |
| |
| -- <... Team t ...> |
| TypeParameter -> TypeValueParameter |
| TypeParameter1 -> TypeValueParameter1 |
| |
| TypeValueParameter1 -> TypeValueParameter '>' |
| |
| TypeValueParameter ::= TypeParameterHeader Identifier |
| /.$putCase consumeTypeValueParameter(); $break ./ |
| /:$compliance 1.5:/ |
| /:$readableName TypeValueParameter:/ |
| |
| TypeParameter -> AnchoredTypeParameterHeader0 '>' TypeBoundOpt |
| TypeParameter1 -> AnchoredTypeParameterHeader0 '>' TypeBoundOpt1 |
| TypeParameter1 -> AnchoredTypeParameterHeader0 '>>' |
| |
| TypeBoundOpt -> $empty |
| TypeBoundOpt ::= 'extends' ReferenceType |
| /.$putCase consumeBoundsOfAnchoredTypeParameter(); $break ./ |
| /:$compliance 1.5:/ |
| /:$readableName TypeParameterBound:/ |
| |
| TypeBoundOpt1 -> '>' |
| TypeBoundOpt1 ::= 'extends' ReferenceType1 |
| /.$putCase consumeBoundsOfAnchoredTypeParameter(); $break ./ |
| /:$compliance 1.5:/ |
| /:$readableName TypeParameterBound:/ |
| |
| AnchoredTypeParameterHeader0 ::= TypeParameterHeader '<' TypeAnchor |
| /.$putCase consumeAnchoredTypeParameter(); $break ./ |
| /:$compliance 1.5:/ |
| /:$readableName AnchoredTypeParameter:/ |
| -- SH} |
| |
| 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:/ |
| |
| --{ObjectTeams: <B base R> |
| TypeParameter1 ::= TypeParameterHeader 'base' ReferenceType1 |
| /.$putCase consumeTypeParameter1WithBase(); $break ./ |
| /:$compliance 1.5:/ |
| -- SH} |
| |
| 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(); $break ./ |
| InstanceofExpression_NotName ::= InstanceofExpression_NotName 'instanceof' ReferenceType |
| /.$putCase consumeInstanceOfExpression(); $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 ::= Modifiers '@' PushRealModifiers interface Identifier TypeParameters |
| /.$putCase consumeAnnotationTypeDeclarationHeaderNameWithTypeParameters() ; $break ./ |
| /:$compliance 1.5:/ |
| AnnotationTypeDeclarationHeaderName ::= '@' PushModifiersForHeader interface Identifier TypeParameters |
| /.$putCase consumeAnnotationTypeDeclarationHeaderNameWithTypeParameters() ; $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 ::= NestedType AnnotationTypeMemberDeclarations |
| /.$putCase consumeAnnotationTypeMemberDeclarationsopt() ; $break ./ |
| /:$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 Type0 'Identifier' '(' |
| /.$putCase consumeMethodHeaderName(true); $break ./ |
| /:$readableName MethodHeaderName:/ |
| /:$compliance 1.5:/ |
| |
| 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:/ |
| /:$recovery_template @ Identifier:/ |
| |
| 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:/ |
| /:$recovery_template Identifier:/ |
| /:$compliance 1.5:/ |
| |
| MemberValueArrayInitializer ::= EnterMemberValueArrayInitializer '{' PushLeftBrace MemberValues ',' '}' |
| /.$putCase consumeMemberValueArrayInitializer() ; $break ./ |
| /:$compliance 1.5:/ |
| MemberValueArrayInitializer ::= EnterMemberValueArrayInitializer '{' PushLeftBrace MemberValues '}' |
| /.$putCase consumeMemberValueArrayInitializer() ; $break ./ |
| /:$compliance 1.5:/ |
| MemberValueArrayInitializer ::= EnterMemberValueArrayInitializer '{' PushLeftBrace ',' '}' |
| /.$putCase consumeEmptyMemberValueArrayInitializer() ; $break ./ |
| /:$compliance 1.5:/ |
| MemberValueArrayInitializer ::= EnterMemberValueArrayInitializer '{' PushLeftBrace '}' |
| /.$putCase consumeEmptyMemberValueArrayInitializer() ; $break ./ |
| /:$readableName MemberValueArrayInitializer:/ |
| /:$compliance 1.5:/ |
| |
| EnterMemberValueArrayInitializer ::= $empty |
| /.$putCase consumeEnterMemberValueArrayInitializer() ; $break ./ |
| /:$readableName EnterMemberValueArrayInitializer:/ |
| /:$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:/ |
| |
| SingleMemberAnnotationMemberValue ::= MemberValue |
| /.$putCase consumeSingleMemberAnnotationMemberValue() ; $break ./ |
| /:$readableName MemberValue:/ |
| /:$compliance 1.5:/ |
| |
| SingleMemberAnnotation ::= AnnotationName '(' SingleMemberAnnotationMemberValue ')' |
| /.$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 Type0 '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:/ |
| |
| --{ObjectTeams: |
| RecoveryBindingHeader -> RecoveryCalloutHeader |
| RecoveryBindingHeader -> RecoveryCallinHeader |
| /:$readableName MethodBindingHeader:/ |
| |
| -- CALLIN-HEADER: |
| |
| -- Note: do not include 'with' in header, it is used to recognize presence of param mappings, |
| -- while consuming the callXX header; this is easier if 'with' has not been consumed, yet. |
| |
| RecoveryCallinHeader ::= RecoveryCallinBindingLeftLong CallinModifier MethodSpecsLong Predicateopt |
| /.$putCase consumeCallinHeader(); $break ./ |
| /:$readableName CallinBindingLong:/ |
| |
| RecoveryCallinHeader ::= Modifiersopt CallinLabel RecoveryCallinBindingLeftLong CallinModifier MethodSpecsLong Predicateopt |
| /.$putCase consumeCallinHeader(); $break ./ |
| |
| RecoveryCallinBindingLeftLong ::= RecoveryMethodSpecLong '<-' |
| /.$putCase consumeCallinBindingLeft(true); $break ./ |
| /:$readableName CallinBindingLeft:/ |
| |
| -- Note(SH): Modifiersopt is needed to make grammar LALR(1), in real life modifiers must be empty |
| RecoveryCallinHeader ::= Modifiersopt CallinBindingLeftShort CallinModifier BaseMethodSpecsShort Predicateopt |
| /.$putCase consumeCallinHeader(); $break ./ |
| RecoveryCallinHeader ::= Modifiersopt CallinLabel Modifiersopt CallinBindingLeftShort CallinModifier BaseMethodSpecsShort Predicateopt |
| /.$putCase consumeCallinHeader(); $break ./ |
| /:$readableName CallinBindingShort:/ |
| |
| -- CALLOUT-HEADER: |
| RecoveryCalloutHeader ::= RecoveryCalloutBindingLeftLong MethodSpecLong |
| /.$putCase consumeCalloutHeader(); $break ./ |
| /:$readableName CalloutBindingLong:/ |
| |
| RecoveryCalloutBindingLeftLong ::= RecoveryMethodSpecLong CalloutKind |
| /.$putCase consumeCalloutBindingLeft(true); $break ./ |
| /:$readableName CalloutBindingLeftLong:/ |
| |
| RecoveryCalloutHeader ::= RecoveryCalloutBindingLeftLong CalloutFieldSpecLong |
| /.$putCase consumeCalloutHeader(); $break ./ |
| /:$readableName CalloutToFieldLong:/ |
| |
| -- Note(SH): Modifiersopt is needed to make grammar LALR(1), in real life modifiers must be empty |
| RecoveryCalloutHeader ::= Modifiersopt CalloutBindingLeftShort CalloutModifieropt MethodSpecShort |
| /.$putCase consumeCalloutHeader(); $break ./ |
| /:$readableName CalloutBindingShort:/ |
| |
| |
| -- METHOD-SPEC (during recover): |
| RecoveryMethodSpecLong ::= RecoveryMethodHeaderName FormalParameterListopt MethodHeaderRightParen |
| /.$putCase consumeMethodSpecLong(false); $break ./ |
| /:$readableName MethodSpecLong:/ |
| -- SH} |
| |
| ----------------------------------- |
| -- 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 ::= '...' |
| |
| -- {ObjectTeams |
| BINDIN ::= '<-' |
| CALLOUT_OVERRIDE ::= '=>' |
| -- Markus Witte} |
| |
| $end |
| -- need a carriage return after the $end |