libgo: update to Go 1.11

[official-gcc.git] / libgo / go / compress / flate / inflate.go

// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Package flate implements the DEFLATE compressed data format, described in
// RFC 1951.  The gzip and zlib packages implement access to DEFLATE-based file
// formats.
package flate

import (
        "bufio"
        "io"
        "math/bits"
        "strconv"
        "sync"
)

const (
        maxCodeLen = 16 // max length of Huffman code
        // The next three numbers come from the RFC section 3.2.7, with the
        // additional proviso in section 3.2.5 which implies that distance codes
        // 30 and 31 should never occur in compressed data.
        maxNumLit  = 286
        maxNumDist = 30
        numCodes   = 19 // number of codes in Huffman meta-code
)

// Initialize the fixedHuffmanDecoder only once upon first use.
var fixedOnce sync.Once
var fixedHuffmanDecoder huffmanDecoder

// A CorruptInputError reports the presence of corrupt input at a given offset.
type CorruptInputError int64

func (e CorruptInputError) Error() string {
        return "flate: corrupt input before offset " + strconv.FormatInt(int64(e), 10)
}

// An InternalError reports an error in the flate code itself.
type InternalError string

func (e InternalError) Error() string { return "flate: internal error: " + string(e) }

// A ReadError reports an error encountered while reading input.
//
// Deprecated: No longer returned.
type ReadError struct {
        Offset int64 // byte offset where error occurred
        Err    error // error returned by underlying Read
}

func (e *ReadError) Error() string {
        return "flate: read error at offset " + strconv.FormatInt(e.Offset, 10) + ": " + e.Err.Error()
}

// A WriteError reports an error encountered while writing output.
//
// Deprecated: No longer returned.
type WriteError struct {
        Offset int64 // byte offset where error occurred
        Err    error // error returned by underlying Write
}

func (e *WriteError) Error() string {
        return "flate: write error at offset " + strconv.FormatInt(e.Offset, 10) + ": " + e.Err.Error()
}

// Resetter resets a ReadCloser returned by NewReader or NewReaderDict to
// to switch to a new underlying Reader. This permits reusing a ReadCloser
// instead of allocating a new one.
type Resetter interface {
        // Reset discards any buffered data and resets the Resetter as if it was
        // newly initialized with the given reader.
        Reset(r io.Reader, dict []byte) error
}

// The data structure for decoding Huffman tables is based on that of
// zlib. There is a lookup table of a fixed bit width (huffmanChunkBits),
// For codes smaller than the table width, there are multiple entries
// (each combination of trailing bits has the same value). For codes
// larger than the table width, the table contains a link to an overflow
// table. The width of each entry in the link table is the maximum code
// size minus the chunk width.
//
// Note that you can do a lookup in the table even without all bits
// filled. Since the extra bits are zero, and the DEFLATE Huffman codes
// have the property that shorter codes come before longer ones, the
// bit length estimate in the result is a lower bound on the actual
// number of bits.
//
// See the following:
//      http://www.gzip.org/algorithm.txt

// chunk & 15 is number of bits
// chunk >> 4 is value, including table link

const (
        huffmanChunkBits  = 9
        huffmanNumChunks  = 1 << huffmanChunkBits
        huffmanCountMask  = 15
        huffmanValueShift = 4
)

type huffmanDecoder struct {
        min      int                      // the minimum code length
        chunks   [huffmanNumChunks]uint32 // chunks as described above
        links    [][]uint32               // overflow links
        linkMask uint32                   // mask the width of the link table
}

