rev 2988 : JDK-8058150

   1 /*
   2  * Copyright (c) 2005, 2015, 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.file;
  27 
  28 import java.io.File;
  29 import java.io.FileNotFoundException;
  30 import java.io.IOException;
  31 import java.net.MalformedURLException;
  32 import java.net.URI;
  33 import java.net.URISyntaxException;
  34 import java.net.URL;
  35 import java.nio.CharBuffer;
  36 import java.nio.charset.Charset;
  37 import java.nio.file.Files;
  38 import java.nio.file.InvalidPathException;
  39 import java.nio.file.LinkOption;
  40 import java.nio.file.NoSuchFileException;
  41 import java.nio.file.Path;
  42 import java.nio.file.Paths;
  43 import java.util.ArrayList;
  44 import java.util.Arrays;
  45 import java.util.Collection;
  46 import java.util.Collections;
  47 import java.util.Comparator;
  48 import java.util.EnumSet;
  49 import java.util.HashMap;
  50 import java.util.Iterator;
  51 import java.util.Map;
  52 import java.util.Objects;
  53 import java.util.Set;
  54 import java.util.stream.Collectors;
  55 import java.util.stream.Stream;
  56 import java.util.zip.ZipFile;
  57 
  58 import javax.lang.model.SourceVersion;
  59 import javax.tools.FileObject;
  60 import javax.tools.JavaFileManager;
  61 import javax.tools.JavaFileObject;
  62 import javax.tools.StandardJavaFileManager;
  63 
  64 import com.sun.tools.javac.file.RelativePath.RelativeDirectory;
  65 import com.sun.tools.javac.file.RelativePath.RelativeFile;
  66 import com.sun.tools.javac.util.Context;
  67 import com.sun.tools.javac.util.DefinedBy;
  68 import com.sun.tools.javac.util.DefinedBy.Api;
  69 import com.sun.tools.javac.util.List;
  70 import com.sun.tools.javac.util.ListBuffer;
  71 
  72 import static javax.tools.StandardLocation.*;
  73 
  74 /**
  75  * This class provides access to the source, class and other files
  76  * used by the compiler and related tools.
  77  *
  78  * <p><b>This is NOT part of any supported API.
  79  * If you write code that depends on this, you do so at your own risk.
  80  * This code and its internal interfaces are subject to change or
  81  * deletion without notice.</b>
  82  */
  83 public class JavacFileManager extends BaseFileManager implements StandardJavaFileManager {
  84 
  85     @SuppressWarnings("cast")
  86     public static char[] toArray(CharBuffer buffer) {
  87         if (buffer.hasArray())
  88             return ((CharBuffer)buffer.compact().flip()).array();
  89         else
  90             return buffer.toString().toCharArray();
  91     }
  92 
  93     private FSInfo fsInfo;
  94 
  95     private boolean contextUseOptimizedZip;
  96     private ZipFileIndexCache zipFileIndexCache;
  97 
  98     private final Set<JavaFileObject.Kind> sourceOrClass =
  99         EnumSet.of(JavaFileObject.Kind.SOURCE, JavaFileObject.Kind.CLASS);
 100 
 101     protected boolean symbolFileEnabled;
 102 
 103     protected enum SortFiles implements Comparator<Path> {
 104         FORWARD {
 105             @Override
 106             public int compare(Path f1, Path f2) {
 107                 return f1.getFileName().compareTo(f2.getFileName());
 108             }
 109         },
 110         REVERSE {
 111             @Override
 112             public int compare(Path f1, Path f2) {
 113                 return -f1.getFileName().compareTo(f2.getFileName());
 114             }
 115         }
 116     }
 117 
 118     protected SortFiles sortFiles;
 119 
 120     /**
 121      * Register a Context.Factory to create a JavacFileManager.
 122      */
 123     public static void preRegister(Context context) {
 124         context.put(JavaFileManager.class, new Context.Factory<JavaFileManager>() {
 125             @Override
 126             public JavaFileManager make(Context c) {
 127                 return new JavacFileManager(c, true, null);
 128             }
 129         });
 130     }
 131 
 132     /**
 133      * Create a JavacFileManager using a given context, optionally registering
 134      * it as the JavaFileManager for that context.
 135      */
 136     public JavacFileManager(Context context, boolean register, Charset charset) {
 137         super(charset);
 138         if (register)
 139             context.put(JavaFileManager.class, this);
 140         setContext(context);
 141     }
 142 
 143     /**
 144      * Set the context for JavacFileManager.
 145      */
 146     @Override
 147     public void setContext(Context context) {
 148         super.setContext(context);
 149 
 150         fsInfo = FSInfo.instance(context);
 151 
 152         contextUseOptimizedZip = options.getBoolean("useOptimizedZip", true);
 153         if (contextUseOptimizedZip)
 154             zipFileIndexCache = ZipFileIndexCache.getSharedInstance();
 155 
 156         symbolFileEnabled = !options.isSet("ignore.symbol.file");
 157 
 158         String sf = options.get("sortFiles");
 159         if (sf != null) {
 160             sortFiles = (sf.equals("reverse") ? SortFiles.REVERSE : SortFiles.FORWARD);
 161         }
 162     }
 163 
 164     /**
 165      * Set whether or not to use ct.sym as an alternate to rt.jar.
 166      */
 167     public void setSymbolFileEnabled(boolean b) {
 168         symbolFileEnabled = b;
 169     }
 170 
 171     public boolean isSymbolFileEnabled() {
 172         return symbolFileEnabled;
 173     }
 174 
 175     // used by tests
 176     public JavaFileObject getFileForInput(String name) {
 177         return getRegularFile(Paths.get(name));
 178     }
 179 
 180     // used by tests
 181     public JavaFileObject getRegularFile(Path file) {
 182         return new RegularFileObject(this, file);
 183     }
 184 
 185     public JavaFileObject getFileForOutput(String classname,
 186                                            JavaFileObject.Kind kind,
 187                                            JavaFileObject sibling)
 188         throws IOException
 189     {
 190         return getJavaFileForOutput(CLASS_OUTPUT, classname, kind, sibling);
 191     }
 192 
 193     @Override @DefinedBy(Api.COMPILER)
 194     public Iterable<? extends JavaFileObject> getJavaFileObjectsFromStrings(Iterable<String> names) {
 195         ListBuffer<Path> paths = new ListBuffer<>();
 196         for (String name : names)
 197             paths.append(Paths.get(nullCheck(name)));
 198         return getJavaFileObjectsFromPaths(paths.toList());
 199     }
 200 
 201     @Override @DefinedBy(Api.COMPILER)
 202     public Iterable<? extends JavaFileObject> getJavaFileObjects(String... names) {
 203         return getJavaFileObjectsFromStrings(Arrays.asList(nullCheck(names)));
 204     }
 205 
 206     private static boolean isValidName(String name) {
 207         // Arguably, isValidName should reject keywords (such as in SourceVersion.isName() ),
 208         // but the set of keywords depends on the source level, and we don't want
 209         // impls of JavaFileManager to have to be dependent on the source level.
 210         // Therefore we simply check that the argument is a sequence of identifiers
 211         // separated by ".".
 212         for (String s : name.split("\\.", -1)) {
 213             if (!SourceVersion.isIdentifier(s))
 214                 return false;
 215         }
 216         return true;
 217     }
 218 
 219     private static void validateClassName(String className) {
 220         if (!isValidName(className))
 221             throw new IllegalArgumentException("Invalid class name: " + className);
 222     }
 223 
 224     private static void validatePackageName(String packageName) {
 225         if (packageName.length() > 0 && !isValidName(packageName))
 226             throw new IllegalArgumentException("Invalid packageName name: " + packageName);
 227     }
 228 
 229     public static void testName(String name,
 230                                 boolean isValidPackageName,
 231                                 boolean isValidClassName)
 232     {
 233         try {
 234             validatePackageName(name);
 235             if (!isValidPackageName)
 236                 throw new AssertionError("Invalid package name accepted: " + name);
 237             printAscii("Valid package name: \"%s\"", name);
 238         } catch (IllegalArgumentException e) {
 239             if (isValidPackageName)
 240                 throw new AssertionError("Valid package name rejected: " + name);
 241             printAscii("Invalid package name: \"%s\"", name);
 242         }
 243         try {
 244             validateClassName(name);
 245             if (!isValidClassName)
 246                 throw new AssertionError("Invalid class name accepted: " + name);
 247             printAscii("Valid class name: \"%s\"", name);
 248         } catch (IllegalArgumentException e) {
 249             if (isValidClassName)
 250                 throw new AssertionError("Valid class name rejected: " + name);
 251             printAscii("Invalid class name: \"%s\"", name);
 252         }
 253     }
 254 
 255     private static void printAscii(String format, Object... args) {
 256         String message;
 257         try {
 258             final String ascii = "US-ASCII";
 259             message = new String(String.format(null, format, args).getBytes(ascii), ascii);
 260         } catch (java.io.UnsupportedEncodingException ex) {
 261             throw new AssertionError(ex);
 262         }
 263         System.out.println(message);
 264     }
 265 
 266     /**
 267      * Insert all files in a subdirectory of the platform image
 268      * which match fileKinds into resultList.
 269      */
 270     private void listJRTImage(RelativeDirectory subdirectory,
 271                                Set<JavaFileObject.Kind> fileKinds,
 272                                boolean recurse,
 273                                ListBuffer<JavaFileObject> resultList) throws IOException {
 274         JRTIndex.Entry e = getJRTIndex().getEntry(subdirectory);
 275         if (symbolFileEnabled && e.ctSym.hidden)
 276             return;
 277         for (Path file: e.files.values()) {
 278             if (fileKinds.contains(getKind(file))) {
 279                 JavaFileObject fe
 280                         = PathFileObject.createJRTPathFileObject(JavacFileManager.this, file);
 281                 resultList.append(fe);
 282             }
 283         }
 284 
 285         if (recurse) {
 286             for (RelativeDirectory rd: e.subdirs) {
 287                 listJRTImage(rd, fileKinds, recurse, resultList);
 288             }
 289         }
 290     }
 291 
 292     private synchronized JRTIndex getJRTIndex() {
 293         if (jrtIndex == null)
 294             jrtIndex = JRTIndex.getSharedInstance();
 295         return jrtIndex;
 296     }
 297 
 298     private JRTIndex jrtIndex;
 299 
 300 
 301     /**
 302      * Insert all files in subdirectory subdirectory of directory directory
 303      * which match fileKinds into resultList
 304      */
 305     private void listDirectory(Path directory,
 306                                RelativeDirectory subdirectory,
 307                                Set<JavaFileObject.Kind> fileKinds,
 308                                boolean recurse,
 309                                ListBuffer<JavaFileObject> resultList) {
 310         Path d;
 311         try {
 312             d = subdirectory.getFile(directory);
 313         } catch (InvalidPathException ignore) {
 314             return;
 315         }
 316 
 317         if (!Files.exists(d)) {
 318            return;
 319         }
 320 
 321         if (!caseMapCheck(d, subdirectory)) {
 322             return;
 323         }
 324 
 325         java.util.List<Path> files;
 326         try (Stream<Path> s = Files.list(d)) {
 327             files = (sortFiles == null ? s : s.sorted(sortFiles)).collect(Collectors.toList());
 328         } catch (IOException ignore) {
 329             return;
 330         }
 331 
 332         for (Path f: files) {
 333             String fname = f.getFileName().toString();
 334             if (fname.endsWith("/"))
 335                 fname = fname.substring(0, fname.length() - 1);
 336             if (Files.isDirectory(f)) {
 337                 if (recurse && SourceVersion.isIdentifier(fname)) {
 338                     listDirectory(directory,
 339                                   new RelativeDirectory(subdirectory, fname),
 340                                   fileKinds,
 341                                   recurse,
 342                                   resultList);
 343                 }
 344             } else {
 345                 if (isValidFile(fname, fileKinds)) {
 346                     JavaFileObject fe =
 347                         new RegularFileObject(this, fname, d.resolve(fname));
 348                     resultList.append(fe);
 349                 }
 350             }
 351         }
 352     }
 353 
 354     /**
 355      * Insert all files in subdirectory subdirectory of archive archive
 356      * which match fileKinds into resultList
 357      */
 358     private void listArchive(Archive archive,
 359                                RelativeDirectory subdirectory,
 360                                Set<JavaFileObject.Kind> fileKinds,
 361                                boolean recurse,
 362                                ListBuffer<JavaFileObject> resultList) {
 363         // Get the files directly in the subdir
 364         List<String> files = archive.getFiles(subdirectory);
 365         if (files != null) {
 366             for (; !files.isEmpty(); files = files.tail) {
 367                 String file = files.head;
 368                 if (isValidFile(file, fileKinds)) {
 369                     resultList.append(archive.getFileObject(subdirectory, file));
 370                 }
 371             }
 372         }
 373         if (recurse) {
 374             for (RelativeDirectory s: archive.getSubdirectories()) {
 375                 if (subdirectory.contains(s)) {
 376                     // Because the archive map is a flat list of directories,
 377                     // the enclosing loop will pick up all child subdirectories.
 378                     // Therefore, there is no need to recurse deeper.
 379                     listArchive(archive, s, fileKinds, false, resultList);
 380                 }
 381             }
 382         }
 383     }
 384 
 385     /**
 386      * container is a directory, a zip file, or a non-existant path.
 387      * Insert all files in subdirectory subdirectory of container which
 388      * match fileKinds into resultList
 389      */
 390     private void listContainer(Path container,
 391                                RelativeDirectory subdirectory,
 392                                Set<JavaFileObject.Kind> fileKinds,
 393                                boolean recurse,
 394                                ListBuffer<JavaFileObject> resultList) {
 395         Archive archive = archives.get(container);
 396         if (archive == null) {
 397             // Very temporary and obnoxious interim hack
 398             if (container.endsWith("bootmodules.jimage")) {
 399                 System.err.println("Warning: reference to bootmodules.jimage replaced by jrt:");
 400                 container = Locations.JRT_MARKER_FILE;
 401             } else if (container.getFileName().toString().endsWith(".jimage")) {
 402                 System.err.println("Warning: reference to " + container + " ignored");
 403                 return;
 404             }
 405 
 406             // archives are not created for directories or jrt: images
 407             if (container == Locations.JRT_MARKER_FILE) {
 408                 try {
 409                     listJRTImage(subdirectory,
 410                             fileKinds,
 411                             recurse,
 412                             resultList);
 413                 } catch (IOException ex) {
 414                     ex.printStackTrace(System.err);
 415                     log.error("error.reading.file", container, getMessage(ex));
 416                 }
 417                 return;
 418             }
 419 
 420             if  (fsInfo.isDirectory(container)) {
 421                 listDirectory(container,
 422                               subdirectory,
 423                               fileKinds,
 424                               recurse,
 425                               resultList);
 426                 return;
 427             }
 428 
 429             // Not a directory; either a file or non-existant, create the archive
 430             try {
 431                 archive = openArchive(container);
 432             } catch (IOException ex) {
 433                 log.error("error.reading.file", container, getMessage(ex));
 434                 return;
 435             }
 436         }
 437         listArchive(archive,
 438                     subdirectory,
 439                     fileKinds,
 440                     recurse,
 441                     resultList);
 442     }
 443 
 444     private boolean isValidFile(String s, Set<JavaFileObject.Kind> fileKinds) {
 445         JavaFileObject.Kind kind = getKind(s);
 446         return fileKinds.contains(kind);
 447     }
 448 
 449     private static final boolean fileSystemIsCaseSensitive =
 450         File.separatorChar == '/';
 451 
 452     /** Hack to make Windows case sensitive. Test whether given path
 453      *  ends in a string of characters with the same case as given name.
 454      *  Ignore file separators in both path and name.
 455      */
 456     private boolean caseMapCheck(Path f, RelativePath name) {
 457         if (fileSystemIsCaseSensitive) return true;
 458         // Note that toRealPath() returns the case-sensitive
 459         // spelled file name.
 460         String path;
 461         char sep;
 462         try {
 463             path = f.toRealPath(LinkOption.NOFOLLOW_LINKS).toString();
 464             sep = f.getFileSystem().getSeparator().charAt(0);
 465         } catch (IOException ex) {
 466             return false;
 467         }
 468         char[] pcs = path.toCharArray();
 469         char[] ncs = name.path.toCharArray();
 470         int i = pcs.length - 1;
 471         int j = ncs.length - 1;
 472         while (i >= 0 && j >= 0) {
 473             while (i >= 0 && pcs[i] == sep) i--;
 474             while (j >= 0 && ncs[j] == '/') j--;
 475             if (i >= 0 && j >= 0) {
 476                 if (pcs[i] != ncs[j]) return false;
 477                 i--;
 478                 j--;
 479             }
 480         }
 481         return j < 0;
 482     }
 483 
 484     /**
 485      * An archive provides a flat directory structure of a ZipFile by
 486      * mapping directory names to lists of files (basenames).
 487      */
 488     public interface Archive {
 489         void close() throws IOException;
 490 
 491         boolean contains(RelativePath name);
 492 
 493         JavaFileObject getFileObject(RelativeDirectory subdirectory, String file);
 494 
 495         List<String> getFiles(RelativeDirectory subdirectory);
 496 
 497         Set<RelativeDirectory> getSubdirectories();
 498     }
 499 
 500     public class MissingArchive implements Archive {
 501         final Path zipFileName;
 502         public MissingArchive(Path name) {
 503             zipFileName = name;
 504         }
 505         @Override
 506         public boolean contains(RelativePath name) {
 507             return false;
 508         }
 509 
 510         @Override
 511         public void close() {
 512         }
 513 
 514         @Override
 515         public JavaFileObject getFileObject(RelativeDirectory subdirectory, String file) {
 516             return null;
 517         }
 518 
 519         @Override
 520         public List<String> getFiles(RelativeDirectory subdirectory) {
 521             return List.nil();
 522         }
 523 
 524         @Override
 525         public Set<RelativeDirectory> getSubdirectories() {
 526             return Collections.emptySet();
 527         }
 528 
 529         @Override
 530         public String toString() {
 531             return "MissingArchive[" + zipFileName + "]";
 532         }
 533     }
 534 
 535     /** A directory of zip files already opened.
 536      */
 537     Map<Path, Archive> archives = new HashMap<>();
 538 
 539     /*
 540      * This method looks for a ZipFormatException and takes appropriate
 541      * evasive action. If there is a failure in the fast mode then we
 542      * fail over to the platform zip, and allow it to deal with a potentially
 543      * non compliant zip file.
 544      */
 545     protected Archive openArchive(Path zipFilename) throws IOException {
 546         try {
 547             return openArchive(zipFilename, contextUseOptimizedZip);
 548         } catch (IOException ioe) {
 549             if (ioe instanceof ZipFileIndex.ZipFormatException) {
 550                 return openArchive(zipFilename, false);
 551             } else {
 552                 throw ioe;
 553             }
 554         }
 555     }
 556 
 557     /** Open a new zip file directory, and cache it.
 558      */
 559     private Archive openArchive(Path zipFileName, boolean useOptimizedZip) throws IOException {
 560         Archive archive;
 561         try {
 562 
 563             ZipFile zdir = null;
 564 
 565             boolean usePreindexedCache = false;
 566             String preindexCacheLocation = null;
 567 
 568             if (!useOptimizedZip) {
 569                 zdir = new ZipFile(zipFileName.toFile());
 570             } else {
 571                 usePreindexedCache = options.isSet("usezipindex");
 572                 preindexCacheLocation = options.get("java.io.tmpdir");
 573                 String optCacheLoc = options.get("cachezipindexdir");
 574 
 575                 if (optCacheLoc != null && optCacheLoc.length() != 0) {
 576                     if (optCacheLoc.startsWith("\"")) {
 577                         if (optCacheLoc.endsWith("\"")) {
 578                             optCacheLoc = optCacheLoc.substring(1, optCacheLoc.length() - 1);
 579                         }
 580                         else {
 581                             optCacheLoc = optCacheLoc.substring(1);
 582                         }
 583                     }
 584 
 585                     File cacheDir = new File(optCacheLoc);
 586                     if (cacheDir.exists() && cacheDir.canWrite()) {
 587                         preindexCacheLocation = optCacheLoc;
 588                         if (!preindexCacheLocation.endsWith("/") &&
 589                             !preindexCacheLocation.endsWith(File.separator)) {
 590                             preindexCacheLocation += File.separator;
 591                         }
 592                     }
 593                 }
 594             }
 595 
 596                 if (!useOptimizedZip) {
 597                     archive = new ZipArchive(this, zdir);
 598                 } else {
 599                     archive = new ZipFileIndexArchive(this,
 600                                     zipFileIndexCache.getZipFileIndex(zipFileName,
 601                                     null,
 602                                     usePreindexedCache,
 603                                     preindexCacheLocation,
 604                                     options.isSet("writezipindexfiles")));
 605                 }
 606         } catch (FileNotFoundException | NoSuchFileException ex) {
 607             archive = new MissingArchive(zipFileName);
 608         } catch (ZipFileIndex.ZipFormatException zfe) {
 609             throw zfe;
 610         } catch (IOException ex) {
 611             if (Files.exists(zipFileName))
 612                 log.error("error.reading.file", zipFileName, getMessage(ex));
 613             archive = new MissingArchive(zipFileName);
 614         }
 615 
 616         archives.put(zipFileName, archive);
 617         return archive;
 618     }
 619 
 620     /** Flush any output resources.
 621      */
 622     @Override @DefinedBy(Api.COMPILER)
 623     public void flush() {
 624         contentCache.clear();
 625     }
 626 
 627     /**
 628      * Close the JavaFileManager, releasing resources.
 629      */
 630     @Override @DefinedBy(Api.COMPILER)
 631     public void close() {
 632         for (Iterator<Archive> i = archives.values().iterator(); i.hasNext(); ) {
 633             Archive a = i.next();
 634             i.remove();
 635             try {
 636                 a.close();
 637             } catch (IOException ignore) {
 638             }
 639         }
 640     }
 641 
 642     @Override @DefinedBy(Api.COMPILER)
 643     public ClassLoader getClassLoader(Location location) {
 644         nullCheck(location);
 645         Iterable<? extends File> path = getLocation(location);
 646         if (path == null)
 647             return null;
 648         ListBuffer<URL> lb = new ListBuffer<>();
 649         for (File f: path) {
 650             try {
 651                 lb.append(f.toURI().toURL());
 652             } catch (MalformedURLException e) {
 653                 throw new AssertionError(e);
 654             }
 655         }
 656 
 657         return getClassLoader(lb.toArray(new URL[lb.size()]));
 658     }
 659 
 660     @Override @DefinedBy(Api.COMPILER)
 661     public Iterable<JavaFileObject> list(Location location,
 662                                          String packageName,
 663                                          Set<JavaFileObject.Kind> kinds,
 664                                          boolean recurse)
 665         throws IOException
 666     {
 667         // validatePackageName(packageName);
 668         nullCheck(packageName);
 669         nullCheck(kinds);
 670 
 671         Iterable<? extends Path> path = getLocationAsPaths(location);
 672         if (path == null)
 673             return List.nil();
 674         RelativeDirectory subdirectory = RelativeDirectory.forPackage(packageName);
 675         ListBuffer<JavaFileObject> results = new ListBuffer<>();
 676 
 677         for (Path directory : path)
 678             listContainer(directory, subdirectory, kinds, recurse, results);
 679         return results.toList();
 680     }
 681 
 682     @Override @DefinedBy(Api.COMPILER)
 683     public String inferBinaryName(Location location, JavaFileObject file) {
 684         Objects.requireNonNull(file);
 685         Objects.requireNonNull(location);
 686         // Need to match the path semantics of list(location, ...)
 687         Iterable<? extends Path> path = getLocationAsPaths(location);
 688         if (path == null) {
 689             return null;
 690         }
 691 
 692         if (file instanceof BaseFileObject) {
 693             return ((BaseFileObject) file).inferBinaryName(path);
 694         } else if (file instanceof PathFileObject) {
 695             return ((PathFileObject) file).inferBinaryName(null);
 696         } else
 697             throw new IllegalArgumentException(file.getClass().getName());
 698     }
 699 
 700     @Override @DefinedBy(Api.COMPILER)
 701     public boolean isSameFile(FileObject a, FileObject b) {
 702         nullCheck(a);
 703         nullCheck(b);
 704         if (a instanceof PathFileObject && b instanceof PathFileObject)
 705             return ((PathFileObject) a).isSameFile((PathFileObject) b);
 706         // In time, we should phase out BaseFileObject in favor of PathFileObject
 707         if (!(a instanceof BaseFileObject  || a instanceof PathFileObject))
 708             throw new IllegalArgumentException("Not supported: " + a);
 709         if (!(b instanceof BaseFileObject || b instanceof PathFileObject))
 710             throw new IllegalArgumentException("Not supported: " + b);
 711         return a.equals(b);
 712     }
 713 
 714     @Override @DefinedBy(Api.COMPILER)
 715     public boolean hasLocation(Location location) {
 716         return getLocation(location) != null;
 717     }
 718 
 719     @Override @DefinedBy(Api.COMPILER)
 720     public JavaFileObject getJavaFileForInput(Location location,
 721                                               String className,
 722                                               JavaFileObject.Kind kind)
 723         throws IOException
 724     {
 725         nullCheck(location);
 726         // validateClassName(className);
 727         nullCheck(className);
 728         nullCheck(kind);
 729         if (!sourceOrClass.contains(kind))
 730             throw new IllegalArgumentException("Invalid kind: " + kind);
 731         return getFileForInput(location, RelativeFile.forClass(className, kind));
 732     }
 733 
 734     @Override @DefinedBy(Api.COMPILER)
 735     public FileObject getFileForInput(Location location,
 736                                       String packageName,
 737                                       String relativeName)
 738         throws IOException
 739     {
 740         nullCheck(location);
 741         // validatePackageName(packageName);
 742         nullCheck(packageName);
 743         if (!isRelativeUri(relativeName))
 744             throw new IllegalArgumentException("Invalid relative name: " + relativeName);
 745         RelativeFile name = packageName.length() == 0
 746             ? new RelativeFile(relativeName)
 747             : new RelativeFile(RelativeDirectory.forPackage(packageName), relativeName);
 748         return getFileForInput(location, name);
 749     }
 750 
 751     private JavaFileObject getFileForInput(Location location, RelativeFile name) throws IOException {
 752         Iterable<? extends Path> path = getLocationAsPaths(location);
 753         if (path == null)
 754             return null;
 755 
 756         for (Path file: path) {
 757             Archive a = archives.get(file);
 758             if (a == null) {
 759                 // archives are not created for directories or jrt: images
 760                 if (file == Locations.JRT_MARKER_FILE) {
 761                     JRTIndex.Entry e = getJRTIndex().getEntry(name.dirname());
 762                     if (symbolFileEnabled && e.ctSym.hidden)
 763                         continue;
 764                     Path p = e.files.get(name.basename());
 765                     if (p != null)
 766                         return PathFileObject.createJRTPathFileObject(this, p);
 767                     continue;
 768                 } else if (fsInfo.isDirectory(file)) {
 769                     try {
 770                         Path f = name.getFile(file);
 771                         if (Files.exists(f))
 772                             return new RegularFileObject(this, f);
 773                     } catch (InvalidPathException ignore) {
 774                     }
 775                     continue;
 776                 }
 777                 // Not a directory, create the archive
 778                 a = openArchive(file);
 779             }
 780             // Process the archive
 781             if (a.contains(name)) {
 782                 return a.getFileObject(name.dirname(), name.basename());
 783             }
 784         }
 785         return null;
 786     }
 787 
 788     @Override @DefinedBy(Api.COMPILER)
 789     public JavaFileObject getJavaFileForOutput(Location location,
 790                                                String className,
 791                                                JavaFileObject.Kind kind,
 792                                                FileObject sibling)
 793         throws IOException
 794     {
 795         nullCheck(location);
 796         // validateClassName(className);
 797         nullCheck(className);
 798         nullCheck(kind);
 799         if (!sourceOrClass.contains(kind))
 800             throw new IllegalArgumentException("Invalid kind: " + kind);
 801         return getFileForOutput(location, RelativeFile.forClass(className, kind), sibling);
 802     }
 803 
 804     @Override @DefinedBy(Api.COMPILER)
 805     public FileObject getFileForOutput(Location location,
 806                                        String packageName,
 807                                        String relativeName,
 808                                        FileObject sibling)
 809         throws IOException
 810     {
 811         nullCheck(location);
 812         // validatePackageName(packageName);
 813         nullCheck(packageName);
 814         if (!isRelativeUri(relativeName))
 815             throw new IllegalArgumentException("Invalid relative name: " + relativeName);
 816         RelativeFile name = packageName.length() == 0
 817             ? new RelativeFile(relativeName)
 818             : new RelativeFile(RelativeDirectory.forPackage(packageName), relativeName);
 819         return getFileForOutput(location, name, sibling);
 820     }
 821 
 822     private JavaFileObject getFileForOutput(Location location,
 823                                             RelativeFile fileName,
 824                                             FileObject sibling)
 825         throws IOException
 826     {
 827         Path dir;
 828         if (location == CLASS_OUTPUT) {
 829             if (getClassOutDir() != null) {
 830                 dir = getClassOutDir();
 831             } else {
 832                 Path siblingDir = null;
 833                 if (sibling != null && sibling instanceof RegularFileObject) {
 834                     siblingDir = ((RegularFileObject)sibling).file.getParent();
 835                 }
 836                 if (siblingDir == null)
 837                     return new RegularFileObject(this, Paths.get(fileName.basename()));
 838                 else
 839                     return new RegularFileObject(this, siblingDir.resolve(fileName.basename()));
 840             }
 841         } else if (location == SOURCE_OUTPUT) {
 842             dir = (getSourceOutDir() != null ? getSourceOutDir() : getClassOutDir());
 843         } else {
 844             Iterable<? extends Path> path = locations.getLocation(location);
 845             dir = null;
 846             for (Path f: path) {
 847                 dir = f;
 848                 break;
 849             }
 850         }
 851 
 852         try {
 853             Path file = fileName.getFile(dir); // null-safe
 854             return new RegularFileObject(this, file);
 855         } catch (InvalidPathException e) {
 856             throw new IOException("bad filename " + fileName, e);
 857         }
 858     }
 859 
 860     @Override @DefinedBy(Api.COMPILER)
 861     public Iterable<? extends JavaFileObject> getJavaFileObjectsFromFiles(
 862         Iterable<? extends File> files)
 863     {
 864         ArrayList<RegularFileObject> result;
 865         if (files instanceof Collection<?>)
 866             result = new ArrayList<>(((Collection<?>)files).size());
 867         else
 868             result = new ArrayList<>();
 869         for (File f: files)
 870             result.add(new RegularFileObject(this, nullCheck(f).toPath()));
 871         return result;
 872     }
 873 
 874     @Override @DefinedBy(Api.COMPILER)
 875     public Iterable<? extends JavaFileObject> getJavaFileObjectsFromPaths(
 876         Iterable<? extends Path> paths)
 877     {
 878         ArrayList<RegularFileObject> result;
 879         if (paths instanceof Collection<?>)
 880             result = new ArrayList<>(((Collection<?>)paths).size());
 881         else
 882             result = new ArrayList<>();
 883         for (Path p: paths)
 884             result.add(new RegularFileObject(this, nullCheck(p)));
 885         return result;
 886     }
 887 
 888     @Override @DefinedBy(Api.COMPILER)
 889     public Iterable<? extends JavaFileObject> getJavaFileObjects(File... files) {
 890         return getJavaFileObjectsFromFiles(Arrays.asList(nullCheck(files)));
 891     }
 892 
 893     @Override @DefinedBy(Api.COMPILER)
 894     public Iterable<? extends JavaFileObject> getJavaFileObjects(Path... paths) {
 895         return getJavaFileObjectsFromPaths(Arrays.asList(nullCheck(paths)));
 896     }
 897 
 898     @Override @DefinedBy(Api.COMPILER)
 899     public void setLocation(Location location,
 900                             Iterable<? extends File> searchpath)
 901         throws IOException
 902     {
 903         nullCheck(location);
 904         locations.setLocation(location, asPaths(searchpath));
 905     }
 906 
 907     @Override @DefinedBy(Api.COMPILER)
 908     public void setLocationFromPaths(Location location,
 909                             Iterable<? extends Path> searchpath)
 910         throws IOException
 911     {
 912         nullCheck(location);
 913         locations.setLocation(location, nullCheck(searchpath));
 914     }
 915 
 916     @Override @DefinedBy(Api.COMPILER)
 917     public Iterable<? extends File> getLocation(Location location) {
 918         nullCheck(location);
 919         return asFiles(locations.getLocation(location));
 920     }
 921 
 922     @Override @DefinedBy(Api.COMPILER)
 923     public Iterable<? extends Path> getLocationAsPaths(Location location) {
 924         nullCheck(location);
 925         return locations.getLocation(location);
 926     }
 927 
 928     private Path getClassOutDir() {
 929         return locations.getOutputLocation(CLASS_OUTPUT);
 930     }
 931 
 932     private Path getSourceOutDir() {
 933         return locations.getOutputLocation(SOURCE_OUTPUT);
 934     }
 935 
 936     @Override @DefinedBy(Api.COMPILER)
 937     public Path asPath(FileObject file) {
 938         if (file instanceof RegularFileObject) {
 939             return ((RegularFileObject) file).file;
 940         } else
 941             throw new IllegalArgumentException(file.getName());
 942     }
 943 
 944     /**
 945      * Enforces the specification of a "relative" name as used in
 946      * {@linkplain #getFileForInput(Location,String,String)
 947      * getFileForInput}.  This method must follow the rules defined in
 948      * that method, do not make any changes without consulting the
 949      * specification.
 950      */
 951     protected static boolean isRelativeUri(URI uri) {
 952         if (uri.isAbsolute())
 953             return false;
 954         String path = uri.normalize().getPath();
 955         if (path.length() == 0 /* isEmpty() is mustang API */)
 956             return false;
 957         if (!path.equals(uri.getPath())) // implicitly checks for embedded . and ..
 958             return false;
 959         if (path.startsWith("/") || path.startsWith("./") || path.startsWith("../"))
 960             return false;
 961         return true;
 962     }
 963 
 964     // Convenience method
 965     protected static boolean isRelativeUri(String u) {
 966         try {
 967             return isRelativeUri(new URI(u));
 968         } catch (URISyntaxException e) {
 969             return false;
 970         }
 971     }
 972 
 973     /**
 974      * Converts a relative file name to a relative URI.  This is
 975      * different from File.toURI as this method does not canonicalize
 976      * the file before creating the URI.  Furthermore, no schema is
 977      * used.
 978      * @param file a relative file name
 979      * @return a relative URI
 980      * @throws IllegalArgumentException if the file name is not
 981      * relative according to the definition given in {@link
 982      * javax.tools.JavaFileManager#getFileForInput}
 983      */
 984     public static String getRelativeName(File file) {
 985         if (!file.isAbsolute()) {
 986             String result = file.getPath().replace(File.separatorChar, '/');
 987             if (isRelativeUri(result))
 988                 return result;
 989         }
 990         throw new IllegalArgumentException("Invalid relative path: " + file);
 991     }
 992 
 993     /**
 994      * Get a detail message from an IOException.
 995      * Most, but not all, instances of IOException provide a non-null result
 996      * for getLocalizedMessage().  But some instances return null: in these
 997      * cases, fallover to getMessage(), and if even that is null, return the
 998      * name of the exception itself.
 999      * @param e an IOException
1000      * @return a string to include in a compiler diagnostic
1001      */
1002     public static String getMessage(IOException e) {
1003         String s = e.getLocalizedMessage();
1004         if (s != null)
1005             return s;
1006         s = e.getMessage();
1007         if (s != null)
1008             return s;
1009         return e.toString();
1010     }
1011 
1012     /* Converters between files and paths.
1013      * These are temporary until we can update the StandardJavaFileManager API.
1014      */
1015 
1016     private static Iterable<Path> asPaths(final Iterable<? extends File> files) {
1017         if (files == null)
1018             return null;
1019 
1020         return () -> new Iterator<Path>() {
1021             Iterator<? extends File> iter = files.iterator();
1022 
1023             @Override
1024             public boolean hasNext() {
1025                 return iter.hasNext();
1026             }
1027 
1028             @Override
1029             public Path next() {
1030                 return iter.next().toPath();
1031             }
1032         };
1033     }
1034 
1035     private static Iterable<File> asFiles(final Iterable<? extends Path> paths) {
1036         if (paths == null)
1037             return null;
1038 
1039         return () -> new Iterator<File>() {
1040             Iterator<? extends Path> iter = paths.iterator();
1041 
1042             @Override
1043             public boolean hasNext() {
1044                 return iter.hasNext();
1045             }
1046 
1047             @Override
1048             public File next() {
1049                 try {
1050                     return iter.next().toFile();
1051                 } catch (UnsupportedOperationException e) {
1052                     throw new IllegalStateException(e);
1053                 }
1054             }
1055         };
1056     }
1057 }
--- EOF ---