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

equal deleted inserted replaced

-:853d8c191eac
+:b316e32eb90c
 import javax.tools.JavaFileManager;
 import javax.tools.JavaFileObject;
 import javax.tools.StandardJavaFileManager;
 import com.sun.tools.javac.code.Source;
+import com.sun.tools.javac.file.RelativePath.RelativeFile;
+import com.sun.tools.javac.file.RelativePath.RelativeDirectory;
 import com.sun.tools.javac.main.JavacOption;
 import com.sun.tools.javac.main.OptionName;
 import com.sun.tools.javac.main.RecognizedOptions;
 import com.sun.tools.javac.util.Context;
 import com.sun.tools.javac.util.JCDiagnostic.SimpleDiagnosticPosition;
 import com.sun.tools.javac.util.List;
 import com.sun.tools.javac.util.ListBuffer;
 import com.sun.tools.javac.util.Log;
 import com.sun.tools.javac.util.Options;
+import static javax.tools.StandardLocation.*;
 import static com.sun.tools.javac.main.OptionName.*;
-import static javax.tools.StandardLocation.*;
 /**
 * This class provides access to the source, class and other files
 * used by the compiler and related tools.
 */
 public class JavacFileManager implements StandardJavaFileManager {
-private static final String[] symbolFileLocation = { "lib", "ct.sym" };
-private static final String symbolFilePrefix = "META-INF/sym/rt.jar/";
 boolean useZipFileIndex;
 private static boolean CHECK_ZIP_TIMESTAMP = false;
 private static Map<File, Boolean> isDirectory = new ConcurrentHashMap<File, Boolean>();
 if (isValidClassName)
 throw new AssertionError("Valid class name rejected: " + name);
 printAscii("Invalid class name: \"%s\"", name);
 }
 }
 private static void printAscii(String format, Object... args) {
 String message;
 try {
 final String ascii = "US-ASCII";
 message = new String(String.format(null, format, args).getBytes(ascii), ascii);
 throw new AssertionError(ex);
 }
 System.out.println(message);
 }
-/** Return external representation of name,
-*  converting '.' to File.separatorChar.
-*/
-private static String externalizeFileName(CharSequence name) {
-return name.toString().replace('.', File.separatorChar);
-}
-private static String externalizeFileName(CharSequence n, JavaFileObject.Kind kind) {
-return externalizeFileName(n) + kind.extension;
-}
-private static String baseName(String fileName) {
-return fileName.substring(fileName.lastIndexOf(File.separatorChar) + 1);
-}
 /**
 * Insert all files in subdirectory `subdirectory' of `directory' which end
 * in one of the extensions in `extensions' into packageSym.
 */
 private void listDirectory(File directory,
-String subdirectory,
+RelativeDirectory subdirectory,
 Set<JavaFileObject.Kind> fileKinds,
 boolean recurse,
 ListBuffer<JavaFileObject> l) {
 Archive archive = archives.get(directory);
 log.error("error.reading.file",
 directory, ex.getLocalizedMessage());
 return;
 }
 }
