/*

 * Copyright (c) 2001, 2013, Oracle and/or its affiliates. All rights reserved.

 * 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.Entry;

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

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

import java.io.BufferedOutputStream;

import java.io.ByteArrayInputStream;

import java.io.ByteArrayOutputStream;

import java.io.EOFException;

import java.io.File;

import java.io.FileOutputStream;

import java.io.FilterInputStream;

import java.io.FilterOutputStream;

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

import java.io.PrintStream;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collections;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.jar.Pack200;

import static com.sun.java.util.jar.pack.Constants.*;

import java.util.LinkedList;

/**

 * Define the structure and ordering of "bands" in a packed file.

 * @author John Rose

 */

@SuppressWarnings({"removal"})

abstract

class BandStructure {

    static final int MAX_EFFORT = 9;

    static final int MIN_EFFORT = 1;

    static final int DEFAULT_EFFORT = 5;

    // Inherit options from Pack200:

    PropMap p200 = Utils.currentPropMap();

    int verbose = p200.getInteger(Utils.DEBUG_VERBOSE);

    int effort = p200.getInteger(Pack200.Packer.EFFORT);

    { if (effort == 0)  effort = DEFAULT_EFFORT; }

    boolean optDumpBands = p200.getBoolean(Utils.COM_PREFIX+"dump.bands");

    boolean optDebugBands = p200.getBoolean(Utils.COM_PREFIX+"debug.bands");

    // Various heuristic options.

    boolean optVaryCodings = !p200.getBoolean(Utils.COM_PREFIX+"no.vary.codings");

    boolean optBigStrings = !p200.getBoolean(Utils.COM_PREFIX+"no.big.strings");

    protected abstract Index getCPIndex(byte tag);

    // Local copy of highest class version.

    private Package.Version highestClassVersion = null;

    /** Call this exactly once, early, to specify the archive major version. */

    public void initHighestClassVersion(Package.Version highestClassVersion) throws IOException {

        if (this.highestClassVersion != null) {

            throw new IOException(

                "Highest class major version is already initialized to " +

                this.highestClassVersion + "; new setting is " + highestClassVersion);

        }

        this.highestClassVersion = highestClassVersion;

        adjustToClassVersion();

    }

    public Package.Version getHighestClassVersion() {

        return highestClassVersion;

    }

    private final boolean isReader = this instanceof PackageReader;

    protected BandStructure() {}

    static final Coding BYTE1 = Coding.of(1,256);

    static final Coding CHAR3 = Coding.of(3,128);

    // Note:  Tried sharper (3,16) with no post-zip benefit.

    // This is best used with BCI values:

    static final Coding BCI5 = Coding.of(5,4);  // mostly 1-byte offsets

    static final Coding BRANCH5 = Coding.of(5,4,2); // mostly forward branches

    static final Coding UNSIGNED5 = Coding.of(5,64);

    static final Coding UDELTA5 = UNSIGNED5.getDeltaCoding();

    // "sharp" (5,64) zips 0.4% better than "medium" (5,128)

    // It zips 1.1% better than "flat" (5,192)

    static final Coding SIGNED5 = Coding.of(5,64,1);  //sharp

    static final Coding DELTA5 = SIGNED5.getDeltaCoding();

    // Note:  Tried (5,128,2) and (5,192,2) with no benefit.

    static final Coding MDELTA5 = Coding.of(5,64,2).getDeltaCoding();

