/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package com.sun.java.util.jar.pack;

import com.sun.java.util.jar.pack.ConstantPool.ClassEntry;

import com.sun.java.util.jar.pack.ConstantPool.DescriptorEntry;

import com.sun.java.util.jar.pack.ConstantPool.Entry;

import com.sun.java.util.jar.pack.ConstantPool.Index;

import com.sun.java.util.jar.pack.ConstantPool.MemberEntry;

import com.sun.java.util.jar.pack.ConstantPool.SignatureEntry;

import com.sun.java.util.jar.pack.ConstantPool.Utf8Entry;

import java.io.*;

import java.util.*;

import com.sun.java.util.jar.pack.Package.Class;

import com.sun.java.util.jar.pack.Package.File;

import com.sun.java.util.jar.pack.Package.InnerClass;

/**

 * Reader for a package file.

 *

 * @see PackageWriter

 * @author John Rose

 */

class PackageReader extends BandStructure {

    Package pkg;

    byte[] bytes;

    LimitedBuffer in;

    PackageReader(Package pkg, InputStream in) throws IOException {

        this.pkg = pkg;

        this.in = new LimitedBuffer(in);

    }

    /** A buffered input stream which is careful not to

     *  read its underlying stream ahead of a given mark,

     *  called the 'readLimit'.  This property declares

     *  the maximum number of characters that future reads

     *  can consume from the underlying stream.

     */

    static

    class LimitedBuffer extends BufferedInputStream {

        long served;     // total number of charburgers served

        int  servedPos;  // ...as of this value of super.pos

        long limit;      // current declared limit

        long buffered;

        public boolean atLimit() {

            boolean z = (getBytesServed() == limit);

            assert(!z || limit == buffered);

            return z;

        }

        public long getBytesServed() {

            return served + (pos - servedPos);

        }

        public void setReadLimit(long newLimit) {

            if (newLimit == -1)

                limit = -1;

            else

                limit = getBytesServed() + newLimit;

        }

        public long getReadLimit() {

            if (limit == -1)

                return limit;

            else

                return limit - getBytesServed();

        }

        public int read() throws IOException {

            if (pos < count) {

                // fast path

                return buf[pos++] & 0xFF;

            }

            served += (pos - servedPos);

            int ch = super.read();

            servedPos = pos;

            if (ch >= 0)  served += 1;

            assert(served <= limit || limit == -1);

            return ch;

        }

        public int read(byte b[], int off, int len) throws IOException {

            served += (pos - servedPos);

            int nr = super.read(b, off, len);

            servedPos = pos;

            if (nr >= 0)  served += nr;

            assert(served <= limit || limit == -1);

            return nr;

        }

        public long skip(long n) throws IOException {

            throw new RuntimeException("no skipping");

        }

        LimitedBuffer(InputStream originalIn) {

            super(null, 1<<14);

            servedPos = pos;

            super.in = new FilterInputStream(originalIn) {

                public int read() throws IOException {

                    if (buffered == limit)

                        return -1;

                    ++buffered;

                    return super.read();

                }

                public int read(byte b[], int off, int len) throws IOException {

                    if (buffered == limit)

                        return -1;

                    if (limit != -1) {

                        long remaining = limit - buffered;

                        if (len > remaining)

                            len = (int)remaining;

                    }

                    int nr = super.read(b, off, len);

                    if (nr >= 0)  buffered += nr;

                    return nr;

                }

            };

        }

    }

    void read() throws IOException {

        boolean ok = false;

        try {

            //  pack200_archive:

            //        file_header

            //        *band_headers :BYTE1

            //        cp_bands

            //        attr_definition_bands

            //        ic_bands

            //        class_bands

            //        bc_bands

            //        file_bands

            readFileHeader();

            readBandHeaders();

            readConstantPool();  // cp_bands

            readAttrDefs();

            readInnerClasses();

            Class[] classes = readClasses();

            readByteCodes();

            readFiles();     // file_bands

            assert(archiveSize1 == 0 || in.atLimit());

            assert(archiveSize1 == 0 ||

                   in.getBytesServed() == archiveSize0+archiveSize1);

            all_bands.doneDisbursing();

            // As a post-pass, build constant pools and inner classes.

            for (int i = 0; i < classes.length; i++) {

                reconstructClass(classes[i]);

            }

            ok = true;

        } catch (Exception ee) {

            Utils.log.warning("Error on input: "+ee, ee);

            if (verbose > 0)

                Utils.log.info("Stream offsets:"+

                                 " served="+in.getBytesServed()+

                                 " buffered="+in.buffered+

                                 " limit="+in.limit);

            //if (verbose > 0)  ee.printStackTrace();

            if (ee instanceof IOException)  throw (IOException)ee;

            if (ee instanceof RuntimeException)  throw (RuntimeException)ee;

            throw new Error("error unpacking", ee);

        }

    }

