zipfileindex.java

是一款用JAVA 编写的编译器 具有很强的编译功能

                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 = ZipFileIndex.EMPTY_LIST;
        private com.sun.tools.javac.util.List<String> zipFileEntriesDirectories = ZipFileIndex.EMPTY_LIST;
        private com.sun.tools.javac.util.List<ZipFileIndexEntry>  zipFileEntries = ZipFileIndex.EMPTY_LIST;
        
        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;
    }
}