Add a lib/cgozlib package

This commit is contained in:
Nigel Tao committed 2019-09-01 22:48:56 +10:00
1 parent 1fa39758cf
commit a93d5a8ea7
2 files changed
+348

No files matched your search

+239
View File
@@ -0,0 +1,239 @@
// Copyright 2019 The Wuffs Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// ----------------
// Package cgozlib wraps the C "zlib" library.
//
// Unlike some other wrappers, this one supports dictionaries.
package cgozlib
/*
#cgo pkg-config: zlib
#include "zlib.h"
typedef struct {
uInt ndst;
uInt nsrc;
} advances;
int cgozlib_inflateInit(z_stream* z) {
return inflateInit(z);
}
int cgozlib_inflateSetDictionary(z_stream* z,
Bytef* dict_ptr,
uInt dict_len) {
return inflateSetDictionary(z, dict_ptr, dict_len);
}
int cgozlib_inflate(z_stream* z,
advances *a,
Bytef* next_out,
uInt avail_out,
Bytef* next_in,
uInt avail_in) {
z->next_out = next_out;
z->avail_out = avail_out;
z->next_in = next_in;
z->avail_in = avail_in;
int ret = inflate(z, Z_NO_FLUSH);
a->ndst = avail_out - z->avail_out;
a->nsrc = avail_in - z->avail_in;
z->next_out = NULL;
z->avail_out = 0;
z->next_in = NULL;
z->avail_in = 0;
return ret;
}
int cgozlib_inflateEnd(z_stream* z) {
return inflateEnd(z);
}
*/
import "C"
import (
"errors"
"io"
"unsafe"
)
var (
errMissingResetCall = errors.New("cgozlib: missing Reset call")
errNilIOReader = errors.New("cgozlib: nil io.Reader")
errNilReceiver = errors.New("cgozlib: nil receiver")
)
const (
errCodeStreamEnd = 1
errCodeNeedDict = 2
)
type errCode int32
func (e errCode) Error() string {
switch e {
case +1:
return "cgozlib: Z_STREAM_END"
case +2:
return "cgozlib: Z_NEED_DICT"
case -1:
return "cgozlib: Z_ERRNO"
case -2:
return "cgozlib: Z_STREAM_ERROR"
case -3:
return "cgozlib: Z_DATA_ERROR"
case -4:
return "cgozlib: Z_MEM_ERROR"
case -5:
return "cgozlib: Z_BUF_ERROR"
case -6:
return "cgozlib: Z_VERSION_ERROR"
}
return "cgozlib: unknown zlib error"
}
// Reader is both a zlib.Resetter and an io.ReadCloser. Call Reset before
// calling Read.
//
// It is analogous to the value returned by zlib.NewReader in the Go standard
// library.
type Reader struct {
buf [4096]byte
i, j uint32
r io.Reader
dict []byte
readErr error
zlibErr error
z C.z_stream
a C.advances
}
// Reset implements zlib.Resetter.
func (r *Reader) Reset(reader io.Reader, dictionary []byte) error {
if r == nil {
return errNilReceiver
}
if reader == nil {
return errNilIOReader
}
if err := r.Close(); err != nil {
return err
}
if e := C.cgozlib_inflateInit(&r.z); e != 0 {
return errCode(e)
}
r.r = reader
r.dict = dictionary
if n := len(r.dict); n > 32768 {
r.dict = r.dict[n-32768:]
}
return nil
}
// Close implements io.Closer.
func (r *Reader) Close() error {
if r == nil {
return errNilReceiver
}
if r.r == nil {
return nil
}
r.i = 0
r.j = 0
r.r = nil
r.dict = nil
r.readErr = nil
r.zlibErr = nil
if e := C.cgozlib_inflateEnd(&r.z); e != 0 {
return errCode(e)
}
return nil
}
// Read implements io.Reader.
func (r *Reader) Read(p []byte) (int, error) {
if r == nil {
return 0, errNilReceiver
}
if r.r == nil {
return 0, errMissingResetCall
}
const maxLen = 1 << 30
if len(p) > maxLen {
p = p[:maxLen]
}
for numRead := 0; ; {
if r.zlibErr != nil {
return numRead, r.zlibErr
}
if len(p) == 0 {
return numRead, nil
}
if r.i >= r.j {
if r.readErr != nil {
return numRead, r.readErr
}
n, err := r.r.Read(r.buf[:])
if err == io.EOF {
err = io.ErrUnexpectedEOF
}
r.i, r.j, r.readErr = 0, uint32(n), err
continue
}
e := C.cgozlib_inflate(&r.z, &r.a,
(*C.Bytef)(unsafe.Pointer(&p[0])),
(C.uInt)(len(p)),
(*C.Bytef)(unsafe.Pointer(&r.buf[r.i])),
(C.uInt)(r.j-r.i),
)
numRead += int(r.a.ndst)
p = p[int(r.a.ndst):]
r.i += uint32(r.a.nsrc)
if e == 0 {
continue
} else if e == errCodeStreamEnd {
r.zlibErr = io.EOF
} else if (e == errCodeNeedDict) && (len(r.dict) > 0) {
e = C.cgozlib_inflateSetDictionary(&r.z,
(*C.Bytef)(unsafe.Pointer(&r.dict[0])),
(C.uInt)(len(r.dict)),
)
if e == 0 {
continue
}
r.zlibErr = errCode(e)
} else {
r.zlibErr = errCode(e)
}
return numRead, r.zlibErr
}
}
+109
View File
@@ -0,0 +1,109 @@
// Copyright 2019 The Wuffs Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package cgozlib
import (
"bytes"
"compress/zlib"
"io"
"io/ioutil"
"strings"
"testing"
)
// These examples come from the RAC spec.
var (
compressedMore = "\x78\x9c\x01\x06\x00\xf9\xff\x4d\x6f\x72\x65\x21" +
"\x0a\x07\x42\x01\xbf"
compressedSheep = "\x78\xf9\x0b\xe0\x02\x6e\x0a\x29\xcf\x87\x31\x01\x01" +
"\x00\x00\xff\xff\x18\x0c\x03\xa8"
dictSheep = []byte("\x20sheep.\n")
)
type resetReadCloser interface {
zlib.Resetter
io.ReadCloser
}
func makePure() resetReadCloser {
r, err := zlib.NewReader(strings.NewReader(compressedMore))
if err != nil {
panic(err.Error())
}
return r.(resetReadCloser)
}
func testReadAll(t *testing.T, r resetReadCloser, src io.Reader, dict []byte, want string) {
t.Helper()
if err := r.Reset(src, dict); err != nil {
t.Fatalf("Reset: %v", err)
}
got, err := ioutil.ReadAll(r)
if err != nil {
t.Fatalf("ReadAll: %v", err)
}
if err := r.Close(); err != nil {
t.Fatalf("Close: %v", err)
}
if string(got) != want {
t.Fatalf("got %q, want %q", got, want)
}
}
func testReader(t *testing.T, r resetReadCloser) {
testReadAll(t, r, strings.NewReader(compressedMore), nil, "More!\n")
testReadAll(t, r, strings.NewReader(compressedSheep), dictSheep, "Two sheep.\n")
testReadAll(t, r, strings.NewReader(compressedMore), nil, "More!\n")
testReadAll(t, r, strings.NewReader(compressedSheep), dictSheep, "Two sheep.\n")
}
func TestCgo(t *testing.T) { testReader(t, &Reader{}) }
func TestPure(t *testing.T) { testReader(t, makePure()) }
func benchmarkReader(b *testing.B, r resetReadCloser) {
src := bytes.NewReader(nil)
srcBytes, err := ioutil.ReadFile("../../test/data/pi.txt.zlib")
if err != nil {
b.Fatalf("ReadFile: %v", err)
}
b.ResetTimer()
for i := 0; i < b.N; i++ {
src.Reset(srcBytes)
if err := r.Reset(src, nil); err != nil {
b.Fatalf("Reset: %v", err)
}
if n, err := io.Copy(ioutil.Discard, r); err != nil {
b.Fatalf("Copy: %v", err)
} else if n != 100003 {
b.Fatalf("Copy: got %d, want %d", n, 100003)
}
if err := r.Close(); err != nil {
b.Fatalf("Close: %v", err)
}
}
}
func BenchmarkCgo(b *testing.B) { benchmarkReader(b, &Reader{}) }
func BenchmarkPure(b *testing.B) { benchmarkReader(b, makePure()) }