// Initialize Huffman decoding tables from array of code lengths.
// Following this function, h is guaranteed to be initialized into a complete
// tree (i.e., neither over-subscribed nor under-subscribed). The exception is a
// degenerate case where the tree has only a single symbol with length 1. Empty
// trees are permitted.
func (h *huffmanDecoder) init(lengths []int) bool {
        // Sanity enables additional runtime tests during Huffman
        // table construction. It's intended to be used during
        // development to supplement the currently ad-hoc unit tests.
        const sanity = false

        if h.min != 0 {
                *h = huffmanDecoder{}
        }

        // Count number of codes of each length,
        // compute min and max length.
        var count [maxCodeLen]int
        var min, max int
        for _, n := range lengths {
                if n == 0 {
                        continue
                }
                if min == 0 || n < min {
                        min = n
                }
                if n > max {
                        max = n
                }
                count[n]++
        }

        // Empty tree. The decompressor.huffSym function will fail later if the tree
        // is used. Technically, an empty tree is only valid for the HDIST tree and
        // not the HCLEN and HLIT tree. However, a stream with an empty HCLEN tree
        // is guaranteed to fail since it will attempt to use the tree to decode the
        // codes for the HLIT and HDIST trees. Similarly, an empty HLIT tree is
        // guaranteed to fail later since the compressed data section must be
        // composed of at least one symbol (the end-of-block marker).
        if max == 0 {
                return true
        }

        code := 0
        var nextcode [maxCodeLen]int
        for i := min; i <= max; i++ {
                code <<= 1
                nextcode[i] = code
                code += count[i]
        }

        // Check that the coding is complete (i.e., that we've
        // assigned all 2-to-the-max possible bit sequences).
        // Exception: To be compatible with zlib, we also need to
        // accept degenerate single-code codings. See also
        // TestDegenerateHuffmanCoding.
        if code != 1<<uint(max) && !(code == 1 && max == 1) {
                return false
        }

        h.min = min
        if max > huffmanChunkBits {
                numLinks := 1 << (uint(max) - huffmanChunkBits)
                h.linkMask = uint32(numLinks - 1)

                // create link tables
                link := nextcode[huffmanChunkBits+1] >> 1
                h.links = make([][]uint32, huffmanNumChunks-link)
                for j := uint(link); j < huffmanNumChunks; j++ {
                        reverse := int(bits.Reverse16(uint16(j)))
                        reverse >>= uint(16 - huffmanChunkBits)
                        off := j - uint(link)
                        if sanity && h.chunks[reverse] != 0 {
                                panic("impossible: overwriting existing chunk")
                        }
                        h.chunks[reverse] = uint32(off<<huffmanValueShift | (huffmanChunkBits + 1))
                        h.links[off] = make([]uint32, numLinks)
                }
        }

        for i, n := range lengths {
                if n == 0 {
                        continue
                }
                code := nextcode[n]
                nextcode[n]++
                chunk := uint32(i<<huffmanValueShift | n)
                reverse := int(bits.Reverse16(uint16(code)))
                reverse >>= uint(16 - n)
                if n <= huffmanChunkBits {
                        for off := reverse; off < len(h.chunks); off += 1 << uint(n) {
                                // We should never need to overwrite
                                // an existing chunk. Also, 0 is
                                // never a valid chunk, because the
                                // lower 4 "count" bits should be
                                // between 1 and 15.
                                if sanity && h.chunks[off] != 0 {
                                        panic("impossible: overwriting existing chunk")
                                }
                                h.chunks[off] = chunk
                        }
                } else {
                        j := reverse & (huffmanNumChunks - 1)
                        if sanity && h.chunks[j]&huffmanCountMask != huffmanChunkBits+1 {
                                // Longer codes should have been
                                // associated with a link table above.
                                panic("impossible: not an indirect chunk")
                        }
                        value := h.chunks[j] >> huffmanValueShift
                        linktab := h.links[value]
                        reverse >>= huffmanChunkBits
                        for off := reverse; off < len(linktab); off += 1 << uint(n-huffmanChunkBits) {
                                if sanity && linktab[off] != 0 {
                                        panic("impossible: overwriting existing chunk")
                                }
                                linktab[off] = chunk
                        }
                }
        }

        if sanity {
                // Above we've sanity checked that we never overwrote
                // an existing entry. Here we additionally check that
                // we filled the tables completely.
                for i, chunk := range h.chunks {
                        if chunk == 0 {
                                // As an exception, in the degenerate
                                // single-code case, we allow odd
                                // chunks to be missing.
                                if code == 1 && i%2 == 1 {
                                        continue
                                }
                                panic("impossible: missing chunk")
                        }
                }
                for _, linktab := range h.links {
                        for _, chunk := range linktab {
                                if chunk == 0 {
                                        panic("impossible: missing chunk")
                                }
                        }
                }
        }

        return true
}

