Mercurial > jdk8-mips64-public > langtools / changeset

     1.1 --- a/src/share/classes/com/sun/tools/apt/main/JavaCompiler.java	Fri Jun 06 15:17:35 2008 -0700
     1.2 +++ b/src/share/classes/com/sun/tools/apt/main/JavaCompiler.java	Mon Jun 16 13:28:00 2008 -0700
     1.3 @@ -26,20 +26,14 @@
     1.4  package com.sun.tools.apt.main;
     1.5  
     1.6  import java.io.*;
     1.7 -import java.nio.CharBuffer;
     1.8 -import java.util.Set;
     1.9 -import java.util.HashSet;
    1.10  import java.util.Map;
    1.11 -import java.util.HashMap;
    1.12  
    1.13  import javax.tools.JavaFileManager;
    1.14  import javax.tools.JavaFileObject;
    1.15  
    1.16 +import com.sun.tools.javac.file.JavacFileManager;
    1.17  import com.sun.tools.javac.util.*;
    1.18  import com.sun.tools.javac.code.*;
    1.19 -import com.sun.tools.javac.tree.*;
    1.20 -import com.sun.tools.javac.parser.*;
    1.21 -import com.sun.tools.javac.comp.*;
    1.22  import com.sun.tools.javac.jvm.*;
    1.23  
    1.24  import com.sun.tools.javac.code.Symbol.*;

     2.1 --- a/src/share/classes/com/sun/tools/apt/main/Main.java	Fri Jun 06 15:17:35 2008 -0700
     2.2 +++ b/src/share/classes/com/sun/tools/apt/main/Main.java	Mon Jun 16 13:28:00 2008 -0700
     2.3 @@ -44,7 +44,7 @@
     2.4  import java.io.File;
     2.5  import java.net.MalformedURLException;
     2.6  
     2.7 -import com.sun.tools.javac.util.Paths;
     2.8 +import com.sun.tools.javac.file.Paths;
     2.9  import com.sun.tools.javac.code.Source;
    2.10  import com.sun.tools.javac.code.Symbol;
    2.11  import com.sun.tools.javac.code.Type;

     3.1 --- a/src/share/classes/com/sun/tools/javac/api/JavacTaskImpl.java	Fri Jun 06 15:17:35 2008 -0700
     3.2 +++ b/src/share/classes/com/sun/tools/javac/api/JavacTaskImpl.java	Mon Jun 16 13:28:00 2008 -0700
     3.3 @@ -36,12 +36,12 @@
     3.4  import javax.lang.model.type.TypeMirror;
     3.5  import javax.tools.*;
     3.6  
     3.7 -import com.sun.source.tree.Tree;
     3.8  import com.sun.source.tree.*;
     3.9  import com.sun.source.util.*;
    3.10  import com.sun.tools.javac.code.*;
    3.11  import com.sun.tools.javac.code.Symbol.*;
    3.12  import com.sun.tools.javac.comp.*;
    3.13 +import com.sun.tools.javac.file.JavacFileManager;
    3.14  import com.sun.tools.javac.main.*;
    3.15  import com.sun.tools.javac.model.*;
    3.16  import com.sun.tools.javac.parser.Parser;

     4.1 --- a/src/share/classes/com/sun/tools/javac/api/JavacTool.java	Fri Jun 06 15:17:35 2008 -0700
     4.2 +++ b/src/share/classes/com/sun/tools/javac/api/JavacTool.java	Mon Jun 16 13:28:00 2008 -0700
     4.3 @@ -31,7 +31,6 @@
     4.4  import java.io.PrintWriter;
     4.5  import java.io.Writer;
     4.6  import java.util.ArrayList;
     4.7 -import java.util.Arrays;
     4.8  import java.util.Collections;
     4.9  import java.util.EnumSet;
    4.10  import java.util.Iterator;
    4.11 @@ -42,13 +41,13 @@
    4.12  import javax.tools.*;
    4.13  
    4.14  import com.sun.source.util.JavacTask;
    4.15 +import com.sun.tools.javac.file.JavacFileManager;
    4.16  import com.sun.tools.javac.main.JavacOption.OptionKind;
    4.17  import com.sun.tools.javac.main.JavacOption;
    4.18  import com.sun.tools.javac.main.Main;
    4.19  import com.sun.tools.javac.main.RecognizedOptions.GrumpyHelper;
    4.20  import com.sun.tools.javac.main.RecognizedOptions;
    4.21  import com.sun.tools.javac.util.Context;
    4.22 -import com.sun.tools.javac.util.JavacFileManager;
    4.23  import com.sun.tools.javac.util.Log;
    4.24  import com.sun.tools.javac.util.Options;
    4.25  import com.sun.tools.javac.util.Pair;

     5.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     5.2 +++ b/src/share/classes/com/sun/tools/javac/file/BaseFileObject.java	Mon Jun 16 13:28:00 2008 -0700
     5.3 @@ -0,0 +1,79 @@
     5.4 +/*
     5.5 + * Copyright 2005-2006 Sun Microsystems, Inc.  All Rights Reserved.
     5.6 + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
     5.7 + *
     5.8 + * This code is free software; you can redistribute it and/or modify it
     5.9 + * under the terms of the GNU General Public License version 2 only, as
    5.10 + * published by the Free Software Foundation.  Sun designates this
    5.11 + * particular file as subject to the "Classpath" exception as provided
    5.12 + * by Sun in the LICENSE file that accompanied this code.
    5.13 + *
    5.14 + * This code is distributed in the hope that it will be useful, but WITHOUT
    5.15 + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
    5.16 + * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
    5.17 + * version 2 for more details (a copy is included in the LICENSE file that
    5.18 + * accompanied this code).
    5.19 + *
    5.20 + * You should have received a copy of the GNU General Public License version
    5.21 + * 2 along with this work; if not, write to the Free Software Foundation,
    5.22 + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
    5.23 + *
    5.24 + * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
    5.25 + * CA 95054 USA or visit www.sun.com if you need additional information or
    5.26 + * have any questions.
    5.27 + */
    5.28 +
    5.29 +package com.sun.tools.javac.file;
    5.30 +
    5.31 +import java.io.IOException;
    5.32 +import java.io.InputStreamReader;
    5.33 +import java.io.Reader;
    5.34 +import java.nio.charset.CharsetDecoder;
    5.35 +import javax.lang.model.element.Modifier;
    5.36 +import javax.lang.model.element.NestingKind;
    5.37 +import javax.tools.JavaFileObject;
    5.38 +
    5.39 +import static javax.tools.JavaFileObject.Kind.*;
    5.40 +
    5.41 +public abstract class BaseFileObject implements JavaFileObject {
    5.42 +
    5.43 +    public JavaFileObject.Kind getKind() {
    5.44 +        String n = getName();
    5.45 +        if (n.endsWith(CLASS.extension))
    5.46 +            return CLASS;
    5.47 +        else if (n.endsWith(SOURCE.extension))
    5.48 +            return SOURCE;
    5.49 +        else if (n.endsWith(HTML.extension))
    5.50 +            return HTML;
    5.51 +        else
    5.52 +            return OTHER;
    5.53 +    }
    5.54 +
    5.55 +    @Override
    5.56 +    public String toString() {
    5.57 +        return getPath();
    5.58 +    }
    5.59 +
    5.60 +    /** @deprecated see bug 6410637 */
    5.61 +    @Deprecated
    5.62 +    public String getPath() {
    5.63 +        return getName();
    5.64 +    }
    5.65 +
    5.66 +    /** @deprecated see bug 6410637 */
    5.67 +    @Deprecated
    5.68 +    abstract public String getName();
    5.69 +
    5.70 +    public NestingKind getNestingKind() { return null; }
    5.71 +
    5.72 +    public Modifier getAccessLevel()  { return null; }
    5.73 +
    5.74 +    public Reader openReader(boolean ignoreEncodingErrors) throws IOException {
    5.75 +        return new InputStreamReader(openInputStream(), getDecoder(ignoreEncodingErrors));
    5.76 +    }
    5.77 +
    5.78 +    protected CharsetDecoder getDecoder(boolean ignoreEncodingErrors) {
    5.79 +        throw new UnsupportedOperationException();
    5.80 +    }
    5.81 +
    5.82 +}

     6.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     6.2 +++ b/src/share/classes/com/sun/tools/javac/file/JavacFileManager.java	Mon Jun 16 13:28:00 2008 -0700
     6.3 @@ -0,0 +1,1718 @@
     6.4 +/*
     6.5 + * Copyright 2005-2006 Sun Microsystems, Inc.  All Rights Reserved.
     6.6 + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
     6.7 + *
     6.8 + * This code is free software; you can redistribute it and/or modify it
     6.9 + * under the terms of the GNU General Public License version 2 only, as
    6.10 + * published by the Free Software Foundation.  Sun designates this
    6.11 + * particular file as subject to the "Classpath" exception as provided
    6.12 + * by Sun in the LICENSE file that accompanied this code.
    6.13 + *
    6.14 + * This code is distributed in the hope that it will be useful, but WITHOUT
    6.15 + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
    6.16 + * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
    6.17 + * version 2 for more details (a copy is included in the LICENSE file that
    6.18 + * accompanied this code).
    6.19 + *
    6.20 + * You should have received a copy of the GNU General Public License version
    6.21 + * 2 along with this work; if not, write to the Free Software Foundation,
    6.22 + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
    6.23 + *
    6.24 + * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
    6.25 + * CA 95054 USA or visit www.sun.com if you need additional information or
    6.26 + * have any questions.
    6.27 + */
    6.28 +
    6.29 +package com.sun.tools.javac.file;
    6.30 +
    6.31 +import java.io.ByteArrayInputStream;
    6.32 +import java.io.ByteArrayOutputStream;
    6.33 +import java.io.File;
    6.34 +import java.io.FileInputStream;
    6.35 +import java.io.FileNotFoundException;
    6.36 +import java.io.FileOutputStream;
    6.37 +import java.io.IOException;
    6.38 +import java.io.InputStream;
    6.39 +import java.io.OutputStream;
    6.40 +import java.io.OutputStreamWriter;
    6.41 +import java.io.Writer;
    6.42 +import java.lang.ref.SoftReference;
    6.43 +import java.net.MalformedURLException;
    6.44 +import java.net.URI;
    6.45 +import java.net.URISyntaxException;
    6.46 +import java.net.URL;
    6.47 +import java.net.URLClassLoader;
    6.48 +import java.nio.ByteBuffer;
    6.49 +import java.nio.CharBuffer;
    6.50 +import java.nio.channels.FileChannel;
    6.51 +import java.nio.charset.Charset;
    6.52 +import java.nio.charset.CharsetDecoder;
    6.53 +import java.nio.charset.CoderResult;
    6.54 +import java.nio.charset.CodingErrorAction;
    6.55 +import java.nio.charset.IllegalCharsetNameException;
    6.56 +import java.nio.charset.UnsupportedCharsetException;
    6.57 +import java.util.ArrayList;
    6.58 +import java.util.Arrays;
    6.59 +import java.util.Collection;
    6.60 +import java.util.Collections;
    6.61 +import java.util.EnumSet;
    6.62 +import java.util.Enumeration;
    6.63 +import java.util.HashMap;
    6.64 +import java.util.Iterator;
    6.65 +import java.util.Map;
    6.66 +import java.util.Set;
    6.67 +import java.util.concurrent.ConcurrentHashMap;
    6.68 +import java.util.zip.ZipEntry;
    6.69 +import java.util.zip.ZipFile;
    6.70 +
    6.71 +import javax.lang.model.SourceVersion;
    6.72 +import javax.tools.FileObject;
    6.73 +import javax.tools.JavaFileManager;
    6.74 +import javax.tools.JavaFileObject;
    6.75 +import javax.tools.StandardJavaFileManager;
    6.76 +
    6.77 +import com.sun.tools.javac.code.Source;
    6.78 +import com.sun.tools.javac.main.JavacOption;
    6.79 +import com.sun.tools.javac.main.OptionName;
    6.80 +import com.sun.tools.javac.main.RecognizedOptions;
    6.81 +import com.sun.tools.javac.util.Context;
    6.82 +import com.sun.tools.javac.util.JCDiagnostic.SimpleDiagnosticPosition;
    6.83 +import com.sun.tools.javac.util.List;
    6.84 +import com.sun.tools.javac.util.ListBuffer;
    6.85 +import com.sun.tools.javac.util.Log;
    6.86 +import com.sun.tools.javac.util.Options;
    6.87 +
    6.88 +import static com.sun.tools.javac.main.OptionName.*;
    6.89 +import static javax.tools.StandardLocation.*;
    6.90 +
    6.91 +/**
    6.92 + * This class provides access to the source, class and other files
    6.93 + * used by the compiler and related tools.
    6.94 + */
    6.95 +public class JavacFileManager implements StandardJavaFileManager {
    6.96 +
    6.97 +    private static final String[] symbolFileLocation = { "lib", "ct.sym" };
    6.98 +    private static final String symbolFilePrefix = "META-INF/sym/rt.jar/";
    6.99 +
   6.100 +    boolean useZipFileIndex;
   6.101 +
   6.102 +    private static int symbolFilePrefixLength = 0;
   6.103 +    static {
   6.104 +        try {
   6.105 +            symbolFilePrefixLength = symbolFilePrefix.getBytes("UTF-8").length;
   6.106 +        } catch (java.io.UnsupportedEncodingException uee) {
   6.107 +            // Can't happen...UTF-8 is always supported.
   6.108 +        }
   6.109 +    }
   6.110 +
   6.111 +    private static boolean CHECK_ZIP_TIMESTAMP = false;
   6.112 +    private static Map<File, Boolean> isDirectory = new ConcurrentHashMap<File, Boolean>();
   6.113 +
   6.114 +
   6.115 +    public static char[] toArray(CharBuffer buffer) {
   6.116 +        if (buffer.hasArray())
   6.117 +            return ((CharBuffer)buffer.compact().flip()).array();
   6.118 +        else
   6.119 +            return buffer.toString().toCharArray();
   6.120 +    }
   6.121 +
   6.122 +    /**
   6.123 +     * The log to be used for error reporting.
   6.124 +     */
   6.125 +    protected Log log;
   6.126 +
   6.127 +    /** Encapsulates knowledge of paths
   6.128 +     */
   6.129 +    private Paths paths;
   6.130 +
   6.131 +    private Options options;
   6.132 +
   6.133 +    private final File uninited = new File("U N I N I T E D");
   6.134 +
   6.135 +    private final Set<JavaFileObject.Kind> sourceOrClass =
   6.136 +        EnumSet.of(JavaFileObject.Kind.SOURCE, JavaFileObject.Kind.CLASS);
   6.137 +
   6.138 +    /** The standard output directory, primarily used for classes.
   6.139 +     *  Initialized by the "-d" option.
   6.140 +     *  If classOutDir = null, files are written into same directory as the sources
   6.141 +     *  they were generated from.
   6.142 +     */
   6.143 +    private File classOutDir = uninited;
   6.144 +
   6.145 +    /** The output directory, used when generating sources while processing annotations.
   6.146 +     *  Initialized by the "-s" option.
   6.147 +     */
   6.148 +    private File sourceOutDir = uninited;
   6.149 +
   6.150 +    protected boolean mmappedIO;
   6.151 +    protected boolean ignoreSymbolFile;
   6.152 +
   6.153 +    /**
   6.154 +     * User provided charset (through javax.tools).
   6.155 +     */
   6.156 +    protected Charset charset;
   6.157 +
   6.158 +    /**
   6.159 +     * Register a Context.Factory to create a JavacFileManager.
   6.160 +     */
   6.161 +    public static void preRegister(final Context context) {
   6.162 +        context.put(JavaFileManager.class, new Context.Factory<JavaFileManager>() {
   6.163 +            public JavaFileManager make() {
   6.164 +                return new JavacFileManager(context, true, null);
   6.165 +            }
   6.166 +        });
   6.167 +    }
   6.168 +
   6.169 +    /**
   6.170 +     * Create a JavacFileManager using a given context, optionally registering
   6.171 +     * it as the JavaFileManager for that context.
   6.172 +     */
   6.173 +    public JavacFileManager(Context context, boolean register, Charset charset) {
   6.174 +        if (register)
   6.175 +            context.put(JavaFileManager.class, this);
   6.176 +        byteBufferCache = new ByteBufferCache();
   6.177 +        this.charset = charset;
   6.178 +        setContext(context);
   6.179 +    }
   6.180 +
   6.181 +    /**
   6.182 +     * Set the context for JavacFileManager.
   6.183 +     */
   6.184 +    public void setContext(Context context) {
   6.185 +        log = Log.instance(context);
   6.186 +        if (paths == null) {
   6.187 +            paths = Paths.instance(context);
   6.188 +        } else {
   6.189 +            // Reuse the Paths object as it stores the locations that
   6.190 +            // have been set with setLocation, etc.
   6.191 +            paths.setContext(context);
   6.192 +        }
   6.193 +
   6.194 +        options = Options.instance(context);
   6.195 +
   6.196 +        useZipFileIndex = System.getProperty("useJavaUtilZip") == null;// TODO: options.get("useJavaUtilZip") == null;
   6.197 +        CHECK_ZIP_TIMESTAMP = System.getProperty("checkZipIndexTimestamp") != null;// TODO: options.get("checkZipIndexTimestamp") != null;
   6.198 +
   6.199 +        mmappedIO = options.get("mmappedIO") != null;
   6.200 +        ignoreSymbolFile = options.get("ignore.symbol.file") != null;
   6.201 +    }
   6.202 +
   6.203 +    public JavaFileObject getFileForInput(String name) {
   6.204 +        return getRegularFile(new File(name));
   6.205 +    }
   6.206 +
   6.207 +    public JavaFileObject getRegularFile(File file) {
   6.208 +        return new RegularFileObject(file);
   6.209 +    }
   6.210 +
   6.211 +    public JavaFileObject getFileForOutput(String classname,
   6.212 +                                           JavaFileObject.Kind kind,
   6.213 +                                           JavaFileObject sibling)
   6.214 +        throws IOException
   6.215 +    {
   6.216 +        return getJavaFileForOutput(CLASS_OUTPUT, classname, kind, sibling);
   6.217 +    }
   6.218 +
   6.219 +    public Iterable<? extends JavaFileObject> getJavaFileObjectsFromStrings(Iterable<String> names) {
   6.220 +        ListBuffer<File> files = new ListBuffer<File>();
   6.221 +        for (String name : names)
   6.222 +            files.append(new File(nullCheck(name)));
   6.223 +        return getJavaFileObjectsFromFiles(files.toList());
   6.224 +    }
   6.225 +
   6.226 +    public Iterable<? extends JavaFileObject> getJavaFileObjects(String... names) {
   6.227 +        return getJavaFileObjectsFromStrings(Arrays.asList(nullCheck(names)));
   6.228 +    }
   6.229 +
   6.230 +    protected JavaFileObject.Kind getKind(String extension) {
   6.231 +        if (extension.equals(JavaFileObject.Kind.CLASS.extension))
   6.232 +            return JavaFileObject.Kind.CLASS;
   6.233 +        else if (extension.equals(JavaFileObject.Kind.SOURCE.extension))
   6.234 +            return JavaFileObject.Kind.SOURCE;
   6.235 +        else if (extension.equals(JavaFileObject.Kind.HTML.extension))
   6.236 +            return JavaFileObject.Kind.HTML;
   6.237 +        else
   6.238 +            return JavaFileObject.Kind.OTHER;
   6.239 +    }
   6.240 +
   6.241 +    private static boolean isValidName(String name) {
   6.242 +        // Arguably, isValidName should reject keywords (such as in SourceVersion.isName() ),
   6.243 +        // but the set of keywords depends on the source level, and we don't want
   6.244 +        // impls of JavaFileManager to have to be dependent on the source level.
   6.245 +        // Therefore we simply check that the argument is a sequence of identifiers
   6.246 +        // separated by ".".
   6.247 +        for (String s : name.split("\\.", -1)) {
   6.248 +            if (!SourceVersion.isIdentifier(s))
   6.249 +                return false;
   6.250 +        }
   6.251 +        return true;
   6.252 +    }
   6.253 +
   6.254 +    private static void validateClassName(String className) {
   6.255 +        if (!isValidName(className))
   6.256 +            throw new IllegalArgumentException("Invalid class name: " + className);
   6.257 +    }
   6.258 +
   6.259 +    private static void validatePackageName(String packageName) {
   6.260 +        if (packageName.length() > 0 && !isValidName(packageName))
   6.261 +            throw new IllegalArgumentException("Invalid packageName name: " + packageName);
   6.262 +    }
   6.263 +
   6.264 +    public static void testName(String name,
   6.265 +                                boolean isValidPackageName,
   6.266 +                                boolean isValidClassName)
   6.267 +    {
   6.268 +        try {
   6.269 +            validatePackageName(name);
   6.270 +            if (!isValidPackageName)
   6.271 +                throw new AssertionError("Invalid package name accepted: " + name);
   6.272 +            printAscii("Valid package name: \"%s\"", name);
   6.273 +        } catch (IllegalArgumentException e) {
   6.274 +            if (isValidPackageName)
   6.275 +                throw new AssertionError("Valid package name rejected: " + name);
   6.276 +            printAscii("Invalid package name: \"%s\"", name);
   6.277 +        }
   6.278 +        try {
   6.279 +            validateClassName(name);
   6.280 +            if (!isValidClassName)
   6.281 +                throw new AssertionError("Invalid class name accepted: " + name);
   6.282 +            printAscii("Valid class name: \"%s\"", name);
   6.283 +        } catch (IllegalArgumentException e) {
   6.284 +            if (isValidClassName)
   6.285 +                throw new AssertionError("Valid class name rejected: " + name);
   6.286 +            printAscii("Invalid class name: \"%s\"", name);
   6.287 +        }
   6.288 +    }
   6.289 +    private static void printAscii(String format, Object... args) {
   6.290 +        String message;
   6.291 +        try {
   6.292 +            final String ascii = "US-ASCII";
   6.293 +            message = new String(String.format(null, format, args).getBytes(ascii), ascii);
   6.294 +        } catch (java.io.UnsupportedEncodingException ex) {
   6.295 +            throw new AssertionError(ex);
   6.296 +        }
   6.297 +        System.out.println(message);
   6.298 +    }
   6.299 +
   6.300 +    /** Return external representation of name,
   6.301 +     *  converting '.' to File.separatorChar.
   6.302 +     */
   6.303 +    private static String externalizeFileName(CharSequence name) {
   6.304 +        return name.toString().replace('.', File.separatorChar);
   6.305 +    }
   6.306 +
   6.307 +    private static String externalizeFileName(CharSequence n, JavaFileObject.Kind kind) {
   6.308 +        return externalizeFileName(n) + kind.extension;
   6.309 +    }
   6.310 +
   6.311 +    private static String baseName(String fileName) {
   6.312 +        return fileName.substring(fileName.lastIndexOf(File.separatorChar) + 1);
   6.313 +    }
   6.314 +
   6.315 +    /**
   6.316 +     * Insert all files in subdirectory `subdirectory' of `directory' which end
   6.317 +     * in one of the extensions in `extensions' into packageSym.
   6.318 +     */
   6.319 +    private void listDirectory(File directory,
   6.320 +                               String subdirectory,
   6.321 +                               Set<JavaFileObject.Kind> fileKinds,
   6.322 +                               boolean recurse,
   6.323 +                               ListBuffer<JavaFileObject> l) {
   6.324 +        Archive archive = archives.get(directory);
   6.325 +
   6.326 +        boolean isFile = false;
   6.327 +        if (CHECK_ZIP_TIMESTAMP) {
   6.328 +            Boolean isf = isDirectory.get(directory);
   6.329 +            if (isf == null) {
   6.330 +                isFile = directory.isFile();
   6.331 +                isDirectory.put(directory, isFile);
   6.332 +            }
   6.333 +            else {
   6.334 +                isFile = directory.isFile();
   6.335 +            }
   6.336 +        }
   6.337 +        else {
   6.338 +            isFile = directory.isFile();
   6.339 +        }
   6.340 +
   6.341 +        if (archive != null || isFile) {
   6.342 +            if (archive == null) {
   6.343 +                try {
   6.344 +                    archive = openArchive(directory);
   6.345 +                } catch (IOException ex) {
   6.346 +                    log.error("error.reading.file",
   6.347 +                       directory, ex.getLocalizedMessage());
   6.348 +                    return;
   6.349 +                }
   6.350 +            }
   6.351 +            if (subdirectory.length() != 0) {
   6.352 +                if (!useZipFileIndex) {
   6.353 +                    subdirectory = subdirectory.replace('\\', '/');
   6.354 +                    if (!subdirectory.endsWith("/")) subdirectory = subdirectory + "/";
   6.355 +                }
   6.356 +                else {
   6.357 +                    if (File.separatorChar == '/') {
   6.358 +                        subdirectory = subdirectory.replace('\\', '/');
   6.359 +                    }
   6.360 +                    else {
   6.361 +                        subdirectory = subdirectory.replace('/', '\\');
   6.362 +                    }
   6.363 +
   6.364 +                    if (!subdirectory.endsWith(File.separator)) subdirectory = subdirectory + File.separator;
   6.365 +                }
   6.366 +            }
   6.367 +
   6.368 +            List<String> files = archive.getFiles(subdirectory);
   6.369 +            if (files != null) {
   6.370 +                for (String file; !files.isEmpty(); files = files.tail) {
   6.371 +                    file = files.head;
   6.372 +                    if (isValidFile(file, fileKinds)) {
   6.373 +                        l.append(archive.getFileObject(subdirectory, file));
   6.374 +                    }
   6.375 +                }
   6.376 +            }
   6.377 +            if (recurse) {
   6.378 +                for (String s: archive.getSubdirectories()) {
   6.379 +                    if (s.startsWith(subdirectory) && !s.equals(subdirectory)) {
   6.380 +                        // Because the archive map is a flat list of directories,
   6.381 +                        // the enclosing loop will pick up all child subdirectories.
   6.382 +                        // Therefore, there is no need to recurse deeper.
   6.383 +                        listDirectory(directory, s, fileKinds, false, l);
   6.384 +                    }
   6.385 +                }
   6.386 +            }
   6.387 +        } else {
   6.388 +            File d = subdirectory.length() != 0
   6.389 +                ? new File(directory, subdirectory)
   6.390 +                : directory;
   6.391 +            if (!caseMapCheck(d, subdirectory))
   6.392 +                return;
   6.393 +
   6.394 +            File[] files = d.listFiles();
   6.395 +            if (files == null)
   6.396 +                return;
   6.397 +
   6.398 +            for (File f: files) {
   6.399 +                String fname = f.getName();
   6.400 +                if (f.isDirectory()) {
   6.401 +                    if (recurse && SourceVersion.isIdentifier(fname)) {
   6.402 +                        listDirectory(directory,
   6.403 +                                      subdirectory + File.separator + fname,
   6.404 +                                      fileKinds,
   6.405 +                                      recurse,
   6.406 +                                      l);
   6.407 +                    }
   6.408 +                } else {
   6.409 +                    if (isValidFile(fname, fileKinds)) {
   6.410 +                        JavaFileObject fe =
   6.411 +                        new RegularFileObject(fname, new File(d, fname));
   6.412 +                        l.append(fe);
   6.413 +                    }
   6.414 +                }
   6.415 +            }
   6.416 +        }
   6.417 +    }
   6.418 +
   6.419 +    private boolean isValidFile(String s, Set<JavaFileObject.Kind> fileKinds) {
   6.420 +        int lastDot = s.lastIndexOf(".");
   6.421 +        String extn = (lastDot == -1 ? s : s.substring(lastDot));
   6.422 +        JavaFileObject.Kind kind = getKind(extn);
   6.423 +        return fileKinds.contains(kind);
   6.424 +    }
   6.425 +
   6.426 +    private static final boolean fileSystemIsCaseSensitive =
   6.427 +        File.separatorChar == '/';
   6.428 +
   6.429 +    /** Hack to make Windows case sensitive. Test whether given path
   6.430 +     *  ends in a string of characters with the same case as given name.
   6.431 +     *  Ignore file separators in both path and name.
   6.432 +     */
   6.433 +    private boolean caseMapCheck(File f, String name) {
   6.434 +        if (fileSystemIsCaseSensitive) return true;
   6.435 +        // Note that getCanonicalPath() returns the case-sensitive
   6.436 +        // spelled file name.
   6.437 +        String path;
   6.438 +        try {
   6.439 +            path = f.getCanonicalPath();
   6.440 +        } catch (IOException ex) {
   6.441 +            return false;
   6.442 +        }
   6.443 +        char[] pcs = path.toCharArray();
   6.444 +        char[] ncs = name.toCharArray();
   6.445 +        int i = pcs.length - 1;
   6.446 +        int j = ncs.length - 1;
   6.447 +        while (i >= 0 && j >= 0) {
   6.448 +            while (i >= 0 && pcs[i] == File.separatorChar) i--;
   6.449 +            while (j >= 0 && ncs[j] == File.separatorChar) j--;
   6.450 +            if (i >= 0 && j >= 0) {
   6.451 +                if (pcs[i] != ncs[j]) return false;
   6.452 +                i--;
   6.453 +                j--;
   6.454 +            }
   6.455 +        }
   6.456 +        return j < 0;
   6.457 +    }
   6.458 +
   6.459 +    /**
   6.460 +     * An archive provides a flat directory structure of a ZipFile by
   6.461 +     * mapping directory names to lists of files (basenames).
   6.462 +     */
   6.463 +    public interface Archive {
   6.464 +        void close() throws IOException;
   6.465 +
   6.466 +        boolean contains(String name);
   6.467 +
   6.468 +        JavaFileObject getFileObject(String subdirectory, String file);
   6.469 +
   6.470 +        List<String> getFiles(String subdirectory);
   6.471 +
   6.472 +        Set<String> getSubdirectories();
   6.473 +    }
   6.474 +
   6.475 +    public class ZipArchive implements Archive {
   6.476 +        protected final Map<String,List<String>> map;
   6.477 +        protected final ZipFile zdir;
   6.478 +        public ZipArchive(ZipFile zdir) throws IOException {
   6.479 +            this.zdir = zdir;
   6.480 +            this.map = new HashMap<String,List<String>>();
   6.481 +            for (Enumeration<? extends ZipEntry> e = zdir.entries(); e.hasMoreElements(); ) {
   6.482 +                ZipEntry entry;
   6.483 +                try {
   6.484 +                    entry = e.nextElement();
   6.485 +                } catch (InternalError ex) {
   6.486 +                    IOException io = new IOException();
   6.487 +                    io.initCause(ex); // convenience constructors added in Mustang :-(
   6.488 +                    throw io;
   6.489 +                }
   6.490 +                addZipEntry(entry);
   6.491 +            }
   6.492 +        }
   6.493 +
   6.494 +        void addZipEntry(ZipEntry entry) {
   6.495 +            String name = entry.getName();
   6.496 +            int i = name.lastIndexOf('/');
   6.497 +            String dirname = name.substring(0, i+1);
   6.498 +            String basename = name.substring(i+1);
   6.499 +            if (basename.length() == 0)
   6.500 +                return;
   6.501 +            List<String> list = map.get(dirname);
   6.502 +            if (list == null)
   6.503 +                list = List.nil();
   6.504 +            list = list.prepend(basename);
   6.505 +            map.put(dirname, list);
   6.506 +        }
   6.507 +
   6.508 +        public boolean contains(String name) {
   6.509 +            int i = name.lastIndexOf('/');
   6.510 +            String dirname = name.substring(0, i+1);
   6.511 +            String basename = name.substring(i+1);
   6.512 +            if (basename.length() == 0)
   6.513 +                return false;
   6.514 +            List<String> list = map.get(dirname);
   6.515 +            return (list != null && list.contains(basename));
   6.516 +        }
   6.517 +
   6.518 +        public List<String> getFiles(String subdirectory) {
   6.519 +            return map.get(subdirectory);
   6.520 +        }
   6.521 +
   6.522 +        public JavaFileObject getFileObject(String subdirectory, String file) {
   6.523 +            ZipEntry ze = zdir.getEntry(subdirectory + file);
   6.524 +            return new ZipFileObject(file, zdir, ze);
   6.525 +        }
   6.526 +
   6.527 +        public Set<String> getSubdirectories() {
   6.528 +            return map.keySet();
   6.529 +        }
   6.530 +
   6.531 +        public void close() throws IOException {
   6.532 +            zdir.close();
   6.533 +        }
   6.534 +    }
   6.535 +
   6.536 +    public class SymbolArchive extends ZipArchive {
   6.537 +        final File origFile;
   6.538 +        public SymbolArchive(File orig, ZipFile zdir) throws IOException {
   6.539 +            super(zdir);
   6.540 +            this.origFile = orig;
   6.541 +        }
   6.542 +
   6.543 +        @Override
   6.544 +        void addZipEntry(ZipEntry entry) {
   6.545 +            // called from super constructor, may not refer to origFile.
   6.546 +            String name = entry.getName();
   6.547 +            if (!name.startsWith(symbolFilePrefix))
   6.548 +                return;
   6.549 +            name = name.substring(symbolFilePrefix.length());
   6.550 +            int i = name.lastIndexOf('/');
   6.551 +            String dirname = name.substring(0, i+1);
   6.552 +            String basename = name.substring(i+1);
   6.553 +            if (basename.length() == 0)
   6.554 +                return;
   6.555 +            List<String> list = map.get(dirname);
   6.556 +            if (list == null)
   6.557 +                list = List.nil();
   6.558 +            list = list.prepend(basename);
   6.559 +            map.put(dirname, list);
   6.560 +        }
   6.561 +
   6.562 +        @Override
   6.563 +        public JavaFileObject getFileObject(String subdirectory, String file) {
   6.564 +            return super.getFileObject(symbolFilePrefix + subdirectory, file);
   6.565 +        }
   6.566 +    }
   6.567 +
   6.568 +    public class MissingArchive implements Archive {
   6.569 +        final File zipFileName;
   6.570 +        public MissingArchive(File name) {
   6.571 +            zipFileName = name;
   6.572 +        }
   6.573 +        public boolean contains(String name) {
   6.574 +              return false;
   6.575 +        }
   6.576 +
   6.577 +        public void close() {
   6.578 +        }
   6.579 +
   6.580 +        public JavaFileObject getFileObject(String subdirectory, String file) {
   6.581 +            return null;
   6.582 +        }
   6.583 +
   6.584 +        public List<String> getFiles(String subdirectory) {
   6.585 +            return List.nil();
   6.586 +        }
   6.587 +
   6.588 +        public Set<String> getSubdirectories() {
   6.589 +            return Collections.emptySet();
   6.590 +        }
   6.591 +    }
   6.592 +
   6.593 +    /** A directory of zip files already opened.
   6.594 +     */
   6.595 +    Map<File, Archive> archives = new HashMap<File,Archive>();
   6.596 +
   6.597 +    /** Open a new zip file directory.
   6.598 +     */
   6.599 +    protected Archive openArchive(File zipFileName) throws IOException {
   6.600 +        Archive archive = archives.get(zipFileName);
   6.601 +        if (archive == null) {
   6.602 +            File origZipFileName = zipFileName;
   6.603 +            if (!ignoreSymbolFile && paths.isBootClassPathRtJar(zipFileName)) {
   6.604 +                File file = zipFileName.getParentFile().getParentFile(); // ${java.home}
   6.605 +                if (new File(file.getName()).equals(new File("jre")))
   6.606 +                    file = file.getParentFile();
   6.607 +                // file == ${jdk.home}
   6.608 +                for (String name : symbolFileLocation)
   6.609 +                    file = new File(file, name);
   6.610 +                // file == ${jdk.home}/lib/ct.sym
   6.611 +                if (file.exists())
   6.612 +                    zipFileName = file;
   6.613 +            }
   6.614 +
   6.615 +            try {
   6.616 +
   6.617 +                ZipFile zdir = null;
   6.618 +
   6.619 +                boolean usePreindexedCache = false;
   6.620 +                String preindexCacheLocation = null;
   6.621 +
   6.622 +                if (!useZipFileIndex) {
   6.623 +                    zdir = new ZipFile(zipFileName);
   6.624 +                }
   6.625 +                else {
   6.626 +                    usePreindexedCache = options.get("usezipindex") != null;
   6.627 +                    preindexCacheLocation = options.get("java.io.tmpdir");
   6.628 +                    String optCacheLoc = options.get("cachezipindexdir");
   6.629 +
   6.630 +                    if (optCacheLoc != null && optCacheLoc.length() != 0) {
   6.631 +                        if (optCacheLoc.startsWith("\"")) {
   6.632 +                            if (optCacheLoc.endsWith("\"")) {
   6.633 +                                optCacheLoc = optCacheLoc.substring(1, optCacheLoc.length() - 1);
   6.634 +                            }
   6.635 +                           else {
   6.636 +                                optCacheLoc = optCacheLoc.substring(1);
   6.637 +                            }
   6.638 +                        }
   6.639 +
   6.640 +                        File cacheDir = new File(optCacheLoc);
   6.641 +                        if (cacheDir.exists() && cacheDir.canWrite()) {
   6.642 +                            preindexCacheLocation = optCacheLoc;
   6.643 +                            if (!preindexCacheLocation.endsWith("/") &&
   6.644 +                                !preindexCacheLocation.endsWith(File.separator)) {
   6.645 +                                preindexCacheLocation += File.separator;
   6.646 +                            }
   6.647 +                        }
   6.648 +                    }
   6.649 +                }
   6.650 +
   6.651 +                if (origZipFileName == zipFileName) {
   6.652 +                    if (!useZipFileIndex) {
   6.653 +                        archive = new ZipArchive(zdir);
   6.654 +                    } else {
   6.655 +                        archive = new ZipFileIndexArchive(this, ZipFileIndex.getZipFileIndex(zipFileName, 0,
   6.656 +                                usePreindexedCache, preindexCacheLocation, options.get("writezipindexfiles") != null));
   6.657 +                    }
   6.658 +                }
   6.659 +                else {
   6.660 +                    if (!useZipFileIndex) {
   6.661 +                        archive = new SymbolArchive(origZipFileName, zdir);
   6.662 +                    }
   6.663 +                    else {
   6.664 +                        archive = new ZipFileIndexArchive(this, ZipFileIndex.getZipFileIndex(zipFileName, symbolFilePrefixLength,
   6.665 +                                usePreindexedCache, preindexCacheLocation, options.get("writezipindexfiles") != null));
   6.666 +                    }
   6.667 +                }
   6.668 +            } catch (FileNotFoundException ex) {
   6.669 +                archive = new MissingArchive(zipFileName);
   6.670 +            } catch (IOException ex) {
   6.671 +                log.error("error.reading.file", zipFileName, ex.getLocalizedMessage());
   6.672 +                archive = new MissingArchive(zipFileName);
   6.673 +            }
   6.674 +
   6.675 +            archives.put(origZipFileName, archive);
   6.676 +        }
   6.677 +        return archive;
   6.678 +    }
   6.679 +
   6.680 +    /** Flush any output resources.
   6.681 +     */
   6.682 +    public void flush() {
   6.683 +        contentCache.clear();
   6.684 +    }
   6.685 +
   6.686 +    /**
   6.687 +     * Close the JavaFileManager, releasing resources.
   6.688 +     */
   6.689 +    public void close() {
   6.690 +        for (Iterator<Archive> i = archives.values().iterator(); i.hasNext(); ) {
   6.691 +            Archive a = i.next();
   6.692 +            i.remove();
   6.693 +            try {
   6.694 +                a.close();
   6.695 +            } catch (IOException e) {
   6.696 +            }
   6.697 +        }
   6.698 +    }
   6.699 +
   6.700 +    private Map<JavaFileObject, SoftReference<CharBuffer>> contentCache = new HashMap<JavaFileObject, SoftReference<CharBuffer>>();
   6.701 +
   6.702 +    private String defaultEncodingName;
   6.703 +    private String getDefaultEncodingName() {
   6.704 +        if (defaultEncodingName == null) {
   6.705 +            defaultEncodingName =
   6.706 +                new OutputStreamWriter(new ByteArrayOutputStream()).getEncoding();
   6.707 +        }
   6.708 +        return defaultEncodingName;
   6.709 +    }
   6.710 +
   6.711 +    protected String getEncodingName() {
   6.712 +        String encName = options.get(OptionName.ENCODING);
   6.713 +        if (encName == null)
   6.714 +            return getDefaultEncodingName();
   6.715 +        else
   6.716 +            return encName;
   6.717 +    }
   6.718 +
   6.719 +    protected Source getSource() {
   6.720 +        String sourceName = options.get(OptionName.SOURCE);
   6.721 +        Source source = null;
   6.722 +        if (sourceName != null)
   6.723 +            source = Source.lookup(sourceName);
   6.724 +        return (source != null ? source : Source.DEFAULT);
   6.725 +    }
   6.726 +
   6.727 +    /**
   6.728 +     * Make a byte buffer from an input stream.
   6.729 +     */
   6.730 +    private ByteBuffer makeByteBuffer(InputStream in)
   6.731 +        throws IOException {
   6.732 +        int limit = in.available();
   6.733 +        if (mmappedIO && in instanceof FileInputStream) {
   6.734 +            // Experimental memory mapped I/O
   6.735 +            FileInputStream fin = (FileInputStream)in;
   6.736 +            return fin.getChannel().map(FileChannel.MapMode.READ_ONLY, 0, limit);
   6.737 +        }
   6.738 +        if (limit < 1024) limit = 1024;
   6.739 +        ByteBuffer result = byteBufferCache.get(limit);
   6.740 +        int position = 0;
   6.741 +        while (in.available() != 0) {
   6.742 +            if (position >= limit)
   6.743 +                // expand buffer
   6.744 +                result = ByteBuffer.
   6.745 +                    allocate(limit <<= 1).
   6.746 +                    put((ByteBuffer)result.flip());
   6.747 +            int count = in.read(result.array(),
   6.748 +                position,
   6.749 +                limit - position);
   6.750 +            if (count < 0) break;
   6.751 +            result.position(position += count);
   6.752 +        }
   6.753 +        return (ByteBuffer)result.flip();
   6.754 +    }
   6.755 +
   6.756 +    /**
   6.757 +     * A single-element cache of direct byte buffers.
   6.758 +     */
   6.759 +    private static class ByteBufferCache {
   6.760 +        private ByteBuffer cached;
   6.761 +        ByteBuffer get(int capacity) {
   6.762 +            if (capacity < 20480) capacity = 20480;
   6.763 +            ByteBuffer result =
   6.764 +                (cached != null && cached.capacity() >= capacity)
   6.765 +                ? (ByteBuffer)cached.clear()
   6.766 +                : ByteBuffer.allocate(capacity + capacity>>1);
   6.767 +            cached = null;
   6.768 +            return result;
   6.769 +        }
   6.770 +        void put(ByteBuffer x) {
   6.771 +            cached = x;
   6.772 +        }
   6.773 +    }
   6.774 +    private final ByteBufferCache byteBufferCache;
   6.775 +
   6.776 +    private CharsetDecoder getDecoder(String encodingName, boolean ignoreEncodingErrors) {
   6.777 +        Charset charset = (this.charset == null)
   6.778 +            ? Charset.forName(encodingName)
   6.779 +            : this.charset;
   6.780 +        CharsetDecoder decoder = charset.newDecoder();
   6.781 +
   6.782 +        CodingErrorAction action;
   6.783 +        if (ignoreEncodingErrors)
   6.784 +            action = CodingErrorAction.REPLACE;
   6.785 +        else
   6.786 +            action = CodingErrorAction.REPORT;
   6.787 +
   6.788 +        return decoder
   6.789 +            .onMalformedInput(action)
   6.790 +            .onUnmappableCharacter(action);
   6.791 +    }
   6.792 +
   6.793 +    /**
   6.794 +     * Decode a ByteBuffer into a CharBuffer.
   6.795 +     */
   6.796 +    private CharBuffer decode(ByteBuffer inbuf, boolean ignoreEncodingErrors) {
   6.797 +        String encodingName = getEncodingName();
   6.798 +        CharsetDecoder decoder;
   6.799 +        try {
   6.800 +            decoder = getDecoder(encodingName, ignoreEncodingErrors);
   6.801 +        } catch (IllegalCharsetNameException e) {
   6.802 +            log.error("unsupported.encoding", encodingName);
   6.803 +            return (CharBuffer)CharBuffer.allocate(1).flip();
   6.804 +        } catch (UnsupportedCharsetException e) {
   6.805 +            log.error("unsupported.encoding", encodingName);
   6.806 +            return (CharBuffer)CharBuffer.allocate(1).flip();
   6.807 +        }
   6.808 +
   6.809 +        // slightly overestimate the buffer size to avoid reallocation.
   6.810 +        float factor =
   6.811 +            decoder.averageCharsPerByte() * 0.8f +
   6.812 +            decoder.maxCharsPerByte() * 0.2f;
   6.813 +        CharBuffer dest = CharBuffer.
   6.814 +            allocate(10 + (int)(inbuf.remaining()*factor));
   6.815 +
   6.816 +        while (true) {
   6.817 +            CoderResult result = decoder.decode(inbuf, dest, true);
   6.818 +            dest.flip();
   6.819 +
   6.820 +            if (result.isUnderflow()) { // done reading
   6.821 +                // make sure there is at least one extra character
   6.822 +                if (dest.limit() == dest.capacity()) {
   6.823 +                    dest = CharBuffer.allocate(dest.capacity()+1).put(dest);
   6.824 +                    dest.flip();
   6.825 +                }
   6.826 +                return dest;
   6.827 +            } else if (result.isOverflow()) { // buffer too small; expand
   6.828 +                int newCapacity =
   6.829 +                    10 + dest.capacity() +
   6.830 +                    (int)(inbuf.remaining()*decoder.maxCharsPerByte());
   6.831 +                dest = CharBuffer.allocate(newCapacity).put(dest);
   6.832 +            } else if (result.isMalformed() || result.isUnmappable()) {
   6.833 +                // bad character in input
   6.834 +
   6.835 +                // report coding error (warn only pre 1.5)
   6.836 +                if (!getSource().allowEncodingErrors()) {
   6.837 +                    log.error(new SimpleDiagnosticPosition(dest.limit()),
   6.838 +                              "illegal.char.for.encoding",
   6.839 +                              charset == null ? encodingName : charset.name());
   6.840 +                } else {
   6.841 +                    log.warning(new SimpleDiagnosticPosition(dest.limit()),
   6.842 +                                "illegal.char.for.encoding",
   6.843 +                                charset == null ? encodingName : charset.name());
   6.844 +                }
   6.845 +
   6.846 +                // skip past the coding error
   6.847 +                inbuf.position(inbuf.position() + result.length());
   6.848 +
   6.849 +                // undo the flip() to prepare the output buffer
   6.850 +                // for more translation
   6.851 +                dest.position(dest.limit());
   6.852 +                dest.limit(dest.capacity());
   6.853 +                dest.put((char)0xfffd); // backward compatible
   6.854 +            } else {
   6.855 +                throw new AssertionError(result);
   6.856 +            }
   6.857 +        }
   6.858 +        // unreached
   6.859 +    }
   6.860 +
   6.861 +    public ClassLoader getClassLoader(Location location) {
   6.862 +        nullCheck(location);
   6.863 +        Iterable<? extends File> path = getLocation(location);
   6.864 +        if (path == null)
   6.865 +            return null;
   6.866 +        ListBuffer<URL> lb = new ListBuffer<URL>();
   6.867 +        for (File f: path) {
   6.868 +            try {
   6.869 +                lb.append(f.toURI().toURL());
   6.870 +            } catch (MalformedURLException e) {
   6.871 +                throw new AssertionError(e);
   6.872 +            }
   6.873 +        }
   6.874 +        return new URLClassLoader(lb.toArray(new URL[lb.size()]),
   6.875 +            getClass().getClassLoader());
   6.876 +    }
   6.877 +
   6.878 +    public Iterable<JavaFileObject> list(Location location,
   6.879 +                                         String packageName,
   6.880 +                                         Set<JavaFileObject.Kind> kinds,
   6.881 +                                         boolean recurse)
   6.882 +        throws IOException
   6.883 +    {
   6.884 +        // validatePackageName(packageName);
   6.885 +        nullCheck(packageName);
   6.886 +        nullCheck(kinds);
   6.887 +
   6.888 +        Iterable<? extends File> path = getLocation(location);
   6.889 +        if (path == null)
   6.890 +            return List.nil();
   6.891 +        String subdirectory = externalizeFileName(packageName);
   6.892 +        ListBuffer<JavaFileObject> results = new ListBuffer<JavaFileObject>();
   6.893 +
   6.894 +        for (File directory : path)
   6.895 +            listDirectory(directory, subdirectory, kinds, recurse, results);
   6.896 +
   6.897 +        return results.toList();
   6.898 +    }
   6.899 +
   6.900 +    public String inferBinaryName(Location location, JavaFileObject file) {
   6.901 +        file.getClass(); // null check
   6.902 +        location.getClass(); // null check
   6.903 +        // Need to match the path semantics of list(location, ...)
   6.904 +        Iterable<? extends File> path = getLocation(location);
   6.905 +        if (path == null) {
   6.906 +            //System.err.println("Path for " + location + " is null");
   6.907 +            return null;
   6.908 +        }
   6.909 +        //System.err.println("Path for " + location + " is " + path);
   6.910 +
   6.911 +        if (file instanceof RegularFileObject) {
   6.912 +            RegularFileObject r = (RegularFileObject) file;
   6.913 +            String rPath = r.getPath();
   6.914 +            //System.err.println("RegularFileObject " + file + " " +r.getPath());
   6.915 +            for (File dir: path) {
   6.916 +                //System.err.println("dir: " + dir);
   6.917 +                String dPath = dir.getPath();
   6.918 +                if (!dPath.endsWith(File.separator))
   6.919 +                    dPath += File.separator;
   6.920 +                if (rPath.regionMatches(true, 0, dPath, 0, dPath.length())
   6.921 +                    && new File(rPath.substring(0, dPath.length())).equals(new File(dPath))) {
   6.922 +                    String relativeName = rPath.substring(dPath.length());
   6.923 +                    return removeExtension(relativeName).replace(File.separatorChar, '.');
   6.924 +                }
   6.925 +            }
   6.926 +        } else if (file instanceof ZipFileObject) {
   6.927 +            ZipFileObject z = (ZipFileObject) file;
   6.928 +            String entryName = z.getZipEntryName();
   6.929 +            if (entryName.startsWith(symbolFilePrefix))
   6.930 +                entryName = entryName.substring(symbolFilePrefix.length());
   6.931 +            return removeExtension(entryName).replace('/', '.');
   6.932 +        } else if (file instanceof ZipFileIndexFileObject) {
   6.933 +            ZipFileIndexFileObject z = (ZipFileIndexFileObject) file;
   6.934 +            String entryName = z.getZipEntryName();
   6.935 +            if (entryName.startsWith(symbolFilePrefix))
   6.936 +                entryName = entryName.substring(symbolFilePrefix.length());
   6.937 +            return removeExtension(entryName).replace(File.separatorChar, '.');
   6.938 +        } else
   6.939 +            throw new IllegalArgumentException(file.getClass().getName());
   6.940 +        // System.err.println("inferBinaryName failed for " + file);
   6.941 +        return null;
   6.942 +    }
   6.943 +    // where
   6.944 +        private static String removeExtension(String fileName) {
   6.945 +            int lastDot = fileName.lastIndexOf(".");
   6.946 +            return (lastDot == -1 ? fileName : fileName.substring(0, lastDot));
   6.947 +        }
   6.948 +
   6.949 +    public boolean isSameFile(FileObject a, FileObject b) {
   6.950 +        nullCheck(a);
   6.951 +        nullCheck(b);
   6.952 +        if (!(a instanceof BaseFileObject))
   6.953 +            throw new IllegalArgumentException("Not supported: " + a);
   6.954 +        if (!(b instanceof BaseFileObject))
   6.955 +            throw new IllegalArgumentException("Not supported: " + b);
   6.956 +        return a.equals(b);
   6.957 +    }
   6.958 +
   6.959 +    public boolean handleOption(String current, Iterator<String> remaining) {
   6.960 +        for (JavacOption o: javacFileManagerOptions) {
   6.961 +            if (o.matches(current))  {
   6.962 +                if (o.hasArg()) {
   6.963 +                    if (remaining.hasNext()) {
   6.964 +                        if (!o.process(options, current, remaining.next()))
   6.965 +                            return true;
   6.966 +                    }
   6.967 +                } else {
   6.968 +                    if (!o.process(options, current))
   6.969 +                        return true;
   6.970 +                }
   6.971 +                // operand missing, or process returned false
   6.972 +                throw new IllegalArgumentException(current);
   6.973 +            }
   6.974 +        }
   6.975 +
   6.976 +        return false;
   6.977 +    }
   6.978 +    // where
   6.979 +        private static JavacOption[] javacFileManagerOptions =
   6.980 +            RecognizedOptions.getJavacFileManagerOptions(
   6.981 +            new RecognizedOptions.GrumpyHelper());
   6.982 +
   6.983 +    public int isSupportedOption(String option) {
   6.984 +        for (JavacOption o : javacFileManagerOptions) {
   6.985 +            if (o.matches(option))
   6.986 +                return o.hasArg() ? 1 : 0;
   6.987 +        }
   6.988 +        return -1;
   6.989 +    }
   6.990 +
   6.991 +    public boolean hasLocation(Location location) {
   6.992 +        return getLocation(location) != null;
   6.993 +    }
   6.994 +
   6.995 +    public JavaFileObject getJavaFileForInput(Location location,
   6.996 +                                              String className,
   6.997 +                                              JavaFileObject.Kind kind)
   6.998 +        throws IOException
   6.999 +    {
  6.1000 +        nullCheck(location);
  6.1001 +        // validateClassName(className);
  6.1002 +        nullCheck(className);
  6.1003 +        nullCheck(kind);
  6.1004 +        if (!sourceOrClass.contains(kind))
  6.1005 +            throw new IllegalArgumentException("Invalid kind " + kind);
  6.1006 +        return getFileForInput(location, externalizeFileName(className, kind));
  6.1007 +    }
  6.1008 +
  6.1009 +    public FileObject getFileForInput(Location location,
  6.1010 +                                      String packageName,
  6.1011 +                                      String relativeName)
  6.1012 +        throws IOException
  6.1013 +    {
  6.1014 +        nullCheck(location);
  6.1015 +        // validatePackageName(packageName);
  6.1016 +        nullCheck(packageName);
  6.1017 +        if (!isRelativeUri(URI.create(relativeName))) // FIXME 6419701
  6.1018 +            throw new IllegalArgumentException("Invalid relative name: " + relativeName);
  6.1019 +        String name = packageName.length() == 0
  6.1020 +            ? relativeName
  6.1021 +            : new File(externalizeFileName(packageName), relativeName).getPath();
  6.1022 +        return getFileForInput(location, name);
  6.1023 +    }
  6.1024 +
  6.1025 +    private JavaFileObject getFileForInput(Location location, String name) throws IOException {
  6.1026 +        Iterable<? extends File> path = getLocation(location);
  6.1027 +        if (path == null)
  6.1028 +            return null;
  6.1029 +
  6.1030 +        for (File dir: path) {
  6.1031 +            if (dir.isDirectory()) {
  6.1032 +                File f = new File(dir, name.replace('/', File.separatorChar));
  6.1033 +                if (f.exists())
  6.1034 +                    return new RegularFileObject(f);
  6.1035 +            } else {
  6.1036 +                Archive a = openArchive(dir);
  6.1037 +                if (a.contains(name)) {
  6.1038 +                    int i = name.lastIndexOf('/');
  6.1039 +                    String dirname = name.substring(0, i+1);
  6.1040 +                    String basename = name.substring(i+1);
  6.1041 +                    return a.getFileObject(dirname, basename);
  6.1042 +                }
  6.1043 +
  6.1044 +            }
  6.1045 +        }
  6.1046 +        return null;
  6.1047 +
  6.1048 +    }
  6.1049 +
  6.1050 +    public JavaFileObject getJavaFileForOutput(Location location,
  6.1051 +                                               String className,
  6.1052 +                                               JavaFileObject.Kind kind,
  6.1053 +                                               FileObject sibling)
  6.1054 +        throws IOException
  6.1055 +    {
  6.1056 +        nullCheck(location);
  6.1057 +        // validateClassName(className);
  6.1058 +        nullCheck(className);
  6.1059 +        nullCheck(kind);
  6.1060 +        if (!sourceOrClass.contains(kind))
  6.1061 +            throw new IllegalArgumentException("Invalid kind " + kind);
  6.1062 +        return getFileForOutput(location, externalizeFileName(className, kind), sibling);
  6.1063 +    }
  6.1064 +
  6.1065 +    public FileObject getFileForOutput(Location location,
  6.1066 +                                       String packageName,
  6.1067 +                                       String relativeName,
  6.1068 +                                       FileObject sibling)
  6.1069 +        throws IOException
  6.1070 +    {
  6.1071 +        nullCheck(location);
  6.1072 +        // validatePackageName(packageName);
  6.1073 +        nullCheck(packageName);
  6.1074 +        if (!isRelativeUri(URI.create(relativeName))) // FIXME 6419701
  6.1075 +            throw new IllegalArgumentException("relativeName is invalid");
  6.1076 +        String name = packageName.length() == 0
  6.1077 +            ? relativeName
  6.1078 +            : new File(externalizeFileName(packageName), relativeName).getPath();
  6.1079 +        return getFileForOutput(location, name, sibling);
  6.1080 +    }
  6.1081 +
  6.1082 +    private JavaFileObject getFileForOutput(Location location,
  6.1083 +                                            String fileName,
  6.1084 +                                            FileObject sibling)
  6.1085 +        throws IOException
  6.1086 +    {
  6.1087 +        File dir;
  6.1088 +        if (location == CLASS_OUTPUT) {
  6.1089 +            if (getClassOutDir() != null) {
  6.1090 +                dir = getClassOutDir();
  6.1091 +            } else {
  6.1092 +                File siblingDir = null;
  6.1093 +                if (sibling != null && sibling instanceof RegularFileObject) {
  6.1094 +                    siblingDir = ((RegularFileObject)sibling).f.getParentFile();
  6.1095 +                }
  6.1096 +                return new RegularFileObject(new File(siblingDir, baseName(fileName)));
  6.1097 +            }
  6.1098 +        } else if (location == SOURCE_OUTPUT) {
  6.1099 +            dir = (getSourceOutDir() != null ? getSourceOutDir() : getClassOutDir());
  6.1100 +        } else {
  6.1101 +            Iterable<? extends File> path = paths.getPathForLocation(location);
  6.1102 +            dir = null;
  6.1103 +            for (File f: path) {
  6.1104 +                dir = f;
  6.1105 +                break;
  6.1106 +            }
  6.1107 +        }
  6.1108 +
  6.1109 +        File file = (dir == null ? new File(fileName) : new File(dir, fileName));
  6.1110 +        return new RegularFileObject(file);
  6.1111 +
  6.1112 +    }
  6.1113 +
  6.1114 +    public Iterable<? extends JavaFileObject> getJavaFileObjectsFromFiles(
  6.1115 +        Iterable<? extends File> files)
  6.1116 +    {
  6.1117 +        ArrayList<RegularFileObject> result;
  6.1118 +        if (files instanceof Collection)
  6.1119 +            result = new ArrayList<RegularFileObject>(((Collection)files).size());
  6.1120 +        else
  6.1121 +            result = new ArrayList<RegularFileObject>();
  6.1122 +        for (File f: files)
  6.1123 +            result.add(new RegularFileObject(nullCheck(f)));
  6.1124 +        return result;
  6.1125 +    }
  6.1126 +
  6.1127 +    public Iterable<? extends JavaFileObject> getJavaFileObjects(File... files) {
  6.1128 +        return getJavaFileObjectsFromFiles(Arrays.asList(nullCheck(files)));
  6.1129 +    }
  6.1130 +
  6.1131 +    public void setLocation(Location location,
  6.1132 +                            Iterable<? extends File> path)
  6.1133 +        throws IOException
  6.1134 +    {
  6.1135 +        nullCheck(location);
  6.1136 +        paths.lazy();
  6.1137 +
  6.1138 +        final File dir = location.isOutputLocation() ? getOutputDirectory(path) : null;
  6.1139 +
  6.1140 +        if (location == CLASS_OUTPUT)
  6.1141 +            classOutDir = getOutputLocation(dir, D);
  6.1142 +        else if (location == SOURCE_OUTPUT)
  6.1143 +            sourceOutDir = getOutputLocation(dir, S);
  6.1144 +        else
  6.1145 +            paths.setPathForLocation(location, path);
  6.1146 +    }
  6.1147 +    // where
  6.1148 +        private File getOutputDirectory(Iterable<? extends File> path) throws IOException {
  6.1149 +            if (path == null)
  6.1150 +                return null;
  6.1151 +            Iterator<? extends File> pathIter = path.iterator();
  6.1152 +            if (!pathIter.hasNext())
  6.1153 +                throw new IllegalArgumentException("empty path for directory");
  6.1154 +            File dir = pathIter.next();
  6.1155 +            if (pathIter.hasNext())
  6.1156 +                throw new IllegalArgumentException("path too long for directory");
  6.1157 +            if (!dir.exists())
  6.1158 +                throw new FileNotFoundException(dir + ": does not exist");
  6.1159 +            else if (!dir.isDirectory())
  6.1160 +                throw new IOException(dir + ": not a directory");
  6.1161 +            return dir;
  6.1162 +        }
  6.1163 +
  6.1164 +    private File getOutputLocation(File dir, OptionName defaultOptionName) {
  6.1165 +        if (dir != null)
  6.1166 +            return dir;
  6.1167 +        String arg = options.get(defaultOptionName);
  6.1168 +        if (arg == null)
  6.1169 +            return null;
  6.1170 +        return new File(arg);
  6.1171 +    }
  6.1172 +
  6.1173 +    public Iterable<? extends File> getLocation(Location location) {
  6.1174 +        nullCheck(location);
  6.1175 +        paths.lazy();
  6.1176 +        if (location == CLASS_OUTPUT) {
  6.1177 +            return (getClassOutDir() == null ? null : List.of(getClassOutDir()));
  6.1178 +        } else if (location == SOURCE_OUTPUT) {
  6.1179 +            return (getSourceOutDir() == null ? null : List.of(getSourceOutDir()));
  6.1180 +        } else
  6.1181 +            return paths.getPathForLocation(location);
  6.1182 +    }
  6.1183 +
  6.1184 +    private File getClassOutDir() {
  6.1185 +        if (classOutDir == uninited)
  6.1186 +            classOutDir = getOutputLocation(null, D);
  6.1187 +        return classOutDir;
  6.1188 +    }
  6.1189 +
  6.1190 +    private File getSourceOutDir() {
  6.1191 +        if (sourceOutDir == uninited)
  6.1192 +            sourceOutDir = getOutputLocation(null, S);
  6.1193 +        return sourceOutDir;
  6.1194 +    }
  6.1195 +
  6.1196 +    /**
  6.1197 +     * Enforces the specification of a "relative" URI as used in
  6.1198 +     * {@linkplain #getFileForInput(Location,String,URI)
  6.1199 +     * getFileForInput}.  This method must follow the rules defined in
  6.1200 +     * that method, do not make any changes without consulting the
  6.1201 +     * specification.
  6.1202 +     */
  6.1203 +    protected static boolean isRelativeUri(URI uri) {
  6.1204 +        if (uri.isAbsolute())
  6.1205 +            return false;
  6.1206 +        String path = uri.normalize().getPath();
  6.1207 +        if (path.length() == 0 /* isEmpty() is mustang API */)
  6.1208 +            return false;
  6.1209 +        char first = path.charAt(0);
  6.1210 +        return first != '.' && first != '/';
  6.1211 +    }
  6.1212 +
  6.1213 +    /**
  6.1214 +     * Converts a relative file name to a relative URI.  This is
  6.1215 +     * different from File.toURI as this method does not canonicalize
  6.1216 +     * the file before creating the URI.  Furthermore, no schema is
  6.1217 +     * used.
  6.1218 +     * @param file a relative file name
  6.1219 +     * @return a relative URI
  6.1220 +     * @throws IllegalArgumentException if the file name is not
  6.1221 +     * relative according to the definition given in {@link
  6.1222 +     * javax.tools.JavaFileManager#getFileForInput}
  6.1223 +     */
  6.1224 +    public static String getRelativeName(File file) {
  6.1225 +        if (!file.isAbsolute()) {
  6.1226 +            String result = file.getPath().replace(File.separatorChar, '/');
  6.1227 +            if (JavacFileManager.isRelativeUri(URI.create(result))) // FIXME 6419701
  6.1228 +                return result;
  6.1229 +        }
  6.1230 +        throw new IllegalArgumentException("Invalid relative path: " + file);
  6.1231 +    }
  6.1232 +
  6.1233 +    @SuppressWarnings("deprecation") // bug 6410637
  6.1234 +    public static String getJavacFileName(FileObject file) {
  6.1235 +        if (file instanceof BaseFileObject)
  6.1236 +            return ((BaseFileObject)file).getPath();
  6.1237 +        URI uri = file.toUri();
  6.1238 +        String scheme = uri.getScheme();
  6.1239 +        if (scheme == null || scheme.equals("file") || scheme.equals("jar"))
  6.1240 +            return uri.getPath();
  6.1241 +        else
  6.1242 +            return uri.toString();
  6.1243 +    }
  6.1244 +
  6.1245 +    @SuppressWarnings("deprecation") // bug 6410637
  6.1246 +    public static String getJavacBaseFileName(FileObject file) {
  6.1247 +        if (file instanceof BaseFileObject)
  6.1248 +            return ((BaseFileObject)file).getName();
  6.1249 +        URI uri = file.toUri();
  6.1250 +        String scheme = uri.getScheme();
  6.1251 +        if (scheme == null || scheme.equals("file") || scheme.equals("jar")) {
  6.1252 +            String path = uri.getPath();
  6.1253 +            if (path == null)
  6.1254 +                return null;
  6.1255 +            if (scheme != null && scheme.equals("jar"))
  6.1256 +                path = path.substring(path.lastIndexOf('!') + 1);
  6.1257 +            return path.substring(path.lastIndexOf('/') + 1);
  6.1258 +        } else {
  6.1259 +            return uri.toString();
  6.1260 +        }
  6.1261 +    }
  6.1262 +
  6.1263 +    private static <T> T nullCheck(T o) {
  6.1264 +        o.getClass(); // null check
  6.1265 +        return o;
  6.1266 +    }
  6.1267 +
  6.1268 +    private static <T> Iterable<T> nullCheck(Iterable<T> it) {
  6.1269 +        for (T t : it)
  6.1270 +            t.getClass(); // null check
  6.1271 +        return it;
  6.1272 +    }
  6.1273 +
  6.1274 +    /**
  6.1275 +     * A subclass of JavaFileObject representing regular files.
  6.1276 +     */
  6.1277 +    private class RegularFileObject extends BaseFileObject {
  6.1278 +        /** Have the parent directories been created?
  6.1279 +         */
  6.1280 +        private boolean hasParents=false;
  6.1281 +
  6.1282 +        /** The file's name.
  6.1283 +         */
  6.1284 +        private String name;
  6.1285 +
  6.1286 +        /** The underlying file.
  6.1287 +         */
  6.1288 +        final File f;
  6.1289 +
  6.1290 +        public RegularFileObject(File f) {
  6.1291 +            this(f.getName(), f);
  6.1292 +        }
  6.1293 +
  6.1294 +        public RegularFileObject(String name, File f) {
  6.1295 +            if (f.isDirectory())
  6.1296 +                throw new IllegalArgumentException("directories not supported");
  6.1297 +            this.name = name;
  6.1298 +            this.f = f;
  6.1299 +        }
  6.1300 +
  6.1301 +        public InputStream openInputStream() throws IOException {
  6.1302 +            return new FileInputStream(f);
  6.1303 +        }
  6.1304 +
  6.1305 +        protected CharsetDecoder getDecoder(boolean ignoreEncodingErrors) {
  6.1306 +            return JavacFileManager.this.getDecoder(getEncodingName(), ignoreEncodingErrors);
  6.1307 +        }
  6.1308 +
  6.1309 +        public OutputStream openOutputStream() throws IOException {
  6.1310 +            ensureParentDirectoriesExist();
  6.1311 +            return new FileOutputStream(f);
  6.1312 +        }
  6.1313 +
  6.1314 +        public Writer openWriter() throws IOException {
  6.1315 +            ensureParentDirectoriesExist();
  6.1316 +            return new OutputStreamWriter(new FileOutputStream(f), getEncodingName());
  6.1317 +        }
  6.1318 +
  6.1319 +        private void ensureParentDirectoriesExist() throws IOException {
  6.1320 +            if (!hasParents) {
  6.1321 +                File parent = f.getParentFile();
  6.1322 +                if (parent != null && !parent.exists()) {
  6.1323 +                    if (!parent.mkdirs()) {
  6.1324 +                        // if the mkdirs failed, it may be because another process concurrently
  6.1325 +                        // created the directory, so check if the directory got created
  6.1326 +                        // anyway before throwing an exception
  6.1327 +                        if (!parent.exists() || !parent.isDirectory())
  6.1328 +                            throw new IOException("could not create parent directories");
  6.1329 +                    }
  6.1330 +                }
  6.1331 +                hasParents = true;
  6.1332 +            }
  6.1333 +        }
  6.1334 +
  6.1335 +        /** @deprecated see bug 6410637 */
  6.1336 +        @Deprecated
  6.1337 +        public String getName() {
  6.1338 +            return name;
  6.1339 +        }
  6.1340 +
  6.1341 +        public boolean isNameCompatible(String cn, JavaFileObject.Kind kind) {
  6.1342 +            cn.getClass(); // null check
  6.1343 +            if (kind == Kind.OTHER && getKind() != kind)
  6.1344 +                return false;
  6.1345 +            String n = cn + kind.extension;
  6.1346 +            if (name.equals(n))
  6.1347 +                return true;
  6.1348 +            if (name.equalsIgnoreCase(n)) {
  6.1349 +                try {
  6.1350 +                    // allow for Windows
  6.1351 +                    return (f.getCanonicalFile().getName().equals(n));
  6.1352 +                } catch (IOException e) {
  6.1353 +                }
  6.1354 +            }
  6.1355 +            return false;
  6.1356 +        }
  6.1357 +
  6.1358 +        /** @deprecated see bug 6410637 */
  6.1359 +        @Deprecated
  6.1360 +        public String getPath() {
  6.1361 +            return f.getPath();
  6.1362 +        }
  6.1363 +
  6.1364 +        public long getLastModified() {
  6.1365 +            return f.lastModified();
  6.1366 +        }
  6.1367 +
  6.1368 +        public boolean delete() {
  6.1369 +            return f.delete();
  6.1370 +        }
  6.1371 +
  6.1372 +        public CharBuffer getCharContent(boolean ignoreEncodingErrors) throws IOException {
  6.1373 +            SoftReference<CharBuffer> r = contentCache.get(this);
  6.1374 +            CharBuffer cb = (r == null ? null : r.get());
  6.1375 +            if (cb == null) {
  6.1376 +                InputStream in = new FileInputStream(f);
  6.1377 +                try {
  6.1378 +                    ByteBuffer bb = makeByteBuffer(in);
  6.1379 +                    JavaFileObject prev = log.useSource(this);
  6.1380 +                    try {
  6.1381 +                        cb = decode(bb, ignoreEncodingErrors);
  6.1382 +                    } finally {
  6.1383 +                        log.useSource(prev);
  6.1384 +                    }
  6.1385 +                    byteBufferCache.put(bb); // save for next time
  6.1386 +                    if (!ignoreEncodingErrors)
  6.1387 +                        contentCache.put(this, new SoftReference<CharBuffer>(cb));
  6.1388 +                } finally {
  6.1389 +                    in.close();
  6.1390 +                }
  6.1391 +            }
  6.1392 +            return cb;
  6.1393 +        }
  6.1394 +
  6.1395 +        @Override
  6.1396 +        public boolean equals(Object other) {
  6.1397 +            if (!(other instanceof RegularFileObject))
  6.1398 +                return false;
  6.1399 +            RegularFileObject o = (RegularFileObject) other;
  6.1400 +            try {
  6.1401 +                return f.equals(o.f)
  6.1402 +                    || f.getCanonicalFile().equals(o.f.getCanonicalFile());
  6.1403 +            } catch (IOException e) {
  6.1404 +                return false;
  6.1405 +            }
  6.1406 +        }
  6.1407 +
  6.1408 +        @Override
  6.1409 +        public int hashCode() {
  6.1410 +            return f.hashCode();
  6.1411 +        }
  6.1412 +
  6.1413 +        public URI toUri() {
  6.1414 +            try {
  6.1415 +                // Do no use File.toURI to avoid file system access
  6.1416 +                String path = f.getAbsolutePath().replace(File.separatorChar, '/');
  6.1417 +                return new URI("file://" + path).normalize();
  6.1418 +            } catch (URISyntaxException ex) {
  6.1419 +                return f.toURI();
  6.1420 +            }
  6.1421 +        }
  6.1422 +
  6.1423 +    }
  6.1424 +
  6.1425 +    /**
  6.1426 +     * A subclass of JavaFileObject representing zip entries.
  6.1427 +     */
  6.1428 +    public class ZipFileObject extends BaseFileObject {
  6.1429 +
  6.1430 +        /** The entry's name.
  6.1431 +         */
  6.1432 +        private String name;
  6.1433 +
  6.1434 +        /** The zipfile containing the entry.
  6.1435 +         */
  6.1436 +        ZipFile zdir;
  6.1437 +
  6.1438 +        /** The underlying zip entry object.
  6.1439 +         */
  6.1440 +        ZipEntry entry;
  6.1441 +
  6.1442 +        public ZipFileObject(String name, ZipFile zdir, ZipEntry entry) {
  6.1443 +            this.name = name;
  6.1444 +            this.zdir = zdir;
  6.1445 +            this.entry = entry;
  6.1446 +        }
  6.1447 +
  6.1448 +        public InputStream openInputStream() throws IOException {
  6.1449 +            return zdir.getInputStream(entry);
  6.1450 +        }
  6.1451 +
  6.1452 +        public OutputStream openOutputStream() throws IOException {
  6.1453 +            throw new UnsupportedOperationException();
  6.1454 +        }
  6.1455 +
  6.1456 +        protected CharsetDecoder getDecoder(boolean ignoreEncodingErrors) {
  6.1457 +            return JavacFileManager.this.getDecoder(getEncodingName(), ignoreEncodingErrors);
  6.1458 +        }
  6.1459 +
  6.1460 +        public Writer openWriter() throws IOException {
  6.1461 +            throw new UnsupportedOperationException();
  6.1462 +        }
  6.1463 +
  6.1464 +        /** @deprecated see bug 6410637 */
  6.1465 +        @Deprecated
  6.1466 +        public String getName() {
  6.1467 +            return name;
  6.1468 +        }
  6.1469 +
  6.1470 +        public boolean isNameCompatible(String cn, JavaFileObject.Kind k) {
  6.1471 +            cn.getClass(); // null check
  6.1472 +            if (k == Kind.OTHER && getKind() != k)
  6.1473 +                return false;
  6.1474 +            return name.equals(cn + k.extension);
  6.1475 +        }
  6.1476 +
  6.1477 +        /** @deprecated see bug 6410637 */
  6.1478 +        @Deprecated
  6.1479 +        public String getPath() {
  6.1480 +            return zdir.getName() + "(" + entry + ")";
  6.1481 +        }
  6.1482 +
  6.1483 +        public long getLastModified() {
  6.1484 +            return entry.getTime();
  6.1485 +        }
  6.1486 +
  6.1487 +        public boolean delete() {
  6.1488 +            throw new UnsupportedOperationException();
  6.1489 +        }
  6.1490 +
  6.1491 +        public CharBuffer getCharContent(boolean ignoreEncodingErrors) throws IOException {
  6.1492 +            SoftReference<CharBuffer> r = contentCache.get(this);
  6.1493 +            CharBuffer cb = (r == null ? null : r.get());
  6.1494 +            if (cb == null) {
  6.1495 +                InputStream in = zdir.getInputStream(entry);
  6.1496 +                try {
  6.1497 +                    ByteBuffer bb = makeByteBuffer(in);
  6.1498 +                    JavaFileObject prev = log.useSource(this);
  6.1499 +                    try {
  6.1500 +                        cb = decode(bb, ignoreEncodingErrors);
  6.1501 +                    } finally {
  6.1502 +                        log.useSource(prev);
  6.1503 +                    }
  6.1504 +                    byteBufferCache.put(bb); // save for next time
  6.1505 +                    if (!ignoreEncodingErrors)
  6.1506 +                        contentCache.put(this, new SoftReference<CharBuffer>(cb));
  6.1507 +                } finally {
  6.1508 +                    in.close();
  6.1509 +                }
  6.1510 +            }
  6.1511 +            return cb;
  6.1512 +        }
  6.1513 +
  6.1514 +        @Override
  6.1515 +        public boolean equals(Object other) {
  6.1516 +            if (!(other instanceof ZipFileObject))
  6.1517 +                return false;
  6.1518 +            ZipFileObject o = (ZipFileObject) other;
  6.1519 +            return zdir.equals(o.zdir) || name.equals(o.name);
  6.1520 +        }
  6.1521 +
  6.1522 +        @Override
  6.1523 +        public int hashCode() {
  6.1524 +            return zdir.hashCode() + name.hashCode();
  6.1525 +        }
  6.1526 +
  6.1527 +        public String getZipName() {
  6.1528 +            return zdir.getName();
  6.1529 +        }
  6.1530 +
  6.1531 +        public String getZipEntryName() {
  6.1532 +            return entry.getName();
  6.1533 +        }
  6.1534 +
  6.1535 +        public URI toUri() {
  6.1536 +            String zipName = new File(getZipName()).toURI().normalize().getPath();
  6.1537 +            String entryName = getZipEntryName();
  6.1538 +            return URI.create("jar:" + zipName + "!" + entryName);
  6.1539 +        }
  6.1540 +
  6.1541 +    }
  6.1542 +
  6.1543 +    /**
  6.1544 +     * A subclass of JavaFileObject representing zip entries using the com.sun.tools.javac.zip.ZipFileIndex implementation.
  6.1545 +     */
  6.1546 +    public class ZipFileIndexFileObject extends BaseFileObject {
  6.1547 +
  6.1548 +            /** The entry's name.
  6.1549 +         */
  6.1550 +        private String name;
  6.1551 +
  6.1552 +        /** The zipfile containing the entry.
  6.1553 +         */
  6.1554 +        ZipFileIndex zfIndex;
  6.1555 +
  6.1556 +        /** The underlying zip entry object.
  6.1557 +         */
  6.1558 +        ZipFileIndexEntry entry;
  6.1559 +
  6.1560 +        /** The InputStream for this zip entry (file.)
  6.1561 +         */
  6.1562 +        InputStream inputStream = null;
  6.1563 +
  6.1564 +        /** The name of the zip file where this entry resides.
  6.1565 +         */
  6.1566 +        String zipName;
  6.1567 +
  6.1568 +        JavacFileManager defFileManager = null;
  6.1569 +
  6.1570 +        public ZipFileIndexFileObject(JavacFileManager fileManager, ZipFileIndex zfIndex, ZipFileIndexEntry entry, String zipFileName) {
  6.1571 +            super();
  6.1572 +            this.name = entry.getFileName();
  6.1573 +            this.zfIndex = zfIndex;
  6.1574 +            this.entry = entry;
  6.1575 +            this.zipName = zipFileName;
  6.1576 +            defFileManager = fileManager;
  6.1577 +        }
  6.1578 +
  6.1579 +        public InputStream openInputStream() throws IOException {
  6.1580 +
  6.1581 +            if (inputStream == null) {
  6.1582 +                inputStream = new ByteArrayInputStream(read());
  6.1583 +            }
  6.1584 +            return inputStream;
  6.1585 +        }
  6.1586 +
  6.1587 +        protected CharsetDecoder getDecoder(boolean ignoreEncodingErrors) {
  6.1588 +            return JavacFileManager.this.getDecoder(getEncodingName(), ignoreEncodingErrors);
  6.1589 +        }
  6.1590 +
  6.1591 +        public OutputStream openOutputStream() throws IOException {
  6.1592 +            throw new UnsupportedOperationException();
  6.1593 +        }
  6.1594 +
  6.1595 +        public Writer openWriter() throws IOException {
  6.1596 +            throw new UnsupportedOperationException();
  6.1597 +        }
  6.1598 +
  6.1599 +        /** @deprecated see bug 6410637 */
  6.1600 +        @Deprecated
  6.1601 +        public String getName() {
  6.1602 +            return name;
  6.1603 +        }
  6.1604 +
  6.1605 +        public boolean isNameCompatible(String cn, JavaFileObject.Kind k) {
  6.1606 +            cn.getClass(); // null check
  6.1607 +            if (k == Kind.OTHER && getKind() != k)
  6.1608 +                return false;
  6.1609 +            return name.equals(cn + k.extension);
  6.1610 +        }
  6.1611 +
  6.1612 +        /** @deprecated see bug 6410637 */
  6.1613 +        @Deprecated
  6.1614 +        public String getPath() {
  6.1615 +            return zipName + "(" + entry.getName() + ")";
  6.1616 +        }
  6.1617 +
  6.1618 +        public long getLastModified() {
  6.1619 +            return entry.getLastModified();
  6.1620 +        }
  6.1621 +
  6.1622 +        public boolean delete() {
  6.1623 +            throw new UnsupportedOperationException();
  6.1624 +        }
  6.1625 +
  6.1626 +        @Override
  6.1627 +        public boolean equals(Object other) {
  6.1628 +            if (!(other instanceof ZipFileIndexFileObject))
  6.1629 +                return false;
  6.1630 +            ZipFileIndexFileObject o = (ZipFileIndexFileObject) other;
  6.1631 +            return entry.equals(o.entry);
  6.1632 +        }
  6.1633 +
  6.1634 +        @Override
  6.1635 +        public int hashCode() {
  6.1636 +            return zipName.hashCode() + (name.hashCode() << 10);
  6.1637 +        }
  6.1638 +
  6.1639 +        public String getZipName() {
  6.1640 +            return zipName;
  6.1641 +        }
  6.1642 +
  6.1643 +        public String getZipEntryName() {
  6.1644 +            return entry.getName();
  6.1645 +        }
  6.1646 +
  6.1647 +        public URI toUri() {
  6.1648 +            String zipName = new File(getZipName()).toURI().normalize().getPath();
  6.1649 +            String entryName = getZipEntryName();
  6.1650 +            if (File.separatorChar != '/') {
  6.1651 +                entryName = entryName.replace(File.separatorChar, '/');
  6.1652 +            }
  6.1653 +            return URI.create("jar:" + zipName + "!" + entryName);
  6.1654 +        }
  6.1655 +
  6.1656 +        private byte[] read() throws IOException {
  6.1657 +            if (entry == null) {
  6.1658 +                entry = zfIndex.getZipIndexEntry(name);
  6.1659 +                if (entry == null)
  6.1660 +                  throw new FileNotFoundException();
  6.1661 +            }
  6.1662 +            return zfIndex.read(entry);
  6.1663 +        }
  6.1664 +
  6.1665 +        public CharBuffer getCharContent(boolean ignoreEncodingErrors) throws IOException {
  6.1666 +            SoftReference<CharBuffer> r = defFileManager.contentCache.get(this);
  6.1667 +            CharBuffer cb = (r == null ? null : r.get());
  6.1668 +            if (cb == null) {
  6.1669 +                InputStream in = new ByteArrayInputStream(zfIndex.read(entry));
  6.1670 +                try {
  6.1671 +                    ByteBuffer bb = makeByteBuffer(in);
  6.1672 +                    JavaFileObject prev = log.useSource(this);
  6.1673 +                    try {
  6.1674 +                        cb = decode(bb, ignoreEncodingErrors);
  6.1675 +                    } finally {
  6.1676 +                        log.useSource(prev);
  6.1677 +                    }
  6.1678 +                    byteBufferCache.put(bb); // save for next time
  6.1679 +                    if (!ignoreEncodingErrors)
  6.1680 +                        defFileManager.contentCache.put(this, new SoftReference<CharBuffer>(cb));
  6.1681 +                } finally {
  6.1682 +                    in.close();
  6.1683 +                }
  6.1684 +            }
  6.1685 +            return cb;
  6.1686 +        }
  6.1687 +    }
  6.1688 +
  6.1689 +    public class ZipFileIndexArchive implements Archive {
  6.1690 +        private final ZipFileIndex zfIndex;
  6.1691 +        private JavacFileManager fileManager;
  6.1692 +
  6.1693 +        public ZipFileIndexArchive(JavacFileManager fileManager, ZipFileIndex zdir) throws IOException {
  6.1694 +            this.fileManager = fileManager;
  6.1695 +            this.zfIndex = zdir;
  6.1696 +        }
  6.1697 +
  6.1698 +        public boolean contains(String name) {
  6.1699 +            return zfIndex.contains(name);
  6.1700 +        }
  6.1701 +
  6.1702 +        public com.sun.tools.javac.util.List<String> getFiles(String subdirectory) {
  6.1703 +              return zfIndex.getFiles(((subdirectory.endsWith("/") || subdirectory.endsWith("\\"))? subdirectory.substring(0, subdirectory.length() - 1) : subdirectory));
  6.1704 +        }
  6.1705 +
  6.1706 +        public JavaFileObject getFileObject(String subdirectory, String file) {
  6.1707 +            String fullZipFileName = subdirectory + file;
  6.1708 +            ZipFileIndexEntry entry = zfIndex.getZipIndexEntry(fullZipFileName);
  6.1709 +            JavaFileObject ret = new ZipFileIndexFileObject(fileManager, zfIndex, entry, zfIndex.getZipFile().getPath());
  6.1710 +            return ret;
  6.1711 +        }
  6.1712 +
  6.1713 +        public Set<String> getSubdirectories() {
  6.1714 +            return zfIndex.getAllDirectories();
  6.1715 +        }
  6.1716 +
  6.1717 +        public void close() throws IOException {
  6.1718 +            zfIndex.close();
  6.1719 +        }
  6.1720 +    }
  6.1721 +}

     7.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     7.2 +++ b/src/share/classes/com/sun/tools/javac/file/Old199.java	Mon Jun 16 13:28:00 2008 -0700
     7.3 @@ -0,0 +1,54 @@
     7.4 +/*
     7.5 + * Copyright 2006 Sun Microsystems, Inc.  All Rights Reserved.
     7.6 + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
     7.7 + *
     7.8 + * This code is free software; you can redistribute it and/or modify it
     7.9 + * under the terms of the GNU General Public License version 2 only, as
    7.10 + * published by the Free Software Foundation.  Sun designates this
    7.11 + * particular file as subject to the "Classpath" exception as provided
    7.12 + * by Sun in the LICENSE file that accompanied this code.
    7.13 + *
    7.14 + * This code is distributed in the hope that it will be useful, but WITHOUT
    7.15 + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
    7.16 + * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
    7.17 + * version 2 for more details (a copy is included in the LICENSE file that
    7.18 + * accompanied this code).
    7.19 + *
    7.20 + * You should have received a copy of the GNU General Public License version
    7.21 + * 2 along with this work; if not, write to the Free Software Foundation,
    7.22 + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
    7.23 + *
    7.24 + * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
    7.25 + * CA 95054 USA or visit www.sun.com if you need additional information or
    7.26 + * have any questions.
    7.27 + */
    7.28 +
    7.29 +package com.sun.tools.javac.file;
    7.30 +
    7.31 +import javax.tools.FileObject;
    7.32 +
    7.33 +/**
    7.34 + * Provides an easy migration to JSR 199 v3.3.  The class is
    7.35 + * deprecated as we should remove it as soon as possible.
    7.36 + *
    7.37 + * <p><b>This is NOT part of any API supported by Sun Microsystems.
    7.38 + * If you write code that depends on this, you do so at your own
    7.39 + * risk.  This code and its internal interfaces are subject to change
    7.40 + * or deletion without notice.</b></p>
    7.41 + *
    7.42 + * @author Peter von der Ah\u00e9
    7.43 + */
    7.44 +@Deprecated
    7.45 +public class Old199 {
    7.46 +
    7.47 +    private Old199() {}
    7.48 +
    7.49 +    public static String getPath(FileObject jfo) {
    7.50 +        return JavacFileManager.getJavacFileName(jfo);
    7.51 +    }
    7.52 +
    7.53 +    public static String getName(FileObject jfo) {
    7.54 +        return JavacFileManager.getJavacBaseFileName(jfo);
    7.55 +    }
    7.56 +
    7.57 +}

     8.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     8.2 +++ b/src/share/classes/com/sun/tools/javac/file/Paths.java	Mon Jun 16 13:28:00 2008 -0700
     8.3 @@ -0,0 +1,577 @@
     8.4 +/*
     8.5 + * Copyright 2003-2006 Sun Microsystems, Inc.  All Rights Reserved.
     8.6 + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
     8.7 + *
     8.8 + * This code is free software; you can redistribute it and/or modify it
     8.9 + * under the terms of the GNU General Public License version 2 only, as
    8.10 + * published by the Free Software Foundation.  Sun designates this
    8.11 + * particular file as subject to the "Classpath" exception as provided
    8.12 + * by Sun in the LICENSE file that accompanied this code.
    8.13 + *
    8.14 + * This code is distributed in the hope that it will be useful, but WITHOUT
    8.15 + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
    8.16 + * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
    8.17 + * version 2 for more details (a copy is included in the LICENSE file that
    8.18 + * accompanied this code).
    8.19 + *
    8.20 + * You should have received a copy of the GNU General Public License version
    8.21 + * 2 along with this work; if not, write to the Free Software Foundation,
    8.22 + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
    8.23 + *
    8.24 + * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
    8.25 + * CA 95054 USA or visit www.sun.com if you need additional information or
    8.26 + * have any questions.
    8.27 + */
    8.28 +
    8.29 +package com.sun.tools.javac.file;
    8.30 +
    8.31 +import java.io.File;
    8.32 +import java.io.IOException;
    8.33 +import java.util.HashMap;
    8.34 +import java.util.HashSet;
    8.35 +import java.util.Map;
    8.36 +import java.util.Set;
    8.37 +import java.util.jar.JarFile;
    8.38 +import java.util.jar.Manifest;
    8.39 +import java.util.jar.Attributes;
    8.40 +import java.util.Collection;
    8.41 +import java.util.Collections;
    8.42 +import java.util.LinkedHashSet;
    8.43 +import java.util.Iterator;
    8.44 +import java.util.StringTokenizer;
    8.45 +import java.util.zip.ZipFile;
    8.46 +import java.util.ArrayList;
    8.47 +import java.util.concurrent.ConcurrentHashMap;
    8.48 +import java.util.concurrent.locks.Lock;
    8.49 +import java.util.concurrent.locks.ReentrantLock;
    8.50 +import javax.tools.JavaFileManager.Location;
    8.51 +
    8.52 +import com.sun.tools.javac.code.Lint;
    8.53 +import com.sun.tools.javac.util.Context;
    8.54 +import com.sun.tools.javac.util.Log;
    8.55 +import com.sun.tools.javac.util.Options;
    8.56 +
    8.57 +import static javax.tools.StandardLocation.*;
    8.58 +import static com.sun.tools.javac.main.OptionName.*;
    8.59 +
    8.60 +/** This class converts command line arguments, environment variables
    8.61 + *  and system properties (in File.pathSeparator-separated String form)
    8.62 + *  into a boot class path, user class path, and source path (in
    8.63 + *  Collection<String> form).
    8.64 + *
    8.65 + *  <p><b>This is NOT part of any API supported by Sun Microsystems.  If
    8.66 + *  you write code that depends on this, you do so at your own risk.
    8.67 + *  This code and its internal interfaces are subject to change or
    8.68 + *  deletion without notice.</b>
    8.69 + */
    8.70 +public class Paths {
    8.71 +
    8.72 +    /** The context key for the todo list */
    8.73 +    protected static final Context.Key<Paths> pathsKey =
    8.74 +        new Context.Key<Paths>();
    8.75 +
    8.76 +    /** Get the Paths instance for this context.
    8.77 +     *  @param context the context
    8.78 +     *  @return the Paths instance for this context
    8.79 +     */
    8.80 +    public static Paths instance(Context context) {
    8.81 +        Paths instance = context.get(pathsKey);
    8.82 +        if (instance == null)
    8.83 +            instance = new Paths(context);
    8.84 +        return instance;
    8.85 +    }
    8.86 +
    8.87 +    /** The log to use for warning output */
    8.88 +    private Log log;
    8.89 +
    8.90 +    /** Collection of command-line options */
    8.91 +    private Options options;
    8.92 +
    8.93 +    /** Handler for -Xlint options */
    8.94 +    private Lint lint;
    8.95 +
    8.96 +    private static boolean NON_BATCH_MODE = System.getProperty("nonBatchMode") != null;// TODO: Use -XD compiler switch for this.
    8.97 +    private static Map<File, PathEntry> pathExistanceCache = new ConcurrentHashMap<File, PathEntry>();
    8.98 +    private static Map<File, java.util.List<File>> manifestEntries = new ConcurrentHashMap<File, java.util.List<File>>();
    8.99 +    private static Map<File, Boolean> isDirectory = new ConcurrentHashMap<File, Boolean>();
   8.100 +    private static Lock lock = new ReentrantLock();
   8.101 +
   8.102 +    public static void clearPathExistanceCache() {
   8.103 +            pathExistanceCache.clear();
   8.104 +    }
   8.105 +
   8.106 +    static class PathEntry {
   8.107 +        boolean exists = false;
   8.108 +        boolean isFile = false;
   8.109 +        File cannonicalPath = null;
   8.110 +    }
   8.111 +
   8.112 +    protected Paths(Context context) {
   8.113 +        context.put(pathsKey, this);
   8.114 +        pathsForLocation = new HashMap<Location,Path>(16);
   8.115 +        setContext(context);
   8.116 +    }
   8.117 +
   8.118 +    void setContext(Context context) {
   8.119 +        log = Log.instance(context);
   8.120 +        options = Options.instance(context);
   8.121 +        lint = Lint.instance(context);
   8.122 +    }
   8.123 +
   8.124 +    /** Whether to warn about non-existent path elements */
   8.125 +    private boolean warn;
   8.126 +
   8.127 +    private Map<Location, Path> pathsForLocation;
   8.128 +
   8.129 +    private boolean inited = false; // TODO? caching bad?
   8.130 +
   8.131 +    /**
   8.132 +     * rt.jar as found on the default bootclass path.  If the user specified a
   8.133 +     * bootclasspath, null is used.
   8.134 +     */
   8.135 +    private File bootClassPathRtJar = null;
   8.136 +
   8.137 +    Path getPathForLocation(Location location) {
   8.138 +        Path path = pathsForLocation.get(location);
   8.139 +        if (path == null)
   8.140 +            setPathForLocation(location, null);
   8.141 +        return pathsForLocation.get(location);
   8.142 +    }
   8.143 +
   8.144 +    void setPathForLocation(Location location, Iterable<? extends File> path) {
   8.145 +        // TODO? if (inited) throw new IllegalStateException
   8.146 +        // TODO: otherwise reset sourceSearchPath, classSearchPath as needed
   8.147 +        Path p;
   8.148 +        if (path == null) {
   8.149 +            if (location == CLASS_PATH)
   8.150 +                p = computeUserClassPath();
   8.151 +            else if (location == PLATFORM_CLASS_PATH)
   8.152 +                p = computeBootClassPath();
   8.153 +            else if (location == ANNOTATION_PROCESSOR_PATH)
   8.154 +                p = computeAnnotationProcessorPath();
   8.155 +            else if (location == SOURCE_PATH)
   8.156 +                p = computeSourcePath();
   8.157 +            else
   8.158 +                // no defaults for other paths
   8.159 +                p = null;
   8.160 +        } else {
   8.161 +            p = new Path();
   8.162 +            for (File f: path)
   8.163 +                p.addFile(f, warn); // TODO: is use of warn appropriate?
   8.164 +        }
   8.165 +        pathsForLocation.put(location, p);
   8.166 +    }
   8.167 +
   8.168 +    protected void lazy() {
   8.169 +        if (!inited) {
   8.170 +            warn = lint.isEnabled(Lint.LintCategory.PATH);
   8.171 +
   8.172 +            pathsForLocation.put(PLATFORM_CLASS_PATH, computeBootClassPath());
   8.173 +            pathsForLocation.put(CLASS_PATH, computeUserClassPath());
   8.174 +            pathsForLocation.put(SOURCE_PATH, computeSourcePath());
   8.175 +
   8.176 +            inited = true;
   8.177 +        }
   8.178 +    }
   8.179 +
   8.180 +    public Collection<File> bootClassPath() {
   8.181 +        lazy();
   8.182 +        return Collections.unmodifiableCollection(getPathForLocation(PLATFORM_CLASS_PATH));
   8.183 +    }
   8.184 +    public Collection<File> userClassPath() {
   8.185 +        lazy();
   8.186 +        return Collections.unmodifiableCollection(getPathForLocation(CLASS_PATH));
   8.187 +    }
   8.188 +    public Collection<File> sourcePath() {
   8.189 +        lazy();
   8.190 +        Path p = getPathForLocation(SOURCE_PATH);
   8.191 +        return p == null || p.size() == 0
   8.192 +            ? null
   8.193 +            : Collections.unmodifiableCollection(p);
   8.194 +    }
   8.195 +
   8.196 +    boolean isBootClassPathRtJar(File file) {
   8.197 +        return file.equals(bootClassPathRtJar);
   8.198 +    }
   8.199 +
   8.200 +    private static class PathIterator implements Iterable<String> {
   8.201 +        private int pos = 0;
   8.202 +        private final String path;
   8.203 +        private final String emptyPathDefault;
   8.204 +
   8.205 +        public PathIterator(String path, String emptyPathDefault) {
   8.206 +            this.path = path;
   8.207 +            this.emptyPathDefault = emptyPathDefault;
   8.208 +        }
   8.209 +        public PathIterator(String path) { this(path, null); }
   8.210 +        public Iterator<String> iterator() {
   8.211 +            return new Iterator<String>() {
   8.212 +                public boolean hasNext() {
   8.213 +                    return pos <= path.length();
   8.214 +                }
   8.215 +                public String next() {
   8.216 +                    int beg = pos;
   8.217 +                    int end = path.indexOf(File.pathSeparator, beg);
   8.218 +                    if (end == -1)
   8.219 +                        end = path.length();
   8.220 +                    pos = end + 1;
   8.221 +
   8.222 +                    if (beg == end && emptyPathDefault != null)
   8.223 +                        return emptyPathDefault;
   8.224 +                    else
   8.225 +                        return path.substring(beg, end);
   8.226 +                }
   8.227 +                public void remove() {
   8.228 +                    throw new UnsupportedOperationException();
   8.229 +                }
   8.230 +            };
   8.231 +        }
   8.232 +    }
   8.233 +
   8.234 +    private class Path extends LinkedHashSet<File> {
   8.235 +        private static final long serialVersionUID = 0;
   8.236 +
   8.237 +        private boolean expandJarClassPaths = false;
   8.238 +        private Set<File> canonicalValues = new HashSet<File>();
   8.239 +
   8.240 +        public Path expandJarClassPaths(boolean x) {
   8.241 +            expandJarClassPaths = x;
   8.242 +            return this;
   8.243 +        }
   8.244 +
   8.245 +        /** What to use when path element is the empty string */
   8.246 +        private String emptyPathDefault = null;
   8.247 +
   8.248 +        public Path emptyPathDefault(String x) {
   8.249 +            emptyPathDefault = x;
   8.250 +            return this;
   8.251 +        }
   8.252 +
   8.253 +        public Path() { super(); }
   8.254 +
   8.255 +        public Path addDirectories(String dirs, boolean warn) {
   8.256 +            if (dirs != null)
   8.257 +                for (String dir : new PathIterator(dirs))
   8.258 +                    addDirectory(dir, warn);
   8.259 +            return this;
   8.260 +        }
   8.261 +
   8.262 +        public Path addDirectories(String dirs) {
   8.263 +            return addDirectories(dirs, warn);
   8.264 +        }
   8.265 +
   8.266 +        private void addDirectory(String dir, boolean warn) {
   8.267 +            if (! new File(dir).isDirectory()) {
   8.268 +                if (warn)
   8.269 +                    log.warning("dir.path.element.not.found", dir);
   8.270 +                return;
   8.271 +            }
   8.272 +
   8.273 +            File[] files = new File(dir).listFiles();
   8.274 +            if (files == null)
   8.275 +                return;
   8.276 +
   8.277 +            for (File direntry : files) {
   8.278 +                if (isArchive(direntry))
   8.279 +                    addFile(direntry, warn);
   8.280 +            }
   8.281 +        }
   8.282 +
   8.283 +        public Path addFiles(String files, boolean warn) {
   8.284 +            if (files != null)
   8.285 +                for (String file : new PathIterator(files, emptyPathDefault))
   8.286 +                    addFile(file, warn);
   8.287 +            return this;
   8.288 +        }
   8.289 +
   8.290 +        public Path addFiles(String files) {
   8.291 +            return addFiles(files, warn);
   8.292 +        }
   8.293 +
   8.294 +        public Path addFile(String file, boolean warn) {
   8.295 +            addFile(new File(file), warn);
   8.296 +            return this;
   8.297 +        }
   8.298 +
   8.299 +        public void addFile(File file, boolean warn) {
   8.300 +            boolean foundInCache = false;
   8.301 +            PathEntry pe = null;
   8.302 +            if (!NON_BATCH_MODE) {
   8.303 +                    pe = pathExistanceCache.get(file);
   8.304 +                    if (pe != null) {
   8.305 +                        foundInCache = true;
   8.306 +                    }
   8.307 +                    else {
   8.308 +                        pe = new PathEntry();
   8.309 +                    }
   8.310 +            }
   8.311 +            else {
   8.312 +                pe = new PathEntry();
   8.313 +            }
   8.314 +
   8.315 +            File canonFile;
   8.316 +            try {
   8.317 +                if (!foundInCache) {
   8.318 +                    pe.cannonicalPath = file.getCanonicalFile();
   8.319 +                }
   8.320 +                else {
   8.321 +                   canonFile = pe.cannonicalPath;
   8.322 +                }
   8.323 +            } catch (IOException e) {
   8.324 +                pe.cannonicalPath = canonFile = file;
   8.325 +            }
   8.326 +
   8.327 +            if (contains(file) || canonicalValues.contains(pe.cannonicalPath)) {
   8.328 +                /* Discard duplicates and avoid infinite recursion */
   8.329 +                return;
   8.330 +            }
   8.331 +
   8.332 +            if (!foundInCache) {
   8.333 +                pe.exists = file.exists();
   8.334 +                pe.isFile = file.isFile();
   8.335 +                if (!NON_BATCH_MODE) {
   8.336 +                    pathExistanceCache.put(file, pe);
   8.337 +                }
   8.338 +            }
   8.339 +
   8.340 +            if (! pe.exists) {
   8.341 +                /* No such file or directory exists */
   8.342 +                if (warn)
   8.343 +                    log.warning("path.element.not.found", file);
   8.344 +            } else if (pe.isFile) {
   8.345 +                /* File is an ordinary file. */
   8.346 +                if (!isArchive(file)) {
   8.347 +                    /* Not a recognized extension; open it to see if
   8.348 +                     it looks like a valid zip file. */
   8.349 +                    try {
   8.350 +                        ZipFile z = new ZipFile(file);
   8.351 +                        z.close();
   8.352 +                        if (warn)
   8.353 +                            log.warning("unexpected.archive.file", file);
   8.354 +                    } catch (IOException e) {
   8.355 +                        // FIXME: include e.getLocalizedMessage in warning
   8.356 +                        if (warn)
   8.357 +                            log.warning("invalid.archive.file", file);
   8.358 +                        return;
   8.359 +                    }
   8.360 +                }
   8.361 +            }
   8.362 +
   8.363 +            /* Now what we have left is either a directory or a file name
   8.364 +               confirming to archive naming convention */
   8.365 +            super.add(file);
   8.366 +            canonicalValues.add(pe.cannonicalPath);
   8.367 +
   8.368 +            if (expandJarClassPaths && file.exists() && file.isFile())
   8.369 +                addJarClassPath(file, warn);
   8.370 +        }
   8.371 +
   8.372 +        // Adds referenced classpath elements from a jar's Class-Path
   8.373 +        // Manifest entry.  In some future release, we may want to
   8.374 +        // update this code to recognize URLs rather than simple
   8.375 +        // filenames, but if we do, we should redo all path-related code.
   8.376 +        private void addJarClassPath(File jarFile, boolean warn) {
   8.377 +            try {
   8.378 +                java.util.List<File> manifestsList = manifestEntries.get(jarFile);
   8.379 +                if (!NON_BATCH_MODE) {
   8.380 +                    lock.lock();
   8.381 +                    try {
   8.382 +                        if (manifestsList != null) {
   8.383 +                            for (File entr : manifestsList) {
   8.384 +                                addFile(entr, warn);
   8.385 +                            }
   8.386 +                            return;
   8.387 +                        }
   8.388 +                    }
   8.389 +                    finally {
   8.390 +                        lock.unlock();
   8.391 +                    }
   8.392 +                }
   8.393 +
   8.394 +                if (!NON_BATCH_MODE) {
   8.395 +                    manifestsList = new ArrayList<File>();
   8.396 +                    manifestEntries.put(jarFile, manifestsList);
   8.397 +                }
   8.398 +
   8.399 +                String jarParent = jarFile.getParent();
   8.400 +                JarFile jar = new JarFile(jarFile);
   8.401 +
   8.402 +                try {
   8.403 +                    Manifest man = jar.getManifest();
   8.404 +                    if (man == null) return;
   8.405 +
   8.406 +                    Attributes attr = man.getMainAttributes();
   8.407 +                    if (attr == null) return;
   8.408 +
   8.409 +                    String path = attr.getValue(Attributes.Name.CLASS_PATH);
   8.410 +                    if (path == null) return;
   8.411 +
   8.412 +                    for (StringTokenizer st = new StringTokenizer(path);
   8.413 +                         st.hasMoreTokens();) {
   8.414 +                        String elt = st.nextToken();
   8.415 +                        File f = (jarParent == null ? new File(elt) : new File(jarParent, elt));
   8.416 +                        addFile(f, warn);
   8.417 +
   8.418 +                        if (!NON_BATCH_MODE) {
   8.419 +                            lock.lock();
   8.420 +                            try {
   8.421 +                                manifestsList.add(f);
   8.422 +                            }
   8.423 +                            finally {
   8.424 +                                lock.unlock();
   8.425 +                            }
   8.426 +                        }
   8.427 +                    }
   8.428 +                } finally {
   8.429 +                    jar.close();
   8.430 +                }
   8.431 +            } catch (IOException e) {
   8.432 +                log.error("error.reading.file", jarFile, e.getLocalizedMessage());
   8.433 +            }
   8.434 +        }
   8.435 +    }
   8.436 +
   8.437 +    private Path computeBootClassPath() {
   8.438 +        bootClassPathRtJar = null;
   8.439 +        String optionValue;
   8.440 +        Path path = new Path();
   8.441 +
   8.442 +        path.addFiles(options.get(XBOOTCLASSPATH_PREPEND));
   8.443 +
   8.444 +        if ((optionValue = options.get(ENDORSEDDIRS)) != null)
   8.445 +            path.addDirectories(optionValue);
   8.446 +        else
   8.447 +            path.addDirectories(System.getProperty("java.endorsed.dirs"), false);
   8.448 +
   8.449 +        if ((optionValue = options.get(BOOTCLASSPATH)) != null) {
   8.450 +            path.addFiles(optionValue);
   8.451 +        } else {
   8.452 +            // Standard system classes for this compiler's release.
   8.453 +            String files = System.getProperty("sun.boot.class.path");
   8.454 +            path.addFiles(files, false);
   8.455 +            File rt_jar = new File("rt.jar");
   8.456 +            for (String file : new PathIterator(files, null)) {
   8.457 +                File f = new File(file);
   8.458 +                if (new File(f.getName()).equals(rt_jar))
   8.459 +                    bootClassPathRtJar = f;
   8.460 +            }
   8.461 +        }
   8.462 +
   8.463 +        path.addFiles(options.get(XBOOTCLASSPATH_APPEND));
   8.464 +
   8.465 +        // Strictly speaking, standard extensions are not bootstrap
   8.466 +        // classes, but we treat them identically, so we'll pretend
   8.467 +        // that they are.
   8.468 +        if ((optionValue = options.get(EXTDIRS)) != null)
   8.469 +            path.addDirectories(optionValue);
   8.470 +        else
   8.471 +            path.addDirectories(System.getProperty("java.ext.dirs"), false);
   8.472 +
   8.473 +        return path;
   8.474 +    }
   8.475 +
   8.476 +    private Path computeUserClassPath() {
   8.477 +        String cp = options.get(CLASSPATH);
   8.478 +
   8.479 +        // CLASSPATH environment variable when run from `javac'.
   8.480 +        if (cp == null) cp = System.getProperty("env.class.path");
   8.481 +
   8.482 +        // If invoked via a java VM (not the javac launcher), use the
   8.483 +        // platform class path
   8.484 +        if (cp == null && System.getProperty("application.home") == null)
   8.485 +            cp = System.getProperty("java.class.path");
   8.486 +
   8.487 +        // Default to current working directory.
   8.488 +        if (cp == null) cp = ".";
   8.489 +
   8.490 +        return new Path()
   8.491 +            .expandJarClassPaths(true) // Only search user jars for Class-Paths
   8.492 +            .emptyPathDefault(".")     // Empty path elt ==> current directory
   8.493 +            .addFiles(cp);
   8.494 +    }
   8.495 +
   8.496 +    private Path computeSourcePath() {
   8.497 +        String sourcePathArg = options.get(SOURCEPATH);
   8.498 +        if (sourcePathArg == null)
   8.499 +            return null;
   8.500 +
   8.501 +        return new Path().addFiles(sourcePathArg);
   8.502 +    }
   8.503 +
   8.504 +    private Path computeAnnotationProcessorPath() {
   8.505 +        String processorPathArg = options.get(PROCESSORPATH);
   8.506 +        if (processorPathArg == null)
   8.507 +            return null;
   8.508 +
   8.509 +        return new Path().addFiles(processorPathArg);
   8.510 +    }
   8.511 +
   8.512 +    /** The actual effective locations searched for sources */
   8.513 +    private Path sourceSearchPath;
   8.514 +
   8.515 +    public Collection<File> sourceSearchPath() {
   8.516 +        if (sourceSearchPath == null) {
   8.517 +            lazy();
   8.518 +            Path sourcePath = getPathForLocation(SOURCE_PATH);
   8.519 +            Path userClassPath = getPathForLocation(CLASS_PATH);
   8.520 +            sourceSearchPath = sourcePath != null ? sourcePath : userClassPath;
   8.521 +        }
   8.522 +        return Collections.unmodifiableCollection(sourceSearchPath);
   8.523 +    }
   8.524 +
   8.525 +    /** The actual effective locations searched for classes */
   8.526 +    private Path classSearchPath;
   8.527 +
   8.528 +    public Collection<File> classSearchPath() {
   8.529 +        if (classSearchPath == null) {
   8.530 +            lazy();
   8.531 +            Path bootClassPath = getPathForLocation(PLATFORM_CLASS_PATH);
   8.532 +            Path userClassPath = getPathForLocation(CLASS_PATH);
   8.533 +            classSearchPath = new Path();
   8.534 +            classSearchPath.addAll(bootClassPath);
   8.535 +            classSearchPath.addAll(userClassPath);
   8.536 +        }
   8.537 +        return Collections.unmodifiableCollection(classSearchPath);
   8.538 +    }
   8.539 +
   8.540 +    /** The actual effective locations for non-source, non-class files */
   8.541 +    private Path otherSearchPath;
   8.542 +
   8.543 +    Collection<File> otherSearchPath() {
   8.544 +        if (otherSearchPath == null) {
   8.545 +            lazy();
   8.546 +            Path userClassPath = getPathForLocation(CLASS_PATH);
   8.547 +            Path sourcePath = getPathForLocation(SOURCE_PATH);
   8.548 +            if (sourcePath == null)
   8.549 +                otherSearchPath = userClassPath;
   8.550 +            else {
   8.551 +                otherSearchPath = new Path();
   8.552 +                otherSearchPath.addAll(userClassPath);
   8.553 +                otherSearchPath.addAll(sourcePath);
   8.554 +            }
   8.555 +        }
   8.556 +        return Collections.unmodifiableCollection(otherSearchPath);
   8.557 +    }
   8.558 +
   8.559 +    /** Is this the name of an archive file? */
   8.560 +    private static boolean isArchive(File file) {
   8.561 +        String n = file.getName().toLowerCase();
   8.562 +        boolean isFile = false;
   8.563 +        if (!NON_BATCH_MODE) {
   8.564 +            Boolean isf = isDirectory.get(file);
   8.565 +            if (isf == null) {
   8.566 +                isFile = file.isFile();
   8.567 +                isDirectory.put(file, isFile);
   8.568 +            }
   8.569 +            else {
   8.570 +                isFile = isf;
   8.571 +            }
   8.572 +        }
   8.573 +        else {
   8.574 +            isFile = file.isFile();
   8.575 +        }
   8.576 +
   8.577 +        return isFile
   8.578 +            && (n.endsWith(".jar") || n.endsWith(".zip"));
   8.579 +    }
   8.580 +}

     9.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     9.2 +++ b/src/share/classes/com/sun/tools/javac/file/ZipFileIndex.java	Mon Jun 16 13:28:00 2008 -0700
     9.3 @@ -0,0 +1,1248 @@
     9.4 +/*
     9.5 + * Copyright 2007-2008 Sun Microsystems, Inc.  All Rights Reserved.
     9.6 + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
     9.7 + *
     9.8 + * This code is free software; you can redistribute it and/or modify it
     9.9 + * under the terms of the GNU General Public License version 2 only, as
    9.10 + * published by the Free Software Foundation.  Sun designates this
    9.11 + * particular file as subject to the "Classpath" exception as provided
    9.12 + * by Sun in the LICENSE file that accompanied this code.
    9.13 + *
    9.14 + * This code is distributed in the hope that it will be useful, but WITHOUT
    9.15 + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
    9.16 + * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
    9.17 + * version 2 for more details (a copy is included in the LICENSE file that
    9.18 + * accompanied this code).
    9.19 + *
    9.20 + * You should have received a copy of the GNU General Public License version
    9.21 + * 2 along with this work; if not, write to the Free Software Foundation,
    9.22 + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
    9.23 + *
    9.24 + * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
    9.25 + * CA 95054 USA or visit www.sun.com if you need additional information or
    9.26 + * have any questions.
    9.27 + */
    9.28 +
    9.29 +package com.sun.tools.javac.file;
    9.30 +
    9.31 +import java.io.File;
    9.32 +import java.io.FileNotFoundException;
    9.33 +import java.io.IOException;
    9.34 +import java.io.RandomAccessFile;
    9.35 +import java.text.MessageFormat;
    9.36 +import java.util.ArrayList;
    9.37 +import java.util.Arrays;
    9.38 +import java.util.Collections;
    9.39 +import java.util.HashMap;
    9.40 +import java.util.HashSet;
    9.41 +import java.util.Iterator;
    9.42 +import java.util.List;
    9.43 +import java.util.Map;
    9.44 +import java.util.Set;
    9.45 +import java.util.concurrent.locks.ReentrantLock;
    9.46 +import java.util.zip.DataFormatException;
    9.47 +import java.util.zip.Inflater;
    9.48 +import java.util.zip.ZipException;
    9.49 +
    9.50 +/** This class implements building of index of a zip archive and access to it's context.
    9.51 + *  It also uses prebuild index if available. It supports invocations where it will
    9.52 + *  serialize an optimized zip index file to disk.
    9.53 + *
    9.54 + *  In oreder to use secondary index file make sure the option "usezipindex" is in the Options object,
    9.55 + *  when JavacFileManager is invoked. (You can pass "-XDusezipindex" on the command line.
    9.56 + *
    9.57 + *  Location where to look for/generate optimized zip index files can be provided using
    9.58 + *  "-XDcachezipindexdir=<directory>". If this flag is not provided, the dfault location is
    9.59 + *  the value of the "java.io.tmpdir" system property.
    9.60 + *
    9.61 + *  If key "-XDwritezipindexfiles" is specified, there will be new optimized index file
    9.62 + *  created for each archive, used by the compiler for compilation, at location,
    9.63 + *  specified by "cachezipindexdir" option.
    9.64 + *
    9.65 + * If nonBatchMode option is specified (-XDnonBatchMode) the compiler will use timestamp
    9.66 + * checking to reindex the zip files if it is needed. In batch mode the timestamps are not checked
    9.67 + * and the compiler uses the cached indexes.
    9.68 + */
    9.69 +public class ZipFileIndex {
    9.70 +    private static final String MIN_CHAR = String.valueOf(Character.MIN_VALUE);
    9.71 +    private static final String MAX_CHAR = String.valueOf(Character.MAX_VALUE);
    9.72 +
    9.73 +    public final static long NOT_MODIFIED = Long.MIN_VALUE;
    9.74 +
    9.75 +    private static Map<File, ZipFileIndex> zipFileIndexCache = new HashMap<File, ZipFileIndex>();
    9.76 +    private static ReentrantLock lock = new ReentrantLock();
    9.77 +
    9.78 +    private static boolean NON_BATCH_MODE = System.getProperty("nonBatchMode") != null;// TODO: Use -XD compiler switch for this.
    9.79 +
    9.80 +    private Map<String, DirectoryEntry> directories = Collections.<String, DirectoryEntry>emptyMap();
    9.81 +    private Set<String> allDirs = Collections.<String>emptySet();
    9.82 +
    9.83 +    // ZipFileIndex data entries
    9.84 +    private File zipFile;
    9.85 +    private long zipFileLastModified = NOT_MODIFIED;
    9.86 +    private RandomAccessFile zipRandomFile;
    9.87 +    private ZipFileIndexEntry[] entries;
    9.88 +
    9.89 +    private boolean readFromIndex = false;
    9.90 +    private File zipIndexFile = null;
    9.91 +    private boolean triedToReadIndex = false;
    9.92 +    private int symbolFilePrefixLength = 0;
    9.93 +    private boolean hasPopulatedData = false;
    9.94 +    private long lastReferenceTimeStamp = NOT_MODIFIED;
    9.95 +
    9.96 +    private boolean usePreindexedCache = false;
    9.97 +    private String preindexedCacheLocation = null;
    9.98 +
    9.99 +    private boolean writeIndex = false;
   9.100 +
   9.101 +    /**
   9.102 +     * Returns a list of all ZipFileIndex entries
   9.103 +     *
   9.104 +     * @return A list of ZipFileIndex entries, or an empty list
   9.105 +     */
   9.106 +    public static List<ZipFileIndex> getZipFileIndexes() {
   9.107 +        return getZipFileIndexes(false);
   9.108 +    }
   9.109 +
   9.110 +    /**
   9.111 +     * Returns a list of all ZipFileIndex entries
   9.112 +     *
   9.113 +     * @param openedOnly If true it returns a list of only opened ZipFileIndex entries, otherwise
   9.114 +     *                   all ZipFileEntry(s) are included into the list.
   9.115 +     * @return A list of ZipFileIndex entries, or an empty list
   9.116 +     */
   9.117 +    public static List<ZipFileIndex> getZipFileIndexes(boolean openedOnly) {
   9.118 +        List<ZipFileIndex> zipFileIndexes = new ArrayList<ZipFileIndex>();
   9.119 +        lock.lock();
   9.120 +        try {
   9.121 +            zipFileIndexes.addAll(zipFileIndexCache.values());
   9.122 +
   9.123 +            if (openedOnly) {
   9.124 +                for(ZipFileIndex elem : zipFileIndexes) {
   9.125 +                    if (!elem.isOpen()) {
   9.126 +                        zipFileIndexes.remove(elem);
   9.127 +                    }
   9.128 +                }
   9.129 +            }
   9.130 +        }
   9.131 +        finally {
   9.132 +            lock.unlock();
   9.133 +        }
   9.134 +        return zipFileIndexes;
   9.135 +    }
   9.136 +
   9.137 +    public boolean isOpen() {
   9.138 +        lock.lock();
   9.139 +        try {
   9.140 +            return zipRandomFile != null;
   9.141 +        }
   9.142 +        finally {
   9.143 +            lock.unlock();
   9.144 +        }
   9.145 +    }
   9.146 +
   9.147 +    public static ZipFileIndex getZipFileIndex(File zipFile, int symbolFilePrefixLen, boolean useCache, String cacheLocation, boolean writeIndex) throws IOException {
   9.148 +        ZipFileIndex zi = null;
   9.149 +        lock.lock();
   9.150 +        try {
   9.151 +            zi = getExistingZipIndex(zipFile);
   9.152 +
   9.153 +            if (zi == null || (zi != null && zipFile.lastModified() != zi.zipFileLastModified)) {
   9.154 +                zi = new ZipFileIndex(zipFile, symbolFilePrefixLen, writeIndex,
   9.155 +                        useCache, cacheLocation);
   9.156 +                zipFileIndexCache.put(zipFile, zi);
   9.157 +            }
   9.158 +        }
   9.159 +        finally {
   9.160 +            lock.unlock();
   9.161 +        }
   9.162 +        return zi;
   9.163 +    }
   9.164 +
   9.165 +    public static ZipFileIndex getExistingZipIndex(File zipFile) {
   9.166 +        lock.lock();
   9.167 +        try {
   9.168 +            return zipFileIndexCache.get(zipFile);
   9.169 +        }
   9.170 +        finally {
   9.171 +            lock.unlock();
   9.172 +        }
   9.173 +    }
   9.174 +
   9.175 +    public static void clearCache() {
   9.176 +        lock.lock();
   9.177 +        try {
   9.178 +            zipFileIndexCache.clear();
   9.179 +        }
   9.180 +        finally {
   9.181 +            lock.unlock();
   9.182 +        }
   9.183 +    }
   9.184 +
   9.185 +    public static void clearCache(long timeNotUsed) {
   9.186 +        lock.lock();
   9.187 +        try {
   9.188 +            Iterator<File> cachedFileIterator = zipFileIndexCache.keySet().iterator();
   9.189 +            while (cachedFileIterator.hasNext()) {
   9.190 +                File cachedFile = cachedFileIterator.next();
   9.191 +                ZipFileIndex cachedZipIndex = zipFileIndexCache.get(cachedFile);
   9.192 +                if (cachedZipIndex != null) {
   9.193 +                    long timeToTest = cachedZipIndex.lastReferenceTimeStamp + timeNotUsed;
   9.194 +                    if (timeToTest < cachedZipIndex.lastReferenceTimeStamp || // Overflow...
   9.195 +                            System.currentTimeMillis() > timeToTest) {
   9.196 +                        zipFileIndexCache.remove(cachedFile);
   9.197 +                    }
   9.198 +                }
   9.199 +            }
   9.200 +        }
   9.201 +        finally {
   9.202 +            lock.unlock();
   9.203 +        }
   9.204 +    }
   9.205 +
   9.206 +    public static void removeFromCache(File file) {
   9.207 +        lock.lock();
   9.208 +        try {
   9.209 +            zipFileIndexCache.remove(file);
   9.210 +        }
   9.211 +        finally {
   9.212 +            lock.unlock();
   9.213 +        }
   9.214 +    }
   9.215 +
   9.216 +    /** Sets already opened list of ZipFileIndexes from an outside client
   9.217 +      * of the compiler. This functionality should be used in a non-batch clients of the compiler.
   9.218 +      */
   9.219 +    public static void setOpenedIndexes(List<ZipFileIndex>indexes) throws IllegalStateException {
   9.220 +        lock.lock();
   9.221 +        try {
   9.222 +            if (zipFileIndexCache.isEmpty()) {
   9.223 +                throw new IllegalStateException("Setting opened indexes should be called only when the ZipFileCache is empty. Call JavacFileManager.flush() before calling this method.");
   9.224 +            }
   9.225 +
   9.226 +            for (ZipFileIndex zfi : indexes) {
   9.227 +                zipFileIndexCache.put(zfi.zipFile, zfi);
   9.228 +            }
   9.229 +        }
   9.230 +        finally {
   9.231 +            lock.unlock();
   9.232 +        }
   9.233 +    }
   9.234 +
   9.235 +    private ZipFileIndex(File zipFile, int symbolFilePrefixLen, boolean writeIndex,
   9.236 +            boolean useCache, String cacheLocation) throws IOException {
   9.237 +        this.zipFile = zipFile;
   9.238 +        this.symbolFilePrefixLength = symbolFilePrefixLen;
   9.239 +        this.writeIndex = writeIndex;
   9.240 +        this.usePreindexedCache = useCache;
   9.241 +        this.preindexedCacheLocation = cacheLocation;
   9.242 +
   9.243 +        if (zipFile != null) {
   9.244 +            this.zipFileLastModified = zipFile.lastModified();
   9.245 +        }
   9.246 +
   9.247 +        // Validate integrity of the zip file
   9.248 +        checkIndex();
   9.249 +    }
   9.250 +
   9.251 +    public String toString() {
   9.252 +        return "ZipFileIndex of file:(" + zipFile + ")";
   9.253 +    }
   9.254 +
   9.255 +    // Just in case...
   9.256 +    protected void finalize() {
   9.257 +        closeFile();
   9.258 +    }
   9.259 +
   9.260 +    private boolean isUpToDate() {
   9.261 +        if (zipFile != null &&
   9.262 +                ((!NON_BATCH_MODE) || zipFileLastModified == zipFile.lastModified()) &&
   9.263 +                hasPopulatedData) {
   9.264 +            return true;
   9.265 +        }
   9.266 +
   9.267 +        return false;
   9.268 +    }
   9.269 +
   9.270 +    /**
   9.271 +     * Here we need to make sure that the ZipFileIndex is valid. Check the timestamp of the file and
   9.272 +     * if its the same as the one at the time the index was build we don't need to reopen anything.
   9.273 +     */
   9.274 +    private void checkIndex() throws IOException {
   9.275 +        boolean isUpToDate = true;
   9.276 +        if (!isUpToDate()) {
   9.277 +            closeFile();
   9.278 +            isUpToDate = false;
   9.279 +        }
   9.280 +
   9.281 +        if (zipRandomFile != null || isUpToDate) {
   9.282 +            lastReferenceTimeStamp = System.currentTimeMillis();
   9.283 +            return;
   9.284 +        }
   9.285 +
   9.286 +        hasPopulatedData = true;
   9.287 +
   9.288 +        if (readIndex()) {
   9.289 +            lastReferenceTimeStamp = System.currentTimeMillis();
   9.290 +            return;
   9.291 +        }
   9.292 +
   9.293 +        directories = Collections.<String, DirectoryEntry>emptyMap();
   9.294 +        allDirs = Collections.<String>emptySet();
   9.295 +
   9.296 +        try {
   9.297 +            openFile();
   9.298 +            long totalLength = zipRandomFile.length();
   9.299 +            ZipDirectory directory = new ZipDirectory(zipRandomFile, 0L, totalLength, this);
   9.300 +            directory.buildIndex();
   9.301 +        } finally {
   9.302 +            if (zipRandomFile != null) {
   9.303 +                closeFile();
   9.304 +            }
   9.305 +        }
   9.306 +
   9.307 +        lastReferenceTimeStamp = System.currentTimeMillis();
   9.308 +    }
   9.309 +
   9.310 +    private void openFile() throws FileNotFoundException {
   9.311 +        if (zipRandomFile == null && zipFile != null) {
   9.312 +            zipRandomFile = new RandomAccessFile(zipFile, "r");
   9.313 +        }
   9.314 +    }
   9.315 +
   9.316 +    private void cleanupState() {
   9.317 +        // Make sure there is a valid but empty index if the file doesn't exist
   9.318 +        entries = ZipFileIndexEntry.EMPTY_ARRAY;
   9.319 +        directories = Collections.<String, DirectoryEntry>emptyMap();
   9.320 +        zipFileLastModified = NOT_MODIFIED;
   9.321 +        allDirs = Collections.<String>emptySet();
   9.322 +    }
   9.323 +
   9.324 +    public void close() {
   9.325 +        lock.lock();
   9.326 +        try {
   9.327 +            writeIndex();
   9.328 +            closeFile();
   9.329 +        }
   9.330 +        finally {
   9.331 +            lock.unlock();
   9.332 +        }
   9.333 +    }
   9.334 +
   9.335 +    private void closeFile() {
   9.336 +        if (zipRandomFile != null) {
   9.337 +            try {
   9.338 +                zipRandomFile.close();
   9.339 +            } catch (IOException ex) {
   9.340 +            }
   9.341 +            zipRandomFile = null;
   9.342 +        }
   9.343 +    }
   9.344 +
   9.345 +    /**
   9.346 +     * Returns the ZipFileIndexEntry for an absolute path, if there is one.
   9.347 +     */
   9.348 +    public ZipFileIndexEntry getZipIndexEntry(String path) {
   9.349 +        if (File.separatorChar != '/') {
   9.350 +            path = path.replace('/', File.separatorChar);
   9.351 +        }
   9.352 +        lock.lock();
   9.353 +        try {
   9.354 +            checkIndex();
   9.355 +            String lookFor = "";
   9.356 +            int lastSepIndex = path.lastIndexOf(File.separatorChar);
   9.357 +            boolean noSeparator = false;
   9.358 +            if (lastSepIndex == -1) {
   9.359 +                noSeparator = true;
   9.360 +            }
   9.361 +
   9.362 +            DirectoryEntry de = directories.get(noSeparator ? "" : path.substring(0, lastSepIndex));
   9.363 +
   9.364 +            lookFor = path.substring(noSeparator ? 0 : lastSepIndex + 1);
   9.365 +
   9.366 +            return de == null ? null : de.getEntry(lookFor);
   9.367 +        }
   9.368 +        catch (IOException e) {
   9.369 +            return null;
   9.370 +        }
   9.371 +        finally {
   9.372 +            lock.unlock();
   9.373 +        }
   9.374 +    }
   9.375 +
   9.376 +    /**
   9.377 +     * Returns a javac List of filenames within an absolute path in the ZipFileIndex.
   9.378 +     */
   9.379 +    public com.sun.tools.javac.util.List<String> getFiles(String path) {
   9.380 +        if (File.separatorChar != '/') {
   9.381 +            path = path.replace('/', File.separatorChar);
   9.382 +        }
   9.383 +
   9.384 +        lock.lock();
   9.385 +        try {
   9.386 +            checkIndex();
   9.387 +
   9.388 +            DirectoryEntry de = directories.get(path);
   9.389 +            com.sun.tools.javac.util.List<String> ret = de == null ? null : de.getFiles();
   9.390 +
   9.391 +            if (ret == null) {
   9.392 +                return com.sun.tools.javac.util.List.<String>nil();
   9.393 +            }
   9.394 +            return ret;
   9.395 +        }
   9.396 +        catch (IOException e) {
   9.397 +            return com.sun.tools.javac.util.List.<String>nil();
   9.398 +        }
   9.399 +        finally {
   9.400 +            lock.unlock();
   9.401 +        }
   9.402 +    }
   9.403 +
   9.404 +    public List<String> getAllDirectories(String path) {
   9.405 +
   9.406 +        if (File.separatorChar != '/') {
   9.407 +            path = path.replace('/', File.separatorChar);
   9.408 +        }
   9.409 +
   9.410 +        lock.lock();
   9.411 +        try {
   9.412 +            checkIndex();
   9.413 +            path = path.intern();
   9.414 +
   9.415 +            DirectoryEntry de = directories.get(path);
   9.416 +            com.sun.tools.javac.util.List<String> ret = de == null ? null : de.getDirectories();
   9.417 +
   9.418 +            if (ret == null) {
   9.419 +                return com.sun.tools.javac.util.List.<String>nil();
   9.420 +            }
   9.421 +
   9.422 +            return ret;
   9.423 +        }
   9.424 +        catch (IOException e) {
   9.425 +            return com.sun.tools.javac.util.List.<String>nil();
   9.426 +        }
   9.427 +        finally {
   9.428 +            lock.unlock();
   9.429 +        }
   9.430 +    }
   9.431 +
   9.432 +    public Set<String> getAllDirectories() {
   9.433 +        lock.lock();
   9.434 +        try {
   9.435 +            checkIndex();
   9.436 +            if (allDirs == Collections.EMPTY_SET) {
   9.437 +                Set<String> alldirs = new HashSet<String>();
   9.438 +                Iterator<String> dirsIter = directories.keySet().iterator();
   9.439 +                while (dirsIter.hasNext()) {
   9.440 +                    alldirs.add(new String(dirsIter.next()));
   9.441 +                }
   9.442 +
   9.443 +                allDirs = alldirs;
   9.444 +            }
   9.445 +
   9.446 +            return allDirs;
   9.447 +        }
   9.448 +        catch (IOException e) {
   9.449 +            return Collections.<String>emptySet();
   9.450 +        }
   9.451 +        finally {
   9.452 +            lock.unlock();
   9.453 +        }
   9.454 +    }
   9.455 +
   9.456 +    /**
   9.457 +     * Tests if a specific path exists in the zip.  This method will return true
   9.458 +     * for file entries and directories.
   9.459 +     *
   9.460 +     * @param path A path within the zip.
   9.461 +     * @return True if the path is a file or dir, false otherwise.
   9.462 +     */
   9.463 +    public boolean contains(String path) {
   9.464 +        lock.lock();
   9.465 +        try {
   9.466 +            checkIndex();
   9.467 +            return getZipIndexEntry(path) != null;
   9.468 +        }
   9.469 +        catch (IOException e) {
   9.470 +            return false;
   9.471 +        }
   9.472 +        finally {
   9.473 +            lock.unlock();
   9.474 +        }
   9.475 +    }
   9.476 +
   9.477 +    public boolean isDirectory(String path) throws IOException {
   9.478 +        lock.lock();
   9.479 +        try {
   9.480 +            // The top level in a zip file is always a directory.
   9.481 +            if (path.length() == 0) {
   9.482 +                lastReferenceTimeStamp = System.currentTimeMillis();
   9.483 +                return true;
   9.484 +            }
   9.485 +
   9.486 +            if (File.separatorChar != '/')
   9.487 +                path = path.replace('/', File.separatorChar);
   9.488 +            checkIndex();
   9.489 +            return directories.get(path) != null;
   9.490 +        }
   9.491 +        finally {
   9.492 +            lock.unlock();
   9.493 +        }
   9.494 +    }
   9.495 +
   9.496 +    public long getLastModified(String path) throws IOException {
   9.497 +        lock.lock();
   9.498 +        try {
   9.499 +            ZipFileIndexEntry entry = getZipIndexEntry(path);
   9.500 +            if (entry == null)
   9.501 +                throw new FileNotFoundException();
   9.502 +            return entry.getLastModified();
   9.503 +        }
   9.504 +        finally {
   9.505 +            lock.unlock();
   9.506 +        }
   9.507 +    }
   9.508 +
   9.509 +    public int length(String path) throws IOException {
   9.510 +        lock.lock();
   9.511 +        try {
   9.512 +            ZipFileIndexEntry entry = getZipIndexEntry(path);
   9.513 +            if (entry == null)
   9.514 +                throw new FileNotFoundException();
   9.515 +
   9.516 +            if (entry.isDir) {
   9.517 +                return 0;
   9.518 +            }
   9.519 +
   9.520 +            byte[] header = getHeader(entry);
   9.521 +            // entry is not compressed?
   9.522 +            if (get2ByteLittleEndian(header, 8) == 0) {
   9.523 +                return entry.compressedSize;
   9.524 +            } else {
   9.525 +                return entry.size;
   9.526 +            }
   9.527 +        }
   9.528 +        finally {
   9.529 +            lock.unlock();
   9.530 +        }
   9.531 +    }
   9.532 +
   9.533 +    public byte[] read(String path) throws IOException {
   9.534 +        lock.lock();
   9.535 +        try {
   9.536 +            ZipFileIndexEntry entry = getZipIndexEntry(path);
   9.537 +            if (entry == null)
   9.538 +                throw new FileNotFoundException(MessageFormat.format("Path not found in ZIP: {0}", path));
   9.539 +            return read(entry);
   9.540 +        }
   9.541 +        finally {
   9.542 +            lock.unlock();
   9.543 +        }
   9.544 +    }
   9.545 +
   9.546 +    public byte[] read(ZipFileIndexEntry entry) throws IOException {
   9.547 +        lock.lock();
   9.548 +        try {
   9.549 +            openFile();
   9.550 +            byte[] result = readBytes(entry);
   9.551 +            closeFile();
   9.552 +            return result;
   9.553 +        }
   9.554 +        finally {
   9.555 +            lock.unlock();
   9.556 +        }
   9.557 +    }
   9.558 +
   9.559 +    public int read(String path, byte[] buffer) throws IOException {
   9.560 +        lock.lock();
   9.561 +        try {
   9.562 +            ZipFileIndexEntry entry = getZipIndexEntry(path);
   9.563 +            if (entry == null)
   9.564 +                throw new FileNotFoundException();
   9.565 +            return read(entry, buffer);
   9.566 +        }
   9.567 +        finally {
   9.568 +            lock.unlock();
   9.569 +        }
   9.570 +    }
   9.571 +
   9.572 +    public int read(ZipFileIndexEntry entry, byte[] buffer)
   9.573 +            throws IOException {
   9.574 +        lock.lock();
   9.575 +        try {
   9.576 +            int result = readBytes(entry, buffer);
   9.577 +            return result;
   9.578 +        }
   9.579 +        finally {
   9.580 +            lock.unlock();
   9.581 +        }
   9.582 +    }
   9.583 +
   9.584 +    private byte[] readBytes(ZipFileIndexEntry entry) throws IOException {
   9.585 +        byte[] header = getHeader(entry);
   9.586 +        int csize = entry.compressedSize;
   9.587 +        byte[] cbuf = new byte[csize];
   9.588 +        zipRandomFile.skipBytes(get2ByteLittleEndian(header, 26) + get2ByteLittleEndian(header, 28));
   9.589 +        zipRandomFile.readFully(cbuf, 0, csize);
   9.590 +
   9.591 +        // is this compressed - offset 8 in the ZipEntry header
   9.592 +        if (get2ByteLittleEndian(header, 8) == 0)
   9.593 +            return cbuf;
   9.594 +
   9.595 +        int size = entry.size;
   9.596 +        byte[] buf = new byte[size];
   9.597 +        if (inflate(cbuf, buf) != size)
   9.598 +            throw new ZipException("corrupted zip file");
   9.599 +
   9.600 +        return buf;
   9.601 +    }
   9.602 +
   9.603 +    /**
   9.604 +     *
   9.605 +     */
   9.606 +    private int readBytes(ZipFileIndexEntry entry, byte[] buffer) throws IOException {
   9.607 +        byte[] header = getHeader(entry);
   9.608 +
   9.609 +        // entry is not compressed?
   9.610 +        if (get2ByteLittleEndian(header, 8) == 0) {
   9.611 +            zipRandomFile.skipBytes(get2ByteLittleEndian(header, 26) + get2ByteLittleEndian(header, 28));
   9.612 +            int offset = 0;
   9.613 +            int size = buffer.length;
   9.614 +            while (offset < size) {
   9.615 +                int count = zipRandomFile.read(buffer, offset, size - offset);
   9.616 +                if (count == -1)
   9.617 +                    break;
   9.618 +                offset += count;
   9.619 +            }
   9.620 +            return entry.size;
   9.621 +        }
   9.622 +
   9.623 +        int csize = entry.compressedSize;
   9.624 +        byte[] cbuf = new byte[csize];
   9.625 +        zipRandomFile.skipBytes(get2ByteLittleEndian(header, 26) + get2ByteLittleEndian(header, 28));
   9.626 +        zipRandomFile.readFully(cbuf, 0, csize);
   9.627 +
   9.628 +        int count = inflate(cbuf, buffer);
   9.629 +        if (count == -1)
   9.630 +            throw new ZipException("corrupted zip file");
   9.631 +
   9.632 +        return entry.size;
   9.633 +    }
   9.634 +
   9.635 +    //----------------------------------------------------------------------------
   9.636 +    // Zip utilities
   9.637 +    //----------------------------------------------------------------------------
   9.638 +
   9.639 +    private byte[] getHeader(ZipFileIndexEntry entry) throws IOException {
   9.640 +        zipRandomFile.seek(entry.offset);
   9.641 +        byte[] header = new byte[30];
   9.642 +        zipRandomFile.readFully(header);
   9.643 +        if (get4ByteLittleEndian(header, 0) != 0x04034b50)
   9.644 +            throw new ZipException("corrupted zip file");
   9.645 +        if ((get2ByteLittleEndian(header, 6) & 1) != 0)
   9.646 +            throw new ZipException("encrypted zip file"); // offset 6 in the header of the ZipFileEntry
   9.647 +        return header;
   9.648 +    }
   9.649 +
   9.650 +  /*
   9.651 +   * Inflate using the java.util.zip.Inflater class
   9.652 +   */
   9.653 +    private static Inflater inflater;
   9.654 +    private int inflate(byte[] src, byte[] dest) {
   9.655 +
   9.656 +        // construct the inflater object or reuse an existing one
   9.657 +        if (inflater == null)
   9.658 +            inflater = new Inflater(true);
   9.659 +
   9.660 +        synchronized (inflater) {
   9.661 +            inflater.reset();
   9.662 +            inflater.setInput(src);
   9.663 +            try {
   9.664 +                return inflater.inflate(dest);
   9.665 +            } catch (DataFormatException ex) {
   9.666 +                return -1;
   9.667 +            }
   9.668 +        }
   9.669 +    }
   9.670 +
   9.671 +    /**
   9.672 +     * return the two bytes buf[pos], buf[pos+1] as an unsigned integer in little
   9.673 +     * endian format.
   9.674 +     */
   9.675 +    private static int get2ByteLittleEndian(byte[] buf, int pos) {
   9.676 +        return (buf[pos] & 0xFF) + ((buf[pos+1] & 0xFF) << 8);
   9.677 +    }
   9.678 +
   9.679 +    /**
   9.680 +     * return the 4 bytes buf[i..i+3] as an integer in little endian format.
   9.681 +     */
   9.682 +    private static int get4ByteLittleEndian(byte[] buf, int pos) {
   9.683 +        return (buf[pos] & 0xFF) + ((buf[pos + 1] & 0xFF) << 8) +
   9.684 +                ((buf[pos + 2] & 0xFF) << 16) + ((buf[pos + 3] & 0xFF) << 24);
   9.685 +    }
   9.686 +
   9.687 +    /* ----------------------------------------------------------------------------
   9.688 +     * ZipDirectory
   9.689 +     * ----------------------------------------------------------------------------*/
   9.690 +
   9.691 +    private class ZipDirectory {
   9.692 +        private String lastDir;
   9.693 +        private int lastStart;
   9.694 +        private int lastLen;
   9.695 +
   9.696 +        byte[] zipDir;
   9.697 +        RandomAccessFile zipRandomFile = null;
   9.698 +        ZipFileIndex zipFileIndex = null;
   9.699 +
   9.700 +        public ZipDirectory(RandomAccessFile zipRandomFile, long start, long end, ZipFileIndex index) throws IOException {
   9.701 +            this.zipRandomFile = zipRandomFile;
   9.702 +            this.zipFileIndex = index;
   9.703 +
   9.704 +            findCENRecord(start, end);
   9.705 +        }
   9.706 +
   9.707 +        /*
   9.708 +         * Reads zip file central directory.
   9.709 +         * For more details see readCEN in zip_util.c from the JDK sources.
   9.710 +         * This is a Java port of that function.
   9.711 +         */
   9.712 +        private void findCENRecord(long start, long end) throws IOException {
   9.713 +            long totalLength = end - start;
   9.714 +            int endbuflen = 1024;
   9.715 +            byte[] endbuf = new byte[endbuflen];
   9.716 +            long endbufend = end - start;
   9.717 +
   9.718 +            // There is a variable-length field after the dir offset record. We need to do consequential search.
   9.719 +            while (endbufend >= 22) {
   9.720 +                if (endbufend < endbuflen)
   9.721 +                    endbuflen = (int)endbufend;
   9.722 +                long endbufpos = endbufend - endbuflen;
   9.723 +                zipRandomFile.seek(start + endbufpos);
   9.724 +                zipRandomFile.readFully(endbuf, 0, endbuflen);
   9.725 +                int i = endbuflen - 22;
   9.726 +                while (i >= 0 &&
   9.727 +                        !(endbuf[i] == 0x50 &&
   9.728 +                        endbuf[i + 1] == 0x4b &&
   9.729 +                        endbuf[i + 2] == 0x05 &&
   9.730 +                        endbuf[i + 3] == 0x06 &&
   9.731 +                        endbufpos + i + 22 +
   9.732 +                        get2ByteLittleEndian(endbuf, i + 20) == totalLength)) {
   9.733 +                    i--;
   9.734 +                }
   9.735 +
   9.736 +                if (i >= 0) {
   9.737 +                    zipDir = new byte[get4ByteLittleEndian(endbuf, i + 12) + 2];
   9.738 +                    zipDir[0] = endbuf[i + 10];
   9.739 +                    zipDir[1] = endbuf[i + 11];
   9.740 +                    zipRandomFile.seek(start + get4ByteLittleEndian(endbuf, i + 16));
   9.741 +                    zipRandomFile.readFully(zipDir, 2, zipDir.length - 2);
   9.742 +                    return;
   9.743 +                } else {
   9.744 +                    endbufend = endbufpos + 21;
   9.745 +                }
   9.746 +            }
   9.747 +            throw new ZipException("cannot read zip file");
   9.748 +        }
   9.749 +        private void buildIndex() throws IOException {
   9.750 +            int entryCount = get2ByteLittleEndian(zipDir, 0);
   9.751 +
   9.752 +            entries = new ZipFileIndexEntry[entryCount];
   9.753 +            // Add each of the files
   9.754 +            if (entryCount > 0) {
   9.755 +                directories = new HashMap<String, DirectoryEntry>();
   9.756 +                ArrayList<ZipFileIndexEntry> entryList = new ArrayList<ZipFileIndexEntry>();
   9.757 +                int pos = 2;
   9.758 +                for (int i = 0; i < entryCount; i++) {
   9.759 +                    pos = readEntry(pos, entryList, directories);
   9.760 +                }
   9.761 +
   9.762 +                // Add the accumulated dirs into the same list
   9.763 +                Iterator i = directories.keySet().iterator();
   9.764 +                while (i.hasNext()) {
   9.765 +                    ZipFileIndexEntry zipFileIndexEntry = new ZipFileIndexEntry( (String) i.next());
   9.766 +                    zipFileIndexEntry.isDir = true;
   9.767 +                    entryList.add(zipFileIndexEntry);
   9.768 +                }
   9.769 +
   9.770 +                entries = entryList.toArray(new ZipFileIndexEntry[entryList.size()]);
   9.771 +                Arrays.sort(entries);
   9.772 +            } else {
   9.773 +                cleanupState();
   9.774 +            }
   9.775 +        }
   9.776 +
   9.777 +        private int readEntry(int pos, List<ZipFileIndexEntry> entryList,
   9.778 +                Map<String, DirectoryEntry> directories) throws IOException {
   9.779 +            if (get4ByteLittleEndian(zipDir, pos) != 0x02014b50) {
   9.780 +                throw new ZipException("cannot read zip file entry");
   9.781 +            }
   9.782 +
   9.783 +            int dirStart = pos + 46;
   9.784 +            int fileStart = dirStart;
   9.785 +            int fileEnd = fileStart + get2ByteLittleEndian(zipDir, pos + 28);
   9.786 +
   9.787 +            if (zipFileIndex.symbolFilePrefixLength != 0 &&
   9.788 +                    ((fileEnd - fileStart) >= symbolFilePrefixLength)) {
   9.789 +                dirStart += zipFileIndex.symbolFilePrefixLength;
   9.790 +               fileStart += zipFileIndex.symbolFilePrefixLength;
   9.791 +            }
   9.792 +
   9.793 +            // Use the OS's path separator. Keep the position of the last one.
   9.794 +            for (int index = fileStart; index < fileEnd; index++) {
   9.795 +                byte nextByte = zipDir[index];
   9.796 +                if (nextByte == (byte)'\\' || nextByte == (byte)'/') {
   9.797 +                    zipDir[index] = (byte)File.separatorChar;
   9.798 +                    fileStart = index + 1;
   9.799 +                }
   9.800 +            }
   9.801 +
   9.802 +            String directory = null;
   9.803 +            if (fileStart == dirStart)
   9.804 +                directory = "";
   9.805 +            else if (lastDir != null && lastLen == fileStart - dirStart - 1) {
   9.806 +                int index = lastLen - 1;
   9.807 +                while (zipDir[lastStart + index] == zipDir[dirStart + index]) {
   9.808 +                    if (index == 0) {
   9.809 +                        directory = lastDir;
   9.810 +                        break;
   9.811 +                    }
   9.812 +                    index--;
   9.813 +                }
   9.814 +            }
   9.815 +
   9.816 +            // Sub directories
   9.817 +            if (directory == null) {
   9.818 +                lastStart = dirStart;
   9.819 +                lastLen = fileStart - dirStart - 1;
   9.820 +
   9.821 +                directory = new String(zipDir, dirStart, lastLen, "UTF-8").intern();
   9.822 +                lastDir = directory;
   9.823 +
   9.824 +                // Enter also all the parent directories
   9.825 +                String tempDirectory = directory;
   9.826 +
   9.827 +                while (directories.get(tempDirectory) == null) {
   9.828 +                    directories.put(tempDirectory, new DirectoryEntry(tempDirectory, zipFileIndex));
   9.829 +                    int separator = tempDirectory.lastIndexOf(File.separatorChar);
   9.830 +                    if (separator == -1)
   9.831 +                        break;
   9.832 +                    tempDirectory = tempDirectory.substring(0, separator);
   9.833 +                }
   9.834 +            }
   9.835 +            else {
   9.836 +                directory = directory.intern();
   9.837 +                if (directories.get(directory) == null) {
   9.838 +                    directories.put(directory, new DirectoryEntry(directory, zipFileIndex));
   9.839 +                }
   9.840 +            }
   9.841 +
   9.842 +            // For each dir create also a file
   9.843 +            if (fileStart != fileEnd) {
   9.844 +                ZipFileIndexEntry entry = new ZipFileIndexEntry(directory,
   9.845 +                        new String(zipDir, fileStart, fileEnd - fileStart, "UTF-8"));
   9.846 +
   9.847 +                entry.setNativeTime(get4ByteLittleEndian(zipDir, pos + 12));
   9.848 +                entry.compressedSize = get4ByteLittleEndian(zipDir, pos + 20);
   9.849 +                entry.size = get4ByteLittleEndian(zipDir, pos + 24);
   9.850 +                entry.offset = get4ByteLittleEndian(zipDir, pos + 42);
   9.851 +                entryList.add(entry);
   9.852 +            }
   9.853 +
   9.854 +            return pos + 46 +
   9.855 +                    get2ByteLittleEndian(zipDir, pos + 28) +
   9.856 +                    get2ByteLittleEndian(zipDir, pos + 30) +
   9.857 +                    get2ByteLittleEndian(zipDir, pos + 32);
   9.858 +        }
   9.859 +    }
   9.860 +
   9.861 +    /**
   9.862 +     * Returns the last modified timestamp of a zip file.
   9.863 +     * @return long
   9.864 +     */
   9.865 +    public long getZipFileLastModified() throws IOException {
   9.866 +        lock.lock();
   9.867 +        try {
   9.868 +            checkIndex();
   9.869 +            return zipFileLastModified;
   9.870 +        }
   9.871 +        finally {
   9.872 +            lock.unlock();
   9.873 +        }
   9.874 +    }
   9.875 +
   9.876 +    /** ------------------------------------------------------------------------
   9.877 +     *  DirectoryEntry class
   9.878 +     * -------------------------------------------------------------------------*/
   9.879 +    static class DirectoryEntry {
   9.880 +        private boolean filesInited;
   9.881 +        private boolean directoriesInited;
   9.882 +        private boolean zipFileEntriesInited;
   9.883 +        private boolean entriesInited;
   9.884 +
   9.885 +        private long writtenOffsetOffset = 0;
   9.886 +
   9.887 +        private String dirName;
   9.888 +
   9.889 +        private com.sun.tools.javac.util.List<String> zipFileEntriesFiles = com.sun.tools.javac.util.List.<String>nil();
   9.890 +        private com.sun.tools.javac.util.List<String> zipFileEntriesDirectories = com.sun.tools.javac.util.List.<String>nil();
   9.891 +        private com.sun.tools.javac.util.List<ZipFileIndexEntry>  zipFileEntries = com.sun.tools.javac.util.List.<ZipFileIndexEntry>nil();
   9.892 +
   9.893 +        private List<ZipFileIndexEntry> entries = new ArrayList<ZipFileIndexEntry>();
   9.894 +
   9.895 +        private ZipFileIndex zipFileIndex;
   9.896 +
   9.897 +        private int numEntries;
   9.898 +
   9.899 +        DirectoryEntry(String dirName, ZipFileIndex index) {
   9.900 +        filesInited = false;
   9.901 +            directoriesInited = false;
   9.902 +            entriesInited = false;
   9.903 +
   9.904 +            if (File.separatorChar == '/') {
   9.905 +                dirName.replace('\\', '/');
   9.906 +            }
   9.907 +            else {
   9.908 +                dirName.replace('/', '\\');
   9.909 +            }
   9.910 +
   9.911 +            this.dirName = dirName.intern();
   9.912 +            this.zipFileIndex = index;
   9.913 +        }
   9.914 +
   9.915 +        private com.sun.tools.javac.util.List<String> getFiles() {
   9.916 +            if (filesInited) {
   9.917 +                return zipFileEntriesFiles;
   9.918 +            }
   9.919 +
   9.920 +            initEntries();
   9.921 +
   9.922 +            for (ZipFileIndexEntry e : entries) {
   9.923 +                if (!e.isDir) {
   9.924 +                    zipFileEntriesFiles = zipFileEntriesFiles.append(e.name);
   9.925 +                }
   9.926 +            }
   9.927 +            filesInited = true;
   9.928 +            return zipFileEntriesFiles;
   9.929 +        }
   9.930 +
   9.931 +        private com.sun.tools.javac.util.List<String> getDirectories() {
   9.932 +            if (directoriesInited) {
   9.933 +                return zipFileEntriesFiles;
   9.934 +            }
   9.935 +
   9.936 +            initEntries();
   9.937 +
   9.938 +            for (ZipFileIndexEntry e : entries) {
   9.939 +                if (e.isDir) {
   9.940 +                    zipFileEntriesDirectories = zipFileEntriesDirectories.append(e.name);
   9.941 +                }
   9.942 +            }
   9.943 +
   9.944 +            directoriesInited = true;
   9.945 +
   9.946 +            return zipFileEntriesDirectories;
   9.947 +        }
   9.948 +
   9.949 +        private com.sun.tools.javac.util.List<ZipFileIndexEntry> getEntries() {
   9.950 +            if (zipFileEntriesInited) {
   9.951 +                return zipFileEntries;
   9.952 +            }
   9.953 +
   9.954 +            initEntries();
   9.955 +
   9.956 +            zipFileEntries = com.sun.tools.javac.util.List.nil();
   9.957 +            for (ZipFileIndexEntry zfie : entries) {
   9.958 +                zipFileEntries = zipFileEntries.append(zfie);
   9.959 +            }
   9.960 +
   9.961 +            zipFileEntriesInited = true;
   9.962 +
   9.963 +            return zipFileEntries;
   9.964 +        }
   9.965 +
   9.966 +        private ZipFileIndexEntry getEntry(String rootName) {
   9.967 +            initEntries();
   9.968 +            int index = Collections.binarySearch(entries, new ZipFileIndexEntry(dirName, rootName));
   9.969 +            if (index < 0) {
   9.970 +                return null;
   9.971 +            }
   9.972 +
   9.973 +            return entries.get(index);
   9.974 +        }
   9.975 +
   9.976 +        private void initEntries() {
   9.977 +            if (entriesInited) {
   9.978 +                return;
   9.979 +            }
   9.980 +
   9.981 +            if (!zipFileIndex.readFromIndex) {
   9.982 +                int from = -Arrays.binarySearch(zipFileIndex.entries,
   9.983 +                        new ZipFileIndexEntry(dirName, ZipFileIndex.MIN_CHAR)) - 1;
   9.984 +                int to = -Arrays.binarySearch(zipFileIndex.entries,
   9.985 +                        new ZipFileIndexEntry(dirName, MAX_CHAR)) - 1;
   9.986 +
   9.987 +                boolean emptyList = false;
   9.988 +
   9.989 +                for (int i = from; i < to; i++) {
   9.990 +                    entries.add(zipFileIndex.entries[i]);
   9.991 +                }
   9.992 +            } else {
   9.993 +                File indexFile = zipFileIndex.getIndexFile();
   9.994 +                if (indexFile != null) {
   9.995 +                    RandomAccessFile raf = null;
   9.996 +                    try {
   9.997 +                        raf = new RandomAccessFile(indexFile, "r");
   9.998 +                        raf.seek(writtenOffsetOffset);
   9.999 +
  9.1000 +                        for (int nFiles = 0; nFiles < numEntries; nFiles++) {
  9.1001 +                            // Read the name bytes
  9.1002 +                            int zfieNameBytesLen = raf.readInt();
  9.1003 +                            byte [] zfieNameBytes = new byte[zfieNameBytesLen];
  9.1004 +                            raf.read(zfieNameBytes);
  9.1005 +                            String eName = new String(zfieNameBytes, "UTF-8");
  9.1006 +
  9.1007 +                            // Read isDir
  9.1008 +                            boolean eIsDir = raf.readByte() == (byte)0 ? false : true;
  9.1009 +
  9.1010 +                            // Read offset of bytes in the real Jar/Zip file
  9.1011 +                            int eOffset = raf.readInt();
  9.1012 +
  9.1013 +                            // Read size of the file in the real Jar/Zip file
  9.1014 +                            int eSize = raf.readInt();
  9.1015 +
  9.1016 +                            // Read compressed size of the file in the real Jar/Zip file
  9.1017 +                            int eCsize = raf.readInt();
  9.1018 +
  9.1019 +                            // Read java time stamp of the file in the real Jar/Zip file
  9.1020 +                            long eJavaTimestamp = raf.readLong();
  9.1021 +
  9.1022 +                            ZipFileIndexEntry rfie = new ZipFileIndexEntry(dirName, eName);
  9.1023 +                            rfie.isDir = eIsDir;
  9.1024 +                            rfie.offset = eOffset;
  9.1025 +                            rfie.size = eSize;
  9.1026 +                            rfie.compressedSize = eCsize;
  9.1027 +                            rfie.javatime = eJavaTimestamp;
  9.1028 +                            entries.add(rfie);
  9.1029 +                        }
  9.1030 +                    } catch (Throwable t) {
  9.1031 +                        // Do nothing
  9.1032 +                    } finally {
  9.1033 +                        try {
  9.1034 +                            if (raf == null) {
  9.1035 +                                raf.close();
  9.1036 +                            }
  9.1037 +                        } catch (Throwable t) {
  9.1038 +                            // Do nothing
  9.1039 +                        }
  9.1040 +                    }
  9.1041 +                }
  9.1042 +            }
  9.1043 +
  9.1044 +            entriesInited = true;
  9.1045 +        }
  9.1046 +
  9.1047 +        List<ZipFileIndexEntry> getEntriesAsCollection() {
  9.1048 +            initEntries();
  9.1049 +
  9.1050 +            return entries;
  9.1051 +        }
  9.1052 +    }
  9.1053 +
  9.1054 +    private boolean readIndex() {
  9.1055 +        if (triedToReadIndex || !usePreindexedCache) {
  9.1056 +            return false;
  9.1057 +        }
  9.1058 +
  9.1059 +        boolean ret = false;
  9.1060 +        lock.lock();
  9.1061 +        try {
  9.1062 +            triedToReadIndex = true;
  9.1063 +            RandomAccessFile raf = null;
  9.1064 +            try {
  9.1065 +                File indexFileName = getIndexFile();
  9.1066 +                raf = new RandomAccessFile(indexFileName, "r");
  9.1067 +
  9.1068 +                long fileStamp = raf.readLong();
  9.1069 +                if (zipFile.lastModified() != fileStamp) {
  9.1070 +                    ret = false;
  9.1071 +                } else {
  9.1072 +                    directories = new HashMap<String, DirectoryEntry>();
  9.1073 +                    int numDirs = raf.readInt();
  9.1074 +                    for (int nDirs = 0; nDirs < numDirs; nDirs++) {
  9.1075 +                        int dirNameBytesLen = raf.readInt();
  9.1076 +                        byte [] dirNameBytes = new byte[dirNameBytesLen];
  9.1077 +                        raf.read(dirNameBytes);
  9.1078 +
  9.1079 +                        String dirNameStr = new String(dirNameBytes, "UTF-8");
  9.1080 +                        DirectoryEntry de = new DirectoryEntry(dirNameStr, this);
  9.1081 +                        de.numEntries = raf.readInt();
  9.1082 +                        de.writtenOffsetOffset = raf.readLong();
  9.1083 +                        directories.put(dirNameStr, de);
  9.1084 +                    }
  9.1085 +                    ret = true;
  9.1086 +                    zipFileLastModified = fileStamp;
  9.1087 +                }
  9.1088 +            } catch (Throwable t) {
  9.1089 +                // Do nothing
  9.1090 +            } finally {
  9.1091 +                if (raf != null) {
  9.1092 +                    try {
  9.1093 +                        raf.close();
  9.1094 +                    } catch (Throwable tt) {
  9.1095 +                        // Do nothing
  9.1096 +                    }
  9.1097 +                }
  9.1098 +            }
  9.1099 +            if (ret == true) {
  9.1100 +                readFromIndex = true;
  9.1101 +            }
  9.1102 +        }
  9.1103 +        finally {
  9.1104 +            lock.unlock();
  9.1105 +        }
  9.1106 +
  9.1107 +        return ret;
  9.1108 +    }
  9.1109 +
  9.1110 +    private boolean writeIndex() {
  9.1111 +        boolean ret = false;
  9.1112 +        if (readFromIndex || !usePreindexedCache) {
  9.1113 +            return true;
  9.1114 +        }
  9.1115 +
  9.1116 +        if (!writeIndex) {
  9.1117 +            return true;
  9.1118 +        }
  9.1119 +
  9.1120 +        File indexFile = getIndexFile();
  9.1121 +        if (indexFile == null) {
  9.1122 +            return false;
  9.1123 +        }
  9.1124 +
  9.1125 +        RandomAccessFile raf = null;
  9.1126 +        long writtenSoFar = 0;
  9.1127 +        try {
  9.1128 +            raf = new RandomAccessFile(indexFile, "rw");
  9.1129 +
  9.1130 +            raf.writeLong(zipFileLastModified);
  9.1131 +            writtenSoFar += 8;
  9.1132 +
  9.1133 +
  9.1134 +            Iterator<String> iterDirName = directories.keySet().iterator();
  9.1135 +            List<DirectoryEntry> directoriesToWrite = new ArrayList<DirectoryEntry>();
  9.1136 +            Map<String, Long> offsets = new HashMap<String, Long>();
  9.1137 +            raf.writeInt(directories.keySet().size());
  9.1138 +            writtenSoFar += 4;
  9.1139 +
  9.1140 +            while(iterDirName.hasNext()) {
  9.1141 +                String dirName = iterDirName.next();
  9.1142 +                DirectoryEntry dirEntry = directories.get(dirName);
  9.1143 +
  9.1144 +                directoriesToWrite.add(dirEntry);
  9.1145 +
  9.1146 +                // Write the dir name bytes
  9.1147 +                byte [] dirNameBytes = dirName.getBytes("UTF-8");
  9.1148 +                int dirNameBytesLen = dirNameBytes.length;
  9.1149 +                raf.writeInt(dirNameBytesLen);
  9.1150 +                writtenSoFar += 4;
  9.1151 +
  9.1152 +                raf.write(dirNameBytes);
  9.1153 +                writtenSoFar += dirNameBytesLen;
  9.1154 +
  9.1155 +                // Write the number of files in the dir
  9.1156 +                List dirEntries = dirEntry.getEntriesAsCollection();
  9.1157 +                raf.writeInt(dirEntries.size());
  9.1158 +                writtenSoFar += 4;
  9.1159 +
  9.1160 +                offsets.put(dirName, new Long(writtenSoFar));
  9.1161 +
  9.1162 +                // Write the offset of the file's data in the dir
  9.1163 +                dirEntry.writtenOffsetOffset = 0L;
  9.1164 +                raf.writeLong(0L);
  9.1165 +                writtenSoFar += 8;
  9.1166 +            }
  9.1167 +
  9.1168 +            for (DirectoryEntry de : directoriesToWrite) {
  9.1169 +                // Fix up the offset in the directory table
  9.1170 +                long currFP = raf.getFilePointer();
  9.1171 +
  9.1172 +                long offsetOffset = offsets.get(de.dirName).longValue();
  9.1173 +                raf.seek(offsetOffset);
  9.1174 +                raf.writeLong(writtenSoFar);
  9.1175 +
  9.1176 +                raf.seek(currFP);
  9.1177 +
  9.1178 +                // Now write each of the files in the DirectoryEntry
  9.1179 +                List<ZipFileIndexEntry> entries = de.getEntriesAsCollection();
  9.1180 +                for (ZipFileIndexEntry zfie : entries) {
  9.1181 +                    // Write the name bytes
  9.1182 +                    byte [] zfieNameBytes = zfie.name.getBytes("UTF-8");
  9.1183 +                    int zfieNameBytesLen = zfieNameBytes.length;
  9.1184 +                    raf.writeInt(zfieNameBytesLen);
  9.1185 +                    writtenSoFar += 4;
  9.1186 +                    raf.write(zfieNameBytes);
  9.1187 +                    writtenSoFar += zfieNameBytesLen;
  9.1188 +
  9.1189 +                    // Write isDir
  9.1190 +                    raf.writeByte(zfie.isDir ? (byte)1 : (byte)0);
  9.1191 +                    writtenSoFar += 1;
  9.1192 +
  9.1193 +                    // Write offset of bytes in the real Jar/Zip file
  9.1194 +                    raf.writeInt(zfie.offset);
  9.1195 +                    writtenSoFar += 4;
  9.1196 +
  9.1197 +                    // Write size of the file in the real Jar/Zip file
  9.1198 +                    raf.writeInt(zfie.size);
  9.1199 +                    writtenSoFar += 4;
  9.1200 +
  9.1201 +                    // Write compressed size of the file in the real Jar/Zip file
  9.1202 +                    raf.writeInt(zfie.compressedSize);
  9.1203 +                    writtenSoFar += 4;
  9.1204 +
  9.1205 +                    // Write java time stamp of the file in the real Jar/Zip file
  9.1206 +                    raf.writeLong(zfie.getLastModified());
  9.1207 +                    writtenSoFar += 8;
  9.1208 +                }
  9.1209 +            }
  9.1210 +        } catch (Throwable t) {
  9.1211 +            // Do nothing
  9.1212 +        } finally {
  9.1213 +            try {
  9.1214 +                if (raf != null) {
  9.1215 +                    raf.close();
  9.1216 +                }
  9.1217 +            } catch(IOException ioe) {
  9.1218 +                // Do nothing
  9.1219 +            }
  9.1220 +        }
  9.1221 +
  9.1222 +        return ret;
  9.1223 +    }
  9.1224 +
  9.1225 +    public boolean writeZipIndex() {
  9.1226 +        lock.lock();
  9.1227 +        try {
  9.1228 +            return writeIndex();
  9.1229 +        }
  9.1230 +        finally {
  9.1231 +            lock.unlock();
  9.1232 +        }
  9.1233 +    }
  9.1234 +
  9.1235 +    private File getIndexFile() {
  9.1236 +        if (zipIndexFile == null) {
  9.1237 +            if (zipFile == null) {
  9.1238 +                return null;
  9.1239 +            }
  9.1240 +
  9.1241 +            zipIndexFile = new File((preindexedCacheLocation == null ? "" : preindexedCacheLocation) +
  9.1242 +                    zipFile.getName() + ".index");
  9.1243 +        }
  9.1244 +
  9.1245 +        return zipIndexFile;
  9.1246 +    }
  9.1247 +
  9.1248 +    public File getZipFile() {
  9.1249 +        return zipFile;
  9.1250 +    }
  9.1251 +}

    10.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    10.2 +++ b/src/share/classes/com/sun/tools/javac/file/ZipFileIndexEntry.java	Mon Jun 16 13:28:00 2008 -0700
    10.3 @@ -0,0 +1,116 @@
    10.4 +/*
    10.5 + * Copyright 2007-2008 Sun Microsystems, Inc.  All Rights Reserved.
    10.6 + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    10.7 + *
    10.8 + * This code is free software; you can redistribute it and/or modify it
    10.9 + * under the terms of the GNU General Public License version 2 only, as
   10.10 + * published by the Free Software Foundation.  Sun designates this
   10.11 + * particular file as subject to the "Classpath" exception as provided
   10.12 + * by Sun in the LICENSE file that accompanied this code.
   10.13 + *
   10.14 + * This code is distributed in the hope that it will be useful, but WITHOUT
   10.15 + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   10.16 + * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   10.17 + * version 2 for more details (a copy is included in the LICENSE file that
   10.18 + * accompanied this code).
   10.19 + *
   10.20 + * You should have received a copy of the GNU General Public License version
   10.21 + * 2 along with this work; if not, write to the Free Software Foundation,
   10.22 + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   10.23 + *
   10.24 + * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
   10.25 + * CA 95054 USA or visit www.sun.com if you need additional information or
   10.26 + * have any questions.
   10.27 + */
   10.28 +
   10.29 +package com.sun.tools.javac.file;
   10.30 +
   10.31 +import java.io.File;
   10.32 +
   10.33 +public final class ZipFileIndexEntry implements Comparable<ZipFileIndexEntry> {
   10.34 +    public static final ZipFileIndexEntry[] EMPTY_ARRAY = {};
   10.35 +
   10.36 +    // Directory related
   10.37 +    String dir;
   10.38 +    boolean isDir;
   10.39 +
   10.40 +    // File related
   10.41 +    String name;
   10.42 +
   10.43 +    int offset;
   10.44 +    int size;
   10.45 +    int compressedSize;
   10.46 +    long javatime;
   10.47 +
   10.48 +    private int nativetime;
   10.49 +
   10.50 +    public ZipFileIndexEntry(String path) {
   10.51 +        int separator = path.lastIndexOf(File.separatorChar);
   10.52 +        if (separator == -1) {
   10.53 +            dir = "".intern();
   10.54 +            name = path;
   10.55 +        } else {
   10.56 +            dir = path.substring(0, separator).intern();
   10.57 +            name = path.substring(separator + 1);
   10.58 +        }
   10.59 +    }
   10.60 +
   10.61 +    public ZipFileIndexEntry(String directory, String name) {
   10.62 +        this.dir = directory.intern();
   10.63 +        this.name = name;
   10.64 +    }
   10.65 +
   10.66 +    public String getName() {
   10.67 +        if (dir == null || dir.length() == 0) {
   10.68 +            return name;
   10.69 +        }
   10.70 +
   10.71 +        StringBuilder sb = new StringBuilder();
   10.72 +        sb.append(dir);
   10.73 +        sb.append(File.separatorChar);
   10.74 +        sb.append(name);
   10.75 +        return sb.toString();
   10.76 +    }
   10.77 +
   10.78 +    public String getFileName() {
   10.79 +        return name;
   10.80 +    }
   10.81 +
   10.82 +    public long getLastModified() {
   10.83 +        if (javatime == 0) {
   10.84 +                javatime = dosToJavaTime(nativetime);
   10.85 +        }
   10.86 +        return javatime;
   10.87 +    }
   10.88 +
   10.89 +    // From java.util.zip
   10.90 +    private static long dosToJavaTime(int nativetime) {
   10.91 +        // Bootstrap build problems prevent me from using the code directly
   10.92 +        // Convert the raw/native time to a long for now
   10.93 +        return (long)nativetime;
   10.94 +    }
   10.95 +
   10.96 +    void setNativeTime(int natTime) {
   10.97 +        nativetime = natTime;
   10.98 +    }
   10.99 +
  10.100 +    public boolean isDirectory() {
  10.101 +        return isDir;
  10.102 +    }
  10.103 +
  10.104 +    public int compareTo(ZipFileIndexEntry other) {
  10.105 +        String otherD = other.dir;
  10.106 +        if (dir != otherD) {
  10.107 +            int c = dir.compareTo(otherD);
  10.108 +            if (c != 0)
  10.109 +                return c;
  10.110 +        }
  10.111 +        return name.compareTo(other.name);
  10.112 +    }
  10.113 +
  10.114 +
  10.115 +    public String toString() {
  10.116 +        return isDir ? ("Dir:" + dir + " : " + name) :
  10.117 +            (dir + ":" + name);
  10.118 +    }
  10.119 +}