mirror of git://gcc.gnu.org/git/gcc.git
135 lines
3.2 KiB
Go
135 lines
3.2 KiB
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 adler32 implements the Adler-32 checksum.
|
|
//
|
|
// It is defined in RFC 1950:
|
|
// Adler-32 is composed of two sums accumulated per byte: s1 is
|
|
// the sum of all bytes, s2 is the sum of all s1 values. Both sums
|
|
// are done modulo 65521. s1 is initialized to 1, s2 to zero. The
|
|
// Adler-32 checksum is stored as s2*65536 + s1 in most-
|
|
// significant-byte first (network) order.
|
|
package adler32
|
|
|
|
import (
|
|
"errors"
|
|
"hash"
|
|
)
|
|
|
|
const (
|
|
// mod is the largest prime that is less than 65536.
|
|
mod = 65521
|
|
// nmax is the largest n such that
|
|
// 255 * n * (n+1) / 2 + (n+1) * (mod-1) <= 2^32-1.
|
|
// It is mentioned in RFC 1950 (search for "5552").
|
|
nmax = 5552
|
|
)
|
|
|
|
// The size of an Adler-32 checksum in bytes.
|
|
const Size = 4
|
|
|
|
// digest represents the partial evaluation of a checksum.
|
|
// The low 16 bits are s1, the high 16 bits are s2.
|
|
type digest uint32
|
|
|
|
func (d *digest) Reset() { *d = 1 }
|
|
|
|
// New returns a new hash.Hash32 computing the Adler-32 checksum. Its
|
|
// Sum method will lay the value out in big-endian byte order. The
|
|
// returned Hash32 also implements encoding.BinaryMarshaler and
|
|
// encoding.BinaryUnmarshaler to marshal and unmarshal the internal
|
|
// state of the hash.
|
|
func New() hash.Hash32 {
|
|
d := new(digest)
|
|
d.Reset()
|
|
return d
|
|
}
|
|
|
|
func (d *digest) Size() int { return Size }
|
|
|
|
func (d *digest) BlockSize() int { return 4 }
|
|
|
|
const (
|
|
magic = "adl\x01"
|
|
marshaledSize = len(magic) + 4
|
|
)
|
|
|
|
func (d *digest) MarshalBinary() ([]byte, error) {
|
|
b := make([]byte, 0, marshaledSize)
|
|
b = append(b, magic...)
|
|
b = appendUint32(b, uint32(*d))
|
|
return b, nil
|
|
}
|
|
|
|
func (d *digest) UnmarshalBinary(b []byte) error {
|
|
if len(b) < len(magic) || string(b[:len(magic)]) != magic {
|
|
return errors.New("hash/adler32: invalid hash state identifier")
|
|
}
|
|
if len(b) != marshaledSize {
|
|
return errors.New("hash/adler32: invalid hash state size")
|
|
}
|
|
*d = digest(readUint32(b[len(magic):]))
|
|
return nil
|
|
}
|
|
|
|
func appendUint32(b []byte, x uint32) []byte {
|
|
a := [4]byte{
|
|
byte(x >> 24),
|
|
byte(x >> 16),
|
|
byte(x >> 8),
|
|
byte(x),
|
|
}
|
|
return append(b, a[:]...)
|
|
}
|
|
|
|
func readUint32(b []byte) uint32 {
|
|
_ = b[3]
|
|
return uint32(b[3]) | uint32(b[2])<<8 | uint32(b[1])<<16 | uint32(b[0])<<24
|
|
}
|
|
|
|
// Add p to the running checksum d.
|
|
func update(d digest, p []byte) digest {
|
|
s1, s2 := uint32(d&0xffff), uint32(d>>16)
|
|
for len(p) > 0 {
|
|
var q []byte
|
|
if len(p) > nmax {
|
|
p, q = p[:nmax], p[nmax:]
|
|
}
|
|
for len(p) >= 4 {
|
|
s1 += uint32(p[0])
|
|
s2 += s1
|
|
s1 += uint32(p[1])
|
|
s2 += s1
|
|
s1 += uint32(p[2])
|
|
s2 += s1
|
|
s1 += uint32(p[3])
|
|
s2 += s1
|
|
p = p[4:]
|
|
}
|
|
for _, x := range p {
|
|
s1 += uint32(x)
|
|
s2 += s1
|
|
}
|
|
s1 %= mod
|
|
s2 %= mod
|
|
p = q
|
|
}
|
|
return digest(s2<<16 | s1)
|
|
}
|
|
|
|
func (d *digest) Write(p []byte) (nn int, err error) {
|
|
*d = update(*d, p)
|
|
return len(p), nil
|
|
}
|
|
|
|
func (d *digest) Sum32() uint32 { return uint32(*d) }
|
|
|
|
func (d *digest) Sum(in []byte) []byte {
|
|
s := uint32(*d)
|
|
return append(in, byte(s>>24), byte(s>>16), byte(s>>8), byte(s))
|
|
}
|
|
|
|
// Checksum returns the Adler-32 checksum of data.
|
|
func Checksum(data []byte) uint32 { return uint32(update(1, data)) }
|