-if (subdirectory.length() != 0) {
-if (!useZipFileIndex) {
-subdirectory = subdirectory.replace('\\', '/');
-if (!subdirectory.endsWith("/")) subdirectory = subdirectory + "/";
-}
-else {
-if (File.separatorChar == '/') {
-subdirectory = subdirectory.replace('\\', '/');
-}
-else {
-subdirectory = subdirectory.replace('/', '\\');
-}
-if (!subdirectory.endsWith(File.separator)) subdirectory = subdirectory + File.separator;
-}
-}
 List<String> files = archive.getFiles(subdirectory);
 if (files != null) {
 for (String file; !files.isEmpty(); files = files.tail) {
 file = files.head;
 l.append(archive.getFileObject(subdirectory, file));
 }
 }
 }
 if (recurse) {
-for (String s: archive.getSubdirectories()) {
+for (RelativeDirectory s: archive.getSubdirectories()) {
-if (s.startsWith(subdirectory) && !s.equals(subdirectory)) {
+if (subdirectory.contains(s)) {
 // Because the archive map is a flat list of directories,
 // the enclosing loop will pick up all child subdirectories.
 // Therefore, there is no need to recurse deeper.
 listDirectory(directory, s, fileKinds, false, l);
 }
 }
 }
 } else {
-File d = subdirectory.length() != 0
+File d = subdirectory.getFile(directory);
-? new File(directory, subdirectory)
-: directory;
 if (!caseMapCheck(d, subdirectory))
 return;
 File[] files = d.listFiles();
 if (files == null)
 for (File f: files) {
 String fname = f.getName();
 if (f.isDirectory()) {
 if (recurse && SourceVersion.isIdentifier(fname)) {
 listDirectory(directory,
-subdirectory + File.separator + fname,
+new RelativeDirectory(subdirectory, fname),
 fileKinds,
 recurse,
 l);
 }
 } else {
 /** Hack to make Windows case sensitive. Test whether given path
 *  ends in a string of characters with the same case as given name.
 *  Ignore file separators in both path and name.
 */
-private boolean caseMapCheck(File f, String name) {
+private boolean caseMapCheck(File f, RelativePath name) {
 if (fileSystemIsCaseSensitive) return true;
 // Note that getCanonicalPath() returns the case-sensitive
 // spelled file name.
 String path;
 try {
 path = f.getCanonicalPath();
 } catch (IOException ex) {
 return false;
 }
 char[] pcs = path.toCharArray();
-char[] ncs = name.toCharArray();
+char[] ncs = name.path.toCharArray();
 int i = pcs.length - 1;
 int j = ncs.length - 1;
 while (i >= 0 && j >= 0) {
 while (i >= 0 && pcs[i] == File.separatorChar) i--;
-while (j >= 0 && ncs[j] == File.separatorChar) j--;
+while (j >= 0 && ncs[j] == '/') j--;
 if (i >= 0 && j >= 0) {
 if (pcs[i] != ncs[j]) return false;
 i--;
 j--;
 }
 * mapping directory names to lists of files (basenames).
 */
 public interface Archive {
 void close() throws IOException;
-boolean contains(String name);
+boolean contains(RelativePath name);
-JavaFileObject getFileObject(String subdirectory, String file);
+JavaFileObject getFileObject(RelativeDirectory subdirectory, String file);
-List<String> getFiles(String subdirectory);
+List<String> getFiles(RelativeDirectory subdirectory);
-Set<String> getSubdirectories();
+Set<RelativeDirectory> getSubdirectories();
 }
 public class MissingArchive implements Archive {
 final File zipFileName;
 public MissingArchive(File name) {
 zipFileName = name;
 }
-public boolean contains(String name) {
+public boolean contains(RelativePath name) {
 return false;
 }
 public void close() {
 }
-public JavaFileObject getFileObject(String subdirectory, String file) {
+public JavaFileObject getFileObject(RelativeDirectory subdirectory, String file) {
 return null;
 }
-public List<String> getFiles(String subdirectory) {
+public List<String> getFiles(RelativeDirectory subdirectory) {
 return List.nil();
 }
-public Set<String> getSubdirectories() {
+public Set<RelativeDirectory> getSubdirectories() {
 return Collections.emptySet();
 }
+public String toString() {
+return "MissingArchive[" + zipFileName + "]";
+}
 }
 /** A directory of zip files already opened.
 */
 Map<File, Archive> archives = new HashMap<File,Archive>();
+private static final String[] symbolFileLocation = { "lib", "ct.sym" };
+private static final RelativeDirectory symbolFilePrefix
+= new RelativeDirectory("META-INF/sym/rt.jar/");
 /** Open a new zip file directory.
 */
 protected Archive openArchive(File zipFileName) throws IOException {
 Archive archive = archives.get(zipFileName);
 if (origZipFileName == zipFileName) {
 if (!useZipFileIndex) {
 archive = new ZipArchive(this, zdir);
 } else {
-archive = new ZipFileIndexArchive(this, ZipFileIndex.getZipFileIndex(zipFileName, null,
+archive = new ZipFileIndexArchive(this,
-usePreindexedCache, preindexCacheLocation, options.get("writezipindexfiles") != null));
+ZipFileIndex.getZipFileIndex(zipFileName,
+null,
+usePreindexedCache,
+preindexCacheLocation,
+options.get("writezipindexfiles") != null));
 }
 }
 else {
 if (!useZipFileIndex) {
 archive = new SymbolArchive(this, origZipFileName, zdir, symbolFilePrefix);
 }
 else {
 archive = new ZipFileIndexArchive(this,
 ZipFileIndex.getZipFileIndex(zipFileName,
 symbolFilePrefix,
 usePreindexedCache,
 preindexCacheLocation,
 options.get("writezipindexfiles") != null));
 }
 }
 } catch (FileNotFoundException ex) {
 archive = new MissingArchive(zipFileName);
 } catch (IOException ex) {
 nullCheck(kinds);
 Iterable<? extends File> path = getLocation(location);
 if (path == null)
 return List.nil();
-String subdirectory = externalizeFileName(packageName);
+RelativeDirectory subdirectory = RelativeDirectory.forPackage(packageName);
 ListBuffer<JavaFileObject> results = new ListBuffer<JavaFileObject>();
 for (File directory : path)
 listDirectory(directory, subdirectory, kinds, recurse, results);
 // validateClassName(className);
 nullCheck(className);
 nullCheck(kind);
 if (!sourceOrClass.contains(kind))
 throw new IllegalArgumentException("Invalid kind " + kind);
-return getFileForInput(location, externalizeFileName(className, kind));
+return getFileForInput(location, RelativeFile.forClass(className, kind));
 }
 public FileObject getFileForInput(Location location,
 String packageName,
 String relativeName)
 nullCheck(location);
 // validatePackageName(packageName);
 nullCheck(packageName);
 if (!isRelativeUri(URI.create(relativeName))) // FIXME 6419701
 throw new IllegalArgumentException("Invalid relative name: " + relativeName);
-String name = packageName.length() == 0
+RelativeFile name = packageName.length() == 0
-? relativeName
+? new RelativeFile(relativeName)
-: new File(externalizeFileName(packageName), relativeName).getPath();
+: new RelativeFile(RelativeDirectory.forPackage(packageName), relativeName);
 return getFileForInput(location, name);
 }
-private JavaFileObject getFileForInput(Location location, String name) throws IOException {
+private JavaFileObject getFileForInput(Location location, RelativeFile name) throws IOException {
 Iterable<? extends File> path = getLocation(location);
 if (path == null)
 return null;
 for (File dir: path) {
 if (dir.isDirectory()) {
-File f = new File(dir, name.replace('/', File.separatorChar));
+File f = name.getFile(dir);
 if (f.exists())
 return new RegularFileObject(this, f);
 } else {
 Archive a = openArchive(dir);
 if (a.contains(name)) {
-int i = name.lastIndexOf('/');
+return a.getFileObject(name.dirname(), name.basename());
-String dirname = name.substring(0, i+1);
+}
-String basename = name.substring(i+1);
-return a.getFileObject(dirname, basename);
+}
 }
-}
-}
 return null;
 }
 public JavaFileObject getJavaFileForOutput(Location location,
 String className,
 JavaFileObject.Kind kind,
 // validateClassName(className);
 nullCheck(className);
 nullCheck(kind);
 if (!sourceOrClass.contains(kind))
 throw new IllegalArgumentException("Invalid kind " + kind);
-return getFileForOutput(location, externalizeFileName(className, kind), sibling);
+return getFileForOutput(location, RelativeFile.forClass(className, kind), sibling);
 }
 public FileObject getFileForOutput(Location location,
 String packageName,
 String relativeName,
 nullCheck(location);
 // validatePackageName(packageName);
 nullCheck(packageName);
 if (!isRelativeUri(URI.create(relativeName))) // FIXME 6419701
 throw new IllegalArgumentException("relativeName is invalid");
-String name = packageName.length() == 0
+RelativeFile name = packageName.length() == 0
-? relativeName
+? new RelativeFile(relativeName)
-: new File(externalizeFileName(packageName), relativeName).getPath();
+: new RelativeFile(RelativeDirectory.forPackage(packageName), relativeName);
 return getFileForOutput(location, name, sibling);
 }
 private JavaFileObject getFileForOutput(Location location,
-String fileName,
+RelativeFile fileName,
 FileObject sibling)
 throws IOException
 {
 File dir;
 if (location == CLASS_OUTPUT) {
 } else {
 File siblingDir = null;
 if (sibling != null && sibling instanceof RegularFileObject) {
 siblingDir = ((RegularFileObject)sibling).f.getParentFile();
 }
-return new RegularFileObject(this, new File(siblingDir, baseName(fileName)));
+return new RegularFileObject(this, new File(siblingDir, fileName.basename()));
 }
 } else if (location == SOURCE_OUTPUT) {
 dir = (getSourceOutDir() != null ? getSourceOutDir() : getClassOutDir());
 } else {
 Iterable<? extends File> path = paths.getPathForLocation(location);
 dir = f;
 break;
 }
 }
-File file = (dir == null ? new File(fileName) : new File(dir, fileName));
+File file = fileName.getFile(dir); // null-safe
 return new RegularFileObject(this, file);
 }
 public Iterable<? extends JavaFileObject> getJavaFileObjectsFromFiles(

changeset 1205	b316e32eb90c
parent 815	bcb5c0d7c1ab
child 1208	5072b0dd3d52