jdk8-mips64-public/langtools: src/share/classes/com/sun/tools/javac/zip/ZipFileIndex.java@9a66ca7c79fa (annotated)

src/share/classes/com/sun/tools/javac/zip/ZipFileIndex.java@9a66ca7c79fa (annotated)

src/share/classes/com/sun/tools/javac/zip/ZipFileIndex.java

Sat, 01 Dec 2007 00:00:00 +0000

author: duke
date: Sat, 01 Dec 2007 00:00:00 +0000
changeset 1: 9a66ca7c79fa
child 36: 58e352559a41
permissions: -rw-r--r--

Initial load

 package com.sun.tools.javac.zip;
 import java.io.*;
 import java.text.MessageFormat;
 import java.util.*;
 import java.util.List;
 import java.util.concurrent.locks.ReentrantLock;
 import java.util.zip.*;
 /** This class implements building of index of a zip archive and access to it's context.
  *  It also uses prebuild index if available. It supports invocations where it will
  *  serialize an optimized zip index file to disk.
  *
  *  In oreder to use secondary index file make sure the option "usezipindex" is in the Options object,
  *  when JavacFileManager is invoked. (You can pass "-XDusezipindex" on the command line.
  *
  *  Location where to look for/generate optimized zip index files can be provided using
  *  "-XDcachezipindexdir=<directory>". If this flag is not provided, the dfault location is
  *  the value of the "java.io.tmpdir" system property.
  *
  *  If key "-XDwritezipindexfiles" is specified, there will be new optimized index file
  *  created for each archive, used by the compiler for compilation, at location,
  *  specified by "cachezipindexdir" option.
  *
  * If nonBatchMode option is specified (-XDnonBatchMode) the compiler will use timestamp
  * checking to reindex the zip files if it is needed. In batch mode the timestamps are not checked
  * and the compiler uses the cached indexes.
  */
 public class ZipFileIndex {
     private static final String MIN_CHAR = String.valueOf(Character.MIN_VALUE);
     private static final String MAX_CHAR = String.valueOf(Character.MAX_VALUE);
     public final static long NOT_MODIFIED = Long.MIN_VALUE;
     private static Map<File, ZipFileIndex> zipFileIndexCache = new HashMap<File, ZipFileIndex>();
     private static ReentrantLock lock = new ReentrantLock();
     private static boolean NON_BATCH_MODE = System.getProperty("nonBatchMode") != null;// TODO: Use -XD compiler switch for this.
     private Map<String, DirectoryEntry> directories = Collections.<String, DirectoryEntry>emptyMap();
     private Set<String> allDirs = Collections.<String>emptySet();
     // ZipFileIndex data entries
     private File zipFile;
     private long zipFileLastModified = NOT_MODIFIED;
     private RandomAccessFile zipRandomFile;
     private ZipFileIndexEntry[] entries;
     private boolean readFromIndex = false;
     private File zipIndexFile = null;
     private boolean triedToReadIndex = false;
     private int symbolFilePrefixLength = 0;
     private boolean hasPopulatedData = false;
     private long lastReferenceTimeStamp = NOT_MODIFIED;
     private boolean usePreindexedCache = false;
     private String preindexedCacheLocation = null;
     private boolean writeIndex = false;
     /**
      * Returns a list of all ZipFileIndex entries
      *
      * @return A list of ZipFileIndex entries, or an empty list
      */
     public static List<ZipFileIndex> getZipFileIndexes() {
         return getZipFileIndexes(false);
     }
     /**
      * Returns a list of all ZipFileIndex entries
      *
      * @param openedOnly If true it returns a list of only opened ZipFileIndex entries, otherwise
      *                   all ZipFileEntry(s) are included into the list.
      * @return A list of ZipFileIndex entries, or an empty list
      */
     public static List<ZipFileIndex> getZipFileIndexes(boolean openedOnly) {
         List<ZipFileIndex> zipFileIndexes = new ArrayList<ZipFileIndex>();
         lock.lock();
         try {
             zipFileIndexes.addAll(zipFileIndexCache.values());
             if (openedOnly) {
                 for(ZipFileIndex elem : zipFileIndexes) {
                     if (!elem.isOpen()) {
                         zipFileIndexes.remove(elem);
                     }
                 }
             }
         }
         finally {
             lock.unlock();
         }
         return zipFileIndexes;
     }
     public boolean isOpen() {
         lock.lock();
         try {
             return zipRandomFile != null;
         }
         finally {
             lock.unlock();
         }
     }
     public static ZipFileIndex getZipFileIndex(File zipFile, int symbolFilePrefixLen, boolean useCache, String cacheLocation, boolean writeIndex) throws IOException {
         ZipFileIndex zi = null;
         lock.lock();
         try {
             zi = getExistingZipIndex(zipFile);
             if (zi == null || (zi != null && zipFile.lastModified() != zi.zipFileLastModified)) {
                 zi = new ZipFileIndex(zipFile, symbolFilePrefixLen, writeIndex,
                         useCache, cacheLocation);
                 zipFileIndexCache.put(zipFile, zi);
             }
         }
         finally {
             lock.unlock();
         }
         return zi;
     }
     public static ZipFileIndex getExistingZipIndex(File zipFile) {
         lock.lock();
         try {
             return zipFileIndexCache.get(zipFile);
         }
         finally {
             lock.unlock();
         }
     }
     public static void clearCache() {
         lock.lock();
         try {
             zipFileIndexCache.clear();
         }
         finally {
             lock.unlock();
         }
     }
     public static void clearCache(long timeNotUsed) {
         lock.lock();
         try {
             Iterator<File> cachedFileIterator = zipFileIndexCache.keySet().iterator();
             while (cachedFileIterator.hasNext()) {
                 File cachedFile = cachedFileIterator.next();
                 ZipFileIndex cachedZipIndex = zipFileIndexCache.get(cachedFile);
                 if (cachedZipIndex != null) {
                     long timeToTest = cachedZipIndex.lastReferenceTimeStamp + timeNotUsed;
                     if (timeToTest < cachedZipIndex.lastReferenceTimeStamp || // Overflow...
                             System.currentTimeMillis() > timeToTest) {
                         zipFileIndexCache.remove(cachedFile);
                     }
                 }
             }
         }
         finally {
             lock.unlock();
         }
     }
     public static void removeFromCache(File file) {
         lock.lock();
         try {
             zipFileIndexCache.remove(file);
         }
         finally {
             lock.unlock();
         }
     }
     /** Sets already opened list of ZipFileIndexes from an outside client
       * of the compiler. This functionality should be used in a non-batch clients of the compiler.
       */
     public static void setOpenedIndexes(List<ZipFileIndex>indexes) throws IllegalStateException {
         lock.lock();
         try {
             if (zipFileIndexCache.isEmpty()) {
                 throw new IllegalStateException("Setting opened indexes should be called only when the ZipFileCache is empty. Call JavacFileManager.flush() before calling this method.");
             }
             for (ZipFileIndex zfi : indexes) {
                 zipFileIndexCache.put(zfi.zipFile, zfi);
             }
         }
         finally {
             lock.unlock();
         }
     }
     private ZipFileIndex(File zipFile, int symbolFilePrefixLen, boolean writeIndex,
             boolean useCache, String cacheLocation) throws IOException {
         this.zipFile = zipFile;
         this.symbolFilePrefixLength = symbolFilePrefixLen;
         this.writeIndex = writeIndex;
         this.usePreindexedCache = useCache;
         this.preindexedCacheLocation = cacheLocation;
         if (zipFile != null) {
             this.zipFileLastModified = zipFile.lastModified();
         }
         // Validate integrity of the zip file
         checkIndex();
     }
     public String toString() {
         return "ZipFileIndex of file:(" + zipFile + ")";
     }
     // Just in case...
     protected void finalize() {
         closeFile();
     }
     private boolean isUpToDate() {
         if (zipFile != null &&
                 ((!NON_BATCH_MODE) || zipFileLastModified == zipFile.lastModified()) &&
                 hasPopulatedData) {
             return true;
         }
         return false;
     }
     /**
      * Here we need to make sure that the ZipFileIndex is valid. Check the timestamp of the file and
      * if its the same as the one at the time the index was build we don't need to reopen anything.
      */
     private void checkIndex() throws IOException {
         boolean isUpToDate = true;
         if (!isUpToDate()) {
             closeFile();
             isUpToDate = false;
         }
         if (zipRandomFile != null || isUpToDate) {
             lastReferenceTimeStamp = System.currentTimeMillis();
             return;
         }
         hasPopulatedData = true;
         if (readIndex()) {
             lastReferenceTimeStamp = System.currentTimeMillis();
             return;
         }
         directories = Collections.<String, DirectoryEntry>emptyMap();
         allDirs = Collections.<String>emptySet();
         try {
             openFile();
             long totalLength = zipRandomFile.length();
             ZipDirectory directory = new ZipDirectory(zipRandomFile, 0L, totalLength, this);
             directory.buildIndex();
         } finally {
             if (zipRandomFile != null) {
                 closeFile();
             }
         }
         lastReferenceTimeStamp = System.currentTimeMillis();
     }
     private void openFile() throws FileNotFoundException {
         if (zipRandomFile == null && zipFile != null) {
             zipRandomFile = new RandomAccessFile(zipFile, "r");
         }
     }
     private void cleanupState() {
         // Make sure there is a valid but empty index if the file doesn't exist
         entries = ZipFileIndexEntry.EMPTY_ARRAY;
         directories = Collections.<String, DirectoryEntry>emptyMap();
         zipFileLastModified = NOT_MODIFIED;
         allDirs = Collections.<String>emptySet();
     }
     public void close() {
         lock.lock();
         try {
             writeIndex();
             closeFile();
         }
         finally {
             lock.unlock();
         }
     }
     private void closeFile() {
         if (zipRandomFile != null) {
             try {
                 zipRandomFile.close();
             } catch (IOException ex) {
             }
             zipRandomFile = null;
         }
     }
     /**
      * Returns the ZipFileIndexEntry for an absolute path, if there is one.
      */
     public ZipFileIndexEntry getZipIndexEntry(String path) {
         if (File.separatorChar != '/') {
             path = path.replace('/', File.separatorChar);
         }
         lock.lock();
         try {
             checkIndex();
             String lookFor = "";
             int lastSepIndex = path.lastIndexOf(File.separatorChar);
             boolean noSeparator = false;
             if (lastSepIndex == -1) {
                 noSeparator = true;
             }
             DirectoryEntry de = directories.get(noSeparator ? "" : path.substring(0, lastSepIndex));
             lookFor = path.substring(noSeparator ? 0 : lastSepIndex + 1);
             return de == null ? null : de.getEntry(lookFor);
         }
         catch (IOException e) {
             return null;
         }
         finally {
             lock.unlock();
         }
     }
     /**
      * Returns a javac List of filenames within an absolute path in the ZipFileIndex.
      */
     public com.sun.tools.javac.util.List<String> getFiles(String path) {
         if (File.separatorChar != '/') {
             path = path.replace('/', File.separatorChar);
         }
         lock.lock();
         try {
             checkIndex();
             DirectoryEntry de = directories.get(path);
             com.sun.tools.javac.util.List<String> ret = de == null ? null : de.getFiles();
             if (ret == null) {
                 return com.sun.tools.javac.util.List.<String>nil();
             }
             return ret;
         }
         catch (IOException e) {
             return com.sun.tools.javac.util.List.<String>nil();
         }
         finally {
             lock.unlock();
         }
     }
     public List<String> getAllDirectories(String path) {
         if (File.separatorChar != '/') {
             path = path.replace('/', File.separatorChar);
         }
         lock.lock();
         try {
             checkIndex();
             path = path.intern();
             DirectoryEntry de = directories.get(path);
             com.sun.tools.javac.util.List<String> ret = de == null ? null : de.getDirectories();
             if (ret == null) {
                 return com.sun.tools.javac.util.List.<String>nil();
             }
             return ret;
         }
         catch (IOException e) {
             return com.sun.tools.javac.util.List.<String>nil();
         }
         finally {
             lock.unlock();
         }
     }
     public Set<String> getAllDirectories() {
         lock.lock();
         try {
             checkIndex();
             if (allDirs == Collections.EMPTY_SET) {
                 Set<String> alldirs = new HashSet<String>();
                 Iterator<String> dirsIter = directories.keySet().iterator();
                 while (dirsIter.hasNext()) {
                     alldirs.add(new String(dirsIter.next()));
                 }
                 allDirs = alldirs;
             }
             return allDirs;
         }
         catch (IOException e) {
             return Collections.<String>emptySet();
         }
         finally {
             lock.unlock();
         }
     }
     /**
      * Tests if a specific path exists in the zip.  This method will return true
      * for file entries and directories.
      *
      * @param path A path within the zip.
      * @return True if the path is a file or dir, false otherwise.
      */
     public boolean contains(String path) {
         lock.lock();
         try {
             checkIndex();
             return getZipIndexEntry(path) != null;
         }
         catch (IOException e) {
             return false;
         }
         finally {
             lock.unlock();
         }
     }
     public boolean isDirectory(String path) throws IOException {
         lock.lock();
         try {
             // The top level in a zip file is always a directory.
             if (path.length() == 0) {
                 lastReferenceTimeStamp = System.currentTimeMillis();
                 return true;
             }
             if (File.separatorChar != '/')
                 path = path.replace('/', File.separatorChar);
             checkIndex();
             return directories.get(path) != null;
         }
         finally {
             lock.unlock();
         }
     }
     public long getLastModified(String path) throws IOException {
         lock.lock();
         try {
             ZipFileIndexEntry entry = getZipIndexEntry(path);
             if (entry == null)
                 throw new FileNotFoundException();
             return entry.getLastModified();
         }
         finally {
             lock.unlock();
         }
     }
     public int length(String path) throws IOException {
         lock.lock();
         try {
             ZipFileIndexEntry entry = getZipIndexEntry(path);
             if (entry == null)
                 throw new FileNotFoundException();
             if (entry.isDir) {
                 return 0;
             }
             byte[] header = getHeader(entry);
             // entry is not compressed?
             if (get2ByteLittleEndian(header, 8) == 0) {
                 return entry.compressedSize;
             } else {
                 return entry.size;
             }
         }
         finally {
             lock.unlock();
         }
     }
     public byte[] read(String path) throws IOException {
         lock.lock();
         try {
             ZipFileIndexEntry entry = getZipIndexEntry(path);
             if (entry == null)
                 throw new FileNotFoundException(MessageFormat.format("Path not found in ZIP: {0}", path));
             return read(entry);
         }
         finally {
             lock.unlock();
         }
     }
     public byte[] read(ZipFileIndexEntry entry) throws IOException {
         lock.lock();
         try {
             openFile();
             byte[] result = readBytes(entry);
             closeFile();
             return result;
         }
         finally {
             lock.unlock();
         }
     }
     public int read(String path, byte[] buffer) throws IOException {
         lock.lock();
         try {
             ZipFileIndexEntry entry = getZipIndexEntry(path);
             if (entry == null)
                 throw new FileNotFoundException();
             return read(entry, buffer);
         }
         finally {
             lock.unlock();
         }
     }
     public int read(ZipFileIndexEntry entry, byte[] buffer)
             throws IOException {
         lock.lock();
         try {
             int result = readBytes(entry, buffer);
             return result;
         }
         finally {
             lock.unlock();
         }
     }
     private byte[] readBytes(ZipFileIndexEntry entry) throws IOException {
         byte[] header = getHeader(entry);
         int csize = entry.compressedSize;
         byte[] cbuf = new byte[csize];
         zipRandomFile.skipBytes(get2ByteLittleEndian(header, 26) + get2ByteLittleEndian(header, 28));
         zipRandomFile.readFully(cbuf, 0, csize);
         // is this compressed - offset 8 in the ZipEntry header
         if (get2ByteLittleEndian(header, 8) == 0)
             return cbuf;
         int size = entry.size;
         byte[] buf = new byte[size];
         if (inflate(cbuf, buf) != size)
             throw new ZipException("corrupted zip file");
         return buf;
     }
     /**
      *
      */
     private int readBytes(ZipFileIndexEntry entry, byte[] buffer) throws IOException {
         byte[] header = getHeader(entry);
         // entry is not compressed?
         if (get2ByteLittleEndian(header, 8) == 0) {
             zipRandomFile.skipBytes(get2ByteLittleEndian(header, 26) + get2ByteLittleEndian(header, 28));
             int offset = 0;
             int size = buffer.length;
             while (offset < size) {
                 int count = zipRandomFile.read(buffer, offset, size - offset);
                 if (count == -1)
                     break;
                 offset += count;
             }
             return entry.size;
         }
         int csize = entry.compressedSize;
         byte[] cbuf = new byte[csize];
         zipRandomFile.skipBytes(get2ByteLittleEndian(header, 26) + get2ByteLittleEndian(header, 28));
         zipRandomFile.readFully(cbuf, 0, csize);
         int count = inflate(cbuf, buffer);
         if (count == -1)
             throw new ZipException("corrupted zip file");
         return entry.size;
     }
     //----------------------------------------------------------------------------
     // Zip utilities
     //----------------------------------------------------------------------------
     private byte[] getHeader(ZipFileIndexEntry entry) throws IOException {
         zipRandomFile.seek(entry.offset);
         byte[] header = new byte[30];
         zipRandomFile.readFully(header);
         if (get4ByteLittleEndian(header, 0) != 0x04034b50)
             throw new ZipException("corrupted zip file");
         if ((get2ByteLittleEndian(header, 6) & 1) != 0)
             throw new ZipException("encrypted zip file"); // offset 6 in the header of the ZipFileEntry
         return header;
     }
   /*
    * Inflate using the java.util.zip.Inflater class
    */
     private static Inflater inflater;
     private int inflate(byte[] src, byte[] dest) {
         // construct the inflater object or reuse an existing one
         if (inflater == null)
             inflater = new Inflater(true);
         synchronized (inflater) {
             inflater.reset();
             inflater.setInput(src);
             try {
                 return inflater.inflate(dest);
             } catch (DataFormatException ex) {
                 return -1;
             }
         }
     }
     /**
      * return the two bytes buf[pos], buf[pos+1] as an unsigned integer in little
      * endian format.
      */
     private static int get2ByteLittleEndian(byte[] buf, int pos) {
         return (buf[pos] & 0xFF) + ((buf[pos+1] & 0xFF) << 8);
     }
     /**
      * return the 4 bytes buf[i..i+3] as an integer in little endian format.
      */
     private static int get4ByteLittleEndian(byte[] buf, int pos) {
         return (buf[pos] & 0xFF) + ((buf[pos + 1] & 0xFF) << 8) +
                 ((buf[pos + 2] & 0xFF) << 16) + ((buf[pos + 3] & 0xFF) << 24);
     }
     /* ----------------------------------------------------------------------------
      * ZipDirectory
      * ----------------------------------------------------------------------------*/
     private class ZipDirectory {
         private String lastDir;
         private int lastStart;
         private int lastLen;
         byte[] zipDir;
         RandomAccessFile zipRandomFile = null;
         ZipFileIndex zipFileIndex = null;
         public ZipDirectory(RandomAccessFile zipRandomFile, long start, long end, ZipFileIndex index) throws IOException {
             this.zipRandomFile = zipRandomFile;
             this.zipFileIndex = index;
             findCENRecord(start, end);
         }
         /*
          * Reads zip file central directory.
          * For more details see readCEN in zip_util.c from the JDK sources.
          * This is a Java port of that function.
          */
         private void findCENRecord(long start, long end) throws IOException {
             long totalLength = end - start;
             int endbuflen = 1024;
             byte[] endbuf = new byte[endbuflen];
             long endbufend = end - start;
             // There is a variable-length field after the dir offset record. We need to do consequential search.
             while (endbufend >= 22) {
                 if (endbufend < endbuflen)
                     endbuflen = (int)endbufend;
                 long endbufpos = endbufend - endbuflen;
                 zipRandomFile.seek(start + endbufpos);
                 zipRandomFile.readFully(endbuf, 0, endbuflen);
                 int i = endbuflen - 22;
                 while (i >= 0 &&
                         !(endbuf[i] == 0x50 &&
                         endbuf[i + 1] == 0x4b &&
                         endbuf[i + 2] == 0x05 &&
                         endbuf[i + 3] == 0x06 &&
                         endbufpos + i + 22 +
                         get2ByteLittleEndian(endbuf, i + 20) == totalLength)) {
                     i--;
                 }
                 if (i >= 0) {
                     zipDir = new byte[get4ByteLittleEndian(endbuf, i + 12) + 2];
                     zipDir[0] = endbuf[i + 10];
                     zipDir[1] = endbuf[i + 11];
                     zipRandomFile.seek(start + get4ByteLittleEndian(endbuf, i + 16));
                     zipRandomFile.readFully(zipDir, 2, zipDir.length - 2);
                     return;
                 } else {
                     endbufend = endbufpos + 21;
                 }
             }
             throw new ZipException("cannot read zip file");
         }
         private void buildIndex() throws IOException {
             int entryCount = get2ByteLittleEndian(zipDir, 0);
             entries = new ZipFileIndexEntry[entryCount];
             // Add each of the files
             if (entryCount > 0) {
                 directories = new HashMap<String, DirectoryEntry>();
                 ArrayList<ZipFileIndexEntry> entryList = new ArrayList<ZipFileIndexEntry>();
                 int pos = 2;
                 for (int i = 0; i < entryCount; i++) {
                     pos = readEntry(pos, entryList, directories);
                 }
                 // Add the accumulated dirs into the same list
                 Iterator i = directories.keySet().iterator();
                 while (i.hasNext()) {
                     ZipFileIndexEntry zipFileIndexEntry = new ZipFileIndexEntry( (String) i.next());
                     zipFileIndexEntry.isDir = true;
                     entryList.add(zipFileIndexEntry);
                 }
                 entries = entryList.toArray(new ZipFileIndexEntry[entryList.size()]);
                 Arrays.sort(entries);
             } else {
                 cleanupState();
             }
         }
         private int readEntry(int pos, List<ZipFileIndexEntry> entryList,
                 Map<String, DirectoryEntry> directories) throws IOException {
             if (get4ByteLittleEndian(zipDir, pos) != 0x02014b50) {
                 throw new ZipException("cannot read zip file entry");
             }
             int dirStart = pos + 46;
             int fileStart = dirStart;
             int fileEnd = fileStart + get2ByteLittleEndian(zipDir, pos + 28);
             if (zipFileIndex.symbolFilePrefixLength != 0 &&
                     ((fileEnd - fileStart) >= symbolFilePrefixLength)) {
                 dirStart += zipFileIndex.symbolFilePrefixLength;
                fileStart += zipFileIndex.symbolFilePrefixLength;
             }
             // Use the OS's path separator. Keep the position of the last one.
             for (int index = fileStart; index < fileEnd; index++) {
                 byte nextByte = zipDir[index];
                 if (nextByte == (byte)'\\' || nextByte == (byte)'/') {
                     zipDir[index] = (byte)File.separatorChar;
                     fileStart = index + 1;
                 }
             }
             String directory = null;
             if (fileStart == dirStart)
                 directory = "";
             else if (lastDir != null && lastLen == fileStart - dirStart - 1) {
                 int index = lastLen - 1;
                 while (zipDir[lastStart + index] == zipDir[dirStart + index]) {
                     if (index == 0) {
                         directory = lastDir;
                         break;
                     }
                     index--;
                 }
             }
             // Sub directories
             if (directory == null) {
                 lastStart = dirStart;
                 lastLen = fileStart - dirStart - 1;
                 directory = new String(zipDir, dirStart, lastLen, "UTF-8").intern();
                 lastDir = directory;
                 // Enter also all the parent directories
                 String tempDirectory = directory;
                 while (directories.get(tempDirectory) == null) {
                     directories.put(tempDirectory, new DirectoryEntry(tempDirectory, zipFileIndex));
                     int separator = tempDirectory.lastIndexOf(File.separatorChar);
                     if (separator == -1)
                         break;
                     tempDirectory = tempDirectory.substring(0, separator);
                 }
             }
             else {
                 directory = directory.intern();
                 if (directories.get(directory) == null) {
                     directories.put(directory, new DirectoryEntry(directory, zipFileIndex));
                 }
             }
             // For each dir create also a file
             if (fileStart != fileEnd) {
                 ZipFileIndexEntry entry = new ZipFileIndexEntry(directory,
                         new String(zipDir, fileStart, fileEnd - fileStart, "UTF-8"));
                 entry.setNativeTime(get4ByteLittleEndian(zipDir, pos + 12));
                 entry.compressedSize = get4ByteLittleEndian(zipDir, pos + 20);
                 entry.size = get4ByteLittleEndian(zipDir, pos + 24);
                 entry.offset = get4ByteLittleEndian(zipDir, pos + 42);
                 entryList.add(entry);
             }
             return pos + 46 +
                     get2ByteLittleEndian(zipDir, pos + 28) +
                     get2ByteLittleEndian(zipDir, pos + 30) +
                     get2ByteLittleEndian(zipDir, pos + 32);
         }
     }
     /**
      * Returns the last modified timestamp of a zip file.
      * @return long
      */
     public long getZipFileLastModified() throws IOException {
         lock.lock();
         try {
             checkIndex();
             return zipFileLastModified;
         }
         finally {
             lock.unlock();
         }
     }
     /** ------------------------------------------------------------------------
      *  DirectoryEntry class
      * -------------------------------------------------------------------------*/
     static class DirectoryEntry {
         private boolean filesInited;
         private boolean directoriesInited;
         private boolean zipFileEntriesInited;
         private boolean entriesInited;
         private long writtenOffsetOffset = 0;
         private String dirName;
         private com.sun.tools.javac.util.List<String> zipFileEntriesFiles = com.sun.tools.javac.util.List.<String>nil();
         private com.sun.tools.javac.util.List<String> zipFileEntriesDirectories = com.sun.tools.javac.util.List.<String>nil();
         private com.sun.tools.javac.util.List<ZipFileIndexEntry>  zipFileEntries = com.sun.tools.javac.util.List.<ZipFileIndexEntry>nil();
         private List<ZipFileIndexEntry> entries = new ArrayList<ZipFileIndexEntry>();
         private ZipFileIndex zipFileIndex;
         private int numEntries;
         DirectoryEntry(String dirName, ZipFileIndex index) {
         filesInited = false;
             directoriesInited = false;
             entriesInited = false;
             if (File.separatorChar == '/') {
                 dirName.replace('\\', '/');
             }
             else {
                 dirName.replace('/', '\\');
             }
             this.dirName = dirName.intern();
             this.zipFileIndex = index;
         }
         private com.sun.tools.javac.util.List<String> getFiles() {
             if (filesInited) {
                 return zipFileEntriesFiles;
             }
             initEntries();
             for (ZipFileIndexEntry e : entries) {
                 if (!e.isDir) {
                     zipFileEntriesFiles = zipFileEntriesFiles.append(e.name);
                 }
             }
             filesInited = true;
             return zipFileEntriesFiles;
         }
         private com.sun.tools.javac.util.List<String> getDirectories() {
             if (directoriesInited) {
                 return zipFileEntriesFiles;
             }
             initEntries();
             for (ZipFileIndexEntry e : entries) {
                 if (e.isDir) {
                     zipFileEntriesDirectories = zipFileEntriesDirectories.append(e.name);
                 }
             }
             directoriesInited = true;
             return zipFileEntriesDirectories;
         }
         private com.sun.tools.javac.util.List<ZipFileIndexEntry> getEntries() {
             if (zipFileEntriesInited) {
                 return zipFileEntries;
             }
             initEntries();
             zipFileEntries = com.sun.tools.javac.util.List.nil();
             for (ZipFileIndexEntry zfie : entries) {
                 zipFileEntries = zipFileEntries.append(zfie);
             }
             zipFileEntriesInited = true;
             return zipFileEntries;
         }
         private ZipFileIndexEntry getEntry(String rootName) {
             initEntries();
             int index = Collections.binarySearch(entries, new ZipFileIndexEntry(dirName, rootName));
             if (index < 0) {
                 return null;
             }
             return entries.get(index);
         }
         private void initEntries() {
             if (entriesInited) {
                 return;
             }
             if (!zipFileIndex.readFromIndex) {
                 int from = -Arrays.binarySearch(zipFileIndex.entries,
                         new ZipFileIndexEntry(dirName, ZipFileIndex.MIN_CHAR)) - 1;
                 int to = -Arrays.binarySearch(zipFileIndex.entries,
                         new ZipFileIndexEntry(dirName, MAX_CHAR)) - 1;
                 boolean emptyList = false;
                 for (int i = from; i < to; i++) {
                     entries.add(zipFileIndex.entries[i]);
                 }
             } else {
                 File indexFile = zipFileIndex.getIndexFile();
                 if (indexFile != null) {
                     RandomAccessFile raf = null;
                     try {
                         raf = new RandomAccessFile(indexFile, "r");
                         raf.seek(writtenOffsetOffset);
                         for (int nFiles = 0; nFiles < numEntries; nFiles++) {
                             // Read the name bytes
                             int zfieNameBytesLen = raf.readInt();
                             byte [] zfieNameBytes = new byte[zfieNameBytesLen];
                             raf.read(zfieNameBytes);
                             String eName = new String(zfieNameBytes, "UTF-8");
                             // Read isDir
                             boolean eIsDir = raf.readByte() == (byte)0 ? false : true;
                             // Read offset of bytes in the real Jar/Zip file
                             int eOffset = raf.readInt();
                             // Read size of the file in the real Jar/Zip file
                             int eSize = raf.readInt();
                             // Read compressed size of the file in the real Jar/Zip file
                             int eCsize = raf.readInt();
                             // Read java time stamp of the file in the real Jar/Zip file
                             long eJavaTimestamp = raf.readLong();
                             ZipFileIndexEntry rfie = new ZipFileIndexEntry(dirName, eName);
                             rfie.isDir = eIsDir;
                             rfie.offset = eOffset;
                             rfie.size = eSize;
                             rfie.compressedSize = eCsize;
                             rfie.javatime = eJavaTimestamp;
                             entries.add(rfie);
                         }
                     } catch (Throwable t) {
                         // Do nothing
                     } finally {
                         try {
                             if (raf == null) {
                                 raf.close();
                             }
                         } catch (Throwable t) {
                             // Do nothing
                         }
                     }
                 }
             }
             entriesInited = true;
         }
         List<ZipFileIndexEntry> getEntriesAsCollection() {
             initEntries();
             return entries;
         }
     }
     private boolean readIndex() {
         if (triedToReadIndex || !usePreindexedCache) {
             return false;
         }
         boolean ret = false;
         lock.lock();
         try {
             triedToReadIndex = true;
             RandomAccessFile raf = null;
             try {
                 File indexFileName = getIndexFile();
                 raf = new RandomAccessFile(indexFileName, "r");
                 long fileStamp = raf.readLong();
                 if (zipFile.lastModified() != fileStamp) {
                     ret = false;
                 } else {
                     directories = new HashMap<String, DirectoryEntry>();
                     int numDirs = raf.readInt();
                     for (int nDirs = 0; nDirs < numDirs; nDirs++) {
                         int dirNameBytesLen = raf.readInt();
                         byte [] dirNameBytes = new byte[dirNameBytesLen];
                         raf.read(dirNameBytes);
                         String dirNameStr = new String(dirNameBytes, "UTF-8");
                         DirectoryEntry de = new DirectoryEntry(dirNameStr, this);
                         de.numEntries = raf.readInt();
                         de.writtenOffsetOffset = raf.readLong();
                         directories.put(dirNameStr, de);
                     }
                     ret = true;
                     zipFileLastModified = fileStamp;
                 }
             } catch (Throwable t) {
                 // Do nothing
             } finally {
                 if (raf != null) {
                     try {
                         raf.close();
                     } catch (Throwable tt) {
                         // Do nothing
                     }
                 }
             }
             if (ret == true) {
                 readFromIndex = true;
             }
         }
         finally {
             lock.unlock();
         }
         return ret;
     }
     private boolean writeIndex() {
         boolean ret = false;
         if (readFromIndex || !usePreindexedCache) {
             return true;
         }
         if (!writeIndex) {
             return true;
         }
         File indexFile = getIndexFile();
         if (indexFile == null) {
             return false;
         }
         RandomAccessFile raf = null;
         long writtenSoFar = 0;
         try {
             raf = new RandomAccessFile(indexFile, "rw");
             raf.writeLong(zipFileLastModified);
             writtenSoFar += 8;
             Iterator<String> iterDirName = directories.keySet().iterator();
             List<DirectoryEntry> directoriesToWrite = new ArrayList<DirectoryEntry>();
             Map<String, Long> offsets = new HashMap<String, Long>();
             raf.writeInt(directories.keySet().size());
             writtenSoFar += 4;
             while(iterDirName.hasNext()) {
                 String dirName = iterDirName.next();
                 DirectoryEntry dirEntry = directories.get(dirName);
                 directoriesToWrite.add(dirEntry);
                 // Write the dir name bytes
                 byte [] dirNameBytes = dirName.getBytes("UTF-8");
                 int dirNameBytesLen = dirNameBytes.length;
                 raf.writeInt(dirNameBytesLen);
                 writtenSoFar += 4;
                 raf.write(dirNameBytes);
                 writtenSoFar += dirNameBytesLen;
                 // Write the number of files in the dir
                 List dirEntries = dirEntry.getEntriesAsCollection();
                 raf.writeInt(dirEntries.size());
                 writtenSoFar += 4;
                 offsets.put(dirName, new Long(writtenSoFar));
                 // Write the offset of the file's data in the dir
                 dirEntry.writtenOffsetOffset = 0L;
                 raf.writeLong(0L);
                 writtenSoFar += 8;
             }
             for (DirectoryEntry de : directoriesToWrite) {
                 // Fix up the offset in the directory table
                 long currFP = raf.getFilePointer();
                 long offsetOffset = offsets.get(de.dirName).longValue();
                 raf.seek(offsetOffset);
                 raf.writeLong(writtenSoFar);
                 raf.seek(currFP);
                 // Now write each of the files in the DirectoryEntry
                 List<ZipFileIndexEntry> entries = de.getEntriesAsCollection();
                 for (ZipFileIndexEntry zfie : entries) {
                     // Write the name bytes
                     byte [] zfieNameBytes = zfie.name.getBytes("UTF-8");
                     int zfieNameBytesLen = zfieNameBytes.length;
                     raf.writeInt(zfieNameBytesLen);
                     writtenSoFar += 4;
                     raf.write(zfieNameBytes);
                     writtenSoFar += zfieNameBytesLen;
                     // Write isDir
                     raf.writeByte(zfie.isDir ? (byte)1 : (byte)0);
                     writtenSoFar += 1;
                     // Write offset of bytes in the real Jar/Zip file
                     raf.writeInt(zfie.offset);
                     writtenSoFar += 4;
                     // Write size of the file in the real Jar/Zip file
                     raf.writeInt(zfie.size);
                     writtenSoFar += 4;
                     // Write compressed size of the file in the real Jar/Zip file
                     raf.writeInt(zfie.compressedSize);
                     writtenSoFar += 4;
                     // Write java time stamp of the file in the real Jar/Zip file
                     raf.writeLong(zfie.getLastModified());
                     writtenSoFar += 8;
                 }
             }
         } catch (Throwable t) {
             // Do nothing
         } finally {
             try {
                 if (raf != null) {
                     raf.close();
                 }
             } catch(IOException ioe) {
                 // Do nothing
             }
         }
         return ret;
     }
     public boolean writeZipIndex() {
         lock.lock();
         try {
             return writeIndex();
         }
         finally {
             lock.unlock();
         }
     }
     private File getIndexFile() {
         if (zipIndexFile == null) {
             if (zipFile == null) {
                 return null;
             }
             zipIndexFile = new File((preindexedCacheLocation == null ? "" : preindexedCacheLocation) +
                     zipFile.getName() + ".index");
         }
         return zipIndexFile;
     }
     public File getZipFile() {
         return zipFile;
     }
 }

Mercurial > jdk8-mips64-public > langtools / annotate

src/share/classes/com/sun/tools/javac/zip/ZipFileIndex.java@9a66ca7c79fa (annotated)

src/share/classes/com/sun/tools/javac/zip/ZipFileIndex.java