mirror of
https://github.com/ceph/ceph-csi.git
synced 2025-04-11 18:13:00 +00:00
bec6090996
Several packages are only used while running the e2e suite. These packages are less important to update, as the they can not influence the final executable that is part of the Ceph-CSI container-image. By moving these dependencies out of the main Ceph-CSI go.mod, it is easier to identify if a reported CVE affects Ceph-CSI, or only the testing (like most of the Kubernetes CVEs). Signed-off-by: Niels de Vos <ndevos@ibm.com>
113 lines
3.4 KiB
Go
113 lines
3.4 KiB
Go
// Copyright 2018 Klaus Post. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file.
|
|
// Based on work Copyright (c) 2013, Yann Collet, released under BSD License.
|
|
|
|
package zstd
|
|
|
|
// bitWriter will write bits.
|
|
// First bit will be LSB of the first byte of output.
|
|
type bitWriter struct {
|
|
bitContainer uint64
|
|
nBits uint8
|
|
out []byte
|
|
}
|
|
|
|
// bitMask16 is bitmasks. Has extra to avoid bounds check.
|
|
var bitMask16 = [32]uint16{
|
|
0, 1, 3, 7, 0xF, 0x1F,
|
|
0x3F, 0x7F, 0xFF, 0x1FF, 0x3FF, 0x7FF,
|
|
0xFFF, 0x1FFF, 0x3FFF, 0x7FFF, 0xFFFF, 0xFFFF,
|
|
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
|
|
0xFFFF, 0xFFFF} /* up to 16 bits */
|
|
|
|
var bitMask32 = [32]uint32{
|
|
0, 1, 3, 7, 0xF, 0x1F, 0x3F, 0x7F, 0xFF,
|
|
0x1FF, 0x3FF, 0x7FF, 0xFFF, 0x1FFF, 0x3FFF, 0x7FFF, 0xFFFF,
|
|
0x1ffff, 0x3ffff, 0x7FFFF, 0xfFFFF, 0x1fFFFF, 0x3fFFFF, 0x7fFFFF, 0xffFFFF,
|
|
0x1ffFFFF, 0x3ffFFFF, 0x7ffFFFF, 0xfffFFFF, 0x1fffFFFF, 0x3fffFFFF, 0x7fffFFFF,
|
|
} // up to 32 bits
|
|
|
|
// addBits16NC will add up to 16 bits.
|
|
// It will not check if there is space for them,
|
|
// so the caller must ensure that it has flushed recently.
|
|
func (b *bitWriter) addBits16NC(value uint16, bits uint8) {
|
|
b.bitContainer |= uint64(value&bitMask16[bits&31]) << (b.nBits & 63)
|
|
b.nBits += bits
|
|
}
|
|
|
|
// addBits32NC will add up to 31 bits.
|
|
// It will not check if there is space for them,
|
|
// so the caller must ensure that it has flushed recently.
|
|
func (b *bitWriter) addBits32NC(value uint32, bits uint8) {
|
|
b.bitContainer |= uint64(value&bitMask32[bits&31]) << (b.nBits & 63)
|
|
b.nBits += bits
|
|
}
|
|
|
|
// addBits64NC will add up to 64 bits.
|
|
// There must be space for 32 bits.
|
|
func (b *bitWriter) addBits64NC(value uint64, bits uint8) {
|
|
if bits <= 31 {
|
|
b.addBits32Clean(uint32(value), bits)
|
|
return
|
|
}
|
|
b.addBits32Clean(uint32(value), 32)
|
|
b.flush32()
|
|
b.addBits32Clean(uint32(value>>32), bits-32)
|
|
}
|
|
|
|
// addBits32Clean will add up to 32 bits.
|
|
// It will not check if there is space for them.
|
|
// The input must not contain more bits than specified.
|
|
func (b *bitWriter) addBits32Clean(value uint32, bits uint8) {
|
|
b.bitContainer |= uint64(value) << (b.nBits & 63)
|
|
b.nBits += bits
|
|
}
|
|
|
|
// addBits16Clean will add up to 16 bits. value may not contain more set bits than indicated.
|
|
// It will not check if there is space for them, so the caller must ensure that it has flushed recently.
|
|
func (b *bitWriter) addBits16Clean(value uint16, bits uint8) {
|
|
b.bitContainer |= uint64(value) << (b.nBits & 63)
|
|
b.nBits += bits
|
|
}
|
|
|
|
// flush32 will flush out, so there are at least 32 bits available for writing.
|
|
func (b *bitWriter) flush32() {
|
|
if b.nBits < 32 {
|
|
return
|
|
}
|
|
b.out = append(b.out,
|
|
byte(b.bitContainer),
|
|
byte(b.bitContainer>>8),
|
|
byte(b.bitContainer>>16),
|
|
byte(b.bitContainer>>24))
|
|
b.nBits -= 32
|
|
b.bitContainer >>= 32
|
|
}
|
|
|
|
// flushAlign will flush remaining full bytes and align to next byte boundary.
|
|
func (b *bitWriter) flushAlign() {
|
|
nbBytes := (b.nBits + 7) >> 3
|
|
for i := uint8(0); i < nbBytes; i++ {
|
|
b.out = append(b.out, byte(b.bitContainer>>(i*8)))
|
|
}
|
|
b.nBits = 0
|
|
b.bitContainer = 0
|
|
}
|
|
|
|
// close will write the alignment bit and write the final byte(s)
|
|
// to the output.
|
|
func (b *bitWriter) close() {
|
|
// End mark
|
|
b.addBits16Clean(1, 1)
|
|
// flush until next byte.
|
|
b.flushAlign()
|
|
}
|
|
|
|
// reset and continue writing by appending to out.
|
|
func (b *bitWriter) reset(out []byte) {
|
|
b.bitContainer = 0
|
|
b.nBits = 0
|
|
b.out = out
|
|
}
|