/** * Make Resources #void, rename ResourceSpecification to ResourceList, * put a LocalVariableDeclaration node inside Resource. * Merge different increment/decrement expressions. * Clément Fournier 07/2019 *==================================================================== * Nest annotations inside the node they apply to. The node TypeBound is * removed. Allow type annotations on InstanceofExpression, MethodReference * and bounds of an IntersectionType. * Clément Fournier 06/2019 *==================================================================== * Change expression, type and annotation grammar to remove unnecessary nodes, * eliminate some inconsistencies, and most importantly have an expressive tree * for primary expressions. Expressions and types now appear to be left-recursive. * This also introduces AmbiguousName, which are pushed only in syntactically * ambiguous contexts: https://docs.oracle.com/javase/specs/jls/se9/html/jls-6.html#jls-6.5.1 * * Those are the first grammar changes for 7.0.0. * Refs: * #1661 [java] About operator nodes * #1367 [java] Parsing error on annotated subclass * #1150 [java] ClassOrInterfaceType AST improvements * #1019 [java] Breaking Java Grammar changes for PMD 7.0.0 * #997 [java] Java8 parsing corner case with annotated array types * #910 [java] AST inconsistency between primitive and reference type arrays * #497 [java] RFC: new layer of abstraction atop PrimaryExpressions * Clément Fournier 04/2019 *==================================================================== * Add support for the yield statement introduced as a preview language * feature with Java 13. See JEP 354. * Add support for text block literals introduces as a preview language * feature with Java 13. See JEP 355. * Andreas Dangel 08/2019 *==================================================================== * Fix #1848 Local classes should preserve their modifiers * Clément Fournier 05/2019 *==================================================================== * Add support for Java 12 switch expressions and switch rules. * Andreas Dangel, Clément Fournier 03/2019 *==================================================================== * Add support for Java 10 Local Variable Type Inference * See #743. In Java 10 mode, "var" as local variable type is handled special. * Andreas Dangel 04/2018 *==================================================================== * Fixes #888 [java] ParseException occurs with valid '<>' in Java 1.8 mode * Juan Martin Sotuyo Dodero 01/2018 *==================================================================== * Fixes #793 [java] Parser error with private method in nested classes in interfaces * Andreas Dangel 12/2017 *==================================================================== * Add support for Java 9 changes: * Private interface methods are only allowed with java9. * A single underscore "_" is an invalid identifier in java9. * Diamond operator for anonymous classes is only allowed with java9. * Add support for module-info.java. * Allow more concise try-with-resources statements with java9. * Andreas Dangel 09/2017 *==================================================================== * Add support for new Java 8 annotation locations. * Bugs #414, #415, #417 * @Snap252 06/2017 *==================================================================== * Allow empty statements (";") between package, import * and type declarations. * Bug #378 * Andreas Dangel 05/2017 *==================================================================== * Allow method references to specify generics also for * constructor references ("new"). * Bug #309 * Andreas Dangel 03/2017 *==================================================================== * Provide a better fix for CastExpression, getting rid of most hacks. * Bug #257 * * Juan Martin Sotuyo Dodero 02/2017 *==================================================================== * Allow local classes to carry more than one annotation. * Bug #208 * * Juan Martin Sotuyo Dodero 01/2017 *==================================================================== * Change lookahead for AnnotationMethodDeclaration in AnnotationTypeMemberDeclaration. * Bug #206 * * Juan Martin Sotuyo Dodero 01/2017 *==================================================================== * Allow method references to specify generics. * Bug #207 * * Juan Martin Sotuyo Dodero 01/2017 *==================================================================== * Simplify VariableDeclaratorId, forbidding illegal sequences such as * this[] and MyClass.this[] * * Juan Martin Sotuyo Dodero 10/2016 *==================================================================== * Improve lambda detection in PrimaryPrefix to improve parsing performance. * * Juan Martin Sotuyo Dodero 10/2016 *==================================================================== * Fix for regression introduced in previous changeset. * The syntactic lookahead was not properly handled by javacc, * so it was converted to a semantic one * Bug #1530 * * Juan Martin Sotuyo Dodero 10/2016 *==================================================================== * Fix for an expression within an additive expression that was * wrongly taken as a cast expression. * Bug #1484 * * Andreas Dangel 05/2016 *==================================================================== * Fix for Lambda expression with one variable * Bug #1470 * * Andreas Dangel 04/2016 *==================================================================== * Added support for explicit receiver parameters. * Bug #1455 * * Andreas Dangel 01/2016 *==================================================================== * Added capability for Tracking Tokens. * * Amit Kumar Prasad 10/2015 *==================================================================== * Fix for Cast Expression not detected properly in Return statements * Bug #1429 * * Andreas Dangel 10/2015 *==================================================================== * Fix for Lambda expressions without variables. * * Andreas Dangel 11/2014 *==================================================================== * Fix for Lambda expressions with two or three variables. * * Andreas Dangel 07/2014 *==================================================================== * Added support for Java 8 language constructs. * * Andreas Dangel 01/2014 * =================================================================== * Fix ForStatement to allow Annotations within the initializer. * * Andreas Dangel 01/2013 * =================================================================== * Fix wrong consumption of modifiers (e.g. "final") in a for-each loop. * Check for wrong java usage when catching multiple exceptions. * * Andreas Dangel 12/2012 * =================================================================== * Enhance grammar to use LocalVariableDeclaration in a for-each loop. * This enhances the symbol table to recognize variables declared in such * a for-each loop. * * Andreas Dangel 10/2012 * =================================================================== * Fix parser problem #3530124 with generics * * Modified the grammar, so that the different usages of generics work. * Adjusted the rules, that use "super", as super is no longer a PrimarySuffix. * It's now either a ExplicitConstructorInvocation or a PrimaryPrefix. * See also test case ParserCornersTest/testParsersCases * * Andreas Dangel 05/2012 * =================================================================== * Added support for Java 7 language constructs * * Dinesh Bolkensteyn (SonarSource), 10/2011 * =================================================================== * Changed the CastLookahead production to use 3 lookaheads for primitive types as suggested by Andreas Dangel * * Brian Remedios 07/2011 * =================================================================== * Added in support for assert as a name using lookaheads * * Tom Copeland, 09/03 * =================================================================== * Copied over the changes made by Andrea Gini and Marco Savard to * support JDK 1.4 language constructs, i.e., asserts. * See the java1_4c.jj distributed in the javacc2.1/examples/JavaGrammers directory. * Made numerous other modifications to support PMD. * * Tom Copeland, 6/02 * =================================================================== * This file is a modified version of one originally found in the * VTransformer Examples directory of JavaCC1_1. It has been * modified to accept Java source code for Java 1.2. Basically, * this means a new key word was added, 'strictfp', and that keyword * added to the appropriate productions and LOOKAHEADs (where other, * similar keywords are listed as possible choices). This involved * changing 11 lines. * * Some other minor changes were made, which can be found by doing * a search on 'DW, 7/99'. * * The goal of this effort was for the grammar to be able to parse * any legal Java 1.2 source code. It does not reject all illegal * cases, but neither did the original. Plus, when it comes to * the new 'strictfp' keyword, the Java Compiler from Sun (JDK1.2.1) * also does not reject all illegal cases, as defined by the * "Updates" document found at * http://java.sun.com/docs/books/jls/strictfp-changes.pdf * (see the testcases.txt file for details). * * David Williams, 7/99 * =================================================================== * * * Copyright (C) 1996, 1997 Sun Microsystems Inc. * * Use of this file and the system it is part of is constrained by the * file COPYRIGHT in the root directory of this system. You may, however, * make any modifications you wish to this file. * * Java files generated by running JavaCC on this file (or modified versions * of this file) may be used in exactly the same manner as Java files * generated from any grammar developed by you. * * Author: Sriram Sankar * Date: 3/5/97 * * This file contains a Java grammar and actions that implement a front-end. */ options { JAVA_UNICODE_ESCAPE = true; CACHE_TOKENS = true; STATIC = false; USER_CHAR_STREAM = true; JDK_VERSION = "1.5"; MULTI = true; VISITOR = true; NODE_USES_PARSER = true; TRACK_TOKENS = true; NODE_PACKAGE="net.sourceforge.pmd.lang.java.ast"; //DEBUG_PARSER = true; //DEBUG_LOOKAHEAD = true; //DEBUG_TOKEN_MANAGER = true; } PARSER_BEGIN(JavaParser) package net.sourceforge.pmd.lang.java.ast; import java.util.ArrayList; import java.util.List; import java.util.Map; import net.sourceforge.pmd.lang.ast.CharStream; import net.sourceforge.pmd.lang.ast.TokenMgrError; import net.sourceforge.pmd.lang.ast.Node; public class JavaParser { private int jdkVersion = 0; private boolean preview = false; public void setJdkVersion(int jdkVersion) { this.jdkVersion = jdkVersion; } public void setPreview(boolean preview) { this.preview = preview; } private void throwParseException(String message) { int line = -1; int col = -1; if (jj_lastpos != null) { line = jj_lastpos.beginLine; col = jj_lastpos.beginColumn; } throw new ParseException("Line " + line + ", Column " + col + ": " + message); } private void checkForBadAssertUsage(String in, String usage) { if (jdkVersion > 3 && in.equals("assert")) { throwParseException("Can't use 'assert' as " + usage + " when running in JDK 1.4 mode!"); } } private void checkForBadStaticImportUsage() { if (jdkVersion < 5) { throwParseException("Can't use static imports when running in JDK 1.4 mode!"); } } private void checkForBadAnnotationUsage() { if (jdkVersion < 5) { throwParseException("Can't use annotations when running in JDK 1.4 mode!"); } } private void checkForBadGenericsUsage() { if (jdkVersion < 5) { throwParseException("Can't use generics unless running in JDK 1.5 mode!"); } } private void checkForBadVariableArgumentsUsage() { if (jdkVersion < 5) { throwParseException("Can't use variable arguments (varargs) when running in JDK 1.4 mode!"); } } private void checkForBadJDK15ForLoopSyntaxArgumentsUsage() { if (jdkVersion < 5) { throwParseException("Can't use JDK 1.5 for loop syntax when running in JDK 1.4 mode!"); } } private void checkForBadEnumUsage(String in, String usage) { if (jdkVersion >= 5 && in.equals("enum")) { throwParseException("Can't use 'enum' as " + usage + " when running in JDK 1.5 mode!"); } } private void checkForBadHexFloatingPointLiteral() { if (jdkVersion < 5) { throwParseException("Can't use hexadecimal floating point literals in pre-JDK 1.5 target"); } } private void checkForBadNumericalLiteralslUsage(Token token) { if (jdkVersion < 7) { if (token.image.contains("_")) { throwParseException("Can't use underscores in numerical literals when running in JDK inferior to 1.7 mode!"); } if (token.image.startsWith("0b") || token.image.startsWith("0B")) { throwParseException("Can't use binary numerical literals when running in JDK inferior to 1.7 mode!"); } } } private void checkForBadDiamondUsage() { if (jdkVersion < 7) { throwParseException("Cannot use the diamond generic notation when running in JDK inferior to 1.7 mode!"); } } private void checkForBadTryWithResourcesUsage() { if (jdkVersion < 7) { throwParseException("Cannot use the try-with-resources notation when running in JDK inferior to 1.7 mode!"); } } private void checkForBadMultipleExceptionsCatching() { if (jdkVersion < 7) { throwParseException("Cannot catch multiple exceptions when running in JDK inferior to 1.7 mode!"); } } private void checkForBadLambdaUsage() { if (jdkVersion < 8) { throwParseException("Cannot use lambda expressions when running in JDK inferior to 1.8 mode!"); } } private void checkForBadMethodReferenceUsage() { if (jdkVersion < 8) { throwParseException("Cannot use method references when running in JDK inferior to 1.8 mode!"); } } private void checkForBadDefaultImplementationUsage() { if (jdkVersion < 8) { throwParseException("Cannot use default implementations in interfaces when running in JDK inferior to 1.8 mode!"); } } private void checkForBadIntersectionTypesInCasts() { if (jdkVersion < 8) { throwParseException("Cannot use intersection types in casts when running in JDK inferior to 1.8 mode!"); } } private void checkForBadTypeAnnotations() { if (jdkVersion < 8) { throwParseException("Cannot use type annotations when running in JDK inferior to 1.8 mode!"); } } private void checkforBadExplicitReceiverParameter() { if (jdkVersion < 8) { throwParseException("Cannot use explicit receiver parameters when running in JDK inferior to 1.8 mode!"); } } private void checkForBadAnonymousDiamondUsage() { if (jdkVersion < 9) { Node node = jjtree.peekNode(); if (node instanceof ASTConstructorCall) { ASTConstructorCall expr = (ASTConstructorCall) node; ASTTypeArguments types = expr.getTypeNode().getTypeArguments(); if (expr.isAnonymousClass() && types != null && types.isDiamond()) { throwParseException("Cannot use '<>' with anonymous inner classes when running in JDK inferior to 9 mode!"); } } } } /** * Keeps track whether we are dealing with an interface or not. Needed since the tree is * is not fully constructed yet, when we check for private interface methods. * The flag is updated, if entering ClassOrInterfaceDeclaration and reset when leaving. * The flag is also reset, if entering a anonymous inner class or enums. */ private boolean inInterface = false; private void checkForBadPrivateInterfaceMethod(ASTMethodDeclaration node) { if (jdkVersion < 9 && inInterface && node.isPrivate()) { throwParseException("Cannot use private interface methods when running in JDK inferior to 9 mode!"); } } private void checkForBadIdentifier(String image) { if (jdkVersion >= 9 && "_".equals(image)) { throwParseException("With JDK 9, '_' is a keyword, and may not be used as an identifier!"); } } private void checkForBadModuleUsage() { if (jdkVersion < 9) { throwParseException("Cannot use module declaration when running in JDK inferior to 9 mode!"); } } private void checkForBadConciseTryWithResourcesUsage() { Node top = jjtree.peekNode(); if (!(top instanceof ASTFieldAccess || top instanceof ASTVariableAccess)) { throwParseException("Expected a variable access, but was a " + top.getXPathNodeName()); } if (jdkVersion < 9) { throwParseException("Cannot use concise try-with-resources when running in JDK inferior to 9 mode!"); } } private void checkForBadTypeIdentifierUsage(String image) { if (jdkVersion >= 10 && "var".equals(image)) { throwParseException("With JDK 10, 'var' is a restricted local variable type and cannot be used for type declarations!"); } } private void checkForMultipleCaseLabels() { if ((jdkVersion != 12 && jdkVersion != 13) || !preview) { throwParseException("Multiple case labels in switch statements are only supported with Java 12 or 13 Preview"); } } /** * Keeps track during tree construction, whether we are currently building a switch label. * A switch label must not contain a LambdaExpression. * Unfortunately, we have added LambdaExpression as part of PrimaryPrefix, which is wrong. * To keep compatibility, this flag is used, whether a LambdaExpression should be parsed * in PrimaryPrefix. * See also comment at #Expression(). */ private boolean inSwitchLabel = false; private void checkForSwitchRules() { if ((jdkVersion != 12 && jdkVersion != 13) || !preview) { throwParseException("Switch rules in switch statements are only supported with Java 12 or 13 Preview"); } } private void checkForSwitchExpression() { if ((jdkVersion != 12 && jdkVersion != 13) || !preview) { throwParseException("Switch expressions are only supported with Java 12 or 13 Preview"); } } private void checkForBreakExpression() { if (jdkVersion != 12 || !preview) { throwParseException("Expressions in break statements are only supported with Java 12 Preview"); } } private void checkForYieldStatement() { if (jdkVersion != 13 || !preview) { throwParseException("Yield statements are only supported with Java 13 Preview"); } } private void checkForTextBlockLiteral() { if (jdkVersion != 13 || !preview) { throwParseException("Text block literals are only supported with Java 13 Preview"); } } // This is a semantic LOOKAHEAD to determine if we're dealing with an assert // Note that this can't be replaced with a syntactic lookahead // since "assert" isn't a string literal token private boolean isNextTokenAnAssert() { if (jdkVersion <= 3) { return false; } return getToken(1).image.equals("assert"); } private boolean isPrecededByComment(Token tok) { boolean res = false; while (!res && tok.specialToken != null) { tok = tok.specialToken; res = tok.kind == SINGLE_LINE_COMMENT || tok.kind == FORMAL_COMMENT || tok.kind == MULTI_LINE_COMMENT; } return res; } /** * Semantic lookahead to check if the next identifier is a * specific restricted keyword. */ private boolean isKeyword(String keyword) { return getToken(1).kind == IDENTIFIER && getToken(1).image.equals(keyword); } private boolean shouldStartStatementInSwitch() { switch (getToken(1).kind) { case _DEFAULT: case CASE: case RBRACE: return false; default: return true; } } public Map getSuppressMap() { return token_source.getSuppressMap(); } public void setSuppressMarker(String marker) { token_source.setSuppressMarker(marker); } private void setLastTokenImage(JavaNode node) { node.setImage(getToken(0).getImage()); } private void forceExprContext() { Node top = jjtree.peekNode(); if (top instanceof ASTAmbiguousName) { // see doc on the method Node replacement = ((ASTAmbiguousName) top).forceExprContext(); jjtree.popNode(); jjtree.pushNode(replacement); } } private void forceTypeContext() { Node top = jjtree.peekNode(); if (top instanceof ASTAmbiguousName) { // see doc on the method Node replacement = ((ASTAmbiguousName) top).forceTypeContext(); jjtree.popNode(); jjtree.pushNode(replacement); } } // make the top node the last child of the second node on the stack // If the stack ends with ..[A][B], then it becomes ..[A[B]] private void injectTop() { AbstractJavaNode top = (AbstractJavaNode) jjtree.popNode(); AbstractJavaNode prev = (AbstractJavaNode) jjtree.peekNode(); prev.jjtAddChild(top, prev.jjtGetNumChildren()); prev.jjtSetLastToken(top.jjtGetLastToken()); } /** * Keeps track during tree construction, whether we are currently building an * explicit constructor invocation. Then the PrimaryExpression that may prefix * a qualified super constructor call may not consume "super" tokens. */ private boolean inExplicitConstructorInvoc = false; } PARSER_END(JavaParser) TOKEN_MGR_DECLS : { protected List comments = new ArrayList(); } /* WHITE SPACE */ SPECIAL_TOKEN : { // those are private, just for code organisation < #HORIZONTAL_WHITESPACE: [" ", "\t", "\f"] > | < #LINE_TERMINATOR: "\n" | "\r" | "\r\n" > // this one is pushed, notice the (..)+ construct, to avoid // creating one token per character | < WHITESPACE: ([" ", "\t", "\f", "\n", "\r"])+ > } /* COMMENTS */ SPECIAL_TOKEN : { < SINGLE_LINE_COMMENT: "//"(~["\n","\r"])* ("\n"|"\r"|"\r\n")? > { int startOfNOPMD = matchedToken.image.indexOf(suppressMarker); if (startOfNOPMD != -1) { suppressMap.put(matchedToken.beginLine, matchedToken.image.substring(startOfNOPMD + suppressMarker.length())); } comments.add(new SingleLineComment(matchedToken)); } } MORE : { <"/**" ~["/"]> { input_stream.backup(1); } : IN_FORMAL_COMMENT | "/*" : IN_MULTI_LINE_COMMENT } SPECIAL_TOKEN : { { comments.add(new FormalComment(matchedToken)); } : DEFAULT } SPECIAL_TOKEN : { { comments.add(new MultiLineComment(matchedToken)); } : DEFAULT } MORE : { < ~[] > } /* RESERVED WORDS AND LITERALS */ TOKEN : { < ABSTRACT: "abstract" > | < 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" > | < EXTENDS: "extends" > | < FALSE: "false" > | < FINAL: "final" > | < FINALLY: "finally" > | < FLOAT: "float" > | < FOR: "for" > | < GOTO: "goto" > | < IF: "if" > | < IMPLEMENTS: "implements" > | < IMPORT: "import" > | < INSTANCEOF: "instanceof" > | < INT: "int" > | < INTERFACE: "interface" > | < LONG: "long" > | < NATIVE: "native" > | < NEW: "new" > | < NULL: "null" > | < PACKAGE: "package"> | < PRIVATE: "private" > | < PROTECTED: "protected" > | < PUBLIC: "public" > | < RETURN: "return" > | < SHORT: "short" > | < STATIC: "static" > | < SUPER: "super" > | < SWITCH: "switch" > | < SYNCHRONIZED: "synchronized" > | < THIS: "this" > | < THROW: "throw" > | < THROWS: "throws" > | < TRANSIENT: "transient" > | < TRUE: "true" > | < TRY: "try" > | < VOID: "void" > | < VOLATILE: "volatile" > | < WHILE: "while" > | < STRICTFP: "strictfp" > } /* Restricted Keywords */ // Note: These are commented out, since these keywords // can still be used as identifiers. // see isKeyword() semantic lookup /* TOKEN : { < OPEN: "open" > | < MODULE: "module" > | < REQUIRES: "requires" > | < TRANSITIVE: "transitive" > | < EXPORTS: "exports" > | < OPENS: "opens" > | < TO: "to" > | < USES: "uses" > | < PROVIDES: "provides" > | < WITH: "with" > } */ /* LITERALS */ TOKEN : { < INTEGER_LITERAL: (["l","L"])? | (["l","L"])? | (["l","L"])? | (["l","L"])? > | < #DECIMAL_LITERAL: (["0"-"9"]((["0"-"9","_"])*["0"-"9"])?) > | < #HEX_LITERAL: "0" ["x","X"] (["0"-"9","a"-"f","A"-"F"]((["0"-"9","a"-"f","A"-"F","_"])*["0"-"9","a"-"f","A"-"F"])?) > | < #BINARY_LITERAL: "0" ["b","B"] (["0","1"]((["0","1","_"])*["0","1"])?) > | < #OCTAL_LITERAL: "0" (["0"-"7"]((["0"-"7","_"])*["0"-"7"])?) > | < FLOATING_POINT_LITERAL: (["0"-"9"]((["0"-"9","_"])*["0"-"9"])?) "." (["0"-"9"]((["0"-"9","_"])*["0"-"9"])?)? ()? (["f","F","d","D"])? | "." (["0"-"9"]((["0"-"9","_"])*["0"-"9"])?) ()? (["f","F","d","D"])? | (["0"-"9"]((["0"-"9","_"])*["0"-"9"])?) (["f","F","d","D"])? | (["0"-"9"]((["0"-"9","_"])*["0"-"9"])?) ()? ["f","F","d","D"] > | < HEX_FLOATING_POINT_LITERAL: ( (".")? | "0" ["x","X"] (["0"-"9","a"-"f","A"-"F"]((["0"-"9","a"-"f","A"-"F","_"])*["0"-"9","a"-"f","A"-"F"])?)? "." (["0"-"9","a"-"f","A"-"F"]((["0"-"9","a"-"f","A"-"F","_"])*["0"-"9","a"-"f","A"-"F"])?)) ["p","P"] (["+","-"])? (["0"-"9"]((["0"-"9","_"])*["0"-"9"])?) (["f","F","d","D"])? > | < #EXPONENT: ["e","E"] (["+","-"])? (["0"-"9"]((["0"-"9","_"])*["0"-"9"])?) > | < CHARACTER_LITERAL: "'" ( (~["'","\\","\n","\r"]) | ("\\" ( ["n","t","b","r","f","\\","'","\""] | ["0"-"7"] ( ["0"-"7"] )? | ["0"-"3"] ["0"-"7"] ["0"-"7"] ) ) ) "'" > | < #STRING_ESCAPE: "\\" ( ["n","t","b","r","f","\\","'","\""] // octal escapes | ["0"-"7"] ( ["0"-"7"] )? | ["0"-"3"] ["0"-"7"] ["0"-"7"] ) > | < STRING_LITERAL: "\"" ( (~["\"","\\","\n","\r"]) | )* "\"" > | < TEXT_BLOCK_LITERAL: "\"\"\"" ()* ( ~["\"", "\\"] | "\"" ~["\""] | "\"\"" ~["\""] | )* "\"\"\"" > } /* IDENTIFIERS */ TOKEN : { < IDENTIFIER: ()* > | < #LETTER: [ // all chars for which Character.isJavaIdentifierStart is true "$", "A"-"Z", "_", "a"-"z", "\u00a2"-"\u00a5", "\u00aa", "\u00b5", "\u00ba", "\u00c0"-"\u00d6", "\u00d8"-"\u00f6", "\u00f8"-"\u02c1", "\u02c6"-"\u02d1", "\u02e0"-"\u02e4", "\u02ec", "\u02ee", "\u0370"-"\u0374", "\u0376"-"\u0377", "\u037a"-"\u037d", "\u037f", "\u0386", "\u0388"-"\u038a", "\u038c", "\u038e"-"\u03a1", "\u03a3"-"\u03f5", "\u03f7"-"\u0481", "\u048a"-"\u052f", "\u0531"-"\u0556", "\u0559", "\u0561"-"\u0587", "\u058f", "\u05d0"-"\u05ea", "\u05f0"-"\u05f2", "\u060b", "\u0620"-"\u064a", "\u066e"-"\u066f", "\u0671"-"\u06d3", "\u06d5", "\u06e5"-"\u06e6", "\u06ee"-"\u06ef", "\u06fa"-"\u06fc", "\u06ff", "\u0710", "\u0712"-"\u072f", "\u074d"-"\u07a5", "\u07b1", "\u07ca"-"\u07ea", "\u07f4"-"\u07f5", "\u07fa", "\u0800"-"\u0815", "\u081a", "\u0824", "\u0828", "\u0840"-"\u0858", "\u08a0"-"\u08b4", "\u0904"-"\u0939", "\u093d", "\u0950", "\u0958"-"\u0961", "\u0971"-"\u0980", "\u0985"-"\u098c", "\u098f"-"\u0990", "\u0993"-"\u09a8", "\u09aa"-"\u09b0", "\u09b2", "\u09b6"-"\u09b9", "\u09bd", "\u09ce", "\u09dc"-"\u09dd", "\u09df"-"\u09e1", "\u09f0"-"\u09f3", "\u09fb", "\u0a05"-"\u0a0a", "\u0a0f"-"\u0a10", "\u0a13"-"\u0a28", "\u0a2a"-"\u0a30", "\u0a32"-"\u0a33", "\u0a35"-"\u0a36", "\u0a38"-"\u0a39", "\u0a59"-"\u0a5c", "\u0a5e", "\u0a72"-"\u0a74", "\u0a85"-"\u0a8d", "\u0a8f"-"\u0a91", "\u0a93"-"\u0aa8", "\u0aaa"-"\u0ab0", "\u0ab2"-"\u0ab3", "\u0ab5"-"\u0ab9", "\u0abd", "\u0ad0", "\u0ae0"-"\u0ae1", "\u0af1", "\u0af9", "\u0b05"-"\u0b0c", "\u0b0f"-"\u0b10", "\u0b13"-"\u0b28", "\u0b2a"-"\u0b30", "\u0b32"-"\u0b33", "\u0b35"-"\u0b39", "\u0b3d", "\u0b5c"-"\u0b5d", "\u0b5f"-"\u0b61", "\u0b71", "\u0b83", "\u0b85"-"\u0b8a", "\u0b8e"-"\u0b90", "\u0b92"-"\u0b95", "\u0b99"-"\u0b9a", "\u0b9c", "\u0b9e"-"\u0b9f", "\u0ba3"-"\u0ba4", "\u0ba8"-"\u0baa", "\u0bae"-"\u0bb9", "\u0bd0", "\u0bf9", "\u0c05"-"\u0c0c", "\u0c0e"-"\u0c10", "\u0c12"-"\u0c28", "\u0c2a"-"\u0c39", "\u0c3d", "\u0c58"-"\u0c5a", "\u0c60"-"\u0c61", "\u0c85"-"\u0c8c", "\u0c8e"-"\u0c90", "\u0c92"-"\u0ca8", "\u0caa"-"\u0cb3", "\u0cb5"-"\u0cb9", "\u0cbd", "\u0cde", "\u0ce0"-"\u0ce1", "\u0cf1"-"\u0cf2", "\u0d05"-"\u0d0c", "\u0d0e"-"\u0d10", "\u0d12"-"\u0d3a", "\u0d3d", "\u0d4e", "\u0d5f"-"\u0d61", "\u0d7a"-"\u0d7f", "\u0d85"-"\u0d96", "\u0d9a"-"\u0db1", "\u0db3"-"\u0dbb", "\u0dbd", "\u0dc0"-"\u0dc6", "\u0e01"-"\u0e30", "\u0e32"-"\u0e33", "\u0e3f"-"\u0e46", "\u0e81"-"\u0e82", "\u0e84", "\u0e87"-"\u0e88", "\u0e8a", "\u0e8d", "\u0e94"-"\u0e97", "\u0e99"-"\u0e9f", "\u0ea1"-"\u0ea3", "\u0ea5", "\u0ea7", "\u0eaa"-"\u0eab", "\u0ead"-"\u0eb0", "\u0eb2"-"\u0eb3", "\u0ebd", "\u0ec0"-"\u0ec4", "\u0ec6", "\u0edc"-"\u0edf", "\u0f00", "\u0f40"-"\u0f47", "\u0f49"-"\u0f6c", "\u0f88"-"\u0f8c", "\u1000"-"\u102a", "\u103f", "\u1050"-"\u1055", "\u105a"-"\u105d", "\u1061", "\u1065"-"\u1066", "\u106e"-"\u1070", "\u1075"-"\u1081", "\u108e", "\u10a0"-"\u10c5", "\u10c7", "\u10cd", "\u10d0"-"\u10fa", "\u10fc"-"\u1248", "\u124a"-"\u124d", "\u1250"-"\u1256", "\u1258", "\u125a"-"\u125d", "\u1260"-"\u1288", "\u128a"-"\u128d", "\u1290"-"\u12b0", "\u12b2"-"\u12b5", "\u12b8"-"\u12be", "\u12c0", "\u12c2"-"\u12c5", "\u12c8"-"\u12d6", "\u12d8"-"\u1310", "\u1312"-"\u1315", "\u1318"-"\u135a", "\u1380"-"\u138f", "\u13a0"-"\u13f5", "\u13f8"-"\u13fd", "\u1401"-"\u166c", "\u166f"-"\u167f", "\u1681"-"\u169a", "\u16a0"-"\u16ea", "\u16ee"-"\u16f8", "\u1700"-"\u170c", "\u170e"-"\u1711", "\u1720"-"\u1731", "\u1740"-"\u1751", "\u1760"-"\u176c", "\u176e"-"\u1770", "\u1780"-"\u17b3", "\u17d7", "\u17db"-"\u17dc", "\u1820"-"\u1877", "\u1880"-"\u18a8", "\u18aa", "\u18b0"-"\u18f5", "\u1900"-"\u191e", "\u1950"-"\u196d", "\u1970"-"\u1974", "\u1980"-"\u19ab", "\u19b0"-"\u19c9", "\u1a00"-"\u1a16", "\u1a20"-"\u1a54", "\u1aa7", "\u1b05"-"\u1b33", "\u1b45"-"\u1b4b", "\u1b83"-"\u1ba0", "\u1bae"-"\u1baf", "\u1bba"-"\u1be5", "\u1c00"-"\u1c23", "\u1c4d"-"\u1c4f", "\u1c5a"-"\u1c7d", "\u1ce9"-"\u1cec", "\u1cee"-"\u1cf1", "\u1cf5"-"\u1cf6", "\u1d00"-"\u1dbf", "\u1e00"-"\u1f15", "\u1f18"-"\u1f1d", "\u1f20"-"\u1f45", "\u1f48"-"\u1f4d", "\u1f50"-"\u1f57", "\u1f59", "\u1f5b", "\u1f5d", "\u1f5f"-"\u1f7d", "\u1f80"-"\u1fb4", "\u1fb6"-"\u1fbc", "\u1fbe", "\u1fc2"-"\u1fc4", "\u1fc6"-"\u1fcc", "\u1fd0"-"\u1fd3", "\u1fd6"-"\u1fdb", "\u1fe0"-"\u1fec", "\u1ff2"-"\u1ff4", "\u1ff6"-"\u1ffc", "\u203f"-"\u2040", "\u2054", "\u2071", "\u207f", "\u2090"-"\u209c", "\u20a0"-"\u20be", "\u2102", "\u2107", "\u210a"-"\u2113", "\u2115", "\u2119"-"\u211d", "\u2124", "\u2126", "\u2128", "\u212a"-"\u212d", "\u212f"-"\u2139", "\u213c"-"\u213f", "\u2145"-"\u2149", "\u214e", "\u2160"-"\u2188", "\u2c00"-"\u2c2e", "\u2c30"-"\u2c5e", "\u2c60"-"\u2ce4", "\u2ceb"-"\u2cee", "\u2cf2"-"\u2cf3", "\u2d00"-"\u2d25", "\u2d27", "\u2d2d", "\u2d30"-"\u2d67", "\u2d6f", "\u2d80"-"\u2d96", "\u2da0"-"\u2da6", "\u2da8"-"\u2dae", "\u2db0"-"\u2db6", "\u2db8"-"\u2dbe", "\u2dc0"-"\u2dc6", "\u2dc8"-"\u2dce", "\u2dd0"-"\u2dd6", "\u2dd8"-"\u2dde", "\u2e2f", "\u3005"-"\u3007", "\u3021"-"\u3029", "\u3031"-"\u3035", "\u3038"-"\u303c", "\u3041"-"\u3096", "\u309d"-"\u309f", "\u30a1"-"\u30fa", "\u30fc"-"\u30ff", "\u3105"-"\u312d", "\u3131"-"\u318e", "\u31a0"-"\u31ba", "\u31f0"-"\u31ff", "\u3400"-"\u4db5", "\u4e00"-"\u9fd5", "\ua000"-"\ua48c", "\ua4d0"-"\ua4fd", "\ua500"-"\ua60c", "\ua610"-"\ua61f", "\ua62a"-"\ua62b", "\ua640"-"\ua66e", "\ua67f"-"\ua69d", "\ua6a0"-"\ua6ef", "\ua717"-"\ua71f", "\ua722"-"\ua788", "\ua78b"-"\ua7ad", "\ua7b0"-"\ua7b7", "\ua7f7"-"\ua801", "\ua803"-"\ua805", "\ua807"-"\ua80a", "\ua80c"-"\ua822", "\ua838", "\ua840"-"\ua873", "\ua882"-"\ua8b3", "\ua8f2"-"\ua8f7", "\ua8fb", "\ua8fd", "\ua90a"-"\ua925", "\ua930"-"\ua946", "\ua960"-"\ua97c", "\ua984"-"\ua9b2", "\ua9cf", "\ua9e0"-"\ua9e4", "\ua9e6"-"\ua9ef", "\ua9fa"-"\ua9fe", "\uaa00"-"\uaa28", "\uaa40"-"\uaa42", "\uaa44"-"\uaa4b", "\uaa60"-"\uaa76", "\uaa7a", "\uaa7e"-"\uaaaf", "\uaab1", "\uaab5"-"\uaab6", "\uaab9"-"\uaabd", "\uaac0", "\uaac2", "\uaadb"-"\uaadd", "\uaae0"-"\uaaea", "\uaaf2"-"\uaaf4", "\uab01"-"\uab06", "\uab09"-"\uab0e", "\uab11"-"\uab16", "\uab20"-"\uab26", "\uab28"-"\uab2e", "\uab30"-"\uab5a", "\uab5c"-"\uab65", "\uab70"-"\uabe2", "\uac00"-"\ud7a3", "\ud7b0"-"\ud7c6", "\ud7cb"-"\ud7fb", "\uf900"-"\ufa6d", "\ufa70"-"\ufad9", "\ufb00"-"\ufb06", "\ufb13"-"\ufb17", "\ufb1d", "\ufb1f"-"\ufb28", "\ufb2a"-"\ufb36", "\ufb38"-"\ufb3c", "\ufb3e", "\ufb40"-"\ufb41", "\ufb43"-"\ufb44", "\ufb46"-"\ufbb1", "\ufbd3"-"\ufd3d", "\ufd50"-"\ufd8f", "\ufd92"-"\ufdc7", "\ufdf0"-"\ufdfc", "\ufe33"-"\ufe34", "\ufe4d"-"\ufe4f", "\ufe69", "\ufe70"-"\ufe74", "\ufe76"-"\ufefc", "\uff04", "\uff21"-"\uff3a", "\uff3f", "\uff41"-"\uff5a", "\uff66"-"\uffbe", "\uffc2"-"\uffc7", "\uffca"-"\uffcf", "\uffd2"-"\uffd7", "\uffda"-"\uffdc", "\uffe0"-"\uffe1", "\uffe5"-"\uffe6" ] > | < #PART_LETTER: [ // all chars for which Character.isJavaIdentifierPart is true "\u0000"-"\u0008", "\u000e"-"\u001b", "$", "0"-"9", "A"-"Z", "_", "a"-"z", "\u007f"-"\u009f", "\u00a2"-"\u00a5", "\u00aa", "\u00ad", "\u00b5", "\u00ba", "\u00c0"-"\u00d6", "\u00d8"-"\u00f6", "\u00f8"-"\u02c1", "\u02c6"-"\u02d1", "\u02e0"-"\u02e4", "\u02ec", "\u02ee", "\u0300"-"\u0374", "\u0376"-"\u0377", "\u037a"-"\u037d", "\u037f", "\u0386", "\u0388"-"\u038a", "\u038c", "\u038e"-"\u03a1", "\u03a3"-"\u03f5", "\u03f7"-"\u0481", "\u0483"-"\u0487", "\u048a"-"\u052f", "\u0531"-"\u0556", "\u0559", "\u0561"-"\u0587", "\u058f", "\u0591"-"\u05bd", "\u05bf", "\u05c1"-"\u05c2", "\u05c4"-"\u05c5", "\u05c7", "\u05d0"-"\u05ea", "\u05f0"-"\u05f2", "\u0600"-"\u0605", "\u060b", "\u0610"-"\u061a", "\u061c", "\u0620"-"\u0669", "\u066e"-"\u06d3", "\u06d5"-"\u06dd", "\u06df"-"\u06e8", "\u06ea"-"\u06fc", "\u06ff", "\u070f"-"\u074a", "\u074d"-"\u07b1", "\u07c0"-"\u07f5", "\u07fa", "\u0800"-"\u082d", "\u0840"-"\u085b", "\u08a0"-"\u08b4", "\u08e3"-"\u0963", "\u0966"-"\u096f", "\u0971"-"\u0983", "\u0985"-"\u098c", "\u098f"-"\u0990", "\u0993"-"\u09a8", "\u09aa"-"\u09b0", "\u09b2", "\u09b6"-"\u09b9", "\u09bc"-"\u09c4", "\u09c7"-"\u09c8", "\u09cb"-"\u09ce", "\u09d7", "\u09dc"-"\u09dd", "\u09df"-"\u09e3", "\u09e6"-"\u09f3", "\u09fb", "\u0a01"-"\u0a03", "\u0a05"-"\u0a0a", "\u0a0f"-"\u0a10", "\u0a13"-"\u0a28", "\u0a2a"-"\u0a30", "\u0a32"-"\u0a33", "\u0a35"-"\u0a36", "\u0a38"-"\u0a39", "\u0a3c", "\u0a3e"-"\u0a42", "\u0a47"-"\u0a48", "\u0a4b"-"\u0a4d", "\u0a51", "\u0a59"-"\u0a5c", "\u0a5e", "\u0a66"-"\u0a75", "\u0a81"-"\u0a83", "\u0a85"-"\u0a8d", "\u0a8f"-"\u0a91", "\u0a93"-"\u0aa8", "\u0aaa"-"\u0ab0", "\u0ab2"-"\u0ab3", "\u0ab5"-"\u0ab9", "\u0abc"-"\u0ac5", "\u0ac7"-"\u0ac9", "\u0acb"-"\u0acd", "\u0ad0", "\u0ae0"-"\u0ae3", "\u0ae6"-"\u0aef", "\u0af1", "\u0af9", "\u0b01"-"\u0b03", "\u0b05"-"\u0b0c", "\u0b0f"-"\u0b10", "\u0b13"-"\u0b28", "\u0b2a"-"\u0b30", "\u0b32"-"\u0b33", "\u0b35"-"\u0b39", "\u0b3c"-"\u0b44", "\u0b47"-"\u0b48", "\u0b4b"-"\u0b4d", "\u0b56"-"\u0b57", "\u0b5c"-"\u0b5d", "\u0b5f"-"\u0b63", "\u0b66"-"\u0b6f", "\u0b71", "\u0b82"-"\u0b83", "\u0b85"-"\u0b8a", "\u0b8e"-"\u0b90", "\u0b92"-"\u0b95", "\u0b99"-"\u0b9a", "\u0b9c", "\u0b9e"-"\u0b9f", "\u0ba3"-"\u0ba4", "\u0ba8"-"\u0baa", "\u0bae"-"\u0bb9", "\u0bbe"-"\u0bc2", "\u0bc6"-"\u0bc8", "\u0bca"-"\u0bcd", "\u0bd0", "\u0bd7", "\u0be6"-"\u0bef", "\u0bf9", "\u0c00"-"\u0c03", "\u0c05"-"\u0c0c", "\u0c0e"-"\u0c10", "\u0c12"-"\u0c28", "\u0c2a"-"\u0c39", "\u0c3d"-"\u0c44", "\u0c46"-"\u0c48", "\u0c4a"-"\u0c4d", "\u0c55"-"\u0c56", "\u0c58"-"\u0c5a", "\u0c60"-"\u0c63", "\u0c66"-"\u0c6f", "\u0c81"-"\u0c83", "\u0c85"-"\u0c8c", "\u0c8e"-"\u0c90", "\u0c92"-"\u0ca8", "\u0caa"-"\u0cb3", "\u0cb5"-"\u0cb9", "\u0cbc"-"\u0cc4", "\u0cc6"-"\u0cc8", "\u0cca"-"\u0ccd", "\u0cd5"-"\u0cd6", "\u0cde", "\u0ce0"-"\u0ce3", "\u0ce6"-"\u0cef", "\u0cf1"-"\u0cf2", "\u0d01"-"\u0d03", "\u0d05"-"\u0d0c", "\u0d0e"-"\u0d10", "\u0d12"-"\u0d3a", "\u0d3d"-"\u0d44", "\u0d46"-"\u0d48", "\u0d4a"-"\u0d4e", "\u0d57", "\u0d5f"-"\u0d63", "\u0d66"-"\u0d6f", "\u0d7a"-"\u0d7f", "\u0d82"-"\u0d83", "\u0d85"-"\u0d96", "\u0d9a"-"\u0db1", "\u0db3"-"\u0dbb", "\u0dbd", "\u0dc0"-"\u0dc6", "\u0dca", "\u0dcf"-"\u0dd4", "\u0dd6", "\u0dd8"-"\u0ddf", "\u0de6"-"\u0def", "\u0df2"-"\u0df3", "\u0e01"-"\u0e3a", "\u0e3f"-"\u0e4e", "\u0e50"-"\u0e59", "\u0e81"-"\u0e82", "\u0e84", "\u0e87"-"\u0e88", "\u0e8a", "\u0e8d", "\u0e94"-"\u0e97", "\u0e99"-"\u0e9f", "\u0ea1"-"\u0ea3", "\u0ea5", "\u0ea7", "\u0eaa"-"\u0eab", "\u0ead"-"\u0eb9", "\u0ebb"-"\u0ebd", "\u0ec0"-"\u0ec4", "\u0ec6", "\u0ec8"-"\u0ecd", "\u0ed0"-"\u0ed9", "\u0edc"-"\u0edf", "\u0f00", "\u0f18"-"\u0f19", "\u0f20"-"\u0f29", "\u0f35", "\u0f37", "\u0f39", "\u0f3e"-"\u0f47", "\u0f49"-"\u0f6c", "\u0f71"-"\u0f84", "\u0f86"-"\u0f97", "\u0f99"-"\u0fbc", "\u0fc6", "\u1000"-"\u1049", "\u1050"-"\u109d", "\u10a0"-"\u10c5", "\u10c7", "\u10cd", "\u10d0"-"\u10fa", "\u10fc"-"\u1248", "\u124a"-"\u124d", "\u1250"-"\u1256", "\u1258", "\u125a"-"\u125d", "\u1260"-"\u1288", "\u128a"-"\u128d", "\u1290"-"\u12b0", "\u12b2"-"\u12b5", "\u12b8"-"\u12be", "\u12c0", "\u12c2"-"\u12c5", "\u12c8"-"\u12d6", "\u12d8"-"\u1310", "\u1312"-"\u1315", "\u1318"-"\u135a", "\u135d"-"\u135f", "\u1380"-"\u138f", "\u13a0"-"\u13f5", "\u13f8"-"\u13fd", "\u1401"-"\u166c", "\u166f"-"\u167f", "\u1681"-"\u169a", "\u16a0"-"\u16ea", "\u16ee"-"\u16f8", "\u1700"-"\u170c", "\u170e"-"\u1714", "\u1720"-"\u1734", "\u1740"-"\u1753", "\u1760"-"\u176c", "\u176e"-"\u1770", "\u1772"-"\u1773", "\u1780"-"\u17d3", "\u17d7", "\u17db"-"\u17dd", "\u17e0"-"\u17e9", "\u180b"-"\u180e", "\u1810"-"\u1819", "\u1820"-"\u1877", "\u1880"-"\u18aa", "\u18b0"-"\u18f5", "\u1900"-"\u191e", "\u1920"-"\u192b", "\u1930"-"\u193b", "\u1946"-"\u196d", "\u1970"-"\u1974", "\u1980"-"\u19ab", "\u19b0"-"\u19c9", "\u19d0"-"\u19d9", "\u1a00"-"\u1a1b", "\u1a20"-"\u1a5e", "\u1a60"-"\u1a7c", "\u1a7f"-"\u1a89", "\u1a90"-"\u1a99", "\u1aa7", "\u1ab0"-"\u1abd", "\u1b00"-"\u1b4b", "\u1b50"-"\u1b59", "\u1b6b"-"\u1b73", "\u1b80"-"\u1bf3", "\u1c00"-"\u1c37", "\u1c40"-"\u1c49", "\u1c4d"-"\u1c7d", "\u1cd0"-"\u1cd2", "\u1cd4"-"\u1cf6", "\u1cf8"-"\u1cf9", "\u1d00"-"\u1df5", "\u1dfc"-"\u1f15", "\u1f18"-"\u1f1d", "\u1f20"-"\u1f45", "\u1f48"-"\u1f4d", "\u1f50"-"\u1f57", "\u1f59", "\u1f5b", "\u1f5d", "\u1f5f"-"\u1f7d", "\u1f80"-"\u1fb4", "\u1fb6"-"\u1fbc", "\u1fbe", "\u1fc2"-"\u1fc4", "\u1fc6"-"\u1fcc", "\u1fd0"-"\u1fd3", "\u1fd6"-"\u1fdb", "\u1fe0"-"\u1fec", "\u1ff2"-"\u1ff4", "\u1ff6"-"\u1ffc", "\u200b"-"\u200f", "\u202a"-"\u202e", "\u203f"-"\u2040", "\u2054", "\u2060"-"\u2064", "\u2066"-"\u206f", "\u2071", "\u207f", "\u2090"-"\u209c", "\u20a0"-"\u20be", "\u20d0"-"\u20dc", "\u20e1", "\u20e5"-"\u20f0", "\u2102", "\u2107", "\u210a"-"\u2113", "\u2115", "\u2119"-"\u211d", "\u2124", "\u2126", "\u2128", "\u212a"-"\u212d", "\u212f"-"\u2139", "\u213c"-"\u213f", "\u2145"-"\u2149", "\u214e", "\u2160"-"\u2188", "\u2c00"-"\u2c2e", "\u2c30"-"\u2c5e", "\u2c60"-"\u2ce4", "\u2ceb"-"\u2cf3", "\u2d00"-"\u2d25", "\u2d27", "\u2d2d", "\u2d30"-"\u2d67", "\u2d6f", "\u2d7f"-"\u2d96", "\u2da0"-"\u2da6", "\u2da8"-"\u2dae", "\u2db0"-"\u2db6", "\u2db8"-"\u2dbe", "\u2dc0"-"\u2dc6", "\u2dc8"-"\u2dce", "\u2dd0"-"\u2dd6", "\u2dd8"-"\u2dde", "\u2de0"-"\u2dff", "\u2e2f", "\u3005"-"\u3007", "\u3021"-"\u302f", "\u3031"-"\u3035", "\u3038"-"\u303c", "\u3041"-"\u3096", "\u3099"-"\u309a", "\u309d"-"\u309f", "\u30a1"-"\u30fa", "\u30fc"-"\u30ff", "\u3105"-"\u312d", "\u3131"-"\u318e", "\u31a0"-"\u31ba", "\u31f0"-"\u31ff", "\u3400"-"\u4db5", "\u4e00"-"\u9fd5", "\ua000"-"\ua48c", "\ua4d0"-"\ua4fd", "\ua500"-"\ua60c", "\ua610"-"\ua62b", "\ua640"-"\ua66f", "\ua674"-"\ua67d", "\ua67f"-"\ua6f1", "\ua717"-"\ua71f", "\ua722"-"\ua788", "\ua78b"-"\ua7ad", "\ua7b0"-"\ua7b7", "\ua7f7"-"\ua827", "\ua838", "\ua840"-"\ua873", "\ua880"-"\ua8c4", "\ua8d0"-"\ua8d9", "\ua8e0"-"\ua8f7", "\ua8fb", "\ua8fd", "\ua900"-"\ua92d", "\ua930"-"\ua953", "\ua960"-"\ua97c", "\ua980"-"\ua9c0", "\ua9cf"-"\ua9d9", "\ua9e0"-"\ua9fe", "\uaa00"-"\uaa36", "\uaa40"-"\uaa4d", "\uaa50"-"\uaa59", "\uaa60"-"\uaa76", "\uaa7a"-"\uaac2", "\uaadb"-"\uaadd", "\uaae0"-"\uaaef", "\uaaf2"-"\uaaf6", "\uab01"-"\uab06", "\uab09"-"\uab0e", "\uab11"-"\uab16", "\uab20"-"\uab26", "\uab28"-"\uab2e", "\uab30"-"\uab5a", "\uab5c"-"\uab65", "\uab70"-"\uabea", "\uabec"-"\uabed", "\uabf0"-"\uabf9", "\uac00"-"\ud7a3", "\ud7b0"-"\ud7c6", "\ud7cb"-"\ud7fb", "\uf900"-"\ufa6d", "\ufa70"-"\ufad9", "\ufb00"-"\ufb06", "\ufb13"-"\ufb17", "\ufb1d"-"\ufb28", "\ufb2a"-"\ufb36", "\ufb38"-"\ufb3c", "\ufb3e", "\ufb40"-"\ufb41", "\ufb43"-"\ufb44", "\ufb46"-"\ufbb1", "\ufbd3"-"\ufd3d", "\ufd50"-"\ufd8f", "\ufd92"-"\ufdc7", "\ufdf0"-"\ufdfc", "\ufe00"-"\ufe0f", "\ufe20"-"\ufe2f", "\ufe33"-"\ufe34", "\ufe4d"-"\ufe4f", "\ufe69", "\ufe70"-"\ufe74", "\ufe76"-"\ufefc", "\ufeff", "\uff04", "\uff10"-"\uff19", "\uff21"-"\uff3a", "\uff3f", "\uff41"-"\uff5a", "\uff66"-"\uffbe", "\uffc2"-"\uffc7", "\uffca"-"\uffcf", "\uffd2"-"\uffd7", "\uffda"-"\uffdc", "\uffe0"-"\uffe1", "\uffe5"-"\uffe6", "\ufff9"-"\ufffb" ] > } /* SEPARATORS */ TOKEN : { < LPAREN: "(" > | < RPAREN: ")" > | < LBRACE: "{" > | < RBRACE: "}" > | < LBRACKET: "[" > | < RBRACKET: "]" > | < SEMICOLON: ";" > | < COMMA: "," > | < DOT: "." > | < AT: "@" > } /* OPERATORS */ TOKEN : { < ASSIGN: "=" > | < LT: "<" > | < BANG: "!" > | < TILDE: "~" > | < HOOK: "?" > | < COLON: ":" > | < EQ: "==" > | < LE: "<=" > | < GE: ">=" > | < NE: "!=" > | < SC_OR: "||" > | < SC_AND: "&&" > | < INCR: "++" > | < DECR: "--" > | < PLUS: "+" > | < MINUS: "-" > | < STAR: "*" > | < SLASH: "/" > | < BIT_AND: "&" > | < BIT_OR: "|" > | < XOR: "^" > | < REM: "%" > | < LSHIFT: "<<" > // Notice the absence of >> or >>>, to not conflict with generics | < PLUSASSIGN: "+=" > | < MINUSASSIGN: "-=" > | < STARASSIGN: "*=" > | < SLASHASSIGN: "/=" > | < ANDASSIGN: "&=" > | < ORASSIGN: "|=" > | < XORASSIGN: "^=" > | < REMASSIGN: "%=" > | < LSHIFTASSIGN: "<<=" > | < RSIGNEDSHIFTASSIGN: ">>=" > | < RUNSIGNEDSHIFTASSIGN: ">>>=" > | < ELLIPSIS: "..." > | < LAMBDA: "->" > | < METHOD_REF: "::" > } /* >'s need special attention due to generics syntax. */ TOKEN : { < RUNSIGNEDSHIFT: ">>>" > { matchedToken.kind = GT; ((Token.GTToken)matchedToken).realKind = RUNSIGNEDSHIFT; input_stream.backup(2); matchedToken.image = ">"; } | < RSIGNEDSHIFT: ">>" > { matchedToken.kind = GT; ((Token.GTToken)matchedToken).realKind = RSIGNEDSHIFT; input_stream.backup(1); matchedToken.image = ">"; } | < GT: ">" > } /***************************************** * THE JAVA LANGUAGE GRAMMAR STARTS HERE * *****************************************/ /* * Program structuring syntax follows. */ ASTCompilationUnit CompilationUnit() : {} { [ LOOKAHEAD( ( Annotation() )* "package" ) PackageDeclaration() ( EmptyStatement() )* ] ( ImportDeclaration() ( EmptyStatement() )* )* // the module decl lookahead needs to be before the type declaration branch, // looking for annotations + "open" | "module" will fail faster if it's *not* // a module (most common case) [ LOOKAHEAD(ModuleDeclLahead()) ModuleDeclaration() ( EmptyStatement() )* ] ( TypeDeclaration() ( EmptyStatement() )* )* ( < "\u001a" > )? ( < "~[]" > )? // what's this for? Do you mean ( < ~[] > )*, i.e. "any character"? { jjtThis.setComments(token_source.comments); return jjtThis; } } private void ModuleDeclLahead() #void: {} { (Annotation())* LOOKAHEAD({isKeyword("open") || isKeyword("module")}) } void PackageDeclaration() : {String image;} { AnnotationList() "package" image=VoidName() { jjtThis.setImage(image); } ";" } void ImportDeclaration() : {String image;} { "import" [ "static" {checkForBadStaticImportUsage();jjtThis.setStatic();} ] image=VoidName() { jjtThis.setImage(image); } [ "." "*" {jjtThis.setImportOnDemand();} ] ";" } /* * Modifiers. We match all modifiers in a single rule to reduce the chances of * syntax errors for simple modifier mistakes. It will also enable us to give * better error messages. */ int Modifiers() #void: { int modifiers = 0; int numAnnots = 0; } { ( LOOKAHEAD(2) ( "public" { modifiers |= AccessNode.PUBLIC; } | "static" { modifiers |= AccessNode.STATIC; } | "protected" { modifiers |= AccessNode.PROTECTED; } | "private" { modifiers |= AccessNode.PRIVATE; } | "final" { modifiers |= AccessNode.FINAL; } | "abstract" { modifiers |= AccessNode.ABSTRACT; } | "synchronized" { modifiers |= AccessNode.SYNCHRONIZED; } | "native" { modifiers |= AccessNode.NATIVE; } | "transient" { modifiers |= AccessNode.TRANSIENT; } | "volatile" { modifiers |= AccessNode.VOLATILE; } | "strictfp" { modifiers |= AccessNode.STRICTFP; } | "default" { modifiers |= AccessNode.DEFAULT; checkForBadDefaultImplementationUsage(); } | Annotation() {numAnnots++;} ) )* { jjtree.injectRight(numAnnots); return modifiers; } } /* * Declaration syntax follows. */ void TypeDeclaration(): { int modifiers; } { modifiers = Modifiers() ( ClassOrInterfaceDeclaration(modifiers) | LOOKAHEAD({isKeyword("enum")}) EnumDeclaration(modifiers) | AnnotationTypeDeclaration(modifiers) ) } void ClassOrInterfaceDeclaration(int modifiers): { Token t = null; jjtThis.setModifiers(modifiers); boolean inInterfaceOld = inInterface; inInterface = false; } { ( "class" | "interface" { jjtThis.setInterface(); inInterface = true; } ) t= { checkForBadTypeIdentifierUsage(t.image); jjtThis.setImage(t.image); } [ TypeParameters() ] [ ExtendsList() ] [ ImplementsList() ] ClassOrInterfaceBody() { inInterface = inInterfaceOld; } // always restore the flag after leaving the node } void ExtendsList(): { boolean extendsMoreThanOne = false; } { "extends" AnnotatedClassOrInterfaceType() ( "," AnnotatedClassOrInterfaceType() { extendsMoreThanOne = true; } )* } void ImplementsList(): {} { "implements" AnnotatedClassOrInterfaceType() ( "," AnnotatedClassOrInterfaceType() )* } void EnumDeclaration(int modifiers): { Token t; jjtThis.setModifiers(modifiers); } { t = { if (!"enum".equals(t.image)) { throw new ParseException("ERROR: expecting enum"); } if (jdkVersion < 5) { throw new ParseException("ERROR: Can't use enum as a keyword in pre-JDK 1.5 target"); } } t= {checkForBadTypeIdentifierUsage(t.image); jjtThis.setImage(t.image);} [ ImplementsList() ] EnumBody() } void EnumBody(): { boolean inInterfaceOld = inInterface; inInterface = false; } { "{" [ EnumConstant() ( LOOKAHEAD(2) "," EnumConstant() )* ] [ "," ] [ ";" ( ClassOrInterfaceBodyDeclaration() )* ] "}" { inInterface = inInterfaceOld; } // always restore the flag after leaving the node } void EnumConstant(): {} { AnnotationList() VariableDeclaratorId() [ ArgumentList() ] [ ClassOrInterfaceBody() #AnonymousClassDeclaration ] } void TypeParameters(): {} { "<" {checkForBadGenericsUsage();} TypeParameter() ( "," TypeParameter() )* ">" } void TypeParameter(): {Token t;} { AnnotationList() t= {jjtThis.setImage(t.image);} [ TypeBound() ] } void TypeBound() #void: {} { "extends" IntersectionType(false) } void ClassOrInterfaceBody(): {} { "{" ( ClassOrInterfaceBodyDeclaration() )* "}" } void ClassOrInterfaceBodyDeclaration(): { int modifiers; } { LOOKAHEAD(["static"] "{" ) Initializer() | modifiers = Modifiers() ( LOOKAHEAD(3) ClassOrInterfaceDeclaration(modifiers) | LOOKAHEAD({isKeyword("enum")}) EnumDeclaration(modifiers) | LOOKAHEAD( [ TypeParameters() ] "(" ) ConstructorDeclaration(modifiers) | LOOKAHEAD( Type() ( "[" "]" )* ( "," | "=" | ";" ) ) FieldDeclaration(modifiers) | LOOKAHEAD(2) MethodDeclaration(modifiers) | LOOKAHEAD(2) AnnotationTypeDeclaration(modifiers) ) | ";" #EmptyDeclaration } void FieldDeclaration(int modifiers) : {jjtThis.setModifiers(modifiers);} { Type() VariableDeclarator() ( "," VariableDeclarator() )* ";" } void VariableDeclarator() : {} { VariableDeclaratorId() [ "=" VariableInitializer() ] } // TODO use ArrayDimensions void VariableDeclaratorId() : { String image; } { { image = getToken(0).getImage(); } ( "[" "]" { jjtThis.bumpArrayDepth(); })* { checkForBadAssertUsage(image, "a variable name"); checkForBadEnumUsage(image, "a variable name"); checkForBadIdentifier(image); jjtThis.setImage(image); } } void ReceiverParameter(): {} { AnnotatedClassOrInterfaceType() [ "." ] "this" } void VariableInitializer() #void: {} { ArrayInitializer() | Expression() } void ArrayInitializer() : {} { "{" [ VariableInitializer() ( LOOKAHEAD(2) "," VariableInitializer() )* ] [ "," ] "}" } void MethodDeclaration(int modifiers) : { jjtThis.setModifiers(modifiers); { checkForBadPrivateInterfaceMethod(jjtThis); } } { [ TypeParameters() ] ResultType() MethodDeclarator() [ "throws" NameList() ] ( Block() | ";" ) } void MethodDeclarator() : {Token t;} { t= { checkForBadAssertUsage(t.image, "a method name"); checkForBadEnumUsage(t.image, "a method name"); jjtThis.setImage( t.image ); } FormalParameters() ( "[" "]" )* // TODO use ArrayDimensions } void FormalParameters() : {} { "(" [ ( LOOKAHEAD(ReceiverParameter()) ReceiverParameter() | FormalParameter() ) ( "," FormalParameter() )* ] ")" } void FormalParameter() : { } { ( "final" {jjtThis.setFinal(true);} | Annotation() )* Type() ("|" {checkForBadMultipleExceptionsCatching();} Type())* // TODO there may be annotations before the "..." of the varargs // the ... is treated analogously to a pair of brackets // the sensible way to parse it would probably be to push an ArrayType with ArrayTypeDim for the "..." [ "..." {checkForBadVariableArgumentsUsage(); jjtThis.setVarargs();} ] VariableDeclaratorId() } void ConstructorDeclaration(int modifiers) : {jjtThis.setModifiers(modifiers); Token t;} { [ TypeParameters() ] {jjtThis.setImage(getToken(0).getImage());} FormalParameters() [ "throws" NameList() ] "{" [ LOOKAHEAD(ExplicitConstructorInvocation()) ExplicitConstructorInvocation() ] ( BlockStatement() )* t = "}" { if (isPrecededByComment(t)) { jjtThis.setContainsComment(); } } } void ExplicitConstructorInvocation() : {inExplicitConstructorInvoc = true;} { // We may only lookahead one token here, because: // * "this" or "super" can't appear in the primary expression in case of // qualified super call (last branch), or else compile error, so if we // see one of them, then the rest is necessarily the arguments // But: "this" may appear if it's qualified! // * No primary expression may start with "<", meaning we can use it to // know we're looking forward to type arguments ( LOOKAHEAD("<") TypeArguments() ( "this" | "super" {jjtThis.setIsSuper();} ) | LOOKAHEAD("this") "this" | LOOKAHEAD("super") "super" {jjtThis.setIsSuper();} | PrimaryExpression() "." [ TypeArguments() ] "super" {jjtThis.setIsSuper();} ) // reset this before parsing the arguments list {inExplicitConstructorInvoc = false;} ArgumentList() ";" } void Initializer() : {} { [ "static" {jjtThis.setStatic();} ] Block() } /* JLS: https://docs.oracle.com/javase/specs/jls/se8/html/jls-4.html#jls-4.3 ReferenceType: ClassOrInterfaceType TypeVariable ArrayType ClassOrInterfaceType: ClassType InterfaceType ClassType: {Annotation} Identifier [TypeArguments] ClassOrInterfaceType . {Annotation} Identifier [TypeArguments] InterfaceType: ClassType TypeVariable: {Annotation} Identifier ArrayType: PrimitiveType Dims ClassOrInterfaceType Dims TypeVariable Dims Dims: {Annotation} [ ] {{Annotation} [ ]} */ void IntersectionType(boolean inCast) #IntersectionType(isIntersection): {boolean isIntersection=false;} { AnnotatedType() ( "&" {if (inCast) checkForBadIntersectionTypesInCasts();isIntersection=true;} AnnotatedClassOrInterfaceType() )* } void AnnotationList() #void: {} { (Annotation())* } int TypeAnnotListNoInject() #void: {int num = 0;} { ( TypeAnnotation() {num++;} )* { return num; } } // Type annotation lists are by default injected in the // next node to be opened (most likely a type). // Sometimes (array dims), this need not be and TypeAnnotListNoInject // should be used. void TypeAnnotationList() #void: {int size=0;} { size=TypeAnnotListNoInject() { jjtree.injectRight(size); } } void AnnotatedType() #void: {} { TypeAnnotationList() Type() } void AnnotatedRefType() #void: {} { TypeAnnotationList() ReferenceType() } void AnnotatedClassOrInterfaceType() #void: {} { TypeAnnotationList() ClassOrInterfaceType() } /* * Type, name and expression syntax follows. * Type is the same as "UnannType" in JLS * * See https://docs.oracle.com/javase/specs/jls/se10/html/jls-8.html#jls-UnannType */ void Type() #void: { Token t; } { // lookahead to catch arrays of primitive types. // we can't lookahead for just PrimitiveType() "[" // because the "[" may be preceded by annotations LOOKAHEAD(PrimitiveType() ArrayTypeDim() | ) ReferenceType() | PrimitiveType() } void Dims() #ArrayDimensions: {} { // the list of dimensions is flat, but annotations are // preserved within each specific dim. (ArrayTypeDim())+ } void ArrayTypeDim(): {} { TypeAnnotListNoInject() "[" "]" } void ReferenceType() #void: {} { // We parse it that way because the right injection considers node openings, // which means if we want the annotations to belong to the element type, then // the ArrayType node needs to be opened after eg the PrimitiveType PrimitiveType() Dims() #ArrayType(2) | ClassOrInterfaceType() [ LOOKAHEAD(2) Dims() #ArrayType(2) ] } /** * Parses a ClassOrInterfaceType. The production itself is #void, * but the node exists (declared inline within the production). */ void ClassOrInterfaceType() #void: {} { (LOOKAHEAD({jjtree.isInjectionPending()}) // Perhaps surprisingly a type annotation binds to the closest segment // So in "@B Map.Entry", "@B" binds to "Map", and Map is required to be a type name. // If the annotation is not applicable to TYPE_USE then it doesn't compile // So if there are annotations pending injection here, then they're necessarily // type annotations, since otherwise they would have been consumed in the // annotation list of a declaration. // Eg in "public abstract @F int foo();", "@F" is part of the modifier list of the method. // but in "public abstract @F T foo();", "@F" is necessarily a type annotation, and indeed // is in a separate AnnotationList (it follows the type parameters so is not a modifier). // To sum it up, if we have annotations pending, then the first segment is necessarily // a type name, otherwise it wouldn't have compiled. So it's not ambiguous and we can // start fresh: "@B Map.Entry" will be unambiguously [[@B Map].Entry] ( {setLastTokenImage(jjtThis);} [ TypeArguments() ]) #ClassOrInterfaceType | // Otherwise, for now we have no clue until the first type arguments // or annotation is found. The name is ambiguous between package or // type name unless type arguments are present, in which case we can // be sure that the last segment is a type name. AmbiguousName() [ TypeArguments() #ClassOrInterfaceType(2) ] { // At this point the first ClassOrInterfaceType may be on top of the stack, // but its image is not set. If it is on the stack we need to shrink the bounds // of the ambiguous name, or delete it. Node first = jjtree.peekNode(); if (first instanceof ASTClassOrInterfaceType) { // then we saw type arguments, so the last segment is definitely a type name ASTAmbiguousName name = first.getFirstChildOfType(ASTAmbiguousName.class); name.shrinkOrDeleteInParentSetImage(); } } ) /* Now if there are other segments, either the previous segment specified type arguments, or the next has an annotation. Either way we know that all the following segments is a type name. Each segment is parsed as its own ClassOrInterfaceType which encloses the previous one. The resulting structure appears left-recursive, but the parser just executes a loop. That scheme preserves the position of type arguments and annotations. See #1150. */ ( LOOKAHEAD(2) "." ClassTypeSegment() )* { forceTypeContext(); } } private void ClassTypeSegment() #ClassOrInterfaceType: {} { TypeAnnotListNoInject() // We'll enclose the previous segment { setLastTokenImage(jjtThis); jjtree.extendLeft();} [ TypeArguments() ] } void TypeArguments(): {} { LOOKAHEAD(2) "<" {checkForBadGenericsUsage();} TypeArgument() ( "," TypeArgument() )* ">" | "<" {checkForBadDiamondUsage();} ">" } void TypeArgument() #void: {} { TypeAnnotationList() (ReferenceType() | WildcardType()) } void WildcardType(): {} { "?" [ ("extends" {jjtThis.setUpperBound(true);}| "super") AnnotatedRefType() ] } /* JLS https://docs.oracle.com/javase/specs/jls/se10/html/jls-4.html#jls-PrimitiveType PrimitiveType: {Annotation} NumericType {Annotation} boolean NumericType: IntegralType FloatingPointType IntegralType: (one of) byte short int long char FloatingPointType: (one of) float double */ void PrimitiveType() : {} { ( "boolean" | "char" | "byte" | "short" | "int" | "long" | "float" | "double" ) {jjtThis.setImage(getToken(0).getImage());} } void ResultType() : {} { "void" | AnnotatedType() } // TODO rename to ThrowsClause, stop using Name void NameList() : {} { (TypeAnnotation())* Name() ( "," (TypeAnnotation())* Name() )* } /* * Expression syntax follows. */ void Expression() #AssignmentExpression(>1): /* * This expansion has been written this way instead of: * Assignment() | ConditionalExpression() * for performance reasons. * However, it is a weakening of the grammar for it allows the LHS of * assignments to be any conditional expression whereas it can only be * a primary expression. Consider adding a semantic predicate to work * around this. */ {AssignmentOp op = null;} { ConditionalExpression() [ LOOKAHEAD(1) op=AssignmentOperator() {jjtThis.setOp(op);} Expression() ] } AssignmentOp AssignmentOperator() #void: {} { ( "=" | "*=" | "/=" | "%=" | "+=" | "-=" | "<<=" | ">>=" | ">>>=" | "&=" | "^=" | "|=" ) {return AssignmentOp.fromImage(getToken(0).getImage());} } void ConditionalExpression() #ConditionalExpression(>1) : {} { ConditionalOrExpression() [LOOKAHEAD(1) "?" Expression() ":" ConditionalExpression() ] } void ConditionalOrExpression() #void: {} { ConditionalAndExpression() (LOOKAHEAD(1) ("||" {jjtThis.setOp(BinaryOp.CONDITIONAL_OR);} ConditionalAndExpression()) #InfixExpression(2))* } void ConditionalAndExpression() #void: {} { InclusiveOrExpression() (LOOKAHEAD(1) ("&&" {jjtThis.setOp(BinaryOp.CONDITIONAL_AND);} InclusiveOrExpression()) #InfixExpression(2))* } void InclusiveOrExpression() #void: {} { ExclusiveOrExpression() (LOOKAHEAD(1) ("|" {jjtThis.setOp(BinaryOp.OR);} ExclusiveOrExpression()) #InfixExpression(2))* } void ExclusiveOrExpression() #void: {} { AndExpression() (LOOKAHEAD(1) ("^" {jjtThis.setOp(BinaryOp.XOR);} AndExpression()) #InfixExpression(2))* } void AndExpression() #void: {} { EqualityExpression() (LOOKAHEAD(1) ("&" {jjtThis.setOp(BinaryOp.AND);} EqualityExpression()) #InfixExpression(2))* } void EqualityExpression() #void: {} { InstanceOfExpression() (LOOKAHEAD(1) ( ( "==" {jjtThis.setOp(BinaryOp.EQ);} | "!=" {jjtThis.setOp(BinaryOp.NE);} ) InstanceOfExpression() ) #InfixExpression(2) )* } void InstanceOfExpression() #InstanceOfExpression(>1): {} { RelationalExpression() [ LOOKAHEAD(1) "instanceof" AnnotatedRefType() ] } void RelationalExpression() #void: {} { // There technically cannot be more than one, because it wouldn't compile // But we give it some leeway to not make the parser too knowledgeable // From the JLS: // For example, a" {jjtThis.setOp(BinaryOp.GT);} | "<=" {jjtThis.setOp(BinaryOp.LE);} | ">=" {jjtThis.setOp(BinaryOp.GE);} ) ShiftExpression() ) #InfixExpression(2) )* } void ShiftExpression() #void: {} { AdditiveExpression() (LOOKAHEAD(1) ( ( "<<" {jjtThis.setOp(BinaryOp.LEFT_SHIFT);} | RSIGNEDSHIFT() {jjtThis.setOp(BinaryOp.RIGHT_SHIFT);} | RUNSIGNEDSHIFT() {jjtThis.setOp(BinaryOp.UNSIGNED_RIGHT_SHIFT);} ) AdditiveExpression() ) #InfixExpression(2) )* } void AdditiveExpression() #void: {} { MultiplicativeExpression() (LOOKAHEAD(1) ( ( "+" {jjtThis.setOp(BinaryOp.ADD);} | "-" {jjtThis.setOp(BinaryOp.SUB);} ) MultiplicativeExpression() ) #InfixExpression(2) )* } void MultiplicativeExpression() #void: {} { UnaryExpression() (LOOKAHEAD(1) ( ( "*" {jjtThis.setOp(BinaryOp.MUL);} | "/" {jjtThis.setOp(BinaryOp.DIV);} | "%" {jjtThis.setOp(BinaryOp.MOD);} ) UnaryExpression() ) #InfixExpression(2) )* } // TODO update operator setting for those expressions void UnaryExpression() #void: {} { (("+" {jjtThis.setImage("+");} | "-" {jjtThis.setImage("-");}) UnaryExpression()) #UnaryExpression | PrefixIncrementExpression() | UnaryExpressionNotPlusMinus() } void PrefixIncrementExpression() #IncrementExpression: {} { ( "++" {jjtThis.setIncrement();} | "--" ) { jjtThis.setPrefix(); } PrimaryExpression() } void UnaryExpressionNotPlusMinus() #void: {} { (( "~" {jjtThis.setImage("~");} | "!" {jjtThis.setImage("!");}) UnaryExpression()) #UnaryExpression // There's no separate production for CastExpression, because that would force // us to repeat the lookahead // Those lookaheads are quite expensive, they're run to disambiguate between // ParenthesizedExpression and CastExpression. | LOOKAHEAD("(" TypeAnnotationList() PrimitiveType() ")") ("(" AnnotatedType() ")" UnaryExpression()) #CastExpression // here we avoid looking ahead for a whole unary expression, instead just testing the token after ")" | LOOKAHEAD("(" IntersectionType(true) ")" UnaryExprNotPmStart() ) ("(" IntersectionType(true) ")" UnaryExpressionNotPlusMinus()) #CastExpression | PostfixExpression() | SwitchExpression() } private void UnaryExprNotPmStart() #void: {} { // Condensed FIRST set of UnaryExpressionNotPlusMinus // Avoid looking ahead for a whole UnaryExpressionNotPlusMinus, but just for a token "~" | "!" | "(" | "switch" | "new" | "this" | "super" | Literal() | "@" | | "void" | PrimitiveType() } void PostfixExpression() #void: {} { PrimaryExpression() [LOOKAHEAD(1) ("++" {jjtThis.setIncrement();} | "--") #IncrementExpression(1) ] } void SwitchExpression() : {} { {checkForSwitchExpression();} "switch" "(" Expression() ")" SwitchBlock() } /** * A primary expression. This includes call chains, etc. * * A PrimaryPrefix corresponds to an unqualified primary expression, * e.g "new Foo()". Then, if any, suffixes of the form e.g. ".method()", * ".field" or "::ref" are added, each time enclosing the previous node. * Iteration stops after the first method reference, or we can't continue. * * The resulting subtree looks left-recursive, but the parsing is iterative. */ void PrimaryExpression() #void : {} { // the lookahead here stops iteration after the first method reference, // because nothing can be chained after a method reference. PrimaryPrefix() ( LOOKAHEAD(SuffixLAhead(), {!(jjtree.peekNode() instanceof ASTMethodReference)}) PrimarySuffix() )* {forceExprContext();} } /* Expressions that may be present at the start of a primary expression. */ void PrimaryPrefix() #void : {Token savedStart;} { Literal() | "this" #ThisExpression | "super" #SuperExpression(true) ("." MemberSelector() | MethodReference()) | UnqualifiedAllocationExpr() | ("void" "." "class") #ClassLiteral | (PrimitiveType() [ Dims() ] ) #ArrayType(>1) ( MethodReference() | "." "class" #ClassLiteral(1) ) // If annotations start the expression, it's necessarily a method or ctor reference // This is because types in class literals or in qualified super/this may not be annotated | LOOKAHEAD({getToken(1).kind == AT}) AnnotatedRefType() MethodReference() | LOOKAHEAD(LambdaLahead()) LambdaExpression() // Parenthesized expr, we need to adjust start/end tokens | "(" {savedStart = getToken(0);} Expression() ")" { AstImplUtil.bumpParenDepth((ASTExpression) jjtree.peekNode()); AbstractJavaNode top = (AbstractJavaNode) jjtree.peekNode(); top.jjtSetFirstToken(savedStart); top.jjtSetLastToken(getToken(0)); } // If it is an ambiguous name, then we may go on // into the next step, which is less restricted // than PrimarySuffix | AmbiguousName() [ LOOKAHEAD(Step2Lahead()) PrimaryStep2() ] } // This describes the cases where the PrimaryPrefix may fall // into PrimaryStep2, after seeing an AmbiguousName. Notice // that type arguments is still possible, as well as annotations // ("@") before an annotated array type, or qualified "this". // If we are in an explicit constructor invocation, then super is disallowed. private void Step2Lahead() #void: {} { "::" | "(" | "@" | "[" // the type arguments must be followed by what may complete a class type + method ref // otherwise we choke on eg `i < w >> 1`, because `< w >` matches type arguments | TypeArguments() ("[" | "." | "@" | "::") | LOOKAHEAD({!inExplicitConstructorInvoc}) "." | LOOKAHEAD({inExplicitConstructorInvoc}) "." ("class" | | TypeArguments() | "new" | "this") // not super in this case } private void SuffixLAhead() #void: {} { // this is simpler than the step 2 lookahead "::" | "[" | LOOKAHEAD({!inExplicitConstructorInvoc}) "." | LOOKAHEAD({inExplicitConstructorInvoc}) "." ( | TypeArguments() | "new") // not super or this in this case } // Step right after the *first* ambiguous name if any. // Then we have more options than a primary suffix, // we can still expect to have some class type and a // class literal, or some type arguments and a method reference void PrimaryStep2() #void: {} { // If we find type parameters, then we can only expect a method reference // class literals or qualifiers to static member access/call may not be parameterised {forceTypeContext();} TypeArguments() {injectTop();} ( "." ClassTypeSegment() )* [ Dims() #ArrayType(2) ] MethodReference() | MethodReference() | ArgumentList() #MethodCall(2) | "." ( {forceTypeContext();} "class" #ClassLiteral(1) // qualified this or super | {forceTypeContext();} "this" #ThisExpression(1) | {forceTypeContext();} "super" #SuperExpression(1) // here we force the super to be followed by something, // "super" alone is not a valid expression ("." MemberSelector() | MethodReference()) | MemberSelector() ) // catches the case where the ambig name is the start of an array type | LOOKAHEAD("@" | "[" "]") {forceTypeContext();} Dims() #ArrayType(2) (MethodReference() | "." "class" #ClassLiteral(1)) // and here, the array expr in an array access | {forceExprContext();} "[" Expression() "]" #ArrayAccess(2) } /** * Productions that may be present after a PrimaryPrefix. Basically * allows for call chains. We loop on this production in PrimaryExpression. */ void PrimarySuffix() #void : {} { MethodReference() | {forceExprContext();} "[" Expression() "]" #ArrayAccess(2) | "." MemberSelector() } /** * Part of a primary suffix that immediately follows a dot. Also * part of step 2. */ void MemberSelector() #void : {} { /* JLS §6.5.1: * A name is syntactically classified as an ExpressionName [...] as the * qualifying expression in a qualified class instance creation expression (§15.9)* */ {forceExprContext();} QualifiedAllocationExpr() // if there are type arguments, this is a method call | (TypeArguments() {setLastTokenImage(jjtThis);} ArgumentList()) #MethodCall(3) | LOOKAHEAD(2) ( {setLastTokenImage(jjtThis);} ArgumentList()) #MethodCall(2) | ( {setLastTokenImage(jjtThis);}) #FieldAccess(1) } void MethodReference(): // LHS is injected {checkForBadMethodReferenceUsage();} { "::" {jjtree.extendLeft();} [TypeArguments()] ( "new" | ) {setLastTokenImage(jjtThis);} {/* empty, to set the image before jjtClose */} } // This factorises the lookahead for a lambda expression // It's necessary because in all contexts a lambda may appear in, // the arguments could be interpreted as a variable reference, // or the start of a parenthesized expression private void LambdaLahead() #void : {} { LOOKAHEAD({!inSwitchLabel}) LambdaParameterList() "->" } // Lambda expressions are not a PrimaryExpression in the JLS, instead they're // separated from the AssignmentExpression production. Their use is restricted // to method and constructor call argument, cast operand, the RHS of assignments, // and the tail of a ternary expression // https://docs.oracle.com/javase/specs/jls/se9/html/jls-15.html#jls-15.27 // // To prevent LambdaExpressions in switch labels, the field #inSwitchLabel is used // as a workaround. void LambdaExpression(): { checkForBadLambdaUsage(); } { LambdaParameterList() "->" ( Expression() | Block() ) } void LambdaParameterList(): {} { VariableDeclaratorId() #LambdaParameter | LOOKAHEAD("(" ("," | ")")) "(" [ VariableDeclaratorId() #LambdaParameter(true) ( "," VariableDeclaratorId() #LambdaParameter )* ] ")" | "(" [ LambdaParameter() ( "," LambdaParameter() )* ] ")" } void LambdaParameter(): { boolean isVarType = false; ASTLambdaParameter me = jjtThis; boolean isFinal = false; } { [ isFinal=LocalVarModifierList() {jjtThis.setFinal(isFinal);} isVarType=LambdaParameterType() { jjtThis.setVarType(); } [ "..." {checkForBadVariableArgumentsUsage(); jjtThis.setVarargs();} ] ] VariableDeclaratorId() } /** Returns true if this is "var". */ boolean LambdaParameterType() #void : {} { LOOKAHEAD( { jdkVersion >= 11 && isKeyword("var") } ) { return true; } | Type() { return false; } } void Literal() #void : { Token t;} { NumericLiteral() | StringLiteral() | CharLiteral() | ("true" { jjtThis.setTrue(); } | "false") #BooleanLiteral | "null" #NullLiteral } void NumericLiteral(): { Token t; } { ( t= { jjtThis.setIntLiteral();} | t= { jjtThis.setFloatLiteral();} | t= { checkForBadHexFloatingPointLiteral(); jjtThis.setFloatLiteral();} ) { checkForBadNumericalLiteralslUsage(t); jjtThis.setImage(t.image); } } void CharLiteral(): {} { {jjtThis.setImage(getToken(0).getImage());} } void StringLiteral(): {} { ( | { jjtThis.setTextBlock(); checkForTextBlockLiteral(); }) { jjtThis.setImage(getToken(0).getImage()); } } void ArgumentList() : {} { "(" [ Expression() ( "," Expression() )* ] ")" } // more straightforward because can't be an array creation expr void QualifiedAllocationExpr() #ConstructorCall: {} { "new" {jjtree.extendLeft();} [ TypeArguments() ] AnnotatedClassOrInterfaceType() ArgumentList() [ { boolean inInterfaceOld = inInterface; inInterface = false; /* a anonymous class is not a interface */ } ClassOrInterfaceBody() #AnonymousClassDeclaration { inInterface = inInterfaceOld; } // always restore the flag after leaving the node ] { checkForBadAnonymousDiamondUsage(); } } // this is much weaker than the JLS but since we parse compilable code // the actual terms we get respect the JLS. // only used in PrimaryPrefix void UnqualifiedAllocationExpr() #void : { boolean isArrayInit=false; } { ( ( "new" [ TypeArguments() ] TypeAnnotationList() ( PrimitiveType() ArrayDimsAndInits(){isArrayInit=true;} | ClassOrInterfaceType() ( ArrayDimsAndInits() {isArrayInit=true;} | ArgumentList() [ { boolean inInterfaceOld = inInterface; inInterface = false; /* a anonymous class is not a interface */ } ClassOrInterfaceBody() #AnonymousClassDeclaration { inInterface = inInterfaceOld; } // always restore the flag after leaving the node ] ) ) {/*Empty unit, important*/} ) #ArrayAllocation(isArrayInit) ) #ConstructorCall(!isArrayInit) { checkForBadAnonymousDiamondUsage(); } } /* * The array dimensions are appended to the array type and they're both * enclosed into an ArrayType node. */ void ArrayDimsAndInits() #void: {} { LOOKAHEAD(TypeAnnotationList() "[" "]" ) (((ArrayTypeDim())+) #ArrayDimensions) #ArrayType(2) [ ArrayInitializer() ] | ( (ArrayDimExpr())+ #ArrayDimensions ) #ArrayType(2) } // may push either an ArrayDimExpr or ArrayTypeDim void ArrayDimExpr() #void: {boolean hasExpr=false;} { ((TypeAnnotListNoInject() "[" [ Expression() {hasExpr=true;} ] "]") #ArrayDimExpr(hasExpr) ) #ArrayTypeDim(!hasExpr) } /* * Statement syntax follows. */ void Statement() : {} { Block() | EmptyStatement() | SwitchStatement() | IfStatement() | WhileStatement() | DoStatement() | ForStatement() | BreakStatement() | ContinueStatement() | ReturnStatement() | ThrowStatement() | SynchronizedStatement() | TryStatement() // testing the hard cases last optimises the code gen // all the previous cases are trivial for the parser // because they start with a different token | LOOKAHEAD( { isNextTokenAnAssert() } ) AssertStatement() | LOOKAHEAD(2) LabeledStatement() | StatementExpression() ";" } void LabeledStatement() : {Token t;} { t= {jjtThis.setImage(t.image);} ":" Statement() } void Block() : {Token t;} { "{" ( BlockStatement() )* t = "}" { if (isPrecededByComment(t)) { jjtThis.setContainsComment(); } } } void BlockStatement(): {} { LOOKAHEAD( { isNextTokenAnAssert() } ) AssertStatement() | LOOKAHEAD({ jdkVersion >= 13 && isKeyword("yield") }) YieldStatement() | LOOKAHEAD(( "final" | Annotation() )* Type() ) LocalVariableDeclaration() ";" | // we need to lookahead until the "class" token, // because a method ref may be annotated // -> so Expression, and hence Statement, may start with "@" LOOKAHEAD(Modifiers() "class") LocalClassDecl() | Statement() } void LocalClassDecl() #void: {int mods = 0;} { // this preserves the modifiers of the local class. // it allows for modifiers that are forbidden for local classes, // but anyway we are *not* checking modifiers for incompatibilities // anywhere else in this grammar (and indeed the production Modifiers // accepts any modifier explicitly for the purpose of forgiving modifier errors, // and reporting them later if needed --see its documentation). // In particular, it unfortunately allows local class declarations to start // with a "default" modifier, which introduces an ambiguity with default // switch labels. This is guarded by a custom lookahead around SwitchLabel mods=Modifiers() ClassOrInterfaceDeclaration(mods) } /* * See https://docs.oracle.com/javase/specs/jls/se10/html/jls-14.html#jls-14.4 */ void LocalVariableDeclaration() : {boolean isFinal = false;} { isFinal=LocalVarModifierList() {jjtThis.setFinal(isFinal);} LocalVariableType() VariableDeclarator() ( "," VariableDeclarator() )* } private boolean LocalVarModifierList() #void: {boolean isFinal = false;} { ( "final" {isFinal = true;} | Annotation() )* {return isFinal;} } void LocalVariableType() #void: {} { LOOKAHEAD( { jdkVersion >= 10 && isKeyword("var") } ) | Type() } void EmptyStatement() : {} { ";" } void StatementExpression() : {AssignmentOp op = null;} { PrefixIncrementExpression() | // using PostfixExpression here allows us to skip the part of the production tree // between Expression() and PostfixExpression() (PostfixExpression() [ op=AssignmentOperator() {jjtThis.setOp(op);} Expression() ]) #AssignmentExpression(>1) } void SwitchStatement(): {} { "switch" "(" Expression() ")" SwitchBlock() } void SwitchBlock() #void : {} { "{" ( SwitchLabel() ( "->" SwitchLabeledRulePart() (SwitchLabeledRule())* | ":" (LOOKAHEAD(2) SwitchLabel() ":")* // the lookahead is to prevent choosing BlockStatement when the token is "default", // which could happen as local class declarations accept the "default" modifier. (LOOKAHEAD({shouldStartStatementInSwitch()}) BlockStatement())* (SwitchLabeledStatementGroup())* ) )? "}" } void SwitchLabeledRule() #void : {checkForSwitchRules();} { SwitchLabel() "->" SwitchLabeledRulePart() } void SwitchLabeledRulePart() #void: {checkForSwitchRules();} { ( Expression() ";" ) #SwitchLabeledExpression(2) | ( Block() ) #SwitchLabeledBlock(2) | ( ThrowStatement() ) #SwitchLabeledThrowStatement(2) } // For PMD 7, make this a real node to group the labels + statements void SwitchLabeledStatementGroup() #void: {} { (LOOKAHEAD(2) SwitchLabel() ":")+ // the lookahead is to prevent choosing BlockStatement when the token is "default", // which could happen as local class declarations accept the "default" modifier. (LOOKAHEAD({shouldStartStatementInSwitch()}) BlockStatement() )* } void SwitchLabel() : {} { { inSwitchLabel = true; } ( "case" ConditionalExpression() ({checkForMultipleCaseLabels();} "," ConditionalExpression() )* | "default" {jjtThis.setDefault();} ) { inSwitchLabel = false; } } void YieldStatement() : { checkForYieldStatement(); } { Expression() ";" } void IfStatement() : /* * The disambiguating algorithm of JavaCC automatically binds dangling * else's to the innermost if statement. The LOOKAHEAD specification * is to tell JavaCC that we know what we are doing. */ {} { "if" "(" Expression() ")" Statement() [ LOOKAHEAD(1) "else" {jjtThis.setHasElse();} Statement() ] } void WhileStatement() : {} { "while" "(" Expression() ")" Statement() } void DoStatement() : {} { "do" Statement() "while" "(" Expression() ")" ";" } void ForStatement() : {} { "for" "(" ( LOOKAHEAD(LocalVariableDeclaration() ":") {checkForBadJDK15ForLoopSyntaxArgumentsUsage();} LocalVariableDeclaration() ":" Expression() | [ ForInit() ] ";" [ Expression() ] ";" [ ForUpdate() ] ) ")" Statement() } void ForInit() : {} { LOOKAHEAD( LocalVariableDeclaration() ) LocalVariableDeclaration() | StatementExpressionList() } void StatementExpressionList() : {} { StatementExpression() ( "," StatementExpression() )* } void ForUpdate() : {} { StatementExpressionList() } void BreakStatement() : {Token t;} { "break" [ LOOKAHEAD( ";") t= {jjtThis.setImage(t.image);} | Expression() {checkForBreakExpression();} ] ";" } void ContinueStatement() : {Token t;} { "continue" [ t= {jjtThis.setImage(t.image);} ] ";" } void ReturnStatement() : {} { "return" [ Expression() ] ";" } void ThrowStatement() : {} { "throw" Expression() ";" } void SynchronizedStatement() : {} { "synchronized" "(" Expression() ")" Block() } void TryStatement() : /* * Semantic check required here to make sure that at least one * resource/finally/catch is present. */ {} { "try" (ResourceList())? Block() ( CatchStatement() )* [ FinallyStatement() ] } void ResourceList(): {} { {checkForBadTryWithResourcesUsage();} "(" Resource() (LOOKAHEAD(2) ";" Resource())* (";" {jjtThis.setTrailingSemi();})? ")" } void Resource() : {boolean isFinal = false;} { LOOKAHEAD(("final" | Annotation())* LocalVariableType() VariableDeclaratorId() "=" ) ( isFinal=LocalVarModifierList() {jjtThis.setFinal(isFinal);} LocalVariableType() VariableDeclarator() ) #LocalVariableDeclaration | PrimaryExpression() {checkForBadConciseTryWithResourcesUsage();} {} } void CatchStatement() : {} { "catch" "(" FormalParameter() ")" Block() } void FinallyStatement() : {} { "finally" Block() } void AssertStatement() : { if (jdkVersion <= 3) { throw new ParseException("Can't use 'assert' as a keyword when running in JDK 1.3 mode!"); } } { Expression() [ ":" Expression() ] ";" } /* We use productions to match >>>, >> and > so that we can keep the * type declaration syntax with generics clean */ void RUNSIGNEDSHIFT() #void: {} { ( LOOKAHEAD({ getToken(1).kind == GT && ((Token.GTToken)getToken(1)).realKind == RUNSIGNEDSHIFT} ) ">" ">" ">" ) } void RSIGNEDSHIFT() #void: {} { ( LOOKAHEAD({ getToken(1).kind == GT && ((Token.GTToken)getToken(1)).realKind == RSIGNEDSHIFT} ) ">" ">" ) } /* Annotation syntax follows. */ void Annotation() #void: {} { ( LOOKAHEAD( "@" VoidName() "(" ( "=" | ")" )) NormalAnnotation() | LOOKAHEAD( "@" VoidName() "(" ) SingleMemberAnnotation() | MarkerAnnotation() ) {checkForBadAnnotationUsage();} } void AnnotationBase(Node n) #void: {String name = null;} { "@" name=VoidName() {n.setImage(name);} } void NormalAnnotation(): {} { AnnotationBase(jjtThis) "(" [ MemberValuePairs() ] ")" } void MarkerAnnotation(): {} { AnnotationBase(jjtThis) } void SingleMemberAnnotation(): {} { AnnotationBase(jjtThis) "(" MemberValue() ")" } void MemberValuePairs() #void: {} { MemberValuePair() ( "," MemberValuePair() )* } void MemberValuePair(): {Token t;} { t= { jjtThis.setImage(t.image); } "=" MemberValue() } void MemberValue() #void: {} { Annotation() | MemberValueArrayInitializer() | // Constant expression ConditionalExpression() } void MemberValueArrayInitializer(): {} { "{" (MemberValue() ( LOOKAHEAD(2) "," MemberValue() )* [ "," ])? "}" } /* * We use that ghost production to factorise the check for JDK >= 1.8. */ void TypeAnnotation() #void: {} { Annotation() {checkForBadTypeAnnotations();} } /* Annotation Types. */ void AnnotationTypeDeclaration(int modifiers): { Token t; jjtThis.setModifiers(modifiers); } { "@" "interface" t= { checkForBadAnnotationUsage(); checkForBadTypeIdentifierUsage(t.image); jjtThis.setImage(t.image); } AnnotationTypeBody() } void AnnotationTypeBody(): {} { "{" ( AnnotationTypeMemberDeclaration() )* "}" } void AnnotationTypeMemberDeclaration(): { int modifiers; } { modifiers = Modifiers() ( LOOKAHEAD(Type() "(") AnnotationMethodDeclaration(modifiers) | ClassOrInterfaceDeclaration(modifiers) | LOOKAHEAD(3) EnumDeclaration(modifiers) | AnnotationTypeDeclaration(modifiers) | FieldDeclaration(modifiers) ) | ";" #EmptyDeclaration } void AnnotationMethodDeclaration(int modifiers): { Token t; jjtThis.setModifiers(modifiers); } { Type() t= "(" ")" [ DefaultValue() ] ";" { jjtThis.setImage(t.image); } } void DefaultValue(): {} { "default" MemberValue() } void ModuleDeclaration(): { StringBuilder s = new StringBuilder(); Token t; checkForBadModuleUsage(); } { ( Annotation() )* [LOOKAHEAD({isKeyword("open")}) {jjtThis.setOpen(true);}] LOOKAHEAD({isKeyword("module")}) t= { s.append(t.image); } ( "." t= { s.append('.').append(t.image); } )* { jjtThis.setImage(s.toString()); } "{" (ModuleDirective())* "}" } void ModuleDirective(): {} { ( LOOKAHEAD({isKeyword("requires")}) { jjtThis.setType(ASTModuleDirective.DirectiveType.REQUIRES); } (LOOKAHEAD({isKeyword("transitive")}) { jjtThis.setRequiresModifier(ASTModuleDirective.RequiresModifier.TRANSITIVE); } | "static" { jjtThis.setRequiresModifier(ASTModuleDirective.RequiresModifier.STATIC); } )? ModuleName() ";" ) | ( LOOKAHEAD({isKeyword("exports")}) { jjtThis.setType(ASTModuleDirective.DirectiveType.EXPORTS); } Name() [ LOOKAHEAD({isKeyword("to")}) ModuleName() ("," ModuleName())*] ";" ) | ( LOOKAHEAD({isKeyword("opens")}) { jjtThis.setType(ASTModuleDirective.DirectiveType.OPENS); } Name() [ LOOKAHEAD({isKeyword("to")}) ModuleName() ("," ModuleName())*] ";" ) | ( LOOKAHEAD({isKeyword("uses")}) { jjtThis.setType(ASTModuleDirective.DirectiveType.USES); } Name() ";" ) | ( LOOKAHEAD({isKeyword("provides")}) { jjtThis.setType(ASTModuleDirective.DirectiveType.PROVIDES); } Name() LOOKAHEAD({isKeyword("with")}) Name() ("," Name() )* ";" ) } // Similar to Name() void ModuleName(): { StringBuilder s = new StringBuilder(); Token t; } { t= { s.append(t.image); } ( "." t= {s.append('.').append(t.image);} )* {jjtThis.setImage(s.toString());} } void Name(): {String image;} { image=VoidName() {jjtThis.setImage(image); } } void AmbiguousName(): {String image;} { image=VoidName() {jjtThis.setImage(image); } } String VoidName() #void: /* * A lookahead of 2 is required below since "Name" can be followed * by a ".*" when used in the context of an "ImportDeclaration", * or with "this" or "super" in PrimaryPrefix. */ { StringBuilder s = new StringBuilder(); Token t; } { t= { s.append(t.image); } ( LOOKAHEAD(2) "." t= {s.append('.').append(t.image);} )* {return s.toString();} } // This is used to get JJTree to generate a node. // Variable references are always ambiguous // when they're parsed, so they're not created // normally by jjtree, but rather by the disambiguation // hooks spread across the parser //noinspection UnusedProduction void VariableAccess(): {} { }