langtools/src/share/classes/com/sun/tools/javac/file/ZipFileIndex.java
author jjh
Wed, 15 Aug 2012 13:48:46 -0700
changeset 13631 dc1212c348f9
parent 13076 cb848b70d7f4
child 14258 8d2148961366
permissions -rw-r--r--
7191449: update copyright year to match last edit in jdk8 langtools repository Reviewed-by: jjh Contributed-by: steve.sides@oracle.com
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
655
1ebc7ce89018 6705945: com.sun.tools.javac.zip files do not have valid copyright
jjg
parents: 10
diff changeset
     1
/*
13631
dc1212c348f9 7191449: update copyright year to match last edit in jdk8 langtools repository
jjh
parents: 13076
diff changeset
     2
 * Copyright (c) 2007, 2012, Oracle and/or its affiliates. All rights reserved.
655
1ebc7ce89018 6705945: com.sun.tools.javac.zip files do not have valid copyright
jjg
parents: 10
diff changeset
     3
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
1ebc7ce89018 6705945: com.sun.tools.javac.zip files do not have valid copyright
jjg
parents: 10
diff changeset
     4
 *
1ebc7ce89018 6705945: com.sun.tools.javac.zip files do not have valid copyright
jjg
parents: 10
diff changeset
     5
 * This code is free software; you can redistribute it and/or modify it
1ebc7ce89018 6705945: com.sun.tools.javac.zip files do not have valid copyright
jjg
parents: 10
diff changeset
     6
 * under the terms of the GNU General Public License version 2 only, as
5520
86e4b9a9da40 6943119: Rebrand source copyright notices
ohair
parents: 4418
diff changeset
     7
 * published by the Free Software Foundation.  Oracle designates this
655
1ebc7ce89018 6705945: com.sun.tools.javac.zip files do not have valid copyright
jjg
parents: 10
diff changeset
     8
 * particular file as subject to the "Classpath" exception as provided
5520
86e4b9a9da40 6943119: Rebrand source copyright notices
ohair
parents: 4418
diff changeset
     9
 * by Oracle in the LICENSE file that accompanied this code.
655
1ebc7ce89018 6705945: com.sun.tools.javac.zip files do not have valid copyright
jjg
parents: 10
diff changeset
    10
 *
1ebc7ce89018 6705945: com.sun.tools.javac.zip files do not have valid copyright
jjg
parents: 10
diff changeset
    11
 * This code is distributed in the hope that it will be useful, but WITHOUT
1ebc7ce89018 6705945: com.sun.tools.javac.zip files do not have valid copyright
jjg
parents: 10
diff changeset
    12
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
1ebc7ce89018 6705945: com.sun.tools.javac.zip files do not have valid copyright
jjg
parents: 10
diff changeset
    13
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
1ebc7ce89018 6705945: com.sun.tools.javac.zip files do not have valid copyright
jjg
parents: 10
diff changeset
    14
 * version 2 for more details (a copy is included in the LICENSE file that
1ebc7ce89018 6705945: com.sun.tools.javac.zip files do not have valid copyright
jjg
parents: 10
diff changeset
    15
 * accompanied this code).
1ebc7ce89018 6705945: com.sun.tools.javac.zip files do not have valid copyright
jjg
parents: 10
diff changeset
    16
 *
1ebc7ce89018 6705945: com.sun.tools.javac.zip files do not have valid copyright
jjg
parents: 10
diff changeset
    17
 * You should have received a copy of the GNU General Public License version
1ebc7ce89018 6705945: com.sun.tools.javac.zip files do not have valid copyright
jjg
parents: 10
diff changeset
    18
 * 2 along with this work; if not, write to the Free Software Foundation,
1ebc7ce89018 6705945: com.sun.tools.javac.zip files do not have valid copyright
jjg
parents: 10
diff changeset
    19
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
1ebc7ce89018 6705945: com.sun.tools.javac.zip files do not have valid copyright
jjg
parents: 10
diff changeset
    20
 *
5520
86e4b9a9da40 6943119: Rebrand source copyright notices
ohair
parents: 4418
diff changeset
    21
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
86e4b9a9da40 6943119: Rebrand source copyright notices
ohair
parents: 4418
diff changeset
    22
 * or visit www.oracle.com if you need additional information or have any
86e4b9a9da40 6943119: Rebrand source copyright notices
ohair
parents: 4418
diff changeset
    23
 * questions.
655
1ebc7ce89018 6705945: com.sun.tools.javac.zip files do not have valid copyright
jjg
parents: 10
diff changeset
    24
 */
1ebc7ce89018 6705945: com.sun.tools.javac.zip files do not have valid copyright
jjg
parents: 10
diff changeset
    25
731
1dd22bdb9ca5 6714364: refactor javac File handling code into new javac.file package
jjg
parents: 655
diff changeset
    26
package com.sun.tools.javac.file;
10
06bc494ca11e Initial load
duke
parents:
diff changeset
    27
1205
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
    28
731
1dd22bdb9ca5 6714364: refactor javac File handling code into new javac.file package
jjg
parents: 655
diff changeset
    29
import java.io.File;
1dd22bdb9ca5 6714364: refactor javac File handling code into new javac.file package
jjg
parents: 655
diff changeset
    30
import java.io.FileNotFoundException;
1dd22bdb9ca5 6714364: refactor javac File handling code into new javac.file package
jjg
parents: 655
diff changeset
    31
import java.io.IOException;
1dd22bdb9ca5 6714364: refactor javac File handling code into new javac.file package
jjg
parents: 655
diff changeset
    32
import java.io.RandomAccessFile;
4073
9788f4549740 6838467: JSR199 FileObjects don't obey general contract of equals.
jjg
parents: 3380
diff changeset
    33
import java.lang.ref.Reference;
1205
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
    34
import java.lang.ref.SoftReference;
731
1dd22bdb9ca5 6714364: refactor javac File handling code into new javac.file package
jjg
parents: 655
diff changeset
    35
import java.util.ArrayList;
1dd22bdb9ca5 6714364: refactor javac File handling code into new javac.file package
jjg
parents: 655
diff changeset
    36
import java.util.Arrays;
865
21668f049d28 6725036: javac returns incorrect value for lastModifiedTime() when source is a zip file archive
jjg
parents: 810
diff changeset
    37
import java.util.Calendar;
731
1dd22bdb9ca5 6714364: refactor javac File handling code into new javac.file package
jjg
parents: 655
diff changeset
    38
import java.util.Collections;
13076
cb848b70d7f4 7177701: error: Filling jar message during javax/imageio/metadata/IIOMetadataFormatImpl compilation
mcimadamore
parents: 8837
diff changeset
    39
import java.util.LinkedHashMap;
731
1dd22bdb9ca5 6714364: refactor javac File handling code into new javac.file package
jjg
parents: 655
diff changeset
    40
import java.util.HashMap;
1dd22bdb9ca5 6714364: refactor javac File handling code into new javac.file package
jjg
parents: 655
diff changeset
    41
import java.util.HashSet;
10
06bc494ca11e Initial load
duke
parents:
diff changeset
    42
import java.util.List;
731
1dd22bdb9ca5 6714364: refactor javac File handling code into new javac.file package
jjg
parents: 655
diff changeset
    43
import java.util.Map;
1dd22bdb9ca5 6714364: refactor javac File handling code into new javac.file package
jjg
parents: 655
diff changeset
    44
import java.util.Set;
1dd22bdb9ca5 6714364: refactor javac File handling code into new javac.file package
jjg
parents: 655
diff changeset
    45
import java.util.zip.DataFormatException;
1dd22bdb9ca5 6714364: refactor javac File handling code into new javac.file package
jjg
parents: 655
diff changeset
    46
import java.util.zip.Inflater;
1dd22bdb9ca5 6714364: refactor javac File handling code into new javac.file package
jjg
parents: 655
diff changeset
    47
import java.util.zip.ZipException;
10
06bc494ca11e Initial load
duke
parents:
diff changeset
    48
1205
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
    49
import com.sun.tools.javac.file.RelativePath.RelativeDirectory;
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
    50
import com.sun.tools.javac.file.RelativePath.RelativeFile;
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
    51
8223
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
    52
/**
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
    53
 * This class implements the building of index of a zip archive and access to
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
    54
 * its context. It also uses a prebuilt index if available.
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
    55
 * It supports invocations where it will serialize an optimized zip index file
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
    56
 * to disk.
10
06bc494ca11e Initial load
duke
parents:
diff changeset
    57
 *
8223
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
    58
 * In order to use a secondary index file, set "usezipindex" in the Options
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
    59
 * object when JavacFileManager is invoked. (You can pass "-XDusezipindex" on
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
    60
 * the command line.)
10
06bc494ca11e Initial load
duke
parents:
diff changeset
    61
 *
8223
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
    62
 * Location where to look for/generate optimized zip index files can be
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
    63
 * provided using "-XDcachezipindexdir=<directory>". If this flag is not
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
    64
 * provided, the default location is the value of the "java.io.tmpdir" system
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
    65
 * property.
10
06bc494ca11e Initial load
duke
parents:
diff changeset
    66
 *
8223
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
    67
 * If "-XDwritezipindexfiles" is specified, there will be new optimized index
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
    68
 * file created for each archive, used by the compiler for compilation, at the
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
    69
 * location specified by the "cachezipindexdir" option.
10
06bc494ca11e Initial load
duke
parents:
diff changeset
    70
 *
8223
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
    71
 * If system property nonBatchMode option is specified the compiler will use
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
    72
 * timestamp checking to reindex the zip files if it is needed. In batch mode
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
    73
 * the timestamps are not checked and the compiler uses the cached indexes.
3380
a6c2bcab0fec 6865399: some javac files are missing Sun internal API comment
jjg
parents: 1789
diff changeset
    74
 *
5847
1908176fd6e3 6944312: Potential rebranding issues in openjdk/langtools repository sources
jjg
parents: 5520
diff changeset
    75
 * <p><b>This is NOT part of any supported API.
3380
a6c2bcab0fec 6865399: some javac files are missing Sun internal API comment
jjg
parents: 1789
diff changeset
    76
 * If you write code that depends on this, you do so at your own risk.
a6c2bcab0fec 6865399: some javac files are missing Sun internal API comment
jjg
parents: 1789
diff changeset
    77
 * This code and its internal interfaces are subject to change or
a6c2bcab0fec 6865399: some javac files are missing Sun internal API comment
jjg
parents: 1789
diff changeset
    78
 * deletion without notice.</b>
10
06bc494ca11e Initial load
duke
parents:
diff changeset
    79
 */
06bc494ca11e Initial load
duke
parents:
diff changeset
    80
