jdk-sandbox: comparison langtools/src/jdk.compiler/share/classes/com/sun/tools/javac/file/Locations.java

equal deleted inserted replaced

-:2efb75c09230
+:1153fab98d25
 import javax.lang.model.SourceVersion;
 import javax.tools.JavaFileManager;
 import javax.tools.JavaFileManager.Location;
 import javax.tools.StandardJavaFileManager;
+import javax.tools.StandardJavaFileManager.PathFactory;
 import javax.tools.StandardLocation;
 import com.sun.tools.javac.code.Lint;
 import com.sun.tools.javac.main.Option;
 import com.sun.tools.javac.resources.CompilerProperties.Errors;
 */
 private boolean warn;
 private ModuleNameReader moduleNameReader;
-static final Path javaHome = Paths.get(System.getProperty("java.home"));
+private PathFactory pathFactory = Paths::get;
+static final Path javaHome = FileSystems.getDefault().getPath(System.getProperty("java.home"));
 static final Path thisSystemModules = javaHome.resolve("lib").resolve("modules");
 Map<Path, FileSystem> fileSystems = new LinkedHashMap<>();
 List<Closeable> closeables = new ArrayList<>();
 Locations() {
 initHandlers();
+}
+Path getPath(String first, String... more) {
+return pathFactory.getPath(first, more);
 }
 public void close() throws IOException {
 ListBuffer<IOException> list = new ListBuffer<>();
 closeables.forEach(closeable -> {
 this.log = log;
 warn = lint.isEnabled(Lint.LintCategory.PATH);
 this.fsInfo = fsInfo;
 }
+void setPathFactory(PathFactory f) {
+pathFactory = f;
+}
 boolean isDefaultBootClassPath() {
 BootClassPathLocationHandler h
 = (BootClassPathLocationHandler) getHandler(PLATFORM_CLASS_PATH);
 return h.isDefault();
 }
 * Split a search path into its elements. Empty path elements will be ignored.
 *
 * @param searchPath The search path to be split
 * @return The elements of the path
 */
-private static Iterable<Path> getPathEntries(String searchPath) {
+private Iterable<Path> getPathEntries(String searchPath) {
 return getPathEntries(searchPath, null);
 }
 /**
 * Split a search path into its elements. If emptyPathDefault is not null, all empty elements in the
 * @param searchPath The search path to be split
 * @param emptyPathDefault The value to substitute for empty path elements, or null, to ignore
 * empty path elements
 * @return The elements of the path
 */
-private static Iterable<Path> getPathEntries(String searchPath, Path emptyPathDefault) {
+private Iterable<Path> getPathEntries(String searchPath, Path emptyPathDefault) {
 ListBuffer<Path> entries = new ListBuffer<>();
 for (String s: searchPath.split(Pattern.quote(File.pathSeparator), -1)) {
 if (s.isEmpty()) {
 if (emptyPathDefault != null) {
 entries.add(emptyPathDefault);
 }
 } else {
-entries.add(Paths.get(s));
+entries.add(getPath(s));
 }
 }
 return entries;
 }
 // TODO: could/should validate outputDir exists and is a directory
 // need to decide how best to report issue for benefit of
 // direct API call on JavaFileManager.handleOption(specifies IAE)
 // vs. command line decoding.
-outputDir = (value == null) ? null : Paths.get(value);
+outputDir = (value == null) ? null : getPath(value);
 return true;
 }
 @Override
 Collection<Path> getPaths() {
 @Override
 protected SearchPath createPath() {
 return new SearchPath()
 .expandJarClassPaths(true) // Only search user jars for Class-Paths
-.emptyPathDefault(Paths.get("."));  // Empty path elt ==> current directory
+.emptyPathDefault(getPath("."));  // Empty path elt ==> current directory
 }
 private void lazy() {
 if (searchPath == null) {
 setPaths(null);
 // entries should be appended to the set of modules.
 paths.addAll(modules);
 for (String s : files.split(Pattern.quote(File.pathSeparator))) {
-paths.add(Paths.get(s));
+paths.add(getPath(s));
 }
 return paths;
 }
 Map<String, Collection<Path>> map = new LinkedHashMap<>();
 final String MARKER = "*";
 for (String seg: segments) {
 int markStart = seg.indexOf(MARKER);
 if (markStart == -1) {
-add(map, Paths.get(seg), null);
+add(map, getPath(seg), null);
 } else {
 if (markStart == 0 || !isSeparator(seg.charAt(markStart - 1))) {
 throw new IllegalArgumentException("illegal use of " + MARKER + " in " + seg);
 }
-Path prefix = Paths.get(seg.substring(0, markStart - 1));
+Path prefix = getPath(seg.substring(0, markStart - 1));
 Path suffix;
 int markEnd = markStart + MARKER.length();
 if (markEnd == seg.length()) {
 suffix = null;
 } else if (!isSeparator(seg.charAt(markEnd))
 || seg.indexOf(MARKER, markEnd) != -1) {
 throw new IllegalArgumentException("illegal use of " + MARKER + " in " + seg);
 } else {
-suffix = Paths.get(seg.substring(markEnd + 1));
+suffix = getPath(seg.substring(markEnd + 1));
 }
 add(map, prefix, suffix);
 }
 }
 }
 }
 private class SystemModulesLocationHandler extends BasicLocationHandler {
-private Path javaHome;
+private Path systemJavaHome;
 private Path modules;
 private Map<String, ModuleLocationHandler> systemModules;
 SystemModulesLocationHandler() {
 super(StandardLocation.SYSTEM_MODULES, Option.SYSTEM);
-javaHome = Paths.get(System.getProperty("java.home"));
+systemJavaHome = Locations.javaHome;
 }
 @Override
 boolean handleOption(Option option, String value) {
 if (!options.contains(option)) {
 return false;
 }
 if (value == null) {
-javaHome = Paths.get(System.getProperty("java.home"));
+systemJavaHome = Locations.javaHome;
 } else if (value.equals("none")) {
-javaHome = null;
+systemJavaHome = null;
 } else {
-update(Paths.get(value));
+update(getPath(value));
 }
 modules = null;
 return true;
 }
 @Override
 Collection<Path> getPaths() {
-return (javaHome == null) ? null : Collections.singleton(javaHome);
+return (systemJavaHome == null) ? null : Collections.singleton(systemJavaHome);
 }
 @Override
 void setPaths(Iterable<? extends Path> files) throws IOException {
 if (files == null) {
-javaHome = null;
+systemJavaHome = null;
 } else {
 Iterator<? extends Path> pathIter = files.iterator();
 if (!pathIter.hasNext()) {
 throw new IllegalArgumentException("empty path for directory"); // TODO: FIXME
 }
 update(dir);
 }
 }
 private void update(Path p) {
-if (!isCurrentPlatform(p) && !Files.exists(p.resolve("jrt-fs.jar")) && !Files.exists(javaHome.resolve("modules")))
+if (!isCurrentPlatform(p) && !Files.exists(p.resolve("jrt-fs.jar")) && !Files.exists(systemJavaHome.resolve("modules")))
 throw new IllegalArgumentException(p.toString());
-javaHome = p;
+systemJavaHome = p;
 modules = null;
 }
 private boolean isCurrentPlatform(Path p) {
-Path jh = Paths.get(System.getProperty("java.home"));
 try {
-return Files.isSameFile(p, jh);
+return Files.isSameFile(p, Locations.javaHome);
 } catch (IOException ex) {
 throw new IllegalArgumentException(p.toString(), ex);
 }
 }
 private void initSystemModules() throws IOException {
 if (systemModules != null) {
 return;
 }
-if (javaHome == null) {
+if (systemJavaHome == null) {
 systemModules = Collections.emptyMap();
 return;
 }
 if (modules == null) {
 try {
 URI jrtURI = URI.create("jrt:/");
 FileSystem jrtfs;
-if (isCurrentPlatform(javaHome)) {
+if (isCurrentPlatform(systemJavaHome)) {
 jrtfs = FileSystems.getFileSystem(jrtURI);
 } else {
 try {
 Map<String, String> attrMap =
-Collections.singletonMap("java.home", javaHome.toString());
+Collections.singletonMap("java.home", systemJavaHome.toString());
 jrtfs = FileSystems.newFileSystem(jrtURI, attrMap);
 } catch (ProviderNotFoundException ex) {
-URL javaHomeURL = javaHome.resolve("jrt-fs.jar").toUri().toURL();
+URL javaHomeURL = systemJavaHome.resolve("jrt-fs.jar").toUri().toURL();
 ClassLoader currentLoader = Locations.class.getClassLoader();
 URLClassLoader fsLoader =
 new URLClassLoader(new URL[] {javaHomeURL}, currentLoader);
 jrtfs = FileSystems.newFileSystem(jrtURI, Collections.emptyMap(), fsLoader);
 closeables.add(jrtfs);
 }
 modules = jrtfs.getPath("/modules");
 } catch (FileSystemNotFoundException | ProviderNotFoundException e) {
-modules = javaHome.resolve("modules");
+modules = systemJavaHome.resolve("modules");
 if (!Files.exists(modules))
 throw new IOException("can't find system classes", e);
 }
 }

changeset 37944	1153fab98d25
parent 37848	3c8ff4204d2d
child 38519	d70d50ec27bb