    // Temporary count values, until band decoding gets rolling.

    int[] tagCount = new int[CONSTANT_Limit];

    int numFiles;

    int numAttrDefs;

    int numInnerClasses;

    int numClasses;

    void readFileHeader() throws IOException {

        //  file_header:

        //        archive_magic archive_header

        readArchiveMagic();

        readArchiveHeader();

    }

    // Local routine used to parse fixed-format scalars

    // in the file_header:

    private int getMagicInt32() throws IOException {

        int res = 0;

        for (int i = 0; i < 4; i++) {

            res <<= 8;

            res |= (archive_magic.getByte() & 0xFF);

        }

        return res;

    }

    final static int MAGIC_BYTES = 4;

    void readArchiveMagic() throws IOException {

        // Read a minimum of bytes in the first gulp.

        in.setReadLimit(MAGIC_BYTES + AH_LENGTH_MIN);

        //  archive_magic:

        //        #archive_magic_word :BYTE1[4]

        archive_magic.expectLength(MAGIC_BYTES);

        archive_magic.readFrom(in);

        // read and check magic numbers:

        pkg.magic = getMagicInt32();

        archive_magic.doneDisbursing();

    }

    void readArchiveHeader() throws IOException {

        //  archive_header:

        //        #archive_minver :UNSIGNED5[1]

        //        #archive_majver :UNSIGNED5[1]

        //        #archive_options :UNSIGNED5[1]

        //        (archive_file_counts) ** (#have_file_headers)

        //        (archive_special_counts) ** (#have_special_formats)

        //        cp_counts

        //        class_counts

        //

        //  archive_file_counts:

        //        #archive_size_hi :UNSIGNED5[1]

        //        #archive_size_lo :UNSIGNED5[1]

        //        #archive_next_count :UNSIGNED5[1]

        //        #archive_modtime :UNSIGNED5[1]

        //        #file_count :UNSIGNED5[1]

        //

        //  class_counts:

        //        #ic_count :UNSIGNED5[1]

        //        #default_class_minver :UNSIGNED5[1]

        //        #default_class_majver :UNSIGNED5[1]

        //        #class_count :UNSIGNED5[1]

        //

        //  archive_special_counts:

        //        #band_headers_size :UNSIGNED5[1]

        //        #attr_definition_count :UNSIGNED5[1]

        //

        assert(AH_LENGTH == 8+(ConstantPool.TAGS_IN_ORDER.length)+6);

        archive_header_0.expectLength(AH_LENGTH_0);

        archive_header_0.readFrom(in);

        pkg.package_minver = archive_header_0.getInt();

        pkg.package_majver = archive_header_0.getInt();

        pkg.checkVersion();

        this.initPackageMajver(pkg.package_majver);

        archiveOptions = archive_header_0.getInt();

        archive_header_0.doneDisbursing();

        // detect archive optional fields in archive header

        boolean haveSpecial = testBit(archiveOptions, AO_HAVE_SPECIAL_FORMATS);

        boolean haveFiles   = testBit(archiveOptions, AO_HAVE_FILE_HEADERS);

        boolean haveNumbers = testBit(archiveOptions, AO_HAVE_CP_NUMBERS);

        initAttrIndexLimit();

        // now we are ready to use the data:

        archive_header_S.expectLength(haveFiles? AH_LENGTH_S: 0);

        archive_header_S.readFrom(in);

        if (haveFiles) {

            long sizeHi = archive_header_S.getInt();

            long sizeLo = archive_header_S.getInt();

            archiveSize1 = (sizeHi << 32) + ((sizeLo << 32) >>> 32);

            // Set the limit, now, up to the file_bits.

            in.setReadLimit(archiveSize1);  // for debug only

        } else {

            archiveSize1 = 0;

            in.setReadLimit(-1);  // remove limitation

        }

        archive_header_S.doneDisbursing();

        archiveSize0 = in.getBytesServed();

        int remainingHeaders = AH_LENGTH - AH_LENGTH_0 - AH_LENGTH_S;

        if (!haveFiles)    remainingHeaders -= AH_FILE_HEADER_LEN-AH_LENGTH_S;

        if (!haveSpecial)  remainingHeaders -= AH_SPECIAL_FORMAT_LEN;

        if (!haveNumbers)  remainingHeaders -= AH_CP_NUMBER_LEN;

        assert(remainingHeaders >= AH_LENGTH_MIN - AH_LENGTH_0);

        archive_header_1.expectLength(remainingHeaders);

        archive_header_1.readFrom(in);

        if (haveFiles) {

            archiveNextCount = archive_header_1.getInt();

            pkg.default_modtime = archive_header_1.getInt();

            numFiles = archive_header_1.getInt();

        } else {

            archiveNextCount = 0;

            numFiles = 0;

        }

        if (haveSpecial) {

            band_headers.expectLength(archive_header_1.getInt());

            numAttrDefs = archive_header_1.getInt();

        } else {

            band_headers.expectLength(0);

            numAttrDefs = 0;

        }

        readConstantPoolCounts(haveNumbers);

        numInnerClasses = archive_header_1.getInt();

        pkg.default_class_minver = (short) archive_header_1.getInt();

        pkg.default_class_majver = (short) archive_header_1.getInt();

        numClasses = archive_header_1.getInt();

        archive_header_1.doneDisbursing();

        // set some derived archive bits

        if (testBit(archiveOptions, AO_DEFLATE_HINT)) {

            pkg.default_options |= FO_DEFLATE_HINT;

        }

    }

