1 /*
   2  * Copyright (c) 2005, 2018, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 package javax.lang.model;
  27 
  28 import java.util.Collections;
  29 import java.util.Set;
  30 import java.util.HashSet;
  31 
  32 /**
  33  * Source versions of the Java™ programming language.
  34  *
  35  * See the appropriate edition of
  36  * <cite>The Java&trade; Language Specification</cite>
  37  * for information about a particular source version.
  38  *
  39  * <p>Note that additional source version constants will be added to
  40  * model future releases of the language.
  41  *
  42  * @author Joseph D. Darcy
  43  * @author Scott Seligman
  44  * @author Peter von der Ah&eacute;
  45  * @since 1.6
  46  */
  47 public enum SourceVersion {
  48     /*
  49      * Summary of language evolution
  50      * 1.1: nested classes
  51      * 1.2: strictfp
  52      * 1.3: no changes
  53      * 1.4: assert
  54      * 1.5: annotations, generics, autoboxing, var-args...
  55      * 1.6: no changes
  56      * 1.7: diamond syntax, try-with-resources, etc.
  57      * 1.8: lambda expressions and default methods
  58      *   9: modules, small cleanups to 1.7 and 1.8 changes
  59      *  10: local-variable type inference (var)
  60      *  11: local-variable syntax for lambda parameters
  61      *  12: TBD

  62      */
  63 
  64     /**
  65      * The original version.
  66      *
  67      * The language described in
  68      * <cite>The Java&trade; Language Specification, First Edition</cite>.
  69      */
  70     RELEASE_0,
  71 
  72     /**
  73      * The version recognized by the Java Platform 1.1.
  74      *
  75      * The language is {@code RELEASE_0} augmented with nested classes as described in the 1.1 update to
  76      * <cite>The Java&trade; Language Specification, First Edition</cite>.
  77      */
  78     RELEASE_1,
  79 
  80     /**
  81      * The version recognized by the Java 2 Platform, Standard Edition,
  82      * v 1.2.
  83      *
  84      * The language described in
  85      * <cite>The Java&trade; Language Specification,
  86      * Second Edition</cite>, which includes the {@code
  87      * strictfp} modifier.
  88      */
  89     RELEASE_2,
  90 
  91     /**
  92      * The version recognized by the Java 2 Platform, Standard Edition,
  93      * v 1.3.
  94      *
  95      * No major changes from {@code RELEASE_2}.
  96      */
  97     RELEASE_3,
  98 
  99     /**
 100      * The version recognized by the Java 2 Platform, Standard Edition,
 101      * v 1.4.
 102      *
 103      * Added a simple assertion facility.
 104      */
 105     RELEASE_4,
 106 
 107     /**
 108      * The version recognized by the Java 2 Platform, Standard
 109      * Edition 5.0.
 110      *
 111      * The language described in
 112      * <cite>The Java&trade; Language Specification,
 113      * Third Edition</cite>.  First release to support
 114      * generics, annotations, autoboxing, var-args, enhanced {@code
 115      * for} loop, and hexadecimal floating-point literals.
 116      */
 117     RELEASE_5,
 118 
 119     /**
 120      * The version recognized by the Java Platform, Standard Edition
 121      * 6.
 122      *
 123      * No major changes from {@code RELEASE_5}.
 124      */
 125     RELEASE_6,
 126 
 127     /**
 128      * The version recognized by the Java Platform, Standard Edition
 129      * 7.
 130      *
 131      * Additions in this release include, diamond syntax for
 132      * constructors, {@code try}-with-resources, strings in switch,
 133      * binary literals, and multi-catch.
 134      * @since 1.7
 135      */
 136     RELEASE_7,
 137 
 138     /**
 139      * The version recognized by the Java Platform, Standard Edition
 140      * 8.
 141      *
 142      * Additions in this release include lambda expressions and default methods.
 143      * @since 1.8
 144      */
 145     RELEASE_8,
 146 
 147     /**
 148      * The version recognized by the Java Platform, Standard Edition
 149      * 9.
 150      *
 151      * Additions in this release include modules and removal of a
 152      * single underscore from the set of legal identifier names.
 153      *
 154      * @since 9
 155      */
 156      RELEASE_9,
 157 
 158     /**
 159      * The version recognized by the Java Platform, Standard Edition
 160      * 10.
 161      *
 162      * Additions in this release include local-variable type inference
 163      * ({@code var}).
 164      *
 165      * @since 10
 166      */
 167      RELEASE_10,
 168 
 169     /**
 170      * The version recognized by the Java Platform, Standard Edition
 171      * 11.
 172      *
 173      * Additions in this release include local-variable syntax for
 174      * lambda parameters.
 175      *
 176      * @since 11
 177      */
 178      RELEASE_11,
 179 
 180     /**
 181      * The version recognized by the Java Platform, Standard Edition
 182      * 12.
 183      *
 184      * @since 12
 185      */
 186      RELEASE_12;








 187 
 188     // Note that when adding constants for newer releases, the
 189     // behavior of latest() and latestSupported() must be updated too.
 190 
 191     /**
 192      * Returns the latest source version that can be modeled.
 193      *
 194      * @return the latest source version that can be modeled
 195      */
 196     public static SourceVersion latest() {
 197         return RELEASE_12;
 198     }
 199 
 200     private static final SourceVersion latestSupported = getLatestSupported();
 201 
 202     private static SourceVersion getLatestSupported() {
 203         try {
 204             String specVersion = System.getProperty("java.specification.version");
 205 
 206             switch (specVersion) {


 207                 case "12":
 208                     return RELEASE_12;
 209                 case "11":
 210                     return RELEASE_11;
 211                 case "10":
 212                     return RELEASE_10;
 213                 case "9":
 214                     return RELEASE_9;
 215                 case "1.8":
 216                     return RELEASE_8;
 217                 case "1.7":
 218                     return RELEASE_7;
 219                 case "1.6":
 220                     return RELEASE_6;
 221             }
 222         } catch (SecurityException se) {}
 223 
 224         return RELEASE_5;
 225     }
 226 
 227     /**
 228      * Returns the latest source version fully supported by the
 229      * current execution environment.  {@code RELEASE_5} or later must
 230      * be returned.
 231      *
 232      * @return the latest source version that is fully supported
 233      */
 234     public static SourceVersion latestSupported() {
 235         return latestSupported;
 236     }
 237 
 238     /**
 239      * Returns whether or not {@code name} is a syntactically valid
 240      * identifier (simple name) or keyword in the latest source
 241      * version.  The method returns {@code true} if the name consists
 242      * of an initial character for which {@link
 243      * Character#isJavaIdentifierStart(int)} returns {@code true},
 244      * followed only by characters for which {@link
 245      * Character#isJavaIdentifierPart(int)} returns {@code true}.
 246      * This pattern matches regular identifiers, keywords, restricted
 247      * keywords, and the literals {@code "true"}, {@code "false"},
 248      * {@code "null"}, and {@code "var"}.
 249      *
 250      * The method returns {@code false} for all other strings.
 251      *
 252      * @param name the string to check
 253      * @return {@code true} if this string is a
 254      * syntactically valid identifier or keyword, {@code false}
 255      * otherwise.
 256      */
 257     public static boolean isIdentifier(CharSequence name) {
 258         String id = name.toString();
 259 
 260         if (id.length() == 0) {
 261             return false;
 262         }
 263         int cp = id.codePointAt(0);
 264         if (!Character.isJavaIdentifierStart(cp)) {
 265             return false;
 266         }
 267         for (int i = Character.charCount(cp);
 268                 i < id.length();
 269                 i += Character.charCount(cp)) {
 270             cp = id.codePointAt(i);
 271             if (!Character.isJavaIdentifierPart(cp)) {
 272                 return false;
 273             }
 274         }
 275         return true;
 276     }
 277 
 278     /**
 279      * Returns whether or not {@code name} is a syntactically valid
 280      * qualified name in the latest source version.  Unlike {@link
 281      * #isIdentifier isIdentifier}, this method returns {@code false}
 282      * for keywords, boolean literals, and the null literal.
 283      *
 284      * This method returns {@code true} for <i>restricted
 285      * keywords</i> and {@code "var"}.
 286      *
 287      * @param name the string to check
 288      * @return {@code true} if this string is a
 289      * syntactically valid name, {@code false} otherwise.
 290      * @jls 3.9 Keywords
 291      * @jls 6.2 Names and Identifiers
 292      */
 293     public static boolean isName(CharSequence name) {
 294         return isName(name, latest());
 295     }
 296 
 297     /**
 298      * Returns whether or not {@code name} is a syntactically valid
 299      * qualified name in the given source version.  Unlike {@link
 300      * #isIdentifier isIdentifier}, this method returns {@code false}
 301      * for keywords, boolean literals, and the null literal.
 302      *
 303      * This method returns {@code true} for <i>restricted
 304      * keywords</i> and {@code "var"}.
 305      *
 306      * @param name the string to check
 307      * @param version the version to use
 308      * @return {@code true} if this string is a
 309      * syntactically valid name, {@code false} otherwise.
 310      * @jls 3.9 Keywords
 311      * @jls 6.2 Names and Identifiers
 312      * @since 9
 313      */
 314     public static boolean isName(CharSequence name, SourceVersion version) {
 315         String id = name.toString();
 316 
 317         for(String s : id.split("\\.", -1)) {
 318             if (!isIdentifier(s) || isKeyword(s, version))
 319                 return false;
 320         }
 321         return true;
 322     }
 323 
 324     /**
 325      * Returns whether or not {@code s} is a keyword, boolean literal,
 326      * or null literal in the latest source version.
 327      * This method returns {@code false} for <i>restricted
 328      * keywords</i> and {@code "var"}.
 329      *
 330      * @param s the string to check
 331      * @return {@code true} if {@code s} is a keyword, or boolean
 332      * literal, or null literal, {@code false} otherwise.
 333      * @jls 3.9 Keywords
 334      * @jls 3.10.3 Boolean Literals
 335      * @jls 3.10.7 The Null Literal
 336      */
 337     public static boolean isKeyword(CharSequence s) {
 338         return isKeyword(s, latest());
 339     }
 340 
 341     /**
 342      * Returns whether or not {@code s} is a keyword, boolean literal,
 343      * or null literal in the given source version.
 344      * This method returns {@code false} for <i>restricted
 345      * keywords</i> and {@code "var"}.
 346      *
 347      * @param s the string to check
 348      * @param version the version to use
 349      * @return {@code true} if {@code s} is a keyword, or boolean
 350      * literal, or null literal, {@code false} otherwise.
 351      * @jls 3.9 Keywords
 352      * @jls 3.10.3 Boolean Literals
 353      * @jls 3.10.7 The Null Literal
 354      * @since 9
 355      */
 356     public static boolean isKeyword(CharSequence s, SourceVersion version) {
 357         String id = s.toString();
 358         switch(id) {
 359             // A trip through history
 360         case "strictfp":
 361             return version.compareTo(RELEASE_2) >= 0;
 362 
 363         case "assert":
 364             return version.compareTo(RELEASE_4) >= 0;
 365 
 366         case "enum":
 367             return version.compareTo(RELEASE_5) >= 0;
 368 
 369         case "_":
 370             return version.compareTo(RELEASE_9) >= 0;
 371 
 372             // Keywords common across versions
 373 
 374             // Modifiers
 375         case "public":    case "protected": case "private":
 376         case "abstract":  case "static":    case "final":
 377         case "transient": case "volatile":  case "synchronized":
 378         case "native":
 379 
 380             // Declarations
 381         case "class":     case "interface": case "extends":
 382         case "package":   case "throws":    case "implements":
 383 
 384             // Primitive types and void
 385         case "boolean":   case "byte":      case "char":
 386         case "short":     case "int":       case "long":
 387         case "float":     case "double":
 388         case "void":
 389 
 390             // Control flow
 391         case "if":      case "else":
 392         case "try":     case "catch":    case "finally":
 393         case "do":      case "while":
 394         case "for":     case "continue":
 395         case "switch":  case "case":     case "default":
 396         case "break":   case "throw":    case "return":
 397 
 398             // Other keywords
 399         case  "this":   case "new":      case "super":
 400         case "import":  case "instanceof":
 401 
 402             // Forbidden!
 403         case "goto":        case "const":
 404 
 405             // literals
 406         case "null":         case "true":       case "false":
 407             return true;
 408 
 409         default:
 410             return false;
 411         }
 412     }
 413 }
--- EOF ---