    private static final Coding[] basicCodings = {

        // Table of "Canonical BHSD Codings" from Pack200 spec.

        null,  // _meta_default

        // Fixed-length codings:

        Coding.of(1,256,0),

        Coding.of(1,256,1),

        Coding.of(1,256,0).getDeltaCoding(),

        Coding.of(1,256,1).getDeltaCoding(),

        Coding.of(2,256,0),

        Coding.of(2,256,1),

        Coding.of(2,256,0).getDeltaCoding(),

        Coding.of(2,256,1).getDeltaCoding(),

        Coding.of(3,256,0),

        Coding.of(3,256,1),

        Coding.of(3,256,0).getDeltaCoding(),

        Coding.of(3,256,1).getDeltaCoding(),

        Coding.of(4,256,0),

        Coding.of(4,256,1),

        Coding.of(4,256,0).getDeltaCoding(),

        Coding.of(4,256,1).getDeltaCoding(),

        // Full-range variable-length codings:

        Coding.of(5,  4,0),

        Coding.of(5,  4,1),

        Coding.of(5,  4,2),

        Coding.of(5, 16,0),

        Coding.of(5, 16,1),

        Coding.of(5, 16,2),

        Coding.of(5, 32,0),

        Coding.of(5, 32,1),

        Coding.of(5, 32,2),

        Coding.of(5, 64,0),

        Coding.of(5, 64,1),

        Coding.of(5, 64,2),

        Coding.of(5,128,0),

        Coding.of(5,128,1),

        Coding.of(5,128,2),

        Coding.of(5,  4,0).getDeltaCoding(),

        Coding.of(5,  4,1).getDeltaCoding(),

        Coding.of(5,  4,2).getDeltaCoding(),

        Coding.of(5, 16,0).getDeltaCoding(),

        Coding.of(5, 16,1).getDeltaCoding(),

        Coding.of(5, 16,2).getDeltaCoding(),

        Coding.of(5, 32,0).getDeltaCoding(),

        Coding.of(5, 32,1).getDeltaCoding(),

        Coding.of(5, 32,2).getDeltaCoding(),

        Coding.of(5, 64,0).getDeltaCoding(),

        Coding.of(5, 64,1).getDeltaCoding(),

        Coding.of(5, 64,2).getDeltaCoding(),

        Coding.of(5,128,0).getDeltaCoding(),

        Coding.of(5,128,1).getDeltaCoding(),

        Coding.of(5,128,2).getDeltaCoding(),

        // Variable length subrange codings:

        Coding.of(2,192,0),

        Coding.of(2,224,0),

        Coding.of(2,240,0),

        Coding.of(2,248,0),

        Coding.of(2,252,0),

        Coding.of(2,  8,0).getDeltaCoding(),

        Coding.of(2,  8,1).getDeltaCoding(),

        Coding.of(2, 16,0).getDeltaCoding(),

        Coding.of(2, 16,1).getDeltaCoding(),

        Coding.of(2, 32,0).getDeltaCoding(),

        Coding.of(2, 32,1).getDeltaCoding(),

        Coding.of(2, 64,0).getDeltaCoding(),

        Coding.of(2, 64,1).getDeltaCoding(),

        Coding.of(2,128,0).getDeltaCoding(),

        Coding.of(2,128,1).getDeltaCoding(),

        Coding.of(2,192,0).getDeltaCoding(),

        Coding.of(2,192,1).getDeltaCoding(),

        Coding.of(2,224,0).getDeltaCoding(),

        Coding.of(2,224,1).getDeltaCoding(),

        Coding.of(2,240,0).getDeltaCoding(),

        Coding.of(2,240,1).getDeltaCoding(),

        Coding.of(2,248,0).getDeltaCoding(),

        Coding.of(2,248,1).getDeltaCoding(),

        Coding.of(3,192,0),

        Coding.of(3,224,0),

        Coding.of(3,240,0),

        Coding.of(3,248,0),

        Coding.of(3,252,0),

        Coding.of(3,  8,0).getDeltaCoding(),

        Coding.of(3,  8,1).getDeltaCoding(),

        Coding.of(3, 16,0).getDeltaCoding(),

        Coding.of(3, 16,1).getDeltaCoding(),

        Coding.of(3, 32,0).getDeltaCoding(),

        Coding.of(3, 32,1).getDeltaCoding(),

        Coding.of(3, 64,0).getDeltaCoding(),

        Coding.of(3, 64,1).getDeltaCoding(),

        Coding.of(3,128,0).getDeltaCoding(),

        Coding.of(3,128,1).getDeltaCoding(),

        Coding.of(3,192,0).getDeltaCoding(),

        Coding.of(3,192,1).getDeltaCoding(),

        Coding.of(3,224,0).getDeltaCoding(),

        Coding.of(3,224,1).getDeltaCoding(),

        Coding.of(3,240,0).getDeltaCoding(),

        Coding.of(3,240,1).getDeltaCoding(),

        Coding.of(3,248,0).getDeltaCoding(),

        Coding.of(3,248,1).getDeltaCoding(),

        Coding.of(4,192,0),

        Coding.of(4,224,0),

        Coding.of(4,240,0),

        Coding.of(4,248,0),

        Coding.of(4,252,0),

        Coding.of(4,  8,0).getDeltaCoding(),

        Coding.of(4,  8,1).getDeltaCoding(),

        Coding.of(4, 16,0).getDeltaCoding(),

        Coding.of(4, 16,1).getDeltaCoding(),

        Coding.of(4, 32,0).getDeltaCoding(),

        Coding.of(4, 32,1).getDeltaCoding(),

        Coding.of(4, 64,0).getDeltaCoding(),

        Coding.of(4, 64,1).getDeltaCoding(),

        Coding.of(4,128,0).getDeltaCoding(),

        Coding.of(4,128,1).getDeltaCoding(),

        Coding.of(4,192,0).getDeltaCoding(),

        Coding.of(4,192,1).getDeltaCoding(),

        Coding.of(4,224,0).getDeltaCoding(),

        Coding.of(4,224,1).getDeltaCoding(),

        Coding.of(4,240,0).getDeltaCoding(),

        Coding.of(4,240,1).getDeltaCoding(),

        Coding.of(4,248,0).getDeltaCoding(),

        Coding.of(4,248,1).getDeltaCoding(),

        null

    };

    private static final Map<Coding, Integer> basicCodingIndexes;

    static {

        assert(basicCodings[_meta_default] == null);

        assert(basicCodings[_meta_canon_min] != null);

        assert(basicCodings[_meta_canon_max] != null);

        Map<Coding, Integer> map = new HashMap<>();

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

            Coding c = basicCodings[i];

            if (c == null)  continue;

            assert(i >= _meta_canon_min);

            assert(i <= _meta_canon_max);

            map.put(c, i);

        }