    void readBandHeaders() throws IOException {

        band_headers.readFrom(in);

        bandHeaderBytePos = 1;  // Leave room to pushback the initial XB byte.

        bandHeaderBytes = new byte[bandHeaderBytePos + band_headers.length()];

        for (int i = bandHeaderBytePos; i < bandHeaderBytes.length; i++) {

            bandHeaderBytes[i] = (byte) band_headers.getByte();

        }

        band_headers.doneDisbursing();

    }

    void readConstantPoolCounts(boolean haveNumbers) throws IOException {

        // size the constant pools:

        for (int k = 0; k < ConstantPool.TAGS_IN_ORDER.length; k++) {

            //  cp_counts:

            //        #cp_Utf8_count :UNSIGNED5[1]

            //        (cp_number_counts) ** (#have_cp_numbers)

            //        #cp_String_count :UNSIGNED5[1]

            //        #cp_Class_count :UNSIGNED5[1]

            //        #cp_Signature_count :UNSIGNED5[1]

            //        #cp_Descr_count :UNSIGNED5[1]

            //        #cp_Field_count :UNSIGNED5[1]

            //        #cp_Method_count :UNSIGNED5[1]

            //        #cp_Imethod_count :UNSIGNED5[1]

            //

            //  cp_number_counts:

            //        #cp_Int_count :UNSIGNED5[1]

            //        #cp_Float_count :UNSIGNED5[1]

            //        #cp_Long_count :UNSIGNED5[1]

            //        #cp_Double_count :UNSIGNED5[1]

            //

            byte tag = ConstantPool.TAGS_IN_ORDER[k];

            if (!haveNumbers) {

                // These four counts are optional.

                switch (tag) {

                case CONSTANT_Integer:

                case CONSTANT_Float:

                case CONSTANT_Long:

                case CONSTANT_Double:

                    continue;

                }

            }

            tagCount[tag] = archive_header_1.getInt();

        }

    }

    protected Index getCPIndex(byte tag) {

        return pkg.cp.getIndexByTag(tag);

    }

    Index initCPIndex(byte tag, Entry[] cpMap) {

        if (verbose > 3) {

            for (int i = 0; i < cpMap.length; i++) {

                Utils.log.fine("cp.add "+cpMap[i]);

            }

        }

        Index index = ConstantPool.makeIndex(ConstantPool.tagName(tag), cpMap);

        if (verbose > 1)  Utils.log.fine("Read "+index);

        pkg.cp.initIndexByTag(tag, index);

        return index;

    }

