jps/jps-builders/src/org/jetbrains/jps/javac/OptimizedFileManager17.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.file.BaseFileObject;
 import com.sun.tools.javac.file.JavacFileManager;
 import com.sun.tools.javac.file.RelativePath;
 import com.sun.tools.javac.util.Context;
 import com.sun.tools.javac.util.List;
 import com.sun.tools.javac.util.ListBuffer;

 import javax.lang.model.SourceVersion;
 import javax.tools.JavaFileObject;
 import java.io.*;
 import java.lang.ref.Reference;
 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.CharsetDecoder;
 import java.nio.file.LinkOption;
 import java.util.*;

 /**
  * WARNING: Loaded via reflection, do not delete
  *
  * @noinspection UnusedDeclaration
  */
 class OptimizedFileManager17 extends com.sun.tools.javac.file.JavacFileManager {
   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 String _OS_NAME = System.getProperty("os.name").toLowerCase(Locale.US);
   private static final boolean isWindows = _OS_NAME.startsWith("windows");
   private static final boolean isOS2 = _OS_NAME.startsWith("os/2") || _OS_NAME.startsWith("os2");
   private static final boolean isMac = _OS_NAME.startsWith("mac");
   private static final boolean isFileSystemCaseSensitive = !isWindows && !isOS2 && !isMac;
   private static final boolean ourUseContentCache = Boolean.valueOf(System.getProperty("javac.use.content.cache", "false"));

   public OptimizedFileManager17() throws Throwable {
     super(new Context(), true, null);
     final Field archivesField = com.sun.tools.javac.file.JavacFileManager.class.getDeclaredField("archives");
     archivesField.setAccessible(true);
     myArchives = (Map<File, Archive>) archivesField.get(this);
   }

   @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(this, 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 List.nil();
     }

     RelativePath.RelativeDirectory subdirectory = new RelativePath.RelativeDirectory(packageName.replace('.', '/'));

     ListBuffer<JavaFileObject> results = new ListBuffer<JavaFileObject>();

     for (File root : locationRoots) {
       Archive archive = myArchives.get(root);

       final boolean isFile;
       if (archive != null) {
         isFile = true;
       }
       else {
         isFile = isFile(root);
       }

       if (isFile) {
         // Not a directory; either a file or non-existant, create the archive
         try {
           if (archive == null) {
             archive = openArchive(root);
           }
           listArchive(archive, subdirectory, kinds, recurse, results);
         }
         catch (IOException ex) {
           log.error("error.reading.file", root, getMessage(ex));
         }
       }
       else {
         final File dir = subdirectory.getFile(root);
         if (recurse) {
           listDirectoryRecursively(dir, kinds, results, true);
         }
         else {
           listDirectory(dir, kinds, results);
         }
       }

     }
     return results.toList();
   }

   private static void listArchive(Archive archive, RelativePath.RelativeDirectory subdirectory, Set<JavaFileObject.Kind> fileKinds, boolean recurse, ListBuffer<JavaFileObject> resultList) {
     // Get the files directly in the subdir
     List<String> files = archive.getFiles(subdirectory);
     if (files != null) {
       for (; !files.isEmpty(); files = files.tail) {
         String file = files.head;
         if (isValidFile(file, fileKinds)) {
           resultList.append(archive.getFileObject(subdirectory, file));
         }
       }
     }
     if (recurse) {
       for (RelativePath.RelativeDirectory s: archive.getSubdirectories()) {
         if (contains(subdirectory, 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.
           listArchive(archive, s, fileKinds, false, resultList);
         }
       }
     }
   }

   private void listDirectory(File directory, Set<JavaFileObject.Kind> fileKinds, ListBuffer<JavaFileObject> resultList) {
     final File[] files = listChildren(directory);
     if (files != null) {
       if (sortFiles != null) {
         Arrays.sort(files, sortFiles);
       }
       final boolean acceptUnknownFiles = fileKinds.contains(JavaFileObject.Kind.OTHER);
       for (File f: files) {
         final String fileName = f.getName();
         if (isValidFile(fileName, fileKinds)) {
           if (acceptUnknownFiles && !isFile(f)) {
             continue;
           }
           final JavaFileObject fe = new InputFileObject(this, f);
           resultList.append(fe);
         }
       }
     }
   }

   private void listDirectoryRecursively(File file, Set<JavaFileObject.Kind> fileKinds, ListBuffer<JavaFileObject> resultList, boolean isRootCall) {
     final File[] children = listChildren(file);
     final String fileName = file.getName();
     if (children != null) { // is directory
       if (isRootCall || SourceVersion.isIdentifier(fileName)) {
         if (sortFiles != null) {
           Arrays.sort(children, sortFiles);
         }
         for (File child : children) {
           listDirectoryRecursively(child, fileKinds, resultList, false);
         }
       }
     }
     else {
       if (isValidFile(fileName, fileKinds)) {
         JavaFileObject fe = new InputFileObject(this, file);
         resultList.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;
   }

   // 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 static boolean contains(RelativePath.RelativeDirectory subdirectory, RelativePath.RelativeDirectory other) {
     final String subdirPath = subdirectory.getPath();
     final String otherPath = other.getPath();
     return otherPath.length() > subdirPath.length() && otherPath.startsWith(subdirPath);
   }

   private static boolean isValidFile(String name, Set<JavaFileObject.Kind> fileKinds) {
     return fileKinds.contains(getKind(name));
   }

   private static class InputFileObject extends BaseFileObject {
     private static final Kind[] ourAvailableKinds = Kind.values();
     private final String name;
     private final File file;
     private final Kind kind;
     private Reference<File> absFileRef;

     public InputFileObject(JavacFileManager fileManager, File f) {
       this(fileManager, f.getName(), f);
     }

     public InputFileObject(JavacFileManager fileManager, String name, File f) {
       super(fileManager);
       this.name = name;
       this.file = f;
       kind = findKind(name);
     }

     @Override
     public URI toUri() {
       try {
         return convertToURI(file.getPath());
       }
       catch (Throwable e) {
         return file.toURI().normalize(); // fallback
       }
     }

     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);
     }

     @Override
     public String getName() {
       return file.getPath();
     }

     @Override
     public String getShortName() {
       return name;
     }

     @Override
     public JavaFileObject.Kind getKind() {
       return kind;
     }

     private static JavaFileObject.Kind findKind(String name) {
       for (Kind kind : ourAvailableKinds) {
         if (kind != Kind.OTHER && name.endsWith(kind.extension)) {
           return kind;
         }
       }
       return Kind.OTHER;
     }

     @Override
     public InputStream openInputStream() throws IOException {
       return new FileInputStream(file);
     }

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

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

     @Override
     public long getLastModified() {
       return file.lastModified();
     }

     @Override
     public boolean delete() {
       return file.delete();
     }

     @Override
     protected CharsetDecoder getDecoder(boolean ignoreEncodingErrors) {
       return fileManager.getDecoder(fileManager.getEncodingName(), ignoreEncodingErrors);
     }

     @Override
     protected String inferBinaryName(Iterable<? extends File> path) {
       final String fPath = file.getPath();
       for (File dir: path) {
         String dirPath = dir.getPath();
         if (dirPath.length() == 0) {
           dirPath = System.getProperty("user.dir");
         }
         if (!fPath.regionMatches(!isFileSystemCaseSensitive, 0, dirPath, 0, dirPath.length())) {
           continue;
         }
         final int pathLength = fPath.length();
         final boolean endsWithSeparator = dirPath.endsWith(File.separator);
         if (!endsWithSeparator) {
           // need to check if the next char in fPath is file separator
           final int separatorIdx = dirPath.length();
           if (pathLength <= separatorIdx || fPath.charAt(separatorIdx) != File.separatorChar) {
             continue;
           }
         }
         // fPath starts with dirPath
         final int startIndex = endsWithSeparator ? dirPath.length() : dirPath.length() + 1;
         int endIndex = fPath.lastIndexOf('.');
         if (endIndex <= startIndex) {
           endIndex = fPath.length();
         }
         final int length = endIndex - startIndex;
         final StringBuilder buf = new StringBuilder(length).append(fPath, startIndex, endIndex);
         for (int idx = 0; idx < length; idx++) {
           if (buf.charAt(idx) == File.separatorChar) {
             buf.setCharAt(idx, '.');
           }
         }
         return buf.toString();
       }
       return null;
     }

     @Override
     public boolean isNameCompatible(String cn, JavaFileObject.Kind kind) {
       cn.getClass();
       // null check
       if (kind == Kind.OTHER && getKind() != kind) {
         return false;
       }
       final String n = cn + kind.extension;
       if (name.equals(n)) {
         return true;
       }
       if (name.equalsIgnoreCase(n)) {
         // if we are on a case-insensitive file system,
         // try to compare against the real (exactly as on the disk) file name
         //
         try {
           //noinspection Since15
           return n.equals(file.toPath().toRealPath(LinkOption.NOFOLLOW_LINKS).getFileName().toString());
         }
         catch (IOException ignored) {
         }
       }
       return false;
     }

     /**
      * Check if two file objects are equal.
      * Two RegularFileObjects are equal if the absolute paths of the underlying
      * files are equal.
      */
     @Override
     public boolean equals(Object other) {
       if (this == other)
         return true;

       if (!(other instanceof InputFileObject))
         return false;

       InputFileObject o = (InputFileObject) other;
       return getAbsoluteFile().equals(o.getAbsoluteFile());
     }

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

     private File getAbsoluteFile() {
       File absFile = (absFileRef == null ? null : absFileRef.get());
       if (absFile == null) {
         absFile = file.getAbsoluteFile();
         absFileRef = new SoftReference<File>(absFile);
       }
       return absFile;
     }

     public CharBuffer getCharContent(boolean ignoreEncodingErrors) throws IOException {
       CharBuffer cb = ourUseContentCache? fileManager.getCachedContent(this) : null;
       if (cb == null) {
         InputStream in = new FileInputStream(file);
         try {
           final ByteBuffer bb = fileManager.makeByteBuffer(in);
           final JavaFileObject prev = fileManager.log.useSource(this);
           try {
             cb = fileManager.decode(bb, ignoreEncodingErrors);
           }
           finally {
             fileManager.log.useSource(prev);
           }
           fileManager.recycleByteBuffer(bb);
           if (ourUseContentCache && !ignoreEncodingErrors) {
             fileManager.cache(this, cb);
           }
         }
         finally {
           in.close();
         }
       }
       return cb;
     }
   }

   public void close() {
     try {
       super.close();
     }
     finally {
       // archives are cleared in super.close()
       myDirectoryCache.clear();
       myIsFile.clear();
     }
   }
 }
	/*
	* 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.file.BaseFileObject;
	import com.sun.tools.javac.file.JavacFileManager;
	import com.sun.tools.javac.file.RelativePath;
	import com.sun.tools.javac.util.Context;
	import com.sun.tools.javac.util.List;
	import com.sun.tools.javac.util.ListBuffer;

	import javax.lang.model.SourceVersion;
	import javax.tools.JavaFileObject;
	import java.io.*;
	import java.lang.ref.Reference;
	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.CharsetDecoder;
	import java.nio.file.LinkOption;
	import java.util.*;

	/**
	* WARNING: Loaded via reflection, do not delete
	*
	* @noinspection UnusedDeclaration
	*/
	class OptimizedFileManager17 extends com.sun.tools.javac.file.JavacFileManager {
	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 String _OS_NAME = System.getProperty("os.name").toLowerCase(Locale.US);
	private static final boolean isWindows = _OS_NAME.startsWith("windows");
	private static final boolean isOS2 = _OS_NAME.startsWith("os/2") \|\| _OS_NAME.startsWith("os2");
	private static final boolean isMac = _OS_NAME.startsWith("mac");
	private static final boolean isFileSystemCaseSensitive = !isWindows && !isOS2 && !isMac;
	private static final boolean ourUseContentCache = Boolean.valueOf(System.getProperty("javac.use.content.cache", "false"));

	public OptimizedFileManager17() throws Throwable {
	super(new Context(), true, null);
	final Field archivesField = com.sun.tools.javac.file.JavacFileManager.class.getDeclaredField("archives");
	archivesField.setAccessible(true);
	myArchives = (Map<File, Archive>) archivesField.get(this);
	}

	@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(this, 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 List.nil();
	}

	RelativePath.RelativeDirectory subdirectory = new RelativePath.RelativeDirectory(packageName.replace('.', '/'));

	ListBuffer<JavaFileObject> results = new ListBuffer<JavaFileObject>();

	for (File root : locationRoots) {
	Archive archive = myArchives.get(root);

	final boolean isFile;
	if (archive != null) {
	isFile = true;
	}
	else {
	isFile = isFile(root);
	}

	if (isFile) {
	// Not a directory; either a file or non-existant, create the archive
	try {
	if (archive == null) {
	archive = openArchive(root);
	}
	listArchive(archive, subdirectory, kinds, recurse, results);
	}
	catch (IOException ex) {
	log.error("error.reading.file", root, getMessage(ex));
	}
	}
	else {
	final File dir = subdirectory.getFile(root);
	if (recurse) {
	listDirectoryRecursively(dir, kinds, results, true);
	}
	else {
	listDirectory(dir, kinds, results);
	}
	}

	}
	return results.toList();
	}

	private static void listArchive(Archive archive, RelativePath.RelativeDirectory subdirectory, Set<JavaFileObject.Kind> fileKinds, boolean recurse, ListBuffer<JavaFileObject> resultList) {
	// Get the files directly in the subdir
	List<String> files = archive.getFiles(subdirectory);
	if (files != null) {
	for (; !files.isEmpty(); files = files.tail) {
	String file = files.head;
	if (isValidFile(file, fileKinds)) {
	resultList.append(archive.getFileObject(subdirectory, file));
	}
	}
	}
	if (recurse) {
	for (RelativePath.RelativeDirectory s: archive.getSubdirectories()) {
	if (contains(subdirectory, 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.
	listArchive(archive, s, fileKinds, false, resultList);
	}
	}
	}
	}

	private void listDirectory(File directory, Set<JavaFileObject.Kind> fileKinds, ListBuffer<JavaFileObject> resultList) {
	final File[] files = listChildren(directory);
	if (files != null) {
	if (sortFiles != null) {
	Arrays.sort(files, sortFiles);
	}
	final boolean acceptUnknownFiles = fileKinds.contains(JavaFileObject.Kind.OTHER);
	for (File f: files) {
	final String fileName = f.getName();
	if (isValidFile(fileName, fileKinds)) {
	if (acceptUnknownFiles && !isFile(f)) {
	continue;
	}
	final JavaFileObject fe = new InputFileObject(this, f);
	resultList.append(fe);
	}
	}
	}
	}

	private void listDirectoryRecursively(File file, Set<JavaFileObject.Kind> fileKinds, ListBuffer<JavaFileObject> resultList, boolean isRootCall) {
	final File[] children = listChildren(file);
	final String fileName = file.getName();
	if (children != null) { // is directory
	if (isRootCall \|\| SourceVersion.isIdentifier(fileName)) {
	if (sortFiles != null) {
	Arrays.sort(children, sortFiles);
	}
	for (File child : children) {
	listDirectoryRecursively(child, fileKinds, resultList, false);
	}
	}
	}
	else {
	if (isValidFile(fileName, fileKinds)) {
	JavaFileObject fe = new InputFileObject(this, file);
	resultList.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;
	}

	// 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 static boolean contains(RelativePath.RelativeDirectory subdirectory, RelativePath.RelativeDirectory other) {
	final String subdirPath = subdirectory.getPath();
	final String otherPath = other.getPath();
	return otherPath.length() > subdirPath.length() && otherPath.startsWith(subdirPath);
	}

	private static boolean isValidFile(String name, Set<JavaFileObject.Kind> fileKinds) {
	return fileKinds.contains(getKind(name));
	}

	private static class InputFileObject extends BaseFileObject {
	private static final Kind[] ourAvailableKinds = Kind.values();
	private final String name;
	private final File file;
	private final Kind kind;
	private Reference<File> absFileRef;

	public InputFileObject(JavacFileManager fileManager, File f) {
	this(fileManager, f.getName(), f);
	}

	public InputFileObject(JavacFileManager fileManager, String name, File f) {
	super(fileManager);
	this.name = name;
	this.file = f;
	kind = findKind(name);
	}

	@Override
	public URI toUri() {
	try {
	return convertToURI(file.getPath());
	}
	catch (Throwable e) {
	return file.toURI().normalize(); // fallback
	}
	}

	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);
	}

	@Override
	public String getName() {
	return file.getPath();
	}

	@Override
	public String getShortName() {
	return name;
	}

	@Override
	public JavaFileObject.Kind getKind() {
	return kind;
	}

	private static JavaFileObject.Kind findKind(String name) {
	for (Kind kind : ourAvailableKinds) {
	if (kind != Kind.OTHER && name.endsWith(kind.extension)) {
	return kind;
	}
	}
	return Kind.OTHER;
	}

	@Override
	public InputStream openInputStream() throws IOException {
	return new FileInputStream(file);
	}

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

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

	@Override
	public long getLastModified() {
	return file.lastModified();
	}

	@Override
	public boolean delete() {
	return file.delete();
	}

	@Override
	protected CharsetDecoder getDecoder(boolean ignoreEncodingErrors) {
	return fileManager.getDecoder(fileManager.getEncodingName(), ignoreEncodingErrors);
	}

	@Override
	protected String inferBinaryName(Iterable<? extends File> path) {
	final String fPath = file.getPath();
	for (File dir: path) {
	String dirPath = dir.getPath();
	if (dirPath.length() == 0) {
	dirPath = System.getProperty("user.dir");
	}
	if (!fPath.regionMatches(!isFileSystemCaseSensitive, 0, dirPath, 0, dirPath.length())) {
	continue;
	}
	final int pathLength = fPath.length();
	final boolean endsWithSeparator = dirPath.endsWith(File.separator);
	if (!endsWithSeparator) {
	// need to check if the next char in fPath is file separator
	final int separatorIdx = dirPath.length();
	if (pathLength <= separatorIdx \|\| fPath.charAt(separatorIdx) != File.separatorChar) {
	continue;
	}
	}
	// fPath starts with dirPath
	final int startIndex = endsWithSeparator ? dirPath.length() : dirPath.length() + 1;
	int endIndex = fPath.lastIndexOf('.');
	if (endIndex <= startIndex) {
	endIndex = fPath.length();
	}
	final int length = endIndex - startIndex;
	final StringBuilder buf = new StringBuilder(length).append(fPath, startIndex, endIndex);
	for (int idx = 0; idx < length; idx++) {
	if (buf.charAt(idx) == File.separatorChar) {
	buf.setCharAt(idx, '.');
	}
	}
	return buf.toString();
	}
	return null;
	}

	@Override
	public boolean isNameCompatible(String cn, JavaFileObject.Kind kind) {
	cn.getClass();
	// null check
	if (kind == Kind.OTHER && getKind() != kind) {
	return false;
	}
	final String n = cn + kind.extension;
	if (name.equals(n)) {
	return true;
	}
	if (name.equalsIgnoreCase(n)) {
	// if we are on a case-insensitive file system,
	// try to compare against the real (exactly as on the disk) file name
	//
	try {
	//noinspection Since15
	return n.equals(file.toPath().toRealPath(LinkOption.NOFOLLOW_LINKS).getFileName().toString());
	}
	catch (IOException ignored) {
	}
	}
	return false;
	}

	/**
	* Check if two file objects are equal.
	* Two RegularFileObjects are equal if the absolute paths of the underlying
	* files are equal.
	*/
	@Override
	public boolean equals(Object other) {
	if (this == other)
	return true;

	if (!(other instanceof InputFileObject))
	return false;

	InputFileObject o = (InputFileObject) other;
	return getAbsoluteFile().equals(o.getAbsoluteFile());
	}

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

	private File getAbsoluteFile() {
	File absFile = (absFileRef == null ? null : absFileRef.get());
	if (absFile == null) {
	absFile = file.getAbsoluteFile();
	absFileRef = new SoftReference<File>(absFile);
	}
	return absFile;
	}

	public CharBuffer getCharContent(boolean ignoreEncodingErrors) throws IOException {
	CharBuffer cb = ourUseContentCache? fileManager.getCachedContent(this) : null;
	if (cb == null) {
	InputStream in = new FileInputStream(file);
	try {
	final ByteBuffer bb = fileManager.makeByteBuffer(in);
	final JavaFileObject prev = fileManager.log.useSource(this);
	try {
	cb = fileManager.decode(bb, ignoreEncodingErrors);
	}
	finally {
	fileManager.log.useSource(prev);
	}
	fileManager.recycleByteBuffer(bb);
	if (ourUseContentCache && !ignoreEncodingErrors) {
	fileManager.cache(this, cb);
	}
	}
	finally {
	in.close();
	}
	}
	return cb;
	}
	}

	public void close() {
	try {
	super.close();
	}
	finally {
	// archives are cleared in super.close()
	myDirectoryCache.clear();
	myIsFile.clear();
	}
	}
	}