1 /*

     2  * Copyright (c) 2009, 2014, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.  Oracle designates this

     8  * particular file as subject to the "Classpath" exception as provided

     9  * by Oracle in the LICENSE file that accompanied this code.

    10  *

    11  * This code is distributed in the hope that it will be useful, but WITHOUT

    12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    14  * version 2 for more details (a copy is included in the LICENSE file that

    15  * accompanied this code).

    16  *

    17  * You should have received a copy of the GNU General Public License version

    18  * 2 along with this work; if not, write to the Free Software Foundation,

    19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    20  *

    21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    22  * or visit www.oracle.com if you need additional information or have any

    23  * questions.

    24  */

    25 

    26 package com.sun.tools.javac.nio;

    27 

    28 import java.io.IOException;

    29 import java.io.InputStream;

    30 import java.io.InputStreamReader;

    31 import java.io.OutputStream;

    32 import java.io.OutputStreamWriter;

    33 import java.io.Reader;

    34 import java.io.Writer;

    35 import java.net.URI;

    36 import java.nio.ByteBuffer;

    37 import java.nio.CharBuffer;

    38 import java.nio.charset.CharsetDecoder;

    39 import java.nio.file.Files;

    40 import java.nio.file.LinkOption;

    41 import java.nio.file.Path;

    42 import java.util.Objects;

    43 import javax.lang.model.element.Modifier;

    44 import javax.lang.model.element.NestingKind;

    45 import javax.tools.JavaFileObject;

    46 

    47 import com.sun.tools.javac.util.BaseFileManager;

    48 import com.sun.tools.javac.util.DefinedBy;

    49 import com.sun.tools.javac.util.DefinedBy.Api;

    50 

    51 

    52 /**

    53  *  Implementation of JavaFileObject using java.nio.file API.

    54  *

    55  *  <p>PathFileObjects are, for the most part, straightforward wrappers around

    56  *  Path objects. The primary complexity is the support for "inferBinaryName".

    57  *  This is left as an abstract method, implemented by each of a number of

    58  *  different factory methods, which compute the binary name based on

    59  *  information available at the time the file object is created.

    60  *

    61  *  <p><b>This is NOT part of any supported API.

    62  *  If you write code that depends on this, you do so at your own risk.

    63  *  This code and its internal interfaces are subject to change or

    64  *  deletion without notice.</b>

    65  */

    66 public abstract class PathFileObject implements JavaFileObject {

    67     private final BaseFileManager fileManager;

    68     private final Path path;

    69 

    70     /**

    71      * Create a PathFileObject within a directory, such that the binary name

    72      * can be inferred from the relationship to the parent directory.

    73      */

    74     static PathFileObject createDirectoryPathFileObject(BaseFileManager fileManager,

    75             final Path path, final Path dir) {

    76         return new PathFileObject(fileManager, path) {

    77             @Override

    78             public String inferBinaryName(Iterable<? extends Path> paths) {

    79                 return toBinaryName(dir.relativize(path));

    80             }

    81         };

    82     }

    83 

    84     /**

    85      * Create a PathFileObject in a file system such as a jar file, such that

    86      * the binary name can be inferred from its position within the filesystem.

    87      */

    88     public static PathFileObject createJarPathFileObject(BaseFileManager fileManager,

    89             final Path path) {

    90         return new PathFileObject(fileManager, path) {

    91             @Override

    92             public String inferBinaryName(Iterable<? extends Path> paths) {

    93                 return toBinaryName(path);

    94             }

    95         };

    96     }

    97 

    98     /**

    99      * Create a PathFileObject in a modular file system, such as jrt:, such that

   100      * the binary name can be inferred from its position within the filesystem.

   101      */

   102     public static PathFileObject createJRTPathFileObject(BaseFileManager fileManager,

   103             final Path path) {

   104         return new PathFileObject(fileManager, path) {

   105             @Override

   106             public String inferBinaryName(Iterable<? extends Path> paths) {

   107                 // use subpath to ignore the leading component containing the module name

   108                 return toBinaryName(path.subpath(1, path.getNameCount()));

   109             }

   110         };

   111     }

   112 

   113     /**

   114      * Create a PathFileObject whose binary name can be inferred from the

   115      * relative path to a sibling.

   116      */

   117     static PathFileObject createSiblingPathFileObject(BaseFileManager fileManager,

   118             final Path path, final String relativePath) {

   119         return new PathFileObject(fileManager, path) {

   120             @Override

   121             public String inferBinaryName(Iterable<? extends Path> paths) {

   122                 return toBinaryName(relativePath, "/");

   123             }

   124         };

   125     }

   126 

   127     /**

   128      * Create a PathFileObject whose binary name might be inferred from its

   129      * position on a search path.

   130      */

   131     static PathFileObject createSimplePathFileObject(BaseFileManager fileManager,

   132             final Path path) {

   133         return new PathFileObject(fileManager, path) {

   134             @Override

   135             public String inferBinaryName(Iterable<? extends Path> paths) {

   136                 Path absPath = path.toAbsolutePath();

   137                 for (Path p: paths) {

   138                     Path ap = p.toAbsolutePath();

   139                     if (absPath.startsWith(ap)) {

   140                         try {

   141                             Path rp = ap.relativize(absPath);

   142                             if (rp != null) // maybe null if absPath same as ap

   143                                 return toBinaryName(rp);

   144                         } catch (IllegalArgumentException e) {

   145                             // ignore this p if cannot relativize path to p

   146                         }

   147                     }

   148                 }

   149                 return null;

   150             }

   151         };

   152     }

   153 

   154     protected PathFileObject(BaseFileManager fileManager, Path path) {

   155         this.fileManager = Objects.requireNonNull(fileManager);

   156         this.path = Objects.requireNonNull(path);

   157     }

   158 

   159     public abstract String inferBinaryName(Iterable<? extends Path> paths);

   160 

   161     /**

   162      * Return the Path for this object.

   163      * @return the Path for this object.

   164      */

   165     public Path getPath() {

   166         return path;

   167     }

   168 

   169     @Override @DefinedBy(Api.COMPILER)

   170     public Kind getKind() {

   171         return BaseFileManager.getKind(path.getFileName().toString());

   172     }

   173 

   174     @Override @DefinedBy(Api.COMPILER)

   175     public boolean isNameCompatible(String simpleName, Kind kind) {

   176         Objects.requireNonNull(simpleName);

   177         // null check

   178         if (kind == Kind.OTHER && getKind() != kind) {

   179             return false;

   180         }

   181         String sn = simpleName + kind.extension;

   182         String pn = path.getFileName().toString();

   183         if (pn.equals(sn)) {

   184             return true;

   185         }

   186         if (pn.equalsIgnoreCase(sn)) {

   187             try {

   188                 // allow for Windows

   189                 return path.toRealPath(LinkOption.NOFOLLOW_LINKS).getFileName().toString().equals(sn);

   190             } catch (IOException e) {

   191             }

   192         }

   193         return false;

   194     }

   195 

   196     @Override @DefinedBy(Api.COMPILER)

   197     public NestingKind getNestingKind() {

   198         return null;

   199     }

   200 

   201     @Override @DefinedBy(Api.COMPILER)

   202     public Modifier getAccessLevel() {

   203         return null;

   204     }

   205 

   206     @Override @DefinedBy(Api.COMPILER)

   207     public URI toUri() {

   208         return path.toUri();

   209     }

   210 

   211     @Override @DefinedBy(Api.COMPILER)

   212     public String getName() {

   213         return path.toString();

   214     }

   215 

   216     @Override @DefinedBy(Api.COMPILER)

   217     public InputStream openInputStream() throws IOException {

   218         return Files.newInputStream(path);

   219     }

   220 

   221     @Override @DefinedBy(Api.COMPILER)

   222     public OutputStream openOutputStream() throws IOException {

   223         fileManager.flushCache(this);

   224         ensureParentDirectoriesExist();

   225         return Files.newOutputStream(path);

   226     }

   227 

   228     @Override @DefinedBy(Api.COMPILER)

   229     public Reader openReader(boolean ignoreEncodingErrors) throws IOException {

   230         CharsetDecoder decoder = fileManager.getDecoder(fileManager.getEncodingName(), ignoreEncodingErrors);

   231         return new InputStreamReader(openInputStream(), decoder);

   232     }

   233 

   234     @Override @DefinedBy(Api.COMPILER)

   235     public CharSequence getCharContent(boolean ignoreEncodingErrors) throws IOException {

   236         CharBuffer cb = fileManager.getCachedContent(this);

   237         if (cb == null) {

   238             try (InputStream in = openInputStream()) {

   239                 ByteBuffer bb = fileManager.makeByteBuffer(in);

   240                 JavaFileObject prev = fileManager.log.useSource(this);

   241                 try {

   242                     cb = fileManager.decode(bb, ignoreEncodingErrors);

   243                 } finally {

   244                     fileManager.log.useSource(prev);

   245                 }

   246                 fileManager.recycleByteBuffer(bb);

   247                 if (!ignoreEncodingErrors) {

   248                     fileManager.cache(this, cb);

   249                 }

   250             }

   251         }

   252         return cb;

   253     }

   254 

   255     @Override @DefinedBy(Api.COMPILER)

   256     public Writer openWriter() throws IOException {

   257         fileManager.flushCache(this);

   258         ensureParentDirectoriesExist();

   259         return new OutputStreamWriter(Files.newOutputStream(path), fileManager.getEncodingName());

   260     }

   261 

   262     @Override @DefinedBy(Api.COMPILER)

   263     public long getLastModified() {

   264         try {

   265             return Files.getLastModifiedTime(path).toMillis();

   266         } catch (IOException e) {

   267             return -1;

   268         }

   269     }

   270 

   271     @Override @DefinedBy(Api.COMPILER)

   272     public boolean delete() {

   273         try {

   274             Files.delete(path);

   275             return true;

   276         } catch (IOException e) {

   277             return false;

   278         }

   279     }

   280 

   281     public boolean isSameFile(PathFileObject other) {

   282         try {

   283             return Files.isSameFile(path, other.path);

   284         } catch (IOException e) {

   285             return false;

   286         }

   287     }

   288 

   289     @Override

   290     public boolean equals(Object other) {

   291         return (other instanceof PathFileObject && path.equals(((PathFileObject) other).path));

   292     }

   293 

   294     @Override

   295     public int hashCode() {

   296         return path.hashCode();

   297     }

   298 

   299     @Override

   300     public String toString() {

   301         return getClass().getSimpleName() + "[" + path + "]";

   302     }

   303 

   304     private void ensureParentDirectoriesExist() throws IOException {

   305         Path parent = path.getParent();

   306         if (parent != null)

   307             Files.createDirectories(parent);

   308     }

   309 

   310     private long size() {

   311         try {

   312             return Files.size(path);

   313         } catch (IOException e) {

   314             return -1;

   315         }

   316     }

   317 

   318     protected static String toBinaryName(Path relativePath) {

   319         return toBinaryName(relativePath.toString(),

   320                 relativePath.getFileSystem().getSeparator());

   321     }

   322 

   323     protected static String toBinaryName(String relativePath, String sep) {

   324         return removeExtension(relativePath).replace(sep, ".");

   325     }

   326 

   327     protected static String removeExtension(String fileName) {

   328         int lastDot = fileName.lastIndexOf(".");

   329         return (lastDot == -1 ? fileName : fileName.substring(0, lastDot));

   330     }

   331 }