mirror of
https://github.com/go-gitea/gitea.git
synced 2024-08-26 21:54:19 -04:00
* update github.com/alecthomas/chroma v0.8.0 -> v0.8.1 * github.com/blevesearch/bleve v1.0.10 -> v1.0.12 * editorconfig-core-go v2.1.1 -> v2.3.7 * github.com/gliderlabs/ssh v0.2.2 -> v0.3.1 * migrate editorconfig.ParseBytes to Parse * github.com/shurcooL/vfsgen to 0d455de96546 * github.com/go-git/go-git/v5 v5.1.0 -> v5.2.0 * github.com/google/uuid v1.1.1 -> v1.1.2 * github.com/huandu/xstrings v1.3.0 -> v1.3.2 * github.com/klauspost/compress v1.10.11 -> v1.11.1 * github.com/markbates/goth v1.61.2 -> v1.65.0 * github.com/mattn/go-sqlite3 v1.14.0 -> v1.14.4 * github.com/mholt/archiver v3.3.0 -> v3.3.2 * github.com/microcosm-cc/bluemonday 4f7140c49acb -> v1.0.4 * github.com/minio/minio-go v7.0.4 -> v7.0.5 * github.com/olivere/elastic v7.0.9 -> v7.0.20 * github.com/urfave/cli v1.20.0 -> v1.22.4 * github.com/prometheus/client_golang v1.1.0 -> v1.8.0 * github.com/xanzy/go-gitlab v0.37.0 -> v0.38.1 * mvdan.cc/xurls v2.1.0 -> v2.2.0 Co-authored-by: Lauris BH <lauris@nix.lv>
150 lines
3.4 KiB
Go
Vendored
150 lines
3.4 KiB
Go
Vendored
// Copyright 2014-2019 Ulrich Kunitz. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
package lzma
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
)
|
|
|
|
// matcher is an interface that supports the identification of the next
|
|
// operation.
|
|
type matcher interface {
|
|
io.Writer
|
|
SetDict(d *encoderDict)
|
|
NextOp(rep [4]uint32) operation
|
|
}
|
|
|
|
// encoderDict provides the dictionary of the encoder. It includes an
|
|
// addtional buffer atop of the actual dictionary.
|
|
type encoderDict struct {
|
|
buf buffer
|
|
m matcher
|
|
head int64
|
|
capacity int
|
|
// preallocated array
|
|
data [maxMatchLen]byte
|
|
}
|
|
|
|
// newEncoderDict creates the encoder dictionary. The argument bufSize
|
|
// defines the size of the additional buffer.
|
|
func newEncoderDict(dictCap, bufSize int, m matcher) (d *encoderDict, err error) {
|
|
if !(1 <= dictCap && int64(dictCap) <= MaxDictCap) {
|
|
return nil, errors.New(
|
|
"lzma: dictionary capacity out of range")
|
|
}
|
|
if bufSize < 1 {
|
|
return nil, errors.New(
|
|
"lzma: buffer size must be larger than zero")
|
|
}
|
|
d = &encoderDict{
|
|
buf: *newBuffer(dictCap + bufSize),
|
|
capacity: dictCap,
|
|
m: m,
|
|
}
|
|
m.SetDict(d)
|
|
return d, nil
|
|
}
|
|
|
|
// Discard discards n bytes. Note that n must not be larger than
|
|
// MaxMatchLen.
|
|
func (d *encoderDict) Discard(n int) {
|
|
p := d.data[:n]
|
|
k, _ := d.buf.Read(p)
|
|
if k < n {
|
|
panic(fmt.Errorf("lzma: can't discard %d bytes", n))
|
|
}
|
|
d.head += int64(n)
|
|
d.m.Write(p)
|
|
}
|
|
|
|
// Len returns the data available in the encoder dictionary.
|
|
func (d *encoderDict) Len() int {
|
|
n := d.buf.Available()
|
|
if int64(n) > d.head {
|
|
return int(d.head)
|
|
}
|
|
return n
|
|
}
|
|
|
|
// DictLen returns the actual length of data in the dictionary.
|
|
func (d *encoderDict) DictLen() int {
|
|
if d.head < int64(d.capacity) {
|
|
return int(d.head)
|
|
}
|
|
return d.capacity
|
|
}
|
|
|
|
// Available returns the number of bytes that can be written by a
|
|
// following Write call.
|
|
func (d *encoderDict) Available() int {
|
|
return d.buf.Available() - d.DictLen()
|
|
}
|
|
|
|
// Write writes data into the dictionary buffer. Note that the position
|
|
// of the dictionary head will not be moved. If there is not enough
|
|
// space in the buffer ErrNoSpace will be returned.
|
|
func (d *encoderDict) Write(p []byte) (n int, err error) {
|
|
m := d.Available()
|
|
if len(p) > m {
|
|
p = p[:m]
|
|
err = ErrNoSpace
|
|
}
|
|
var e error
|
|
if n, e = d.buf.Write(p); e != nil {
|
|
err = e
|
|
}
|
|
return n, err
|
|
}
|
|
|
|
// Pos returns the position of the head.
|
|
func (d *encoderDict) Pos() int64 { return d.head }
|
|
|
|
// ByteAt returns the byte at the given distance.
|
|
func (d *encoderDict) ByteAt(distance int) byte {
|
|
if !(0 < distance && distance <= d.Len()) {
|
|
return 0
|
|
}
|
|
i := d.buf.rear - distance
|
|
if i < 0 {
|
|
i += len(d.buf.data)
|
|
}
|
|
return d.buf.data[i]
|
|
}
|
|
|
|
// CopyN copies the last n bytes from the dictionary into the provided
|
|
// writer. This is used for copying uncompressed data into an
|
|
// uncompressed segment.
|
|
func (d *encoderDict) CopyN(w io.Writer, n int) (written int, err error) {
|
|
if n <= 0 {
|
|
return 0, nil
|
|
}
|
|
m := d.Len()
|
|
if n > m {
|
|
n = m
|
|
err = ErrNoSpace
|
|
}
|
|
i := d.buf.rear - n
|
|
var e error
|
|
if i < 0 {
|
|
i += len(d.buf.data)
|
|
if written, e = w.Write(d.buf.data[i:]); e != nil {
|
|
return written, e
|
|
}
|
|
i = 0
|
|
}
|
|
var k int
|
|
k, e = w.Write(d.buf.data[i:d.buf.rear])
|
|
written += k
|
|
if e != nil {
|
|
err = e
|
|
}
|
|
return written, err
|
|
}
|
|
|
|
// Buffered returns the number of bytes in the buffer.
|
|
func (d *encoderDict) Buffered() int { return d.buf.Buffered() }
|