jps/jps-builders/src/org/jetbrains/jps/javac/OptimizedFileManager.java - platform/tools/idea - Git at Google

 /*
  * Copyright 2000-2012 JetBrains s.r.o.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  * http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 package org.jetbrains.jps.javac;

 import com.sun.tools.javac.util.Context;
 import com.sun.tools.javac.util.JCDiagnostic;
 import com.sun.tools.javac.util.List;
 import com.sun.tools.javac.util.ListBuffer;

 import javax.lang.model.SourceVersion;
 import javax.tools.FileObject;
 import javax.tools.JavaFileObject;
 import java.io.*;
 import java.lang.ref.SoftReference;
 import java.lang.reflect.Field;
 import java.net.URI;
 import java.net.URISyntaxException;
 import java.nio.ByteBuffer;
 import java.nio.CharBuffer;
 import java.nio.charset.*;
 import java.util.*;
 import java.util.concurrent.atomic.AtomicReference;

 /**
  * WARNING: Loaded via reflection, do not delete
  *
  * @author nik
  * @noinspection UnusedDeclaration
  */
 class OptimizedFileManager extends DefaultFileManager {
   private boolean myUseZipFileIndex;
   private final Map<File, Archive> myArchives;
   private final Map<File, Boolean> myIsFile = new HashMap<File, Boolean>();
   private final Map<File, File[]> myDirectoryCache = new HashMap<File, File[]>();
   public static final File[] NULL_FILE_ARRAY = new File[0];

   private static final boolean ourUseContentCache = Boolean.valueOf(System.getProperty("javac.use.content.cache", "false"));
   private final Map<InputFileObject, SoftReference<CharBuffer>> myContentCache = ourUseContentCache? new HashMap<InputFileObject, SoftReference<CharBuffer>>() : Collections.<InputFileObject, SoftReference<CharBuffer>>emptyMap();

   public OptimizedFileManager() throws Throwable {
     super(new Context(), true, null);
     final Field archivesField = DefaultFileManager.class.getDeclaredField("archives");
     archivesField.setAccessible(true);
     myArchives = (Map<File, Archive>) archivesField.get(this);

     try {
       final Field useZipFileIndexField = DefaultFileManager.class.getDeclaredField("useZipFileIndex");
       useZipFileIndexField.setAccessible(true);
       myUseZipFileIndex = (Boolean) useZipFileIndexField.get(this);
     }
     catch (Exception e) {
       myUseZipFileIndex = false;
     }
   }

   @Override
   public FileObject getFileForInput(Location location, String packageName, String relativeName) throws IOException {
     final String name = packageName == null || packageName.isEmpty() ? relativeName.replace('\\', '/') : (packageName.replace('.', '/') + "/" + relativeName.replace('\\', '/'));
     return getFileForInput(location, name);
   }

   @Override
   public JavaFileObject getJavaFileForInput(Location location, String className, JavaFileObject.Kind kind) throws IOException {
     final String name = className.replace('.', '/') + kind.extension;
     return getFileForInput(location, name);
   }

   @Override
   public Iterable<? extends JavaFileObject> getJavaFileObjectsFromFiles(Iterable<? extends File> files) {
     java.util.List<InputFileObject> result;
     if (files instanceof Collection) {
       result = new ArrayList<InputFileObject>(((Collection)files).size());
     }
     else {
       result = new ArrayList<InputFileObject>();
     }
     for (File f: files) {
       result.add(new InputFileObject(f));
     }
     return result;
   }

   @Override
   public Iterable<JavaFileObject> list(Location location, String packageName, Set<JavaFileObject.Kind> kinds, boolean recurse) throws IOException {
     Iterable<? extends File> locationRoots = getLocation(location);
     if (locationRoots == null) {
       return Collections.emptyList();
     }

     final String relativePath = packageName.replace('.', File.separatorChar);
     ListBuffer<JavaFileObject> results = new ListBuffer<JavaFileObject>();

     for (File root : locationRoots) {
       final Archive archive = myArchives.get(root);
       final boolean isFile;
       if (archive != null) {
         isFile = true;
       }
       else {
         isFile = isFile(root);
       }
       if (isFile) {
         collectFromArchive(root, archive, relativePath, kinds, recurse, results);
       }
       else {
         final File directory = relativePath.length() != 0 ? new File(root, relativePath) : root;
         if (recurse) {
           collectFromDirectoryRecursively(directory, kinds, results, true);
         }
         else {
           collectFromDirectory(directory, kinds, results);
         }
       }
     }

     return results.toList();
   }

   // important! called via reflection, so avoid renaming or signature changing or rename carefully
   public void fileGenerated(File file) {
     final File parent = file.getParentFile();
     if (parent != null) {
       myDirectoryCache.remove(parent);
     }
   }

   private boolean isFile(File root) {
     Boolean cachedIsFile = myIsFile.get(root);
     if (cachedIsFile == null) {
       cachedIsFile = Boolean.valueOf(root.isFile());
       myIsFile.put(root, cachedIsFile);
     }
     return cachedIsFile.booleanValue();
   }

   private void collectFromArchive(File root, Archive archive, String relativePath, Set<JavaFileObject.Kind> kinds, boolean recurse, ListBuffer<JavaFileObject> result) {
     if (archive == null) {
       try {
         archive = openArchive(root);
       }
       catch (IOException ex) {
         log.error("error.reading.file", root, ex.getLocalizedMessage());
         return;
       }
     }
     final String separator = myUseZipFileIndex ? File.separator : "/";
     if (relativePath.length() != 0) {
       if (!myUseZipFileIndex) {
         relativePath = relativePath.replace('\\', '/');
       }
       if (!relativePath.endsWith(separator)) {
         relativePath = relativePath + separator;
       }
     }

     collectArchiveFiles(archive, relativePath, kinds, result);
     if (recurse) {
       for (String s : archive.getSubdirectories()) {
         if (s.startsWith(relativePath) && !s.equals(relativePath)) {
           if (!s.endsWith(separator)) {
             s += separator;
           }
           collectArchiveFiles(archive, s, kinds, result);
         }
       }
     }
   }

   private void collectFromDirectory(File directory, Set<JavaFileObject.Kind> fileKinds, ListBuffer<JavaFileObject> result) {
     final File[] children = listChildren(directory);
     if (children != null) {
       final boolean acceptUnknownFiles = fileKinds.contains(JavaFileObject.Kind.OTHER);
       for (File child : children) {
         if (isValidFile(child.getName(), fileKinds)) {
           if (acceptUnknownFiles && !isFile(child)) {
             continue;
           }
           final JavaFileObject fe = new InputFileObject(child);
           result.append(fe);
         }
       }
     }
   }

   private void collectFromDirectoryRecursively(File file, Set<JavaFileObject.Kind> fileKinds, ListBuffer<JavaFileObject> result, boolean isRootCall) {
     final File[] children = listChildren(file);
     final String name = file.getName();
     if (children != null) { // is directory
       if (isRootCall || SourceVersion.isIdentifier(name)) {
         for (File child : children) {
           collectFromDirectoryRecursively(child, fileKinds, result, false);
         }
       }
     }
     else {
       if (isValidFile(name, fileKinds)) {
         JavaFileObject fe = new InputFileObject(file);
         result.append(fe);
       }
     }
   }

   private File[] listChildren(File file) {
     File[] cached = myDirectoryCache.get(file);
     if (cached == null) {
       cached = file.listFiles();
       myDirectoryCache.put(file, cached != null? cached : NULL_FILE_ARRAY);
     }
     return cached == NULL_FILE_ARRAY ? null : cached;
   }

   private void collectArchiveFiles(Archive archive, String relativePath, Set<JavaFileObject.Kind> fileKinds, ListBuffer<JavaFileObject> result) {
     List<String> files = archive.getFiles(relativePath);
     if (files != null) {
       for (String file; !files.isEmpty(); files = files.tail) {
         file = files.head;
         if (isValidFile(file, fileKinds)) {
           result.append(archive.getFileObject(relativePath, file));
         }
       }
     }
   }

   private boolean isValidFile(String name, Set<JavaFileObject.Kind> fileKinds) {
     int dot = name.lastIndexOf(".");
     JavaFileObject.Kind kind = getKind(dot == -1 ? name : name.substring(dot));
     return fileKinds.contains(kind);
   }

   private JavaFileObject getFileForInput(Location location, String name) throws IOException {
     Iterable<? extends File> path = getLocation(location);
     if (path == null) {
       return null;
     }

     for (File root : path) {
       Archive archive = myArchives.get(root);
       final boolean isFile;
       if (archive != null) {
         isFile = true;
       }
       else {
         isFile = isFile(root);
       }
       if (isFile) {
         if (archive == null) {
           try {
             archive = openArchive(root);
           }
           catch (IOException ex) {
             log.error("error.reading.file", root, ex.getLocalizedMessage());
             break;
           }
         }
         if (archive.contains(name)) {
           int i = name.lastIndexOf('/');
           String dirname = name.substring(0, i+1);
           String basename = name.substring(i+1);
           return archive.getFileObject(dirname, basename);
         }
       }
       else {
         final File f = new File(root, name.replace('/', File.separatorChar));
         if (f.exists()) {
           return new InputFileObject(f);
         }
       }
     }
     return null;
   }

   //actually Javac doesn't check if this method returns null. It always get substring of the returned string starting from the last dot.
   @Override
   public String inferBinaryName(Location location, JavaFileObject file) {
     final String name = file.getName();
     int dot = name.lastIndexOf('.');
     final String relativePath = dot != -1 ? name.substring(0, dot) : name;
     return relativePath.replace(File.separatorChar, '.');
   }

   private class InputFileObject extends BaseFileObject {

     /** The underlying file.
      */
     final File f;

     public InputFileObject(File f) {
       this.f = f;
     }

     public InputStream openInputStream() throws IOException {
       return new FileInputStream(f);
     }

     public Reader openReader(boolean ignoreEncodingErrors) throws IOException {
       throw new UnsupportedOperationException();
     }

     public OutputStream openOutputStream() throws IOException {
       throw new UnsupportedOperationException();
     }

     public Writer openWriter() throws IOException {
       throw new UnsupportedOperationException();
     }

     @Deprecated
     public String getName() {
       return f.getPath();
     }

     public boolean isNameCompatible(String simpleName, JavaFileObject.Kind kind) {
       final String n = simpleName + kind.extension;
       final String fileName = f.getName();
       if (fileName.equals(n)) {
         return true;
       }
       if (fileName.equalsIgnoreCase(n)) {
         try {
           // allow for Windows
           return (f.getCanonicalFile().getName().equals(n));
         }
         catch (IOException e) {
         }
       }
       return false;
     }

     /** @deprecated see bug 6410637 */
     @Deprecated
     public String getPath() {
       return f.getPath();
     }

     public long getLastModified() {
       return f.lastModified();
     }

     public boolean delete() {
       return f.delete();
     }

     public CharBuffer getCharContent(boolean ignoreEncodingErrors) throws IOException {
       CharBuffer cb;
       if (ourUseContentCache) {
         SoftReference<CharBuffer> ref = myContentCache.get(this);
         cb = (ref != null) ? ref.get() : null;
         if (cb == null) {
           cb = loadFileContent(ignoreEncodingErrors);
           if (!ignoreEncodingErrors) {
             myContentCache.put(this, new SoftReference<CharBuffer>(cb));
           }
         }
       }
       else {
         cb = loadFileContent(ignoreEncodingErrors);
       }
       return cb;
     }

     private CharBuffer loadFileContent(boolean ignoreEncodingErrors) throws IOException {
       final InputStream in = new FileInputStream(f);
       final ByteBuffer bb = makeByteBuffer(in);
       JavaFileObject prev = log.useSource(this);
       try {
         return decode(bb, ignoreEncodingErrors);
       }
       finally {
         log.useSource(prev);
         myByteBufferCache.put(bb); // save for next time
         in.close();
       }
     }

     @Override
     public boolean equals(Object other) {
       if (!(other instanceof InputFileObject)) {
         return false;
       }
       InputFileObject o = (InputFileObject) other;
       try {
         return f.equals(o.f) || f.getCanonicalFile().equals(o.f.getCanonicalFile());
       }
       catch (IOException e) {
         return false;
       }
     }

     @Override
     public int hashCode() {
       return f.hashCode();
     }

     public URI toUri() {
       try {
         return convertToURI(f.getPath());
       }
       catch (Throwable ex) {
         return f.toURI().normalize();
       }
     }
   }

   private static URI convertToURI(String localPath) throws URISyntaxException {
     String p = localPath.replace('\\', '/');
     if (!p.startsWith("/")) {
       p = "/" + p;
     }
     if (!p.startsWith("//")) {
       p = "//" + p;
     }
     return new URI("file", null, p, null);
   }

   private ByteBuffer makeByteBuffer(InputStream in) throws IOException {
     int limit = in.available();
     if (limit < 1024) {
       limit = 1024;
     }
     ByteBuffer result = myByteBufferCache.get(limit);
     int position = 0;
     while (in.available() != 0) {
       if (position >= limit) {
         // expand buffer
         result = ByteBuffer.allocate(limit <<= 1).put((ByteBuffer)result.flip());
       }
       final int count = in.read(result.array(), position, limit - position);
       if (count < 0) {
         break;
       }
       result.position(position += count);
     }
     return (ByteBuffer)result.flip();
   }

   private CharBuffer decode(ByteBuffer inbuf, boolean ignoreEncodingErrors) {
     CharsetDecoder decoder;
     String encodingName = getEncodingName();
     try {
       Charset charset = (this.charset == null) ? Charset.forName(encodingName) : this.charset;
       decoder = charset.newDecoder();

       CodingErrorAction action;
       if (ignoreEncodingErrors) {
         action = CodingErrorAction.REPLACE;
       }
       else {
         action = CodingErrorAction.REPORT;
       }

       decoder.onMalformedInput(action).onUnmappableCharacter(action);
     }
     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.
     final 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 = 10 + 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 JCDiagnostic.SimpleDiagnosticPosition(dest.limit()), "illegal.char.for.encoding", charset == null ? encodingName : charset.name());
         }
         else {
           log.warning(new JCDiagnostic.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
   }

   private static class ByteBufferCache {
     private AtomicReference<ByteBuffer> myCached = new AtomicReference<ByteBuffer>(null);

     ByteBuffer get(int capacity) {
       if (capacity < 20480) {
         capacity = 20480;
       }
       final ByteBuffer cached = myCached.getAndSet(null);
       return (cached != null && cached.capacity() >= capacity) ? (ByteBuffer)cached.clear() : ByteBuffer.allocate(capacity + capacity>>1);
     }

     void put(ByteBuffer x) {
       myCached.set(x);
     }

     void clear() {
       myCached.set(null);
     }
   }
   private final ByteBufferCache myByteBufferCache = new ByteBufferCache();


   private static volatile boolean ourPathCacheClearProblem = false;

   public void close() {
     try {
       super.close();
     }
     finally {
       // archives are cleared in super.close()
       if (ourUseContentCache) {
         myContentCache.clear();
       }
       myDirectoryCache.clear();
       myByteBufferCache.clear();
       myIsFile.clear();
       if (!ourPathCacheClearProblem) {
         try {
           Paths.clearPathExistanceCache();
         }
         catch (Throwable ignored) {
           ourPathCacheClearProblem = true;
         }
       }
     }
   }
 }
	/*
	* Copyright 2000-2012 JetBrains s.r.o.
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/
	package org.jetbrains.jps.javac;

	import com.sun.tools.javac.util.Context;
	import com.sun.tools.javac.util.JCDiagnostic;
	import com.sun.tools.javac.util.List;
	import com.sun.tools.javac.util.ListBuffer;

	import javax.lang.model.SourceVersion;
	import javax.tools.FileObject;
	import javax.tools.JavaFileObject;
	import java.io.*;
	import java.lang.ref.SoftReference;
	import java.lang.reflect.Field;
	import java.net.URI;
	import java.net.URISyntaxException;
	import java.nio.ByteBuffer;
	import java.nio.CharBuffer;
	import java.nio.charset.*;
	import java.util.*;
	import java.util.concurrent.atomic.AtomicReference;

	/**
	* WARNING: Loaded via reflection, do not delete
	*
	* @author nik
	* @noinspection UnusedDeclaration
	*/
	class OptimizedFileManager extends DefaultFileManager {
	private boolean myUseZipFileIndex;
	private final Map<File, Archive> myArchives;
	private final Map<File, Boolean> myIsFile = new HashMap<File, Boolean>();
	private final Map<File, File[]> myDirectoryCache = new HashMap<File, File[]>();
	public static final File[] NULL_FILE_ARRAY = new File[0];

	private static final boolean ourUseContentCache = Boolean.valueOf(System.getProperty("javac.use.content.cache", "false"));
	private final Map<InputFileObject, SoftReference<CharBuffer>> myContentCache = ourUseContentCache? new HashMap<InputFileObject, SoftReference<CharBuffer>>() : Collections.<InputFileObject, SoftReference<CharBuffer>>emptyMap();

	public OptimizedFileManager() throws Throwable {
	super(new Context(), true, null);
	final Field archivesField = DefaultFileManager.class.getDeclaredField("archives");
	archivesField.setAccessible(true);
	myArchives = (Map<File, Archive>) archivesField.get(this);

	try {
	final Field useZipFileIndexField = DefaultFileManager.class.getDeclaredField("useZipFileIndex");
	useZipFileIndexField.setAccessible(true);
	myUseZipFileIndex = (Boolean) useZipFileIndexField.get(this);
	}
	catch (Exception e) {
	myUseZipFileIndex = false;
	}
	}

	@Override
	public FileObject getFileForInput(Location location, String packageName, String relativeName) throws IOException {
	final String name = packageName == null \|\| packageName.isEmpty() ? relativeName.replace('\\', '/') : (packageName.replace('.', '/') + "/" + relativeName.replace('\\', '/'));
	return getFileForInput(location, name);
	}

	@Override
	public JavaFileObject getJavaFileForInput(Location location, String className, JavaFileObject.Kind kind) throws IOException {
	final String name = className.replace('.', '/') + kind.extension;
	return getFileForInput(location, name);
	}

	@Override
	public Iterable<? extends JavaFileObject> getJavaFileObjectsFromFiles(Iterable<? extends File> files) {
	java.util.List<InputFileObject> result;
	if (files instanceof Collection) {
	result = new ArrayList<InputFileObject>(((Collection)files).size());
	}
	else {
	result = new ArrayList<InputFileObject>();
	}
	for (File f: files) {
	result.add(new InputFileObject(f));
	}
	return result;
	}

	@Override
	public Iterable<JavaFileObject> list(Location location, String packageName, Set<JavaFileObject.Kind> kinds, boolean recurse) throws IOException {
	Iterable<? extends File> locationRoots = getLocation(location);
	if (locationRoots == null) {
	return Collections.emptyList();
	}

	final String relativePath = packageName.replace('.', File.separatorChar);
	ListBuffer<JavaFileObject> results = new ListBuffer<JavaFileObject>();

	for (File root : locationRoots) {
	final Archive archive = myArchives.get(root);
	final boolean isFile;
	if (archive != null) {
	isFile = true;
	}
	else {
	isFile = isFile(root);
	}
	if (isFile) {
	collectFromArchive(root, archive, relativePath, kinds, recurse, results);
	}
	else {
	final File directory = relativePath.length() != 0 ? new File(root, relativePath) : root;
	if (recurse) {
	collectFromDirectoryRecursively(directory, kinds, results, true);
	}
	else {
	collectFromDirectory(directory, kinds, results);
	}
	}
	}

	return results.toList();
	}

	// important! called via reflection, so avoid renaming or signature changing or rename carefully
	public void fileGenerated(File file) {
	final File parent = file.getParentFile();
	if (parent != null) {
	myDirectoryCache.remove(parent);
	}
	}

	private boolean isFile(File root) {
	Boolean cachedIsFile = myIsFile.get(root);
	if (cachedIsFile == null) {
	cachedIsFile = Boolean.valueOf(root.isFile());
	myIsFile.put(root, cachedIsFile);
	}
	return cachedIsFile.booleanValue();
	}

	private void collectFromArchive(File root, Archive archive, String relativePath, Set<JavaFileObject.Kind> kinds, boolean recurse, ListBuffer<JavaFileObject> result) {
	if (archive == null) {
	try {
	archive = openArchive(root);
	}
	catch (IOException ex) {
	log.error("error.reading.file", root, ex.getLocalizedMessage());
	return;
	}
	}
	final String separator = myUseZipFileIndex ? File.separator : "/";
	if (relativePath.length() != 0) {
	if (!myUseZipFileIndex) {
	relativePath = relativePath.replace('\\', '/');
	}
	if (!relativePath.endsWith(separator)) {
	relativePath = relativePath + separator;
	}
	}

	collectArchiveFiles(archive, relativePath, kinds, result);
	if (recurse) {
	for (String s : archive.getSubdirectories()) {
	if (s.startsWith(relativePath) && !s.equals(relativePath)) {
	if (!s.endsWith(separator)) {
	s += separator;
	}
	collectArchiveFiles(archive, s, kinds, result);
	}
	}
	}
	}

	private void collectFromDirectory(File directory, Set<JavaFileObject.Kind> fileKinds, ListBuffer<JavaFileObject> result) {
	final File[] children = listChildren(directory);
	if (children != null) {
	final boolean acceptUnknownFiles = fileKinds.contains(JavaFileObject.Kind.OTHER);
	for (File child : children) {
	if (isValidFile(child.getName(), fileKinds)) {
	if (acceptUnknownFiles && !isFile(child)) {
	continue;
	}
	final JavaFileObject fe = new InputFileObject(child);
	result.append(fe);
	}
	}
	}
	}

	private void collectFromDirectoryRecursively(File file, Set<JavaFileObject.Kind> fileKinds, ListBuffer<JavaFileObject> result, boolean isRootCall) {
	final File[] children = listChildren(file);
	final String name = file.getName();
	if (children != null) { // is directory
	if (isRootCall \|\| SourceVersion.isIdentifier(name)) {
	for (File child : children) {
	collectFromDirectoryRecursively(child, fileKinds, result, false);
	}
	}
	}
	else {
	if (isValidFile(name, fileKinds)) {
	JavaFileObject fe = new InputFileObject(file);
	result.append(fe);
	}
	}
	}

	private File[] listChildren(File file) {
	File[] cached = myDirectoryCache.get(file);
	if (cached == null) {
	cached = file.listFiles();
	myDirectoryCache.put(file, cached != null? cached : NULL_FILE_ARRAY);
	}
	return cached == NULL_FILE_ARRAY ? null : cached;
	}

	private void collectArchiveFiles(Archive archive, String relativePath, Set<JavaFileObject.Kind> fileKinds, ListBuffer<JavaFileObject> result) {
	List<String> files = archive.getFiles(relativePath);
	if (files != null) {
	for (String file; !files.isEmpty(); files = files.tail) {
	file = files.head;
	if (isValidFile(file, fileKinds)) {
	result.append(archive.getFileObject(relativePath, file));
	}
	}
	}
	}

	private boolean isValidFile(String name, Set<JavaFileObject.Kind> fileKinds) {
	int dot = name.lastIndexOf(".");
	JavaFileObject.Kind kind = getKind(dot == -1 ? name : name.substring(dot));
	return fileKinds.contains(kind);
	}

	private JavaFileObject getFileForInput(Location location, String name) throws IOException {
	Iterable<? extends File> path = getLocation(location);
	if (path == null) {
	return null;
	}

	for (File root : path) {
	Archive archive = myArchives.get(root);
	final boolean isFile;
	if (archive != null) {
	isFile = true;
	}
	else {
	isFile = isFile(root);
	}
	if (isFile) {
	if (archive == null) {
	try {
	archive = openArchive(root);
	}
	catch (IOException ex) {
	log.error("error.reading.file", root, ex.getLocalizedMessage());
	break;
	}
	}
	if (archive.contains(name)) {
	int i = name.lastIndexOf('/');
	String dirname = name.substring(0, i+1);
	String basename = name.substring(i+1);
	return archive.getFileObject(dirname, basename);
	}
	}
	else {
	final File f = new File(root, name.replace('/', File.separatorChar));
	if (f.exists()) {
	return new InputFileObject(f);
	}
	}
	}
	return null;
	}

	//actually Javac doesn't check if this method returns null. It always get substring of the returned string starting from the last dot.
	@Override
	public String inferBinaryName(Location location, JavaFileObject file) {
	final String name = file.getName();
	int dot = name.lastIndexOf('.');
	final String relativePath = dot != -1 ? name.substring(0, dot) : name;
	return relativePath.replace(File.separatorChar, '.');
	}

	private class InputFileObject extends BaseFileObject {

	/** The underlying file.
	*/
	final File f;

	public InputFileObject(File f) {
	this.f = f;
	}

	public InputStream openInputStream() throws IOException {
	return new FileInputStream(f);
	}

	public Reader openReader(boolean ignoreEncodingErrors) throws IOException {
	throw new UnsupportedOperationException();
	}

	public OutputStream openOutputStream() throws IOException {
	throw new UnsupportedOperationException();
	}

	public Writer openWriter() throws IOException {
	throw new UnsupportedOperationException();
	}

	@Deprecated
	public String getName() {
	return f.getPath();
	}

	public boolean isNameCompatible(String simpleName, JavaFileObject.Kind kind) {
	final String n = simpleName + kind.extension;
	final String fileName = f.getName();
	if (fileName.equals(n)) {
	return true;
	}
	if (fileName.equalsIgnoreCase(n)) {
	try {
	// allow for Windows
	return (f.getCanonicalFile().getName().equals(n));
	}
	catch (IOException e) {
	}
	}
	return false;
	}

	/** @deprecated see bug 6410637 */
	@Deprecated
	public String getPath() {
	return f.getPath();
	}

	public long getLastModified() {
	return f.lastModified();
	}

	public boolean delete() {
	return f.delete();
	}

	public CharBuffer getCharContent(boolean ignoreEncodingErrors) throws IOException {
	CharBuffer cb;
	if (ourUseContentCache) {
	SoftReference<CharBuffer> ref = myContentCache.get(this);
	cb = (ref != null) ? ref.get() : null;
	if (cb == null) {
	cb = loadFileContent(ignoreEncodingErrors);
	if (!ignoreEncodingErrors) {
	myContentCache.put(this, new SoftReference<CharBuffer>(cb));
	}
	}
	}
	else {
	cb = loadFileContent(ignoreEncodingErrors);
	}
	return cb;
	}

	private CharBuffer loadFileContent(boolean ignoreEncodingErrors) throws IOException {
	final InputStream in = new FileInputStream(f);
	final ByteBuffer bb = makeByteBuffer(in);
	JavaFileObject prev = log.useSource(this);
	try {
	return decode(bb, ignoreEncodingErrors);
	}
	finally {
	log.useSource(prev);
	myByteBufferCache.put(bb); // save for next time
	in.close();
	}
	}

	@Override
	public boolean equals(Object other) {
	if (!(other instanceof InputFileObject)) {
	return false;
	}
	InputFileObject o = (InputFileObject) other;
	try {
	return f.equals(o.f) \|\| f.getCanonicalFile().equals(o.f.getCanonicalFile());
	}
	catch (IOException e) {
	return false;
	}
	}

	@Override
	public int hashCode() {
	return f.hashCode();
	}

	public URI toUri() {
	try {
	return convertToURI(f.getPath());
	}
	catch (Throwable ex) {
	return f.toURI().normalize();
	}
	}
	}

	private static URI convertToURI(String localPath) throws URISyntaxException {
	String p = localPath.replace('\\', '/');
	if (!p.startsWith("/")) {
	p = "/" + p;
	}
	if (!p.startsWith("//")) {
	p = "//" + p;
	}
	return new URI("file", null, p, null);
	}

	private ByteBuffer makeByteBuffer(InputStream in) throws IOException {
	int limit = in.available();
	if (limit < 1024) {
	limit = 1024;
	}
	ByteBuffer result = myByteBufferCache.get(limit);
	int position = 0;
	while (in.available() != 0) {
	if (position >= limit) {
	// expand buffer
	result = ByteBuffer.allocate(limit <<= 1).put((ByteBuffer)result.flip());
	}
	final int count = in.read(result.array(), position, limit - position);
	if (count < 0) {
	break;
	}
	result.position(position += count);
	}
	return (ByteBuffer)result.flip();
	}

	private CharBuffer decode(ByteBuffer inbuf, boolean ignoreEncodingErrors) {
	CharsetDecoder decoder;
	String encodingName = getEncodingName();
	try {
	Charset charset = (this.charset == null) ? Charset.forName(encodingName) : this.charset;
	decoder = charset.newDecoder();

	CodingErrorAction action;
	if (ignoreEncodingErrors) {
	action = CodingErrorAction.REPLACE;
	}
	else {
	action = CodingErrorAction.REPORT;
	}

	decoder.onMalformedInput(action).onUnmappableCharacter(action);
	}
	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.
	final 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 = 10 + 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 JCDiagnostic.SimpleDiagnosticPosition(dest.limit()), "illegal.char.for.encoding", charset == null ? encodingName : charset.name());
	}
	else {
	log.warning(new JCDiagnostic.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
	}

	private static class ByteBufferCache {
	private AtomicReference<ByteBuffer> myCached = new AtomicReference<ByteBuffer>(null);

	ByteBuffer get(int capacity) {
	if (capacity < 20480) {
	capacity = 20480;
	}
	final ByteBuffer cached = myCached.getAndSet(null);
	return (cached != null && cached.capacity() >= capacity) ? (ByteBuffer)cached.clear() : ByteBuffer.allocate(capacity + capacity>>1);
	}

	void put(ByteBuffer x) {
	myCached.set(x);
	}

	void clear() {
	myCached.set(null);
	}
	}
	private final ByteBufferCache myByteBufferCache = new ByteBufferCache();


	private static volatile boolean ourPathCacheClearProblem = false;

	public void close() {
	try {
	super.close();
	}
	finally {
	// archives are cleared in super.close()
	if (ourUseContentCache) {
	myContentCache.clear();
	}
	myDirectoryCache.clear();
	myByteBufferCache.clear();
	myIsFile.clear();
	if (!ourPathCacheClearProblem) {
	try {
	Paths.clearPathExistanceCache();
	}
	catch (Throwable ignored) {
	ourPathCacheClearProblem = true;
	}
	}
	}
	}
	}