internal/cgen/base/io-private.h - third_party/wuffs - Git at Google

 // 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
	// 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