23  * have any questions.

    23  * have any questions.

    24  */

    24  */

    25 

    25 

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

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

    27 

    27 

    28 import java.io.File;

    29 import java.io.File;

    29 import java.io.FileNotFoundException;

    30 import java.io.FileNotFoundException;

    30 import java.io.IOException;

    31 import java.io.IOException;

    31 import java.io.RandomAccessFile;

    32 import java.io.RandomAccessFile;

    33 import java.util.ArrayList;

    34 import java.util.ArrayList;

    34 import java.util.Arrays;

    35 import java.util.Arrays;

    35 import java.util.Calendar;

    36 import java.util.Calendar;

    36 import java.util.Collections;

    37 import java.util.Collections;

    37 import java.util.HashMap;

    38 import java.util.HashMap;

    42 import java.util.Set;

    43 import java.util.Set;

    43 import java.util.concurrent.locks.ReentrantLock;

    44 import java.util.concurrent.locks.ReentrantLock;

    44 import java.util.zip.DataFormatException;

    45 import java.util.zip.DataFormatException;

    45 import java.util.zip.Inflater;

    46 import java.util.zip.Inflater;

    46 import java.util.zip.ZipException;

    47 import java.util.zip.ZipException;

    47 

    51 

    48 /** This class implements building of index of a zip archive and access to it's context.

    52 /** This class implements building of index of a zip archive and access to it's context.

    49  *  It also uses prebuild index if available. It supports invocations where it will

    53  *  It also uses prebuild index if available. It supports invocations where it will

    50  *  serialize an optimized zip index file to disk.

    54  *  serialize an optimized zip index file to disk.

    51  *

    55  *

    73     private static Map<File, ZipFileIndex> zipFileIndexCache = new HashMap<File, ZipFileIndex>();

    77     private static Map<File, ZipFileIndex> zipFileIndexCache = new HashMap<File, ZipFileIndex>();

    74     private static ReentrantLock lock = new ReentrantLock();

    78     private static ReentrantLock lock = new ReentrantLock();

    75 

    79 

    76     private static boolean NON_BATCH_MODE = System.getProperty("nonBatchMode") != null;// TODO: Use -XD compiler switch for this.

    80     private static boolean NON_BATCH_MODE = System.getProperty("nonBatchMode") != null;// TODO: Use -XD compiler switch for this.

    77 

    81 

    80 

    84 

    81     // ZipFileIndex data entries

    85     // ZipFileIndex data entries

    82     private File zipFile;

    86     private File zipFile;

    83     private long zipFileLastModified = NOT_MODIFIED;

    87     private long zipFileLastModified = NOT_MODIFIED;

    84     private RandomAccessFile zipRandomFile;

    88     private RandomAccessFile zipRandomFile;

    85     private Entry[] entries;

    89     private Entry[] entries;

    86 

    90 

    87     private boolean readFromIndex = false;

    91     private boolean readFromIndex = false;

    88     private File zipIndexFile = null;

    92     private File zipIndexFile = null;

    89     private boolean triedToReadIndex = false;

    93     private boolean triedToReadIndex = false;

    91     private int symbolFilePrefixLength = 0;

    95     private int symbolFilePrefixLength = 0;

    92     private boolean hasPopulatedData = false;

    96     private boolean hasPopulatedData = false;

    93     private long lastReferenceTimeStamp = NOT_MODIFIED;

    97     private long lastReferenceTimeStamp = NOT_MODIFIED;

    94 

    98 

    95     private boolean usePreindexedCache = false;

    99     private boolean usePreindexedCache = false;

    96     private String preindexedCacheLocation = null;

   100     private String preindexedCacheLocation = null;

    97 

   101 

    98     private boolean writeIndex = false;

   102     private boolean writeIndex = false;

    99 

   106 

   100     /**

   107     /**

   101      * Returns a list of all ZipFileIndex entries

   108      * Returns a list of all ZipFileIndex entries

   102      *

   109      *

   103      * @return A list of ZipFileIndex entries, or an empty list

   110      * @return A list of ZipFileIndex entries, or an empty list

   141         finally {

   148         finally {

   142             lock.unlock();

   149             lock.unlock();

   143         }

   150         }

   144     }

   151     }

   145 

   152 

   147         ZipFileIndex zi = null;

   157         ZipFileIndex zi = null;

   148         lock.lock();

   158         lock.lock();

   149         try {

   159         try {

   150             zi = getExistingZipIndex(zipFile);

   160             zi = getExistingZipIndex(zipFile);

   151 

   161 

   229         finally {

   239         finally {

   230             lock.unlock();

   240             lock.unlock();

   231         }

   241         }

   232     }

   242     }

   233 

   243 

   235             boolean useCache, String cacheLocation) throws IOException {

   245             boolean useCache, String cacheLocation) throws IOException {

   236         this.zipFile = zipFile;

   246         this.zipFile = zipFile;

   237         this.symbolFilePrefix = symbolFilePrefix;

   247         this.symbolFilePrefix = symbolFilePrefix;

   238         this.symbolFilePrefixLength = (symbolFilePrefix == null ? 0 :

   248         this.symbolFilePrefixLength = (symbolFilePrefix == null ? 0 :

   240         this.writeIndex = writeIndex;

   250         this.writeIndex = writeIndex;

   241         this.usePreindexedCache = useCache;

   251         this.usePreindexedCache = useCache;

   242         this.preindexedCacheLocation = cacheLocation;

   252         this.preindexedCacheLocation = cacheLocation;

   243 

   253 

   244         if (zipFile != null) {

   254         if (zipFile != null) {

   248         // Validate integrity of the zip file

   258         // Validate integrity of the zip file

   249         checkIndex();

   259         checkIndex();

   250     }

   260     }

   251 

   261 

   252     public String toString() {

   262     public String toString() {

   254     }

   264     }

   255 

   265 

   256     // Just in case...

   266     // Just in case...

   257     protected void finalize() {

   267     protected void finalize() {

   258         closeFile();

   268         closeFile();

   289         if (readIndex()) {

   299         if (readIndex()) {

   290             lastReferenceTimeStamp = System.currentTimeMillis();

   300             lastReferenceTimeStamp = System.currentTimeMillis();

   291             return;

   301             return;

   292         }

   302         }

   293 

   303 

   296 

   306 

   297         try {

   307         try {

   298             openFile();

   308             openFile();

   299             long totalLength = zipRandomFile.length();

   309             long totalLength = zipRandomFile.length();

   300             ZipDirectory directory = new ZipDirectory(zipRandomFile, 0L, totalLength, this);

   310             ZipDirectory directory = new ZipDirectory(zipRandomFile, 0L, totalLength, this);

   315     }

   325     }

   316 

   326 

   317     private void cleanupState() {

   327     private void cleanupState() {

   318         // Make sure there is a valid but empty index if the file doesn't exist

   328         // Make sure there is a valid but empty index if the file doesn't exist

   319         entries = Entry.EMPTY_ARRAY;

   329         entries = Entry.EMPTY_ARRAY;

   321         zipFileLastModified = NOT_MODIFIED;

   331         zipFileLastModified = NOT_MODIFIED;

   323     }

   333     }

   324 

   334 

   325     public void close() {

   335     public void close() {

   326         lock.lock();

   336         lock.lock();

   327         try {

   337         try {

   344     }

   354     }

   345 

   355 

   346     /**

   356     /**

   347      * Returns the ZipFileIndexEntry for an absolute path, if there is one.

   357      * Returns the ZipFileIndexEntry for an absolute path, if there is one.

   348      */

   358      */

   353         lock.lock();

   360         lock.lock();

   354         try {

   361         try {

   355             checkIndex();

   362             checkIndex();

   367             return de == null ? null : de.getEntry(lookFor);

   365             return de == null ? null : de.getEntry(lookFor);

   368         }

   366         }

   369         catch (IOException e) {

   367         catch (IOException e) {

   370             return null;

   368             return null;

   371         }

   369         }

   375     }

   373     }

   376 

   374 

   377     /**

   375     /**

   378      * Returns a javac List of filenames within an absolute path in the ZipFileIndex.

   376      * Returns a javac List of filenames within an absolute path in the ZipFileIndex.

   379      */

   377      */

   385         lock.lock();

   379         lock.lock();

   386         try {

   380         try {

   387             checkIndex();

   381             checkIndex();

   388 

   382 

   389             DirectoryEntry de = directories.get(path);

   383             DirectoryEntry de = directories.get(path);

   400         finally {

   394         finally {

   401             lock.unlock();

   395             lock.unlock();

   402         }

   396         }

   403     }

   397     }

   404 

   398 

   411         lock.lock();

   400         lock.lock();

   412         try {

   401         try {

   413             checkIndex();

   402             checkIndex();

   415 

   403 

   416             DirectoryEntry de = directories.get(path);

   404             DirectoryEntry de = directories.get(path);

   417             com.sun.tools.javac.util.List<String> ret = de == null ? null : de.getDirectories();

   405             com.sun.tools.javac.util.List<String> ret = de == null ? null : de.getDirectories();

   418 

   406 

   419             if (ret == null) {

   407             if (ret == null) {

   428         finally {

   416         finally {

   429             lock.unlock();

   417             lock.unlock();

   430         }

   418         }

   431     }

   419     }

   432 

   420 

   434         lock.lock();

   422         lock.lock();

   435         try {

   423         try {

   436             checkIndex();

   424             checkIndex();

   437             if (allDirs == Collections.EMPTY_SET) {

   425             if (allDirs == Collections.EMPTY_SET) {

   445             }

   427             }

   446 

   428 

   447             return allDirs;

   429             return allDirs;

   448         }

   430         }

   449         catch (IOException e) {

   431         catch (IOException e) {

   451         }

   433         }

   452         finally {

   434         finally {

   453             lock.unlock();

   435             lock.unlock();

   454         }

   436         }

   455     }

   437     }

   459      * for file entries and directories.

   441      * for file entries and directories.

   460      *

   442      *

   461      * @param path A path within the zip.

   443      * @param path A path within the zip.

   462      * @return True if the path is a file or dir, false otherwise.

   444      * @return True if the path is a file or dir, false otherwise.

   463      */

   445      */

   465         lock.lock();

   447         lock.lock();

   466         try {

   448         try {

   467             checkIndex();

   449             checkIndex();

   468             return getZipIndexEntry(path) != null;

   450             return getZipIndexEntry(path) != null;

   469         }

   451         }

   473         finally {

   455         finally {

   474             lock.unlock();

   456             lock.unlock();

   475         }

   457         }

   476     }

   458     }

   477 

   459 

   479         lock.lock();

   461         lock.lock();

   480         try {

   462         try {

   481             // The top level in a zip file is always a directory.

   463             // The top level in a zip file is always a directory.

   483                 lastReferenceTimeStamp = System.currentTimeMillis();

   465                 lastReferenceTimeStamp = System.currentTimeMillis();

   484                 return true;

   466                 return true;

   485             }

   467             }

   486 

   468 

   489             checkIndex();

   469             checkIndex();

   490             return directories.get(path) != null;

   470             return directories.get(path) != null;

   491         }

   471         }

   492         finally {

   472         finally {

   493             lock.unlock();

   473             lock.unlock();

   494         }

   474         }

   495     }

   475     }

   496 

   476 

   498         lock.lock();

   478         lock.lock();

   499         try {

   479         try {

   500             Entry entry = getZipIndexEntry(path);

   480             Entry entry = getZipIndexEntry(path);

   501             if (entry == null)

   481             if (entry == null)

   502                 throw new FileNotFoundException();

   482                 throw new FileNotFoundException();

   505         finally {

   485         finally {

   506             lock.unlock();

   486             lock.unlock();

   507         }

   487         }

   508     }

   488     }

   509 

   489 

   511         lock.lock();

   491         lock.lock();

   512         try {

   492         try {

   513             Entry entry = getZipIndexEntry(path);

   493             Entry entry = getZipIndexEntry(path);

   514             if (entry == null)

   494             if (entry == null)

   515                 throw new FileNotFoundException();

   495                 throw new FileNotFoundException();

   529         finally {

   509         finally {

   530             lock.unlock();

   510             lock.unlock();

   531         }

   511         }

   532     }

   512     }

   533 

   513 

   535         lock.lock();

   515         lock.lock();

   536         try {

   516         try {

   537             Entry entry = getZipIndexEntry(path);

   517             Entry entry = getZipIndexEntry(path);

   538             if (entry == null)

   518             if (entry == null)

   540             return read(entry);

   520             return read(entry);

   541         }

   521         }

   542         finally {

   522         finally {

   543             lock.unlock();

   523             lock.unlock();

   544         }

   524         }

   555         finally {

   535         finally {

   556             lock.unlock();

   536             lock.unlock();

   557         }

   537         }

   558     }

   538     }

   559 

   539 

   561         lock.lock();

   541         lock.lock();

   562         try {

   542         try {

   563             Entry entry = getZipIndexEntry(path);

   543             Entry entry = getZipIndexEntry(path);

   564             if (entry == null)

   544             if (entry == null)

   565                 throw new FileNotFoundException();

   545                 throw new FileNotFoundException();

   688     /* ----------------------------------------------------------------------------

   668     /* ----------------------------------------------------------------------------

   689      * ZipDirectory

   669      * ZipDirectory

   690      * ----------------------------------------------------------------------------*/

   670      * ----------------------------------------------------------------------------*/

   691 

   671 

   692     private class ZipDirectory {

   672     private class ZipDirectory {

   694         private int lastStart;

   674         private int lastStart;

   695         private int lastLen;

   675         private int lastLen;

   696 

   676 

   697         byte[] zipDir;

   677         byte[] zipDir;

   698         RandomAccessFile zipRandomFile = null;

   678         RandomAccessFile zipRandomFile = null;

   745                     endbufend = endbufpos + 21;

   725                     endbufend = endbufpos + 21;

   746                 }

   726                 }

   747             }

   727             }

   748             throw new ZipException("cannot read zip file");

   728             throw new ZipException("cannot read zip file");

   749         }

   729         }

   750         private void buildIndex() throws IOException {

   731         private void buildIndex() throws IOException {

   751             int entryCount = get2ByteLittleEndian(zipDir, 0);

   732             int entryCount = get2ByteLittleEndian(zipDir, 0);

   752 

   733 

   754             // Add each of the files

   734             // Add each of the files

   755             if (entryCount > 0) {

   735             if (entryCount > 0) {

   757                 ArrayList<Entry> entryList = new ArrayList<Entry>();

   737                 ArrayList<Entry> entryList = new ArrayList<Entry>();

   758                 int pos = 2;

   738                 int pos = 2;

   759                 for (int i = 0; i < entryCount; i++) {

   739                 for (int i = 0; i < entryCount; i++) {

   760                     pos = readEntry(pos, entryList, directories);

   740                     pos = readEntry(pos, entryList, directories);

   761                 }

   741                 }

   762 

   742 

   763                 // Add the accumulated dirs into the same list

   743                 // Add the accumulated dirs into the same list

   767                     zipFileIndexEntry.isDir = true;

   749                     zipFileIndexEntry.isDir = true;

   768                     entryList.add(zipFileIndexEntry);

   750                     entryList.add(zipFileIndexEntry);

   769                 }

   751                 }

   770 

   752 

   771                 entries = entryList.toArray(new Entry[entryList.size()]);

   753                 entries = entryList.toArray(new Entry[entryList.size()]);

   774                 cleanupState();

   756                 cleanupState();

   775             }

   757             }

   776         }

   758         }

   777 

   759 

   778         private int readEntry(int pos, List<Entry> entryList,

   760         private int readEntry(int pos, List<Entry> entryList,

   780             if (get4ByteLittleEndian(zipDir, pos) != 0x02014b50) {

   762             if (get4ByteLittleEndian(zipDir, pos) != 0x02014b50) {

   781                 throw new ZipException("cannot read zip file entry");

   763                 throw new ZipException("cannot read zip file entry");

   782             }

   764             }

   783 

   765 

   784             int dirStart = pos + 46;

   766             int dirStart = pos + 46;

   788             if (zipFileIndex.symbolFilePrefixLength != 0 &&

   770             if (zipFileIndex.symbolFilePrefixLength != 0 &&

   789                     ((fileEnd - fileStart) >= symbolFilePrefixLength)) {

   771                     ((fileEnd - fileStart) >= symbolFilePrefixLength)) {

   790                 dirStart += zipFileIndex.symbolFilePrefixLength;

   772                 dirStart += zipFileIndex.symbolFilePrefixLength;

   791                fileStart += zipFileIndex.symbolFilePrefixLength;

   773                fileStart += zipFileIndex.symbolFilePrefixLength;

   792             }

   774             }

   795             for (int index = fileStart; index < fileEnd; index++) {

   776             for (int index = fileStart; index < fileEnd; index++) {

   796                 byte nextByte = zipDir[index];

   777                 byte nextByte = zipDir[index];

   799                     fileStart = index + 1;

   780                     fileStart = index + 1;

   804             if (fileStart == dirStart)

   787             if (fileStart == dirStart)

   806             else if (lastDir != null && lastLen == fileStart - dirStart - 1) {

   789             else if (lastDir != null && lastLen == fileStart - dirStart - 1) {

   807                 int index = lastLen - 1;

   790                 int index = lastLen - 1;

   808                 while (zipDir[lastStart + index] == zipDir[dirStart + index]) {

   791                 while (zipDir[lastStart + index] == zipDir[dirStart + index]) {

   809                     if (index == 0) {

   792                     if (index == 0) {

   810                         directory = lastDir;

   793                         directory = lastDir;

   817             // Sub directories

   800             // Sub directories

   818             if (directory == null) {

   801             if (directory == null) {

   819                 lastStart = dirStart;

   802                 lastStart = dirStart;

   820                 lastLen = fileStart - dirStart - 1;

   803                 lastLen = fileStart - dirStart - 1;

   821 

   804 

   823                 lastDir = directory;

   806                 lastDir = directory;

   824 

   807 

   825                 // Enter also all the parent directories

   808                 // Enter also all the parent directories

   827 

   810 

   828                 while (directories.get(tempDirectory) == null) {

   811                 while (directories.get(tempDirectory) == null) {

   829                     directories.put(tempDirectory, new DirectoryEntry(tempDirectory, zipFileIndex));

   812                     directories.put(tempDirectory, new DirectoryEntry(tempDirectory, zipFileIndex));

   832                         break;

   814                         break;

   834                 }

   819                 }

   835             }

   820             }

   836             else {

   821             else {

   838                 if (directories.get(directory) == null) {

   822                 if (directories.get(directory) == null) {

   839                     directories.put(directory, new DirectoryEntry(directory, zipFileIndex));

   823                     directories.put(directory, new DirectoryEntry(directory, zipFileIndex));

   840                 }

   824                 }

   841             }

   825             }

   842 

   826 

   884         private boolean zipFileEntriesInited;

   868         private boolean zipFileEntriesInited;

   885         private boolean entriesInited;

   869         private boolean entriesInited;

   886 

   870 

   887         private long writtenOffsetOffset = 0;

   871         private long writtenOffsetOffset = 0;

   888 

   872 

   890 

   874 

   891         private com.sun.tools.javac.util.List<String> zipFileEntriesFiles = com.sun.tools.javac.util.List.<String>nil();

   875         private com.sun.tools.javac.util.List<String> zipFileEntriesFiles = com.sun.tools.javac.util.List.<String>nil();

   892         private com.sun.tools.javac.util.List<String> zipFileEntriesDirectories = com.sun.tools.javac.util.List.<String>nil();

   876         private com.sun.tools.javac.util.List<String> zipFileEntriesDirectories = com.sun.tools.javac.util.List.<String>nil();

   893         private com.sun.tools.javac.util.List<Entry>  zipFileEntries = com.sun.tools.javac.util.List.<Entry>nil();

   877         private com.sun.tools.javac.util.List<Entry>  zipFileEntries = com.sun.tools.javac.util.List.<Entry>nil();

   894 

   878 

   896 

   880 

   897         private ZipFileIndex zipFileIndex;

   881         private ZipFileIndex zipFileIndex;

   898 

   882 

   899         private int numEntries;

   883         private int numEntries;

   900 

   884 

   903             directoriesInited = false;

   887             directoriesInited = false;

   904             entriesInited = false;

   888             entriesInited = false;

   905 

   889 

   914             this.zipFileIndex = index;

   891             this.zipFileIndex = index;

   915         }

   892         }

   916 

   893 

   917         private com.sun.tools.javac.util.List<String> getFiles() {

   894         private com.sun.tools.javac.util.List<String> getFiles() {

   930             return zipFileEntriesFiles;

   904             return zipFileEntriesFiles;

   931         }

   905         }

   932 

   906 

   933         private com.sun.tools.javac.util.List<String> getDirectories() {

   907         private com.sun.tools.javac.util.List<String> getDirectories() {

   948             return zipFileEntriesDirectories;

   917             return zipFileEntriesDirectories;

   949         }

   918         }

   950 

   919 

   951         private com.sun.tools.javac.util.List<Entry> getEntries() {

   920         private com.sun.tools.javac.util.List<Entry> getEntries() {

   965             return zipFileEntries;

   929             return zipFileEntries;

   966         }

   930         }

   967 

   931 

   968         private Entry getEntry(String rootName) {

   932         private Entry getEntry(String rootName) {

   969             initEntries();

   933             initEntries();

   983             if (!zipFileIndex.readFromIndex) {

   947             if (!zipFileIndex.readFromIndex) {

   984                 int from = -Arrays.binarySearch(zipFileIndex.entries,

   948                 int from = -Arrays.binarySearch(zipFileIndex.entries,

   985                         new Entry(dirName, ZipFileIndex.MIN_CHAR)) - 1;

   949                         new Entry(dirName, ZipFileIndex.MIN_CHAR)) - 1;

   986                 int to = -Arrays.binarySearch(zipFileIndex.entries,

   950                 int to = -Arrays.binarySearch(zipFileIndex.entries,

   987                         new Entry(dirName, MAX_CHAR)) - 1;

   951                         new Entry(dirName, MAX_CHAR)) - 1;

   990 

   952 

   991                 for (int i = from; i < to; i++) {

   953                 for (int i = from; i < to; i++) {

   992                     entries.add(zipFileIndex.entries[i]);

   954                     entries.add(zipFileIndex.entries[i]);

   993                 }

   955                 }

   994             } else {

   956             } else {

  1069 

  1031 

  1070                 long fileStamp = raf.readLong();

  1032                 long fileStamp = raf.readLong();

  1071                 if (zipFile.lastModified() != fileStamp) {

  1033                 if (zipFile.lastModified() != fileStamp) {

  1072                     ret = false;

  1034                     ret = false;

  1073                 } else {

  1035                 } else {

  1075                     int numDirs = raf.readInt();

  1037                     int numDirs = raf.readInt();

  1076                     for (int nDirs = 0; nDirs < numDirs; nDirs++) {

  1038                     for (int nDirs = 0; nDirs < numDirs; nDirs++) {

  1077                         int dirNameBytesLen = raf.readInt();

  1039                         int dirNameBytesLen = raf.readInt();

  1078                         byte [] dirNameBytes = new byte[dirNameBytesLen];

  1040                         byte [] dirNameBytes = new byte[dirNameBytesLen];

  1079                         raf.read(dirNameBytes);

  1041                         raf.read(dirNameBytes);

  1080 

  1042 

  1082                         DirectoryEntry de = new DirectoryEntry(dirNameStr, this);

  1044                         DirectoryEntry de = new DirectoryEntry(dirNameStr, this);

  1083                         de.numEntries = raf.readInt();

  1045                         de.numEntries = raf.readInt();

  1084                         de.writtenOffsetOffset = raf.readLong();

  1046                         de.writtenOffsetOffset = raf.readLong();

  1085                         directories.put(dirNameStr, de);

  1047                         directories.put(dirNameStr, de);

  1086                     }

  1048                     }

  1130             raf = new RandomAccessFile(indexFile, "rw");

  1092             raf = new RandomAccessFile(indexFile, "rw");

  1131 

  1093 

  1132             raf.writeLong(zipFileLastModified);

  1094             raf.writeLong(zipFileLastModified);

  1133             writtenSoFar += 8;

  1095             writtenSoFar += 8;

  1134 

  1096 

  1137             List<DirectoryEntry> directoriesToWrite = new ArrayList<DirectoryEntry>();

  1097             List<DirectoryEntry> directoriesToWrite = new ArrayList<DirectoryEntry>();

  1139             raf.writeInt(directories.keySet().size());

  1099             raf.writeInt(directories.keySet().size());

  1140             writtenSoFar += 4;

  1100             writtenSoFar += 4;

  1141 

  1101 

  1144                 DirectoryEntry dirEntry = directories.get(dirName);

  1103                 DirectoryEntry dirEntry = directories.get(dirName);

  1145 

  1104 

  1146                 directoriesToWrite.add(dirEntry);

  1105                 directoriesToWrite.add(dirEntry);

  1147 

  1106 

  1148                 // Write the dir name bytes

  1107                 // Write the dir name bytes

  1150                 int dirNameBytesLen = dirNameBytes.length;

  1109                 int dirNameBytesLen = dirNameBytes.length;

  1151                 raf.writeInt(dirNameBytesLen);

  1110                 raf.writeInt(dirNameBytesLen);

  1152                 writtenSoFar += 4;

  1111                 writtenSoFar += 4;

  1153 

  1112 

  1154                 raf.write(dirNameBytes);

  1113                 raf.write(dirNameBytes);

  1249 

  1208 

  1250     public File getZipFile() {

  1209     public File getZipFile() {

  1251         return zipFile;

  1210         return zipFile;

  1252     }

  1211     }

  1253 

  1212 

  1254 

  1225 

  1255     static class Entry implements Comparable<Entry> {

  1226     static class Entry implements Comparable<Entry> {

  1256         public static final Entry[] EMPTY_ARRAY = {};

  1227         public static final Entry[] EMPTY_ARRAY = {};

  1257 

  1228 

  1258         // Directory related

  1229         // Directory related

  1260         boolean isDir;

  1231         boolean isDir;

  1261 

  1232 

  1262         // File related

  1233         // File related

  1263         String name;

  1234         String name;

  1264 

  1235 

  1267         int compressedSize;

  1238         int compressedSize;

  1268         long javatime;

  1239         long javatime;

  1269 

  1240 

  1270         private int nativetime;

  1241         private int nativetime;

  1271 

  1242 

  1285             this.name = name;

  1249             this.name = name;

  1286         }

  1250         }

  1287 

  1251 

  1288         public String getName() {

  1252         public String getName() {

  1298         }

  1254         }

  1299 

  1255 

  1300         public String getFileName() {

  1256         public String getFileName() {

  1301             return name;

  1257             return name;

  1302         }

  1258         }

  1329         public boolean isDirectory() {

  1285         public boolean isDirectory() {

  1330             return isDir;

  1286             return isDir;

  1331         }

  1287         }

  1332 

  1288 

  1333         public int compareTo(Entry other) {

  1289         public int compareTo(Entry other) {

  1335             if (dir != otherD) {

  1291             if (dir != otherD) {

  1336                 int c = dir.compareTo(otherD);

  1292                 int c = dir.compareTo(otherD);

  1337                 if (c != 0)

  1293                 if (c != 0)

  1338                     return c;

  1294                     return c;

  1339             }

  1295             }

  1340             return name.compareTo(other.name);

  1296             return name.compareTo(other.name);

  1341         }

  1297         }

  1342 

  1298 

  1343 

  1315 

  1344         public String toString() {

  1316         public String toString() {

  1345             return isDir ? ("Dir:" + dir + " : " + name) :

  1317             return isDir ? ("Dir:" + dir + " : " + name) :

  1346                 (dir + ":" + name);

  1318                 (dir + ":" + name);

  1347         }

  1319         }