// The actual read interface needed by NewReader.
// If the passed in io.Reader does not also have ReadByte,
// the NewReader will introduce its own buffering.
type Reader interface {
        io.Reader
        io.ByteReader
}

// Decompress state.
type decompressor struct {
        // Input source.
        r       Reader
        roffset int64

        // Input bits, in top of b.
        b  uint32
        nb uint

        // Huffman decoders for literal/length, distance.
        h1, h2 huffmanDecoder

        // Length arrays used to define Huffman codes.
        bits     *[maxNumLit + maxNumDist]int
        codebits *[numCodes]int

        // Output history, buffer.
        dict dictDecoder

        // Temporary buffer (avoids repeated allocation).
        buf [4]byte

        // Next step in the decompression,
        // and decompression state.
        step      func(*decompressor)
        stepState int
        final     bool
        err       error
        toRead    []byte
        hl, hd    *huffmanDecoder
        copyLen   int
        copyDist  int
}

func (f *decompressor) nextBlock() {
        for f.nb < 1+2 {
                if f.err = f.moreBits(); f.err != nil {
                        return
                }
        }
        f.final = f.b&1 == 1
        f.b >>= 1
        typ := f.b & 3
        f.b >>= 2
        f.nb -= 1 + 2
        switch typ {
        case 0:
                f.dataBlock()
        case 1:
                // compressed, fixed Huffman tables
                f.hl = &fixedHuffmanDecoder
                f.hd = nil
                f.huffmanBlock()
        case 2:
                // compressed, dynamic Huffman tables
                if f.err = f.readHuffman(); f.err != nil {
                        break
                }
                f.hl = &f.h1
                f.hd = &f.h2
                f.huffmanBlock()
        default:
                // 3 is reserved.
                f.err = CorruptInputError(f.roffset)
        }
}

func (f *decompressor) Read(b []byte) (int, error) {
        for {
                if len(f.toRead) > 0 {
                        n := copy(b, f.toRead)
                        f.toRead = f.toRead[n:]
                        if len(f.toRead) == 0 {
                                return n, f.err
                        }
                        return n, nil
                }
                if f.err != nil {
                        return 0, f.err
                }
                f.step(f)
                if f.err != nil && len(f.toRead) == 0 {
                        f.toRead = f.dict.readFlush() // Flush what's left in case of error
                }
        }
}

func (f *decompressor) Close() error {
        if f.err == io.EOF {
                return nil
        }
        return f.err
}

// RFC 1951 section 3.2.7.
// Compression with dynamic Huffman codes

var codeOrder = [...]int{16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15}

