org.checkerframework.javacutil.SystemUtil Maven / Gradle / Ivy
Show all versions of checker Show documentation
package org.checkerframework.javacutil;
import com.sun.tools.javac.main.Option;
import com.sun.tools.javac.processing.JavacProcessingEnvironment;
import com.sun.tools.javac.util.Context;
import com.sun.tools.javac.util.Options;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import javax.annotation.processing.ProcessingEnvironment;
import org.checkerframework.checker.nullness.qual.Nullable;
/** This file contains basic utility functions. */
public class SystemUtil {
/**
* Returns the major JRE version.
*
* This is different from the version passed to the compiler via --release; use {@link
* #getReleaseValue(ProcessingEnvironment)} to get that version.
*
*
Extract the major version number from the "java.version" system property. Two possible
* formats are considered. Up to Java 8, from a version string like `1.8.whatever`, this method
* extracts 8. Since Java 9, from a version string like `11.0.1`, this method extracts 11.
*
* @return the major version number from "java.version"
*/
public static int getJreVersion() {
final String jreVersionStr = System.getProperty("java.version");
final Pattern oldVersionPattern = Pattern.compile("^1\\.(\\d+)\\..*$");
final Matcher oldVersionMatcher = oldVersionPattern.matcher(jreVersionStr);
if (oldVersionMatcher.matches()) {
String v = oldVersionMatcher.group(1);
assert v != null : "@AssumeAssertion(nullness): inspection";
return Integer.parseInt(v);
}
// See http://openjdk.java.net/jeps/223
// We only care about the major version number.
final Pattern newVersionPattern = Pattern.compile("^(\\d+).*$");
final Matcher newVersionMatcher = newVersionPattern.matcher(jreVersionStr);
if (newVersionMatcher.matches()) {
String v = newVersionMatcher.group(1);
assert v != null : "@AssumeAssertion(nullness): inspection";
return Integer.parseInt(v);
}
// For Early Access version of the JDK
final Pattern eaVersionPattern = Pattern.compile("^(\\d+)-ea$");
final Matcher eaVersionMatcher = eaVersionPattern.matcher(jreVersionStr);
if (eaVersionMatcher.matches()) {
String v = eaVersionMatcher.group(1);
assert v != null : "@AssumeAssertion(nullness): inspection";
return Integer.parseInt(v);
}
throw new RuntimeException(
"Could not determine version from property java.version=" + jreVersionStr);
}
/**
* Returns the release value passed to the compiler or null if release was not passed.
*
* @param env the ProcessingEnvironment
* @return the release value or null if none was passed
*/
public static @Nullable String getReleaseValue(ProcessingEnvironment env) {
Context ctx = ((JavacProcessingEnvironment) env).getContext();
Options options = Options.instance(ctx);
return options.get(Option.RELEASE);
}
/**
* Returns the pathname to the tools.jar file, or null if it does not exist. Returns null on Java
* 9 and later.
*
* @return the pathname to the tools.jar file, or null
*/
public static @Nullable String getToolsJar() {
if (getJreVersion() > 8) {
return null;
}
String javaHome = System.getenv("JAVA_HOME");
if (javaHome == null) {
String javaHomeProperty = System.getProperty("java.home");
if (javaHomeProperty.endsWith(File.separator + "jre")) {
javaHome = javaHomeProperty.substring(javaHomeProperty.length() - 4);
} else {
// Could also determine the location of javac on the path...
throw new Error("Can't infer Java home; java.home=" + javaHomeProperty);
}
}
String toolsJarFilename = javaHome + File.separator + "lib" + File.separator + "tools.jar";
if (!new File(toolsJarFilename).exists()) {
throw new Error(
String.format(
"File does not exist: %s ; JAVA_HOME=%s ; java.home=%s",
toolsJarFilename, javaHome, System.getProperty("java.home")));
}
return javaHome + File.separator + "lib" + File.separator + "tools.jar";
}
///
/// Array and collection methods
///
/**
* Returns a list that contains all the distinct elements of the two lists: that is, the union of
* the two arguments.
*
*
For very short lists, this is likely more efficient than creating a set and converting back
* to a list.
*
* @param the type of the list elements
* @param list1 a list
* @param list2 a list
* @return a list that contains all the distinct elements of the two lists
*/
public static List union(List list1, List list2) {
List result = new ArrayList<>(list1.size() + list2.size());
addWithoutDuplicates(result, list1);
addWithoutDuplicates(result, list2);
return result;
}
/**
* Adds, to dest, all the elements of source that are not already in dest.
*
* For very short lists, this is likely more efficient than creating a set and converting back
* to a list.
*
* @param the type of the list elements
* @param dest a list to add to
* @param source a list of elements to add
*/
@SuppressWarnings("nullness:argument" // true positive: `dest` might be incompatible with
// null and `source` might contain null.
)
public static void addWithoutDuplicates(List dest, List source) {
for (T elt : source) {
if (!dest.contains(elt)) {
dest.add(elt);
}
}
}
/**
* Returns a list that contains all the elements that are in both lists: that is, the set
* difference of the two arguments.
*
* For very short lists, this is likely more efficient than creating a set and converting back
* to a list.
*
* @param the type of the list elements
* @param list1 a list
* @param list2 a list
* @return a list that contains all the elements of {@code list1} that are not in {@code list2}
*/
public static List intersection(List list1, List list2) {
List result = new ArrayList<>(list1);
result.retainAll(list2);
return result;
}
///
/// Deprecated methods
///
/**
* Return a list of Strings, one per line of the file.
*
* @param argFile argument file
* @return a list of Strings, one per line of the file
* @throws IOException when reading the argFile
* @deprecated use Files.readAllLines
*/
@Deprecated // 2021-03-10
public static List readFile(final File argFile) throws IOException {
final BufferedReader br = new BufferedReader(new FileReader(argFile));
String line;
List lines = new ArrayList<>();
while ((line = br.readLine()) != null) {
lines.add(line);
}
br.close();
return lines;
}
/**
* Like Thread.sleep, but does not throw any exceptions, so it is easier for clients to use.
* Causes the currently executing thread to sleep (temporarily cease execution) for the specified
* number of milliseconds.
*
* @param millis the length of time to sleep in milliseconds
* @deprecated use SystemPlume.sleep
*/
@Deprecated // 2021-03-10
public static void sleep(long millis) {
try {
Thread.sleep(millis);
} catch (InterruptedException ex) {
Thread.currentThread().interrupt();
}
}
/**
* Concatenates an element, an array, and an element.
*
* @param the type of the array elements
* @param firstElt the first element
* @param array the array
* @param lastElt the last elemeent
* @return a new array containing first element, the array, and the last element, in that order
* @deprecated use PlumeUtil.concat
*/
@Deprecated // 2021-03-10
@SuppressWarnings("unchecked")
public static T[] concatenate(T firstElt, T[] array, T lastElt) {
@SuppressWarnings("nullness") // elements are not non-null yet, but will be by return stmt
T[] result = Arrays.copyOf(array, array.length + 2);
result[0] = firstElt;
System.arraycopy(array, 0, result, 1, array.length);
result[result.length - 1] = lastElt;
return result;
}
/**
* Return true if the system property is set to "true". Return false if the system property is not
* set or is set to "false". Otherwise, errs.
*
* @param key system property to check
* @return true if the system property is set to "true". Return false if the system property is
* not set or is set to "false". Otherwise, errs.
* @deprecated use UtilPlume.getBooleanSystemProperty
*/
@Deprecated // 2021-03-28
public static boolean getBooleanSystemProperty(String key) {
return Boolean.parseBoolean(System.getProperty(key, "false"));
}
/**
* Return its boolean value if the system property is set. Return defaultValue if the system
* property is not set. Errs if the system property is set to a non-boolean value.
*
* @param key system property to check
* @param defaultValue value to use if the property is not set
* @return the boolean value of {@code key} or {@code defaultValue} if {@code key} is not set
* @deprecated use UtilPlume.getBooleanSystemProperty
*/
@Deprecated // 2021-03-28
public static boolean getBooleanSystemProperty(String key, boolean defaultValue) {
String value = System.getProperty(key);
if (value == null) {
return defaultValue;
}
if (value.equals("true")) {
return true;
}
if (value.equals("false")) {
return false;
}
throw new UserError(
String.format(
"Value for system property %s should be boolean, but is \"%s\".", key, value));
}
/**
* Concatenates two arrays. Can be invoked varargs-style.
*
* @param the type of the array elements
* @param array1 the first array
* @param array2 the second array
* @return a new array containing the contents of the given arrays, in order
* @deprecated use StringsPlume.concatenate
*/
@Deprecated // 2021-03-28
@SuppressWarnings("unchecked")
public static T[] concatenate(T[] array1, T... array2) {
@SuppressWarnings("nullness") // elements are not non-null yet, but will be by return stmt
T[] result = Arrays.copyOf(array1, array1.length + array2.length);
System.arraycopy(array2, 0, result, array1.length, array2.length);
return result;
}
/**
* Given an expected number of elements, returns the capacity that should be passed to a HashMap
* or HashSet constructor, so that the set or map will not resize.
*
* @param numElements the maximum expected number of elements in the map or set
* @return the initial capacity to pass to a HashMap or HashSet constructor
* @deprecated use CollectionsPlume.mapCapacity
*/
@Deprecated // 2021-05-05
public static int mapCapacity(int numElements) {
// Equivalent to: (int) (numElements / 0.75) + 1
// where 0.75 is the default load factor.
return (numElements * 4 / 3) + 1;
}
/**
* Given an expected number of elements, returns the capacity that should be passed to a HashMap
* or HashSet constructor, so that the set or map will not resize.
*
* @param c a collection whose size is the maximum expected number of elements in the map or set
* @return the initial capacity to pass to a HashMap or HashSet constructor
* @deprecated use CollectionsPlume.mapCapacity
*/
@Deprecated // 2021-05-05
public static int mapCapacity(Collection c) {
return mapCapacity(c.size());
}
/**
* Given an expected number of elements, returns the capacity that should be passed to a HashMap
* or HashSet constructor, so that the set or map will not resize.
*
* @param m a map whose size is the maximum expected number of elements in the map or set
* @return the initial capacity to pass to a HashMap or HashSet constructor
* @deprecated use CollectionsPlume.mapCapacity
*/
@Deprecated // 2021-05-05
public static int mapCapacity(Map m) {
return mapCapacity(m.size());
}
}