jdk-sandbox: comparison jdk/src/jdk.rmic/share/classes/sun/tools/java/ClassPath.java

equal deleted inserted replaced

-:eaaa79b68cd5
+:729f9700483a
 * questions.
 */
 package sun.tools.java;
-import java.util.Enumeration;
-import java.util.Hashtable;
 import java.io.File;
 import java.io.IOException;
+import java.io.UncheckedIOException;
 import java.util.zip.*;
+import java.util.Enumeration;
+import java.util.Map;
+import java.util.HashMap;
+import java.util.Hashtable;
+import java.util.Set;
+import java.util.LinkedHashSet;
+import java.net.URI;
+import java.nio.file.DirectoryStream;
+import java.nio.file.Files;
+import java.nio.file.FileSystem;
+import java.nio.file.FileSystems;
+import java.nio.file.Path;
+import java.nio.file.spi.FileSystemProvider;
 /**
 * This class is used to represent a class path, which can contain both
 * directories and zip files.
 *
 * supported API.  Code that depends on them does so at its own risk:
 * they are subject to change or removal without notice.
 */
 public
 class ClassPath {
+private static final String JIMAGE_EXT = ".jimage";
+private FileSystem getJrtFileSystem() {
+return FileSystems.getFileSystem(URI.create("jrt:/"));
+}
 static final char dirSeparator = File.pathSeparatorChar;
 /**
 * The original class path string
 */
 n++; i++;
 }
 // Build the class path
 ClassPathEntry[] path = new ClassPathEntry[n+1];
 int len = pathstr.length();
+boolean jrtAdded = false;
 for (i = n = 0; i < len; i = j + 1) {
 if ((j = pathstr.indexOf(dirSeparator, i)) == -1) {
 j = len;
 }
 if (i == j) {
-path[n] = new ClassPathEntry();
+path[n++] = new DirClassPathEntry(new File("."));
-path[n++].dir = new File(".");
 } else {
-File file = new File(pathstr.substring(i, j));
+String filename = pathstr.substring(i, j);
+File file = new File(filename);
 if (file.isFile()) {
-try {
+if (filename.endsWith(JIMAGE_EXT)) {
-ZipFile zip = new ZipFile(file);
+if (jrtAdded) continue;
-path[n] = new ClassPathEntry();
+FileSystem fs = getJrtFileSystem();
-path[n++].zip = zip;
+path[n++] = new JrtClassPathEntry(fs);
-} catch (ZipException e) {
+jrtAdded = true;
-} catch (IOException e) {
+} else {
-// Ignore exceptions, at least for now...
+try {
+ZipFile zip = new ZipFile(file);
+path[n++] = new ZipClassPathEntry(zip);
+} catch (ZipException e) {
+} catch (IOException e) {
+// Ignore exceptions, at least for now...
+}
 }
 } else {
-path[n] = new ClassPathEntry();
+path[n++] = new DirClassPathEntry(file);
-path[n++].dir = file;
 }
 }
 }
 // Trim class path to exact size
 this.path = new ClassPathEntry[n];
 }
 // Build the class path
 ClassPathEntry[] path = new ClassPathEntry[patharray.length];
 int n = 0;
