mirror of
https://github.com/ddidderr/wuffs.git
synced 2026-11-19 16:47:28 +01:00
282 lines
9.0 KiB
C
282 lines
9.0 KiB
C
// After editing this file, run "go generate" in the parent directory.
|
|
|
|
// Copyright 2017 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.
|
|
|
|
// ---------------- I/O
|
|
|
|
static inline bool //
|
|
wuffs_base__io_buffer__is_valid(wuffs_base__io_buffer buf) {
|
|
return (buf.data.ptr || (buf.data.len == 0)) &&
|
|
(buf.data.len >= buf.meta.wi) && (buf.meta.wi >= buf.meta.ri);
|
|
}
|
|
|
|
// TODO: wuffs_base__io_reader__is_eof is no longer used by Wuffs per se, but
|
|
// it might be handy to programs that use Wuffs. Either delete it, or promote
|
|
// it to the public API.
|
|
//
|
|
// If making this function public (i.e. moving it to base-header.h), it also
|
|
// needs to allow NULL (i.e. implicit, callee-calculated) mark/limit.
|
|
|
|
static inline bool //
|
|
wuffs_base__io_reader__is_eof(wuffs_base__io_reader o) {
|
|
wuffs_base__io_buffer* buf = o.private_impl.buf;
|
|
return buf && buf->meta.closed &&
|
|
(buf->data.ptr + buf->meta.wi == o.private_impl.limit);
|
|
}
|
|
|
|
static inline bool //
|
|
wuffs_base__io_reader__is_valid(wuffs_base__io_reader o) {
|
|
wuffs_base__io_buffer* buf = o.private_impl.buf;
|
|
// Note: if making this function public (i.e. moving it to base-header.h), it
|
|
// also needs to allow NULL (i.e. implicit, callee-calculated) mark/limit.
|
|
return buf ? ((buf->data.ptr <= o.private_impl.mark) &&
|
|
(o.private_impl.mark <= o.private_impl.limit) &&
|
|
(o.private_impl.limit <= buf->data.ptr + buf->data.len))
|
|
: ((o.private_impl.mark == NULL) &&
|
|
(o.private_impl.limit == NULL));
|
|
}
|
|
|
|
static inline bool //
|
|
wuffs_base__io_writer__is_valid(wuffs_base__io_writer o) {
|
|
wuffs_base__io_buffer* buf = o.private_impl.buf;
|
|
// Note: if making this function public (i.e. moving it to base-header.h), it
|
|
// also needs to allow NULL (i.e. implicit, callee-calculated) mark/limit.
|
|
return buf ? ((buf->data.ptr <= o.private_impl.mark) &&
|
|
(o.private_impl.mark <= o.private_impl.limit) &&
|
|
(o.private_impl.limit <= buf->data.ptr + buf->data.len))
|
|
: ((o.private_impl.mark == NULL) &&
|
|
(o.private_impl.limit == NULL));
|
|
}
|
|
|
|
static inline uint32_t //
|
|
wuffs_base__io_writer__copy_n_from_history(uint8_t** ptr_iop_w,
|
|
uint8_t* io0_w,
|
|
uint8_t* io1_w,
|
|
uint32_t length,
|
|
uint32_t distance) {
|
|
if (!distance) {
|
|
return 0;
|
|
}
|
|
uint8_t* p = *ptr_iop_w;
|
|
if ((size_t)(p - io0_w) < (size_t)(distance)) {
|
|
return 0;
|
|
}
|
|
uint8_t* q = p - distance;
|
|
size_t n = (size_t)(io1_w - p);
|
|
if ((size_t)(length) > n) {
|
|
length = (uint32_t)(n);
|
|
} else {
|
|
n = (size_t)(length);
|
|
}
|
|
// TODO: unrolling by 3 seems best for the std/deflate benchmarks, but that
|
|
// is mostly because 3 is the minimum length for the deflate format. This
|
|
// function implementation shouldn't overfit to that one format. Perhaps the
|
|
// copy_n_from_history Wuffs method should also take an unroll hint argument,
|
|
// and the cgen can look if that argument is the constant expression '3'.
|
|
//
|
|
// See also wuffs_base__io_writer__copy_n_from_history_fast below.
|
|
//
|
|
// Alternatively, or additionally, have a sloppy_copy_n_from_history method
|
|
// that copies 8 bytes at a time, possibly writing more than length bytes?
|
|
for (; n >= 3; n -= 3) {
|
|
*p++ = *q++;
|
|
*p++ = *q++;
|
|
*p++ = *q++;
|
|
}
|
|
for (; n; n--) {
|
|
*p++ = *q++;
|
|
}
|
|
*ptr_iop_w = p;
|
|
return length;
|
|
}
|
|
|
|
// wuffs_base__io_writer__copy_n_from_history_fast is like the
|
|
// wuffs_base__io_writer__copy_n_from_history function above, but has stronger
|
|
// pre-conditions. The caller needs to prove that:
|
|
// - distance > 0
|
|
// - distance <= (*ptr_iop_w - io0_w)
|
|
// - length <= (io1_w - *ptr_iop_w)
|
|
static inline uint32_t //
|
|
wuffs_base__io_writer__copy_n_from_history_fast(uint8_t** ptr_iop_w,
|
|
uint8_t* io0_w,
|
|
uint8_t* io1_w,
|
|
uint32_t length,
|
|
uint32_t distance) {
|
|
uint8_t* p = *ptr_iop_w;
|
|
uint8_t* q = p - distance;
|
|
uint32_t n = length;
|
|
for (; n >= 3; n -= 3) {
|
|
*p++ = *q++;
|
|
*p++ = *q++;
|
|
*p++ = *q++;
|
|
}
|
|
for (; n; n--) {
|
|
*p++ = *q++;
|
|
}
|
|
*ptr_iop_w = p;
|
|
return length;
|
|
}
|
|
|
|
static inline uint32_t //
|
|
wuffs_base__io_writer__copy_n_from_reader(uint8_t** ptr_iop_w,
|
|
uint8_t* io1_w,
|
|
uint32_t length,
|
|
uint8_t** ptr_iop_r,
|
|
uint8_t* io1_r) {
|
|
uint8_t* iop_w = *ptr_iop_w;
|
|
size_t n = length;
|
|
if (n > ((size_t)(io1_w - iop_w))) {
|
|
n = (size_t)(io1_w - iop_w);
|
|
}
|
|
uint8_t* iop_r = *ptr_iop_r;
|
|
if (n > ((size_t)(io1_r - iop_r))) {
|
|
n = (size_t)(io1_r - iop_r);
|
|
}
|
|
if (n > 0) {
|
|
memmove(iop_w, iop_r, n);
|
|
*ptr_iop_w += n;
|
|
*ptr_iop_r += n;
|
|
}
|
|
return (uint32_t)(n);
|
|
}
|
|
|
|
static inline uint64_t //
|
|
wuffs_base__io_writer__copy_from_slice(uint8_t** ptr_iop_w,
|
|
uint8_t* io1_w,
|
|
wuffs_base__slice_u8 src) {
|
|
uint8_t* iop_w = *ptr_iop_w;
|
|
size_t n = src.len;
|
|
if (n > ((size_t)(io1_w - iop_w))) {
|
|
n = (size_t)(io1_w - iop_w);
|
|
}
|
|
if (n > 0) {
|
|
memmove(iop_w, src.ptr, n);
|
|
*ptr_iop_w += n;
|
|
}
|
|
return (uint64_t)(n);
|
|
}
|
|
|
|
static inline uint32_t //
|
|
wuffs_base__io_writer__copy_n_from_slice(uint8_t** ptr_iop_w,
|
|
uint8_t* io1_w,
|
|
uint32_t length,
|
|
wuffs_base__slice_u8 src) {
|
|
uint8_t* iop_w = *ptr_iop_w;
|
|
size_t n = src.len;
|
|
if (n > length) {
|
|
n = length;
|
|
}
|
|
if (n > ((size_t)(io1_w - iop_w))) {
|
|
n = (size_t)(io1_w - iop_w);
|
|
}
|
|
if (n > 0) {
|
|
memmove(iop_w, src.ptr, n);
|
|
*ptr_iop_w += n;
|
|
}
|
|
return (uint32_t)(n);
|
|
}
|
|
|
|
static inline wuffs_base__empty_struct //
|
|
wuffs_base__io_reader__set(wuffs_base__io_reader* o,
|
|
wuffs_base__io_buffer* b,
|
|
uint8_t** ptr_iop_r,
|
|
uint8_t** ptr_io1_r,
|
|
wuffs_base__slice_u8 data) {
|
|
b->data = data;
|
|
b->meta.wi = data.len;
|
|
b->meta.ri = 0;
|
|
b->meta.pos = 0;
|
|
b->meta.closed = false;
|
|
|
|
o->private_impl.buf = b;
|
|
o->private_impl.mark = data.ptr;
|
|
o->private_impl.limit = data.ptr + data.len;
|
|
*ptr_iop_r = data.ptr;
|
|
*ptr_io1_r = data.ptr + data.len;
|
|
|
|
wuffs_base__empty_struct ret;
|
|
ret.private_impl = 0;
|
|
return ret;
|
|
}
|
|
|
|
static inline wuffs_base__empty_struct //
|
|
wuffs_base__io_reader__set_limit(wuffs_base__io_reader* o,
|
|
uint8_t* iop_r,
|
|
uint64_t limit) {
|
|
if (o && (((size_t)(o->private_impl.limit - iop_r)) > limit)) {
|
|
o->private_impl.limit = iop_r + limit;
|
|
}
|
|
|
|
wuffs_base__empty_struct ret;
|
|
ret.private_impl = 0;
|
|
return ret;
|
|
}
|
|
|
|
static inline wuffs_base__empty_struct //
|
|
wuffs_base__io_reader__set_mark(wuffs_base__io_reader* o, uint8_t* mark) {
|
|
o->private_impl.mark = mark;
|
|
|
|
wuffs_base__empty_struct ret;
|
|
ret.private_impl = 0;
|
|
return ret;
|
|
}
|
|
|
|
static inline wuffs_base__slice_u8 //
|
|
wuffs_base__io_reader__take(uint8_t** ptr_iop_r, uint8_t* io1_r, uint64_t n) {
|
|
if (n <= ((size_t)(io1_r - *ptr_iop_r))) {
|
|
uint8_t* p = *ptr_iop_r;
|
|
*ptr_iop_r += n;
|
|
return wuffs_base__make_slice_u8(p, n);
|
|
}
|
|
return wuffs_base__make_slice_u8(NULL, 0);
|
|
}
|
|
|
|
static inline wuffs_base__empty_struct //
|
|
wuffs_base__io_writer__set(wuffs_base__io_writer* o,
|
|
wuffs_base__io_buffer* b,
|
|
uint8_t** ptr_iop_w,
|
|
uint8_t** ptr_io1_w,
|
|
wuffs_base__slice_u8 data) {
|
|
b->data = data;
|
|
b->meta.wi = 0;
|
|
b->meta.ri = 0;
|
|
b->meta.pos = 0;
|
|
b->meta.closed = false;
|
|
|
|
o->private_impl.buf = b;
|
|
o->private_impl.mark = data.ptr;
|
|
o->private_impl.limit = data.ptr + data.len;
|
|
*ptr_iop_w = data.ptr;
|
|
*ptr_io1_w = data.ptr + data.len;
|
|
|
|
wuffs_base__empty_struct ret;
|
|
ret.private_impl = 0;
|
|
return ret;
|
|
}
|
|
|
|
static inline wuffs_base__empty_struct //
|
|
wuffs_base__io_writer__set_mark(wuffs_base__io_writer* o, uint8_t* mark) {
|
|
o->private_impl.mark = mark;
|
|
|
|
wuffs_base__empty_struct ret;
|
|
ret.private_impl = 0;
|
|
return ret;
|
|
}
|
|
|
|
// ---------------- I/O (Utility)
|
|
|
|
#define wuffs_base__utility__null_io_reader wuffs_base__null_io_reader
|
|
#define wuffs_base__utility__null_io_writer wuffs_base__null_io_writer
|