        basicCodingIndexes = map;

    }

    public static Coding codingForIndex(int i) {

        return i < basicCodings.length ? basicCodings[i] : null;

    }

    public static int indexOf(Coding c) {

        Integer i = basicCodingIndexes.get(c);

        if (i == null)  return 0;

        return i.intValue();

    }

    public static Coding[] getBasicCodings() {

        return basicCodings.clone();

    }

    protected byte[] bandHeaderBytes;    // used for input only

    protected int    bandHeaderBytePos;  // BHB read pointer, for input only

    protected int    bandHeaderBytePos0; // for debug

    protected CodingMethod getBandHeader(int XB, Coding regularCoding) {

        CodingMethod[] res = {null};

        // push back XB onto the band header bytes

        bandHeaderBytes[--bandHeaderBytePos] = (byte) XB;

        bandHeaderBytePos0 = bandHeaderBytePos;

        // scan forward through XB and any additional band header bytes

        bandHeaderBytePos = parseMetaCoding(bandHeaderBytes,

                                            bandHeaderBytePos,

                                            regularCoding,

                                            res);

        return res[0];

    }

    public static int parseMetaCoding(byte[] bytes, int pos, Coding dflt, CodingMethod[] res) {

        if ((bytes[pos] & 0xFF) == _meta_default) {

            res[0] = dflt;

            return pos+1;

        }

        int pos2;

        pos2 = Coding.parseMetaCoding(bytes, pos, dflt, res);

        if (pos2 > pos)  return pos2;

        pos2 = PopulationCoding.parseMetaCoding(bytes, pos, dflt, res);

        if (pos2 > pos)  return pos2;

        pos2 = AdaptiveCoding.parseMetaCoding(bytes, pos, dflt, res);

        if (pos2 > pos)  return pos2;

        throw new RuntimeException("Bad meta-coding op "+(bytes[pos]&0xFF));

    }

    static final int SHORT_BAND_HEURISTIC = 100;

    public static final int NO_PHASE        = 0;

    // package writing phases:

    public static final int COLLECT_PHASE   = 1; // collect data before write

    public static final int FROZEN_PHASE    = 3; // no longer collecting

    public static final int WRITE_PHASE     = 5; // ready to write bytes

    // package reading phases:

    public static final int EXPECT_PHASE    = 2; // gather expected counts

    public static final int READ_PHASE      = 4; // ready to read bytes

    public static final int DISBURSE_PHASE  = 6; // pass out data after read

    public static final int DONE_PHASE      = 8; // done writing or reading

    static boolean phaseIsRead(int p) {

        return (p % 2) == 0;

    }

    static int phaseCmp(int p0, int p1) {

        assert((p0 % 2) == (p1 % 2) || (p0 % 8) == 0 || (p1 % 8) == 0);

        return p0 - p1;

    }

    /** The packed file is divided up into a number of segments.

     *  Most segments are typed as ValueBand, strongly-typed sequences

     *  of integer values, all interpreted in a single way.

     *  A few segments are ByteBands, which hetergeneous sequences

     *  of bytes.

     *

     *  The two phases for writing a packed file are COLLECT and WRITE.

     *  1. When writing a packed file, each band collects

     *  data in an ad-hoc order.

     *  2. At the end, each band is assigned a coding scheme,

     *  and then all the bands are written in their global order.

     *

     *  The three phases for reading a packed file are EXPECT, READ,

     *  and DISBURSE.

     *  1. For each band, the expected number of integers  is determined.

     *  2. The data is actually read from the file into the band.

     *  3. The band pays out its values as requested, in an ad hoc order.

     *

     *  When the last phase of a band is done, it is marked so (DONE).

     *  Clearly, these phases must be properly ordered WRT each other.

     */

    abstract class Band {

        private int    phase = NO_PHASE;

        private final  String name;

        private int    valuesExpected;

        protected long outputSize = -1;  // cache

        public final Coding regularCoding;

        public final int seqForDebug;

        public int       elementCountForDebug;

        protected Band(String name, Coding regularCoding) {

            this.name = name;

            this.regularCoding = regularCoding;

            this.seqForDebug = ++nextSeqForDebug;

            if (verbose > 2)

                Utils.log.fine("Band "+seqForDebug+" is "+name);

            // caller must call init

        }

        public Band init() {

            // Cannot due this from the constructor, because constructor

            // may wish to initialize some subclass variables.

            // Set initial phase for reading or writing:

            if (isReader)

                readyToExpect();

            else

                readyToCollect();

            return this;

        }

        // common operations

        boolean isReader() { return isReader; }

        int phase() { return phase; }

        String name() { return name; }

        /** Return -1 if data buffer not allocated, else max length. */

        public abstract int capacity();

        /** Allocate data buffer to specified length. */

        protected abstract void setCapacity(int cap);

        /** Return current number of values in buffer, which must exist. */

        public abstract int length();

        protected abstract int valuesRemainingForDebug();

        public final int valuesExpected() {

            return valuesExpected;

        }

        /** Write out bytes, encoding the values. */

        public final void writeTo(OutputStream out) throws IOException {

            assert(assertReadyToWriteTo(this, out));

            setPhase(WRITE_PHASE);

            // subclasses continue by writing their contents to output

            writeDataTo(out);

            doneWriting();

        }

        abstract void chooseBandCodings() throws IOException;

        public final long outputSize() {

            if (outputSize >= 0) {

                long size = outputSize;

                assert(size == computeOutputSize());

                return size;

            }

            return computeOutputSize();

        }

        protected abstract long computeOutputSize();

        protected abstract void writeDataTo(OutputStream out) throws IOException;

        /** Expect a certain number of values. */

        void expectLength(int l) {

            assert(assertPhase(this, EXPECT_PHASE));

            assert(valuesExpected == 0);  // all at once

            assert(l >= 0);

            valuesExpected = l;

        }

        /** Expect more values.  (Multiple calls accumulate.) */

        void expectMoreLength(int l) {

            assert(assertPhase(this, EXPECT_PHASE));

            valuesExpected += l;

        }

        /// Phase change markers.

        private void readyToCollect() { // called implicitly by constructor

            setCapacity(1);

            setPhase(COLLECT_PHASE);

        }

        protected void doneWriting() {

            assert(assertPhase(this, WRITE_PHASE));

            setPhase(DONE_PHASE);

        }

        private void readyToExpect() { // called implicitly by constructor

            setPhase(EXPECT_PHASE);

        }

        /** Read in bytes, decoding the values. */

        public final void readFrom(InputStream in) throws IOException {

            assert(assertReadyToReadFrom(this, in));

            setCapacity(valuesExpected());

            setPhase(READ_PHASE);

            // subclasses continue by reading their contents from input:

            readDataFrom(in);

            readyToDisburse();

        }

        protected abstract void readDataFrom(InputStream in) throws IOException;

        protected void readyToDisburse() {

            if (verbose > 1)  Utils.log.fine("readyToDisburse "+this);

            setPhase(DISBURSE_PHASE);

        }

        public void doneDisbursing() {

            assert(assertPhase(this, DISBURSE_PHASE));

            setPhase(DONE_PHASE);

        }

        public final void doneWithUnusedBand() {

            if (isReader) {

                assert(assertPhase(this, EXPECT_PHASE));

                assert(valuesExpected() == 0);

                // Fast forward:

                setPhase(READ_PHASE);

                setPhase(DISBURSE_PHASE);

                setPhase(DONE_PHASE);

            } else {

                setPhase(FROZEN_PHASE);

            }

        }

        protected void setPhase(int newPhase) {

            assert(assertPhaseChangeOK(this, phase, newPhase));

            this.phase = newPhase;

        }

        protected int lengthForDebug = -1;  // DEBUG ONLY

        @Override

        public String toString() {  // DEBUG ONLY

            int length = (lengthForDebug != -1 ? lengthForDebug : length());

            String str = name;

            if (length != 0)

                str += "[" + length + "]";

            if (elementCountForDebug != 0)

                str += "(" + elementCountForDebug + ")";

            return str;

        }

    }

    class ValueBand extends Band {

        private int[]  values;   // must be null in EXPECT phase

        private int    length;

        private int    valuesDisbursed;

        private CodingMethod bandCoding;

        private byte[] metaCoding;

        protected ValueBand(String name, Coding regularCoding) {

            super(name, regularCoding);

        }

        @Override

        public int capacity() {

            return values == null ? -1 : values.length;

        }

        /** Declare predicted or needed capacity. */

        @Override

        protected void setCapacity(int cap) {

            assert(length <= cap);

            if (cap == -1) { values = null; return; }

            values = realloc(values, cap);

        }

        @Override

        public int length() {

            return length;

        }

        @Override

        protected int valuesRemainingForDebug() {

            return length - valuesDisbursed;

        }

        protected int valueAtForDebug(int i) {

            return values[i];

        }

        void patchValue(int i, int value) {

            // Only one use for this.

            assert(this == archive_header_S);

            assert(i == AH_ARCHIVE_SIZE_HI || i == AH_ARCHIVE_SIZE_LO);

            assert(i < length);  // must have already output a dummy

            values[i] = value;

            outputSize = -1;  // decache

        }

        protected void initializeValues(int[] values) {

            assert(assertCanChangeLength(this));

            assert(length == 0);

            this.values = values;

            this.length = values.length;

        }

        /** Collect one value, or store one decoded value. */

        protected void addValue(int x) {

            assert(assertCanChangeLength(this));

            if (length == values.length)

                setCapacity(length < 1000 ? length * 10 : length * 2);

            values[length++] = x;

        }

        private boolean canVaryCoding() {

            if (!optVaryCodings)           return false;

            if (length == 0)               return false;

            // Can't read band_headers w/o the archive header:

            if (this == archive_header_0)  return false;

            if (this == archive_header_S)  return false;

            if (this == archive_header_1)  return false;

            // BYTE1 bands can't vary codings, but the others can.

            // All that's needed for the initial escape is at least

            // 256 negative values or more than 256 non-negative values

            return (regularCoding.min() <= -256 || regularCoding.max() >= 256);

        }

        private boolean shouldVaryCoding() {

            assert(canVaryCoding());

            if (effort < MAX_EFFORT && length < SHORT_BAND_HEURISTIC)

                return false;

            return true;

        }

        @Override

        protected void chooseBandCodings() throws IOException {

            boolean canVary = canVaryCoding();

            if (!canVary || !shouldVaryCoding()) {

                if (regularCoding.canRepresent(values, 0, length)) {

                    bandCoding = regularCoding;

                } else {

                    assert(canVary);

                    if (verbose > 1)

                        Utils.log.fine("regular coding fails in band "+name());

                    bandCoding = UNSIGNED5;

                }

                outputSize = -1;

            } else {

                int[] sizes = {0,0};

                bandCoding = chooseCoding(values, 0, length,

                                          regularCoding, name(),

                                          sizes);

                outputSize = sizes[CodingChooser.BYTE_SIZE];

                if (outputSize == 0)  // CodingChooser failed to size it.

                    outputSize = -1;

            }

            // Compute and save the meta-coding bytes also.

            if (bandCoding != regularCoding) {

                metaCoding = bandCoding.getMetaCoding(regularCoding);

                if (verbose > 1) {

                    Utils.log.fine("alternate coding "+this+" "+bandCoding);

                }

            } else if (canVary &&

                       decodeEscapeValue(values[0], regularCoding) >= 0) {

                // Need an explicit default.

                metaCoding = defaultMetaCoding;

            } else {

                // Common case:  Zero bytes of meta coding.

                metaCoding = noMetaCoding;

            }

            if (metaCoding.length > 0

                && (verbose > 2 || verbose > 1 && metaCoding.length > 1)) {

                StringBuilder sb = new StringBuilder();

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

                    if (i == 1)  sb.append(" /");

                    sb.append(" ").append(metaCoding[i] & 0xFF);

                }

                Utils.log.fine("   meta-coding "+sb);

            }

            assert((outputSize < 0) ||

                   !(bandCoding instanceof Coding) ||

                   (outputSize == ((Coding)bandCoding)

                    .getLength(values, 0, length)))

                : (bandCoding+" : "+

                   outputSize+" != "+

                   ((Coding)bandCoding).getLength(values, 0, length)

                   +" ?= "+getCodingChooser().computeByteSize(bandCoding,values,0,length)

                   );

            // Compute outputSize of the escape value X, if any.

            if (metaCoding.length > 0) {

                // First byte XB of meta-coding is treated specially,

                // but any other bytes go into the band headers band.

                // This must be done before any other output happens.

                if (outputSize >= 0)

                    outputSize += computeEscapeSize();  // good cache

                // Other bytes go into band_headers.

                for (int i = 1; i < metaCoding.length; i++) {

                    band_headers.putByte(metaCoding[i] & 0xFF);

                }

            }

        }

        @Override

        protected long computeOutputSize() {

            outputSize = getCodingChooser().computeByteSize(bandCoding,

                                                            values, 0, length);

            assert(outputSize < Integer.MAX_VALUE);

            outputSize += computeEscapeSize();

            return outputSize;

        }

        protected int computeEscapeSize() {

            if (metaCoding.length == 0)  return 0;

            int XB = metaCoding[0] & 0xFF;

            int X = encodeEscapeValue(XB, regularCoding);

            return regularCoding.setD(0).getLength(X);

        }

        @Override

        protected void writeDataTo(OutputStream out) throws IOException {

            if (length == 0)  return;  // nothing to write

            long len0 = 0;

            if (out == outputCounter) {

                len0 = outputCounter.getCount();

            }

            if (metaCoding.length > 0) {

                int XB = metaCoding[0] & 0xFF;

                // We need an explicit band header, either because

                // there is a non-default coding method, or because

                // the first value would be parsed as an escape value.

                int X = encodeEscapeValue(XB, regularCoding);

                //System.out.println("X="+X+" XB="+XB+" in "+this);

                regularCoding.setD(0).writeTo(out, X);

            }

            bandCoding.writeArrayTo(out, values, 0, length);

            if (out == outputCounter) {

                assert(outputSize == outputCounter.getCount() - len0)

                    : (outputSize+" != "+outputCounter.getCount()+"-"+len0);

            }

            if (optDumpBands)  dumpBand();

        }

        @Override

        protected void readDataFrom(InputStream in) throws IOException {

            length = valuesExpected();

            if (length == 0)  return;  // nothing to read

            if (verbose > 1)

                Utils.log.fine("Reading band "+this);

            if (!canVaryCoding()) {

                bandCoding = regularCoding;

                metaCoding = noMetaCoding;

            } else {

                assert(in.markSupported());  // input must be buffered

                in.mark(Coding.B_MAX);

                int X = regularCoding.setD(0).readFrom(in);

                int XB = decodeEscapeValue(X, regularCoding);

                if (XB < 0) {

                    // Do not consume this value.  No alternate coding.

                    in.reset();

                    bandCoding = regularCoding;

                    metaCoding = noMetaCoding;

                } else if (XB == _meta_default) {

                    bandCoding = regularCoding;

                    metaCoding = defaultMetaCoding;

                } else {

                    if (verbose > 2)

                        Utils.log.fine("found X="+X+" => XB="+XB);

                    bandCoding = getBandHeader(XB, regularCoding);

                    // This is really used only by dumpBands.

                    int p0 = bandHeaderBytePos0;

                    int p1 = bandHeaderBytePos;

                    metaCoding = new byte[p1-p0];

                    System.arraycopy(bandHeaderBytes, p0,

                                     metaCoding, 0, metaCoding.length);

                }

            }

            if (bandCoding != regularCoding) {

                if (verbose > 1)

                    Utils.log.fine(name()+": irregular coding "+bandCoding);

            }

            bandCoding.readArrayFrom(in, values, 0, length);

            if (optDumpBands)  dumpBand();

        }

        @Override

        public void doneDisbursing() {

            super.doneDisbursing();

            values = null;  // for GC

        }

        private void dumpBand() throws IOException {

            assert(optDumpBands);

            try (PrintStream ps = new PrintStream(getDumpStream(this, ".txt"))) {

                String irr = (bandCoding == regularCoding) ? "" : " irregular";

                ps.print("# length="+length+

                         " size="+outputSize()+

                         irr+" coding="+bandCoding);

                if (metaCoding != noMetaCoding) {

                    StringBuilder sb = new StringBuilder();

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

                        if (i == 1)  sb.append(" /");

                        sb.append(" ").append(metaCoding[i] & 0xFF);

                    }

                    ps.print(" //header: "+sb);

                }

                printArrayTo(ps, values, 0, length);

            }

            try (OutputStream ds = getDumpStream(this, ".bnd")) {

                bandCoding.writeArrayTo(ds, values, 0, length);

            }

        }

        /** Disburse one value. */

        protected int getValue() {

            assert(phase() == DISBURSE_PHASE);

            // when debugging return a zero if lengths are zero

            if (optDebugBands && length == 0 && valuesDisbursed == length)

                return 0;

            assert(valuesDisbursed <= length);

            return values[valuesDisbursed++];

        }

        /** Reset for another pass over the same value set. */

        public void resetForSecondPass() {

            assert(phase() == DISBURSE_PHASE);

            assert(valuesDisbursed == length());  // 1st pass is complete

            valuesDisbursed = 0;

        }

    }

    class ByteBand extends Band {

        private ByteArrayOutputStream bytes;  // input buffer

        private ByteArrayOutputStream bytesForDump;

        private InputStream in;

        public ByteBand(String name) {

            super(name, BYTE1);

        }

        @Override

        public int capacity() {

            return bytes == null ? -1 : Integer.MAX_VALUE;

        }

        @Override

        protected void setCapacity(int cap) {

            assert(bytes == null);  // do this just once

            bytes = new ByteArrayOutputStream(cap);

        }

        public void destroy() {

            lengthForDebug = length();

            bytes = null;

        }

        @Override

        public int length() {

            return bytes == null ? -1 : bytes.size();

        }

        public void reset() {

            bytes.reset();

        }

        @Override

        protected int valuesRemainingForDebug() {

            return (bytes == null) ? -1 : ((ByteArrayInputStream)in).available();

        }

        @Override

        protected void chooseBandCodings() throws IOException {

            // No-op.

            assert(decodeEscapeValue(regularCoding.min(), regularCoding) < 0);

            assert(decodeEscapeValue(regularCoding.max(), regularCoding) < 0);

        }

        @Override

        protected long computeOutputSize() {

            // do not cache

            return bytes.size();

        }

        @Override

        public void writeDataTo(OutputStream out) throws IOException {

            if (length() == 0)  return;

            bytes.writeTo(out);

            if (optDumpBands)  dumpBand();

            destroy();  // done with the bits!

        }

        private void dumpBand() throws IOException {

            assert(optDumpBands);

            try (OutputStream ds = getDumpStream(this, ".bnd")) {

                if (bytesForDump != null)

                    bytesForDump.writeTo(ds);

                else

                    bytes.writeTo(ds);

            }

        }

        @Override

        public void readDataFrom(InputStream in) throws IOException {

            int vex = valuesExpected();

            if (vex == 0)  return;

            if (verbose > 1) {

                lengthForDebug = vex;

                Utils.log.fine("Reading band "+this);

                lengthForDebug = -1;

            }

            byte[] buf = new byte[Math.min(vex, 1<<14)];

            while (vex > 0) {

                int nr = in.read(buf, 0, Math.min(vex, buf.length));

                if (nr < 0)  throw new EOFException();

                bytes.write(buf, 0, nr);

                vex -= nr;

            }

            if (optDumpBands)  dumpBand();

        }

        @Override

        public void readyToDisburse() {

            in = new ByteArrayInputStream(bytes.toByteArray());

            super.readyToDisburse();

        }

        @Override

        public void doneDisbursing() {

            super.doneDisbursing();

            if (optDumpBands

                && bytesForDump != null && bytesForDump.size() > 0) {

                try {

                    dumpBand();

                } catch (IOException ee) {

                    throw new RuntimeException(ee);

                }

            }

            in = null; // GC

            bytes = null;  // GC

            bytesForDump = null;  // GC

        }

        // alternative to readFrom:

        public void setInputStreamFrom(InputStream in) throws IOException {

            assert(bytes == null);

            assert(assertReadyToReadFrom(this, in));

            setPhase(READ_PHASE);

            this.in = in;

            if (optDumpBands) {

                // Tap the stream.

                bytesForDump = new ByteArrayOutputStream();

                this.in = new FilterInputStream(in) {

                    @Override

                    public int read() throws IOException {

                        int ch = in.read();

                        if (ch >= 0)  bytesForDump.write(ch);

                        return ch;

                    }

                    @Override

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

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

                        if (nr >= 0)  bytesForDump.write(b, off, nr);

                        return nr;

                    }

                };

            }

            super.readyToDisburse();

        }

        public OutputStream collectorStream() {

            assert(phase() == COLLECT_PHASE);

            assert(bytes != null);

            return bytes;

        }

        public InputStream getInputStream() {

            assert(phase() == DISBURSE_PHASE);

            assert(in != null);

            return in;

        }

        public int getByte() throws IOException {

            int b = getInputStream().read();

            if (b < 0)  throw new EOFException();

            return b;

        }

        public void putByte(int b) throws IOException {

            assert(b == (b & 0xFF));

            collectorStream().write(b);

        }

        @Override

        public String toString() {

            return "byte "+super.toString();

        }

    }

    class IntBand extends ValueBand {

        // The usual coding for bands is 7bit/5byte/delta.

        public IntBand(String name, Coding regularCoding) {

            super(name, regularCoding);

        }

        public void putInt(int x) {

            assert(phase() == COLLECT_PHASE);

            addValue(x);

        }

        public int getInt() {

            return getValue();

        }

        /** Return the sum of all values in this band. */

        public int getIntTotal() {

            assert(phase() == DISBURSE_PHASE);

            // assert that this is the whole pass; no other reads allowed

            assert(valuesRemainingForDebug() == length());

            int total = 0;

            for (int k = length(); k > 0; k--) {

                total += getInt();

            }

            resetForSecondPass();

            return total;

        }

        /** Return the occurrence count of a specific value in this band. */

        public int getIntCount(int value) {

            assert(phase() == DISBURSE_PHASE);

            // assert that this is the whole pass; no other reads allowed

            assert(valuesRemainingForDebug() == length());

            int total = 0;

            for (int k = length(); k > 0; k--) {

                if (getInt() == value) {

                    total += 1;

                }

            }

            resetForSecondPass();

            return total;

        }

    }

    static int getIntTotal(int[] values) {

        int total = 0;

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

            total += values[i];

        }

        return total;

    }

    class CPRefBand extends ValueBand {

        Index index;

        boolean nullOK;

        public CPRefBand(String name, Coding regularCoding, byte cpTag, boolean nullOK) {

            super(name, regularCoding);

            this.nullOK = nullOK;

            if (cpTag != CONSTANT_None)

                setBandIndex(this, cpTag);

        }

        public CPRefBand(String name, Coding regularCoding, byte cpTag) {

            this(name, regularCoding, cpTag, false);

        }

        public CPRefBand(String name, Coding regularCoding, Object undef) {

            this(name, regularCoding, CONSTANT_None, false);

        }

        public void setIndex(Index index) {

            this.index = index;

        }

        protected void readDataFrom(InputStream in) throws IOException {

            super.readDataFrom(in);

            assert(assertValidCPRefs(this));

        }

        /** Write a constant pool reference. */

        public void putRef(Entry e) {

            addValue(encodeRefOrNull(e, index));

        }

        public void putRef(Entry e, Index index) {

            assert(this.index == null);

            addValue(encodeRefOrNull(e, index));

        }

        public void putRef(Entry e, byte cptag) {

            putRef(e, getCPIndex(cptag));

        }

        public Entry getRef() {

            if (index == null)  Utils.log.warning("No index for "+this);

            assert(index != null);

            return decodeRefOrNull(getValue(), index);

        }

        public Entry getRef(Index index) {

            assert(this.index == null);

            return decodeRefOrNull(getValue(), index);

        }

        public Entry getRef(byte cptag) {

            return getRef(getCPIndex(cptag));

        }

        private int encodeRefOrNull(Entry e, Index index) {

            int nonNullCode;  // NNC is the coding which assumes nulls are rare

            if (e == null) {

                nonNullCode = -1;  // negative values are rare

            } else {

                nonNullCode = encodeRef(e, index);

            }

            // If nulls are expected, increment, to make -1 code turn to 0.

            return (nullOK ? 1 : 0) + nonNullCode;

        }

        private Entry decodeRefOrNull(int code, Index index) {

            // Inverse to encodeRefOrNull...

            int nonNullCode = code - (nullOK ? 1 : 0);

            if (nonNullCode == -1) {

                return null;

            } else {

                return decodeRef(nonNullCode, index);

            }

        }

    }

    // Bootstrap support for CPRefBands.  These are needed to record

    // intended CP indexes, before the CP has been created.

    private final List<CPRefBand> allKQBands = new ArrayList<>();

    private List<Object[]> needPredefIndex = new ArrayList<>();

    int encodeRef(Entry e, Index ix) {

        if (ix == null)

            throw new RuntimeException("null index for " + e.stringValue());

        int coding = ix.indexOf(e);

        if (verbose > 2)

            Utils.log.fine("putRef "+coding+" => "+e);

        return coding;

    }

    Entry decodeRef(int n, Index ix) {

        if (n < 0 || n >= ix.size())

            Utils.log.warning("decoding bad ref "+n+" in "+ix);

        Entry e = ix.getEntry(n);

        if (verbose > 2)

            Utils.log.fine("getRef "+n+" => "+e);

        return e;

    }

    private CodingChooser codingChooser;

    protected CodingChooser getCodingChooser() {

        if (codingChooser == null) {

            codingChooser = new CodingChooser(effort, basicCodings);

            if (codingChooser.stress != null

                && this instanceof PackageWriter) {

                // Twist the random state based on my first file.

                // This sends each segment off in a different direction.

                List<Package.Class> classes = ((PackageWriter)this).pkg.classes;

                if (!classes.isEmpty()) {

                    Package.Class cls = classes.get(0);

                    codingChooser.addStressSeed(cls.getName().hashCode());

                }

            }

        }

        return codingChooser;

    }

    public CodingMethod chooseCoding(int[] values, int start, int end,

                                     Coding regular, String bandName,

                                     int[] sizes) {

        assert(optVaryCodings);

        if (effort <= MIN_EFFORT) {

            return regular;

        }

        CodingChooser cc = getCodingChooser();

        if (verbose > 1 || cc.verbose > 1) {

            Utils.log.fine("--- chooseCoding "+bandName);

        }

        return cc.choose(values, start, end, regular, sizes);

    }

    static final byte[] defaultMetaCoding = { _meta_default };

    static final byte[] noMetaCoding      = {};

    // The first value in a band is always coded with the default coding D.

    // If this first value X is an escape value, it actually represents the

    // first (and perhaps only) byte of a meta-coding.

    //

    // If D.S != 0 and D includes the range [-256..-1],

    // the escape values are in that range,

    // and the first byte XB is -1-X.

    //

    // If D.S == 0 and D includes the range [(D.L)..(D.L)+255],

    // the escape values are in that range,

    // and XB is X-(D.L).

    //

    // This representation is designed so that a band header is unlikely

    // to be confused with the initial value of a headerless band,

    // and yet so that a band header is likely to occupy only a byte or two.

    //

    // Result is in [0..255] if XB was successfully extracted, else -1.

    // See section "Coding Specifier Meta-Encoding" in the JSR 200 spec.

    protected static int decodeEscapeValue(int X, Coding regularCoding) {

        // The first value in a band is always coded with the default coding D.

        // If this first value X is an escape value, it actually represents the

        // first (and perhaps only) byte of a meta-coding.

        // Result is in [0..255] if XB was successfully extracted, else -1.

        if (regularCoding.B() == 1 || regularCoding.L() == 0)

            return -1;  // degenerate regular coding (BYTE1)

        if (regularCoding.S() != 0) {

            if (-256 <= X && X <= -1 && regularCoding.min() <= -256) {

                int XB = -1-X;

                assert(XB >= 0 && XB < 256);

                return XB;

            }

        } else {

            int L = regularCoding.L();

            if (L <= X && X <= L+255 && regularCoding.max() >= L+255) {

                int XB = X-L;

                assert(XB >= 0 && XB < 256);

                return XB;

            }

        }

        return -1;  // negative value for failure

    }

    // Inverse to decodeEscapeValue().

    protected static int encodeEscapeValue(int XB, Coding regularCoding) {

        assert(XB >= 0 && XB < 256);

        assert(regularCoding.B() > 1 && regularCoding.L() > 0);

        int X;

        if (regularCoding.S() != 0) {

            assert(regularCoding.min() <= -256);

            X = -1-XB;

        } else {

            int L = regularCoding.L();

            assert(regularCoding.max() >= L+255);

            X = XB+L;

        }

        assert(decodeEscapeValue(X, regularCoding) == XB)

            : (regularCoding+" XB="+XB+" X="+X);

        return X;

    }

    static {

        boolean checkXB = false;

        assert(checkXB = true);

        if (checkXB) {

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

                Coding D = basicCodings[i];

                if (D == null)   continue;

                if (D.B() == 1)  continue;

                if (D.L() == 0)  continue;

                for (int XB = 0; XB <= 255; XB++) {

                    // The following exercises decodeEscapeValue also:

                    encodeEscapeValue(XB, D);

                }

            }

        }

    }

    class MultiBand extends Band {

        MultiBand(String name, Coding regularCoding) {

            super(name, regularCoding);

        }

        @Override

        public Band init() {

            super.init();

            // This is all just to keep the asserts happy:

            setCapacity(0);

            if (phase() == EXPECT_PHASE) {

                // Fast forward:

                setPhase(READ_PHASE);

                setPhase(DISBURSE_PHASE);

            }

            return this;

        }

        Band[] bands     = new Band[10];

        int    bandCount = 0;

        int size() {

            return bandCount;

        }

        Band get(int i) {

            assert(i < bandCount);

            return bands[i];

        }

        Band[] toArray() {

            return (Band[]) realloc(bands, bandCount);

        }

        void add(Band b) {

            assert(bandCount == 0 || notePrevForAssert(b, bands[bandCount-1]));

            if (bandCount == bands.length) {

                bands = (Band[]) realloc(bands);

            }

            bands[bandCount++] = b;

        }

        ByteBand newByteBand(String name) {

            ByteBand b = new ByteBand(name);

            b.init(); add(b);

            return b;

        }

        IntBand newIntBand(String name) {

            IntBand b = new IntBand(name, regularCoding);

            b.init(); add(b);

            return b;

        }

        IntBand newIntBand(String name, Coding regularCoding) {

            IntBand b = new IntBand(name, regularCoding);

            b.init(); add(b);

            return b;

        }

        MultiBand newMultiBand(String name, Coding regularCoding) {

            MultiBand b = new MultiBand(name, regularCoding);

            b.init(); add(b);

            return b;

        }

        CPRefBand newCPRefBand(String name, byte cpTag) {

            CPRefBand b = new CPRefBand(name, regularCoding, cpTag);

            b.init(); add(b);

            return b;

        }

        CPRefBand newCPRefBand(String name, Coding regularCoding,

                               byte cpTag) {

            CPRefBand b = new CPRefBand(name, regularCoding, cpTag);

            b.init(); add(b);

            return b;

        }

        CPRefBand newCPRefBand(String name, Coding regularCoding,

                               byte cpTag, boolean nullOK) {

            CPRefBand b = new CPRefBand(name, regularCoding, cpTag, nullOK);

            b.init(); add(b);

            return b;

        }

        int bandCount() { return bandCount; }

        private int cap = -1;

        @Override

        public int capacity() { return cap; }

        @Override

        public void setCapacity(int cap) { this.cap = cap; }

        @Override

        public int length() { return 0; }

        @Override

        public int valuesRemainingForDebug() { return 0; }

        @Override

        protected void chooseBandCodings() throws IOException {

            // coding decision pass

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

                Band b = bands[i];

                b.chooseBandCodings();

            }

        }

        @Override

        protected long computeOutputSize() {

            // coding decision pass

            long sum = 0;

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

                Band b = bands[i];

                long bsize = b.outputSize();

                assert(bsize >= 0) : b;

                sum += bsize;

            }

            // do not cache

            return sum;

        }

        @Override

        protected void writeDataTo(OutputStream out) throws IOException {

            long preCount = 0;

            if (outputCounter != null)  preCount = outputCounter.getCount();