1 /*
  2  * Copyright (c) 2002, 2023, 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 com.sun.tools.javac.jvm;
 27 
 28 import java.util.*;
 29 
 30 import com.sun.tools.javac.code.Flags;
 31 import com.sun.tools.javac.code.Symbol;
 32 import com.sun.tools.javac.util.*;
 33 
 34 import static com.sun.tools.javac.main.Option.TARGET;
 35 
 36 /** The classfile version target.
 37  *
 38  *  <p><b>This is NOT part of any supported API.
 39  *  If you write code that depends on this, you do so at your own risk.
 40  *  This code and its internal interfaces are subject to change or
 41  *  deletion without notice.</b>
 42  */
 43 public enum Target {
 44     JDK1_1("1.1", 45, 3),
 45     JDK1_2("1.2", 46, 0),
 46     JDK1_3("1.3", 47, 0),
 47 
 48     /** J2SE1.4 = Merlin. */
 49     JDK1_4("1.4", 48, 0),
 50 
 51     /** JDK 5, codename Tiger. */
 52     JDK1_5("5", 49, 0),
 53 
 54     /** JDK 6. */
 55     JDK1_6("6", 50, 0),
 56 
 57     /** JDK 7. */
 58     JDK1_7("7", 51, 0),
 59 
 60     /** JDK 8. */
 61     JDK1_8("8", 52, 0),
 62 
 63     /** JDK 9. */
 64     JDK1_9("9", 53, 0),
 65 
 66     /** JDK 10. */
 67     JDK1_10("10", 54, 0),
 68 
 69     /** JDK 11. */
 70     JDK1_11("11", 55, 0),
 71 
 72     /** JDK 12. */
 73     JDK1_12("12", 56, 0),
 74 
 75     /** JDK 13. */
 76     JDK1_13("13", 57, 0),
 77 
 78     /** JDK 14. */
 79     JDK1_14("14", 58, 0),
 80 
 81     /** JDK 15. */
 82     JDK1_15("15", 59, 0),
 83 
 84     /** JDK 16. */
 85     JDK1_16("16", 60, 0),
 86 
 87     /** JDK 17. */
 88     JDK1_17("17", 61, 0),
 89 
 90     /** JDK 18. */
 91     JDK1_18("18", 62, 0),
 92 
 93     /** JDK 19. */
 94     JDK1_19("19", 63, 0),
 95 
 96     /** JDK 20. */
 97     JDK1_20("20", 64, 0),
 98 
 99     /** JDK 21. */
100     JDK1_21("21", 65, 0),
101 
102     /** JDK 22. */
103     JDK1_22("22", 66, 0),
104     ; // Reduce code churn when appending new constants
105 
106     private static final Context.Key<Target> targetKey = new Context.Key<>();
107 
108     public static Target instance(Context context) {
109         Target instance = context.get(targetKey);
110         if (instance == null) {
111             Options options = Options.instance(context);
112             String targetString = options.get(TARGET);
113             if (targetString != null) instance = lookup(targetString);
114             if (instance == null) instance = DEFAULT;
115             context.put(targetKey, instance);
116         }
117         return instance;
118     }
119 
120     public static final Target MIN = Target.JDK1_8;
121 
122     private static final Target MAX = values()[values().length - 1];
123 
124     public static final Target DEFAULT = MAX;
125 
126     private static final Map<String,Target> tab = new HashMap<>();
127     static {
128         for (Target t : values()) {
129             tab.put(t.name, t);
130         }
131         tab.put("1.5", JDK1_5);
132         tab.put("1.6", JDK1_6);
133         tab.put("1.7", JDK1_7);
134         tab.put("1.8", JDK1_8);
135         tab.put("1.9", JDK1_9);
136         tab.put("1.10", JDK1_10);
137     }
138 
139     public final String name;
140     public final int majorVersion;
141     public final int minorVersion;
142     private Target(String name, int majorVersion, int minorVersion) {
143         this.name = name;
144         this.majorVersion = majorVersion;
145         this.minorVersion = minorVersion;
146     }
147 
148     public static Target lookup(String name) {
149         return tab.get(name);
150     }
151 
152     public boolean isSupported() {
153         return this.compareTo(MIN) >= 0;
154     }
155 
156     /** Return the character to be used in constructing synthetic
157      *  identifiers, where not specified by the JLS.
158      */
159     public char syntheticNameChar() {
160         return '$';
161     }
162 
163     /** Does the target VM expect MethodParameters attributes?
164      */
165     public boolean hasMethodParameters() {
166         return compareTo(JDK1_8) >= 0;
167     }
168 
169     /** Does the target JDK contain StringConcatFactory class?
170      */
171     public boolean hasStringConcatFactory() {
172         return compareTo(JDK1_9) >= 0;
173     }
174 
175     /** Value of platform release used to access multi-release jar files
176      */
177     public String multiReleaseValue() {
178         return Integer.toString(this.ordinal() - Target.JDK1_1.ordinal() + 1);
179     }
180 
181     /** All modules that export an API are roots when compiling code in the unnamed
182      *  module and targeting 11 or newer.
183      */
184     public boolean allApiModulesAreRoots() {
185         return compareTo(JDK1_11) >= 0;
186     }
187 
188     /** Does the target VM support nestmate access?
189      */
190     public boolean hasNestmateAccess() {
191         return compareTo(JDK1_11) >= 0;
192     }
193 
194     /** language runtime uses nest-based access.
195      *  e.g. lambda and string concat spin dynamic proxy class as a nestmate
196      *  of the target class
197      */
198     public boolean runtimeUseNestAccess() {
199         return compareTo(JDK1_15) >= 0;
200     }
201 
202     /** Does the target VM support virtual private invocations?
203      */
204     public boolean hasVirtualPrivateInvoke() {
205         return compareTo(JDK1_11) >= 0;
206     }
207 
208     /** Does the target VM support sealed types
209      */
210     public boolean hasSealedClasses() {
211         return compareTo(JDK1_15) >= 0;
212     }
213 
214     /** Does the target VM support value classes
215      */
216     public boolean hasValueClasses() {
217         return compareTo(JDK1_19) >= 0;
218     }
219 
220     /** Is the ACC_STRICT bit redundant and obsolete
221      */
222     public boolean obsoleteAccStrict() {
223         return compareTo(JDK1_17) >= 0;
224     }
225 
226     /** Omit unused enclosing instance fields from inner classes that don't access enclosing
227      * instance state.
228      */
229     public boolean optimizeOuterThis() {
230         return compareTo(JDK1_18) >= 0;
231     }
232 }