    void readConstantPool() throws IOException {

        //  cp_bands:

        //        cp_Utf8

        //        *cp_Int :UDELTA5

        //        *cp_Float :UDELTA5

        //        cp_Long

        //        cp_Double

        //        *cp_String :UDELTA5  (cp_Utf8)

        //        *cp_Class :UDELTA5  (cp_Utf8)

        //        cp_Signature

        //        cp_Descr

        //        cp_Field

        //        cp_Method

        //        cp_Imethod

        if (verbose > 0)  Utils.log.info("Reading CP");

        for (int k = 0; k < ConstantPool.TAGS_IN_ORDER.length; k++) {

            byte tag = ConstantPool.TAGS_IN_ORDER[k];

            int  len = tagCount[tag];

            Entry[] cpMap = new Entry[len];

            if (verbose > 0)

                Utils.log.info("Reading "+cpMap.length+" "+ConstantPool.tagName(tag)+" entries...");

            switch (tag) {

            case CONSTANT_Utf8:

                readUtf8Bands(cpMap);

                break;

            case CONSTANT_Integer:

                cp_Int.expectLength(cpMap.length);

                cp_Int.readFrom(in);

                for (int i = 0; i < cpMap.length; i++) {

                    int x = cp_Int.getInt();  // coding handles signs OK

                    cpMap[i] = ConstantPool.getLiteralEntry(new Integer(x));

                }

                cp_Int.doneDisbursing();

                break;

            case CONSTANT_Float:

                cp_Float.expectLength(cpMap.length);

                cp_Float.readFrom(in);

                for (int i = 0; i < cpMap.length; i++) {

                    int x = cp_Float.getInt();

                    float fx = Float.intBitsToFloat(x);

                    cpMap[i] = ConstantPool.getLiteralEntry(new Float(fx));

                }

                cp_Float.doneDisbursing();

                break;

            case CONSTANT_Long:

                //  cp_Long:

                //        *cp_Long_hi :UDELTA5

                //        *cp_Long_lo :DELTA5

                cp_Long_hi.expectLength(cpMap.length);

                cp_Long_hi.readFrom(in);

                cp_Long_lo.expectLength(cpMap.length);

                cp_Long_lo.readFrom(in);

                for (int i = 0; i < cpMap.length; i++) {

                    long hi = cp_Long_hi.getInt();

                    long lo = cp_Long_lo.getInt();

                    long x = (hi << 32) + ((lo << 32) >>> 32);

                    cpMap[i] = ConstantPool.getLiteralEntry(new Long(x));

                }

                cp_Long_hi.doneDisbursing();

                cp_Long_lo.doneDisbursing();

                break;

            case CONSTANT_Double:

                //  cp_Double:

                //        *cp_Double_hi :UDELTA5

                //        *cp_Double_lo :DELTA5

                cp_Double_hi.expectLength(cpMap.length);

                cp_Double_hi.readFrom(in);

                cp_Double_lo.expectLength(cpMap.length);

                cp_Double_lo.readFrom(in);

                for (int i = 0; i < cpMap.length; i++) {

                    long hi = cp_Double_hi.getInt();

                    long lo = cp_Double_lo.getInt();

                    long x = (hi << 32) + ((lo << 32) >>> 32);

                    double dx = Double.longBitsToDouble(x);

                    cpMap[i] = ConstantPool.getLiteralEntry(new Double(dx));

                }

                cp_Double_hi.doneDisbursing();

                cp_Double_lo.doneDisbursing();

                break;

            case CONSTANT_String:

                cp_String.expectLength(cpMap.length);

                cp_String.readFrom(in);

                cp_String.setIndex(getCPIndex(CONSTANT_Utf8));

                for (int i = 0; i < cpMap.length; i++) {

                    cpMap[i] = ConstantPool.getLiteralEntry(cp_String.getRef().stringValue());

                }

                cp_String.doneDisbursing();

                break;

            case CONSTANT_Class:

                cp_Class.expectLength(cpMap.length);

                cp_Class.readFrom(in);

                cp_Class.setIndex(getCPIndex(CONSTANT_Utf8));

                for (int i = 0; i < cpMap.length; i++) {

                    cpMap[i] = ConstantPool.getClassEntry(cp_Class.getRef().stringValue());

                }

                cp_Class.doneDisbursing();

                break;

            case CONSTANT_Signature:

                readSignatureBands(cpMap);

                break;

            case CONSTANT_NameandType:

                //  cp_Descr:

                //        *cp_Descr_type :DELTA5  (cp_Signature)

                //        *cp_Descr_name :UDELTA5  (cp_Utf8)

                cp_Descr_name.expectLength(cpMap.length);

                cp_Descr_name.readFrom(in);

                cp_Descr_name.setIndex(getCPIndex(CONSTANT_Utf8));

                cp_Descr_type.expectLength(cpMap.length);

                cp_Descr_type.readFrom(in);

                cp_Descr_type.setIndex(getCPIndex(CONSTANT_Signature));

                for (int i = 0; i < cpMap.length; i++) {

                    Entry ref  = cp_Descr_name.getRef();

                    Entry ref2 = cp_Descr_type.getRef();

                    cpMap[i] = ConstantPool.getDescriptorEntry((Utf8Entry)ref,

                                                        (SignatureEntry)ref2);

                }

                cp_Descr_name.doneDisbursing();

                cp_Descr_type.doneDisbursing();

                break;

            case CONSTANT_Fieldref:

                readMemberRefs(tag, cpMap, cp_Field_class, cp_Field_desc);

                break;

            case CONSTANT_Methodref:

                readMemberRefs(tag, cpMap, cp_Method_class, cp_Method_desc);

                break;

            case CONSTANT_InterfaceMethodref:

                readMemberRefs(tag, cpMap, cp_Imethod_class, cp_Imethod_desc);

                break;

            default:

                assert(false);

            }

            Index index = initCPIndex(tag, cpMap);

            if (optDumpBands) {

                PrintStream ps = new PrintStream(getDumpStream(index, ".idx"));

                printArrayTo(ps, index.cpMap, 0, index.cpMap.length);