func (f *decompressor) readHuffman() error {
        // HLIT[5], HDIST[5], HCLEN[4].
        for f.nb < 5+5+4 {
                if err := f.moreBits(); err != nil {
                        return err
                }
        }
        nlit := int(f.b&0x1F) + 257
        if nlit > maxNumLit {
                return CorruptInputError(f.roffset)
        }
        f.b >>= 5
        ndist := int(f.b&0x1F) + 1
        if ndist > maxNumDist {
                return CorruptInputError(f.roffset)
        }
        f.b >>= 5
        nclen := int(f.b&0xF) + 4
        // numCodes is 19, so nclen is always valid.
        f.b >>= 4
        f.nb -= 5 + 5 + 4

        // (HCLEN+4)*3 bits: code lengths in the magic codeOrder order.
        for i := 0; i < nclen; i++ {
                for f.nb < 3 {
                        if err := f.moreBits(); err != nil {
                                return err
                        }
                }
                f.codebits[codeOrder[i]] = int(f.b & 0x7)
                f.b >>= 3
                f.nb -= 3
        }
        for i := nclen; i < len(codeOrder); i++ {
                f.codebits[codeOrder[i]] = 0
        }
        if !f.h1.init(f.codebits[0:]) {
                return CorruptInputError(f.roffset)
        }

        // HLIT + 257 code lengths, HDIST + 1 code lengths,
        // using the code length Huffman code.
        for i, n := 0, nlit+ndist; i < n; {
                x, err := f.huffSym(&f.h1)
                if err != nil {
                        return err
                }
                if x < 16 {
                        // Actual length.
                        f.bits[i] = x
                        i++
                        continue
                }
                // Repeat previous length or zero.
                var rep int
                var nb uint
                var b int
                switch x {
                default:
                        return InternalError("unexpected length code")
                case 16:
                        rep = 3
                        nb = 2
                        if i == 0 {
                                return CorruptInputError(f.roffset)
                        }
                        b = f.bits[i-1]
                case 17:
                        rep = 3
                        nb = 3
                        b = 0
                case 18:
                        rep = 11
                        nb = 7
                        b = 0
                }
                for f.nb < nb {
                        if err := f.moreBits(); err != nil {
                                return err
                        }
                }
                rep += int(f.b & uint32(1<<nb-1))
                f.b >>= nb
                f.nb -= nb
                if i+rep > n {
                        return CorruptInputError(f.roffset)
                }
                for j := 0; j < rep; j++ {
                        f.bits[i] = b
                        i++
                }
        }

        if !f.h1.init(f.bits[0:nlit]) || !f.h2.init(f.bits[nlit:nlit+ndist]) {
                return CorruptInputError(f.roffset)
        }

        // As an optimization, we can initialize the min bits to read at a time
        // for the HLIT tree to the length of the EOB marker since we know that
        // every block must terminate with one. This preserves the property that
        // we never read any extra bytes after the end of the DEFLATE stream.
        if f.h1.min < f.bits[endBlockMarker] {
                f.h1.min = f.bits[endBlockMarker]
        }

        return nil
}

// Decode a single Huffman block from f.
// hl and hd are the Huffman states for the lit/length values
// and the distance values, respectively. If hd == nil, using the
// fixed distance encoding associated with fixed Huffman blocks.
func (f *decompressor) huffmanBlock() {
        const (
                stateInit = iota // Zero value must be stateInit
                stateDict
        )

        switch f.stepState {
        case stateInit:
                goto readLiteral
        case stateDict:
                goto copyHistory
        }

readLiteral:
        // Read literal and/or (length, distance) according to RFC section 3.2.3.
        {
                v, err := f.huffSym(f.hl)
                if err != nil {
                        f.err = err
                        return
                }
                var n uint // number of bits extra
                var length int
                switch {
                case v < 256:
                        f.dict.writeByte(byte(v))
                        if f.dict.availWrite() == 0 {
                                f.toRead = f.dict.readFlush()
                                f.step = (*decompressor).huffmanBlock
                                f.stepState = stateInit
                                return
                        }
                        goto readLiteral
                case v == 256:
                        f.finishBlock()
                        return
                // otherwise, reference to older data
                case v < 265:
                        length = v - (257 - 3)
                        n = 0
                case v < 269:
                        length = v*2 - (265*2 - 11)
                        n = 1
                case v < 273:
                        length = v*4 - (269*4 - 19)
                        n = 2
                case v < 277:
                        length = v*8 - (273*8 - 35)
                        n = 3
                case v < 281:
                        length = v*16 - (277*16 - 67)
                        n = 4
                case v < 285:
                        length = v*32 - (281*32 - 131)
                        n = 5
                case v < maxNumLit:
                        length = 258
                        n = 0
                default:
                        f.err = CorruptInputError(f.roffset)
                        return
                }
                if n > 0 {
                        for f.nb < n {
                                if err = f.moreBits(); err != nil {
                                        f.err = err
                                        return
                                }
                        }
                        length += int(f.b & uint32(1<<n-1))
                        f.b >>= n
                        f.nb -= n
                }

                var dist int
                if f.hd == nil {
                        for f.nb < 5 {
                                if err = f.moreBits(); err != nil {
                                        f.err = err
                                        return
                                }
                        }
                        dist = int(bits.Reverse8(uint8(f.b & 0x1F << 3)))
                        f.b >>= 5
                        f.nb -= 5
                } else {
                        if dist, err = f.huffSym(f.hd); err != nil {
                                f.err = err
                                return
                        }
                }

                switch {
                case dist < 4:
                        dist++
                case dist < maxNumDist:
                        nb := uint(dist-2) >> 1
                        // have 1 bit in bottom of dist, need nb more.
                        extra := (dist & 1) << nb
                        for f.nb < nb {
                                if err = f.moreBits(); err != nil {
                                        f.err = err
                                        return
                                }
                        }
                        extra |= int(f.b & uint32(1<<nb-1))
                        f.b >>= nb
                        f.nb -= nb
                        dist = 1<<(nb+1) + 1 + extra
                default:
                        f.err = CorruptInputError(f.roffset)
                        return
                }

                // No check on length; encoding can be prescient.
                if dist > f.dict.histSize() {
                        f.err = CorruptInputError(f.roffset)
                        return
                }

                f.copyLen, f.copyDist = length, dist
                goto copyHistory
        }

copyHistory:
        // Perform a backwards copy according to RFC section 3.2.3.
        {
                cnt := f.dict.tryWriteCopy(f.copyDist, f.copyLen)
                if cnt == 0 {
                        cnt = f.dict.writeCopy(f.copyDist, f.copyLen)
                }
                f.copyLen -= cnt

                if f.dict.availWrite() == 0 || f.copyLen > 0 {
                        f.toRead = f.dict.readFlush()
                        f.step = (*decompressor).huffmanBlock // We need to continue this work
                        f.stepState = stateDict
                        return
                }
                goto readLiteral
        }
}

