    001/*
    002 *  Licensed to the Apache Software Foundation (ASF) under one or more
    003 *  contributor license agreements.  See the NOTICE file distributed with
    004 *  this work for additional information regarding copyright ownership.
    005 *  The ASF licenses this file to You under the Apache License, Version 2.0
    006 *  (the "License"); you may not use this file except in compliance with
    007 *  the License.  You may obtain a copy of the License at
    008 *
    009 *     http://www.apache.org/licenses/LICENSE-2.0
    010 *
    011 *  Unless required by applicable law or agreed to in writing, software
    012 *  distributed under the License is distributed on an "AS IS" BASIS,
    013 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    014 *  See the License for the specific language governing permissions and
    015 *  limitations under the License.
    016 */
    017package org.apache.commons.compress.harmony.unpack200;
    018
    019import java.io.BufferedInputStream;
    020import java.io.ByteArrayInputStream;
    021import java.io.ByteArrayOutputStream;
    022import java.io.DataOutputStream;
    023import java.io.IOException;
    024import java.io.InputStream;
    025import java.io.OutputStream;
    026import java.io.OutputStreamWriter;
    027import java.io.PrintWriter;
    028import java.nio.charset.Charset;
    029import java.util.ArrayList;
    030import java.util.HashSet;
    031import java.util.List;
    032import java.util.Set;
    033import java.util.TimeZone;
    034import java.util.jar.JarEntry;
    035import java.util.jar.JarOutputStream;
    036import java.util.zip.CRC32;
    037import java.util.zip.GZIPInputStream;
    038import java.util.zip.ZipEntry;
    039
    040import org.apache.commons.compress.harmony.pack200.Codec;
    041import org.apache.commons.compress.harmony.pack200.Pack200Exception;
    042import org.apache.commons.compress.harmony.unpack200.bytecode.Attribute;
    043import org.apache.commons.compress.harmony.unpack200.bytecode.CPClass;
    044import org.apache.commons.compress.harmony.unpack200.bytecode.CPField;
    045import org.apache.commons.compress.harmony.unpack200.bytecode.CPMethod;
    046import org.apache.commons.compress.harmony.unpack200.bytecode.CPUTF8;
    047import org.apache.commons.compress.harmony.unpack200.bytecode.ClassConstantPool;
    048import org.apache.commons.compress.harmony.unpack200.bytecode.ClassFile;
    049import org.apache.commons.compress.harmony.unpack200.bytecode.ClassFileEntry;
    050import org.apache.commons.compress.harmony.unpack200.bytecode.InnerClassesAttribute;
    051import org.apache.commons.compress.harmony.unpack200.bytecode.SourceFileAttribute;
    052import org.apache.commons.io.input.BoundedInputStream;
    053
    054/**
    055 * A Pack200 archive consists of one or more segments. Each segment is stand-alone, in the sense that every segment has the magic number header; thus, every
    056 * segment is also a valid archive. However, it is possible to combine (non-GZipped) archives into a single large archive by concatenation alone. Thus, all the
    057 * hard work in unpacking an archive falls to understanding a segment.
    058 *
    059 * The first component of a segment is the header; this contains (amongst other things) the expected counts of constant pool entries, which in turn defines how
    060 * many values need to be read from the stream. Because values are variable width (see {@link Codec}), it is not possible to calculate the start of the next
    061 * segment, although one of the header values does hint at the size of the segment if non-zero, which can be used for buffering purposes.
    062 *
    063 * Note that this does not perform any buffering of the input stream; each value will be read on a byte-by-byte basis. It does not perform GZip decompression
    064 * automatically; both of these are expected to be done by the caller if the stream has the magic header for GZip streams ({@link GZIPInputStream#GZIP_MAGIC}).
    065 * In any case, if GZip decompression is being performed the input stream will be buffered at a higher level, and thus this can read on a byte-oriented basis.
    066 */
    067public class Segment {
    068
    069    public static final int LOG_LEVEL_VERBOSE = 2;
    070
    071    public static final int LOG_LEVEL_STANDARD = 1;
    072
    073    public static final int LOG_LEVEL_QUIET = 0;
    074
    075    private SegmentHeader header;
    076
    077    private CpBands cpBands;
    078
    079    private AttrDefinitionBands attrDefinitionBands;
    080
    081    private IcBands icBands;
    082
    083    private ClassBands classBands;
    084
    085    private BcBands bcBands;
    086
    087    private FileBands fileBands;
    088
    089    private boolean overrideDeflateHint;
    090
    091    private boolean deflateHint;
    092
    093    private boolean doPreRead;
    094
    095    private int logLevel;
    096
    097    private PrintWriter logStream;
    098
    099    private byte[][] classFilesContents;
    100
    101    private boolean[] fileDeflate;
    102
    103    private boolean[] fileIsClass;
    104
    105    private InputStream internalBuffer;
    106
    107    private ClassFile buildClassFile(final int classNum) {
    108        final ClassFile classFile = new ClassFile();
    109        final int[] major = classBands.getClassVersionMajor();
    110        final int[] minor = classBands.getClassVersionMinor();
    111        if (major != null) {
    112            classFile.major = major[classNum];
    113            classFile.minor = minor[classNum];
    114        } else {
    115            classFile.major = header.getDefaultClassMajorVersion();
    116            classFile.minor = header.getDefaultClassMinorVersion();
    117        }
    118        // build constant pool
    119        final ClassConstantPool cp = classFile.pool;
    120        final int fullNameIndexInCpClass = classBands.getClassThisInts()[classNum];
    121        final String fullName = cpBands.getCpClass()[fullNameIndexInCpClass];
    122        // SourceFile attribute
    123        int i = fullName.lastIndexOf("/") + 1; // if lastIndexOf==-1, then
    124        // -1+1=0, so str.substring(0)
    125        // == str
    126
    127        // Get the source file attribute
    128        final List<Attribute> classAttributes = classBands.getClassAttributes()[classNum];
    129        SourceFileAttribute sourceFileAttribute = null;
    130        for (final Attribute classAttribute : classAttributes) {
    131            if (classAttribute.isSourceFileAttribute()) {
    132                sourceFileAttribute = (SourceFileAttribute) classAttribute;
    133            }
    134        }
    135
    136        if (sourceFileAttribute == null) {
    137            // If we don't have a source file attribute yet, we need
    138            // to infer it from the class.
    139            final AttributeLayout SOURCE_FILE = attrDefinitionBands.getAttributeDefinitionMap().getAttributeLayout(AttributeLayout.ATTRIBUTE_SOURCE_FILE,
    140                    AttributeLayout.CONTEXT_CLASS);
    141            if (SOURCE_FILE.matches(classBands.getRawClassFlags()[classNum])) {
    142                int firstDollar = -1;
    143                for (int index = 0; index < fullName.length(); index++) {
    144                    if (fullName.charAt(index) <= '$') {
    145                        firstDollar = index;
    146                    }
    147                }
    148                String fileName;
    149
    150                if (firstDollar > -1 && i <= firstDollar) {
    151                    fileName = fullName.substring(i, firstDollar) + ".java";
    152                } else {
    153                    fileName = fullName.substring(i) + ".java";
    154                }
    155                sourceFileAttribute = new SourceFileAttribute(cpBands.cpUTF8Value(fileName, false));
    156                classFile.attributes = new Attribute[] { (Attribute) cp.add(sourceFileAttribute) };
    157            } else {
    158                classFile.attributes = new Attribute[] {};
    159            }
    160        } else {
    161            classFile.attributes = new Attribute[] { (Attribute) cp.add(sourceFileAttribute) };
    162        }
    163
    164        // If we see any class attributes, add them to the class's attributes
    165        // that will
    166        // be written out. Keep SourceFileAttributes out since we just
    167        // did them above.
    168        final List<Attribute> classAttributesWithoutSourceFileAttribute = new ArrayList<>(classAttributes.size());
    169        for (int index = 0; index < classAttributes.size(); index++) {
    170            final Attribute attrib = classAttributes.get(index);
    171            if (!attrib.isSourceFileAttribute()) {
    172                classAttributesWithoutSourceFileAttribute.add(attrib);
    173            }
    174        }
    175        final Attribute[] originalAttributes = classFile.attributes;
    176        classFile.attributes = new Attribute[originalAttributes.length + classAttributesWithoutSourceFileAttribute.size()];
    177        System.arraycopy(originalAttributes, 0, classFile.attributes, 0, originalAttributes.length);
    178        for (int index = 0; index < classAttributesWithoutSourceFileAttribute.size(); index++) {
    179            final Attribute attrib = classAttributesWithoutSourceFileAttribute.get(index);
    180            cp.add(attrib);
    181            classFile.attributes[originalAttributes.length + index] = attrib;
    182        }
    183
    184        // this/superclass
    185        final ClassFileEntry cfThis = cp.add(cpBands.cpClassValue(fullNameIndexInCpClass));
    186        final ClassFileEntry cfSuper = cp.add(cpBands.cpClassValue(classBands.getClassSuperInts()[classNum]));
    187        // add interfaces
    188        final ClassFileEntry[] cfInterfaces = new ClassFileEntry[classBands.getClassInterfacesInts()[classNum].length];
    189        for (i = 0; i < cfInterfaces.length; i++) {
    190            cfInterfaces[i] = cp.add(cpBands.cpClassValue(classBands.getClassInterfacesInts()[classNum][i]));
    191        }
    192        // add fields
    193        final ClassFileEntry[] cfFields = new ClassFileEntry[classBands.getClassFieldCount()[classNum]];
    194        // fieldDescr and fieldFlags used to create this
    195        for (i = 0; i < cfFields.length; i++) {
    196            final int descriptorIndex = classBands.getFieldDescrInts()[classNum][i];
    197            final int nameIndex = cpBands.getCpDescriptorNameInts()[descriptorIndex];
    198            final int typeIndex = cpBands.getCpDescriptorTypeInts()[descriptorIndex];
    199            final CPUTF8 name = cpBands.cpUTF8Value(nameIndex);
    200            final CPUTF8 descriptor = cpBands.cpSignatureValue(typeIndex);
    201            cfFields[i] = cp.add(new CPField(name, descriptor, classBands.getFieldFlags()[classNum][i], classBands.getFieldAttributes()[classNum][i]));
    202        }
    203        // add methods
    204        final ClassFileEntry[] cfMethods = new ClassFileEntry[classBands.getClassMethodCount()[classNum]];
    205        // methodDescr and methodFlags used to create this
    206        for (i = 0; i < cfMethods.length; i++) {
    207            final int descriptorIndex = classBands.getMethodDescrInts()[classNum][i];
    208            final int nameIndex = cpBands.getCpDescriptorNameInts()[descriptorIndex];
    209            final int typeIndex = cpBands.getCpDescriptorTypeInts()[descriptorIndex];
    210            final CPUTF8 name = cpBands.cpUTF8Value(nameIndex);
    211            final CPUTF8 descriptor = cpBands.cpSignatureValue(typeIndex);
    212            cfMethods[i] = cp.add(new CPMethod(name, descriptor, classBands.getMethodFlags()[classNum][i], classBands.getMethodAttributes()[classNum][i]));
    213        }
    214        cp.addNestedEntries();
    215
    216        // add inner class attribute (if required)
    217        boolean addInnerClassesAttr = false;
    218        final IcTuple[] icLocal = getClassBands().getIcLocal()[classNum];
    219        final boolean icLocalSent = icLocal != null;
    220        final InnerClassesAttribute innerClassesAttribute = new InnerClassesAttribute("InnerClasses");
    221        final IcTuple[] icRelevant = getIcBands().getRelevantIcTuples(fullName, cp);
    222        final List<IcTuple> ic_stored = computeIcStored(icLocal, icRelevant);
    223        for (final IcTuple icStored : ic_stored) {
    224            final int innerClassIndex = icStored.thisClassIndex();
    225            final int outerClassIndex = icStored.outerClassIndex();
    226            final int simpleClassNameIndex = icStored.simpleClassNameIndex();
    227
    228            final String innerClassString = icStored.thisClassString();
    229            final String outerClassString = icStored.outerClassString();
    230            final String simpleClassName = icStored.simpleClassName();
    231
    232            CPUTF8 innerName = null;
    233            CPClass outerClass = null;
    234
    235            final CPClass innerClass = innerClassIndex != -1 ? cpBands.cpClassValue(innerClassIndex) : cpBands.cpClassValue(innerClassString);
    236            if (!icStored.isAnonymous()) {
    237                innerName = simpleClassNameIndex != -1 ? cpBands.cpUTF8Value(simpleClassNameIndex) : cpBands.cpUTF8Value(simpleClassName);
    238            }
    239
    240            if (icStored.isMember()) {
    241                outerClass = outerClassIndex != -1 ? cpBands.cpClassValue(outerClassIndex) : cpBands.cpClassValue(outerClassString);
    242            }
    243            final int flags = icStored.F;
    244            innerClassesAttribute.addInnerClassesEntry(innerClass, outerClass, innerName, flags);
    245            addInnerClassesAttr = true;
    246        }
    247        // If ic_local is sent, and it's empty, don't add
    248        // the inner classes attribute.
    249        if (icLocalSent && icLocal.length == 0) {
    250            addInnerClassesAttr = false;
    251        }
    252
    253        // If ic_local is not sent and ic_relevant is empty,
    254        // don't add the inner class attribute.
    255        if (!icLocalSent && icRelevant.length == 0) {
    256            addInnerClassesAttr = false;
    257        }
    258
    259        if (addInnerClassesAttr) {
    260            // Need to add the InnerClasses attribute to the
    261            // existing classFile attributes.
    262            final Attribute[] originalAttrs = classFile.attributes;
    263            final Attribute[] newAttrs = new Attribute[originalAttrs.length + 1];
    264            System.arraycopy(originalAttrs, 0, newAttrs, 0, originalAttrs.length);
    265            newAttrs[newAttrs.length - 1] = innerClassesAttribute;
    266            classFile.attributes = newAttrs;
    267            cp.addWithNestedEntries(innerClassesAttribute);
    268        }
    269        // sort CP according to cp_All
    270        cp.resolve(this);
    271        // NOTE the indexOf is only valid after the cp.resolve()
    272        // build up remainder of file
    273        classFile.accessFlags = (int) classBands.getClassFlags()[classNum];
    274        classFile.thisClass = cp.indexOf(cfThis);
    275        classFile.superClass = cp.indexOf(cfSuper);
    276        // TODO placate format of file for writing purposes
    277        classFile.interfaces = new int[cfInterfaces.length];
    278        for (i = 0; i < cfInterfaces.length; i++) {
    279            classFile.interfaces[i] = cp.indexOf(cfInterfaces[i]);
    280        }
    281        classFile.fields = cfFields;
    282        classFile.methods = cfMethods;
    283        return classFile;
    284    }
    285
    286    /**
    287     * Given an ic_local and an ic_relevant, use them to calculate what should be added as ic_stored.
    288     *
    289     * @param icLocal    IcTuple[] array of local transmitted tuples
    290     * @param icRelevant IcTuple[] array of relevant tuples
    291     * @return List of tuples to be stored. If ic_local is null or empty, the values returned may not be correct. The caller will have to determine if this is
    292     *         the case.
    293     */
    294    private List<IcTuple> computeIcStored(final IcTuple[] icLocal, final IcTuple[] icRelevant) {
    295        final List<IcTuple> result = new ArrayList<>(icRelevant.length);
    296        final List<IcTuple> duplicates = new ArrayList<>(icRelevant.length);
    297        final Set<IcTuple> isInResult = new HashSet<>(icRelevant.length);
    298
    299        // need to compute:
    300        // result = ic_local XOR ic_relevant
    301
    302        // add ic_local
    303        if (icLocal != null) {
    304            for (final IcTuple element : icLocal) {
    305                if (isInResult.add(element)) {
    306                    result.add(element);
    307                }
    308            }
    309        }
    310
    311        // add ic_relevant
    312        for (final IcTuple element : icRelevant) {
    313            if (isInResult.add(element)) {
    314                result.add(element);
    315            } else {
    316                duplicates.add(element);
    317            }
    318        }
    319
    320        // eliminate "duplicates"
    321        duplicates.forEach(result::remove);
    322
    323        return result;
    324    }
    325
    326    protected AttrDefinitionBands getAttrDefinitionBands() {
    327        return attrDefinitionBands;
    328    }
    329
    330    protected ClassBands getClassBands() {
    331        return classBands;
    332    }
    333
    334    public SegmentConstantPool getConstantPool() {
    335        return cpBands.getConstantPool();
    336    }
    337
    338    protected CpBands getCpBands() {
    339        return cpBands;
    340    }
    341
    342    protected IcBands getIcBands() {
    343        return icBands;
    344    }
    345
    346    public SegmentHeader getSegmentHeader() {
    347        return header;
    348    }
    349
    350    public void log(final int logLevel, final String message) {
    351        if (this.logLevel >= logLevel) {
    352            logStream.println(message);
    353        }
    354    }
    355
    356    /**
    357     * Override the archive's deflate hint with the given boolean
    358     *
    359     * @param deflateHint - the deflate hint to use
    360     */
    361    public void overrideDeflateHint(final boolean deflateHint) {
    362        this.overrideDeflateHint = true;
    363        this.deflateHint = deflateHint;
    364    }
    365
    366    /**
    367     * This performs the actual work of parsing against a non-static instance of Segment. This method is intended to run concurrently for multiple segments.
    368     *
    369     * @throws IOException      if a problem occurs during reading from the underlying stream
    370     * @throws Pack200Exception if a problem occurs with an unexpected value or unsupported codec
    371     */
    372    private void parseSegment() throws IOException, Pack200Exception {
    373
    374        header.unpack();
    375        cpBands.unpack();
    376        attrDefinitionBands.unpack();
    377        icBands.unpack();
    378        classBands.unpack();
    379        bcBands.unpack();
    380        fileBands.unpack();
    381
    382        int classNum = 0;
    383        final int numberOfFiles = header.getNumberOfFiles();
    384        final String[] fileName = fileBands.getFileName();
    385        final int[] fileOptions = fileBands.getFileOptions();
    386        final SegmentOptions options = header.getOptions();
    387
    388        classFilesContents = new byte[numberOfFiles][];
    389        fileDeflate = new boolean[numberOfFiles];
    390        fileIsClass = new boolean[numberOfFiles];
    391
    392        final ByteArrayOutputStream bos = new ByteArrayOutputStream();
    393        final DataOutputStream dos = new DataOutputStream(bos);
    394
    395        for (int i = 0; i < numberOfFiles; i++) {
    396            String name = fileName[i];
    397
    398            final boolean nameIsEmpty = name == null || name.isEmpty();
    399            final boolean isClass = (fileOptions[i] & 2) == 2 || nameIsEmpty;
    400            if (isClass && nameIsEmpty) {
    401                name = cpBands.getCpClass()[classBands.getClassThisInts()[classNum]] + ".class";
    402                fileName[i] = name;
    403            }
    404
    405            if (!overrideDeflateHint) {
    406                fileDeflate[i] = (fileOptions[i] & 1) == 1 || options.shouldDeflate();
    407            } else {
    408                fileDeflate[i] = deflateHint;
    409            }
    410
    411            fileIsClass[i] = isClass;
    412
    413            if (isClass) {
    414                final ClassFile classFile = buildClassFile(classNum);
    415                classFile.write(dos);
    416                dos.flush();
    417
    418                classFilesContents[classNum] = bos.toByteArray();
    419                bos.reset();
    420
    421                classNum++;
    422            }
    423        }
    424    }
    425
    426    /**
    427     * This performs reading the data from the stream into non-static instance of Segment. After the completion of this method stream can be freed.
    428     *
    429     * @param in the input stream to read from
    430     * @throws IOException      if a problem occurs during reading from the underlying stream
    431     * @throws Pack200Exception if a problem occurs with an unexpected value or unsupported codec
    432     */
    433    private void readSegment(final InputStream in) throws IOException, Pack200Exception {
    434        log(LOG_LEVEL_VERBOSE, "-------");
    435        cpBands = new CpBands(this);
    436        cpBands.read(in);
    437        attrDefinitionBands = new AttrDefinitionBands(this);
    438        attrDefinitionBands.read(in);
    439        icBands = new IcBands(this);
    440        icBands.read(in);
    441        classBands = new ClassBands(this);
    442        classBands.read(in);
    443        bcBands = new BcBands(this);
    444        bcBands.read(in);
    445        fileBands = new FileBands(this);
    446        fileBands.read(in);
    447
    448        fileBands.processFileBits();
    449    }
    450
    451    public void setLogLevel(final int logLevel) {
    452        this.logLevel = logLevel;
    453    }
    454
    455    public void setLogStream(final OutputStream logStream) {
    456        this.logStream = new PrintWriter(new OutputStreamWriter(logStream, Charset.defaultCharset()), false);
    457    }
    458
    459    public void setPreRead(final boolean value) {
    460        doPreRead = value;
    461    }
    462
    463    /**
    464     * Unpacks a packed stream (either .pack. or .pack.gz) into a corresponding JarOuputStream.
    465     *
    466     * @param inputStream  a packed input stream, preferably a {@link BoundedInputStream}.
    467     * @param out output stream.
    468     * @throws Pack200Exception if there is a problem unpacking
    469     * @throws IOException      if there is a problem with I/O during unpacking
    470     */
    471    public void unpack(final InputStream inputStream, final JarOutputStream out) throws IOException, Pack200Exception {
    472        unpackRead(inputStream);
    473        unpackProcess();
    474        unpackWrite(out);
    475    }
    476
    477    void unpackProcess() throws IOException, Pack200Exception {
    478        if (internalBuffer != null) {
    479            readSegment(internalBuffer);
    480        }
    481        parseSegment();
    482    }
    483
    484    /*
    485     * Package-private accessors for unpacking stages
    486     */
    487    void unpackRead(final InputStream inputStream) throws IOException, Pack200Exception {
    488        @SuppressWarnings("resource")
    489        final InputStream in = Pack200UnpackerAdapter.newBoundedInputStream(inputStream);
    490
    491        header = new SegmentHeader(this);
    492        header.read(in);
    493
    494        final int size = (int) header.getArchiveSize() - header.getArchiveSizeOffset();
    495
    496        if (doPreRead && header.getArchiveSize() != 0) {
    497            final byte[] data = new byte[size];
    498            in.read(data);
    499            internalBuffer = new BufferedInputStream(new ByteArrayInputStream(data));
    500        } else {
    501            readSegment(in);
    502        }
    503    }
    504
    505    void unpackWrite(final JarOutputStream out) throws IOException {
    506        writeJar(out);
    507        if (logStream != null) {
    508            logStream.close();
    509        }
    510    }
    511
    512    /**
    513     * Writes the segment to an output stream. The output stream should be pre-buffered for efficiency. Also takes the same input stream for reading, since the
    514     * file bits may not be loaded and thus just copied from one stream to another. Doesn't close the output stream when finished, in case there are more
    515     * entries (e.g. further segments) to be written.
    516     *
    517     * @param out the JarOutputStream to write data to
    518     * @throws IOException if an error occurs while reading or writing to the streams
    519     */
    520    public void writeJar(final JarOutputStream out) throws IOException {
    521        final String[] fileName = fileBands.getFileName();
    522        final int[] fileModtime = fileBands.getFileModtime();
    523        final long[] fileSize = fileBands.getFileSize();
    524        final byte[][] fileBits = fileBands.getFileBits();
    525
    526        // now write the files out
    527        int classNum = 0;
    528        final int numberOfFiles = header.getNumberOfFiles();
    529        final long archiveModtime = header.getArchiveModtime();
    530
    531        for (int i = 0; i < numberOfFiles; i++) {
    532            final String name = fileName[i];
    533            // For Pack200 archives, modtime is in seconds
    534            // from the epoch. JarEntries need it to be in
    535            // milliseconds from the epoch.
    536            // Even though we're adding two longs and multiplying
    537            // by 1000, we won't overflow because both longs are
    538            // always under 2^32.
    539            final long modtime = 1000 * (archiveModtime + fileModtime[i]);
    540            final boolean deflate = fileDeflate[i];
    541
    542            final JarEntry entry = new JarEntry(name);
    543            if (deflate) {
    544                entry.setMethod(ZipEntry.DEFLATED);
    545            } else {
    546                entry.setMethod(ZipEntry.STORED);
    547                final CRC32 crc = new CRC32();
    548                if (fileIsClass[i]) {
    549                    crc.update(classFilesContents[classNum]);
    550                    entry.setSize(classFilesContents[classNum].length);
    551                } else {
    552                    crc.update(fileBits[i]);
    553                    entry.setSize(fileSize[i]);
    554                }
    555                entry.setCrc(crc.getValue());
    556            }
    557            // On Windows at least, need to correct for timezone
    558            entry.setTime(modtime - TimeZone.getDefault().getRawOffset());
    559            out.putNextEntry(entry);
    560
    561            // write to output stream
    562            if (fileIsClass[i]) {
    563                entry.setSize(classFilesContents[classNum].length);
    564                out.write(classFilesContents[classNum]);
    565                classNum++;
    566            } else {
    567                entry.setSize(fileSize[i]);
    568                out.write(fileBits[i]);
    569            }
    570        }
    571    }
    572
    573}