public class ZipFileIndex {
06bc494ca11e Initial load
duke
parents:
diff changeset
    81
    private static final String MIN_CHAR = String.valueOf(Character.MIN_VALUE);
06bc494ca11e Initial load
duke
parents:
diff changeset
    82
    private static final String MAX_CHAR = String.valueOf(Character.MAX_VALUE);
06bc494ca11e Initial load
duke
parents:
diff changeset
    83
06bc494ca11e Initial load
duke
parents:
diff changeset
    84
    public final static long NOT_MODIFIED = Long.MIN_VALUE;
06bc494ca11e Initial load
duke
parents:
diff changeset
    85
06bc494ca11e Initial load
duke
parents:
diff changeset
    86
06bc494ca11e Initial load
duke
parents:
diff changeset
    87
    private static boolean NON_BATCH_MODE = System.getProperty("nonBatchMode") != null;// TODO: Use -XD compiler switch for this.
06bc494ca11e Initial load
duke
parents:
diff changeset
    88
8223
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
    89
    private Map<RelativeDirectory, DirectoryEntry> directories =
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
    90
            Collections.<RelativeDirectory, DirectoryEntry>emptyMap();
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
    91
    private Set<RelativeDirectory> allDirs =
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
    92
            Collections.<RelativeDirectory>emptySet();
10
06bc494ca11e Initial load
duke
parents:
diff changeset
    93
06bc494ca11e Initial load
duke
parents:
diff changeset
    94
    // ZipFileIndex data entries
8223
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
    95
    final File zipFile;
4073
9788f4549740 6838467: JSR199 FileObjects don't obey general contract of equals.
jjg
parents: 3380
diff changeset
    96
    private Reference<File> absFileRef;
8223
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
    97
    long zipFileLastModified = NOT_MODIFIED;
10
06bc494ca11e Initial load
duke
parents:
diff changeset
    98
    private RandomAccessFile zipRandomFile;
810
e4b6a6d206e6 6714365: refactor JavacFileManager to move nested classes to top level
jjg
parents: 731
diff changeset
    99
    private Entry[] entries;
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   100
06bc494ca11e Initial load
duke
parents:
diff changeset
   101
    private boolean readFromIndex = false;
06bc494ca11e Initial load
duke
parents:
diff changeset
   102
    private File zipIndexFile = null;
06bc494ca11e Initial load
duke
parents:
diff changeset
   103
    private boolean triedToReadIndex = false;
1205
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
   104
    final RelativeDirectory symbolFilePrefix;
8223
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
   105
    private final int symbolFilePrefixLength;
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   106
    private boolean hasPopulatedData = false;
8223
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
   107
    long lastReferenceTimeStamp = NOT_MODIFIED;
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   108
8223
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
   109
    private final boolean usePreindexedCache;
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
   110
    private final String preindexedCacheLocation;
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   111
06bc494ca11e Initial load
duke
parents:
diff changeset
   112
    private boolean writeIndex = false;
06bc494ca11e Initial load
duke
parents:
diff changeset
   113
8223
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
   114
    private Map<String, SoftReference<RelativeDirectory>> relativeDirectoryCache =
1205
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
   115
            new HashMap<String, SoftReference<RelativeDirectory>>();
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
   116
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   117
8223
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
   118
    public synchronized boolean isOpen() {
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
   119
        return (zipRandomFile != null);
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   120
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   121
8223
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
   122
    ZipFileIndex(File zipFile, RelativeDirectory symbolFilePrefix, boolean writeIndex,
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   123
            boolean useCache, String cacheLocation) throws IOException {
06bc494ca11e Initial load
duke
parents:
diff changeset
   124
        this.zipFile = zipFile;
810
e4b6a6d206e6 6714365: refactor JavacFileManager to move nested classes to top level
jjg
parents: 731
diff changeset
   125
        this.symbolFilePrefix = symbolFilePrefix;
e4b6a6d206e6 6714365: refactor JavacFileManager to move nested classes to top level
jjg
parents: 731
diff changeset
   126
        this.symbolFilePrefixLength = (symbolFilePrefix == null ? 0 :
1205
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
   127
            symbolFilePrefix.getPath().getBytes("UTF-8").length);
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   128
        this.writeIndex = writeIndex;
06bc494ca11e Initial load
duke
parents:
diff changeset
   129
        this.usePreindexedCache = useCache;
06bc494ca11e Initial load
duke
parents:
diff changeset
   130
        this.preindexedCacheLocation = cacheLocation;
06bc494ca11e Initial load
duke
parents:
diff changeset
   131
06bc494ca11e Initial load
duke
parents:
diff changeset
   132
        if (zipFile != null) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   133
            this.zipFileLastModified = zipFile.lastModified();
06bc494ca11e Initial load
duke
parents:
diff changeset
   134
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   135
06bc494ca11e Initial load
duke
parents:
diff changeset
   136
        // Validate integrity of the zip file
06bc494ca11e Initial load
duke
parents:
diff changeset
   137
        checkIndex();
06bc494ca11e Initial load
duke
parents:
diff changeset
   138
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   139
8223
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
   140
    @Override
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   141
    public String toString() {
1205
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
   142
        return "ZipFileIndex[" + zipFile + "]";
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   143
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   144
06bc494ca11e Initial load
duke
parents:
diff changeset
   145
    // Just in case...
8223
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
   146
    @Override
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
   147
    protected void finalize() throws Throwable {
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   148
        closeFile();
8223
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
   149
        super.finalize();
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   150
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   151
06bc494ca11e Initial load
duke
parents:
diff changeset
   152
    private boolean isUpToDate() {
8223
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
   153
        if (zipFile != null
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
   154
                && ((!NON_BATCH_MODE) || zipFileLastModified == zipFile.lastModified())
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
   155
                && hasPopulatedData) {
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   156
            return true;
06bc494ca11e Initial load
duke
parents:
diff changeset
   157
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   158
06bc494ca11e Initial load
duke
parents:
diff changeset
   159
        return false;
06bc494ca11e Initial load
duke
parents:
diff changeset
   160
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   161
06bc494ca11e Initial load
duke
parents:
diff changeset
   162
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   163
     * Here we need to make sure that the ZipFileIndex is valid. Check the timestamp of the file and
06bc494ca11e Initial load
duke
parents:
diff changeset
   164
     * if its the same as the one at the time the index was build we don't need to reopen anything.
06bc494ca11e Initial load
duke
parents:
diff changeset
   165
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   166
    private void checkIndex() throws IOException {
06bc494ca11e Initial load
duke
parents:
diff changeset
   167
        boolean isUpToDate = true;
06bc494ca11e Initial load
duke
parents:
diff changeset
   168
        if (!isUpToDate()) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   169
            closeFile();
06bc494ca11e Initial load
duke
parents:
diff changeset
   170
            isUpToDate = false;
06bc494ca11e Initial load
duke
parents:
diff changeset
   171
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   172
06bc494ca11e Initial load
duke
parents:
diff changeset
   173
        if (zipRandomFile != null || isUpToDate) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   174
            lastReferenceTimeStamp = System.currentTimeMillis();
06bc494ca11e Initial load
duke
parents:
diff changeset
   175
            return;
06bc494ca11e Initial load
duke
parents:
diff changeset
   176
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   177
06bc494ca11e Initial load
duke
parents:
diff changeset
   178
        hasPopulatedData = true;
06bc494ca11e Initial load
duke
parents:
diff changeset
   179
06bc494ca11e Initial load
duke
parents:
diff changeset
   180
        if (readIndex()) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   181
            lastReferenceTimeStamp = System.currentTimeMillis();
06bc494ca11e Initial load
duke
parents:
diff changeset
   182
            return;
06bc494ca11e Initial load
duke
parents:
diff changeset
   183
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   184
1205
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
   185
        directories = Collections.<RelativeDirectory, DirectoryEntry>emptyMap();
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
   186
        allDirs = Collections.<RelativeDirectory>emptySet();
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   187
06bc494ca11e Initial load
duke
parents:
diff changeset
   188
        try {
06bc494ca11e Initial load
duke
parents:
diff changeset
   189
            openFile();
06bc494ca11e Initial load
duke
parents:
diff changeset
   190
            long totalLength = zipRandomFile.length();
06bc494ca11e Initial load
duke
parents:
diff changeset
   191
            ZipDirectory directory = new ZipDirectory(zipRandomFile, 0L, totalLength, this);
06bc494ca11e Initial load
duke
parents:
diff changeset
   192
            directory.buildIndex();
06bc494ca11e Initial load
duke
parents:
diff changeset
   193
        } finally {
06bc494ca11e Initial load
duke
parents:
diff changeset
   194
            if (zipRandomFile != null) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   195
                closeFile();
06bc494ca11e Initial load
duke
parents:
diff changeset
   196
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
   197
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   198
06bc494ca11e Initial load
duke
parents:
diff changeset
   199
        lastReferenceTimeStamp = System.currentTimeMillis();
06bc494ca11e Initial load
duke
parents:
diff changeset
   200
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   201
06bc494ca11e Initial load
duke
parents:
diff changeset
   202
    private void openFile() throws FileNotFoundException {
06bc494ca11e Initial load
duke
parents:
diff changeset
   203
        if (zipRandomFile == null && zipFile != null) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   204
            zipRandomFile = new RandomAccessFile(zipFile, "r");
06bc494ca11e Initial load
duke
parents:
diff changeset
   205
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   206
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   207
06bc494ca11e Initial load
duke
parents:
diff changeset
   208
    private void cleanupState() {
06bc494ca11e Initial load
duke
parents:
diff changeset
   209
        // Make sure there is a valid but empty index if the file doesn't exist
810
e4b6a6d206e6 6714365: refactor JavacFileManager to move nested classes to top level
jjg
parents: 731
diff changeset
   210
        entries = Entry.EMPTY_ARRAY;
1205
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
   211
        directories = Collections.<RelativeDirectory, DirectoryEntry>emptyMap();
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   212
        zipFileLastModified = NOT_MODIFIED;
1205
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
   213
        allDirs = Collections.<RelativeDirectory>emptySet();
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   214
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   215
8223
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
   216
    public synchronized void close() {
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
   217
        writeIndex();
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
   218
        closeFile();
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   219
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   220
06bc494ca11e Initial load
duke
parents:
diff changeset
   221
    private void closeFile() {
06bc494ca11e Initial load
duke
parents:
diff changeset
   222
        if (zipRandomFile != null) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   223
            try {
06bc494ca11e Initial load
duke
parents:
diff changeset
   224
                zipRandomFile.close();
06bc494ca11e Initial load
duke
parents:
diff changeset
   225
            } catch (IOException ex) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   226
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
   227
            zipRandomFile = null;
06bc494ca11e Initial load
duke
parents:
diff changeset
   228
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   229
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   230
06bc494ca11e Initial load
duke
parents:
diff changeset
   231
    /**
8223
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
   232
     * Returns the ZipFileIndexEntry for a path, if there is one.
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   233
     */
8223
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
   234
    synchronized Entry getZipIndexEntry(RelativePath path) {
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   235
        try {
06bc494ca11e Initial load
duke
parents:
diff changeset
   236
            checkIndex();
1205
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
   237
            DirectoryEntry de = directories.get(path.dirname());
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
   238
            String lookFor = path.basename();
8223
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
   239
            return (de == null) ? null : de.getEntry(lookFor);
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   240
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   241
        catch (IOException e) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   242
            return null;
06bc494ca11e Initial load
duke
parents:
diff changeset
   243
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   244
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   245
06bc494ca11e Initial load
duke
parents:
diff changeset
   246
    /**
8223
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
   247
     * Returns a javac List of filenames within a directory in the ZipFileIndex.
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   248
     */
8223
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
   249
    public synchronized com.sun.tools.javac.util.List<String> getFiles(RelativeDirectory path) {
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   250
        try {
06bc494ca11e Initial load
duke
parents:
diff changeset
   251
            checkIndex();
06bc494ca11e Initial load
duke
parents:
diff changeset
   252
06bc494ca11e Initial load
duke
parents:
diff changeset
   253
            DirectoryEntry de = directories.get(path);
06bc494ca11e Initial load
duke
parents:
diff changeset
   254
            com.sun.tools.javac.util.List<String> ret = de == null ? null : de.getFiles();
06bc494ca11e Initial load
duke
parents:
diff changeset
   255
06bc494ca11e Initial load
duke
parents:
diff changeset
   256
            if (ret == null) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   257
                return com.sun.tools.javac.util.List.<String>nil();
06bc494ca11e Initial load
duke
parents:
diff changeset
   258
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
   259
            return ret;
06bc494ca11e Initial load
duke
parents:
diff changeset
   260
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   261
        catch (IOException e) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   262
            return com.sun.tools.javac.util.List.<String>nil();
06bc494ca11e Initial load
duke
parents:
diff changeset
   263
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   264
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   265
8223
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
   266
    public synchronized List<String> getDirectories(RelativeDirectory path) {
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   267
        try {
06bc494ca11e Initial load
duke
parents:
diff changeset
   268
            checkIndex();
06bc494ca11e Initial load
duke
parents:
diff changeset
   269
06bc494ca11e Initial load
duke
parents:
diff changeset
   270
            DirectoryEntry de = directories.get(path);
06bc494ca11e Initial load
duke
parents:
diff changeset
   271
            com.sun.tools.javac.util.List<String> ret = de == null ? null : de.getDirectories();
06bc494ca11e Initial load
duke
parents:
diff changeset
   272
06bc494ca11e Initial load
duke
parents:
diff changeset
   273
            if (ret == null) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   274
                return com.sun.tools.javac.util.List.<String>nil();
06bc494ca11e Initial load
duke
parents:
diff changeset
   275
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
   276
06bc494ca11e Initial load
duke
parents:
diff changeset
   277
            return ret;
06bc494ca11e Initial load
duke
parents:
diff changeset
   278
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   279
        catch (IOException e) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   280
            return com.sun.tools.javac.util.List.<String>nil();
06bc494ca11e Initial load
duke
parents:
diff changeset
   281
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   282
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   283
8223
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
   284
    public synchronized Set<RelativeDirectory> getAllDirectories() {
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   285
        try {
06bc494ca11e Initial load
duke
parents:
diff changeset
   286
            checkIndex();
06bc494ca11e Initial load
duke
parents:
diff changeset
   287
            if (allDirs == Collections.EMPTY_SET) {
13076
cb848b70d7f4 7177701: error: Filling jar message during javax/imageio/metadata/IIOMetadataFormatImpl compilation
mcimadamore
parents: 8837
diff changeset
   288
                allDirs = new java.util.LinkedHashSet<RelativeDirectory>(directories.keySet());
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   289
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
   290
06bc494ca11e Initial load
duke
parents:
diff changeset
   291
            return allDirs;
06bc494ca11e Initial load
duke
parents:
diff changeset
   292
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   293
        catch (IOException e) {
1205
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
   294
            return Collections.<RelativeDirectory>emptySet();
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   295
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   296
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   297
06bc494ca11e Initial load
duke
parents:
diff changeset
   298
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   299
     * Tests if a specific path exists in the zip.  This method will return true
06bc494ca11e Initial load
duke
parents:
diff changeset
   300
     * for file entries and directories.
06bc494ca11e Initial load
duke
parents:
diff changeset
   301
     *
06bc494ca11e Initial load
duke
parents:
diff changeset
   302
     * @param path A path within the zip.
06bc494ca11e Initial load
duke
parents:
diff changeset
   303
     * @return True if the path is a file or dir, false otherwise.
06bc494ca11e Initial load
duke
parents:
diff changeset
   304
     */
8223
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
   305
    public synchronized boolean contains(RelativePath path) {
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   306
        try {
06bc494ca11e Initial load
duke
parents:
diff changeset
   307
            checkIndex();
06bc494ca11e Initial load
duke
parents:
diff changeset
   308
            return getZipIndexEntry(path) != null;
06bc494ca11e Initial load
duke
parents:
diff changeset
   309
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   310
        catch (IOException e) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   311
            return false;
06bc494ca11e Initial load
duke
parents:
diff changeset
   312
        }
8223
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
   313
    }
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
   314
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
   315
    public synchronized boolean isDirectory(RelativePath path) throws IOException {
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
   316
        // The top level in a zip file is always a directory.
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
   317
        if (path.getPath().length() == 0) {
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
   318
            lastReferenceTimeStamp = System.currentTimeMillis();
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
   319
            return true;
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   320
        }
8223
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
   321
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
   322
        checkIndex();
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
   323
        return directories.get(path) != null;
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   324
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   325
8223
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
   326
    public synchronized long getLastModified(RelativeFile path) throws IOException {
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
   327
        Entry entry = getZipIndexEntry(path);
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
   328
        if (entry == null)
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
   329
            throw new FileNotFoundException();
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
   330
        return entry.getLastModified();
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   331
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   332
8223
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
   333
    public synchronized int length(RelativeFile path) throws IOException {
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
   334
        Entry entry = getZipIndexEntry(path);
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
   335
        if (entry == null)
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
   336
            throw new FileNotFoundException();
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
   337
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
   338
        if (entry.isDir) {
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
   339
            return 0;
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   340
        }
8223
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
   341
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
   342
        byte[] header = getHeader(entry);
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
   343
        // entry is not compressed?
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
   344
        if (get2ByteLittleEndian(header, 8) == 0) {
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
   345
            return entry.compressedSize;
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
   346
        } else {
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
   347
            return entry.size;
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   348
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   349
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   350
8223
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
   351
    public synchronized byte[] read(RelativeFile path) throws IOException {
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
   352
        Entry entry = getZipIndexEntry(path);
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
   353
        if (entry == null)
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
   354
            throw new FileNotFoundException("Path not found in ZIP: " + path.path);
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
   355
        return read(entry);
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   356
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   357
8223
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
   358
    synchronized byte[] read(Entry entry) throws IOException {
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
   359
        openFile();
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
   360
        byte[] result = readBytes(entry);
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
   361
        closeFile();
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
   362
        return result;
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   363
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   364
8223
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
   365
    public synchronized int read(RelativeFile path, byte[] buffer) throws IOException {
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
   366
        Entry entry = getZipIndexEntry(path);
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
   367
        if (entry == null)
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
   368
            throw new FileNotFoundException();
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
   369
        return read(entry, buffer);
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   370
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   371
8223
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
   372
    synchronized int read(Entry entry, byte[] buffer)
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   373
            throws IOException {
8223
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
   374
        int result = readBytes(entry, buffer);
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
   375
        return  result;
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   376
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   377
810
e4b6a6d206e6 6714365: refactor JavacFileManager to move nested classes to top level
jjg
parents: 731
diff changeset
   378
    private byte[] readBytes(Entry entry) throws IOException {
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   379
        byte[] header = getHeader(entry);
06bc494ca11e Initial load
duke
parents:
diff changeset
   380
        int csize = entry.compressedSize;
06bc494ca11e Initial load
duke
parents:
diff changeset
   381
        byte[] cbuf = new byte[csize];
06bc494ca11e Initial load
duke
parents:
diff changeset
   382
        zipRandomFile.skipBytes(get2ByteLittleEndian(header, 26) + get2ByteLittleEndian(header, 28));
06bc494ca11e Initial load
duke
parents:
diff changeset
   383
        zipRandomFile.readFully(cbuf, 0, csize);
06bc494ca11e Initial load
duke
parents:
diff changeset
   384
06bc494ca11e Initial load
duke
parents:
diff changeset
   385
        // is this compressed - offset 8 in the ZipEntry header
06bc494ca11e Initial load
duke
parents:
diff changeset
   386
        if (get2ByteLittleEndian(header, 8) == 0)
06bc494ca11e Initial load
duke
parents:
diff changeset
   387
            return cbuf;
06bc494ca11e Initial load
duke
parents:
diff changeset
   388
06bc494ca11e Initial load
duke
parents:
diff changeset
   389
        int size = entry.size;
06bc494ca11e Initial load
duke
parents:
diff changeset
   390
        byte[] buf = new byte[size];
06bc494ca11e Initial load
duke
parents:
diff changeset
   391
        if (inflate(cbuf, buf) != size)
06bc494ca11e Initial load
duke
parents:
diff changeset
   392
            throw new ZipException("corrupted zip file");
06bc494ca11e Initial load
duke
parents:
diff changeset
   393
06bc494ca11e Initial load
duke
parents:
diff changeset
   394
        return buf;
06bc494ca11e Initial load
duke
parents:
diff changeset
   395
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   396
06bc494ca11e Initial load
duke
parents:
diff changeset
   397
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   398
     *
06bc494ca11e Initial load
duke
parents:
diff changeset
   399
     */
810
e4b6a6d206e6 6714365: refactor JavacFileManager to move nested classes to top level
jjg
parents: 731
diff changeset
   400
    private int readBytes(Entry entry, byte[] buffer) throws IOException {
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   401
        byte[] header = getHeader(entry);
06bc494ca11e Initial load
duke
parents:
diff changeset
   402
06bc494ca11e Initial load
duke
parents:
diff changeset
   403
        // entry is not compressed?
06bc494ca11e Initial load
duke
parents:
diff changeset
   404
        if (get2ByteLittleEndian(header, 8) == 0) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   405
            zipRandomFile.skipBytes(get2ByteLittleEndian(header, 26) + get2ByteLittleEndian(header, 28));
06bc494ca11e Initial load
duke
parents:
diff changeset
   406
            int offset = 0;
06bc494ca11e Initial load
duke
parents:
diff changeset
   407
            int size = buffer.length;
06bc494ca11e Initial load
duke
parents:
diff changeset
   408
            while (offset < size) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   409
                int count = zipRandomFile.read(buffer, offset, size - offset);
06bc494ca11e Initial load
duke
parents:
diff changeset
   410
                if (count == -1)
06bc494ca11e Initial load
duke
parents:
diff changeset
   411
                    break;
06bc494ca11e Initial load
duke
parents:
diff changeset
   412
                offset += count;
06bc494ca11e Initial load
duke
parents:
diff changeset
   413
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
   414
            return entry.size;
06bc494ca11e Initial load
duke
parents:
diff changeset
   415
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   416
06bc494ca11e Initial load
duke
parents:
diff changeset
   417
        int csize = entry.compressedSize;
06bc494ca11e Initial load
duke
parents:
diff changeset
   418
        byte[] cbuf = new byte[csize];
06bc494ca11e Initial load
duke
parents:
diff changeset
   419
        zipRandomFile.skipBytes(get2ByteLittleEndian(header, 26) + get2ByteLittleEndian(header, 28));
06bc494ca11e Initial load
duke
parents:
diff changeset
   420
        zipRandomFile.readFully(cbuf, 0, csize);
06bc494ca11e Initial load
duke
parents:
diff changeset
   421
06bc494ca11e Initial load
duke
parents:
diff changeset
   422
        int count = inflate(cbuf, buffer);
06bc494ca11e Initial load
duke
parents:
diff changeset
   423
        if (count == -1)
06bc494ca11e Initial load
duke
parents:
diff changeset
   424
            throw new ZipException("corrupted zip file");
06bc494ca11e Initial load
duke
parents:
diff changeset
   425
06bc494ca11e Initial load
duke
parents:
diff changeset
   426
        return entry.size;
06bc494ca11e Initial load
duke
parents:
diff changeset
   427
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   428
06bc494ca11e Initial load
duke
parents:
diff changeset
   429
    //----------------------------------------------------------------------------
06bc494ca11e Initial load
duke
parents:
diff changeset
   430
    // Zip utilities
06bc494ca11e Initial load
duke
parents:
diff changeset
   431
    //----------------------------------------------------------------------------
06bc494ca11e Initial load
duke
parents:
diff changeset
   432
810
e4b6a6d206e6 6714365: refactor JavacFileManager to move nested classes to top level
jjg
parents: 731
diff changeset
   433
    private byte[] getHeader(Entry entry) throws IOException {
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   434
        zipRandomFile.seek(entry.offset);
06bc494ca11e Initial load
duke
parents:
diff changeset
   435
        byte[] header = new byte[30];
06bc494ca11e Initial load
duke
parents:
diff changeset
   436
        zipRandomFile.readFully(header);
06bc494ca11e Initial load
duke
parents:
diff changeset
   437
        if (get4ByteLittleEndian(header, 0) != 0x04034b50)
06bc494ca11e Initial load
duke
parents:
diff changeset
   438
            throw new ZipException("corrupted zip file");
06bc494ca11e Initial load
duke
parents:
diff changeset
   439
        if ((get2ByteLittleEndian(header, 6) & 1) != 0)
06bc494ca11e Initial load
duke
parents:
diff changeset
   440
            throw new ZipException("encrypted zip file"); // offset 6 in the header of the ZipFileEntry
06bc494ca11e Initial load
duke
parents:
diff changeset
   441
        return header;
06bc494ca11e Initial load
duke
parents:
diff changeset
   442
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   443
06bc494ca11e Initial load
duke
parents:
diff changeset
   444
  /*
06bc494ca11e Initial load
duke
parents:
diff changeset
   445
   * Inflate using the java.util.zip.Inflater class
06bc494ca11e Initial load
duke
parents:
diff changeset
   446
   */
8223
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
   447
    private SoftReference<Inflater> inflaterRef;
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   448
    private int inflate(byte[] src, byte[] dest) {
8223
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
   449
        Inflater inflater = (inflaterRef == null ? null : inflaterRef.get());
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   450
06bc494ca11e Initial load
duke
parents:
diff changeset
   451
        // construct the inflater object or reuse an existing one
06bc494ca11e Initial load
duke
parents:
diff changeset
   452
        if (inflater == null)
8223
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
   453
            inflaterRef = new SoftReference<Inflater>(inflater = new Inflater(true));
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   454
8223
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
   455
        inflater.reset();
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
   456
        inflater.setInput(src);
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
   457
        try {
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
   458
            return inflater.inflate(dest);
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
   459
        } catch (DataFormatException ex) {
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
   460
            return -1;
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   461
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   462
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   463
06bc494ca11e Initial load
duke
parents:
diff changeset
   464
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   465
     * return the two bytes buf[pos], buf[pos+1] as an unsigned integer in little
06bc494ca11e Initial load
duke
parents:
diff changeset
   466
     * endian format.
06bc494ca11e Initial load
duke
parents:
diff changeset
   467
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   468
    private static int get2ByteLittleEndian(byte[] buf, int pos) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   469
        return (buf[pos] & 0xFF) + ((buf[pos+1] & 0xFF) << 8);
06bc494ca11e Initial load
duke
parents:
diff changeset
   470
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   471
06bc494ca11e Initial load
duke
parents:
diff changeset
   472
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   473
     * return the 4 bytes buf[i..i+3] as an integer in little endian format.
06bc494ca11e Initial load
duke
parents:
diff changeset
   474
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   475
    private static int get4ByteLittleEndian(byte[] buf, int pos) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   476
        return (buf[pos] & 0xFF) + ((buf[pos + 1] & 0xFF) << 8) +
06bc494ca11e Initial load
duke
parents:
diff changeset
   477
                ((buf[pos + 2] & 0xFF) << 16) + ((buf[pos + 3] & 0xFF) << 24);
06bc494ca11e Initial load
duke
parents:
diff changeset
   478
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   479
06bc494ca11e Initial load
duke
parents:
diff changeset
   480
    /* ----------------------------------------------------------------------------
06bc494ca11e Initial load
duke
parents:
diff changeset
   481
     * ZipDirectory
06bc494ca11e Initial load
duke
parents:
diff changeset
   482
     * ----------------------------------------------------------------------------*/
06bc494ca11e Initial load
duke
parents:
diff changeset
   483
06bc494ca11e Initial load
duke
parents:
diff changeset
   484
    private class ZipDirectory {
1205
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
   485
        private RelativeDirectory lastDir;
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   486
        private int lastStart;
06bc494ca11e Initial load
duke
parents:
diff changeset
   487
        private int lastLen;
06bc494ca11e Initial load
duke
parents:
diff changeset
   488
06bc494ca11e Initial load
duke
parents:
diff changeset
   489
        byte[] zipDir;
06bc494ca11e Initial load
duke
parents:
diff changeset
   490
        RandomAccessFile zipRandomFile = null;
06bc494ca11e Initial load
duke
parents:
diff changeset
   491
        ZipFileIndex zipFileIndex = null;
06bc494ca11e Initial load
duke
parents:
diff changeset
   492
06bc494ca11e Initial load
duke
parents:
diff changeset
   493
        public ZipDirectory(RandomAccessFile zipRandomFile, long start, long end, ZipFileIndex index) throws IOException {
06bc494ca11e Initial load
duke
parents:
diff changeset
   494
            this.zipRandomFile = zipRandomFile;
06bc494ca11e Initial load
duke
parents:
diff changeset
   495
            this.zipFileIndex = index;
8837
141b22c7e7b2 7021927: javac: regression in performance
ksrini
parents: 8223
diff changeset
   496
            hasValidHeader();
141b22c7e7b2 7021927: javac: regression in performance
ksrini
parents: 8223
diff changeset
   497
            findCENRecord(start, end);
141b22c7e7b2 7021927: javac: regression in performance
ksrini
parents: 8223
diff changeset
   498
        }
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   499
8837
141b22c7e7b2 7021927: javac: regression in performance
ksrini
parents: 8223
diff changeset
   500
        /*
141b22c7e7b2 7021927: javac: regression in performance
ksrini
parents: 8223
diff changeset
   501
         * the zip entry signature should be at offset 0, otherwise allow the
141b22c7e7b2 7021927: javac: regression in performance
ksrini
parents: 8223
diff changeset
   502
         * calling logic to take evasive action by throwing ZipFormatException.
141b22c7e7b2 7021927: javac: regression in performance
ksrini
parents: 8223
diff changeset
   503
         */
141b22c7e7b2 7021927: javac: regression in performance
ksrini
parents: 8223
diff changeset
   504
        private boolean hasValidHeader() throws IOException {
141b22c7e7b2 7021927: javac: regression in performance
ksrini
parents: 8223
diff changeset
   505
            final long pos = zipRandomFile.getFilePointer();
141b22c7e7b2 7021927: javac: regression in performance
ksrini
parents: 8223
diff changeset
   506
            try {
141b22c7e7b2 7021927: javac: regression in performance
ksrini
parents: 8223
diff changeset
   507
                if (zipRandomFile.read() == 'P') {
141b22c7e7b2 7021927: javac: regression in performance
ksrini
parents: 8223
diff changeset
   508
                    if (zipRandomFile.read() == 'K') {
141b22c7e7b2 7021927: javac: regression in performance
ksrini
parents: 8223
diff changeset
   509
                        if (zipRandomFile.read() == 0x03) {
141b22c7e7b2 7021927: javac: regression in performance
ksrini
parents: 8223
diff changeset
   510
                            if (zipRandomFile.read() == 0x04) {
141b22c7e7b2 7021927: javac: regression in performance
ksrini
parents: 8223
diff changeset
   511
                                return true;
141b22c7e7b2 7021927: javac: regression in performance
ksrini
parents: 8223
diff changeset
   512
                            }
141b22c7e7b2 7021927: javac: regression in performance
ksrini
parents: 8223
diff changeset
   513
                        }
141b22c7e7b2 7021927: javac: regression in performance
ksrini
parents: 8223
diff changeset
   514
                    }
141b22c7e7b2 7021927: javac: regression in performance
ksrini
parents: 8223
diff changeset
   515
                }
141b22c7e7b2 7021927: javac: regression in performance
ksrini
parents: 8223
diff changeset
   516
            } finally {
141b22c7e7b2 7021927: javac: regression in performance
ksrini
parents: 8223
diff changeset
   517
                zipRandomFile.seek(pos);
141b22c7e7b2 7021927: javac: regression in performance
ksrini
parents: 8223
diff changeset
   518
            }
141b22c7e7b2 7021927: javac: regression in performance
ksrini
parents: 8223
diff changeset
   519
            throw new ZipFormatException("invalid zip magic");
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   520
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   521
06bc494ca11e Initial load
duke
parents:
diff changeset
   522
        /*
06bc494ca11e Initial load
duke
parents:
diff changeset
   523
         * Reads zip file central directory.
06bc494ca11e Initial load
duke
parents:
diff changeset
   524
         * For more details see readCEN in zip_util.c from the JDK sources.
06bc494ca11e Initial load
duke
parents:
diff changeset
   525
         * This is a Java port of that function.
06bc494ca11e Initial load
duke
parents:
diff changeset
   526
         */
06bc494ca11e Initial load
duke
parents:
diff changeset
   527
        private void findCENRecord(long start, long end) throws IOException {
06bc494ca11e Initial load
duke
parents:
diff changeset
   528
            long totalLength = end - start;
06bc494ca11e Initial load
duke
parents:
diff changeset
   529
            int endbuflen = 1024;
06bc494ca11e Initial load
duke
parents:
diff changeset
   530
            byte[] endbuf = new byte[endbuflen];
06bc494ca11e Initial load
duke
parents:
diff changeset
   531
            long endbufend = end - start;
06bc494ca11e Initial load
duke
parents:
diff changeset
   532
06bc494ca11e Initial load
duke
parents:
diff changeset
   533
            // There is a variable-length field after the dir offset record. We need to do consequential search.
06bc494ca11e Initial load
duke
parents:
diff changeset
   534
            while (endbufend >= 22) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   535
                if (endbufend < endbuflen)
06bc494ca11e Initial load
duke
parents:
diff changeset
   536
                    endbuflen = (int)endbufend;
06bc494ca11e Initial load
duke
parents:
diff changeset
   537
                long endbufpos = endbufend - endbuflen;
06bc494ca11e Initial load
duke
parents:
diff changeset
   538
                zipRandomFile.seek(start + endbufpos);
06bc494ca11e Initial load
duke
parents:
diff changeset
   539
                zipRandomFile.readFully(endbuf, 0, endbuflen);
06bc494ca11e Initial load
duke
parents:
diff changeset
   540
                int i = endbuflen - 22;
06bc494ca11e Initial load
duke
parents:
diff changeset
   541
                while (i >= 0 &&
06bc494ca11e Initial load
duke
parents:
diff changeset
   542
                        !(endbuf[i] == 0x50 &&
06bc494ca11e Initial load
duke
parents:
diff changeset
   543
                        endbuf[i + 1] == 0x4b &&
06bc494ca11e Initial load
duke
parents:
diff changeset
   544
                        endbuf[i + 2] == 0x05 &&
06bc494ca11e Initial load
duke
parents:
diff changeset
   545
                        endbuf[i + 3] == 0x06 &&
06bc494ca11e Initial load
duke
parents:
diff changeset
   546
                        endbufpos + i + 22 +
06bc494ca11e Initial load
duke
parents:
diff changeset
   547
                        get2ByteLittleEndian(endbuf, i + 20) == totalLength)) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   548
                    i--;
06bc494ca11e Initial load
duke
parents:
diff changeset
   549
                }
06bc494ca11e Initial load
duke
parents:
diff changeset
   550
06bc494ca11e Initial load
duke
parents:
diff changeset
   551
                if (i >= 0) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   552
                    zipDir = new byte[get4ByteLittleEndian(endbuf, i + 12) + 2];
06bc494ca11e Initial load
duke
parents:
diff changeset
   553
                    zipDir[0] = endbuf[i + 10];
06bc494ca11e Initial load
duke
parents:
diff changeset
   554
                    zipDir[1] = endbuf[i + 11];
8837
141b22c7e7b2 7021927: javac: regression in performance
ksrini
parents: 8223
diff changeset
   555
                    int sz = get4ByteLittleEndian(endbuf, i + 16);
141b22c7e7b2 7021927: javac: regression in performance
ksrini
parents: 8223
diff changeset
   556
                    // a negative offset or the entries field indicates a
141b22c7e7b2 7021927: javac: regression in performance
ksrini
parents: 8223
diff changeset
   557
                    // potential zip64 archive
141b22c7e7b2 7021927: javac: regression in performance
ksrini
parents: 8223
diff changeset
   558
                    if (sz < 0 || get2ByteLittleEndian(zipDir, 0) == 0xffff) {
141b22c7e7b2 7021927: javac: regression in performance
ksrini
parents: 8223
diff changeset
   559
                        throw new ZipFormatException("detected a zip64 archive");
141b22c7e7b2 7021927: javac: regression in performance
ksrini
parents: 8223
diff changeset
   560
                    }
141b22c7e7b2 7021927: javac: regression in performance
ksrini
parents: 8223
diff changeset
   561
                    zipRandomFile.seek(start + sz);
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   562
                    zipRandomFile.readFully(zipDir, 2, zipDir.length - 2);
06bc494ca11e Initial load
duke
parents:
diff changeset
   563
                    return;
06bc494ca11e Initial load
duke
parents:
diff changeset
   564
                } else {
06bc494ca11e Initial load
duke
parents:
diff changeset
   565
                    endbufend = endbufpos + 21;
06bc494ca11e Initial load
duke
parents:
diff changeset
   566
                }
06bc494ca11e Initial load
duke
parents:
diff changeset
   567
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
   568
            throw new ZipException("cannot read zip file");
06bc494ca11e Initial load
duke
parents:
diff changeset
   569
        }
1205
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
   570
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   571
        private void buildIndex() throws IOException {
06bc494ca11e Initial load
duke
parents:
diff changeset
   572
            int entryCount = get2ByteLittleEndian(zipDir, 0);
06bc494ca11e Initial load
duke
parents:
diff changeset
   573
06bc494ca11e Initial load
duke
parents:
diff changeset
   574
            // Add each of the files
06bc494ca11e Initial load
duke
parents:
diff changeset
   575
            if (entryCount > 0) {
13076
cb848b70d7f4 7177701: error: Filling jar message during javax/imageio/metadata/IIOMetadataFormatImpl compilation
mcimadamore
parents: 8837
diff changeset
   576
                directories = new LinkedHashMap<RelativeDirectory, DirectoryEntry>();
810
e4b6a6d206e6 6714365: refactor JavacFileManager to move nested classes to top level
jjg
parents: 731
diff changeset
   577
                ArrayList<Entry> entryList = new ArrayList<Entry>();
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   578
                int pos = 2;
06bc494ca11e Initial load
duke
parents:
diff changeset
   579
                for (int i = 0; i < entryCount; i++) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   580
                    pos = readEntry(pos, entryList, directories);
06bc494ca11e Initial load
duke
parents:
diff changeset
   581
                }
06bc494ca11e Initial load
duke
parents:
diff changeset
   582
06bc494ca11e Initial load
duke
parents:
diff changeset
   583
                // Add the accumulated dirs into the same list
1205
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
   584
                for (RelativeDirectory d: directories.keySet()) {
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
   585
                    // use shared RelativeDirectory objects for parent dirs
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
   586
                    RelativeDirectory parent = getRelativeDirectory(d.dirname().getPath());
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
   587
                    String file = d.basename();
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
   588
                    Entry zipFileIndexEntry = new Entry(parent, file);
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   589
                    zipFileIndexEntry.isDir = true;
06bc494ca11e Initial load
duke
parents:
diff changeset
   590
                    entryList.add(zipFileIndexEntry);
06bc494ca11e Initial load
duke
parents:
diff changeset
   591
                }
06bc494ca11e Initial load
duke
parents:
diff changeset
   592
810
e4b6a6d206e6 6714365: refactor JavacFileManager to move nested classes to top level
jjg
parents: 731
diff changeset
   593
                entries = entryList.toArray(new Entry[entryList.size()]);
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   594
                Arrays.sort(entries);
06bc494ca11e Initial load
duke
parents:
diff changeset
   595
            } else {
06bc494ca11e Initial load
duke
parents:
diff changeset
   596
                cleanupState();
06bc494ca11e Initial load
duke
parents:
diff changeset
   597
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
   598
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   599
810
e4b6a6d206e6 6714365: refactor JavacFileManager to move nested classes to top level
jjg
parents: 731
diff changeset
   600
        private int readEntry(int pos, List<Entry> entryList,
1205
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
   601
                Map<RelativeDirectory, DirectoryEntry> directories) throws IOException {
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   602
            if (get4ByteLittleEndian(zipDir, pos) != 0x02014b50) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   603
                throw new ZipException("cannot read zip file entry");
06bc494ca11e Initial load
duke
parents:
diff changeset
   604
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
   605
06bc494ca11e Initial load
duke
parents:
diff changeset
   606
            int dirStart = pos + 46;
06bc494ca11e Initial load
duke
parents:
diff changeset
   607
            int fileStart = dirStart;
06bc494ca11e Initial load
duke
parents:
diff changeset
   608
            int fileEnd = fileStart + get2ByteLittleEndian(zipDir, pos + 28);
06bc494ca11e Initial load
duke
parents:
diff changeset
   609
06bc494ca11e Initial load
duke
parents:
diff changeset
   610
            if (zipFileIndex.symbolFilePrefixLength != 0 &&
06bc494ca11e Initial load
duke
parents:
diff changeset
   611
                    ((fileEnd - fileStart) >= symbolFilePrefixLength)) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   612
                dirStart += zipFileIndex.symbolFilePrefixLength;
06bc494ca11e Initial load
duke
parents:
diff changeset
   613
               fileStart += zipFileIndex.symbolFilePrefixLength;
06bc494ca11e Initial load
duke
parents:
diff changeset
   614
            }
1205
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
   615
            // Force any '\' to '/'. Keep the position of the last separator.
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   616
            for (int index = fileStart; index < fileEnd; index++) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   617
                byte nextByte = zipDir[index];
1205
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
   618
                if (nextByte == (byte)'\\') {
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
   619
                    zipDir[index] = (byte)'/';
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
   620
                    fileStart = index + 1;
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
   621
                } else if (nextByte == (byte)'/') {
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   622
                    fileStart = index + 1;
06bc494ca11e Initial load
duke
parents:
diff changeset
   623
                }
06bc494ca11e Initial load
duke
parents:
diff changeset
   624
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
   625
1205
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
   626
            RelativeDirectory directory = null;
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   627
            if (fileStart == dirStart)
1205
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
   628
                directory = getRelativeDirectory("");
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   629
            else if (lastDir != null && lastLen == fileStart - dirStart - 1) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   630
                int index = lastLen - 1;
06bc494ca11e Initial load
duke
parents:
diff changeset
   631
                while (zipDir[lastStart + index] == zipDir[dirStart + index]) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   632
                    if (index == 0) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   633
                        directory = lastDir;
06bc494ca11e Initial load
duke
parents:
diff changeset
   634
                        break;
06bc494ca11e Initial load
duke
parents:
diff changeset
   635
                    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   636
                    index--;
06bc494ca11e Initial load
duke
parents:
diff changeset
   637
                }
06bc494ca11e Initial load
duke
parents:
diff changeset
   638
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
   639
06bc494ca11e Initial load
duke
parents:
diff changeset
   640
            // Sub directories
06bc494ca11e Initial load
duke
parents:
diff changeset
   641
            if (directory == null) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   642
                lastStart = dirStart;
06bc494ca11e Initial load
duke
parents:
diff changeset
   643
                lastLen = fileStart - dirStart - 1;
06bc494ca11e Initial load
duke
parents:
diff changeset
   644
1205
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
   645
                directory = getRelativeDirectory(new String(zipDir, dirStart, lastLen, "UTF-8"));
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   646
                lastDir = directory;
06bc494ca11e Initial load
duke
parents:
diff changeset
   647
06bc494ca11e Initial load
duke
parents:
diff changeset
   648
                // Enter also all the parent directories
1205
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
   649
                RelativeDirectory tempDirectory = directory;
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   650
06bc494ca11e Initial load
duke
parents:
diff changeset
   651
                while (directories.get(tempDirectory) == null) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   652
                    directories.put(tempDirectory, new DirectoryEntry(tempDirectory, zipFileIndex));
1205
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
   653
                    if (tempDirectory.path.indexOf("/") == tempDirectory.path.length() - 1)
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   654
                        break;
1205
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
   655
                    else {
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
   656
                        // use shared RelativeDirectory objects for parent dirs
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
   657
                        tempDirectory = getRelativeDirectory(tempDirectory.dirname().getPath());
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
   658
                    }
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   659
                }
06bc494ca11e Initial load
duke
parents:
diff changeset
   660
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
   661
            else {
06bc494ca11e Initial load
duke
parents:
diff changeset
   662
                if (directories.get(directory) == null) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   663
                    directories.put(directory, new DirectoryEntry(directory, zipFileIndex));
06bc494ca11e Initial load
duke
parents:
diff changeset
   664
                }
06bc494ca11e Initial load
duke
parents:
diff changeset
   665
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
   666
06bc494ca11e Initial load
duke
parents:
diff changeset
   667
            // For each dir create also a file
06bc494ca11e Initial load
duke
parents:
diff changeset
   668
            if (fileStart != fileEnd) {
810
e4b6a6d206e6 6714365: refactor JavacFileManager to move nested classes to top level
jjg
parents: 731
diff changeset
   669
                Entry entry = new Entry(directory,
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   670
                        new String(zipDir, fileStart, fileEnd - fileStart, "UTF-8"));
06bc494ca11e Initial load
duke
parents:
diff changeset
   671
06bc494ca11e Initial load
duke
parents:
diff changeset
   672
                entry.setNativeTime(get4ByteLittleEndian(zipDir, pos + 12));
06bc494ca11e Initial load
duke
parents:
diff changeset
   673
                entry.compressedSize = get4ByteLittleEndian(zipDir, pos + 20);
06bc494ca11e Initial load
duke
parents:
diff changeset
   674
                entry.size = get4ByteLittleEndian(zipDir, pos + 24);
06bc494ca11e Initial load
duke
parents:
diff changeset
   675
                entry.offset = get4ByteLittleEndian(zipDir, pos + 42);
06bc494ca11e Initial load
duke
parents:
diff changeset
   676
                entryList.add(entry);
06bc494ca11e Initial load
duke
parents:
diff changeset
   677
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
   678
06bc494ca11e Initial load
duke
parents:
diff changeset
   679
            return pos + 46 +
06bc494ca11e Initial load
duke
parents:
diff changeset
   680
                    get2ByteLittleEndian(zipDir, pos + 28) +
06bc494ca11e Initial load
duke
parents:
diff changeset
   681
                    get2ByteLittleEndian(zipDir, pos + 30) +
06bc494ca11e Initial load
duke
parents:
diff changeset
   682
                    get2ByteLittleEndian(zipDir, pos + 32);
06bc494ca11e Initial load
duke
parents:
diff changeset
   683
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   684
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   685
06bc494ca11e Initial load
duke
parents:
diff changeset
   686
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   687
     * Returns the last modified timestamp of a zip file.
06bc494ca11e Initial load
duke
parents:
diff changeset
   688
     * @return long
06bc494ca11e Initial load
duke
parents:
diff changeset
   689
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   690
    public long getZipFileLastModified() throws IOException {
8223
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
   691
        synchronized (this) {
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   692
            checkIndex();
06bc494ca11e Initial load
duke
parents:
diff changeset
   693
            return zipFileLastModified;
06bc494ca11e Initial load
duke
parents:
diff changeset
   694
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   695
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   696
06bc494ca11e Initial load
duke
parents:
diff changeset
   697
    /** ------------------------------------------------------------------------
06bc494ca11e Initial load
duke
parents:
diff changeset
   698
     *  DirectoryEntry class
06bc494ca11e Initial load
duke
parents:
diff changeset
   699
     * -------------------------------------------------------------------------*/
810
e4b6a6d206e6 6714365: refactor JavacFileManager to move nested classes to top level
jjg
parents: 731
diff changeset
   700
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   701
    static class DirectoryEntry {
06bc494ca11e Initial load
duke
parents:
diff changeset
   702
        private boolean filesInited;
06bc494ca11e Initial load
duke
parents:
diff changeset
   703
        private boolean directoriesInited;
06bc494ca11e Initial load
duke
parents:
diff changeset
   704
        private boolean zipFileEntriesInited;
06bc494ca11e Initial load
duke
parents:
diff changeset
   705
        private boolean entriesInited;
06bc494ca11e Initial load
duke
parents:
diff changeset
   706
06bc494ca11e Initial load
duke
parents:
diff changeset
   707
        private long writtenOffsetOffset = 0;
06bc494ca11e Initial load
duke
parents:
diff changeset
   708
1205
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
   709
        private RelativeDirectory dirName;
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   710
06bc494ca11e Initial load
duke
parents:
diff changeset
   711
        private com.sun.tools.javac.util.List<String> zipFileEntriesFiles = com.sun.tools.javac.util.List.<String>nil();
06bc494ca11e Initial load
duke
parents:
diff changeset
   712
        private com.sun.tools.javac.util.List<String> zipFileEntriesDirectories = com.sun.tools.javac.util.List.<String>nil();
810
e4b6a6d206e6 6714365: refactor JavacFileManager to move nested classes to top level
jjg
parents: 731
diff changeset
   713
        private com.sun.tools.javac.util.List<Entry>  zipFileEntries = com.sun.tools.javac.util.List.<Entry>nil();
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   714
810
e4b6a6d206e6 6714365: refactor JavacFileManager to move nested classes to top level
jjg
parents: 731
diff changeset
   715
        private List<Entry> entries = new ArrayList<Entry>();
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   716
06bc494ca11e Initial load
duke
parents:
diff changeset
   717
        private ZipFileIndex zipFileIndex;
06bc494ca11e Initial load
duke
parents:
diff changeset
   718
06bc494ca11e Initial load
duke
parents:
diff changeset
   719
        private int numEntries;
06bc494ca11e Initial load
duke
parents:
diff changeset
   720
1205
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
   721
        DirectoryEntry(RelativeDirectory dirName, ZipFileIndex index) {
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
   722
            filesInited = false;
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   723
            directoriesInited = false;
06bc494ca11e Initial load
duke
parents:
diff changeset
   724
            entriesInited = false;
06bc494ca11e Initial load
duke
parents:
diff changeset
   725
1205
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
   726
            this.dirName = dirName;
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   727
            this.zipFileIndex = index;
06bc494ca11e Initial load
duke
parents:
diff changeset
   728
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   729
06bc494ca11e Initial load
duke
parents:
diff changeset
   730
        private com.sun.tools.javac.util.List<String> getFiles() {
1205
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
   731
            if (!filesInited) {
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
   732
                initEntries();
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
   733
                for (Entry e : entries) {
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
   734
                    if (!e.isDir) {
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
   735
                        zipFileEntriesFiles = zipFileEntriesFiles.append(e.name);
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
   736
                    }
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
   737
                }
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
   738
                filesInited = true;
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   739
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
   740
            return zipFileEntriesFiles;
06bc494ca11e Initial load
duke
parents:
diff changeset
   741
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   742
06bc494ca11e Initial load
duke
parents:
diff changeset
   743
        private com.sun.tools.javac.util.List<String> getDirectories() {
1205
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
   744
            if (!directoriesInited) {
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
   745
                initEntries();
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
   746
                for (Entry e : entries) {
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
   747
                    if (e.isDir) {
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
   748
                        zipFileEntriesDirectories = zipFileEntriesDirectories.append(e.name);
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
   749
                    }
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
   750
                }
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
   751
                directoriesInited = true;
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   752
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
   753
            return zipFileEntriesDirectories;
06bc494ca11e Initial load
duke
parents:
diff changeset
   754
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   755
810
e4b6a6d206e6 6714365: refactor JavacFileManager to move nested classes to top level
jjg
parents: 731
diff changeset
   756
        private com.sun.tools.javac.util.List<Entry> getEntries() {
1205
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
   757
            if (!zipFileEntriesInited) {
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
   758
                initEntries();
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
   759
                zipFileEntries = com.sun.tools.javac.util.List.nil();
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
   760
                for (Entry zfie : entries) {
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
   761
                    zipFileEntries = zipFileEntries.append(zfie);
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
   762
                }
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
   763
                zipFileEntriesInited = true;
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   764
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
   765
            return zipFileEntries;
06bc494ca11e Initial load
duke
parents:
diff changeset
   766
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   767
810
e4b6a6d206e6 6714365: refactor JavacFileManager to move nested classes to top level
jjg
parents: 731
diff changeset
   768
        private Entry getEntry(String rootName) {
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   769
            initEntries();
810
e4b6a6d206e6 6714365: refactor JavacFileManager to move nested classes to top level
jjg
parents: 731
diff changeset
   770
            int index = Collections.binarySearch(entries, new Entry(dirName, rootName));
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   771
            if (index < 0) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   772
                return null;
06bc494ca11e Initial load
duke
parents:
diff changeset
   773
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
   774
06bc494ca11e Initial load
duke
parents:
diff changeset
   775
            return entries.get(index);
06bc494ca11e Initial load
duke
parents:
diff changeset
   776
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   777
06bc494ca11e Initial load
duke
parents:
diff changeset
   778
        private void initEntries() {
06bc494ca11e Initial load
duke
parents:
diff changeset
   779
            if (entriesInited) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   780
                return;
06bc494ca11e Initial load
duke
parents:
diff changeset
   781
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
   782
06bc494ca11e Initial load
duke
parents:
diff changeset
   783
            if (!zipFileIndex.readFromIndex) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   784
                int from = -Arrays.binarySearch(zipFileIndex.entries,
810
e4b6a6d206e6 6714365: refactor JavacFileManager to move nested classes to top level
jjg
parents: 731
diff changeset
   785
                        new Entry(dirName, ZipFileIndex.MIN_CHAR)) - 1;
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   786
                int to = -Arrays.binarySearch(zipFileIndex.entries,
810
e4b6a6d206e6 6714365: refactor JavacFileManager to move nested classes to top level
jjg
parents: 731
diff changeset
   787
                        new Entry(dirName, MAX_CHAR)) - 1;
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   788
06bc494ca11e Initial load
duke
parents:
diff changeset
   789
                for (int i = from; i < to; i++) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   790
                    entries.add(zipFileIndex.entries[i]);
06bc494ca11e Initial load
duke
parents:
diff changeset
   791
                }
06bc494ca11e Initial load
duke
parents:
diff changeset
   792
            } else {
06bc494ca11e Initial load
duke
parents:
diff changeset
   793
                File indexFile = zipFileIndex.getIndexFile();
06bc494ca11e Initial load
duke
parents:
diff changeset
   794
                if (indexFile != null) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   795
                    RandomAccessFile raf = null;
06bc494ca11e Initial load
duke
parents:
diff changeset
   796
                    try {
06bc494ca11e Initial load
duke
parents:
diff changeset
   797
                        raf = new RandomAccessFile(indexFile, "r");
06bc494ca11e Initial load
duke
parents:
diff changeset
   798
                        raf.seek(writtenOffsetOffset);
06bc494ca11e Initial load
duke
parents:
diff changeset
   799
06bc494ca11e Initial load
duke
parents:
diff changeset
   800
                        for (int nFiles = 0; nFiles < numEntries; nFiles++) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   801
                            // Read the name bytes
06bc494ca11e Initial load
duke
parents:
diff changeset
   802
                            int zfieNameBytesLen = raf.readInt();
06bc494ca11e Initial load
duke
parents:
diff changeset
   803
                            byte [] zfieNameBytes = new byte[zfieNameBytesLen];
06bc494ca11e Initial load
duke
parents:
diff changeset
   804
                            raf.read(zfieNameBytes);
06bc494ca11e Initial load
duke
parents:
diff changeset
   805
                            String eName = new String(zfieNameBytes, "UTF-8");
06bc494ca11e Initial load
duke
parents:
diff changeset
   806
06bc494ca11e Initial load
duke
parents:
diff changeset
   807
                            // Read isDir
06bc494ca11e Initial load
duke
parents:
diff changeset
   808
                            boolean eIsDir = raf.readByte() == (byte)0 ? false : true;
06bc494ca11e Initial load
duke
parents:
diff changeset
   809
06bc494ca11e Initial load
duke
parents:
diff changeset
   810
                            // Read offset of bytes in the real Jar/Zip file
06bc494ca11e Initial load
duke
parents:
diff changeset
   811
                            int eOffset = raf.readInt();
06bc494ca11e Initial load
duke
parents:
diff changeset
   812
06bc494ca11e Initial load
duke
parents:
diff changeset
   813
                            // Read size of the file in the real Jar/Zip file
06bc494ca11e Initial load
duke
parents:
diff changeset
   814
                            int eSize = raf.readInt();
06bc494ca11e Initial load
duke
parents:
diff changeset
   815
06bc494ca11e Initial load
duke
parents:
diff changeset
   816
                            // Read compressed size of the file in the real Jar/Zip file
06bc494ca11e Initial load
duke
parents:
diff changeset
   817
                            int eCsize = raf.readInt();
06bc494ca11e Initial load
duke
parents:
diff changeset
   818
06bc494ca11e Initial load
duke
parents:
diff changeset
   819
                            // Read java time stamp of the file in the real Jar/Zip file
06bc494ca11e Initial load
duke
parents:
diff changeset
   820
                            long eJavaTimestamp = raf.readLong();
06bc494ca11e Initial load
duke
parents:
diff changeset
   821
810
e4b6a6d206e6 6714365: refactor JavacFileManager to move nested classes to top level
jjg
parents: 731
diff changeset
   822
                            Entry rfie = new Entry(dirName, eName);
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   823
                            rfie.isDir = eIsDir;
06bc494ca11e Initial load
duke
parents:
diff changeset
   824
                            rfie.offset = eOffset;
06bc494ca11e Initial load
duke
parents:
diff changeset
   825
                            rfie.size = eSize;
06bc494ca11e Initial load
duke
parents:
diff changeset
   826
                            rfie.compressedSize = eCsize;
06bc494ca11e Initial load
duke
parents:
diff changeset
   827
                            rfie.javatime = eJavaTimestamp;
06bc494ca11e Initial load
duke
parents:
diff changeset
   828
                            entries.add(rfie);
06bc494ca11e Initial load
duke
parents:
diff changeset
   829
                        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   830
                    } catch (Throwable t) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   831
                        // Do nothing
06bc494ca11e Initial load
duke
parents:
diff changeset
   832
                    } finally {
06bc494ca11e Initial load
duke
parents:
diff changeset
   833
                        try {
4418
7c5fe46dd6c5 6907660: stupid typo in ZipFileIndex guarantees NPE
jjg
parents: 4073
diff changeset
   834
                            if (raf != null) {
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   835
                                raf.close();
06bc494ca11e Initial load
duke
parents:
diff changeset
   836
                            }
06bc494ca11e Initial load
duke
parents:
diff changeset
   837
                        } catch (Throwable t) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   838
                            // Do nothing
06bc494ca11e Initial load
duke
parents:
diff changeset
   839
                        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   840
                    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   841
                }
06bc494ca11e Initial load
duke
parents:
diff changeset
   842
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
   843
06bc494ca11e Initial load
duke
parents:
diff changeset
   844
            entriesInited = true;
06bc494ca11e Initial load
duke
parents:
diff changeset
   845
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   846
810
e4b6a6d206e6 6714365: refactor JavacFileManager to move nested classes to top level
jjg
parents: 731
diff changeset
   847
        List<Entry> getEntriesAsCollection() {
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   848
            initEntries();
06bc494ca11e Initial load
duke
parents:
diff changeset
   849
06bc494ca11e Initial load
duke
parents:
diff changeset
   850
            return entries;
06bc494ca11e Initial load
duke
parents:
diff changeset
   851
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   852
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   853
06bc494ca11e Initial load
duke
parents:
diff changeset
   854
    private boolean readIndex() {
06bc494ca11e Initial load
duke
parents:
diff changeset
   855
        if (triedToReadIndex || !usePreindexedCache) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   856
            return false;
06bc494ca11e Initial load
duke
parents:
diff changeset
   857
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   858
06bc494ca11e Initial load
duke
parents:
diff changeset
   859
        boolean ret = false;
8223
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
   860
        synchronized (this) {
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   861
            triedToReadIndex = true;
06bc494ca11e Initial load
duke
parents:
diff changeset
   862
            RandomAccessFile raf = null;
06bc494ca11e Initial load
duke
parents:
diff changeset
   863
            try {
06bc494ca11e Initial load
duke
parents:
diff changeset
   864
                File indexFileName = getIndexFile();
06bc494ca11e Initial load
duke
parents:
diff changeset
   865
                raf = new RandomAccessFile(indexFileName, "r");
06bc494ca11e Initial load
duke
parents:
diff changeset
   866
06bc494ca11e Initial load
duke
parents:
diff changeset
   867
                long fileStamp = raf.readLong();
06bc494ca11e Initial load
duke
parents:
diff changeset
   868
                if (zipFile.lastModified() != fileStamp) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   869
                    ret = false;
06bc494ca11e Initial load
duke
parents:
diff changeset
   870
                } else {
13076
cb848b70d7f4 7177701: error: Filling jar message during javax/imageio/metadata/IIOMetadataFormatImpl compilation
mcimadamore
parents: 8837
diff changeset
   871
                    directories = new LinkedHashMap<RelativeDirectory, DirectoryEntry>();
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   872
                    int numDirs = raf.readInt();
06bc494ca11e Initial load
duke
parents:
diff changeset
   873
                    for (int nDirs = 0; nDirs < numDirs; nDirs++) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   874
                        int dirNameBytesLen = raf.readInt();
06bc494ca11e Initial load
duke
parents:
diff changeset
   875
                        byte [] dirNameBytes = new byte[dirNameBytesLen];
06bc494ca11e Initial load
duke
parents:
diff changeset
   876
                        raf.read(dirNameBytes);
06bc494ca11e Initial load
duke
parents:
diff changeset
   877
1205
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
   878
                        RelativeDirectory dirNameStr = getRelativeDirectory(new String(dirNameBytes, "UTF-8"));
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   879
                        DirectoryEntry de = new DirectoryEntry(dirNameStr, this);
06bc494ca11e Initial load
duke
parents:
diff changeset
   880
                        de.numEntries = raf.readInt();
06bc494ca11e Initial load
duke
parents:
diff changeset
   881
                        de.writtenOffsetOffset = raf.readLong();
06bc494ca11e Initial load
duke
parents:
diff changeset
   882
                        directories.put(dirNameStr, de);
06bc494ca11e Initial load
duke
parents:
diff changeset
   883
                    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   884
                    ret = true;
06bc494ca11e Initial load
duke
parents:
diff changeset
   885
                    zipFileLastModified = fileStamp;
06bc494ca11e Initial load
duke
parents:
diff changeset
   886
                }
06bc494ca11e Initial load
duke
parents:
diff changeset
   887
            } catch (Throwable t) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   888
                // Do nothing
06bc494ca11e Initial load
duke
parents:
diff changeset
   889
            } finally {
06bc494ca11e Initial load
duke
parents:
diff changeset
   890
                if (raf != null) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   891
                    try {
06bc494ca11e Initial load
duke
parents:
diff changeset
   892
                        raf.close();
06bc494ca11e Initial load
duke
parents:
diff changeset
   893
                    } catch (Throwable tt) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   894
                        // Do nothing
06bc494ca11e Initial load
duke
parents:
diff changeset
   895
                    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   896
                }
06bc494ca11e Initial load
duke
parents:
diff changeset
   897
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
   898
            if (ret == true) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   899
                readFromIndex = true;
06bc494ca11e Initial load
duke
parents:
diff changeset
   900
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
   901
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   902
06bc494ca11e Initial load
duke
parents:
diff changeset
   903
        return ret;
06bc494ca11e Initial load
duke
parents:
diff changeset
   904
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   905
06bc494ca11e Initial load
duke
parents:
diff changeset
   906
    private boolean writeIndex() {
06bc494ca11e Initial load
duke
parents:
diff changeset
   907
        boolean ret = false;
06bc494ca11e Initial load
duke
parents:
diff changeset
   908
        if (readFromIndex || !usePreindexedCache) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   909
            return true;
06bc494ca11e Initial load
duke
parents:
diff changeset
   910
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   911
06bc494ca11e Initial load
duke
parents:
diff changeset
   912
        if (!writeIndex) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   913
            return true;
06bc494ca11e Initial load
duke
parents:
diff changeset
   914
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   915
06bc494ca11e Initial load
duke
parents:
diff changeset
   916
        File indexFile = getIndexFile();
06bc494ca11e Initial load
duke
parents:
diff changeset
   917
        if (indexFile == null) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   918
            return false;
06bc494ca11e Initial load
duke
parents:
diff changeset
   919
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   920
06bc494ca11e Initial load
duke
parents:
diff changeset
   921
        RandomAccessFile raf = null;
06bc494ca11e Initial load
duke
parents:
diff changeset
   922
        long writtenSoFar = 0;
06bc494ca11e Initial load
duke
parents:
diff changeset
   923
        try {
06bc494ca11e Initial load
duke
parents:
diff changeset
   924
            raf = new RandomAccessFile(indexFile, "rw");
06bc494ca11e Initial load
duke
parents:
diff changeset
   925
06bc494ca11e Initial load
duke
parents:
diff changeset
   926
            raf.writeLong(zipFileLastModified);
06bc494ca11e Initial load
duke
parents:
diff changeset
   927
            writtenSoFar += 8;
06bc494ca11e Initial load
duke
parents:
diff changeset
   928
06bc494ca11e Initial load
duke
parents:
diff changeset
   929
            List<DirectoryEntry> directoriesToWrite = new ArrayList<DirectoryEntry>();
1205
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
   930
            Map<RelativeDirectory, Long> offsets = new HashMap<RelativeDirectory, Long>();
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   931
            raf.writeInt(directories.keySet().size());
06bc494ca11e Initial load
duke
parents:
diff changeset
   932
            writtenSoFar += 4;
06bc494ca11e Initial load
duke
parents:
diff changeset
   933
1205
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
   934
            for (RelativeDirectory dirName: directories.keySet()) {
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   935
                DirectoryEntry dirEntry = directories.get(dirName);
06bc494ca11e Initial load
duke
parents:
diff changeset
   936
06bc494ca11e Initial load
duke
parents:
diff changeset
   937
                directoriesToWrite.add(dirEntry);
06bc494ca11e Initial load
duke
parents:
diff changeset
   938
06bc494ca11e Initial load
duke
parents:
diff changeset
   939
                // Write the dir name bytes
1205
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
   940
                byte [] dirNameBytes = dirName.getPath().getBytes("UTF-8");
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   941
                int dirNameBytesLen = dirNameBytes.length;
06bc494ca11e Initial load
duke
parents:
diff changeset
   942
                raf.writeInt(dirNameBytesLen);
06bc494ca11e Initial load
duke
parents:
diff changeset
   943
                writtenSoFar += 4;
06bc494ca11e Initial load
duke
parents:
diff changeset
   944
06bc494ca11e Initial load
duke
parents:
diff changeset
   945
                raf.write(dirNameBytes);
06bc494ca11e Initial load
duke
parents:
diff changeset
   946
                writtenSoFar += dirNameBytesLen;
06bc494ca11e Initial load
duke
parents:
diff changeset
   947
06bc494ca11e Initial load
duke
parents:
diff changeset
   948
                // Write the number of files in the dir
1789
7ac8c0815000 6765045: Remove rawtypes warnings from langtools
mcimadamore
parents: 1205
diff changeset
   949
                List<Entry> dirEntries = dirEntry.getEntriesAsCollection();
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   950
                raf.writeInt(dirEntries.size());
06bc494ca11e Initial load
duke
parents:
diff changeset
   951
                writtenSoFar += 4;
06bc494ca11e Initial load
duke
parents:
diff changeset
   952
06bc494ca11e Initial load
duke
parents:
diff changeset
   953
                offsets.put(dirName, new Long(writtenSoFar));
06bc494ca11e Initial load
duke
parents:
diff changeset
   954
06bc494ca11e Initial load
duke
parents:
diff changeset
   955
                // Write the offset of the file's data in the dir
06bc494ca11e Initial load
duke
parents:
diff changeset
   956
                dirEntry.writtenOffsetOffset = 0L;
06bc494ca11e Initial load
duke
parents:
diff changeset
   957
                raf.writeLong(0L);
06bc494ca11e Initial load
duke
parents:
diff changeset
   958
                writtenSoFar += 8;
06bc494ca11e Initial load
duke
parents:
diff changeset
   959
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
   960
06bc494ca11e Initial load
duke
parents:
diff changeset
   961
            for (DirectoryEntry de : directoriesToWrite) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   962
                // Fix up the offset in the directory table
06bc494ca11e Initial load
duke
parents:
diff changeset
   963
                long currFP = raf.getFilePointer();
06bc494ca11e Initial load
duke
parents:
diff changeset
   964
06bc494ca11e Initial load
duke
parents:
diff changeset
   965
                long offsetOffset = offsets.get(de.dirName).longValue();
06bc494ca11e Initial load
duke
parents:
diff changeset
   966
                raf.seek(offsetOffset);
06bc494ca11e Initial load
duke
parents:
diff changeset
   967
                raf.writeLong(writtenSoFar);
06bc494ca11e Initial load
duke
parents:
diff changeset
   968
06bc494ca11e Initial load
duke
parents:
diff changeset
   969
                raf.seek(currFP);
06bc494ca11e Initial load
duke
parents:
diff changeset
   970
06bc494ca11e Initial load
duke
parents:
diff changeset
   971
                // Now write each of the files in the DirectoryEntry
8223
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
   972
                List<Entry> list = de.getEntriesAsCollection();
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
   973
                for (Entry zfie : list) {
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   974
                    // Write the name bytes
06bc494ca11e Initial load
duke
parents:
diff changeset
   975
                    byte [] zfieNameBytes = zfie.name.getBytes("UTF-8");
06bc494ca11e Initial load
duke
parents:
diff changeset
   976
                    int zfieNameBytesLen = zfieNameBytes.length;
06bc494ca11e Initial load
duke
parents:
diff changeset
   977
                    raf.writeInt(zfieNameBytesLen);
06bc494ca11e Initial load
duke
parents:
diff changeset
   978
                    writtenSoFar += 4;
06bc494ca11e Initial load
duke
parents:
diff changeset
   979
                    raf.write(zfieNameBytes);
06bc494ca11e Initial load
duke
parents:
diff changeset
   980
                    writtenSoFar += zfieNameBytesLen;
06bc494ca11e Initial load
duke
parents:
diff changeset
   981
06bc494ca11e Initial load
duke
parents:
diff changeset
   982
                    // Write isDir
06bc494ca11e Initial load
duke
parents:
diff changeset
   983
                    raf.writeByte(zfie.isDir ? (byte)1 : (byte)0);
06bc494ca11e Initial load
duke
parents:
diff changeset
   984
                    writtenSoFar += 1;
06bc494ca11e Initial load
duke
parents:
diff changeset
   985
06bc494ca11e Initial load
duke
parents:
diff changeset
   986
                    // Write offset of bytes in the real Jar/Zip file
06bc494ca11e Initial load
duke
parents:
diff changeset
   987
                    raf.writeInt(zfie.offset);
06bc494ca11e Initial load
duke
parents:
diff changeset
   988
                    writtenSoFar += 4;
06bc494ca11e Initial load
duke
parents:
diff changeset
   989
06bc494ca11e Initial load
duke
parents:
diff changeset
   990
                    // Write size of the file in the real Jar/Zip file
06bc494ca11e Initial load
duke
parents:
diff changeset
   991
                    raf.writeInt(zfie.size);
06bc494ca11e Initial load
duke
parents:
diff changeset
   992
                    writtenSoFar += 4;
06bc494ca11e Initial load
duke
parents:
diff changeset
   993
06bc494ca11e Initial load
duke
parents:
diff changeset
   994
                    // Write compressed size of the file in the real Jar/Zip file
06bc494ca11e Initial load
duke
parents:
diff changeset
   995
                    raf.writeInt(zfie.compressedSize);
06bc494ca11e Initial load
duke
parents:
diff changeset
   996
                    writtenSoFar += 4;
06bc494ca11e Initial load
duke
parents:
diff changeset
   997
06bc494ca11e Initial load
duke
parents:
diff changeset
   998
                    // Write java time stamp of the file in the real Jar/Zip file
06bc494ca11e Initial load
duke
parents:
diff changeset
   999
                    raf.writeLong(zfie.getLastModified());
06bc494ca11e Initial load
duke
parents:
diff changeset
  1000
                    writtenSoFar += 8;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1001
                }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1002
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1003
        } catch (Throwable t) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1004
            // Do nothing
06bc494ca11e Initial load
duke
parents:
diff changeset
  1005
        } finally {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1006
            try {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1007
                if (raf != null) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1008
                    raf.close();
06bc494ca11e Initial load
duke
parents:
diff changeset
  1009
                }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1010
            } catch(IOException ioe) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1011
                // Do nothing
06bc494ca11e Initial load
duke
parents:
diff changeset
  1012
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1013
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1014
06bc494ca11e Initial load
duke
parents:
diff changeset
  1015
        return ret;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1016
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1017
06bc494ca11e Initial load
duke
parents:
diff changeset
  1018
    public boolean writeZipIndex() {
8223
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
  1019
        synchronized (this) {
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1020
            return writeIndex();
06bc494ca11e Initial load
duke
parents:
diff changeset
  1021
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1022
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1023
06bc494ca11e Initial load
duke
parents:
diff changeset
  1024
    private File getIndexFile() {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1025
        if (zipIndexFile == null) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1026
            if (zipFile == null) {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1027
                return null;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1028
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1029
06bc494ca11e Initial load
duke
parents:
diff changeset
  1030
            zipIndexFile = new File((preindexedCacheLocation == null ? "" : preindexedCacheLocation) +
06bc494ca11e Initial load
duke
parents:
diff changeset
  1031
                    zipFile.getName() + ".index");
06bc494ca11e Initial load
duke
parents:
diff changeset
  1032
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1033
06bc494ca11e Initial load
duke
parents:
diff changeset
  1034
        return zipIndexFile;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1035
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
  1036
06bc494ca11e Initial load
duke
parents:
diff changeset
  1037
    public File getZipFile() {
06bc494ca11e Initial load
duke
parents:
diff changeset
  1038
        return zipFile;
06bc494ca11e Initial load
duke
parents:
diff changeset
  1039
    }
810
e4b6a6d206e6 6714365: refactor JavacFileManager to move nested classes to top level
jjg
parents: 731
diff changeset
  1040
4073
9788f4549740 6838467: JSR199 FileObjects don't obey general contract of equals.
jjg
parents: 3380
diff changeset
  1041
    File getAbsoluteFile() {
9788f4549740 6838467: JSR199 FileObjects don't obey general contract of equals.
jjg
parents: 3380
diff changeset
  1042
        File absFile = (absFileRef == null ? null : absFileRef.get());
9788f4549740 6838467: JSR199 FileObjects don't obey general contract of equals.
jjg
parents: 3380
diff changeset
  1043
        if (absFile == null) {
9788f4549740 6838467: JSR199 FileObjects don't obey general contract of equals.
jjg
parents: 3380
diff changeset
  1044
            absFile = zipFile.getAbsoluteFile();
9788f4549740 6838467: JSR199 FileObjects don't obey general contract of equals.
jjg
parents: 3380
diff changeset
  1045
            absFileRef = new SoftReference<File>(absFile);
9788f4549740 6838467: JSR199 FileObjects don't obey general contract of equals.
jjg
parents: 3380
diff changeset
  1046
        }
9788f4549740 6838467: JSR199 FileObjects don't obey general contract of equals.
jjg
parents: 3380
diff changeset
  1047
        return absFile;
9788f4549740 6838467: JSR199 FileObjects don't obey general contract of equals.
jjg
parents: 3380
diff changeset
  1048
    }
9788f4549740 6838467: JSR199 FileObjects don't obey general contract of equals.
jjg
parents: 3380
diff changeset
  1049
1205
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
  1050
    private RelativeDirectory getRelativeDirectory(String path) {
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
  1051
        RelativeDirectory rd;
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
  1052
        SoftReference<RelativeDirectory> ref = relativeDirectoryCache.get(path);
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
  1053
        if (ref != null) {
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
  1054
            rd = ref.get();
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
  1055
            if (rd != null)
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
  1056
                return rd;
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
  1057
        }
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
  1058
        rd = new RelativeDirectory(path);
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
  1059
        relativeDirectoryCache.put(path, new SoftReference<RelativeDirectory>(rd));
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
  1060
        return rd;
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
  1061
    }
810
e4b6a6d206e6 6714365: refactor JavacFileManager to move nested classes to top level
jjg
parents: 731
diff changeset
  1062
e4b6a6d206e6 6714365: refactor JavacFileManager to move nested classes to top level
jjg
parents: 731
diff changeset
  1063
    static class Entry implements Comparable<Entry> {
e4b6a6d206e6 6714365: refactor JavacFileManager to move nested classes to top level
jjg
parents: 731
diff changeset
  1064
        public static final Entry[] EMPTY_ARRAY = {};
e4b6a6d206e6 6714365: refactor JavacFileManager to move nested classes to top level
jjg
parents: 731
diff changeset
  1065
e4b6a6d206e6 6714365: refactor JavacFileManager to move nested classes to top level
jjg
parents: 731
diff changeset
  1066
        // Directory related
1205
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
  1067
        RelativeDirectory dir;
810
e4b6a6d206e6 6714365: refactor JavacFileManager to move nested classes to top level
jjg
parents: 731
diff changeset
  1068
        boolean isDir;
e4b6a6d206e6 6714365: refactor JavacFileManager to move nested classes to top level
jjg
parents: 731
diff changeset
  1069
e4b6a6d206e6 6714365: refactor JavacFileManager to move nested classes to top level
jjg
parents: 731
diff changeset
  1070
        // File related
e4b6a6d206e6 6714365: refactor JavacFileManager to move nested classes to top level
jjg
parents: 731
diff changeset
  1071
        String name;
e4b6a6d206e6 6714365: refactor JavacFileManager to move nested classes to top level
jjg
parents: 731
diff changeset
  1072
e4b6a6d206e6 6714365: refactor JavacFileManager to move nested classes to top level
jjg
parents: 731
diff changeset
  1073
        int offset;
e4b6a6d206e6 6714365: refactor JavacFileManager to move nested classes to top level
jjg
parents: 731
diff changeset
  1074
        int size;
e4b6a6d206e6 6714365: refactor JavacFileManager to move nested classes to top level
jjg
parents: 731
diff changeset
  1075
        int compressedSize;
e4b6a6d206e6 6714365: refactor JavacFileManager to move nested classes to top level
jjg
parents: 731
diff changeset
  1076
        long javatime;
e4b6a6d206e6 6714365: refactor JavacFileManager to move nested classes to top level
jjg
parents: 731
diff changeset
  1077
e4b6a6d206e6 6714365: refactor JavacFileManager to move nested classes to top level
jjg
parents: 731
diff changeset
  1078
        private int nativetime;
e4b6a6d206e6 6714365: refactor JavacFileManager to move nested classes to top level
jjg
parents: 731
diff changeset
  1079
1205
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
  1080
        public Entry(RelativePath path) {
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
  1081
            this(path.dirname(), path.basename());
810
e4b6a6d206e6 6714365: refactor JavacFileManager to move nested classes to top level
jjg
parents: 731
diff changeset
  1082
        }
e4b6a6d206e6 6714365: refactor JavacFileManager to move nested classes to top level
jjg
parents: 731
diff changeset
  1083
1205
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
  1084
        public Entry(RelativeDirectory directory, String name) {
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
  1085
            this.dir = directory;
810
e4b6a6d206e6 6714365: refactor JavacFileManager to move nested classes to top level
jjg
parents: 731
diff changeset
  1086
            this.name = name;
e4b6a6d206e6 6714365: refactor JavacFileManager to move nested classes to top level
jjg
parents: 731
diff changeset
  1087
        }
e4b6a6d206e6 6714365: refactor JavacFileManager to move nested classes to top level
jjg
parents: 731
diff changeset
  1088
e4b6a6d206e6 6714365: refactor JavacFileManager to move nested classes to top level
jjg
parents: 731
diff changeset
  1089
        public String getName() {
1205
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
  1090
            return new RelativeFile(dir, name).getPath();
810
e4b6a6d206e6 6714365: refactor JavacFileManager to move nested classes to top level
jjg
parents: 731
diff changeset
  1091
        }
e4b6a6d206e6 6714365: refactor JavacFileManager to move nested classes to top level
jjg
parents: 731
diff changeset
  1092
e4b6a6d206e6 6714365: refactor JavacFileManager to move nested classes to top level
jjg
parents: 731
diff changeset
  1093
        public String getFileName() {
e4b6a6d206e6 6714365: refactor JavacFileManager to move nested classes to top level
jjg
parents: 731
diff changeset
  1094
            return name;
e4b6a6d206e6 6714365: refactor JavacFileManager to move nested classes to top level
jjg
parents: 731
diff changeset
  1095
        }
e4b6a6d206e6 6714365: refactor JavacFileManager to move nested classes to top level
jjg
parents: 731
diff changeset
  1096
e4b6a6d206e6 6714365: refactor JavacFileManager to move nested classes to top level
jjg
parents: 731
diff changeset
  1097
        public long getLastModified() {
e4b6a6d206e6 6714365: refactor JavacFileManager to move nested classes to top level
jjg
parents: 731
diff changeset
  1098
            if (javatime == 0) {
e4b6a6d206e6 6714365: refactor JavacFileManager to move nested classes to top level
jjg
parents: 731
diff changeset
  1099
                    javatime = dosToJavaTime(nativetime);
e4b6a6d206e6 6714365: refactor JavacFileManager to move nested classes to top level
jjg
parents: 731
diff changeset
  1100
            }
e4b6a6d206e6 6714365: refactor JavacFileManager to move nested classes to top level
jjg
parents: 731
diff changeset
  1101
            return javatime;
e4b6a6d206e6 6714365: refactor JavacFileManager to move nested classes to top level
jjg
parents: 731
diff changeset
  1102
        }
e4b6a6d206e6 6714365: refactor JavacFileManager to move nested classes to top level
jjg
parents: 731
diff changeset
  1103
865
21668f049d28 6725036: javac returns incorrect value for lastModifiedTime() when source is a zip file archive
jjg
parents: 810
diff changeset
  1104
        // based on dosToJavaTime in java.util.Zip, but avoiding the
21668f049d28 6725036: javac returns incorrect value for lastModifiedTime() when source is a zip file archive
jjg
parents: 810
diff changeset
  1105
        // use of deprecated Date constructor
21668f049d28 6725036: javac returns incorrect value for lastModifiedTime() when source is a zip file archive
jjg
parents: 810
diff changeset
  1106
        private static long dosToJavaTime(int dtime) {
21668f049d28 6725036: javac returns incorrect value for lastModifiedTime() when source is a zip file archive
jjg
parents: 810
diff changeset
  1107
            Calendar c = Calendar.getInstance();
21668f049d28 6725036: javac returns incorrect value for lastModifiedTime() when source is a zip file archive
jjg
parents: 810
diff changeset
  1108
            c.set(Calendar.YEAR,        ((dtime >> 25) & 0x7f) + 1980);
21668f049d28 6725036: javac returns incorrect value for lastModifiedTime() when source is a zip file archive
jjg
parents: 810
diff changeset
  1109
            c.set(Calendar.MONTH,       ((dtime >> 21) & 0x0f) - 1);
21668f049d28 6725036: javac returns incorrect value for lastModifiedTime() when source is a zip file archive
jjg
parents: 810
diff changeset
  1110
            c.set(Calendar.DATE,        ((dtime >> 16) & 0x1f));
21668f049d28 6725036: javac returns incorrect value for lastModifiedTime() when source is a zip file archive
jjg
parents: 810
diff changeset
  1111
            c.set(Calendar.HOUR_OF_DAY, ((dtime >> 11) & 0x1f));
21668f049d28 6725036: javac returns incorrect value for lastModifiedTime() when source is a zip file archive
jjg
parents: 810
diff changeset
  1112
            c.set(Calendar.MINUTE,      ((dtime >>  5) & 0x3f));
21668f049d28 6725036: javac returns incorrect value for lastModifiedTime() when source is a zip file archive
jjg
parents: 810
diff changeset
  1113
            c.set(Calendar.SECOND,      ((dtime <<  1) & 0x3e));
21668f049d28 6725036: javac returns incorrect value for lastModifiedTime() when source is a zip file archive
jjg
parents: 810
diff changeset
  1114
            c.set(Calendar.MILLISECOND, 0);
21668f049d28 6725036: javac returns incorrect value for lastModifiedTime() when source is a zip file archive
jjg
parents: 810
diff changeset
  1115
            return c.getTimeInMillis();
810
e4b6a6d206e6 6714365: refactor JavacFileManager to move nested classes to top level
jjg
parents: 731
diff changeset
  1116
        }
e4b6a6d206e6 6714365: refactor JavacFileManager to move nested classes to top level
jjg
parents: 731
diff changeset
  1117
e4b6a6d206e6 6714365: refactor JavacFileManager to move nested classes to top level
jjg
parents: 731
diff changeset
  1118
        void setNativeTime(int natTime) {
e4b6a6d206e6 6714365: refactor JavacFileManager to move nested classes to top level
jjg
parents: 731
diff changeset
  1119
            nativetime = natTime;
e4b6a6d206e6 6714365: refactor JavacFileManager to move nested classes to top level
jjg
parents: 731
diff changeset
  1120
        }
e4b6a6d206e6 6714365: refactor JavacFileManager to move nested classes to top level
jjg
parents: 731
diff changeset
  1121
e4b6a6d206e6 6714365: refactor JavacFileManager to move nested classes to top level
jjg
parents: 731
diff changeset
  1122
        public boolean isDirectory() {
e4b6a6d206e6 6714365: refactor JavacFileManager to move nested classes to top level
jjg
parents: 731
diff changeset
  1123
            return isDir;
e4b6a6d206e6 6714365: refactor JavacFileManager to move nested classes to top level
jjg
parents: 731
diff changeset
  1124
        }
e4b6a6d206e6 6714365: refactor JavacFileManager to move nested classes to top level
jjg
parents: 731
diff changeset
  1125
e4b6a6d206e6 6714365: refactor JavacFileManager to move nested classes to top level
jjg
parents: 731
diff changeset
  1126
        public int compareTo(Entry other) {
1205
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
  1127
            RelativeDirectory otherD = other.dir;
810
e4b6a6d206e6 6714365: refactor JavacFileManager to move nested classes to top level
jjg
parents: 731
diff changeset
  1128
            if (dir != otherD) {
e4b6a6d206e6 6714365: refactor JavacFileManager to move nested classes to top level
jjg
parents: 731
diff changeset
  1129
                int c = dir.compareTo(otherD);
e4b6a6d206e6 6714365: refactor JavacFileManager to move nested classes to top level
jjg
parents: 731
diff changeset
  1130
                if (c != 0)
e4b6a6d206e6 6714365: refactor JavacFileManager to move nested classes to top level
jjg
parents: 731
diff changeset
  1131
                    return c;
e4b6a6d206e6 6714365: refactor JavacFileManager to move nested classes to top level
jjg
parents: 731
diff changeset
  1132
            }
e4b6a6d206e6 6714365: refactor JavacFileManager to move nested classes to top level
jjg
parents: 731
diff changeset
  1133
            return name.compareTo(other.name);
e4b6a6d206e6 6714365: refactor JavacFileManager to move nested classes to top level
jjg
parents: 731
diff changeset
  1134
        }
e4b6a6d206e6 6714365: refactor JavacFileManager to move nested classes to top level
jjg
parents: 731
diff changeset
  1135
1205
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
  1136
        @Override
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
  1137
        public boolean equals(Object o) {
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
  1138
            if (!(o instanceof Entry))
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
  1139
                return false;
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
  1140
            Entry other = (Entry) o;
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
  1141
            return dir.equals(other.dir) && name.equals(other.name);
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
  1142
        }
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
  1143
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
  1144
        @Override
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
  1145
        public int hashCode() {
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
  1146
            int hash = 7;
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
  1147
            hash = 97 * hash + (this.dir != null ? this.dir.hashCode() : 0);
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
  1148
            hash = 97 * hash + (this.name != null ? this.name.hashCode() : 0);
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
  1149
            return hash;
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
  1150
        }
b316e32eb90c 6508981: cleanup file separator handling in JavacFileManager
jjg
parents: 865
diff changeset
  1151
8223
638daa596494 6988106: javac report 'java.lang.IllegalMonitorStateException'
jjg
parents: 5847
diff changeset
  1152
        @Override
810
e4b6a6d206e6 6714365: refactor JavacFileManager to move nested classes to top level
jjg
parents: 731
diff changeset
  1153
        public String toString() {
e4b6a6d206e6 6714365: refactor JavacFileManager to move nested classes to top level
jjg
parents: 731
diff changeset
  1154
            return isDir ? ("Dir:" + dir + " : " + name) :
e4b6a6d206e6 6714365: refactor JavacFileManager to move nested classes to top level
jjg
parents: 731
diff changeset
  1155
                (dir + ":" + name);
e4b6a6d206e6 6714365: refactor JavacFileManager to move nested classes to top level
jjg
parents: 731
diff changeset
  1156
        }
e4b6a6d206e6 6714365: refactor JavacFileManager to move nested classes to top level
jjg
parents: 731
diff changeset
  1157
    }
e4b6a6d206e6 6714365: refactor JavacFileManager to move nested classes to top level
jjg
parents: 731
diff changeset
  1158
8837
141b22c7e7b2 7021927: javac: regression in performance
ksrini
parents: 8223
diff changeset
  1159
    /*
141b22c7e7b2 7021927: javac: regression in performance
ksrini
parents: 8223
diff changeset
  1160
     * Exception primarily used to implement a failover, used exclusively here.
141b22c7e7b2 7021927: javac: regression in performance
ksrini
parents: 8223
diff changeset
  1161
     */
141b22c7e7b2 7021927: javac: regression in performance
ksrini
parents: 8223
diff changeset
  1162
141b22c7e7b2 7021927: javac: regression in performance
ksrini
parents: 8223
diff changeset
  1163
    static final class ZipFormatException extends IOException {
141b22c7e7b2 7021927: javac: regression in performance
ksrini
parents: 8223
diff changeset
  1164
        private static final long serialVersionUID = 8000196834066748623L;
141b22c7e7b2 7021927: javac: regression in performance
ksrini
parents: 8223
diff changeset
  1165
        protected ZipFormatException(String message) {
141b22c7e7b2 7021927: javac: regression in performance
ksrini
parents: 8223
diff changeset
  1166
            super(message);
141b22c7e7b2 7021927: javac: regression in performance
ksrini
parents: 8223
diff changeset
  1167
        }
141b22c7e7b2 7021927: javac: regression in performance
ksrini
parents: 8223
diff changeset
  1168
141b22c7e7b2 7021927: javac: regression in performance
ksrini
parents: 8223
diff changeset
  1169
        protected ZipFormatException(String message, Throwable cause) {
141b22c7e7b2 7021927: javac: regression in performance
ksrini
parents: 8223
diff changeset
  1170
            super(message, cause);
141b22c7e7b2 7021927: javac: regression in performance
ksrini
parents: 8223
diff changeset
  1171
        }
141b22c7e7b2 7021927: javac: regression in performance
ksrini
parents: 8223
diff changeset
  1172
    }
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1173
}