+boolean jrtAdded = false;
 for (String name : patharray) {
 File file = new File(name);
 if (file.isFile()) {
-try {
+if (name.endsWith(JIMAGE_EXT)) {
-ZipFile zip = new ZipFile(file);
+if (jrtAdded) continue;
-path[n] = new ClassPathEntry();
+FileSystem fs = getJrtFileSystem();
-path[n++].zip = zip;
+path[n++] = new JrtClassPathEntry(fs);
-} catch (ZipException e) {
+jrtAdded = true;
-} catch (IOException e) {
+} else {
-// Ignore exceptions, at least for now...
+try {
-}
+ZipFile zip = new ZipFile(file);
+path[n++] = new ZipClassPathEntry(zip);
+} catch (ZipException e) {
+} catch (IOException e) {
+// Ignore exceptions, at least for now...
+}
+}
 } else {
-path[n] = new ClassPathEntry();
+path[n++] = new DirClassPathEntry(file);
-path[n++].dir = file;
 }
 }
 // Trim class path to exact size
 this.path = new ClassPathEntry[n];
 System.arraycopy((Object)path, 0, (Object)this.path, 0, n);
 // also, the getFiles caches are keyed with a trailing /
 subdir = subdir + File.separatorChar;
 name = subdir;      // Note: isDirectory==true & basename==""
 }
 for (int i = 0; i < path.length; i++) {
-if (path[i].zip != null) {
+ClassFile cf = path[i].getFile(name, subdir, basename, isDirectory);
-String newname = name.replace(File.separatorChar, '/');
+if (cf != null) {
-ZipEntry entry = path[i].zip.getEntry(newname);
+return cf;
-if (entry != null) {
+}
-return new ClassFile(path[i].zip, entry);
+}
+return null;
+}
+/**
+* Returns list of files given a package name and extension.
+*/
+public Enumeration<ClassFile> getFiles(String pkg, String ext) {
+Hashtable<String, ClassFile> files = new Hashtable<>();
+for (int i = path.length; --i >= 0; ) {
+path[i].fillFiles(pkg, ext, files);
+}
+return files.elements();
+}
+/**
+* Release resources.
+*/
+public void close() throws IOException {
+for (int i = path.length; --i >= 0; ) {
+path[i].close();
+}
+}
+/**
+* Returns original class path string
+*/
+public String toString() {
+return pathstr;
+}
+}
+/**
+* A class path entry, which can either be a directory or an open zip file or an open jimage filesystem.
+*/
+abstract class ClassPathEntry {
+abstract ClassFile getFile(String name, String subdir, String basename, boolean isDirectory);
+abstract void fillFiles(String pkg, String ext, Hashtable<String, ClassFile> files);
+abstract void close() throws IOException;
+}
+// a ClassPathEntry that represents a directory
+final class DirClassPathEntry extends ClassPathEntry {
+private final File dir;
+DirClassPathEntry(File dir) {
+this.dir = dir;
+}
+private final Hashtable<String, String[]> subdirs = new Hashtable<>(29); // cache of sub-directory listings:
+private String[] getFiles(String subdir) {
+String files[] = subdirs.get(subdir);
+if (files == null) {
+files = computeFiles(subdir);
+subdirs.put(subdir, files);
+}
+return files;
+}
+private String[] computeFiles(String subdir) {
+File sd = new File(dir.getPath(), subdir);
+String[] files = null;
+if (sd.isDirectory()) {
+files = sd.list();
+if (files == null) {
+// should not happen, but just in case, fail silently
+files = new String[0];
+}
+if (files.length == 0) {
+String nonEmpty[] = { "" };
+files = nonEmpty;
+}
+} else {
+files = new String[0];
+}
+return files;
+}
+ClassFile getFile(String name,  String subdir, String basename, boolean isDirectory) {
+File file = new File(dir.getPath(), name);
+String list[] = getFiles(subdir);
+if (isDirectory) {
+if (list.length > 0) {
+return ClassFile.newClassFile(file);
+}
+} else {
+for (int j = 0; j < list.length; j++) {
+if (basename.equals(list[j])) {
+// Don't bother checking !file.isDir,
+// since we only look for names which
+// cannot already be packages (foo.java, etc).
+return ClassFile.newClassFile(file);
 }
-} else {
+}
-File file = new File(path[i].dir.getPath(), name);
+}
-String list[] = path[i].getFiles(subdir);
+return null;
-if (isDirectory) {
+}
-if (list.length > 0) {
-return new ClassFile(file);
+void fillFiles(String pkg, String ext, Hashtable<String, ClassFile> files) {
-}
+String[] list = getFiles(pkg);
-} else {
+for (int j = 0; j < list.length; j++) {
-for (int j = 0; j < list.length; j++) {
+String name = list[j];
-if (basename.equals(list[j])) {
+if (name.endsWith(ext)) {
-// Don't bother checking !file.isDir,
+name = pkg + File.separatorChar + name;
-// since we only look for names which
+File file = new File(dir.getPath(), name);
-// cannot already be packages (foo.java, etc).
+files.put(name, ClassFile.newClassFile(file));
-return new ClassFile(file);
+}
+}
+}
+void close() throws IOException {
+}
+}
+// a ClassPathEntry that represents a .zip or a .jar file
+final class ZipClassPathEntry extends ClassPathEntry {
+private final ZipFile zip;
+ZipClassPathEntry(ZipFile zip) {
+this.zip = zip;
+}
+void close() throws IOException {
+zip.close();
+}
+ClassFile getFile(String name, String subdir, String basename, boolean isDirectory) {
+String newname = name.replace(File.separatorChar, '/');
+ZipEntry entry = zip.getEntry(newname);
+return entry != null? ClassFile.newClassFile(zip, entry) : null;
+}
+void fillFiles(String pkg, String ext, Hashtable<String, ClassFile> files) {
+Enumeration<? extends ZipEntry> e = zip.entries();
+while (e.hasMoreElements()) {
+ZipEntry entry = (ZipEntry)e.nextElement();
+String name = entry.getName();
+name = name.replace('/', File.separatorChar);
+if (name.startsWith(pkg) && name.endsWith(ext)) {
+files.put(name, ClassFile.newClassFile(zip, entry));
+}
+}
+}
+}
+// a ClassPathEntry that represents jrt file system
+final class JrtClassPathEntry extends ClassPathEntry {
+private final FileSystem fs;
+// module directory paths in jrt fs
+private final Set<Path> jrtModules;
+// package name to package directory path mapping (lazily filled)
+private final Map<String, Path> pkgDirs;
+JrtClassPathEntry(FileSystem fs) {
+this.fs = fs;
+this.jrtModules = new LinkedHashSet<>();
+this.pkgDirs = new HashMap<>();
+// fill in module directories at the root dir
+Path root = fs.getPath("/");
+try {
+try (DirectoryStream<Path> stream = Files.newDirectoryStream(root)) {
+for (Path entry: stream) {
+if (Files.isDirectory(entry))
+jrtModules.add(entry);
+}
+}
+} catch (IOException ioExp) {
+throw new UncheckedIOException(ioExp);
+}
+}
+void close() throws IOException {
+}
+// from pkgName (internal separator '/') to it's Path in jrtfs
+synchronized Path getPackagePath(String pkgName) throws IOException {
+// check the cache first
+if (pkgDirs.containsKey(pkgName)) {
+return pkgDirs.get(pkgName);
+}
+for (Path modPath : jrtModules) {
+Path pkgDir = fs.getPath(modPath.toString(), pkgName);
+// check if package directory is under any of the known modules
+if (Files.exists(pkgDir)) {
+// it is a package directory only if contains atleast one .class file
+try (DirectoryStream<Path> stream = Files.newDirectoryStream(pkgDir)) {
+for (Path p : stream) {
+if (Files.isRegularFile(p) && p.toString().endsWith(".class")) {
+// cache package-to-package dir mapping for future
+pkgDirs.put(pkgName, pkgDir);
+return pkgDir;
 }
 }
 }
 }
 }
 return null;
 }
-/**
+// fully qualified (internal) class name to it's Path in jrtfs
-* Returns list of files given a package name and extension.
+Path getClassPath(String clsName) throws IOException {
-*/
+int index = clsName.lastIndexOf('/');
-public Enumeration<ClassFile> getFiles(String pkg, String ext) {
+if (index == -1) {
-Hashtable<String, ClassFile> files = new Hashtable<>();
+return null;
-for (int i = path.length; --i >= 0; ) {
+}
-if (path[i].zip != null) {
+Path pkgPath = getPackagePath(clsName.substring(0, index));
-Enumeration<? extends ZipEntry> e = path[i].zip.entries();
+return pkgPath == null? null : fs.getPath(pkgPath + "/" + clsName.substring(index + 1));
-while (e.hasMoreElements()) {
+}
-ZipEntry entry = (ZipEntry)e.nextElement();
-String name = entry.getName();
+ClassFile getFile(String name, String subdir, String basename, boolean isDirectory) {
-name = name.replace('/', File.separatorChar);
+try {
-if (name.startsWith(pkg) && name.endsWith(ext)) {
+name = name.replace(File.separatorChar, '/');
-files.put(name, new ClassFile(path[i].zip, entry));
+Path cp = getClassPath(name);
-}
+return cp == null? null : ClassFile.newClassFile(cp);
+} catch (IOException ioExp) {
+throw new UncheckedIOException(ioExp);
+}
+}
+void fillFiles(String pkg, String ext, Hashtable<String, ClassFile> files) {
+Path dir;
+try {
+dir = getPackagePath(pkg);
+if (dir == null) {
+return;
+}
+} catch (IOException ioExp) {
+throw new UncheckedIOException(ioExp);
+}
+try (DirectoryStream<Path> stream = Files.newDirectoryStream(dir)) {
+for (Path p : stream) {
+String name = p.toString();
+name = name.replace('/', File.separatorChar);
+if (name.startsWith(pkg) && name.endsWith(ext)) {
+files.put(name, ClassFile.newClassFile(p));
 }
-} else {
+}
-String[] list = path[i].getFiles(pkg);
+} catch (IOException ioExp) {
-for (int j = 0; j < list.length; j++) {
+throw new UncheckedIOException(ioExp);
-String name = list[j];
+}
-if (name.endsWith(ext)) {
-name = pkg + File.separatorChar + name;
-File file = new File(path[i].dir.getPath(), name);
-files.put(name, new ClassFile(file));
-}
-}
-}
-}
-return files.elements();
-}
-/**
-* Release resources.
-*/
-public void close() throws IOException {
-for (int i = path.length; --i >= 0; ) {
-if (path[i].zip != null) {
-path[i].zip.close();
-}
-}
-}
-/**
-* Returns original class path string
-*/
-public String toString() {
-return pathstr;
 }
 }
-/**
-* A class path entry, which can either be a directory or an open zip file.
-*/
-class ClassPathEntry {
-File dir;
-ZipFile zip;
-Hashtable<String, String[]> subdirs = new Hashtable<>(29); // cache of sub-directory listings:
-String[] getFiles(String subdir) {
-String files[] = subdirs.get(subdir);
-if (files == null) {
-// search the directory, exactly once
-File sd = new File(dir.getPath(), subdir);
-if (sd.isDirectory()) {
-files = sd.list();
-if (files == null) {
-// should not happen, but just in case, fail silently
-files = new String[0];
-}
-if (files.length == 0) {
-String nonEmpty[] = { "" };
-files = nonEmpty;
-}
-} else {
-files = new String[0];
-}
-subdirs.put(subdir, files);
-}
-return files;
-}
-}

changeset 27565	729f9700483a
parent 25859	3317bb8137f4
child 31673	135283550686