// Copy a single uncompressed data block from input to output.
func (f *decompressor) dataBlock() {
        // Uncompressed.
        // Discard current half-byte.
        f.nb = 0
        f.b = 0

        // Length then ones-complement of length.
        nr, err := io.ReadFull(f.r, f.buf[0:4])
        f.roffset += int64(nr)
        if err != nil {
                f.err = noEOF(err)
                return
        }
        n := int(f.buf[0]) | int(f.buf[1])<<8
        nn := int(f.buf[2]) | int(f.buf[3])<<8
        if uint16(nn) != uint16(^n) {
                f.err = CorruptInputError(f.roffset)
                return
        }

        if n == 0 {
                f.toRead = f.dict.readFlush()
                f.finishBlock()
                return
        }

        f.copyLen = n
        f.copyData()
}

// copyData copies f.copyLen bytes from the underlying reader into f.hist.
// It pauses for reads when f.hist is full.
func (f *decompressor) copyData() {
        buf := f.dict.writeSlice()
        if len(buf) > f.copyLen {
                buf = buf[:f.copyLen]
        }

        cnt, err := io.ReadFull(f.r, buf)
        f.roffset += int64(cnt)
        f.copyLen -= cnt
        f.dict.writeMark(cnt)
        if err != nil {
                f.err = noEOF(err)
                return
        }

        if f.dict.availWrite() == 0 || f.copyLen > 0 {
                f.toRead = f.dict.readFlush()
                f.step = (*decompressor).copyData
                return
        }
        f.finishBlock()
}

func (f *decompressor) finishBlock() {
        if f.final {
                if f.dict.availRead() > 0 {
                        f.toRead = f.dict.readFlush()
                }
                f.err = io.EOF
        }
        f.step = (*decompressor).nextBlock
}

// noEOF returns err, unless err == io.EOF, in which case it returns io.ErrUnexpectedEOF.
func noEOF(e error) error {
        if e == io.EOF {
                return io.ErrUnexpectedEOF
        }
        return e
}

func (f *decompressor) moreBits() error {
        c, err := f.r.ReadByte()
        if err != nil {
                return noEOF(err)
        }
        f.roffset++
        f.b |= uint32(c) << f.nb
        f.nb += 8
        return nil
}

