diff --git a/src/main/antlr4/de/dhbwstuttgart/parser/antlr/Java17Lexer.g4 b/src/main/antlr4/de/dhbwstuttgart/parser/antlr/Java17Lexer.g4 new file mode 100644 index 00000000..7be32dad --- /dev/null +++ b/src/main/antlr4/de/dhbwstuttgart/parser/antlr/Java17Lexer.g4 @@ -0,0 +1,241 @@ +/* + [The "BSD licence"] + Copyright (c) 2013 Terence Parr, Sam Harwell + Copyright (c) 2017 Ivan Kochurkin (upgrade to Java 8) + Copyright (c) 2021 Michał Lorek (upgrade to Java 11) + Copyright (c) 2022 Michał Lorek (upgrade to Java 17) + 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. +*/ + +lexer grammar Java17Lexer; + +// Keywords + +ABSTRACT: 'abstract'; +ASSERT: 'assert'; +BOOLEAN: 'boolean'; +BREAK: 'break'; +BYTE: 'byte'; +CASE: 'case'; +CATCH: 'catch'; +CHAR: 'char'; +CLASS: 'class'; +CONST: 'const'; +CONTINUE: 'continue'; +DEFAULT: 'default'; +DO: 'do'; +DOUBLE: 'double'; +ELSE: 'else'; +ENUM: 'enum'; +EXTENDS: 'extends'; +FINAL: 'final'; +FINALLY: 'finally'; +FLOAT: 'float'; +FOR: 'for'; +IF: 'if'; +GOTO: 'goto'; +IMPLEMENTS: 'implements'; +IMPORT: 'import'; +INSTANCEOF: 'instanceof'; +INT: 'int'; +INTERFACE: 'interface'; +LONG: 'long'; +NATIVE: 'native'; +NEW: 'new'; +PACKAGE: 'package'; +PRIVATE: 'private'; +PROTECTED: 'protected'; +PUBLIC: 'public'; +RETURN: 'return'; +SHORT: 'short'; +STATIC: 'static'; +STRICTFP: 'strictfp'; +SUPER: 'super'; +SWITCH: 'switch'; +SYNCHRONIZED: 'synchronized'; +THIS: 'this'; +THROW: 'throw'; +THROWS: 'throws'; +TRANSIENT: 'transient'; +TRY: 'try'; +VOID: 'void'; +VOLATILE: 'volatile'; +WHILE: 'while'; + +// Module related keywords +MODULE: 'module'; +OPEN: 'open'; +REQUIRES: 'requires'; +EXPORTS: 'exports'; +OPENS: 'opens'; +TO: 'to'; +USES: 'uses'; +PROVIDES: 'provides'; +WITH: 'with'; +TRANSITIVE: 'transitive'; + +// Local Variable Type Inference +VAR: 'var'; // reserved type name + +// Switch Expressions +YIELD: 'yield'; // reserved type name from Java 14 + +// Records +RECORD: 'record'; + +// Sealed Classes +SEALED: 'sealed'; +PERMITS: 'permits'; +NON_SEALED: 'non-sealed'; + +// Literals + +DECIMAL_LITERAL: ('0' | [1-9] (Digits? | '_'+ Digits)) [lL]?; +HEX_LITERAL: '0' [xX] [0-9a-fA-F] ([0-9a-fA-F_]* [0-9a-fA-F])? [lL]?; +OCT_LITERAL: '0' '_'* [0-7] ([0-7_]* [0-7])? [lL]?; +BINARY_LITERAL: '0' [bB] [01] ([01_]* [01])? [lL]?; + +FLOAT_LITERAL: (Digits '.' Digits? | '.' Digits) ExponentPart? [fFdD]? + | Digits (ExponentPart [fFdD]? | [fFdD]) + ; + +HEX_FLOAT_LITERAL: '0' [xX] (HexDigits '.'? | HexDigits? '.' HexDigits) [pP] [+-]? Digits [fFdD]?; + +BOOL_LITERAL: 'true' + | 'false' + ; + +CHAR_LITERAL: '\'' (~['\\\r\n] | EscapeSequence) '\''; + +STRING_LITERAL: '"' (~["\\\r\n] | EscapeSequence)* '"'; + +TEXT_BLOCK: '"""' [ \t]* [\r\n] (. | EscapeSequence)*? '"""'; + +NULL_LITERAL: 'null'; + +// Separators + +LPAREN: '('; +RPAREN: ')'; +LBRACE: '{'; +RBRACE: '}'; +LBRACK: '['; +RBRACK: ']'; +SEMI: ';'; +COMMA: ','; +DOT: '.'; + +// Operators + +ASSIGN: '='; +GT: '>'; +LT: '<'; +BANG: '!'; +TILDE: '~'; +QUESTION: '?'; +COLON: ':'; +EQUAL: '=='; +LE: '<='; +GE: '>='; +NOTEQUAL: '!='; +AND: '&&'; +OR: '||'; +INC: '++'; +DEC: '--'; +ADD: '+'; +SUB: '-'; +MUL: '*'; +DIV: '/'; +BITAND: '&'; +BITOR: '|'; +CARET: '^'; +MOD: '%'; + +ADD_ASSIGN: '+='; +SUB_ASSIGN: '-='; +MUL_ASSIGN: '*='; +DIV_ASSIGN: '/='; +AND_ASSIGN: '&='; +OR_ASSIGN: '|='; +XOR_ASSIGN: '^='; +MOD_ASSIGN: '%='; +LSHIFT_ASSIGN: '<<='; +RSHIFT_ASSIGN: '>>='; +URSHIFT_ASSIGN: '>>>='; + +// Java 8 tokens + +ARROW: '->'; +COLONCOLON: '::'; + +// Additional symbols not defined in the lexical specification + +AT: '@'; +ELLIPSIS: '...'; + +// Whitespace and comments + +WS: [ \t\r\n\u000C]+ -> channel(HIDDEN); +COMMENT: '/*' .*? '*/' -> channel(HIDDEN); +LINE_COMMENT: '//' ~[\r\n]* -> channel(HIDDEN); + +// Identifiers + +IDENTIFIER: Letter LetterOrDigit*; + +// Fragment rules + +fragment ExponentPart + : [eE] [+-]? Digits + ; + +fragment EscapeSequence + : '\\' [btnfr"'\\] + | '\\' ([0-3]? [0-7])? [0-7] + | '\\' 'u'+ HexDigit HexDigit HexDigit HexDigit + ; + +fragment HexDigits + : HexDigit ((HexDigit | '_')* HexDigit)? + ; + +fragment HexDigit + : [0-9a-fA-F] + ; + +fragment Digits + : [0-9] ([0-9_]* [0-9])? + ; + +fragment LetterOrDigit + : Letter + | [0-9] + ; + +fragment Letter + : [a-zA-Z$_] // these are the "java letters" below 0x7F + | ~[\u0000-\u007F\uD800-\uDBFF] // covers all characters above 0x7F which are not a surrogate + | [\uD800-\uDBFF] [\uDC00-\uDFFF] // covers UTF-16 surrogate pairs encodings for U+10000 to U+10FFFF + ; \ No newline at end of file diff --git a/src/main/antlr4/de/dhbwstuttgart/parser/antlr/Java17Parser.g4 b/src/main/antlr4/de/dhbwstuttgart/parser/antlr/Java17Parser.g4 new file mode 100644 index 00000000..70b78141 --- /dev/null +++ b/src/main/antlr4/de/dhbwstuttgart/parser/antlr/Java17Parser.g4 @@ -0,0 +1,767 @@ +/* + [The "BSD licence"] + Copyright (c) 2013 Terence Parr, Sam Harwell + Copyright (c) 2017 Ivan Kochurkin (upgrade to Java 8) + Copyright (c) 2021 Michał Lorek (upgrade to Java 11) + Copyright (c) 2022 Michał Lorek (upgrade to Java 17) + 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. +*/ + +parser grammar Java17Parser; + +options { tokenVocab=Java17Lexer; } + +compilationUnit + : packageDeclaration? importDeclaration* typeDeclaration* + | moduleDeclaration EOF + ; + +packageDeclaration + : annotation* PACKAGE qualifiedName ';' + ; + +importDeclaration + : IMPORT STATIC? qualifiedName ('.' '*')? ';' + ; + +typeDeclaration + : classOrInterfaceModifier* + (classDeclaration | enumDeclaration | interfaceDeclaration | annotationTypeDeclaration | recordDeclaration) + | ';' + ; + +modifier + : classOrInterfaceModifier + | NATIVE + | SYNCHRONIZED + | TRANSIENT + | VOLATILE + ; + +classOrInterfaceModifier + : annotation + | PUBLIC + | PROTECTED + | PRIVATE + | STATIC + | ABSTRACT + | FINAL // FINAL for class only -- does not apply to interfaces + | STRICTFP + | SEALED // Java17 + | NON_SEALED // Java17 + ; + +variableModifier + : FINAL + | annotation + ; + +classDeclaration + : CLASS identifier typeParameters? + (EXTENDS typeType)? + (IMPLEMENTS typeList)? + (PERMITS typeList)? // Java17 + classBody + ; + +typeParameters + : '<' typeParameter (',' typeParameter)* '>' + ; + +typeParameter + : annotation* identifier (EXTENDS annotation* typeBound)? + ; + +typeBound + : typeType ('&' typeType)* + ; + +enumDeclaration + : ENUM identifier (IMPLEMENTS typeList)? '{' enumConstants? ','? enumBodyDeclarations? '}' + ; + +enumConstants + : enumConstant (',' enumConstant)* + ; + +enumConstant + : annotation* identifier arguments? classBody? + ; + +enumBodyDeclarations + : ';' classBodyDeclaration* + ; + +interfaceDeclaration + : INTERFACE identifier typeParameters? (EXTENDS typeList)? (PERMITS typeList)? interfaceBody + ; + +classBody + : '{' classBodyDeclaration* '}' + ; + +interfaceBody + : '{' interfaceBodyDeclaration* '}' + ; + +classBodyDeclaration + : ';' + | STATIC? block + | modifier* memberDeclaration + ; + +memberDeclaration + : recordDeclaration //Java17 + | methodDeclaration + | genericMethodDeclaration + | fieldDeclaration + | constructorDeclaration + | genericConstructorDeclaration + | interfaceDeclaration + | annotationTypeDeclaration + | classDeclaration + | enumDeclaration + ; + +/* We use rule this even for void methods which cannot have [] after parameters. + This simplifies grammar and we can consider void to be a type, which + renders the [] matching as a context-sensitive issue or a semantic check + for invalid return type after parsing. + */ +methodDeclaration + : typeTypeOrVoid identifier formalParameters ('[' ']')* + (THROWS qualifiedNameList)? + methodBody + ; + +methodBody + : block + | ';' + ; + +typeTypeOrVoid + : typeType + | VOID + ; + +genericMethodDeclaration + : typeParameters methodDeclaration + ; + +genericConstructorDeclaration + : typeParameters constructorDeclaration + ; + +constructorDeclaration + : identifier formalParameters (THROWS qualifiedNameList)? constructorBody=block + ; + +fieldDeclaration + : typeType variableDeclarators ';' + ; + +interfaceBodyDeclaration + : modifier* interfaceMemberDeclaration + | ';' + ; + +interfaceMemberDeclaration + : constDeclaration + | interfaceMethodDeclaration + | genericInterfaceMethodDeclaration + | interfaceDeclaration + | annotationTypeDeclaration + | classDeclaration + | enumDeclaration + | recordDeclaration // Java17 + ; + +constDeclaration + : typeType constantDeclarator (',' constantDeclarator)* ';' + ; + +constantDeclarator + : identifier ('[' ']')* '=' variableInitializer + ; + +// Early versions of Java allows brackets after the method name, eg. +// public int[] return2DArray() [] { ... } +// is the same as +// public int[][] return2DArray() { ... } +interfaceMethodDeclaration + : interfaceMethodModifier* interfaceCommonBodyDeclaration + ; + +// Java8 +interfaceMethodModifier + : annotation + | PUBLIC + | ABSTRACT + | DEFAULT + | STATIC + | STRICTFP + ; + +genericInterfaceMethodDeclaration + : interfaceMethodModifier* typeParameters interfaceCommonBodyDeclaration + ; + +interfaceCommonBodyDeclaration + : annotation* typeTypeOrVoid identifier formalParameters ('[' ']')* (THROWS qualifiedNameList)? methodBody + ; + +variableDeclarators + : variableDeclarator (',' variableDeclarator)* + ; + +variableDeclarator + : variableDeclaratorId ('=' variableInitializer)? + ; + +variableDeclaratorId + : identifier ('[' ']')* + ; + +variableInitializer + : arrayInitializer + | expression + ; + +arrayInitializer + : '{' (variableInitializer (',' variableInitializer)* (',')? )? '}' + ; + +classOrInterfaceType + : (identifier typeArguments? '.')* typeIdentifier typeArguments? + ; + +typeArgument + : typeType + | annotation* '?' ((EXTENDS | SUPER) typeType)? + ; + +qualifiedNameList + : qualifiedName (',' qualifiedName)* + ; + +formalParameters + : '(' ( receiverParameter? + | receiverParameter (',' formalParameterList)? + | formalParameterList? + ) ')' + ; + +receiverParameter + : typeType (identifier '.')* THIS + ; + +formalParameterList + : formalParameter (',' formalParameter)* (',' lastFormalParameter)? + | lastFormalParameter + ; + +formalParameter + : variableModifier* typeType variableDeclaratorId + ; + +lastFormalParameter + : variableModifier* typeType annotation* '...' variableDeclaratorId + ; + +// local variable type inference +lambdaLVTIList + : lambdaLVTIParameter (',' lambdaLVTIParameter)* + ; + +lambdaLVTIParameter + : variableModifier* VAR identifier + ; + +qualifiedName + : identifier ('.' identifier)* + ; + +literal + : integerLiteral + | floatLiteral + | CHAR_LITERAL + | STRING_LITERAL + | BOOL_LITERAL + | NULL_LITERAL + | TEXT_BLOCK // Java17 + ; + +integerLiteral + : DECIMAL_LITERAL + | HEX_LITERAL + | OCT_LITERAL + | BINARY_LITERAL + ; + +floatLiteral + : FLOAT_LITERAL + | HEX_FLOAT_LITERAL + ; + +// ANNOTATIONS +altAnnotationQualifiedName + : (identifier DOT)* '@' identifier + ; + +annotation + : ('@' qualifiedName | altAnnotationQualifiedName) ('(' ( elementValuePairs | elementValue )? ')')? + ; + +elementValuePairs + : elementValuePair (',' elementValuePair)* + ; + +elementValuePair + : identifier '=' elementValue + ; + +elementValue + : expression + | annotation + | elementValueArrayInitializer + ; + +elementValueArrayInitializer + : '{' (elementValue (',' elementValue)*)? (',')? '}' + ; + +annotationTypeDeclaration + : '@' INTERFACE identifier annotationTypeBody + ; + +annotationTypeBody + : '{' (annotationTypeElementDeclaration)* '}' + ; + +annotationTypeElementDeclaration + : modifier* annotationTypeElementRest + | ';' // this is not allowed by the grammar, but apparently allowed by the actual compiler + ; + +annotationTypeElementRest + : typeType annotationMethodOrConstantRest ';' + | classDeclaration ';'? + | interfaceDeclaration ';'? + | enumDeclaration ';'? + | annotationTypeDeclaration ';'? + | recordDeclaration ';'? // Java17 + ; + +annotationMethodOrConstantRest + : annotationMethodRest + | annotationConstantRest + ; + +annotationMethodRest + : identifier '(' ')' defaultValue? + ; + +annotationConstantRest + : variableDeclarators + ; + +defaultValue + : DEFAULT elementValue + ; + +// MODULES - Java9 + +moduleDeclaration + : OPEN? MODULE qualifiedName moduleBody + ; + +moduleBody + : '{' moduleDirective* '}' + ; + +moduleDirective + : REQUIRES requiresModifier* qualifiedName ';' + | EXPORTS qualifiedName (TO qualifiedName)? ';' + | OPENS qualifiedName (TO qualifiedName)? ';' + | USES qualifiedName ';' + | PROVIDES qualifiedName WITH qualifiedName ';' + ; + +requiresModifier + : TRANSITIVE + | STATIC + ; + +// RECORDS - Java 17 + +recordDeclaration + : RECORD identifier typeParameters? recordHeader + (IMPLEMENTS typeList)? + recordBody + ; + +recordHeader + : '(' recordComponentList? ')' + ; + +recordComponentList + : recordComponent (',' recordComponent)* + ; + +recordComponent + : typeType identifier + ; + +recordBody + : '{' classBodyDeclaration* '}' + ; + +// STATEMENTS / BLOCKS + +block + : '{' blockStatement* '}' + ; + +blockStatement + : localVariableDeclaration ';' + | localTypeDeclaration + | statement + ; + +localVariableDeclaration + : variableModifier* (VAR identifier '=' expression | typeType variableDeclarators) + ; + +identifier + : IDENTIFIER + | MODULE + | OPEN + | REQUIRES + | EXPORTS + | OPENS + | TO + | USES + | PROVIDES + | WITH + | TRANSITIVE + | YIELD + | SEALED + | PERMITS + | RECORD + | VAR + ; + +typeIdentifier // Identifiers that are not restricted for type declarations + : IDENTIFIER + | MODULE + | OPEN + | REQUIRES + | EXPORTS + | OPENS + | TO + | USES + | PROVIDES + | WITH + | TRANSITIVE + | SEALED + | PERMITS + | RECORD + ; + +localTypeDeclaration + : classOrInterfaceModifier* + (classDeclaration | interfaceDeclaration | recordDeclaration) + | ';' + ; + +statement + : blockLabel=block + | ASSERT expression (':' expression)? ';' + | IF parExpression statement (ELSE statement)? + | FOR '(' forControl ')' statement + | WHILE parExpression statement + | DO statement WHILE parExpression ';' + | TRY block (catchClause+ finallyBlock? | finallyBlock) + | TRY resourceSpecification block catchClause* finallyBlock? + | SWITCH parExpression '{' switchBlockStatementGroup* switchLabel* '}' + | SYNCHRONIZED parExpression block + | RETURN expression? ';' + | THROW expression ';' + | BREAK identifier? ';' + | CONTINUE identifier? ';' + | YIELD expression ';' // Java17 + | SEMI + | statementExpression=expression ';' + | switchExpression ';'? // Java17 + | identifierLabel=identifier ':' statement + ; + +catchClause + : CATCH '(' variableModifier* catchType identifier ')' block + ; + +catchType + : qualifiedName ('|' qualifiedName)* + ; + +finallyBlock + : FINALLY block + ; + +resourceSpecification + : '(' resources ';'? ')' + ; + +resources + : resource (';' resource)* + ; + +resource + : variableModifier* ( classOrInterfaceType variableDeclaratorId | VAR identifier ) '=' expression + | identifier + ; + +/** Matches cases then statements, both of which are mandatory. + * To handle empty cases at the end, we add switchLabel* to statement. + */ +switchBlockStatementGroup + : switchLabel+ blockStatement+ + ; + +switchLabel + : CASE (constantExpression=expression | enumConstantName=IDENTIFIER | typeType varName=identifier) ':' + | DEFAULT ':' + ; + +forControl + : enhancedForControl + | forInit? ';' expression? ';' forUpdate=expressionList? + ; + +forInit + : localVariableDeclaration + | expressionList + ; + +enhancedForControl + : variableModifier* (typeType | VAR) variableDeclaratorId ':' expression + ; + +// EXPRESSIONS + +parExpression + : '(' expression ')' + ; + +expressionList + : expression (',' expression)* + ; + +methodCall + : identifier '(' expressionList? ')' + | THIS '(' expressionList? ')' + | SUPER '(' expressionList? ')' + ; + +expression + : primary + | expression bop='.' + ( + identifier + | methodCall + | THIS + | NEW nonWildcardTypeArguments? innerCreator + | SUPER superSuffix + | explicitGenericInvocation + ) + | expression '[' expression ']' + | methodCall + | NEW creator + | '(' annotation* typeType ('&' typeType)* ')' expression + | expression postfix=('++' | '--') + | prefix=('+'|'-'|'++'|'--') expression + | prefix=('~'|'!') expression + | expression bop=('*'|'/'|'%') expression + | expression bop=('+'|'-') expression + | expression ('<' '<' | '>' '>' '>' | '>' '>') expression + | expression bop=('<=' | '>=' | '>' | '<') expression + | expression bop=INSTANCEOF (typeType | pattern) + | expression bop=('==' | '!=') expression + | expression bop='&' expression + | expression bop='^' expression + | expression bop='|' expression + | expression bop='&&' expression + | expression bop='||' expression + | expression bop='?' expression ':' expression + | expression + bop=('=' | '+=' | '-=' | '*=' | '/=' | '&=' | '|=' | '^=' | '>>=' | '>>>=' | '<<=' | '%=') + expression + | lambdaExpression // Java8 + | switchExpression // Java17 + + // Java 8 methodReference + | expression '::' typeArguments? identifier + | typeType '::' (typeArguments? identifier | NEW) + | classType '::' typeArguments? NEW + ; + +// Java17 +pattern + : variableModifier* typeType annotation* identifier + ; + +// Java8 +lambdaExpression + : lambdaParameters '->' lambdaBody + ; + +// Java8 +lambdaParameters + : identifier + | '(' formalParameterList? ')' + | '(' identifier (',' identifier)* ')' + | '(' lambdaLVTIList? ')' + ; + +// Java8 +lambdaBody + : expression + | block + ; + +primary + : '(' expression ')' + | THIS + | SUPER + | literal + | identifier + | typeTypeOrVoid '.' CLASS + | nonWildcardTypeArguments (explicitGenericInvocationSuffix | THIS arguments) + ; + +// Java17 +switchExpression + : SWITCH parExpression '{' switchLabeledRule* '}' + ; + +// Java17 +switchLabeledRule + : CASE (expressionList | NULL_LITERAL | guardedPattern) (ARROW | COLON) switchRuleOutcome + | DEFAULT (ARROW | COLON) switchRuleOutcome + ; + +// Java17 +guardedPattern + : '(' guardedPattern ')' + | variableModifier* typeType annotation* identifier ('&&' expression)* + | guardedPattern '&&' expression + ; + +// Java17 +switchRuleOutcome + : block + | blockStatement* + ; + +classType + : (classOrInterfaceType '.')? annotation* identifier typeArguments? + ; + +creator + : nonWildcardTypeArguments createdName classCreatorRest + | createdName (arrayCreatorRest | classCreatorRest) + ; + +createdName + : identifier typeArgumentsOrDiamond? ('.' identifier typeArgumentsOrDiamond?)* + | primitiveType + ; + +innerCreator + : identifier nonWildcardTypeArgumentsOrDiamond? classCreatorRest + ; + +arrayCreatorRest + : '[' (']' ('[' ']')* arrayInitializer | expression ']' ('[' expression ']')* ('[' ']')*) + ; + +classCreatorRest + : arguments classBody? + ; + +explicitGenericInvocation + : nonWildcardTypeArguments explicitGenericInvocationSuffix + ; + +typeArgumentsOrDiamond + : '<' '>' + | typeArguments + ; + +nonWildcardTypeArgumentsOrDiamond + : '<' '>' + | nonWildcardTypeArguments + ; + +nonWildcardTypeArguments + : '<' typeList '>' + ; + +typeList + : typeType (',' typeType)* + ; + +typeType + : annotation* (classOrInterfaceType | primitiveType) (annotation* '[' ']')* + ; + +primitiveType + : BOOLEAN + | CHAR + | BYTE + | SHORT + | INT + | LONG + | FLOAT + | DOUBLE + ; + +typeArguments + : '<' typeArgument (',' typeArgument)* '>' + ; + +superSuffix + : arguments + | '.' typeArguments? identifier arguments? + ; + +explicitGenericInvocationSuffix + : SUPER superSuffix + | identifier arguments + ; + +arguments + : '(' expressionList? ')' + ; \ No newline at end of file diff --git a/src/main/antlr4/de/dhbwstuttgart/parser/antlr/Java8.g4 b/src/main/antlr4/de/dhbwstuttgart/parser/antlr/Java8.g4 deleted file mode 100644 index 79ab6543..00000000 --- a/src/main/antlr4/de/dhbwstuttgart/parser/antlr/Java8.g4 +++ /dev/null @@ -1,1878 +0,0 @@ -/* - * [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? - ; - -classTypeList - : classType (',' classType)* - ; - -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 - | recordDeclaration - ; - -normalClassDeclaration - : classModifier* 'class' Identifier typeParameters? superclass? superinterfaces? permittedsubclasses? classBody - ; - -classModifier - : annotation - | 'public' - | 'protected' - | 'private' - | 'abstract' - | 'static' - | 'sealed' - | 'final' - | 'non-sealed' - | 'strictfp' - ; - -typeParameters - : '<' typeParameterList '>' - ; - -typeParameterList - : typeParameter (',' typeParameter)* - ; - -superclass - : 'extends' classType - ; - -superinterfaces - : 'implements' interfaceTypeList - ; - -permittedsubclasses - : 'permits' classTypeList - ; - -interfaceTypeList - : interfaceType (',' interfaceType)* - ; - -classBody - : '{' classBodyDeclaration* '}' - ; - -classBodyDeclaration - : classMemberDeclaration - | instanceInitializer - | staticInitializer -// | constructorDeclaration - ; - -classMemberDeclaration - : fieldDeclaration - | methodDeclaration - | classDeclaration - | interfaceDeclaration - | ';' - ; - -fieldDeclaration - : fieldModifier* unannTypeOrAuto? variableDeclaratorList ';' - ; - -fieldModifier - : annotation - | 'public' - | 'protected' - | 'private' - | 'static' - | 'final' - | 'transient' - | 'volatile' - ; - -variableDeclaratorList - : variableDeclarator (',' variableDeclarator)* - ; - -variableDeclarator - : variableDeclaratorId ('=' variableInitializer)? //auskommentiert, weil variablenDecklaration sonst nicht eindeutig - ; - -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 - ; - -//TODO: weitere erlaubte Modifiert für Variablen aufnehmen (https://www.w3schools.com/java/java_modifiers.asp) -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* - ; - -recordDeclaration - : classModifier* 'record' Identifier typeParameters? recordHeader superinterfaces? recordBody - ; - -recordHeader - : '(' recordComponentList? ')' - ; - -recordComponentList - : recordComponent (',' recordComponent)* - ; - -recordComponent - : annotation* unannType Identifier - | variableArityRecordComponent - ; - -variableArityRecordComponent - : annotation* unannType annotation* '...' Identifier - ; - -recordBody - : '{' recordBodyDeclaration* '}' - ; - -recordBodyDeclaration - : classBodyDeclaration - | compactConstructorDeclaration - ; - -compactConstructorDeclaration - : constructorModifier* simpleTypeName constructorBody - ; - -/* - * 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 ';' - ; - -unannTypeOrAuto - : unannType - | 'var' - ; - -localVariableDeclaration - : variableModifier* unannTypeOrAuto variableDeclaratorList - ; - -statement - : statementWithoutTrailingSubstatement - | labeledStatement - | ifThenStatement - | ifThenElseStatement - | whileStatement - | forStatement - | switchExpression ';'? - ; - -statementNoShortIf - : statementWithoutTrailingSubstatement - | labeledStatementNoShortIf - | ifThenElseStatementNoShortIf - | whileStatementNoShortIf - | forStatementNoShortIf - ; - -statementWithoutTrailingSubstatement - : block - | emptyStatement - | expressionStatement - | assertStatement - | switchStatement - | doStatement - | breakStatement - | yieldStatement - | continueStatement - | returnStatement - | synchronizedStatement - | throwStatement - | tryStatement - ; - -emptyStatement - : ';' - ; - -labeledStatement - : Identifier ':' statement - ; - -labeledStatementNoShortIf - : Identifier ':' statementNoShortIf - ; - -expressionStatement - : statementExpression ';' - ; - -statementExpression - : assignment - | preIncrementExpression - | preDecrementExpression - | postIncrementExpression - | postDecrementExpression - | methodInvocation - | classInstanceCreationExpression - ; - -ifThenStatement - : 'if' '(' expression ')' statement - ; - -ifThenElseStatement - : 'if' parExpression statementNoShortIf 'else' statement - ; - -ifThenElseStatementNoShortIf - : 'if' parExpression statementNoShortIf 'else' statementNoShortIf - ; - -assertStatement - : 'assert' expression ';' - | 'assert' expression ':' expression ';' - ; - -switchStatement - : 'switch' parExpression switchBlock - ; - -switchBlock - : '{' switchBlockStatementGroup* switchLabel* '}' - ; - -switchBlockStatementGroup - : switchLabels blockStatements - ; - -switchLabels - : switchLabel switchLabel* - ; - -switchLabel - : 'case' constantExpression ':' - | 'case' enumConstantName ':' - | 'default' ':' - ; - -switchExpression - : 'switch' parExpression '{' switchLabeledRule* '}' - ; - -switchLabeledRule - : CASE (expressionList | NullLiteral | guardedPattern) (ARROW|COLON) switchRuleOutcome - | DEFAULT (ARROW|COLON) switchRuleOutcome - ; - -guardedPattern - : '(' guardedPattern ')' - | variableModifier* annotation* Identifier ('&&' expression)* - | guardedPattern '&&' expression - ; - -switchRuleOutcome - : block - | blockStatement* - ; - -enumConstantName - : Identifier - ; - -enumConstantNameList - : enumConstantName (',' enumConstantName)* - ; - -whileStatement - : 'while' parExpression statement - ; - -whileStatementNoShortIf - : 'while' parExpression statementNoShortIf - ; - -doStatement - : 'do' statement 'while' parExpression ';' - ; - -forStatement - : basicForStatement - | enhancedForStatement - ; - -forStatementNoShortIf - : basicForStatementNoShortIf - | enhancedForStatementNoShortIf - ; - -basicForStatement - : 'for' '(' forInit? ';' expression? ';' forUpdate? ')' statement - ; - -basicForStatementNoShortIf - : 'for' '(' forInit? ';' expression? ';' forUpdate? ')' statementNoShortIf - ; - -forInit - : statementExpressionList - | localVariableDeclaration - ; - -forUpdate - : statementExpressionList - ; - -statementExpressionList - : statementExpression (',' statementExpression)* - ; - -enhancedForStatement - : 'for' '(' variableModifier* unannType variableDeclaratorId ':' expression ')' statement - ; - -enhancedForStatementNoShortIf - : 'for' '(' variableModifier* unannType variableDeclaratorId ':' expression ')' statementNoShortIf - ; - -breakStatement - : 'break' Identifier? ';' - ; - -yieldStatement - : 'yield' Identifier? ';' - ; - -continueStatement - : 'continue' Identifier? ';' - ; - -returnStatement - : 'return' expression? ';' - ; - -throwStatement - : 'throw' expression ';' - ; - -synchronizedStatement - : 'synchronized' parExpression block - ; - -tryStatement - : 'try' block catches - | 'try' block catches? finally_ - | tryWithResourcesStatement - ; - -catches - : catchClause catchClause* - ; - -catchClause - : 'catch' '(' catchFormalParameter ')' block - ; - -catchFormalParameter - : variableModifier* catchType variableDeclaratorId - ; - -catchType - : unannClassType ('|' classType)* - ; - -finally_ - : 'finally' block - ; - -tryWithResourcesStatement - : 'try' resourceSpecification block catches? finally_? - ; - -resourceSpecification - : '(' resourceList ';'? ')' - ; - -resourceList - : resource (';' resource)* - ; - -resource - : variableModifier* unannType variableDeclaratorId '=' expression - ; - -/* - * Productions from §15 (Expressions) - */ - -primary - : ( primaryNoNewArray_lfno_primary - | arrayCreationExpression - ) - ( primaryNoNewArray_lf_primary - )* - ; - -primaryNoNewArray - : literal - | typeName ('[' ']')* '.' 'class' - | 'void' '.' 'class' - | 'this' - | typeName '.' 'this' - | parExpression - | classInstanceCreationExpression - | fieldAccess - | arrayAccess - | methodInvocation - | methodReference - ; - -primaryNoNewArray_lf_arrayAccess - : - ; - -primaryNoNewArray_lfno_arrayAccess - : literal - | typeName ('[' ']')* '.' 'class' - | 'void' '.' 'class' - | 'this' - | typeName '.' 'this' - | parExpression - | classInstanceCreationExpression - | fieldAccess - | methodInvocation - | methodReference - ; - -primaryNoNewArray_lf_primary - : classInstanceCreationExpression_lf_primary - | fieldAccess_lf_primary - | arrayAccess_lf_primary - | methodInvocation_lf_primary - | methodReference_lf_primary - ; - -primaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary - : - ; - -primaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary - : classInstanceCreationExpression_lf_primary - | fieldAccess_lf_primary - | methodInvocation_lf_primary - | methodReference_lf_primary - ; - -primaryNoNewArray_lfno_primary - : literal //done - | typeName ('[' ']')* '.' 'class' - | unannPrimitiveType ('[' ']')* '.' 'class' - | 'void' '.' 'class' - | 'this' - | typeName '.' 'this' - | parExpression //done - | classInstanceCreationExpression_lfno_primary //done - | fieldAccess_lfno_primary - | arrayAccess_lfno_primary - | methodInvocation_lfno_primary //done - | methodReference_lfno_primary - ; - -primaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary - : - ; - -primaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary - : literal - | typeName ('[' ']')* '.' 'class' - | unannPrimitiveType ('[' ']')* '.' 'class' - | 'void' '.' 'class' - | 'this' - | typeName '.' 'this' - | parExpression - | classInstanceCreationExpression_lfno_primary - | fieldAccess_lfno_primary - | methodInvocation_lfno_primary - | methodReference_lfno_primary - ; - -classInstanceCreationExpression - : 'new' typeArguments? annotation* Identifier ('.' annotation* Identifier)* typeArgumentsOrDiamond? '(' argumentList? ')' classBody? - | expressionName '.' 'new' typeArguments? annotation* Identifier typeArgumentsOrDiamond? '(' argumentList? ')' classBody? - | primary '.' 'new' typeArguments? annotation* Identifier typeArgumentsOrDiamond? '(' argumentList? ')' classBody? - ; - -classInstanceCreationExpression_lf_primary - : '.' 'new' typeArguments? annotation* Identifier typeArgumentsOrDiamond? '(' argumentList? ')' classBody? - ; - -classInstanceCreationExpression_lfno_primary - : 'new' typeArguments? annotation* Identifier ('.' annotation* Identifier)* typeArgumentsOrDiamond? '(' argumentList? ')' classBody? - | expressionName '.' 'new' typeArguments? annotation* Identifier typeArgumentsOrDiamond? '(' argumentList? ')' classBody? - ; - -typeArgumentsOrDiamond - : typeArguments - | '<' '>' - ; - -fieldAccess - : primary '.' Identifier - | 'super' '.' Identifier - | typeName '.' 'super' '.' Identifier - ; - -fieldAccess_lf_primary - : '.' Identifier - ; - -fieldAccess_lfno_primary - : 'super' '.' Identifier - | typeName '.' 'super' '.' Identifier - ; - -arrayAccess - : ( expressionName '[' expression ']' - | primaryNoNewArray_lfno_arrayAccess '[' expression ']' - ) - ( primaryNoNewArray_lf_arrayAccess '[' expression ']' - )* - ; - -arrayAccess_lf_primary - : ( primaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary '[' expression ']' - ) - ( primaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary '[' expression ']' - )* - ; - -arrayAccess_lfno_primary - : ( expressionName '[' expression ']' - | primaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary '[' expression ']' - ) - ( primaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary '[' expression ']' - )* - ; - -methodInvocation - : methodName '(' argumentList? ')' - | typeName '.' typeArguments? Identifier '(' argumentList? ')' - | expressionName '.' typeArguments? Identifier '(' argumentList? ')' - | primary '.' typeArguments? Identifier '(' argumentList? ')' - | 'super' '.' typeArguments? Identifier '(' argumentList? ')' - | typeName '.' 'super' '.' typeArguments? Identifier '(' argumentList? ')' - ; - -methodInvocation_lf_primary - : '.' typeArguments? Identifier '(' argumentList? ')' - ; - -methodInvocation_lfno_primary - : methodName '(' argumentList? ')' - | typeName '.' typeArguments? Identifier '(' argumentList? ')' - | expressionName '.' typeArguments? Identifier '(' argumentList? ')' - | 'super' '.' typeArguments? Identifier '(' argumentList? ')' - | typeName '.' 'super' '.' typeArguments? Identifier '(' argumentList? ')' - ; - -argumentList - : expression (',' expression)* - ; - -methodReference - : expressionName '::' typeArguments? Identifier - | referenceType '::' typeArguments? Identifier - | primary '::' typeArguments? Identifier - | 'super' '::' typeArguments? Identifier - | typeName '.' 'super' '::' typeArguments? Identifier - | classType '::' typeArguments? 'new' - | arrayType '::' 'new' - ; - -methodReference_lf_primary - : '::' typeArguments? Identifier - ; - -methodReference_lfno_primary - : expressionName '::' typeArguments? Identifier - | referenceType '::' typeArguments? Identifier - | 'super' '::' typeArguments? Identifier - | typeName '.' 'super' '::' typeArguments? Identifier - | classType '::' typeArguments? 'new' - | arrayType '::' 'new' - ; - -arrayCreationExpression - : 'new' primitiveType dimExprs dims? - | 'new' classOrInterfaceType dimExprs dims? - | 'new' primitiveType dims arrayInitializer - | 'new' classOrInterfaceType dims arrayInitializer - ; - -dimExprs - : dimExpr dimExpr* - ; - -dimExpr - : annotation* '[' expression ']' - ; - -constantExpression - : expression - ; - -constantExpressionList - : constantExpression (',' constantExpression)* - ; - -expression - : lambdaExpression - | assignmentExpression - | switchExpression - ; - -expressionList - : expression (',' expression)* - ; - -parExpression - : '(' expression ')' - ; - -lambdaExpression - : lambdaParameters '->' lambdaBody - ; - -lambdaParameters - : Identifier - | '(' formalParameterList? ')' - //| '(' inferredFormalParameterList ')' - ; - -inferredFormalParameterList - : Identifier (',' Identifier)* - ; - -lambdaBody - : expression - | block - ; - -assignmentExpression - : conditionalExpression - | assignment - ; - -assignment - : leftHandSide assignmentOperator expression - ; - -leftHandSide - : expressionName - | fieldAccess - | arrayAccess - ; - -assignmentOperator - : '=' - | '*=' - | '/=' - | '%=' - | '+=' - | '-=' - | '<<=' - | '>>=' - | '>>>=' - | '&=' - | '^=' - | '|=' - ; - -conditionalExpression - : conditionalOrExpression - | conditionalOrExpression '?' expression ':' conditionalExpression - ; - -conditionalOrExpression - : conditionalAndExpression - | conditionalOrExpression '||' conditionalAndExpression - ; - -conditionalAndExpression - : inclusiveOrExpression - | conditionalAndExpression '&&' inclusiveOrExpression - ; - -inclusiveOrExpression - : exclusiveOrExpression - | inclusiveOrExpression '|' exclusiveOrExpression - ; - -exclusiveOrExpression - : andExpression - | exclusiveOrExpression '^' andExpression - ; - -andExpression - : equalityExpression - | andExpression '&' equalityExpression - ; - -equalityExpression - : relationalExpression - | equalityExpression '==' relationalExpression - | equalityExpression '!=' relationalExpression - ; - -relationalExpression - : shiftExpression - | relationalExpression '<' shiftExpression - | relationalExpression '>' shiftExpression - | relationalExpression '<=' shiftExpression - | relationalExpression '>=' shiftExpression - | relationalExpression 'instanceof' referenceType - ; - -shiftExpression - : additiveExpression - | shiftExpression '<' '<' additiveExpression - | shiftExpression '>' '>' additiveExpression - | shiftExpression '>' '>' '>' additiveExpression - ; - -additiveExpression - : multiplicativeExpression - | additiveExpression '+' multiplicativeExpression - | additiveExpression '-' multiplicativeExpression - ; - -multiplicativeExpression - : unaryExpression - | multiplicativeExpression '*' unaryExpression - | multiplicativeExpression '/' unaryExpression - | multiplicativeExpression '%' unaryExpression - ; - -unaryExpression - : preIncrementExpression - | preDecrementExpression - | '+' unaryExpression - | '-' unaryExpression - | unaryExpressionNotPlusMinus - ; - -preIncrementExpression - : '++' unaryExpression - ; - -preDecrementExpression - : '--' unaryExpression - ; - -unaryExpressionNotPlusMinus - : postfixExpression - | '~' unaryExpression - | '!' unaryExpression - | castExpression - ; - -postfixExpression - : ( primary - | expressionName - ) - ( postIncrementExpression_lf_postfixExpression - | postDecrementExpression_lf_postfixExpression - )* - ; - -postIncrementExpression - : postfixExpression '++' - ; - -postIncrementExpression_lf_postfixExpression - : '++' - ; - -postDecrementExpression - : postfixExpression '--' - ; - -postDecrementExpression_lf_postfixExpression - : '--' - ; - -castExpression - : '(' primitiveType ')' unaryExpression - | '(' referenceType additionalBound* ')' unaryExpressionNotPlusMinus - | '(' referenceType additionalBound* ')' lambdaExpression - ; - -// Java17 -pattern - : variableModifier* referenceType annotation* Identifier - ; - -// LEXER - -// §3.9 Keywords - -ABSTRACT : 'abstract'; -ASSERT : 'assert'; -BOOLEAN : 'boolean'; -BREAK : 'break'; -BYTE : 'byte'; -CASE : 'case'; -CATCH : 'catch'; -CHAR : 'char'; -CLASS : 'class'; -CONST : 'const'; -CONTINUE : 'continue'; -DEFAULT : 'default'; -DO : 'do'; -DOUBLE : 'double'; -ELSE : 'else'; -ENUM : 'enum'; -EXTENDS : 'extends'; -FINAL : 'final'; -FINALLY : 'finally'; -FLOAT : 'float'; -FOR : 'for'; -IF : 'if'; -GOTO : 'goto'; -IMPLEMENTS : 'implements'; -IMPORT : 'import'; -INSTANCEOF : 'instanceof'; -INT : 'int'; -INTERFACE : 'interface'; -LONG : 'long'; -NATIVE : 'native'; -NEW : 'new'; -PACKAGE : 'package'; -PRIVATE : 'private'; -PROTECTED : 'protected'; -PUBLIC : 'public'; -RETURN : 'return'; -SHORT : 'short'; -STATIC : 'static'; -STRICTFP : 'strictfp'; -SUPER : 'super'; -SWITCH : 'switch'; -SYNCHRONIZED : 'synchronized'; -THIS : 'this'; -THROW : 'throw'; -THROWS : 'throws'; -TRANSIENT : 'transient'; -TRY : 'try'; -VOID : 'void'; -VOLATILE : 'volatile'; -WHILE : 'while'; - -// §3.10.1 Integer Literals - -IntegerLiteral - : DecimalIntegerLiteral - | HexIntegerLiteral - | OctalIntegerLiteral - | BinaryIntegerLiteral - ; - -fragment -DecimalIntegerLiteral - : DecimalNumeral IntegerTypeSuffix? - ; - -fragment -HexIntegerLiteral - : HexNumeral IntegerTypeSuffix? - ; - -fragment -OctalIntegerLiteral - : OctalNumeral IntegerTypeSuffix? - ; - -fragment -BinaryIntegerLiteral - : BinaryNumeral IntegerTypeSuffix? - ; - -fragment -IntegerTypeSuffix - : [lL] - ; - -fragment -DecimalNumeral - : '0' - | NonZeroDigit (Digits? | Underscores Digits) - ; - -fragment -Digits - : Digit (DigitsAndUnderscores? Digit)? - ; - -fragment -Digit - : '0' - | NonZeroDigit - ; - -fragment -NonZeroDigit - : [1-9] - ; - -fragment -DigitsAndUnderscores - : DigitOrUnderscore+ - ; - -fragment -DigitOrUnderscore - : Digit - | '_' - ; - -fragment -Underscores - : '_'+ - ; - -fragment -HexNumeral - : '0' [xX] HexDigits - ; - -fragment -HexDigits - : HexDigit (HexDigitsAndUnderscores? HexDigit)? - ; - -fragment -HexDigit - : [0-9a-fA-F] - ; - -fragment -HexDigitsAndUnderscores - : HexDigitOrUnderscore+ - ; - -fragment -HexDigitOrUnderscore - : HexDigit - | '_' - ; - -fragment -OctalNumeral - : '0' Underscores? OctalDigits - ; - -fragment -OctalDigits - : OctalDigit (OctalDigitsAndUnderscores? OctalDigit)? - ; - -fragment -OctalDigit - : [0-7] - ; - -fragment -OctalDigitsAndUnderscores - : OctalDigitOrUnderscore+ - ; - -fragment -OctalDigitOrUnderscore - : OctalDigit - | '_' - ; - -fragment -BinaryNumeral - : '0' [bB] BinaryDigits - ; - -fragment -BinaryDigits - : BinaryDigit (BinaryDigitsAndUnderscores? BinaryDigit)? - ; - -fragment -BinaryDigit - : [01] - ; - -fragment -BinaryDigitsAndUnderscores - : BinaryDigitOrUnderscore+ - ; - -fragment -BinaryDigitOrUnderscore - : BinaryDigit - | '_' - ; - -// §3.10.2 Floating-Point Literals - -FloatingPointLiteral - : DecimalFloatingPointLiteral - | HexadecimalFloatingPointLiteral - ; - -fragment -DecimalFloatingPointLiteral - : Digits '.' Digits? ExponentPart? FloatTypeSuffix? - | '.' Digits ExponentPart? FloatTypeSuffix? - | Digits ExponentPart FloatTypeSuffix? - | Digits FloatTypeSuffix - ; - -fragment -ExponentPart - : ExponentIndicator SignedInteger - ; - -fragment -ExponentIndicator - : [eE] - ; - -fragment -SignedInteger - : Sign? Digits - ; - -fragment -Sign - : [+-] - ; - -fragment -FloatTypeSuffix - : [fFdD] - ; - -fragment -HexadecimalFloatingPointLiteral - : HexSignificand BinaryExponent FloatTypeSuffix? - ; - -fragment -HexSignificand - : HexNumeral '.'? - | '0' [xX] HexDigits? '.' HexDigits - ; - -fragment -BinaryExponent - : BinaryExponentIndicator SignedInteger - ; - -fragment -BinaryExponentIndicator - : [pP] - ; - -// §3.10.3 Boolean Literals - -BooleanLiteral - : 'true' - | 'false' - ; - -// §3.10.4 Character Literals - -CharacterLiteral - : '\'' SingleCharacter '\'' - | '\'' EscapeSequence '\'' - ; - -fragment -SingleCharacter - : ~['\\] - ; - -// §3.10.5 String Literals - -StringLiteral - : '"' StringCharacters? '"' - ; - -fragment -StringCharacters - : StringCharacter+ - ; - -fragment -StringCharacter - : ~["\\] - | EscapeSequence - ; - -// §3.10.6 Escape Sequences for Character and String Literals - -fragment -EscapeSequence - : '\\' [btnfr"'\\] - | OctalEscape - | UnicodeEscape // This is not in the spec but prevents having to preprocess the input - ; - -fragment -OctalEscape - : '\\' OctalDigit - | '\\' OctalDigit OctalDigit - | '\\' ZeroToThree OctalDigit OctalDigit - ; - -fragment -ZeroToThree - : [0-3] - ; - -// This is not in the spec but prevents having to preprocess the input -fragment -UnicodeEscape - : '\\' 'u' HexDigit HexDigit HexDigit HexDigit - ; - -// §3.10.7 The Null Literal - -NullLiteral - : 'null' - ; - -// §3.11 Separators - -LPAREN : '('; -RPAREN : ')'; -LBRACE : '{'; -RBRACE : '}'; -LBRACK : '['; -RBRACK : ']'; -SEMI : ';'; -COMMA : ','; -DOT : '.'; - -// §3.12 Operators - -ASSIGN : '='; -GT : '>'; -LT : '<'; -BANG : '!'; -TILDE : '~'; -QUESTION : '?'; -COLON : ':'; -EQUAL : '=='; -LE : '<='; -GE : '>='; -NOTEQUAL : '!='; -AND : '&&'; -OR : '||'; -INC : '++'; -DEC : '--'; -ADD : '+'; -SUB : '-'; -MUL : '*'; -DIV : '/'; -BITAND : '&'; -BITOR : '|'; -CARET : '^'; -MOD : '%'; -ARROW : '->'; -COLONCOLON : '::'; - -ADD_ASSIGN : '+='; -SUB_ASSIGN : '-='; -MUL_ASSIGN : '*='; -DIV_ASSIGN : '/='; -AND_ASSIGN : '&='; -OR_ASSIGN : '|='; -XOR_ASSIGN : '^='; -MOD_ASSIGN : '%='; -LSHIFT_ASSIGN : '<<='; -RSHIFT_ASSIGN : '>>='; -URSHIFT_ASSIGN : '>>>='; - -// §3.8 Identifiers (must appear after all keywords in the grammar) - -Identifier - : JavaLetter JavaLetterOrDigit* - ; - -fragment -JavaLetter - : [a-zA-Z$_] // these are the "java letters" below 0x7F - | // covers all characters above 0x7F which are not a surrogate - ~[\u0000-\u007F\uD800-\uDBFF] - {Character.isJavaIdentifierStart(_input.LA(-1))}? - | // covers UTF-16 surrogate pairs encodings for U+10000 to U+10FFFF - [\uD800-\uDBFF] [\uDC00-\uDFFF] - {Character.isJavaIdentifierStart(Character.toCodePoint((char)_input.LA(-2), (char)_input.LA(-1)))}? - ; - -fragment -JavaLetterOrDigit - : [a-zA-Z0-9$_] // these are the "java letters or digits" below 0x7F - | // covers all characters above 0x7F which are not a surrogate - ~[\u0000-\u007F\uD800-\uDBFF] - {Character.isJavaIdentifierPart(_input.LA(-1))}? - | // covers UTF-16 surrogate pairs encodings for U+10000 to U+10FFFF - [\uD800-\uDBFF] [\uDC00-\uDFFF] - {Character.isJavaIdentifierPart(Character.toCodePoint((char)_input.LA(-2), (char)_input.LA(-1)))}? - ; - -// -// Additional symbols not defined in the lexical specification -// - -AT : '@'; -ELLIPSIS : '...'; - -// -// Whitespace and comments -// - -WS : [ \t\r\n\u000C]+ -> skip - ; - -COMMENT - : '/*' .*? '*/' -> skip - ; - -LINE_COMMENT - : '//' ~[\r\n]* -> skip - ;