jdk8-mips64-public/langtools: src/share/classes/com/sun/tools/javac/file/JavacFileManager.java@07c916ecfc71 (annotated)

src/share/classes/com/sun/tools/javac/file/JavacFileManager.java@07c916ecfc71 (annotated)

src/share/classes/com/sun/tools/javac/file/JavacFileManager.java

Fri, 04 Jul 2008 15:06:27 -0700

author: tbell
date: Fri, 04 Jul 2008 15:06:27 -0700
changeset 62: 07c916ecfc71
parent 57: aa67a5da66e3
parent 54: eaf608c64fec
child 103: e571266ae14f
permissions: -rw-r--r--

Merge

 /*
  * Copyright 2005-2008 Sun Microsystems, Inc.  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.  Sun designates this
  * particular file as subject to the "Classpath" exception as provided
  * by Sun 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
  * CA 95054 USA or visit www.sun.com if you need additional information or
  * have any questions.
  */
 package com.sun.tools.javac.file;
 import java.io.ByteArrayOutputStream;
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileNotFoundException;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStreamWriter;
 import java.lang.ref.SoftReference;
 import java.net.MalformedURLException;
 import java.net.URI;
 import java.net.URL;
 import java.net.URLClassLoader;
 import java.nio.ByteBuffer;
 import java.nio.CharBuffer;
 import java.nio.channels.FileChannel;
 import java.nio.charset.Charset;
 import java.nio.charset.CharsetDecoder;
 import java.nio.charset.CoderResult;
 import java.nio.charset.CodingErrorAction;
 import java.nio.charset.IllegalCharsetNameException;
 import java.nio.charset.UnsupportedCharsetException;
 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.Map;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.zip.ZipFile;
 import javax.lang.model.SourceVersion;
 import javax.tools.FileObject;
 import javax.tools.JavaFileManager;
 import javax.tools.JavaFileObject;
 import javax.tools.StandardJavaFileManager;
 import com.sun.tools.javac.code.Source;
 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 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>();
     public static char[] toArray(CharBuffer buffer) {
         if (buffer.hasArray())
             return ((CharBuffer)buffer.compact().flip()).array();
         else
             return buffer.toString().toCharArray();
     }
     /**
      * The log to be used for error reporting.
      */
     protected Log log;
     /** Encapsulates knowledge of paths
      */
     private Paths paths;
     private Options options;
     private final File uninited = new File("U N I N I T E D");
     private final Set<JavaFileObject.Kind> sourceOrClass =
         EnumSet.of(JavaFileObject.Kind.SOURCE, JavaFileObject.Kind.CLASS);
     /** The standard output directory, primarily used for classes.
      *  Initialized by the "-d" option.
      *  If classOutDir = null, files are written into same directory as the sources
      *  they were generated from.
      */
     private File classOutDir = uninited;
     /** The output directory, used when generating sources while processing annotations.
      *  Initialized by the "-s" option.
      */
     private File sourceOutDir = uninited;
     protected boolean mmappedIO;
     protected boolean ignoreSymbolFile;
     /**
      * User provided charset (through javax.tools).
      */
     protected Charset charset;
     /**
      * Register a Context.Factory to create a JavacFileManager.
      */
     public static void preRegister(final Context context) {
         context.put(JavaFileManager.class, new Context.Factory<JavaFileManager>() {
             public JavaFileManager make() {
                 return new JavacFileManager(context, true, null);
             }
         });
     }
     /**
      * Create a JavacFileManager using a given context, optionally registering
      * it as the JavaFileManager for that context.
      */
     public JavacFileManager(Context context, boolean register, Charset charset) {
         if (register)
             context.put(JavaFileManager.class, this);
         byteBufferCache = new ByteBufferCache();
         this.charset = charset;
         setContext(context);
     }
     /**
      * Set the context for JavacFileManager.
      */
     public void setContext(Context context) {
         log = Log.instance(context);
         if (paths == null) {
             paths = Paths.instance(context);
         } else {
             // Reuse the Paths object as it stores the locations that
             // have been set with setLocation, etc.
             paths.setContext(context);
         }
         options = Options.instance(context);
         useZipFileIndex = System.getProperty("useJavaUtilZip") == null;// TODO: options.get("useJavaUtilZip") == null;
         CHECK_ZIP_TIMESTAMP = System.getProperty("checkZipIndexTimestamp") != null;// TODO: options.get("checkZipIndexTimestamp") != null;
         mmappedIO = options.get("mmappedIO") != null;
         ignoreSymbolFile = options.get("ignore.symbol.file") != null;
     }
     public JavaFileObject getFileForInput(String name) {
         return getRegularFile(new File(name));
     }
     public JavaFileObject getRegularFile(File file) {
         return new RegularFileObject(this, file);
     }
     public JavaFileObject getFileForOutput(String classname,
                                            JavaFileObject.Kind kind,
                                            JavaFileObject sibling)
         throws IOException
     {
         return getJavaFileForOutput(CLASS_OUTPUT, classname, kind, sibling);
     }
     public Iterable<? extends JavaFileObject> getJavaFileObjectsFromStrings(Iterable<String> names) {
         ListBuffer<File> files = new ListBuffer<File>();
         for (String name : names)
             files.append(new File(nullCheck(name)));
         return getJavaFileObjectsFromFiles(files.toList());
     }
     public Iterable<? extends JavaFileObject> getJavaFileObjects(String... names) {
         return getJavaFileObjectsFromStrings(Arrays.asList(nullCheck(names)));
     }
     protected JavaFileObject.Kind getKind(String extension) {
         if (extension.equals(JavaFileObject.Kind.CLASS.extension))
             return JavaFileObject.Kind.CLASS;
         else if (extension.equals(JavaFileObject.Kind.SOURCE.extension))
             return JavaFileObject.Kind.SOURCE;
         else if (extension.equals(JavaFileObject.Kind.HTML.extension))
             return JavaFileObject.Kind.HTML;
         else
             return JavaFileObject.Kind.OTHER;
     }
     private static boolean isValidName(String name) {
         // Arguably, isValidName should reject keywords (such as in SourceVersion.isName() ),
         // but the set of keywords depends on the source level, and we don't want
         // impls of JavaFileManager to have to be dependent on the source level.
         // Therefore we simply check that the argument is a sequence of identifiers
         // separated by ".".
         for (String s : name.split("\\.", -1)) {
             if (!SourceVersion.isIdentifier(s))
                 return false;
         }
         return true;
     }
     private static void validateClassName(String className) {
         if (!isValidName(className))
             throw new IllegalArgumentException("Invalid class name: " + className);
     }
     private static void validatePackageName(String packageName) {
         if (packageName.length() > 0 && !isValidName(packageName))
             throw new IllegalArgumentException("Invalid packageName name: " + packageName);
     }
     public static void testName(String name,
                                 boolean isValidPackageName,
                                 boolean isValidClassName)
     {
         try {
             validatePackageName(name);
             if (!isValidPackageName)
                 throw new AssertionError("Invalid package name accepted: " + name);
             printAscii("Valid package name: \"%s\"", name);
         } catch (IllegalArgumentException e) {
             if (isValidPackageName)
                 throw new AssertionError("Valid package name rejected: " + name);
             printAscii("Invalid package name: \"%s\"", name);
         }
         try {
             validateClassName(name);
             if (!isValidClassName)
                 throw new AssertionError("Invalid class name accepted: " + name);
             printAscii("Valid class name: \"%s\"", name);
         } catch (IllegalArgumentException e) {
             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);
         } catch (java.io.UnsupportedEncodingException ex) {
             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,
                                Set<JavaFileObject.Kind> fileKinds,
                                boolean recurse,
                                ListBuffer<JavaFileObject> l) {
         Archive archive = archives.get(directory);
         boolean isFile = false;
         if (CHECK_ZIP_TIMESTAMP) {
             Boolean isf = isDirectory.get(directory);
             if (isf == null) {
                 isFile = directory.isFile();
                 isDirectory.put(directory, isFile);
             }
             else {
                 isFile = directory.isFile();
             }
         }
         else {
             isFile = directory.isFile();
         }
         if (archive != null || isFile) {
             if (archive == null) {
                 try {
                     archive = openArchive(directory);
                 } catch (IOException ex) {
                     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;
                     if (isValidFile(file, fileKinds)) {
                         l.append(archive.getFileObject(subdirectory, file));
                     }
                 }
             }
             if (recurse) {
                 for (String s: archive.getSubdirectories()) {
                     if (s.startsWith(subdirectory) && !s.equals(subdirectory)) {
                         // 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
                 ? new File(directory, subdirectory)
                 : directory;
             if (!caseMapCheck(d, subdirectory))
                 return;
             File[] files = d.listFiles();
             if (files == null)
                 return;
             for (File f: files) {
                 String fname = f.getName();
                 if (f.isDirectory()) {
                     if (recurse && SourceVersion.isIdentifier(fname)) {
                         listDirectory(directory,
                                       subdirectory + File.separator + fname,
                                       fileKinds,
                                       recurse,
                                       l);
                     }
                 } else {
                     if (isValidFile(fname, fileKinds)) {
                         JavaFileObject fe =
                             new RegularFileObject(this, fname, new File(d, fname));
                         l.append(fe);
                     }
                 }
             }
         }
     }
     private boolean isValidFile(String s, Set<JavaFileObject.Kind> fileKinds) {
         int lastDot = s.lastIndexOf(".");
         String extn = (lastDot == -1 ? s : s.substring(lastDot));
         JavaFileObject.Kind kind = getKind(extn);
         return fileKinds.contains(kind);
     }
     private static final boolean fileSystemIsCaseSensitive =
         File.separatorChar == '/';
     /** 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) {
         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();
         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--;
             if (i >= 0 && j >= 0) {
                 if (pcs[i] != ncs[j]) return false;
                 i--;
                 j--;
             }
         }
         return j < 0;
     }
     /**
      * An archive provides a flat directory structure of a ZipFile by
      * mapping directory names to lists of files (basenames).
      */
     public interface Archive {
         void close() throws IOException;
         boolean contains(String name);
         JavaFileObject getFileObject(String subdirectory, String file);
         List<String> getFiles(String subdirectory);
         Set<String> getSubdirectories();
     }
     public class MissingArchive implements Archive {
         final File zipFileName;
         public MissingArchive(File name) {
             zipFileName = name;
         }
         public boolean contains(String name) {
             return false;
         }
         public void close() {
         }
         public JavaFileObject getFileObject(String subdirectory, String file) {
             return null;
         }
         public List<String> getFiles(String subdirectory) {
             return List.nil();
         }
         public Set<String> getSubdirectories() {
             return Collections.emptySet();
         }
     }
     /** A directory of zip files already opened.
      */
     Map<File, Archive> archives = new HashMap<File,Archive>();
     /** Open a new zip file directory.
      */
     protected Archive openArchive(File zipFileName) throws IOException {
         Archive archive = archives.get(zipFileName);
         if (archive == null) {
             File origZipFileName = zipFileName;
             if (!ignoreSymbolFile && paths.isBootClassPathRtJar(zipFileName)) {
                 File file = zipFileName.getParentFile().getParentFile(); // ${java.home}
                 if (new File(file.getName()).equals(new File("jre")))
                     file = file.getParentFile();
                 // file == ${jdk.home}
                 for (String name : symbolFileLocation)
                     file = new File(file, name);
                 // file == ${jdk.home}/lib/ct.sym
                 if (file.exists())
                     zipFileName = file;
             }
             try {
                 ZipFile zdir = null;
                 boolean usePreindexedCache = false;
                 String preindexCacheLocation = null;
                 if (!useZipFileIndex) {
                     zdir = new ZipFile(zipFileName);
                 }
                 else {
                     usePreindexedCache = options.get("usezipindex") != null;
                     preindexCacheLocation = options.get("java.io.tmpdir");
                     String optCacheLoc = options.get("cachezipindexdir");
                     if (optCacheLoc != null && optCacheLoc.length() != 0) {
                         if (optCacheLoc.startsWith("\"")) {
                             if (optCacheLoc.endsWith("\"")) {
                                 optCacheLoc = optCacheLoc.substring(1, optCacheLoc.length() - 1);
                             }
                            else {
                                 optCacheLoc = optCacheLoc.substring(1);
                             }
                         }
                         File cacheDir = new File(optCacheLoc);
                         if (cacheDir.exists() && cacheDir.canWrite()) {
                             preindexCacheLocation = optCacheLoc;
                             if (!preindexCacheLocation.endsWith("/") &&
                                 !preindexCacheLocation.endsWith(File.separator)) {
                                 preindexCacheLocation += File.separator;
                             }
                         }
                     }
                 }
                 if (origZipFileName == zipFileName) {
                     if (!useZipFileIndex) {
                         archive = new ZipArchive(this, zdir);
                     } else {
                         archive = new ZipFileIndexArchive(this, 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) {
                 if (zipFileName.exists())
                     log.error("error.reading.file", zipFileName, ex.getLocalizedMessage());
                 archive = new MissingArchive(zipFileName);
             }
             archives.put(origZipFileName, archive);
         }
         return archive;
     }
     /** Flush any output resources.
      */
     public void flush() {
         contentCache.clear();
     }
     /**
      * Close the JavaFileManager, releasing resources.
      */
     public void close() {
         for (Iterator<Archive> i = archives.values().iterator(); i.hasNext(); ) {
             Archive a = i.next();
             i.remove();
             try {
                 a.close();
             } catch (IOException e) {
             }
         }
     }
     CharBuffer getCachedContent(JavaFileObject file) {
         SoftReference<CharBuffer> r = contentCache.get(file);
         return (r == null ? null : r.get());
     }
     void cache(JavaFileObject file, CharBuffer cb) {
         contentCache.put(file, new SoftReference<CharBuffer>(cb));
     }
     private final Map<JavaFileObject, SoftReference<CharBuffer>> contentCache
             = new HashMap<JavaFileObject, SoftReference<CharBuffer>>();
     private String defaultEncodingName;
     private String getDefaultEncodingName() {
         if (defaultEncodingName == null) {
             defaultEncodingName =
                 new OutputStreamWriter(new ByteArrayOutputStream()).getEncoding();
         }
         return defaultEncodingName;
     }
     protected String getEncodingName() {
         String encName = options.get(OptionName.ENCODING);
         if (encName == null)
             return getDefaultEncodingName();
         else
             return encName;
     }
     protected Source getSource() {
         String sourceName = options.get(OptionName.SOURCE);
         Source source = null;
         if (sourceName != null)
             source = Source.lookup(sourceName);
         return (source != null ? source : Source.DEFAULT);
     }
     /**
      * Make a byte buffer from an input stream.
      */
     ByteBuffer makeByteBuffer(InputStream in)
         throws IOException {
         int limit = in.available();
         if (mmappedIO && in instanceof FileInputStream) {
             // Experimental memory mapped I/O
             FileInputStream fin = (FileInputStream)in;
             return fin.getChannel().map(FileChannel.MapMode.READ_ONLY, 0, limit);
         }
         if (limit < 1024) limit = 1024;
         ByteBuffer result = byteBufferCache.get(limit);
         int position = 0;
         while (in.available() != 0) {
             if (position >= limit)
                 // expand buffer
                 result = ByteBuffer.
                     allocate(limit <<= 1).
                     put((ByteBuffer)result.flip());
             int count = in.read(result.array(),
                 position,
                 limit - position);
             if (count < 0) break;
             result.position(position += count);
         }
         return (ByteBuffer)result.flip();
     }
     void recycleByteBuffer(ByteBuffer bb) {
         byteBufferCache.put(bb);
     }
     /**
      * A single-element cache of direct byte buffers.
      */
     private static class ByteBufferCache {
         private ByteBuffer cached;
         ByteBuffer get(int capacity) {
             if (capacity < 20480) capacity = 20480;
             ByteBuffer result =
                 (cached != null && cached.capacity() >= capacity)
                 ? (ByteBuffer)cached.clear()
                 : ByteBuffer.allocate(capacity + capacity>>1);
             cached = null;
             return result;
         }
         void put(ByteBuffer x) {
             cached = x;
         }
     }
     private final ByteBufferCache byteBufferCache;
     CharsetDecoder getDecoder(String encodingName, boolean ignoreEncodingErrors) {
         Charset charset = (this.charset == null)
             ? Charset.forName(encodingName)
             : this.charset;
         CharsetDecoder decoder = charset.newDecoder();
         CodingErrorAction action;
         if (ignoreEncodingErrors)
             action = CodingErrorAction.REPLACE;
         else
             action = CodingErrorAction.REPORT;
         return decoder
             .onMalformedInput(action)
             .onUnmappableCharacter(action);
     }
     /**
      * Decode a ByteBuffer into a CharBuffer.
      */
     CharBuffer decode(ByteBuffer inbuf, boolean ignoreEncodingErrors) {
         String encodingName = getEncodingName();
         CharsetDecoder decoder;
         try {
             decoder = getDecoder(encodingName, ignoreEncodingErrors);
         } catch (IllegalCharsetNameException e) {
             log.error("unsupported.encoding", encodingName);
             return (CharBuffer)CharBuffer.allocate(1).flip();
         } catch (UnsupportedCharsetException e) {
             log.error("unsupported.encoding", encodingName);
             return (CharBuffer)CharBuffer.allocate(1).flip();
         }
         // slightly overestimate the buffer size to avoid reallocation.
         float factor =
             decoder.averageCharsPerByte() * 0.8f +
             decoder.maxCharsPerByte() * 0.2f;
         CharBuffer dest = CharBuffer.
             allocate(10 + (int)(inbuf.remaining()*factor));
         while (true) {
             CoderResult result = decoder.decode(inbuf, dest, true);
             dest.flip();
             if (result.isUnderflow()) { // done reading
                 // make sure there is at least one extra character
                 if (dest.limit() == dest.capacity()) {
                     dest = CharBuffer.allocate(dest.capacity()+1).put(dest);
                     dest.flip();
                 }
                 return dest;
             } else if (result.isOverflow()) { // buffer too small; expand
                 int newCapacity =
 + dest.capacity() +
                     (int)(inbuf.remaining()*decoder.maxCharsPerByte());
                 dest = CharBuffer.allocate(newCapacity).put(dest);
             } else if (result.isMalformed() || result.isUnmappable()) {
                 // bad character in input
                 // report coding error (warn only pre 1.5)
                 if (!getSource().allowEncodingErrors()) {
                     log.error(new SimpleDiagnosticPosition(dest.limit()),
                               "illegal.char.for.encoding",
                               charset == null ? encodingName : charset.name());
                 } else {
                     log.warning(new SimpleDiagnosticPosition(dest.limit()),
                                 "illegal.char.for.encoding",
                                 charset == null ? encodingName : charset.name());
                 }
                 // skip past the coding error
                 inbuf.position(inbuf.position() + result.length());
                 // undo the flip() to prepare the output buffer
                 // for more translation
                 dest.position(dest.limit());
                 dest.limit(dest.capacity());
                 dest.put((char)0xfffd); // backward compatible
             } else {
                 throw new AssertionError(result);
             }
         }
         // unreached
     }
     public ClassLoader getClassLoader(Location location) {
         nullCheck(location);
         Iterable<? extends File> path = getLocation(location);
         if (path == null)
             return null;
         ListBuffer<URL> lb = new ListBuffer<URL>();
         for (File f: path) {
             try {
                 lb.append(f.toURI().toURL());
             } catch (MalformedURLException e) {
                 throw new AssertionError(e);
             }
         }
         return new URLClassLoader(lb.toArray(new URL[lb.size()]),
             getClass().getClassLoader());
     }
     public Iterable<JavaFileObject> list(Location location,
                                          String packageName,
                                          Set<JavaFileObject.Kind> kinds,
                                          boolean recurse)
         throws IOException
     {
         // validatePackageName(packageName);
         nullCheck(packageName);
         nullCheck(kinds);
         Iterable<? extends File> path = getLocation(location);
         if (path == null)
             return List.nil();
         String subdirectory = externalizeFileName(packageName);
         ListBuffer<JavaFileObject> results = new ListBuffer<JavaFileObject>();
         for (File directory : path)
             listDirectory(directory, subdirectory, kinds, recurse, results);
         return results.toList();
     }
     public String inferBinaryName(Location location, JavaFileObject file) {
         file.getClass(); // null check
         location.getClass(); // null check
         // Need to match the path semantics of list(location, ...)
         Iterable<? extends File> path = getLocation(location);
         if (path == null) {
             return null;
         }
         if (file instanceof BaseFileObject) {
             return ((BaseFileObject) file).inferBinaryName(path);
         } else
             throw new IllegalArgumentException(file.getClass().getName());
     }
     public boolean isSameFile(FileObject a, FileObject b) {
         nullCheck(a);
         nullCheck(b);
         if (!(a instanceof BaseFileObject))
             throw new IllegalArgumentException("Not supported: " + a);
         if (!(b instanceof BaseFileObject))
             throw new IllegalArgumentException("Not supported: " + b);
         return a.equals(b);
     }
     public boolean handleOption(String current, Iterator<String> remaining) {
         for (JavacOption o: javacFileManagerOptions) {
             if (o.matches(current))  {
                 if (o.hasArg()) {
                     if (remaining.hasNext()) {
                         if (!o.process(options, current, remaining.next()))
                             return true;
                     }
                 } else {
                     if (!o.process(options, current))
                         return true;
                 }
                 // operand missing, or process returned false
                 throw new IllegalArgumentException(current);
             }
         }
         return false;
     }
     // where
         private static JavacOption[] javacFileManagerOptions =
             RecognizedOptions.getJavacFileManagerOptions(
             new RecognizedOptions.GrumpyHelper());
     public int isSupportedOption(String option) {
         for (JavacOption o : javacFileManagerOptions) {
             if (o.matches(option))
                 return o.hasArg() ? 1 : 0;
         }
         return -1;
     }
     public boolean hasLocation(Location location) {
         return getLocation(location) != null;
     }
     public JavaFileObject getJavaFileForInput(Location location,
                                               String className,
                                               JavaFileObject.Kind kind)
         throws IOException
     {
         nullCheck(location);
         // validateClassName(className);
         nullCheck(className);
         nullCheck(kind);
         if (!sourceOrClass.contains(kind))
             throw new IllegalArgumentException("Invalid kind " + kind);
         return getFileForInput(location, externalizeFileName(className, kind));
     }
     public FileObject getFileForInput(Location location,
                                       String packageName,
                                       String relativeName)
         throws IOException
     {
         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
             ? relativeName
             : new File(externalizeFileName(packageName), relativeName).getPath();
         return getFileForInput(location, name);
     }
     private JavaFileObject getFileForInput(Location location, String 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));
                 if (f.exists())
                     return new RegularFileObject(this, f);
             } else {
                 Archive a = openArchive(dir);
                 if (a.contains(name)) {
                     int i = name.lastIndexOf('/');
                     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,
                                                FileObject sibling)
         throws IOException
     {
         nullCheck(location);
         // validateClassName(className);
         nullCheck(className);
         nullCheck(kind);
         if (!sourceOrClass.contains(kind))
             throw new IllegalArgumentException("Invalid kind " + kind);
         return getFileForOutput(location, externalizeFileName(className, kind), sibling);
     }
     public FileObject getFileForOutput(Location location,
                                        String packageName,
                                        String relativeName,
                                        FileObject sibling)
         throws IOException
     {
         nullCheck(location);
         // validatePackageName(packageName);
         nullCheck(packageName);
         if (!isRelativeUri(URI.create(relativeName))) // FIXME 6419701
             throw new IllegalArgumentException("relativeName is invalid");
         String name = packageName.length() == 0
             ? relativeName
             : new File(externalizeFileName(packageName), relativeName).getPath();
         return getFileForOutput(location, name, sibling);
     }
     private JavaFileObject getFileForOutput(Location location,
                                             String fileName,
                                             FileObject sibling)
         throws IOException
     {
         File dir;
         if (location == CLASS_OUTPUT) {
             if (getClassOutDir() != null) {
                 dir = getClassOutDir();
             } else {
                 File siblingDir = null;
                 if (sibling != null && sibling instanceof RegularFileObject) {
                     siblingDir = ((RegularFileObject)sibling).f.getParentFile();
                 }
                 return new RegularFileObject(this, new File(siblingDir, baseName(fileName)));
             }
         } else if (location == SOURCE_OUTPUT) {
             dir = (getSourceOutDir() != null ? getSourceOutDir() : getClassOutDir());
         } else {
             Iterable<? extends File> path = paths.getPathForLocation(location);
             dir = null;
             for (File f: path) {
                 dir = f;
                 break;
             }
         }
         File file = (dir == null ? new File(fileName) : new File(dir, fileName));
         return new RegularFileObject(this, file);
     }
     public Iterable<? extends JavaFileObject> getJavaFileObjectsFromFiles(
         Iterable<? extends File> files)
     {
         ArrayList<RegularFileObject> result;
         if (files instanceof Collection)
             result = new ArrayList<RegularFileObject>(((Collection)files).size());
         else
             result = new ArrayList<RegularFileObject>();
         for (File f: files)
             result.add(new RegularFileObject(this, nullCheck(f)));
         return result;
     }
     public Iterable<? extends JavaFileObject> getJavaFileObjects(File... files) {
         return getJavaFileObjectsFromFiles(Arrays.asList(nullCheck(files)));
     }
     public void setLocation(Location location,
                             Iterable<? extends File> path)
         throws IOException
     {
         nullCheck(location);
         paths.lazy();
         final File dir = location.isOutputLocation() ? getOutputDirectory(path) : null;
         if (location == CLASS_OUTPUT)
             classOutDir = getOutputLocation(dir, D);
         else if (location == SOURCE_OUTPUT)
             sourceOutDir = getOutputLocation(dir, S);
         else
             paths.setPathForLocation(location, path);
     }
     // where
         private File getOutputDirectory(Iterable<? extends File> path) throws IOException {
             if (path == null)
                 return null;
             Iterator<? extends File> pathIter = path.iterator();
             if (!pathIter.hasNext())
                 throw new IllegalArgumentException("empty path for directory");
             File dir = pathIter.next();
             if (pathIter.hasNext())
                 throw new IllegalArgumentException("path too long for directory");
             if (!dir.exists())
                 throw new FileNotFoundException(dir + ": does not exist");
             else if (!dir.isDirectory())
                 throw new IOException(dir + ": not a directory");
             return dir;
         }
     private File getOutputLocation(File dir, OptionName defaultOptionName) {
         if (dir != null)
             return dir;
         String arg = options.get(defaultOptionName);
         if (arg == null)
             return null;
         return new File(arg);
     }
     public Iterable<? extends File> getLocation(Location location) {
         nullCheck(location);
         paths.lazy();
         if (location == CLASS_OUTPUT) {
             return (getClassOutDir() == null ? null : List.of(getClassOutDir()));
         } else if (location == SOURCE_OUTPUT) {
             return (getSourceOutDir() == null ? null : List.of(getSourceOutDir()));
         } else
             return paths.getPathForLocation(location);
     }
     private File getClassOutDir() {
         if (classOutDir == uninited)
             classOutDir = getOutputLocation(null, D);
         return classOutDir;
     }
     private File getSourceOutDir() {
         if (sourceOutDir == uninited)
             sourceOutDir = getOutputLocation(null, S);
         return sourceOutDir;
     }
     /**
      * Enforces the specification of a "relative" URI as used in
      * {@linkplain #getFileForInput(Location,String,URI)
      * getFileForInput}.  This method must follow the rules defined in
      * that method, do not make any changes without consulting the
      * specification.
      */
     protected static boolean isRelativeUri(URI uri) {
         if (uri.isAbsolute())
             return false;
         String path = uri.normalize().getPath();
         if (path.length() == 0 /* isEmpty() is mustang API */)
             return false;
         char first = path.charAt(0);
         return first != '.' && first != '/';
     }
     /**
      * Converts a relative file name to a relative URI.  This is
      * different from File.toURI as this method does not canonicalize
      * the file before creating the URI.  Furthermore, no schema is
      * used.
      * @param file a relative file name
      * @return a relative URI
      * @throws IllegalArgumentException if the file name is not
      * relative according to the definition given in {@link
      * javax.tools.JavaFileManager#getFileForInput}
      */
     public static String getRelativeName(File file) {
         if (!file.isAbsolute()) {
             String result = file.getPath().replace(File.separatorChar, '/');
             if (JavacFileManager.isRelativeUri(URI.create(result))) // FIXME 6419701
                 return result;
         }
         throw new IllegalArgumentException("Invalid relative path: " + file);
     }
     @SuppressWarnings("deprecation") // bug 6410637
     public static String getJavacFileName(FileObject file) {
         if (file instanceof BaseFileObject)
             return ((BaseFileObject)file).getPath();
         URI uri = file.toUri();
         String scheme = uri.getScheme();
         if (scheme == null || scheme.equals("file") || scheme.equals("jar"))
             return uri.getPath();
         else
             return uri.toString();
     }
     @SuppressWarnings("deprecation") // bug 6410637
     public static String getJavacBaseFileName(FileObject file) {
         if (file instanceof BaseFileObject)
             return ((BaseFileObject)file).getName();
         URI uri = file.toUri();
         String scheme = uri.getScheme();
         if (scheme == null || scheme.equals("file") || scheme.equals("jar")) {
             String path = uri.getPath();
             if (path == null)
                 return null;
             if (scheme != null && scheme.equals("jar"))
                 path = path.substring(path.lastIndexOf('!') + 1);
             return path.substring(path.lastIndexOf('/') + 1);
         } else {
             return uri.toString();
         }
     }
     private static <T> T nullCheck(T o) {
         o.getClass(); // null check
         return o;
     }
     private static <T> Iterable<T> nullCheck(Iterable<T> it) {
         for (T t : it)
             t.getClass(); // null check
         return it;
     }
 }

Mercurial > jdk8-mips64-public > langtools / annotate

src/share/classes/com/sun/tools/javac/file/JavacFileManager.java@07c916ecfc71 (annotated)

src/share/classes/com/sun/tools/javac/file/JavacFileManager.java