// Read the next Huffman-encoded symbol from f according to h.
func (f *decompressor) huffSym(h *huffmanDecoder) (int, error) {
        // Since a huffmanDecoder can be empty or be composed of a degenerate tree
        // with single element, huffSym must error on these two edge cases. In both
        // cases, the chunks slice will be 0 for the invalid sequence, leading it
        // satisfy the n == 0 check below.
        n := uint(h.min)
        // Optimization. Compiler isn't smart enough to keep f.b,f.nb in registers,
        // but is smart enough to keep local variables in registers, so use nb and b,
        // inline call to moreBits and reassign b,nb back to f on return.
        nb, b := f.nb, f.b
        for {
                for nb < n {
                        c, err := f.r.ReadByte()
                        if err != nil {
                                f.b = b
                                f.nb = nb
                                return 0, noEOF(err)
                        }
                        f.roffset++
                        b |= uint32(c) << (nb & 31)
                        nb += 8
                }
                chunk := h.chunks[b&(huffmanNumChunks-1)]
                n = uint(chunk & huffmanCountMask)
                if n > huffmanChunkBits {
                        chunk = h.links[chunk>>huffmanValueShift][(b>>huffmanChunkBits)&h.linkMask]
                        n = uint(chunk & huffmanCountMask)
                }
                if n <= nb {
                        if n == 0 {
                                f.b = b
                                f.nb = nb
                                f.err = CorruptInputError(f.roffset)
                                return 0, f.err
                        }
                        f.b = b >> (n & 31)
                        f.nb = nb - n
                        return int(chunk >> huffmanValueShift), nil
                }
        }
}

func makeReader(r io.Reader) Reader {
        if rr, ok := r.(Reader); ok {
                return rr
        }
        return bufio.NewReader(r)
}

func fixedHuffmanDecoderInit() {
        fixedOnce.Do(func() {
                // These come from the RFC section 3.2.6.
                var bits [288]int
                for i := 0; i < 144; i++ {
                        bits[i] = 8
                }
                for i := 144; i < 256; i++ {
                        bits[i] = 9
                }
                for i := 256; i < 280; i++ {
                        bits[i] = 7
                }
                for i := 280; i < 288; i++ {
                        bits[i] = 8
                }
                fixedHuffmanDecoder.init(bits[:])
        })
}

func (f *decompressor) Reset(r io.Reader, dict []byte) error {
        *f = decompressor{
                r:        makeReader(r),
                bits:     f.bits,
                codebits: f.codebits,
                dict:     f.dict,
                step:     (*decompressor).nextBlock,
        }
        f.dict.init(maxMatchOffset, dict)
        return nil
}

// NewReader returns a new ReadCloser that can be used
// to read the uncompressed version of r.
// If r does not also implement io.ByteReader,
// the decompressor may read more data than necessary from r.
// It is the caller's responsibility to call Close on the ReadCloser
// when finished reading.
//
// The ReadCloser returned by NewReader also implements Resetter.
func NewReader(r io.Reader) io.ReadCloser {
        fixedHuffmanDecoderInit()

        var f decompressor
        f.r = makeReader(r)
        f.bits = new([maxNumLit + maxNumDist]int)
        f.codebits = new([numCodes]int)
        f.step = (*decompressor).nextBlock
        f.dict.init(maxMatchOffset, nil)
        return &f
}

// NewReaderDict is like NewReader but initializes the reader
// with a preset dictionary. The returned Reader behaves as if
// the uncompressed data stream started with the given dictionary,
// which has already been read. NewReaderDict is typically used
// to read data compressed by NewWriterDict.
//
// The ReadCloser returned by NewReader also implements Resetter.
func NewReaderDict(r io.Reader, dict []byte) io.ReadCloser {
        fixedHuffmanDecoderInit()

        var f decompressor
        f.r = makeReader(r)
        f.bits = new([maxNumLit + maxNumDist]int)
        f.codebits = new([numCodes]int)
        f.step = (*decompressor).nextBlock
        f.dict.init(maxMatchOffset, dict)
        return &f
}