544 lines
19 KiB
Java
544 lines
19 KiB
Java
/*
|
|
* Copyright (c) 2009, 2012, Oracle and/or its affiliates. All rights reserved.
|
|
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
*
|
|
* This code is free software; you can redistribute it and/or modify it
|
|
* under the terms of the GNU General Public License version 2 only, as
|
|
* published by the Free Software Foundation. Oracle designates this
|
|
* particular file as subject to the "Classpath" exception as provided
|
|
* by Oracle in the LICENSE file that accompanied this code.
|
|
*
|
|
* This code is distributed in the hope that it will be useful, but WITHOUT
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
* version 2 for more details (a copy is included in the LICENSE file that
|
|
* accompanied this code).
|
|
*
|
|
* You should have received a copy of the GNU General Public License version
|
|
* 2 along with this work; if not, write to the Free Software Foundation,
|
|
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
*
|
|
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
|
* or visit www.oracle.com if you need additional information or have any
|
|
* questions.
|
|
*/
|
|
|
|
package com.sun.tools.javac.nio;
|
|
|
|
import java.io.File;
|
|
import java.io.IOException;
|
|
import java.net.MalformedURLException;
|
|
import java.net.URL;
|
|
import java.nio.charset.Charset;
|
|
import java.nio.file.Files;
|
|
import java.nio.file.FileSystem;
|
|
import java.nio.file.FileSystems;
|
|
import java.nio.file.FileVisitOption;
|
|
import java.nio.file.FileVisitResult;
|
|
import java.nio.file.Path;
|
|
import java.nio.file.SimpleFileVisitor;
|
|
import java.nio.file.attribute.BasicFileAttributes;
|
|
import java.util.ArrayList;
|
|
import java.util.Arrays;
|
|
import java.util.Collection;
|
|
import java.util.Collections;
|
|
import java.util.EnumSet;
|
|
import java.util.HashMap;
|
|
import java.util.Iterator;
|
|
import java.util.LinkedHashSet;
|
|
import java.util.Map;
|
|
import java.util.Set;
|
|
import javax.lang.model.SourceVersion;
|
|
import javax.tools.FileObject;
|
|
import javax.tools.JavaFileManager;
|
|
import javax.tools.JavaFileObject;
|
|
import javax.tools.JavaFileObject.Kind;
|
|
import javax.tools.StandardLocation;
|
|
|
|
import static java.nio.file.FileVisitOption.*;
|
|
import static javax.tools.StandardLocation.*;
|
|
|
|
import com.sun.tools.javac.util.BaseFileManager;
|
|
import com.sun.tools.javac.util.Context;
|
|
import com.sun.tools.javac.util.List;
|
|
import com.sun.tools.javac.util.ListBuffer;
|
|
|
|
import static com.sun.tools.javac.main.Option.*;
|
|
|
|
|
|
// NOTE the imports carefully for this compilation unit.
|
|
//
|
|
// Path: java.nio.file.Path -- the new NIO type for which this file manager exists
|
|
//
|
|
// Paths: com.sun.tools.javac.file.Paths -- legacy javac type for handling path options
|
|
// The other Paths (java.nio.file.Paths) is not used
|
|
|
|
// NOTE this and related classes depend on new API in JDK 7.
|
|
// This requires special handling while bootstrapping the JDK build,
|
|
// when these classes might not yet have been compiled. To workaround
|
|
// this, the build arranges to make stubs of these classes available
|
|
// when compiling this and related classes. The set of stub files
|
|
// is specified in make/build.properties.
|
|
|
|
/**
|
|
* Implementation of PathFileManager: a JavaFileManager based on the use
|
|
* of java.nio.file.Path.
|
|
*
|
|
* <p>Just as a Path is somewhat analagous to a File, so too is this
|
|
* JavacPathFileManager analogous to JavacFileManager, as it relates to the
|
|
* support of FileObjects based on File objects (i.e. just RegularFileObject,
|
|
* not ZipFileObject and its variants.)
|
|
*
|
|
* <p>The default values for the standard locations supported by this file
|
|
* manager are the same as the default values provided by JavacFileManager --
|
|
* i.e. as determined by the javac.file.Paths class. To override these values,
|
|
* call {@link #setLocation}.
|
|
*
|
|
* <p>To reduce confusion with Path objects, the locations such as "class path",
|
|
* "source path", etc, are generically referred to here as "search paths".
|
|
*
|
|
* <p><b>This is NOT part of any supported API.
|
|
* If you write code that depends on this, you do so at your own risk.
|
|
* This code and its internal interfaces are subject to change or
|
|
* deletion without notice.</b>
|
|
*/
|
|
public class JavacPathFileManager extends BaseFileManager implements PathFileManager {
|
|
protected FileSystem defaultFileSystem;
|
|
|
|
/**
|
|
* Create a JavacPathFileManager using a given context, optionally registering
|
|
* it as the JavaFileManager for that context.
|
|
*/
|
|
public JavacPathFileManager(Context context, boolean register, Charset charset) {
|
|
super(charset);
|
|
if (register)
|
|
context.put(JavaFileManager.class, this);
|
|
pathsForLocation = new HashMap<Location, PathsForLocation>();
|
|
fileSystems = new HashMap<Path,FileSystem>();
|
|
setContext(context);
|
|
}
|
|
|
|
/**
|
|
* Set the context for JavacPathFileManager.
|
|
*/
|
|
@Override
|
|
public void setContext(Context context) {
|
|
super.setContext(context);
|
|
}
|
|
|
|
@Override
|
|
public FileSystem getDefaultFileSystem() {
|
|
if (defaultFileSystem == null)
|
|
defaultFileSystem = FileSystems.getDefault();
|
|
return defaultFileSystem;
|
|
}
|
|
|
|
@Override
|
|
public void setDefaultFileSystem(FileSystem fs) {
|
|
defaultFileSystem = fs;
|
|
}
|
|
|
|
@Override
|
|
public void flush() throws IOException {
|
|
contentCache.clear();
|
|
}
|
|
|
|
@Override
|
|
public void close() throws IOException {
|
|
for (FileSystem fs: fileSystems.values())
|
|
fs.close();
|
|
}
|
|
|
|
@Override
|
|
public ClassLoader getClassLoader(Location location) {
|
|
nullCheck(location);
|
|
Iterable<? extends Path> path = getLocation(location);
|
|
if (path == null)
|
|
return null;
|
|
ListBuffer<URL> lb = new ListBuffer<URL>();
|
|
for (Path p: path) {
|
|
try {
|
|
lb.append(p.toUri().toURL());
|
|
} catch (MalformedURLException e) {
|
|
throw new AssertionError(e);
|
|
}
|
|
}
|
|
|
|
return getClassLoader(lb.toArray(new URL[lb.size()]));
|
|
}
|
|
|
|
@Override
|
|
public boolean isDefaultBootClassPath() {
|
|
return locations.isDefaultBootClassPath();
|
|
}
|
|
|
|
// <editor-fold defaultstate="collapsed" desc="Location handling">
|
|
|
|
public boolean hasLocation(Location location) {
|
|
return (getLocation(location) != null);
|
|
}
|
|
|
|
public Iterable<? extends Path> getLocation(Location location) {
|
|
nullCheck(location);
|
|
lazyInitSearchPaths();
|
|
PathsForLocation path = pathsForLocation.get(location);
|
|
if (path == null && !pathsForLocation.containsKey(location)) {
|
|
setDefaultForLocation(location);
|
|
path = pathsForLocation.get(location);
|
|
}
|
|
return path;
|
|
}
|
|
|
|
private Path getOutputLocation(Location location) {
|
|
Iterable<? extends Path> paths = getLocation(location);
|
|
return (paths == null ? null : paths.iterator().next());
|
|
}
|
|
|
|
public void setLocation(Location location, Iterable<? extends Path> searchPath)
|
|
throws IOException
|
|
{
|
|
nullCheck(location);
|
|
lazyInitSearchPaths();
|
|
if (searchPath == null) {
|
|
setDefaultForLocation(location);
|
|
} else {
|
|
if (location.isOutputLocation())
|
|
checkOutputPath(searchPath);
|
|
PathsForLocation pl = new PathsForLocation();
|
|
for (Path p: searchPath)
|
|
pl.add(p); // TODO -Xlint:path warn if path not found
|
|
pathsForLocation.put(location, pl);
|
|
}
|
|
}
|
|
|
|
private void checkOutputPath(Iterable<? extends Path> searchPath) throws IOException {
|
|
Iterator<? extends Path> pathIter = searchPath.iterator();
|
|
if (!pathIter.hasNext())
|
|
throw new IllegalArgumentException("empty path for directory");
|
|
Path path = pathIter.next();
|
|
if (pathIter.hasNext())
|
|
throw new IllegalArgumentException("path too long for directory");
|
|
if (!isDirectory(path))
|
|
throw new IOException(path + ": not a directory");
|
|
}
|
|
|
|
private void setDefaultForLocation(Location locn) {
|
|
Collection<File> files = null;
|
|
if (locn instanceof StandardLocation) {
|
|
switch ((StandardLocation) locn) {
|
|
case CLASS_PATH:
|
|
files = locations.userClassPath();
|
|
break;
|
|
case PLATFORM_CLASS_PATH:
|
|
files = locations.bootClassPath();
|
|
break;
|
|
case SOURCE_PATH:
|
|
files = locations.sourcePath();
|
|
break;
|
|
case CLASS_OUTPUT: {
|
|
String arg = options.get(D);
|
|
files = (arg == null ? null : Collections.singleton(new File(arg)));
|
|
break;
|
|
}
|
|
case SOURCE_OUTPUT: {
|
|
String arg = options.get(S);
|
|
files = (arg == null ? null : Collections.singleton(new File(arg)));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
PathsForLocation pl = new PathsForLocation();
|
|
if (files != null) {
|
|
for (File f: files)
|
|
pl.add(f.toPath());
|
|
}
|
|
if (!pl.isEmpty())
|
|
pathsForLocation.put(locn, pl);
|
|
}
|
|
|
|
private void lazyInitSearchPaths() {
|
|
if (!inited) {
|
|
setDefaultForLocation(PLATFORM_CLASS_PATH);
|
|
setDefaultForLocation(CLASS_PATH);
|
|
setDefaultForLocation(SOURCE_PATH);
|
|
inited = true;
|
|
}
|
|
}
|
|
// where
|
|
private boolean inited = false;
|
|
|
|
private Map<Location, PathsForLocation> pathsForLocation;
|
|
|
|
private static class PathsForLocation extends LinkedHashSet<Path> {
|
|
private static final long serialVersionUID = 6788510222394486733L;
|
|
}
|
|
|
|
// </editor-fold>
|
|
|
|
// <editor-fold defaultstate="collapsed" desc="FileObject handling">
|
|
|
|
@Override
|
|
public Path getPath(FileObject fo) {
|
|
nullCheck(fo);
|
|
if (!(fo instanceof PathFileObject))
|
|
throw new IllegalArgumentException();
|
|
return ((PathFileObject) fo).getPath();
|
|
}
|
|
|
|
@Override
|
|
public boolean isSameFile(FileObject a, FileObject b) {
|
|
nullCheck(a);
|
|
nullCheck(b);
|
|
if (!(a instanceof PathFileObject))
|
|
throw new IllegalArgumentException("Not supported: " + a);
|
|
if (!(b instanceof PathFileObject))
|
|
throw new IllegalArgumentException("Not supported: " + b);
|
|
return ((PathFileObject) a).isSameFile((PathFileObject) b);
|
|
}
|
|
|
|
@Override
|
|
public Iterable<JavaFileObject> list(Location location,
|
|
String packageName, Set<Kind> kinds, boolean recurse)
|
|
throws IOException {
|
|
// validatePackageName(packageName);
|
|
nullCheck(packageName);
|
|
nullCheck(kinds);
|
|
|
|
Iterable<? extends Path> paths = getLocation(location);
|
|
if (paths == null)
|
|
return List.nil();
|
|
ListBuffer<JavaFileObject> results = new ListBuffer<JavaFileObject>();
|
|
|
|
for (Path path : paths)
|
|
list(path, packageName, kinds, recurse, results);
|
|
|
|
return results.toList();
|
|
}
|
|
|
|
private void list(Path path, String packageName, final Set<Kind> kinds,
|
|
boolean recurse, final ListBuffer<JavaFileObject> results)
|
|
throws IOException {
|
|
if (!Files.exists(path))
|
|
return;
|
|
|
|
final Path pathDir;
|
|
if (isDirectory(path))
|
|
pathDir = path;
|
|
else {
|
|
FileSystem fs = getFileSystem(path);
|
|
if (fs == null)
|
|
return;
|
|
pathDir = fs.getRootDirectories().iterator().next();
|
|
}
|
|
String sep = path.getFileSystem().getSeparator();
|
|
Path packageDir = packageName.isEmpty() ? pathDir
|
|
: pathDir.resolve(packageName.replace(".", sep));
|
|
if (!Files.exists(packageDir))
|
|
return;
|
|
|
|
/* Alternate impl of list, superceded by use of Files.walkFileTree */
|
|
// Deque<Path> queue = new LinkedList<Path>();
|
|
// queue.add(packageDir);
|
|
//
|
|
// Path dir;
|
|
// while ((dir = queue.poll()) != null) {
|
|
// DirectoryStream<Path> ds = dir.newDirectoryStream();
|
|
// try {
|
|
// for (Path p: ds) {
|
|
// String name = p.getFileName().toString();
|
|
// if (isDirectory(p)) {
|
|
// if (recurse && SourceVersion.isIdentifier(name)) {
|
|
// queue.add(p);
|
|
// }
|
|
// } else {
|
|
// if (kinds.contains(getKind(name))) {
|
|
// JavaFileObject fe =
|
|
// PathFileObject.createDirectoryPathFileObject(this, p, pathDir);
|
|
// results.append(fe);
|
|
// }
|
|
// }
|
|
// }
|
|
// } finally {
|
|
// ds.close();
|
|
// }
|
|
// }
|
|
int maxDepth = (recurse ? Integer.MAX_VALUE : 1);
|
|
Set<FileVisitOption> opts = EnumSet.of(FOLLOW_LINKS);
|
|
Files.walkFileTree(packageDir, opts, maxDepth,
|
|
new SimpleFileVisitor<Path>() {
|
|
@Override
|
|
public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) {
|
|
Path name = dir.getFileName();
|
|
if (name == null || SourceVersion.isIdentifier(name.toString())) // JSR 292?
|
|
return FileVisitResult.CONTINUE;
|
|
else
|
|
return FileVisitResult.SKIP_SUBTREE;
|
|
}
|
|
|
|
@Override
|
|
public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) {
|
|
if (attrs.isRegularFile() && kinds.contains(getKind(file.getFileName().toString()))) {
|
|
JavaFileObject fe =
|
|
PathFileObject.createDirectoryPathFileObject(
|
|
JavacPathFileManager.this, file, pathDir);
|
|
results.append(fe);
|
|
}
|
|
return FileVisitResult.CONTINUE;
|
|
}
|
|
});
|
|
}
|
|
|
|
@Override
|
|
public Iterable<? extends JavaFileObject> getJavaFileObjectsFromPaths(
|
|
Iterable<? extends Path> paths) {
|
|
ArrayList<PathFileObject> result;
|
|
if (paths instanceof Collection<?>)
|
|
result = new ArrayList<PathFileObject>(((Collection<?>)paths).size());
|
|
else
|
|
result = new ArrayList<PathFileObject>();
|
|
for (Path p: paths)
|
|
result.add(PathFileObject.createSimplePathFileObject(this, nullCheck(p)));
|
|
return result;
|
|
}
|
|
|
|
@Override
|
|
public Iterable<? extends JavaFileObject> getJavaFileObjects(Path... paths) {
|
|
return getJavaFileObjectsFromPaths(Arrays.asList(nullCheck(paths)));
|
|
}
|
|
|
|
@Override
|
|
public JavaFileObject getJavaFileForInput(Location location,
|
|
String className, Kind kind) throws IOException {
|
|
return getFileForInput(location, getRelativePath(className, kind));
|
|
}
|
|
|
|
@Override
|
|
public FileObject getFileForInput(Location location,
|
|
String packageName, String relativeName) throws IOException {
|
|
return getFileForInput(location, getRelativePath(packageName, relativeName));
|
|
}
|
|
|
|
private JavaFileObject getFileForInput(Location location, String relativePath)
|
|
throws IOException {
|
|
for (Path p: getLocation(location)) {
|
|
if (isDirectory(p)) {
|
|
Path f = resolve(p, relativePath);
|
|
if (Files.exists(f))
|
|
return PathFileObject.createDirectoryPathFileObject(this, f, p);
|
|
} else {
|
|
FileSystem fs = getFileSystem(p);
|
|
if (fs != null) {
|
|
Path file = getPath(fs, relativePath);
|
|
if (Files.exists(file))
|
|
return PathFileObject.createJarPathFileObject(this, file);
|
|
}
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
@Override
|
|
public JavaFileObject getJavaFileForOutput(Location location,
|
|
String className, Kind kind, FileObject sibling) throws IOException {
|
|
return getFileForOutput(location, getRelativePath(className, kind), sibling);
|
|
}
|
|
|
|
@Override
|
|
public FileObject getFileForOutput(Location location, String packageName,
|
|
String relativeName, FileObject sibling)
|
|
throws IOException {
|
|
return getFileForOutput(location, getRelativePath(packageName, relativeName), sibling);
|
|
}
|
|
|
|
private JavaFileObject getFileForOutput(Location location,
|
|
String relativePath, FileObject sibling) {
|
|
Path dir = getOutputLocation(location);
|
|
if (dir == null) {
|
|
if (location == CLASS_OUTPUT) {
|
|
Path siblingDir = null;
|
|
if (sibling != null && sibling instanceof PathFileObject) {
|
|
siblingDir = ((PathFileObject) sibling).getPath().getParent();
|
|
}
|
|
return PathFileObject.createSiblingPathFileObject(this,
|
|
siblingDir.resolve(getBaseName(relativePath)),
|
|
relativePath);
|
|
} else if (location == SOURCE_OUTPUT) {
|
|
dir = getOutputLocation(CLASS_OUTPUT);
|
|
}
|
|
}
|
|
|
|
Path file;
|
|
if (dir != null) {
|
|
file = resolve(dir, relativePath);
|
|
return PathFileObject.createDirectoryPathFileObject(this, file, dir);
|
|
} else {
|
|
file = getPath(getDefaultFileSystem(), relativePath);
|
|
return PathFileObject.createSimplePathFileObject(this, file);
|
|
}
|
|
|
|
}
|
|
|
|
@Override
|
|
public String inferBinaryName(Location location, JavaFileObject fo) {
|
|
nullCheck(fo);
|
|
// Need to match the path semantics of list(location, ...)
|
|
Iterable<? extends Path> paths = getLocation(location);
|
|
if (paths == null) {
|
|
return null;
|
|
}
|
|
|
|
if (!(fo instanceof PathFileObject))
|
|
throw new IllegalArgumentException(fo.getClass().getName());
|
|
|
|
return ((PathFileObject) fo).inferBinaryName(paths);
|
|
}
|
|
|
|
private FileSystem getFileSystem(Path p) throws IOException {
|
|
FileSystem fs = fileSystems.get(p);
|
|
if (fs == null) {
|
|
fs = FileSystems.newFileSystem(p, null);
|
|
fileSystems.put(p, fs);
|
|
}
|
|
return fs;
|
|
}
|
|
|
|
private Map<Path,FileSystem> fileSystems;
|
|
|
|
// </editor-fold>
|
|
|
|
// <editor-fold defaultstate="collapsed" desc="Utility methods">
|
|
|
|
private static String getRelativePath(String className, Kind kind) {
|
|
return className.replace(".", "/") + kind.extension;
|
|
}
|
|
|
|
private static String getRelativePath(String packageName, String relativeName) {
|
|
return packageName.isEmpty()
|
|
? relativeName : packageName.replace(".", "/") + "/" + relativeName;
|
|
}
|
|
|
|
private static String getBaseName(String relativePath) {
|
|
int lastSep = relativePath.lastIndexOf("/");
|
|
return relativePath.substring(lastSep + 1); // safe if "/" not found
|
|
}
|
|
|
|
private static boolean isDirectory(Path path) throws IOException {
|
|
BasicFileAttributes attrs = Files.readAttributes(path, BasicFileAttributes.class);
|
|
return attrs.isDirectory();
|
|
}
|
|
|
|
private static Path getPath(FileSystem fs, String relativePath) {
|
|
return fs.getPath(relativePath.replace("/", fs.getSeparator()));
|
|
}
|
|
|
|
private static Path resolve(Path base, String relativePath) {
|
|
FileSystem fs = base.getFileSystem();
|
|
Path rp = fs.getPath(relativePath.replace("/", fs.getSeparator()));
|
|
return base.resolve(rp);
|
|
}
|
|
|
|
// </editor-fold>
|
|
|
|
}
|