Commit 7f3ef00d authored by Alexander Weigl's avatar Alexander Weigl

clean up and syntaxhighlightning

parent 2d44879d
Pipeline #10934 passed with stage
in 2 minutes and 16 seconds
/*
* [The "BSD license"]
* Copyright (c) 2014 Terence Parr
* Copyright (c) 2014 Sam Harwell
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/**
* A Java 8 grammar for ANTLR 4 derived from the Java Language Specification
* chapter 19.
*
* NOTE: This grammar results in a generated parser that is much slower
* than the Java 7 grammar in the grammars-v4/java directory. This
* one is, however, extremely close to the spec.
*
* You can test with
*
* $ antlr4 Java8.g4
* $ javac *.java
* $ grun Java8 compilationUnit *.java
*
* Or,
~/antlr/code/grammars-v4/java8 $ java Test .
/Users/parrt/antlr/code/grammars-v4/java8/./Java8BaseListener.java
/Users/parrt/antlr/code/grammars-v4/java8/./Java8Lexer.java
/Users/parrt/antlr/code/grammars-v4/java8/./Java8Listener.java
/Users/parrt/antlr/code/grammars-v4/java8/./Java8Parser.java
/Users/parrt/antlr/code/grammars-v4/java8/./Test.java
Total lexer+parser time 30844ms.
*/
grammar Java8;
/*
* Productions from §3 (Lexical Structure)
*/
literal
: IntegerLiteral
| FloatingPointLiteral
| BooleanLiteral
| CharacterLiteral
| StringLiteral
| NullLiteral
;
/*
* Productions from §4 (Types, Values, and Variables)
*/
type
: primitiveType
| referenceType
;
primitiveType
: annotation* numericType
| annotation* 'boolean'
;
numericType
: integralType
| floatingPointType
;
integralType
: 'byte'
| 'short'
| 'int'
| 'long'
| 'char'
;
floatingPointType
: 'float'
| 'double'
;
referenceType
: classOrInterfaceType
| typeVariable
| arrayType
;
classOrInterfaceType
: ( classType_lfno_classOrInterfaceType
| interfaceType_lfno_classOrInterfaceType
)
( classType_lf_classOrInterfaceType
| interfaceType_lf_classOrInterfaceType
)*
;
classType
: annotation* Identifier typeArguments?
| classOrInterfaceType '.' annotation* Identifier typeArguments?
;
classType_lf_classOrInterfaceType
: '.' annotation* Identifier typeArguments?
;
classType_lfno_classOrInterfaceType
: annotation* Identifier typeArguments?
;
interfaceType
: classType
;
interfaceType_lf_classOrInterfaceType
: classType_lf_classOrInterfaceType
;
interfaceType_lfno_classOrInterfaceType
: classType_lfno_classOrInterfaceType
;
typeVariable
: annotation* Identifier
;
arrayType
: primitiveType dims
| classOrInterfaceType dims
| typeVariable dims
;
dims
: annotation* '[' ']' (annotation* '[' ']')*
;
typeParameter
: typeParameterModifier* Identifier typeBound?
;
typeParameterModifier
: annotation
;
typeBound
: 'extends' typeVariable
| 'extends' classOrInterfaceType additionalBound*
;
additionalBound
: '&' interfaceType
;
typeArguments
: '<' typeArgumentList '>'
;
typeArgumentList
: typeArgument (',' typeArgument)*
;
typeArgument
: referenceType
| wildcard
;
wildcard
: annotation* '?' wildcardBounds?
;
wildcardBounds
: 'extends' referenceType
| 'super' referenceType
;
/*
* Productions from §6 (Names)
*/
packageName
: Identifier
| packageName '.' Identifier
;
typeName
: Identifier
| packageOrTypeName '.' Identifier
;
packageOrTypeName
: Identifier
| packageOrTypeName '.' Identifier
;
expressionName
: Identifier
| ambiguousName '.' Identifier
;
methodName
: Identifier
;
ambiguousName
: Identifier
| ambiguousName '.' Identifier
;
/*
* Productions from §7 (Packages)
*/
compilationUnit
: packageDeclaration? importDeclaration* typeDeclaration* EOF
;
packageDeclaration
: packageModifier* 'package' Identifier ('.' Identifier)* ';'
;
packageModifier
: annotation
;
importDeclaration
: singleTypeImportDeclaration
| typeImportOnDemandDeclaration
| singleStaticImportDeclaration
| staticImportOnDemandDeclaration
;
singleTypeImportDeclaration
: 'import' typeName ';'
;
typeImportOnDemandDeclaration
: 'import' packageOrTypeName '.' '*' ';'
;
singleStaticImportDeclaration
: 'import' 'static' typeName '.' Identifier ';'
;
staticImportOnDemandDeclaration
: 'import' 'static' typeName '.' '*' ';'
;
typeDeclaration
: classDeclaration
| interfaceDeclaration
| ';'
;
/*
* Productions from §8 (Classes)
*/
classDeclaration
: normalClassDeclaration
| enumDeclaration
;
normalClassDeclaration
: classModifier* 'class' Identifier typeParameters? superclass? superinterfaces? classBody
;
classModifier
: annotation
| 'public'
| 'protected'
| 'private'
| 'abstract'
| 'static'
| 'final'
| 'strictfp'
;
typeParameters
: '<' typeParameterList '>'
;
typeParameterList
: typeParameter (',' typeParameter)*
;
superclass
: 'extends' classType
;
superinterfaces
: 'implements' interfaceTypeList
;
interfaceTypeList
: interfaceType (',' interfaceType)*
;
classBody
: '{' classBodyDeclaration* '}'
;
classBodyDeclaration
: classMemberDeclaration
| instanceInitializer
| staticInitializer
| constructorDeclaration
;
classMemberDeclaration
: fieldDeclaration
| methodDeclaration
| classDeclaration
| interfaceDeclaration
| ';'
;
fieldDeclaration
: fieldModifier* unannType variableDeclaratorList ';'
;
fieldModifier
: annotation
| 'public'
| 'protected'
| 'private'
| 'static'
| 'final'
| 'transient'
| 'volatile'
;
variableDeclaratorList
: variableDeclarator (',' variableDeclarator)*
;
variableDeclarator
: variableDeclaratorId ('=' variableInitializer)?
;
variableDeclaratorId
: Identifier dims?
;
variableInitializer
: expression
| arrayInitializer
;
unannType
: unannPrimitiveType
| unannReferenceType
;
unannPrimitiveType
: numericType
| 'boolean'
;
unannReferenceType
: unannClassOrInterfaceType
| unannTypeVariable
| unannArrayType
;
unannClassOrInterfaceType
: ( unannClassType_lfno_unannClassOrInterfaceType
| unannInterfaceType_lfno_unannClassOrInterfaceType
)
( unannClassType_lf_unannClassOrInterfaceType
| unannInterfaceType_lf_unannClassOrInterfaceType
)*
;
unannClassType
: Identifier typeArguments?
| unannClassOrInterfaceType '.' annotation* Identifier typeArguments?
;
unannClassType_lf_unannClassOrInterfaceType
: '.' annotation* Identifier typeArguments?
;
unannClassType_lfno_unannClassOrInterfaceType
: Identifier typeArguments?
;
unannInterfaceType
: unannClassType
;
unannInterfaceType_lf_unannClassOrInterfaceType
: unannClassType_lf_unannClassOrInterfaceType
;
unannInterfaceType_lfno_unannClassOrInterfaceType
: unannClassType_lfno_unannClassOrInterfaceType
;
unannTypeVariable
: Identifier
;
unannArrayType
: unannPrimitiveType dims
| unannClassOrInterfaceType dims
| unannTypeVariable dims
;
methodDeclaration
: methodModifier* methodHeader methodBody
;
methodModifier
: annotation
| 'public'
| 'protected'
| 'private'
| 'abstract'
| 'static'
| 'final'
| 'synchronized'
| 'native'
| 'strictfp'
;
methodHeader
: result methodDeclarator throws_?
| typeParameters annotation* result methodDeclarator throws_?
;
result
: unannType
| 'void'
;
methodDeclarator
: Identifier '(' formalParameterList? ')' dims?
;
formalParameterList
: formalParameters ',' lastFormalParameter
| lastFormalParameter
;
formalParameters
: formalParameter (',' formalParameter)*
| receiverParameter (',' formalParameter)*
;
formalParameter
: variableModifier* unannType variableDeclaratorId
;
variableModifier
: annotation
| 'final'
;
lastFormalParameter
: variableModifier* unannType annotation* '...' variableDeclaratorId
| formalParameter
;
receiverParameter
: annotation* unannType (Identifier '.')? 'this'
;
throws_
: 'throws' exceptionTypeList
;
exceptionTypeList
: exceptionType (',' exceptionType)*
;
exceptionType
: classType
| typeVariable
;
methodBody
: block
| ';'
;
instanceInitializer
: block
;
staticInitializer
: 'static' block
;
constructorDeclaration
: constructorModifier* constructorDeclarator throws_? constructorBody
;
constructorModifier
: annotation
| 'public'
| 'protected'
| 'private'
;
constructorDeclarator
: typeParameters? simpleTypeName '(' formalParameterList? ')'
;
simpleTypeName
: Identifier
;
constructorBody
: '{' explicitConstructorInvocation? blockStatements? '}'
;
explicitConstructorInvocation
: typeArguments? 'this' '(' argumentList? ')' ';'
| typeArguments? 'super' '(' argumentList? ')' ';'
| expressionName '.' typeArguments? 'super' '(' argumentList? ')' ';'
| primary '.' typeArguments? 'super' '(' argumentList? ')' ';'
;
enumDeclaration
: classModifier* 'enum' Identifier superinterfaces? enumBody
;
enumBody
: '{' enumConstantList? ','? enumBodyDeclarations? '}'
;
enumConstantList
: enumConstant (',' enumConstant)*
;
enumConstant
: enumConstantModifier* Identifier ('(' argumentList? ')')? classBody?
;
enumConstantModifier
: annotation
;
enumBodyDeclarations
: ';' classBodyDeclaration*
;
/*
* Productions from §9 (Interfaces)
*/
interfaceDeclaration
: normalInterfaceDeclaration
| annotationTypeDeclaration
;
normalInterfaceDeclaration
: interfaceModifier* 'interface' Identifier typeParameters? extendsInterfaces? interfaceBody
;
interfaceModifier
: annotation
| 'public'
| 'protected'
| 'private'
| 'abstract'
| 'static'
| 'strictfp'
;
extendsInterfaces
: 'extends' interfaceTypeList
;
interfaceBody
: '{' interfaceMemberDeclaration* '}'
;
interfaceMemberDeclaration
: constantDeclaration
| interfaceMethodDeclaration
| classDeclaration
| interfaceDeclaration
| ';'
;
constantDeclaration
: constantModifier* unannType variableDeclaratorList ';'
;
constantModifier
: annotation
| 'public'
| 'static'
| 'final'
;
interfaceMethodDeclaration
: interfaceMethodModifier* methodHeader methodBody
;
interfaceMethodModifier
: annotation
| 'public'
| 'abstract'
| 'default'
| 'static'
| 'strictfp'
;
annotationTypeDeclaration
: interfaceModifier* '@' 'interface' Identifier annotationTypeBody
;
annotationTypeBody
: '{' annotationTypeMemberDeclaration* '}'
;
annotationTypeMemberDeclaration
: annotationTypeElementDeclaration
| constantDeclaration
| classDeclaration
| interfaceDeclaration
| ';'
;
annotationTypeElementDeclaration
: annotationTypeElementModifier* unannType Identifier '(' ')' dims? defaultValue? ';'
;
annotationTypeElementModifier
: annotation
| 'public'
| 'abstract'
;
defaultValue
: 'default' elementValue
;
annotation
: normalAnnotation
| markerAnnotation
| singleElementAnnotation
;
normalAnnotation
: '@' typeName '(' elementValuePairList? ')'
;
elementValuePairList
: elementValuePair (',' elementValuePair)*
;
elementValuePair
: Identifier '=' elementValue
;
elementValue
: conditionalExpression
| elementValueArrayInitializer
| annotation
;
elementValueArrayInitializer
: '{' elementValueList? ','? '}'
;
elementValueList
: elementValue (',' elementValue)*
;
markerAnnotation
: '@' typeName
;
singleElementAnnotation
: '@' typeName '(' elementValue ')'
;
/*
* Productions from §10 (Arrays)
*/
arrayInitializer
: '{' variableInitializerList? ','? '}'
;
variableInitializerList
: variableInitializer (',' variableInitializer)*
;
/*
* Productions from §14 (Blocks and Statements)
*/
block
: '{' blockStatements? '}'
;
blockStatements
: blockStatement blockStatement*
;
blockStatement
: localVariableDeclarationStatement
| classDeclaration
| statement
;
localVariableDeclarationStatement
: localVariableDeclaration ';'
;
localVariableDeclaration
: variableModifier* unannType variableDeclaratorList
;
statement
: statementWithoutTrailingSubstatement
| labeledStatement
| ifThenStatement
| ifThenElseStatement
| whileStatement
| forStatement
;
statementNoShortIf
: statementWithoutTrailingSubstatement
| labeledStatementNoShortIf
| ifThenElseStatementNoShortIf
| whileStatementNoShortIf
| forStatementNoShortIf
;
statementWithoutTrailingSubstatement
: block
| emptyStatement
| expressionStatement
| assertStatement
| switchStatement
| doStatement
| breakStatement
| continueStatement
| returnStatement
| synchronizedStatement
| throwStatement
| tryStatement
;
emptyStatement
: ';'
;